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

Commit 25ec4f68 authored by Ruslan Tkhakokhov's avatar Ruslan Tkhakokhov Committed by Android (Google) Code Review
Browse files

Merge changes from topic "backup-eligibility" 

* changes:
  Update robolectric tetst for BackupEligibilityRules refactor
  Migrate usages of AppBackupUtils to BackupEligibilityRules
  Refactor AppBackupUtils into BackupEligibilityRules
parents 84327831 9a747776

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

+9 −7
Original line number Diff line number Diff line
@@ -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);

            }

        }

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

+55 −40
Original line number Diff line number Diff line
@@ -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();

services/backup/java/com/android/server/backup/fullbackup/PerformAdbBackupTask.java

+10 −6
Original line number Diff line number Diff line
@@ -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

services/backup/java/com/android/server/backup/fullbackup/PerformFullTransportBackupTask.java

+11 −7
Original line number Diff line number Diff line
@@ -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.

services/backup/java/com/android/server/backup/internal/BackupHandler.java

+12 −4
Original line number Diff line number Diff line
@@ -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;

            }