services/core/java/com/android/server/ForceAppStandbyTracker.java

/*
 * 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.annotation.Nullable;
import android.app.ActivityManager;
import android.app.AppOpsManager;
import android.app.AppOpsManager.PackageOps;
import android.app.IUidObserver;
import android.content.Context;
import android.os.Handler;
import android.os.PowerManager.ServiceType;
import android.os.PowerManagerInternal;
import android.os.RemoteException;
import android.os.ServiceManager;
import android.os.UserHandle;
import android.util.ArraySet;
import android.util.Pair;
import android.util.Slog;
import android.util.SparseBooleanArray;

import com.android.internal.annotations.GuardedBy;
import com.android.internal.app.IAppOpsCallback;
import com.android.internal.app.IAppOpsService;
import com.android.internal.util.Preconditions;

import java.util.List;

/**
 * Class to track OP_RUN_ANY_IN_BACKGROUND, UID foreground state and "force all app standby".
 *
 * TODO Clean up cache when a user is deleted.
 * TODO Add unit tests. b/68769804.
 */
public class ForceAppStandbyTracker {
    private static final String TAG = "ForceAppStandbyTracker";

    @GuardedBy("ForceAppStandbyTracker.class")
    private static ForceAppStandbyTracker sInstance;

    private final Object mLock = new Object();
    private final Context mContext;

    AppOpsManager mAppOpsManager;
    IAppOpsService mAppOpsService;
    PowerManagerInternal mPowerManagerInternal;

    private final Handler mCallbackHandler;

    /**
     * Pair of (uid (not user-id), packageName) with OP_RUN_ANY_IN_BACKGROUND *not* allowed.
     */
    @GuardedBy("mLock")
    final ArraySet<Pair<Integer, String>> mForcedAppStandbyUidPackages = new ArraySet<>();

    @GuardedBy("mLock")
    final SparseBooleanArray mForegroundUids = new SparseBooleanArray();

    @GuardedBy("mLock")
    final ArraySet<Listener> mListeners = new ArraySet<>();

    @GuardedBy("mLock")
    boolean mStarted;

    @GuardedBy("mLock")
    boolean mForceAllAppsStandby;

    public static abstract class Listener {
        public void onRestrictionChanged(int uid, @Nullable String packageName) {
        }

        public void onGlobalRestrictionChanged() {
        }
    }

    private ForceAppStandbyTracker(Context context) {
        mContext = context;
        mCallbackHandler = FgThread.getHandler();
    }

    /**
     * Get the singleton instance.
     */
    public static synchronized ForceAppStandbyTracker getInstance(Context context) {
        if (sInstance == null) {
            sInstance = new ForceAppStandbyTracker(context);
        }
        return sInstance;
    }

    /**
     * Call it when the system is ready.
     */
    public void start() {
        synchronized (mLock) {
            if (mStarted) {
                return;
            }
            mStarted = true;

            mAppOpsManager = Preconditions.checkNotNull(
                    mContext.getSystemService(AppOpsManager.class));
            mAppOpsService = Preconditions.checkNotNull(
                    IAppOpsService.Stub.asInterface(
                            ServiceManager.getService(Context.APP_OPS_SERVICE)));
            mPowerManagerInternal = Preconditions.checkNotNull(
                    LocalServices.getService(PowerManagerInternal.class));

            try {
                ActivityManager.getService().registerUidObserver(new UidObserver(),
                        ActivityManager.UID_OBSERVER_GONE | ActivityManager.UID_OBSERVER_IDLE
                                | ActivityManager.UID_OBSERVER_ACTIVE,
                        ActivityManager.PROCESS_STATE_UNKNOWN, null);
                mAppOpsService.startWatchingMode(AppOpsManager.OP_RUN_ANY_IN_BACKGROUND, null,
                        new AppOpsWatcher());
            } catch (RemoteException e) {
                // shouldn't happen.
            }

            mPowerManagerInternal.registerLowPowerModeObserver(
                    ServiceType.FORCE_ALL_APPS_STANDBY,
                    state -> updateForceAllAppsStandby(state.batterySaverEnabled));

            updateForceAllAppsStandby(
                    mPowerManagerInternal.getLowPowerState(ServiceType.FORCE_ALL_APPS_STANDBY)
                            .batterySaverEnabled);

            refreshForcedAppStandbyUidPackagesLocked();
        }
    }

