| /* |
| * 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.IndentingPrintWriter; |
| import com.android.internal.util.Preconditions; |
| import com.android.internal.util.StatLogger; |
| 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. |
| * |
| * Test: |
| atest $ANDROID_BUILD_TOP/frameworks/base/services/tests/servicestests/src/com/android/server/AppStateTrackerTest.java |
| */ |
| public class AppStateTracker { |
| private static final String TAG = "AppStateTracker"; |
| private static final boolean DEBUG = false; |
| |
| 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]; |
| |
| /** |
| * User whitelisted apps in the device idle controller. |
| */ |
| @GuardedBy("mLock") |
| private int[] mPowerWhitelistedUserAppIds = 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, sender.isUidActive(uid)); |
| |
| 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(); |
| } |
| |
| if (!sender.isRunAnyInBackgroundAppOpsAllowed(uid, packageName)) { |
| Slog.v(TAG, "Package " + packageName + "/" + uid |
| + " toggled into fg service restriction"); |
| stopForegroundServicesForUidPackage(uid, packageName); |
| } |
| } |
| |
| /** |
| * 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) { |
| final boolean isActive = sender.isUidActive(uid); |
| |
| updateJobsForUid(uid, isActive); |
| |
| if (isActive) { |
| 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, boolean isNowActive) { |
| } |
| |
| /** |
| * 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, boolean isNowActive) { |
| } |
| |
| /** |
| * Called when an app goes into forced app standby and its foreground |
| * services need to be removed from that state. |
| */ |
| public void stopForegroundServicesForUidPackage(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, int reason) { |
| 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[] powerSaveWhitelistExceptIdleAppIdArray, |
| int[] powerSaveWhitelistUserAppIdArray, |
| int[] tempWhitelistAppIdArray) { |
| synchronized (mLock) { |
| final int[] previousWhitelist = mPowerWhitelistedAllAppIds; |
| final int[] previousTempWhitelist = mTempWhitelistedAppIds; |
| |
| mPowerWhitelistedAllAppIds = powerSaveWhitelistExceptIdleAppIdArray; |
| mTempWhitelistedAppIds = tempWhitelistAppIdArray; |
| mPowerWhitelistedUserAppIds = powerSaveWhitelistUserAppIdArray; |
| |
| 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 isExemptOnBatterySaver) { |
| return isRestricted(uid, packageName, /*useTempWhitelistToo=*/ false, |
| isExemptOnBatterySaver); |
| } |
| |
| /** |
| * @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 foreground services should be suppressed in the background |
| * due to forced app standby for the given app |
| */ |
| public boolean areForegroundServicesRestricted(int uid, @NonNull String packageName) { |
| synchronized (mLock) { |
| return isRunAnyRestrictedLocked(uid, packageName); |
| } |
| } |
| |
| /** |
| * @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)); |
| } |
| } |
| |
| /** |
| * @param uid the uid to check for |
| * @return whether a UID is in the user defined power-save whitelist or not. |
| */ |
| public boolean isUidPowerSaveUserWhitelisted(int uid) { |
| synchronized (mLock) { |
| return ArrayUtils.contains(mPowerWhitelistedUserAppIds, 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)); |
| } |
| } |
| |
| @Deprecated |
| public void dump(PrintWriter pw, String prefix) { |
| dump(new IndentingPrintWriter(pw, " ").setIndent(prefix)); |
| } |
| |
| public void dump(IndentingPrintWriter pw) { |
| synchronized (mLock) { |
| pw.println("Forced App Standby Feature enabled: " + mForcedAppStandbyEnabled); |
| |
| pw.print("Force all apps standby: "); |
| pw.println(isForceAllAppsStandbyEnabled()); |
| |
| pw.print("Small Battery Device: "); |
| pw.println(isSmallBatteryDevice()); |
| |
| pw.print("Force all apps standby for small battery device: "); |
| pw.println(mForceAllAppStandbyForSmallBattery); |
| |
| pw.print("Plugged In: "); |
| pw.println(mIsPluggedIn); |
| |
| pw.print("Active uids: "); |
| dumpUids(pw, mActiveUids); |
| |
| pw.print("Foreground uids: "); |
| dumpUids(pw, mForegroundUids); |
| |
| pw.print("Except-idle + user whitelist appids: "); |
| pw.println(Arrays.toString(mPowerWhitelistedAllAppIds)); |
| |
| pw.print("User whitelist appids: "); |
| pw.println(Arrays.toString(mPowerWhitelistedUserAppIds)); |
| |
| pw.print("Temp whitelist appids: "); |
| pw.println(Arrays.toString(mTempWhitelistedAppIds)); |
| |
| pw.println("Exempted packages:"); |
| pw.increaseIndent(); |
| for (int i = 0; i < mExemptedPackages.size(); i++) { |
| pw.print("User "); |
| pw.print(mExemptedPackages.keyAt(i)); |
| pw.println(); |
| |
| pw.increaseIndent(); |
| for (int j = 0; j < mExemptedPackages.sizeAt(i); j++) { |
| pw.print(mExemptedPackages.valueAt(i, j)); |
| pw.println(); |
| } |
| pw.decreaseIndent(); |
| } |
| pw.decreaseIndent(); |
| pw.println(); |
| |
| pw.println("Restricted packages:"); |
| pw.increaseIndent(); |
| for (Pair<Integer, String> uidAndPackage : mRunAnyRestrictedPackages) { |
| pw.print(UserHandle.formatUid(uidAndPackage.first)); |
| pw.print(" "); |
| pw.print(uidAndPackage.second); |
| pw.println(); |
| } |
| pw.decreaseIndent(); |
| |
| mStatLogger.dump(pw); |
| } |
| } |
| |
| 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 : mPowerWhitelistedUserAppIds) { |
| proto.write(ForceAppStandbyTrackerProto.POWER_SAVE_USER_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); |
| } |
| } |
| } |
