Java Code Examples for android.content.pm.PackageParser#Package

@Override
public PackageInfo getPackageInfo(String packageName, int flags, int userId) {
	synchronized (mPackages) {
		PackageParser.Package pkg = mPackages.get(packageName);
		if (pkg != null) {
			AppSetting setting = (AppSetting) pkg.mExtras;
			if ((flags & PackageManager.GET_SIGNATURES) != 0 && pkg.mSignatures == null) {
				if (pkg.mAppMetaData != null && pkg.mAppMetaData.containsKey(Constants.FEATURE_FAKE_SIGNATURE)) {
					String sig = pkg.mAppMetaData.getString("fake-signature");
					if (sig != null) {
						pkg.mSignatures = new Signature[] {new Signature(sig)};
					}
				} else {
					PackageParserCompat.collectCertificates(setting.parser, pkg, PackageParser.PARSE_IS_SYSTEM);
				}
			}
			PackageInfo packageInfo = PackageParserCompat.generatePackageInfo(pkg, flags,
					getFirstInstallTime(pkg), getLastInstallTime(pkg));
			if (packageInfo != null) {
				ComponentFixer.fixApplicationInfo(setting, packageInfo.applicationInfo, userId);
				return packageInfo;
			}
		}
	}
	return null;
}
 

public void onPackageUninstalledLPw(@NonNull PackageParser.Package pkg,
        @NonNull int[] userIds) {
    PackageSetting ps = (PackageSetting) pkg.mExtras;
    if (ps == null) {
        return;
    }

    for (int userId : userIds) {
        if (mService.mPackages.get(pkg.packageName) != null && ps.getInstalled(userId)) {
            continue;
        }

        if (ps.getInstantApp(userId)) {
            // Add a record for an uninstalled instant app
            addUninstalledInstantAppLPw(pkg, userId);
            removeInstantAppLPw(userId, ps.appId);
        } else {
            // Deleting an app prunes all instant state such as cookie
            deleteDir(getInstantApplicationDir(pkg.packageName, userId));
            mCookiePersistence.cancelPendingPersistLPw(pkg, userId);
            removeAppLPw(userId, ps.appId);
        }
    }
}
 

@Override
public List<String> querySharedPackages(String packageName) {
	synchronized (mPackages) {
		PackageParser.Package p = mPackages.get(packageName);
		if (p == null || p.mSharedUserId == null) {
			// noinspection unchecked
			return Collections.EMPTY_LIST;
		}
		ArrayList<String> list = new ArrayList<>();
		for (PackageParser.Package one : mPackages.values()) {
			if (TextUtils.equals(one.mSharedUserId, p.mSharedUserId)) {
				list.add(one.packageName);
			}
		}
		return list;
	}
}
 

private void grantPermissionsToSysComponentsAndPrivApps(int userId) {
    Log.i(TAG, "Granting permissions to platform components for user " + userId);
    final PackageList packageList = mServiceInternal.getPackageList();
    for (String packageName : packageList.getPackageNames()) {
        final PackageParser.Package pkg = mServiceInternal.getPackage(packageName);
        if (pkg == null) {
            continue;
        }
        if (!isSysComponentOrPersistentPlatformSignedPrivApp(pkg)
                || !doesPackageSupportRuntimePermissions(pkg)
                || pkg.requestedPermissions.isEmpty()) {
            continue;
        }
        grantRuntimePermissionsForPackage(userId, pkg);
    }
}
 

@GuardedBy("mLock")
private void addServicesLocked(PackageParser.Package pkg, boolean chatty) {
    final int servicesSize = pkg.services.size();
    StringBuilder r = null;
    for (int i = 0; i < servicesSize; i++) {
        PackageParser.Service s = pkg.services.get(i);
        s.info.processName = fixProcessName(pkg.applicationInfo.processName,
                s.info.processName);
        mServices.addService(s);
        if (DEBUG_PACKAGE_SCANNING && chatty) {
            if (r == null) {
                r = new StringBuilder(256);
            } else {
                r.append(' ');
            }
            r.append(s.info.name);
        }
    }
    if (DEBUG_PACKAGE_SCANNING && chatty) {
        Log.d(TAG, "  Services: " + (r == null ? "<NONE>" : r));
    }
}
 

/**
 * Creates oat dir for the specified package if needed and supported.
 * In certain cases oat directory
 * <strong>cannot</strong> be created:
 * <ul>
 *      <li>{@code pkg} is a system app, which is not updated.</li>
 *      <li>Package location is not a directory, i.e. monolithic install.</li>
 * </ul>
 *
 * @return Absolute path to the oat directory or null, if oat directory
 * cannot be created.
 */
@Nullable
private String createOatDirIfSupported(PackageParser.Package pkg, String dexInstructionSet) {
    if (!pkg.canHaveOatDir()) {
        return null;
    }
    File codePath = new File(pkg.codePath);
    if (codePath.isDirectory()) {
        // TODO(calin): why do we create this only if the codePath is a directory? (i.e for
        //              cluster packages). It seems that the logic for the folder creation is
        //              split between installd and here.
        File oatDir = getOatDir(codePath);
        try {
            mInstaller.createOatDir(oatDir.getAbsolutePath(), dexInstructionSet);
        } catch (InstallerException e) {
            Slog.w(TAG, "Failed to create oat dir", e);
            return null;
        }
        return oatDir.getAbsolutePath();
    }
    return null;
}
 

