Merge "[Multi-user] Make backup and initialize receivers per user" (834b72e7) · Commits · e / os / android_frameworks_base

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

+30 −10

Original line number	Original line	Diff line number	Diff line
	@@ -503,26 +503,46 @@ public class UserBackupManagerService {

	mBackupPasswordManager = new BackupPasswordManager(mContext, mBaseStateDir, mRng);		mBackupPasswordManager = new BackupPasswordManager(mContext, mBaseStateDir, mRng);

	// Alarm receivers for scheduled backups & initialization operations		// Receivers for scheduled backups and transport initialization operations.
	BroadcastReceiver mRunBackupReceiver = new RunBackupReceiver(this);		BroadcastReceiver runBackupReceiver = new RunBackupReceiver(this);
	IntentFilter filter = new IntentFilter();		IntentFilter filter = new IntentFilter();
	filter.addAction(RUN_BACKUP_ACTION);		filter.addAction(RUN_BACKUP_ACTION);
	context.registerReceiver(mRunBackupReceiver, filter,		context.registerReceiverAsUser(
	android.Manifest.permission.BACKUP, null);		runBackupReceiver,
			UserHandle.of(userId),
	BroadcastReceiver mRunInitReceiver = new RunInitializeReceiver(this);		filter,
			android.Manifest.permission.BACKUP,
			/* scheduler */ null);

			BroadcastReceiver runInitReceiver = new RunInitializeReceiver(this);
	filter = new IntentFilter();		filter = new IntentFilter();
	filter.addAction(RUN_INITIALIZE_ACTION);		filter.addAction(RUN_INITIALIZE_ACTION);
	context.registerReceiver(mRunInitReceiver, filter,		context.registerReceiverAsUser(
	android.Manifest.permission.BACKUP, null);		runInitReceiver,
			UserHandle.of(userId),
			filter,
			android.Manifest.permission.BACKUP,
			/* scheduler */ null);

	Intent backupIntent = new Intent(RUN_BACKUP_ACTION);		Intent backupIntent = new Intent(RUN_BACKUP_ACTION);
	backupIntent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);		backupIntent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);
	mRunBackupIntent = PendingIntent.getBroadcast(context, 0, backupIntent, 0);		mRunBackupIntent =
			PendingIntent.getBroadcastAsUser(
			context,
			/* requestCode */ 0,
			backupIntent,
			/* flags */ 0,
			UserHandle.of(userId));

	Intent initIntent = new Intent(RUN_INITIALIZE_ACTION);		Intent initIntent = new Intent(RUN_INITIALIZE_ACTION);
	initIntent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);		initIntent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);
	mRunInitIntent = PendingIntent.getBroadcast(context, 0, initIntent, 0);		mRunInitIntent =
			PendingIntent.getBroadcastAsUser(
			context,
			/* requestCode */ 0,
			initIntent,
			/* flags */ 0,
			UserHandle.of(userId));

	// Set up the backup-request journaling		// Set up the backup-request journaling
	mJournalDir = new File(mBaseStateDir, "pending");		mJournalDir = new File(mBaseStateDir, "pending");

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

+65 −43

Original line number	Original line	Diff line number	Diff line
	@@ -26,62 +26,84 @@ import android.app.PendingIntent;
	import android.content.BroadcastReceiver;		import android.content.BroadcastReceiver;
	import android.content.Context;		import android.content.Context;
	import android.content.Intent;		import android.content.Intent;
			import android.os.Handler;
	import android.os.Message;		import android.os.Message;
	import android.util.Slog;		import android.util.Slog;

	import com.android.server.backup.UserBackupManagerService;		import com.android.server.backup.UserBackupManagerService;

			/**
			* A {@link BroadcastReceiver} for the action {@link UserBackupManagerService#RUN_BACKUP_ACTION}
			* that runs an immediate backup operation if eligible.
			*/
	public class RunBackupReceiver extends BroadcastReceiver {		public class RunBackupReceiver extends BroadcastReceiver {
			private final UserBackupManagerService mUserBackupManagerService;

	private UserBackupManagerService backupManagerService;		public RunBackupReceiver(UserBackupManagerService userBackupManagerService) {
			mUserBackupManagerService = userBackupManagerService;
	public RunBackupReceiver(UserBackupManagerService backupManagerService) {
	this.backupManagerService = backupManagerService;
	}		}

			/**
			* Run a backup pass if we're eligible. We're eligible if the following conditions are met:
			*
			* <ul>
			* <li>No transports are pending initialization (otherwise we kick off an initialization
			* operation instead).
			* <li>Backup is enabled for the user.
			* <li>The user has completed setup.
			* <li>No backup operation is currently running for the user.
			* </ul>
			*/
	public void onReceive(Context context, Intent intent) {		public void onReceive(Context context, Intent intent) {
	if (RUN_BACKUP_ACTION.equals(intent.getAction())) {		if (!RUN_BACKUP_ACTION.equals(intent.getAction())) {
	synchronized (backupManagerService.getQueueLock()) {		return;
	if (backupManagerService.getPendingInits().size() > 0) {		}
	// If there are pending init operations, we process those
	// and then settle into the usual periodic backup schedule.		synchronized (mUserBackupManagerService.getQueueLock()) {
			if (mUserBackupManagerService.getPendingInits().size() > 0) {
			// If there are pending init operations, we process those and then settle into the
			// usual periodic backup schedule.
	if (MORE_DEBUG) {		if (MORE_DEBUG) {
	Slog.v(TAG, "Init pending at scheduled backup");		Slog.v(TAG, "Init pending at scheduled backup");
	}		}
	try {		try {
	backupManagerService.getAlarmManager().cancel(		PendingIntent runInitIntent = mUserBackupManagerService.getRunInitIntent();
	backupManagerService.getRunInitIntent());		mUserBackupManagerService.getAlarmManager().cancel(runInitIntent);
	backupManagerService.getRunInitIntent().send();		runInitIntent.send();
	} catch (PendingIntent.CanceledException ce) {		} catch (PendingIntent.CanceledException ce) {
	Slog.e(TAG, "Run init intent cancelled");		Slog.w(TAG, "Run init intent cancelled");
	// can't really do more than bail here
	}		}
	} else {		} else {
	// Don't run backups now if we're disabled or not yet		// Don't run backups if we're disabled or not yet set up.
	// fully set up.		if (!mUserBackupManagerService.isEnabled()
	if (backupManagerService.isEnabled()		\|\| !mUserBackupManagerService.isSetupComplete()) {
	&& backupManagerService.isSetupComplete()) {		Slog.w(
	if (!backupManagerService.isBackupRunning()) {		TAG,
	if (DEBUG) {		"Backup pass but enabled="
	Slog.v(TAG, "Running a backup pass");		+ mUserBackupManagerService.isEnabled()
			+ " setupComplete="
			+ mUserBackupManagerService.isSetupComplete());
			return;
	}		}

	// Acquire the wakelock and pass it to the backup thread. it will		// Don't run backups if one is already running.
	// be released once backup concludes.		if (mUserBackupManagerService.isBackupRunning()) {
	backupManagerService.setBackupRunning(true);
	backupManagerService.getWakelock().acquire();

	Message msg = backupManagerService.getBackupHandler().obtainMessage(
	MSG_RUN_BACKUP);
	backupManagerService.getBackupHandler().sendMessage(msg);
	} else {
	Slog.i(TAG, "Backup time but one already running");		Slog.i(TAG, "Backup time but one already running");
			return;
	}		}
	} else {
	Slog.w(TAG, "Backup pass but enabled=" + backupManagerService.isEnabled()		if (DEBUG) {
	+ " setupComplete=" + backupManagerService.isSetupComplete());		Slog.v(TAG, "Running a backup pass");
	}
	}		}

			// Acquire the wakelock and pass it to the backup thread. It will be released once
			// backup concludes.
			mUserBackupManagerService.setBackupRunning(true);
			mUserBackupManagerService.getWakelock().acquire();

			Handler backupHandler = mUserBackupManagerService.getBackupHandler();
			Message message = backupHandler.obtainMessage(MSG_RUN_BACKUP);
			backupHandler.sendMessage(message);
	}		}
	}		}
	}		}

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

