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

Commit 9a724ed0 authored by Ruslan Tkhakokhov's avatar Ruslan Tkhakokhov
Browse files

Migrate usages of AppBackupUtils to BackupEligibilityRules 

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
parent b0a213ef

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;

            }