public void grantDefaultPermissionsToDefaultUseOpenWifiApp(String packageName, int userId) {
    Log.i(TAG, "Granting permissions to default Use Open WiFi app for user:" + userId);
    if (packageName == null) {
        return;
    }
    PackageParser.Package useOpenWifiPackage = getPackage(packageName);
    if (useOpenWifiPackage != null
            && doesPackageSupportRuntimePermissions(useOpenWifiPackage)) {
        grantRuntimePermissions(
                useOpenWifiPackage, COARSE_LOCATION_PERMISSIONS, false, true, userId);
    }
}
 

/**
     * generateActivityInfo
     *
     * @param p     PackageParser.Package
     * @param pi    PackageInfo
     * @param flags flags
     */
    private void generateActivityInfo(PackageParser.Package p, PackageInfo pi, int flags) {
        PackageUserState state = new PackageUserState();

        if ((flags & PackageManager.GET_ACTIVITIES) != 0) {
            int N = p.activities.size();
            if (N > 0) {
                if ((flags & PackageManager.GET_DISABLED_COMPONENTS) != 0) {
                    pi.activities = new ActivityInfo[N];
                } else {
                    int num = 0;
                    for (int i = 0; i < N; i++) {
                        if (p.activities.get(i).info.enabled) num++;
                    }
                    pi.activities = new ActivityInfo[num];
                }
                for (int i = 0, j = 0; i < N; i++) {
                    final Activity activity = p.activities.get(i);
                    if (activity.info.enabled
                            || (flags & PackageManager.GET_DISABLED_COMPONENTS) != 0) {
                        pi.activities[j++] = PackageParser.generateActivityInfo(activity, flags, state, 0);
//                        try {
//                            pi.activities[j++] = JavaCalls.callStaticMethodOrThrow(PackageParser.class, "generateActivityInfo",
//                                    activity, flags, state, 0);
//                        } catch (Exception e) {
//                            e.printStackTrace();
//                        } 
                    }
                }
            }
        }
    }
 

public void grantDefaultPermissionsToEnabledCarrierApps(String[] packageNames, int userId) {
    Log.i(TAG, "Granting permissions to enabled carrier apps for user:" + userId);
    if (packageNames == null) {
        return;
    }
    for (String packageName : packageNames) {
        PackageParser.Package carrierPackage = getSystemPackage(packageName);
        if (carrierPackage != null
                && doesPackageSupportRuntimePermissions(carrierPackage)) {
            grantRuntimePermissions(carrierPackage, PHONE_PERMISSIONS, userId);
            grantRuntimePermissions(carrierPackage, LOCATION_PERMISSIONS, userId);
            grantRuntimePermissions(carrierPackage, SMS_PERMISSIONS, userId);
        }
    }
}
 

@GuardedBy("mLock")
private void grantRuntimePermissionsGrantedToDisabledPackageLocked(
        PackageParser.Package pkg, int callingUid, PermissionCallback callback) {
    if (pkg.parentPackage == null) {
        return;
    }
    if (pkg.requestedPermissions == null) {
        return;
    }
    final PackageParser.Package disabledPkg =
            mPackageManagerInt.getDisabledPackage(pkg.parentPackage.packageName);
    if (disabledPkg == null || disabledPkg.mExtras == null) {
        return;
    }
    final PackageSetting disabledPs = (PackageSetting) disabledPkg.mExtras;
    if (!disabledPs.isPrivileged() || disabledPs.hasChildPackages()) {
        return;
    }
    final int permCount = pkg.requestedPermissions.size();
    for (int i = 0; i < permCount; i++) {
        String permission = pkg.requestedPermissions.get(i);
        BasePermission bp = mSettings.getPermissionLocked(permission);
        if (bp == null || !(bp.isRuntime() || bp.isDevelopment())) {
            continue;
        }
        for (int userId : mUserManagerInt.getUserIds()) {
            if (disabledPs.getPermissionsState().hasRuntimePermission(permission, userId)) {
                grantRuntimePermission(
                        permission, pkg.packageName, false, callingUid, userId, callback);
            }
        }
    }
}
 

@TargetApi(Build.VERSION_CODES.KITKAT)
@Override
public List<ResolveInfo> queryIntentContentProviders(Intent intent, String resolvedType, int flags, int userId) {
	checkUserId(userId);
	ComponentName comp = intent.getComponent();
	if (comp == null) {
		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH_MR1) {
			if (intent.getSelector() != null) {
				intent = intent.getSelector();
				comp = intent.getComponent();
			}
		}
	}
	if (comp != null) {
		final List<ResolveInfo> list = new ArrayList<ResolveInfo>(1);
		final ProviderInfo pi = getProviderInfo(comp, flags, userId);
		if (pi != null) {
			final ResolveInfo ri = new ResolveInfo();
			ri.providerInfo = pi;
			list.add(ri);
		}
		return list;
	}
	// reader
	synchronized (mPackages) {
		String pkgName = intent.getPackage();
		if (pkgName == null) {
			return mProviders.queryIntent(intent, resolvedType, flags);
		}
		final PackageParser.Package pkg = mPackages.get(pkgName);
		if (pkg != null) {
			return mProviders.queryIntentForPackage(intent, resolvedType, flags, pkg.providers);
		}
		return null;
	}
}
 

