android/car/SystemActivityMonitoringService.java

/*
 * Copyright (C) 2016 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.car;

import static com.android.car.pm.CarPackageManagerService.BLOCKING_INTENT_EXTRA_DISPLAY_ID;

import android.app.ActivityManager;
import android.app.ActivityOptions;
import android.app.ActivityTaskManager.RootTaskInfo;
import android.app.IActivityManager;
import android.app.IProcessObserver;
import android.app.TaskStackListener;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper;
import android.os.Message;
import android.os.RemoteException;
import android.os.UserHandle;
import android.util.ArrayMap;
import android.util.ArraySet;
import android.util.IndentingPrintWriter;
import android.util.Log;
import android.util.Pair;
import android.util.Slog;
import android.util.SparseArray;
import android.view.Display;

import com.android.internal.annotations.GuardedBy;

import java.lang.ref.WeakReference;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;

/**
 * Service to monitor AMS for new Activity or Service launching.
 */
public class SystemActivityMonitoringService implements CarServiceBase {

    /**
     * Container to hold info on top task in an Activity stack
     */
    public static class TopTaskInfoContainer {
        public final ComponentName topActivity;
        public final int taskId;
        public final int displayId;
        public final int position;
        public final RootTaskInfo taskInfo;

        private TopTaskInfoContainer(ComponentName topActivity, int taskId,
                int displayId, int position, RootTaskInfo taskInfo) {
            this.topActivity = topActivity;
            this.taskId = taskId;
            this.displayId = displayId;
            this.position = position;
            this.taskInfo = taskInfo;
        }

        public boolean isMatching(TopTaskInfoContainer taskInfo) {
            return taskInfo != null
                    && Objects.equals(this.topActivity, taskInfo.topActivity)
                    && this.taskId == taskInfo.taskId
                    && this.displayId == taskInfo.displayId
                    && this.position == taskInfo.position
                    && this.taskInfo.userId == taskInfo.taskInfo.userId;
        }

        @Override
        public String toString() {
            return String.format(
                    "TaskInfoContainer [topActivity=%s, taskId=%d, stackId=%d, userId=%d, "
                    + "displayId=%d, position=%d",
                  topActivity, taskId, taskInfo.taskId, taskInfo.userId, displayId, position);
        }
    }

    public interface ActivityLaunchListener {
        /**
         * Notify launch of activity.
         * @param topTask Task information for what is currently launched.
         */
        void onActivityLaunch(TopTaskInfoContainer topTask);
    }

    private static final int INVALID_STACK_ID = -1;
    private final Context mContext;
    private final IActivityManager mAm;
    private final ProcessObserver mProcessObserver;
    private final TaskListener mTaskListener;

    private final HandlerThread mMonitorHandlerThread = CarServiceUtils.getHandlerThread(
            getClass().getSimpleName());
    private final ActivityMonitorHandler mHandler = new ActivityMonitorHandler(
            mMonitorHandlerThread.getLooper(), this);

    private final Object mLock = new Object();

    /** K: display id, V: top task */
    @GuardedBy("mLock")
    private final SparseArray<TopTaskInfoContainer> mTopTasks = new SparseArray<>();
    /** K: uid, V : list of pid */
    @GuardedBy("mLock")
    private final Map<Integer, Set<Integer>> mForegroundUidPids = new ArrayMap<>();
    @GuardedBy("mLock")
    private ActivityLaunchListener mActivityLaunchListener;

    public SystemActivityMonitoringService(Context context) {
        mContext = context;
        mProcessObserver = new ProcessObserver();
        mTaskListener = new TaskListener();
        mAm = ActivityManager.getService();
    }

    @Override
    public void init() {
        // Monitoring both listeners are necessary as there are cases where one listener cannot
        // monitor activity change.
        try {
            mAm.registerProcessObserver(mProcessObserver);
            mAm.registerTaskStackListener(mTaskListener);
        } catch (RemoteException e) {
            Slog.e(CarLog.TAG_AM, "cannot register activity monitoring", e);
            throw new RuntimeException(e);
        }
        updateTasks();
    }

    @Override
    public void release() {
        try {
            mAm.unregisterProcessObserver(mProcessObserver);
            mAm.unregisterTaskStackListener(mTaskListener);
        } catch (RemoteException e) {
            Slog.e(CarLog.TAG_AM, "Failed to unregister listeners", e);
        }
    }

