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                    AppOpsManager.OP_MONITOR_LOCATION,
106                    AppOpsManager.OP_MONITOR_HIGH_POWER_LOCATION },
107            new boolean[] { true,
108                    true,
109                    false,
110                    false,
111                    false,
112                    false,
113                    false }
114            );
115
116    public static final OpsTemplate PERSONAL_TEMPLATE = new OpsTemplate(
117            new int[] { AppOpsManager.OP_READ_CONTACTS,
118                    AppOpsManager.OP_WRITE_CONTACTS,
119                    AppOpsManager.OP_READ_CALL_LOG,
120                    AppOpsManager.OP_WRITE_CALL_LOG,
121                    AppOpsManager.OP_READ_CALENDAR,
122                    AppOpsManager.OP_WRITE_CALENDAR,
123                    AppOpsManager.OP_READ_CLIPBOARD,
124                    AppOpsManager.OP_WRITE_CLIPBOARD },
125            new boolean[] { true,
126                    true,
127                    true,
128                    true,
129                    true,
130                    true,
131                    false,
132                    false }
133            );
134
135    public static final OpsTemplate MESSAGING_TEMPLATE = new OpsTemplate(
136            new int[] { AppOpsManager.OP_READ_SMS,
137                    AppOpsManager.OP_RECEIVE_SMS,
138                    AppOpsManager.OP_RECEIVE_EMERGECY_SMS,
139                    AppOpsManager.OP_RECEIVE_MMS,
140                    AppOpsManager.OP_RECEIVE_WAP_PUSH,
141                    AppOpsManager.OP_WRITE_SMS,
142                    AppOpsManager.OP_SEND_SMS,
143                    AppOpsManager.OP_READ_ICC_SMS,
144                    AppOpsManager.OP_WRITE_ICC_SMS },
145            new boolean[] { true,
146                    true,
147                    true,
148                    true,
149                    true,
150                    true,
151                    true,
152                    true,
153                    true }
154            );
155
156    public static final OpsTemplate MEDIA_TEMPLATE = new OpsTemplate(
157            new int[] { AppOpsManager.OP_VIBRATE,
158                    AppOpsManager.OP_CAMERA,
159                    AppOpsManager.OP_RECORD_AUDIO,
160                    AppOpsManager.OP_PLAY_AUDIO,
161                    AppOpsManager.OP_TAKE_MEDIA_BUTTONS,
162                    AppOpsManager.OP_TAKE_AUDIO_FOCUS,
163                    AppOpsManager.OP_AUDIO_MASTER_VOLUME,
164                    AppOpsManager.OP_AUDIO_VOICE_VOLUME,
165                    AppOpsManager.OP_AUDIO_RING_VOLUME,
166                    AppOpsManager.OP_AUDIO_MEDIA_VOLUME,
167                    AppOpsManager.OP_AUDIO_ALARM_VOLUME,
168                    AppOpsManager.OP_AUDIO_NOTIFICATION_VOLUME,
169                    AppOpsManager.OP_AUDIO_BLUETOOTH_VOLUME,
170                    AppOpsManager.OP_MUTE_MICROPHONE},
171            new boolean[] { false,
172                    true,
173                    true,
174                    false,
175                    false,
176                    false,
177                    false,
178                    false,
179                    false,
180                    false,
181                    false,
182                    false,
183                    false }
184            );
185
186    public static final OpsTemplate DEVICE_TEMPLATE = new OpsTemplate(
187            new int[] { AppOpsManager.OP_POST_NOTIFICATION,
188                    AppOpsManager.OP_ACCESS_NOTIFICATIONS,
189                    AppOpsManager.OP_CALL_PHONE,
190                    AppOpsManager.OP_WRITE_SETTINGS,
191                    AppOpsManager.OP_SYSTEM_ALERT_WINDOW,
192                    AppOpsManager.OP_WAKE_LOCK,
193                    AppOpsManager.OP_PROJECT_MEDIA,
194                    AppOpsManager.OP_ACTIVATE_VPN,
195                    AppOpsManager.OP_ASSIST_STRUCTURE,
196                    AppOpsManager.OP_ASSIST_SCREENSHOT},
197            new boolean[] { false,
198                    true,
199                    true,
200                    true,
201                    true,
202                    true,
203                    false,
204                    false,
205                    false,
206                    false }
207            );
208
209    public static final OpsTemplate[] ALL_TEMPLATES = new OpsTemplate[] {
210            LOCATION_TEMPLATE, PERSONAL_TEMPLATE, MESSAGING_TEMPLATE,
211            MEDIA_TEMPLATE, DEVICE_TEMPLATE
212    };
213
214    /**
215     * This class holds the per-item data in our Loader.
216     */
217    public static class AppEntry {
218        private final AppOpsState mState;
219        private final ApplicationInfo mInfo;
220        private final File mApkFile;
221        private final SparseArray<AppOpsManager.OpEntry> mOps
222                = new SparseArray<AppOpsManager.OpEntry>();
223        private final SparseArray<AppOpEntry> mOpSwitches
224                = new SparseArray<AppOpEntry>();
225        private String mLabel;
226        private Drawable mIcon;
227        private boolean mMounted;
228
229        public AppEntry(AppOpsState state, ApplicationInfo info) {
230            mState = state;
231            mInfo = info;
232            mApkFile = new File(info.sourceDir);
233        }
234
235        public void addOp(AppOpEntry entry, AppOpsManager.OpEntry op) {
236            mOps.put(op.getOp(), op);
237            mOpSwitches.put(AppOpsManager.opToSwitch(op.getOp()), entry);
238        }
239
240        public boolean hasOp(int op) {
241            return mOps.indexOfKey(op) >= 0;
242        }
243
244        public AppOpEntry getOpSwitch(int op) {
245            return mOpSwitches.get(AppOpsManager.opToSwitch(op));
246        }
247
248        public ApplicationInfo getApplicationInfo() {
249            return mInfo;
250        }
251
252        public String getLabel() {
253            return mLabel;
254        }
255
256        public Drawable getIcon() {
257            if (mIcon == null) {
258                if (mApkFile.exists()) {
259                    mIcon = mInfo.loadIcon(mState.mPm);
260                    return mIcon;
261                } else {
262                    mMounted = false;
263                }
264            } else if (!mMounted) {
265                // If the app wasn't mounted but is now mounted, reload
266                // its icon.
267                if (mApkFile.exists()) {
268                    mMounted = true;
269                    mIcon = mInfo.loadIcon(mState.mPm);
270                    return mIcon;
271                }
272            } else {
273                return mIcon;
274            }
275
276            return mState.mContext.getDrawable(
277                    android.R.drawable.sym_def_app_icon);
278        }
279
280        @Override public String toString() {
281            return mLabel;
282        }
283
284        void loadLabel(Context context) {
285            if (mLabel == null || !mMounted) {
286                if (!mApkFile.exists()) {
287                    mMounted = false;
288                    mLabel = mInfo.packageName;
289                } else {
290                    mMounted = true;
291                    CharSequence label = mInfo.loadLabel(context.getPackageManager());
292                    mLabel = label != null ? label.toString() : mInfo.packageName;
293                }
294            }
295        }
296    }
297
298    /**
299     * This class holds the per-item data in our Loader.
300     */
301    public static class AppOpEntry {
302        private final AppOpsManager.PackageOps mPkgOps;
303        private final ArrayList<AppOpsManager.OpEntry> mOps
304                = new ArrayList<AppOpsManager.OpEntry>();
305        private final ArrayList<AppOpsManager.OpEntry> mSwitchOps
306                = new ArrayList<AppOpsManager.OpEntry>();
307        private final AppEntry mApp;
308        private final int mSwitchOrder;
309
310        public AppOpEntry(AppOpsManager.PackageOps pkg, AppOpsManager.OpEntry op, AppEntry app,
311                int switchOrder) {
312            mPkgOps = pkg;
313            mApp = app;
314            mSwitchOrder = switchOrder;
315            mApp.addOp(this, op);
316            mOps.add(op);
317            mSwitchOps.add(op);
318        }
319
320        private static void addOp(ArrayList<AppOpsManager.OpEntry> list, AppOpsManager.OpEntry op) {
321            for (int i=0; i<list.size(); i++) {
322                AppOpsManager.OpEntry pos = list.get(i);
323                if (pos.isRunning() != op.isRunning()) {
324                    if (op.isRunning()) {
325                        list.add(i, op);
326                        return;
327                    }
328                    continue;
329                }
330                if (pos.getTime() < op.getTime()) {
331                    list.add(i, op);
332                    return;
333                }
334            }
335            list.add(op);
336        }
337
338        public void addOp(AppOpsManager.OpEntry op) {
339            mApp.addOp(this, op);
340            addOp(mOps, op);
341            if (mApp.getOpSwitch(AppOpsManager.opToSwitch(op.getOp())) == null) {
342                addOp(mSwitchOps, op);
343            }
344        }
345
346        public AppEntry getAppEntry() {
347            return mApp;
348        }
349
350        public int getSwitchOrder() {
351            return mSwitchOrder;
352        }
353
354        public AppOpsManager.PackageOps getPackageOps() {
355            return mPkgOps;
356        }
357
358        public int getNumOpEntry() {
359            return mOps.size();
360        }
361
362        public AppOpsManager.OpEntry getOpEntry(int pos) {
363            return mOps.get(pos);
364        }
365
366        private CharSequence getCombinedText(ArrayList<AppOpsManager.OpEntry> ops,
367                CharSequence[] items) {
368            if (ops.size() == 1) {
369                return items[ops.get(0).getOp()];
370            } else {
371                StringBuilder builder = new StringBuilder();
372                for (int i=0; i<ops.size(); i++) {
373                    if (i > 0) {
374                        builder.append(", ");
375                    }
376                    builder.append(items[ops.get(i).getOp()]);
377                }
378                return builder.toString();
379            }
380        }
381
382        public CharSequence getSummaryText(AppOpsState state) {
383            return getCombinedText(mOps, state.mOpSummaries);
384        }
385
386        public CharSequence getSwitchText(AppOpsState state) {
387            if (mSwitchOps.size() > 0) {
388                return getCombinedText(mSwitchOps, state.mOpLabels);
389            } else {
390                return getCombinedText(mOps, state.mOpLabels);
391            }
392        }
393
394        public CharSequence getTimeText(Resources res, boolean showEmptyText) {
395            if (isRunning()) {
396                return res.getText(R.string.app_ops_running);
397            }
398            if (getTime() > 0) {
399                return DateUtils.getRelativeTimeSpanString(getTime(),
400                        System.currentTimeMillis(),
401                        DateUtils.MINUTE_IN_MILLIS,
402                        DateUtils.FORMAT_ABBREV_RELATIVE);
403            }
404            return showEmptyText ? res.getText(R.string.app_ops_never_used) : "";
405        }
406
407        public boolean isRunning() {
408            return mOps.get(0).isRunning();
409        }
410
411        public long getTime() {
412            return mOps.get(0).getTime();
413        }
414
415        @Override public String toString() {
416            return mApp.getLabel();
417        }
418    }
419
420    /**
421     * Perform alphabetical comparison of application entry objects.
422     */
423    public static final Comparator<AppOpEntry> APP_OP_COMPARATOR = new Comparator<AppOpEntry>() {
424        private final Collator sCollator = Collator.getInstance();
425        @Override
426        public int compare(AppOpEntry object1, AppOpEntry object2) {
427            if (object1.getSwitchOrder() != object2.getSwitchOrder()) {
428                return object1.getSwitchOrder() < object2.getSwitchOrder() ? -1 : 1;
429            }
430            if (object1.isRunning() != object2.isRunning()) {
431                // Currently running ops go first.
432                return object1.isRunning() ? -1 : 1;
433            }
434            if (object1.getTime() != object2.getTime()) {
435                // More recent times go first.
436                return object1.getTime() > object2.getTime() ? -1 : 1;
437            }
438            return sCollator.compare(object1.getAppEntry().getLabel(),
439                    object2.getAppEntry().getLabel());
440        }
441    };
442
443    private void addOp(List<AppOpEntry> entries, AppOpsManager.PackageOps pkgOps,
444            AppEntry appEntry, AppOpsManager.OpEntry opEntry, boolean allowMerge, int switchOrder) {
445        if (allowMerge && entries.size() > 0) {
446            AppOpEntry last = entries.get(entries.size()-1);
447            if (last.getAppEntry() == appEntry) {
448                boolean lastExe = last.getTime() != 0;
449                boolean entryExe = opEntry.getTime() != 0;
450                if (lastExe == entryExe) {
451                    if (DEBUG) Log.d(TAG, "Add op " + opEntry.getOp() + " to package "
452                            + pkgOps.getPackageName() + ": append to " + last);
453                    last.addOp(opEntry);
454                    return;
455                }
456            }
457        }
458        AppOpEntry entry = appEntry.getOpSwitch(opEntry.getOp());
459        if (entry != null) {
460            entry.addOp(opEntry);
461            return;
462        }
463        entry = new AppOpEntry(pkgOps, opEntry, appEntry, switchOrder);
464        if (DEBUG) Log.d(TAG, "Add op " + opEntry.getOp() + " to package "
465                + pkgOps.getPackageName() + ": making new " + entry);
466        entries.add(entry);
467    }
468
469    public List<AppOpEntry> buildState(OpsTemplate tpl) {
470        return buildState(tpl, 0, null);
471    }
472
473    private AppEntry getAppEntry(final Context context, final HashMap<String, AppEntry> appEntries,
474            final String packageName, ApplicationInfo appInfo) {
475        AppEntry appEntry = appEntries.get(packageName);
476        if (appEntry == null) {
477            if (appInfo == null) {
478                try {
479                    appInfo = mPm.getApplicationInfo(packageName,
480                            PackageManager.GET_DISABLED_COMPONENTS
481                            | PackageManager.GET_UNINSTALLED_PACKAGES);
482                } catch (PackageManager.NameNotFoundException e) {
483                    Log.w(TAG, "Unable to find info for package " + packageName);
484                    return null;
485                }
486            }
487            appEntry = new AppEntry(this, appInfo);
488            appEntry.loadLabel(context);
489            appEntries.put(packageName, appEntry);
490        }
491        return appEntry;
492    }
493
494    public List<AppOpEntry> buildState(OpsTemplate tpl, int uid, String packageName) {
495        final Context context = mContext;
496
497        final HashMap<String, AppEntry> appEntries = new HashMap<String, AppEntry>();
498        final List<AppOpEntry> entries = new ArrayList<AppOpEntry>();
499
500        final ArrayList<String> perms = new ArrayList<String>();
501        final ArrayList<Integer> permOps = new ArrayList<Integer>();
502        final int[] opToOrder = new int[AppOpsManager._NUM_OP];
503        for (int i=0; i<tpl.ops.length; i++) {
504            if (tpl.showPerms[i]) {
505                String perm = AppOpsManager.opToPermission(tpl.ops[i]);
506                if (perm != null && !perms.contains(perm)) {
507                    perms.add(perm);
508                    permOps.add(tpl.ops[i]);
509                    opToOrder[tpl.ops[i]] = i;
510                }
511            }
512        }
513
514        List<AppOpsManager.PackageOps> pkgs;
515        if (packageName != null) {
516            pkgs = mAppOps.getOpsForPackage(uid, packageName, tpl.ops);
517        } else {
518            pkgs = mAppOps.getPackagesForOps(tpl.ops);
519        }
520
521        if (pkgs != null) {
522            for (int i=0; i<pkgs.size(); i++) {
523                AppOpsManager.PackageOps pkgOps = pkgs.get(i);
524                AppEntry appEntry = getAppEntry(context, appEntries, pkgOps.getPackageName(), null);
525                if (appEntry == null) {
526                    continue;
527                }
528                for (int j=0; j<pkgOps.getOps().size(); j++) {
529                    AppOpsManager.OpEntry opEntry = pkgOps.getOps().get(j);
530                    addOp(entries, pkgOps, appEntry, opEntry, packageName == null,
531                            packageName == null ? 0 : opToOrder[opEntry.getOp()]);
532                }
533            }
534        }
535
536        List<PackageInfo> apps;
537        if (packageName != null) {
538            apps = new ArrayList<PackageInfo>();
539            try {
540                PackageInfo pi = mPm.getPackageInfo(packageName, PackageManager.GET_PERMISSIONS);
541                apps.add(pi);
542            } catch (NameNotFoundException e) {
543            }
544        } else {
545            String[] permsArray = new String[perms.size()];
546            perms.toArray(permsArray);
547            apps = mPm.getPackagesHoldingPermissions(permsArray, 0);
548        }
549        for (int i=0; i<apps.size(); i++) {
550            PackageInfo appInfo = apps.get(i);
551            AppEntry appEntry = getAppEntry(context, appEntries, appInfo.packageName,
552                    appInfo.applicationInfo);
553            if (appEntry == null) {
554                continue;
555            }
556            List<AppOpsManager.OpEntry> dummyOps = null;
557            AppOpsManager.PackageOps pkgOps = null;
558            if (appInfo.requestedPermissions != null) {
559                for (int j=0; j<appInfo.requestedPermissions.length; j++) {
560                    if (appInfo.requestedPermissionsFlags != null) {
561                        if ((appInfo.requestedPermissionsFlags[j]
562                                & PackageInfo.REQUESTED_PERMISSION_GRANTED) == 0) {
563                            if (DEBUG) Log.d(TAG, "Pkg " + appInfo.packageName + " perm "
564                                    + appInfo.requestedPermissions[j] + " not granted; skipping");
565                            continue;
566                        }
567                    }
568                    if (DEBUG) Log.d(TAG, "Pkg " + appInfo.packageName + ": requested perm "
569                            + appInfo.requestedPermissions[j]);
570                    for (int k=0; k<perms.size(); k++) {
571                        if (!perms.get(k).equals(appInfo.requestedPermissions[j])) {
572                            continue;
573                        }
574                        if (DEBUG) Log.d(TAG, "Pkg " + appInfo.packageName + " perm " + perms.get(k)
575                                + " has op " + permOps.get(k) + ": " + appEntry.hasOp(permOps.get(k)));
576                        if (appEntry.hasOp(permOps.get(k))) {
577                            continue;
578                        }
579                        if (dummyOps == null) {
580                            dummyOps = new ArrayList<AppOpsManager.OpEntry>();
581                            pkgOps = new AppOpsManager.PackageOps(
582                                    appInfo.packageName, appInfo.applicationInfo.uid, dummyOps);
583
584                        }
585                        AppOpsManager.OpEntry opEntry = new AppOpsManager.OpEntry(
586                                permOps.get(k), AppOpsManager.MODE_ALLOWED, 0, 0, 0, -1, null);
587                        dummyOps.add(opEntry);
588                        addOp(entries, pkgOps, appEntry, opEntry, packageName == null,
589                                packageName == null ? 0 : opToOrder[opEntry.getOp()]);
590                    }
591                }
592            }
593        }
594
595        // Sort the list.
596        Collections.sort(entries, APP_OP_COMPARATOR);
597
598        // Done!
599        return entries;
600    }
601}
602