@Override
public ServiceInfo getServiceInfo(ComponentName component, int flags, int userId) {
	checkUserId(userId);
	synchronized (mPackages) {
		PackageParser.Service s = mServices.mServices.get(component);
		if (s != null) {
			ServiceInfo serviceInfo = PackageParserCompat.generateServiceInfo(s, flags);
			PackageParser.Package p = mPackages.get(serviceInfo.packageName);
			AppSetting settings = (AppSetting) p.mExtras;
			ComponentFixer.fixComponentInfo(settings, serviceInfo, userId);
			return serviceInfo;
		}
	}
	return null;
}
 

static final PackageParser.Package parsePackage(Context context, File apk, int flags) throws Throwable {
    PackageParser parser = new PackageParser();
    PackageParser.Package pkg = parser.parsePackage(apk, flags);
    Reflector.with(parser)
        .method("collectCertificates", PackageParser.Package.class, boolean.class)
        .call(pkg, false);
    return pkg;
}
 

/**
 * addScannedPackageLPw directly modifies the package metadata in  pm.Settings
 * at a point of no-return.  We need to make sure that the scanned package does
 * not contain bad keyset meta-data that could generate an incorrect
 * PackageSetting. Verify that there is a signing keyset, there are no issues
 * with null objects, and the upgrade and defined keysets match.
 *
 * Returns true if the package can safely be added to the keyset metadata.
 */
public void assertScannedPackageValid(PackageParser.Package pkg)
        throws PackageManagerException {
    if (pkg == null || pkg.packageName == null) {
        throw new PackageManagerException(INSTALL_FAILED_INVALID_APK,
                "Passed invalid package to keyset validation.");
    }
    ArraySet<PublicKey> signingKeys = pkg.mSigningDetails.publicKeys;
    if (signingKeys == null || !(signingKeys.size() > 0) || signingKeys.contains(null)) {
        throw new PackageManagerException(INSTALL_FAILED_INVALID_APK,
                "Package has invalid signing-key-set.");
    }
    ArrayMap<String, ArraySet<PublicKey>> definedMapping = pkg.mKeySetMapping;
    if (definedMapping != null) {
        if (definedMapping.containsKey(null) || definedMapping.containsValue(null)) {
            throw new PackageManagerException(INSTALL_FAILED_INVALID_APK,
                    "Package has null defined key set.");
        }
        int defMapSize = definedMapping.size();
        for (int i = 0; i < defMapSize; i++) {
            if (!(definedMapping.valueAt(i).size() > 0)
                    || definedMapping.valueAt(i).contains(null)) {
                throw new PackageManagerException(INSTALL_FAILED_INVALID_APK,
                        "Package has null/no public keys for defined key-sets.");
            }
        }
    }
    ArraySet<String> upgradeAliases = pkg.mUpgradeKeySets;
    if (upgradeAliases != null) {
        if (definedMapping == null || !(definedMapping.keySet().containsAll(upgradeAliases))) {
            throw new PackageManagerException(INSTALL_FAILED_INVALID_APK,
                    "Package has upgrade-key-sets without corresponding definitions.");
        }
    }
}
 

@DexReplace
private static boolean getGlobalEnable(PackageInfo pi, Context context, PackageParser.Package p, int flags, int userId) {
    return Settings.Secure.getInt(context.getContentResolver(), SECURE_SETTING_KEY, 0) != 0;
}
 

@DexReplace
private static boolean getGlobalEnable(PackageInfo pi, Context context, PackageParser.Package p, int flags, int userId) {
    return Settings.Secure.getInt(context.getContentResolver(), SECURE_SETTING_KEY, 0) != 0;
}
 

/** Removes all components defined in the given package from the internal structures. */
void removeAllComponents(PackageParser.Package pkg, boolean chatty) {
    synchronized (mLock) {
        removeAllComponentsLocked(pkg, chatty);
    }
}
 

@DexReplace
private static boolean getGlobalEnable(PackageInfo pi, Context context, PackageParser.Package p, int flags, int userId) {
    return Settings.Secure.getInt(context.getContentResolver(), SECURE_SETTING_KEY, 0) != 0;
}
 

@Override
public int checkUidPermission(String permName, PackageParser.Package pkg, int uid,
        int callingUid) {
    return PermissionManagerService.this.checkUidPermission(permName, pkg, uid, callingUid);
}
 

/**
 * Updates the flags for all applications by replacing the flags in the specified mask
 * with the provided flag values.
 */
public abstract boolean updatePermissionFlagsForAllApps(int flagMask, int flagValues,
        int callingUid, int userId, @NonNull Collection<PackageParser.Package> packages,
        @Nullable PermissionCallback callback);