1 /* 2 * Copyright (C) 2007 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 android.content.pm; 18 19 import android.annotation.CurrentTimeMillisLong; 20 import android.annotation.FlaggedApi; 21 import android.annotation.NonNull; 22 import android.annotation.Nullable; 23 import android.compat.annotation.UnsupportedAppUsage; 24 import android.os.Build; 25 import android.os.Parcel; 26 import android.os.Parcelable; 27 28 /** 29 * Overall information about the contents of a package. This corresponds 30 * to all of the information collected from AndroidManifest.xml. 31 */ 32 @android.ravenwood.annotation.RavenwoodKeepWholeClass 33 public class PackageInfo implements Parcelable { 34 /** 35 * The name of this package. From the <manifest> tag's "name" 36 * attribute. 37 */ 38 @NonNull 39 public String packageName; 40 41 /** 42 * The names of any installed split APKs for this package. 43 */ 44 @NonNull 45 public String[] splitNames; 46 47 /** 48 * @deprecated Use {@link #getLongVersionCode()} instead, which includes both 49 * this and the additional 50 * {@link android.R.styleable#AndroidManifest_versionCodeMajor versionCodeMajor} attribute. 51 * The version number of this package, as specified by the <manifest> 52 * tag's {@link android.R.styleable#AndroidManifest_versionCode versionCode} 53 * attribute. 54 * @see #getLongVersionCode() 55 */ 56 @Deprecated 57 public int versionCode; 58 59 /** 60 * @hide 61 * The major version number of this package, as specified by the <manifest> 62 * tag's {@link android.R.styleable#AndroidManifest_versionCode versionCodeMajor} 63 * attribute. 64 * @see #getLongVersionCode() 65 */ 66 public int versionCodeMajor; 67 68 /** 69 * Return {@link android.R.styleable#AndroidManifest_versionCode versionCode} and 70 * {@link android.R.styleable#AndroidManifest_versionCodeMajor versionCodeMajor} combined 71 * together as a single long value. The 72 * {@link android.R.styleable#AndroidManifest_versionCodeMajor versionCodeMajor} is placed in 73 * the upper 32 bits. 74 */ getLongVersionCode()75 public long getLongVersionCode() { 76 return composeLongVersionCode(versionCodeMajor, versionCode); 77 } 78 79 /** 80 * Set the full version code in this PackageInfo, updating {@link #versionCode} 81 * with the lower bits. 82 * @see #getLongVersionCode() 83 */ setLongVersionCode(long longVersionCode)84 public void setLongVersionCode(long longVersionCode) { 85 versionCodeMajor = (int) (longVersionCode>>32); 86 versionCode = (int) longVersionCode; 87 } 88 89 /** 90 * @hide Internal implementation for composing a minor and major version code in to 91 * a single long version code. 92 */ composeLongVersionCode(int major, int minor)93 public static long composeLongVersionCode(int major, int minor) { 94 return (((long) major) << 32) | (((long) minor) & 0xffffffffL); 95 } 96 97 /** 98 * The version name of this package, as specified by the <manifest> 99 * tag's {@link android.R.styleable#AndroidManifest_versionName versionName} 100 * attribute, or null if there was none. 101 */ 102 @Nullable 103 public String versionName; 104 105 /** 106 * The revision number of the base APK for this package, as specified by the 107 * <manifest> tag's 108 * {@link android.R.styleable#AndroidManifest_revisionCode revisionCode} 109 * attribute. 110 */ 111 public int baseRevisionCode; 112 113 /** 114 * The revision number of any split APKs for this package, as specified by 115 * the <manifest> tag's 116 * {@link android.R.styleable#AndroidManifest_revisionCode revisionCode} 117 * attribute. Indexes are a 1:1 mapping against {@link #splitNames}. 118 */ 119 @NonNull 120 public int[] splitRevisionCodes; 121 122 /** 123 * The shared user ID name of this package, as specified by the <manifest> 124 * tag's {@link android.R.styleable#AndroidManifest_sharedUserId sharedUserId} 125 * attribute. 126 */ 127 @Nullable 128 public String sharedUserId; 129 130 /** 131 * The shared user ID label of this package, as specified by the <manifest> 132 * tag's {@link android.R.styleable#AndroidManifest_sharedUserLabel sharedUserLabel} 133 * attribute. 134 */ 135 public int sharedUserLabel; 136 137 /** 138 * Information collected from the <application> tag, or null if 139 * there was none. 140 */ 141 @Nullable 142 public ApplicationInfo applicationInfo; 143 144 /** 145 * The time at which the app was first installed. Units are as 146 * per {@link System#currentTimeMillis()}. 147 */ 148 public long firstInstallTime; 149 150 /** 151 * The time at which the app was last updated. Units are as 152 * per {@link System#currentTimeMillis()}. 153 */ 154 public long lastUpdateTime; 155 156 /** 157 * All kernel group-IDs that have been assigned to this package. 158 * This is only filled in if the flag {@link PackageManager#GET_GIDS} was set. 159 */ 160 @Nullable 161 public int[] gids; 162 163 /** 164 * Array of all {@link android.R.styleable#AndroidManifestActivity 165 * <activity>} tags included under <application>, 166 * or null if there were none. This is only filled in if the flag 167 * {@link PackageManager#GET_ACTIVITIES} was set. 168 */ 169 @Nullable 170 public ActivityInfo[] activities; 171 172 /** 173 * Array of all {@link android.R.styleable#AndroidManifestReceiver 174 * <receiver>} tags included under <application>, 175 * or null if there were none. This is only filled in if the flag 176 * {@link PackageManager#GET_RECEIVERS} was set. 177 */ 178 @Nullable 179 public ActivityInfo[] receivers; 180 181 /** 182 * Array of all {@link android.R.styleable#AndroidManifestService 183 * <service>} tags included under <application>, 184 * or null if there were none. This is only filled in if the flag 185 * {@link PackageManager#GET_SERVICES} was set. 186 */ 187 @Nullable 188 public ServiceInfo[] services; 189 190 /** 191 * Array of all {@link android.R.styleable#AndroidManifestProvider 192 * <provider>} tags included under <application>, 193 * or null if there were none. This is only filled in if the flag 194 * {@link PackageManager#GET_PROVIDERS} was set. 195 */ 196 @Nullable 197 public ProviderInfo[] providers; 198 199 /** 200 * Array of all {@link android.R.styleable#AndroidManifestInstrumentation 201 * <instrumentation>} tags included under <manifest>, 202 * or null if there were none. This is only filled in if the flag 203 * {@link PackageManager#GET_INSTRUMENTATION} was set. 204 */ 205 @Nullable 206 public InstrumentationInfo[] instrumentation; 207 208 /** 209 * Array of all {@link android.R.styleable#AndroidManifestPermission 210 * <permission>} tags included under <manifest>, 211 * or null if there were none. This is only filled in if the flag 212 * {@link PackageManager#GET_PERMISSIONS} was set. 213 */ 214 @Nullable 215 public PermissionInfo[] permissions; 216 217 /** 218 * Array of all {@link android.R.styleable#AndroidManifestUsesPermission 219 * <uses-permission>} tags included under <manifest>, 220 * or null if there were none. This is only filled in if the flag 221 * {@link PackageManager#GET_PERMISSIONS} was set. This list includes 222 * all permissions requested, even those that were not granted or known 223 * by the system at install time. 224 */ 225 @Nullable 226 public String[] requestedPermissions; 227 228 /** 229 * Array of flags of all {@link android.R.styleable#AndroidManifestUsesPermission 230 * <uses-permission>} tags included under <manifest>, 231 * or null if there were none. This is only filled in if the flag 232 * {@link PackageManager#GET_PERMISSIONS} was set. Each value matches 233 * the corresponding entry in {@link #requestedPermissions}, and will have 234 * the flags {@link #REQUESTED_PERMISSION_GRANTED}, {@link #REQUESTED_PERMISSION_IMPLICIT}, and 235 * {@link #REQUESTED_PERMISSION_NEVER_FOR_LOCATION} set as appropriate. 236 */ 237 @Nullable 238 public int[] requestedPermissionsFlags; 239 240 /** 241 * Array of all {@link android.R.styleable#AndroidManifestAttribution 242 * <attribution>} tags included under <manifest>, or null if there were none. This 243 * is only filled if the flag {@link PackageManager#GET_ATTRIBUTIONS_LONG} was set. 244 */ 245 @SuppressWarnings({"ArrayReturn", "NullableCollection"}) 246 @Nullable 247 public Attribution[] attributions; 248 249 /** 250 * The time at which the app was archived for the user. Units are as 251 * per {@link System#currentTimeMillis()}. 252 * @hide 253 */ 254 @CurrentTimeMillisLong 255 private long mArchiveTimeMillis; 256 257 /** 258 * Flag for {@link #requestedPermissionsFlags}: the requested permission 259 * is required for the application to run; the user can not optionally 260 * disable it. Currently all permissions are required. 261 * 262 * @removed We do not support required permissions. 263 */ 264 public static final int REQUESTED_PERMISSION_REQUIRED = 0x00000001; 265 266 /** 267 * Flag for {@link #requestedPermissionsFlags}: the requested permission 268 * is currently granted to the application. 269 */ 270 public static final int REQUESTED_PERMISSION_GRANTED = 0x00000002; 271 272 /** 273 * Flag for {@link #requestedPermissionsFlags}: the requested permission has 274 * declared {@code neverForLocation} in their manifest as a strong assertion 275 * by a developer that they will never use this permission to derive the 276 * physical location of the device, regardless of 277 * {@link android.Manifest.permission#ACCESS_FINE_LOCATION} and/or 278 * {@link android.Manifest.permission#ACCESS_COARSE_LOCATION} being granted. 279 */ 280 public static final int REQUESTED_PERMISSION_NEVER_FOR_LOCATION = 0x00010000; 281 282 /** 283 * Flag for {@link #requestedPermissionsFlags}: the requested permission was 284 * not explicitly requested via uses-permission, but was instead implicitly 285 * requested (e.g., for version compatibility reasons). 286 */ 287 public static final int REQUESTED_PERMISSION_IMPLICIT = 0x00000004; 288 289 /** 290 * Array of all signatures read from the package file. This is only filled 291 * in if the flag {@link PackageManager#GET_SIGNATURES} was set. A package 292 * must be signed with at least one certificate which is at position zero. 293 * The package can be signed with additional certificates which appear as 294 * subsequent entries. 295 * 296 * <strong>Note:</strong> Signature ordering is not guaranteed to be 297 * stable which means that a package signed with certificates A and B is 298 * equivalent to being signed with certificates B and A. This means that 299 * in case multiple signatures are reported you cannot assume the one at 300 * the first position to be the same across updates. 301 * 302 * <strong>Deprecated</strong> This has been replaced by the 303 * {@link PackageInfo#signingInfo} field, which takes into 304 * account signing certificate rotation. For backwards compatibility in 305 * the event of signing certificate rotation, this will return the oldest 306 * reported signing certificate, so that an application will appear to 307 * callers as though no rotation occurred. 308 * 309 * @deprecated use {@code signingInfo} instead 310 */ 311 @Deprecated 312 @Nullable 313 public Signature[] signatures; 314 315 /** 316 * Signing information read from the package file, potentially 317 * including past signing certificates no longer used after signing 318 * certificate rotation. This is only filled in if 319 * the flag {@link PackageManager#GET_SIGNING_CERTIFICATES} was set. 320 * 321 * Use this field instead of the deprecated {@code signatures} field. 322 * See {@link SigningInfo} for more information on its contents. 323 */ 324 @Nullable 325 public SigningInfo signingInfo; 326 327 /** 328 * Application specified preferred configuration 329 * {@link android.R.styleable#AndroidManifestUsesConfiguration 330 * <uses-configuration>} tags included under <manifest>, 331 * or null if there were none. This is only filled in if the flag 332 * {@link PackageManager#GET_CONFIGURATIONS} was set. 333 */ 334 @Nullable 335 public ConfigurationInfo[] configPreferences; 336 337 /** 338 * Features that this application has requested. 339 * 340 * @see FeatureInfo#FLAG_REQUIRED 341 */ 342 @Nullable 343 public FeatureInfo[] reqFeatures; 344 345 /** 346 * Groups of features that this application has requested. 347 * Each group contains a set of features that are required. 348 * A device must match the features listed in {@link #reqFeatures} and one 349 * or more FeatureGroups in order to have satisfied the feature requirement. 350 * 351 * @see FeatureInfo#FLAG_REQUIRED 352 */ 353 @Nullable 354 public FeatureGroupInfo[] featureGroups; 355 356 /** 357 * Constant corresponding to <code>auto</code> in 358 * the {@link android.R.attr#installLocation} attribute. 359 * @hide 360 */ 361 @UnsupportedAppUsage 362 public static final int INSTALL_LOCATION_UNSPECIFIED = -1; 363 364 /** 365 * Constant corresponding to <code>auto</code> in the 366 * {@link android.R.attr#installLocation} attribute. 367 */ 368 public static final int INSTALL_LOCATION_AUTO = 0; 369 370 /** 371 * Constant corresponding to <code>internalOnly</code> in the 372 * {@link android.R.attr#installLocation} attribute. 373 */ 374 public static final int INSTALL_LOCATION_INTERNAL_ONLY = 1; 375 376 /** 377 * Constant corresponding to <code>preferExternal</code> in the 378 * {@link android.R.attr#installLocation} attribute. 379 */ 380 public static final int INSTALL_LOCATION_PREFER_EXTERNAL = 2; 381 382 /** 383 * The install location requested by the package. From the 384 * {@link android.R.attr#installLocation} attribute, one of 385 * {@link #INSTALL_LOCATION_AUTO}, {@link #INSTALL_LOCATION_INTERNAL_ONLY}, 386 * {@link #INSTALL_LOCATION_PREFER_EXTERNAL} 387 */ 388 public int installLocation = INSTALL_LOCATION_INTERNAL_ONLY; 389 390 /** 391 * Whether or not the package is a stub and should be replaced by a full version of the app. 392 * 393 * @hide 394 */ 395 public boolean isStub; 396 397 /** 398 * Whether the app is included when the device is booted into a minimal state. Set through the 399 * non-namespaced "coreApp" attribute of the manifest tag. 400 * 401 * @hide 402 */ 403 @UnsupportedAppUsage 404 public boolean coreApp; 405 406 /** 407 * Signals that this app is required for all users on the device. 408 * 409 * When a restricted user profile is created, the user is prompted with a list of apps to 410 * install on that user. Settings uses this field to determine obligatory apps which cannot be 411 * deselected. 412 * 413 * This restriction is not handled by the framework itself. 414 * @hide 415 */ 416 public boolean requiredForAllUsers; 417 418 /** 419 * The restricted account authenticator type that is used by this application. 420 * @hide 421 */ 422 @Nullable 423 public String restrictedAccountType; 424 425 /** 426 * The required account type without which this application will not function. 427 * @hide 428 */ 429 @Nullable 430 public String requiredAccountType; 431 432 /** 433 * What package, if any, this package will overlay. 434 * 435 * Package name of target package, or null. 436 * @hide 437 */ 438 @UnsupportedAppUsage 439 @Nullable 440 public String overlayTarget; 441 442 /** 443 * The name of the overlayable set of elements package, if any, this package will overlay. 444 * 445 * Overlayable name defined within the target package, or null. 446 * @hide 447 */ 448 @Nullable 449 public String targetOverlayableName; 450 451 /** 452 * The overlay category, if any, of this package 453 * 454 * @hide 455 */ 456 @Nullable 457 public String overlayCategory; 458 459 /** @hide */ 460 public int overlayPriority; 461 462 /** 463 * Whether the overlay is static, meaning it cannot be enabled/disabled at runtime. 464 * @hide 465 */ 466 public boolean mOverlayIsStatic; 467 468 /** 469 * The user-visible SDK version (ex. 26) of the framework against which the application claims 470 * to have been compiled, or {@code 0} if not specified. 471 * <p> 472 * This property is the compile-time equivalent of 473 * {@link android.os.Build.VERSION#SDK_INT Build.VERSION.SDK_INT}. 474 * 475 * @hide For platform use only; we don't expect developers to need to read this value. 476 */ 477 public int compileSdkVersion; 478 479 /** 480 * The development codename (ex. "O", "REL") of the framework against which the application 481 * claims to have been compiled, or {@code null} if not specified. 482 * <p> 483 * This property is the compile-time equivalent of 484 * {@link android.os.Build.VERSION#CODENAME Build.VERSION.CODENAME}. 485 * 486 * @hide For platform use only; we don't expect developers to need to read this value. 487 */ 488 @Nullable 489 public String compileSdkVersionCodename; 490 491 /** 492 * Whether the package is an APEX package. 493 */ 494 public boolean isApex; 495 496 /** 497 * Whether this is an active APEX package. 498 * @hide 499 */ 500 public boolean isActiveApex; 501 502 /** 503 * If the package is an APEX package (i.e. the value of {@link #isApex} 504 * is true), this field is the package name of the APEX. If the package 505 * is one APK-in-APEX app, this field is the package name of the parent 506 * APEX that contains the app. If the package is not one of the above 507 * two cases, this field is {@code null}. 508 */ 509 @Nullable 510 private String mApexPackageName; 511 PackageInfo()512 public PackageInfo() { 513 } 514 515 /** 516 * Returns true if the package is a valid Runtime Overlay package. 517 * @hide 518 */ isOverlayPackage()519 public boolean isOverlayPackage() { 520 return overlayTarget != null; 521 } 522 523 /** 524 * Returns true if the package is a valid static Runtime Overlay package. Static overlays 525 * are not updatable outside of a system update and are safe to load in the system process. 526 * @hide 527 */ isStaticOverlayPackage()528 public boolean isStaticOverlayPackage() { 529 return overlayTarget != null && mOverlayIsStatic; 530 } 531 532 /** 533 * Returns the time at which the app was archived for the user. Units are as 534 * per {@link System#currentTimeMillis()}. 535 */ 536 @FlaggedApi(Flags.FLAG_ARCHIVING) getArchiveTimeMillis()537 public @CurrentTimeMillisLong long getArchiveTimeMillis() { 538 return mArchiveTimeMillis; 539 } 540 541 /** 542 * @hide 543 */ setArchiveTimeMillis(@urrentTimeMillisLong long value)544 public void setArchiveTimeMillis(@CurrentTimeMillisLong long value) { 545 mArchiveTimeMillis = value; 546 } 547 548 /** 549 * If the package is an APEX package (i.e. the value of {@link #isApex} 550 * is true), returns the package name of the APEX. If the package 551 * is one APK-in-APEX app, returns the package name of the parent 552 * APEX that contains the app. If the package is not one of the above 553 * two cases, returns {@code null}. 554 */ 555 @Nullable 556 @FlaggedApi(android.content.pm.Flags.FLAG_PROVIDE_INFO_OF_APK_IN_APEX) getApexPackageName()557 public String getApexPackageName() { 558 return mApexPackageName; 559 } 560 561 /** 562 * @hide 563 */ setApexPackageName(@ullable String apexPackageName)564 public void setApexPackageName(@Nullable String apexPackageName) { 565 mApexPackageName = apexPackageName; 566 } 567 568 @Override toString()569 public String toString() { 570 return "PackageInfo{" 571 + Integer.toHexString(System.identityHashCode(this)) 572 + " " + packageName + "}"; 573 } 574 575 @Override describeContents()576 public int describeContents() { 577 return 0; 578 } 579 580 @Override writeToParcel(Parcel dest, int parcelableFlags)581 public void writeToParcel(Parcel dest, int parcelableFlags) { 582 // Allow ApplicationInfo to be squashed. 583 final boolean prevAllowSquashing = dest.allowSquashing(); 584 dest.writeString8(packageName); 585 dest.writeString8Array(splitNames); 586 dest.writeInt(versionCode); 587 dest.writeInt(versionCodeMajor); 588 dest.writeString8(versionName); 589 dest.writeInt(baseRevisionCode); 590 dest.writeIntArray(splitRevisionCodes); 591 dest.writeString8(sharedUserId); 592 dest.writeInt(sharedUserLabel); 593 if (applicationInfo != null) { 594 dest.writeInt(1); 595 applicationInfo.writeToParcel(dest, parcelableFlags); 596 } else { 597 dest.writeInt(0); 598 } 599 dest.writeLong(firstInstallTime); 600 dest.writeLong(lastUpdateTime); 601 dest.writeIntArray(gids); 602 dest.writeTypedArray(activities, parcelableFlags); 603 dest.writeTypedArray(receivers, parcelableFlags); 604 dest.writeTypedArray(services, parcelableFlags); 605 dest.writeTypedArray(providers, parcelableFlags); 606 dest.writeTypedArray(instrumentation, parcelableFlags); 607 dest.writeTypedArray(permissions, parcelableFlags); 608 dest.writeString8Array(requestedPermissions); 609 dest.writeIntArray(requestedPermissionsFlags); 610 dest.writeTypedArray(signatures, parcelableFlags); 611 dest.writeTypedArray(configPreferences, parcelableFlags); 612 dest.writeTypedArray(reqFeatures, parcelableFlags); 613 dest.writeTypedArray(featureGroups, parcelableFlags); 614 dest.writeTypedArray(attributions, parcelableFlags); 615 dest.writeInt(installLocation); 616 dest.writeInt(isStub ? 1 : 0); 617 dest.writeInt(coreApp ? 1 : 0); 618 dest.writeInt(requiredForAllUsers ? 1 : 0); 619 dest.writeString8(restrictedAccountType); 620 dest.writeString8(requiredAccountType); 621 dest.writeString8(overlayTarget); 622 dest.writeString8(overlayCategory); 623 dest.writeInt(overlayPriority); 624 dest.writeBoolean(mOverlayIsStatic); 625 dest.writeInt(compileSdkVersion); 626 dest.writeString8(compileSdkVersionCodename); 627 if (signingInfo != null) { 628 dest.writeInt(1); 629 signingInfo.writeToParcel(dest, parcelableFlags); 630 } else { 631 dest.writeInt(0); 632 } 633 dest.writeBoolean(isApex); 634 dest.writeBoolean(isActiveApex); 635 dest.writeLong(mArchiveTimeMillis); 636 if (mApexPackageName != null) { 637 dest.writeInt(1); 638 dest.writeString8(mApexPackageName); 639 } else { 640 dest.writeInt(0); 641 } 642 dest.restoreAllowSquashing(prevAllowSquashing); 643 } 644 645 public static final @android.annotation.NonNull Parcelable.Creator<PackageInfo> CREATOR 646 = new Parcelable.Creator<PackageInfo>() { 647 @Override 648 public PackageInfo createFromParcel(Parcel source) { 649 return new PackageInfo(source); 650 } 651 652 @Override 653 public PackageInfo[] newArray(int size) { 654 return new PackageInfo[size]; 655 } 656 }; 657 658 @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P, trackingBug = 115609023) PackageInfo(Parcel source)659 private PackageInfo(Parcel source) { 660 packageName = source.readString8(); 661 splitNames = source.createString8Array(); 662 versionCode = source.readInt(); 663 versionCodeMajor = source.readInt(); 664 versionName = source.readString8(); 665 baseRevisionCode = source.readInt(); 666 splitRevisionCodes = source.createIntArray(); 667 sharedUserId = source.readString8(); 668 sharedUserLabel = source.readInt(); 669 int hasApp = source.readInt(); 670 if (hasApp != 0) { 671 applicationInfo = ApplicationInfo.CREATOR.createFromParcel(source); 672 } 673 firstInstallTime = source.readLong(); 674 lastUpdateTime = source.readLong(); 675 gids = source.createIntArray(); 676 activities = source.createTypedArray(ActivityInfo.CREATOR); 677 receivers = source.createTypedArray(ActivityInfo.CREATOR); 678 services = source.createTypedArray(ServiceInfo.CREATOR); 679 providers = source.createTypedArray(ProviderInfo.CREATOR); 680 instrumentation = source.createTypedArray(InstrumentationInfo.CREATOR); 681 permissions = source.createTypedArray(PermissionInfo.CREATOR); 682 requestedPermissions = source.createString8Array(); 683 requestedPermissionsFlags = source.createIntArray(); 684 signatures = source.createTypedArray(Signature.CREATOR); 685 configPreferences = source.createTypedArray(ConfigurationInfo.CREATOR); 686 reqFeatures = source.createTypedArray(FeatureInfo.CREATOR); 687 featureGroups = source.createTypedArray(FeatureGroupInfo.CREATOR); 688 attributions = source.createTypedArray(Attribution.CREATOR); 689 installLocation = source.readInt(); 690 isStub = source.readInt() != 0; 691 coreApp = source.readInt() != 0; 692 requiredForAllUsers = source.readInt() != 0; 693 restrictedAccountType = source.readString8(); 694 requiredAccountType = source.readString8(); 695 overlayTarget = source.readString8(); 696 overlayCategory = source.readString8(); 697 overlayPriority = source.readInt(); 698 mOverlayIsStatic = source.readBoolean(); 699 compileSdkVersion = source.readInt(); 700 compileSdkVersionCodename = source.readString8(); 701 int hasSigningInfo = source.readInt(); 702 if (hasSigningInfo != 0) { 703 signingInfo = SigningInfo.CREATOR.createFromParcel(source); 704 } 705 isApex = source.readBoolean(); 706 isActiveApex = source.readBoolean(); 707 mArchiveTimeMillis = source.readLong(); 708 int hasApexPackageName = source.readInt(); 709 if (hasApexPackageName != 0) { 710 mApexPackageName = source.readString8(); 711 } 712 } 713 } 714