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

Add a level to commit all available rollbacks

Browse Source 
There have been a few issues (like b/244419269) which led to devices
performing factory reset step, but could have been prevented
if we committed all available rollbacks. Thus adding the step to rollback all available rollbacks as preventive step to reduce the cases where device goes into Factory Reset mode.
Also adding few more impact levels in Package Watchdog to granularly control the execution of various levels by package health observers.

Test: atest RollbackPackageHealthObserver
Bug: b/264997660

Change-Id: Ifbee3a67fe69aa9c54080e498f9afa891b6be8dc
Merged-In: Ifbee3a67fe69aa9c54080e498f9afa891b6be8dc
This commit is contained in:
Harshit Mahajan
2023-02-28 15:39:38 +00:00
parent 93b5d6a3a5
commit bb4675df3f
6 changed files with 181 additions and 75 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
services/core/java/com/android/server/PackageWatchdog.java
View File

@@ -426,7 +426,7 @@ public class PackageWatchdog {
}
int impact = registeredObserver.onHealthCheckFailed(
versionedPackage, failureReason, mitigationCount);
if (impact != PackageHealthObserverImpact.USER_IMPACT_NONE
if (impact != PackageHealthObserverImpact.USER_IMPACT_LEVEL_0
&& impact < currentObserverImpact) {
currentObserverToNotify = registeredObserver;
currentObserverImpact = impact;
@@ -466,7 +466,7 @@ public class PackageWatchdog {
if (registeredObserver != null) {
int impact = registeredObserver.onHealthCheckFailed(
failingPackage, failureReason, 1);
if (impact != PackageHealthObserverImpact.USER_IMPACT_NONE
if (impact != PackageHealthObserverImpact.USER_IMPACT_LEVEL_0
&& impact < currentObserverImpact) {
currentObserverToNotify = registeredObserver;
currentObserverImpact = impact;
@@ -494,7 +494,7 @@ public class PackageWatchdog {
PackageHealthObserver registeredObserver = observer.registeredObserver;
if (registeredObserver != null) {
int impact = registeredObserver.onBootLoop(mitigationCount);
if (impact != PackageHealthObserverImpact.USER_IMPACT_NONE
if (impact != PackageHealthObserverImpact.USER_IMPACT_LEVEL_0
&& impact < currentObserverImpact) {
currentObserverToNotify = registeredObserver;
currentObserverImpact = impact;
@@ -576,19 +576,23 @@ public class PackageWatchdog {
/** Possible severity values of the user impact of a {@link PackageHealthObserver#execute}. */
@Retention(SOURCE)
@IntDef(value = {PackageHealthObserverImpact.USER_IMPACT_NONE,
PackageHealthObserverImpact.USER_IMPACT_LOW,
PackageHealthObserverImpact.USER_IMPACT_MEDIUM,
PackageHealthObserverImpact.USER_IMPACT_HIGH})
@IntDef(value = {PackageHealthObserverImpact.USER_IMPACT_LEVEL_0,
PackageHealthObserverImpact.USER_IMPACT_LEVEL_10,
PackageHealthObserverImpact.USER_IMPACT_LEVEL_30,
PackageHealthObserverImpact.USER_IMPACT_LEVEL_50,
PackageHealthObserverImpact.USER_IMPACT_LEVEL_70,
PackageHealthObserverImpact.USER_IMPACT_LEVEL_100})
public @interface PackageHealthObserverImpact {
/** No action to take. */
int USER_IMPACT_NONE = 0;
int USER_IMPACT_LEVEL_0 = 0;
/* Action has low user impact, user of a device will barely notice. */
int USER_IMPACT_LOW = 1;
/* Action has medium user impact, user of a device will likely notice. */
int USER_IMPACT_MEDIUM = 3;
int USER_IMPACT_LEVEL_10 = 10;
/* Actions having medium user impact, user of a device will likely notice. */
int USER_IMPACT_LEVEL_30 = 30;
int USER_IMPACT_LEVEL_50 = 50;
int USER_IMPACT_LEVEL_70 = 70;
/* Action has high user impact, a last resort, user of a device will be very frustrated. */
int USER_IMPACT_HIGH = 5;
int USER_IMPACT_LEVEL_100 = 100;
}
/** Register instances of this interface to receive notifications on package failure. */
@@ -633,7 +637,7 @@ public class PackageWatchdog {
* boot loop (including this time).
*/
default @PackageHealthObserverImpact int onBootLoop(int mitigationCount) {
return PackageHealthObserverImpact.USER_IMPACT_NONE;
return PackageHealthObserverImpact.USER_IMPACT_LEVEL_0;
}
/**

11
services/core/java/com/android/server/RescueParty.java
View File

@@ -489,13 +489,14 @@ public class RescueParty {
switch(rescueLevel) {
case LEVEL_RESET_SETTINGS_UNTRUSTED_DEFAULTS:
case LEVEL_RESET_SETTINGS_UNTRUSTED_CHANGES:
return PackageHealthObserverImpact.USER_IMPACT_LOW;
return PackageHealthObserverImpact.USER_IMPACT_LEVEL_10;
case LEVEL_RESET_SETTINGS_TRUSTED_DEFAULTS:
case LEVEL_WARM_REBOOT:
return PackageHealthObserverImpact.USER_IMPACT_LEVEL_50;
case LEVEL_FACTORY_RESET:
return PackageHealthObserverImpact.USER_IMPACT_HIGH;
return PackageHealthObserverImpact.USER_IMPACT_LEVEL_100;
default:
return PackageHealthObserverImpact.USER_IMPACT_NONE;
return PackageHealthObserverImpact.USER_IMPACT_LEVEL_0;
}
}
@@ -633,7 +634,7 @@ public class RescueParty {
return mapRescueLevelToUserImpact(getRescueLevel(mitigationCount,
mayPerformReboot(failedPackage)));
} else {
return PackageHealthObserverImpact.USER_IMPACT_NONE;
return PackageHealthObserverImpact.USER_IMPACT_LEVEL_0;
}
}
@@ -677,7 +678,7 @@ public class RescueParty {
@Override
public int onBootLoop(int mitigationCount) {
if (isDisabled()) {
return PackageHealthObserverImpact.USER_IMPACT_NONE;
return PackageHealthObserverImpact.USER_IMPACT_LEVEL_0;
}
return mapRescueLevelToUserImpact(getRescueLevel(mitigationCount, true));
}

44
services/core/java/com/android/server/rollback/RollbackPackageHealthObserver.java
View File

@@ -105,36 +105,46 @@ final class RollbackPackageHealthObserver implements PackageHealthObserver {
@Override
public int onHealthCheckFailed(@Nullable VersionedPackage failedPackage,
@FailureReasons int failureReason, int mitigationCount) {
// For native crashes, we will roll back any available rollbacks
boolean anyRollbackAvailable = !mContext.getSystemService(RollbackManager.class)
.getAvailableRollbacks().isEmpty();
int impact = PackageHealthObserverImpact.USER_IMPACT_LEVEL_0;
if (failureReason == PackageWatchdog.FAILURE_REASON_NATIVE_CRASH
&& !mContext.getSystemService(RollbackManager.class)
.getAvailableRollbacks().isEmpty()) {
return PackageHealthObserverImpact.USER_IMPACT_MEDIUM;
}
if (getAvailableRollback(failedPackage) == null) {
// Don't handle the notification, no rollbacks available for the package
return PackageHealthObserverImpact.USER_IMPACT_NONE;
} else {
&& anyRollbackAvailable) {
// For native crashes, we will directly roll back any available rollbacks
// Note: For non-native crashes the rollback-all step has higher impact
impact = PackageHealthObserverImpact.USER_IMPACT_LEVEL_30;
} else if (mitigationCount == 1 && getAvailableRollback(failedPackage) != null) {
// Rollback is available, we may get a callback into #execute
return PackageHealthObserverImpact.USER_IMPACT_MEDIUM;
impact = PackageHealthObserverImpact.USER_IMPACT_LEVEL_30;
} else if (mitigationCount > 1 && anyRollbackAvailable) {
// If any rollbacks are available, we will commit them
impact = PackageHealthObserverImpact.USER_IMPACT_LEVEL_70;
}
return impact;
}
@Override
public boolean execute(@Nullable VersionedPackage failedPackage,
@FailureReasons int rollbackReason, int mitigationCount) {
if (rollbackReason == PackageWatchdog.FAILURE_REASON_NATIVE_CRASH) {
mHandler.post(() -> rollbackAll());
mHandler.post(this::rollbackAll);
return true;
}
RollbackInfo rollback = getAvailableRollback(failedPackage);
if (rollback == null) {
Slog.w(TAG, "Expected rollback but no valid rollback found for " + failedPackage);
return false;
if (mitigationCount == 1) {
RollbackInfo rollback = getAvailableRollback(failedPackage);
if (rollback == null) {
Slog.w(TAG, "Expected rollback but no valid rollback found for " + failedPackage);
return false;
}
mHandler.post(() -> rollbackPackage(rollback, failedPackage, rollbackReason));
} else if (mitigationCount > 1) {
mHandler.post(this::rollbackAll);
}
mHandler.post(() -> rollbackPackage(rollback, failedPackage, rollbackReason));
// Assume rollback executed successfully
// Assume rollbacks executed successfully
return true;
}

22
services/tests/mockingservicestests/src/com/android/server/RescuePartyTest.java
View File

@@ -567,36 +567,36 @@ public class RescuePartyTest {
// Ensure that no action is taken for cases where the failure reason is unknown
assertEquals(observer.onHealthCheckFailed(null, PackageWatchdog.FAILURE_REASON_UNKNOWN, 1),
PackageHealthObserverImpact.USER_IMPACT_NONE);
PackageHealthObserverImpact.USER_IMPACT_LEVEL_0);
// Ensure the correct user impact is returned for each mitigation count.
assertEquals(observer.onHealthCheckFailed(null,
PackageWatchdog.FAILURE_REASON_APP_NOT_RESPONDING, 1),
PackageHealthObserverImpact.USER_IMPACT_LOW);
PackageHealthObserverImpact.USER_IMPACT_LEVEL_10);
assertEquals(observer.onHealthCheckFailed(null,
PackageWatchdog.FAILURE_REASON_APP_NOT_RESPONDING, 2),
PackageHealthObserverImpact.USER_IMPACT_LOW);
PackageHealthObserverImpact.USER_IMPACT_LEVEL_10);
assertEquals(observer.onHealthCheckFailed(null,
PackageWatchdog.FAILURE_REASON_APP_NOT_RESPONDING, 3),
PackageHealthObserverImpact.USER_IMPACT_HIGH);
PackageHealthObserverImpact.USER_IMPACT_LEVEL_50);
assertEquals(observer.onHealthCheckFailed(null,
PackageWatchdog.FAILURE_REASON_APP_NOT_RESPONDING, 4),
PackageHealthObserverImpact.USER_IMPACT_HIGH);
PackageHealthObserverImpact.USER_IMPACT_LEVEL_50);
}
@Test
public void testBootLoopLevels() {
RescuePartyObserver observer = RescuePartyObserver.getInstance(mMockContext);
assertEquals(observer.onBootLoop(0), PackageHealthObserverImpact.USER_IMPACT_NONE);
assertEquals(observer.onBootLoop(1), PackageHealthObserverImpact.USER_IMPACT_LOW);
assertEquals(observer.onBootLoop(2), PackageHealthObserverImpact.USER_IMPACT_LOW);
assertEquals(observer.onBootLoop(3), PackageHealthObserverImpact.USER_IMPACT_HIGH);
assertEquals(observer.onBootLoop(4), PackageHealthObserverImpact.USER_IMPACT_HIGH);
assertEquals(observer.onBootLoop(5), PackageHealthObserverImpact.USER_IMPACT_HIGH);
assertEquals(observer.onBootLoop(0), PackageHealthObserverImpact.USER_IMPACT_LEVEL_0);
assertEquals(observer.onBootLoop(1), PackageHealthObserverImpact.USER_IMPACT_LEVEL_10);
assertEquals(observer.onBootLoop(2), PackageHealthObserverImpact.USER_IMPACT_LEVEL_10);
assertEquals(observer.onBootLoop(3), PackageHealthObserverImpact.USER_IMPACT_LEVEL_50);
assertEquals(observer.onBootLoop(4), PackageHealthObserverImpact.USER_IMPACT_LEVEL_50);
assertEquals(observer.onBootLoop(5), PackageHealthObserverImpact.USER_IMPACT_LEVEL_100);
}
@Test

103
services/tests/servicestests/src/com/android/server/rollback/RollbackPackageHealthObserverTest.java → services/tests/mockingservicestests/src/com/android/server/rollback/RollbackPackageHealthObserverTest.java
View File

@@ -16,31 +16,65 @@
package com.android.server.rollback;
import static com.android.dx.mockito.inline.extended.ExtendedMockito.doAnswer;
import static com.google.common.truth.Truth.assertThat;
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.when;
import android.content.Context;
import android.content.pm.VersionedPackage;
import android.content.rollback.PackageRollbackInfo;
import android.content.rollback.RollbackInfo;
import android.content.rollback.RollbackManager;
import android.util.Log;
import android.util.Xml;
import androidx.test.runner.AndroidJUnit4;
import com.android.dx.mockito.inline.extended.ExtendedMockito;
import com.android.server.PackageWatchdog;
import com.android.server.SystemConfig;
import org.junit.After;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.junit.runner.RunWith;
import org.mockito.Answers;
import org.mockito.Mock;
import org.mockito.MockitoSession;
import org.mockito.quality.Strictness;
import org.mockito.stubbing.Answer;
import org.xmlpull.v1.XmlPullParser;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.List;
import java.util.Scanner;
@RunWith(AndroidJUnit4.class)
public class RollbackPackageHealthObserverTest {
@Mock
private Context mMockContext;
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private PackageWatchdog mMockPackageWatchdog;
@Mock
RollbackManager mRollbackManager;
@Mock
RollbackInfo mRollbackInfo;
@Mock
PackageRollbackInfo mPackageRollbackInfo;
private MockitoSession mSession;
private static final String APP_A = "com.package.a";
private static final long VERSION_CODE = 1L;
private static final String LOG_TAG = "RollbackPackageHealthObserverTest";
private SystemConfig mSysConfig;
@@ -50,17 +84,74 @@ public class RollbackPackageHealthObserverTest {
@Before
public void setup() {
mSysConfig = new SystemConfigTestClass();
mSession = ExtendedMockito.mockitoSession()
.initMocks(this)
.strictness(Strictness.LENIENT)
.spyStatic(PackageWatchdog.class)
.startMocking();
// Mock PackageWatchdog
doAnswer((Answer<PackageWatchdog>) invocationOnMock -> mMockPackageWatchdog)
.when(() -> PackageWatchdog.getInstance(mMockContext));
}
@After
public void tearDown() throws Exception {
mSession.finishMocking();
}
/**
* Subclass of SystemConfig without running the constructor.
*/
* Subclass of SystemConfig without running the constructor.
*/
private class SystemConfigTestClass extends SystemConfig {
SystemConfigTestClass() {
super(false);
super(false);
}
}
@Test
public void testHealthCheckLevels() {
RollbackPackageHealthObserver observer =
spy(new RollbackPackageHealthObserver(mMockContext));
VersionedPackage testFailedPackage = new VersionedPackage(APP_A, VERSION_CODE);
when(mMockContext.getSystemService(RollbackManager.class)).thenReturn(mRollbackManager);
// Crashes with no rollbacks available
assertEquals(PackageWatchdog.PackageHealthObserverImpact.USER_IMPACT_LEVEL_0,
observer.onHealthCheckFailed(null,
PackageWatchdog.FAILURE_REASON_NATIVE_CRASH, 1));
assertEquals(PackageWatchdog.PackageHealthObserverImpact.USER_IMPACT_LEVEL_0,
observer.onHealthCheckFailed(null,
PackageWatchdog.FAILURE_REASON_APP_CRASH, 1));
// Make the rollbacks available
when(mRollbackManager.getAvailableRollbacks()).thenReturn(List.of(mRollbackInfo));
when(mRollbackInfo.getPackages()).thenReturn(List.of(mPackageRollbackInfo));
when(mPackageRollbackInfo.getVersionRolledBackFrom()).thenReturn(testFailedPackage);
// native crash
assertEquals(PackageWatchdog.PackageHealthObserverImpact.USER_IMPACT_LEVEL_30,
observer.onHealthCheckFailed(null,
PackageWatchdog.FAILURE_REASON_NATIVE_CRASH, 1));
// non-native crash
assertEquals(PackageWatchdog.PackageHealthObserverImpact.USER_IMPACT_LEVEL_30,
observer.onHealthCheckFailed(testFailedPackage,
PackageWatchdog.FAILURE_REASON_APP_CRASH, 1));
// Second non-native crash again
assertEquals(PackageWatchdog.PackageHealthObserverImpact.USER_IMPACT_LEVEL_70,
observer.onHealthCheckFailed(testFailedPackage,
PackageWatchdog.FAILURE_REASON_APP_CRASH, 2));
// Subsequent crashes when rollbacks have completed
when(mRollbackManager.getAvailableRollbacks()).thenReturn(List.of());
assertEquals(PackageWatchdog.PackageHealthObserverImpact.USER_IMPACT_LEVEL_0,
observer.onHealthCheckFailed(testFailedPackage,
PackageWatchdog.FAILURE_REASON_APP_CRASH, 3));
}
/**
* Test that isAutomaticRollbackDenied works correctly when packages that are not
* denied are sent.
@@ -77,7 +168,7 @@ public class RollbackPackageHealthObserverTest {
readPermissions(folder, /* Grant all permission flags */ ~0);
assertThat(RollbackPackageHealthObserver.isAutomaticRollbackDenied(mSysConfig,
new VersionedPackage("com.test.package", 1))).isEqualTo(false);
new VersionedPackage("com.test.package", 1))).isEqualTo(false);
}
/**
@@ -96,7 +187,7 @@ public class RollbackPackageHealthObserverTest {
readPermissions(folder, /* Grant all permission flags */ ~0);
assertThat(RollbackPackageHealthObserver.isAutomaticRollbackDenied(mSysConfig,
new VersionedPackage("com.android.vending", 1))).isEqualTo(true);
new VersionedPackage("com.android.vending", 1))).isEqualTo(true);
}
/**
@@ -109,7 +200,7 @@ public class RollbackPackageHealthObserverTest {
readPermissions(folder, /* Grant all permission flags */ ~0);
assertThat(RollbackPackageHealthObserver.isAutomaticRollbackDenied(mSysConfig,
new VersionedPackage("com.android.vending", 1))).isEqualTo(false);
new VersionedPackage("com.android.vending", 1))).isEqualTo(false);
}
/**

46
tests/PackageWatchdog/src/com/android/server/PackageWatchdogTest.java
View File

@@ -417,9 +417,9 @@ public class PackageWatchdogTest {
int failureReason, int mitigationCount) {
if (versionedPackage.getVersionCode() == VERSION_CODE) {
// Only rollback for specific versionCode
return PackageHealthObserverImpact.USER_IMPACT_MEDIUM;
return PackageHealthObserverImpact.USER_IMPACT_LEVEL_30;
}
return PackageHealthObserverImpact.USER_IMPACT_NONE;
return PackageHealthObserverImpact.USER_IMPACT_LEVEL_0;
}
};
@@ -442,13 +442,13 @@ public class PackageWatchdogTest {
public void testPackageFailureNotifyAllDifferentImpacts() throws Exception {
PackageWatchdog watchdog = createWatchdog();
TestObserver observerNone = new TestObserver(OBSERVER_NAME_1,
PackageHealthObserverImpact.USER_IMPACT_NONE);
PackageHealthObserverImpact.USER_IMPACT_LEVEL_0);
TestObserver observerHigh = new TestObserver(OBSERVER_NAME_2,
PackageHealthObserverImpact.USER_IMPACT_HIGH);
PackageHealthObserverImpact.USER_IMPACT_LEVEL_100);
TestObserver observerMid = new TestObserver(OBSERVER_NAME_3,
PackageHealthObserverImpact.USER_IMPACT_MEDIUM);
PackageHealthObserverImpact.USER_IMPACT_LEVEL_30);
TestObserver observerLow = new TestObserver(OBSERVER_NAME_4,
PackageHealthObserverImpact.USER_IMPACT_LOW);
PackageHealthObserverImpact.USER_IMPACT_LEVEL_10);
// Start observing for all impact observers
watchdog.startObservingHealth(observerNone, Arrays.asList(APP_A, APP_B, APP_C, APP_D),
@@ -499,9 +499,9 @@ public class PackageWatchdogTest {
public void testPackageFailureNotifyLeastImpactSuccessively() throws Exception {
PackageWatchdog watchdog = createWatchdog();
TestObserver observerFirst = new TestObserver(OBSERVER_NAME_1,
PackageHealthObserverImpact.USER_IMPACT_LOW);
PackageHealthObserverImpact.USER_IMPACT_LEVEL_10);
TestObserver observerSecond = new TestObserver(OBSERVER_NAME_2,
PackageHealthObserverImpact.USER_IMPACT_MEDIUM);
PackageHealthObserverImpact.USER_IMPACT_LEVEL_30);
// Start observing for observerFirst and observerSecond with failure handling
watchdog.startObservingHealth(observerFirst, Arrays.asList(APP_A), LONG_DURATION);
@@ -517,7 +517,7 @@ public class PackageWatchdogTest {
assertThat(observerSecond.mMitigatedPackages).isEmpty();
// After observerFirst handles failure, next action it has is high impact
observerFirst.mImpact = PackageHealthObserverImpact.USER_IMPACT_HIGH;
observerFirst.mImpact = PackageHealthObserverImpact.USER_IMPACT_LEVEL_100;
observerFirst.mMitigatedPackages.clear();
observerSecond.mMitigatedPackages.clear();
@@ -531,7 +531,7 @@ public class PackageWatchdogTest {
assertThat(observerFirst.mMitigatedPackages).isEmpty();
// After observerSecond handles failure, it has no further actions
observerSecond.mImpact = PackageHealthObserverImpact.USER_IMPACT_NONE;
observerSecond.mImpact = PackageHealthObserverImpact.USER_IMPACT_LEVEL_0;
observerFirst.mMitigatedPackages.clear();
observerSecond.mMitigatedPackages.clear();
@@ -545,7 +545,7 @@ public class PackageWatchdogTest {
assertThat(observerSecond.mMitigatedPackages).isEmpty();
// After observerFirst handles failure, it too has no further actions
observerFirst.mImpact = PackageHealthObserverImpact.USER_IMPACT_NONE;
observerFirst.mImpact = PackageHealthObserverImpact.USER_IMPACT_LEVEL_0;
observerFirst.mMitigatedPackages.clear();
observerSecond.mMitigatedPackages.clear();
@@ -566,9 +566,9 @@ public class PackageWatchdogTest {
public void testPackageFailureNotifyOneSameImpact() throws Exception {
PackageWatchdog watchdog = createWatchdog();
TestObserver observer1 = new TestObserver(OBSERVER_NAME_1,
PackageHealthObserverImpact.USER_IMPACT_HIGH);
PackageHealthObserverImpact.USER_IMPACT_LEVEL_100);
TestObserver observer2 = new TestObserver(OBSERVER_NAME_2,
PackageHealthObserverImpact.USER_IMPACT_HIGH);
PackageHealthObserverImpact.USER_IMPACT_LEVEL_100);
// Start observing for observer1 and observer2 with failure handling
watchdog.startObservingHealth(observer2, Arrays.asList(APP_A), SHORT_DURATION);
@@ -592,11 +592,11 @@ public class PackageWatchdogTest {
TestController controller = new TestController();
PackageWatchdog watchdog = createWatchdog(controller, true /* withPackagesReady */);
TestObserver observer1 = new TestObserver(OBSERVER_NAME_1,
PackageHealthObserverImpact.USER_IMPACT_HIGH);
PackageHealthObserverImpact.USER_IMPACT_LEVEL_100);
TestObserver observer2 = new TestObserver(OBSERVER_NAME_2,
PackageHealthObserverImpact.USER_IMPACT_HIGH);
PackageHealthObserverImpact.USER_IMPACT_LEVEL_100);
TestObserver observer3 = new TestObserver(OBSERVER_NAME_3,
PackageHealthObserverImpact.USER_IMPACT_HIGH);
PackageHealthObserverImpact.USER_IMPACT_LEVEL_100);
// Start observing with explicit health checks for APP_A and APP_B respectively
@@ -645,7 +645,7 @@ public class PackageWatchdogTest {
TestController controller = new TestController();
PackageWatchdog watchdog = createWatchdog(controller, true /* withPackagesReady */);
TestObserver observer = new TestObserver(OBSERVER_NAME_1,
PackageHealthObserverImpact.USER_IMPACT_MEDIUM);
PackageHealthObserverImpact.USER_IMPACT_LEVEL_30);
// Start observing with explicit health checks for APP_A and APP_B
controller.setSupportedPackages(Arrays.asList(APP_A, APP_B, APP_C));
@@ -711,7 +711,7 @@ public class PackageWatchdogTest {
TestController controller = new TestController();
PackageWatchdog watchdog = createWatchdog(controller, true /* withPackagesReady */);
TestObserver observer = new TestObserver(OBSERVER_NAME_1,
PackageHealthObserverImpact.USER_IMPACT_MEDIUM);
PackageHealthObserverImpact.USER_IMPACT_LEVEL_30);
// Start observing with explicit health checks for APP_A and
// package observation duration == LONG_DURATION
@@ -742,7 +742,7 @@ public class PackageWatchdogTest {
TestController controller = new TestController();
PackageWatchdog watchdog = createWatchdog(controller, true /* withPackagesReady */);
TestObserver observer = new TestObserver(OBSERVER_NAME_1,
PackageHealthObserverImpact.USER_IMPACT_MEDIUM);
PackageHealthObserverImpact.USER_IMPACT_LEVEL_30);
// Start observing with explicit health checks for APP_A and
// package observation duration == SHORT_DURATION / 2
@@ -818,7 +818,7 @@ public class PackageWatchdogTest {
// Start observing with failure handling
TestObserver observer = new TestObserver(OBSERVER_NAME_1,
PackageHealthObserverImpact.USER_IMPACT_HIGH);
PackageHealthObserverImpact.USER_IMPACT_LEVEL_100);
wd.startObservingHealth(observer, Collections.singletonList(APP_A), SHORT_DURATION);
// Notify of NetworkStack failure
@@ -1073,9 +1073,9 @@ public class PackageWatchdogTest {
public void testBootLoopMitigationDoneForLowestUserImpact() {
PackageWatchdog watchdog = createWatchdog();
TestObserver bootObserver1 = new TestObserver(OBSERVER_NAME_1);
bootObserver1.setImpact(PackageHealthObserverImpact.USER_IMPACT_LOW);
bootObserver1.setImpact(PackageHealthObserverImpact.USER_IMPACT_LEVEL_10);
TestObserver bootObserver2 = new TestObserver(OBSERVER_NAME_2);
bootObserver2.setImpact(PackageHealthObserverImpact.USER_IMPACT_MEDIUM);
bootObserver2.setImpact(PackageHealthObserverImpact.USER_IMPACT_LEVEL_30);
watchdog.registerHealthObserver(bootObserver1);
watchdog.registerHealthObserver(bootObserver2);
for (int i = 0; i < PackageWatchdog.DEFAULT_BOOT_LOOP_TRIGGER_COUNT; i++) {
@@ -1446,7 +1446,7 @@ public class PackageWatchdogTest {
TestObserver(String name) {
mName = name;
mImpact = PackageHealthObserverImpact.USER_IMPACT_MEDIUM;
mImpact = PackageHealthObserverImpact.USER_IMPACT_LEVEL_30;
}
TestObserver(String name, int impact) {