    /**
     * Update {@link #mForcedAppStandbyUidPackages} with the current app ops state.
     */
    private void refreshForcedAppStandbyUidPackagesLocked() {
        final int op = AppOpsManager.OP_RUN_ANY_IN_BACKGROUND;

        mForcedAppStandbyUidPackages.clear();
        final List<PackageOps> ops = mAppOpsManager.getPackagesForOps(new int[] {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() != op) {
                    continue;
                }
                if (ent.getMode() != AppOpsManager.MODE_ALLOWED) {
                    mForcedAppStandbyUidPackages.add(Pair.create(
                            pkg.getUid(), pkg.getPackageName()));
                }
            }
        }
    }

    boolean isRunAnyInBackgroundAppOpRestricted(int uid, @NonNull String packageName) {
        try {
            return mAppOpsService.checkOperation(AppOpsManager.OP_RUN_ANY_IN_BACKGROUND,
                    uid, packageName) != AppOpsManager.MODE_ALLOWED;
        } catch (RemoteException e) {
            return false; // shouldn't happen.
        }
    }

    private int findForcedAppStandbyUidPackageIndexLocked(int uid, @NonNull String packageName) {
        // TODO Maybe we should switch to indexOf(Pair.create()) if the array size is too big.
        final int size = mForcedAppStandbyUidPackages.size();
        for (int i = 0; i < size; i++) {
            final Pair<Integer, String> pair = mForcedAppStandbyUidPackages.valueAt(i);

            if ((pair.first == uid) && packageName.equals(pair.second)) {
                return i;
            }
        }
        return -1;
    }

    /**
     * @return whether a uid package-name pair is in mForcedAppStandbyUidPackages.
     */
    boolean isUidPackageRestrictedLocked(int uid, @NonNull String packageName) {
        return findForcedAppStandbyUidPackageIndexLocked(uid, packageName) >= 0;
    }

    boolean updateRestrictedUidPackageLocked(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) {
            mForcedAppStandbyUidPackages.add(Pair.create(uid, packageName));
        } else {
            mForcedAppStandbyUidPackages.removeAt(index);
        }
        return true;
    }

    void uidToForeground(int uid) {
        synchronized (mLock) {
            if (!UserHandle.isApp(uid)) {
                return;
            }
            // TODO This can be optimized by calling indexOfKey and sharing the index for get and
            // put.
            if (mForegroundUids.get(uid)) {
                return;
            }
            mForegroundUids.put(uid, true);
            notifyForUidPackage(uid, null);
        }
    }

    void uidToBackground(int uid, boolean remove) {
        synchronized (mLock) {
            if (!UserHandle.isApp(uid)) {
                return;
            }
            // TODO This can be optimized by calling indexOfKey and sharing the index for get and
            // put.
            if (!mForegroundUids.get(uid)) {
                return;
            }
            if (remove) {
                mForegroundUids.delete(uid);
            } else {
                mForegroundUids.put(uid, false);
            }
            notifyForUidPackage(uid, null);
        }
    }

    // Event handlers

    final class UidObserver extends IUidObserver.Stub {
        @Override public void onUidStateChanged(int uid, int procState, long procStateSeq) {
        }

        @Override public void onUidGone(int uid, boolean disabled) {
            uidToBackground(uid, /*remove=*/ true);
        }

        @Override public void onUidActive(int uid) {
            uidToForeground(uid);
        }

        @Override public void onUidIdle(int uid, boolean disabled) {
            // Just to avoid excessive memcpy, don't remove from the array in this case.
            uidToBackground(uid, /*remove=*/ false);
        }

        @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 {
            synchronized (mLock) {
                final boolean restricted = isRunAnyInBackgroundAppOpRestricted(uid, packageName);

                if (updateRestrictedUidPackageLocked(uid, packageName, restricted)) {
                    notifyForUidPackage(uid, packageName);
                }
            }
        }
    }

    private Listener[] cloneListeners() {
        synchronized (mLock) {
            return mListeners.toArray(new Listener[mListeners.size()]);
        }
    }

    void notifyForUidPackage(int uid, String packageName) {
        mCallbackHandler.post(() -> {
            for (Listener l : cloneListeners()) {
                l.onRestrictionChanged(uid, packageName);
            }
        });
    }

    void notifyGlobal() {
        mCallbackHandler.post(() -> {
            for (Listener l : cloneListeners()) {
                l.onGlobalRestrictionChanged();
            }
        });
    }

    void updateForceAllAppsStandby(boolean forceAllAppsStandby) {
        synchronized (mLock) {
            if (mForceAllAppsStandby == forceAllAppsStandby) {
                return;
            }
            mForceAllAppsStandby = forceAllAppsStandby;
            Slog.i(TAG, "Force all app standby: " + mForceAllAppsStandby);
            notifyGlobal();
        }
    }

    // Public interface.

    /**
     * Register a new listener.
     */
    public void addListener(@NonNull Listener listener) {
        synchronized (mLock) {
            mListeners.add(listener);
        }
    }

    /**
     * Whether force-app-standby is effective for a UID package-name.
     */
    public boolean isRestricted(int uid, @NonNull String packageName) {
        if (isInForeground(uid)) {
            return false;
        }
        synchronized (mLock) {
            if (mForceAllAppsStandby) {
                return true;
            }
            return isUidPackageRestrictedLocked(uid, packageName);
        }
    }

    /** For dumpsys -- otherwise the callers don't need to know it. */
    public boolean isInForeground(int uid) {
        if (!UserHandle.isApp(uid)) {
            return true;
        }
        synchronized (mLock) {
            return mForegroundUids.get(uid);
        }
    }

    /** For dumpsys -- otherwise the callers don't need to know it. */
    public boolean isForceAllAppsStandbyEnabled() {
        synchronized (mLock) {
            return mForceAllAppsStandby;
        }
    }

    /** For dumpsys -- otherwise the callers don't need to know it. */
    public boolean isRunAnyInBackgroundAppOpsAllowed(int uid, @NonNull String packageName) {
        synchronized (mLock) {
            return !isUidPackageRestrictedLocked(uid, packageName);
        }
    }

    /** For dumpsys -- otherwise the callers don't need to know it. */
    public SparseBooleanArray getForegroudUids() {
        synchronized (mLock) {
            return mForegroundUids.clone();
        }
    }

    /** For dumpsys -- otherwise the callers don't need to know it. */
    public ArraySet<Pair<Integer, String>> getRestrictedUidPackages() {
        synchronized (mLock) {
            return new ArraySet(mForcedAppStandbyUidPackages);
        }
    }
}