From 6b407ebfc4c5281cb662c618fd51db5b084accad Mon Sep 17 00:00:00 2001 From: Sam Dubey Date: Mon, 3 Apr 2023 14:20:10 +0000 Subject: [PATCH] Revert "Use "frozen" state for broadcasts." This reverts commit 4b5ce4920c5a05241fcb458e96b42a6399f7e5bc. Reason for revert: b/276537038 (Testing for cuttlefish specific boot failures seen in CI) Change-Id: Ie08340f8b8b5f285047b463fcf0430b628a5069b --- .../server/am/ActivityManagerService.java | 2 - .../android/server/am/BroadcastConstants.java | 16 ++--- .../server/am/BroadcastProcessQueue.java | 43 +++++++------ .../server/am/BroadcastQueueModernImpl.java | 61 +++++-------------- .../am/BroadcastQueueModernImplTest.java | 46 +++++++------- .../android/server/am/BroadcastQueueTest.java | 41 +++++-------- 6 files changed, 83 insertions(+), 126 deletions(-) diff --git a/services/core/java/com/android/server/am/ActivityManagerService.java b/services/core/java/com/android/server/am/ActivityManagerService.java index 6749140da74c2..1a9d97ec85d94 100644 --- a/services/core/java/com/android/server/am/ActivityManagerService.java +++ b/services/core/java/com/android/server/am/ActivityManagerService.java @@ -18769,7 +18769,6 @@ public class ActivityManagerService extends IActivityManager.Stub // too quickly in parallel below pingCount.incrementAndGet(); - synchronized (this) { synchronized (mProcLock) { final ArrayMap> pmap = mProcessList.getProcessNamesLOSP().getMap(); @@ -18794,7 +18793,6 @@ public class ActivityManagerService extends IActivityManager.Stub } } } - } // Now that we've dispatched all "ping" events above, we can send our // "pong" sentinel value diff --git a/services/core/java/com/android/server/am/BroadcastConstants.java b/services/core/java/com/android/server/am/BroadcastConstants.java index 094b0408f0b12..4d469639be6fa 100644 --- a/services/core/java/com/android/server/am/BroadcastConstants.java +++ b/services/core/java/com/android/server/am/BroadcastConstants.java @@ -203,11 +203,11 @@ public class BroadcastConstants { /** * For {@link BroadcastQueueModernImpl}: Delay to apply to broadcasts - * targeting frozen applications. + * targeting cached applications. */ - public long DELAY_FROZEN_MILLIS = DEFAULT_DELAY_FROZEN_MILLIS; - private static final String KEY_DELAY_FROZEN_MILLIS = "bcast_delay_frozen_millis"; - private static final long DEFAULT_DELAY_FROZEN_MILLIS = +120_000; + public long DELAY_CACHED_MILLIS = DEFAULT_DELAY_CACHED_MILLIS; + private static final String KEY_DELAY_CACHED_MILLIS = "bcast_delay_cached_millis"; + private static final long DEFAULT_DELAY_CACHED_MILLIS = +120_000; /** * For {@link BroadcastQueueModernImpl}: Delay to apply to urgent @@ -373,8 +373,8 @@ public class BroadcastConstants { DEFAULT_MAX_PENDING_BROADCASTS); DELAY_NORMAL_MILLIS = getDeviceConfigLong(KEY_DELAY_NORMAL_MILLIS, DEFAULT_DELAY_NORMAL_MILLIS); - DELAY_FROZEN_MILLIS = getDeviceConfigLong(KEY_DELAY_FROZEN_MILLIS, - DEFAULT_DELAY_FROZEN_MILLIS); + DELAY_CACHED_MILLIS = getDeviceConfigLong(KEY_DELAY_CACHED_MILLIS, + DEFAULT_DELAY_CACHED_MILLIS); DELAY_URGENT_MILLIS = getDeviceConfigLong(KEY_DELAY_URGENT_MILLIS, DEFAULT_DELAY_URGENT_MILLIS); MAX_HISTORY_COMPLETE_SIZE = getDeviceConfigInt(KEY_MAX_HISTORY_COMPLETE_SIZE, @@ -421,8 +421,8 @@ public class BroadcastConstants { pw.print(KEY_MAX_PENDING_BROADCASTS, MAX_PENDING_BROADCASTS).println(); pw.print(KEY_DELAY_NORMAL_MILLIS, TimeUtils.formatDuration(DELAY_NORMAL_MILLIS)).println(); - pw.print(KEY_DELAY_FROZEN_MILLIS, - TimeUtils.formatDuration(DELAY_FROZEN_MILLIS)).println(); + pw.print(KEY_DELAY_CACHED_MILLIS, + TimeUtils.formatDuration(DELAY_CACHED_MILLIS)).println(); pw.print(KEY_DELAY_URGENT_MILLIS, TimeUtils.formatDuration(DELAY_URGENT_MILLIS)).println(); pw.print(KEY_MAX_HISTORY_COMPLETE_SIZE, MAX_HISTORY_COMPLETE_SIZE).println(); diff --git a/services/core/java/com/android/server/am/BroadcastProcessQueue.java b/services/core/java/com/android/server/am/BroadcastProcessQueue.java index 5140f9056e119..056e17a5ef3c5 100644 --- a/services/core/java/com/android/server/am/BroadcastProcessQueue.java +++ b/services/core/java/com/android/server/am/BroadcastProcessQueue.java @@ -188,7 +188,7 @@ class BroadcastProcessQueue { private @Reason int mRunnableAtReason = REASON_EMPTY; private boolean mRunnableAtInvalidated; - private boolean mUidFrozen; + private boolean mProcessCached; private boolean mProcessInstrumented; private boolean mProcessPersistent; @@ -385,9 +385,11 @@ class BroadcastProcessQueue { public void setProcess(@Nullable ProcessRecord app) { this.app = app; if (app != null) { + setProcessCached(app.isCached()); setProcessInstrumented(app.getActiveInstrumentation() != null); setProcessPersistent(app.isPersistent()); } else { + setProcessCached(false); setProcessInstrumented(false); setProcessPersistent(false); } @@ -398,12 +400,13 @@ class BroadcastProcessQueue { } /** - * Update if this UID is in the "frozen" state, typically signaling that + * Update if this process is in the "cached" state, typically signaling that * broadcast dispatch should be paused or delayed. */ - public void setUidFrozen(boolean frozen) { - if (mUidFrozen != frozen) { - mUidFrozen = frozen; + @VisibleForTesting + void setProcessCached(boolean cached) { + if (mProcessCached != cached) { + mProcessCached = cached; invalidateRunnableAt(); } } @@ -810,7 +813,7 @@ class BroadcastProcessQueue { public boolean isDeferredUntilActive() { if (mRunnableAtInvalidated) updateRunnableAt(); - return mRunnableAtReason == BroadcastProcessQueue.REASON_INFINITE_DEFER; + return mRunnableAtReason == BroadcastProcessQueue.REASON_CACHED_INFINITE_DEFER; } public boolean hasDeferredBroadcasts() { @@ -845,14 +848,14 @@ class BroadcastProcessQueue { } static final int REASON_EMPTY = 0; - static final int REASON_FROZEN = 1; + static final int REASON_CACHED = 1; static final int REASON_NORMAL = 2; static final int REASON_MAX_PENDING = 3; static final int REASON_BLOCKED = 4; static final int REASON_INSTRUMENTED = 5; static final int REASON_PERSISTENT = 6; static final int REASON_FORCE_DELAYED = 7; - static final int REASON_INFINITE_DEFER = 8; + static final int REASON_CACHED_INFINITE_DEFER = 8; static final int REASON_CONTAINS_FOREGROUND = 10; static final int REASON_CONTAINS_ORDERED = 11; static final int REASON_CONTAINS_ALARM = 12; @@ -864,14 +867,14 @@ class BroadcastProcessQueue { @IntDef(flag = false, prefix = { "REASON_" }, value = { REASON_EMPTY, - REASON_FROZEN, + REASON_CACHED, REASON_NORMAL, REASON_MAX_PENDING, REASON_BLOCKED, REASON_INSTRUMENTED, REASON_PERSISTENT, REASON_FORCE_DELAYED, - REASON_INFINITE_DEFER, + REASON_CACHED_INFINITE_DEFER, REASON_CONTAINS_FOREGROUND, REASON_CONTAINS_ORDERED, REASON_CONTAINS_ALARM, @@ -887,14 +890,14 @@ class BroadcastProcessQueue { static @NonNull String reasonToString(@Reason int reason) { switch (reason) { case REASON_EMPTY: return "EMPTY"; - case REASON_FROZEN: return "FROZEN"; + case REASON_CACHED: return "CACHED"; case REASON_NORMAL: return "NORMAL"; case REASON_MAX_PENDING: return "MAX_PENDING"; case REASON_BLOCKED: return "BLOCKED"; case REASON_INSTRUMENTED: return "INSTRUMENTED"; case REASON_PERSISTENT: return "PERSISTENT"; case REASON_FORCE_DELAYED: return "FORCE_DELAYED"; - case REASON_INFINITE_DEFER: return "INFINITE_DEFER"; + case REASON_CACHED_INFINITE_DEFER: return "INFINITE_DEFER"; case REASON_CONTAINS_FOREGROUND: return "CONTAINS_FOREGROUND"; case REASON_CONTAINS_ORDERED: return "CONTAINS_ORDERED"; case REASON_CONTAINS_ALARM: return "CONTAINS_ALARM"; @@ -975,12 +978,12 @@ class BroadcastProcessQueue { } else if (mProcessPersistent) { mRunnableAt = runnableAt; mRunnableAtReason = REASON_PERSISTENT; - } else if (mUidFrozen) { + } else if (mProcessCached) { if (r.deferUntilActive) { // All enqueued broadcasts are deferrable, defer if (mCountDeferred == mCountEnqueued) { mRunnableAt = Long.MAX_VALUE; - mRunnableAtReason = REASON_INFINITE_DEFER; + mRunnableAtReason = REASON_CACHED_INFINITE_DEFER; } else { // At least one enqueued broadcast isn't deferrable, repick time and reason // for this record. If a later record is not deferrable and is one of these @@ -995,14 +998,14 @@ class BroadcastProcessQueue { mRunnableAt = runnableAt; mRunnableAtReason = REASON_CONTAINS_RESULT_TO; } else { - mRunnableAt = runnableAt + constants.DELAY_FROZEN_MILLIS; - mRunnableAtReason = REASON_FROZEN; + mRunnableAt = runnableAt + constants.DELAY_CACHED_MILLIS; + mRunnableAtReason = REASON_CACHED; } } } else { // This record isn't deferrable - mRunnableAt = runnableAt + constants.DELAY_FROZEN_MILLIS; - mRunnableAtReason = REASON_FROZEN; + mRunnableAt = runnableAt + constants.DELAY_CACHED_MILLIS; + mRunnableAtReason = REASON_CACHED; } } else if (mCountResultTo > 0) { // All resultTo broadcasts are infinitely deferrable, so if the app @@ -1184,8 +1187,8 @@ class BroadcastProcessQueue { @NeverCompile private void dumpProcessState(@NonNull IndentingPrintWriter pw) { final StringBuilder sb = new StringBuilder(); - if (mUidFrozen) { - sb.append("FROZEN"); + if (mProcessCached) { + sb.append("CACHED"); } if (mProcessInstrumented) { if (sb.length() > 0) sb.append("|"); diff --git a/services/core/java/com/android/server/am/BroadcastQueueModernImpl.java b/services/core/java/com/android/server/am/BroadcastQueueModernImpl.java index e574b490f3fd0..5010ec03285fe 100644 --- a/services/core/java/com/android/server/am/BroadcastQueueModernImpl.java +++ b/services/core/java/com/android/server/am/BroadcastQueueModernImpl.java @@ -16,7 +16,6 @@ package com.android.server.am; -import static android.app.ActivityManager.UidFrozenStateChangedCallback.UID_FROZEN_STATE_FROZEN; import static android.os.Process.ZYGOTE_POLICY_FLAG_EMPTY; import static android.os.Process.ZYGOTE_POLICY_FLAG_LATENCY_SENSITIVE; @@ -48,7 +47,7 @@ import android.app.ActivityManager; import android.app.ApplicationExitInfo; import android.app.BroadcastOptions; import android.app.IApplicationThread; -import android.app.IUidFrozenStateChangedCallback; +import android.app.UidObserver; import android.app.usage.UsageEvents.Event; import android.content.ComponentName; import android.content.ContentResolver; @@ -72,7 +71,6 @@ import android.util.MathUtils; import android.util.Pair; import android.util.Slog; import android.util.SparseArray; -import android.util.SparseBooleanArray; import android.util.TimeUtils; import android.util.proto.ProtoOutputStream; @@ -210,16 +208,6 @@ class BroadcastQueueModernImpl extends BroadcastQueue { private final AtomicReference> mReplacedBroadcastsCache = new AtomicReference<>(); - /** - * Map from UID to its last known "frozen" state. - *

