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