src/com/android/settings/UsageAccessSettings.java

/*
 * 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.AlertDialog;
import android.app.AppOpsManager;
import android.app.Dialog;
import android.app.DialogFragment;
import android.content.Context;
import android.content.DialogInterface;
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.PreferenceScreen;
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();
                mPreferenceScreen.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.
                    mPreferenceScreen.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);
                    mPreferenceScreen.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);
            }
        }
    }

    static boolean shouldIgnorePackage(String packageName) {
        return packageName.equals("android") || packageName.equals("com.android.settings");
    }

    private AppsRequestingAccessFetcher mLastFetcherTask;
    ArrayMap<String, PackageEntry> mPackageEntryMap = new ArrayMap<>();
    AppOpsManager mAppOpsManager;
    PreferenceScreen mPreferenceScreen;

    @Override
    public void onCreate(Bundle icicle) {
        super.onCreate(icicle);

        addPreferencesFromResource(R.xml.usage_access_settings);
        mPreferenceScreen = getPreferenceScreen();
        mPreferenceScreen.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) {
            if (newMode != AppOpsManager.MODE_ALLOWED) {
                // Turning off the setting has no warning.
                setNewMode(pe, newMode);
                return true;
            }

            // Turning on the setting has a Warning.
            getFragmentManager().beginTransaction()
                    .add(new WarningDialog(pe), "warning")
                    .commit();
            return false;
        }
        return true;
    }

    void setNewMode(PackageEntry pe, int newMode) {
        mAppOpsManager.setMode(AppOpsManager.OP_GET_USAGE_STATS,
        pe.packageInfo.applicationInfo.uid, pe.packageName, newMode);
        pe.appOpMode = newMode;
    }

    private final PackageMonitor mPackageMonitor = new PackageMonitor() {
        @Override
        public void onPackageAdded(String packageName, int uid) {
            updateInterestedApps();
        }

        @Override
        public void onPackageRemoved(String packageName, int uid) {
            updateInterestedApps();
        }
    };

    private class WarningDialog extends DialogFragment
            implements DialogInterface.OnClickListener {
        private final PackageEntry mEntry;

        public WarningDialog(PackageEntry pe) {
            mEntry = pe;
        }

        @Override
        public Dialog onCreateDialog(Bundle savedInstanceState) {
            return new AlertDialog.Builder(getActivity())
                    .setTitle(R.string.allow_usage_access_title)
                    .setMessage(R.string.allow_usage_access_message)
                    .setIconAttribute(android.R.attr.alertDialogIcon)
                    .setNegativeButton(R.string.cancel, this)
                    .setPositiveButton(android.R.string.ok, this)
                    .create();
        }

        @Override
        public void onClick(DialogInterface dialog, int which) {
            if (which == DialogInterface.BUTTON_POSITIVE) {
                setNewMode(mEntry, AppOpsManager.MODE_ALLOWED);
                mEntry.preference.setChecked(true);
            } else {
                dialog.cancel();
            }
        }
    }
}