ApplicationFeatureProviderImpl.java revision 01cfb9d8c54dd2c888cea15987e7644e8a78a3e0 
1/*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy 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,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package com.android.settings.applications;
18
19import android.app.admin.DevicePolicyManager;
20import android.content.Context;
21import android.content.Intent;
22import android.content.pm.ComponentInfo;
23import android.content.pm.IPackageManager;
24import android.content.pm.PackageManager;
25import android.content.pm.ResolveInfo;
26import android.content.pm.UserInfo;
27import android.os.RemoteException;
28import android.os.UserManager;
29import android.util.ArraySet;
30
31import com.android.settingslib.wrapper.PackageManagerWrapper;
32
33import java.util.ArrayList;
34import java.util.List;
35import java.util.Set;
36
37public class ApplicationFeatureProviderImpl implements ApplicationFeatureProvider {
38
39    private final Context mContext;
40    private final PackageManagerWrapper mPm;
41    private final IPackageManager mPms;
42    private final DevicePolicyManager mDpm;
43    private final UserManager mUm;
44
45    public ApplicationFeatureProviderImpl(Context context, PackageManagerWrapper pm,
46            IPackageManager pms, DevicePolicyManager dpm) {
47        mContext = context.getApplicationContext();
48        mPm = pm;
49        mPms = pms;
50        mDpm = dpm;
51        mUm = UserManager.get(mContext);
52    }
53
54    @Override
55    public void calculateNumberOfPolicyInstalledApps(boolean async, NumberOfAppsCallback callback) {
56        final CurrentUserAndManagedProfilePolicyInstalledAppCounter counter =
57                new CurrentUserAndManagedProfilePolicyInstalledAppCounter(mContext, mPm, callback);
58        if (async) {
59            counter.execute();
60        } else {
61            counter.executeInForeground();
62        }
63    }
64
65    @Override
66    public void listPolicyInstalledApps(ListOfAppsCallback callback) {
67        final CurrentUserPolicyInstalledAppLister lister =
68                new CurrentUserPolicyInstalledAppLister(mPm, mUm, callback);
69        lister.execute();
70    }
71
72    @Override
73    public void calculateNumberOfAppsWithAdminGrantedPermissions(String[] permissions,
74            boolean async, NumberOfAppsCallback callback) {
75        final CurrentUserAndManagedProfileAppWithAdminGrantedPermissionsCounter counter =
76                new CurrentUserAndManagedProfileAppWithAdminGrantedPermissionsCounter(mContext,
77                        permissions, mPm, mPms, mDpm, callback);
78        if (async) {
79            counter.execute();
80        } else {
81            counter.executeInForeground();
82        }
83    }
84
85    @Override
86    public void listAppsWithAdminGrantedPermissions(String[] permissions,
87            ListOfAppsCallback callback) {
88        final CurrentUserAppWithAdminGrantedPermissionsLister lister =
89                new CurrentUserAppWithAdminGrantedPermissionsLister(permissions, mPm, mPms, mDpm,
90                        mUm, callback);
91        lister.execute();
92    }
93
94    @Override
95    public List<UserAppInfo> findPersistentPreferredActivities(int userId, Intent[] intents) {
96        final List<UserAppInfo> preferredActivities = new ArrayList<>();
97        final Set<UserAppInfo> uniqueApps = new ArraySet<>();
98        final UserInfo userInfo = mUm.getUserInfo(userId);
99        for (final Intent intent : intents) {
100            try {
101                final ResolveInfo resolveInfo =
102                        mPms.findPersistentPreferredActivity(intent, userId);
103                if (resolveInfo != null) {
104                    ComponentInfo componentInfo = null;
105                    if (resolveInfo.activityInfo != null) {
106                        componentInfo = resolveInfo.activityInfo;
107                    } else if (resolveInfo.serviceInfo != null) {
108                        componentInfo = resolveInfo.serviceInfo;
109                    } else if (resolveInfo.providerInfo != null) {
110                        componentInfo = resolveInfo.providerInfo;
111                    }
112                    if (componentInfo != null) {
113                        UserAppInfo info = new UserAppInfo(userInfo, componentInfo.applicationInfo);
114                        if (uniqueApps.add(info)) {
115                            preferredActivities.add(info);
116                        }
117                    }
118                }
119            } catch (RemoteException exception) {
120            }
121        }
122        return preferredActivities;
123    }
124
125    @Override
126    public Set<String> getKeepEnabledPackages() {
127        return new ArraySet<>();
128    }
129
130    private static class CurrentUserAndManagedProfilePolicyInstalledAppCounter
131            extends InstalledAppCounter {
132        private NumberOfAppsCallback mCallback;
133
134        CurrentUserAndManagedProfilePolicyInstalledAppCounter(Context context,
135                PackageManagerWrapper packageManager, NumberOfAppsCallback callback) {
136            super(context, PackageManager.INSTALL_REASON_POLICY, packageManager);
137            mCallback = callback;
138        }
139
140        @Override
141        protected void onCountComplete(int num) {
142            mCallback.onNumberOfAppsResult(num);
143        }
144    }
145
146    private static class CurrentUserAndManagedProfileAppWithAdminGrantedPermissionsCounter
147            extends AppWithAdminGrantedPermissionsCounter {
148        private NumberOfAppsCallback mCallback;
149
150        CurrentUserAndManagedProfileAppWithAdminGrantedPermissionsCounter(Context context,
151                String[] permissions, PackageManagerWrapper packageManager,
152                IPackageManager packageManagerService,
153                DevicePolicyManager devicePolicyManager, NumberOfAppsCallback callback) {
154            super(context, permissions, packageManager, packageManagerService, devicePolicyManager);
155            mCallback = callback;
156        }
157
158        @Override
159        protected void onCountComplete(int num) {
160            mCallback.onNumberOfAppsResult(num);
161        }
162    }
163
164    private static class CurrentUserPolicyInstalledAppLister extends InstalledAppLister {
165        private ListOfAppsCallback mCallback;
166
167        CurrentUserPolicyInstalledAppLister(PackageManagerWrapper packageManager,
168                UserManager userManager, ListOfAppsCallback callback) {
169            super(packageManager, userManager);
170            mCallback = callback;
171        }
172
173        @Override
174        protected void onAppListBuilt(List<UserAppInfo> list) {
175            mCallback.onListOfAppsResult(list);
176        }
177    }
178
179    private static class CurrentUserAppWithAdminGrantedPermissionsLister extends
180            AppWithAdminGrantedPermissionsLister {
181        private ListOfAppsCallback mCallback;
182
183        CurrentUserAppWithAdminGrantedPermissionsLister(String[] permissions,
184                PackageManagerWrapper packageManager, IPackageManager packageManagerService,
185                DevicePolicyManager devicePolicyManager, UserManager userManager,
186                ListOfAppsCallback callback) {
187            super(permissions, packageManager, packageManagerService, devicePolicyManager,
188                    userManager);
189            mCallback = callback;
190        }
191
192        @Override
193        protected void onAppListBuilt(List<UserAppInfo> list) {
194            mCallback.onListOfAppsResult(list);
195        }
196    }
197
198}
199