Make observer last parameter

As per feedback, moving observer as the last parameter for better
Kotlin readability in following APIs of PackageWatchdog:
1. registerHealthObserver
2. startExplicitHealthCheck

Bug: 384702135
Test: TH
Flag: android.crashrecovery.flags.enable_crashrecovery
Change-Id: I5a6110215d89e4acc557c3055e2ed6faee7c7467

9 files changed, 159 insertions, 163 deletions

diff --git a/packages/CrashRecovery/services/module/java/com/android/server/PackageWatchdog.java b/packages/CrashRecovery/services/module/java/com/android/server/PackageWatchdog.java
index e5126b431e28..951ab64524c0 100644
--- a/packages/CrashRecovery/services/module/java/com/android/server/PackageWatchdog.java
+++ b/packages/CrashRecovery/services/module/java/com/android/server/PackageWatchdog.java
@@ -347,8 +347,8 @@ public class PackageWatchdog {
      *                 and boot loops.
      * @param executor Executor for the thread on which observers would receive callbacks
      */
-    public void registerHealthObserver(@NonNull PackageHealthObserver observer,
-            @NonNull @CallbackExecutor Executor executor) {
+    public void registerHealthObserver(@NonNull @CallbackExecutor Executor executor,
+            @NonNull PackageHealthObserver observer) {
         synchronized (sLock) {
             ObserverInternal internalObserver = mAllObservers.get(observer.getUniqueIdentifier());
             if (internalObserver != null) {
@@ -390,8 +390,8 @@ public class PackageWatchdog {
      *
      * @throws IllegalStateException if the observer was not previously registered
      */
-    public void startExplicitHealthCheck(@NonNull PackageHealthObserver observer,
-            @NonNull List<String> packageNames, long timeoutMs) {
+    public void startExplicitHealthCheck(@NonNull List<String> packageNames, long timeoutMs,
+            @NonNull PackageHealthObserver observer) {
         synchronized (sLock) {
             if (!mAllObservers.containsKey(observer.getUniqueIdentifier())) {
                 Slog.wtf(TAG, "No observer found, need to register the observer: "
diff --git a/packages/CrashRecovery/services/module/java/com/android/server/RescueParty.java b/packages/CrashRecovery/services/module/java/com/android/server/RescueParty.java
index bb9e96238e1c..40bc5f78a9c6 100644
--- a/packages/CrashRecovery/services/module/java/com/android/server/RescueParty.java
+++ b/packages/CrashRecovery/services/module/java/com/android/server/RescueParty.java
@@ -162,7 +162,7 @@ public class RescueParty {
     /** Register the Rescue Party observer as a Package Watchdog health observer */
     public static void registerHealthObserver(Context context) {
         PackageWatchdog.getInstance(context).registerHealthObserver(
-                RescuePartyObserver.getInstance(context), context.getMainExecutor());
+                context.getMainExecutor(), RescuePartyObserver.getInstance(context));
     }
 
     private static boolean isDisabled() {
@@ -316,9 +316,9 @@ public class RescueParty {
             Slog.i(TAG, "Starting to observe: " + callingPackageList + ", updated namespace: "
                     + updatedNamespace);
             PackageWatchdog.getInstance(context).startExplicitHealthCheck(
-                    rescuePartyObserver,
                     callingPackageList,
-                    DEFAULT_OBSERVING_DURATION_MS);
+                    DEFAULT_OBSERVING_DURATION_MS,
+                    rescuePartyObserver);
         }
     }
 
diff --git a/packages/CrashRecovery/services/module/java/com/android/server/rollback/RollbackPackageHealthObserver.java b/packages/CrashRecovery/services/module/java/com/android/server/rollback/RollbackPackageHealthObserver.java
index c75f3aa60ac4..4978df491c62 100644
--- a/packages/CrashRecovery/services/module/java/com/android/server/rollback/RollbackPackageHealthObserver.java
+++ b/packages/CrashRecovery/services/module/java/com/android/server/rollback/RollbackPackageHealthObserver.java
@@ -113,8 +113,8 @@ public final class RollbackPackageHealthObserver implements PackageHealthObserve
         dataDir.mkdirs();
         mLastStagedRollbackIdsFile = new File(dataDir, "last-staged-rollback-ids");
         mTwoPhaseRollbackEnabledFile = new File(dataDir, "two-phase-rollback-enabled");
-        PackageWatchdog.getInstance(mContext).registerHealthObserver(this,
-                context.getMainExecutor());
+        PackageWatchdog.getInstance(mContext).registerHealthObserver(context.getMainExecutor(),
+                this);
 
         if (SystemProperties.getBoolean("sys.boot_completed", false)) {
             // Load the value from the file if system server has crashed and restarted
diff --git a/packages/CrashRecovery/services/platform/java/com/android/server/PackageWatchdog.java b/packages/CrashRecovery/services/platform/java/com/android/server/PackageWatchdog.java
index ffae5176cebf..9811f395bb05 100644
--- a/packages/CrashRecovery/services/platform/java/com/android/server/PackageWatchdog.java
+++ b/packages/CrashRecovery/services/platform/java/com/android/server/PackageWatchdog.java
@@ -363,7 +363,7 @@ public class PackageWatchdog {
      * it will resume observing any packages requested from a previous boot.
      * @hide
      */
-    public void registerHealthObserver(PackageHealthObserver observer, Executor ignoredExecutor) {
+    public void registerHealthObserver(Executor ignoredExecutor, PackageHealthObserver observer) {
         synchronized (mLock) {
             ObserverInternal internalObserver = mAllObservers.get(observer.getUniqueIdentifier());
             if (internalObserver != null) {
@@ -397,8 +397,8 @@ public class PackageWatchdog {
      * {@link #DEFAULT_OBSERVING_DURATION_MS} will be used.
      * @hide
      */
-    public void startExplicitHealthCheck(PackageHealthObserver observer, List<String> packageNames,
-            long durationMs) {
+    public void startExplicitHealthCheck(List<String> packageNames, long durationMs,
+            PackageHealthObserver observer) {
         if (packageNames.isEmpty()) {
             Slog.wtf(TAG, "No packages to observe, " + observer.getUniqueIdentifier());
             return;
@@ -446,7 +446,7 @@ public class PackageWatchdog {
             }
 
             // Register observer in case not already registered
-            registerHealthObserver(observer, null);
+            registerHealthObserver(null, observer);
 
             // Sync after we add the new packages to the observers. We may have received packges
             // requiring an earlier schedule than we are currently scheduled for.
diff --git a/packages/CrashRecovery/services/platform/java/com/android/server/RescueParty.java b/packages/CrashRecovery/services/platform/java/com/android/server/RescueParty.java
index c6452d31f881..8251fb4c98e4 100644
--- a/packages/CrashRecovery/services/platform/java/com/android/server/RescueParty.java
+++ b/packages/CrashRecovery/services/platform/java/com/android/server/RescueParty.java
@@ -168,7 +168,7 @@ public class RescueParty {
     /** Register the Rescue Party observer as a Package Watchdog health observer */
     public static void registerHealthObserver(Context context) {
         PackageWatchdog.getInstance(context).registerHealthObserver(
-                RescuePartyObserver.getInstance(context), null);
+                null, RescuePartyObserver.getInstance(context));
     }
 
     private static boolean isDisabled() {
@@ -390,9 +390,9 @@ public class RescueParty {
             Slog.i(TAG, "Starting to observe: " + callingPackageList + ", updated namespace: "
                     + updatedNamespace);
             PackageWatchdog.getInstance(context).startExplicitHealthCheck(
-                    rescuePartyObserver,
                     callingPackageList,
-                    DEFAULT_OBSERVING_DURATION_MS);
+                    DEFAULT_OBSERVING_DURATION_MS,
+                    rescuePartyObserver);
         }
     }
 
diff --git a/packages/CrashRecovery/services/platform/java/com/android/server/rollback/RollbackPackageHealthObserver.java b/packages/CrashRecovery/services/platform/java/com/android/server/rollback/RollbackPackageHealthObserver.java
index 04115373e926..5c4e57e93519 100644
--- a/packages/CrashRecovery/services/platform/java/com/android/server/rollback/RollbackPackageHealthObserver.java
+++ b/packages/CrashRecovery/services/platform/java/com/android/server/rollback/RollbackPackageHealthObserver.java
@@ -112,7 +112,7 @@ public final class RollbackPackageHealthObserver implements PackageHealthObserve
         dataDir.mkdirs();
         mLastStagedRollbackIdsFile = new File(dataDir, "last-staged-rollback-ids");
         mTwoPhaseRollbackEnabledFile = new File(dataDir, "two-phase-rollback-enabled");
-        PackageWatchdog.getInstance(mContext).registerHealthObserver(this, null);
+        PackageWatchdog.getInstance(mContext).registerHealthObserver(null, this);
         mApexManager = apexManager;
 
         if (SystemProperties.getBoolean("sys.boot_completed", false)) {
@@ -286,7 +286,7 @@ public final class RollbackPackageHealthObserver implements PackageHealthObserve
     @AnyThread
     @NonNull
     public void startObservingHealth(@NonNull List<String> packages, @NonNull long durationMs) {
-        PackageWatchdog.getInstance(mContext).startExplicitHealthCheck(this, packages, durationMs);
+        PackageWatchdog.getInstance(mContext).startExplicitHealthCheck(packages, durationMs, this);
     }
 
     @AnyThread
diff --git a/services/core/java/com/android/server/rollback/RollbackManagerServiceImpl.java b/services/core/java/com/android/server/rollback/RollbackManagerServiceImpl.java
index 1bed48a09d9e..2e6be5bb56a8 100644
--- a/services/core/java/com/android/server/rollback/RollbackManagerServiceImpl.java
+++ b/services/core/java/com/android/server/rollback/RollbackManagerServiceImpl.java
@@ -1251,12 +1251,12 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub implements Rollba
                 // should document in PackageInstaller.SessionParams#setEnableRollback
                 // After enabling and committing any rollback, observe packages and
                 // prepare to rollback if packages crashes too frequently.
-                mPackageWatchdog.startExplicitHealthCheck(mPackageHealthObserver,
-                        rollback.getPackageNames(), mRollbackLifetimeDurationInMillis);
+                mPackageWatchdog.startExplicitHealthCheck(rollback.getPackageNames(),
+                        mRollbackLifetimeDurationInMillis, mPackageHealthObserver);
             }
         } else {
-            mPackageWatchdog.startExplicitHealthCheck(mPackageHealthObserver,
-                    rollback.getPackageNames(), mRollbackLifetimeDurationInMillis);
+            mPackageWatchdog.startExplicitHealthCheck(rollback.getPackageNames(),
+                    mRollbackLifetimeDurationInMillis, mPackageHealthObserver);
         }
         runExpiration();
     }
diff --git a/tests/PackageWatchdog/src/com/android/server/CrashRecoveryTest.java b/tests/PackageWatchdog/src/com/android/server/CrashRecoveryTest.java
index 49616c30b784..8ac3433033c6 100644
--- a/tests/PackageWatchdog/src/com/android/server/CrashRecoveryTest.java
+++ b/tests/PackageWatchdog/src/com/android/server/CrashRecoveryTest.java
@@ -765,14 +765,14 @@ public class CrashRecoveryTest {
         } catch (PackageManager.NameNotFoundException e) {
             throw new RuntimeException(e);
         }
-        watchdog.registerHealthObserver(rollbackObserver, mTestExecutor);
+        watchdog.registerHealthObserver(mTestExecutor, rollbackObserver);
         return rollbackObserver;
     }
     RescuePartyObserver setUpRescuePartyObserver(PackageWatchdog watchdog) {
         setCrashRecoveryPropRescueBootCount(0);
         RescuePartyObserver rescuePartyObserver = spy(RescuePartyObserver.getInstance(mSpyContext));
         assertFalse(RescueParty.isRebootPropertySet());
-        watchdog.registerHealthObserver(rescuePartyObserver, mTestExecutor);
+        watchdog.registerHealthObserver(mTestExecutor, rescuePartyObserver);
         return rescuePartyObserver;
     }
 
diff --git a/tests/PackageWatchdog/src/com/android/server/PackageWatchdogTest.java b/tests/PackageWatchdog/src/com/android/server/PackageWatchdogTest.java
index 928e2326498d..1c50cb1b55fd 100644
--- a/tests/PackageWatchdog/src/com/android/server/PackageWatchdogTest.java
+++ b/tests/PackageWatchdog/src/com/android/server/PackageWatchdogTest.java
@@ -54,7 +54,6 @@ import android.platform.test.flag.junit.SetFlagsRule;
 import android.provider.DeviceConfig;
 import android.util.AtomicFile;
 import android.util.LongArrayQueue;
-import android.util.Slog;
 import android.util.Xml;
 
 import androidx.test.InstrumentationRegistry;
@@ -231,8 +230,8 @@ public class PackageWatchdogTest {
         PackageWatchdog watchdog = createWatchdog();
         TestObserver observer = new TestObserver(OBSERVER_NAME_1);
 
-        watchdog.registerHealthObserver(observer, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observer, Arrays.asList(APP_A), SHORT_DURATION);
+        watchdog.registerHealthObserver(mTestExecutor, observer);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A), SHORT_DURATION, observer);
         raiseFatalFailureAndDispatch(watchdog,
                 Arrays.asList(new VersionedPackage(APP_A, VERSION_CODE)),
                 PackageWatchdog.FAILURE_REASON_UNKNOWN);
@@ -248,10 +247,10 @@ public class PackageWatchdogTest {
         TestObserver observer1 = new TestObserver(OBSERVER_NAME_1);
         TestObserver observer2 = new TestObserver(OBSERVER_NAME_2);
 
-        watchdog.registerHealthObserver(observer1, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observer1, Arrays.asList(APP_A), SHORT_DURATION);
-        watchdog.registerHealthObserver(observer2, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observer2, Arrays.asList(APP_A, APP_B), SHORT_DURATION);
+        watchdog.registerHealthObserver(mTestExecutor, observer1);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A), SHORT_DURATION, observer1);
+        watchdog.registerHealthObserver(mTestExecutor, observer2);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A, APP_B), SHORT_DURATION, observer2);
         raiseFatalFailureAndDispatch(watchdog,
                 Arrays.asList(new VersionedPackage(APP_A, VERSION_CODE),
                         new VersionedPackage(APP_B, VERSION_CODE)),
@@ -268,8 +267,8 @@ public class PackageWatchdogTest {
         PackageWatchdog watchdog = createWatchdog();
         TestObserver observer = new TestObserver(OBSERVER_NAME_1);
 
-        watchdog.registerHealthObserver(observer, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observer, Arrays.asList(APP_A), SHORT_DURATION);
+        watchdog.registerHealthObserver(mTestExecutor, observer);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A), SHORT_DURATION, observer);
         watchdog.unregisterHealthObserver(observer);
         raiseFatalFailureAndDispatch(watchdog,
                 Arrays.asList(new VersionedPackage(APP_A, VERSION_CODE)),
@@ -285,10 +284,10 @@ public class PackageWatchdogTest {
         TestObserver observer1 = new TestObserver(OBSERVER_NAME_1);
         TestObserver observer2 = new TestObserver(OBSERVER_NAME_2);
 
-        watchdog.registerHealthObserver(observer1, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observer1, Arrays.asList(APP_A), SHORT_DURATION);
-        watchdog.registerHealthObserver(observer2, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observer2, Arrays.asList(APP_A), SHORT_DURATION);
+        watchdog.registerHealthObserver(mTestExecutor, observer1);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A), SHORT_DURATION, observer1);
+        watchdog.registerHealthObserver(mTestExecutor, observer2);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A), SHORT_DURATION, observer2);
         watchdog.unregisterHealthObserver(observer2);
         raiseFatalFailureAndDispatch(watchdog,
                 Arrays.asList(new VersionedPackage(APP_A, VERSION_CODE)),
@@ -305,8 +304,8 @@ public class PackageWatchdogTest {
         PackageWatchdog watchdog = createWatchdog();
         TestObserver observer = new TestObserver(OBSERVER_NAME_1);
 
-        watchdog.registerHealthObserver(observer, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observer, Arrays.asList(APP_A), SHORT_DURATION);
+        watchdog.registerHealthObserver(mTestExecutor, observer);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A), SHORT_DURATION, observer);
         moveTimeForwardAndDispatch(SHORT_DURATION);
         raiseFatalFailureAndDispatch(watchdog,
                 Arrays.asList(new VersionedPackage(APP_A, VERSION_CODE)),
@@ -322,10 +321,10 @@ public class PackageWatchdogTest {
         TestObserver observer1 = new TestObserver(OBSERVER_NAME_1);
         TestObserver observer2 = new TestObserver(OBSERVER_NAME_2);
 
-        watchdog.registerHealthObserver(observer1, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observer1, Arrays.asList(APP_A), SHORT_DURATION);
-        watchdog.registerHealthObserver(observer2, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observer2, Arrays.asList(APP_A), LONG_DURATION);
+        watchdog.registerHealthObserver(mTestExecutor, observer1);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A), SHORT_DURATION, observer1);
+        watchdog.registerHealthObserver(mTestExecutor, observer2);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A), LONG_DURATION, observer2);
         moveTimeForwardAndDispatch(SHORT_DURATION);
         raiseFatalFailureAndDispatch(watchdog,
                 Arrays.asList(new VersionedPackage(APP_A, VERSION_CODE)),
@@ -344,14 +343,14 @@ public class PackageWatchdogTest {
         TestObserver observer = new TestObserver(OBSERVER_NAME_1);
 
         // Start observing APP_A
-        watchdog.registerHealthObserver(observer, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observer, Arrays.asList(APP_A), SHORT_DURATION);
+        watchdog.registerHealthObserver(mTestExecutor, observer);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A), SHORT_DURATION, observer);
 
         // Then advance time half-way
         moveTimeForwardAndDispatch(SHORT_DURATION / 2);
 
         // Start observing APP_A again
-        watchdog.startExplicitHealthCheck(observer, Arrays.asList(APP_A), SHORT_DURATION);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A), SHORT_DURATION, observer);
 
         // Then advance time such that it should have expired were it not for the second observation
         moveTimeForwardAndDispatch((SHORT_DURATION / 2) + 1);
@@ -373,17 +372,17 @@ public class PackageWatchdogTest {
         TestObserver observer1 = new TestObserver(OBSERVER_NAME_1);
         TestObserver observer2 = new TestObserver(OBSERVER_NAME_2);
 
-        watchdog1.registerHealthObserver(observer1, mTestExecutor);
-        watchdog1.startExplicitHealthCheck(observer1, Arrays.asList(APP_A), SHORT_DURATION);
-        watchdog1.registerHealthObserver(observer2, mTestExecutor);
-        watchdog1.startExplicitHealthCheck(observer2, Arrays.asList(APP_A, APP_B), SHORT_DURATION);
+        watchdog1.registerHealthObserver(mTestExecutor, observer1);
+        watchdog1.startExplicitHealthCheck(Arrays.asList(APP_A), SHORT_DURATION, observer1);
+        watchdog1.registerHealthObserver(mTestExecutor, observer2);
+        watchdog1.startExplicitHealthCheck(Arrays.asList(APP_A, APP_B), SHORT_DURATION, observer2);
         // Then advance time and run IO Handler so file is saved
         mTestLooper.dispatchAll();
         // Then start a new watchdog
         PackageWatchdog watchdog2 = createWatchdog();
         // Then resume observer1 and observer2
-        watchdog2.registerHealthObserver(observer1, mTestExecutor);
-        watchdog2.registerHealthObserver(observer2, mTestExecutor);
+        watchdog2.registerHealthObserver(mTestExecutor, observer1);
+        watchdog2.registerHealthObserver(mTestExecutor, observer2);
         raiseFatalFailureAndDispatch(watchdog2,
                 Arrays.asList(new VersionedPackage(APP_A, VERSION_CODE),
                         new VersionedPackage(APP_B, VERSION_CODE)),
@@ -405,10 +404,10 @@ public class PackageWatchdogTest {
         TestObserver observer1 = new TestObserver(OBSERVER_NAME_1);
         TestObserver observer2 = new TestObserver(OBSERVER_NAME_2);
 
-        watchdog.registerHealthObserver(observer2, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observer2, Arrays.asList(APP_A), SHORT_DURATION);
-        watchdog.registerHealthObserver(observer1, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observer1, Arrays.asList(APP_A), SHORT_DURATION);
+        watchdog.registerHealthObserver(mTestExecutor, observer2);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A), SHORT_DURATION, observer2);
+        watchdog.registerHealthObserver(mTestExecutor, observer1);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A), SHORT_DURATION, observer1);
 
         // Then fail APP_A below the threshold
         for (int i = 0; i < watchdog.getTriggerFailureCount() - 1; i++) {
@@ -434,10 +433,10 @@ public class PackageWatchdogTest {
         TestObserver observer1 = new TestObserver(OBSERVER_NAME_1);
         TestObserver observer2 = new TestObserver(OBSERVER_NAME_2);
 
-        watchdog.registerHealthObserver(observer2, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observer2, Arrays.asList(APP_A), SHORT_DURATION);
-        watchdog.registerHealthObserver(observer1, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observer1, Arrays.asList(APP_B), SHORT_DURATION);
+        watchdog.registerHealthObserver(mTestExecutor, observer2);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A), SHORT_DURATION, observer2);
+        watchdog.registerHealthObserver(mTestExecutor, observer1);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_B), SHORT_DURATION, observer1);
 
         // Then fail APP_C (not observed) above the threshold
         raiseFatalFailureAndDispatch(watchdog,
@@ -469,8 +468,8 @@ public class PackageWatchdogTest {
                 }
             };
 
-        watchdog.registerHealthObserver(observer, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observer, Arrays.asList(APP_A), SHORT_DURATION);
+        watchdog.registerHealthObserver(mTestExecutor, observer);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A), SHORT_DURATION, observer);
 
         // Then fail APP_A (different version) above the threshold
         raiseFatalFailureAndDispatch(watchdog,
@@ -499,18 +498,17 @@ public class PackageWatchdogTest {
                 PackageHealthObserverImpact.USER_IMPACT_LEVEL_10);
 
         // Start observing for all impact observers
-        watchdog.registerHealthObserver(observerNone, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observerNone, Arrays.asList(APP_A, APP_B, APP_C, APP_D),
-                SHORT_DURATION);
-        watchdog.registerHealthObserver(observerHigh, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observerHigh, Arrays.asList(APP_A, APP_B, APP_C),
-                SHORT_DURATION);
-        watchdog.registerHealthObserver(observerMid, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observerMid, Arrays.asList(APP_A, APP_B),
-                SHORT_DURATION);
-        watchdog.registerHealthObserver(observerLow, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observerLow, Arrays.asList(APP_A),
-                SHORT_DURATION);
+        watchdog.registerHealthObserver(mTestExecutor, observerNone);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A, APP_B, APP_C, APP_D),
+                SHORT_DURATION, observerNone);
+        watchdog.registerHealthObserver(mTestExecutor, observerHigh);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A, APP_B, APP_C), SHORT_DURATION,
+                observerHigh);
+        watchdog.registerHealthObserver(mTestExecutor, observerMid);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A, APP_B), SHORT_DURATION,
+                observerMid);
+        watchdog.registerHealthObserver(mTestExecutor, observerLow);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A), SHORT_DURATION, observerLow);
 
         // Then fail all apps above the threshold
         raiseFatalFailureAndDispatch(watchdog,
@@ -549,18 +547,17 @@ public class PackageWatchdogTest {
                 PackageHealthObserverImpact.USER_IMPACT_LEVEL_10);
 
         // Start observing for all impact observers
-        watchdog.registerHealthObserver(observerNone, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observerNone, Arrays.asList(APP_A, APP_B, APP_C, APP_D),
-                SHORT_DURATION);
-        watchdog.registerHealthObserver(observerHigh, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observerHigh, Arrays.asList(APP_A, APP_B, APP_C),
-                SHORT_DURATION);
-        watchdog.registerHealthObserver(observerMid, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observerMid, Arrays.asList(APP_A, APP_B),
-                SHORT_DURATION);
-        watchdog.registerHealthObserver(observerLow, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observerLow, Arrays.asList(APP_A),
-                SHORT_DURATION);
+        watchdog.registerHealthObserver(mTestExecutor, observerNone);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A, APP_B, APP_C, APP_D),
+                SHORT_DURATION, observerNone);
+        watchdog.registerHealthObserver(mTestExecutor, observerHigh);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A, APP_B, APP_C), SHORT_DURATION,
+                observerHigh);
+        watchdog.registerHealthObserver(mTestExecutor, observerMid);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A, APP_B), SHORT_DURATION,
+                observerMid);
+        watchdog.registerHealthObserver(mTestExecutor, observerLow);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A), SHORT_DURATION, observerLow);
 
         // Then fail all apps above the threshold
         raiseFatalFailureAndDispatch(watchdog,
@@ -607,10 +604,10 @@ public class PackageWatchdogTest {
                 PackageHealthObserverImpact.USER_IMPACT_LEVEL_30);
 
         // Start observing for observerFirst and observerSecond with failure handling
-        watchdog.registerHealthObserver(observerFirst, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observerFirst, Arrays.asList(APP_A), LONG_DURATION);
-        watchdog.registerHealthObserver(observerSecond, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observerSecond, Arrays.asList(APP_A), LONG_DURATION);
+        watchdog.registerHealthObserver(mTestExecutor, observerFirst);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A), LONG_DURATION, observerFirst);
+        watchdog.registerHealthObserver(mTestExecutor, observerSecond);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A), LONG_DURATION, observerSecond);
 
         // Then fail APP_A above the threshold
         raiseFatalFailureAndDispatch(watchdog,
@@ -673,10 +670,10 @@ public class PackageWatchdogTest {
                 PackageHealthObserverImpact.USER_IMPACT_LEVEL_30);
 
         // Start observing for observerFirst and observerSecond with failure handling
-        watchdog.registerHealthObserver(observerFirst, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observerFirst, Arrays.asList(APP_A), LONG_DURATION);
-        watchdog.registerHealthObserver(observerSecond, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observerSecond, Arrays.asList(APP_A), LONG_DURATION);
+        watchdog.registerHealthObserver(mTestExecutor, observerFirst);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A), LONG_DURATION, observerFirst);
+        watchdog.registerHealthObserver(mTestExecutor, observerSecond);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A), LONG_DURATION, observerSecond);
 
         // Then fail APP_A above the threshold
         raiseFatalFailureAndDispatch(watchdog,
@@ -743,10 +740,10 @@ public class PackageWatchdogTest {
                 PackageHealthObserverImpact.USER_IMPACT_LEVEL_100);
 
         // Start observing for observer1 and observer2 with failure handling
-        watchdog.registerHealthObserver(observer2, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observer2, Arrays.asList(APP_A), SHORT_DURATION);
-        watchdog.registerHealthObserver(observer1, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observer1, Arrays.asList(APP_A), SHORT_DURATION);
+        watchdog.registerHealthObserver(mTestExecutor, observer2);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A), SHORT_DURATION, observer2);
+        watchdog.registerHealthObserver(mTestExecutor, observer1);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A), SHORT_DURATION, observer1);
 
         // Then fail APP_A above the threshold
         raiseFatalFailureAndDispatch(watchdog,
@@ -767,10 +764,10 @@ public class PackageWatchdogTest {
                 PackageHealthObserverImpact.USER_IMPACT_LEVEL_50);
 
         // Start observing for observer1 and observer2 with failure handling
-        watchdog.registerHealthObserver(observer2, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observer2, Arrays.asList(APP_A), SHORT_DURATION);
-        watchdog.registerHealthObserver(observer1, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observer1, Arrays.asList(APP_A), SHORT_DURATION);
+        watchdog.registerHealthObserver(mTestExecutor, observer2);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A), SHORT_DURATION, observer2);
+        watchdog.registerHealthObserver(mTestExecutor, observer1);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A), SHORT_DURATION, observer1);
 
         // Then fail APP_A above the threshold
         raiseFatalFailureAndDispatch(watchdog,
@@ -800,10 +797,10 @@ public class PackageWatchdogTest {
         // Start observing with explicit health checks for APP_A and APP_B respectively
         // with observer1 and observer2
         controller.setSupportedPackages(Arrays.asList(APP_A, APP_B));
-        watchdog.registerHealthObserver(observer1, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observer1, Arrays.asList(APP_A), SHORT_DURATION);
-        watchdog.registerHealthObserver(observer2, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observer2, Arrays.asList(APP_B), SHORT_DURATION);
+        watchdog.registerHealthObserver(mTestExecutor, observer1);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A), SHORT_DURATION, observer1);
+        watchdog.registerHealthObserver(mTestExecutor, observer2);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_B), SHORT_DURATION, observer2);
 
         // Run handler so requests are dispatched to the controller
         mTestLooper.dispatchAll();
