diff options
17 files changed, 479 insertions, 244 deletions
diff --git a/services/backup/java/com/android/server/backup/RefactoredBackupManagerService.java b/services/backup/java/com/android/server/backup/RefactoredBackupManagerService.java index 02dc0623a45c..677efd0d6de3 100644 --- a/services/backup/java/com/android/server/backup/RefactoredBackupManagerService.java +++ b/services/backup/java/com/android/server/backup/RefactoredBackupManagerService.java @@ -255,26 +255,26 @@ public class RefactoredBackupManagerService implements BackupManagerServiceInter private static final long BUSY_BACKOFF_MIN_MILLIS = 1000 * 60 * 60; // one hour private static final int BUSY_BACKOFF_FUZZ = 1000 * 60 * 60 * 2; // two hours - public Context mContext; - public PackageManager mPackageManager; - public IPackageManager mPackageManagerBinder; - public IActivityManager mActivityManager; + private Context mContext; + private PackageManager mPackageManager; + private IPackageManager mPackageManagerBinder; + private IActivityManager mActivityManager; private PowerManager mPowerManager; - public AlarmManager mAlarmManager; + private AlarmManager mAlarmManager; private IStorageManager mStorageManager; - public IBackupManager mBackupManagerBinder; + private IBackupManager mBackupManagerBinder; - public final TransportManager mTransportManager; + private final TransportManager mTransportManager; - public boolean mEnabled; // access to this is synchronized on 'this' - public boolean mProvisioned; + private boolean mEnabled; // access to this is synchronized on 'this' + private boolean mProvisioned; private boolean mAutoRestore; - public PowerManager.WakeLock mWakelock; + private PowerManager.WakeLock mWakelock; private HandlerThread mHandlerThread; - public BackupHandler mBackupHandler; + private BackupHandler mBackupHandler; private PendingIntent mRunBackupIntent; - public PendingIntent mRunInitIntent; + private PendingIntent mRunInitIntent; private BroadcastReceiver mRunBackupReceiver; private BroadcastReceiver mRunInitReceiver; // map UIDs to the set of participating packages under that UID @@ -282,14 +282,14 @@ public class RefactoredBackupManagerService implements BackupManagerServiceInter = new SparseArray<>(); // Backups that we haven't started yet. Keys are package names. - public HashMap<String, BackupRequest> mPendingBackups + private HashMap<String, BackupRequest> mPendingBackups = new HashMap<>(); // Pseudoname that we use for the Package Manager metadata "package" public static final String PACKAGE_MANAGER_SENTINEL = "@pm@"; // locking around the pending-backup management - public final Object mQueueLock = new Object(); + private final Object mQueueLock = new Object(); // The thread performing the sequence of queued backups binds to each app's agent // in succession. Bind notifications are asynchronously delivered through the @@ -297,24 +297,24 @@ public class RefactoredBackupManagerService implements BackupManagerServiceInter // completed. private final Object mAgentConnectLock = new Object(); private IBackupAgent mConnectedAgent; - public volatile boolean mBackupRunning; + private volatile boolean mBackupRunning; private volatile boolean mConnecting; - public volatile long mLastBackupPass; + private volatile long mLastBackupPass; // For debugging, we maintain a progress trace of operations during backup public static final boolean DEBUG_BACKUP_TRACE = true; private final List<String> mBackupTrace = new ArrayList<>(); // A similar synchronization mechanism around clearing apps' data for restore - public final Object mClearDataLock = new Object(); - public volatile boolean mClearingData; + private final Object mClearDataLock = new Object(); + private volatile boolean mClearingData; @GuardedBy("mPendingRestores") - public boolean mIsRestoreInProgress; + private boolean mIsRestoreInProgress; @GuardedBy("mPendingRestores") - public final Queue<PerformUnifiedRestoreTask> mPendingRestores = new ArrayDeque<>(); + private final Queue<PerformUnifiedRestoreTask> mPendingRestores = new ArrayDeque<>(); - public ActiveRestoreSession mActiveRestoreSession; + private ActiveRestoreSession mActiveRestoreSession; // Watch the device provisioning operation during setup private ContentObserver mProvisionedObserver; @@ -330,6 +330,237 @@ public class RefactoredBackupManagerService implements BackupManagerServiceInter return sInstance; } + public Context getContext() { + return mContext; + } + + public void setContext(Context context) { + mContext = context; + } + + public PackageManager getPackageManager() { + return mPackageManager; + } + + public void setPackageManager(PackageManager packageManager) { + mPackageManager = packageManager; + } + + public IPackageManager getPackageManagerBinder() { + return mPackageManagerBinder; + } + + public void setPackageManagerBinder(IPackageManager packageManagerBinder) { + mPackageManagerBinder = packageManagerBinder; + } + + public IActivityManager getActivityManager() { + return mActivityManager; + } + + public void setActivityManager(IActivityManager activityManager) { + mActivityManager = activityManager; + } + + public AlarmManager getAlarmManager() { + return mAlarmManager; + } + + public void setAlarmManager(AlarmManager alarmManager) { + mAlarmManager = alarmManager; + } + + public void setBackupManagerBinder(IBackupManager backupManagerBinder) { + mBackupManagerBinder = backupManagerBinder; + } + + public TransportManager getTransportManager() { + return mTransportManager; + } + + public boolean isEnabled() { + return mEnabled; + } + + public void setEnabled(boolean enabled) { + mEnabled = enabled; + } + + public boolean isProvisioned() { + return mProvisioned; + } + + public void setProvisioned(boolean provisioned) { + mProvisioned = provisioned; + } + + public PowerManager.WakeLock getWakelock() { + return mWakelock; + } + + public void setWakelock(PowerManager.WakeLock wakelock) { + mWakelock = wakelock; + } + + public BackupHandler getBackupHandler() { + return mBackupHandler; + } + + public void setBackupHandler(BackupHandler backupHandler) { + mBackupHandler = backupHandler; + } + + public PendingIntent getRunInitIntent() { + return mRunInitIntent; + } + + public void setRunInitIntent(PendingIntent runInitIntent) { + mRunInitIntent = runInitIntent; + } + + public HashMap<String, BackupRequest> getPendingBackups() { + return mPendingBackups; + } + + public void setPendingBackups( + HashMap<String, BackupRequest> pendingBackups) { + mPendingBackups = pendingBackups; + } + + public Object getQueueLock() { + return mQueueLock; + } + + public boolean isBackupRunning() { + return mBackupRunning; + } + + public void setBackupRunning(boolean backupRunning) { + mBackupRunning = backupRunning; + } + + public long getLastBackupPass() { + return mLastBackupPass; + } + + public void setLastBackupPass(long lastBackupPass) { + mLastBackupPass = lastBackupPass; + } + + public Object getClearDataLock() { + return mClearDataLock; + } + + public boolean isClearingData() { + return mClearingData; + } + + public void setClearingData(boolean clearingData) { + mClearingData = clearingData; + } + + public boolean isRestoreInProgress() { + return mIsRestoreInProgress; + } + + public void setRestoreInProgress(boolean restoreInProgress) { + mIsRestoreInProgress = restoreInProgress; + } + + public Queue<PerformUnifiedRestoreTask> getPendingRestores() { + return mPendingRestores; + } + + public ActiveRestoreSession getActiveRestoreSession() { + return mActiveRestoreSession; + } + + public void setActiveRestoreSession( + ActiveRestoreSession activeRestoreSession) { + mActiveRestoreSession = activeRestoreSession; + } + + public SparseArray<Operation> getCurrentOperations() { + return mCurrentOperations; + } + + public Object getCurrentOpLock() { + return mCurrentOpLock; + } + + public SparseArray<AdbParams> getAdbBackupRestoreConfirmations() { + return mAdbBackupRestoreConfirmations; + } + + public File getBaseStateDir() { + return mBaseStateDir; + } + + public void setBaseStateDir(File baseStateDir) { + mBaseStateDir = baseStateDir; + } + + public File getDataDir() { + return mDataDir; + } + + public void setDataDir(File dataDir) { + mDataDir = dataDir; + } + + public File getJournal() { + return mJournal; + } + + public void setJournal(File journal) { + mJournal = journal; + } + + public SecureRandom getRng() { + return mRng; + } + + public Set<String> getAncestralPackages() { + return mAncestralPackages; + } + + public void setAncestralPackages(Set<String> ancestralPackages) { + mAncestralPackages = ancestralPackages; + } + + public long getAncestralToken() { + return mAncestralToken; + } + + public void setAncestralToken(long ancestralToken) { + mAncestralToken = ancestralToken; + } + + public long getCurrentToken() { + return mCurrentToken; + } + + public void setCurrentToken(long currentToken) { + mCurrentToken = currentToken; + } + + public HashSet<String> getPendingInits() { + return mPendingInits; + } + + public void setPendingInits(HashSet<String> pendingInits) { + mPendingInits = pendingInits; + } + + public PerformFullTransportBackupTask getRunningFullBackupTask() { + return mRunningFullBackupTask; + } + + public void setRunningFullBackupTask( + PerformFullTransportBackupTask runningFullBackupTask) { + mRunningFullBackupTask = runningFullBackupTask; + } + public static final class Lifecycle extends SystemService { public Lifecycle(Context context) { @@ -415,17 +646,17 @@ public class RefactoredBackupManagerService implements BackupManagerServiceInter * cancel backup tasks. */ @GuardedBy("mCurrentOpLock") - public final SparseArray<Operation> mCurrentOperations = new SparseArray<>(); - public final Object mCurrentOpLock = new Object(); + private final SparseArray<Operation> mCurrentOperations = new SparseArray<>(); + private final Object mCurrentOpLock = new Object(); private final Random mTokenGenerator = new Random(); - public final SparseArray<AdbParams> mAdbBackupRestoreConfirmations = new SparseArray<>(); + private final SparseArray<AdbParams> mAdbBackupRestoreConfirmations = new SparseArray<>(); // Where we keep our journal files and other bookkeeping - public File mBaseStateDir; - public File mDataDir; + private File mBaseStateDir; + private File mDataDir; private File mJournalDir; - public File mJournal; + private File mJournal; // Backup password, if any, and the file where it's saved. What is stored is not the // password text itself; it's the result of a PBKDF2 hash with a randomly chosen (but @@ -433,7 +664,7 @@ public class RefactoredBackupManagerService implements BackupManagerServiceInter // same PBKDF2 cycle with the persisted salt; if the resulting derived key string matches // the saved hash string, then the challenge text matches the originally supplied // password text. - public final SecureRandom mRng = new SecureRandom(); + private final SecureRandom mRng = new SecureRandom(); private String mPasswordHash; private File mPasswordHashFile; private int mPasswordVersion; @@ -455,13 +686,13 @@ public class RefactoredBackupManagerService implements BackupManagerServiceInter private static final int CURRENT_ANCESTRAL_RECORD_VERSION = 1; // increment when the schema changes private File mTokenFile; - public Set<String> mAncestralPackages = null; - public long mAncestralToken = 0; - public long mCurrentToken = 0; + private Set<String> mAncestralPackages = null; + private long mAncestralToken = 0; + private long mCurrentToken = 0; // Persistently track the need to do a full init private static final String INIT_SENTINEL_FILE_NAME = "_need_init_"; - public HashSet<String> mPendingInits = new HashSet<>(); // transport names + private HashSet<String> mPendingInits = new HashSet<>(); // transport names // Round-robin queue for scheduling full backup passes private static final int SCHEDULE_FILE_VERSION = 1; // current version of the schedule file @@ -470,7 +701,7 @@ public class RefactoredBackupManagerService implements BackupManagerServiceInter // If we're running a schedule-driven full backup, this is the task instance doing it @GuardedBy("mQueueLock") - public PerformFullTransportBackupTask mRunningFullBackupTask; + private PerformFullTransportBackupTask mRunningFullBackupTask; @GuardedBy("mQueueLock") private ArrayList<FullBackupEntry> mFullBackupQueue; diff --git a/services/backup/java/com/android/server/backup/fullbackup/FullBackupEngine.java b/services/backup/java/com/android/server/backup/fullbackup/FullBackupEngine.java index 57cbbd0793e8..fbb7a127b95f 100644 --- a/services/backup/java/com/android/server/backup/fullbackup/FullBackupEngine.java +++ b/services/backup/java/com/android/server/backup/fullbackup/FullBackupEngine.java @@ -91,7 +91,7 @@ public class FullBackupEngine { "Writing manifest for " + mPackage.packageName); } RefactoredBackupManagerService - .writeAppManifest(mPackage, backupManagerService.mPackageManager, + .writeAppManifest(mPackage, backupManagerService.getPackageManager(), mManifestFile, mSendApk, writeWidgetData); FullBackup.backupToTar(mPackage.packageName, null, null, @@ -125,7 +125,7 @@ public class FullBackupEngine { mTimeoutMonitor /* in parent class */, RefactoredBackupManagerService.OP_TYPE_BACKUP_WAIT); mAgent.doFullBackup(mPipe, mQuota, mToken, - backupManagerService.mBackupManagerBinder); + backupManagerService.getBackupManagerBinder()); } catch (IOException e) { Slog.e(RefactoredBackupManagerService.TAG, "Error running full backup for " + mPackage.packageName); diff --git a/services/backup/java/com/android/server/backup/fullbackup/FullBackupObbConnection.java b/services/backup/java/com/android/server/backup/fullbackup/FullBackupObbConnection.java index 32b741a2e7b0..826db582f994 100644 --- a/services/backup/java/com/android/server/backup/fullbackup/FullBackupObbConnection.java +++ b/services/backup/java/com/android/server/backup/fullbackup/FullBackupObbConnection.java @@ -50,12 +50,12 @@ public class FullBackupObbConnection implements ServiceConnection { Intent obbIntent = new Intent().setComponent(new ComponentName( "com.android.sharedstoragebackup", "com.android.sharedstoragebackup.ObbBackupService")); - backupManagerService.mContext.bindServiceAsUser( + backupManagerService.getContext().bindServiceAsUser( obbIntent, this, Context.BIND_AUTO_CREATE, UserHandle.SYSTEM); } public void tearDown() { - backupManagerService.mContext.unbindService(this); + backupManagerService.getContext().unbindService(this); } public boolean backupObbs(PackageInfo pkg, OutputStream out) { @@ -71,7 +71,7 @@ public class FullBackupObbConnection implements ServiceConnection { RefactoredBackupManagerService.TIMEOUT_FULL_BACKUP_INTERVAL, null, RefactoredBackupManagerService.OP_TYPE_BACKUP_WAIT); mService.backupObbs(pkg.packageName, pipes[1], token, - backupManagerService.mBackupManagerBinder); + backupManagerService.getBackupManagerBinder()); RefactoredBackupManagerService.routeSocketDataToOutput(pipes[0], out); success = backupManagerService.waitUntilOperationComplete(token); } catch (Exception e) { diff --git a/services/backup/java/com/android/server/backup/fullbackup/PerformAdbBackupTask.java b/services/backup/java/com/android/server/backup/fullbackup/PerformAdbBackupTask.java index 9e02153fc1ac..174a38a52cac 100644 --- a/services/backup/java/com/android/server/backup/fullbackup/PerformAdbBackupTask.java +++ b/services/backup/java/com/android/server/backup/fullbackup/PerformAdbBackupTask.java @@ -118,7 +118,7 @@ public class PerformAdbBackupTask extends FullBackupTask implements BackupRestor for (String pkgName : pkgNames) { if (!set.containsKey(pkgName)) { try { - PackageInfo info = backupManagerService.mPackageManager.getPackageInfo(pkgName, + PackageInfo info = backupManagerService.getPackageManager().getPackageInfo(pkgName, PackageManager.GET_SIGNATURES); set.put(pkgName, info); } catch (NameNotFoundException e) { @@ -141,7 +141,7 @@ public class PerformAdbBackupTask extends FullBackupTask implements BackupRestor // the master key is random for each backup byte[] masterPw = new byte[256 / 8]; - backupManagerService.mRng.nextBytes(masterPw); + backupManagerService.getRng().nextBytes(masterPw); byte[] checksumSalt = backupManagerService .randomBytes(RefactoredBackupManagerService.PBKDF2_SALT_SIZE); @@ -233,7 +233,7 @@ public class PerformAdbBackupTask extends FullBackupTask implements BackupRestor // doAllApps supersedes the package set if any if (mAllApps) { List<PackageInfo> allPackages = - backupManagerService.mPackageManager.getInstalledPackages( + backupManagerService.getPackageManager().getInstalledPackages( PackageManager.GET_SIGNATURES); for (int i = 0; i < allPackages.size(); i++) { PackageInfo pkg = allPackages.get(i); @@ -387,7 +387,7 @@ public class PerformAdbBackupTask extends FullBackupTask implements BackupRestor // Shared storage if requested if (mIncludeShared) { try { - pkg = backupManagerService.mPackageManager.getPackageInfo( + pkg = backupManagerService.getPackageManager().getPackageInfo( RefactoredBackupManagerService.SHARED_BACKUP_AGENT_PACKAGE, 0); backupQueue.add(pkg); } catch (NameNotFoundException e) { @@ -437,9 +437,9 @@ public class PerformAdbBackupTask extends FullBackupTask implements BackupRestor KeyValueAdbBackupEngine kvBackupEngine = new KeyValueAdbBackupEngine(out, keyValuePackage, backupManagerService, - backupManagerService.mPackageManager, - backupManagerService.mBaseStateDir, - backupManagerService.mDataDir); + backupManagerService.getPackageManager(), + backupManagerService.getBaseStateDir(), + backupManagerService.getDataDir()); sendOnBackupPackage(keyValuePackage.packageName); kvBackupEngine.backupOnePackage(); } @@ -470,7 +470,7 @@ public class PerformAdbBackupTask extends FullBackupTask implements BackupRestor if (RefactoredBackupManagerService.DEBUG) { Slog.d(RefactoredBackupManagerService.TAG, "Full backup pass complete."); } - backupManagerService.mWakelock.release(); + backupManagerService.getWakelock().release(); } } diff --git a/services/backup/java/com/android/server/backup/fullbackup/PerformFullTransportBackupTask.java b/services/backup/java/com/android/server/backup/fullbackup/PerformFullTransportBackupTask.java index 97d323656771..0a728d715d22 100644 --- a/services/backup/java/com/android/server/backup/fullbackup/PerformFullTransportBackupTask.java +++ b/services/backup/java/com/android/server/backup/fullbackup/PerformFullTransportBackupTask.java @@ -129,7 +129,7 @@ public class PerformFullTransportBackupTask extends FullBackupTask implements Ba for (String pkg : whichPackages) { try { - PackageInfo info = backupManagerService.mPackageManager.getPackageInfo(pkg, + PackageInfo info = backupManagerService.getPackageManager().getPackageInfo(pkg, PackageManager.GET_SIGNATURES); mCurrentPackage = info; if (!RefactoredBackupManagerService.appIsEligibleForBackup(info.applicationInfo)) { @@ -192,9 +192,9 @@ public class PerformFullTransportBackupTask extends FullBackupTask implements Ba } private void registerTask() { - synchronized (backupManagerService.mCurrentOpLock) { + synchronized (backupManagerService.getCurrentOpLock()) { Slog.d(TAG, "backupmanager pftbt token=" + Integer.toHexString(mCurrentOpToken)); - backupManagerService.mCurrentOperations.put(mCurrentOpToken, new Operation( + backupManagerService.getCurrentOperations().put(mCurrentOpToken, new Operation( RefactoredBackupManagerService.OP_PENDING, this, RefactoredBackupManagerService.OP_TYPE_BACKUP)); } @@ -257,14 +257,15 @@ public class PerformFullTransportBackupTask extends FullBackupTask implements Ba int backupRunStatus = BackupManager.SUCCESS; try { - if (!backupManagerService.mEnabled || !backupManagerService.mProvisioned) { + if (!backupManagerService.isEnabled() || !backupManagerService.isProvisioned()) { // Backups are globally disabled, so don't proceed. if (RefactoredBackupManagerService.DEBUG) { - Slog.i(TAG, "full backup requested but enabled=" + backupManagerService.mEnabled - + " provisioned=" + backupManagerService.mProvisioned + "; ignoring"); + Slog.i(TAG, "full backup requested but enabled=" + backupManagerService + .isEnabled() + + " provisioned=" + backupManagerService.isProvisioned() + "; ignoring"); } int monitoringEvent; - if (!backupManagerService.mEnabled) { + if (!backupManagerService.isEnabled()) { monitoringEvent = BackupManagerMonitor.LOG_EVENT_ID_BACKUP_DISABLED; } else { monitoringEvent = BackupManagerMonitor.LOG_EVENT_ID_DEVICE_NOT_PROVISIONED; @@ -278,7 +279,7 @@ public class PerformFullTransportBackupTask extends FullBackupTask implements Ba return; } - mTransport = backupManagerService.mTransportManager.getCurrentTransportBinder(); + mTransport = backupManagerService.getTransportManager().getCurrentTransportBinder(); if (mTransport == null) { Slog.w(TAG, "Transport not present; full data backup not performed"); backupRunStatus = BackupManager.ERROR_TRANSPORT_ABORTED; @@ -529,7 +530,7 @@ public class PerformFullTransportBackupTask extends FullBackupTask implements Ba Slog.i(TAG, "Unbinding agent in " + packageName); backupManagerService.addBackupTrace("unbinding " + packageName); try { - backupManagerService.mActivityManager.unbindBackupAgent( + backupManagerService.getActivityManager().unbindBackupAgent( currentPackage.applicationInfo); } catch (RemoteException e) { /* can't happen; activity manager is local */ } } @@ -565,8 +566,8 @@ public class PerformFullTransportBackupTask extends FullBackupTask implements Ba mJob.finishBackupPass(); } - synchronized (backupManagerService.mQueueLock) { - backupManagerService.mRunningFullBackupTask = null; + synchronized (backupManagerService.getQueueLock()) { + backupManagerService.setRunningFullBackupTask(null); } mLatch.countDown(); @@ -578,7 +579,7 @@ public class PerformFullTransportBackupTask extends FullBackupTask implements Ba } Slog.i(RefactoredBackupManagerService.TAG, "Full data backup pass finished."); - backupManagerService.mWakelock.release(); + backupManagerService.getWakelock().release(); } } @@ -634,7 +635,7 @@ public class PerformFullTransportBackupTask extends FullBackupTask implements Ba Slog.d(TAG, "Preflighting full payload of " + pkg.packageName); } agent.doMeasureFullBackup(mQuota, mCurrentOpToken, - backupManagerService.mBackupManagerBinder); + backupManagerService.getBackupManagerBinder()); // Now wait to get our result back. If this backstop timeout is reached without // the latch being thrown, flow will continue as though a result or "normal" @@ -736,16 +737,16 @@ public class PerformFullTransportBackupTask extends FullBackupTask implements Ba } void registerTask() { - synchronized (backupManagerService.mCurrentOpLock) { - backupManagerService.mCurrentOperations.put(mCurrentOpToken, new Operation( + synchronized (backupManagerService.getCurrentOpLock()) { + backupManagerService.getCurrentOperations().put(mCurrentOpToken, new Operation( RefactoredBackupManagerService.OP_PENDING, this, RefactoredBackupManagerService.OP_TYPE_BACKUP_WAIT)); } } void unregisterTask() { - synchronized (backupManagerService.mCurrentOpLock) { - backupManagerService.mCurrentOperations.remove(mCurrentOpToken); + synchronized (backupManagerService.getCurrentOpLock()) { + backupManagerService.getCurrentOperations().remove(mCurrentOpToken); } } diff --git a/services/backup/java/com/android/server/backup/internal/BackupHandler.java b/services/backup/java/com/android/server/backup/internal/BackupHandler.java index 4ab500a4c76e..a97614610b97 100644 --- a/services/backup/java/com/android/server/backup/internal/BackupHandler.java +++ b/services/backup/java/com/android/server/backup/internal/BackupHandler.java @@ -67,38 +67,38 @@ public class BackupHandler extends Handler { switch (msg.what) { case RefactoredBackupManagerService.MSG_RUN_BACKUP: { - backupManagerService.mLastBackupPass = System.currentTimeMillis(); + backupManagerService.setLastBackupPass(System.currentTimeMillis()); IBackupTransport transport = - backupManagerService.mTransportManager.getCurrentTransportBinder(); + backupManagerService.getTransportManager().getCurrentTransportBinder(); if (transport == null) { Slog.v(RefactoredBackupManagerService.TAG, "Backup requested but no transport available"); - synchronized (backupManagerService.mQueueLock) { - backupManagerService.mBackupRunning = false; + synchronized (backupManagerService.getQueueLock()) { + backupManagerService.setBackupRunning(false); } - backupManagerService.mWakelock.release(); + backupManagerService.getWakelock().release(); break; } // snapshot the pending-backup set and work on that ArrayList<BackupRequest> queue = new ArrayList<>(); - File oldJournal = backupManagerService.mJournal; - synchronized (backupManagerService.mQueueLock) { + File oldJournal = backupManagerService.getJournal(); + synchronized (backupManagerService.getQueueLock()) { // Do we have any work to do? Construct the work queue // then release the synchronization lock to actually run // the backup. - if (backupManagerService.mPendingBackups.size() > 0) { - for (BackupRequest b : backupManagerService.mPendingBackups.values()) { + if (backupManagerService.getPendingBackups().size() > 0) { + for (BackupRequest b : backupManagerService.getPendingBackups().values()) { queue.add(b); } if (RefactoredBackupManagerService.DEBUG) { Slog.v(RefactoredBackupManagerService.TAG, "clearing pending backups"); } - backupManagerService.mPendingBackups.clear(); + backupManagerService.getPendingBackups().clear(); // Start a new backup-queue journal file too - backupManagerService.mJournal = null; + backupManagerService.setJournal(null); } } @@ -136,10 +136,10 @@ public class BackupHandler extends Handler { if (!staged) { // if we didn't actually hand off the wakelock, rewind until next time - synchronized (backupManagerService.mQueueLock) { - backupManagerService.mBackupRunning = false; + synchronized (backupManagerService.getQueueLock()) { + backupManagerService.setBackupRunning(false); } - backupManagerService.mWakelock.release(); + backupManagerService.getWakelock().release(); } break; } @@ -201,20 +201,20 @@ public class BackupHandler extends Handler { params.observer, params.monitor, params.token, params.pkgInfo, params.pmToken, params.isSystemRestore, params.filterSet); - synchronized (backupManagerService.mPendingRestores) { - if (backupManagerService.mIsRestoreInProgress) { + synchronized (backupManagerService.getPendingRestores()) { + if (backupManagerService.isRestoreInProgress()) { if (RefactoredBackupManagerService.DEBUG) { Slog.d(RefactoredBackupManagerService.TAG, "Restore in progress, queueing."); } - backupManagerService.mPendingRestores.add(task); + backupManagerService.getPendingRestores().add(task); // This task will be picked up and executed when the the currently running // restore task finishes. } else { if (RefactoredBackupManagerService.DEBUG) { Slog.d(RefactoredBackupManagerService.TAG, "Starting restore."); } - backupManagerService.mIsRestoreInProgress = true; + backupManagerService.setRestoreInProgress(true); Message restoreMsg = obtainMessage( RefactoredBackupManagerService.MSG_BACKUP_RESTORE_STEP, task); sendMessage(restoreMsg); @@ -253,9 +253,9 @@ public class BackupHandler extends Handler { HashSet<String> queue; // Snapshot the pending-init queue and work on that - synchronized (backupManagerService.mQueueLock) { - queue = new HashSet<>(backupManagerService.mPendingInits); - backupManagerService.mPendingInits.clear(); + synchronized (backupManagerService.getQueueLock()) { + queue = new HashSet<>(backupManagerService.getPendingInits()); + backupManagerService.getPendingInits().clear(); } (new PerformInitializeTask(backupManagerService, queue)).run(); @@ -263,11 +263,11 @@ public class BackupHandler extends Handler { } case RefactoredBackupManagerService.MSG_RETRY_INIT: { - synchronized (backupManagerService.mQueueLock) { + synchronized (backupManagerService.getQueueLock()) { backupManagerService.recordInitPendingLocked(msg.arg1 != 0, (String) msg.obj); - backupManagerService.mAlarmManager.set(AlarmManager.RTC_WAKEUP, + backupManagerService.getAlarmManager().set(AlarmManager.RTC_WAKEUP, System.currentTimeMillis(), - backupManagerService.mRunInitIntent); + backupManagerService.getRunInitIntent()); } break; } @@ -307,7 +307,7 @@ public class BackupHandler extends Handler { RefactoredBackupManagerService.MSG_RESTORE_SESSION_TIMEOUT, RefactoredBackupManagerService.TIMEOUT_RESTORE_INTERVAL); - backupManagerService.mWakelock.release(); + backupManagerService.getWakelock().release(); } break; } @@ -322,24 +322,25 @@ public class BackupHandler extends Handler { case RefactoredBackupManagerService.MSG_RESTORE_SESSION_TIMEOUT: { synchronized (backupManagerService) { - if (backupManagerService.mActiveRestoreSession != null) { + if (backupManagerService.getActiveRestoreSession() != null) { // Client app left the restore session dangling. We know that it // can't be in the middle of an actual restore operation because // the timeout is suspended while a restore is in progress. Clean // up now. Slog.w(RefactoredBackupManagerService.TAG, "Restore session timed out; aborting"); - backupManagerService.mActiveRestoreSession.markTimedOut(); - post(backupManagerService.mActiveRestoreSession.new EndRestoreRunnable( - backupManagerService, backupManagerService.mActiveRestoreSession)); + backupManagerService.getActiveRestoreSession().markTimedOut(); + post(backupManagerService.getActiveRestoreSession().new EndRestoreRunnable( + backupManagerService, + backupManagerService.getActiveRestoreSession())); } } break; } case RefactoredBackupManagerService.MSG_FULL_CONFIRMATION_TIMEOUT: { - synchronized (backupManagerService.mAdbBackupRestoreConfirmations) { - AdbParams params = backupManagerService.mAdbBackupRestoreConfirmations.get( + synchronized (backupManagerService.getAdbBackupRestoreConfirmations()) { + AdbParams params = backupManagerService.getAdbBackupRestoreConfirmations().get( msg.arg1); if (params != null) { Slog.i(RefactoredBackupManagerService.TAG, @@ -349,7 +350,7 @@ public class BackupHandler extends Handler { backupManagerService.signalAdbBackupRestoreCompletion(params); // Remove the token from the set - backupManagerService.mAdbBackupRestoreConfirmations.delete(msg.arg1); + backupManagerService.getAdbBackupRestoreConfirmations().delete(msg.arg1); // Report a timeout to the observer, if any if (params.observer != null) { @@ -369,7 +370,7 @@ public class BackupHandler extends Handler { case RefactoredBackupManagerService.MSG_WIDGET_BROADCAST: { final Intent intent = (Intent) msg.obj; - backupManagerService.mContext.sendBroadcastAsUser(intent, UserHandle.SYSTEM); + backupManagerService.getContext().sendBroadcastAsUser(intent, UserHandle.SYSTEM); break; } @@ -383,8 +384,8 @@ public class BackupHandler extends Handler { for (String packageName : params.kvPackages) { kvQueue.add(new BackupRequest(packageName)); } - backupManagerService.mBackupRunning = true; - backupManagerService.mWakelock.acquire(); + backupManagerService.setBackupRunning(true); + backupManagerService.getWakelock().acquire(); PerformBackupTask pbt = new PerformBackupTask( backupManagerService, diff --git a/services/backup/java/com/android/server/backup/internal/ClearDataObserver.java b/services/backup/java/com/android/server/backup/internal/ClearDataObserver.java index 8aff9055a1b3..d82c86541b8c 100644 --- a/services/backup/java/com/android/server/backup/internal/ClearDataObserver.java +++ b/services/backup/java/com/android/server/backup/internal/ClearDataObserver.java @@ -29,9 +29,9 @@ public class ClearDataObserver extends IPackageDataObserver.Stub { } public void onRemoveCompleted(String packageName, boolean succeeded) { - synchronized (backupManagerService.mClearDataLock) { - backupManagerService.mClearingData = false; - backupManagerService.mClearDataLock.notifyAll(); + synchronized (backupManagerService.getClearDataLock()) { + backupManagerService.setClearingData(false); + backupManagerService.getClearDataLock().notifyAll(); } } } diff --git a/services/backup/java/com/android/server/backup/internal/PerformBackupTask.java b/services/backup/java/com/android/server/backup/internal/PerformBackupTask.java index b9ce90b580f8..aedc6ff2aace 100644 --- a/services/backup/java/com/android/server/backup/internal/PerformBackupTask.java +++ b/services/backup/java/com/android/server/backup/internal/PerformBackupTask.java @@ -142,12 +142,12 @@ public class PerformBackupTask implements BackupRestoreTask { mUserInitiated = userInitiated; mNonIncremental = nonIncremental; - mStateDir = new File(backupManagerService.mBaseStateDir, dirName); + mStateDir = new File(backupManagerService.getBaseStateDir(), dirName); mCurrentOpToken = backupManagerService.generateRandomIntegerToken(); mFinished = false; - synchronized (backupManagerService.mCurrentOpLock) { + synchronized (backupManagerService.getCurrentOpLock()) { if (backupManagerService.isBackupOperationInProgress()) { if (RefactoredBackupManagerService.DEBUG) { Slog.d(TAG, "Skipping backup since one is already in progress."); @@ -179,8 +179,8 @@ public class PerformBackupTask implements BackupRestoreTask { * Put this task in the repository of running tasks. */ private void registerTask() { - synchronized (backupManagerService.mCurrentOpLock) { - backupManagerService.mCurrentOperations.put(mCurrentOpToken, new Operation( + synchronized (backupManagerService.getCurrentOpLock()) { + backupManagerService.getCurrentOperations().put(mCurrentOpToken, new Operation( RefactoredBackupManagerService.OP_PENDING, this, RefactoredBackupManagerService.OP_TYPE_BACKUP)); } @@ -309,7 +309,7 @@ public class PerformBackupTask implements BackupRestoreTask { // step even if we're selecting among various transports at run time. if (mStatus == BackupTransport.TRANSPORT_OK) { PackageManagerBackupAgent pmAgent = new PackageManagerBackupAgent( - backupManagerService.mPackageManager); + backupManagerService.getPackageManager()); mStatus = invokeAgentForBackup( RefactoredBackupManagerService.PACKAGE_MANAGER_SENTINEL, IBackupAgent.Stub.asInterface(pmAgent.onBind()), mTransport); @@ -318,7 +318,7 @@ public class PerformBackupTask implements BackupRestoreTask { // Because the PMBA is a local instance, it has already executed its // backup callback and returned. Blow away the lingering (spurious) // pending timeout message for it. - backupManagerService.mBackupHandler.removeMessages( + backupManagerService.getBackupHandler().removeMessages( RefactoredBackupManagerService.MSG_BACKUP_OPERATION_TIMEOUT); } } @@ -377,7 +377,7 @@ public class PerformBackupTask implements BackupRestoreTask { // to sanity-check here. This also gives us the classname of the // package's backup agent. try { - mCurrentPackage = backupManagerService.mPackageManager.getPackageInfo( + mCurrentPackage = backupManagerService.getPackageManager().getPackageInfo( request.packageName, PackageManager.GET_SIGNATURES); if (!RefactoredBackupManagerService.appIsEligibleForBackup( @@ -428,7 +428,7 @@ public class PerformBackupTask implements BackupRestoreTask { IBackupAgent agent = null; try { - backupManagerService.mWakelock.setWorkSource( + backupManagerService.getWakelock().setWorkSource( new WorkSource(mCurrentPackage.applicationInfo.uid)); agent = backupManagerService.bindToAgentSynchronous(mCurrentPackage.applicationInfo, ApplicationThreadConstants.BACKUP_MODE_INCREMENTAL); @@ -454,7 +454,7 @@ public class PerformBackupTask implements BackupRestoreTask { backupManagerService.addBackupTrace("no such package"); mStatus = BackupTransport.AGENT_UNKNOWN; } finally { - backupManagerService.mWakelock.setWorkSource(null); + backupManagerService.getWakelock().setWorkSource(null); // If there was an agent error, no timeout/completion handling will occur. // That means we need to direct to the next state ourselves. @@ -517,11 +517,11 @@ public class PerformBackupTask implements BackupRestoreTask { // If everything actually went through and this is the first time we've // done a backup, we can now record what the current backup dataset token // is. - if ((backupManagerService.mCurrentToken == 0) && (mStatus + if ((backupManagerService.getCurrentToken() == 0) && (mStatus == BackupTransport.TRANSPORT_OK)) { backupManagerService.addBackupTrace("success; recording token"); try { - backupManagerService.mCurrentToken = mTransport.getCurrentRestoreSet(); + backupManagerService.setCurrentToken(mTransport.getCurrentRestoreSet()); backupManagerService.writeRestoreTokens(); } catch (Exception e) { // nothing for it at this point, unfortunately, but this will be @@ -534,8 +534,8 @@ public class PerformBackupTask implements BackupRestoreTask { // Set up the next backup pass - at this point we can set mBackupRunning // to false to allow another pass to fire, because we're done with the // state machine sequence and the wakelock is refcounted. - synchronized (backupManagerService.mQueueLock) { - backupManagerService.mBackupRunning = false; + synchronized (backupManagerService.getQueueLock()) { + backupManagerService.setBackupRunning(false); if (mStatus == BackupTransport.TRANSPORT_NOT_INITIALIZED) { // Make sure we back up everything and perform the one-time init if (RefactoredBackupManagerService.MORE_DEBUG) { @@ -544,10 +544,10 @@ public class PerformBackupTask implements BackupRestoreTask { } backupManagerService.addBackupTrace("init required; rerunning"); try { - final String name = backupManagerService.mTransportManager.getTransportName( + final String name = backupManagerService.getTransportManager().getTransportName( mTransport); if (name != null) { - backupManagerService.mPendingInits.add(name); + backupManagerService.getPendingInits().add(name); } else { if (RefactoredBackupManagerService.DEBUG) { Slog.w(TAG, "Couldn't find name of transport " + mTransport @@ -571,7 +571,7 @@ public class PerformBackupTask implements BackupRestoreTask { mPendingFullBackups != null && !mPendingFullBackups.isEmpty()) { Slog.d(TAG, "Starting full backups for: " + mPendingFullBackups); // Acquiring wakelock for PerformFullTransportBackupTask before its start. - backupManagerService.mWakelock.acquire(); + backupManagerService.getWakelock().acquire(); (new Thread(mFullBackupTask, "full-transport-requested")).start(); } else if (mCancelAll) { if (mFullBackupTask != null) { @@ -599,7 +599,7 @@ public class PerformBackupTask implements BackupRestoreTask { } Slog.i(RefactoredBackupManagerService.TAG, "K/V backup pass finished."); // Only once we're entirely finished do we release the wakelock for k/v backup. - backupManagerService.mWakelock.release(); + backupManagerService.getWakelock().release(); } // Remove the PM metadata state. This will generate an init on the next pass. @@ -621,7 +621,7 @@ public class PerformBackupTask implements BackupRestoreTask { File blankStateName = new File(mStateDir, "blank_state"); mSavedStateName = new File(mStateDir, packageName); - mBackupDataName = new File(backupManagerService.mDataDir, packageName + ".data"); + mBackupDataName = new File(backupManagerService.getDataDir(), packageName + ".data"); mNewStateName = new File(mStateDir, packageName + ".new"); if (RefactoredBackupManagerService.MORE_DEBUG) Slog.d(TAG, "data file: " + mBackupDataName); @@ -676,7 +676,7 @@ public class PerformBackupTask implements BackupRestoreTask { backupManagerService.addBackupTrace("calling agent doBackup()"); agent.doBackup(mSavedState, mBackupData, mNewState, quota, mEphemeralOpToken, - backupManagerService.mBackupManagerBinder); + backupManagerService.getBackupManagerBinder()); } catch (Exception e) { Slog.e(TAG, "Error invoking for backup on " + packageName + ". " + e); backupManagerService.addBackupTrace("exception: " + e); @@ -842,7 +842,7 @@ public class PerformBackupTask implements BackupRestoreTask { backupManagerService.putMonitoringExtra(null, BackupManagerMonitor.EXTRA_LOG_ILLEGAL_KEY, key)); - backupManagerService.mBackupHandler.removeMessages( + backupManagerService.getBackupHandler().removeMessages( RefactoredBackupManagerService .MSG_BACKUP_OPERATION_TIMEOUT); RefactoredBackupManagerService @@ -882,7 +882,7 @@ public class PerformBackupTask implements BackupRestoreTask { "operationComplete(): sending data to transport for " + pkgName); } - backupManagerService.mBackupHandler.removeMessages( + backupManagerService.getBackupHandler().removeMessages( RefactoredBackupManagerService.MSG_BACKUP_OPERATION_TIMEOUT); clearAgentState(); backupManagerService.addBackupTrace("operation complete"); @@ -1058,7 +1058,7 @@ public class PerformBackupTask implements BackupRestoreTask { Slog.w(TAG, "Unable to contact transport for recommended backoff: " + e.getMessage()); delay = 0; // use the scheduler's default } - KeyValueBackupJob.schedule(backupManagerService.mContext, delay); + KeyValueBackupJob.schedule(backupManagerService.getContext(), delay); for (BackupRequest request : mOriginalQueue) { backupManagerService.dataChangedImpl(request.packageName); @@ -1086,11 +1086,11 @@ public class PerformBackupTask implements BackupRestoreTask { if (mNewState != null) mNewState.close(); } catch (IOException e) { } - synchronized (backupManagerService.mCurrentOpLock) { + synchronized (backupManagerService.getCurrentOpLock()) { // Current-operation callback handling requires the validity of these various // bits of internal state as an invariant of the operation still being live. // This means we make sure to clear all of the state in unison inside the lock. - backupManagerService.mCurrentOperations.remove(mEphemeralOpToken); + backupManagerService.getCurrentOperations().remove(mEphemeralOpToken); mSavedState = mBackupData = mNewState = null; } @@ -1098,7 +1098,7 @@ public class PerformBackupTask implements BackupRestoreTask { if (mCurrentPackage.applicationInfo != null) { backupManagerService.addBackupTrace("unbinding " + mCurrentPackage.packageName); try { // unbind even on timeout, just in case - backupManagerService.mActivityManager.unbindBackupAgent( + backupManagerService.getActivityManager().unbindBackupAgent( mCurrentPackage.applicationInfo); } catch (RemoteException e) { /* can't happen; activity manager is local */ } } @@ -1111,8 +1111,8 @@ public class PerformBackupTask implements BackupRestoreTask { } backupManagerService.addBackupTrace("executeNextState => " + nextState); mCurrentState = nextState; - Message msg = backupManagerService.mBackupHandler.obtainMessage( + Message msg = backupManagerService.getBackupHandler().obtainMessage( RefactoredBackupManagerService.MSG_BACKUP_RESTORE_STEP, this); - backupManagerService.mBackupHandler.sendMessage(msg); + backupManagerService.getBackupHandler().sendMessage(msg); } } diff --git a/services/backup/java/com/android/server/backup/internal/PerformClearTask.java b/services/backup/java/com/android/server/backup/internal/PerformClearTask.java index 3c1481943171..28dc7667206e 100644 --- a/services/backup/java/com/android/server/backup/internal/PerformClearTask.java +++ b/services/backup/java/com/android/server/backup/internal/PerformClearTask.java @@ -40,7 +40,7 @@ public class PerformClearTask implements Runnable { public void run() { try { // Clear the on-device backup state to ensure a full backup next time - File stateDir = new File(backupManagerService.mBaseStateDir, + File stateDir = new File(backupManagerService.getBaseStateDir(), mTransport.transportDirName()); File stateFile = new File(stateDir, mPackage.packageName); stateFile.delete(); @@ -62,7 +62,7 @@ public class PerformClearTask implements Runnable { } // Last but not least, release the cpu - backupManagerService.mWakelock.release(); + backupManagerService.getWakelock().release(); } } } diff --git a/services/backup/java/com/android/server/backup/internal/PerformInitializeTask.java b/services/backup/java/com/android/server/backup/internal/PerformInitializeTask.java index 43f7f4386774..f1156b42525a 100644 --- a/services/backup/java/com/android/server/backup/internal/PerformInitializeTask.java +++ b/services/backup/java/com/android/server/backup/internal/PerformInitializeTask.java @@ -44,7 +44,7 @@ public class PerformInitializeTask implements Runnable { try { for (String transportName : mQueue) { IBackupTransport transport = - backupManagerService.mTransportManager.getTransportBinder(transportName); + backupManagerService.getTransportManager().getTransportBinder(transportName); if (transport == null) { Slog.e( RefactoredBackupManagerService.TAG, @@ -68,10 +68,10 @@ public class PerformInitializeTask implements Runnable { int millis = (int) (SystemClock.elapsedRealtime() - startRealtime); EventLog.writeEvent(EventLogTags.BACKUP_INITIALIZE); backupManagerService - .resetBackupState(new File(backupManagerService.mBaseStateDir, + .resetBackupState(new File(backupManagerService.getBaseStateDir(), transport.transportDirName())); EventLog.writeEvent(EventLogTags.BACKUP_SUCCESS, 0, millis); - synchronized (backupManagerService.mQueueLock) { + synchronized (backupManagerService.getQueueLock()) { backupManagerService.recordInitPendingLocked(false, transportName); } } else { @@ -80,23 +80,23 @@ public class PerformInitializeTask implements Runnable { Slog.e(RefactoredBackupManagerService.TAG, "Transport error in initializeDevice()"); EventLog.writeEvent(EventLogTags.BACKUP_TRANSPORT_FAILURE, "(initialize)"); - synchronized (backupManagerService.mQueueLock) { + synchronized (backupManagerService.getQueueLock()) { backupManagerService.recordInitPendingLocked(true, transportName); } // do this via another alarm to make sure of the wakelock states long delay = transport.requestBackupTime(); Slog.w(RefactoredBackupManagerService.TAG, "Init failed on " + transportName + " resched in " + delay); - backupManagerService.mAlarmManager.set(AlarmManager.RTC_WAKEUP, + backupManagerService.getAlarmManager().set(AlarmManager.RTC_WAKEUP, System.currentTimeMillis() + delay, - backupManagerService.mRunInitIntent); + backupManagerService.getRunInitIntent()); } } } catch (Exception e) { Slog.e(RefactoredBackupManagerService.TAG, "Unexpected error performing init", e); } finally { // Done; release the wakelock - backupManagerService.mWakelock.release(); + backupManagerService.getWakelock().release(); } } } diff --git a/services/backup/java/com/android/server/backup/internal/ProvisionedObserver.java b/services/backup/java/com/android/server/backup/internal/ProvisionedObserver.java index 743f38237768..24f225a6eca5 100644 --- a/services/backup/java/com/android/server/backup/internal/ProvisionedObserver.java +++ b/services/backup/java/com/android/server/backup/internal/ProvisionedObserver.java @@ -34,24 +34,24 @@ public class ProvisionedObserver extends ContentObserver { } public void onChange(boolean selfChange) { - final boolean wasProvisioned = backupManagerService.mProvisioned; + final boolean wasProvisioned = backupManagerService.isProvisioned(); final boolean isProvisioned = backupManagerService.deviceIsProvisioned(); // latch: never unprovision - backupManagerService.mProvisioned = wasProvisioned || isProvisioned; + backupManagerService.setProvisioned(wasProvisioned || isProvisioned); if (RefactoredBackupManagerService.MORE_DEBUG) { Slog.d(RefactoredBackupManagerService.TAG, "Provisioning change: was=" + wasProvisioned - + " is=" + isProvisioned + " now=" + backupManagerService.mProvisioned); + + " is=" + isProvisioned + " now=" + backupManagerService.isProvisioned()); } - synchronized (backupManagerService.mQueueLock) { - if (backupManagerService.mProvisioned && !wasProvisioned - && backupManagerService.mEnabled) { + synchronized (backupManagerService.getQueueLock()) { + if (backupManagerService.isProvisioned() && !wasProvisioned + && backupManagerService.isEnabled()) { // we're now good to go, so start the backup alarms if (RefactoredBackupManagerService.MORE_DEBUG) { Slog.d(RefactoredBackupManagerService.TAG, "Now provisioned, so starting backups"); } - KeyValueBackupJob.schedule(backupManagerService.mContext); + KeyValueBackupJob.schedule(backupManagerService.getContext()); backupManagerService.scheduleNextFullBackupJob(0); } } diff --git a/services/backup/java/com/android/server/backup/internal/RunBackupReceiver.java b/services/backup/java/com/android/server/backup/internal/RunBackupReceiver.java index 66d37360e5dd..4276b257bea4 100644 --- a/services/backup/java/com/android/server/backup/internal/RunBackupReceiver.java +++ b/services/backup/java/com/android/server/backup/internal/RunBackupReceiver.java @@ -35,8 +35,8 @@ public class RunBackupReceiver extends BroadcastReceiver { public void onReceive(Context context, Intent intent) { if (RefactoredBackupManagerService.RUN_BACKUP_ACTION.equals(intent.getAction())) { - synchronized (backupManagerService.mQueueLock) { - if (backupManagerService.mPendingInits.size() > 0) { + synchronized (backupManagerService.getQueueLock()) { + if (backupManagerService.getPendingInits().size() > 0) { // If there are pending init operations, we process those // and then settle into the usual periodic backup schedule. if (RefactoredBackupManagerService.MORE_DEBUG) { @@ -44,9 +44,9 @@ public class RunBackupReceiver extends BroadcastReceiver { "Init pending at scheduled backup"); } try { - backupManagerService.mAlarmManager.cancel( - backupManagerService.mRunInitIntent); - backupManagerService.mRunInitIntent.send(); + backupManagerService.getAlarmManager().cancel( + backupManagerService.getRunInitIntent()); + backupManagerService.getRunInitIntent().send(); } catch (PendingIntent.CanceledException ce) { Slog.e(RefactoredBackupManagerService.TAG, "Run init intent cancelled"); // can't really do more than bail here @@ -54,20 +54,20 @@ public class RunBackupReceiver extends BroadcastReceiver { } else { // Don't run backups now if we're disabled or not yet // fully set up. - if (backupManagerService.mEnabled && backupManagerService.mProvisioned) { - if (!backupManagerService.mBackupRunning) { + if (backupManagerService.isEnabled() && backupManagerService.isProvisioned()) { + if (!backupManagerService.isBackupRunning()) { if (RefactoredBackupManagerService.DEBUG) { Slog.v(RefactoredBackupManagerService.TAG, "Running a backup pass"); } // Acquire the wakelock and pass it to the backup thread. it will // be released once backup concludes. - backupManagerService.mBackupRunning = true; - backupManagerService.mWakelock.acquire(); + backupManagerService.setBackupRunning(true); + backupManagerService.getWakelock().acquire(); - Message msg = backupManagerService.mBackupHandler.obtainMessage( + Message msg = backupManagerService.getBackupHandler().obtainMessage( RefactoredBackupManagerService.MSG_RUN_BACKUP); - backupManagerService.mBackupHandler.sendMessage(msg); + backupManagerService.getBackupHandler().sendMessage(msg); } else { Slog.i(RefactoredBackupManagerService.TAG, "Backup time but one already running"); @@ -75,8 +75,8 @@ public class RunBackupReceiver extends BroadcastReceiver { } else { Slog.w( RefactoredBackupManagerService.TAG, - "Backup pass but e=" + backupManagerService.mEnabled + " p=" - + backupManagerService.mProvisioned); + "Backup pass but e=" + backupManagerService.isEnabled() + " p=" + + backupManagerService.isProvisioned()); } } } diff --git a/services/backup/java/com/android/server/backup/internal/RunInitializeReceiver.java b/services/backup/java/com/android/server/backup/internal/RunInitializeReceiver.java index 7a487cc8698e..c995b09f9601 100644 --- a/services/backup/java/com/android/server/backup/internal/RunInitializeReceiver.java +++ b/services/backup/java/com/android/server/backup/internal/RunInitializeReceiver.java @@ -34,18 +34,18 @@ public class RunInitializeReceiver extends BroadcastReceiver { public void onReceive(Context context, Intent intent) { if (RefactoredBackupManagerService.RUN_INITIALIZE_ACTION.equals(intent.getAction())) { - synchronized (backupManagerService.mQueueLock) { + synchronized (backupManagerService.getQueueLock()) { if (RefactoredBackupManagerService.DEBUG) { Slog.v(RefactoredBackupManagerService.TAG, "Running a device init"); } // Acquire the wakelock and pass it to the init thread. it will // be released once init concludes. - backupManagerService.mWakelock.acquire(); + backupManagerService.getWakelock().acquire(); - Message msg = backupManagerService.mBackupHandler.obtainMessage( + Message msg = backupManagerService.getBackupHandler().obtainMessage( RefactoredBackupManagerService.MSG_RUN_INITIALIZE); - backupManagerService.mBackupHandler.sendMessage(msg); + backupManagerService.getBackupHandler().sendMessage(msg); } } } diff --git a/services/backup/java/com/android/server/backup/restore/ActiveRestoreSession.java b/services/backup/java/com/android/server/backup/restore/ActiveRestoreSession.java index 4470751d4b1b..6ef1d08443fe 100644 --- a/services/backup/java/com/android/server/backup/restore/ActiveRestoreSession.java +++ b/services/backup/java/com/android/server/backup/restore/ActiveRestoreSession.java @@ -50,7 +50,7 @@ public class ActiveRestoreSession extends IRestoreSession.Stub { String packageName, String transport) { this.backupManagerService = backupManagerService; mPackageName = packageName; - mRestoreTransport = backupManagerService.mTransportManager.getTransportBinder(transport); + mRestoreTransport = backupManagerService.getTransportManager().getTransportBinder(transport); } public void markTimedOut() { @@ -60,7 +60,7 @@ public class ActiveRestoreSession extends IRestoreSession.Stub { // --- Binder interface --- public synchronized int getAvailableRestoreSets(IRestoreObserver observer, IBackupManagerMonitor monitor) { - backupManagerService.mContext.enforceCallingOrSelfPermission( + backupManagerService.getContext().enforceCallingOrSelfPermission( android.Manifest.permission.BACKUP, "getAvailableRestoreSets"); if (observer == null) { @@ -86,16 +86,16 @@ public class ActiveRestoreSession extends IRestoreSession.Stub { // We know we're doing legit work now, so halt the timeout // until we're done. It gets started again when the result // comes in. - backupManagerService.mBackupHandler.removeMessages( + backupManagerService.getBackupHandler().removeMessages( RefactoredBackupManagerService.MSG_RESTORE_SESSION_TIMEOUT); // spin off the transport request to our service thread - backupManagerService.mWakelock.acquire(); - Message msg = backupManagerService.mBackupHandler.obtainMessage( + backupManagerService.getWakelock().acquire(); + Message msg = backupManagerService.getBackupHandler().obtainMessage( RefactoredBackupManagerService.MSG_RUN_GET_RESTORE_SETS, new RestoreGetSetsParams(mRestoreTransport, this, observer, monitor)); - backupManagerService.mBackupHandler.sendMessage(msg); + backupManagerService.getBackupHandler().sendMessage(msg); return 0; } catch (Exception e) { Slog.e(TAG, "Error in getAvailableRestoreSets", e); @@ -107,7 +107,7 @@ public class ActiveRestoreSession extends IRestoreSession.Stub { public synchronized int restoreAll(long token, IRestoreObserver observer, IBackupManagerMonitor monitor) { - backupManagerService.mContext.enforceCallingOrSelfPermission( + backupManagerService.getContext().enforceCallingOrSelfPermission( android.Manifest.permission.BACKUP, "performRestore"); @@ -144,23 +144,23 @@ public class ActiveRestoreSession extends IRestoreSession.Stub { return -1; } - synchronized (backupManagerService.mQueueLock) { + synchronized (backupManagerService.getQueueLock()) { for (int i = 0; i < mRestoreSets.length; i++) { if (token == mRestoreSets[i].token) { // Real work, so stop the session timeout until we finalize the restore - backupManagerService.mBackupHandler.removeMessages( + backupManagerService.getBackupHandler().removeMessages( RefactoredBackupManagerService.MSG_RESTORE_SESSION_TIMEOUT); long oldId = Binder.clearCallingIdentity(); - backupManagerService.mWakelock.acquire(); + backupManagerService.getWakelock().acquire(); if (RefactoredBackupManagerService.MORE_DEBUG) { Slog.d(TAG, "restoreAll() kicking off"); } - Message msg = backupManagerService.mBackupHandler.obtainMessage( + Message msg = backupManagerService.getBackupHandler().obtainMessage( RefactoredBackupManagerService.MSG_RUN_RESTORE); msg.obj = new RestoreParams(mRestoreTransport, dirName, observer, monitor, token); - backupManagerService.mBackupHandler.sendMessage(msg); + backupManagerService.getBackupHandler().sendMessage(msg); Binder.restoreCallingIdentity(oldId); return 0; } @@ -174,7 +174,7 @@ public class ActiveRestoreSession extends IRestoreSession.Stub { // Restores of more than a single package are treated as 'system' restores public synchronized int restoreSome(long token, IRestoreObserver observer, IBackupManagerMonitor monitor, String[] packages) { - backupManagerService.mContext.enforceCallingOrSelfPermission( + backupManagerService.getContext().enforceCallingOrSelfPermission( android.Manifest.permission.BACKUP, "performRestore"); @@ -237,23 +237,23 @@ public class ActiveRestoreSession extends IRestoreSession.Stub { return -1; } - synchronized (backupManagerService.mQueueLock) { + synchronized (backupManagerService.getQueueLock()) { for (int i = 0; i < mRestoreSets.length; i++) { if (token == mRestoreSets[i].token) { // Stop the session timeout until we finalize the restore - backupManagerService.mBackupHandler.removeMessages( + backupManagerService.getBackupHandler().removeMessages( RefactoredBackupManagerService.MSG_RESTORE_SESSION_TIMEOUT); long oldId = Binder.clearCallingIdentity(); - backupManagerService.mWakelock.acquire(); + backupManagerService.getWakelock().acquire(); if (RefactoredBackupManagerService.MORE_DEBUG) { Slog.d(TAG, "restoreSome() of " + packages.length + " packages"); } - Message msg = backupManagerService.mBackupHandler.obtainMessage( + Message msg = backupManagerService.getBackupHandler().obtainMessage( RefactoredBackupManagerService.MSG_RUN_RESTORE); msg.obj = new RestoreParams(mRestoreTransport, dirName, observer, monitor, token, packages, packages.length > 1); - backupManagerService.mBackupHandler.sendMessage(msg); + backupManagerService.getBackupHandler().sendMessage(msg); Binder.restoreCallingIdentity(oldId); return 0; } @@ -290,7 +290,7 @@ public class ActiveRestoreSession extends IRestoreSession.Stub { PackageInfo app = null; try { - app = backupManagerService.mPackageManager.getPackageInfo(packageName, 0); + app = backupManagerService.getPackageManager().getPackageInfo(packageName, 0); } catch (NameNotFoundException nnf) { Slog.w(TAG, "Asked to restore nonexistent pkg " + packageName); return -1; @@ -298,7 +298,7 @@ public class ActiveRestoreSession extends IRestoreSession.Stub { // If the caller is not privileged and is not coming from the target // app's uid, throw a permission exception back to the caller. - int perm = backupManagerService.mContext.checkPermission(android.Manifest.permission.BACKUP, + int perm = backupManagerService.getContext().checkPermission(android.Manifest.permission.BACKUP, Binder.getCallingPid(), Binder.getCallingUid()); if ((perm == PackageManager.PERMISSION_DENIED) && (app.applicationInfo.uid != Binder.getCallingUid())) { @@ -339,19 +339,19 @@ public class ActiveRestoreSession extends IRestoreSession.Stub { } // Stop the session timeout until we finalize the restore - backupManagerService.mBackupHandler.removeMessages( + backupManagerService.getBackupHandler().removeMessages( RefactoredBackupManagerService.MSG_RESTORE_SESSION_TIMEOUT); // Ready to go: enqueue the restore request and claim success - backupManagerService.mWakelock.acquire(); + backupManagerService.getWakelock().acquire(); if (RefactoredBackupManagerService.MORE_DEBUG) { Slog.d(TAG, "restorePackage() : " + packageName); } - Message msg = backupManagerService.mBackupHandler.obtainMessage( + Message msg = backupManagerService.getBackupHandler().obtainMessage( RefactoredBackupManagerService.MSG_RUN_RESTORE); msg.obj = new RestoreParams(mRestoreTransport, dirName, observer, monitor, token, app); - backupManagerService.mBackupHandler.sendMessage(msg); + backupManagerService.getBackupHandler().sendMessage(msg); } finally { Binder.restoreCallingIdentity(oldId); } @@ -397,7 +397,7 @@ public class ActiveRestoreSession extends IRestoreSession.Stub { throw new IllegalStateException("Restore session already ended"); } - backupManagerService.mBackupHandler.post( + backupManagerService.getBackupHandler().post( new EndRestoreRunnable(backupManagerService, this)); } } diff --git a/services/backup/java/com/android/server/backup/restore/FullRestoreEngine.java b/services/backup/java/com/android/server/backup/restore/FullRestoreEngine.java index 0b1eec29d72c..4a0e2e0dce73 100644 --- a/services/backup/java/com/android/server/backup/restore/FullRestoreEngine.java +++ b/services/backup/java/com/android/server/backup/restore/FullRestoreEngine.java @@ -160,7 +160,7 @@ public class FullRestoreEngine extends RestoreEngine { try { mAgent.doRestoreFile(mSocket, mInfo.size, mInfo.type, mInfo.domain, mInfo.path, mInfo.mode, mInfo.mtime, - mToken, backupManagerService.mBackupManagerBinder); + mToken, backupManagerService.getBackupManagerBinder()); } catch (RemoteException e) { // never happens; this is used strictly for local binder calls } @@ -338,7 +338,7 @@ public class FullRestoreEngine extends RestoreEngine { } try { - mTargetApp = backupManagerService.mPackageManager.getApplicationInfo( + mTargetApp = backupManagerService.getPackageManager().getApplicationInfo( pkg, 0); // If we haven't sent any data to this app yet, we probably @@ -419,7 +419,7 @@ public class FullRestoreEngine extends RestoreEngine { mObbConnection.restoreObbFile(pkg, mPipes[0], info.size, info.type, info.path, info.mode, info.mtime, mEphemeralOpToken, - backupManagerService.mBackupManagerBinder); + backupManagerService.getBackupManagerBinder()); } else { if (RefactoredBackupManagerService.MORE_DEBUG) { Slog.d(RefactoredBackupManagerService.TAG, @@ -440,7 +440,7 @@ public class FullRestoreEngine extends RestoreEngine { mAgent.doRestoreFile(mPipes[0], info.size, info.type, info.domain, info.path, info.mode, info.mtime, mEphemeralOpToken, - backupManagerService.mBackupManagerBinder); + backupManagerService.getBackupManagerBinder()); } } } catch (IOException e) { @@ -509,7 +509,7 @@ public class FullRestoreEngine extends RestoreEngine { if (!agentSuccess) { Slog.w(RefactoredBackupManagerService.TAG, "Agent failure; ending restore"); - backupManagerService.mBackupHandler.removeMessages( + backupManagerService.getBackupHandler().removeMessages( RefactoredBackupManagerService.MSG_RESTORE_OPERATION_TIMEOUT); tearDownPipes(); tearDownAgent(mTargetApp); @@ -693,7 +693,7 @@ public class FullRestoreEngine extends RestoreEngine { // The file content is an .apk file. Copy it out to a staging location and // attempt to install it. - File apkFile = new File(backupManagerService.mDataDir, info.packageName); + File apkFile = new File(backupManagerService.getDataDir(), info.packageName); try { FileOutputStream apkStream = new FileOutputStream(apkFile); byte[] buffer = new byte[32 * 1024]; @@ -715,7 +715,7 @@ public class FullRestoreEngine extends RestoreEngine { // Now install it Uri packageUri = Uri.fromFile(apkFile); mInstallObserver.reset(); - backupManagerService.mPackageManager.installPackage(packageUri, mInstallObserver, + backupManagerService.getPackageManager().installPackage(packageUri, mInstallObserver, PackageManager.INSTALL_REPLACE_EXISTING | PackageManager.INSTALL_FROM_ADB, installerPackage); mInstallObserver.waitForCompletion(); @@ -740,7 +740,7 @@ public class FullRestoreEngine extends RestoreEngine { uninstall = true; } else { try { - PackageInfo pkg = backupManagerService.mPackageManager.getPackageInfo( + PackageInfo pkg = backupManagerService.getPackageManager().getPackageInfo( info.packageName, PackageManager.GET_SIGNATURES); if ((pkg.applicationInfo.flags & ApplicationInfo.FLAG_ALLOW_BACKUP) @@ -783,7 +783,7 @@ public class FullRestoreEngine extends RestoreEngine { // that we just installed. if (uninstall) { mDeleteObserver.reset(); - backupManagerService.mPackageManager.deletePackage( + backupManagerService.getPackageManager().deletePackage( mInstallObserver.mPackageName, mDeleteObserver, 0); mDeleteObserver.waitForCompletion(); @@ -960,7 +960,7 @@ public class FullRestoreEngine extends RestoreEngine { // Okay, got the manifest info we need... try { PackageInfo pkgInfo = - backupManagerService.mPackageManager.getPackageInfo( + backupManagerService.getPackageManager().getPackageInfo( info.packageName, PackageManager.GET_SIGNATURES); // Fall through to IGNORE if the app explicitly disallows backup final int flags = pkgInfo.applicationInfo.flags; diff --git a/services/backup/java/com/android/server/backup/restore/PerformAdbRestoreTask.java b/services/backup/java/com/android/server/backup/restore/PerformAdbRestoreTask.java index 94ae76ef0d33..f06a679745bc 100644 --- a/services/backup/java/com/android/server/backup/restore/PerformAdbRestoreTask.java +++ b/services/backup/java/com/android/server/backup/restore/PerformAdbRestoreTask.java @@ -102,7 +102,7 @@ public class PerformAdbRestoreTask implements Runnable { @Override public void run() { try { - mAgent.doRestoreFinished(mToken, backupManagerService.mBackupManagerBinder); + mAgent.doRestoreFinished(mToken, backupManagerService.getBackupManagerBinder()); } catch (RemoteException e) { // never happens; this is used only for local binder calls } @@ -134,7 +134,7 @@ public class PerformAdbRestoreTask implements Runnable { mLatchObject = latch; mAgent = null; mPackageManagerBackupAgent = new PackageManagerBackupAgent( - backupManagerService.mPackageManager); + backupManagerService.getPackageManager()); mAgentPackage = null; mTargetApp = null; mObbConnection = new FullBackupObbConnection(backupManagerService); @@ -171,7 +171,7 @@ public class PerformAdbRestoreTask implements Runnable { try { mAgent.doRestoreFile(mSocket, mInfo.size, mInfo.type, mInfo.domain, mInfo.path, mInfo.mode, mInfo.mtime, - mToken, backupManagerService.mBackupManagerBinder); + mToken, backupManagerService.getBackupManagerBinder()); } catch (RemoteException e) { // never happens; this is used strictly for local binder calls } @@ -291,7 +291,7 @@ public class PerformAdbRestoreTask implements Runnable { mObbConnection.tearDown(); sendEndRestore(); Slog.d(RefactoredBackupManagerService.TAG, "Full restore pass complete."); - backupManagerService.mWakelock.release(); + backupManagerService.getWakelock().release(); } } @@ -556,7 +556,7 @@ public class PerformAdbRestoreTask implements Runnable { } try { - mTargetApp = backupManagerService.mPackageManager.getApplicationInfo( + mTargetApp = backupManagerService.getPackageManager().getApplicationInfo( pkg, 0); // If we haven't sent any data to this app yet, we probably @@ -639,7 +639,7 @@ public class PerformAdbRestoreTask implements Runnable { mObbConnection.restoreObbFile(pkg, mPipes[0], info.size, info.type, info.path, info.mode, info.mtime, token, - backupManagerService.mBackupManagerBinder); + backupManagerService.getBackupManagerBinder()); } else if (FullBackup.KEY_VALUE_DATA_TOKEN.equals(info.domain)) { if (RefactoredBackupManagerService.DEBUG) { Slog.d(RefactoredBackupManagerService.TAG, @@ -649,7 +649,7 @@ public class PerformAdbRestoreTask implements Runnable { KeyValueAdbRestoreEngine restoreEngine = new KeyValueAdbRestoreEngine( backupManagerService, - backupManagerService.mDataDir, info, mPipes[0], + backupManagerService.getDataDir(), info, mPipes[0], mAgent, token); new Thread(restoreEngine, "restore-key-value-runner").start(); } else { @@ -671,7 +671,7 @@ public class PerformAdbRestoreTask implements Runnable { } else { mAgent.doRestoreFile(mPipes[0], info.size, info.type, info.domain, info.path, info.mode, info.mtime, - token, backupManagerService.mBackupManagerBinder); + token, backupManagerService.getBackupManagerBinder()); } } } catch (IOException e) { @@ -735,7 +735,7 @@ public class PerformAdbRestoreTask implements Runnable { Slog.d(RefactoredBackupManagerService.TAG, "Agent failure restoring " + pkg + "; now ignoring"); } - backupManagerService.mBackupHandler.removeMessages( + backupManagerService.getBackupHandler().removeMessages( RefactoredBackupManagerService.MSG_RESTORE_OPERATION_TIMEOUT); tearDownPipes(); tearDownAgent(mTargetApp, false); @@ -817,14 +817,15 @@ public class PerformAdbRestoreTask implements Runnable { Runnable runner = new RestoreFinishedRunnable(mAgent, token); new Thread(runner, "restore-sys-finished-runner").start(); } else { - mAgent.doRestoreFinished(token, backupManagerService.mBackupManagerBinder); + mAgent.doRestoreFinished(token, + backupManagerService.getBackupManagerBinder()); } latch.await(); } // unbind and tidy up even on timeout or failure, just in case - backupManagerService.mActivityManager.unbindBackupAgent(app); + backupManagerService.getActivityManager().unbindBackupAgent(app); // The agent was running with a stub Application object, so shut it down. // !!! We hardcode the confirmation UI's package name here rather than use a @@ -834,7 +835,7 @@ public class PerformAdbRestoreTask implements Runnable { if (RefactoredBackupManagerService.DEBUG) { Slog.d(RefactoredBackupManagerService.TAG, "Killing host process"); } - backupManagerService.mActivityManager.killApplicationProcess(app.processName, + backupManagerService.getActivityManager().killApplicationProcess(app.processName, app.uid); } else { if (RefactoredBackupManagerService.DEBUG) { @@ -933,7 +934,7 @@ public class PerformAdbRestoreTask implements Runnable { // The file content is an .apk file. Copy it out to a staging location and // attempt to install it. - File apkFile = new File(backupManagerService.mDataDir, info.packageName); + File apkFile = new File(backupManagerService.getDataDir(), info.packageName); try { FileOutputStream apkStream = new FileOutputStream(apkFile); byte[] buffer = new byte[32 * 1024]; @@ -955,7 +956,7 @@ public class PerformAdbRestoreTask implements Runnable { // Now install it Uri packageUri = Uri.fromFile(apkFile); mInstallObserver.reset(); - backupManagerService.mPackageManager.installPackage(packageUri, mInstallObserver, + backupManagerService.getPackageManager().installPackage(packageUri, mInstallObserver, PackageManager.INSTALL_REPLACE_EXISTING | PackageManager.INSTALL_FROM_ADB, installerPackage); mInstallObserver.waitForCompletion(); @@ -980,7 +981,7 @@ public class PerformAdbRestoreTask implements Runnable { uninstall = true; } else { try { - PackageInfo pkg = backupManagerService.mPackageManager.getPackageInfo( + PackageInfo pkg = backupManagerService.getPackageManager().getPackageInfo( info.packageName, PackageManager.GET_SIGNATURES); if ((pkg.applicationInfo.flags & ApplicationInfo.FLAG_ALLOW_BACKUP) @@ -1023,7 +1024,7 @@ public class PerformAdbRestoreTask implements Runnable { // that we just installed. if (uninstall) { mDeleteObserver.reset(); - backupManagerService.mPackageManager.deletePackage( + backupManagerService.getPackageManager().deletePackage( mInstallObserver.mPackageName, mDeleteObserver, 0); mDeleteObserver.waitForCompletion(); @@ -1170,7 +1171,7 @@ public class PerformAdbRestoreTask implements Runnable { // Okay, got the manifest info we need... try { PackageInfo pkgInfo = - backupManagerService.mPackageManager.getPackageInfo( + backupManagerService.getPackageManager().getPackageInfo( info.packageName, PackageManager.GET_SIGNATURES); // Fall through to IGNORE if the app explicitly disallows backup final int flags = pkgInfo.applicationInfo.flags; diff --git a/services/backup/java/com/android/server/backup/restore/PerformUnifiedRestoreTask.java b/services/backup/java/com/android/server/backup/restore/PerformUnifiedRestoreTask.java index 23e03ab52e1a..1c1709aa2604 100644 --- a/services/backup/java/com/android/server/backup/restore/PerformUnifiedRestoreTask.java +++ b/services/backup/java/com/android/server/backup/restore/PerformUnifiedRestoreTask.java @@ -166,7 +166,7 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask { // We want everything and a pony List<PackageInfo> apps = PackageManagerBackupAgent.getStorableApplications( - backupManagerService.mPackageManager); + backupManagerService.getPackageManager()); filterSet = packagesToNames(apps); if (RefactoredBackupManagerService.DEBUG) { Slog.i(RefactoredBackupManagerService.TAG, @@ -183,7 +183,7 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask { boolean hasSettings = false; for (int i = 0; i < filterSet.length; i++) { try { - PackageInfo info = backupManagerService.mPackageManager.getPackageInfo( + PackageInfo info = backupManagerService.getPackageManager().getPackageInfo( filterSet[i], 0); if ("android".equals(info.packageName)) { hasSystem = true; @@ -205,14 +205,14 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask { if (hasSystem) { try { mAcceptSet.add(0, - backupManagerService.mPackageManager.getPackageInfo("android", 0)); + backupManagerService.getPackageManager().getPackageInfo("android", 0)); } catch (NameNotFoundException e) { // won't happen; we know a priori that it's valid } } if (hasSettings) { try { - mAcceptSet.add(backupManagerService.mPackageManager.getPackageInfo( + mAcceptSet.add(backupManagerService.getPackageManager().getPackageInfo( RefactoredBackupManagerService.SETTINGS_PACKAGE, 0)); } catch (NameNotFoundException e) { // this one is always valid too @@ -330,7 +330,7 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask { try { String transportDir = mTransport.transportDirName(); - mStateDir = new File(backupManagerService.mBaseStateDir, transportDir); + mStateDir = new File(backupManagerService.getBaseStateDir(), transportDir); // Fetch the current metadata from the dataset first PackageInfo pmPackage = new PackageInfo(); @@ -375,7 +375,7 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask { // Pull the Package Manager metadata from the restore set first mCurrentPackage = new PackageInfo(); mCurrentPackage.packageName = RefactoredBackupManagerService.PACKAGE_MANAGER_SENTINEL; - mPmAgent = new PackageManagerBackupAgent(backupManagerService.mPackageManager, null); + mPmAgent = new PackageManagerBackupAgent(backupManagerService.getPackageManager(), null); mAgent = IBackupAgent.Stub.asInterface(mPmAgent.onBind()); if (RefactoredBackupManagerService.MORE_DEBUG) { Slog.v(RefactoredBackupManagerService.TAG, "initiating restore for PMBA"); @@ -388,7 +388,7 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask { // message and jump straight to the FINAL state. Because this was // synchronous we also know that we should cancel the pending timeout // message. - backupManagerService.mBackupHandler.removeMessages( + backupManagerService.getBackupHandler().removeMessages( RefactoredBackupManagerService.MSG_RESTORE_OPERATION_TIMEOUT); // Verify that the backup set includes metadata. If not, we can't do @@ -405,7 +405,7 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask { RefactoredBackupManagerService.PACKAGE_MANAGER_SENTINEL, "Package manager restore metadata missing"); mStatus = BackupTransport.TRANSPORT_ERROR; - backupManagerService.mBackupHandler.removeMessages( + backupManagerService.getBackupHandler().removeMessages( RefactoredBackupManagerService.MSG_BACKUP_RESTORE_STEP, this); executeNextState(UnifiedRestoreState.FINAL); return; @@ -423,7 +423,7 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask { null, BackupManagerMonitor.LOG_EVENT_CATEGORY_TRANSPORT, null); mStatus = BackupTransport.TRANSPORT_ERROR; - backupManagerService.mBackupHandler.removeMessages( + backupManagerService.getBackupHandler().removeMessages( RefactoredBackupManagerService.MSG_BACKUP_RESTORE_STEP, this); executeNextState(UnifiedRestoreState.FINAL); return; @@ -471,7 +471,7 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask { } try { - mCurrentPackage = backupManagerService.mPackageManager.getPackageInfo( + mCurrentPackage = backupManagerService.getPackageManager().getPackageInfo( pkgName, PackageManager.GET_SIGNATURES); } catch (NameNotFoundException e) { // Whoops, we thought we could restore this package but it @@ -641,8 +641,8 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask { } // !!! TODO: get the dirs from the transport - mBackupDataName = new File(backupManagerService.mDataDir, packageName + ".restore"); - mStageName = new File(backupManagerService.mDataDir, packageName + ".stage"); + mBackupDataName = new File(backupManagerService.getDataDir(), packageName + ".restore"); + mStageName = new File(backupManagerService.getDataDir(), packageName + ".stage"); mNewStateName = new File(mStateDir, packageName + ".new"); mSavedStateName = new File(mStateDir, packageName); @@ -734,7 +734,7 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask { RefactoredBackupManagerService.TIMEOUT_RESTORE_INTERVAL, this, RefactoredBackupManagerService.OP_TYPE_RESTORE_WAIT); mAgent.doRestore(mBackupData, appVersionCode, mNewState, - mEphemeralOpToken, backupManagerService.mBackupManagerBinder); + mEphemeralOpToken, backupManagerService.getBackupManagerBinder()); } catch (Exception e) { Slog.e(RefactoredBackupManagerService.TAG, "Unable to call app for restore: " + packageName, e); @@ -787,7 +787,8 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask { .prepareOperationTimeout(mEphemeralOpToken, RefactoredBackupManagerService.TIMEOUT_RESTORE_FINISHED_INTERVAL, this, RefactoredBackupManagerService.OP_TYPE_RESTORE_WAIT); - mAgent.doRestoreFinished(mEphemeralOpToken, backupManagerService.mBackupManagerBinder); + mAgent.doRestoreFinished(mEphemeralOpToken, + backupManagerService.getBackupManagerBinder()); // If we get this far, the callback or timeout will schedule the // next restore state, so we're done } catch (Exception e) { @@ -1064,7 +1065,7 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask { } // Clear any ongoing session timeout. - backupManagerService.mBackupHandler.removeMessages( + backupManagerService.getBackupHandler().removeMessages( RefactoredBackupManagerService.MSG_RESTORE_SESSION_TIMEOUT); // If we have a PM token, we must under all circumstances be sure to @@ -1074,13 +1075,13 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask { Slog.v(RefactoredBackupManagerService.TAG, "finishing PM token " + mPmToken); } try { - backupManagerService.mPackageManagerBinder.finishPackageInstall(mPmToken, + backupManagerService.getPackageManagerBinder().finishPackageInstall(mPmToken, mDidLaunch); } catch (RemoteException e) { /* can't happen */ } } else { // We were invoked via an active restore session, not by the Package // Manager, so start up the session timeout again. - backupManagerService.mBackupHandler.sendEmptyMessageDelayed( + backupManagerService.getBackupHandler().sendEmptyMessageDelayed( RefactoredBackupManagerService.MSG_RESTORE_SESSION_TIMEOUT, RefactoredBackupManagerService.TIMEOUT_RESTORE_INTERVAL); } @@ -1092,33 +1093,33 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask { // If this was a full-system restore, record the ancestral // dataset information if (mIsSystemRestore && mPmAgent != null) { - backupManagerService.mAncestralPackages = mPmAgent.getRestoredPackages(); - backupManagerService.mAncestralToken = mToken; + backupManagerService.setAncestralPackages(mPmAgent.getRestoredPackages()); + backupManagerService.setAncestralToken(mToken); backupManagerService.writeRestoreTokens(); } // done; we can finally release the wakelock and be legitimately done. Slog.i(RefactoredBackupManagerService.TAG, "Restore complete."); - synchronized (backupManagerService.mPendingRestores) { - if (backupManagerService.mPendingRestores.size() > 0) { + synchronized (backupManagerService.getPendingRestores()) { + if (backupManagerService.getPendingRestores().size() > 0) { if (RefactoredBackupManagerService.DEBUG) { Slog.d(RefactoredBackupManagerService.TAG, "Starting next pending restore."); } - PerformUnifiedRestoreTask task = backupManagerService.mPendingRestores.remove(); - backupManagerService.mBackupHandler.sendMessage( - backupManagerService.mBackupHandler.obtainMessage( + PerformUnifiedRestoreTask task = backupManagerService.getPendingRestores().remove(); + backupManagerService.getBackupHandler().sendMessage( + backupManagerService.getBackupHandler().obtainMessage( RefactoredBackupManagerService.MSG_BACKUP_RESTORE_STEP, task)); } else { - backupManagerService.mIsRestoreInProgress = false; + backupManagerService.setRestoreInProgress(false); if (RefactoredBackupManagerService.MORE_DEBUG) { Slog.d(RefactoredBackupManagerService.TAG, "No pending restores."); } } } - backupManagerService.mWakelock.release(); + backupManagerService.getWakelock().release(); } void keyValueAgentErrorCleanup() { @@ -1167,7 +1168,7 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask { if (mCurrentPackage.applicationInfo != null) { // unbind and tidy up even on timeout or failure try { - backupManagerService.mActivityManager.unbindBackupAgent( + backupManagerService.getActivityManager().unbindBackupAgent( mCurrentPackage.applicationInfo); // The agent was probably running with a stub Application object, @@ -1196,7 +1197,7 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask { "Restore complete, killing host process of " + mCurrentPackage.applicationInfo.processName); } - backupManagerService.mActivityManager.killApplicationProcess( + backupManagerService.getActivityManager().killApplicationProcess( mCurrentPackage.applicationInfo.processName, mCurrentPackage.applicationInfo.uid); } @@ -1207,7 +1208,7 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask { // The caller is responsible for reestablishing the state machine; our // responsibility here is to clear the decks for whatever comes next. - backupManagerService.mBackupHandler.removeMessages( + backupManagerService.getBackupHandler().removeMessages( RefactoredBackupManagerService.MSG_RESTORE_OPERATION_TIMEOUT, this); } @@ -1297,9 +1298,9 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask { + this + " nextState=" + nextState); } mState = nextState; - Message msg = backupManagerService.mBackupHandler.obtainMessage( + Message msg = backupManagerService.getBackupHandler().obtainMessage( RefactoredBackupManagerService.MSG_BACKUP_RESTORE_STEP, this); - backupManagerService.mBackupHandler.sendMessage(msg); + backupManagerService.getBackupHandler().sendMessage(msg); } // restore observer support |