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 flag {@link #REQUESTED_PERMISSION_GRANTED} set as appropriate. 217 */ 218 public int[] requestedPermissionsFlags; 219 220 /** 221 * Array of all {@link android.R.styleable#AndroidManifestAttribution 222 * <attribution>} tags included under <manifest>, or null if there were none. This 223 * is only filled if the flag {@link PackageManager#GET_ATTRIBUTIONS} was set. 224 */ 225 @SuppressWarnings({"ArrayReturn", "NullableCollection"}) 226 public @Nullable Attribution[] attributions; 227 228 /** 229 * Flag for {@link #requestedPermissionsFlags}: the requested permission 230 * is required for the application to run; the user can not optionally 231 * disable it. Currently all permissions are required. 232 * 233 * @removed We do not support required permissions. 234 */ 235 public static final int REQUESTED_PERMISSION_REQUIRED = 0x00000001; 236 237 /** 238 * Flag for {@link #requestedPermissionsFlags}: the requested permission 239 * is currently granted to the application. 240 */ 241 public static final int REQUESTED_PERMISSION_GRANTED = 0x00000002; 242 243 /** 244 * Flag for {@link #requestedPermissionsFlags}: the requested permission has 245 * declared {@code neverForLocation} in their manifest as a strong assertion 246 * by a developer that they will never use this permission to derive the 247 * physical location of the device, regardless of 248 * {@link android.Manifest.permission#ACCESS_FINE_LOCATION} and/or 249 * {@link android.Manifest.permission#ACCESS_COARSE_LOCATION} being granted. 250 */ 251 public static final int REQUESTED_PERMISSION_NEVER_FOR_LOCATION = 0x00010000; 252 253 /** 254 * Array of all signatures read from the package file. This is only filled 255 * in if the flag {@link PackageManager#GET_SIGNATURES} was set. A package 256 * must be signed with at least one certificate which is at position zero. 257 * The package can be signed with additional certificates which appear as 258 * subsequent entries. 259 * 260 * <strong>Note:</strong> Signature ordering is not guaranteed to be 261 * stable which means that a package signed with certificates A and B is 262 * equivalent to being signed with certificates B and A. This means that 263 * in case multiple signatures are reported you cannot assume the one at 264 * the first position to be the same across updates. 265 * 266 * <strong>Deprecated</strong> This has been replaced by the 267 * {@link PackageInfo#signingInfo} field, which takes into 268 * account signing certificate rotation. For backwards compatibility in 269 * the event of signing certificate rotation, this will return the oldest 270 * reported signing certificate, so that an application will appear to 271 * callers as though no rotation occurred. 272 * 273 * @deprecated use {@code signingInfo} instead 274 */ 275 @Deprecated 276 public Signature[] signatures; 277 278 /** 279 * Signing information read from the package file, potentially 280 * including past signing certificates no longer used after signing 281 * certificate rotation. This is only filled in if 282 * the flag {@link PackageManager#GET_SIGNING_CERTIFICATES} was set. 283 * 284 * Use this field instead of the deprecated {@code signatures} field. 285 * See {@link SigningInfo} for more information on its contents. 286 */ 287 public SigningInfo signingInfo; 288 289 /** 290 * Application specified preferred configuration 291 * {@link android.R.styleable#AndroidManifestUsesConfiguration 292 * <uses-configuration>} tags included under <manifest>, 293 * or null if there were none. This is only filled in if the flag 294 * {@link PackageManager#GET_CONFIGURATIONS} was set. 295 */ 296 public ConfigurationInfo[] configPreferences; 297 298 /** 299 * Features that this application has requested. 300 * 301 * @see FeatureInfo#FLAG_REQUIRED 302 */ 303 public FeatureInfo[] reqFeatures; 304 305 /** 306 * Groups of features that this application has requested. 307 * Each group contains a set of features that are required. 308 * A device must match the features listed in {@link #reqFeatures} and one 309 * or more FeatureGroups in order to have satisfied the feature requirement. 310 * 311 * @see FeatureInfo#FLAG_REQUIRED 312 */ 313 public FeatureGroupInfo[] featureGroups; 314 315 /** 316 * Constant corresponding to <code>auto</code> in 317 * the {@link android.R.attr#installLocation} attribute. 318 * @hide 319 */ 320 @UnsupportedAppUsage 321 public static final int INSTALL_LOCATION_UNSPECIFIED = -1; 322 323 /** 324 * Constant corresponding to <code>auto</code> in the 325 * {@link android.R.attr#installLocation} attribute. 326 */ 327 public static final int INSTALL_LOCATION_AUTO = 0; 328 329 /** 330 * Constant corresponding to <code>internalOnly</code> in the 331 * {@link android.R.attr#installLocation} attribute. 332 */ 333 public static final int INSTALL_LOCATION_INTERNAL_ONLY = 1; 334 335 /** 336 * Constant corresponding to <code>preferExternal</code> in the 337 * {@link android.R.attr#installLocation} attribute. 338 */ 339 public static final int INSTALL_LOCATION_PREFER_EXTERNAL = 2; 340 341 /** 342 * The install location requested by the package. From the 343 * {@link android.R.attr#installLocation} attribute, one of 344 * {@link #INSTALL_LOCATION_AUTO}, {@link #INSTALL_LOCATION_INTERNAL_ONLY}, 345 * {@link #INSTALL_LOCATION_PREFER_EXTERNAL} 346 */ 347 public int installLocation = INSTALL_LOCATION_INTERNAL_ONLY; 348 349 /** @hide */ 350 public boolean isStub; 351 352 /** @hide */ 353 @UnsupportedAppUsage 354 public boolean coreApp; 355 356 /** @hide */ 357 public boolean requiredForAllUsers; 358 359 /** @hide */ 360 public String restrictedAccountType; 361 362 /** @hide */ 363 public String requiredAccountType; 364 365 /** 366 * What package, if any, this package will overlay. 367 * 368 * Package name of target package, or null. 369 * @hide 370 */ 371 @UnsupportedAppUsage 372 public String overlayTarget; 373 374 /** 375 * The name of the overlayable set of elements package, if any, this package will overlay. 376 * 377 * Overlayable name defined within the target package, or null. 378 * @hide 379 */ 380 public String targetOverlayableName; 381 382 /** 383 * The overlay category, if any, of this package 384 * 385 * @hide 386 */ 387 public String overlayCategory; 388 389 /** @hide */ 390 public int overlayPriority; 391 392 /** 393 * Whether the overlay is static, meaning it cannot be enabled/disabled at runtime. 394 * @hide 395 */ 396 public boolean mOverlayIsStatic; 397 398 /** 399 * The user-visible SDK version (ex. 26) of the framework against which the application claims 400 * to have been compiled, or {@code 0} if not specified. 401 * <p> 402 * This property is the compile-time equivalent of 403 * {@link android.os.Build.VERSION#SDK_INT Build.VERSION.SDK_INT}. 404 * 405 * @hide For platform use only; we don't expect developers to need to read this value. 406 */ 407 public int compileSdkVersion; 408 409 /** 410 * The development codename (ex. "O", "REL") of the framework against which the application 411 * claims to have been compiled, or {@code null} if not specified. 412 * <p> 413 * This property is the compile-time equivalent of 414 * {@link android.os.Build.VERSION#CODENAME Build.VERSION.CODENAME}. 415 * 416 * @hide For platform use only; we don't expect developers to need to read this value. 417 */ 418 @Nullable 419 public String compileSdkVersionCodename; 420 421 /** 422 * Whether the package is an APEX package. 423 */ 424 public boolean isApex; 425 PackageInfo()426 public PackageInfo() { 427 } 428 429 /** 430 * Returns true if the package is a valid Runtime Overlay package. 431 * @hide 432 */ isOverlayPackage()433 public boolean isOverlayPackage() { 434 return overlayTarget != null; 435 } 436 437 /** 438 * Returns true if the package is a valid static Runtime Overlay package. Static overlays 439 * are not updatable outside of a system update and are safe to load in the system process. 440 * @hide 441 */ isStaticOverlayPackage()442 public boolean isStaticOverlayPackage() { 443 return overlayTarget != null && mOverlayIsStatic; 444 } 445 446 @Override toString()447 public String toString() { 448 return "PackageInfo{" 449 + Integer.toHexString(System.identityHashCode(this)) 450 + " " + packageName + "}"; 451 } 452 453 @Override describeContents()454 public int describeContents() { 455 return 0; 456 } 457 458 @Override writeToParcel(Parcel dest, int parcelableFlags)459 public void writeToParcel(Parcel dest, int parcelableFlags) { 460 // Allow ApplicationInfo to be squashed. 461 final boolean prevAllowSquashing = dest.allowSquashing(); 462 dest.writeString8(packageName); 463 dest.writeString8Array(splitNames); 464 dest.writeInt(versionCode); 465 dest.writeInt(versionCodeMajor); 466 dest.writeString8(versionName); 467 dest.writeInt(baseRevisionCode); 468 dest.writeIntArray(splitRevisionCodes); 469 dest.writeString8(sharedUserId); 470 dest.writeInt(sharedUserLabel); 471 if (applicationInfo != null) { 472 dest.writeInt(1); 473 applicationInfo.writeToParcel(dest, parcelableFlags); 474 } else { 475 dest.writeInt(0); 476 } 477 dest.writeLong(firstInstallTime); 478 dest.writeLong(lastUpdateTime); 479 dest.writeIntArray(gids); 480 dest.writeTypedArray(activities, parcelableFlags); 481 dest.writeTypedArray(receivers, parcelableFlags); 482 dest.writeTypedArray(services, parcelableFlags); 483 dest.writeTypedArray(providers, parcelableFlags); 484 dest.writeTypedArray(instrumentation, parcelableFlags); 485 dest.writeTypedArray(permissions, parcelableFlags); 486 dest.writeString8Array(requestedPermissions); 487 dest.writeIntArray(requestedPermissionsFlags); 488 dest.writeTypedArray(signatures, parcelableFlags); 489 dest.writeTypedArray(configPreferences, parcelableFlags); 490 dest.writeTypedArray(reqFeatures, parcelableFlags); 491 dest.writeTypedArray(featureGroups, parcelableFlags); 492 dest.writeTypedArray(attributions, parcelableFlags); 493 dest.writeInt(installLocation); 494 dest.writeInt(isStub ? 1 : 0); 495 dest.writeInt(coreApp ? 1 : 0); 496 dest.writeInt(requiredForAllUsers ? 1 : 0); 497 dest.writeString8(restrictedAccountType); 498 dest.writeString8(requiredAccountType); 499 dest.writeString8(overlayTarget); 500 dest.writeString8(overlayCategory); 501 dest.writeInt(overlayPriority); 502 dest.writeBoolean(mOverlayIsStatic); 503 dest.writeInt(compileSdkVersion); 504 dest.writeString8(compileSdkVersionCodename); 505 if (signingInfo != null) { 506 dest.writeInt(1); 507 signingInfo.writeToParcel(dest, parcelableFlags); 508 } else { 509 dest.writeInt(0); 510 } 511 dest.writeBoolean(isApex); 512 dest.restoreAllowSquashing(prevAllowSquashing); 513 } 514 515 public static final @android.annotation.NonNull Parcelable.Creator<PackageInfo> CREATOR 516 = new Parcelable.Creator<PackageInfo>() { 517 @Override 518 public PackageInfo createFromParcel(Parcel source) { 519 return new PackageInfo(source); 520 } 521 522 @Override 523 public PackageInfo[] newArray(int size) { 524 return new PackageInfo[size]; 525 } 526 }; 527 528 @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P, trackingBug = 115609023) PackageInfo(Parcel source)529 private PackageInfo(Parcel source) { 530 packageName = source.readString8(); 531 splitNames = source.createString8Array(); 532 versionCode = source.readInt(); 533 versionCodeMajor = source.readInt(); 534 versionName = source.readString8(); 535 baseRevisionCode = source.readInt(); 536 splitRevisionCodes = source.createIntArray(); 537 sharedUserId = source.readString8(); 538 sharedUserLabel = source.readInt(); 539 int hasApp = source.readInt(); 540 if (hasApp != 0) { 541 applicationInfo = ApplicationInfo.CREATOR.createFromParcel(source); 542 } 543 firstInstallTime = source.readLong(); 544 lastUpdateTime = source.readLong(); 545 gids = source.createIntArray(); 546 activities = source.createTypedArray(ActivityInfo.CREATOR); 547 receivers = source.createTypedArray(ActivityInfo.CREATOR); 548 services = source.createTypedArray(ServiceInfo.CREATOR); 549 providers = source.createTypedArray(ProviderInfo.CREATOR); 550 instrumentation = source.createTypedArray(InstrumentationInfo.CREATOR); 551 permissions = source.createTypedArray(PermissionInfo.CREATOR); 552 requestedPermissions = source.createString8Array(); 553 requestedPermissionsFlags = source.createIntArray(); 554 signatures = source.createTypedArray(Signature.CREATOR); 555 configPreferences = source.createTypedArray(ConfigurationInfo.CREATOR); 556 reqFeatures = source.createTypedArray(FeatureInfo.CREATOR); 557 featureGroups = source.createTypedArray(FeatureGroupInfo.CREATOR); 558 attributions = source.createTypedArray(Attribution.CREATOR); 559 installLocation = source.readInt(); 560 isStub = source.readInt() != 0; 561 coreApp = source.readInt() != 0; 562 requiredForAllUsers = source.readInt() != 0; 563 restrictedAccountType = source.readString8(); 564 requiredAccountType = source.readString8(); 565 overlayTarget = source.readString8(); 566 overlayCategory = source.readString8(); 567 overlayPriority = source.readInt(); 568 mOverlayIsStatic = source.readBoolean(); 569 compileSdkVersion = source.readInt(); 570 compileSdkVersionCodename = source.readString8(); 571 int hasSigningInfo = source.readInt(); 572 if (hasSigningInfo != 0) { 573 signingInfo = SigningInfo.CREATOR.createFromParcel(source); 574 } 575 isApex = source.readBoolean(); 576 } 577 } 578