1 /* 2 * Copyright (C) 2020 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.pkg; 18 19 import android.annotation.NonNull; 20 import android.annotation.Nullable; 21 import android.content.ComponentName; 22 import android.content.pm.PackageManager; 23 import android.content.pm.overlay.OverlayPaths; 24 import android.text.TextUtils; 25 import android.util.ArrayMap; 26 import android.util.ArraySet; 27 import android.util.Pair; 28 29 import com.android.internal.annotations.VisibleForTesting; 30 import com.android.internal.util.ArrayUtils; 31 import com.android.internal.util.CollectionUtils; 32 import com.android.internal.util.DataClass; 33 import com.android.server.utils.Snappable; 34 import com.android.server.utils.SnapshotCache; 35 import com.android.server.utils.Watchable; 36 import com.android.server.utils.WatchableImpl; 37 import com.android.server.utils.WatchedArrayMap; 38 import com.android.server.utils.WatchedArraySet; 39 40 import java.util.Collections; 41 import java.util.Map; 42 import java.util.Objects; 43 44 @DataClass(genConstructor = false, genBuilder = false, genEqualsHashCode = true) 45 @DataClass.Suppress({"mOverlayPathsLock", "mOverlayPaths", "mSharedLibraryOverlayPathsLock", 46 "mSharedLibraryOverlayPaths", "setOverlayPaths", "setCachedOverlayPaths"}) 47 public class PackageUserStateImpl extends WatchableImpl implements PackageUserStateInternal, 48 Snappable { 49 50 @Nullable 51 protected WatchedArraySet<String> mDisabledComponentsWatched; 52 @Nullable 53 protected WatchedArraySet<String> mEnabledComponentsWatched; 54 55 private long mCeDataInode; 56 private boolean mInstalled = true; 57 private boolean mStopped; 58 private boolean mNotLaunched; 59 private boolean mHidden; // Is the app restricted by owner / admin 60 private int mDistractionFlags; 61 private boolean mInstantApp; 62 private boolean mVirtualPreload; 63 private int mEnabledState = PackageManager.COMPONENT_ENABLED_STATE_DEFAULT; 64 @PackageManager.InstallReason 65 private int mInstallReason = PackageManager.INSTALL_REASON_UNKNOWN; 66 @PackageManager.UninstallReason 67 private int mUninstallReason = PackageManager.UNINSTALL_REASON_UNKNOWN; 68 @Nullable 69 private String mHarmfulAppWarning; 70 @Nullable 71 private String mLastDisableAppCaller; 72 73 @Nullable 74 private OverlayPaths mOverlayPaths; 75 76 // Lib name to overlay paths 77 @Nullable 78 protected WatchedArrayMap<String, OverlayPaths> mSharedLibraryOverlayPaths; 79 80 @Nullable 81 private String mSplashScreenTheme; 82 83 /** 84 * Suspending package to suspend params 85 */ 86 @Nullable 87 private WatchedArrayMap<String, SuspendParams> mSuspendParams; 88 89 @Nullable 90 private WatchedArrayMap<ComponentName, Pair<String, Integer>> mComponentLabelIconOverrideMap; 91 92 private long mFirstInstallTime; 93 94 @Nullable 95 private final Watchable mWatchable; 96 97 @NonNull 98 final SnapshotCache<PackageUserStateImpl> mSnapshot; 99 makeCache()100 private SnapshotCache<PackageUserStateImpl> makeCache() { 101 return new SnapshotCache<PackageUserStateImpl>(this, this) { 102 @Override 103 public PackageUserStateImpl createSnapshot() { 104 return new PackageUserStateImpl(mWatchable, mSource); 105 }}; 106 } 107 108 /** 109 * Only used for tests 110 */ 111 public PackageUserStateImpl() { 112 super(); 113 mWatchable = null; 114 mSnapshot = makeCache(); 115 } 116 117 public PackageUserStateImpl(@NonNull Watchable watchable) { 118 mWatchable = watchable; 119 mSnapshot = makeCache(); 120 } 121 122 public PackageUserStateImpl(@NonNull Watchable watchable, PackageUserStateImpl other) { 123 mWatchable = watchable; 124 mDisabledComponentsWatched = other.mDisabledComponentsWatched == null 125 ? null : other.mDisabledComponentsWatched.snapshot(); 126 mEnabledComponentsWatched = other.mEnabledComponentsWatched == null 127 ? null : other.mEnabledComponentsWatched.snapshot(); 128 mOverlayPaths = other.mOverlayPaths; 129 mSharedLibraryOverlayPaths = other.mSharedLibraryOverlayPaths == null 130 ? null : other.mSharedLibraryOverlayPaths.snapshot(); 131 mCeDataInode = other.mCeDataInode; 132 mInstalled = other.mInstalled; 133 mStopped = other.mStopped; 134 mNotLaunched = other.mNotLaunched; 135 mHidden = other.mHidden; 136 mDistractionFlags = other.mDistractionFlags; 137 mInstantApp = other.mInstantApp; 138 mVirtualPreload = other.mVirtualPreload; 139 mEnabledState = other.mEnabledState; 140 mInstallReason = other.mInstallReason; 141 mUninstallReason = other.mUninstallReason; 142 mHarmfulAppWarning = other.mHarmfulAppWarning; 143 mLastDisableAppCaller = other.mLastDisableAppCaller; 144 mSplashScreenTheme = other.mSplashScreenTheme; 145 mSuspendParams = other.mSuspendParams == null ? null : other.mSuspendParams.snapshot(); 146 mComponentLabelIconOverrideMap = other.mComponentLabelIconOverrideMap == null 147 ? null : other.mComponentLabelIconOverrideMap.snapshot(); 148 mFirstInstallTime = other.mFirstInstallTime; 149 mSnapshot = new SnapshotCache.Sealed<>(); 150 } 151 152 private void onChanged() { 153 if (mWatchable != null) { 154 mWatchable.dispatchChange(mWatchable); 155 } 156 dispatchChange(this); 157 } 158 159 @NonNull 160 @Override 161 public PackageUserStateImpl snapshot() { 162 return mSnapshot.snapshot(); 163 } 164 165 /** 166 * Sets the path of overlays currently enabled for this package and user combination. 167 * 168 * @return true if the path contents differ than what they were previously 169 */ 170 @Nullable 171 public boolean setOverlayPaths(@Nullable OverlayPaths paths) { 172 if (Objects.equals(paths, mOverlayPaths)) { 173 return false; 174 } 175 if ((mOverlayPaths == null && paths.isEmpty()) 176 || (paths == null && mOverlayPaths.isEmpty())) { 177 return false; 178 } 179 mOverlayPaths = paths; 180 onChanged(); 181 return true; 182 } 183 184 /** 185 * Sets the path of overlays currently enabled for a library that this package uses. 186 * 187 * @return true if the path contents for the library differ than what they were previously 188 */ 189 public boolean setSharedLibraryOverlayPaths(@NonNull String library, 190 @Nullable OverlayPaths paths) { 191 if (mSharedLibraryOverlayPaths == null) { 192 mSharedLibraryOverlayPaths = new WatchedArrayMap<>(); 193 mSharedLibraryOverlayPaths.registerObserver(mSnapshot); 194 } 195 final OverlayPaths currentPaths = mSharedLibraryOverlayPaths.get(library); 196 if (Objects.equals(paths, currentPaths)) { 197 return false; 198 } 199 if (paths == null || paths.isEmpty()) { 200 boolean returnValue = mSharedLibraryOverlayPaths.remove(library) != null; 201 onChanged(); 202 return returnValue; 203 } else { 204 mSharedLibraryOverlayPaths.put(library, paths); 205 onChanged(); 206 return true; 207 } 208 } 209 210 @Nullable 211 @Override 212 public WatchedArraySet<String> getDisabledComponentsNoCopy() { 213 return mDisabledComponentsWatched; 214 } 215 216 @Nullable 217 @Override 218 public WatchedArraySet<String> getEnabledComponentsNoCopy() { 219 return mEnabledComponentsWatched; 220 } 221 222 @NonNull 223 @Override 224 public ArraySet<String> getDisabledComponents() { 225 return mDisabledComponentsWatched == null 226 ? new ArraySet<>() : mDisabledComponentsWatched.untrackedStorage(); 227 } 228 229 @NonNull 230 @Override 231 public ArraySet<String> getEnabledComponents() { 232 return mEnabledComponentsWatched == null 233 ? new ArraySet<>() : mEnabledComponentsWatched.untrackedStorage(); 234 } 235 236 237 @Override 238 public boolean isComponentEnabled(String componentName) { 239 return mEnabledComponentsWatched != null 240 && mEnabledComponentsWatched.contains(componentName); 241 } 242 243 @Override 244 public boolean isComponentDisabled(String componentName) { 245 return mDisabledComponentsWatched != null 246 && mDisabledComponentsWatched.contains(componentName); 247 } 248 249 @Override 250 public OverlayPaths getAllOverlayPaths() { 251 if (mOverlayPaths == null && mSharedLibraryOverlayPaths == null) { 252 return null; 253 } 254 final OverlayPaths.Builder newPaths = new OverlayPaths.Builder(); 255 newPaths.addAll(mOverlayPaths); 256 if (mSharedLibraryOverlayPaths != null) { 257 for (final OverlayPaths libOverlayPaths : mSharedLibraryOverlayPaths.values()) { 258 newPaths.addAll(libOverlayPaths); 259 } 260 } 261 return newPaths.build(); 262 } 263 264 /** 265 * Overrides the non-localized label and icon of a component. 266 * 267 * @return true if the label or icon was changed. 268 */ 269 @VisibleForTesting(visibility = VisibleForTesting.Visibility.PACKAGE) 270 public boolean overrideLabelAndIcon(@NonNull ComponentName component, 271 @Nullable String nonLocalizedLabel, @Nullable Integer icon) { 272 String existingLabel = null; 273 Integer existingIcon = null; 274 275 if (mComponentLabelIconOverrideMap != null) { 276 Pair<String, Integer> pair = mComponentLabelIconOverrideMap.get(component); 277 if (pair != null) { 278 existingLabel = pair.first; 279 existingIcon = pair.second; 280 } 281 } 282 283 boolean changed = !TextUtils.equals(existingLabel, nonLocalizedLabel) 284 || !Objects.equals(existingIcon, icon); 285 286 if (changed) { 287 if (nonLocalizedLabel == null && icon == null) { 288 mComponentLabelIconOverrideMap.remove(component); 289 if (mComponentLabelIconOverrideMap.isEmpty()) { 290 mComponentLabelIconOverrideMap = null; 291 } 292 } else { 293 if (mComponentLabelIconOverrideMap == null) { 294 mComponentLabelIconOverrideMap = new WatchedArrayMap<>(1); 295 mComponentLabelIconOverrideMap.registerObserver(mSnapshot); 296 } 297 298 mComponentLabelIconOverrideMap.put(component, Pair.create(nonLocalizedLabel, icon)); 299 } 300 onChanged(); 301 } 302 303 return changed; 304 } 305 306 /** 307 * Clears all values previously set by {@link #overrideLabelAndIcon(ComponentName, String, 308 * Integer)}. 309 * <p> 310 * This is done when the package is updated as the components and resource IDs may have 311 * changed. 312 */ 313 public void resetOverrideComponentLabelIcon() { 314 mComponentLabelIconOverrideMap = null; 315 } 316 317 @Nullable 318 public Pair<String, Integer> getOverrideLabelIconForComponent(ComponentName componentName) { 319 if (ArrayUtils.isEmpty(mComponentLabelIconOverrideMap)) { 320 return null; 321 } 322 323 return mComponentLabelIconOverrideMap.get(componentName); 324 } 325 326 @Override 327 public boolean isSuspended() { 328 return !CollectionUtils.isEmpty(mSuspendParams); 329 } 330 331 public PackageUserStateImpl putSuspendParams(@NonNull String suspendingPackage, 332 @Nullable SuspendParams suspendParams) { 333 if (mSuspendParams == null) { 334 mSuspendParams = new WatchedArrayMap<>(); 335 mSuspendParams.registerObserver(mSnapshot); 336 } 337 if (!mSuspendParams.containsKey(suspendingPackage) 338 || !Objects.equals(mSuspendParams.get(suspendingPackage), suspendParams)) { 339 mSuspendParams.put(suspendingPackage, suspendParams); 340 onChanged(); 341 } 342 343 return this; 344 } 345 346 public PackageUserStateImpl removeSuspension(@NonNull String suspendingPackage) { 347 if (mSuspendParams != null) { 348 mSuspendParams.remove(suspendingPackage); 349 onChanged(); 350 } 351 return this; 352 } 353 354 public @NonNull PackageUserStateImpl setDisabledComponents(@Nullable ArraySet<String> value) { 355 if (value == null) { 356 return this; 357 } 358 if (mDisabledComponentsWatched == null) { 359 mDisabledComponentsWatched = new WatchedArraySet<>(); 360 mDisabledComponentsWatched.registerObserver(mSnapshot); 361 } 362 mDisabledComponentsWatched.clear(); 363 mDisabledComponentsWatched.addAll(value); 364 onChanged(); 365 return this; 366 } 367 368 public @NonNull PackageUserStateImpl setEnabledComponents(@Nullable ArraySet<String> value) { 369 if (value == null) { 370 return this; 371 } 372 if (mEnabledComponentsWatched == null) { 373 mEnabledComponentsWatched = new WatchedArraySet<>(); 374 mEnabledComponentsWatched.registerObserver(mSnapshot); 375 } 376 mEnabledComponentsWatched.clear(); 377 mEnabledComponentsWatched.addAll(value); 378 onChanged(); 379 return this; 380 } 381 382 public @NonNull PackageUserStateImpl setEnabledComponents( 383 @Nullable WatchedArraySet<String> value) { 384 mEnabledComponentsWatched = value; 385 if (mEnabledComponentsWatched != null) { 386 mEnabledComponentsWatched.registerObserver(mSnapshot); 387 } 388 onChanged(); 389 return this; 390 } 391 392 public @NonNull PackageUserStateImpl setDisabledComponents( 393 @Nullable WatchedArraySet<String> value) { 394 mDisabledComponentsWatched = value; 395 if (mDisabledComponentsWatched != null) { 396 mDisabledComponentsWatched.registerObserver(mSnapshot); 397 } 398 onChanged(); 399 return this; 400 } 401 402 public @NonNull PackageUserStateImpl setCeDataInode(long value) { 403 mCeDataInode = value; 404 onChanged(); 405 return this; 406 } 407 408 public @NonNull PackageUserStateImpl setInstalled(boolean value) { 409 mInstalled = value; 410 onChanged(); 411 return this; 412 } 413 414 public @NonNull PackageUserStateImpl setStopped(boolean value) { 415 mStopped = value; 416 onChanged(); 417 return this; 418 } 419 420 public @NonNull PackageUserStateImpl setNotLaunched(boolean value) { 421 mNotLaunched = value; 422 onChanged(); 423 return this; 424 } 425 426 public @NonNull PackageUserStateImpl setHidden(boolean value) { 427 mHidden = value; 428 onChanged(); 429 return this; 430 } 431 432 public @NonNull PackageUserStateImpl setDistractionFlags(int value) { 433 mDistractionFlags = value; 434 onChanged(); 435 return this; 436 } 437 438 public @NonNull PackageUserStateImpl setInstantApp(boolean value) { 439 mInstantApp = value; 440 onChanged(); 441 return this; 442 } 443 444 public @NonNull PackageUserStateImpl setVirtualPreload(boolean value) { 445 mVirtualPreload = value; 446 onChanged(); 447 return this; 448 } 449 450 public @NonNull PackageUserStateImpl setEnabledState(int value) { 451 mEnabledState = value; 452 onChanged(); 453 return this; 454 } 455 456 public @NonNull PackageUserStateImpl setInstallReason(@PackageManager.InstallReason int value) { 457 mInstallReason = value; 458 com.android.internal.util.AnnotationValidations.validate( 459 PackageManager.InstallReason.class, null, mInstallReason); 460 onChanged(); 461 return this; 462 } 463 464 public @NonNull PackageUserStateImpl setUninstallReason( 465 @PackageManager.UninstallReason int value) { 466 mUninstallReason = value; 467 com.android.internal.util.AnnotationValidations.validate( 468 PackageManager.UninstallReason.class, null, mUninstallReason); 469 onChanged(); 470 return this; 471 } 472 473 public @NonNull PackageUserStateImpl setHarmfulAppWarning(@NonNull String value) { 474 mHarmfulAppWarning = value; 475 onChanged(); 476 return this; 477 } 478 479 public @NonNull PackageUserStateImpl setLastDisableAppCaller(@NonNull String value) { 480 mLastDisableAppCaller = value; 481 onChanged(); 482 return this; 483 } 484 485 public @NonNull PackageUserStateImpl setSharedLibraryOverlayPaths( 486 @NonNull ArrayMap<String, OverlayPaths> value) { 487 if (value == null) { 488 return this; 489 } 490 if (mSharedLibraryOverlayPaths == null) { 491 mSharedLibraryOverlayPaths = new WatchedArrayMap<>(); 492 registerObserver(mSnapshot); 493 } 494 mSharedLibraryOverlayPaths.clear(); 495 mSharedLibraryOverlayPaths.putAll(value); 496 onChanged(); 497 return this; 498 } 499 500 public @NonNull PackageUserStateImpl setSplashScreenTheme(@NonNull String value) { 501 mSplashScreenTheme = value; 502 onChanged(); 503 return this; 504 } 505 506 /** 507 * Suspending package to suspend params 508 */ 509 public @NonNull PackageUserStateImpl setSuspendParams( 510 @NonNull ArrayMap<String, SuspendParams> value) { 511 if (value == null) { 512 return this; 513 } 514 if (mSuspendParams == null) { 515 mSuspendParams = new WatchedArrayMap<>(); 516 registerObserver(mSnapshot); 517 } 518 mSuspendParams.clear(); 519 mSuspendParams.putAll(value); 520 onChanged(); 521 return this; 522 } 523 524 public @NonNull PackageUserStateImpl setComponentLabelIconOverrideMap( 525 @NonNull ArrayMap<ComponentName, Pair<String, Integer>> value) { 526 if (value == null) { 527 return this; 528 } 529 if (mComponentLabelIconOverrideMap == null) { 530 mComponentLabelIconOverrideMap = new WatchedArrayMap<>(); 531 registerObserver(mSnapshot); 532 } 533 mComponentLabelIconOverrideMap.clear(); 534 mComponentLabelIconOverrideMap.putAll(value); 535 onChanged(); 536 return this; 537 } 538 539 public @NonNull PackageUserStateImpl setFirstInstallTime(long value) { 540 mFirstInstallTime = value; 541 onChanged(); 542 return this; 543 } 544 545 @NonNull 546 @Override 547 public Map<String, OverlayPaths> getSharedLibraryOverlayPaths() { 548 return mSharedLibraryOverlayPaths == null 549 ? Collections.emptyMap() : mSharedLibraryOverlayPaths; 550 } 551 552 @Override 553 public boolean equals(@Nullable Object o) { 554 // You can override field equality logic by defining either of the methods like: 555 // boolean fieldNameEquals(PackageUserStateImpl other) { ... } 556 // boolean fieldNameEquals(FieldType otherValue) { ... } 557 558 if (this == o) return true; 559 if (o == null || getClass() != o.getClass()) return false; 560 @SuppressWarnings("unchecked") 561 PackageUserStateImpl that = (PackageUserStateImpl) o; 562 //noinspection PointlessBooleanExpression 563 return Objects.equals(mDisabledComponentsWatched, that.mDisabledComponentsWatched) 564 && Objects.equals(mEnabledComponentsWatched, that.mEnabledComponentsWatched) 565 && mCeDataInode == that.mCeDataInode 566 && mInstalled == that.mInstalled 567 && mStopped == that.mStopped 568 && mNotLaunched == that.mNotLaunched 569 && mHidden == that.mHidden 570 && mDistractionFlags == that.mDistractionFlags 571 && mInstantApp == that.mInstantApp 572 && mVirtualPreload == that.mVirtualPreload 573 && mEnabledState == that.mEnabledState 574 && mInstallReason == that.mInstallReason 575 && mUninstallReason == that.mUninstallReason 576 && Objects.equals(mHarmfulAppWarning, that.mHarmfulAppWarning) 577 && Objects.equals(mLastDisableAppCaller, that.mLastDisableAppCaller) 578 && Objects.equals(mOverlayPaths, that.mOverlayPaths) 579 && Objects.equals(mSharedLibraryOverlayPaths, that.mSharedLibraryOverlayPaths) 580 && Objects.equals(mSplashScreenTheme, that.mSplashScreenTheme) 581 && Objects.equals(mSuspendParams, that.mSuspendParams) 582 && Objects.equals(mComponentLabelIconOverrideMap, 583 that.mComponentLabelIconOverrideMap) 584 && mFirstInstallTime == that.mFirstInstallTime 585 && Objects.equals(mWatchable, that.mWatchable); 586 } 587 588 @Override 589 public int hashCode() { 590 // You can override field hashCode logic by defining methods like: 591 // int fieldNameHashCode() { ... } 592 593 int _hash = 1; 594 _hash = 31 * _hash + Objects.hashCode(mDisabledComponentsWatched); 595 _hash = 31 * _hash + Objects.hashCode(mEnabledComponentsWatched); 596 _hash = 31 * _hash + Long.hashCode(mCeDataInode); 597 _hash = 31 * _hash + Boolean.hashCode(mInstalled); 598 _hash = 31 * _hash + Boolean.hashCode(mStopped); 599 _hash = 31 * _hash + Boolean.hashCode(mNotLaunched); 600 _hash = 31 * _hash + Boolean.hashCode(mHidden); 601 _hash = 31 * _hash + mDistractionFlags; 602 _hash = 31 * _hash + Boolean.hashCode(mInstantApp); 603 _hash = 31 * _hash + Boolean.hashCode(mVirtualPreload); 604 _hash = 31 * _hash + mEnabledState; 605 _hash = 31 * _hash + mInstallReason; 606 _hash = 31 * _hash + mUninstallReason; 607 _hash = 31 * _hash + Objects.hashCode(mHarmfulAppWarning); 608 _hash = 31 * _hash + Objects.hashCode(mLastDisableAppCaller); 609 _hash = 31 * _hash + Objects.hashCode(mOverlayPaths); 610 _hash = 31 * _hash + Objects.hashCode(mSharedLibraryOverlayPaths); 611 _hash = 31 * _hash + Objects.hashCode(mSplashScreenTheme); 612 _hash = 31 * _hash + Objects.hashCode(mSuspendParams); 613 _hash = 31 * _hash + Objects.hashCode(mComponentLabelIconOverrideMap); 614 _hash = 31 * _hash + Long.hashCode(mFirstInstallTime); 615 _hash = 31 * _hash + Objects.hashCode(mWatchable); 616 return _hash; 617 } 618 619 620 621 // Code below generated by codegen v1.0.23. 622 // 623 // DO NOT MODIFY! 624 // CHECKSTYLE:OFF Generated code 625 // 626 // To regenerate run: 627 // $ codegen $ANDROID_BUILD_TOP/frameworks/base/services/core/java/com/android/server/pm/pkg/PackageUserStateImpl.java 628 // 629 // To exclude the generated code from IntelliJ auto-formatting enable (one-time): 630 // Settings > Editor > Code Style > Formatter Control 631 //@formatter:off 632 633 634 @DataClass.Generated.Member 635 public @Nullable WatchedArraySet<String> getDisabledComponentsWatched() { 636 return mDisabledComponentsWatched; 637 } 638 639 @DataClass.Generated.Member 640 public @Nullable WatchedArraySet<String> getEnabledComponentsWatched() { 641 return mEnabledComponentsWatched; 642 } 643 644 @DataClass.Generated.Member 645 public long getCeDataInode() { 646 return mCeDataInode; 647 } 648 649 @DataClass.Generated.Member 650 public boolean isInstalled() { 651 return mInstalled; 652 } 653 654 @DataClass.Generated.Member 655 public boolean isStopped() { 656 return mStopped; 657 } 658 659 @DataClass.Generated.Member 660 public boolean isNotLaunched() { 661 return mNotLaunched; 662 } 663 664 @DataClass.Generated.Member 665 public boolean isHidden() { 666 return mHidden; 667 } 668 669 @DataClass.Generated.Member 670 public int getDistractionFlags() { 671 return mDistractionFlags; 672 } 673 674 @DataClass.Generated.Member 675 public boolean isInstantApp() { 676 return mInstantApp; 677 } 678 679 @DataClass.Generated.Member 680 public boolean isVirtualPreload() { 681 return mVirtualPreload; 682 } 683 684 @DataClass.Generated.Member 685 public int getEnabledState() { 686 return mEnabledState; 687 } 688 689 @DataClass.Generated.Member 690 public @PackageManager.InstallReason int getInstallReason() { 691 return mInstallReason; 692 } 693 694 @DataClass.Generated.Member 695 public @PackageManager.UninstallReason int getUninstallReason() { 696 return mUninstallReason; 697 } 698 699 @DataClass.Generated.Member 700 public @Nullable String getHarmfulAppWarning() { 701 return mHarmfulAppWarning; 702 } 703 704 @DataClass.Generated.Member 705 public @Nullable String getLastDisableAppCaller() { 706 return mLastDisableAppCaller; 707 } 708 709 @DataClass.Generated.Member 710 public @Nullable OverlayPaths getOverlayPaths() { 711 return mOverlayPaths; 712 } 713 714 @DataClass.Generated.Member 715 public @Nullable String getSplashScreenTheme() { 716 return mSplashScreenTheme; 717 } 718 719 /** 720 * Suspending package to suspend params 721 */ 722 @DataClass.Generated.Member 723 public @Nullable WatchedArrayMap<String,SuspendParams> getSuspendParams() { 724 return mSuspendParams; 725 } 726 727 @DataClass.Generated.Member 728 public @Nullable WatchedArrayMap<ComponentName,Pair<String,Integer>> getComponentLabelIconOverrideMap() { 729 return mComponentLabelIconOverrideMap; 730 } 731 732 @DataClass.Generated.Member 733 public long getFirstInstallTime() { 734 return mFirstInstallTime; 735 } 736 737 @DataClass.Generated.Member 738 public @Nullable Watchable getWatchable() { 739 return mWatchable; 740 } 741 742 @DataClass.Generated.Member 743 public @NonNull SnapshotCache<PackageUserStateImpl> getSnapshot() { 744 return mSnapshot; 745 } 746 747 @DataClass.Generated.Member 748 public @NonNull PackageUserStateImpl setDisabledComponentsWatched(@NonNull WatchedArraySet<String> value) { 749 mDisabledComponentsWatched = value; 750 return this; 751 } 752 753 @DataClass.Generated.Member 754 public @NonNull PackageUserStateImpl setEnabledComponentsWatched(@NonNull WatchedArraySet<String> value) { 755 mEnabledComponentsWatched = value; 756 return this; 757 } 758 759 @DataClass.Generated.Member 760 public @NonNull PackageUserStateImpl setSharedLibraryOverlayPaths(@NonNull WatchedArrayMap<String,OverlayPaths> value) { 761 mSharedLibraryOverlayPaths = value; 762 return this; 763 } 764 765 /** 766 * Suspending package to suspend params 767 */ 768 @DataClass.Generated.Member 769 public @NonNull PackageUserStateImpl setSuspendParams(@NonNull WatchedArrayMap<String,SuspendParams> value) { 770 mSuspendParams = value; 771 return this; 772 } 773 774 @DataClass.Generated.Member 775 public @NonNull PackageUserStateImpl setComponentLabelIconOverrideMap(@NonNull WatchedArrayMap<ComponentName,Pair<String,Integer>> value) { 776 mComponentLabelIconOverrideMap = value; 777 return this; 778 } 779 780 @DataClass.Generated( 781 time = 1645040852569L, 782 codegenVersion = "1.0.23", 783 sourceFile = "frameworks/base/services/core/java/com/android/server/pm/pkg/PackageUserStateImpl.java", 784 inputSignatures = "protected @android.annotation.Nullable com.android.server.utils.WatchedArraySet<java.lang.String> mDisabledComponentsWatched\nprotected @android.annotation.Nullable com.android.server.utils.WatchedArraySet<java.lang.String> mEnabledComponentsWatched\nprivate long mCeDataInode\nprivate boolean mInstalled\nprivate boolean mStopped\nprivate boolean mNotLaunched\nprivate boolean mHidden\nprivate int mDistractionFlags\nprivate boolean mInstantApp\nprivate boolean mVirtualPreload\nprivate int mEnabledState\nprivate @android.content.pm.PackageManager.InstallReason int mInstallReason\nprivate @android.content.pm.PackageManager.UninstallReason int mUninstallReason\nprivate @android.annotation.Nullable java.lang.String mHarmfulAppWarning\nprivate @android.annotation.Nullable java.lang.String mLastDisableAppCaller\nprivate @android.annotation.Nullable android.content.pm.overlay.OverlayPaths mOverlayPaths\nprotected @android.annotation.Nullable com.android.server.utils.WatchedArrayMap<java.lang.String,android.content.pm.overlay.OverlayPaths> mSharedLibraryOverlayPaths\nprivate @android.annotation.Nullable java.lang.String mSplashScreenTheme\nprivate @android.annotation.Nullable com.android.server.utils.WatchedArrayMap<java.lang.String,com.android.server.pm.pkg.SuspendParams> mSuspendParams\nprivate @android.annotation.Nullable com.android.server.utils.WatchedArrayMap<android.content.ComponentName,android.util.Pair<java.lang.String,java.lang.Integer>> mComponentLabelIconOverrideMap\nprivate long mFirstInstallTime\nprivate final @android.annotation.Nullable com.android.server.utils.Watchable mWatchable\nfinal @android.annotation.NonNull com.android.server.utils.SnapshotCache<com.android.server.pm.pkg.PackageUserStateImpl> mSnapshot\nprivate com.android.server.utils.SnapshotCache<com.android.server.pm.pkg.PackageUserStateImpl> makeCache()\nprivate void onChanged()\npublic @android.annotation.NonNull @java.lang.Override com.android.server.pm.pkg.PackageUserStateImpl snapshot()\npublic @android.annotation.Nullable boolean setOverlayPaths(android.content.pm.overlay.OverlayPaths)\npublic boolean setSharedLibraryOverlayPaths(java.lang.String,android.content.pm.overlay.OverlayPaths)\npublic @android.annotation.Nullable @java.lang.Override com.android.server.utils.WatchedArraySet<java.lang.String> getDisabledComponentsNoCopy()\npublic @android.annotation.Nullable @java.lang.Override com.android.server.utils.WatchedArraySet<java.lang.String> getEnabledComponentsNoCopy()\npublic @android.annotation.NonNull @java.lang.Override android.util.ArraySet<java.lang.String> getDisabledComponents()\npublic @android.annotation.NonNull @java.lang.Override android.util.ArraySet<java.lang.String> getEnabledComponents()\npublic @java.lang.Override boolean isComponentEnabled(java.lang.String)\npublic @java.lang.Override boolean isComponentDisabled(java.lang.String)\npublic @java.lang.Override android.content.pm.overlay.OverlayPaths getAllOverlayPaths()\npublic @com.android.internal.annotations.VisibleForTesting boolean overrideLabelAndIcon(android.content.ComponentName,java.lang.String,java.lang.Integer)\npublic void resetOverrideComponentLabelIcon()\npublic @android.annotation.Nullable android.util.Pair<java.lang.String,java.lang.Integer> getOverrideLabelIconForComponent(android.content.ComponentName)\npublic @java.lang.Override boolean isSuspended()\npublic com.android.server.pm.pkg.PackageUserStateImpl putSuspendParams(java.lang.String,com.android.server.pm.pkg.SuspendParams)\npublic com.android.server.pm.pkg.PackageUserStateImpl removeSuspension(java.lang.String)\npublic @android.annotation.NonNull com.android.server.pm.pkg.PackageUserStateImpl setDisabledComponents(android.util.ArraySet<java.lang.String>)\npublic @android.annotation.NonNull com.android.server.pm.pkg.PackageUserStateImpl setEnabledComponents(android.util.ArraySet<java.lang.String>)\npublic @android.annotation.NonNull com.android.server.pm.pkg.PackageUserStateImpl setEnabledComponents(com.android.server.utils.WatchedArraySet<java.lang.String>)\npublic @android.annotation.NonNull com.android.server.pm.pkg.PackageUserStateImpl setDisabledComponents(com.android.server.utils.WatchedArraySet<java.lang.String>)\npublic @android.annotation.NonNull com.android.server.pm.pkg.PackageUserStateImpl setCeDataInode(long)\npublic @android.annotation.NonNull com.android.server.pm.pkg.PackageUserStateImpl setInstalled(boolean)\npublic @android.annotation.NonNull com.android.server.pm.pkg.PackageUserStateImpl setStopped(boolean)\npublic @android.annotation.NonNull com.android.server.pm.pkg.PackageUserStateImpl setNotLaunched(boolean)\npublic @android.annotation.NonNull com.android.server.pm.pkg.PackageUserStateImpl setHidden(boolean)\npublic @android.annotation.NonNull com.android.server.pm.pkg.PackageUserStateImpl setDistractionFlags(int)\npublic @android.annotation.NonNull com.android.server.pm.pkg.PackageUserStateImpl setInstantApp(boolean)\npublic @android.annotation.NonNull com.android.server.pm.pkg.PackageUserStateImpl setVirtualPreload(boolean)\npublic @android.annotation.NonNull com.android.server.pm.pkg.PackageUserStateImpl setEnabledState(int)\npublic @android.annotation.NonNull com.android.server.pm.pkg.PackageUserStateImpl setInstallReason(int)\npublic @android.annotation.NonNull com.android.server.pm.pkg.PackageUserStateImpl setUninstallReason(int)\npublic @android.annotation.NonNull com.android.server.pm.pkg.PackageUserStateImpl setHarmfulAppWarning(java.lang.String)\npublic @android.annotation.NonNull com.android.server.pm.pkg.PackageUserStateImpl setLastDisableAppCaller(java.lang.String)\npublic @android.annotation.NonNull com.android.server.pm.pkg.PackageUserStateImpl setSharedLibraryOverlayPaths(android.util.ArrayMap<java.lang.String,android.content.pm.overlay.OverlayPaths>)\npublic @android.annotation.NonNull com.android.server.pm.pkg.PackageUserStateImpl setSplashScreenTheme(java.lang.String)\npublic @android.annotation.NonNull com.android.server.pm.pkg.PackageUserStateImpl setSuspendParams(android.util.ArrayMap<java.lang.String,com.android.server.pm.pkg.SuspendParams>)\npublic @android.annotation.NonNull com.android.server.pm.pkg.PackageUserStateImpl setComponentLabelIconOverrideMap(android.util.ArrayMap<android.content.ComponentName,android.util.Pair<java.lang.String,java.lang.Integer>>)\npublic @android.annotation.NonNull com.android.server.pm.pkg.PackageUserStateImpl setFirstInstallTime(long)\npublic @android.annotation.NonNull @java.lang.Override java.util.Map<java.lang.String,android.content.pm.overlay.OverlayPaths> getSharedLibraryOverlayPaths()\npublic @java.lang.Override boolean equals(java.lang.Object)\npublic @java.lang.Override int hashCode()\nclass PackageUserStateImpl extends com.android.server.utils.WatchableImpl implements [com.android.server.pm.pkg.PackageUserStateInternal, com.android.server.utils.Snappable]\n@com.android.internal.util.DataClass(genConstructor=false, genBuilder=false, genEqualsHashCode=true)") 785 @Deprecated 786 private void __metadata() {} 787 788 789 //@formatter:on 790 // End of generated code 791 792 } 793