ActivityStackSupervisor.java revision 6ea0d0a2592395b8980c24304733daec628e947e
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 17package com.android.server.am; 18 19import static android.Manifest.permission.START_ANY_ACTIVITY; 20import static android.content.Intent.FLAG_ACTIVITY_NEW_TASK; 21import static android.content.Intent.FLAG_ACTIVITY_TASK_ON_HOME; 22import static android.content.pm.PackageManager.PERMISSION_GRANTED; 23import static com.android.server.am.ActivityManagerService.localLOGV; 24import static com.android.server.am.ActivityManagerService.DEBUG_CONFIGURATION; 25import static com.android.server.am.ActivityManagerService.DEBUG_FOCUS; 26import static com.android.server.am.ActivityManagerService.DEBUG_PAUSE; 27import static com.android.server.am.ActivityManagerService.DEBUG_RESULTS; 28import static com.android.server.am.ActivityManagerService.DEBUG_STACK; 29import static com.android.server.am.ActivityManagerService.DEBUG_SWITCH; 30import static com.android.server.am.ActivityManagerService.DEBUG_TASKS; 31import static com.android.server.am.ActivityManagerService.DEBUG_USER_LEAVING; 32import static com.android.server.am.ActivityManagerService.FIRST_SUPERVISOR_STACK_MSG; 33import static com.android.server.am.ActivityManagerService.TAG; 34import static com.android.server.am.ActivityRecord.HOME_ACTIVITY_TYPE; 35import static com.android.server.am.ActivityRecord.RECENTS_ACTIVITY_TYPE; 36import static com.android.server.am.ActivityRecord.APPLICATION_ACTIVITY_TYPE; 37 38import android.app.Activity; 39import android.app.ActivityManager; 40import android.app.ActivityManager.StackInfo; 41import android.app.ActivityOptions; 42import android.app.AppGlobals; 43import android.app.IActivityContainer; 44import android.app.IActivityContainerCallback; 45import android.app.IActivityManager; 46import android.app.IApplicationThread; 47import android.app.PendingIntent; 48import android.app.ActivityManager.RunningTaskInfo; 49import android.app.IActivityManager.WaitResult; 50import android.app.ResultInfo; 51import android.app.StatusBarManager; 52import android.app.admin.DevicePolicyManager; 53import android.app.admin.IDevicePolicyManager; 54import android.content.ComponentName; 55import android.content.Context; 56import android.content.IIntentSender; 57import android.content.Intent; 58import android.content.IntentSender; 59import android.content.pm.ActivityInfo; 60import android.content.pm.ApplicationInfo; 61import android.content.pm.PackageManager; 62import android.content.pm.ResolveInfo; 63import android.content.res.Configuration; 64import android.graphics.Point; 65import android.hardware.display.DisplayManager; 66import android.hardware.display.DisplayManager.DisplayListener; 67import android.hardware.display.DisplayManagerGlobal; 68import android.hardware.display.VirtualDisplay; 69import android.hardware.input.InputManager; 70import android.hardware.input.InputManagerInternal; 71import android.os.Binder; 72import android.os.Bundle; 73import android.os.Debug; 74import android.os.Handler; 75import android.os.IBinder; 76import android.os.Looper; 77import android.os.Message; 78import android.os.ParcelFileDescriptor; 79import android.os.PowerManager; 80import android.os.Process; 81import android.os.RemoteException; 82import android.os.ServiceManager; 83import android.os.SystemClock; 84import android.os.UserHandle; 85import android.provider.Settings; 86import android.provider.Settings.SettingNotFoundException; 87import android.service.voice.IVoiceInteractionSession; 88import android.util.EventLog; 89import android.util.Slog; 90import android.util.SparseArray; 91 92import android.util.SparseIntArray; 93import android.view.Display; 94import android.view.DisplayInfo; 95import android.view.InputEvent; 96import android.view.Surface; 97import com.android.internal.app.HeavyWeightSwitcherActivity; 98import com.android.internal.app.IVoiceInteractor; 99import com.android.internal.os.TransferPipe; 100import com.android.internal.statusbar.IStatusBarService; 101import com.android.server.LocalServices; 102import com.android.server.am.ActivityManagerService.PendingActivityLaunch; 103import com.android.server.am.ActivityStack.ActivityState; 104import com.android.server.wm.WindowManagerService; 105 106 107import java.io.FileDescriptor; 108import java.io.IOException; 109import java.io.PrintWriter; 110import java.util.ArrayList; 111import java.util.List; 112 113public final class ActivityStackSupervisor implements DisplayListener { 114 static final boolean DEBUG = ActivityManagerService.DEBUG || false; 115 static final boolean DEBUG_ADD_REMOVE = DEBUG || false; 116 static final boolean DEBUG_APP = DEBUG || false; 117 static final boolean DEBUG_CONTAINERS = DEBUG || false; 118 static final boolean DEBUG_IDLE = DEBUG || false; 119 static final boolean DEBUG_SAVED_STATE = DEBUG || false; 120 static final boolean DEBUG_SCREENSHOTS = DEBUG || false; 121 static final boolean DEBUG_STATES = DEBUG || false; 122 123 public static final int HOME_STACK_ID = 0; 124 125 /** How long we wait until giving up on the last activity telling us it is idle. */ 126 static final int IDLE_TIMEOUT = 10*1000; 127 128 /** How long we can hold the sleep wake lock before giving up. */ 129 static final int SLEEP_TIMEOUT = 5*1000; 130 131 // How long we can hold the launch wake lock before giving up. 132 static final int LAUNCH_TIMEOUT = 10*1000; 133 134 static final int IDLE_TIMEOUT_MSG = FIRST_SUPERVISOR_STACK_MSG; 135 static final int IDLE_NOW_MSG = FIRST_SUPERVISOR_STACK_MSG + 1; 136 static final int RESUME_TOP_ACTIVITY_MSG = FIRST_SUPERVISOR_STACK_MSG + 2; 137 static final int SLEEP_TIMEOUT_MSG = FIRST_SUPERVISOR_STACK_MSG + 3; 138 static final int LAUNCH_TIMEOUT_MSG = FIRST_SUPERVISOR_STACK_MSG + 4; 139 static final int HANDLE_DISPLAY_ADDED = FIRST_SUPERVISOR_STACK_MSG + 5; 140 static final int HANDLE_DISPLAY_CHANGED = FIRST_SUPERVISOR_STACK_MSG + 6; 141 static final int HANDLE_DISPLAY_REMOVED = FIRST_SUPERVISOR_STACK_MSG + 7; 142 static final int CONTAINER_CALLBACK_VISIBILITY = FIRST_SUPERVISOR_STACK_MSG + 8; 143 static final int LOCK_TASK_START_MSG = FIRST_SUPERVISOR_STACK_MSG + 9; 144 static final int LOCK_TASK_END_MSG = FIRST_SUPERVISOR_STACK_MSG + 10; 145 static final int CONTAINER_CALLBACK_TASK_LIST_EMPTY = FIRST_SUPERVISOR_STACK_MSG + 11; 146 static final int CONTAINER_TASK_LIST_EMPTY_TIMEOUT = FIRST_SUPERVISOR_STACK_MSG + 12; 147 148 private final static String VIRTUAL_DISPLAY_BASE_NAME = "ActivityViewVirtualDisplay"; 149 150 private static final String LOCK_TASK_TAG = "Lock-to-App"; 151 152 /** Status Bar Service **/ 153 private IBinder mToken = new Binder(); 154 private IStatusBarService mStatusBarService; 155 private IDevicePolicyManager mDevicePolicyManager; 156 157 // For debugging to make sure the caller when acquiring/releasing our 158 // wake lock is the system process. 159 static final boolean VALIDATE_WAKE_LOCK_CALLER = false; 160 161 final ActivityManagerService mService; 162 163 final ActivityStackSupervisorHandler mHandler; 164 165 /** Short cut */ 166 WindowManagerService mWindowManager; 167 DisplayManager mDisplayManager; 168 169 /** Dismiss the keyguard after the next activity is displayed? */ 170 boolean mDismissKeyguardOnNextActivity = false; 171 172 /** Identifier counter for all ActivityStacks */ 173 private int mLastStackId = HOME_STACK_ID; 174 175 /** Task identifier that activities are currently being started in. Incremented each time a 176 * new task is created. */ 177 private int mCurTaskId = 0; 178 179 /** The current user */ 180 private int mCurrentUser; 181 182 /** The stack containing the launcher app. Assumed to always be attached to 183 * Display.DEFAULT_DISPLAY. */ 184 private ActivityStack mHomeStack; 185 186 /** The stack currently receiving input or launching the next activity. */ 187 private ActivityStack mFocusedStack; 188 189 /** If this is the same as mFocusedStack then the activity on the top of the focused stack has 190 * been resumed. If stacks are changing position this will hold the old stack until the new 191 * stack becomes resumed after which it will be set to mFocusedStack. */ 192 private ActivityStack mLastFocusedStack; 193 194 /** List of activities that are waiting for a new activity to become visible before completing 195 * whatever operation they are supposed to do. */ 196 final ArrayList<ActivityRecord> mWaitingVisibleActivities = new ArrayList<ActivityRecord>(); 197 198 /** List of processes waiting to find out about the next visible activity. */ 199 final ArrayList<IActivityManager.WaitResult> mWaitingActivityVisible = 200 new ArrayList<IActivityManager.WaitResult>(); 201 202 /** List of processes waiting to find out about the next launched activity. */ 203 final ArrayList<IActivityManager.WaitResult> mWaitingActivityLaunched = 204 new ArrayList<IActivityManager.WaitResult>(); 205 206 /** List of activities that are ready to be stopped, but waiting for the next activity to 207 * settle down before doing so. */ 208 final ArrayList<ActivityRecord> mStoppingActivities = new ArrayList<ActivityRecord>(); 209 210 /** List of activities that are ready to be finished, but waiting for the previous activity to 211 * settle down before doing so. It contains ActivityRecord objects. */ 212 final ArrayList<ActivityRecord> mFinishingActivities = new ArrayList<ActivityRecord>(); 213 214 /** List of activities that are in the process of going to sleep. */ 215 final ArrayList<ActivityRecord> mGoingToSleepActivities = new ArrayList<ActivityRecord>(); 216 217 /** Used on user changes */ 218 final ArrayList<UserStartedState> mStartingUsers = new ArrayList<UserStartedState>(); 219 220 /** Used to queue up any background users being started */ 221 final ArrayList<UserStartedState> mStartingBackgroundUsers = new ArrayList<UserStartedState>(); 222 223 /** Set to indicate whether to issue an onUserLeaving callback when a newly launched activity 224 * is being brought in front of us. */ 225 boolean mUserLeaving = false; 226 227 /** Set when we have taken too long waiting to go to sleep. */ 228 boolean mSleepTimeout = false; 229 230 /** Indicates if we are running on a Leanback-only (TV) device. Only initialized after 231 * setWindowManager is called. **/ 232 private boolean mLeanbackOnlyDevice; 233 234 /** 235 * We don't want to allow the device to go to sleep while in the process 236 * of launching an activity. This is primarily to allow alarm intent 237 * receivers to launch an activity and get that to run before the device 238 * goes back to sleep. 239 */ 240 PowerManager.WakeLock mLaunchingActivity; 241 242 /** 243 * Set when the system is going to sleep, until we have 244 * successfully paused the current activity and released our wake lock. 245 * At that point the system is allowed to actually sleep. 246 */ 247 PowerManager.WakeLock mGoingToSleep; 248 249 /** Stack id of the front stack when user switched, indexed by userId. */ 250 SparseIntArray mUserStackInFront = new SparseIntArray(2); 251 252 // TODO: Add listener for removal of references. 253 /** Mapping from (ActivityStack/TaskStack).mStackId to their current state */ 254 private SparseArray<ActivityContainer> mActivityContainers = new SparseArray<ActivityContainer>(); 255 256 /** Mapping from displayId to display current state */ 257 private final SparseArray<ActivityDisplay> mActivityDisplays = 258 new SparseArray<ActivityDisplay>(); 259 260 InputManagerInternal mInputManagerInternal; 261 262 /** If non-null then the task specified remains in front and no other tasks may be started 263 * until the task exits or #stopLockTaskMode() is called. */ 264 TaskRecord mLockTaskModeTask; 265 /** Whether lock task has been entered by an authorized app and cannot 266 * be exited. */ 267 private boolean mLockTaskIsLocked; 268 /** 269 * Notifies the user when entering/exiting lock-task. 270 */ 271 private LockTaskNotify mLockTaskNotify; 272 273 public ActivityStackSupervisor(ActivityManagerService service) { 274 mService = service; 275 mHandler = new ActivityStackSupervisorHandler(mService.mHandler.getLooper()); 276 } 277 278 /** 279 * At the time when the constructor runs, the power manager has not yet been 280 * initialized. So we initialize our wakelocks afterwards. 281 */ 282 void initPowerManagement() { 283 PowerManager pm = (PowerManager)mService.mContext.getSystemService(Context.POWER_SERVICE); 284 mGoingToSleep = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "ActivityManager-Sleep"); 285 mLaunchingActivity = 286 pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "ActivityManager-Launch"); 287 mLaunchingActivity.setReferenceCounted(false); 288 } 289 290 // This function returns a IStatusBarService. The value is from ServiceManager. 291 // getService and is cached. 292 private IStatusBarService getStatusBarService() { 293 synchronized (mService) { 294 if (mStatusBarService == null) { 295 mStatusBarService = IStatusBarService.Stub.asInterface( 296 ServiceManager.checkService(Context.STATUS_BAR_SERVICE)); 297 if (mStatusBarService == null) { 298 Slog.w("StatusBarManager", "warning: no STATUS_BAR_SERVICE"); 299 } 300 } 301 return mStatusBarService; 302 } 303 } 304 305 private IDevicePolicyManager getDevicePolicyManager() { 306 synchronized (mService) { 307 if (mDevicePolicyManager == null) { 308 mDevicePolicyManager = IDevicePolicyManager.Stub.asInterface( 309 ServiceManager.checkService(Context.DEVICE_POLICY_SERVICE)); 310 if (mDevicePolicyManager == null) { 311 Slog.w(TAG, "warning: no DEVICE_POLICY_SERVICE"); 312 } 313 } 314 return mDevicePolicyManager; 315 } 316 } 317 318 void setWindowManager(WindowManagerService wm) { 319 synchronized (mService) { 320 mWindowManager = wm; 321 322 mDisplayManager = 323 (DisplayManager)mService.mContext.getSystemService(Context.DISPLAY_SERVICE); 324 mDisplayManager.registerDisplayListener(this, null); 325 326 Display[] displays = mDisplayManager.getDisplays(); 327 for (int displayNdx = displays.length - 1; displayNdx >= 0; --displayNdx) { 328 final int displayId = displays[displayNdx].getDisplayId(); 329 ActivityDisplay activityDisplay = new ActivityDisplay(displayId); 330 mActivityDisplays.put(displayId, activityDisplay); 331 } 332 333 createStackOnDisplay(HOME_STACK_ID, Display.DEFAULT_DISPLAY); 334 mHomeStack = mFocusedStack = mLastFocusedStack = getStack(HOME_STACK_ID); 335 336 mInputManagerInternal = LocalServices.getService(InputManagerInternal.class); 337 338 // Initialize this here, now that we can get a valid reference to PackageManager. 339 mLeanbackOnlyDevice = isLeanbackOnlyDevice(); 340 } 341 } 342 343 void dismissKeyguard() { 344 if (ActivityManagerService.DEBUG_LOCKSCREEN) mService.logLockScreen(""); 345 if (mDismissKeyguardOnNextActivity) { 346 mDismissKeyguardOnNextActivity = false; 347 mWindowManager.dismissKeyguard(); 348 } 349 } 350 351 ActivityStack getFocusedStack() { 352 return mFocusedStack; 353 } 354 355 ActivityStack getLastStack() { 356 return mLastFocusedStack; 357 } 358 359 // TODO: Split into two methods isFrontStack for any visible stack and isFrontmostStack for the 360 // top of all visible stacks. 361 boolean isFrontStack(ActivityStack stack) { 362 final ActivityRecord parent = stack.mActivityContainer.mParentActivity; 363 if (parent != null) { 364 stack = parent.task.stack; 365 } 366 ArrayList<ActivityStack> stacks = stack.mStacks; 367 if (stacks != null && !stacks.isEmpty()) { 368 return stack == stacks.get(stacks.size() - 1); 369 } 370 return false; 371 } 372 373 void moveHomeStack(boolean toFront) { 374 ArrayList<ActivityStack> stacks = mHomeStack.mStacks; 375 int topNdx = stacks.size() - 1; 376 if (topNdx <= 0) { 377 return; 378 } 379 ActivityStack topStack = stacks.get(topNdx); 380 final boolean homeInFront = topStack == mHomeStack; 381 if (homeInFront != toFront) { 382 mLastFocusedStack = topStack; 383 stacks.remove(mHomeStack); 384 stacks.add(toFront ? topNdx : 0, mHomeStack); 385 mFocusedStack = stacks.get(topNdx); 386 if (DEBUG_STACK) Slog.d(TAG, "moveHomeTask: topStack old=" + topStack + " new=" 387 + mFocusedStack); 388 } 389 } 390 391 void moveHomeStackTaskToTop(int homeStackTaskType) { 392 if (homeStackTaskType == RECENTS_ACTIVITY_TYPE) { 393 mWindowManager.showRecentApps(); 394 return; 395 } 396 moveHomeStack(true); 397 mHomeStack.moveHomeStackTaskToTop(homeStackTaskType); 398 } 399 400 boolean resumeHomeStackTask(int homeStackTaskType, ActivityRecord prev) { 401 if (homeStackTaskType == RECENTS_ACTIVITY_TYPE) { 402 mWindowManager.showRecentApps(); 403 return false; 404 } 405 moveHomeStackTaskToTop(homeStackTaskType); 406 if (prev != null) { 407 prev.task.setTaskToReturnTo(APPLICATION_ACTIVITY_TYPE); 408 } 409 410 ActivityRecord r = mHomeStack.topRunningActivityLocked(null); 411 // if (r != null && (r.isHomeActivity() || r.isRecentsActivity())) { 412 if (r != null && r.isHomeActivity()) { 413 mService.setFocusedActivityLocked(r); 414 return resumeTopActivitiesLocked(mHomeStack, prev, null); 415 } 416 return mService.startHomeActivityLocked(mCurrentUser); 417 } 418 419 void setDismissKeyguard(boolean dismiss) { 420 if (ActivityManagerService.DEBUG_LOCKSCREEN) mService.logLockScreen(" dismiss=" + dismiss); 421 mDismissKeyguardOnNextActivity = dismiss; 422 } 423 424 TaskRecord anyTaskForIdLocked(int id) { 425 int numDisplays = mActivityDisplays.size(); 426 for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) { 427 ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 428 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 429 ActivityStack stack = stacks.get(stackNdx); 430 TaskRecord task = stack.taskForIdLocked(id); 431 if (task != null) { 432 return task; 433 } 434 } 435 } 436 return null; 437 } 438 439 ActivityRecord isInAnyStackLocked(IBinder token) { 440 int numDisplays = mActivityDisplays.size(); 441 for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) { 442 ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 443 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 444 final ActivityRecord r = stacks.get(stackNdx).isInStackLocked(token); 445 if (r != null) { 446 return r; 447 } 448 } 449 } 450 return null; 451 } 452 453 void setNextTaskId(int taskId) { 454 if (taskId > mCurTaskId) { 455 mCurTaskId = taskId; 456 } 457 } 458 459 int getNextTaskId() { 460 do { 461 mCurTaskId++; 462 if (mCurTaskId <= 0) { 463 mCurTaskId = 1; 464 } 465 } while (anyTaskForIdLocked(mCurTaskId) != null); 466 return mCurTaskId; 467 } 468 469 ActivityRecord resumedAppLocked() { 470 ActivityStack stack = getFocusedStack(); 471 if (stack == null) { 472 return null; 473 } 474 ActivityRecord resumedActivity = stack.mResumedActivity; 475 if (resumedActivity == null || resumedActivity.app == null) { 476 resumedActivity = stack.mPausingActivity; 477 if (resumedActivity == null || resumedActivity.app == null) { 478 resumedActivity = stack.topRunningActivityLocked(null); 479 } 480 } 481 return resumedActivity; 482 } 483 484 boolean attachApplicationLocked(ProcessRecord app) throws Exception { 485 final String processName = app.processName; 486 boolean didSomething = false; 487 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 488 ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 489 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 490 final ActivityStack stack = stacks.get(stackNdx); 491 if (!isFrontStack(stack)) { 492 continue; 493 } 494 ActivityRecord hr = stack.topRunningActivityLocked(null); 495 if (hr != null) { 496 if (hr.app == null && app.uid == hr.info.applicationInfo.uid 497 && processName.equals(hr.processName)) { 498 try { 499 if (realStartActivityLocked(hr, app, true, true)) { 500 didSomething = true; 501 } 502 } catch (Exception e) { 503 Slog.w(TAG, "Exception in new application when starting activity " 504 + hr.intent.getComponent().flattenToShortString(), e); 505 throw e; 506 } 507 } 508 } 509 } 510 } 511 if (!didSomething) { 512 ensureActivitiesVisibleLocked(null, 0); 513 } 514 return didSomething; 515 } 516 517 boolean allResumedActivitiesIdle() { 518 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 519 ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 520 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 521 final ActivityStack stack = stacks.get(stackNdx); 522 if (!isFrontStack(stack) || stack.numActivities() == 0) { 523 continue; 524 } 525 final ActivityRecord resumedActivity = stack.mResumedActivity; 526 if (resumedActivity == null || !resumedActivity.idle) { 527 if (DEBUG_STATES) Slog.d(TAG, "allResumedActivitiesIdle: stack=" 528 + stack.mStackId + " " + resumedActivity + " not idle"); 529 return false; 530 } 531 } 532 } 533 return true; 534 } 535 536 boolean allResumedActivitiesComplete() { 537 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 538 ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 539 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 540 final ActivityStack stack = stacks.get(stackNdx); 541 if (isFrontStack(stack)) { 542 final ActivityRecord r = stack.mResumedActivity; 543 if (r != null && r.state != ActivityState.RESUMED) { 544 return false; 545 } 546 } 547 } 548 } 549 // TODO: Not sure if this should check if all Paused are complete too. 550 if (DEBUG_STACK) Slog.d(TAG, 551 "allResumedActivitiesComplete: mLastFocusedStack changing from=" + 552 mLastFocusedStack + " to=" + mFocusedStack); 553 mLastFocusedStack = mFocusedStack; 554 return true; 555 } 556 557 boolean allResumedActivitiesVisible() { 558 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 559 ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 560 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 561 final ActivityStack stack = stacks.get(stackNdx); 562 final ActivityRecord r = stack.mResumedActivity; 563 if (r != null && (!r.nowVisible || r.waitingVisible)) { 564 return false; 565 } 566 } 567 } 568 return true; 569 } 570 571 /** 572 * Pause all activities in either all of the stacks or just the back stacks. 573 * @param userLeaving Passed to pauseActivity() to indicate whether to call onUserLeaving(). 574 * @return true if any activity was paused as a result of this call. 575 */ 576 boolean pauseBackStacks(boolean userLeaving) { 577 boolean someActivityPaused = false; 578 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 579 ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 580 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 581 final ActivityStack stack = stacks.get(stackNdx); 582 if (!isFrontStack(stack) && stack.mResumedActivity != null) { 583 if (DEBUG_STATES) Slog.d(TAG, "pauseBackStacks: stack=" + stack + 584 " mResumedActivity=" + stack.mResumedActivity); 585 stack.startPausingLocked(userLeaving, false); 586 someActivityPaused = true; 587 } 588 } 589 } 590 return someActivityPaused; 591 } 592 593 boolean allPausedActivitiesComplete() { 594 boolean pausing = true; 595 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 596 ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 597 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 598 final ActivityStack stack = stacks.get(stackNdx); 599 final ActivityRecord r = stack.mPausingActivity; 600 if (r != null && r.state != ActivityState.PAUSED 601 && r.state != ActivityState.STOPPED 602 && r.state != ActivityState.STOPPING) { 603 if (DEBUG_STATES) { 604 Slog.d(TAG, "allPausedActivitiesComplete: r=" + r + " state=" + r.state); 605 pausing = false; 606 } else { 607 return false; 608 } 609 } 610 } 611 } 612 return pausing; 613 } 614 615 void pauseChildStacks(ActivityRecord parent, boolean userLeaving, boolean uiSleeping) { 616 // TODO: Put all stacks in supervisor and iterate through them instead. 617 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 618 ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 619 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 620 final ActivityStack stack = stacks.get(stackNdx); 621 if (stack.mResumedActivity != null && 622 stack.mActivityContainer.mParentActivity == parent) { 623 stack.startPausingLocked(userLeaving, uiSleeping); 624 } 625 } 626 } 627 } 628 629 void reportActivityVisibleLocked(ActivityRecord r) { 630 for (int i = mWaitingActivityVisible.size()-1; i >= 0; i--) { 631 WaitResult w = mWaitingActivityVisible.get(i); 632 w.timeout = false; 633 if (r != null) { 634 w.who = new ComponentName(r.info.packageName, r.info.name); 635 } 636 w.totalTime = SystemClock.uptimeMillis() - w.thisTime; 637 w.thisTime = w.totalTime; 638 } 639 mService.notifyAll(); 640 dismissKeyguard(); 641 } 642 643 void reportActivityLaunchedLocked(boolean timeout, ActivityRecord r, 644 long thisTime, long totalTime) { 645 for (int i = mWaitingActivityLaunched.size() - 1; i >= 0; i--) { 646 WaitResult w = mWaitingActivityLaunched.remove(i); 647 w.timeout = timeout; 648 if (r != null) { 649 w.who = new ComponentName(r.info.packageName, r.info.name); 650 } 651 w.thisTime = thisTime; 652 w.totalTime = totalTime; 653 } 654 mService.notifyAll(); 655 } 656 657 ActivityRecord topRunningActivityLocked() { 658 final ActivityStack focusedStack = getFocusedStack(); 659 ActivityRecord r = focusedStack.topRunningActivityLocked(null); 660 if (r != null) { 661 return r; 662 } 663 664 // Return to the home stack. 665 final ArrayList<ActivityStack> stacks = mHomeStack.mStacks; 666 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 667 final ActivityStack stack = stacks.get(stackNdx); 668 if (stack != focusedStack && isFrontStack(stack)) { 669 r = stack.topRunningActivityLocked(null); 670 if (r != null) { 671 return r; 672 } 673 } 674 } 675 return null; 676 } 677 678 void getTasksLocked(int maxNum, List<RunningTaskInfo> list, int callingUid, boolean allowed) { 679 // Gather all of the running tasks for each stack into runningTaskLists. 680 ArrayList<ArrayList<RunningTaskInfo>> runningTaskLists = 681 new ArrayList<ArrayList<RunningTaskInfo>>(); 682 final int numDisplays = mActivityDisplays.size(); 683 for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) { 684 ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 685 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 686 final ActivityStack stack = stacks.get(stackNdx); 687 ArrayList<RunningTaskInfo> stackTaskList = new ArrayList<RunningTaskInfo>(); 688 runningTaskLists.add(stackTaskList); 689 stack.getTasksLocked(stackTaskList, callingUid, allowed); 690 } 691 } 692 693 // The lists are already sorted from most recent to oldest. Just pull the most recent off 694 // each list and add it to list. Stop when all lists are empty or maxNum reached. 695 while (maxNum > 0) { 696 long mostRecentActiveTime = Long.MIN_VALUE; 697 ArrayList<RunningTaskInfo> selectedStackList = null; 698 final int numTaskLists = runningTaskLists.size(); 699 for (int stackNdx = 0; stackNdx < numTaskLists; ++stackNdx) { 700 ArrayList<RunningTaskInfo> stackTaskList = runningTaskLists.get(stackNdx); 701 if (!stackTaskList.isEmpty()) { 702 final long lastActiveTime = stackTaskList.get(0).lastActiveTime; 703 if (lastActiveTime > mostRecentActiveTime) { 704 mostRecentActiveTime = lastActiveTime; 705 selectedStackList = stackTaskList; 706 } 707 } 708 } 709 if (selectedStackList != null) { 710 list.add(selectedStackList.remove(0)); 711 --maxNum; 712 } else { 713 break; 714 } 715 } 716 } 717 718 ActivityInfo resolveActivity(Intent intent, String resolvedType, int startFlags, 719 String profileFile, ParcelFileDescriptor profileFd, int userId) { 720 // Collect information about the target of the Intent. 721 ActivityInfo aInfo; 722 try { 723 ResolveInfo rInfo = 724 AppGlobals.getPackageManager().resolveIntent( 725 intent, resolvedType, 726 PackageManager.MATCH_DEFAULT_ONLY 727 | ActivityManagerService.STOCK_PM_FLAGS, userId); 728 aInfo = rInfo != null ? rInfo.activityInfo : null; 729 } catch (RemoteException e) { 730 aInfo = null; 731 } 732 733 if (aInfo != null) { 734 // Store the found target back into the intent, because now that 735 // we have it we never want to do this again. For example, if the 736 // user navigates back to this point in the history, we should 737 // always restart the exact same activity. 738 intent.setComponent(new ComponentName( 739 aInfo.applicationInfo.packageName, aInfo.name)); 740 741 // Don't debug things in the system process 742 if ((startFlags&ActivityManager.START_FLAG_DEBUG) != 0) { 743 if (!aInfo.processName.equals("system")) { 744 mService.setDebugApp(aInfo.processName, true, false); 745 } 746 } 747 748 if ((startFlags&ActivityManager.START_FLAG_OPENGL_TRACES) != 0) { 749 if (!aInfo.processName.equals("system")) { 750 mService.setOpenGlTraceApp(aInfo.applicationInfo, aInfo.processName); 751 } 752 } 753 754 if (profileFile != null) { 755 if (!aInfo.processName.equals("system")) { 756 mService.setProfileApp(aInfo.applicationInfo, aInfo.processName, 757 profileFile, profileFd, 758 (startFlags&ActivityManager.START_FLAG_AUTO_STOP_PROFILER) != 0); 759 } 760 } 761 } 762 return aInfo; 763 } 764 765 void startHomeActivity(Intent intent, ActivityInfo aInfo) { 766 moveHomeStackTaskToTop(HOME_ACTIVITY_TYPE); 767 startActivityLocked(null, intent, null, aInfo, null, null, null, null, 0, 0, 0, null, 0, 768 null, false, null, null); 769 } 770 771 final int startActivityMayWait(IApplicationThread caller, int callingUid, 772 String callingPackage, Intent intent, String resolvedType, 773 IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor, 774 IBinder resultTo, String resultWho, int requestCode, int startFlags, String profileFile, 775 ParcelFileDescriptor profileFd, WaitResult outResult, Configuration config, 776 Bundle options, int userId, IActivityContainer iContainer) { 777 // Refuse possible leaked file descriptors 778 if (intent != null && intent.hasFileDescriptors()) { 779 throw new IllegalArgumentException("File descriptors passed in Intent"); 780 } 781 boolean componentSpecified = intent.getComponent() != null; 782 783 // Don't modify the client's object! 784 intent = new Intent(intent); 785 786 // Collect information about the target of the Intent. 787 ActivityInfo aInfo = resolveActivity(intent, resolvedType, startFlags, 788 profileFile, profileFd, userId); 789 790 ActivityContainer container = (ActivityContainer)iContainer; 791 synchronized (mService) { 792 int callingPid; 793 if (callingUid >= 0) { 794 callingPid = -1; 795 } else if (caller == null) { 796 callingPid = Binder.getCallingPid(); 797 callingUid = Binder.getCallingUid(); 798 } else { 799 callingPid = callingUid = -1; 800 } 801 802 final ActivityStack stack; 803 if (container == null || container.mStack.isOnHomeDisplay()) { 804 stack = getFocusedStack(); 805 } else { 806 stack = container.mStack; 807 } 808 stack.mConfigWillChange = config != null 809 && mService.mConfiguration.diff(config) != 0; 810 if (DEBUG_CONFIGURATION) Slog.v(TAG, 811 "Starting activity when config will change = " + stack.mConfigWillChange); 812 813 final long origId = Binder.clearCallingIdentity(); 814 815 if (aInfo != null && 816 (aInfo.applicationInfo.flags&ApplicationInfo.FLAG_CANT_SAVE_STATE) != 0) { 817 // This may be a heavy-weight process! Check to see if we already 818 // have another, different heavy-weight process running. 819 if (aInfo.processName.equals(aInfo.applicationInfo.packageName)) { 820 if (mService.mHeavyWeightProcess != null && 821 (mService.mHeavyWeightProcess.info.uid != aInfo.applicationInfo.uid || 822 !mService.mHeavyWeightProcess.processName.equals(aInfo.processName))) { 823 int realCallingUid = callingUid; 824 if (caller != null) { 825 ProcessRecord callerApp = mService.getRecordForAppLocked(caller); 826 if (callerApp != null) { 827 realCallingUid = callerApp.info.uid; 828 } else { 829 Slog.w(TAG, "Unable to find app for caller " + caller 830 + " (pid=" + callingPid + ") when starting: " 831 + intent.toString()); 832 ActivityOptions.abort(options); 833 return ActivityManager.START_PERMISSION_DENIED; 834 } 835 } 836 837 IIntentSender target = mService.getIntentSenderLocked( 838 ActivityManager.INTENT_SENDER_ACTIVITY, "android", 839 realCallingUid, userId, null, null, 0, new Intent[] { intent }, 840 new String[] { resolvedType }, PendingIntent.FLAG_CANCEL_CURRENT 841 | PendingIntent.FLAG_ONE_SHOT, null); 842 843 Intent newIntent = new Intent(); 844 if (requestCode >= 0) { 845 // Caller is requesting a result. 846 newIntent.putExtra(HeavyWeightSwitcherActivity.KEY_HAS_RESULT, true); 847 } 848 newIntent.putExtra(HeavyWeightSwitcherActivity.KEY_INTENT, 849 new IntentSender(target)); 850 if (mService.mHeavyWeightProcess.activities.size() > 0) { 851 ActivityRecord hist = mService.mHeavyWeightProcess.activities.get(0); 852 newIntent.putExtra(HeavyWeightSwitcherActivity.KEY_CUR_APP, 853 hist.packageName); 854 newIntent.putExtra(HeavyWeightSwitcherActivity.KEY_CUR_TASK, 855 hist.task.taskId); 856 } 857 newIntent.putExtra(HeavyWeightSwitcherActivity.KEY_NEW_APP, 858 aInfo.packageName); 859 newIntent.setFlags(intent.getFlags()); 860 newIntent.setClassName("android", 861 HeavyWeightSwitcherActivity.class.getName()); 862 intent = newIntent; 863 resolvedType = null; 864 caller = null; 865 callingUid = Binder.getCallingUid(); 866 callingPid = Binder.getCallingPid(); 867 componentSpecified = true; 868 try { 869 ResolveInfo rInfo = 870 AppGlobals.getPackageManager().resolveIntent( 871 intent, null, 872 PackageManager.MATCH_DEFAULT_ONLY 873 | ActivityManagerService.STOCK_PM_FLAGS, userId); 874 aInfo = rInfo != null ? rInfo.activityInfo : null; 875 aInfo = mService.getActivityInfoForUser(aInfo, userId); 876 } catch (RemoteException e) { 877 aInfo = null; 878 } 879 } 880 } 881 } 882 883 int res = startActivityLocked(caller, intent, resolvedType, aInfo, 884 voiceSession, voiceInteractor, resultTo, resultWho, 885 requestCode, callingPid, callingUid, callingPackage, startFlags, options, 886 componentSpecified, null, container); 887 888 if (stack.mConfigWillChange) { 889 // If the caller also wants to switch to a new configuration, 890 // do so now. This allows a clean switch, as we are waiting 891 // for the current activity to pause (so we will not destroy 892 // it), and have not yet started the next activity. 893 mService.enforceCallingPermission(android.Manifest.permission.CHANGE_CONFIGURATION, 894 "updateConfiguration()"); 895 stack.mConfigWillChange = false; 896 if (DEBUG_CONFIGURATION) Slog.v(TAG, 897 "Updating to new configuration after starting activity."); 898 mService.updateConfigurationLocked(config, null, false, false); 899 } 900 901 Binder.restoreCallingIdentity(origId); 902 903 if (outResult != null) { 904 outResult.result = res; 905 if (res == ActivityManager.START_SUCCESS) { 906 mWaitingActivityLaunched.add(outResult); 907 do { 908 try { 909 mService.wait(); 910 } catch (InterruptedException e) { 911 } 912 } while (!outResult.timeout && outResult.who == null); 913 } else if (res == ActivityManager.START_TASK_TO_FRONT) { 914 ActivityRecord r = stack.topRunningActivityLocked(null); 915 if (r.nowVisible) { 916 outResult.timeout = false; 917 outResult.who = new ComponentName(r.info.packageName, r.info.name); 918 outResult.totalTime = 0; 919 outResult.thisTime = 0; 920 } else { 921 outResult.thisTime = SystemClock.uptimeMillis(); 922 mWaitingActivityVisible.add(outResult); 923 do { 924 try { 925 mService.wait(); 926 } catch (InterruptedException e) { 927 } 928 } while (!outResult.timeout && outResult.who == null); 929 } 930 } 931 } 932 933 return res; 934 } 935 } 936 937 final int startActivities(IApplicationThread caller, int callingUid, String callingPackage, 938 Intent[] intents, String[] resolvedTypes, IBinder resultTo, 939 Bundle options, int userId) { 940 if (intents == null) { 941 throw new NullPointerException("intents is null"); 942 } 943 if (resolvedTypes == null) { 944 throw new NullPointerException("resolvedTypes is null"); 945 } 946 if (intents.length != resolvedTypes.length) { 947 throw new IllegalArgumentException("intents are length different than resolvedTypes"); 948 } 949 950 951 int callingPid; 952 if (callingUid >= 0) { 953 callingPid = -1; 954 } else if (caller == null) { 955 callingPid = Binder.getCallingPid(); 956 callingUid = Binder.getCallingUid(); 957 } else { 958 callingPid = callingUid = -1; 959 } 960 final long origId = Binder.clearCallingIdentity(); 961 try { 962 synchronized (mService) { 963 ActivityRecord[] outActivity = new ActivityRecord[1]; 964 for (int i=0; i<intents.length; i++) { 965 Intent intent = intents[i]; 966 if (intent == null) { 967 continue; 968 } 969 970 // Refuse possible leaked file descriptors 971 if (intent != null && intent.hasFileDescriptors()) { 972 throw new IllegalArgumentException("File descriptors passed in Intent"); 973 } 974 975 boolean componentSpecified = intent.getComponent() != null; 976 977 // Don't modify the client's object! 978 intent = new Intent(intent); 979 980 // Collect information about the target of the Intent. 981 ActivityInfo aInfo = resolveActivity(intent, resolvedTypes[i], 982 0, null, null, userId); 983 // TODO: New, check if this is correct 984 aInfo = mService.getActivityInfoForUser(aInfo, userId); 985 986 if (aInfo != null && 987 (aInfo.applicationInfo.flags & ApplicationInfo.FLAG_CANT_SAVE_STATE) 988 != 0) { 989 throw new IllegalArgumentException( 990 "FLAG_CANT_SAVE_STATE not supported here"); 991 } 992 993 Bundle theseOptions; 994 if (options != null && i == intents.length-1) { 995 theseOptions = options; 996 } else { 997 theseOptions = null; 998 } 999 int res = startActivityLocked(caller, intent, resolvedTypes[i], 1000 aInfo, null, null, resultTo, null, -1, callingPid, callingUid, callingPackage, 1001 0, theseOptions, componentSpecified, outActivity, null); 1002 if (res < 0) { 1003 return res; 1004 } 1005 1006 resultTo = outActivity[0] != null ? outActivity[0].appToken : null; 1007 } 1008 } 1009 } finally { 1010 Binder.restoreCallingIdentity(origId); 1011 } 1012 1013 return ActivityManager.START_SUCCESS; 1014 } 1015 1016 final boolean realStartActivityLocked(ActivityRecord r, 1017 ProcessRecord app, boolean andResume, boolean checkConfig) 1018 throws RemoteException { 1019 1020 r.startFreezingScreenLocked(app, 0); 1021 if (false) Slog.d(TAG, "realStartActivity: setting app visibility true"); 1022 mWindowManager.setAppVisibility(r.appToken, true); 1023 1024 // schedule launch ticks to collect information about slow apps. 1025 r.startLaunchTickingLocked(); 1026 1027 // Have the window manager re-evaluate the orientation of 1028 // the screen based on the new activity order. Note that 1029 // as a result of this, it can call back into the activity 1030 // manager with a new orientation. We don't care about that, 1031 // because the activity is not currently running so we are 1032 // just restarting it anyway. 1033 if (checkConfig) { 1034 Configuration config = mWindowManager.updateOrientationFromAppTokens( 1035 mService.mConfiguration, 1036 r.mayFreezeScreenLocked(app) ? r.appToken : null); 1037 mService.updateConfigurationLocked(config, r, false, false); 1038 } 1039 1040 r.app = app; 1041 app.waitingToKill = null; 1042 r.launchCount++; 1043 r.lastLaunchTime = SystemClock.uptimeMillis(); 1044 1045 if (localLOGV) Slog.v(TAG, "Launching: " + r); 1046 1047 int idx = app.activities.indexOf(r); 1048 if (idx < 0) { 1049 app.activities.add(r); 1050 } 1051 mService.updateLruProcessLocked(app, true, null); 1052 mService.updateOomAdjLocked(); 1053 1054 final ActivityStack stack = r.task.stack; 1055 try { 1056 if (app.thread == null) { 1057 throw new RemoteException(); 1058 } 1059 List<ResultInfo> results = null; 1060 List<Intent> newIntents = null; 1061 if (andResume) { 1062 results = r.results; 1063 newIntents = r.newIntents; 1064 } 1065 if (DEBUG_SWITCH) Slog.v(TAG, "Launching: " + r 1066 + " icicle=" + r.icicle 1067 + " with results=" + results + " newIntents=" + newIntents 1068 + " andResume=" + andResume); 1069 if (andResume) { 1070 EventLog.writeEvent(EventLogTags.AM_RESTART_ACTIVITY, 1071 r.userId, System.identityHashCode(r), 1072 r.task.taskId, r.shortComponentName); 1073 } 1074 if (r.isHomeActivity() && r.isNotResolverActivity()) { 1075 // Home process is the root process of the task. 1076 mService.mHomeProcess = r.task.mActivities.get(0).app; 1077 } 1078 mService.ensurePackageDexOpt(r.intent.getComponent().getPackageName()); 1079 r.sleeping = false; 1080 r.forceNewConfig = false; 1081 mService.showAskCompatModeDialogLocked(r); 1082 r.compat = mService.compatibilityInfoForPackageLocked(r.info.applicationInfo); 1083 String profileFile = null; 1084 ParcelFileDescriptor profileFd = null; 1085 boolean profileAutoStop = false; 1086 if (mService.mProfileApp != null && mService.mProfileApp.equals(app.processName)) { 1087 if (mService.mProfileProc == null || mService.mProfileProc == app) { 1088 mService.mProfileProc = app; 1089 profileFile = mService.mProfileFile; 1090 profileFd = mService.mProfileFd; 1091 profileAutoStop = mService.mAutoStopProfiler; 1092 } 1093 } 1094 app.hasShownUi = true; 1095 app.pendingUiClean = true; 1096 if (profileFd != null) { 1097 try { 1098 profileFd = profileFd.dup(); 1099 } catch (IOException e) { 1100 if (profileFd != null) { 1101 try { 1102 profileFd.close(); 1103 } catch (IOException o) { 1104 } 1105 profileFd = null; 1106 } 1107 } 1108 } 1109 1110 app.forceProcessStateUpTo(ActivityManager.PROCESS_STATE_TOP); 1111 app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken, 1112 System.identityHashCode(r), r.info, 1113 new Configuration(mService.mConfiguration), r.compat, r.task.voiceInteractor, 1114 app.repProcState, r.icicle, r.persistentState, results, newIntents, !andResume, 1115 mService.isNextTransitionForward(), profileFile, profileFd, profileAutoStop 1116 ); 1117 1118 if ((app.info.flags&ApplicationInfo.FLAG_CANT_SAVE_STATE) != 0) { 1119 // This may be a heavy-weight process! Note that the package 1120 // manager will ensure that only activity can run in the main 1121 // process of the .apk, which is the only thing that will be 1122 // considered heavy-weight. 1123 if (app.processName.equals(app.info.packageName)) { 1124 if (mService.mHeavyWeightProcess != null 1125 && mService.mHeavyWeightProcess != app) { 1126 Slog.w(TAG, "Starting new heavy weight process " + app 1127 + " when already running " 1128 + mService.mHeavyWeightProcess); 1129 } 1130 mService.mHeavyWeightProcess = app; 1131 Message msg = mService.mHandler.obtainMessage( 1132 ActivityManagerService.POST_HEAVY_NOTIFICATION_MSG); 1133 msg.obj = r; 1134 mService.mHandler.sendMessage(msg); 1135 } 1136 } 1137 1138 } catch (RemoteException e) { 1139 if (r.launchFailed) { 1140 // This is the second time we failed -- finish activity 1141 // and give up. 1142 Slog.e(TAG, "Second failure launching " 1143 + r.intent.getComponent().flattenToShortString() 1144 + ", giving up", e); 1145 mService.appDiedLocked(app, app.pid, app.thread); 1146 stack.requestFinishActivityLocked(r.appToken, Activity.RESULT_CANCELED, null, 1147 "2nd-crash", false); 1148 return false; 1149 } 1150 1151 // This is the first time we failed -- restart process and 1152 // retry. 1153 app.activities.remove(r); 1154 throw e; 1155 } 1156 1157 r.launchFailed = false; 1158 if (stack.updateLRUListLocked(r)) { 1159 Slog.w(TAG, "Activity " + r 1160 + " being launched, but already in LRU list"); 1161 } 1162 1163 if (andResume) { 1164 // As part of the process of launching, ActivityThread also performs 1165 // a resume. 1166 stack.minimalResumeActivityLocked(r); 1167 } else { 1168 // This activity is not starting in the resumed state... which 1169 // should look like we asked it to pause+stop (but remain visible), 1170 // and it has done so and reported back the current icicle and 1171 // other state. 1172 if (DEBUG_STATES) Slog.v(TAG, "Moving to STOPPED: " + r 1173 + " (starting in stopped state)"); 1174 r.state = ActivityState.STOPPED; 1175 r.stopped = true; 1176 } 1177 1178 // Launch the new version setup screen if needed. We do this -after- 1179 // launching the initial activity (that is, home), so that it can have 1180 // a chance to initialize itself while in the background, making the 1181 // switch back to it faster and look better. 1182 if (isFrontStack(stack)) { 1183 mService.startSetupActivityLocked(); 1184 } 1185 1186 return true; 1187 } 1188 1189 void startSpecificActivityLocked(ActivityRecord r, 1190 boolean andResume, boolean checkConfig) { 1191 // Is this activity's application already running? 1192 ProcessRecord app = mService.getProcessRecordLocked(r.processName, 1193 r.info.applicationInfo.uid, true); 1194 1195 r.task.stack.setLaunchTime(r); 1196 1197 if (app != null && app.thread != null) { 1198 try { 1199 if ((r.info.flags&ActivityInfo.FLAG_MULTIPROCESS) == 0 1200 || !"android".equals(r.info.packageName)) { 1201 // Don't add this if it is a platform component that is marked 1202 // to run in multiple processes, because this is actually 1203 // part of the framework so doesn't make sense to track as a 1204 // separate apk in the process. 1205 app.addPackage(r.info.packageName, r.info.applicationInfo.versionCode, 1206 mService.mProcessStats); 1207 } 1208 realStartActivityLocked(r, app, andResume, checkConfig); 1209 return; 1210 } catch (RemoteException e) { 1211 Slog.w(TAG, "Exception when starting activity " 1212 + r.intent.getComponent().flattenToShortString(), e); 1213 } 1214 1215 // If a dead object exception was thrown -- fall through to 1216 // restart the application. 1217 } 1218 1219 mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0, 1220 "activity", r.intent.getComponent(), false, false, true); 1221 } 1222 1223 final int startActivityLocked(IApplicationThread caller, 1224 Intent intent, String resolvedType, ActivityInfo aInfo, 1225 IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor, 1226 IBinder resultTo, String resultWho, int requestCode, 1227 int callingPid, int callingUid, String callingPackage, int startFlags, Bundle options, 1228 boolean componentSpecified, ActivityRecord[] outActivity, ActivityContainer container) { 1229 int err = ActivityManager.START_SUCCESS; 1230 1231 ProcessRecord callerApp = null; 1232 if (caller != null) { 1233 callerApp = mService.getRecordForAppLocked(caller); 1234 if (callerApp != null) { 1235 callingPid = callerApp.pid; 1236 callingUid = callerApp.info.uid; 1237 } else { 1238 Slog.w(TAG, "Unable to find app for caller " + caller 1239 + " (pid=" + callingPid + ") when starting: " 1240 + intent.toString()); 1241 err = ActivityManager.START_PERMISSION_DENIED; 1242 } 1243 } 1244 1245 if (err == ActivityManager.START_SUCCESS) { 1246 final int userId = aInfo != null ? UserHandle.getUserId(aInfo.applicationInfo.uid) : 0; 1247 Slog.i(TAG, "START u" + userId + " {" + intent.toShortString(true, true, true, false) 1248 + "} from pid " + (callerApp != null ? callerApp.pid : callingPid) 1249 + " on display " + (container == null ? (mFocusedStack == null ? 1250 Display.DEFAULT_DISPLAY : mFocusedStack.mDisplayId) : 1251 (container.mActivityDisplay == null ? Display.DEFAULT_DISPLAY : 1252 container.mActivityDisplay.mDisplayId))); 1253 } 1254 1255 ActivityRecord sourceRecord = null; 1256 ActivityRecord resultRecord = null; 1257 if (resultTo != null) { 1258 sourceRecord = isInAnyStackLocked(resultTo); 1259 if (DEBUG_RESULTS) Slog.v( 1260 TAG, "Will send result to " + resultTo + " " + sourceRecord); 1261 if (sourceRecord != null) { 1262 if (requestCode >= 0 && !sourceRecord.finishing) { 1263 resultRecord = sourceRecord; 1264 } 1265 } 1266 } 1267 ActivityStack resultStack = resultRecord == null ? null : resultRecord.task.stack; 1268 1269 final int launchFlags = intent.getFlags(); 1270 1271 if ((launchFlags&Intent.FLAG_ACTIVITY_FORWARD_RESULT) != 0 1272 && sourceRecord != null) { 1273 // Transfer the result target from the source activity to the new 1274 // one being started, including any failures. 1275 if (requestCode >= 0) { 1276 ActivityOptions.abort(options); 1277 return ActivityManager.START_FORWARD_AND_REQUEST_CONFLICT; 1278 } 1279 resultRecord = sourceRecord.resultTo; 1280 resultWho = sourceRecord.resultWho; 1281 requestCode = sourceRecord.requestCode; 1282 sourceRecord.resultTo = null; 1283 if (resultRecord != null) { 1284 resultRecord.removeResultsLocked(sourceRecord, resultWho, requestCode); 1285 } 1286 if (sourceRecord.launchedFromUid == callingUid) { 1287 // The new activity is being launched from the same uid as the previous 1288 // activity in the flow, and asking to forward its result back to the 1289 // previous. In this case the activity is serving as a trampoline between 1290 // the two, so we also want to update its launchedFromPackage to be the 1291 // same as the previous activity. Note that this is safe, since we know 1292 // these two packages come from the same uid; the caller could just as 1293 // well have supplied that same package name itself. This specifially 1294 // deals with the case of an intent picker/chooser being launched in the app 1295 // flow to redirect to an activity picked by the user, where we want the final 1296 // activity to consider it to have been launched by the previous app activity. 1297 callingPackage = sourceRecord.launchedFromPackage; 1298 } 1299 } 1300 1301 if (err == ActivityManager.START_SUCCESS && intent.getComponent() == null) { 1302 // We couldn't find a class that can handle the given Intent. 1303 // That's the end of that! 1304 err = ActivityManager.START_INTENT_NOT_RESOLVED; 1305 } 1306 1307 if (err == ActivityManager.START_SUCCESS && aInfo == null) { 1308 // We couldn't find the specific class specified in the Intent. 1309 // Also the end of the line. 1310 err = ActivityManager.START_CLASS_NOT_FOUND; 1311 } 1312 1313 if (err == ActivityManager.START_SUCCESS && sourceRecord != null 1314 && sourceRecord.task.voiceSession != null) { 1315 // If this activity is being launched as part of a voice session, we need 1316 // to ensure that it is safe to do so. If the upcoming activity will also 1317 // be part of the voice session, we can only launch it if it has explicitly 1318 // said it supports the VOICE category, or it is a part of the calling app. 1319 if ((launchFlags & Intent.FLAG_ACTIVITY_NEW_TASK) == 0 1320 && sourceRecord.info.applicationInfo.uid != aInfo.applicationInfo.uid) { 1321 try { 1322 if (!AppGlobals.getPackageManager().activitySupportsIntent(intent.getComponent(), 1323 intent, resolvedType)) { 1324 err = ActivityManager.START_NOT_VOICE_COMPATIBLE; 1325 } 1326 } catch (RemoteException e) { 1327 err = ActivityManager.START_NOT_VOICE_COMPATIBLE; 1328 } 1329 } 1330 } 1331 1332 if (err == ActivityManager.START_SUCCESS && voiceSession != null) { 1333 // If the caller is starting a new voice session, just make sure the target 1334 // is actually allowing it to run this way. 1335 try { 1336 if (!AppGlobals.getPackageManager().activitySupportsIntent(intent.getComponent(), 1337 intent, resolvedType)) { 1338 err = ActivityManager.START_NOT_VOICE_COMPATIBLE; 1339 } 1340 } catch (RemoteException e) { 1341 err = ActivityManager.START_NOT_VOICE_COMPATIBLE; 1342 } 1343 } 1344 1345 if (err != ActivityManager.START_SUCCESS) { 1346 if (resultRecord != null) { 1347 resultStack.sendActivityResultLocked(-1, 1348 resultRecord, resultWho, requestCode, 1349 Activity.RESULT_CANCELED, null); 1350 } 1351 setDismissKeyguard(false); 1352 ActivityOptions.abort(options); 1353 return err; 1354 } 1355 1356 final int startAnyPerm = mService.checkPermission( 1357 START_ANY_ACTIVITY, callingPid, callingUid); 1358 final int componentPerm = mService.checkComponentPermission(aInfo.permission, callingPid, 1359 callingUid, aInfo.applicationInfo.uid, aInfo.exported); 1360 if (startAnyPerm != PERMISSION_GRANTED && componentPerm != PERMISSION_GRANTED) { 1361 if (resultRecord != null) { 1362 resultStack.sendActivityResultLocked(-1, 1363 resultRecord, resultWho, requestCode, 1364 Activity.RESULT_CANCELED, null); 1365 } 1366 setDismissKeyguard(false); 1367 String msg; 1368 if (!aInfo.exported) { 1369 msg = "Permission Denial: starting " + intent.toString() 1370 + " from " + callerApp + " (pid=" + callingPid 1371 + ", uid=" + callingUid + ")" 1372 + " not exported from uid " + aInfo.applicationInfo.uid; 1373 } else { 1374 msg = "Permission Denial: starting " + intent.toString() 1375 + " from " + callerApp + " (pid=" + callingPid 1376 + ", uid=" + callingUid + ")" 1377 + " requires " + aInfo.permission; 1378 } 1379 Slog.w(TAG, msg); 1380 throw new SecurityException(msg); 1381 } 1382 1383 boolean abort = !mService.mIntentFirewall.checkStartActivity(intent, callingUid, 1384 callingPid, resolvedType, aInfo.applicationInfo); 1385 1386 if (mService.mController != null) { 1387 try { 1388 // The Intent we give to the watcher has the extra data 1389 // stripped off, since it can contain private information. 1390 Intent watchIntent = intent.cloneFilter(); 1391 abort |= !mService.mController.activityStarting(watchIntent, 1392 aInfo.applicationInfo.packageName); 1393 } catch (RemoteException e) { 1394 mService.mController = null; 1395 } 1396 } 1397 1398 if (abort) { 1399 if (resultRecord != null) { 1400 resultStack.sendActivityResultLocked(-1, resultRecord, resultWho, requestCode, 1401 Activity.RESULT_CANCELED, null); 1402 } 1403 // We pretend to the caller that it was really started, but 1404 // they will just get a cancel result. 1405 setDismissKeyguard(false); 1406 ActivityOptions.abort(options); 1407 return ActivityManager.START_SUCCESS; 1408 } 1409 1410 ActivityRecord r = new ActivityRecord(mService, callerApp, callingUid, callingPackage, 1411 intent, resolvedType, aInfo, mService.mConfiguration, resultRecord, resultWho, 1412 requestCode, componentSpecified, this, container, options); 1413 if (outActivity != null) { 1414 outActivity[0] = r; 1415 } 1416 1417 final ActivityStack stack = getFocusedStack(); 1418 if (voiceSession == null && (stack.mResumedActivity == null 1419 || stack.mResumedActivity.info.applicationInfo.uid != callingUid)) { 1420 if (!mService.checkAppSwitchAllowedLocked(callingPid, callingUid, "Activity start")) { 1421 PendingActivityLaunch pal = 1422 new PendingActivityLaunch(r, sourceRecord, startFlags, stack); 1423 mService.mPendingActivityLaunches.add(pal); 1424 setDismissKeyguard(false); 1425 ActivityOptions.abort(options); 1426 return ActivityManager.START_SWITCHES_CANCELED; 1427 } 1428 } 1429 1430 if (mService.mDidAppSwitch) { 1431 // This is the second allowed switch since we stopped switches, 1432 // so now just generally allow switches. Use case: user presses 1433 // home (switches disabled, switch to home, mDidAppSwitch now true); 1434 // user taps a home icon (coming from home so allowed, we hit here 1435 // and now allow anyone to switch again). 1436 mService.mAppSwitchesAllowedTime = 0; 1437 } else { 1438 mService.mDidAppSwitch = true; 1439 } 1440 1441 mService.doPendingActivityLaunchesLocked(false); 1442 1443 err = startActivityUncheckedLocked(r, sourceRecord, voiceSession, voiceInteractor, 1444 startFlags, true, options); 1445 1446 if (allPausedActivitiesComplete()) { 1447 // If someone asked to have the keyguard dismissed on the next 1448 // activity start, but we are not actually doing an activity 1449 // switch... just dismiss the keyguard now, because we 1450 // probably want to see whatever is behind it. 1451 dismissKeyguard(); 1452 } 1453 return err; 1454 } 1455 1456 ActivityStack adjustStackFocus(ActivityRecord r, boolean newTask) { 1457 final TaskRecord task = r.task; 1458 1459 // On leanback only devices we should keep all activities in the same stack. 1460 if (!mLeanbackOnlyDevice && 1461 (r.isApplicationActivity() || (task != null && task.isApplicationTask()))) { 1462 if (task != null) { 1463 final ActivityStack taskStack = task.stack; 1464 if (taskStack.isOnHomeDisplay()) { 1465 if (mFocusedStack != taskStack) { 1466 if (DEBUG_FOCUS || DEBUG_STACK) Slog.d(TAG, "adjustStackFocus: Setting " + 1467 "focused stack to r=" + r + " task=" + task); 1468 mFocusedStack = taskStack; 1469 } else { 1470 if (DEBUG_FOCUS || DEBUG_STACK) Slog.d(TAG, 1471 "adjustStackFocus: Focused stack already=" + mFocusedStack); 1472 } 1473 } 1474 return taskStack; 1475 } 1476 1477 final ActivityContainer container = r.mInitialActivityContainer; 1478 if (container != null) { 1479 // The first time put it on the desired stack, after this put on task stack. 1480 r.mInitialActivityContainer = null; 1481 return container.mStack; 1482 } 1483 1484 if (mFocusedStack != mHomeStack && (!newTask || 1485 mFocusedStack.mActivityContainer.isEligibleForNewTasks())) { 1486 if (DEBUG_FOCUS || DEBUG_STACK) Slog.d(TAG, 1487 "adjustStackFocus: Have a focused stack=" + mFocusedStack); 1488 return mFocusedStack; 1489 } 1490 1491 final ArrayList<ActivityStack> homeDisplayStacks = mHomeStack.mStacks; 1492 for (int stackNdx = homeDisplayStacks.size() - 1; stackNdx >= 0; --stackNdx) { 1493 final ActivityStack stack = homeDisplayStacks.get(stackNdx); 1494 if (!stack.isHomeStack()) { 1495 if (DEBUG_FOCUS || DEBUG_STACK) Slog.d(TAG, 1496 "adjustStackFocus: Setting focused stack=" + stack); 1497 mFocusedStack = stack; 1498 return mFocusedStack; 1499 } 1500 } 1501 1502 // Need to create an app stack for this user. 1503 int stackId = createStackOnDisplay(getNextStackId(), Display.DEFAULT_DISPLAY); 1504 if (DEBUG_FOCUS || DEBUG_STACK) Slog.d(TAG, "adjustStackFocus: New stack r=" + r + 1505 " stackId=" + stackId); 1506 mFocusedStack = getStack(stackId); 1507 return mFocusedStack; 1508 } 1509 return mHomeStack; 1510 } 1511 1512 void setFocusedStack(ActivityRecord r) { 1513 if (r != null) { 1514 final TaskRecord task = r.task; 1515 boolean isHomeActivity = !r.isApplicationActivity(); 1516 if (!isHomeActivity && task != null) { 1517 isHomeActivity = !task.isApplicationTask(); 1518 } 1519 if (!isHomeActivity && task != null) { 1520 final ActivityRecord parent = task.stack.mActivityContainer.mParentActivity; 1521 isHomeActivity = parent != null && parent.isHomeActivity(); 1522 } 1523 moveHomeStack(isHomeActivity); 1524 } 1525 } 1526 1527 final int startActivityUncheckedLocked(ActivityRecord r, 1528 ActivityRecord sourceRecord, 1529 IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor, int startFlags, 1530 boolean doResume, Bundle options) { 1531 final Intent intent = r.intent; 1532 final int callingUid = r.launchedFromUid; 1533 1534 int launchFlags = intent.getFlags(); 1535 1536 if ((launchFlags & Intent.FLAG_ACTIVITY_NEW_DOCUMENT) != 0 && 1537 (r.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE || 1538 r.launchMode == ActivityInfo.LAUNCH_SINGLE_TASK)) { 1539 // We have a conflict between the Intent and the Activity manifest, manifest wins. 1540 Slog.i(TAG, "Ignoring FLAG_ACTIVITY_NEW_DOCUMENT, launchMode is " + 1541 "\"singleInstance\" or \"singleTask\""); 1542 launchFlags &= 1543 ~(Intent.FLAG_ACTIVITY_NEW_DOCUMENT | Intent.FLAG_ACTIVITY_MULTIPLE_TASK); 1544 } else { 1545 switch (r.info.documentLaunchMode) { 1546 case ActivityInfo.DOCUMENT_LAUNCH_NONE: 1547 break; 1548 case ActivityInfo.DOCUMENT_LAUNCH_INTO_EXISTING: 1549 launchFlags |= Intent.FLAG_ACTIVITY_NEW_DOCUMENT; 1550 break; 1551 case ActivityInfo.DOCUMENT_LAUNCH_ALWAYS: 1552 launchFlags |= Intent.FLAG_ACTIVITY_NEW_DOCUMENT; 1553 break; 1554 case ActivityInfo.DOCUMENT_LAUNCH_NEVER: 1555 launchFlags &= ~Intent.FLAG_ACTIVITY_MULTIPLE_TASK; 1556 break; 1557 } 1558 } 1559 1560 if (r.resultTo != null && (launchFlags & Intent.FLAG_ACTIVITY_NEW_TASK) != 0) { 1561 // For whatever reason this activity is being launched into a new 1562 // task... yet the caller has requested a result back. Well, that 1563 // is pretty messed up, so instead immediately send back a cancel 1564 // and let the new task continue launched as normal without a 1565 // dependency on its originator. 1566 Slog.w(TAG, "Activity is launching as a new task, so cancelling activity result."); 1567 r.resultTo.task.stack.sendActivityResultLocked(-1, 1568 r.resultTo, r.resultWho, r.requestCode, 1569 Activity.RESULT_CANCELED, null); 1570 r.resultTo = null; 1571 } 1572 1573 if ((launchFlags & Intent.FLAG_ACTIVITY_NEW_DOCUMENT) != 0 && r.resultTo == null) { 1574 launchFlags |= Intent.FLAG_ACTIVITY_NEW_TASK; 1575 } 1576 1577 // We'll invoke onUserLeaving before onPause only if the launching 1578 // activity did not explicitly state that this is an automated launch. 1579 mUserLeaving = (launchFlags & Intent.FLAG_ACTIVITY_NO_USER_ACTION) == 0; 1580 if (DEBUG_USER_LEAVING) Slog.v(TAG, "startActivity() => mUserLeaving=" + mUserLeaving); 1581 1582 // If the caller has asked not to resume at this point, we make note 1583 // of this in the record so that we can skip it when trying to find 1584 // the top running activity. 1585 if (!doResume) { 1586 r.delayedResume = true; 1587 } 1588 1589 ActivityRecord notTop = 1590 (launchFlags & Intent.FLAG_ACTIVITY_PREVIOUS_IS_TOP) != 0 ? r : null; 1591 1592 // If the onlyIfNeeded flag is set, then we can do this if the activity 1593 // being launched is the same as the one making the call... or, as 1594 // a special case, if we do not know the caller then we count the 1595 // current top activity as the caller. 1596 if ((startFlags&ActivityManager.START_FLAG_ONLY_IF_NEEDED) != 0) { 1597 ActivityRecord checkedCaller = sourceRecord; 1598 if (checkedCaller == null) { 1599 checkedCaller = getFocusedStack().topRunningNonDelayedActivityLocked(notTop); 1600 } 1601 if (!checkedCaller.realActivity.equals(r.realActivity)) { 1602 // Caller is not the same as launcher, so always needed. 1603 startFlags &= ~ActivityManager.START_FLAG_ONLY_IF_NEEDED; 1604 } 1605 } 1606 1607 if (sourceRecord == null) { 1608 // This activity is not being started from another... in this 1609 // case we -always- start a new task. 1610 if ((launchFlags & Intent.FLAG_ACTIVITY_NEW_TASK) == 0) { 1611 Slog.w(TAG, "startActivity called from non-Activity context; forcing " + 1612 "Intent.FLAG_ACTIVITY_NEW_TASK for: " + intent); 1613 launchFlags |= Intent.FLAG_ACTIVITY_NEW_TASK; 1614 } 1615 } else if (sourceRecord.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE) { 1616 // The original activity who is starting us is running as a single 1617 // instance... this new activity it is starting must go on its 1618 // own task. 1619 launchFlags |= Intent.FLAG_ACTIVITY_NEW_TASK; 1620 } else if (r.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE 1621 || r.launchMode == ActivityInfo.LAUNCH_SINGLE_TASK) { 1622 // The activity being started is a single instance... it always 1623 // gets launched into its own task. 1624 launchFlags |= Intent.FLAG_ACTIVITY_NEW_TASK; 1625 } 1626 1627 ActivityInfo newTaskInfo = null; 1628 Intent newTaskIntent = null; 1629 final ActivityStack sourceStack; 1630 if (sourceRecord != null) { 1631 if (sourceRecord.finishing) { 1632 // If the source is finishing, we can't further count it as our source. This 1633 // is because the task it is associated with may now be empty and on its way out, 1634 // so we don't want to blindly throw it in to that task. Instead we will take 1635 // the NEW_TASK flow and try to find a task for it. But save the task information 1636 // so it can be used when creating the new task. 1637 if ((launchFlags & Intent.FLAG_ACTIVITY_NEW_TASK) == 0) { 1638 Slog.w(TAG, "startActivity called from finishing " + sourceRecord 1639 + "; forcing " + "Intent.FLAG_ACTIVITY_NEW_TASK for: " + intent); 1640 launchFlags |= Intent.FLAG_ACTIVITY_NEW_TASK; 1641 newTaskInfo = sourceRecord.info; 1642 newTaskIntent = sourceRecord.task.intent; 1643 } 1644 sourceRecord = null; 1645 sourceStack = null; 1646 } else { 1647 sourceStack = sourceRecord.task.stack; 1648 } 1649 } else { 1650 sourceStack = null; 1651 } 1652 1653 intent.setFlags(launchFlags); 1654 1655 boolean addingToTask = false; 1656 boolean movedHome = false; 1657 TaskRecord reuseTask = null; 1658 ActivityStack targetStack; 1659 if (((launchFlags & Intent.FLAG_ACTIVITY_NEW_TASK) != 0 && 1660 (launchFlags & Intent.FLAG_ACTIVITY_MULTIPLE_TASK) == 0) 1661 || r.launchMode == ActivityInfo.LAUNCH_SINGLE_TASK 1662 || r.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE) { 1663 // If bring to front is requested, and no result is requested, and 1664 // we can find a task that was started with this same 1665 // component, then instead of launching bring that one to the front. 1666 if (r.resultTo == null) { 1667 // See if there is a task to bring to the front. If this is 1668 // a SINGLE_INSTANCE activity, there can be one and only one 1669 // instance of it in the history, and it is always in its own 1670 // unique task, so we do a special search. 1671 ActivityRecord intentActivity = r.launchMode != ActivityInfo.LAUNCH_SINGLE_INSTANCE 1672 ? findTaskLocked(r) 1673 : findActivityLocked(intent, r.info); 1674 if (intentActivity != null) { 1675 if (isLockTaskModeViolation(intentActivity.task)) { 1676 showLockTaskToast(); 1677 Slog.e(TAG, "moveTaskToFront: Attempt to violate Lock Task Mode"); 1678 return ActivityManager.START_RETURN_LOCK_TASK_MODE_VIOLATION; 1679 } 1680 if (r.task == null) { 1681 r.task = intentActivity.task; 1682 } 1683 targetStack = intentActivity.task.stack; 1684 targetStack.mLastPausedActivity = null; 1685 if (DEBUG_TASKS) Slog.d(TAG, "Bring to front target: " + targetStack 1686 + " from " + intentActivity); 1687 targetStack.moveToFront(); 1688 if (intentActivity.task.intent == null) { 1689 // This task was started because of movement of 1690 // the activity based on affinity... now that we 1691 // are actually launching it, we can assign the 1692 // base intent. 1693 intentActivity.task.setIntent(intent, r.info); 1694 } 1695 // If the target task is not in the front, then we need 1696 // to bring it to the front... except... well, with 1697 // SINGLE_TASK_LAUNCH it's not entirely clear. We'd like 1698 // to have the same behavior as if a new instance was 1699 // being started, which means not bringing it to the front 1700 // if the caller is not itself in the front. 1701 final ActivityStack lastStack = getLastStack(); 1702 ActivityRecord curTop = lastStack == null? 1703 null : lastStack.topRunningNonDelayedActivityLocked(notTop); 1704 if (curTop != null && (curTop.task != intentActivity.task || 1705 curTop.task != lastStack.topTask())) { 1706 r.intent.addFlags(Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT); 1707 if (sourceRecord == null || (sourceStack.topActivity() != null && 1708 sourceStack.topActivity().task == sourceRecord.task)) { 1709 // We really do want to push this one into the 1710 // user's face, right now. 1711 movedHome = true; 1712 targetStack.moveTaskToFrontLocked(intentActivity.task, r, options); 1713 if ((launchFlags & 1714 (FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_TASK_ON_HOME)) 1715 == (FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_TASK_ON_HOME)) { 1716 // Caller wants to appear on home activity. 1717 intentActivity.task.setTaskToReturnTo(HOME_ACTIVITY_TYPE); 1718 } 1719 options = null; 1720 } 1721 } 1722 // If the caller has requested that the target task be 1723 // reset, then do so. 1724 if ((launchFlags&Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED) != 0) { 1725 intentActivity = targetStack.resetTaskIfNeededLocked(intentActivity, r); 1726 } 1727 if ((startFlags&ActivityManager.START_FLAG_ONLY_IF_NEEDED) != 0) { 1728 // We don't need to start a new activity, and 1729 // the client said not to do anything if that 1730 // is the case, so this is it! And for paranoia, make 1731 // sure we have correctly resumed the top activity. 1732 if (doResume) { 1733 resumeTopActivitiesLocked(targetStack, null, options); 1734 } else { 1735 ActivityOptions.abort(options); 1736 } 1737 return ActivityManager.START_RETURN_INTENT_TO_CALLER; 1738 } 1739 if ((launchFlags & 1740 (Intent.FLAG_ACTIVITY_NEW_TASK|Intent.FLAG_ACTIVITY_CLEAR_TASK)) 1741 == (Intent.FLAG_ACTIVITY_NEW_TASK|Intent.FLAG_ACTIVITY_CLEAR_TASK)) { 1742 // The caller has requested to completely replace any 1743 // existing task with its new activity. Well that should 1744 // not be too hard... 1745 reuseTask = intentActivity.task; 1746 reuseTask.performClearTaskLocked(); 1747 reuseTask.setIntent(r.intent, r.info); 1748 } else if ((launchFlags&Intent.FLAG_ACTIVITY_CLEAR_TOP) != 0 1749 || r.launchMode == ActivityInfo.LAUNCH_SINGLE_TASK 1750 || r.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE) { 1751 // In this situation we want to remove all activities 1752 // from the task up to the one being started. In most 1753 // cases this means we are resetting the task to its 1754 // initial state. 1755 ActivityRecord top = 1756 intentActivity.task.performClearTaskLocked(r, launchFlags); 1757 if (top != null) { 1758 if (top.frontOfTask) { 1759 // Activity aliases may mean we use different 1760 // intents for the top activity, so make sure 1761 // the task now has the identity of the new 1762 // intent. 1763 top.task.setIntent(r.intent, r.info); 1764 } 1765 ActivityStack.logStartActivity(EventLogTags.AM_NEW_INTENT, 1766 r, top.task); 1767 top.deliverNewIntentLocked(callingUid, r.intent); 1768 } else { 1769 // A special case: we need to 1770 // start the activity because it is not currently 1771 // running, and the caller has asked to clear the 1772 // current task to have this activity at the top. 1773 addingToTask = true; 1774 // Now pretend like this activity is being started 1775 // by the top of its task, so it is put in the 1776 // right place. 1777 sourceRecord = intentActivity; 1778 } 1779 } else if (r.realActivity.equals(intentActivity.task.realActivity)) { 1780 // In this case the top activity on the task is the 1781 // same as the one being launched, so we take that 1782 // as a request to bring the task to the foreground. 1783 // If the top activity in the task is the root 1784 // activity, deliver this new intent to it if it 1785 // desires. 1786 if (((launchFlags&Intent.FLAG_ACTIVITY_SINGLE_TOP) != 0 1787 || r.launchMode == ActivityInfo.LAUNCH_SINGLE_TOP) 1788 && intentActivity.realActivity.equals(r.realActivity)) { 1789 ActivityStack.logStartActivity(EventLogTags.AM_NEW_INTENT, r, 1790 intentActivity.task); 1791 if (intentActivity.frontOfTask) { 1792 intentActivity.task.setIntent(r.intent, r.info); 1793 } 1794 intentActivity.deliverNewIntentLocked(callingUid, r.intent); 1795 } else if (!r.intent.filterEquals(intentActivity.task.intent)) { 1796 // In this case we are launching the root activity 1797 // of the task, but with a different intent. We 1798 // should start a new instance on top. 1799 addingToTask = true; 1800 sourceRecord = intentActivity; 1801 } 1802 } else if ((launchFlags&Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED) == 0) { 1803 // In this case an activity is being launched in to an 1804 // existing task, without resetting that task. This 1805 // is typically the situation of launching an activity 1806 // from a notification or shortcut. We want to place 1807 // the new activity on top of the current task. 1808 addingToTask = true; 1809 sourceRecord = intentActivity; 1810 } else if (!intentActivity.task.rootWasReset) { 1811 // In this case we are launching in to an existing task 1812 // that has not yet been started from its front door. 1813 // The current task has been brought to the front. 1814 // Ideally, we'd probably like to place this new task 1815 // at the bottom of its stack, but that's a little hard 1816 // to do with the current organization of the code so 1817 // for now we'll just drop it. 1818 intentActivity.task.setIntent(r.intent, r.info); 1819 } 1820 if (!addingToTask && reuseTask == null) { 1821 // We didn't do anything... but it was needed (a.k.a., client 1822 // don't use that intent!) And for paranoia, make 1823 // sure we have correctly resumed the top activity. 1824 if (doResume) { 1825 targetStack.resumeTopActivityLocked(null, options); 1826 } else { 1827 ActivityOptions.abort(options); 1828 } 1829 return ActivityManager.START_TASK_TO_FRONT; 1830 } 1831 } 1832 } 1833 } 1834 1835 //String uri = r.intent.toURI(); 1836 //Intent intent2 = new Intent(uri); 1837 //Slog.i(TAG, "Given intent: " + r.intent); 1838 //Slog.i(TAG, "URI is: " + uri); 1839 //Slog.i(TAG, "To intent: " + intent2); 1840 1841 if (r.packageName != null) { 1842 // If the activity being launched is the same as the one currently 1843 // at the top, then we need to check if it should only be launched 1844 // once. 1845 ActivityStack topStack = getFocusedStack(); 1846 ActivityRecord top = topStack.topRunningNonDelayedActivityLocked(notTop); 1847 if (top != null && r.resultTo == null) { 1848 if (top.realActivity.equals(r.realActivity) && top.userId == r.userId) { 1849 if (top.app != null && top.app.thread != null) { 1850 if ((launchFlags & Intent.FLAG_ACTIVITY_SINGLE_TOP) != 0 1851 || r.launchMode == ActivityInfo.LAUNCH_SINGLE_TOP 1852 || r.launchMode == ActivityInfo.LAUNCH_SINGLE_TASK) { 1853 ActivityStack.logStartActivity(EventLogTags.AM_NEW_INTENT, top, 1854 top.task); 1855 // For paranoia, make sure we have correctly 1856 // resumed the top activity. 1857 topStack.mLastPausedActivity = null; 1858 if (doResume) { 1859 resumeTopActivitiesLocked(); 1860 } 1861 ActivityOptions.abort(options); 1862 if ((startFlags&ActivityManager.START_FLAG_ONLY_IF_NEEDED) != 0) { 1863 // We don't need to start a new activity, and 1864 // the client said not to do anything if that 1865 // is the case, so this is it! 1866 return ActivityManager.START_RETURN_INTENT_TO_CALLER; 1867 } 1868 top.deliverNewIntentLocked(callingUid, r.intent); 1869 return ActivityManager.START_DELIVERED_TO_TOP; 1870 } 1871 } 1872 } 1873 } 1874 1875 } else { 1876 if (r.resultTo != null) { 1877 r.resultTo.task.stack.sendActivityResultLocked(-1, r.resultTo, r.resultWho, 1878 r.requestCode, Activity.RESULT_CANCELED, null); 1879 } 1880 ActivityOptions.abort(options); 1881 return ActivityManager.START_CLASS_NOT_FOUND; 1882 } 1883 1884 boolean newTask = false; 1885 boolean keepCurTransition = false; 1886 1887 // Should this be considered a new task? 1888 if (r.resultTo == null && !addingToTask 1889 && (launchFlags & Intent.FLAG_ACTIVITY_NEW_TASK) != 0) { 1890 if (isLockTaskModeViolation(reuseTask)) { 1891 Slog.e(TAG, "Attempted Lock Task Mode violation r=" + r); 1892 return ActivityManager.START_RETURN_LOCK_TASK_MODE_VIOLATION; 1893 } 1894 newTask = true; 1895 targetStack = adjustStackFocus(r, newTask); 1896 targetStack.moveToFront(); 1897 if (reuseTask == null) { 1898 r.setTask(targetStack.createTaskRecord(getNextTaskId(), 1899 newTaskInfo != null ? newTaskInfo : r.info, 1900 newTaskIntent != null ? newTaskIntent : intent, 1901 voiceSession, voiceInteractor, true), true); 1902 if (DEBUG_TASKS) Slog.v(TAG, "Starting new activity " + r + " in new task " + 1903 r.task); 1904 } else { 1905 r.setTask(reuseTask, true); 1906 } 1907 if (!movedHome) { 1908 if ((launchFlags & 1909 (Intent.FLAG_ACTIVITY_NEW_TASK|Intent.FLAG_ACTIVITY_TASK_ON_HOME)) 1910 == (Intent.FLAG_ACTIVITY_NEW_TASK|Intent.FLAG_ACTIVITY_TASK_ON_HOME)) { 1911 // Caller wants to appear on home activity, so before starting 1912 // their own activity we will bring home to the front. 1913 r.task.setTaskToReturnTo(HOME_ACTIVITY_TYPE); 1914 } 1915 } 1916 } else if (sourceRecord != null) { 1917 TaskRecord sourceTask = sourceRecord.task; 1918 if (isLockTaskModeViolation(sourceTask)) { 1919 Slog.e(TAG, "Attempted Lock Task Mode violation r=" + r); 1920 return ActivityManager.START_RETURN_LOCK_TASK_MODE_VIOLATION; 1921 } 1922 targetStack = sourceTask.stack; 1923 targetStack.moveToFront(); 1924 mWindowManager.moveTaskToTop(targetStack.topTask().taskId); 1925 if (!addingToTask && 1926 (launchFlags&Intent.FLAG_ACTIVITY_CLEAR_TOP) != 0) { 1927 // In this case, we are adding the activity to an existing 1928 // task, but the caller has asked to clear that task if the 1929 // activity is already running. 1930 ActivityRecord top = sourceTask.performClearTaskLocked(r, launchFlags); 1931 keepCurTransition = true; 1932 if (top != null) { 1933 ActivityStack.logStartActivity(EventLogTags.AM_NEW_INTENT, r, top.task); 1934 top.deliverNewIntentLocked(callingUid, r.intent); 1935 // For paranoia, make sure we have correctly 1936 // resumed the top activity. 1937 targetStack.mLastPausedActivity = null; 1938 if (doResume) { 1939 targetStack.resumeTopActivityLocked(null); 1940 } 1941 ActivityOptions.abort(options); 1942 return ActivityManager.START_DELIVERED_TO_TOP; 1943 } 1944 } else if (!addingToTask && 1945 (launchFlags&Intent.FLAG_ACTIVITY_REORDER_TO_FRONT) != 0) { 1946 // In this case, we are launching an activity in our own task 1947 // that may already be running somewhere in the history, and 1948 // we want to shuffle it to the front of the stack if so. 1949 final ActivityRecord top = sourceTask.findActivityInHistoryLocked(r); 1950 if (top != null) { 1951 final TaskRecord task = top.task; 1952 task.moveActivityToFrontLocked(top); 1953 ActivityStack.logStartActivity(EventLogTags.AM_NEW_INTENT, r, task); 1954 top.updateOptionsLocked(options); 1955 top.deliverNewIntentLocked(callingUid, r.intent); 1956 targetStack.mLastPausedActivity = null; 1957 if (doResume) { 1958 targetStack.resumeTopActivityLocked(null); 1959 } 1960 return ActivityManager.START_DELIVERED_TO_TOP; 1961 } 1962 } 1963 // An existing activity is starting this new activity, so we want 1964 // to keep the new one in the same task as the one that is starting 1965 // it. 1966 r.setTask(sourceTask, false); 1967 if (DEBUG_TASKS) Slog.v(TAG, "Starting new activity " + r 1968 + " in existing task " + r.task + " from source " + sourceRecord); 1969 1970 } else { 1971 // This not being started from an existing activity, and not part 1972 // of a new task... just put it in the top task, though these days 1973 // this case should never happen. 1974 targetStack = adjustStackFocus(r, newTask); 1975 targetStack.moveToFront(); 1976 ActivityRecord prev = targetStack.topActivity(); 1977 r.setTask(prev != null ? prev.task : targetStack.createTaskRecord(getNextTaskId(), 1978 r.info, intent, null, null, true), true); 1979 mWindowManager.moveTaskToTop(r.task.taskId); 1980 if (DEBUG_TASKS) Slog.v(TAG, "Starting new activity " + r 1981 + " in new guessed " + r.task); 1982 } 1983 1984 mService.grantUriPermissionFromIntentLocked(callingUid, r.packageName, 1985 intent, r.getUriPermissionsLocked(), r.userId); 1986 1987 if (sourceRecord != null && sourceRecord.isRecentsActivity()) { 1988 r.task.setTaskToReturnTo(RECENTS_ACTIVITY_TYPE); 1989 } 1990 if (newTask) { 1991 EventLog.writeEvent(EventLogTags.AM_CREATE_TASK, r.userId, r.task.taskId); 1992 } 1993 ActivityStack.logStartActivity(EventLogTags.AM_CREATE_ACTIVITY, r, r.task); 1994 targetStack.mLastPausedActivity = null; 1995 targetStack.startActivityLocked(r, newTask, doResume, keepCurTransition, options); 1996 mService.setFocusedActivityLocked(r); 1997 return ActivityManager.START_SUCCESS; 1998 } 1999 2000 void acquireLaunchWakelock() { 2001 if (VALIDATE_WAKE_LOCK_CALLER && Binder.getCallingUid() != Process.myUid()) { 2002 throw new IllegalStateException("Calling must be system uid"); 2003 } 2004 mLaunchingActivity.acquire(); 2005 if (!mHandler.hasMessages(LAUNCH_TIMEOUT_MSG)) { 2006 // To be safe, don't allow the wake lock to be held for too long. 2007 mHandler.sendEmptyMessageDelayed(LAUNCH_TIMEOUT_MSG, LAUNCH_TIMEOUT); 2008 } 2009 } 2010 2011 // Checked. 2012 final ActivityRecord activityIdleInternalLocked(final IBinder token, boolean fromTimeout, 2013 Configuration config) { 2014 if (localLOGV) Slog.v(TAG, "Activity idle: " + token); 2015 2016 ArrayList<ActivityRecord> stops = null; 2017 ArrayList<ActivityRecord> finishes = null; 2018 ArrayList<UserStartedState> startingUsers = null; 2019 int NS = 0; 2020 int NF = 0; 2021 boolean booting = false; 2022 boolean enableScreen = false; 2023 boolean activityRemoved = false; 2024 2025 ActivityRecord r = ActivityRecord.forToken(token); 2026 if (r != null) { 2027 if (DEBUG_IDLE) Slog.d(TAG, "activityIdleInternalLocked: Callers=" + 2028 Debug.getCallers(4)); 2029 mHandler.removeMessages(IDLE_TIMEOUT_MSG, r); 2030 r.finishLaunchTickingLocked(); 2031 if (fromTimeout) { 2032 reportActivityLaunchedLocked(fromTimeout, r, -1, -1); 2033 } 2034 2035 // This is a hack to semi-deal with a race condition 2036 // in the client where it can be constructed with a 2037 // newer configuration from when we asked it to launch. 2038 // We'll update with whatever configuration it now says 2039 // it used to launch. 2040 if (config != null) { 2041 r.configuration = config; 2042 } 2043 2044 // We are now idle. If someone is waiting for a thumbnail from 2045 // us, we can now deliver. 2046 r.idle = true; 2047 2048 //Slog.i(TAG, "IDLE: mBooted=" + mBooted + ", fromTimeout=" + fromTimeout); 2049 if (!mService.mBooted && isFrontStack(r.task.stack)) { 2050 mService.mBooted = true; 2051 enableScreen = true; 2052 } 2053 } 2054 2055 if (allResumedActivitiesIdle()) { 2056 if (r != null) { 2057 mService.scheduleAppGcsLocked(); 2058 } 2059 2060 if (mLaunchingActivity.isHeld()) { 2061 mHandler.removeMessages(LAUNCH_TIMEOUT_MSG); 2062 if (VALIDATE_WAKE_LOCK_CALLER && 2063 Binder.getCallingUid() != Process.myUid()) { 2064 throw new IllegalStateException("Calling must be system uid"); 2065 } 2066 mLaunchingActivity.release(); 2067 } 2068 ensureActivitiesVisibleLocked(null, 0); 2069 } 2070 2071 // Atomically retrieve all of the other things to do. 2072 stops = processStoppingActivitiesLocked(true); 2073 NS = stops != null ? stops.size() : 0; 2074 if ((NF=mFinishingActivities.size()) > 0) { 2075 finishes = new ArrayList<ActivityRecord>(mFinishingActivities); 2076 mFinishingActivities.clear(); 2077 } 2078 2079 if (isFrontStack(mHomeStack)) { 2080 booting = mService.mBooting; 2081 mService.mBooting = false; 2082 } 2083 2084 if (mStartingUsers.size() > 0) { 2085 startingUsers = new ArrayList<UserStartedState>(mStartingUsers); 2086 mStartingUsers.clear(); 2087 } 2088 2089 // Stop any activities that are scheduled to do so but have been 2090 // waiting for the next one to start. 2091 for (int i = 0; i < NS; i++) { 2092 r = stops.get(i); 2093 final ActivityStack stack = r.task.stack; 2094 if (r.finishing) { 2095 stack.finishCurrentActivityLocked(r, ActivityStack.FINISH_IMMEDIATELY, false); 2096 } else { 2097 stack.stopActivityLocked(r); 2098 } 2099 } 2100 2101 // Finish any activities that are scheduled to do so but have been 2102 // waiting for the next one to start. 2103 for (int i = 0; i < NF; i++) { 2104 r = finishes.get(i); 2105 activityRemoved |= r.task.stack.destroyActivityLocked(r, true, false, "finish-idle"); 2106 } 2107 2108 if (booting) { 2109 mService.finishBooting(); 2110 } else { 2111 // Complete user switch 2112 if (startingUsers != null) { 2113 for (int i = 0; i < startingUsers.size(); i++) { 2114 mService.finishUserSwitch(startingUsers.get(i)); 2115 } 2116 } 2117 // Complete starting up of background users 2118 if (mStartingBackgroundUsers.size() > 0) { 2119 startingUsers = new ArrayList<UserStartedState>(mStartingBackgroundUsers); 2120 mStartingBackgroundUsers.clear(); 2121 for (int i = 0; i < startingUsers.size(); i++) { 2122 mService.finishUserBoot(startingUsers.get(i)); 2123 } 2124 } 2125 } 2126 2127 mService.trimApplications(); 2128 //dump(); 2129 //mWindowManager.dump(); 2130 2131 if (enableScreen) { 2132 mService.enableScreenAfterBoot(); 2133 } 2134 2135 if (activityRemoved) { 2136 resumeTopActivitiesLocked(); 2137 } 2138 2139 return r; 2140 } 2141 2142 boolean handleAppDiedLocked(ProcessRecord app) { 2143 boolean hasVisibleActivities = false; 2144 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 2145 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 2146 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 2147 hasVisibleActivities |= stacks.get(stackNdx).handleAppDiedLocked(app); 2148 } 2149 } 2150 return hasVisibleActivities; 2151 } 2152 2153 void closeSystemDialogsLocked() { 2154 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 2155 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 2156 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 2157 stacks.get(stackNdx).closeSystemDialogsLocked(); 2158 } 2159 } 2160 } 2161 2162 void removeUserLocked(int userId) { 2163 mUserStackInFront.delete(userId); 2164 } 2165 2166 /** 2167 * @return true if some activity was finished (or would have finished if doit were true). 2168 */ 2169 boolean forceStopPackageLocked(String name, boolean doit, boolean evenPersistent, int userId) { 2170 boolean didSomething = false; 2171 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 2172 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 2173 final int numStacks = stacks.size(); 2174 for (int stackNdx = 0; stackNdx < numStacks; ++stackNdx) { 2175 final ActivityStack stack = stacks.get(stackNdx); 2176 if (stack.forceStopPackageLocked(name, doit, evenPersistent, userId)) { 2177 didSomething = true; 2178 } 2179 } 2180 } 2181 return didSomething; 2182 } 2183 2184 void updatePreviousProcessLocked(ActivityRecord r) { 2185 // Now that this process has stopped, we may want to consider 2186 // it to be the previous app to try to keep around in case 2187 // the user wants to return to it. 2188 2189 // First, found out what is currently the foreground app, so that 2190 // we don't blow away the previous app if this activity is being 2191 // hosted by the process that is actually still the foreground. 2192 ProcessRecord fgApp = null; 2193 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 2194 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 2195 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 2196 final ActivityStack stack = stacks.get(stackNdx); 2197 if (isFrontStack(stack)) { 2198 if (stack.mResumedActivity != null) { 2199 fgApp = stack.mResumedActivity.app; 2200 } else if (stack.mPausingActivity != null) { 2201 fgApp = stack.mPausingActivity.app; 2202 } 2203 break; 2204 } 2205 } 2206 } 2207 2208 // Now set this one as the previous process, only if that really 2209 // makes sense to. 2210 if (r.app != null && fgApp != null && r.app != fgApp 2211 && r.lastVisibleTime > mService.mPreviousProcessVisibleTime 2212 && r.app != mService.mHomeProcess) { 2213 mService.mPreviousProcess = r.app; 2214 mService.mPreviousProcessVisibleTime = r.lastVisibleTime; 2215 } 2216 } 2217 2218 boolean resumeTopActivitiesLocked() { 2219 return resumeTopActivitiesLocked(null, null, null); 2220 } 2221 2222 boolean resumeTopActivitiesLocked(ActivityStack targetStack, ActivityRecord target, 2223 Bundle targetOptions) { 2224 if (targetStack == null) { 2225 targetStack = getFocusedStack(); 2226 } 2227 // Do targetStack first. 2228 boolean result = false; 2229 if (isFrontStack(targetStack)) { 2230 result = targetStack.resumeTopActivityLocked(target, targetOptions); 2231 } 2232 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 2233 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 2234 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 2235 final ActivityStack stack = stacks.get(stackNdx); 2236 if (stack == targetStack) { 2237 // Already started above. 2238 continue; 2239 } 2240 if (isFrontStack(stack)) { 2241 stack.resumeTopActivityLocked(null); 2242 } 2243 } 2244 } 2245 return result; 2246 } 2247 2248 void finishTopRunningActivityLocked(ProcessRecord app) { 2249 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 2250 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 2251 final int numStacks = stacks.size(); 2252 for (int stackNdx = 0; stackNdx < numStacks; ++stackNdx) { 2253 final ActivityStack stack = stacks.get(stackNdx); 2254 stack.finishTopRunningActivityLocked(app); 2255 } 2256 } 2257 } 2258 2259 void finishVoiceTask(IVoiceInteractionSession session) { 2260 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 2261 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 2262 final int numStacks = stacks.size(); 2263 for (int stackNdx = 0; stackNdx < numStacks; ++stackNdx) { 2264 final ActivityStack stack = stacks.get(stackNdx); 2265 stack.finishVoiceTask(session); 2266 } 2267 } 2268 } 2269 2270 void findTaskToMoveToFrontLocked(TaskRecord task, int flags, Bundle options) { 2271 if ((flags & ActivityManager.MOVE_TASK_NO_USER_ACTION) == 0) { 2272 mUserLeaving = true; 2273 } 2274 if ((flags & ActivityManager.MOVE_TASK_WITH_HOME) != 0) { 2275 // Caller wants the home activity moved with it. To accomplish this, 2276 // we'll just indicate that this task returns to the home task. 2277 task.setTaskToReturnTo(HOME_ACTIVITY_TYPE); 2278 } 2279 task.stack.moveTaskToFrontLocked(task, null, options); 2280 if (DEBUG_STACK) Slog.d(TAG, "findTaskToMoveToFront: moved to front of stack=" 2281 + task.stack); 2282 } 2283 2284 ActivityStack getStack(int stackId) { 2285 ActivityContainer activityContainer = mActivityContainers.get(stackId); 2286 if (activityContainer != null) { 2287 return activityContainer.mStack; 2288 } 2289 return null; 2290 } 2291 2292 ArrayList<ActivityStack> getStacks() { 2293 ArrayList<ActivityStack> allStacks = new ArrayList<ActivityStack>(); 2294 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 2295 allStacks.addAll(mActivityDisplays.valueAt(displayNdx).mStacks); 2296 } 2297 return allStacks; 2298 } 2299 2300 IBinder getHomeActivityToken() { 2301 final ArrayList<TaskRecord> tasks = mHomeStack.getAllTasks(); 2302 for (int taskNdx = tasks.size() - 1; taskNdx >= 0; --taskNdx) { 2303 final TaskRecord task = tasks.get(taskNdx); 2304 if (task.isHomeTask()) { 2305 final ArrayList<ActivityRecord> activities = task.mActivities; 2306 for (int activityNdx = activities.size() - 1; activityNdx >= 0; --activityNdx) { 2307 final ActivityRecord r = activities.get(activityNdx); 2308 if (r.isHomeActivity()) { 2309 return r.appToken; 2310 } 2311 } 2312 } 2313 } 2314 return null; 2315 } 2316 2317 ActivityContainer createActivityContainer(ActivityRecord parentActivity, 2318 IActivityContainerCallback callback) { 2319 ActivityContainer activityContainer = 2320 new VirtualActivityContainer(parentActivity, callback); 2321 mActivityContainers.put(activityContainer.mStackId, activityContainer); 2322 if (DEBUG_CONTAINERS) Slog.d(TAG, "createActivityContainer: " + activityContainer); 2323 parentActivity.mChildContainers.add(activityContainer); 2324 return activityContainer; 2325 } 2326 2327 void removeChildActivityContainers(ActivityRecord parentActivity) { 2328 final ArrayList<ActivityContainer> childStacks = parentActivity.mChildContainers; 2329 for (int containerNdx = childStacks.size() - 1; containerNdx >= 0; --containerNdx) { 2330 ActivityContainer container = childStacks.remove(containerNdx); 2331 if (DEBUG_CONTAINERS) Slog.d(TAG, "removeChildActivityContainers: removing " + 2332 container); 2333 container.release(); 2334 } 2335 } 2336 2337 void deleteActivityContainer(IActivityContainer container) { 2338 ActivityContainer activityContainer = (ActivityContainer)container; 2339 if (activityContainer != null) { 2340 if (DEBUG_CONTAINERS) Slog.d(TAG, "deleteActivityContainer: ", 2341 new RuntimeException("here").fillInStackTrace()); 2342 final int stackId = activityContainer.mStackId; 2343 mActivityContainers.remove(stackId); 2344 mWindowManager.removeStack(stackId); 2345 } 2346 } 2347 2348 private int createStackOnDisplay(int stackId, int displayId) { 2349 ActivityDisplay activityDisplay = mActivityDisplays.get(displayId); 2350 if (activityDisplay == null) { 2351 return -1; 2352 } 2353 2354 ActivityContainer activityContainer = new ActivityContainer(stackId); 2355 mActivityContainers.put(stackId, activityContainer); 2356 activityContainer.attachToDisplayLocked(activityDisplay); 2357 return stackId; 2358 } 2359 2360 int getNextStackId() { 2361 while (true) { 2362 if (++mLastStackId <= HOME_STACK_ID) { 2363 mLastStackId = HOME_STACK_ID + 1; 2364 } 2365 if (getStack(mLastStackId) == null) { 2366 break; 2367 } 2368 } 2369 return mLastStackId; 2370 } 2371 2372 void createStackForRestoredTaskHistory(ArrayList<TaskRecord> tasks) { 2373 int stackId = createStackOnDisplay(getNextStackId(), Display.DEFAULT_DISPLAY); 2374 final ActivityStack stack = getStack(stackId); 2375 for (int taskNdx = tasks.size() - 1; taskNdx >= 0; --taskNdx) { 2376 final TaskRecord task = tasks.get(taskNdx); 2377 stack.addTask(task, false, false); 2378 final int taskId = task.taskId; 2379 final ArrayList<ActivityRecord> activities = task.mActivities; 2380 for (int activityNdx = activities.size() - 1; activityNdx >= 0; --activityNdx) { 2381 final ActivityRecord r = activities.get(activityNdx); 2382 mWindowManager.addAppToken(0, r.appToken, taskId, stackId, 2383 r.info.screenOrientation, r.fullscreen, 2384 (r.info.flags & ActivityInfo.FLAG_SHOW_ON_LOCK_SCREEN) != 0, 2385 r.userId, r.info.configChanges, task.voiceSession != null); 2386 } 2387 mWindowManager.addTask(taskId, stackId, false); 2388 } 2389 resumeHomeStackTask(HOME_ACTIVITY_TYPE, null); 2390 } 2391 2392 void moveTaskToStack(int taskId, int stackId, boolean toTop) { 2393 final TaskRecord task = anyTaskForIdLocked(taskId); 2394 if (task == null) { 2395 return; 2396 } 2397 final ActivityStack stack = getStack(stackId); 2398 if (stack == null) { 2399 Slog.w(TAG, "moveTaskToStack: no stack for id=" + stackId); 2400 return; 2401 } 2402 task.stack.removeTask(task); 2403 stack.addTask(task, toTop, true); 2404 mWindowManager.addTask(taskId, stackId, toTop); 2405 resumeTopActivitiesLocked(); 2406 } 2407 2408 ActivityRecord findTaskLocked(ActivityRecord r) { 2409 if (DEBUG_TASKS) Slog.d(TAG, "Looking for task of " + r); 2410 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 2411 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 2412 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 2413 final ActivityStack stack = stacks.get(stackNdx); 2414 if (!r.isApplicationActivity() && !stack.isHomeStack()) { 2415 if (DEBUG_TASKS) Slog.d(TAG, "Skipping stack: (home activity) " + stack); 2416 continue; 2417 } 2418 if (!stack.mActivityContainer.isEligibleForNewTasks()) { 2419 if (DEBUG_TASKS) Slog.d(TAG, "Skipping stack: (new task not allowed) " + 2420 stack); 2421 continue; 2422 } 2423 final ActivityRecord ar = stack.findTaskLocked(r); 2424 if (ar != null) { 2425 return ar; 2426 } 2427 } 2428 } 2429 if (DEBUG_TASKS) Slog.d(TAG, "No task found"); 2430 return null; 2431 } 2432 2433 ActivityRecord findActivityLocked(Intent intent, ActivityInfo info) { 2434 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 2435 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 2436 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 2437 final ActivityRecord ar = stacks.get(stackNdx).findActivityLocked(intent, info); 2438 if (ar != null) { 2439 return ar; 2440 } 2441 } 2442 } 2443 return null; 2444 } 2445 2446 void goingToSleepLocked() { 2447 scheduleSleepTimeout(); 2448 if (!mGoingToSleep.isHeld()) { 2449 mGoingToSleep.acquire(); 2450 if (mLaunchingActivity.isHeld()) { 2451 if (VALIDATE_WAKE_LOCK_CALLER && Binder.getCallingUid() != Process.myUid()) { 2452 throw new IllegalStateException("Calling must be system uid"); 2453 } 2454 mLaunchingActivity.release(); 2455 mService.mHandler.removeMessages(LAUNCH_TIMEOUT_MSG); 2456 } 2457 } 2458 checkReadyForSleepLocked(); 2459 } 2460 2461 boolean shutdownLocked(int timeout) { 2462 goingToSleepLocked(); 2463 2464 boolean timedout = false; 2465 final long endTime = System.currentTimeMillis() + timeout; 2466 while (true) { 2467 boolean cantShutdown = false; 2468 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 2469 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 2470 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 2471 cantShutdown |= stacks.get(stackNdx).checkReadyForSleepLocked(); 2472 } 2473 } 2474 if (cantShutdown) { 2475 long timeRemaining = endTime - System.currentTimeMillis(); 2476 if (timeRemaining > 0) { 2477 try { 2478 mService.wait(timeRemaining); 2479 } catch (InterruptedException e) { 2480 } 2481 } else { 2482 Slog.w(TAG, "Activity manager shutdown timed out"); 2483 timedout = true; 2484 break; 2485 } 2486 } else { 2487 break; 2488 } 2489 } 2490 2491 // Force checkReadyForSleep to complete. 2492 mSleepTimeout = true; 2493 checkReadyForSleepLocked(); 2494 2495 return timedout; 2496 } 2497 2498 void comeOutOfSleepIfNeededLocked() { 2499 removeSleepTimeouts(); 2500 if (mGoingToSleep.isHeld()) { 2501 mGoingToSleep.release(); 2502 } 2503 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 2504 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 2505 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 2506 final ActivityStack stack = stacks.get(stackNdx); 2507 stack.awakeFromSleepingLocked(); 2508 if (isFrontStack(stack)) { 2509 resumeTopActivitiesLocked(); 2510 } 2511 } 2512 } 2513 mGoingToSleepActivities.clear(); 2514 } 2515 2516 void activitySleptLocked(ActivityRecord r) { 2517 mGoingToSleepActivities.remove(r); 2518 checkReadyForSleepLocked(); 2519 } 2520 2521 void checkReadyForSleepLocked() { 2522 if (!mService.isSleepingOrShuttingDown()) { 2523 // Do not care. 2524 return; 2525 } 2526 2527 if (!mSleepTimeout) { 2528 boolean dontSleep = false; 2529 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 2530 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 2531 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 2532 dontSleep |= stacks.get(stackNdx).checkReadyForSleepLocked(); 2533 } 2534 } 2535 2536 if (mStoppingActivities.size() > 0) { 2537 // Still need to tell some activities to stop; can't sleep yet. 2538 if (DEBUG_PAUSE) Slog.v(TAG, "Sleep still need to stop " 2539 + mStoppingActivities.size() + " activities"); 2540 scheduleIdleLocked(); 2541 dontSleep = true; 2542 } 2543 2544 if (mGoingToSleepActivities.size() > 0) { 2545 // Still need to tell some activities to sleep; can't sleep yet. 2546 if (DEBUG_PAUSE) Slog.v(TAG, "Sleep still need to sleep " 2547 + mGoingToSleepActivities.size() + " activities"); 2548 dontSleep = true; 2549 } 2550 2551 if (dontSleep) { 2552 return; 2553 } 2554 } 2555 2556 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 2557 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 2558 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 2559 stacks.get(stackNdx).goToSleep(); 2560 } 2561 } 2562 2563 removeSleepTimeouts(); 2564 2565 if (mGoingToSleep.isHeld()) { 2566 mGoingToSleep.release(); 2567 } 2568 if (mService.mShuttingDown) { 2569 mService.notifyAll(); 2570 } 2571 } 2572 2573 boolean reportResumedActivityLocked(ActivityRecord r) { 2574 final ActivityStack stack = r.task.stack; 2575 if (isFrontStack(stack)) { 2576 mService.updateUsageStats(r, true); 2577 } 2578 if (allResumedActivitiesComplete()) { 2579 ensureActivitiesVisibleLocked(null, 0); 2580 mWindowManager.executeAppTransition(); 2581 return true; 2582 } 2583 return false; 2584 } 2585 2586 void handleAppCrashLocked(ProcessRecord app) { 2587 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 2588 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 2589 final int numStacks = stacks.size(); 2590 for (int stackNdx = 0; stackNdx < numStacks; ++stackNdx) { 2591 final ActivityStack stack = stacks.get(stackNdx); 2592 stack.handleAppCrashLocked(app); 2593 } 2594 } 2595 } 2596 2597 void ensureActivitiesVisibleLocked(ActivityRecord starting, int configChanges) { 2598 // First the front stacks. In case any are not fullscreen and are in front of home. 2599 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 2600 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 2601 final int topStackNdx = stacks.size() - 1; 2602 for (int stackNdx = topStackNdx; stackNdx >= 0; --stackNdx) { 2603 final ActivityStack stack = stacks.get(stackNdx); 2604 stack.ensureActivitiesVisibleLocked(starting, configChanges); 2605 } 2606 } 2607 } 2608 2609 void scheduleDestroyAllActivities(ProcessRecord app, String reason) { 2610 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 2611 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 2612 final int numStacks = stacks.size(); 2613 for (int stackNdx = 0; stackNdx < numStacks; ++stackNdx) { 2614 final ActivityStack stack = stacks.get(stackNdx); 2615 stack.scheduleDestroyActivities(app, false, reason); 2616 } 2617 } 2618 } 2619 2620 boolean switchUserLocked(int userId, UserStartedState uss) { 2621 mUserStackInFront.put(mCurrentUser, getFocusedStack().getStackId()); 2622 final int restoreStackId = mUserStackInFront.get(userId, HOME_STACK_ID); 2623 mCurrentUser = userId; 2624 2625 mStartingUsers.add(uss); 2626 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 2627 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 2628 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 2629 final ActivityStack stack = stacks.get(stackNdx); 2630 stack.switchUserLocked(userId); 2631 TaskRecord task = stack.topTask(); 2632 if (task != null) { 2633 mWindowManager.moveTaskToTop(task.taskId); 2634 } 2635 } 2636 } 2637 2638 ActivityStack stack = getStack(restoreStackId); 2639 if (stack == null) { 2640 stack = mHomeStack; 2641 } 2642 final boolean homeInFront = stack.isHomeStack(); 2643 if (stack.isOnHomeDisplay()) { 2644 moveHomeStack(homeInFront); 2645 TaskRecord task = stack.topTask(); 2646 if (task != null) { 2647 mWindowManager.moveTaskToTop(task.taskId); 2648 } 2649 } else { 2650 // Stack was moved to another display while user was swapped out. 2651 resumeHomeStackTask(HOME_ACTIVITY_TYPE, null); 2652 } 2653 return homeInFront; 2654 } 2655 2656 /** 2657 * Add background users to send boot completed events to. 2658 * @param userId The user being started in the background 2659 * @param uss The state object for the user. 2660 */ 2661 public void startBackgroundUserLocked(int userId, UserStartedState uss) { 2662 mStartingBackgroundUsers.add(uss); 2663 } 2664 2665 final ArrayList<ActivityRecord> processStoppingActivitiesLocked(boolean remove) { 2666 int N = mStoppingActivities.size(); 2667 if (N <= 0) return null; 2668 2669 ArrayList<ActivityRecord> stops = null; 2670 2671 final boolean nowVisible = allResumedActivitiesVisible(); 2672 for (int i=0; i<N; i++) { 2673 ActivityRecord s = mStoppingActivities.get(i); 2674 if (localLOGV) Slog.v(TAG, "Stopping " + s + ": nowVisible=" 2675 + nowVisible + " waitingVisible=" + s.waitingVisible 2676 + " finishing=" + s.finishing); 2677 if (s.waitingVisible && nowVisible) { 2678 mWaitingVisibleActivities.remove(s); 2679 s.waitingVisible = false; 2680 if (s.finishing) { 2681 // If this activity is finishing, it is sitting on top of 2682 // everyone else but we now know it is no longer needed... 2683 // so get rid of it. Otherwise, we need to go through the 2684 // normal flow and hide it once we determine that it is 2685 // hidden by the activities in front of it. 2686 if (localLOGV) Slog.v(TAG, "Before stopping, can hide: " + s); 2687 mWindowManager.setAppVisibility(s.appToken, false); 2688 } 2689 } 2690 if ((!s.waitingVisible || mService.isSleepingOrShuttingDown()) && remove) { 2691 if (localLOGV) Slog.v(TAG, "Ready to stop: " + s); 2692 if (stops == null) { 2693 stops = new ArrayList<ActivityRecord>(); 2694 } 2695 stops.add(s); 2696 mStoppingActivities.remove(i); 2697 N--; 2698 i--; 2699 } 2700 } 2701 2702 return stops; 2703 } 2704 2705 void validateTopActivitiesLocked() { 2706 // FIXME 2707/* for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 2708 final ActivityStack stack = stacks.get(stackNdx); 2709 final ActivityRecord r = stack.topRunningActivityLocked(null); 2710 final ActivityState state = r == null ? ActivityState.DESTROYED : r.state; 2711 if (isFrontStack(stack)) { 2712 if (r == null) { 2713 Slog.e(TAG, "validateTop...: null top activity, stack=" + stack); 2714 } else { 2715 final ActivityRecord pausing = stack.mPausingActivity; 2716 if (pausing != null && pausing == r) { 2717 Slog.e(TAG, "validateTop...: top stack has pausing activity r=" + r + 2718 " state=" + state); 2719 } 2720 if (state != ActivityState.INITIALIZING && state != ActivityState.RESUMED) { 2721 Slog.e(TAG, "validateTop...: activity in front not resumed r=" + r + 2722 " state=" + state); 2723 } 2724 } 2725 } else { 2726 final ActivityRecord resumed = stack.mResumedActivity; 2727 if (resumed != null && resumed == r) { 2728 Slog.e(TAG, "validateTop...: back stack has resumed activity r=" + r + 2729 " state=" + state); 2730 } 2731 if (r != null && (state == ActivityState.INITIALIZING 2732 || state == ActivityState.RESUMED)) { 2733 Slog.e(TAG, "validateTop...: activity in back resumed r=" + r + 2734 " state=" + state); 2735 } 2736 } 2737 } 2738*/ 2739 } 2740 2741 public void dump(PrintWriter pw, String prefix) { 2742 pw.print(prefix); pw.print("mDismissKeyguardOnNextActivity="); 2743 pw.println(mDismissKeyguardOnNextActivity); 2744 pw.print(prefix); pw.print("mFocusedStack=" + mFocusedStack); 2745 pw.print(" mLastFocusedStack="); pw.println(mLastFocusedStack); 2746 pw.print(prefix); pw.println("mSleepTimeout=" + mSleepTimeout); 2747 pw.print(prefix); pw.println("mCurTaskId=" + mCurTaskId); 2748 pw.print(prefix); pw.println("mUserStackInFront=" + mUserStackInFront); 2749 pw.print(prefix); pw.println("mActivityContainers=" + mActivityContainers); 2750 } 2751 2752 ArrayList<ActivityRecord> getDumpActivitiesLocked(String name) { 2753 return getFocusedStack().getDumpActivitiesLocked(name); 2754 } 2755 2756 static boolean printThisActivity(PrintWriter pw, ActivityRecord activity, String dumpPackage, 2757 boolean needSep, String prefix) { 2758 if (activity != null) { 2759 if (dumpPackage == null || dumpPackage.equals(activity.packageName)) { 2760 if (needSep) { 2761 pw.println(); 2762 } 2763 pw.print(prefix); 2764 pw.println(activity); 2765 return true; 2766 } 2767 } 2768 return false; 2769 } 2770 2771 boolean dumpActivitiesLocked(FileDescriptor fd, PrintWriter pw, boolean dumpAll, 2772 boolean dumpClient, String dumpPackage) { 2773 boolean printed = false; 2774 boolean needSep = false; 2775 for (int displayNdx = 0; displayNdx < mActivityDisplays.size(); ++displayNdx) { 2776 ActivityDisplay activityDisplay = mActivityDisplays.valueAt(displayNdx); 2777 pw.print("Display #"); pw.println(activityDisplay.mDisplayId); 2778 ArrayList<ActivityStack> stacks = activityDisplay.mStacks; 2779 final int numStacks = stacks.size(); 2780 for (int stackNdx = 0; stackNdx < numStacks; ++stackNdx) { 2781 final ActivityStack stack = stacks.get(stackNdx); 2782 StringBuilder stackHeader = new StringBuilder(128); 2783 stackHeader.append(" Stack #"); 2784 stackHeader.append(stack.mStackId); 2785 stackHeader.append(":"); 2786 printed |= stack.dumpActivitiesLocked(fd, pw, dumpAll, dumpClient, dumpPackage, 2787 needSep, stackHeader.toString()); 2788 printed |= dumpHistoryList(fd, pw, stack.mLRUActivities, " ", "Run", false, 2789 !dumpAll, false, dumpPackage, true, 2790 " Running activities (most recent first):", null); 2791 2792 needSep = printed; 2793 boolean pr = printThisActivity(pw, stack.mPausingActivity, dumpPackage, needSep, 2794 " mPausingActivity: "); 2795 if (pr) { 2796 printed = true; 2797 needSep = false; 2798 } 2799 pr = printThisActivity(pw, stack.mResumedActivity, dumpPackage, needSep, 2800 " mResumedActivity: "); 2801 if (pr) { 2802 printed = true; 2803 needSep = false; 2804 } 2805 if (dumpAll) { 2806 pr = printThisActivity(pw, stack.mLastPausedActivity, dumpPackage, needSep, 2807 " mLastPausedActivity: "); 2808 if (pr) { 2809 printed = true; 2810 needSep = true; 2811 } 2812 printed |= printThisActivity(pw, stack.mLastNoHistoryActivity, dumpPackage, 2813 needSep, " mLastNoHistoryActivity: "); 2814 } 2815 needSep = printed; 2816 } 2817 } 2818 2819 printed |= dumpHistoryList(fd, pw, mFinishingActivities, " ", "Fin", false, !dumpAll, 2820 false, dumpPackage, true, " Activities waiting to finish:", null); 2821 printed |= dumpHistoryList(fd, pw, mStoppingActivities, " ", "Stop", false, !dumpAll, 2822 false, dumpPackage, true, " Activities waiting to stop:", null); 2823 printed |= dumpHistoryList(fd, pw, mWaitingVisibleActivities, " ", "Wait", false, !dumpAll, 2824 false, dumpPackage, true, " Activities waiting for another to become visible:", 2825 null); 2826 printed |= dumpHistoryList(fd, pw, mGoingToSleepActivities, " ", "Sleep", false, !dumpAll, 2827 false, dumpPackage, true, " Activities waiting to sleep:", null); 2828 printed |= dumpHistoryList(fd, pw, mGoingToSleepActivities, " ", "Sleep", false, !dumpAll, 2829 false, dumpPackage, true, " Activities waiting to sleep:", null); 2830 2831 return printed; 2832 } 2833 2834 static boolean dumpHistoryList(FileDescriptor fd, PrintWriter pw, List<ActivityRecord> list, 2835 String prefix, String label, boolean complete, boolean brief, boolean client, 2836 String dumpPackage, boolean needNL, String header1, String header2) { 2837 TaskRecord lastTask = null; 2838 String innerPrefix = null; 2839 String[] args = null; 2840 boolean printed = false; 2841 for (int i=list.size()-1; i>=0; i--) { 2842 final ActivityRecord r = list.get(i); 2843 if (dumpPackage != null && !dumpPackage.equals(r.packageName)) { 2844 continue; 2845 } 2846 if (innerPrefix == null) { 2847 innerPrefix = prefix + " "; 2848 args = new String[0]; 2849 } 2850 printed = true; 2851 final boolean full = !brief && (complete || !r.isInHistory()); 2852 if (needNL) { 2853 pw.println(""); 2854 needNL = false; 2855 } 2856 if (header1 != null) { 2857 pw.println(header1); 2858 header1 = null; 2859 } 2860 if (header2 != null) { 2861 pw.println(header2); 2862 header2 = null; 2863 } 2864 if (lastTask != r.task) { 2865 lastTask = r.task; 2866 pw.print(prefix); 2867 pw.print(full ? "* " : " "); 2868 pw.println(lastTask); 2869 if (full) { 2870 lastTask.dump(pw, prefix + " "); 2871 } else if (complete) { 2872 // Complete + brief == give a summary. Isn't that obvious?!? 2873 if (lastTask.intent != null) { 2874 pw.print(prefix); pw.print(" "); 2875 pw.println(lastTask.intent.toInsecureStringWithClip()); 2876 } 2877 } 2878 } 2879 pw.print(prefix); pw.print(full ? " * " : " "); pw.print(label); 2880 pw.print(" #"); pw.print(i); pw.print(": "); 2881 pw.println(r); 2882 if (full) { 2883 r.dump(pw, innerPrefix); 2884 } else if (complete) { 2885 // Complete + brief == give a summary. Isn't that obvious?!? 2886 pw.print(innerPrefix); pw.println(r.intent.toInsecureString()); 2887 if (r.app != null) { 2888 pw.print(innerPrefix); pw.println(r.app); 2889 } 2890 } 2891 if (client && r.app != null && r.app.thread != null) { 2892 // flush anything that is already in the PrintWriter since the thread is going 2893 // to write to the file descriptor directly 2894 pw.flush(); 2895 try { 2896 TransferPipe tp = new TransferPipe(); 2897 try { 2898 r.app.thread.dumpActivity(tp.getWriteFd().getFileDescriptor(), 2899 r.appToken, innerPrefix, args); 2900 // Short timeout, since blocking here can 2901 // deadlock with the application. 2902 tp.go(fd, 2000); 2903 } finally { 2904 tp.kill(); 2905 } 2906 } catch (IOException e) { 2907 pw.println(innerPrefix + "Failure while dumping the activity: " + e); 2908 } catch (RemoteException e) { 2909 pw.println(innerPrefix + "Got a RemoteException while dumping the activity"); 2910 } 2911 needNL = true; 2912 } 2913 } 2914 return printed; 2915 } 2916 2917 void scheduleIdleTimeoutLocked(ActivityRecord next) { 2918 if (DEBUG_IDLE) Slog.d(TAG, "scheduleIdleTimeoutLocked: Callers=" + Debug.getCallers(4)); 2919 Message msg = mHandler.obtainMessage(IDLE_TIMEOUT_MSG, next); 2920 mHandler.sendMessageDelayed(msg, IDLE_TIMEOUT); 2921 } 2922 2923 final void scheduleIdleLocked() { 2924 mHandler.sendEmptyMessage(IDLE_NOW_MSG); 2925 } 2926 2927 void removeTimeoutsForActivityLocked(ActivityRecord r) { 2928 if (DEBUG_IDLE) Slog.d(TAG, "removeTimeoutsForActivity: Callers=" + Debug.getCallers(4)); 2929 mHandler.removeMessages(IDLE_TIMEOUT_MSG, r); 2930 } 2931 2932 final void scheduleResumeTopActivities() { 2933 if (!mHandler.hasMessages(RESUME_TOP_ACTIVITY_MSG)) { 2934 mHandler.sendEmptyMessage(RESUME_TOP_ACTIVITY_MSG); 2935 } 2936 } 2937 2938 void removeSleepTimeouts() { 2939 mSleepTimeout = false; 2940 mHandler.removeMessages(SLEEP_TIMEOUT_MSG); 2941 } 2942 2943 final void scheduleSleepTimeout() { 2944 removeSleepTimeouts(); 2945 mHandler.sendEmptyMessageDelayed(SLEEP_TIMEOUT_MSG, SLEEP_TIMEOUT); 2946 } 2947 2948 @Override 2949 public void onDisplayAdded(int displayId) { 2950 Slog.v(TAG, "Display added displayId=" + displayId); 2951 mHandler.sendMessage(mHandler.obtainMessage(HANDLE_DISPLAY_ADDED, displayId, 0)); 2952 } 2953 2954 @Override 2955 public void onDisplayRemoved(int displayId) { 2956 Slog.v(TAG, "Display removed displayId=" + displayId); 2957 mHandler.sendMessage(mHandler.obtainMessage(HANDLE_DISPLAY_REMOVED, displayId, 0)); 2958 } 2959 2960 @Override 2961 public void onDisplayChanged(int displayId) { 2962 Slog.v(TAG, "Display changed displayId=" + displayId); 2963 mHandler.sendMessage(mHandler.obtainMessage(HANDLE_DISPLAY_CHANGED, displayId, 0)); 2964 } 2965 2966 public void handleDisplayAddedLocked(int displayId) { 2967 boolean newDisplay; 2968 synchronized (mService) { 2969 newDisplay = mActivityDisplays.get(displayId) == null; 2970 if (newDisplay) { 2971 ActivityDisplay activityDisplay = new ActivityDisplay(displayId); 2972 mActivityDisplays.put(displayId, activityDisplay); 2973 } 2974 } 2975 if (newDisplay) { 2976 mWindowManager.onDisplayAdded(displayId); 2977 } 2978 } 2979 2980 public void handleDisplayRemovedLocked(int displayId) { 2981 synchronized (mService) { 2982 ActivityDisplay activityDisplay = mActivityDisplays.get(displayId); 2983 if (activityDisplay != null) { 2984 ArrayList<ActivityStack> stacks = activityDisplay.mStacks; 2985 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 2986 stacks.get(stackNdx).mActivityContainer.detachLocked(); 2987 } 2988 mActivityDisplays.remove(displayId); 2989 } 2990 } 2991 mWindowManager.onDisplayRemoved(displayId); 2992 } 2993 2994 public void handleDisplayChangedLocked(int displayId) { 2995 synchronized (mService) { 2996 ActivityDisplay activityDisplay = mActivityDisplays.get(displayId); 2997 if (activityDisplay != null) { 2998 // TODO: Update the bounds. 2999 } 3000 } 3001 mWindowManager.onDisplayChanged(displayId); 3002 } 3003 3004 StackInfo getStackInfo(ActivityStack stack) { 3005 StackInfo info = new StackInfo(); 3006 mWindowManager.getStackBounds(stack.mStackId, info.bounds); 3007 info.displayId = Display.DEFAULT_DISPLAY; 3008 info.stackId = stack.mStackId; 3009 3010 ArrayList<TaskRecord> tasks = stack.getAllTasks(); 3011 final int numTasks = tasks.size(); 3012 int[] taskIds = new int[numTasks]; 3013 String[] taskNames = new String[numTasks]; 3014 for (int i = 0; i < numTasks; ++i) { 3015 final TaskRecord task = tasks.get(i); 3016 taskIds[i] = task.taskId; 3017 taskNames[i] = task.origActivity != null ? task.origActivity.flattenToString() 3018 : task.realActivity != null ? task.realActivity.flattenToString() 3019 : task.getTopActivity() != null ? task.getTopActivity().packageName 3020 : "unknown"; 3021 } 3022 info.taskIds = taskIds; 3023 info.taskNames = taskNames; 3024 return info; 3025 } 3026 3027 StackInfo getStackInfoLocked(int stackId) { 3028 ActivityStack stack = getStack(stackId); 3029 if (stack != null) { 3030 return getStackInfo(stack); 3031 } 3032 return null; 3033 } 3034 3035 ArrayList<StackInfo> getAllStackInfosLocked() { 3036 ArrayList<StackInfo> list = new ArrayList<StackInfo>(); 3037 for (int displayNdx = 0; displayNdx < mActivityDisplays.size(); ++displayNdx) { 3038 ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 3039 for (int ndx = stacks.size() - 1; ndx >= 0; --ndx) { 3040 list.add(getStackInfo(stacks.get(ndx))); 3041 } 3042 } 3043 return list; 3044 } 3045 3046 void showLockTaskToast() { 3047 mLockTaskNotify.showToast(mLockTaskIsLocked); 3048 } 3049 3050 void setLockTaskModeLocked(TaskRecord task, boolean isLocked) { 3051 if (task == null) { 3052 // Take out of lock task mode if necessary 3053 if (mLockTaskModeTask != null) { 3054 final Message lockTaskMsg = Message.obtain(); 3055 lockTaskMsg.arg1 = mLockTaskModeTask.userId; 3056 lockTaskMsg.what = LOCK_TASK_END_MSG; 3057 mLockTaskModeTask = null; 3058 mHandler.sendMessage(lockTaskMsg); 3059 } 3060 return; 3061 } 3062 if (isLockTaskModeViolation(task)) { 3063 Slog.e(TAG, "setLockTaskMode: Attempt to start a second Lock Task Mode task."); 3064 return; 3065 } 3066 mLockTaskModeTask = task; 3067 findTaskToMoveToFrontLocked(task, 0, null); 3068 resumeTopActivitiesLocked(); 3069 3070 final Message lockTaskMsg = Message.obtain(); 3071 lockTaskMsg.obj = mLockTaskModeTask.intent.getComponent().getPackageName(); 3072 lockTaskMsg.arg1 = mLockTaskModeTask.userId; 3073 lockTaskMsg.what = LOCK_TASK_START_MSG; 3074 lockTaskMsg.arg2 = !isLocked ? 1 : 0; 3075 mHandler.sendMessage(lockTaskMsg); 3076 } 3077 3078 boolean isLockTaskModeViolation(TaskRecord task) { 3079 return mLockTaskModeTask != null && mLockTaskModeTask != task; 3080 } 3081 3082 void endLockTaskModeIfTaskEnding(TaskRecord task) { 3083 if (mLockTaskModeTask != null && mLockTaskModeTask == task) { 3084 mLockTaskModeTask = null; 3085 } 3086 } 3087 3088 boolean isInLockTaskMode() { 3089 return mLockTaskModeTask != null; 3090 } 3091 3092 private final class ActivityStackSupervisorHandler extends Handler { 3093 3094 public ActivityStackSupervisorHandler(Looper looper) { 3095 super(looper); 3096 } 3097 3098 void activityIdleInternal(ActivityRecord r) { 3099 synchronized (mService) { 3100 activityIdleInternalLocked(r != null ? r.appToken : null, true, null); 3101 } 3102 } 3103 3104 @Override 3105 public void handleMessage(Message msg) { 3106 switch (msg.what) { 3107 case IDLE_TIMEOUT_MSG: { 3108 if (DEBUG_IDLE) Slog.d(TAG, "handleMessage: IDLE_TIMEOUT_MSG: r=" + msg.obj); 3109 if (mService.mDidDexOpt) { 3110 mService.mDidDexOpt = false; 3111 Message nmsg = mHandler.obtainMessage(IDLE_TIMEOUT_MSG); 3112 nmsg.obj = msg.obj; 3113 mHandler.sendMessageDelayed(nmsg, IDLE_TIMEOUT); 3114 return; 3115 } 3116 // We don't at this point know if the activity is fullscreen, 3117 // so we need to be conservative and assume it isn't. 3118 activityIdleInternal((ActivityRecord)msg.obj); 3119 } break; 3120 case IDLE_NOW_MSG: { 3121 if (DEBUG_IDLE) Slog.d(TAG, "handleMessage: IDLE_NOW_MSG: r=" + msg.obj); 3122 activityIdleInternal((ActivityRecord)msg.obj); 3123 } break; 3124 case RESUME_TOP_ACTIVITY_MSG: { 3125 synchronized (mService) { 3126 resumeTopActivitiesLocked(); 3127 } 3128 } break; 3129 case SLEEP_TIMEOUT_MSG: { 3130 synchronized (mService) { 3131 if (mService.isSleepingOrShuttingDown()) { 3132 Slog.w(TAG, "Sleep timeout! Sleeping now."); 3133 mSleepTimeout = true; 3134 checkReadyForSleepLocked(); 3135 } 3136 } 3137 } break; 3138 case LAUNCH_TIMEOUT_MSG: { 3139 if (mService.mDidDexOpt) { 3140 mService.mDidDexOpt = false; 3141 mHandler.sendEmptyMessageDelayed(LAUNCH_TIMEOUT_MSG, LAUNCH_TIMEOUT); 3142 return; 3143 } 3144 synchronized (mService) { 3145 if (mLaunchingActivity.isHeld()) { 3146 Slog.w(TAG, "Launch timeout has expired, giving up wake lock!"); 3147 if (VALIDATE_WAKE_LOCK_CALLER 3148 && Binder.getCallingUid() != Process.myUid()) { 3149 throw new IllegalStateException("Calling must be system uid"); 3150 } 3151 mLaunchingActivity.release(); 3152 } 3153 } 3154 } break; 3155 case HANDLE_DISPLAY_ADDED: { 3156 handleDisplayAddedLocked(msg.arg1); 3157 } break; 3158 case HANDLE_DISPLAY_CHANGED: { 3159 handleDisplayChangedLocked(msg.arg1); 3160 } break; 3161 case HANDLE_DISPLAY_REMOVED: { 3162 handleDisplayRemovedLocked(msg.arg1); 3163 } break; 3164 case CONTAINER_CALLBACK_VISIBILITY: { 3165 final ActivityContainer container = (ActivityContainer) msg.obj; 3166 final IActivityContainerCallback callback = container.mCallback; 3167 if (callback != null) { 3168 try { 3169 callback.setVisible(container.asBinder(), msg.arg1 == 1); 3170 } catch (RemoteException e) { 3171 } 3172 } 3173 } break; 3174 case LOCK_TASK_START_MSG: { 3175 // When lock task starts, we disable the status bars. 3176 try { 3177 if (mLockTaskNotify == null) { 3178 mLockTaskNotify = new LockTaskNotify(mService.mContext); 3179 } 3180 mLockTaskNotify.show(true); 3181 if (getStatusBarService() != null) { 3182 int flags = 3183 StatusBarManager.DISABLE_MASK ^ StatusBarManager.DISABLE_BACK; 3184 if (msg.arg2 != 0) { 3185 flags ^= StatusBarManager.DISABLE_HOME 3186 | StatusBarManager.DISABLE_RECENT; 3187 } 3188 getStatusBarService().disable(flags, mToken, 3189 mService.mContext.getPackageName()); 3190 } 3191 mWindowManager.disableKeyguard(mToken, LOCK_TASK_TAG); 3192 if (getDevicePolicyManager() != null) { 3193 getDevicePolicyManager().notifyLockTaskModeChanged(true, 3194 (String)msg.obj, msg.arg1); 3195 } 3196 } catch (RemoteException ex) { 3197 throw new RuntimeException(ex); 3198 } 3199 } break; 3200 case LOCK_TASK_END_MSG: { 3201 // When lock task ends, we enable the status bars. 3202 try { 3203 if (getStatusBarService() != null) { 3204 getStatusBarService().disable(StatusBarManager.DISABLE_NONE, mToken, 3205 mService.mContext.getPackageName()); 3206 } 3207 mWindowManager.reenableKeyguard(mToken); 3208 if (getDevicePolicyManager() != null) { 3209 getDevicePolicyManager().notifyLockTaskModeChanged(false, null, 3210 msg.arg1); 3211 } 3212 if (mLockTaskNotify == null) { 3213 mLockTaskNotify = new LockTaskNotify(mService.mContext); 3214 } 3215 mLockTaskNotify.show(false); 3216 try { 3217 boolean shouldLockKeyguard = Settings.System.getInt( 3218 mService.mContext.getContentResolver(), 3219 Settings.System.LOCK_TO_APP_EXIT_LOCKED) != 0; 3220 if (shouldLockKeyguard) { 3221 mWindowManager.lockNow(null); 3222 } 3223 } catch (SettingNotFoundException e) { 3224 // No setting, don't lock. 3225 } 3226 } catch (RemoteException ex) { 3227 throw new RuntimeException(ex); 3228 } 3229 } break; 3230 case CONTAINER_CALLBACK_TASK_LIST_EMPTY: { 3231 final ActivityContainer container = (ActivityContainer) msg.obj; 3232 final IActivityContainerCallback callback = container.mCallback; 3233 if (callback != null) { 3234 try { 3235 callback.onAllActivitiesComplete(container.asBinder()); 3236 } catch (RemoteException e) { 3237 } 3238 } 3239 } break; 3240 case CONTAINER_TASK_LIST_EMPTY_TIMEOUT: { 3241 synchronized (mService) { 3242 Slog.w(TAG, "Timeout waiting for all activities in task to finish. " + 3243 msg.obj); 3244 ((ActivityContainer) msg.obj).onTaskListEmptyLocked(); 3245 } 3246 } break; 3247 } 3248 } 3249 } 3250 3251 class ActivityContainer extends android.app.IActivityContainer.Stub { 3252 final static int FORCE_NEW_TASK_FLAGS = Intent.FLAG_ACTIVITY_NEW_TASK | 3253 Intent.FLAG_ACTIVITY_MULTIPLE_TASK | Intent.FLAG_ACTIVITY_NO_ANIMATION; 3254 final int mStackId; 3255 IActivityContainerCallback mCallback = null; 3256 final ActivityStack mStack; 3257 ActivityRecord mParentActivity = null; 3258 String mIdString; 3259 3260 boolean mVisible = true; 3261 3262 /** Display this ActivityStack is currently on. Null if not attached to a Display. */ 3263 ActivityDisplay mActivityDisplay; 3264 3265 final static int CONTAINER_STATE_HAS_SURFACE = 0; 3266 final static int CONTAINER_STATE_NO_SURFACE = 1; 3267 final static int CONTAINER_STATE_FINISHING = 2; 3268 int mContainerState = CONTAINER_STATE_HAS_SURFACE; 3269 3270 ActivityContainer(int stackId) { 3271 synchronized (mService) { 3272 mStackId = stackId; 3273 mStack = new ActivityStack(this); 3274 mIdString = "ActivtyContainer{" + mStackId + "}"; 3275 if (DEBUG_STACK) Slog.d(TAG, "Creating " + this); 3276 } 3277 } 3278 3279 void attachToDisplayLocked(ActivityDisplay activityDisplay) { 3280 if (DEBUG_STACK) Slog.d(TAG, "attachToDisplayLocked: " + this 3281 + " to display=" + activityDisplay); 3282 mActivityDisplay = activityDisplay; 3283 mStack.mDisplayId = activityDisplay.mDisplayId; 3284 mStack.mStacks = activityDisplay.mStacks; 3285 3286 activityDisplay.attachActivities(mStack); 3287 mWindowManager.attachStack(mStackId, activityDisplay.mDisplayId); 3288 } 3289 3290 @Override 3291 public void attachToDisplay(int displayId) { 3292 synchronized (mService) { 3293 ActivityDisplay activityDisplay = mActivityDisplays.get(displayId); 3294 if (activityDisplay == null) { 3295 return; 3296 } 3297 attachToDisplayLocked(activityDisplay); 3298 } 3299 } 3300 3301 @Override 3302 public int getDisplayId() { 3303 synchronized (mService) { 3304 if (mActivityDisplay != null) { 3305 return mActivityDisplay.mDisplayId; 3306 } 3307 } 3308 return -1; 3309 } 3310 3311 @Override 3312 public boolean injectEvent(InputEvent event) { 3313 final long origId = Binder.clearCallingIdentity(); 3314 try { 3315 synchronized (mService) { 3316 if (mActivityDisplay != null) { 3317 return mInputManagerInternal.injectInputEvent(event, 3318 mActivityDisplay.mDisplayId, 3319 InputManager.INJECT_INPUT_EVENT_MODE_ASYNC); 3320 } 3321 } 3322 return false; 3323 } finally { 3324 Binder.restoreCallingIdentity(origId); 3325 } 3326 } 3327 3328 @Override 3329 public void release() { 3330 synchronized (mService) { 3331 if (mContainerState == CONTAINER_STATE_FINISHING) { 3332 return; 3333 } 3334 mContainerState = CONTAINER_STATE_FINISHING; 3335 3336 final Message msg = 3337 mHandler.obtainMessage(CONTAINER_TASK_LIST_EMPTY_TIMEOUT, this); 3338 mHandler.sendMessageDelayed(msg, 1000); 3339 3340 long origId = Binder.clearCallingIdentity(); 3341 try { 3342 mStack.finishAllActivitiesLocked(); 3343 } finally { 3344 Binder.restoreCallingIdentity(origId); 3345 } 3346 } 3347 } 3348 3349 private void detachLocked() { 3350 if (DEBUG_STACK) Slog.d(TAG, "detachLocked: " + this + " from display=" 3351 + mActivityDisplay + " Callers=" + Debug.getCallers(2)); 3352 if (mActivityDisplay != null) { 3353 mActivityDisplay.detachActivitiesLocked(mStack); 3354 mActivityDisplay = null; 3355 mStack.mDisplayId = -1; 3356 mStack.mStacks = null; 3357 mWindowManager.detachStack(mStackId); 3358 } 3359 } 3360 3361 @Override 3362 public final int startActivity(Intent intent) { 3363 mService.enforceNotIsolatedCaller("ActivityContainer.startActivity"); 3364 int userId = mService.handleIncomingUser(Binder.getCallingPid(), 3365 Binder.getCallingUid(), mCurrentUser, false, true, "ActivityContainer", null); 3366 // TODO: Switch to user app stacks here. 3367 intent.addFlags(FORCE_NEW_TASK_FLAGS); 3368 String mimeType = intent.getType(); 3369 if (mimeType == null && intent.getData() != null 3370 && "content".equals(intent.getData().getScheme())) { 3371 mimeType = mService.getProviderMimeType(intent.getData(), userId); 3372 } 3373 return startActivityMayWait(null, -1, null, intent, mimeType, null, null, null, null, 0, 0, null, 3374 null, null, null, null, userId, this); 3375 } 3376 3377 @Override 3378 public final int startActivityIntentSender(IIntentSender intentSender) { 3379 mService.enforceNotIsolatedCaller("ActivityContainer.startActivityIntentSender"); 3380 3381 if (!(intentSender instanceof PendingIntentRecord)) { 3382 throw new IllegalArgumentException("Bad PendingIntent object"); 3383 } 3384 3385 return ((PendingIntentRecord)intentSender).sendInner(0, null, null, null, null, null, 3386 null, 0, FORCE_NEW_TASK_FLAGS, FORCE_NEW_TASK_FLAGS, null, this); 3387 } 3388 3389 private void checkEmbeddedAllowedInner(Intent intent, String resolvedType) { 3390 int userId = mService.handleIncomingUser(Binder.getCallingPid(), 3391 Binder.getCallingUid(), mCurrentUser, false, true, "ActivityContainer", null); 3392 if (resolvedType == null) { 3393 resolvedType = intent.getType(); 3394 if (resolvedType == null && intent.getData() != null 3395 && "content".equals(intent.getData().getScheme())) { 3396 resolvedType = mService.getProviderMimeType(intent.getData(), userId); 3397 } 3398 } 3399 ActivityInfo aInfo = resolveActivity(intent, resolvedType, 0, null, null, userId); 3400 if (aInfo != null && (aInfo.flags & ActivityInfo.FLAG_ALLOW_EMBEDDED) == 0) { 3401 throw new SecurityException( 3402 "Attempt to embed activity that has not set allowEmbedded=\"true\""); 3403 } 3404 } 3405 3406 /** Throw a SecurityException if allowEmbedded is not true */ 3407 @Override 3408 public final void checkEmbeddedAllowed(Intent intent) { 3409 checkEmbeddedAllowedInner(intent, null); 3410 } 3411 3412 /** Throw a SecurityException if allowEmbedded is not true */ 3413 @Override 3414 public final void checkEmbeddedAllowedIntentSender(IIntentSender intentSender) { 3415 if (!(intentSender instanceof PendingIntentRecord)) { 3416 throw new IllegalArgumentException("Bad PendingIntent object"); 3417 } 3418 PendingIntentRecord pendingIntent = (PendingIntentRecord) intentSender; 3419 checkEmbeddedAllowedInner(pendingIntent.key.requestIntent, 3420 pendingIntent.key.requestResolvedType); 3421 } 3422 3423 @Override 3424 public IBinder asBinder() { 3425 return this; 3426 } 3427 3428 @Override 3429 public void setSurface(Surface surface, int width, int height, int density) { 3430 mService.enforceNotIsolatedCaller("ActivityContainer.attachToSurface"); 3431 } 3432 3433 ActivityStackSupervisor getOuter() { 3434 return ActivityStackSupervisor.this; 3435 } 3436 3437 boolean isAttachedLocked() { 3438 return mActivityDisplay != null; 3439 } 3440 3441 void getBounds(Point outBounds) { 3442 synchronized (mService) { 3443 if (mActivityDisplay != null) { 3444 mActivityDisplay.getBounds(outBounds); 3445 } else { 3446 outBounds.set(0, 0); 3447 } 3448 } 3449 } 3450 3451 // TODO: Make sure every change to ActivityRecord.visible results in a call to this. 3452 void setVisible(boolean visible) { 3453 if (mVisible != visible) { 3454 mVisible = visible; 3455 if (mCallback != null) { 3456 mHandler.obtainMessage(CONTAINER_CALLBACK_VISIBILITY, visible ? 1 : 0, 3457 0 /* unused */, this).sendToTarget(); 3458 } 3459 } 3460 } 3461 3462 void setDrawn() { 3463 } 3464 3465 // You can always start a new task on a regular ActivityStack. 3466 boolean isEligibleForNewTasks() { 3467 return true; 3468 } 3469 3470 void onTaskListEmptyLocked() { 3471 mHandler.removeMessages(CONTAINER_TASK_LIST_EMPTY_TIMEOUT, this); 3472 if (!mStack.isHomeStack()) { 3473 detachLocked(); 3474 deleteActivityContainer(this); 3475 } 3476 mHandler.obtainMessage(CONTAINER_CALLBACK_TASK_LIST_EMPTY, this).sendToTarget(); 3477 } 3478 3479 @Override 3480 public String toString() { 3481 return mIdString + (mActivityDisplay == null ? "N" : "A"); 3482 } 3483 } 3484 3485 private class VirtualActivityContainer extends ActivityContainer { 3486 Surface mSurface; 3487 boolean mDrawn = false; 3488 3489 VirtualActivityContainer(ActivityRecord parent, IActivityContainerCallback callback) { 3490 super(getNextStackId()); 3491 mParentActivity = parent; 3492 mCallback = callback; 3493 mContainerState = CONTAINER_STATE_NO_SURFACE; 3494 mIdString = "VirtualActivityContainer{" + mStackId + ", parent=" + mParentActivity + "}"; 3495 } 3496 3497 @Override 3498 public void setSurface(Surface surface, int width, int height, int density) { 3499 super.setSurface(surface, width, height, density); 3500 3501 synchronized (mService) { 3502 final long origId = Binder.clearCallingIdentity(); 3503 try { 3504 setSurfaceLocked(surface, width, height, density); 3505 } finally { 3506 Binder.restoreCallingIdentity(origId); 3507 } 3508 } 3509 } 3510 3511 private void setSurfaceLocked(Surface surface, int width, int height, int density) { 3512 if (mContainerState == CONTAINER_STATE_FINISHING) { 3513 return; 3514 } 3515 VirtualActivityDisplay virtualActivityDisplay = 3516 (VirtualActivityDisplay) mActivityDisplay; 3517 if (virtualActivityDisplay == null) { 3518 virtualActivityDisplay = 3519 new VirtualActivityDisplay(width, height, density); 3520 mActivityDisplay = virtualActivityDisplay; 3521 mActivityDisplays.put(virtualActivityDisplay.mDisplayId, virtualActivityDisplay); 3522 attachToDisplayLocked(virtualActivityDisplay); 3523 } 3524 3525 if (mSurface != null) { 3526 mSurface.release(); 3527 } 3528 3529 mSurface = surface; 3530 if (surface != null) { 3531 mStack.resumeTopActivityLocked(null); 3532 } else { 3533 mContainerState = CONTAINER_STATE_NO_SURFACE; 3534 ((VirtualActivityDisplay) mActivityDisplay).setSurface(null); 3535 if (mStack.mPausingActivity == null && mStack.mResumedActivity != null) { 3536 mStack.startPausingLocked(false, true); 3537 } 3538 } 3539 3540 setSurfaceIfReadyLocked(); 3541 3542 if (DEBUG_STACK) Slog.d(TAG, "setSurface: " + this + " to display=" 3543 + virtualActivityDisplay); 3544 } 3545 3546 @Override 3547 boolean isAttachedLocked() { 3548 return mSurface != null && super.isAttachedLocked(); 3549 } 3550 3551 @Override 3552 void setDrawn() { 3553 synchronized (mService) { 3554 mDrawn = true; 3555 setSurfaceIfReadyLocked(); 3556 } 3557 } 3558 3559 // Never start a new task on an ActivityView if it isn't explicitly specified. 3560 @Override 3561 boolean isEligibleForNewTasks() { 3562 return false; 3563 } 3564 3565 private void setSurfaceIfReadyLocked() { 3566 if (DEBUG_STACK) Slog.v(TAG, "setSurfaceIfReadyLocked: mDrawn=" + mDrawn + 3567 " mContainerState=" + mContainerState + " mSurface=" + mSurface); 3568 if (mDrawn && mSurface != null && mContainerState == CONTAINER_STATE_NO_SURFACE) { 3569 ((VirtualActivityDisplay) mActivityDisplay).setSurface(mSurface); 3570 mContainerState = CONTAINER_STATE_HAS_SURFACE; 3571 } 3572 } 3573 } 3574 3575 /** Exactly one of these classes per Display in the system. Capable of holding zero or more 3576 * attached {@link ActivityStack}s */ 3577 class ActivityDisplay { 3578 /** Actual Display this object tracks. */ 3579 int mDisplayId; 3580 Display mDisplay; 3581 DisplayInfo mDisplayInfo = new DisplayInfo(); 3582 3583 /** All of the stacks on this display. Order matters, topmost stack is in front of all other 3584 * stacks, bottommost behind. Accessed directly by ActivityManager package classes */ 3585 final ArrayList<ActivityStack> mStacks = new ArrayList<ActivityStack>(); 3586 3587 ActivityDisplay() { 3588 } 3589 3590 ActivityDisplay(int displayId) { 3591 init(mDisplayManager.getDisplay(displayId)); 3592 } 3593 3594 void init(Display display) { 3595 mDisplay = display; 3596 mDisplayId = display.getDisplayId(); 3597 mDisplay.getDisplayInfo(mDisplayInfo); 3598 } 3599 3600 void attachActivities(ActivityStack stack) { 3601 if (DEBUG_STACK) Slog.v(TAG, "attachActivities: attaching " + stack + " to displayId=" 3602 + mDisplayId); 3603 mStacks.add(stack); 3604 } 3605 3606 void detachActivitiesLocked(ActivityStack stack) { 3607 if (DEBUG_STACK) Slog.v(TAG, "detachActivitiesLocked: detaching " + stack 3608 + " from displayId=" + mDisplayId); 3609 mStacks.remove(stack); 3610 } 3611 3612 void getBounds(Point bounds) { 3613 mDisplay.getDisplayInfo(mDisplayInfo); 3614 bounds.x = mDisplayInfo.appWidth; 3615 bounds.y = mDisplayInfo.appHeight; 3616 } 3617 3618 @Override 3619 public String toString() { 3620 return "ActivityDisplay={" + mDisplayId + " numStacks=" + mStacks.size() + "}"; 3621 } 3622 } 3623 3624 class VirtualActivityDisplay extends ActivityDisplay { 3625 VirtualDisplay mVirtualDisplay; 3626 3627 VirtualActivityDisplay(int width, int height, int density) { 3628 DisplayManagerGlobal dm = DisplayManagerGlobal.getInstance(); 3629 mVirtualDisplay = dm.createVirtualDisplay(mService.mContext, VIRTUAL_DISPLAY_BASE_NAME, 3630 width, height, density, null, DisplayManager.VIRTUAL_DISPLAY_FLAG_PUBLIC | 3631 DisplayManager.VIRTUAL_DISPLAY_FLAG_OWN_CONTENT_ONLY); 3632 3633 init(mVirtualDisplay.getDisplay()); 3634 3635 mWindowManager.handleDisplayAdded(mDisplayId); 3636 } 3637 3638 void setSurface(Surface surface) { 3639 if (mVirtualDisplay != null) { 3640 mVirtualDisplay.setSurface(surface); 3641 } 3642 } 3643 3644 @Override 3645 void detachActivitiesLocked(ActivityStack stack) { 3646 super.detachActivitiesLocked(stack); 3647 if (mVirtualDisplay != null) { 3648 mVirtualDisplay.release(); 3649 mVirtualDisplay = null; 3650 } 3651 } 3652 3653 @Override 3654 public String toString() { 3655 return "VirtualActivityDisplay={" + mDisplayId + "}"; 3656 } 3657 } 3658 3659 private boolean isLeanbackOnlyDevice() { 3660 boolean onLeanbackOnly = false; 3661 try { 3662 onLeanbackOnly = AppGlobals.getPackageManager().hasSystemFeature( 3663 PackageManager.FEATURE_LEANBACK_ONLY); 3664 } catch (RemoteException e) { 3665 // noop 3666 } 3667 3668 return onLeanbackOnly; 3669 } 3670} 3671