Move backup operations to Trampoline (b6bc6e2f) · Commits · e / os / android_frameworks_base

services/backup/java/com/android/server/backup/BackupManagerService.java

+0 −114

Original line number	Original line	Diff line number	Diff line
	@@ -20,14 +20,8 @@ import static com.android.internal.util.Preconditions.checkNotNull;

	import android.annotation.Nullable;		import android.annotation.Nullable;
	import android.annotation.UserIdInt;		import android.annotation.UserIdInt;
	import android.app.backup.BackupManager;
	import android.app.backup.IBackupManagerMonitor;
	import android.app.backup.IBackupObserver;
	import android.app.backup.IFullBackupRestoreObserver;		import android.app.backup.IFullBackupRestoreObserver;
	import android.app.backup.IRestoreSession;		import android.app.backup.IRestoreSession;
	import android.app.job.JobParameters;
	import android.app.job.JobScheduler;
	import android.app.job.JobService;
	import android.content.Context;		import android.content.Context;
	import android.content.pm.PackageManager;		import android.content.pm.PackageManager;
	import android.os.IBinder;		import android.os.IBinder;
	@@ -98,114 +92,6 @@ public class BackupManagerService {
	*/		*/
	// TODO (b/118520567): Stop hardcoding system user when we pass in user id as a parameter		// TODO (b/118520567): Stop hardcoding system user when we pass in user id as a parameter

	// ---------------------------------------------
	// BACKUP OPERATIONS
	// ---------------------------------------------

	/** Checks if the given package {@code packageName} is eligible for backup. */
	public boolean isAppEligibleForBackup(@UserIdInt int userId, String packageName) {
	UserBackupManagerService userBackupManagerService =
	getServiceForUserIfCallerHasPermission(userId, "isAppEligibleForBackup()");

	return userBackupManagerService != null
	&& userBackupManagerService.isAppEligibleForBackup(packageName);
	}

	/**
	* Returns from the inputted packages {@code packages}, the ones that are eligible for backup.
	*/
	@Nullable
	public String[] filterAppsEligibleForBackup(@UserIdInt int userId, String[] packages) {
	UserBackupManagerService userBackupManagerService =
	getServiceForUserIfCallerHasPermission(userId, "filterAppsEligibleForBackup()");

	return userBackupManagerService == null
	? null
	: userBackupManagerService.filterAppsEligibleForBackup(packages);
	}

	/**
	* Run a backup pass immediately for any key-value backup applications that have declared that
	* they have pending updates.
	*/
	public void backupNow(@UserIdInt int userId) {
	UserBackupManagerService userBackupManagerService =
	getServiceForUserIfCallerHasPermission(userId, "backupNow()");

	if (userBackupManagerService != null) {
	userBackupManagerService.backupNow();
	}
	}

	/**
	* Requests a backup for the inputted {@code packages} with a specified callback {@link
	* IBackupManagerMonitor} for receiving events during the operation.
	*/
	public int requestBackup(
	@UserIdInt int userId,
	String[] packages,
	IBackupObserver observer,
	IBackupManagerMonitor monitor,
	int flags) {
	UserBackupManagerService userBackupManagerService =
	getServiceForUserIfCallerHasPermission(userId, "requestBackup()");

	return userBackupManagerService == null
	? BackupManager.ERROR_BACKUP_NOT_ALLOWED
	: userBackupManagerService.requestBackup(packages, observer, monitor, flags);
	}

	/** Cancel all running backup operations. */
	public void cancelBackups(@UserIdInt int userId) {
	UserBackupManagerService userBackupManagerService =
	getServiceForUserIfCallerHasPermission(userId, "cancelBackups()");

	if (userBackupManagerService != null) {
	userBackupManagerService.cancelBackups();
	}
	}

	/**
	* Used by the {@link JobScheduler} to run a full backup when conditions are right. The model we
	* use is to perform one app backup per scheduled job execution, and to reschedule the job with
	* zero latency as long as conditions remain right and we still have work to do.
	*
	* @return Whether ongoing work will continue. The return value here will be passed along as the
	* return value to the callback {@link JobService#onStartJob(JobParameters)}.
	*/
	public boolean beginFullBackup(@UserIdInt int userId, FullBackupJob scheduledJob) {
	UserBackupManagerService userBackupManagerService =
	getServiceForUserIfCallerHasPermission(userId, "beginFullBackup()");

	return userBackupManagerService != null
	&& userBackupManagerService.beginFullBackup(scheduledJob);
	}

	/**
	* Used by the {@link JobScheduler} to end the current full backup task when conditions are no
	* longer met for running the full backup job.
	*/
	public void endFullBackup(@UserIdInt int userId) {
	UserBackupManagerService userBackupManagerService =
	getServiceForUserIfCallerHasPermission(userId, "endFullBackup()");

	if (userBackupManagerService != null) {
	userBackupManagerService.endFullBackup();
	}
	}

	/**
	* Run a full backup pass for the given packages {@code packageNames}. Used by 'adb shell bmgr'.
	*/
	public void fullTransportBackup(@UserIdInt int userId, String[] packageNames) {
	UserBackupManagerService userBackupManagerService =
	getServiceForUserIfCallerHasPermission(userId, "fullTransportBackup()");

	if (userBackupManagerService != null) {
	userBackupManagerService.fullTransportBackup(packageNames);
	}
	}

	// ---------------------------------------------		// ---------------------------------------------
	// RESTORE OPERATIONS		// RESTORE OPERATIONS
	// ---------------------------------------------		// ---------------------------------------------

services/backup/java/com/android/server/backup/Trampoline.java

+115 −15

Original line number	Original line	Diff line number	Diff line
	@@ -33,6 +33,9 @@ import android.app.backup.IBackupObserver;
	import android.app.backup.IFullBackupRestoreObserver;		import android.app.backup.IFullBackupRestoreObserver;
	import android.app.backup.IRestoreSession;		import android.app.backup.IRestoreSession;
	import android.app.backup.ISelectBackupTransportCallback;		import android.app.backup.ISelectBackupTransportCallback;
			import android.app.job.JobParameters;
			import android.app.job.JobScheduler;
			import android.app.job.JobService;
	import android.content.BroadcastReceiver;		import android.content.BroadcastReceiver;
	import android.content.ComponentName;		import android.content.ComponentName;
	import android.content.Context;		import android.content.Context;
	@@ -720,7 +723,7 @@ public class Trampoline extends IBackupManager.Stub {
	@Override		@Override
	public void backupNowForUser(@UserIdInt int userId) throws RemoteException {		public void backupNowForUser(@UserIdInt int userId) throws RemoteException {
	if (isUserReadyForBackup(userId)) {		if (isUserReadyForBackup(userId)) {
	mService.backupNow(userId);		backupNow(userId);
	}		}
	}		}

	@@ -729,6 +732,19 @@ public class Trampoline extends IBackupManager.Stub {
	backupNowForUser(binderGetCallingUserId());		backupNowForUser(binderGetCallingUserId());
	}		}

			/**
			* Run a backup pass immediately for any key-value backup applications that have declared that
			* they have pending updates.
			*/
			public void backupNow(@UserIdInt int userId) {
			UserBackupManagerService userBackupManagerService =
			getServiceForUserIfCallerHasPermission(userId, "backupNow()");

			if (userBackupManagerService != null) {
			userBackupManagerService.backupNow();
			}
			}

	public void adbBackup(@UserIdInt int userId, ParcelFileDescriptor fd,		public void adbBackup(@UserIdInt int userId, ParcelFileDescriptor fd,
	boolean includeApks, boolean includeObbs, boolean includeShared, boolean doWidgets,		boolean includeApks, boolean includeObbs, boolean includeShared, boolean doWidgets,
	boolean allApps, boolean allIncludesSystem, boolean doCompress, boolean doKeyValue,		boolean allApps, boolean allIncludesSystem, boolean doCompress, boolean doKeyValue,
	@@ -743,7 +759,19 @@ public class Trampoline extends IBackupManager.Stub {
	public void fullTransportBackupForUser(int userId, String[] packageNames)		public void fullTransportBackupForUser(int userId, String[] packageNames)
	throws RemoteException {		throws RemoteException {
	if (isUserReadyForBackup(userId)) {		if (isUserReadyForBackup(userId)) {
	mService.fullTransportBackup(userId, packageNames);		fullTransportBackup(userId, packageNames);
			}
			}

			/**
			* Run a full backup pass for the given packages {@code packageNames}. Used by 'adb shell bmgr'.
			*/
			public void fullTransportBackup(@UserIdInt int userId, String[] packageNames) {
			UserBackupManagerService userBackupManagerService =
			getServiceForUserIfCallerHasPermission(userId, "fullTransportBackup()");

			if (userBackupManagerService != null) {
			userBackupManagerService.fullTransportBackup(packageNames);
	}		}
	}		}

	@@ -1147,14 +1175,35 @@ public class Trampoline extends IBackupManager.Stub {

	@Override		@Override
	public boolean isAppEligibleForBackupForUser(int userId, String packageName) {		public boolean isAppEligibleForBackupForUser(int userId, String packageName) {
	return isUserReadyForBackup(userId) && mService.isAppEligibleForBackup(userId,		return isUserReadyForBackup(userId) && isAppEligibleForBackup(userId,
	packageName);		packageName);
	}		}

			/** Checks if the given package {@code packageName} is eligible for backup. */
			public boolean isAppEligibleForBackup(@UserIdInt int userId, String packageName) {
			UserBackupManagerService userBackupManagerService =
			getServiceForUserIfCallerHasPermission(userId, "isAppEligibleForBackup()");

			return userBackupManagerService != null
			&& userBackupManagerService.isAppEligibleForBackup(packageName);
			}

	@Override		@Override
	public String[] filterAppsEligibleForBackupForUser(int userId, String[] packages) {		public String[] filterAppsEligibleForBackupForUser(int userId, String[] packages) {
	return isUserReadyForBackup(userId) ? mService.filterAppsEligibleForBackup(userId,		return isUserReadyForBackup(userId) ? filterAppsEligibleForBackup(userId, packages) : null;
	packages) : null;		}

			/**
			* Returns from the inputted packages {@code packages}, the ones that are eligible for backup.
			*/
			@Nullable
			public String[] filterAppsEligibleForBackup(@UserIdInt int userId, String[] packages) {
			UserBackupManagerService userBackupManagerService =
			getServiceForUserIfCallerHasPermission(userId, "filterAppsEligibleForBackup()");

			return userBackupManagerService == null
			? null
			: userBackupManagerService.filterAppsEligibleForBackup(packages);
	}		}

	@Override		@Override
	@@ -1163,7 +1212,7 @@ public class Trampoline extends IBackupManager.Stub {
	if (!isUserReadyForBackup(userId)) {		if (!isUserReadyForBackup(userId)) {
	return BackupManager.ERROR_BACKUP_NOT_ALLOWED;		return BackupManager.ERROR_BACKUP_NOT_ALLOWED;
	}		}
	return mService.requestBackup(userId, packages, observer, monitor, flags);		return requestBackup(userId, packages, observer, monitor, flags);
	}		}

	@Override		@Override
	@@ -1173,10 +1222,28 @@ public class Trampoline extends IBackupManager.Stub {
	observer, monitor, flags);		observer, monitor, flags);
	}		}

			/**
			* Requests a backup for the inputted {@code packages} with a specified callback {@link
			* IBackupManagerMonitor} for receiving events during the operation.
			*/
			public int requestBackup(
			@UserIdInt int userId,
			String[] packages,
			IBackupObserver observer,
			IBackupManagerMonitor monitor,
			int flags) {
			UserBackupManagerService userBackupManagerService =
			getServiceForUserIfCallerHasPermission(userId, "requestBackup()");

			return userBackupManagerService == null
			? BackupManager.ERROR_BACKUP_NOT_ALLOWED
			: userBackupManagerService.requestBackup(packages, observer, monitor, flags);
			}

	@Override		@Override
	public void cancelBackupsForUser(@UserIdInt int userId) throws RemoteException {		public void cancelBackupsForUser(@UserIdInt int userId) throws RemoteException {
	if (isUserReadyForBackup(userId)) {		if (isUserReadyForBackup(userId)) {
	mService.cancelBackups(userId);		cancelBackups(userId);
	}		}
	}		}

	@@ -1185,9 +1252,19 @@ public class Trampoline extends IBackupManager.Stub {
	cancelBackupsForUser(binderGetCallingUserId());		cancelBackupsForUser(binderGetCallingUserId());
	}		}

			/** Cancel all running backup operations. */
			public void cancelBackups(@UserIdInt int userId) {
			UserBackupManagerService userBackupManagerService =
			getServiceForUserIfCallerHasPermission(userId, "cancelBackups()");

			if (userBackupManagerService != null) {
			userBackupManagerService.cancelBackups();
			}
			}

	/**		/**
	* Returns a {@link UserHandle} for the user that has {@code ancestralSerialNumber} as the		* Returns a {@link UserHandle} for the user that has {@code ancestralSerialNumber} as the
	* serial number of the its ancestral work profile or null if there is no {@link		* serial number of its ancestral work profile or null if there is no {@link
	* UserBackupManagerService} associated with that user.		* UserBackupManagerService} associated with that user.
	*		*
	* <p> The ancestral work profile is set by {@link #setAncestralSerialNumber(long)}		* <p> The ancestral work profile is set by {@link #setAncestralSerialNumber(long)}
	@@ -1255,15 +1332,38 @@ public class Trampoline extends IBackupManager.Stub {
	}		}
	}		}

	// Full backup/restore entry points - non-Binder; called directly		/**
	// by the full-backup scheduled job		* Used by the {@link JobScheduler} to run a full backup when conditions are right. The model we
	/* package */ boolean beginFullBackup(@UserIdInt int userId, FullBackupJob scheduledJob) {		* use is to perform one app backup per scheduled job execution, and to reschedule the job with
	return (isUserReadyForBackup(userId)) && mService.beginFullBackup(userId, scheduledJob);		* zero latency as long as conditions remain right and we still have work to do.
			*
			* @return Whether ongoing work will continue. The return value here will be passed along as the
			* return value to the callback {@link JobService#onStartJob(JobParameters)}.
			*/
			public boolean beginFullBackup(@UserIdInt int userId, FullBackupJob scheduledJob) {
			if (!isUserReadyForBackup(userId)) {
			return false;
			}
			UserBackupManagerService userBackupManagerService =
			getServiceForUserIfCallerHasPermission(userId, "beginFullBackup()");

			return userBackupManagerService != null
			&& userBackupManagerService.beginFullBackup(scheduledJob);
			}

			/**
			* Used by the {@link JobScheduler} to end the current full backup task when conditions are no
			* longer met for running the full backup job.
			*/
			public void endFullBackup(@UserIdInt int userId) {
			if (!isUserReadyForBackup(userId)) {
			return;
	}		}
			UserBackupManagerService userBackupManagerService =
			getServiceForUserIfCallerHasPermission(userId, "endFullBackup()");

	/* package */ void endFullBackup(@UserIdInt int userId) {		if (userBackupManagerService != null) {
	if (isUserReadyForBackup(userId)) {		userBackupManagerService.endFullBackup();
	mService.endFullBackup(userId);
	}		}
	}		}

services/robotests/backup/src/com/android/server/backup/BackupManagerServiceTest.java

+0 −306

File changed.

Preview size limit exceeded, changes collapsed.

services/robotests/backup/src/com/android/server/backup/TrampolineRoboTest.java

+305 −0

File changed.

Preview size limit exceeded, changes collapsed.

services/tests/servicestests/src/com/android/server/backup/TrampolineTest.java

+0 −89

Original line number	Original line	Diff line number	Diff line
	@@ -510,23 +510,6 @@ public class TrampolineTest {
	verify(mBackupManagerServiceMock).hasBackupPassword();		verify(mBackupManagerServiceMock).hasBackupPassword();
	}		}

	@Test
	public void backupNowForUser_forwarded() throws Exception {

	mTrampoline.backupNowForUser(mUserId);

	verify(mBackupManagerServiceMock).backupNow(mUserId);
	}

	@Test
	public void backupNow_forwardedToCallingUserId() throws Exception {
	TrampolineTestable.sCallingUserId = mUserId;

	mTrampoline.backupNow();

	verify(mBackupManagerServiceMock).backupNow(mUserId);
	}

	@Test		@Test
	public void adbBackup_forwarded() throws Exception {		public void adbBackup_forwarded() throws Exception {
	mTrampoline.adbBackup(mUserId, mParcelFileDescriptorMock, true, true,		mTrampoline.adbBackup(mUserId, mParcelFileDescriptorMock, true, true,
	@@ -536,14 +519,6 @@ public class TrampolineTest {
	true, true, true, true, true, true, true, PACKAGE_NAMES);		true, true, true, true, true, true, true, PACKAGE_NAMES);
	}		}

	@Test
	public void fullTransportBackupForUser_forwarded() throws Exception {

	mTrampoline.fullTransportBackupForUser(mUserId, PACKAGE_NAMES);

	verify(mBackupManagerServiceMock).fullTransportBackup(mUserId, PACKAGE_NAMES);
	}

	@Test		@Test
	public void adbRestore_forwarded() throws Exception {		public void adbRestore_forwarded() throws Exception {
	mTrampoline.adbRestore(mUserId, mParcelFileDescriptorMock);		mTrampoline.adbRestore(mUserId, mParcelFileDescriptorMock);
	@@ -646,70 +621,6 @@ public class TrampolineTest {
	verify(mBackupManagerServiceMock).getAvailableRestoreToken(mUserId, PACKAGE_NAME);		verify(mBackupManagerServiceMock).getAvailableRestoreToken(mUserId, PACKAGE_NAME);
	}		}

	@Test
	public void isAppEligibleForBackupForUser_forwarded() {
	when(mBackupManagerServiceMock.isAppEligibleForBackup(mUserId, PACKAGE_NAME))
	.thenReturn(true);

	assertTrue(mTrampoline.isAppEligibleForBackupForUser(mUserId, PACKAGE_NAME));
	verify(mBackupManagerServiceMock).isAppEligibleForBackup(mUserId, PACKAGE_NAME);
	}

	@Test
	public void requestBackupForUser_forwarded() throws Exception {
	when(mBackupManagerServiceMock.requestBackup(mUserId, PACKAGE_NAMES,
	mBackupObserverMock, mBackupManagerMonitorMock, 123)).thenReturn(456);

	assertEquals(456, mTrampoline.requestBackupForUser(mUserId, PACKAGE_NAMES,
	mBackupObserverMock, mBackupManagerMonitorMock, 123));
	verify(mBackupManagerServiceMock).requestBackup(mUserId, PACKAGE_NAMES,
	mBackupObserverMock, mBackupManagerMonitorMock, 123);
	}

	@Test
	public void requestBackup_forwardedToCallingUserId() throws Exception {
	TrampolineTestable.sCallingUserId = mUserId;
	when(mBackupManagerServiceMock.requestBackup(mUserId, PACKAGE_NAMES,
	mBackupObserverMock, mBackupManagerMonitorMock, 123)).thenReturn(456);

	assertEquals(456, mTrampoline.requestBackup(PACKAGE_NAMES,
	mBackupObserverMock, mBackupManagerMonitorMock, 123));
	verify(mBackupManagerServiceMock).requestBackup(mUserId, PACKAGE_NAMES,
	mBackupObserverMock, mBackupManagerMonitorMock, 123);
	}

	@Test
	public void cancelBackupsForUser_forwarded() throws Exception {

	mTrampoline.cancelBackupsForUser(mUserId);

	verify(mBackupManagerServiceMock).cancelBackups(mUserId);
	}

	@Test
	public void cancelBackups_forwardedToCallingUserId() throws Exception {
	TrampolineTestable.sCallingUserId = mUserId;

	mTrampoline.cancelBackups();

	verify(mBackupManagerServiceMock).cancelBackups(mUserId);
	}

	@Test
	public void beginFullBackup_forwarded() throws Exception {
	FullBackupJob fullBackupJob = new FullBackupJob();
	when(mBackupManagerServiceMock.beginFullBackup(mUserId, fullBackupJob)).thenReturn(true);

	assertTrue(mTrampoline.beginFullBackup(mUserId, fullBackupJob));
	verify(mBackupManagerServiceMock).beginFullBackup(mUserId, fullBackupJob);
	}

	@Test
	public void endFullBackup_forwarded() {
	mTrampoline.endFullBackup(mUserId);
	verify(mBackupManagerServiceMock).endFullBackup(mUserId);
	}

	@Test		@Test
	public void dump_callerDoesNotHavePermission_ignored() {		public void dump_callerDoesNotHavePermission_ignored() {
	when(mContextMock.checkCallingOrSelfPermission(		when(mContextMock.checkCallingOrSelfPermission(