| /* |
| * 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.providers.applications; |
| |
| import com.android.internal.content.PackageMonitor; |
| import com.android.internal.os.PkgUsageStats; |
| |
| import android.app.ActivityManager; |
| import android.app.AlarmManager; |
| import android.app.PendingIntent; |
| import android.app.SearchManager; |
| import android.content.BroadcastReceiver; |
| import android.content.ComponentName; |
| import android.content.ContentProvider; |
| import android.content.ContentResolver; |
| import android.content.ContentValues; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.content.IntentFilter; |
| import android.content.UriMatcher; |
| import android.content.pm.ActivityInfo; |
| import android.content.pm.ApplicationInfo; |
| import android.content.pm.PackageManager; |
| import android.content.pm.ResolveInfo; |
| import android.content.res.Resources; |
| import android.database.Cursor; |
| import android.database.DatabaseUtils; |
| import android.database.sqlite.SQLiteDatabase; |
| import android.database.sqlite.SQLiteQueryBuilder; |
| import android.net.Uri; |
| import android.os.Handler; |
| import android.os.HandlerThread; |
| import android.os.Looper; |
| import android.os.Message; |
| import android.provider.Applications; |
| import android.text.TextUtils; |
| import android.util.Log; |
| |
| import java.lang.Runnable; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| |
| import com.google.common.annotations.VisibleForTesting; |
| |
| /** |
| * Fetches the list of applications installed on the phone to provide search suggestions. |
| * If the functionality of this provider changes, the documentation at |
| * {@link android.provider.Applications} should be updated. |
| * |
| * TODO: this provider should be moved to the Launcher, which contains similar logic to keep an up |
| * to date list of installed applications. Alternatively, Launcher could be updated to use this |
| * provider. |
| */ |
| public class ApplicationsProvider extends ContentProvider { |
| |
| private static final boolean DBG = false; |
| |
| private static final String TAG = "ApplicationsProvider"; |
| |
| private static final int SEARCH_SUGGEST = 0; |
| private static final int SHORTCUT_REFRESH = 1; |
| private static final int SEARCH = 2; |
| |
| private static final UriMatcher sURIMatcher = buildUriMatcher(); |
| |
| private static final int THREAD_PRIORITY = android.os.Process.THREAD_PRIORITY_BACKGROUND; |
| |
| // Messages for mHandler |
| private static final int MSG_UPDATE_ALL = 0; |
| private static final int MSG_UPDATE_PACKAGE = 1; |
| |
| public static final String _ID = "_id"; |
| public static final String NAME = "name"; |
| public static final String DESCRIPTION = "description"; |
| public static final String PACKAGE = "package"; |
| public static final String CLASS = "class"; |
| public static final String ICON = "icon"; |
| public static final String LAUNCH_COUNT = "launch_count"; |
| public static final String LAST_RESUME_TIME = "last_resume_time"; |
| |
| // A query parameter to refresh application statistics. Used by QSB. |
| public static final String REFRESH_STATS = "refresh"; |
| |
| private static final String APPLICATIONS_TABLE = "applications"; |
| |
| private static final String APPLICATIONS_LOOKUP_JOIN = |
| "applicationsLookup JOIN " + APPLICATIONS_TABLE + " ON" |
| + " applicationsLookup.source = " + APPLICATIONS_TABLE + "." + _ID; |
| |
| private static final HashMap<String, String> sSearchSuggestionsProjectionMap = |
| buildSuggestionsProjectionMap(false); |
| private static final HashMap<String, String> sGlobalSearchSuggestionsProjectionMap = |
| buildSuggestionsProjectionMap(true); |
| private static final HashMap<String, String> sSearchProjectionMap = |
| buildSearchProjectionMap(); |
| |
| /** |
| * An in-memory database storing the details of applications installed on |
| * the device. Populated when the ApplicationsProvider is launched. |
| */ |
| private SQLiteDatabase mDb; |
| |
| // Handler that runs DB updates. |
| private Handler mHandler; |
| |
| /** |
| * We delay application updates by this many millis to avoid doing more than one update to the |
| * applications list within this window. |
| */ |
| private static final long UPDATE_DELAY_MILLIS = 1000L; |
| |
| private static UriMatcher buildUriMatcher() { |
| UriMatcher matcher = new UriMatcher(UriMatcher.NO_MATCH); |
| matcher.addURI(Applications.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY, |
| SEARCH_SUGGEST); |
| matcher.addURI(Applications.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY + "/*", |
| SEARCH_SUGGEST); |
| matcher.addURI(Applications.AUTHORITY, SearchManager.SUGGEST_URI_PATH_SHORTCUT, |
| SHORTCUT_REFRESH); |
| matcher.addURI(Applications.AUTHORITY, SearchManager.SUGGEST_URI_PATH_SHORTCUT + "/*", |
| SHORTCUT_REFRESH); |
| matcher.addURI(Applications.AUTHORITY, Applications.SEARCH_PATH, |
| SEARCH); |
| matcher.addURI(Applications.AUTHORITY, Applications.SEARCH_PATH + "/*", |
| SEARCH); |
| return matcher; |
| } |
| |
| /** |
| * Updates applications list when packages are added/removed. |
| * |
| * TODO: Maybe this should listen for changes to individual apps instead. |
| */ |
| private class MyPackageMonitor extends PackageMonitor { |
| @Override |
| public void onSomePackagesChanged() { |
| postUpdateAll(); |
| } |
| |
| @Override |
| public void onPackageModified(String packageName) { |
| postUpdatePackage(packageName); |
| } |
| } |
| |
| // Broadcast receiver for updating applications list when the locale changes. |
| private BroadcastReceiver mLocaleChangeReceiver = new BroadcastReceiver() { |
| @Override |
| public void onReceive(Context context, Intent intent) { |
| String action = intent.getAction(); |
| if (Intent.ACTION_LOCALE_CHANGED.equals(action)) { |
| if (DBG) Log.d(TAG, "locale changed"); |
| postUpdateAll(); |
| } |
| } |
| }; |
| |
| @Override |
| public boolean onCreate() { |
| createDatabase(); |
| // Start thread that runs app updates |
| HandlerThread thread = new HandlerThread("ApplicationsProviderUpdater", THREAD_PRIORITY); |
| thread.start(); |
| mHandler = createHandler(thread.getLooper()); |
| // Kick off first apps update |
| postUpdateAll(); |
| // Listen for package changes |
| new MyPackageMonitor().register(getContext(), null, true); |
| // Listen for locale changes |
| IntentFilter localeFilter = new IntentFilter(Intent.ACTION_LOCALE_CHANGED); |
| getContext().registerReceiver(mLocaleChangeReceiver, localeFilter); |
| return true; |
| } |
| |
| @VisibleForTesting |
| Handler createHandler(Looper looper) { |
| return new UpdateHandler(looper); |
| } |
| |
| @VisibleForTesting |
| class UpdateHandler extends Handler { |
| |
| public UpdateHandler(Looper looper) { |
| super(looper); |
| } |
| |
| @Override |
| public void handleMessage(Message msg) { |
| switch (msg.what) { |
| case MSG_UPDATE_ALL: |
| updateApplicationsList(null); |
| break; |
| case MSG_UPDATE_PACKAGE: |
| updateApplicationsList((String) msg.obj); |
| break; |
| default: |
| Log.e(TAG, "Unknown message: " + msg.what); |
| break; |
| } |
| } |
| } |
| |
| /** |
| * Posts an update to run on the DB update thread. |
| */ |
| private void postUpdateAll() { |
| // Clear pending updates |
| mHandler.removeMessages(MSG_UPDATE_ALL); |
| // Post a new update |
| Message msg = Message.obtain(); |
| msg.what = MSG_UPDATE_ALL; |
| mHandler.sendMessageDelayed(msg, UPDATE_DELAY_MILLIS); |
| } |
| |
| private void postUpdatePackage(String packageName) { |
| Message msg = Message.obtain(); |
| msg.what = MSG_UPDATE_PACKAGE; |
| msg.obj = packageName; |
| mHandler.sendMessageDelayed(msg, UPDATE_DELAY_MILLIS); |
| } |
| |
| // ---------- |
| // END ASYC UPDATE CODE |
| // ---------- |
| |
| |
| /** |
| * Creates an in-memory database for storing application info. |
| */ |
| private void createDatabase() { |
| mDb = SQLiteDatabase.create(null); |
| mDb.execSQL("CREATE TABLE IF NOT EXISTS " + APPLICATIONS_TABLE + " ("+ |
| _ID + " INTEGER PRIMARY KEY AUTOINCREMENT," + |
| NAME + " TEXT COLLATE LOCALIZED," + |
| DESCRIPTION + " description TEXT," + |
| PACKAGE + " TEXT," + |
| CLASS + " TEXT," + |
| ICON + " TEXT," + |
| LAUNCH_COUNT + " INTEGER DEFAULT 0," + |
| LAST_RESUME_TIME + " INTEGER DEFAULT 0" + |
| ");"); |
| // Needed for efficient update and remove |
| mDb.execSQL("CREATE INDEX applicationsComponentIndex ON " + APPLICATIONS_TABLE + " (" |
| + PACKAGE + "," + CLASS + ");"); |
| // Maps token from the app name to records in the applications table |
| mDb.execSQL("CREATE TABLE applicationsLookup (" + |
| "token TEXT," + |
| "source INTEGER REFERENCES " + APPLICATIONS_TABLE + "(" + _ID + ")," + |
| "token_index INTEGER" + |
| ");"); |
| mDb.execSQL("CREATE INDEX applicationsLookupIndex ON applicationsLookup (" + |
| "token," + |
| "source" + |
| ");"); |
| // Triggers to keep the applicationsLookup table up to date |
| mDb.execSQL("CREATE TRIGGER applicationsLookup_update UPDATE OF " + NAME + " ON " + |
| APPLICATIONS_TABLE + " " + |
| "BEGIN " + |
| "DELETE FROM applicationsLookup WHERE source = new." + _ID + ";" + |
| "SELECT _TOKENIZE('applicationsLookup', new." + _ID + ", new." + NAME + ", ' ', 1);" + |
| "END"); |
| mDb.execSQL("CREATE TRIGGER applicationsLookup_insert AFTER INSERT ON " + |
| APPLICATIONS_TABLE + " " + |
| "BEGIN " + |
| "SELECT _TOKENIZE('applicationsLookup', new." + _ID + ", new." + NAME + ", ' ', 1);" + |
| "END"); |
| mDb.execSQL("CREATE TRIGGER applicationsLookup_delete DELETE ON " + |
| APPLICATIONS_TABLE + " " + |
| "BEGIN " + |
| "DELETE FROM applicationsLookup WHERE source = old." + _ID + ";" + |
| "END"); |
| } |
| |
| /** |
| * This will always return {@link SearchManager#SUGGEST_MIME_TYPE} as this |
| * provider is purely to provide suggestions. |
| */ |
| @Override |
| public String getType(Uri uri) { |
| switch (sURIMatcher.match(uri)) { |
| case SEARCH_SUGGEST: |
| return SearchManager.SUGGEST_MIME_TYPE; |
| case SHORTCUT_REFRESH: |
| return SearchManager.SHORTCUT_MIME_TYPE; |
| case SEARCH: |
| return Applications.APPLICATION_DIR_TYPE; |
| default: |
| throw new IllegalArgumentException("URL " + uri + " doesn't support querying."); |
| } |
| } |
| |
| /** |
| * Queries for a given search term and returns a cursor containing |
| * suggestions ordered by best match. |
| */ |
| @Override |
| public Cursor query(Uri uri, String[] projectionIn, String selection, |
| String[] selectionArgs, String sortOrder) { |
| if (DBG) Log.d(TAG, "query(" + uri + ")"); |
| |
| if (!TextUtils.isEmpty(selection)) { |
| throw new IllegalArgumentException("selection not allowed for " + uri); |
| } |
| if (selectionArgs != null && selectionArgs.length != 0) { |
| throw new IllegalArgumentException("selectionArgs not allowed for " + uri); |
| } |
| if (!TextUtils.isEmpty(sortOrder)) { |
| throw new IllegalArgumentException("sortOrder not allowed for " + uri); |
| } |
| |
| switch (sURIMatcher.match(uri)) { |
| case SEARCH_SUGGEST: { |
| String query = null; |
| if (uri.getPathSegments().size() > 1) { |
| query = uri.getLastPathSegment().toLowerCase(); |
| } |
| if (uri.getQueryParameter(REFRESH_STATS) != null) { |
| updateUsageStats(); |
| } |
| return getSuggestions(query, projectionIn); |
| } |
| case SHORTCUT_REFRESH: { |
| String shortcutId = null; |
| if (uri.getPathSegments().size() > 1) { |
| shortcutId = uri.getLastPathSegment(); |
| } |
| return refreshShortcut(shortcutId, projectionIn); |
| } |
| case SEARCH: { |
| String query = null; |
| if (uri.getPathSegments().size() > 1) { |
| query = uri.getLastPathSegment().toLowerCase(); |
| } |
| return getSearchResults(query, projectionIn); |
| } |
| default: |
| throw new IllegalArgumentException("URL " + uri + " doesn't support querying."); |
| } |
| } |
| |
| private Cursor getSuggestions(String query, String[] projectionIn) { |
| Map<String, String> projectionMap = sSearchSuggestionsProjectionMap; |
| // No zero-query suggestions or launch times except for global search, |
| // to avoid leaking info about apps that have been used. |
| if (hasGlobalSearchPermission()) { |
| projectionMap = sGlobalSearchSuggestionsProjectionMap; |
| } else if (TextUtils.isEmpty(query)) { |
| return null; |
| } |
| return searchApplications(query, projectionIn, projectionMap); |
| } |
| |
| /** |
| * Refreshes the shortcut of an application. |
| * |
| * @param shortcutId Flattened component name of an activity. |
| */ |
| private Cursor refreshShortcut(String shortcutId, String[] projectionIn) { |
| ComponentName component = ComponentName.unflattenFromString(shortcutId); |
| if (component == null) { |
| Log.w(TAG, "Bad shortcut id: " + shortcutId); |
| return null; |
| } |
| SQLiteQueryBuilder qb = new SQLiteQueryBuilder(); |
| qb.setTables(APPLICATIONS_TABLE); |
| qb.setProjectionMap(sSearchSuggestionsProjectionMap); |
| qb.appendWhere("package = ? AND class = ?"); |
| String[] selectionArgs = { component.getPackageName(), component.getClassName() }; |
| Cursor cursor = qb.query(mDb, projectionIn, null, selectionArgs, null, null, null); |
| if (DBG) Log.d(TAG, "Returning " + cursor.getCount() + " results for shortcut refresh."); |
| return cursor; |
| } |
| |
| private Cursor getSearchResults(String query, String[] projectionIn) { |
| return searchApplications(query, projectionIn, sSearchProjectionMap); |
| } |
| |
| private Cursor searchApplications(String query, String[] projectionIn, |
| Map<String, String> columnMap) { |
| final boolean zeroQuery = TextUtils.isEmpty(query); |
| SQLiteQueryBuilder qb = new SQLiteQueryBuilder(); |
| qb.setTables(APPLICATIONS_LOOKUP_JOIN); |
| qb.setProjectionMap(columnMap); |
| String orderBy = null; |
| if (!zeroQuery) { |
| qb.appendWhere(buildTokenFilter(query)); |
| } else { |
| if (hasGlobalSearchPermission()) { |
| qb.appendWhere(LAST_RESUME_TIME + " > 0"); |
| } |
| } |
| if (!hasGlobalSearchPermission()) { |
| orderBy = getOrderBy(zeroQuery); |
| } |
| // don't return duplicates when there are two matching tokens for an app |
| String groupBy = APPLICATIONS_TABLE + "." + _ID; |
| Cursor cursor = qb.query(mDb, projectionIn, null, null, groupBy, null, orderBy); |
| if (DBG) Log.d(TAG, "Returning " + cursor.getCount() + " results for " + query); |
| return cursor; |
| } |
| |
| private String getOrderBy(boolean zeroQuery) { |
| // order first by whether it a full prefix match, then by launch |
| // count (if allowed, frequently used apps rank higher), then name |
| // MIN(token_index) != 0 is true for non-full prefix matches, |
| // and since false (0) < true(1), this expression makes sure |
| // that full prefix matches come first. |
| StringBuilder orderBy = new StringBuilder(); |
| if (!zeroQuery) { |
| orderBy.append("MIN(token_index) != 0, "); |
| } |
| |
| if (hasGlobalSearchPermission()) { |
| orderBy.append(LAST_RESUME_TIME + " DESC, "); |
| } |
| |
| orderBy.append(NAME); |
| |
| return orderBy.toString(); |
| } |
| |
| @SuppressWarnings("deprecation") |
| private String buildTokenFilter(String filterParam) { |
| StringBuilder filter = new StringBuilder("token GLOB "); |
| // NOTE: Query parameters won't work here since the SQL compiler |
| // needs to parse the actual string to know that it can use the |
| // index to do a prefix scan. |
| DatabaseUtils.appendEscapedSQLString(filter, |
| DatabaseUtils.getHexCollationKey(filterParam) + "*"); |
| return filter.toString(); |
| } |
| |
| private static HashMap<String, String> buildSuggestionsProjectionMap(boolean forGlobalSearch) { |
| HashMap<String, String> map = new HashMap<String, String>(); |
| addProjection(map, Applications.ApplicationColumns._ID, _ID); |
| addProjection(map, SearchManager.SUGGEST_COLUMN_TEXT_1, NAME); |
| addProjection(map, SearchManager.SUGGEST_COLUMN_TEXT_2, DESCRIPTION); |
| addProjection(map, SearchManager.SUGGEST_COLUMN_INTENT_DATA, |
| "'content://" + Applications.AUTHORITY + "/applications/'" |
| + " || " + PACKAGE + " || '/' || " + CLASS); |
| addProjection(map, SearchManager.SUGGEST_COLUMN_ICON_1, ICON); |
| addProjection(map, SearchManager.SUGGEST_COLUMN_ICON_2, "NULL"); |
| addProjection(map, SearchManager.SUGGEST_COLUMN_SHORTCUT_ID, |
| PACKAGE + " || '/' || " + CLASS); |
| if (forGlobalSearch) { |
| addProjection(map, SearchManager.SUGGEST_COLUMN_LAST_ACCESS_HINT, |
| LAST_RESUME_TIME); |
| } |
| return map; |
| } |
| |
| private static HashMap<String, String> buildSearchProjectionMap() { |
| HashMap<String, String> map = new HashMap<String, String>(); |
| addProjection(map, Applications.ApplicationColumns._ID, _ID); |
| addProjection(map, Applications.ApplicationColumns.NAME, NAME); |
| addProjection(map, Applications.ApplicationColumns.ICON, ICON); |
| addProjection(map, Applications.ApplicationColumns.URI, |
| "'content://" + Applications.AUTHORITY + "/applications/'" |
| + " || " + PACKAGE + " || '/' || " + CLASS); |
| return map; |
| } |
| |
| private static void addProjection(HashMap<String, String> map, String name, String value) { |
| if (!value.equals(name)) { |
| value = value + " AS " + name; |
| } |
| map.put(name, value); |
| } |
| |
| /** |
| * Updates the cached list of installed applications. |
| * |
| * @param packageName Name of package whose activities to update. |
| * If {@code null}, all packages are updated. |
| */ |
| private synchronized void updateApplicationsList(String packageName) { |
| if (DBG) Log.d(TAG, "Updating database (packageName = " + packageName + ")..."); |
| |
| DatabaseUtils.InsertHelper inserter = |
| new DatabaseUtils.InsertHelper(mDb, APPLICATIONS_TABLE); |
| int nameCol = inserter.getColumnIndex(NAME); |
| int descriptionCol = inserter.getColumnIndex(DESCRIPTION); |
| int packageCol = inserter.getColumnIndex(PACKAGE); |
| int classCol = inserter.getColumnIndex(CLASS); |
| int iconCol = inserter.getColumnIndex(ICON); |
| int launchCountCol = inserter.getColumnIndex(LAUNCH_COUNT); |
| int lastResumeTimeCol = inserter.getColumnIndex(LAST_RESUME_TIME); |
| |
| Map<String, PkgUsageStats> usageStats = fetchUsageStats(); |
| |
| mDb.beginTransaction(); |
| try { |
| removeApplications(packageName); |
| String description = getContext().getString(R.string.application_desc); |
| // Iterate and find all the activities which have the LAUNCHER category set. |
| Intent mainIntent = new Intent(Intent.ACTION_MAIN, null); |
| mainIntent.addCategory(Intent.CATEGORY_LAUNCHER); |
| if (packageName != null) { |
| // Limit to activities in the package, if given |
| mainIntent.setPackage(packageName); |
| } |
| final PackageManager manager = getPackageManager(); |
| List<ResolveInfo> activities = manager.queryIntentActivities(mainIntent, 0); |
| int activityCount = activities == null ? 0 : activities.size(); |
| for (int i = 0; i < activityCount; i++) { |
| ResolveInfo info = activities.get(i); |
| String title = info.loadLabel(manager).toString(); |
| String activityClassName = info.activityInfo.name; |
| if (TextUtils.isEmpty(title)) { |
| title = activityClassName; |
| } |
| |
| String activityPackageName = info.activityInfo.applicationInfo.packageName; |
| if (DBG) Log.d(TAG, "activity " + activityPackageName + "/" + activityClassName); |
| PkgUsageStats stats = usageStats.get(activityPackageName); |
| int launchCount = 0; |
| long lastResumeTime = 0; |
| if (stats != null) { |
| launchCount = stats.launchCount; |
| if (stats.componentResumeTimes.containsKey(activityClassName)) { |
| lastResumeTime = stats.componentResumeTimes.get(activityClassName); |
| } |
| } |
| |
| String icon = getActivityIconUri(info.activityInfo); |
| inserter.prepareForInsert(); |
| inserter.bind(nameCol, title); |
| inserter.bind(descriptionCol, description); |
| inserter.bind(packageCol, activityPackageName); |
| inserter.bind(classCol, activityClassName); |
| inserter.bind(iconCol, icon); |
| inserter.bind(launchCountCol, launchCount); |
| inserter.bind(lastResumeTimeCol, lastResumeTime); |
| inserter.execute(); |
| } |
| mDb.setTransactionSuccessful(); |
| } finally { |
| mDb.endTransaction(); |
| inserter.close(); |
| } |
| |
| if (DBG) Log.d(TAG, "Finished updating database."); |
| } |
| |
| @VisibleForTesting |
| protected synchronized void updateUsageStats() { |
| if (DBG) Log.d(TAG, "Update application usage stats."); |
| Map<String, PkgUsageStats> usageStats = fetchUsageStats(); |
| |
| mDb.beginTransaction(); |
| try { |
| for (Map.Entry<String, PkgUsageStats> statsEntry : usageStats.entrySet()) { |
| ContentValues updatedLaunchCount = new ContentValues(); |
| String packageName = statsEntry.getKey(); |
| PkgUsageStats stats = statsEntry.getValue(); |
| updatedLaunchCount.put(LAUNCH_COUNT, stats.launchCount); |
| |
| mDb.update(APPLICATIONS_TABLE, updatedLaunchCount, |
| PACKAGE + " = ?", new String[] { packageName }); |
| |
| for (Map.Entry<String, Long> crtEntry: stats.componentResumeTimes.entrySet()) { |
| ContentValues updatedLastResumeTime = new ContentValues(); |
| String componentName = crtEntry.getKey(); |
| updatedLastResumeTime.put(LAST_RESUME_TIME, crtEntry.getValue()); |
| |
| mDb.update(APPLICATIONS_TABLE, updatedLastResumeTime, |
| PACKAGE + " = ? AND " + CLASS + " = ?", |
| new String[] { packageName, componentName }); |
| } |
| } |
| mDb.setTransactionSuccessful(); |
| } finally { |
| mDb.endTransaction(); |
| } |
| |
| if (DBG) Log.d(TAG, "Finished updating application usage stats in database."); |
| } |
| |
| private String getActivityIconUri(ActivityInfo activityInfo) { |
| int icon = activityInfo.getIconResource(); |
| if (icon == 0) return null; |
| Uri uri = getResourceUri(activityInfo.applicationInfo, icon); |
| return uri == null ? null : uri.toString(); |
| } |
| |
| private void removeApplications(String packageName) { |
| if (packageName == null) { |
| mDb.delete(APPLICATIONS_TABLE, null, null); |
| } else { |
| mDb.delete(APPLICATIONS_TABLE, PACKAGE + " = ?", new String[] { packageName }); |
| } |
| |
| } |
| |
| @Override |
| public Uri insert(Uri uri, ContentValues values) { |
| throw new UnsupportedOperationException(); |
| } |
| |
| @Override |
| public int update(Uri uri, ContentValues values, String selection, |
| String[] selectionArgs) { |
| throw new UnsupportedOperationException(); |
| } |
| |
| @Override |
| public int delete(Uri uri, String selection, String[] selectionArgs) { |
| throw new UnsupportedOperationException(); |
| } |
| |
| private Uri getResourceUri(ApplicationInfo appInfo, int res) { |
| try { |
| Resources resources = getPackageManager().getResourcesForApplication(appInfo); |
| return getResourceUri(resources, appInfo.packageName, res); |
| } catch (PackageManager.NameNotFoundException e) { |
| return null; |
| } catch (Resources.NotFoundException e) { |
| return null; |
| } |
| } |
| |
| private static Uri getResourceUri(Resources resources, String appPkg, int res) |
| throws Resources.NotFoundException { |
| String resPkg = resources.getResourcePackageName(res); |
| String type = resources.getResourceTypeName(res); |
| String name = resources.getResourceEntryName(res); |
| return makeResourceUri(appPkg, resPkg, type, name); |
| } |
| |
| private static Uri makeResourceUri(String appPkg, String resPkg, String type, String name) |
| throws Resources.NotFoundException { |
| Uri.Builder uriBuilder = new Uri.Builder(); |
| uriBuilder.scheme(ContentResolver.SCHEME_ANDROID_RESOURCE); |
| uriBuilder.encodedAuthority(appPkg); |
| uriBuilder.appendEncodedPath(type); |
| if (!appPkg.equals(resPkg)) { |
| uriBuilder.appendEncodedPath(resPkg + ":" + name); |
| } else { |
| uriBuilder.appendEncodedPath(name); |
| } |
| return uriBuilder.build(); |
| } |
| |
| @VisibleForTesting |
| protected Map<String, PkgUsageStats> fetchUsageStats() { |
| try { |
| ActivityManager activityManager = (ActivityManager) |
| getContext().getSystemService(Context.ACTIVITY_SERVICE); |
| |
| if (activityManager != null) { |
| Map<String, PkgUsageStats> stats = new HashMap<String, PkgUsageStats>(); |
| PkgUsageStats[] pkgUsageStats = activityManager.getAllPackageUsageStats(); |
| if (pkgUsageStats != null) { |
| for (PkgUsageStats pus : pkgUsageStats) { |
| stats.put(pus.packageName, pus); |
| } |
| } |
| return stats; |
| } |
| } catch (Exception e) { |
| Log.w(TAG, "Could not fetch usage stats", e); |
| } |
| return new HashMap<String, PkgUsageStats>(); |
| } |
| |
| @VisibleForTesting |
| protected PackageManager getPackageManager() { |
| return getContext().getPackageManager(); |
| } |
| |
| @VisibleForTesting |
| protected boolean hasGlobalSearchPermission() { |
| // Only the global-search system is allowed to see the usage stats of |
| // applications. Without this restriction the ApplicationsProvider |
| // could leak information about the user's behavior to applications. |
| return (PackageManager.PERMISSION_GRANTED == |
| getContext().checkCallingPermission(android.Manifest.permission.GLOBAL_SEARCH)); |
| } |
| |
| } |