@@ -819,8 +816,8 @@ public class PackageWatchdogTest {
         // Observer3 didn't exist when we got the explicit health check above, so
         // it starts out with a non-passing explicit health check and has to wait for a pass
         // otherwise it would be notified of APP_A failure on expiry
-        watchdog.registerHealthObserver(observer3, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observer3, Arrays.asList(APP_A), SHORT_DURATION);
+        watchdog.registerHealthObserver(mTestExecutor, observer3);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A), SHORT_DURATION, observer3);
 
         // Then expire observers
         moveTimeForwardAndDispatch(SHORT_DURATION);
@@ -850,9 +847,9 @@ public class PackageWatchdogTest {
 
         // Start observing with explicit health checks for APP_A and APP_B
         controller.setSupportedPackages(Arrays.asList(APP_A, APP_B, APP_C));
-        watchdog.registerHealthObserver(observer, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observer, Arrays.asList(APP_A), SHORT_DURATION);
-        watchdog.startExplicitHealthCheck(observer, Arrays.asList(APP_B), LONG_DURATION);
+        watchdog.registerHealthObserver(mTestExecutor, observer);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A), SHORT_DURATION, observer);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_B), LONG_DURATION, observer);
 
         // Run handler so requests are dispatched to the controller
         mTestLooper.dispatchAll();
