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.parsing; 18 19 import static java.util.Collections.emptyList; 20 import static java.util.Collections.emptyMap; 21 import static java.util.Collections.emptySet; 22 23 import android.annotation.CallSuper; 24 import android.annotation.LongDef; 25 import android.annotation.NonNull; 26 import android.annotation.Nullable; 27 import android.annotation.SuppressLint; 28 import android.content.Intent; 29 import android.content.IntentFilter; 30 import android.content.pm.ApplicationInfo; 31 import android.content.pm.ConfigurationInfo; 32 import android.content.pm.FeatureGroupInfo; 33 import android.content.pm.FeatureInfo; 34 import android.content.pm.PackageInfo; 35 import android.content.pm.PackageManager.Property; 36 import android.content.pm.SigningDetails; 37 import android.content.res.TypedArray; 38 import android.os.Build; 39 import android.os.Bundle; 40 import android.os.Parcel; 41 import android.os.Parcelable; 42 import android.os.storage.StorageManager; 43 import android.text.TextUtils; 44 import android.util.ArrayMap; 45 import android.util.ArraySet; 46 import android.util.Pair; 47 import android.util.SparseArray; 48 import android.util.SparseIntArray; 49 50 import com.android.internal.R; 51 import com.android.internal.annotations.VisibleForTesting; 52 import com.android.internal.util.ArrayUtils; 53 import com.android.internal.util.CollectionUtils; 54 import com.android.internal.util.DataClass; 55 import com.android.internal.util.Parcelling; 56 import com.android.internal.util.Parcelling.BuiltIn.ForBoolean; 57 import com.android.internal.util.Parcelling.BuiltIn.ForInternedString; 58 import com.android.internal.util.Parcelling.BuiltIn.ForInternedStringArray; 59 import com.android.internal.util.Parcelling.BuiltIn.ForInternedStringList; 60 import com.android.internal.util.Parcelling.BuiltIn.ForInternedStringSet; 61 import com.android.internal.util.Parcelling.BuiltIn.ForInternedStringValueMap; 62 import com.android.internal.util.Parcelling.BuiltIn.ForStringSet; 63 import com.android.server.pm.pkg.component.ParsedActivity; 64 import com.android.server.pm.pkg.component.ParsedActivityImpl; 65 import com.android.server.pm.pkg.component.ParsedApexSystemService; 66 import com.android.server.pm.pkg.component.ParsedApexSystemServiceImpl; 67 import com.android.server.pm.pkg.component.ParsedAttribution; 68 import com.android.server.pm.pkg.component.ParsedAttributionImpl; 69 import com.android.server.pm.pkg.component.ParsedComponent; 70 import com.android.server.pm.pkg.component.ParsedInstrumentation; 71 import com.android.server.pm.pkg.component.ParsedInstrumentationImpl; 72 import com.android.server.pm.pkg.component.ParsedIntentInfo; 73 import com.android.server.pm.pkg.component.ParsedMainComponent; 74 import com.android.server.pm.pkg.component.ParsedPermission; 75 import com.android.server.pm.pkg.component.ParsedPermissionGroup; 76 import com.android.server.pm.pkg.component.ParsedPermissionGroupImpl; 77 import com.android.server.pm.pkg.component.ParsedPermissionImpl; 78 import com.android.server.pm.pkg.component.ParsedProcess; 79 import com.android.server.pm.pkg.component.ParsedProvider; 80 import com.android.server.pm.pkg.component.ParsedProviderImpl; 81 import com.android.server.pm.pkg.component.ParsedService; 82 import com.android.server.pm.pkg.component.ParsedServiceImpl; 83 import com.android.server.pm.pkg.component.ParsedUsesPermission; 84 import com.android.server.pm.pkg.component.ParsedUsesPermissionImpl; 85 86 import libcore.util.EmptyArray; 87 88 import java.security.PublicKey; 89 import java.util.Collections; 90 import java.util.Comparator; 91 import java.util.List; 92 import java.util.Map; 93 import java.util.Set; 94 import java.util.UUID; 95 96 /** 97 * The backing data for a package that was parsed from disk. 98 * 99 * The field nullability annotations here are for internal reference. For effective nullability, 100 * see the parent interfaces. 101 * 102 * TODO(b/135203078): Convert Lists used as sets into Sets, to better express intended use case 103 * 104 * @hide 105 */ 106 public class ParsingPackageImpl implements ParsingPackage, ParsingPackageHidden, Parcelable { 107 108 private static final SparseArray<int[]> EMPTY_INT_ARRAY_SPARSE_ARRAY = new SparseArray<>(); 109 public static ForBoolean sForBoolean = Parcelling.Cache.getOrCreate(ForBoolean.class); 110 public static ForInternedString sForInternedString = Parcelling.Cache.getOrCreate( 111 ForInternedString.class); 112 public static ForInternedStringArray sForInternedStringArray = Parcelling.Cache.getOrCreate( 113 ForInternedStringArray.class); 114 public static ForInternedStringList sForInternedStringList = Parcelling.Cache.getOrCreate( 115 ForInternedStringList.class); 116 public static ForInternedStringValueMap sForInternedStringValueMap = 117 Parcelling.Cache.getOrCreate(ForInternedStringValueMap.class); 118 public static ForStringSet sForStringSet = Parcelling.Cache.getOrCreate(ForStringSet.class); 119 public static ForInternedStringSet sForInternedStringSet = 120 Parcelling.Cache.getOrCreate(ForInternedStringSet.class); 121 protected static ParsingUtils.StringPairListParceler sForIntentInfoPairs = 122 new ParsingUtils.StringPairListParceler(); 123 124 private static final Comparator<ParsedMainComponent> ORDER_COMPARATOR = 125 (first, second) -> Integer.compare(second.getOrder(), first.getOrder()); 126 127 // These are objects because null represents not explicitly set 128 @Nullable 129 @DataClass.ParcelWith(ForBoolean.class) 130 private Boolean supportsSmallScreens; 131 @Nullable 132 @DataClass.ParcelWith(ForBoolean.class) 133 private Boolean supportsNormalScreens; 134 @Nullable 135 @DataClass.ParcelWith(ForBoolean.class) 136 private Boolean supportsLargeScreens; 137 @Nullable 138 @DataClass.ParcelWith(ForBoolean.class) 139 private Boolean supportsExtraLargeScreens; 140 @Nullable 141 @DataClass.ParcelWith(ForBoolean.class) 142 private Boolean resizeable; 143 @Nullable 144 @DataClass.ParcelWith(ForBoolean.class) 145 private Boolean anyDensity; 146 147 protected int versionCode; 148 protected int versionCodeMajor; 149 private int baseRevisionCode; 150 @Nullable 151 @DataClass.ParcelWith(ForInternedString.class) 152 private String versionName; 153 154 private int compileSdkVersion; 155 @Nullable 156 @DataClass.ParcelWith(ForInternedString.class) 157 private String compileSdkVersionCodeName; 158 159 @NonNull 160 @DataClass.ParcelWith(ForInternedString.class) 161 protected String packageName; 162 163 @NonNull 164 protected String mBaseApkPath; 165 166 @Nullable 167 @DataClass.ParcelWith(ForInternedString.class) 168 private String restrictedAccountType; 169 @Nullable 170 @DataClass.ParcelWith(ForInternedString.class) 171 private String requiredAccountType; 172 173 @Nullable 174 @DataClass.ParcelWith(ForInternedString.class) 175 private String overlayTarget; 176 @Nullable 177 @DataClass.ParcelWith(ForInternedString.class) 178 private String overlayTargetOverlayableName; 179 @Nullable 180 @DataClass.ParcelWith(ForInternedString.class) 181 private String overlayCategory; 182 private int overlayPriority; 183 @NonNull 184 @DataClass.ParcelWith(ForInternedStringValueMap.class) 185 private Map<String, String> overlayables = emptyMap(); 186 187 @Nullable 188 @DataClass.ParcelWith(ForInternedString.class) 189 private String sdkLibName; 190 private int sdkLibVersionMajor; 191 @Nullable 192 @DataClass.ParcelWith(ForInternedString.class) 193 private String staticSharedLibName; 194 private long staticSharedLibVersion; 195 @NonNull 196 @DataClass.ParcelWith(ForInternedStringList.class) 197 private List<String> libraryNames = emptyList(); 198 @NonNull 199 @DataClass.ParcelWith(ForInternedStringList.class) 200 protected List<String> usesLibraries = emptyList(); 201 @NonNull 202 @DataClass.ParcelWith(ForInternedStringList.class) 203 protected List<String> usesOptionalLibraries = emptyList(); 204 205 @NonNull 206 @DataClass.ParcelWith(ForInternedStringList.class) 207 protected List<String> usesNativeLibraries = emptyList(); 208 @NonNull 209 @DataClass.ParcelWith(ForInternedStringList.class) 210 protected List<String> usesOptionalNativeLibraries = emptyList(); 211 212 @NonNull 213 @DataClass.ParcelWith(ForInternedStringList.class) 214 private List<String> usesStaticLibraries = emptyList(); 215 @Nullable 216 private long[] usesStaticLibrariesVersions; 217 @Nullable 218 private String[][] usesStaticLibrariesCertDigests; 219 220 @NonNull 221 @DataClass.ParcelWith(ForInternedStringList.class) 222 private List<String> usesSdkLibraries = emptyList(); 223 @Nullable 224 private long[] usesSdkLibrariesVersionsMajor; 225 @Nullable 226 private String[][] usesSdkLibrariesCertDigests; 227 228 @Nullable 229 @DataClass.ParcelWith(ForInternedString.class) 230 private String sharedUserId; 231 232 private int sharedUserLabel; 233 @NonNull 234 private List<ConfigurationInfo> configPreferences = emptyList(); 235 @NonNull 236 private List<FeatureInfo> reqFeatures = emptyList(); 237 @NonNull 238 private List<FeatureGroupInfo> featureGroups = emptyList(); 239 240 @Nullable 241 private byte[] restrictUpdateHash; 242 243 @NonNull 244 @DataClass.ParcelWith(ForInternedStringList.class) 245 protected List<String> originalPackages = emptyList(); 246 @NonNull 247 @DataClass.ParcelWith(ForInternedStringList.class) 248 protected List<String> adoptPermissions = emptyList(); 249 /** 250 * @deprecated consider migrating to {@link #getUsesPermissions} which has 251 * more parsed details, such as flags 252 */ 253 @NonNull 254 @Deprecated 255 @DataClass.ParcelWith(ForInternedStringList.class) 256 protected List<String> requestedPermissions = emptyList(); 257 258 @NonNull 259 private List<ParsedUsesPermission> usesPermissions = emptyList(); 260 261 @NonNull 262 @DataClass.ParcelWith(ForInternedStringList.class) 263 private List<String> implicitPermissions = emptyList(); 264 265 @NonNull 266 private Set<String> upgradeKeySets = emptySet(); 267 @NonNull 268 private Map<String, ArraySet<PublicKey>> keySetMapping = emptyMap(); 269 270 @NonNull 271 @DataClass.ParcelWith(ForInternedStringList.class) 272 protected List<String> protectedBroadcasts = emptyList(); 273 274 @NonNull 275 protected List<ParsedActivity> activities = emptyList(); 276 277 @NonNull 278 protected List<ParsedApexSystemService> apexSystemServices = emptyList(); 279 280 @NonNull 281 protected List<ParsedActivity> receivers = emptyList(); 282 283 @NonNull 284 protected List<ParsedService> services = emptyList(); 285 286 @NonNull 287 protected List<ParsedProvider> providers = emptyList(); 288 289 @NonNull 290 private List<ParsedAttribution> attributions = emptyList(); 291 292 @NonNull 293 protected List<ParsedPermission> permissions = emptyList(); 294 295 @NonNull 296 protected List<ParsedPermissionGroup> permissionGroups = emptyList(); 297 298 @NonNull 299 protected List<ParsedInstrumentation> instrumentations = emptyList(); 300 301 @NonNull 302 // @DataClass.ParcelWith(ParsingUtils.StringPairListParceler.class) 303 private List<Pair<String, ParsedIntentInfo>> preferredActivityFilters = emptyList(); 304 305 /** 306 * Map from a process name to a {@link ParsedProcess}. 307 */ 308 @NonNull 309 private Map<String, ParsedProcess> processes = emptyMap(); 310 311 @Nullable 312 private Bundle metaData; 313 314 @NonNull 315 private Map<String, Property> mProperties = emptyMap(); 316 317 @Nullable 318 @DataClass.ParcelWith(ForInternedString.class) 319 protected String volumeUuid; 320 @Nullable 321 private SigningDetails signingDetails; 322 323 @NonNull 324 @DataClass.ParcelWith(ForInternedString.class) 325 protected String mPath; 326 327 @NonNull 328 @DataClass.ParcelWith(ForInternedStringList.class) 329 private List<Intent> queriesIntents = emptyList(); 330 331 @NonNull 332 @DataClass.ParcelWith(ForInternedStringList.class) 333 private List<String> queriesPackages = emptyList(); 334 335 @NonNull 336 @DataClass.ParcelWith(ForInternedStringSet.class) 337 private Set<String> queriesProviders = emptySet(); 338 339 @Nullable 340 @DataClass.ParcelWith(ForInternedStringArray.class) 341 private String[] splitClassLoaderNames; 342 @Nullable 343 protected String[] splitCodePaths; 344 @Nullable 345 private SparseArray<int[]> splitDependencies; 346 @Nullable 347 private int[] splitFlags; 348 @Nullable 349 @DataClass.ParcelWith(ForInternedStringArray.class) 350 private String[] splitNames; 351 @Nullable 352 private int[] splitRevisionCodes; 353 354 @Nullable 355 @DataClass.ParcelWith(ForInternedString.class) 356 private String appComponentFactory; 357 @Nullable 358 @DataClass.ParcelWith(ForInternedString.class) 359 private String backupAgentName; 360 private int banner; 361 private int category = ApplicationInfo.CATEGORY_UNDEFINED; 362 @Nullable 363 @DataClass.ParcelWith(ForInternedString.class) 364 private String classLoaderName; 365 @Nullable 366 @DataClass.ParcelWith(ForInternedString.class) 367 private String className; 368 private int compatibleWidthLimitDp; 369 private int descriptionRes; 370 371 private int fullBackupContent; 372 private int dataExtractionRules; 373 private int iconRes; 374 private int installLocation = ParsingPackageUtils.PARSE_DEFAULT_INSTALL_LOCATION; 375 private int labelRes; 376 private int largestWidthLimitDp; 377 private int logo; 378 @Nullable 379 @DataClass.ParcelWith(ForInternedString.class) 380 private String manageSpaceActivityName; 381 private float maxAspectRatio; 382 private float minAspectRatio; 383 @Nullable 384 private SparseIntArray minExtensionVersions; 385 private int minSdkVersion = ParsingUtils.DEFAULT_MIN_SDK_VERSION; 386 private int maxSdkVersion = ParsingUtils.DEFAULT_MAX_SDK_VERSION; 387 private int networkSecurityConfigRes; 388 @Nullable 389 private CharSequence nonLocalizedLabel; 390 @Nullable 391 @DataClass.ParcelWith(ForInternedString.class) 392 private String permission; 393 @Nullable 394 @DataClass.ParcelWith(ForInternedString.class) 395 private String processName; 396 private int requiresSmallestWidthDp; 397 private int roundIconRes; 398 private int targetSandboxVersion; 399 private int targetSdkVersion = ParsingUtils.DEFAULT_TARGET_SDK_VERSION; 400 @Nullable 401 @DataClass.ParcelWith(ForInternedString.class) 402 private String taskAffinity; 403 private int theme; 404 405 private int uiOptions; 406 @Nullable 407 @DataClass.ParcelWith(ForInternedString.class) 408 private String zygotePreloadName; 409 410 /** 411 * @see ParsingPackageRead#getResizeableActivity() 412 */ 413 @Nullable 414 @DataClass.ParcelWith(ForBoolean.class) 415 private Boolean resizeableActivity; 416 417 private int autoRevokePermissions; 418 419 @ApplicationInfo.GwpAsanMode 420 private int gwpAsanMode; 421 422 @ApplicationInfo.MemtagMode 423 private int memtagMode; 424 425 @ApplicationInfo.NativeHeapZeroInitialized 426 private int nativeHeapZeroInitialized; 427 428 @Nullable 429 @DataClass.ParcelWith(ForBoolean.class) 430 private Boolean requestRawExternalStorageAccess; 431 432 // TODO(chiuwinson): Non-null 433 @Nullable 434 private ArraySet<String> mimeGroups; 435 436 // Usually there's code to set enabled to true during parsing, but it's possible to install 437 // an APK targeting <R that doesn't contain an <application> tag. That code would be skipped 438 // and never assign this, so initialize this to true for those cases. 439 private long mBooleans = Booleans.ENABLED; 440 441 /** 442 * Flags used for a internal bitset. These flags should never be persisted or exposed outside 443 * of this class. It is expected that PackageCacher explicitly clears itself whenever the 444 * Parcelable implementation changes such that all these flags can be re-ordered or invalidated. 445 */ 446 protected static class Booleans { 447 @LongDef({ 448 EXTERNAL_STORAGE, 449 BASE_HARDWARE_ACCELERATED, 450 ALLOW_BACKUP, 451 KILL_AFTER_RESTORE, 452 RESTORE_ANY_VERSION, 453 FULL_BACKUP_ONLY, 454 PERSISTENT, 455 DEBUGGABLE, 456 VM_SAFE_MODE, 457 HAS_CODE, 458 ALLOW_TASK_REPARENTING, 459 ALLOW_CLEAR_USER_DATA, 460 LARGE_HEAP, 461 USES_CLEARTEXT_TRAFFIC, 462 SUPPORTS_RTL, 463 TEST_ONLY, 464 MULTI_ARCH, 465 EXTRACT_NATIVE_LIBS, 466 GAME, 467 STATIC_SHARED_LIBRARY, 468 OVERLAY, 469 ISOLATED_SPLIT_LOADING, 470 HAS_DOMAIN_URLS, 471 PROFILEABLE_BY_SHELL, 472 BACKUP_IN_FOREGROUND, 473 USE_EMBEDDED_DEX, 474 DEFAULT_TO_DEVICE_PROTECTED_STORAGE, 475 DIRECT_BOOT_AWARE, 476 PARTIALLY_DIRECT_BOOT_AWARE, 477 RESIZEABLE_ACTIVITY_VIA_SDK_VERSION, 478 ALLOW_CLEAR_USER_DATA_ON_FAILED_RESTORE, 479 ALLOW_AUDIO_PLAYBACK_CAPTURE, 480 REQUEST_LEGACY_EXTERNAL_STORAGE, 481 USES_NON_SDK_API, 482 HAS_FRAGILE_USER_DATA, 483 CANT_SAVE_STATE, 484 ALLOW_NATIVE_HEAP_POINTER_TAGGING, 485 PRESERVE_LEGACY_EXTERNAL_STORAGE, 486 REQUIRED_FOR_ALL_USERS, 487 OVERLAY_IS_STATIC, 488 USE_32_BIT_ABI, 489 VISIBLE_TO_INSTANT_APPS, 490 FORCE_QUERYABLE, 491 CROSS_PROFILE, 492 ENABLED, 493 DISALLOW_PROFILING, 494 REQUEST_FOREGROUND_SERVICE_EXEMPTION, 495 ATTRIBUTIONS_ARE_USER_VISIBLE, 496 RESET_ENABLED_SETTINGS_ON_APP_DATA_CLEARED, 497 SDK_LIBRARY, 498 }) 499 public @interface Values {} 500 private static final long EXTERNAL_STORAGE = 1L; 501 private static final long BASE_HARDWARE_ACCELERATED = 1L << 1; 502 private static final long ALLOW_BACKUP = 1L << 2; 503 private static final long KILL_AFTER_RESTORE = 1L << 3; 504 private static final long RESTORE_ANY_VERSION = 1L << 4; 505 private static final long FULL_BACKUP_ONLY = 1L << 5; 506 private static final long PERSISTENT = 1L << 6; 507 private static final long DEBUGGABLE = 1L << 7; 508 private static final long VM_SAFE_MODE = 1L << 8; 509 private static final long HAS_CODE = 1L << 9; 510 private static final long ALLOW_TASK_REPARENTING = 1L << 10; 511 private static final long ALLOW_CLEAR_USER_DATA = 1L << 11; 512 private static final long LARGE_HEAP = 1L << 12; 513 private static final long USES_CLEARTEXT_TRAFFIC = 1L << 13; 514 private static final long SUPPORTS_RTL = 1L << 14; 515 private static final long TEST_ONLY = 1L << 15; 516 private static final long MULTI_ARCH = 1L << 16; 517 private static final long EXTRACT_NATIVE_LIBS = 1L << 17; 518 private static final long GAME = 1L << 18; 519 private static final long STATIC_SHARED_LIBRARY = 1L << 19; 520 private static final long OVERLAY = 1L << 20; 521 private static final long ISOLATED_SPLIT_LOADING = 1L << 21; 522 private static final long HAS_DOMAIN_URLS = 1L << 22; 523 private static final long PROFILEABLE_BY_SHELL = 1L << 23; 524 private static final long BACKUP_IN_FOREGROUND = 1L << 24; 525 private static final long USE_EMBEDDED_DEX = 1L << 25; 526 private static final long DEFAULT_TO_DEVICE_PROTECTED_STORAGE = 1L << 26; 527 private static final long DIRECT_BOOT_AWARE = 1L << 27; 528 private static final long PARTIALLY_DIRECT_BOOT_AWARE = 1L << 28; 529 private static final long RESIZEABLE_ACTIVITY_VIA_SDK_VERSION = 1L << 29; 530 private static final long ALLOW_CLEAR_USER_DATA_ON_FAILED_RESTORE = 1L << 30; 531 private static final long ALLOW_AUDIO_PLAYBACK_CAPTURE = 1L << 31; 532 private static final long REQUEST_LEGACY_EXTERNAL_STORAGE = 1L << 32; 533 private static final long USES_NON_SDK_API = 1L << 33; 534 private static final long HAS_FRAGILE_USER_DATA = 1L << 34; 535 private static final long CANT_SAVE_STATE = 1L << 35; 536 private static final long ALLOW_NATIVE_HEAP_POINTER_TAGGING = 1L << 36; 537 private static final long PRESERVE_LEGACY_EXTERNAL_STORAGE = 1L << 37; 538 private static final long REQUIRED_FOR_ALL_USERS = 1L << 38; 539 private static final long OVERLAY_IS_STATIC = 1L << 39; 540 private static final long USE_32_BIT_ABI = 1L << 40; 541 private static final long VISIBLE_TO_INSTANT_APPS = 1L << 41; 542 private static final long FORCE_QUERYABLE = 1L << 42; 543 private static final long CROSS_PROFILE = 1L << 43; 544 private static final long ENABLED = 1L << 44; 545 private static final long DISALLOW_PROFILING = 1L << 45; 546 private static final long REQUEST_FOREGROUND_SERVICE_EXEMPTION = 1L << 46; 547 private static final long ATTRIBUTIONS_ARE_USER_VISIBLE = 1L << 47; 548 private static final long RESET_ENABLED_SETTINGS_ON_APP_DATA_CLEARED = 1L << 48; 549 private static final long SDK_LIBRARY = 1L << 49; 550 private static final long ENABLE_ON_BACK_INVOKED_CALLBACK = 1L << 50; 551 private static final long LEAVING_SHARED_UID = 1L << 51; 552 } 553 setBoolean(@ooleans.Values long flag, boolean value)554 private ParsingPackageImpl setBoolean(@Booleans.Values long flag, boolean value) { 555 if (value) { 556 mBooleans |= flag; 557 } else { 558 mBooleans &= ~flag; 559 } 560 return this; 561 } 562 getBoolean(@ooleans.Values long flag)563 private boolean getBoolean(@Booleans.Values long flag) { 564 return (mBooleans & flag) != 0; 565 } 566 567 @Nullable 568 private Set<String> mKnownActivityEmbeddingCerts; 569 570 // Derived fields 571 @NonNull 572 private UUID mStorageUuid; 573 private long mLongVersionCode; 574 575 private int mLocaleConfigRes; 576 577 @VisibleForTesting ParsingPackageImpl(@onNull String packageName, @NonNull String baseApkPath, @NonNull String path, @Nullable TypedArray manifestArray)578 public ParsingPackageImpl(@NonNull String packageName, @NonNull String baseApkPath, 579 @NonNull String path, @Nullable TypedArray manifestArray) { 580 this.packageName = TextUtils.safeIntern(packageName); 581 this.mBaseApkPath = baseApkPath; 582 this.mPath = path; 583 584 if (manifestArray != null) { 585 versionCode = manifestArray.getInteger(R.styleable.AndroidManifest_versionCode, 0); 586 versionCodeMajor = manifestArray.getInteger( 587 R.styleable.AndroidManifest_versionCodeMajor, 0); 588 setBaseRevisionCode( 589 manifestArray.getInteger(R.styleable.AndroidManifest_revisionCode, 0)); 590 setVersionName(manifestArray.getNonConfigurationString( 591 R.styleable.AndroidManifest_versionName, 0)); 592 593 setCompileSdkVersion(manifestArray.getInteger( 594 R.styleable.AndroidManifest_compileSdkVersion, 0)); 595 setCompileSdkVersionCodeName(manifestArray.getNonConfigurationString( 596 R.styleable.AndroidManifest_compileSdkVersionCodename, 0)); 597 598 setIsolatedSplitLoading(manifestArray.getBoolean( 599 R.styleable.AndroidManifest_isolatedSplits, false)); 600 601 } 602 } 603 isSupportsSmallScreens()604 public boolean isSupportsSmallScreens() { 605 if (supportsSmallScreens == null) { 606 return targetSdkVersion >= Build.VERSION_CODES.DONUT; 607 } 608 609 return supportsSmallScreens; 610 } 611 isSupportsNormalScreens()612 public boolean isSupportsNormalScreens() { 613 return supportsNormalScreens == null || supportsNormalScreens; 614 } 615 isSupportsLargeScreens()616 public boolean isSupportsLargeScreens() { 617 if (supportsLargeScreens == null) { 618 return targetSdkVersion >= Build.VERSION_CODES.DONUT; 619 } 620 621 return supportsLargeScreens; 622 } 623 isSupportsExtraLargeScreens()624 public boolean isSupportsExtraLargeScreens() { 625 if (supportsExtraLargeScreens == null) { 626 return targetSdkVersion >= Build.VERSION_CODES.GINGERBREAD; 627 } 628 629 return supportsExtraLargeScreens; 630 } 631 isResizeable()632 public boolean isResizeable() { 633 if (resizeable == null) { 634 return targetSdkVersion >= Build.VERSION_CODES.DONUT; 635 } 636 637 return resizeable; 638 } 639 isAnyDensity()640 public boolean isAnyDensity() { 641 if (anyDensity == null) { 642 return targetSdkVersion >= Build.VERSION_CODES.DONUT; 643 } 644 645 return anyDensity; 646 } 647 648 @Override sortActivities()649 public ParsingPackageImpl sortActivities() { 650 Collections.sort(this.activities, ORDER_COMPARATOR); 651 return this; 652 } 653 654 @Override sortReceivers()655 public ParsingPackageImpl sortReceivers() { 656 Collections.sort(this.receivers, ORDER_COMPARATOR); 657 return this; 658 } 659 660 @Override sortServices()661 public ParsingPackageImpl sortServices() { 662 Collections.sort(this.services, ORDER_COMPARATOR); 663 return this; 664 } 665 666 @SuppressLint("MissingSuperCall") 667 @CallSuper 668 @Override hideAsParsed()669 public Object hideAsParsed() { 670 assignDerivedFields(); 671 return this; 672 } 673 assignDerivedFields()674 private void assignDerivedFields() { 675 mStorageUuid = StorageManager.convert(volumeUuid); 676 mLongVersionCode = PackageInfo.composeLongVersionCode(versionCodeMajor, versionCode); 677 } 678 679 @Override addConfigPreference(ConfigurationInfo configPreference)680 public ParsingPackageImpl addConfigPreference(ConfigurationInfo configPreference) { 681 this.configPreferences = CollectionUtils.add(this.configPreferences, configPreference); 682 return this; 683 } 684 685 @Override addReqFeature(FeatureInfo reqFeature)686 public ParsingPackageImpl addReqFeature(FeatureInfo reqFeature) { 687 this.reqFeatures = CollectionUtils.add(this.reqFeatures, reqFeature); 688 return this; 689 } 690 691 @Override addFeatureGroup(FeatureGroupInfo featureGroup)692 public ParsingPackageImpl addFeatureGroup(FeatureGroupInfo featureGroup) { 693 this.featureGroups = CollectionUtils.add(this.featureGroups, featureGroup); 694 return this; 695 } 696 697 @Override addProperty(@ullable Property property)698 public ParsingPackageImpl addProperty(@Nullable Property property) { 699 if (property == null) { 700 return this; 701 } 702 this.mProperties = CollectionUtils.add(this.mProperties, property.getName(), property); 703 return this; 704 } 705 706 @Override addProtectedBroadcast(String protectedBroadcast)707 public ParsingPackageImpl addProtectedBroadcast(String protectedBroadcast) { 708 if (!this.protectedBroadcasts.contains(protectedBroadcast)) { 709 this.protectedBroadcasts = CollectionUtils.add(this.protectedBroadcasts, 710 TextUtils.safeIntern(protectedBroadcast)); 711 } 712 return this; 713 } 714 715 @Override addInstrumentation(ParsedInstrumentation instrumentation)716 public ParsingPackageImpl addInstrumentation(ParsedInstrumentation instrumentation) { 717 this.instrumentations = CollectionUtils.add(this.instrumentations, instrumentation); 718 return this; 719 } 720 721 @Override addOriginalPackage(String originalPackage)722 public ParsingPackageImpl addOriginalPackage(String originalPackage) { 723 this.originalPackages = CollectionUtils.add(this.originalPackages, originalPackage); 724 return this; 725 } 726 727 @Override addOverlayable(String overlayableName, String actorName)728 public ParsingPackage addOverlayable(String overlayableName, String actorName) { 729 this.overlayables = CollectionUtils.add(this.overlayables, overlayableName, 730 TextUtils.safeIntern(actorName)); 731 return this; 732 } 733 734 @Override addAdoptPermission(String adoptPermission)735 public ParsingPackageImpl addAdoptPermission(String adoptPermission) { 736 this.adoptPermissions = CollectionUtils.add(this.adoptPermissions, 737 TextUtils.safeIntern(adoptPermission)); 738 return this; 739 } 740 741 @Override addPermission(ParsedPermission permission)742 public ParsingPackageImpl addPermission(ParsedPermission permission) { 743 this.permissions = CollectionUtils.add(this.permissions, permission); 744 return this; 745 } 746 747 @Override addPermissionGroup(ParsedPermissionGroup permissionGroup)748 public ParsingPackageImpl addPermissionGroup(ParsedPermissionGroup permissionGroup) { 749 this.permissionGroups = CollectionUtils.add(this.permissionGroups, permissionGroup); 750 return this; 751 } 752 753 @Override addUsesPermission(ParsedUsesPermission permission)754 public ParsingPackageImpl addUsesPermission(ParsedUsesPermission permission) { 755 this.usesPermissions = CollectionUtils.add(this.usesPermissions, permission); 756 757 // Continue populating legacy data structures to avoid performance 758 // issues until all that code can be migrated 759 this.requestedPermissions = CollectionUtils.add(this.requestedPermissions, 760 permission.getName()); 761 762 return this; 763 } 764 765 @Override addImplicitPermission(String permission)766 public ParsingPackageImpl addImplicitPermission(String permission) { 767 addUsesPermission(new ParsedUsesPermissionImpl(permission, 0 /*usesPermissionFlags*/)); 768 this.implicitPermissions = CollectionUtils.add(this.implicitPermissions, 769 TextUtils.safeIntern(permission)); 770 return this; 771 } 772 773 @Override addKeySet(String keySetName, PublicKey publicKey)774 public ParsingPackageImpl addKeySet(String keySetName, PublicKey publicKey) { 775 ArraySet<PublicKey> publicKeys = keySetMapping.get(keySetName); 776 if (publicKeys == null) { 777 publicKeys = new ArraySet<>(); 778 } 779 publicKeys.add(publicKey); 780 keySetMapping = CollectionUtils.add(this.keySetMapping, keySetName, publicKeys); 781 return this; 782 } 783 784 @Override addActivity(ParsedActivity parsedActivity)785 public ParsingPackageImpl addActivity(ParsedActivity parsedActivity) { 786 this.activities = CollectionUtils.add(this.activities, parsedActivity); 787 addMimeGroupsFromComponent(parsedActivity); 788 return this; 789 } 790 791 @Override addApexSystemService( ParsedApexSystemService parsedApexSystemService)792 public final ParsingPackageImpl addApexSystemService( 793 ParsedApexSystemService parsedApexSystemService) { 794 this.apexSystemServices = CollectionUtils.add( 795 this.apexSystemServices, parsedApexSystemService); 796 return this; 797 } 798 799 @Override addReceiver(ParsedActivity parsedReceiver)800 public ParsingPackageImpl addReceiver(ParsedActivity parsedReceiver) { 801 this.receivers = CollectionUtils.add(this.receivers, parsedReceiver); 802 addMimeGroupsFromComponent(parsedReceiver); 803 return this; 804 } 805 806 @Override addService(ParsedService parsedService)807 public ParsingPackageImpl addService(ParsedService parsedService) { 808 this.services = CollectionUtils.add(this.services, parsedService); 809 addMimeGroupsFromComponent(parsedService); 810 return this; 811 } 812 813 @Override addProvider(ParsedProvider parsedProvider)814 public ParsingPackageImpl addProvider(ParsedProvider parsedProvider) { 815 this.providers = CollectionUtils.add(this.providers, parsedProvider); 816 addMimeGroupsFromComponent(parsedProvider); 817 return this; 818 } 819 820 @Override addAttribution(ParsedAttribution attribution)821 public ParsingPackageImpl addAttribution(ParsedAttribution attribution) { 822 this.attributions = CollectionUtils.add(this.attributions, attribution); 823 return this; 824 } 825 826 @Override addLibraryName(String libraryName)827 public ParsingPackageImpl addLibraryName(String libraryName) { 828 this.libraryNames = CollectionUtils.add(this.libraryNames, 829 TextUtils.safeIntern(libraryName)); 830 return this; 831 } 832 833 @Override addUsesOptionalLibrary(String libraryName)834 public ParsingPackageImpl addUsesOptionalLibrary(String libraryName) { 835 this.usesOptionalLibraries = CollectionUtils.add(this.usesOptionalLibraries, 836 TextUtils.safeIntern(libraryName)); 837 return this; 838 } 839 840 @Override addUsesLibrary(String libraryName)841 public ParsingPackageImpl addUsesLibrary(String libraryName) { 842 this.usesLibraries = CollectionUtils.add(this.usesLibraries, 843 TextUtils.safeIntern(libraryName)); 844 return this; 845 } 846 847 @Override removeUsesOptionalLibrary(String libraryName)848 public ParsingPackageImpl removeUsesOptionalLibrary(String libraryName) { 849 this.usesOptionalLibraries = CollectionUtils.remove(this.usesOptionalLibraries, 850 libraryName); 851 return this; 852 } 853 854 @Override addUsesOptionalNativeLibrary(String libraryName)855 public final ParsingPackageImpl addUsesOptionalNativeLibrary(String libraryName) { 856 this.usesOptionalNativeLibraries = CollectionUtils.add(this.usesOptionalNativeLibraries, 857 TextUtils.safeIntern(libraryName)); 858 return this; 859 } 860 861 @Override addUsesNativeLibrary(String libraryName)862 public final ParsingPackageImpl addUsesNativeLibrary(String libraryName) { 863 this.usesNativeLibraries = CollectionUtils.add(this.usesNativeLibraries, 864 TextUtils.safeIntern(libraryName)); 865 return this; 866 } 867 removeUsesOptionalNativeLibrary(String libraryName)868 @Override public ParsingPackageImpl removeUsesOptionalNativeLibrary(String libraryName) { 869 this.usesOptionalNativeLibraries = CollectionUtils.remove(this.usesOptionalNativeLibraries, 870 libraryName); 871 return this; 872 } 873 874 @Override addUsesSdkLibrary(String libraryName, long versionMajor, String[] certSha256Digests)875 public ParsingPackageImpl addUsesSdkLibrary(String libraryName, long versionMajor, 876 String[] certSha256Digests) { 877 this.usesSdkLibraries = CollectionUtils.add(this.usesSdkLibraries, 878 TextUtils.safeIntern(libraryName)); 879 this.usesSdkLibrariesVersionsMajor = ArrayUtils.appendLong( 880 this.usesSdkLibrariesVersionsMajor, versionMajor, true); 881 this.usesSdkLibrariesCertDigests = ArrayUtils.appendElement(String[].class, 882 this.usesSdkLibrariesCertDigests, certSha256Digests, true); 883 return this; 884 } 885 886 @Override addUsesStaticLibrary(String libraryName, long version, String[] certSha256Digests)887 public ParsingPackageImpl addUsesStaticLibrary(String libraryName, long version, 888 String[] certSha256Digests) { 889 this.usesStaticLibraries = CollectionUtils.add(this.usesStaticLibraries, 890 TextUtils.safeIntern(libraryName)); 891 this.usesStaticLibrariesVersions = ArrayUtils.appendLong(this.usesStaticLibrariesVersions, 892 version, true); 893 this.usesStaticLibrariesCertDigests = ArrayUtils.appendElement(String[].class, 894 this.usesStaticLibrariesCertDigests, certSha256Digests, true); 895 return this; 896 } 897 898 @Override addPreferredActivityFilter(String className, ParsedIntentInfo intentInfo)899 public ParsingPackageImpl addPreferredActivityFilter(String className, 900 ParsedIntentInfo intentInfo) { 901 this.preferredActivityFilters = CollectionUtils.add(this.preferredActivityFilters, 902 Pair.create(className, intentInfo)); 903 return this; 904 } 905 906 @Override addQueriesIntent(Intent intent)907 public ParsingPackageImpl addQueriesIntent(Intent intent) { 908 this.queriesIntents = CollectionUtils.add(this.queriesIntents, intent); 909 return this; 910 } 911 912 @Override addQueriesPackage(String packageName)913 public ParsingPackageImpl addQueriesPackage(String packageName) { 914 this.queriesPackages = CollectionUtils.add(this.queriesPackages, 915 TextUtils.safeIntern(packageName)); 916 return this; 917 } 918 919 @Override addQueriesProvider(String authority)920 public ParsingPackageImpl addQueriesProvider(String authority) { 921 this.queriesProviders = CollectionUtils.add(this.queriesProviders, authority); 922 return this; 923 } 924 925 @Override setSupportsSmallScreens(int supportsSmallScreens)926 public ParsingPackageImpl setSupportsSmallScreens(int supportsSmallScreens) { 927 if (supportsSmallScreens == 1) { 928 return this; 929 } 930 931 this.supportsSmallScreens = supportsSmallScreens < 0; 932 return this; 933 } 934 935 @Override 936 public ParsingPackageImpl setSupportsNormalScreens(int supportsNormalScreens) { 937 if (supportsNormalScreens == 1) { 938 return this; 939 } 940 941 this.supportsNormalScreens = supportsNormalScreens < 0; 942 return this; 943 } 944 945 @Override 946 public ParsingPackageImpl setSupportsLargeScreens(int supportsLargeScreens) { 947 if (supportsLargeScreens == 1) { 948 return this; 949 } 950 951 this.supportsLargeScreens = supportsLargeScreens < 0; 952 return this; 953 } 954 955 @Override 956 public ParsingPackageImpl setSupportsExtraLargeScreens(int supportsExtraLargeScreens) { 957 if (supportsExtraLargeScreens == 1) { 958 return this; 959 } 960 961 this.supportsExtraLargeScreens = supportsExtraLargeScreens < 0; 962 return this; 963 } 964 965 @Override 966 public ParsingPackageImpl setResizeable(int resizeable) { 967 if (resizeable == 1) { 968 return this; 969 } 970 971 this.resizeable = resizeable < 0; 972 return this; 973 } 974 975 @Override 976 public ParsingPackageImpl setAnyDensity(int anyDensity) { 977 if (anyDensity == 1) { 978 return this; 979 } 980 981 this.anyDensity = anyDensity < 0; 982 return this; 983 } 984 985 @Override 986 public ParsingPackageImpl asSplit(String[] splitNames, String[] splitCodePaths, 987 int[] splitRevisionCodes, SparseArray<int[]> splitDependencies) { 988 this.splitNames = splitNames; 989 this.splitCodePaths = splitCodePaths; 990 this.splitRevisionCodes = splitRevisionCodes; 991 this.splitDependencies = splitDependencies; 992 993 int count = splitNames.length; 994 this.splitFlags = new int[count]; 995 this.splitClassLoaderNames = new String[count]; 996 return this; 997 } 998 999 @Override 1000 public ParsingPackageImpl setSplitHasCode(int splitIndex, boolean splitHasCode) { 1001 this.splitFlags[splitIndex] = splitHasCode 1002 ? this.splitFlags[splitIndex] | ApplicationInfo.FLAG_HAS_CODE 1003 : this.splitFlags[splitIndex] & ~ApplicationInfo.FLAG_HAS_CODE; 1004 return this; 1005 } 1006 1007 @Override 1008 public ParsingPackageImpl setSplitClassLoaderName(int splitIndex, String classLoaderName) { 1009 this.splitClassLoaderNames[splitIndex] = classLoaderName; 1010 return this; 1011 } 1012 1013 @Override 1014 public ParsingPackageImpl setRequiredAccountType(@Nullable String requiredAccountType) { 1015 this.requiredAccountType = TextUtils.nullIfEmpty(requiredAccountType); 1016 return this; 1017 } 1018 1019 @Override 1020 public ParsingPackageImpl setOverlayTarget(@Nullable String overlayTarget) { 1021 this.overlayTarget = TextUtils.safeIntern(overlayTarget); 1022 return this; 1023 } 1024 1025 @Override 1026 public ParsingPackageImpl setVolumeUuid(@Nullable String volumeUuid) { 1027 this.volumeUuid = TextUtils.safeIntern(volumeUuid); 1028 return this; 1029 } 1030 1031 @Override 1032 public ParsingPackageImpl setStaticSharedLibName(String staticSharedLibName) { 1033 this.staticSharedLibName = TextUtils.safeIntern(staticSharedLibName); 1034 return this; 1035 } 1036 1037 @Override 1038 public ParsingPackageImpl setSharedUserId(String sharedUserId) { 1039 this.sharedUserId = TextUtils.safeIntern(sharedUserId); 1040 return this; 1041 } 1042 1043 @Override 1044 public ParsingPackageImpl setNonLocalizedLabel(@Nullable CharSequence value) { 1045 nonLocalizedLabel = value == null ? null : value.toString().trim(); 1046 return this; 1047 } 1048 1049 @NonNull 1050 @Override 1051 public String getProcessName() { 1052 return processName != null ? processName : packageName; 1053 } 1054 1055 @Override 1056 public String toString() { 1057 return "Package{" 1058 + Integer.toHexString(System.identityHashCode(this)) 1059 + " " + packageName + "}"; 1060 } 1061 1062 @Deprecated 1063 @Override 1064 public ApplicationInfo toAppInfoWithoutState() { 1065 ApplicationInfo appInfo = toAppInfoWithoutStateWithoutFlags(); 1066 appInfo.flags = PackageInfoWithoutStateUtils.appInfoFlags(this); 1067 appInfo.privateFlags = PackageInfoWithoutStateUtils.appInfoPrivateFlags(this); 1068 appInfo.privateFlagsExt = PackageInfoWithoutStateUtils.appInfoPrivateFlagsExt(this); 1069 return appInfo; 1070 } 1071 1072 public ApplicationInfo toAppInfoWithoutStateWithoutFlags() { 1073 ApplicationInfo appInfo = new ApplicationInfo(); 1074 1075 // Lines that are commented below are state related and should not be assigned here. 1076 // They are left in as placeholders, since there is no good backwards compatible way to 1077 // separate these. 1078 appInfo.appComponentFactory = appComponentFactory; 1079 appInfo.backupAgentName = backupAgentName; 1080 appInfo.banner = banner; 1081 appInfo.category = category; 1082 appInfo.classLoaderName = classLoaderName; 1083 appInfo.className = className; 1084 appInfo.compatibleWidthLimitDp = compatibleWidthLimitDp; 1085 appInfo.compileSdkVersion = compileSdkVersion; 1086 appInfo.compileSdkVersionCodename = compileSdkVersionCodeName; 1087 // appInfo.credentialProtectedDataDir 1088 appInfo.crossProfile = isCrossProfile(); 1089 // appInfo.dataDir 1090 appInfo.descriptionRes = descriptionRes; 1091 // appInfo.deviceProtectedDataDir 1092 appInfo.enabled = getBoolean(Booleans.ENABLED); 1093 // appInfo.enabledSetting 1094 appInfo.fullBackupContent = fullBackupContent; 1095 appInfo.dataExtractionRulesRes = dataExtractionRules; 1096 // TODO(b/135203078): See ParsingPackageImpl#getHiddenApiEnforcementPolicy 1097 // appInfo.mHiddenApiPolicy 1098 // appInfo.hiddenUntilInstalled 1099 appInfo.icon = 1100 (ParsingPackageUtils.sUseRoundIcon && roundIconRes != 0) ? roundIconRes : iconRes; 1101 appInfo.iconRes = iconRes; 1102 appInfo.roundIconRes = roundIconRes; 1103 appInfo.installLocation = installLocation; 1104 appInfo.labelRes = labelRes; 1105 appInfo.largestWidthLimitDp = largestWidthLimitDp; 1106 appInfo.logo = logo; 1107 appInfo.manageSpaceActivityName = manageSpaceActivityName; 1108 appInfo.maxAspectRatio = maxAspectRatio; 1109 appInfo.metaData = metaData; 1110 appInfo.minAspectRatio = minAspectRatio; 1111 appInfo.minSdkVersion = minSdkVersion; 1112 appInfo.name = className; 1113 // appInfo.nativeLibraryDir 1114 // appInfo.nativeLibraryRootDir 1115 // appInfo.nativeLibraryRootRequiresIsa 1116 appInfo.networkSecurityConfigRes = networkSecurityConfigRes; 1117 appInfo.nonLocalizedLabel = nonLocalizedLabel; 1118 appInfo.packageName = packageName; 1119 appInfo.permission = permission; 1120 // appInfo.primaryCpuAbi 1121 appInfo.processName = getProcessName(); 1122 appInfo.requiresSmallestWidthDp = requiresSmallestWidthDp; 1123 // appInfo.resourceDirs 1124 // appInfo.secondaryCpuAbi 1125 // appInfo.secondaryNativeLibraryDir 1126 // appInfo.seInfo 1127 // appInfo.seInfoUser 1128 // appInfo.sharedLibraryFiles 1129 // appInfo.sharedLibraryInfos 1130 // appInfo.showUserIcon 1131 appInfo.splitClassLoaderNames = splitClassLoaderNames; 1132 appInfo.splitDependencies = (splitDependencies == null || splitDependencies.size() == 0) 1133 ? null : splitDependencies; 1134 appInfo.splitNames = splitNames; 1135 appInfo.storageUuid = mStorageUuid; 1136 appInfo.targetSandboxVersion = targetSandboxVersion; 1137 appInfo.targetSdkVersion = targetSdkVersion; 1138 appInfo.taskAffinity = taskAffinity; 1139 appInfo.theme = theme; 1140 // appInfo.uid 1141 appInfo.uiOptions = uiOptions; 1142 appInfo.volumeUuid = volumeUuid; 1143 appInfo.zygotePreloadName = zygotePreloadName; 1144 appInfo.setGwpAsanMode(gwpAsanMode); 1145 appInfo.setMemtagMode(memtagMode); 1146 appInfo.setNativeHeapZeroInitialized(nativeHeapZeroInitialized); 1147 appInfo.setRequestRawExternalStorageAccess(requestRawExternalStorageAccess); 1148 appInfo.setBaseCodePath(mBaseApkPath); 1149 appInfo.setBaseResourcePath(mBaseApkPath); 1150 appInfo.setCodePath(mPath); 1151 appInfo.setResourcePath(mPath); 1152 appInfo.setSplitCodePaths(ArrayUtils.size(splitCodePaths) == 0 ? null : splitCodePaths); 1153 appInfo.setSplitResourcePaths(ArrayUtils.size(splitCodePaths) == 0 ? null : splitCodePaths); 1154 appInfo.setVersionCode(mLongVersionCode); 1155 appInfo.setAppClassNamesByProcess(buildAppClassNamesByProcess()); 1156 appInfo.setLocaleConfigRes(mLocaleConfigRes); 1157 if (mKnownActivityEmbeddingCerts != null) { 1158 appInfo.setKnownActivityEmbeddingCerts(mKnownActivityEmbeddingCerts); 1159 } 1160 1161 return appInfo; 1162 } 1163 1164 /** 1165 * Create a map from a process name to the custom application class for this process, 1166 * which comes from <processes><process android:name="xxx">. 1167 * 1168 * The original information is stored in {@link #processes}, but it's stored in 1169 * a form of: [process name] -[1:N]-> [package name] -[1:N]-> [class name]. 1170 * We scan it and collect the process names and their app class names, only for this package. 1171 * 1172 * The resulting map only contains processes with a custom application class set. 1173 */ 1174 @Nullable 1175 private ArrayMap<String, String> buildAppClassNamesByProcess() { 1176 if (ArrayUtils.size(processes) == 0) { 1177 return null; 1178 } 1179 final ArrayMap<String, String> ret = new ArrayMap<>(4); 1180 for (String processName : processes.keySet()) { 1181 final ParsedProcess process = processes.get(processName); 1182 final ArrayMap<String, String> appClassesByPackage = 1183 process.getAppClassNamesByPackage(); 1184 1185 for (int i = 0; i < appClassesByPackage.size(); i++) { 1186 final String packageName = appClassesByPackage.keyAt(i); 1187 1188 if (this.packageName.equals(packageName)) { 1189 final String appClassName = appClassesByPackage.valueAt(i); 1190 if (!TextUtils.isEmpty(appClassName)) { 1191 ret.put(processName, appClassName); 1192 } 1193 } 1194 } 1195 } 1196 return ret; 1197 } 1198 1199 @Override 1200 public int describeContents() { 1201 return 0; 1202 } 1203 1204 @Override 1205 public void writeToParcel(Parcel dest, int flags) { 1206 sForBoolean.parcel(this.supportsSmallScreens, dest, flags); 1207 sForBoolean.parcel(this.supportsNormalScreens, dest, flags); 1208 sForBoolean.parcel(this.supportsLargeScreens, dest, flags); 1209 sForBoolean.parcel(this.supportsExtraLargeScreens, dest, flags); 1210 sForBoolean.parcel(this.resizeable, dest, flags); 1211 sForBoolean.parcel(this.anyDensity, dest, flags); 1212 dest.writeInt(this.versionCode); 1213 dest.writeInt(this.versionCodeMajor); 1214 dest.writeInt(this.baseRevisionCode); 1215 sForInternedString.parcel(this.versionName, dest, flags); 1216 dest.writeInt(this.compileSdkVersion); 1217 dest.writeString(this.compileSdkVersionCodeName); 1218 sForInternedString.parcel(this.packageName, dest, flags); 1219 dest.writeString(this.mBaseApkPath); 1220 dest.writeString(this.restrictedAccountType); 1221 dest.writeString(this.requiredAccountType); 1222 sForInternedString.parcel(this.overlayTarget, dest, flags); 1223 dest.writeString(this.overlayTargetOverlayableName); 1224 dest.writeString(this.overlayCategory); 1225 dest.writeInt(this.overlayPriority); 1226 sForInternedStringValueMap.parcel(this.overlayables, dest, flags); 1227 sForInternedString.parcel(this.sdkLibName, dest, flags); 1228 dest.writeInt(this.sdkLibVersionMajor); 1229 sForInternedString.parcel(this.staticSharedLibName, dest, flags); 1230 dest.writeLong(this.staticSharedLibVersion); 1231 sForInternedStringList.parcel(this.libraryNames, dest, flags); 1232 sForInternedStringList.parcel(this.usesLibraries, dest, flags); 1233 sForInternedStringList.parcel(this.usesOptionalLibraries, dest, flags); 1234 sForInternedStringList.parcel(this.usesNativeLibraries, dest, flags); 1235 sForInternedStringList.parcel(this.usesOptionalNativeLibraries, dest, flags); 1236 1237 sForInternedStringList.parcel(this.usesStaticLibraries, dest, flags); 1238 dest.writeLongArray(this.usesStaticLibrariesVersions); 1239 if (this.usesStaticLibrariesCertDigests == null) { 1240 dest.writeInt(-1); 1241 } else { 1242 dest.writeInt(this.usesStaticLibrariesCertDigests.length); 1243 for (int index = 0; index < this.usesStaticLibrariesCertDigests.length; index++) { 1244 dest.writeStringArray(this.usesStaticLibrariesCertDigests[index]); 1245 } 1246 } 1247 1248 sForInternedStringList.parcel(this.usesSdkLibraries, dest, flags); 1249 dest.writeLongArray(this.usesSdkLibrariesVersionsMajor); 1250 if (this.usesSdkLibrariesCertDigests == null) { 1251 dest.writeInt(-1); 1252 } else { 1253 dest.writeInt(this.usesSdkLibrariesCertDigests.length); 1254 for (int index = 0; index < this.usesSdkLibrariesCertDigests.length; index++) { 1255 dest.writeStringArray(this.usesSdkLibrariesCertDigests[index]); 1256 } 1257 } 1258 1259 sForInternedString.parcel(this.sharedUserId, dest, flags); 1260 dest.writeInt(this.sharedUserLabel); 1261 dest.writeTypedList(this.configPreferences); 1262 dest.writeTypedList(this.reqFeatures); 1263 dest.writeTypedList(this.featureGroups); 1264 dest.writeByteArray(this.restrictUpdateHash); 1265 dest.writeStringList(this.originalPackages); 1266 sForInternedStringList.parcel(this.adoptPermissions, dest, flags); 1267 sForInternedStringList.parcel(this.requestedPermissions, dest, flags); 1268 ParsingUtils.writeParcelableList(dest, this.usesPermissions); 1269 sForInternedStringList.parcel(this.implicitPermissions, dest, flags); 1270 sForStringSet.parcel(this.upgradeKeySets, dest, flags); 1271 ParsingPackageUtils.writeKeySetMapping(dest, this.keySetMapping); 1272 sForInternedStringList.parcel(this.protectedBroadcasts, dest, flags); 1273 ParsingUtils.writeParcelableList(dest, this.activities); 1274 ParsingUtils.writeParcelableList(dest, this.apexSystemServices); 1275 ParsingUtils.writeParcelableList(dest, this.receivers); 1276 ParsingUtils.writeParcelableList(dest, this.services); 1277 ParsingUtils.writeParcelableList(dest, this.providers); 1278 ParsingUtils.writeParcelableList(dest, this.attributions); 1279 ParsingUtils.writeParcelableList(dest, this.permissions); 1280 ParsingUtils.writeParcelableList(dest, this.permissionGroups); 1281 ParsingUtils.writeParcelableList(dest, this.instrumentations); 1282 sForIntentInfoPairs.parcel(this.preferredActivityFilters, dest, flags); 1283 dest.writeMap(this.processes); 1284 dest.writeBundle(this.metaData); 1285 sForInternedString.parcel(this.volumeUuid, dest, flags); 1286 dest.writeParcelable(this.signingDetails, flags); 1287 dest.writeString(this.mPath); 1288 dest.writeTypedList(this.queriesIntents, flags); 1289 sForInternedStringList.parcel(this.queriesPackages, dest, flags); 1290 sForInternedStringSet.parcel(this.queriesProviders, dest, flags); 1291 dest.writeString(this.appComponentFactory); 1292 dest.writeString(this.backupAgentName); 1293 dest.writeInt(this.banner); 1294 dest.writeInt(this.category); 1295 dest.writeString(this.classLoaderName); 1296 dest.writeString(this.className); 1297 dest.writeInt(this.compatibleWidthLimitDp); 1298 dest.writeInt(this.descriptionRes); 1299 dest.writeInt(this.fullBackupContent); 1300 dest.writeInt(this.dataExtractionRules); 1301 dest.writeInt(this.iconRes); 1302 dest.writeInt(this.installLocation); 1303 dest.writeInt(this.labelRes); 1304 dest.writeInt(this.largestWidthLimitDp); 1305 dest.writeInt(this.logo); 1306 dest.writeString(this.manageSpaceActivityName); 1307 dest.writeFloat(this.maxAspectRatio); 1308 dest.writeFloat(this.minAspectRatio); 1309 dest.writeInt(this.minSdkVersion); 1310 dest.writeInt(this.maxSdkVersion); 1311 dest.writeInt(this.networkSecurityConfigRes); 1312 dest.writeCharSequence(this.nonLocalizedLabel); 1313 dest.writeString(this.permission); 1314 dest.writeString(this.processName); 1315 dest.writeInt(this.requiresSmallestWidthDp); 1316 dest.writeInt(this.roundIconRes); 1317 dest.writeInt(this.targetSandboxVersion); 1318 dest.writeInt(this.targetSdkVersion); 1319 dest.writeString(this.taskAffinity); 1320 dest.writeInt(this.theme); 1321 dest.writeInt(this.uiOptions); 1322 dest.writeString(this.zygotePreloadName); 1323 dest.writeStringArray(this.splitClassLoaderNames); 1324 dest.writeStringArray(this.splitCodePaths); 1325 dest.writeSparseArray(this.splitDependencies); 1326 dest.writeIntArray(this.splitFlags); 1327 dest.writeStringArray(this.splitNames); 1328 dest.writeIntArray(this.splitRevisionCodes); 1329 sForBoolean.parcel(this.resizeableActivity, dest, flags); 1330 dest.writeInt(this.autoRevokePermissions); 1331 dest.writeArraySet(this.mimeGroups); 1332 dest.writeInt(this.gwpAsanMode); 1333 dest.writeSparseIntArray(this.minExtensionVersions); 1334 dest.writeLong(this.mBooleans); 1335 dest.writeMap(this.mProperties); 1336 dest.writeInt(this.memtagMode); 1337 dest.writeInt(this.nativeHeapZeroInitialized); 1338 sForBoolean.parcel(this.requestRawExternalStorageAccess, dest, flags); 1339 dest.writeInt(this.mLocaleConfigRes); 1340 sForStringSet.parcel(mKnownActivityEmbeddingCerts, dest, flags); 1341 } 1342 1343 public ParsingPackageImpl(Parcel in) { 1344 // We use the boot classloader for all classes that we load. 1345 final ClassLoader boot = Object.class.getClassLoader(); 1346 this.supportsSmallScreens = sForBoolean.unparcel(in); 1347 this.supportsNormalScreens = sForBoolean.unparcel(in); 1348 this.supportsLargeScreens = sForBoolean.unparcel(in); 1349 this.supportsExtraLargeScreens = sForBoolean.unparcel(in); 1350 this.resizeable = sForBoolean.unparcel(in); 1351 this.anyDensity = sForBoolean.unparcel(in); 1352 this.versionCode = in.readInt(); 1353 this.versionCodeMajor = in.readInt(); 1354 this.baseRevisionCode = in.readInt(); 1355 this.versionName = sForInternedString.unparcel(in); 1356 this.compileSdkVersion = in.readInt(); 1357 this.compileSdkVersionCodeName = in.readString(); 1358 this.packageName = sForInternedString.unparcel(in); 1359 this.mBaseApkPath = in.readString(); 1360 this.restrictedAccountType = in.readString(); 1361 this.requiredAccountType = in.readString(); 1362 this.overlayTarget = sForInternedString.unparcel(in); 1363 this.overlayTargetOverlayableName = in.readString(); 1364 this.overlayCategory = in.readString(); 1365 this.overlayPriority = in.readInt(); 1366 this.overlayables = sForInternedStringValueMap.unparcel(in); 1367 this.sdkLibName = sForInternedString.unparcel(in); 1368 this.sdkLibVersionMajor = in.readInt(); 1369 this.staticSharedLibName = sForInternedString.unparcel(in); 1370 this.staticSharedLibVersion = in.readLong(); 1371 this.libraryNames = sForInternedStringList.unparcel(in); 1372 this.usesLibraries = sForInternedStringList.unparcel(in); 1373 this.usesOptionalLibraries = sForInternedStringList.unparcel(in); 1374 this.usesNativeLibraries = sForInternedStringList.unparcel(in); 1375 this.usesOptionalNativeLibraries = sForInternedStringList.unparcel(in); 1376 1377 this.usesStaticLibraries = sForInternedStringList.unparcel(in); 1378 this.usesStaticLibrariesVersions = in.createLongArray(); 1379 { 1380 int digestsSize = in.readInt(); 1381 if (digestsSize >= 0) { 1382 this.usesStaticLibrariesCertDigests = new String[digestsSize][]; 1383 for (int index = 0; index < digestsSize; index++) { 1384 this.usesStaticLibrariesCertDigests[index] = sForInternedStringArray.unparcel( 1385 in); 1386 } 1387 } 1388 } 1389 1390 this.usesSdkLibraries = sForInternedStringList.unparcel(in); 1391 this.usesSdkLibrariesVersionsMajor = in.createLongArray(); 1392 { 1393 int digestsSize = in.readInt(); 1394 if (digestsSize >= 0) { 1395 this.usesSdkLibrariesCertDigests = new String[digestsSize][]; 1396 for (int index = 0; index < digestsSize; index++) { 1397 this.usesSdkLibrariesCertDigests[index] = sForInternedStringArray.unparcel(in); 1398 } 1399 } 1400 } 1401 1402 this.sharedUserId = sForInternedString.unparcel(in); 1403 this.sharedUserLabel = in.readInt(); 1404 this.configPreferences = in.createTypedArrayList(ConfigurationInfo.CREATOR); 1405 this.reqFeatures = in.createTypedArrayList(FeatureInfo.CREATOR); 1406 this.featureGroups = in.createTypedArrayList(FeatureGroupInfo.CREATOR); 1407 this.restrictUpdateHash = in.createByteArray(); 1408 this.originalPackages = in.createStringArrayList(); 1409 this.adoptPermissions = sForInternedStringList.unparcel(in); 1410 this.requestedPermissions = sForInternedStringList.unparcel(in); 1411 this.usesPermissions = ParsingUtils.createTypedInterfaceList(in, 1412 ParsedUsesPermissionImpl.CREATOR); 1413 this.implicitPermissions = sForInternedStringList.unparcel(in); 1414 this.upgradeKeySets = sForStringSet.unparcel(in); 1415 this.keySetMapping = ParsingPackageUtils.readKeySetMapping(in); 1416 this.protectedBroadcasts = sForInternedStringList.unparcel(in); 1417 1418 this.activities = ParsingUtils.createTypedInterfaceList(in, ParsedActivityImpl.CREATOR); 1419 this.apexSystemServices = ParsingUtils.createTypedInterfaceList(in, 1420 ParsedApexSystemServiceImpl.CREATOR); 1421 this.receivers = ParsingUtils.createTypedInterfaceList(in, ParsedActivityImpl.CREATOR); 1422 this.services = ParsingUtils.createTypedInterfaceList(in, ParsedServiceImpl.CREATOR); 1423 this.providers = ParsingUtils.createTypedInterfaceList(in, ParsedProviderImpl.CREATOR); 1424 this.attributions = ParsingUtils.createTypedInterfaceList(in, 1425 ParsedAttributionImpl.CREATOR); 1426 this.permissions = ParsingUtils.createTypedInterfaceList(in, ParsedPermissionImpl.CREATOR); 1427 this.permissionGroups = ParsingUtils.createTypedInterfaceList(in, 1428 ParsedPermissionGroupImpl.CREATOR); 1429 this.instrumentations = ParsingUtils.createTypedInterfaceList(in, 1430 ParsedInstrumentationImpl.CREATOR); 1431 this.preferredActivityFilters = sForIntentInfoPairs.unparcel(in); 1432 this.processes = in.readHashMap(ParsedProcess.class.getClassLoader()); 1433 this.metaData = in.readBundle(boot); 1434 this.volumeUuid = sForInternedString.unparcel(in); 1435 this.signingDetails = in.readParcelable(boot); 1436 this.mPath = in.readString(); 1437 this.queriesIntents = in.createTypedArrayList(Intent.CREATOR); 1438 this.queriesPackages = sForInternedStringList.unparcel(in); 1439 this.queriesProviders = sForInternedStringSet.unparcel(in); 1440 this.appComponentFactory = in.readString(); 1441 this.backupAgentName = in.readString(); 1442 this.banner = in.readInt(); 1443 this.category = in.readInt(); 1444 this.classLoaderName = in.readString(); 1445 this.className = in.readString(); 1446 this.compatibleWidthLimitDp = in.readInt(); 1447 this.descriptionRes = in.readInt(); 1448 this.fullBackupContent = in.readInt(); 1449 this.dataExtractionRules = in.readInt(); 1450 this.iconRes = in.readInt(); 1451 this.installLocation = in.readInt(); 1452 this.labelRes = in.readInt(); 1453 this.largestWidthLimitDp = in.readInt(); 1454 this.logo = in.readInt(); 1455 this.manageSpaceActivityName = in.readString(); 1456 this.maxAspectRatio = in.readFloat(); 1457 this.minAspectRatio = in.readFloat(); 1458 this.minSdkVersion = in.readInt(); 1459 this.maxSdkVersion = in.readInt(); 1460 this.networkSecurityConfigRes = in.readInt(); 1461 this.nonLocalizedLabel = in.readCharSequence(); 1462 this.permission = in.readString(); 1463 this.processName = in.readString(); 1464 this.requiresSmallestWidthDp = in.readInt(); 1465 this.roundIconRes = in.readInt(); 1466 this.targetSandboxVersion = in.readInt(); 1467 this.targetSdkVersion = in.readInt(); 1468 this.taskAffinity = in.readString(); 1469 this.theme = in.readInt(); 1470 this.uiOptions = in.readInt(); 1471 this.zygotePreloadName = in.readString(); 1472 this.splitClassLoaderNames = in.createStringArray(); 1473 this.splitCodePaths = in.createStringArray(); 1474 this.splitDependencies = in.readSparseArray(boot); 1475 this.splitFlags = in.createIntArray(); 1476 this.splitNames = in.createStringArray(); 1477 this.splitRevisionCodes = in.createIntArray(); 1478 this.resizeableActivity = sForBoolean.unparcel(in); 1479 1480 this.autoRevokePermissions = in.readInt(); 1481 this.mimeGroups = (ArraySet<String>) in.readArraySet(boot); 1482 this.gwpAsanMode = in.readInt(); 1483 this.minExtensionVersions = in.readSparseIntArray(); 1484 this.mBooleans = in.readLong(); 1485 this.mProperties = in.readHashMap(boot); 1486 this.memtagMode = in.readInt(); 1487 this.nativeHeapZeroInitialized = in.readInt(); 1488 this.requestRawExternalStorageAccess = sForBoolean.unparcel(in); 1489 this.mLocaleConfigRes = in.readInt(); 1490 this.mKnownActivityEmbeddingCerts = sForStringSet.unparcel(in); 1491 assignDerivedFields(); 1492 } 1493 1494 public static final Parcelable.Creator<ParsingPackageImpl> CREATOR = 1495 new Parcelable.Creator<ParsingPackageImpl>() { 1496 @Override 1497 public ParsingPackageImpl createFromParcel(Parcel source) { 1498 return new ParsingPackageImpl(source); 1499 } 1500 1501 @Override 1502 public ParsingPackageImpl[] newArray(int size) { 1503 return new ParsingPackageImpl[size]; 1504 } 1505 }; 1506 1507 @Override 1508 public int getVersionCode() { 1509 return versionCode; 1510 } 1511 1512 @Override 1513 public int getVersionCodeMajor() { 1514 return versionCodeMajor; 1515 } 1516 1517 @Override 1518 public long getLongVersionCode() { 1519 return mLongVersionCode; 1520 } 1521 1522 @Override 1523 public int getBaseRevisionCode() { 1524 return baseRevisionCode; 1525 } 1526 1527 @Nullable 1528 @Override 1529 public String getVersionName() { 1530 return versionName; 1531 } 1532 1533 @Override 1534 public int getCompileSdkVersion() { 1535 return compileSdkVersion; 1536 } 1537 1538 @Nullable 1539 @Override 1540 public String getCompileSdkVersionCodeName() { 1541 return compileSdkVersionCodeName; 1542 } 1543 1544 @NonNull 1545 @Override 1546 public String getPackageName() { 1547 return packageName; 1548 } 1549 1550 @NonNull 1551 @Override 1552 public String getBaseApkPath() { 1553 return mBaseApkPath; 1554 } 1555 1556 @Override 1557 public boolean isRequiredForAllUsers() { 1558 return getBoolean(Booleans.REQUIRED_FOR_ALL_USERS); 1559 } 1560 1561 @Nullable 1562 @Override 1563 public String getRestrictedAccountType() { 1564 return restrictedAccountType; 1565 } 1566 1567 @Nullable 1568 @Override 1569 public String getRequiredAccountType() { 1570 return requiredAccountType; 1571 } 1572 1573 @Nullable 1574 @Override 1575 public String getOverlayTarget() { 1576 return overlayTarget; 1577 } 1578 1579 @Nullable 1580 @Override 1581 public String getOverlayTargetOverlayableName() { 1582 return overlayTargetOverlayableName; 1583 } 1584 1585 @Nullable 1586 @Override 1587 public String getOverlayCategory() { 1588 return overlayCategory; 1589 } 1590 1591 @Override 1592 public int getOverlayPriority() { 1593 return overlayPriority; 1594 } 1595 1596 @Override 1597 public boolean isOverlayIsStatic() { 1598 return getBoolean(Booleans.OVERLAY_IS_STATIC); 1599 } 1600 1601 @NonNull 1602 @Override 1603 public Map<String,String> getOverlayables() { 1604 return overlayables; 1605 } 1606 1607 @Nullable 1608 @Override 1609 public String getSdkLibName() { 1610 return sdkLibName; 1611 } 1612 1613 @Override 1614 public int getSdkLibVersionMajor() { 1615 return sdkLibVersionMajor; 1616 } 1617 1618 @Nullable 1619 @Override 1620 public String getStaticSharedLibName() { 1621 return staticSharedLibName; 1622 } 1623 1624 @Override 1625 public long getStaticSharedLibVersion() { 1626 return staticSharedLibVersion; 1627 } 1628 1629 @NonNull 1630 @Override 1631 public List<String> getLibraryNames() { 1632 return libraryNames; 1633 } 1634 1635 @NonNull 1636 @Override 1637 public List<String> getUsesLibraries() { 1638 return usesLibraries; 1639 } 1640 1641 @NonNull 1642 @Override 1643 public List<String> getUsesOptionalLibraries() { 1644 return usesOptionalLibraries; 1645 } 1646 1647 @NonNull 1648 @Override 1649 public List<String> getUsesNativeLibraries() { 1650 return usesNativeLibraries; 1651 } 1652 1653 @NonNull 1654 @Override 1655 public List<String> getUsesOptionalNativeLibraries() { 1656 return usesOptionalNativeLibraries; 1657 } 1658 1659 @NonNull 1660 @Override 1661 public List<String> getUsesStaticLibraries() { 1662 return usesStaticLibraries; 1663 } 1664 1665 @Nullable 1666 @Override 1667 public long[] getUsesStaticLibrariesVersions() { 1668 return usesStaticLibrariesVersions; 1669 } 1670 1671 @Nullable 1672 @Override 1673 public String[][] getUsesStaticLibrariesCertDigests() { 1674 return usesStaticLibrariesCertDigests; 1675 } 1676 1677 @NonNull 1678 @Override 1679 public List<String> getUsesSdkLibraries() { return usesSdkLibraries; } 1680 1681 @Nullable 1682 @Override 1683 public long[] getUsesSdkLibrariesVersionsMajor() { return usesSdkLibrariesVersionsMajor; } 1684 1685 @Nullable 1686 @Override 1687 public String[][] getUsesSdkLibrariesCertDigests() { return usesSdkLibrariesCertDigests; } 1688 1689 @Nullable 1690 @Override 1691 public String getSharedUserId() { 1692 return sharedUserId; 1693 } 1694 1695 @Override 1696 public int getSharedUserLabel() { 1697 return sharedUserLabel; 1698 } 1699 1700 @NonNull 1701 @Override 1702 public List<ConfigurationInfo> getConfigPreferences() { 1703 return configPreferences; 1704 } 1705 1706 @NonNull 1707 @Override 1708 public List<FeatureInfo> getRequestedFeatures() { 1709 return reqFeatures; 1710 } 1711 1712 @NonNull 1713 @Override 1714 public List<FeatureGroupInfo> getFeatureGroups() { 1715 return featureGroups; 1716 } 1717 1718 @Nullable 1719 @Override 1720 public byte[] getRestrictUpdateHash() { 1721 return restrictUpdateHash; 1722 } 1723 1724 @NonNull 1725 @Override 1726 public List<String> getOriginalPackages() { 1727 return originalPackages; 1728 } 1729 1730 @NonNull 1731 @Override 1732 public List<String> getAdoptPermissions() { 1733 return adoptPermissions; 1734 } 1735 1736 /** 1737 * @deprecated consider migrating to {@link #getUsesPermissions} which has 1738 * more parsed details, such as flags 1739 */ 1740 @NonNull 1741 @Override 1742 @Deprecated 1743 public List<String> getRequestedPermissions() { 1744 return requestedPermissions; 1745 } 1746 1747 @NonNull 1748 @Override 1749 public List<ParsedUsesPermission> getUsesPermissions() { 1750 return usesPermissions; 1751 } 1752 1753 @NonNull 1754 @Override 1755 public List<String> getImplicitPermissions() { 1756 return implicitPermissions; 1757 } 1758 1759 @NonNull 1760 @Override 1761 public Map<String, Property> getProperties() { 1762 return mProperties; 1763 } 1764 1765 @NonNull 1766 @Override 1767 public Set<String> getUpgradeKeySets() { 1768 return upgradeKeySets; 1769 } 1770 1771 @NonNull 1772 @Override 1773 public Map<String,ArraySet<PublicKey>> getKeySetMapping() { 1774 return keySetMapping; 1775 } 1776 1777 @NonNull 1778 @Override 1779 public List<String> getProtectedBroadcasts() { 1780 return protectedBroadcasts; 1781 } 1782 1783 @NonNull 1784 @Override 1785 public List<ParsedActivity> getActivities() { 1786 return activities; 1787 } 1788 1789 @NonNull 1790 @Override 1791 public List<ParsedApexSystemService> getApexSystemServices() { 1792 return apexSystemServices; 1793 } 1794 1795 @NonNull 1796 @Override 1797 public List<ParsedActivity> getReceivers() { 1798 return receivers; 1799 } 1800 1801 @NonNull 1802 @Override 1803 public List<ParsedService> getServices() { 1804 return services; 1805 } 1806 1807 @NonNull 1808 @Override 1809 public List<ParsedProvider> getProviders() { 1810 return providers; 1811 } 1812 1813 @NonNull 1814 @Override 1815 public List<ParsedAttribution> getAttributions() { 1816 return attributions; 1817 } 1818 1819 @NonNull 1820 @Override 1821 public List<ParsedPermission> getPermissions() { 1822 return permissions; 1823 } 1824 1825 @NonNull 1826 @Override 1827 public List<ParsedPermissionGroup> getPermissionGroups() { 1828 return permissionGroups; 1829 } 1830 1831 @NonNull 1832 @Override 1833 public List<ParsedInstrumentation> getInstrumentations() { 1834 return instrumentations; 1835 } 1836 1837 @NonNull 1838 @Override 1839 public List<Pair<String,ParsedIntentInfo>> getPreferredActivityFilters() { 1840 return preferredActivityFilters; 1841 } 1842 1843 @NonNull 1844 @Override 1845 public Map<String,ParsedProcess> getProcesses() { 1846 return processes; 1847 } 1848 1849 @Nullable 1850 @Override 1851 public Bundle getMetaData() { 1852 return metaData; 1853 } 1854 1855 private void addMimeGroupsFromComponent(ParsedComponent component) { 1856 for (int i = component.getIntents().size() - 1; i >= 0; i--) { 1857 IntentFilter filter = component.getIntents().get(i).getIntentFilter(); 1858 for (int groupIndex = filter.countMimeGroups() - 1; groupIndex >= 0; groupIndex--) { 1859 if (mimeGroups != null && mimeGroups.size() > 500) { 1860 throw new IllegalStateException("Max limit on number of MIME Groups reached"); 1861 } 1862 mimeGroups = ArrayUtils.add(mimeGroups, filter.getMimeGroup(groupIndex)); 1863 } 1864 } 1865 } 1866 1867 @Override 1868 @Nullable 1869 public Set<String> getMimeGroups() { 1870 return mimeGroups; 1871 } 1872 1873 @Nullable 1874 @Override 1875 public String getVolumeUuid() { 1876 return volumeUuid; 1877 } 1878 1879 @Nullable 1880 @Override 1881 public SigningDetails getSigningDetails() { 1882 return signingDetails; 1883 } 1884 1885 @NonNull 1886 @Override 1887 public String getPath() { 1888 return mPath; 1889 } 1890 1891 @Override 1892 public boolean isUse32BitAbi() { 1893 return getBoolean(Booleans.USE_32_BIT_ABI); 1894 } 1895 1896 @Override 1897 public boolean isVisibleToInstantApps() { 1898 return getBoolean(Booleans.VISIBLE_TO_INSTANT_APPS); 1899 } 1900 1901 @Override 1902 public boolean isForceQueryable() { 1903 return getBoolean(Booleans.FORCE_QUERYABLE); 1904 } 1905 1906 @NonNull 1907 @Override 1908 public List<Intent> getQueriesIntents() { 1909 return queriesIntents; 1910 } 1911 1912 @NonNull 1913 @Override 1914 public List<String> getQueriesPackages() { 1915 return queriesPackages; 1916 } 1917 1918 @NonNull 1919 @Override 1920 public Set<String> getQueriesProviders() { 1921 return queriesProviders; 1922 } 1923 1924 @NonNull 1925 @Override 1926 public String[] getSplitClassLoaderNames() { 1927 return splitClassLoaderNames == null ? EmptyArray.STRING : splitClassLoaderNames; 1928 } 1929 1930 @NonNull 1931 @Override 1932 public String[] getSplitCodePaths() { 1933 return splitCodePaths == null ? EmptyArray.STRING : splitCodePaths; 1934 } 1935 1936 @Nullable 1937 @Override 1938 public SparseArray<int[]> getSplitDependencies() { 1939 return splitDependencies == null ? EMPTY_INT_ARRAY_SPARSE_ARRAY : splitDependencies; 1940 } 1941 1942 @Nullable 1943 @Override 1944 public int[] getSplitFlags() { 1945 return splitFlags; 1946 } 1947 1948 @NonNull 1949 @Override 1950 public String[] getSplitNames() { 1951 return splitNames == null ? EmptyArray.STRING : splitNames; 1952 } 1953 1954 @NonNull 1955 @Override 1956 public int[] getSplitRevisionCodes() { 1957 return splitRevisionCodes == null ? EmptyArray.INT : splitRevisionCodes; 1958 } 1959 1960 @Nullable 1961 @Override 1962 public String getAppComponentFactory() { 1963 return appComponentFactory; 1964 } 1965 1966 @Nullable 1967 @Override 1968 public String getBackupAgentName() { 1969 return backupAgentName; 1970 } 1971 1972 @Override 1973 public int getBanner() { 1974 return banner; 1975 } 1976 1977 @Override 1978 public int getCategory() { 1979 return category; 1980 } 1981 1982 @Nullable 1983 @Override 1984 public String getClassLoaderName() { 1985 return classLoaderName; 1986 } 1987 1988 @Nullable 1989 @Override 1990 public String getClassName() { 1991 return className; 1992 } 1993 1994 @Override 1995 public int getCompatibleWidthLimitDp() { 1996 return compatibleWidthLimitDp; 1997 } 1998 1999 @Override 2000 public int getDescriptionRes() { 2001 return descriptionRes; 2002 } 2003 2004 @Override 2005 public boolean isEnabled() { 2006 return getBoolean(Booleans.ENABLED); 2007 } 2008 2009 @Override 2010 public boolean isCrossProfile() { 2011 return getBoolean(Booleans.CROSS_PROFILE); 2012 } 2013 2014 @Override 2015 public int getFullBackupContent() { 2016 return fullBackupContent; 2017 } 2018 2019 @Override 2020 public int getDataExtractionRules() { 2021 return dataExtractionRules; 2022 } 2023 2024 @Override 2025 public int getIconRes() { 2026 return iconRes; 2027 } 2028 2029 @Override 2030 public int getInstallLocation() { 2031 return installLocation; 2032 } 2033 2034 @Override 2035 public int getLabelRes() { 2036 return labelRes; 2037 } 2038 2039 @Override 2040 public int getLargestWidthLimitDp() { 2041 return largestWidthLimitDp; 2042 } 2043 2044 @Override 2045 public int getLogo() { 2046 return logo; 2047 } 2048 2049 @Nullable 2050 @Override 2051 public String getManageSpaceActivityName() { 2052 return manageSpaceActivityName; 2053 } 2054 2055 @Override 2056 public float getMaxAspectRatio() { 2057 return maxAspectRatio; 2058 } 2059 2060 @Override 2061 public float getMinAspectRatio() { 2062 return minAspectRatio; 2063 } 2064 2065 @Nullable 2066 @Override 2067 public SparseIntArray getMinExtensionVersions() { 2068 return minExtensionVersions; 2069 } 2070 2071 @Override 2072 public int getMinSdkVersion() { 2073 return minSdkVersion; 2074 } 2075 2076 @Override 2077 public int getMaxSdkVersion() { 2078 return maxSdkVersion; 2079 } 2080 2081 @Override 2082 public int getNetworkSecurityConfigRes() { 2083 return networkSecurityConfigRes; 2084 } 2085 2086 @Nullable 2087 @Override 2088 public CharSequence getNonLocalizedLabel() { 2089 return nonLocalizedLabel; 2090 } 2091 2092 @Nullable 2093 @Override 2094 public String getPermission() { 2095 return permission; 2096 } 2097 2098 @Override 2099 public int getRequiresSmallestWidthDp() { 2100 return requiresSmallestWidthDp; 2101 } 2102 2103 @Override 2104 public int getRoundIconRes() { 2105 return roundIconRes; 2106 } 2107 2108 @Override 2109 public int getTargetSdkVersion() { 2110 return targetSdkVersion; 2111 } 2112 2113 @Override 2114 public int getTargetSandboxVersion() { 2115 return targetSandboxVersion; 2116 } 2117 2118 @Nullable 2119 @Override 2120 public String getTaskAffinity() { 2121 return taskAffinity; 2122 } 2123 2124 @Override 2125 public int getTheme() { 2126 return theme; 2127 } 2128 2129 @Override 2130 public int getUiOptions() { 2131 return uiOptions; 2132 } 2133 2134 @Nullable 2135 @Override 2136 public String getZygotePreloadName() { 2137 return zygotePreloadName; 2138 } 2139 2140 @Override 2141 public boolean isExternalStorage() { 2142 return getBoolean(Booleans.EXTERNAL_STORAGE); 2143 } 2144 2145 @Override 2146 public boolean isBaseHardwareAccelerated() { 2147 return getBoolean(Booleans.BASE_HARDWARE_ACCELERATED); 2148 } 2149 2150 @Override 2151 public boolean isAllowBackup() { 2152 return getBoolean(Booleans.ALLOW_BACKUP); 2153 } 2154 2155 @Override 2156 public boolean isKillAfterRestore() { 2157 return getBoolean(Booleans.KILL_AFTER_RESTORE); 2158 } 2159 2160 @Override 2161 public boolean isRestoreAnyVersion() { 2162 return getBoolean(Booleans.RESTORE_ANY_VERSION); 2163 } 2164 2165 @Override 2166 public boolean isFullBackupOnly() { 2167 return getBoolean(Booleans.FULL_BACKUP_ONLY); 2168 } 2169 2170 @Override 2171 public boolean isPersistent() { 2172 return getBoolean(Booleans.PERSISTENT); 2173 } 2174 2175 @Override 2176 public boolean isDebuggable() { 2177 return getBoolean(Booleans.DEBUGGABLE); 2178 } 2179 2180 @Override 2181 public boolean isVmSafeMode() { 2182 return getBoolean(Booleans.VM_SAFE_MODE); 2183 } 2184 2185 @Override 2186 public boolean isHasCode() { 2187 return getBoolean(Booleans.HAS_CODE); 2188 } 2189 2190 @Override 2191 public boolean isAllowTaskReparenting() { 2192 return getBoolean(Booleans.ALLOW_TASK_REPARENTING); 2193 } 2194 2195 @Override 2196 public boolean isAllowClearUserData() { 2197 return getBoolean(Booleans.ALLOW_CLEAR_USER_DATA); 2198 } 2199 2200 @Override 2201 public boolean isLargeHeap() { 2202 return getBoolean(Booleans.LARGE_HEAP); 2203 } 2204 2205 @Override 2206 public boolean isUsesCleartextTraffic() { 2207 return getBoolean(Booleans.USES_CLEARTEXT_TRAFFIC); 2208 } 2209 2210 @Override 2211 public boolean isSupportsRtl() { 2212 return getBoolean(Booleans.SUPPORTS_RTL); 2213 } 2214 2215 @Override 2216 public boolean isTestOnly() { 2217 return getBoolean(Booleans.TEST_ONLY); 2218 } 2219 2220 @Override 2221 public boolean isMultiArch() { 2222 return getBoolean(Booleans.MULTI_ARCH); 2223 } 2224 2225 @Override 2226 public boolean isExtractNativeLibs() { 2227 return getBoolean(Booleans.EXTRACT_NATIVE_LIBS); 2228 } 2229 2230 @Override 2231 public boolean isGame() { 2232 return getBoolean(Booleans.GAME); 2233 } 2234 2235 /** 2236 * @see ParsingPackageRead#getResizeableActivity() 2237 */ 2238 @Nullable 2239 @Override 2240 public Boolean getResizeableActivity() { 2241 return resizeableActivity; 2242 } 2243 2244 @Override 2245 public boolean isStaticSharedLibrary() { 2246 return getBoolean(Booleans.STATIC_SHARED_LIBRARY); 2247 } 2248 2249 @Override 2250 public boolean isSdkLibrary() { 2251 return getBoolean(Booleans.SDK_LIBRARY); 2252 } 2253 2254 @Override 2255 public boolean isOverlay() { 2256 return getBoolean(Booleans.OVERLAY); 2257 } 2258 2259 @Override 2260 public boolean isIsolatedSplitLoading() { 2261 return getBoolean(Booleans.ISOLATED_SPLIT_LOADING); 2262 } 2263 2264 @Override 2265 public boolean isHasDomainUrls() { 2266 return getBoolean(Booleans.HAS_DOMAIN_URLS); 2267 } 2268 2269 @Override 2270 public boolean isProfileableByShell() { 2271 return isProfileable() && getBoolean(Booleans.PROFILEABLE_BY_SHELL); 2272 } 2273 2274 @Override 2275 public boolean isProfileable() { 2276 return !getBoolean(Booleans.DISALLOW_PROFILING); 2277 } 2278 2279 @Override 2280 public boolean isBackupInForeground() { 2281 return getBoolean(Booleans.BACKUP_IN_FOREGROUND); 2282 } 2283 2284 @Override 2285 public boolean isUseEmbeddedDex() { 2286 return getBoolean(Booleans.USE_EMBEDDED_DEX); 2287 } 2288 2289 @Override 2290 public boolean isDefaultToDeviceProtectedStorage() { 2291 return getBoolean(Booleans.DEFAULT_TO_DEVICE_PROTECTED_STORAGE); 2292 } 2293 2294 @Override 2295 public boolean isDirectBootAware() { 2296 return getBoolean(Booleans.DIRECT_BOOT_AWARE); 2297 } 2298 2299 @ApplicationInfo.GwpAsanMode 2300 @Override 2301 public int getGwpAsanMode() { 2302 return gwpAsanMode; 2303 } 2304 2305 @ApplicationInfo.MemtagMode 2306 @Override 2307 public int getMemtagMode() { 2308 return memtagMode; 2309 } 2310 2311 @ApplicationInfo.NativeHeapZeroInitialized 2312 @Override 2313 public int getNativeHeapZeroInitialized() { 2314 return nativeHeapZeroInitialized; 2315 } 2316 2317 @Override 2318 public int getLocaleConfigRes() { 2319 return mLocaleConfigRes; 2320 } 2321 2322 @Nullable 2323 @Override 2324 public Boolean hasRequestRawExternalStorageAccess() { 2325 return requestRawExternalStorageAccess; 2326 } 2327 2328 @Override 2329 public boolean isPartiallyDirectBootAware() { 2330 return getBoolean(Booleans.PARTIALLY_DIRECT_BOOT_AWARE); 2331 } 2332 2333 @Override 2334 public boolean isResizeableActivityViaSdkVersion() { 2335 return getBoolean(Booleans.RESIZEABLE_ACTIVITY_VIA_SDK_VERSION); 2336 } 2337 2338 @Override 2339 public boolean isAllowClearUserDataOnFailedRestore() { 2340 return getBoolean(Booleans.ALLOW_CLEAR_USER_DATA_ON_FAILED_RESTORE); 2341 } 2342 2343 @Override 2344 public boolean isAllowAudioPlaybackCapture() { 2345 return getBoolean(Booleans.ALLOW_AUDIO_PLAYBACK_CAPTURE); 2346 } 2347 2348 @Override 2349 public boolean isRequestLegacyExternalStorage() { 2350 return getBoolean(Booleans.REQUEST_LEGACY_EXTERNAL_STORAGE); 2351 } 2352 2353 @Override 2354 public boolean isUsesNonSdkApi() { 2355 return getBoolean(Booleans.USES_NON_SDK_API); 2356 } 2357 2358 @Override 2359 public boolean isHasFragileUserData() { 2360 return getBoolean(Booleans.HAS_FRAGILE_USER_DATA); 2361 } 2362 2363 @Override 2364 public boolean isCantSaveState() { 2365 return getBoolean(Booleans.CANT_SAVE_STATE); 2366 } 2367 2368 @Override 2369 public boolean isAllowNativeHeapPointerTagging() { 2370 return getBoolean(Booleans.ALLOW_NATIVE_HEAP_POINTER_TAGGING); 2371 } 2372 2373 @Override 2374 public int getAutoRevokePermissions() { 2375 return autoRevokePermissions; 2376 } 2377 2378 @Override 2379 public boolean hasPreserveLegacyExternalStorage() { 2380 return getBoolean(Booleans.PRESERVE_LEGACY_EXTERNAL_STORAGE); 2381 } 2382 2383 @Override 2384 public boolean hasRequestForegroundServiceExemption() { 2385 return getBoolean(Booleans.REQUEST_FOREGROUND_SERVICE_EXEMPTION); 2386 } 2387 2388 @Override 2389 public boolean areAttributionsUserVisible() { 2390 return getBoolean(Booleans.ATTRIBUTIONS_ARE_USER_VISIBLE); 2391 } 2392 2393 @Override 2394 public boolean isResetEnabledSettingsOnAppDataCleared() { 2395 return getBoolean(Booleans.RESET_ENABLED_SETTINGS_ON_APP_DATA_CLEARED); 2396 } 2397 2398 @NonNull 2399 @Override 2400 public Set<String> getKnownActivityEmbeddingCerts() { 2401 return mKnownActivityEmbeddingCerts == null ? Collections.emptySet() 2402 : mKnownActivityEmbeddingCerts; 2403 } 2404 2405 @Override 2406 public boolean isOnBackInvokedCallbackEnabled() { 2407 return getBoolean(Booleans.ENABLE_ON_BACK_INVOKED_CALLBACK); 2408 } 2409 2410 @Override 2411 public boolean isLeavingSharedUid() { 2412 return getBoolean(Booleans.LEAVING_SHARED_UID); 2413 } 2414 2415 @Override 2416 public ParsingPackageImpl setBaseRevisionCode(int value) { 2417 baseRevisionCode = value; 2418 return this; 2419 } 2420 2421 @Override 2422 public ParsingPackageImpl setCompileSdkVersion(int value) { 2423 compileSdkVersion = value; 2424 return this; 2425 } 2426 2427 @Override 2428 public ParsingPackageImpl setRequiredForAllUsers(boolean value) { 2429 return setBoolean(Booleans.REQUIRED_FOR_ALL_USERS, value); 2430 } 2431 2432 @Override 2433 public ParsingPackageImpl setOverlayPriority(int value) { 2434 overlayPriority = value; 2435 return this; 2436 } 2437 2438 @Override 2439 public ParsingPackageImpl setOverlayIsStatic(boolean value) { 2440 return setBoolean(Booleans.OVERLAY_IS_STATIC, value); 2441 } 2442 2443 @Override 2444 public ParsingPackageImpl setStaticSharedLibVersion(long value) { 2445 staticSharedLibVersion = value; 2446 return this; 2447 } 2448 2449 @Override 2450 public ParsingPackageImpl setSharedUserLabel(int value) { 2451 sharedUserLabel = value; 2452 return this; 2453 } 2454 2455 @Override 2456 public ParsingPackageImpl setRestrictUpdateHash(@Nullable byte... value) { 2457 restrictUpdateHash = value; 2458 return this; 2459 } 2460 2461 @Override 2462 public ParsingPackageImpl setUpgradeKeySets(@NonNull Set<String> value) { 2463 upgradeKeySets = value; 2464 return this; 2465 } 2466 2467 @Override 2468 public ParsingPackageImpl setProcesses(@NonNull Map<String,ParsedProcess> value) { 2469 processes = value; 2470 return this; 2471 } 2472 2473 @Override 2474 public ParsingPackageImpl setMetaData(@Nullable Bundle value) { 2475 metaData = value; 2476 return this; 2477 } 2478 2479 @Override 2480 public ParsingPackageImpl setSigningDetails(@Nullable SigningDetails value) { 2481 signingDetails = value; 2482 return this; 2483 } 2484 2485 @Override 2486 public ParsingPackageImpl setUse32BitAbi(boolean value) { 2487 return setBoolean(Booleans.USE_32_BIT_ABI, value); 2488 } 2489 2490 @Override 2491 public ParsingPackageImpl setVisibleToInstantApps(boolean value) { 2492 return setBoolean(Booleans.VISIBLE_TO_INSTANT_APPS, value); 2493 } 2494 2495 @Override 2496 public ParsingPackageImpl setForceQueryable(boolean value) { 2497 return setBoolean(Booleans.FORCE_QUERYABLE, value); 2498 } 2499 2500 @Override 2501 public ParsingPackageImpl setBanner(int value) { 2502 banner = value; 2503 return this; 2504 } 2505 2506 @Override 2507 public ParsingPackageImpl setCategory(int value) { 2508 category = value; 2509 return this; 2510 } 2511 2512 @Override 2513 public ParsingPackageImpl setCompatibleWidthLimitDp(int value) { 2514 compatibleWidthLimitDp = value; 2515 return this; 2516 } 2517 2518 @Override 2519 public ParsingPackageImpl setDescriptionRes(int value) { 2520 descriptionRes = value; 2521 return this; 2522 } 2523 2524 @Override 2525 public ParsingPackageImpl setEnabled(boolean value) { 2526 return setBoolean(Booleans.ENABLED, value); 2527 } 2528 2529 @Override 2530 public ParsingPackageImpl setCrossProfile(boolean value) { 2531 return setBoolean(Booleans.CROSS_PROFILE, value); 2532 } 2533 2534 @Override 2535 public ParsingPackageImpl setFullBackupContent(int value) { 2536 fullBackupContent = value; 2537 return this; 2538 } 2539 2540 @Override 2541 public ParsingPackageImpl setDataExtractionRules(int value) { 2542 dataExtractionRules = value; 2543 return this; 2544 } 2545 2546 @Override 2547 public ParsingPackageImpl setIconRes(int value) { 2548 iconRes = value; 2549 return this; 2550 } 2551 2552 @Override 2553 public ParsingPackageImpl setInstallLocation(int value) { 2554 installLocation = value; 2555 return this; 2556 } 2557 2558 @Override 2559 public ParsingPackageImpl setLeavingSharedUid(boolean value) { 2560 return setBoolean(Booleans.LEAVING_SHARED_UID, value); 2561 } 2562 2563 @Override 2564 public ParsingPackageImpl setLabelRes(int value) { 2565 labelRes = value; 2566 return this; 2567 } 2568 2569 @Override 2570 public ParsingPackageImpl setLargestWidthLimitDp(int value) { 2571 largestWidthLimitDp = value; 2572 return this; 2573 } 2574 2575 @Override 2576 public ParsingPackageImpl setLogo(int value) { 2577 logo = value; 2578 return this; 2579 } 2580 2581 @Override 2582 public ParsingPackageImpl setMaxAspectRatio(float value) { 2583 maxAspectRatio = value; 2584 return this; 2585 } 2586 2587 @Override 2588 public ParsingPackageImpl setMinAspectRatio(float value) { 2589 minAspectRatio = value; 2590 return this; 2591 } 2592 2593 @Override 2594 public ParsingPackageImpl setMinExtensionVersions(@Nullable SparseIntArray value) { 2595 minExtensionVersions = value; 2596 return this; 2597 } 2598 2599 @Override 2600 public ParsingPackageImpl setMinSdkVersion(int value) { 2601 minSdkVersion = value; 2602 return this; 2603 } 2604 2605 @Override 2606 public ParsingPackageImpl setMaxSdkVersion(int value) { 2607 maxSdkVersion = value; 2608 return this; 2609 } 2610 2611 @Override 2612 public ParsingPackageImpl setNetworkSecurityConfigRes(int value) { 2613 networkSecurityConfigRes = value; 2614 return this; 2615 } 2616 2617 @Override 2618 public ParsingPackageImpl setRequiresSmallestWidthDp(int value) { 2619 requiresSmallestWidthDp = value; 2620 return this; 2621 } 2622 2623 @Override 2624 public ParsingPackageImpl setRoundIconRes(int value) { 2625 roundIconRes = value; 2626 return this; 2627 } 2628 2629 @Override 2630 public ParsingPackageImpl setTargetSandboxVersion(int value) { 2631 targetSandboxVersion = value; 2632 return this; 2633 } 2634 2635 @Override 2636 public ParsingPackageImpl setTargetSdkVersion(int value) { 2637 targetSdkVersion = value; 2638 return this; 2639 } 2640 2641 @Override 2642 public ParsingPackageImpl setTheme(int value) { 2643 theme = value; 2644 return this; 2645 } 2646 2647 @Override 2648 public ParsingPackageImpl setRequestForegroundServiceExemption(boolean value) { 2649 return setBoolean(Booleans.REQUEST_FOREGROUND_SERVICE_EXEMPTION, value); 2650 } 2651 2652 @Override 2653 public ParsingPackageImpl setUiOptions(int value) { 2654 uiOptions = value; 2655 return this; 2656 } 2657 2658 @Override 2659 public ParsingPackageImpl setExternalStorage(boolean value) { 2660 return setBoolean(Booleans.EXTERNAL_STORAGE, value); 2661 } 2662 2663 @Override 2664 public ParsingPackageImpl setBaseHardwareAccelerated(boolean value) { 2665 return setBoolean(Booleans.BASE_HARDWARE_ACCELERATED, value); 2666 } 2667 2668 @Override 2669 public ParsingPackageImpl setAllowBackup(boolean value) { 2670 return setBoolean(Booleans.ALLOW_BACKUP, value); 2671 } 2672 2673 @Override 2674 public ParsingPackageImpl setKillAfterRestore(boolean value) { 2675 return setBoolean(Booleans.KILL_AFTER_RESTORE, value); 2676 } 2677 2678 @Override 2679 public ParsingPackageImpl setRestoreAnyVersion(boolean value) { 2680 return setBoolean(Booleans.RESTORE_ANY_VERSION, value); 2681 } 2682 2683 @Override 2684 public ParsingPackageImpl setFullBackupOnly(boolean value) { 2685 return setBoolean(Booleans.FULL_BACKUP_ONLY, value); 2686 } 2687 2688 @Override 2689 public ParsingPackageImpl setPersistent(boolean value) { 2690 return setBoolean(Booleans.PERSISTENT, value); 2691 } 2692 2693 @Override 2694 public ParsingPackageImpl setDebuggable(boolean value) { 2695 return setBoolean(Booleans.DEBUGGABLE, value); 2696 } 2697 2698 @Override 2699 public ParsingPackageImpl setVmSafeMode(boolean value) { 2700 return setBoolean(Booleans.VM_SAFE_MODE, value); 2701 } 2702 2703 @Override 2704 public ParsingPackageImpl setHasCode(boolean value) { 2705 return setBoolean(Booleans.HAS_CODE, value); 2706 } 2707 2708 @Override 2709 public ParsingPackageImpl setAllowTaskReparenting(boolean value) { 2710 return setBoolean(Booleans.ALLOW_TASK_REPARENTING, value); 2711 } 2712 2713 @Override 2714 public ParsingPackageImpl setAllowClearUserData(boolean value) { 2715 return setBoolean(Booleans.ALLOW_CLEAR_USER_DATA, value); 2716 } 2717 2718 @Override 2719 public ParsingPackageImpl setLargeHeap(boolean value) { 2720 return setBoolean(Booleans.LARGE_HEAP, value); 2721 } 2722 2723 @Override 2724 public ParsingPackageImpl setUsesCleartextTraffic(boolean value) { 2725 return setBoolean(Booleans.USES_CLEARTEXT_TRAFFIC, value); 2726 } 2727 2728 @Override 2729 public ParsingPackageImpl setSupportsRtl(boolean value) { 2730 return setBoolean(Booleans.SUPPORTS_RTL, value); 2731 } 2732 2733 @Override 2734 public ParsingPackageImpl setTestOnly(boolean value) { 2735 return setBoolean(Booleans.TEST_ONLY, value); 2736 } 2737 2738 @Override 2739 public ParsingPackageImpl setMultiArch(boolean value) { 2740 return setBoolean(Booleans.MULTI_ARCH, value); 2741 } 2742 2743 @Override 2744 public ParsingPackageImpl setExtractNativeLibs(boolean value) { 2745 return setBoolean(Booleans.EXTRACT_NATIVE_LIBS, value); 2746 } 2747 2748 @Override 2749 public ParsingPackageImpl setGame(boolean value) { 2750 return setBoolean(Booleans.GAME, value); 2751 } 2752 2753 /** 2754 * @see ParsingPackageRead#getResizeableActivity() 2755 */ 2756 @Override 2757 public ParsingPackageImpl setResizeableActivity(@Nullable Boolean value) { 2758 resizeableActivity = value; 2759 return this; 2760 } 2761 2762 @Override 2763 public ParsingPackageImpl setSdkLibName(String sdkLibName) { 2764 this.sdkLibName = TextUtils.safeIntern(sdkLibName); 2765 return this; 2766 } 2767 2768 @Override 2769 public ParsingPackageImpl setSdkLibVersionMajor(int sdkLibVersionMajor) { 2770 this.sdkLibVersionMajor = sdkLibVersionMajor; 2771 return this; 2772 } 2773 2774 @Override 2775 public ParsingPackageImpl setSdkLibrary(boolean value) { 2776 return setBoolean(Booleans.SDK_LIBRARY, value); 2777 } 2778 2779 @Override 2780 public ParsingPackageImpl setStaticSharedLibrary(boolean value) { 2781 return setBoolean(Booleans.STATIC_SHARED_LIBRARY, value); 2782 } 2783 2784 @Override 2785 public ParsingPackageImpl setOverlay(boolean value) { 2786 return setBoolean(Booleans.OVERLAY, value); 2787 } 2788 2789 @Override 2790 public ParsingPackageImpl setIsolatedSplitLoading(boolean value) { 2791 return setBoolean(Booleans.ISOLATED_SPLIT_LOADING, value); 2792 } 2793 2794 @Override 2795 public ParsingPackageImpl setHasDomainUrls(boolean value) { 2796 return setBoolean(Booleans.HAS_DOMAIN_URLS, value); 2797 } 2798 2799 @Override 2800 public ParsingPackageImpl setProfileableByShell(boolean value) { 2801 return setBoolean(Booleans.PROFILEABLE_BY_SHELL, value); 2802 } 2803 2804 @Override 2805 public ParsingPackageImpl setProfileable(boolean value) { 2806 return setBoolean(Booleans.DISALLOW_PROFILING, !value); 2807 } 2808 2809 @Override 2810 public ParsingPackageImpl setBackupInForeground(boolean value) { 2811 return setBoolean(Booleans.BACKUP_IN_FOREGROUND, value); 2812 } 2813 2814 @Override 2815 public ParsingPackageImpl setUseEmbeddedDex(boolean value) { 2816 return setBoolean(Booleans.USE_EMBEDDED_DEX, value); 2817 } 2818 2819 @Override 2820 public ParsingPackageImpl setDefaultToDeviceProtectedStorage(boolean value) { 2821 return setBoolean(Booleans.DEFAULT_TO_DEVICE_PROTECTED_STORAGE, value); 2822 } 2823 2824 @Override 2825 public ParsingPackageImpl setDirectBootAware(boolean value) { 2826 return setBoolean(Booleans.DIRECT_BOOT_AWARE, value); 2827 } 2828 2829 @Override 2830 public ParsingPackageImpl setGwpAsanMode(@ApplicationInfo.GwpAsanMode int value) { 2831 gwpAsanMode = value; 2832 return this; 2833 } 2834 2835 @Override 2836 public ParsingPackageImpl setMemtagMode(@ApplicationInfo.MemtagMode int value) { 2837 memtagMode = value; 2838 return this; 2839 } 2840 2841 @Override 2842 public ParsingPackageImpl setNativeHeapZeroInitialized( 2843 @ApplicationInfo.NativeHeapZeroInitialized int value) { 2844 nativeHeapZeroInitialized = value; 2845 return this; 2846 } 2847 2848 @Override 2849 public ParsingPackageImpl setRequestRawExternalStorageAccess(@Nullable Boolean value) { 2850 requestRawExternalStorageAccess = value; 2851 return this; 2852 } 2853 @Override 2854 public ParsingPackageImpl setPartiallyDirectBootAware(boolean value) { 2855 return setBoolean(Booleans.PARTIALLY_DIRECT_BOOT_AWARE, value); 2856 } 2857 2858 @Override 2859 public ParsingPackageImpl setResizeableActivityViaSdkVersion(boolean value) { 2860 return setBoolean(Booleans.RESIZEABLE_ACTIVITY_VIA_SDK_VERSION, value); 2861 } 2862 2863 @Override 2864 public ParsingPackageImpl setAllowClearUserDataOnFailedRestore(boolean value) { 2865 return setBoolean(Booleans.ALLOW_CLEAR_USER_DATA_ON_FAILED_RESTORE, value); 2866 } 2867 2868 @Override 2869 public ParsingPackageImpl setAllowAudioPlaybackCapture(boolean value) { 2870 return setBoolean(Booleans.ALLOW_AUDIO_PLAYBACK_CAPTURE, value); 2871 } 2872 2873 @Override 2874 public ParsingPackageImpl setRequestLegacyExternalStorage(boolean value) { 2875 return setBoolean(Booleans.REQUEST_LEGACY_EXTERNAL_STORAGE, value); 2876 } 2877 2878 @Override 2879 public ParsingPackageImpl setUsesNonSdkApi(boolean value) { 2880 return setBoolean(Booleans.USES_NON_SDK_API, value); 2881 } 2882 2883 @Override 2884 public ParsingPackageImpl setHasFragileUserData(boolean value) { 2885 return setBoolean(Booleans.HAS_FRAGILE_USER_DATA, value); 2886 } 2887 2888 @Override 2889 public ParsingPackageImpl setCantSaveState(boolean value) { 2890 return setBoolean(Booleans.CANT_SAVE_STATE, value); 2891 } 2892 2893 @Override 2894 public ParsingPackageImpl setAllowNativeHeapPointerTagging(boolean value) { 2895 return setBoolean(Booleans.ALLOW_NATIVE_HEAP_POINTER_TAGGING, value); 2896 } 2897 2898 @Override 2899 public ParsingPackageImpl setAutoRevokePermissions(int value) { 2900 autoRevokePermissions = value; 2901 return this; 2902 } 2903 2904 @Override 2905 public ParsingPackageImpl setPreserveLegacyExternalStorage(boolean value) { 2906 return setBoolean(Booleans.PRESERVE_LEGACY_EXTERNAL_STORAGE, value); 2907 } 2908 2909 @Override 2910 public ParsingPackageImpl setVersionName(String versionName) { 2911 this.versionName = versionName; 2912 return this; 2913 } 2914 2915 @Override 2916 public ParsingPackage setCompileSdkVersionCodeName(String compileSdkVersionCodeName) { 2917 this.compileSdkVersionCodeName = compileSdkVersionCodeName; 2918 return this; 2919 } 2920 2921 @Override 2922 public ParsingPackageImpl setProcessName(String processName) { 2923 this.processName = processName; 2924 return this; 2925 } 2926 2927 @Override 2928 public ParsingPackageImpl setRestrictedAccountType(@Nullable String restrictedAccountType) { 2929 this.restrictedAccountType = restrictedAccountType; 2930 return this; 2931 } 2932 2933 @Override 2934 public ParsingPackageImpl setOverlayTargetOverlayableName( 2935 @Nullable String overlayTargetOverlayableName) { 2936 this.overlayTargetOverlayableName = overlayTargetOverlayableName; 2937 return this; 2938 } 2939 2940 @Override 2941 public ParsingPackageImpl setOverlayCategory(@Nullable String overlayCategory) { 2942 this.overlayCategory = overlayCategory; 2943 return this; 2944 } 2945 2946 @Override 2947 public ParsingPackageImpl setAppComponentFactory(@Nullable String appComponentFactory) { 2948 this.appComponentFactory = appComponentFactory; 2949 return this; 2950 } 2951 2952 @Override 2953 public ParsingPackageImpl setBackupAgentName(@Nullable String backupAgentName) { 2954 this.backupAgentName = backupAgentName; 2955 return this; 2956 } 2957 2958 @Override 2959 public ParsingPackageImpl setClassLoaderName(@Nullable String classLoaderName) { 2960 this.classLoaderName = classLoaderName; 2961 return this; 2962 } 2963 2964 @Override 2965 public ParsingPackageImpl setClassName(@Nullable String className) { 2966 this.className = className == null ? null : className.trim(); 2967 return this; 2968 } 2969 2970 @Override 2971 public ParsingPackageImpl setManageSpaceActivityName(@Nullable String manageSpaceActivityName) { 2972 this.manageSpaceActivityName = manageSpaceActivityName; 2973 return this; 2974 } 2975 2976 @Override 2977 public ParsingPackageImpl setPermission(@Nullable String permission) { 2978 this.permission = permission; 2979 return this; 2980 } 2981 2982 @Override 2983 public ParsingPackageImpl setTaskAffinity(@Nullable String taskAffinity) { 2984 this.taskAffinity = taskAffinity; 2985 return this; 2986 } 2987 2988 @Override 2989 public ParsingPackageImpl setZygotePreloadName(@Nullable String zygotePreloadName) { 2990 this.zygotePreloadName = zygotePreloadName; 2991 return this; 2992 } 2993 2994 @Override 2995 public ParsingPackage setAttributionsAreUserVisible(boolean attributionsAreUserVisible) { 2996 setBoolean(Booleans.ATTRIBUTIONS_ARE_USER_VISIBLE, attributionsAreUserVisible); 2997 return this; 2998 } 2999 3000 @Override 3001 public ParsingPackage setResetEnabledSettingsOnAppDataCleared( 3002 boolean resetEnabledSettingsOnAppDataCleared) { 3003 setBoolean(Booleans.RESET_ENABLED_SETTINGS_ON_APP_DATA_CLEARED, 3004 resetEnabledSettingsOnAppDataCleared); 3005 return this; 3006 } 3007 3008 @Override 3009 public ParsingPackageImpl setLocaleConfigRes(int value) { 3010 mLocaleConfigRes = value; 3011 return this; 3012 } 3013 3014 @Override 3015 public ParsingPackage setKnownActivityEmbeddingCerts( 3016 @Nullable Set<String> knownEmbeddingCerts) { 3017 mKnownActivityEmbeddingCerts = knownEmbeddingCerts; 3018 return this; 3019 } 3020 3021 @Override 3022 public ParsingPackage setOnBackInvokedCallbackEnabled(boolean value) { 3023 setBoolean(Booleans.ENABLE_ON_BACK_INVOKED_CALLBACK, value); 3024 return this; 3025 } 3026 } 3027