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