1 /*
2  * Copyright (C) 2010 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 android.app;
18 
19 import android.annotation.DrawableRes;
20 import android.annotation.NonNull;
21 import android.annotation.Nullable;
22 import android.annotation.StringRes;
23 import android.annotation.XmlRes;
24 import android.app.admin.DevicePolicyManager;
25 import android.content.ComponentName;
26 import android.content.ContentResolver;
27 import android.content.Intent;
28 import android.content.IntentFilter;
29 import android.content.IntentSender;
30 import android.content.pm.ActivityInfo;
31 import android.content.pm.ApplicationInfo;
32 import android.content.pm.ComponentInfo;
33 import android.content.pm.EphemeralApplicationInfo;
34 import android.content.pm.FeatureInfo;
35 import android.content.pm.IOnPermissionsChangeListener;
36 import android.content.pm.IPackageDataObserver;
37 import android.content.pm.IPackageDeleteObserver;
38 import android.content.pm.IPackageInstallObserver;
39 import android.content.pm.IPackageManager;
40 import android.content.pm.IPackageMoveObserver;
41 import android.content.pm.IPackageStatsObserver;
42 import android.content.pm.InstrumentationInfo;
43 import android.content.pm.IntentFilterVerificationInfo;
44 import android.content.pm.KeySet;
45 import android.content.pm.PackageInfo;
46 import android.content.pm.PackageInstaller;
47 import android.content.pm.PackageItemInfo;
48 import android.content.pm.PackageManager;
49 import android.content.pm.ParceledListSlice;
50 import android.content.pm.PermissionGroupInfo;
51 import android.content.pm.PermissionInfo;
52 import android.content.pm.ProviderInfo;
53 import android.content.pm.ResolveInfo;
54 import android.content.pm.ServiceInfo;
55 import android.content.pm.UserInfo;
56 import android.content.pm.VerifierDeviceIdentity;
57 import android.content.res.Resources;
58 import android.content.res.XmlResourceParser;
59 import android.graphics.Bitmap;
60 import android.graphics.Canvas;
61 import android.graphics.Rect;
62 import android.graphics.drawable.BitmapDrawable;
63 import android.graphics.drawable.Drawable;
64 import android.net.Uri;
65 import android.os.Bundle;
66 import android.os.Handler;
67 import android.os.Looper;
68 import android.os.Message;
69 import android.os.Process;
70 import android.os.RemoteException;
71 import android.os.SystemProperties;
72 import android.os.UserHandle;
73 import android.os.UserManager;
74 import android.os.storage.StorageManager;
75 import android.os.storage.VolumeInfo;
76 import android.provider.Settings;
77 import android.util.ArrayMap;
78 import android.util.Log;
79 import android.view.Display;
80 
81 import dalvik.system.VMRuntime;
82 
83 import com.android.internal.annotations.GuardedBy;
84 import com.android.internal.os.SomeArgs;
85 import com.android.internal.util.Preconditions;
86 import com.android.internal.util.UserIcons;
87 import libcore.util.EmptyArray;
88 
89 import java.lang.ref.WeakReference;
90 import java.util.ArrayList;
91 import java.util.Collections;
92 import java.util.Iterator;
93 import java.util.List;
94 import java.util.Map;
95 import java.util.Objects;
96 
97 /** @hide */
98 public class ApplicationPackageManager extends PackageManager {
99     private static final String TAG = "ApplicationPackageManager";
100     private final static boolean DEBUG_ICONS = false;
101 
102     private static final int DEFAULT_EPHEMERAL_COOKIE_MAX_SIZE_BYTES = 16384; // 16KB
103 
104     // Default flags to use with PackageManager when no flags are given.
105     private final static int sDefaultFlags = PackageManager.GET_SHARED_LIBRARY_FILES;
106 
107     private final Object mLock = new Object();
108 
109     @GuardedBy("mLock")
110     private UserManager mUserManager;
111     @GuardedBy("mLock")
112     private PackageInstaller mInstaller;
113 
114     @GuardedBy("mDelegates")
115     private final ArrayList<MoveCallbackDelegate> mDelegates = new ArrayList<>();
116 
117     @GuardedBy("mLock")
118     private String mPermissionsControllerPackageName;
119 
getUserManager()120     UserManager getUserManager() {
121         synchronized (mLock) {
122             if (mUserManager == null) {
123                 mUserManager = UserManager.get(mContext);
124             }
125             return mUserManager;
126         }
127     }
128 
129     @Override
getPackageInfo(String packageName, int flags)130     public PackageInfo getPackageInfo(String packageName, int flags)
131             throws NameNotFoundException {
132         return getPackageInfoAsUser(packageName, flags, mContext.getUserId());
133     }
134 
135     @Override
getPackageInfoAsUser(String packageName, int flags, int userId)136     public PackageInfo getPackageInfoAsUser(String packageName, int flags, int userId)
137             throws NameNotFoundException {
138         try {
139             PackageInfo pi = mPM.getPackageInfo(packageName, flags, userId);
140             if (pi != null) {
141                 return pi;
142             }
143         } catch (RemoteException e) {
144             throw e.rethrowFromSystemServer();
145         }
146 
147         throw new NameNotFoundException(packageName);
148     }
149 
150     @Override
currentToCanonicalPackageNames(String[] names)151     public String[] currentToCanonicalPackageNames(String[] names) {
152         try {
153             return mPM.currentToCanonicalPackageNames(names);
154         } catch (RemoteException e) {
155             throw e.rethrowFromSystemServer();
156         }
157     }
158 
159     @Override
canonicalToCurrentPackageNames(String[] names)160     public String[] canonicalToCurrentPackageNames(String[] names) {
161         try {
162             return mPM.canonicalToCurrentPackageNames(names);
163         } catch (RemoteException e) {
164             throw e.rethrowFromSystemServer();
165         }
166     }
167 
168     @Override
getLaunchIntentForPackage(String packageName)169     public Intent getLaunchIntentForPackage(String packageName) {
170         // First see if the package has an INFO activity; the existence of
171         // such an activity is implied to be the desired front-door for the
172         // overall package (such as if it has multiple launcher entries).
173         Intent intentToResolve = new Intent(Intent.ACTION_MAIN);
174         intentToResolve.addCategory(Intent.CATEGORY_INFO);
175         intentToResolve.setPackage(packageName);
176         List<ResolveInfo> ris = queryIntentActivities(intentToResolve, 0);
177 
178         // Otherwise, try to find a main launcher activity.
179         if (ris == null || ris.size() <= 0) {
180             // reuse the intent instance
181             intentToResolve.removeCategory(Intent.CATEGORY_INFO);
182             intentToResolve.addCategory(Intent.CATEGORY_LAUNCHER);
183             intentToResolve.setPackage(packageName);
184             ris = queryIntentActivities(intentToResolve, 0);
185         }
186         if (ris == null || ris.size() <= 0) {
187             return null;
188         }
189         Intent intent = new Intent(intentToResolve);
190         intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
191         intent.setClassName(ris.get(0).activityInfo.packageName,
192                 ris.get(0).activityInfo.name);
193         return intent;
194     }
195 
196     @Override
getLeanbackLaunchIntentForPackage(String packageName)197     public Intent getLeanbackLaunchIntentForPackage(String packageName) {
198         // Try to find a main leanback_launcher activity.
199         Intent intentToResolve = new Intent(Intent.ACTION_MAIN);
200         intentToResolve.addCategory(Intent.CATEGORY_LEANBACK_LAUNCHER);
201         intentToResolve.setPackage(packageName);
202         List<ResolveInfo> ris = queryIntentActivities(intentToResolve, 0);
203 
204         if (ris == null || ris.size() <= 0) {
205             return null;
206         }
207         Intent intent = new Intent(intentToResolve);
208         intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
209         intent.setClassName(ris.get(0).activityInfo.packageName,
210                 ris.get(0).activityInfo.name);
211         return intent;
212     }
213 
214     @Override
getPackageGids(String packageName)215     public int[] getPackageGids(String packageName) throws NameNotFoundException {
216         return getPackageGids(packageName, 0);
217     }
218 
219     @Override
getPackageGids(String packageName, int flags)220     public int[] getPackageGids(String packageName, int flags)
221             throws NameNotFoundException {
222         try {
223             int[] gids = mPM.getPackageGids(packageName, flags, mContext.getUserId());
224             if (gids != null) {
225                 return gids;
226             }
227         } catch (RemoteException e) {
228             throw e.rethrowFromSystemServer();
229         }
230 
231         throw new NameNotFoundException(packageName);
232     }
233 
234     @Override
getPackageUid(String packageName, int flags)235     public int getPackageUid(String packageName, int flags) throws NameNotFoundException {
236         return getPackageUidAsUser(packageName, flags, mContext.getUserId());
237     }
238 
239     @Override
getPackageUidAsUser(String packageName, int userId)240     public int getPackageUidAsUser(String packageName, int userId) throws NameNotFoundException {
241         return getPackageUidAsUser(packageName, 0, userId);
242     }
243 
244     @Override
getPackageUidAsUser(String packageName, int flags, int userId)245     public int getPackageUidAsUser(String packageName, int flags, int userId)
246             throws NameNotFoundException {
247         try {
248             int uid = mPM.getPackageUid(packageName, flags, userId);
249             if (uid >= 0) {
250                 return uid;
251             }
252         } catch (RemoteException e) {
253             throw e.rethrowFromSystemServer();
254         }
255 
256         throw new NameNotFoundException(packageName);
257     }
258 
259     @Override
getPermissionInfo(String name, int flags)260     public PermissionInfo getPermissionInfo(String name, int flags)
261             throws NameNotFoundException {
262         try {
263             PermissionInfo pi = mPM.getPermissionInfo(name, flags);
264             if (pi != null) {
265                 return pi;
266             }
267         } catch (RemoteException e) {
268             throw e.rethrowFromSystemServer();
269         }
270 
271         throw new NameNotFoundException(name);
272     }
273 
274     @Override
275     @SuppressWarnings("unchecked")
queryPermissionsByGroup(String group, int flags)276     public List<PermissionInfo> queryPermissionsByGroup(String group, int flags)
277             throws NameNotFoundException {
278         try {
279             ParceledListSlice<PermissionInfo> parceledList =
280                     mPM.queryPermissionsByGroup(group, flags);
281             if (parceledList != null) {
282                 List<PermissionInfo> pi = parceledList.getList();
283                 if (pi != null) {
284                     return pi;
285                 }
286             }
287         } catch (RemoteException e) {
288             throw e.rethrowFromSystemServer();
289         }
290 
291         throw new NameNotFoundException(group);
292     }
293 
294     @Override
getPermissionGroupInfo(String name, int flags)295     public PermissionGroupInfo getPermissionGroupInfo(String name,
296             int flags) throws NameNotFoundException {
297         try {
298             PermissionGroupInfo pgi = mPM.getPermissionGroupInfo(name, flags);
299             if (pgi != null) {
300                 return pgi;
301             }
302         } catch (RemoteException e) {
303             throw e.rethrowFromSystemServer();
304         }
305 
306         throw new NameNotFoundException(name);
307     }
308 
309     @Override
310     @SuppressWarnings("unchecked")
getAllPermissionGroups(int flags)311     public List<PermissionGroupInfo> getAllPermissionGroups(int flags) {
312         try {
313             ParceledListSlice<PermissionGroupInfo> parceledList =
314                     mPM.getAllPermissionGroups(flags);
315             if (parceledList == null) {
316                 return Collections.emptyList();
317             }
318             return parceledList.getList();
319         } catch (RemoteException e) {
320             throw e.rethrowFromSystemServer();
321         }
322     }
323 
324     @Override
getApplicationInfo(String packageName, int flags)325     public ApplicationInfo getApplicationInfo(String packageName, int flags)
326             throws NameNotFoundException {
327         return getApplicationInfoAsUser(packageName, flags, mContext.getUserId());
328     }
329 
330     @Override
getApplicationInfoAsUser(String packageName, int flags, int userId)331     public ApplicationInfo getApplicationInfoAsUser(String packageName, int flags, int userId)
332             throws NameNotFoundException {
333         try {
334             ApplicationInfo ai = mPM.getApplicationInfo(packageName, flags, userId);
335             if (ai != null) {
336                 // This is a temporary hack. Callers must use
337                 // createPackageContext(packageName).getApplicationInfo() to
338                 // get the right paths.
339                 return maybeAdjustApplicationInfo(ai);
340             }
341         } catch (RemoteException e) {
342             throw e.rethrowFromSystemServer();
343         }
344 
345         throw new NameNotFoundException(packageName);
346     }
347 
maybeAdjustApplicationInfo(ApplicationInfo info)348     private static ApplicationInfo maybeAdjustApplicationInfo(ApplicationInfo info) {
349         // If we're dealing with a multi-arch application that has both
350         // 32 and 64 bit shared libraries, we might need to choose the secondary
351         // depending on what the current runtime's instruction set is.
352         if (info.primaryCpuAbi != null && info.secondaryCpuAbi != null) {
353             final String runtimeIsa = VMRuntime.getRuntime().vmInstructionSet();
354 
355             // Get the instruction set that the libraries of secondary Abi is supported.
356             // In presence of a native bridge this might be different than the one secondary Abi used.
357             String secondaryIsa = VMRuntime.getInstructionSet(info.secondaryCpuAbi);
358             final String secondaryDexCodeIsa = SystemProperties.get("ro.dalvik.vm.isa." + secondaryIsa);
359             secondaryIsa = secondaryDexCodeIsa.isEmpty() ? secondaryIsa : secondaryDexCodeIsa;
360 
361             // If the runtimeIsa is the same as the primary isa, then we do nothing.
362             // Everything will be set up correctly because info.nativeLibraryDir will
363             // correspond to the right ISA.
364             if (runtimeIsa.equals(secondaryIsa)) {
365                 ApplicationInfo modified = new ApplicationInfo(info);
366                 modified.nativeLibraryDir = info.secondaryNativeLibraryDir;
367                 return modified;
368             }
369         }
370         return info;
371     }
372 
373     @Override
getActivityInfo(ComponentName className, int flags)374     public ActivityInfo getActivityInfo(ComponentName className, int flags)
375             throws NameNotFoundException {
376         try {
377             ActivityInfo ai = mPM.getActivityInfo(className, flags, mContext.getUserId());
378             if (ai != null) {
379                 return ai;
380             }
381         } catch (RemoteException e) {
382             throw e.rethrowFromSystemServer();
383         }
384 
385         throw new NameNotFoundException(className.toString());
386     }
387 
388     @Override
getReceiverInfo(ComponentName className, int flags)389     public ActivityInfo getReceiverInfo(ComponentName className, int flags)
390             throws NameNotFoundException {
391         try {
392             ActivityInfo ai = mPM.getReceiverInfo(className, flags, mContext.getUserId());
393             if (ai != null) {
394                 return ai;
395             }
396         } catch (RemoteException e) {
397             throw e.rethrowFromSystemServer();
398         }
399 
400         throw new NameNotFoundException(className.toString());
401     }
402 
403     @Override
getServiceInfo(ComponentName className, int flags)404     public ServiceInfo getServiceInfo(ComponentName className, int flags)
405             throws NameNotFoundException {
406         try {
407             ServiceInfo si = mPM.getServiceInfo(className, flags, mContext.getUserId());
408             if (si != null) {
409                 return si;
410             }
411         } catch (RemoteException e) {
412             throw e.rethrowFromSystemServer();
413         }
414 
415         throw new NameNotFoundException(className.toString());
416     }
417 
418     @Override
getProviderInfo(ComponentName className, int flags)419     public ProviderInfo getProviderInfo(ComponentName className, int flags)
420             throws NameNotFoundException {
421         try {
422             ProviderInfo pi = mPM.getProviderInfo(className, flags, mContext.getUserId());
423             if (pi != null) {
424                 return pi;
425             }
426         } catch (RemoteException e) {
427             throw e.rethrowFromSystemServer();
428         }
429 
430         throw new NameNotFoundException(className.toString());
431     }
432 
433     @Override
getSystemSharedLibraryNames()434     public String[] getSystemSharedLibraryNames() {
435         try {
436             return mPM.getSystemSharedLibraryNames();
437         } catch (RemoteException e) {
438             throw e.rethrowFromSystemServer();
439         }
440     }
441 
442     /** @hide */
443     @Override
getServicesSystemSharedLibraryPackageName()444     public @NonNull String getServicesSystemSharedLibraryPackageName() {
445         try {
446             return mPM.getServicesSystemSharedLibraryPackageName();
447         } catch (RemoteException e) {
448             throw e.rethrowFromSystemServer();
449         }
450     }
451 
452     /**
453      * @hide
454      */
getSharedSystemSharedLibraryPackageName()455     public @NonNull String getSharedSystemSharedLibraryPackageName() {
456         try {
457             return mPM.getSharedSystemSharedLibraryPackageName();
458         } catch (RemoteException e) {
459             throw e.rethrowFromSystemServer();
460         }
461     }
462 
463     @Override
464     @SuppressWarnings("unchecked")
getSystemAvailableFeatures()465     public FeatureInfo[] getSystemAvailableFeatures() {
466         try {
467             ParceledListSlice<FeatureInfo> parceledList =
468                     mPM.getSystemAvailableFeatures();
469             if (parceledList == null) {
470                 return new FeatureInfo[0];
471             }
472             final List<FeatureInfo> list = parceledList.getList();
473             final FeatureInfo[] res = new FeatureInfo[list.size()];
474             for (int i = 0; i < res.length; i++) {
475                 res[i] = list.get(i);
476             }
477             return res;
478         } catch (RemoteException e) {
479             throw e.rethrowFromSystemServer();
480         }
481     }
482 
483     @Override
hasSystemFeature(String name)484     public boolean hasSystemFeature(String name) {
485         return hasSystemFeature(name, 0);
486     }
487 
488     @Override
hasSystemFeature(String name, int version)489     public boolean hasSystemFeature(String name, int version) {
490         try {
491             return mPM.hasSystemFeature(name, version);
492         } catch (RemoteException e) {
493             throw e.rethrowFromSystemServer();
494         }
495     }
496 
497     @Override
checkPermission(String permName, String pkgName)498     public int checkPermission(String permName, String pkgName) {
499         try {
500             return mPM.checkPermission(permName, pkgName, mContext.getUserId());
501         } catch (RemoteException e) {
502             throw e.rethrowFromSystemServer();
503         }
504     }
505 
506     @Override
isPermissionRevokedByPolicy(String permName, String pkgName)507     public boolean isPermissionRevokedByPolicy(String permName, String pkgName) {
508         try {
509             return mPM.isPermissionRevokedByPolicy(permName, pkgName, mContext.getUserId());
510         } catch (RemoteException e) {
511             throw e.rethrowFromSystemServer();
512         }
513     }
514 
515     /**
516      * @hide
517      */
518     @Override
getPermissionControllerPackageName()519     public String getPermissionControllerPackageName() {
520         synchronized (mLock) {
521             if (mPermissionsControllerPackageName == null) {
522                 try {
523                     mPermissionsControllerPackageName = mPM.getPermissionControllerPackageName();
524                 } catch (RemoteException e) {
525                     throw e.rethrowFromSystemServer();
526                 }
527             }
528             return mPermissionsControllerPackageName;
529         }
530     }
531 
532     @Override
addPermission(PermissionInfo info)533     public boolean addPermission(PermissionInfo info) {
534         try {
535             return mPM.addPermission(info);
536         } catch (RemoteException e) {
537             throw e.rethrowFromSystemServer();
538         }
539     }
540 
541     @Override
addPermissionAsync(PermissionInfo info)542     public boolean addPermissionAsync(PermissionInfo info) {
543         try {
544             return mPM.addPermissionAsync(info);
545         } catch (RemoteException e) {
546             throw e.rethrowFromSystemServer();
547         }
548     }
549 
550     @Override
removePermission(String name)551     public void removePermission(String name) {
552         try {
553             mPM.removePermission(name);
554         } catch (RemoteException e) {
555             throw e.rethrowFromSystemServer();
556         }
557     }
558 
559     @Override
grantRuntimePermission(String packageName, String permissionName, UserHandle user)560     public void grantRuntimePermission(String packageName, String permissionName,
561             UserHandle user) {
562         try {
563             mPM.grantRuntimePermission(packageName, permissionName, user.getIdentifier());
564         } catch (RemoteException e) {
565             throw e.rethrowFromSystemServer();
566         }
567     }
568 
569     @Override
revokeRuntimePermission(String packageName, String permissionName, UserHandle user)570     public void revokeRuntimePermission(String packageName, String permissionName,
571             UserHandle user) {
572         try {
573             mPM.revokeRuntimePermission(packageName, permissionName, user.getIdentifier());
574         } catch (RemoteException e) {
575             throw e.rethrowFromSystemServer();
576         }
577     }
578 
579     @Override
getPermissionFlags(String permissionName, String packageName, UserHandle user)580     public int getPermissionFlags(String permissionName, String packageName, UserHandle user) {
581         try {
582             return mPM.getPermissionFlags(permissionName, packageName, user.getIdentifier());
583         } catch (RemoteException e) {
584             throw e.rethrowFromSystemServer();
585         }
586     }
587 
588     @Override
updatePermissionFlags(String permissionName, String packageName, int flagMask, int flagValues, UserHandle user)589     public void updatePermissionFlags(String permissionName, String packageName,
590             int flagMask, int flagValues, UserHandle user) {
591         try {
592             mPM.updatePermissionFlags(permissionName, packageName, flagMask,
593                     flagValues, user.getIdentifier());
594         } catch (RemoteException e) {
595             throw e.rethrowFromSystemServer();
596         }
597     }
598 
599     @Override
shouldShowRequestPermissionRationale(String permission)600     public boolean shouldShowRequestPermissionRationale(String permission) {
601         try {
602             return mPM.shouldShowRequestPermissionRationale(permission,
603                     mContext.getPackageName(), mContext.getUserId());
604         } catch (RemoteException e) {
605             throw e.rethrowFromSystemServer();
606         }
607     }
608 
609     @Override
checkSignatures(String pkg1, String pkg2)610     public int checkSignatures(String pkg1, String pkg2) {
611         try {
612             return mPM.checkSignatures(pkg1, pkg2);
613         } catch (RemoteException e) {
614             throw e.rethrowFromSystemServer();
615         }
616     }
617 
618     @Override
checkSignatures(int uid1, int uid2)619     public int checkSignatures(int uid1, int uid2) {
620         try {
621             return mPM.checkUidSignatures(uid1, uid2);
622         } catch (RemoteException e) {
623             throw e.rethrowFromSystemServer();
624         }
625     }
626 
627     @Override
getPackagesForUid(int uid)628     public String[] getPackagesForUid(int uid) {
629         try {
630             return mPM.getPackagesForUid(uid);
631         } catch (RemoteException e) {
632             throw e.rethrowFromSystemServer();
633         }
634     }
635 
636     @Override
getNameForUid(int uid)637     public String getNameForUid(int uid) {
638         try {
639             return mPM.getNameForUid(uid);
640         } catch (RemoteException e) {
641             throw e.rethrowFromSystemServer();
642         }
643     }
644 
645     @Override
getUidForSharedUser(String sharedUserName)646     public int getUidForSharedUser(String sharedUserName)
647             throws NameNotFoundException {
648         try {
649             int uid = mPM.getUidForSharedUser(sharedUserName);
650             if(uid != -1) {
651                 return uid;
652             }
653         } catch (RemoteException e) {
654             throw e.rethrowFromSystemServer();
655         }
656         throw new NameNotFoundException("No shared userid for user:"+sharedUserName);
657     }
658 
659     @SuppressWarnings("unchecked")
660     @Override
getInstalledPackages(int flags)661     public List<PackageInfo> getInstalledPackages(int flags) {
662         return getInstalledPackagesAsUser(flags, mContext.getUserId());
663     }
664 
665     /** @hide */
666     @Override
667     @SuppressWarnings("unchecked")
getInstalledPackagesAsUser(int flags, int userId)668     public List<PackageInfo> getInstalledPackagesAsUser(int flags, int userId) {
669         try {
670             ParceledListSlice<PackageInfo> parceledList =
671                     mPM.getInstalledPackages(flags, userId);
672             if (parceledList == null) {
673                 return Collections.emptyList();
674             }
675             return parceledList.getList();
676         } catch (RemoteException e) {
677             throw e.rethrowFromSystemServer();
678         }
679     }
680 
681     @SuppressWarnings("unchecked")
682     @Override
getPackagesHoldingPermissions( String[] permissions, int flags)683     public List<PackageInfo> getPackagesHoldingPermissions(
684             String[] permissions, int flags) {
685         final int userId = mContext.getUserId();
686         try {
687             ParceledListSlice<PackageInfo> parceledList =
688                     mPM.getPackagesHoldingPermissions(permissions, flags, userId);
689             if (parceledList == null) {
690                 return Collections.emptyList();
691             }
692             return parceledList.getList();
693         } catch (RemoteException e) {
694             throw e.rethrowFromSystemServer();
695         }
696     }
697 
698     @SuppressWarnings("unchecked")
699     @Override
getInstalledApplications(int flags)700     public List<ApplicationInfo> getInstalledApplications(int flags) {
701         final int userId = mContext.getUserId();
702         try {
703             ParceledListSlice<ApplicationInfo> parceledList =
704                     mPM.getInstalledApplications(flags, userId);
705             if (parceledList == null) {
706                 return Collections.emptyList();
707             }
708             return parceledList.getList();
709         } catch (RemoteException e) {
710             throw e.rethrowFromSystemServer();
711         }
712     }
713 
714     /** @hide */
715     @SuppressWarnings("unchecked")
716     @Override
getEphemeralApplications()717     public List<EphemeralApplicationInfo> getEphemeralApplications() {
718         try {
719             ParceledListSlice<EphemeralApplicationInfo> slice =
720                     mPM.getEphemeralApplications(mContext.getUserId());
721             if (slice != null) {
722                 return slice.getList();
723             }
724             return Collections.emptyList();
725         } catch (RemoteException e) {
726             throw e.rethrowFromSystemServer();
727         }
728     }
729 
730     /** @hide */
731     @Override
getEphemeralApplicationIcon(String packageName)732     public Drawable getEphemeralApplicationIcon(String packageName) {
733         try {
734             Bitmap bitmap = mPM.getEphemeralApplicationIcon(
735                     packageName, mContext.getUserId());
736             if (bitmap != null) {
737                 return new BitmapDrawable(null, bitmap);
738             }
739             return null;
740         } catch (RemoteException e) {
741             throw e.rethrowFromSystemServer();
742         }
743     }
744 
745     @Override
isEphemeralApplication()746     public boolean isEphemeralApplication() {
747         try {
748             return mPM.isEphemeralApplication(
749                     mContext.getPackageName(), mContext.getUserId());
750         } catch (RemoteException e) {
751             throw e.rethrowFromSystemServer();
752         }
753     }
754 
755     @Override
getEphemeralCookieMaxSizeBytes()756     public int getEphemeralCookieMaxSizeBytes() {
757         return Settings.Global.getInt(mContext.getContentResolver(),
758                 Settings.Global.EPHEMERAL_COOKIE_MAX_SIZE_BYTES,
759                 DEFAULT_EPHEMERAL_COOKIE_MAX_SIZE_BYTES);
760     }
761 
762     @Override
getEphemeralCookie()763     public @NonNull byte[] getEphemeralCookie() {
764         try {
765             final byte[] cookie = mPM.getEphemeralApplicationCookie(
766                     mContext.getPackageName(), mContext.getUserId());
767             if (cookie != null) {
768                 return cookie;
769             } else {
770                 return EmptyArray.BYTE;
771             }
772         } catch (RemoteException e) {
773             throw e.rethrowFromSystemServer();
774         }
775     }
776 
777     @Override
setEphemeralCookie(@onNull byte[] cookie)778     public boolean setEphemeralCookie(@NonNull  byte[] cookie) {
779         try {
780             return mPM.setEphemeralApplicationCookie(
781                     mContext.getPackageName(), cookie, mContext.getUserId());
782         } catch (RemoteException e) {
783             throw e.rethrowFromSystemServer();
784         }
785     }
786 
787     @Override
resolveActivity(Intent intent, int flags)788     public ResolveInfo resolveActivity(Intent intent, int flags) {
789         return resolveActivityAsUser(intent, flags, mContext.getUserId());
790     }
791 
792     @Override
resolveActivityAsUser(Intent intent, int flags, int userId)793     public ResolveInfo resolveActivityAsUser(Intent intent, int flags, int userId) {
794         try {
795             return mPM.resolveIntent(
796                 intent,
797                 intent.resolveTypeIfNeeded(mContext.getContentResolver()),
798                 flags,
799                 userId);
800         } catch (RemoteException e) {
801             throw e.rethrowFromSystemServer();
802         }
803     }
804 
805     @Override
queryIntentActivities(Intent intent, int flags)806     public List<ResolveInfo> queryIntentActivities(Intent intent,
807                                                    int flags) {
808         return queryIntentActivitiesAsUser(intent, flags, mContext.getUserId());
809     }
810 
811     /** @hide Same as above but for a specific user */
812     @Override
813     @SuppressWarnings("unchecked")
queryIntentActivitiesAsUser(Intent intent, int flags, int userId)814     public List<ResolveInfo> queryIntentActivitiesAsUser(Intent intent,
815             int flags, int userId) {
816         try {
817             ParceledListSlice<ResolveInfo> parceledList =
818                     mPM.queryIntentActivities(intent,
819                             intent.resolveTypeIfNeeded(mContext.getContentResolver()),
820                             flags, userId);
821             if (parceledList == null) {
822                 return Collections.emptyList();
823             }
824             return parceledList.getList();
825         } catch (RemoteException e) {
826             throw e.rethrowFromSystemServer();
827         }
828     }
829 
830     @Override
831     @SuppressWarnings("unchecked")
queryIntentActivityOptions( ComponentName caller, Intent[] specifics, Intent intent, int flags)832     public List<ResolveInfo> queryIntentActivityOptions(
833         ComponentName caller, Intent[] specifics, Intent intent,
834         int flags) {
835         final ContentResolver resolver = mContext.getContentResolver();
836 
837         String[] specificTypes = null;
838         if (specifics != null) {
839             final int N = specifics.length;
840             for (int i=0; i<N; i++) {
841                 Intent sp = specifics[i];
842                 if (sp != null) {
843                     String t = sp.resolveTypeIfNeeded(resolver);
844                     if (t != null) {
845                         if (specificTypes == null) {
846                             specificTypes = new String[N];
847                         }
848                         specificTypes[i] = t;
849                     }
850                 }
851             }
852         }
853 
854         try {
855             ParceledListSlice<ResolveInfo> parceledList =
856                     mPM.queryIntentActivityOptions(caller, specifics, specificTypes, intent,
857                     intent.resolveTypeIfNeeded(resolver), flags, mContext.getUserId());
858             if (parceledList == null) {
859                 return Collections.emptyList();
860             }
861             return parceledList.getList();
862         } catch (RemoteException e) {
863             throw e.rethrowFromSystemServer();
864         }
865     }
866 
867     /**
868      * @hide
869      */
870     @Override
871     @SuppressWarnings("unchecked")
queryBroadcastReceiversAsUser(Intent intent, int flags, int userId)872     public List<ResolveInfo> queryBroadcastReceiversAsUser(Intent intent, int flags, int userId) {
873         try {
874             ParceledListSlice<ResolveInfo> parceledList =
875                     mPM.queryIntentReceivers(intent,
876                             intent.resolveTypeIfNeeded(mContext.getContentResolver()),
877                             flags,  userId);
878             if (parceledList == null) {
879                 return Collections.emptyList();
880             }
881             return parceledList.getList();
882         } catch (RemoteException e) {
883             throw e.rethrowFromSystemServer();
884         }
885     }
886 
887     @Override
queryBroadcastReceivers(Intent intent, int flags)888     public List<ResolveInfo> queryBroadcastReceivers(Intent intent, int flags) {
889         return queryBroadcastReceiversAsUser(intent, flags, mContext.getUserId());
890     }
891 
892     @Override
resolveService(Intent intent, int flags)893     public ResolveInfo resolveService(Intent intent, int flags) {
894         try {
895             return mPM.resolveService(
896                 intent,
897                 intent.resolveTypeIfNeeded(mContext.getContentResolver()),
898                 flags,
899                 mContext.getUserId());
900         } catch (RemoteException e) {
901             throw e.rethrowFromSystemServer();
902         }
903     }
904 
905     @Override
906     @SuppressWarnings("unchecked")
queryIntentServicesAsUser(Intent intent, int flags, int userId)907     public List<ResolveInfo> queryIntentServicesAsUser(Intent intent, int flags, int userId) {
908         try {
909             ParceledListSlice<ResolveInfo> parceledList =
910                     mPM.queryIntentServices(intent,
911                     intent.resolveTypeIfNeeded(mContext.getContentResolver()),
912                     flags, userId);
913             if (parceledList == null) {
914                 return Collections.emptyList();
915             }
916             return parceledList.getList();
917         } catch (RemoteException e) {
918             throw e.rethrowFromSystemServer();
919         }
920     }
921 
922     @Override
queryIntentServices(Intent intent, int flags)923     public List<ResolveInfo> queryIntentServices(Intent intent, int flags) {
924         return queryIntentServicesAsUser(intent, flags, mContext.getUserId());
925     }
926 
927     @Override
928     @SuppressWarnings("unchecked")
queryIntentContentProvidersAsUser( Intent intent, int flags, int userId)929     public List<ResolveInfo> queryIntentContentProvidersAsUser(
930             Intent intent, int flags, int userId) {
931         try {
932             ParceledListSlice<ResolveInfo> parceledList =
933                     mPM.queryIntentContentProviders(intent,
934                             intent.resolveTypeIfNeeded(mContext.getContentResolver()),
935                             flags, userId);
936             if (parceledList == null) {
937                 return Collections.emptyList();
938             }
939             return parceledList.getList();
940         } catch (RemoteException e) {
941             throw e.rethrowFromSystemServer();
942         }
943     }
944 
945     @Override
queryIntentContentProviders(Intent intent, int flags)946     public List<ResolveInfo> queryIntentContentProviders(Intent intent, int flags) {
947         return queryIntentContentProvidersAsUser(intent, flags, mContext.getUserId());
948     }
949 
950     @Override
resolveContentProvider(String name, int flags)951     public ProviderInfo resolveContentProvider(String name, int flags) {
952         return resolveContentProviderAsUser(name, flags, mContext.getUserId());
953     }
954 
955     /** @hide **/
956     @Override
resolveContentProviderAsUser(String name, int flags, int userId)957     public ProviderInfo resolveContentProviderAsUser(String name, int flags, int userId) {
958         try {
959             return mPM.resolveContentProvider(name, flags, userId);
960         } catch (RemoteException e) {
961             throw e.rethrowFromSystemServer();
962         }
963     }
964 
965     @Override
966     @SuppressWarnings("unchecked")
queryContentProviders(String processName, int uid, int flags)967     public List<ProviderInfo> queryContentProviders(String processName,
968             int uid, int flags) {
969         try {
970             ParceledListSlice<ProviderInfo> slice =
971                     mPM.queryContentProviders(processName, uid, flags);
972             return slice != null ? slice.getList() : Collections.<ProviderInfo>emptyList();
973         } catch (RemoteException e) {
974             throw e.rethrowFromSystemServer();
975         }
976     }
977 
978     @Override
getInstrumentationInfo( ComponentName className, int flags)979     public InstrumentationInfo getInstrumentationInfo(
980         ComponentName className, int flags)
981             throws NameNotFoundException {
982         try {
983             InstrumentationInfo ii = mPM.getInstrumentationInfo(
984                 className, flags);
985             if (ii != null) {
986                 return ii;
987             }
988         } catch (RemoteException e) {
989             throw e.rethrowFromSystemServer();
990         }
991 
992         throw new NameNotFoundException(className.toString());
993     }
994 
995     @Override
996     @SuppressWarnings("unchecked")
queryInstrumentation( String targetPackage, int flags)997     public List<InstrumentationInfo> queryInstrumentation(
998         String targetPackage, int flags) {
999         try {
1000             ParceledListSlice<InstrumentationInfo> parceledList =
1001                     mPM.queryInstrumentation(targetPackage, flags);
1002             if (parceledList == null) {
1003                 return Collections.emptyList();
1004             }
1005             return parceledList.getList();
1006         } catch (RemoteException e) {
1007             throw e.rethrowFromSystemServer();
1008         }
1009     }
1010 
1011     @Nullable
1012     @Override
getDrawable(String packageName, @DrawableRes int resId, @Nullable ApplicationInfo appInfo)1013     public Drawable getDrawable(String packageName, @DrawableRes int resId,
1014             @Nullable ApplicationInfo appInfo) {
1015         final ResourceName name = new ResourceName(packageName, resId);
1016         final Drawable cachedIcon = getCachedIcon(name);
1017         if (cachedIcon != null) {
1018             return cachedIcon;
1019         }
1020 
1021         if (appInfo == null) {
1022             try {
1023                 appInfo = getApplicationInfo(packageName, sDefaultFlags);
1024             } catch (NameNotFoundException e) {
1025                 return null;
1026             }
1027         }
1028 
1029         if (resId != 0) {
1030             try {
1031                 final Resources r = getResourcesForApplication(appInfo);
1032                 final Drawable dr = r.getDrawable(resId, null);
1033                 if (dr != null) {
1034                     putCachedIcon(name, dr);
1035                 }
1036 
1037                 if (false) {
1038                     RuntimeException e = new RuntimeException("here");
1039                     e.fillInStackTrace();
1040                     Log.w(TAG, "Getting drawable 0x" + Integer.toHexString(resId)
1041                                     + " from package " + packageName
1042                                     + ": app scale=" + r.getCompatibilityInfo().applicationScale
1043                                     + ", caller scale=" + mContext.getResources()
1044                                     .getCompatibilityInfo().applicationScale,
1045                             e);
1046                 }
1047                 if (DEBUG_ICONS) {
1048                     Log.v(TAG, "Getting drawable 0x"
1049                             + Integer.toHexString(resId) + " from " + r
1050                             + ": " + dr);
1051                 }
1052                 return dr;
1053             } catch (NameNotFoundException e) {
1054                 Log.w("PackageManager", "Failure retrieving resources for "
1055                         + appInfo.packageName);
1056             } catch (Resources.NotFoundException e) {
1057                 Log.w("PackageManager", "Failure retrieving resources for "
1058                         + appInfo.packageName + ": " + e.getMessage());
1059             } catch (Exception e) {
1060                 // If an exception was thrown, fall through to return
1061                 // default icon.
1062                 Log.w("PackageManager", "Failure retrieving icon 0x"
1063                         + Integer.toHexString(resId) + " in package "
1064                         + packageName, e);
1065             }
1066         }
1067 
1068         return null;
1069     }
1070 
getActivityIcon(ComponentName activityName)1071     @Override public Drawable getActivityIcon(ComponentName activityName)
1072             throws NameNotFoundException {
1073         return getActivityInfo(activityName, sDefaultFlags).loadIcon(this);
1074     }
1075 
getActivityIcon(Intent intent)1076     @Override public Drawable getActivityIcon(Intent intent)
1077             throws NameNotFoundException {
1078         if (intent.getComponent() != null) {
1079             return getActivityIcon(intent.getComponent());
1080         }
1081 
1082         ResolveInfo info = resolveActivity(
1083             intent, PackageManager.MATCH_DEFAULT_ONLY);
1084         if (info != null) {
1085             return info.activityInfo.loadIcon(this);
1086         }
1087 
1088         throw new NameNotFoundException(intent.toUri(0));
1089     }
1090 
getDefaultActivityIcon()1091     @Override public Drawable getDefaultActivityIcon() {
1092         return Resources.getSystem().getDrawable(
1093             com.android.internal.R.drawable.sym_def_app_icon);
1094     }
1095 
getApplicationIcon(ApplicationInfo info)1096     @Override public Drawable getApplicationIcon(ApplicationInfo info) {
1097         return info.loadIcon(this);
1098     }
1099 
getApplicationIcon(String packageName)1100     @Override public Drawable getApplicationIcon(String packageName)
1101             throws NameNotFoundException {
1102         return getApplicationIcon(getApplicationInfo(packageName, sDefaultFlags));
1103     }
1104 
1105     @Override
getActivityBanner(ComponentName activityName)1106     public Drawable getActivityBanner(ComponentName activityName)
1107             throws NameNotFoundException {
1108         return getActivityInfo(activityName, sDefaultFlags).loadBanner(this);
1109     }
1110 
1111     @Override
getActivityBanner(Intent intent)1112     public Drawable getActivityBanner(Intent intent)
1113             throws NameNotFoundException {
1114         if (intent.getComponent() != null) {
1115             return getActivityBanner(intent.getComponent());
1116         }
1117 
1118         ResolveInfo info = resolveActivity(
1119                 intent, PackageManager.MATCH_DEFAULT_ONLY);
1120         if (info != null) {
1121             return info.activityInfo.loadBanner(this);
1122         }
1123 
1124         throw new NameNotFoundException(intent.toUri(0));
1125     }
1126 
1127     @Override
getApplicationBanner(ApplicationInfo info)1128     public Drawable getApplicationBanner(ApplicationInfo info) {
1129         return info.loadBanner(this);
1130     }
1131 
1132     @Override
getApplicationBanner(String packageName)1133     public Drawable getApplicationBanner(String packageName)
1134             throws NameNotFoundException {
1135         return getApplicationBanner(getApplicationInfo(packageName, sDefaultFlags));
1136     }
1137 
1138     @Override
getActivityLogo(ComponentName activityName)1139     public Drawable getActivityLogo(ComponentName activityName)
1140             throws NameNotFoundException {
1141         return getActivityInfo(activityName, sDefaultFlags).loadLogo(this);
1142     }
1143 
1144     @Override
getActivityLogo(Intent intent)1145     public Drawable getActivityLogo(Intent intent)
1146             throws NameNotFoundException {
1147         if (intent.getComponent() != null) {
1148             return getActivityLogo(intent.getComponent());
1149         }
1150 
1151         ResolveInfo info = resolveActivity(
1152             intent, PackageManager.MATCH_DEFAULT_ONLY);
1153         if (info != null) {
1154             return info.activityInfo.loadLogo(this);
1155         }
1156 
1157         throw new NameNotFoundException(intent.toUri(0));
1158     }
1159 
1160     @Override
getApplicationLogo(ApplicationInfo info)1161     public Drawable getApplicationLogo(ApplicationInfo info) {
1162         return info.loadLogo(this);
1163     }
1164 
1165     @Override
getApplicationLogo(String packageName)1166     public Drawable getApplicationLogo(String packageName)
1167             throws NameNotFoundException {
1168         return getApplicationLogo(getApplicationInfo(packageName, sDefaultFlags));
1169     }
1170 
1171     @Override
getManagedUserBadgedDrawable(Drawable drawable, Rect badgeLocation, int badgeDensity)1172     public Drawable getManagedUserBadgedDrawable(Drawable drawable, Rect badgeLocation,
1173             int badgeDensity) {
1174         Drawable badgeDrawable = getDrawableForDensity(
1175             com.android.internal.R.drawable.ic_corp_badge, badgeDensity);
1176         return getBadgedDrawable(drawable, badgeDrawable, badgeLocation, true);
1177     }
1178 
1179     @Override
getUserBadgedIcon(Drawable icon, UserHandle user)1180     public Drawable getUserBadgedIcon(Drawable icon, UserHandle user) {
1181         final int badgeResId = getBadgeResIdForUser(user.getIdentifier());
1182         if (badgeResId == 0) {
1183             return icon;
1184         }
1185         Drawable badgeIcon = getDrawable("system", badgeResId, null);
1186         return getBadgedDrawable(icon, badgeIcon, null, true);
1187     }
1188 
1189     @Override
getUserBadgedDrawableForDensity(Drawable drawable, UserHandle user, Rect badgeLocation, int badgeDensity)1190     public Drawable getUserBadgedDrawableForDensity(Drawable drawable, UserHandle user,
1191             Rect badgeLocation, int badgeDensity) {
1192         Drawable badgeDrawable = getUserBadgeForDensity(user, badgeDensity);
1193         if (badgeDrawable == null) {
1194             return drawable;
1195         }
1196         return getBadgedDrawable(drawable, badgeDrawable, badgeLocation, true);
1197     }
1198 
1199     @Override
getUserBadgeForDensity(UserHandle user, int density)1200     public Drawable getUserBadgeForDensity(UserHandle user, int density) {
1201         return getManagedProfileIconForDensity(user, com.android.internal.R.drawable.ic_corp_badge,
1202                 density);
1203     }
1204 
1205     @Override
getUserBadgeForDensityNoBackground(UserHandle user, int density)1206     public Drawable getUserBadgeForDensityNoBackground(UserHandle user, int density) {
1207         return getManagedProfileIconForDensity(user,
1208                 com.android.internal.R.drawable.ic_corp_badge_no_background, density);
1209     }
1210 
getDrawableForDensity(int drawableId, int density)1211     private Drawable getDrawableForDensity(int drawableId, int density) {
1212         if (density <= 0) {
1213             density = mContext.getResources().getDisplayMetrics().densityDpi;
1214         }
1215         return Resources.getSystem().getDrawableForDensity(drawableId, density);
1216     }
1217 
getManagedProfileIconForDensity(UserHandle user, int drawableId, int density)1218     private Drawable getManagedProfileIconForDensity(UserHandle user, int drawableId, int density) {
1219         if (isManagedProfile(user.getIdentifier())) {
1220             return getDrawableForDensity(drawableId, density);
1221         }
1222         return null;
1223     }
1224 
1225     @Override
getUserBadgedLabel(CharSequence label, UserHandle user)1226     public CharSequence getUserBadgedLabel(CharSequence label, UserHandle user) {
1227         if (isManagedProfile(user.getIdentifier())) {
1228             return Resources.getSystem().getString(
1229                     com.android.internal.R.string.managed_profile_label_badge, label);
1230         }
1231         return label;
1232     }
1233 
1234     @Override
getResourcesForActivity(ComponentName activityName)1235     public Resources getResourcesForActivity(ComponentName activityName)
1236             throws NameNotFoundException {
1237         return getResourcesForApplication(
1238             getActivityInfo(activityName, sDefaultFlags).applicationInfo);
1239     }
1240 
1241     @Override
getResourcesForApplication(@onNull ApplicationInfo app)1242     public Resources getResourcesForApplication(@NonNull ApplicationInfo app)
1243             throws NameNotFoundException {
1244         if (app.packageName.equals("system")) {
1245             return mContext.mMainThread.getSystemContext().getResources();
1246         }
1247         final boolean sameUid = (app.uid == Process.myUid());
1248         try {
1249             return mContext.mMainThread.getTopLevelResources(
1250                     sameUid ? app.sourceDir : app.publicSourceDir,
1251                     sameUid ? app.splitSourceDirs : app.splitPublicSourceDirs,
1252                     app.resourceDirs, app.sharedLibraryFiles, Display.DEFAULT_DISPLAY,
1253                     mContext.mPackageInfo);
1254         } catch (Resources.NotFoundException cause) {
1255             final NameNotFoundException ex =
1256                     new NameNotFoundException("Unable to open " + app.publicSourceDir);
1257             ex.initCause(cause);
1258             throw ex;
1259         }
1260     }
1261 
1262     @Override
getResourcesForApplication(String appPackageName)1263     public Resources getResourcesForApplication(String appPackageName)
1264             throws NameNotFoundException {
1265         return getResourcesForApplication(
1266             getApplicationInfo(appPackageName, sDefaultFlags));
1267     }
1268 
1269     /** @hide */
1270     @Override
getResourcesForApplicationAsUser(String appPackageName, int userId)1271     public Resources getResourcesForApplicationAsUser(String appPackageName, int userId)
1272             throws NameNotFoundException {
1273         if (userId < 0) {
1274             throw new IllegalArgumentException(
1275                     "Call does not support special user #" + userId);
1276         }
1277         if ("system".equals(appPackageName)) {
1278             return mContext.mMainThread.getSystemContext().getResources();
1279         }
1280         try {
1281             ApplicationInfo ai = mPM.getApplicationInfo(appPackageName, sDefaultFlags, userId);
1282             if (ai != null) {
1283                 return getResourcesForApplication(ai);
1284             }
1285         } catch (RemoteException e) {
1286             throw e.rethrowFromSystemServer();
1287         }
1288         throw new NameNotFoundException("Package " + appPackageName + " doesn't exist");
1289     }
1290 
1291     volatile int mCachedSafeMode = -1;
1292 
1293     @Override
isSafeMode()1294     public boolean isSafeMode() {
1295         try {
1296             if (mCachedSafeMode < 0) {
1297                 mCachedSafeMode = mPM.isSafeMode() ? 1 : 0;
1298             }
1299             return mCachedSafeMode != 0;
1300         } catch (RemoteException e) {
1301             throw e.rethrowFromSystemServer();
1302         }
1303     }
1304 
1305     @Override
addOnPermissionsChangeListener(OnPermissionsChangedListener listener)1306     public void addOnPermissionsChangeListener(OnPermissionsChangedListener listener) {
1307         synchronized (mPermissionListeners) {
1308             if (mPermissionListeners.get(listener) != null) {
1309                 return;
1310             }
1311             OnPermissionsChangeListenerDelegate delegate =
1312                     new OnPermissionsChangeListenerDelegate(listener, Looper.getMainLooper());
1313             try {
1314                 mPM.addOnPermissionsChangeListener(delegate);
1315                 mPermissionListeners.put(listener, delegate);
1316             } catch (RemoteException e) {
1317                 throw e.rethrowFromSystemServer();
1318             }
1319         }
1320     }
1321 
1322     @Override
removeOnPermissionsChangeListener(OnPermissionsChangedListener listener)1323     public void removeOnPermissionsChangeListener(OnPermissionsChangedListener listener) {
1324         synchronized (mPermissionListeners) {
1325             IOnPermissionsChangeListener delegate = mPermissionListeners.get(listener);
1326             if (delegate != null) {
1327                 try {
1328                     mPM.removeOnPermissionsChangeListener(delegate);
1329                     mPermissionListeners.remove(listener);
1330                 } catch (RemoteException e) {
1331                     throw e.rethrowFromSystemServer();
1332                 }
1333             }
1334         }
1335     }
1336 
configurationChanged()1337     static void configurationChanged() {
1338         synchronized (sSync) {
1339             sIconCache.clear();
1340             sStringCache.clear();
1341         }
1342     }
1343 
ApplicationPackageManager(ContextImpl context, IPackageManager pm)1344     ApplicationPackageManager(ContextImpl context,
1345                               IPackageManager pm) {
1346         mContext = context;
1347         mPM = pm;
1348     }
1349 
1350     @Nullable
getCachedIcon(@onNull ResourceName name)1351     private Drawable getCachedIcon(@NonNull ResourceName name) {
1352         synchronized (sSync) {
1353             final WeakReference<Drawable.ConstantState> wr = sIconCache.get(name);
1354             if (DEBUG_ICONS) Log.v(TAG, "Get cached weak drawable ref for "
1355                                    + name + ": " + wr);
1356             if (wr != null) {   // we have the activity
1357                 final Drawable.ConstantState state = wr.get();
1358                 if (state != null) {
1359                     if (DEBUG_ICONS) {
1360                         Log.v(TAG, "Get cached drawable state for " + name + ": " + state);
1361                     }
1362                     // Note: It's okay here to not use the newDrawable(Resources) variant
1363                     //       of the API. The ConstantState comes from a drawable that was
1364                     //       originally created by passing the proper app Resources instance
1365                     //       which means the state should already contain the proper
1366                     //       resources specific information (like density.) See
1367                     //       BitmapDrawable.BitmapState for instance.
1368                     return state.newDrawable();
1369                 }
1370                 // our entry has been purged
1371                 sIconCache.remove(name);
1372             }
1373         }
1374         return null;
1375     }
1376 
putCachedIcon(@onNull ResourceName name, @NonNull Drawable dr)1377     private void putCachedIcon(@NonNull ResourceName name, @NonNull Drawable dr) {
1378         synchronized (sSync) {
1379             sIconCache.put(name, new WeakReference<>(dr.getConstantState()));
1380             if (DEBUG_ICONS) Log.v(TAG, "Added cached drawable state for " + name + ": " + dr);
1381         }
1382     }
1383 
handlePackageBroadcast(int cmd, String[] pkgList, boolean hasPkgInfo)1384     static void handlePackageBroadcast(int cmd, String[] pkgList, boolean hasPkgInfo) {
1385         boolean immediateGc = false;
1386         if (cmd == IApplicationThread.EXTERNAL_STORAGE_UNAVAILABLE) {
1387             immediateGc = true;
1388         }
1389         if (pkgList != null && (pkgList.length > 0)) {
1390             boolean needCleanup = false;
1391             for (String ssp : pkgList) {
1392                 synchronized (sSync) {
1393                     for (int i=sIconCache.size()-1; i>=0; i--) {
1394                         ResourceName nm = sIconCache.keyAt(i);
1395                         if (nm.packageName.equals(ssp)) {
1396                             //Log.i(TAG, "Removing cached drawable for " + nm);
1397                             sIconCache.removeAt(i);
1398                             needCleanup = true;
1399                         }
1400                     }
1401                     for (int i=sStringCache.size()-1; i>=0; i--) {
1402                         ResourceName nm = sStringCache.keyAt(i);
1403                         if (nm.packageName.equals(ssp)) {
1404                             //Log.i(TAG, "Removing cached string for " + nm);
1405                             sStringCache.removeAt(i);
1406                             needCleanup = true;
1407                         }
1408                     }
1409                 }
1410             }
1411             if (needCleanup || hasPkgInfo) {
1412                 if (immediateGc) {
1413                     // Schedule an immediate gc.
1414                     Runtime.getRuntime().gc();
1415                 } else {
1416                     ActivityThread.currentActivityThread().scheduleGcIdler();
1417                 }
1418             }
1419         }
1420     }
1421 
1422     private static final class ResourceName {
1423         final String packageName;
1424         final int iconId;
1425 
ResourceName(String _packageName, int _iconId)1426         ResourceName(String _packageName, int _iconId) {
1427             packageName = _packageName;
1428             iconId = _iconId;
1429         }
1430 
ResourceName(ApplicationInfo aInfo, int _iconId)1431         ResourceName(ApplicationInfo aInfo, int _iconId) {
1432             this(aInfo.packageName, _iconId);
1433         }
1434 
ResourceName(ComponentInfo cInfo, int _iconId)1435         ResourceName(ComponentInfo cInfo, int _iconId) {
1436             this(cInfo.applicationInfo.packageName, _iconId);
1437         }
1438 
ResourceName(ResolveInfo rInfo, int _iconId)1439         ResourceName(ResolveInfo rInfo, int _iconId) {
1440             this(rInfo.activityInfo.applicationInfo.packageName, _iconId);
1441         }
1442 
1443         @Override
equals(Object o)1444         public boolean equals(Object o) {
1445             if (this == o) return true;
1446             if (o == null || getClass() != o.getClass()) return false;
1447 
1448             ResourceName that = (ResourceName) o;
1449 
1450             if (iconId != that.iconId) return false;
1451             return !(packageName != null ?
1452                      !packageName.equals(that.packageName) : that.packageName != null);
1453 
1454         }
1455 
1456         @Override
hashCode()1457         public int hashCode() {
1458             int result;
1459             result = packageName.hashCode();
1460             result = 31 * result + iconId;
1461             return result;
1462         }
1463 
1464         @Override
toString()1465         public String toString() {
1466             return "{ResourceName " + packageName + " / " + iconId + "}";
1467         }
1468     }
1469 
getCachedString(ResourceName name)1470     private CharSequence getCachedString(ResourceName name) {
1471         synchronized (sSync) {
1472             WeakReference<CharSequence> wr = sStringCache.get(name);
1473             if (wr != null) {   // we have the activity
1474                 CharSequence cs = wr.get();
1475                 if (cs != null) {
1476                     return cs;
1477                 }
1478                 // our entry has been purged
1479                 sStringCache.remove(name);
1480             }
1481         }
1482         return null;
1483     }
1484 
putCachedString(ResourceName name, CharSequence cs)1485     private void putCachedString(ResourceName name, CharSequence cs) {
1486         synchronized (sSync) {
1487             sStringCache.put(name, new WeakReference<CharSequence>(cs));
1488         }
1489     }
1490 
1491     @Override
getText(String packageName, @StringRes int resid, ApplicationInfo appInfo)1492     public CharSequence getText(String packageName, @StringRes int resid,
1493                                 ApplicationInfo appInfo) {
1494         ResourceName name = new ResourceName(packageName, resid);
1495         CharSequence text = getCachedString(name);
1496         if (text != null) {
1497             return text;
1498         }
1499         if (appInfo == null) {
1500             try {
1501                 appInfo = getApplicationInfo(packageName, sDefaultFlags);
1502             } catch (NameNotFoundException e) {
1503                 return null;
1504             }
1505         }
1506         try {
1507             Resources r = getResourcesForApplication(appInfo);
1508             text = r.getText(resid);
1509             putCachedString(name, text);
1510             return text;
1511         } catch (NameNotFoundException e) {
1512             Log.w("PackageManager", "Failure retrieving resources for "
1513                   + appInfo.packageName);
1514         } catch (RuntimeException e) {
1515             // If an exception was thrown, fall through to return
1516             // default icon.
1517             Log.w("PackageManager", "Failure retrieving text 0x"
1518                   + Integer.toHexString(resid) + " in package "
1519                   + packageName, e);
1520         }
1521         return null;
1522     }
1523 
1524     @Override
getXml(String packageName, @XmlRes int resid, ApplicationInfo appInfo)1525     public XmlResourceParser getXml(String packageName, @XmlRes int resid,
1526                                     ApplicationInfo appInfo) {
1527         if (appInfo == null) {
1528             try {
1529                 appInfo = getApplicationInfo(packageName, sDefaultFlags);
1530             } catch (NameNotFoundException e) {
1531                 return null;
1532             }
1533         }
1534         try {
1535             Resources r = getResourcesForApplication(appInfo);
1536             return r.getXml(resid);
1537         } catch (RuntimeException e) {
1538             // If an exception was thrown, fall through to return
1539             // default icon.
1540             Log.w("PackageManager", "Failure retrieving xml 0x"
1541                   + Integer.toHexString(resid) + " in package "
1542                   + packageName, e);
1543         } catch (NameNotFoundException e) {
1544             Log.w("PackageManager", "Failure retrieving resources for "
1545                   + appInfo.packageName);
1546         }
1547         return null;
1548     }
1549 
1550     @Override
getApplicationLabel(ApplicationInfo info)1551     public CharSequence getApplicationLabel(ApplicationInfo info) {
1552         return info.loadLabel(this);
1553     }
1554 
1555     @Override
installPackage(Uri packageURI, IPackageInstallObserver observer, int flags, String installerPackageName)1556     public void installPackage(Uri packageURI, IPackageInstallObserver observer, int flags,
1557                                String installerPackageName) {
1558         installCommon(packageURI, new LegacyPackageInstallObserver(observer), flags,
1559                 installerPackageName, mContext.getUserId());
1560     }
1561 
1562     @Override
installPackage(Uri packageURI, PackageInstallObserver observer, int flags, String installerPackageName)1563     public void installPackage(Uri packageURI, PackageInstallObserver observer,
1564             int flags, String installerPackageName) {
1565         installCommon(packageURI, observer, flags, installerPackageName, mContext.getUserId());
1566     }
1567 
installCommon(Uri packageURI, PackageInstallObserver observer, int flags, String installerPackageName, int userId)1568     private void installCommon(Uri packageURI,
1569             PackageInstallObserver observer, int flags, String installerPackageName,
1570             int userId) {
1571         if (!"file".equals(packageURI.getScheme())) {
1572             throw new UnsupportedOperationException("Only file:// URIs are supported");
1573         }
1574 
1575         final String originPath = packageURI.getPath();
1576         try {
1577             mPM.installPackageAsUser(originPath, observer.getBinder(), flags, installerPackageName,
1578                     userId);
1579         } catch (RemoteException e) {
1580             throw e.rethrowFromSystemServer();
1581         }
1582     }
1583 
1584     @Override
installExistingPackage(String packageName)1585     public int installExistingPackage(String packageName) throws NameNotFoundException {
1586         return installExistingPackageAsUser(packageName, mContext.getUserId());
1587     }
1588 
1589     @Override
installExistingPackageAsUser(String packageName, int userId)1590     public int installExistingPackageAsUser(String packageName, int userId)
1591             throws NameNotFoundException {
1592         try {
1593             int res = mPM.installExistingPackageAsUser(packageName, userId);
1594             if (res == INSTALL_FAILED_INVALID_URI) {
1595                 throw new NameNotFoundException("Package " + packageName + " doesn't exist");
1596             }
1597             return res;
1598         } catch (RemoteException e) {
1599             throw e.rethrowFromSystemServer();
1600         }
1601     }
1602 
1603     @Override
verifyPendingInstall(int id, int response)1604     public void verifyPendingInstall(int id, int response) {
1605         try {
1606             mPM.verifyPendingInstall(id, response);
1607         } catch (RemoteException e) {
1608             throw e.rethrowFromSystemServer();
1609         }
1610     }
1611 
1612     @Override
extendVerificationTimeout(int id, int verificationCodeAtTimeout, long millisecondsToDelay)1613     public void extendVerificationTimeout(int id, int verificationCodeAtTimeout,
1614             long millisecondsToDelay) {
1615         try {
1616             mPM.extendVerificationTimeout(id, verificationCodeAtTimeout, millisecondsToDelay);
1617         } catch (RemoteException e) {
1618             throw e.rethrowFromSystemServer();
1619         }
1620     }
1621 
1622     @Override
verifyIntentFilter(int id, int verificationCode, List<String> failedDomains)1623     public void verifyIntentFilter(int id, int verificationCode, List<String> failedDomains) {
1624         try {
1625             mPM.verifyIntentFilter(id, verificationCode, failedDomains);
1626         } catch (RemoteException e) {
1627             throw e.rethrowFromSystemServer();
1628         }
1629     }
1630 
1631     @Override
getIntentVerificationStatusAsUser(String packageName, int userId)1632     public int getIntentVerificationStatusAsUser(String packageName, int userId) {
1633         try {
1634             return mPM.getIntentVerificationStatus(packageName, userId);
1635         } catch (RemoteException e) {
1636             throw e.rethrowFromSystemServer();
1637         }
1638     }
1639 
1640     @Override
updateIntentVerificationStatusAsUser(String packageName, int status, int userId)1641     public boolean updateIntentVerificationStatusAsUser(String packageName, int status, int userId) {
1642         try {
1643             return mPM.updateIntentVerificationStatus(packageName, status, userId);
1644         } catch (RemoteException e) {
1645             throw e.rethrowFromSystemServer();
1646         }
1647     }
1648 
1649     @Override
1650     @SuppressWarnings("unchecked")
getIntentFilterVerifications(String packageName)1651     public List<IntentFilterVerificationInfo> getIntentFilterVerifications(String packageName) {
1652         try {
1653             ParceledListSlice<IntentFilterVerificationInfo> parceledList =
1654                     mPM.getIntentFilterVerifications(packageName);
1655             if (parceledList == null) {
1656                 return Collections.emptyList();
1657             }
1658             return parceledList.getList();
1659         } catch (RemoteException e) {
1660             throw e.rethrowFromSystemServer();
1661         }
1662     }
1663 
1664     @Override
1665     @SuppressWarnings("unchecked")
getAllIntentFilters(String packageName)1666     public List<IntentFilter> getAllIntentFilters(String packageName) {
1667         try {
1668             ParceledListSlice<IntentFilter> parceledList =
1669                     mPM.getAllIntentFilters(packageName);
1670             if (parceledList == null) {
1671                 return Collections.emptyList();
1672             }
1673             return parceledList.getList();
1674         } catch (RemoteException e) {
1675             throw e.rethrowFromSystemServer();
1676         }
1677     }
1678 
1679     @Override
getDefaultBrowserPackageNameAsUser(int userId)1680     public String getDefaultBrowserPackageNameAsUser(int userId) {
1681         try {
1682             return mPM.getDefaultBrowserPackageName(userId);
1683         } catch (RemoteException e) {
1684             throw e.rethrowFromSystemServer();
1685         }
1686     }
1687 
1688     @Override
setDefaultBrowserPackageNameAsUser(String packageName, int userId)1689     public boolean setDefaultBrowserPackageNameAsUser(String packageName, int userId) {
1690         try {
1691             return mPM.setDefaultBrowserPackageName(packageName, userId);
1692         } catch (RemoteException e) {
1693             throw e.rethrowFromSystemServer();
1694         }
1695     }
1696 
1697     @Override
setInstallerPackageName(String targetPackage, String installerPackageName)1698     public void setInstallerPackageName(String targetPackage,
1699             String installerPackageName) {
1700         try {
1701             mPM.setInstallerPackageName(targetPackage, installerPackageName);
1702         } catch (RemoteException e) {
1703             throw e.rethrowFromSystemServer();
1704         }
1705     }
1706 
1707     @Override
getInstallerPackageName(String packageName)1708     public String getInstallerPackageName(String packageName) {
1709         try {
1710             return mPM.getInstallerPackageName(packageName);
1711         } catch (RemoteException e) {
1712             throw e.rethrowFromSystemServer();
1713         }
1714     }
1715 
1716     @Override
getMoveStatus(int moveId)1717     public int getMoveStatus(int moveId) {
1718         try {
1719             return mPM.getMoveStatus(moveId);
1720         } catch (RemoteException e) {
1721             throw e.rethrowFromSystemServer();
1722         }
1723     }
1724 
1725     @Override
registerMoveCallback(MoveCallback callback, Handler handler)1726     public void registerMoveCallback(MoveCallback callback, Handler handler) {
1727         synchronized (mDelegates) {
1728             final MoveCallbackDelegate delegate = new MoveCallbackDelegate(callback,
1729                     handler.getLooper());
1730             try {
1731                 mPM.registerMoveCallback(delegate);
1732             } catch (RemoteException e) {
1733                 throw e.rethrowFromSystemServer();
1734             }
1735             mDelegates.add(delegate);
1736         }
1737     }
1738 
1739     @Override
unregisterMoveCallback(MoveCallback callback)1740     public void unregisterMoveCallback(MoveCallback callback) {
1741         synchronized (mDelegates) {
1742             for (Iterator<MoveCallbackDelegate> i = mDelegates.iterator(); i.hasNext();) {
1743                 final MoveCallbackDelegate delegate = i.next();
1744                 if (delegate.mCallback == callback) {
1745                     try {
1746                         mPM.unregisterMoveCallback(delegate);
1747                     } catch (RemoteException e) {
1748                         throw e.rethrowFromSystemServer();
1749                     }
1750                     i.remove();
1751                 }
1752             }
1753         }
1754     }
1755 
1756     @Override
movePackage(String packageName, VolumeInfo vol)1757     public int movePackage(String packageName, VolumeInfo vol) {
1758         try {
1759             final String volumeUuid;
1760             if (VolumeInfo.ID_PRIVATE_INTERNAL.equals(vol.id)) {
1761                 volumeUuid = StorageManager.UUID_PRIVATE_INTERNAL;
1762             } else if (vol.isPrimaryPhysical()) {
1763                 volumeUuid = StorageManager.UUID_PRIMARY_PHYSICAL;
1764             } else {
1765                 volumeUuid = Preconditions.checkNotNull(vol.fsUuid);
1766             }
1767 
1768             return mPM.movePackage(packageName, volumeUuid);
1769         } catch (RemoteException e) {
1770             throw e.rethrowFromSystemServer();
1771         }
1772     }
1773 
1774     @Override
getPackageCurrentVolume(ApplicationInfo app)1775     public @Nullable VolumeInfo getPackageCurrentVolume(ApplicationInfo app) {
1776         final StorageManager storage = mContext.getSystemService(StorageManager.class);
1777         if (app.isInternal()) {
1778             return storage.findVolumeById(VolumeInfo.ID_PRIVATE_INTERNAL);
1779         } else if (app.isExternalAsec()) {
1780             return storage.getPrimaryPhysicalVolume();
1781         } else {
1782             return storage.findVolumeByUuid(app.volumeUuid);
1783         }
1784     }
1785 
1786     @Override
getPackageCandidateVolumes(ApplicationInfo app)1787     public @NonNull List<VolumeInfo> getPackageCandidateVolumes(ApplicationInfo app) {
1788         final StorageManager storage = mContext.getSystemService(StorageManager.class);
1789         final VolumeInfo currentVol = getPackageCurrentVolume(app);
1790         final List<VolumeInfo> vols = storage.getVolumes();
1791         final List<VolumeInfo> candidates = new ArrayList<>();
1792         for (VolumeInfo vol : vols) {
1793             if (Objects.equals(vol, currentVol) || isPackageCandidateVolume(mContext, app, vol)) {
1794                 candidates.add(vol);
1795             }
1796         }
1797         return candidates;
1798     }
1799 
isPackageCandidateVolume( ContextImpl context, ApplicationInfo app, VolumeInfo vol)1800     private boolean isPackageCandidateVolume(
1801             ContextImpl context, ApplicationInfo app, VolumeInfo vol) {
1802         final boolean forceAllowOnExternal = Settings.Global.getInt(
1803                 context.getContentResolver(), Settings.Global.FORCE_ALLOW_ON_EXTERNAL, 0) != 0;
1804         // Private internal is always an option
1805         if (VolumeInfo.ID_PRIVATE_INTERNAL.equals(vol.getId())) {
1806             return true;
1807         }
1808 
1809         // System apps and apps demanding internal storage can't be moved
1810         // anywhere else
1811         if (app.isSystemApp()) {
1812             return false;
1813         }
1814         if (!forceAllowOnExternal
1815                 && (app.installLocation == PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY
1816                         || app.installLocation == PackageInfo.INSTALL_LOCATION_UNSPECIFIED)) {
1817             return false;
1818         }
1819 
1820         // Gotta be able to write there
1821         if (!vol.isMountedWritable()) {
1822             return false;
1823         }
1824 
1825         // Moving into an ASEC on public primary is only option internal
1826         if (vol.isPrimaryPhysical()) {
1827             return app.isInternal();
1828         }
1829 
1830         // Some apps can't be moved. (e.g. device admins)
1831         try {
1832             if (mPM.isPackageDeviceAdminOnAnyUser(app.packageName)) {
1833                 return false;
1834             }
1835         } catch (RemoteException e) {
1836             throw e.rethrowFromSystemServer();
1837         }
1838 
1839         // Otherwise we can move to any private volume
1840         return (vol.getType() == VolumeInfo.TYPE_PRIVATE);
1841     }
1842 
1843     @Override
movePrimaryStorage(VolumeInfo vol)1844     public int movePrimaryStorage(VolumeInfo vol) {
1845         try {
1846             final String volumeUuid;
1847             if (VolumeInfo.ID_PRIVATE_INTERNAL.equals(vol.id)) {
1848                 volumeUuid = StorageManager.UUID_PRIVATE_INTERNAL;
1849             } else if (vol.isPrimaryPhysical()) {
1850                 volumeUuid = StorageManager.UUID_PRIMARY_PHYSICAL;
1851             } else {
1852                 volumeUuid = Preconditions.checkNotNull(vol.fsUuid);
1853             }
1854 
1855             return mPM.movePrimaryStorage(volumeUuid);
1856         } catch (RemoteException e) {
1857             throw e.rethrowFromSystemServer();
1858         }
1859     }
1860 
1861     @Override
getPrimaryStorageCurrentVolume()1862     public @Nullable VolumeInfo getPrimaryStorageCurrentVolume() {
1863         final StorageManager storage = mContext.getSystemService(StorageManager.class);
1864         final String volumeUuid = storage.getPrimaryStorageUuid();
1865         return storage.findVolumeByQualifiedUuid(volumeUuid);
1866     }
1867 
1868     @Override
getPrimaryStorageCandidateVolumes()1869     public @NonNull List<VolumeInfo> getPrimaryStorageCandidateVolumes() {
1870         final StorageManager storage = mContext.getSystemService(StorageManager.class);
1871         final VolumeInfo currentVol = getPrimaryStorageCurrentVolume();
1872         final List<VolumeInfo> vols = storage.getVolumes();
1873         final List<VolumeInfo> candidates = new ArrayList<>();
1874         if (Objects.equals(StorageManager.UUID_PRIMARY_PHYSICAL,
1875                 storage.getPrimaryStorageUuid()) && currentVol != null) {
1876             // TODO: support moving primary physical to emulated volume
1877             candidates.add(currentVol);
1878         } else {
1879             for (VolumeInfo vol : vols) {
1880                 if (Objects.equals(vol, currentVol) || isPrimaryStorageCandidateVolume(vol)) {
1881                     candidates.add(vol);
1882                 }
1883             }
1884         }
1885         return candidates;
1886     }
1887 
isPrimaryStorageCandidateVolume(VolumeInfo vol)1888     private static boolean isPrimaryStorageCandidateVolume(VolumeInfo vol) {
1889         // Private internal is always an option
1890         if (VolumeInfo.ID_PRIVATE_INTERNAL.equals(vol.getId())) {
1891             return true;
1892         }
1893 
1894         // Gotta be able to write there
1895         if (!vol.isMountedWritable()) {
1896             return false;
1897         }
1898 
1899         // We can move to any private volume
1900         return (vol.getType() == VolumeInfo.TYPE_PRIVATE);
1901     }
1902 
1903     @Override
deletePackage(String packageName, IPackageDeleteObserver observer, int flags)1904     public void deletePackage(String packageName, IPackageDeleteObserver observer, int flags) {
1905         deletePackageAsUser(packageName, observer, flags, mContext.getUserId());
1906     }
1907 
1908     @Override
deletePackageAsUser(String packageName, IPackageDeleteObserver observer, int flags, int userId)1909     public void deletePackageAsUser(String packageName, IPackageDeleteObserver observer, int flags,
1910             int userId) {
1911         try {
1912             mPM.deletePackageAsUser(packageName, observer, userId, flags);
1913         } catch (RemoteException e) {
1914             throw e.rethrowFromSystemServer();
1915         }
1916     }
1917 
1918     @Override
clearApplicationUserData(String packageName, IPackageDataObserver observer)1919     public void clearApplicationUserData(String packageName,
1920                                          IPackageDataObserver observer) {
1921         try {
1922             mPM.clearApplicationUserData(packageName, observer, mContext.getUserId());
1923         } catch (RemoteException e) {
1924             throw e.rethrowFromSystemServer();
1925         }
1926     }
1927     @Override
deleteApplicationCacheFiles(String packageName, IPackageDataObserver observer)1928     public void deleteApplicationCacheFiles(String packageName,
1929                                             IPackageDataObserver observer) {
1930         try {
1931             mPM.deleteApplicationCacheFiles(packageName, observer);
1932         } catch (RemoteException e) {
1933             throw e.rethrowFromSystemServer();
1934         }
1935     }
1936 
1937     @Override
deleteApplicationCacheFilesAsUser(String packageName, int userId, IPackageDataObserver observer)1938     public void deleteApplicationCacheFilesAsUser(String packageName, int userId,
1939             IPackageDataObserver observer) {
1940         try {
1941             mPM.deleteApplicationCacheFilesAsUser(packageName, userId, observer);
1942         } catch (RemoteException e) {
1943             throw e.rethrowFromSystemServer();
1944         }
1945     }
1946 
1947     @Override
freeStorageAndNotify(String volumeUuid, long idealStorageSize, IPackageDataObserver observer)1948     public void freeStorageAndNotify(String volumeUuid, long idealStorageSize,
1949             IPackageDataObserver observer) {
1950         try {
1951             mPM.freeStorageAndNotify(volumeUuid, idealStorageSize, observer);
1952         } catch (RemoteException e) {
1953             throw e.rethrowFromSystemServer();
1954         }
1955     }
1956 
1957     @Override
freeStorage(String volumeUuid, long freeStorageSize, IntentSender pi)1958     public void freeStorage(String volumeUuid, long freeStorageSize, IntentSender pi) {
1959         try {
1960             mPM.freeStorage(volumeUuid, freeStorageSize, pi);
1961         } catch (RemoteException e) {
1962             throw e.rethrowFromSystemServer();
1963         }
1964     }
1965 
1966     @Override
setPackagesSuspendedAsUser(String[] packageNames, boolean suspended, int userId)1967     public String[] setPackagesSuspendedAsUser(String[] packageNames, boolean suspended,
1968             int userId) {
1969         try {
1970             return mPM.setPackagesSuspendedAsUser(packageNames, suspended, userId);
1971         } catch (RemoteException e) {
1972             throw e.rethrowFromSystemServer();
1973         }
1974     }
1975 
1976     @Override
isPackageSuspendedForUser(String packageName, int userId)1977     public boolean isPackageSuspendedForUser(String packageName, int userId) {
1978         try {
1979             return mPM.isPackageSuspendedForUser(packageName, userId);
1980         } catch (RemoteException e) {
1981             throw e.rethrowFromSystemServer();
1982         }
1983     }
1984 
1985     @Override
getPackageSizeInfoAsUser(String packageName, int userHandle, IPackageStatsObserver observer)1986     public void getPackageSizeInfoAsUser(String packageName, int userHandle,
1987             IPackageStatsObserver observer) {
1988         try {
1989             mPM.getPackageSizeInfo(packageName, userHandle, observer);
1990         } catch (RemoteException e) {
1991             throw e.rethrowFromSystemServer();
1992         }
1993     }
1994 
1995     @Override
addPackageToPreferred(String packageName)1996     public void addPackageToPreferred(String packageName) {
1997         Log.w(TAG, "addPackageToPreferred() is a no-op");
1998     }
1999 
2000     @Override
removePackageFromPreferred(String packageName)2001     public void removePackageFromPreferred(String packageName) {
2002         Log.w(TAG, "removePackageFromPreferred() is a no-op");
2003     }
2004 
2005     @Override
getPreferredPackages(int flags)2006     public List<PackageInfo> getPreferredPackages(int flags) {
2007         Log.w(TAG, "getPreferredPackages() is a no-op");
2008         return Collections.emptyList();
2009     }
2010 
2011     @Override
addPreferredActivity(IntentFilter filter, int match, ComponentName[] set, ComponentName activity)2012     public void addPreferredActivity(IntentFilter filter,
2013                                      int match, ComponentName[] set, ComponentName activity) {
2014         try {
2015             mPM.addPreferredActivity(filter, match, set, activity, mContext.getUserId());
2016         } catch (RemoteException e) {
2017             throw e.rethrowFromSystemServer();
2018         }
2019     }
2020 
2021     @Override
addPreferredActivityAsUser(IntentFilter filter, int match, ComponentName[] set, ComponentName activity, int userId)2022     public void addPreferredActivityAsUser(IntentFilter filter, int match,
2023             ComponentName[] set, ComponentName activity, int userId) {
2024         try {
2025             mPM.addPreferredActivity(filter, match, set, activity, userId);
2026         } catch (RemoteException e) {
2027             throw e.rethrowFromSystemServer();
2028         }
2029     }
2030 
2031     @Override
replacePreferredActivity(IntentFilter filter, int match, ComponentName[] set, ComponentName activity)2032     public void replacePreferredActivity(IntentFilter filter,
2033                                          int match, ComponentName[] set, ComponentName activity) {
2034         try {
2035             mPM.replacePreferredActivity(filter, match, set, activity, mContext.getUserId());
2036         } catch (RemoteException e) {
2037             throw e.rethrowFromSystemServer();
2038         }
2039     }
2040 
2041     @Override
replacePreferredActivityAsUser(IntentFilter filter, int match, ComponentName[] set, ComponentName activity, int userId)2042     public void replacePreferredActivityAsUser(IntentFilter filter,
2043                                          int match, ComponentName[] set, ComponentName activity,
2044                                          int userId) {
2045         try {
2046             mPM.replacePreferredActivity(filter, match, set, activity, userId);
2047         } catch (RemoteException e) {
2048             throw e.rethrowFromSystemServer();
2049         }
2050     }
2051 
2052     @Override
clearPackagePreferredActivities(String packageName)2053     public void clearPackagePreferredActivities(String packageName) {
2054         try {
2055             mPM.clearPackagePreferredActivities(packageName);
2056         } catch (RemoteException e) {
2057             throw e.rethrowFromSystemServer();
2058         }
2059     }
2060 
2061     @Override
getPreferredActivities(List<IntentFilter> outFilters, List<ComponentName> outActivities, String packageName)2062     public int getPreferredActivities(List<IntentFilter> outFilters,
2063                                       List<ComponentName> outActivities, String packageName) {
2064         try {
2065             return mPM.getPreferredActivities(outFilters, outActivities, packageName);
2066         } catch (RemoteException e) {
2067             throw e.rethrowFromSystemServer();
2068         }
2069     }
2070 
2071     @Override
getHomeActivities(List<ResolveInfo> outActivities)2072     public ComponentName getHomeActivities(List<ResolveInfo> outActivities) {
2073         try {
2074             return mPM.getHomeActivities(outActivities);
2075         } catch (RemoteException e) {
2076             throw e.rethrowFromSystemServer();
2077         }
2078     }
2079 
2080     @Override
setComponentEnabledSetting(ComponentName componentName, int newState, int flags)2081     public void setComponentEnabledSetting(ComponentName componentName,
2082                                            int newState, int flags) {
2083         try {
2084             mPM.setComponentEnabledSetting(componentName, newState, flags, mContext.getUserId());
2085         } catch (RemoteException e) {
2086             throw e.rethrowFromSystemServer();
2087         }
2088     }
2089 
2090     @Override
getComponentEnabledSetting(ComponentName componentName)2091     public int getComponentEnabledSetting(ComponentName componentName) {
2092         try {
2093             return mPM.getComponentEnabledSetting(componentName, mContext.getUserId());
2094         } catch (RemoteException e) {
2095             throw e.rethrowFromSystemServer();
2096         }
2097     }
2098 
2099     @Override
setApplicationEnabledSetting(String packageName, int newState, int flags)2100     public void setApplicationEnabledSetting(String packageName,
2101                                              int newState, int flags) {
2102         try {
2103             mPM.setApplicationEnabledSetting(packageName, newState, flags,
2104                     mContext.getUserId(), mContext.getOpPackageName());
2105         } catch (RemoteException e) {
2106             throw e.rethrowFromSystemServer();
2107         }
2108     }
2109 
2110     @Override
getApplicationEnabledSetting(String packageName)2111     public int getApplicationEnabledSetting(String packageName) {
2112         try {
2113             return mPM.getApplicationEnabledSetting(packageName, mContext.getUserId());
2114         } catch (RemoteException e) {
2115             throw e.rethrowFromSystemServer();
2116         }
2117     }
2118 
2119     @Override
flushPackageRestrictionsAsUser(int userId)2120     public void flushPackageRestrictionsAsUser(int userId) {
2121         try {
2122             mPM.flushPackageRestrictionsAsUser(userId);
2123         } catch (RemoteException e) {
2124             throw e.rethrowFromSystemServer();
2125         }
2126     }
2127 
2128     @Override
setApplicationHiddenSettingAsUser(String packageName, boolean hidden, UserHandle user)2129     public boolean setApplicationHiddenSettingAsUser(String packageName, boolean hidden,
2130             UserHandle user) {
2131         try {
2132             return mPM.setApplicationHiddenSettingAsUser(packageName, hidden,
2133                     user.getIdentifier());
2134         } catch (RemoteException e) {
2135             throw e.rethrowFromSystemServer();
2136         }
2137     }
2138 
2139     @Override
getApplicationHiddenSettingAsUser(String packageName, UserHandle user)2140     public boolean getApplicationHiddenSettingAsUser(String packageName, UserHandle user) {
2141         try {
2142             return mPM.getApplicationHiddenSettingAsUser(packageName, user.getIdentifier());
2143         } catch (RemoteException e) {
2144             throw e.rethrowFromSystemServer();
2145         }
2146     }
2147 
2148     /** @hide */
2149     @Override
getKeySetByAlias(String packageName, String alias)2150     public KeySet getKeySetByAlias(String packageName, String alias) {
2151         Preconditions.checkNotNull(packageName);
2152         Preconditions.checkNotNull(alias);
2153         try {
2154             return mPM.getKeySetByAlias(packageName, alias);
2155         } catch (RemoteException e) {
2156             throw e.rethrowFromSystemServer();
2157         }
2158     }
2159 
2160     /** @hide */
2161     @Override
getSigningKeySet(String packageName)2162     public KeySet getSigningKeySet(String packageName) {
2163         Preconditions.checkNotNull(packageName);
2164         try {
2165             return mPM.getSigningKeySet(packageName);
2166         } catch (RemoteException e) {
2167             throw e.rethrowFromSystemServer();
2168         }
2169     }
2170 
2171     /** @hide */
2172     @Override
isSignedBy(String packageName, KeySet ks)2173     public boolean isSignedBy(String packageName, KeySet ks) {
2174         Preconditions.checkNotNull(packageName);
2175         Preconditions.checkNotNull(ks);
2176         try {
2177             return mPM.isPackageSignedByKeySet(packageName, ks);
2178         } catch (RemoteException e) {
2179             throw e.rethrowFromSystemServer();
2180         }
2181     }
2182 
2183     /** @hide */
2184     @Override
isSignedByExactly(String packageName, KeySet ks)2185     public boolean isSignedByExactly(String packageName, KeySet ks) {
2186         Preconditions.checkNotNull(packageName);
2187         Preconditions.checkNotNull(ks);
2188         try {
2189             return mPM.isPackageSignedByKeySetExactly(packageName, ks);
2190         } catch (RemoteException e) {
2191             throw e.rethrowFromSystemServer();
2192         }
2193     }
2194 
2195     /**
2196      * @hide
2197      */
2198     @Override
getVerifierDeviceIdentity()2199     public VerifierDeviceIdentity getVerifierDeviceIdentity() {
2200         try {
2201             return mPM.getVerifierDeviceIdentity();
2202         } catch (RemoteException e) {
2203             throw e.rethrowFromSystemServer();
2204         }
2205     }
2206 
2207     /**
2208      * @hide
2209      */
2210     @Override
isUpgrade()2211     public boolean isUpgrade() {
2212         try {
2213             return mPM.isUpgrade();
2214         } catch (RemoteException e) {
2215             throw e.rethrowFromSystemServer();
2216         }
2217     }
2218 
2219     @Override
getPackageInstaller()2220     public PackageInstaller getPackageInstaller() {
2221         synchronized (mLock) {
2222             if (mInstaller == null) {
2223                 try {
2224                     mInstaller = new PackageInstaller(mContext, this, mPM.getPackageInstaller(),
2225                             mContext.getPackageName(), mContext.getUserId());
2226                 } catch (RemoteException e) {
2227                     throw e.rethrowFromSystemServer();
2228                 }
2229             }
2230             return mInstaller;
2231         }
2232     }
2233 
2234     @Override
isPackageAvailable(String packageName)2235     public boolean isPackageAvailable(String packageName) {
2236         try {
2237             return mPM.isPackageAvailable(packageName, mContext.getUserId());
2238         } catch (RemoteException e) {
2239             throw e.rethrowFromSystemServer();
2240         }
2241     }
2242 
2243     /**
2244      * @hide
2245      */
2246     @Override
addCrossProfileIntentFilter(IntentFilter filter, int sourceUserId, int targetUserId, int flags)2247     public void addCrossProfileIntentFilter(IntentFilter filter, int sourceUserId, int targetUserId,
2248             int flags) {
2249         try {
2250             mPM.addCrossProfileIntentFilter(filter, mContext.getOpPackageName(),
2251                     sourceUserId, targetUserId, flags);
2252         } catch (RemoteException e) {
2253             throw e.rethrowFromSystemServer();
2254         }
2255     }
2256 
2257     /**
2258      * @hide
2259      */
2260     @Override
clearCrossProfileIntentFilters(int sourceUserId)2261     public void clearCrossProfileIntentFilters(int sourceUserId) {
2262         try {
2263             mPM.clearCrossProfileIntentFilters(sourceUserId, mContext.getOpPackageName());
2264         } catch (RemoteException e) {
2265             throw e.rethrowFromSystemServer();
2266         }
2267     }
2268 
2269     /**
2270      * @hide
2271      */
loadItemIcon(PackageItemInfo itemInfo, ApplicationInfo appInfo)2272     public Drawable loadItemIcon(PackageItemInfo itemInfo, ApplicationInfo appInfo) {
2273         Drawable dr = loadUnbadgedItemIcon(itemInfo, appInfo);
2274         if (itemInfo.showUserIcon != UserHandle.USER_NULL) {
2275             return dr;
2276         }
2277         return getUserBadgedIcon(dr, new UserHandle(mContext.getUserId()));
2278     }
2279 
2280     /**
2281      * @hide
2282      */
loadUnbadgedItemIcon(PackageItemInfo itemInfo, ApplicationInfo appInfo)2283     public Drawable loadUnbadgedItemIcon(PackageItemInfo itemInfo, ApplicationInfo appInfo) {
2284         if (itemInfo.showUserIcon != UserHandle.USER_NULL) {
2285             Bitmap bitmap = getUserManager().getUserIcon(itemInfo.showUserIcon);
2286             if (bitmap == null) {
2287                 return UserIcons.getDefaultUserIcon(itemInfo.showUserIcon, /* light= */ false);
2288             }
2289             return new BitmapDrawable(bitmap);
2290         }
2291         Drawable dr = null;
2292         if (itemInfo.packageName != null) {
2293             dr = getDrawable(itemInfo.packageName, itemInfo.icon, appInfo);
2294         }
2295         if (dr == null) {
2296             dr = itemInfo.loadDefaultIcon(this);
2297         }
2298         return dr;
2299     }
2300 
getBadgedDrawable(Drawable drawable, Drawable badgeDrawable, Rect badgeLocation, boolean tryBadgeInPlace)2301     private Drawable getBadgedDrawable(Drawable drawable, Drawable badgeDrawable,
2302             Rect badgeLocation, boolean tryBadgeInPlace) {
2303         final int badgedWidth = drawable.getIntrinsicWidth();
2304         final int badgedHeight = drawable.getIntrinsicHeight();
2305         final boolean canBadgeInPlace = tryBadgeInPlace
2306                 && (drawable instanceof BitmapDrawable)
2307                 && ((BitmapDrawable) drawable).getBitmap().isMutable();
2308 
2309         final Bitmap bitmap;
2310         if (canBadgeInPlace) {
2311             bitmap = ((BitmapDrawable) drawable).getBitmap();
2312         } else {
2313             bitmap = Bitmap.createBitmap(badgedWidth, badgedHeight, Bitmap.Config.ARGB_8888);
2314         }
2315         Canvas canvas = new Canvas(bitmap);
2316 
2317         if (!canBadgeInPlace) {
2318             drawable.setBounds(0, 0, badgedWidth, badgedHeight);
2319             drawable.draw(canvas);
2320         }
2321 
2322         if (badgeLocation != null) {
2323             if (badgeLocation.left < 0 || badgeLocation.top < 0
2324                     || badgeLocation.width() > badgedWidth || badgeLocation.height() > badgedHeight) {
2325                 throw new IllegalArgumentException("Badge location " + badgeLocation
2326                         + " not in badged drawable bounds "
2327                         + new Rect(0, 0, badgedWidth, badgedHeight));
2328             }
2329             badgeDrawable.setBounds(0, 0, badgeLocation.width(), badgeLocation.height());
2330 
2331             canvas.save();
2332             canvas.translate(badgeLocation.left, badgeLocation.top);
2333             badgeDrawable.draw(canvas);
2334             canvas.restore();
2335         } else {
2336             badgeDrawable.setBounds(0, 0, badgedWidth, badgedHeight);
2337             badgeDrawable.draw(canvas);
2338         }
2339 
2340         if (!canBadgeInPlace) {
2341             BitmapDrawable mergedDrawable = new BitmapDrawable(mContext.getResources(), bitmap);
2342 
2343             if (drawable instanceof BitmapDrawable) {
2344                 BitmapDrawable bitmapDrawable = (BitmapDrawable) drawable;
2345                 mergedDrawable.setTargetDensity(bitmapDrawable.getBitmap().getDensity());
2346             }
2347 
2348             return mergedDrawable;
2349         }
2350 
2351         return drawable;
2352     }
2353 
getBadgeResIdForUser(int userId)2354     private int getBadgeResIdForUser(int userId) {
2355         // Return the framework-provided badge.
2356         if (isManagedProfile(userId)) {
2357             return com.android.internal.R.drawable.ic_corp_icon_badge;
2358         }
2359         return 0;
2360     }
2361 
isManagedProfile(int userId)2362     private boolean isManagedProfile(int userId) {
2363         return getUserManager().isManagedProfile(userId);
2364     }
2365 
2366     /** {@hide} */
2367     private static class MoveCallbackDelegate extends IPackageMoveObserver.Stub implements
2368             Handler.Callback {
2369         private static final int MSG_CREATED = 1;
2370         private static final int MSG_STATUS_CHANGED = 2;
2371 
2372         final MoveCallback mCallback;
2373         final Handler mHandler;
2374 
MoveCallbackDelegate(MoveCallback callback, Looper looper)2375         public MoveCallbackDelegate(MoveCallback callback, Looper looper) {
2376             mCallback = callback;
2377             mHandler = new Handler(looper, this);
2378         }
2379 
2380         @Override
handleMessage(Message msg)2381         public boolean handleMessage(Message msg) {
2382             switch (msg.what) {
2383                 case MSG_CREATED: {
2384                     final SomeArgs args = (SomeArgs) msg.obj;
2385                     mCallback.onCreated(args.argi1, (Bundle) args.arg2);
2386                     args.recycle();
2387                     return true;
2388                 }
2389                 case MSG_STATUS_CHANGED: {
2390                     final SomeArgs args = (SomeArgs) msg.obj;
2391                     mCallback.onStatusChanged(args.argi1, args.argi2, (long) args.arg3);
2392                     args.recycle();
2393                     return true;
2394                 }
2395             }
2396             return false;
2397         }
2398 
2399         @Override
onCreated(int moveId, Bundle extras)2400         public void onCreated(int moveId, Bundle extras) {
2401             final SomeArgs args = SomeArgs.obtain();
2402             args.argi1 = moveId;
2403             args.arg2 = extras;
2404             mHandler.obtainMessage(MSG_CREATED, args).sendToTarget();
2405         }
2406 
2407         @Override
onStatusChanged(int moveId, int status, long estMillis)2408         public void onStatusChanged(int moveId, int status, long estMillis) {
2409             final SomeArgs args = SomeArgs.obtain();
2410             args.argi1 = moveId;
2411             args.argi2 = status;
2412             args.arg3 = estMillis;
2413             mHandler.obtainMessage(MSG_STATUS_CHANGED, args).sendToTarget();
2414         }
2415     }
2416 
2417     private final ContextImpl mContext;
2418     private final IPackageManager mPM;
2419 
2420     private static final Object sSync = new Object();
2421     private static ArrayMap<ResourceName, WeakReference<Drawable.ConstantState>> sIconCache
2422             = new ArrayMap<ResourceName, WeakReference<Drawable.ConstantState>>();
2423     private static ArrayMap<ResourceName, WeakReference<CharSequence>> sStringCache
2424             = new ArrayMap<ResourceName, WeakReference<CharSequence>>();
2425 
2426     private final Map<OnPermissionsChangedListener, IOnPermissionsChangeListener>
2427             mPermissionListeners = new ArrayMap<>();
2428 
2429     public class OnPermissionsChangeListenerDelegate extends IOnPermissionsChangeListener.Stub
2430             implements Handler.Callback{
2431         private static final int MSG_PERMISSIONS_CHANGED = 1;
2432 
2433         private final OnPermissionsChangedListener mListener;
2434         private final Handler mHandler;
2435 
2436 
OnPermissionsChangeListenerDelegate(OnPermissionsChangedListener listener, Looper looper)2437         public OnPermissionsChangeListenerDelegate(OnPermissionsChangedListener listener,
2438                 Looper looper) {
2439             mListener = listener;
2440             mHandler = new Handler(looper, this);
2441         }
2442 
2443         @Override
onPermissionsChanged(int uid)2444         public void onPermissionsChanged(int uid) {
2445             mHandler.obtainMessage(MSG_PERMISSIONS_CHANGED, uid, 0).sendToTarget();
2446         }
2447 
2448         @Override
handleMessage(Message msg)2449         public boolean handleMessage(Message msg) {
2450             switch (msg.what) {
2451                 case MSG_PERMISSIONS_CHANGED: {
2452                     final int uid = msg.arg1;
2453                     mListener.onPermissionsChanged(uid);
2454                     return true;
2455                 }
2456             }
2457             return false;
2458         }
2459     }
2460 }
2461