Java程序
|
1279行
|
51.76 KB
/*
* Copyright (C) 2015 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.server.pm;
import android.annotation.NonNull;
import android.annotation.Nullable;
import android.annotation.UserIdInt;
import android.content.Intent;
import android.content.pm.InstantAppInfo;
import android.content.pm.PackageManager;
import android.content.pm.PackageParser;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.os.Binder;
import android.os.Environment;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.os.UserHandle;
import android.os.storage.StorageManager;
import android.provider.Settings;
import android.util.ArrayMap;
import android.util.AtomicFile;
import android.util.ByteStringUtils;
import android.util.PackageUtils;
import android.util.Slog;
import android.util.SparseArray;
import android.util.SparseBooleanArray;
import android.util.Xml;
import com.android.internal.annotations.GuardedBy;
import com.android.internal.os.BackgroundThread;
import com.android.internal.os.SomeArgs;
import com.android.internal.util.ArrayUtils;
import com.android.internal.util.XmlUtils;
import libcore.io.IoUtils;
import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;
import org.xmlpull.v1.XmlSerializer;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.security.SecureRandom;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import java.util.Set;
import java.util.function.Predicate;
/**
* This class is a part of the package manager service that is responsible
* for managing data associated with instant apps such as cached uninstalled
* instant apps and instant apps' cookies. In addition it is responsible for
* pruning installed instant apps and meta-data for uninstalled instant apps
* when free space is needed.
*/
class InstantAppRegistry {
private static final boolean DEBUG = false;
private static final String LOG_TAG = "InstantAppRegistry";
static final long DEFAULT_INSTALLED_INSTANT_APP_MIN_CACHE_PERIOD =
DEBUG ? 30 * 1000L /* thirty seconds */ : 7 * 24 * 60 * 60 * 1000L; /* one week */
private static final long DEFAULT_INSTALLED_INSTANT_APP_MAX_CACHE_PERIOD =
DEBUG ? 60 * 1000L /* one min */ : 6 * 30 * 24 * 60 * 60 * 1000L; /* six months */
static final long DEFAULT_UNINSTALLED_INSTANT_APP_MIN_CACHE_PERIOD =
DEBUG ? 30 * 1000L /* thirty seconds */ : 7 * 24 * 60 * 60 * 1000L; /* one week */
private static final long DEFAULT_UNINSTALLED_INSTANT_APP_MAX_CACHE_PERIOD =
DEBUG ? 60 * 1000L /* one min */ : 6 * 30 * 24 * 60 * 60 * 1000L; /* six months */
private static final String INSTANT_APPS_FOLDER = "instant";
private static final String INSTANT_APP_ICON_FILE = "icon.png";
private static final String INSTANT_APP_COOKIE_FILE_PREFIX = "cookie_";
private static final String INSTANT_APP_COOKIE_FILE_SIFFIX = ".dat";
private static final String INSTANT_APP_METADATA_FILE = "metadata.xml";
private static final String INSTANT_APP_ANDROID_ID_FILE = "android_id";
private static final String TAG_PACKAGE = "package";
private static final String TAG_PERMISSIONS = "permissions";
private static final String TAG_PERMISSION = "permission";
private static final String ATTR_LABEL = "label";
private static final String ATTR_NAME = "name";
private static final String ATTR_GRANTED = "granted";
private final PackageManagerService mService;
private final CookiePersistence mCookiePersistence;
/** State for uninstalled instant apps */
@GuardedBy("mService.mPackages")
private SparseArray<List<UninstalledInstantAppState>> mUninstalledInstantApps;
/**
* Automatic grants for access to instant app metadata.
* The key is the target application UID.
* The value is a set of instant app UIDs.
* UserID -> TargetAppId -> InstantAppId
*/
@GuardedBy("mService.mPackages")
private SparseArray<SparseArray<SparseBooleanArray>> mInstantGrants;
/** The set of all installed instant apps. UserID -> AppID */
@GuardedBy("mService.mPackages")
private SparseArray<SparseBooleanArray> mInstalledInstantAppUids;
public InstantAppRegistry(PackageManagerService service) {
mService = service;
mCookiePersistence = new CookiePersistence(BackgroundThread.getHandler().getLooper());
}
@GuardedBy("mService.mPackages")
public byte[] getInstantAppCookieLPw(@NonNull String packageName,
@UserIdInt int userId) {
// Only installed packages can get their own cookie
PackageParser.Package pkg = mService.mPackages.get(packageName);
if (pkg == null) {
return null;
}
byte[] pendingCookie = mCookiePersistence.getPendingPersistCookieLPr(pkg, userId);
if (pendingCookie != null) {
return pendingCookie;
}
File cookieFile = peekInstantCookieFile(packageName, userId);
if (cookieFile != null && cookieFile.exists()) {
try {
return IoUtils.readFileAsByteArray(cookieFile.toString());
} catch (IOException e) {
Slog.w(LOG_TAG, "Error reading cookie file: " + cookieFile);
}
}
return null;
}
@GuardedBy("mService.mPackages")
public boolean setInstantAppCookieLPw(@NonNull String packageName,
@Nullable byte[] cookie, @UserIdInt int userId) {
if (cookie != null && cookie.length > 0) {
final int maxCookieSize = mService.mContext.getPackageManager()
.getInstantAppCookieMaxBytes();
if (cookie.length > maxCookieSize) {
Slog.e(LOG_TAG, "Instant app cookie for package " + packageName + " size "
+ cookie.length + " bytes while max size is " + maxCookieSize);
return false;
}
}
// Only an installed package can set its own cookie
PackageParser.Package pkg = mService.mPackages.get(packageName);
if (pkg == null) {
return false;
}
mCookiePersistence.schedulePersistLPw(userId, pkg, cookie);
return true;
}
private void persistInstantApplicationCookie(@Nullable byte[] cookie,
@NonNull String packageName, @NonNull File cookieFile, @UserIdInt int userId) {
synchronized (mService.mPackages) {
File appDir = getInstantApplicationDir(packageName, userId);
if (!appDir.exists() && !appDir.mkdirs()) {
Slog.e(LOG_TAG, "Cannot create instant app cookie directory");
return;
}
if (cookieFile.exists() && !cookieFile.delete()) {
Slog.e(LOG_TAG, "Cannot delete instant app cookie file");
}
// No cookie or an empty one means delete - done
if (cookie == null || cookie.length <= 0) {
return;
}
}
try (FileOutputStream fos = new FileOutputStream(cookieFile)) {
fos.write(cookie, 0, cookie.length);
} catch (IOException e) {
Slog.e(LOG_TAG, "Error writing instant app cookie file: " + cookieFile, e);
}
}
public Bitmap getInstantAppIconLPw(@NonNull String packageName,
@UserIdInt int userId) {
File iconFile = new File(getInstantApplicationDir(packageName, userId),
INSTANT_APP_ICON_FILE);
if (iconFile.exists()) {
return BitmapFactory.decodeFile(iconFile.toString());
}
return null;
}
public String getInstantAppAndroidIdLPw(@NonNull String packageName,
@UserIdInt int userId) {
File idFile = new File(getInstantApplicationDir(packageName, userId),
INSTANT_APP_ANDROID_ID_FILE);
if (idFile.exists()) {
try {
return IoUtils.readFileAsString(idFile.getAbsolutePath());
} catch (IOException e) {
Slog.e(LOG_TAG, "Failed to read instant app android id file: " + idFile, e);
}
}
return generateInstantAppAndroidIdLPw(packageName, userId);
}
private String generateInstantAppAndroidIdLPw(@NonNull String packageName,
@UserIdInt int userId) {
byte[] randomBytes = new byte[8];
new SecureRandom().nextBytes(randomBytes);
String id = ByteStringUtils.toHexString(randomBytes).toLowerCase(Locale.US);
File appDir = getInstantApplicationDir(packageName, userId);
if (!appDir.exists() && !appDir.mkdirs()) {
Slog.e(LOG_TAG, "Cannot create instant app cookie directory");
return id;
}
File idFile = new File(getInstantApplicationDir(packageName, userId),
INSTANT_APP_ANDROID_ID_FILE);
try (FileOutputStream fos = new FileOutputStream(idFile)) {
fos.write(id.getBytes());
} catch (IOException e) {
Slog.e(LOG_TAG, "Error writing instant app android id file: " + idFile, e);
}
return id;
}
@GuardedBy("mService.mPackages")
public @Nullable List<InstantAppInfo> getInstantAppsLPr(@UserIdInt int userId) {
List<InstantAppInfo> installedApps = getInstalledInstantApplicationsLPr(userId);
List<InstantAppInfo> uninstalledApps = getUninstalledInstantApplicationsLPr(userId);
if (installedApps != null) {
if (uninstalledApps != null) {
installedApps.addAll(uninstalledApps);
}
return installedApps;
}
return uninstalledApps;
}
@GuardedBy("mService.mPackages")
public void onPackageInstalledLPw(@NonNull PackageParser.Package pkg, @NonNull int[] userIds) {
PackageSetting ps = (PackageSetting) pkg.mExtras;
if (ps == null) {
return;
}
for (int userId : userIds) {
// Ignore not installed apps
if (mService.mPackages.get(pkg.packageName) == null || !ps.getInstalled(userId)) {
continue;
}
// Propagate permissions before removing any state
propagateInstantAppPermissionsIfNeeded(pkg, userId);
// Track instant apps
if (ps.getInstantApp(userId)) {
addInstantAppLPw(userId, ps.appId);
}
// Remove the in-memory state
removeUninstalledInstantAppStateLPw((UninstalledInstantAppState state) ->
state.mInstantAppInfo.getPackageName().equals(pkg.packageName),
userId);
// Remove the on-disk state except the cookie
File instantAppDir = getInstantApplicationDir(pkg.packageName, userId);
new File(instantAppDir, INSTANT_APP_METADATA_FILE).delete();
new File(instantAppDir, INSTANT_APP_ICON_FILE).delete();
// If app signature changed - wipe the cookie
File currentCookieFile = peekInstantCookieFile(pkg.packageName, userId);
if (currentCookieFile == null) {
continue;
}
String cookieName = currentCookieFile.getName();
String currentCookieSha256 =
cookieName.substring(INSTANT_APP_COOKIE_FILE_PREFIX.length(),
cookieName.length() - INSTANT_APP_COOKIE_FILE_SIFFIX.length());
// Before we used only the first signature to compute the SHA 256 but some
// apps could be singed by multiple certs and the cert order is undefined.
// We prefer the modern computation procedure where all certs are taken
// into account but also allow the value from the old computation to avoid
// data loss.
if (pkg.mSigningDetails.checkCapability(currentCookieSha256,
PackageParser.SigningDetails.CertCapabilities.INSTALLED_DATA)) {
return;
}
// For backwards compatibility we accept match based on any signature, since we may have
// recorded only the first for multiply-signed packages
final String[] signaturesSha256Digests =
PackageUtils.computeSignaturesSha256Digests(pkg.mSigningDetails.signatures);
for (String s : signaturesSha256Digests) {
if (s.equals(currentCookieSha256)) {
return;
}
}
// Sorry, you are out of luck - different signatures - nuke data
Slog.i(LOG_TAG, "Signature for package " + pkg.packageName
+ " changed - dropping cookie");
// Make sure a pending write for the old signed app is cancelled
mCookiePersistence.cancelPendingPersistLPw(pkg, userId);
currentCookieFile.delete();
}
}
@GuardedBy("mService.mPackages")
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);
}
}
}
@GuardedBy("mService.mPackages")
public void onUserRemovedLPw(int userId) {
if (mUninstalledInstantApps != null) {
mUninstalledInstantApps.remove(userId);
if (mUninstalledInstantApps.size() <= 0) {
mUninstalledInstantApps = null;
}
}
if (mInstalledInstantAppUids != null) {
mInstalledInstantAppUids.remove(userId);
if (mInstalledInstantAppUids.size() <= 0) {
mInstalledInstantAppUids = null;
}
}
if (mInstantGrants != null) {
mInstantGrants.remove(userId);
if (mInstantGrants.size() <= 0) {
mInstantGrants = null;
}
}
deleteDir(getInstantApplicationsDir(userId));
}
public boolean isInstantAccessGranted(@UserIdInt int userId, int targetAppId,
int instantAppId) {
if (mInstantGrants == null) {
return false;
}
final SparseArray<SparseBooleanArray> targetAppList = mInstantGrants.get(userId);
if (targetAppList == null) {
return false;
}
final SparseBooleanArray instantGrantList = targetAppList.get(targetAppId);
if (instantGrantList == null) {
return false;
}
return instantGrantList.get(instantAppId);
}
@GuardedBy("mService.mPackages")
public void grantInstantAccessLPw(@UserIdInt int userId, @Nullable Intent intent,
int targetAppId, int instantAppId) {
if (mInstalledInstantAppUids == null) {
return; // no instant apps installed; no need to grant
}
SparseBooleanArray instantAppList = mInstalledInstantAppUids.get(userId);
if (instantAppList == null || !instantAppList.get(instantAppId)) {
return; // instant app id isn't installed; no need to grant
}
if (instantAppList.get(targetAppId)) {
return; // target app id is an instant app; no need to grant
}
if (intent != null && Intent.ACTION_VIEW.equals(intent.getAction())) {
final Set<String> categories = intent.getCategories();
if (categories != null && categories.contains(Intent.CATEGORY_BROWSABLE)) {
return; // launched via VIEW/BROWSABLE intent; no need to grant
}
}
if (mInstantGrants == null) {
mInstantGrants = new SparseArray<>();
}
SparseArray<SparseBooleanArray> targetAppList = mInstantGrants.get(userId);
if (targetAppList == null) {
targetAppList = new SparseArray<>();
mInstantGrants.put(userId, targetAppList);
}
SparseBooleanArray instantGrantList = targetAppList.get(targetAppId);
if (instantGrantList == null) {
instantGrantList = new SparseBooleanArray();
targetAppList.put(targetAppId, instantGrantList);
}
instantGrantList.put(instantAppId, true /*granted*/);
}
@GuardedBy("mService.mPackages")
public void addInstantAppLPw(@UserIdInt int userId, int instantAppId) {
if (mInstalledInstantAppUids == null) {
mInstalledInstantAppUids = new SparseArray<>();
}
SparseBooleanArray instantAppList = mInstalledInstantAppUids.get(userId);
if (instantAppList == null) {
instantAppList = new SparseBooleanArray();
mInstalledInstantAppUids.put(userId, instantAppList);
}
instantAppList.put(instantAppId, true /*installed*/);
}
@GuardedBy("mService.mPackages")
private void removeInstantAppLPw(@UserIdInt int userId, int instantAppId) {
// remove from the installed list
if (mInstalledInstantAppUids == null) {
return; // no instant apps on the system
}
final SparseBooleanArray instantAppList = mInstalledInstantAppUids.get(userId);
if (instantAppList == null) {
return;
}
instantAppList.delete(instantAppId);
// remove any grants
if (mInstantGrants == null) {
return; // no grants on the system
}
final SparseArray<SparseBooleanArray> targetAppList = mInstantGrants.get(userId);
if (targetAppList == null) {
return; // no grants for this user
}
for (int i = targetAppList.size() - 1; i >= 0; --i) {
targetAppList.valueAt(i).delete(instantAppId);
}
}
@GuardedBy("mService.mPackages")
private void removeAppLPw(@UserIdInt int userId, int targetAppId) {
// remove from the installed list
if (mInstantGrants == null) {
return; // no grants on the system
}
final SparseArray<SparseBooleanArray> targetAppList = mInstantGrants.get(userId);
if (targetAppList == null) {
return; // no grants for this user
}
targetAppList.delete(targetAppId);
}
@GuardedBy("mService.mPackages")
private void addUninstalledInstantAppLPw(@NonNull PackageParser.Package pkg,
@UserIdInt int userId) {
InstantAppInfo uninstalledApp = createInstantAppInfoForPackage(
pkg, userId, false);
if (uninstalledApp == null) {
return;
}
if (mUninstalledInstantApps == null) {
mUninstalledInstantApps = new SparseArray<>();
}
List<UninstalledInstantAppState> uninstalledAppStates =
mUninstalledInstantApps.get(userId);
if (uninstalledAppStates == null) {
uninstalledAppStates = new ArrayList<>();
mUninstalledInstantApps.put(userId, uninstalledAppStates);
}
UninstalledInstantAppState uninstalledAppState = new UninstalledInstantAppState(
uninstalledApp, System.currentTimeMillis());
uninstalledAppStates.add(uninstalledAppState);
writeUninstalledInstantAppMetadata(uninstalledApp, userId);
writeInstantApplicationIconLPw(pkg, userId);
}
private void writeInstantApplicationIconLPw(@NonNull PackageParser.Package pkg,
@UserIdInt int userId) {
File appDir = getInstantApplicationDir(pkg.packageName, userId);
if (!appDir.exists()) {
return;
}
Drawable icon = pkg.applicationInfo.loadIcon(mService.mContext.getPackageManager());
final Bitmap bitmap;
if (icon instanceof BitmapDrawable) {
bitmap = ((BitmapDrawable) icon).getBitmap();
} else {
bitmap = Bitmap.createBitmap(icon.getIntrinsicWidth(),
icon.getIntrinsicHeight(), Bitmap.Config.ARGB_8888);
Canvas canvas = new Canvas(bitmap);
icon.setBounds(0, 0, icon.getIntrinsicWidth(), icon.getIntrinsicHeight());
icon.draw(canvas);
}
File iconFile = new File(getInstantApplicationDir(pkg.packageName, userId),
INSTANT_APP_ICON_FILE);
try (FileOutputStream out = new FileOutputStream(iconFile)) {
bitmap.compress(Bitmap.CompressFormat.PNG, 100, out);
} catch (Exception e) {
Slog.e(LOG_TAG, "Error writing instant app icon", e);
}
}
@GuardedBy("mService.mPackages")
boolean hasInstantApplicationMetadataLPr(String packageName, int userId) {
return hasUninstalledInstantAppStateLPr(packageName, userId)
|| hasInstantAppMetadataLPr(packageName, userId);
}
@GuardedBy("mService.mPackages")
public void deleteInstantApplicationMetadataLPw(@NonNull String packageName,
@UserIdInt int userId) {
removeUninstalledInstantAppStateLPw((UninstalledInstantAppState state) ->
state.mInstantAppInfo.getPackageName().equals(packageName),
userId);
File instantAppDir = getInstantApplicationDir(packageName, userId);
new File(instantAppDir, INSTANT_APP_METADATA_FILE).delete();
new File(instantAppDir, INSTANT_APP_ICON_FILE).delete();
new File(instantAppDir, INSTANT_APP_ANDROID_ID_FILE).delete();
File cookie = peekInstantCookieFile(packageName, userId);
if (cookie != null) {
cookie.delete();
}
}
@GuardedBy("mService.mPackages")
private void removeUninstalledInstantAppStateLPw(
@NonNull Predicate<UninstalledInstantAppState> criteria, @UserIdInt int userId) {
if (mUninstalledInstantApps == null) {
return;
}
List<UninstalledInstantAppState> uninstalledAppStates =
mUninstalledInstantApps.get(userId);
if (uninstalledAppStates == null) {
return;
}
final int appCount = uninstalledAppStates.size();
for (int i = appCount - 1; i >= 0; --i) {
UninstalledInstantAppState uninstalledAppState = uninstalledAppStates.get(i);
if (!criteria.test(uninstalledAppState)) {
continue;
}
uninstalledAppStates.remove(i);
if (uninstalledAppStates.isEmpty()) {
mUninstalledInstantApps.remove(userId);
if (mUninstalledInstantApps.size() <= 0) {
mUninstalledInstantApps = null;
}
return;
}
}
}
@GuardedBy("mService.mPackages")
private boolean hasUninstalledInstantAppStateLPr(String packageName, @UserIdInt int userId) {
if (mUninstalledInstantApps == null) {
return false;
}
final List<UninstalledInstantAppState> uninstalledAppStates =
mUninstalledInstantApps.get(userId);
if (uninstalledAppStates == null) {
return false;
}
final int appCount = uninstalledAppStates.size();
for (int i = 0; i < appCount; i++) {
final UninstalledInstantAppState uninstalledAppState = uninstalledAppStates.get(i);
if (packageName.equals(uninstalledAppState.mInstantAppInfo.getPackageName())) {
return true;
}
}
return false;
}
private boolean hasInstantAppMetadataLPr(String packageName, @UserIdInt int userId) {
final File instantAppDir = getInstantApplicationDir(packageName, userId);
return new File(instantAppDir, INSTANT_APP_METADATA_FILE).exists()
|| new File(instantAppDir, INSTANT_APP_ICON_FILE).exists()
|| new File(instantAppDir, INSTANT_APP_ANDROID_ID_FILE).exists()
|| peekInstantCookieFile(packageName, userId) != null;
}
void pruneInstantApps() {
final long maxInstalledCacheDuration = Settings.Global.getLong(
mService.mContext.getContentResolver(),
Settings.Global.INSTALLED_INSTANT_APP_MAX_CACHE_PERIOD,
DEFAULT_INSTALLED_INSTANT_APP_MAX_CACHE_PERIOD);
final long maxUninstalledCacheDuration = Settings.Global.getLong(
mService.mContext.getContentResolver(),
Settings.Global.UNINSTALLED_INSTANT_APP_MAX_CACHE_PERIOD,
DEFAULT_UNINSTALLED_INSTANT_APP_MAX_CACHE_PERIOD);
try {
pruneInstantApps(Long.MAX_VALUE,
maxInstalledCacheDuration, maxUninstalledCacheDuration);
} catch (IOException e) {
Slog.e(LOG_TAG, "Error pruning installed and uninstalled instant apps", e);
}
}
boolean pruneInstalledInstantApps(long neededSpace, long maxInstalledCacheDuration) {
try {
return pruneInstantApps(neededSpace, maxInstalledCacheDuration, Long.MAX_VALUE);
} catch (IOException e) {
Slog.e(LOG_TAG, "Error pruning installed instant apps", e);
return false;
}
}
boolean pruneUninstalledInstantApps(long neededSpace, long maxUninstalledCacheDuration) {
try {
return pruneInstantApps(neededSpace, Long.MAX_VALUE, maxUninstalledCacheDuration);
} catch (IOException e) {
Slog.e(LOG_TAG, "Error pruning uninstalled instant apps", e);
return false;
}
}
/**
* Prunes instant apps until there is enough <code>neededSpace</code>. Both
* installed and uninstalled instant apps are pruned that are older than
* <code>maxInstalledCacheDuration</code> and <code>maxUninstalledCacheDuration</code>
* respectively. All times are in milliseconds.
*
* @param neededSpace The space to ensure is free.
* @param maxInstalledCacheDuration The max duration for caching installed apps in millis.
* @param maxUninstalledCacheDuration The max duration for caching uninstalled apps in millis.
* @return Whether enough space was freed.
*
* @throws IOException
*/
private boolean pruneInstantApps(long neededSpace, long maxInstalledCacheDuration,
long maxUninstalledCacheDuration) throws IOException {
final StorageManager storage = mService.mContext.getSystemService(StorageManager.class);
final File file = storage.findPathForUuid(StorageManager.UUID_PRIVATE_INTERNAL);
if (file.getUsableSpace() >= neededSpace) {
return true;
}
List<String> packagesToDelete = null;
final int[] allUsers;
final long now = System.currentTimeMillis();
// Prune first installed instant apps
synchronized (mService.mPackages) {
allUsers = PackageManagerService.sUserManager.getUserIds();
final int packageCount = mService.mPackages.size();
for (int i = 0; i < packageCount; i++) {
final PackageParser.Package pkg = mService.mPackages.valueAt(i);
if (now - pkg.getLatestPackageUseTimeInMills() < maxInstalledCacheDuration) {
continue;
}
if (!(pkg.mExtras instanceof PackageSetting)) {
continue;
}
final PackageSetting ps = (PackageSetting) pkg.mExtras;
boolean installedOnlyAsInstantApp = false;
for (int userId : allUsers) {
if (ps.getInstalled(userId)) {
if (ps.getInstantApp(userId)) {
installedOnlyAsInstantApp = true;
} else {
installedOnlyAsInstantApp = false;
break;
}
}
}
if (installedOnlyAsInstantApp) {
if (packagesToDelete == null) {
packagesToDelete = new ArrayList<>();
}
packagesToDelete.add(pkg.packageName);
}
}
if (packagesToDelete != null) {
packagesToDelete.sort((String lhs, String rhs) -> {
final PackageParser.Package lhsPkg = mService.mPackages.get(lhs);
final PackageParser.Package rhsPkg = mService.mPackages.get(rhs);
if (lhsPkg == null && rhsPkg == null) {
return 0;
} else if (lhsPkg == null) {
return -1;
} else if (rhsPkg == null) {
return 1;
} else {
if (lhsPkg.getLatestPackageUseTimeInMills() >
rhsPkg.getLatestPackageUseTimeInMills()) {
return 1;
} else if (lhsPkg.getLatestPackageUseTimeInMills() <
rhsPkg.getLatestPackageUseTimeInMills()) {
return -1;
} else {
if (lhsPkg.mExtras instanceof PackageSetting
&& rhsPkg.mExtras instanceof PackageSetting) {
final PackageSetting lhsPs = (PackageSetting) lhsPkg.mExtras;
final PackageSetting rhsPs = (PackageSetting) rhsPkg.mExtras;
if (lhsPs.firstInstallTime > rhsPs.firstInstallTime) {
return 1;
} else {
return -1;
}
} else {
return 0;
}
}
}
});
}
}
if (packagesToDelete != null) {
final int packageCount = packagesToDelete.size();
for (int i = 0; i < packageCount; i++) {
final String packageToDelete = packagesToDelete.get(i);
if (mService.deletePackageX(packageToDelete, PackageManager.VERSION_CODE_HIGHEST,
UserHandle.USER_SYSTEM, PackageManager.DELETE_ALL_USERS)
== PackageManager.DELETE_SUCCEEDED) {
if (file.getUsableSpace() >= neededSpace) {
return true;
}
}
}
}
// Prune uninstalled instant apps
synchronized (mService.mPackages) {
// TODO: Track last used time for uninstalled instant apps for better pruning
for (int userId : UserManagerService.getInstance().getUserIds()) {
// Prune in-memory state
removeUninstalledInstantAppStateLPw((UninstalledInstantAppState state) -> {
final long elapsedCachingMillis = System.currentTimeMillis() - state.mTimestamp;
return (elapsedCachingMillis > maxUninstalledCacheDuration);
}, userId);
// Prune on-disk state
File instantAppsDir = getInstantApplicationsDir(userId);
if (!instantAppsDir.exists()) {
continue;
}
File[] files = instantAppsDir.listFiles();
if (files == null) {
continue;
}
for (File instantDir : files) {
if (!instantDir.isDirectory()) {
continue;
}
File metadataFile = new File(instantDir, INSTANT_APP_METADATA_FILE);
if (!metadataFile.exists()) {
continue;
}
final long elapsedCachingMillis = System.currentTimeMillis()
- metadataFile.lastModified();
if (elapsedCachingMillis > maxUninstalledCacheDuration) {
deleteDir(instantDir);
if (file.getUsableSpace() >= neededSpace) {
return true;
}
}
}
}
}
return false;
}
@GuardedBy("mService.mPackages")
private @Nullable List<InstantAppInfo> getInstalledInstantApplicationsLPr(
@UserIdInt int userId) {
List<InstantAppInfo> result = null;
final int packageCount = mService.mPackages.size();
for (int i = 0; i < packageCount; i++) {
final PackageParser.Package pkg = mService.mPackages.valueAt(i);
final PackageSetting ps = (PackageSetting) pkg.mExtras;
if (ps == null || !ps.getInstantApp(userId)) {
continue;
}
final InstantAppInfo info = createInstantAppInfoForPackage(
pkg, userId, true);
if (info == null) {
continue;
}
if (result == null) {
result = new ArrayList<>();
}
result.add(info);
}
return result;
}
private @NonNull
InstantAppInfo createInstantAppInfoForPackage(
@NonNull PackageParser.Package pkg, @UserIdInt int userId,
boolean addApplicationInfo) {
PackageSetting ps = (PackageSetting) pkg.mExtras;
if (ps == null) {
return null;
}
if (!ps.getInstalled(userId)) {
return null;
}
String[] requestedPermissions = new String[pkg.requestedPermissions.size()];
pkg.requestedPermissions.toArray(requestedPermissions);
Set<String> permissions = ps.getPermissionsState().getPermissions(userId);
String[] grantedPermissions = new String[permissions.size()];
permissions.toArray(grantedPermissions);
if (addApplicationInfo) {
return new InstantAppInfo(pkg.applicationInfo,
requestedPermissions, grantedPermissions);
} else {
return new InstantAppInfo(pkg.applicationInfo.packageName,
pkg.applicationInfo.loadLabel(mService.mContext.getPackageManager()),
requestedPermissions, grantedPermissions);
}
}
@GuardedBy("mService.mPackages")
private @Nullable List<InstantAppInfo> getUninstalledInstantApplicationsLPr(
@UserIdInt int userId) {
List<UninstalledInstantAppState> uninstalledAppStates =
getUninstalledInstantAppStatesLPr(userId);
if (uninstalledAppStates == null || uninstalledAppStates.isEmpty()) {
return null;
}
List<InstantAppInfo> uninstalledApps = null;
final int stateCount = uninstalledAppStates.size();
for (int i = 0; i < stateCount; i++) {
UninstalledInstantAppState uninstalledAppState = uninstalledAppStates.get(i);
if (uninstalledApps == null) {
uninstalledApps = new ArrayList<>();
}
uninstalledApps.add(uninstalledAppState.mInstantAppInfo);
}
return uninstalledApps;
}
private void propagateInstantAppPermissionsIfNeeded(@NonNull PackageParser.Package pkg,
@UserIdInt int userId) {
InstantAppInfo appInfo = peekOrParseUninstalledInstantAppInfo(
pkg.packageName, userId);
if (appInfo == null) {
return;
}
if (ArrayUtils.isEmpty(appInfo.getGrantedPermissions())) {
return;
}
final long identity = Binder.clearCallingIdentity();
try {
for (String grantedPermission : appInfo.getGrantedPermissions()) {
final boolean propagatePermission =
mService.mSettings.canPropagatePermissionToInstantApp(grantedPermission);
if (propagatePermission && pkg.requestedPermissions.contains(grantedPermission)) {
mService.grantRuntimePermission(pkg.packageName, grantedPermission, userId);
}
}
} finally {
Binder.restoreCallingIdentity(identity);
}
}
private @NonNull
InstantAppInfo peekOrParseUninstalledInstantAppInfo(
@NonNull String packageName, @UserIdInt int userId) {
if (mUninstalledInstantApps != null) {
List<UninstalledInstantAppState> uninstalledAppStates =
mUninstalledInstantApps.get(userId);
if (uninstalledAppStates != null) {
final int appCount = uninstalledAppStates.size();
for (int i = 0; i < appCount; i++) {
UninstalledInstantAppState uninstalledAppState = uninstalledAppStates.get(i);
if (uninstalledAppState.mInstantAppInfo
.getPackageName().equals(packageName)) {
return uninstalledAppState.mInstantAppInfo;
}
}
}
}
File metadataFile = new File(getInstantApplicationDir(packageName, userId),
INSTANT_APP_METADATA_FILE);
UninstalledInstantAppState uninstalledAppState = parseMetadataFile(metadataFile);
if (uninstalledAppState == null) {
return null;
}
return uninstalledAppState.mInstantAppInfo;
}
@GuardedBy("mService.mPackages")
private @Nullable List<UninstalledInstantAppState> getUninstalledInstantAppStatesLPr(
@UserIdInt int userId) {
List<UninstalledInstantAppState> uninstalledAppStates = null;
if (mUninstalledInstantApps != null) {
uninstalledAppStates = mUninstalledInstantApps.get(userId);
if (uninstalledAppStates != null) {
return uninstalledAppStates;
}
}
File instantAppsDir = getInstantApplicationsDir(userId);
if (instantAppsDir.exists()) {
File[] files = instantAppsDir.listFiles();
if (files != null) {
for (File instantDir : files) {
if (!instantDir.isDirectory()) {
continue;
}
File metadataFile = new File(instantDir,
INSTANT_APP_METADATA_FILE);
UninstalledInstantAppState uninstalledAppState =
parseMetadataFile(metadataFile);
if (uninstalledAppState == null) {
continue;
}
if (uninstalledAppStates == null) {
uninstalledAppStates = new ArrayList<>();
}
uninstalledAppStates.add(uninstalledAppState);
}
}
}
if (uninstalledAppStates != null) {
if (mUninstalledInstantApps == null) {
mUninstalledInstantApps = new SparseArray<>();
}
mUninstalledInstantApps.put(userId, uninstalledAppStates);
}
return uninstalledAppStates;
}
private static @Nullable UninstalledInstantAppState parseMetadataFile(
@NonNull File metadataFile) {
if (!metadataFile.exists()) {
return null;
}
FileInputStream in;
try {
in = new AtomicFile(metadataFile).openRead();
} catch (FileNotFoundException fnfe) {
Slog.i(LOG_TAG, "No instant metadata file");
return null;
}
final File instantDir = metadataFile.getParentFile();
final long timestamp = metadataFile.lastModified();
final String packageName = instantDir.getName();
try {
XmlPullParser parser = Xml.newPullParser();
parser.setInput(in, StandardCharsets.UTF_8.name());
return new UninstalledInstantAppState(
parseMetadata(parser, packageName), timestamp);
} catch (XmlPullParserException | IOException e) {
throw new IllegalStateException("Failed parsing instant"
+ " metadata file: " + metadataFile, e);
} finally {
IoUtils.closeQuietly(in);
}
}
private static @NonNull File computeInstantCookieFile(@NonNull String packageName,
@NonNull String sha256Digest, @UserIdInt int userId) {
final File appDir = getInstantApplicationDir(packageName, userId);
final String cookieFile = INSTANT_APP_COOKIE_FILE_PREFIX
+ sha256Digest + INSTANT_APP_COOKIE_FILE_SIFFIX;
return new File(appDir, cookieFile);
}
private static @Nullable File peekInstantCookieFile(@NonNull String packageName,
@UserIdInt int userId) {
File appDir = getInstantApplicationDir(packageName, userId);
if (!appDir.exists()) {
return null;
}
File[] files = appDir.listFiles();
if (files == null) {
return null;
}
for (File file : files) {
if (!file.isDirectory()
&& file.getName().startsWith(INSTANT_APP_COOKIE_FILE_PREFIX)
&& file.getName().endsWith(INSTANT_APP_COOKIE_FILE_SIFFIX)) {
return file;
}
}
return null;
}
private static @Nullable
InstantAppInfo parseMetadata(@NonNull XmlPullParser parser,
@NonNull String packageName)
throws IOException, XmlPullParserException {
final int outerDepth = parser.getDepth();
while (XmlUtils.nextElementWithin(parser, outerDepth)) {
if (TAG_PACKAGE.equals(parser.getName())) {
return parsePackage(parser, packageName);
}
}
return null;
}
private static InstantAppInfo parsePackage(@NonNull XmlPullParser parser,
@NonNull String packageName)
throws IOException, XmlPullParserException {
String label = parser.getAttributeValue(null, ATTR_LABEL);
List<String> outRequestedPermissions = new ArrayList<>();
List<String> outGrantedPermissions = new ArrayList<>();
final int outerDepth = parser.getDepth();
while (XmlUtils.nextElementWithin(parser, outerDepth)) {
if (TAG_PERMISSIONS.equals(parser.getName())) {
parsePermissions(parser, outRequestedPermissions, outGrantedPermissions);
}
}
String[] requestedPermissions = new String[outRequestedPermissions.size()];
outRequestedPermissions.toArray(requestedPermissions);
String[] grantedPermissions = new String[outGrantedPermissions.size()];
outGrantedPermissions.toArray(grantedPermissions);
return new InstantAppInfo(packageName, label,
requestedPermissions, grantedPermissions);
}
private static void parsePermissions(@NonNull XmlPullParser parser,
@NonNull List<String> outRequestedPermissions,
@NonNull List<String> outGrantedPermissions)
throws IOException, XmlPullParserException {
final int outerDepth = parser.getDepth();
while (XmlUtils.nextElementWithin(parser,outerDepth)) {
if (TAG_PERMISSION.equals(parser.getName())) {
String permission = XmlUtils.readStringAttribute(parser, ATTR_NAME);
outRequestedPermissions.add(permission);
if (XmlUtils.readBooleanAttribute(parser, ATTR_GRANTED)) {
outGrantedPermissions.add(permission);
}
}
}
}
private void writeUninstalledInstantAppMetadata(
@NonNull InstantAppInfo instantApp, @UserIdInt int userId) {
File appDir = getInstantApplicationDir(instantApp.getPackageName(), userId);
if (!appDir.exists() && !appDir.mkdirs()) {
return;
}
File metadataFile = new File(appDir, INSTANT_APP_METADATA_FILE);
AtomicFile destination = new AtomicFile(metadataFile);
FileOutputStream out = null;
try {
out = destination.startWrite();
XmlSerializer serializer = Xml.newSerializer();
serializer.setOutput(out, StandardCharsets.UTF_8.name());
serializer.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output", true);
serializer.startDocument(null, true);
serializer.startTag(null, TAG_PACKAGE);
serializer.attribute(null, ATTR_LABEL, instantApp.loadLabel(
mService.mContext.getPackageManager()).toString());
serializer.startTag(null, TAG_PERMISSIONS);
for (String permission : instantApp.getRequestedPermissions()) {
serializer.startTag(null, TAG_PERMISSION);
serializer.attribute(null, ATTR_NAME, permission);
if (ArrayUtils.contains(instantApp.getGrantedPermissions(), permission)) {
serializer.attribute(null, ATTR_GRANTED, String.valueOf(true));
}
serializer.endTag(null, TAG_PERMISSION);
}
serializer.endTag(null, TAG_PERMISSIONS);
serializer.endTag(null, TAG_PACKAGE);
serializer.endDocument();
destination.finishWrite(out);
} catch (Throwable t) {
Slog.wtf(LOG_TAG, "Failed to write instant state, restoring backup", t);
destination.failWrite(out);
} finally {
IoUtils.closeQuietly(out);
}
}
private static @NonNull File getInstantApplicationsDir(int userId) {
return new File(Environment.getUserSystemDirectory(userId),
INSTANT_APPS_FOLDER);
}
private static @NonNull File getInstantApplicationDir(String packageName, int userId) {
return new File(getInstantApplicationsDir(userId), packageName);
}
private static void deleteDir(@NonNull File dir) {
File[] files = dir.listFiles();
if (files != null) {
for (File file : files) {
deleteDir(file);
}
}
dir.delete();
}
private static final class UninstalledInstantAppState {
final InstantAppInfo mInstantAppInfo;
final long mTimestamp;
public UninstalledInstantAppState(InstantAppInfo instantApp,
long timestamp) {
mInstantAppInfo = instantApp;
mTimestamp = timestamp;
}
}
private final class CookiePersistence extends Handler {
private static final long PERSIST_COOKIE_DELAY_MILLIS = 1000L; /* one second */
// The cookies are cached per package name per user-id in this sparse
// array. The caching is so that pending persistence can be canceled within
// a short interval. To ensure we still return pending persist cookies
// for a package that uninstalled and reinstalled while the persistence
// was still pending, we use the package name as a key for
// mPendingPersistCookies, since that stays stable across reinstalls.
private final SparseArray<ArrayMap<String, SomeArgs>> mPendingPersistCookies
= new SparseArray<>();
public CookiePersistence(Looper looper) {
super(looper);
}
public void schedulePersistLPw(@UserIdInt int userId, @NonNull PackageParser.Package pkg,
@NonNull byte[] cookie) {
// Before we used only the first signature to compute the SHA 256 but some
// apps could be singed by multiple certs and the cert order is undefined.
// We prefer the modern computation procedure where all certs are taken
// into account and delete the file derived via the legacy hash computation.
File newCookieFile = computeInstantCookieFile(pkg.packageName,
PackageUtils.computeSignaturesSha256Digest(pkg.mSigningDetails.signatures), userId);
if (!pkg.mSigningDetails.hasSignatures()) {
Slog.wtf(LOG_TAG, "Parsed Instant App contains no valid signatures!");
}
File oldCookieFile = peekInstantCookieFile(pkg.packageName, userId);
if (oldCookieFile != null && !newCookieFile.equals(oldCookieFile)) {
oldCookieFile.delete();
}
cancelPendingPersistLPw(pkg, userId);
addPendingPersistCookieLPw(userId, pkg, cookie, newCookieFile);
sendMessageDelayed(obtainMessage(userId, pkg),
PERSIST_COOKIE_DELAY_MILLIS);
}
public @Nullable byte[] getPendingPersistCookieLPr(@NonNull PackageParser.Package pkg,
@UserIdInt int userId) {
ArrayMap<String, SomeArgs> pendingWorkForUser =
mPendingPersistCookies.get(userId);
if (pendingWorkForUser != null) {
SomeArgs state = pendingWorkForUser.get(pkg.packageName);
if (state != null) {
return (byte[]) state.arg1;
}
}
return null;
}
public void cancelPendingPersistLPw(@NonNull PackageParser.Package pkg,
@UserIdInt int userId) {
removeMessages(userId, pkg);
SomeArgs state = removePendingPersistCookieLPr(pkg, userId);
if (state != null) {
state.recycle();
}
}
private void addPendingPersistCookieLPw(@UserIdInt int userId,
@NonNull PackageParser.Package pkg, @NonNull byte[] cookie,
@NonNull File cookieFile) {
ArrayMap<String, SomeArgs> pendingWorkForUser =
mPendingPersistCookies.get(userId);
if (pendingWorkForUser == null) {
pendingWorkForUser = new ArrayMap<>();
mPendingPersistCookies.put(userId, pendingWorkForUser);
}
SomeArgs args = SomeArgs.obtain();
args.arg1 = cookie;
args.arg2 = cookieFile;
pendingWorkForUser.put(pkg.packageName, args);
}
private SomeArgs removePendingPersistCookieLPr(@NonNull PackageParser.Package pkg,
@UserIdInt int userId) {
ArrayMap<String, SomeArgs> pendingWorkForUser =
mPendingPersistCookies.get(userId);
SomeArgs state = null;
if (pendingWorkForUser != null) {
state = pendingWorkForUser.remove(pkg.packageName);
if (pendingWorkForUser.isEmpty()) {
mPendingPersistCookies.remove(userId);
}
}
return state;
}
@Override
public void handleMessage(Message message) {
int userId = message.what;
PackageParser.Package pkg = (PackageParser.Package) message.obj;
SomeArgs state = removePendingPersistCookieLPr(pkg, userId);
if (state == null) {
return;
}
byte[] cookie = (byte[]) state.arg1;
File cookieFile = (File) state.arg2;
state.recycle();
persistInstantApplicationCookie(cookie, pkg.packageName, cookieFile, userId);
}
}
}