diff options
15 files changed, 718 insertions, 244 deletions
diff --git a/services/backup/java/com/android/server/backup/UserBackupManagerService.java b/services/backup/java/com/android/server/backup/UserBackupManagerService.java index d5aee9284116..4c137bce4f7b 100644 --- a/services/backup/java/com/android/server/backup/UserBackupManagerService.java +++ b/services/backup/java/com/android/server/backup/UserBackupManagerService.java @@ -132,7 +132,8 @@ import com.android.server.backup.transport.TransportConnection; import com.android.server.backup.transport.TransportNotAvailableException; import com.android.server.backup.transport.TransportNotRegisteredException; import com.android.server.backup.utils.BackupEligibilityRules; -import com.android.server.backup.utils.BackupManagerMonitorUtils; +import com.android.server.backup.utils.BackupManagerMonitorDumpsysUtils; +import com.android.server.backup.utils.BackupManagerMonitorEventSender; import com.android.server.backup.utils.BackupObserverUtils; import com.android.server.backup.utils.SparseArrayUtils; @@ -141,6 +142,7 @@ import dalvik.annotation.optimization.NeverCompile; import com.google.android.collect.Sets; import java.io.BufferedInputStream; +import java.io.BufferedReader; import java.io.ByteArrayOutputStream; import java.io.DataInputStream; import java.io.DataOutputStream; @@ -149,6 +151,7 @@ import java.io.FileDescriptor; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; +import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.io.RandomAccessFile; @@ -1830,12 +1833,14 @@ public class UserBackupManagerService { */ public int requestBackup(String[] packages, IBackupObserver observer, IBackupManagerMonitor monitor, int flags) { + BackupManagerMonitorEventSender mBackupManagerMonitorEventSender = + getBMMEventSender(monitor); mContext.enforceCallingPermission(android.Manifest.permission.BACKUP, "requestBackup"); if (packages == null || packages.length < 1) { Slog.e(TAG, addUserIdToLogMessage(mUserId, "No packages named for backup request")); BackupObserverUtils.sendBackupFinished(observer, BackupManager.ERROR_TRANSPORT_ABORTED); - monitor = BackupManagerMonitorUtils.monitorEvent(monitor, + mBackupManagerMonitorEventSender.monitorEvent( BackupManagerMonitor.LOG_EVENT_ID_NO_PACKAGES, null, BackupManagerMonitor.LOG_EVENT_CATEGORY_TRANSPORT, null); throw new IllegalArgumentException("No packages are provided for backup"); @@ -1853,7 +1858,7 @@ public class UserBackupManagerService { final int logTag = mSetupComplete ? BackupManagerMonitor.LOG_EVENT_ID_BACKUP_DISABLED : BackupManagerMonitor.LOG_EVENT_ID_DEVICE_NOT_PROVISIONED; - monitor = BackupManagerMonitorUtils.monitorEvent(monitor, logTag, null, + mBackupManagerMonitorEventSender.monitorEvent(logTag, null, BackupManagerMonitor.LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY, null); return BackupManager.ERROR_BACKUP_NOT_ALLOWED; } @@ -1871,7 +1876,7 @@ public class UserBackupManagerService { } catch (TransportNotRegisteredException | TransportNotAvailableException | RemoteException e) { BackupObserverUtils.sendBackupFinished(observer, BackupManager.ERROR_TRANSPORT_ABORTED); - monitor = BackupManagerMonitorUtils.monitorEvent(monitor, + mBackupManagerMonitorEventSender.monitorEvent( BackupManagerMonitor.LOG_EVENT_ID_TRANSPORT_IS_NULL, null, BackupManagerMonitor.LOG_EVENT_CATEGORY_TRANSPORT, null); return BackupManager.ERROR_TRANSPORT_ABORTED; @@ -3066,7 +3071,9 @@ public class UserBackupManagerService { /* caller */ "BMS.reportDelayedRestoreResult"); IBackupManagerMonitor monitor = transportClient.getBackupManagerMonitor(); - BackupManagerMonitorUtils.sendAgentLoggingResults(monitor, packageInfo, results, + BackupManagerMonitorEventSender mBackupManagerMonitorEventSender = + getBMMEventSender(monitor); + mBackupManagerMonitorEventSender.sendAgentLoggingResults(packageInfo, results, BackupAnnotations.OperationType.RESTORE); } catch (NameNotFoundException | TransportNotAvailableException | TransportNotRegisteredException | RemoteException e) { @@ -3190,6 +3197,11 @@ public class UserBackupManagerService { } } + @VisibleForTesting + BackupManagerMonitorEventSender getBMMEventSender(IBackupManagerMonitor monitor) { + return new BackupManagerMonitorEventSender(monitor); + } + /** User-configurable enabling/disabling of backups. */ public void setBackupEnabled(boolean enable) { setBackupEnabled(enable, /* persistToDisk */ true); @@ -4148,6 +4160,7 @@ public class UserBackupManagerService { } } dumpInternal(pw); + dumpBMMEvents(pw); } finally { Binder.restoreCallingIdentity(identityToken); } @@ -4165,6 +4178,23 @@ public class UserBackupManagerService { } } + private void dumpBMMEvents(PrintWriter pw) { + BackupManagerMonitorDumpsysUtils bm = + new BackupManagerMonitorDumpsysUtils(); + File events = bm.getBMMEventsFile(); + pw.println("START OF BACKUP MANAGER MONITOR EVENTS"); + try (BufferedReader reader = new BufferedReader(new FileReader(events))) { + String line; + while ((line = reader.readLine()) != null) { + pw.println(line); + } + } catch (IOException e) { + Slog.e(TAG, "IO Exception when reading BMM events from file: " + e); + pw.println("IO Exception when reading BMM events from file"); + } + pw.println("END OF BACKUP MANAGER MONITOR EVENTS"); + } + @NeverCompile // Avoid size overhead of debugging code. private void dumpInternal(PrintWriter pw) { // Add prefix for only non-system users so that system user dumpsys is the same as before diff --git a/services/backup/java/com/android/server/backup/fullbackup/FullBackupEngine.java b/services/backup/java/com/android/server/backup/fullbackup/FullBackupEngine.java index ad29422501c6..12712063e344 100644 --- a/services/backup/java/com/android/server/backup/fullbackup/FullBackupEngine.java +++ b/services/backup/java/com/android/server/backup/fullbackup/FullBackupEngine.java @@ -23,13 +23,11 @@ import static com.android.server.backup.UserBackupManagerService.BACKUP_MANIFEST import static com.android.server.backup.UserBackupManagerService.BACKUP_METADATA_FILENAME; import static com.android.server.backup.UserBackupManagerService.SHARED_BACKUP_AGENT_PACKAGE; -import android.annotation.Nullable; import android.annotation.UserIdInt; import android.app.ApplicationThreadConstants; import android.app.IBackupAgent; import android.app.backup.BackupTransport; import android.app.backup.FullBackupDataOutput; -import android.app.backup.IBackupManagerMonitor; import android.content.pm.ApplicationInfo; import android.content.pm.PackageInfo; import android.content.pm.PackageManager; @@ -44,7 +42,7 @@ 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; -import com.android.server.backup.utils.BackupManagerMonitorUtils; +import com.android.server.backup.utils.BackupManagerMonitorEventSender; import com.android.server.backup.utils.FullBackupUtils; import java.io.File; @@ -69,7 +67,7 @@ public class FullBackupEngine { private final int mTransportFlags; private final BackupAgentTimeoutParameters mAgentTimeoutParameters; private final BackupEligibilityRules mBackupEligibilityRules; - @Nullable private final IBackupManagerMonitor mMonitor; + private final BackupManagerMonitorEventSender mBackupManagerMonitorEventSender; class FullBackupRunner implements Runnable { private final @UserIdInt int mUserId; @@ -198,7 +196,7 @@ public class FullBackupEngine { int opToken, int transportFlags, BackupEligibilityRules backupEligibilityRules, - IBackupManagerMonitor monitor) { + BackupManagerMonitorEventSender backupManagerMonitorEventSender) { this.backupManagerService = backupManagerService; mOutput = output; mPreflightHook = preflightHook; @@ -213,7 +211,7 @@ public class FullBackupEngine { backupManagerService.getAgentTimeoutParameters(), "Timeout parameters cannot be null"); mBackupEligibilityRules = backupEligibilityRules; - mMonitor = monitor; + mBackupManagerMonitorEventSender = backupManagerMonitorEventSender; } public int preflightCheck() throws RemoteException { @@ -270,7 +268,7 @@ public class FullBackupEngine { result = BackupTransport.TRANSPORT_OK; } - BackupManagerMonitorUtils.monitorAgentLoggingResults(mMonitor, mPkg, mAgent); + mBackupManagerMonitorEventSender.monitorAgentLoggingResults(mPkg, mAgent); } catch (IOException e) { Slog.e(TAG, "Error backing up " + mPkg.packageName + ": " + e.getMessage()); result = BackupTransport.AGENT_ERROR; diff --git a/services/backup/java/com/android/server/backup/fullbackup/PerformAdbBackupTask.java b/services/backup/java/com/android/server/backup/fullbackup/PerformAdbBackupTask.java index cba1e299ff58..dc6709141b25 100644 --- a/services/backup/java/com/android/server/backup/fullbackup/PerformAdbBackupTask.java +++ b/services/backup/java/com/android/server/backup/fullbackup/PerformAdbBackupTask.java @@ -40,6 +40,7 @@ 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.BackupManagerMonitorEventSender; import com.android.server.backup.utils.PasswordUtils; import java.io.ByteArrayOutputStream; @@ -421,7 +422,7 @@ public class PerformAdbBackupTask extends FullBackupTask implements BackupRestor mCurrentOpToken, /*transportFlags=*/ 0, mBackupEligibilityRules, - /* monitor= */ null); + new BackupManagerMonitorEventSender(null)); sendOnBackupPackage(isSharedStorage ? "Shared storage" : pkg.packageName); // Don't need to check preflight result as there is no preflight hook. diff --git a/services/backup/java/com/android/server/backup/fullbackup/PerformFullTransportBackupTask.java b/services/backup/java/com/android/server/backup/fullbackup/PerformFullTransportBackupTask.java index 162046a66560..6aed9aa15860 100644 --- a/services/backup/java/com/android/server/backup/fullbackup/PerformFullTransportBackupTask.java +++ b/services/backup/java/com/android/server/backup/fullbackup/PerformFullTransportBackupTask.java @@ -54,7 +54,7 @@ import com.android.server.backup.transport.BackupTransportClient; import com.android.server.backup.transport.TransportConnection; import com.android.server.backup.transport.TransportNotAvailableException; import com.android.server.backup.utils.BackupEligibilityRules; -import com.android.server.backup.utils.BackupManagerMonitorUtils; +import com.android.server.backup.utils.BackupManagerMonitorEventSender; import com.android.server.backup.utils.BackupObserverUtils; import com.google.android.collect.Sets; @@ -153,7 +153,6 @@ public class PerformFullTransportBackupTask extends FullBackupTask implements Ba CountDownLatch mLatch; FullBackupJob mJob; // if a scheduled job needs to be finished afterwards IBackupObserver mBackupObserver; - @Nullable private IBackupManagerMonitor mMonitor; boolean mUserInitiated; SinglePackageBackupRunner mBackupRunner; private final int mBackupRunnerOpToken; @@ -167,6 +166,7 @@ public class PerformFullTransportBackupTask extends FullBackupTask implements Ba private final int mCurrentOpToken; private final BackupAgentTimeoutParameters mAgentTimeoutParameters; private final BackupEligibilityRules mBackupEligibilityRules; + private BackupManagerMonitorEventSender mBackupManagerMonitorEventSender; public PerformFullTransportBackupTask(UserBackupManagerService backupManagerService, OperationStorage operationStorage, @@ -185,11 +185,12 @@ public class PerformFullTransportBackupTask extends FullBackupTask implements Ba mJob = runningJob; mPackages = new ArrayList<>(whichPackages.length); mBackupObserver = backupObserver; - mMonitor = monitor; mListener = (listener != null) ? listener : OnTaskFinishedListener.NOP; mUserInitiated = userInitiated; mCurrentOpToken = backupManagerService.generateRandomIntegerToken(); mBackupRunnerOpToken = backupManagerService.generateRandomIntegerToken(); + mBackupManagerMonitorEventSender = + new BackupManagerMonitorEventSender(monitor); mAgentTimeoutParameters = Objects.requireNonNull( backupManagerService.getAgentTimeoutParameters(), "Timeout parameters cannot be null"); @@ -218,7 +219,7 @@ public class PerformFullTransportBackupTask extends FullBackupTask implements Ba if (MORE_DEBUG) { Slog.d(TAG, "Ignoring ineligible package " + pkg); } - mMonitor = BackupManagerMonitorUtils.monitorEvent(mMonitor, + mBackupManagerMonitorEventSender.monitorEvent( BackupManagerMonitor.LOG_EVENT_ID_PACKAGE_INELIGIBLE, mCurrentPackage, BackupManagerMonitor.LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY, @@ -233,7 +234,7 @@ public class PerformFullTransportBackupTask extends FullBackupTask implements Ba Slog.d(TAG, "Ignoring full-data backup of key/value participant " + pkg); } - mMonitor = BackupManagerMonitorUtils.monitorEvent(mMonitor, + mBackupManagerMonitorEventSender.monitorEvent( BackupManagerMonitor.LOG_EVENT_ID_PACKAGE_KEY_VALUE_PARTICIPANT, mCurrentPackage, BackupManagerMonitor.LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY, @@ -248,7 +249,7 @@ public class PerformFullTransportBackupTask extends FullBackupTask implements Ba if (MORE_DEBUG) { Slog.d(TAG, "Ignoring stopped package " + pkg); } - mMonitor = BackupManagerMonitorUtils.monitorEvent(mMonitor, + mBackupManagerMonitorEventSender.monitorEvent( BackupManagerMonitor.LOG_EVENT_ID_PACKAGE_STOPPED, mCurrentPackage, BackupManagerMonitor.LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY, @@ -260,7 +261,7 @@ public class PerformFullTransportBackupTask extends FullBackupTask implements Ba mPackages.add(info); } catch (NameNotFoundException e) { Slog.i(TAG, "Requested package " + pkg + " not found; ignoring"); - mMonitor = BackupManagerMonitorUtils.monitorEvent(mMonitor, + mBackupManagerMonitorEventSender.monitorEvent( BackupManagerMonitor.LOG_EVENT_ID_PACKAGE_NOT_FOUND, mCurrentPackage, BackupManagerMonitor.LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY, @@ -356,8 +357,8 @@ public class PerformFullTransportBackupTask extends FullBackupTask implements Ba } else { monitoringEvent = BackupManagerMonitor.LOG_EVENT_ID_DEVICE_NOT_PROVISIONED; } - mMonitor = BackupManagerMonitorUtils - .monitorEvent(mMonitor, monitoringEvent, null, + mBackupManagerMonitorEventSender + .monitorEvent(monitoringEvent, null, BackupManagerMonitor.LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY, null); mUpdateSchedule = false; @@ -369,7 +370,7 @@ public class PerformFullTransportBackupTask extends FullBackupTask implements Ba if (transport == null) { Slog.w(TAG, "Transport not present; full data backup not performed"); backupRunStatus = BackupManager.ERROR_TRANSPORT_ABORTED; - mMonitor = BackupManagerMonitorUtils.monitorEvent(mMonitor, + mBackupManagerMonitorEventSender.monitorEvent( BackupManagerMonitor.LOG_EVENT_ID_PACKAGE_TRANSPORT_NOT_PRESENT, mCurrentPackage, BackupManagerMonitor.LOG_EVENT_CATEGORY_TRANSPORT, null); @@ -378,9 +379,10 @@ public class PerformFullTransportBackupTask extends FullBackupTask implements Ba // In some cases there may not be a monitor passed in when creating this task. So, if we // don't have one already we ask the transport for a monitor. - if (mMonitor == null) { + if (mBackupManagerMonitorEventSender.getMonitor() == null) { try { - mMonitor = transport.getBackupManagerMonitor(); + mBackupManagerMonitorEventSender + .setMonitor(transport.getBackupManagerMonitor()); } catch (RemoteException e) { Slog.i(TAG, "Failed to retrieve monitor from transport"); } @@ -457,11 +459,11 @@ public class PerformFullTransportBackupTask extends FullBackupTask implements Ba + packageName + ": " + preflightResult + ", not running backup."); } - mMonitor = BackupManagerMonitorUtils.monitorEvent(mMonitor, + mBackupManagerMonitorEventSender.monitorEvent( BackupManagerMonitor.LOG_EVENT_ID_ERROR_PREFLIGHT, mCurrentPackage, BackupManagerMonitor.LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY, - BackupManagerMonitorUtils.putMonitoringExtra(null, + mBackupManagerMonitorEventSender.putMonitoringExtra(null, BackupManagerMonitor.EXTRA_LOG_PREFLIGHT_ERROR, preflightResult)); backupPackageStatus = (int) preflightResult; @@ -492,7 +494,7 @@ public class PerformFullTransportBackupTask extends FullBackupTask implements Ba if (backupPackageStatus == BackupTransport.TRANSPORT_QUOTA_EXCEEDED) { Slog.w(TAG, "Package hit quota limit in-flight " + packageName + ": " + totalRead + " of " + quota); - mMonitor = BackupManagerMonitorUtils.monitorEvent(mMonitor, + mBackupManagerMonitorEventSender.monitorEvent( BackupManagerMonitor.LOG_EVENT_ID_QUOTA_HIT_PREFLIGHT, mCurrentPackage, BackupManagerMonitor.LOG_EVENT_CATEGORY_TRANSPORT, @@ -647,11 +649,11 @@ public class PerformFullTransportBackupTask extends FullBackupTask implements Ba } catch (Exception e) { backupRunStatus = BackupManager.ERROR_TRANSPORT_ABORTED; Slog.w(TAG, "Exception trying full transport backup", e); - mMonitor = BackupManagerMonitorUtils.monitorEvent(mMonitor, + mBackupManagerMonitorEventSender.monitorEvent( BackupManagerMonitor.LOG_EVENT_ID_EXCEPTION_FULL_BACKUP, mCurrentPackage, BackupManagerMonitor.LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY, - BackupManagerMonitorUtils.putMonitoringExtra(null, + mBackupManagerMonitorEventSender.putMonitoringExtra(null, BackupManagerMonitor.EXTRA_LOG_EXCEPTION_FULL_BACKUP, Log.getStackTraceString(e))); @@ -885,7 +887,7 @@ public class PerformFullTransportBackupTask extends FullBackupTask implements Ba mCurrentOpToken, mTransportFlags, mBackupEligibilityRules, - mMonitor); + mBackupManagerMonitorEventSender); try { try { if (!mIsCancelled) { @@ -967,7 +969,7 @@ public class PerformFullTransportBackupTask extends FullBackupTask implements Ba Slog.w(TAG, "Full backup cancel of " + mTarget.packageName); } - mMonitor = BackupManagerMonitorUtils.monitorEvent(mMonitor, + mBackupManagerMonitorEventSender.monitorEvent( BackupManagerMonitor.LOG_EVENT_ID_FULL_BACKUP_CANCEL, mCurrentPackage, BackupManagerMonitor.LOG_EVENT_CATEGORY_AGENT, null); mIsCancelled = true; diff --git a/services/backup/java/com/android/server/backup/keyvalue/KeyValueBackupReporter.java b/services/backup/java/com/android/server/backup/keyvalue/KeyValueBackupReporter.java index 4632cb0e51e2..20c8cf6c6923 100644 --- a/services/backup/java/com/android/server/backup/keyvalue/KeyValueBackupReporter.java +++ b/services/backup/java/com/android/server/backup/keyvalue/KeyValueBackupReporter.java @@ -32,7 +32,7 @@ import com.android.server.backup.BackupManagerService; import com.android.server.backup.DataChangedJournal; import com.android.server.backup.UserBackupManagerService; import com.android.server.backup.remote.RemoteResult; -import com.android.server.backup.utils.BackupManagerMonitorUtils; +import com.android.server.backup.utils.BackupManagerMonitorEventSender; import com.android.server.backup.utils.BackupObserverUtils; import java.io.File; @@ -65,21 +65,21 @@ public class KeyValueBackupReporter { private final UserBackupManagerService mBackupManagerService; private final IBackupObserver mObserver; - @Nullable private IBackupManagerMonitor mMonitor; + private final BackupManagerMonitorEventSender mBackupManagerMonitorEventSender; KeyValueBackupReporter( UserBackupManagerService backupManagerService, IBackupObserver observer, - @Nullable IBackupManagerMonitor monitor) { + BackupManagerMonitorEventSender backupManagerMonitorEventSender) { mBackupManagerService = backupManagerService; mObserver = observer; - mMonitor = monitor; + mBackupManagerMonitorEventSender = backupManagerMonitorEventSender; } /** Returns the monitor or {@code null} if we lost connection to it. */ @Nullable IBackupManagerMonitor getMonitor() { - return mMonitor; + return mBackupManagerMonitorEventSender.getMonitor(); } IBackupObserver getObserver() { @@ -208,13 +208,11 @@ public class KeyValueBackupReporter { void onAgentIllegalKey(PackageInfo packageInfo, String key) { String packageName = packageInfo.packageName; EventLog.writeEvent(EventLogTags.BACKUP_AGENT_FAILURE, packageName, "bad key"); - mMonitor = - BackupManagerMonitorUtils.monitorEvent( - mMonitor, + mBackupManagerMonitorEventSender.monitorEvent( BackupManagerMonitor.LOG_EVENT_ID_ILLEGAL_KEY, packageInfo, BackupManagerMonitor.LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY, - BackupManagerMonitorUtils.putMonitoringExtra( + mBackupManagerMonitorEventSender.putMonitoringExtra( null, BackupManagerMonitor.EXTRA_LOG_ILLEGAL_KEY, key)); BackupObserverUtils.sendBackupOnPackageResult( mObserver, packageName, BackupManager.ERROR_AGENT_FAILURE); @@ -254,13 +252,11 @@ public class KeyValueBackupReporter { if (MORE_DEBUG) { Slog.i(TAG, "No backup data written, not calling transport"); } - mMonitor = - BackupManagerMonitorUtils.monitorEvent( - mMonitor, - BackupManagerMonitor.LOG_EVENT_ID_NO_DATA_TO_SEND, - packageInfo, - BackupManagerMonitor.LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY, - null); + mBackupManagerMonitorEventSender.monitorEvent( + BackupManagerMonitor.LOG_EVENT_ID_NO_DATA_TO_SEND, + packageInfo, + BackupManagerMonitor.LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY, + null); } void onPackageBackupComplete(String packageName, long size) { @@ -291,8 +287,7 @@ public class KeyValueBackupReporter { void onPackageBackupNonIncrementalRequired(PackageInfo packageInfo) { Slog.i(TAG, "Transport lost data, retrying package"); - BackupManagerMonitorUtils.monitorEvent( - mMonitor, + mBackupManagerMonitorEventSender.monitorEvent( BackupManagerMonitor.LOG_EVENT_ID_TRANSPORT_NON_INCREMENTAL_BACKUP_REQUIRED, packageInfo, BackupManagerMonitor.LOG_EVENT_CATEGORY_TRANSPORT, @@ -335,28 +330,24 @@ public class KeyValueBackupReporter { EventLog.writeEvent(EventLogTags.BACKUP_AGENT_FAILURE, packageName); // Time-out used to be implemented as cancel w/ cancelAll = false. // TODO: Change monitoring event to reflect time-out as an event itself. - mMonitor = - BackupManagerMonitorUtils.monitorEvent( - mMonitor, - BackupManagerMonitor.LOG_EVENT_ID_KEY_VALUE_BACKUP_CANCEL, - packageInfo, - BackupManagerMonitor.LOG_EVENT_CATEGORY_AGENT, - BackupManagerMonitorUtils.putMonitoringExtra( - null, BackupManagerMonitor.EXTRA_LOG_CANCEL_ALL, false)); + mBackupManagerMonitorEventSender.monitorEvent( + BackupManagerMonitor.LOG_EVENT_ID_KEY_VALUE_BACKUP_CANCEL, + packageInfo, + BackupManagerMonitor.LOG_EVENT_CATEGORY_AGENT, + mBackupManagerMonitorEventSender.putMonitoringExtra( + null, BackupManagerMonitor.EXTRA_LOG_CANCEL_ALL, false)); } void onAgentCancelled(@Nullable PackageInfo packageInfo) { String packageName = getPackageName(packageInfo); Slog.i(TAG, "Cancel backing up " + packageName); EventLog.writeEvent(EventLogTags.BACKUP_AGENT_FAILURE, packageName); - mMonitor = - BackupManagerMonitorUtils.monitorEvent( - mMonitor, - BackupManagerMonitor.LOG_EVENT_ID_KEY_VALUE_BACKUP_CANCEL, - packageInfo, - BackupManagerMonitor.LOG_EVENT_CATEGORY_AGENT, - BackupManagerMonitorUtils.putMonitoringExtra( - null, BackupManagerMonitor.EXTRA_LOG_CANCEL_ALL, true)); + mBackupManagerMonitorEventSender.monitorEvent( + BackupManagerMonitor.LOG_EVENT_ID_KEY_VALUE_BACKUP_CANCEL, + packageInfo, + BackupManagerMonitor.LOG_EVENT_CATEGORY_AGENT, + mBackupManagerMonitorEventSender.putMonitoringExtra( + null, BackupManagerMonitor.EXTRA_LOG_CANCEL_ALL, true)); } void onAgentResultError(@Nullable PackageInfo packageInfo) { diff --git a/services/backup/java/com/android/server/backup/keyvalue/KeyValueBackupTask.java b/services/backup/java/com/android/server/backup/keyvalue/KeyValueBackupTask.java index 41e8092436b5..3a6e1cafa505 100644 --- a/services/backup/java/com/android/server/backup/keyvalue/KeyValueBackupTask.java +++ b/services/backup/java/com/android/server/backup/keyvalue/KeyValueBackupTask.java @@ -68,7 +68,7 @@ import com.android.server.backup.transport.BackupTransportClient; import com.android.server.backup.transport.TransportConnection; import com.android.server.backup.transport.TransportNotAvailableException; import com.android.server.backup.utils.BackupEligibilityRules; -import com.android.server.backup.utils.BackupManagerMonitorUtils; +import com.android.server.backup.utils.BackupManagerMonitorEventSender; import libcore.io.IoUtils; @@ -225,7 +225,8 @@ public class KeyValueBackupTask implements BackupRestoreTask, Runnable { boolean nonIncremental, BackupEligibilityRules backupEligibilityRules) { KeyValueBackupReporter reporter = - new KeyValueBackupReporter(backupManagerService, observer, monitor); + new KeyValueBackupReporter(backupManagerService, observer, + new BackupManagerMonitorEventSender(monitor)); KeyValueBackupTask task = new KeyValueBackupTask( backupManagerService, @@ -698,8 +699,9 @@ public class KeyValueBackupTask implements BackupRestoreTask, Runnable { try { extractAgentData(mCurrentPackage); - BackupManagerMonitorUtils.monitorAgentLoggingResults( - mReporter.getMonitor(), mCurrentPackage, mAgent); + BackupManagerMonitorEventSender mBackupManagerMonitorEventSender = + new BackupManagerMonitorEventSender(mReporter.getMonitor()); + mBackupManagerMonitorEventSender.monitorAgentLoggingResults(mCurrentPackage, mAgent); int status = sendDataToTransport(mCurrentPackage); cleanUpAgentForTransportStatus(status); } catch (AgentException | TaskException e) { diff --git a/services/backup/java/com/android/server/backup/restore/PerformUnifiedRestoreTask.java b/services/backup/java/com/android/server/backup/restore/PerformUnifiedRestoreTask.java index 8cbb5dc03b9e..e04bf11dad9f 100644 --- a/services/backup/java/com/android/server/backup/restore/PerformUnifiedRestoreTask.java +++ b/services/backup/java/com/android/server/backup/restore/PerformUnifiedRestoreTask.java @@ -16,6 +16,8 @@ package com.android.server.backup.restore; +import static android.app.backup.BackupAnnotations.OperationType.RESTORE; + 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; @@ -30,6 +32,7 @@ import static com.android.server.pm.PackageManagerService.PLATFORM_PACKAGE_NAME; import android.annotation.Nullable; import android.app.ApplicationThreadConstants; import android.app.IBackupAgent; +import android.app.backup.BackupAnnotations; import android.app.backup.BackupDataInput; import android.app.backup.BackupDataOutput; import android.app.backup.BackupManagerMonitor; @@ -70,7 +73,7 @@ import com.android.server.backup.internal.OnTaskFinishedListener; import com.android.server.backup.transport.BackupTransportClient; import com.android.server.backup.transport.TransportConnection; import com.android.server.backup.utils.BackupEligibilityRules; -import com.android.server.backup.utils.BackupManagerMonitorUtils; +import com.android.server.backup.utils.BackupManagerMonitorEventSender; import libcore.io.IoUtils; @@ -84,7 +87,6 @@ import java.util.Objects; import java.util.Set; public class PerformUnifiedRestoreTask implements BackupRestoreTask { - private UserBackupManagerService backupManagerService; private final OperationStorage mOperationStorage; private final int mUserId; @@ -98,8 +100,7 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask { // Restore observer; may be null private IRestoreObserver mObserver; - // BackuoManagerMonitor; may be null - private IBackupManagerMonitor mMonitor; + private BackupManagerMonitorEventSender mBackupManagerMonitorEventSender; // Token identifying the dataset to the transport private long mToken; @@ -181,6 +182,8 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask { mUserId = 0; mBackupEligibilityRules = null; this.backupManagerService = backupManagerService; + mBackupManagerMonitorEventSender = + new BackupManagerMonitorEventSender(/*monitor*/null); } // This task can assume that the wakelock is properly held for it and doesn't have to worry @@ -208,7 +211,8 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask { mTransportConnection = transportConnection; mObserver = observer; - mMonitor = monitor; + mBackupManagerMonitorEventSender = + new BackupManagerMonitorEventSender(monitor); mToken = restoreSetToken; mPmToken = pmToken; mTargetPackage = targetPackage; @@ -410,8 +414,8 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask { // If the requester of the restore has not passed in a monitor, we ask the transport // for one. - if (mMonitor == null) { - mMonitor = transport.getBackupManagerMonitor(); + if (mBackupManagerMonitorEventSender.getMonitor() == null) { + mBackupManagerMonitorEventSender.setMonitor(transport.getBackupManagerMonitor()); } mStatus = transport.startRestore(mToken, packages); @@ -425,10 +429,12 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask { RestoreDescription desc = transport.nextRestorePackage(); if (desc == null) { Slog.e(TAG, "No restore metadata available; halting"); - mMonitor = BackupManagerMonitorUtils.monitorEvent(mMonitor, + Bundle monitoringExtras = addRestoreOperationTypeToEvent(/*extras*/null); + mBackupManagerMonitorEventSender.monitorEvent( BackupManagerMonitor.LOG_EVENT_ID_NO_RESTORE_METADATA_AVAILABLE, mCurrentPackage, - BackupManagerMonitor.LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY, null); + BackupManagerMonitor.LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY, + monitoringExtras); mStatus = BackupTransport.TRANSPORT_ERROR; executeNextState(UnifiedRestoreState.FINAL); return; @@ -437,10 +443,12 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask { desc.getPackageName())) { Slog.e(TAG, "Required package metadata but got " + desc.getPackageName()); - mMonitor = BackupManagerMonitorUtils.monitorEvent(mMonitor, + Bundle monitoringExtras = addRestoreOperationTypeToEvent(/*extras*/null); + mBackupManagerMonitorEventSender.monitorEvent( BackupManagerMonitor.LOG_EVENT_ID_NO_PM_METADATA_RECEIVED, mCurrentPackage, - BackupManagerMonitor.LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY, null); + BackupManagerMonitor.LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY, + monitoringExtras); mStatus = BackupTransport.TRANSPORT_ERROR; executeNextState(UnifiedRestoreState.FINAL); return; @@ -472,10 +480,12 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask { // the restore operation. if (!mPmAgent.hasMetadata()) { Slog.e(TAG, "PM agent has no metadata, so not restoring"); - mMonitor = BackupManagerMonitorUtils.monitorEvent(mMonitor, + Bundle monitoringExtras = addRestoreOperationTypeToEvent(/*extras*/null); + mBackupManagerMonitorEventSender.monitorEvent( BackupManagerMonitor.LOG_EVENT_ID_PM_AGENT_HAS_NO_METADATA, mCurrentPackage, - BackupManagerMonitor.LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY, null); + BackupManagerMonitor.LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY, + monitoringExtras); EventLog.writeEvent(EventLogTags.RESTORE_AGENT_FAILURE, PACKAGE_MANAGER_SENTINEL, "Package manager restore metadata missing"); @@ -492,10 +502,12 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask { } catch (Exception e) { // If we lost the transport at any time, halt Slog.e(TAG, "Unable to contact transport for restore: " + e.getMessage()); - mMonitor = BackupManagerMonitorUtils.monitorEvent(mMonitor, + Bundle monitoringExtras = addRestoreOperationTypeToEvent(/*extras*/null); + mBackupManagerMonitorEventSender.monitorEvent( BackupManagerMonitor.LOG_EVENT_ID_LOST_TRANSPORT, null, - BackupManagerMonitor.LOG_EVENT_CATEGORY_TRANSPORT, null); + BackupManagerMonitor.LOG_EVENT_CATEGORY_TRANSPORT, + monitoringExtras); mStatus = BackupTransport.TRANSPORT_ERROR; backupManagerService.getBackupHandler().removeMessages( MSG_BACKUP_RESTORE_STEP, this); @@ -552,11 +564,12 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask { // Whoops, we thought we could restore this package but it // turns out not to be present. Skip it. Slog.e(TAG, "Package not present: " + pkgName); - mMonitor = BackupManagerMonitorUtils.monitorEvent(mMonitor, + Bundle monitoringExtras = addRestoreOperationTypeToEvent(/*extras*/null); + mBackupManagerMonitorEventSender.monitorEvent( BackupManagerMonitor.LOG_EVENT_ID_PACKAGE_NOT_PRESENT, mCurrentPackage, BackupManagerMonitor.LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY, - null); + monitoringExtras); EventLog.writeEvent(EventLogTags.RESTORE_AGENT_FAILURE, pkgName, "Package missing on device"); nextState = UnifiedRestoreState.RUNNING_QUEUE; @@ -572,13 +585,15 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask { String message = "Source version " + metaInfo.versionCode + " > installed version " + mCurrentPackage.getLongVersionCode(); Slog.w(TAG, "Package " + pkgName + ": " + message); - Bundle monitoringExtras = BackupManagerMonitorUtils.putMonitoringExtra(null, + Bundle monitoringExtras = mBackupManagerMonitorEventSender.putMonitoringExtra( + null, BackupManagerMonitor.EXTRA_LOG_RESTORE_VERSION, metaInfo.versionCode); - monitoringExtras = BackupManagerMonitorUtils.putMonitoringExtra( + monitoringExtras = mBackupManagerMonitorEventSender.putMonitoringExtra( monitoringExtras, BackupManagerMonitor.EXTRA_LOG_RESTORE_ANYWAY, false); - mMonitor = BackupManagerMonitorUtils.monitorEvent(mMonitor, + monitoringExtras = addRestoreOperationTypeToEvent(monitoringExtras); + mBackupManagerMonitorEventSender.monitorEvent( BackupManagerMonitor.LOG_EVENT_ID_RESTORE_VERSION_HIGHER, mCurrentPackage, BackupManagerMonitor.LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY, @@ -593,13 +608,15 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask { + " > installed version " + mCurrentPackage.getLongVersionCode() + " but restoreAnyVersion"); } - Bundle monitoringExtras = BackupManagerMonitorUtils.putMonitoringExtra(null, + Bundle monitoringExtras = mBackupManagerMonitorEventSender.putMonitoringExtra( + null, BackupManagerMonitor.EXTRA_LOG_RESTORE_VERSION, metaInfo.versionCode); - monitoringExtras = BackupManagerMonitorUtils.putMonitoringExtra( + monitoringExtras = mBackupManagerMonitorEventSender.putMonitoringExtra( monitoringExtras, BackupManagerMonitor.EXTRA_LOG_RESTORE_ANYWAY, true); - mMonitor = BackupManagerMonitorUtils.monitorEvent(mMonitor, + monitoringExtras = addRestoreOperationTypeToEvent(monitoringExtras); + mBackupManagerMonitorEventSender.monitorEvent( BackupManagerMonitor.LOG_EVENT_ID_RESTORE_VERSION_HIGHER, mCurrentPackage, BackupManagerMonitor.LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY, @@ -652,9 +669,10 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask { Slog.i(TAG, "Data exists for package " + packageName + " but app has no agent; skipping"); } - mMonitor = BackupManagerMonitorUtils.monitorEvent(mMonitor, + Bundle monitoringExtras = addRestoreOperationTypeToEvent(/*extras*/null); + mBackupManagerMonitorEventSender.monitorEvent( BackupManagerMonitor.LOG_EVENT_ID_APP_HAS_NO_AGENT, mCurrentPackage, - BackupManagerMonitor.LOG_EVENT_CATEGORY_AGENT, null); + BackupManagerMonitor.LOG_EVENT_CATEGORY_AGENT, monitoringExtras); EventLog.writeEvent(EventLogTags.RESTORE_AGENT_FAILURE, packageName, "Package has no agent"); executeNextState(UnifiedRestoreState.RUNNING_QUEUE); @@ -665,9 +683,11 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask { PackageManagerInternal pmi = LocalServices.getService(PackageManagerInternal.class); if (!BackupUtils.signaturesMatch(metaInfo.sigHashes, mCurrentPackage, pmi)) { Slog.w(TAG, "Signature mismatch restoring " + packageName); - mMonitor = BackupManagerMonitorUtils.monitorEvent(mMonitor, + Bundle monitoringExtras = addRestoreOperationTypeToEvent(/*extras*/null); + mBackupManagerMonitorEventSender.monitorEvent( BackupManagerMonitor.LOG_EVENT_ID_SIGNATURE_MISMATCH, mCurrentPackage, - BackupManagerMonitor.LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY, null); + BackupManagerMonitor.LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY, + monitoringExtras); EventLog.writeEvent(EventLogTags.RESTORE_AGENT_FAILURE, packageName, "Signature mismatch"); executeNextState(UnifiedRestoreState.RUNNING_QUEUE); @@ -681,9 +701,11 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask { mBackupEligibilityRules.getBackupDestination()); if (mAgent == null) { Slog.w(TAG, "Can't find backup agent for " + packageName); - mMonitor = BackupManagerMonitorUtils.monitorEvent(mMonitor, + Bundle monitoringExtras = addRestoreOperationTypeToEvent(/*extras*/null); + mBackupManagerMonitorEventSender.monitorEvent( BackupManagerMonitor.LOG_EVENT_ID_CANT_FIND_AGENT, mCurrentPackage, - BackupManagerMonitor.LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY, null); + BackupManagerMonitor.LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY, + monitoringExtras); EventLog.writeEvent(EventLogTags.RESTORE_AGENT_FAILURE, packageName, "Restore agent missing"); executeNextState(UnifiedRestoreState.RUNNING_QUEUE); @@ -941,8 +963,9 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask { EventLog.writeEvent(EventLogTags.FULL_RESTORE_PACKAGE, mCurrentPackage.packageName); - mEngine = new FullRestoreEngine(backupManagerService, mOperationStorage, this, null, - mMonitor, mCurrentPackage, false, mEphemeralOpToken, false, + mEngine = new FullRestoreEngine(backupManagerService, mOperationStorage, + this, null, mBackupManagerMonitorEventSender.getMonitor(), + mCurrentPackage, false, mEphemeralOpToken, false, mBackupEligibilityRules); mEngineThread = new FullRestoreEngineThread(mEngine, mEnginePipes[0]); @@ -1095,10 +1118,11 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask { if (DEBUG) { Slog.w(TAG, "Full-data restore target timed out; shutting down"); } - - mMonitor = BackupManagerMonitorUtils.monitorEvent(mMonitor, + Bundle monitoringExtras = addRestoreOperationTypeToEvent(/*extras*/null); + mBackupManagerMonitorEventSender.monitorEvent( BackupManagerMonitor.LOG_EVENT_ID_FULL_RESTORE_TIMEOUT, - mCurrentPackage, BackupManagerMonitor.LOG_EVENT_CATEGORY_AGENT, null); + mCurrentPackage, BackupManagerMonitor.LOG_EVENT_CATEGORY_AGENT, + monitoringExtras); mEngineThread.handleTimeout(); IoUtils.closeQuietly(mEnginePipes[1]); @@ -1322,7 +1346,7 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask { // Ask the agent for logs after doRestoreFinished() has completed executing to allow // it to finalize its logs. - BackupManagerMonitorUtils.monitorAgentLoggingResults(mMonitor, mCurrentPackage, + mBackupManagerMonitorEventSender.monitorAgentLoggingResults(mCurrentPackage, mAgent); // Just go back to running the restore queue @@ -1358,9 +1382,10 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask { public void handleCancel(boolean cancelAll) { mOperationStorage.removeOperation(mEphemeralOpToken); Slog.e(TAG, "Timeout restoring application " + mCurrentPackage.packageName); - mMonitor = BackupManagerMonitorUtils.monitorEvent(mMonitor, + Bundle monitoringExtras = addRestoreOperationTypeToEvent(/*extras*/null); + mBackupManagerMonitorEventSender.monitorEvent( BackupManagerMonitor.LOG_EVENT_ID_KEY_VALUE_RESTORE_TIMEOUT, - mCurrentPackage, BackupManagerMonitor.LOG_EVENT_CATEGORY_AGENT, null); + mCurrentPackage, BackupManagerMonitor.LOG_EVENT_CATEGORY_AGENT, monitoringExtras); EventLog.writeEvent(EventLogTags.RESTORE_AGENT_FAILURE, mCurrentPackage.packageName, "restore timeout"); // Handle like an agent that threw on invocation: wipe it and go on to the next @@ -1433,4 +1458,10 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask { } } } + + private Bundle addRestoreOperationTypeToEvent (@Nullable Bundle extra) { + return mBackupManagerMonitorEventSender.putMonitoringExtra( + extra, + BackupManagerMonitor.EXTRA_LOG_OPERATION_TYPE, RESTORE); + } } diff --git a/services/backup/java/com/android/server/backup/utils/BackupManagerMonitorDumpsysUtils.java b/services/backup/java/com/android/server/backup/utils/BackupManagerMonitorDumpsysUtils.java new file mode 100644 index 000000000000..0b55ca21371b --- /dev/null +++ b/services/backup/java/com/android/server/backup/utils/BackupManagerMonitorDumpsysUtils.java @@ -0,0 +1,260 @@ +/* + * Copyright (C) 2023 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.server.backup.utils; + +import android.app.backup.BackupAnnotations; +import android.app.backup.BackupManagerMonitor; +import android.app.backup.BackupRestoreEventLogger; +import android.os.Bundle; +import android.os.Environment; +import android.util.Slog; + +import com.android.internal.util.FastPrintWriter; + +import java.io.File; +import java.io.FileOutputStream; +import java.io.PrintWriter; +import java.text.SimpleDateFormat; +import java.util.ArrayList; +import java.util.Date; +import java.util.Map; + + +/* + * Util class to parse a BMM event and write it to a text file, to be the printed in + * the backup dumpsys + * + * Note: this class is note thread safe + */ +public class BackupManagerMonitorDumpsysUtils { + + private static final String TAG = "BackupManagerMonitorDumpsysUtils"; + // Name of the subdirectory where the text file containing the BMM events will be stored. + // Same as {@link UserBackupManagerFiles} + private static final String BACKUP_PERSISTENT_DIR = "backup"; + + /** + * Parses the BackupManagerMonitor bundle for a RESTORE event in a series of strings that + * will be persisted in a text file and printed in the dumpsys. + * + * If the evenntBundle passed is not a RESTORE event, return early + * + * Key information related to the event: + * - Timestamp (HAS TO ALWAYS BE THE FIRST LINE OF EACH EVENT) + * - Event ID + * - Event Category + * - Operation type + * - Package name (can be null) + * - Agent logs (if available) + * + * Example of formatting: + * RESTORE Event: [2023-08-18 17:16:00.735] Agent - Agent logging results + * Package name: com.android.wallpaperbackup + * Agent Logs: + * Data Type: wlp_img_system + * Item restored: 0/1 + * Agent Error - Category: no_wallpaper, Count: 1 + * Data Type: wlp_img_lock + * Item restored: 0/1 + * Agent Error - Category: no_wallpaper, Count: 1 + */ + public void parseBackupManagerMonitorRestoreEventForDumpsys(Bundle eventBundle) { + if (eventBundle == null) { + return; + } + + if (!isOpTypeRestore(eventBundle)) { + //We only log Restore events + return; + } + + if (!eventBundle.containsKey(BackupManagerMonitor.EXTRA_LOG_EVENT_ID) + || !eventBundle.containsKey(BackupManagerMonitor.EXTRA_LOG_EVENT_CATEGORY)) { + Slog.w(TAG, "Event id and category are not optional fields."); + return; + } + File bmmEvents = getBMMEventsFile(); + + try (FileOutputStream out = new FileOutputStream(bmmEvents, /*append*/ true); + PrintWriter pw = new FastPrintWriter(out);) { + + int eventCategory = eventBundle.getInt(BackupManagerMonitor.EXTRA_LOG_EVENT_CATEGORY); + int eventId = eventBundle.getInt(BackupManagerMonitor.EXTRA_LOG_EVENT_ID); + + if (eventId == BackupManagerMonitor.LOG_EVENT_ID_AGENT_LOGGING_RESULTS && + !hasAgentLogging(eventBundle)) { + // Do not record an empty agent logging event + return; + } + + pw.println("RESTORE Event: [" + timestamp() + "] " + + getCategory(eventCategory) + " - " + + getId(eventId)); + + if (eventBundle.containsKey(BackupManagerMonitor.EXTRA_LOG_EVENT_PACKAGE_NAME)) { + pw.println("\tPackage name: " + + eventBundle.getString(BackupManagerMonitor.EXTRA_LOG_EVENT_PACKAGE_NAME)); + } + + // TODO(b/296818666): add extras to the events + addAgentLogsIfAvailable(eventBundle, pw); + } catch (java.io.IOException e) { + Slog.e(TAG, "IO Exception when writing BMM events to file: " + e); + } + + } + + private boolean hasAgentLogging(Bundle eventBundle) { + if (eventBundle.containsKey(BackupManagerMonitor.EXTRA_LOG_AGENT_LOGGING_RESULTS)) { + ArrayList<BackupRestoreEventLogger.DataTypeResult> agentLogs = + eventBundle.getParcelableArrayList( + BackupManagerMonitor.EXTRA_LOG_AGENT_LOGGING_RESULTS); + + return !agentLogs.isEmpty(); + } + return false; + } + + /** + * Extracts agent logs from the BackupManagerMonitor event. These logs detail: + * - the data type for the agent + * - the count of successfully restored items + * - the count of items that failed to restore + * - the metadata associated with this datatype + * - any errors + */ + private void addAgentLogsIfAvailable(Bundle eventBundle, PrintWriter pw) { + if (hasAgentLogging(eventBundle)) { + pw.println("\tAgent Logs:"); + ArrayList<BackupRestoreEventLogger.DataTypeResult> agentLogs = + eventBundle.getParcelableArrayList( + BackupManagerMonitor.EXTRA_LOG_AGENT_LOGGING_RESULTS); + for (BackupRestoreEventLogger.DataTypeResult result : agentLogs) { + int totalItems = result.getFailCount() + result.getSuccessCount(); + pw.println("\t\tData Type: " + result.getDataType()); + pw.println("\t\t\tItem restored: " + result.getSuccessCount() + "/" + + totalItems); + for (Map.Entry<String, Integer> entry : result.getErrors().entrySet()) { + pw.println("\t\t\tAgent Error - Category: " + + entry.getKey() + ", Count: " + entry.getValue()); + } + } + } + } + + /* + * Get the path of the text files which stores the BMM events + */ + public File getBMMEventsFile() { + File dataDir = new File(Environment.getDataDirectory(), BACKUP_PERSISTENT_DIR); + File fname = new File(dataDir, "bmmevents.txt"); + return fname; + } + + private String timestamp() { + long currentTime = System.currentTimeMillis(); + Date date = new Date(currentTime); + SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS"); + return dateFormat.format(date); + } + + private String getCategory(int code) { + String category = switch (code) { + case BackupManagerMonitor.LOG_EVENT_CATEGORY_TRANSPORT -> "Transport"; + case BackupManagerMonitor.LOG_EVENT_CATEGORY_AGENT -> "Agent"; + case BackupManagerMonitor.LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY -> + "Backup Manager Policy"; + default -> "Unknown category code: " + code; + }; + return category; + } + + private String getId(int code) { + String id = switch (code) { + case BackupManagerMonitor.LOG_EVENT_ID_FULL_BACKUP_CANCEL -> "Full backup cancel"; + case BackupManagerMonitor.LOG_EVENT_ID_ILLEGAL_KEY -> "Illegal key"; + case BackupManagerMonitor.LOG_EVENT_ID_NO_DATA_TO_SEND -> "No data to send"; + case BackupManagerMonitor.LOG_EVENT_ID_PACKAGE_INELIGIBLE -> "Package ineligible"; + case BackupManagerMonitor.LOG_EVENT_ID_PACKAGE_KEY_VALUE_PARTICIPANT -> + "Package key-value participant"; + case BackupManagerMonitor.LOG_EVENT_ID_PACKAGE_STOPPED -> "Package stopped"; + case BackupManagerMonitor.LOG_EVENT_ID_PACKAGE_NOT_FOUND -> "Package not found"; + case BackupManagerMonitor.LOG_EVENT_ID_BACKUP_DISABLED -> "Backup disabled"; + case BackupManagerMonitor.LOG_EVENT_ID_DEVICE_NOT_PROVISIONED -> + "Device not provisioned"; + case BackupManagerMonitor.LOG_EVENT_ID_PACKAGE_TRANSPORT_NOT_PRESENT -> + "Package transport not present"; + case BackupManagerMonitor.LOG_EVENT_ID_ERROR_PREFLIGHT -> "Error preflight"; + case BackupManagerMonitor.LOG_EVENT_ID_QUOTA_HIT_PREFLIGHT -> "Quota hit preflight"; + case BackupManagerMonitor.LOG_EVENT_ID_EXCEPTION_FULL_BACKUP -> "Exception full backup"; + case BackupManagerMonitor.LOG_EVENT_ID_KEY_VALUE_BACKUP_CANCEL -> + "Key-value backup cancel"; + case BackupManagerMonitor.LOG_EVENT_ID_NO_RESTORE_METADATA_AVAILABLE -> + "No restore metadata available"; + case BackupManagerMonitor.LOG_EVENT_ID_NO_PM_METADATA_RECEIVED -> + "No PM metadata received"; + case BackupManagerMonitor.LOG_EVENT_ID_PM_AGENT_HAS_NO_METADATA -> + "PM agent has no metadata"; + case BackupManagerMonitor.LOG_EVENT_ID_LOST_TRANSPORT -> "Lost transport"; + case BackupManagerMonitor.LOG_EVENT_ID_PACKAGE_NOT_PRESENT -> "Package not present"; + case BackupManagerMonitor.LOG_EVENT_ID_RESTORE_VERSION_HIGHER -> + "Restore version higher"; + case BackupManagerMonitor.LOG_EVENT_ID_APP_HAS_NO_AGENT -> "App has no agent"; + case BackupManagerMonitor.LOG_EVENT_ID_SIGNATURE_MISMATCH -> "Signature mismatch"; + case BackupManagerMonitor.LOG_EVENT_ID_CANT_FIND_AGENT -> "Can't find agent"; + case BackupManagerMonitor.LOG_EVENT_ID_KEY_VALUE_RESTORE_TIMEOUT -> + "Key-value restore timeout"; + case BackupManagerMonitor.LOG_EVENT_ID_RESTORE_ANY_VERSION -> "Restore any version"; + case BackupManagerMonitor.LOG_EVENT_ID_VERSIONS_MATCH -> "Versions match"; + case BackupManagerMonitor.LOG_EVENT_ID_VERSION_OF_BACKUP_OLDER -> + "Version of backup older"; + case BackupManagerMonitor.LOG_EVENT_ID_FULL_RESTORE_SIGNATURE_MISMATCH -> + "Full restore signature mismatch"; + case BackupManagerMonitor.LOG_EVENT_ID_SYSTEM_APP_NO_AGENT -> "System app no agent"; + case BackupManagerMonitor.LOG_EVENT_ID_FULL_RESTORE_ALLOW_BACKUP_FALSE -> + "Full restore allow backup false"; + case BackupManagerMonitor.LOG_EVENT_ID_APK_NOT_INSTALLED -> "APK not installed"; + case BackupManagerMonitor.LOG_EVENT_ID_CANNOT_RESTORE_WITHOUT_APK -> + "Cannot restore without APK"; + case BackupManagerMonitor.LOG_EVENT_ID_MISSING_SIGNATURE -> "Missing signature"; + case BackupManagerMonitor.LOG_EVENT_ID_EXPECTED_DIFFERENT_PACKAGE -> + "Expected different package"; + case BackupManagerMonitor.LOG_EVENT_ID_UNKNOWN_VERSION -> "Unknown version"; + case BackupManagerMonitor.LOG_EVENT_ID_FULL_RESTORE_TIMEOUT -> "Full restore timeout"; + case BackupManagerMonitor.LOG_EVENT_ID_CORRUPT_MANIFEST -> "Corrupt manifest"; + case BackupManagerMonitor.LOG_EVENT_ID_WIDGET_METADATA_MISMATCH -> + "Widget metadata mismatch"; + case BackupManagerMonitor.LOG_EVENT_ID_WIDGET_UNKNOWN_VERSION -> + "Widget unknown version"; + case BackupManagerMonitor.LOG_EVENT_ID_NO_PACKAGES -> "No packages"; + case BackupManagerMonitor.LOG_EVENT_ID_TRANSPORT_IS_NULL -> "Transport is null"; + case BackupManagerMonitor.LOG_EVENT_ID_TRANSPORT_NON_INCREMENTAL_BACKUP_REQUIRED -> + "Transport non-incremental backup required"; + case BackupManagerMonitor.LOG_EVENT_ID_AGENT_LOGGING_RESULTS -> "Agent logging results"; + default -> "Unknown log event ID: " + code; + }; + return id; + } + + private boolean isOpTypeRestore(Bundle eventBundle) { + return switch (eventBundle.getInt( + BackupManagerMonitor.EXTRA_LOG_OPERATION_TYPE, -1)) { + case BackupAnnotations.OperationType.RESTORE -> true; + default -> false; + }; + } +} diff --git a/services/backup/java/com/android/server/backup/utils/BackupManagerMonitorUtils.java b/services/backup/java/com/android/server/backup/utils/BackupManagerMonitorEventSender.java index 439b83687b8f..92e3107b6977 100644 --- a/services/backup/java/com/android/server/backup/utils/BackupManagerMonitorUtils.java +++ b/services/backup/java/com/android/server/backup/utils/BackupManagerMonitorEventSender.java @@ -25,7 +25,6 @@ import static android.app.backup.BackupManagerMonitor.LOG_EVENT_ID_AGENT_LOGGING import static com.android.server.backup.BackupManagerService.DEBUG; import static com.android.server.backup.BackupManagerService.TAG; -import android.annotation.NonNull; import android.annotation.Nullable; import android.app.IBackupAgent; import android.app.backup.BackupAnnotations.OperationType; @@ -37,6 +36,7 @@ import android.os.Bundle; import android.os.RemoteException; import android.util.Slog; +import com.android.internal.annotations.VisibleForTesting; import com.android.internal.infra.AndroidFuture; import java.util.List; @@ -44,9 +44,9 @@ import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeoutException; /** - * Utility methods to communicate with BackupManagerMonitor. + * Utility methods to log BackupManagerMonitor events. */ -public class BackupManagerMonitorUtils { +public class BackupManagerMonitorEventSender { /** * Timeout for how long we wait before we give up on getting logs from a {@link IBackupAgent}. * We expect this to be very fast since the agent immediately returns whatever logs have been @@ -54,51 +54,77 @@ public class BackupManagerMonitorUtils { * for non-essential logs. */ private static final int AGENT_LOGGER_RESULTS_TIMEOUT_MILLIS = 500; + @Nullable private IBackupManagerMonitor mMonitor; + private final BackupManagerMonitorDumpsysUtils mBackupManagerMonitorDumpsysUtils; + public BackupManagerMonitorEventSender(@Nullable IBackupManagerMonitor monitor) { + mMonitor = monitor; + mBackupManagerMonitorDumpsysUtils = new BackupManagerMonitorDumpsysUtils(); + } + + @VisibleForTesting + BackupManagerMonitorEventSender(@Nullable IBackupManagerMonitor monitor, + BackupManagerMonitorDumpsysUtils backupManagerMonitorDumpsysUtils) { + mMonitor = monitor; + mBackupManagerMonitorDumpsysUtils = backupManagerMonitorDumpsysUtils; + } + + public void setMonitor(IBackupManagerMonitor monitor) { + mMonitor = monitor; + } + + public IBackupManagerMonitor getMonitor() { + return mMonitor; + } /** * Notifies monitor about the event. * * Calls {@link IBackupManagerMonitor#onEvent(Bundle)} with a bundle representing current event. * - * @param monitor - implementation of {@link IBackupManagerMonitor} to notify. * @param id - event id. * @param pkg - package event is related to. * @param category - event category. * @param extras - additional event data. - * @return <code>monitor</code> if call succeeded and <code>null</code> otherwise. */ - @Nullable - public static IBackupManagerMonitor monitorEvent( - @Nullable IBackupManagerMonitor monitor, + public void monitorEvent( int id, PackageInfo pkg, int category, Bundle extras) { - if (monitor != null) { - try { - Bundle bundle = new Bundle(); - bundle.putInt(BackupManagerMonitor.EXTRA_LOG_EVENT_ID, id); - bundle.putInt(BackupManagerMonitor.EXTRA_LOG_EVENT_CATEGORY, category); - if (pkg != null) { - bundle.putString(EXTRA_LOG_EVENT_PACKAGE_NAME, - pkg.packageName); - bundle.putInt(BackupManagerMonitor.EXTRA_LOG_EVENT_PACKAGE_VERSION, - pkg.versionCode); - bundle.putLong(BackupManagerMonitor.EXTRA_LOG_EVENT_PACKAGE_LONG_VERSION, - pkg.getLongVersionCode()); - } - if (extras != null) { - bundle.putAll(extras); + try { + Bundle bundle = new Bundle(); + bundle.putInt(BackupManagerMonitor.EXTRA_LOG_EVENT_ID, id); + bundle.putInt(BackupManagerMonitor.EXTRA_LOG_EVENT_CATEGORY, category); + if (pkg != null) { + bundle.putString(EXTRA_LOG_EVENT_PACKAGE_NAME, + pkg.packageName); + bundle.putInt(BackupManagerMonitor.EXTRA_LOG_EVENT_PACKAGE_VERSION, + pkg.versionCode); + bundle.putLong(BackupManagerMonitor.EXTRA_LOG_EVENT_PACKAGE_LONG_VERSION, + pkg.getLongVersionCode()); + } + if (extras != null) { + bundle.putAll(extras); + if (extras.containsKey(EXTRA_LOG_OPERATION_TYPE) && + extras.getInt(EXTRA_LOG_OPERATION_TYPE) == OperationType.RESTORE){ + mBackupManagerMonitorDumpsysUtils + .parseBackupManagerMonitorRestoreEventForDumpsys(bundle); } - monitor.onEvent(bundle); - return monitor; - } catch (RemoteException e) { + } + + if (mMonitor != null) { + mMonitor.onEvent(bundle); + } else { if (DEBUG) { - Slog.w(TAG, "backup manager monitor went away"); + Slog.w(TAG, "backup manager monitor is null unable to send event"); } } + } catch (RemoteException e) { + mMonitor = null; + if (DEBUG) { + Slog.w(TAG, "backup manager monitor went away"); + } } - return null; } /** @@ -108,17 +134,12 @@ public class BackupManagerMonitorUtils { * <p>Note that this method does two separate binder calls (one to the agent and one to the * monitor). * - * @param monitor - implementation of {@link IBackupManagerMonitor} to notify. * @param pkg - package the {@code agent} belongs to. * @param agent - the {@link IBackupAgent} to retrieve logs from. - * @return {@code null} if the monitor is null. {@code monitor} if we fail to retrieve the logs - * from the {@code agent}. Otherwise, the result of {@link - * #monitorEvent(IBackupManagerMonitor, int, PackageInfo, int, Bundle)}. */ - public static IBackupManagerMonitor monitorAgentLoggingResults( - @Nullable IBackupManagerMonitor monitor, PackageInfo pkg, IBackupAgent agent) { - if (monitor == null) { - return null; + public void monitorAgentLoggingResults(PackageInfo pkg, IBackupAgent agent) { + if (mMonitor == null) { + Slog.i(TAG, "backup manager monitor is null unable to send event"+pkg); } try { @@ -127,7 +148,7 @@ public class BackupManagerMonitorUtils { AndroidFuture<Integer> operationTypeFuture = new AndroidFuture<>(); agent.getLoggerResults(resultsFuture); agent.getOperationType(operationTypeFuture); - return sendAgentLoggingResults(monitor, pkg, + sendAgentLoggingResults(pkg, resultsFuture.get(AGENT_LOGGER_RESULTS_TIMEOUT_MILLIS, TimeUnit.MILLISECONDS), operationTypeFuture.get(AGENT_LOGGER_RESULTS_TIMEOUT_MILLIS, TimeUnit.MILLISECONDS)); @@ -136,18 +157,15 @@ public class BackupManagerMonitorUtils { } catch (Exception e) { Slog.w(TAG, "Failed to retrieve logging results from agent", e); } - return monitor; } - public static IBackupManagerMonitor sendAgentLoggingResults( - @NonNull IBackupManagerMonitor monitor, PackageInfo pkg, List<DataTypeResult> results, + public void sendAgentLoggingResults(PackageInfo pkg, List<DataTypeResult> results, @OperationType int operationType) { Bundle loggerResultsBundle = new Bundle(); loggerResultsBundle.putParcelableList( EXTRA_LOG_AGENT_LOGGING_RESULTS, results); loggerResultsBundle.putInt(EXTRA_LOG_OPERATION_TYPE, operationType); - return monitorEvent( - monitor, + monitorEvent( LOG_EVENT_ID_AGENT_LOGGING_RESULTS, pkg, LOG_EVENT_CATEGORY_AGENT, diff --git a/services/backup/java/com/android/server/backup/utils/TarBackupReader.java b/services/backup/java/com/android/server/backup/utils/TarBackupReader.java index 71ca8ca24604..78a9952d066d 100644 --- a/services/backup/java/com/android/server/backup/utils/TarBackupReader.java +++ b/services/backup/java/com/android/server/backup/utils/TarBackupReader.java @@ -85,7 +85,8 @@ public class TarBackupReader { private final InputStream mInputStream; private final BytesReadListener mBytesReadListener; - private IBackupManagerMonitor mMonitor; + + private BackupManagerMonitorEventSender mBackupManagerMonitorEventSender; // Widget blob to be restored out-of-band. private byte[] mWidgetData = null; @@ -94,7 +95,7 @@ public class TarBackupReader { IBackupManagerMonitor monitor) { mInputStream = inputStream; mBytesReadListener = bytesReadListener; - mMonitor = monitor; + mBackupManagerMonitorEventSender = new BackupManagerMonitorEventSender(monitor); } /** @@ -323,24 +324,22 @@ public class TarBackupReader { return sigs; } else { Slog.i(TAG, "Missing signature on backed-up package " + info.packageName); - mMonitor = BackupManagerMonitorUtils.monitorEvent( - mMonitor, + mBackupManagerMonitorEventSender.monitorEvent( LOG_EVENT_ID_MISSING_SIGNATURE, null, LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY, - BackupManagerMonitorUtils.putMonitoringExtra(null, + mBackupManagerMonitorEventSender.putMonitoringExtra(null, EXTRA_LOG_EVENT_PACKAGE_NAME, info.packageName)); } } else { Slog.i(TAG, "Expected package " + info.packageName + " but restore manifest claims " + manifestPackage); - Bundle monitoringExtras = BackupManagerMonitorUtils.putMonitoringExtra(null, - EXTRA_LOG_EVENT_PACKAGE_NAME, info.packageName); - monitoringExtras = BackupManagerMonitorUtils.putMonitoringExtra( + Bundle monitoringExtras = mBackupManagerMonitorEventSender.putMonitoringExtra( + null, EXTRA_LOG_EVENT_PACKAGE_NAME, info.packageName); + monitoringExtras = mBackupManagerMonitorEventSender.putMonitoringExtra( monitoringExtras, EXTRA_LOG_MANIFEST_PACKAGE_NAME, manifestPackage); - mMonitor = BackupManagerMonitorUtils.monitorEvent( - mMonitor, + mBackupManagerMonitorEventSender.monitorEvent( LOG_EVENT_ID_EXPECTED_DIFFERENT_PACKAGE, null, LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY, @@ -349,12 +348,11 @@ public class TarBackupReader { } else { Slog.i(TAG, "Unknown restore manifest version " + version + " for package " + info.packageName); - Bundle monitoringExtras = BackupManagerMonitorUtils.putMonitoringExtra(null, - EXTRA_LOG_EVENT_PACKAGE_NAME, info.packageName); - monitoringExtras = BackupManagerMonitorUtils.putMonitoringExtra(monitoringExtras, - EXTRA_LOG_EVENT_PACKAGE_VERSION, version); - mMonitor = BackupManagerMonitorUtils.monitorEvent( - mMonitor, + Bundle monitoringExtras = mBackupManagerMonitorEventSender.putMonitoringExtra( + null, EXTRA_LOG_EVENT_PACKAGE_NAME, info.packageName); + monitoringExtras = mBackupManagerMonitorEventSender.putMonitoringExtra( + monitoringExtras, EXTRA_LOG_EVENT_PACKAGE_VERSION, version); + mBackupManagerMonitorEventSender.monitorEvent( BackupManagerMonitor.LOG_EVENT_ID_UNKNOWN_VERSION, null, LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY, @@ -363,12 +361,12 @@ public class TarBackupReader { } } catch (NumberFormatException e) { Slog.w(TAG, "Corrupt restore manifest for package " + info.packageName); - mMonitor = BackupManagerMonitorUtils.monitorEvent( - mMonitor, + mBackupManagerMonitorEventSender.monitorEvent( BackupManagerMonitor.LOG_EVENT_ID_CORRUPT_MANIFEST, null, LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY, - BackupManagerMonitorUtils.putMonitoringExtra(null, EXTRA_LOG_EVENT_PACKAGE_NAME, + mBackupManagerMonitorEventSender.putMonitoringExtra(null, + EXTRA_LOG_EVENT_PACKAGE_NAME, info.packageName)); } catch (IllegalArgumentException e) { Slog.w(TAG, e.getMessage()); @@ -436,8 +434,7 @@ public class TarBackupReader { if ((pkgInfo.applicationInfo.flags & ApplicationInfo.FLAG_RESTORE_ANY_VERSION) != 0) { Slog.i(TAG, "Package has restoreAnyVersion; taking data"); - mMonitor = BackupManagerMonitorUtils.monitorEvent( - mMonitor, + mBackupManagerMonitorEventSender.monitorEvent( LOG_EVENT_ID_RESTORE_ANY_VERSION, pkgInfo, LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY, @@ -446,8 +443,7 @@ public class TarBackupReader { } else if (pkgInfo.getLongVersionCode() >= info.version) { Slog.i(TAG, "Sig + version match; taking data"); policy = RestorePolicy.ACCEPT; - mMonitor = BackupManagerMonitorUtils.monitorEvent( - mMonitor, + mBackupManagerMonitorEventSender.monitorEvent( LOG_EVENT_ID_VERSIONS_MATCH, pkgInfo, LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY, @@ -466,12 +462,11 @@ public class TarBackupReader { } else { Slog.i(TAG, "Data requires newer version " + info.version + "; ignoring"); - mMonitor = BackupManagerMonitorUtils - .monitorEvent(mMonitor, + mBackupManagerMonitorEventSender.monitorEvent( LOG_EVENT_ID_VERSION_OF_BACKUP_OLDER, pkgInfo, LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY, - BackupManagerMonitorUtils + mBackupManagerMonitorEventSender .putMonitoringExtra( null, EXTRA_LOG_OLD_VERSION, @@ -484,8 +479,7 @@ public class TarBackupReader { Slog.w(TAG, "Restore manifest signatures do not match " + "installed application for " + info.packageName); - mMonitor = BackupManagerMonitorUtils.monitorEvent( - mMonitor, + mBackupManagerMonitorEventSender.monitorEvent( LOG_EVENT_ID_FULL_RESTORE_SIGNATURE_MISMATCH, pkgInfo, LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY, @@ -494,8 +488,7 @@ public class TarBackupReader { } else { Slog.w(TAG, "Package " + info.packageName + " is system level with no agent"); - mMonitor = BackupManagerMonitorUtils.monitorEvent( - mMonitor, + mBackupManagerMonitorEventSender.monitorEvent( LOG_EVENT_ID_SYSTEM_APP_NO_AGENT, pkgInfo, LOG_EVENT_CATEGORY_AGENT, @@ -506,8 +499,7 @@ public class TarBackupReader { Slog.i(TAG, "Restore manifest from " + info.packageName + " but allowBackup=false"); } - mMonitor = BackupManagerMonitorUtils.monitorEvent( - mMonitor, + mBackupManagerMonitorEventSender.monitorEvent( LOG_EVENT_ID_FULL_RESTORE_ALLOW_BACKUP_FALSE, pkgInfo, LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY, @@ -526,14 +518,13 @@ public class TarBackupReader { } else { policy = RestorePolicy.IGNORE; } - Bundle monitoringExtras = BackupManagerMonitorUtils.putMonitoringExtra( + Bundle monitoringExtras = mBackupManagerMonitorEventSender.putMonitoringExtra( null, EXTRA_LOG_EVENT_PACKAGE_NAME, info.packageName); - monitoringExtras = BackupManagerMonitorUtils.putMonitoringExtra( + monitoringExtras = mBackupManagerMonitorEventSender.putMonitoringExtra( monitoringExtras, EXTRA_LOG_POLICY_ALLOW_APKS, allowApks); - mMonitor = BackupManagerMonitorUtils.monitorEvent( - mMonitor, + mBackupManagerMonitorEventSender.monitorEvent( LOG_EVENT_ID_APK_NOT_INSTALLED, null, LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY, @@ -543,12 +534,11 @@ public class TarBackupReader { if (policy == RestorePolicy.ACCEPT_IF_APK && !info.hasApk) { Slog.i(TAG, "Cannot restore package " + info.packageName + " without the matching .apk"); - mMonitor = BackupManagerMonitorUtils.monitorEvent( - mMonitor, + mBackupManagerMonitorEventSender.monitorEvent( LOG_EVENT_ID_CANNOT_RESTORE_WITHOUT_APK, null, LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY, - BackupManagerMonitorUtils.putMonitoringExtra(null, + mBackupManagerMonitorEventSender.putMonitoringExtra(null, EXTRA_LOG_EVENT_PACKAGE_NAME, info.packageName)); } @@ -632,12 +622,11 @@ public class TarBackupReader { "Metadata mismatch: package " + info.packageName + " but widget data for " + pkg); - Bundle monitoringExtras = BackupManagerMonitorUtils.putMonitoringExtra(null, + Bundle monitoringExtras = mBackupManagerMonitorEventSender.putMonitoringExtra(null, EXTRA_LOG_EVENT_PACKAGE_NAME, info.packageName); - monitoringExtras = BackupManagerMonitorUtils.putMonitoringExtra(monitoringExtras, - BackupManagerMonitor.EXTRA_LOG_WIDGET_PACKAGE_NAME, pkg); - mMonitor = BackupManagerMonitorUtils.monitorEvent( - mMonitor, + monitoringExtras = mBackupManagerMonitorEventSender.putMonitoringExtra( + monitoringExtras, BackupManagerMonitor.EXTRA_LOG_WIDGET_PACKAGE_NAME, pkg); + mBackupManagerMonitorEventSender.monitorEvent( BackupManagerMonitor.LOG_EVENT_ID_WIDGET_METADATA_MISMATCH, null, LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY, @@ -646,13 +635,12 @@ public class TarBackupReader { } else { Slog.w(TAG, "Unsupported metadata version " + version); - Bundle monitoringExtras = BackupManagerMonitorUtils + Bundle monitoringExtras = mBackupManagerMonitorEventSender .putMonitoringExtra(null, EXTRA_LOG_EVENT_PACKAGE_NAME, info.packageName); - monitoringExtras = BackupManagerMonitorUtils.putMonitoringExtra(monitoringExtras, + monitoringExtras = mBackupManagerMonitorEventSender.putMonitoringExtra(monitoringExtras, EXTRA_LOG_EVENT_PACKAGE_VERSION, version); - mMonitor = BackupManagerMonitorUtils.monitorEvent( - mMonitor, + mBackupManagerMonitorEventSender.monitorEvent( BackupManagerMonitor.LOG_EVENT_ID_WIDGET_UNKNOWN_VERSION, null, LOG_EVENT_CATEGORY_BACKUP_MANAGER_POLICY, @@ -810,7 +798,7 @@ public class TarBackupReader { } public IBackupManagerMonitor getMonitor() { - return mMonitor; + return mBackupManagerMonitorEventSender.getMonitor(); } public byte[] getWidgetData() { diff --git a/services/robotests/backup/src/com/android/server/backup/keyvalue/KeyValueBackupReporterTest.java b/services/robotests/backup/src/com/android/server/backup/keyvalue/KeyValueBackupReporterTest.java index 14b4dc3dc7d0..2db2438b9a21 100644 --- a/services/robotests/backup/src/com/android/server/backup/keyvalue/KeyValueBackupReporterTest.java +++ b/services/robotests/backup/src/com/android/server/backup/keyvalue/KeyValueBackupReporterTest.java @@ -27,6 +27,7 @@ import android.platform.test.annotations.Presubmit; import android.util.Log; import com.android.server.backup.UserBackupManagerService; +import com.android.server.backup.utils.BackupManagerMonitorEventSender; import com.android.server.testing.shadows.ShadowEventLog; import com.android.server.testing.shadows.ShadowSlog; @@ -46,10 +47,13 @@ public class KeyValueBackupReporterTest { @Mock private IBackupManagerMonitor mMonitor; private KeyValueBackupReporter mReporter; + private BackupManagerMonitorEventSender mBackupManagerMonitorEventSender; @Before public void setUp() { - mReporter = new KeyValueBackupReporter(mBackupManagerService, mObserver, mMonitor); + mBackupManagerMonitorEventSender = new BackupManagerMonitorEventSender(mMonitor); + mReporter = new KeyValueBackupReporter( + mBackupManagerService, mObserver, mBackupManagerMonitorEventSender); } @Test diff --git a/services/robotests/backup/src/com/android/server/backup/keyvalue/KeyValueBackupTaskTest.java b/services/robotests/backup/src/com/android/server/backup/keyvalue/KeyValueBackupTaskTest.java index bfbc0f50f67a..7349c14ef62b 100644 --- a/services/robotests/backup/src/com/android/server/backup/keyvalue/KeyValueBackupTaskTest.java +++ b/services/robotests/backup/src/com/android/server/backup/keyvalue/KeyValueBackupTaskTest.java @@ -122,6 +122,7 @@ import com.android.server.backup.testing.TransportData; import com.android.server.backup.testing.TransportTestUtils; import com.android.server.backup.testing.TransportTestUtils.TransportMock; import com.android.server.backup.utils.BackupEligibilityRules; +import com.android.server.backup.utils.BackupManagerMonitorEventSender; import com.android.server.testing.shadows.FrameworkShadowLooper; import com.android.server.testing.shadows.ShadowApplicationPackageManager; import com.android.server.testing.shadows.ShadowBackupDataInput; @@ -260,7 +261,8 @@ public class KeyValueBackupTaskTest { mBackupHandler = mBackupManagerService.getBackupHandler(); mShadowBackupLooper = shadowOf(mBackupHandler.getLooper()); ShadowEventLog.setUp(); - mReporter = spy(new KeyValueBackupReporter(mBackupManagerService, mObserver, mMonitor)); + mReporter = spy(new KeyValueBackupReporter(mBackupManagerService, mObserver, + new BackupManagerMonitorEventSender(mMonitor))); when(mPackageManagerInternal.getApplicationEnabledState(any(), anyInt())) .thenReturn(PackageManager.COMPONENT_ENABLED_STATE_ENABLED); diff --git a/services/tests/mockingservicestests/src/com/android/server/backup/UserBackupManagerServiceTest.java b/services/tests/mockingservicestests/src/com/android/server/backup/UserBackupManagerServiceTest.java index dc1c6d57dfdb..c942cf4b8ee4 100644 --- a/services/tests/mockingservicestests/src/com/android/server/backup/UserBackupManagerServiceTest.java +++ b/services/tests/mockingservicestests/src/com/android/server/backup/UserBackupManagerServiceTest.java @@ -52,7 +52,7 @@ import com.android.server.backup.params.BackupParams; import com.android.server.backup.transport.BackupTransportClient; import com.android.server.backup.transport.TransportConnection; import com.android.server.backup.utils.BackupEligibilityRules; -import com.android.server.backup.utils.BackupManagerMonitorUtils; +import com.android.server.backup.utils.BackupManagerMonitorEventSender; import com.google.common.collect.ImmutableSet; @@ -86,6 +86,7 @@ public class UserBackupManagerServiceTest { @Mock BackupTransportClient mBackupTransport; @Mock BackupEligibilityRules mBackupEligibilityRules; @Mock LifecycleOperationStorage mOperationStorage; + @Mock BackupManagerMonitorEventSender mBackupManagerMonitorEventSender; private MockitoSession mSession; private TestBackupService mService; @@ -94,7 +95,7 @@ public class UserBackupManagerServiceTest { public void setUp() throws Exception { mSession = mockitoSession() .initMocks(this) - .mockStatic(BackupManagerMonitorUtils.class) + .mockStatic(BackupManagerMonitorEventSender.class) .mockStatic(FeatureFlagUtils.class) // TODO(b/263239775): Remove unnecessary stubbing. .strictness(Strictness.LENIENT) @@ -246,9 +247,9 @@ public class UserBackupManagerServiceTest { new DataTypeResult(/* dataType */ "type_2")); mService.reportDelayedRestoreResult(TEST_PACKAGE, results); - verify(() -> BackupManagerMonitorUtils.sendAgentLoggingResults( - eq(mBackupManagerMonitor), eq(packageInfo), eq(results), eq( - BackupAnnotations.OperationType.RESTORE))); + + verify(mBackupManagerMonitorEventSender).sendAgentLoggingResults( + eq(packageInfo), eq(results), eq(BackupAnnotations.OperationType.RESTORE)); } private static PackageInfo getPackageInfo(String packageName) { @@ -258,7 +259,7 @@ public class UserBackupManagerServiceTest { return packageInfo; } - private static class TestBackupService extends UserBackupManagerService { + private class TestBackupService extends UserBackupManagerService { boolean isEnabledStatePersisted = false; boolean shouldUseNewBackupEligibilityRules = false; @@ -293,6 +294,11 @@ public class UserBackupManagerServiceTest { return mWorkerThread; } + @Override + BackupManagerMonitorEventSender getBMMEventSender(IBackupManagerMonitor monitor) { + return mBackupManagerMonitorEventSender; + } + private void waitForAsyncOperation() { if (mWorkerThread == null) { return; diff --git a/services/tests/mockingservicestests/src/com/android/server/backup/utils/BackupManagerMonitorDumpsysUtilsTest.java b/services/tests/mockingservicestests/src/com/android/server/backup/utils/BackupManagerMonitorDumpsysUtilsTest.java new file mode 100644 index 000000000000..8e17b3a58769 --- /dev/null +++ b/services/tests/mockingservicestests/src/com/android/server/backup/utils/BackupManagerMonitorDumpsysUtilsTest.java @@ -0,0 +1,84 @@ +/* + * Copyright (C) 2023 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.server.backup.utils; + +import static org.junit.Assert.assertTrue; + +import android.app.backup.BackupManagerMonitor; +import android.os.Bundle; + +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.TemporaryFolder; + +import java.io.File; + +public class BackupManagerMonitorDumpsysUtilsTest { + private File mTempFile; + private TestBackupManagerMonitorDumpsysUtils mBackupManagerMonitorDumpsysUtils; + @Rule + public TemporaryFolder tmp = new TemporaryFolder(); + + @Before + public void setUp() throws Exception { + mTempFile = tmp.newFile("testbmmevents.txt"); + mBackupManagerMonitorDumpsysUtils = new TestBackupManagerMonitorDumpsysUtils(); + } + + + @Test + public void parseBackupManagerMonitorEventForDumpsys_bundleIsNull_noLogsWrittenToFile() + throws Exception { + mBackupManagerMonitorDumpsysUtils.parseBackupManagerMonitorRestoreEventForDumpsys(null); + + assertTrue(mTempFile.length() == 0); + + } + + @Test + public void parseBackupManagerMonitorEventForDumpsys_missingID_noLogsWrittenToFile() + throws Exception { + Bundle event = new Bundle(); + event.putInt(BackupManagerMonitor.EXTRA_LOG_EVENT_CATEGORY, 1); + mBackupManagerMonitorDumpsysUtils.parseBackupManagerMonitorRestoreEventForDumpsys(event); + + assertTrue(mTempFile.length() == 0); + } + + @Test + public void parseBackupManagerMonitorEventForDumpsys_missingCategory_noLogsWrittenToFile() + throws Exception { + Bundle event = new Bundle(); + event.putInt(BackupManagerMonitor.EXTRA_LOG_EVENT_ID, 1); + mBackupManagerMonitorDumpsysUtils.parseBackupManagerMonitorRestoreEventForDumpsys(event); + + assertTrue(mTempFile.length() == 0); + } + + private class TestBackupManagerMonitorDumpsysUtils + extends BackupManagerMonitorDumpsysUtils { + TestBackupManagerMonitorDumpsysUtils() { + super(); + } + + @Override + public File getBMMEventsFile() { + return mTempFile; + } + } +} diff --git a/services/tests/mockingservicestests/src/com/android/server/backup/utils/BackupManagerMonitorUtilsTest.java b/services/tests/mockingservicestests/src/com/android/server/backup/utils/BackupManagerMonitorEventSenderTest.java index 093ad3cc7bb3..3af2932ee937 100644 --- a/services/tests/mockingservicestests/src/com/android/server/backup/utils/BackupManagerMonitorUtilsTest.java +++ b/services/tests/mockingservicestests/src/com/android/server/backup/utils/BackupManagerMonitorEventSenderTest.java @@ -30,11 +30,11 @@ import static com.google.common.truth.Truth.assertThat; import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.doAnswer; import static org.mockito.Mockito.doThrow; +import static org.mockito.Mockito.never; import static org.mockito.Mockito.spy; import static org.mockito.Mockito.verify; import android.app.IBackupAgent; -import android.app.backup.BackupAnnotations; import android.app.backup.BackupAnnotations.OperationType; import android.app.backup.BackupManagerMonitor; import android.app.backup.BackupRestoreEventLogger; @@ -62,39 +62,65 @@ import java.util.List; @SmallTest @Presubmit @RunWith(AndroidJUnit4.class) -public class BackupManagerMonitorUtilsTest { +public class BackupManagerMonitorEventSenderTest { @Mock private IBackupManagerMonitor mMonitorMock; + @Mock private BackupManagerMonitorDumpsysUtils mBackupManagerMonitorDumpsysUtilsMock; + + private BackupManagerMonitorEventSender mBackupManagerMonitorEventSender; @Before public void setUp() { MockitoAnnotations.initMocks(this); + mBackupManagerMonitorEventSender = new BackupManagerMonitorEventSender(mMonitorMock, + mBackupManagerMonitorDumpsysUtilsMock); + } + + @Test + public void monitorEvent_monitorIsNull_sendBundleToDumpsys() throws Exception { + Bundle extras = new Bundle(); + extras.putInt(EXTRA_LOG_OPERATION_TYPE, OperationType.RESTORE); + mBackupManagerMonitorEventSender.setMonitor(null); + mBackupManagerMonitorEventSender.monitorEvent(0, null, 0, extras); + IBackupManagerMonitor monitor = mBackupManagerMonitorEventSender.getMonitor(); + + verify(mBackupManagerMonitorDumpsysUtilsMock).parseBackupManagerMonitorRestoreEventForDumpsys(any( + Bundle.class)); } @Test - public void monitorEvent_monitorIsNull_returnsNull() throws Exception { - IBackupManagerMonitor result = BackupManagerMonitorUtils.monitorEvent(null, 0, null, 0, - null); + public void monitorEvent_monitorIsNull_doNotCallOnEvent() throws Exception { + mBackupManagerMonitorEventSender = new BackupManagerMonitorEventSender(null); + mBackupManagerMonitorEventSender.monitorEvent(0, null, 0, null); + IBackupManagerMonitor monitor = mBackupManagerMonitorEventSender.getMonitor(); - assertThat(result).isNull(); + verify(mMonitorMock, never()).onEvent(any(Bundle.class)); } @Test - public void monitorEvent_monitorOnEventThrows_returnsNull() throws Exception { + public void monitorEvent_monitorOnEventThrows_setsMonitorToNull() throws Exception { doThrow(new RemoteException()).when(mMonitorMock).onEvent(any(Bundle.class)); - IBackupManagerMonitor result = BackupManagerMonitorUtils.monitorEvent(mMonitorMock, 0, null, - 0, null); + mBackupManagerMonitorEventSender.monitorEvent(0, null, 0, null); + IBackupManagerMonitor monitor = mBackupManagerMonitorEventSender.getMonitor(); verify(mMonitorMock).onEvent(any(Bundle.class)); - assertThat(result).isNull(); + assertThat(monitor).isNull(); + } + + @Test + public void monitorEvent_extrasAreNull_doNotSendBundleToDumpsys() throws Exception { + mBackupManagerMonitorEventSender.monitorEvent(1, null, 2, null); + + verify(mBackupManagerMonitorDumpsysUtilsMock, never()) + .parseBackupManagerMonitorRestoreEventForDumpsys(any(Bundle.class)); } @Test public void monitorEvent_packageAndExtrasAreNull_fillsBundleCorrectly() throws Exception { - IBackupManagerMonitor result = BackupManagerMonitorUtils.monitorEvent(mMonitorMock, 1, null, - 2, null); + mBackupManagerMonitorEventSender.monitorEvent(1, null, 2, null); + IBackupManagerMonitor monitor = mBackupManagerMonitorEventSender.getMonitor(); - assertThat(result).isEqualTo(mMonitorMock); + assertThat(monitor).isEqualTo(mMonitorMock); ArgumentCaptor<Bundle> bundleCaptor = ArgumentCaptor.forClass(Bundle.class); verify(mMonitorMock).onEvent(bundleCaptor.capture()); Bundle eventBundle = bundleCaptor.getValue(); @@ -112,10 +138,10 @@ public class BackupManagerMonitorUtilsTest { extras.putInt("key1", 4); extras.putString("key2", "value2"); - IBackupManagerMonitor result = BackupManagerMonitorUtils.monitorEvent(mMonitorMock, 1, - packageInfo, 2, extras); + mBackupManagerMonitorEventSender.monitorEvent(1, packageInfo, 2, extras); + IBackupManagerMonitor monitor = mBackupManagerMonitorEventSender.getMonitor(); - assertThat(result).isEqualTo(mMonitorMock); + assertThat(monitor).isEqualTo(mMonitorMock); ArgumentCaptor<Bundle> bundleCaptor = ArgumentCaptor.forClass(Bundle.class); verify(mMonitorMock).onEvent(bundleCaptor.capture()); Bundle eventBundle = bundleCaptor.getValue(); @@ -130,7 +156,8 @@ public class BackupManagerMonitorUtilsTest { } @Test - public void monitorEvent_packageAndExtrasAreNotNull_fillsBundleCorrectlyLong() throws Exception { + public void monitorEvent_packageAndExtrasAreNotNull_fillsBundleCorrectlyLong() + throws Exception { PackageInfo packageInfo = new PackageInfo(); packageInfo.packageName = "test.package"; packageInfo.versionCode = 3; @@ -139,10 +166,10 @@ public class BackupManagerMonitorUtilsTest { extras.putInt("key1", 4); extras.putString("key2", "value2"); - IBackupManagerMonitor result = BackupManagerMonitorUtils.monitorEvent(mMonitorMock, 1, - packageInfo, 2, extras); + mBackupManagerMonitorEventSender.monitorEvent(1, packageInfo, 2, extras); + IBackupManagerMonitor monitor = mBackupManagerMonitorEventSender.getMonitor(); - assertThat(result).isEqualTo(mMonitorMock); + assertThat(monitor).isEqualTo(mMonitorMock); ArgumentCaptor<Bundle> bundleCaptor = ArgumentCaptor.forClass(Bundle.class); verify(mMonitorMock).onEvent(bundleCaptor.capture()); Bundle eventBundle = bundleCaptor.getValue(); @@ -158,15 +185,45 @@ public class BackupManagerMonitorUtilsTest { } @Test + public void monitorEvent_eventOpTypeIsRestore_sendBundleToDumpsys() throws Exception { + Bundle extras = new Bundle(); + extras.putInt(EXTRA_LOG_OPERATION_TYPE, OperationType.RESTORE); + mBackupManagerMonitorEventSender.monitorEvent(1, null, 2, extras); + + verify(mBackupManagerMonitorDumpsysUtilsMock).parseBackupManagerMonitorRestoreEventForDumpsys(any( + Bundle.class)); + } + + @Test + public void monitorEvent_eventOpTypeIsBackup_doNotSendBundleToDumpsys() throws Exception { + Bundle extras = new Bundle(); + extras.putInt(EXTRA_LOG_OPERATION_TYPE, OperationType.BACKUP); + mBackupManagerMonitorEventSender.monitorEvent(1, null, 2, extras); + + verify(mBackupManagerMonitorDumpsysUtilsMock, never()) + .parseBackupManagerMonitorRestoreEventForDumpsys(any(Bundle.class)); + } + + @Test + public void monitorEvent_eventOpTypeIsUnknown_doNotSendBundleToDumpsys() throws Exception { + Bundle extras = new Bundle(); + extras.putInt(EXTRA_LOG_OPERATION_TYPE, OperationType.UNKNOWN); + mBackupManagerMonitorEventSender.monitorEvent(1, null, 2, extras); + + verify(mBackupManagerMonitorDumpsysUtilsMock, never()) + .parseBackupManagerMonitorRestoreEventForDumpsys(any(Bundle.class)); + } + + @Test public void monitorAgentLoggingResults_onBackup_fillsBundleCorrectly() throws Exception { PackageInfo packageInfo = new PackageInfo(); packageInfo.packageName = "test.package"; // Mock an agent that returns a logging result. IBackupAgent agent = setUpLoggingAgentForOperation(OperationType.BACKUP); - IBackupManagerMonitor monitor = - BackupManagerMonitorUtils.monitorAgentLoggingResults( - mMonitorMock, packageInfo, agent); + + mBackupManagerMonitorEventSender.monitorAgentLoggingResults(packageInfo, agent); + IBackupManagerMonitor monitor = mBackupManagerMonitorEventSender.getMonitor(); assertCorrectBundleSentToMonitor(monitor, OperationType.BACKUP); } @@ -178,9 +235,8 @@ public class BackupManagerMonitorUtilsTest { // Mock an agent that returns a logging result. IBackupAgent agent = setUpLoggingAgentForOperation(OperationType.RESTORE); - IBackupManagerMonitor monitor = - BackupManagerMonitorUtils.monitorAgentLoggingResults( - mMonitorMock, packageInfo, agent); + mBackupManagerMonitorEventSender.monitorAgentLoggingResults(packageInfo, agent); + IBackupManagerMonitor monitor = mBackupManagerMonitorEventSender.getMonitor(); assertCorrectBundleSentToMonitor(monitor, OperationType.RESTORE); } @@ -217,9 +273,9 @@ public class BackupManagerMonitorUtilsTest { List<BackupRestoreEventLogger.DataTypeResult> loggingResults = new ArrayList<>(); loggingResults.add(new BackupRestoreEventLogger.DataTypeResult("testLoggingResult")); - IBackupManagerMonitor monitor = BackupManagerMonitorUtils.sendAgentLoggingResults( - mMonitorMock, packageInfo, loggingResults, OperationType.BACKUP); - + mBackupManagerMonitorEventSender.sendAgentLoggingResults( + packageInfo, loggingResults, OperationType.BACKUP); + IBackupManagerMonitor monitor = mBackupManagerMonitorEventSender.getMonitor(); assertCorrectBundleSentToMonitor(monitor, OperationType.BACKUP); } @@ -230,8 +286,9 @@ public class BackupManagerMonitorUtilsTest { List<BackupRestoreEventLogger.DataTypeResult> loggingResults = new ArrayList<>(); loggingResults.add(new BackupRestoreEventLogger.DataTypeResult("testLoggingResult")); - IBackupManagerMonitor monitor = BackupManagerMonitorUtils.sendAgentLoggingResults( - mMonitorMock, packageInfo, loggingResults, OperationType.RESTORE); + mBackupManagerMonitorEventSender.sendAgentLoggingResults( + packageInfo, loggingResults, OperationType.RESTORE); + IBackupManagerMonitor monitor = mBackupManagerMonitorEventSender.getMonitor(); assertCorrectBundleSentToMonitor(monitor, OperationType.RESTORE); } @@ -262,7 +319,7 @@ public class BackupManagerMonitorUtilsTest { public void putMonitoringExtraString_bundleExists_fillsBundleCorrectly() throws Exception { Bundle bundle = new Bundle(); - Bundle result = BackupManagerMonitorUtils.putMonitoringExtra(bundle, "key", "value"); + Bundle result = mBackupManagerMonitorEventSender.putMonitoringExtra(bundle, "key", "value"); assertThat(result).isEqualTo(bundle); assertThat(result.size()).isEqualTo(1); @@ -272,7 +329,7 @@ public class BackupManagerMonitorUtilsTest { @Test public void putMonitoringExtraString_bundleDoesNotExist_fillsBundleCorrectly() throws Exception { - Bundle result = BackupManagerMonitorUtils.putMonitoringExtra(null, "key", "value"); + Bundle result = mBackupManagerMonitorEventSender.putMonitoringExtra(null, "key", "value"); assertThat(result).isNotNull(); assertThat(result.size()).isEqualTo(1); @@ -284,7 +341,7 @@ public class BackupManagerMonitorUtilsTest { public void putMonitoringExtraLong_bundleExists_fillsBundleCorrectly() throws Exception { Bundle bundle = new Bundle(); - Bundle result = BackupManagerMonitorUtils.putMonitoringExtra(bundle, "key", 123); + Bundle result = mBackupManagerMonitorEventSender.putMonitoringExtra(bundle, "key", 123); assertThat(result).isEqualTo(bundle); assertThat(result.size()).isEqualTo(1); @@ -293,7 +350,7 @@ public class BackupManagerMonitorUtilsTest { @Test public void putMonitoringExtraLong_bundleDoesNotExist_fillsBundleCorrectly() throws Exception { - Bundle result = BackupManagerMonitorUtils.putMonitoringExtra(null, "key", 123); + Bundle result = mBackupManagerMonitorEventSender.putMonitoringExtra(null, "key", 123); assertThat(result).isNotNull(); assertThat(result.size()).isEqualTo(1); @@ -304,7 +361,7 @@ public class BackupManagerMonitorUtilsTest { public void putMonitoringExtraBoolean_bundleExists_fillsBundleCorrectly() throws Exception { Bundle bundle = new Bundle(); - Bundle result = BackupManagerMonitorUtils.putMonitoringExtra(bundle, "key", true); + Bundle result = mBackupManagerMonitorEventSender.putMonitoringExtra(bundle, "key", true); assertThat(result).isEqualTo(bundle); assertThat(result.size()).isEqualTo(1); @@ -314,10 +371,10 @@ public class BackupManagerMonitorUtilsTest { @Test public void putMonitoringExtraBoolean_bundleDoesNotExist_fillsBundleCorrectly() throws Exception { - Bundle result = BackupManagerMonitorUtils.putMonitoringExtra(null, "key", true); + Bundle result = mBackupManagerMonitorEventSender.putMonitoringExtra(null, "key", true); assertThat(result).isNotNull(); assertThat(result.size()).isEqualTo(1); assertThat(result.getBoolean("key")).isTrue(); } -}
\ No newline at end of file +} |