private static final boolean DEBUG_PARSER = false;
private static final boolean DEBUG_BACKUP = false;
+ private static final int MAX_PACKAGES_PER_APK = 5;
+
// TODO: switch outError users to PackageParserException
// TODO: refactor "codePath" to "apkPath"
/** Path prefix for apps on expanded storage */
private static final String MNT_EXPAND = "/mnt/expand/";
+ private static final String TAG_MANIFEST = "manifest";
+ private static final String TAG_APPLICATION = "application";
+ private static final String TAG_OVERLAY = "overlay";
+ private static final String TAG_KEY_SETS = "key-sets";
+ private static final String TAG_PERMISSION_GROUP = "permission-group";
+ private static final String TAG_PERMISSION = "permission";
+ private static final String TAG_PERMISSION_TREE = "permission-tree";
+ private static final String TAG_USES_PERMISSION = "uses-permission";
+ private static final String TAG_USES_PERMISSION_SDK_M = "uses-permission-sdk-m";
+ private static final String TAG_USES_PERMISSION_SDK_23 = "uses-permission-sdk-23";
+ private static final String TAG_USES_CONFIGURATION = "uses-configuration";
+ private static final String TAG_USES_FEATURE = "uses-feature";
+ private static final String TAG_FEATURE_GROUP = "feature-group";
+ private static final String TAG_USES_SDK = "uses-sdk";
+ private static final String TAG_SUPPORT_SCREENS = "supports-screens";
+ private static final String TAG_PROTECTED_BROADCAST = "protected-broadcast";
+ private static final String TAG_INSTRUMENTATION = "instrumentation";
+ private static final String TAG_ORIGINAL_PACKAGE = "original-package";
+ private static final String TAG_ADOPT_PERMISSIONS = "adopt-permissions";
+ private static final String TAG_USES_GL_TEXTURE = "uses-gl-texture";
+ private static final String TAG_COMPATIBLE_SCREENS = "compatible-screens";
+ private static final String TAG_SUPPORTS_INPUT = "supports-input";
+ private static final String TAG_EAT_COMMENT = "eat-comment";
+ private static final String TAG_PACKAGE = "package";
+
+ // These are the tags supported by child packages
+ private static final Set<String> CHILD_PACKAGE_TAGS = new ArraySet<>();
+ static {
+ CHILD_PACKAGE_TAGS.add(TAG_APPLICATION);
+ CHILD_PACKAGE_TAGS.add(TAG_USES_PERMISSION);
+ CHILD_PACKAGE_TAGS.add(TAG_USES_PERMISSION_SDK_M);
+ CHILD_PACKAGE_TAGS.add(TAG_USES_PERMISSION_SDK_23);
+ CHILD_PACKAGE_TAGS.add(TAG_USES_CONFIGURATION);
+ CHILD_PACKAGE_TAGS.add(TAG_USES_FEATURE);
+ CHILD_PACKAGE_TAGS.add(TAG_FEATURE_GROUP);
+ CHILD_PACKAGE_TAGS.add(TAG_USES_SDK);
+ CHILD_PACKAGE_TAGS.add(TAG_SUPPORT_SCREENS);
+ CHILD_PACKAGE_TAGS.add(TAG_INSTRUMENTATION);
+ CHILD_PACKAGE_TAGS.add(TAG_USES_GL_TEXTURE);
+ CHILD_PACKAGE_TAGS.add(TAG_COMPATIBLE_SCREENS);
+ CHILD_PACKAGE_TAGS.add(TAG_SUPPORTS_INPUT);
+ CHILD_PACKAGE_TAGS.add(TAG_EAT_COMMENT);
+ }
+
/** @hide */
public static class NewPermissionInfo {
public final String name;
}
}
- pkg.codePath = packageDir.getAbsolutePath();
- pkg.cpuAbiOverride = lite.abiOverride;
+ pkg.setCodePath(packageDir.getAbsolutePath());
+ pkg.setCpuAbiOverride(lite.abiOverride);
+
return pkg;
} finally {
IoUtils.closeQuietly(assets);
final AssetManager assets = new AssetManager();
try {
final Package pkg = parseBaseApk(apkFile, assets, flags);
- pkg.codePath = apkFile.getAbsolutePath();
- pkg.cpuAbiOverride = lite.abiOverride;
+ pkg.setCodePath(apkFile.getAbsolutePath());
+ pkg.setCpuAbiOverride(lite.abiOverride);
return pkg;
} finally {
IoUtils.closeQuietly(assets);
apkPath + " (at " + parser.getPositionDescription() + "): " + outError[0]);
}
- pkg.volumeUuid = volumeUuid;
- pkg.applicationInfo.volumeUuid = volumeUuid;
- pkg.baseCodePath = apkPath;
- pkg.mSignatures = null;
+ pkg.setVolumeUuid(volumeUuid);
+ pkg.setApplicationVolumeUuid(volumeUuid);
+ pkg.setBaseCodePath(apkPath);
+ pkg.setSignatures(null);
return pkg;
AttributeSet attrs = parser;
// We parsed manifest tag earlier; just skip past it
- parsePackageSplitNames(parser, attrs, flags);
+ parsePackageSplitNames(parser, attrs);
mParseInstrumentationArgs = null;
mParseActivityArgs = null;
}
foundApp = true;
- if (!parseSplitApplication(pkg, res, parser, attrs, flags, splitIndex, outError)) {
+ if (!parseSplitApplication(pkg, res, parser, flags, splitIndex, outError)) {
return null;
}
* populating {@link Package#mSignatures}. Also asserts that all APK
* contents are signed correctly and consistently.
*/
- public void collectCertificates(Package pkg, int parseFlags) throws PackageParserException {
+ public static void collectCertificates(Package pkg, int parseFlags) throws PackageParserException {
+ collectCertificatesInternal(pkg, parseFlags);
+ final int childCount = (pkg.childPackages != null) ? pkg.childPackages.size() : 0;
+ for (int i = 0; i < childCount; i++) {
+ Package childPkg = pkg.childPackages.get(i);
+ childPkg.mCertificates = pkg.mCertificates;
+ childPkg.mSignatures = pkg.mSignatures;
+ childPkg.mSigningKeys = pkg.mSigningKeys;
+ }
+ }
+
+ private static void collectCertificatesInternal(Package pkg, int parseFlags) throws PackageParserException {
pkg.mCertificates = null;
pkg.mSignatures = null;
pkg.mSigningKeys = null;
}
private static Pair<String, String> parsePackageSplitNames(XmlPullParser parser,
- AttributeSet attrs, int flags) throws IOException, XmlPullParserException,
+ AttributeSet attrs) throws IOException, XmlPullParserException,
PackageParserException {
int type;
throw new PackageParserException(INSTALL_PARSE_FAILED_MANIFEST_MALFORMED,
"No start tag found");
}
- if (!parser.getName().equals("manifest")) {
+ if (!parser.getName().equals(TAG_MANIFEST)) {
throw new PackageParserException(INSTALL_PARSE_FAILED_MANIFEST_MALFORMED,
"No <manifest> tag");
}
private static ApkLite parseApkLite(String codePath, Resources res, XmlPullParser parser,
AttributeSet attrs, int flags, Signature[] signatures) throws IOException,
XmlPullParserException, PackageParserException {
- final Pair<String, String> packageSplit = parsePackageSplitNames(parser, attrs, flags);
+ final Pair<String, String> packageSplit = parsePackageSplitNames(parser, attrs);
int installLocation = PARSE_DEFAULT_INSTALL_LOCATION;
int versionCode = 0;
}
/**
- * Parse the manifest of a <em>base APK</em>.
- * <p>
- * When adding new features, carefully consider if they should also be
- * supported by split APKs.
+ * Parses a child package and adds it to the parent if successful. If you add
+ * new tags that need to be supported by child packages make sure to add them
+ * to {@link #CHILD_PACKAGE_TAGS}.
+ *
+ * @param parentPkg The parent that contains the child
+ * @param res Resources against which to resolve values
+ * @param parser Parser of the manifest
+ * @param flags Flags about how to parse
+ * @param outError Human readable error if parsing fails
+ * @return True of parsing succeeded.
+ *
+ * @throws XmlPullParserException
+ * @throws IOException
*/
- private Package parseBaseApk(Resources res, XmlResourceParser parser, int flags,
- String[] outError) throws XmlPullParserException, IOException {
- final boolean trustedOverlay = (flags & PARSE_TRUSTED_OVERLAY) != 0;
+ private boolean parseBaseApkChild(Package parentPkg, Resources res, XmlResourceParser parser,
+ int flags, String[] outError) throws XmlPullParserException, IOException {
+ // Let ppl not abuse this mechanism by limiting the packages per APK
+ if (parentPkg.childPackages != null && parentPkg.childPackages.size() + 2
+ > MAX_PACKAGES_PER_APK) {
+ outError[0] = "Maximum number of packages per APK is: " + MAX_PACKAGES_PER_APK;
+ mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
+ return false;
+ }
- AttributeSet attrs = parser;
+ // Make sure we have a valid child package name
+ String childPackageName = parser.getAttributeValue(null, "package");
+ if (validateName(childPackageName, true, false) != null) {
+ mParseError = PackageManager.INSTALL_PARSE_FAILED_BAD_PACKAGE_NAME;
+ return false;
+ }
- mParseInstrumentationArgs = null;
- mParseActivityArgs = null;
- mParseServiceArgs = null;
- mParseProviderArgs = null;
+ // Child packages must be unique
+ if (childPackageName.equals(parentPkg.packageName)) {
+ String message = "Child package name cannot be equal to parent package name: "
+ + parentPkg.packageName;
+ Slog.w(TAG, message);
+ outError[0] = message;
+ mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
+ return false;
+ }
- final String pkgName;
+ // Child packages must be unique
+ if (parentPkg.hasChildPackage(childPackageName)) {
+ String message = "Duplicate child package:" + childPackageName;
+ Slog.w(TAG, message);
+ outError[0] = message;
+ mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
+ return false;
+ }
+
+ // Go ahead and parse the child
+ Package childPkg = new Package(childPackageName);
+
+ // Child package inherits parent version code/name/target SDK
+ childPkg.mVersionCode = parentPkg.mVersionCode;
+ childPkg.baseRevisionCode = parentPkg.baseRevisionCode;
+ childPkg.mVersionName = parentPkg.mVersionName;
+ childPkg.applicationInfo.targetSdkVersion = parentPkg.applicationInfo.targetSdkVersion;
+
+ childPkg = parseBaseApkCommon(childPkg, CHILD_PACKAGE_TAGS, res, parser, flags, outError);
+ if (childPkg == null) {
+ // If we got null then error was set during child parsing
+ return false;
+ }
+
+ // Set the parent-child relation
+ if (parentPkg.childPackages == null) {
+ parentPkg.childPackages = new ArrayList<>();
+ }
+ parentPkg.childPackages.add(childPkg);
+ childPkg.parentPackage = parentPkg;
+
+ return true;
+ }
+
+ /**
+ * Parse the manifest of a <em>base APK</em>. When adding new features you
+ * need to consider whether they should be supported by split APKs and child
+ * packages.
+ *
+ * @param res The resources from which to resolve values
+ * @param parser The manifest parser
+ * @param flags Flags how to parse
+ * @param outError Human readable error message
+ * @return Parsed package or null on error.
+ *
+ * @throws XmlPullParserException
+ * @throws IOException
+ */
+ private Package parseBaseApk(Resources res, XmlResourceParser parser, int flags,
+ String[] outError) throws XmlPullParserException, IOException {
final String splitName;
+ final String pkgName;
+
try {
- Pair<String, String> packageSplit = parsePackageSplitNames(parser, attrs, flags);
+ Pair<String, String> packageSplit = parsePackageSplitNames(parser, parser);
pkgName = packageSplit.first;
splitName = packageSplit.second;
- } catch (PackageParserException e) {
- mParseError = PackageManager.INSTALL_PARSE_FAILED_BAD_PACKAGE_NAME;
- return null;
- }
- int type;
-
- if (!TextUtils.isEmpty(splitName)) {
- outError[0] = "Expected base APK, but found split " + splitName;
+ if (!TextUtils.isEmpty(splitName)) {
+ outError[0] = "Expected base APK, but found split " + splitName;
+ mParseError = PackageManager.INSTALL_PARSE_FAILED_BAD_PACKAGE_NAME;
+ return null;
+ }
+ } catch (PackageParserException e) {
mParseError = PackageManager.INSTALL_PARSE_FAILED_BAD_PACKAGE_NAME;
return null;
}
final Package pkg = new Package(pkgName);
- boolean foundApp = false;
- TypedArray sa = res.obtainAttributes(attrs,
+ TypedArray sa = res.obtainAttributes(parser,
com.android.internal.R.styleable.AndroidManifest);
+
pkg.mVersionCode = pkg.applicationInfo.versionCode = sa.getInteger(
com.android.internal.R.styleable.AndroidManifest_versionCode, 0);
pkg.baseRevisionCode = sa.getInteger(
if (pkg.mVersionName != null) {
pkg.mVersionName = pkg.mVersionName.intern();
}
+
+ pkg.coreApp = parser.getAttributeBooleanValue(null, "coreApp", false);
+
+ sa.recycle();
+
+ return parseBaseApkCommon(pkg, null, res, parser, flags, outError);
+ }
+
+ /**
+ * This is the common parsing routing for handling parent and child
+ * packages in a base APK. The difference between parent and child
+ * parsing is that some targs are not supported by child packages as
+ * well as some manifest attributes are ignored. The implementation
+ * assumes the calling code already handled the manifest tag if needed
+ * (this applies to the parent only).
+ *
+ * @param pkg The package which to populate
+ * @param acceptedTags Which tags to handle, null to handle all
+ * @param res Resources against which to resolve values
+ * @param parser Parser of the manifest
+ * @param flags Flags about how to parse
+ * @param outError Human readable error if parsing fails
+ * @return The package if parsing succeeded or null.
+ *
+ * @throws XmlPullParserException
+ * @throws IOException
+ */
+ private Package parseBaseApkCommon(Package pkg, Set<String> acceptedTags, Resources res,
+ XmlResourceParser parser, int flags, String[] outError) throws XmlPullParserException,
+ IOException {
+ final boolean trustedOverlay = (flags & PARSE_TRUSTED_OVERLAY) != 0;
+ mParseInstrumentationArgs = null;
+ mParseActivityArgs = null;
+ mParseServiceArgs = null;
+ mParseProviderArgs = null;
+
+ int type;
+ boolean foundApp = false;
+
+ TypedArray sa = res.obtainAttributes(parser,
+ com.android.internal.R.styleable.AndroidManifest);
+
String str = sa.getNonConfigurationString(
com.android.internal.R.styleable.AndroidManifest_sharedUserId, 0);
if (str != null && str.length() > 0) {
String nameError = validateName(str, true, false);
- if (nameError != null && !"android".equals(pkgName)) {
+ if (nameError != null && !"android".equals(pkg.packageName)) {
outError[0] = "<manifest> specifies bad sharedUserId name \""
+ str + "\": " + nameError;
mParseError = PackageManager.INSTALL_PARSE_FAILED_BAD_SHARED_USER_ID;
PARSE_DEFAULT_INSTALL_LOCATION);
pkg.applicationInfo.installLocation = pkg.installLocation;
- pkg.coreApp = attrs.getAttributeBooleanValue(null, "coreApp", false);
-
- sa.recycle();
/* Set the global "forward lock" flag */
if ((flags & PARSE_FORWARD_LOCK) != 0) {
}
String tagName = parser.getName();
- if (tagName.equals("application")) {
+
+ if (acceptedTags != null && !acceptedTags.contains(tagName)) {
+ Slog.w(TAG, "Skipping unsupported element under <manifest>: "
+ + tagName + " at " + mArchiveSourcePath + " "
+ + parser.getPositionDescription());
+ XmlUtils.skipCurrentTag(parser);
+ continue;
+ }
+
+ if (tagName.equals(TAG_APPLICATION)) {
if (foundApp) {
if (RIGID_PARSER) {
outError[0] = "<manifest> has more than one <application>";
}
foundApp = true;
- if (!parseBaseApplication(pkg, res, parser, attrs, flags, outError)) {
+ if (!parseBaseApplication(pkg, res, parser, flags, outError)) {
return null;
}
- } else if (tagName.equals("overlay")) {
+ } else if (tagName.equals(TAG_OVERLAY)) {
pkg.mTrustedOverlay = trustedOverlay;
- sa = res.obtainAttributes(attrs,
+ sa = res.obtainAttributes(parser,
com.android.internal.R.styleable.AndroidManifestResourceOverlay);
pkg.mOverlayTarget = sa.getString(
com.android.internal.R.styleable.AndroidManifestResourceOverlay_targetPackage);
}
XmlUtils.skipCurrentTag(parser);
- } else if (tagName.equals("key-sets")) {
- if (!parseKeySets(pkg, res, parser, attrs, outError)) {
+ } else if (tagName.equals(TAG_KEY_SETS)) {
+ if (!parseKeySets(pkg, res, parser, outError)) {
return null;
}
- } else if (tagName.equals("permission-group")) {
- if (parsePermissionGroup(pkg, flags, res, parser, attrs, outError) == null) {
+ } else if (tagName.equals(TAG_PERMISSION_GROUP)) {
+ if (parsePermissionGroup(pkg, flags, res, parser, outError) == null) {
return null;
}
- } else if (tagName.equals("permission")) {
- if (parsePermission(pkg, res, parser, attrs, outError) == null) {
+ } else if (tagName.equals(TAG_PERMISSION)) {
+ if (parsePermission(pkg, res, parser, outError) == null) {
return null;
}
- } else if (tagName.equals("permission-tree")) {
- if (parsePermissionTree(pkg, res, parser, attrs, outError) == null) {
+ } else if (tagName.equals(TAG_PERMISSION_TREE)) {
+ if (parsePermissionTree(pkg, res, parser, outError) == null) {
return null;
}
- } else if (tagName.equals("uses-permission")) {
- if (!parseUsesPermission(pkg, res, parser, attrs)) {
+ } else if (tagName.equals(TAG_USES_PERMISSION)) {
+ if (!parseUsesPermission(pkg, res, parser)) {
return null;
}
- } else if (tagName.equals("uses-permission-sdk-m")
- || tagName.equals("uses-permission-sdk-23")) {
- if (!parseUsesPermission(pkg, res, parser, attrs)) {
+ } else if (tagName.equals(TAG_USES_PERMISSION_SDK_M)
+ || tagName.equals(TAG_USES_PERMISSION_SDK_23)) {
+ if (!parseUsesPermission(pkg, res, parser)) {
return null;
}
- } else if (tagName.equals("uses-configuration")) {
+ } else if (tagName.equals(TAG_USES_CONFIGURATION)) {
ConfigurationInfo cPref = new ConfigurationInfo();
- sa = res.obtainAttributes(attrs,
+ sa = res.obtainAttributes(parser,
com.android.internal.R.styleable.AndroidManifestUsesConfiguration);
cPref.reqTouchScreen = sa.getInt(
com.android.internal.R.styleable.AndroidManifestUsesConfiguration_reqTouchScreen,
XmlUtils.skipCurrentTag(parser);
- } else if (tagName.equals("uses-feature")) {
- FeatureInfo fi = parseUsesFeature(res, attrs);
+ } else if (tagName.equals(TAG_USES_FEATURE)) {
+ FeatureInfo fi = parseUsesFeature(res, parser);
pkg.reqFeatures = ArrayUtils.add(pkg.reqFeatures, fi);
if (fi.name == null) {
XmlUtils.skipCurrentTag(parser);
- } else if (tagName.equals("feature-group")) {
+ } else if (tagName.equals(TAG_FEATURE_GROUP)) {
FeatureGroupInfo group = new FeatureGroupInfo();
ArrayList<FeatureInfo> features = null;
final int innerDepth = parser.getDepth();
final String innerTagName = parser.getName();
if (innerTagName.equals("uses-feature")) {
- FeatureInfo featureInfo = parseUsesFeature(res, attrs);
+ FeatureInfo featureInfo = parseUsesFeature(res, parser);
// FeatureGroups are stricter and mandate that
// any <uses-feature> declared are mandatory.
featureInfo.flags |= FeatureInfo.FLAG_REQUIRED;
}
pkg.featureGroups = ArrayUtils.add(pkg.featureGroups, group);
- } else if (tagName.equals("uses-sdk")) {
+ } else if (tagName.equals(TAG_USES_SDK)) {
if (SDK_VERSION > 0) {
- sa = res.obtainAttributes(attrs,
+ sa = res.obtainAttributes(parser,
com.android.internal.R.styleable.AndroidManifestUsesSdk);
int minVers = 0;
XmlUtils.skipCurrentTag(parser);
- } else if (tagName.equals("supports-screens")) {
- sa = res.obtainAttributes(attrs,
+ } else if (tagName.equals(TAG_SUPPORT_SCREENS)) {
+ sa = res.obtainAttributes(parser,
com.android.internal.R.styleable.AndroidManifestSupportsScreens);
pkg.applicationInfo.requiresSmallestWidthDp = sa.getInteger(
XmlUtils.skipCurrentTag(parser);
- } else if (tagName.equals("protected-broadcast")) {
- sa = res.obtainAttributes(attrs,
+ } else if (tagName.equals(TAG_PROTECTED_BROADCAST)) {
+ sa = res.obtainAttributes(parser,
com.android.internal.R.styleable.AndroidManifestProtectedBroadcast);
// Note: don't allow this value to be a reference to a resource
XmlUtils.skipCurrentTag(parser);
- } else if (tagName.equals("instrumentation")) {
- if (parseInstrumentation(pkg, res, parser, attrs, outError) == null) {
+ } else if (tagName.equals(TAG_INSTRUMENTATION)) {
+ if (parseInstrumentation(pkg, res, parser, outError) == null) {
return null;
}
-
- } else if (tagName.equals("original-package")) {
- sa = res.obtainAttributes(attrs,
+ } else if (tagName.equals(TAG_ORIGINAL_PACKAGE)) {
+ sa = res.obtainAttributes(parser,
com.android.internal.R.styleable.AndroidManifestOriginalPackage);
String orig =sa.getNonConfigurationString(
XmlUtils.skipCurrentTag(parser);
- } else if (tagName.equals("adopt-permissions")) {
- sa = res.obtainAttributes(attrs,
+ } else if (tagName.equals(TAG_ADOPT_PERMISSIONS)) {
+ sa = res.obtainAttributes(parser,
com.android.internal.R.styleable.AndroidManifestOriginalPackage);
String name = sa.getNonConfigurationString(
XmlUtils.skipCurrentTag(parser);
- } else if (tagName.equals("uses-gl-texture")) {
+ } else if (tagName.equals(TAG_USES_GL_TEXTURE)) {
// Just skip this tag
XmlUtils.skipCurrentTag(parser);
continue;
- } else if (tagName.equals("compatible-screens")) {
+ } else if (tagName.equals(TAG_COMPATIBLE_SCREENS)) {
// Just skip this tag
XmlUtils.skipCurrentTag(parser);
continue;
- } else if (tagName.equals("supports-input")) {
+ } else if (tagName.equals(TAG_SUPPORTS_INPUT)) {//
XmlUtils.skipCurrentTag(parser);
continue;
- } else if (tagName.equals("eat-comment")) {
+ } else if (tagName.equals(TAG_EAT_COMMENT)) {
// Just skip this tag
XmlUtils.skipCurrentTag(parser);
continue;
+ } else if (tagName.equals(TAG_PACKAGE)) {
+ if (!parseBaseApkChild(pkg, res, parser, flags, outError)) {
+ // If parsing a child failed the error is already set
+ return null;
+ }
} else if (RIGID_PARSER) {
outError[0] = "Bad element under <manifest>: "
+ parser.getName();
return fi;
}
- private boolean parseUsesPermission(Package pkg, Resources res, XmlResourceParser parser,
- AttributeSet attrs) throws XmlPullParserException, IOException {
- TypedArray sa = res.obtainAttributes(attrs,
+ private boolean parseUsesPermission(Package pkg, Resources res, XmlResourceParser parser)
+ throws XmlPullParserException, IOException {
+ TypedArray sa = res.obtainAttributes(parser,
com.android.internal.R.styleable.AndroidManifestUsesPermission);
// Note: don't allow this value to be a reference to a resource
}
private boolean parseKeySets(Package owner, Resources res,
- XmlPullParser parser, AttributeSet attrs, String[] outError)
+ XmlResourceParser parser, String[] outError)
throws XmlPullParserException, IOException {
// we've encountered the 'key-sets' tag
// all the keys and keysets that we want must be defined here
mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
return false;
}
- final TypedArray sa = res.obtainAttributes(attrs,
+ final TypedArray sa = res.obtainAttributes(parser,
com.android.internal.R.styleable.AndroidManifestKeySet);
final String keysetName = sa.getNonResourceString(
com.android.internal.R.styleable.AndroidManifestKeySet_name);
mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
return false;
}
- final TypedArray sa = res.obtainAttributes(attrs,
+ final TypedArray sa = res.obtainAttributes(parser,
com.android.internal.R.styleable.AndroidManifestPublicKey);
final String publicKeyName = sa.getNonResourceString(
com.android.internal.R.styleable.AndroidManifestPublicKey_name);
sa.recycle();
XmlUtils.skipCurrentTag(parser);
} else if (tagName.equals("upgrade-key-set")) {
- final TypedArray sa = res.obtainAttributes(attrs,
+ final TypedArray sa = res.obtainAttributes(parser,
com.android.internal.R.styleable.AndroidManifestUpgradeKeySet);
String name = sa.getNonResourceString(
com.android.internal.R.styleable.AndroidManifestUpgradeKeySet_name);
}
private PermissionGroup parsePermissionGroup(Package owner, int flags, Resources res,
- XmlPullParser parser, AttributeSet attrs, String[] outError)
- throws XmlPullParserException, IOException {
+ XmlResourceParser parser, String[] outError)
+ throws XmlPullParserException, IOException {
PermissionGroup perm = new PermissionGroup(owner);
- TypedArray sa = res.obtainAttributes(attrs,
+ TypedArray sa = res.obtainAttributes(parser,
com.android.internal.R.styleable.AndroidManifestPermissionGroup);
if (!parsePackageItemInfo(owner, perm.info, outError,
sa.recycle();
- if (!parseAllMetaData(res, parser, attrs, "<permission-group>", perm,
+ if (!parseAllMetaData(res, parser, "<permission-group>", perm,
outError)) {
mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
return null;
}
private Permission parsePermission(Package owner, Resources res,
- XmlPullParser parser, AttributeSet attrs, String[] outError)
+ XmlResourceParser parser, String[] outError)
throws XmlPullParserException, IOException {
Permission perm = new Permission(owner);
- TypedArray sa = res.obtainAttributes(attrs,
+ TypedArray sa = res.obtainAttributes(parser,
com.android.internal.R.styleable.AndroidManifestPermission);
if (!parsePackageItemInfo(owner, perm.info, outError,
}
}
- if (!parseAllMetaData(res, parser, attrs, "<permission>", perm,
- outError)) {
+ if (!parseAllMetaData(res, parser, "<permission>", perm, outError)) {
mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
return null;
}
}
private Permission parsePermissionTree(Package owner, Resources res,
- XmlPullParser parser, AttributeSet attrs, String[] outError)
+ XmlResourceParser parser, String[] outError)
throws XmlPullParserException, IOException {
Permission perm = new Permission(owner);
- TypedArray sa = res.obtainAttributes(attrs,
+ TypedArray sa = res.obtainAttributes(parser,
com.android.internal.R.styleable.AndroidManifestPermissionTree);
if (!parsePackageItemInfo(owner, perm.info, outError,
perm.info.protectionLevel = PermissionInfo.PROTECTION_NORMAL;
perm.tree = true;
- if (!parseAllMetaData(res, parser, attrs, "<permission-tree>", perm,
+ if (!parseAllMetaData(res, parser, "<permission-tree>", perm,
outError)) {
mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
return null;
}
private Instrumentation parseInstrumentation(Package owner, Resources res,
- XmlPullParser parser, AttributeSet attrs, String[] outError)
- throws XmlPullParserException, IOException {
- TypedArray sa = res.obtainAttributes(attrs,
+ XmlResourceParser parser, String[] outError)
+ throws XmlPullParserException, IOException {
+ TypedArray sa = res.obtainAttributes(parser,
com.android.internal.R.styleable.AndroidManifestInstrumentation);
if (mParseInstrumentationArgs == null) {
return null;
}
- if (!parseAllMetaData(res, parser, attrs, "<instrumentation>", a,
+ if (!parseAllMetaData(res, parser, "<instrumentation>", a,
outError)) {
mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
return null;
* supported by split APKs.
*/
private boolean parseBaseApplication(Package owner, Resources res,
- XmlPullParser parser, AttributeSet attrs, int flags, String[] outError)
+ XmlResourceParser parser, int flags, String[] outError)
throws XmlPullParserException, IOException {
final ApplicationInfo ai = owner.applicationInfo;
final String pkgName = owner.applicationInfo.packageName;
- TypedArray sa = res.obtainAttributes(attrs,
+ TypedArray sa = res.obtainAttributes(parser,
com.android.internal.R.styleable.AndroidManifestApplication);
String name = sa.getNonConfigurationString(
ai.flags |= ApplicationInfo.FLAG_ALLOW_CLEAR_USER_DATA;
}
- if (sa.getBoolean(
- com.android.internal.R.styleable.AndroidManifestApplication_testOnly,
- false)) {
- ai.flags |= ApplicationInfo.FLAG_TEST_ONLY;
+ // The parent package controls installation, hence specify test only installs.
+ if (owner.parentPackage == null) {
+ if (sa.getBoolean(
+ com.android.internal.R.styleable.AndroidManifestApplication_testOnly,
+ false)) {
+ ai.flags |= ApplicationInfo.FLAG_TEST_ONLY;
+ }
}
if (sa.getBoolean(
String tagName = parser.getName();
if (tagName.equals("activity")) {
- Activity a = parseActivity(owner, res, parser, attrs, flags, outError, false,
+ Activity a = parseActivity(owner, res, parser, flags, outError, false,
owner.baseHardwareAccelerated);
if (a == null) {
mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
owner.activities.add(a);
} else if (tagName.equals("receiver")) {
- Activity a = parseActivity(owner, res, parser, attrs, flags, outError, true, false);
+ Activity a = parseActivity(owner, res, parser, flags, outError, true, false);
if (a == null) {
mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
return false;
owner.receivers.add(a);
} else if (tagName.equals("service")) {
- Service s = parseService(owner, res, parser, attrs, flags, outError);
+ Service s = parseService(owner, res, parser, flags, outError);
if (s == null) {
mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
return false;
owner.services.add(s);
} else if (tagName.equals("provider")) {
- Provider p = parseProvider(owner, res, parser, attrs, flags, outError);
+ Provider p = parseProvider(owner, res, parser, flags, outError);
if (p == null) {
mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
return false;
owner.providers.add(p);
} else if (tagName.equals("activity-alias")) {
- Activity a = parseActivityAlias(owner, res, parser, attrs, flags, outError);
+ Activity a = parseActivityAlias(owner, res, parser, flags, outError);
if (a == null) {
mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
return false;
// note: application meta-data is stored off to the side, so it can
// remain null in the primary copy (we like to avoid extra copies because
// it can be large)
- if ((owner.mAppMetaData = parseMetaData(res, parser, attrs, owner.mAppMetaData,
+ if ((owner.mAppMetaData = parseMetaData(res, parser, owner.mAppMetaData,
outError)) == null) {
mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
return false;
}
} else if (tagName.equals("library")) {
- sa = res.obtainAttributes(attrs,
+ sa = res.obtainAttributes(parser,
com.android.internal.R.styleable.AndroidManifestLibrary);
// Note: don't allow this value to be a reference to a resource
XmlUtils.skipCurrentTag(parser);
} else if (tagName.equals("uses-library")) {
- sa = res.obtainAttributes(attrs,
+ sa = res.obtainAttributes(parser,
com.android.internal.R.styleable.AndroidManifestUsesLibrary);
// Note: don't allow this value to be a reference to a resource
* of doing, so many valid features of a base APK have been carefully
* omitted here.
*/
- private boolean parseSplitApplication(Package owner, Resources res, XmlPullParser parser,
- AttributeSet attrs, int flags, int splitIndex, String[] outError)
+ private boolean parseSplitApplication(Package owner, Resources res, XmlResourceParser parser,
+ int flags, int splitIndex, String[] outError)
throws XmlPullParserException, IOException {
- TypedArray sa = res.obtainAttributes(attrs,
+ TypedArray sa = res.obtainAttributes(parser,
com.android.internal.R.styleable.AndroidManifestApplication);
if (sa.getBoolean(
String tagName = parser.getName();
if (tagName.equals("activity")) {
- Activity a = parseActivity(owner, res, parser, attrs, flags, outError, false,
+ Activity a = parseActivity(owner, res, parser, flags, outError, false,
owner.baseHardwareAccelerated);
if (a == null) {
mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
owner.activities.add(a);
} else if (tagName.equals("receiver")) {
- Activity a = parseActivity(owner, res, parser, attrs, flags, outError, true, false);
+ Activity a = parseActivity(owner, res, parser, flags, outError, true, false);
if (a == null) {
mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
return false;
owner.receivers.add(a);
} else if (tagName.equals("service")) {
- Service s = parseService(owner, res, parser, attrs, flags, outError);
+ Service s = parseService(owner, res, parser, flags, outError);
if (s == null) {
mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
return false;
owner.services.add(s);
} else if (tagName.equals("provider")) {
- Provider p = parseProvider(owner, res, parser, attrs, flags, outError);
+ Provider p = parseProvider(owner, res, parser, flags, outError);
if (p == null) {
mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
return false;
owner.providers.add(p);
} else if (tagName.equals("activity-alias")) {
- Activity a = parseActivityAlias(owner, res, parser, attrs, flags, outError);
+ Activity a = parseActivityAlias(owner, res, parser, flags, outError);
if (a == null) {
mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
return false;
// note: application meta-data is stored off to the side, so it can
// remain null in the primary copy (we like to avoid extra copies because
// it can be large)
- if ((owner.mAppMetaData = parseMetaData(res, parser, attrs, owner.mAppMetaData,
+ if ((owner.mAppMetaData = parseMetaData(res, parser, owner.mAppMetaData,
outError)) == null) {
mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
return false;
}
} else if (tagName.equals("uses-library")) {
- sa = res.obtainAttributes(attrs,
+ sa = res.obtainAttributes(parser,
com.android.internal.R.styleable.AndroidManifestUsesLibrary);
// Note: don't allow this value to be a reference to a resource
}
private Activity parseActivity(Package owner, Resources res,
- XmlPullParser parser, AttributeSet attrs, int flags, String[] outError,
+ XmlResourceParser parser, int flags, String[] outError,
boolean receiver, boolean hardwareAccelerated)
throws XmlPullParserException, IOException {
- TypedArray sa = res.obtainAttributes(attrs, R.styleable.AndroidManifestActivity);
+ TypedArray sa = res.obtainAttributes(parser, R.styleable.AndroidManifestActivity);
if (mParseActivityArgs == null) {
mParseActivityArgs = new ParseComponentArgs(owner, outError,
if (parser.getName().equals("intent-filter")) {
ActivityIntentInfo intent = new ActivityIntentInfo(a);
- if (!parseIntent(res, parser, attrs, true, true, intent, outError)) {
+ if (!parseIntent(res, parser, true, true, intent, outError)) {
return null;
}
if (intent.countActions() == 0) {
}
} else if (!receiver && parser.getName().equals("preferred")) {
ActivityIntentInfo intent = new ActivityIntentInfo(a);
- if (!parseIntent(res, parser, attrs, false, false, intent, outError)) {
+ if (!parseIntent(res, parser, false, false, intent, outError)) {
return null;
}
if (intent.countActions() == 0) {
owner.preferredActivityFilters.add(intent);
}
} else if (parser.getName().equals("meta-data")) {
- if ((a.metaData = parseMetaData(res, parser, attrs, a.metaData,
+ if ((a.metaData = parseMetaData(res, parser, a.metaData,
outError)) == null) {
return null;
}
} else if (!receiver && parser.getName().equals("layout")) {
- parseLayout(res, attrs, a);
+ parseLayout(res, parser, a);
} else {
if (!RIGID_PARSER) {
Slog.w(TAG, "Problem in package " + mArchiveSourcePath + ":");
}
private Activity parseActivityAlias(Package owner, Resources res,
- XmlPullParser parser, AttributeSet attrs, int flags, String[] outError)
+ XmlResourceParser parser, int flags, String[] outError)
throws XmlPullParserException, IOException {
- TypedArray sa = res.obtainAttributes(attrs,
+ TypedArray sa = res.obtainAttributes(parser,
com.android.internal.R.styleable.AndroidManifestActivityAlias);
String targetActivity = sa.getNonConfigurationString(
if (parser.getName().equals("intent-filter")) {
ActivityIntentInfo intent = new ActivityIntentInfo(a);
- if (!parseIntent(res, parser, attrs, true, true, intent, outError)) {
+ if (!parseIntent(res, parser, true, true, intent, outError)) {
return null;
}
if (intent.countActions() == 0) {
a.intents.add(intent);
}
} else if (parser.getName().equals("meta-data")) {
- if ((a.metaData=parseMetaData(res, parser, attrs, a.metaData,
+ if ((a.metaData=parseMetaData(res, parser, a.metaData,
outError)) == null) {
return null;
}
}
private Provider parseProvider(Package owner, Resources res,
- XmlPullParser parser, AttributeSet attrs, int flags, String[] outError)
+ XmlResourceParser parser, int flags, String[] outError)
throws XmlPullParserException, IOException {
- TypedArray sa = res.obtainAttributes(attrs,
+ TypedArray sa = res.obtainAttributes(parser,
com.android.internal.R.styleable.AndroidManifestProvider);
if (mParseProviderArgs == null) {
}
p.info.authority = cpname.intern();
- if (!parseProviderTags(res, parser, attrs, p, outError)) {
+ if (!parseProviderTags(res, parser, p, outError)) {
return null;
}
}
private boolean parseProviderTags(Resources res,
- XmlPullParser parser, AttributeSet attrs,
- Provider outInfo, String[] outError)
+ XmlResourceParser parser, Provider outInfo, String[] outError)
throws XmlPullParserException, IOException {
int outerDepth = parser.getDepth();
int type;
if (parser.getName().equals("intent-filter")) {
ProviderIntentInfo intent = new ProviderIntentInfo(outInfo);
- if (!parseIntent(res, parser, attrs, true, false, intent, outError)) {
+ if (!parseIntent(res, parser, true, false, intent, outError)) {
return false;
}
outInfo.intents.add(intent);
} else if (parser.getName().equals("meta-data")) {
- if ((outInfo.metaData=parseMetaData(res, parser, attrs,
+ if ((outInfo.metaData=parseMetaData(res, parser,
outInfo.metaData, outError)) == null) {
return false;
}
} else if (parser.getName().equals("grant-uri-permission")) {
- TypedArray sa = res.obtainAttributes(attrs,
+ TypedArray sa = res.obtainAttributes(parser,
com.android.internal.R.styleable.AndroidManifestGrantUriPermission);
PatternMatcher pa = null;
XmlUtils.skipCurrentTag(parser);
} else if (parser.getName().equals("path-permission")) {
- TypedArray sa = res.obtainAttributes(attrs,
+ TypedArray sa = res.obtainAttributes(parser,
com.android.internal.R.styleable.AndroidManifestPathPermission);
PathPermission pa = null;
}
private Service parseService(Package owner, Resources res,
- XmlPullParser parser, AttributeSet attrs, int flags, String[] outError)
+ XmlResourceParser parser, int flags, String[] outError)
throws XmlPullParserException, IOException {
- TypedArray sa = res.obtainAttributes(attrs,
+ TypedArray sa = res.obtainAttributes(parser,
com.android.internal.R.styleable.AndroidManifestService);
if (mParseServiceArgs == null) {
if (parser.getName().equals("intent-filter")) {
ServiceIntentInfo intent = new ServiceIntentInfo(s);
- if (!parseIntent(res, parser, attrs, true, false, intent, outError)) {
+ if (!parseIntent(res, parser, true, false, intent, outError)) {
return null;
}
s.intents.add(intent);
} else if (parser.getName().equals("meta-data")) {
- if ((s.metaData=parseMetaData(res, parser, attrs, s.metaData,
+ if ((s.metaData=parseMetaData(res, parser, s.metaData,
outError)) == null) {
return null;
}
return s;
}
- private boolean parseAllMetaData(Resources res,
- XmlPullParser parser, AttributeSet attrs, String tag,
- Component<?> outInfo, String[] outError)
- throws XmlPullParserException, IOException {
+ private boolean parseAllMetaData(Resources res, XmlResourceParser parser, String tag,
+ Component<?> outInfo, String[] outError) throws XmlPullParserException, IOException {
int outerDepth = parser.getDepth();
int type;
while ((type=parser.next()) != XmlPullParser.END_DOCUMENT
}
if (parser.getName().equals("meta-data")) {
- if ((outInfo.metaData=parseMetaData(res, parser, attrs,
+ if ((outInfo.metaData=parseMetaData(res, parser,
outInfo.metaData, outError)) == null) {
return false;
}
}
private Bundle parseMetaData(Resources res,
- XmlPullParser parser, AttributeSet attrs,
- Bundle data, String[] outError)
+ XmlResourceParser parser, Bundle data, String[] outError)
throws XmlPullParserException, IOException {
- TypedArray sa = res.obtainAttributes(attrs,
+ TypedArray sa = res.obtainAttributes(parser,
com.android.internal.R.styleable.AndroidManifestMetaData);
if (data == null) {
private static final String ANDROID_RESOURCES
= "http://schemas.android.com/apk/res/android";
- private boolean parseIntent(Resources res, XmlPullParser parser, AttributeSet attrs,
+ private boolean parseIntent(Resources res, XmlResourceParser parser,
boolean allowGlobs, boolean allowAutoVerify, IntentInfo outInfo, String[] outError)
throws XmlPullParserException, IOException {
- TypedArray sa = res.obtainAttributes(attrs,
+ TypedArray sa = res.obtainAttributes(parser,
com.android.internal.R.styleable.AndroidManifestIntentFilter);
int priority = sa.getInt(
String nodeName = parser.getName();
if (nodeName.equals("action")) {
- String value = attrs.getAttributeValue(
+ String value = parser.getAttributeValue(
ANDROID_RESOURCES, "name");
if (value == null || value == "") {
outError[0] = "No value supplied for <android:name>";
outInfo.addAction(value);
} else if (nodeName.equals("category")) {
- String value = attrs.getAttributeValue(
+ String value = parser.getAttributeValue(
ANDROID_RESOURCES, "name");
if (value == null || value == "") {
outError[0] = "No value supplied for <android:name>";
outInfo.addCategory(value);
} else if (nodeName.equals("data")) {
- sa = res.obtainAttributes(attrs,
+ sa = res.obtainAttributes(parser,
com.android.internal.R.styleable.AndroidManifestData);
String str = sa.getNonConfigurationString(
public ArrayList<String> protectedBroadcasts;
+ public Package parentPackage;
+ public ArrayList<Package> childPackages;
+
public ArrayList<String> libraryNames = null;
public ArrayList<String> usesLibraries = null;
public ArrayList<String> usesOptionalLibraries = null;
applicationInfo.uid = -1;
}
+ public void setApplicationVolumeUuid(String volumeUuid) {
+ this.applicationInfo.volumeUuid = volumeUuid;
+ if (childPackages != null) {
+ final int packageCount = childPackages.size();
+ for (int i = 0; i < packageCount; i++) {
+ childPackages.get(i).applicationInfo.volumeUuid = volumeUuid;
+ }
+ }
+ }
+
+ public void setApplicationInfoCodePath(String codePath) {
+ this.applicationInfo.setCodePath(codePath);
+ if (childPackages != null) {
+ final int packageCount = childPackages.size();
+ for (int i = 0; i < packageCount; i++) {
+ childPackages.get(i).applicationInfo.setCodePath(codePath);
+ }
+ }
+ }
+
+ public void setApplicationInfoResourcePath(String resourcePath) {
+ this.applicationInfo.setResourcePath(resourcePath);
+ if (childPackages != null) {
+ final int packageCount = childPackages.size();
+ for (int i = 0; i < packageCount; i++) {
+ childPackages.get(i).applicationInfo.setResourcePath(resourcePath);
+ }
+ }
+ }
+
+ public void setApplicationInfoBaseResourcePath(String resourcePath) {
+ this.applicationInfo.setBaseResourcePath(resourcePath);
+ if (childPackages != null) {
+ final int packageCount = childPackages.size();
+ for (int i = 0; i < packageCount; i++) {
+ childPackages.get(i).applicationInfo.setBaseResourcePath(resourcePath);
+ }
+ }
+ }
+
+ public void setApplicationInfoBaseCodePath(String baseCodePath) {
+ this.applicationInfo.setBaseCodePath(baseCodePath);
+ if (childPackages != null) {
+ final int packageCount = childPackages.size();
+ for (int i = 0; i < packageCount; i++) {
+ childPackages.get(i).applicationInfo.setBaseCodePath(baseCodePath);
+ }
+ }
+ }
+
+ public boolean hasChildPackage(String packageName) {
+ final int childCount = (childPackages != null) ? childPackages.size() : 0;
+ for (int i = 0; i < childCount; i++) {
+ if (childPackages.get(i).packageName.equals(packageName)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ public void setApplicationInfoSplitCodePaths(String[] splitCodePaths) {
+ this.applicationInfo.setSplitCodePaths(splitCodePaths);
+ // Children have no splits
+ }
+
+ public void setApplicationInfoSplitResourcePaths(String[] resroucePaths) {
+ this.applicationInfo.setSplitResourcePaths(resroucePaths);
+ // Children have no splits
+ }
+
+ public void setSplitCodePaths(String[] codePaths) {
+ this.splitCodePaths = codePaths;
+ }
+
+ public void setCodePath(String codePath) {
+ this.codePath = codePath;
+ if (childPackages != null) {
+ final int packageCount = childPackages.size();
+ for (int i = 0; i < packageCount; i++) {
+ childPackages.get(i).codePath = codePath;
+ }
+ }
+ }
+
+ public void setBaseCodePath(String baseCodePath) {
+ this.baseCodePath = baseCodePath;
+ if (childPackages != null) {
+ final int packageCount = childPackages.size();
+ for (int i = 0; i < packageCount; i++) {
+ childPackages.get(i).baseCodePath = baseCodePath;
+ }
+ }
+ }
+
+ public void setSignatures(Signature[] signatures) {
+ this.mSignatures = signatures;
+ if (childPackages != null) {
+ final int packageCount = childPackages.size();
+ for (int i = 0; i < packageCount; i++) {
+ childPackages.get(i).mSignatures = signatures;
+ }
+ }
+ }
+
+ public void setVolumeUuid(String volumeUuid) {
+ this.volumeUuid = volumeUuid;
+ if (childPackages != null) {
+ final int packageCount = childPackages.size();
+ for (int i = 0; i < packageCount; i++) {
+ childPackages.get(i).volumeUuid = volumeUuid;
+ }
+ }
+ }
+
+ public void setApplicationInfoFlags(int mask, int flags) {
+ applicationInfo.flags = (applicationInfo.flags & ~mask) | (mask & flags);
+ if (childPackages != null) {
+ final int packageCount = childPackages.size();
+ for (int i = 0; i < packageCount; i++) {
+ childPackages.get(i).applicationInfo.flags =
+ (applicationInfo.flags & ~mask) | (mask & flags);
+ }
+ }
+ }
+
+ public void setCpuAbiOverride(String cpuAbiOverride) {
+ this.cpuAbiOverride = cpuAbiOverride;
+ if (childPackages != null) {
+ final int packageCount = childPackages.size();
+ for (int i = 0; i < packageCount; i++) {
+ childPackages.get(i).cpuAbiOverride = cpuAbiOverride;
+ }
+ }
+ }
+
public List<String> getAllCodePaths() {
ArrayList<String> paths = new ArrayList<>();
paths.add(baseCodePath);
import static android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED;
import static android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_DISABLED_USER;
import static android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_ENABLED;
+import static android.content.pm.PackageManager.DELETE_KEEP_DATA;
import static android.content.pm.PackageManager.FLAG_PERMISSION_GRANTED_BY_DEFAULT;
import static android.content.pm.PackageManager.FLAG_PERMISSION_POLICY_FIXED;
import static android.content.pm.PackageManager.FLAG_PERMISSION_REVIEW_REQUIRED;
import static android.content.pm.PackageManager.MOVE_FAILED_SYSTEM_PACKAGE;
import static android.content.pm.PackageManager.PERMISSION_DENIED;
import static android.content.pm.PackageManager.PERMISSION_GRANTED;
+import static android.content.pm.PackageParser.PARSE_IS_PRIVILEGED;
import static android.content.pm.PackageParser.isApkFile;
import static android.os.Process.PACKAGE_INFO_GID;
import static android.os.Process.SYSTEM_UID;
static final int SCAN_REQUIRE_KNOWN = 1<<12;
static final int SCAN_MOVE = 1<<13;
static final int SCAN_INITIAL = 1<<14;
+ static final int SCAN_CHECK_ONLY = 1<<15;
static final int REMOVE_CHATTY = 1<<16;
PackageInstalledInfo res = data.res;
if (res.returnCode == PackageManager.INSTALL_SUCCEEDED) {
+ //TODO: Broadcast for child packages too
final String packageName = res.pkg.applicationInfo.packageName;
res.removedInfo.sendBroadcast(false, true, false);
Bundle extras = new Bundle(1);
}
}
+ void scheduleWritePackageRestrictionsLocked(UserHandle user) {
+ final int userId = user == null ? UserHandle.USER_ALL : user.getIdentifier();
+ scheduleWritePackageRestrictionsLocked(userId);
+ }
+
void scheduleWritePackageRestrictionsLocked(int userId) {
- if (!sUserManager.exists(userId)) return;
- mDirtyUsers.add(userId);
- if (!mHandler.hasMessages(WRITE_PACKAGE_RESTRICTIONS)) {
- mHandler.sendEmptyMessageDelayed(WRITE_PACKAGE_RESTRICTIONS, WRITE_SETTINGS_DELAY);
+ final int[] userIds = (userId == UserHandle.USER_ALL)
+ ? sUserManager.getUserIds() : new int[]{userId};
+ for (int nextUserId : userIds) {
+ if (!sUserManager.exists(nextUserId)) return;
+ mDirtyUsers.add(nextUserId);
+ if (!mHandler.hasMessages(WRITE_PACKAGE_RESTRICTIONS)) {
+ mHandler.sendEmptyMessageDelayed(WRITE_PACKAGE_RESTRICTIONS, WRITE_SETTINGS_DELAY);
+ }
}
}
+ ps.codePathString + ", installStatus=" + ps.installStatus
+ ", versionCode=" + ps.versionCode + "; scanned versionCode="
+ scannedPkg.mVersionCode);
- removePackageLI(ps, true);
+ removePackageSettingLI(scannedPkg, true);
mExpectingBetter.put(ps.name, ps.codePath);
}
}
}
- private void collectCertificatesLI(PackageParser pp, PackageSetting ps,
- PackageParser.Package pkg, File srcFile, int parseFlags)
- throws PackageManagerException {
+ private void collectCertificatesLI(PackageSetting ps, PackageParser.Package pkg, File srcFile,
+ int parseFlags) throws PackageManagerException {
if (ps != null
&& ps.codePath.equals(srcFile)
&& ps.timeStamp == srcFile.lastModified()
}
try {
- pp.collectCertificates(pkg, parseFlags);
+ PackageParser.collectCertificates(pkg, parseFlags);
} catch (PackageParserException e) {
throw PackageManagerException.from(e);
}
throw PackageManagerException.from(e);
}
+ return scanPackageLI(pkg, scanFile, parseFlags, scanFlags, currentTime, user);
+ }
+
+ /**
+ * Scans a package and returns the newly parsed package.
+ * @throws PackageManagerException on a parse error.
+ */
+ private PackageParser.Package scanPackageLI(PackageParser.Package pkg, File scanFile,
+ int parseFlags, int scanFlags, long currentTime, UserHandle user)
+ throws PackageManagerException {
+ // If the package has children and this is the first dive in the function
+ // we scan the package with the SCAN_CHECK_ONLY flag set to see whether all
+ // packages (parent and children) would be successfully scanned before the
+ // actual scan since scanning mutates internal state and we want to atomically
+ // install the package and its children.
+ if ((scanFlags & SCAN_CHECK_ONLY) == 0) {
+ if (pkg.childPackages != null && pkg.childPackages.size() > 0) {
+ scanFlags |= SCAN_CHECK_ONLY;
+ }
+ } else {
+ scanFlags &= ~SCAN_CHECK_ONLY;
+ }
+
+ // Scan the parent
+ PackageParser.Package scannedPkg = scanPackageInternalLI(pkg, scanFile, parseFlags,
+ scanFlags, currentTime, user);
+
+ // Scan the children
+ final int childCount = (pkg.childPackages != null) ? pkg.childPackages.size() : 0;
+ for (int i = 0; i < childCount; i++) {
+ PackageParser.Package childPackage = pkg.childPackages.get(i);
+ scanPackageInternalLI(childPackage, scanFile, parseFlags, scanFlags,
+ currentTime, user);
+ }
+
+
+ if ((scanFlags & SCAN_CHECK_ONLY) != 0) {
+ return scanPackageLI(pkg, scanFile, parseFlags, scanFlags, currentTime, user);
+ }
+
+ return scannedPkg;
+ }
+
+ /**
+ * Scans a package and returns the newly parsed package.
+ * @throws PackageManagerException on a parse error.
+ */
+ private PackageParser.Package scanPackageInternalLI(PackageParser.Package pkg, File scanFile,
+ int parseFlags, int scanFlags, long currentTime, UserHandle user)
+ throws PackageManagerException {
PackageSetting ps = null;
PackageSetting updatedPkg;
// reader
// package name depending on our state.
updatedPkg = mSettings.getDisabledSystemPkgLPr(ps != null ? ps.name : pkg.packageName);
if (DEBUG_INSTALL && updatedPkg != null) Slog.d(TAG, "updatedPkg = " + updatedPkg);
+
+ // If this is a package we don't know about on the system partition, we
+ // may need to remove disabled child packages on the system partition
+ // or may need to not add child packages if the parent apk is updated
+ // on the data partition and no longer defines this child package.
+ if ((parseFlags & PackageParser.PARSE_IS_SYSTEM) != 0) {
+ // If this is a parent package for an updated system app and this system
+ // app got an OTA update which no longer defines some of the child packages
+ // we have to prune them from the disabled system packages.
+ PackageSetting disabledPs = mSettings.getDisabledSystemPkgLPr(pkg.packageName);
+ if (disabledPs != null) {
+ final int scannedChildCount = (pkg.childPackages != null)
+ ? pkg.childPackages.size() : 0;
+ final int disabledChildCount = disabledPs.childPackageNames != null
+ ? disabledPs.childPackageNames.size() : 0;
+ for (int i = 0; i < disabledChildCount; i++) {
+ String disabledChildPackageName = disabledPs.childPackageNames.get(i);
+ boolean disabledPackageAvailable = false;
+ for (int j = 0; j < scannedChildCount; j++) {
+ PackageParser.Package childPkg = pkg.childPackages.get(j);
+ if (childPkg.packageName.equals(disabledChildPackageName)) {
+ disabledPackageAvailable = true;
+ break;
+ }
+ }
+ if (!disabledPackageAvailable) {
+ mSettings.removeDisabledSystemPackageLPw(disabledChildPackageName);
+ }
+ }
+ }
+ }
}
+
boolean updatedPkgBetter = false;
// First check if this is a system package that may involve an update
if (updatedPkg != null && (parseFlags & PackageParser.PARSE_IS_SYSTEM) != 0) {
updatedPkg.resourcePathString = scanFile.toString();
}
updatedPkg.pkg = pkg;
- throw new PackageManagerException(INSTALL_FAILED_DUPLICATE_PACKAGE,
- "Package " + ps.name + " at " + scanFile
- + " ignored: updated version " + ps.versionCode
- + " better than this " + pkg.mVersionCode);
+ updatedPkg.versionCode = pkg.mVersionCode;
+
+ // Update the disabled system child packages to point to the package too.
+ final int childCount = updatedPkg.childPackageNames != null
+ ? updatedPkg.childPackageNames.size() : 0;
+ for (int i = 0; i < childCount; i++) {
+ String childPackageName = updatedPkg.childPackageNames.get(i);
+ PackageSetting updatedChildPkg = mSettings.getDisabledSystemPkgLPr(
+ childPackageName);
+ if (updatedChildPkg != null) {
+ updatedChildPkg.pkg = pkg;
+ updatedChildPkg.versionCode = pkg.mVersionCode;
+ }
+ }
+
+ throw new PackageManagerException(Log.WARN, "Package " + ps.name + " at "
+ + scanFile + " ignored: updated version " + ps.versionCode
+ + " better than this " + pkg.mVersionCode);
} else {
// The current app on the system partition is better than
// what we have updated to on the data partition; switch
}
// Verify certificates against what was last scanned
- collectCertificatesLI(pp, ps, pkg, scanFile, parseFlags);
+ collectCertificatesLI(ps, pkg, scanFile, parseFlags);
/*
* A new system app appeared, but we already had a non-system one of the
!= PackageManager.SIGNATURE_MATCH) {
logCriticalInfo(Log.WARN, "Package " + ps.name + " appeared on system, but"
+ " signatures don't match existing userdata copy; removing");
- deletePackageLI(pkg.packageName, null, true, null, null, 0, null, false);
+ deletePackageLI(pkg.packageName, null, true, null, null, 0, null, false, null);
ps = null;
} else {
/*
}
// Set application objects path explicitly.
- pkg.applicationInfo.volumeUuid = pkg.volumeUuid;
- pkg.applicationInfo.setCodePath(pkg.codePath);
- pkg.applicationInfo.setBaseCodePath(pkg.baseCodePath);
- pkg.applicationInfo.setSplitCodePaths(pkg.splitCodePaths);
- pkg.applicationInfo.setResourcePath(resourcePath);
- pkg.applicationInfo.setBaseResourcePath(baseResourcePath);
- pkg.applicationInfo.setSplitResourcePaths(pkg.splitCodePaths);
+ pkg.setApplicationVolumeUuid(pkg.volumeUuid);
+ pkg.setApplicationInfoCodePath(pkg.codePath);
+ pkg.setApplicationInfoBaseCodePath(pkg.baseCodePath);
+ pkg.setApplicationInfoSplitCodePaths(pkg.splitCodePaths);
+ pkg.setApplicationInfoResourcePath(resourcePath);
+ pkg.setApplicationInfoBaseResourcePath(baseResourcePath);
+ pkg.setApplicationInfoSplitResourcePaths(pkg.splitCodePaths);
// Note that we invoke the following method only if we are about to unpack an application
PackageParser.Package scannedPkg = scanPackageLI(pkg, parseFlags, scanFlags
*/
if (shouldHideSystemApp) {
synchronized (mPackages) {
- mSettings.disableSystemPackageLPw(pkg.packageName);
+ mSettings.disableSystemPackageLPw(pkg.packageName, true);
}
}
}
private void deleteCodeCacheDirsLI(String volumeUuid, String packageName) {
+ final PackageParser.Package pkg;
+ synchronized (mPackages) {
+ pkg = mPackages.get(packageName);
+ }
+ if (pkg == null) {
+ Slog.w(TAG, "Failed to delete code cache directory. No package: " + packageName);
+ return;
+ }
+ deleteCodeCacheDirsLI(pkg);
+ }
+
+ private void deleteCodeCacheDirsLI(PackageParser.Package pkg) {
// TODO: triage flags as part of 26466827
final int flags = StorageManager.FLAG_STORAGE_CE | StorageManager.FLAG_STORAGE_DE;
- final int[] users = sUserManager.getUserIds();
+ int[] users = sUserManager.getUserIds();
+ int res = 0;
for (int user : users) {
+ // Remove the parent code cache
try {
- mInstaller.clearAppData(volumeUuid, packageName, user,
+ mInstaller.clearAppData(pkg.volumeUuid, pkg.packageName, user,
flags | Installer.FLAG_CLEAR_CODE_CACHE_ONLY);
} catch (InstallerException e) {
Slog.w(TAG, "Failed to delete code cache directory", e);
}
+ final int childCount = (pkg.childPackages != null) ? pkg.childPackages.size() : 0;
+ for (int i = 0; i < childCount; i++) {
+ PackageParser.Package childPkg = pkg.childPackages.get(i);
+ // Remove the child code cache
+ try {
+ mInstaller.clearAppData(childPkg.volumeUuid, childPkg.packageName,
+ user, flags | Installer.FLAG_CLEAR_CODE_CACHE_ONLY);
+ } catch (InstallerException e) {
+ Slog.w(TAG, "Failed to delete code cache directory", e);
+ }
+ }
+ }
+ }
+
+ private void setInstallAndUpdateTime(PackageParser.Package pkg, long firstInstallTime,
+ long lastUpdateTime) {
+ // Set parent install/update time
+ PackageSetting ps = (PackageSetting) pkg.mExtras;
+ if (ps != null) {
+ ps.firstInstallTime = firstInstallTime;
+ ps.lastUpdateTime = lastUpdateTime;
+ }
+ // Set children install/update time
+ final int childCount = (pkg.childPackages != null) ? pkg.childPackages.size() : 0;
+ for (int i = 0; i < childCount; i++) {
+ PackageParser.Package childPkg = pkg.childPackages.get(i);
+ ps = (PackageSetting) childPkg.mExtras;
+ if (ps != null) {
+ ps.firstInstallTime = firstInstallTime;
+ ps.lastUpdateTime = lastUpdateTime;
+ }
}
}
private PackageParser.Package scanPackageTracedLI(PackageParser.Package pkg, int parseFlags,
int scanFlags, long currentTime, UserHandle user) throws PackageManagerException {
Trace.traceBegin(TRACE_TAG_PACKAGE_MANAGER, "scanPackage");
+ // If the package has children and this is the first dive in the function
+ // we recursively scan the package with the SCAN_CHECK_ONLY flag set to see
+ // whether all packages (parent and children) would be successfully scanned
+ // before the actual scan since scanning mutates internal state and we want
+ // to atomically install the package and its children.
+ if ((scanFlags & SCAN_CHECK_ONLY) == 0) {
+ if (pkg.childPackages != null && pkg.childPackages.size() > 0) {
+ scanFlags |= SCAN_CHECK_ONLY;
+ }
+ } else {
+ scanFlags &= ~SCAN_CHECK_ONLY;
+ }
+
+ final PackageParser.Package scannedPkg;
try {
- return scanPackageLI(pkg, parseFlags, scanFlags, currentTime, user);
+ // Scan the parent
+ scannedPkg = scanPackageLI(pkg, parseFlags, scanFlags, currentTime, user);
+ // Scan the children
+ final int childCount = (pkg.childPackages != null) ? pkg.childPackages.size() : 0;
+ for (int i = 0; i < childCount; i++) {
+ PackageParser.Package childPkg = pkg.childPackages.get(i);
+ scanPackageLI(childPkg, parseFlags,
+ scanFlags, currentTime, user);
+ }
} finally {
Trace.traceEnd(TRACE_TAG_PACKAGE_MANAGER);
}
+
+ if ((scanFlags & SCAN_CHECK_ONLY) != 0) {
+ return scanPackageTracedLI(pkg, parseFlags, scanFlags, currentTime, user);
+ }
+
+ return scannedPkg;
}
private PackageParser.Package scanPackageLI(PackageParser.Package pkg, int parseFlags,
}
private PackageParser.Package scanPackageDirtyLI(PackageParser.Package pkg, int parseFlags,
- int scanFlags, long currentTime, UserHandle user) throws PackageManagerException {
+ int scanFlags, long currentTime, UserHandle user)
+ throws PackageManagerException {
final File scanFile = new File(pkg.codePath);
if (pkg.applicationInfo.getCodePath() == null ||
pkg.applicationInfo.getResourcePath() == null) {
"Core android package being redefined. Skipping.");
}
- // Set up information for our fall-back user intent resolution activity.
- mPlatformPackage = pkg;
- pkg.mVersionCode = mSdkVersion;
- mAndroidApplication = pkg.applicationInfo;
-
- if (!mResolverReplaced) {
- mResolveActivity.applicationInfo = mAndroidApplication;
- mResolveActivity.name = ResolverActivity.class.getName();
- mResolveActivity.packageName = mAndroidApplication.packageName;
- mResolveActivity.processName = "system:ui";
- mResolveActivity.launchMode = ActivityInfo.LAUNCH_MULTIPLE;
- mResolveActivity.documentLaunchMode = ActivityInfo.DOCUMENT_LAUNCH_NEVER;
- mResolveActivity.flags = ActivityInfo.FLAG_EXCLUDE_FROM_RECENTS;
- mResolveActivity.theme = R.style.Theme_Holo_Dialog_Alert;
- mResolveActivity.exported = true;
- mResolveActivity.enabled = true;
- mResolveInfo.activityInfo = mResolveActivity;
- mResolveInfo.priority = 0;
- mResolveInfo.preferredOrder = 0;
- mResolveInfo.match = 0;
- mResolveComponentName = new ComponentName(
- mAndroidApplication.packageName, mResolveActivity.name);
+ if ((scanFlags & SCAN_CHECK_ONLY) == 0) {
+ // Set up information for our fall-back user intent resolution activity.
+ mPlatformPackage = pkg;
+ pkg.mVersionCode = mSdkVersion;
+ mAndroidApplication = pkg.applicationInfo;
+
+ if (!mResolverReplaced) {
+ mResolveActivity.applicationInfo = mAndroidApplication;
+ mResolveActivity.name = ResolverActivity.class.getName();
+ mResolveActivity.packageName = mAndroidApplication.packageName;
+ mResolveActivity.processName = "system:ui";
+ mResolveActivity.launchMode = ActivityInfo.LAUNCH_MULTIPLE;
+ mResolveActivity.documentLaunchMode = ActivityInfo.DOCUMENT_LAUNCH_NEVER;
+ mResolveActivity.flags = ActivityInfo.FLAG_EXCLUDE_FROM_RECENTS;
+ mResolveActivity.theme = R.style.Theme_Holo_Dialog_Alert;
+ mResolveActivity.exported = true;
+ mResolveActivity.enabled = true;
+ mResolveInfo.activityInfo = mResolveActivity;
+ mResolveInfo.priority = 0;
+ mResolveInfo.preferredOrder = 0;
+ mResolveInfo.match = 0;
+ mResolveComponentName = new ComponentName(
+ mAndroidApplication.packageName, mResolveActivity.name);
+ }
}
}
}
Log.d(TAG, "Scanning package " + pkg.packageName);
}
- if (mPackages.containsKey(pkg.packageName)
- || mSharedLibraries.containsKey(pkg.packageName)) {
- throw new PackageManagerException(INSTALL_FAILED_DUPLICATE_PACKAGE,
- "Application package " + pkg.packageName
- + " already installed. Skipping duplicate.");
- }
-
- // If we're only installing presumed-existing packages, require that the
- // scanned APK is both already known and at the path previously established
- // for it. Previously unknown packages we pick up normally, but if we have an
- // a priori expectation about this package's install presence, enforce it.
- // With a singular exception for new system packages. When an OTA contains
- // a new system package, we allow the codepath to change from a system location
- // to the user-installed location. If we don't allow this change, any newer,
- // user-installed version of the application will be ignored.
- if ((scanFlags & SCAN_REQUIRE_KNOWN) != 0) {
- if (mExpectingBetter.containsKey(pkg.packageName)) {
- logCriticalInfo(Log.WARN,
- "Relax SCAN_REQUIRE_KNOWN requirement for package " + pkg.packageName);
- } else {
- PackageSetting known = mSettings.peekPackageLPr(pkg.packageName);
- if (known != null) {
- if (DEBUG_PACKAGE_SCANNING) {
- Log.d(TAG, "Examining " + pkg.codePath
- + " and requiring known paths " + known.codePathString
- + " & " + known.resourcePathString);
- }
- if (!pkg.applicationInfo.getCodePath().equals(known.codePathString)
- || !pkg.applicationInfo.getResourcePath().equals(known.resourcePathString)) {
- throw new PackageManagerException(INSTALL_FAILED_PACKAGE_CHANGED,
- "Application package " + pkg.packageName
- + " found at " + pkg.applicationInfo.getCodePath()
- + " but expected at " + known.codePathString + "; ignoring.");
+ synchronized (mPackages) {
+ if (mPackages.containsKey(pkg.packageName)
+ || mSharedLibraries.containsKey(pkg.packageName)) {
+ throw new PackageManagerException(INSTALL_FAILED_DUPLICATE_PACKAGE,
+ "Application package " + pkg.packageName
+ + " already installed. Skipping duplicate.");
+ }
+
+ // If we're only installing presumed-existing packages, require that the
+ // scanned APK is both already known and at the path previously established
+ // for it. Previously unknown packages we pick up normally, but if we have an
+ // a priori expectation about this package's install presence, enforce it.
+ // With a singular exception for new system packages. When an OTA contains
+ // a new system package, we allow the codepath to change from a system location
+ // to the user-installed location. If we don't allow this change, any newer,
+ // user-installed version of the application will be ignored.
+ if ((scanFlags & SCAN_REQUIRE_KNOWN) != 0) {
+ if (mExpectingBetter.containsKey(pkg.packageName)) {
+ logCriticalInfo(Log.WARN,
+ "Relax SCAN_REQUIRE_KNOWN requirement for package " + pkg.packageName);
+ } else {
+ PackageSetting known = mSettings.peekPackageLPr(pkg.packageName);
+ if (known != null) {
+ if (DEBUG_PACKAGE_SCANNING) {
+ Log.d(TAG, "Examining " + pkg.codePath
+ + " and requiring known paths " + known.codePathString
+ + " & " + known.resourcePathString);
+ }
+ if (!pkg.applicationInfo.getCodePath().equals(known.codePathString)
+ || !pkg.applicationInfo.getResourcePath().equals(
+ known.resourcePathString)) {
+ throw new PackageManagerException(INSTALL_FAILED_PACKAGE_CHANGED,
+ "Application package " + pkg.packageName
+ + " found at " + pkg.applicationInfo.getCodePath()
+ + " but expected at " + known.codePathString
+ + "; ignoring.");
+ }
}
}
}
pkg.mAdoptPermissions = null;
}
+ // Getting the package setting may have a side-effect, so if we
+ // are only checking if scan would succeed, stash a copy of the
+ // old setting to restore at the end.
+ PackageSetting nonMutatedPs = null;
+
// writer
synchronized (mPackages) {
if (pkg.mSharedUserId != null) {
+ " was transferred to another, but its .apk remains");
}
+ // See comments in nonMutatedPs declaration
+ if ((scanFlags & SCAN_CHECK_ONLY) != 0) {
+ PackageSetting foundPs = mSettings.peekPackageLPr(pkg.packageName);
+ if (foundPs != null) {
+ nonMutatedPs = new PackageSetting(foundPs);
+ }
+ }
+
// Just create the setting, don't add it yet. For already existing packages
// the PkgSetting exists already and doesn't have to be created.
pkgSetting = mSettings.getPackageLPw(pkg, origPackage, realName, suid, destCodeFile,
reportSettingsProblem(Log.WARN, msg);
// Make a note of it.
- mTransferedPackages.add(origPackage.name);
+ if ((scanFlags & SCAN_CHECK_ONLY) == 0) {
+ mTransferedPackages.add(origPackage.name);
+ }
// No longer need to retain this.
pkgSetting.origPackage = null;
}
- if (realName != null) {
+ if ((scanFlags & SCAN_CHECK_ONLY) == 0 && realName != null) {
// Make a note of it.
mTransferedPackages.add(pkg.packageName);
}
}
}
- if (pkg.mAdoptPermissions != null) {
+ if ((scanFlags & SCAN_CHECK_ONLY) == 0 && pkg.mAdoptPermissions != null) {
// This package wants to adopt ownership of permissions from
// another package.
for (int i = pkg.mAdoptPermissions.size() - 1; i >= 0; i--) {
ArrayList<PackageParser.Package> clientLibPkgs = null;
+ if ((scanFlags & SCAN_CHECK_ONLY) != 0) {
+ if (nonMutatedPs != null) {
+ synchronized (mPackages) {
+ mSettings.mPackages.put(nonMutatedPs.name, nonMutatedPs);
+ }
+ }
+ return pkg;
+ }
+
+ // Only privileged apps and updated privileged apps can add child packages.
+ if (pkg.childPackages != null && !pkg.childPackages.isEmpty()) {
+ if ((parseFlags & PARSE_IS_PRIVILEGED) == 0) {
+ throw new PackageManagerException("Only privileged apps and updated "
+ + "privileged apps can add child packages. Ignoring package "
+ + pkg.packageName);
+ }
+ final int childCount = pkg.childPackages.size();
+ for (int i = 0; i < childCount; i++) {
+ PackageParser.Package childPkg = pkg.childPackages.get(i);
+ if (mSettings.hasOtherDisabledSystemPkgWithChildLPr(pkg.packageName,
+ childPkg.packageName)) {
+ throw new PackageManagerException("Cannot override a child package of "
+ + "another disabled system app. Ignoring package " + pkg.packageName);
+ }
+ }
+ }
+
// writer
synchronized (mPackages) {
if ((pkg.applicationInfo.flags&ApplicationInfo.FLAG_SYSTEM) != 0) {
// Now that permission groups have a special meaning, we ignore permission
// groups for legacy apps to prevent unexpected behavior. In particular,
- // permissions for one app being granted to someone just becuase they happen
+ // permissions for one app being granted to someone just becase they happen
// to be in a group defined by another app (before this had no implications).
if (pkg.applicationInfo.targetSdkVersion > Build.VERSION_CODES.LOLLIPOP_MR1) {
p.group = mPermissionGroups.get(p.info.group);
}
}
+ private void killPackage(PackageParser.Package pkg, String reason) {
+ // Kill the parent package
+ killApplication(pkg.packageName, pkg.applicationInfo.uid, reason);
+ // Kill the child packages
+ final int childCount = (pkg.childPackages != null) ? pkg.childPackages.size() : 0;
+ for (int i = 0; i < childCount; i++) {
+ PackageParser.Package childPkg = pkg.childPackages.get(i);
+ killApplication(childPkg.packageName, childPkg.applicationInfo.uid, reason);
+ }
+ }
+
private void killApplication(String pkgName, int appId, String reason) {
// Request the ActivityManager to kill the process(only for existing packages)
// so that we do not end up in a confused state while the user is still using the older
}
}
- void removePackageLI(PackageSetting ps, boolean chatty) {
+ private void removePackageSettingLI(PackageParser.Package pkg, boolean chatty) {
+ // Remove the parent package setting
+ PackageSetting ps = (PackageSetting) pkg.mExtras;
+ if (ps != null) {
+ removePackageSettingLI(ps, chatty);
+ }
+ // Remove the child package setting
+ final int childCount = (pkg.childPackages != null) ? pkg.childPackages.size() : 0;
+ for (int i = 0; i < childCount; i++) {
+ PackageParser.Package childPkg = pkg.childPackages.get(i);
+ ps = (PackageSetting) childPkg.mExtras;
+ if (ps != null) {
+ removePackageSettingLI(ps, chatty);
+ }
+ }
+ }
+
+ void removePackageSettingLI(PackageSetting ps, boolean chatty) {
if (DEBUG_INSTALL) {
if (chatty)
Log.d(TAG, "Removing package " + ps.name);
// writer
synchronized (mPackages) {
+ // Remove the parent package
mPackages.remove(pkg.applicationInfo.packageName);
cleanPackageDataStructuresLILPw(pkg, chatty);
+
+ // Remove the child packages
+ final int childCount = (pkg.childPackages != null) ? pkg.childPackages.size() : 0;
+ for (int i = 0; i < childCount; i++) {
+ PackageParser.Package childPkg = pkg.childPackages.get(i);
+ mPackages.remove(childPkg.applicationInfo.packageName);
+ cleanPackageDataStructuresLILPw(childPkg, chatty);
+ }
}
}
static final int UPDATE_PERMISSIONS_REPLACE_PKG = 1<<1;
static final int UPDATE_PERMISSIONS_REPLACE_ALL = 1<<2;
+ private void updatePermissionsLPw(PackageParser.Package pkg, int flags) {
+ // Update the parent permissions
+ updatePermissionsLPw(pkg.packageName, pkg, flags);
+ // Update the child permissions
+ final int childCount = (pkg.childPackages != null) ? pkg.childPackages.size() : 0;
+ for (int i = 0; i < childCount; i++) {
+ PackageParser.Package childPkg = pkg.childPackages.get(i);
+ updatePermissionsLPw(childPkg.packageName, childPkg, flags);
+ }
+ }
+
private void updatePermissionsLPw(String changingPkg, PackageParser.Package pkgInfo,
int flags) {
final String volumeUuid = (pkgInfo != null) ? getVolumeUuidForPackage(pkgInfo) : null;
if (pkg.isUpdatedSystemApp()) {
final PackageSetting sysPs = mSettings
.getDisabledSystemPkgLPr(pkg.packageName);
- if (sysPs.getPermissionsState().hasInstallPermission(perm)) {
+ if (sysPs != null && sysPs.getPermissionsState().hasInstallPermission(perm)) {
// If the original was granted this permission, we take
// that grant decision as read and propagate it to the
// update.
// before. In this case we do want to allow the app to
// now get the new permission if the ancestral apk is
// privileged to get it.
- if (sysPs.pkg != null && sysPs.isPrivileged()) {
- for (int j=0;
- j<sysPs.pkg.requestedPermissions.size(); j++) {
- if (perm.equals(
- sysPs.pkg.requestedPermissions.get(j))) {
+ if (sysPs != null && sysPs.pkg != null && sysPs.isPrivileged()) {
+ for (int j = 0; j < sysPs.pkg.requestedPermissions.size(); j++) {
+ if (perm.equals(sysPs.pkg.requestedPermissions.get(j))) {
allowed = true;
break;
}
}
}
+ // Also if a privileged parent package on the system image or any of
+ // its children requested a privileged permission, the updated child
+ // packages can also get the permission.
+ if (pkg.parentPackage != null) {
+ final PackageSetting disabledSysParentPs = mSettings
+ .getDisabledSystemPkgLPr(pkg.parentPackage.packageName);
+ if (disabledSysParentPs != null && disabledSysParentPs.pkg != null
+ && disabledSysParentPs.isPrivileged()) {
+ if (isPackageRequestingPermission(disabledSysParentPs.pkg, perm)) {
+ allowed = true;
+ } else if (disabledSysParentPs.pkg.childPackages != null) {
+ final int count = disabledSysParentPs.pkg.childPackages.size();
+ for (int i = 0; i < count; i++) {
+ PackageParser.Package disabledSysChildPkg =
+ disabledSysParentPs.pkg.childPackages.get(i);
+ if (isPackageRequestingPermission(disabledSysChildPkg,
+ perm)) {
+ allowed = true;
+ break;
+ }
+ }
+ }
+ }
+ }
}
} else {
allowed = isPrivilegedApp(pkg);
return allowed;
}
+ private boolean isPackageRequestingPermission(PackageParser.Package pkg, String permission) {
+ final int permCount = pkg.requestedPermissions.size();
+ for (int j = 0; j < permCount; j++) {
+ String requestedPermission = pkg.requestedPermissions.get(j);
+ if (permission.equals(requestedPermission)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
final class ActivityIntentResolver
extends IntentResolver<PackageParser.ActivityIntentInfo, ResolveInfo> {
public List<ResolveInfo> queryIntent(Intent intent, String resolvedType,
resourceFile = afterCodeFile;
// Reflect the rename in scanned details
- pkg.codePath = afterCodeFile.getAbsolutePath();
- pkg.baseCodePath = FileUtils.rewriteAfterRename(beforeCodeFile, afterCodeFile,
- pkg.baseCodePath);
- pkg.splitCodePaths = FileUtils.rewriteAfterRename(beforeCodeFile, afterCodeFile,
- pkg.splitCodePaths);
+ pkg.setCodePath(afterCodeFile.getAbsolutePath());
+ pkg.setBaseCodePath(FileUtils.rewriteAfterRename(beforeCodeFile,
+ afterCodeFile, pkg.baseCodePath));
+ pkg.setSplitCodePaths(FileUtils.rewriteAfterRename(beforeCodeFile,
+ afterCodeFile, pkg.splitCodePaths));
// Reflect the rename in app info
- pkg.applicationInfo.volumeUuid = pkg.volumeUuid;
- pkg.applicationInfo.setCodePath(pkg.codePath);
- pkg.applicationInfo.setBaseCodePath(pkg.baseCodePath);
- pkg.applicationInfo.setSplitCodePaths(pkg.splitCodePaths);
- pkg.applicationInfo.setResourcePath(pkg.codePath);
- pkg.applicationInfo.setBaseResourcePath(pkg.baseCodePath);
- pkg.applicationInfo.setSplitResourcePaths(pkg.splitCodePaths);
+ pkg.setApplicationVolumeUuid(pkg.volumeUuid);
+ pkg.setApplicationInfoCodePath(pkg.codePath);
+ pkg.setApplicationInfoBaseCodePath(pkg.baseCodePath);
+ pkg.setApplicationInfoSplitCodePaths(pkg.splitCodePaths);
+ pkg.setApplicationInfoResourcePath(pkg.codePath);
+ pkg.setApplicationInfoBaseResourcePath(pkg.baseCodePath);
+ pkg.setApplicationInfoSplitResourcePaths(pkg.splitCodePaths);
return true;
}
final File afterCodeFile = new File(packagePath);
// Reflect the rename in scanned details
- pkg.codePath = afterCodeFile.getAbsolutePath();
- pkg.baseCodePath = FileUtils.rewriteAfterRename(beforeCodeFile, afterCodeFile,
- pkg.baseCodePath);
- pkg.splitCodePaths = FileUtils.rewriteAfterRename(beforeCodeFile, afterCodeFile,
- pkg.splitCodePaths);
+ pkg.setCodePath(afterCodeFile.getAbsolutePath());
+ pkg.setBaseCodePath(FileUtils.rewriteAfterRename(beforeCodeFile,
+ afterCodeFile, pkg.baseCodePath));
+ pkg.setSplitCodePaths(FileUtils.rewriteAfterRename(beforeCodeFile,
+ afterCodeFile, pkg.splitCodePaths));
// Reflect the rename in app info
- pkg.applicationInfo.volumeUuid = pkg.volumeUuid;
- pkg.applicationInfo.setCodePath(pkg.codePath);
- pkg.applicationInfo.setBaseCodePath(pkg.baseCodePath);
- pkg.applicationInfo.setSplitCodePaths(pkg.splitCodePaths);
- pkg.applicationInfo.setResourcePath(pkg.codePath);
- pkg.applicationInfo.setBaseResourcePath(pkg.baseCodePath);
- pkg.applicationInfo.setSplitResourcePaths(pkg.splitCodePaths);
+ pkg.setApplicationVolumeUuid(pkg.volumeUuid);
+ pkg.setApplicationInfoCodePath(pkg.codePath);
+ pkg.setApplicationInfoBaseCodePath(pkg.baseCodePath);
+ pkg.setApplicationInfoSplitCodePaths(pkg.splitCodePaths);
+ pkg.setApplicationInfoResourcePath(pkg.codePath);
+ pkg.setApplicationInfoBaseResourcePath(pkg.baseCodePath);
+ pkg.setApplicationInfoSplitResourcePaths(pkg.splitCodePaths);
return true;
}
}
// Reflect the move in app info
- pkg.applicationInfo.volumeUuid = pkg.volumeUuid;
- pkg.applicationInfo.setCodePath(pkg.codePath);
- pkg.applicationInfo.setBaseCodePath(pkg.baseCodePath);
- pkg.applicationInfo.setSplitCodePaths(pkg.splitCodePaths);
- pkg.applicationInfo.setResourcePath(pkg.codePath);
- pkg.applicationInfo.setBaseResourcePath(pkg.baseCodePath);
- pkg.applicationInfo.setSplitResourcePaths(pkg.splitCodePaths);
+ pkg.setApplicationVolumeUuid(pkg.volumeUuid);
+ pkg.setApplicationInfoCodePath(pkg.codePath);
+ pkg.setApplicationInfoBaseCodePath(pkg.baseCodePath);
+ pkg.setApplicationInfoSplitCodePaths(pkg.splitCodePaths);
+ pkg.setApplicationInfoResourcePath(pkg.codePath);
+ pkg.setApplicationInfoBaseResourcePath(pkg.baseCodePath);
+ pkg.setApplicationInfoSplitResourcePaths(pkg.splitCodePaths);
return true;
}
PackageParser.Package newPackage = scanPackageTracedLI(pkg, parseFlags, scanFlags,
System.currentTimeMillis(), user);
- updateSettingsLI(newPackage, installerPackageName, volumeUuid, null, null, res, user);
+ updateSettingsLI(newPackage, installerPackageName, null, null, res, user);
prepareAppDataAfterInstall(newPackage);
// delete the partially installed application. the data directory will have to be
// install.
deletePackageLI(pkgName, UserHandle.ALL, false, null, null,
dataDirExists ? PackageManager.DELETE_KEEP_DATA : 0,
- res.removedInfo, true);
+ res.removedInfo, true, null);
}
} catch (PackageManagerException e) {
if (DEBUG_INSTALL) Slog.d(TAG, "replacePackageLI: new=" + pkg + ", old=" + oldPackage);
final PackageSetting ps = mSettings.mPackages.get(pkgName);
if (shouldCheckUpgradeKeySetLP(ps, scanFlags)) {
- if(!checkUpgradeKeySetLP(ps, pkg)) {
+ if (!checkUpgradeKeySetLP(ps, pkg)) {
res.setError(INSTALL_FAILED_UPDATE_INCOMPATIBLE,
"New package not signed by keys specified by upgrade-keysets: "
- + pkgName);
+ + pkgName);
return;
}
} else {
// default to original signature matching
if (compareSignatures(oldPackage.mSignatures, pkg.mSignatures)
- != PackageManager.SIGNATURE_MATCH) {
+ != PackageManager.SIGNATURE_MATCH) {
res.setError(INSTALL_FAILED_UPDATE_INCOMPATIBLE,
"New package has a different signature: " + pkgName);
return;
boolean sysPkg = (isSystemApp(oldPackage));
if (sysPkg) {
replaceSystemPackageLI(oldPackage, pkg, parseFlags, scanFlags,
- user, allUsers, perUserInstalled, installerPackageName, volumeUuid, res);
+ user, allUsers, perUserInstalled, installerPackageName, res);
} else {
replaceNonSystemPackageLI(oldPackage, pkg, parseFlags, scanFlags,
- user, allUsers, perUserInstalled, installerPackageName, volumeUuid, res);
+ user, allUsers, perUserInstalled, installerPackageName, res);
}
}
private void replaceNonSystemPackageLI(PackageParser.Package deletedPackage,
PackageParser.Package pkg, int parseFlags, int scanFlags, UserHandle user,
int[] allUsers, boolean[] perUserInstalled, String installerPackageName,
- String volumeUuid, PackageInstalledInfo res) {
+ PackageInstalledInfo res) {
+ if (DEBUG_INSTALL) Slog.d(TAG, "replaceNonSystemPackageLI: new=" + pkg + ", old="
+ + deletedPackage);
+
String pkgName = deletedPackage.packageName;
boolean deletedPkg = true;
- boolean updatedSettings = false;
+ boolean addedPkg = false;
- if (DEBUG_INSTALL) Slog.d(TAG, "replaceNonSystemPackageLI: new=" + pkg + ", old="
- + deletedPackage);
- long origUpdateTime;
- if (pkg.mExtras != null) {
- origUpdateTime = ((PackageSetting)pkg.mExtras).lastUpdateTime;
- } else {
- origUpdateTime = 0;
- }
+ final long origUpdateTime = (pkg.mExtras != null)
+ ? ((PackageSetting)pkg.mExtras).lastUpdateTime : 0;
// First delete the existing package while retaining the data directory
if (!deletePackageLI(pkgName, null, true, null, null, PackageManager.DELETE_KEEP_DATA,
- res.removedInfo, true)) {
+ res.removedInfo, true, pkg)) {
// If the existing package wasn't successfully deleted
res.setError(INSTALL_FAILED_REPLACE_COULDNT_DELETE, "replaceNonSystemPackageLI");
deletedPkg = false;
sendResourcesChangedBroadcast(false, true, pkgList, uidArray, null);
}
- deleteCodeCacheDirsLI(pkg.volumeUuid, pkgName);
+ deleteCodeCacheDirsLI(pkg);
+
try {
final PackageParser.Package newPackage = scanPackageTracedLI(pkg, parseFlags,
scanFlags | SCAN_UPDATE_TIME, System.currentTimeMillis(), user);
- updateSettingsLI(newPackage, installerPackageName, volumeUuid, allUsers,
+ updateSettingsLI(newPackage, installerPackageName, allUsers,
perUserInstalled, res, user);
prepareAppDataAfterInstall(newPackage);
- updatedSettings = true;
+ addedPkg = true;
} catch (PackageManagerException e) {
res.setError("Package couldn't be installed in " + pkg.codePath, e);
}
}
if (res.returnCode != PackageManager.INSTALL_SUCCEEDED) {
- // remove package from internal structures. Note that we want deletePackageX to
- // delete the package data and cache directories that it created in
- // scanPackageLocked, unless those directories existed before we even tried to
- // install.
- if(updatedSettings) {
- if (DEBUG_INSTALL) Slog.d(TAG, "Install failed, rolling pack: " + pkgName);
- deletePackageLI(
- pkgName, null, true, allUsers, perUserInstalled,
- PackageManager.DELETE_KEEP_DATA,
- res.removedInfo, true);
- }
- // Since we failed to install the new package we need to restore the old
- // package that we deleted.
+ if (DEBUG_INSTALL) Slog.d(TAG, "Install failed, rolling pack: " + pkgName);
+
+ // Revert all internal state mutations and added folders for the failed install
+ if (addedPkg) {
+ deletePackageLI(pkgName, null, true, allUsers, perUserInstalled,
+ PackageManager.DELETE_KEEP_DATA, res.removedInfo, true, null);
+ }
+
+ // Restore the old package
if (deletedPkg) {
if (DEBUG_INSTALL) Slog.d(TAG, "Install failed, reinstalling: " + deletedPackage);
File restoreFile = new File(deletedPackage.codePath);
+ e.getMessage());
return;
}
- // Restore of old package succeeded. Update permissions.
- // writer
+
synchronized (mPackages) {
- updatePermissionsLPw(deletedPackage.packageName, deletedPackage,
- UPDATE_PERMISSIONS_ALL);
- // can downgrade to reader
+ // Ensure the installer package name up to date
+ setInstallerPackageNameLPw(deletedPackage, installerPackageName);
+
+ // Update permissions for restored package
+ updatePermissionsLPw(deletedPackage, UPDATE_PERMISSIONS_ALL);
+
mSettings.writeLPr();
}
+
Slog.i(TAG, "Successfully restored package : " + pkgName + " after failed upgrade");
}
}
private void replaceSystemPackageLI(PackageParser.Package deletedPackage,
PackageParser.Package pkg, int parseFlags, int scanFlags, UserHandle user,
int[] allUsers, boolean[] perUserInstalled, String installerPackageName,
- String volumeUuid, PackageInstalledInfo res) {
+ PackageInstalledInfo res) {
if (DEBUG_INSTALL) Slog.d(TAG, "replaceSystemPackageLI: new=" + pkg
+ ", old=" + deletedPackage);
- boolean disabledSystem = false;
- boolean updatedSettings = false;
+
+ final boolean disabledSystem;
+
+ // Set the system/privileged flags as needed
parseFlags |= PackageParser.PARSE_IS_SYSTEM;
- if ((deletedPackage.applicationInfo.privateFlags&ApplicationInfo.PRIVATE_FLAG_PRIVILEGED)
+ if ((deletedPackage.applicationInfo.privateFlags & ApplicationInfo.PRIVATE_FLAG_PRIVILEGED)
!= 0) {
parseFlags |= PackageParser.PARSE_IS_PRIVILEGED;
}
- String packageName = deletedPackage.packageName;
- if (packageName == null) {
- res.setError(INSTALL_FAILED_REPLACE_COULDNT_DELETE,
- "Attempt to delete null packageName.");
- return;
- }
- PackageParser.Package oldPkg;
- PackageSetting oldPkgSetting;
- // reader
- synchronized (mPackages) {
- oldPkg = mPackages.get(packageName);
- oldPkgSetting = mSettings.mPackages.get(packageName);
- if((oldPkg == null) || (oldPkg.applicationInfo == null) ||
- (oldPkgSetting == null)) {
- res.setError(INSTALL_FAILED_REPLACE_COULDNT_DELETE,
- "Couldn't find package " + packageName + " information");
- return;
- }
- }
- killApplication(packageName, oldPkg.applicationInfo.uid, "replace sys pkg");
+ // Kill package processes including services, providers, etc.
+ killPackage(deletedPackage, "replace sys pkg");
+
+ // Report the result for the parent package only
+ res.removedInfo.uid = deletedPackage.applicationInfo.uid;
+ res.removedInfo.removedPackage = deletedPackage.packageName;
- res.removedInfo.uid = oldPkg.applicationInfo.uid;
- res.removedInfo.removedPackage = packageName;
// Remove existing system package
- removePackageLI(oldPkgSetting, true);
- // writer
- synchronized (mPackages) {
- disabledSystem = mSettings.disableSystemPackageLPw(packageName);
- if (!disabledSystem && deletedPackage != null) {
- // We didn't need to disable the .apk as a current system package,
- // which means we are replacing another update that is already
- // installed. We need to make sure to delete the older one's .apk.
- res.removedInfo.args = createInstallArgsForExisting(0,
- deletedPackage.applicationInfo.getCodePath(),
- deletedPackage.applicationInfo.getResourcePath(),
- getAppDexInstructionSets(deletedPackage.applicationInfo));
- } else {
- res.removedInfo.args = null;
- }
+ removePackageSettingLI(deletedPackage, true);
+
+ disabledSystem = disableSystemPackageLPw(deletedPackage, pkg);
+ if (!disabledSystem) {
+ // We didn't need to disable the .apk as a current system package,
+ // which means we are replacing another update that is already
+ // installed. We need to make sure to delete the older one's .apk.
+ res.removedInfo.args = createInstallArgsForExisting(0,
+ deletedPackage.applicationInfo.getCodePath(),
+ deletedPackage.applicationInfo.getResourcePath(),
+ getAppDexInstructionSets(deletedPackage.applicationInfo));
+ } else {
+ res.removedInfo.args = null;
}
// Successfully disabled the old package. Now proceed with re-installation
- deleteCodeCacheDirsLI(pkg.volumeUuid, packageName);
+ deleteCodeCacheDirsLI(pkg);
res.returnCode = PackageManager.INSTALL_SUCCEEDED;
- pkg.applicationInfo.flags |= ApplicationInfo.FLAG_UPDATED_SYSTEM_APP;
+ pkg.setApplicationInfoFlags(ApplicationInfo.FLAG_UPDATED_SYSTEM_APP,
+ ApplicationInfo.FLAG_UPDATED_SYSTEM_APP);
PackageParser.Package newPackage = null;
try {
+ // Add the package to the internal data structures
newPackage = scanPackageTracedLI(pkg, parseFlags, scanFlags, 0, user);
- if (newPackage.mExtras != null) {
- final PackageSetting newPkgSetting = (PackageSetting) newPackage.mExtras;
- newPkgSetting.firstInstallTime = oldPkgSetting.firstInstallTime;
- newPkgSetting.lastUpdateTime = System.currentTimeMillis();
- // is the update attempting to change shared user? that isn't going to work...
- if (oldPkgSetting.sharedUser != newPkgSetting.sharedUser) {
- res.setError(INSTALL_FAILED_SHARED_USER_INCOMPATIBLE,
- "Forbidding shared user change from " + oldPkgSetting.sharedUser
- + " to " + newPkgSetting.sharedUser);
- updatedSettings = true;
- }
+ // Set the update and install times
+ PackageSetting deletedPkgSetting = (PackageSetting) deletedPackage.mExtras;
+ setInstallAndUpdateTime(newPackage, deletedPkgSetting.firstInstallTime,
+ System.currentTimeMillis());
+
+ // Check for shared user id changes
+ String invalidPackageName = getParentOrChildPackageChangedSharedUser(deletedPackage, newPackage);
+ if (invalidPackageName != null) {
+ res.setError(INSTALL_FAILED_SHARED_USER_INCOMPATIBLE,
+ "Forbidding shared user change from " + deletedPkgSetting.sharedUser
+ + " to " + invalidPackageName);
}
+ // Update the package dynamic state if succeeded
if (res.returnCode == PackageManager.INSTALL_SUCCEEDED) {
- updateSettingsLI(newPackage, installerPackageName, volumeUuid, allUsers,
+ // Now that the install succeeded make sure we remove data
+ // directories for any child package the update removed.
+ final int deletedChildCount = (deletedPackage.childPackages != null)
+ ? deletedPackage.childPackages.size() : 0;
+ final int newChildCount = (newPackage.childPackages != null)
+ ? newPackage.childPackages.size() : 0;
+ for (int i = 0; i < deletedChildCount; i++) {
+ PackageParser.Package deletedChildPkg = deletedPackage.childPackages.get(i);
+ boolean childPackageDeleted = true;
+ for (int j = 0; j < newChildCount; j++) {
+ PackageParser.Package newChildPkg = newPackage.childPackages.get(j);
+ if (deletedChildPkg.packageName.equals(newChildPkg.packageName)) {
+ childPackageDeleted = false;
+ break;
+ }
+ }
+ if (childPackageDeleted) {
+ PackageSetting ps = mSettings.getDisabledSystemPkgLPr(
+ deletedChildPkg.packageName);
+ if (ps != null) {
+ removePackageDataLI(ps, allUsers, perUserInstalled, null, 0, false);
+ }
+ }
+ }
+
+ updateSettingsLI(newPackage, installerPackageName, allUsers,
perUserInstalled, res, user);
prepareAppDataAfterInstall(newPackage);
- updatedSettings = true;
}
-
} catch (PackageManagerException e) {
+ res.returnCode = INSTALL_FAILED_INTERNAL_ERROR;
res.setError("Package couldn't be installed in " + pkg.codePath, e);
}
}
// Add back the old system package
try {
- scanPackageTracedLI(oldPkg, parseFlags, SCAN_UPDATE_SIGNATURE, 0, user);
+ scanPackageTracedLI(deletedPackage, parseFlags, SCAN_UPDATE_SIGNATURE, 0, user);
} catch (PackageManagerException e) {
Slog.e(TAG, "Failed to restore original package: " + e.getMessage());
}
- // Restore the old system information in Settings
+
synchronized (mPackages) {
if (disabledSystem) {
- mSettings.enableSystemPackageLPw(packageName);
- }
- if (updatedSettings) {
- mSettings.setInstallerPackageName(packageName,
- oldPkgSetting.installerPackageName);
+ enableSystemPackageLPw(deletedPackage);
}
+
+ // Ensure the installer package name up to date
+ setInstallerPackageNameLPw(deletedPackage, installerPackageName);
+
+ // Update permissions for restored package
+ updatePermissionsLPw(deletedPackage, UPDATE_PERMISSIONS_ALL);
+
mSettings.writeLPr();
}
+
+ Slog.i(TAG, "Successfully restored package : " + deletedPackage.packageName
+ + " after failed upgrade");
+ }
+ }
+
+ /**
+ * Checks whether the parent or any of the child packages have a change shared
+ * user. For a package to be a valid update the shred users of the parent and
+ * the children should match. We may later support changing child shared users.
+ * @param oldPkg The updated package.
+ * @param newPkg The update package.
+ * @return The shared user that change between the versions.
+ */
+ private String getParentOrChildPackageChangedSharedUser(PackageParser.Package oldPkg,
+ PackageParser.Package newPkg) {
+ // Check parent shared user
+ if (!Objects.equals(oldPkg.mSharedUserId, newPkg.mSharedUserId)) {
+ return newPkg.packageName;
+ }
+ // Check child shared users
+ final int oldChildCount = (oldPkg.childPackages != null) ? oldPkg.childPackages.size() : 0;
+ final int newChildCount = (newPkg.childPackages != null) ? newPkg.childPackages.size() : 0;
+ for (int i = 0; i < newChildCount; i++) {
+ PackageParser.Package newChildPkg = newPkg.childPackages.get(i);
+ // If this child was present, did it have the same shared user?
+ for (int j = 0; j < oldChildCount; j++) {
+ PackageParser.Package oldChildPkg = oldPkg.childPackages.get(j);
+ if (newChildPkg.packageName.equals(oldChildPkg.packageName)
+ && !Objects.equals(newChildPkg.mSharedUserId, oldChildPkg.mSharedUserId)) {
+ return newChildPkg.packageName;
+ }
+ }
+ }
+ return null;
+ }
+
+ private void removeNativeBinariesLI(PackageParser.Package pkg) {
+ // Remove the lib path for the parent package
+ PackageSetting ps = (PackageSetting) pkg.mExtras;
+ if (ps != null) {
+ NativeLibraryHelper.removeNativeBinariesLI(ps.legacyNativeLibraryPathString);
+ }
+ // Remove the lib path for the child packages
+ final int childCount = (pkg.childPackages != null) ? pkg.childPackages.size() : 0;
+ for (int i = 0; i < childCount; i++) {
+ ps = (PackageSetting) pkg.childPackages.get(i).mExtras;
+ if (ps != null) {
+ NativeLibraryHelper.removeNativeBinariesLI(ps.legacyNativeLibraryPathString);
+ }
+ }
+ }
+
+ private void enableSystemPackageLPw(PackageParser.Package pkg) {
+ // Enable the parent package
+ mSettings.enableSystemPackageLPw(pkg.packageName);
+ // Enable the child packages
+ final int childCount = (pkg.childPackages != null) ? pkg.childPackages.size() : 0;
+ for (int i = 0; i < childCount; i++) {
+ PackageParser.Package childPkg = pkg.childPackages.get(i);
+ mSettings.enableSystemPackageLPw(childPkg.packageName);
+ }
+ }
+
+ private boolean disableSystemPackageLPw(PackageParser.Package oldPkg,
+ PackageParser.Package newPkg) {
+ // Disable the parent package (parent always replaced)
+ boolean disabled = mSettings.disableSystemPackageLPw(oldPkg.packageName, true);
+ // Disable the child packages
+ final int childCount = (oldPkg.childPackages != null) ? oldPkg.childPackages.size() : 0;
+ for (int i = 0; i < childCount; i++) {
+ PackageParser.Package childPkg = oldPkg.childPackages.get(i);
+ final boolean replace = newPkg.hasChildPackage(childPkg.packageName);
+ disabled |= mSettings.disableSystemPackageLPw(childPkg.packageName, replace);
+ }
+ return disabled;
+ }
+
+ private void setInstallerPackageNameLPw(PackageParser.Package pkg,
+ String installerPackageName) {
+ // Enable the parent package
+ mSettings.setInstallerPackageName(pkg.packageName, installerPackageName);
+ // Enable the child packages
+ final int childCount = (pkg.childPackages != null) ? pkg.childPackages.size() : 0;
+ for (int i = 0; i < childCount; i++) {
+ PackageParser.Package childPkg = pkg.childPackages.get(i);
+ mSettings.setInstallerPackageName(childPkg.packageName, installerPackageName);
}
}
}
private void updateSettingsLI(PackageParser.Package newPackage, String installerPackageName,
- String volumeUuid, int[] allUsers, boolean[] perUserInstalled, PackageInstalledInfo res,
- UserHandle user) {
+ int[] allUsers, boolean[] perUserInstalled, PackageInstalledInfo res, UserHandle user) {
+ // Update the parent package setting
+ updateSettingsInternalLI(newPackage, installerPackageName, allUsers, perUserInstalled,
+ res, user);
+ // Update the child packages setting
+ final int childCount = (newPackage.childPackages != null)
+ ? newPackage.childPackages.size() : 0;
+ for (int i = 0; i < childCount; i++) {
+ PackageParser.Package childPackage = newPackage.childPackages.get(i);
+ updateSettingsInternalLI(childPackage, installerPackageName, allUsers, perUserInstalled,
+ res, user);
+ }
+ }
+
+ private void updateSettingsInternalLI(PackageParser.Package newPackage,
+ String installerPackageName, int[] allUsers, boolean[] perUserInstalled,
+ PackageInstalledInfo res, UserHandle user) {
Trace.traceBegin(TRACE_TAG_PACKAGE_MANAGER, "updateSettings");
String pkgName = newPackage.packageName;
Trace.traceBegin(TRACE_TAG_PACKAGE_MANAGER, "collectCertificates");
try {
- pp.collectCertificates(pkg, parseFlags);
+ PackageParser.collectCertificates(pkg, parseFlags);
} catch (PackageParserException e) {
res.setError("Failed collect during installPackageLI", e);
return;
if (DEBUG_INSTALL) Slog.d(TAG, "Replace existing pacakge: " + pkgName);
}
- // Prevent apps opting out from runtime permissions
+ // Child packages are installed through the parent package
+ if (pkg.parentPackage != null) {
+ res.setError(PackageManager.INSTALL_PARSE_FAILED_BAD_PACKAGE_NAME,
+ "Package " + pkg.packageName + " is child of package "
+ + pkg.parentPackage.parentPackage + ". Child packages "
+ + "can be updated only through the parent package.");
+ return;
+ }
+
if (replace) {
+ // Prevent apps opting out from runtime permissions
PackageParser.Package oldPackage = mPackages.get(pkgName);
final int oldTargetSdk = oldPackage.applicationInfo.targetSdkVersion;
final int newTargetSdk = pkg.applicationInfo.targetSdkVersion;
+ " target SDK " + oldTargetSdk + " does.");
return;
}
+
+ // Prevent installing of child packages
+ if (oldPackage.parentPackage != null) {
+ res.setError(PackageManager.INSTALL_PARSE_FAILED_BAD_PACKAGE_NAME,
+ "Package " + pkg.packageName + " is child of package "
+ + oldPackage.parentPackage + ". Child packages "
+ + "can be updated only through the parent package.");
+ return;
+ }
}
}
}
}
}
-
}
if (systemApp) {
synchronized (mInstallLock) {
if (DEBUG_REMOVE) Slog.d(TAG, "deletePackageX: pkg=" + packageName + " user=" + userId);
- res = deletePackageLI(packageName, removeForUser,
- true, allUsers, perUserInstalled,
- flags | REMOVE_CHATTY, info, true);
+ res = deletePackageLI(packageName, removeForUser, true, allUsers, perUserInstalled,
+ flags | REMOVE_CHATTY, info, true, null);
systemUpdate = info.isRemovedPackageSystemUpdate;
synchronized (mPackages) {
if (res) {
PackageRemovedInfo outInfo, int flags, boolean writeSettings) {
String packageName = ps.name;
if (DEBUG_REMOVE) Slog.d(TAG, "removePackageDataLI: " + ps);
- removePackageLI(ps, (flags&REMOVE_CHATTY) != 0);
+ removePackageSettingLI(ps, (flags&REMOVE_CHATTY) != 0);
// Retrieve object to delete permissions for shared user later on
final PackageSetting deletedPs;
// reader
/*
* Tries to delete system package.
*/
- private boolean deleteSystemPackageLI(PackageSetting newPs,
- int[] allUserHandles, boolean[] perUserInstalled,
- int flags, PackageRemovedInfo outInfo, boolean writeSettings) {
+ private boolean deleteSystemPackageLI(PackageParser.Package deletedPkg,
+ PackageSetting deletedPs, int[] allUserHandles, boolean[] perUserInstalled,
+ int flags, PackageRemovedInfo outInfo, boolean writeSettings,
+ PackageParser.Package replacingPackage) {
+ if (deletedPkg.parentPackage != null) {
+ Slog.w(TAG, "Attempt to delete child system package " + deletedPkg.packageName);
+ return false;
+ }
+
final boolean applyUserRestrictions
= (allUserHandles != null) && (perUserInstalled != null);
- PackageSetting disabledPs = null;
+ final PackageSetting disabledPs;
// Confirm if the system package has been updated
// An updated system app can be deleted. This will also have to restore
// the system pkg from system partition
// reader
synchronized (mPackages) {
- disabledPs = mSettings.getDisabledSystemPkgLPr(newPs.name);
+ disabledPs = mSettings.getDisabledSystemPkgLPr(deletedPkg.packageName);
}
- if (DEBUG_REMOVE) Slog.d(TAG, "deleteSystemPackageLI: newPs=" + newPs
+
+ if (DEBUG_REMOVE) Slog.d(TAG, "deleteSystemPackageLI: newPs=" + deletedPkg.packageName
+ " disabledPs=" + disabledPs);
+
if (disabledPs == null) {
- Slog.w(TAG, "Attempt to delete unknown system package "+ newPs.name);
+ Slog.w(TAG, "Attempt to delete unknown system package "+ deletedPkg.packageName);
return false;
} else if (DEBUG_REMOVE) {
Slog.d(TAG, "Deleting system pkg from data partition");
}
+
if (DEBUG_REMOVE) {
if (applyUserRestrictions) {
Slog.d(TAG, "Remembering install states:");
}
}
}
+
// Delete the updated package
outInfo.isRemovedPackageSystemUpdate = true;
- if (disabledPs.versionCode < newPs.versionCode) {
+ if (disabledPs.versionCode < deletedPs.versionCode) {
// Delete data for downgrades
flags &= ~PackageManager.DELETE_KEEP_DATA;
} else {
// Preserve data by setting flag
flags |= PackageManager.DELETE_KEEP_DATA;
}
- boolean ret = deleteInstalledPackageLI(newPs, true, flags,
- allUserHandles, perUserInstalled, outInfo, writeSettings);
+ boolean ret = deleteInstalledPackageLI(deletedPkg, true, flags, allUserHandles,
+ perUserInstalled, outInfo, writeSettings, replacingPackage);
if (!ret) {
return false;
}
+
// writer
synchronized (mPackages) {
// Reinstate the old system package
- mSettings.enableSystemPackageLPw(newPs.name);
+ enableSystemPackageLPw(disabledPs.pkg);
// Remove any native libraries from the upgraded package.
- NativeLibraryHelper.removeNativeBinariesLI(newPs.legacyNativeLibraryPathString);
+ removeNativeBinariesLI(deletedPkg);
}
+
// Install the system package
if (DEBUG_REMOVE) Slog.d(TAG, "Re-installing system package: " + disabledPs);
int parseFlags = PackageParser.PARSE_MUST_BE_APK | PackageParser.PARSE_IS_SYSTEM;
try {
newPkg = scanPackageTracedLI(disabledPs.codePath, parseFlags, SCAN_NO_PATHS, 0, null);
} catch (PackageManagerException e) {
- Slog.w(TAG, "Failed to restore system package " + newPs.name + ": " + e.getMessage());
+ Slog.w(TAG, "Failed to restore system package:" + deletedPkg.packageName + ": "
+ + e.getMessage());
return false;
}
// Propagate the permissions state as we do not want to drop on the floor
// runtime permissions. The update permissions method below will take
// care of removing obsolete permissions and grant install permissions.
- ps.getPermissionsState().copyFrom(newPs.getPermissionsState());
+ ps.getPermissionsState().copyFrom(deletedPs.getPermissionsState());
updatePermissionsLPw(newPkg.packageName, newPkg,
UPDATE_PERMISSIONS_ALL | UPDATE_PERMISSIONS_REPLACE_PKG);
return true;
}
- private boolean deleteInstalledPackageLI(PackageSetting ps,
- boolean deleteCodeAndResources, int flags,
- int[] allUserHandles, boolean[] perUserInstalled,
- PackageRemovedInfo outInfo, boolean writeSettings) {
- if (outInfo != null) {
- outInfo.uid = ps.appId;
+ private boolean deleteInstalledPackageLI(PackageParser.Package pkg,
+ boolean deleteCodeAndResources, int flags, int[] allUserHandles,
+ boolean[] perUserInstalled, PackageRemovedInfo outInfo, boolean writeSettings,
+ PackageParser.Package replacingPackage) {
+ PackageSetting ps = null;
+
+ synchronized (mPackages) {
+ pkg = mPackages.get(pkg.packageName);
+ if (pkg == null) {
+ return false;
+ }
+
+ ps = mSettings.mPackages.get(pkg.packageName);
+ if (ps == null) {
+ return false;
+ }
+
+ if (outInfo != null) {
+ outInfo.uid = ps.appId;
+ }
}
// Delete package data from internal structures and also remove data if flag is set
- removePackageDataLI(ps, allUserHandles, perUserInstalled, outInfo, flags, writeSettings);
+ removePackageDataLI(ps, allUserHandles, perUserInstalled, outInfo, flags,
+ writeSettings);
- // Delete application code and resources
- if (deleteCodeAndResources && (outInfo != null)) {
- outInfo.args = createInstallArgsForExisting(packageFlagsToInstallFlags(ps),
- ps.codePathString, ps.resourcePathString, getAppDexInstructionSets(ps));
- if (DEBUG_SD_INSTALL) Slog.i(TAG, "args=" + outInfo.args);
+ // Delete the child packages data
+ final int childCount = (pkg.childPackages != null) ? pkg.childPackages.size() : 0;
+ for (int i = 0; i < childCount; i++) {
+ PackageSetting childPs;
+ synchronized (mPackages) {
+ childPs = mSettings.peekPackageLPr(pkg.childPackages.get(i).packageName);
+ }
+ if (childPs != null) {
+ final int deleteFlags = (flags & DELETE_KEEP_DATA) != 0
+ && (replacingPackage != null
+ && !replacingPackage.hasChildPackage(childPs.name))
+ ? flags & ~DELETE_KEEP_DATA : flags;
+ removePackageDataLI(childPs, allUserHandles, perUserInstalled, outInfo,
+ deleteFlags, writeSettings);
+ }
}
+
+ // Delete application code and resources only for parent packages
+ if (ps.pkg.parentPackage == null) {
+ if (deleteCodeAndResources && (outInfo != null)) {
+ outInfo.args = createInstallArgsForExisting(packageFlagsToInstallFlags(ps),
+ ps.codePathString, ps.resourcePathString, getAppDexInstructionSets(ps));
+ if (DEBUG_SD_INSTALL) Slog.i(TAG, "args=" + outInfo.args);
+ }
+ }
+
return true;
}
*/
private boolean deletePackageLI(String packageName, UserHandle user,
boolean deleteCodeAndResources, int[] allUserHandles, boolean[] perUserInstalled,
- int flags, PackageRemovedInfo outInfo,
- boolean writeSettings) {
+ int flags, PackageRemovedInfo outInfo, boolean writeSettings,
+ PackageParser.Package replacingPackage) {
if (packageName == null) {
Slog.w(TAG, "Attempt to delete null packageName.");
return false;
}
+
if (DEBUG_REMOVE) Slog.d(TAG, "deletePackageLI: " + packageName + " user " + user);
+
PackageSetting ps;
- boolean dataOnly = false;
int removeUser = -1;
- int appId = -1;
+
synchronized (mPackages) {
ps = mSettings.mPackages.get(packageName);
if (ps == null) {
Slog.w(TAG, "Package named '" + packageName + "' doesn't exist.");
return false;
}
- if ((!isSystemApp(ps) || (flags&PackageManager.DELETE_SYSTEM_APP) != 0) && user != null
- && user.getIdentifier() != UserHandle.USER_ALL) {
- // The caller is asking that the package only be deleted for a single
- // user. To do this, we just mark its uninstalled state and delete
- // its data. If this is a system app, we only allow this to happen if
- // they have set the special DELETE_SYSTEM_APP which requests different
- // semantics than normal for uninstalling system apps.
- if (DEBUG_REMOVE) Slog.d(TAG, "Only deleting for single user");
- final int userId = user.getIdentifier();
- ps.setUserState(userId,
- COMPONENT_ENABLED_STATE_DEFAULT,
- false, //installed
- true, //stopped
- true, //notLaunched
- false, //hidden
- false, //suspended
- null, null, null,
- false, // blockUninstall
- ps.readUserState(userId).domainVerificationStatus, 0);
- if (!isSystemApp(ps)) {
- // Do not uninstall the APK if an app should be cached
- boolean keepUninstalledPackage = shouldKeepUninstalledPackageLPr(packageName);
- if (ps.isAnyInstalled(sUserManager.getUserIds()) || keepUninstalledPackage) {
- // Other user still have this package installed, so all
- // we need to do is clear this user's data and save that
- // it is uninstalled.
- if (DEBUG_REMOVE) Slog.d(TAG, "Still installed by other users");
- removeUser = user.getIdentifier();
- appId = ps.appId;
- scheduleWritePackageRestrictionsLocked(removeUser);
- } else {
- // We need to set it back to 'installed' so the uninstall
- // broadcasts will be sent correctly.
- if (DEBUG_REMOVE) Slog.d(TAG, "Not installed by other users, full delete");
- ps.setInstalled(true, user.getIdentifier());
- }
- } else {
- // This is a system app, so we assume that the
- // other users still have this package installed, so all
- // we need to do is clear this user's data and save that
- // it is uninstalled.
- if (DEBUG_REMOVE) Slog.d(TAG, "Deleting system app");
- removeUser = user.getIdentifier();
- appId = ps.appId;
- scheduleWritePackageRestrictionsLocked(removeUser);
+
+ if (ps.pkg.parentPackage != null && (!isSystemApp(ps)
+ || (flags & PackageManager.DELETE_SYSTEM_APP) != 0)) {
+ if (DEBUG_REMOVE) {
+ Slog.d(TAG, "Uninstalled child package:" + packageName + " for user:"
+ + ((user == null) ? UserHandle.USER_ALL : user));
+ }
+ if (!clearPackageStateForUser(ps, removeUser, outInfo)) {
+ return false;
}
+ markPackageUninstalledForUserLPw(ps, user);
+ scheduleWritePackageRestrictionsLocked(user);
+ return true;
}
}
- if (removeUser >= 0) {
- // From above, we determined that we are deleting this only
- // for a single user. Continue the work here.
- if (DEBUG_REMOVE) Slog.d(TAG, "Updating install state for user: " + removeUser);
- if (outInfo != null) {
- outInfo.removedPackage = packageName;
- outInfo.removedAppId = appId;
- outInfo.removedUsers = new int[] {removeUser};
- }
- // TODO: triage flags as part of 26466827
- final int installerFlags = StorageManager.FLAG_STORAGE_CE
- | StorageManager.FLAG_STORAGE_DE;
- try {
- mInstaller.destroyAppData(ps.volumeUuid, packageName, removeUser, installerFlags);
- } catch (InstallerException e) {
- Slog.w(TAG, "Failed to delete app data", e);
- }
- removeKeystoreDataIfNeeded(removeUser, appId);
- schedulePackageCleaning(packageName, removeUser, false);
- synchronized (mPackages) {
- if (clearPackagePreferredActivitiesLPw(packageName, removeUser)) {
- scheduleWritePackageRestrictionsLocked(removeUser);
+ if (((!isSystemApp(ps) || (flags&PackageManager.DELETE_SYSTEM_APP) != 0) && user != null
+ && user.getIdentifier() != UserHandle.USER_ALL)) {
+ // The caller is asking that the package only be deleted for a single
+ // user. To do this, we just mark its uninstalled state and delete
+ // its data. If this is a system app, we only allow this to happen if
+ // they have set the special DELETE_SYSTEM_APP which requests different
+ // semantics than normal for uninstalling system apps.
+ markPackageUninstalledForUserLPw(ps, user);
+
+ if (!isSystemApp(ps)) {
+ // Do not uninstall the APK if an app should be cached
+ boolean keepUninstalledPackage = shouldKeepUninstalledPackageLPr(packageName);
+ if (ps.isAnyInstalled(sUserManager.getUserIds()) || keepUninstalledPackage) {
+ // Other user still have this package installed, so all
+ // we need to do is clear this user's data and save that
+ // it is uninstalled.
+ if (DEBUG_REMOVE) Slog.d(TAG, "Still installed by other users");
+ if (!clearPackageStateForUser(ps, removeUser, outInfo)) {
+ return false;
+ }
+ scheduleWritePackageRestrictionsLocked(user);
+ return true;
+ } else {
+ // We need to set it back to 'installed' so the uninstall
+ // broadcasts will be sent correctly.
+ if (DEBUG_REMOVE) Slog.d(TAG, "Not installed by other users, full delete");
+ ps.setInstalled(true, user.getIdentifier());
}
- resetUserChangesToRuntimePermissionsAndFlagsLPw(ps, removeUser);
+ } else {
+ // This is a system app, so we assume that the
+ // other users still have this package installed, so all
+ // we need to do is clear this user's data and save that
+ // it is uninstalled.
+ if (DEBUG_REMOVE) Slog.d(TAG, "Deleting system app");
+ if (!clearPackageStateForUser(ps, removeUser, outInfo)) {
+ return false;
+ }
+ scheduleWritePackageRestrictionsLocked(user);
+ return true;
}
- return true;
- }
-
- if (dataOnly) {
- // Delete application data first
- if (DEBUG_REMOVE) Slog.d(TAG, "Removing package data only");
- removePackageDataLI(ps, null, null, outInfo, flags, writeSettings);
- return true;
}
boolean ret = false;
if (DEBUG_REMOVE) Slog.d(TAG, "Removing system package: " + ps.name);
// When an updated system application is deleted we delete the existing resources as well and
// fall back to existing code in system partition
- ret = deleteSystemPackageLI(ps, allUserHandles, perUserInstalled,
- flags, outInfo, writeSettings);
+ ret = deleteSystemPackageLI(ps.pkg, ps, allUserHandles, perUserInstalled,
+ flags, outInfo, writeSettings, replacingPackage);
} else {
if (DEBUG_REMOVE) Slog.d(TAG, "Removing non-system package: " + ps.name);
// Kill application pre-emptively especially for apps on sd.
killApplication(packageName, ps.appId, "uninstall pkg");
- ret = deleteInstalledPackageLI(ps, deleteCodeAndResources, flags,
- allUserHandles, perUserInstalled,
- outInfo, writeSettings);
+ ret = deleteInstalledPackageLI(ps.pkg, deleteCodeAndResources, flags, allUserHandles,
+ perUserInstalled, outInfo, writeSettings, replacingPackage);
}
return ret;
}
- private final static class ClearStorageConnection implements ServiceConnection {
+ private void markPackageUninstalledForUserLPw(PackageSetting ps, UserHandle user) {
+ final int[] userIds = (user == null || user.getIdentifier() == UserHandle.USER_ALL)
+ ? sUserManager.getUserIds() : new int[] {user.getIdentifier()};
+ for (int nextUserId : userIds) {
+ if (DEBUG_REMOVE) {
+ Slog.d(TAG, "Marking package:" + ps.name + " uninstalled for user:" + nextUserId);
+ }
+ ps.setUserState(nextUserId, COMPONENT_ENABLED_STATE_DEFAULT,
+ false /*installed*/, true /*stopped*/, true /*notLaunched*/,
+ false /*hidden*/, false /*suspended*/, null, null, null,
+ false /*blockUninstall*/,
+ ps.readUserState(nextUserId).domainVerificationStatus, 0);
+ }
+ }
+
+ private boolean clearPackageStateForUser(PackageSetting ps, int userId,
+ PackageRemovedInfo outInfo) {
+ final int[] userIds = (userId == UserHandle.USER_ALL) ? sUserManager.getUserIds()
+ : new int[] {userId};
+ for (int nextUserId : userIds) {
+ if (DEBUG_REMOVE) {
+ Slog.d(TAG, "Updating package:" + ps.name + " install state for user:"
+ + nextUserId);
+ }
+ final int flags = StorageManager.FLAG_STORAGE_CE| StorageManager.FLAG_STORAGE_DE;
+ try {
+ mInstaller.destroyAppData(ps.volumeUuid, ps.name, nextUserId, flags);
+ } catch (InstallerException e) {
+ Slog.w(TAG, "Couldn't remove cache files for package " + ps.name, e);
+ return false;
+ }
+ removeKeystoreDataIfNeeded(nextUserId, ps.appId);
+ schedulePackageCleaning(ps.name, nextUserId, false);
+ synchronized (mPackages) {
+ if (clearPackagePreferredActivitiesLPw(ps.name, nextUserId)) {
+ scheduleWritePackageRestrictionsLocked(nextUserId);
+ }
+ resetUserChangesToRuntimePermissionsAndFlagsLPw(ps, nextUserId);
+ }
+ }
+
+ if (outInfo != null) {
+ outInfo.removedPackage = ps.name;
+ outInfo.removedAppId = ps.appId;
+ outInfo.removedUsers = userIds;
+ }
+
+ return true;
+ }
+
+ private final class ClearStorageConnection implements ServiceConnection {
IMediaContainerService mContainerService;
@Override
/*
* Unload packages mounted on external media. This involves deleting package
- * data from internal structures, sending broadcasts about diabled packages,
+ * data from internal structures, sending broadcasts about disabled packages,
* gc'ing to free up references, unmounting all secure containers
* corresponding to packages on external media, and posting a
* UPDATED_MEDIA_STATUS message if status has been requested. Please note
PackageRemovedInfo outInfo = new PackageRemovedInfo();
synchronized (mInstallLock) {
boolean res = deletePackageLI(pkgName, null, false, null, null,
- PackageManager.DELETE_KEEP_DATA, outInfo, false);
+ PackageManager.DELETE_KEEP_DATA, outInfo, false, null);
if (res) {
pkgList.add(pkgName);
} else {
final ApplicationInfo info = ps.pkg.applicationInfo;
final PackageRemovedInfo outInfo = new PackageRemovedInfo();
if (deletePackageLI(ps.name, null, false, null, null,
- PackageManager.DELETE_KEEP_DATA, outInfo, false)) {
+ PackageManager.DELETE_KEEP_DATA, outInfo, false, null)) {
unloaded.add(info);
} else {
Slog.w(TAG, "Failed to unload " + ps.codePath);
* left intact.
*/
private void prepareAppDataAfterInstall(PackageParser.Package pkg) {
+ prepareAppDataAfterInstallInternal(pkg);
+ final int childCount = (pkg.childPackages != null) ? pkg.childPackages.size() : 0;
+ for (int i = 0; i < childCount; i++) {
+ PackageParser.Package childPackage = pkg.childPackages.get(i);
+ prepareAppDataAfterInstallInternal(childPackage);
+ }
+ }
+
+ private void prepareAppDataAfterInstallInternal(PackageParser.Package pkg) {
final PackageSetting ps;
synchronized (mPackages) {
ps = mSettings.mPackages.get(pkg.packageName);
private static final String TAG_SHARED_USER = "shared-user";
private static final String TAG_RUNTIME_PERMISSIONS = "runtime-permissions";
private static final String TAG_PERMISSIONS = "perms";
+ private static final String TAG_CHILD_PACKAGE = "child-package";
+
private static final String TAG_PERSISTENT_PREFERRED_ACTIVITIES =
"persistent-preferred-activities";
static final String TAG_CROSS_PROFILE_INTENT_FILTERS =
String legacyNativeLibraryPathString, String primaryCpuAbi, String secondaryCpuAbi,
int pkgFlags, int pkgPrivateFlags, UserHandle user, boolean add) {
final String name = pkg.packageName;
+ final String parentPackageName = (pkg.parentPackage != null)
+ ? pkg.parentPackage.packageName : null;
+
+ List<String> childPackageNames = null;
+ if (pkg.childPackages != null) {
+ final int childCount = pkg.childPackages.size();
+ childPackageNames = new ArrayList<>(childCount);
+ for (int i = 0; i < childCount; i++) {
+ String childPackageName = pkg.childPackages.get(i).packageName;
+ childPackageNames.add(childPackageName);
+ }
+ }
+
PackageSetting p = getPackageLPw(name, origPackage, realName, sharedUser, codePath,
resourcePath, legacyNativeLibraryPathString, primaryCpuAbi, secondaryCpuAbi,
- pkg.mVersionCode, pkgFlags, pkgPrivateFlags, user, add, true /* allowInstall */);
+ pkg.mVersionCode, pkgFlags, pkgPrivateFlags, user, add, true /* allowInstall */,
+ parentPackageName, childPackageNames);
return p;
}
return mSharedUsers.values();
}
-
- boolean disableSystemPackageLPw(String name) {
+ boolean disableSystemPackageLPw(String name, boolean replaced) {
final PackageSetting p = mPackages.get(name);
if(p == null) {
Log.w(PackageManagerService.TAG, "Package " + name + " is not an installed package");
}
final PackageSetting dp = mDisabledSysPackages.get(name);
// always make sure the system package code and resource paths dont change
- if (dp == null) {
+ if (dp == null && p.pkg != null && p.pkg.isSystemApp() && !p.pkg.isUpdatedSystemApp()) {
if((p.pkg != null) && (p.pkg.applicationInfo != null)) {
p.pkg.applicationInfo.flags |= ApplicationInfo.FLAG_UPDATED_SYSTEM_APP;
}
mDisabledSysPackages.put(name, p);
- // a little trick... when we install the new package, we don't
- // want to modify the existing PackageSetting for the built-in
- // version. so at this point we need a new PackageSetting that
- // is okay to muck with.
- PackageSetting newp = new PackageSetting(p);
- replacePackageLPw(name, newp);
+ if (replaced) {
+ // a little trick... when we install the new package, we don't
+ // want to modify the existing PackageSetting for the built-in
+ // version. so at this point we need a new PackageSetting that
+ // is okay to muck with.
+ PackageSetting newp = new PackageSetting(p);
+ replacePackageLPw(name, newp);
+ } else {
+ mPackages.remove(name);
+ }
return true;
}
return false;
PackageSetting ret = addPackageLPw(name, p.realName, p.codePath, p.resourcePath,
p.legacyNativeLibraryPathString, p.primaryCpuAbiString,
p.secondaryCpuAbiString, p.secondaryCpuAbiString,
- p.appId, p.versionCode, p.pkgFlags, p.pkgPrivateFlags);
+ p.appId, p.versionCode, p.pkgFlags, p.pkgPrivateFlags,
+ p.parentPackageName, p.childPackageNames);
mDisabledSysPackages.remove(name);
return ret;
}
PackageSetting addPackageLPw(String name, String realName, File codePath, File resourcePath,
String legacyNativeLibraryPathString, String primaryCpuAbiString, String secondaryCpuAbiString,
- String cpuAbiOverrideString, int uid, int vc, int pkgFlags, int pkgPrivateFlags) {
+ String cpuAbiOverrideString, int uid, int vc, int pkgFlags, int pkgPrivateFlags,
+ String parentPackageName, List<String> childPackageNames) {
PackageSetting p = mPackages.get(name);
if (p != null) {
if (p.appId == uid) {
}
p = new PackageSetting(name, realName, codePath, resourcePath,
legacyNativeLibraryPathString, primaryCpuAbiString, secondaryCpuAbiString,
- cpuAbiOverrideString, vc, pkgFlags, pkgPrivateFlags);
+ cpuAbiOverrideString, vc, pkgFlags, pkgPrivateFlags, parentPackageName,
+ childPackageNames);
p.appId = uid;
if (addUserIdLPw(uid, p, name)) {
mPackages.put(name, p);
String realName, SharedUserSetting sharedUser, File codePath, File resourcePath,
String legacyNativeLibraryPathString, String primaryCpuAbiString,
String secondaryCpuAbiString, int vc, int pkgFlags, int pkgPrivateFlags,
- UserHandle installUser, boolean add, boolean allowInstall) {
+ UserHandle installUser, boolean add, boolean allowInstall, String parentPackage,
+ List<String> childPackageNames) {
PackageSetting p = mPackages.get(name);
UserManagerService userManager = UserManagerService.getInstance();
if (p != null) {
// We are consuming the data from an existing package.
p = new PackageSetting(origPackage.name, name, codePath, resourcePath,
legacyNativeLibraryPathString, primaryCpuAbiString, secondaryCpuAbiString,
- null /* cpuAbiOverrideString */, vc, pkgFlags, pkgPrivateFlags);
+ null /* cpuAbiOverrideString */, vc, pkgFlags, pkgPrivateFlags,
+ parentPackage, childPackageNames);
if (PackageManagerService.DEBUG_UPGRADE) Log.v(PackageManagerService.TAG, "Package "
+ name + " is adopting original package " + origPackage.name);
// Note that we will retain the new package's signature so
} else {
p = new PackageSetting(name, realName, codePath, resourcePath,
legacyNativeLibraryPathString, primaryCpuAbiString, secondaryCpuAbiString,
- null /* cpuAbiOverrideString */, vc, pkgFlags, pkgPrivateFlags);
+ null /* cpuAbiOverrideString */, vc, pkgFlags, pkgPrivateFlags,
+ parentPackage, childPackageNames);
p.setTimeStamp(codePath.lastModified());
p.sharedUser = sharedUser;
// If this is not a system app, it starts out stopped.
serializer.endTag(null, TAG_PERMISSIONS);
}
+ void writeChildPackagesLPw(XmlSerializer serializer, List<String> childPackageNames)
+ throws IOException {
+ if (childPackageNames == null) {
+ return;
+ }
+ final int childCount = childPackageNames.size();
+ for (int i = 0; i < childCount; i++) {
+ String childPackageName = childPackageNames.get(i);
+ serializer.startTag(null, TAG_CHILD_PACKAGE);
+ serializer.attribute(null, ATTR_NAME, childPackageName);
+ serializer.endTag(null, TAG_CHILD_PACKAGE);
+ }
+ }
+
// Note: assumed "stopped" field is already cleared in all packages.
// Legacy reader, used to read in the old file format after an upgrade. Not used after that.
void readStoppedLPw() {
serializer.attribute(null, "sharedUserId", Integer.toString(pkg.appId));
}
+ if (pkg.parentPackageName != null) {
+ serializer.attribute(null, "parentPackageName", pkg.parentPackageName);
+ }
+
+ writeChildPackagesLPw(serializer, pkg.childPackageNames);
+
// If this is a shared user, the permissions will be written there.
if (pkg.sharedUser == null) {
writePermissionsLPr(serializer, pkg.getPermissionsState()
if (pkg.volumeUuid != null) {
serializer.attribute(null, "volumeUuid", pkg.volumeUuid);
}
+
+ if (pkg.parentPackageName != null) {
+ serializer.attribute(null, "parentPackageName", pkg.parentPackageName);
+ }
+
+ writeChildPackagesLPw(serializer, pkg.childPackageNames);
+
pkg.signatures.writeXml(serializer, "sigs", mPastSignatures);
writePermissionsLPr(serializer, pkg.getPermissionsState()
(SharedUserSetting) idObj, pp.codePath, pp.resourcePath,
pp.legacyNativeLibraryPathString, pp.primaryCpuAbiString,
pp.secondaryCpuAbiString, pp.versionCode, pp.pkgFlags, pp.pkgPrivateFlags,
- null, true /* add */, false /* allowInstall */);
+ null, true /* add */, false /* allowInstall */, pp.parentPackageName,
+ pp.childPackageNames);
if (p == null) {
PackageManagerService.reportSettingsProblem(Log.WARN,
"Unable to create application package for " + pp.name);
String legacyCpuAbiStr = parser.getAttributeValue(null, "requiredCpuAbi");
String legacyNativeLibraryPathStr = parser.getAttributeValue(null, "nativeLibraryPath");
+ String parentPackageName = parser.getAttributeValue(null, "parentPackageName");
+
String primaryCpuAbiStr = parser.getAttributeValue(null, "primaryCpuAbi");
String secondaryCpuAbiStr = parser.getAttributeValue(null, "secondaryCpuAbi");
String cpuAbiOverrideStr = parser.getAttributeValue(null, "cpuAbiOverride");
}
PackageSetting ps = new PackageSetting(name, realName, codePathFile,
new File(resourcePathStr), legacyNativeLibraryPathStr, primaryCpuAbiStr,
- secondaryCpuAbiStr, cpuAbiOverrideStr, versionCode, pkgFlags, pkgPrivateFlags);
+ secondaryCpuAbiStr, cpuAbiOverrideStr, versionCode, pkgFlags, pkgPrivateFlags,
+ parentPackageName, null);
String timeStampStr = parser.getAttributeValue(null, "ft");
if (timeStampStr != null) {
try {
if (parser.getName().equals(TAG_PERMISSIONS)) {
readInstallPermissionsLPr(parser, ps.getPermissionsState());
+ } else if (parser.getName().equals(TAG_CHILD_PACKAGE)) {
+ String childPackageName = parser.getAttributeValue(null, ATTR_NAME);
+ if (ps.childPackageNames == null) {
+ ps.childPackageNames = new ArrayList<>();
+ }
+ ps.childPackageNames.add(childPackageName);
} else {
PackageManagerService.reportSettingsProblem(Log.WARN,
"Unknown element under <updated-package>: " + parser.getName());
PackageSettingBase packageSetting = null;
String version = null;
int versionCode = 0;
+ String parentPackageName;
try {
name = parser.getAttributeValue(null, ATTR_NAME);
realName = parser.getAttributeValue(null, "realName");
legacyCpuAbiString = parser.getAttributeValue(null, "requiredCpuAbi");
+ parentPackageName = parser.getAttributeValue(null, "parentPackageName");
+
legacyNativeLibraryPathStr = parser.getAttributeValue(null, "nativeLibraryPath");
primaryCpuAbiString = parser.getAttributeValue(null, "primaryCpuAbi");
secondaryCpuAbiString = parser.getAttributeValue(null, "secondaryCpuAbi");
packageSetting = addPackageLPw(name.intern(), realName, new File(codePathStr),
new File(resourcePathStr), legacyNativeLibraryPathStr, primaryCpuAbiString,
secondaryCpuAbiString, cpuAbiOverrideString, userId, versionCode, pkgFlags,
- pkgPrivateFlags);
+ pkgPrivateFlags, parentPackageName, null);
if (PackageManagerService.DEBUG_SETTINGS)
Log.i(PackageManagerService.TAG, "Reading package " + name + ": userId="
+ userId + " pkg=" + packageSetting);
packageSetting = new PendingPackage(name.intern(), realName, new File(
codePathStr), new File(resourcePathStr), legacyNativeLibraryPathStr,
primaryCpuAbiString, secondaryCpuAbiString, cpuAbiOverrideString,
- userId, versionCode, pkgFlags, pkgPrivateFlags);
+ userId, versionCode, pkgFlags, pkgPrivateFlags, parentPackageName,
+ null);
packageSetting.setTimeStamp(timeStamp);
packageSetting.firstInstallTime = firstInstallTime;
packageSetting.lastUpdateTime = lastUpdateTime;
packageSetting.installStatus = PackageSettingBase.PKG_INSTALL_COMPLETE;
}
}
+
int outerDepth = parser.getDepth();
int type;
while ((type = parser.next()) != XmlPullParser.END_DOCUMENT
packageSetting.keySetData.addDefinedKeySet(id, alias);
} else if (tagName.equals(TAG_DOMAIN_VERIFICATION)) {
readDomainVerificationLPw(parser, packageSetting);
+ } else if (tagName.equals(TAG_CHILD_PACKAGE)) {
+ String childPackageName = parser.getAttributeValue(null, ATTR_NAME);
+ if (packageSetting.childPackageNames == null) {
+ packageSetting.childPackageNames = new ArrayList<>();
+ }
+ packageSetting.childPackageNames.add(childPackageName);
} else {
PackageManagerService.reportSettingsProblem(Log.WARN,
"Unknown element under <package>: " + parser.getName());
return mVerifierDeviceIdentity;
}
+ public boolean hasOtherDisabledSystemPkgWithChildLPr(String parentPackageName,
+ String childPackageName) {
+ final int packageCount = mDisabledSysPackages.size();
+ for (int i = 0; i < packageCount; i++) {
+ PackageSetting disabledPs = mDisabledSysPackages.valueAt(i);
+ if (disabledPs.childPackageNames == null || disabledPs.childPackageNames.isEmpty()) {
+ continue;
+ }
+ if (disabledPs.name.equals(parentPackageName)) {
+ continue;
+ }
+ final int childCount = disabledPs.childPackageNames.size();
+ for (int j = 0; j < childCount; j++) {
+ String currChildPackageName = disabledPs.childPackageNames.get(j);
+ if (currChildPackageName.equals(childPackageName)) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
public PackageSetting getDisabledSystemPkgLPr(String name) {
PackageSetting ps = mDisabledSysPackages.get(name);
return ps;
}
pw.println();
if (ps.pkg != null) {
+ if (ps.pkg.parentPackage != null) {
+ PackageParser.Package parentPkg = ps.pkg.parentPackage;
+ PackageSetting pps = mPackages.get(parentPkg.packageName);
+ if (pps == null || !pps.codePathString.equals(parentPkg.codePath)) {
+ pps = mDisabledSysPackages.get(parentPkg.packageName);
+ }
+ if (pps != null) {
+ pw.print(prefix); pw.print(" parentPackage=");
+ pw.println(pps.realName != null ? pps.realName : pps.name);
+ }
+ } else if (ps.pkg.childPackages != null) {
+ pw.print(prefix); pw.print(" childPackages=[");
+ final int childCount = ps.pkg.childPackages.size();
+ for (int i = 0; i < childCount; i++) {
+ PackageParser.Package childPkg = ps.pkg.childPackages.get(i);
+ PackageSetting cps = mPackages.get(childPkg.packageName);
+ if (cps == null || !cps.codePathString.equals(childPkg.codePath)) {
+ cps = mDisabledSysPackages.get(childPkg.packageName);
+ }
+ if (cps != null) {
+ if (i > 0) {
+ pw.print(", ");
+ }
+ pw.print(cps.realName != null ? cps.realName : cps.name);
+ }
+ }
+ pw.println("]");
+ }
pw.print(prefix); pw.print(" versionName="); pw.println(ps.pkg.mVersionName);
pw.print(prefix); pw.print(" splits="); dumpSplitNames(pw, ps.pkg); pw.println();
pw.print(prefix); pw.print(" applicationInfo=");