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

Merge "Refactor UBMS to use LifecycleOperationStorage."

Browse Source
This commit is contained in:
Paul Hadfield
2021-12-14 10:35:58 +00:00
committed by Android (Google) Code Review
parent a172e37813 c1e3183618
commit 17dd9c30d6
19 changed files with 154 additions and 325 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
services/backup/java/com/android/server/backup/KeyValueAdbBackupEngine.java
View File

@@ -6,7 +6,6 @@ import static android.os.ParcelFileDescriptor.MODE_READ_WRITE;
import static android.os.ParcelFileDescriptor.MODE_TRUNCATE;
import static com.android.server.backup.UserBackupManagerService.BACKUP_MANIFEST_FILENAME;
import static com.android.server.backup.UserBackupManagerService.OP_TYPE_BACKUP_WAIT;
import android.app.ApplicationThreadConstants;
import android.app.IBackupAgent;
@@ -22,6 +21,7 @@ import android.os.RemoteException;
import android.os.SELinux;
import android.util.Slog;
import com.android.server.backup.OperationStorage.OpType;
import com.android.server.backup.fullbackup.AppMetadataBackupWriter;
import com.android.server.backup.remote.ServiceBackupCallback;
import com.android.server.backup.utils.FullBackupUtils;
@@ -162,7 +162,7 @@ public class KeyValueAdbBackupEngine {
long kvBackupAgentTimeoutMillis = mAgentTimeoutParameters.getKvBackupAgentTimeoutMillis();
try {
mBackupManagerService.prepareOperationTimeout(token, kvBackupAgentTimeoutMillis, null,
OP_TYPE_BACKUP_WAIT);
OpType.BACKUP_WAIT);
IBackupCallback callback =
new ServiceBackupCallback(
@@ -262,7 +262,7 @@ public class KeyValueAdbBackupEngine {
pipes = ParcelFileDescriptor.createPipe();
mBackupManagerService.prepareOperationTimeout(token, kvBackupAgentTimeoutMillis, null,
OP_TYPE_BACKUP_WAIT);
OpType.BACKUP_WAIT);
// We will have to create a runnable that will read the manifest and backup data we
// created, such that we can pipe the data into mOutput. The reason we do this is that

298
services/backup/java/com/android/server/backup/UserBackupManagerService.java
View File

@@ -107,12 +107,14 @@ import com.android.internal.util.Preconditions;
import com.android.server.AppWidgetBackupBridge;
import com.android.server.EventLogTags;
import com.android.server.LocalServices;
import com.android.server.backup.OperationStorage.OpState;
import com.android.server.backup.OperationStorage.OpType;
import com.android.server.backup.fullbackup.FullBackupEntry;
import com.android.server.backup.fullbackup.PerformFullTransportBackupTask;
import com.android.server.backup.internal.BackupHandler;
import com.android.server.backup.internal.ClearDataObserver;
import com.android.server.backup.internal.LifecycleOperationStorage;
import com.android.server.backup.internal.OnTaskFinishedListener;
import com.android.server.backup.internal.Operation;
import com.android.server.backup.internal.PerformInitializeTask;
import com.android.server.backup.internal.RunInitializeReceiver;
import com.android.server.backup.internal.SetupObserver;
@@ -287,21 +289,6 @@ public class UserBackupManagerService {
private static final String BACKUP_FINISHED_ACTION = "android.intent.action.BACKUP_FINISHED";
private static final String BACKUP_FINISHED_PACKAGE_EXTRA = "packageName";
// Bookkeeping of in-flight operations. The operation token is the index of the entry in the
// pending operations list.
public static final int OP_PENDING = 0;
private static final int OP_ACKNOWLEDGED = 1;
private static final int OP_TIMEOUT = -1;
// Waiting for backup agent to respond during backup operation.
public static final int OP_TYPE_BACKUP_WAIT = 0;
// Waiting for backup agent to respond during restore operation.
public static final int OP_TYPE_RESTORE_WAIT = 1;
// An entire backup operation spanning multiple packages.
public static final int OP_TYPE_BACKUP = 2;
// Time delay for initialization operations that can be delayed so as not to consume too much
// CPU on bring-up and increase time-to-UI.
private static final long INITIALIZATION_DELAY_MILLIS = 3000;
@@ -400,30 +387,8 @@ public class UserBackupManagerService {
private ActiveRestoreSession mActiveRestoreSession;
/**
* mCurrentOperations contains the list of currently active operations.
*
* If type of operation is OP_TYPE_WAIT, it are waiting for an ack or timeout.
* An operation wraps a BackupRestoreTask within it.
* It's the responsibility of this task to remove the operation from this array.
*
* A BackupRestore task gets notified of ack/timeout for the operation via
* BackupRestoreTask#handleCancel, BackupRestoreTask#operationComplete and notifyAll called
* on the mCurrentOpLock.
* {@link UserBackupManagerService#waitUntilOperationComplete(int)} is
* used in various places to 'wait' for notifyAll and detect change of pending state of an
* operation. So typically, an operation will be removed from this array by:
* - BackupRestoreTask#handleCancel and
* - BackupRestoreTask#operationComplete OR waitUntilOperationComplete. Do not remove at both
* these places because waitUntilOperationComplete relies on the operation being present to
* determine its completion status.
*
* If type of operation is OP_BACKUP, it is a task running backups. It provides a handle to
* cancel backup tasks.
*/
@GuardedBy("mCurrentOpLock")
private final SparseArray<Operation> mCurrentOperations = new SparseArray<>();
private final Object mCurrentOpLock = new Object();
private final LifecycleOperationStorage mOperationStorage;
private final Random mTokenGenerator = new Random();
private final AtomicInteger mNextToken = new AtomicInteger();
@@ -542,12 +507,14 @@ public class UserBackupManagerService {
}
@VisibleForTesting
UserBackupManagerService(Context context, PackageManager packageManager) {
UserBackupManagerService(Context context, PackageManager packageManager,
LifecycleOperationStorage operationStorage) {
mContext = context;
mUserId = 0;
mRegisterTransportsRequestedTime = 0;
mPackageManager = packageManager;
mOperationStorage = operationStorage;
mBaseStateDir = null;
mDataDir = null;
@@ -600,8 +567,10 @@ public class UserBackupManagerService {
BackupAgentTimeoutParameters(Handler.getMain(), mContext.getContentResolver());
mAgentTimeoutParameters.start();
mOperationStorage = new LifecycleOperationStorage(mUserId);
Objects.requireNonNull(userBackupThread, "userBackupThread cannot be null");
mBackupHandler = new BackupHandler(this, userBackupThread);
mBackupHandler = new BackupHandler(this, mOperationStorage, userBackupThread);
// Set up our bookkeeping
final ContentResolver resolver = context.getContentResolver();
@@ -756,6 +725,10 @@ public class UserBackupManagerService {
return mTransportManager;
}
public OperationStorage getOperationStorage() {
return mOperationStorage;
}
public boolean isEnabled() {
return mEnabled;
}
@@ -838,14 +811,6 @@ public class UserBackupManagerService {
return mActiveRestoreSession;
}
public SparseArray<Operation> getCurrentOperations() {
return mCurrentOperations;
}
public Object getCurrentOpLock() {
return mCurrentOpLock;
}
public SparseArray<AdbParams> getAdbBackupRestoreConfirmations() {
return mAdbBackupRestoreConfirmations;
}
@@ -1987,18 +1952,12 @@ public class UserBackupManagerService {
}
final long oldToken = Binder.clearCallingIdentity();
try {
List<Integer> operationsToCancel = new ArrayList<>();
synchronized (mCurrentOpLock) {
for (int i = 0; i < mCurrentOperations.size(); i++) {
Operation op = mCurrentOperations.valueAt(i);
int token = mCurrentOperations.keyAt(i);
if (op.type == OP_TYPE_BACKUP) {
operationsToCancel.add(token);
}
}
}
Set<Integer> operationsToCancel =
mOperationStorage.operationTokensForOpType(OpType.BACKUP);
for (Integer token : operationsToCancel) {
handleCancel(token, true /* cancelAll */);
mOperationStorage.cancelOperation(token, /* cancelAll */ true,
operationType -> { /* no callback needed here */ });
}
// We don't want the backup jobs to kick in any time soon.
// Reschedules them to run in the distant future.
@@ -2012,7 +1971,7 @@ public class UserBackupManagerService {
/** Schedule a timeout message for the operation identified by {@code token}. */
public void prepareOperationTimeout(int token, long interval, BackupRestoreTask callback,
int operationType) {
if (operationType != OP_TYPE_BACKUP_WAIT && operationType != OP_TYPE_RESTORE_WAIT) {
if (operationType != OpType.BACKUP_WAIT && operationType != OpType.RESTORE_WAIT) {
Slog.wtf(
TAG,
addUserIdToLogMessage(
@@ -2036,19 +1995,17 @@ public class UserBackupManagerService {
+ callback));
}
synchronized (mCurrentOpLock) {
mCurrentOperations.put(token, new Operation(OP_PENDING, callback, operationType));
Message msg = mBackupHandler.obtainMessage(getMessageIdForOperationType(operationType),
token, 0, callback);
mBackupHandler.sendMessageDelayed(msg, interval);
}
mOperationStorage.registerOperation(token, OpState.PENDING, callback, operationType);
Message msg = mBackupHandler.obtainMessage(getMessageIdForOperationType(operationType),
token, 0, callback);
mBackupHandler.sendMessageDelayed(msg, interval);
}
private int getMessageIdForOperationType(int operationType) {
switch (operationType) {
case OP_TYPE_BACKUP_WAIT:
case OpType.BACKUP_WAIT:
return MSG_BACKUP_OPERATION_TIMEOUT;
case OP_TYPE_RESTORE_WAIT:
case OpType.RESTORE_WAIT:
return MSG_RESTORE_OPERATION_TIMEOUT;
default:
Slog.wtf(
@@ -2061,162 +2018,28 @@ public class UserBackupManagerService {
}
}
/**
* Add an operation to the list of currently running operations. Used for cancellation,
* completion and timeout callbacks that act on the operation via the {@code token}.
*/
public void putOperation(int token, Operation operation) {
if (MORE_DEBUG) {
Slog.d(
TAG,
addUserIdToLogMessage(
mUserId,
"Adding operation token="
+ Integer.toHexString(token)
+ ", operation type="
+ operation.type));
}
synchronized (mCurrentOpLock) {
mCurrentOperations.put(token, operation);
}
}
/**
* Remove an operation from the list of currently running operations. An operation is removed
* when it is completed, cancelled, or timed out, and thus no longer running.
*/
public void removeOperation(int token) {
if (MORE_DEBUG) {
Slog.d(
TAG,
addUserIdToLogMessage(
mUserId, "Removing operation token=" + Integer.toHexString(token)));
}
synchronized (mCurrentOpLock) {
if (mCurrentOperations.get(token) == null) {
Slog.w(TAG, addUserIdToLogMessage(mUserId, "Duplicate remove for operation. token="
+ Integer.toHexString(token)));
}
mCurrentOperations.remove(token);
}
}
/** Block until we received an operation complete message (from the agent or cancellation). */
public boolean waitUntilOperationComplete(int token) {
if (MORE_DEBUG) {
Slog.i(TAG, addUserIdToLogMessage(mUserId, "Blocking until operation complete for "
+ Integer.toHexString(token)));
}
int finalState = OP_PENDING;
Operation op = null;
synchronized (mCurrentOpLock) {
while (true) {
op = mCurrentOperations.get(token);
if (op == null) {
// mysterious disappearance: treat as success with no callback
break;
} else {
if (op.state == OP_PENDING) {
try {
mCurrentOpLock.wait();
} catch (InterruptedException e) {
}
// When the wait is notified we loop around and recheck the current state
} else {
if (MORE_DEBUG) {
Slog.d(
TAG,
addUserIdToLogMessage(
mUserId,
"Unblocked waiting for operation token="
+ Integer.toHexString(token)));
}
// No longer pending; we're done
finalState = op.state;
break;
}
}
}
}
removeOperation(token);
if (op != null) {
mBackupHandler.removeMessages(getMessageIdForOperationType(op.type));
}
if (MORE_DEBUG) {
Slog.v(TAG, addUserIdToLogMessage(mUserId, "operation " + Integer.toHexString(token)
+ " complete: finalState=" + finalState));
}
return finalState == OP_ACKNOWLEDGED;
return mOperationStorage.waitUntilOperationComplete(token, operationType -> {
mBackupHandler.removeMessages(getMessageIdForOperationType(operationType));
});
}
/** Cancel the operation associated with {@code token}. */
public void handleCancel(int token, boolean cancelAll) {
// Notify any synchronous waiters
Operation op = null;
synchronized (mCurrentOpLock) {
op = mCurrentOperations.get(token);
if (MORE_DEBUG) {
if (op == null) {
Slog.w(
TAG,
addUserIdToLogMessage(
mUserId,
"Cancel of token "
+ Integer.toHexString(token)
+ " but no op found"));
}
// Remove all pending timeout messages of types OpType.BACKUP_WAIT and
// OpType.RESTORE_WAIT. On the other hand, OP_TYPE_BACKUP cannot time out and
// doesn't require cancellation.
mOperationStorage.cancelOperation(token, cancelAll, operationType -> {
if (operationType == OpType.BACKUP_WAIT || operationType == OpType.RESTORE_WAIT) {
mBackupHandler.removeMessages(getMessageIdForOperationType(operationType));
}
int state = (op != null) ? op.state : OP_TIMEOUT;
if (state == OP_ACKNOWLEDGED) {
// The operation finished cleanly, so we have nothing more to do.
if (DEBUG) {
Slog.w(TAG, addUserIdToLogMessage(mUserId, "Operation already got an ack."
+ "Should have been removed from mCurrentOperations."));
}
op = null;
mCurrentOperations.delete(token);
} else if (state == OP_PENDING) {
if (DEBUG) {
Slog.v(
TAG,
addUserIdToLogMessage(
mUserId, "Cancel: token=" + Integer.toHexString(token)));
}
op.state = OP_TIMEOUT;
// Can't delete op from mCurrentOperations here. waitUntilOperationComplete may be
// called after we receive cancel here. We need this op's state there.
// Remove all pending timeout messages of types OP_TYPE_BACKUP_WAIT and
// OP_TYPE_RESTORE_WAIT. On the other hand, OP_TYPE_BACKUP cannot time out and
// doesn't require cancellation.
if (op.type == OP_TYPE_BACKUP_WAIT || op.type == OP_TYPE_RESTORE_WAIT) {
mBackupHandler.removeMessages(getMessageIdForOperationType(op.type));
}
}
mCurrentOpLock.notifyAll();
}
// If there's a TimeoutHandler for this event, call it
if (op != null && op.callback != null) {
if (MORE_DEBUG) {
Slog.v(TAG, addUserIdToLogMessage(mUserId, " Invoking cancel on " + op.callback));
}
op.callback.handleCancel(cancelAll);
}
});
}
/** Returns {@code true} if a backup is currently running, else returns {@code false}. */
public boolean isBackupOperationInProgress() {
synchronized (mCurrentOpLock) {
for (int i = 0; i < mCurrentOperations.size(); i++) {
Operation op = mCurrentOperations.valueAt(i);
if (op.type == OP_TYPE_BACKUP && op.state == OP_PENDING) {
return true;
}
}
}
return false;
return mOperationStorage.isBackupOperationInProgress();
}
/** Unbind the backup agent and kill the app if it's a non-system app. */
@@ -2578,6 +2401,7 @@ public class UserBackupManagerService {
String[] pkg = new String[]{entry.packageName};
mRunningFullBackupTask = PerformFullTransportBackupTask.newWithCurrentTransport(
this,
mOperationStorage,
/* observer */ null,
pkg,
/* updateSchedule */ true,
@@ -3107,6 +2931,7 @@ public class UserBackupManagerService {
CountDownLatch latch = new CountDownLatch(1);
Runnable task = PerformFullTransportBackupTask.newWithCurrentTransport(
this,
mOperationStorage,
/* observer */ null,
pkgNames,
/* updateSchedule */ false,
@@ -4126,48 +3951,11 @@ public class UserBackupManagerService {
* outstanding asynchronous backup/restore operation.
*/
public void opComplete(int token, long result) {
if (MORE_DEBUG) {
Slog.v(
TAG,
addUserIdToLogMessage(
mUserId,
"opComplete: " + Integer.toHexString(token) + " result=" + result));
}
Operation op = null;
synchronized (mCurrentOpLock) {
op = mCurrentOperations.get(token);
if (op != null) {
if (op.state == OP_TIMEOUT) {
// The operation already timed out, and this is a late response. Tidy up
// and ignore it; we've already dealt with the timeout.
op = null;
mCurrentOperations.delete(token);
} else if (op.state == OP_ACKNOWLEDGED) {
if (DEBUG) {
Slog.w(
TAG,
addUserIdToLogMessage(
mUserId,
"Received duplicate ack for token="
+ Integer.toHexString(token)));
}
op = null;
mCurrentOperations.remove(token);
} else if (op.state == OP_PENDING) {
// Can't delete op from mCurrentOperations. waitUntilOperationComplete can be
// called after we we receive this call.
op.state = OP_ACKNOWLEDGED;
}
}
mCurrentOpLock.notifyAll();
}
// The completion callback, if any, is invoked on the handler
if (op != null && op.callback != null) {
Pair<BackupRestoreTask, Long> callbackAndResult = Pair.create(op.callback, result);
mOperationStorage.onOperationComplete(token, result, callback -> {
Pair<BackupRestoreTask, Long> callbackAndResult = Pair.create(callback, result);
Message msg = mBackupHandler.obtainMessage(MSG_OP_COMPLETE, callbackAndResult);
mBackupHandler.sendMessage(msg);
}
});
}
/** Checks if the package is eligible for backup. */

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

@@ -21,7 +21,6 @@ import static com.android.server.backup.BackupManagerService.MORE_DEBUG;
import static com.android.server.backup.BackupManagerService.TAG;
import static com.android.server.backup.UserBackupManagerService.BACKUP_MANIFEST_FILENAME;
import static com.android.server.backup.UserBackupManagerService.BACKUP_METADATA_FILENAME;
import static com.android.server.backup.UserBackupManagerService.OP_TYPE_BACKUP_WAIT;
import static com.android.server.backup.UserBackupManagerService.SHARED_BACKUP_AGENT_PACKAGE;
import android.annotation.UserIdInt;
@@ -39,6 +38,7 @@ import android.util.Slog;
import com.android.server.AppWidgetBackupBridge;
import com.android.server.backup.BackupAgentTimeoutParameters;
import com.android.server.backup.BackupRestoreTask;
import com.android.server.backup.OperationStorage.OpType;
import com.android.server.backup.UserBackupManagerService;
import com.android.server.backup.remote.RemoteCall;
import com.android.server.backup.utils.BackupEligibilityRules;
@@ -147,7 +147,7 @@ public class FullBackupEngine {
mToken,
timeout,
mTimeoutMonitor /* in parent class */,
OP_TYPE_BACKUP_WAIT);
OpType.BACKUP_WAIT);
mAgent.doFullBackup(
mPipe,
mQuota,

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

@@ -18,7 +18,6 @@ package com.android.server.backup.fullbackup;
import static com.android.server.backup.BackupManagerService.MORE_DEBUG;
import static com.android.server.backup.BackupManagerService.TAG;
import static com.android.server.backup.UserBackupManagerService.OP_TYPE_BACKUP_WAIT;
import android.app.backup.IBackupManager;
import android.content.ComponentName;
@@ -33,6 +32,7 @@ import android.util.Slog;
import com.android.internal.backup.IObbBackupService;
import com.android.server.backup.BackupAgentTimeoutParameters;
import com.android.server.backup.OperationStorage.OpType;
import com.android.server.backup.UserBackupManagerService;
import com.android.server.backup.utils.FullBackupUtils;
@@ -83,7 +83,7 @@ public class FullBackupObbConnection implements ServiceConnection {
long fullBackupAgentTimeoutMillis =
mAgentTimeoutParameters.getFullBackupAgentTimeoutMillis();
backupManagerService.prepareOperationTimeout(
token, fullBackupAgentTimeoutMillis, null, OP_TYPE_BACKUP_WAIT);
token, fullBackupAgentTimeoutMillis, null, OpType.BACKUP_WAIT);
mService.backupObbs(pkg.packageName, pipes[1], token,
backupManagerService.getBackupManagerBinder());
FullBackupUtils.routeSocketDataToOutput(pipes[0], out);

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

@@ -37,6 +37,7 @@ import android.util.Slog;
import com.android.server.AppWidgetBackupBridge;
import com.android.server.backup.BackupRestoreTask;
import com.android.server.backup.KeyValueAdbBackupEngine;
import com.android.server.backup.OperationStorage;
import com.android.server.backup.UserBackupManagerService;
import com.android.server.backup.utils.BackupEligibilityRules;
import com.android.server.backup.utils.PasswordUtils;
@@ -67,6 +68,7 @@ import javax.crypto.spec.SecretKeySpec;
public class PerformAdbBackupTask extends FullBackupTask implements BackupRestoreTask {
private final UserBackupManagerService mUserBackupManagerService;
private final OperationStorage mOperationStorage;
private final AtomicBoolean mLatch;
private final ParcelFileDescriptor mOutputFile;
@@ -85,7 +87,8 @@ public class PerformAdbBackupTask extends FullBackupTask implements BackupRestor
private final int mCurrentOpToken;
private final BackupEligibilityRules mBackupEligibilityRules;
public PerformAdbBackupTask(UserBackupManagerService backupManagerService,
public PerformAdbBackupTask(
UserBackupManagerService backupManagerService, OperationStorage operationStorage,
ParcelFileDescriptor fd, IFullBackupRestoreObserver observer,
boolean includeApks, boolean includeObbs, boolean includeShared, boolean doWidgets,
String curPassword, String encryptPassword, boolean doAllApps, boolean doSystem,
@@ -93,6 +96,7 @@ public class PerformAdbBackupTask extends FullBackupTask implements BackupRestor
BackupEligibilityRules backupEligibilityRules) {
super(observer);
mUserBackupManagerService = backupManagerService;
mOperationStorage = operationStorage;
mCurrentOpToken = backupManagerService.generateRandomIntegerToken();
mLatch = latch;
@@ -505,6 +509,6 @@ public class PerformAdbBackupTask extends FullBackupTask implements BackupRestor
if (target != null) {
mUserBackupManagerService.tearDownAgentAndKill(mCurrentTarget.applicationInfo);
}
mUserBackupManagerService.removeOperation(mCurrentOpToken);
mOperationStorage.removeOperation(mCurrentOpToken);
}
}

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

@@ -19,9 +19,6 @@ package com.android.server.backup.fullbackup;
import static com.android.server.backup.BackupManagerService.DEBUG;
import static com.android.server.backup.BackupManagerService.DEBUG_SCHEDULING;
import static com.android.server.backup.BackupManagerService.MORE_DEBUG;
import static com.android.server.backup.UserBackupManagerService.OP_PENDING;
import static com.android.server.backup.UserBackupManagerService.OP_TYPE_BACKUP;
import static com.android.server.backup.UserBackupManagerService.OP_TYPE_BACKUP_WAIT;
import android.annotation.Nullable;
import android.app.IBackupAgent;
@@ -45,10 +42,12 @@ import com.android.server.EventLogTags;
import com.android.server.backup.BackupAgentTimeoutParameters;
import com.android.server.backup.BackupRestoreTask;
import com.android.server.backup.FullBackupJob;
import com.android.server.backup.OperationStorage;
import com.android.server.backup.OperationStorage.OpState;
import com.android.server.backup.OperationStorage.OpType;
import com.android.server.backup.TransportManager;
import com.android.server.backup.UserBackupManagerService;
import com.android.server.backup.internal.OnTaskFinishedListener;
import com.android.server.backup.internal.Operation;
import com.android.server.backup.remote.RemoteCall;
import com.android.server.backup.transport.BackupTransportClient;
import com.android.server.backup.transport.TransportConnection;
@@ -99,6 +98,7 @@ import java.util.concurrent.atomic.AtomicLong;
public class PerformFullTransportBackupTask extends FullBackupTask implements BackupRestoreTask {
public static PerformFullTransportBackupTask newWithCurrentTransport(
UserBackupManagerService backupManagerService,
OperationStorage operationStorage,
IFullBackupRestoreObserver observer,
String[] whichPackages,
boolean updateSchedule,
@@ -118,6 +118,7 @@ public class PerformFullTransportBackupTask extends FullBackupTask implements Ba
listenerCaller);
return new PerformFullTransportBackupTask(
backupManagerService,
operationStorage,
transportConnection,
observer,
whichPackages,
@@ -136,6 +137,7 @@ public class PerformFullTransportBackupTask extends FullBackupTask implements Ba
private UserBackupManagerService mUserBackupManagerService;
private final Object mCancelLock = new Object();
OperationStorage mOperationStorage;
List<PackageInfo> mPackages;
PackageInfo mCurrentPackage;
boolean mUpdateSchedule;
@@ -158,6 +160,7 @@ public class PerformFullTransportBackupTask extends FullBackupTask implements Ba
private final BackupEligibilityRules mBackupEligibilityRules;
public PerformFullTransportBackupTask(UserBackupManagerService backupManagerService,
OperationStorage operationStorage,
TransportConnection transportConnection,
IFullBackupRestoreObserver observer,
String[] whichPackages, boolean updateSchedule,
@@ -165,7 +168,8 @@ public class PerformFullTransportBackupTask extends FullBackupTask implements Ba
@Nullable IBackupManagerMonitor monitor, @Nullable OnTaskFinishedListener listener,
boolean userInitiated, BackupEligibilityRules backupEligibilityRules) {
super(observer);
this.mUserBackupManagerService = backupManagerService;
mUserBackupManagerService = backupManagerService;
mOperationStorage = operationStorage;
mTransportConnection = transportConnection;
mUpdateSchedule = updateSchedule;
mLatch = latch;
@@ -261,16 +265,13 @@ public class PerformFullTransportBackupTask extends FullBackupTask implements Ba
}
private void registerTask() {
synchronized (mUserBackupManagerService.getCurrentOpLock()) {
Slog.d(TAG, "backupmanager pftbt token=" + Integer.toHexString(mCurrentOpToken));
mUserBackupManagerService.getCurrentOperations().put(
mCurrentOpToken,
new Operation(OP_PENDING, this, OP_TYPE_BACKUP));
}
Slog.d(TAG, "backupmanager pftbt token=" + Integer.toHexString(mCurrentOpToken));
mOperationStorage.registerOperation(mCurrentOpToken, OpState.PENDING, this, OpType.BACKUP);
}
// public, because called from KeyValueBackupTask.finishTask.
public void unregisterTask() {
mUserBackupManagerService.removeOperation(mCurrentOpToken);
mOperationStorage.removeOperation(mCurrentOpToken);
}
@Override
@@ -722,7 +723,7 @@ public class PerformFullTransportBackupTask extends FullBackupTask implements Ba
mAgentTimeoutParameters.getFullBackupAgentTimeoutMillis();
try {
mUserBackupManagerService.prepareOperationTimeout(
mCurrentOpToken, fullBackupAgentTimeoutMillis, this, OP_TYPE_BACKUP_WAIT);
mCurrentOpToken, fullBackupAgentTimeoutMillis, this, OpType.BACKUP_WAIT);
if (MORE_DEBUG) {
Slog.d(TAG, "Preflighting full payload of " + pkg.packageName);
}
@@ -777,7 +778,7 @@ public class PerformFullTransportBackupTask extends FullBackupTask implements Ba
}
mResult.set(result);
mLatch.countDown();
mUserBackupManagerService.removeOperation(mCurrentOpToken);
mOperationStorage.removeOperation(mCurrentOpToken);
}
@Override
@@ -787,7 +788,7 @@ public class PerformFullTransportBackupTask extends FullBackupTask implements Ba
}
mResult.set(BackupTransport.AGENT_ERROR);
mLatch.countDown();
mUserBackupManagerService.removeOperation(mCurrentOpToken);
mOperationStorage.removeOperation(mCurrentOpToken);
}
@Override
@@ -837,16 +838,12 @@ public class PerformFullTransportBackupTask extends FullBackupTask implements Ba
}
void registerTask() {
synchronized (mUserBackupManagerService.getCurrentOpLock()) {
mUserBackupManagerService.getCurrentOperations().put(
mCurrentOpToken, new Operation(OP_PENDING, this, OP_TYPE_BACKUP_WAIT));
}
mOperationStorage.registerOperation(mCurrentOpToken,
OpState.PENDING, this, OpType.BACKUP_WAIT);
}
void unregisterTask() {
synchronized (mUserBackupManagerService.getCurrentOpLock()) {
mUserBackupManagerService.getCurrentOperations().remove(mCurrentOpToken);
}
mOperationStorage.removeOperation(mCurrentOpToken);
}
@Override
@@ -956,7 +953,7 @@ public class PerformFullTransportBackupTask extends FullBackupTask implements Ba
mPreflightLatch.countDown();
mBackupLatch.countDown();
// We are done with this operation.
mUserBackupManagerService.removeOperation(mCurrentOpToken);
mOperationStorage.removeOperation(mCurrentOpToken);
}
}
}

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

@@ -35,6 +35,7 @@ import com.android.server.EventLogTags;
import com.android.server.backup.BackupAgentTimeoutParameters;
import com.android.server.backup.BackupRestoreTask;
import com.android.server.backup.DataChangedJournal;
import com.android.server.backup.OperationStorage;
import com.android.server.backup.TransportManager;
import com.android.server.backup.UserBackupManagerService;
import com.android.server.backup.fullbackup.PerformAdbBackupTask;
@@ -84,6 +85,7 @@ public class BackupHandler extends Handler {
public static final int MSG_STOP = 22;
private final UserBackupManagerService backupManagerService;
private final OperationStorage mOperationStorage;
private final BackupAgentTimeoutParameters mAgentTimeoutParameters;
private final HandlerThread mBackupThread;
@@ -92,10 +94,12 @@ public class BackupHandler extends Handler {
volatile boolean mIsStopping = false;
public BackupHandler(
UserBackupManagerService backupManagerService, HandlerThread backupThread) {
UserBackupManagerService backupManagerService, OperationStorage operationStorage,
HandlerThread backupThread) {
super(backupThread.getLooper());
mBackupThread = backupThread;
this.backupManagerService = backupManagerService;
mOperationStorage = operationStorage;
mAgentTimeoutParameters = Objects.requireNonNull(
backupManagerService.getAgentTimeoutParameters(),
"Timeout parameters cannot be null");
@@ -215,6 +219,7 @@ public class BackupHandler extends Handler {
caller);
KeyValueBackupTask.start(
backupManagerService,
mOperationStorage,
transportConnection,
transport.transportDirName(),
queue,
@@ -278,8 +283,8 @@ public class BackupHandler extends Handler {
// TODO: refactor full backup to be a looper-based state machine
// similar to normal backup/restore.
AdbBackupParams params = (AdbBackupParams) msg.obj;
PerformAdbBackupTask task = new PerformAdbBackupTask(backupManagerService,
params.fd,
PerformAdbBackupTask task = new PerformAdbBackupTask(
backupManagerService, mOperationStorage, params.fd,
params.observer, params.includeApks, params.includeObbs,
params.includeShared, params.doWidgets, params.curPassword,
params.encryptPassword, params.allApps, params.includeSystem,
@@ -296,6 +301,7 @@ public class BackupHandler extends Handler {
PerformUnifiedRestoreTask task =
new PerformUnifiedRestoreTask(
backupManagerService,
mOperationStorage,
params.mTransportConnection,
params.observer,
params.monitor,
@@ -332,7 +338,7 @@ public class BackupHandler extends Handler {
// similar to normal backup/restore.
AdbRestoreParams params = (AdbRestoreParams) msg.obj;
PerformAdbRestoreTask task = new PerformAdbRestoreTask(backupManagerService,
params.fd,
mOperationStorage, params.fd,
params.curPassword, params.encryptPassword,
params.observer, params.latch);
(new Thread(task, "adb-restore")).start();
@@ -459,6 +465,7 @@ public class BackupHandler extends Handler {
KeyValueBackupTask.start(
backupManagerService,
mOperationStorage,
params.mTransportConnection,
params.dirName,
params.kvPackages,

17
services/backup/java/com/android/server/backup/keyvalue/KeyValueBackupTask.java
View File

@@ -23,8 +23,6 @@ import static android.os.ParcelFileDescriptor.MODE_READ_WRITE;
import static android.os.ParcelFileDescriptor.MODE_TRUNCATE;
import static com.android.server.backup.UserBackupManagerService.KEY_WIDGET_STATE;
import static com.android.server.backup.UserBackupManagerService.OP_PENDING;
import static com.android.server.backup.UserBackupManagerService.OP_TYPE_BACKUP;
import android.annotation.IntDef;
import android.annotation.Nullable;
@@ -57,10 +55,12 @@ import com.android.server.backup.BackupAgentTimeoutParameters;
import com.android.server.backup.BackupRestoreTask;
import com.android.server.backup.DataChangedJournal;
import com.android.server.backup.KeyValueBackupJob;
import com.android.server.backup.OperationStorage;
import com.android.server.backup.OperationStorage.OpState;
import com.android.server.backup.OperationStorage.OpType;
import com.android.server.backup.UserBackupManagerService;
import com.android.server.backup.fullbackup.PerformFullTransportBackupTask;
import com.android.server.backup.internal.OnTaskFinishedListener;
import com.android.server.backup.internal.Operation;
import com.android.server.backup.remote.RemoteCall;
import com.android.server.backup.remote.RemoteCallable;
import com.android.server.backup.remote.RemoteResult;
@@ -211,6 +211,7 @@ public class KeyValueBackupTask implements BackupRestoreTask, Runnable {
*/
public static KeyValueBackupTask start(
UserBackupManagerService backupManagerService,
OperationStorage operationStorage,
TransportConnection transportConnection,
String transportDirName,
List<String> queue,
@@ -227,6 +228,7 @@ public class KeyValueBackupTask implements BackupRestoreTask, Runnable {
KeyValueBackupTask task =
new KeyValueBackupTask(
backupManagerService,
operationStorage,
transportConnection,
transportDirName,
queue,
@@ -244,6 +246,7 @@ public class KeyValueBackupTask implements BackupRestoreTask, Runnable {
}
private final UserBackupManagerService mBackupManagerService;
private final OperationStorage mOperationStorage;
private final PackageManager mPackageManager;
private final TransportConnection mTransportConnection;
private final BackupAgentTimeoutParameters mAgentTimeoutParameters;
@@ -302,6 +305,7 @@ public class KeyValueBackupTask implements BackupRestoreTask, Runnable {
@VisibleForTesting
public KeyValueBackupTask(
UserBackupManagerService backupManagerService,
OperationStorage operationStorage,
TransportConnection transportConnection,
String transportDirName,
List<String> queue,
@@ -313,6 +317,7 @@ public class KeyValueBackupTask implements BackupRestoreTask, Runnable {
boolean nonIncremental,
BackupEligibilityRules backupEligibilityRules) {
mBackupManagerService = backupManagerService;
mOperationStorage = operationStorage;
mPackageManager = backupManagerService.getPackageManager();
mTransportConnection = transportConnection;
mOriginalQueue = queue;
@@ -338,12 +343,11 @@ public class KeyValueBackupTask implements BackupRestoreTask, Runnable {
}
private void registerTask() {
mBackupManagerService.putOperation(
mCurrentOpToken, new Operation(OP_PENDING, this, OP_TYPE_BACKUP));
mOperationStorage.registerOperation(mCurrentOpToken, OpState.PENDING, this, OpType.BACKUP);
}
private void unregisterTask() {
mBackupManagerService.removeOperation(mCurrentOpToken);
mOperationStorage.removeOperation(mCurrentOpToken);
}
@Override
@@ -639,6 +643,7 @@ public class KeyValueBackupTask implements BackupRestoreTask, Runnable {
private PerformFullTransportBackupTask createFullBackupTask(List<String> packages) {
return new PerformFullTransportBackupTask(
mBackupManagerService,
mOperationStorage,
mTransportConnection,
/* fullBackupRestoreObserver */ null,
packages.toArray(new String[packages.size()]),

8
services/backup/java/com/android/server/backup/restore/AdbRestoreFinishedLatch.java
View File

@@ -23,6 +23,7 @@ import android.util.Slog;
import com.android.server.backup.BackupAgentTimeoutParameters;
import com.android.server.backup.BackupRestoreTask;
import com.android.server.backup.OperationStorage;
import com.android.server.backup.UserBackupManagerService;
import java.util.Objects;
@@ -36,13 +37,16 @@ public class AdbRestoreFinishedLatch implements BackupRestoreTask {
private static final String TAG = "AdbRestoreFinishedLatch";
private UserBackupManagerService backupManagerService;
private final OperationStorage mOperationStorage;
final CountDownLatch mLatch;
private final int mCurrentOpToken;
private final BackupAgentTimeoutParameters mAgentTimeoutParameters;
public AdbRestoreFinishedLatch(UserBackupManagerService backupManagerService,
OperationStorage operationStorage,
int currentOpToken) {
this.backupManagerService = backupManagerService;
mOperationStorage = operationStorage;
mLatch = new CountDownLatch(1);
mCurrentOpToken = currentOpToken;
mAgentTimeoutParameters = Objects.requireNonNull(
@@ -72,7 +76,7 @@ public class AdbRestoreFinishedLatch implements BackupRestoreTask {
Slog.w(TAG, "adb onRestoreFinished() complete");
}
mLatch.countDown();
backupManagerService.removeOperation(mCurrentOpToken);
mOperationStorage.removeOperation(mCurrentOpToken);
}
@Override
@@ -81,6 +85,6 @@ public class AdbRestoreFinishedLatch implements BackupRestoreTask {
Slog.w(TAG, "adb onRestoreFinished() timed out");
}
mLatch.countDown();
backupManagerService.removeOperation(mCurrentOpToken);
mOperationStorage.removeOperation(mCurrentOpToken);
}
}

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

@@ -21,7 +21,6 @@ import static com.android.server.backup.BackupManagerService.MORE_DEBUG;
import static com.android.server.backup.BackupManagerService.TAG;
import static com.android.server.backup.UserBackupManagerService.BACKUP_MANIFEST_FILENAME;
import static com.android.server.backup.UserBackupManagerService.BACKUP_METADATA_FILENAME;
import static com.android.server.backup.UserBackupManagerService.OP_TYPE_RESTORE_WAIT;
import static com.android.server.backup.UserBackupManagerService.SHARED_BACKUP_AGENT_PACKAGE;
import static com.android.server.backup.internal.BackupHandler.MSG_RESTORE_OPERATION_TIMEOUT;
@@ -48,6 +47,8 @@ import com.android.server.backup.BackupAgentTimeoutParameters;
import com.android.server.backup.BackupRestoreTask;
import com.android.server.backup.FileMetadata;
import com.android.server.backup.KeyValueAdbRestoreEngine;
import com.android.server.backup.OperationStorage;
import com.android.server.backup.OperationStorage.OpType;
import com.android.server.backup.UserBackupManagerService;
import com.android.server.backup.fullbackup.FullBackupObbConnection;
import com.android.server.backup.utils.BackupEligibilityRules;
@@ -71,6 +72,7 @@ import java.util.Objects;
public class FullRestoreEngine extends RestoreEngine {
private final UserBackupManagerService mBackupManagerService;
private final OperationStorage mOperationStorage;
private final int mUserId;
// Task in charge of monitoring timeouts
@@ -133,12 +135,14 @@ public class FullRestoreEngine extends RestoreEngine {
private boolean mPipesClosed;
private final BackupEligibilityRules mBackupEligibilityRules;
public FullRestoreEngine(UserBackupManagerService backupManagerService,
public FullRestoreEngine(
UserBackupManagerService backupManagerService, OperationStorage operationStorage,
BackupRestoreTask monitorTask, IFullBackupRestoreObserver observer,
IBackupManagerMonitor monitor, PackageInfo onlyPackage, boolean allowApks,
int ephemeralOpToken, boolean isAdbRestore,
BackupEligibilityRules backupEligibilityRules) {
mBackupManagerService = backupManagerService;
mOperationStorage = operationStorage;
mEphemeralOpToken = ephemeralOpToken;
mMonitorTask = monitorTask;
mObserver = observer;
@@ -409,7 +413,7 @@ public class FullRestoreEngine extends RestoreEngine {
mBackupManagerService.prepareOperationTimeout(token,
timeout,
mMonitorTask,
OP_TYPE_RESTORE_WAIT);
OpType.RESTORE_WAIT);
if (FullBackup.OBB_TREE_TOKEN.equals(info.domain)) {
if (DEBUG) {
@@ -603,9 +607,9 @@ public class FullRestoreEngine extends RestoreEngine {
long fullBackupAgentTimeoutMillis =
mAgentTimeoutParameters.getFullBackupAgentTimeoutMillis();
final AdbRestoreFinishedLatch latch = new AdbRestoreFinishedLatch(
mBackupManagerService, token);
mBackupManagerService, mOperationStorage, token);
mBackupManagerService.prepareOperationTimeout(
token, fullBackupAgentTimeoutMillis, latch, OP_TYPE_RESTORE_WAIT);
token, fullBackupAgentTimeoutMillis, latch, OpType.RESTORE_WAIT);
if (mTargetApp.processName.equals("system")) {
if (MORE_DEBUG) {
Slog.d(TAG, "system agent - restoreFinished on thread");

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

@@ -32,6 +32,7 @@ import android.util.Slog;
import com.android.internal.annotations.VisibleForTesting;
import com.android.server.LocalServices;
import com.android.server.backup.OperationStorage;
import com.android.server.backup.UserBackupManagerService;
import com.android.server.backup.fullbackup.FullBackupObbConnection;
import com.android.server.backup.utils.BackupEligibilityRules;
@@ -60,6 +61,7 @@ import javax.crypto.spec.SecretKeySpec;
public class PerformAdbRestoreTask implements Runnable {
private final UserBackupManagerService mBackupManagerService;
private final OperationStorage mOperationStorage;
private final ParcelFileDescriptor mInputFile;
private final String mCurrentPassword;
private final String mDecryptPassword;
@@ -68,10 +70,12 @@ public class PerformAdbRestoreTask implements Runnable {
private IFullBackupRestoreObserver mObserver;
public PerformAdbRestoreTask(UserBackupManagerService backupManagerService,
public PerformAdbRestoreTask(
UserBackupManagerService backupManagerService, OperationStorage operationStorage,
ParcelFileDescriptor fd, String curPassword, String decryptPassword,
IFullBackupRestoreObserver observer, AtomicBoolean latch) {
this.mBackupManagerService = backupManagerService;
mOperationStorage = operationStorage;
mInputFile = fd;
mCurrentPassword = curPassword;
mDecryptPassword = decryptPassword;
@@ -109,9 +113,9 @@ public class PerformAdbRestoreTask implements Runnable {
mBackupManagerService.getPackageManager(),
LocalServices.getService(PackageManagerInternal.class),
mBackupManagerService.getUserId(), BackupManager.OperationType.ADB_BACKUP);
FullRestoreEngine mEngine = new FullRestoreEngine(mBackupManagerService, null,
mObserver, null, null, true, 0 /*unused*/, true,
eligibilityRules);
FullRestoreEngine mEngine = new FullRestoreEngine(mBackupManagerService,
mOperationStorage, null, mObserver, null, null,
true, 0 /*unused*/, true, eligibilityRules);
FullRestoreEngineThread mEngineThread = new FullRestoreEngineThread(mEngine,
tarInputStream);
mEngineThread.run();

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

@@ -20,7 +20,6 @@ import static com.android.server.backup.BackupManagerService.DEBUG;
import static com.android.server.backup.BackupManagerService.MORE_DEBUG;
import static com.android.server.backup.BackupManagerService.TAG;
import static com.android.server.backup.UserBackupManagerService.KEY_WIDGET_STATE;
import static com.android.server.backup.UserBackupManagerService.OP_TYPE_RESTORE_WAIT;
import static com.android.server.backup.UserBackupManagerService.PACKAGE_MANAGER_SENTINEL;
import static com.android.server.backup.UserBackupManagerService.SETTINGS_PACKAGE;
import static com.android.server.backup.internal.BackupHandler.MSG_BACKUP_RESTORE_STEP;
@@ -60,6 +59,8 @@ import com.android.server.LocalServices;
import com.android.server.backup.BackupAgentTimeoutParameters;
import com.android.server.backup.BackupRestoreTask;
import com.android.server.backup.BackupUtils;
import com.android.server.backup.OperationStorage;
import com.android.server.backup.OperationStorage.OpType;
import com.android.server.backup.PackageManagerBackupAgent;
import com.android.server.backup.PackageManagerBackupAgent.Metadata;
import com.android.server.backup.TransportManager;
@@ -84,6 +85,7 @@ import java.util.Set;
public class PerformUnifiedRestoreTask implements BackupRestoreTask {
private UserBackupManagerService backupManagerService;
private final OperationStorage mOperationStorage;
private final int mUserId;
private final TransportManager mTransportManager;
// Transport client we're working with to do the restore
@@ -169,6 +171,7 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask {
PerformUnifiedRestoreTask(UserBackupManagerService backupManagerService) {
mListener = null;
mAgentTimeoutParameters = null;
mOperationStorage = null;
mTransportConnection = null;
mTransportManager = null;
mEphemeralOpToken = 0;
@@ -181,6 +184,7 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask {
// about releasing it.
public PerformUnifiedRestoreTask(
UserBackupManagerService backupManagerService,
OperationStorage operationStorage,
TransportConnection transportConnection,
IRestoreObserver observer,
IBackupManagerMonitor monitor,
@@ -192,6 +196,7 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask {
OnTaskFinishedListener listener,
BackupEligibilityRules backupEligibilityRules) {
this.backupManagerService = backupManagerService;
mOperationStorage = operationStorage;
mUserId = backupManagerService.getUserId();
mTransportManager = backupManagerService.getTransportManager();
mEphemeralOpToken = backupManagerService.generateRandomIntegerToken();
@@ -767,7 +772,7 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask {
long restoreAgentTimeoutMillis = mAgentTimeoutParameters.getRestoreAgentTimeoutMillis(
app.applicationInfo.uid);
backupManagerService.prepareOperationTimeout(
mEphemeralOpToken, restoreAgentTimeoutMillis, this, OP_TYPE_RESTORE_WAIT);
mEphemeralOpToken, restoreAgentTimeoutMillis, this, OpType.RESTORE_WAIT);
startedAgentRestore = true;
mAgent.doRestoreWithExcludedKeys(mBackupData, appVersionCode, mNewState,
mEphemeralOpToken, backupManagerService.getBackupManagerBinder(),
@@ -877,7 +882,7 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask {
backupManagerService
.prepareOperationTimeout(mEphemeralOpToken,
restoreAgentFinishedTimeoutMillis, this,
OP_TYPE_RESTORE_WAIT);
OpType.RESTORE_WAIT);
mAgent.doRestoreFinished(mEphemeralOpToken,
backupManagerService.getBackupManagerBinder());
// If we get this far, the callback or timeout will schedule the
@@ -921,7 +926,7 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask {
EventLog.writeEvent(EventLogTags.FULL_RESTORE_PACKAGE,
mCurrentPackage.packageName);
mEngine = new FullRestoreEngine(backupManagerService, this, null,
mEngine = new FullRestoreEngine(backupManagerService, mOperationStorage, this, null,
mMonitor, mCurrentPackage, false, mEphemeralOpToken, false,
mBackupEligibilityRules);
mEngineThread = new FullRestoreEngineThread(mEngine, mEnginePipes[0]);
@@ -1071,7 +1076,7 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask {
// The app has timed out handling a restoring file
@Override
public void handleCancel(boolean cancelAll) {
backupManagerService.removeOperation(mEphemeralOpToken);
mOperationStorage.removeOperation(mEphemeralOpToken);
if (DEBUG) {
Slog.w(TAG, "Full-data restore target timed out; shutting down");
}
@@ -1268,7 +1273,7 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask {
@Override
public void operationComplete(long unusedResult) {
backupManagerService.removeOperation(mEphemeralOpToken);
mOperationStorage.removeOperation(mEphemeralOpToken);
if (MORE_DEBUG) {
Slog.i(TAG, "operationComplete() during restore: target="
+ mCurrentPackage.packageName
@@ -1331,7 +1336,7 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask {
// A call to agent.doRestore() or agent.doRestoreFinished() has timed out
@Override
public void handleCancel(boolean cancelAll) {
backupManagerService.removeOperation(mEphemeralOpToken);
mOperationStorage.removeOperation(mEphemeralOpToken);
Slog.e(TAG, "Timeout restoring application " + mCurrentPackage.packageName);
mMonitor = BackupManagerMonitorUtils.monitorEvent(mMonitor,
BackupManagerMonitor.LOG_EVENT_ID_KEY_VALUE_RESTORE_TIMEOUT,

5
services/robotests/backup/src/com/android/server/backup/keyvalue/KeyValueBackupTaskTest.java
View File

@@ -278,7 +278,7 @@ public class KeyValueBackupTaskTest {
assertThat(mBackupManagerService.getPendingInits()).isEmpty();
assertThat(mBackupManagerService.isBackupRunning()).isFalse();
assertThat(mBackupManagerService.getCurrentOperations().size()).isEqualTo(0);
assertThat(mBackupManagerService.getOperationStorage().numOperations()).isEqualTo(0);
verify(mOldJournal).delete();
}
@@ -449,7 +449,7 @@ public class KeyValueBackupTaskTest {
assertThat(mBackupManagerService.getPendingInits()).isEmpty();
assertThat(mBackupManagerService.isBackupRunning()).isFalse();
assertThat(mBackupManagerService.getCurrentOperations().size()).isEqualTo(0);
assertThat(mBackupManagerService.getOperationStorage().numOperations()).isEqualTo(0);
assertThat(mBackupManagerService.getCurrentToken()).isEqualTo(1234L);
verify(mBackupManagerService).writeRestoreTokens();
verify(mOldJournal).delete();
@@ -2665,6 +2665,7 @@ public class KeyValueBackupTaskTest {
KeyValueBackupTask task =
new KeyValueBackupTask(
mBackupManagerService,
mBackupManagerService.getOperationStorage(),
transportMock.mTransportConnection,
transportMock.transportData.transportDirName,
queue,

6
services/robotests/backup/src/com/android/server/backup/restore/ActiveRestoreSessionTest.java
View File

@@ -51,6 +51,7 @@ import android.platform.test.annotations.Presubmit;
import com.android.server.EventLogTags;
import com.android.server.backup.BackupAgentTimeoutParameters;
import com.android.server.backup.OperationStorage;
import com.android.server.backup.TransportManager;
import com.android.server.backup.UserBackupManagerService;
import com.android.server.backup.internal.BackupHandler;
@@ -98,6 +99,7 @@ public class ActiveRestoreSessionTest {
@Mock private IRestoreObserver mObserver;
@Mock private IBackupManagerMonitor mMonitor;
@Mock private BackupEligibilityRules mBackupEligibilityRules;
@Mock private OperationStorage mOperationStorage;
private ShadowLooper mShadowBackupLooper;
private ShadowApplication mShadowApplication;
private UserBackupManagerService.BackupWakeLock mWakeLock;
@@ -132,7 +134,9 @@ public class ActiveRestoreSessionTest {
// We need to mock BMS timeout parameters before initializing the BackupHandler since
// the constructor of BackupHandler relies on it.
when(mBackupManagerService.getAgentTimeoutParameters()).thenReturn(agentTimeoutParameters);
BackupHandler backupHandler = new BackupHandler(mBackupManagerService, handlerThread);
BackupHandler backupHandler =
new BackupHandler(mBackupManagerService, mOperationStorage, handlerThread);
mWakeLock = createBackupWakeLock(application);

1
services/robotests/backup/src/com/android/server/backup/testing/BackupManagerServiceTestUtils.java
View File

@@ -120,7 +120,6 @@ public class BackupManagerServiceTestUtils {
when(backupManagerService.getTransportManager()).thenReturn(transportManager);
when(backupManagerService.getPackageManager()).thenReturn(packageManager);
when(backupManagerService.getBackupHandler()).thenReturn(backupHandler);
when(backupManagerService.getCurrentOpLock()).thenReturn(new Object());
when(backupManagerService.getQueueLock()).thenReturn(new Object());
when(backupManagerService.getActivityManager()).thenReturn(mock(IActivityManager.class));
when(backupManagerService.getWakelock()).thenReturn(wakeLock);

2
services/robotests/src/com/android/server/testing/shadows/ShadowKeyValueBackupTask.java
View File

@@ -19,6 +19,7 @@ package com.android.server.testing.shadows;
import android.annotation.Nullable;
import com.android.server.backup.DataChangedJournal;
import com.android.server.backup.OperationStorage;
import com.android.server.backup.UserBackupManagerService;
import com.android.server.backup.internal.OnTaskFinishedListener;
import com.android.server.backup.keyvalue.KeyValueBackupReporter;
@@ -56,6 +57,7 @@ public class ShadowKeyValueBackupTask {
@Implementation
protected void __constructor__(
UserBackupManagerService backupManagerService,
OperationStorage operationStorage,
TransportConnection transportConnection,
String transportDirName,
List<String> queue,

2
services/robotests/src/com/android/server/testing/shadows/ShadowPerformUnifiedRestoreTask.java
View File

@@ -21,6 +21,7 @@ import android.app.backup.IBackupManagerMonitor;
import android.app.backup.IRestoreObserver;
import android.content.pm.PackageInfo;
import com.android.server.backup.OperationStorage;
import com.android.server.backup.UserBackupManagerService;
import com.android.server.backup.internal.OnTaskFinishedListener;
import com.android.server.backup.restore.PerformUnifiedRestoreTask;
@@ -57,6 +58,7 @@ public class ShadowPerformUnifiedRestoreTask {
@Implementation
protected void __constructor__(
UserBackupManagerService backupManagerService,
OperationStorage operationStorage,
TransportConnection transportConnection,
IRestoreObserver observer,
IBackupManagerMonitor monitor,

10
services/tests/servicestests/src/com/android/server/backup/UserBackupManagerServiceTest.java
View File

@@ -35,6 +35,7 @@ import android.platform.test.annotations.Presubmit;
import androidx.test.runner.AndroidJUnit4;
import com.android.server.backup.internal.LifecycleOperationStorage;
import com.android.server.backup.internal.OnTaskFinishedListener;
import com.android.server.backup.params.BackupParams;
import com.android.server.backup.transport.BackupTransportClient;
@@ -60,7 +61,7 @@ public class UserBackupManagerServiceTest {
@Mock TransportConnection mTransportConnection;
@Mock BackupTransportClient mBackupTransport;
@Mock BackupEligibilityRules mBackupEligibilityRules;
@Mock LifecycleOperationStorage mOperationStorage;
private TestBackupService mService;
@@ -68,7 +69,7 @@ public class UserBackupManagerServiceTest {
public void setUp() throws Exception {
MockitoAnnotations.initMocks(this);
mService = new TestBackupService(mContext, mPackageManager);
mService = new TestBackupService(mContext, mPackageManager, mOperationStorage);
mService.setEnabled(true);
mService.setSetupComplete(true);
}
@@ -173,8 +174,9 @@ public class UserBackupManagerServiceTest {
boolean isEnabledStatePersisted = false;
boolean shouldUseNewBackupEligibilityRules = false;
TestBackupService(Context context, PackageManager packageManager) {
super(context, packageManager);
TestBackupService(Context context, PackageManager packageManager,
LifecycleOperationStorage operationStorage) {
super(context, packageManager, operationStorage);
}
@Override

5
services/tests/servicestests/src/com/android/server/backup/internal/BackupHandlerTest.java
View File

@@ -18,7 +18,6 @@ package com.android.server.backup.internal;
import static org.mockito.Mockito.when;
import static org.testng.Assert.assertFalse;
import static org.testng.Assert.assertThrows;
import static org.testng.Assert.assertTrue;
import android.os.HandlerThread;
@@ -28,6 +27,7 @@ import android.platform.test.annotations.Presubmit;
import androidx.test.runner.AndroidJUnit4;
import com.android.server.backup.BackupAgentTimeoutParameters;
import com.android.server.backup.OperationStorage;
import com.android.server.backup.UserBackupManagerService;
import org.junit.After;
@@ -46,6 +46,7 @@ public class BackupHandlerTest {
private static final int MESSAGE_TIMEOUT_MINUTES = 1;
@Mock private UserBackupManagerService mUserBackupManagerService;
@Mock private OperationStorage mOperationStorage;
@Mock private BackupAgentTimeoutParameters mTimeoutParameters;
private HandlerThread mHandlerThread;
@@ -114,7 +115,7 @@ public class BackupHandlerTest {
private final boolean mShouldStop;
TestBackupHandler(boolean shouldStop) {
super(mUserBackupManagerService, mHandlerThread);
super(mUserBackupManagerService, mOperationStorage, mHandlerThread);
mShouldStop = shouldStop;
}