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