Encapsulate RefactoredBackupManagerService fields. (d6c00c71) · Commits · e / os / android_frameworks_base

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

+264 −33

Original line number	Diff line number	Diff line
		@@ -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;

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

+2 −2

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

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

+3 −3

Original line number	Diff line number	Diff line
		@@ -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) {

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

+8 −8

Original line number	Diff line number	Diff line
		@@ -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();
		}
		}

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

+18 −17

Original line number	Diff line number	Diff line
		@@ -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);
		}
		}