@@ -888,7 +885,7 @@ public class PackageWatchdogTest {
         // Then set new supported packages
         controller.setSupportedPackages(Arrays.asList(APP_C));
         // Start observing APP_A and APP_C; only APP_C has support for explicit health checks
-        watchdog.startExplicitHealthCheck(observer, Arrays.asList(APP_A, APP_C), SHORT_DURATION);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A, APP_C), SHORT_DURATION, observer);
 
         // Run handler so requests/cancellations are dispatched to the controller
         mTestLooper.dispatchAll();
@@ -919,8 +916,8 @@ public class PackageWatchdogTest {
         // package observation duration == LONG_DURATION
         // health check duration == SHORT_DURATION (set by default in the TestController)
         controller.setSupportedPackages(Arrays.asList(APP_A));
-        watchdog.registerHealthObserver(observer, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observer, Arrays.asList(APP_A), LONG_DURATION);
+        watchdog.registerHealthObserver(mTestExecutor, observer);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A), LONG_DURATION, observer);
 
         // Then APP_A has exceeded health check duration
         moveTimeForwardAndDispatch(SHORT_DURATION);
@@ -951,8 +948,8 @@ public class PackageWatchdogTest {
         // package observation duration == SHORT_DURATION / 2
         // health check duration == SHORT_DURATION (set by default in the TestController)
         controller.setSupportedPackages(Arrays.asList(APP_A));
-        watchdog.registerHealthObserver(observer, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observer, Arrays.asList(APP_A), SHORT_DURATION / 2);
+        watchdog.registerHealthObserver(mTestExecutor, observer);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A), SHORT_DURATION / 2, observer);
 
         // Forward time to expire the observation duration
         moveTimeForwardAndDispatch(SHORT_DURATION / 2);
