714 lines
25 KiB
Java
714 lines
25 KiB
Java
/*
|
|
* Copyright (C) 2007 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package android.content.pm;
|
|
|
|
import android.annotation.CurrentTimeMillisLong;
|
|
import android.annotation.FlaggedApi;
|
|
import android.annotation.NonNull;
|
|
import android.annotation.Nullable;
|
|
import android.compat.annotation.UnsupportedAppUsage;
|
|
import android.os.Build;
|
|
import android.os.Parcel;
|
|
import android.os.Parcelable;
|
|
|
|
/**
|
|
* Overall information about the contents of a package. This corresponds
|
|
* to all of the information collected from AndroidManifest.xml.
|
|
*/
|
|
@android.ravenwood.annotation.RavenwoodKeepWholeClass
|
|
public class PackageInfo implements Parcelable {
|
|
/**
|
|
* The name of this package. From the <manifest> tag's "name"
|
|
* attribute.
|
|
*/
|
|
@NonNull
|
|
public String packageName;
|
|
|
|
/**
|
|
* The names of any installed split APKs for this package.
|
|
*/
|
|
@NonNull
|
|
public String[] splitNames;
|
|
|
|
/**
|
|
* @deprecated Use {@link #getLongVersionCode()} instead, which includes both
|
|
* this and the additional
|
|
* {@link android.R.styleable#AndroidManifest_versionCodeMajor versionCodeMajor} attribute.
|
|
* The version number of this package, as specified by the <manifest>
|
|
* tag's {@link android.R.styleable#AndroidManifest_versionCode versionCode}
|
|
* attribute.
|
|
* @see #getLongVersionCode()
|
|
*/
|
|
@Deprecated
|
|
public int versionCode;
|
|
|
|
/**
|
|
* @hide
|
|
* The major version number of this package, as specified by the <manifest>
|
|
* tag's {@link android.R.styleable#AndroidManifest_versionCode versionCodeMajor}
|
|
* attribute.
|
|
* @see #getLongVersionCode()
|
|
*/
|
|
public int versionCodeMajor;
|
|
|
|
/**
|
|
* Return {@link android.R.styleable#AndroidManifest_versionCode versionCode} and
|
|
* {@link android.R.styleable#AndroidManifest_versionCodeMajor versionCodeMajor} combined
|
|
* together as a single long value. The
|
|
* {@link android.R.styleable#AndroidManifest_versionCodeMajor versionCodeMajor} is placed in
|
|
* the upper 32 bits.
|
|
*/
|
|
public long getLongVersionCode() {
|
|
return composeLongVersionCode(versionCodeMajor, versionCode);
|
|
}
|
|
|
|
/**
|
|
* Set the full version code in this PackageInfo, updating {@link #versionCode}
|
|
* with the lower bits.
|
|
* @see #getLongVersionCode()
|
|
*/
|
|
public void setLongVersionCode(long longVersionCode) {
|
|
versionCodeMajor = (int) (longVersionCode>>32);
|
|
versionCode = (int) longVersionCode;
|
|
}
|
|
|
|
/**
|
|
* @hide Internal implementation for composing a minor and major version code in to
|
|
* a single long version code.
|
|
*/
|
|
public static long composeLongVersionCode(int major, int minor) {
|
|
return (((long) major) << 32) | (((long) minor) & 0xffffffffL);
|
|
}
|
|
|
|
/**
|
|
* The version name of this package, as specified by the <manifest>
|
|
* tag's {@link android.R.styleable#AndroidManifest_versionName versionName}
|
|
* attribute, or null if there was none.
|
|
*/
|
|
@Nullable
|
|
public String versionName;
|
|
|
|
/**
|
|
* The revision number of the base APK for this package, as specified by the
|
|
* <manifest> tag's
|
|
* {@link android.R.styleable#AndroidManifest_revisionCode revisionCode}
|
|
* attribute.
|
|
*/
|
|
public int baseRevisionCode;
|
|
|
|
/**
|
|
* The revision number of any split APKs for this package, as specified by
|
|
* the <manifest> tag's
|
|
* {@link android.R.styleable#AndroidManifest_revisionCode revisionCode}
|
|
* attribute. Indexes are a 1:1 mapping against {@link #splitNames}.
|
|
*/
|
|
@NonNull
|
|
public int[] splitRevisionCodes;
|
|
|
|
/**
|
|
* The shared user ID name of this package, as specified by the <manifest>
|
|
* tag's {@link android.R.styleable#AndroidManifest_sharedUserId sharedUserId}
|
|
* attribute.
|
|
*/
|
|
@Nullable
|
|
public String sharedUserId;
|
|
|
|
/**
|
|
* The shared user ID label of this package, as specified by the <manifest>
|
|
* tag's {@link android.R.styleable#AndroidManifest_sharedUserLabel sharedUserLabel}
|
|
* attribute.
|
|
*/
|
|
public int sharedUserLabel;
|
|
|
|
/**
|
|
* Information collected from the <application> tag, or null if
|
|
* there was none.
|
|
*/
|
|
@Nullable
|
|
public ApplicationInfo applicationInfo;
|
|
|
|
/**
|
|
* The time at which the app was first installed. Units are as
|
|
* per {@link System#currentTimeMillis()}.
|
|
*/
|
|
public long firstInstallTime;
|
|
|
|
/**
|
|
* The time at which the app was last updated. Units are as
|
|
* per {@link System#currentTimeMillis()}.
|
|
*/
|
|
public long lastUpdateTime;
|
|
|
|
/**
|
|
* All kernel group-IDs that have been assigned to this package.
|
|
* This is only filled in if the flag {@link PackageManager#GET_GIDS} was set.
|
|
*/
|
|
@Nullable
|
|
public int[] gids;
|
|
|
|
/**
|
|
* Array of all {@link android.R.styleable#AndroidManifestActivity
|
|
* <activity>} tags included under <application>,
|
|
* or null if there were none. This is only filled in if the flag
|
|
* {@link PackageManager#GET_ACTIVITIES} was set.
|
|
*/
|
|
@Nullable
|
|
public ActivityInfo[] activities;
|
|
|
|
/**
|
|
* Array of all {@link android.R.styleable#AndroidManifestReceiver
|
|
* <receiver>} tags included under <application>,
|
|
* or null if there were none. This is only filled in if the flag
|
|
* {@link PackageManager#GET_RECEIVERS} was set.
|
|
*/
|
|
@Nullable
|
|
public ActivityInfo[] receivers;
|
|
|
|
/**
|
|
* Array of all {@link android.R.styleable#AndroidManifestService
|
|
* <service>} tags included under <application>,
|
|
* or null if there were none. This is only filled in if the flag
|
|
* {@link PackageManager#GET_SERVICES} was set.
|
|
*/
|
|
@Nullable
|
|
public ServiceInfo[] services;
|
|
|
|
/**
|
|
* Array of all {@link android.R.styleable#AndroidManifestProvider
|
|
* <provider>} tags included under <application>,
|
|
* or null if there were none. This is only filled in if the flag
|
|
* {@link PackageManager#GET_PROVIDERS} was set.
|
|
*/
|
|
@Nullable
|
|
public ProviderInfo[] providers;
|
|
|
|
/**
|
|
* Array of all {@link android.R.styleable#AndroidManifestInstrumentation
|
|
* <instrumentation>} tags included under <manifest>,
|
|
* or null if there were none. This is only filled in if the flag
|
|
* {@link PackageManager#GET_INSTRUMENTATION} was set.
|
|
*/
|
|
@Nullable
|
|
public InstrumentationInfo[] instrumentation;
|
|
|
|
/**
|
|
* Array of all {@link android.R.styleable#AndroidManifestPermission
|
|
* <permission>} tags included under <manifest>,
|
|
* or null if there were none. This is only filled in if the flag
|
|
* {@link PackageManager#GET_PERMISSIONS} was set.
|
|
*/
|
|
@Nullable
|
|
public PermissionInfo[] permissions;
|
|
|
|
/**
|
|
* Array of all {@link android.R.styleable#AndroidManifestUsesPermission
|
|
* <uses-permission>} tags included under <manifest>,
|
|
* or null if there were none. This is only filled in if the flag
|
|
* {@link PackageManager#GET_PERMISSIONS} was set. This list includes
|
|
* all permissions requested, even those that were not granted or known
|
|
* by the system at install time.
|
|
*/
|
|
@Nullable
|
|
public String[] requestedPermissions;
|
|
|
|
/**
|
|
* Array of flags of all {@link android.R.styleable#AndroidManifestUsesPermission
|
|
* <uses-permission>} tags included under <manifest>,
|
|
* or null if there were none. This is only filled in if the flag
|
|
* {@link PackageManager#GET_PERMISSIONS} was set. Each value matches
|
|
* the corresponding entry in {@link #requestedPermissions}, and will have
|
|
* the flags {@link #REQUESTED_PERMISSION_GRANTED}, {@link #REQUESTED_PERMISSION_IMPLICIT}, and
|
|
* {@link #REQUESTED_PERMISSION_NEVER_FOR_LOCATION} set as appropriate.
|
|
*/
|
|
@Nullable
|
|
public int[] requestedPermissionsFlags;
|
|
|
|
/**
|
|
* Array of all {@link android.R.styleable#AndroidManifestAttribution
|
|
* <attribution>} tags included under <manifest>, or null if there were none. This
|
|
* is only filled if the flag {@link PackageManager#GET_ATTRIBUTIONS_LONG} was set.
|
|
*/
|
|
@SuppressWarnings({"ArrayReturn", "NullableCollection"})
|
|
@Nullable
|
|
public Attribution[] attributions;
|
|
|
|
/**
|
|
* The time at which the app was archived for the user. Units are as
|
|
* per {@link System#currentTimeMillis()}.
|
|
* @hide
|
|
*/
|
|
@CurrentTimeMillisLong
|
|
private long mArchiveTimeMillis;
|
|
|
|
/**
|
|
* Flag for {@link #requestedPermissionsFlags}: the requested permission
|
|
* is required for the application to run; the user can not optionally
|
|
* disable it. Currently all permissions are required.
|
|
*
|
|
* @removed We do not support required permissions.
|
|
*/
|
|
public static final int REQUESTED_PERMISSION_REQUIRED = 0x00000001;
|
|
|
|
/**
|
|
* Flag for {@link #requestedPermissionsFlags}: the requested permission
|
|
* is currently granted to the application.
|
|
*/
|
|
public static final int REQUESTED_PERMISSION_GRANTED = 0x00000002;
|
|
|
|
/**
|
|
* Flag for {@link #requestedPermissionsFlags}: the requested permission has
|
|
* declared {@code neverForLocation} in their manifest as a strong assertion
|
|
* by a developer that they will never use this permission to derive the
|
|
* physical location of the device, regardless of
|
|
* {@link android.Manifest.permission#ACCESS_FINE_LOCATION} and/or
|
|
* {@link android.Manifest.permission#ACCESS_COARSE_LOCATION} being granted.
|
|
*/
|
|
public static final int REQUESTED_PERMISSION_NEVER_FOR_LOCATION = 0x00010000;
|
|
|
|
/**
|
|
* Flag for {@link #requestedPermissionsFlags}: the requested permission was
|
|
* not explicitly requested via uses-permission, but was instead implicitly
|
|
* requested (e.g., for version compatibility reasons).
|
|
*/
|
|
public static final int REQUESTED_PERMISSION_IMPLICIT = 0x00000004;
|
|
|
|
/**
|
|
* Array of all signatures read from the package file. This is only filled
|
|
* in if the flag {@link PackageManager#GET_SIGNATURES} was set. A package
|
|
* must be signed with at least one certificate which is at position zero.
|
|
* The package can be signed with additional certificates which appear as
|
|
* subsequent entries.
|
|
*
|
|
* <strong>Note:</strong> Signature ordering is not guaranteed to be
|
|
* stable which means that a package signed with certificates A and B is
|
|
* equivalent to being signed with certificates B and A. This means that
|
|
* in case multiple signatures are reported you cannot assume the one at
|
|
* the first position to be the same across updates.
|
|
*
|
|
* <strong>Deprecated</strong> This has been replaced by the
|
|
* {@link PackageInfo#signingInfo} field, which takes into
|
|
* account signing certificate rotation. For backwards compatibility in
|
|
* the event of signing certificate rotation, this will return the oldest
|
|
* reported signing certificate, so that an application will appear to
|
|
* callers as though no rotation occurred.
|
|
*
|
|
* @deprecated use {@code signingInfo} instead
|
|
*/
|
|
@Deprecated
|
|
@Nullable
|
|
public Signature[] signatures;
|
|
|
|
/**
|
|
* Signing information read from the package file, potentially
|
|
* including past signing certificates no longer used after signing
|
|
* certificate rotation. This is only filled in if
|
|
* the flag {@link PackageManager#GET_SIGNING_CERTIFICATES} was set.
|
|
*
|
|
* Use this field instead of the deprecated {@code signatures} field.
|
|
* See {@link SigningInfo} for more information on its contents.
|
|
*/
|
|
@Nullable
|
|
public SigningInfo signingInfo;
|
|
|
|
/**
|
|
* Application specified preferred configuration
|
|
* {@link android.R.styleable#AndroidManifestUsesConfiguration
|
|
* <uses-configuration>} tags included under <manifest>,
|
|
* or null if there were none. This is only filled in if the flag
|
|
* {@link PackageManager#GET_CONFIGURATIONS} was set.
|
|
*/
|
|
@Nullable
|
|
public ConfigurationInfo[] configPreferences;
|
|
|
|
/**
|
|
* Features that this application has requested.
|
|
*
|
|
* @see FeatureInfo#FLAG_REQUIRED
|
|
*/
|
|
@Nullable
|
|
public FeatureInfo[] reqFeatures;
|
|
|
|
/**
|
|
* Groups of features that this application has requested.
|
|
* Each group contains a set of features that are required.
|
|
* A device must match the features listed in {@link #reqFeatures} and one
|
|
* or more FeatureGroups in order to have satisfied the feature requirement.
|
|
*
|
|
* @see FeatureInfo#FLAG_REQUIRED
|
|
*/
|
|
@Nullable
|
|
public FeatureGroupInfo[] featureGroups;
|
|
|
|
/**
|
|
* Constant corresponding to <code>auto</code> in
|
|
* the {@link android.R.attr#installLocation} attribute.
|
|
* @hide
|
|
*/
|
|
@UnsupportedAppUsage
|
|
public static final int INSTALL_LOCATION_UNSPECIFIED = -1;
|
|
|
|
/**
|
|
* Constant corresponding to <code>auto</code> in the
|
|
* {@link android.R.attr#installLocation} attribute.
|
|
*/
|
|
public static final int INSTALL_LOCATION_AUTO = 0;
|
|
|
|
/**
|
|
* Constant corresponding to <code>internalOnly</code> in the
|
|
* {@link android.R.attr#installLocation} attribute.
|
|
*/
|
|
public static final int INSTALL_LOCATION_INTERNAL_ONLY = 1;
|
|
|
|
/**
|
|
* Constant corresponding to <code>preferExternal</code> in the
|
|
* {@link android.R.attr#installLocation} attribute.
|
|
*/
|
|
public static final int INSTALL_LOCATION_PREFER_EXTERNAL = 2;
|
|
|
|
/**
|
|
* The install location requested by the package. From the
|
|
* {@link android.R.attr#installLocation} attribute, one of
|
|
* {@link #INSTALL_LOCATION_AUTO}, {@link #INSTALL_LOCATION_INTERNAL_ONLY},
|
|
* {@link #INSTALL_LOCATION_PREFER_EXTERNAL}
|
|
*/
|
|
public int installLocation = INSTALL_LOCATION_INTERNAL_ONLY;
|
|
|
|
/**
|
|
* Whether or not the package is a stub and should be replaced by a full version of the app.
|
|
*
|
|
* @hide
|
|
*/
|
|
public boolean isStub;
|
|
|
|
/**
|
|
* Whether the app is included when the device is booted into a minimal state. Set through the
|
|
* non-namespaced "coreApp" attribute of the manifest tag.
|
|
*
|
|
* @hide
|
|
*/
|
|
@UnsupportedAppUsage
|
|
public boolean coreApp;
|
|
|
|
/**
|
|
* Signals that this app is required for all users on the device.
|
|
*
|
|
* When a restricted user profile is created, the user is prompted with a list of apps to
|
|
* install on that user. Settings uses this field to determine obligatory apps which cannot be
|
|
* deselected.
|
|
*
|
|
* This restriction is not handled by the framework itself.
|
|
* @hide
|
|
*/
|
|
public boolean requiredForAllUsers;
|
|
|
|
/**
|
|
* The restricted account authenticator type that is used by this application.
|
|
* @hide
|
|
*/
|
|
@Nullable
|
|
public String restrictedAccountType;
|
|
|
|
/**
|
|
* The required account type without which this application will not function.
|
|
* @hide
|
|
*/
|
|
@Nullable
|
|
public String requiredAccountType;
|
|
|
|
/**
|
|
* What package, if any, this package will overlay.
|
|
*
|
|
* Package name of target package, or null.
|
|
* @hide
|
|
*/
|
|
@UnsupportedAppUsage
|
|
@Nullable
|
|
public String overlayTarget;
|
|
|
|
/**
|
|
* The name of the overlayable set of elements package, if any, this package will overlay.
|
|
*
|
|
* Overlayable name defined within the target package, or null.
|
|
* @hide
|
|
*/
|
|
@Nullable
|
|
public String targetOverlayableName;
|
|
|
|
/**
|
|
* The overlay category, if any, of this package
|
|
*
|
|
* @hide
|
|
*/
|
|
@Nullable
|
|
public String overlayCategory;
|
|
|
|
/** @hide */
|
|
public int overlayPriority;
|
|
|
|
/**
|
|
* Whether the overlay is static, meaning it cannot be enabled/disabled at runtime.
|
|
* @hide
|
|
*/
|
|
public boolean mOverlayIsStatic;
|
|
|
|
/**
|
|
* The user-visible SDK version (ex. 26) of the framework against which the application claims
|
|
* to have been compiled, or {@code 0} if not specified.
|
|
* <p>
|
|
* This property is the compile-time equivalent of
|
|
* {@link android.os.Build.VERSION#SDK_INT Build.VERSION.SDK_INT}.
|
|
*
|
|
* @hide For platform use only; we don't expect developers to need to read this value.
|
|
*/
|
|
public int compileSdkVersion;
|
|
|
|
/**
|
|
* The development codename (ex. "O", "REL") of the framework against which the application
|
|
* claims to have been compiled, or {@code null} if not specified.
|
|
* <p>
|
|
* This property is the compile-time equivalent of
|
|
* {@link android.os.Build.VERSION#CODENAME Build.VERSION.CODENAME}.
|
|
*
|
|
* @hide For platform use only; we don't expect developers to need to read this value.
|
|
*/
|
|
@Nullable
|
|
public String compileSdkVersionCodename;
|
|
|
|
/**
|
|
* Whether the package is an APEX package.
|
|
*/
|
|
public boolean isApex;
|
|
|
|
/**
|
|
* Whether this is an active APEX package.
|
|
* @hide
|
|
*/
|
|
public boolean isActiveApex;
|
|
|
|
/**
|
|
* If the package is an APEX package (i.e. the value of {@link #isApex}
|
|
* is true), this field is the package name of the APEX. If the package
|
|
* is one APK-in-APEX app, this field is the package name of the parent
|
|
* APEX that contains the app. If the package is not one of the above
|
|
* two cases, this field is {@code null}.
|
|
*/
|
|
@Nullable
|
|
private String mApexPackageName;
|
|
|
|
public PackageInfo() {
|
|
}
|
|
|
|
/**
|
|
* Returns true if the package is a valid Runtime Overlay package.
|
|
* @hide
|
|
*/
|
|
public boolean isOverlayPackage() {
|
|
return overlayTarget != null;
|
|
}
|
|
|
|
/**
|
|
* Returns true if the package is a valid static Runtime Overlay package. Static overlays
|
|
* are not updatable outside of a system update and are safe to load in the system process.
|
|
* @hide
|
|
*/
|
|
public boolean isStaticOverlayPackage() {
|
|
return overlayTarget != null && mOverlayIsStatic;
|
|
}
|
|
|
|
/**
|
|
* Returns the time at which the app was archived for the user. Units are as
|
|
* per {@link System#currentTimeMillis()}.
|
|
*/
|
|
@FlaggedApi(Flags.FLAG_ARCHIVING)
|
|
public @CurrentTimeMillisLong long getArchiveTimeMillis() {
|
|
return mArchiveTimeMillis;
|
|
}
|
|
|
|
/**
|
|
* @hide
|
|
*/
|
|
public void setArchiveTimeMillis(@CurrentTimeMillisLong long value) {
|
|
mArchiveTimeMillis = value;
|
|
}
|
|
|
|
/**
|
|
* If the package is an APEX package (i.e. the value of {@link #isApex}
|
|
* is true), returns the package name of the APEX. If the package
|
|
* is one APK-in-APEX app, returns the package name of the parent
|
|
* APEX that contains the app. If the package is not one of the above
|
|
* two cases, returns {@code null}.
|
|
*/
|
|
@Nullable
|
|
@FlaggedApi(android.content.pm.Flags.FLAG_PROVIDE_INFO_OF_APK_IN_APEX)
|
|
public String getApexPackageName() {
|
|
return mApexPackageName;
|
|
}
|
|
|
|
/**
|
|
* @hide
|
|
*/
|
|
public void setApexPackageName(@Nullable String apexPackageName) {
|
|
mApexPackageName = apexPackageName;
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
return "PackageInfo{"
|
|
+ Integer.toHexString(System.identityHashCode(this))
|
|
+ " " + packageName + "}";
|
|
}
|
|
|
|
@Override
|
|
public int describeContents() {
|
|
return 0;
|
|
}
|
|
|
|
@Override
|
|
public void writeToParcel(Parcel dest, int parcelableFlags) {
|
|
// Allow ApplicationInfo to be squashed.
|
|
final boolean prevAllowSquashing = dest.allowSquashing();
|
|
dest.writeString8(packageName);
|
|
dest.writeString8Array(splitNames);
|
|
dest.writeInt(versionCode);
|
|
dest.writeInt(versionCodeMajor);
|
|
dest.writeString8(versionName);
|
|
dest.writeInt(baseRevisionCode);
|
|
dest.writeIntArray(splitRevisionCodes);
|
|
dest.writeString8(sharedUserId);
|
|
dest.writeInt(sharedUserLabel);
|
|
if (applicationInfo != null) {
|
|
dest.writeInt(1);
|
|
applicationInfo.writeToParcel(dest, parcelableFlags);
|
|
} else {
|
|
dest.writeInt(0);
|
|
}
|
|
dest.writeLong(firstInstallTime);
|
|
dest.writeLong(lastUpdateTime);
|
|
dest.writeIntArray(gids);
|
|
dest.writeTypedArray(activities, parcelableFlags);
|
|
dest.writeTypedArray(receivers, parcelableFlags);
|
|
dest.writeTypedArray(services, parcelableFlags);
|
|
dest.writeTypedArray(providers, parcelableFlags);
|
|
dest.writeTypedArray(instrumentation, parcelableFlags);
|
|
dest.writeTypedArray(permissions, parcelableFlags);
|
|
dest.writeString8Array(requestedPermissions);
|
|
dest.writeIntArray(requestedPermissionsFlags);
|
|
dest.writeTypedArray(signatures, parcelableFlags);
|
|
dest.writeTypedArray(configPreferences, parcelableFlags);
|
|
dest.writeTypedArray(reqFeatures, parcelableFlags);
|
|
dest.writeTypedArray(featureGroups, parcelableFlags);
|
|
dest.writeTypedArray(attributions, parcelableFlags);
|
|
dest.writeInt(installLocation);
|
|
dest.writeInt(isStub ? 1 : 0);
|
|
dest.writeInt(coreApp ? 1 : 0);
|
|
dest.writeInt(requiredForAllUsers ? 1 : 0);
|
|
dest.writeString8(restrictedAccountType);
|
|
dest.writeString8(requiredAccountType);
|
|
dest.writeString8(overlayTarget);
|
|
dest.writeString8(overlayCategory);
|
|
dest.writeInt(overlayPriority);
|
|
dest.writeBoolean(mOverlayIsStatic);
|
|
dest.writeInt(compileSdkVersion);
|
|
dest.writeString8(compileSdkVersionCodename);
|
|
if (signingInfo != null) {
|
|
dest.writeInt(1);
|
|
signingInfo.writeToParcel(dest, parcelableFlags);
|
|
} else {
|
|
dest.writeInt(0);
|
|
}
|
|
dest.writeBoolean(isApex);
|
|
dest.writeBoolean(isActiveApex);
|
|
dest.writeLong(mArchiveTimeMillis);
|
|
if (mApexPackageName != null) {
|
|
dest.writeInt(1);
|
|
dest.writeString8(mApexPackageName);
|
|
} else {
|
|
dest.writeInt(0);
|
|
}
|
|
dest.restoreAllowSquashing(prevAllowSquashing);
|
|
}
|
|
|
|
public static final @android.annotation.NonNull Parcelable.Creator<PackageInfo> CREATOR
|
|
= new Parcelable.Creator<PackageInfo>() {
|
|
@Override
|
|
public PackageInfo createFromParcel(Parcel source) {
|
|
return new PackageInfo(source);
|
|
}
|
|
|
|
@Override
|
|
public PackageInfo[] newArray(int size) {
|
|
return new PackageInfo[size];
|
|
}
|
|
};
|
|
|
|
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P, trackingBug = 115609023)
|
|
private PackageInfo(Parcel source) {
|
|
packageName = source.readString8();
|
|
splitNames = source.createString8Array();
|
|
versionCode = source.readInt();
|
|
versionCodeMajor = source.readInt();
|
|
versionName = source.readString8();
|
|
baseRevisionCode = source.readInt();
|
|
splitRevisionCodes = source.createIntArray();
|
|
sharedUserId = source.readString8();
|
|
sharedUserLabel = source.readInt();
|
|
int hasApp = source.readInt();
|
|
if (hasApp != 0) {
|
|
applicationInfo = ApplicationInfo.CREATOR.createFromParcel(source);
|
|
}
|
|
firstInstallTime = source.readLong();
|
|
lastUpdateTime = source.readLong();
|
|
gids = source.createIntArray();
|
|
activities = source.createTypedArray(ActivityInfo.CREATOR);
|
|
receivers = source.createTypedArray(ActivityInfo.CREATOR);
|
|
services = source.createTypedArray(ServiceInfo.CREATOR);
|
|
providers = source.createTypedArray(ProviderInfo.CREATOR);
|
|
instrumentation = source.createTypedArray(InstrumentationInfo.CREATOR);
|
|
permissions = source.createTypedArray(PermissionInfo.CREATOR);
|
|
requestedPermissions = source.createString8Array();
|
|
requestedPermissionsFlags = source.createIntArray();
|
|
signatures = source.createTypedArray(Signature.CREATOR);
|
|
configPreferences = source.createTypedArray(ConfigurationInfo.CREATOR);
|
|
reqFeatures = source.createTypedArray(FeatureInfo.CREATOR);
|
|
featureGroups = source.createTypedArray(FeatureGroupInfo.CREATOR);
|
|
attributions = source.createTypedArray(Attribution.CREATOR);
|
|
installLocation = source.readInt();
|
|
isStub = source.readInt() != 0;
|
|
coreApp = source.readInt() != 0;
|
|
requiredForAllUsers = source.readInt() != 0;
|
|
restrictedAccountType = source.readString8();
|
|
requiredAccountType = source.readString8();
|
|
overlayTarget = source.readString8();
|
|
overlayCategory = source.readString8();
|
|
overlayPriority = source.readInt();
|
|
mOverlayIsStatic = source.readBoolean();
|
|
compileSdkVersion = source.readInt();
|
|
compileSdkVersionCodename = source.readString8();
|
|
int hasSigningInfo = source.readInt();
|
|
if (hasSigningInfo != 0) {
|
|
signingInfo = SigningInfo.CREATOR.createFromParcel(source);
|
|
}
|
|
isApex = source.readBoolean();
|
|
isActiveApex = source.readBoolean();
|
|
mArchiveTimeMillis = source.readLong();
|
|
int hasApexPackageName = source.readInt();
|
|
if (hasApexPackageName != 0) {
|
|
mApexPackageName = source.readString8();
|
|
}
|
|
}
|
|
}
|