    @Override
    public void dump(IndentingPrintWriter writer) {
        writer.println("*SystemActivityMonitoringService*");
        writer.println(" Top Tasks per display:");
        synchronized (mLock) {
            for (int i = 0; i < mTopTasks.size(); i++) {
                int displayId = mTopTasks.keyAt(i);
                TopTaskInfoContainer info = mTopTasks.valueAt(i);
                if (info != null) {
                    writer.println("display id " + displayId + ": " + info);
                }
            }
            writer.println(" Foreground uid-pids:");
            for (Integer key : mForegroundUidPids.keySet()) {
                Set<Integer> pids = mForegroundUidPids.get(key);
                if (pids == null) {
                    continue;
                }
                writer.println("uid:" + key + ", pids:" + Arrays.toString(pids.toArray()));
            }
        }
    }

    /**
     * Block the current task: Launch new activity with given Intent and finish the current task.
     * @param currentTask task to finish
     * @param newActivityIntent Intent for new Activity
     */
    public void blockActivity(TopTaskInfoContainer currentTask, Intent newActivityIntent) {
        mHandler.requestBlockActivity(currentTask, newActivityIntent);
    }

    public List<TopTaskInfoContainer> getTopTasks() {
        LinkedList<TopTaskInfoContainer> tasks = new LinkedList<>();
        synchronized (mLock) {
            for (int i = 0; i < mTopTasks.size(); i++) {
                TopTaskInfoContainer topTask = mTopTasks.valueAt(i);
                if (topTask == null) {
                    Slog.e(CarLog.TAG_AM, "Top tasks contains null. Full content is: "
                            + mTopTasks.toString());
                    continue;
                }
                tasks.add(topTask);
            }
        }
        return tasks;
    }

    public boolean isInForeground(int pid, int uid) {
        synchronized (mLock) {
            Set<Integer> pids = mForegroundUidPids.get(uid);
            if (pids == null) {
                return false;
            }
            if (pids.contains(pid)) {
                return true;
            }
        }
        return false;
    }

    /**
     * Attempts to restart a task.
     *
     * <p>Restarts a task by sending an empty intent with flag
     * {@link Intent#FLAG_ACTIVITY_CLEAR_TASK} to its root activity. If the task does not exist,
     * do nothing.
     *
     * @param taskId id of task to be restarted.
     */
    public void restartTask(int taskId) {
        String rootActivityName = null;
        int userId = 0;
        try {
            findRootActivityName:
            for (RootTaskInfo info : mAm.getAllRootTaskInfos()) {
                for (int i = 0; i < info.childTaskIds.length; i++) {
                    if (info.childTaskIds[i] == taskId) {
                        rootActivityName = info.childTaskNames[i];
                        userId = info.userId;
                        if (Log.isLoggable(CarLog.TAG_AM, Log.DEBUG)) {
                            Slog.d(CarLog.TAG_AM, "Root activity is " + rootActivityName);
                            Slog.d(CarLog.TAG_AM, "User id is " + userId);
                        }
                        // Break out of nested loop.
                        break findRootActivityName;
                    }
                }
            }
        } catch (RemoteException e) {
            Slog.e(CarLog.TAG_AM, "Could not get stack info", e);
            return;
        }

        if (rootActivityName == null) {
            Slog.e(CarLog.TAG_AM, "Could not find root activity with task id " + taskId);
            return;
        }

        Intent rootActivityIntent = new Intent();
        rootActivityIntent.setComponent(ComponentName.unflattenFromString(rootActivityName));
        // Clear the task the root activity is running in and start it in a new task.
        // Effectively restart root activity.
        rootActivityIntent.addFlags(
                Intent.FLAG_ACTIVITY_CLEAR_TASK | Intent.FLAG_ACTIVITY_NEW_TASK);

        if (Log.isLoggable(CarLog.TAG_AM, Log.INFO)) {
            Slog.i(CarLog.TAG_AM, "restarting root activity with user id " + userId);
        }
        mContext.startActivityAsUser(rootActivityIntent, new UserHandle(userId));
    }

    public void registerActivityLaunchListener(ActivityLaunchListener listener) {
        synchronized (mLock) {
            mActivityLaunchListener = listener;
        }
    }

