Merge "Add PermissionsInfo to SettingsLib"

/*

 * Copyright (C) 2015 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

package com.android.settingslib.applications;

import android.content.Context;

import android.content.pm.PackageInfo;

import android.content.pm.PackageManager;

import android.content.pm.PackageManager.NameNotFoundException;

import android.content.pm.PermissionGroupInfo;

import android.content.pm.PermissionInfo;

import android.graphics.drawable.Drawable;

import android.graphics.drawable.ShapeDrawable;

import android.os.AsyncTask;

import android.os.Build;

import android.os.UserHandle;

import android.os.UserManager;

import android.util.ArrayMap;

import android.util.Log;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

import java.util.Map;

public class PermissionsInfo {

    private static final String TAG = "PermissionsInfo";

    private final PackageManager mPm;

    private final ArrayList<PermissionGroup> mGroups = new ArrayList<>();

    private final Map<String, PermissionGroup> mGroupLookup = new ArrayMap<>();

    private final Callback mCallback;

    private final Context mContext;

    // Count of apps that request runtime permissions.

    private int mRuntimePermAppsCt;

    // Count of apps that are granted runtime permissions.

    private int mRuntimePermAppsGrantedCt;

    public PermissionsInfo(Context context, Callback callback) {

        mContext = context;

        mPm = context.getPackageManager();

        mCallback = callback;

        new PermissionsLoader().execute();

    }

    public List<PermissionGroup> getGroups() {

        synchronized (mGroups) {

            return new ArrayList<>(mGroups);

        }

    }

    public int getRuntimePermAppsCount() {

        return mRuntimePermAppsCt;

    }

    public int getRuntimePermAppsGrantedCount() {

        return mRuntimePermAppsGrantedCt;

    }

    private PermissionGroup getOrCreateGroup(String permission) {

        PermissionGroup group = mGroupLookup.get(permission);

        if (group == null) {

            // Some permissions don't have a group, in that case treat them like a group

            // and create their own PermissionGroup (only if they are runtime).

            try {

                PermissionInfo info = mPm.getPermissionInfo(permission, 0);

                if (info.protectionLevel == PermissionInfo.PROTECTION_DANGEROUS) {

                    group = new PermissionGroup();

                    // TODO: Add default permission icon.

                    group.icon = info.icon != 0 ? info.loadIcon(mPm) : new ShapeDrawable();

                    group.name = info.name;

                    group.label = info.loadLabel(mPm).toString();

                    mGroups.add(group);

                    mGroupLookup.put(permission, group);

                }

            } catch (NameNotFoundException e) {

                Log.w(TAG, "Unknown permission " + permission, e);

            }

        }

        return group;

    }

    private class PermissionsLoader extends AsyncTask<Void, Void, Void> {

        @Override

        protected Void doInBackground(Void... params) {

            List<PermissionGroupInfo> groups =

                    mPm.getAllPermissionGroups(PackageManager.GET_META_DATA);

            // Get the groups.

            for (PermissionGroupInfo groupInfo : groups) {

                PermissionGroup group = new PermissionGroup();

                // TODO: Add default permission icon.

                group.icon = groupInfo.icon != 0 ? groupInfo.loadIcon(mPm) : new ShapeDrawable();

                group.name = groupInfo.name;

                group.label = groupInfo.loadLabel(mPm).toString();

                synchronized (mGroups) {

                    mGroups.add(group);

                }

            }

            // Load permissions and which are runtime.

            for (PermissionGroup group : mGroups) {

                try {

                    List<PermissionInfo> permissions =

                            mPm.queryPermissionsByGroup(group.name, 0);

                    for (PermissionInfo info : permissions) {

                        if (info.protectionLevel != PermissionInfo.PROTECTION_DANGEROUS) continue;

                        mGroupLookup.put(info.name, group);

                    }

                } catch (NameNotFoundException e) {

                    Log.w(TAG, "Problem getting permissions", e);

                }

            }

            // Load granted info.

            for (UserHandle user : UserManager.get(mContext).getUserProfiles()) {

                List<PackageInfo> allApps = mPm.getInstalledPackages(

                        PackageManager.GET_PERMISSIONS, user.getIdentifier());

                for (PackageInfo info : allApps) {

                    if (info.applicationInfo.targetSdkVersion <= Build.VERSION_CODES.LOLLIPOP_MR1

                            || info.requestedPermissions == null)  {

                        continue;

                    }

                    final int N = info.requestedPermissionsFlags.length;

                    boolean appHasRuntimePerms = false;

                    boolean appGrantedRuntimePerms = false;

                    for (int i = 0; i < N; i++) {

                        boolean granted = (info.requestedPermissionsFlags[i]

                                & PackageInfo.REQUESTED_PERMISSION_GRANTED) != 0;

                        PermissionGroup group = getOrCreateGroup(info.requestedPermissions[i]);

                        String key = Integer.toString(info.applicationInfo.uid);

                        if (group != null && !group.possibleApps.contains(key)) {

                            appHasRuntimePerms = true;

                            group.possibleApps.add(key);

                            if (granted) {

                                appGrantedRuntimePerms = true;

                                group.grantedApps.add(key);

                            }

                        }

                    }

                    if (appHasRuntimePerms) {

                        mRuntimePermAppsCt++;

                        if (appGrantedRuntimePerms) {

                            mRuntimePermAppsGrantedCt++;

                        }

                    }

                }

            }

            Collections.sort(mGroups);

            return null;

        }

        @Override

        protected void onPostExecute(Void result) {

            mCallback.onPermissionLoadComplete();

        }

    }

    public static class PermissionGroup implements Comparable<PermissionGroup> {

        public final List<String> possibleApps = new ArrayList<>();

        public final List<String> grantedApps = new ArrayList<>();

        public String name;

        public String label;

        public Drawable icon;

        @Override

        public int compareTo(PermissionGroup another) {

            return label.compareTo(another.label);

        }

    }

    public interface Callback {

        void onPermissionLoadComplete();

    }

}