| /* |
| * Copyright (C) 2014 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.settings; |
| |
| import com.android.internal.content.PackageMonitor; |
| |
| import android.Manifest; |
| import android.app.ActivityThread; |
| import android.app.AppOpsManager; |
| import android.content.Context; |
| import android.content.pm.IPackageManager; |
| import android.content.pm.PackageInfo; |
| import android.content.pm.PackageManager; |
| import android.os.AsyncTask; |
| import android.os.Bundle; |
| import android.os.Looper; |
| import android.os.RemoteException; |
| import android.preference.Preference; |
| import android.preference.SwitchPreference; |
| import android.util.ArrayMap; |
| import android.util.Log; |
| |
| import java.util.List; |
| |
| public class UsageAccessSettings extends SettingsPreferenceFragment implements |
| Preference.OnPreferenceChangeListener { |
| |
| private static final String TAG = "UsageAccessSettings"; |
| |
| private static final String[] PM_USAGE_STATS_PERMISSION = new String[] { |
| Manifest.permission.PACKAGE_USAGE_STATS |
| }; |
| |
| private static final int[] APP_OPS_OP_CODES = new int[] { |
| AppOpsManager.OP_GET_USAGE_STATS |
| }; |
| |
| private static class PackageEntry { |
| public PackageEntry(String packageName) { |
| this.packageName = packageName; |
| this.appOpMode = AppOpsManager.MODE_DEFAULT; |
| } |
| |
| final String packageName; |
| PackageInfo packageInfo; |
| boolean permissionGranted; |
| int appOpMode; |
| |
| SwitchPreference preference; |
| } |
| |
| /** |
| * Fetches the list of Apps that are requesting access to the UsageStats API and updates |
| * the PreferenceScreen with the results when complete. |
| */ |
| private class AppsRequestingAccessFetcher extends |
| AsyncTask<Void, Void, ArrayMap<String, PackageEntry>> { |
| |
| private final Context mContext; |
| private final PackageManager mPackageManager; |
| private final IPackageManager mIPackageManager; |
| |
| public AppsRequestingAccessFetcher(Context context) { |
| mContext = context; |
| mPackageManager = context.getPackageManager(); |
| mIPackageManager = ActivityThread.getPackageManager(); |
| } |
| |
| @Override |
| protected ArrayMap<String, PackageEntry> doInBackground(Void... params) { |
| final String[] packages; |
| try { |
| packages = mIPackageManager.getAppOpPermissionPackages( |
| Manifest.permission.PACKAGE_USAGE_STATS); |
| } catch (RemoteException e) { |
| Log.w(TAG, "PackageManager is dead. Can't get list of packages requesting " |
| + Manifest.permission.PACKAGE_USAGE_STATS); |
| return null; |
| } |
| |
| if (packages == null) { |
| // No packages are requesting permission to use the UsageStats API. |
| return null; |
| } |
| |
| ArrayMap<String, PackageEntry> entries = new ArrayMap<>(); |
| for (final String packageName : packages) { |
| if (!shouldIgnorePackage(packageName)) { |
| entries.put(packageName, new PackageEntry(packageName)); |
| } |
| } |
| |
| // Load the packages that have been granted the PACKAGE_USAGE_STATS permission. |
| final List<PackageInfo> packageInfos = mPackageManager.getPackagesHoldingPermissions( |
| PM_USAGE_STATS_PERMISSION, 0); |
| final int packageInfoCount = packageInfos != null ? packageInfos.size() : 0; |
| for (int i = 0; i < packageInfoCount; i++) { |
| final PackageInfo packageInfo = packageInfos.get(i); |
| final PackageEntry pe = entries.get(packageInfo.packageName); |
| if (pe != null) { |
| pe.packageInfo = packageInfo; |
| pe.permissionGranted = true; |
| } |
| } |
| |
| // Load the remaining packages that have requested but don't have the |
| // PACKAGE_USAGE_STATS permission. |
| int packageCount = entries.size(); |
| for (int i = 0; i < packageCount; i++) { |
| final PackageEntry pe = entries.valueAt(i); |
| if (pe.packageInfo == null) { |
| try { |
| pe.packageInfo = mPackageManager.getPackageInfo(pe.packageName, 0); |
| } catch (PackageManager.NameNotFoundException e) { |
| // This package doesn't exist. This may occur when an app is uninstalled for |
| // one user, but it is not removed from the system. |
| entries.removeAt(i); |
| i--; |
| packageCount--; |
| } |
| } |
| } |
| |
| // Find out which packages have been granted permission from AppOps. |
| final List<AppOpsManager.PackageOps> packageOps = mAppOpsManager.getPackagesForOps( |
| APP_OPS_OP_CODES); |
| final int packageOpsCount = packageOps != null ? packageOps.size() : 0; |
| for (int i = 0; i < packageOpsCount; i++) { |
| final AppOpsManager.PackageOps packageOp = packageOps.get(i); |
| final PackageEntry pe = entries.get(packageOp.getPackageName()); |
| if (pe == null) { |
| Log.w(TAG, "AppOp permission exists for package " + packageOp.getPackageName() |
| + " but package doesn't exist or did not request UsageStats access"); |
| continue; |
| } |
| |
| if (packageOp.getUid() != pe.packageInfo.applicationInfo.uid) { |
| // This AppOp does not belong to this user. |
| continue; |
| } |
| |
| if (packageOp.getOps().size() < 1) { |
| Log.w(TAG, "No AppOps permission exists for package " |
| + packageOp.getPackageName()); |
| continue; |
| } |
| |
| pe.appOpMode = packageOp.getOps().get(0).getMode(); |
| } |
| |
| return entries; |
| } |
| |
| @Override |
| protected void onPostExecute(ArrayMap<String, PackageEntry> newEntries) { |
| mLastFetcherTask = null; |
| |
| if (getActivity() == null) { |
| // We must have finished the Activity while we were processing in the background. |
| return; |
| } |
| |
| if (newEntries == null) { |
| mPackageEntryMap.clear(); |
| getPreferenceScreen().removeAll(); |
| return; |
| } |
| |
| // Find the deleted entries and remove them from the PreferenceScreen. |
| final int oldPackageCount = mPackageEntryMap.size(); |
| for (int i = 0; i < oldPackageCount; i++) { |
| final PackageEntry oldPackageEntry = mPackageEntryMap.valueAt(i); |
| final PackageEntry newPackageEntry = newEntries.get(oldPackageEntry.packageName); |
| if (newPackageEntry == null) { |
| // This package has been removed. |
| getPreferenceScreen().removePreference(oldPackageEntry.preference); |
| } else { |
| // This package already exists in the preference hierarchy, so reuse that |
| // Preference. |
| newPackageEntry.preference = oldPackageEntry.preference; |
| } |
| } |
| |
| // Now add new packages to the PreferenceScreen. |
| final int packageCount = newEntries.size(); |
| for (int i = 0; i < packageCount; i++) { |
| final PackageEntry packageEntry = newEntries.valueAt(i); |
| if (packageEntry.preference == null) { |
| packageEntry.preference = new SwitchPreference(mContext); |
| packageEntry.preference.setPersistent(false); |
| packageEntry.preference.setOnPreferenceChangeListener(UsageAccessSettings.this); |
| getPreferenceScreen().addPreference(packageEntry.preference); |
| } |
| updatePreference(packageEntry); |
| } |
| |
| mPackageEntryMap.clear(); |
| mPackageEntryMap = newEntries; |
| } |
| |
| private void updatePreference(PackageEntry pe) { |
| pe.preference.setIcon(pe.packageInfo.applicationInfo.loadIcon(mPackageManager)); |
| pe.preference.setTitle(pe.packageInfo.applicationInfo.loadLabel(mPackageManager)); |
| pe.preference.setKey(pe.packageName); |
| |
| boolean check = false; |
| if (pe.appOpMode == AppOpsManager.MODE_ALLOWED) { |
| check = true; |
| } else if (pe.appOpMode == AppOpsManager.MODE_DEFAULT) { |
| // If the default AppOps mode is set, then fall back to |
| // whether the app has been granted permission by PackageManager. |
| check = pe.permissionGranted; |
| } |
| |
| if (check != pe.preference.isChecked()) { |
| pe.preference.setChecked(check); |
| } |
| } |
| } |
| |
| private static boolean shouldIgnorePackage(String packageName) { |
| return packageName.equals("android") || packageName.equals("com.android.settings"); |
| } |
| |
| private ArrayMap<String, PackageEntry> mPackageEntryMap = new ArrayMap<>(); |
| private AppOpsManager mAppOpsManager; |
| private AppsRequestingAccessFetcher mLastFetcherTask; |
| |
| @Override |
| public void onCreate(Bundle icicle) { |
| super.onCreate(icicle); |
| |
| addPreferencesFromResource(R.xml.usage_access_settings); |
| getPreferenceScreen().setOrderingAsAdded(false); |
| mAppOpsManager = (AppOpsManager) getSystemService(Context.APP_OPS_SERVICE); |
| } |
| |
| @Override |
| public void onResume() { |
| super.onResume(); |
| |
| updateInterestedApps(); |
| mPackageMonitor.register(getActivity(), Looper.getMainLooper(), false); |
| } |
| |
| @Override |
| public void onPause() { |
| super.onPause(); |
| |
| mPackageMonitor.unregister(); |
| if (mLastFetcherTask != null) { |
| mLastFetcherTask.cancel(true); |
| mLastFetcherTask = null; |
| } |
| } |
| |
| private void updateInterestedApps() { |
| if (mLastFetcherTask != null) { |
| // Canceling can only fail for some obscure reason since mLastFetcherTask would be |
| // null if the task has already completed. So we ignore the result of cancel and |
| // spawn a new task to get fresh data. AsyncTask executes tasks serially anyways, |
| // so we are safe from running two tasks at the same time. |
| mLastFetcherTask.cancel(true); |
| } |
| |
| mLastFetcherTask = new AppsRequestingAccessFetcher(getActivity()); |
| mLastFetcherTask.execute(); |
| } |
| |
| @Override |
| public boolean onPreferenceChange(Preference preference, Object newValue) { |
| final String packageName = preference.getKey(); |
| final PackageEntry pe = mPackageEntryMap.get(packageName); |
| if (pe == null) { |
| Log.w(TAG, "Preference change event for package " + packageName |
| + " but that package is no longer valid."); |
| return false; |
| } |
| |
| if (!(newValue instanceof Boolean)) { |
| Log.w(TAG, "Preference change event for package " + packageName |
| + " had non boolean value of type " + newValue.getClass().getName()); |
| return false; |
| } |
| |
| final int newMode = (Boolean) newValue ? |
| AppOpsManager.MODE_ALLOWED : AppOpsManager.MODE_IGNORED; |
| |
| // Check if we need to do any work. |
| if (pe.appOpMode != newMode) { |
| mAppOpsManager.setMode(AppOpsManager.OP_GET_USAGE_STATS, |
| pe.packageInfo.applicationInfo.uid, packageName, newMode); |
| pe.appOpMode = newMode; |
| } |
| return true; |
| } |
| |
| private final PackageMonitor mPackageMonitor = new PackageMonitor() { |
| @Override |
| public void onPackageAdded(String packageName, int uid) { |
| updateInterestedApps(); |
| } |
| |
| @Override |
| public void onPackageRemoved(String packageName, int uid) { |
| updateInterestedApps(); |
| } |
| }; |
| } |