    private void updateTasks() {
        List<RootTaskInfo> infos;
        try {
            infos = mAm.getAllRootTaskInfos();
        } catch (RemoteException e) {
            Slog.e(CarLog.TAG_AM, "cannot getTasks", e);
            return;
        }

        if (infos == null) {
            return;
        }

        int focusedStackId = INVALID_STACK_ID;
        try {
            // TODO(b/66955160): Someone on the Auto-team should probably re-work the code in the
            // synchronized block below based on this new API.
            final RootTaskInfo focusedTaskInfo = mAm.getFocusedRootTaskInfo();
            if (focusedTaskInfo != null) {
                focusedStackId = focusedTaskInfo.taskId;
            }
        } catch (RemoteException e) {
            Slog.e(CarLog.TAG_AM, "cannot getFocusedStackId", e);
            return;
        }

        SparseArray<TopTaskInfoContainer> topTasks = new SparseArray<>();
        ActivityLaunchListener listener;
        synchronized (mLock) {
            mTopTasks.clear();
            listener = mActivityLaunchListener;

            for (RootTaskInfo info : infos) {
                int displayId = info.displayId;
                if (info.childTaskNames.length == 0
                        || !info.visible) { // empty stack or not shown
                    continue;
                }
                TopTaskInfoContainer newTopTaskInfo = new TopTaskInfoContainer(
                        info.topActivity, info.childTaskIds[info.childTaskIds.length - 1],
                        info.displayId, info.position, info);
                TopTaskInfoContainer currentTopTaskInfo = topTasks.get(displayId);

                if (currentTopTaskInfo == null ||
                        newTopTaskInfo.position > currentTopTaskInfo.position) {
                    topTasks.put(displayId, newTopTaskInfo);
                    if (Log.isLoggable(CarLog.TAG_AM, Log.INFO)) {
                        Slog.i(CarLog.TAG_AM, "Updating top task to: " + newTopTaskInfo);
                    }
                }
            }
            // Assuming displays remains the same.
            for (int i = 0; i < topTasks.size(); i++) {
                TopTaskInfoContainer topTask = topTasks.valueAt(i);

                int displayId = topTasks.keyAt(i);
                mTopTasks.put(displayId, topTask);
            }
        }
        if (listener != null) {
            for (int i = 0; i < topTasks.size(); i++) {
                TopTaskInfoContainer topTask = topTasks.valueAt(i);

                if (Log.isLoggable(CarLog.TAG_AM, Log.INFO)) {
                    Slog.i(CarLog.TAG_AM, "Notifying about top task: " + topTask.toString());
                }
                listener.onActivityLaunch(topTask);
            }
        }
    }

    public RootTaskInfo getFocusedStackForTopActivity(ComponentName activity) {
        RootTaskInfo focusedStack;
        try {
            focusedStack = mAm.getFocusedRootTaskInfo();
        } catch (RemoteException e) {
            Slog.e(CarLog.TAG_AM, "cannot getFocusedStackId", e);
            return null;
        }
        if (focusedStack.childTaskNames.length == 0) { // nothing in focused stack
            return null;
        }
        ComponentName topActivity = ComponentName.unflattenFromString(
                focusedStack.childTaskNames[focusedStack.childTaskNames.length - 1]);
        if (topActivity.equals(activity)) {
            return focusedStack;
        } else {
            return null;
        }
    }

    private void handleForegroundActivitiesChanged(int pid, int uid, boolean foregroundActivities) {
        synchronized (mLock) {
            if (foregroundActivities) {
                Set<Integer> pids = mForegroundUidPids.get(uid);
                if (pids == null) {
                    pids = new ArraySet<Integer>();
                    mForegroundUidPids.put(uid, pids);
                }
                pids.add(pid);
            } else {
                doHandlePidGoneLocked(pid, uid);
            }
        }
    }

    private void handleProcessDied(int pid, int uid) {
        synchronized (mLock) {
            doHandlePidGoneLocked(pid, uid);
        }
    }

    private void doHandlePidGoneLocked(int pid, int uid) {
        Set<Integer> pids = mForegroundUidPids.get(uid);
        if (pids != null) {
            pids.remove(pid);
            if (pids.isEmpty()) {
                mForegroundUidPids.remove(uid);
            }
        }
    }

    /**
     * block the current task with the provided new activity.
     */
    private void handleBlockActivity(TopTaskInfoContainer currentTask, Intent newActivityIntent) {
        int displayId = newActivityIntent.getIntExtra(BLOCKING_INTENT_EXTRA_DISPLAY_ID,
                Display.DEFAULT_DISPLAY);
        if (Log.isLoggable(CarLog.TAG_AM, Log.DEBUG)) {
            Slog.d(CarLog.TAG_AM, "Launching blocking activity on display: " + displayId);
        }

        ActivityOptions options = ActivityOptions.makeBasic();
        options.setLaunchDisplayId(displayId);
        mContext.startActivityAsUser(newActivityIntent, options.toBundle(),
                new UserHandle(currentTask.taskInfo.userId));
        // Now make stack with new activity focused.
        findTaskAndGrantFocus(newActivityIntent.getComponent());
    }

