ApplicationPackageManager.java revision e6306c485f0d43ce094a708c76bb9f5ea9703fd3
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.getSystemContext().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.getSystemContext().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 String getInstallerPackageName(String packageName) { 1818 try { 1819 return mPM.getInstallerPackageName(packageName); 1820 } catch (RemoteException e) { 1821 throw e.rethrowFromSystemServer(); 1822 } 1823 } 1824 1825 @Override 1826 public int getMoveStatus(int moveId) { 1827 try { 1828 return mPM.getMoveStatus(moveId); 1829 } catch (RemoteException e) { 1830 throw e.rethrowFromSystemServer(); 1831 } 1832 } 1833 1834 @Override 1835 public void registerMoveCallback(MoveCallback callback, Handler handler) { 1836 synchronized (mDelegates) { 1837 final MoveCallbackDelegate delegate = new MoveCallbackDelegate(callback, 1838 handler.getLooper()); 1839 try { 1840 mPM.registerMoveCallback(delegate); 1841 } catch (RemoteException e) { 1842 throw e.rethrowFromSystemServer(); 1843 } 1844 mDelegates.add(delegate); 1845 } 1846 } 1847 1848 @Override 1849 public void unregisterMoveCallback(MoveCallback callback) { 1850 synchronized (mDelegates) { 1851 for (Iterator<MoveCallbackDelegate> i = mDelegates.iterator(); i.hasNext();) { 1852 final MoveCallbackDelegate delegate = i.next(); 1853 if (delegate.mCallback == callback) { 1854 try { 1855 mPM.unregisterMoveCallback(delegate); 1856 } catch (RemoteException e) { 1857 throw e.rethrowFromSystemServer(); 1858 } 1859 i.remove(); 1860 } 1861 } 1862 } 1863 } 1864 1865 @Override 1866 public int movePackage(String packageName, VolumeInfo vol) { 1867 try { 1868 final String volumeUuid; 1869 if (VolumeInfo.ID_PRIVATE_INTERNAL.equals(vol.id)) { 1870 volumeUuid = StorageManager.UUID_PRIVATE_INTERNAL; 1871 } else if (vol.isPrimaryPhysical()) { 1872 volumeUuid = StorageManager.UUID_PRIMARY_PHYSICAL; 1873 } else { 1874 volumeUuid = Preconditions.checkNotNull(vol.fsUuid); 1875 } 1876 1877 return mPM.movePackage(packageName, volumeUuid); 1878 } catch (RemoteException e) { 1879 throw e.rethrowFromSystemServer(); 1880 } 1881 } 1882 1883 @Override 1884 public @Nullable VolumeInfo getPackageCurrentVolume(ApplicationInfo app) { 1885 final StorageManager storage = mContext.getSystemService(StorageManager.class); 1886 return getPackageCurrentVolume(app, storage); 1887 } 1888 1889 @VisibleForTesting 1890 protected @Nullable VolumeInfo getPackageCurrentVolume(ApplicationInfo app, 1891 StorageManager storage) { 1892 if (app.isInternal()) { 1893 return storage.findVolumeById(VolumeInfo.ID_PRIVATE_INTERNAL); 1894 } else if (app.isExternalAsec()) { 1895 return storage.getPrimaryPhysicalVolume(); 1896 } else { 1897 return storage.findVolumeByUuid(app.volumeUuid); 1898 } 1899 } 1900 1901 @Override 1902 public @NonNull List<VolumeInfo> getPackageCandidateVolumes(ApplicationInfo app) { 1903 final StorageManager storageManager = mContext.getSystemService(StorageManager.class); 1904 return getPackageCandidateVolumes(app, storageManager, mPM); 1905 } 1906 1907 @VisibleForTesting 1908 protected @NonNull List<VolumeInfo> getPackageCandidateVolumes(ApplicationInfo app, 1909 StorageManager storageManager, IPackageManager pm) { 1910 final VolumeInfo currentVol = getPackageCurrentVolume(app, storageManager); 1911 final List<VolumeInfo> vols = storageManager.getVolumes(); 1912 final List<VolumeInfo> candidates = new ArrayList<>(); 1913 for (VolumeInfo vol : vols) { 1914 if (Objects.equals(vol, currentVol) 1915 || isPackageCandidateVolume(mContext, app, vol, pm)) { 1916 candidates.add(vol); 1917 } 1918 } 1919 return candidates; 1920 } 1921 1922 @VisibleForTesting 1923 protected boolean isForceAllowOnExternal(Context context) { 1924 return Settings.Global.getInt( 1925 context.getContentResolver(), Settings.Global.FORCE_ALLOW_ON_EXTERNAL, 0) != 0; 1926 } 1927 1928 @VisibleForTesting 1929 protected boolean isAllow3rdPartyOnInternal(Context context) { 1930 return context.getResources().getBoolean( 1931 com.android.internal.R.bool.config_allow3rdPartyAppOnInternal); 1932 } 1933 1934 private boolean isPackageCandidateVolume( 1935 ContextImpl context, ApplicationInfo app, VolumeInfo vol, IPackageManager pm) { 1936 final boolean forceAllowOnExternal = isForceAllowOnExternal(context); 1937 1938 if (VolumeInfo.ID_PRIVATE_INTERNAL.equals(vol.getId())) { 1939 return app.isSystemApp() || isAllow3rdPartyOnInternal(context); 1940 } 1941 1942 // System apps and apps demanding internal storage can't be moved 1943 // anywhere else 1944 if (app.isSystemApp()) { 1945 return false; 1946 } 1947 if (!forceAllowOnExternal 1948 && (app.installLocation == PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY 1949 || app.installLocation == PackageInfo.INSTALL_LOCATION_UNSPECIFIED)) { 1950 return false; 1951 } 1952 1953 // Gotta be able to write there 1954 if (!vol.isMountedWritable()) { 1955 return false; 1956 } 1957 1958 // Moving into an ASEC on public primary is only option internal 1959 if (vol.isPrimaryPhysical()) { 1960 return app.isInternal(); 1961 } 1962 1963 // Some apps can't be moved. (e.g. device admins) 1964 try { 1965 if (pm.isPackageDeviceAdminOnAnyUser(app.packageName)) { 1966 return false; 1967 } 1968 } catch (RemoteException e) { 1969 throw e.rethrowFromSystemServer(); 1970 } 1971 1972 // Otherwise we can move to any private volume 1973 return (vol.getType() == VolumeInfo.TYPE_PRIVATE); 1974 } 1975 1976 @Override 1977 public int movePrimaryStorage(VolumeInfo vol) { 1978 try { 1979 final String volumeUuid; 1980 if (VolumeInfo.ID_PRIVATE_INTERNAL.equals(vol.id)) { 1981 volumeUuid = StorageManager.UUID_PRIVATE_INTERNAL; 1982 } else if (vol.isPrimaryPhysical()) { 1983 volumeUuid = StorageManager.UUID_PRIMARY_PHYSICAL; 1984 } else { 1985 volumeUuid = Preconditions.checkNotNull(vol.fsUuid); 1986 } 1987 1988 return mPM.movePrimaryStorage(volumeUuid); 1989 } catch (RemoteException e) { 1990 throw e.rethrowFromSystemServer(); 1991 } 1992 } 1993 1994 @Override 1995 public @Nullable VolumeInfo getPrimaryStorageCurrentVolume() { 1996 final StorageManager storage = mContext.getSystemService(StorageManager.class); 1997 final String volumeUuid = storage.getPrimaryStorageUuid(); 1998 return storage.findVolumeByQualifiedUuid(volumeUuid); 1999 } 2000 2001 @Override 2002 public @NonNull List<VolumeInfo> getPrimaryStorageCandidateVolumes() { 2003 final StorageManager storage = mContext.getSystemService(StorageManager.class); 2004 final VolumeInfo currentVol = getPrimaryStorageCurrentVolume(); 2005 final List<VolumeInfo> vols = storage.getVolumes(); 2006 final List<VolumeInfo> candidates = new ArrayList<>(); 2007 if (Objects.equals(StorageManager.UUID_PRIMARY_PHYSICAL, 2008 storage.getPrimaryStorageUuid()) && currentVol != null) { 2009 // TODO: support moving primary physical to emulated volume 2010 candidates.add(currentVol); 2011 } else { 2012 for (VolumeInfo vol : vols) { 2013 if (Objects.equals(vol, currentVol) || isPrimaryStorageCandidateVolume(vol)) { 2014 candidates.add(vol); 2015 } 2016 } 2017 } 2018 return candidates; 2019 } 2020 2021 private static boolean isPrimaryStorageCandidateVolume(VolumeInfo vol) { 2022 // Private internal is always an option 2023 if (VolumeInfo.ID_PRIVATE_INTERNAL.equals(vol.getId())) { 2024 return true; 2025 } 2026 2027 // Gotta be able to write there 2028 if (!vol.isMountedWritable()) { 2029 return false; 2030 } 2031 2032 // We can move to any private volume 2033 return (vol.getType() == VolumeInfo.TYPE_PRIVATE); 2034 } 2035 2036 @Override 2037 public void deletePackage(String packageName, IPackageDeleteObserver observer, int flags) { 2038 deletePackageAsUser(packageName, observer, flags, mContext.getUserId()); 2039 } 2040 2041 @Override 2042 public void deletePackageAsUser(String packageName, IPackageDeleteObserver observer, 2043 int flags, int userId) { 2044 try { 2045 mPM.deletePackageAsUser(packageName, PackageManager.VERSION_CODE_HIGHEST, 2046 observer, userId, flags); 2047 } catch (RemoteException e) { 2048 throw e.rethrowFromSystemServer(); 2049 } 2050 } 2051 2052 @Override 2053 public void clearApplicationUserData(String packageName, 2054 IPackageDataObserver observer) { 2055 try { 2056 mPM.clearApplicationUserData(packageName, observer, mContext.getUserId()); 2057 } catch (RemoteException e) { 2058 throw e.rethrowFromSystemServer(); 2059 } 2060 } 2061 @Override 2062 public void deleteApplicationCacheFiles(String packageName, 2063 IPackageDataObserver observer) { 2064 try { 2065 mPM.deleteApplicationCacheFiles(packageName, observer); 2066 } catch (RemoteException e) { 2067 throw e.rethrowFromSystemServer(); 2068 } 2069 } 2070 2071 @Override 2072 public void deleteApplicationCacheFilesAsUser(String packageName, int userId, 2073 IPackageDataObserver observer) { 2074 try { 2075 mPM.deleteApplicationCacheFilesAsUser(packageName, userId, observer); 2076 } catch (RemoteException e) { 2077 throw e.rethrowFromSystemServer(); 2078 } 2079 } 2080 2081 @Override 2082 public void freeStorageAndNotify(String volumeUuid, long idealStorageSize, 2083 IPackageDataObserver observer) { 2084 try { 2085 mPM.freeStorageAndNotify(volumeUuid, idealStorageSize, observer); 2086 } catch (RemoteException e) { 2087 throw e.rethrowFromSystemServer(); 2088 } 2089 } 2090 2091 @Override 2092 public void freeStorage(String volumeUuid, long freeStorageSize, IntentSender pi) { 2093 try { 2094 mPM.freeStorage(volumeUuid, freeStorageSize, pi); 2095 } catch (RemoteException e) { 2096 throw e.rethrowFromSystemServer(); 2097 } 2098 } 2099 2100 @Override 2101 public String[] setPackagesSuspendedAsUser(String[] packageNames, boolean suspended, 2102 int userId) { 2103 try { 2104 return mPM.setPackagesSuspendedAsUser(packageNames, suspended, userId); 2105 } catch (RemoteException e) { 2106 throw e.rethrowFromSystemServer(); 2107 } 2108 } 2109 2110 @Override 2111 public boolean isPackageSuspendedForUser(String packageName, int userId) { 2112 try { 2113 return mPM.isPackageSuspendedForUser(packageName, userId); 2114 } catch (RemoteException e) { 2115 throw e.rethrowFromSystemServer(); 2116 } 2117 } 2118 2119 /** @hide */ 2120 @Override 2121 public void setApplicationCategoryHint(String packageName, int categoryHint) { 2122 try { 2123 mPM.setApplicationCategoryHint(packageName, categoryHint, 2124 mContext.getOpPackageName()); 2125 } catch (RemoteException e) { 2126 throw e.rethrowFromSystemServer(); 2127 } 2128 } 2129 2130 @Override 2131 public void getPackageSizeInfoAsUser(String packageName, int userHandle, 2132 IPackageStatsObserver observer) { 2133 if (mContext.getApplicationInfo().targetSdkVersion >= Build.VERSION_CODES.O) { 2134 throw new UnsupportedOperationException( 2135 "Shame on you for calling a hidden API. Shame!"); 2136 } else if (observer != null) { 2137 Log.d(TAG, "Shame on you for calling a hidden API. Shame!"); 2138 try { 2139 observer.onGetStatsCompleted(null, false); 2140 } catch (RemoteException ignored) { 2141 } 2142 } 2143 } 2144 2145 @Override 2146 public void addPackageToPreferred(String packageName) { 2147 Log.w(TAG, "addPackageToPreferred() is a no-op"); 2148 } 2149 2150 @Override 2151 public void removePackageFromPreferred(String packageName) { 2152 Log.w(TAG, "removePackageFromPreferred() is a no-op"); 2153 } 2154 2155 @Override 2156 public List<PackageInfo> getPreferredPackages(int flags) { 2157 Log.w(TAG, "getPreferredPackages() is a no-op"); 2158 return Collections.emptyList(); 2159 } 2160 2161 @Override 2162 public void addPreferredActivity(IntentFilter filter, 2163 int match, ComponentName[] set, ComponentName activity) { 2164 try { 2165 mPM.addPreferredActivity(filter, match, set, activity, mContext.getUserId()); 2166 } catch (RemoteException e) { 2167 throw e.rethrowFromSystemServer(); 2168 } 2169 } 2170 2171 @Override 2172 public void addPreferredActivityAsUser(IntentFilter filter, int match, 2173 ComponentName[] set, ComponentName activity, int userId) { 2174 try { 2175 mPM.addPreferredActivity(filter, match, set, activity, userId); 2176 } catch (RemoteException e) { 2177 throw e.rethrowFromSystemServer(); 2178 } 2179 } 2180 2181 @Override 2182 public void replacePreferredActivity(IntentFilter filter, 2183 int match, ComponentName[] set, ComponentName activity) { 2184 try { 2185 mPM.replacePreferredActivity(filter, match, set, activity, mContext.getUserId()); 2186 } catch (RemoteException e) { 2187 throw e.rethrowFromSystemServer(); 2188 } 2189 } 2190 2191 @Override 2192 public void replacePreferredActivityAsUser(IntentFilter filter, 2193 int match, ComponentName[] set, ComponentName activity, 2194 int userId) { 2195 try { 2196 mPM.replacePreferredActivity(filter, match, set, activity, userId); 2197 } catch (RemoteException e) { 2198 throw e.rethrowFromSystemServer(); 2199 } 2200 } 2201 2202 @Override 2203 public void clearPackagePreferredActivities(String packageName) { 2204 try { 2205 mPM.clearPackagePreferredActivities(packageName); 2206 } catch (RemoteException e) { 2207 throw e.rethrowFromSystemServer(); 2208 } 2209 } 2210 2211 @Override 2212 public int getPreferredActivities(List<IntentFilter> outFilters, 2213 List<ComponentName> outActivities, String packageName) { 2214 try { 2215 return mPM.getPreferredActivities(outFilters, outActivities, packageName); 2216 } catch (RemoteException e) { 2217 throw e.rethrowFromSystemServer(); 2218 } 2219 } 2220 2221 @Override 2222 public ComponentName getHomeActivities(List<ResolveInfo> outActivities) { 2223 try { 2224 return mPM.getHomeActivities(outActivities); 2225 } catch (RemoteException e) { 2226 throw e.rethrowFromSystemServer(); 2227 } 2228 } 2229 2230 @Override 2231 public void setComponentEnabledSetting(ComponentName componentName, 2232 int newState, int flags) { 2233 try { 2234 mPM.setComponentEnabledSetting(componentName, newState, flags, mContext.getUserId()); 2235 } catch (RemoteException e) { 2236 throw e.rethrowFromSystemServer(); 2237 } 2238 } 2239 2240 @Override 2241 public int getComponentEnabledSetting(ComponentName componentName) { 2242 try { 2243 return mPM.getComponentEnabledSetting(componentName, mContext.getUserId()); 2244 } catch (RemoteException e) { 2245 throw e.rethrowFromSystemServer(); 2246 } 2247 } 2248 2249 @Override 2250 public void setApplicationEnabledSetting(String packageName, 2251 int newState, int flags) { 2252 try { 2253 mPM.setApplicationEnabledSetting(packageName, newState, flags, 2254 mContext.getUserId(), mContext.getOpPackageName()); 2255 } catch (RemoteException e) { 2256 throw e.rethrowFromSystemServer(); 2257 } 2258 } 2259 2260 @Override 2261 public int getApplicationEnabledSetting(String packageName) { 2262 try { 2263 return mPM.getApplicationEnabledSetting(packageName, mContext.getUserId()); 2264 } catch (RemoteException e) { 2265 throw e.rethrowFromSystemServer(); 2266 } 2267 } 2268 2269 @Override 2270 public void flushPackageRestrictionsAsUser(int userId) { 2271 try { 2272 mPM.flushPackageRestrictionsAsUser(userId); 2273 } catch (RemoteException e) { 2274 throw e.rethrowFromSystemServer(); 2275 } 2276 } 2277 2278 @Override 2279 public boolean setApplicationHiddenSettingAsUser(String packageName, boolean hidden, 2280 UserHandle user) { 2281 try { 2282 return mPM.setApplicationHiddenSettingAsUser(packageName, hidden, 2283 user.getIdentifier()); 2284 } catch (RemoteException e) { 2285 throw e.rethrowFromSystemServer(); 2286 } 2287 } 2288 2289 @Override 2290 public boolean getApplicationHiddenSettingAsUser(String packageName, UserHandle user) { 2291 try { 2292 return mPM.getApplicationHiddenSettingAsUser(packageName, user.getIdentifier()); 2293 } catch (RemoteException e) { 2294 throw e.rethrowFromSystemServer(); 2295 } 2296 } 2297 2298 /** @hide */ 2299 @Override 2300 public KeySet getKeySetByAlias(String packageName, String alias) { 2301 Preconditions.checkNotNull(packageName); 2302 Preconditions.checkNotNull(alias); 2303 try { 2304 return mPM.getKeySetByAlias(packageName, alias); 2305 } catch (RemoteException e) { 2306 throw e.rethrowFromSystemServer(); 2307 } 2308 } 2309 2310 /** @hide */ 2311 @Override 2312 public KeySet getSigningKeySet(String packageName) { 2313 Preconditions.checkNotNull(packageName); 2314 try { 2315 return mPM.getSigningKeySet(packageName); 2316 } catch (RemoteException e) { 2317 throw e.rethrowFromSystemServer(); 2318 } 2319 } 2320 2321 /** @hide */ 2322 @Override 2323 public boolean isSignedBy(String packageName, KeySet ks) { 2324 Preconditions.checkNotNull(packageName); 2325 Preconditions.checkNotNull(ks); 2326 try { 2327 return mPM.isPackageSignedByKeySet(packageName, ks); 2328 } catch (RemoteException e) { 2329 throw e.rethrowFromSystemServer(); 2330 } 2331 } 2332 2333 /** @hide */ 2334 @Override 2335 public boolean isSignedByExactly(String packageName, KeySet ks) { 2336 Preconditions.checkNotNull(packageName); 2337 Preconditions.checkNotNull(ks); 2338 try { 2339 return mPM.isPackageSignedByKeySetExactly(packageName, ks); 2340 } catch (RemoteException e) { 2341 throw e.rethrowFromSystemServer(); 2342 } 2343 } 2344 2345 /** 2346 * @hide 2347 */ 2348 @Override 2349 public VerifierDeviceIdentity getVerifierDeviceIdentity() { 2350 try { 2351 return mPM.getVerifierDeviceIdentity(); 2352 } catch (RemoteException e) { 2353 throw e.rethrowFromSystemServer(); 2354 } 2355 } 2356 2357 /** 2358 * @hide 2359 */ 2360 @Override 2361 public boolean isUpgrade() { 2362 try { 2363 return mPM.isUpgrade(); 2364 } catch (RemoteException e) { 2365 throw e.rethrowFromSystemServer(); 2366 } 2367 } 2368 2369 @Override 2370 public PackageInstaller getPackageInstaller() { 2371 synchronized (mLock) { 2372 if (mInstaller == null) { 2373 try { 2374 mInstaller = new PackageInstaller(mPM.getPackageInstaller(), 2375 mContext.getPackageName(), mContext.getUserId()); 2376 } catch (RemoteException e) { 2377 throw e.rethrowFromSystemServer(); 2378 } 2379 } 2380 return mInstaller; 2381 } 2382 } 2383 2384 @Override 2385 public boolean isPackageAvailable(String packageName) { 2386 try { 2387 return mPM.isPackageAvailable(packageName, mContext.getUserId()); 2388 } catch (RemoteException e) { 2389 throw e.rethrowFromSystemServer(); 2390 } 2391 } 2392 2393 /** 2394 * @hide 2395 */ 2396 @Override 2397 public void addCrossProfileIntentFilter(IntentFilter filter, int sourceUserId, int targetUserId, 2398 int flags) { 2399 try { 2400 mPM.addCrossProfileIntentFilter(filter, mContext.getOpPackageName(), 2401 sourceUserId, targetUserId, flags); 2402 } catch (RemoteException e) { 2403 throw e.rethrowFromSystemServer(); 2404 } 2405 } 2406 2407 /** 2408 * @hide 2409 */ 2410 @Override 2411 public void clearCrossProfileIntentFilters(int sourceUserId) { 2412 try { 2413 mPM.clearCrossProfileIntentFilters(sourceUserId, mContext.getOpPackageName()); 2414 } catch (RemoteException e) { 2415 throw e.rethrowFromSystemServer(); 2416 } 2417 } 2418 2419 /** 2420 * @hide 2421 */ 2422 public Drawable loadItemIcon(PackageItemInfo itemInfo, ApplicationInfo appInfo) { 2423 Drawable dr = loadUnbadgedItemIcon(itemInfo, appInfo); 2424 if (itemInfo.showUserIcon != UserHandle.USER_NULL) { 2425 return dr; 2426 } 2427 return getUserBadgedIcon(dr, new UserHandle(mContext.getUserId())); 2428 } 2429 2430 /** 2431 * @hide 2432 */ 2433 public Drawable loadUnbadgedItemIcon(PackageItemInfo itemInfo, ApplicationInfo appInfo) { 2434 if (itemInfo.showUserIcon != UserHandle.USER_NULL) { 2435 Bitmap bitmap = getUserManager().getUserIcon(itemInfo.showUserIcon); 2436 if (bitmap == null) { 2437 return UserIcons.getDefaultUserIcon(itemInfo.showUserIcon, /* light= */ false); 2438 } 2439 return new BitmapDrawable(bitmap); 2440 } 2441 Drawable dr = null; 2442 if (itemInfo.packageName != null) { 2443 dr = getDrawable(itemInfo.packageName, itemInfo.icon, appInfo); 2444 } 2445 if (dr == null) { 2446 dr = itemInfo.loadDefaultIcon(this); 2447 } 2448 return dr; 2449 } 2450 2451 private Drawable getBadgedDrawable(Drawable drawable, Drawable badgeDrawable, 2452 Rect badgeLocation, boolean tryBadgeInPlace) { 2453 final int badgedWidth = drawable.getIntrinsicWidth(); 2454 final int badgedHeight = drawable.getIntrinsicHeight(); 2455 final boolean canBadgeInPlace = tryBadgeInPlace 2456 && (drawable instanceof BitmapDrawable) 2457 && ((BitmapDrawable) drawable).getBitmap().isMutable(); 2458 2459 final Bitmap bitmap; 2460 if (canBadgeInPlace) { 2461 bitmap = ((BitmapDrawable) drawable).getBitmap(); 2462 } else { 2463 bitmap = Bitmap.createBitmap(badgedWidth, badgedHeight, Bitmap.Config.ARGB_8888); 2464 } 2465 Canvas canvas = new Canvas(bitmap); 2466 2467 if (!canBadgeInPlace) { 2468 drawable.setBounds(0, 0, badgedWidth, badgedHeight); 2469 drawable.draw(canvas); 2470 } 2471 2472 if (badgeLocation != null) { 2473 if (badgeLocation.left < 0 || badgeLocation.top < 0 2474 || badgeLocation.width() > badgedWidth || badgeLocation.height() > badgedHeight) { 2475 throw new IllegalArgumentException("Badge location " + badgeLocation 2476 + " not in badged drawable bounds " 2477 + new Rect(0, 0, badgedWidth, badgedHeight)); 2478 } 2479 badgeDrawable.setBounds(0, 0, badgeLocation.width(), badgeLocation.height()); 2480 2481 canvas.save(); 2482 canvas.translate(badgeLocation.left, badgeLocation.top); 2483 badgeDrawable.draw(canvas); 2484 canvas.restore(); 2485 } else { 2486 badgeDrawable.setBounds(0, 0, badgedWidth, badgedHeight); 2487 badgeDrawable.draw(canvas); 2488 } 2489 2490 if (!canBadgeInPlace) { 2491 BitmapDrawable mergedDrawable = new BitmapDrawable(mContext.getResources(), bitmap); 2492 2493 if (drawable instanceof BitmapDrawable) { 2494 BitmapDrawable bitmapDrawable = (BitmapDrawable) drawable; 2495 mergedDrawable.setTargetDensity(bitmapDrawable.getBitmap().getDensity()); 2496 } 2497 2498 return mergedDrawable; 2499 } 2500 2501 return drawable; 2502 } 2503 2504 private boolean isManagedProfile(int userId) { 2505 return getUserManager().isManagedProfile(userId); 2506 } 2507 2508 /** 2509 * @hide 2510 */ 2511 @Override 2512 public int getInstallReason(String packageName, UserHandle user) { 2513 try { 2514 return mPM.getInstallReason(packageName, user.getIdentifier()); 2515 } catch (RemoteException e) { 2516 throw e.rethrowFromSystemServer(); 2517 } 2518 } 2519 2520 /** {@hide} */ 2521 private static class MoveCallbackDelegate extends IPackageMoveObserver.Stub implements 2522 Handler.Callback { 2523 private static final int MSG_CREATED = 1; 2524 private static final int MSG_STATUS_CHANGED = 2; 2525 2526 final MoveCallback mCallback; 2527 final Handler mHandler; 2528 2529 public MoveCallbackDelegate(MoveCallback callback, Looper looper) { 2530 mCallback = callback; 2531 mHandler = new Handler(looper, this); 2532 } 2533 2534 @Override 2535 public boolean handleMessage(Message msg) { 2536 switch (msg.what) { 2537 case MSG_CREATED: { 2538 final SomeArgs args = (SomeArgs) msg.obj; 2539 mCallback.onCreated(args.argi1, (Bundle) args.arg2); 2540 args.recycle(); 2541 return true; 2542 } 2543 case MSG_STATUS_CHANGED: { 2544 final SomeArgs args = (SomeArgs) msg.obj; 2545 mCallback.onStatusChanged(args.argi1, args.argi2, (long) args.arg3); 2546 args.recycle(); 2547 return true; 2548 } 2549 } 2550 return false; 2551 } 2552 2553 @Override 2554 public void onCreated(int moveId, Bundle extras) { 2555 final SomeArgs args = SomeArgs.obtain(); 2556 args.argi1 = moveId; 2557 args.arg2 = extras; 2558 mHandler.obtainMessage(MSG_CREATED, args).sendToTarget(); 2559 } 2560 2561 @Override 2562 public void onStatusChanged(int moveId, int status, long estMillis) { 2563 final SomeArgs args = SomeArgs.obtain(); 2564 args.argi1 = moveId; 2565 args.argi2 = status; 2566 args.arg3 = estMillis; 2567 mHandler.obtainMessage(MSG_STATUS_CHANGED, args).sendToTarget(); 2568 } 2569 } 2570 2571 private final ContextImpl mContext; 2572 private final IPackageManager mPM; 2573 2574 private static final Object sSync = new Object(); 2575 private static ArrayMap<ResourceName, WeakReference<Drawable.ConstantState>> sIconCache 2576 = new ArrayMap<ResourceName, WeakReference<Drawable.ConstantState>>(); 2577 private static ArrayMap<ResourceName, WeakReference<CharSequence>> sStringCache 2578 = new ArrayMap<ResourceName, WeakReference<CharSequence>>(); 2579 2580 private final Map<OnPermissionsChangedListener, IOnPermissionsChangeListener> 2581 mPermissionListeners = new ArrayMap<>(); 2582 2583 public class OnPermissionsChangeListenerDelegate extends IOnPermissionsChangeListener.Stub 2584 implements Handler.Callback{ 2585 private static final int MSG_PERMISSIONS_CHANGED = 1; 2586 2587 private final OnPermissionsChangedListener mListener; 2588 private final Handler mHandler; 2589 2590 2591 public OnPermissionsChangeListenerDelegate(OnPermissionsChangedListener listener, 2592 Looper looper) { 2593 mListener = listener; 2594 mHandler = new Handler(looper, this); 2595 } 2596 2597 @Override 2598 public void onPermissionsChanged(int uid) { 2599 mHandler.obtainMessage(MSG_PERMISSIONS_CHANGED, uid, 0).sendToTarget(); 2600 } 2601 2602 @Override 2603 public boolean handleMessage(Message msg) { 2604 switch (msg.what) { 2605 case MSG_PERMISSIONS_CHANGED: { 2606 final int uid = msg.arg1; 2607 mListener.onPermissionsChanged(uid); 2608 return true; 2609 } 2610 } 2611 return false; 2612 } 2613 } 2614 2615 @Override 2616 public boolean canRequestPackageInstalls() { 2617 try { 2618 return mPM.canRequestPackageInstalls(mContext.getPackageName(), mContext.getUserId()); 2619 } catch (RemoteException e) { 2620 throw e.rethrowAsRuntimeException(); 2621 } 2622 } 2623} 2624