@@ -1025,7 +1022,7 @@ public class PackageWatchdogTest {
         // Start observing with failure handling
         TestObserver observer = new TestObserver(OBSERVER_NAME_1,
                 PackageHealthObserverImpact.USER_IMPACT_LEVEL_100);
-        wd.startExplicitHealthCheck(observer, Collections.singletonList(APP_A), SHORT_DURATION);
+        wd.startExplicitHealthCheck(Collections.singletonList(APP_A), SHORT_DURATION, observer);
 
         // Notify of NetworkStack failure
         mConnectivityModuleCallbackCaptor.getValue().onNetworkStackFailure(APP_A);
@@ -1045,7 +1042,7 @@ public class PackageWatchdogTest {
         // Start observing with failure handling
         TestObserver observer = new TestObserver(OBSERVER_NAME_1,
                 PackageHealthObserverImpact.USER_IMPACT_LEVEL_100);
-        wd.startExplicitHealthCheck(observer, Collections.singletonList(APP_A), SHORT_DURATION);
+        wd.startExplicitHealthCheck(Collections.singletonList(APP_A), SHORT_DURATION, observer);
 
         // Notify of NetworkStack failure
         mConnectivityModuleCallbackCaptor.getValue().onNetworkStackFailure(APP_A);
@@ -1066,8 +1063,8 @@ public class PackageWatchdogTest {
         PackageWatchdog watchdog = createWatchdog();
         TestObserver observer = new TestObserver(OBSERVER_NAME_1);
 
-        watchdog.registerHealthObserver(observer, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observer, Arrays.asList(APP_A), SHORT_DURATION);
+        watchdog.registerHealthObserver(mTestExecutor, observer);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A), SHORT_DURATION, observer);
         // Fail APP_A below the threshold which should not trigger package failures
         for (int i = 0; i < PackageWatchdog.DEFAULT_TRIGGER_FAILURE_COUNT - 1; i++) {
             watchdog.notifyPackageFailure(Arrays.asList(new VersionedPackage(APP_A, VERSION_CODE)),
@@ -1095,8 +1092,8 @@ public class PackageWatchdogTest {
         PackageWatchdog watchdog = createWatchdog();
         TestObserver observer = new TestObserver(OBSERVER_NAME_1);
 
-        watchdog.registerHealthObserver(observer, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observer, Arrays.asList(APP_A, APP_B), Long.MAX_VALUE);
+        watchdog.registerHealthObserver(mTestExecutor, observer);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A, APP_B), Long.MAX_VALUE, observer);
         watchdog.notifyPackageFailure(Arrays.asList(new VersionedPackage(APP_A, VERSION_CODE)),
                 PackageWatchdog.FAILURE_REASON_UNKNOWN);
         moveTimeForwardAndDispatch(PackageWatchdog.DEFAULT_TRIGGER_FAILURE_DURATION_MS + 1);
@@ -1129,8 +1126,8 @@ public class PackageWatchdogTest {
         PackageWatchdog watchdog = createWatchdog();
         TestObserver observer = new TestObserver(OBSERVER_NAME_1);
 
-        watchdog.registerHealthObserver(observer, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observer, Arrays.asList(APP_A), -1);
+        watchdog.registerHealthObserver(mTestExecutor, observer);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A), -1, observer);
         // Note: Don't move too close to the expiration time otherwise the handler will be thrashed
         // by PackageWatchdog#scheduleNextSyncStateLocked which keeps posting runnables with very
         // small timeouts.
@@ -1152,8 +1149,8 @@ public class PackageWatchdogTest {
         PackageWatchdog watchdog = createWatchdog();
         TestObserver observer = new TestObserver(OBSERVER_NAME_1);
 
-        watchdog.registerHealthObserver(observer, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observer, Arrays.asList(APP_A), -1);
+        watchdog.registerHealthObserver(mTestExecutor, observer);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A), -1, observer);
         moveTimeForwardAndDispatch(PackageWatchdog.DEFAULT_OBSERVING_DURATION_MS + 1);
         raiseFatalFailureAndDispatch(watchdog,
                 Arrays.asList(new VersionedPackage(APP_A, VERSION_CODE)),
@@ -1175,8 +1172,8 @@ public class PackageWatchdogTest {
         PackageWatchdog watchdog = createWatchdog();
         TestObserver observer = new TestObserver(OBSERVER_NAME_1);
 
-        watchdog.registerHealthObserver(observer, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observer, Arrays.asList(APP_A), Long.MAX_VALUE);
+        watchdog.registerHealthObserver(mTestExecutor, observer);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A), Long.MAX_VALUE, observer);
         // Raise 2 failures at t=0 and t=900 respectively
         watchdog.notifyPackageFailure(Arrays.asList(new VersionedPackage(APP_A, VERSION_CODE)),
                 PackageWatchdog.FAILURE_REASON_UNKNOWN);
