Home | History | Annotate | Download | only in applications 
      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 
     17 package com.android.settings.applications;
     18 
     19 import android.app.Fragment;
     20 import android.content.Context;
     21 import android.content.Intent;
     22 import android.content.pm.ComponentInfo;
     23 import android.content.pm.PackageManager;
     24 import android.content.pm.ResolveInfo;
     25 import android.content.pm.UserInfo;
     26 import android.os.RemoteException;
     27 import android.os.UserHandle;
     28 import android.os.UserManager;
     29 import android.util.ArraySet;
     30 import android.view.View;
     31 
     32 import com.android.settings.applications.instantapps.InstantAppButtonsController;
     33 import com.android.settings.enterprise.DevicePolicyManagerWrapper;
     34 
     35 import java.util.ArrayList;
     36 import java.util.List;
     37 import java.util.Set;
     38 
     39 public class ApplicationFeatureProviderImpl implements ApplicationFeatureProvider {
     40 
     41     private final Context mContext;
     42     private final PackageManagerWrapper mPm;
     43     private final IPackageManagerWrapper mPms;
     44     private final DevicePolicyManagerWrapper mDpm;
     45     private final UserManager mUm;
     46 
     47     public ApplicationFeatureProviderImpl(Context context, PackageManagerWrapper pm,
     48             IPackageManagerWrapper pms, DevicePolicyManagerWrapper dpm) {
     49         mContext = context.getApplicationContext();
     50         mPm = pm;
     51         mPms = pms;
     52         mDpm = dpm;
     53         mUm = UserManager.get(mContext);
     54     }
     55 
     56     @Override
     57     public AppHeaderController newAppHeaderController(Fragment fragment, View appHeader) {
     58         return new AppHeaderController(mContext, fragment, appHeader);
     59     }
     60 
     61     @Override
     62     public InstantAppButtonsController newInstantAppButtonsController(Fragment fragment,
     63             View view, InstantAppButtonsController.ShowDialogDelegate showDialogDelegate) {
     64         return new InstantAppButtonsController(mContext, fragment, view, showDialogDelegate);
     65     }
     66 
     67     @Override
     68     public void calculateNumberOfPolicyInstalledApps(boolean async, NumberOfAppsCallback callback) {
     69         final CurrentUserAndManagedProfilePolicyInstalledAppCounter counter =
     70                 new CurrentUserAndManagedProfilePolicyInstalledAppCounter(mContext, mPm, callback);
     71         if (async) {
     72             counter.execute();
     73         } else {
     74             counter.executeInForeground();
     75         }
     76     }
     77 
     78     @Override
     79     public void listPolicyInstalledApps(ListOfAppsCallback callback) {
     80         final CurrentUserPolicyInstalledAppLister lister =
     81                 new CurrentUserPolicyInstalledAppLister(mPm, mUm, callback);
     82         lister.execute();
     83     }
     84 
     85     @Override
     86     public void calculateNumberOfAppsWithAdminGrantedPermissions(String[] permissions,
     87             boolean async, NumberOfAppsCallback callback) {
     88         final CurrentUserAndManagedProfileAppWithAdminGrantedPermissionsCounter counter =
     89                 new CurrentUserAndManagedProfileAppWithAdminGrantedPermissionsCounter(mContext,
     90                         permissions, mPm, mPms, mDpm, callback);
     91         if (async) {
     92             counter.execute();
     93         } else {
     94             counter.executeInForeground();
     95         }
     96     }
     97 
     98     @Override
     99     public void listAppsWithAdminGrantedPermissions(String[] permissions,
    100             ListOfAppsCallback callback) {
    101         final CurrentUserAppWithAdminGrantedPermissionsLister lister =
    102                 new CurrentUserAppWithAdminGrantedPermissionsLister(permissions, mPm, mPms, mDpm,
    103                         mUm, callback);
    104         lister.execute();
    105     }
    106 
    107     @Override
    108     public List<UserAppInfo> findPersistentPreferredActivities(int userId, Intent[] intents) {
    109         final List<UserAppInfo> preferredActivities = new ArrayList<>();
    110         final Set<UserAppInfo> uniqueApps = new ArraySet<>();
    111         final UserInfo userInfo = mUm.getUserInfo(userId);
    112         for (final Intent intent : intents) {
    113             try {
    114                 final ResolveInfo resolveInfo =
    115                         mPms.findPersistentPreferredActivity(intent, userId);
    116                 if (resolveInfo != null) {
    117                     ComponentInfo componentInfo = null;
    118                     if (resolveInfo.activityInfo != null) {
    119                         componentInfo = resolveInfo.activityInfo;
    120                     } else if (resolveInfo.serviceInfo != null) {
    121                         componentInfo = resolveInfo.serviceInfo;
    122                     } else if (resolveInfo.providerInfo != null) {
    123                         componentInfo = resolveInfo.providerInfo;
    124                     }
    125                     if (componentInfo != null) {
    126                         UserAppInfo info = new UserAppInfo(userInfo, componentInfo.applicationInfo);
    127                         if (uniqueApps.add(info)) {
    128                             preferredActivities.add(info);
    129                         }
    130                     }
    131                 }
    132             } catch (RemoteException exception) {
    133             }
    134         }
    135         return preferredActivities;
    136     }
    137 
    138     @Override
    139     public Set<String> getKeepEnabledPackages() {
    140         return new ArraySet<>();
    141     }
    142 
    143     private static class CurrentUserAndManagedProfilePolicyInstalledAppCounter
    144             extends InstalledAppCounter {
    145         private NumberOfAppsCallback mCallback;
    146 
    147         CurrentUserAndManagedProfilePolicyInstalledAppCounter(Context context,
    148                 PackageManagerWrapper packageManager, NumberOfAppsCallback callback) {
    149             super(context, PackageManager.INSTALL_REASON_POLICY, packageManager);
    150             mCallback = callback;
    151         }
    152 
    153         @Override
    154         protected void onCountComplete(int num) {
    155             mCallback.onNumberOfAppsResult(num);
    156         }
    157     }
    158 
    159     private static class CurrentUserAndManagedProfileAppWithAdminGrantedPermissionsCounter
    160             extends AppWithAdminGrantedPermissionsCounter {
    161         private NumberOfAppsCallback mCallback;
    162 
    163         CurrentUserAndManagedProfileAppWithAdminGrantedPermissionsCounter(Context context,
    164                 String[] permissions, PackageManagerWrapper packageManager,
    165                 IPackageManagerWrapper packageManagerService,
    166                 DevicePolicyManagerWrapper devicePolicyManager, NumberOfAppsCallback callback) {
    167             super(context, permissions, packageManager, packageManagerService, devicePolicyManager);
    168             mCallback = callback;
    169         }
    170 
    171         @Override
    172         protected void onCountComplete(int num) {
    173             mCallback.onNumberOfAppsResult(num);
    174         }
    175     }
    176 
    177     private static class CurrentUserPolicyInstalledAppLister extends InstalledAppLister {
    178         private ListOfAppsCallback mCallback;
    179 
    180         CurrentUserPolicyInstalledAppLister(PackageManagerWrapper packageManager,
    181                 UserManager userManager, ListOfAppsCallback callback) {
    182             super(packageManager, userManager);
    183             mCallback = callback;
    184         }
    185 
    186         @Override
    187         protected void onAppListBuilt(List<UserAppInfo> list) {
    188             mCallback.onListOfAppsResult(list);
    189         }
    190     }
    191 
    192     private static class CurrentUserAppWithAdminGrantedPermissionsLister extends
    193             AppWithAdminGrantedPermissionsLister {
    194         private ListOfAppsCallback mCallback;
    195 
    196         CurrentUserAppWithAdminGrantedPermissionsLister(String[] permissions,
    197                 PackageManagerWrapper packageManager, IPackageManagerWrapper packageManagerService,
    198                 DevicePolicyManagerWrapper devicePolicyManager, UserManager userManager,
    199                 ListOfAppsCallback callback) {
    200             super(permissions, packageManager, packageManagerService, devicePolicyManager,
    201                     userManager);
    202             mCallback = callback;
    203         }
    204 
    205         @Override
    206         protected void onAppListBuilt(List<UserAppInfo> list) {
    207             mCallback.onListOfAppsResult(list);
    208         }
    209     }
    210 
    211 }
    212