Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit b6bc6e2f authored by Bernardo Rufino's avatar Bernardo Rufino
Browse files

Move backup operations to Trampoline

From BMS.

Test: atest BackupManagerServiceTest TrampolineRoboTest TrampolineTest
Bug: 135661048
Change-Id: Ia44b7b839c2f871535e18d648be49277b46e3b11
parent 7dedc861
Loading
Loading
Loading
Loading
+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
    // ---------------------------------------------
    // ---------------------------------------------
+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);
        }
        }
    }
    }


+0 −306

File changed.

Preview size limit exceeded, changes collapsed.

+305 −0

File changed.

Preview size limit exceeded, changes collapsed.

+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(