@@ -1203,10 +1200,10 @@ public class PackageWatchdogTest {
         TestObserver observer1 = new TestObserver(OBSERVER_NAME_1);
         TestObserver observer2 = new TestObserver(OBSERVER_NAME_2);
 
-        watchdog.registerHealthObserver(observer1, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observer1, Arrays.asList(APP_A), SHORT_DURATION);
-        watchdog.registerHealthObserver(observer2, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observer2, Arrays.asList(APP_B), SHORT_DURATION);
+        watchdog.registerHealthObserver(mTestExecutor, observer1);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A), SHORT_DURATION, observer1);
+        watchdog.registerHealthObserver(mTestExecutor, observer2);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_B), SHORT_DURATION, observer2);
 
         raiseFatalFailureAndDispatch(watchdog, Arrays.asList(new VersionedPackage(APP_A,
                 VERSION_CODE)), PackageWatchdog.FAILURE_REASON_APP_CRASH);
@@ -1225,8 +1222,8 @@ public class PackageWatchdogTest {
         PackageWatchdog watchdog = createWatchdog();
         TestObserver observer1 = new TestObserver(OBSERVER_NAME_1);
 
-        watchdog.registerHealthObserver(observer1, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observer1, Arrays.asList(APP_A), SHORT_DURATION);
+        watchdog.registerHealthObserver(mTestExecutor, observer1);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A), SHORT_DURATION, observer1);
 
         raiseFatalFailureAndDispatch(watchdog, Arrays.asList(new VersionedPackage(APP_A,
                 VERSION_CODE)), PackageWatchdog.FAILURE_REASON_NATIVE_CRASH);
