ActivityStackSupervisor.java revision a8f569c10a423ced5be7e019c3df2bca11b052f5
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 findTaskToMoveToFrontLocked(TaskRecord task, int flags, Bundle options) { 2260 if ((flags & ActivityManager.MOVE_TASK_NO_USER_ACTION) == 0) { 2261 mUserLeaving = true; 2262 } 2263 if ((flags & ActivityManager.MOVE_TASK_WITH_HOME) != 0) { 2264 // Caller wants the home activity moved with it. To accomplish this, 2265 // we'll just indicate that this task returns to the home task. 2266 task.setTaskToReturnTo(HOME_ACTIVITY_TYPE); 2267 } 2268 task.stack.moveTaskToFrontLocked(task, null, options); 2269 if (DEBUG_STACK) Slog.d(TAG, "findTaskToMoveToFront: moved to front of stack=" 2270 + task.stack); 2271 } 2272 2273 ActivityStack getStack(int stackId) { 2274 ActivityContainer activityContainer = mActivityContainers.get(stackId); 2275 if (activityContainer != null) { 2276 return activityContainer.mStack; 2277 } 2278 return null; 2279 } 2280 2281 ArrayList<ActivityStack> getStacks() { 2282 ArrayList<ActivityStack> allStacks = new ArrayList<ActivityStack>(); 2283 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 2284 allStacks.addAll(mActivityDisplays.valueAt(displayNdx).mStacks); 2285 } 2286 return allStacks; 2287 } 2288 2289 IBinder getHomeActivityToken() { 2290 final ArrayList<TaskRecord> tasks = mHomeStack.getAllTasks(); 2291 for (int taskNdx = tasks.size() - 1; taskNdx >= 0; --taskNdx) { 2292 final TaskRecord task = tasks.get(taskNdx); 2293 if (task.isHomeTask()) { 2294 final ArrayList<ActivityRecord> activities = task.mActivities; 2295 for (int activityNdx = activities.size() - 1; activityNdx >= 0; --activityNdx) { 2296 final ActivityRecord r = activities.get(activityNdx); 2297 if (r.isHomeActivity()) { 2298 return r.appToken; 2299 } 2300 } 2301 } 2302 } 2303 return null; 2304 } 2305 2306 ActivityContainer createActivityContainer(ActivityRecord parentActivity, 2307 IActivityContainerCallback callback) { 2308 ActivityContainer activityContainer = 2309 new VirtualActivityContainer(parentActivity, callback); 2310 mActivityContainers.put(activityContainer.mStackId, activityContainer); 2311 if (DEBUG_CONTAINERS) Slog.d(TAG, "createActivityContainer: " + activityContainer); 2312 parentActivity.mChildContainers.add(activityContainer); 2313 return activityContainer; 2314 } 2315 2316 void removeChildActivityContainers(ActivityRecord parentActivity) { 2317 final ArrayList<ActivityContainer> childStacks = parentActivity.mChildContainers; 2318 for (int containerNdx = childStacks.size() - 1; containerNdx >= 0; --containerNdx) { 2319 ActivityContainer container = childStacks.remove(containerNdx); 2320 if (DEBUG_CONTAINERS) Slog.d(TAG, "removeChildActivityContainers: removing " + 2321 container); 2322 container.release(); 2323 } 2324 } 2325 2326 void deleteActivityContainer(IActivityContainer container) { 2327 ActivityContainer activityContainer = (ActivityContainer)container; 2328 if (activityContainer != null) { 2329 if (DEBUG_CONTAINERS) Slog.d(TAG, "deleteActivityContainer: ", 2330 new RuntimeException("here").fillInStackTrace()); 2331 final int stackId = activityContainer.mStackId; 2332 mActivityContainers.remove(stackId); 2333 mWindowManager.removeStack(stackId); 2334 } 2335 } 2336 2337 private int createStackOnDisplay(int stackId, int displayId) { 2338 ActivityDisplay activityDisplay = mActivityDisplays.get(displayId); 2339 if (activityDisplay == null) { 2340 return -1; 2341 } 2342 2343 ActivityContainer activityContainer = new ActivityContainer(stackId); 2344 mActivityContainers.put(stackId, activityContainer); 2345 activityContainer.attachToDisplayLocked(activityDisplay); 2346 return stackId; 2347 } 2348 2349 int getNextStackId() { 2350 while (true) { 2351 if (++mLastStackId <= HOME_STACK_ID) { 2352 mLastStackId = HOME_STACK_ID + 1; 2353 } 2354 if (getStack(mLastStackId) == null) { 2355 break; 2356 } 2357 } 2358 return mLastStackId; 2359 } 2360 2361 void createStackForRestoredTaskHistory(ArrayList<TaskRecord> tasks) { 2362 int stackId = createStackOnDisplay(getNextStackId(), Display.DEFAULT_DISPLAY); 2363 final ActivityStack stack = getStack(stackId); 2364 for (int taskNdx = tasks.size() - 1; taskNdx >= 0; --taskNdx) { 2365 final TaskRecord task = tasks.get(taskNdx); 2366 stack.addTask(task, false, false); 2367 final int taskId = task.taskId; 2368 final ArrayList<ActivityRecord> activities = task.mActivities; 2369 for (int activityNdx = activities.size() - 1; activityNdx >= 0; --activityNdx) { 2370 final ActivityRecord r = activities.get(activityNdx); 2371 mWindowManager.addAppToken(0, r.appToken, taskId, stackId, 2372 r.info.screenOrientation, r.fullscreen, 2373 (r.info.flags & ActivityInfo.FLAG_SHOW_ON_LOCK_SCREEN) != 0, 2374 r.userId, r.info.configChanges, task.voiceSession != null); 2375 } 2376 mWindowManager.addTask(taskId, stackId, false); 2377 } 2378 resumeHomeStackTask(HOME_ACTIVITY_TYPE, null); 2379 } 2380 2381 void moveTaskToStack(int taskId, int stackId, boolean toTop) { 2382 final TaskRecord task = anyTaskForIdLocked(taskId); 2383 if (task == null) { 2384 return; 2385 } 2386 final ActivityStack stack = getStack(stackId); 2387 if (stack == null) { 2388 Slog.w(TAG, "moveTaskToStack: no stack for id=" + stackId); 2389 return; 2390 } 2391 task.stack.removeTask(task); 2392 stack.addTask(task, toTop, true); 2393 mWindowManager.addTask(taskId, stackId, toTop); 2394 resumeTopActivitiesLocked(); 2395 } 2396 2397 ActivityRecord findTaskLocked(ActivityRecord r) { 2398 if (DEBUG_TASKS) Slog.d(TAG, "Looking for task of " + r); 2399 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 2400 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 2401 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 2402 final ActivityStack stack = stacks.get(stackNdx); 2403 if (!r.isApplicationActivity() && !stack.isHomeStack()) { 2404 if (DEBUG_TASKS) Slog.d(TAG, "Skipping stack: (home activity) " + stack); 2405 continue; 2406 } 2407 if (!stack.mActivityContainer.isEligibleForNewTasks()) { 2408 if (DEBUG_TASKS) Slog.d(TAG, "Skipping stack: (new task not allowed) " + 2409 stack); 2410 continue; 2411 } 2412 final ActivityRecord ar = stack.findTaskLocked(r); 2413 if (ar != null) { 2414 return ar; 2415 } 2416 } 2417 } 2418 if (DEBUG_TASKS) Slog.d(TAG, "No task found"); 2419 return null; 2420 } 2421 2422 ActivityRecord findActivityLocked(Intent intent, ActivityInfo info) { 2423 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 2424 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 2425 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 2426 final ActivityRecord ar = stacks.get(stackNdx).findActivityLocked(intent, info); 2427 if (ar != null) { 2428 return ar; 2429 } 2430 } 2431 } 2432 return null; 2433 } 2434 2435 void goingToSleepLocked() { 2436 scheduleSleepTimeout(); 2437 if (!mGoingToSleep.isHeld()) { 2438 mGoingToSleep.acquire(); 2439 if (mLaunchingActivity.isHeld()) { 2440 if (VALIDATE_WAKE_LOCK_CALLER && Binder.getCallingUid() != Process.myUid()) { 2441 throw new IllegalStateException("Calling must be system uid"); 2442 } 2443 mLaunchingActivity.release(); 2444 mService.mHandler.removeMessages(LAUNCH_TIMEOUT_MSG); 2445 } 2446 } 2447 checkReadyForSleepLocked(); 2448 } 2449 2450 boolean shutdownLocked(int timeout) { 2451 goingToSleepLocked(); 2452 2453 boolean timedout = false; 2454 final long endTime = System.currentTimeMillis() + timeout; 2455 while (true) { 2456 boolean cantShutdown = false; 2457 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 2458 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 2459 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 2460 cantShutdown |= stacks.get(stackNdx).checkReadyForSleepLocked(); 2461 } 2462 } 2463 if (cantShutdown) { 2464 long timeRemaining = endTime - System.currentTimeMillis(); 2465 if (timeRemaining > 0) { 2466 try { 2467 mService.wait(timeRemaining); 2468 } catch (InterruptedException e) { 2469 } 2470 } else { 2471 Slog.w(TAG, "Activity manager shutdown timed out"); 2472 timedout = true; 2473 break; 2474 } 2475 } else { 2476 break; 2477 } 2478 } 2479 2480 // Force checkReadyForSleep to complete. 2481 mSleepTimeout = true; 2482 checkReadyForSleepLocked(); 2483 2484 return timedout; 2485 } 2486 2487 void comeOutOfSleepIfNeededLocked() { 2488 removeSleepTimeouts(); 2489 if (mGoingToSleep.isHeld()) { 2490 mGoingToSleep.release(); 2491 } 2492 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 2493 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 2494 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 2495 final ActivityStack stack = stacks.get(stackNdx); 2496 stack.awakeFromSleepingLocked(); 2497 if (isFrontStack(stack)) { 2498 resumeTopActivitiesLocked(); 2499 } 2500 } 2501 } 2502 mGoingToSleepActivities.clear(); 2503 } 2504 2505 void activitySleptLocked(ActivityRecord r) { 2506 mGoingToSleepActivities.remove(r); 2507 checkReadyForSleepLocked(); 2508 } 2509 2510 void checkReadyForSleepLocked() { 2511 if (!mService.isSleepingOrShuttingDown()) { 2512 // Do not care. 2513 return; 2514 } 2515 2516 if (!mSleepTimeout) { 2517 boolean dontSleep = false; 2518 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 2519 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 2520 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 2521 dontSleep |= stacks.get(stackNdx).checkReadyForSleepLocked(); 2522 } 2523 } 2524 2525 if (mStoppingActivities.size() > 0) { 2526 // Still need to tell some activities to stop; can't sleep yet. 2527 if (DEBUG_PAUSE) Slog.v(TAG, "Sleep still need to stop " 2528 + mStoppingActivities.size() + " activities"); 2529 scheduleIdleLocked(); 2530 dontSleep = true; 2531 } 2532 2533 if (mGoingToSleepActivities.size() > 0) { 2534 // Still need to tell some activities to sleep; can't sleep yet. 2535 if (DEBUG_PAUSE) Slog.v(TAG, "Sleep still need to sleep " 2536 + mGoingToSleepActivities.size() + " activities"); 2537 dontSleep = true; 2538 } 2539 2540 if (dontSleep) { 2541 return; 2542 } 2543 } 2544 2545 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 2546 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 2547 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 2548 stacks.get(stackNdx).goToSleep(); 2549 } 2550 } 2551 2552 removeSleepTimeouts(); 2553 2554 if (mGoingToSleep.isHeld()) { 2555 mGoingToSleep.release(); 2556 } 2557 if (mService.mShuttingDown) { 2558 mService.notifyAll(); 2559 } 2560 } 2561 2562 boolean reportResumedActivityLocked(ActivityRecord r) { 2563 final ActivityStack stack = r.task.stack; 2564 if (isFrontStack(stack)) { 2565 mService.updateUsageStats(r, true); 2566 } 2567 if (allResumedActivitiesComplete()) { 2568 ensureActivitiesVisibleLocked(null, 0); 2569 mWindowManager.executeAppTransition(); 2570 return true; 2571 } 2572 return false; 2573 } 2574 2575 void handleAppCrashLocked(ProcessRecord app) { 2576 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 2577 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 2578 final int numStacks = stacks.size(); 2579 for (int stackNdx = 0; stackNdx < numStacks; ++stackNdx) { 2580 final ActivityStack stack = stacks.get(stackNdx); 2581 stack.handleAppCrashLocked(app); 2582 } 2583 } 2584 } 2585 2586 void ensureActivitiesVisibleLocked(ActivityRecord starting, int configChanges) { 2587 // First the front stacks. In case any are not fullscreen and are in front of home. 2588 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 2589 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 2590 final int topStackNdx = stacks.size() - 1; 2591 for (int stackNdx = topStackNdx; stackNdx >= 0; --stackNdx) { 2592 final ActivityStack stack = stacks.get(stackNdx); 2593 stack.ensureActivitiesVisibleLocked(starting, configChanges); 2594 } 2595 } 2596 } 2597 2598 void scheduleDestroyAllActivities(ProcessRecord app, String reason) { 2599 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 2600 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 2601 final int numStacks = stacks.size(); 2602 for (int stackNdx = 0; stackNdx < numStacks; ++stackNdx) { 2603 final ActivityStack stack = stacks.get(stackNdx); 2604 stack.scheduleDestroyActivities(app, false, reason); 2605 } 2606 } 2607 } 2608 2609 boolean switchUserLocked(int userId, UserStartedState uss) { 2610 mUserStackInFront.put(mCurrentUser, getFocusedStack().getStackId()); 2611 final int restoreStackId = mUserStackInFront.get(userId, HOME_STACK_ID); 2612 mCurrentUser = userId; 2613 2614 mStartingUsers.add(uss); 2615 for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { 2616 final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 2617 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 2618 final ActivityStack stack = stacks.get(stackNdx); 2619 stack.switchUserLocked(userId); 2620 TaskRecord task = stack.topTask(); 2621 if (task != null) { 2622 mWindowManager.moveTaskToTop(task.taskId); 2623 } 2624 } 2625 } 2626 2627 ActivityStack stack = getStack(restoreStackId); 2628 if (stack == null) { 2629 stack = mHomeStack; 2630 } 2631 final boolean homeInFront = stack.isHomeStack(); 2632 if (stack.isOnHomeDisplay()) { 2633 moveHomeStack(homeInFront); 2634 TaskRecord task = stack.topTask(); 2635 if (task != null) { 2636 mWindowManager.moveTaskToTop(task.taskId); 2637 } 2638 } else { 2639 // Stack was moved to another display while user was swapped out. 2640 resumeHomeStackTask(HOME_ACTIVITY_TYPE, null); 2641 } 2642 return homeInFront; 2643 } 2644 2645 /** 2646 * Add background users to send boot completed events to. 2647 * @param userId The user being started in the background 2648 * @param uss The state object for the user. 2649 */ 2650 public void startBackgroundUserLocked(int userId, UserStartedState uss) { 2651 mStartingBackgroundUsers.add(uss); 2652 } 2653 2654 final ArrayList<ActivityRecord> processStoppingActivitiesLocked(boolean remove) { 2655 int N = mStoppingActivities.size(); 2656 if (N <= 0) return null; 2657 2658 ArrayList<ActivityRecord> stops = null; 2659 2660 final boolean nowVisible = allResumedActivitiesVisible(); 2661 for (int i=0; i<N; i++) { 2662 ActivityRecord s = mStoppingActivities.get(i); 2663 if (localLOGV) Slog.v(TAG, "Stopping " + s + ": nowVisible=" 2664 + nowVisible + " waitingVisible=" + s.waitingVisible 2665 + " finishing=" + s.finishing); 2666 if (s.waitingVisible && nowVisible) { 2667 mWaitingVisibleActivities.remove(s); 2668 s.waitingVisible = false; 2669 if (s.finishing) { 2670 // If this activity is finishing, it is sitting on top of 2671 // everyone else but we now know it is no longer needed... 2672 // so get rid of it. Otherwise, we need to go through the 2673 // normal flow and hide it once we determine that it is 2674 // hidden by the activities in front of it. 2675 if (localLOGV) Slog.v(TAG, "Before stopping, can hide: " + s); 2676 mWindowManager.setAppVisibility(s.appToken, false); 2677 } 2678 } 2679 if ((!s.waitingVisible || mService.isSleepingOrShuttingDown()) && remove) { 2680 if (localLOGV) Slog.v(TAG, "Ready to stop: " + s); 2681 if (stops == null) { 2682 stops = new ArrayList<ActivityRecord>(); 2683 } 2684 stops.add(s); 2685 mStoppingActivities.remove(i); 2686 N--; 2687 i--; 2688 } 2689 } 2690 2691 return stops; 2692 } 2693 2694 void validateTopActivitiesLocked() { 2695 // FIXME 2696/* for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 2697 final ActivityStack stack = stacks.get(stackNdx); 2698 final ActivityRecord r = stack.topRunningActivityLocked(null); 2699 final ActivityState state = r == null ? ActivityState.DESTROYED : r.state; 2700 if (isFrontStack(stack)) { 2701 if (r == null) { 2702 Slog.e(TAG, "validateTop...: null top activity, stack=" + stack); 2703 } else { 2704 final ActivityRecord pausing = stack.mPausingActivity; 2705 if (pausing != null && pausing == r) { 2706 Slog.e(TAG, "validateTop...: top stack has pausing activity r=" + r + 2707 " state=" + state); 2708 } 2709 if (state != ActivityState.INITIALIZING && state != ActivityState.RESUMED) { 2710 Slog.e(TAG, "validateTop...: activity in front not resumed r=" + r + 2711 " state=" + state); 2712 } 2713 } 2714 } else { 2715 final ActivityRecord resumed = stack.mResumedActivity; 2716 if (resumed != null && resumed == r) { 2717 Slog.e(TAG, "validateTop...: back stack has resumed activity r=" + r + 2718 " state=" + state); 2719 } 2720 if (r != null && (state == ActivityState.INITIALIZING 2721 || state == ActivityState.RESUMED)) { 2722 Slog.e(TAG, "validateTop...: activity in back resumed r=" + r + 2723 " state=" + state); 2724 } 2725 } 2726 } 2727*/ 2728 } 2729 2730 public void dump(PrintWriter pw, String prefix) { 2731 pw.print(prefix); pw.print("mDismissKeyguardOnNextActivity="); 2732 pw.println(mDismissKeyguardOnNextActivity); 2733 pw.print(prefix); pw.print("mFocusedStack=" + mFocusedStack); 2734 pw.print(" mLastFocusedStack="); pw.println(mLastFocusedStack); 2735 pw.print(prefix); pw.println("mSleepTimeout=" + mSleepTimeout); 2736 pw.print(prefix); pw.println("mCurTaskId=" + mCurTaskId); 2737 pw.print(prefix); pw.println("mUserStackInFront=" + mUserStackInFront); 2738 pw.print(prefix); pw.println("mActivityContainers=" + mActivityContainers); 2739 } 2740 2741 ArrayList<ActivityRecord> getDumpActivitiesLocked(String name) { 2742 return getFocusedStack().getDumpActivitiesLocked(name); 2743 } 2744 2745 static boolean printThisActivity(PrintWriter pw, ActivityRecord activity, String dumpPackage, 2746 boolean needSep, String prefix) { 2747 if (activity != null) { 2748 if (dumpPackage == null || dumpPackage.equals(activity.packageName)) { 2749 if (needSep) { 2750 pw.println(); 2751 } 2752 pw.print(prefix); 2753 pw.println(activity); 2754 return true; 2755 } 2756 } 2757 return false; 2758 } 2759 2760 boolean dumpActivitiesLocked(FileDescriptor fd, PrintWriter pw, boolean dumpAll, 2761 boolean dumpClient, String dumpPackage) { 2762 boolean printed = false; 2763 boolean needSep = false; 2764 for (int displayNdx = 0; displayNdx < mActivityDisplays.size(); ++displayNdx) { 2765 ActivityDisplay activityDisplay = mActivityDisplays.valueAt(displayNdx); 2766 pw.print("Display #"); pw.println(activityDisplay.mDisplayId); 2767 ArrayList<ActivityStack> stacks = activityDisplay.mStacks; 2768 final int numStacks = stacks.size(); 2769 for (int stackNdx = 0; stackNdx < numStacks; ++stackNdx) { 2770 final ActivityStack stack = stacks.get(stackNdx); 2771 StringBuilder stackHeader = new StringBuilder(128); 2772 stackHeader.append(" Stack #"); 2773 stackHeader.append(stack.mStackId); 2774 stackHeader.append(":"); 2775 printed |= stack.dumpActivitiesLocked(fd, pw, dumpAll, dumpClient, dumpPackage, 2776 needSep, stackHeader.toString()); 2777 printed |= dumpHistoryList(fd, pw, stack.mLRUActivities, " ", "Run", false, 2778 !dumpAll, false, dumpPackage, true, 2779 " Running activities (most recent first):", null); 2780 2781 needSep = printed; 2782 boolean pr = printThisActivity(pw, stack.mPausingActivity, dumpPackage, needSep, 2783 " mPausingActivity: "); 2784 if (pr) { 2785 printed = true; 2786 needSep = false; 2787 } 2788 pr = printThisActivity(pw, stack.mResumedActivity, dumpPackage, needSep, 2789 " mResumedActivity: "); 2790 if (pr) { 2791 printed = true; 2792 needSep = false; 2793 } 2794 if (dumpAll) { 2795 pr = printThisActivity(pw, stack.mLastPausedActivity, dumpPackage, needSep, 2796 " mLastPausedActivity: "); 2797 if (pr) { 2798 printed = true; 2799 needSep = true; 2800 } 2801 printed |= printThisActivity(pw, stack.mLastNoHistoryActivity, dumpPackage, 2802 needSep, " mLastNoHistoryActivity: "); 2803 } 2804 needSep = printed; 2805 } 2806 } 2807 2808 printed |= dumpHistoryList(fd, pw, mFinishingActivities, " ", "Fin", false, !dumpAll, 2809 false, dumpPackage, true, " Activities waiting to finish:", null); 2810 printed |= dumpHistoryList(fd, pw, mStoppingActivities, " ", "Stop", false, !dumpAll, 2811 false, dumpPackage, true, " Activities waiting to stop:", null); 2812 printed |= dumpHistoryList(fd, pw, mWaitingVisibleActivities, " ", "Wait", false, !dumpAll, 2813 false, dumpPackage, true, " Activities waiting for another to become visible:", 2814 null); 2815 printed |= dumpHistoryList(fd, pw, mGoingToSleepActivities, " ", "Sleep", false, !dumpAll, 2816 false, dumpPackage, true, " Activities waiting to sleep:", null); 2817 printed |= dumpHistoryList(fd, pw, mGoingToSleepActivities, " ", "Sleep", false, !dumpAll, 2818 false, dumpPackage, true, " Activities waiting to sleep:", null); 2819 2820 return printed; 2821 } 2822 2823 static boolean dumpHistoryList(FileDescriptor fd, PrintWriter pw, List<ActivityRecord> list, 2824 String prefix, String label, boolean complete, boolean brief, boolean client, 2825 String dumpPackage, boolean needNL, String header1, String header2) { 2826 TaskRecord lastTask = null; 2827 String innerPrefix = null; 2828 String[] args = null; 2829 boolean printed = false; 2830 for (int i=list.size()-1; i>=0; i--) { 2831 final ActivityRecord r = list.get(i); 2832 if (dumpPackage != null && !dumpPackage.equals(r.packageName)) { 2833 continue; 2834 } 2835 if (innerPrefix == null) { 2836 innerPrefix = prefix + " "; 2837 args = new String[0]; 2838 } 2839 printed = true; 2840 final boolean full = !brief && (complete || !r.isInHistory()); 2841 if (needNL) { 2842 pw.println(""); 2843 needNL = false; 2844 } 2845 if (header1 != null) { 2846 pw.println(header1); 2847 header1 = null; 2848 } 2849 if (header2 != null) { 2850 pw.println(header2); 2851 header2 = null; 2852 } 2853 if (lastTask != r.task) { 2854 lastTask = r.task; 2855 pw.print(prefix); 2856 pw.print(full ? "* " : " "); 2857 pw.println(lastTask); 2858 if (full) { 2859 lastTask.dump(pw, prefix + " "); 2860 } else if (complete) { 2861 // Complete + brief == give a summary. Isn't that obvious?!? 2862 if (lastTask.intent != null) { 2863 pw.print(prefix); pw.print(" "); 2864 pw.println(lastTask.intent.toInsecureStringWithClip()); 2865 } 2866 } 2867 } 2868 pw.print(prefix); pw.print(full ? " * " : " "); pw.print(label); 2869 pw.print(" #"); pw.print(i); pw.print(": "); 2870 pw.println(r); 2871 if (full) { 2872 r.dump(pw, innerPrefix); 2873 } else if (complete) { 2874 // Complete + brief == give a summary. Isn't that obvious?!? 2875 pw.print(innerPrefix); pw.println(r.intent.toInsecureString()); 2876 if (r.app != null) { 2877 pw.print(innerPrefix); pw.println(r.app); 2878 } 2879 } 2880 if (client && r.app != null && r.app.thread != null) { 2881 // flush anything that is already in the PrintWriter since the thread is going 2882 // to write to the file descriptor directly 2883 pw.flush(); 2884 try { 2885 TransferPipe tp = new TransferPipe(); 2886 try { 2887 r.app.thread.dumpActivity(tp.getWriteFd().getFileDescriptor(), 2888 r.appToken, innerPrefix, args); 2889 // Short timeout, since blocking here can 2890 // deadlock with the application. 2891 tp.go(fd, 2000); 2892 } finally { 2893 tp.kill(); 2894 } 2895 } catch (IOException e) { 2896 pw.println(innerPrefix + "Failure while dumping the activity: " + e); 2897 } catch (RemoteException e) { 2898 pw.println(innerPrefix + "Got a RemoteException while dumping the activity"); 2899 } 2900 needNL = true; 2901 } 2902 } 2903 return printed; 2904 } 2905 2906 void scheduleIdleTimeoutLocked(ActivityRecord next) { 2907 if (DEBUG_IDLE) Slog.d(TAG, "scheduleIdleTimeoutLocked: Callers=" + Debug.getCallers(4)); 2908 Message msg = mHandler.obtainMessage(IDLE_TIMEOUT_MSG, next); 2909 mHandler.sendMessageDelayed(msg, IDLE_TIMEOUT); 2910 } 2911 2912 final void scheduleIdleLocked() { 2913 mHandler.sendEmptyMessage(IDLE_NOW_MSG); 2914 } 2915 2916 void removeTimeoutsForActivityLocked(ActivityRecord r) { 2917 if (DEBUG_IDLE) Slog.d(TAG, "removeTimeoutsForActivity: Callers=" + Debug.getCallers(4)); 2918 mHandler.removeMessages(IDLE_TIMEOUT_MSG, r); 2919 } 2920 2921 final void scheduleResumeTopActivities() { 2922 if (!mHandler.hasMessages(RESUME_TOP_ACTIVITY_MSG)) { 2923 mHandler.sendEmptyMessage(RESUME_TOP_ACTIVITY_MSG); 2924 } 2925 } 2926 2927 void removeSleepTimeouts() { 2928 mSleepTimeout = false; 2929 mHandler.removeMessages(SLEEP_TIMEOUT_MSG); 2930 } 2931 2932 final void scheduleSleepTimeout() { 2933 removeSleepTimeouts(); 2934 mHandler.sendEmptyMessageDelayed(SLEEP_TIMEOUT_MSG, SLEEP_TIMEOUT); 2935 } 2936 2937 @Override 2938 public void onDisplayAdded(int displayId) { 2939 Slog.v(TAG, "Display added displayId=" + displayId); 2940 mHandler.sendMessage(mHandler.obtainMessage(HANDLE_DISPLAY_ADDED, displayId, 0)); 2941 } 2942 2943 @Override 2944 public void onDisplayRemoved(int displayId) { 2945 Slog.v(TAG, "Display removed displayId=" + displayId); 2946 mHandler.sendMessage(mHandler.obtainMessage(HANDLE_DISPLAY_REMOVED, displayId, 0)); 2947 } 2948 2949 @Override 2950 public void onDisplayChanged(int displayId) { 2951 Slog.v(TAG, "Display changed displayId=" + displayId); 2952 mHandler.sendMessage(mHandler.obtainMessage(HANDLE_DISPLAY_CHANGED, displayId, 0)); 2953 } 2954 2955 public void handleDisplayAddedLocked(int displayId) { 2956 boolean newDisplay; 2957 synchronized (mService) { 2958 newDisplay = mActivityDisplays.get(displayId) == null; 2959 if (newDisplay) { 2960 ActivityDisplay activityDisplay = new ActivityDisplay(displayId); 2961 mActivityDisplays.put(displayId, activityDisplay); 2962 } 2963 } 2964 if (newDisplay) { 2965 mWindowManager.onDisplayAdded(displayId); 2966 } 2967 } 2968 2969 public void handleDisplayRemovedLocked(int displayId) { 2970 synchronized (mService) { 2971 ActivityDisplay activityDisplay = mActivityDisplays.get(displayId); 2972 if (activityDisplay != null) { 2973 ArrayList<ActivityStack> stacks = activityDisplay.mStacks; 2974 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 2975 stacks.get(stackNdx).mActivityContainer.detachLocked(); 2976 } 2977 mActivityDisplays.remove(displayId); 2978 } 2979 } 2980 mWindowManager.onDisplayRemoved(displayId); 2981 } 2982 2983 public void handleDisplayChangedLocked(int displayId) { 2984 synchronized (mService) { 2985 ActivityDisplay activityDisplay = mActivityDisplays.get(displayId); 2986 if (activityDisplay != null) { 2987 // TODO: Update the bounds. 2988 } 2989 } 2990 mWindowManager.onDisplayChanged(displayId); 2991 } 2992 2993 StackInfo getStackInfo(ActivityStack stack) { 2994 StackInfo info = new StackInfo(); 2995 mWindowManager.getStackBounds(stack.mStackId, info.bounds); 2996 info.displayId = Display.DEFAULT_DISPLAY; 2997 info.stackId = stack.mStackId; 2998 2999 ArrayList<TaskRecord> tasks = stack.getAllTasks(); 3000 final int numTasks = tasks.size(); 3001 int[] taskIds = new int[numTasks]; 3002 String[] taskNames = new String[numTasks]; 3003 for (int i = 0; i < numTasks; ++i) { 3004 final TaskRecord task = tasks.get(i); 3005 taskIds[i] = task.taskId; 3006 taskNames[i] = task.origActivity != null ? task.origActivity.flattenToString() 3007 : task.realActivity != null ? task.realActivity.flattenToString() 3008 : task.getTopActivity() != null ? task.getTopActivity().packageName 3009 : "unknown"; 3010 } 3011 info.taskIds = taskIds; 3012 info.taskNames = taskNames; 3013 return info; 3014 } 3015 3016 StackInfo getStackInfoLocked(int stackId) { 3017 ActivityStack stack = getStack(stackId); 3018 if (stack != null) { 3019 return getStackInfo(stack); 3020 } 3021 return null; 3022 } 3023 3024 ArrayList<StackInfo> getAllStackInfosLocked() { 3025 ArrayList<StackInfo> list = new ArrayList<StackInfo>(); 3026 for (int displayNdx = 0; displayNdx < mActivityDisplays.size(); ++displayNdx) { 3027 ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; 3028 for (int ndx = stacks.size() - 1; ndx >= 0; --ndx) { 3029 list.add(getStackInfo(stacks.get(ndx))); 3030 } 3031 } 3032 return list; 3033 } 3034 3035 void showLockTaskToast() { 3036 mLockTaskNotify.showToast(mLockTaskIsLocked); 3037 } 3038 3039 void setLockTaskModeLocked(TaskRecord task, boolean isLocked) { 3040 if (task == null) { 3041 // Take out of lock task mode if necessary 3042 if (mLockTaskModeTask != null) { 3043 final Message lockTaskMsg = Message.obtain(); 3044 lockTaskMsg.arg1 = mLockTaskModeTask.userId; 3045 lockTaskMsg.what = LOCK_TASK_END_MSG; 3046 mLockTaskModeTask = null; 3047 mHandler.sendMessage(lockTaskMsg); 3048 } 3049 return; 3050 } 3051 if (isLockTaskModeViolation(task)) { 3052 Slog.e(TAG, "setLockTaskMode: Attempt to start a second Lock Task Mode task."); 3053 return; 3054 } 3055 mLockTaskModeTask = task; 3056 findTaskToMoveToFrontLocked(task, 0, null); 3057 resumeTopActivitiesLocked(); 3058 3059 final Message lockTaskMsg = Message.obtain(); 3060 lockTaskMsg.obj = mLockTaskModeTask.intent.getComponent().getPackageName(); 3061 lockTaskMsg.arg1 = mLockTaskModeTask.userId; 3062 lockTaskMsg.what = LOCK_TASK_START_MSG; 3063 lockTaskMsg.arg2 = !isLocked ? 1 : 0; 3064 mHandler.sendMessage(lockTaskMsg); 3065 } 3066 3067 boolean isLockTaskModeViolation(TaskRecord task) { 3068 return mLockTaskModeTask != null && mLockTaskModeTask != task; 3069 } 3070 3071 void endLockTaskModeIfTaskEnding(TaskRecord task) { 3072 if (mLockTaskModeTask != null && mLockTaskModeTask == task) { 3073 mLockTaskModeTask = null; 3074 } 3075 } 3076 3077 boolean isInLockTaskMode() { 3078 return mLockTaskModeTask != null; 3079 } 3080 3081 private final class ActivityStackSupervisorHandler extends Handler { 3082 3083 public ActivityStackSupervisorHandler(Looper looper) { 3084 super(looper); 3085 } 3086 3087 void activityIdleInternal(ActivityRecord r) { 3088 synchronized (mService) { 3089 activityIdleInternalLocked(r != null ? r.appToken : null, true, null); 3090 } 3091 } 3092 3093 @Override 3094 public void handleMessage(Message msg) { 3095 switch (msg.what) { 3096 case IDLE_TIMEOUT_MSG: { 3097 if (DEBUG_IDLE) Slog.d(TAG, "handleMessage: IDLE_TIMEOUT_MSG: r=" + msg.obj); 3098 if (mService.mDidDexOpt) { 3099 mService.mDidDexOpt = false; 3100 Message nmsg = mHandler.obtainMessage(IDLE_TIMEOUT_MSG); 3101 nmsg.obj = msg.obj; 3102 mHandler.sendMessageDelayed(nmsg, IDLE_TIMEOUT); 3103 return; 3104 } 3105 // We don't at this point know if the activity is fullscreen, 3106 // so we need to be conservative and assume it isn't. 3107 activityIdleInternal((ActivityRecord)msg.obj); 3108 } break; 3109 case IDLE_NOW_MSG: { 3110 if (DEBUG_IDLE) Slog.d(TAG, "handleMessage: IDLE_NOW_MSG: r=" + msg.obj); 3111 activityIdleInternal((ActivityRecord)msg.obj); 3112 } break; 3113 case RESUME_TOP_ACTIVITY_MSG: { 3114 synchronized (mService) { 3115 resumeTopActivitiesLocked(); 3116 } 3117 } break; 3118 case SLEEP_TIMEOUT_MSG: { 3119 synchronized (mService) { 3120 if (mService.isSleepingOrShuttingDown()) { 3121 Slog.w(TAG, "Sleep timeout! Sleeping now."); 3122 mSleepTimeout = true; 3123 checkReadyForSleepLocked(); 3124 } 3125 } 3126 } break; 3127 case LAUNCH_TIMEOUT_MSG: { 3128 if (mService.mDidDexOpt) { 3129 mService.mDidDexOpt = false; 3130 mHandler.sendEmptyMessageDelayed(LAUNCH_TIMEOUT_MSG, LAUNCH_TIMEOUT); 3131 return; 3132 } 3133 synchronized (mService) { 3134 if (mLaunchingActivity.isHeld()) { 3135 Slog.w(TAG, "Launch timeout has expired, giving up wake lock!"); 3136 if (VALIDATE_WAKE_LOCK_CALLER 3137 && Binder.getCallingUid() != Process.myUid()) { 3138 throw new IllegalStateException("Calling must be system uid"); 3139 } 3140 mLaunchingActivity.release(); 3141 } 3142 } 3143 } break; 3144 case HANDLE_DISPLAY_ADDED: { 3145 handleDisplayAddedLocked(msg.arg1); 3146 } break; 3147 case HANDLE_DISPLAY_CHANGED: { 3148 handleDisplayChangedLocked(msg.arg1); 3149 } break; 3150 case HANDLE_DISPLAY_REMOVED: { 3151 handleDisplayRemovedLocked(msg.arg1); 3152 } break; 3153 case CONTAINER_CALLBACK_VISIBILITY: { 3154 final ActivityContainer container = (ActivityContainer) msg.obj; 3155 final IActivityContainerCallback callback = container.mCallback; 3156 if (callback != null) { 3157 try { 3158 callback.setVisible(container.asBinder(), msg.arg1 == 1); 3159 } catch (RemoteException e) { 3160 } 3161 } 3162 } break; 3163 case LOCK_TASK_START_MSG: { 3164 // When lock task starts, we disable the status bars. 3165 try { 3166 if (mLockTaskNotify == null) { 3167 mLockTaskNotify = new LockTaskNotify(mService.mContext); 3168 } 3169 mLockTaskNotify.show(true); 3170 if (getStatusBarService() != null) { 3171 int flags = 3172 StatusBarManager.DISABLE_MASK ^ StatusBarManager.DISABLE_BACK; 3173 if (msg.arg2 != 0) { 3174 flags ^= StatusBarManager.DISABLE_HOME 3175 | StatusBarManager.DISABLE_RECENT; 3176 } 3177 getStatusBarService().disable(flags, mToken, 3178 mService.mContext.getPackageName()); 3179 } 3180 mWindowManager.disableKeyguard(mToken, LOCK_TASK_TAG); 3181 if (getDevicePolicyManager() != null) { 3182 getDevicePolicyManager().notifyLockTaskModeChanged(true, 3183 (String)msg.obj, msg.arg1); 3184 } 3185 } catch (RemoteException ex) { 3186 throw new RuntimeException(ex); 3187 } 3188 } break; 3189 case LOCK_TASK_END_MSG: { 3190 // When lock task ends, we enable the status bars. 3191 try { 3192 if (getStatusBarService() != null) { 3193 getStatusBarService().disable(StatusBarManager.DISABLE_NONE, mToken, 3194 mService.mContext.getPackageName()); 3195 } 3196 mWindowManager.reenableKeyguard(mToken); 3197 if (getDevicePolicyManager() != null) { 3198 getDevicePolicyManager().notifyLockTaskModeChanged(false, null, 3199 msg.arg1); 3200 } 3201 if (mLockTaskNotify == null) { 3202 mLockTaskNotify = new LockTaskNotify(mService.mContext); 3203 } 3204 mLockTaskNotify.show(false); 3205 try { 3206 boolean shouldLockKeyguard = Settings.System.getInt( 3207 mService.mContext.getContentResolver(), 3208 Settings.System.LOCK_TO_APP_EXIT_LOCKED) != 0; 3209 if (shouldLockKeyguard) { 3210 mWindowManager.lockNow(null); 3211 } 3212 } catch (SettingNotFoundException e) { 3213 // No setting, don't lock. 3214 } 3215 } catch (RemoteException ex) { 3216 throw new RuntimeException(ex); 3217 } 3218 } break; 3219 case CONTAINER_CALLBACK_TASK_LIST_EMPTY: { 3220 final ActivityContainer container = (ActivityContainer) msg.obj; 3221 final IActivityContainerCallback callback = container.mCallback; 3222 if (callback != null) { 3223 try { 3224 callback.onAllActivitiesComplete(container.asBinder()); 3225 } catch (RemoteException e) { 3226 } 3227 } 3228 } break; 3229 case CONTAINER_TASK_LIST_EMPTY_TIMEOUT: { 3230 synchronized (mService) { 3231 Slog.w(TAG, "Timeout waiting for all activities in task to finish. " + 3232 msg.obj); 3233 ((ActivityContainer) msg.obj).onTaskListEmptyLocked(); 3234 } 3235 } break; 3236 } 3237 } 3238 } 3239 3240 class ActivityContainer extends android.app.IActivityContainer.Stub { 3241 final static int FORCE_NEW_TASK_FLAGS = Intent.FLAG_ACTIVITY_NEW_TASK | 3242 Intent.FLAG_ACTIVITY_MULTIPLE_TASK | Intent.FLAG_ACTIVITY_NO_ANIMATION; 3243 final int mStackId; 3244 IActivityContainerCallback mCallback = null; 3245 final ActivityStack mStack; 3246 ActivityRecord mParentActivity = null; 3247 String mIdString; 3248 3249 boolean mVisible = true; 3250 3251 /** Display this ActivityStack is currently on. Null if not attached to a Display. */ 3252 ActivityDisplay mActivityDisplay; 3253 3254 final static int CONTAINER_STATE_HAS_SURFACE = 0; 3255 final static int CONTAINER_STATE_NO_SURFACE = 1; 3256 final static int CONTAINER_STATE_FINISHING = 2; 3257 int mContainerState = CONTAINER_STATE_HAS_SURFACE; 3258 3259 ActivityContainer(int stackId) { 3260 synchronized (mService) { 3261 mStackId = stackId; 3262 mStack = new ActivityStack(this); 3263 mIdString = "ActivtyContainer{" + mStackId + "}"; 3264 if (DEBUG_STACK) Slog.d(TAG, "Creating " + this); 3265 } 3266 } 3267 3268 void attachToDisplayLocked(ActivityDisplay activityDisplay) { 3269 if (DEBUG_STACK) Slog.d(TAG, "attachToDisplayLocked: " + this 3270 + " to display=" + activityDisplay); 3271 mActivityDisplay = activityDisplay; 3272 mStack.mDisplayId = activityDisplay.mDisplayId; 3273 mStack.mStacks = activityDisplay.mStacks; 3274 3275 activityDisplay.attachActivities(mStack); 3276 mWindowManager.attachStack(mStackId, activityDisplay.mDisplayId); 3277 } 3278 3279 @Override 3280 public void attachToDisplay(int displayId) { 3281 synchronized (mService) { 3282 ActivityDisplay activityDisplay = mActivityDisplays.get(displayId); 3283 if (activityDisplay == null) { 3284 return; 3285 } 3286 attachToDisplayLocked(activityDisplay); 3287 } 3288 } 3289 3290 @Override 3291 public int getDisplayId() { 3292 synchronized (mService) { 3293 if (mActivityDisplay != null) { 3294 return mActivityDisplay.mDisplayId; 3295 } 3296 } 3297 return -1; 3298 } 3299 3300 @Override 3301 public boolean injectEvent(InputEvent event) { 3302 final long origId = Binder.clearCallingIdentity(); 3303 try { 3304 synchronized (mService) { 3305 if (mActivityDisplay != null) { 3306 return mInputManagerInternal.injectInputEvent(event, 3307 mActivityDisplay.mDisplayId, 3308 InputManager.INJECT_INPUT_EVENT_MODE_ASYNC); 3309 } 3310 } 3311 return false; 3312 } finally { 3313 Binder.restoreCallingIdentity(origId); 3314 } 3315 } 3316 3317 @Override 3318 public void release() { 3319 synchronized (mService) { 3320 if (mContainerState == CONTAINER_STATE_FINISHING) { 3321 return; 3322 } 3323 mContainerState = CONTAINER_STATE_FINISHING; 3324 3325 final Message msg = 3326 mHandler.obtainMessage(CONTAINER_TASK_LIST_EMPTY_TIMEOUT, this); 3327 mHandler.sendMessageDelayed(msg, 1000); 3328 3329 long origId = Binder.clearCallingIdentity(); 3330 try { 3331 mStack.finishAllActivitiesLocked(); 3332 } finally { 3333 Binder.restoreCallingIdentity(origId); 3334 } 3335 } 3336 } 3337 3338 private void detachLocked() { 3339 if (DEBUG_STACK) Slog.d(TAG, "detachLocked: " + this + " from display=" 3340 + mActivityDisplay + " Callers=" + Debug.getCallers(2)); 3341 if (mActivityDisplay != null) { 3342 mActivityDisplay.detachActivitiesLocked(mStack); 3343 mActivityDisplay = null; 3344 mStack.mDisplayId = -1; 3345 mStack.mStacks = null; 3346 mWindowManager.detachStack(mStackId); 3347 } 3348 } 3349 3350 @Override 3351 public final int startActivity(Intent intent) { 3352 mService.enforceNotIsolatedCaller("ActivityContainer.startActivity"); 3353 int userId = mService.handleIncomingUser(Binder.getCallingPid(), 3354 Binder.getCallingUid(), mCurrentUser, false, true, "ActivityContainer", null); 3355 // TODO: Switch to user app stacks here. 3356 intent.addFlags(FORCE_NEW_TASK_FLAGS); 3357 String mimeType = intent.getType(); 3358 if (mimeType == null && intent.getData() != null 3359 && "content".equals(intent.getData().getScheme())) { 3360 mimeType = mService.getProviderMimeType(intent.getData(), userId); 3361 } 3362 return startActivityMayWait(null, -1, null, intent, mimeType, null, null, null, null, 0, 0, null, 3363 null, null, null, null, userId, this); 3364 } 3365 3366 @Override 3367 public final int startActivityIntentSender(IIntentSender intentSender) { 3368 mService.enforceNotIsolatedCaller("ActivityContainer.startActivityIntentSender"); 3369 3370 if (!(intentSender instanceof PendingIntentRecord)) { 3371 throw new IllegalArgumentException("Bad PendingIntent object"); 3372 } 3373 3374 return ((PendingIntentRecord)intentSender).sendInner(0, null, null, null, null, null, 3375 null, 0, FORCE_NEW_TASK_FLAGS, FORCE_NEW_TASK_FLAGS, null, this); 3376 } 3377 3378 private void checkEmbeddedAllowedInner(Intent intent, String resolvedType) { 3379 int userId = mService.handleIncomingUser(Binder.getCallingPid(), 3380 Binder.getCallingUid(), mCurrentUser, false, true, "ActivityContainer", null); 3381 if (resolvedType == null) { 3382 resolvedType = intent.getType(); 3383 if (resolvedType == null && intent.getData() != null 3384 && "content".equals(intent.getData().getScheme())) { 3385 resolvedType = mService.getProviderMimeType(intent.getData(), userId); 3386 } 3387 } 3388 ActivityInfo aInfo = resolveActivity(intent, resolvedType, 0, null, null, userId); 3389 if (aInfo != null && (aInfo.flags & ActivityInfo.FLAG_ALLOW_EMBEDDED) == 0) { 3390 throw new SecurityException( 3391 "Attempt to embed activity that has not set allowEmbedded=\"true\""); 3392 } 3393 } 3394 3395 /** Throw a SecurityException if allowEmbedded is not true */ 3396 @Override 3397 public final void checkEmbeddedAllowed(Intent intent) { 3398 checkEmbeddedAllowedInner(intent, null); 3399 } 3400 3401 /** Throw a SecurityException if allowEmbedded is not true */ 3402 @Override 3403 public final void checkEmbeddedAllowedIntentSender(IIntentSender intentSender) { 3404 if (!(intentSender instanceof PendingIntentRecord)) { 3405 throw new IllegalArgumentException("Bad PendingIntent object"); 3406 } 3407 PendingIntentRecord pendingIntent = (PendingIntentRecord) intentSender; 3408 checkEmbeddedAllowedInner(pendingIntent.key.requestIntent, 3409 pendingIntent.key.requestResolvedType); 3410 } 3411 3412 @Override 3413 public IBinder asBinder() { 3414 return this; 3415 } 3416 3417 @Override 3418 public void setSurface(Surface surface, int width, int height, int density) { 3419 mService.enforceNotIsolatedCaller("ActivityContainer.attachToSurface"); 3420 } 3421 3422 ActivityStackSupervisor getOuter() { 3423 return ActivityStackSupervisor.this; 3424 } 3425 3426 boolean isAttachedLocked() { 3427 return mActivityDisplay != null; 3428 } 3429 3430 void getBounds(Point outBounds) { 3431 synchronized (mService) { 3432 if (mActivityDisplay != null) { 3433 mActivityDisplay.getBounds(outBounds); 3434 } else { 3435 outBounds.set(0, 0); 3436 } 3437 } 3438 } 3439 3440 // TODO: Make sure every change to ActivityRecord.visible results in a call to this. 3441 void setVisible(boolean visible) { 3442 if (mVisible != visible) { 3443 mVisible = visible; 3444 if (mCallback != null) { 3445 mHandler.obtainMessage(CONTAINER_CALLBACK_VISIBILITY, visible ? 1 : 0, 3446 0 /* unused */, this).sendToTarget(); 3447 } 3448 } 3449 } 3450 3451 void setDrawn() { 3452 } 3453 3454 // You can always start a new task on a regular ActivityStack. 3455 boolean isEligibleForNewTasks() { 3456 return true; 3457 } 3458 3459 void onTaskListEmptyLocked() { 3460 mHandler.removeMessages(CONTAINER_TASK_LIST_EMPTY_TIMEOUT, this); 3461 if (!mStack.isHomeStack()) { 3462 detachLocked(); 3463 deleteActivityContainer(this); 3464 } 3465 mHandler.obtainMessage(CONTAINER_CALLBACK_TASK_LIST_EMPTY, this).sendToTarget(); 3466 } 3467 3468 @Override 3469 public String toString() { 3470 return mIdString + (mActivityDisplay == null ? "N" : "A"); 3471 } 3472 } 3473 3474 private class VirtualActivityContainer extends ActivityContainer { 3475 Surface mSurface; 3476 boolean mDrawn = false; 3477 3478 VirtualActivityContainer(ActivityRecord parent, IActivityContainerCallback callback) { 3479 super(getNextStackId()); 3480 mParentActivity = parent; 3481 mCallback = callback; 3482 mContainerState = CONTAINER_STATE_NO_SURFACE; 3483 mIdString = "VirtualActivityContainer{" + mStackId + ", parent=" + mParentActivity + "}"; 3484 } 3485 3486 @Override 3487 public void setSurface(Surface surface, int width, int height, int density) { 3488 super.setSurface(surface, width, height, density); 3489 3490 synchronized (mService) { 3491 final long origId = Binder.clearCallingIdentity(); 3492 try { 3493 setSurfaceLocked(surface, width, height, density); 3494 } finally { 3495 Binder.restoreCallingIdentity(origId); 3496 } 3497 } 3498 } 3499 3500 private void setSurfaceLocked(Surface surface, int width, int height, int density) { 3501 if (mContainerState == CONTAINER_STATE_FINISHING) { 3502 return; 3503 } 3504 VirtualActivityDisplay virtualActivityDisplay = 3505 (VirtualActivityDisplay) mActivityDisplay; 3506 if (virtualActivityDisplay == null) { 3507 virtualActivityDisplay = 3508 new VirtualActivityDisplay(width, height, density); 3509 mActivityDisplay = virtualActivityDisplay; 3510 mActivityDisplays.put(virtualActivityDisplay.mDisplayId, virtualActivityDisplay); 3511 attachToDisplayLocked(virtualActivityDisplay); 3512 } 3513 3514 if (mSurface != null) { 3515 mSurface.release(); 3516 } 3517 3518 mSurface = surface; 3519 if (surface != null) { 3520 mStack.resumeTopActivityLocked(null); 3521 } else { 3522 mContainerState = CONTAINER_STATE_NO_SURFACE; 3523 ((VirtualActivityDisplay) mActivityDisplay).setSurface(null); 3524 if (mStack.mPausingActivity == null && mStack.mResumedActivity != null) { 3525 mStack.startPausingLocked(false, true); 3526 } 3527 } 3528 3529 setSurfaceIfReadyLocked(); 3530 3531 if (DEBUG_STACK) Slog.d(TAG, "setSurface: " + this + " to display=" 3532 + virtualActivityDisplay); 3533 } 3534 3535 @Override 3536 boolean isAttachedLocked() { 3537 return mSurface != null && super.isAttachedLocked(); 3538 } 3539 3540 @Override 3541 void setDrawn() { 3542 synchronized (mService) { 3543 mDrawn = true; 3544 setSurfaceIfReadyLocked(); 3545 } 3546 } 3547 3548 // Never start a new task on an ActivityView if it isn't explicitly specified. 3549 @Override 3550 boolean isEligibleForNewTasks() { 3551 return false; 3552 } 3553 3554 private void setSurfaceIfReadyLocked() { 3555 if (DEBUG_STACK) Slog.v(TAG, "setSurfaceIfReadyLocked: mDrawn=" + mDrawn + 3556 " mContainerState=" + mContainerState + " mSurface=" + mSurface); 3557 if (mDrawn && mSurface != null && mContainerState == CONTAINER_STATE_NO_SURFACE) { 3558 ((VirtualActivityDisplay) mActivityDisplay).setSurface(mSurface); 3559 mContainerState = CONTAINER_STATE_HAS_SURFACE; 3560 } 3561 } 3562 } 3563 3564 /** Exactly one of these classes per Display in the system. Capable of holding zero or more 3565 * attached {@link ActivityStack}s */ 3566 class ActivityDisplay { 3567 /** Actual Display this object tracks. */ 3568 int mDisplayId; 3569 Display mDisplay; 3570 DisplayInfo mDisplayInfo = new DisplayInfo(); 3571 3572 /** All of the stacks on this display. Order matters, topmost stack is in front of all other 3573 * stacks, bottommost behind. Accessed directly by ActivityManager package classes */ 3574 final ArrayList<ActivityStack> mStacks = new ArrayList<ActivityStack>(); 3575 3576 ActivityDisplay() { 3577 } 3578 3579 ActivityDisplay(int displayId) { 3580 init(mDisplayManager.getDisplay(displayId)); 3581 } 3582 3583 void init(Display display) { 3584 mDisplay = display; 3585 mDisplayId = display.getDisplayId(); 3586 mDisplay.getDisplayInfo(mDisplayInfo); 3587 } 3588 3589 void attachActivities(ActivityStack stack) { 3590 if (DEBUG_STACK) Slog.v(TAG, "attachActivities: attaching " + stack + " to displayId=" 3591 + mDisplayId); 3592 mStacks.add(stack); 3593 } 3594 3595 void detachActivitiesLocked(ActivityStack stack) { 3596 if (DEBUG_STACK) Slog.v(TAG, "detachActivitiesLocked: detaching " + stack 3597 + " from displayId=" + mDisplayId); 3598 mStacks.remove(stack); 3599 } 3600 3601 void getBounds(Point bounds) { 3602 mDisplay.getDisplayInfo(mDisplayInfo); 3603 bounds.x = mDisplayInfo.appWidth; 3604 bounds.y = mDisplayInfo.appHeight; 3605 } 3606 3607 @Override 3608 public String toString() { 3609 return "ActivityDisplay={" + mDisplayId + " numStacks=" + mStacks.size() + "}"; 3610 } 3611 } 3612 3613 class VirtualActivityDisplay extends ActivityDisplay { 3614 VirtualDisplay mVirtualDisplay; 3615 3616 VirtualActivityDisplay(int width, int height, int density) { 3617 DisplayManagerGlobal dm = DisplayManagerGlobal.getInstance(); 3618 mVirtualDisplay = dm.createVirtualDisplay(mService.mContext, VIRTUAL_DISPLAY_BASE_NAME, 3619 width, height, density, null, DisplayManager.VIRTUAL_DISPLAY_FLAG_PUBLIC | 3620 DisplayManager.VIRTUAL_DISPLAY_FLAG_OWN_CONTENT_ONLY); 3621 3622 init(mVirtualDisplay.getDisplay()); 3623 3624 mWindowManager.handleDisplayAdded(mDisplayId); 3625 } 3626 3627 void setSurface(Surface surface) { 3628 if (mVirtualDisplay != null) { 3629 mVirtualDisplay.setSurface(surface); 3630 } 3631 } 3632 3633 @Override 3634 void detachActivitiesLocked(ActivityStack stack) { 3635 super.detachActivitiesLocked(stack); 3636 if (mVirtualDisplay != null) { 3637 mVirtualDisplay.release(); 3638 mVirtualDisplay = null; 3639 } 3640 } 3641 3642 @Override 3643 public String toString() { 3644 return "VirtualActivityDisplay={" + mDisplayId + "}"; 3645 } 3646 } 3647 3648 private boolean isLeanbackOnlyDevice() { 3649 boolean onLeanbackOnly = false; 3650 try { 3651 onLeanbackOnly = AppGlobals.getPackageManager().hasSystemFeature( 3652 PackageManager.FEATURE_LEANBACK_ONLY); 3653 } catch (RemoteException e) { 3654 // noop 3655 } 3656 3657 return onLeanbackOnly; 3658 } 3659} 3660