2 * Copyright (C) 2013 The Android Open Source Project
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
17 package com.android.server.am;
19 import static android.Manifest.permission.INTERNAL_SYSTEM_WINDOW;
20 import static android.Manifest.permission.MANAGE_ACTIVITY_STACKS;
21 import static android.Manifest.permission.START_ANY_ACTIVITY;
22 import static android.Manifest.permission.START_TASKS_FROM_RECENTS;
23 import static android.app.ActivityManager.LOCK_TASK_MODE_LOCKED;
24 import static android.app.ActivityManager.LOCK_TASK_MODE_NONE;
25 import static android.app.ActivityManager.LOCK_TASK_MODE_PINNED;
26 import static android.app.ActivityManager.START_TASK_TO_FRONT;
27 import static android.app.ActivityManager.StackId.DOCKED_STACK_ID;
28 import static android.app.ActivityManager.StackId.FIRST_DYNAMIC_STACK_ID;
29 import static android.app.ActivityManager.StackId.FIRST_STATIC_STACK_ID;
30 import static android.app.ActivityManager.StackId.FREEFORM_WORKSPACE_STACK_ID;
31 import static android.app.ActivityManager.StackId.FULLSCREEN_WORKSPACE_STACK_ID;
32 import static android.app.ActivityManager.StackId.HOME_STACK_ID;
33 import static android.app.ActivityManager.StackId.INVALID_STACK_ID;
34 import static android.app.ActivityManager.StackId.LAST_STATIC_STACK_ID;
35 import static android.app.ActivityManager.StackId.PINNED_STACK_ID;
36 import static android.app.ActivityManager.StackId.RECENTS_STACK_ID;
37 import static android.app.ITaskStackListener.FORCED_RESIZEABLE_REASON_SECONDARY_DISPLAY;
38 import static android.app.ITaskStackListener.FORCED_RESIZEABLE_REASON_SPLIT_SCREEN;
39 import static android.content.Intent.FLAG_ACTIVITY_MULTIPLE_TASK;
40 import static android.content.Intent.FLAG_ACTIVITY_NEW_TASK;
41 import static android.content.pm.PackageManager.PERMISSION_GRANTED;
42 import static android.os.Process.SYSTEM_UID;
43 import static android.os.Trace.TRACE_TAG_ACTIVITY_MANAGER;
44 import static android.view.Display.DEFAULT_DISPLAY;
45 import static android.view.Display.FLAG_PRIVATE;
46 import static android.view.Display.INVALID_DISPLAY;
47 import static android.view.Display.REMOVE_MODE_DESTROY_CONTENT;
48 import static android.view.Display.TYPE_VIRTUAL;
50 import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.ACTION_PICTURE_IN_PICTURE_EXPANDED_TO_FULLSCREEN;
51 import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_ALL;
52 import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_CONTAINERS;
53 import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_FOCUS;
54 import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_IDLE;
55 import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_LOCKTASK;
56 import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_PAUSE;
57 import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_RECENTS;
58 import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_RELEASE;
59 import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_STACK;
60 import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_STATES;
61 import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_SWITCH;
62 import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_TASKS;
63 import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_VISIBLE_BEHIND;
64 import static com.android.server.am.ActivityManagerDebugConfig.POSTFIX_CONTAINERS;
65 import static com.android.server.am.ActivityManagerDebugConfig.POSTFIX_FOCUS;
66 import static com.android.server.am.ActivityManagerDebugConfig.POSTFIX_IDLE;
67 import static com.android.server.am.ActivityManagerDebugConfig.POSTFIX_LOCKTASK;
68 import static com.android.server.am.ActivityManagerDebugConfig.POSTFIX_PAUSE;
69 import static com.android.server.am.ActivityManagerDebugConfig.POSTFIX_RECENTS;
70 import static com.android.server.am.ActivityManagerDebugConfig.POSTFIX_RELEASE;
71 import static com.android.server.am.ActivityManagerDebugConfig.POSTFIX_STACK;
72 import static com.android.server.am.ActivityManagerDebugConfig.POSTFIX_STATES;
73 import static com.android.server.am.ActivityManagerDebugConfig.POSTFIX_SWITCH;
74 import static com.android.server.am.ActivityManagerDebugConfig.POSTFIX_TASKS;
75 import static com.android.server.am.ActivityManagerDebugConfig.POSTFIX_VISIBLE_BEHIND;
76 import static com.android.server.am.ActivityManagerDebugConfig.TAG_AM;
77 import static com.android.server.am.ActivityManagerDebugConfig.TAG_WITH_CLASS_NAME;
78 import static com.android.server.am.ActivityManagerService.ANIMATE;
79 import static com.android.server.am.ActivityManagerService.FIRST_SUPERVISOR_STACK_MSG;
80 import static com.android.server.am.ActivityRecord.APPLICATION_ACTIVITY_TYPE;
81 import static com.android.server.am.ActivityRecord.HOME_ACTIVITY_TYPE;
82 import static com.android.server.am.ActivityStack.ActivityState.DESTROYED;
83 import static com.android.server.am.ActivityStack.ActivityState.DESTROYING;
84 import static com.android.server.am.ActivityStack.ActivityState.INITIALIZING;
85 import static com.android.server.am.ActivityStack.ActivityState.PAUSED;
86 import static com.android.server.am.ActivityStack.ActivityState.PAUSING;
87 import static com.android.server.am.ActivityStack.ActivityState.RESUMED;
88 import static com.android.server.am.ActivityStack.ActivityState.STOPPED;
89 import static com.android.server.am.ActivityStack.ActivityState.STOPPING;
90 import static com.android.server.am.ActivityStack.REMOVE_TASK_MODE_MOVING;
91 import static com.android.server.am.ActivityStack.STACK_INVISIBLE;
92 import static com.android.server.am.ActivityStack.STACK_VISIBLE;
93 import static com.android.server.am.TaskRecord.LOCK_TASK_AUTH_DONT_LOCK;
94 import static com.android.server.am.TaskRecord.LOCK_TASK_AUTH_LAUNCHABLE;
95 import static com.android.server.am.TaskRecord.LOCK_TASK_AUTH_LAUNCHABLE_PRIV;
96 import static com.android.server.am.TaskRecord.LOCK_TASK_AUTH_PINNABLE;
97 import static com.android.server.am.TaskRecord.LOCK_TASK_AUTH_WHITELISTED;
98 import static com.android.server.am.TaskRecord.REPARENT_KEEP_STACK_AT_FRONT;
99 import static com.android.server.am.TaskRecord.REPARENT_LEAVE_STACK_IN_PLACE;
100 import static com.android.server.am.TaskRecord.REPARENT_MOVE_STACK_TO_FRONT;
101 import static com.android.server.wm.AppTransition.TRANSIT_DOCK_TASK_FROM_RECENTS;
102 import static java.lang.Integer.MAX_VALUE;
104 import android.Manifest;
105 import android.annotation.IntDef;
106 import android.annotation.NonNull;
107 import android.annotation.UserIdInt;
108 import android.app.Activity;
109 import android.app.ActivityManager;
110 import android.app.ActivityManager.RunningTaskInfo;
111 import android.app.ActivityManager.StackId;
112 import android.app.ActivityManager.StackInfo;
113 import android.app.ActivityOptions;
114 import android.app.AppOpsManager;
115 import android.app.IActivityContainerCallback;
116 import android.app.ProfilerInfo;
117 import android.app.ResultInfo;
118 import android.app.StatusBarManager;
119 import android.app.WaitResult;
120 import android.app.admin.IDevicePolicyManager;
121 import android.content.ComponentName;
122 import android.content.Context;
123 import android.content.IIntentSender;
124 import android.content.Intent;
125 import android.content.pm.ActivityInfo;
126 import android.content.pm.ApplicationInfo;
127 import android.content.pm.PackageInfo;
128 import android.content.pm.PackageManager;
129 import android.content.pm.ResolveInfo;
130 import android.content.pm.UserInfo;
131 import android.content.res.Configuration;
132 import android.graphics.Rect;
133 import android.hardware.display.DisplayManager;
134 import android.hardware.display.DisplayManager.DisplayListener;
135 import android.hardware.display.DisplayManagerGlobal;
136 import android.hardware.display.DisplayManagerInternal;
137 import android.hardware.display.VirtualDisplay;
138 import android.hardware.input.InputManager;
139 import android.hardware.input.InputManagerInternal;
140 import android.os.Binder;
141 import android.os.Bundle;
142 import android.os.Debug;
143 import android.os.Handler;
144 import android.os.IBinder;
145 import android.os.Looper;
146 import android.os.Message;
147 import android.os.ParcelFileDescriptor;
148 import android.os.PowerManager;
149 import android.os.Process;
150 import android.os.RemoteException;
151 import android.os.ServiceManager;
152 import android.os.SystemClock;
153 import android.os.Trace;
154 import android.os.TransactionTooLargeException;
155 import android.os.UserHandle;
156 import android.os.UserManager;
157 import android.os.WorkSource;
158 import android.provider.MediaStore;
159 import android.provider.Settings;
160 import android.provider.Settings.SettingNotFoundException;
161 import android.service.voice.IVoiceInteractionSession;
162 import android.util.ArrayMap;
163 import android.util.ArraySet;
164 import android.util.EventLog;
165 import android.util.IntArray;
166 import android.util.MergedConfiguration;
167 import android.util.Slog;
168 import android.util.SparseArray;
169 import android.util.SparseIntArray;
170 import android.view.Display;
171 import android.view.InputEvent;
172 import android.view.Surface;
174 import com.android.internal.content.ReferrerIntent;
175 import com.android.internal.logging.MetricsLogger;
176 import com.android.internal.os.TransferPipe;
177 import com.android.internal.statusbar.IStatusBarService;
178 import com.android.internal.util.ArrayUtils;
179 import com.android.internal.widget.LockPatternUtils;
180 import com.android.server.LocalServices;
181 import com.android.server.am.ActivityStack.ActivityState;
182 import com.android.server.wm.PinnedStackWindowController;
183 import com.android.server.wm.WindowManagerService;
185 import java.io.FileDescriptor;
186 import java.io.IOException;
187 import java.io.PrintWriter;
188 import java.lang.annotation.Retention;
189 import java.lang.annotation.RetentionPolicy;
190 import java.util.ArrayList;
191 import java.util.Arrays;
192 import java.util.List;
193 import java.util.Set;
195 public class ActivityStackSupervisor extends ConfigurationContainer implements DisplayListener {
196 private static final String TAG = TAG_WITH_CLASS_NAME ? "ActivityStackSupervisor" : TAG_AM;
197 private static final String TAG_CONTAINERS = TAG + POSTFIX_CONTAINERS;
198 private static final String TAG_FOCUS = TAG + POSTFIX_FOCUS;
199 private static final String TAG_IDLE = TAG + POSTFIX_IDLE;
200 private static final String TAG_LOCKTASK = TAG + POSTFIX_LOCKTASK;
201 private static final String TAG_PAUSE = TAG + POSTFIX_PAUSE;
202 private static final String TAG_RECENTS = TAG + POSTFIX_RECENTS;
203 private static final String TAG_RELEASE = TAG + POSTFIX_RELEASE;
204 private static final String TAG_STACK = TAG + POSTFIX_STACK;
205 private static final String TAG_STATES = TAG + POSTFIX_STATES;
206 private static final String TAG_SWITCH = TAG + POSTFIX_SWITCH;
207 static final String TAG_TASKS = TAG + POSTFIX_TASKS;
208 private static final String TAG_VISIBLE_BEHIND = TAG + POSTFIX_VISIBLE_BEHIND;
210 /** How long we wait until giving up on the last activity telling us it is idle. */
211 static final int IDLE_TIMEOUT = 10 * 1000;
213 /** How long we can hold the sleep wake lock before giving up. */
214 static final int SLEEP_TIMEOUT = 5 * 1000;
216 // How long we can hold the launch wake lock before giving up.
217 static final int LAUNCH_TIMEOUT = 10 * 1000;
219 static final int IDLE_TIMEOUT_MSG = FIRST_SUPERVISOR_STACK_MSG;
220 static final int IDLE_NOW_MSG = FIRST_SUPERVISOR_STACK_MSG + 1;
221 static final int RESUME_TOP_ACTIVITY_MSG = FIRST_SUPERVISOR_STACK_MSG + 2;
222 static final int SLEEP_TIMEOUT_MSG = FIRST_SUPERVISOR_STACK_MSG + 3;
223 static final int LAUNCH_TIMEOUT_MSG = FIRST_SUPERVISOR_STACK_MSG + 4;
224 static final int HANDLE_DISPLAY_ADDED = FIRST_SUPERVISOR_STACK_MSG + 5;
225 static final int HANDLE_DISPLAY_CHANGED = FIRST_SUPERVISOR_STACK_MSG + 6;
226 static final int HANDLE_DISPLAY_REMOVED = FIRST_SUPERVISOR_STACK_MSG + 7;
227 static final int CONTAINER_CALLBACK_VISIBILITY = FIRST_SUPERVISOR_STACK_MSG + 8;
228 static final int LOCK_TASK_START_MSG = FIRST_SUPERVISOR_STACK_MSG + 9;
229 static final int LOCK_TASK_END_MSG = FIRST_SUPERVISOR_STACK_MSG + 10;
230 static final int CONTAINER_CALLBACK_TASK_LIST_EMPTY = FIRST_SUPERVISOR_STACK_MSG + 11;
231 static final int LAUNCH_TASK_BEHIND_COMPLETE = FIRST_SUPERVISOR_STACK_MSG + 12;
232 static final int SHOW_LOCK_TASK_ESCAPE_MESSAGE_MSG = FIRST_SUPERVISOR_STACK_MSG + 13;
233 static final int REPORT_MULTI_WINDOW_MODE_CHANGED_MSG = FIRST_SUPERVISOR_STACK_MSG + 14;
234 static final int REPORT_PIP_MODE_CHANGED_MSG = FIRST_SUPERVISOR_STACK_MSG + 15;
236 private static final String VIRTUAL_DISPLAY_BASE_NAME = "ActivityViewVirtualDisplay";
238 private static final String LOCK_TASK_TAG = "Lock-to-App";
240 // Used to indicate if an object (e.g. stack) that we are trying to get
241 // should be created if it doesn't exist already.
242 static final boolean CREATE_IF_NEEDED = true;
244 // Used to indicate that windows of activities should be preserved during the resize.
245 static final boolean PRESERVE_WINDOWS = true;
247 // Used to indicate if an object (e.g. task) should be moved/created
248 // at the top of its container (e.g. stack).
249 static final boolean ON_TOP = true;
251 // Used to indicate that an objects (e.g. task) removal from its container
252 // (e.g. stack) is due to it moving to another container.
253 static final boolean MOVING = true;
255 // Force the focus to change to the stack we are moving a task to..
256 static final boolean FORCE_FOCUS = true;
258 // Don't execute any calls to resume.
259 static final boolean DEFER_RESUME = true;
261 // Used to indicate that a task is removed it should also be removed from recents.
262 static final boolean REMOVE_FROM_RECENTS = true;
264 // Used to indicate that pausing an activity should occur immediately without waiting for
265 // the activity callback indicating that it has completed pausing
266 static final boolean PAUSE_IMMEDIATELY = true;
269 * The modes which affect which tasks are returned when calling
270 * {@link ActivityStackSupervisor#anyTaskForIdLocked(int)}.
272 @Retention(RetentionPolicy.SOURCE)
274 MATCH_TASK_IN_STACKS_ONLY,
275 MATCH_TASK_IN_STACKS_OR_RECENT_TASKS,
276 MATCH_TASK_IN_STACKS_OR_RECENT_TASKS_AND_RESTORE
278 public @interface AnyTaskForIdMatchTaskMode {}
279 // Match only tasks in the current stacks
280 static final int MATCH_TASK_IN_STACKS_ONLY = 0;
281 // Match either tasks in the current stacks, or in the recent tasks if not found in the stacks
282 static final int MATCH_TASK_IN_STACKS_OR_RECENT_TASKS = 1;
283 // Match either tasks in the current stacks, or in the recent tasks, restoring it to the
285 static final int MATCH_TASK_IN_STACKS_OR_RECENT_TASKS_AND_RESTORE = 2;
287 // Activity actions an app cannot start if it uses a permission which is not granted.
288 private static final ArrayMap<String, String> ACTION_TO_RUNTIME_PERMISSION =
292 ACTION_TO_RUNTIME_PERMISSION.put(MediaStore.ACTION_IMAGE_CAPTURE,
293 Manifest.permission.CAMERA);
294 ACTION_TO_RUNTIME_PERMISSION.put(MediaStore.ACTION_VIDEO_CAPTURE,
295 Manifest.permission.CAMERA);
296 ACTION_TO_RUNTIME_PERMISSION.put(Intent.ACTION_CALL,
297 Manifest.permission.CALL_PHONE);
300 /** Action restriction: launching the activity is not restricted. */
301 private static final int ACTIVITY_RESTRICTION_NONE = 0;
302 /** Action restriction: launching the activity is restricted by a permission. */
303 private static final int ACTIVITY_RESTRICTION_PERMISSION = 1;
304 /** Action restriction: launching the activity is restricted by an app op. */
305 private static final int ACTIVITY_RESTRICTION_APPOP = 2;
307 /** Status Bar Service **/
308 private IBinder mToken = new Binder();
309 private IStatusBarService mStatusBarService;
310 private IDevicePolicyManager mDevicePolicyManager;
312 // For debugging to make sure the caller when acquiring/releasing our
313 // wake lock is the system process.
314 static final boolean VALIDATE_WAKE_LOCK_CALLER = false;
315 /** The number of distinct task ids that can be assigned to the tasks of a single user */
316 private static final int MAX_TASK_IDS_PER_USER = UserHandle.PER_USER_RANGE;
318 final ActivityManagerService mService;
320 private RecentTasks mRecentTasks;
322 final ActivityStackSupervisorHandler mHandler;
325 WindowManagerService mWindowManager;
326 DisplayManager mDisplayManager;
328 /** Counter for next free stack ID to use for dynamic activity stacks. */
329 private int mNextFreeStackId = FIRST_DYNAMIC_STACK_ID;
332 * Maps the task identifier that activities are currently being started in to the userId of the
333 * task. Each time a new task is created, the entry for the userId of the task is incremented
335 private final SparseIntArray mCurTaskIdForUser = new SparseIntArray(20);
337 /** The current user */
340 /** The stack containing the launcher app. Assumed to always be attached to
341 * Display.DEFAULT_DISPLAY. */
342 ActivityStack mHomeStack;
344 /** The stack currently receiving input or launching the next activity. */
345 ActivityStack mFocusedStack;
347 /** If this is the same as mFocusedStack then the activity on the top of the focused stack has
348 * been resumed. If stacks are changing position this will hold the old stack until the new
349 * stack becomes resumed after which it will be set to mFocusedStack. */
350 private ActivityStack mLastFocusedStack;
352 /** List of activities that are waiting for a new activity to become visible before completing
353 * whatever operation they are supposed to do. */
354 // TODO: Remove mActivitiesWaitingForVisibleActivity list and just remove activity from
355 // mStoppingActivities when something else comes up.
356 final ArrayList<ActivityRecord> mActivitiesWaitingForVisibleActivity = new ArrayList<>();
358 /** List of processes waiting to find out when a specific activity becomes visible. */
359 private final ArrayList<WaitInfo> mWaitingForActivityVisible = new ArrayList<>();
361 /** List of processes waiting to find out about the next launched activity. */
362 final ArrayList<WaitResult> mWaitingActivityLaunched = new ArrayList<>();
364 /** List of activities that are ready to be stopped, but waiting for the next activity to
365 * settle down before doing so. */
366 final ArrayList<ActivityRecord> mStoppingActivities = new ArrayList<>();
368 /** List of activities that are ready to be finished, but waiting for the previous activity to
369 * settle down before doing so. It contains ActivityRecord objects. */
370 final ArrayList<ActivityRecord> mFinishingActivities = new ArrayList<>();
372 /** List of activities that are in the process of going to sleep. */
373 final ArrayList<ActivityRecord> mGoingToSleepActivities = new ArrayList<>();
375 /** List of activities whose multi-window mode changed that we need to report to the
377 final ArrayList<ActivityRecord> mMultiWindowModeChangedActivities = new ArrayList<>();
379 /** List of activities whose picture-in-picture mode changed that we need to report to the
381 final ArrayList<ActivityRecord> mPipModeChangedActivities = new ArrayList<>();
383 /** The target stack bounds for the picture-in-picture mode changed that we need to report to
385 Rect mPipModeChangedTargetStackBounds;
387 /** Used on user changes */
388 final ArrayList<UserState> mStartingUsers = new ArrayList<>();
390 /** Set to indicate whether to issue an onUserLeaving callback when a newly launched activity
391 * is being brought in front of us. */
392 boolean mUserLeaving = false;
394 /** Set when we have taken too long waiting to go to sleep. */
395 boolean mSleepTimeout = false;
398 * We don't want to allow the device to go to sleep while in the process
399 * of launching an activity. This is primarily to allow alarm intent
400 * receivers to launch an activity and get that to run before the device
401 * goes back to sleep.
403 PowerManager.WakeLock mLaunchingActivity;
406 * Set when the system is going to sleep, until we have
407 * successfully paused the current activity and released our wake lock.
408 * At that point the system is allowed to actually sleep.
410 PowerManager.WakeLock mGoingToSleep;
412 /** Stack id of the front stack when user switched, indexed by userId. */
413 SparseIntArray mUserStackInFront = new SparseIntArray(2);
415 // TODO: Add listener for removal of references.
416 /** Mapping from (ActivityStack/TaskStack).mStackId to their current state */
417 SparseArray<ActivityContainer> mActivityContainers = new SparseArray<>();
419 // TODO: There should be an ActivityDisplayController coordinating am/wm interaction.
420 /** Mapping from displayId to display current state */
421 private final SparseArray<ActivityDisplay> mActivityDisplays = new SparseArray<>();
423 private final SparseArray<IntArray> mDisplayAccessUIDs = new SparseArray<>();
425 private DisplayManagerInternal mDisplayManagerInternal;
426 private InputManagerInternal mInputManagerInternal;
428 /** The chain of tasks in lockTask mode. The current frontmost task is at the top, and tasks
429 * may be finished until there is only one entry left. If this is empty the system is not
430 * in lockTask mode. */
431 ArrayList<TaskRecord> mLockTaskModeTasks = new ArrayList<>();
432 /** Store the current lock task mode. Possible values:
433 * {@link ActivityManager#LOCK_TASK_MODE_NONE}, {@link ActivityManager#LOCK_TASK_MODE_LOCKED},
434 * {@link ActivityManager#LOCK_TASK_MODE_PINNED}
436 private int mLockTaskModeState;
438 * Notifies the user when entering/exiting lock-task.
440 private LockTaskNotify mLockTaskNotify;
442 /** Used to keep resumeTopActivityUncheckedLocked() from being entered recursively */
443 boolean inResumeTopActivity;
446 * Temporary rect used during docked stack resize calculation so we don't need to create a new
449 private final Rect tempRect = new Rect();
451 // The default minimal size that will be used if the activity doesn't specify its minimal size.
452 // It will be calculated when the default display gets added.
453 int mDefaultMinSizeOfResizeableTask = -1;
455 // Whether tasks have moved and we need to rank the tasks before next OOM scoring
456 private boolean mTaskLayersChanged = true;
458 final ActivityMetricsLogger mActivityMetricsLogger;
460 private final ArrayList<ActivityRecord> mTmpActivityList = new ArrayList<>();
463 protected int getChildCount() {
464 return mActivityDisplays.size();
468 protected ActivityDisplay getChildAt(int index) {
469 return mActivityDisplays.valueAt(index);
473 protected ConfigurationContainer getParent() {
477 Configuration getDisplayOverrideConfiguration(int displayId) {
478 final ActivityDisplay activityDisplay = getActivityDisplayOrCreateLocked(displayId);
479 if (activityDisplay == null) {
480 throw new IllegalArgumentException("No display found with id: " + displayId);
483 return activityDisplay.getOverrideConfiguration();
486 void setDisplayOverrideConfiguration(Configuration overrideConfiguration, int displayId) {
487 final ActivityDisplay activityDisplay = getActivityDisplayOrCreateLocked(displayId);
488 if (activityDisplay == null) {
489 throw new IllegalArgumentException("No display found with id: " + displayId);
492 activityDisplay.onOverrideConfigurationChanged(overrideConfiguration);
495 /** Check if placing task or activity on specified display is allowed. */
496 boolean canPlaceEntityOnDisplay(int displayId, boolean resizeable) {
497 return displayId == DEFAULT_DISPLAY || (mService.mSupportsMultiDisplay
498 && (resizeable || displayConfigMatchesGlobal(displayId)));
502 * Check if configuration of specified display matches current global config.
503 * Used to check if we can put a non-resizeable activity on a secondary display and it will get
504 * the same config as on the default display.
505 * @param displayId Id of the display to check.
506 * @return {@code true} if configuration matches.
508 private boolean displayConfigMatchesGlobal(int displayId) {
509 if (displayId == DEFAULT_DISPLAY) {
512 if (displayId == INVALID_DISPLAY) {
515 final ActivityDisplay targetDisplay = getActivityDisplayOrCreateLocked(displayId);
516 if (targetDisplay == null) {
517 throw new IllegalArgumentException("No display found with id: " + displayId);
519 return getConfiguration().equals(targetDisplay.getConfiguration());
522 static class FindTaskResult {
524 boolean matchedByRootAffinity;
526 private final FindTaskResult mTmpFindTaskResult = new FindTaskResult();
529 * Temp storage for display ids sorted in focus order.
530 * Maps position to id. Using {@link SparseIntArray} instead of {@link ArrayList} because
531 * it's more efficient, as the number of displays is usually small.
533 private SparseIntArray mTmpOrderedDisplayIds = new SparseIntArray();
536 * Used to keep track whether app visibilities got changed since the last pause. Useful to
537 * determine whether to invoke the task stack change listener after pausing.
539 boolean mAppVisibilitiesChangedSinceLastPause;
542 * Set of tasks that are in resizing mode during an app transition to fill the "void".
544 private final ArraySet<Integer> mResizingTasksDuringAnimation = new ArraySet<>();
548 * If set to {@code false} all calls to resize the docked stack {@link #resizeDockedStackLocked}
549 * will be ignored. Useful for the case where the caller is handling resizing of other stack and
550 * moving tasks around and doesn't want dock stack to be resized due to an automatic trigger
551 * like the docked stack going empty.
553 private boolean mAllowDockedStackResize = true;
556 * Is dock currently minimized.
558 boolean mIsDockMinimized;
560 final KeyguardController mKeyguardController;
563 * Description of a request to start a new activity, which has been held
564 * due to app switches being disabled.
566 static class PendingActivityLaunch {
567 final ActivityRecord r;
568 final ActivityRecord sourceRecord;
569 final int startFlags;
570 final ActivityStack stack;
571 final ProcessRecord callerApp;
573 PendingActivityLaunch(ActivityRecord _r, ActivityRecord _sourceRecord,
574 int _startFlags, ActivityStack _stack, ProcessRecord _callerApp) {
576 sourceRecord = _sourceRecord;
577 startFlags = _startFlags;
579 callerApp = _callerApp;
582 void sendErrorResult(String message) {
584 if (callerApp.thread != null) {
585 callerApp.thread.scheduleCrash(message);
587 } catch (RemoteException e) {
588 Slog.e(TAG, "Exception scheduling crash of failed "
589 + "activity launcher sourceRecord=" + sourceRecord, e);
594 public ActivityStackSupervisor(ActivityManagerService service, Looper looper) {
596 mHandler = new ActivityStackSupervisorHandler(looper);
597 mActivityMetricsLogger = new ActivityMetricsLogger(this, mService.mContext);
598 mKeyguardController = new KeyguardController(service, this);
601 void setRecentTasks(RecentTasks recentTasks) {
602 mRecentTasks = recentTasks;
606 * At the time when the constructor runs, the power manager has not yet been
607 * initialized. So we initialize our wakelocks afterwards.
609 void initPowerManagement() {
610 PowerManager pm = (PowerManager)mService.mContext.getSystemService(Context.POWER_SERVICE);
611 mGoingToSleep = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "ActivityManager-Sleep");
612 mLaunchingActivity = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "*launch*");
613 mLaunchingActivity.setReferenceCounted(false);
616 // This function returns a IStatusBarService. The value is from ServiceManager.
617 // getService and is cached.
618 private IStatusBarService getStatusBarService() {
619 synchronized (mService) {
620 if (mStatusBarService == null) {
621 mStatusBarService = IStatusBarService.Stub.asInterface(
622 ServiceManager.checkService(Context.STATUS_BAR_SERVICE));
623 if (mStatusBarService == null) {
624 Slog.w("StatusBarManager", "warning: no STATUS_BAR_SERVICE");
627 return mStatusBarService;
631 private IDevicePolicyManager getDevicePolicyManager() {
632 synchronized (mService) {
633 if (mDevicePolicyManager == null) {
634 mDevicePolicyManager = IDevicePolicyManager.Stub.asInterface(
635 ServiceManager.checkService(Context.DEVICE_POLICY_SERVICE));
636 if (mDevicePolicyManager == null) {
637 Slog.w(TAG, "warning: no DEVICE_POLICY_SERVICE");
640 return mDevicePolicyManager;
644 void setWindowManager(WindowManagerService wm) {
645 synchronized (mService) {
647 mKeyguardController.setWindowManager(wm);
650 (DisplayManager)mService.mContext.getSystemService(Context.DISPLAY_SERVICE);
651 mDisplayManager.registerDisplayListener(this, null);
652 mDisplayManagerInternal = LocalServices.getService(DisplayManagerInternal.class);
654 Display[] displays = mDisplayManager.getDisplays();
655 for (int displayNdx = displays.length - 1; displayNdx >= 0; --displayNdx) {
656 final int displayId = displays[displayNdx].getDisplayId();
657 ActivityDisplay activityDisplay = new ActivityDisplay(displayId);
658 if (activityDisplay.mDisplay == null) {
659 throw new IllegalStateException("Default Display does not exist");
661 mActivityDisplays.put(displayId, activityDisplay);
662 calculateDefaultMinimalSizeOfResizeableTasks(activityDisplay);
665 mHomeStack = mFocusedStack = mLastFocusedStack =
666 getStack(HOME_STACK_ID, CREATE_IF_NEEDED, ON_TOP);
668 mInputManagerInternal = LocalServices.getService(InputManagerInternal.class);
672 ActivityStack getFocusedStack() {
673 return mFocusedStack;
676 ActivityStack getLastStack() {
677 return mLastFocusedStack;
680 boolean isFocusedStack(ActivityStack stack) {
685 final ActivityRecord parent = stack.mActivityContainer.mParentActivity;
686 if (parent != null) {
687 stack = parent.getStack();
689 return stack == mFocusedStack;
692 /** The top most stack on its display. */
693 boolean isFrontStackOnDisplay(ActivityStack stack) {
694 return isFrontOfStackList(stack, stack.mActivityContainer.mActivityDisplay.mStacks);
697 private boolean isFrontOfStackList(ActivityStack stack, List<ActivityStack> stackList) {
702 final ActivityRecord parent = stack.mActivityContainer.mParentActivity;
703 if (parent != null) {
704 stack = parent.getStack();
706 return stack == stackList.get((stackList.size() - 1));
709 /** NOTE: Should only be called from {@link ActivityStack#moveToFront} */
710 void setFocusStackUnchecked(String reason, ActivityStack focusCandidate) {
711 if (!focusCandidate.isFocusable()) {
712 // The focus candidate isn't focusable. Move focus to the top stack that is focusable.
713 focusCandidate = getNextFocusableStackLocked(focusCandidate);
716 if (focusCandidate != mFocusedStack) {
717 mLastFocusedStack = mFocusedStack;
718 mFocusedStack = focusCandidate;
720 EventLogTags.writeAmFocusedStack(
721 mCurrentUser, mFocusedStack == null ? -1 : mFocusedStack.getStackId(),
722 mLastFocusedStack == null ? -1 : mLastFocusedStack.getStackId(), reason);
725 final ActivityRecord r = topRunningActivityLocked();
726 if (mService.mBooting || !mService.mBooted) {
727 if (r != null && r.idle) {
728 checkFinishBootingLocked();
733 void moveHomeStackToFront(String reason) {
734 mHomeStack.moveToFront(reason);
737 void moveRecentsStackToFront(String reason) {
738 final ActivityStack recentsStack = getStack(RECENTS_STACK_ID);
739 if (recentsStack != null) {
740 recentsStack.moveToFront(reason);
744 /** Returns true if the focus activity was adjusted to the home stack top activity. */
745 boolean moveHomeStackTaskToTop(String reason) {
746 mHomeStack.moveHomeStackTaskToTop();
748 final ActivityRecord top = getHomeActivity();
752 moveFocusableActivityStackToFrontLocked(top, reason);
756 boolean resumeHomeStackTask(ActivityRecord prev, String reason) {
757 if (!mService.mBooting && !mService.mBooted) {
763 prev.getTask().setTaskToReturnTo(APPLICATION_ACTIVITY_TYPE);
766 mHomeStack.moveHomeStackTaskToTop();
767 ActivityRecord r = getHomeActivity();
768 final String myReason = reason + " resumeHomeStackTask";
770 // Only resume home activity if isn't finishing.
771 if (r != null && !r.finishing) {
772 moveFocusableActivityStackToFrontLocked(r, myReason);
773 return resumeFocusedStackTopActivityLocked(mHomeStack, prev, null);
775 return mService.startHomeActivityLocked(mCurrentUser, myReason);
778 TaskRecord anyTaskForIdLocked(int id) {
779 return anyTaskForIdLocked(id, MATCH_TASK_IN_STACKS_OR_RECENT_TASKS_AND_RESTORE,
784 * Returns a {@link TaskRecord} for the input id if available. {@code null} otherwise.
785 * @param id Id of the task we would like returned.
786 * @param matchMode The mode to match the given task id in.
787 * @param stackId The stack to restore the task to (default launch stack will be used if
788 * stackId is {@link android.app.ActivityManager.StackId#INVALID_STACK_ID}). Only
789 * valid if the matchMode is
790 * {@link #MATCH_TASK_IN_STACKS_OR_RECENT_TASKS_AND_RESTORE}.
792 TaskRecord anyTaskForIdLocked(int id, @AnyTaskForIdMatchTaskMode int matchMode, int stackId) {
793 // If there is a stack id set, ensure that we are attempting to actually restore a task
794 if (matchMode != MATCH_TASK_IN_STACKS_OR_RECENT_TASKS_AND_RESTORE &&
795 stackId != INVALID_STACK_ID) {
796 throw new IllegalArgumentException("Should not specify stackId for non-restore lookup");
799 int numDisplays = mActivityDisplays.size();
800 for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
801 ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
802 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
803 ActivityStack stack = stacks.get(stackNdx);
804 final TaskRecord task = stack.taskForIdLocked(id);
811 // If we are matching stack tasks only, return now
812 if (matchMode == MATCH_TASK_IN_STACKS_ONLY) {
816 // Otherwise, check the recent tasks and return if we find it there and we are not restoring
817 // the task from recents
818 if (DEBUG_RECENTS) Slog.v(TAG_RECENTS, "Looking for task id=" + id + " in recents");
819 final TaskRecord task = mRecentTasks.taskForIdLocked(id);
823 Slog.d(TAG_RECENTS, "\tDidn't find task id=" + id + " in recents");
829 if (matchMode == MATCH_TASK_IN_STACKS_OR_RECENT_TASKS) {
833 // Implicitly, this case is MATCH_TASK_IN_STACKS_OR_RECENT_TASKS_AND_RESTORE
834 if (!restoreRecentTaskLocked(task, stackId)) {
835 if (DEBUG_RECENTS) Slog.w(TAG_RECENTS,
836 "Couldn't restore task id=" + id + " found in recents");
839 if (DEBUG_RECENTS) Slog.w(TAG_RECENTS, "Restored task id=" + id + " from in recents");
843 ActivityRecord isInAnyStackLocked(IBinder token) {
844 int numDisplays = mActivityDisplays.size();
845 for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
846 ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
847 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
848 final ActivityRecord r = stacks.get(stackNdx).isInStackLocked(token);
858 * Detects whether we should show a lock screen in front of this task for a locked user.
860 * We'll do this if either of the following holds:
862 * <li>The top activity explicitly belongs to {@param userId}.</li>
863 * <li>The top activity returns a result to an activity belonging to {@param userId}.</li>
866 * @return {@code true} if the top activity looks like it belongs to {@param userId}.
868 private boolean taskTopActivityIsUser(TaskRecord task, @UserIdInt int userId) {
869 // To handle the case that work app is in the task but just is not the top one.
870 final ActivityRecord activityRecord = task.getTopActivity();
871 final ActivityRecord resultTo = (activityRecord != null ? activityRecord.resultTo : null);
873 return (activityRecord != null && activityRecord.userId == userId)
874 || (resultTo != null && resultTo.userId == userId);
878 * Find all visible task stacks containing {@param userId} and intercept them with an activity
879 * to block out the contents and possibly start a credential-confirming intent.
881 * @param userId user handle for the locked managed profile.
883 void lockAllProfileTasks(@UserIdInt int userId) {
884 mWindowManager.deferSurfaceLayout();
886 final List<ActivityStack> stacks = getStacks();
887 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; stackNdx--) {
888 final List<TaskRecord> tasks = stacks.get(stackNdx).getAllTasks();
889 for (int taskNdx = tasks.size() - 1; taskNdx >= 0; taskNdx--) {
890 final TaskRecord task = tasks.get(taskNdx);
892 // Check the task for a top activity belonging to userId, or returning a result
893 // to an activity belonging to userId. Example case: a document picker for
894 // personal files, opened by a work app, should still get locked.
895 if (taskTopActivityIsUser(task, userId)) {
896 mService.mTaskChangeNotificationController.notifyTaskProfileLocked(
897 task.taskId, userId);
902 mWindowManager.continueSurfaceLayout();
906 void setNextTaskIdForUserLocked(int taskId, int userId) {
907 final int currentTaskId = mCurTaskIdForUser.get(userId, -1);
908 if (taskId > currentTaskId) {
909 mCurTaskIdForUser.put(userId, taskId);
913 static int nextTaskIdForUser(int taskId, int userId) {
914 int nextTaskId = taskId + 1;
915 if (nextTaskId == (userId + 1) * MAX_TASK_IDS_PER_USER) {
916 // Wrap around as there will be smaller task ids that are available now.
917 nextTaskId -= MAX_TASK_IDS_PER_USER;
922 int getNextTaskIdForUserLocked(int userId) {
923 final int currentTaskId = mCurTaskIdForUser.get(userId, userId * MAX_TASK_IDS_PER_USER);
924 // for a userId u, a taskId can only be in the range
925 // [u*MAX_TASK_IDS_PER_USER, (u+1)*MAX_TASK_IDS_PER_USER-1], so if MAX_TASK_IDS_PER_USER
926 // was 10, user 0 could only have taskIds 0 to 9, user 1: 10 to 19, user 2: 20 to 29, so on.
927 int candidateTaskId = nextTaskIdForUser(currentTaskId, userId);
928 while (mRecentTasks.taskIdTakenForUserLocked(candidateTaskId, userId)
929 || anyTaskForIdLocked(candidateTaskId, MATCH_TASK_IN_STACKS_OR_RECENT_TASKS,
930 INVALID_STACK_ID) != null) {
931 candidateTaskId = nextTaskIdForUser(candidateTaskId, userId);
932 if (candidateTaskId == currentTaskId) {
934 // All MAX_TASK_IDS_PER_USER task ids are taken up by running tasks for this user
935 throw new IllegalStateException("Cannot get an available task id."
936 + " Reached limit of " + MAX_TASK_IDS_PER_USER
937 + " running tasks per user.");
940 mCurTaskIdForUser.put(userId, candidateTaskId);
941 return candidateTaskId;
944 ActivityRecord getResumedActivityLocked() {
945 ActivityStack stack = mFocusedStack;
949 ActivityRecord resumedActivity = stack.mResumedActivity;
950 if (resumedActivity == null || resumedActivity.app == null) {
951 resumedActivity = stack.mPausingActivity;
952 if (resumedActivity == null || resumedActivity.app == null) {
953 resumedActivity = stack.topRunningActivityLocked();
956 return resumedActivity;
959 boolean attachApplicationLocked(ProcessRecord app) throws RemoteException {
960 final String processName = app.processName;
961 boolean didSomething = false;
962 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
963 ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
964 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
965 final ActivityStack stack = stacks.get(stackNdx);
966 if (!isFocusedStack(stack)) {
969 stack.getAllRunningVisibleActivitiesLocked(mTmpActivityList);
970 final ActivityRecord top = stack.topRunningActivityLocked();
971 final int size = mTmpActivityList.size();
972 for (int i = 0; i < size; i++) {
973 final ActivityRecord activity = mTmpActivityList.get(i);
974 if (activity.app == null && app.uid == activity.info.applicationInfo.uid
975 && processName.equals(activity.processName)) {
977 if (realStartActivityLocked(activity, app,
978 top == activity /* andResume */, true /* checkConfig */)) {
981 } catch (RemoteException e) {
982 Slog.w(TAG, "Exception in new application when starting activity "
983 + top.intent.getComponent().flattenToShortString(), e);
991 ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
996 boolean allResumedActivitiesIdle() {
997 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
998 ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
999 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
1000 final ActivityStack stack = stacks.get(stackNdx);
1001 if (!isFocusedStack(stack) || stack.numActivities() == 0) {
1004 final ActivityRecord resumedActivity = stack.mResumedActivity;
1005 if (resumedActivity == null || !resumedActivity.idle) {
1006 if (DEBUG_STATES) Slog.d(TAG_STATES, "allResumedActivitiesIdle: stack="
1007 + stack.mStackId + " " + resumedActivity + " not idle");
1012 // Send launch end powerhint when idle
1013 mService.mActivityStarter.sendPowerHintForLaunchEndIfNeeded();
1017 boolean allResumedActivitiesComplete() {
1018 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
1019 ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
1020 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
1021 final ActivityStack stack = stacks.get(stackNdx);
1022 if (isFocusedStack(stack)) {
1023 final ActivityRecord r = stack.mResumedActivity;
1024 if (r != null && r.state != RESUMED) {
1030 // TODO: Not sure if this should check if all Paused are complete too.
1031 if (DEBUG_STACK) Slog.d(TAG_STACK,
1032 "allResumedActivitiesComplete: mLastFocusedStack changing from=" +
1033 mLastFocusedStack + " to=" + mFocusedStack);
1034 mLastFocusedStack = mFocusedStack;
1038 boolean allResumedActivitiesVisible() {
1039 boolean foundResumed = false;
1040 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
1041 ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
1042 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
1043 final ActivityStack stack = stacks.get(stackNdx);
1044 final ActivityRecord r = stack.mResumedActivity;
1046 if (!r.nowVisible || mActivitiesWaitingForVisibleActivity.contains(r)) {
1049 foundResumed = true;
1053 return foundResumed;
1057 * Pause all activities in either all of the stacks or just the back stacks.
1058 * @param userLeaving Passed to pauseActivity() to indicate whether to call onUserLeaving().
1059 * @param resuming The resuming activity.
1060 * @param dontWait The resuming activity isn't going to wait for all activities to be paused
1062 * @return true if any activity was paused as a result of this call.
1064 boolean pauseBackStacks(boolean userLeaving, ActivityRecord resuming, boolean dontWait) {
1065 boolean someActivityPaused = false;
1066 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
1067 ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
1068 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
1069 final ActivityStack stack = stacks.get(stackNdx);
1070 if (!isFocusedStack(stack) && stack.mResumedActivity != null) {
1071 if (DEBUG_STATES) Slog.d(TAG_STATES, "pauseBackStacks: stack=" + stack +
1072 " mResumedActivity=" + stack.mResumedActivity);
1073 someActivityPaused |= stack.startPausingLocked(userLeaving, false, resuming,
1078 return someActivityPaused;
1081 boolean allPausedActivitiesComplete() {
1082 boolean pausing = true;
1083 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
1084 ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
1085 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
1086 final ActivityStack stack = stacks.get(stackNdx);
1087 final ActivityRecord r = stack.mPausingActivity;
1088 if (r != null && r.state != PAUSED && r.state != STOPPED && r.state != STOPPING) {
1091 "allPausedActivitiesComplete: r=" + r + " state=" + r.state);
1102 void pauseChildStacks(ActivityRecord parent, boolean userLeaving, boolean uiSleeping,
1103 ActivityRecord resuming, boolean dontWait) {
1104 // TODO: Put all stacks in supervisor and iterate through them instead.
1105 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
1106 ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
1107 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
1108 final ActivityStack stack = stacks.get(stackNdx);
1109 if (stack.mResumedActivity != null &&
1110 stack.mActivityContainer.mParentActivity == parent) {
1111 stack.startPausingLocked(userLeaving, uiSleeping, resuming, dontWait);
1117 void cancelInitializingActivities() {
1118 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
1119 ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
1120 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
1121 stacks.get(stackNdx).cancelInitializingActivities();
1126 void waitActivityVisible(ComponentName name, WaitResult result) {
1127 final WaitInfo waitInfo = new WaitInfo(name, result);
1128 mWaitingForActivityVisible.add(waitInfo);
1131 void cleanupActivity(ActivityRecord r) {
1132 // Make sure this record is no longer in the pending finishes list.
1133 // This could happen, for example, if we are trimming activities
1134 // down to the max limit while they are still waiting to finish.
1135 mFinishingActivities.remove(r);
1136 mActivitiesWaitingForVisibleActivity.remove(r);
1138 for (int i = mWaitingForActivityVisible.size() - 1; i >= 0; --i) {
1139 if (mWaitingForActivityVisible.get(i).matches(r.realActivity)) {
1140 mWaitingForActivityVisible.remove(i);
1145 void reportActivityVisibleLocked(ActivityRecord r) {
1146 sendWaitingVisibleReportLocked(r);
1149 void sendWaitingVisibleReportLocked(ActivityRecord r) {
1150 boolean changed = false;
1151 for (int i = mWaitingForActivityVisible.size() - 1; i >= 0; --i) {
1152 final WaitInfo w = mWaitingForActivityVisible.get(i);
1153 if (w.matches(r.realActivity)) {
1154 final WaitResult result = w.getResult();
1156 result.timeout = false;
1157 result.who = w.getComponent();
1158 result.totalTime = SystemClock.uptimeMillis() - result.thisTime;
1159 result.thisTime = result.totalTime;
1160 mWaitingForActivityVisible.remove(w);
1164 mService.notifyAll();
1168 void reportTaskToFrontNoLaunch(ActivityRecord r) {
1169 boolean changed = false;
1170 for (int i = mWaitingActivityLaunched.size() - 1; i >= 0; i--) {
1171 WaitResult w = mWaitingActivityLaunched.remove(i);
1172 if (w.who == null) {
1174 // Set result to START_TASK_TO_FRONT so that startActivityMayWait() knows that
1175 // the starting activity ends up moving another activity to front, and it should
1176 // wait for this new activity to become visible instead.
1177 // Do not modify other fields.
1178 w.result = START_TASK_TO_FRONT;
1182 mService.notifyAll();
1186 void reportActivityLaunchedLocked(boolean timeout, ActivityRecord r,
1187 long thisTime, long totalTime) {
1188 boolean changed = false;
1189 for (int i = mWaitingActivityLaunched.size() - 1; i >= 0; i--) {
1190 WaitResult w = mWaitingActivityLaunched.remove(i);
1191 if (w.who == null) {
1193 w.timeout = timeout;
1195 w.who = new ComponentName(r.info.packageName, r.info.name);
1197 w.thisTime = thisTime;
1198 w.totalTime = totalTime;
1199 // Do not modify w.result.
1203 mService.notifyAll();
1207 ActivityRecord topRunningActivityLocked() {
1208 final ActivityStack focusedStack = mFocusedStack;
1209 ActivityRecord r = focusedStack.topRunningActivityLocked();
1214 // Look in other non-focused and non-home stacks.
1215 mWindowManager.getDisplaysInFocusOrder(mTmpOrderedDisplayIds);
1217 for (int i = mTmpOrderedDisplayIds.size() - 1; i >= 0; --i) {
1218 final int displayId = mTmpOrderedDisplayIds.get(i);
1219 final List<ActivityStack> stacks = mActivityDisplays.get(displayId).mStacks;
1220 if (stacks == null) {
1223 for (int j = stacks.size() - 1; j >= 0; --j) {
1224 final ActivityStack stack = stacks.get(j);
1225 if (stack != focusedStack && isFrontStackOnDisplay(stack) && stack.isFocusable()) {
1226 r = stack.topRunningActivityLocked();
1236 void getTasksLocked(int maxNum, List<RunningTaskInfo> list, int callingUid, boolean allowed) {
1237 // Gather all of the running tasks for each stack into runningTaskLists.
1238 ArrayList<ArrayList<RunningTaskInfo>> runningTaskLists =
1239 new ArrayList<ArrayList<RunningTaskInfo>>();
1240 final int numDisplays = mActivityDisplays.size();
1241 for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
1242 ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
1243 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
1244 final ActivityStack stack = stacks.get(stackNdx);
1245 ArrayList<RunningTaskInfo> stackTaskList = new ArrayList<>();
1246 runningTaskLists.add(stackTaskList);
1247 stack.getTasksLocked(stackTaskList, callingUid, allowed);
1251 // The lists are already sorted from most recent to oldest. Just pull the most recent off
1252 // each list and add it to list. Stop when all lists are empty or maxNum reached.
1253 while (maxNum > 0) {
1254 long mostRecentActiveTime = Long.MIN_VALUE;
1255 ArrayList<RunningTaskInfo> selectedStackList = null;
1256 final int numTaskLists = runningTaskLists.size();
1257 for (int stackNdx = 0; stackNdx < numTaskLists; ++stackNdx) {
1258 ArrayList<RunningTaskInfo> stackTaskList = runningTaskLists.get(stackNdx);
1259 if (!stackTaskList.isEmpty()) {
1260 final long lastActiveTime = stackTaskList.get(0).lastActiveTime;
1261 if (lastActiveTime > mostRecentActiveTime) {
1262 mostRecentActiveTime = lastActiveTime;
1263 selectedStackList = stackTaskList;
1267 if (selectedStackList != null) {
1268 list.add(selectedStackList.remove(0));
1276 ActivityInfo resolveActivity(Intent intent, ResolveInfo rInfo, int startFlags,
1277 ProfilerInfo profilerInfo) {
1278 final ActivityInfo aInfo = rInfo != null ? rInfo.activityInfo : null;
1279 if (aInfo != null) {
1280 // Store the found target back into the intent, because now that
1281 // we have it we never want to do this again. For example, if the
1282 // user navigates back to this point in the history, we should
1283 // always restart the exact same activity.
1284 intent.setComponent(new ComponentName(
1285 aInfo.applicationInfo.packageName, aInfo.name));
1287 // Don't debug things in the system process
1288 if (!aInfo.processName.equals("system")) {
1289 if ((startFlags & ActivityManager.START_FLAG_DEBUG) != 0) {
1290 mService.setDebugApp(aInfo.processName, true, false);
1293 if ((startFlags & ActivityManager.START_FLAG_NATIVE_DEBUGGING) != 0) {
1294 mService.setNativeDebuggingAppLocked(aInfo.applicationInfo, aInfo.processName);
1297 if ((startFlags & ActivityManager.START_FLAG_TRACK_ALLOCATION) != 0) {
1298 mService.setTrackAllocationApp(aInfo.applicationInfo, aInfo.processName);
1301 if (profilerInfo != null) {
1302 mService.setProfileApp(aInfo.applicationInfo, aInfo.processName, profilerInfo);
1305 final String intentLaunchToken = intent.getLaunchToken();
1306 if (aInfo.launchToken == null && intentLaunchToken != null) {
1307 aInfo.launchToken = intentLaunchToken;
1313 ResolveInfo resolveIntent(Intent intent, String resolvedType, int userId) {
1314 return resolveIntent(intent, resolvedType, userId, 0);
1317 ResolveInfo resolveIntent(Intent intent, String resolvedType, int userId, int flags) {
1318 synchronized (mService) {
1319 return mService.getPackageManagerInternalLocked().resolveIntent(intent, resolvedType,
1320 PackageManager.MATCH_INSTANT | PackageManager.MATCH_DEFAULT_ONLY | flags
1321 | ActivityManagerService.STOCK_PM_FLAGS, userId);
1325 ActivityInfo resolveActivity(Intent intent, String resolvedType, int startFlags,
1326 ProfilerInfo profilerInfo, int userId) {
1327 final ResolveInfo rInfo = resolveIntent(intent, resolvedType, userId);
1328 return resolveActivity(intent, rInfo, startFlags, profilerInfo);
1331 final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
1332 boolean andResume, boolean checkConfig) throws RemoteException {
1334 if (!allPausedActivitiesComplete()) {
1335 // While there are activities pausing we skipping starting any new activities until
1336 // pauses are complete. NOTE: that we also do this for activities that are starting in
1337 // the paused state because they will first be resumed then paused on the client side.
1338 if (DEBUG_SWITCH || DEBUG_PAUSE || DEBUG_STATES) Slog.v(TAG_PAUSE,
1339 "realStartActivityLocked: Skipping start of r=" + r
1340 + " some activities pausing...");
1344 r.startFreezingScreenLocked(app, 0);
1345 if (r.getStack().checkKeyguardVisibility(r, true /* shouldBeVisible */, true /* isTop */)) {
1346 // We only set the visibility to true if the activity is allowed to be visible based on
1347 // keyguard state. This avoids setting this into motion in window manager that is later
1348 // cancelled due to later calls to ensure visible activities that set visibility back to
1350 r.setVisibility(true);
1353 // schedule launch ticks to collect information about slow apps.
1354 r.startLaunchTickingLocked();
1356 // Have the window manager re-evaluate the orientation of the screen based on the new
1357 // activity order. Note that as a result of this, it can call back into the activity
1358 // manager with a new orientation. We don't care about that, because the activity is not
1359 // currently running so we are just restarting it anyway.
1361 final int displayId = r.getDisplayId();
1362 final Configuration config = mWindowManager.updateOrientationFromAppTokens(
1363 getDisplayOverrideConfiguration(displayId),
1364 r.mayFreezeScreenLocked(app) ? r.appToken : null, displayId);
1365 // Deferring resume here because we're going to launch new activity shortly.
1366 // We don't want to perform a redundant launch of the same record while ensuring
1367 // configurations and trying to resume top activity of focused stack.
1368 mService.updateDisplayOverrideConfigurationLocked(config, r, true /* deferResume */,
1372 if (mKeyguardController.isKeyguardLocked()) {
1373 r.notifyUnknownVisibilityLaunched();
1375 final int applicationInfoUid =
1376 (r.info.applicationInfo != null) ? r.info.applicationInfo.uid : -1;
1377 if ((r.userId != app.userId) || (r.appInfo.uid != applicationInfoUid)) {
1379 "User ID for activity changing for " + r
1380 + " appInfo.uid=" + r.appInfo.uid
1381 + " info.ai.uid=" + applicationInfoUid
1382 + " old=" + r.app + " new=" + app);
1386 app.waitingToKill = null;
1388 r.lastLaunchTime = SystemClock.uptimeMillis();
1390 if (DEBUG_ALL) Slog.v(TAG, "Launching: " + r);
1392 int idx = app.activities.indexOf(r);
1394 app.activities.add(r);
1396 mService.updateLruProcessLocked(app, true, null);
1397 mService.updateOomAdjLocked();
1399 final TaskRecord task = r.getTask();
1400 if (task.mLockTaskAuth == LOCK_TASK_AUTH_LAUNCHABLE ||
1401 task.mLockTaskAuth == LOCK_TASK_AUTH_LAUNCHABLE_PRIV) {
1402 setLockTaskModeLocked(task, LOCK_TASK_MODE_LOCKED, "mLockTaskAuth==LAUNCHABLE", false);
1405 final ActivityStack stack = task.getStack();
1407 if (app.thread == null) {
1408 throw new RemoteException();
1410 List<ResultInfo> results = null;
1411 List<ReferrerIntent> newIntents = null;
1413 // We don't need to deliver new intents and/or set results if activity is going
1414 // to pause immediately after launch.
1415 results = r.results;
1416 newIntents = r.newIntents;
1418 if (DEBUG_SWITCH) Slog.v(TAG_SWITCH,
1419 "Launching: " + r + " icicle=" + r.icicle + " with results=" + results
1420 + " newIntents=" + newIntents + " andResume=" + andResume);
1421 EventLog.writeEvent(EventLogTags.AM_RESTART_ACTIVITY, r.userId,
1422 System.identityHashCode(r), task.taskId, r.shortComponentName);
1423 if (r.isHomeActivity()) {
1424 // Home process is the root process of the task.
1425 mService.mHomeProcess = task.mActivities.get(0).app;
1427 mService.notifyPackageUse(r.intent.getComponent().getPackageName(),
1428 PackageManager.NOTIFY_PACKAGE_USE_ACTIVITY);
1430 r.forceNewConfig = false;
1431 mService.showUnsupportedZoomDialogIfNeededLocked(r);
1432 mService.showAskCompatModeDialogLocked(r);
1433 r.compat = mService.compatibilityInfoForPackageLocked(r.info.applicationInfo);
1434 ProfilerInfo profilerInfo = null;
1435 if (mService.mProfileApp != null && mService.mProfileApp.equals(app.processName)) {
1436 if (mService.mProfileProc == null || mService.mProfileProc == app) {
1437 mService.mProfileProc = app;
1438 final String profileFile = mService.mProfileFile;
1439 if (profileFile != null) {
1440 ParcelFileDescriptor profileFd = mService.mProfileFd;
1441 if (profileFd != null) {
1443 profileFd = profileFd.dup();
1444 } catch (IOException e) {
1445 if (profileFd != null) {
1448 } catch (IOException o) {
1455 profilerInfo = new ProfilerInfo(profileFile, profileFd,
1456 mService.mSamplingInterval, mService.mAutoStopProfiler,
1457 mService.mStreamingOutput);
1462 app.hasShownUi = true;
1463 app.pendingUiClean = true;
1464 app.forceProcessStateUpTo(mService.mTopProcessState);
1465 // Because we could be starting an Activity in the system process this may not go across
1466 // a Binder interface which would create a new Configuration. Consequently we have to
1467 // always create a new Configuration here.
1469 final MergedConfiguration mergedConfiguration = new MergedConfiguration(
1470 mService.getGlobalConfiguration(), r.getMergedOverrideConfiguration());
1471 r.setLastReportedConfiguration(mergedConfiguration);
1473 logIfTransactionTooLarge(r.intent, r.icicle);
1474 app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken,
1475 System.identityHashCode(r), r.info,
1476 // TODO: Have this take the merged configuration instead of separate global and
1477 // override configs.
1478 mergedConfiguration.getGlobalConfiguration(),
1479 mergedConfiguration.getOverrideConfiguration(), r.compat,
1480 r.launchedFromPackage, task.voiceInteractor, app.repProcState, r.icicle,
1481 r.persistentState, results, newIntents, !andResume,
1482 mService.isNextTransitionForward(), profilerInfo);
1484 if ((app.info.privateFlags&ApplicationInfo.PRIVATE_FLAG_CANT_SAVE_STATE) != 0) {
1485 // This may be a heavy-weight process! Note that the package
1486 // manager will ensure that only activity can run in the main
1487 // process of the .apk, which is the only thing that will be
1488 // considered heavy-weight.
1489 if (app.processName.equals(app.info.packageName)) {
1490 if (mService.mHeavyWeightProcess != null
1491 && mService.mHeavyWeightProcess != app) {
1492 Slog.w(TAG, "Starting new heavy weight process " + app
1493 + " when already running "
1494 + mService.mHeavyWeightProcess);
1496 mService.mHeavyWeightProcess = app;
1497 Message msg = mService.mHandler.obtainMessage(
1498 ActivityManagerService.POST_HEAVY_NOTIFICATION_MSG);
1500 mService.mHandler.sendMessage(msg);
1504 } catch (RemoteException e) {
1505 if (r.launchFailed) {
1506 // This is the second time we failed -- finish activity
1508 Slog.e(TAG, "Second failure launching "
1509 + r.intent.getComponent().flattenToShortString()
1510 + ", giving up", e);
1511 mService.appDiedLocked(app);
1512 stack.requestFinishActivityLocked(r.appToken, Activity.RESULT_CANCELED, null,
1513 "2nd-crash", false);
1517 // This is the first time we failed -- restart process and
1519 r.launchFailed = true;
1520 app.activities.remove(r);
1524 r.launchFailed = false;
1525 if (stack.updateLRUListLocked(r)) {
1526 Slog.w(TAG, "Activity " + r + " being launched, but already in LRU list");
1530 // As part of the process of launching, ActivityThread also performs
1532 stack.minimalResumeActivityLocked(r);
1534 // This activity is not starting in the resumed state... which should look like we asked
1535 // it to pause+stop (but remain visible), and it has done so and reported back the
1536 // current icicle and other state.
1537 if (DEBUG_STATES) Slog.v(TAG_STATES,
1538 "Moving to PAUSED: " + r + " (starting in paused state)");
1542 // Launch the new version setup screen if needed. We do this -after-
1543 // launching the initial activity (that is, home), so that it can have
1544 // a chance to initialize itself while in the background, making the
1545 // switch back to it faster and look better.
1546 if (isFocusedStack(stack)) {
1547 mService.startSetupActivityLocked();
1550 // Update any services we are bound to that might care about whether
1551 // their client may have activities.
1552 if (r.app != null) {
1553 mService.mServices.updateServiceConnectionActivitiesLocked(r.app);
1559 private void logIfTransactionTooLarge(Intent intent, Bundle icicle) {
1561 if (intent != null) {
1562 final Bundle extras = intent.getExtras();
1563 if (extras != null) {
1564 extrasSize = extras.getSize();
1567 int icicleSize = (icicle == null ? 0 : icicle.getSize());
1568 if (extrasSize + icicleSize > 200000) {
1569 Slog.e(TAG, "Transaction too large, intent: " + intent + ", extras size: " + extrasSize
1570 + ", icicle size: " + icicleSize);
1574 void startSpecificActivityLocked(ActivityRecord r,
1575 boolean andResume, boolean checkConfig) {
1576 // Is this activity's application already running?
1577 ProcessRecord app = mService.getProcessRecordLocked(r.processName,
1578 r.info.applicationInfo.uid, true);
1580 r.getStack().setLaunchTime(r);
1582 if (app != null && app.thread != null) {
1584 if ((r.info.flags&ActivityInfo.FLAG_MULTIPROCESS) == 0
1585 || !"android".equals(r.info.packageName)) {
1586 // Don't add this if it is a platform component that is marked
1587 // to run in multiple processes, because this is actually
1588 // part of the framework so doesn't make sense to track as a
1589 // separate apk in the process.
1590 app.addPackage(r.info.packageName, r.info.applicationInfo.versionCode,
1591 mService.mProcessStats);
1593 realStartActivityLocked(r, app, andResume, checkConfig);
1595 } catch (RemoteException e) {
1596 Slog.w(TAG, "Exception when starting activity "
1597 + r.intent.getComponent().flattenToShortString(), e);
1600 // If a dead object exception was thrown -- fall through to
1601 // restart the application.
1604 mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,
1605 "activity", r.intent.getComponent(), false, false, true);
1608 boolean checkStartAnyActivityPermission(Intent intent, ActivityInfo aInfo,
1609 String resultWho, int requestCode, int callingPid, int callingUid,
1610 String callingPackage, boolean ignoreTargetSecurity, ProcessRecord callerApp,
1611 ActivityRecord resultRecord, ActivityStack resultStack, ActivityOptions options) {
1612 final int startAnyPerm = mService.checkPermission(START_ANY_ACTIVITY, callingPid,
1614 if (startAnyPerm == PERMISSION_GRANTED) {
1617 final int componentRestriction = getComponentRestrictionForCallingPackage(
1618 aInfo, callingPackage, callingPid, callingUid, ignoreTargetSecurity);
1619 final int actionRestriction = getActionRestrictionForCallingPackage(
1620 intent.getAction(), callingPackage, callingPid, callingUid);
1621 if (componentRestriction == ACTIVITY_RESTRICTION_PERMISSION
1622 || actionRestriction == ACTIVITY_RESTRICTION_PERMISSION) {
1623 if (resultRecord != null) {
1624 resultStack.sendActivityResultLocked(-1,
1625 resultRecord, resultWho, requestCode,
1626 Activity.RESULT_CANCELED, null);
1629 if (actionRestriction == ACTIVITY_RESTRICTION_PERMISSION) {
1630 msg = "Permission Denial: starting " + intent.toString()
1631 + " from " + callerApp + " (pid=" + callingPid
1632 + ", uid=" + callingUid + ")" + " with revoked permission "
1633 + ACTION_TO_RUNTIME_PERMISSION.get(intent.getAction());
1634 } else if (!aInfo.exported) {
1635 msg = "Permission Denial: starting " + intent.toString()
1636 + " from " + callerApp + " (pid=" + callingPid
1637 + ", uid=" + callingUid + ")"
1638 + " not exported from uid " + aInfo.applicationInfo.uid;
1640 msg = "Permission Denial: starting " + intent.toString()
1641 + " from " + callerApp + " (pid=" + callingPid
1642 + ", uid=" + callingUid + ")"
1643 + " requires " + aInfo.permission;
1646 throw new SecurityException(msg);
1649 if (actionRestriction == ACTIVITY_RESTRICTION_APPOP) {
1650 final String message = "Appop Denial: starting " + intent.toString()
1651 + " from " + callerApp + " (pid=" + callingPid
1652 + ", uid=" + callingUid + ")"
1653 + " requires " + AppOpsManager.permissionToOp(
1654 ACTION_TO_RUNTIME_PERMISSION.get(intent.getAction()));
1655 Slog.w(TAG, message);
1657 } else if (componentRestriction == ACTIVITY_RESTRICTION_APPOP) {
1658 final String message = "Appop Denial: starting " + intent.toString()
1659 + " from " + callerApp + " (pid=" + callingPid
1660 + ", uid=" + callingUid + ")"
1661 + " requires appop " + AppOpsManager.permissionToOp(aInfo.permission);
1662 Slog.w(TAG, message);
1665 if (options != null) {
1666 if (options.getLaunchTaskId() != INVALID_STACK_ID) {
1667 final int startInTaskPerm = mService.checkPermission(START_TASKS_FROM_RECENTS,
1668 callingPid, callingUid);
1669 if (startInTaskPerm != PERMISSION_GRANTED) {
1670 final String msg = "Permission Denial: starting " + intent.toString()
1671 + " from " + callerApp + " (pid=" + callingPid
1672 + ", uid=" + callingUid + ") with launchTaskId="
1673 + options.getLaunchTaskId();
1675 throw new SecurityException(msg);
1678 // Check if someone tries to launch an activity on a private display with a different
1680 final int launchDisplayId = options.getLaunchDisplayId();
1681 if (launchDisplayId != INVALID_DISPLAY
1682 && !isCallerAllowedToLaunchOnDisplay(callingPid, callingUid, launchDisplayId)) {
1683 final String msg = "Permission Denial: starting " + intent.toString()
1684 + " from " + callerApp + " (pid=" + callingPid
1685 + ", uid=" + callingUid + ") with launchDisplayId="
1688 throw new SecurityException(msg);
1695 /** Check if caller is allowed to launch activities on specified display. */
1696 boolean isCallerAllowedToLaunchOnDisplay(int callingPid, int callingUid, int launchDisplayId) {
1697 if (DEBUG_TASKS) Slog.d(TAG, "Launch on display check: displayId=" + launchDisplayId
1698 + " callingPid=" + callingPid + " callingUid=" + callingUid);
1700 final ActivityDisplay activityDisplay = getActivityDisplayOrCreateLocked(launchDisplayId);
1701 if (activityDisplay == null) {
1702 Slog.w(TAG, "Launch on display check: display not found");
1706 // Check if the caller can manage activity stacks.
1707 final int startAnyPerm = mService.checkPermission(INTERNAL_SYSTEM_WINDOW, callingPid,
1709 if (startAnyPerm == PERMISSION_GRANTED) {
1710 if (DEBUG_TASKS) Slog.d(TAG, "Launch on display check:"
1711 + " allow launch any on display");
1715 if (activityDisplay.mDisplay.getType() == TYPE_VIRTUAL
1716 && activityDisplay.mDisplay.getOwnerUid() != SYSTEM_UID) {
1717 // Limit launching on virtual displays, because their contents can be read from Surface
1718 // by apps that created them.
1719 if (DEBUG_TASKS) Slog.d(TAG, "Launch on display check:"
1720 + " disallow launch on virtual display for not-embedded activity");
1724 if (!activityDisplay.isPrivate()) {
1725 // Anyone can launch on a public display.
1726 if (DEBUG_TASKS) Slog.d(TAG, "Launch on display check:"
1727 + " allow launch on public display");
1731 // Check if the caller is the owner of the display.
1732 if (activityDisplay.mDisplay.getOwnerUid() == callingUid) {
1733 if (DEBUG_TASKS) Slog.d(TAG, "Launch on display check:"
1734 + " allow launch for owner of the display");
1738 // Check if caller is present on display
1739 if (activityDisplay.isUidPresent(callingUid)) {
1740 if (DEBUG_TASKS) Slog.d(TAG, "Launch on display check:"
1741 + " allow launch for caller present on the display");
1745 Slog.w(TAG, "Launch on display check: denied");
1749 /** Update lists of UIDs that are present on displays and have access to them. */
1750 void updateUIDsPresentOnDisplay() {
1751 mDisplayAccessUIDs.clear();
1752 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
1753 final ActivityDisplay activityDisplay = mActivityDisplays.valueAt(displayNdx);
1754 // Only bother calculating the whitelist for private displays
1755 if (activityDisplay.isPrivate()) {
1756 mDisplayAccessUIDs.append(
1757 activityDisplay.mDisplayId, activityDisplay.getPresentUIDs());
1760 // Store updated lists in DisplayManager. Callers from outside of AM should get them there.
1761 mDisplayManagerInternal.setDisplayAccessUIDs(mDisplayAccessUIDs);
1764 UserInfo getUserInfo(int userId) {
1765 final long identity = Binder.clearCallingIdentity();
1767 return UserManager.get(mService.mContext).getUserInfo(userId);
1769 Binder.restoreCallingIdentity(identity);
1773 private int getComponentRestrictionForCallingPackage(ActivityInfo activityInfo,
1774 String callingPackage, int callingPid, int callingUid, boolean ignoreTargetSecurity) {
1775 if (!ignoreTargetSecurity && mService.checkComponentPermission(activityInfo.permission,
1776 callingPid, callingUid, activityInfo.applicationInfo.uid, activityInfo.exported)
1777 == PackageManager.PERMISSION_DENIED) {
1778 return ACTIVITY_RESTRICTION_PERMISSION;
1781 if (activityInfo.permission == null) {
1782 return ACTIVITY_RESTRICTION_NONE;
1785 final int opCode = AppOpsManager.permissionToOpCode(activityInfo.permission);
1786 if (opCode == AppOpsManager.OP_NONE) {
1787 return ACTIVITY_RESTRICTION_NONE;
1790 if (mService.mAppOpsService.noteOperation(opCode, callingUid,
1791 callingPackage) != AppOpsManager.MODE_ALLOWED) {
1792 if (!ignoreTargetSecurity) {
1793 return ACTIVITY_RESTRICTION_APPOP;
1797 return ACTIVITY_RESTRICTION_NONE;
1800 private int getActionRestrictionForCallingPackage(String action,
1801 String callingPackage, int callingPid, int callingUid) {
1802 if (action == null) {
1803 return ACTIVITY_RESTRICTION_NONE;
1806 String permission = ACTION_TO_RUNTIME_PERMISSION.get(action);
1807 if (permission == null) {
1808 return ACTIVITY_RESTRICTION_NONE;
1811 final PackageInfo packageInfo;
1813 packageInfo = mService.mContext.getPackageManager()
1814 .getPackageInfo(callingPackage, PackageManager.GET_PERMISSIONS);
1815 } catch (PackageManager.NameNotFoundException e) {
1816 Slog.i(TAG, "Cannot find package info for " + callingPackage);
1817 return ACTIVITY_RESTRICTION_NONE;
1820 if (!ArrayUtils.contains(packageInfo.requestedPermissions, permission)) {
1821 return ACTIVITY_RESTRICTION_NONE;
1824 if (mService.checkPermission(permission, callingPid, callingUid) ==
1825 PackageManager.PERMISSION_DENIED) {
1826 return ACTIVITY_RESTRICTION_PERMISSION;
1829 final int opCode = AppOpsManager.permissionToOpCode(permission);
1830 if (opCode == AppOpsManager.OP_NONE) {
1831 return ACTIVITY_RESTRICTION_NONE;
1834 if (mService.mAppOpsService.noteOperation(opCode, callingUid,
1835 callingPackage) != AppOpsManager.MODE_ALLOWED) {
1836 return ACTIVITY_RESTRICTION_APPOP;
1839 return ACTIVITY_RESTRICTION_NONE;
1842 void setLaunchSource(int uid) {
1843 mLaunchingActivity.setWorkSource(new WorkSource(uid));
1846 void acquireLaunchWakelock() {
1847 if (VALIDATE_WAKE_LOCK_CALLER && Binder.getCallingUid() != Process.myUid()) {
1848 throw new IllegalStateException("Calling must be system uid");
1850 mLaunchingActivity.acquire();
1851 if (!mHandler.hasMessages(LAUNCH_TIMEOUT_MSG)) {
1852 // To be safe, don't allow the wake lock to be held for too long.
1853 mHandler.sendEmptyMessageDelayed(LAUNCH_TIMEOUT_MSG, LAUNCH_TIMEOUT);
1858 * Called when the frontmost task is idle.
1859 * @return the state of mService.mBooting before this was called.
1861 private boolean checkFinishBootingLocked() {
1862 final boolean booting = mService.mBooting;
1863 boolean enableScreen = false;
1864 mService.mBooting = false;
1865 if (!mService.mBooted) {
1866 mService.mBooted = true;
1867 enableScreen = true;
1869 if (booting || enableScreen) {
1870 mService.postFinishBooting(booting, enableScreen);
1876 final ActivityRecord activityIdleInternalLocked(final IBinder token, boolean fromTimeout,
1877 boolean processPausingActivities, Configuration config) {
1878 if (DEBUG_ALL) Slog.v(TAG, "Activity idle: " + token);
1880 ArrayList<ActivityRecord> finishes = null;
1881 ArrayList<UserState> startingUsers = null;
1884 boolean booting = false;
1885 boolean activityRemoved = false;
1887 ActivityRecord r = ActivityRecord.forTokenLocked(token);
1889 if (DEBUG_IDLE) Slog.d(TAG_IDLE, "activityIdleInternalLocked: Callers="
1890 + Debug.getCallers(4));
1891 mHandler.removeMessages(IDLE_TIMEOUT_MSG, r);
1892 r.finishLaunchTickingLocked();
1894 reportActivityLaunchedLocked(fromTimeout, r, -1, -1);
1897 // This is a hack to semi-deal with a race condition
1898 // in the client where it can be constructed with a
1899 // newer configuration from when we asked it to launch.
1900 // We'll update with whatever configuration it now says
1901 // it used to launch.
1902 if (config != null) {
1903 r.setLastReportedGlobalConfiguration(config);
1906 // We are now idle. If someone is waiting for a thumbnail from
1907 // us, we can now deliver.
1910 //Slog.i(TAG, "IDLE: mBooted=" + mBooted + ", fromTimeout=" + fromTimeout);
1911 if (isFocusedStack(r.getStack()) || fromTimeout) {
1912 booting = checkFinishBootingLocked();
1916 if (allResumedActivitiesIdle()) {
1918 mService.scheduleAppGcsLocked();
1921 if (mLaunchingActivity.isHeld()) {
1922 mHandler.removeMessages(LAUNCH_TIMEOUT_MSG);
1923 if (VALIDATE_WAKE_LOCK_CALLER &&
1924 Binder.getCallingUid() != Process.myUid()) {
1925 throw new IllegalStateException("Calling must be system uid");
1927 mLaunchingActivity.release();
1929 ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
1932 // Atomically retrieve all of the other things to do.
1933 final ArrayList<ActivityRecord> stops = processStoppingActivitiesLocked(r,
1934 true /* remove */, processPausingActivities);
1935 NS = stops != null ? stops.size() : 0;
1936 if ((NF = mFinishingActivities.size()) > 0) {
1937 finishes = new ArrayList<>(mFinishingActivities);
1938 mFinishingActivities.clear();
1941 if (mStartingUsers.size() > 0) {
1942 startingUsers = new ArrayList<>(mStartingUsers);
1943 mStartingUsers.clear();
1946 // Stop any activities that are scheduled to do so but have been
1947 // waiting for the next one to start.
1948 for (int i = 0; i < NS; i++) {
1950 final ActivityStack stack = r.getStack();
1951 if (stack != null) {
1953 stack.finishCurrentActivityLocked(r, ActivityStack.FINISH_IMMEDIATELY, false);
1955 stack.stopActivityLocked(r);
1960 // Finish any activities that are scheduled to do so but have been
1961 // waiting for the next one to start.
1962 for (int i = 0; i < NF; i++) {
1963 r = finishes.get(i);
1964 final ActivityStack stack = r.getStack();
1965 if (stack != null) {
1966 activityRemoved |= stack.destroyActivityLocked(r, true, "finish-idle");
1971 // Complete user switch
1972 if (startingUsers != null) {
1973 for (int i = 0; i < startingUsers.size(); i++) {
1974 mService.mUserController.finishUserSwitch(startingUsers.get(i));
1979 mService.trimApplications();
1981 //mWindowManager.dump();
1983 if (activityRemoved) {
1984 resumeFocusedStackTopActivityLocked();
1990 boolean handleAppDiedLocked(ProcessRecord app) {
1991 boolean hasVisibleActivities = false;
1992 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
1993 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
1994 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
1995 hasVisibleActivities |= stacks.get(stackNdx).handleAppDiedLocked(app);
1998 return hasVisibleActivities;
2001 void closeSystemDialogsLocked() {
2002 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
2003 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
2004 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
2005 stacks.get(stackNdx).closeSystemDialogsLocked();
2010 void removeUserLocked(int userId) {
2011 mUserStackInFront.delete(userId);
2015 * Update the last used stack id for non-current user (current user's last
2016 * used stack is the focused stack)
2018 void updateUserStackLocked(int userId, ActivityStack stack) {
2019 if (userId != mCurrentUser) {
2020 mUserStackInFront.put(userId, stack != null ? stack.getStackId() : HOME_STACK_ID);
2025 * @return true if some activity was finished (or would have finished if doit were true).
2027 boolean finishDisabledPackageActivitiesLocked(String packageName, Set<String> filterByClasses,
2028 boolean doit, boolean evenPersistent, int userId) {
2029 boolean didSomething = false;
2030 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
2031 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
2032 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
2033 final ActivityStack stack = stacks.get(stackNdx);
2034 if (stack.finishDisabledPackageActivitiesLocked(
2035 packageName, filterByClasses, doit, evenPersistent, userId)) {
2036 didSomething = true;
2040 return didSomething;
2043 void updatePreviousProcessLocked(ActivityRecord r) {
2044 // Now that this process has stopped, we may want to consider
2045 // it to be the previous app to try to keep around in case
2046 // the user wants to return to it.
2048 // First, found out what is currently the foreground app, so that
2049 // we don't blow away the previous app if this activity is being
2050 // hosted by the process that is actually still the foreground.
2051 ProcessRecord fgApp = null;
2052 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
2053 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
2054 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
2055 final ActivityStack stack = stacks.get(stackNdx);
2056 if (isFocusedStack(stack)) {
2057 if (stack.mResumedActivity != null) {
2058 fgApp = stack.mResumedActivity.app;
2059 } else if (stack.mPausingActivity != null) {
2060 fgApp = stack.mPausingActivity.app;
2067 // Now set this one as the previous process, only if that really
2069 if (r.app != null && fgApp != null && r.app != fgApp
2070 && r.lastVisibleTime > mService.mPreviousProcessVisibleTime
2071 && r.app != mService.mHomeProcess) {
2072 mService.mPreviousProcess = r.app;
2073 mService.mPreviousProcessVisibleTime = r.lastVisibleTime;
2077 boolean resumeFocusedStackTopActivityLocked() {
2078 return resumeFocusedStackTopActivityLocked(null, null, null);
2081 boolean resumeFocusedStackTopActivityLocked(
2082 ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
2083 if (targetStack != null && isFocusedStack(targetStack)) {
2084 return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
2086 final ActivityRecord r = mFocusedStack.topRunningActivityLocked();
2087 if (r == null || r.state != RESUMED) {
2088 mFocusedStack.resumeTopActivityUncheckedLocked(null, null);
2089 } else if (r.state == RESUMED) {
2090 // Kick off any lingering app transitions form the MoveTaskToFront operation.
2091 mFocusedStack.executeAppTransition(targetOptions);
2096 void updateActivityApplicationInfoLocked(ApplicationInfo aInfo) {
2097 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
2098 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
2099 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
2100 stacks.get(stackNdx).updateActivityApplicationInfoLocked(aInfo);
2105 TaskRecord finishTopRunningActivityLocked(ProcessRecord app, String reason) {
2106 TaskRecord finishedTask = null;
2107 ActivityStack focusedStack = getFocusedStack();
2108 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
2109 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
2110 final int numStacks = stacks.size();
2111 for (int stackNdx = 0; stackNdx < numStacks; ++stackNdx) {
2112 final ActivityStack stack = stacks.get(stackNdx);
2113 TaskRecord t = stack.finishTopRunningActivityLocked(app, reason);
2114 if (stack == focusedStack || finishedTask == null) {
2119 return finishedTask;
2122 void finishVoiceTask(IVoiceInteractionSession session) {
2123 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
2124 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
2125 final int numStacks = stacks.size();
2126 for (int stackNdx = 0; stackNdx < numStacks; ++stackNdx) {
2127 final ActivityStack stack = stacks.get(stackNdx);
2128 stack.finishVoiceTask(session);
2133 void findTaskToMoveToFrontLocked(TaskRecord task, int flags, ActivityOptions options,
2134 String reason, boolean forceNonResizeable) {
2135 if ((flags & ActivityManager.MOVE_TASK_NO_USER_ACTION) == 0) {
2136 mUserLeaving = true;
2138 if ((flags & ActivityManager.MOVE_TASK_WITH_HOME) != 0) {
2139 // Caller wants the home activity moved with it. To accomplish this,
2140 // we'll just indicate that this task returns to the home task.
2141 task.setTaskToReturnTo(HOME_ACTIVITY_TYPE);
2143 ActivityStack currentStack = task.getStack();
2144 if (currentStack == null) {
2145 Slog.e(TAG, "findTaskToMoveToFrontLocked: can't move task="
2146 + task + " to front. Stack is null");
2150 if (task.isResizeable() && options != null) {
2151 int stackId = options.getLaunchStackId();
2152 if (canUseActivityOptionsLaunchBounds(options, stackId)) {
2153 final Rect bounds = TaskRecord.validateBounds(options.getLaunchBounds());
2154 task.updateOverrideConfiguration(bounds);
2155 if (stackId == INVALID_STACK_ID) {
2156 stackId = task.getLaunchStackId();
2158 if (stackId != currentStack.mStackId) {
2159 task.reparent(stackId, ON_TOP, REPARENT_KEEP_STACK_AT_FRONT, !ANIMATE,
2160 DEFER_RESUME, "findTaskToMoveToFrontLocked");
2161 stackId = currentStack.mStackId;
2162 // moveTaskToStackUncheckedLocked() should already placed the task on top,
2163 // still need moveTaskToFrontLocked() below for any transition settings.
2165 if (StackId.resizeStackWithLaunchBounds(stackId)) {
2166 resizeStackLocked(stackId, bounds,
2167 null /* tempTaskBounds */, null /* tempTaskInsetBounds */,
2168 !PRESERVE_WINDOWS, true /* allowResizeInDockedMode */, !DEFER_RESUME);
2170 // WM resizeTask must be done after the task is moved to the correct stack,
2171 // because Task's setBounds() also updates dim layer's bounds, but that has
2172 // dependency on the stack.
2173 task.resizeWindowContainer();
2178 final ActivityRecord r = task.getTopActivity();
2179 currentStack.moveTaskToFrontLocked(task, false /* noAnimation */, options,
2180 r == null ? null : r.appTimeTracker, reason);
2182 if (DEBUG_STACK) Slog.d(TAG_STACK,
2183 "findTaskToMoveToFront: moved to front of stack=" + currentStack);
2185 handleNonResizableTaskIfNeeded(task, INVALID_STACK_ID, DEFAULT_DISPLAY,
2186 currentStack.mStackId, forceNonResizeable);
2189 boolean canUseActivityOptionsLaunchBounds(ActivityOptions options, int launchStackId) {
2190 // We use the launch bounds in the activity options is the device supports freeform
2191 // window management or is launching into the pinned stack.
2192 if (options.getLaunchBounds() == null) {
2195 return (mService.mSupportsPictureInPicture && launchStackId == PINNED_STACK_ID)
2196 || mService.mSupportsFreeformWindowManagement;
2199 protected <T extends ActivityStack> T getStack(int stackId) {
2200 return getStack(stackId, !CREATE_IF_NEEDED, !ON_TOP);
2203 protected <T extends ActivityStack> T getStack(int stackId, boolean createStaticStackIfNeeded,
2204 boolean createOnTop) {
2205 final ActivityContainer activityContainer = mActivityContainers.get(stackId);
2206 if (activityContainer != null) {
2207 return (T) activityContainer.mStack;
2209 if (!createStaticStackIfNeeded || !StackId.isStaticStack(stackId)) {
2212 if (stackId == DOCKED_STACK_ID) {
2213 // Make sure recents stack exist when creating a dock stack as it normally need to be on
2214 // the other side of the docked stack and we make visibility decisions based on that.
2215 getStack(RECENTS_STACK_ID, CREATE_IF_NEEDED, createOnTop);
2217 return (T) createStackOnDisplay(stackId, DEFAULT_DISPLAY, createOnTop);
2221 * Get a topmost stack on the display, that is a valid launch stack for specified activity.
2222 * If there is no such stack, new dynamic stack can be created.
2223 * @param displayId Target display.
2224 * @param r Activity that should be launched there.
2225 * @return Existing stack if there is a valid one, new dynamic stack if it is valid or null.
2227 ActivityStack getValidLaunchStackOnDisplay(int displayId, @NonNull ActivityRecord r) {
2228 final ActivityDisplay activityDisplay = getActivityDisplayOrCreateLocked(displayId);
2229 if (activityDisplay == null) {
2230 throw new IllegalArgumentException(
2231 "Display with displayId=" + displayId + " not found.");
2234 // Return the topmost valid stack on the display.
2235 for (int i = activityDisplay.mStacks.size() - 1; i >= 0; --i) {
2236 final ActivityStack stack = activityDisplay.mStacks.get(i);
2237 if (mService.mActivityStarter.isValidLaunchStackId(stack.mStackId, displayId, r)) {
2242 // If there is no valid stack on the external display - check if new dynamic stack will do.
2243 if (displayId != Display.DEFAULT_DISPLAY) {
2244 final int newDynamicStackId = getNextStackId();
2245 if (mService.mActivityStarter.isValidLaunchStackId(newDynamicStackId, displayId, r)) {
2246 return createStackOnDisplay(newDynamicStackId, displayId, true /*onTop*/);
2250 Slog.w(TAG, "getValidLaunchStackOnDisplay: can't launch on displayId " + displayId);
2254 ArrayList<ActivityStack> getStacks() {
2255 ArrayList<ActivityStack> allStacks = new ArrayList<>();
2256 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
2257 allStacks.addAll(mActivityDisplays.valueAt(displayNdx).mStacks);
2262 ArrayList<ActivityStack> getStacksOnDefaultDisplay() {
2263 return mActivityDisplays.valueAt(DEFAULT_DISPLAY).mStacks;
2267 * Get next focusable stack in the system. This will search across displays and stacks
2268 * in last-focused order for a focusable and visible stack, different from the target stack.
2270 * @param currentFocus The stack that previously had focus and thus needs to be ignored when
2271 * searching for next candidate.
2272 * @return Next focusable {@link ActivityStack}, null if not found.
2274 ActivityStack getNextFocusableStackLocked(ActivityStack currentFocus) {
2275 mWindowManager.getDisplaysInFocusOrder(mTmpOrderedDisplayIds);
2277 for (int i = mTmpOrderedDisplayIds.size() - 1; i >= 0; --i) {
2278 final int displayId = mTmpOrderedDisplayIds.get(i);
2279 // If a display is registered in WM, it must also be available in AM.
2280 @SuppressWarnings("ConstantConditions")
2281 final List<ActivityStack> stacks = getActivityDisplayOrCreateLocked(displayId).mStacks;
2282 for (int j = stacks.size() - 1; j >= 0; --j) {
2283 final ActivityStack stack = stacks.get(j);
2284 if (stack != currentFocus && stack.isFocusable()
2285 && stack.shouldBeVisible(null) != STACK_INVISIBLE) {
2295 * Get next valid stack for launching provided activity in the system. This will search across
2296 * displays and stacks in last-focused order for a focusable and visible stack, except those
2297 * that are on a currently focused display.
2299 * @param r The activity that is being launched.
2300 * @param currentFocus The display that previously had focus and thus needs to be ignored when
2301 * searching for the next candidate.
2302 * @return Next valid {@link ActivityStack}, null if not found.
2304 ActivityStack getNextValidLaunchStackLocked(@NonNull ActivityRecord r, int currentFocus) {
2305 mWindowManager.getDisplaysInFocusOrder(mTmpOrderedDisplayIds);
2306 for (int i = mTmpOrderedDisplayIds.size() - 1; i >= 0; --i) {
2307 final int displayId = mTmpOrderedDisplayIds.get(i);
2308 if (displayId == currentFocus) {
2311 final ActivityStack stack = getValidLaunchStackOnDisplay(displayId, r);
2312 if (stack != null) {
2319 ActivityRecord getHomeActivity() {
2320 return getHomeActivityForUser(mCurrentUser);
2323 ActivityRecord getHomeActivityForUser(int userId) {
2324 final ArrayList<TaskRecord> tasks = mHomeStack.getAllTasks();
2325 for (int taskNdx = tasks.size() - 1; taskNdx >= 0; --taskNdx) {
2326 final TaskRecord task = tasks.get(taskNdx);
2327 if (task.isHomeTask()) {
2328 final ArrayList<ActivityRecord> activities = task.mActivities;
2329 for (int activityNdx = activities.size() - 1; activityNdx >= 0; --activityNdx) {
2330 final ActivityRecord r = activities.get(activityNdx);
2331 if (r.isHomeActivity()
2332 && ((userId == UserHandle.USER_ALL) || (r.userId == userId))) {
2342 * Returns if a stack should be treated as if it's docked. Returns true if the stack is
2343 * the docked stack itself, or if it's side-by-side to the docked stack.
2345 boolean isStackDockedInEffect(int stackId) {
2346 return stackId == DOCKED_STACK_ID ||
2347 (StackId.isResizeableByDockedStack(stackId) && getStack(DOCKED_STACK_ID) != null);
2350 ActivityContainer createVirtualActivityContainer(ActivityRecord parentActivity,
2351 IActivityContainerCallback callback) {
2352 ActivityContainer activityContainer =
2353 new VirtualActivityContainer(parentActivity, callback);
2354 mActivityContainers.put(activityContainer.mStackId, activityContainer);
2355 if (DEBUG_CONTAINERS) Slog.d(TAG_CONTAINERS,
2356 "createActivityContainer: " + activityContainer);
2357 parentActivity.mChildContainers.add(activityContainer);
2358 return activityContainer;
2361 void removeChildActivityContainers(ActivityRecord parentActivity) {
2362 final ArrayList<ActivityContainer> childStacks = parentActivity.mChildContainers;
2363 for (int containerNdx = childStacks.size() - 1; containerNdx >= 0; --containerNdx) {
2364 ActivityContainer container = childStacks.remove(containerNdx);
2365 if (DEBUG_CONTAINERS) Slog.d(TAG_CONTAINERS, "removeChildActivityContainers: removing "
2367 container.release();
2371 void deleteActivityContainerRecord(int stackId) {
2372 if (DEBUG_CONTAINERS) Slog.d(TAG_CONTAINERS,
2373 "deleteActivityContainerRecord: callers=" + Debug.getCallers(4));
2374 mActivityContainers.remove(stackId);
2377 void resizeStackLocked(int stackId, Rect bounds, Rect tempTaskBounds, Rect tempTaskInsetBounds,
2378 boolean preserveWindows, boolean allowResizeInDockedMode, boolean deferResume) {
2379 if (stackId == DOCKED_STACK_ID) {
2380 resizeDockedStackLocked(bounds, tempTaskBounds, tempTaskInsetBounds, null, null,
2381 preserveWindows, deferResume);
2384 final ActivityStack stack = getStack(stackId);
2385 if (stack == null) {
2386 Slog.w(TAG, "resizeStack: stackId " + stackId + " not found.");
2390 if (!allowResizeInDockedMode && !StackId.tasksAreFloating(stackId) &&
2391 getStack(DOCKED_STACK_ID) != null) {
2392 // If the docked stack exists, don't resize non-floating stacks independently of the
2393 // size computed from the docked stack size (otherwise they will be out of sync)
2397 Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "am.resizeStack_" + stackId);
2398 mWindowManager.deferSurfaceLayout();
2400 stack.resize(bounds, tempTaskBounds, tempTaskInsetBounds);
2402 stack.ensureVisibleActivitiesConfigurationLocked(
2403 stack.topRunningActivityLocked(), preserveWindows);
2406 mWindowManager.continueSurfaceLayout();
2407 Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
2411 void deferUpdateBounds(int stackId) {
2412 final ActivityStack stack = getStack(stackId);
2413 if (stack != null) {
2414 stack.deferUpdateBounds();
2418 void continueUpdateBounds(int stackId) {
2419 final ActivityStack stack = getStack(stackId);
2420 if (stack != null) {
2421 stack.continueUpdateBounds();
2425 void notifyAppTransitionDone() {
2426 continueUpdateBounds(RECENTS_STACK_ID);
2427 for (int i = mResizingTasksDuringAnimation.size() - 1; i >= 0; i--) {
2428 final int taskId = mResizingTasksDuringAnimation.valueAt(i);
2429 final TaskRecord task =
2430 anyTaskForIdLocked(taskId, MATCH_TASK_IN_STACKS_ONLY, INVALID_STACK_ID);
2432 task.setTaskDockedResizing(false);
2435 mResizingTasksDuringAnimation.clear();
2438 private void moveTasksToFullscreenStackInSurfaceTransaction(int fromStackId,
2441 final ActivityStack stack = getStack(fromStackId);
2442 if (stack == null) {
2446 mWindowManager.deferSurfaceLayout();
2448 if (fromStackId == DOCKED_STACK_ID) {
2449 // We are moving all tasks from the docked stack to the fullscreen stack,
2450 // which is dismissing the docked stack, so resize all other stacks to
2451 // fullscreen here already so we don't end up with resize trashing.
2452 for (int i = FIRST_STATIC_STACK_ID; i <= LAST_STATIC_STACK_ID; i++) {
2453 if (StackId.isResizeableByDockedStack(i)) {
2454 ActivityStack otherStack = getStack(i);
2455 if (otherStack != null) {
2456 resizeStackLocked(i, null, null, null, PRESERVE_WINDOWS,
2457 true /* allowResizeInDockedMode */, DEFER_RESUME);
2462 // Also disable docked stack resizing since we have manually adjusted the
2463 // size of other stacks above and we don't want to trigger a docked stack
2464 // resize when we remove task from it below and it is detached from the
2465 // display because it no longer contains any tasks.
2466 mAllowDockedStackResize = false;
2467 } else if (fromStackId == PINNED_STACK_ID) {
2469 // Log if we are expanding the PiP to fullscreen
2470 MetricsLogger.action(mService.mContext,
2471 ACTION_PICTURE_IN_PICTURE_EXPANDED_TO_FULLSCREEN);
2474 ActivityStack fullscreenStack = getStack(FULLSCREEN_WORKSPACE_STACK_ID);
2475 final boolean isFullscreenStackVisible = fullscreenStack != null &&
2476 fullscreenStack.shouldBeVisible(null) == STACK_VISIBLE;
2477 // If we are moving from the pinned stack, then the animation takes care of updating
2478 // the picture-in-picture mode.
2479 final boolean schedulePictureInPictureModeChange = (fromStackId == PINNED_STACK_ID);
2480 final ArrayList<TaskRecord> tasks = stack.getAllTasks();
2481 final int size = tasks.size();
2483 for (int i = 0; i < size; i++) {
2484 final TaskRecord task = tasks.get(i);
2485 final boolean isTopTask = i == (size - 1);
2486 if (fromStackId == PINNED_STACK_ID) {
2487 // Update the return-to to reflect where the pinned stack task was moved
2488 // from so that we retain the stack that was previously visible if the
2489 // pinned stack is recreated. See moveActivityToPinnedStackLocked().
2490 task.setTaskToReturnTo(isFullscreenStackVisible && onTop ?
2491 APPLICATION_ACTIVITY_TYPE : HOME_ACTIVITY_TYPE);
2493 // Defer resume until all the tasks have been moved to the fullscreen stack
2494 task.reparent(FULLSCREEN_WORKSPACE_STACK_ID, ON_TOP,
2495 REPARENT_MOVE_STACK_TO_FRONT, isTopTask /* animate */, DEFER_RESUME,
2496 schedulePictureInPictureModeChange,
2497 "moveTasksToFullscreenStack - onTop");
2500 for (int i = 0; i < size; i++) {
2501 final TaskRecord task = tasks.get(i);
2502 // Position the tasks in the fullscreen stack in order at the bottom of the
2503 // stack. Also defer resume until all the tasks have been moved to the
2504 // fullscreen stack.
2505 task.reparent(FULLSCREEN_WORKSPACE_STACK_ID, i /* position */,
2506 REPARENT_LEAVE_STACK_IN_PLACE, !ANIMATE, DEFER_RESUME,
2507 schedulePictureInPictureModeChange,
2508 "moveTasksToFullscreenStack - NOT_onTop");
2512 ensureActivitiesVisibleLocked(null, 0, PRESERVE_WINDOWS);
2513 resumeFocusedStackTopActivityLocked();
2515 mAllowDockedStackResize = true;
2516 mWindowManager.continueSurfaceLayout();
2520 void moveTasksToFullscreenStackLocked(int fromStackId, boolean onTop) {
2521 mWindowManager.inSurfaceTransaction(
2522 () -> moveTasksToFullscreenStackInSurfaceTransaction(fromStackId, onTop));
2525 void resizeDockedStackLocked(Rect dockedBounds, Rect tempDockedTaskBounds,
2526 Rect tempDockedTaskInsetBounds, Rect tempOtherTaskBounds, Rect tempOtherTaskInsetBounds,
2527 boolean preserveWindows) {
2528 resizeDockedStackLocked(dockedBounds, tempDockedTaskBounds, tempDockedTaskInsetBounds,
2529 tempOtherTaskBounds, tempOtherTaskInsetBounds, preserveWindows,
2530 false /* deferResume */);
2533 void resizeDockedStackLocked(Rect dockedBounds, Rect tempDockedTaskBounds,
2534 Rect tempDockedTaskInsetBounds, Rect tempOtherTaskBounds, Rect tempOtherTaskInsetBounds,
2535 boolean preserveWindows, boolean deferResume) {
2537 if (!mAllowDockedStackResize) {
2538 // Docked stack resize currently disabled.
2542 final ActivityStack stack = getStack(DOCKED_STACK_ID);
2543 if (stack == null) {
2544 Slog.w(TAG, "resizeDockedStackLocked: docked stack not found");
2548 Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "am.resizeDockedStack");
2549 mWindowManager.deferSurfaceLayout();
2551 // Don't allow re-entry while resizing. E.g. due to docked stack detaching.
2552 mAllowDockedStackResize = false;
2553 ActivityRecord r = stack.topRunningActivityLocked();
2554 stack.resize(dockedBounds, tempDockedTaskBounds, tempDockedTaskInsetBounds);
2556 // TODO: Checking for isAttached might not be needed as if the user passes in null
2557 // dockedBounds then they want the docked stack to be dismissed.
2558 if (stack.mFullscreen || (dockedBounds == null && !stack.isAttached())) {
2559 // The dock stack either was dismissed or went fullscreen, which is kinda the same.
2560 // In this case we make all other static stacks fullscreen and move all
2561 // docked stack tasks to the fullscreen stack.
2562 moveTasksToFullscreenStackLocked(DOCKED_STACK_ID, ON_TOP);
2564 // stack shouldn't contain anymore activities, so nothing to resume.
2567 // Docked stacks occupy a dedicated region on screen so the size of all other
2568 // static stacks need to be adjusted so they don't overlap with the docked stack.
2569 // We get the bounds to use from window manager which has been adjusted for any
2570 // screen controls and is also the same for all stacks.
2571 final Rect otherTaskRect = new Rect();
2572 for (int i = FIRST_STATIC_STACK_ID; i <= LAST_STATIC_STACK_ID; i++) {
2573 final ActivityStack current = getStack(i);
2574 if (current != null && StackId.isResizeableByDockedStack(i)) {
2575 current.getStackDockedModeBounds(
2576 tempOtherTaskBounds /* currentTempTaskBounds */,
2577 tempRect /* outStackBounds */,
2578 otherTaskRect /* outTempTaskBounds */, true /* ignoreVisibility */);
2580 resizeStackLocked(i, !tempRect.isEmpty() ? tempRect : null,
2581 !otherTaskRect.isEmpty() ? otherTaskRect : tempOtherTaskBounds,
2582 tempOtherTaskInsetBounds, preserveWindows,
2583 true /* allowResizeInDockedMode */, deferResume);
2588 stack.ensureVisibleActivitiesConfigurationLocked(r, preserveWindows);
2591 mAllowDockedStackResize = true;
2592 mWindowManager.continueSurfaceLayout();
2593 Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
2597 void resizePinnedStackLocked(Rect pinnedBounds, Rect tempPinnedTaskBounds) {
2598 final PinnedActivityStack stack = getStack(PINNED_STACK_ID);
2599 if (stack == null) {
2600 Slog.w(TAG, "resizePinnedStackLocked: pinned stack not found");
2604 // It is possible for the bounds animation from the WM to call this but be delayed by
2605 // another AM call that is holding the AMS lock. In such a case, the pinnedBounds may be
2606 // incorrect if AMS.resizeStackWithBoundsFromWindowManager() is already called while waiting
2607 // for the AMS lock to be freed. So check and make sure these bounds are still good.
2608 final PinnedStackWindowController stackController = stack.getWindowContainerController();
2609 if (stackController.pinnedStackResizeDisallowed()) {
2613 Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "am.resizePinnedStack");
2614 mWindowManager.deferSurfaceLayout();
2616 ActivityRecord r = stack.topRunningActivityLocked();
2617 Rect insetBounds = null;
2618 if (tempPinnedTaskBounds != null) {
2619 // We always use 0,0 as the position for the inset rect because
2620 // if we are getting insets at all in the pinned stack it must mean
2621 // we are headed for fullscreen.
2622 insetBounds = tempRect;
2623 insetBounds.top = 0;
2624 insetBounds.left = 0;
2625 insetBounds.right = tempPinnedTaskBounds.width();
2626 insetBounds.bottom = tempPinnedTaskBounds.height();
2628 stack.resize(pinnedBounds, tempPinnedTaskBounds, insetBounds);
2629 stack.ensureVisibleActivitiesConfigurationLocked(r, false);
2631 mWindowManager.continueSurfaceLayout();
2632 Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
2636 ActivityStack createStackOnDisplay(int stackId, int displayId, boolean onTop) {
2637 final ActivityDisplay activityDisplay = getActivityDisplayOrCreateLocked(displayId);
2638 if (activityDisplay == null) {
2642 final ActivityContainer activityContainer =
2643 new ActivityContainer(stackId, activityDisplay, onTop);
2644 return activityContainer.mStack;
2648 void removeStackInSurfaceTransaction(int stackId) {
2649 final ActivityStack stack = getStack(stackId);
2650 if (stack == null) {
2654 final ArrayList<TaskRecord> tasks = stack.getAllTasks();
2655 if (stack.getStackId() == PINNED_STACK_ID) {
2657 * Workaround: Force-stop all the activities in the pinned stack before we reparent them
2658 * to the fullscreen stack. This is to guarantee that when we are removing a stack,
2659 * that the client receives onStop() before it is reparented. We do this by detaching
2660 * the stack from the display so that it will be considered invisible when
2661 * ensureActivitiesVisibleLocked() is called, and all of its activitys will be marked
2662 * invisible as well and added to the stopping list. After which we process the
2663 * stopping list by handling the idle.
2665 final PinnedActivityStack pinnedStack = (PinnedActivityStack) stack;
2666 pinnedStack.mForceHidden = true;
2667 pinnedStack.ensureActivitiesVisibleLocked(null, 0, PRESERVE_WINDOWS);
2668 pinnedStack.mForceHidden = false;
2669 activityIdleInternalLocked(null, false /* fromTimeout */,
2670 true /* processPausingActivites */, null /* configuration */);
2672 // Move all the tasks to the bottom of the fullscreen stack
2673 moveTasksToFullscreenStackLocked(PINNED_STACK_ID, !ON_TOP);
2675 for (int i = tasks.size() - 1; i >= 0; i--) {
2676 removeTaskByIdLocked(tasks.get(i).taskId, true /* killProcess */,
2677 REMOVE_FROM_RECENTS);
2683 * Removes the stack associated with the given {@param stackId}. If the {@param stackId} is the
2684 * pinned stack, then its tasks are not explicitly removed when the stack is destroyed, but
2685 * instead moved back onto the fullscreen stack.
2687 void removeStackLocked(int stackId) {
2688 mWindowManager.inSurfaceTransaction(
2689 () -> removeStackInSurfaceTransaction(stackId));
2693 * See {@link #removeTaskByIdLocked(int, boolean, boolean, boolean)}
2695 boolean removeTaskByIdLocked(int taskId, boolean killProcess, boolean removeFromRecents) {
2696 return removeTaskByIdLocked(taskId, killProcess, removeFromRecents, !PAUSE_IMMEDIATELY);
2700 * Removes the task with the specified task id.
2702 * @param taskId Identifier of the task to be removed.
2703 * @param killProcess Kill any process associated with the task if possible.
2704 * @param removeFromRecents Whether to also remove the task from recents.
2705 * @param pauseImmediately Pauses all task activities immediately without waiting for the
2706 * pause-complete callback from the activity.
2707 * @return Returns true if the given task was found and removed.
2709 boolean removeTaskByIdLocked(int taskId, boolean killProcess, boolean removeFromRecents,
2710 boolean pauseImmediately) {
2711 final TaskRecord tr = anyTaskForIdLocked(taskId, MATCH_TASK_IN_STACKS_OR_RECENT_TASKS,
2714 tr.removeTaskActivitiesLocked(pauseImmediately);
2715 cleanUpRemovedTaskLocked(tr, killProcess, removeFromRecents);
2716 if (tr.isPersistable) {
2717 mService.notifyTaskPersisterLocked(null, true);
2721 Slog.w(TAG, "Request to remove task ignored for non-existent task " + taskId);
2725 void cleanUpRemovedTaskLocked(TaskRecord tr, boolean killProcess, boolean removeFromRecents) {
2726 if (removeFromRecents) {
2727 mRecentTasks.remove(tr);
2728 tr.removedFromRecents();
2730 ComponentName component = tr.getBaseIntent().getComponent();
2731 if (component == null) {
2732 Slog.w(TAG, "No component for base intent of task: " + tr);
2736 // Find any running services associated with this app and stop if needed.
2737 mService.mServices.cleanUpRemovedTaskLocked(tr, component, new Intent(tr.getBaseIntent()));
2743 // Determine if the process(es) for this task should be killed.
2744 final String pkg = component.getPackageName();
2745 ArrayList<ProcessRecord> procsToKill = new ArrayList<>();
2746 ArrayMap<String, SparseArray<ProcessRecord>> pmap = mService.mProcessNames.getMap();
2747 for (int i = 0; i < pmap.size(); i++) {
2749 SparseArray<ProcessRecord> uids = pmap.valueAt(i);
2750 for (int j = 0; j < uids.size(); j++) {
2751 ProcessRecord proc = uids.valueAt(j);
2752 if (proc.userId != tr.userId) {
2753 // Don't kill process for a different user.
2756 if (proc == mService.mHomeProcess) {
2757 // Don't kill the home process along with tasks from the same package.
2760 if (!proc.pkgList.containsKey(pkg)) {
2761 // Don't kill process that is not associated with this task.
2765 for (int k = 0; k < proc.activities.size(); k++) {
2766 TaskRecord otherTask = proc.activities.get(k).getTask();
2767 if (tr.taskId != otherTask.taskId && otherTask.inRecents) {
2768 // Don't kill process(es) that has an activity in a different task that is
2774 if (proc.foregroundServices) {
2775 // Don't kill process(es) with foreground service.
2779 // Add process to kill list.
2780 procsToKill.add(proc);
2784 // Kill the running processes.
2785 for (int i = 0; i < procsToKill.size(); i++) {
2786 ProcessRecord pr = procsToKill.get(i);
2787 if (pr.setSchedGroup == ProcessList.SCHED_GROUP_BACKGROUND
2788 && pr.curReceivers.isEmpty()) {
2789 pr.kill("remove task", true);
2791 // We delay killing processes that are not in the background or running a receiver.
2792 pr.waitingToKill = "remove task";
2797 int getNextStackId() {
2799 if (mNextFreeStackId >= FIRST_DYNAMIC_STACK_ID
2800 && getStack(mNextFreeStackId) == null) {
2805 return mNextFreeStackId;
2809 * Restores a recent task to a stack
2810 * @param task The recent task to be restored.
2811 * @param stackId The stack to restore the task to (default launch stack will be used
2812 * if stackId is {@link android.app.ActivityManager.StackId#INVALID_STACK_ID}
2813 * or is not a static stack).
2814 * @return true if the task has been restored successfully.
2816 boolean restoreRecentTaskLocked(TaskRecord task, int stackId) {
2817 if (!StackId.isStaticStack(stackId)) {
2818 // If stack is not static (or stack id is invalid) - use the default one.
2819 // This means that tasks that were on external displays will be restored on the
2821 stackId = task.getLaunchStackId();
2822 } else if (stackId == DOCKED_STACK_ID && !task.supportsSplitScreen()) {
2823 // Preferred stack is the docked stack, but the task can't go in the docked stack.
2824 // Put it in the fullscreen stack.
2825 stackId = FULLSCREEN_WORKSPACE_STACK_ID;
2828 final ActivityStack currentStack = task.getStack();
2829 if (currentStack != null) {
2830 // Task has already been restored once. See if we need to do anything more
2831 if (currentStack.mStackId == stackId) {
2832 // Nothing else to do since it is already restored in the right stack.
2835 // Remove current stack association, so we can re-associate the task with the
2836 // right stack below.
2837 currentStack.removeTask(task, "restoreRecentTaskLocked", REMOVE_TASK_MODE_MOVING);
2840 final ActivityStack stack =
2841 getStack(stackId, CREATE_IF_NEEDED, !ON_TOP);
2843 if (stack == null) {
2844 // What does this mean??? Not sure how we would get here...
2845 if (DEBUG_RECENTS) Slog.v(TAG_RECENTS,
2846 "Unable to find/create stack to restore recent task=" + task);
2850 stack.addTask(task, false /* toTop */, "restoreRecentTask");
2851 // TODO: move call for creation here and other place into Stack.addTask()
2852 task.createWindowContainer(false /* toTop */, true /* showForAllUsers */);
2853 if (DEBUG_RECENTS) Slog.v(TAG_RECENTS,
2854 "Added restored task=" + task + " to stack=" + stack);
2855 final ArrayList<ActivityRecord> activities = task.mActivities;
2856 for (int activityNdx = activities.size() - 1; activityNdx >= 0; --activityNdx) {
2857 activities.get(activityNdx).createWindowContainer();
2863 * Move stack with all its existing content to specified display.
2864 * @param stackId Id of stack to move.
2865 * @param displayId Id of display to move stack to.
2866 * @param onTop Indicates whether container should be place on top or on bottom.
2868 void moveStackToDisplayLocked(int stackId, int displayId, boolean onTop) {
2869 final ActivityDisplay activityDisplay = getActivityDisplayOrCreateLocked(displayId);
2870 if (activityDisplay == null) {
2871 throw new IllegalArgumentException("moveStackToDisplayLocked: Unknown displayId="
2874 final ActivityContainer activityContainer = mActivityContainers.get(stackId);
2875 if (activityContainer != null) {
2876 if (activityContainer.isAttachedLocked()) {
2877 if (activityContainer.getDisplayId() == displayId) {
2878 throw new IllegalArgumentException("Trying to move stackId=" + stackId
2879 + " to its current displayId=" + displayId);
2882 activityContainer.moveToDisplayLocked(activityDisplay, onTop);
2884 throw new IllegalStateException("moveStackToDisplayLocked: Stack with stackId="
2885 + stackId + " is not attached to any display.");
2888 throw new IllegalArgumentException("moveStackToDisplayLocked: Unknown stackId="
2891 // TODO(multi-display): resize stacks properly if moved from split-screen.
2895 * Returns the reparent target stack, creating the stack if necessary. This call also enforces
2896 * the various checks on tasks that are going to be reparented from one stack to another.
2898 ActivityStack getReparentTargetStack(TaskRecord task, int stackId, boolean toTop) {
2899 final ActivityStack prevStack = task.getStack();
2901 // Check that we aren't reparenting to the same stack that the task is already in
2902 if (prevStack != null && prevStack.mStackId == stackId) {
2903 Slog.w(TAG, "Can not reparent to same stack, task=" + task
2904 + " already in stackId=" + stackId);
2908 // Ensure that we aren't trying to move into a multi-window stack without multi-window
2910 if (StackId.isMultiWindowStack(stackId) && !mService.mSupportsMultiWindow) {
2911 throw new IllegalArgumentException("Device doesn't support multi-window, can not"
2912 + " reparent task=" + task + " to stackId=" + stackId);
2915 // Ensure that we're not moving a task to a dynamic stack if device doesn't support
2917 // TODO(multi-display): Support non-dynamic stacks on secondary displays.
2918 // TODO: Check ActivityView after fixing b/35349678.
2919 if (StackId.isDynamicStack(stackId) && !mService.mSupportsMultiDisplay) {
2920 throw new IllegalArgumentException("Device doesn't support multi-display, can not"
2921 + " reparent task=" + task + " to stackId=" + stackId);
2924 // Ensure that we aren't trying to move into a freeform stack without freeform
2926 if (stackId == FREEFORM_WORKSPACE_STACK_ID && !mService.mSupportsFreeformWindowManagement) {
2927 throw new IllegalArgumentException("Device doesn't support freeform, can not reparent"
2931 // We don't allow moving a unresizeable task to the docked stack since the docked stack is
2932 // used for split-screen mode and will cause things like the docked divider to show up. We
2933 // instead leave the task in its current stack or move it to the fullscreen stack if it
2934 // isn't currently in a stack.
2935 if (stackId == DOCKED_STACK_ID && !task.isResizeable()) {
2936 stackId = (prevStack != null) ? prevStack.mStackId : FULLSCREEN_WORKSPACE_STACK_ID;
2937 Slog.w(TAG, "Can not move unresizeable task=" + task + " to docked stack."
2938 + " Moving to stackId=" + stackId + " instead.");
2941 // Temporarily disable resizeablility of the task as we don't want it to be resized if, for
2942 // example, a docked stack is created which will lead to the stack we are moving from being
2943 // resized and and its resizeable tasks being resized.
2945 task.mTemporarilyUnresizable = true;
2946 return getStack(stackId, CREATE_IF_NEEDED, toTop);
2948 task.mTemporarilyUnresizable = false;
2952 boolean moveTopStackActivityToPinnedStackLocked(int stackId, Rect destBounds) {
2953 final ActivityStack stack = getStack(stackId, !CREATE_IF_NEEDED, !ON_TOP);
2954 if (stack == null) {
2955 throw new IllegalArgumentException(
2956 "moveTopStackActivityToPinnedStackLocked: Unknown stackId=" + stackId);
2959 final ActivityRecord r = stack.topRunningActivityLocked();
2961 Slog.w(TAG, "moveTopStackActivityToPinnedStackLocked: No top running activity"
2962 + " in stack=" + stack);
2966 if (!mService.mForceResizableActivities && !r.supportsPictureInPicture()) {
2968 "moveTopStackActivityToPinnedStackLocked: Picture-In-Picture not supported for "
2973 moveActivityToPinnedStackLocked(r, null /* sourceBounds */, 0f /* aspectRatio */,
2974 true /* moveHomeStackToFront */, "moveTopActivityToPinnedStack");
2978 void moveActivityToPinnedStackLocked(ActivityRecord r, Rect sourceHintBounds, float aspectRatio,
2979 boolean moveHomeStackToFront, String reason) {
2981 mWindowManager.deferSurfaceLayout();
2983 // This will clear the pinned stack by moving an existing task to the full screen stack,
2984 // ensuring only one task is present.
2985 moveTasksToFullscreenStackLocked(PINNED_STACK_ID, !ON_TOP);
2987 // Need to make sure the pinned stack exist so we can resize it below...
2988 final PinnedActivityStack stack = getStack(PINNED_STACK_ID, CREATE_IF_NEEDED, ON_TOP);
2991 final TaskRecord task = r.getTask();
2993 if (r == task.getStack().getVisibleBehindActivity()) {
2994 // An activity can't be pinned and visible behind at the same time. Go ahead and
2995 // release it from been visible behind before pinning.
2996 requestVisibleBehindLocked(r, false);
2999 // Resize the pinned stack to match the current size of the task the activity we are
3000 // going to be moving is currently contained in. We do this to have the right starting
3001 // animation bounds for the pinned stack to the desired bounds the caller wants.
3002 resizeStackLocked(PINNED_STACK_ID, task.mBounds, null /* tempTaskBounds */,
3003 null /* tempTaskInsetBounds */, !PRESERVE_WINDOWS,
3004 true /* allowResizeInDockedMode */, !DEFER_RESUME);
3006 if (task.mActivities.size() == 1) {
3007 // There is only one activity in the task. So, we can just move the task over to
3008 // the stack without re-parenting the activity in a different task. We don't
3009 // move the home stack forward if we are currently entering picture-in-picture
3010 // while pausing because that changes the focused stack and may prevent the new
3011 // starting activity from resuming.
3012 if (moveHomeStackToFront && task.getTaskToReturnTo() == HOME_ACTIVITY_TYPE
3013 && (r.state == RESUMED || !r.supportsPictureInPictureWhilePausing)) {
3014 // Move the home stack forward if the task we just moved to the pinned stack
3015 // was launched from home so home should be visible behind it.
3016 moveHomeStackToFront(reason);
3018 // Defer resume until below, and do not schedule PiP changes until we animate below
3019 task.reparent(PINNED_STACK_ID, ON_TOP, REPARENT_MOVE_STACK_TO_FRONT, !ANIMATE,
3020 DEFER_RESUME, false /* schedulePictureInPictureModeChange */, reason);
3022 // There are multiple activities in the task and moving the top activity should
3023 // reveal/leave the other activities in their original task.
3025 // Currently, we don't support reparenting activities across tasks in two different
3026 // stacks, so instead, just create a new task in the same stack, reparent the
3027 // activity into that task, and then reparent the whole task to the new stack. This
3028 // ensures that all the necessary work to migrate states in the old and new stacks
3030 final TaskRecord newTask = task.getStack().createTaskRecord(
3031 getNextTaskIdForUserLocked(r.userId), r.info, r.intent, null, null, true,
3033 r.reparent(newTask, MAX_VALUE, "moveActivityToStack");
3035 // Defer resume until below, and do not schedule PiP changes until we animate below
3036 newTask.reparent(PINNED_STACK_ID, ON_TOP, REPARENT_MOVE_STACK_TO_FRONT, !ANIMATE,
3037 DEFER_RESUME, false /* schedulePictureInPictureModeChange */, reason);
3040 // Reset the state that indicates it can enter PiP while pausing after we've moved it
3041 // to the pinned stack
3042 r.supportsPictureInPictureWhilePausing = false;
3044 mWindowManager.continueSurfaceLayout();
3047 // Calculate the default bounds (don't use existing stack bounds as we may have just created
3048 // the stack, and schedule the start of the animation into PiP (the bounds animator that
3049 // is triggered by this is posted on another thread)
3050 final Rect destBounds = stack.getDefaultPictureInPictureBounds(aspectRatio);
3052 stack.animateResizePinnedStack(sourceHintBounds, destBounds, -1 /* animationDuration */,
3053 true /* fromFullscreen */);
3055 // Update the visibility of all activities after the they have been reparented to the new
3056 // stack. This MUST run after the animation above is scheduled to ensure that the windows
3057 // drawn signal is scheduled after the bounds animation start call on the bounds animator
3059 ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
3060 resumeFocusedStackTopActivityLocked();
3062 mService.mTaskChangeNotificationController.notifyActivityPinned(r.packageName,
3063 r.getTask().taskId);
3066 /** Move activity with its stack to front and make the stack focused. */
3067 boolean moveFocusableActivityStackToFrontLocked(ActivityRecord r, String reason) {
3068 if (r == null || !r.isFocusable()) {
3069 if (DEBUG_FOCUS) Slog.d(TAG_FOCUS,
3070 "moveActivityStackToFront: unfocusable r=" + r);
3074 final TaskRecord task = r.getTask();
3075 final ActivityStack stack = r.getStack();
3076 if (stack == null) {
3077 Slog.w(TAG, "moveActivityStackToFront: invalid task or stack: r="
3078 + r + " task=" + task);
3082 if (stack == mFocusedStack && stack.topRunningActivityLocked() == r) {
3083 if (DEBUG_FOCUS) Slog.d(TAG_FOCUS,
3084 "moveActivityStackToFront: already on top, r=" + r);
3088 if (DEBUG_FOCUS) Slog.d(TAG_FOCUS,
3089 "moveActivityStackToFront: r=" + r);
3091 stack.moveToFront(reason, task);
3095 ActivityRecord findTaskLocked(ActivityRecord r, int displayId) {
3096 mTmpFindTaskResult.r = null;
3097 mTmpFindTaskResult.matchedByRootAffinity = false;
3098 ActivityRecord affinityMatch = null;
3099 if (DEBUG_TASKS) Slog.d(TAG_TASKS, "Looking for task of " + r);
3100 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
3101 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
3102 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
3103 final ActivityStack stack = stacks.get(stackNdx);
3104 if (!checkActivityBelongsInStack(r, stack)) {
3105 if (DEBUG_TASKS) Slog.d(TAG_TASKS, "Skipping stack: (mismatch activity/stack) "
3109 if (!stack.mActivityContainer.isEligibleForNewTasks()) {
3110 if (DEBUG_TASKS) Slog.d(TAG_TASKS,
3111 "Skipping stack: (new task not allowed) " + stack);
3114 stack.findTaskLocked(r, mTmpFindTaskResult);
3115 // It is possible to have tasks in multiple stacks with the same root affinity, so
3116 // we should keep looking after finding an affinity match to see if there is a
3117 // better match in another stack. Also, task affinity isn't a good enough reason
3118 // to target a display which isn't the source of the intent, so skip any affinity
3119 // matches not on the specified display.
3120 if (mTmpFindTaskResult.r != null) {
3121 if (!mTmpFindTaskResult.matchedByRootAffinity) {
3122 return mTmpFindTaskResult.r;
3123 } else if (mTmpFindTaskResult.r.getDisplayId() == displayId) {
3124 // Note: since the traversing through the stacks is top down, the floating
3125 // tasks should always have lower priority than any affinity-matching tasks
3126 // in the fullscreen stacks
3127 affinityMatch = mTmpFindTaskResult.r;
3133 if (DEBUG_TASKS && affinityMatch == null) Slog.d(TAG_TASKS, "No task found");
3134 return affinityMatch;
3138 * Checks that for the given activity {@param r}, its activity type matches the {@param stack}
3141 private boolean checkActivityBelongsInStack(ActivityRecord r, ActivityStack stack) {
3142 if (r.isHomeActivity()) {
3143 return stack.isHomeStack();
3144 } else if (r.isRecentsActivity()) {
3145 return stack.isRecentsStack();
3146 } else if (r.isAssistantActivity()) {
3147 return stack.isAssistantStack();
3152 ActivityRecord findActivityLocked(Intent intent, ActivityInfo info,
3153 boolean compareIntentFilters) {
3154 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
3155 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
3156 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
3157 final ActivityRecord ar = stacks.get(stackNdx)
3158 .findActivityLocked(intent, info, compareIntentFilters);
3167 void goingToSleepLocked() {
3168 scheduleSleepTimeout();
3169 if (!mGoingToSleep.isHeld()) {
3170 mGoingToSleep.acquire();
3171 if (mLaunchingActivity.isHeld()) {
3172 if (VALIDATE_WAKE_LOCK_CALLER && Binder.getCallingUid() != Process.myUid()) {
3173 throw new IllegalStateException("Calling must be system uid");
3175 mLaunchingActivity.release();
3176 mService.mHandler.removeMessages(LAUNCH_TIMEOUT_MSG);
3179 checkReadyForSleepLocked();
3182 boolean shutdownLocked(int timeout) {
3183 goingToSleepLocked();
3185 boolean timedout = false;
3186 final long endTime = System.currentTimeMillis() + timeout;
3188 boolean cantShutdown = false;
3189 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
3190 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
3191 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
3192 cantShutdown |= stacks.get(stackNdx).checkReadyForSleepLocked();
3196 long timeRemaining = endTime - System.currentTimeMillis();
3197 if (timeRemaining > 0) {
3199 mService.wait(timeRemaining);
3200 } catch (InterruptedException e) {
3203 Slog.w(TAG, "Activity manager shutdown timed out");
3212 // Force checkReadyForSleep to complete.
3213 mSleepTimeout = true;
3214 checkReadyForSleepLocked();
3219 void comeOutOfSleepIfNeededLocked() {
3220 removeSleepTimeouts();
3221 if (mGoingToSleep.isHeld()) {
3222 mGoingToSleep.release();
3224 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
3225 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
3226 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
3227 final ActivityStack stack = stacks.get(stackNdx);
3228 stack.awakeFromSleepingLocked();
3229 if (isFocusedStack(stack)) {
3230 resumeFocusedStackTopActivityLocked();
3234 mGoingToSleepActivities.clear();
3237 void activitySleptLocked(ActivityRecord r) {
3238 mGoingToSleepActivities.remove(r);
3239 checkReadyForSleepLocked();
3242 void checkReadyForSleepLocked() {
3243 if (!mService.isSleepingOrShuttingDownLocked()) {
3248 if (!mSleepTimeout) {
3249 boolean dontSleep = false;
3250 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
3251 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
3252 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
3253 dontSleep |= stacks.get(stackNdx).checkReadyForSleepLocked();
3257 if (mStoppingActivities.size() > 0) {
3258 // Still need to tell some activities to stop; can't sleep yet.
3259 if (DEBUG_PAUSE) Slog.v(TAG_PAUSE, "Sleep still need to stop "
3260 + mStoppingActivities.size() + " activities");
3261 scheduleIdleLocked();
3265 if (mGoingToSleepActivities.size() > 0) {
3266 // Still need to tell some activities to sleep; can't sleep yet.
3267 if (DEBUG_PAUSE) Slog.v(TAG_PAUSE, "Sleep still need to sleep "
3268 + mGoingToSleepActivities.size() + " activities");
3277 // Send launch end powerhint before going sleep
3278 mService.mActivityStarter.sendPowerHintForLaunchEndIfNeeded();
3280 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
3281 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
3282 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
3283 stacks.get(stackNdx).goToSleep();
3287 removeSleepTimeouts();
3289 if (mGoingToSleep.isHeld()) {
3290 mGoingToSleep.release();
3292 if (mService.mShuttingDown) {
3293 mService.notifyAll();
3297 boolean reportResumedActivityLocked(ActivityRecord r) {
3298 final ActivityStack stack = r.getStack();
3299 if (isFocusedStack(stack)) {
3300 mService.updateUsageStats(r, true);
3302 if (allResumedActivitiesComplete()) {
3303 ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
3304 mWindowManager.executeAppTransition();
3310 void handleAppCrashLocked(ProcessRecord app) {
3311 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
3312 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
3313 int stackNdx = stacks.size() - 1;
3314 while (stackNdx >= 0) {
3315 stacks.get(stackNdx).handleAppCrashLocked(app);
3321 boolean requestVisibleBehindLocked(ActivityRecord r, boolean visible) {
3322 final ActivityStack stack = r.getStack();
3323 if (stack == null) {
3324 if (DEBUG_VISIBLE_BEHIND) Slog.d(TAG_VISIBLE_BEHIND,
3325 "requestVisibleBehind: r=" + r + " visible=" + visible + " stack is null");
3329 if (visible && !StackId.activitiesCanRequestVisibleBehind(stack.mStackId)) {
3330 if (DEBUG_VISIBLE_BEHIND) Slog.d(TAG_VISIBLE_BEHIND, "requestVisibleBehind: r=" + r
3331 + " visible=" + visible + " stackId=" + stack.mStackId
3332 + " can't contain visible behind activities");
3336 final boolean isVisible = stack.hasVisibleBehindActivity();
3337 if (DEBUG_VISIBLE_BEHIND) Slog.d(TAG_VISIBLE_BEHIND,
3338 "requestVisibleBehind r=" + r + " visible=" + visible + " isVisible=" + isVisible);
3340 final ActivityRecord top = topRunningActivityLocked();
3341 if (top == null || top == r || (visible == isVisible)) {
3342 if (DEBUG_VISIBLE_BEHIND) Slog.d(TAG_VISIBLE_BEHIND, "requestVisibleBehind: quick return");
3343 stack.setVisibleBehindActivity(visible ? r : null);
3347 // A non-top activity is reporting a visibility change.
3348 if (visible && top.fullscreen) {
3349 // Let the caller know that it can't be seen.
3350 if (DEBUG_VISIBLE_BEHIND) Slog.d(TAG_VISIBLE_BEHIND,
3351 "requestVisibleBehind: returning top.fullscreen=" + top.fullscreen
3352 + " top.state=" + top.state + " top.app=" + top.app + " top.app.thread="
3355 } else if (!visible && stack.getVisibleBehindActivity() != r) {
3356 // Only the activity set as currently visible behind should actively reset its
3357 // visible behind state.
3358 if (DEBUG_VISIBLE_BEHIND) Slog.d(TAG_VISIBLE_BEHIND,
3359 "requestVisibleBehind: returning visible=" + visible
3360 + " stack.getVisibleBehindActivity()=" + stack.getVisibleBehindActivity()
3365 stack.setVisibleBehindActivity(visible ? r : null);
3367 // If there is a translucent home activity, we need to force it stop being translucent,
3368 // because we can't depend on the application to necessarily perform that operation.
3369 // Check out b/14469711 for details.
3370 final ActivityRecord next = stack.findNextTranslucentActivity(r);
3371 if (next != null && next.isHomeActivity()) {
3372 mService.convertFromTranslucent(next.appToken);
3375 if (top.app != null && top.app.thread != null) {
3376 // Notify the top app of the change.
3378 top.app.thread.scheduleBackgroundVisibleBehindChanged(top.appToken, visible);
3379 } catch (RemoteException e) {
3385 // Called when WindowManager has finished animating the launchingBehind activity to the back.
3386 private void handleLaunchTaskBehindCompleteLocked(ActivityRecord r) {
3387 final TaskRecord task = r.getTask();
3388 final ActivityStack stack = task.getStack();
3390 r.mLaunchTaskBehind = false;
3391 task.setLastThumbnailLocked(r.screenshotActivityLocked());
3392 mRecentTasks.addLocked(task);
3393 mService.mTaskChangeNotificationController.notifyTaskStackChanged();
3394 r.setVisibility(false);
3396 // When launching tasks behind, update the last active time of the top task after the new
3397 // task has been shown briefly
3398 final ActivityRecord top = stack.topActivity();
3400 top.getTask().touchActiveTime();
3404 void scheduleLaunchTaskBehindComplete(IBinder token) {
3405 mHandler.obtainMessage(LAUNCH_TASK_BEHIND_COMPLETE, token).sendToTarget();
3408 void ensureActivitiesVisibleLocked(ActivityRecord starting, int configChanges,
3409 boolean preserveWindows) {
3410 mKeyguardController.beginActivityVisibilityUpdate();
3412 // First the front stacks. In case any are not fullscreen and are in front of home.
3413 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
3414 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
3415 final int topStackNdx = stacks.size() - 1;
3416 for (int stackNdx = topStackNdx; stackNdx >= 0; --stackNdx) {
3417 final ActivityStack stack = stacks.get(stackNdx);
3418 stack.ensureActivitiesVisibleLocked(starting, configChanges, preserveWindows);
3422 mKeyguardController.endActivityVisibilityUpdate();
3426 void addStartingWindowsForVisibleActivities(boolean taskSwitch) {
3427 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
3428 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
3429 final int topStackNdx = stacks.size() - 1;
3430 for (int stackNdx = topStackNdx; stackNdx >= 0; --stackNdx) {
3431 final ActivityStack stack = stacks.get(stackNdx);
3432 stack.addStartingWindowsForVisibleActivities(taskSwitch);
3437 void invalidateTaskLayers() {
3438 mTaskLayersChanged = true;
3441 void rankTaskLayersIfNeeded() {
3442 if (!mTaskLayersChanged) {
3445 mTaskLayersChanged = false;
3446 for (int displayNdx = 0; displayNdx < mActivityDisplays.size(); displayNdx++) {
3447 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
3449 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
3450 baseLayer += stacks.get(stackNdx).rankTaskLayers(baseLayer);
3455 void clearOtherAppTimeTrackers(AppTimeTracker except) {
3456 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
3457 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
3458 final int topStackNdx = stacks.size() - 1;
3459 for (int stackNdx = topStackNdx; stackNdx >= 0; --stackNdx) {
3460 final ActivityStack stack = stacks.get(stackNdx);
3461 stack.clearOtherAppTimeTrackers(except);
3466 void scheduleDestroyAllActivities(ProcessRecord app, String reason) {
3467 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
3468 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
3469 final int numStacks = stacks.size();
3470 for (int stackNdx = 0; stackNdx < numStacks; ++stackNdx) {
3471 final ActivityStack stack = stacks.get(stackNdx);
3472 stack.scheduleDestroyActivities(app, reason);
3477 void releaseSomeActivitiesLocked(ProcessRecord app, String reason) {
3478 // Examine all activities currently running in the process.
3479 TaskRecord firstTask = null;
3480 // Tasks is non-null only if two or more tasks are found.
3481 ArraySet<TaskRecord> tasks = null;
3482 if (DEBUG_RELEASE) Slog.d(TAG_RELEASE, "Trying to release some activities in " + app);
3483 for (int i = 0; i < app.activities.size(); i++) {
3484 ActivityRecord r = app.activities.get(i);
3485 // First, if we find an activity that is in the process of being destroyed,
3486 // then we just aren't going to do anything for now; we want things to settle
3487 // down before we try to prune more activities.
3488 if (r.finishing || r.state == DESTROYING || r.state == DESTROYED) {
3489 if (DEBUG_RELEASE) Slog.d(TAG_RELEASE, "Abort release; already destroying: " + r);
3492 // Don't consider any activies that are currently not in a state where they
3493 // can be destroyed.
3494 if (r.visible || !r.stopped || !r.haveState || r.state == RESUMED || r.state == PAUSING
3495 || r.state == PAUSED || r.state == STOPPING) {
3496 if (DEBUG_RELEASE) Slog.d(TAG_RELEASE, "Not releasing in-use activity: " + r);
3500 final TaskRecord task = r.getTask();
3502 if (DEBUG_RELEASE) Slog.d(TAG_RELEASE, "Collecting release task " + task
3504 if (firstTask == null) {
3506 } else if (firstTask != task) {
3507 if (tasks == null) {
3508 tasks = new ArraySet<>();
3509 tasks.add(firstTask);
3515 if (tasks == null) {
3516 if (DEBUG_RELEASE) Slog.d(TAG_RELEASE, "Didn't find two or more tasks to release");
3519 // If we have activities in multiple tasks that are in a position to be destroyed,
3520 // let's iterate through the tasks and release the oldest one.
3521 final int numDisplays = mActivityDisplays.size();
3522 for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
3523 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
3524 // Step through all stacks starting from behind, to hit the oldest things first.
3525 for (int stackNdx = 0; stackNdx < stacks.size(); stackNdx++) {
3526 final ActivityStack stack = stacks.get(stackNdx);
3527 // Try to release activities in this stack; if we manage to, we are done.
3528 if (stack.releaseSomeActivitiesLocked(app, tasks, reason) > 0) {
3535 boolean switchUserLocked(int userId, UserState uss) {
3536 final int focusStackId = mFocusedStack.getStackId();
3537 // We dismiss the docked stack whenever we switch users.
3538 moveTasksToFullscreenStackLocked(DOCKED_STACK_ID, focusStackId == DOCKED_STACK_ID);
3539 // Also dismiss the pinned stack whenever we switch users. Removing the pinned stack will
3540 // also cause all tasks to be moved to the fullscreen stack at a position that is
3542 removeStackLocked(PINNED_STACK_ID);
3544 mUserStackInFront.put(mCurrentUser, focusStackId);
3545 final int restoreStackId = mUserStackInFront.get(userId, HOME_STACK_ID);
3546 mCurrentUser = userId;
3548 mStartingUsers.add(uss);
3549 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
3550 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
3551 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
3552 final ActivityStack stack = stacks.get(stackNdx);
3553 stack.switchUserLocked(userId);
3554 TaskRecord task = stack.topTask();
3556 stack.positionChildWindowContainerAtTop(task);
3561 ActivityStack stack = getStack(restoreStackId);
3562 if (stack == null) {
3565 final boolean homeInFront = stack.isHomeStack();
3566 if (stack.isOnHomeDisplay()) {
3567 stack.moveToFront("switchUserOnHomeDisplay");
3569 // Stack was moved to another display while user was swapped out.
3570 resumeHomeStackTask(null, "switchUserOnOtherDisplay");
3575 /** Checks whether the userid is a profile of the current user. */
3576 boolean isCurrentProfileLocked(int userId) {
3577 if (userId == mCurrentUser) return true;
3578 return mService.mUserController.isCurrentProfileLocked(userId);
3582 * Returns whether a stopping activity is present that should be stopped after visible, rather
3584 * @return {@code true} if such activity is present. {@code false} otherwise.
3586 boolean isStoppingNoHistoryActivity() {
3587 // Activities that are marked as nohistory should be stopped immediately after the resumed
3588 // activity has become visible.
3589 for (ActivityRecord record : mStoppingActivities) {
3590 if (record.isNoHistory()) {
3598 final ArrayList<ActivityRecord> processStoppingActivitiesLocked(ActivityRecord idleActivity,
3599 boolean remove, boolean processPausingActivities) {
3600 ArrayList<ActivityRecord> stops = null;
3602 final boolean nowVisible = allResumedActivitiesVisible();
3603 for (int activityNdx = mStoppingActivities.size() - 1; activityNdx >= 0; --activityNdx) {
3604 ActivityRecord s = mStoppingActivities.get(activityNdx);
3605 boolean waitingVisible = mActivitiesWaitingForVisibleActivity.contains(s);
3606 if (DEBUG_STATES) Slog.v(TAG, "Stopping " + s + ": nowVisible=" + nowVisible
3607 + " waitingVisible=" + waitingVisible + " finishing=" + s.finishing);
3608 if (waitingVisible && nowVisible) {
3609 mActivitiesWaitingForVisibleActivity.remove(s);
3610 waitingVisible = false;
3612 // If this activity is finishing, it is sitting on top of
3613 // everyone else but we now know it is no longer needed...
3614 // so get rid of it. Otherwise, we need to go through the
3615 // normal flow and hide it once we determine that it is
3616 // hidden by the activities in front of it.
3617 if (DEBUG_STATES) Slog.v(TAG, "Before stopping, can hide: " + s);
3618 s.setVisibility(false);
3621 if ((!waitingVisible || mService.isSleepingOrShuttingDownLocked()) && remove) {
3622 if (!processPausingActivities && s.state == PAUSING) {
3623 // Defer processing pausing activities in this iteration and reschedule
3624 // a delayed idle to reprocess it again
3625 removeTimeoutsForActivityLocked(idleActivity);
3626 scheduleIdleTimeoutLocked(idleActivity);
3630 if (DEBUG_STATES) Slog.v(TAG, "Ready to stop: " + s);
3631 if (stops == null) {
3632 stops = new ArrayList<>();
3635 mStoppingActivities.remove(activityNdx);
3642 void validateTopActivitiesLocked() {
3643 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
3644 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
3645 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
3646 final ActivityStack stack = stacks.get(stackNdx);
3647 final ActivityRecord r = stack.topRunningActivityLocked();
3648 final ActivityState state = r == null ? DESTROYED : r.state;
3649 if (isFocusedStack(stack)) {
3650 if (r == null) Slog.e(TAG,
3651 "validateTop...: null top activity, stack=" + stack);
3653 final ActivityRecord pausing = stack.mPausingActivity;
3654 if (pausing != null && pausing == r) Slog.e(TAG,
3655 "validateTop...: top stack has pausing activity r=" + r
3656 + " state=" + state);
3657 if (state != INITIALIZING && state != RESUMED) Slog.e(TAG,
3658 "validateTop...: activity in front not resumed r=" + r
3659 + " state=" + state);
3662 final ActivityRecord resumed = stack.mResumedActivity;
3663 if (resumed != null && resumed == r) Slog.e(TAG,
3664 "validateTop...: back stack has resumed activity r=" + r
3665 + " state=" + state);
3666 if (r != null && (state == INITIALIZING || state == RESUMED)) Slog.e(TAG,
3667 "validateTop...: activity in back resumed r=" + r + " state=" + state);
3673 private String lockTaskModeToString() {
3674 switch (mLockTaskModeState) {
3675 case LOCK_TASK_MODE_LOCKED:
3677 case LOCK_TASK_MODE_PINNED:
3679 case LOCK_TASK_MODE_NONE:
3681 default: return "unknown=" + mLockTaskModeState;
3685 public void dump(PrintWriter pw, String prefix) {
3686 pw.print(prefix); pw.print("mFocusedStack=" + mFocusedStack);
3687 pw.print(" mLastFocusedStack="); pw.println(mLastFocusedStack);
3688 pw.print(prefix); pw.println("mSleepTimeout=" + mSleepTimeout);
3690 pw.println("mCurTaskIdForUser=" + mCurTaskIdForUser);
3691 pw.print(prefix); pw.println("mUserStackInFront=" + mUserStackInFront);
3692 pw.print(prefix); pw.println("mActivityContainers=" + mActivityContainers);
3693 pw.print(prefix); pw.print("mLockTaskModeState=" + lockTaskModeToString());
3694 final SparseArray<String[]> packages = mService.mLockTaskPackages;
3695 if (packages.size() > 0) {
3696 pw.print(prefix); pw.println("mLockTaskPackages (userId:packages)=");
3697 for (int i = 0; i < packages.size(); ++i) {
3698 pw.print(prefix); pw.print(prefix); pw.print(packages.keyAt(i));
3699 pw.print(":"); pw.println(Arrays.toString(packages.valueAt(i)));
3702 if (!mWaitingForActivityVisible.isEmpty()) {
3703 pw.print(prefix); pw.println("mWaitingForActivityVisible=");
3704 for (int i = 0; i < mWaitingForActivityVisible.size(); ++i) {
3705 pw.print(prefix); pw.print(prefix); mWaitingForActivityVisible.get(i).dump(pw, prefix);
3709 pw.println(" mLockTaskModeTasks" + mLockTaskModeTasks);
3710 mKeyguardController.dump(pw, prefix);
3714 * Dump all connected displays' configurations.
3715 * @param prefix Prefix to apply to each line of the dump.
3717 void dumpDisplayConfigs(PrintWriter pw, String prefix) {
3718 pw.print(prefix); pw.println("Display override configurations:");
3719 final int displayCount = mActivityDisplays.size();
3720 for (int i = 0; i < displayCount; i++) {
3721 final ActivityDisplay activityDisplay = mActivityDisplays.valueAt(i);
3722 pw.print(prefix); pw.print(" "); pw.print(activityDisplay.mDisplayId); pw.print(": ");
3723 pw.println(activityDisplay.getOverrideConfiguration());
3728 * Dumps the activities matching the given {@param name} in the either the focused stack
3729 * or all visible stacks if {@param dumpVisibleStacks} is true.
3731 ArrayList<ActivityRecord> getDumpActivitiesLocked(String name, boolean dumpVisibleStacksOnly,
3732 boolean dumpFocusedStackOnly) {
3733 if (dumpFocusedStackOnly) {
3734 return mFocusedStack.getDumpActivitiesLocked(name);
3736 ArrayList<ActivityRecord> activities = new ArrayList<>();
3737 int numDisplays = mActivityDisplays.size();
3738 for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
3739 ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
3740 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
3741 ActivityStack stack = stacks.get(stackNdx);
3742 if (!dumpVisibleStacksOnly ||
3743 stack.shouldBeVisible(null) == STACK_VISIBLE) {
3744 activities.addAll(stack.getDumpActivitiesLocked(name));
3752 static boolean printThisActivity(PrintWriter pw, ActivityRecord activity, String dumpPackage,
3753 boolean needSep, String prefix) {
3754 if (activity != null) {
3755 if (dumpPackage == null || dumpPackage.equals(activity.packageName)) {
3760 pw.println(activity);
3767 boolean dumpActivitiesLocked(FileDescriptor fd, PrintWriter pw, boolean dumpAll,
3768 boolean dumpClient, String dumpPackage) {
3769 boolean printed = false;
3770 boolean needSep = false;
3771 for (int displayNdx = 0; displayNdx < mActivityDisplays.size(); ++displayNdx) {
3772 ActivityDisplay activityDisplay = mActivityDisplays.valueAt(displayNdx);
3773 pw.print("Display #"); pw.print(activityDisplay.mDisplayId);
3774 pw.println(" (activities from top to bottom):");
3775 ArrayList<ActivityStack> stacks = activityDisplay.mStacks;
3776 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
3777 final ActivityStack stack = stacks.get(stackNdx);
3778 StringBuilder stackHeader = new StringBuilder(128);
3779 stackHeader.append(" Stack #");
3780 stackHeader.append(stack.mStackId);
3781 stackHeader.append(":");
3782 stackHeader.append("\n");
3783 stackHeader.append(" mFullscreen=" + stack.mFullscreen);
3784 stackHeader.append("\n");
3785 stackHeader.append(" mBounds=" + stack.mBounds);
3787 final boolean printedStackHeader = stack.dumpActivitiesLocked(fd, pw, dumpAll,
3788 dumpClient, dumpPackage, needSep, stackHeader.toString());
3789 printed |= printedStackHeader;
3790 if (!printedStackHeader) {
3791 // Ensure we always dump the stack header even if there are no activities
3793 pw.println(stackHeader);
3796 printed |= dumpHistoryList(fd, pw, stack.mLRUActivities, " ", "Run", false,
3797 !dumpAll, false, dumpPackage, true,
3798 " Running activities (most recent first):", null);
3801 boolean pr = printThisActivity(pw, stack.mPausingActivity, dumpPackage, needSep,
3802 " mPausingActivity: ");
3807 pr = printThisActivity(pw, stack.mResumedActivity, dumpPackage, needSep,
3808 " mResumedActivity: ");
3814 pr = printThisActivity(pw, stack.mLastPausedActivity, dumpPackage, needSep,
3815 " mLastPausedActivity: ");
3820 printed |= printThisActivity(pw, stack.mLastNoHistoryActivity, dumpPackage,
3821 needSep, " mLastNoHistoryActivity: ");
3827 printed |= dumpHistoryList(fd, pw, mFinishingActivities, " ", "Fin", false, !dumpAll,
3828 false, dumpPackage, true, " Activities waiting to finish:", null);
3829 printed |= dumpHistoryList(fd, pw, mStoppingActivities, " ", "Stop", false, !dumpAll,
3830 false, dumpPackage, true, " Activities waiting to stop:", null);
3831 printed |= dumpHistoryList(fd, pw, mActivitiesWaitingForVisibleActivity, " ", "Wait",
3832 false, !dumpAll, false, dumpPackage, true,
3833 " Activities waiting for another to become visible:", null);
3834 printed |= dumpHistoryList(fd, pw, mGoingToSleepActivities, " ", "Sleep", false, !dumpAll,
3835 false, dumpPackage, true, " Activities waiting to sleep:", null);
3836 printed |= dumpHistoryList(fd, pw, mGoingToSleepActivities, " ", "Sleep", false, !dumpAll,
3837 false, dumpPackage, true, " Activities waiting to sleep:", null);
3842 static boolean dumpHistoryList(FileDescriptor fd, PrintWriter pw, List<ActivityRecord> list,
3843 String prefix, String label, boolean complete, boolean brief, boolean client,
3844 String dumpPackage, boolean needNL, String header1, String header2) {
3845 TaskRecord lastTask = null;
3846 String innerPrefix = null;
3847 String[] args = null;
3848 boolean printed = false;
3849 for (int i=list.size()-1; i>=0; i--) {
3850 final ActivityRecord r = list.get(i);
3851 if (dumpPackage != null && !dumpPackage.equals(r.packageName)) {
3854 if (innerPrefix == null) {
3855 innerPrefix = prefix + " ";
3856 args = new String[0];
3859 final boolean full = !brief && (complete || !r.isInHistory());
3864 if (header1 != null) {
3865 pw.println(header1);
3868 if (header2 != null) {
3869 pw.println(header2);
3872 if (lastTask != r.getTask()) {
3873 lastTask = r.getTask();
3875 pw.print(full ? "* " : " ");
3876 pw.println(lastTask);
3878 lastTask.dump(pw, prefix + " ");
3879 } else if (complete) {
3880 // Complete + brief == give a summary. Isn't that obvious?!?
3881 if (lastTask.intent != null) {
3882 pw.print(prefix); pw.print(" ");
3883 pw.println(lastTask.intent.toInsecureStringWithClip());
3887 pw.print(prefix); pw.print(full ? " * " : " "); pw.print(label);
3888 pw.print(" #"); pw.print(i); pw.print(": ");
3891 r.dump(pw, innerPrefix);
3892 } else if (complete) {
3893 // Complete + brief == give a summary. Isn't that obvious?!?
3894 pw.print(innerPrefix); pw.println(r.intent.toInsecureString());
3895 if (r.app != null) {
3896 pw.print(innerPrefix); pw.println(r.app);
3899 if (client && r.app != null && r.app.thread != null) {
3900 // flush anything that is already in the PrintWriter since the thread is going
3901 // to write to the file descriptor directly
3904 TransferPipe tp = new TransferPipe();
3906 r.app.thread.dumpActivity(tp.getWriteFd(), r.appToken, innerPrefix, args);
3907 // Short timeout, since blocking here can
3908 // deadlock with the application.
3913 } catch (IOException e) {
3914 pw.println(innerPrefix + "Failure while dumping the activity: " + e);
3915 } catch (RemoteException e) {
3916 pw.println(innerPrefix + "Got a RemoteException while dumping the activity");
3924 void scheduleIdleTimeoutLocked(ActivityRecord next) {
3925 if (DEBUG_IDLE) Slog.d(TAG_IDLE,
3926 "scheduleIdleTimeoutLocked: Callers=" + Debug.getCallers(4));
3927 Message msg = mHandler.obtainMessage(IDLE_TIMEOUT_MSG, next);
3928 mHandler.sendMessageDelayed(msg, IDLE_TIMEOUT);
3931 final void scheduleIdleLocked() {
3932 mHandler.sendEmptyMessage(IDLE_NOW_MSG);
3935 void removeTimeoutsForActivityLocked(ActivityRecord r) {
3936 if (DEBUG_IDLE) Slog.d(TAG_IDLE, "removeTimeoutsForActivity: Callers="
3937 + Debug.getCallers(4));
3938 mHandler.removeMessages(IDLE_TIMEOUT_MSG, r);
3941 final void scheduleResumeTopActivities() {
3942 if (!mHandler.hasMessages(RESUME_TOP_ACTIVITY_MSG)) {
3943 mHandler.sendEmptyMessage(RESUME_TOP_ACTIVITY_MSG);
3947 void removeSleepTimeouts() {
3948 mSleepTimeout = false;
3949 mHandler.removeMessages(SLEEP_TIMEOUT_MSG);
3952 final void scheduleSleepTimeout() {
3953 removeSleepTimeouts();
3954 mHandler.sendEmptyMessageDelayed(SLEEP_TIMEOUT_MSG, SLEEP_TIMEOUT);
3958 public void onDisplayAdded(int displayId) {
3959 if (DEBUG_STACK) Slog.v(TAG, "Display added displayId=" + displayId);
3960 mHandler.sendMessage(mHandler.obtainMessage(HANDLE_DISPLAY_ADDED, displayId, 0));
3964 public void onDisplayRemoved(int displayId) {
3965 if (DEBUG_STACK) Slog.v(TAG, "Display removed displayId=" + displayId);
3966 mHandler.sendMessage(mHandler.obtainMessage(HANDLE_DISPLAY_REMOVED, displayId, 0));
3970 public void onDisplayChanged(int displayId) {
3971 if (DEBUG_STACK) Slog.v(TAG, "Display changed displayId=" + displayId);
3972 mHandler.sendMessage(mHandler.obtainMessage(HANDLE_DISPLAY_CHANGED, displayId, 0));
3975 private void handleDisplayAdded(int displayId) {
3976 synchronized (mService) {
3977 getActivityDisplayOrCreateLocked(displayId);
3981 /** Check if display with specified id is added to the list. */
3982 boolean isDisplayAdded(int displayId) {
3983 return getActivityDisplayOrCreateLocked(displayId) != null;
3987 * Get an existing instance of {@link ActivityDisplay} or create new if there is a
3988 * corresponding record in display manager.
3990 private ActivityDisplay getActivityDisplayOrCreateLocked(int displayId) {
3991 ActivityDisplay activityDisplay = mActivityDisplays.get(displayId);
3992 if (activityDisplay != null) {
3993 return activityDisplay;
3995 if (mDisplayManager == null) {
3996 // The system isn't fully initialized yet.
3999 final Display display = mDisplayManager.getDisplay(displayId);
4000 if (display == null) {
4001 // The display is not registered in DisplayManager.
4004 // The display hasn't been added to ActivityManager yet, create a new record now.
4005 activityDisplay = new ActivityDisplay(displayId);
4006 if (activityDisplay.mDisplay == null) {
4007 Slog.w(TAG, "Display " + displayId + " gone before initialization complete");
4010 mActivityDisplays.put(displayId, activityDisplay);
4011 calculateDefaultMinimalSizeOfResizeableTasks(activityDisplay);
4012 mWindowManager.onDisplayAdded(displayId);
4013 return activityDisplay;
4016 private void calculateDefaultMinimalSizeOfResizeableTasks(ActivityDisplay display) {
4017 mDefaultMinSizeOfResizeableTask =
4018 mService.mContext.getResources().getDimensionPixelSize(
4019 com.android.internal.R.dimen.default_minimal_size_resizable_task);
4022 private void handleDisplayRemoved(int displayId) {
4023 if (displayId == DEFAULT_DISPLAY) {
4024 throw new IllegalArgumentException("Can't remove the primary display.");
4027 synchronized (mService) {
4028 ActivityDisplay activityDisplay = mActivityDisplays.get(displayId);
4029 if (activityDisplay != null) {
4030 final boolean destroyContentOnRemoval
4031 = activityDisplay.shouldDestroyContentOnRemove();
4032 final ArrayList<ActivityStack> stacks = activityDisplay.mStacks;
4033 while (!stacks.isEmpty()) {
4034 final ActivityStack stack = stacks.get(0);
4035 if (destroyContentOnRemoval) {
4036 moveStackToDisplayLocked(stack.mStackId, DEFAULT_DISPLAY,
4038 stack.finishAllActivitiesLocked(true /* immediately */);
4040 // Moving all tasks to fullscreen stack, because it's guaranteed to be
4041 // a valid launch stack for all activities. This way the task history from
4042 // external display will be preserved on primary after move.
4043 moveTasksToFullscreenStackLocked(stack.getStackId(), true /* onTop */);
4046 mActivityDisplays.remove(displayId);
4047 mWindowManager.onDisplayRemoved(displayId);
4052 private void handleDisplayChanged(int displayId) {
4053 synchronized (mService) {
4054 ActivityDisplay activityDisplay = mActivityDisplays.get(displayId);
4055 if (activityDisplay != null) {
4056 // TODO: Update the bounds.
4058 mWindowManager.onDisplayChanged(displayId);
4062 private StackInfo getStackInfoLocked(ActivityStack stack) {
4063 final int displayId = stack.mDisplayId;
4064 final ActivityDisplay display = mActivityDisplays.get(displayId);
4065 StackInfo info = new StackInfo();
4066 stack.getWindowContainerBounds(info.bounds);
4067 info.displayId = displayId;
4068 info.stackId = stack.mStackId;
4069 info.userId = stack.mCurrentUser;
4070 info.visible = stack.shouldBeVisible(null) == STACK_VISIBLE;
4071 // A stack might be not attached to a display.
4072 info.position = display != null
4073 ? display.mStacks.indexOf(stack)
4076 ArrayList<TaskRecord> tasks = stack.getAllTasks();
4077 final int numTasks = tasks.size();
4078 int[] taskIds = new int[numTasks];
4079 String[] taskNames = new String[numTasks];
4080 Rect[] taskBounds = new Rect[numTasks];
4081 int[] taskUserIds = new int[numTasks];
4082 for (int i = 0; i < numTasks; ++i) {
4083 final TaskRecord task = tasks.get(i);
4084 taskIds[i] = task.taskId;
4085 taskNames[i] = task.origActivity != null ? task.origActivity.flattenToString()
4086 : task.realActivity != null ? task.realActivity.flattenToString()
4087 : task.getTopActivity() != null ? task.getTopActivity().packageName
4089 taskBounds[i] = new Rect();
4090 task.getWindowContainerBounds(taskBounds[i]);
4091 taskUserIds[i] = task.userId;
4093 info.taskIds = taskIds;
4094 info.taskNames = taskNames;
4095 info.taskBounds = taskBounds;
4096 info.taskUserIds = taskUserIds;
4098 final ActivityRecord top = stack.topRunningActivityLocked();
4099 info.topActivity = top != null ? top.intent.getComponent() : null;
4103 StackInfo getStackInfoLocked(int stackId) {
4104 ActivityStack stack = getStack(stackId);
4105 if (stack != null) {
4106 return getStackInfoLocked(stack);
4111 ArrayList<StackInfo> getAllStackInfosLocked() {
4112 ArrayList<StackInfo> list = new ArrayList<>();
4113 for (int displayNdx = 0; displayNdx < mActivityDisplays.size(); ++displayNdx) {
4114 ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
4115 for (int ndx = stacks.size() - 1; ndx >= 0; --ndx) {
4116 list.add(getStackInfoLocked(stacks.get(ndx)));
4122 TaskRecord getLockedTaskLocked() {
4123 final int top = mLockTaskModeTasks.size() - 1;
4125 return mLockTaskModeTasks.get(top);
4130 boolean isLockedTask(TaskRecord task) {
4131 return mLockTaskModeTasks.contains(task);
4134 boolean isLastLockedTask(TaskRecord task) {
4135 return mLockTaskModeTasks.size() == 1 && mLockTaskModeTasks.contains(task);
4138 void removeLockedTaskLocked(final TaskRecord task) {
4139 if (!mLockTaskModeTasks.remove(task)) {
4142 if (DEBUG_LOCKTASK) Slog.w(TAG_LOCKTASK, "removeLockedTaskLocked: removed " + task);
4143 if (mLockTaskModeTasks.isEmpty()) {
4145 if (DEBUG_LOCKTASK) Slog.d(TAG_LOCKTASK, "removeLockedTask: task=" + task +
4146 " last task, reverting locktask mode. Callers=" + Debug.getCallers(3));
4147 final Message lockTaskMsg = Message.obtain();
4148 lockTaskMsg.arg1 = task.userId;
4149 lockTaskMsg.what = LOCK_TASK_END_MSG;
4150 mHandler.sendMessage(lockTaskMsg);
4154 void handleNonResizableTaskIfNeeded(TaskRecord task, int preferredStackId,
4155 int preferredDisplayId, int actualStackId) {
4156 handleNonResizableTaskIfNeeded(task, preferredStackId, preferredDisplayId, actualStackId,
4157 false /* forceNonResizable */);
4160 private void handleNonResizableTaskIfNeeded(TaskRecord task, int preferredStackId,
4161 int preferredDisplayId, int actualStackId, boolean forceNonResizable) {
4162 final boolean isSecondaryDisplayPreferred =
4163 (preferredDisplayId != DEFAULT_DISPLAY && preferredDisplayId != INVALID_DISPLAY)
4164 || StackId.isDynamicStack(preferredStackId);
4165 if (((!isStackDockedInEffect(actualStackId) && preferredStackId != DOCKED_STACK_ID)
4166 && !isSecondaryDisplayPreferred) || task.isHomeTask()) {
4170 // Handle incorrect launch/move to secondary display if needed.
4171 final boolean launchOnSecondaryDisplayFailed;
4172 if (isSecondaryDisplayPreferred) {
4173 final int actualDisplayId = task.getStack().mDisplayId;
4174 if (!task.canBeLaunchedOnDisplay(actualDisplayId)) {
4175 // The task landed on an inappropriate display somehow, move it to the default
4177 // TODO(multi-display): Find proper stack for the task on the default display.
4178 mService.moveTaskToStack(task.taskId, FULLSCREEN_WORKSPACE_STACK_ID,
4180 launchOnSecondaryDisplayFailed = true;
4182 // The task might have landed on a display different from requested.
4183 launchOnSecondaryDisplayFailed = actualDisplayId == DEFAULT_DISPLAY
4184 || (preferredDisplayId != INVALID_DISPLAY
4185 && preferredDisplayId != actualDisplayId);
4188 // The task wasn't requested to be on a secondary display.
4189 launchOnSecondaryDisplayFailed = false;
4192 final ActivityRecord topActivity = task.getTopActivity();
4193 if (launchOnSecondaryDisplayFailed || !task.supportsSplitScreen() || forceNonResizable) {
4194 if (launchOnSecondaryDisplayFailed) {
4195 // Display a warning toast that we tried to put a non-resizeable task on a secondary
4196 // display with config different from global config.
4197 mService.mTaskChangeNotificationController
4198 .notifyActivityLaunchOnSecondaryDisplayFailed();
4200 // Display a warning toast that we tried to put a non-dockable task in the docked
4202 mService.mTaskChangeNotificationController.notifyActivityDismissingDockedStack();
4205 // Dismiss docked stack. If task appeared to be in docked stack but is not resizable -
4206 // we need to move it to top of fullscreen stack, otherwise it will be covered.
4207 moveTasksToFullscreenStackLocked(DOCKED_STACK_ID, actualStackId == DOCKED_STACK_ID);
4208 } else if (topActivity != null && topActivity.isNonResizableOrForcedResizable()
4209 && !topActivity.noDisplay) {
4210 final String packageName = topActivity.appInfo.packageName;
4211 final int reason = isSecondaryDisplayPreferred
4212 ? FORCED_RESIZEABLE_REASON_SECONDARY_DISPLAY
4213 : FORCED_RESIZEABLE_REASON_SPLIT_SCREEN;
4214 mService.mTaskChangeNotificationController.notifyActivityForcedResizable(
4215 task.taskId, reason, packageName);
4219 void showLockTaskToast() {
4220 if (mLockTaskNotify != null) {
4221 mLockTaskNotify.showToast(mLockTaskModeState);
4225 void showLockTaskEscapeMessageLocked(TaskRecord task) {
4226 if (mLockTaskModeTasks.contains(task)) {
4227 mHandler.sendEmptyMessage(SHOW_LOCK_TASK_ESCAPE_MESSAGE_MSG);
4231 void setLockTaskModeLocked(TaskRecord task, int lockTaskModeState, String reason,
4232 boolean andResume) {
4234 // Take out of lock task mode if necessary
4235 final TaskRecord lockedTask = getLockedTaskLocked();
4236 if (lockedTask != null) {
4237 removeLockedTaskLocked(lockedTask);
4238 if (!mLockTaskModeTasks.isEmpty()) {
4239 // There are locked tasks remaining, can only finish this task, not unlock it.
4240 if (DEBUG_LOCKTASK) Slog.w(TAG_LOCKTASK,
4241 "setLockTaskModeLocked: Tasks remaining, can't unlock");
4242 lockedTask.performClearTaskLocked();
4243 resumeFocusedStackTopActivityLocked();
4247 if (DEBUG_LOCKTASK) Slog.w(TAG_LOCKTASK,
4248 "setLockTaskModeLocked: No tasks to unlock. Callers=" + Debug.getCallers(4));
4252 // Should have already been checked, but do it again.
4253 if (task.mLockTaskAuth == LOCK_TASK_AUTH_DONT_LOCK) {
4254 if (DEBUG_LOCKTASK) Slog.w(TAG_LOCKTASK,
4255 "setLockTaskModeLocked: Can't lock due to auth");
4258 if (isLockTaskModeViolation(task)) {
4259 Slog.e(TAG_LOCKTASK, "setLockTaskMode: Attempt to start an unauthorized lock task.");
4263 if (mLockTaskModeTasks.isEmpty()) {
4265 final Message lockTaskMsg = Message.obtain();
4266 lockTaskMsg.obj = task.intent.getComponent().getPackageName();
4267 lockTaskMsg.arg1 = task.userId;
4268 lockTaskMsg.what = LOCK_TASK_START_MSG;
4269 lockTaskMsg.arg2 = lockTaskModeState;
4270 mHandler.sendMessage(lockTaskMsg);
4272 // Add it or move it to the top.
4273 if (DEBUG_LOCKTASK) Slog.w(TAG_LOCKTASK, "setLockTaskModeLocked: Locking to " + task +
4274 " Callers=" + Debug.getCallers(4));
4275 mLockTaskModeTasks.remove(task);
4276 mLockTaskModeTasks.add(task);
4278 if (task.mLockTaskUid == -1) {
4279 task.mLockTaskUid = task.effectiveUid;
4283 findTaskToMoveToFrontLocked(task, 0, null, reason,
4284 lockTaskModeState != LOCK_TASK_MODE_NONE);
4285 resumeFocusedStackTopActivityLocked();
4286 mWindowManager.executeAppTransition();
4287 } else if (lockTaskModeState != LOCK_TASK_MODE_NONE) {
4288 handleNonResizableTaskIfNeeded(task, INVALID_STACK_ID, DEFAULT_DISPLAY,
4289 task.getStackId(), true /* forceNonResizable */);
4293 boolean isLockTaskModeViolation(TaskRecord task) {
4294 return isLockTaskModeViolation(task, false);
4297 boolean isLockTaskModeViolation(TaskRecord task, boolean isNewClearTask) {
4298 if (getLockedTaskLocked() == task && !isNewClearTask) {
4301 final int lockTaskAuth = task.mLockTaskAuth;
4302 switch (lockTaskAuth) {
4303 case LOCK_TASK_AUTH_DONT_LOCK:
4304 return !mLockTaskModeTasks.isEmpty();
4305 case LOCK_TASK_AUTH_LAUNCHABLE_PRIV:
4306 case LOCK_TASK_AUTH_LAUNCHABLE:
4307 case LOCK_TASK_AUTH_WHITELISTED:
4309 case LOCK_TASK_AUTH_PINNABLE:
4310 // Pinnable tasks can't be launched on top of locktask tasks.
4311 return !mLockTaskModeTasks.isEmpty();
4313 Slog.w(TAG, "isLockTaskModeViolation: invalid lockTaskAuth value=" + lockTaskAuth);
4318 void onLockTaskPackagesUpdatedLocked() {
4319 boolean didSomething = false;
4320 for (int taskNdx = mLockTaskModeTasks.size() - 1; taskNdx >= 0; --taskNdx) {
4321 final TaskRecord lockedTask = mLockTaskModeTasks.get(taskNdx);
4322 final boolean wasWhitelisted =
4323 (lockedTask.mLockTaskAuth == LOCK_TASK_AUTH_LAUNCHABLE) ||
4324 (lockedTask.mLockTaskAuth == LOCK_TASK_AUTH_WHITELISTED);
4325 lockedTask.setLockTaskAuth();
4326 final boolean isWhitelisted =
4327 (lockedTask.mLockTaskAuth == LOCK_TASK_AUTH_LAUNCHABLE) ||
4328 (lockedTask.mLockTaskAuth == LOCK_TASK_AUTH_WHITELISTED);
4329 if (wasWhitelisted && !isWhitelisted) {
4330 // Lost whitelisting authorization. End it now.
4331 if (DEBUG_LOCKTASK) Slog.d(TAG_LOCKTASK, "onLockTaskPackagesUpdated: removing " +
4332 lockedTask + " mLockTaskAuth=" + lockedTask.lockTaskAuthToString());
4333 removeLockedTaskLocked(lockedTask);
4334 lockedTask.performClearTaskLocked();
4335 didSomething = true;
4338 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
4339 ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
4340 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
4341 final ActivityStack stack = stacks.get(stackNdx);
4342 stack.onLockTaskPackagesUpdatedLocked();
4345 final ActivityRecord r = topRunningActivityLocked();
4346 final TaskRecord task = r != null ? r.getTask() : null;
4347 if (mLockTaskModeTasks.isEmpty() && task != null
4348 && task.mLockTaskAuth == LOCK_TASK_AUTH_LAUNCHABLE) {
4349 // This task must have just been authorized.
4350 if (DEBUG_LOCKTASK) Slog.d(TAG_LOCKTASK,
4351 "onLockTaskPackagesUpdated: starting new locktask task=" + task);
4352 setLockTaskModeLocked(task, ActivityManager.LOCK_TASK_MODE_LOCKED, "package updated",
4354 didSomething = true;
4357 resumeFocusedStackTopActivityLocked();
4361 int getLockTaskModeState() {
4362 return mLockTaskModeState;
4365 void activityRelaunchedLocked(IBinder token) {
4366 mWindowManager.notifyAppRelaunchingFinished(token);
4367 if (mService.isSleepingOrShuttingDownLocked()) {
4368 final ActivityRecord r = ActivityRecord.isInStackLocked(token);
4370 r.setSleeping(true, true);
4375 void activityRelaunchingLocked(ActivityRecord r) {
4376 mWindowManager.notifyAppRelaunching(r.appToken);
4379 void logStackState() {
4380 mActivityMetricsLogger.logWindowState();
4383 void scheduleUpdateMultiWindowMode(TaskRecord task) {
4384 // If the stack is animating in a way where we will be forcing a multi-mode change at the
4385 // end, then ensure that we defer all in between multi-window mode changes
4386 if (task.getStack().deferScheduleMultiWindowModeChanged()) {
4390 for (int i = task.mActivities.size() - 1; i >= 0; i--) {
4391 final ActivityRecord r = task.mActivities.get(i);
4392 if (r.app != null && r.app.thread != null) {
4393 mMultiWindowModeChangedActivities.add(r);
4397 if (!mHandler.hasMessages(REPORT_MULTI_WINDOW_MODE_CHANGED_MSG)) {
4398 mHandler.sendEmptyMessage(REPORT_MULTI_WINDOW_MODE_CHANGED_MSG);
4402 void scheduleUpdatePictureInPictureModeIfNeeded(TaskRecord task, ActivityStack prevStack) {
4403 final ActivityStack stack = task.getStack();
4404 if (prevStack == null || prevStack == stack
4405 || (prevStack.mStackId != PINNED_STACK_ID && stack.mStackId != PINNED_STACK_ID)) {
4409 scheduleUpdatePictureInPictureModeIfNeeded(task, stack.mBounds, false /* immediate */);
4412 void scheduleUpdatePictureInPictureModeIfNeeded(TaskRecord task, Rect targetStackBounds,
4413 boolean immediate) {
4416 mHandler.removeMessages(REPORT_PIP_MODE_CHANGED_MSG);
4417 for (int i = task.mActivities.size() - 1; i >= 0; i--) {
4418 final ActivityRecord r = task.mActivities.get(i);
4419 if (r.app != null && r.app.thread != null) {
4420 r.updatePictureInPictureMode(targetStackBounds);
4424 for (int i = task.mActivities.size() - 1; i >= 0; i--) {
4425 final ActivityRecord r = task.mActivities.get(i);
4426 if (r.app != null && r.app.thread != null) {
4427 mPipModeChangedActivities.add(r);
4430 mPipModeChangedTargetStackBounds = targetStackBounds;
4432 if (!mHandler.hasMessages(REPORT_PIP_MODE_CHANGED_MSG)) {
4433 mHandler.sendEmptyMessage(REPORT_PIP_MODE_CHANGED_MSG);
4438 void setDockedStackMinimized(boolean minimized) {
4439 mIsDockMinimized = minimized;
4442 private final class ActivityStackSupervisorHandler extends Handler {
4444 public ActivityStackSupervisorHandler(Looper looper) {
4448 void activityIdleInternal(ActivityRecord r, boolean processPausingActivities) {
4449 synchronized (mService) {
4450 activityIdleInternalLocked(r != null ? r.appToken : null, true /* fromTimeout */,
4451 processPausingActivities, null);
4456 public void handleMessage(Message msg) {
4458 case REPORT_MULTI_WINDOW_MODE_CHANGED_MSG: {
4459 synchronized (mService) {
4460 for (int i = mMultiWindowModeChangedActivities.size() - 1; i >= 0; i--) {
4461 final ActivityRecord r = mMultiWindowModeChangedActivities.remove(i);
4462 r.updateMultiWindowMode();
4466 case REPORT_PIP_MODE_CHANGED_MSG: {
4467 synchronized (mService) {
4468 for (int i = mPipModeChangedActivities.size() - 1; i >= 0; i--) {
4469 final ActivityRecord r = mPipModeChangedActivities.remove(i);
4470 r.updatePictureInPictureMode(mPipModeChangedTargetStackBounds);
4474 case IDLE_TIMEOUT_MSG: {
4475 if (DEBUG_IDLE) Slog.d(TAG_IDLE,
4476 "handleMessage: IDLE_TIMEOUT_MSG: r=" + msg.obj);
4477 // We don't at this point know if the activity is fullscreen,
4478 // so we need to be conservative and assume it isn't.
4479 activityIdleInternal((ActivityRecord) msg.obj,
4480 true /* processPausingActivities */);
4482 case IDLE_NOW_MSG: {
4483 if (DEBUG_IDLE) Slog.d(TAG_IDLE, "handleMessage: IDLE_NOW_MSG: r=" + msg.obj);
4484 activityIdleInternal((ActivityRecord) msg.obj,
4485 false /* processPausingActivities */);
4487 case RESUME_TOP_ACTIVITY_MSG: {
4488 synchronized (mService) {
4489 resumeFocusedStackTopActivityLocked();
4492 case SLEEP_TIMEOUT_MSG: {
4493 synchronized (mService) {
4494 if (mService.isSleepingOrShuttingDownLocked()) {
4495 Slog.w(TAG, "Sleep timeout! Sleeping now.");
4496 mSleepTimeout = true;
4497 checkReadyForSleepLocked();
4501 case LAUNCH_TIMEOUT_MSG: {
4502 synchronized (mService) {
4503 if (mLaunchingActivity.isHeld()) {
4504 Slog.w(TAG, "Launch timeout has expired, giving up wake lock!");
4505 if (VALIDATE_WAKE_LOCK_CALLER
4506 && Binder.getCallingUid() != Process.myUid()) {
4507 throw new IllegalStateException("Calling must be system uid");
4509 mLaunchingActivity.release();
4513 case HANDLE_DISPLAY_ADDED: {
4514 handleDisplayAdded(msg.arg1);
4516 case HANDLE_DISPLAY_CHANGED: {
4517 handleDisplayChanged(msg.arg1);
4519 case HANDLE_DISPLAY_REMOVED: {
4520 handleDisplayRemoved(msg.arg1);
4522 case CONTAINER_CALLBACK_VISIBILITY: {
4523 final ActivityContainer container = (ActivityContainer) msg.obj;
4524 final IActivityContainerCallback callback = container.mCallback;
4525 if (callback != null) {
4527 callback.setVisible(container.asBinder(), msg.arg1 == 1);
4528 } catch (RemoteException e) {
4532 case LOCK_TASK_START_MSG: {
4533 // When lock task starts, we disable the status bars.
4535 if (mLockTaskNotify == null) {
4536 mLockTaskNotify = new LockTaskNotify(mService.mContext);
4538 mLockTaskNotify.show(true);
4539 mLockTaskModeState = msg.arg2;
4540 if (getStatusBarService() != null) {
4542 if (mLockTaskModeState == LOCK_TASK_MODE_LOCKED) {
4543 flags = StatusBarManager.DISABLE_MASK
4544 & (~StatusBarManager.DISABLE_BACK);
4545 } else if (mLockTaskModeState == LOCK_TASK_MODE_PINNED) {
4546 flags = StatusBarManager.DISABLE_MASK
4547 & (~StatusBarManager.DISABLE_BACK)
4548 & (~StatusBarManager.DISABLE_HOME)
4549 & (~StatusBarManager.DISABLE_RECENT);
4551 getStatusBarService().disable(flags, mToken,
4552 mService.mContext.getPackageName());
4554 mWindowManager.disableKeyguard(mToken, LOCK_TASK_TAG);
4555 if (getDevicePolicyManager() != null) {
4556 getDevicePolicyManager().notifyLockTaskModeChanged(true,
4557 (String)msg.obj, msg.arg1);
4559 } catch (RemoteException ex) {
4560 throw new RuntimeException(ex);
4563 case LOCK_TASK_END_MSG: {
4564 // When lock task ends, we enable the status bars.
4566 if (getStatusBarService() != null) {
4567 getStatusBarService().disable(StatusBarManager.DISABLE_NONE, mToken,
4568 mService.mContext.getPackageName());
4570 mWindowManager.reenableKeyguard(mToken);
4571 if (getDevicePolicyManager() != null) {
4572 getDevicePolicyManager().notifyLockTaskModeChanged(false, null,
4575 if (mLockTaskNotify == null) {
4576 mLockTaskNotify = new LockTaskNotify(mService.mContext);
4578 mLockTaskNotify.show(false);
4580 boolean shouldLockKeyguard = Settings.Secure.getInt(
4581 mService.mContext.getContentResolver(),
4582 Settings.Secure.LOCK_TO_APP_EXIT_LOCKED) != 0;
4583 if (mLockTaskModeState == LOCK_TASK_MODE_PINNED && shouldLockKeyguard) {
4584 mWindowManager.lockNow(null);
4585 mWindowManager.dismissKeyguard(null /* callback */);
4586 new LockPatternUtils(mService.mContext)
4587 .requireCredentialEntry(UserHandle.USER_ALL);
4589 } catch (SettingNotFoundException e) {
4590 // No setting, don't lock.
4592 } catch (RemoteException ex) {
4593 throw new RuntimeException(ex);
4595 mLockTaskModeState = LOCK_TASK_MODE_NONE;
4598 case SHOW_LOCK_TASK_ESCAPE_MESSAGE_MSG: {
4599 if (mLockTaskNotify == null) {
4600 mLockTaskNotify = new LockTaskNotify(mService.mContext);
4602 mLockTaskNotify.showToast(LOCK_TASK_MODE_PINNED);
4604 case CONTAINER_CALLBACK_TASK_LIST_EMPTY: {
4605 final ActivityContainer container = (ActivityContainer) msg.obj;
4606 final IActivityContainerCallback callback = container.mCallback;
4607 if (callback != null) {
4609 callback.onAllActivitiesComplete(container.asBinder());
4610 } catch (RemoteException e) {
4614 case LAUNCH_TASK_BEHIND_COMPLETE: {
4615 synchronized (mService) {
4616 ActivityRecord r = ActivityRecord.forTokenLocked((IBinder) msg.obj);
4618 handleLaunchTaskBehindCompleteLocked(r);
4627 class ActivityContainer extends android.app.IActivityContainer.Stub {
4628 final static int FORCE_NEW_TASK_FLAGS = FLAG_ACTIVITY_NEW_TASK |
4629 FLAG_ACTIVITY_MULTIPLE_TASK | Intent.FLAG_ACTIVITY_NO_ANIMATION;
4631 IActivityContainerCallback mCallback = null;
4632 ActivityStack mStack;
4633 ActivityRecord mParentActivity = null;
4636 boolean mVisible = true;
4638 /** Display this ActivityStack is currently on. Null if not attached to a Display. */
4639 ActivityDisplay mActivityDisplay;
4641 final static int CONTAINER_STATE_HAS_SURFACE = 0;
4642 final static int CONTAINER_STATE_NO_SURFACE = 1;
4643 final static int CONTAINER_STATE_FINISHING = 2;
4644 int mContainerState = CONTAINER_STATE_HAS_SURFACE;
4646 ActivityContainer(int stackId, ActivityDisplay activityDisplay, boolean onTop) {
4647 synchronized (mService) {
4649 mActivityDisplay = activityDisplay;
4650 mIdString = "ActivtyContainer{" + mStackId + "}";
4652 createStack(stackId, onTop);
4653 if (DEBUG_STACK) Slog.d(TAG_STACK, "Creating " + this);
4657 protected void createStack(int stackId, boolean onTop) {
4659 case PINNED_STACK_ID:
4660 new PinnedActivityStack(this, mRecentTasks, onTop);
4663 new ActivityStack(this, mRecentTasks, onTop);
4669 * Adds the stack to specified display. Also calls WindowManager to do the same from
4670 * {@link ActivityStack#reparent(ActivityDisplay, boolean)}.
4671 * @param activityDisplay The display to add the stack to.
4673 void addToDisplayLocked(ActivityDisplay activityDisplay) {
4674 if (DEBUG_STACK) Slog.d(TAG_STACK, "addToDisplayLocked: " + this
4675 + " to display=" + activityDisplay);
4676 if (mActivityDisplay != null) {
4677 throw new IllegalStateException("ActivityContainer is already attached, " +
4678 "displayId=" + mActivityDisplay.mDisplayId);
4680 mActivityDisplay = activityDisplay;
4681 mStack.reparent(activityDisplay, true /* onTop */);
4685 public void addToDisplay(int displayId) {
4686 synchronized (mService) {
4687 final ActivityDisplay activityDisplay = getActivityDisplayOrCreateLocked(displayId);
4688 if (activityDisplay == null) {
4691 addToDisplayLocked(activityDisplay);
4696 public int getDisplayId() {
4697 synchronized (mService) {
4698 if (mActivityDisplay != null) {
4699 return mActivityDisplay.mDisplayId;
4706 public int getStackId() {
4707 synchronized (mService) {
4713 public boolean injectEvent(InputEvent event) {
4714 final long origId = Binder.clearCallingIdentity();
4716 synchronized (mService) {
4717 if (mActivityDisplay != null) {
4718 return mInputManagerInternal.injectInputEvent(event,
4719 mActivityDisplay.mDisplayId,
4720 InputManager.INJECT_INPUT_EVENT_MODE_ASYNC);
4725 Binder.restoreCallingIdentity(origId);
4730 public void release() {
4731 synchronized (mService) {
4732 if (mContainerState == CONTAINER_STATE_FINISHING) {
4735 mContainerState = CONTAINER_STATE_FINISHING;
4737 long origId = Binder.clearCallingIdentity();
4739 mStack.finishAllActivitiesLocked(false);
4740 mService.mActivityStarter.removePendingActivityLaunchesLocked(mStack);
4742 Binder.restoreCallingIdentity(origId);
4748 * Remove the stack completely. Must be called only when there are no tasks left in it,
4749 * as this method does not finish running activities.
4751 void removeLocked() {
4752 if (DEBUG_STACK) Slog.d(TAG_STACK, "removeLocked: " + this + " from display="
4753 + mActivityDisplay + " Callers=" + Debug.getCallers(2));
4754 if (mActivityDisplay != null) {
4755 removeFromDisplayLocked();
4761 * Remove the stack from its current {@link ActivityDisplay}, so it can be either destroyed
4762 * completely or re-parented.
4764 private void removeFromDisplayLocked() {
4765 if (DEBUG_STACK) Slog.d(TAG_STACK, "removeFromDisplayLocked: " + this
4766 + " current displayId=" + mActivityDisplay.mDisplayId);
4768 mActivityDisplay.detachStack(mStack);
4769 mActivityDisplay = null;
4773 * Move the stack to specified display.
4774 * @param activityDisplay Target display to move the stack to.
4775 * @param onTop Indicates whether container should be place on top or on bottom.
4777 void moveToDisplayLocked(ActivityDisplay activityDisplay, boolean onTop) {
4778 if (DEBUG_STACK) Slog.d(TAG_STACK, "moveToDisplayLocked: " + this + " from display="
4779 + mActivityDisplay + " to display=" + activityDisplay
4780 + " Callers=" + Debug.getCallers(2));
4782 removeFromDisplayLocked();
4784 mActivityDisplay = activityDisplay;
4785 mStack.reparent(activityDisplay, onTop);
4789 public final int startActivity(Intent intent) {
4790 return mService.startActivity(intent, this);
4794 public final int startActivityIntentSender(IIntentSender intentSender)
4795 throws TransactionTooLargeException {
4796 mService.enforceNotIsolatedCaller("ActivityContainer.startActivityIntentSender");
4798 if (!(intentSender instanceof PendingIntentRecord)) {
4799 throw new IllegalArgumentException("Bad PendingIntent object");
4802 final int userId = mService.mUserController.handleIncomingUser(Binder.getCallingPid(),
4803 Binder.getCallingUid(), mCurrentUser, false,
4804 ActivityManagerService.ALLOW_FULL_ONLY, "ActivityContainer", null);
4806 final PendingIntentRecord pendingIntent = (PendingIntentRecord) intentSender;
4807 checkEmbeddedAllowedInner(userId, pendingIntent.key.requestIntent,
4808 pendingIntent.key.requestResolvedType);
4810 return pendingIntent.sendInner(0, null, null, null, null, null, null, null, 0,
4811 FORCE_NEW_TASK_FLAGS, FORCE_NEW_TASK_FLAGS, null, this);
4814 void checkEmbeddedAllowedInner(int userId, Intent intent, String resolvedType) {
4815 ActivityInfo aInfo = resolveActivity(intent, resolvedType, 0, null, userId);
4816 if (aInfo != null && (aInfo.flags & ActivityInfo.FLAG_ALLOW_EMBEDDED) == 0) {
4817 throw new SecurityException(
4818 "Attempt to embed activity that has not set allowEmbedded=\"true\"");
4823 public IBinder asBinder() {
4828 public void setSurface(Surface surface, int width, int height, int density) {
4829 mService.enforceNotIsolatedCaller("ActivityContainer.attachToSurface");
4832 ActivityStackSupervisor getOuter() {
4833 return ActivityStackSupervisor.this;
4836 boolean isAttachedLocked() {
4837 return mActivityDisplay != null;
4840 // TODO: Make sure every change to ActivityRecord.visible results in a call to this.
4841 void setVisible(boolean visible) {
4842 if (mVisible != visible) {
4844 if (mCallback != null) {
4845 mHandler.obtainMessage(CONTAINER_CALLBACK_VISIBILITY, visible ? 1 : 0,
4846 0 /* unused */, this).sendToTarget();
4854 // You can always start a new task on a regular ActivityStack.
4855 boolean isEligibleForNewTasks() {
4859 void onTaskListEmptyLocked() {
4861 mHandler.obtainMessage(CONTAINER_CALLBACK_TASK_LIST_EMPTY, this).sendToTarget();
4865 public String toString() {
4866 return mIdString + (mActivityDisplay == null ? "N" : "A");
4870 private class VirtualActivityContainer extends ActivityContainer {
4872 boolean mDrawn = false;
4874 VirtualActivityContainer(ActivityRecord parent, IActivityContainerCallback callback) {
4875 super(getNextStackId(), parent.getStack().mActivityContainer.mActivityDisplay,
4877 mParentActivity = parent;
4878 mCallback = callback;
4879 mContainerState = CONTAINER_STATE_NO_SURFACE;
4880 mIdString = "VirtualActivityContainer{" + mStackId + ", parent=" + mParentActivity + "}";
4884 public void setSurface(Surface surface, int width, int height, int density) {
4885 super.setSurface(surface, width, height, density);
4887 synchronized (mService) {
4888 final long origId = Binder.clearCallingIdentity();
4890 setSurfaceLocked(surface, width, height, density);
4892 Binder.restoreCallingIdentity(origId);
4897 private void setSurfaceLocked(Surface surface, int width, int height, int density) {
4898 if (mContainerState == CONTAINER_STATE_FINISHING) {
4901 VirtualActivityDisplay virtualActivityDisplay =
4902 (VirtualActivityDisplay) mActivityDisplay;
4903 if (virtualActivityDisplay == null) {
4904 virtualActivityDisplay =
4905 new VirtualActivityDisplay(width, height, density);
4906 mActivityDisplay = virtualActivityDisplay;
4907 mActivityDisplays.put(virtualActivityDisplay.mDisplayId, virtualActivityDisplay);
4908 addToDisplayLocked(virtualActivityDisplay);
4911 if (mSurface != null) {
4916 if (surface != null) {
4917 resumeFocusedStackTopActivityLocked();
4919 mContainerState = CONTAINER_STATE_NO_SURFACE;
4920 ((VirtualActivityDisplay) mActivityDisplay).setSurface(null);
4921 if (mStack.mPausingActivity == null && mStack.mResumedActivity != null) {
4922 mStack.startPausingLocked(false, true, null, false);
4926 setSurfaceIfReadyLocked();
4928 if (DEBUG_STACK) Slog.d(TAG_STACK,
4929 "setSurface: " + this + " to display=" + virtualActivityDisplay);
4933 boolean isAttachedLocked() {
4934 return mSurface != null && super.isAttachedLocked();
4939 synchronized (mService) {
4941 setSurfaceIfReadyLocked();
4945 // Never start a new task on an ActivityView if it isn't explicitly specified.
4947 boolean isEligibleForNewTasks() {
4951 private void setSurfaceIfReadyLocked() {
4952 if (DEBUG_STACK) Slog.v(TAG_STACK, "setSurfaceIfReadyLocked: mDrawn=" + mDrawn +
4953 " mContainerState=" + mContainerState + " mSurface=" + mSurface);
4954 if (mDrawn && mSurface != null && mContainerState == CONTAINER_STATE_NO_SURFACE) {
4955 ((VirtualActivityDisplay) mActivityDisplay).setSurface(mSurface);
4956 mContainerState = CONTAINER_STATE_HAS_SURFACE;
4961 /** Exactly one of these classes per Display in the system. Capable of holding zero or more
4962 * attached {@link ActivityStack}s */
4963 class ActivityDisplay extends ConfigurationContainer {
4964 /** Actual Display this object tracks. */
4968 /** All of the stacks on this display. Order matters, topmost stack is in front of all other
4969 * stacks, bottommost behind. Accessed directly by ActivityManager package classes */
4970 final ArrayList<ActivityStack> mStacks = new ArrayList<>();
4972 ActivityRecord mVisibleBehindActivity;
4974 /** Array of all UIDs that are present on the display. */
4975 private IntArray mDisplayAccessUIDs = new IntArray();
4980 // After instantiation, check that mDisplay is not null before using this. The alternative
4981 // is for this to throw an exception if mDisplayManager.getDisplay() returns null.
4982 ActivityDisplay(int displayId) {
4983 final Display display = mDisplayManager.getDisplay(displayId);
4984 if (display == null) {
4990 void init(Display display) {
4992 mDisplayId = display.getDisplayId();
4995 void attachStack(ActivityStack stack, int position) {
4996 if (DEBUG_STACK) Slog.v(TAG_STACK, "attachStack: attaching " + stack
4997 + " to displayId=" + mDisplayId + " position=" + position);
4998 mStacks.add(position, stack);
5001 void detachStack(ActivityStack stack) {
5002 if (DEBUG_STACK) Slog.v(TAG_STACK, "detachStack: detaching " + stack
5003 + " from displayId=" + mDisplayId);
5004 mStacks.remove(stack);
5007 void setVisibleBehindActivity(ActivityRecord r) {
5008 mVisibleBehindActivity = r;
5011 boolean hasVisibleBehindActivity() {
5012 return mVisibleBehindActivity != null;
5016 public String toString() {
5017 return "ActivityDisplay={" + mDisplayId + " numStacks=" + mStacks.size() + "}";
5021 protected int getChildCount() {
5022 return mStacks.size();
5026 protected ConfigurationContainer getChildAt(int index) {
5027 return mStacks.get(index);
5031 protected ConfigurationContainer getParent() {
5032 return ActivityStackSupervisor.this;
5035 boolean isPrivate() {
5036 return (mDisplay.getFlags() & FLAG_PRIVATE) != 0;
5039 boolean isUidPresent(int uid) {
5040 for (ActivityStack stack : mStacks) {
5041 if (stack.isUidPresent(uid)) {
5048 /** Update and get all UIDs that are present on the display and have access to it. */
5049 private IntArray getPresentUIDs() {
5050 mDisplayAccessUIDs.clear();
5051 for (ActivityStack stack : mStacks) {
5052 stack.getPresentUIDs(mDisplayAccessUIDs);
5054 return mDisplayAccessUIDs;
5057 boolean shouldDestroyContentOnRemove() {
5058 return mDisplay.getRemoveMode() == REMOVE_MODE_DESTROY_CONTENT;
5062 class VirtualActivityDisplay extends ActivityDisplay {
5063 VirtualDisplay mVirtualDisplay;
5065 VirtualActivityDisplay(int width, int height, int density) {
5066 DisplayManagerGlobal dm = DisplayManagerGlobal.getInstance();
5067 mVirtualDisplay = dm.createVirtualDisplay(mService.mContext, null /* projection */,
5068 VIRTUAL_DISPLAY_BASE_NAME, width, height, density, null /* surface */,
5069 DisplayManager.VIRTUAL_DISPLAY_FLAG_PUBLIC |
5070 DisplayManager.VIRTUAL_DISPLAY_FLAG_OWN_CONTENT_ONLY, null /* callback */,
5071 null /* handler */, null /* uniqueId */);
5073 init(mVirtualDisplay.getDisplay());
5075 mWindowManager.onDisplayAdded(mDisplayId);
5078 void setSurface(Surface surface) {
5079 if (mVirtualDisplay != null) {
5080 mVirtualDisplay.setSurface(surface);
5085 void detachStack(ActivityStack stack) {
5086 super.detachStack(stack);
5087 if (mVirtualDisplay != null) {
5088 mVirtualDisplay.release();
5089 mVirtualDisplay = null;
5094 public String toString() {
5095 return "VirtualActivityDisplay={" + mDisplayId + "}";
5099 ActivityStack findStackBehind(ActivityStack stack) {
5100 // TODO(multi-display): We are only looking for stacks on the default display.
5101 final ActivityDisplay display = mActivityDisplays.get(DEFAULT_DISPLAY);
5102 if (display == null) {
5105 final ArrayList<ActivityStack> stacks = display.mStacks;
5106 for (int i = stacks.size() - 1; i >= 0; i--) {
5107 if (stacks.get(i) == stack && i > 0) {
5108 return stacks.get(i - 1);
5111 throw new IllegalStateException("Failed to find a stack behind stack=" + stack
5116 * Puts a task into resizing mode during the next app transition.
5118 * @param task The task to put into resizing mode
5120 private void setResizingDuringAnimation(TaskRecord task) {
5121 mResizingTasksDuringAnimation.add(task.taskId);
5122 task.setTaskDockedResizing(true);
5125 final int startActivityFromRecentsInner(int taskId, Bundle bOptions) {
5126 final TaskRecord task;
5127 final int callingUid;
5128 final String callingPackage;
5129 final Intent intent;
5131 final ActivityOptions activityOptions = (bOptions != null)
5132 ? new ActivityOptions(bOptions) : null;
5133 final int launchStackId = (activityOptions != null)
5134 ? activityOptions.getLaunchStackId() : INVALID_STACK_ID;
5135 if (StackId.isHomeOrRecentsStack(launchStackId)) {
5136 throw new IllegalArgumentException("startActivityFromRecentsInner: Task "
5137 + taskId + " can't be launch in the home/recents stack.");
5140 mWindowManager.deferSurfaceLayout();
5142 if (launchStackId == DOCKED_STACK_ID) {
5143 mWindowManager.setDockedStackCreateState(
5144 activityOptions.getDockCreateMode(), null /* initialBounds */);
5146 // Defer updating the stack in which recents is until the app transition is done, to
5147 // not run into issues where we still need to draw the task in recents but the
5148 // docked stack is already created.
5149 deferUpdateBounds(RECENTS_STACK_ID);
5150 mWindowManager.prepareAppTransition(TRANSIT_DOCK_TASK_FROM_RECENTS, false);
5153 task = anyTaskForIdLocked(taskId, MATCH_TASK_IN_STACKS_OR_RECENT_TASKS_AND_RESTORE,
5156 continueUpdateBounds(RECENTS_STACK_ID);
5157 mWindowManager.executeAppTransition();
5158 throw new IllegalArgumentException(
5159 "startActivityFromRecentsInner: Task " + taskId + " not found.");
5162 // Since we don't have an actual source record here, we assume that the currently
5163 // focused activity was the source.
5164 final ActivityStack focusedStack = getFocusedStack();
5165 final ActivityRecord sourceRecord =
5166 focusedStack != null ? focusedStack.topActivity() : null;
5168 if (launchStackId != INVALID_STACK_ID) {
5169 if (task.getStackId() != launchStackId) {
5170 task.reparent(launchStackId, ON_TOP, REPARENT_MOVE_STACK_TO_FRONT, ANIMATE,
5171 DEFER_RESUME, "startActivityFromRecents");
5175 // If the user must confirm credentials (e.g. when first launching a work app and the
5176 // Work Challenge is present) let startActivityInPackage handle the intercepting.
5177 if (!mService.mUserController.shouldConfirmCredentials(task.userId)
5178 && task.getRootActivity() != null) {
5179 final ActivityRecord targetActivity = task.getTopActivity();
5181 mService.mActivityStarter.sendPowerHintForLaunchStartIfNeeded(true /* forceSend */,
5183 mActivityMetricsLogger.notifyActivityLaunching();
5184 mService.moveTaskToFrontLocked(task.taskId, 0, bOptions, true /* fromRecents */);
5185 mActivityMetricsLogger.notifyActivityLaunched(ActivityManager.START_TASK_TO_FRONT,
5188 // If we are launching the task in the docked stack, put it into resizing mode so
5189 // the window renders full-screen with the background filling the void. Also only
5190 // call this at the end to make sure that tasks exists on the window manager side.
5191 if (launchStackId == DOCKED_STACK_ID) {
5192 setResizingDuringAnimation(task);
5195 mService.mActivityStarter.postStartActivityProcessing(task.getTopActivity(),
5196 ActivityManager.START_TASK_TO_FRONT,
5197 sourceRecord != null
5198 ? sourceRecord.getTask().getStackId() : INVALID_STACK_ID,
5199 sourceRecord, task.getStack());
5200 return ActivityManager.START_TASK_TO_FRONT;
5202 callingUid = task.mCallingUid;
5203 callingPackage = task.mCallingPackage;
5204 intent = task.intent;
5205 intent.addFlags(Intent.FLAG_ACTIVITY_LAUNCHED_FROM_HISTORY);
5206 userId = task.userId;
5207 int result = mService.startActivityInPackage(callingUid, callingPackage, intent, null,
5208 null, null, 0, 0, bOptions, userId, null, task, "startActivityFromRecents");
5209 if (launchStackId == DOCKED_STACK_ID) {
5210 setResizingDuringAnimation(task);
5214 mWindowManager.continueSurfaceLayout();
5219 * @return a list of activities which are the top ones in each visible stack. The first
5220 * entry will be the focused activity.
5222 List<IBinder> getTopVisibleActivities() {
5223 final ArrayList<IBinder> topActivityTokens = new ArrayList<>();
5224 // Traverse all displays.
5225 for (int i = mActivityDisplays.size() - 1; i >= 0; i--) {
5226 final ActivityDisplay display = mActivityDisplays.valueAt(i);
5227 // Traverse all stacks on a display.
5228 for (int j = display.mStacks.size() - 1; j >= 0; j--) {
5229 final ActivityStack stack = display.mStacks.get(j);
5230 // Get top activity from a visible stack and add it to the list.
5231 if (stack.shouldBeVisible(null /* starting */)
5232 == ActivityStack.STACK_VISIBLE) {
5233 final ActivityRecord top = stack.topActivity();
5235 if (stack == mFocusedStack) {
5236 topActivityTokens.add(0, top.appToken);
5238 topActivityTokens.add(top.appToken);
5244 return topActivityTokens;
5248 * Internal container to store a match qualifier alongside a WaitResult.
5250 static class WaitInfo {
5251 private final ComponentName mTargetComponent;
5252 private final WaitResult mResult;
5254 public WaitInfo(ComponentName targetComponent, WaitResult result) {
5255 this.mTargetComponent = targetComponent;
5256 this.mResult = result;
5259 public boolean matches(ComponentName targetComponent) {
5260 return mTargetComponent == null || mTargetComponent.equals(targetComponent);
5263 public WaitResult getResult() {
5267 public ComponentName getComponent() {
5268 return mTargetComponent;
5271 public void dump(PrintWriter pw, String prefix) {
5272 pw.println(prefix + "WaitInfo:");
5273 pw.println(prefix + " mTargetComponent=" + mTargetComponent);
5274 pw.println(prefix + " mResult=");
5275 mResult.dump(pw, prefix);