1 /* 2 * Copyright (C) 2013 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.android.server.am; 18 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; 49 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; 103 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; 173 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; 184 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; 194 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; 209 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; 212 213 /** How long we can hold the sleep wake lock before giving up. */ 214 static final int SLEEP_TIMEOUT = 5 * 1000; 215 216 // How long we can hold the launch wake lock before giving up. 217 static final int LAUNCH_TIMEOUT = 10 * 1000; 218 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; 235 236 private static final String VIRTUAL_DISPLAY_BASE_NAME = "ActivityViewVirtualDisplay"; 237 238 private static final String LOCK_TASK_TAG = "Lock-to-App"; 239 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; 243 244 // Used to indicate that windows of activities should be preserved during the resize. 245 static final boolean PRESERVE_WINDOWS = true; 246 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; 250 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; 254 255 // Force the focus to change to the stack we are moving a task to.. 256 static final boolean FORCE_FOCUS = true; 257 258 // Don't execute any calls to resume. 259 static final boolean DEFER_RESUME = true; 260 261 // Used to indicate that a task is removed it should also be removed from recents. 262 static final boolean REMOVE_FROM_RECENTS = true; 263 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; 267 268 /** 269 * The modes which affect which tasks are returned when calling 270 * {@link ActivityStackSupervisor#anyTaskForIdLocked(int)}. 271 */ 272 @Retention(RetentionPolicy.SOURCE) 273 @IntDef({ 274 MATCH_TASK_IN_STACKS_ONLY, 275 MATCH_TASK_IN_STACKS_OR_RECENT_TASKS, 276 MATCH_TASK_IN_STACKS_OR_RECENT_TASKS_AND_RESTORE 277 }) 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 284 // provided stack id 285 static final int MATCH_TASK_IN_STACKS_OR_RECENT_TASKS_AND_RESTORE = 2; 286 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 = 289 new ArrayMap<>(); 290 291 static { 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); 298 } 299 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; 306 307 /** Status Bar Service **/ 308 private IBinder mToken = new Binder(); 309 private IStatusBarService mStatusBarService; 310 private IDevicePolicyManager mDevicePolicyManager; 311 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; 317 318 final ActivityManagerService mService; 319 320 private RecentTasks mRecentTasks; 321 322 final ActivityStackSupervisorHandler mHandler; 323 324 /** Short cut */ 325 WindowManagerService mWindowManager; 326 DisplayManager mDisplayManager; 327 328 /** Counter for next free stack ID to use for dynamic activity stacks. */ 329 private int mNextFreeStackId = FIRST_DYNAMIC_STACK_ID; 330 331 /** 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 334 */ 335 private final SparseIntArray mCurTaskIdForUser = new SparseIntArray(20); 336 337 /** The current user */ 338 int mCurrentUser; 339 340 /** The stack containing the launcher app. Assumed to always be attached to 341 * Display.DEFAULT_DISPLAY. */ 342 ActivityStack mHomeStack; 343 344 /** The stack currently receiving input or launching the next activity. */ 345 ActivityStack mFocusedStack; 346 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; 351 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<>(); 357 358 /** List of processes waiting to find out when a specific activity becomes visible. */ 359 private final ArrayList<WaitInfo> mWaitingForActivityVisible = new ArrayList<>(); 360 361 /** List of processes waiting to find out about the next launched activity. */ 362 final ArrayList<WaitResult> mWaitingActivityLaunched = new ArrayList<>(); 363 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<>(); 367 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<>(); 371 372 /** List of activities that are in the process of going to sleep. */ 373 final ArrayList<ActivityRecord> mGoingToSleepActivities = new ArrayList<>(); 374 375 /** List of activities whose multi-window mode changed that we need to report to the 376 * application */ 377 final ArrayList<ActivityRecord> mMultiWindowModeChangedActivities = new ArrayList<>(); 378 379 /** List of activities whose picture-in-picture mode changed that we need to report to the 380 * application */ 381 final ArrayList<ActivityRecord> mPipModeChangedActivities = new ArrayList<>(); 382 383 /** The target stack bounds for the picture-in-picture mode changed that we need to report to 384 * the application */ 385 Rect mPipModeChangedTargetStackBounds; 386 387 /** Used on user changes */ 388 final ArrayList<UserState> mStartingUsers = new ArrayList<>(); 389 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; 393 394 /** Set when we have taken too long waiting to go to sleep. */ 395 boolean mSleepTimeout = false; 396 397 /** 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. 402 */ 403 PowerManager.WakeLock mLaunchingActivity; 404 405 /** 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. 409 */ 410 PowerManager.WakeLock mGoingToSleep; 411 412 /** Stack id of the front stack when user switched, indexed by userId. */ 413 SparseIntArray mUserStackInFront = new SparseIntArray(2); 414 415 // TODO: Add listener for removal of references. 416 /** Mapping from (ActivityStack/TaskStack).mStackId to their current state */ 417 SparseArray<ActivityContainer> mActivityContainers = new SparseArray<>(); 418 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<>(); 422 423 private final SparseArray<IntArray> mDisplayAccessUIDs = new SparseArray<>(); 424 425 private DisplayManagerInternal mDisplayManagerInternal; 426 private InputManagerInternal mInputManagerInternal; 427 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} 435 */ 436 private int mLockTaskModeState; 437 /** 438 * Notifies the user when entering/exiting lock-task. 439 */ 440 private LockTaskNotify mLockTaskNotify; 441 442 /** Used to keep resumeTopActivityUncheckedLocked() from being entered recursively */ 443 boolean inResumeTopActivity; 444 445 /** 446 * Temporary rect used during docked stack resize calculation so we don't need to create a new 447 * object each time. 448 */ 449 private final Rect tempRect = new Rect(); 450 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; 454 455 // Whether tasks have moved and we need to rank the tasks before next OOM scoring 456 private boolean mTaskLayersChanged = true; 457 458 final ActivityMetricsLogger mActivityMetricsLogger; 459 460 @Override 461 protected int getChildCount() { 462 return mActivityDisplays.size(); 463 } 464 465 @Override 466 protected ActivityDisplay getChildAt(int index) { 467 return mActivityDisplays.valueAt(index); 468 } 469 470 @Override 471 protected ConfigurationContainer getParent() { 472 return null; 473 } 474 475 Configuration getDisplayOverrideConfiguration(int displayId) { 476 final ActivityDisplay activityDisplay = getActivityDisplayOrCreateLocked(displayId); 477 if (activityDisplay == null) { 478 throw new IllegalArgumentException("No display found with id: " + displayId); 479 } 480 481 return activityDisplay.getOverrideConfiguration(); 482 } 483 484 void setDisplayOverrideConfiguration(Configuration overrideConfiguration, int displayId) { 485 final ActivityDisplay activityDisplay = getActivityDisplayOrCreateLocked(displayId); 486 if (activityDisplay == null) { 487 throw new IllegalArgumentException("No display found with id: " + displayId); 488 } 489 490 activityDisplay.onOverrideConfigurationChanged(overrideConfiguration); 491 } 492 493 /** Check if placing task or activity on specified display is allowed. */ 494 boolean canPlaceEntityOnDisplay(int displayId, boolean resizeable) { 495 return displayId == DEFAULT_DISPLAY || (mService.mSupportsMultiDisplay 496 && (resizeable || displayConfigMatchesGlobal(displayId))); 497 } 498 499 /** 500 * Check if configuration of specified display matches current global config. 501 * Used to check if we can put a non-resizeable activity on a secondary display and it will get 502 * the same config as on the default display. 503 * @param displayId Id of the display to check. 504 * @return {@code true} if configuration matches. 505 */ 506 private boolean displayConfigMatchesGlobal(int displayId) { 507 if (displayId == DEFAULT_DISPLAY) { 508 return true; 509 } 510 if (displayId == INVALID_DISPLAY) { 511 return false; 512 } 513 final ActivityDisplay targetDisplay = getActivityDisplayOrCreateLocked(displayId); 514 if (targetDisplay == null) { 515 throw new IllegalArgumentException("No display found with id: " + displayId); 516 } 517 return getConfiguration().equals(targetDisplay.getConfiguration()); 518 } 519 520 static class FindTaskResult { 521 ActivityRecord r; 522 boolean matchedByRootAffinity; 523 } 524 private final FindTaskResult mTmpFindTaskResult = new FindTaskResult(); 525 526 /** 527 * Temp storage for display ids sorted in focus order. 528 * Maps position to id. Using {@link SparseIntArray} instead of {@link ArrayList} because 529 * it's more efficient, as the number of displays is usually small. 530 */ 531 private SparseIntArray mTmpOrderedDisplayIds = new SparseIntArray(); 532 533 /** 534 * Used to keep track whether app visibilities got changed since the last pause. Useful to 535 * determine whether to invoke the task stack change listener after pausing. 536 */ 537 boolean mAppVisibilitiesChangedSinceLastPause; 538 539 /** 540 * Set of tasks that are in resizing mode during an app transition to fill the "void". 541 */ 542 private final ArraySet<Integer> mResizingTasksDuringAnimation = new ArraySet<>(); 543 544 545 /** 546 * If set to {@code false} all calls to resize the docked stack {@link #resizeDockedStackLocked} 547 * will be ignored. Useful for the case where the caller is handling resizing of other stack and 548 * moving tasks around and doesn't want dock stack to be resized due to an automatic trigger 549 * like the docked stack going empty. 550 */ 551 private boolean mAllowDockedStackResize = true; 552 553 /** 554 * Is dock currently minimized. 555 */ 556 boolean mIsDockMinimized; 557 558 final KeyguardController mKeyguardController; 559 560 /** 561 * Description of a request to start a new activity, which has been held 562 * due to app switches being disabled. 563 */ 564 static class PendingActivityLaunch { 565 final ActivityRecord r; 566 final ActivityRecord sourceRecord; 567 final int startFlags; 568 final ActivityStack stack; 569 final ProcessRecord callerApp; 570 571 PendingActivityLaunch(ActivityRecord _r, ActivityRecord _sourceRecord, 572 int _startFlags, ActivityStack _stack, ProcessRecord _callerApp) { 573 r = _r; 574 sourceRecord = _sourceRecord; 575 startFlags = _startFlags; 576 stack = _stack; 577 callerApp = _callerApp; 578 } 579 580 void sendErrorResult(String message) { 581 try { 582 if (callerApp.thread != null) { 583 callerApp.thread.scheduleCrash(message); 584 } 585 } catch (RemoteException e) { 586 Slog.e(TAG, "Exception scheduling crash of failed " 587 + "activity launcher sourceRecord=" + sourceRecord, e); 588 } 589 } 590 } 591 592 public ActivityStackSupervisor(ActivityManagerService service, Looper looper) { 593 mService = service; 594 mHandler = new ActivityStackSupervisorHandler(looper); 595 mActivityMetricsLogger = new ActivityMetricsLogger(this, mService.mContext); 596 mKeyguardController = new KeyguardController(service, this); 597 } 598 599 void setRecentTasks(RecentTasks recentTasks) { 600 mRecentTasks = recentTasks; 601 } 602 603 /** 604 * At the time when the constructor runs, the power manager has not yet been 605 * initialized. So we initialize our wakelocks afterwards. 606 */ 607 void initPowerManagement() { 608 PowerManager pm = (PowerManager)mService.mContext.getSystemService(Context.POWER_SERVICE); 609 mGoingToSleep = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "ActivityManager-Sleep"); 610 mLaunchingActivity = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "*launch*"); 611 mLaunchingActivity.setReferenceCounted(false); 612 } 613 614 // This function returns a IStatusBarService. The value is from ServiceManager. 615 // getService and is cached. 616 private IStatusBarService getStatusBarService() { 617 synchronized (mService) { 618 if (mStatusBarService == null) { 619 mStatusBarService = IStatusBarService.Stub.asInterface( 620 ServiceManager.checkService(Context.STATUS_BAR_SERVICE)); 621 if (mStatusBarService == null) { 622 Slog.w("StatusBarManager", "warning: no STATUS_BAR_SERVICE"); 623 } 624 } 625 return mStatusBarService; 626 } 627 } 628 629 private IDevicePolicyManager getDevicePolicyManager() { 630 synchronized (mService) { 631 if (mDevicePolicyManager == null) { 632 mDevicePolicyManager = IDevicePolicyManager.Stub.asInterface( 633 ServiceManager.checkService(Context.DEVICE_POLICY_SERVICE)); 634 if (mDevicePolicyManager == null) { 635 Slog.w(TAG, "warning: no DEVICE_POLICY_SERVICE"); 636 } 637 } 638 return mDevicePolicyManager; 639 } 640 } 641 642 void setWindowManager(WindowManagerService wm) { 643 synchronized (mService) { 644 mWindowManager = wm; 645 mKeyguardController.setWindowManager(wm); 646 647 mDisplayManager = 648 (DisplayManager)mService.mContext.getSystemService(Context.DISPLAY_SERVICE); 649 mDisplayManager.registerDisplayListener(this, null); 650 mDisplayManagerInternal = LocalServices.getService(DisplayManagerInternal.class); 651 652 Display[] displays = mDisplayManager.getDisplays(); 653 for (int displayNdx = displays.length - 1; displayNdx >= 0; --displayNdx) { 654 final int displayId = displays[displayNdx].getDisplayId(); 655 ActivityDisplay activityDisplay = new ActivityDisplay(displayId); 656 if (activityDisplay.mDisplay == null) { 657 throw new IllegalStateException("Default Display does not exist"); 658 } 659 mActivityDisplays.put(displayId, activityDisplay); 660 calculateDefaultMinimalSizeOfResizeableTasks(activityDisplay); 661 } 662 663 mHomeStack = mFocusedStack = mLastFocusedStack = 664 getStack(HOME_STACK_ID, CREATE_IF_NEEDED, ON_TOP); 665 666 mInputManagerInternal = LocalServices.getService(InputManagerInternal.class); 667 } 668 } 669 670 ActivityStack getFocusedStack() { 671 return mFocusedStack; 672 } 673 674 ActivityStack getLastStack() { 675 return mLastFocusedStack; 676 } 677 678 boolean isFocusedStack(ActivityStack stack) { 679 if (stack == null) { 680 return false; 681 } 682 683 final ActivityRecord parent = stack.mActivityContainer.mParentActivity; 684 if (parent != null) { 685 stack = parent.getStack(); 686 } 687 return stack == mFocusedStack; 688 } 689 690 /** The top most stack on its display. */ 691 boolean isFrontStackOnDisplay(ActivityStack stack) { 692 return isFrontOfStackList(stack, stack.mActivityContainer.mActivityDisplay.mStacks); 693 } 694 695 private boolean isFrontOfStackList(ActivityStack stack, List<ActivityStack> stackList) { 696 if (stack == null) { 697 return false; 698 } 699 700 final ActivityRecord parent = stack.mActivityContainer.mParentActivity; 701 if (parent != null) { 702 stack = parent.getStack(); 703 } 704 return stack == stackList.get((stackList.size() - 1)); 705 } 706 707 /** NOTE: Should only be called from {@link ActivityStack#moveToFront} */ 708 void setFocusStackUnchecked(String reason, ActivityStack focusCandidate) { 709 if (!focusCandidate.isFocusable()) { 710 // The focus candidate isn't focusable. Move focus to the top stack that is focusable. 711 focusCandidate = getNextFocusableStackLocked(focusCandidate); 712 } 713 714 if (focusCandidate != mFocusedStack) { 715 mLastFocusedStack = mFocusedStack; 716 mFocusedStack = focusCandidate; 717 718 EventLogTags.writeAmFocusedStack( 719 mCurrentUser, mFocusedStack == null ? -1 : mFocusedStack.getStackId(), 720 mLastFocusedStack == null ? -1 : mLastFocusedStack.getStackId(), reason); 721 } 722 723 final ActivityRecord r = topRunningActivityLocked(); 724 if (mService.mBooting || !mService.mBooted) { 725 if (r != null && r.idle) { 726 checkFinishBootingLocked(); 727 } 728 } 729 } 730 731 void moveHomeStackToFront(String reason) { 732 mHomeStack.moveToFront(reason); 733 } 734 735 void moveRecentsStackToFront(String reason) { 736 final ActivityStack recentsStack = getStack(RECENTS_STACK_ID); 737 if (recentsStack != null) { 738 recentsStack.moveToFront(reason); 739 } 740 } 741 742 /** Returns true if the focus activity was adjusted to the home stack top activity. */ 743 boolean moveHomeStackTaskToTop(String reason) { 744 mHomeStack.moveHomeStackTaskToTop(); 745 746 final ActivityRecord top = getHomeActivity(); 747 if (top == null) { 748 return false; 749 } 750 moveFocusableActivityStackToFrontLocked(top, reason); 751 return true; 752 } 753 754 boolean resumeHomeStackTask(ActivityRecord prev, String reason) { 755 if (!mService.mBooting && !mService.mBooted) { 756 // Not ready yet! 757 return false; 758 } 759 760 if (prev != null) { 761 prev.getTask().setTaskToReturnTo(APPLICATION_ACTIVITY_TYPE); 762 } 763 764 mHomeStack.moveHomeStackTaskToTop(); 765 ActivityRecord r = getHomeActivity(); 766 final String myReason = reason + " resumeHomeStackTask"; 767 768 // Only resume home activity if isn't finishing. 769 if (r != null && !r.finishing) { 770 moveFocusableActivityStackToFrontLocked(r, myReason); 771 return resumeFocusedStackTopActivityLocked(mHomeStack, prev, null); 772 } 773 return mService.startHomeActivityLocked(mCurrentUser, myReason); 774 } 775 776 TaskRecord anyTaskForIdLocked(int id) { 777 return anyTaskForIdLocked(id, MATCH_TASK_IN_STACKS_OR_RECENT_TASKS_AND_RESTORE, 778 INVALID_STACK_ID); 779 } 780 781 /** 782 * Returns a {@link TaskRecord} for the input id if available. {@code null} otherwise. 783 * @param id Id of the task we would like returned. 784 * @param matchMode The mode to match the given task id in. 785 * @param stackId The stack to restore the task to (default launch stack will be used if 786 * stackId is {@link android.app.ActivityManager.StackId#INVALID_STACK_ID}). Only 787 * valid if the matchMode is 788 * {@link #MATCH_TASK_IN_STACKS_OR_RECENT_TASKS_AND_RESTORE}. 789 */ 790 TaskRecord anyTaskForIdLocked(int id, @AnyTaskForIdMatchTaskMode int matchMode, int stackId) { 791 // If there is a stack id set, ensure that we are attempting to actually restore a task 792 if (matchMode != MATCH_TASK_IN_STACKS_OR_RECENT_TASKS_AND_RESTORE && 793 stackId != INVALID_STACK_ID) { 794 throw new IllegalArgumentException("Should not specify stackId for non-restore lookup"); 795 } 796 797 int numDisplays = mActivityDisplays.size(); 798 for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) { 799 ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 800 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 801 ActivityStack stack = stacks.get(stackNdx); 802 final TaskRecord task = stack.taskForIdLocked(id); 803 if (task != null) { 804 return task; 805 } 806 } 807 } 808 809 // If we are matching stack tasks only, return now 810 if (matchMode == MATCH_TASK_IN_STACKS_ONLY) { 811 return null; 812 } 813 814 // Otherwise, check the recent tasks and return if we find it there and we are not restoring 815 // the task from recents 816 if (DEBUG_RECENTS) Slog.v(TAG_RECENTS, "Looking for task id=" + id + " in recents"); 817 final TaskRecord task = mRecentTasks.taskForIdLocked(id); 818 819 if (task == null) { 820 if (DEBUG_RECENTS) { 821 Slog.d(TAG_RECENTS, "\tDidn't find task id=" + id + " in recents"); 822 } 823 824 return null; 825 } 826 827 if (matchMode == MATCH_TASK_IN_STACKS_OR_RECENT_TASKS) { 828 return task; 829 } 830 831 // Implicitly, this case is MATCH_TASK_IN_STACKS_OR_RECENT_TASKS_AND_RESTORE 832 if (!restoreRecentTaskLocked(task, stackId)) { 833 if (DEBUG_RECENTS) Slog.w(TAG_RECENTS, 834 "Couldn't restore task id=" + id + " found in recents"); 835 return null; 836 } 837 if (DEBUG_RECENTS) Slog.w(TAG_RECENTS, "Restored task id=" + id + " from in recents"); 838 return task; 839 } 840 841 ActivityRecord isInAnyStackLocked(IBinder token) { 842 int numDisplays = mActivityDisplays.size(); 843 for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) { 844 ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 845 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 846 final ActivityRecord r = stacks.get(stackNdx).isInStackLocked(token); 847 if (r != null) { 848 return r; 849 } 850 } 851 } 852 return null; 853 } 854 855 /** 856 * Detects whether we should show a lock screen in front of this task for a locked user. 857 * <p> 858 * We'll do this if either of the following holds: 859 * <ul> 860 * <li>The top activity explicitly belongs to {@param userId}.</li> 861 * <li>The top activity returns a result to an activity belonging to {@param userId}.</li> 862 * </ul> 863 * 864 * @return {@code true} if the top activity looks like it belongs to {@param userId}. 865 */ 866 private boolean taskTopActivityIsUser(TaskRecord task, @UserIdInt int userId) { 867 // To handle the case that work app is in the task but just is not the top one. 868 final ActivityRecord activityRecord = task.getTopActivity(); 869 final ActivityRecord resultTo = (activityRecord != null ? activityRecord.resultTo : null); 870 871 return (activityRecord != null && activityRecord.userId == userId) 872 || (resultTo != null && resultTo.userId == userId); 873 } 874 875 /** 876 * Find all visible task stacks containing {@param userId} and intercept them with an activity 877 * to block out the contents and possibly start a credential-confirming intent. 878 * 879 * @param userId user handle for the locked managed profile. 880 */ 881 void lockAllProfileTasks(@UserIdInt int userId) { 882 mWindowManager.deferSurfaceLayout(); 883 try { 884 final List<ActivityStack> stacks = getStacks(); 885 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; stackNdx--) { 886 final List<TaskRecord> tasks = stacks.get(stackNdx).getAllTasks(); 887 for (int taskNdx = tasks.size() - 1; taskNdx >= 0; taskNdx--) { 888 final TaskRecord task = tasks.get(taskNdx); 889 890 // Check the task for a top activity belonging to userId, or returning a result 891 // to an activity belonging to userId. Example case: a document picker for 892 // personal files, opened by a work app, should still get locked. 893 if (taskTopActivityIsUser(task, userId)) { 894 mService.mTaskChangeNotificationController.notifyTaskProfileLocked( 895 task.taskId, userId); 896 } 897 } 898 } 899 } finally { 900 mWindowManager.continueSurfaceLayout(); 901 } 902 } 903 904 void setNextTaskIdForUserLocked(int taskId, int userId) { 905 final int currentTaskId = mCurTaskIdForUser.get(userId, -1); 906 if (taskId > currentTaskId) { 907 mCurTaskIdForUser.put(userId, taskId); 908 } 909 } 910 911 static int nextTaskIdForUser(int taskId, int userId) { 912 int nextTaskId = taskId + 1; 913 if (nextTaskId == (userId + 1) * MAX_TASK_IDS_PER_USER) { 914 // Wrap around as there will be smaller task ids that are available now. 915 nextTaskId -= MAX_TASK_IDS_PER_USER; 916 } 917 return nextTaskId; 918 } 919 920 int getNextTaskIdForUserLocked(int userId) { 921 final int currentTaskId = mCurTaskIdForUser.get(userId, userId * MAX_TASK_IDS_PER_USER); 922 // for a userId u, a taskId can only be in the range 923 // [u*MAX_TASK_IDS_PER_USER, (u+1)*MAX_TASK_IDS_PER_USER-1], so if MAX_TASK_IDS_PER_USER 924 // was 10, user 0 could only have taskIds 0 to 9, user 1: 10 to 19, user 2: 20 to 29, so on. 925 int candidateTaskId = nextTaskIdForUser(currentTaskId, userId); 926 while (mRecentTasks.taskIdTakenForUserLocked(candidateTaskId, userId) 927 || anyTaskForIdLocked(candidateTaskId, MATCH_TASK_IN_STACKS_OR_RECENT_TASKS, 928 INVALID_STACK_ID) != null) { 929 candidateTaskId = nextTaskIdForUser(candidateTaskId, userId); 930 if (candidateTaskId == currentTaskId) { 931 // Something wrong! 932 // All MAX_TASK_IDS_PER_USER task ids are taken up by running tasks for this user 933 throw new IllegalStateException("Cannot get an available task id." 934 + " Reached limit of " + MAX_TASK_IDS_PER_USER 935 + " running tasks per user."); 936 } 937 } 938 mCurTaskIdForUser.put(userId, candidateTaskId); 939 return candidateTaskId; 940 } 941 942 ActivityRecord getResumedActivityLocked() { 943 ActivityStack stack = mFocusedStack; 944 if (stack == null) { 945 return null; 946 } 947 ActivityRecord resumedActivity = stack.mResumedActivity; 948 if (resumedActivity == null || resumedActivity.app == null) { 949 resumedActivity = stack.mPausingActivity; 950 if (resumedActivity == null || resumedActivity.app == null) { 951 resumedActivity = stack.topRunningActivityLocked(); 952 } 953 } 954 return resumedActivity; 955 } 956 957 boolean attachApplicationLocked(ProcessRecord app) throws RemoteException { 958 final String processName = app.processName; 959 boolean didSomething = false; 960 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 961 ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 962 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 963 final ActivityStack stack = stacks.get(stackNdx); 964 if (!isFocusedStack(stack)) { 965 continue; 966 } 967 ActivityRecord hr = stack.topRunningActivityLocked(); 968 if (hr != null) { 969 if (hr.app == null && app.uid == hr.info.applicationInfo.uid 970 && processName.equals(hr.processName)) { 971 try { 972 if (realStartActivityLocked(hr, app, true, true)) { 973 didSomething = true; 974 } 975 } catch (RemoteException e) { 976 Slog.w(TAG, "Exception in new application when starting activity " 977 + hr.intent.getComponent().flattenToShortString(), e); 978 throw e; 979 } 980 } 981 } 982 } 983 } 984 if (!didSomething) { 985 ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS); 986 } 987 return didSomething; 988 } 989 990 boolean allResumedActivitiesIdle() { 991 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 992 ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 993 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 994 final ActivityStack stack = stacks.get(stackNdx); 995 if (!isFocusedStack(stack) || stack.numActivities() == 0) { 996 continue; 997 } 998 final ActivityRecord resumedActivity = stack.mResumedActivity; 999 if (resumedActivity == null || !resumedActivity.idle) { 1000 if (DEBUG_STATES) Slog.d(TAG_STATES, "allResumedActivitiesIdle: stack=" 1001 + stack.mStackId + " " + resumedActivity + " not idle"); 1002 return false; 1003 } 1004 } 1005 } 1006 // Send launch end powerhint when idle 1007 mService.mActivityStarter.sendPowerHintForLaunchEndIfNeeded(); 1008 return true; 1009 } 1010 1011 boolean allResumedActivitiesComplete() { 1012 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 1013 ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 1014 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 1015 final ActivityStack stack = stacks.get(stackNdx); 1016 if (isFocusedStack(stack)) { 1017 final ActivityRecord r = stack.mResumedActivity; 1018 if (r != null && r.state != RESUMED) { 1019 return false; 1020 } 1021 } 1022 } 1023 } 1024 // TODO: Not sure if this should check if all Paused are complete too. 1025 if (DEBUG_STACK) Slog.d(TAG_STACK, 1026 "allResumedActivitiesComplete: mLastFocusedStack changing from=" + 1027 mLastFocusedStack + " to=" + mFocusedStack); 1028 mLastFocusedStack = mFocusedStack; 1029 return true; 1030 } 1031 1032 boolean allResumedActivitiesVisible() { 1033 boolean foundResumed = false; 1034 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 1035 ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 1036 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 1037 final ActivityStack stack = stacks.get(stackNdx); 1038 final ActivityRecord r = stack.mResumedActivity; 1039 if (r != null) { 1040 if (!r.nowVisible || mActivitiesWaitingForVisibleActivity.contains(r)) { 1041 return false; 1042 } 1043 foundResumed = true; 1044 } 1045 } 1046 } 1047 return foundResumed; 1048 } 1049 1050 /** 1051 * Pause all activities in either all of the stacks or just the back stacks. 1052 * @param userLeaving Passed to pauseActivity() to indicate whether to call onUserLeaving(). 1053 * @param resuming The resuming activity. 1054 * @param dontWait The resuming activity isn't going to wait for all activities to be paused 1055 * before resuming. 1056 * @return true if any activity was paused as a result of this call. 1057 */ 1058 boolean pauseBackStacks(boolean userLeaving, ActivityRecord resuming, boolean dontWait) { 1059 boolean someActivityPaused = false; 1060 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 1061 ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 1062 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 1063 final ActivityStack stack = stacks.get(stackNdx); 1064 if (!isFocusedStack(stack) && stack.mResumedActivity != null) { 1065 if (DEBUG_STATES) Slog.d(TAG_STATES, "pauseBackStacks: stack=" + stack + 1066 " mResumedActivity=" + stack.mResumedActivity); 1067 someActivityPaused |= stack.startPausingLocked(userLeaving, false, resuming, 1068 dontWait); 1069 } 1070 } 1071 } 1072 return someActivityPaused; 1073 } 1074 1075 boolean allPausedActivitiesComplete() { 1076 boolean pausing = true; 1077 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 1078 ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 1079 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 1080 final ActivityStack stack = stacks.get(stackNdx); 1081 final ActivityRecord r = stack.mPausingActivity; 1082 if (r != null && r.state != PAUSED && r.state != STOPPED && r.state != STOPPING) { 1083 if (DEBUG_STATES) { 1084 Slog.d(TAG_STATES, 1085 "allPausedActivitiesComplete: r=" + r + " state=" + r.state); 1086 pausing = false; 1087 } else { 1088 return false; 1089 } 1090 } 1091 } 1092 } 1093 return pausing; 1094 } 1095 1096 void pauseChildStacks(ActivityRecord parent, boolean userLeaving, boolean uiSleeping, 1097 ActivityRecord resuming, boolean dontWait) { 1098 // TODO: Put all stacks in supervisor and iterate through them instead. 1099 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 1100 ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 1101 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 1102 final ActivityStack stack = stacks.get(stackNdx); 1103 if (stack.mResumedActivity != null && 1104 stack.mActivityContainer.mParentActivity == parent) { 1105 stack.startPausingLocked(userLeaving, uiSleeping, resuming, dontWait); 1106 } 1107 } 1108 } 1109 } 1110 1111 void cancelInitializingActivities() { 1112 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 1113 ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 1114 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 1115 stacks.get(stackNdx).cancelInitializingActivities(); 1116 } 1117 } 1118 } 1119 1120 void waitActivityVisible(ComponentName name, WaitResult result) { 1121 final WaitInfo waitInfo = new WaitInfo(name, result); 1122 mWaitingForActivityVisible.add(waitInfo); 1123 } 1124 1125 void cleanupActivity(ActivityRecord r) { 1126 // Make sure this record is no longer in the pending finishes list. 1127 // This could happen, for example, if we are trimming activities 1128 // down to the max limit while they are still waiting to finish. 1129 mFinishingActivities.remove(r); 1130 mActivitiesWaitingForVisibleActivity.remove(r); 1131 1132 for (int i = mWaitingForActivityVisible.size() - 1; i >= 0; --i) { 1133 if (mWaitingForActivityVisible.get(i).matches(r.realActivity)) { 1134 mWaitingForActivityVisible.remove(i); 1135 } 1136 } 1137 } 1138 1139 void reportActivityVisibleLocked(ActivityRecord r) { 1140 sendWaitingVisibleReportLocked(r); 1141 } 1142 1143 void sendWaitingVisibleReportLocked(ActivityRecord r) { 1144 boolean changed = false; 1145 for (int i = mWaitingForActivityVisible.size() - 1; i >= 0; --i) { 1146 final WaitInfo w = mWaitingForActivityVisible.get(i); 1147 if (w.matches(r.realActivity)) { 1148 final WaitResult result = w.getResult(); 1149 changed = true; 1150 result.timeout = false; 1151 result.who = w.getComponent(); 1152 result.totalTime = SystemClock.uptimeMillis() - result.thisTime; 1153 result.thisTime = result.totalTime; 1154 mWaitingForActivityVisible.remove(w); 1155 } 1156 } 1157 if (changed) { 1158 mService.notifyAll(); 1159 } 1160 } 1161 1162 void reportTaskToFrontNoLaunch(ActivityRecord r) { 1163 boolean changed = false; 1164 for (int i = mWaitingActivityLaunched.size() - 1; i >= 0; i--) { 1165 WaitResult w = mWaitingActivityLaunched.remove(i); 1166 if (w.who == null) { 1167 changed = true; 1168 // Set result to START_TASK_TO_FRONT so that startActivityMayWait() knows that 1169 // the starting activity ends up moving another activity to front, and it should 1170 // wait for this new activity to become visible instead. 1171 // Do not modify other fields. 1172 w.result = START_TASK_TO_FRONT; 1173 } 1174 } 1175 if (changed) { 1176 mService.notifyAll(); 1177 } 1178 } 1179 1180 void reportActivityLaunchedLocked(boolean timeout, ActivityRecord r, 1181 long thisTime, long totalTime) { 1182 boolean changed = false; 1183 for (int i = mWaitingActivityLaunched.size() - 1; i >= 0; i--) { 1184 WaitResult w = mWaitingActivityLaunched.remove(i); 1185 if (w.who == null) { 1186 changed = true; 1187 w.timeout = timeout; 1188 if (r != null) { 1189 w.who = new ComponentName(r.info.packageName, r.info.name); 1190 } 1191 w.thisTime = thisTime; 1192 w.totalTime = totalTime; 1193 // Do not modify w.result. 1194 } 1195 } 1196 if (changed) { 1197 mService.notifyAll(); 1198 } 1199 } 1200 1201 ActivityRecord topRunningActivityLocked() { 1202 final ActivityStack focusedStack = mFocusedStack; 1203 ActivityRecord r = focusedStack.topRunningActivityLocked(); 1204 if (r != null) { 1205 return r; 1206 } 1207 1208 // Look in other non-focused and non-home stacks. 1209 mWindowManager.getDisplaysInFocusOrder(mTmpOrderedDisplayIds); 1210 1211 for (int i = mTmpOrderedDisplayIds.size() - 1; i >= 0; --i) { 1212 final int displayId = mTmpOrderedDisplayIds.get(i); 1213 final List<ActivityStack> stacks = mActivityDisplays.get(displayId).mStacks; 1214 if (stacks == null) { 1215 continue; 1216 } 1217 for (int j = stacks.size() - 1; j >= 0; --j) { 1218 final ActivityStack stack = stacks.get(j); 1219 if (stack != focusedStack && isFrontStackOnDisplay(stack) && stack.isFocusable()) { 1220 r = stack.topRunningActivityLocked(); 1221 if (r != null) { 1222 return r; 1223 } 1224 } 1225 } 1226 } 1227 return null; 1228 } 1229 1230 void getTasksLocked(int maxNum, List<RunningTaskInfo> list, int callingUid, boolean allowed) { 1231 // Gather all of the running tasks for each stack into runningTaskLists. 1232 ArrayList<ArrayList<RunningTaskInfo>> runningTaskLists = 1233 new ArrayList<ArrayList<RunningTaskInfo>>(); 1234 final int numDisplays = mActivityDisplays.size(); 1235 for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) { 1236 ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 1237 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 1238 final ActivityStack stack = stacks.get(stackNdx); 1239 ArrayList<RunningTaskInfo> stackTaskList = new ArrayList<>(); 1240 runningTaskLists.add(stackTaskList); 1241 stack.getTasksLocked(stackTaskList, callingUid, allowed); 1242 } 1243 } 1244 1245 // The lists are already sorted from most recent to oldest. Just pull the most recent off 1246 // each list and add it to list. Stop when all lists are empty or maxNum reached. 1247 while (maxNum > 0) { 1248 long mostRecentActiveTime = Long.MIN_VALUE; 1249 ArrayList<RunningTaskInfo> selectedStackList = null; 1250 final int numTaskLists = runningTaskLists.size(); 1251 for (int stackNdx = 0; stackNdx < numTaskLists; ++stackNdx) { 1252 ArrayList<RunningTaskInfo> stackTaskList = runningTaskLists.get(stackNdx); 1253 if (!stackTaskList.isEmpty()) { 1254 final long lastActiveTime = stackTaskList.get(0).lastActiveTime; 1255 if (lastActiveTime > mostRecentActiveTime) { 1256 mostRecentActiveTime = lastActiveTime; 1257 selectedStackList = stackTaskList; 1258 } 1259 } 1260 } 1261 if (selectedStackList != null) { 1262 list.add(selectedStackList.remove(0)); 1263 --maxNum; 1264 } else { 1265 break; 1266 } 1267 } 1268 } 1269 1270 ActivityInfo resolveActivity(Intent intent, ResolveInfo rInfo, int startFlags, 1271 ProfilerInfo profilerInfo) { 1272 final ActivityInfo aInfo = rInfo != null ? rInfo.activityInfo : null; 1273 if (aInfo != null) { 1274 // Store the found target back into the intent, because now that 1275 // we have it we never want to do this again. For example, if the 1276 // user navigates back to this point in the history, we should 1277 // always restart the exact same activity. 1278 intent.setComponent(new ComponentName( 1279 aInfo.applicationInfo.packageName, aInfo.name)); 1280 1281 // Don't debug things in the system process 1282 if (!aInfo.processName.equals("system")) { 1283 if ((startFlags & ActivityManager.START_FLAG_DEBUG) != 0) { 1284 mService.setDebugApp(aInfo.processName, true, false); 1285 } 1286 1287 if ((startFlags & ActivityManager.START_FLAG_NATIVE_DEBUGGING) != 0) { 1288 mService.setNativeDebuggingAppLocked(aInfo.applicationInfo, aInfo.processName); 1289 } 1290 1291 if ((startFlags & ActivityManager.START_FLAG_TRACK_ALLOCATION) != 0) { 1292 mService.setTrackAllocationApp(aInfo.applicationInfo, aInfo.processName); 1293 } 1294 1295 if (profilerInfo != null) { 1296 mService.setProfileApp(aInfo.applicationInfo, aInfo.processName, profilerInfo); 1297 } 1298 } 1299 final String intentLaunchToken = intent.getLaunchToken(); 1300 if (aInfo.launchToken == null && intentLaunchToken != null) { 1301 aInfo.launchToken = intentLaunchToken; 1302 } 1303 } 1304 return aInfo; 1305 } 1306 1307 ResolveInfo resolveIntent(Intent intent, String resolvedType, int userId) { 1308 return resolveIntent(intent, resolvedType, userId, 0); 1309 } 1310 1311 ResolveInfo resolveIntent(Intent intent, String resolvedType, int userId, int flags) { 1312 synchronized (mService) { 1313 return mService.getPackageManagerInternalLocked().resolveIntent(intent, resolvedType, 1314 PackageManager.MATCH_INSTANT | PackageManager.MATCH_DEFAULT_ONLY | flags 1315 | ActivityManagerService.STOCK_PM_FLAGS, userId); 1316 } 1317 } 1318 1319 ActivityInfo resolveActivity(Intent intent, String resolvedType, int startFlags, 1320 ProfilerInfo profilerInfo, int userId) { 1321 final ResolveInfo rInfo = resolveIntent(intent, resolvedType, userId); 1322 return resolveActivity(intent, rInfo, startFlags, profilerInfo); 1323 } 1324 1325 final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app, 1326 boolean andResume, boolean checkConfig) throws RemoteException { 1327 1328 if (!allPausedActivitiesComplete()) { 1329 // While there are activities pausing we skipping starting any new activities until 1330 // pauses are complete. NOTE: that we also do this for activities that are starting in 1331 // the paused state because they will first be resumed then paused on the client side. 1332 if (DEBUG_SWITCH || DEBUG_PAUSE || DEBUG_STATES) Slog.v(TAG_PAUSE, 1333 "realStartActivityLocked: Skipping start of r=" + r 1334 + " some activities pausing..."); 1335 return false; 1336 } 1337 1338 r.startFreezingScreenLocked(app, 0); 1339 if (r.getStack().checkKeyguardVisibility(r, true /* shouldBeVisible */, true /* isTop */)) { 1340 // We only set the visibility to true if the activity is allowed to be visible based on 1341 // keyguard state. This avoids setting this into motion in window manager that is later 1342 // cancelled due to later calls to ensure visible activities that set visibility back to 1343 // false. 1344 r.setVisibility(true); 1345 } 1346 1347 // schedule launch ticks to collect information about slow apps. 1348 r.startLaunchTickingLocked(); 1349 1350 // Have the window manager re-evaluate the orientation of the screen based on the new 1351 // activity order. Note that as a result of this, it can call back into the activity 1352 // manager with a new orientation. We don't care about that, because the activity is not 1353 // currently running so we are just restarting it anyway. 1354 if (checkConfig) { 1355 final int displayId = r.getDisplayId(); 1356 final Configuration config = mWindowManager.updateOrientationFromAppTokens( 1357 getDisplayOverrideConfiguration(displayId), 1358 r.mayFreezeScreenLocked(app) ? r.appToken : null, displayId); 1359 // Deferring resume here because we're going to launch new activity shortly. 1360 // We don't want to perform a redundant launch of the same record while ensuring 1361 // configurations and trying to resume top activity of focused stack. 1362 mService.updateDisplayOverrideConfigurationLocked(config, r, true /* deferResume */, 1363 displayId); 1364 } 1365 1366 if (mKeyguardController.isKeyguardLocked()) { 1367 r.notifyUnknownVisibilityLaunched(); 1368 } 1369 final int applicationInfoUid = 1370 (r.info.applicationInfo != null) ? r.info.applicationInfo.uid : -1; 1371 if ((r.userId != app.userId) || (r.appInfo.uid != applicationInfoUid)) { 1372 Slog.wtf(TAG, 1373 "User ID for activity changing for " + r 1374 + " appInfo.uid=" + r.appInfo.uid 1375 + " info.ai.uid=" + applicationInfoUid 1376 + " old=" + r.app + " new=" + app); 1377 } 1378 1379 r.app = app; 1380 app.waitingToKill = null; 1381 r.launchCount++; 1382 r.lastLaunchTime = SystemClock.uptimeMillis(); 1383 1384 if (DEBUG_ALL) Slog.v(TAG, "Launching: " + r); 1385 1386 int idx = app.activities.indexOf(r); 1387 if (idx < 0) { 1388 app.activities.add(r); 1389 } 1390 mService.updateLruProcessLocked(app, true, null); 1391 mService.updateOomAdjLocked(); 1392 1393 final TaskRecord task = r.getTask(); 1394 if (task.mLockTaskAuth == LOCK_TASK_AUTH_LAUNCHABLE || 1395 task.mLockTaskAuth == LOCK_TASK_AUTH_LAUNCHABLE_PRIV) { 1396 setLockTaskModeLocked(task, LOCK_TASK_MODE_LOCKED, "mLockTaskAuth==LAUNCHABLE", false); 1397 } 1398 1399 final ActivityStack stack = task.getStack(); 1400 try { 1401 if (app.thread == null) { 1402 throw new RemoteException(); 1403 } 1404 List<ResultInfo> results = null; 1405 List<ReferrerIntent> newIntents = null; 1406 if (andResume) { 1407 // We don't need to deliver new intents and/or set results if activity is going 1408 // to pause immediately after launch. 1409 results = r.results; 1410 newIntents = r.newIntents; 1411 } 1412 if (DEBUG_SWITCH) Slog.v(TAG_SWITCH, 1413 "Launching: " + r + " icicle=" + r.icicle + " with results=" + results 1414 + " newIntents=" + newIntents + " andResume=" + andResume); 1415 EventLog.writeEvent(EventLogTags.AM_RESTART_ACTIVITY, r.userId, 1416 System.identityHashCode(r), task.taskId, r.shortComponentName); 1417 if (r.isHomeActivity()) { 1418 // Home process is the root process of the task. 1419 mService.mHomeProcess = task.mActivities.get(0).app; 1420 } 1421 mService.notifyPackageUse(r.intent.getComponent().getPackageName(), 1422 PackageManager.NOTIFY_PACKAGE_USE_ACTIVITY); 1423 r.sleeping = false; 1424 r.forceNewConfig = false; 1425 mService.showUnsupportedZoomDialogIfNeededLocked(r); 1426 mService.showAskCompatModeDialogLocked(r); 1427 r.compat = mService.compatibilityInfoForPackageLocked(r.info.applicationInfo); 1428 ProfilerInfo profilerInfo = null; 1429 if (mService.mProfileApp != null && mService.mProfileApp.equals(app.processName)) { 1430 if (mService.mProfileProc == null || mService.mProfileProc == app) { 1431 mService.mProfileProc = app; 1432 final String profileFile = mService.mProfileFile; 1433 if (profileFile != null) { 1434 ParcelFileDescriptor profileFd = mService.mProfileFd; 1435 if (profileFd != null) { 1436 try { 1437 profileFd = profileFd.dup(); 1438 } catch (IOException e) { 1439 if (profileFd != null) { 1440 try { 1441 profileFd.close(); 1442 } catch (IOException o) { 1443 } 1444 profileFd = null; 1445 } 1446 } 1447 } 1448 1449 profilerInfo = new ProfilerInfo(profileFile, profileFd, 1450 mService.mSamplingInterval, mService.mAutoStopProfiler, 1451 mService.mStreamingOutput); 1452 } 1453 } 1454 } 1455 1456 app.hasShownUi = true; 1457 app.pendingUiClean = true; 1458 app.forceProcessStateUpTo(mService.mTopProcessState); 1459 // Because we could be starting an Activity in the system process this may not go across 1460 // a Binder interface which would create a new Configuration. Consequently we have to 1461 // always create a new Configuration here. 1462 1463 final MergedConfiguration mergedConfiguration = new MergedConfiguration( 1464 mService.getGlobalConfiguration(), r.getMergedOverrideConfiguration()); 1465 r.setLastReportedConfiguration(mergedConfiguration); 1466 1467 app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken, 1468 System.identityHashCode(r), r.info, 1469 // TODO: Have this take the merged configuration instead of separate global and 1470 // override configs. 1471 mergedConfiguration.getGlobalConfiguration(), 1472 mergedConfiguration.getOverrideConfiguration(), r.compat, 1473 r.launchedFromPackage, task.voiceInteractor, app.repProcState, r.icicle, 1474 r.persistentState, results, newIntents, !andResume, 1475 mService.isNextTransitionForward(), profilerInfo); 1476 1477 if ((app.info.privateFlags&ApplicationInfo.PRIVATE_FLAG_CANT_SAVE_STATE) != 0) { 1478 // This may be a heavy-weight process! Note that the package 1479 // manager will ensure that only activity can run in the main 1480 // process of the .apk, which is the only thing that will be 1481 // considered heavy-weight. 1482 if (app.processName.equals(app.info.packageName)) { 1483 if (mService.mHeavyWeightProcess != null 1484 && mService.mHeavyWeightProcess != app) { 1485 Slog.w(TAG, "Starting new heavy weight process " + app 1486 + " when already running " 1487 + mService.mHeavyWeightProcess); 1488 } 1489 mService.mHeavyWeightProcess = app; 1490 Message msg = mService.mHandler.obtainMessage( 1491 ActivityManagerService.POST_HEAVY_NOTIFICATION_MSG); 1492 msg.obj = r; 1493 mService.mHandler.sendMessage(msg); 1494 } 1495 } 1496 1497 } catch (RemoteException e) { 1498 if (r.launchFailed) { 1499 // This is the second time we failed -- finish activity 1500 // and give up. 1501 Slog.e(TAG, "Second failure launching " 1502 + r.intent.getComponent().flattenToShortString() 1503 + ", giving up", e); 1504 mService.appDiedLocked(app); 1505 stack.requestFinishActivityLocked(r.appToken, Activity.RESULT_CANCELED, null, 1506 "2nd-crash", false); 1507 return false; 1508 } 1509 1510 // This is the first time we failed -- restart process and 1511 // retry. 1512 r.launchFailed = true; 1513 app.activities.remove(r); 1514 throw e; 1515 } 1516 1517 r.launchFailed = false; 1518 if (stack.updateLRUListLocked(r)) { 1519 Slog.w(TAG, "Activity " + r + " being launched, but already in LRU list"); 1520 } 1521 1522 if (andResume) { 1523 // As part of the process of launching, ActivityThread also performs 1524 // a resume. 1525 stack.minimalResumeActivityLocked(r); 1526 } else { 1527 // This activity is not starting in the resumed state... which should look like we asked 1528 // it to pause+stop (but remain visible), and it has done so and reported back the 1529 // current icicle and other state. 1530 if (DEBUG_STATES) Slog.v(TAG_STATES, 1531 "Moving to PAUSED: " + r + " (starting in paused state)"); 1532 r.state = PAUSED; 1533 } 1534 1535 // Launch the new version setup screen if needed. We do this -after- 1536 // launching the initial activity (that is, home), so that it can have 1537 // a chance to initialize itself while in the background, making the 1538 // switch back to it faster and look better. 1539 if (isFocusedStack(stack)) { 1540 mService.startSetupActivityLocked(); 1541 } 1542 1543 // Update any services we are bound to that might care about whether 1544 // their client may have activities. 1545 if (r.app != null) { 1546 mService.mServices.updateServiceConnectionActivitiesLocked(r.app); 1547 } 1548 1549 return true; 1550 } 1551 1552 void startSpecificActivityLocked(ActivityRecord r, 1553 boolean andResume, boolean checkConfig) { 1554 // Is this activity's application already running? 1555 ProcessRecord app = mService.getProcessRecordLocked(r.processName, 1556 r.info.applicationInfo.uid, true); 1557 1558 r.getStack().setLaunchTime(r); 1559 1560 if (app != null && app.thread != null) { 1561 try { 1562 if ((r.info.flags&ActivityInfo.FLAG_MULTIPROCESS) == 0 1563 || !"android".equals(r.info.packageName)) { 1564 // Don't add this if it is a platform component that is marked 1565 // to run in multiple processes, because this is actually 1566 // part of the framework so doesn't make sense to track as a 1567 // separate apk in the process. 1568 app.addPackage(r.info.packageName, r.info.applicationInfo.versionCode, 1569 mService.mProcessStats); 1570 } 1571 realStartActivityLocked(r, app, andResume, checkConfig); 1572 return; 1573 } catch (RemoteException e) { 1574 Slog.w(TAG, "Exception when starting activity " 1575 + r.intent.getComponent().flattenToShortString(), e); 1576 } 1577 1578 // If a dead object exception was thrown -- fall through to 1579 // restart the application. 1580 } 1581 1582 mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0, 1583 "activity", r.intent.getComponent(), false, false, true); 1584 } 1585 1586 boolean checkStartAnyActivityPermission(Intent intent, ActivityInfo aInfo, 1587 String resultWho, int requestCode, int callingPid, int callingUid, 1588 String callingPackage, boolean ignoreTargetSecurity, ProcessRecord callerApp, 1589 ActivityRecord resultRecord, ActivityStack resultStack, ActivityOptions options) { 1590 final int startAnyPerm = mService.checkPermission(START_ANY_ACTIVITY, callingPid, 1591 callingUid); 1592 if (startAnyPerm == PERMISSION_GRANTED) { 1593 return true; 1594 } 1595 final int componentRestriction = getComponentRestrictionForCallingPackage( 1596 aInfo, callingPackage, callingPid, callingUid, ignoreTargetSecurity); 1597 final int actionRestriction = getActionRestrictionForCallingPackage( 1598 intent.getAction(), callingPackage, callingPid, callingUid); 1599 if (componentRestriction == ACTIVITY_RESTRICTION_PERMISSION 1600 || actionRestriction == ACTIVITY_RESTRICTION_PERMISSION) { 1601 if (resultRecord != null) { 1602 resultStack.sendActivityResultLocked(-1, 1603 resultRecord, resultWho, requestCode, 1604 Activity.RESULT_CANCELED, null); 1605 } 1606 final String msg; 1607 if (actionRestriction == ACTIVITY_RESTRICTION_PERMISSION) { 1608 msg = "Permission Denial: starting " + intent.toString() 1609 + " from " + callerApp + " (pid=" + callingPid 1610 + ", uid=" + callingUid + ")" + " with revoked permission " 1611 + ACTION_TO_RUNTIME_PERMISSION.get(intent.getAction()); 1612 } else if (!aInfo.exported) { 1613 msg = "Permission Denial: starting " + intent.toString() 1614 + " from " + callerApp + " (pid=" + callingPid 1615 + ", uid=" + callingUid + ")" 1616 + " not exported from uid " + aInfo.applicationInfo.uid; 1617 } else { 1618 msg = "Permission Denial: starting " + intent.toString() 1619 + " from " + callerApp + " (pid=" + callingPid 1620 + ", uid=" + callingUid + ")" 1621 + " requires " + aInfo.permission; 1622 } 1623 Slog.w(TAG, msg); 1624 throw new SecurityException(msg); 1625 } 1626 1627 if (actionRestriction == ACTIVITY_RESTRICTION_APPOP) { 1628 final String message = "Appop Denial: starting " + intent.toString() 1629 + " from " + callerApp + " (pid=" + callingPid 1630 + ", uid=" + callingUid + ")" 1631 + " requires " + AppOpsManager.permissionToOp( 1632 ACTION_TO_RUNTIME_PERMISSION.get(intent.getAction())); 1633 Slog.w(TAG, message); 1634 return false; 1635 } else if (componentRestriction == ACTIVITY_RESTRICTION_APPOP) { 1636 final String message = "Appop Denial: starting " + intent.toString() 1637 + " from " + callerApp + " (pid=" + callingPid 1638 + ", uid=" + callingUid + ")" 1639 + " requires appop " + AppOpsManager.permissionToOp(aInfo.permission); 1640 Slog.w(TAG, message); 1641 return false; 1642 } 1643 if (options != null) { 1644 if (options.getLaunchTaskId() != INVALID_STACK_ID) { 1645 final int startInTaskPerm = mService.checkPermission(START_TASKS_FROM_RECENTS, 1646 callingPid, callingUid); 1647 if (startInTaskPerm != PERMISSION_GRANTED) { 1648 final String msg = "Permission Denial: starting " + intent.toString() 1649 + " from " + callerApp + " (pid=" + callingPid 1650 + ", uid=" + callingUid + ") with launchTaskId=" 1651 + options.getLaunchTaskId(); 1652 Slog.w(TAG, msg); 1653 throw new SecurityException(msg); 1654 } 1655 } 1656 // Check if someone tries to launch an activity on a private display with a different 1657 // owner. 1658 final int launchDisplayId = options.getLaunchDisplayId(); 1659 if (launchDisplayId != INVALID_DISPLAY 1660 && !isCallerAllowedToLaunchOnDisplay(callingPid, callingUid, launchDisplayId)) { 1661 final String msg = "Permission Denial: starting " + intent.toString() 1662 + " from " + callerApp + " (pid=" + callingPid 1663 + ", uid=" + callingUid + ") with launchDisplayId=" 1664 + launchDisplayId; 1665 Slog.w(TAG, msg); 1666 throw new SecurityException(msg); 1667 } 1668 } 1669 1670 return true; 1671 } 1672 1673 /** Check if caller is allowed to launch activities on specified display. */ 1674 boolean isCallerAllowedToLaunchOnDisplay(int callingPid, int callingUid, int launchDisplayId) { 1675 if (DEBUG_TASKS) Slog.d(TAG, "Launch on display check: displayId=" + launchDisplayId 1676 + " callingPid=" + callingPid + " callingUid=" + callingUid); 1677 1678 final ActivityDisplay activityDisplay = getActivityDisplayOrCreateLocked(launchDisplayId); 1679 if (activityDisplay == null) { 1680 Slog.w(TAG, "Launch on display check: display not found"); 1681 return false; 1682 } 1683 1684 // Check if the caller can manage activity stacks. 1685 final int startAnyPerm = mService.checkPermission(INTERNAL_SYSTEM_WINDOW, callingPid, 1686 callingUid); 1687 if (startAnyPerm == PERMISSION_GRANTED) { 1688 if (DEBUG_TASKS) Slog.d(TAG, "Launch on display check:" 1689 + " allow launch any on display"); 1690 return true; 1691 } 1692 1693 if (activityDisplay.mDisplay.getType() == TYPE_VIRTUAL 1694 && activityDisplay.mDisplay.getOwnerUid() != SYSTEM_UID) { 1695 // Limit launching on virtual displays, because their contents can be read from Surface 1696 // by apps that created them. 1697 if (DEBUG_TASKS) Slog.d(TAG, "Launch on display check:" 1698 + " disallow launch on virtual display for not-embedded activity"); 1699 return false; 1700 } 1701 1702 if (!activityDisplay.isPrivate()) { 1703 // Anyone can launch on a public display. 1704 if (DEBUG_TASKS) Slog.d(TAG, "Launch on display check:" 1705 + " allow launch on public display"); 1706 return true; 1707 } 1708 1709 // Check if the caller is the owner of the display. 1710 if (activityDisplay.mDisplay.getOwnerUid() == callingUid) { 1711 if (DEBUG_TASKS) Slog.d(TAG, "Launch on display check:" 1712 + " allow launch for owner of the display"); 1713 return true; 1714 } 1715 1716 // Check if caller is present on display 1717 if (activityDisplay.isUidPresent(callingUid)) { 1718 if (DEBUG_TASKS) Slog.d(TAG, "Launch on display check:" 1719 + " allow launch for caller present on the display"); 1720 return true; 1721 } 1722 1723 Slog.w(TAG, "Launch on display check: denied"); 1724 return false; 1725 } 1726 1727 /** Update lists of UIDs that are present on displays and have access to them. */ 1728 void updateUIDsPresentOnDisplay() { 1729 mDisplayAccessUIDs.clear(); 1730 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 1731 final ActivityDisplay activityDisplay = mActivityDisplays.valueAt(displayNdx); 1732 // Only bother calculating the whitelist for private displays 1733 if (activityDisplay.isPrivate()) { 1734 mDisplayAccessUIDs.append( 1735 activityDisplay.mDisplayId, activityDisplay.getPresentUIDs()); 1736 } 1737 } 1738 // Store updated lists in DisplayManager. Callers from outside of AM should get them there. 1739 mDisplayManagerInternal.setDisplayAccessUIDs(mDisplayAccessUIDs); 1740 } 1741 1742 UserInfo getUserInfo(int userId) { 1743 final long identity = Binder.clearCallingIdentity(); 1744 try { 1745 return UserManager.get(mService.mContext).getUserInfo(userId); 1746 } finally { 1747 Binder.restoreCallingIdentity(identity); 1748 } 1749 } 1750 1751 private int getComponentRestrictionForCallingPackage(ActivityInfo activityInfo, 1752 String callingPackage, int callingPid, int callingUid, boolean ignoreTargetSecurity) { 1753 if (!ignoreTargetSecurity && mService.checkComponentPermission(activityInfo.permission, 1754 callingPid, callingUid, activityInfo.applicationInfo.uid, activityInfo.exported) 1755 == PackageManager.PERMISSION_DENIED) { 1756 return ACTIVITY_RESTRICTION_PERMISSION; 1757 } 1758 1759 if (activityInfo.permission == null) { 1760 return ACTIVITY_RESTRICTION_NONE; 1761 } 1762 1763 final int opCode = AppOpsManager.permissionToOpCode(activityInfo.permission); 1764 if (opCode == AppOpsManager.OP_NONE) { 1765 return ACTIVITY_RESTRICTION_NONE; 1766 } 1767 1768 if (mService.mAppOpsService.noteOperation(opCode, callingUid, 1769 callingPackage) != AppOpsManager.MODE_ALLOWED) { 1770 if (!ignoreTargetSecurity) { 1771 return ACTIVITY_RESTRICTION_APPOP; 1772 } 1773 } 1774 1775 return ACTIVITY_RESTRICTION_NONE; 1776 } 1777 1778 private int getActionRestrictionForCallingPackage(String action, 1779 String callingPackage, int callingPid, int callingUid) { 1780 if (action == null) { 1781 return ACTIVITY_RESTRICTION_NONE; 1782 } 1783 1784 String permission = ACTION_TO_RUNTIME_PERMISSION.get(action); 1785 if (permission == null) { 1786 return ACTIVITY_RESTRICTION_NONE; 1787 } 1788 1789 final PackageInfo packageInfo; 1790 try { 1791 packageInfo = mService.mContext.getPackageManager() 1792 .getPackageInfo(callingPackage, PackageManager.GET_PERMISSIONS); 1793 } catch (PackageManager.NameNotFoundException e) { 1794 Slog.i(TAG, "Cannot find package info for " + callingPackage); 1795 return ACTIVITY_RESTRICTION_NONE; 1796 } 1797 1798 if (!ArrayUtils.contains(packageInfo.requestedPermissions, permission)) { 1799 return ACTIVITY_RESTRICTION_NONE; 1800 } 1801 1802 if (mService.checkPermission(permission, callingPid, callingUid) == 1803 PackageManager.PERMISSION_DENIED) { 1804 return ACTIVITY_RESTRICTION_PERMISSION; 1805 } 1806 1807 final int opCode = AppOpsManager.permissionToOpCode(permission); 1808 if (opCode == AppOpsManager.OP_NONE) { 1809 return ACTIVITY_RESTRICTION_NONE; 1810 } 1811 1812 if (mService.mAppOpsService.noteOperation(opCode, callingUid, 1813 callingPackage) != AppOpsManager.MODE_ALLOWED) { 1814 return ACTIVITY_RESTRICTION_APPOP; 1815 } 1816 1817 return ACTIVITY_RESTRICTION_NONE; 1818 } 1819 1820 void setLaunchSource(int uid) { 1821 mLaunchingActivity.setWorkSource(new WorkSource(uid)); 1822 } 1823 1824 void acquireLaunchWakelock() { 1825 if (VALIDATE_WAKE_LOCK_CALLER && Binder.getCallingUid() != Process.myUid()) { 1826 throw new IllegalStateException("Calling must be system uid"); 1827 } 1828 mLaunchingActivity.acquire(); 1829 if (!mHandler.hasMessages(LAUNCH_TIMEOUT_MSG)) { 1830 // To be safe, don't allow the wake lock to be held for too long. 1831 mHandler.sendEmptyMessageDelayed(LAUNCH_TIMEOUT_MSG, LAUNCH_TIMEOUT); 1832 } 1833 } 1834 1835 /** 1836 * Called when the frontmost task is idle. 1837 * @return the state of mService.mBooting before this was called. 1838 */ 1839 private boolean checkFinishBootingLocked() { 1840 final boolean booting = mService.mBooting; 1841 boolean enableScreen = false; 1842 mService.mBooting = false; 1843 if (!mService.mBooted) { 1844 mService.mBooted = true; 1845 enableScreen = true; 1846 } 1847 if (booting || enableScreen) { 1848 mService.postFinishBooting(booting, enableScreen); 1849 } 1850 return booting; 1851 } 1852 1853 // Checked. 1854 final ActivityRecord activityIdleInternalLocked(final IBinder token, boolean fromTimeout, 1855 boolean processPausingActivities, Configuration config) { 1856 if (DEBUG_ALL) Slog.v(TAG, "Activity idle: " + token); 1857 1858 ArrayList<ActivityRecord> finishes = null; 1859 ArrayList<UserState> startingUsers = null; 1860 int NS = 0; 1861 int NF = 0; 1862 boolean booting = false; 1863 boolean activityRemoved = false; 1864 1865 ActivityRecord r = ActivityRecord.forTokenLocked(token); 1866 if (r != null) { 1867 if (DEBUG_IDLE) Slog.d(TAG_IDLE, "activityIdleInternalLocked: Callers=" 1868 + Debug.getCallers(4)); 1869 mHandler.removeMessages(IDLE_TIMEOUT_MSG, r); 1870 r.finishLaunchTickingLocked(); 1871 if (fromTimeout) { 1872 reportActivityLaunchedLocked(fromTimeout, r, -1, -1); 1873 } 1874 1875 // This is a hack to semi-deal with a race condition 1876 // in the client where it can be constructed with a 1877 // newer configuration from when we asked it to launch. 1878 // We'll update with whatever configuration it now says 1879 // it used to launch. 1880 if (config != null) { 1881 r.setLastReportedGlobalConfiguration(config); 1882 } 1883 1884 // We are now idle. If someone is waiting for a thumbnail from 1885 // us, we can now deliver. 1886 r.idle = true; 1887 1888 //Slog.i(TAG, "IDLE: mBooted=" + mBooted + ", fromTimeout=" + fromTimeout); 1889 if (isFocusedStack(r.getStack()) || fromTimeout) { 1890 booting = checkFinishBootingLocked(); 1891 } 1892 } 1893 1894 if (allResumedActivitiesIdle()) { 1895 if (r != null) { 1896 mService.scheduleAppGcsLocked(); 1897 } 1898 1899 if (mLaunchingActivity.isHeld()) { 1900 mHandler.removeMessages(LAUNCH_TIMEOUT_MSG); 1901 if (VALIDATE_WAKE_LOCK_CALLER && 1902 Binder.getCallingUid() != Process.myUid()) { 1903 throw new IllegalStateException("Calling must be system uid"); 1904 } 1905 mLaunchingActivity.release(); 1906 } 1907 ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS); 1908 } 1909 1910 // Atomically retrieve all of the other things to do. 1911 final ArrayList<ActivityRecord> stops = processStoppingActivitiesLocked(r, 1912 true /* remove */, processPausingActivities); 1913 NS = stops != null ? stops.size() : 0; 1914 if ((NF = mFinishingActivities.size()) > 0) { 1915 finishes = new ArrayList<>(mFinishingActivities); 1916 mFinishingActivities.clear(); 1917 } 1918 1919 if (mStartingUsers.size() > 0) { 1920 startingUsers = new ArrayList<>(mStartingUsers); 1921 mStartingUsers.clear(); 1922 } 1923 1924 // Stop any activities that are scheduled to do so but have been 1925 // waiting for the next one to start. 1926 for (int i = 0; i < NS; i++) { 1927 r = stops.get(i); 1928 final ActivityStack stack = r.getStack(); 1929 if (stack != null) { 1930 if (r.finishing) { 1931 stack.finishCurrentActivityLocked(r, ActivityStack.FINISH_IMMEDIATELY, false); 1932 } else { 1933 stack.stopActivityLocked(r); 1934 } 1935 } 1936 } 1937 1938 // Finish any activities that are scheduled to do so but have been 1939 // waiting for the next one to start. 1940 for (int i = 0; i < NF; i++) { 1941 r = finishes.get(i); 1942 final ActivityStack stack = r.getStack(); 1943 if (stack != null) { 1944 activityRemoved |= stack.destroyActivityLocked(r, true, "finish-idle"); 1945 } 1946 } 1947 1948 if (!booting) { 1949 // Complete user switch 1950 if (startingUsers != null) { 1951 for (int i = 0; i < startingUsers.size(); i++) { 1952 mService.mUserController.finishUserSwitch(startingUsers.get(i)); 1953 } 1954 } 1955 } 1956 1957 mService.trimApplications(); 1958 //dump(); 1959 //mWindowManager.dump(); 1960 1961 if (activityRemoved) { 1962 resumeFocusedStackTopActivityLocked(); 1963 } 1964 1965 return r; 1966 } 1967 1968 boolean handleAppDiedLocked(ProcessRecord app) { 1969 boolean hasVisibleActivities = false; 1970 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 1971 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 1972 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 1973 hasVisibleActivities |= stacks.get(stackNdx).handleAppDiedLocked(app); 1974 } 1975 } 1976 return hasVisibleActivities; 1977 } 1978 1979 void closeSystemDialogsLocked() { 1980 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 1981 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 1982 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 1983 stacks.get(stackNdx).closeSystemDialogsLocked(); 1984 } 1985 } 1986 } 1987 1988 void removeUserLocked(int userId) { 1989 mUserStackInFront.delete(userId); 1990 } 1991 1992 /** 1993 * Update the last used stack id for non-current user (current user's last 1994 * used stack is the focused stack) 1995 */ 1996 void updateUserStackLocked(int userId, ActivityStack stack) { 1997 if (userId != mCurrentUser) { 1998 mUserStackInFront.put(userId, stack != null ? stack.getStackId() : HOME_STACK_ID); 1999 } 2000 } 2001 2002 /** 2003 * @return true if some activity was finished (or would have finished if doit were true). 2004 */ 2005 boolean finishDisabledPackageActivitiesLocked(String packageName, Set<String> filterByClasses, 2006 boolean doit, boolean evenPersistent, int userId) { 2007 boolean didSomething = false; 2008 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 2009 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 2010 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 2011 final ActivityStack stack = stacks.get(stackNdx); 2012 if (stack.finishDisabledPackageActivitiesLocked( 2013 packageName, filterByClasses, doit, evenPersistent, userId)) { 2014 didSomething = true; 2015 } 2016 } 2017 } 2018 return didSomething; 2019 } 2020 2021 void updatePreviousProcessLocked(ActivityRecord r) { 2022 // Now that this process has stopped, we may want to consider 2023 // it to be the previous app to try to keep around in case 2024 // the user wants to return to it. 2025 2026 // First, found out what is currently the foreground app, so that 2027 // we don't blow away the previous app if this activity is being 2028 // hosted by the process that is actually still the foreground. 2029 ProcessRecord fgApp = null; 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 (isFocusedStack(stack)) { 2035 if (stack.mResumedActivity != null) { 2036 fgApp = stack.mResumedActivity.app; 2037 } else if (stack.mPausingActivity != null) { 2038 fgApp = stack.mPausingActivity.app; 2039 } 2040 break; 2041 } 2042 } 2043 } 2044 2045 // Now set this one as the previous process, only if that really 2046 // makes sense to. 2047 if (r.app != null && fgApp != null && r.app != fgApp 2048 && r.lastVisibleTime > mService.mPreviousProcessVisibleTime 2049 && r.app != mService.mHomeProcess) { 2050 mService.mPreviousProcess = r.app; 2051 mService.mPreviousProcessVisibleTime = r.lastVisibleTime; 2052 } 2053 } 2054 2055 boolean resumeFocusedStackTopActivityLocked() { 2056 return resumeFocusedStackTopActivityLocked(null, null, null); 2057 } 2058 2059 boolean resumeFocusedStackTopActivityLocked( 2060 ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) { 2061 if (targetStack != null && isFocusedStack(targetStack)) { 2062 return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions); 2063 } 2064 final ActivityRecord r = mFocusedStack.topRunningActivityLocked(); 2065 if (r == null || r.state != RESUMED) { 2066 mFocusedStack.resumeTopActivityUncheckedLocked(null, null); 2067 } else if (r.state == RESUMED) { 2068 // Kick off any lingering app transitions form the MoveTaskToFront operation. 2069 mFocusedStack.executeAppTransition(targetOptions); 2070 } 2071 return false; 2072 } 2073 2074 void updateActivityApplicationInfoLocked(ApplicationInfo aInfo) { 2075 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 2076 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 2077 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 2078 stacks.get(stackNdx).updateActivityApplicationInfoLocked(aInfo); 2079 } 2080 } 2081 } 2082 2083 TaskRecord finishTopRunningActivityLocked(ProcessRecord app, String reason) { 2084 TaskRecord finishedTask = null; 2085 ActivityStack focusedStack = getFocusedStack(); 2086 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 2087 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 2088 final int numStacks = stacks.size(); 2089 for (int stackNdx = 0; stackNdx < numStacks; ++stackNdx) { 2090 final ActivityStack stack = stacks.get(stackNdx); 2091 TaskRecord t = stack.finishTopRunningActivityLocked(app, reason); 2092 if (stack == focusedStack || finishedTask == null) { 2093 finishedTask = t; 2094 } 2095 } 2096 } 2097 return finishedTask; 2098 } 2099 2100 void finishVoiceTask(IVoiceInteractionSession session) { 2101 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 2102 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 2103 final int numStacks = stacks.size(); 2104 for (int stackNdx = 0; stackNdx < numStacks; ++stackNdx) { 2105 final ActivityStack stack = stacks.get(stackNdx); 2106 stack.finishVoiceTask(session); 2107 } 2108 } 2109 } 2110 2111 void findTaskToMoveToFrontLocked(TaskRecord task, int flags, ActivityOptions options, 2112 String reason, boolean forceNonResizeable) { 2113 if ((flags & ActivityManager.MOVE_TASK_NO_USER_ACTION) == 0) { 2114 mUserLeaving = true; 2115 } 2116 if ((flags & ActivityManager.MOVE_TASK_WITH_HOME) != 0) { 2117 // Caller wants the home activity moved with it. To accomplish this, 2118 // we'll just indicate that this task returns to the home task. 2119 task.setTaskToReturnTo(HOME_ACTIVITY_TYPE); 2120 } 2121 ActivityStack currentStack = task.getStack(); 2122 if (currentStack == null) { 2123 Slog.e(TAG, "findTaskToMoveToFrontLocked: can't move task=" 2124 + task + " to front. Stack is null"); 2125 return; 2126 } 2127 2128 if (task.isResizeable() && options != null) { 2129 int stackId = options.getLaunchStackId(); 2130 if (canUseActivityOptionsLaunchBounds(options, stackId)) { 2131 final Rect bounds = TaskRecord.validateBounds(options.getLaunchBounds()); 2132 task.updateOverrideConfiguration(bounds); 2133 if (stackId == INVALID_STACK_ID) { 2134 stackId = task.getLaunchStackId(); 2135 } 2136 if (stackId != currentStack.mStackId) { 2137 task.reparent(stackId, ON_TOP, REPARENT_KEEP_STACK_AT_FRONT, !ANIMATE, 2138 DEFER_RESUME, "findTaskToMoveToFrontLocked"); 2139 stackId = currentStack.mStackId; 2140 // moveTaskToStackUncheckedLocked() should already placed the task on top, 2141 // still need moveTaskToFrontLocked() below for any transition settings. 2142 } 2143 if (StackId.resizeStackWithLaunchBounds(stackId)) { 2144 resizeStackLocked(stackId, bounds, 2145 null /* tempTaskBounds */, null /* tempTaskInsetBounds */, 2146 !PRESERVE_WINDOWS, true /* allowResizeInDockedMode */, !DEFER_RESUME); 2147 } else { 2148 // WM resizeTask must be done after the task is moved to the correct stack, 2149 // because Task's setBounds() also updates dim layer's bounds, but that has 2150 // dependency on the stack. 2151 task.resizeWindowContainer(); 2152 } 2153 } 2154 } 2155 2156 final ActivityRecord r = task.getTopActivity(); 2157 currentStack.moveTaskToFrontLocked(task, false /* noAnimation */, options, 2158 r == null ? null : r.appTimeTracker, reason); 2159 2160 if (DEBUG_STACK) Slog.d(TAG_STACK, 2161 "findTaskToMoveToFront: moved to front of stack=" + currentStack); 2162 2163 handleNonResizableTaskIfNeeded(task, INVALID_STACK_ID, DEFAULT_DISPLAY, 2164 currentStack.mStackId, forceNonResizeable); 2165 } 2166 2167 boolean canUseActivityOptionsLaunchBounds(ActivityOptions options, int launchStackId) { 2168 // We use the launch bounds in the activity options is the device supports freeform 2169 // window management or is launching into the pinned stack. 2170 if (options.getLaunchBounds() == null) { 2171 return false; 2172 } 2173 return (mService.mSupportsPictureInPicture && launchStackId == PINNED_STACK_ID) 2174 || mService.mSupportsFreeformWindowManagement; 2175 } 2176 2177 protected <T extends ActivityStack> T getStack(int stackId) { 2178 return getStack(stackId, !CREATE_IF_NEEDED, !ON_TOP); 2179 } 2180 2181 protected <T extends ActivityStack> T getStack(int stackId, boolean createStaticStackIfNeeded, 2182 boolean createOnTop) { 2183 final ActivityContainer activityContainer = mActivityContainers.get(stackId); 2184 if (activityContainer != null) { 2185 return (T) activityContainer.mStack; 2186 } 2187 if (!createStaticStackIfNeeded || !StackId.isStaticStack(stackId)) { 2188 return null; 2189 } 2190 if (stackId == DOCKED_STACK_ID) { 2191 // Make sure recents stack exist when creating a dock stack as it normally need to be on 2192 // the other side of the docked stack and we make visibility decisions based on that. 2193 getStack(RECENTS_STACK_ID, CREATE_IF_NEEDED, createOnTop); 2194 } 2195 return (T) createStackOnDisplay(stackId, DEFAULT_DISPLAY, createOnTop); 2196 } 2197 2198 /** 2199 * Get a topmost stack on the display, that is a valid launch stack for specified activity. 2200 * If there is no such stack, new dynamic stack can be created. 2201 * @param displayId Target display. 2202 * @param r Activity that should be launched there. 2203 * @return Existing stack if there is a valid one, new dynamic stack if it is valid or null. 2204 */ 2205 ActivityStack getValidLaunchStackOnDisplay(int displayId, @NonNull ActivityRecord r) { 2206 final ActivityDisplay activityDisplay = getActivityDisplayOrCreateLocked(displayId); 2207 if (activityDisplay == null) { 2208 throw new IllegalArgumentException( 2209 "Display with displayId=" + displayId + " not found."); 2210 } 2211 2212 // Return the topmost valid stack on the display. 2213 for (int i = activityDisplay.mStacks.size() - 1; i >= 0; --i) { 2214 final ActivityStack stack = activityDisplay.mStacks.get(i); 2215 if (mService.mActivityStarter.isValidLaunchStackId(stack.mStackId, displayId, r)) { 2216 return stack; 2217 } 2218 } 2219 2220 // If there is no valid stack on the external display - check if new dynamic stack will do. 2221 if (displayId != Display.DEFAULT_DISPLAY) { 2222 final int newDynamicStackId = getNextStackId(); 2223 if (mService.mActivityStarter.isValidLaunchStackId(newDynamicStackId, displayId, r)) { 2224 return createStackOnDisplay(newDynamicStackId, displayId, true /*onTop*/); 2225 } 2226 } 2227 2228 Slog.w(TAG, "getValidLaunchStackOnDisplay: can't launch on displayId " + displayId); 2229 return null; 2230 } 2231 2232 ArrayList<ActivityStack> getStacks() { 2233 ArrayList<ActivityStack> allStacks = new ArrayList<>(); 2234 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 2235 allStacks.addAll(mActivityDisplays.valueAt(displayNdx).mStacks); 2236 } 2237 return allStacks; 2238 } 2239 2240 ArrayList<ActivityStack> getStacksOnDefaultDisplay() { 2241 return mActivityDisplays.valueAt(DEFAULT_DISPLAY).mStacks; 2242 } 2243 2244 /** 2245 * Get next focusable stack in the system. This will search across displays and stacks 2246 * in last-focused order for a focusable and visible stack, different from the target stack. 2247 * 2248 * @param currentFocus The stack that previously had focus and thus needs to be ignored when 2249 * searching for next candidate. 2250 * @return Next focusable {@link ActivityStack}, null if not found. 2251 */ 2252 ActivityStack getNextFocusableStackLocked(ActivityStack currentFocus) { 2253 mWindowManager.getDisplaysInFocusOrder(mTmpOrderedDisplayIds); 2254 2255 for (int i = mTmpOrderedDisplayIds.size() - 1; i >= 0; --i) { 2256 final int displayId = mTmpOrderedDisplayIds.get(i); 2257 // If a display is registered in WM, it must also be available in AM. 2258 @SuppressWarnings("ConstantConditions") 2259 final List<ActivityStack> stacks = getActivityDisplayOrCreateLocked(displayId).mStacks; 2260 for (int j = stacks.size() - 1; j >= 0; --j) { 2261 final ActivityStack stack = stacks.get(j); 2262 if (stack != currentFocus && stack.isFocusable() 2263 && stack.shouldBeVisible(null) != STACK_INVISIBLE) { 2264 return stack; 2265 } 2266 } 2267 } 2268 2269 return null; 2270 } 2271 2272 /** 2273 * Get next valid stack for launching provided activity in the system. This will search across 2274 * displays and stacks in last-focused order for a focusable and visible stack, except those 2275 * that are on a currently focused display. 2276 * 2277 * @param r The activity that is being launched. 2278 * @param currentFocus The display that previously had focus and thus needs to be ignored when 2279 * searching for the next candidate. 2280 * @return Next valid {@link ActivityStack}, null if not found. 2281 */ 2282 ActivityStack getNextValidLaunchStackLocked(@NonNull ActivityRecord r, int currentFocus) { 2283 mWindowManager.getDisplaysInFocusOrder(mTmpOrderedDisplayIds); 2284 for (int i = mTmpOrderedDisplayIds.size() - 1; i >= 0; --i) { 2285 final int displayId = mTmpOrderedDisplayIds.get(i); 2286 if (displayId == currentFocus) { 2287 continue; 2288 } 2289 final ActivityStack stack = getValidLaunchStackOnDisplay(displayId, r); 2290 if (stack != null) { 2291 return stack; 2292 } 2293 } 2294 return null; 2295 } 2296 2297 ActivityRecord getHomeActivity() { 2298 return getHomeActivityForUser(mCurrentUser); 2299 } 2300 2301 ActivityRecord getHomeActivityForUser(int userId) { 2302 final ArrayList<TaskRecord> tasks = mHomeStack.getAllTasks(); 2303 for (int taskNdx = tasks.size() - 1; taskNdx >= 0; --taskNdx) { 2304 final TaskRecord task = tasks.get(taskNdx); 2305 if (task.isHomeTask()) { 2306 final ArrayList<ActivityRecord> activities = task.mActivities; 2307 for (int activityNdx = activities.size() - 1; activityNdx >= 0; --activityNdx) { 2308 final ActivityRecord r = activities.get(activityNdx); 2309 if (r.isHomeActivity() 2310 && ((userId == UserHandle.USER_ALL) || (r.userId == userId))) { 2311 return r; 2312 } 2313 } 2314 } 2315 } 2316 return null; 2317 } 2318 2319 /** 2320 * Returns if a stack should be treated as if it's docked. Returns true if the stack is 2321 * the docked stack itself, or if it's side-by-side to the docked stack. 2322 */ 2323 boolean isStackDockedInEffect(int stackId) { 2324 return stackId == DOCKED_STACK_ID || 2325 (StackId.isResizeableByDockedStack(stackId) && getStack(DOCKED_STACK_ID) != null); 2326 } 2327 2328 ActivityContainer createVirtualActivityContainer(ActivityRecord parentActivity, 2329 IActivityContainerCallback callback) { 2330 ActivityContainer activityContainer = 2331 new VirtualActivityContainer(parentActivity, callback); 2332 mActivityContainers.put(activityContainer.mStackId, activityContainer); 2333 if (DEBUG_CONTAINERS) Slog.d(TAG_CONTAINERS, 2334 "createActivityContainer: " + activityContainer); 2335 parentActivity.mChildContainers.add(activityContainer); 2336 return activityContainer; 2337 } 2338 2339 void removeChildActivityContainers(ActivityRecord parentActivity) { 2340 final ArrayList<ActivityContainer> childStacks = parentActivity.mChildContainers; 2341 for (int containerNdx = childStacks.size() - 1; containerNdx >= 0; --containerNdx) { 2342 ActivityContainer container = childStacks.remove(containerNdx); 2343 if (DEBUG_CONTAINERS) Slog.d(TAG_CONTAINERS, "removeChildActivityContainers: removing " 2344 + container); 2345 container.release(); 2346 } 2347 } 2348 2349 void deleteActivityContainerRecord(int stackId) { 2350 if (DEBUG_CONTAINERS) Slog.d(TAG_CONTAINERS, 2351 "deleteActivityContainerRecord: callers=" + Debug.getCallers(4)); 2352 mActivityContainers.remove(stackId); 2353 } 2354 2355 void resizeStackLocked(int stackId, Rect bounds, Rect tempTaskBounds, Rect tempTaskInsetBounds, 2356 boolean preserveWindows, boolean allowResizeInDockedMode, boolean deferResume) { 2357 if (stackId == DOCKED_STACK_ID) { 2358 resizeDockedStackLocked(bounds, tempTaskBounds, tempTaskInsetBounds, null, null, 2359 preserveWindows, deferResume); 2360 return; 2361 } 2362 final ActivityStack stack = getStack(stackId); 2363 if (stack == null) { 2364 Slog.w(TAG, "resizeStack: stackId " + stackId + " not found."); 2365 return; 2366 } 2367 2368 if (!allowResizeInDockedMode && !StackId.tasksAreFloating(stackId) && 2369 getStack(DOCKED_STACK_ID) != null) { 2370 // If the docked stack exists, don't resize non-floating stacks independently of the 2371 // size computed from the docked stack size (otherwise they will be out of sync) 2372 return; 2373 } 2374 2375 Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "am.resizeStack_" + stackId); 2376 mWindowManager.deferSurfaceLayout(); 2377 try { 2378 stack.resize(bounds, tempTaskBounds, tempTaskInsetBounds); 2379 if (!deferResume) { 2380 stack.ensureVisibleActivitiesConfigurationLocked( 2381 stack.topRunningActivityLocked(), preserveWindows); 2382 } 2383 } finally { 2384 mWindowManager.continueSurfaceLayout(); 2385 Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER); 2386 } 2387 } 2388 2389 void deferUpdateBounds(int stackId) { 2390 final ActivityStack stack = getStack(stackId); 2391 if (stack != null) { 2392 stack.deferUpdateBounds(); 2393 } 2394 } 2395 2396 void continueUpdateBounds(int stackId) { 2397 final ActivityStack stack = getStack(stackId); 2398 if (stack != null) { 2399 stack.continueUpdateBounds(); 2400 } 2401 } 2402 2403 void notifyAppTransitionDone() { 2404 continueUpdateBounds(RECENTS_STACK_ID); 2405 for (int i = mResizingTasksDuringAnimation.size() - 1; i >= 0; i--) { 2406 final int taskId = mResizingTasksDuringAnimation.valueAt(i); 2407 final TaskRecord task = 2408 anyTaskForIdLocked(taskId, MATCH_TASK_IN_STACKS_ONLY, INVALID_STACK_ID); 2409 if (task != null) { 2410 task.setTaskDockedResizing(false); 2411 } 2412 } 2413 mResizingTasksDuringAnimation.clear(); 2414 } 2415 2416 private void moveTasksToFullscreenStackInSurfaceTransaction(int fromStackId, 2417 boolean onTop) { 2418 2419 final ActivityStack stack = getStack(fromStackId); 2420 if (stack == null) { 2421 return; 2422 } 2423 2424 mWindowManager.deferSurfaceLayout(); 2425 try { 2426 if (fromStackId == DOCKED_STACK_ID) { 2427 // We are moving all tasks from the docked stack to the fullscreen stack, 2428 // which is dismissing the docked stack, so resize all other stacks to 2429 // fullscreen here already so we don't end up with resize trashing. 2430 for (int i = FIRST_STATIC_STACK_ID; i <= LAST_STATIC_STACK_ID; i++) { 2431 if (StackId.isResizeableByDockedStack(i)) { 2432 ActivityStack otherStack = getStack(i); 2433 if (otherStack != null) { 2434 resizeStackLocked(i, null, null, null, PRESERVE_WINDOWS, 2435 true /* allowResizeInDockedMode */, DEFER_RESUME); 2436 } 2437 } 2438 } 2439 2440 // Also disable docked stack resizing since we have manually adjusted the 2441 // size of other stacks above and we don't want to trigger a docked stack 2442 // resize when we remove task from it below and it is detached from the 2443 // display because it no longer contains any tasks. 2444 mAllowDockedStackResize = false; 2445 } else if (fromStackId == PINNED_STACK_ID) { 2446 if (onTop) { 2447 // Log if we are expanding the PiP to fullscreen 2448 MetricsLogger.action(mService.mContext, 2449 ACTION_PICTURE_IN_PICTURE_EXPANDED_TO_FULLSCREEN); 2450 } 2451 } 2452 ActivityStack fullscreenStack = getStack(FULLSCREEN_WORKSPACE_STACK_ID); 2453 final boolean isFullscreenStackVisible = fullscreenStack != null && 2454 fullscreenStack.shouldBeVisible(null) == STACK_VISIBLE; 2455 // If we are moving from the pinned stack, then the animation takes care of updating 2456 // the picture-in-picture mode. 2457 final boolean schedulePictureInPictureModeChange = (fromStackId == PINNED_STACK_ID); 2458 final ArrayList<TaskRecord> tasks = stack.getAllTasks(); 2459 final int size = tasks.size(); 2460 if (onTop) { 2461 for (int i = 0; i < size; i++) { 2462 final TaskRecord task = tasks.get(i); 2463 final boolean isTopTask = i == (size - 1); 2464 if (fromStackId == PINNED_STACK_ID) { 2465 // Update the return-to to reflect where the pinned stack task was moved 2466 // from so that we retain the stack that was previously visible if the 2467 // pinned stack is recreated. See moveActivityToPinnedStackLocked(). 2468 task.setTaskToReturnTo(isFullscreenStackVisible && onTop ? 2469 APPLICATION_ACTIVITY_TYPE : HOME_ACTIVITY_TYPE); 2470 } 2471 // Defer resume until all the tasks have been moved to the fullscreen stack 2472 task.reparent(FULLSCREEN_WORKSPACE_STACK_ID, ON_TOP, 2473 REPARENT_MOVE_STACK_TO_FRONT, isTopTask /* animate */, DEFER_RESUME, 2474 schedulePictureInPictureModeChange, 2475 "moveTasksToFullscreenStack - onTop"); 2476 } 2477 } else { 2478 for (int i = 0; i < size; i++) { 2479 final TaskRecord task = tasks.get(i); 2480 // Position the tasks in the fullscreen stack in order at the bottom of the 2481 // stack. Also defer resume until all the tasks have been moved to the 2482 // fullscreen stack. 2483 task.reparent(FULLSCREEN_WORKSPACE_STACK_ID, i /* position */, 2484 REPARENT_LEAVE_STACK_IN_PLACE, !ANIMATE, DEFER_RESUME, 2485 schedulePictureInPictureModeChange, 2486 "moveTasksToFullscreenStack - NOT_onTop"); 2487 } 2488 } 2489 2490 ensureActivitiesVisibleLocked(null, 0, PRESERVE_WINDOWS); 2491 resumeFocusedStackTopActivityLocked(); 2492 } finally { 2493 mAllowDockedStackResize = true; 2494 mWindowManager.continueSurfaceLayout(); 2495 } 2496 } 2497 2498 void moveTasksToFullscreenStackLocked(int fromStackId, boolean onTop) { 2499 mWindowManager.inSurfaceTransaction( 2500 () -> moveTasksToFullscreenStackInSurfaceTransaction(fromStackId, onTop)); 2501 } 2502 2503 void resizeDockedStackLocked(Rect dockedBounds, Rect tempDockedTaskBounds, 2504 Rect tempDockedTaskInsetBounds, Rect tempOtherTaskBounds, Rect tempOtherTaskInsetBounds, 2505 boolean preserveWindows) { 2506 resizeDockedStackLocked(dockedBounds, tempDockedTaskBounds, tempDockedTaskInsetBounds, 2507 tempOtherTaskBounds, tempOtherTaskInsetBounds, preserveWindows, 2508 false /* deferResume */); 2509 } 2510 2511 void resizeDockedStackLocked(Rect dockedBounds, Rect tempDockedTaskBounds, 2512 Rect tempDockedTaskInsetBounds, Rect tempOtherTaskBounds, Rect tempOtherTaskInsetBounds, 2513 boolean preserveWindows, boolean deferResume) { 2514 2515 if (!mAllowDockedStackResize) { 2516 // Docked stack resize currently disabled. 2517 return; 2518 } 2519 2520 final ActivityStack stack = getStack(DOCKED_STACK_ID); 2521 if (stack == null) { 2522 Slog.w(TAG, "resizeDockedStackLocked: docked stack not found"); 2523 return; 2524 } 2525 2526 Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "am.resizeDockedStack"); 2527 mWindowManager.deferSurfaceLayout(); 2528 try { 2529 // Don't allow re-entry while resizing. E.g. due to docked stack detaching. 2530 mAllowDockedStackResize = false; 2531 ActivityRecord r = stack.topRunningActivityLocked(); 2532 stack.resize(dockedBounds, tempDockedTaskBounds, tempDockedTaskInsetBounds); 2533 2534 // TODO: Checking for isAttached might not be needed as if the user passes in null 2535 // dockedBounds then they want the docked stack to be dismissed. 2536 if (stack.mFullscreen || (dockedBounds == null && !stack.isAttached())) { 2537 // The dock stack either was dismissed or went fullscreen, which is kinda the same. 2538 // In this case we make all other static stacks fullscreen and move all 2539 // docked stack tasks to the fullscreen stack. 2540 moveTasksToFullscreenStackLocked(DOCKED_STACK_ID, ON_TOP); 2541 2542 // stack shouldn't contain anymore activities, so nothing to resume. 2543 r = null; 2544 } else { 2545 // Docked stacks occupy a dedicated region on screen so the size of all other 2546 // static stacks need to be adjusted so they don't overlap with the docked stack. 2547 // We get the bounds to use from window manager which has been adjusted for any 2548 // screen controls and is also the same for all stacks. 2549 final Rect otherTaskRect = new Rect(); 2550 for (int i = FIRST_STATIC_STACK_ID; i <= LAST_STATIC_STACK_ID; i++) { 2551 final ActivityStack current = getStack(i); 2552 if (current != null && StackId.isResizeableByDockedStack(i)) { 2553 current.getStackDockedModeBounds( 2554 tempOtherTaskBounds /* currentTempTaskBounds */, 2555 tempRect /* outStackBounds */, 2556 otherTaskRect /* outTempTaskBounds */, true /* ignoreVisibility */); 2557 2558 resizeStackLocked(i, !tempRect.isEmpty() ? tempRect : null, 2559 !otherTaskRect.isEmpty() ? otherTaskRect : tempOtherTaskBounds, 2560 tempOtherTaskInsetBounds, preserveWindows, 2561 true /* allowResizeInDockedMode */, deferResume); 2562 } 2563 } 2564 } 2565 if (!deferResume) { 2566 stack.ensureVisibleActivitiesConfigurationLocked(r, preserveWindows); 2567 } 2568 } finally { 2569 mAllowDockedStackResize = true; 2570 mWindowManager.continueSurfaceLayout(); 2571 Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER); 2572 } 2573 } 2574 2575 void resizePinnedStackLocked(Rect pinnedBounds, Rect tempPinnedTaskBounds) { 2576 final PinnedActivityStack stack = getStack(PINNED_STACK_ID); 2577 if (stack == null) { 2578 Slog.w(TAG, "resizePinnedStackLocked: pinned stack not found"); 2579 return; 2580 } 2581 2582 // It is possible for the bounds animation from the WM to call this but be delayed by 2583 // another AM call that is holding the AMS lock. In such a case, the pinnedBounds may be 2584 // incorrect if AMS.resizeStackWithBoundsFromWindowManager() is already called while waiting 2585 // for the AMS lock to be freed. So check and make sure these bounds are still good. 2586 final PinnedStackWindowController stackController = stack.getWindowContainerController(); 2587 if (stackController.pinnedStackResizeDisallowed()) { 2588 return; 2589 } 2590 2591 Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "am.resizePinnedStack"); 2592 mWindowManager.deferSurfaceLayout(); 2593 try { 2594 ActivityRecord r = stack.topRunningActivityLocked(); 2595 Rect insetBounds = null; 2596 if (tempPinnedTaskBounds != null) { 2597 // We always use 0,0 as the position for the inset rect because 2598 // if we are getting insets at all in the pinned stack it must mean 2599 // we are headed for fullscreen. 2600 insetBounds = tempRect; 2601 insetBounds.top = 0; 2602 insetBounds.left = 0; 2603 insetBounds.right = tempPinnedTaskBounds.width(); 2604 insetBounds.bottom = tempPinnedTaskBounds.height(); 2605 } 2606 stack.resize(pinnedBounds, tempPinnedTaskBounds, insetBounds); 2607 stack.ensureVisibleActivitiesConfigurationLocked(r, false); 2608 } finally { 2609 mWindowManager.continueSurfaceLayout(); 2610 Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER); 2611 } 2612 } 2613 2614 ActivityStack createStackOnDisplay(int stackId, int displayId, boolean onTop) { 2615 final ActivityDisplay activityDisplay = getActivityDisplayOrCreateLocked(displayId); 2616 if (activityDisplay == null) { 2617 return null; 2618 } 2619 2620 final ActivityContainer activityContainer = 2621 new ActivityContainer(stackId, activityDisplay, onTop); 2622 return activityContainer.mStack; 2623 } 2624 2625 2626 void removeStackInSurfaceTransaction(int stackId) { 2627 final ActivityStack stack = getStack(stackId); 2628 if (stack == null) { 2629 return; 2630 } 2631 2632 final ArrayList<TaskRecord> tasks = stack.getAllTasks(); 2633 if (stack.getStackId() == PINNED_STACK_ID) { 2634 /** 2635 * Workaround: Force-stop all the activities in the pinned stack before we reparent them 2636 * to the fullscreen stack. This is to guarantee that when we are removing a stack, 2637 * that the client receives onStop() before it is reparented. We do this by detaching 2638 * the stack from the display so that it will be considered invisible when 2639 * ensureActivitiesVisibleLocked() is called, and all of its activitys will be marked 2640 * invisible as well and added to the stopping list. After which we process the 2641 * stopping list by handling the idle. 2642 */ 2643 final PinnedActivityStack pinnedStack = (PinnedActivityStack) stack; 2644 pinnedStack.mForceHidden = true; 2645 pinnedStack.ensureActivitiesVisibleLocked(null, 0, PRESERVE_WINDOWS); 2646 pinnedStack.mForceHidden = false; 2647 activityIdleInternalLocked(null, false /* fromTimeout */, 2648 true /* processPausingActivites */, null /* configuration */); 2649 2650 // Move all the tasks to the bottom of the fullscreen stack 2651 moveTasksToFullscreenStackLocked(PINNED_STACK_ID, !ON_TOP); 2652 } else { 2653 for (int i = tasks.size() - 1; i >= 0; i--) { 2654 removeTaskByIdLocked(tasks.get(i).taskId, true /* killProcess */, 2655 REMOVE_FROM_RECENTS); 2656 } 2657 } 2658 } 2659 2660 /** 2661 * Removes the stack associated with the given {@param stackId}. If the {@param stackId} is the 2662 * pinned stack, then its tasks are not explicitly removed when the stack is destroyed, but 2663 * instead moved back onto the fullscreen stack. 2664 */ 2665 void removeStackLocked(int stackId) { 2666 mWindowManager.inSurfaceTransaction( 2667 () -> removeStackInSurfaceTransaction(stackId)); 2668 } 2669 2670 /** 2671 * See {@link #removeTaskByIdLocked(int, boolean, boolean, boolean)} 2672 */ 2673 boolean removeTaskByIdLocked(int taskId, boolean killProcess, boolean removeFromRecents) { 2674 return removeTaskByIdLocked(taskId, killProcess, removeFromRecents, !PAUSE_IMMEDIATELY); 2675 } 2676 2677 /** 2678 * Removes the task with the specified task id. 2679 * 2680 * @param taskId Identifier of the task to be removed. 2681 * @param killProcess Kill any process associated with the task if possible. 2682 * @param removeFromRecents Whether to also remove the task from recents. 2683 * @param pauseImmediately Pauses all task activities immediately without waiting for the 2684 * pause-complete callback from the activity. 2685 * @return Returns true if the given task was found and removed. 2686 */ 2687 boolean removeTaskByIdLocked(int taskId, boolean killProcess, boolean removeFromRecents, 2688 boolean pauseImmediately) { 2689 final TaskRecord tr = anyTaskForIdLocked(taskId, MATCH_TASK_IN_STACKS_OR_RECENT_TASKS, 2690 INVALID_STACK_ID); 2691 if (tr != null) { 2692 tr.removeTaskActivitiesLocked(pauseImmediately); 2693 cleanUpRemovedTaskLocked(tr, killProcess, removeFromRecents); 2694 if (tr.isPersistable) { 2695 mService.notifyTaskPersisterLocked(null, true); 2696 } 2697 return true; 2698 } 2699 Slog.w(TAG, "Request to remove task ignored for non-existent task " + taskId); 2700 return false; 2701 } 2702 2703 void cleanUpRemovedTaskLocked(TaskRecord tr, boolean killProcess, boolean removeFromRecents) { 2704 if (removeFromRecents) { 2705 mRecentTasks.remove(tr); 2706 tr.removedFromRecents(); 2707 } 2708 ComponentName component = tr.getBaseIntent().getComponent(); 2709 if (component == null) { 2710 Slog.w(TAG, "No component for base intent of task: " + tr); 2711 return; 2712 } 2713 2714 // Find any running services associated with this app and stop if needed. 2715 mService.mServices.cleanUpRemovedTaskLocked(tr, component, new Intent(tr.getBaseIntent())); 2716 2717 if (!killProcess) { 2718 return; 2719 } 2720 2721 // Determine if the process(es) for this task should be killed. 2722 final String pkg = component.getPackageName(); 2723 ArrayList<ProcessRecord> procsToKill = new ArrayList<>(); 2724 ArrayMap<String, SparseArray<ProcessRecord>> pmap = mService.mProcessNames.getMap(); 2725 for (int i = 0; i < pmap.size(); i++) { 2726 2727 SparseArray<ProcessRecord> uids = pmap.valueAt(i); 2728 for (int j = 0; j < uids.size(); j++) { 2729 ProcessRecord proc = uids.valueAt(j); 2730 if (proc.userId != tr.userId) { 2731 // Don't kill process for a different user. 2732 continue; 2733 } 2734 if (proc == mService.mHomeProcess) { 2735 // Don't kill the home process along with tasks from the same package. 2736 continue; 2737 } 2738 if (!proc.pkgList.containsKey(pkg)) { 2739 // Don't kill process that is not associated with this task. 2740 continue; 2741 } 2742 2743 for (int k = 0; k < proc.activities.size(); k++) { 2744 TaskRecord otherTask = proc.activities.get(k).getTask(); 2745 if (tr.taskId != otherTask.taskId && otherTask.inRecents) { 2746 // Don't kill process(es) that has an activity in a different task that is 2747 // also in recents. 2748 return; 2749 } 2750 } 2751 2752 if (proc.foregroundServices) { 2753 // Don't kill process(es) with foreground service. 2754 return; 2755 } 2756 2757 // Add process to kill list. 2758 procsToKill.add(proc); 2759 } 2760 } 2761 2762 // Kill the running processes. 2763 for (int i = 0; i < procsToKill.size(); i++) { 2764 ProcessRecord pr = procsToKill.get(i); 2765 if (pr.setSchedGroup == ProcessList.SCHED_GROUP_BACKGROUND 2766 && pr.curReceivers.isEmpty()) { 2767 pr.kill("remove task", true); 2768 } else { 2769 // We delay killing processes that are not in the background or running a receiver. 2770 pr.waitingToKill = "remove task"; 2771 } 2772 } 2773 } 2774 2775 int getNextStackId() { 2776 while (true) { 2777 if (mNextFreeStackId >= FIRST_DYNAMIC_STACK_ID 2778 && getStack(mNextFreeStackId) == null) { 2779 break; 2780 } 2781 mNextFreeStackId++; 2782 } 2783 return mNextFreeStackId; 2784 } 2785 2786 /** 2787 * Restores a recent task to a stack 2788 * @param task The recent task to be restored. 2789 * @param stackId The stack to restore the task to (default launch stack will be used 2790 * if stackId is {@link android.app.ActivityManager.StackId#INVALID_STACK_ID} 2791 * or is not a static stack). 2792 * @return true if the task has been restored successfully. 2793 */ 2794 boolean restoreRecentTaskLocked(TaskRecord task, int stackId) { 2795 if (!StackId.isStaticStack(stackId)) { 2796 // If stack is not static (or stack id is invalid) - use the default one. 2797 // This means that tasks that were on external displays will be restored on the 2798 // primary display. 2799 stackId = task.getLaunchStackId(); 2800 } else if (stackId == DOCKED_STACK_ID && !task.supportsSplitScreen()) { 2801 // Preferred stack is the docked stack, but the task can't go in the docked stack. 2802 // Put it in the fullscreen stack. 2803 stackId = FULLSCREEN_WORKSPACE_STACK_ID; 2804 } 2805 2806 final ActivityStack currentStack = task.getStack(); 2807 if (currentStack != null) { 2808 // Task has already been restored once. See if we need to do anything more 2809 if (currentStack.mStackId == stackId) { 2810 // Nothing else to do since it is already restored in the right stack. 2811 return true; 2812 } 2813 // Remove current stack association, so we can re-associate the task with the 2814 // right stack below. 2815 currentStack.removeTask(task, "restoreRecentTaskLocked", REMOVE_TASK_MODE_MOVING); 2816 } 2817 2818 final ActivityStack stack = 2819 getStack(stackId, CREATE_IF_NEEDED, !ON_TOP); 2820 2821 if (stack == null) { 2822 // What does this mean??? Not sure how we would get here... 2823 if (DEBUG_RECENTS) Slog.v(TAG_RECENTS, 2824 "Unable to find/create stack to restore recent task=" + task); 2825 return false; 2826 } 2827 2828 stack.addTask(task, false /* toTop */, "restoreRecentTask"); 2829 // TODO: move call for creation here and other place into Stack.addTask() 2830 task.createWindowContainer(false /* toTop */, true /* showForAllUsers */); 2831 if (DEBUG_RECENTS) Slog.v(TAG_RECENTS, 2832 "Added restored task=" + task + " to stack=" + stack); 2833 final ArrayList<ActivityRecord> activities = task.mActivities; 2834 for (int activityNdx = activities.size() - 1; activityNdx >= 0; --activityNdx) { 2835 activities.get(activityNdx).createWindowContainer(); 2836 } 2837 return true; 2838 } 2839 2840 /** 2841 * Move stack with all its existing content to specified display. 2842 * @param stackId Id of stack to move. 2843 * @param displayId Id of display to move stack to. 2844 * @param onTop Indicates whether container should be place on top or on bottom. 2845 */ 2846 void moveStackToDisplayLocked(int stackId, int displayId, boolean onTop) { 2847 final ActivityDisplay activityDisplay = getActivityDisplayOrCreateLocked(displayId); 2848 if (activityDisplay == null) { 2849 throw new IllegalArgumentException("moveStackToDisplayLocked: Unknown displayId=" 2850 + displayId); 2851 } 2852 final ActivityContainer activityContainer = mActivityContainers.get(stackId); 2853 if (activityContainer != null) { 2854 if (activityContainer.isAttachedLocked()) { 2855 if (activityContainer.getDisplayId() == displayId) { 2856 throw new IllegalArgumentException("Trying to move stackId=" + stackId 2857 + " to its current displayId=" + displayId); 2858 } 2859 2860 activityContainer.moveToDisplayLocked(activityDisplay, onTop); 2861 } else { 2862 throw new IllegalStateException("moveStackToDisplayLocked: Stack with stackId=" 2863 + stackId + " is not attached to any display."); 2864 } 2865 } else { 2866 throw new IllegalArgumentException("moveStackToDisplayLocked: Unknown stackId=" 2867 + stackId); 2868 } 2869 // TODO(multi-display): resize stacks properly if moved from split-screen. 2870 } 2871 2872 /** 2873 * Returns the reparent target stack, creating the stack if necessary. This call also enforces 2874 * the various checks on tasks that are going to be reparented from one stack to another. 2875 */ 2876 ActivityStack getReparentTargetStack(TaskRecord task, int stackId, boolean toTop) { 2877 final ActivityStack prevStack = task.getStack(); 2878 2879 // Check that we aren't reparenting to the same stack that the task is already in 2880 if (prevStack != null && prevStack.mStackId == stackId) { 2881 Slog.w(TAG, "Can not reparent to same stack, task=" + task 2882 + " already in stackId=" + stackId); 2883 return prevStack; 2884 } 2885 2886 // Ensure that we aren't trying to move into a multi-window stack without multi-window 2887 // support 2888 if (StackId.isMultiWindowStack(stackId) && !mService.mSupportsMultiWindow) { 2889 throw new IllegalArgumentException("Device doesn't support multi-window, can not" 2890 + " reparent task=" + task + " to stackId=" + stackId); 2891 } 2892 2893 // Ensure that we're not moving a task to a dynamic stack if device doesn't support 2894 // multi-display. 2895 // TODO(multi-display): Support non-dynamic stacks on secondary displays. 2896 // TODO: Check ActivityView after fixing b/35349678. 2897 if (StackId.isDynamicStack(stackId) && !mService.mSupportsMultiDisplay) { 2898 throw new IllegalArgumentException("Device doesn't support multi-display, can not" 2899 + " reparent task=" + task + " to stackId=" + stackId); 2900 } 2901 2902 // Ensure that we aren't trying to move into a freeform stack without freeform 2903 // support 2904 if (stackId == FREEFORM_WORKSPACE_STACK_ID && !mService.mSupportsFreeformWindowManagement) { 2905 throw new IllegalArgumentException("Device doesn't support freeform, can not reparent" 2906 + " task=" + task); 2907 } 2908 2909 // We don't allow moving a unresizeable task to the docked stack since the docked stack is 2910 // used for split-screen mode and will cause things like the docked divider to show up. We 2911 // instead leave the task in its current stack or move it to the fullscreen stack if it 2912 // isn't currently in a stack. 2913 if (stackId == DOCKED_STACK_ID && !task.isResizeable()) { 2914 stackId = (prevStack != null) ? prevStack.mStackId : FULLSCREEN_WORKSPACE_STACK_ID; 2915 Slog.w(TAG, "Can not move unresizeable task=" + task + " to docked stack." 2916 + " Moving to stackId=" + stackId + " instead."); 2917 } 2918 2919 // Temporarily disable resizeablility of the task as we don't want it to be resized if, for 2920 // example, a docked stack is created which will lead to the stack we are moving from being 2921 // resized and and its resizeable tasks being resized. 2922 try { 2923 task.mTemporarilyUnresizable = true; 2924 return getStack(stackId, CREATE_IF_NEEDED, toTop); 2925 } finally { 2926 task.mTemporarilyUnresizable = false; 2927 } 2928 } 2929 2930 boolean moveTopStackActivityToPinnedStackLocked(int stackId, Rect destBounds) { 2931 final ActivityStack stack = getStack(stackId, !CREATE_IF_NEEDED, !ON_TOP); 2932 if (stack == null) { 2933 throw new IllegalArgumentException( 2934 "moveTopStackActivityToPinnedStackLocked: Unknown stackId=" + stackId); 2935 } 2936 2937 final ActivityRecord r = stack.topRunningActivityLocked(); 2938 if (r == null) { 2939 Slog.w(TAG, "moveTopStackActivityToPinnedStackLocked: No top running activity" 2940 + " in stack=" + stack); 2941 return false; 2942 } 2943 2944 if (!mService.mForceResizableActivities && !r.supportsPictureInPicture()) { 2945 Slog.w(TAG, 2946 "moveTopStackActivityToPinnedStackLocked: Picture-In-Picture not supported for " 2947 + " r=" + r); 2948 return false; 2949 } 2950 2951 moveActivityToPinnedStackLocked(r, null /* sourceBounds */, 0f /* aspectRatio */, 2952 true /* moveHomeStackToFront */, "moveTopActivityToPinnedStack"); 2953 return true; 2954 } 2955 2956 void moveActivityToPinnedStackLocked(ActivityRecord r, Rect sourceHintBounds, float aspectRatio, 2957 boolean moveHomeStackToFront, String reason) { 2958 2959 mWindowManager.deferSurfaceLayout(); 2960 2961 // This will clear the pinned stack by moving an existing task to the full screen stack, 2962 // ensuring only one task is present. 2963 moveTasksToFullscreenStackLocked(PINNED_STACK_ID, !ON_TOP); 2964 2965 // Need to make sure the pinned stack exist so we can resize it below... 2966 final PinnedActivityStack stack = getStack(PINNED_STACK_ID, CREATE_IF_NEEDED, ON_TOP); 2967 2968 try { 2969 final TaskRecord task = r.getTask(); 2970 2971 if (r == task.getStack().getVisibleBehindActivity()) { 2972 // An activity can't be pinned and visible behind at the same time. Go ahead and 2973 // release it from been visible behind before pinning. 2974 requestVisibleBehindLocked(r, false); 2975 } 2976 2977 // Resize the pinned stack to match the current size of the task the activity we are 2978 // going to be moving is currently contained in. We do this to have the right starting 2979 // animation bounds for the pinned stack to the desired bounds the caller wants. 2980 resizeStackLocked(PINNED_STACK_ID, task.mBounds, null /* tempTaskBounds */, 2981 null /* tempTaskInsetBounds */, !PRESERVE_WINDOWS, 2982 true /* allowResizeInDockedMode */, !DEFER_RESUME); 2983 2984 if (task.mActivities.size() == 1) { 2985 // There is only one activity in the task. So, we can just move the task over to 2986 // the stack without re-parenting the activity in a different task. We don't 2987 // move the home stack forward if we are currently entering picture-in-picture 2988 // while pausing because that changes the focused stack and may prevent the new 2989 // starting activity from resuming. 2990 if (moveHomeStackToFront && task.getTaskToReturnTo() == HOME_ACTIVITY_TYPE 2991 && (r.state == RESUMED || !r.supportsPictureInPictureWhilePausing)) { 2992 // Move the home stack forward if the task we just moved to the pinned stack 2993 // was launched from home so home should be visible behind it. 2994 moveHomeStackToFront(reason); 2995 } 2996 // Defer resume until below, and do not schedule PiP changes until we animate below 2997 task.reparent(PINNED_STACK_ID, ON_TOP, REPARENT_MOVE_STACK_TO_FRONT, !ANIMATE, 2998 DEFER_RESUME, false /* schedulePictureInPictureModeChange */, reason); 2999 } else { 3000 // There are multiple activities in the task and moving the top activity should 3001 // reveal/leave the other activities in their original task. 3002 3003 // Currently, we don't support reparenting activities across tasks in two different 3004 // stacks, so instead, just create a new task in the same stack, reparent the 3005 // activity into that task, and then reparent the whole task to the new stack. This 3006 // ensures that all the necessary work to migrate states in the old and new stacks 3007 // is also done. 3008 final TaskRecord newTask = task.getStack().createTaskRecord( 3009 getNextTaskIdForUserLocked(r.userId), r.info, r.intent, null, null, true, 3010 r.mActivityType); 3011 r.reparent(newTask, MAX_VALUE, "moveActivityToStack"); 3012 3013 // Defer resume until below, and do not schedule PiP changes until we animate below 3014 newTask.reparent(PINNED_STACK_ID, ON_TOP, REPARENT_MOVE_STACK_TO_FRONT, !ANIMATE, 3015 DEFER_RESUME, false /* schedulePictureInPictureModeChange */, reason); 3016 } 3017 3018 // Reset the state that indicates it can enter PiP while pausing after we've moved it 3019 // to the pinned stack 3020 r.supportsPictureInPictureWhilePausing = false; 3021 } finally { 3022 mWindowManager.continueSurfaceLayout(); 3023 } 3024 3025 // Calculate the default bounds (don't use existing stack bounds as we may have just created 3026 // the stack, and schedule the start of the animation into PiP (the bounds animator that 3027 // is triggered by this is posted on another thread) 3028 final Rect destBounds = stack.getDefaultPictureInPictureBounds(aspectRatio); 3029 3030 stack.animateResizePinnedStack(sourceHintBounds, destBounds, -1 /* animationDuration */, 3031 true /* fromFullscreen */); 3032 3033 // Update the visibility of all activities after the they have been reparented to the new 3034 // stack. This MUST run after the animation above is scheduled to ensure that the windows 3035 // drawn signal is scheduled after the bounds animation start call on the bounds animator 3036 // thread. 3037 ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS); 3038 resumeFocusedStackTopActivityLocked(); 3039 3040 mService.mTaskChangeNotificationController.notifyActivityPinned(r.packageName, 3041 r.getTask().taskId); 3042 } 3043 3044 /** Move activity with its stack to front and make the stack focused. */ 3045 boolean moveFocusableActivityStackToFrontLocked(ActivityRecord r, String reason) { 3046 if (r == null || !r.isFocusable()) { 3047 if (DEBUG_FOCUS) Slog.d(TAG_FOCUS, 3048 "moveActivityStackToFront: unfocusable r=" + r); 3049 return false; 3050 } 3051 3052 final TaskRecord task = r.getTask(); 3053 final ActivityStack stack = r.getStack(); 3054 if (stack == null) { 3055 Slog.w(TAG, "moveActivityStackToFront: invalid task or stack: r=" 3056 + r + " task=" + task); 3057 return false; 3058 } 3059 3060 if (stack == mFocusedStack && stack.topRunningActivityLocked() == r) { 3061 if (DEBUG_FOCUS) Slog.d(TAG_FOCUS, 3062 "moveActivityStackToFront: already on top, r=" + r); 3063 return false; 3064 } 3065 3066 if (DEBUG_FOCUS) Slog.d(TAG_FOCUS, 3067 "moveActivityStackToFront: r=" + r); 3068 3069 stack.moveToFront(reason, task); 3070 return true; 3071 } 3072 3073 ActivityRecord findTaskLocked(ActivityRecord r, int displayId) { 3074 mTmpFindTaskResult.r = null; 3075 mTmpFindTaskResult.matchedByRootAffinity = false; 3076 ActivityRecord affinityMatch = null; 3077 if (DEBUG_TASKS) Slog.d(TAG_TASKS, "Looking for task of " + r); 3078 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 3079 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 3080 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 3081 final ActivityStack stack = stacks.get(stackNdx); 3082 if (!checkActivityBelongsInStack(r, stack)) { 3083 if (DEBUG_TASKS) Slog.d(TAG_TASKS, "Skipping stack: (mismatch activity/stack) " 3084 + stack); 3085 continue; 3086 } 3087 if (!stack.mActivityContainer.isEligibleForNewTasks()) { 3088 if (DEBUG_TASKS) Slog.d(TAG_TASKS, 3089 "Skipping stack: (new task not allowed) " + stack); 3090 continue; 3091 } 3092 stack.findTaskLocked(r, mTmpFindTaskResult); 3093 // It is possible to have tasks in multiple stacks with the same root affinity, so 3094 // we should keep looking after finding an affinity match to see if there is a 3095 // better match in another stack. Also, task affinity isn't a good enough reason 3096 // to target a display which isn't the source of the intent, so skip any affinity 3097 // matches not on the specified display. 3098 if (mTmpFindTaskResult.r != null) { 3099 if (!mTmpFindTaskResult.matchedByRootAffinity) { 3100 return mTmpFindTaskResult.r; 3101 } else if (mTmpFindTaskResult.r.getDisplayId() == displayId) { 3102 // Note: since the traversing through the stacks is top down, the floating 3103 // tasks should always have lower priority than any affinity-matching tasks 3104 // in the fullscreen stacks 3105 affinityMatch = mTmpFindTaskResult.r; 3106 } 3107 } 3108 } 3109 } 3110 3111 if (DEBUG_TASKS && affinityMatch == null) Slog.d(TAG_TASKS, "No task found"); 3112 return affinityMatch; 3113 } 3114 3115 /** 3116 * Checks that for the given activity {@param r}, its activity type matches the {@param stack} 3117 * type. 3118 */ 3119 private boolean checkActivityBelongsInStack(ActivityRecord r, ActivityStack stack) { 3120 if (r.isHomeActivity()) { 3121 return stack.isHomeStack(); 3122 } else if (r.isRecentsActivity()) { 3123 return stack.isRecentsStack(); 3124 } else if (r.isAssistantActivity()) { 3125 return stack.isAssistantStack(); 3126 } 3127 return true; 3128 } 3129 3130 ActivityRecord findActivityLocked(Intent intent, ActivityInfo info, 3131 boolean compareIntentFilters) { 3132 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 3133 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 3134 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 3135 final ActivityRecord ar = stacks.get(stackNdx) 3136 .findActivityLocked(intent, info, compareIntentFilters); 3137 if (ar != null) { 3138 return ar; 3139 } 3140 } 3141 } 3142 return null; 3143 } 3144 3145 void goingToSleepLocked() { 3146 scheduleSleepTimeout(); 3147 if (!mGoingToSleep.isHeld()) { 3148 mGoingToSleep.acquire(); 3149 if (mLaunchingActivity.isHeld()) { 3150 if (VALIDATE_WAKE_LOCK_CALLER && Binder.getCallingUid() != Process.myUid()) { 3151 throw new IllegalStateException("Calling must be system uid"); 3152 } 3153 mLaunchingActivity.release(); 3154 mService.mHandler.removeMessages(LAUNCH_TIMEOUT_MSG); 3155 } 3156 } 3157 checkReadyForSleepLocked(); 3158 } 3159 3160 boolean shutdownLocked(int timeout) { 3161 goingToSleepLocked(); 3162 3163 boolean timedout = false; 3164 final long endTime = System.currentTimeMillis() + timeout; 3165 while (true) { 3166 boolean cantShutdown = false; 3167 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 3168 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 3169 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 3170 cantShutdown |= stacks.get(stackNdx).checkReadyForSleepLocked(); 3171 } 3172 } 3173 if (cantShutdown) { 3174 long timeRemaining = endTime - System.currentTimeMillis(); 3175 if (timeRemaining > 0) { 3176 try { 3177 mService.wait(timeRemaining); 3178 } catch (InterruptedException e) { 3179 } 3180 } else { 3181 Slog.w(TAG, "Activity manager shutdown timed out"); 3182 timedout = true; 3183 break; 3184 } 3185 } else { 3186 break; 3187 } 3188 } 3189 3190 // Force checkReadyForSleep to complete. 3191 mSleepTimeout = true; 3192 checkReadyForSleepLocked(); 3193 3194 return timedout; 3195 } 3196 3197 void comeOutOfSleepIfNeededLocked() { 3198 removeSleepTimeouts(); 3199 if (mGoingToSleep.isHeld()) { 3200 mGoingToSleep.release(); 3201 } 3202 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 3203 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 3204 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 3205 final ActivityStack stack = stacks.get(stackNdx); 3206 stack.awakeFromSleepingLocked(); 3207 if (isFocusedStack(stack)) { 3208 resumeFocusedStackTopActivityLocked(); 3209 } 3210 } 3211 } 3212 mGoingToSleepActivities.clear(); 3213 } 3214 3215 void activitySleptLocked(ActivityRecord r) { 3216 mGoingToSleepActivities.remove(r); 3217 checkReadyForSleepLocked(); 3218 } 3219 3220 void checkReadyForSleepLocked() { 3221 if (!mService.isSleepingOrShuttingDownLocked()) { 3222 // Do not care. 3223 return; 3224 } 3225 3226 if (!mSleepTimeout) { 3227 boolean dontSleep = false; 3228 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 3229 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 3230 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 3231 dontSleep |= stacks.get(stackNdx).checkReadyForSleepLocked(); 3232 } 3233 } 3234 3235 if (mStoppingActivities.size() > 0) { 3236 // Still need to tell some activities to stop; can't sleep yet. 3237 if (DEBUG_PAUSE) Slog.v(TAG_PAUSE, "Sleep still need to stop " 3238 + mStoppingActivities.size() + " activities"); 3239 scheduleIdleLocked(); 3240 dontSleep = true; 3241 } 3242 3243 if (mGoingToSleepActivities.size() > 0) { 3244 // Still need to tell some activities to sleep; can't sleep yet. 3245 if (DEBUG_PAUSE) Slog.v(TAG_PAUSE, "Sleep still need to sleep " 3246 + mGoingToSleepActivities.size() + " activities"); 3247 dontSleep = true; 3248 } 3249 3250 if (dontSleep) { 3251 return; 3252 } 3253 } 3254 3255 // Send launch end powerhint before going sleep 3256 mService.mActivityStarter.sendPowerHintForLaunchEndIfNeeded(); 3257 3258 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 3259 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 3260 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 3261 stacks.get(stackNdx).goToSleep(); 3262 } 3263 } 3264 3265 removeSleepTimeouts(); 3266 3267 if (mGoingToSleep.isHeld()) { 3268 mGoingToSleep.release(); 3269 } 3270 if (mService.mShuttingDown) { 3271 mService.notifyAll(); 3272 } 3273 } 3274 3275 boolean reportResumedActivityLocked(ActivityRecord r) { 3276 final ActivityStack stack = r.getStack(); 3277 if (isFocusedStack(stack)) { 3278 mService.updateUsageStats(r, true); 3279 } 3280 if (allResumedActivitiesComplete()) { 3281 ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS); 3282 mWindowManager.executeAppTransition(); 3283 return true; 3284 } 3285 return false; 3286 } 3287 3288 void handleAppCrashLocked(ProcessRecord app) { 3289 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 3290 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 3291 int stackNdx = stacks.size() - 1; 3292 while (stackNdx >= 0) { 3293 stacks.get(stackNdx).handleAppCrashLocked(app); 3294 stackNdx--; 3295 } 3296 } 3297 } 3298 3299 boolean requestVisibleBehindLocked(ActivityRecord r, boolean visible) { 3300 final ActivityStack stack = r.getStack(); 3301 if (stack == null) { 3302 if (DEBUG_VISIBLE_BEHIND) Slog.d(TAG_VISIBLE_BEHIND, 3303 "requestVisibleBehind: r=" + r + " visible=" + visible + " stack is null"); 3304 return false; 3305 } 3306 3307 if (visible && !StackId.activitiesCanRequestVisibleBehind(stack.mStackId)) { 3308 if (DEBUG_VISIBLE_BEHIND) Slog.d(TAG_VISIBLE_BEHIND, "requestVisibleBehind: r=" + r 3309 + " visible=" + visible + " stackId=" + stack.mStackId 3310 + " can't contain visible behind activities"); 3311 return false; 3312 } 3313 3314 final boolean isVisible = stack.hasVisibleBehindActivity(); 3315 if (DEBUG_VISIBLE_BEHIND) Slog.d(TAG_VISIBLE_BEHIND, 3316 "requestVisibleBehind r=" + r + " visible=" + visible + " isVisible=" + isVisible); 3317 3318 final ActivityRecord top = topRunningActivityLocked(); 3319 if (top == null || top == r || (visible == isVisible)) { 3320 if (DEBUG_VISIBLE_BEHIND) Slog.d(TAG_VISIBLE_BEHIND, "requestVisibleBehind: quick return"); 3321 stack.setVisibleBehindActivity(visible ? r : null); 3322 return true; 3323 } 3324 3325 // A non-top activity is reporting a visibility change. 3326 if (visible && top.fullscreen) { 3327 // Let the caller know that it can't be seen. 3328 if (DEBUG_VISIBLE_BEHIND) Slog.d(TAG_VISIBLE_BEHIND, 3329 "requestVisibleBehind: returning top.fullscreen=" + top.fullscreen 3330 + " top.state=" + top.state + " top.app=" + top.app + " top.app.thread=" 3331 + top.app.thread); 3332 return false; 3333 } else if (!visible && stack.getVisibleBehindActivity() != r) { 3334 // Only the activity set as currently visible behind should actively reset its 3335 // visible behind state. 3336 if (DEBUG_VISIBLE_BEHIND) Slog.d(TAG_VISIBLE_BEHIND, 3337 "requestVisibleBehind: returning visible=" + visible 3338 + " stack.getVisibleBehindActivity()=" + stack.getVisibleBehindActivity() 3339 + " r=" + r); 3340 return false; 3341 } 3342 3343 stack.setVisibleBehindActivity(visible ? r : null); 3344 if (!visible) { 3345 // If there is a translucent home activity, we need to force it stop being translucent, 3346 // because we can't depend on the application to necessarily perform that operation. 3347 // Check out b/14469711 for details. 3348 final ActivityRecord next = stack.findNextTranslucentActivity(r); 3349 if (next != null && next.isHomeActivity()) { 3350 mService.convertFromTranslucent(next.appToken); 3351 } 3352 } 3353 if (top.app != null && top.app.thread != null) { 3354 // Notify the top app of the change. 3355 try { 3356 top.app.thread.scheduleBackgroundVisibleBehindChanged(top.appToken, visible); 3357 } catch (RemoteException e) { 3358 } 3359 } 3360 return true; 3361 } 3362 3363 // Called when WindowManager has finished animating the launchingBehind activity to the back. 3364 private void handleLaunchTaskBehindCompleteLocked(ActivityRecord r) { 3365 final TaskRecord task = r.getTask(); 3366 final ActivityStack stack = task.getStack(); 3367 3368 r.mLaunchTaskBehind = false; 3369 task.setLastThumbnailLocked(r.screenshotActivityLocked()); 3370 mRecentTasks.addLocked(task); 3371 mService.mTaskChangeNotificationController.notifyTaskStackChanged(); 3372 r.setVisibility(false); 3373 3374 // When launching tasks behind, update the last active time of the top task after the new 3375 // task has been shown briefly 3376 final ActivityRecord top = stack.topActivity(); 3377 if (top != null) { 3378 top.getTask().touchActiveTime(); 3379 } 3380 } 3381 3382 void scheduleLaunchTaskBehindComplete(IBinder token) { 3383 mHandler.obtainMessage(LAUNCH_TASK_BEHIND_COMPLETE, token).sendToTarget(); 3384 } 3385 3386 void ensureActivitiesVisibleLocked(ActivityRecord starting, int configChanges, 3387 boolean preserveWindows) { 3388 mKeyguardController.beginActivityVisibilityUpdate(); 3389 try { 3390 // First the front stacks. In case any are not fullscreen and are in front of home. 3391 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 3392 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 3393 final int topStackNdx = stacks.size() - 1; 3394 for (int stackNdx = topStackNdx; stackNdx >= 0; --stackNdx) { 3395 final ActivityStack stack = stacks.get(stackNdx); 3396 stack.ensureActivitiesVisibleLocked(starting, configChanges, preserveWindows); 3397 } 3398 } 3399 } finally { 3400 mKeyguardController.endActivityVisibilityUpdate(); 3401 } 3402 } 3403 3404 void addStartingWindowsForVisibleActivities(boolean taskSwitch) { 3405 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 3406 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 3407 final int topStackNdx = stacks.size() - 1; 3408 for (int stackNdx = topStackNdx; stackNdx >= 0; --stackNdx) { 3409 final ActivityStack stack = stacks.get(stackNdx); 3410 stack.addStartingWindowsForVisibleActivities(taskSwitch); 3411 } 3412 } 3413 } 3414 3415 void invalidateTaskLayers() { 3416 mTaskLayersChanged = true; 3417 } 3418 3419 void rankTaskLayersIfNeeded() { 3420 if (!mTaskLayersChanged) { 3421 return; 3422 } 3423 mTaskLayersChanged = false; 3424 for (int displayNdx = 0; displayNdx < mActivityDisplays.size(); displayNdx++) { 3425 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 3426 int baseLayer = 0; 3427 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 3428 baseLayer += stacks.get(stackNdx).rankTaskLayers(baseLayer); 3429 } 3430 } 3431 } 3432 3433 void clearOtherAppTimeTrackers(AppTimeTracker except) { 3434 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 3435 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 3436 final int topStackNdx = stacks.size() - 1; 3437 for (int stackNdx = topStackNdx; stackNdx >= 0; --stackNdx) { 3438 final ActivityStack stack = stacks.get(stackNdx); 3439 stack.clearOtherAppTimeTrackers(except); 3440 } 3441 } 3442 } 3443 3444 void scheduleDestroyAllActivities(ProcessRecord app, String reason) { 3445 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 3446 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 3447 final int numStacks = stacks.size(); 3448 for (int stackNdx = 0; stackNdx < numStacks; ++stackNdx) { 3449 final ActivityStack stack = stacks.get(stackNdx); 3450 stack.scheduleDestroyActivities(app, reason); 3451 } 3452 } 3453 } 3454 3455 void releaseSomeActivitiesLocked(ProcessRecord app, String reason) { 3456 // Examine all activities currently running in the process. 3457 TaskRecord firstTask = null; 3458 // Tasks is non-null only if two or more tasks are found. 3459 ArraySet<TaskRecord> tasks = null; 3460 if (DEBUG_RELEASE) Slog.d(TAG_RELEASE, "Trying to release some activities in " + app); 3461 for (int i = 0; i < app.activities.size(); i++) { 3462 ActivityRecord r = app.activities.get(i); 3463 // First, if we find an activity that is in the process of being destroyed, 3464 // then we just aren't going to do anything for now; we want things to settle 3465 // down before we try to prune more activities. 3466 if (r.finishing || r.state == DESTROYING || r.state == DESTROYED) { 3467 if (DEBUG_RELEASE) Slog.d(TAG_RELEASE, "Abort release; already destroying: " + r); 3468 return; 3469 } 3470 // Don't consider any activies that are currently not in a state where they 3471 // can be destroyed. 3472 if (r.visible || !r.stopped || !r.haveState || r.state == RESUMED || r.state == PAUSING 3473 || r.state == PAUSED || r.state == STOPPING) { 3474 if (DEBUG_RELEASE) Slog.d(TAG_RELEASE, "Not releasing in-use activity: " + r); 3475 continue; 3476 } 3477 3478 final TaskRecord task = r.getTask(); 3479 if (task != null) { 3480 if (DEBUG_RELEASE) Slog.d(TAG_RELEASE, "Collecting release task " + task 3481 + " from " + r); 3482 if (firstTask == null) { 3483 firstTask = task; 3484 } else if (firstTask != task) { 3485 if (tasks == null) { 3486 tasks = new ArraySet<>(); 3487 tasks.add(firstTask); 3488 } 3489 tasks.add(task); 3490 } 3491 } 3492 } 3493 if (tasks == null) { 3494 if (DEBUG_RELEASE) Slog.d(TAG_RELEASE, "Didn't find two or more tasks to release"); 3495 return; 3496 } 3497 // If we have activities in multiple tasks that are in a position to be destroyed, 3498 // let's iterate through the tasks and release the oldest one. 3499 final int numDisplays = mActivityDisplays.size(); 3500 for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) { 3501 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 3502 // Step through all stacks starting from behind, to hit the oldest things first. 3503 for (int stackNdx = 0; stackNdx < stacks.size(); stackNdx++) { 3504 final ActivityStack stack = stacks.get(stackNdx); 3505 // Try to release activities in this stack; if we manage to, we are done. 3506 if (stack.releaseSomeActivitiesLocked(app, tasks, reason) > 0) { 3507 return; 3508 } 3509 } 3510 } 3511 } 3512 3513 boolean switchUserLocked(int userId, UserState uss) { 3514 final int focusStackId = mFocusedStack.getStackId(); 3515 // We dismiss the docked stack whenever we switch users. 3516 moveTasksToFullscreenStackLocked(DOCKED_STACK_ID, focusStackId == DOCKED_STACK_ID); 3517 // Also dismiss the pinned stack whenever we switch users. Removing the pinned stack will 3518 // also cause all tasks to be moved to the fullscreen stack at a position that is 3519 // appropriate. 3520 removeStackLocked(PINNED_STACK_ID); 3521 3522 mUserStackInFront.put(mCurrentUser, focusStackId); 3523 final int restoreStackId = mUserStackInFront.get(userId, HOME_STACK_ID); 3524 mCurrentUser = userId; 3525 3526 mStartingUsers.add(uss); 3527 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 3528 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 3529 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 3530 final ActivityStack stack = stacks.get(stackNdx); 3531 stack.switchUserLocked(userId); 3532 TaskRecord task = stack.topTask(); 3533 if (task != null) { 3534 stack.positionChildWindowContainerAtTop(task); 3535 } 3536 } 3537 } 3538 3539 ActivityStack stack = getStack(restoreStackId); 3540 if (stack == null) { 3541 stack = mHomeStack; 3542 } 3543 final boolean homeInFront = stack.isHomeStack(); 3544 if (stack.isOnHomeDisplay()) { 3545 stack.moveToFront("switchUserOnHomeDisplay"); 3546 } else { 3547 // Stack was moved to another display while user was swapped out. 3548 resumeHomeStackTask(null, "switchUserOnOtherDisplay"); 3549 } 3550 return homeInFront; 3551 } 3552 3553 /** Checks whether the userid is a profile of the current user. */ 3554 boolean isCurrentProfileLocked(int userId) { 3555 if (userId == mCurrentUser) return true; 3556 return mService.mUserController.isCurrentProfileLocked(userId); 3557 } 3558 3559 /** 3560 * Returns whether a stopping activity is present that should be stopped after visible, rather 3561 * than idle. 3562 * @return {@code true} if such activity is present. {@code false} otherwise. 3563 */ 3564 boolean isStoppingNoHistoryActivity() { 3565 // Activities that are marked as nohistory should be stopped immediately after the resumed 3566 // activity has become visible. 3567 for (ActivityRecord record : mStoppingActivities) { 3568 if (record.isNoHistory()) { 3569 return true; 3570 } 3571 } 3572 3573 return false; 3574 } 3575 3576 final ArrayList<ActivityRecord> processStoppingActivitiesLocked(ActivityRecord idleActivity, 3577 boolean remove, boolean processPausingActivities) { 3578 ArrayList<ActivityRecord> stops = null; 3579 3580 final boolean nowVisible = allResumedActivitiesVisible(); 3581 for (int activityNdx = mStoppingActivities.size() - 1; activityNdx >= 0; --activityNdx) { 3582 ActivityRecord s = mStoppingActivities.get(activityNdx); 3583 boolean waitingVisible = mActivitiesWaitingForVisibleActivity.contains(s); 3584 if (DEBUG_STATES) Slog.v(TAG, "Stopping " + s + ": nowVisible=" + nowVisible 3585 + " waitingVisible=" + waitingVisible + " finishing=" + s.finishing); 3586 if (waitingVisible && nowVisible) { 3587 mActivitiesWaitingForVisibleActivity.remove(s); 3588 waitingVisible = false; 3589 if (s.finishing) { 3590 // If this activity is finishing, it is sitting on top of 3591 // everyone else but we now know it is no longer needed... 3592 // so get rid of it. Otherwise, we need to go through the 3593 // normal flow and hide it once we determine that it is 3594 // hidden by the activities in front of it. 3595 if (DEBUG_STATES) Slog.v(TAG, "Before stopping, can hide: " + s); 3596 s.setVisibility(false); 3597 } 3598 } 3599 if ((!waitingVisible || mService.isSleepingOrShuttingDownLocked()) && remove) { 3600 if (!processPausingActivities && s.state == PAUSING) { 3601 // Defer processing pausing activities in this iteration and reschedule 3602 // a delayed idle to reprocess it again 3603 removeTimeoutsForActivityLocked(idleActivity); 3604 scheduleIdleTimeoutLocked(idleActivity); 3605 continue; 3606 } 3607 3608 if (DEBUG_STATES) Slog.v(TAG, "Ready to stop: " + s); 3609 if (stops == null) { 3610 stops = new ArrayList<>(); 3611 } 3612 stops.add(s); 3613 mStoppingActivities.remove(activityNdx); 3614 } 3615 } 3616 3617 return stops; 3618 } 3619 3620 void validateTopActivitiesLocked() { 3621 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 3622 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 3623 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 3624 final ActivityStack stack = stacks.get(stackNdx); 3625 final ActivityRecord r = stack.topRunningActivityLocked(); 3626 final ActivityState state = r == null ? DESTROYED : r.state; 3627 if (isFocusedStack(stack)) { 3628 if (r == null) Slog.e(TAG, 3629 "validateTop...: null top activity, stack=" + stack); 3630 else { 3631 final ActivityRecord pausing = stack.mPausingActivity; 3632 if (pausing != null && pausing == r) Slog.e(TAG, 3633 "validateTop...: top stack has pausing activity r=" + r 3634 + " state=" + state); 3635 if (state != INITIALIZING && state != RESUMED) Slog.e(TAG, 3636 "validateTop...: activity in front not resumed r=" + r 3637 + " state=" + state); 3638 } 3639 } else { 3640 final ActivityRecord resumed = stack.mResumedActivity; 3641 if (resumed != null && resumed == r) Slog.e(TAG, 3642 "validateTop...: back stack has resumed activity r=" + r 3643 + " state=" + state); 3644 if (r != null && (state == INITIALIZING || state == RESUMED)) Slog.e(TAG, 3645 "validateTop...: activity in back resumed r=" + r + " state=" + state); 3646 } 3647 } 3648 } 3649 } 3650 3651 private String lockTaskModeToString() { 3652 switch (mLockTaskModeState) { 3653 case LOCK_TASK_MODE_LOCKED: 3654 return "LOCKED"; 3655 case LOCK_TASK_MODE_PINNED: 3656 return "PINNED"; 3657 case LOCK_TASK_MODE_NONE: 3658 return "NONE"; 3659 default: return "unknown=" + mLockTaskModeState; 3660 } 3661 } 3662 3663 public void dump(PrintWriter pw, String prefix) { 3664 pw.print(prefix); pw.print("mFocusedStack=" + mFocusedStack); 3665 pw.print(" mLastFocusedStack="); pw.println(mLastFocusedStack); 3666 pw.print(prefix); pw.println("mSleepTimeout=" + mSleepTimeout); 3667 pw.print(prefix); 3668 pw.println("mCurTaskIdForUser=" + mCurTaskIdForUser); 3669 pw.print(prefix); pw.println("mUserStackInFront=" + mUserStackInFront); 3670 pw.print(prefix); pw.println("mActivityContainers=" + mActivityContainers); 3671 pw.print(prefix); pw.print("mLockTaskModeState=" + lockTaskModeToString()); 3672 final SparseArray<String[]> packages = mService.mLockTaskPackages; 3673 if (packages.size() > 0) { 3674 pw.print(prefix); pw.println("mLockTaskPackages (userId:packages)="); 3675 for (int i = 0; i < packages.size(); ++i) { 3676 pw.print(prefix); pw.print(prefix); pw.print(packages.keyAt(i)); 3677 pw.print(":"); pw.println(Arrays.toString(packages.valueAt(i))); 3678 } 3679 } 3680 if (!mWaitingForActivityVisible.isEmpty()) { 3681 pw.print(prefix); pw.println("mWaitingForActivityVisible="); 3682 for (int i = 0; i < mWaitingForActivityVisible.size(); ++i) { 3683 pw.print(prefix); pw.print(prefix); mWaitingForActivityVisible.get(i).dump(pw, prefix); 3684 } 3685 } 3686 3687 pw.println(" mLockTaskModeTasks" + mLockTaskModeTasks); 3688 mKeyguardController.dump(pw, prefix); 3689 } 3690 3691 /** 3692 * Dump all connected displays' configurations. 3693 * @param prefix Prefix to apply to each line of the dump. 3694 */ 3695 void dumpDisplayConfigs(PrintWriter pw, String prefix) { 3696 pw.print(prefix); pw.println("Display override configurations:"); 3697 final int displayCount = mActivityDisplays.size(); 3698 for (int i = 0; i < displayCount; i++) { 3699 final ActivityDisplay activityDisplay = mActivityDisplays.valueAt(i); 3700 pw.print(prefix); pw.print(" "); pw.print(activityDisplay.mDisplayId); pw.print(": "); 3701 pw.println(activityDisplay.getOverrideConfiguration()); 3702 } 3703 } 3704 3705 /** 3706 * Dumps the activities matching the given {@param name} in the either the focused stack 3707 * or all visible stacks if {@param dumpVisibleStacks} is true. 3708 */ 3709 ArrayList<ActivityRecord> getDumpActivitiesLocked(String name, boolean dumpVisibleStacksOnly, 3710 boolean dumpFocusedStackOnly) { 3711 if (dumpFocusedStackOnly) { 3712 return mFocusedStack.getDumpActivitiesLocked(name); 3713 } else { 3714 ArrayList<ActivityRecord> activities = new ArrayList<>(); 3715 int numDisplays = mActivityDisplays.size(); 3716 for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) { 3717 ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 3718 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 3719 ActivityStack stack = stacks.get(stackNdx); 3720 if (!dumpVisibleStacksOnly || 3721 stack.shouldBeVisible(null) == STACK_VISIBLE) { 3722 activities.addAll(stack.getDumpActivitiesLocked(name)); 3723 } 3724 } 3725 } 3726 return activities; 3727 } 3728 } 3729 3730 static boolean printThisActivity(PrintWriter pw, ActivityRecord activity, String dumpPackage, 3731 boolean needSep, String prefix) { 3732 if (activity != null) { 3733 if (dumpPackage == null || dumpPackage.equals(activity.packageName)) { 3734 if (needSep) { 3735 pw.println(); 3736 } 3737 pw.print(prefix); 3738 pw.println(activity); 3739 return true; 3740 } 3741 } 3742 return false; 3743 } 3744 3745 boolean dumpActivitiesLocked(FileDescriptor fd, PrintWriter pw, boolean dumpAll, 3746 boolean dumpClient, String dumpPackage) { 3747 boolean printed = false; 3748 boolean needSep = false; 3749 for (int displayNdx = 0; displayNdx < mActivityDisplays.size(); ++displayNdx) { 3750 ActivityDisplay activityDisplay = mActivityDisplays.valueAt(displayNdx); 3751 pw.print("Display #"); pw.print(activityDisplay.mDisplayId); 3752 pw.println(" (activities from top to bottom):"); 3753 ArrayList<ActivityStack> stacks = activityDisplay.mStacks; 3754 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 3755 final ActivityStack stack = stacks.get(stackNdx); 3756 StringBuilder stackHeader = new StringBuilder(128); 3757 stackHeader.append(" Stack #"); 3758 stackHeader.append(stack.mStackId); 3759 stackHeader.append(":"); 3760 stackHeader.append("\n"); 3761 stackHeader.append(" mFullscreen=" + stack.mFullscreen); 3762 stackHeader.append("\n"); 3763 stackHeader.append(" mBounds=" + stack.mBounds); 3764 3765 final boolean printedStackHeader = stack.dumpActivitiesLocked(fd, pw, dumpAll, 3766 dumpClient, dumpPackage, needSep, stackHeader.toString()); 3767 printed |= printedStackHeader; 3768 if (!printedStackHeader) { 3769 // Ensure we always dump the stack header even if there are no activities 3770 pw.println(); 3771 pw.println(stackHeader); 3772 } 3773 3774 printed |= dumpHistoryList(fd, pw, stack.mLRUActivities, " ", "Run", false, 3775 !dumpAll, false, dumpPackage, true, 3776 " Running activities (most recent first):", null); 3777 3778 needSep = printed; 3779 boolean pr = printThisActivity(pw, stack.mPausingActivity, dumpPackage, needSep, 3780 " mPausingActivity: "); 3781 if (pr) { 3782 printed = true; 3783 needSep = false; 3784 } 3785 pr = printThisActivity(pw, stack.mResumedActivity, dumpPackage, needSep, 3786 " mResumedActivity: "); 3787 if (pr) { 3788 printed = true; 3789 needSep = false; 3790 } 3791 if (dumpAll) { 3792 pr = printThisActivity(pw, stack.mLastPausedActivity, dumpPackage, needSep, 3793 " mLastPausedActivity: "); 3794 if (pr) { 3795 printed = true; 3796 needSep = true; 3797 } 3798 printed |= printThisActivity(pw, stack.mLastNoHistoryActivity, dumpPackage, 3799 needSep, " mLastNoHistoryActivity: "); 3800 } 3801 needSep = printed; 3802 } 3803 } 3804 3805 printed |= dumpHistoryList(fd, pw, mFinishingActivities, " ", "Fin", false, !dumpAll, 3806 false, dumpPackage, true, " Activities waiting to finish:", null); 3807 printed |= dumpHistoryList(fd, pw, mStoppingActivities, " ", "Stop", false, !dumpAll, 3808 false, dumpPackage, true, " Activities waiting to stop:", null); 3809 printed |= dumpHistoryList(fd, pw, mActivitiesWaitingForVisibleActivity, " ", "Wait", 3810 false, !dumpAll, false, dumpPackage, true, 3811 " Activities waiting for another to become visible:", null); 3812 printed |= dumpHistoryList(fd, pw, mGoingToSleepActivities, " ", "Sleep", false, !dumpAll, 3813 false, dumpPackage, true, " Activities waiting to sleep:", null); 3814 printed |= dumpHistoryList(fd, pw, mGoingToSleepActivities, " ", "Sleep", false, !dumpAll, 3815 false, dumpPackage, true, " Activities waiting to sleep:", null); 3816 3817 return printed; 3818 } 3819 3820 static boolean dumpHistoryList(FileDescriptor fd, PrintWriter pw, List<ActivityRecord> list, 3821 String prefix, String label, boolean complete, boolean brief, boolean client, 3822 String dumpPackage, boolean needNL, String header1, String header2) { 3823 TaskRecord lastTask = null; 3824 String innerPrefix = null; 3825 String[] args = null; 3826 boolean printed = false; 3827 for (int i=list.size()-1; i>=0; i--) { 3828 final ActivityRecord r = list.get(i); 3829 if (dumpPackage != null && !dumpPackage.equals(r.packageName)) { 3830 continue; 3831 } 3832 if (innerPrefix == null) { 3833 innerPrefix = prefix + " "; 3834 args = new String[0]; 3835 } 3836 printed = true; 3837 final boolean full = !brief && (complete || !r.isInHistory()); 3838 if (needNL) { 3839 pw.println(""); 3840 needNL = false; 3841 } 3842 if (header1 != null) { 3843 pw.println(header1); 3844 header1 = null; 3845 } 3846 if (header2 != null) { 3847 pw.println(header2); 3848 header2 = null; 3849 } 3850 if (lastTask != r.getTask()) { 3851 lastTask = r.getTask(); 3852 pw.print(prefix); 3853 pw.print(full ? "* " : " "); 3854 pw.println(lastTask); 3855 if (full) { 3856 lastTask.dump(pw, prefix + " "); 3857 } else if (complete) { 3858 // Complete + brief == give a summary. Isn't that obvious?!? 3859 if (lastTask.intent != null) { 3860 pw.print(prefix); pw.print(" "); 3861 pw.println(lastTask.intent.toInsecureStringWithClip()); 3862 } 3863 } 3864 } 3865 pw.print(prefix); pw.print(full ? " * " : " "); pw.print(label); 3866 pw.print(" #"); pw.print(i); pw.print(": "); 3867 pw.println(r); 3868 if (full) { 3869 r.dump(pw, innerPrefix); 3870 } else if (complete) { 3871 // Complete + brief == give a summary. Isn't that obvious?!? 3872 pw.print(innerPrefix); pw.println(r.intent.toInsecureString()); 3873 if (r.app != null) { 3874 pw.print(innerPrefix); pw.println(r.app); 3875 } 3876 } 3877 if (client && r.app != null && r.app.thread != null) { 3878 // flush anything that is already in the PrintWriter since the thread is going 3879 // to write to the file descriptor directly 3880 pw.flush(); 3881 try { 3882 TransferPipe tp = new TransferPipe(); 3883 try { 3884 r.app.thread.dumpActivity(tp.getWriteFd(), r.appToken, innerPrefix, args); 3885 // Short timeout, since blocking here can 3886 // deadlock with the application. 3887 tp.go(fd, 2000); 3888 } finally { 3889 tp.kill(); 3890 } 3891 } catch (IOException e) { 3892 pw.println(innerPrefix + "Failure while dumping the activity: " + e); 3893 } catch (RemoteException e) { 3894 pw.println(innerPrefix + "Got a RemoteException while dumping the activity"); 3895 } 3896 needNL = true; 3897 } 3898 } 3899 return printed; 3900 } 3901 3902 void scheduleIdleTimeoutLocked(ActivityRecord next) { 3903 if (DEBUG_IDLE) Slog.d(TAG_IDLE, 3904 "scheduleIdleTimeoutLocked: Callers=" + Debug.getCallers(4)); 3905 Message msg = mHandler.obtainMessage(IDLE_TIMEOUT_MSG, next); 3906 mHandler.sendMessageDelayed(msg, IDLE_TIMEOUT); 3907 } 3908 3909 final void scheduleIdleLocked() { 3910 mHandler.sendEmptyMessage(IDLE_NOW_MSG); 3911 } 3912 3913 void removeTimeoutsForActivityLocked(ActivityRecord r) { 3914 if (DEBUG_IDLE) Slog.d(TAG_IDLE, "removeTimeoutsForActivity: Callers=" 3915 + Debug.getCallers(4)); 3916 mHandler.removeMessages(IDLE_TIMEOUT_MSG, r); 3917 } 3918 3919 final void scheduleResumeTopActivities() { 3920 if (!mHandler.hasMessages(RESUME_TOP_ACTIVITY_MSG)) { 3921 mHandler.sendEmptyMessage(RESUME_TOP_ACTIVITY_MSG); 3922 } 3923 } 3924 3925 void removeSleepTimeouts() { 3926 mSleepTimeout = false; 3927 mHandler.removeMessages(SLEEP_TIMEOUT_MSG); 3928 } 3929 3930 final void scheduleSleepTimeout() { 3931 removeSleepTimeouts(); 3932 mHandler.sendEmptyMessageDelayed(SLEEP_TIMEOUT_MSG, SLEEP_TIMEOUT); 3933 } 3934 3935 @Override 3936 public void onDisplayAdded(int displayId) { 3937 if (DEBUG_STACK) Slog.v(TAG, "Display added displayId=" + displayId); 3938 mHandler.sendMessage(mHandler.obtainMessage(HANDLE_DISPLAY_ADDED, displayId, 0)); 3939 } 3940 3941 @Override 3942 public void onDisplayRemoved(int displayId) { 3943 if (DEBUG_STACK) Slog.v(TAG, "Display removed displayId=" + displayId); 3944 mHandler.sendMessage(mHandler.obtainMessage(HANDLE_DISPLAY_REMOVED, displayId, 0)); 3945 } 3946 3947 @Override 3948 public void onDisplayChanged(int displayId) { 3949 if (DEBUG_STACK) Slog.v(TAG, "Display changed displayId=" + displayId); 3950 mHandler.sendMessage(mHandler.obtainMessage(HANDLE_DISPLAY_CHANGED, displayId, 0)); 3951 } 3952 3953 private void handleDisplayAdded(int displayId) { 3954 synchronized (mService) { 3955 getActivityDisplayOrCreateLocked(displayId); 3956 } 3957 } 3958 3959 /** Check if display with specified id is added to the list. */ 3960 boolean isDisplayAdded(int displayId) { 3961 return getActivityDisplayOrCreateLocked(displayId) != null; 3962 } 3963 3964 /** 3965 * Get an existing instance of {@link ActivityDisplay} or create new if there is a 3966 * corresponding record in display manager. 3967 */ 3968 private ActivityDisplay getActivityDisplayOrCreateLocked(int displayId) { 3969 ActivityDisplay activityDisplay = mActivityDisplays.get(displayId); 3970 if (activityDisplay != null) { 3971 return activityDisplay; 3972 } 3973 if (mDisplayManager == null) { 3974 // The system isn't fully initialized yet. 3975 return null; 3976 } 3977 final Display display = mDisplayManager.getDisplay(displayId); 3978 if (display == null) { 3979 // The display is not registered in DisplayManager. 3980 return null; 3981 } 3982 // The display hasn't been added to ActivityManager yet, create a new record now. 3983 activityDisplay = new ActivityDisplay(displayId); 3984 if (activityDisplay.mDisplay == null) { 3985 Slog.w(TAG, "Display " + displayId + " gone before initialization complete"); 3986 return null; 3987 } 3988 mActivityDisplays.put(displayId, activityDisplay); 3989 calculateDefaultMinimalSizeOfResizeableTasks(activityDisplay); 3990 mWindowManager.onDisplayAdded(displayId); 3991 return activityDisplay; 3992 } 3993 3994 private void calculateDefaultMinimalSizeOfResizeableTasks(ActivityDisplay display) { 3995 mDefaultMinSizeOfResizeableTask = 3996 mService.mContext.getResources().getDimensionPixelSize( 3997 com.android.internal.R.dimen.default_minimal_size_resizable_task); 3998 } 3999 4000 private void handleDisplayRemoved(int displayId) { 4001 if (displayId == DEFAULT_DISPLAY) { 4002 throw new IllegalArgumentException("Can't remove the primary display."); 4003 } 4004 4005 synchronized (mService) { 4006 ActivityDisplay activityDisplay = mActivityDisplays.get(displayId); 4007 if (activityDisplay != null) { 4008 final boolean destroyContentOnRemoval 4009 = activityDisplay.shouldDestroyContentOnRemove(); 4010 final ArrayList<ActivityStack> stacks = activityDisplay.mStacks; 4011 while (!stacks.isEmpty()) { 4012 final ActivityStack stack = stacks.get(0); 4013 if (destroyContentOnRemoval) { 4014 moveStackToDisplayLocked(stack.mStackId, DEFAULT_DISPLAY, 4015 false /* onTop */); 4016 stack.finishAllActivitiesLocked(true /* immediately */); 4017 } else { 4018 // Moving all tasks to fullscreen stack, because it's guaranteed to be 4019 // a valid launch stack for all activities. This way the task history from 4020 // external display will be preserved on primary after move. 4021 moveTasksToFullscreenStackLocked(stack.getStackId(), true /* onTop */); 4022 } 4023 } 4024 mActivityDisplays.remove(displayId); 4025 mWindowManager.onDisplayRemoved(displayId); 4026 } 4027 } 4028 } 4029 4030 private void handleDisplayChanged(int displayId) { 4031 synchronized (mService) { 4032 ActivityDisplay activityDisplay = mActivityDisplays.get(displayId); 4033 if (activityDisplay != null) { 4034 // TODO: Update the bounds. 4035 } 4036 mWindowManager.onDisplayChanged(displayId); 4037 } 4038 } 4039 4040 private StackInfo getStackInfoLocked(ActivityStack stack) { 4041 final int displayId = stack.mDisplayId; 4042 final ActivityDisplay display = mActivityDisplays.get(displayId); 4043 StackInfo info = new StackInfo(); 4044 stack.getWindowContainerBounds(info.bounds); 4045 info.displayId = displayId; 4046 info.stackId = stack.mStackId; 4047 info.userId = stack.mCurrentUser; 4048 info.visible = stack.shouldBeVisible(null) == STACK_VISIBLE; 4049 // A stack might be not attached to a display. 4050 info.position = display != null 4051 ? display.mStacks.indexOf(stack) 4052 : 0; 4053 4054 ArrayList<TaskRecord> tasks = stack.getAllTasks(); 4055 final int numTasks = tasks.size(); 4056 int[] taskIds = new int[numTasks]; 4057 String[] taskNames = new String[numTasks]; 4058 Rect[] taskBounds = new Rect[numTasks]; 4059 int[] taskUserIds = new int[numTasks]; 4060 for (int i = 0; i < numTasks; ++i) { 4061 final TaskRecord task = tasks.get(i); 4062 taskIds[i] = task.taskId; 4063 taskNames[i] = task.origActivity != null ? task.origActivity.flattenToString() 4064 : task.realActivity != null ? task.realActivity.flattenToString() 4065 : task.getTopActivity() != null ? task.getTopActivity().packageName 4066 : "unknown"; 4067 taskBounds[i] = new Rect(); 4068 task.getWindowContainerBounds(taskBounds[i]); 4069 taskUserIds[i] = task.userId; 4070 } 4071 info.taskIds = taskIds; 4072 info.taskNames = taskNames; 4073 info.taskBounds = taskBounds; 4074 info.taskUserIds = taskUserIds; 4075 4076 final ActivityRecord top = stack.topRunningActivityLocked(); 4077 info.topActivity = top != null ? top.intent.getComponent() : null; 4078 return info; 4079 } 4080 4081 StackInfo getStackInfoLocked(int stackId) { 4082 ActivityStack stack = getStack(stackId); 4083 if (stack != null) { 4084 return getStackInfoLocked(stack); 4085 } 4086 return null; 4087 } 4088 4089 ArrayList<StackInfo> getAllStackInfosLocked() { 4090 ArrayList<StackInfo> list = new ArrayList<>(); 4091 for (int displayNdx = 0; displayNdx < mActivityDisplays.size(); ++displayNdx) { 4092 ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 4093 for (int ndx = stacks.size() - 1; ndx >= 0; --ndx) { 4094 list.add(getStackInfoLocked(stacks.get(ndx))); 4095 } 4096 } 4097 return list; 4098 } 4099 4100 TaskRecord getLockedTaskLocked() { 4101 final int top = mLockTaskModeTasks.size() - 1; 4102 if (top >= 0) { 4103 return mLockTaskModeTasks.get(top); 4104 } 4105 return null; 4106 } 4107 4108 boolean isLockedTask(TaskRecord task) { 4109 return mLockTaskModeTasks.contains(task); 4110 } 4111 4112 boolean isLastLockedTask(TaskRecord task) { 4113 return mLockTaskModeTasks.size() == 1 && mLockTaskModeTasks.contains(task); 4114 } 4115 4116 void removeLockedTaskLocked(final TaskRecord task) { 4117 if (!mLockTaskModeTasks.remove(task)) { 4118 return; 4119 } 4120 if (DEBUG_LOCKTASK) Slog.w(TAG_LOCKTASK, "removeLockedTaskLocked: removed " + task); 4121 if (mLockTaskModeTasks.isEmpty()) { 4122 // Last one. 4123 if (DEBUG_LOCKTASK) Slog.d(TAG_LOCKTASK, "removeLockedTask: task=" + task + 4124 " last task, reverting locktask mode. Callers=" + Debug.getCallers(3)); 4125 final Message lockTaskMsg = Message.obtain(); 4126 lockTaskMsg.arg1 = task.userId; 4127 lockTaskMsg.what = LOCK_TASK_END_MSG; 4128 mHandler.sendMessage(lockTaskMsg); 4129 } 4130 } 4131 4132 void handleNonResizableTaskIfNeeded(TaskRecord task, int preferredStackId, 4133 int preferredDisplayId, int actualStackId) { 4134 handleNonResizableTaskIfNeeded(task, preferredStackId, preferredDisplayId, actualStackId, 4135 false /* forceNonResizable */); 4136 } 4137 4138 private void handleNonResizableTaskIfNeeded(TaskRecord task, int preferredStackId, 4139 int preferredDisplayId, int actualStackId, boolean forceNonResizable) { 4140 final boolean isSecondaryDisplayPreferred = 4141 (preferredDisplayId != DEFAULT_DISPLAY && preferredDisplayId != INVALID_DISPLAY) 4142 || StackId.isDynamicStack(preferredStackId); 4143 if (((!isStackDockedInEffect(actualStackId) && preferredStackId != DOCKED_STACK_ID) 4144 && !isSecondaryDisplayPreferred) || task.isHomeTask()) { 4145 return; 4146 } 4147 4148 // Handle incorrect launch/move to secondary display if needed. 4149 final boolean launchOnSecondaryDisplayFailed; 4150 if (isSecondaryDisplayPreferred) { 4151 final int actualDisplayId = task.getStack().mDisplayId; 4152 if (!task.canBeLaunchedOnDisplay(actualDisplayId)) { 4153 // The task landed on an inappropriate display somehow, move it to the default 4154 // display. 4155 // TODO(multi-display): Find proper stack for the task on the default display. 4156 mService.moveTaskToStack(task.taskId, FULLSCREEN_WORKSPACE_STACK_ID, 4157 true /* toTop */); 4158 launchOnSecondaryDisplayFailed = true; 4159 } else { 4160 // The task might have landed on a display different from requested. 4161 launchOnSecondaryDisplayFailed = actualDisplayId == DEFAULT_DISPLAY 4162 || (preferredDisplayId != INVALID_DISPLAY 4163 && preferredDisplayId != actualDisplayId); 4164 } 4165 } else { 4166 // The task wasn't requested to be on a secondary display. 4167 launchOnSecondaryDisplayFailed = false; 4168 } 4169 4170 final ActivityRecord topActivity = task.getTopActivity(); 4171 if (launchOnSecondaryDisplayFailed || !task.supportsSplitScreen() || forceNonResizable) { 4172 if (launchOnSecondaryDisplayFailed) { 4173 // Display a warning toast that we tried to put a non-resizeable task on a secondary 4174 // display with config different from global config. 4175 mService.mTaskChangeNotificationController 4176 .notifyActivityLaunchOnSecondaryDisplayFailed(); 4177 } else { 4178 // Display a warning toast that we tried to put a non-dockable task in the docked 4179 // stack. 4180 mService.mTaskChangeNotificationController.notifyActivityDismissingDockedStack(); 4181 } 4182 4183 // Dismiss docked stack. If task appeared to be in docked stack but is not resizable - 4184 // we need to move it to top of fullscreen stack, otherwise it will be covered. 4185 moveTasksToFullscreenStackLocked(DOCKED_STACK_ID, actualStackId == DOCKED_STACK_ID); 4186 } else if (topActivity != null && topActivity.isNonResizableOrForcedResizable() 4187 && !topActivity.noDisplay) { 4188 final String packageName = topActivity.appInfo.packageName; 4189 final int reason = isSecondaryDisplayPreferred 4190 ? FORCED_RESIZEABLE_REASON_SECONDARY_DISPLAY 4191 : FORCED_RESIZEABLE_REASON_SPLIT_SCREEN; 4192 mService.mTaskChangeNotificationController.notifyActivityForcedResizable( 4193 task.taskId, reason, packageName); 4194 } 4195 } 4196 4197 void showLockTaskToast() { 4198 if (mLockTaskNotify != null) { 4199 mLockTaskNotify.showToast(mLockTaskModeState); 4200 } 4201 } 4202 4203 void showLockTaskEscapeMessageLocked(TaskRecord task) { 4204 if (mLockTaskModeTasks.contains(task)) { 4205 mHandler.sendEmptyMessage(SHOW_LOCK_TASK_ESCAPE_MESSAGE_MSG); 4206 } 4207 } 4208 4209 void setLockTaskModeLocked(TaskRecord task, int lockTaskModeState, String reason, 4210 boolean andResume) { 4211 if (task == null) { 4212 // Take out of lock task mode if necessary 4213 final TaskRecord lockedTask = getLockedTaskLocked(); 4214 if (lockedTask != null) { 4215 removeLockedTaskLocked(lockedTask); 4216 if (!mLockTaskModeTasks.isEmpty()) { 4217 // There are locked tasks remaining, can only finish this task, not unlock it. 4218 if (DEBUG_LOCKTASK) Slog.w(TAG_LOCKTASK, 4219 "setLockTaskModeLocked: Tasks remaining, can't unlock"); 4220 lockedTask.performClearTaskLocked(); 4221 resumeFocusedStackTopActivityLocked(); 4222 return; 4223 } 4224 } 4225 if (DEBUG_LOCKTASK) Slog.w(TAG_LOCKTASK, 4226 "setLockTaskModeLocked: No tasks to unlock. Callers=" + Debug.getCallers(4)); 4227 return; 4228 } 4229 4230 // Should have already been checked, but do it again. 4231 if (task.mLockTaskAuth == LOCK_TASK_AUTH_DONT_LOCK) { 4232 if (DEBUG_LOCKTASK) Slog.w(TAG_LOCKTASK, 4233 "setLockTaskModeLocked: Can't lock due to auth"); 4234 return; 4235 } 4236 if (isLockTaskModeViolation(task)) { 4237 Slog.e(TAG_LOCKTASK, "setLockTaskMode: Attempt to start an unauthorized lock task."); 4238 return; 4239 } 4240 4241 if (mLockTaskModeTasks.isEmpty()) { 4242 // First locktask. 4243 final Message lockTaskMsg = Message.obtain(); 4244 lockTaskMsg.obj = task.intent.getComponent().getPackageName(); 4245 lockTaskMsg.arg1 = task.userId; 4246 lockTaskMsg.what = LOCK_TASK_START_MSG; 4247 lockTaskMsg.arg2 = lockTaskModeState; 4248 mHandler.sendMessage(lockTaskMsg); 4249 } 4250 // Add it or move it to the top. 4251 if (DEBUG_LOCKTASK) Slog.w(TAG_LOCKTASK, "setLockTaskModeLocked: Locking to " + task + 4252 " Callers=" + Debug.getCallers(4)); 4253 mLockTaskModeTasks.remove(task); 4254 mLockTaskModeTasks.add(task); 4255 4256 if (task.mLockTaskUid == -1) { 4257 task.mLockTaskUid = task.effectiveUid; 4258 } 4259 4260 if (andResume) { 4261 findTaskToMoveToFrontLocked(task, 0, null, reason, 4262 lockTaskModeState != LOCK_TASK_MODE_NONE); 4263 resumeFocusedStackTopActivityLocked(); 4264 mWindowManager.executeAppTransition(); 4265 } else if (lockTaskModeState != LOCK_TASK_MODE_NONE) { 4266 handleNonResizableTaskIfNeeded(task, INVALID_STACK_ID, DEFAULT_DISPLAY, 4267 task.getStackId(), true /* forceNonResizable */); 4268 } 4269 } 4270 4271 boolean isLockTaskModeViolation(TaskRecord task) { 4272 return isLockTaskModeViolation(task, false); 4273 } 4274 4275 boolean isLockTaskModeViolation(TaskRecord task, boolean isNewClearTask) { 4276 if (getLockedTaskLocked() == task && !isNewClearTask) { 4277 return false; 4278 } 4279 final int lockTaskAuth = task.mLockTaskAuth; 4280 switch (lockTaskAuth) { 4281 case LOCK_TASK_AUTH_DONT_LOCK: 4282 return !mLockTaskModeTasks.isEmpty(); 4283 case LOCK_TASK_AUTH_LAUNCHABLE_PRIV: 4284 case LOCK_TASK_AUTH_LAUNCHABLE: 4285 case LOCK_TASK_AUTH_WHITELISTED: 4286 return false; 4287 case LOCK_TASK_AUTH_PINNABLE: 4288 // Pinnable tasks can't be launched on top of locktask tasks. 4289 return !mLockTaskModeTasks.isEmpty(); 4290 default: 4291 Slog.w(TAG, "isLockTaskModeViolation: invalid lockTaskAuth value=" + lockTaskAuth); 4292 return true; 4293 } 4294 } 4295 4296 void onLockTaskPackagesUpdatedLocked() { 4297 boolean didSomething = false; 4298 for (int taskNdx = mLockTaskModeTasks.size() - 1; taskNdx >= 0; --taskNdx) { 4299 final TaskRecord lockedTask = mLockTaskModeTasks.get(taskNdx); 4300 final boolean wasWhitelisted = 4301 (lockedTask.mLockTaskAuth == LOCK_TASK_AUTH_LAUNCHABLE) || 4302 (lockedTask.mLockTaskAuth == LOCK_TASK_AUTH_WHITELISTED); 4303 lockedTask.setLockTaskAuth(); 4304 final boolean isWhitelisted = 4305 (lockedTask.mLockTaskAuth == LOCK_TASK_AUTH_LAUNCHABLE) || 4306 (lockedTask.mLockTaskAuth == LOCK_TASK_AUTH_WHITELISTED); 4307 if (wasWhitelisted && !isWhitelisted) { 4308 // Lost whitelisting authorization. End it now. 4309 if (DEBUG_LOCKTASK) Slog.d(TAG_LOCKTASK, "onLockTaskPackagesUpdated: removing " + 4310 lockedTask + " mLockTaskAuth=" + lockedTask.lockTaskAuthToString()); 4311 removeLockedTaskLocked(lockedTask); 4312 lockedTask.performClearTaskLocked(); 4313 didSomething = true; 4314 } 4315 } 4316 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 4317 ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 4318 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 4319 final ActivityStack stack = stacks.get(stackNdx); 4320 stack.onLockTaskPackagesUpdatedLocked(); 4321 } 4322 } 4323 final ActivityRecord r = topRunningActivityLocked(); 4324 final TaskRecord task = r != null ? r.getTask() : null; 4325 if (mLockTaskModeTasks.isEmpty() && task != null 4326 && task.mLockTaskAuth == LOCK_TASK_AUTH_LAUNCHABLE) { 4327 // This task must have just been authorized. 4328 if (DEBUG_LOCKTASK) Slog.d(TAG_LOCKTASK, 4329 "onLockTaskPackagesUpdated: starting new locktask task=" + task); 4330 setLockTaskModeLocked(task, ActivityManager.LOCK_TASK_MODE_LOCKED, "package updated", 4331 false); 4332 didSomething = true; 4333 } 4334 if (didSomething) { 4335 resumeFocusedStackTopActivityLocked(); 4336 } 4337 } 4338 4339 int getLockTaskModeState() { 4340 return mLockTaskModeState; 4341 } 4342 4343 void activityRelaunchedLocked(IBinder token) { 4344 mWindowManager.notifyAppRelaunchingFinished(token); 4345 if (mService.isSleepingOrShuttingDownLocked()) { 4346 final ActivityRecord r = ActivityRecord.isInStackLocked(token); 4347 if (r != null) { 4348 r.setSleeping(true, true); 4349 } 4350 } 4351 } 4352 4353 void activityRelaunchingLocked(ActivityRecord r) { 4354 mWindowManager.notifyAppRelaunching(r.appToken); 4355 } 4356 4357 void logStackState() { 4358 mActivityMetricsLogger.logWindowState(); 4359 } 4360 4361 void scheduleUpdateMultiWindowMode(TaskRecord task) { 4362 // If the stack is animating in a way where we will be forcing a multi-mode change at the 4363 // end, then ensure that we defer all in between multi-window mode changes 4364 if (task.getStack().deferScheduleMultiWindowModeChanged()) { 4365 return; 4366 } 4367 4368 for (int i = task.mActivities.size() - 1; i >= 0; i--) { 4369 final ActivityRecord r = task.mActivities.get(i); 4370 if (r.app != null && r.app.thread != null) { 4371 mMultiWindowModeChangedActivities.add(r); 4372 } 4373 } 4374 4375 if (!mHandler.hasMessages(REPORT_MULTI_WINDOW_MODE_CHANGED_MSG)) { 4376 mHandler.sendEmptyMessage(REPORT_MULTI_WINDOW_MODE_CHANGED_MSG); 4377 } 4378 } 4379 4380 void scheduleUpdatePictureInPictureModeIfNeeded(TaskRecord task, ActivityStack prevStack) { 4381 final ActivityStack stack = task.getStack(); 4382 if (prevStack == null || prevStack == stack 4383 || (prevStack.mStackId != PINNED_STACK_ID && stack.mStackId != PINNED_STACK_ID)) { 4384 return; 4385 } 4386 4387 scheduleUpdatePictureInPictureModeIfNeeded(task, stack.mBounds, false /* immediate */); 4388 } 4389 4390 void scheduleUpdatePictureInPictureModeIfNeeded(TaskRecord task, Rect targetStackBounds, 4391 boolean immediate) { 4392 4393 if (immediate) { 4394 mHandler.removeMessages(REPORT_PIP_MODE_CHANGED_MSG); 4395 for (int i = task.mActivities.size() - 1; i >= 0; i--) { 4396 final ActivityRecord r = task.mActivities.get(i); 4397 if (r.app != null && r.app.thread != null) { 4398 r.updatePictureInPictureMode(targetStackBounds); 4399 } 4400 } 4401 } else { 4402 for (int i = task.mActivities.size() - 1; i >= 0; i--) { 4403 final ActivityRecord r = task.mActivities.get(i); 4404 if (r.app != null && r.app.thread != null) { 4405 mPipModeChangedActivities.add(r); 4406 } 4407 } 4408 mPipModeChangedTargetStackBounds = targetStackBounds; 4409 4410 if (!mHandler.hasMessages(REPORT_PIP_MODE_CHANGED_MSG)) { 4411 mHandler.sendEmptyMessage(REPORT_PIP_MODE_CHANGED_MSG); 4412 } 4413 } 4414 } 4415 4416 void setDockedStackMinimized(boolean minimized) { 4417 mIsDockMinimized = minimized; 4418 } 4419 4420 private final class ActivityStackSupervisorHandler extends Handler { 4421 4422 public ActivityStackSupervisorHandler(Looper looper) { 4423 super(looper); 4424 } 4425 4426 void activityIdleInternal(ActivityRecord r, boolean processPausingActivities) { 4427 synchronized (mService) { 4428 activityIdleInternalLocked(r != null ? r.appToken : null, true /* fromTimeout */, 4429 processPausingActivities, null); 4430 } 4431 } 4432 4433 @Override 4434 public void handleMessage(Message msg) { 4435 switch (msg.what) { 4436 case REPORT_MULTI_WINDOW_MODE_CHANGED_MSG: { 4437 synchronized (mService) { 4438 for (int i = mMultiWindowModeChangedActivities.size() - 1; i >= 0; i--) { 4439 final ActivityRecord r = mMultiWindowModeChangedActivities.remove(i); 4440 r.updateMultiWindowMode(); 4441 } 4442 } 4443 } break; 4444 case REPORT_PIP_MODE_CHANGED_MSG: { 4445 synchronized (mService) { 4446 for (int i = mPipModeChangedActivities.size() - 1; i >= 0; i--) { 4447 final ActivityRecord r = mPipModeChangedActivities.remove(i); 4448 r.updatePictureInPictureMode(mPipModeChangedTargetStackBounds); 4449 } 4450 } 4451 } break; 4452 case IDLE_TIMEOUT_MSG: { 4453 if (DEBUG_IDLE) Slog.d(TAG_IDLE, 4454 "handleMessage: IDLE_TIMEOUT_MSG: r=" + msg.obj); 4455 if (mService.mDidDexOpt) { 4456 mService.mDidDexOpt = false; 4457 Message nmsg = mHandler.obtainMessage(IDLE_TIMEOUT_MSG); 4458 nmsg.obj = msg.obj; 4459 mHandler.sendMessageDelayed(nmsg, IDLE_TIMEOUT); 4460 return; 4461 } 4462 // We don't at this point know if the activity is fullscreen, 4463 // so we need to be conservative and assume it isn't. 4464 activityIdleInternal((ActivityRecord) msg.obj, 4465 true /* processPausingActivities */); 4466 } break; 4467 case IDLE_NOW_MSG: { 4468 if (DEBUG_IDLE) Slog.d(TAG_IDLE, "handleMessage: IDLE_NOW_MSG: r=" + msg.obj); 4469 activityIdleInternal((ActivityRecord) msg.obj, 4470 false /* processPausingActivities */); 4471 } break; 4472 case RESUME_TOP_ACTIVITY_MSG: { 4473 synchronized (mService) { 4474 resumeFocusedStackTopActivityLocked(); 4475 } 4476 } break; 4477 case SLEEP_TIMEOUT_MSG: { 4478 synchronized (mService) { 4479 if (mService.isSleepingOrShuttingDownLocked()) { 4480 Slog.w(TAG, "Sleep timeout! Sleeping now."); 4481 mSleepTimeout = true; 4482 checkReadyForSleepLocked(); 4483 } 4484 } 4485 } break; 4486 case LAUNCH_TIMEOUT_MSG: { 4487 if (mService.mDidDexOpt) { 4488 mService.mDidDexOpt = false; 4489 mHandler.sendEmptyMessageDelayed(LAUNCH_TIMEOUT_MSG, LAUNCH_TIMEOUT); 4490 return; 4491 } 4492 synchronized (mService) { 4493 if (mLaunchingActivity.isHeld()) { 4494 Slog.w(TAG, "Launch timeout has expired, giving up wake lock!"); 4495 if (VALIDATE_WAKE_LOCK_CALLER 4496 && Binder.getCallingUid() != Process.myUid()) { 4497 throw new IllegalStateException("Calling must be system uid"); 4498 } 4499 mLaunchingActivity.release(); 4500 } 4501 } 4502 } break; 4503 case HANDLE_DISPLAY_ADDED: { 4504 handleDisplayAdded(msg.arg1); 4505 } break; 4506 case HANDLE_DISPLAY_CHANGED: { 4507 handleDisplayChanged(msg.arg1); 4508 } break; 4509 case HANDLE_DISPLAY_REMOVED: { 4510 handleDisplayRemoved(msg.arg1); 4511 } break; 4512 case CONTAINER_CALLBACK_VISIBILITY: { 4513 final ActivityContainer container = (ActivityContainer) msg.obj; 4514 final IActivityContainerCallback callback = container.mCallback; 4515 if (callback != null) { 4516 try { 4517 callback.setVisible(container.asBinder(), msg.arg1 == 1); 4518 } catch (RemoteException e) { 4519 } 4520 } 4521 } break; 4522 case LOCK_TASK_START_MSG: { 4523 // When lock task starts, we disable the status bars. 4524 try { 4525 if (mLockTaskNotify == null) { 4526 mLockTaskNotify = new LockTaskNotify(mService.mContext); 4527 } 4528 mLockTaskNotify.show(true); 4529 mLockTaskModeState = msg.arg2; 4530 if (getStatusBarService() != null) { 4531 int flags = 0; 4532 if (mLockTaskModeState == LOCK_TASK_MODE_LOCKED) { 4533 flags = StatusBarManager.DISABLE_MASK 4534 & (~StatusBarManager.DISABLE_BACK); 4535 } else if (mLockTaskModeState == LOCK_TASK_MODE_PINNED) { 4536 flags = StatusBarManager.DISABLE_MASK 4537 & (~StatusBarManager.DISABLE_BACK) 4538 & (~StatusBarManager.DISABLE_HOME) 4539 & (~StatusBarManager.DISABLE_RECENT); 4540 } 4541 getStatusBarService().disable(flags, mToken, 4542 mService.mContext.getPackageName()); 4543 } 4544 mWindowManager.disableKeyguard(mToken, LOCK_TASK_TAG); 4545 if (getDevicePolicyManager() != null) { 4546 getDevicePolicyManager().notifyLockTaskModeChanged(true, 4547 (String)msg.obj, msg.arg1); 4548 } 4549 } catch (RemoteException ex) { 4550 throw new RuntimeException(ex); 4551 } 4552 } break; 4553 case LOCK_TASK_END_MSG: { 4554 // When lock task ends, we enable the status bars. 4555 try { 4556 if (getStatusBarService() != null) { 4557 getStatusBarService().disable(StatusBarManager.DISABLE_NONE, mToken, 4558 mService.mContext.getPackageName()); 4559 } 4560 mWindowManager.reenableKeyguard(mToken); 4561 if (getDevicePolicyManager() != null) { 4562 getDevicePolicyManager().notifyLockTaskModeChanged(false, null, 4563 msg.arg1); 4564 } 4565 if (mLockTaskNotify == null) { 4566 mLockTaskNotify = new LockTaskNotify(mService.mContext); 4567 } 4568 mLockTaskNotify.show(false); 4569 try { 4570 boolean shouldLockKeyguard = Settings.Secure.getInt( 4571 mService.mContext.getContentResolver(), 4572 Settings.Secure.LOCK_TO_APP_EXIT_LOCKED) != 0; 4573 if (mLockTaskModeState == LOCK_TASK_MODE_PINNED && shouldLockKeyguard) { 4574 mWindowManager.lockNow(null); 4575 mWindowManager.dismissKeyguard(null /* callback */); 4576 new LockPatternUtils(mService.mContext) 4577 .requireCredentialEntry(UserHandle.USER_ALL); 4578 } 4579 } catch (SettingNotFoundException e) { 4580 // No setting, don't lock. 4581 } 4582 } catch (RemoteException ex) { 4583 throw new RuntimeException(ex); 4584 } finally { 4585 mLockTaskModeState = LOCK_TASK_MODE_NONE; 4586 } 4587 } break; 4588 case SHOW_LOCK_TASK_ESCAPE_MESSAGE_MSG: { 4589 if (mLockTaskNotify == null) { 4590 mLockTaskNotify = new LockTaskNotify(mService.mContext); 4591 } 4592 mLockTaskNotify.showToast(LOCK_TASK_MODE_PINNED); 4593 } break; 4594 case CONTAINER_CALLBACK_TASK_LIST_EMPTY: { 4595 final ActivityContainer container = (ActivityContainer) msg.obj; 4596 final IActivityContainerCallback callback = container.mCallback; 4597 if (callback != null) { 4598 try { 4599 callback.onAllActivitiesComplete(container.asBinder()); 4600 } catch (RemoteException e) { 4601 } 4602 } 4603 } break; 4604 case LAUNCH_TASK_BEHIND_COMPLETE: { 4605 synchronized (mService) { 4606 ActivityRecord r = ActivityRecord.forTokenLocked((IBinder) msg.obj); 4607 if (r != null) { 4608 handleLaunchTaskBehindCompleteLocked(r); 4609 } 4610 } 4611 } break; 4612 4613 } 4614 } 4615 } 4616 4617 class ActivityContainer extends android.app.IActivityContainer.Stub { 4618 final static int FORCE_NEW_TASK_FLAGS = FLAG_ACTIVITY_NEW_TASK | 4619 FLAG_ACTIVITY_MULTIPLE_TASK | Intent.FLAG_ACTIVITY_NO_ANIMATION; 4620 final int mStackId; 4621 IActivityContainerCallback mCallback = null; 4622 ActivityStack mStack; 4623 ActivityRecord mParentActivity = null; 4624 String mIdString; 4625 4626 boolean mVisible = true; 4627 4628 /** Display this ActivityStack is currently on. Null if not attached to a Display. */ 4629 ActivityDisplay mActivityDisplay; 4630 4631 final static int CONTAINER_STATE_HAS_SURFACE = 0; 4632 final static int CONTAINER_STATE_NO_SURFACE = 1; 4633 final static int CONTAINER_STATE_FINISHING = 2; 4634 int mContainerState = CONTAINER_STATE_HAS_SURFACE; 4635 4636 ActivityContainer(int stackId, ActivityDisplay activityDisplay, boolean onTop) { 4637 synchronized (mService) { 4638 mStackId = stackId; 4639 mActivityDisplay = activityDisplay; 4640 mIdString = "ActivtyContainer{" + mStackId + "}"; 4641 4642 createStack(stackId, onTop); 4643 if (DEBUG_STACK) Slog.d(TAG_STACK, "Creating " + this); 4644 } 4645 } 4646 4647 protected void createStack(int stackId, boolean onTop) { 4648 switch (stackId) { 4649 case PINNED_STACK_ID: 4650 new PinnedActivityStack(this, mRecentTasks, onTop); 4651 break; 4652 default: 4653 new ActivityStack(this, mRecentTasks, onTop); 4654 break; 4655 } 4656 } 4657 4658 /** 4659 * Adds the stack to specified display. Also calls WindowManager to do the same from 4660 * {@link ActivityStack#reparent(ActivityDisplay, boolean)}. 4661 * @param activityDisplay The display to add the stack to. 4662 */ 4663 void addToDisplayLocked(ActivityDisplay activityDisplay) { 4664 if (DEBUG_STACK) Slog.d(TAG_STACK, "addToDisplayLocked: " + this 4665 + " to display=" + activityDisplay); 4666 if (mActivityDisplay != null) { 4667 throw new IllegalStateException("ActivityContainer is already attached, " + 4668 "displayId=" + mActivityDisplay.mDisplayId); 4669 } 4670 mActivityDisplay = activityDisplay; 4671 mStack.reparent(activityDisplay, true /* onTop */); 4672 } 4673 4674 @Override 4675 public void addToDisplay(int displayId) { 4676 synchronized (mService) { 4677 final ActivityDisplay activityDisplay = getActivityDisplayOrCreateLocked(displayId); 4678 if (activityDisplay == null) { 4679 return; 4680 } 4681 addToDisplayLocked(activityDisplay); 4682 } 4683 } 4684 4685 @Override 4686 public int getDisplayId() { 4687 synchronized (mService) { 4688 if (mActivityDisplay != null) { 4689 return mActivityDisplay.mDisplayId; 4690 } 4691 } 4692 return -1; 4693 } 4694 4695 @Override 4696 public int getStackId() { 4697 synchronized (mService) { 4698 return mStackId; 4699 } 4700 } 4701 4702 @Override 4703 public boolean injectEvent(InputEvent event) { 4704 final long origId = Binder.clearCallingIdentity(); 4705 try { 4706 synchronized (mService) { 4707 if (mActivityDisplay != null) { 4708 return mInputManagerInternal.injectInputEvent(event, 4709 mActivityDisplay.mDisplayId, 4710 InputManager.INJECT_INPUT_EVENT_MODE_ASYNC); 4711 } 4712 } 4713 return false; 4714 } finally { 4715 Binder.restoreCallingIdentity(origId); 4716 } 4717 } 4718 4719 @Override 4720 public void release() { 4721 synchronized (mService) { 4722 if (mContainerState == CONTAINER_STATE_FINISHING) { 4723 return; 4724 } 4725 mContainerState = CONTAINER_STATE_FINISHING; 4726 4727 long origId = Binder.clearCallingIdentity(); 4728 try { 4729 mStack.finishAllActivitiesLocked(false); 4730 mService.mActivityStarter.removePendingActivityLaunchesLocked(mStack); 4731 } finally { 4732 Binder.restoreCallingIdentity(origId); 4733 } 4734 } 4735 } 4736 4737 /** 4738 * Remove the stack completely. Must be called only when there are no tasks left in it, 4739 * as this method does not finish running activities. 4740 */ 4741 void removeLocked() { 4742 if (DEBUG_STACK) Slog.d(TAG_STACK, "removeLocked: " + this + " from display=" 4743 + mActivityDisplay + " Callers=" + Debug.getCallers(2)); 4744 if (mActivityDisplay != null) { 4745 removeFromDisplayLocked(); 4746 } 4747 mStack.remove(); 4748 } 4749 4750 /** 4751 * Remove the stack from its current {@link ActivityDisplay}, so it can be either destroyed 4752 * completely or re-parented. 4753 */ 4754 private void removeFromDisplayLocked() { 4755 if (DEBUG_STACK) Slog.d(TAG_STACK, "removeFromDisplayLocked: " + this 4756 + " current displayId=" + mActivityDisplay.mDisplayId); 4757 4758 mActivityDisplay.detachStack(mStack); 4759 mActivityDisplay = null; 4760 } 4761 4762 /** 4763 * Move the stack to specified display. 4764 * @param activityDisplay Target display to move the stack to. 4765 * @param onTop Indicates whether container should be place on top or on bottom. 4766 */ 4767 void moveToDisplayLocked(ActivityDisplay activityDisplay, boolean onTop) { 4768 if (DEBUG_STACK) Slog.d(TAG_STACK, "moveToDisplayLocked: " + this + " from display=" 4769 + mActivityDisplay + " to display=" + activityDisplay 4770 + " Callers=" + Debug.getCallers(2)); 4771 4772 removeFromDisplayLocked(); 4773 4774 mActivityDisplay = activityDisplay; 4775 mStack.reparent(activityDisplay, onTop); 4776 } 4777 4778 @Override 4779 public final int startActivity(Intent intent) { 4780 return mService.startActivity(intent, this); 4781 } 4782 4783 @Override 4784 public final int startActivityIntentSender(IIntentSender intentSender) 4785 throws TransactionTooLargeException { 4786 mService.enforceNotIsolatedCaller("ActivityContainer.startActivityIntentSender"); 4787 4788 if (!(intentSender instanceof PendingIntentRecord)) { 4789 throw new IllegalArgumentException("Bad PendingIntent object"); 4790 } 4791 4792 final int userId = mService.mUserController.handleIncomingUser(Binder.getCallingPid(), 4793 Binder.getCallingUid(), mCurrentUser, false, 4794 ActivityManagerService.ALLOW_FULL_ONLY, "ActivityContainer", null); 4795 4796 final PendingIntentRecord pendingIntent = (PendingIntentRecord) intentSender; 4797 checkEmbeddedAllowedInner(userId, pendingIntent.key.requestIntent, 4798 pendingIntent.key.requestResolvedType); 4799 4800 return pendingIntent.sendInner(0, null, null, null, null, null, null, null, 0, 4801 FORCE_NEW_TASK_FLAGS, FORCE_NEW_TASK_FLAGS, null, this); 4802 } 4803 4804 void checkEmbeddedAllowedInner(int userId, Intent intent, String resolvedType) { 4805 ActivityInfo aInfo = resolveActivity(intent, resolvedType, 0, null, userId); 4806 if (aInfo != null && (aInfo.flags & ActivityInfo.FLAG_ALLOW_EMBEDDED) == 0) { 4807 throw new SecurityException( 4808 "Attempt to embed activity that has not set allowEmbedded=\"true\""); 4809 } 4810 } 4811 4812 @Override 4813 public IBinder asBinder() { 4814 return this; 4815 } 4816 4817 @Override 4818 public void setSurface(Surface surface, int width, int height, int density) { 4819 mService.enforceNotIsolatedCaller("ActivityContainer.attachToSurface"); 4820 } 4821 4822 ActivityStackSupervisor getOuter() { 4823 return ActivityStackSupervisor.this; 4824 } 4825 4826 boolean isAttachedLocked() { 4827 return mActivityDisplay != null; 4828 } 4829 4830 // TODO: Make sure every change to ActivityRecord.visible results in a call to this. 4831 void setVisible(boolean visible) { 4832 if (mVisible != visible) { 4833 mVisible = visible; 4834 if (mCallback != null) { 4835 mHandler.obtainMessage(CONTAINER_CALLBACK_VISIBILITY, visible ? 1 : 0, 4836 0 /* unused */, this).sendToTarget(); 4837 } 4838 } 4839 } 4840 4841 void setDrawn() { 4842 } 4843 4844 // You can always start a new task on a regular ActivityStack. 4845 boolean isEligibleForNewTasks() { 4846 return true; 4847 } 4848 4849 void onTaskListEmptyLocked() { 4850 removeLocked(); 4851 mHandler.obtainMessage(CONTAINER_CALLBACK_TASK_LIST_EMPTY, this).sendToTarget(); 4852 } 4853 4854 @Override 4855 public String toString() { 4856 return mIdString + (mActivityDisplay == null ? "N" : "A"); 4857 } 4858 } 4859 4860 private class VirtualActivityContainer extends ActivityContainer { 4861 Surface mSurface; 4862 boolean mDrawn = false; 4863 4864 VirtualActivityContainer(ActivityRecord parent, IActivityContainerCallback callback) { 4865 super(getNextStackId(), parent.getStack().mActivityContainer.mActivityDisplay, 4866 true /* onTop */); 4867 mParentActivity = parent; 4868 mCallback = callback; 4869 mContainerState = CONTAINER_STATE_NO_SURFACE; 4870 mIdString = "VirtualActivityContainer{" + mStackId + ", parent=" + mParentActivity + "}"; 4871 } 4872 4873 @Override 4874 public void setSurface(Surface surface, int width, int height, int density) { 4875 super.setSurface(surface, width, height, density); 4876 4877 synchronized (mService) { 4878 final long origId = Binder.clearCallingIdentity(); 4879 try { 4880 setSurfaceLocked(surface, width, height, density); 4881 } finally { 4882 Binder.restoreCallingIdentity(origId); 4883 } 4884 } 4885 } 4886 4887 private void setSurfaceLocked(Surface surface, int width, int height, int density) { 4888 if (mContainerState == CONTAINER_STATE_FINISHING) { 4889 return; 4890 } 4891 VirtualActivityDisplay virtualActivityDisplay = 4892 (VirtualActivityDisplay) mActivityDisplay; 4893 if (virtualActivityDisplay == null) { 4894 virtualActivityDisplay = 4895 new VirtualActivityDisplay(width, height, density); 4896 mActivityDisplay = virtualActivityDisplay; 4897 mActivityDisplays.put(virtualActivityDisplay.mDisplayId, virtualActivityDisplay); 4898 addToDisplayLocked(virtualActivityDisplay); 4899 } 4900 4901 if (mSurface != null) { 4902 mSurface.release(); 4903 } 4904 4905 mSurface = surface; 4906 if (surface != null) { 4907 resumeFocusedStackTopActivityLocked(); 4908 } else { 4909 mContainerState = CONTAINER_STATE_NO_SURFACE; 4910 ((VirtualActivityDisplay) mActivityDisplay).setSurface(null); 4911 if (mStack.mPausingActivity == null && mStack.mResumedActivity != null) { 4912 mStack.startPausingLocked(false, true, null, false); 4913 } 4914 } 4915 4916 setSurfaceIfReadyLocked(); 4917 4918 if (DEBUG_STACK) Slog.d(TAG_STACK, 4919 "setSurface: " + this + " to display=" + virtualActivityDisplay); 4920 } 4921 4922 @Override 4923 boolean isAttachedLocked() { 4924 return mSurface != null && super.isAttachedLocked(); 4925 } 4926 4927 @Override 4928 void setDrawn() { 4929 synchronized (mService) { 4930 mDrawn = true; 4931 setSurfaceIfReadyLocked(); 4932 } 4933 } 4934 4935 // Never start a new task on an ActivityView if it isn't explicitly specified. 4936 @Override 4937 boolean isEligibleForNewTasks() { 4938 return false; 4939 } 4940 4941 private void setSurfaceIfReadyLocked() { 4942 if (DEBUG_STACK) Slog.v(TAG_STACK, "setSurfaceIfReadyLocked: mDrawn=" + mDrawn + 4943 " mContainerState=" + mContainerState + " mSurface=" + mSurface); 4944 if (mDrawn && mSurface != null && mContainerState == CONTAINER_STATE_NO_SURFACE) { 4945 ((VirtualActivityDisplay) mActivityDisplay).setSurface(mSurface); 4946 mContainerState = CONTAINER_STATE_HAS_SURFACE; 4947 } 4948 } 4949 } 4950 4951 /** Exactly one of these classes per Display in the system. Capable of holding zero or more 4952 * attached {@link ActivityStack}s */ 4953 class ActivityDisplay extends ConfigurationContainer { 4954 /** Actual Display this object tracks. */ 4955 int mDisplayId; 4956 Display mDisplay; 4957 4958 /** All of the stacks on this display. Order matters, topmost stack is in front of all other 4959 * stacks, bottommost behind. Accessed directly by ActivityManager package classes */ 4960 final ArrayList<ActivityStack> mStacks = new ArrayList<>(); 4961 4962 ActivityRecord mVisibleBehindActivity; 4963 4964 /** Array of all UIDs that are present on the display. */ 4965 private IntArray mDisplayAccessUIDs = new IntArray(); 4966 4967 ActivityDisplay() { 4968 } 4969 4970 // After instantiation, check that mDisplay is not null before using this. The alternative 4971 // is for this to throw an exception if mDisplayManager.getDisplay() returns null. 4972 ActivityDisplay(int displayId) { 4973 final Display display = mDisplayManager.getDisplay(displayId); 4974 if (display == null) { 4975 return; 4976 } 4977 init(display); 4978 } 4979 4980 void init(Display display) { 4981 mDisplay = display; 4982 mDisplayId = display.getDisplayId(); 4983 } 4984 4985 void attachStack(ActivityStack stack, int position) { 4986 if (DEBUG_STACK) Slog.v(TAG_STACK, "attachStack: attaching " + stack 4987 + " to displayId=" + mDisplayId + " position=" + position); 4988 mStacks.add(position, stack); 4989 } 4990 4991 void detachStack(ActivityStack stack) { 4992 if (DEBUG_STACK) Slog.v(TAG_STACK, "detachStack: detaching " + stack 4993 + " from displayId=" + mDisplayId); 4994 mStacks.remove(stack); 4995 } 4996 4997 void setVisibleBehindActivity(ActivityRecord r) { 4998 mVisibleBehindActivity = r; 4999 } 5000 5001 boolean hasVisibleBehindActivity() { 5002 return mVisibleBehindActivity != null; 5003 } 5004 5005 @Override 5006 public String toString() { 5007 return "ActivityDisplay={" + mDisplayId + " numStacks=" + mStacks.size() + "}"; 5008 } 5009 5010 @Override 5011 protected int getChildCount() { 5012 return mStacks.size(); 5013 } 5014 5015 @Override 5016 protected ConfigurationContainer getChildAt(int index) { 5017 return mStacks.get(index); 5018 } 5019 5020 @Override 5021 protected ConfigurationContainer getParent() { 5022 return ActivityStackSupervisor.this; 5023 } 5024 5025 boolean isPrivate() { 5026 return (mDisplay.getFlags() & FLAG_PRIVATE) != 0; 5027 } 5028 5029 boolean isUidPresent(int uid) { 5030 for (ActivityStack stack : mStacks) { 5031 if (stack.isUidPresent(uid)) { 5032 return true; 5033 } 5034 } 5035 return false; 5036 } 5037 5038 /** Update and get all UIDs that are present on the display and have access to it. */ 5039 private IntArray getPresentUIDs() { 5040 mDisplayAccessUIDs.clear(); 5041 for (ActivityStack stack : mStacks) { 5042 stack.getPresentUIDs(mDisplayAccessUIDs); 5043 } 5044 return mDisplayAccessUIDs; 5045 } 5046 5047 boolean shouldDestroyContentOnRemove() { 5048 return mDisplay.getRemoveMode() == REMOVE_MODE_DESTROY_CONTENT; 5049 } 5050 } 5051 5052 class VirtualActivityDisplay extends ActivityDisplay { 5053 VirtualDisplay mVirtualDisplay; 5054 5055 VirtualActivityDisplay(int width, int height, int density) { 5056 DisplayManagerGlobal dm = DisplayManagerGlobal.getInstance(); 5057 mVirtualDisplay = dm.createVirtualDisplay(mService.mContext, null /* projection */, 5058 VIRTUAL_DISPLAY_BASE_NAME, width, height, density, null /* surface */, 5059 DisplayManager.VIRTUAL_DISPLAY_FLAG_PUBLIC | 5060 DisplayManager.VIRTUAL_DISPLAY_FLAG_OWN_CONTENT_ONLY, null /* callback */, 5061 null /* handler */, null /* uniqueId */); 5062 5063 init(mVirtualDisplay.getDisplay()); 5064 5065 mWindowManager.onDisplayAdded(mDisplayId); 5066 } 5067 5068 void setSurface(Surface surface) { 5069 if (mVirtualDisplay != null) { 5070 mVirtualDisplay.setSurface(surface); 5071 } 5072 } 5073 5074 @Override 5075 void detachStack(ActivityStack stack) { 5076 super.detachStack(stack); 5077 if (mVirtualDisplay != null) { 5078 mVirtualDisplay.release(); 5079 mVirtualDisplay = null; 5080 } 5081 } 5082 5083 @Override 5084 public String toString() { 5085 return "VirtualActivityDisplay={" + mDisplayId + "}"; 5086 } 5087 } 5088 5089 ActivityStack findStackBehind(ActivityStack stack) { 5090 // TODO(multi-display): We are only looking for stacks on the default display. 5091 final ActivityDisplay display = mActivityDisplays.get(DEFAULT_DISPLAY); 5092 if (display == null) { 5093 return null; 5094 } 5095 final ArrayList<ActivityStack> stacks = display.mStacks; 5096 for (int i = stacks.size() - 1; i >= 0; i--) { 5097 if (stacks.get(i) == stack && i > 0) { 5098 return stacks.get(i - 1); 5099 } 5100 } 5101 throw new IllegalStateException("Failed to find a stack behind stack=" + stack 5102 + " in=" + stacks); 5103 } 5104 5105 /** 5106 * Puts a task into resizing mode during the next app transition. 5107 * 5108 * @param task The task to put into resizing mode 5109 */ 5110 private void setResizingDuringAnimation(TaskRecord task) { 5111 mResizingTasksDuringAnimation.add(task.taskId); 5112 task.setTaskDockedResizing(true); 5113 } 5114 5115 final int startActivityFromRecentsInner(int taskId, Bundle bOptions) { 5116 final TaskRecord task; 5117 final int callingUid; 5118 final String callingPackage; 5119 final Intent intent; 5120 final int userId; 5121 final ActivityOptions activityOptions = (bOptions != null) 5122 ? new ActivityOptions(bOptions) : null; 5123 final int launchStackId = (activityOptions != null) 5124 ? activityOptions.getLaunchStackId() : INVALID_STACK_ID; 5125 if (StackId.isHomeOrRecentsStack(launchStackId)) { 5126 throw new IllegalArgumentException("startActivityFromRecentsInner: Task " 5127 + taskId + " can't be launch in the home/recents stack."); 5128 } 5129 5130 mWindowManager.deferSurfaceLayout(); 5131 try { 5132 if (launchStackId == DOCKED_STACK_ID) { 5133 mWindowManager.setDockedStackCreateState( 5134 activityOptions.getDockCreateMode(), null /* initialBounds */); 5135 5136 // Defer updating the stack in which recents is until the app transition is done, to 5137 // not run into issues where we still need to draw the task in recents but the 5138 // docked stack is already created. 5139 deferUpdateBounds(RECENTS_STACK_ID); 5140 mWindowManager.prepareAppTransition(TRANSIT_DOCK_TASK_FROM_RECENTS, false); 5141 } 5142 5143 task = anyTaskForIdLocked(taskId, MATCH_TASK_IN_STACKS_OR_RECENT_TASKS_AND_RESTORE, 5144 launchStackId); 5145 if (task == null) { 5146 continueUpdateBounds(RECENTS_STACK_ID); 5147 mWindowManager.executeAppTransition(); 5148 throw new IllegalArgumentException( 5149 "startActivityFromRecentsInner: Task " + taskId + " not found."); 5150 } 5151 5152 // Since we don't have an actual source record here, we assume that the currently 5153 // focused activity was the source. 5154 final ActivityStack focusedStack = getFocusedStack(); 5155 final ActivityRecord sourceRecord = 5156 focusedStack != null ? focusedStack.topActivity() : null; 5157 5158 if (launchStackId != INVALID_STACK_ID) { 5159 if (task.getStackId() != launchStackId) { 5160 task.reparent(launchStackId, ON_TOP, REPARENT_MOVE_STACK_TO_FRONT, ANIMATE, 5161 DEFER_RESUME, "startActivityFromRecents"); 5162 } 5163 } 5164 5165 // If the user must confirm credentials (e.g. when first launching a work app and the 5166 // Work Challenge is present) let startActivityInPackage handle the intercepting. 5167 if (!mService.mUserController.shouldConfirmCredentials(task.userId) 5168 && task.getRootActivity() != null) { 5169 mService.mActivityStarter.sendPowerHintForLaunchStartIfNeeded(true /* forceSend */); 5170 mActivityMetricsLogger.notifyActivityLaunching(); 5171 mService.moveTaskToFrontLocked(task.taskId, 0, bOptions, true /* fromRecents */); 5172 mActivityMetricsLogger.notifyActivityLaunched(ActivityManager.START_TASK_TO_FRONT, 5173 task.getTopActivity()); 5174 5175 // If we are launching the task in the docked stack, put it into resizing mode so 5176 // the window renders full-screen with the background filling the void. Also only 5177 // call this at the end to make sure that tasks exists on the window manager side. 5178 if (launchStackId == DOCKED_STACK_ID) { 5179 setResizingDuringAnimation(task); 5180 } 5181 5182 mService.mActivityStarter.postStartActivityProcessing(task.getTopActivity(), 5183 ActivityManager.START_TASK_TO_FRONT, 5184 sourceRecord != null 5185 ? sourceRecord.getTask().getStackId() : INVALID_STACK_ID, 5186 sourceRecord, task.getStack()); 5187 return ActivityManager.START_TASK_TO_FRONT; 5188 } 5189 callingUid = task.mCallingUid; 5190 callingPackage = task.mCallingPackage; 5191 intent = task.intent; 5192 intent.addFlags(Intent.FLAG_ACTIVITY_LAUNCHED_FROM_HISTORY); 5193 userId = task.userId; 5194 int result = mService.startActivityInPackage(callingUid, callingPackage, intent, null, 5195 null, null, 0, 0, bOptions, userId, null, task, "startActivityFromRecents"); 5196 if (launchStackId == DOCKED_STACK_ID) { 5197 setResizingDuringAnimation(task); 5198 } 5199 return result; 5200 } finally { 5201 mWindowManager.continueSurfaceLayout(); 5202 } 5203 } 5204 5205 /** 5206 * @return a list of activities which are the top ones in each visible stack. The first 5207 * entry will be the focused activity. 5208 */ 5209 List<IBinder> getTopVisibleActivities() { 5210 final ArrayList<IBinder> topActivityTokens = new ArrayList<>(); 5211 // Traverse all displays. 5212 for (int i = mActivityDisplays.size() - 1; i >= 0; i--) { 5213 final ActivityDisplay display = mActivityDisplays.valueAt(i); 5214 // Traverse all stacks on a display. 5215 for (int j = display.mStacks.size() - 1; j >= 0; j--) { 5216 final ActivityStack stack = display.mStacks.get(j); 5217 // Get top activity from a visible stack and add it to the list. 5218 if (stack.shouldBeVisible(null /* starting */) 5219 == ActivityStack.STACK_VISIBLE) { 5220 final ActivityRecord top = stack.topActivity(); 5221 if (top != null) { 5222 if (stack == mFocusedStack) { 5223 topActivityTokens.add(0, top.appToken); 5224 } else { 5225 topActivityTokens.add(top.appToken); 5226 } 5227 } 5228 } 5229 } 5230 } 5231 return topActivityTokens; 5232 } 5233 5234 /** 5235 * Internal container to store a match qualifier alongside a WaitResult. 5236 */ 5237 static class WaitInfo { 5238 private final ComponentName mTargetComponent; 5239 private final WaitResult mResult; 5240 5241 public WaitInfo(ComponentName targetComponent, WaitResult result) { 5242 this.mTargetComponent = targetComponent; 5243 this.mResult = result; 5244 } 5245 5246 public boolean matches(ComponentName targetComponent) { 5247 return mTargetComponent == null || mTargetComponent.equals(targetComponent); 5248 } 5249 5250 public WaitResult getResult() { 5251 return mResult; 5252 } 5253 5254 public ComponentName getComponent() { 5255 return mTargetComponent; 5256 } 5257 5258 public void dump(PrintWriter pw, String prefix) { 5259 pw.println(prefix + "WaitInfo:"); 5260 pw.println(prefix + " mTargetComponent=" + mTargetComponent); 5261 pw.println(prefix + " mResult="); 5262 mResult.dump(pw, prefix); 5263 } 5264 } 5265 } 5266