Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Encapsulate RefactoredBackupManagerService fields."

Browse Source
This commit is contained in:
TreeHugger Robot
2017-04-24 13:26:56 +00:00
committed by Android (Google) Code Review
parent 04fbbec585 d6c00c7110
commit 6d021ba5fd
17 changed files with 479 additions and 244 deletions
Download Patch File Download Diff File Expand all files Collapse all files

297
services/backup/java/com/android/server/backup/RefactoredBackupManagerService.java
View File

@@ -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;

4
services/backup/java/com/android/server/backup/fullbackup/FullBackupEngine.java
View File

@@ -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);

6
services/backup/java/com/android/server/backup/fullbackup/FullBackupObbConnection.java
View File

@@ -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) {

16
services/backup/java/com/android/server/backup/fullbackup/PerformAdbBackupTask.java
View File

@@ -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();
}
}

35
services/backup/java/com/android/server/backup/fullbackup/PerformFullTransportBackupTask.java
View File

@@ -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);
}
}

71
services/backup/java/com/android/server/backup/internal/BackupHandler.java
View File

@@ -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,

6
services/backup/java/com/android/server/backup/internal/ClearDataObserver.java
View File

@@ -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();
}
}
}

54
services/backup/java/com/android/server/backup/internal/PerformBackupTask.java
View File

@@ -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);
}
}

4
services/backup/java/com/android/server/backup/internal/PerformClearTask.java
View File

@@ -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();
}
}
}

14
services/backup/java/com/android/server/backup/internal/PerformInitializeTask.java
View File

@@ -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();
}
}
}

14
services/backup/java/com/android/server/backup/internal/ProvisionedObserver.java
View File

@@ -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);
}
}

26
services/backup/java/com/android/server/backup/internal/RunBackupReceiver.java
View File

@@ -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());
}
}
}

8
services/backup/java/com/android/server/backup/internal/RunInitializeReceiver.java
View File

@@ -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);
}
}
}

50
services/backup/java/com/android/server/backup/restore/ActiveRestoreSession.java
View File

@@ -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));
}
}

20
services/backup/java/com/android/server/backup/restore/FullRestoreEngine.java
View File

@@ -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;

35
services/backup/java/com/android/server/backup/restore/PerformAdbRestoreTask.java
View File

@@ -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;

63
services/backup/java/com/android/server/backup/restore/PerformUnifiedRestoreTask.java
View File

@@ -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