Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Migrate usages of AppBackupUtils to BackupEligibilityRules

Browse Source 
After refactoring AppBackupUtils into BackupEligibilityRules (see the
other linked CL), update the usages throughout the code.

Bug: 161241479
Test: atest UserBackupManagerServiceTest
      atest TarBackupReaderTest
      atest BackupHandlerTest
      atest PerformUnifiedRestoreTaskTest
Change-Id: I2a90c4f5b951fa3e3c564a1065ad10a88cc16273
This commit is contained in:
Ruslan Tkhakokhov
2020-07-14 17:40:54 +01:00
parent b0a213ef06
commit 9a724ed0b3
13 changed files with 233 additions and 122 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
services/backup/java/com/android/server/backup/PackageManagerBackupAgent.java
View File

@@ -33,7 +33,7 @@ import android.os.ParcelFileDescriptor;
import android.util.Slog;
import com.android.server.LocalServices;
import com.android.server.backup.utils.AppBackupUtils;
import com.android.server.backup.utils.BackupEligibilityRules;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
@@ -134,10 +134,11 @@ public class PackageManagerBackupAgent extends BackupAgent {
init(packageMgr, packages, userId);
}
public PackageManagerBackupAgent(PackageManager packageMgr, int userId) {
public PackageManagerBackupAgent(PackageManager packageMgr, int userId,
BackupEligibilityRules backupEligibilityRules) {
init(packageMgr, null, userId);
evaluateStorablePackages();
evaluateStorablePackages(backupEligibilityRules);
}
private void init(PackageManager packageMgr, List<PackageInfo> packages, int userId) {
@@ -153,18 +154,19 @@ public class PackageManagerBackupAgent extends BackupAgent {
// We will need to refresh our understanding of what is eligible for
// backup periodically; this entry point serves that purpose.
public void evaluateStorablePackages() {
mAllPackages = getStorableApplications(mPackageManager, mUserId);
public void evaluateStorablePackages(BackupEligibilityRules backupEligibilityRules) {
mAllPackages = getStorableApplications(mPackageManager, mUserId, backupEligibilityRules);
}
/** Gets all packages installed on user {@code userId} eligible for backup. */
public static List<PackageInfo> getStorableApplications(PackageManager pm, int userId) {
public static List<PackageInfo> getStorableApplications(PackageManager pm, int userId,
BackupEligibilityRules backupEligibilityRules) {
List<PackageInfo> pkgs =
pm.getInstalledPackagesAsUser(PackageManager.GET_SIGNING_CERTIFICATES, userId);
int N = pkgs.size();
for (int a = N-1; a >= 0; a--) {
PackageInfo pkg = pkgs.get(a);
if (!AppBackupUtils.appIsEligibleForBackup(pkg.applicationInfo, userId)) {
if (!backupEligibilityRules.appIsEligibleForBackup(pkg.applicationInfo)) {
pkgs.remove(a);
}
}

95
services/backup/java/com/android/server/backup/UserBackupManagerService.java
View File

@@ -68,6 +68,7 @@ import android.content.pm.IPackageManager;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.content.pm.PackageManager.NameNotFoundException;
import android.content.pm.PackageManagerInternal;
import android.database.ContentObserver;
import android.net.Uri;
import android.os.Binder;
@@ -127,7 +128,7 @@ import com.android.server.backup.restore.ActiveRestoreSession;
import com.android.server.backup.restore.PerformUnifiedRestoreTask;
import com.android.server.backup.transport.TransportClient;
import com.android.server.backup.transport.TransportNotRegisteredException;
import com.android.server.backup.utils.AppBackupUtils;
import com.android.server.backup.utils.BackupEligibilityRules;
import com.android.server.backup.utils.BackupManagerMonitorUtils;
import com.android.server.backup.utils.BackupObserverUtils;
import com.android.server.backup.utils.SparseArrayUtils;
@@ -336,6 +337,7 @@ public class UserBackupManagerService {
private final BackupManagerConstants mConstants;
private final BackupWakeLock mWakelock;
private final BackupHandler mBackupHandler;
private final BackupEligibilityRules mScheduledBackupEligibility;
private final IBackupManager mBackupManagerBinder;
@@ -563,6 +565,7 @@ public class UserBackupManagerService {
mActivityManager = null;
mStorageManager = null;
mBackupManagerBinder = null;
mScheduledBackupEligibility = null;
}
private UserBackupManagerService(
@@ -579,6 +582,8 @@ public class UserBackupManagerService {
mPackageManagerBinder = AppGlobals.getPackageManager();
mActivityManager = ActivityManager.getService();
mActivityManagerInternal = LocalServices.getService(ActivityManagerInternal.class);
mScheduledBackupEligibility = getEligibilityRules(mPackageManager, userId,
OperationType.BACKUP);
mAlarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
mPowerManager = (PowerManager) context.getSystemService(Context.POWER_SERVICE);
@@ -914,7 +919,13 @@ public class UserBackupManagerService {
* non-lifecycle agent instance, so we manually set up the context topology for it.
*/
public BackupAgent makeMetadataAgent() {
PackageManagerBackupAgent pmAgent = new PackageManagerBackupAgent(mPackageManager, mUserId);
return makeMetadataAgentWithEligibilityRules(mScheduledBackupEligibility);
}
public BackupAgent makeMetadataAgentWithEligibilityRules(
BackupEligibilityRules backupEligibilityRules) {
PackageManagerBackupAgent pmAgent = new PackageManagerBackupAgent(mPackageManager, mUserId,
backupEligibilityRules);
pmAgent.attach(mContext);
pmAgent.onCreate(UserHandle.of(mUserId));
return pmAgent;
@@ -996,7 +1007,8 @@ public class UserBackupManagerService {
boolean changed = false;
ArrayList<FullBackupEntry> schedule = null;
List<PackageInfo> apps =
PackageManagerBackupAgent.getStorableApplications(mPackageManager, mUserId);
PackageManagerBackupAgent.getStorableApplications(mPackageManager, mUserId,
mScheduledBackupEligibility);
if (mFullBackupScheduleFile.exists()) {
try (FileInputStream fstream = new FileInputStream(mFullBackupScheduleFile);
@@ -1026,9 +1038,9 @@ public class UserBackupManagerService {
foundApps.add(pkgName); // all apps that we've addressed already
try {
PackageInfo pkg = mPackageManager.getPackageInfoAsUser(pkgName, 0, mUserId);
if (AppBackupUtils.appGetsFullBackup(pkg)
&& AppBackupUtils.appIsEligibleForBackup(pkg.applicationInfo,
mUserId)) {
if (mScheduledBackupEligibility.appGetsFullBackup(pkg)
&& mScheduledBackupEligibility.appIsEligibleForBackup(
pkg.applicationInfo)) {
schedule.add(new FullBackupEntry(pkgName, lastBackup));
} else {
if (DEBUG) {
@@ -1047,9 +1059,9 @@ public class UserBackupManagerService {
// New apps can arrive "out of band" via OTA and similar, so we also need to
// scan to make sure that we're tracking all full-backup candidates properly
for (PackageInfo app : apps) {
if (AppBackupUtils.appGetsFullBackup(app)
&& AppBackupUtils.appIsEligibleForBackup(app.applicationInfo,
mUserId)) {
if (mScheduledBackupEligibility.appGetsFullBackup(app)
&& mScheduledBackupEligibility.appIsEligibleForBackup(
app.applicationInfo)) {
if (!foundApps.contains(app.packageName)) {
if (MORE_DEBUG) {
Slog.i(
@@ -1080,8 +1092,9 @@ public class UserBackupManagerService {
changed = true;
schedule = new ArrayList<>(apps.size());
for (PackageInfo info : apps) {
if (AppBackupUtils.appGetsFullBackup(info) && AppBackupUtils.appIsEligibleForBackup(
info.applicationInfo, mUserId)) {
if (mScheduledBackupEligibility.appGetsFullBackup(info)
&& mScheduledBackupEligibility.appIsEligibleForBackup(
info.applicationInfo)) {
schedule.add(new FullBackupEntry(info.packageName, 0));
}
}
@@ -1381,9 +1394,9 @@ public class UserBackupManagerService {
PackageInfo app =
mPackageManager.getPackageInfoAsUser(
packageName, /* flags */ 0, mUserId);
if (AppBackupUtils.appGetsFullBackup(app)
&& AppBackupUtils.appIsEligibleForBackup(
app.applicationInfo, mUserId)) {
if (mScheduledBackupEligibility.appGetsFullBackup(app)
&& mScheduledBackupEligibility.appIsEligibleForBackup(
app.applicationInfo)) {
enqueueFullBackup(packageName, now);
scheduleNextFullBackupJob(0);
} else {
@@ -1881,9 +1894,11 @@ public class UserBackupManagerService {
OnTaskFinishedListener listener =
caller -> mTransportManager.disposeOfTransportClient(transportClient, caller);
BackupEligibilityRules backupEligibilityRules = getEligibilityRulesForOperation(
operationType);
Message msg = mBackupHandler.obtainMessage(MSG_REQUEST_BACKUP);
msg.obj = getRequestBackupParams(packages, observer, monitor, flags, operationType,
msg.obj = getRequestBackupParams(packages, observer, monitor, flags, backupEligibilityRules,
transportClient, transportDirName, listener);
mBackupHandler.sendMessage(msg);
return BackupManager.SUCCESS;
@@ -1891,7 +1906,7 @@ public class UserBackupManagerService {
@VisibleForTesting
BackupParams getRequestBackupParams(String[] packages, IBackupObserver observer,
IBackupManagerMonitor monitor, int flags, @OperationType int operationType,
IBackupManagerMonitor monitor, int flags, BackupEligibilityRules backupEligibilityRules,
TransportClient transportClient, String transportDirName,
OnTaskFinishedListener listener) {
ArrayList<String> fullBackupList = new ArrayList<>();
@@ -1904,13 +1919,12 @@ public class UserBackupManagerService {
try {
PackageInfo packageInfo = mPackageManager.getPackageInfoAsUser(packageName,
PackageManager.GET_SIGNING_CERTIFICATES, mUserId);
if (!appIsEligibleForBackup(packageInfo.applicationInfo, mUserId,
operationType)) {
if (!backupEligibilityRules.appIsEligibleForBackup(packageInfo.applicationInfo)) {
BackupObserverUtils.sendBackupOnPackageResult(observer, packageName,
BackupManager.ERROR_BACKUP_NOT_ALLOWED);
continue;
}
if (appGetsFullBackup(packageInfo, operationType)) {
if (backupEligibilityRules.appGetsFullBackup(packageInfo)) {
fullBackupList.add(packageInfo.packageName);
} else {
kvBackupList.add(packageInfo.packageName);
@@ -1941,18 +1955,7 @@ public class UserBackupManagerService {
return new BackupParams(transportClient, transportDirName, kvBackupList, fullBackupList,
observer, monitor, listener, /* userInitiated */ true, nonIncrementalBackup,
operationType);
}
@VisibleForTesting
boolean appIsEligibleForBackup(ApplicationInfo applicationInfo, int userId,
@OperationType int operationType) {
return AppBackupUtils.appIsEligibleForBackup(applicationInfo, userId, operationType);
}
@VisibleForTesting
boolean appGetsFullBackup(PackageInfo packageInfo, @OperationType int operationType) {
return AppBackupUtils.appGetsFullBackup(packageInfo, operationType);
backupEligibilityRules);
}
/** Cancel all running backups. */
@@ -2481,7 +2484,7 @@ public class UserBackupManagerService {
try {
PackageInfo appInfo = mPackageManager.getPackageInfoAsUser(
entry.packageName, 0, mUserId);
if (!AppBackupUtils.appGetsFullBackup(appInfo)) {
if (!mScheduledBackupEligibility.appGetsFullBackup(appInfo)) {
// The head app isn't supposed to get full-data backups [any more];
// so we cull it and force a loop around to consider the new head
// app.
@@ -2562,7 +2565,8 @@ public class UserBackupManagerService {
/* backupObserver */ null,
/* monitor */ null,
/* userInitiated */ false,
"BMS.beginFullBackup()");
"BMS.beginFullBackup()",
getEligibilityRulesForOperation(OperationType.BACKUP));
// Acquiring wakelock for PerformFullTransportBackupTask before its start.
mWakelock.acquire();
(new Thread(mRunningFullBackupTask)).start();
@@ -3001,7 +3005,7 @@ public class UserBackupManagerService {
AdbBackupParams params = new AdbBackupParams(fd, includeApks, includeObbs,
includeShared, doWidgets, doAllApps, includeSystem, compress, doKeyValue,
pkgList);
pkgList, mScheduledBackupEligibility);
final int token = generateRandomIntegerToken();
synchronized (mAdbBackupRestoreConfirmations) {
mAdbBackupRestoreConfirmations.put(token, params);
@@ -3086,7 +3090,8 @@ public class UserBackupManagerService {
/* backupObserver */ null,
/* monitor */ null,
/* userInitiated */ false,
"BMS.fullTransportBackup()");
"BMS.fullTransportBackup()",
getEligibilityRulesForOperation(OperationType.BACKUP));
// Acquiring wakelock for PerformFullTransportBackupTask before its start.
mWakelock.acquire();
(new Thread(task, "full-transport-master")).start();
@@ -4137,8 +4142,8 @@ public class UserBackupManagerService {
TransportClient transportClient =
mTransportManager.getCurrentTransportClient(callerLogString);
boolean eligible =
AppBackupUtils.appIsRunningAndEligibleForBackupWithTransport(
transportClient, packageName, mPackageManager, mUserId);
mScheduledBackupEligibility.appIsRunningAndEligibleForBackupWithTransport(
transportClient, packageName);
if (transportClient != null) {
mTransportManager.disposeOfTransportClient(transportClient, callerLogString);
}
@@ -4160,9 +4165,8 @@ public class UserBackupManagerService {
mTransportManager.getCurrentTransportClient(callerLogString);
List<String> eligibleApps = new LinkedList<>();
for (String packageName : packages) {
if (AppBackupUtils
.appIsRunningAndEligibleForBackupWithTransport(
transportClient, packageName, mPackageManager, mUserId)) {
if (mScheduledBackupEligibility.appIsRunningAndEligibleForBackupWithTransport(
transportClient, packageName)) {
eligibleApps.add(packageName);
}
}
@@ -4175,6 +4179,17 @@ public class UserBackupManagerService {
}
}
public BackupEligibilityRules getEligibilityRulesForOperation(
@OperationType int operationType) {
return getEligibilityRules(mPackageManager, mUserId, operationType);
}
private static BackupEligibilityRules getEligibilityRules(PackageManager packageManager,
int userId, @OperationType int operationType) {
return new BackupEligibilityRules(packageManager,
LocalServices.getService(PackageManagerInternal.class), userId, operationType);
}
/** Prints service state for 'dumpsys backup'. */
public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
long identityToken = Binder.clearCallingIdentity();

16
services/backup/java/com/android/server/backup/fullbackup/PerformAdbBackupTask.java
View File

@@ -24,6 +24,8 @@ import static com.android.server.backup.UserBackupManagerService.BACKUP_FILE_HEA
import static com.android.server.backup.UserBackupManagerService.BACKUP_FILE_VERSION;
import static com.android.server.backup.UserBackupManagerService.SHARED_BACKUP_AGENT_PACKAGE;
import android.app.backup.BackupManager;
import android.app.backup.BackupManager.OperationType;
import android.app.backup.IFullBackupRestoreObserver;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageInfo;
@@ -38,7 +40,7 @@ import com.android.server.AppWidgetBackupBridge;
import com.android.server.backup.BackupRestoreTask;
import com.android.server.backup.KeyValueAdbBackupEngine;
import com.android.server.backup.UserBackupManagerService;
import com.android.server.backup.utils.AppBackupUtils;
import com.android.server.backup.utils.BackupEligibilityRules;
import com.android.server.backup.utils.PasswordUtils;
import java.io.ByteArrayOutputStream;
@@ -83,12 +85,14 @@ public class PerformAdbBackupTask extends FullBackupTask implements BackupRestor
private final String mCurrentPassword;
private final String mEncryptPassword;
private final int mCurrentOpToken;
private final BackupEligibilityRules mBackupEligibilityRules;
public PerformAdbBackupTask(UserBackupManagerService backupManagerService,
ParcelFileDescriptor fd, IFullBackupRestoreObserver observer,
boolean includeApks, boolean includeObbs, boolean includeShared, boolean doWidgets,
String curPassword, String encryptPassword, boolean doAllApps, boolean doSystem,
boolean doCompress, boolean doKeyValue, String[] packages, AtomicBoolean latch) {
boolean doCompress, boolean doKeyValue, String[] packages, AtomicBoolean latch,
BackupEligibilityRules backupEligibilityRules) {
super(observer);
mUserBackupManagerService = backupManagerService;
mCurrentOpToken = backupManagerService.generateRandomIntegerToken();
@@ -119,6 +123,7 @@ public class PerformAdbBackupTask extends FullBackupTask implements BackupRestor
}
mCompress = doCompress;
mKeyValue = doKeyValue;
mBackupEligibilityRules = backupEligibilityRules;
}
private void addPackagesToSet(TreeMap<String, PackageInfo> set, List<String> pkgNames) {
@@ -286,15 +291,14 @@ public class PerformAdbBackupTask extends FullBackupTask implements BackupRestor
Iterator<Entry<String, PackageInfo>> iter = packagesToBackup.entrySet().iterator();
while (iter.hasNext()) {
PackageInfo pkg = iter.next().getValue();
if (!AppBackupUtils.appIsEligibleForBackup(pkg.applicationInfo,
mUserBackupManagerService.getUserId())
|| AppBackupUtils.appIsStopped(pkg.applicationInfo)) {
if (!mBackupEligibilityRules.appIsEligibleForBackup(pkg.applicationInfo)
|| mBackupEligibilityRules.appIsStopped(pkg.applicationInfo)) {
iter.remove();
if (DEBUG) {
Slog.i(TAG, "Package " + pkg.packageName
+ " is not eligible for backup, removing.");
}
} else if (AppBackupUtils.appIsKeyValueOnly(pkg)) {
} else if (mBackupEligibilityRules.appIsKeyValueOnly(pkg)) {
iter.remove();
if (DEBUG) {
Slog.i(TAG, "Package " + pkg.packageName

18
services/backup/java/com/android/server/backup/fullbackup/PerformFullTransportBackupTask.java
View File

@@ -53,7 +53,7 @@ import com.android.server.backup.internal.Operation;
import com.android.server.backup.remote.RemoteCall;
import com.android.server.backup.transport.TransportClient;
import com.android.server.backup.transport.TransportNotAvailableException;
import com.android.server.backup.utils.AppBackupUtils;
import com.android.server.backup.utils.BackupEligibilityRules;
import com.android.server.backup.utils.BackupManagerMonitorUtils;
import com.android.server.backup.utils.BackupObserverUtils;
@@ -107,7 +107,8 @@ public class PerformFullTransportBackupTask extends FullBackupTask implements Ba
IBackupObserver backupObserver,
IBackupManagerMonitor monitor,
boolean userInitiated,
String caller) {
String caller,
BackupEligibilityRules backupEligibilityRules) {
TransportManager transportManager = backupManagerService.getTransportManager();
TransportClient transportClient = transportManager.getCurrentTransportClient(caller);
OnTaskFinishedListener listener =
@@ -124,7 +125,8 @@ public class PerformFullTransportBackupTask extends FullBackupTask implements Ba
backupObserver,
monitor,
listener,
userInitiated);
userInitiated,
backupEligibilityRules);
}
private static final String TAG = "PFTBT";
@@ -151,6 +153,7 @@ public class PerformFullTransportBackupTask extends FullBackupTask implements Ba
private volatile boolean mCancelAll;
private final int mCurrentOpToken;
private final BackupAgentTimeoutParameters mAgentTimeoutParameters;
private final BackupEligibilityRules mBackupEligibilityRules;
public PerformFullTransportBackupTask(UserBackupManagerService backupManagerService,
TransportClient transportClient,
@@ -158,7 +161,7 @@ public class PerformFullTransportBackupTask extends FullBackupTask implements Ba
String[] whichPackages, boolean updateSchedule,
FullBackupJob runningJob, CountDownLatch latch, IBackupObserver backupObserver,
@Nullable IBackupManagerMonitor monitor, @Nullable OnTaskFinishedListener listener,
boolean userInitiated) {
boolean userInitiated, BackupEligibilityRules backupEligibilityRules) {
super(observer);
this.mUserBackupManagerService = backupManagerService;
mTransportClient = transportClient;
@@ -176,6 +179,7 @@ public class PerformFullTransportBackupTask extends FullBackupTask implements Ba
backupManagerService.getAgentTimeoutParameters(),
"Timeout parameters cannot be null");
mUserId = backupManagerService.getUserId();
mBackupEligibilityRules = backupEligibilityRules;
if (backupManagerService.isBackupOperationInProgress()) {
if (DEBUG) {
@@ -193,7 +197,7 @@ public class PerformFullTransportBackupTask extends FullBackupTask implements Ba
PackageInfo info = pm.getPackageInfoAsUser(pkg,
PackageManager.GET_SIGNING_CERTIFICATES, mUserId);
mCurrentPackage = info;
if (!AppBackupUtils.appIsEligibleForBackup(info.applicationInfo, mUserId)) {
if (!mBackupEligibilityRules.appIsEligibleForBackup(info.applicationInfo)) {
// Cull any packages that have indicated that backups are not permitted,
// that run as system-domain uids but do not define their own backup agents,
// as well as any explicit mention of the 'special' shared-storage agent
@@ -209,7 +213,7 @@ public class PerformFullTransportBackupTask extends FullBackupTask implements Ba
BackupObserverUtils.sendBackupOnPackageResult(mBackupObserver, pkg,
BackupManager.ERROR_BACKUP_NOT_ALLOWED);
continue;
} else if (!AppBackupUtils.appGetsFullBackup(info)) {
} else if (!mBackupEligibilityRules.appGetsFullBackup(info)) {
// Cull any packages that are found in the queue but now aren't supposed
// to get full-data backup operations.
if (MORE_DEBUG) {
@@ -224,7 +228,7 @@ public class PerformFullTransportBackupTask extends FullBackupTask implements Ba
BackupObserverUtils.sendBackupOnPackageResult(mBackupObserver, pkg,
BackupManager.ERROR_BACKUP_NOT_ALLOWED);
continue;
} else if (AppBackupUtils.appIsStopped(info.applicationInfo)) {
} else if (mBackupEligibilityRules.appIsStopped(info.applicationInfo)) {
// Cull any packages in the 'stopped' state: they've either just been
// installed or have explicitly been force-stopped by the user. In both
// cases we do not want to launch them for backup.

16
services/backup/java/com/android/server/backup/internal/BackupHandler.java
View File

@@ -20,6 +20,8 @@ import static com.android.server.backup.BackupManagerService.DEBUG;
import static com.android.server.backup.BackupManagerService.MORE_DEBUG;
import static com.android.server.backup.BackupManagerService.TAG;
import android.app.backup.BackupManager;
import android.app.backup.BackupManager.OperationType;
import android.app.backup.RestoreSet;
import android.os.Handler;
import android.os.HandlerThread;
@@ -222,7 +224,9 @@ public class BackupHandler extends Handler {
listener,
Collections.emptyList(),
/* userInitiated */ false,
/* nonIncremental */ false);
/* nonIncremental */ false,
backupManagerService.getEligibilityRulesForOperation(
OperationType.BACKUP));
} catch (Exception e) {
// unable to ask the transport its dir name -- transient failure, since
// the above check succeeded. Try again next time.
@@ -279,7 +283,8 @@ public class BackupHandler extends Handler {
params.observer, params.includeApks, params.includeObbs,
params.includeShared, params.doWidgets, params.curPassword,
params.encryptPassword, params.allApps, params.includeSystem,
params.doCompress, params.includeKeyValue, params.packages, params.latch);
params.doCompress, params.includeKeyValue, params.packages, params.latch,
params.backupEligibilityRules);
(new Thread(task, "adb-backup")).start();
break;
}
@@ -299,7 +304,9 @@ public class BackupHandler extends Handler {
params.pmToken,
params.isSystemRestore,
params.filterSet,
params.listener);
params.listener,
backupManagerService.getEligibilityRulesForOperation(
OperationType.BACKUP));
synchronized (backupManagerService.getPendingRestores()) {
if (backupManagerService.isRestoreInProgress()) {
@@ -462,7 +469,8 @@ public class BackupHandler extends Handler {
params.listener,
params.fullPackages,
/* userInitiated */ true,
params.nonIncrementalBackup);
params.nonIncrementalBackup,
params.mBackupEligibilityRules);
break;
}

30
services/backup/java/com/android/server/backup/keyvalue/KeyValueBackupTask.java
View File

@@ -67,7 +67,7 @@ import com.android.server.backup.remote.RemoteCallable;
import com.android.server.backup.remote.RemoteResult;
import com.android.server.backup.transport.TransportClient;
import com.android.server.backup.transport.TransportNotAvailableException;
import com.android.server.backup.utils.AppBackupUtils;
import com.android.server.backup.utils.BackupEligibilityRules;
import libcore.io.IoUtils;
@@ -220,7 +220,8 @@ public class KeyValueBackupTask implements BackupRestoreTask, Runnable {
OnTaskFinishedListener listener,
List<String> pendingFullBackups,
boolean userInitiated,
boolean nonIncremental) {
boolean nonIncremental,
BackupEligibilityRules backupEligibilityRules) {
KeyValueBackupReporter reporter =
new KeyValueBackupReporter(backupManagerService, observer, monitor);
KeyValueBackupTask task =
@@ -234,7 +235,8 @@ public class KeyValueBackupTask implements BackupRestoreTask, Runnable {
listener,
pendingFullBackups,
userInitiated,
nonIncremental);
nonIncremental,
backupEligibilityRules);
Thread thread = new Thread(task, "key-value-backup-" + THREAD_COUNT.incrementAndGet());
thread.start();
KeyValueBackupReporter.onNewThread(thread.getName());
@@ -258,6 +260,7 @@ public class KeyValueBackupTask implements BackupRestoreTask, Runnable {
private final List<String> mPendingFullBackups;
private final Object mQueueLock;
@Nullable private final DataChangedJournal mJournal;
private final BackupEligibilityRules mBackupEligibilityRules;
@Nullable private PerformFullTransportBackupTask mFullBackupTask;
@Nullable private IBackupAgent mAgent;
@@ -307,7 +310,8 @@ public class KeyValueBackupTask implements BackupRestoreTask, Runnable {
OnTaskFinishedListener taskFinishedListener,
List<String> pendingFullBackups,
boolean userInitiated,
boolean nonIncremental) {
boolean nonIncremental,
BackupEligibilityRules backupEligibilityRules) {
mBackupManagerService = backupManagerService;
mPackageManager = backupManagerService.getPackageManager();
mTransportClient = transportClient;
@@ -330,6 +334,7 @@ public class KeyValueBackupTask implements BackupRestoreTask, Runnable {
mQueueLock = mBackupManagerService.getQueueLock();
mBlankStateFile = new File(mStateDirectory, BLANK_STATE_FILE_NAME);
mUserId = backupManagerService.getUserId();
mBackupEligibilityRules = backupEligibilityRules;
}
private void registerTask() {
@@ -456,9 +461,9 @@ public class KeyValueBackupTask implements BackupRestoreTask, Runnable {
/** Determine if a package is eligible to be backed up to the transport */
private boolean isEligibleForNoDataCall(PackageInfo packageInfo) {
return AppBackupUtils.appIsKeyValueOnly(packageInfo)
&& AppBackupUtils.appIsRunningAndEligibleForBackupWithTransport(mTransportClient,
packageInfo.packageName, mPackageManager, mUserId);
return mBackupEligibilityRules.appIsKeyValueOnly(packageInfo)
&& mBackupEligibilityRules.appIsRunningAndEligibleForBackupWithTransport(
mTransportClient, packageInfo.packageName);
}
/** Send the "no data changed" message to a transport for a specific package */
@@ -642,7 +647,8 @@ public class KeyValueBackupTask implements BackupRestoreTask, Runnable {
mReporter.getObserver(),
mReporter.getMonitor(),
mTaskFinishedListener,
mUserInitiated);
mUserInitiated,
mBackupEligibilityRules);
}
private void backupPm() throws TaskException {
@@ -704,15 +710,15 @@ public class KeyValueBackupTask implements BackupRestoreTask, Runnable {
throw AgentException.permanent(e);
}
ApplicationInfo applicationInfo = packageInfo.applicationInfo;
if (!AppBackupUtils.appIsEligibleForBackup(applicationInfo, mUserId)) {
if (!mBackupEligibilityRules.appIsEligibleForBackup(applicationInfo)) {
mReporter.onPackageNotEligibleForBackup(packageName);
throw AgentException.permanent();
}
if (AppBackupUtils.appGetsFullBackup(packageInfo)) {
if (mBackupEligibilityRules.appGetsFullBackup(packageInfo)) {
mReporter.onPackageEligibleForFullBackup(packageName);
throw AgentException.permanent();
}
if (AppBackupUtils.appIsStopped(applicationInfo)) {
if (mBackupEligibilityRules.appIsStopped(applicationInfo)) {
mReporter.onPackageStopped(packageName);
throw AgentException.permanent();
}
@@ -843,7 +849,7 @@ public class KeyValueBackupTask implements BackupRestoreTask, Runnable {
/** Same as {@link #extractAgentData(PackageInfo)}, but only for PM package. */
private void extractPmAgentData(PackageInfo packageInfo) throws AgentException, TaskException {
Preconditions.checkArgument(packageInfo.packageName.equals(PM_PACKAGE));
BackupAgent pmAgent = mBackupManagerService.makeMetadataAgent();
BackupAgent pmAgent = mBackupManagerService.makeMetadataAgentWithEligibilityRules(mBackupEligibilityRules);
mAgent = IBackupAgent.Stub.asInterface(pmAgent.onBind());
extractAgentData(packageInfo, mAgent);
}

7
services/backup/java/com/android/server/backup/params/AdbBackupParams.java
View File

@@ -18,6 +18,8 @@ package com.android.server.backup.params;
import android.os.ParcelFileDescriptor;
import com.android.server.backup.utils.BackupEligibilityRules;
public class AdbBackupParams extends AdbParams {
public boolean includeApks;
@@ -29,10 +31,12 @@ public class AdbBackupParams extends AdbParams {
public boolean doCompress;
public boolean includeKeyValue;
public String[] packages;
public BackupEligibilityRules backupEligibilityRules;
public AdbBackupParams(ParcelFileDescriptor output, boolean saveApks, boolean saveObbs,
boolean saveShared, boolean alsoWidgets, boolean doAllApps, boolean doSystem,
boolean compress, boolean doKeyValue, String[] pkgList) {
boolean compress, boolean doKeyValue, String[] pkgList,
BackupEligibilityRules eligibilityRules) {
fd = output;
includeApks = saveApks;
includeObbs = saveObbs;
@@ -43,5 +47,6 @@ public class AdbBackupParams extends AdbParams {
doCompress = compress;
includeKeyValue = doKeyValue;
packages = pkgList;
backupEligibilityRules = eligibilityRules;
}
}

8
services/backup/java/com/android/server/backup/params/BackupParams.java
View File

@@ -16,12 +16,12 @@
package com.android.server.backup.params;
import android.app.backup.BackupManager.OperationType;
import android.app.backup.IBackupManagerMonitor;
import android.app.backup.IBackupObserver;
import com.android.server.backup.internal.OnTaskFinishedListener;
import com.android.server.backup.transport.TransportClient;
import com.android.server.backup.utils.BackupEligibilityRules;
import java.util.ArrayList;
@@ -36,12 +36,12 @@ public class BackupParams {
public OnTaskFinishedListener listener;
public boolean userInitiated;
public boolean nonIncrementalBackup;
@OperationType public int operationType;
public BackupEligibilityRules mBackupEligibilityRules;
public BackupParams(TransportClient transportClient, String dirName,
ArrayList<String> kvPackages, ArrayList<String> fullPackages, IBackupObserver observer,
IBackupManagerMonitor monitor, OnTaskFinishedListener listener, boolean userInitiated,
boolean nonIncrementalBackup, int operationType) {
boolean nonIncrementalBackup, BackupEligibilityRules backupEligibilityRules) {
this.transportClient = transportClient;
this.dirName = dirName;
this.kvPackages = kvPackages;
@@ -51,6 +51,6 @@ public class BackupParams {
this.listener = listener;
this.userInitiated = userInitiated;
this.nonIncrementalBackup = nonIncrementalBackup;
this.operationType = operationType;
this.mBackupEligibilityRules = backupEligibilityRules;
}
}

10
services/backup/java/com/android/server/backup/restore/PerformUnifiedRestoreTask.java
View File

@@ -66,7 +66,7 @@ import com.android.server.backup.TransportManager;
import com.android.server.backup.UserBackupManagerService;
import com.android.server.backup.internal.OnTaskFinishedListener;
import com.android.server.backup.transport.TransportClient;
import com.android.server.backup.utils.AppBackupUtils;
import com.android.server.backup.utils.BackupEligibilityRules;
import com.android.server.backup.utils.BackupManagerMonitorUtils;
import libcore.io.IoUtils;
@@ -186,7 +186,8 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask {
int pmToken,
boolean isFullSystemRestore,
@Nullable String[] filterSet,
OnTaskFinishedListener listener) {
OnTaskFinishedListener listener,
BackupEligibilityRules backupEligibilityRules) {
this.backupManagerService = backupManagerService;
mUserId = backupManagerService.getUserId();
mTransportManager = backupManagerService.getTransportManager();
@@ -218,7 +219,8 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask {
// We want everything and a pony
List<PackageInfo> apps =
PackageManagerBackupAgent.getStorableApplications(
backupManagerService.getPackageManager(), mUserId);
backupManagerService.getPackageManager(), mUserId,
backupEligibilityRules);
filterSet = packagesToNames(apps);
if (DEBUG) {
Slog.i(TAG, "Full restore; asking about " + filterSet.length + " apps");
@@ -245,7 +247,7 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask {
continue;
}
if (AppBackupUtils.appIsEligibleForBackup(info.applicationInfo, mUserId)) {
if (backupEligibilityRules.appIsEligibleForBackup(info.applicationInfo)) {
mAcceptSet.add(info);
}
} catch (NameNotFoundException e) {

4
services/backup/java/com/android/server/backup/utils/RestoreUtils.java
View File

@@ -159,7 +159,9 @@ public class RestoreUtils {
Signature[] sigs = manifestSignatures.get(info.packageName);
PackageManagerInternal pmi = LocalServices.getService(
PackageManagerInternal.class);
if (AppBackupUtils.signaturesMatch(sigs, pkg, pmi)) {
BackupEligibilityRules eligibilityRules =
BackupEligibilityRules.forBackup(packageManager, pmi, userId);
if (eligibilityRules.signaturesMatch(sigs, pkg)) {
// If this is a system-uid app without a declared backup agent,
// don't restore any of the file data.
if (UserHandle.isCore(pkg.applicationInfo.uid)

5
services/backup/java/com/android/server/backup/utils/TarBackupReader.java
View File

@@ -394,7 +394,8 @@ public class TarBackupReader {
}
RestorePolicy policy = RestorePolicy.IGNORE;
BackupEligibilityRules eligibilityRules = BackupEligibilityRules.forBackup(packageManager,
pmi, userId);
// Okay, got the manifest info we need...
try {
PackageInfo pkgInfo = packageManager.getPackageInfoAsUser(
@@ -413,7 +414,7 @@ public class TarBackupReader {
// such packages are signed with the platform cert instead of
// the app developer's cert, so they're different on every
// device.
if (AppBackupUtils.signaturesMatch(signatures, pkgInfo, pmi)) {
if (eligibilityRules.signaturesMatch(signatures, pkgInfo)) {
if ((pkgInfo.applicationInfo.flags
& ApplicationInfo.FLAG_RESTORE_ANY_VERSION) != 0) {
Slog.i(TAG, "Package has restoreAnyVersion; taking data");

78
services/robotests/src/com/android/server/testing/shadows/ShadowBackupEligibilityRules.java Normal file
View File

@@ -0,0 +1,78 @@
/*
* Copyright (C) 2018 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.testing.shadows;
import android.annotation.Nullable;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import com.android.server.backup.transport.TransportClient;
import com.android.server.backup.utils.BackupEligibilityRules;
import org.robolectric.annotation.Implementation;
import org.robolectric.annotation.Implements;
import org.robolectric.annotation.Resetter;
import java.util.HashSet;
import java.util.Set;
@Implements(BackupEligibilityRules.class)
public class ShadowBackupEligibilityRules {
private static final Set<String> sAppsRunningAndEligibleForBackupWithTransport =
new HashSet<>();
private static final Set<String> sAppsEligibleForBackup = new HashSet<>();
private static final Set<String> sAppsGetFullBackup = new HashSet<>();
public static void setAppRunningAndEligibleForBackupWithTransport(String packageName) {
sAppsEligibleForBackup.add(packageName);
sAppsRunningAndEligibleForBackupWithTransport.add(packageName);
}
public static void setAppEligibleForBackup(String packageName) {
sAppsEligibleForBackup.add(packageName);
}
/** By default the app will be key-value. */
public static void setAppGetsFullBackup(String packageName) {
sAppsGetFullBackup.add(packageName);
}
@Implementation
protected boolean appIsRunningAndEligibleForBackupWithTransport(
@Nullable TransportClient transportClient,
String packageName) {
return sAppsRunningAndEligibleForBackupWithTransport.contains(packageName);
}
@Implementation
protected boolean appIsEligibleForBackup(ApplicationInfo app) {
return sAppsEligibleForBackup.contains(app.packageName);
}
@Implementation
protected boolean appGetsFullBackup(PackageInfo packageInfo) {
return sAppsGetFullBackup.contains(packageInfo.packageName);
}
@Resetter
public static void reset() {
sAppsRunningAndEligibleForBackupWithTransport.clear();
sAppsEligibleForBackup.clear();
sAppsGetFullBackup.clear();
}
}

52
services/tests/servicestests/src/com/android/server/backup/UserBackupManagerServiceTest.java
View File

@@ -18,6 +18,7 @@ package com.android.server.backup;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.when;
@@ -36,6 +37,7 @@ import androidx.test.runner.AndroidJUnit4;
import com.android.server.backup.internal.OnTaskFinishedListener;
import com.android.server.backup.params.BackupParams;
import com.android.server.backup.transport.TransportClient;
import com.android.server.backup.utils.BackupEligibilityRules;
import org.junit.Before;
import org.junit.Test;
@@ -54,6 +56,7 @@ public class UserBackupManagerServiceTest {
@Mock IBackupObserver mBackupObserver;
@Mock PackageManager mPackageManager;
@Mock TransportClient mTransportClient;
@Mock BackupEligibilityRules mBackupEligibilityRules;
private TestBackupService mService;
@@ -82,54 +85,51 @@ public class UserBackupManagerServiceTest {
}
@Test
public void getRequestBackupParams_isMigrationAndAppGetsFullBackup() throws Exception {
public void getRequestBackupParams_appIsEligibleForFullBackup() throws Exception {
when(mPackageManager.getPackageInfoAsUser(anyString(), anyInt(), anyInt())).thenReturn(
getPackageInfo(TEST_PACKAGE));
mService.mAppIsEligibleForBackup = true;
mService.mAppGetsFullBackup = true;
when(mBackupEligibilityRules.appIsEligibleForBackup(any())).thenReturn(true);
when(mBackupEligibilityRules.appGetsFullBackup(any())).thenReturn(true);
BackupParams params = mService.getRequestBackupParams(TEST_PACKAGES, mBackupObserver,
mBackupManagerMonitor, /* flags */ 0, OperationType.MIGRATION,
mBackupManagerMonitor, /* flags */ 0, mBackupEligibilityRules,
mTransportClient, /* transportDirName */ "", OnTaskFinishedListener.NOP);
assertThat(params.kvPackages).isEmpty();
assertThat(params.fullPackages).contains(TEST_PACKAGE);
assertThat(params.operationType).isEqualTo(OperationType.MIGRATION);
assertThat(mService.mOperationType).isEqualTo(OperationType.MIGRATION);
assertThat(params.mBackupEligibilityRules).isEqualTo(mBackupEligibilityRules);
}
@Test
public void getRequestBackupParams_isMigrationAndAppGetsKeyValueBackup() throws Exception {
public void getRequestBackupParams_appIsEligibleForKeyValueBackup() throws Exception {
when(mPackageManager.getPackageInfoAsUser(anyString(), anyInt(), anyInt())).thenReturn(
getPackageInfo(TEST_PACKAGE));
mService.mAppIsEligibleForBackup = true;
mService.mAppGetsFullBackup = false;
when(mBackupEligibilityRules.appIsEligibleForBackup(any())).thenReturn(true);
when(mBackupEligibilityRules.appGetsFullBackup(any())).thenReturn(false);
BackupParams params = mService.getRequestBackupParams(TEST_PACKAGES, mBackupObserver,
mBackupManagerMonitor, /* flags */ 0, OperationType.MIGRATION,
mBackupManagerMonitor, /* flags */ 0, mBackupEligibilityRules,
mTransportClient, /* transportDirName */ "", OnTaskFinishedListener.NOP);
assertThat(params.kvPackages).contains(TEST_PACKAGE);
assertThat(params.fullPackages).isEmpty();
assertThat(params.operationType).isEqualTo(OperationType.MIGRATION);
assertThat(mService.mOperationType).isEqualTo(OperationType.MIGRATION);
assertThat(params.mBackupEligibilityRules).isEqualTo(mBackupEligibilityRules);
}
@Test
public void getRequestBackupParams_isMigrationAndAppNotEligibleForBackup() throws Exception {
public void getRequestBackupParams_appIsNotEligibleForBackup() throws Exception {
when(mPackageManager.getPackageInfoAsUser(anyString(), anyInt(), anyInt())).thenReturn(
getPackageInfo(TEST_PACKAGE));
mService.mAppIsEligibleForBackup = false;
mService.mAppGetsFullBackup = false;
when(mBackupEligibilityRules.appIsEligibleForBackup(any())).thenReturn(false);
when(mBackupEligibilityRules.appGetsFullBackup(any())).thenReturn(false);
BackupParams params = mService.getRequestBackupParams(TEST_PACKAGES, mBackupObserver,
mBackupManagerMonitor, /* flags */ 0, OperationType.MIGRATION,
mBackupManagerMonitor, /* flags */ 0, mBackupEligibilityRules,
mTransportClient, /* transportDirName */ "", OnTaskFinishedListener.NOP);
assertThat(params.kvPackages).isEmpty();
assertThat(params.fullPackages).isEmpty();
assertThat(params.operationType).isEqualTo(OperationType.MIGRATION);
assertThat(mService.mOperationType).isEqualTo(OperationType.MIGRATION);
assertThat(params.mBackupEligibilityRules).isEqualTo(mBackupEligibilityRules);
}
private static PackageInfo getPackageInfo(String packageName) {
@@ -141,9 +141,6 @@ public class UserBackupManagerServiceTest {
private static class TestBackupService extends UserBackupManagerService {
boolean isEnabledStatePersisted = false;
boolean mAppIsEligibleForBackup = false;
boolean mAppGetsFullBackup = false;
int mOperationType = 0;
TestBackupService(Context context, PackageManager packageManager) {
super(context, packageManager);
@@ -161,18 +158,5 @@ public class UserBackupManagerServiceTest {
@Override
void updateStateOnBackupEnabled(boolean wasEnabled, boolean enable) {}
@Override
boolean appIsEligibleForBackup(ApplicationInfo applicationInfo, int userId,
@OperationType int operationType) {
mOperationType = operationType;
return mAppIsEligibleForBackup;
}
@Override
boolean appGetsFullBackup(PackageInfo packageInfo, @OperationType int operationType) {
mOperationType = operationType;
return mAppGetsFullBackup;
}
}
}