[3rd try] JobScheduler to use UID active state for job exemption
JobScheduler used to use procstate foreground state to decide whether
to exempt jobs, but it should use UID's active state instead, so that
if apps in the temp-whitelist schedule jobs, they run immediately.
Test: Boot
Test: atest CtsAlarmManagerTestCases
Test: atest CtsJobSchedulerTestCases
Test: atest CtsBatterySavingTestCases
Test: atest $ANDROID_BUILD_TOP/frameworks/base/services/tests/servicestests/src/com/android/server/AppStateTrackerTest.java
Bug: 72125364
Change-Id: I7a5628e76121199f3a5299e2a5576e1481574a6e
diff --git a/services/core/java/com/android/server/AppStateTracker.java b/services/core/java/com/android/server/AppStateTracker.java
new file mode 100644
index 0000000..9b29b32
--- /dev/null
+++ b/services/core/java/com/android/server/AppStateTracker.java
@@ -0,0 +1,1327 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.server;
+
+import android.annotation.NonNull;
+import android.app.ActivityManager;
+import android.app.ActivityManagerInternal;
+import android.app.AppOpsManager;
+import android.app.AppOpsManager.PackageOps;
+import android.app.IActivityManager;
+import android.app.IUidObserver;
+import android.app.usage.UsageStatsManager;
+import android.app.usage.UsageStatsManagerInternal;
+import android.app.usage.UsageStatsManagerInternal.AppIdleStateChangeListener;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.database.ContentObserver;
+import android.net.Uri;
+import android.os.BatteryManager;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.Message;
+import android.os.PowerManager.ServiceType;
+import android.os.PowerManagerInternal;
+import android.os.RemoteException;
+import android.os.ServiceManager;
+import android.os.UserHandle;
+import android.provider.Settings;
+import android.util.ArraySet;
+import android.util.Pair;
+import android.util.Slog;
+import android.util.SparseBooleanArray;
+import android.util.SparseSetArray;
+import android.util.proto.ProtoOutputStream;
+
+import com.android.internal.annotations.GuardedBy;
+import com.android.internal.annotations.VisibleForTesting;
+import com.android.internal.app.IAppOpsCallback;
+import com.android.internal.app.IAppOpsService;
+import com.android.internal.util.ArrayUtils;
+import com.android.internal.util.Preconditions;
+import com.android.server.ForceAppStandbyTrackerProto.ExemptedPackage;
+import com.android.server.ForceAppStandbyTrackerProto.RunAnyInBackgroundRestrictedPackages;
+
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Class to keep track of the information related to "force app standby", which includes:
+ * - OP_RUN_ANY_IN_BACKGROUND for each package
+ * - UID foreground/active state
+ * - User+system power save whitelist
+ * - Temporary power save whitelist
+ * - Global "force all apps standby" mode enforced by battery saver.
+ *
+ * TODO: Make it a LocalService.
+ *
+ * Test:
+ atest $ANDROID_BUILD_TOP/frameworks/base/services/tests/servicestests/src/com/android/server/AppStateTrackerTest.java
+ */
+public class AppStateTracker {
+ private static final String TAG = "ForceAppStandbyTracker";
+ private static final boolean DEBUG = true;
+
+ @GuardedBy("AppStateTracker.class")
+ private static AppStateTracker sInstance;
+
+ private final Object mLock = new Object();
+ private final Context mContext;
+
+ @VisibleForTesting
+ static final int TARGET_OP = AppOpsManager.OP_RUN_ANY_IN_BACKGROUND;
+
+ IActivityManager mIActivityManager;
+ ActivityManagerInternal mActivityManagerInternal;
+ AppOpsManager mAppOpsManager;
+ IAppOpsService mAppOpsService;
+ PowerManagerInternal mPowerManagerInternal;
+ StandbyTracker mStandbyTracker;
+ UsageStatsManagerInternal mUsageStatsManagerInternal;
+
+ private final MyHandler mHandler;
+
+ @VisibleForTesting
+ FeatureFlagsObserver mFlagsObserver;
+
+ /**
+ * Pair of (uid (not user-id), packageName) with OP_RUN_ANY_IN_BACKGROUND *not* allowed.
+ */
+ @GuardedBy("mLock")
+ final ArraySet<Pair<Integer, String>> mRunAnyRestrictedPackages = new ArraySet<>();
+
+ /** UIDs that are active. */
+ @GuardedBy("mLock")
+ final SparseBooleanArray mActiveUids = new SparseBooleanArray();
+
+ /** UIDs that are in the foreground. */
+ @GuardedBy("mLock")
+ final SparseBooleanArray mForegroundUids = new SparseBooleanArray();
+
+ /**
+ * System except-idle + user whitelist in the device idle controller.
+ */
+ @GuardedBy("mLock")
+ private int[] mPowerWhitelistedAllAppIds = new int[0];
+
+ @GuardedBy("mLock")
+ private int[] mTempWhitelistedAppIds = mPowerWhitelistedAllAppIds;
+
+ /**
+ * Per-user packages that are in the EXEMPT bucket.
+ */
+ @GuardedBy("mLock")
+ private final SparseSetArray<String> mExemptedPackages = new SparseSetArray<>();
+
+ @GuardedBy("mLock")
+ final ArraySet<Listener> mListeners = new ArraySet<>();
+
+ @GuardedBy("mLock")
+ boolean mStarted;
+
+ /**
+ * Only used for small battery use-case.
+ */
+ @GuardedBy("mLock")
+ boolean mIsPluggedIn;
+
+ @GuardedBy("mLock")
+ boolean mBatterySaverEnabled;
+
+ /**
+ * True if the forced app standby is currently enabled
+ */
+ @GuardedBy("mLock")
+ boolean mForceAllAppsStandby;
+
+ /**
+ * True if the forced app standby for small battery devices feature is enabled in settings
+ */
+ @GuardedBy("mLock")
+ boolean mForceAllAppStandbyForSmallBattery;
+
+ /**
+ * True if the forced app standby feature is enabled in settings
+ */
+ @GuardedBy("mLock")
+ boolean mForcedAppStandbyEnabled;
+
+ interface Stats {
+ int UID_FG_STATE_CHANGED = 0;
+ int UID_ACTIVE_STATE_CHANGED = 1;
+ int RUN_ANY_CHANGED = 2;
+ int ALL_UNWHITELISTED = 3;
+ int ALL_WHITELIST_CHANGED = 4;
+ int TEMP_WHITELIST_CHANGED = 5;
+ int EXEMPT_CHANGED = 6;
+ int FORCE_ALL_CHANGED = 7;
+ int FORCE_APP_STANDBY_FEATURE_FLAG_CHANGED = 8;
+
+ int IS_UID_ACTIVE_CACHED = 9;
+ int IS_UID_ACTIVE_RAW = 10;
+ }
+
+ private final StatLogger mStatLogger = new StatLogger(new String[] {
+ "UID_FG_STATE_CHANGED",
+ "UID_ACTIVE_STATE_CHANGED",
+ "RUN_ANY_CHANGED",
+ "ALL_UNWHITELISTED",
+ "ALL_WHITELIST_CHANGED",
+ "TEMP_WHITELIST_CHANGED",
+ "EXEMPT_CHANGED",
+ "FORCE_ALL_CHANGED",
+ "FORCE_APP_STANDBY_FEATURE_FLAG_CHANGED",
+
+ "IS_UID_ACTIVE_CACHED",
+ "IS_UID_ACTIVE_RAW",
+ });
+
+ @VisibleForTesting
+ class FeatureFlagsObserver extends ContentObserver {
+ FeatureFlagsObserver() {
+ super(null);
+ }
+
+ void register() {
+ mContext.getContentResolver().registerContentObserver(
+ Settings.Global.getUriFor(Settings.Global.FORCED_APP_STANDBY_ENABLED),
+ false, this);
+
+ mContext.getContentResolver().registerContentObserver(Settings.Global.getUriFor(
+ Settings.Global.FORCED_APP_STANDBY_FOR_SMALL_BATTERY_ENABLED), false, this);
+ }
+
+ boolean isForcedAppStandbyEnabled() {
+ return injectGetGlobalSettingInt(Settings.Global.FORCED_APP_STANDBY_ENABLED, 1) == 1;
+ }
+
+ boolean isForcedAppStandbyForSmallBatteryEnabled() {
+ return injectGetGlobalSettingInt(
+ Settings.Global.FORCED_APP_STANDBY_FOR_SMALL_BATTERY_ENABLED, 0) == 1;
+ }
+
+ @Override
+ public void onChange(boolean selfChange, Uri uri) {
+ if (Settings.Global.getUriFor(Settings.Global.FORCED_APP_STANDBY_ENABLED).equals(uri)) {
+ final boolean enabled = isForcedAppStandbyEnabled();
+ synchronized (mLock) {
+ if (mForcedAppStandbyEnabled == enabled) {
+ return;
+ }
+ mForcedAppStandbyEnabled = enabled;
+ if (DEBUG) {
+ Slog.d(TAG,"Forced app standby feature flag changed: "
+ + mForcedAppStandbyEnabled);
+ }
+ }
+ mHandler.notifyForcedAppStandbyFeatureFlagChanged();
+ } else if (Settings.Global.getUriFor(
+ Settings.Global.FORCED_APP_STANDBY_FOR_SMALL_BATTERY_ENABLED).equals(uri)) {
+ final boolean enabled = isForcedAppStandbyForSmallBatteryEnabled();
+ synchronized (mLock) {
+ if (mForceAllAppStandbyForSmallBattery == enabled) {
+ return;
+ }
+ mForceAllAppStandbyForSmallBattery = enabled;
+ if (DEBUG) {
+ Slog.d(TAG, "Forced app standby for small battery feature flag changed: "
+ + mForceAllAppStandbyForSmallBattery);
+ }
+ updateForceAllAppStandbyState();
+ }
+ } else {
+ Slog.w(TAG, "Unexpected feature flag uri encountered: " + uri);
+ }
+ }
+ }
+
+ public static abstract class Listener {
+ /**
+ * This is called when the OP_RUN_ANY_IN_BACKGROUND appops changed for a package.
+ */
+ private void onRunAnyAppOpsChanged(AppStateTracker sender,
+ int uid, @NonNull String packageName) {
+ updateJobsForUidPackage(uid, packageName);
+
+ if (!sender.areAlarmsRestricted(uid, packageName, /*allowWhileIdle=*/ false)) {
+ unblockAlarmsForUidPackage(uid, packageName);
+ } else if (!sender.areAlarmsRestricted(uid, packageName, /*allowWhileIdle=*/ true)){
+ // we need to deliver the allow-while-idle alarms for this uid, package
+ unblockAllUnrestrictedAlarms();
+ }
+ }
+
+ /**
+ * This is called when the foreground state changed for a UID.
+ */
+ private void onUidForegroundStateChanged(AppStateTracker sender, int uid) {
+ onUidForeground(uid, sender.isUidInForeground(uid));
+ }
+
+ /**
+ * This is called when the active/idle state changed for a UID.
+ */
+ private void onUidActiveStateChanged(AppStateTracker sender, int uid) {
+ updateJobsForUid(uid);
+
+ if (sender.isUidActive(uid)) {
+ unblockAlarmsForUid(uid);
+ }
+ }
+
+ /**
+ * This is called when an app-id(s) is removed from the power save whitelist.
+ */
+ private void onPowerSaveUnwhitelisted(AppStateTracker sender) {
+ updateAllJobs();
+ unblockAllUnrestrictedAlarms();
+ }
+
+ /**
+ * This is called when the power save whitelist changes, excluding the
+ * {@link #onPowerSaveUnwhitelisted} case.
+ */
+ private void onPowerSaveWhitelistedChanged(AppStateTracker sender) {
+ updateAllJobs();
+ }
+
+ /**
+ * This is called when the temp whitelist changes.
+ */
+ private void onTempPowerSaveWhitelistChanged(AppStateTracker sender) {
+
+ // TODO This case happens rather frequently; consider optimizing and update jobs
+ // only for affected app-ids.
+
+ updateAllJobs();
+
+ // Note when an app is just put in the temp whitelist, we do *not* drain pending alarms.
+ }
+
+ /**
+ * This is called when the EXEMPT bucket is updated.
+ */
+ private void onExemptChanged(AppStateTracker sender) {
+ // This doesn't happen very often, so just re-evaluate all jobs / alarms.
+ updateAllJobs();
+ unblockAllUnrestrictedAlarms();
+ }
+
+ /**
+ * This is called when the global "force all apps standby" flag changes.
+ */
+ private void onForceAllAppsStandbyChanged(AppStateTracker sender) {
+ updateAllJobs();
+
+ if (!sender.isForceAllAppsStandbyEnabled()) {
+ unblockAllUnrestrictedAlarms();
+ }
+ }
+
+ /**
+ * Called when the job restrictions for multiple UIDs might have changed, so the job
+ * scheduler should re-evaluate all restrictions for all jobs.
+ */
+ public void updateAllJobs() {
+ }
+
+ /**
+ * Called when the job restrictions for a UID might have changed, so the job
+ * scheduler should re-evaluate all restrictions for all jobs.
+ */
+ public void updateJobsForUid(int uid) {
+ }
+
+ /**
+ * Called when the job restrictions for a UID - package might have changed, so the job
+ * scheduler should re-evaluate all restrictions for all jobs.
+ */
+ public void updateJobsForUidPackage(int uid, String packageName) {
+ }
+
+ /**
+ * Called when the job restrictions for multiple UIDs might have changed, so the alarm
+ * manager should re-evaluate all restrictions for all blocked jobs.
+ */
+ public void unblockAllUnrestrictedAlarms() {
+ }
+
+ /**
+ * Called when all jobs for a specific UID are unblocked.
+ */
+ public void unblockAlarmsForUid(int uid) {
+ }
+
+ /**
+ * Called when all alarms for a specific UID - package are unblocked.
+ */
+ public void unblockAlarmsForUidPackage(int uid, String packageName) {
+ }
+
+ /**
+ * Called when a UID comes into the foreground or the background.
+ *
+ * @see #isUidInForeground(int)
+ */
+ public void onUidForeground(int uid, boolean foreground) {
+ }
+ }
+
+ public AppStateTracker(Context context, Looper looper) {
+ mContext = context;
+ mHandler = new MyHandler(looper);
+ }
+
+ /**
+ * Call it when the system is ready.
+ */
+ public void onSystemServicesReady() {
+ synchronized (mLock) {
+ if (mStarted) {
+ return;
+ }
+ mStarted = true;
+
+ mIActivityManager = Preconditions.checkNotNull(injectIActivityManager());
+ mActivityManagerInternal = Preconditions.checkNotNull(injectActivityManagerInternal());
+ mAppOpsManager = Preconditions.checkNotNull(injectAppOpsManager());
+ mAppOpsService = Preconditions.checkNotNull(injectIAppOpsService());
+ mPowerManagerInternal = Preconditions.checkNotNull(injectPowerManagerInternal());
+ mUsageStatsManagerInternal = Preconditions.checkNotNull(
+ injectUsageStatsManagerInternal());
+
+ mFlagsObserver = new FeatureFlagsObserver();
+ mFlagsObserver.register();
+ mForcedAppStandbyEnabled = mFlagsObserver.isForcedAppStandbyEnabled();
+ mForceAllAppStandbyForSmallBattery =
+ mFlagsObserver.isForcedAppStandbyForSmallBatteryEnabled();
+ mStandbyTracker = new StandbyTracker();
+ mUsageStatsManagerInternal.addAppIdleStateChangeListener(mStandbyTracker);
+
+ try {
+ mIActivityManager.registerUidObserver(new UidObserver(),
+ ActivityManager.UID_OBSERVER_GONE
+ | ActivityManager.UID_OBSERVER_IDLE
+ | ActivityManager.UID_OBSERVER_ACTIVE
+ | ActivityManager.UID_OBSERVER_PROCSTATE,
+ ActivityManager.PROCESS_STATE_UNKNOWN, null);
+ mAppOpsService.startWatchingMode(TARGET_OP, null,
+ new AppOpsWatcher());
+ } catch (RemoteException e) {
+ // shouldn't happen.
+ }
+
+ IntentFilter filter = new IntentFilter();
+ filter.addAction(Intent.ACTION_USER_REMOVED);
+ filter.addAction(Intent.ACTION_BATTERY_CHANGED);
+ mContext.registerReceiver(new MyReceiver(), filter);
+
+ refreshForcedAppStandbyUidPackagesLocked();
+
+ mPowerManagerInternal.registerLowPowerModeObserver(
+ ServiceType.FORCE_ALL_APPS_STANDBY,
+ (state) -> {
+ synchronized (mLock) {
+ mBatterySaverEnabled = state.batterySaverEnabled;
+ updateForceAllAppStandbyState();
+ }
+ });
+
+ mBatterySaverEnabled = mPowerManagerInternal.getLowPowerState(
+ ServiceType.FORCE_ALL_APPS_STANDBY).batterySaverEnabled;
+
+ updateForceAllAppStandbyState();
+ }
+ }
+
+ @VisibleForTesting
+ AppOpsManager injectAppOpsManager() {
+ return mContext.getSystemService(AppOpsManager.class);
+ }
+
+ @VisibleForTesting
+ IAppOpsService injectIAppOpsService() {
+ return IAppOpsService.Stub.asInterface(
+ ServiceManager.getService(Context.APP_OPS_SERVICE));
+ }
+
+ @VisibleForTesting
+ IActivityManager injectIActivityManager() {
+ return ActivityManager.getService();
+ }
+
+ @VisibleForTesting
+ ActivityManagerInternal injectActivityManagerInternal() {
+ return LocalServices.getService(ActivityManagerInternal.class);
+ }
+
+ @VisibleForTesting
+ PowerManagerInternal injectPowerManagerInternal() {
+ return LocalServices.getService(PowerManagerInternal.class);
+ }
+
+ @VisibleForTesting
+ UsageStatsManagerInternal injectUsageStatsManagerInternal() {
+ return LocalServices.getService(UsageStatsManagerInternal.class);
+ }
+
+ @VisibleForTesting
+ boolean isSmallBatteryDevice() {
+ return ActivityManager.isSmallBatteryDevice();
+ }
+
+ @VisibleForTesting
+ int injectGetGlobalSettingInt(String key, int def) {
+ return Settings.Global.getInt(mContext.getContentResolver(), key, def);
+ }
+
+ /**
+ * Update {@link #mRunAnyRestrictedPackages} with the current app ops state.
+ */
+ @GuardedBy("mLock")
+ private void refreshForcedAppStandbyUidPackagesLocked() {
+ mRunAnyRestrictedPackages.clear();
+ final List<PackageOps> ops = mAppOpsManager.getPackagesForOps(
+ new int[] {TARGET_OP});
+
+ if (ops == null) {
+ return;
+ }
+ final int size = ops.size();
+ for (int i = 0; i < size; i++) {
+ final AppOpsManager.PackageOps pkg = ops.get(i);
+ final List<AppOpsManager.OpEntry> entries = ops.get(i).getOps();
+
+ for (int j = 0; j < entries.size(); j++) {
+ AppOpsManager.OpEntry ent = entries.get(j);
+ if (ent.getOp() != TARGET_OP) {
+ continue;
+ }
+ if (ent.getMode() != AppOpsManager.MODE_ALLOWED) {
+ mRunAnyRestrictedPackages.add(Pair.create(
+ pkg.getUid(), pkg.getPackageName()));
+ }
+ }
+ }
+ }
+
+ private void updateForceAllAppStandbyState() {
+ synchronized (mLock) {
+ if (mForceAllAppStandbyForSmallBattery && isSmallBatteryDevice()) {
+ toggleForceAllAppsStandbyLocked(!mIsPluggedIn);
+ } else {
+ toggleForceAllAppsStandbyLocked(mBatterySaverEnabled);
+ }
+ }
+ }
+
+ /**
+ * Update {@link #mForceAllAppsStandby} and notifies the listeners.
+ */
+ @GuardedBy("mLock")
+ private void toggleForceAllAppsStandbyLocked(boolean enable) {
+ if (enable == mForceAllAppsStandby) {
+ return;
+ }
+ mForceAllAppsStandby = enable;
+
+ mHandler.notifyForceAllAppsStandbyChanged();
+ }
+
+ @GuardedBy("mLock")
+ private int findForcedAppStandbyUidPackageIndexLocked(int uid, @NonNull String packageName) {
+ final int size = mRunAnyRestrictedPackages.size();
+ if (size > 8) {
+ return mRunAnyRestrictedPackages.indexOf(Pair.create(uid, packageName));
+ }
+ for (int i = 0; i < size; i++) {
+ final Pair<Integer, String> pair = mRunAnyRestrictedPackages.valueAt(i);
+
+ if ((pair.first == uid) && packageName.equals(pair.second)) {
+ return i;
+ }
+ }
+ return -1;
+ }
+
+ /**
+ * @return whether a uid package-name pair is in mRunAnyRestrictedPackages.
+ */
+ @GuardedBy("mLock")
+ boolean isRunAnyRestrictedLocked(int uid, @NonNull String packageName) {
+ return findForcedAppStandbyUidPackageIndexLocked(uid, packageName) >= 0;
+ }
+
+ /**
+ * Add to / remove from {@link #mRunAnyRestrictedPackages}.
+ */
+ @GuardedBy("mLock")
+ boolean updateForcedAppStandbyUidPackageLocked(int uid, @NonNull String packageName,
+ boolean restricted) {
+ final int index = findForcedAppStandbyUidPackageIndexLocked(uid, packageName);
+ final boolean wasRestricted = index >= 0;
+ if (wasRestricted == restricted) {
+ return false;
+ }
+ if (restricted) {
+ mRunAnyRestrictedPackages.add(Pair.create(uid, packageName));
+ } else {
+ mRunAnyRestrictedPackages.removeAt(index);
+ }
+ return true;
+ }
+
+ private static boolean addUidToArray(SparseBooleanArray array, int uid) {
+ if (UserHandle.isCore(uid)) {
+ return false;
+ }
+ if (array.get(uid)) {
+ return false;
+ }
+ array.put(uid, true);
+ return true;
+ }
+
+ private static boolean removeUidFromArray(SparseBooleanArray array, int uid, boolean remove) {
+ if (UserHandle.isCore(uid)) {
+ return false;
+ }
+ if (!array.get(uid)) {
+ return false;
+ }
+ if (remove) {
+ array.delete(uid);
+ } else {
+ array.put(uid, false);
+ }
+ return true;
+ }
+
+ private final class UidObserver extends IUidObserver.Stub {
+ @Override
+ public void onUidStateChanged(int uid, int procState, long procStateSeq) {
+ mHandler.onUidStateChanged(uid, procState);
+ }
+
+ @Override
+ public void onUidActive(int uid) {
+ mHandler.onUidActive(uid);
+ }
+
+ @Override
+ public void onUidGone(int uid, boolean disabled) {
+ mHandler.onUidGone(uid, disabled);
+ }
+
+ @Override
+ public void onUidIdle(int uid, boolean disabled) {
+ mHandler.onUidIdle(uid, disabled);
+ }
+
+ @Override
+ public void onUidCachedChanged(int uid, boolean cached) {
+ }
+ }
+
+ private final class AppOpsWatcher extends IAppOpsCallback.Stub {
+ @Override
+ public void opChanged(int op, int uid, String packageName) throws RemoteException {
+ boolean restricted = false;
+ try {
+ restricted = mAppOpsService.checkOperation(TARGET_OP,
+ uid, packageName) != AppOpsManager.MODE_ALLOWED;
+ } catch (RemoteException e) {
+ // Shouldn't happen
+ }
+ synchronized (mLock) {
+ if (updateForcedAppStandbyUidPackageLocked(uid, packageName, restricted)) {
+ mHandler.notifyRunAnyAppOpsChanged(uid, packageName);
+ }
+ }
+ }
+ }
+
+ private final class MyReceiver extends BroadcastReceiver {
+ @Override
+ public void onReceive(Context context, Intent intent) {
+ if (Intent.ACTION_USER_REMOVED.equals(intent.getAction())) {
+ final int userId = intent.getIntExtra(Intent.EXTRA_USER_HANDLE, -1);
+ if (userId > 0) {
+ mHandler.doUserRemoved(userId);
+ }
+ } else if (Intent.ACTION_BATTERY_CHANGED.equals(intent.getAction())) {
+ synchronized (mLock) {
+ mIsPluggedIn = (intent.getIntExtra(BatteryManager.EXTRA_PLUGGED, 0) != 0);
+ }
+ updateForceAllAppStandbyState();
+ }
+ }
+ }
+
+ final class StandbyTracker extends AppIdleStateChangeListener {
+ @Override
+ public void onAppIdleStateChanged(String packageName, int userId, boolean idle,
+ int bucket) {
+ if (DEBUG) {
+ Slog.d(TAG,"onAppIdleStateChanged: " + packageName + " u" + userId
+ + (idle ? " idle" : " active") + " " + bucket);
+ }
+ final boolean changed;
+ if (bucket == UsageStatsManager.STANDBY_BUCKET_EXEMPTED) {
+ changed = mExemptedPackages.add(userId, packageName);
+ } else {
+ changed = mExemptedPackages.remove(userId, packageName);
+ }
+ if (changed) {
+ mHandler.notifyExemptChanged();
+ }
+ }
+
+ @Override
+ public void onParoleStateChanged(boolean isParoleOn) {
+ }
+ }
+
+ private Listener[] cloneListeners() {
+ synchronized (mLock) {
+ return mListeners.toArray(new Listener[mListeners.size()]);
+ }
+ }
+
+ private class MyHandler extends Handler {
+ private static final int MSG_UID_ACTIVE_STATE_CHANGED = 0;
+ private static final int MSG_UID_FG_STATE_CHANGED = 1;
+ private static final int MSG_RUN_ANY_CHANGED = 3;
+ private static final int MSG_ALL_UNWHITELISTED = 4;
+ private static final int MSG_ALL_WHITELIST_CHANGED = 5;
+ private static final int MSG_TEMP_WHITELIST_CHANGED = 6;
+ private static final int MSG_FORCE_ALL_CHANGED = 7;
+ private static final int MSG_USER_REMOVED = 8;
+ private static final int MSG_FORCE_APP_STANDBY_FEATURE_FLAG_CHANGED = 9;
+ private static final int MSG_EXEMPT_CHANGED = 10;
+
+ private static final int MSG_ON_UID_STATE_CHANGED = 11;
+ private static final int MSG_ON_UID_ACTIVE = 12;
+ private static final int MSG_ON_UID_GONE = 13;
+ private static final int MSG_ON_UID_IDLE = 14;
+
+ public MyHandler(Looper looper) {
+ super(looper);
+ }
+
+ public void notifyUidActiveStateChanged(int uid) {
+ obtainMessage(MSG_UID_ACTIVE_STATE_CHANGED, uid, 0).sendToTarget();
+ }
+
+ public void notifyUidForegroundStateChanged(int uid) {
+ obtainMessage(MSG_UID_FG_STATE_CHANGED, uid, 0).sendToTarget();
+ }
+
+ public void notifyRunAnyAppOpsChanged(int uid, @NonNull String packageName) {
+ obtainMessage(MSG_RUN_ANY_CHANGED, uid, 0, packageName).sendToTarget();
+ }
+
+ public void notifyAllUnwhitelisted() {
+ removeMessages(MSG_ALL_UNWHITELISTED);
+ obtainMessage(MSG_ALL_UNWHITELISTED).sendToTarget();
+ }
+
+ public void notifyAllWhitelistChanged() {
+ removeMessages(MSG_ALL_WHITELIST_CHANGED);
+ obtainMessage(MSG_ALL_WHITELIST_CHANGED).sendToTarget();
+ }
+
+ public void notifyTempWhitelistChanged() {
+ removeMessages(MSG_TEMP_WHITELIST_CHANGED);
+ obtainMessage(MSG_TEMP_WHITELIST_CHANGED).sendToTarget();
+ }
+
+ public void notifyForceAllAppsStandbyChanged() {
+ removeMessages(MSG_FORCE_ALL_CHANGED);
+ obtainMessage(MSG_FORCE_ALL_CHANGED).sendToTarget();
+ }
+
+ public void notifyForcedAppStandbyFeatureFlagChanged() {
+ removeMessages(MSG_FORCE_APP_STANDBY_FEATURE_FLAG_CHANGED);
+ obtainMessage(MSG_FORCE_APP_STANDBY_FEATURE_FLAG_CHANGED).sendToTarget();
+ }
+
+ public void notifyExemptChanged() {
+ removeMessages(MSG_EXEMPT_CHANGED);
+ obtainMessage(MSG_EXEMPT_CHANGED).sendToTarget();
+ }
+
+ public void doUserRemoved(int userId) {
+ obtainMessage(MSG_USER_REMOVED, userId, 0).sendToTarget();
+ }
+
+ public void onUidStateChanged(int uid, int procState) {
+ obtainMessage(MSG_ON_UID_STATE_CHANGED, uid, procState).sendToTarget();
+ }
+
+ public void onUidActive(int uid) {
+ obtainMessage(MSG_ON_UID_ACTIVE, uid, 0).sendToTarget();
+ }
+
+ public void onUidGone(int uid, boolean disabled) {
+ obtainMessage(MSG_ON_UID_GONE, uid, disabled ? 1 : 0).sendToTarget();
+ }
+
+ public void onUidIdle(int uid, boolean disabled) {
+ obtainMessage(MSG_ON_UID_IDLE, uid, disabled ? 1 : 0).sendToTarget();
+ }
+
+ @Override
+ public void handleMessage(Message msg) {
+ switch (msg.what) {
+ case MSG_USER_REMOVED:
+ handleUserRemoved(msg.arg1);
+ return;
+ }
+
+ // Only notify the listeners when started.
+ synchronized (mLock) {
+ if (!mStarted) {
+ return;
+ }
+ }
+ final AppStateTracker sender = AppStateTracker.this;
+
+ long start = mStatLogger.getTime();
+ switch (msg.what) {
+ case MSG_UID_ACTIVE_STATE_CHANGED:
+ for (Listener l : cloneListeners()) {
+ l.onUidActiveStateChanged(sender, msg.arg1);
+ }
+ mStatLogger.logDurationStat(Stats.UID_ACTIVE_STATE_CHANGED, start);
+ return;
+
+ case MSG_UID_FG_STATE_CHANGED:
+ for (Listener l : cloneListeners()) {
+ l.onUidForegroundStateChanged(sender, msg.arg1);
+ }
+ mStatLogger.logDurationStat(Stats.UID_FG_STATE_CHANGED, start);
+ return;
+
+ case MSG_RUN_ANY_CHANGED:
+ for (Listener l : cloneListeners()) {
+ l.onRunAnyAppOpsChanged(sender, msg.arg1, (String) msg.obj);
+ }
+ mStatLogger.logDurationStat(Stats.RUN_ANY_CHANGED, start);
+ return;
+
+ case MSG_ALL_UNWHITELISTED:
+ for (Listener l : cloneListeners()) {
+ l.onPowerSaveUnwhitelisted(sender);
+ }
+ mStatLogger.logDurationStat(Stats.ALL_UNWHITELISTED, start);
+ return;
+
+ case MSG_ALL_WHITELIST_CHANGED:
+ for (Listener l : cloneListeners()) {
+ l.onPowerSaveWhitelistedChanged(sender);
+ }
+ mStatLogger.logDurationStat(Stats.ALL_WHITELIST_CHANGED, start);
+ return;
+
+ case MSG_TEMP_WHITELIST_CHANGED:
+ for (Listener l : cloneListeners()) {
+ l.onTempPowerSaveWhitelistChanged(sender);
+ }
+ mStatLogger.logDurationStat(Stats.TEMP_WHITELIST_CHANGED, start);
+ return;
+
+ case MSG_EXEMPT_CHANGED:
+ for (Listener l : cloneListeners()) {
+ l.onExemptChanged(sender);
+ }
+ mStatLogger.logDurationStat(Stats.EXEMPT_CHANGED, start);
+ return;
+
+ case MSG_FORCE_ALL_CHANGED:
+ for (Listener l : cloneListeners()) {
+ l.onForceAllAppsStandbyChanged(sender);
+ }
+ mStatLogger.logDurationStat(Stats.FORCE_ALL_CHANGED, start);
+ return;
+
+ case MSG_FORCE_APP_STANDBY_FEATURE_FLAG_CHANGED:
+ // Feature flag for forced app standby changed.
+ final boolean unblockAlarms;
+ synchronized (mLock) {
+ unblockAlarms = !mForcedAppStandbyEnabled && !mForceAllAppsStandby;
+ }
+ for (Listener l : cloneListeners()) {
+ l.updateAllJobs();
+ if (unblockAlarms) {
+ l.unblockAllUnrestrictedAlarms();
+ }
+ }
+ mStatLogger.logDurationStat(
+ Stats.FORCE_APP_STANDBY_FEATURE_FLAG_CHANGED, start);
+ return;
+
+ case MSG_USER_REMOVED:
+ handleUserRemoved(msg.arg1);
+ return;
+
+ case MSG_ON_UID_STATE_CHANGED:
+ handleUidStateChanged(msg.arg1, msg.arg2);
+ return;
+ case MSG_ON_UID_ACTIVE:
+ handleUidActive(msg.arg1);
+ return;
+ case MSG_ON_UID_GONE:
+ handleUidGone(msg.arg1, msg.arg1 != 0);
+ return;
+ case MSG_ON_UID_IDLE:
+ handleUidIdle(msg.arg1, msg.arg1 != 0);
+ return;
+ }
+ }
+
+ public void handleUidStateChanged(int uid, int procState) {
+ synchronized (mLock) {
+ if (procState > ActivityManager.PROCESS_STATE_IMPORTANT_FOREGROUND) {
+ if (removeUidFromArray(mForegroundUids, uid, false)) {
+ mHandler.notifyUidForegroundStateChanged(uid);
+ }
+ } else {
+ if (addUidToArray(mForegroundUids, uid)) {
+ mHandler.notifyUidForegroundStateChanged(uid);
+ }
+ }
+ }
+ }
+
+ public void handleUidActive(int uid) {
+ synchronized (mLock) {
+ if (addUidToArray(mActiveUids, uid)) {
+ mHandler.notifyUidActiveStateChanged(uid);
+ }
+ }
+ }
+
+ public void handleUidGone(int uid, boolean disabled) {
+ removeUid(uid, true);
+ }
+
+ public void handleUidIdle(int uid, boolean disabled) {
+ // Just to avoid excessive memcpy, don't remove from the array in this case.
+ removeUid(uid, false);
+ }
+
+ private void removeUid(int uid, boolean remove) {
+ synchronized (mLock) {
+ if (removeUidFromArray(mActiveUids, uid, remove)) {
+ mHandler.notifyUidActiveStateChanged(uid);
+ }
+ if (removeUidFromArray(mForegroundUids, uid, remove)) {
+ mHandler.notifyUidForegroundStateChanged(uid);
+ }
+ }
+ }
+ }
+
+ void handleUserRemoved(int removedUserId) {
+ synchronized (mLock) {
+ for (int i = mRunAnyRestrictedPackages.size() - 1; i >= 0; i--) {
+ final Pair<Integer, String> pair = mRunAnyRestrictedPackages.valueAt(i);
+ final int uid = pair.first;
+ final int userId = UserHandle.getUserId(uid);
+
+ if (userId == removedUserId) {
+ mRunAnyRestrictedPackages.removeAt(i);
+ }
+ }
+ cleanUpArrayForUser(mActiveUids, removedUserId);
+ cleanUpArrayForUser(mForegroundUids, removedUserId);
+ mExemptedPackages.remove(removedUserId);
+ }
+ }
+
+ private void cleanUpArrayForUser(SparseBooleanArray array, int removedUserId) {
+ for (int i = array.size() - 1; i >= 0; i--) {
+ final int uid = array.keyAt(i);
+ final int userId = UserHandle.getUserId(uid);
+
+ if (userId == removedUserId) {
+ array.removeAt(i);
+ }
+ }
+ }
+
+ /**
+ * Called by device idle controller to update the power save whitelists.
+ */
+ public void setPowerSaveWhitelistAppIds(
+ int[] powerSaveWhitelistAllAppIdArray, int[] tempWhitelistAppIdArray) {
+ synchronized (mLock) {
+ final int[] previousWhitelist = mPowerWhitelistedAllAppIds;
+ final int[] previousTempWhitelist = mTempWhitelistedAppIds;
+
+ mPowerWhitelistedAllAppIds = powerSaveWhitelistAllAppIdArray;
+ mTempWhitelistedAppIds = tempWhitelistAppIdArray;
+
+ if (isAnyAppIdUnwhitelisted(previousWhitelist, mPowerWhitelistedAllAppIds)) {
+ mHandler.notifyAllUnwhitelisted();
+ } else if (!Arrays.equals(previousWhitelist, mPowerWhitelistedAllAppIds)) {
+ mHandler.notifyAllWhitelistChanged();
+ }
+
+ if (!Arrays.equals(previousTempWhitelist, mTempWhitelistedAppIds)) {
+ mHandler.notifyTempWhitelistChanged();
+ }
+
+ }
+ }
+
+ /**
+ * @retunr true if a sorted app-id array {@code prevArray} has at least one element
+ * that's not in a sorted app-id array {@code newArray}.
+ */
+ @VisibleForTesting
+ static boolean isAnyAppIdUnwhitelisted(int[] prevArray, int[] newArray) {
+ int i1 = 0;
+ int i2 = 0;
+ boolean prevFinished;
+ boolean newFinished;
+
+ for (;;) {
+ prevFinished = i1 >= prevArray.length;
+ newFinished = i2 >= newArray.length;
+ if (prevFinished || newFinished) {
+ break;
+ }
+ int a1 = prevArray[i1];
+ int a2 = newArray[i2];
+
+ if (a1 == a2) {
+ i1++;
+ i2++;
+ continue;
+ }
+ if (a1 < a2) {
+ // prevArray has an element that's not in a2.
+ return true;
+ }
+ i2++;
+ }
+ if (prevFinished) {
+ return false;
+ }
+ return newFinished;
+ }
+
+ // Public interface.
+
+ /**
+ * Register a new listener.
+ */
+ public void addListener(@NonNull Listener listener) {
+ synchronized (mLock) {
+ mListeners.add(listener);
+ }
+ }
+
+ /**
+ * @return whether alarms should be restricted for a UID package-name.
+ */
+ public boolean areAlarmsRestricted(int uid, @NonNull String packageName,
+ boolean allowWhileIdle) {
+ return isRestricted(uid, packageName, /*useTempWhitelistToo=*/ false,
+ /* exemptOnBatterySaver =*/ allowWhileIdle);
+ }
+
+ /**
+ * @return whether jobs should be restricted for a UID package-name.
+ */
+ public boolean areJobsRestricted(int uid, @NonNull String packageName,
+ boolean hasForegroundExemption) {
+ return isRestricted(uid, packageName, /*useTempWhitelistToo=*/ true,
+ hasForegroundExemption);
+ }
+
+ /**
+ * @return whether force-app-standby is effective for a UID package-name.
+ */
+ private boolean isRestricted(int uid, @NonNull String packageName,
+ boolean useTempWhitelistToo, boolean exemptOnBatterySaver) {
+ if (isUidActive(uid)) {
+ return false;
+ }
+ synchronized (mLock) {
+ // Whitelisted?
+ final int appId = UserHandle.getAppId(uid);
+ if (ArrayUtils.contains(mPowerWhitelistedAllAppIds, appId)) {
+ return false;
+ }
+ if (useTempWhitelistToo &&
+ ArrayUtils.contains(mTempWhitelistedAppIds, appId)) {
+ return false;
+ }
+ if (mForcedAppStandbyEnabled && isRunAnyRestrictedLocked(uid, packageName)) {
+ return true;
+ }
+ if (exemptOnBatterySaver) {
+ return false;
+ }
+ final int userId = UserHandle.getUserId(uid);
+ if (mExemptedPackages.contains(userId, packageName)) {
+ return false;
+ }
+ return mForceAllAppsStandby;
+ }
+ }
+
+ /**
+ * @return whether a UID is in active or not *based on cached information.*
+ *
+ * Note this information is based on the UID proc state callback, meaning it's updated
+ * asynchronously and may subtly be stale. If the fresh data is needed, use
+ * {@link #isUidActiveSynced} instead.
+ */
+ public boolean isUidActive(int uid) {
+ if (UserHandle.isCore(uid)) {
+ return true;
+ }
+ synchronized (mLock) {
+ return mActiveUids.get(uid);
+ }
+ }
+
+ /**
+ * @return whether a UID is in active or not *right now.*
+ *
+ * This gives the fresh information, but may access the activity manager so is slower.
+ */
+ public boolean isUidActiveSynced(int uid) {
+ if (isUidActive(uid)) { // Use the cached one first.
+ return true;
+ }
+ final long start = mStatLogger.getTime();
+
+ final boolean ret = mActivityManagerInternal.isUidActive(uid);
+ mStatLogger.logDurationStat(Stats.IS_UID_ACTIVE_RAW, start);
+
+ return ret;
+ }
+
+ /**
+ * @return whether a UID is in the foreground or not.
+ *
+ * Note this information is based on the UID proc state callback, meaning it's updated
+ * asynchronously and may subtly be stale. If the fresh data is needed, use
+ * {@link ActivityManagerInternal#getUidProcessState} instead.
+ */
+ public boolean isUidInForeground(int uid) {
+ if (UserHandle.isCore(uid)) {
+ return true;
+ }
+ synchronized (mLock) {
+ return mForegroundUids.get(uid);
+ }
+ }
+
+ /**
+ * @return whether force all apps standby is enabled or not.
+ *
+ */
+ boolean isForceAllAppsStandbyEnabled() {
+ synchronized (mLock) {
+ return mForceAllAppsStandby;
+ }
+ }
+
+ /**
+ * @return whether a UID/package has {@code OP_RUN_ANY_IN_BACKGROUND} allowed or not.
+ *
+ * Note clients normally shouldn't need to access it. It's only for dumpsys.
+ */
+ public boolean isRunAnyInBackgroundAppOpsAllowed(int uid, @NonNull String packageName) {
+ synchronized (mLock) {
+ return !isRunAnyRestrictedLocked(uid, packageName);
+ }
+ }
+
+ /**
+ * @return whether a UID is in the user / system defined power-save whitelist or not.
+ *
+ * Note clients normally shouldn't need to access it. It's only for dumpsys.
+ */
+ public boolean isUidPowerSaveWhitelisted(int uid) {
+ synchronized (mLock) {
+ return ArrayUtils.contains(mPowerWhitelistedAllAppIds, UserHandle.getAppId(uid));
+ }
+ }
+
+ /**
+ * @return whether a UID is in the temp power-save whitelist or not.
+ *
+ * Note clients normally shouldn't need to access it. It's only for dumpsys.
+ */
+ public boolean isUidTempPowerSaveWhitelisted(int uid) {
+ synchronized (mLock) {
+ return ArrayUtils.contains(mTempWhitelistedAppIds, UserHandle.getAppId(uid));
+ }
+ }
+
+ public void dump(PrintWriter pw, String indent) {
+ synchronized (mLock) {
+ pw.print(indent);
+ pw.println("Forced App Standby Feature enabled: " + mForcedAppStandbyEnabled);
+
+ pw.print(indent);
+ pw.print("Force all apps standby: ");
+ pw.println(isForceAllAppsStandbyEnabled());
+
+ pw.print(indent);
+ pw.print("Small Battery Device: ");
+ pw.println(isSmallBatteryDevice());
+
+ pw.print(indent);
+ pw.print("Force all apps standby for small battery device: ");
+ pw.println(mForceAllAppStandbyForSmallBattery);
+
+ pw.print(indent);
+ pw.print("Plugged In: ");
+ pw.println(mIsPluggedIn);
+
+ pw.print(indent);
+ pw.print("Active uids: ");
+ dumpUids(pw, mActiveUids);
+
+ pw.print(indent);
+ pw.print("Foreground uids: ");
+ dumpUids(pw, mForegroundUids);
+
+ pw.print(indent);
+ pw.print("Whitelist appids: ");
+ pw.println(Arrays.toString(mPowerWhitelistedAllAppIds));
+
+ pw.print(indent);
+ pw.print("Temp whitelist appids: ");
+ pw.println(Arrays.toString(mTempWhitelistedAppIds));
+
+ pw.print(indent);
+ pw.println("Exempted packages:");
+ for (int i = 0; i < mExemptedPackages.size(); i++) {
+ pw.print(indent);
+ pw.print(" User ");
+ pw.print(mExemptedPackages.keyAt(i));
+ pw.println();
+
+ for (int j = 0; j < mExemptedPackages.sizeAt(i); j++) {
+ pw.print(indent);
+ pw.print(" ");
+ pw.print(mExemptedPackages.valueAt(i, j));
+ pw.println();
+ }
+ }
+ pw.println();
+
+ pw.print(indent);
+ pw.println("Restricted packages:");
+ for (Pair<Integer, String> uidAndPackage : mRunAnyRestrictedPackages) {
+ pw.print(indent);
+ pw.print(" ");
+ pw.print(UserHandle.formatUid(uidAndPackage.first));
+ pw.print(" ");
+ pw.print(uidAndPackage.second);
+ pw.println();
+ }
+
+ mStatLogger.dump(pw, indent);
+ }
+ }
+
+ private void dumpUids(PrintWriter pw, SparseBooleanArray array) {
+ pw.print("[");
+
+ String sep = "";
+ for (int i = 0; i < array.size(); i++) {
+ if (array.valueAt(i)) {
+ pw.print(sep);
+ pw.print(UserHandle.formatUid(array.keyAt(i)));
+ sep = " ";
+ }
+ }
+ pw.println("]");
+ }
+
+ public void dumpProto(ProtoOutputStream proto, long fieldId) {
+ synchronized (mLock) {
+ final long token = proto.start(fieldId);
+
+ proto.write(ForceAppStandbyTrackerProto.FORCE_ALL_APPS_STANDBY, mForceAllAppsStandby);
+ proto.write(ForceAppStandbyTrackerProto.IS_SMALL_BATTERY_DEVICE,
+ isSmallBatteryDevice());
+ proto.write(ForceAppStandbyTrackerProto.FORCE_ALL_APPS_STANDBY_FOR_SMALL_BATTERY,
+ mForceAllAppStandbyForSmallBattery);
+ proto.write(ForceAppStandbyTrackerProto.IS_PLUGGED_IN, mIsPluggedIn);
+
+ for (int i = 0; i < mActiveUids.size(); i++) {
+ if (mActiveUids.valueAt(i)) {
+ proto.write(ForceAppStandbyTrackerProto.ACTIVE_UIDS,
+ mActiveUids.keyAt(i));
+ }
+ }
+
+ for (int i = 0; i < mForegroundUids.size(); i++) {
+ if (mForegroundUids.valueAt(i)) {
+ proto.write(ForceAppStandbyTrackerProto.FOREGROUND_UIDS,
+ mForegroundUids.keyAt(i));
+ }
+ }
+
+ for (int appId : mPowerWhitelistedAllAppIds) {
+ proto.write(ForceAppStandbyTrackerProto.POWER_SAVE_WHITELIST_APP_IDS, appId);
+ }
+
+ for (int appId : mTempWhitelistedAppIds) {
+ proto.write(ForceAppStandbyTrackerProto.TEMP_POWER_SAVE_WHITELIST_APP_IDS, appId);
+ }
+
+ for (int i = 0; i < mExemptedPackages.size(); i++) {
+ for (int j = 0; j < mExemptedPackages.sizeAt(i); j++) {
+ final long token2 = proto.start(
+ ForceAppStandbyTrackerProto.EXEMPTED_PACKAGES);
+
+ proto.write(ExemptedPackage.USER_ID, mExemptedPackages.keyAt(i));
+ proto.write(ExemptedPackage.PACKAGE_NAME, mExemptedPackages.valueAt(i, j));
+
+ proto.end(token2);
+ }
+ }
+
+ for (Pair<Integer, String> uidAndPackage : mRunAnyRestrictedPackages) {
+ final long token2 = proto.start(
+ ForceAppStandbyTrackerProto.RUN_ANY_IN_BACKGROUND_RESTRICTED_PACKAGES);
+ proto.write(RunAnyInBackgroundRestrictedPackages.UID, uidAndPackage.first);
+ proto.write(RunAnyInBackgroundRestrictedPackages.PACKAGE_NAME,
+ uidAndPackage.second);
+ proto.end(token2);
+ }
+
+ mStatLogger.dumpProto(proto, ForceAppStandbyTrackerProto.STATS);
+
+ proto.end(token);
+ }
+ }
+}