/*
* 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.server.search;
import android.app.AppGlobals;
import android.app.SearchManager;
import android.app.SearchableInfo;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.pm.ActivityInfo;
import android.content.pm.ApplicationInfo;
import android.content.pm.IPackageManager;
import android.content.pm.PackageManager;
import android.content.pm.PackageManagerInternal;
import android.content.pm.ResolveInfo;
import android.os.Binder;
import android.os.Bundle;
import android.os.RemoteException;
import android.os.UserHandle;
import android.provider.Settings;
import android.text.TextUtils;
import android.util.Log;
import com.android.server.LocalServices;
import java.io.FileDescriptor;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
/**
* This class maintains the information about all searchable activities.
* This is a hidden class.
*/
public class Searchables {
private static final String LOG_TAG = "Searchables";
// static strings used for XML lookups, etc.
// TODO how should these be documented for the developer, in a more structured way than
// the current long wordy javadoc in SearchManager.java ?
private static final String MD_LABEL_DEFAULT_SEARCHABLE = "android.app.default_searchable";
private static final String MD_SEARCHABLE_SYSTEM_SEARCH = "*";
private Context mContext;
private HashMap<ComponentName, SearchableInfo> mSearchablesMap = null;
private ArrayList<SearchableInfo> mSearchablesList = null;
private ArrayList<SearchableInfo> mSearchablesInGlobalSearchList = null;
// Contains all installed activities that handle the global search
// intent.
private List<ResolveInfo> mGlobalSearchActivities;
private ComponentName mCurrentGlobalSearchActivity = null;
private ComponentName mWebSearchActivity = null;
public static String GOOGLE_SEARCH_COMPONENT_NAME =
"com.android.googlesearch/.GoogleSearch";
public static String ENHANCED_GOOGLE_SEARCH_COMPONENT_NAME =
"com.google.android.providers.enhancedgooglesearch/.Launcher";
// Cache the package manager instance
final private IPackageManager mPm;
// User for which this Searchables caches information
private int mUserId;
/**
*
* @param context Context to use for looking up activities etc.
*/
public Searchables (Context context, int userId) {
mContext = context;
mUserId = userId;
mPm = AppGlobals.getPackageManager();
}
/**
* Look up, or construct, based on the activity.
*
* The activities fall into three cases, based on meta-data found in
* the manifest entry:
* <ol>
* <li>The activity itself implements search. This is indicated by the
* presence of a "android.app.searchable" meta-data attribute.
* The value is a reference to an XML file containing search information.</li>
* <li>A related activity implements search. This is indicated by the
* presence of a "android.app.default_searchable" meta-data attribute.
* The value is a string naming the activity implementing search. In this
* case the factory will "redirect" and return the searchable data.</li>
* <li>No searchability data is provided. We return null here and other
* code will insert the "default" (e.g. contacts) search.
*
* TODO: cache the result in the map, and check the map first.
* TODO: it might make sense to implement the searchable reference as
* an application meta-data entry. This way we don't have to pepper each
* and every activity.
* TODO: can we skip the constructor step if it's a non-searchable?
* TODO: does it make sense to plug the default into a slot here for
* automatic return? Probably not, but it's one way to do it.
*
* @param activity The name of the current activity, or null if the
* activity does not define any explicit searchable metadata.
*/
public SearchableInfo getSearchableInfo(ComponentName activity) {
// Step 1. Is the result already hashed? (case 1)
SearchableInfo result;
synchronized (this) {
result = mSearchablesMap.get(activity);
if (result != null) {
final PackageManagerInternal pm =
LocalServices.getService(PackageManagerInternal.class);
if (pm.canAccessComponent(Binder.getCallingUid(), result.getSearchActivity(),
UserHandle.getCallingUserId())) {
return result;
}
return null;
}
}
// Step 2. See if the current activity references a searchable.
// Note: Conceptually, this could be a while(true) loop, but there's
// no point in implementing reference chaining here and risking a loop.
// References must point directly to searchable activities.
ActivityInfo ai = null;
try {
ai = mPm.getActivityInfo(activity, PackageManager.GET_META_DATA, mUserId);
} catch (RemoteException re) {
Log.e(LOG_TAG, "Error getting activity info " + re);
return null;
}
String refActivityName = null;
// First look for activity-specific reference
Bundle md = ai.metaData;
if (md != null) {
refActivityName = md.getString(MD_LABEL_DEFAULT_SEARCHABLE);
}
// If not found, try for app-wide reference
if (refActivityName == null) {
md = ai.applicationInfo.metaData;
if (md != null) {
refActivityName = md.getString(MD_LABEL_DEFAULT_SEARCHABLE);
}
}
// Irrespective of source, if a reference was found, follow it.
if (refActivityName != null)
{
// This value is deprecated, return null
if (refActivityName.equals(MD_SEARCHABLE_SYSTEM_SEARCH)) {
return null;
}
String pkg = activity.getPackageName();
ComponentName referredActivity;
if (refActivityName.charAt(0) == '.') {
referredActivity = new ComponentName(pkg, pkg + refActivityName);
} else {
referredActivity = new ComponentName(pkg, refActivityName);
}
// Now try the referred activity, and if found, cache
// it against the original name so we can skip the check
synchronized (this) {
result = mSearchablesMap.get(referredActivity);
if (result != null) {
mSearchablesMap.put(activity, result);
}
}
if (result != null) {
final PackageManagerInternal pm =
LocalServices.getService(PackageManagerInternal.class);
if (pm.canAccessComponent(Binder.getCallingUid(), result.getSearchActivity(),
UserHandle.getCallingUserId())) {
return result;
}
return null;
}
}
// Step 3. None found. Return null.
return null;
}
/**
* Builds an entire list (suitable for display) of
* activities that are searchable, by iterating the entire set of
* ACTION_SEARCH & ACTION_WEB_SEARCH intents.
*
* Also clears the hash of all activities -> searches which will
* refill as the user clicks "search".
*
* This should only be done at startup and again if we know that the
* list has changed.
*
* TODO: every activity that provides a ACTION_SEARCH intent should
* also provide searchability meta-data. There are a bunch of checks here
* that, if data is not found, silently skip to the next activity. This
* won't help a developer trying to figure out why their activity isn't
* showing up in the list, but an exception here is too rough. I would
* like to find a better notification mechanism.
*
* TODO: sort the list somehow? UI choice.
*/
public void updateSearchableList() {
// These will become the new values at the end of the method
HashMap<ComponentName, SearchableInfo> newSearchablesMap
= new HashMap<ComponentName, SearchableInfo>();
ArrayList<SearchableInfo> newSearchablesList
= new ArrayList<SearchableInfo>();
ArrayList<SearchableInfo> newSearchablesInGlobalSearchList
= new ArrayList<SearchableInfo>();
// Use intent resolver to generate list of ACTION_SEARCH & ACTION_WEB_SEARCH receivers.
List<ResolveInfo> searchList;
final Intent intent = new Intent(Intent.ACTION_SEARCH);
long ident = Binder.clearCallingIdentity();
try {
searchList = queryIntentActivities(intent,
PackageManager.GET_META_DATA | PackageManager.MATCH_DEBUG_TRIAGED_MISSING);
List<ResolveInfo> webSearchInfoList;
final Intent webSearchIntent = new Intent(Intent.ACTION_WEB_SEARCH);
webSearchInfoList = queryIntentActivities(webSearchIntent,
PackageManager.GET_META_DATA | PackageManager.MATCH_DEBUG_TRIAGED_MISSING);
// analyze each one, generate a Searchables record, and record
if (searchList != null || webSearchInfoList != null) {
int search_count = (searchList == null ? 0 : searchList.size());
int web_search_count = (webSearchInfoList == null ? 0 : webSearchInfoList.size());
int count = search_count + web_search_count;
for (int ii = 0; ii < count; ii++) {
// for each component, try to find metadata
ResolveInfo info = (ii < search_count)
? searchList.get(ii)
: webSearchInfoList.get(ii - search_count);
ActivityInfo ai = info.activityInfo;
// Check first to avoid duplicate entries.
if (newSearchablesMap.get(new ComponentName(ai.packageName, ai.name)) == null) {
SearchableInfo searchable = SearchableInfo.getActivityMetaData(mContext, ai,
mUserId);
if (searchable != null) {
newSearchablesList.add(searchable);
newSearchablesMap.put(searchable.getSearchActivity(), searchable);
if (searchable.shouldIncludeInGlobalSearch()) {
newSearchablesInGlobalSearchList.add(searchable);
}
}
}
}
}
List<ResolveInfo> newGlobalSearchActivities = findGlobalSearchActivities();
// Find the global search activity
ComponentName newGlobalSearchActivity = findGlobalSearchActivity(
newGlobalSearchActivities);
// Find the web search activity
ComponentName newWebSearchActivity = findWebSearchActivity(newGlobalSearchActivity);
// Store a consistent set of new values
synchronized (this) {
mSearchablesMap = newSearchablesMap;
mSearchablesList = newSearchablesList;
mSearchablesInGlobalSearchList = newSearchablesInGlobalSearchList;
mGlobalSearchActivities = newGlobalSearchActivities;
mCurrentGlobalSearchActivity = newGlobalSearchActivity;
mWebSearchActivity = newWebSearchActivity;
}
} finally {
Binder.restoreCallingIdentity(ident);
}
}
/**
* Returns a sorted list of installed search providers as per
* the following heuristics:
*
* (a) System apps are given priority over non system apps.
* (b) Among system apps and non system apps, the relative ordering
* is defined by their declared priority.
*/
private List<ResolveInfo> findGlobalSearchActivities() {
// Step 1 : Query the package manager for a list
// of activities that can handle the GLOBAL_SEARCH intent.
Intent intent = new Intent(SearchManager.INTENT_ACTION_GLOBAL_SEARCH);
List<ResolveInfo> activities = queryIntentActivities(intent,
PackageManager.MATCH_DEFAULT_ONLY | PackageManager.MATCH_DEBUG_TRIAGED_MISSING);
if (activities != null && !activities.isEmpty()) {
// Step 2: Rank matching activities according to our heuristics.
Collections.sort(activities, GLOBAL_SEARCH_RANKER);
}
return activities;
}
/**
* Finds the global search activity.
*/
private ComponentName findGlobalSearchActivity(List<ResolveInfo> installed) {
// Fetch the global search provider from the system settings,
// and if it's still installed, return it.
final String searchProviderSetting = getGlobalSearchProviderSetting();
if (!TextUtils.isEmpty(searchProviderSetting)) {
final ComponentName globalSearchComponent = ComponentName.unflattenFromString(
searchProviderSetting);
if (globalSearchComponent != null && isInstalled(globalSearchComponent)) {
return globalSearchComponent;
}
}
return getDefaultGlobalSearchProvider(installed);
}
/**
* Checks whether the global search provider with a given
* component name is installed on the system or not. This deals with
* cases such as the removal of an installed provider.
*/
private boolean isInstalled(ComponentName globalSearch) {
Intent intent = new Intent(SearchManager.INTENT_ACTION_GLOBAL_SEARCH);
intent.setComponent(globalSearch);
List<ResolveInfo> activities = queryIntentActivities(intent,
PackageManager.MATCH_DEFAULT_ONLY);
if (activities != null && !activities.isEmpty()) {
return true;
}
return false;
}
private static final Comparator<ResolveInfo> GLOBAL_SEARCH_RANKER =
new Comparator<ResolveInfo>() {
@Override
public int compare(ResolveInfo lhs, ResolveInfo rhs) {
if (lhs == rhs) {
return 0;
}
boolean lhsSystem = isSystemApp(lhs);
boolean rhsSystem = isSystemApp(rhs);
if (lhsSystem && !rhsSystem) {
return -1;
} else if (rhsSystem && !lhsSystem) {
return 1;
} else {
// Either both system engines, or both non system
// engines.
//
// Note, this isn't a typo. Higher priority numbers imply
// higher priority, but are "lower" in the sort order.
return rhs.priority - lhs.priority;
}
}
};
/**
* @return true iff. the resolve info corresponds to a system application.
*/
private static final boolean isSystemApp(ResolveInfo res) {
return (res.activityInfo.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM) != 0;
}
/**
* Returns the highest ranked search provider as per the
* ranking defined in {@link #getGlobalSearchActivities()}.
*/
private ComponentName getDefaultGlobalSearchProvider(List<ResolveInfo> providerList) {
if (providerList != null && !providerList.isEmpty()) {
ActivityInfo ai = providerList.get(0).activityInfo;
return new ComponentName(ai.packageName, ai.name);
}
Log.w(LOG_TAG, "No global search activity found");
return null;
}
private String getGlobalSearchProviderSetting() {
return Settings.Secure.getString(mContext.getContentResolver(),
Settings.Secure.SEARCH_GLOBAL_SEARCH_ACTIVITY);
}
/**
* Finds the web search activity.
*
* Only looks in the package of the global search activity.
*/
private ComponentName findWebSearchActivity(ComponentName globalSearchActivity) {
if (globalSearchActivity == null) {
return null;
}
Intent intent = new Intent(Intent.ACTION_WEB_SEARCH);
intent.setPackage(globalSearchActivity.getPackageName());
List<ResolveInfo> activities =
queryIntentActivities(intent, PackageManager.MATCH_DEFAULT_ONLY);
if (activities != null && !activities.isEmpty()) {
ActivityInfo ai = activities.get(0).activityInfo;
// TODO: do some sanity checks here?
return new ComponentName(ai.packageName, ai.name);
}
Log.w(LOG_TAG, "No web search activity found");
return null;
}
private List<ResolveInfo> queryIntentActivities(Intent intent, int flags) {
List<ResolveInfo> activities = null;
try {
activities =
mPm.queryIntentActivities(intent,
intent.resolveTypeIfNeeded(mContext.getContentResolver()),
flags | PackageManager.MATCH_INSTANT, mUserId).getList();
} catch (RemoteException re) {
// Local call
}
return activities;
}
/**
* Returns the list of searchable activities.
*/
public synchronized ArrayList<SearchableInfo> getSearchablesList() {
return createFilterdSearchableInfoList(mSearchablesList);
}
/**
* Returns a list of the searchable activities that can be included in global search.
*/
public synchronized ArrayList<SearchableInfo> getSearchablesInGlobalSearchList() {
return createFilterdSearchableInfoList(mSearchablesInGlobalSearchList);
}
/**
* Returns a list of activities that handle the global search intent.
*/
public synchronized ArrayList<ResolveInfo> getGlobalSearchActivities() {
return createFilterdResolveInfoList(mGlobalSearchActivities);
}
private ArrayList<SearchableInfo> createFilterdSearchableInfoList(List<SearchableInfo> list) {
if (list == null) {
return null;
}
final ArrayList<SearchableInfo> resultList = new ArrayList<>(list.size());
final PackageManagerInternal pm = LocalServices.getService(PackageManagerInternal.class);
final int callingUid = Binder.getCallingUid();
final int callingUserId = UserHandle.getCallingUserId();
for (SearchableInfo info : list) {
if (pm.canAccessComponent(callingUid, info.getSearchActivity(), callingUserId)) {
resultList.add(info);
}
}
return resultList;
}
private ArrayList<ResolveInfo> createFilterdResolveInfoList(List<ResolveInfo> list) {
if (list == null) {
return null;
}
final ArrayList<ResolveInfo> resultList = new ArrayList<>(list.size());
final PackageManagerInternal pm = LocalServices.getService(PackageManagerInternal.class);
final int callingUid = Binder.getCallingUid();
final int callingUserId = UserHandle.getCallingUserId();
for (ResolveInfo info : list) {
if (pm.canAccessComponent(
callingUid, info.activityInfo.getComponentName(), callingUserId)) {
resultList.add(info);
}
}
return resultList;
}
/**
* Gets the name of the global search activity.
*/
public synchronized ComponentName getGlobalSearchActivity() {
final PackageManagerInternal pm = LocalServices.getService(PackageManagerInternal.class);
final int callingUid = Binder.getCallingUid();
final int callingUserId = UserHandle.getCallingUserId();
if (mCurrentGlobalSearchActivity != null
&& pm.canAccessComponent(callingUid, mCurrentGlobalSearchActivity, callingUserId)) {
return mCurrentGlobalSearchActivity;
}
return null;
}
/**
* Gets the name of the web search activity.
*/
public synchronized ComponentName getWebSearchActivity() {
final PackageManagerInternal pm = LocalServices.getService(PackageManagerInternal.class);
final int callingUid = Binder.getCallingUid();
final int callingUserId = UserHandle.getCallingUserId();
if (mWebSearchActivity != null
&& pm.canAccessComponent(callingUid, mWebSearchActivity, callingUserId)) {
return mWebSearchActivity;
}
return null;
}
void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
pw.println("Searchable authorities:");
synchronized (this) {
if (mSearchablesList != null) {
for (SearchableInfo info: mSearchablesList) {
pw.print(" "); pw.println(info.getSuggestAuthority());
}
}
}
}
}