diff options
6 files changed, 126 insertions, 83 deletions
diff --git a/services/core/java/com/android/server/am/ActivityManagerService.java b/services/core/java/com/android/server/am/ActivityManagerService.java index 1a9d97ec85d9..6749140da74c 100644 --- a/services/core/java/com/android/server/am/ActivityManagerService.java +++ b/services/core/java/com/android/server/am/ActivityManagerService.java @@ -18769,6 +18769,7 @@ public class ActivityManagerService extends IActivityManager.Stub // too quickly in parallel below pingCount.incrementAndGet(); + synchronized (this) { synchronized (mProcLock) { final ArrayMap<String, SparseArray<ProcessRecord>> pmap = mProcessList.getProcessNamesLOSP().getMap(); @@ -18793,6 +18794,7 @@ 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 4d469639be6f..094b0408f0b1 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 cached applications. + * targeting frozen applications. */ - 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; + 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; /** * 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_CACHED_MILLIS = getDeviceConfigLong(KEY_DELAY_CACHED_MILLIS, - DEFAULT_DELAY_CACHED_MILLIS); + DELAY_FROZEN_MILLIS = getDeviceConfigLong(KEY_DELAY_FROZEN_MILLIS, + DEFAULT_DELAY_FROZEN_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_CACHED_MILLIS, - TimeUtils.formatDuration(DELAY_CACHED_MILLIS)).println(); + pw.print(KEY_DELAY_FROZEN_MILLIS, + TimeUtils.formatDuration(DELAY_FROZEN_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 056e17a5ef3c..5140f9056e11 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 mProcessCached; + private boolean mUidFrozen; private boolean mProcessInstrumented; private boolean mProcessPersistent; @@ -385,11 +385,9 @@ 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); } @@ -400,13 +398,12 @@ class BroadcastProcessQueue { } /** - * Update if this process is in the "cached" state, typically signaling that + * Update if this UID is in the "frozen" state, typically signaling that * broadcast dispatch should be paused or delayed. */ - @VisibleForTesting - void setProcessCached(boolean cached) { - if (mProcessCached != cached) { - mProcessCached = cached; + public void setUidFrozen(boolean frozen) { + if (mUidFrozen != frozen) { + mUidFrozen = frozen; invalidateRunnableAt(); } } @@ -813,7 +810,7 @@ class BroadcastProcessQueue { public boolean isDeferredUntilActive() { if (mRunnableAtInvalidated) updateRunnableAt(); - return mRunnableAtReason == BroadcastProcessQueue.REASON_CACHED_INFINITE_DEFER; + return mRunnableAtReason == BroadcastProcessQueue.REASON_INFINITE_DEFER; } public boolean hasDeferredBroadcasts() { @@ -848,14 +845,14 @@ class BroadcastProcessQueue { } static final int REASON_EMPTY = 0; - static final int REASON_CACHED = 1; + static final int REASON_FROZEN = 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_CACHED_INFINITE_DEFER = 8; + static final int REASON_INFINITE_DEFER = 8; static final int REASON_CONTAINS_FOREGROUND = 10; static final int REASON_CONTAINS_ORDERED = 11; static final int REASON_CONTAINS_ALARM = 12; @@ -867,14 +864,14 @@ class BroadcastProcessQueue { @IntDef(flag = false, prefix = { "REASON_" }, value = { REASON_EMPTY, - REASON_CACHED, + REASON_FROZEN, REASON_NORMAL, REASON_MAX_PENDING, REASON_BLOCKED, REASON_INSTRUMENTED, REASON_PERSISTENT, REASON_FORCE_DELAYED, - REASON_CACHED_INFINITE_DEFER, + REASON_INFINITE_DEFER, REASON_CONTAINS_FOREGROUND, REASON_CONTAINS_ORDERED, REASON_CONTAINS_ALARM, @@ -890,14 +887,14 @@ class BroadcastProcessQueue { static @NonNull String reasonToString(@Reason int reason) { switch (reason) { case REASON_EMPTY: return "EMPTY"; - case REASON_CACHED: return "CACHED"; + case REASON_FROZEN: return "FROZEN"; 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_CACHED_INFINITE_DEFER: return "INFINITE_DEFER"; + case REASON_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"; @@ -978,12 +975,12 @@ class BroadcastProcessQueue { } else if (mProcessPersistent) { mRunnableAt = runnableAt; mRunnableAtReason = REASON_PERSISTENT; - } else if (mProcessCached) { + } else if (mUidFrozen) { if (r.deferUntilActive) { // All enqueued broadcasts are deferrable, defer if (mCountDeferred == mCountEnqueued) { mRunnableAt = Long.MAX_VALUE; - mRunnableAtReason = REASON_CACHED_INFINITE_DEFER; + mRunnableAtReason = REASON_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 @@ -998,14 +995,14 @@ class BroadcastProcessQueue { mRunnableAt = runnableAt; mRunnableAtReason = REASON_CONTAINS_RESULT_TO; } else { - mRunnableAt = runnableAt + constants.DELAY_CACHED_MILLIS; - mRunnableAtReason = REASON_CACHED; + mRunnableAt = runnableAt + constants.DELAY_FROZEN_MILLIS; + mRunnableAtReason = REASON_FROZEN; } } } else { // This record isn't deferrable - mRunnableAt = runnableAt + constants.DELAY_CACHED_MILLIS; - mRunnableAtReason = REASON_CACHED; + mRunnableAt = runnableAt + constants.DELAY_FROZEN_MILLIS; + mRunnableAtReason = REASON_FROZEN; } } else if (mCountResultTo > 0) { // All resultTo broadcasts are infinitely deferrable, so if the app @@ -1187,8 +1184,8 @@ class BroadcastProcessQueue { @NeverCompile private void dumpProcessState(@NonNull IndentingPrintWriter pw) { final StringBuilder sb = new StringBuilder(); - if (mProcessCached) { - sb.append("CACHED"); + if (mUidFrozen) { + sb.append("FROZEN"); } 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 5010ec03285f..e574b490f3fd 100644 --- a/services/core/java/com/android/server/am/BroadcastQueueModernImpl.java +++ b/services/core/java/com/android/server/am/BroadcastQueueModernImpl.java @@ -16,6 +16,7 @@ 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; @@ -47,7 +48,7 @@ import android.app.ActivityManager; import android.app.ApplicationExitInfo; import android.app.BroadcastOptions; import android.app.IApplicationThread; -import android.app.UidObserver; +import android.app.IUidFrozenStateChangedCallback; import android.app.usage.UsageEvents.Event; import android.content.ComponentName; import android.content.ContentResolver; @@ -71,6 +72,7 @@ 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; @@ -208,6 +210,16 @@ class BroadcastQueueModernImpl extends BroadcastQueue { private final AtomicReference<ArraySet<BroadcastRecord>> mReplacedBroadcastsCache = new AtomicReference<>(); + /** + * Map from UID to its last known "frozen" state. + * <p> + * 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; @@ -485,6 +497,7 @@ 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; @@ -526,6 +539,7 @@ 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)) { @@ -1325,23 +1339,34 @@ class BroadcastQueueModernImpl extends BroadcastQueue { mFgConstants.startObserving(mHandler, resolver); mBgConstants.startObserving(mHandler, resolver); - mService.registerUidObserver(new UidObserver() { + mService.registerUidFrozenStateChangedCallback(new IUidFrozenStateChangedCallback.Stub() { @Override - public void onUidCachedChanged(int uid, boolean cached) { + public void onUidFrozenStateChanged(int[] uids, int[] frozenStates) { synchronized (mService) { - 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; + 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(); } - enqueueUpdateRunningList(); } } - }, ActivityManager.UID_OBSERVER_CACHED, 0, "android"); + }); // Kick off periodic health checks mLocalHandler.sendEmptyMessage(MSG_CHECK_HEALTH); @@ -1496,6 +1521,7 @@ 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)); } } @@ -1690,6 +1716,7 @@ 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); @@ -1812,12 +1839,18 @@ 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 36d191b466ba..c68db4f67337 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_CACHED_MILLIS = 120_000; + mConstants.DELAY_FROZEN_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.setProcessCached(false); + queue.setUidFrozen(false); final long notCachedRunnableAt = queue.getRunnableAt(); - queue.setProcessCached(true); + queue.setUidFrozen(true); final long cachedRunnableAt = queue.getRunnableAt(); assertThat(cachedRunnableAt).isGreaterThan(notCachedRunnableAt); assertFalse(queue.isRunnable()); - assertEquals(BroadcastProcessQueue.REASON_CACHED_INFINITE_DEFER, + assertEquals(BroadcastProcessQueue.REASON_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.setProcessCached(false); + queue.setUidFrozen(false); final long notCachedRunnableAt = queue.getRunnableAt(); - queue.setProcessCached(true); + queue.setUidFrozen(true); final long cachedRunnableAt = queue.getRunnableAt(); assertThat(cachedRunnableAt).isGreaterThan(notCachedRunnableAt); assertTrue(queue.isRunnable()); - assertEquals(BroadcastProcessQueue.REASON_CACHED, queue.getRunnableAtReason()); + assertEquals(BroadcastProcessQueue.REASON_FROZEN, 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.setProcessCached(false); + queue.setUidFrozen(false); assertTrue(queue.isRunnable()); assertThat(queue.getRunnableAt()).isAtMost(airplaneRecord.enqueueClockTime); assertEquals(ProcessList.SCHED_GROUP_DEFAULT, queue.getPreferredSchedulingGroupLocked()); assertEquals(queue.peekNextBroadcastRecord(), airplaneRecord); - queue.setProcessCached(true); + queue.setUidFrozen(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_Cached(BroadcastRecord testRecord, int testRunnableAtReason) { + private void doRunnableAt_Frozen(BroadcastRecord testRecord, int testRunnableAtReason) { final BroadcastProcessQueue queue = new BroadcastProcessQueue(mConstants, PACKAGE_GREEN, getUidForPackage(PACKAGE_GREEN)); - queue.setProcessCached(true); + queue.setUidFrozen(true); final BroadcastRecord lazyRecord = makeBroadcastRecord( new Intent(Intent.ACTION_AIRPLANE_MODE_CHANGED), @@ -515,49 +515,49 @@ public final class BroadcastQueueModernImplTest { } @Test - public void testRunnableAt_Cached_Manifest() { - doRunnableAt_Cached(makeBroadcastRecord(makeMockIntent(), null, + public void testRunnableAt_Frozen_Manifest() { + doRunnableAt_Frozen(makeBroadcastRecord(makeMockIntent(), null, List.of(makeMockManifestReceiver()), null, false), REASON_CONTAINS_MANIFEST); } @Test - public void testRunnableAt_Cached_Ordered() { - doRunnableAt_Cached(makeBroadcastRecord(makeMockIntent(), null, + public void testRunnableAt_Frozen_Ordered() { + doRunnableAt_Frozen(makeBroadcastRecord(makeMockIntent(), null, List.of(makeMockRegisteredReceiver()), null, true), REASON_CONTAINS_ORDERED); } @Test - public void testRunnableAt_Cached_Foreground() { + public void testRunnableAt_Frozen_Foreground() { final Intent foregroundIntent = new Intent(); foregroundIntent.addFlags(Intent.FLAG_RECEIVER_FOREGROUND); - doRunnableAt_Cached(makeBroadcastRecord(foregroundIntent, null, + doRunnableAt_Frozen(makeBroadcastRecord(foregroundIntent, null, List.of(makeMockRegisteredReceiver()), null, false), REASON_CONTAINS_FOREGROUND); } @Test - public void testRunnableAt_Cached_Interactive() { + public void testRunnableAt_Frozen_Interactive() { final BroadcastOptions options = BroadcastOptions.makeBasic(); options.setInteractive(true); - doRunnableAt_Cached(makeBroadcastRecord(makeMockIntent(), options, + doRunnableAt_Frozen(makeBroadcastRecord(makeMockIntent(), options, List.of(makeMockRegisteredReceiver()), null, false), REASON_CONTAINS_INTERACTIVE); } @Test - public void testRunnableAt_Cached_Alarm() { + public void testRunnableAt_Frozen_Alarm() { final BroadcastOptions options = BroadcastOptions.makeBasic(); options.setAlarmBroadcast(true); - doRunnableAt_Cached(makeBroadcastRecord(makeMockIntent(), options, + doRunnableAt_Frozen(makeBroadcastRecord(makeMockIntent(), options, List.of(makeMockRegisteredReceiver()), null, false), REASON_CONTAINS_ALARM); } @Test - public void testRunnableAt_Cached_Prioritized_NonDeferrable() { + public void testRunnableAt_Frozen_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_Cached(makeBroadcastRecord(makeMockIntent(), options, + doRunnableAt_Frozen(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 bca39ae64823..17a0b6f17bcb 100644 --- a/services/tests/mockingservicestests/src/com/android/server/am/BroadcastQueueTest.java +++ b/services/tests/mockingservicestests/src/com/android/server/am/BroadcastQueueTest.java @@ -16,6 +16,8 @@ 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; @@ -53,7 +55,7 @@ import android.app.AppOpsManager; import android.app.BackgroundStartPrivileges; import android.app.BroadcastOptions; import android.app.IApplicationThread; -import android.app.UidObserver; +import android.app.IUidFrozenStateChangedCallback; import android.app.usage.UsageEvents.Event; import android.app.usage.UsageStatsManagerInternal; import android.content.ComponentName; @@ -162,7 +164,7 @@ public class BroadcastQueueTest { private BroadcastQueue mQueue; BroadcastConstants mConstants; private BroadcastSkipPolicy mSkipPolicy; - private UidObserver mUidObserver; + private IUidFrozenStateChangedCallback mUidFrozenStateChangedCallback; /** * Desired behavior of the next @@ -289,9 +291,9 @@ public class BroadcastQueueTest { doNothing().when(mAms).appNotResponding(any(), any()); doAnswer((invocation) -> { - mUidObserver = invocation.getArgument(0); + mUidFrozenStateChangedCallback = invocation.getArgument(0); return null; - }).when(mAms).registerUidObserver(any(), anyInt(), anyInt(), any()); + }).when(mAms).registerUidFrozenStateChangedCallback(any()); mConstants = new BroadcastConstants(Settings.Global.BROADCAST_FG_CONSTANTS); mConstants.TIMEOUT = 100; @@ -399,6 +401,18 @@ 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); @@ -1661,8 +1675,8 @@ public class BroadcastQueueTest { final ProcessRecord receiverYellowApp = makeActiveProcessRecord(PACKAGE_YELLOW); final ProcessRecord receiverOrangeApp = makeActiveProcessRecord(PACKAGE_ORANGE); - receiverGreenApp.setCached(true); - receiverBlueApp.setCached(true); + freezeUid(getUidForPackage(PACKAGE_GREEN)); + freezeUid(getUidForPackage(PACKAGE_BLUE)); final Intent timeTick = new Intent(Intent.ACTION_TIME_TICK); final BroadcastOptions opts = BroadcastOptions.makeBasic() @@ -1706,14 +1720,12 @@ public class BroadcastQueueTest { eq(UserHandle.USER_SYSTEM), anyInt(), anyInt(), any()); // Shift blue to be active and confirm that deferred broadcast is delivered - receiverBlueApp.setCached(false); - mUidObserver.onUidCachedChanged(getUidForPackage(PACKAGE_BLUE), false); + thawUid(getUidForPackage(PACKAGE_BLUE)); waitForIdle(); verifyScheduleRegisteredReceiver(times(1), receiverBlueApp, timeTick); // Shift green to be active and confirm that deferred broadcast is delivered - receiverGreenApp.setCached(false); - mUidObserver.onUidCachedChanged(getUidForPackage(PACKAGE_GREEN), false); + thawUid(getUidForPackage(PACKAGE_GREEN)); waitForIdle(); verifyScheduleRegisteredReceiver(times(1), receiverGreenApp, timeTick); } @@ -2046,9 +2058,9 @@ public class BroadcastQueueTest { final ProcessRecord receiverBlueApp = makeActiveProcessRecord(PACKAGE_BLUE); final ProcessRecord receiverYellowApp = makeActiveProcessRecord(PACKAGE_YELLOW); - receiverGreenApp.setCached(true); - receiverBlueApp.setCached(true); - receiverYellowApp.setCached(false); + freezeUid(getUidForPackage(PACKAGE_GREEN)); + freezeUid(getUidForPackage(PACKAGE_BLUE)); + thawUid(getUidForPackage(PACKAGE_YELLOW)); final Intent airplane = new Intent(Intent.ACTION_AIRPLANE_MODE_CHANGED); final BroadcastOptions opts = BroadcastOptions.makeBasic() @@ -2071,8 +2083,7 @@ public class BroadcastQueueTest { verifyScheduleRegisteredReceiver(times(1), receiverYellowApp, airplane); // Shift green to be active and confirm that deferred broadcast is delivered - receiverGreenApp.setCached(false); - mUidObserver.onUidCachedChanged(getUidForPackage(PACKAGE_GREEN), false); + thawUid(getUidForPackage(PACKAGE_GREEN)); waitForIdle(); verifyScheduleRegisteredReceiver(times(1), receiverGreenApp, airplane); } |