+31 −22

Original line number	Original line	Diff line number	Diff line
	@@ -24,41 +24,50 @@ import android.content.BroadcastReceiver;
	import android.content.Context;		import android.content.Context;
	import android.content.Intent;		import android.content.Intent;
	import android.os.PowerManager;		import android.os.PowerManager;
	import android.util.ArraySet;
	import android.util.Slog;		import android.util.Slog;

	import com.android.server.backup.UserBackupManagerService;		import com.android.server.backup.UserBackupManagerService;

			import java.util.Set;

			/**
			* A {@link BroadcastReceiver} for the action {@link UserBackupManagerService#RUN_INITIALIZE_ACTION}
			* that runs an initialization operation on all pending transports.
			*/
	public class RunInitializeReceiver extends BroadcastReceiver {		public class RunInitializeReceiver extends BroadcastReceiver {
	private final UserBackupManagerService mBackupManagerService;		private final UserBackupManagerService mUserBackupManagerService;

	public RunInitializeReceiver(UserBackupManagerService backupManagerService) {		public RunInitializeReceiver(UserBackupManagerService userBackupManagerService) {
	mBackupManagerService = backupManagerService;		mUserBackupManagerService = userBackupManagerService;
	}		}

	public void onReceive(Context context, Intent intent) {		public void onReceive(Context context, Intent intent) {
	if (RUN_INITIALIZE_ACTION.equals(intent.getAction())) {		if (!RUN_INITIALIZE_ACTION.equals(intent.getAction())) {
	synchronized (mBackupManagerService.getQueueLock()) {		return;
	final ArraySet<String> pendingInits = mBackupManagerService.getPendingInits();		}

			synchronized (mUserBackupManagerService.getQueueLock()) {
			Set<String> pendingInits = mUserBackupManagerService.getPendingInits();
	if (DEBUG) {		if (DEBUG) {
	Slog.v(TAG, "Running a device init; " + pendingInits.size() + " pending");		Slog.v(TAG, "Running a device init; " + pendingInits.size() + " pending");
	}		}

	if (pendingInits.size() > 0) {		if (pendingInits.size() > 0) {
	final String[] transports =		String[] transports = pendingInits.toArray(new String[pendingInits.size()]);
	pendingInits.toArray(new String[pendingInits.size()]);

	mBackupManagerService.clearPendingInits();		mUserBackupManagerService.clearPendingInits();

	PowerManager.WakeLock wakelock = mBackupManagerService.getWakelock();		PowerManager.WakeLock wakelock = mUserBackupManagerService.getWakelock();
	wakelock.acquire();		wakelock.acquire();
	OnTaskFinishedListener listener = caller -> wakelock.release();		OnTaskFinishedListener listener = caller -> wakelock.release();

	Runnable task =		Runnable task =
	new PerformInitializeTask(		new PerformInitializeTask(
	mBackupManagerService, transports, null, listener);		mUserBackupManagerService,
	mBackupManagerService.getBackupHandler().post(task);		transports,
	}		/* observer */ null,
			listener);
			mUserBackupManagerService.getBackupHandler().post(task);
	}		}
	}		}
	}		}