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