AppOpsState.java revision 983378738761150d8ba649b4b1d74635881e61ec 
1/**
2 * Copyright (C) 2013 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
5 * use this file except in compliance with the License. You may obtain a copy
6 * of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
12 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13 * License for the specific language governing permissions and limitations
14 * under the License.
15 */
16
17package com.android.settings.applications;
18
19import android.app.AppOpsManager;
20import android.content.Context;
21import android.content.pm.ApplicationInfo;
22import android.content.pm.PackageInfo;
23import android.content.pm.PackageManager;
24import android.content.pm.PackageManager.NameNotFoundException;
25import android.content.res.Resources;
26import android.graphics.drawable.Drawable;
27import android.os.Parcel;
28import android.os.Parcelable;
29import android.text.format.DateUtils;
30
31import android.util.Log;
32import android.util.SparseArray;
33import com.android.settings.R;
34
35import java.io.File;
36import java.text.Collator;
37import java.util.ArrayList;
38import java.util.Collections;
39import java.util.Comparator;
40import java.util.HashMap;
41import java.util.List;
42
43public class AppOpsState {
44    static final String TAG = "AppOpsState";
45    static final boolean DEBUG = false;
46
47    final Context mContext;
48    final AppOpsManager mAppOps;
49    final PackageManager mPm;
50    final CharSequence[] mOpSummaries;
51    final CharSequence[] mOpLabels;
52
53    List<AppOpEntry> mApps;
54
55    public AppOpsState(Context context) {
56        mContext = context;
57        mAppOps = (AppOpsManager)context.getSystemService(Context.APP_OPS_SERVICE);
58        mPm = context.getPackageManager();
59        mOpSummaries = context.getResources().getTextArray(R.array.app_ops_summaries);
60        mOpLabels = context.getResources().getTextArray(R.array.app_ops_labels);
61    }
62
63    public static class OpsTemplate implements Parcelable {
64        public final int[] ops;
65        public final boolean[] showPerms;
66
67        public OpsTemplate(int[] _ops, boolean[] _showPerms) {
68            ops = _ops;
69            showPerms = _showPerms;
70        }
71
72        OpsTemplate(Parcel src) {
73            ops = src.createIntArray();
74            showPerms = src.createBooleanArray();
75        }
76
77        @Override
78        public int describeContents() {
79            return 0;
80        }
81
82        @Override
83        public void writeToParcel(Parcel dest, int flags) {
84            dest.writeIntArray(ops);
85            dest.writeBooleanArray(showPerms);
86        }
87
88        public static final Creator<OpsTemplate> CREATOR = new Creator<OpsTemplate>() {
89            @Override public OpsTemplate createFromParcel(Parcel source) {
90                return new OpsTemplate(source);
91            }
92
93            @Override public OpsTemplate[] newArray(int size) {
94                return new OpsTemplate[size];
95            }
96        };
97    }
98
99    public static final OpsTemplate LOCATION_TEMPLATE = new OpsTemplate(
100            new int[] { AppOpsManager.OP_COARSE_LOCATION,
101                    AppOpsManager.OP_FINE_LOCATION,
102                    AppOpsManager.OP_GPS,
103                    AppOpsManager.OP_WIFI_SCAN,
104                    AppOpsManager.OP_NEIGHBORING_CELLS },
105            new boolean[] { true,
106                    true,
107                    false,
108                    false,
109                    false }
110            );
111
112    public static final OpsTemplate PERSONAL_TEMPLATE = new OpsTemplate(
113            new int[] { AppOpsManager.OP_READ_CONTACTS,
114                    AppOpsManager.OP_WRITE_CONTACTS,
115                    AppOpsManager.OP_READ_CALL_LOG,
116                    AppOpsManager.OP_WRITE_CALL_LOG,
117                    AppOpsManager.OP_READ_CALENDAR,
118                    AppOpsManager.OP_WRITE_CALENDAR },
119            new boolean[] { true,
120                    true,
121                    true,
122                    true,
123                    true,
124                    true }
125            );
126
127    public static final OpsTemplate MESSAGING_TEMPLATE = new OpsTemplate(
128            new int[] { AppOpsManager.OP_READ_SMS,
129                    AppOpsManager.OP_RECEIVE_SMS,
130                    AppOpsManager.OP_RECEIVE_EMERGECY_SMS,
131                    AppOpsManager.OP_RECEIVE_MMS,
132                    AppOpsManager.OP_RECEIVE_WAP_PUSH,
133                    AppOpsManager.OP_WRITE_SMS,
134                    AppOpsManager.OP_SEND_SMS,
135                    AppOpsManager.OP_READ_ICC_SMS,
136                    AppOpsManager.OP_WRITE_ICC_SMS },
137            new boolean[] { true,
138                    true,
139                    true,
140                    true,
141                    true,
142                    true,
143                    true,
144                    true,
145                    true }
146            );
147
148    public static final OpsTemplate DEVICE_TEMPLATE = new OpsTemplate(
149            new int[] { AppOpsManager.OP_VIBRATE,
150                    AppOpsManager.OP_POST_NOTIFICATION,
151                    AppOpsManager.OP_CALL_PHONE },
152            new boolean[] { false,
153                    false,
154                    true }
155            );
156
157    public static final OpsTemplate[] ALL_TEMPLATES = new OpsTemplate[] {
158            LOCATION_TEMPLATE, PERSONAL_TEMPLATE, MESSAGING_TEMPLATE, DEVICE_TEMPLATE
159    };
160
161    /**
162     * This class holds the per-item data in our Loader.
163     */
164    public static class AppEntry {
165        private final AppOpsState mState;
166        private final ApplicationInfo mInfo;
167        private final File mApkFile;
168        private final SparseArray<AppOpsManager.OpEntry> mOps
169                = new SparseArray<AppOpsManager.OpEntry>();
170        private final SparseArray<AppOpEntry> mOpSwitches
171                = new SparseArray<AppOpEntry>();
172        private String mLabel;
173        private Drawable mIcon;
174        private boolean mMounted;
175
176        public AppEntry(AppOpsState state, ApplicationInfo info) {
177            mState = state;
178            mInfo = info;
179            mApkFile = new File(info.sourceDir);
180        }
181
182        public void addOp(AppOpEntry entry, AppOpsManager.OpEntry op) {
183            mOps.put(op.getOp(), op);
184            mOpSwitches.put(AppOpsManager.opToSwitch(op.getOp()), entry);
185        }
186
187        public boolean hasOp(int op) {
188            return mOps.indexOfKey(op) >= 0;
189        }
190
191        public AppOpEntry getOpSwitch(int op) {
192            return mOpSwitches.get(AppOpsManager.opToSwitch(op));
193        }
194
195        public ApplicationInfo getApplicationInfo() {
196            return mInfo;
197        }
198
199        public String getLabel() {
200            return mLabel;
201        }
202
203        public Drawable getIcon() {
204            if (mIcon == null) {
205                if (mApkFile.exists()) {
206                    mIcon = mInfo.loadIcon(mState.mPm);
207                    return mIcon;
208                } else {
209                    mMounted = false;
210                }
211            } else if (!mMounted) {
212                // If the app wasn't mounted but is now mounted, reload
213                // its icon.
214                if (mApkFile.exists()) {
215                    mMounted = true;
216                    mIcon = mInfo.loadIcon(mState.mPm);
217                    return mIcon;
218                }
219            } else {
220                return mIcon;
221            }
222
223            return mState.mContext.getResources().getDrawable(
224                    android.R.drawable.sym_def_app_icon);
225        }
226
227        @Override public String toString() {
228            return mLabel;
229        }
230
231        void loadLabel(Context context) {
232            if (mLabel == null || !mMounted) {
233                if (!mApkFile.exists()) {
234                    mMounted = false;
235                    mLabel = mInfo.packageName;
236                } else {
237                    mMounted = true;
238                    CharSequence label = mInfo.loadLabel(context.getPackageManager());
239                    mLabel = label != null ? label.toString() : mInfo.packageName;
240                }
241            }
242        }
243    }
244
245    /**
246     * This class holds the per-item data in our Loader.
247     */
248    public static class AppOpEntry {
249        private final AppOpsManager.PackageOps mPkgOps;
250        private final ArrayList<AppOpsManager.OpEntry> mOps
251                = new ArrayList<AppOpsManager.OpEntry>();
252        private final ArrayList<AppOpsManager.OpEntry> mSwitchOps
253                = new ArrayList<AppOpsManager.OpEntry>();
254        private final AppEntry mApp;
255
256        public AppOpEntry(AppOpsManager.PackageOps pkg, AppOpsManager.OpEntry op, AppEntry app) {
257            mPkgOps = pkg;
258            mApp = app;
259            mApp.addOp(this, op);
260            mOps.add(op);
261            mSwitchOps.add(op);
262        }
263
264        private static void addOp(ArrayList<AppOpsManager.OpEntry> list, AppOpsManager.OpEntry op) {
265            for (int i=0; i<list.size(); i++) {
266                AppOpsManager.OpEntry pos = list.get(i);
267                if (pos.isRunning() != op.isRunning()) {
268                    if (op.isRunning()) {
269                        list.add(i, op);
270                        return;
271                    }
272                    continue;
273                }
274                if (pos.getTime() < op.getTime()) {
275                    list.add(i, op);
276                    return;
277                }
278            }
279            list.add(op);
280        }
281
282        public void addOp(AppOpsManager.OpEntry op) {
283            mApp.addOp(this, op);
284            addOp(mOps, op);
285            if (mApp.getOpSwitch(AppOpsManager.opToSwitch(op.getOp())) == null) {
286                addOp(mSwitchOps, op);
287            }
288        }
289
290        public AppEntry getAppEntry() {
291            return mApp;
292        }
293
294        public AppOpsManager.PackageOps getPackageOps() {
295            return mPkgOps;
296        }
297
298        public int getNumOpEntry() {
299            return mOps.size();
300        }
301
302        public AppOpsManager.OpEntry getOpEntry(int pos) {
303            return mOps.get(pos);
304        }
305
306        private CharSequence getCombinedText(ArrayList<AppOpsManager.OpEntry> ops,
307                CharSequence[] items) {
308            if (ops.size() == 1) {
309                return items[ops.get(0).getOp()];
310            } else {
311                StringBuilder builder = new StringBuilder();
312                for (int i=0; i<ops.size(); i++) {
313                    if (i > 0) {
314                        builder.append(", ");
315                    }
316                    builder.append(items[ops.get(i).getOp()]);
317                }
318                return builder.toString();
319            }
320        }
321
322        public CharSequence getSummaryText(AppOpsState state) {
323            return getCombinedText(mOps, state.mOpSummaries);
324        }
325
326        public CharSequence getSwitchText(AppOpsState state) {
327            if (mSwitchOps.size() > 0) {
328                return getCombinedText(mSwitchOps, state.mOpLabels);
329            } else {
330                return getCombinedText(mOps, state.mOpLabels);
331            }
332        }
333
334        public CharSequence getTimeText(Resources res, boolean showEmptyText) {
335            if (isRunning()) {
336                return res.getText(R.string.app_ops_running);
337            }
338            if (getTime() > 0) {
339                return DateUtils.getRelativeTimeSpanString(getTime(),
340                        System.currentTimeMillis(),
341                        DateUtils.MINUTE_IN_MILLIS,
342                        DateUtils.FORMAT_ABBREV_RELATIVE);
343            }
344            return showEmptyText ? res.getText(R.string.app_ops_never_used) : "";
345        }
346
347        public boolean isRunning() {
348            return mOps.get(0).isRunning();
349        }
350
351        public long getTime() {
352            return mOps.get(0).getTime();
353        }
354
355        @Override public String toString() {
356            return mApp.getLabel();
357        }
358    }
359
360    /**
361     * Perform alphabetical comparison of application entry objects.
362     */
363    public static final Comparator<AppOpEntry> APP_OP_COMPARATOR = new Comparator<AppOpEntry>() {
364        private final Collator sCollator = Collator.getInstance();
365        @Override
366        public int compare(AppOpEntry object1, AppOpEntry object2) {
367            if (object1.isRunning() != object2.isRunning()) {
368                // Currently running ops go first.
369                return object1.isRunning() ? -1 : 1;
370            }
371            if (object1.getTime() != object2.getTime()) {
372                // More recent times go first.
373                return object1.getTime() > object2.getTime() ? -1 : 1;
374            }
375            return sCollator.compare(object1.getAppEntry().getLabel(),
376                    object2.getAppEntry().getLabel());
377        }
378    };
379
380    private void addOp(List<AppOpEntry> entries, AppOpsManager.PackageOps pkgOps,
381            AppEntry appEntry, AppOpsManager.OpEntry opEntry, boolean allowMerge) {
382        if (allowMerge && entries.size() > 0) {
383            AppOpEntry last = entries.get(entries.size()-1);
384            if (last.getAppEntry() == appEntry) {
385                boolean lastExe = last.getTime() != 0;
386                boolean entryExe = opEntry.getTime() != 0;
387                if (lastExe == entryExe) {
388                    if (DEBUG) Log.d(TAG, "Add op " + opEntry.getOp() + " to package "
389                            + pkgOps.getPackageName() + ": append to " + last);
390                    last.addOp(opEntry);
391                    return;
392                }
393            }
394        }
395        AppOpEntry entry = appEntry.getOpSwitch(opEntry.getOp());
396        if (entry != null) {
397            entry.addOp(opEntry);
398            return;
399        }
400        entry = new AppOpEntry(pkgOps, opEntry, appEntry);
401        if (DEBUG) Log.d(TAG, "Add op " + opEntry.getOp() + " to package "
402                + pkgOps.getPackageName() + ": making new " + entry);
403        entries.add(entry);
404    }
405
406    public List<AppOpEntry> buildState(OpsTemplate tpl) {
407        return buildState(tpl, 0, null);
408    }
409
410    private AppEntry getAppEntry(final Context context, final HashMap<String, AppEntry> appEntries,
411            final String packageName, ApplicationInfo appInfo) {
412        AppEntry appEntry = appEntries.get(packageName);
413        if (appEntry == null) {
414            if (appInfo == null) {
415                try {
416                    appInfo = mPm.getApplicationInfo(packageName,
417                            PackageManager.GET_DISABLED_COMPONENTS
418                            | PackageManager.GET_UNINSTALLED_PACKAGES);
419                } catch (PackageManager.NameNotFoundException e) {
420                    Log.w(TAG, "Unable to find info for package " + packageName);
421                    return null;
422                }
423            }
424            appEntry = new AppEntry(this, appInfo);
425            appEntry.loadLabel(context);
426            appEntries.put(packageName, appEntry);
427        }
428        return appEntry;
429    }
430
431    public List<AppOpEntry> buildState(OpsTemplate tpl, int uid, String packageName) {
432        final Context context = mContext;
433
434        final HashMap<String, AppEntry> appEntries = new HashMap<String, AppEntry>();
435        final List<AppOpEntry> entries = new ArrayList<AppOpEntry>();
436
437        final ArrayList<String> perms = new ArrayList<String>();
438        final ArrayList<Integer> permOps = new ArrayList<Integer>();
439        for (int i=0; i<tpl.ops.length; i++) {
440            if (tpl.showPerms[i]) {
441                String perm = AppOpsManager.opToPermission(tpl.ops[i]);
442                if (perm != null && !perms.contains(perm)) {
443                    perms.add(perm);
444                    permOps.add(tpl.ops[i]);
445                }
446            }
447        }
448
449        List<AppOpsManager.PackageOps> pkgs;
450        if (packageName != null) {
451            pkgs = mAppOps.getOpsForPackage(uid, packageName, tpl.ops);
452        } else {
453            pkgs = mAppOps.getPackagesForOps(tpl.ops);
454        }
455
456        if (pkgs != null) {
457            for (int i=0; i<pkgs.size(); i++) {
458                AppOpsManager.PackageOps pkgOps = pkgs.get(i);
459                AppEntry appEntry = getAppEntry(context, appEntries, pkgOps.getPackageName(), null);
460                if (appEntry == null) {
461                    continue;
462                }
463                for (int j=0; j<pkgOps.getOps().size(); j++) {
464                    AppOpsManager.OpEntry opEntry = pkgOps.getOps().get(j);
465                    addOp(entries, pkgOps, appEntry, opEntry, packageName == null);
466                }
467            }
468        }
469
470        List<PackageInfo> apps;
471        if (packageName != null) {
472            apps = new ArrayList<PackageInfo>();
473            try {
474                PackageInfo pi = mPm.getPackageInfo(packageName, PackageManager.GET_PERMISSIONS);
475                apps.add(pi);
476            } catch (NameNotFoundException e) {
477            }
478        } else {
479            String[] permsArray = new String[perms.size()];
480            perms.toArray(permsArray);
481            apps = mPm.getPackagesHoldingPermissions(permsArray, 0);
482        }
483        for (int i=0; i<apps.size(); i++) {
484            PackageInfo appInfo = apps.get(i);
485            AppEntry appEntry = getAppEntry(context, appEntries, appInfo.packageName,
486                    appInfo.applicationInfo);
487            if (appEntry == null) {
488                continue;
489            }
490            List<AppOpsManager.OpEntry> dummyOps = null;
491            AppOpsManager.PackageOps pkgOps = null;
492            if (appInfo.requestedPermissions != null) {
493                for (int j=0; j<appInfo.requestedPermissions.length; j++) {
494                    if (appInfo.requestedPermissionsFlags != null) {
495                        if ((appInfo.requestedPermissionsFlags[j]
496                                & PackageInfo.REQUESTED_PERMISSION_GRANTED) == 0) {
497                            if (DEBUG) Log.d(TAG, "Pkg " + appInfo.packageName + " perm "
498                                    + appInfo.requestedPermissions[j] + " not granted; skipping");
499                            break;
500                        }
501                    }
502                    if (DEBUG) Log.d(TAG, "Pkg " + appInfo.packageName + ": requested perm "
503                            + appInfo.requestedPermissions[j]);
504                    for (int k=0; k<perms.size(); k++) {
505                        if (!perms.get(k).equals(appInfo.requestedPermissions[j])) {
506                            continue;
507                        }
508                        if (DEBUG) Log.d(TAG, "Pkg " + appInfo.packageName + " perm " + perms.get(k)
509                                + " has op " + permOps.get(k) + ": " + appEntry.hasOp(permOps.get(k)));
510                        if (appEntry.hasOp(permOps.get(k))) {
511                            continue;
512                        }
513                        if (dummyOps == null) {
514                            dummyOps = new ArrayList<AppOpsManager.OpEntry>();
515                            pkgOps = new AppOpsManager.PackageOps(
516                                    appInfo.packageName, appInfo.applicationInfo.uid, dummyOps);
517
518                        }
519                        AppOpsManager.OpEntry opEntry = new AppOpsManager.OpEntry(
520                                permOps.get(k), AppOpsManager.MODE_ALLOWED, 0, 0, 0);
521                        dummyOps.add(opEntry);
522                        addOp(entries, pkgOps, appEntry, opEntry, packageName == null);
523                    }
524                }
525            }
526        }
527
528        // Sort the list.
529        Collections.sort(entries, APP_OP_COMPARATOR);
530
531        // Done!
532        return entries;
533    }
534}
535