- * We manually maintain this data structure since the lifecycle of - * {@link ProcessRecord} and {@link BroadcastProcessQueue} can be - * mismatched. - */ - @GuardedBy("mService") - private final SparseBooleanArray mUidFrozen = new SparseBooleanArray(); - private final BroadcastConstants mConstants; private final BroadcastConstants mFgConstants; private final BroadcastConstants mBgConstants; @@ -497,7 +485,6 @@ class BroadcastQueueModernImpl extends BroadcastQueue { final BroadcastProcessQueue queue = getProcessQueue(app); if (queue != null) { queue.setProcess(app); - queue.setUidFrozen(mUidFrozen.get(queue.uid, false)); } boolean didSomething = false; @@ -539,7 +526,6 @@ class BroadcastQueueModernImpl extends BroadcastQueue { final BroadcastProcessQueue queue = getProcessQueue(app); if (queue != null) { queue.setProcess(null); - queue.setUidFrozen(mUidFrozen.get(queue.uid, false)); } if ((mRunningColdStart != null) && (mRunningColdStart == queue)) { @@ -1339,34 +1325,23 @@ class BroadcastQueueModernImpl extends BroadcastQueue { mFgConstants.startObserving(mHandler, resolver); mBgConstants.startObserving(mHandler, resolver); - mService.registerUidFrozenStateChangedCallback(new IUidFrozenStateChangedCallback.Stub() { + mService.registerUidObserver(new UidObserver() { @Override - public void onUidFrozenStateChanged(int[] uids, int[] frozenStates) { + public void onUidCachedChanged(int uid, boolean cached) { synchronized (mService) { - for (int i = 0; i < uids.length; i++) { - final int uid = uids[i]; - final boolean frozen = frozenStates[i] == UID_FROZEN_STATE_FROZEN; - if (frozen) { - mUidFrozen.put(uid, true); - } else { - mUidFrozen.delete(uid); - } - - BroadcastProcessQueue leaf = mProcessQueues.get(uid); - while (leaf != null) { - // Update internal state by refreshing values previously - // read from any known running process - leaf.setProcess(leaf.app); - leaf.setUidFrozen(frozen); - updateQueueDeferred(leaf); - updateRunnableList(leaf); - leaf = leaf.processNameNext; - } - enqueueUpdateRunningList(); + BroadcastProcessQueue leaf = mProcessQueues.get(uid); + while (leaf != null) { + // Update internal state by refreshing values previously + // read from any known running process + leaf.setProcess(leaf.app); + updateQueueDeferred(leaf); + updateRunnableList(leaf); + leaf = leaf.processNameNext; } + enqueueUpdateRunningList(); } } - }); + }, ActivityManager.UID_OBSERVER_CACHED, 0, "android"); // Kick off periodic health checks mLocalHandler.sendEmptyMessage(MSG_CHECK_HEALTH); @@ -1521,7 +1496,6 @@ class BroadcastQueueModernImpl extends BroadcastQueue { private void updateWarmProcess(@NonNull BroadcastProcessQueue queue) { if (!queue.isProcessWarm()) { queue.setProcess(mService.getProcessRecordLocked(queue.processName, queue.uid)); - queue.setUidFrozen(mUidFrozen.get(queue.uid, false)); } } @@ -1716,7 +1690,6 @@ class BroadcastQueueModernImpl extends BroadcastQueue { BroadcastProcessQueue created = new BroadcastProcessQueue(mConstants, processName, uid); created.setProcess(mService.getProcessRecordLocked(processName, uid)); - created.setUidFrozen(mUidFrozen.get(uid, false)); if (leaf == null) { mProcessQueues.put(uid, created); @@ -1839,18 +1812,12 @@ class BroadcastQueueModernImpl extends BroadcastQueue { ipw.decreaseIndent(); ipw.println(); - ipw.println("Broadcasts with ignored delivery group policies:"); + ipw.println(" Broadcasts with ignored delivery group policies:"); ipw.increaseIndent(); mService.dumpDeliveryGroupPolicyIgnoredActions(ipw); ipw.decreaseIndent(); ipw.println(); - ipw.println("Frozen UIDs:"); - ipw.increaseIndent(); - ipw.println(mUidFrozen.toString()); - ipw.decreaseIndent(); - ipw.println(); - if (dumpConstants) { mConstants.dump(ipw); } diff --git a/services/tests/mockingservicestests/src/com/android/server/am/BroadcastQueueModernImplTest.java b/services/tests/mockingservicestests/src/com/android/server/am/BroadcastQueueModernImplTest.java index c68db4f673372..36d191b466bac 100644 --- a/services/tests/mockingservicestests/src/com/android/server/am/BroadcastQueueModernImplTest.java +++ b/services/tests/mockingservicestests/src/com/android/server/am/BroadcastQueueModernImplTest.java @@ -129,7 +129,7 @@ public final class BroadcastQueueModernImplTest { mConstants = new BroadcastConstants(Settings.Global.BROADCAST_FG_CONSTANTS); mConstants.DELAY_URGENT_MILLIS = -120_000; mConstants.DELAY_NORMAL_MILLIS = 10_000; - mConstants.DELAY_FROZEN_MILLIS = 120_000; + mConstants.DELAY_CACHED_MILLIS = 120_000; final BroadcastSkipPolicy emptySkipPolicy = new BroadcastSkipPolicy(mAms) { public boolean shouldSkip(BroadcastRecord r, Object o) { @@ -371,13 +371,13 @@ public final class BroadcastQueueModernImplTest { List.of(makeMockRegisteredReceiver()), false); queue.enqueueOrReplaceBroadcast(airplaneRecord, 0, false); - queue.setUidFrozen(false); + queue.setProcessCached(false); final long notCachedRunnableAt = queue.getRunnableAt(); - queue.setUidFrozen(true); + queue.setProcessCached(true); final long cachedRunnableAt = queue.getRunnableAt(); assertThat(cachedRunnableAt).isGreaterThan(notCachedRunnableAt); assertFalse(queue.isRunnable()); - assertEquals(BroadcastProcessQueue.REASON_INFINITE_DEFER, + assertEquals(BroadcastProcessQueue.REASON_CACHED_INFINITE_DEFER, queue.getRunnableAtReason()); assertEquals(ProcessList.SCHED_GROUP_UNDEFINED, queue.getPreferredSchedulingGroupLocked()); } @@ -398,13 +398,13 @@ public final class BroadcastQueueModernImplTest { List.of(makeMockRegisteredReceiver()), false); queue.enqueueOrReplaceBroadcast(airplaneRecord, 0, false); - queue.setUidFrozen(false); + queue.setProcessCached(false); final long notCachedRunnableAt = queue.getRunnableAt(); - queue.setUidFrozen(true); + queue.setProcessCached(true); final long cachedRunnableAt = queue.getRunnableAt(); assertThat(cachedRunnableAt).isGreaterThan(notCachedRunnableAt); assertTrue(queue.isRunnable()); - assertEquals(BroadcastProcessQueue.REASON_FROZEN, queue.getRunnableAtReason()); + assertEquals(BroadcastProcessQueue.REASON_CACHED, queue.getRunnableAtReason()); assertEquals(ProcessList.SCHED_GROUP_BACKGROUND, queue.getPreferredSchedulingGroupLocked()); } @@ -430,13 +430,13 @@ public final class BroadcastQueueModernImplTest { // verify that: // (a) the queue is immediately runnable by existence of a fg-priority broadcast // (b) the next one up is the fg-priority broadcast despite its later enqueue time - queue.setUidFrozen(false); + queue.setProcessCached(false); assertTrue(queue.isRunnable()); assertThat(queue.getRunnableAt()).isAtMost(airplaneRecord.enqueueClockTime); assertEquals(ProcessList.SCHED_GROUP_DEFAULT, queue.getPreferredSchedulingGroupLocked()); assertEquals(queue.peekNextBroadcastRecord(), airplaneRecord); - queue.setUidFrozen(true); + queue.setProcessCached(true); assertTrue(queue.isRunnable()); assertThat(queue.getRunnableAt()).isAtMost(airplaneRecord.enqueueClockTime); assertEquals(ProcessList.SCHED_GROUP_DEFAULT, queue.getPreferredSchedulingGroupLocked()); @@ -496,10 +496,10 @@ public final class BroadcastQueueModernImplTest { * Verify that a cached process that would normally be delayed becomes * immediately runnable when the given broadcast is enqueued. */ - private void doRunnableAt_Frozen(BroadcastRecord testRecord, int testRunnableAtReason) { + private void doRunnableAt_Cached(BroadcastRecord testRecord, int testRunnableAtReason) { final BroadcastProcessQueue queue = new BroadcastProcessQueue(mConstants, PACKAGE_GREEN, getUidForPackage(PACKAGE_GREEN)); - queue.setUidFrozen(true); + queue.setProcessCached(true); final BroadcastRecord lazyRecord = makeBroadcastRecord( new Intent(Intent.ACTION_AIRPLANE_MODE_CHANGED), @@ -515,49 +515,49 @@ public final class BroadcastQueueModernImplTest { } @Test - public void testRunnableAt_Frozen_Manifest() { - doRunnableAt_Frozen(makeBroadcastRecord(makeMockIntent(), null, + public void testRunnableAt_Cached_Manifest() { + doRunnableAt_Cached(makeBroadcastRecord(makeMockIntent(), null, List.of(makeMockManifestReceiver()), null, false), REASON_CONTAINS_MANIFEST); } @Test - public void testRunnableAt_Frozen_Ordered() { - doRunnableAt_Frozen(makeBroadcastRecord(makeMockIntent(), null, + public void testRunnableAt_Cached_Ordered() { + doRunnableAt_Cached(makeBroadcastRecord(makeMockIntent(), null, List.of(makeMockRegisteredReceiver()), null, true), REASON_CONTAINS_ORDERED); } @Test - public void testRunnableAt_Frozen_Foreground() { + public void testRunnableAt_Cached_Foreground() { final Intent foregroundIntent = new Intent(); foregroundIntent.addFlags(Intent.FLAG_RECEIVER_FOREGROUND); - doRunnableAt_Frozen(makeBroadcastRecord(foregroundIntent, null, + doRunnableAt_Cached(makeBroadcastRecord(foregroundIntent, null, List.of(makeMockRegisteredReceiver()), null, false), REASON_CONTAINS_FOREGROUND); } @Test - public void testRunnableAt_Frozen_Interactive() { + public void testRunnableAt_Cached_Interactive() { final BroadcastOptions options = BroadcastOptions.makeBasic(); options.setInteractive(true); - doRunnableAt_Frozen(makeBroadcastRecord(makeMockIntent(), options, + doRunnableAt_Cached(makeBroadcastRecord(makeMockIntent(), options, List.of(makeMockRegisteredReceiver()), null, false), REASON_CONTAINS_INTERACTIVE); } @Test - public void testRunnableAt_Frozen_Alarm() { + public void testRunnableAt_Cached_Alarm() { final BroadcastOptions options = BroadcastOptions.makeBasic(); options.setAlarmBroadcast(true); - doRunnableAt_Frozen(makeBroadcastRecord(makeMockIntent(), options, + doRunnableAt_Cached(makeBroadcastRecord(makeMockIntent(), options, List.of(makeMockRegisteredReceiver()), null, false), REASON_CONTAINS_ALARM); } @Test - public void testRunnableAt_Frozen_Prioritized_NonDeferrable() { + public void testRunnableAt_Cached_Prioritized_NonDeferrable() { final List receivers = List.of( withPriority(makeManifestReceiver(PACKAGE_RED, PACKAGE_RED), 10), withPriority(makeManifestReceiver(PACKAGE_GREEN, PACKAGE_GREEN), -10)); final BroadcastOptions options = BroadcastOptions.makeBasic() .setDeferralPolicy(BroadcastOptions.DEFERRAL_POLICY_NONE); - doRunnableAt_Frozen(makeBroadcastRecord(makeMockIntent(), options, + doRunnableAt_Cached(makeBroadcastRecord(makeMockIntent(), options, receivers, null, false), REASON_CONTAINS_PRIORITIZED); } diff --git a/services/tests/mockingservicestests/src/com/android/server/am/BroadcastQueueTest.java b/services/tests/mockingservicestests/src/com/android/server/am/BroadcastQueueTest.java index 17a0b6f17bcb1..bca39ae648239 100644 --- a/services/tests/mockingservicestests/src/com/android/server/am/BroadcastQueueTest.java +++ b/services/tests/mockingservicestests/src/com/android/server/am/BroadcastQueueTest.java @@ -16,8 +16,6 @@ package com.android.server.am; -import static android.app.ActivityManager.UidFrozenStateChangedCallback.UID_FROZEN_STATE_FROZEN; -import static android.app.ActivityManager.UidFrozenStateChangedCallback.UID_FROZEN_STATE_UNFROZEN; import static android.os.UserHandle.USER_SYSTEM; import static com.android.server.am.BroadcastProcessQueue.reasonToString; @@ -55,7 +53,7 @@ import android.app.AppOpsManager; import android.app.BackgroundStartPrivileges; import android.app.BroadcastOptions; import android.app.IApplicationThread; -import android.app.IUidFrozenStateChangedCallback; +import android.app.UidObserver; import android.app.usage.UsageEvents.Event; import android.app.usage.UsageStatsManagerInternal; import android.content.ComponentName; @@ -164,7 +162,7 @@ public class BroadcastQueueTest { private BroadcastQueue mQueue; BroadcastConstants mConstants; private BroadcastSkipPolicy mSkipPolicy; - private IUidFrozenStateChangedCallback mUidFrozenStateChangedCallback; + private UidObserver mUidObserver; /** * Desired behavior of the next @@ -291,9 +289,9 @@ public class BroadcastQueueTest { doNothing().when(mAms).appNotResponding(any(), any()); doAnswer((invocation) -> { - mUidFrozenStateChangedCallback = invocation.getArgument(0); + mUidObserver = invocation.getArgument(0); return null; - }).when(mAms).registerUidFrozenStateChangedCallback(any()); + }).when(mAms).registerUidObserver(any(), anyInt(), anyInt(), any()); mConstants = new BroadcastConstants(Settings.Global.BROADCAST_FG_CONSTANTS); mConstants.TIMEOUT = 100; @@ -401,18 +399,6 @@ public class BroadcastQueueTest { DEAD, } - private void freezeUid(int uid) throws Exception { - mUidFrozenStateChangedCallback.onUidFrozenStateChanged( - new int[] { uid }, - new int[] { UID_FROZEN_STATE_FROZEN }); - } - - private void thawUid(int uid) throws Exception { - mUidFrozenStateChangedCallback.onUidFrozenStateChanged( - new int[] { uid }, - new int[] { UID_FROZEN_STATE_UNFROZEN }); - } - private ProcessRecord makeActiveProcessRecord(String packageName) throws Exception { return makeActiveProcessRecord(packageName, packageName, ProcessBehavior.NORMAL, UserHandle.USER_SYSTEM); @@ -1675,8 +1661,8 @@ public class BroadcastQueueTest { final ProcessRecord receiverYellowApp = makeActiveProcessRecord(PACKAGE_YELLOW); final ProcessRecord receiverOrangeApp = makeActiveProcessRecord(PACKAGE_ORANGE); - freezeUid(getUidForPackage(PACKAGE_GREEN)); - freezeUid(getUidForPackage(PACKAGE_BLUE)); + receiverGreenApp.setCached(true); + receiverBlueApp.setCached(true); final Intent timeTick = new Intent(Intent.ACTION_TIME_TICK); final BroadcastOptions opts = BroadcastOptions.makeBasic() @@ -1720,12 +1706,14 @@ public class BroadcastQueueTest { eq(UserHandle.USER_SYSTEM), anyInt(), anyInt(), any()); // Shift blue to be active and confirm that deferred broadcast is delivered - thawUid(getUidForPackage(PACKAGE_BLUE)); + receiverBlueApp.setCached(false); + mUidObserver.onUidCachedChanged(getUidForPackage(PACKAGE_BLUE), false); waitForIdle(); verifyScheduleRegisteredReceiver(times(1), receiverBlueApp, timeTick); // Shift green to be active and confirm that deferred broadcast is delivered - thawUid(getUidForPackage(PACKAGE_GREEN)); + receiverGreenApp.setCached(false); + mUidObserver.onUidCachedChanged(getUidForPackage(PACKAGE_GREEN), false); waitForIdle(); verifyScheduleRegisteredReceiver(times(1), receiverGreenApp, timeTick); } @@ -2058,9 +2046,9 @@ public class BroadcastQueueTest { final ProcessRecord receiverBlueApp = makeActiveProcessRecord(PACKAGE_BLUE); final ProcessRecord receiverYellowApp = makeActiveProcessRecord(PACKAGE_YELLOW); - freezeUid(getUidForPackage(PACKAGE_GREEN)); - freezeUid(getUidForPackage(PACKAGE_BLUE)); - thawUid(getUidForPackage(PACKAGE_YELLOW)); + receiverGreenApp.setCached(true); + receiverBlueApp.setCached(true); + receiverYellowApp.setCached(false); final Intent airplane = new Intent(Intent.ACTION_AIRPLANE_MODE_CHANGED); final BroadcastOptions opts = BroadcastOptions.makeBasic() @@ -2083,7 +2071,8 @@ public class BroadcastQueueTest { verifyScheduleRegisteredReceiver(times(1), receiverYellowApp, airplane); // Shift green to be active and confirm that deferred broadcast is delivered - thawUid(getUidForPackage(PACKAGE_GREEN)); + receiverGreenApp.setCached(false); + mUidObserver.onUidCachedChanged(getUidForPackage(PACKAGE_GREEN), false); waitForIdle(); verifyScheduleRegisteredReceiver(times(1), receiverGreenApp, airplane); }