1 /* 2 * Copyright (C) 2011 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.android.server.pm; 18 19 import static android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_DEFAULT; 20 import static android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_DISABLED; 21 import static android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_ENABLED; 22 23 import android.annotation.NonNull; 24 import android.annotation.Nullable; 25 import android.annotation.UserIdInt; 26 import android.content.ComponentName; 27 import android.content.pm.ApplicationInfo; 28 import android.content.pm.PackageManager; 29 import android.content.pm.SharedLibraryInfo; 30 import android.content.pm.SigningDetails; 31 import android.content.pm.SigningInfo; 32 import android.content.pm.UserInfo; 33 import android.content.pm.overlay.OverlayPaths; 34 import android.os.UserHandle; 35 import android.os.incremental.IncrementalManager; 36 import android.service.pm.PackageProto; 37 import android.text.TextUtils; 38 import android.util.ArrayMap; 39 import android.util.ArraySet; 40 import android.util.SparseArray; 41 import android.util.proto.ProtoOutputStream; 42 43 import com.android.internal.annotations.VisibleForTesting; 44 import com.android.internal.util.CollectionUtils; 45 import com.android.internal.util.DataClass; 46 import com.android.server.pm.parsing.pkg.AndroidPackageInternal; 47 import com.android.server.pm.parsing.pkg.AndroidPackageUtils; 48 import com.android.server.pm.permission.LegacyPermissionDataProvider; 49 import com.android.server.pm.permission.LegacyPermissionState; 50 import com.android.server.pm.pkg.AndroidPackage; 51 import com.android.server.pm.pkg.PackageState; 52 import com.android.server.pm.pkg.PackageStateInternal; 53 import com.android.server.pm.pkg.PackageStateUnserialized; 54 import com.android.server.pm.pkg.PackageUserState; 55 import com.android.server.pm.pkg.PackageUserStateImpl; 56 import com.android.server.pm.pkg.PackageUserStateInternal; 57 import com.android.server.pm.pkg.SharedLibrary; 58 import com.android.server.pm.pkg.SharedLibraryWrapper; 59 import com.android.server.pm.pkg.SuspendParams; 60 import com.android.server.utils.SnapshotCache; 61 import com.android.server.utils.WatchedArraySet; 62 63 import libcore.util.EmptyArray; 64 65 import java.io.File; 66 import java.util.ArrayList; 67 import java.util.Arrays; 68 import java.util.Collection; 69 import java.util.Collections; 70 import java.util.List; 71 import java.util.Map; 72 import java.util.Objects; 73 import java.util.Set; 74 import java.util.UUID; 75 76 /** 77 * Settings data for a particular package we know about. 78 * 79 * @hide 80 */ 81 @DataClass(genGetters = true, genConstructor = false, genSetters = false, genBuilder = false) 82 @DataClass.Suppress({"getSnapshot", }) 83 public class PackageSetting extends SettingBase implements PackageStateInternal { 84 85 /** 86 * The shared user ID lets us link this object to {@link SharedUserSetting}. 87 */ 88 private int mSharedUserAppId; 89 90 @Nullable 91 private Map<String, Set<String>> mimeGroups; 92 93 @Deprecated 94 @Nullable 95 private Set<String> mOldCodePaths; 96 97 @Nullable 98 private String[] usesSdkLibraries; 99 100 @Nullable 101 private long[] usesSdkLibrariesVersionsMajor; 102 103 @Nullable 104 private String[] usesStaticLibraries; 105 106 @Nullable 107 private long[] usesStaticLibrariesVersions; 108 109 /** 110 * The path under which native libraries have been unpacked. This path is 111 * always derived at runtime, and is only stored here for cleanup when a 112 * package is uninstalled. 113 */ 114 @Nullable 115 @Deprecated 116 private String legacyNativeLibraryPath; 117 118 @NonNull 119 private String mName; 120 121 @Nullable 122 private String mRealName; 123 124 private int mAppId; 125 126 /** 127 * It is expected that all code that uses a {@link PackageSetting} understands this inner field 128 * may be null. Note that this relationship only works one way. It should not be possible to 129 * have an entry inside {@link PackageManagerService#mPackages} without a corresponding 130 * {@link PackageSetting} inside {@link Settings#mPackages}. 131 * 132 * @see PackageState#getAndroidPackage() 133 */ 134 @Nullable 135 private AndroidPackageInternal pkg; 136 137 /** @see AndroidPackage#getPath() */ 138 @NonNull 139 private File mPath; 140 @NonNull 141 private String mPathString; 142 143 private float mLoadingProgress; 144 private long mLoadingCompletedTime; 145 146 @Nullable 147 private String mPrimaryCpuAbi; 148 149 @Nullable 150 private String mSecondaryCpuAbi; 151 152 @Nullable 153 private String mCpuAbiOverride; 154 155 private long mLastModifiedTime; 156 private long lastUpdateTime; 157 private long versionCode; 158 159 @NonNull 160 private PackageSignatures signatures; 161 162 private boolean installPermissionsFixed; 163 164 @NonNull 165 private PackageKeySetData keySetData = new PackageKeySetData(); 166 167 // TODO: Access is not locked. 168 @NonNull 169 private final SparseArray<PackageUserStateImpl> mUserStates = new SparseArray<>(); 170 171 @NonNull 172 private InstallSource installSource; 173 174 /** @see PackageState#getVolumeUuid() */ 175 @Nullable 176 private String volumeUuid; 177 178 /** @see PackageState#getCategoryOverride() */ 179 private int categoryOverride = ApplicationInfo.CATEGORY_UNDEFINED; 180 181 /** @see PackageState#isUpdateAvailable() */ 182 private boolean updateAvailable; 183 184 private boolean forceQueryableOverride; 185 186 @NonNull 187 private final PackageStateUnserialized pkgState = new PackageStateUnserialized(this); 188 189 @NonNull 190 private UUID mDomainSetId; 191 192 @Nullable 193 private String mAppMetadataFilePath; 194 195 /** 196 * Snapshot support. 197 */ 198 @NonNull 199 private final SnapshotCache<PackageSetting> mSnapshot; 200 makeCache()201 private SnapshotCache<PackageSetting> makeCache() { 202 return new SnapshotCache<PackageSetting>(this, this) { 203 @Override 204 public PackageSetting createSnapshot() { 205 return new PackageSetting(mSource, true); 206 }}; 207 } 208 209 @VisibleForTesting(visibility = VisibleForTesting.Visibility.PACKAGE) 210 public PackageSetting(String name, String realName, @NonNull File path, 211 String legacyNativeLibraryPath, String primaryCpuAbi, 212 String secondaryCpuAbi, String cpuAbiOverride, 213 long longVersionCode, int pkgFlags, int pkgPrivateFlags, 214 int sharedUserAppId, 215 String[] usesSdkLibraries, long[] usesSdkLibrariesVersionsMajor, 216 String[] usesStaticLibraries, long[] usesStaticLibrariesVersions, 217 Map<String, Set<String>> mimeGroups, 218 @NonNull UUID domainSetId) { 219 super(pkgFlags, pkgPrivateFlags); 220 this.mName = name; 221 this.mRealName = realName; 222 this.usesSdkLibraries = usesSdkLibraries; 223 this.usesSdkLibrariesVersionsMajor = usesSdkLibrariesVersionsMajor; 224 this.usesStaticLibraries = usesStaticLibraries; 225 this.usesStaticLibrariesVersions = usesStaticLibrariesVersions; 226 this.mPath = path; 227 this.mPathString = path.toString(); 228 this.legacyNativeLibraryPath = legacyNativeLibraryPath; 229 this.mPrimaryCpuAbi = primaryCpuAbi; 230 this.mSecondaryCpuAbi = secondaryCpuAbi; 231 this.mCpuAbiOverride = cpuAbiOverride; 232 this.versionCode = longVersionCode; 233 this.signatures = new PackageSignatures(); 234 this.installSource = InstallSource.EMPTY; 235 this.mSharedUserAppId = sharedUserAppId; 236 mDomainSetId = domainSetId; 237 copyMimeGroups(mimeGroups); 238 mSnapshot = makeCache(); 239 } 240 241 /** 242 * New instance of PackageSetting replicating the original settings. 243 * Note that it keeps the same PackageParser.Package instance. 244 */ 245 PackageSetting(PackageSetting orig) { 246 this(orig, false); 247 } 248 249 /** 250 * New instance of PackageSetting with one-level-deep cloning. 251 * <p> 252 * IMPORTANT: With a shallow copy, we do NOT create new contained objects. 253 * This means, for example, changes to the user state of the original PackageSetting 254 * will also change the user state in its copy. 255 */ 256 PackageSetting(PackageSetting base, String realPkgName) { 257 this(base, false); 258 this.mRealName = realPkgName; 259 } 260 261 PackageSetting(@NonNull PackageSetting original, boolean sealedSnapshot) { 262 super(original); 263 copyPackageSetting(original, sealedSnapshot); 264 if (sealedSnapshot) { 265 mSnapshot = new SnapshotCache.Sealed(); 266 } else { 267 mSnapshot = makeCache(); 268 } 269 } 270 271 /** 272 * Return the package snapshot. 273 */ 274 public PackageSetting snapshot() { 275 return mSnapshot.snapshot(); 276 } 277 278 public void dumpDebug(ProtoOutputStream proto, long fieldId, List<UserInfo> users, 279 LegacyPermissionDataProvider dataProvider) { 280 final long packageToken = proto.start(fieldId); 281 proto.write(PackageProto.NAME, (mRealName != null ? mRealName : mName)); 282 proto.write(PackageProto.UID, mAppId); 283 proto.write(PackageProto.VERSION_CODE, versionCode); 284 proto.write(PackageProto.UPDATE_TIME_MS, lastUpdateTime); 285 proto.write(PackageProto.INSTALLER_NAME, installSource.mInstallerPackageName); 286 287 if (pkg != null) { 288 proto.write(PackageProto.VERSION_STRING, pkg.getVersionName()); 289 290 long splitToken = proto.start(PackageProto.SPLITS); 291 proto.write(PackageProto.SplitProto.NAME, "base"); 292 proto.write(PackageProto.SplitProto.REVISION_CODE, pkg.getBaseRevisionCode()); 293 proto.end(splitToken); 294 295 for (int i = 0; i < pkg.getSplitNames().length; i++) { 296 splitToken = proto.start(PackageProto.SPLITS); 297 proto.write(PackageProto.SplitProto.NAME, pkg.getSplitNames()[i]); 298 proto.write(PackageProto.SplitProto.REVISION_CODE, 299 pkg.getSplitRevisionCodes()[i]); 300 proto.end(splitToken); 301 } 302 303 long sourceToken = proto.start(PackageProto.INSTALL_SOURCE); 304 proto.write(PackageProto.InstallSourceProto.INITIATING_PACKAGE_NAME, 305 installSource.mInitiatingPackageName); 306 proto.write(PackageProto.InstallSourceProto.ORIGINATING_PACKAGE_NAME, 307 installSource.mOriginatingPackageName); 308 proto.write(PackageProto.InstallSourceProto.UPDATE_OWNER_PACKAGE_NAME, 309 installSource.mUpdateOwnerPackageName); 310 proto.end(sourceToken); 311 } 312 proto.write(PackageProto.StatesProto.IS_LOADING, isLoading()); 313 writeUsersInfoToProto(proto, PackageProto.USERS); 314 writePackageUserPermissionsProto(proto, PackageProto.USER_PERMISSIONS, users, dataProvider); 315 proto.end(packageToken); 316 } 317 318 public PackageSetting setAppId(int appId) { 319 this.mAppId = appId; 320 onChanged(); 321 return this; 322 } 323 324 public PackageSetting setCpuAbiOverride(String cpuAbiOverrideString) { 325 this.mCpuAbiOverride = cpuAbiOverrideString; 326 onChanged(); 327 return this; 328 } 329 330 /** 331 * In case of replacing an old package, restore the first install timestamps if it was installed 332 * for the same users 333 */ 334 public PackageSetting setFirstInstallTimeFromReplaced(PackageStateInternal replacedPkgSetting, 335 int[] userIds) { 336 for (int userId = 0; userId < userIds.length; userId++) { 337 final long previousFirstInstallTime = 338 replacedPkgSetting.getUserStateOrDefault(userId).getFirstInstallTimeMillis(); 339 if (previousFirstInstallTime != 0) { 340 modifyUserState(userId).setFirstInstallTimeMillis(previousFirstInstallTime); 341 } 342 } 343 onChanged(); 344 return this; 345 } 346 347 /** 348 * Set the time for the first time when an app is installed for a user. If userId specifies all 349 * users, set the same timestamp for all the users. 350 */ 351 public PackageSetting setFirstInstallTime(long firstInstallTime, int userId) { 352 if (userId == UserHandle.USER_ALL) { 353 int userStateCount = mUserStates.size(); 354 for (int i = 0; i < userStateCount; i++) { 355 mUserStates.valueAt(i).setFirstInstallTimeMillis(firstInstallTime); 356 } 357 } else { 358 modifyUserState(userId).setFirstInstallTimeMillis(firstInstallTime); 359 } 360 onChanged(); 361 return this; 362 } 363 364 public PackageSetting setForceQueryableOverride(boolean forceQueryableOverride) { 365 this.forceQueryableOverride = forceQueryableOverride; 366 onChanged(); 367 return this; 368 } 369 370 public PackageSetting setInstallerPackage(@Nullable String installerPackageName, 371 int installerPackageUid) { 372 installSource = installSource.setInstallerPackage(installerPackageName, 373 installerPackageUid); 374 onChanged(); 375 return this; 376 } 377 378 public PackageSetting setUpdateOwnerPackage(@Nullable String updateOwnerPackageName) { 379 installSource = installSource.setUpdateOwnerPackageName(updateOwnerPackageName); 380 onChanged(); 381 return this; 382 } 383 384 public PackageSetting setInstallSource(InstallSource installSource) { 385 this.installSource = Objects.requireNonNull(installSource); 386 onChanged(); 387 return this; 388 } 389 390 PackageSetting removeInstallerPackage(@Nullable String packageName) { 391 installSource = installSource.removeInstallerPackage(packageName); 392 onChanged(); 393 return this; 394 } 395 396 public PackageSetting setIsOrphaned(boolean isOrphaned) { 397 installSource = installSource.setIsOrphaned(isOrphaned); 398 onChanged(); 399 return this; 400 } 401 402 public PackageSetting setKeySetData(PackageKeySetData keySetData) { 403 this.keySetData = keySetData; 404 onChanged(); 405 return this; 406 } 407 408 public PackageSetting setLastModifiedTime(long timeStamp) { 409 this.mLastModifiedTime = timeStamp; 410 onChanged(); 411 return this; 412 } 413 414 public PackageSetting setLastUpdateTime(long lastUpdateTime) { 415 this.lastUpdateTime = lastUpdateTime; 416 onChanged(); 417 return this; 418 } 419 420 public PackageSetting setLongVersionCode(long versionCode) { 421 this.versionCode = versionCode; 422 onChanged(); 423 return this; 424 } 425 426 public boolean setMimeGroup(String mimeGroup, ArraySet<String> newMimeTypes) { 427 Set<String> oldMimeTypes = mimeGroups == null ? null : mimeGroups.get(mimeGroup); 428 if (oldMimeTypes == null) { 429 throw new IllegalArgumentException("Unknown MIME group " + mimeGroup 430 + " for package " + mName); 431 } 432 433 boolean hasChanges = !newMimeTypes.equals(oldMimeTypes); 434 mimeGroups.put(mimeGroup, newMimeTypes); 435 if (hasChanges) { 436 onChanged(); 437 } 438 return hasChanges; 439 } 440 441 // TODO: Remove, only commit package when it's actually finalized 442 public PackageSetting setPkg(AndroidPackage pkg) { 443 this.pkg = (AndroidPackageInternal) pkg; 444 onChanged(); 445 return this; 446 } 447 448 /** 449 * Notify {@link #onChanged()} if the parameter {@code usesLibraryFiles} is different from 450 * {@link #getUsesLibraryFiles()}. 451 * @param usesLibraryFiles the new uses library files 452 * @return {@code this} 453 */ 454 public PackageSetting setPkgStateLibraryFiles(@NonNull Collection<String> usesLibraryFiles) { 455 final Collection<String> oldUsesLibraryFiles = getUsesLibraryFiles(); 456 if (oldUsesLibraryFiles.size() != usesLibraryFiles.size() 457 || !oldUsesLibraryFiles.containsAll(usesLibraryFiles)) { 458 pkgState.setUsesLibraryFiles(new ArrayList<>(usesLibraryFiles)); 459 onChanged(); 460 } 461 return this; 462 } 463 464 public PackageSetting setPrimaryCpuAbi(String primaryCpuAbiString) { 465 this.mPrimaryCpuAbi = primaryCpuAbiString; 466 onChanged(); 467 return this; 468 } 469 470 public PackageSetting setSecondaryCpuAbi(String secondaryCpuAbiString) { 471 this.mSecondaryCpuAbi = secondaryCpuAbiString; 472 onChanged(); 473 return this; 474 } 475 476 public PackageSetting setSignatures(PackageSignatures signatures) { 477 this.signatures = signatures; 478 onChanged(); 479 return this; 480 } 481 482 public PackageSetting setVolumeUuid(String volumeUuid) { 483 this.volumeUuid = volumeUuid; 484 onChanged(); 485 return this; 486 } 487 488 @Override 489 public boolean isExternalStorage() { 490 return (getFlags() & ApplicationInfo.FLAG_EXTERNAL_STORAGE) != 0; 491 } 492 493 public PackageSetting setUpdateAvailable(boolean updateAvailable) { 494 this.updateAvailable = updateAvailable; 495 onChanged(); 496 return this; 497 } 498 499 public void setSharedUserAppId(int sharedUserAppId) { 500 mSharedUserAppId = sharedUserAppId; 501 onChanged(); 502 } 503 504 @Override 505 public int getSharedUserAppId() { 506 return mSharedUserAppId; 507 } 508 509 @Override 510 public boolean hasSharedUser() { 511 return mSharedUserAppId > 0; 512 } 513 514 @Override 515 public String toString() { 516 return "PackageSetting{" 517 + Integer.toHexString(System.identityHashCode(this)) 518 + " " + mName + "/" + mAppId + "}"; 519 } 520 521 protected void copyMimeGroups(@Nullable Map<String, Set<String>> newMimeGroups) { 522 if (newMimeGroups == null) { 523 mimeGroups = null; 524 return; 525 } 526 527 mimeGroups = new ArrayMap<>(newMimeGroups.size()); 528 for (String mimeGroup : newMimeGroups.keySet()) { 529 Set<String> mimeTypes = newMimeGroups.get(mimeGroup); 530 531 if (mimeTypes != null) { 532 mimeGroups.put(mimeGroup, new ArraySet<>(mimeTypes)); 533 } else { 534 mimeGroups.put(mimeGroup, new ArraySet<>()); 535 } 536 } 537 } 538 539 /** Updates all fields in the current setting from another. */ 540 public void updateFrom(PackageSetting other) { 541 copyPackageSetting(other, false /* sealedSnapshot */); 542 543 Set<String> mimeGroupNames = other.mimeGroups != null ? other.mimeGroups.keySet() : null; 544 updateMimeGroups(mimeGroupNames); 545 546 onChanged(); 547 } 548 549 /** 550 * Updates declared MIME groups, removing no longer declared groups 551 * and keeping previous state of MIME groups 552 */ 553 PackageSetting updateMimeGroups(@Nullable Set<String> newMimeGroupNames) { 554 if (newMimeGroupNames == null) { 555 mimeGroups = null; 556 return this; 557 } 558 559 if (mimeGroups == null) { 560 // set mimeGroups to empty map to avoid repeated null-checks in the next loop 561 mimeGroups = Collections.emptyMap(); 562 } 563 564 ArrayMap<String, Set<String>> updatedMimeGroups = 565 new ArrayMap<>(newMimeGroupNames.size()); 566 567 for (String mimeGroup : newMimeGroupNames) { 568 if (mimeGroups.containsKey(mimeGroup)) { 569 updatedMimeGroups.put(mimeGroup, mimeGroups.get(mimeGroup)); 570 } else { 571 updatedMimeGroups.put(mimeGroup, new ArraySet<>()); 572 } 573 } 574 onChanged(); 575 mimeGroups = updatedMimeGroups; 576 return this; 577 } 578 579 @Deprecated 580 @Override 581 public LegacyPermissionState getLegacyPermissionState() { 582 return super.getLegacyPermissionState(); 583 } 584 585 public PackageSetting setInstallPermissionsFixed(boolean installPermissionsFixed) { 586 this.installPermissionsFixed = installPermissionsFixed; 587 return this; 588 } 589 590 public boolean isPrivileged() { 591 return (getPrivateFlags() & ApplicationInfo.PRIVATE_FLAG_PRIVILEGED) != 0; 592 } 593 594 public boolean isOem() { 595 return (getPrivateFlags() & ApplicationInfo.PRIVATE_FLAG_OEM) != 0; 596 } 597 598 public boolean isVendor() { 599 return (getPrivateFlags() & ApplicationInfo.PRIVATE_FLAG_VENDOR) != 0; 600 } 601 602 public boolean isProduct() { 603 return (getPrivateFlags() & ApplicationInfo.PRIVATE_FLAG_PRODUCT) != 0; 604 } 605 606 @Override 607 public boolean isRequiredForSystemUser() { 608 return (getPrivateFlags() & ApplicationInfo.PRIVATE_FLAG_REQUIRED_FOR_SYSTEM_USER) != 0; 609 } 610 611 public boolean isSystemExt() { 612 return (getPrivateFlags() & ApplicationInfo.PRIVATE_FLAG_SYSTEM_EXT) != 0; 613 } 614 615 public boolean isOdm() { 616 return (getPrivateFlags() & ApplicationInfo.PRIVATE_FLAG_ODM) != 0; 617 } 618 619 public boolean isSystem() { 620 return (getFlags() & ApplicationInfo.FLAG_SYSTEM) != 0; 621 } 622 623 public SigningDetails getSigningDetails() { 624 return signatures.mSigningDetails; 625 } 626 627 public PackageSetting setSigningDetails(SigningDetails signingDetails) { 628 // TODO: Immutability 629 signatures.mSigningDetails = signingDetails; 630 onChanged(); 631 return this; 632 } 633 634 public void copyPackageSetting(PackageSetting other, boolean sealedSnapshot) { 635 super.copySettingBase(other); 636 mSharedUserAppId = other.mSharedUserAppId; 637 mLoadingProgress = other.mLoadingProgress; 638 mLoadingCompletedTime = other.mLoadingCompletedTime; 639 legacyNativeLibraryPath = other.legacyNativeLibraryPath; 640 mName = other.mName; 641 mRealName = other.mRealName; 642 mAppId = other.mAppId; 643 pkg = other.pkg; 644 mPath = other.mPath; 645 mPathString = other.mPathString; 646 mPrimaryCpuAbi = other.mPrimaryCpuAbi; 647 mSecondaryCpuAbi = other.mSecondaryCpuAbi; 648 mCpuAbiOverride = other.mCpuAbiOverride; 649 mLastModifiedTime = other.mLastModifiedTime; 650 lastUpdateTime = other.lastUpdateTime; 651 versionCode = other.versionCode; 652 signatures = other.signatures; 653 installPermissionsFixed = other.installPermissionsFixed; 654 keySetData = new PackageKeySetData(other.keySetData); 655 installSource = other.installSource; 656 volumeUuid = other.volumeUuid; 657 categoryOverride = other.categoryOverride; 658 updateAvailable = other.updateAvailable; 659 forceQueryableOverride = other.forceQueryableOverride; 660 mDomainSetId = other.mDomainSetId; 661 mAppMetadataFilePath = other.mAppMetadataFilePath; 662 663 usesSdkLibraries = other.usesSdkLibraries != null 664 ? Arrays.copyOf(other.usesSdkLibraries, 665 other.usesSdkLibraries.length) : null; 666 usesSdkLibrariesVersionsMajor = other.usesSdkLibrariesVersionsMajor != null 667 ? Arrays.copyOf(other.usesSdkLibrariesVersionsMajor, 668 other.usesSdkLibrariesVersionsMajor.length) : null; 669 670 usesStaticLibraries = other.usesStaticLibraries != null 671 ? Arrays.copyOf(other.usesStaticLibraries, 672 other.usesStaticLibraries.length) : null; 673 usesStaticLibrariesVersions = other.usesStaticLibrariesVersions != null 674 ? Arrays.copyOf(other.usesStaticLibrariesVersions, 675 other.usesStaticLibrariesVersions.length) : null; 676 mUserStates.clear(); 677 for (int i = 0; i < other.mUserStates.size(); i++) { 678 if (sealedSnapshot) { 679 mUserStates.put(other.mUserStates.keyAt(i), 680 other.mUserStates.valueAt(i).snapshot()); 681 } else { 682 var userState = other.mUserStates.valueAt(i); 683 userState.setWatchable(this); 684 mUserStates.put(other.mUserStates.keyAt(i), userState); 685 } 686 } 687 688 if (mOldCodePaths != null) { 689 if (other.mOldCodePaths != null) { 690 mOldCodePaths.clear(); 691 mOldCodePaths.addAll(other.mOldCodePaths); 692 } else { 693 mOldCodePaths = null; 694 } 695 } 696 697 copyMimeGroups(other.mimeGroups); 698 pkgState.updateFrom(other.pkgState); 699 onChanged(); 700 } 701 702 @VisibleForTesting 703 PackageUserStateImpl modifyUserState(int userId) { 704 PackageUserStateImpl state = mUserStates.get(userId); 705 if (state == null) { 706 state = new PackageUserStateImpl(this); 707 mUserStates.put(userId, state); 708 onChanged(); 709 } 710 return state; 711 } 712 713 public PackageUserStateImpl getOrCreateUserState(@UserIdInt int userId) { 714 PackageUserStateImpl state = mUserStates.get(userId); 715 if (state == null) { 716 state = new PackageUserStateImpl(this); 717 mUserStates.put(userId, state); 718 } 719 return state; 720 } 721 722 @NonNull 723 public PackageUserStateInternal readUserState(int userId) { 724 PackageUserStateInternal state = mUserStates.get(userId); 725 if (state == null) { 726 return PackageUserStateInternal.DEFAULT; 727 } 728 return state; 729 } 730 731 void setEnabled(int state, int userId, String callingPackage) { 732 modifyUserState(userId) 733 .setEnabledState(state) 734 .setLastDisableAppCaller(callingPackage); 735 onChanged(); 736 } 737 738 int getEnabled(int userId) { 739 return readUserState(userId).getEnabledState(); 740 } 741 742 void setInstalled(boolean inst, int userId) { 743 modifyUserState(userId).setInstalled(inst); 744 onChanged(); 745 } 746 747 boolean getInstalled(int userId) { 748 return readUserState(userId).isInstalled(); 749 } 750 751 int getInstallReason(int userId) { 752 return readUserState(userId).getInstallReason(); 753 } 754 755 void setInstallReason(int installReason, int userId) { 756 modifyUserState(userId).setInstallReason(installReason); 757 onChanged(); 758 } 759 760 int getUninstallReason(int userId) { 761 return readUserState(userId).getUninstallReason(); 762 } 763 764 void setUninstallReason(@PackageManager.UninstallReason int uninstallReason, int userId) { 765 modifyUserState(userId).setUninstallReason(uninstallReason); 766 onChanged(); 767 } 768 769 @NonNull 770 OverlayPaths getOverlayPaths(int userId) { 771 return readUserState(userId).getOverlayPaths(); 772 } 773 774 boolean setOverlayPathsForLibrary(String libName, OverlayPaths overlayPaths, int userId) { 775 boolean changed = modifyUserState(userId) 776 .setSharedLibraryOverlayPaths(libName, overlayPaths); 777 onChanged(); 778 return changed; 779 } 780 781 boolean isAnyInstalled(int[] users) { 782 for (int user: users) { 783 if (readUserState(user).isInstalled()) { 784 return true; 785 } 786 } 787 return false; 788 } 789 790 int[] queryInstalledUsers(int[] users, boolean installed) { 791 int num = 0; 792 for (int user : users) { 793 if (getInstalled(user) == installed) { 794 num++; 795 } 796 } 797 int[] res = new int[num]; 798 num = 0; 799 for (int user : users) { 800 if (getInstalled(user) == installed) { 801 res[num] = user; 802 num++; 803 } 804 } 805 return res; 806 } 807 808 long getCeDataInode(int userId) { 809 return readUserState(userId).getCeDataInode(); 810 } 811 812 void setCeDataInode(long ceDataInode, int userId) { 813 modifyUserState(userId).setCeDataInode(ceDataInode); 814 onChanged(); 815 } 816 817 boolean getStopped(int userId) { 818 return readUserState(userId).isStopped(); 819 } 820 821 void setStopped(boolean stop, int userId) { 822 modifyUserState(userId).setStopped(stop); 823 onChanged(); 824 } 825 826 boolean getNotLaunched(int userId) { 827 return readUserState(userId).isNotLaunched(); 828 } 829 830 void setNotLaunched(boolean stop, int userId) { 831 modifyUserState(userId).setNotLaunched(stop); 832 onChanged(); 833 } 834 835 boolean getHidden(int userId) { 836 return readUserState(userId).isHidden(); 837 } 838 839 void setHidden(boolean hidden, int userId) { 840 modifyUserState(userId).setHidden(hidden); 841 onChanged(); 842 } 843 844 int getDistractionFlags(int userId) { 845 return readUserState(userId).getDistractionFlags(); 846 } 847 848 void setDistractionFlags(int distractionFlags, int userId) { 849 modifyUserState(userId).setDistractionFlags(distractionFlags); 850 onChanged(); 851 } 852 853 public boolean getInstantApp(int userId) { 854 return readUserState(userId).isInstantApp(); 855 } 856 857 void setInstantApp(boolean instantApp, int userId) { 858 modifyUserState(userId).setInstantApp(instantApp); 859 onChanged(); 860 } 861 862 boolean getVirtualPreload(int userId) { 863 return readUserState(userId).isVirtualPreload(); 864 } 865 866 void setVirtualPreload(boolean virtualPreload, int userId) { 867 modifyUserState(userId).setVirtualPreload(virtualPreload); 868 onChanged(); 869 } 870 871 void setUserState(int userId, long ceDataInode, int enabled, boolean installed, boolean stopped, 872 boolean notLaunched, boolean hidden, int distractionFlags, 873 ArrayMap<String, SuspendParams> suspendParams, boolean instantApp, 874 boolean virtualPreload, String lastDisableAppCaller, 875 ArraySet<String> enabledComponents, ArraySet<String> disabledComponents, 876 int installReason, int uninstallReason, 877 String harmfulAppWarning, String splashScreenTheme, 878 long firstInstallTime, int aspectRatio) { 879 modifyUserState(userId) 880 .setSuspendParams(suspendParams) 881 .setCeDataInode(ceDataInode) 882 .setEnabledState(enabled) 883 .setInstalled(installed) 884 .setStopped(stopped) 885 .setNotLaunched(notLaunched) 886 .setHidden(hidden) 887 .setDistractionFlags(distractionFlags) 888 .setLastDisableAppCaller(lastDisableAppCaller) 889 .setEnabledComponents(enabledComponents) 890 .setDisabledComponents(disabledComponents) 891 .setInstallReason(installReason) 892 .setUninstallReason(uninstallReason) 893 .setInstantApp(instantApp) 894 .setVirtualPreload(virtualPreload) 895 .setHarmfulAppWarning(harmfulAppWarning) 896 .setSplashScreenTheme(splashScreenTheme) 897 .setFirstInstallTimeMillis(firstInstallTime) 898 .setMinAspectRatio(aspectRatio); 899 onChanged(); 900 } 901 902 void setUserState(int userId, PackageUserStateInternal otherState) { 903 setUserState(userId, otherState.getCeDataInode(), otherState.getEnabledState(), 904 otherState.isInstalled(), otherState.isStopped(), otherState.isNotLaunched(), 905 otherState.isHidden(), otherState.getDistractionFlags(), 906 otherState.getSuspendParams() == null 907 ? null : otherState.getSuspendParams().untrackedStorage(), 908 otherState.isInstantApp(), 909 otherState.isVirtualPreload(), otherState.getLastDisableAppCaller(), 910 otherState.getEnabledComponentsNoCopy() == null 911 ? null : otherState.getEnabledComponentsNoCopy().untrackedStorage(), 912 otherState.getDisabledComponentsNoCopy() == null 913 ? null : otherState.getDisabledComponentsNoCopy().untrackedStorage(), 914 otherState.getInstallReason(), otherState.getUninstallReason(), 915 otherState.getHarmfulAppWarning(), otherState.getSplashScreenTheme(), 916 otherState.getFirstInstallTimeMillis(), otherState.getMinAspectRatio()); 917 } 918 919 WatchedArraySet<String> getEnabledComponents(int userId) { 920 return readUserState(userId).getEnabledComponentsNoCopy(); 921 } 922 923 WatchedArraySet<String> getDisabledComponents(int userId) { 924 return readUserState(userId).getDisabledComponentsNoCopy(); 925 } 926 927 /** Test only */ 928 void setEnabledComponents(WatchedArraySet<String> components, int userId) { 929 modifyUserState(userId).setEnabledComponents(components); 930 onChanged(); 931 } 932 933 /** Test only */ 934 void setDisabledComponents(WatchedArraySet<String> components, int userId) { 935 modifyUserState(userId).setDisabledComponents(components); 936 onChanged(); 937 } 938 939 void setEnabledComponentsCopy(WatchedArraySet<String> components, int userId) { 940 modifyUserState(userId).setEnabledComponents(components != null 941 ? components.untrackedStorage() : null); 942 onChanged(); 943 } 944 945 void setDisabledComponentsCopy(WatchedArraySet<String> components, int userId) { 946 modifyUserState(userId).setDisabledComponents(components != null 947 ? components.untrackedStorage() : null); 948 onChanged(); 949 } 950 951 PackageUserStateImpl modifyUserStateComponents(int userId, boolean disabled, 952 boolean enabled) { 953 PackageUserStateImpl state = modifyUserState(userId); 954 boolean changed = false; 955 if (disabled && state.getDisabledComponentsNoCopy() == null) { 956 state.setDisabledComponents(new ArraySet<String>(1)); 957 changed = true; 958 } 959 if (enabled && state.getEnabledComponentsNoCopy() == null) { 960 state.setEnabledComponents(new ArraySet<String>(1)); 961 changed = true; 962 } 963 if (changed) { 964 onChanged(); 965 } 966 return state; 967 } 968 969 void addDisabledComponent(String componentClassName, int userId) { 970 modifyUserStateComponents(userId, true, false) 971 .getDisabledComponentsNoCopy().add(componentClassName); 972 onChanged(); 973 } 974 975 void addEnabledComponent(String componentClassName, int userId) { 976 modifyUserStateComponents(userId, false, true) 977 .getEnabledComponentsNoCopy().add(componentClassName); 978 onChanged(); 979 } 980 981 boolean enableComponentLPw(String componentClassName, int userId) { 982 PackageUserStateImpl state = modifyUserStateComponents(userId, false, true); 983 boolean changed = state.getDisabledComponentsNoCopy() != null 984 ? state.getDisabledComponentsNoCopy().remove(componentClassName) : false; 985 changed |= state.getEnabledComponentsNoCopy().add(componentClassName); 986 if (changed) { 987 onChanged(); 988 } 989 return changed; 990 } 991 992 boolean disableComponentLPw(String componentClassName, int userId) { 993 PackageUserStateImpl state = modifyUserStateComponents(userId, true, false); 994 boolean changed = state.getEnabledComponentsNoCopy() != null 995 ? state.getEnabledComponentsNoCopy().remove(componentClassName) : false; 996 changed |= state.getDisabledComponentsNoCopy().add(componentClassName); 997 if (changed) { 998 onChanged(); 999 } 1000 return changed; 1001 } 1002 1003 boolean restoreComponentLPw(String componentClassName, int userId) { 1004 PackageUserStateImpl state = modifyUserStateComponents(userId, true, true); 1005 boolean changed = state.getDisabledComponentsNoCopy() != null 1006 ? state.getDisabledComponentsNoCopy().remove(componentClassName) : false; 1007 changed |= state.getEnabledComponentsNoCopy() != null 1008 ? state.getEnabledComponentsNoCopy().remove(componentClassName) : false; 1009 if (changed) { 1010 onChanged(); 1011 } 1012 return changed; 1013 } 1014 1015 int getCurrentEnabledStateLPr(String componentName, int userId) { 1016 PackageUserStateInternal state = readUserState(userId); 1017 if (state.getEnabledComponentsNoCopy() != null 1018 && state.getEnabledComponentsNoCopy().contains(componentName)) { 1019 return COMPONENT_ENABLED_STATE_ENABLED; 1020 } else if (state.getDisabledComponentsNoCopy() != null 1021 && state.getDisabledComponentsNoCopy().contains(componentName)) { 1022 return COMPONENT_ENABLED_STATE_DISABLED; 1023 } else { 1024 return COMPONENT_ENABLED_STATE_DEFAULT; 1025 } 1026 } 1027 1028 void removeUser(int userId) { 1029 mUserStates.delete(userId); 1030 onChanged(); 1031 } 1032 1033 public int[] getNotInstalledUserIds() { 1034 int count = 0; 1035 int userStateCount = mUserStates.size(); 1036 for (int i = 0; i < userStateCount; i++) { 1037 if (!mUserStates.valueAt(i).isInstalled()) { 1038 count++; 1039 } 1040 } 1041 if (count == 0) { 1042 return EmptyArray.INT; 1043 } 1044 1045 int[] excludedUserIds = new int[count]; 1046 int idx = 0; 1047 for (int i = 0; i < userStateCount; i++) { 1048 if (!mUserStates.valueAt(i).isInstalled()) { 1049 excludedUserIds[idx++] = mUserStates.keyAt(i); 1050 } 1051 } 1052 return excludedUserIds; 1053 } 1054 1055 /** 1056 * TODO (b/170263003) refactor to dump to permissiongr proto Dumps the permissions that are 1057 * granted to users for this package. 1058 */ 1059 void writePackageUserPermissionsProto(ProtoOutputStream proto, long fieldId, 1060 List<UserInfo> users, LegacyPermissionDataProvider dataProvider) { 1061 Collection<LegacyPermissionState.PermissionState> runtimePermissionStates; 1062 for (UserInfo user : users) { 1063 final long permissionsToken = proto.start(PackageProto.USER_PERMISSIONS); 1064 proto.write(PackageProto.UserPermissionsProto.ID, user.id); 1065 1066 runtimePermissionStates = dataProvider.getLegacyPermissionState(mAppId) 1067 .getPermissionStates(user.id); 1068 for (LegacyPermissionState.PermissionState permission : runtimePermissionStates) { 1069 if (permission.isGranted()) { 1070 proto.write(PackageProto.UserPermissionsProto.GRANTED_PERMISSIONS, 1071 permission.getName()); 1072 } 1073 } 1074 proto.end(permissionsToken); 1075 } 1076 } 1077 1078 protected void writeUsersInfoToProto(ProtoOutputStream proto, long fieldId) { 1079 int count = mUserStates.size(); 1080 for (int i = 0; i < count; i++) { 1081 final long userToken = proto.start(fieldId); 1082 final int userId = mUserStates.keyAt(i); 1083 final PackageUserStateInternal state = mUserStates.valueAt(i); 1084 proto.write(PackageProto.UserInfoProto.ID, userId); 1085 final int installType; 1086 if (state.isInstantApp()) { 1087 installType = PackageProto.UserInfoProto.INSTANT_APP_INSTALL; 1088 } else if (state.isInstalled()) { 1089 installType = PackageProto.UserInfoProto.FULL_APP_INSTALL; 1090 } else { 1091 installType = PackageProto.UserInfoProto.NOT_INSTALLED_FOR_USER; 1092 } 1093 proto.write(PackageProto.UserInfoProto.INSTALL_TYPE, installType); 1094 proto.write(PackageProto.UserInfoProto.IS_HIDDEN, state.isHidden()); 1095 proto.write(PackageProto.UserInfoProto.DISTRACTION_FLAGS, state.getDistractionFlags()); 1096 proto.write(PackageProto.UserInfoProto.IS_SUSPENDED, state.isSuspended()); 1097 if (state.isSuspended()) { 1098 for (int j = 0; j < state.getSuspendParams().size(); j++) { 1099 proto.write(PackageProto.UserInfoProto.SUSPENDING_PACKAGE, 1100 state.getSuspendParams().keyAt(j)); 1101 } 1102 } 1103 proto.write(PackageProto.UserInfoProto.IS_STOPPED, state.isStopped()); 1104 proto.write(PackageProto.UserInfoProto.IS_LAUNCHED, !state.isNotLaunched()); 1105 proto.write(PackageProto.UserInfoProto.ENABLED_STATE, state.getEnabledState()); 1106 proto.write( 1107 PackageProto.UserInfoProto.LAST_DISABLED_APP_CALLER, 1108 state.getLastDisableAppCaller()); 1109 proto.write(PackageProto.UserInfoProto.FIRST_INSTALL_TIME_MS, 1110 state.getFirstInstallTimeMillis()); 1111 proto.end(userToken); 1112 } 1113 } 1114 1115 /** 1116 * @see #mPath 1117 */ 1118 PackageSetting setPath(@NonNull File path) { 1119 this.mPath = path; 1120 this.mPathString = path.toString(); 1121 onChanged(); 1122 return this; 1123 } 1124 1125 /** 1126 * @param userId the specific user to change the label/icon for 1127 * @see PackageUserStateImpl#overrideLabelAndIcon(ComponentName, String, Integer) 1128 */ 1129 @VisibleForTesting(visibility = VisibleForTesting.Visibility.PACKAGE) 1130 public boolean overrideNonLocalizedLabelAndIcon(@NonNull ComponentName component, 1131 @Nullable String label, @Nullable Integer icon, @UserIdInt int userId) { 1132 boolean changed = modifyUserState(userId).overrideLabelAndIcon(component, label, icon); 1133 onChanged(); 1134 return changed; 1135 } 1136 1137 /** 1138 * @param userId the specific user to reset 1139 * @see PackageUserStateImpl#resetOverrideComponentLabelIcon() 1140 */ 1141 public void resetOverrideComponentLabelIcon(@UserIdInt int userId) { 1142 modifyUserState(userId).resetOverrideComponentLabelIcon(); 1143 onChanged(); 1144 } 1145 1146 /** 1147 * @param userId the specified user to get the theme setting from 1148 * @return the theme name previously persisted for the user or null if no splashscreen theme is 1149 * persisted. 1150 * @see android.window.SplashScreen#setSplashScreenTheme(int) 1151 */ 1152 @Nullable 1153 public String getSplashScreenTheme(@UserIdInt int userId) { 1154 return readUserState(userId).getSplashScreenTheme(); 1155 } 1156 1157 public boolean isIncremental() { 1158 return IncrementalManager.isIncrementalPath(mPathString); 1159 } 1160 /** 1161 * @return True if package is still being loaded, false if the package is fully loaded. 1162 */ 1163 public boolean isLoading() { 1164 return Math.abs(1.0f - mLoadingProgress) >= 0.00000001f; 1165 } 1166 1167 public PackageSetting setLoadingProgress(float progress) { 1168 mLoadingProgress = progress; 1169 onChanged(); 1170 return this; 1171 } 1172 1173 public PackageSetting setLoadingCompletedTime(long loadingCompletedTime) { 1174 mLoadingCompletedTime = loadingCompletedTime; 1175 onChanged(); 1176 return this; 1177 } 1178 1179 /** 1180 * @param path to app metadata file 1181 */ 1182 public PackageSetting setAppMetadataFilePath(String path) { 1183 mAppMetadataFilePath = path; 1184 onChanged(); 1185 return this; 1186 } 1187 1188 @NonNull 1189 @Override 1190 public long getVersionCode() { 1191 return versionCode; 1192 } 1193 1194 /** 1195 * @see PackageState#getMimeGroups() 1196 */ 1197 @Nullable 1198 @Override 1199 public Map<String, Set<String>> getMimeGroups() { 1200 return CollectionUtils.isEmpty(mimeGroups) ? Collections.emptyMap() 1201 : Collections.unmodifiableMap(mimeGroups); 1202 } 1203 1204 @NonNull 1205 @Override 1206 public String getPackageName() { 1207 return mName; 1208 } 1209 1210 @Nullable 1211 @Override 1212 public AndroidPackage getAndroidPackage() { 1213 return getPkg(); 1214 } 1215 1216 @NonNull 1217 public SigningInfo getSigningInfo() { 1218 return new SigningInfo(signatures.mSigningDetails); 1219 } 1220 1221 @NonNull 1222 @Override 1223 public String[] getUsesSdkLibraries() { 1224 return usesSdkLibraries == null ? EmptyArray.STRING : usesSdkLibraries; 1225 } 1226 1227 @NonNull 1228 @Override 1229 public long[] getUsesSdkLibrariesVersionsMajor() { 1230 return usesSdkLibrariesVersionsMajor == null ? EmptyArray.LONG 1231 : usesSdkLibrariesVersionsMajor; 1232 } 1233 1234 @NonNull 1235 @Override 1236 public String[] getUsesStaticLibraries() { 1237 return usesStaticLibraries == null ? EmptyArray.STRING : usesStaticLibraries; 1238 } 1239 1240 @NonNull 1241 @Override 1242 public long[] getUsesStaticLibrariesVersions() { 1243 return usesStaticLibrariesVersions == null ? EmptyArray.LONG : usesStaticLibrariesVersions; 1244 } 1245 1246 @NonNull 1247 @Override 1248 public List<SharedLibrary> getSharedLibraryDependencies() { 1249 return (List<SharedLibrary>) (List<?>) pkgState.getUsesLibraryInfos(); 1250 } 1251 1252 @NonNull 1253 public PackageSetting addUsesLibraryInfo(@NonNull SharedLibraryInfo value) { 1254 pkgState.addUsesLibraryInfo(new SharedLibraryWrapper(value)); 1255 return this; 1256 } 1257 1258 @NonNull 1259 @Override 1260 public List<String> getUsesLibraryFiles() { 1261 return pkgState.getUsesLibraryFiles(); 1262 } 1263 1264 @NonNull 1265 public PackageSetting addUsesLibraryFile(String value) { 1266 pkgState.addUsesLibraryFile(value); 1267 return this; 1268 } 1269 1270 @Override 1271 public boolean isHiddenUntilInstalled() { 1272 return pkgState.isHiddenUntilInstalled(); 1273 } 1274 1275 @NonNull 1276 @Override 1277 public long[] getLastPackageUsageTime() { 1278 return pkgState.getLastPackageUsageTimeInMills(); 1279 } 1280 1281 @Override 1282 public boolean isUpdatedSystemApp() { 1283 return pkgState.isUpdatedSystemApp(); 1284 } 1285 1286 @Override 1287 public boolean isApkInUpdatedApex() { 1288 return pkgState.isApkInUpdatedApex(); 1289 } 1290 1291 @Nullable 1292 @Override 1293 public String getApexModuleName() { 1294 return pkgState.getApexModuleName(); 1295 } 1296 1297 public PackageSetting setDomainSetId(@NonNull UUID domainSetId) { 1298 mDomainSetId = domainSetId; 1299 onChanged(); 1300 return this; 1301 } 1302 1303 public PackageSetting setCategoryOverride(int categoryHint) { 1304 this.categoryOverride = categoryHint; 1305 onChanged(); 1306 return this; 1307 } 1308 1309 public PackageSetting setLegacyNativeLibraryPath( 1310 String legacyNativeLibraryPathString) { 1311 this.legacyNativeLibraryPath = legacyNativeLibraryPathString; 1312 onChanged(); 1313 return this; 1314 } 1315 1316 public PackageSetting setMimeGroups(@NonNull Map<String, Set<String>> mimeGroups) { 1317 this.mimeGroups = mimeGroups; 1318 onChanged(); 1319 return this; 1320 } 1321 1322 public PackageSetting setOldCodePaths(Set<String> oldCodePaths) { 1323 mOldCodePaths = oldCodePaths; 1324 onChanged(); 1325 return this; 1326 } 1327 1328 public PackageSetting setUsesSdkLibraries(String[] usesSdkLibraries) { 1329 this.usesSdkLibraries = usesSdkLibraries; 1330 onChanged(); 1331 return this; 1332 } 1333 1334 public PackageSetting setUsesSdkLibrariesVersionsMajor(long[] usesSdkLibrariesVersions) { 1335 this.usesSdkLibrariesVersionsMajor = usesSdkLibrariesVersions; 1336 onChanged(); 1337 return this; 1338 } 1339 1340 public PackageSetting setUsesStaticLibraries(String[] usesStaticLibraries) { 1341 this.usesStaticLibraries = usesStaticLibraries; 1342 onChanged(); 1343 return this; 1344 } 1345 1346 public PackageSetting setUsesStaticLibrariesVersions(long[] usesStaticLibrariesVersions) { 1347 this.usesStaticLibrariesVersions = usesStaticLibrariesVersions; 1348 onChanged(); 1349 return this; 1350 } 1351 1352 public PackageSetting setApexModuleName(@Nullable String apexModuleName) { 1353 pkgState.setApexModuleName(apexModuleName); 1354 return this; 1355 } 1356 1357 @NonNull 1358 @Override 1359 public PackageStateUnserialized getTransientState() { 1360 return pkgState; 1361 } 1362 1363 @NonNull 1364 public SparseArray<? extends PackageUserStateInternal> getUserStates() { 1365 return mUserStates; 1366 } 1367 1368 public PackageSetting addMimeTypes(String mimeGroup, Set<String> mimeTypes) { 1369 if (mimeGroups == null) { 1370 mimeGroups = new ArrayMap<>(); 1371 } 1372 1373 Set<String> existingMimeTypes = mimeGroups.get(mimeGroup); 1374 if (existingMimeTypes == null) { 1375 existingMimeTypes = new ArraySet<>(); 1376 mimeGroups.put(mimeGroup, existingMimeTypes); 1377 } 1378 existingMimeTypes.addAll(mimeTypes); 1379 return this; 1380 } 1381 1382 @NonNull 1383 @Override 1384 public PackageUserState getStateForUser(@NonNull UserHandle user) { 1385 PackageUserState userState = getUserStates().get(user.getIdentifier()); 1386 return userState == null ? PackageUserState.DEFAULT : userState; 1387 } 1388 1389 @Nullable 1390 public String getPrimaryCpuAbi() { 1391 if (TextUtils.isEmpty(mPrimaryCpuAbi) && pkg != null) { 1392 return AndroidPackageUtils.getRawPrimaryCpuAbi(pkg); 1393 } 1394 1395 return mPrimaryCpuAbi; 1396 } 1397 1398 @Nullable 1399 public String getSecondaryCpuAbi() { 1400 if (TextUtils.isEmpty(mSecondaryCpuAbi) && pkg != null) { 1401 return AndroidPackageUtils.getRawSecondaryCpuAbi(pkg); 1402 } 1403 1404 return mSecondaryCpuAbi; 1405 } 1406 1407 @Nullable 1408 @Override 1409 public String getSeInfo() { 1410 String overrideSeInfo = getTransientState().getOverrideSeInfo(); 1411 if (!TextUtils.isEmpty(overrideSeInfo)) { 1412 return overrideSeInfo; 1413 } 1414 1415 return getTransientState().getSeInfo(); 1416 } 1417 1418 @Nullable 1419 public String getPrimaryCpuAbiLegacy() { 1420 return mPrimaryCpuAbi; 1421 } 1422 1423 @Nullable 1424 public String getSecondaryCpuAbiLegacy() { 1425 return mSecondaryCpuAbi; 1426 } 1427 1428 @ApplicationInfo.HiddenApiEnforcementPolicy 1429 @Override 1430 public int getHiddenApiEnforcementPolicy() { 1431 return AndroidPackageUtils.getHiddenApiEnforcementPolicy(getAndroidPackage(), this); 1432 } 1433 1434 @Override 1435 public boolean isApex() { 1436 // TODO(b/256637152): 1437 // TODO(b/243839669): Use a flag tracked directly in PackageSetting 1438 return getAndroidPackage() != null && getAndroidPackage().isApex(); 1439 } 1440 1441 1442 1443 // Code below generated by codegen v1.0.23. 1444 // 1445 // DO NOT MODIFY! 1446 // CHECKSTYLE:OFF Generated code 1447 // 1448 // To regenerate run: 1449 // $ codegen $ANDROID_BUILD_TOP/frameworks/base/services/core/java/com/android/server/pm/PackageSetting.java 1450 // 1451 // To exclude the generated code from IntelliJ auto-formatting enable (one-time): 1452 // Settings > Editor > Code Style > Formatter Control 1453 //@formatter:off 1454 1455 1456 @DataClass.Generated.Member 1457 public @Deprecated @Nullable Set<String> getOldCodePaths() { 1458 return mOldCodePaths; 1459 } 1460 1461 /** 1462 * The path under which native libraries have been unpacked. This path is 1463 * always derived at runtime, and is only stored here for cleanup when a 1464 * package is uninstalled. 1465 */ 1466 @DataClass.Generated.Member 1467 public @Nullable @Deprecated String getLegacyNativeLibraryPath() { 1468 return legacyNativeLibraryPath; 1469 } 1470 1471 @DataClass.Generated.Member 1472 public @NonNull String getName() { 1473 return mName; 1474 } 1475 1476 @DataClass.Generated.Member 1477 public @Nullable String getRealName() { 1478 return mRealName; 1479 } 1480 1481 @DataClass.Generated.Member 1482 public int getAppId() { 1483 return mAppId; 1484 } 1485 1486 /** 1487 * It is expected that all code that uses a {@link PackageSetting} understands this inner field 1488 * may be null. Note that this relationship only works one way. It should not be possible to 1489 * have an entry inside {@link PackageManagerService#mPackages} without a corresponding 1490 * {@link PackageSetting} inside {@link Settings#mPackages}. 1491 * 1492 * @see PackageState#getAndroidPackage() 1493 */ 1494 @DataClass.Generated.Member 1495 public @Nullable AndroidPackageInternal getPkg() { 1496 return pkg; 1497 } 1498 1499 /** 1500 * @see AndroidPackage#getPath() 1501 */ 1502 @DataClass.Generated.Member 1503 public @NonNull File getPath() { 1504 return mPath; 1505 } 1506 1507 @DataClass.Generated.Member 1508 public @NonNull String getPathString() { 1509 return mPathString; 1510 } 1511 1512 @DataClass.Generated.Member 1513 public float getLoadingProgress() { 1514 return mLoadingProgress; 1515 } 1516 1517 @DataClass.Generated.Member 1518 public long getLoadingCompletedTime() { 1519 return mLoadingCompletedTime; 1520 } 1521 1522 @DataClass.Generated.Member 1523 public @Nullable String getCpuAbiOverride() { 1524 return mCpuAbiOverride; 1525 } 1526 1527 @DataClass.Generated.Member 1528 public long getLastModifiedTime() { 1529 return mLastModifiedTime; 1530 } 1531 1532 @DataClass.Generated.Member 1533 public long getLastUpdateTime() { 1534 return lastUpdateTime; 1535 } 1536 1537 @DataClass.Generated.Member 1538 public @NonNull PackageSignatures getSignatures() { 1539 return signatures; 1540 } 1541 1542 @DataClass.Generated.Member 1543 public boolean isInstallPermissionsFixed() { 1544 return installPermissionsFixed; 1545 } 1546 1547 @DataClass.Generated.Member 1548 public @NonNull PackageKeySetData getKeySetData() { 1549 return keySetData; 1550 } 1551 1552 @DataClass.Generated.Member 1553 public @NonNull InstallSource getInstallSource() { 1554 return installSource; 1555 } 1556 1557 /** 1558 * @see PackageState#getVolumeUuid() 1559 */ 1560 @DataClass.Generated.Member 1561 public @Nullable String getVolumeUuid() { 1562 return volumeUuid; 1563 } 1564 1565 /** 1566 * @see PackageState#getCategoryOverride() 1567 */ 1568 @DataClass.Generated.Member 1569 public int getCategoryOverride() { 1570 return categoryOverride; 1571 } 1572 1573 /** 1574 * @see PackageState#isUpdateAvailable() 1575 */ 1576 @DataClass.Generated.Member 1577 public boolean isUpdateAvailable() { 1578 return updateAvailable; 1579 } 1580 1581 @DataClass.Generated.Member 1582 public boolean isForceQueryableOverride() { 1583 return forceQueryableOverride; 1584 } 1585 1586 @DataClass.Generated.Member 1587 public @NonNull PackageStateUnserialized getPkgState() { 1588 return pkgState; 1589 } 1590 1591 @DataClass.Generated.Member 1592 public @NonNull UUID getDomainSetId() { 1593 return mDomainSetId; 1594 } 1595 1596 @DataClass.Generated.Member 1597 public @Nullable String getAppMetadataFilePath() { 1598 return mAppMetadataFilePath; 1599 } 1600 1601 @DataClass.Generated( 1602 time = 1680917079522L, 1603 codegenVersion = "1.0.23", 1604 sourceFile = "frameworks/base/services/core/java/com/android/server/pm/PackageSetting.java", 1605 inputSignatures = "private int mSharedUserAppId\nprivate @android.annotation.Nullable java.util.Map<java.lang.String,java.util.Set<java.lang.String>> mimeGroups\nprivate @java.lang.Deprecated @android.annotation.Nullable java.util.Set<java.lang.String> mOldCodePaths\nprivate @android.annotation.Nullable java.lang.String[] usesSdkLibraries\nprivate @android.annotation.Nullable long[] usesSdkLibrariesVersionsMajor\nprivate @android.annotation.Nullable java.lang.String[] usesStaticLibraries\nprivate @android.annotation.Nullable long[] usesStaticLibrariesVersions\nprivate @android.annotation.Nullable @java.lang.Deprecated java.lang.String legacyNativeLibraryPath\nprivate @android.annotation.NonNull java.lang.String mName\nprivate @android.annotation.Nullable java.lang.String mRealName\nprivate int mAppId\nprivate @android.annotation.Nullable com.android.server.pm.parsing.pkg.AndroidPackageInternal pkg\nprivate @android.annotation.NonNull java.io.File mPath\nprivate @android.annotation.NonNull java.lang.String mPathString\nprivate float mLoadingProgress\nprivate long mLoadingCompletedTime\nprivate @android.annotation.Nullable java.lang.String mPrimaryCpuAbi\nprivate @android.annotation.Nullable java.lang.String mSecondaryCpuAbi\nprivate @android.annotation.Nullable java.lang.String mCpuAbiOverride\nprivate long mLastModifiedTime\nprivate long lastUpdateTime\nprivate long versionCode\nprivate @android.annotation.NonNull com.android.server.pm.PackageSignatures signatures\nprivate boolean installPermissionsFixed\nprivate @android.annotation.NonNull com.android.server.pm.PackageKeySetData keySetData\nprivate final @android.annotation.NonNull android.util.SparseArray<com.android.server.pm.pkg.PackageUserStateImpl> mUserStates\nprivate @android.annotation.NonNull com.android.server.pm.InstallSource installSource\nprivate @android.annotation.Nullable java.lang.String volumeUuid\nprivate int categoryOverride\nprivate boolean updateAvailable\nprivate boolean forceQueryableOverride\nprivate final @android.annotation.NonNull com.android.server.pm.pkg.PackageStateUnserialized pkgState\nprivate @android.annotation.NonNull java.util.UUID mDomainSetId\nprivate @android.annotation.Nullable java.lang.String mAppMetadataFilePath\nprivate final @android.annotation.NonNull com.android.server.utils.SnapshotCache<com.android.server.pm.PackageSetting> mSnapshot\nprivate com.android.server.utils.SnapshotCache<com.android.server.pm.PackageSetting> makeCache()\npublic com.android.server.pm.PackageSetting snapshot()\npublic void dumpDebug(android.util.proto.ProtoOutputStream,long,java.util.List<android.content.pm.UserInfo>,com.android.server.pm.permission.LegacyPermissionDataProvider)\npublic com.android.server.pm.PackageSetting setAppId(int)\npublic com.android.server.pm.PackageSetting setCpuAbiOverride(java.lang.String)\npublic com.android.server.pm.PackageSetting setFirstInstallTimeFromReplaced(com.android.server.pm.pkg.PackageStateInternal,int[])\npublic com.android.server.pm.PackageSetting setFirstInstallTime(long,int)\npublic com.android.server.pm.PackageSetting setForceQueryableOverride(boolean)\npublic com.android.server.pm.PackageSetting setInstallerPackage(java.lang.String,int)\npublic com.android.server.pm.PackageSetting setUpdateOwnerPackage(java.lang.String)\npublic com.android.server.pm.PackageSetting setInstallSource(com.android.server.pm.InstallSource)\n com.android.server.pm.PackageSetting removeInstallerPackage(java.lang.String)\npublic com.android.server.pm.PackageSetting setIsOrphaned(boolean)\npublic com.android.server.pm.PackageSetting setKeySetData(com.android.server.pm.PackageKeySetData)\npublic com.android.server.pm.PackageSetting setLastModifiedTime(long)\npublic com.android.server.pm.PackageSetting setLastUpdateTime(long)\npublic com.android.server.pm.PackageSetting setLongVersionCode(long)\npublic boolean setMimeGroup(java.lang.String,android.util.ArraySet<java.lang.String>)\npublic com.android.server.pm.PackageSetting setPkg(com.android.server.pm.pkg.AndroidPackage)\npublic com.android.server.pm.PackageSetting setPkgStateLibraryFiles(java.util.Collection<java.lang.String>)\npublic com.android.server.pm.PackageSetting setPrimaryCpuAbi(java.lang.String)\npublic com.android.server.pm.PackageSetting setSecondaryCpuAbi(java.lang.String)\npublic com.android.server.pm.PackageSetting setSignatures(com.android.server.pm.PackageSignatures)\npublic com.android.server.pm.PackageSetting setVolumeUuid(java.lang.String)\npublic @java.lang.Override boolean isExternalStorage()\npublic com.android.server.pm.PackageSetting setUpdateAvailable(boolean)\npublic void setSharedUserAppId(int)\npublic @java.lang.Override int getSharedUserAppId()\npublic @java.lang.Override boolean hasSharedUser()\npublic @java.lang.Override java.lang.String toString()\nprotected void copyMimeGroups(java.util.Map<java.lang.String,java.util.Set<java.lang.String>>)\npublic void updateFrom(com.android.server.pm.PackageSetting)\n com.android.server.pm.PackageSetting updateMimeGroups(java.util.Set<java.lang.String>)\npublic @java.lang.Deprecated @java.lang.Override com.android.server.pm.permission.LegacyPermissionState getLegacyPermissionState()\npublic com.android.server.pm.PackageSetting setInstallPermissionsFixed(boolean)\npublic boolean isPrivileged()\npublic boolean isOem()\npublic boolean isVendor()\npublic boolean isProduct()\npublic @java.lang.Override boolean isRequiredForSystemUser()\npublic boolean isSystemExt()\npublic boolean isOdm()\npublic boolean isSystem()\npublic android.content.pm.SigningDetails getSigningDetails()\npublic com.android.server.pm.PackageSetting setSigningDetails(android.content.pm.SigningDetails)\npublic void copyPackageSetting(com.android.server.pm.PackageSetting,boolean)\n @com.android.internal.annotations.VisibleForTesting com.android.server.pm.pkg.PackageUserStateImpl modifyUserState(int)\npublic com.android.server.pm.pkg.PackageUserStateImpl getOrCreateUserState(int)\npublic @android.annotation.NonNull com.android.server.pm.pkg.PackageUserStateInternal readUserState(int)\n void setEnabled(int,int,java.lang.String)\n int getEnabled(int)\n void setInstalled(boolean,int)\n boolean getInstalled(int)\n int getInstallReason(int)\n void setInstallReason(int,int)\n int getUninstallReason(int)\n void setUninstallReason(int,int)\n @android.annotation.NonNull android.content.pm.overlay.OverlayPaths getOverlayPaths(int)\n boolean setOverlayPathsForLibrary(java.lang.String,android.content.pm.overlay.OverlayPaths,int)\n boolean isAnyInstalled(int[])\n int[] queryInstalledUsers(int[],boolean)\n long getCeDataInode(int)\n void setCeDataInode(long,int)\n boolean getStopped(int)\n void setStopped(boolean,int)\n boolean getNotLaunched(int)\n void setNotLaunched(boolean,int)\n boolean getHidden(int)\n void setHidden(boolean,int)\n int getDistractionFlags(int)\n void setDistractionFlags(int,int)\npublic boolean getInstantApp(int)\n void setInstantApp(boolean,int)\n boolean getVirtualPreload(int)\n void setVirtualPreload(boolean,int)\n void setUserState(int,long,int,boolean,boolean,boolean,boolean,int,android.util.ArrayMap<java.lang.String,com.android.server.pm.pkg.SuspendParams>,boolean,boolean,java.lang.String,android.util.ArraySet<java.lang.String>,android.util.ArraySet<java.lang.String>,int,int,java.lang.String,java.lang.String,long)\n void setUserState(int,com.android.server.pm.pkg.PackageUserStateInternal)\n com.android.server.utils.WatchedArraySet<java.lang.String> getEnabledComponents(int)\n com.android.server.utils.WatchedArraySet<java.lang.String> getDisabledComponents(int)\n void setEnabledComponents(com.android.server.utils.WatchedArraySet<java.lang.String>,int)\n void setDisabledComponents(com.android.server.utils.WatchedArraySet<java.lang.String>,int)\n void setEnabledComponentsCopy(com.android.server.utils.WatchedArraySet<java.lang.String>,int)\n void setDisabledComponentsCopy(com.android.server.utils.WatchedArraySet<java.lang.String>,int)\n com.android.server.pm.pkg.PackageUserStateImpl modifyUserStateComponents(int,boolean,boolean)\n void addDisabledComponent(java.lang.String,int)\n void addEnabledComponent(java.lang.String,int)\n boolean enableComponentLPw(java.lang.String,int)\n boolean disableComponentLPw(java.lang.String,int)\n boolean restoreComponentLPw(java.lang.String,int)\n int getCurrentEnabledStateLPr(java.lang.String,int)\n void removeUser(int)\npublic int[] getNotInstalledUserIds()\n void writePackageUserPermissionsProto(android.util.proto.ProtoOutputStream,long,java.util.List<android.content.pm.UserInfo>,com.android.server.pm.permission.LegacyPermissionDataProvider)\nprotected void writeUsersInfoToProto(android.util.proto.ProtoOutputStream,long)\n com.android.server.pm.PackageSetting setPath(java.io.File)\npublic @com.android.internal.annotations.VisibleForTesting boolean overrideNonLocalizedLabelAndIcon(android.content.ComponentName,java.lang.String,java.lang.Integer,int)\npublic void resetOverrideComponentLabelIcon(int)\npublic @android.annotation.Nullable java.lang.String getSplashScreenTheme(int)\npublic boolean isIncremental()\npublic boolean isLoading()\npublic com.android.server.pm.PackageSetting setLoadingProgress(float)\npublic com.android.server.pm.PackageSetting setLoadingCompletedTime(long)\npublic com.android.server.pm.PackageSetting setAppMetadataFilePath(java.lang.String)\npublic @android.annotation.NonNull @java.lang.Override long getVersionCode()\npublic @android.annotation.Nullable @java.lang.Override java.util.Map<java.lang.String,java.util.Set<java.lang.String>> getMimeGroups()\npublic @android.annotation.NonNull @java.lang.Override java.lang.String getPackageName()\npublic @android.annotation.Nullable @java.lang.Override com.android.server.pm.pkg.AndroidPackage getAndroidPackage()\npublic @android.annotation.NonNull android.content.pm.SigningInfo getSigningInfo()\npublic @android.annotation.NonNull @java.lang.Override java.lang.String[] getUsesSdkLibraries()\npublic @android.annotation.NonNull @java.lang.Override long[] getUsesSdkLibrariesVersionsMajor()\npublic @android.annotation.NonNull @java.lang.Override java.lang.String[] getUsesStaticLibraries()\npublic @android.annotation.NonNull @java.lang.Override long[] getUsesStaticLibrariesVersions()\npublic @android.annotation.NonNull @java.lang.Override java.util.List<com.android.server.pm.pkg.SharedLibrary> getSharedLibraryDependencies()\npublic @android.annotation.NonNull com.android.server.pm.PackageSetting addUsesLibraryInfo(android.content.pm.SharedLibraryInfo)\npublic @android.annotation.NonNull @java.lang.Override java.util.List<java.lang.String> getUsesLibraryFiles()\npublic @android.annotation.NonNull com.android.server.pm.PackageSetting addUsesLibraryFile(java.lang.String)\npublic @java.lang.Override boolean isHiddenUntilInstalled()\npublic @android.annotation.NonNull @java.lang.Override long[] getLastPackageUsageTime()\npublic @java.lang.Override boolean isUpdatedSystemApp()\npublic @java.lang.Override boolean isApkInUpdatedApex()\npublic @android.annotation.Nullable @java.lang.Override java.lang.String getApexModuleName()\npublic com.android.server.pm.PackageSetting setDomainSetId(java.util.UUID)\npublic com.android.server.pm.PackageSetting setCategoryOverride(int)\npublic com.android.server.pm.PackageSetting setLegacyNativeLibraryPath(java.lang.String)\npublic com.android.server.pm.PackageSetting setMimeGroups(java.util.Map<java.lang.String,java.util.Set<java.lang.String>>)\npublic com.android.server.pm.PackageSetting setOldCodePaths(java.util.Set<java.lang.String>)\npublic com.android.server.pm.PackageSetting setUsesSdkLibraries(java.lang.String[])\npublic com.android.server.pm.PackageSetting setUsesSdkLibrariesVersionsMajor(long[])\npublic com.android.server.pm.PackageSetting setUsesStaticLibraries(java.lang.String[])\npublic com.android.server.pm.PackageSetting setUsesStaticLibrariesVersions(long[])\npublic com.android.server.pm.PackageSetting setApexModuleName(java.lang.String)\npublic @android.annotation.NonNull @java.lang.Override com.android.server.pm.pkg.PackageStateUnserialized getTransientState()\npublic @android.annotation.NonNull android.util.SparseArray<? extends PackageUserStateInternal> getUserStates()\npublic com.android.server.pm.PackageSetting addMimeTypes(java.lang.String,java.util.Set<java.lang.String>)\npublic @android.annotation.NonNull @java.lang.Override com.android.server.pm.pkg.PackageUserState getStateForUser(android.os.UserHandle)\npublic @android.annotation.Nullable java.lang.String getPrimaryCpuAbi()\npublic @android.annotation.Nullable java.lang.String getSecondaryCpuAbi()\npublic @android.annotation.Nullable @java.lang.Override java.lang.String getSeInfo()\npublic @android.annotation.Nullable java.lang.String getPrimaryCpuAbiLegacy()\npublic @android.annotation.Nullable java.lang.String getSecondaryCpuAbiLegacy()\npublic @android.content.pm.ApplicationInfo.HiddenApiEnforcementPolicy @java.lang.Override int getHiddenApiEnforcementPolicy()\npublic @java.lang.Override boolean isApex()\nclass PackageSetting extends com.android.server.pm.SettingBase implements [com.android.server.pm.pkg.PackageStateInternal]\n@com.android.internal.util.DataClass(genGetters=true, genConstructor=false, genSetters=false, genBuilder=false)") 1606 @Deprecated 1607 private void __metadata() {} 1608 1609 1610 //@formatter:on 1611 // End of generated code 1612 1613 } 1614