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