Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2016 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | package com.android.car; |
| 17 | |
Yao, Yuxing | d525de1 | 2019-05-06 15:11:48 -0700 | [diff] [blame] | 18 | import static com.android.car.pm.CarPackageManagerService.BLOCKING_INTENT_EXTRA_DISPLAY_ID; |
| 19 | |
Sudheer Shanka | a4f49aa | 2016-11-10 16:39:13 -0800 | [diff] [blame] | 20 | import android.app.ActivityManager; |
Yao, Yuxing | cfcc59f | 2019-03-05 16:35:47 -0800 | [diff] [blame] | 21 | import android.app.ActivityOptions; |
Louis Chang | 3bf2f20 | 2020-08-18 13:04:28 +0800 | [diff] [blame] | 22 | import android.app.ActivityTaskManager.RootTaskInfo; |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 23 | import android.app.IActivityManager; |
| 24 | import android.app.IProcessObserver; |
Yorke Lee | c1265de | 2016-10-27 11:25:25 -0700 | [diff] [blame] | 25 | import android.app.TaskStackListener; |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 26 | import android.content.ComponentName; |
| 27 | import android.content.Context; |
| 28 | import android.content.Intent; |
| 29 | import android.os.Handler; |
| 30 | import android.os.HandlerThread; |
| 31 | import android.os.Looper; |
| 32 | import android.os.Message; |
| 33 | import android.os.RemoteException; |
| 34 | import android.os.UserHandle; |
Yao Chen | ed8609e | 2016-10-07 09:49:13 -0700 | [diff] [blame] | 35 | import android.util.ArrayMap; |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 36 | import android.util.ArraySet; |
Felipe Leme | 176a5fd | 2021-01-20 15:48:33 -0800 | [diff] [blame] | 37 | import android.util.IndentingPrintWriter; |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 38 | import android.util.Log; |
| 39 | import android.util.Pair; |
Eric Jeong | bd5fb56 | 2020-12-21 13:49:40 -0800 | [diff] [blame] | 40 | import android.util.Slog; |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 41 | import android.util.SparseArray; |
Yao, Yuxing | cfcc59f | 2019-03-05 16:35:47 -0800 | [diff] [blame] | 42 | import android.view.Display; |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 43 | |
Yuncheol Heo | 8b5ab80 | 2020-04-09 12:13:44 -0700 | [diff] [blame] | 44 | import com.android.internal.annotations.GuardedBy; |
| 45 | |
Keun young Park | b241d02 | 2020-04-20 20:31:34 -0700 | [diff] [blame] | 46 | import java.lang.ref.WeakReference; |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 47 | import java.util.Arrays; |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 48 | import java.util.LinkedList; |
| 49 | import java.util.List; |
| 50 | import java.util.Map; |
Yao Chen | ed8609e | 2016-10-07 09:49:13 -0700 | [diff] [blame] | 51 | import java.util.Objects; |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 52 | import java.util.Set; |
| 53 | |
| 54 | /** |
| 55 | * Service to monitor AMS for new Activity or Service launching. |
| 56 | */ |
| 57 | public class SystemActivityMonitoringService implements CarServiceBase { |
| 58 | |
| 59 | /** |
| 60 | * Container to hold info on top task in an Activity stack |
| 61 | */ |
| 62 | public static class TopTaskInfoContainer { |
| 63 | public final ComponentName topActivity; |
| 64 | public final int taskId; |
Yao, Yuxing | cfcc59f | 2019-03-05 16:35:47 -0800 | [diff] [blame] | 65 | public final int displayId; |
Yao, Yuxing | 4ddb2c6 | 2019-02-04 11:26:46 -0800 | [diff] [blame] | 66 | public final int position; |
Louis Chang | 3bf2f20 | 2020-08-18 13:04:28 +0800 | [diff] [blame] | 67 | public final RootTaskInfo taskInfo; |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 68 | |
Yao, Yuxing | 4ddb2c6 | 2019-02-04 11:26:46 -0800 | [diff] [blame] | 69 | private TopTaskInfoContainer(ComponentName topActivity, int taskId, |
Louis Chang | 3bf2f20 | 2020-08-18 13:04:28 +0800 | [diff] [blame] | 70 | int displayId, int position, RootTaskInfo taskInfo) { |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 71 | this.topActivity = topActivity; |
| 72 | this.taskId = taskId; |
Yao, Yuxing | cfcc59f | 2019-03-05 16:35:47 -0800 | [diff] [blame] | 73 | this.displayId = displayId; |
Yao, Yuxing | 4ddb2c6 | 2019-02-04 11:26:46 -0800 | [diff] [blame] | 74 | this.position = position; |
Louis Chang | 3bf2f20 | 2020-08-18 13:04:28 +0800 | [diff] [blame] | 75 | this.taskInfo = taskInfo; |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 76 | } |
| 77 | |
Yao Chen | ed8609e | 2016-10-07 09:49:13 -0700 | [diff] [blame] | 78 | public boolean isMatching(TopTaskInfoContainer taskInfo) { |
| 79 | return taskInfo != null |
| 80 | && Objects.equals(this.topActivity, taskInfo.topActivity) |
| 81 | && this.taskId == taskInfo.taskId |
Yao, Yuxing | cfcc59f | 2019-03-05 16:35:47 -0800 | [diff] [blame] | 82 | && this.displayId == taskInfo.displayId |
Yao, Yuxing | 4ddb2c6 | 2019-02-04 11:26:46 -0800 | [diff] [blame] | 83 | && this.position == taskInfo.position |
Louis Chang | 3bf2f20 | 2020-08-18 13:04:28 +0800 | [diff] [blame] | 84 | && this.taskInfo.userId == taskInfo.taskInfo.userId; |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 85 | } |
| 86 | |
| 87 | @Override |
| 88 | public String toString() { |
| 89 | return String.format( |
Yao, Yuxing | 4ddb2c6 | 2019-02-04 11:26:46 -0800 | [diff] [blame] | 90 | "TaskInfoContainer [topActivity=%s, taskId=%d, stackId=%d, userId=%d, " |
| 91 | + "displayId=%d, position=%d", |
Louis Chang | 3bf2f20 | 2020-08-18 13:04:28 +0800 | [diff] [blame] | 92 | topActivity, taskId, taskInfo.taskId, taskInfo.userId, displayId, position); |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 93 | } |
| 94 | } |
| 95 | |
| 96 | public interface ActivityLaunchListener { |
| 97 | /** |
| 98 | * Notify launch of activity. |
| 99 | * @param topTask Task information for what is currently launched. |
| 100 | */ |
| 101 | void onActivityLaunch(TopTaskInfoContainer topTask); |
| 102 | } |
| 103 | |
Michal Palczewski | 7684dbb | 2018-11-13 18:36:06 -0800 | [diff] [blame] | 104 | private static final int INVALID_STACK_ID = -1; |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 105 | private final Context mContext; |
| 106 | private final IActivityManager mAm; |
| 107 | private final ProcessObserver mProcessObserver; |
| 108 | private final TaskListener mTaskListener; |
| 109 | |
Keun young Park | b241d02 | 2020-04-20 20:31:34 -0700 | [diff] [blame] | 110 | private final HandlerThread mMonitorHandlerThread = CarServiceUtils.getHandlerThread( |
| 111 | getClass().getSimpleName()); |
| 112 | private final ActivityMonitorHandler mHandler = new ActivityMonitorHandler( |
| 113 | mMonitorHandlerThread.getLooper(), this); |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 114 | |
Yuncheol Heo | 8b5ab80 | 2020-04-09 12:13:44 -0700 | [diff] [blame] | 115 | private final Object mLock = new Object(); |
| 116 | |
Yao, Yuxing | d525de1 | 2019-05-06 15:11:48 -0700 | [diff] [blame] | 117 | /** K: display id, V: top task */ |
Yuncheol Heo | 8b5ab80 | 2020-04-09 12:13:44 -0700 | [diff] [blame] | 118 | @GuardedBy("mLock") |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 119 | private final SparseArray<TopTaskInfoContainer> mTopTasks = new SparseArray<>(); |
| 120 | /** K: uid, V : list of pid */ |
Yuncheol Heo | 8b5ab80 | 2020-04-09 12:13:44 -0700 | [diff] [blame] | 121 | @GuardedBy("mLock") |
Yao Chen | ed8609e | 2016-10-07 09:49:13 -0700 | [diff] [blame] | 122 | private final Map<Integer, Set<Integer>> mForegroundUidPids = new ArrayMap<>(); |
Yuncheol Heo | 8b5ab80 | 2020-04-09 12:13:44 -0700 | [diff] [blame] | 123 | @GuardedBy("mLock") |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 124 | private ActivityLaunchListener mActivityLaunchListener; |
| 125 | |
| 126 | public SystemActivityMonitoringService(Context context) { |
| 127 | mContext = context; |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 128 | mProcessObserver = new ProcessObserver(); |
| 129 | mTaskListener = new TaskListener(); |
Sudheer Shanka | a4f49aa | 2016-11-10 16:39:13 -0800 | [diff] [blame] | 130 | mAm = ActivityManager.getService(); |
Yuncheol Heo | b2c7899 | 2020-04-28 16:24:56 -0700 | [diff] [blame] | 131 | } |
| 132 | |
| 133 | @Override |
| 134 | public void init() { |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 135 | // Monitoring both listeners are necessary as there are cases where one listener cannot |
| 136 | // monitor activity change. |
| 137 | try { |
| 138 | mAm.registerProcessObserver(mProcessObserver); |
| 139 | mAm.registerTaskStackListener(mTaskListener); |
| 140 | } catch (RemoteException e) { |
Eric Jeong | bd5fb56 | 2020-12-21 13:49:40 -0800 | [diff] [blame] | 141 | Slog.e(CarLog.TAG_AM, "cannot register activity monitoring", e); |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 142 | throw new RuntimeException(e); |
| 143 | } |
| 144 | updateTasks(); |
| 145 | } |
| 146 | |
| 147 | @Override |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 148 | public void release() { |
Yuncheol Heo | b2c7899 | 2020-04-28 16:24:56 -0700 | [diff] [blame] | 149 | try { |
| 150 | mAm.unregisterProcessObserver(mProcessObserver); |
| 151 | mAm.unregisterTaskStackListener(mTaskListener); |
| 152 | } catch (RemoteException e) { |
Eric Jeong | bd5fb56 | 2020-12-21 13:49:40 -0800 | [diff] [blame] | 153 | Slog.e(CarLog.TAG_AM, "Failed to unregister listeners", e); |
Yuncheol Heo | b2c7899 | 2020-04-28 16:24:56 -0700 | [diff] [blame] | 154 | } |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 155 | } |
| 156 | |
| 157 | @Override |
Felipe Leme | 176a5fd | 2021-01-20 15:48:33 -0800 | [diff] [blame] | 158 | public void dump(IndentingPrintWriter writer) { |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 159 | writer.println("*SystemActivityMonitoringService*"); |
Yao, Yuxing | 4ddb2c6 | 2019-02-04 11:26:46 -0800 | [diff] [blame] | 160 | writer.println(" Top Tasks per display:"); |
Yuncheol Heo | 8b5ab80 | 2020-04-09 12:13:44 -0700 | [diff] [blame] | 161 | synchronized (mLock) { |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 162 | for (int i = 0; i < mTopTasks.size(); i++) { |
Yao, Yuxing | 4ddb2c6 | 2019-02-04 11:26:46 -0800 | [diff] [blame] | 163 | int displayId = mTopTasks.keyAt(i); |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 164 | TopTaskInfoContainer info = mTopTasks.valueAt(i); |
| 165 | if (info != null) { |
Yao, Yuxing | 4ddb2c6 | 2019-02-04 11:26:46 -0800 | [diff] [blame] | 166 | writer.println("display id " + displayId + ": " + info); |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 167 | } |
| 168 | } |
Yao, Yuxing | 4ddb2c6 | 2019-02-04 11:26:46 -0800 | [diff] [blame] | 169 | writer.println(" Foreground uid-pids:"); |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 170 | for (Integer key : mForegroundUidPids.keySet()) { |
| 171 | Set<Integer> pids = mForegroundUidPids.get(key); |
| 172 | if (pids == null) { |
| 173 | continue; |
| 174 | } |
| 175 | writer.println("uid:" + key + ", pids:" + Arrays.toString(pids.toArray())); |
| 176 | } |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 177 | } |
| 178 | } |
| 179 | |
| 180 | /** |
| 181 | * Block the current task: Launch new activity with given Intent and finish the current task. |
| 182 | * @param currentTask task to finish |
| 183 | * @param newActivityIntent Intent for new Activity |
| 184 | */ |
| 185 | public void blockActivity(TopTaskInfoContainer currentTask, Intent newActivityIntent) { |
| 186 | mHandler.requestBlockActivity(currentTask, newActivityIntent); |
| 187 | } |
| 188 | |
| 189 | public List<TopTaskInfoContainer> getTopTasks() { |
| 190 | LinkedList<TopTaskInfoContainer> tasks = new LinkedList<>(); |
Yuncheol Heo | 8b5ab80 | 2020-04-09 12:13:44 -0700 | [diff] [blame] | 191 | synchronized (mLock) { |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 192 | for (int i = 0; i < mTopTasks.size(); i++) { |
Yao, Yuxing | 2646cff | 2019-04-23 17:01:26 -0700 | [diff] [blame] | 193 | TopTaskInfoContainer topTask = mTopTasks.valueAt(i); |
| 194 | if (topTask == null) { |
Eric Jeong | bd5fb56 | 2020-12-21 13:49:40 -0800 | [diff] [blame] | 195 | Slog.e(CarLog.TAG_AM, "Top tasks contains null. Full content is: " |
Yao, Yuxing | 2646cff | 2019-04-23 17:01:26 -0700 | [diff] [blame] | 196 | + mTopTasks.toString()); |
| 197 | continue; |
| 198 | } |
| 199 | tasks.add(topTask); |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 200 | } |
| 201 | } |
| 202 | return tasks; |
| 203 | } |
| 204 | |
| 205 | public boolean isInForeground(int pid, int uid) { |
Yuncheol Heo | 8b5ab80 | 2020-04-09 12:13:44 -0700 | [diff] [blame] | 206 | synchronized (mLock) { |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 207 | Set<Integer> pids = mForegroundUidPids.get(uid); |
| 208 | if (pids == null) { |
| 209 | return false; |
| 210 | } |
| 211 | if (pids.contains(pid)) { |
| 212 | return true; |
| 213 | } |
| 214 | } |
| 215 | return false; |
| 216 | } |
| 217 | |
Yao, Yuxing | d1d6a37 | 2018-05-08 10:37:43 -0700 | [diff] [blame] | 218 | /** |
| 219 | * Attempts to restart a task. |
| 220 | * |
| 221 | * <p>Restarts a task by sending an empty intent with flag |
| 222 | * {@link Intent#FLAG_ACTIVITY_CLEAR_TASK} to its root activity. If the task does not exist, |
| 223 | * do nothing. |
| 224 | * |
| 225 | * @param taskId id of task to be restarted. |
| 226 | */ |
| 227 | public void restartTask(int taskId) { |
| 228 | String rootActivityName = null; |
| 229 | int userId = 0; |
| 230 | try { |
| 231 | findRootActivityName: |
Louis Chang | 3bf2f20 | 2020-08-18 13:04:28 +0800 | [diff] [blame] | 232 | for (RootTaskInfo info : mAm.getAllRootTaskInfos()) { |
| 233 | for (int i = 0; i < info.childTaskIds.length; i++) { |
| 234 | if (info.childTaskIds[i] == taskId) { |
| 235 | rootActivityName = info.childTaskNames[i]; |
Yao, Yuxing | d1d6a37 | 2018-05-08 10:37:43 -0700 | [diff] [blame] | 236 | userId = info.userId; |
| 237 | if (Log.isLoggable(CarLog.TAG_AM, Log.DEBUG)) { |
Eric Jeong | bd5fb56 | 2020-12-21 13:49:40 -0800 | [diff] [blame] | 238 | Slog.d(CarLog.TAG_AM, "Root activity is " + rootActivityName); |
| 239 | Slog.d(CarLog.TAG_AM, "User id is " + userId); |
Yao, Yuxing | d1d6a37 | 2018-05-08 10:37:43 -0700 | [diff] [blame] | 240 | } |
| 241 | // Break out of nested loop. |
| 242 | break findRootActivityName; |
| 243 | } |
| 244 | } |
| 245 | } |
| 246 | } catch (RemoteException e) { |
Eric Jeong | bd5fb56 | 2020-12-21 13:49:40 -0800 | [diff] [blame] | 247 | Slog.e(CarLog.TAG_AM, "Could not get stack info", e); |
Yao, Yuxing | d1d6a37 | 2018-05-08 10:37:43 -0700 | [diff] [blame] | 248 | return; |
| 249 | } |
| 250 | |
| 251 | if (rootActivityName == null) { |
Eric Jeong | bd5fb56 | 2020-12-21 13:49:40 -0800 | [diff] [blame] | 252 | Slog.e(CarLog.TAG_AM, "Could not find root activity with task id " + taskId); |
Yao, Yuxing | d1d6a37 | 2018-05-08 10:37:43 -0700 | [diff] [blame] | 253 | return; |
| 254 | } |
| 255 | |
| 256 | Intent rootActivityIntent = new Intent(); |
| 257 | rootActivityIntent.setComponent(ComponentName.unflattenFromString(rootActivityName)); |
| 258 | // Clear the task the root activity is running in and start it in a new task. |
| 259 | // Effectively restart root activity. |
| 260 | rootActivityIntent.addFlags( |
| 261 | Intent.FLAG_ACTIVITY_CLEAR_TASK | Intent.FLAG_ACTIVITY_NEW_TASK); |
| 262 | |
| 263 | if (Log.isLoggable(CarLog.TAG_AM, Log.INFO)) { |
Eric Jeong | bd5fb56 | 2020-12-21 13:49:40 -0800 | [diff] [blame] | 264 | Slog.i(CarLog.TAG_AM, "restarting root activity with user id " + userId); |
Yao, Yuxing | d1d6a37 | 2018-05-08 10:37:43 -0700 | [diff] [blame] | 265 | } |
| 266 | mContext.startActivityAsUser(rootActivityIntent, new UserHandle(userId)); |
| 267 | } |
| 268 | |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 269 | public void registerActivityLaunchListener(ActivityLaunchListener listener) { |
Yuncheol Heo | 8b5ab80 | 2020-04-09 12:13:44 -0700 | [diff] [blame] | 270 | synchronized (mLock) { |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 271 | mActivityLaunchListener = listener; |
| 272 | } |
| 273 | } |
| 274 | |
| 275 | private void updateTasks() { |
Louis Chang | 3bf2f20 | 2020-08-18 13:04:28 +0800 | [diff] [blame] | 276 | List<RootTaskInfo> infos; |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 277 | try { |
Louis Chang | 3bf2f20 | 2020-08-18 13:04:28 +0800 | [diff] [blame] | 278 | infos = mAm.getAllRootTaskInfos(); |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 279 | } catch (RemoteException e) { |
Eric Jeong | bd5fb56 | 2020-12-21 13:49:40 -0800 | [diff] [blame] | 280 | Slog.e(CarLog.TAG_AM, "cannot getTasks", e); |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 281 | return; |
| 282 | } |
tadvana | 3b9ed20 | 2019-07-17 19:21:28 -0700 | [diff] [blame] | 283 | |
| 284 | if (infos == null) { |
| 285 | return; |
| 286 | } |
| 287 | |
Michal Palczewski | 7684dbb | 2018-11-13 18:36:06 -0800 | [diff] [blame] | 288 | int focusedStackId = INVALID_STACK_ID; |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 289 | try { |
Wale Ogunwale | 9a000b9 | 2017-09-26 11:05:02 -0700 | [diff] [blame] | 290 | // TODO(b/66955160): Someone on the Auto-team should probably re-work the code in the |
| 291 | // synchronized block below based on this new API. |
Louis Chang | 3bf2f20 | 2020-08-18 13:04:28 +0800 | [diff] [blame] | 292 | final RootTaskInfo focusedTaskInfo = mAm.getFocusedRootTaskInfo(); |
| 293 | if (focusedTaskInfo != null) { |
| 294 | focusedStackId = focusedTaskInfo.taskId; |
Wale Ogunwale | 9a000b9 | 2017-09-26 11:05:02 -0700 | [diff] [blame] | 295 | } |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 296 | } catch (RemoteException e) { |
Eric Jeong | bd5fb56 | 2020-12-21 13:49:40 -0800 | [diff] [blame] | 297 | Slog.e(CarLog.TAG_AM, "cannot getFocusedStackId", e); |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 298 | return; |
| 299 | } |
Yao, Yuxing | 4ddb2c6 | 2019-02-04 11:26:46 -0800 | [diff] [blame] | 300 | |
| 301 | SparseArray<TopTaskInfoContainer> topTasks = new SparseArray<>(); |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 302 | ActivityLaunchListener listener; |
Yuncheol Heo | 8b5ab80 | 2020-04-09 12:13:44 -0700 | [diff] [blame] | 303 | synchronized (mLock) { |
| 304 | mTopTasks.clear(); |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 305 | listener = mActivityLaunchListener; |
Yao, Yuxing | f4ed528 | 2019-04-09 13:37:59 -0700 | [diff] [blame] | 306 | |
Louis Chang | 3bf2f20 | 2020-08-18 13:04:28 +0800 | [diff] [blame] | 307 | for (RootTaskInfo info : infos) { |
Yao, Yuxing | 4ddb2c6 | 2019-02-04 11:26:46 -0800 | [diff] [blame] | 308 | int displayId = info.displayId; |
Louis Chang | 3bf2f20 | 2020-08-18 13:04:28 +0800 | [diff] [blame] | 309 | if (info.childTaskNames.length == 0 |
| 310 | || !info.visible) { // empty stack or not shown |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 311 | continue; |
| 312 | } |
Yao Chen | ed8609e | 2016-10-07 09:49:13 -0700 | [diff] [blame] | 313 | TopTaskInfoContainer newTopTaskInfo = new TopTaskInfoContainer( |
Louis Chang | 3bf2f20 | 2020-08-18 13:04:28 +0800 | [diff] [blame] | 314 | info.topActivity, info.childTaskIds[info.childTaskIds.length - 1], |
Yao, Yuxing | 4ddb2c6 | 2019-02-04 11:26:46 -0800 | [diff] [blame] | 315 | info.displayId, info.position, info); |
| 316 | TopTaskInfoContainer currentTopTaskInfo = topTasks.get(displayId); |
Yao Chen | ed8609e | 2016-10-07 09:49:13 -0700 | [diff] [blame] | 317 | |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 318 | if (currentTopTaskInfo == null || |
Yao, Yuxing | 4ddb2c6 | 2019-02-04 11:26:46 -0800 | [diff] [blame] | 319 | newTopTaskInfo.position > currentTopTaskInfo.position) { |
| 320 | topTasks.put(displayId, newTopTaskInfo); |
Yao, Yuxing | d1d6a37 | 2018-05-08 10:37:43 -0700 | [diff] [blame] | 321 | if (Log.isLoggable(CarLog.TAG_AM, Log.INFO)) { |
Eric Jeong | bd5fb56 | 2020-12-21 13:49:40 -0800 | [diff] [blame] | 322 | Slog.i(CarLog.TAG_AM, "Updating top task to: " + newTopTaskInfo); |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 323 | } |
| 324 | } |
| 325 | } |
Yao, Yuxing | 4ddb2c6 | 2019-02-04 11:26:46 -0800 | [diff] [blame] | 326 | // Assuming displays remains the same. |
| 327 | for (int i = 0; i < topTasks.size(); i++) { |
Yao, Yuxing | 2646cff | 2019-04-23 17:01:26 -0700 | [diff] [blame] | 328 | TopTaskInfoContainer topTask = topTasks.valueAt(i); |
Yao, Yuxing | f4ed528 | 2019-04-09 13:37:59 -0700 | [diff] [blame] | 329 | |
Yao, Yuxing | 4ddb2c6 | 2019-02-04 11:26:46 -0800 | [diff] [blame] | 330 | int displayId = topTasks.keyAt(i); |
Yao, Yuxing | f4ed528 | 2019-04-09 13:37:59 -0700 | [diff] [blame] | 331 | mTopTasks.put(displayId, topTask); |
Michal Palczewski | 7684dbb | 2018-11-13 18:36:06 -0800 | [diff] [blame] | 332 | } |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 333 | } |
| 334 | if (listener != null) { |
Yao, Yuxing | f4ed528 | 2019-04-09 13:37:59 -0700 | [diff] [blame] | 335 | for (int i = 0; i < topTasks.size(); i++) { |
| 336 | TopTaskInfoContainer topTask = topTasks.valueAt(i); |
| 337 | |
Yao, Yuxing | d1d6a37 | 2018-05-08 10:37:43 -0700 | [diff] [blame] | 338 | if (Log.isLoggable(CarLog.TAG_AM, Log.INFO)) { |
Eric Jeong | bd5fb56 | 2020-12-21 13:49:40 -0800 | [diff] [blame] | 339 | Slog.i(CarLog.TAG_AM, "Notifying about top task: " + topTask.toString()); |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 340 | } |
| 341 | listener.onActivityLaunch(topTask); |
| 342 | } |
| 343 | } |
| 344 | } |
| 345 | |
Louis Chang | 3bf2f20 | 2020-08-18 13:04:28 +0800 | [diff] [blame] | 346 | public RootTaskInfo getFocusedStackForTopActivity(ComponentName activity) { |
| 347 | RootTaskInfo focusedStack; |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 348 | try { |
Louis Chang | 3bf2f20 | 2020-08-18 13:04:28 +0800 | [diff] [blame] | 349 | focusedStack = mAm.getFocusedRootTaskInfo(); |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 350 | } catch (RemoteException e) { |
Eric Jeong | bd5fb56 | 2020-12-21 13:49:40 -0800 | [diff] [blame] | 351 | Slog.e(CarLog.TAG_AM, "cannot getFocusedStackId", e); |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 352 | return null; |
| 353 | } |
Louis Chang | 3bf2f20 | 2020-08-18 13:04:28 +0800 | [diff] [blame] | 354 | if (focusedStack.childTaskNames.length == 0) { // nothing in focused stack |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 355 | return null; |
| 356 | } |
| 357 | ComponentName topActivity = ComponentName.unflattenFromString( |
Louis Chang | 3bf2f20 | 2020-08-18 13:04:28 +0800 | [diff] [blame] | 358 | focusedStack.childTaskNames[focusedStack.childTaskNames.length - 1]); |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 359 | if (topActivity.equals(activity)) { |
| 360 | return focusedStack; |
| 361 | } else { |
| 362 | return null; |
| 363 | } |
| 364 | } |
| 365 | |
| 366 | private void handleForegroundActivitiesChanged(int pid, int uid, boolean foregroundActivities) { |
Yuncheol Heo | 8b5ab80 | 2020-04-09 12:13:44 -0700 | [diff] [blame] | 367 | synchronized (mLock) { |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 368 | if (foregroundActivities) { |
| 369 | Set<Integer> pids = mForegroundUidPids.get(uid); |
| 370 | if (pids == null) { |
| 371 | pids = new ArraySet<Integer>(); |
| 372 | mForegroundUidPids.put(uid, pids); |
| 373 | } |
| 374 | pids.add(pid); |
| 375 | } else { |
| 376 | doHandlePidGoneLocked(pid, uid); |
| 377 | } |
| 378 | } |
| 379 | } |
| 380 | |
| 381 | private void handleProcessDied(int pid, int uid) { |
Yuncheol Heo | 8b5ab80 | 2020-04-09 12:13:44 -0700 | [diff] [blame] | 382 | synchronized (mLock) { |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 383 | doHandlePidGoneLocked(pid, uid); |
| 384 | } |
| 385 | } |
| 386 | |
| 387 | private void doHandlePidGoneLocked(int pid, int uid) { |
| 388 | Set<Integer> pids = mForegroundUidPids.get(uid); |
| 389 | if (pids != null) { |
| 390 | pids.remove(pid); |
| 391 | if (pids.isEmpty()) { |
| 392 | mForegroundUidPids.remove(uid); |
| 393 | } |
| 394 | } |
| 395 | } |
| 396 | |
Ram Periathiruvadi | ffcdb84 | 2018-04-16 17:17:39 -0700 | [diff] [blame] | 397 | /** |
| 398 | * block the current task with the provided new activity. |
| 399 | */ |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 400 | private void handleBlockActivity(TopTaskInfoContainer currentTask, Intent newActivityIntent) { |
Yao, Yuxing | d525de1 | 2019-05-06 15:11:48 -0700 | [diff] [blame] | 401 | int displayId = newActivityIntent.getIntExtra(BLOCKING_INTENT_EXTRA_DISPLAY_ID, |
| 402 | Display.DEFAULT_DISPLAY); |
| 403 | if (Log.isLoggable(CarLog.TAG_AM, Log.DEBUG)) { |
Eric Jeong | bd5fb56 | 2020-12-21 13:49:40 -0800 | [diff] [blame] | 404 | Slog.d(CarLog.TAG_AM, "Launching blocking activity on display: " + displayId); |
Yao, Yuxing | d525de1 | 2019-05-06 15:11:48 -0700 | [diff] [blame] | 405 | } |
Yao, Yuxing | cfcc59f | 2019-03-05 16:35:47 -0800 | [diff] [blame] | 406 | |
Yao, Yuxing | d525de1 | 2019-05-06 15:11:48 -0700 | [diff] [blame] | 407 | ActivityOptions options = ActivityOptions.makeBasic(); |
| 408 | options.setLaunchDisplayId(displayId); |
Yao, Yuxing | cfcc59f | 2019-03-05 16:35:47 -0800 | [diff] [blame] | 409 | mContext.startActivityAsUser(newActivityIntent, options.toBundle(), |
Louis Chang | 3bf2f20 | 2020-08-18 13:04:28 +0800 | [diff] [blame] | 410 | new UserHandle(currentTask.taskInfo.userId)); |
Yao, Yuxing | d1d6a37 | 2018-05-08 10:37:43 -0700 | [diff] [blame] | 411 | // Now make stack with new activity focused. |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 412 | findTaskAndGrantFocus(newActivityIntent.getComponent()); |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 413 | } |
| 414 | |
| 415 | private void findTaskAndGrantFocus(ComponentName activity) { |
Louis Chang | 3bf2f20 | 2020-08-18 13:04:28 +0800 | [diff] [blame] | 416 | List<RootTaskInfo> infos; |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 417 | try { |
Louis Chang | 3bf2f20 | 2020-08-18 13:04:28 +0800 | [diff] [blame] | 418 | infos = mAm.getAllRootTaskInfos(); |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 419 | } catch (RemoteException e) { |
Eric Jeong | bd5fb56 | 2020-12-21 13:49:40 -0800 | [diff] [blame] | 420 | Slog.e(CarLog.TAG_AM, "cannot getTasks", e); |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 421 | return; |
| 422 | } |
Louis Chang | 3bf2f20 | 2020-08-18 13:04:28 +0800 | [diff] [blame] | 423 | for (RootTaskInfo info : infos) { |
| 424 | if (info.childTaskNames.length == 0) { |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 425 | continue; |
| 426 | } |
| 427 | ComponentName topActivity = ComponentName.unflattenFromString( |
Louis Chang | 3bf2f20 | 2020-08-18 13:04:28 +0800 | [diff] [blame] | 428 | info.childTaskNames[info.childTaskNames.length - 1]); |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 429 | if (activity.equals(topActivity)) { |
| 430 | try { |
Louis Chang | 0b8c202 | 2020-09-23 21:42:40 +0800 | [diff] [blame] | 431 | mAm.setFocusedRootTask(info.taskId); |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 432 | } catch (RemoteException e) { |
Eric Jeong | bd5fb56 | 2020-12-21 13:49:40 -0800 | [diff] [blame] | 433 | Slog.e(CarLog.TAG_AM, "cannot setFocusedRootTask to task:" + info.taskId, e); |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 434 | } |
| 435 | return; |
| 436 | } |
| 437 | } |
Eric Jeong | bd5fb56 | 2020-12-21 13:49:40 -0800 | [diff] [blame] | 438 | Slog.i(CarLog.TAG_AM, "cannot give focus, cannot find Activity:" + activity); |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 439 | } |
| 440 | |
| 441 | private class ProcessObserver extends IProcessObserver.Stub { |
| 442 | @Override |
| 443 | public void onForegroundActivitiesChanged(int pid, int uid, boolean foregroundActivities) { |
Yao, Yuxing | d1d6a37 | 2018-05-08 10:37:43 -0700 | [diff] [blame] | 444 | if (Log.isLoggable(CarLog.TAG_AM, Log.INFO)) { |
Eric Jeong | bd5fb56 | 2020-12-21 13:49:40 -0800 | [diff] [blame] | 445 | Slog.i(CarLog.TAG_AM, |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 446 | String.format("onForegroundActivitiesChanged uid %d pid %d fg %b", |
| 447 | uid, pid, foregroundActivities)); |
| 448 | } |
| 449 | mHandler.requestForegroundActivitiesChanged(pid, uid, foregroundActivities); |
| 450 | } |
| 451 | |
| 452 | @Override |
Narayan Kamath | 4291a19 | 2019-03-15 18:49:29 +0000 | [diff] [blame] | 453 | public void onForegroundServicesChanged(int pid, int uid, int fgServiceTypes) { |
| 454 | } |
| 455 | |
| 456 | @Override |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 457 | public void onProcessDied(int pid, int uid) { |
| 458 | mHandler.requestProcessDied(pid, uid); |
| 459 | } |
| 460 | } |
| 461 | |
Yorke Lee | c1265de | 2016-10-27 11:25:25 -0700 | [diff] [blame] | 462 | private class TaskListener extends TaskStackListener { |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 463 | @Override |
| 464 | public void onTaskStackChanged() { |
Yao, Yuxing | d1d6a37 | 2018-05-08 10:37:43 -0700 | [diff] [blame] | 465 | if (Log.isLoggable(CarLog.TAG_AM, Log.INFO)) { |
Eric Jeong | bd5fb56 | 2020-12-21 13:49:40 -0800 | [diff] [blame] | 466 | Slog.i(CarLog.TAG_AM, "onTaskStackChanged"); |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 467 | } |
| 468 | mHandler.requestUpdatingTask(); |
| 469 | } |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 470 | } |
| 471 | |
Keun young Park | b241d02 | 2020-04-20 20:31:34 -0700 | [diff] [blame] | 472 | private static final class ActivityMonitorHandler extends Handler { |
| 473 | private static final String TAG = ActivityMonitorHandler.class.getSimpleName(); |
| 474 | |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 475 | private static final int MSG_UPDATE_TASKS = 0; |
| 476 | private static final int MSG_FOREGROUND_ACTIVITIES_CHANGED = 1; |
| 477 | private static final int MSG_PROCESS_DIED = 2; |
| 478 | private static final int MSG_BLOCK_ACTIVITY = 3; |
| 479 | |
Keun young Park | b241d02 | 2020-04-20 20:31:34 -0700 | [diff] [blame] | 480 | private final WeakReference<SystemActivityMonitoringService> mService; |
| 481 | |
| 482 | private ActivityMonitorHandler(Looper looper, SystemActivityMonitoringService service) { |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 483 | super(looper); |
Keun young Park | b241d02 | 2020-04-20 20:31:34 -0700 | [diff] [blame] | 484 | mService = new WeakReference<SystemActivityMonitoringService>(service); |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 485 | } |
| 486 | |
| 487 | private void requestUpdatingTask() { |
| 488 | Message msg = obtainMessage(MSG_UPDATE_TASKS); |
| 489 | sendMessage(msg); |
| 490 | } |
| 491 | |
| 492 | private void requestForegroundActivitiesChanged(int pid, int uid, |
| 493 | boolean foregroundActivities) { |
| 494 | Message msg = obtainMessage(MSG_FOREGROUND_ACTIVITIES_CHANGED, pid, uid, |
| 495 | Boolean.valueOf(foregroundActivities)); |
| 496 | sendMessage(msg); |
| 497 | } |
| 498 | |
| 499 | private void requestProcessDied(int pid, int uid) { |
| 500 | Message msg = obtainMessage(MSG_PROCESS_DIED, pid, uid); |
| 501 | sendMessage(msg); |
| 502 | } |
| 503 | |
| 504 | private void requestBlockActivity(TopTaskInfoContainer currentTask, |
| 505 | Intent newActivityIntent) { |
| 506 | Message msg = obtainMessage(MSG_BLOCK_ACTIVITY, |
| 507 | new Pair<TopTaskInfoContainer, Intent>(currentTask, newActivityIntent)); |
| 508 | sendMessage(msg); |
| 509 | } |
| 510 | |
| 511 | @Override |
| 512 | public void handleMessage(Message msg) { |
Keun young Park | b241d02 | 2020-04-20 20:31:34 -0700 | [diff] [blame] | 513 | SystemActivityMonitoringService service = mService.get(); |
| 514 | if (service == null) { |
Eric Jeong | bd5fb56 | 2020-12-21 13:49:40 -0800 | [diff] [blame] | 515 | Slog.i(TAG, "handleMessage null service"); |
Keun young Park | b241d02 | 2020-04-20 20:31:34 -0700 | [diff] [blame] | 516 | return; |
| 517 | } |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 518 | switch (msg.what) { |
| 519 | case MSG_UPDATE_TASKS: |
Keun young Park | b241d02 | 2020-04-20 20:31:34 -0700 | [diff] [blame] | 520 | service.updateTasks(); |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 521 | break; |
| 522 | case MSG_FOREGROUND_ACTIVITIES_CHANGED: |
Keun young Park | b241d02 | 2020-04-20 20:31:34 -0700 | [diff] [blame] | 523 | service.handleForegroundActivitiesChanged(msg.arg1, msg.arg2, |
| 524 | (Boolean) msg.obj); |
| 525 | service.updateTasks(); |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 526 | break; |
| 527 | case MSG_PROCESS_DIED: |
Keun young Park | b241d02 | 2020-04-20 20:31:34 -0700 | [diff] [blame] | 528 | service.handleProcessDied(msg.arg1, msg.arg2); |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 529 | break; |
| 530 | case MSG_BLOCK_ACTIVITY: |
| 531 | Pair<TopTaskInfoContainer, Intent> pair = |
| 532 | (Pair<TopTaskInfoContainer, Intent>) msg.obj; |
Keun young Park | b241d02 | 2020-04-20 20:31:34 -0700 | [diff] [blame] | 533 | service.handleBlockActivity(pair.first, pair.second); |
Keun-young Park | 4727da3 | 2016-05-31 10:00:51 -0700 | [diff] [blame] | 534 | break; |
| 535 | } |
| 536 | } |
| 537 | } |
| 538 | } |