    private void findTaskAndGrantFocus(ComponentName activity) {
        List<RootTaskInfo> infos;
        try {
            infos = mAm.getAllRootTaskInfos();
        } catch (RemoteException e) {
            Slog.e(CarLog.TAG_AM, "cannot getTasks", e);
            return;
        }
        for (RootTaskInfo info : infos) {
            if (info.childTaskNames.length == 0) {
                continue;
            }
            ComponentName topActivity = ComponentName.unflattenFromString(
                    info.childTaskNames[info.childTaskNames.length - 1]);
            if (activity.equals(topActivity)) {
                try {
                    mAm.setFocusedRootTask(info.taskId);
                } catch (RemoteException e) {
                    Slog.e(CarLog.TAG_AM, "cannot setFocusedRootTask to task:" + info.taskId, e);
                }
                return;
            }
        }
        Slog.i(CarLog.TAG_AM, "cannot give focus, cannot find Activity:" + activity);
    }

    private class ProcessObserver extends IProcessObserver.Stub {
        @Override
        public void onForegroundActivitiesChanged(int pid, int uid, boolean foregroundActivities) {
            if (Log.isLoggable(CarLog.TAG_AM, Log.INFO)) {
                Slog.i(CarLog.TAG_AM,
                        String.format("onForegroundActivitiesChanged uid %d pid %d fg %b",
                    uid, pid, foregroundActivities));
            }
            mHandler.requestForegroundActivitiesChanged(pid, uid, foregroundActivities);
        }

        @Override
        public void onForegroundServicesChanged(int pid, int uid, int fgServiceTypes) {
        }

        @Override
        public void onProcessDied(int pid, int uid) {
            mHandler.requestProcessDied(pid, uid);
        }
    }

    private class TaskListener extends TaskStackListener {
        @Override
        public void onTaskStackChanged() {
            if (Log.isLoggable(CarLog.TAG_AM, Log.INFO)) {
                Slog.i(CarLog.TAG_AM, "onTaskStackChanged");
            }
            mHandler.requestUpdatingTask();
        }
    }

    private static final class ActivityMonitorHandler extends Handler {
        private  static final String TAG = ActivityMonitorHandler.class.getSimpleName();

        private static final int MSG_UPDATE_TASKS = 0;
        private static final int MSG_FOREGROUND_ACTIVITIES_CHANGED = 1;
        private static final int MSG_PROCESS_DIED = 2;
        private static final int MSG_BLOCK_ACTIVITY = 3;

        private final WeakReference<SystemActivityMonitoringService> mService;

        private ActivityMonitorHandler(Looper looper, SystemActivityMonitoringService service) {
            super(looper);
            mService = new WeakReference<SystemActivityMonitoringService>(service);
        }

        private void requestUpdatingTask() {
            Message msg = obtainMessage(MSG_UPDATE_TASKS);
            sendMessage(msg);
        }

        private void requestForegroundActivitiesChanged(int pid, int uid,
                boolean foregroundActivities) {
            Message msg = obtainMessage(MSG_FOREGROUND_ACTIVITIES_CHANGED, pid, uid,
                    Boolean.valueOf(foregroundActivities));
            sendMessage(msg);
        }

        private void requestProcessDied(int pid, int uid) {
            Message msg = obtainMessage(MSG_PROCESS_DIED, pid, uid);
            sendMessage(msg);
        }

        private void requestBlockActivity(TopTaskInfoContainer currentTask,
                Intent newActivityIntent) {
            Message msg = obtainMessage(MSG_BLOCK_ACTIVITY,
                    new Pair<TopTaskInfoContainer, Intent>(currentTask, newActivityIntent));
            sendMessage(msg);
        }

        @Override
        public void handleMessage(Message msg) {
            SystemActivityMonitoringService service = mService.get();
            if (service == null) {
                Slog.i(TAG, "handleMessage null service");
                return;
            }
            switch (msg.what) {
                case MSG_UPDATE_TASKS:
                    service.updateTasks();
                    break;
                case MSG_FOREGROUND_ACTIVITIES_CHANGED:
                    service.handleForegroundActivitiesChanged(msg.arg1, msg.arg2,
                            (Boolean) msg.obj);
                    service.updateTasks();
                    break;
                case MSG_PROCESS_DIED:
                    service.handleProcessDied(msg.arg1, msg.arg2);
                    break;
                case MSG_BLOCK_ACTIVITY:
                    Pair<TopTaskInfoContainer, Intent> pair =
                        (Pair<TopTaskInfoContainer, Intent>) msg.obj;
                    service.handleBlockActivity(pair.first, pair.second);
                    break;
            }
        }
    }
}