src/com/android/quicksearchbox/SearchableSource.java - platform/packages/apps/QuickSearchBox - Git at Google

 /*
  * Copyright (C) 2009 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.quicksearchbox;

 import com.android.quicksearchbox.util.NamedTaskExecutor;
 import com.android.quicksearchbox.util.Util;

 import android.app.PendingIntent;
 import android.app.SearchManager;
 import android.app.SearchableInfo;
 import android.content.ComponentName;
 import android.content.ContentResolver;
 import android.content.Context;
 import android.content.Intent;
 import android.content.pm.ActivityInfo;
 import android.content.pm.PackageInfo;
 import android.content.pm.PackageManager;
 import android.content.pm.PackageManager.NameNotFoundException;
 import android.content.pm.PathPermission;
 import android.content.pm.ProviderInfo;
 import android.database.Cursor;
 import android.graphics.drawable.Drawable;
 import android.net.Uri;
 import android.os.Bundle;
 import android.os.Handler;
 import android.speech.RecognizerIntent;
 import android.util.Log;

 import java.util.Arrays;

 /**
  * Represents a single suggestion source, e.g. Contacts.
  */
 public class SearchableSource extends AbstractSource {

     private static final boolean DBG = false;
     private static final String TAG = "QSB.SearchableSource";

     // TODO: This should be exposed or moved to android-common, see http://b/issue?id=2440614
     // The extra key used in an intent to the speech recognizer for in-app voice search.
     private static final String EXTRA_CALLING_PACKAGE = "calling_package";

     private final SearchableInfo mSearchable;

     private final String mName;

     private final ActivityInfo mActivityInfo;

     private final int mVersionCode;

     // Cached label for the activity
     private CharSequence mLabel = null;

     // Cached icon for the activity
     private Drawable.ConstantState mSourceIcon = null;

     private Uri mSuggestUriBase;

     public SearchableSource(Context context, SearchableInfo searchable, Handler uiThread,
             NamedTaskExecutor iconLoader) throws NameNotFoundException {
         super(context, uiThread, iconLoader);
         ComponentName componentName = searchable.getSearchActivity();
         if (DBG) Log.d(TAG, "created Searchable for " + componentName);
         mSearchable = searchable;
         mName = componentName.flattenToShortString();
         PackageManager pm = context.getPackageManager();
         mActivityInfo = pm.getActivityInfo(componentName, 0);
         PackageInfo pkgInfo = pm.getPackageInfo(componentName.getPackageName(), 0);
         mVersionCode = pkgInfo.versionCode;
     }

     public SearchableInfo getSearchableInfo() {
         return mSearchable;
     }

     /**
      * Checks if the current process can read the suggestion provider in this source.
      */
     public boolean canRead() {
         String authority = mSearchable.getSuggestAuthority();
         if (authority == null) {
             // TODO: maybe we should have a way to distinguish between having suggestions
             // and being readable.
             return true;
         }

         Uri.Builder uriBuilder = new Uri.Builder()
                 .scheme(ContentResolver.SCHEME_CONTENT)
                 .authority(authority);
         // if content path provided, insert it now
         String contentPath = mSearchable.getSuggestPath();
         if (contentPath != null) {
             uriBuilder.appendEncodedPath(contentPath);
         }
         // append standard suggestion query path
         uriBuilder.appendEncodedPath(SearchManager.SUGGEST_URI_PATH_QUERY);
         Uri uri = uriBuilder.build();
         return canRead(uri);
     }

     /**
      * Checks if the current process can read the given content URI.
      *
      * TODO: Shouldn't this be a PackageManager / Context / ContentResolver method?
      */
     private boolean canRead(Uri uri) {
         ProviderInfo provider = getContext().getPackageManager().resolveContentProvider(
                 uri.getAuthority(), 0);
         if (provider == null) {
             Log.w(TAG, getName() + " has bad suggestion authority " + uri.getAuthority());
             return false;
         }
         String readPermission = provider.readPermission;
         if (readPermission == null) {
             // No permission required to read anything in the content provider
             return true;
         }
         int pid = android.os.Process.myPid();
         int uid = android.os.Process.myUid();
         if (getContext().checkPermission(readPermission, pid, uid)
                 == PackageManager.PERMISSION_GRANTED) {
             // We have permission to read everything in the content provider
             return true;
         }
         PathPermission[] pathPermissions = provider.pathPermissions;
         if (pathPermissions == null || pathPermissions.length == 0) {
             // We don't have the readPermission, and there are no pathPermissions
             if (DBG) Log.d(TAG, "Missing " + readPermission);
             return false;
         }
         String path = uri.getPath();
         for (PathPermission perm : pathPermissions) {
             String pathReadPermission = perm.getReadPermission();
             if (pathReadPermission != null
                     && perm.match(path)
                     && getContext().checkPermission(pathReadPermission, pid, uid)
                             == PackageManager.PERMISSION_GRANTED) {
                 // We have the path permission
                 return true;
             }
         }
         if (DBG) Log.d(TAG, "Missing " + readPermission + " and no path permission applies");
         return false;
     }

     public ComponentName getIntentComponent() {
         return mSearchable.getSearchActivity();
     }

     public int getVersionCode() {
         return mVersionCode;
     }

     public String getName() {
         return mName;
     }

     @Override
     protected String getIconPackage() {
         // Get icons from the package containing the suggestion provider, if any
         String iconPackage = mSearchable.getSuggestPackage();
         if (iconPackage != null) {
             return iconPackage;
         } else {
             // Fall back to the package containing the searchable activity
             return mSearchable.getSearchActivity().getPackageName();
         }
     }

     public CharSequence getLabel() {
         if (mLabel == null) {
             // Load label lazily
             mLabel = mActivityInfo.loadLabel(getContext().getPackageManager());
         }
         return mLabel;
     }

     public CharSequence getHint() {
         return getText(mSearchable.getHintId());
     }

     public int getQueryThreshold() {
         return mSearchable.getSuggestThreshold();
     }

     public CharSequence getSettingsDescription() {
         return getText(mSearchable.getSettingsDescriptionId());
     }

     public Drawable getSourceIcon() {
         if (mSourceIcon == null) {
             Drawable icon = loadSourceIcon();
             if (icon == null) {
                 icon = getContext().getResources().getDrawable(R.drawable.corpus_icon_default);
             }
             // Can't share Drawable instances, save constant state instead.
             mSourceIcon = (icon != null) ? icon.getConstantState() : null;
             // Optimization, return the Drawable the first time
             return icon;
         }
         return (mSourceIcon != null) ? mSourceIcon.newDrawable() : null;
     }

     private Drawable loadSourceIcon() {
         int iconRes = getSourceIconResource();
         if (iconRes == 0) return null;
         PackageManager pm = getContext().getPackageManager();
         return pm.getDrawable(mActivityInfo.packageName, iconRes,
                 mActivityInfo.applicationInfo);
     }

     public Uri getSourceIconUri() {
         int resourceId = getSourceIconResource();
         if (resourceId == 0) {
             return Util.getResourceUri(getContext(), R.drawable.corpus_icon_default);
         } else {
             return Util.getResourceUri(getContext(), mActivityInfo.applicationInfo, resourceId);
         }
     }

     private int getSourceIconResource() {
         return mActivityInfo.getIconResource();
     }

     public boolean voiceSearchEnabled() {
         return mSearchable.getVoiceSearchEnabled();
     }

     public Intent createVoiceSearchIntent(Bundle appData) {
         if (mSearchable.getVoiceSearchLaunchWebSearch()) {
             return createVoiceWebSearchIntent(appData);
         } else if (mSearchable.getVoiceSearchLaunchRecognizer()) {
             return createVoiceAppSearchIntent(appData);
         }
         return null;
     }

     /**
      * Create and return an Intent that can launch the voice search activity, perform a specific
      * voice transcription, and forward the results to the searchable activity.
      *
      * This code is copied from SearchDialog
      *
      * @return A completely-configured intent ready to send to the voice search activity
      */
     private Intent createVoiceAppSearchIntent(Bundle appData) {
         ComponentName searchActivity = mSearchable.getSearchActivity();

         // create the necessary intent to set up a search-and-forward operation
         // in the voice search system.   We have to keep the bundle separate,
         // because it becomes immutable once it enters the PendingIntent
         Intent queryIntent = new Intent(Intent.ACTION_SEARCH);
         queryIntent.setComponent(searchActivity);
         PendingIntent pending = PendingIntent.getActivity(
                 getContext(), 0, queryIntent, PendingIntent.FLAG_ONE_SHOT);

         // Now set up the bundle that will be inserted into the pending intent
         // when it's time to do the search.  We always build it here (even if empty)
         // because the voice search activity will always need to insert "QUERY" into
         // it anyway.
         Bundle queryExtras = new Bundle();
         if (appData != null) {
             queryExtras.putBundle(SearchManager.APP_DATA, appData);
         }

         // Now build the intent to launch the voice search.  Add all necessary
         // extras to launch the voice recognizer, and then all the necessary extras
         // to forward the results to the searchable activity
         Intent voiceIntent = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH);
         voiceIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

         // Add all of the configuration options supplied by the searchable's metadata
         String languageModel = getString(mSearchable.getVoiceLanguageModeId());
         if (languageModel == null) {
             languageModel = RecognizerIntent.LANGUAGE_MODEL_FREE_FORM;
         }
         String prompt = getString(mSearchable.getVoicePromptTextId());
         String language = getString(mSearchable.getVoiceLanguageId());
         int maxResults = mSearchable.getVoiceMaxResults();
         if (maxResults <= 0) {
             maxResults = 1;
         }

         voiceIntent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL, languageModel);
         voiceIntent.putExtra(RecognizerIntent.EXTRA_PROMPT, prompt);
         voiceIntent.putExtra(RecognizerIntent.EXTRA_LANGUAGE, language);
         voiceIntent.putExtra(RecognizerIntent.EXTRA_MAX_RESULTS, maxResults);
         voiceIntent.putExtra(EXTRA_CALLING_PACKAGE,
                 searchActivity == null ? null : searchActivity.toShortString());

         // Add the values that configure forwarding the results
         voiceIntent.putExtra(RecognizerIntent.EXTRA_RESULTS_PENDINGINTENT, pending);
         voiceIntent.putExtra(RecognizerIntent.EXTRA_RESULTS_PENDINGINTENT_BUNDLE, queryExtras);

         return voiceIntent;
     }

     public SourceResult getSuggestions(String query, int queryLimit, boolean onlySource) {
         try {
             Cursor cursor = getSuggestions(getContext(), mSearchable, query, queryLimit);
             if (DBG) Log.d(TAG, toString() + "[" + query + "] returned.");
             return new CursorBackedSourceResult(this, query, cursor);
         } catch (RuntimeException ex) {
             Log.e(TAG, toString() + "[" + query + "] failed", ex);
             return new CursorBackedSourceResult(this, query);
         }
     }

     public SuggestionCursor refreshShortcut(String shortcutId, String extraData) {
         Cursor cursor = null;
         try {
             cursor = getValidationCursor(getContext(), mSearchable, shortcutId, extraData);
             if (DBG) Log.d(TAG, toString() + "[" + shortcutId + "] returned.");
             if (cursor != null && cursor.getCount() > 0) {
                 cursor.moveToFirst();
             }
             return new CursorBackedSourceResult(this, null, cursor);
         } catch (RuntimeException ex) {
             Log.e(TAG, toString() + "[" + shortcutId + "] failed", ex);
             if (cursor != null) {
                 cursor.close();
             }
             // TODO: Should we delete the shortcut even if the failure is temporary?
             return null;
         }
     }

     public String getSuggestUri() {
         Uri uri = getSuggestUriBase(mSearchable);
         if (uri == null) return null;
         return uri.toString();
     }

     private synchronized Uri getSuggestUriBase(SearchableInfo searchable) {
         if (searchable == null) {
             return null;
         }
         if (mSuggestUriBase == null) {

             String authority = searchable.getSuggestAuthority();
             if (authority == null) {
                 return null;
             }

             Uri.Builder uriBuilder = new Uri.Builder()
                     .scheme(ContentResolver.SCHEME_CONTENT)
                     .authority(authority);

             // if content path provided, insert it now
             final String contentPath = searchable.getSuggestPath();
             if (contentPath != null) {
                 uriBuilder.appendEncodedPath(contentPath);
             }

             // append standard suggestion query path
             uriBuilder.appendPath(SearchManager.SUGGEST_URI_PATH_QUERY);
             mSuggestUriBase = uriBuilder.build();
         }
         return mSuggestUriBase;
     }

     /**
      * This is a copy of {@link SearchManager#getSuggestions(SearchableInfo, String)}.
      */
     private Cursor getSuggestions(Context context, SearchableInfo searchable, String query,
             int queryLimit) {

         Uri base = getSuggestUriBase(searchable);
         if (base == null) return null;
         Uri.Builder uriBuilder = base.buildUpon();

         // get the query selection, may be null
         String selection = searchable.getSuggestSelection();
         // inject query, either as selection args or inline
         String[] selArgs = null;
         if (selection != null) {    // use selection if provided
             selArgs = new String[] { query };
         } else {                    // no selection, use REST pattern
             uriBuilder.appendPath(query);
         }

         uriBuilder.appendQueryParameter("limit", String.valueOf(queryLimit));

         Uri uri = uriBuilder.build();

         // finally, make the query
         if (DBG) {
             Log.d(TAG, "query(" + uri + ",null," + selection + ","
                     + Arrays.toString(selArgs) + ",null)");
         }
         Cursor c = context.getContentResolver().query(uri, null, selection, selArgs, null);
         if (DBG) Log.d(TAG, "Got cursor from " + mName + ": " + c);
         return c;
     }

     private static Cursor getValidationCursor(Context context, SearchableInfo searchable,
             String shortcutId, String extraData) {
         String authority = searchable.getSuggestAuthority();
         if (authority == null) {
             return null;
         }

         Uri.Builder uriBuilder = new Uri.Builder()
                 .scheme(ContentResolver.SCHEME_CONTENT)
                 .authority(authority);

         // if content path provided, insert it now
         final String contentPath = searchable.getSuggestPath();
         if (contentPath != null) {
             uriBuilder.appendEncodedPath(contentPath);
         }

         // append the shortcut path and id
         uriBuilder.appendPath(SearchManager.SUGGEST_URI_PATH_SHORTCUT);
         uriBuilder.appendPath(shortcutId);

         Uri uri = uriBuilder
                 .appendQueryParameter(SearchManager.SUGGEST_COLUMN_INTENT_EXTRA_DATA, extraData)
                 .build();

         if (DBG) Log.d(TAG, "Requesting refresh " + uri);
         // finally, make the query
         return context.getContentResolver().query(uri, null, null, null, null);
     }

     public int getMaxShortcuts(Config config) {
         return config.getMaxShortcuts(getName());
     }

     public boolean includeInAll() {
         return true;
     }

     public boolean queryAfterZeroResults() {
         return mSearchable.queryAfterZeroResults();
     }

     public String getDefaultIntentAction() {
         String action = mSearchable.getSuggestIntentAction();
         if (action != null) return action;
         return Intent.ACTION_SEARCH;
     }

     public String getDefaultIntentData() {
         return mSearchable.getSuggestIntentData();
     }

     private CharSequence getText(int id) {
         if (id == 0) return null;
         return getContext().getPackageManager().getText(mActivityInfo.packageName, id,
                 mActivityInfo.applicationInfo);
     }

     private String getString(int id) {
         CharSequence text = getText(id);
         return text == null ? null : text.toString();
     }
 }
	/*
	* Copyright (C) 2009 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.quicksearchbox;

	import com.android.quicksearchbox.util.NamedTaskExecutor;
	import com.android.quicksearchbox.util.Util;

	import android.app.PendingIntent;
	import android.app.SearchManager;
	import android.app.SearchableInfo;
	import android.content.ComponentName;
	import android.content.ContentResolver;
	import android.content.Context;
	import android.content.Intent;
	import android.content.pm.ActivityInfo;
	import android.content.pm.PackageInfo;
	import android.content.pm.PackageManager;
	import android.content.pm.PackageManager.NameNotFoundException;
	import android.content.pm.PathPermission;
	import android.content.pm.ProviderInfo;
	import android.database.Cursor;
	import android.graphics.drawable.Drawable;
	import android.net.Uri;
	import android.os.Bundle;
	import android.os.Handler;
	import android.speech.RecognizerIntent;
	import android.util.Log;

	import java.util.Arrays;

	/**
	* Represents a single suggestion source, e.g. Contacts.
	*/
	public class SearchableSource extends AbstractSource {

	private static final boolean DBG = false;
	private static final String TAG = "QSB.SearchableSource";

	// TODO: This should be exposed or moved to android-common, see http://b/issue?id=2440614
	// The extra key used in an intent to the speech recognizer for in-app voice search.
	private static final String EXTRA_CALLING_PACKAGE = "calling_package";

	private final SearchableInfo mSearchable;

	private final String mName;

	private final ActivityInfo mActivityInfo;

	private final int mVersionCode;

	// Cached label for the activity
	private CharSequence mLabel = null;

	// Cached icon for the activity
	private Drawable.ConstantState mSourceIcon = null;

	private Uri mSuggestUriBase;

	public SearchableSource(Context context, SearchableInfo searchable, Handler uiThread,
	NamedTaskExecutor iconLoader) throws NameNotFoundException {
	super(context, uiThread, iconLoader);
	ComponentName componentName = searchable.getSearchActivity();
	if (DBG) Log.d(TAG, "created Searchable for " + componentName);
	mSearchable = searchable;
	mName = componentName.flattenToShortString();
	PackageManager pm = context.getPackageManager();
	mActivityInfo = pm.getActivityInfo(componentName, 0);
	PackageInfo pkgInfo = pm.getPackageInfo(componentName.getPackageName(), 0);
	mVersionCode = pkgInfo.versionCode;
	}

	public SearchableInfo getSearchableInfo() {
	return mSearchable;
	}

	/**
	* Checks if the current process can read the suggestion provider in this source.
	*/
	public boolean canRead() {
	String authority = mSearchable.getSuggestAuthority();
	if (authority == null) {
	// TODO: maybe we should have a way to distinguish between having suggestions
	// and being readable.
	return true;
	}

	Uri.Builder uriBuilder = new Uri.Builder()
	.scheme(ContentResolver.SCHEME_CONTENT)
	.authority(authority);
	// if content path provided, insert it now
	String contentPath = mSearchable.getSuggestPath();
	if (contentPath != null) {
	uriBuilder.appendEncodedPath(contentPath);
	}
	// append standard suggestion query path
	uriBuilder.appendEncodedPath(SearchManager.SUGGEST_URI_PATH_QUERY);
	Uri uri = uriBuilder.build();
	return canRead(uri);
	}

	/**
	* Checks if the current process can read the given content URI.
	*
	* TODO: Shouldn't this be a PackageManager / Context / ContentResolver method?
	*/
	private boolean canRead(Uri uri) {
	ProviderInfo provider = getContext().getPackageManager().resolveContentProvider(
	uri.getAuthority(), 0);
	if (provider == null) {
	Log.w(TAG, getName() + " has bad suggestion authority " + uri.getAuthority());
	return false;
	}
	String readPermission = provider.readPermission;
	if (readPermission == null) {
	// No permission required to read anything in the content provider
	return true;
	}
	int pid = android.os.Process.myPid();
	int uid = android.os.Process.myUid();
	if (getContext().checkPermission(readPermission, pid, uid)
	== PackageManager.PERMISSION_GRANTED) {
	// We have permission to read everything in the content provider
	return true;
	}
	PathPermission[] pathPermissions = provider.pathPermissions;
	if (pathPermissions == null \|\| pathPermissions.length == 0) {
	// We don't have the readPermission, and there are no pathPermissions
	if (DBG) Log.d(TAG, "Missing " + readPermission);
	return false;
	}
	String path = uri.getPath();
	for (PathPermission perm : pathPermissions) {
	String pathReadPermission = perm.getReadPermission();
	if (pathReadPermission != null
	&& perm.match(path)
	&& getContext().checkPermission(pathReadPermission, pid, uid)
	== PackageManager.PERMISSION_GRANTED) {
	// We have the path permission
	return true;
	}
	}
	if (DBG) Log.d(TAG, "Missing " + readPermission + " and no path permission applies");
	return false;
	}

	public ComponentName getIntentComponent() {
	return mSearchable.getSearchActivity();
	}

	public int getVersionCode() {
	return mVersionCode;
	}

	public String getName() {
	return mName;
	}

	@Override
	protected String getIconPackage() {
	// Get icons from the package containing the suggestion provider, if any
	String iconPackage = mSearchable.getSuggestPackage();
	if (iconPackage != null) {
	return iconPackage;
	} else {
	// Fall back to the package containing the searchable activity
	return mSearchable.getSearchActivity().getPackageName();
	}
	}

	public CharSequence getLabel() {
	if (mLabel == null) {
	// Load label lazily
	mLabel = mActivityInfo.loadLabel(getContext().getPackageManager());
	}
	return mLabel;
	}

	public CharSequence getHint() {
	return getText(mSearchable.getHintId());
	}

	public int getQueryThreshold() {
	return mSearchable.getSuggestThreshold();
	}

	public CharSequence getSettingsDescription() {
	return getText(mSearchable.getSettingsDescriptionId());
	}

	public Drawable getSourceIcon() {
	if (mSourceIcon == null) {
	Drawable icon = loadSourceIcon();
	if (icon == null) {
	icon = getContext().getResources().getDrawable(R.drawable.corpus_icon_default);
	}
	// Can't share Drawable instances, save constant state instead.
	mSourceIcon = (icon != null) ? icon.getConstantState() : null;
	// Optimization, return the Drawable the first time
	return icon;
	}
	return (mSourceIcon != null) ? mSourceIcon.newDrawable() : null;
	}

	private Drawable loadSourceIcon() {
	int iconRes = getSourceIconResource();
	if (iconRes == 0) return null;
	PackageManager pm = getContext().getPackageManager();
	return pm.getDrawable(mActivityInfo.packageName, iconRes,
	mActivityInfo.applicationInfo);
	}

	public Uri getSourceIconUri() {
	int resourceId = getSourceIconResource();
	if (resourceId == 0) {
	return Util.getResourceUri(getContext(), R.drawable.corpus_icon_default);
	} else {
	return Util.getResourceUri(getContext(), mActivityInfo.applicationInfo, resourceId);
	}
	}

	private int getSourceIconResource() {
	return mActivityInfo.getIconResource();
	}

	public boolean voiceSearchEnabled() {
	return mSearchable.getVoiceSearchEnabled();
	}

	public Intent createVoiceSearchIntent(Bundle appData) {
	if (mSearchable.getVoiceSearchLaunchWebSearch()) {
	return createVoiceWebSearchIntent(appData);
	} else if (mSearchable.getVoiceSearchLaunchRecognizer()) {
	return createVoiceAppSearchIntent(appData);
	}
	return null;
	}

	/**
	* Create and return an Intent that can launch the voice search activity, perform a specific
	* voice transcription, and forward the results to the searchable activity.
	*
	* This code is copied from SearchDialog
	*
	* @return A completely-configured intent ready to send to the voice search activity
	*/
	private Intent createVoiceAppSearchIntent(Bundle appData) {
	ComponentName searchActivity = mSearchable.getSearchActivity();

	// create the necessary intent to set up a search-and-forward operation
	// in the voice search system. We have to keep the bundle separate,
	// because it becomes immutable once it enters the PendingIntent
	Intent queryIntent = new Intent(Intent.ACTION_SEARCH);
	queryIntent.setComponent(searchActivity);
	PendingIntent pending = PendingIntent.getActivity(
	getContext(), 0, queryIntent, PendingIntent.FLAG_ONE_SHOT);

	// Now set up the bundle that will be inserted into the pending intent
	// when it's time to do the search. We always build it here (even if empty)
	// because the voice search activity will always need to insert "QUERY" into
	// it anyway.
	Bundle queryExtras = new Bundle();
	if (appData != null) {
	queryExtras.putBundle(SearchManager.APP_DATA, appData);
	}

	// Now build the intent to launch the voice search. Add all necessary
	// extras to launch the voice recognizer, and then all the necessary extras
	// to forward the results to the searchable activity
	Intent voiceIntent = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH);
	voiceIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

	// Add all of the configuration options supplied by the searchable's metadata
	String languageModel = getString(mSearchable.getVoiceLanguageModeId());
	if (languageModel == null) {
	languageModel = RecognizerIntent.LANGUAGE_MODEL_FREE_FORM;
	}
	String prompt = getString(mSearchable.getVoicePromptTextId());
	String language = getString(mSearchable.getVoiceLanguageId());
	int maxResults = mSearchable.getVoiceMaxResults();
	if (maxResults <= 0) {
	maxResults = 1;
	}

	voiceIntent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL, languageModel);
	voiceIntent.putExtra(RecognizerIntent.EXTRA_PROMPT, prompt);
	voiceIntent.putExtra(RecognizerIntent.EXTRA_LANGUAGE, language);
	voiceIntent.putExtra(RecognizerIntent.EXTRA_MAX_RESULTS, maxResults);
	voiceIntent.putExtra(EXTRA_CALLING_PACKAGE,
	searchActivity == null ? null : searchActivity.toShortString());

	// Add the values that configure forwarding the results
	voiceIntent.putExtra(RecognizerIntent.EXTRA_RESULTS_PENDINGINTENT, pending);
	voiceIntent.putExtra(RecognizerIntent.EXTRA_RESULTS_PENDINGINTENT_BUNDLE, queryExtras);

	return voiceIntent;
	}

	public SourceResult getSuggestions(String query, int queryLimit, boolean onlySource) {
	try {
	Cursor cursor = getSuggestions(getContext(), mSearchable, query, queryLimit);
	if (DBG) Log.d(TAG, toString() + "[" + query + "] returned.");
	return new CursorBackedSourceResult(this, query, cursor);
	} catch (RuntimeException ex) {
	Log.e(TAG, toString() + "[" + query + "] failed", ex);
	return new CursorBackedSourceResult(this, query);
	}
	}

	public SuggestionCursor refreshShortcut(String shortcutId, String extraData) {
	Cursor cursor = null;
	try {
	cursor = getValidationCursor(getContext(), mSearchable, shortcutId, extraData);
	if (DBG) Log.d(TAG, toString() + "[" + shortcutId + "] returned.");
	if (cursor != null && cursor.getCount() > 0) {
	cursor.moveToFirst();
	}
	return new CursorBackedSourceResult(this, null, cursor);
	} catch (RuntimeException ex) {
	Log.e(TAG, toString() + "[" + shortcutId + "] failed", ex);
	if (cursor != null) {
	cursor.close();
	}
	// TODO: Should we delete the shortcut even if the failure is temporary?
	return null;
	}
	}

	public String getSuggestUri() {
	Uri uri = getSuggestUriBase(mSearchable);
	if (uri == null) return null;
	return uri.toString();
	}

	private synchronized Uri getSuggestUriBase(SearchableInfo searchable) {
	if (searchable == null) {
	return null;
	}
	if (mSuggestUriBase == null) {

	String authority = searchable.getSuggestAuthority();
	if (authority == null) {
	return null;
	}

	Uri.Builder uriBuilder = new Uri.Builder()
	.scheme(ContentResolver.SCHEME_CONTENT)
	.authority(authority);

	// if content path provided, insert it now
	final String contentPath = searchable.getSuggestPath();
	if (contentPath != null) {
	uriBuilder.appendEncodedPath(contentPath);
	}

	// append standard suggestion query path
	uriBuilder.appendPath(SearchManager.SUGGEST_URI_PATH_QUERY);
	mSuggestUriBase = uriBuilder.build();
	}
	return mSuggestUriBase;
	}

	/**
	* This is a copy of {@link SearchManager#getSuggestions(SearchableInfo, String)}.
	*/
	private Cursor getSuggestions(Context context, SearchableInfo searchable, String query,
	int queryLimit) {

	Uri base = getSuggestUriBase(searchable);
	if (base == null) return null;
	Uri.Builder uriBuilder = base.buildUpon();

	// get the query selection, may be null
	String selection = searchable.getSuggestSelection();
	// inject query, either as selection args or inline
	String[] selArgs = null;
	if (selection != null) { // use selection if provided
	selArgs = new String[] { query };
	} else { // no selection, use REST pattern
	uriBuilder.appendPath(query);
	}

	uriBuilder.appendQueryParameter("limit", String.valueOf(queryLimit));

	Uri uri = uriBuilder.build();

	// finally, make the query
	if (DBG) {
	Log.d(TAG, "query(" + uri + ",null," + selection + ","
	+ Arrays.toString(selArgs) + ",null)");
	}
	Cursor c = context.getContentResolver().query(uri, null, selection, selArgs, null);
	if (DBG) Log.d(TAG, "Got cursor from " + mName + ": " + c);
	return c;
	}

	private static Cursor getValidationCursor(Context context, SearchableInfo searchable,
	String shortcutId, String extraData) {
	String authority = searchable.getSuggestAuthority();
	if (authority == null) {
	return null;
	}

	Uri.Builder uriBuilder = new Uri.Builder()
	.scheme(ContentResolver.SCHEME_CONTENT)
	.authority(authority);

	// if content path provided, insert it now
	final String contentPath = searchable.getSuggestPath();
	if (contentPath != null) {
	uriBuilder.appendEncodedPath(contentPath);
	}

	// append the shortcut path and id
	uriBuilder.appendPath(SearchManager.SUGGEST_URI_PATH_SHORTCUT);
	uriBuilder.appendPath(shortcutId);

	Uri uri = uriBuilder
	.appendQueryParameter(SearchManager.SUGGEST_COLUMN_INTENT_EXTRA_DATA, extraData)
	.build();

	if (DBG) Log.d(TAG, "Requesting refresh " + uri);
	// finally, make the query
	return context.getContentResolver().query(uri, null, null, null, null);
	}

	public int getMaxShortcuts(Config config) {
	return config.getMaxShortcuts(getName());
	}

	public boolean includeInAll() {
	return true;
	}

	public boolean queryAfterZeroResults() {
	return mSearchable.queryAfterZeroResults();
	}

	public String getDefaultIntentAction() {
	String action = mSearchable.getSuggestIntentAction();
	if (action != null) return action;
	return Intent.ACTION_SEARCH;
	}

	public String getDefaultIntentData() {
	return mSearchable.getSuggestIntentData();
	}

	private CharSequence getText(int id) {
	if (id == 0) return null;
	return getContext().getPackageManager().getText(mActivityInfo.packageName, id,
	mActivityInfo.applicationInfo);
	}

	private String getString(int id) {
	CharSequence text = getText(id);
	return text == null ? null : text.toString();
	}
	}