@@ -1246,8 +1243,8 @@ public class PackageWatchdogTest {
         persistentObserver.setPersistent(true);
         persistentObserver.setMayObservePackages(true);
 
-        watchdog.registerHealthObserver(persistentObserver, mTestExecutor);
-        watchdog.startExplicitHealthCheck(persistentObserver, Arrays.asList(APP_B), SHORT_DURATION);
+        watchdog.registerHealthObserver(mTestExecutor, persistentObserver);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_B), SHORT_DURATION, persistentObserver);
 
         raiseFatalFailureAndDispatch(watchdog, Arrays.asList(new VersionedPackage(APP_A,
                 VERSION_CODE)), PackageWatchdog.FAILURE_REASON_UNKNOWN);
@@ -1265,8 +1262,8 @@ public class PackageWatchdogTest {
         persistentObserver.setPersistent(true);
         persistentObserver.setMayObservePackages(false);
 
-        watchdog.registerHealthObserver(persistentObserver, mTestExecutor);
-        watchdog.startExplicitHealthCheck(persistentObserver, Arrays.asList(APP_B), SHORT_DURATION);
+        watchdog.registerHealthObserver(mTestExecutor, persistentObserver);
+        watchdog.startExplicitHealthCheck(Arrays.asList(APP_B), SHORT_DURATION, persistentObserver);
 
         raiseFatalFailureAndDispatch(watchdog, Arrays.asList(new VersionedPackage(APP_A,
                 VERSION_CODE)), PackageWatchdog.FAILURE_REASON_UNKNOWN);
@@ -1277,11 +1274,10 @@ public class PackageWatchdogTest {
     /** Ensure that boot loop mitigation is done when the number of boots meets the threshold. */
     @Test
     public void testBootLoopDetection_meetsThreshold() {
-        Slog.w("hrm1243", "I should definitely be here try 1 ");
         mSetFlagsRule.disableFlags(Flags.FLAG_RECOVERABILITY_DETECTION);
         PackageWatchdog watchdog = createWatchdog();
         TestObserver bootObserver = new TestObserver(OBSERVER_NAME_1);
-        watchdog.registerHealthObserver(bootObserver, mTestExecutor);
+        watchdog.registerHealthObserver(mTestExecutor, bootObserver);
         for (int i = 0; i < PackageWatchdog.DEFAULT_BOOT_LOOP_TRIGGER_COUNT; i++) {
             watchdog.noteBoot();
         }
@@ -1293,7 +1289,7 @@ public class PackageWatchdogTest {
     public void testBootLoopDetection_meetsThresholdRecoverability() {
         PackageWatchdog watchdog = createWatchdog();
         TestObserver bootObserver = new TestObserver(OBSERVER_NAME_1);
-        watchdog.registerHealthObserver(bootObserver, mTestExecutor);
+        watchdog.registerHealthObserver(mTestExecutor, bootObserver);
         for (int i = 0; i < 15; i++) {
             watchdog.noteBoot();
         }
@@ -1309,7 +1305,7 @@ public class PackageWatchdogTest {
     public void testBootLoopDetection_doesNotMeetThreshold() {
         PackageWatchdog watchdog = createWatchdog();
         TestObserver bootObserver = new TestObserver(OBSERVER_NAME_1);
-        watchdog.registerHealthObserver(bootObserver, mTestExecutor);
+        watchdog.registerHealthObserver(mTestExecutor, bootObserver);
         for (int i = 0; i < PackageWatchdog.DEFAULT_BOOT_LOOP_TRIGGER_COUNT - 1; i++) {
             watchdog.noteBoot();
         }
@@ -1326,7 +1322,7 @@ public class PackageWatchdogTest {
         PackageWatchdog watchdog = createWatchdog();
         TestObserver bootObserver = new TestObserver(OBSERVER_NAME_1,
                 PackageHealthObserverImpact.USER_IMPACT_LEVEL_30);
-        watchdog.registerHealthObserver(bootObserver, mTestExecutor);
+        watchdog.registerHealthObserver(mTestExecutor, bootObserver);
         for (int i = 0; i < PackageWatchdog.DEFAULT_BOOT_LOOP_TRIGGER_COUNT - 1; i++) {
             watchdog.noteBoot();
         }
@@ -1345,8 +1341,8 @@ public class PackageWatchdogTest {
         bootObserver1.setImpact(PackageHealthObserverImpact.USER_IMPACT_LEVEL_10);
         TestObserver bootObserver2 = new TestObserver(OBSERVER_NAME_2);
         bootObserver2.setImpact(PackageHealthObserverImpact.USER_IMPACT_LEVEL_30);
-        watchdog.registerHealthObserver(bootObserver1, mTestExecutor);
-        watchdog.registerHealthObserver(bootObserver2, mTestExecutor);
+        watchdog.registerHealthObserver(mTestExecutor, bootObserver1);
+        watchdog.registerHealthObserver(mTestExecutor, bootObserver2);
         for (int i = 0; i < PackageWatchdog.DEFAULT_BOOT_LOOP_TRIGGER_COUNT; i++) {
             watchdog.noteBoot();
         }
@@ -1362,8 +1358,8 @@ public class PackageWatchdogTest {
         bootObserver1.setImpact(PackageHealthObserverImpact.USER_IMPACT_LEVEL_10);
         TestObserver bootObserver2 = new TestObserver(OBSERVER_NAME_2);
         bootObserver2.setImpact(PackageHealthObserverImpact.USER_IMPACT_LEVEL_30);
-        watchdog.registerHealthObserver(bootObserver1, mTestExecutor);
-        watchdog.registerHealthObserver(bootObserver2, mTestExecutor);
+        watchdog.registerHealthObserver(mTestExecutor, bootObserver1);
+        watchdog.registerHealthObserver(mTestExecutor, bootObserver2);
         for (int i = 0; i < 15; i++) {
             watchdog.noteBoot();
         }
@@ -1380,7 +1376,7 @@ public class PackageWatchdogTest {
         mSetFlagsRule.disableFlags(Flags.FLAG_RECOVERABILITY_DETECTION);
         PackageWatchdog watchdog = createWatchdog();
         TestObserver bootObserver = new TestObserver(OBSERVER_NAME_1);
-        watchdog.registerHealthObserver(bootObserver, mTestExecutor);
+        watchdog.registerHealthObserver(mTestExecutor, bootObserver);
         for (int i = 0; i < 4; i++) {
             for (int j = 0; j < PackageWatchdog.DEFAULT_BOOT_LOOP_TRIGGER_COUNT; j++) {
                 watchdog.noteBoot();
@@ -1403,7 +1399,7 @@ public class PackageWatchdogTest {
         PackageWatchdog watchdog = createWatchdog();
         TestObserver bootObserver = new TestObserver(OBSERVER_NAME_1,
                 PackageHealthObserverImpact.USER_IMPACT_LEVEL_30);
-        watchdog.registerHealthObserver(bootObserver, mTestExecutor);
+        watchdog.registerHealthObserver(mTestExecutor, bootObserver);
         for (int j = 0; j < PackageWatchdog.DEFAULT_BOOT_LOOP_TRIGGER_COUNT - 1; j++) {
             watchdog.noteBoot();
         }
@@ -1431,8 +1427,8 @@ public class PackageWatchdogTest {
     public void testNullFailedPackagesList() {
         PackageWatchdog watchdog = createWatchdog();
         TestObserver observer1 = new TestObserver(OBSERVER_NAME_1);
-        watchdog.registerHealthObserver(observer1, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observer1, List.of(APP_A), LONG_DURATION);
+        watchdog.registerHealthObserver(mTestExecutor, observer1);
+        watchdog.startExplicitHealthCheck(List.of(APP_A), LONG_DURATION, observer1);
 
         raiseFatalFailureAndDispatch(watchdog, null, PackageWatchdog.FAILURE_REASON_APP_CRASH);
         assertThat(observer1.mMitigatedPackages).isEmpty();
@@ -1450,18 +1446,18 @@ public class PackageWatchdogTest {
         PackageWatchdog watchdog = createWatchdog(testController, true);
 
         TestObserver testObserver1 = new TestObserver(OBSERVER_NAME_1);
-        watchdog.registerHealthObserver(testObserver1, mTestExecutor);
-        watchdog.startExplicitHealthCheck(testObserver1, List.of(APP_A), LONG_DURATION);
+        watchdog.registerHealthObserver(mTestExecutor, testObserver1);
+        watchdog.startExplicitHealthCheck(List.of(APP_A), LONG_DURATION, testObserver1);
         mTestLooper.dispatchAll();
 
         TestObserver testObserver2 = new TestObserver(OBSERVER_NAME_2);
-        watchdog.registerHealthObserver(testObserver2, mTestExecutor);
-        watchdog.startExplicitHealthCheck(testObserver2, List.of(APP_B), LONG_DURATION);
+        watchdog.registerHealthObserver(mTestExecutor, testObserver2);
+        watchdog.startExplicitHealthCheck(List.of(APP_B), LONG_DURATION, testObserver2);
         mTestLooper.dispatchAll();
 
         TestObserver testObserver3 = new TestObserver(OBSERVER_NAME_3);
-        watchdog.registerHealthObserver(testObserver3, mTestExecutor);
-        watchdog.startExplicitHealthCheck(testObserver3, List.of(APP_C), LONG_DURATION);
+        watchdog.registerHealthObserver(mTestExecutor, testObserver3);
+        watchdog.startExplicitHealthCheck(List.of(APP_C), LONG_DURATION, testObserver3);
         mTestLooper.dispatchAll();
 
         watchdog.unregisterHealthObserver(testObserver1);
@@ -1493,15 +1489,15 @@ public class PackageWatchdogTest {
     public void testFailureHistoryIsPreserved() {
         PackageWatchdog watchdog = createWatchdog();
         TestObserver observer = new TestObserver(OBSERVER_NAME_1);
-        watchdog.registerHealthObserver(observer, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observer, List.of(APP_A), SHORT_DURATION);
+        watchdog.registerHealthObserver(mTestExecutor, observer);
+        watchdog.startExplicitHealthCheck(List.of(APP_A), SHORT_DURATION, observer);
         for (int i = 0; i < PackageWatchdog.DEFAULT_TRIGGER_FAILURE_COUNT - 1; i++) {
             watchdog.notifyPackageFailure(List.of(new VersionedPackage(APP_A, VERSION_CODE)),
                     PackageWatchdog.FAILURE_REASON_UNKNOWN);
         }
         mTestLooper.dispatchAll();
         assertThat(observer.mMitigatedPackages).isEmpty();
-        watchdog.startExplicitHealthCheck(observer, List.of(APP_A), LONG_DURATION);
+        watchdog.startExplicitHealthCheck(List.of(APP_A), LONG_DURATION, observer);
         watchdog.notifyPackageFailure(List.of(new VersionedPackage(APP_A, VERSION_CODE)),
                 PackageWatchdog.FAILURE_REASON_UNKNOWN);
         mTestLooper.dispatchAll();
@@ -1516,9 +1512,9 @@ public class PackageWatchdogTest {
     public void testMitigationSlidingWindow() {
         PackageWatchdog watchdog = createWatchdog();
         TestObserver observer = new TestObserver(OBSERVER_NAME_1);
-        watchdog.registerHealthObserver(observer, mTestExecutor);
-        watchdog.startExplicitHealthCheck(observer, List.of(APP_A),
-                PackageWatchdog.DEFAULT_OBSERVING_DURATION_MS * 2);
+        watchdog.registerHealthObserver(mTestExecutor, observer);
+        watchdog.startExplicitHealthCheck(List.of(APP_A),
+                PackageWatchdog.DEFAULT_OBSERVING_DURATION_MS * 2, observer);
 
 
         raiseFatalFailureAndDispatch(watchdog, Arrays.asList(new VersionedPackage(APP_A,