Home | History | Annotate | Download | only in widget 
      1 /*
      2 **
      3 ** Copyright 2007, The Android Open Source Project
      4 **
      5 ** Licensed under the Apache License, Version 2.0 (the "License");
      6 ** you may not use this file except in compliance with the License.
      7 ** You may obtain a copy of the License at
      8 **
      9 **     http://www.apache.org/licenses/LICENSE-2.0
     10 **
     11 ** Unless required by applicable law or agreed to in writing, software
     12 ** distributed under the License is distributed on an "AS IS" BASIS,
     13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     14 ** See the License for the specific language governing permissions and
     15 ** limitations under the License.
     16 */
     17 package android.widget;
     18 
     19 import android.app.AlertDialog;
     20 import android.content.Context;
     21 import android.content.DialogInterface;
     22 import android.content.pm.ApplicationInfo;
     23 import android.content.pm.PackageInfo;
     24 import android.content.pm.PackageItemInfo;
     25 import android.content.pm.PackageManager;
     26 import android.content.pm.PackageManager.NameNotFoundException;
     27 import android.content.pm.PermissionGroupInfo;
     28 import android.content.pm.PermissionInfo;
     29 import android.graphics.drawable.Drawable;
     30 import android.os.Parcel;
     31 import android.os.UserHandle;
     32 import android.text.SpannableStringBuilder;
     33 import android.text.TextUtils;
     34 import android.util.AttributeSet;
     35 import android.util.Log;
     36 import android.view.LayoutInflater;
     37 import android.view.View;
     38 import android.view.ViewGroup;
     39 
     40 import com.android.internal.R;
     41 
     42 import java.text.Collator;
     43 import java.util.ArrayList;
     44 import java.util.Collections;
     45 import java.util.Comparator;
     46 import java.util.HashMap;
     47 import java.util.HashSet;
     48 import java.util.List;
     49 import java.util.Map;
     50 import java.util.Set;
     51 
     52 /**
     53  * This class contains the SecurityPermissions view implementation.
     54  * Initially the package's advanced or dangerous security permissions
     55  * are displayed under categorized
     56  * groups. Clicking on the additional permissions presents
     57  * extended information consisting of all groups and permissions.
     58  * To use this view define a LinearLayout or any ViewGroup and add this
     59  * view by instantiating AppSecurityPermissions and invoking getPermissionsView.
     60  *
     61  * {@hide}
     62  */
     63 public class AppSecurityPermissions {
     64 
     65     public static final int WHICH_NEW = 1<<2;
     66     public static final int WHICH_ALL = 0xffff;
     67 
     68     private final static String TAG = "AppSecurityPermissions";
     69     private final static boolean localLOGV = false;
     70     private final Context mContext;
     71     private final LayoutInflater mInflater;
     72     private final PackageManager mPm;
     73     private final Map<String, MyPermissionGroupInfo> mPermGroups
     74             = new HashMap<String, MyPermissionGroupInfo>();
     75     private final List<MyPermissionGroupInfo> mPermGroupsList
     76             = new ArrayList<MyPermissionGroupInfo>();
     77     private final PermissionGroupInfoComparator mPermGroupComparator =
     78             new PermissionGroupInfoComparator();
     79     private final PermissionInfoComparator mPermComparator = new PermissionInfoComparator();
     80     private final List<MyPermissionInfo> mPermsList = new ArrayList<MyPermissionInfo>();
     81     private final CharSequence mNewPermPrefix;
     82     private String mPackageName;
     83 
     84     /** @hide */
     85     static class MyPermissionGroupInfo extends PermissionGroupInfo {
     86         CharSequence mLabel;
     87 
     88         final ArrayList<MyPermissionInfo> mNewPermissions = new ArrayList<MyPermissionInfo>();
     89         final ArrayList<MyPermissionInfo> mAllPermissions = new ArrayList<MyPermissionInfo>();
     90 
     91         MyPermissionGroupInfo(PermissionInfo perm) {
     92             name = perm.packageName;
     93             packageName = perm.packageName;
     94         }
     95 
     96         MyPermissionGroupInfo(PermissionGroupInfo info) {
     97             super(info);
     98         }
     99 
    100         public Drawable loadGroupIcon(Context context, PackageManager pm) {
    101             if (icon != 0) {
    102                 return loadUnbadgedIcon(pm);
    103             } else {
    104                 return context.getDrawable(R.drawable.ic_perm_device_info);
    105             }
    106         }
    107     }
    108 
    109     /** @hide */
    110     private static class MyPermissionInfo extends PermissionInfo {
    111         CharSequence mLabel;
    112 
    113         /**
    114          * PackageInfo.requestedPermissionsFlags for the new package being installed.
    115          */
    116         int mNewReqFlags;
    117 
    118         /**
    119          * PackageInfo.requestedPermissionsFlags for the currently installed
    120          * package, if it is installed.
    121          */
    122         int mExistingReqFlags;
    123 
    124         /**
    125          * True if this should be considered a new permission.
    126          */
    127         boolean mNew;
    128 
    129         MyPermissionInfo(PermissionInfo info) {
    130             super(info);
    131         }
    132     }
    133 
    134     /** @hide */
    135     public static class PermissionItemView extends LinearLayout implements View.OnClickListener {
    136         MyPermissionGroupInfo mGroup;
    137         MyPermissionInfo mPerm;
    138         AlertDialog mDialog;
    139         private boolean mShowRevokeUI = false;
    140         private String mPackageName;
    141 
    142         public PermissionItemView(Context context, AttributeSet attrs) {
    143             super(context, attrs);
    144             setClickable(true);
    145         }
    146 
    147         public void setPermission(MyPermissionGroupInfo grp, MyPermissionInfo perm,
    148                 boolean first, CharSequence newPermPrefix, String packageName,
    149                 boolean showRevokeUI) {
    150             mGroup = grp;
    151             mPerm = perm;
    152             mShowRevokeUI = showRevokeUI;
    153             mPackageName = packageName;
    154 
    155             ImageView permGrpIcon = findViewById(R.id.perm_icon);
    156             TextView permNameView = findViewById(R.id.perm_name);
    157 
    158             PackageManager pm = getContext().getPackageManager();
    159             Drawable icon = null;
    160             if (first) {
    161                 icon = grp.loadGroupIcon(getContext(), pm);
    162             }
    163             CharSequence label = perm.mLabel;
    164             if (perm.mNew && newPermPrefix != null) {
    165                 // If this is a new permission, format it appropriately.
    166                 SpannableStringBuilder builder = new SpannableStringBuilder();
    167                 Parcel parcel = Parcel.obtain();
    168                 TextUtils.writeToParcel(newPermPrefix, parcel, 0);
    169                 parcel.setDataPosition(0);
    170                 CharSequence newStr = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(parcel);
    171                 parcel.recycle();
    172                 builder.append(newStr);
    173                 builder.append(label);
    174                 label = builder;
    175             }
    176 
    177             permGrpIcon.setImageDrawable(icon);
    178             permNameView.setText(label);
    179             setOnClickListener(this);
    180             if (localLOGV) Log.i(TAG, "Made perm item " + perm.name
    181                     + ": " + label + " in group " + grp.name);
    182         }
    183 
    184         @Override
    185         public void onClick(View v) {
    186             if (mGroup != null && mPerm != null) {
    187                 if (mDialog != null) {
    188                     mDialog.dismiss();
    189                 }
    190                 PackageManager pm = getContext().getPackageManager();
    191                 AlertDialog.Builder builder = new AlertDialog.Builder(getContext());
    192                 builder.setTitle(mGroup.mLabel);
    193                 if (mPerm.descriptionRes != 0) {
    194                     builder.setMessage(mPerm.loadDescription(pm));
    195                 } else {
    196                     CharSequence appName;
    197                     try {
    198                         ApplicationInfo app = pm.getApplicationInfo(mPerm.packageName, 0);
    199                         appName = app.loadLabel(pm);
    200                     } catch (NameNotFoundException e) {
    201                         appName = mPerm.packageName;
    202                     }
    203                     StringBuilder sbuilder = new StringBuilder(128);
    204                     sbuilder.append(getContext().getString(
    205                             R.string.perms_description_app, appName));
    206                     sbuilder.append("\n\n");
    207                     sbuilder.append(mPerm.name);
    208                     builder.setMessage(sbuilder.toString());
    209                 }
    210                 builder.setCancelable(true);
    211                 builder.setIcon(mGroup.loadGroupIcon(getContext(), pm));
    212                 addRevokeUIIfNecessary(builder);
    213                 mDialog = builder.show();
    214                 mDialog.setCanceledOnTouchOutside(true);
    215             }
    216         }
    217 
    218         @Override
    219         protected void onDetachedFromWindow() {
    220             super.onDetachedFromWindow();
    221             if (mDialog != null) {
    222                 mDialog.dismiss();
    223             }
    224         }
    225 
    226         private void addRevokeUIIfNecessary(AlertDialog.Builder builder) {
    227             if (!mShowRevokeUI) {
    228                 return;
    229             }
    230 
    231             final boolean isRequired =
    232                     ((mPerm.mExistingReqFlags & PackageInfo.REQUESTED_PERMISSION_REQUIRED) != 0);
    233 
    234             if (isRequired) {
    235                 return;
    236             }
    237 
    238             DialogInterface.OnClickListener ocl = new DialogInterface.OnClickListener() {
    239                 @Override
    240                 public void onClick(DialogInterface dialog, int which) {
    241                     PackageManager pm = getContext().getPackageManager();
    242                     pm.revokeRuntimePermission(mPackageName, mPerm.name,
    243                             new UserHandle(mContext.getUserId()));
    244                     PermissionItemView.this.setVisibility(View.GONE);
    245                 }
    246             };
    247             builder.setNegativeButton(R.string.revoke, ocl);
    248             builder.setPositiveButton(R.string.ok, null);
    249         }
    250     }
    251 
    252     private AppSecurityPermissions(Context context) {
    253         mContext = context;
    254         mInflater = (LayoutInflater) mContext.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
    255         mPm = mContext.getPackageManager();
    256         // Pick up from framework resources instead.
    257         mNewPermPrefix = mContext.getText(R.string.perms_new_perm_prefix);
    258     }
    259 
    260     public AppSecurityPermissions(Context context, String packageName) {
    261         this(context);
    262         mPackageName = packageName;
    263         Set<MyPermissionInfo> permSet = new HashSet<MyPermissionInfo>();
    264         PackageInfo pkgInfo;
    265         try {
    266             pkgInfo = mPm.getPackageInfo(packageName, PackageManager.GET_PERMISSIONS);
    267         } catch (NameNotFoundException e) {
    268             Log.w(TAG, "Couldn't retrieve permissions for package:"+packageName);
    269             return;
    270         }
    271         // Extract all user permissions
    272         if((pkgInfo.applicationInfo != null) && (pkgInfo.applicationInfo.uid != -1)) {
    273             getAllUsedPermissions(pkgInfo.applicationInfo.uid, permSet);
    274         }
    275         mPermsList.addAll(permSet);
    276         setPermissions(mPermsList);
    277     }
    278 
    279     public AppSecurityPermissions(Context context, PackageInfo info) {
    280         this(context);
    281         Set<MyPermissionInfo> permSet = new HashSet<MyPermissionInfo>();
    282         if(info == null) {
    283             return;
    284         }
    285         mPackageName = info.packageName;
    286 
    287         // Convert to a PackageInfo
    288         PackageInfo installedPkgInfo = null;
    289         // Get requested permissions
    290         if (info.requestedPermissions != null) {
    291             try {
    292                 installedPkgInfo = mPm.getPackageInfo(info.packageName,
    293                         PackageManager.GET_PERMISSIONS);
    294             } catch (NameNotFoundException e) {
    295             }
    296             extractPerms(info, permSet, installedPkgInfo);
    297         }
    298         // Get permissions related to shared user if any
    299         if (info.sharedUserId != null) {
    300             int sharedUid;
    301             try {
    302                 sharedUid = mPm.getUidForSharedUser(info.sharedUserId);
    303                 getAllUsedPermissions(sharedUid, permSet);
    304             } catch (NameNotFoundException e) {
    305                 Log.w(TAG, "Couldn't retrieve shared user id for: " + info.packageName);
    306             }
    307         }
    308         // Retrieve list of permissions
    309         mPermsList.addAll(permSet);
    310         setPermissions(mPermsList);
    311     }
    312 
    313     /**
    314      * Utility to retrieve a view displaying a single permission.  This provides
    315      * the old UI layout for permissions; it is only here for the device admin
    316      * settings to continue to use.
    317      */
    318     public static View getPermissionItemView(Context context,
    319             CharSequence grpName, CharSequence description, boolean dangerous) {
    320         LayoutInflater inflater = (LayoutInflater)context.getSystemService(
    321                 Context.LAYOUT_INFLATER_SERVICE);
    322         Drawable icon = context.getDrawable(dangerous
    323                 ? R.drawable.ic_bullet_key_permission : R.drawable.ic_text_dot);
    324         return getPermissionItemViewOld(context, inflater, grpName,
    325                 description, dangerous, icon);
    326     }
    327 
    328     private void getAllUsedPermissions(int sharedUid, Set<MyPermissionInfo> permSet) {
    329         String sharedPkgList[] = mPm.getPackagesForUid(sharedUid);
    330         if(sharedPkgList == null || (sharedPkgList.length == 0)) {
    331             return;
    332         }
    333         for(String sharedPkg : sharedPkgList) {
    334             getPermissionsForPackage(sharedPkg, permSet);
    335         }
    336     }
    337 
    338     private void getPermissionsForPackage(String packageName, Set<MyPermissionInfo> permSet) {
    339         try {
    340             PackageInfo pkgInfo = mPm.getPackageInfo(packageName, PackageManager.GET_PERMISSIONS);
    341             extractPerms(pkgInfo, permSet, pkgInfo);
    342         } catch (NameNotFoundException e) {
    343             Log.w(TAG, "Couldn't retrieve permissions for package: " + packageName);
    344         }
    345     }
    346 
    347     private void extractPerms(PackageInfo info, Set<MyPermissionInfo> permSet,
    348             PackageInfo installedPkgInfo) {
    349         String[] strList = info.requestedPermissions;
    350         int[] flagsList = info.requestedPermissionsFlags;
    351         if ((strList == null) || (strList.length == 0)) {
    352             return;
    353         }
    354         for (int i=0; i<strList.length; i++) {
    355             String permName = strList[i];
    356             try {
    357                 PermissionInfo tmpPermInfo = mPm.getPermissionInfo(permName, 0);
    358                 if (tmpPermInfo == null) {
    359                     continue;
    360                 }
    361                 int existingIndex = -1;
    362                 if (installedPkgInfo != null
    363                         && installedPkgInfo.requestedPermissions != null) {
    364                     for (int j=0; j<installedPkgInfo.requestedPermissions.length; j++) {
    365                         if (permName.equals(installedPkgInfo.requestedPermissions[j])) {
    366                             existingIndex = j;
    367                             break;
    368                         }
    369                     }
    370                 }
    371                 final int existingFlags = existingIndex >= 0 ?
    372                         installedPkgInfo.requestedPermissionsFlags[existingIndex] : 0;
    373                 if (!isDisplayablePermission(tmpPermInfo, flagsList[i], existingFlags)) {
    374                     // This is not a permission that is interesting for the user
    375                     // to see, so skip it.
    376                     continue;
    377                 }
    378                 final String origGroupName = tmpPermInfo.group;
    379                 String groupName = origGroupName;
    380                 if (groupName == null) {
    381                     groupName = tmpPermInfo.packageName;
    382                     tmpPermInfo.group = groupName;
    383                 }
    384                 MyPermissionGroupInfo group = mPermGroups.get(groupName);
    385                 if (group == null) {
    386                     PermissionGroupInfo grp = null;
    387                     if (origGroupName != null) {
    388                         grp = mPm.getPermissionGroupInfo(origGroupName, 0);
    389                     }
    390                     if (grp != null) {
    391                         group = new MyPermissionGroupInfo(grp);
    392                     } else {
    393                         // We could be here either because the permission
    394                         // didn't originally specify a group or the group it
    395                         // gave couldn't be found.  In either case, we consider
    396                         // its group to be the permission's package name.
    397                         tmpPermInfo.group = tmpPermInfo.packageName;
    398                         group = mPermGroups.get(tmpPermInfo.group);
    399                         if (group == null) {
    400                             group = new MyPermissionGroupInfo(tmpPermInfo);
    401                         }
    402                         group = new MyPermissionGroupInfo(tmpPermInfo);
    403                     }
    404                     mPermGroups.put(tmpPermInfo.group, group);
    405                 }
    406                 final boolean newPerm = installedPkgInfo != null
    407                         && (existingFlags&PackageInfo.REQUESTED_PERMISSION_GRANTED) == 0;
    408                 MyPermissionInfo myPerm = new MyPermissionInfo(tmpPermInfo);
    409                 myPerm.mNewReqFlags = flagsList[i];
    410                 myPerm.mExistingReqFlags = existingFlags;
    411                 // This is a new permission if the app is already installed and
    412                 // doesn't currently hold this permission.
    413                 myPerm.mNew = newPerm;
    414                 permSet.add(myPerm);
    415             } catch (NameNotFoundException e) {
    416                 Log.i(TAG, "Ignoring unknown permission:"+permName);
    417             }
    418         }
    419     }
    420 
    421     public int getPermissionCount() {
    422         return getPermissionCount(WHICH_ALL);
    423     }
    424 
    425     private List<MyPermissionInfo> getPermissionList(MyPermissionGroupInfo grp, int which) {
    426         if (which == WHICH_NEW) {
    427             return grp.mNewPermissions;
    428         } else {
    429             return grp.mAllPermissions;
    430         }
    431     }
    432 
    433     public int getPermissionCount(int which) {
    434         int N = 0;
    435         for (int i=0; i<mPermGroupsList.size(); i++) {
    436             N += getPermissionList(mPermGroupsList.get(i), which).size();
    437         }
    438         return N;
    439     }
    440 
    441     public View getPermissionsView() {
    442         return getPermissionsView(WHICH_ALL, false);
    443     }
    444 
    445     public View getPermissionsViewWithRevokeButtons() {
    446         return getPermissionsView(WHICH_ALL, true);
    447     }
    448 
    449     public View getPermissionsView(int which) {
    450         return getPermissionsView(which, false);
    451     }
    452 
    453     private View getPermissionsView(int which, boolean showRevokeUI) {
    454         LinearLayout permsView = (LinearLayout) mInflater.inflate(R.layout.app_perms_summary, null);
    455         LinearLayout displayList = permsView.findViewById(R.id.perms_list);
    456         View noPermsView = permsView.findViewById(R.id.no_permissions);
    457 
    458         displayPermissions(mPermGroupsList, displayList, which, showRevokeUI);
    459         if (displayList.getChildCount() <= 0) {
    460             noPermsView.setVisibility(View.VISIBLE);
    461         }
    462 
    463         return permsView;
    464     }
    465 
    466     /**
    467      * Utility method that displays permissions from a map containing group name and
    468      * list of permission descriptions.
    469      */
    470     private void displayPermissions(List<MyPermissionGroupInfo> groups,
    471             LinearLayout permListView, int which, boolean showRevokeUI) {
    472         permListView.removeAllViews();
    473 
    474         int spacing = (int)(8*mContext.getResources().getDisplayMetrics().density);
    475 
    476         for (int i=0; i<groups.size(); i++) {
    477             MyPermissionGroupInfo grp = groups.get(i);
    478             final List<MyPermissionInfo> perms = getPermissionList(grp, which);
    479             for (int j=0; j<perms.size(); j++) {
    480                 MyPermissionInfo perm = perms.get(j);
    481                 View view = getPermissionItemView(grp, perm, j == 0,
    482                         which != WHICH_NEW ? mNewPermPrefix : null, showRevokeUI);
    483                 LinearLayout.LayoutParams lp = new LinearLayout.LayoutParams(
    484                         ViewGroup.LayoutParams.MATCH_PARENT,
    485                         ViewGroup.LayoutParams.WRAP_CONTENT);
    486                 if (j == 0) {
    487                     lp.topMargin = spacing;
    488                 }
    489                 if (j == grp.mAllPermissions.size()-1) {
    490                     lp.bottomMargin = spacing;
    491                 }
    492                 if (permListView.getChildCount() == 0) {
    493                     lp.topMargin *= 2;
    494                 }
    495                 permListView.addView(view, lp);
    496             }
    497         }
    498     }
    499 
    500     private PermissionItemView getPermissionItemView(MyPermissionGroupInfo grp,
    501             MyPermissionInfo perm, boolean first, CharSequence newPermPrefix, boolean showRevokeUI) {
    502         return getPermissionItemView(mContext, mInflater, grp, perm, first, newPermPrefix,
    503                 mPackageName, showRevokeUI);
    504     }
    505 
    506     private static PermissionItemView getPermissionItemView(Context context, LayoutInflater inflater,
    507             MyPermissionGroupInfo grp, MyPermissionInfo perm, boolean first,
    508             CharSequence newPermPrefix, String packageName, boolean showRevokeUI) {
    509             PermissionItemView permView = (PermissionItemView)inflater.inflate(
    510                 (perm.flags & PermissionInfo.FLAG_COSTS_MONEY) != 0
    511                         ? R.layout.app_permission_item_money : R.layout.app_permission_item,
    512                 null);
    513         permView.setPermission(grp, perm, first, newPermPrefix, packageName, showRevokeUI);
    514         return permView;
    515     }
    516 
    517     private static View getPermissionItemViewOld(Context context, LayoutInflater inflater,
    518             CharSequence grpName, CharSequence permList, boolean dangerous, Drawable icon) {
    519         View permView = inflater.inflate(R.layout.app_permission_item_old, null);
    520 
    521         TextView permGrpView = permView.findViewById(R.id.permission_group);
    522         TextView permDescView = permView.findViewById(R.id.permission_list);
    523 
    524         ImageView imgView = (ImageView)permView.findViewById(R.id.perm_icon);
    525         imgView.setImageDrawable(icon);
    526         if(grpName != null) {
    527             permGrpView.setText(grpName);
    528             permDescView.setText(permList);
    529         } else {
    530             permGrpView.setText(permList);
    531             permDescView.setVisibility(View.GONE);
    532         }
    533         return permView;
    534     }
    535 
    536     private boolean isDisplayablePermission(PermissionInfo pInfo, int newReqFlags,
    537             int existingReqFlags) {
    538         final int base = pInfo.protectionLevel & PermissionInfo.PROTECTION_MASK_BASE;
    539         final boolean isNormal = (base == PermissionInfo.PROTECTION_NORMAL);
    540 
    541         // We do not show normal permissions in the UI.
    542         if (isNormal) {
    543             return false;
    544         }
    545 
    546         final boolean isDangerous = (base == PermissionInfo.PROTECTION_DANGEROUS)
    547                 || ((pInfo.protectionLevel&PermissionInfo.PROTECTION_FLAG_PRE23) != 0);
    548         final boolean isRequired =
    549                 ((newReqFlags&PackageInfo.REQUESTED_PERMISSION_REQUIRED) != 0);
    550         final boolean isDevelopment =
    551                 ((pInfo.protectionLevel&PermissionInfo.PROTECTION_FLAG_DEVELOPMENT) != 0);
    552         final boolean wasGranted =
    553                 ((existingReqFlags&PackageInfo.REQUESTED_PERMISSION_GRANTED) != 0);
    554         final boolean isGranted =
    555                 ((newReqFlags&PackageInfo.REQUESTED_PERMISSION_GRANTED) != 0);
    556 
    557         // Dangerous and normal permissions are always shown to the user if the permission
    558         // is required, or it was previously granted
    559         if (isDangerous && (isRequired || wasGranted || isGranted)) {
    560             return true;
    561         }
    562 
    563         // Development permissions are only shown to the user if they are already
    564         // granted to the app -- if we are installing an app and they are not
    565         // already granted, they will not be granted as part of the install.
    566         if (isDevelopment && wasGranted) {
    567             if (localLOGV) Log.i(TAG, "Special perm " + pInfo.name
    568                     + ": protlevel=0x" + Integer.toHexString(pInfo.protectionLevel));
    569             return true;
    570         }
    571         return false;
    572     }
    573 
    574     private static class PermissionGroupInfoComparator implements Comparator<MyPermissionGroupInfo> {
    575         private final Collator sCollator = Collator.getInstance();
    576         @Override
    577         public final int compare(MyPermissionGroupInfo a, MyPermissionGroupInfo b) {
    578             return sCollator.compare(a.mLabel, b.mLabel);
    579         }
    580     }
    581 
    582     private static class PermissionInfoComparator implements Comparator<MyPermissionInfo> {
    583         private final Collator sCollator = Collator.getInstance();
    584         PermissionInfoComparator() {
    585         }
    586         public final int compare(MyPermissionInfo a, MyPermissionInfo b) {
    587             return sCollator.compare(a.mLabel, b.mLabel);
    588         }
    589     }
    590 
    591     private void addPermToList(List<MyPermissionInfo> permList,
    592             MyPermissionInfo pInfo) {
    593         if (pInfo.mLabel == null) {
    594             pInfo.mLabel = pInfo.loadSafeLabel(mPm, 20000, PackageItemInfo.SAFE_LABEL_FLAG_TRIM
    595                     | PackageItemInfo.SAFE_LABEL_FLAG_FIRST_LINE);
    596         }
    597         int idx = Collections.binarySearch(permList, pInfo, mPermComparator);
    598         if(localLOGV) Log.i(TAG, "idx="+idx+", list.size="+permList.size());
    599         if (idx < 0) {
    600             idx = -idx-1;
    601             permList.add(idx, pInfo);
    602         }
    603     }
    604 
    605     private void setPermissions(List<MyPermissionInfo> permList) {
    606         if (permList != null) {
    607             // First pass to group permissions
    608             for (MyPermissionInfo pInfo : permList) {
    609                 if(localLOGV) Log.i(TAG, "Processing permission:"+pInfo.name);
    610                 if(!isDisplayablePermission(pInfo, pInfo.mNewReqFlags, pInfo.mExistingReqFlags)) {
    611                     if(localLOGV) Log.i(TAG, "Permission:"+pInfo.name+" is not displayable");
    612                     continue;
    613                 }
    614                 MyPermissionGroupInfo group = mPermGroups.get(pInfo.group);
    615                 if (group != null) {
    616                     pInfo.mLabel = pInfo.loadSafeLabel(mPm, 20000,
    617                             PackageItemInfo.SAFE_LABEL_FLAG_TRIM
    618                             | PackageItemInfo.SAFE_LABEL_FLAG_FIRST_LINE);
    619                     addPermToList(group.mAllPermissions, pInfo);
    620                     if (pInfo.mNew) {
    621                         addPermToList(group.mNewPermissions, pInfo);
    622                     }
    623                 }
    624             }
    625         }
    626 
    627         for (MyPermissionGroupInfo pgrp : mPermGroups.values()) {
    628             if (pgrp.labelRes != 0 || pgrp.nonLocalizedLabel != null) {
    629                 pgrp.mLabel = pgrp.loadSafeLabel(mPm, 20000, PackageItemInfo.SAFE_LABEL_FLAG_TRIM
    630                         | PackageItemInfo.SAFE_LABEL_FLAG_FIRST_LINE);
    631             } else {
    632                 ApplicationInfo app;
    633                 try {
    634                     app = mPm.getApplicationInfo(pgrp.packageName, 0);
    635                     pgrp.mLabel = app.loadSafeLabel(mPm, 20000, PackageItemInfo.SAFE_LABEL_FLAG_TRIM
    636                             | PackageItemInfo.SAFE_LABEL_FLAG_FIRST_LINE);
    637                 } catch (NameNotFoundException e) {
    638                     pgrp.mLabel = pgrp.loadSafeLabel(mPm, 20000,
    639                             PackageItemInfo.SAFE_LABEL_FLAG_TRIM
    640                             | PackageItemInfo.SAFE_LABEL_FLAG_FIRST_LINE);
    641                 }
    642             }
    643             mPermGroupsList.add(pgrp);
    644         }
    645         Collections.sort(mPermGroupsList, mPermGroupComparator);
    646     }
    647 }
    648