Moved Activity management out of ActivityManager to WindowManager (37/n)
What could go wrong ;)
Note that ATMS and all other activity management files are still under
the AMS lock. We will be changing them soon to use the WMS lock, but
till then it is important to take care not to use the WMS lock for
activities stuff and AMS lock for window stuff.
Test: Existing tests pass
Bug: 80414790
Change-Id: I69f5a6e40ad892557a425e1f34be987507102136
diff --git a/services/core/java/com/android/server/wm/ActivityDisplay.java b/services/core/java/com/android/server/wm/ActivityDisplay.java
new file mode 100644
index 0000000..f8c4ca2
--- /dev/null
+++ b/services/core/java/com/android/server/wm/ActivityDisplay.java
@@ -0,0 +1,1304 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.server.wm;
+
+import static android.app.ActivityTaskManager.INVALID_STACK_ID;
+import static android.app.WindowConfiguration.ACTIVITY_TYPE_HOME;
+import static android.app.WindowConfiguration.ACTIVITY_TYPE_RECENTS;
+import static android.app.WindowConfiguration.ACTIVITY_TYPE_STANDARD;
+import static android.app.WindowConfiguration.ACTIVITY_TYPE_UNDEFINED;
+import static android.app.WindowConfiguration.WINDOWING_MODE_FREEFORM;
+import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN;
+import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN_OR_SPLIT_SCREEN_SECONDARY;
+import static android.app.WindowConfiguration.WINDOWING_MODE_PINNED;
+import static android.app.WindowConfiguration.WINDOWING_MODE_SPLIT_SCREEN_PRIMARY;
+import static android.app.WindowConfiguration.WINDOWING_MODE_SPLIT_SCREEN_SECONDARY;
+import static android.app.WindowConfiguration.WINDOWING_MODE_UNDEFINED;
+import static android.view.Display.DEFAULT_DISPLAY;
+import static android.view.Display.FLAG_PRIVATE;
+import static android.view.Display.REMOVE_MODE_DESTROY_CONTENT;
+
+import static com.android.server.am.ActivityDisplayProto.CONFIGURATION_CONTAINER;
+import static com.android.server.am.ActivityDisplayProto.FOCUSED_STACK_ID;
+import static com.android.server.am.ActivityDisplayProto.ID;
+import static com.android.server.am.ActivityDisplayProto.RESUMED_ACTIVITY;
+import static com.android.server.am.ActivityDisplayProto.STACKS;
+import static com.android.server.wm.ActivityStack.ActivityState.RESUMED;
+import static com.android.server.wm.ActivityStackSupervisor.FindTaskResult;
+import static com.android.server.wm.ActivityStackSupervisor.TAG_STATES;
+import static com.android.server.wm.ActivityStackSupervisor.TAG_TASKS;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_STACK;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_STATES;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_TASKS;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_STACK;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_ATM;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_WITH_CLASS_NAME;
+
+import android.annotation.Nullable;
+import android.app.ActivityOptions;
+import android.app.WindowConfiguration;
+import android.graphics.Point;
+import android.os.UserHandle;
+import android.util.IntArray;
+import android.util.Slog;
+import android.util.proto.ProtoOutputStream;
+import android.view.Display;
+
+import com.android.internal.annotations.VisibleForTesting;
+import com.android.server.am.EventLogTags;
+
+import java.io.PrintWriter;
+import java.util.ArrayList;
+
+/**
+ * Exactly one of these classes per Display in the system. Capable of holding zero or more
+ * attached {@link ActivityStack}s.
+ */
+class ActivityDisplay extends ConfigurationContainer<ActivityStack>
+ implements WindowContainerListener {
+ private static final String TAG = TAG_WITH_CLASS_NAME ? "ActivityDisplay" : TAG_ATM;
+ private static final String TAG_STACK = TAG + POSTFIX_STACK;
+
+ static final int POSITION_TOP = Integer.MAX_VALUE;
+ static final int POSITION_BOTTOM = Integer.MIN_VALUE;
+
+
+ /**
+ * Counter for next free stack ID to use for dynamic activity stacks. Unique across displays.
+ */
+ private static int sNextFreeStackId = 0;
+
+ private ActivityStackSupervisor mSupervisor;
+ /** Actual Display this object tracks. */
+ int mDisplayId;
+ Display mDisplay;
+
+ /**
+ * All of the stacks on this display. Order matters, topmost stack is in front of all other
+ * stacks, bottommost behind. Accessed directly by ActivityManager package classes. Any calls
+ * changing the list should also call {@link #onStackOrderChanged()}.
+ */
+ private final ArrayList<ActivityStack> mStacks = new ArrayList<>();
+ private ArrayList<OnStackOrderChangedListener> mStackOrderChangedCallbacks = new ArrayList<>();
+
+ /** Array of all UIDs that are present on the display. */
+ private IntArray mDisplayAccessUIDs = new IntArray();
+
+ /** All tokens used to put activities on this stack to sleep (including mOffToken) */
+ final ArrayList<ActivityTaskManagerInternal.SleepToken> mAllSleepTokens = new ArrayList<>();
+ /** The token acquired by ActivityStackSupervisor to put stacks on the display to sleep */
+ ActivityTaskManagerInternal.SleepToken mOffToken;
+
+ private boolean mSleeping;
+
+ /**
+ * The display is removed from the system and we are just waiting for all activities on it to be
+ * finished before removing this object.
+ */
+ private boolean mRemoved;
+
+ /**
+ * A focusable stack that is purposely to be positioned at the top. Although the stack may not
+ * have the topmost index, it is used as a preferred candidate to prevent being unable to resume
+ * target stack properly when there are other focusable always-on-top stacks.
+ */
+ private ActivityStack mPreferredTopFocusableStack;
+
+ /**
+ * If this is the same as {@link #getFocusedStack} then the activity on the top of the focused
+ * stack has been resumed. If stacks are changing position this will hold the old stack until
+ * the new stack becomes resumed after which it will be set to current focused stack.
+ */
+ private ActivityStack mLastFocusedStack;
+
+ // Cached reference to some special stacks we tend to get a lot so we don't need to loop
+ // through the list to find them.
+ private ActivityStack mHomeStack = null;
+ private ActivityStack mRecentsStack = null;
+ private ActivityStack mPinnedStack = null;
+ private ActivityStack mSplitScreenPrimaryStack = null;
+
+ // Used in updating the display size
+ private Point mTmpDisplaySize = new Point();
+
+ private DisplayWindowController mWindowContainerController;
+
+ private final FindTaskResult mTmpFindTaskResult = new FindTaskResult();
+
+ ActivityDisplay(ActivityStackSupervisor supervisor, Display display) {
+ mSupervisor = supervisor;
+ mDisplayId = display.getDisplayId();
+ mDisplay = display;
+ mWindowContainerController = createWindowContainerController();
+ updateBounds();
+ }
+
+ protected DisplayWindowController createWindowContainerController() {
+ return new DisplayWindowController(mDisplay, this);
+ }
+
+ DisplayWindowController getWindowContainerController() {
+ return mWindowContainerController;
+ }
+
+ void updateBounds() {
+ mDisplay.getSize(mTmpDisplaySize);
+ setBounds(0, 0, mTmpDisplaySize.x, mTmpDisplaySize.y);
+ }
+
+ void onDisplayChanged() {
+ // The window policy is responsible for stopping activities on the default display.
+ final int displayId = mDisplay.getDisplayId();
+ if (displayId != DEFAULT_DISPLAY) {
+ final int displayState = mDisplay.getState();
+ if (displayState == Display.STATE_OFF && mOffToken == null) {
+ mOffToken = mSupervisor.mService.acquireSleepToken("Display-off", displayId);
+ } else if (displayState == Display.STATE_ON && mOffToken != null) {
+ mOffToken.release();
+ mOffToken = null;
+ }
+ }
+
+ updateBounds();
+ mWindowContainerController.onDisplayChanged();
+ }
+
+ void addChild(ActivityStack stack, int position) {
+ if (position == POSITION_BOTTOM) {
+ position = 0;
+ } else if (position == POSITION_TOP) {
+ position = mStacks.size();
+ }
+ if (DEBUG_STACK) Slog.v(TAG_STACK, "addChild: attaching " + stack
+ + " to displayId=" + mDisplayId + " position=" + position);
+ addStackReferenceIfNeeded(stack);
+ positionChildAt(stack, position);
+ mSupervisor.mService.updateSleepIfNeededLocked();
+ }
+
+ void removeChild(ActivityStack stack) {
+ if (DEBUG_STACK) Slog.v(TAG_STACK, "removeChild: detaching " + stack
+ + " from displayId=" + mDisplayId);
+ mStacks.remove(stack);
+ if (mPreferredTopFocusableStack == stack) {
+ mPreferredTopFocusableStack = null;
+ }
+ removeStackReferenceIfNeeded(stack);
+ releaseSelfIfNeeded();
+ mSupervisor.mService.updateSleepIfNeededLocked();
+ onStackOrderChanged();
+ }
+
+ void positionChildAtTop(ActivityStack stack, boolean includingParents) {
+ positionChildAtTop(stack, includingParents, null /* updateLastFocusedStackReason */);
+ }
+
+ void positionChildAtTop(ActivityStack stack, boolean includingParents,
+ String updateLastFocusedStackReason) {
+ positionChildAt(stack, mStacks.size(), includingParents, updateLastFocusedStackReason);
+ }
+
+ void positionChildAtBottom(ActivityStack stack) {
+ positionChildAtBottom(stack, null /* updateLastFocusedStackReason */);
+ }
+
+ void positionChildAtBottom(ActivityStack stack, String updateLastFocusedStackReason) {
+ positionChildAt(stack, 0, false /* includingParents */, updateLastFocusedStackReason);
+ }
+
+ private void positionChildAt(ActivityStack stack, int position) {
+ positionChildAt(stack, position, false /* includingParents */,
+ null /* updateLastFocusedStackReason */);
+ }
+
+ private void positionChildAt(ActivityStack stack, int position, boolean includingParents,
+ String updateLastFocusedStackReason) {
+ // TODO: Keep in sync with WindowContainer.positionChildAt(), once we change that to adjust
+ // the position internally, also update the logic here
+ final ActivityStack prevFocusedStack = updateLastFocusedStackReason != null
+ ? getFocusedStack() : null;
+ final boolean wasContained = mStacks.remove(stack);
+ final int insertPosition = getTopInsertPosition(stack, position);
+ mStacks.add(insertPosition, stack);
+
+ // The insert position may be adjusted to non-top when there is always-on-top stack. Since
+ // the original position is preferred to be top, the stack should have higher priority when
+ // we are looking for top focusable stack. The condition {@code wasContained} restricts the
+ // preferred stack is set only when moving an existing stack to top instead of adding a new
+ // stack that may be too early (e.g. in the middle of launching or reparenting).
+ if (wasContained && position >= mStacks.size() - 1 && stack.isFocusableAndVisible()) {
+ mPreferredTopFocusableStack = stack;
+ } else if (mPreferredTopFocusableStack == stack) {
+ mPreferredTopFocusableStack = null;
+ }
+
+ if (updateLastFocusedStackReason != null) {
+ final ActivityStack currentFocusedStack = getFocusedStack();
+ if (currentFocusedStack != prevFocusedStack) {
+ mLastFocusedStack = prevFocusedStack;
+ EventLogTags.writeAmFocusedStack(mSupervisor.mCurrentUser, mDisplayId,
+ currentFocusedStack == null ? -1 : currentFocusedStack.getStackId(),
+ mLastFocusedStack == null ? -1 : mLastFocusedStack.getStackId(),
+ updateLastFocusedStackReason);
+ }
+ }
+
+ // Since positionChildAt() is called during the creation process of pinned stacks,
+ // ActivityStack#getWindowContainerController() can be null. In this special case,
+ // since DisplayContest#positionStackAt() is called in TaskStack#onConfigurationChanged(),
+ // we don't have to call WindowContainerController#positionChildAt() here.
+ if (stack.getWindowContainerController() != null) {
+ mWindowContainerController.positionChildAt(stack.getWindowContainerController(),
+ insertPosition, includingParents);
+ }
+ onStackOrderChanged();
+ }
+
+ private int getTopInsertPosition(ActivityStack stack, int candidatePosition) {
+ int position = mStacks.size();
+ if (stack.inPinnedWindowingMode()) {
+ // Stack in pinned windowing mode is z-ordered on-top of all other stacks so okay to
+ // just return the candidate position.
+ return Math.min(position, candidatePosition);
+ }
+ while (position > 0) {
+ final ActivityStack targetStack = mStacks.get(position - 1);
+ if (!targetStack.isAlwaysOnTop()) {
+ // We reached a stack that isn't always-on-top.
+ break;
+ }
+ if (stack.isAlwaysOnTop() && !targetStack.inPinnedWindowingMode()) {
+ // Always on-top non-pinned windowing mode stacks can go anywhere below pinned stack.
+ break;
+ }
+ position--;
+ }
+ return Math.min(position, candidatePosition);
+ }
+
+ <T extends ActivityStack> T getStack(int stackId) {
+ for (int i = mStacks.size() - 1; i >= 0; --i) {
+ final ActivityStack stack = mStacks.get(i);
+ if (stack.mStackId == stackId) {
+ return (T) stack;
+ }
+ }
+ return null;
+ }
+
+ /**
+ * @return the topmost stack on the display that is compatible with the input windowing mode and
+ * activity type. {@code null} means no compatible stack on the display.
+ * @see ConfigurationContainer#isCompatible(int, int)
+ */
+ <T extends ActivityStack> T getStack(int windowingMode, int activityType) {
+ if (activityType == ACTIVITY_TYPE_HOME) {
+ return (T) mHomeStack;
+ } else if (activityType == ACTIVITY_TYPE_RECENTS) {
+ return (T) mRecentsStack;
+ }
+ if (windowingMode == WINDOWING_MODE_PINNED) {
+ return (T) mPinnedStack;
+ } else if (windowingMode == WINDOWING_MODE_SPLIT_SCREEN_PRIMARY) {
+ return (T) mSplitScreenPrimaryStack;
+ }
+
+ for (int i = mStacks.size() - 1; i >= 0; --i) {
+ final ActivityStack stack = mStacks.get(i);
+ if (stack.isCompatible(windowingMode, activityType)) {
+ return (T) stack;
+ }
+ }
+ return null;
+ }
+
+ private boolean alwaysCreateStack(int windowingMode, int activityType) {
+ // Always create a stack for fullscreen, freeform, and split-screen-secondary windowing
+ // modes so that we can manage visual ordering and return types correctly.
+ return activityType == ACTIVITY_TYPE_STANDARD
+ && (windowingMode == WINDOWING_MODE_FULLSCREEN
+ || windowingMode == WINDOWING_MODE_FREEFORM
+ || windowingMode == WINDOWING_MODE_SPLIT_SCREEN_SECONDARY);
+ }
+
+ /**
+ * Returns an existing stack compatible with the windowing mode and activity type or creates one
+ * if a compatible stack doesn't exist.
+ * @see #getStack(int, int)
+ * @see #createStack(int, int, boolean)
+ */
+ <T extends ActivityStack> T getOrCreateStack(int windowingMode, int activityType,
+ boolean onTop) {
+ if (!alwaysCreateStack(windowingMode, activityType)) {
+ T stack = getStack(windowingMode, activityType);
+ if (stack != null) {
+ return stack;
+ }
+ }
+ return createStack(windowingMode, activityType, onTop);
+ }
+
+ /**
+ * Returns an existing stack compatible with the input params or creates one
+ * if a compatible stack doesn't exist.
+ * @see #getOrCreateStack(int, int, boolean)
+ */
+ <T extends ActivityStack> T getOrCreateStack(@Nullable ActivityRecord r,
+ @Nullable ActivityOptions options, @Nullable TaskRecord candidateTask, int activityType,
+ boolean onTop) {
+ // First preference is the windowing mode in the activity options if set.
+ int windowingMode = (options != null)
+ ? options.getLaunchWindowingMode() : WINDOWING_MODE_UNDEFINED;
+ // Validate that our desired windowingMode will work under the current conditions.
+ // UNDEFINED windowing mode is a valid result and means that the new stack will inherit
+ // it's display's windowing mode.
+ windowingMode = validateWindowingMode(windowingMode, r, candidateTask, activityType);
+ return getOrCreateStack(windowingMode, activityType, onTop);
+ }
+
+ @VisibleForTesting
+ int getNextStackId() {
+ return sNextFreeStackId++;
+ }
+
+ /**
+ * Creates a stack matching the input windowing mode and activity type on this display.
+ * @param windowingMode The windowing mode the stack should be created in. If
+ * {@link WindowConfiguration#WINDOWING_MODE_UNDEFINED} then the stack will
+ * inherit it's parent's windowing mode.
+ * @param activityType The activityType the stack should be created in. If
+ * {@link WindowConfiguration#ACTIVITY_TYPE_UNDEFINED} then the stack will
+ * be created in {@link WindowConfiguration#ACTIVITY_TYPE_STANDARD}.
+ * @param onTop If true the stack will be created at the top of the display, else at the bottom.
+ * @return The newly created stack.
+ */
+ <T extends ActivityStack> T createStack(int windowingMode, int activityType, boolean onTop) {
+
+ if (activityType == ACTIVITY_TYPE_UNDEFINED) {
+ // Can't have an undefined stack type yet...so re-map to standard. Anyone that wants
+ // anything else should be passing it in anyways...
+ activityType = ACTIVITY_TYPE_STANDARD;
+ }
+
+ if (activityType != ACTIVITY_TYPE_STANDARD) {
+ // For now there can be only one stack of a particular non-standard activity type on a
+ // display. So, get that ignoring whatever windowing mode it is currently in.
+ T stack = getStack(WINDOWING_MODE_UNDEFINED, activityType);
+ if (stack != null) {
+ throw new IllegalArgumentException("Stack=" + stack + " of activityType="
+ + activityType + " already on display=" + this + ". Can't have multiple.");
+ }
+ }
+
+ final ActivityTaskManagerService service = mSupervisor.mService;
+ if (!isWindowingModeSupported(windowingMode, service.mSupportsMultiWindow,
+ service.mSupportsSplitScreenMultiWindow, service.mSupportsFreeformWindowManagement,
+ service.mSupportsPictureInPicture, activityType)) {
+ throw new IllegalArgumentException("Can't create stack for unsupported windowingMode="
+ + windowingMode);
+ }
+
+ final int stackId = getNextStackId();
+ return createStackUnchecked(windowingMode, activityType, stackId, onTop);
+ }
+
+ @VisibleForTesting
+ <T extends ActivityStack> T createStackUnchecked(int windowingMode, int activityType,
+ int stackId, boolean onTop) {
+ if (windowingMode == WINDOWING_MODE_PINNED) {
+ return (T) new PinnedActivityStack(this, stackId, mSupervisor, onTop);
+ }
+ return (T) new ActivityStack(
+ this, stackId, mSupervisor, windowingMode, activityType, onTop);
+ }
+
+ /**
+ * Get the preferred focusable stack in priority. If the preferred stack does not exist, find a
+ * focusable and visible stack from the top of stacks in this display.
+ */
+ ActivityStack getFocusedStack() {
+ if (mPreferredTopFocusableStack != null) {
+ return mPreferredTopFocusableStack;
+ }
+
+ for (int i = mStacks.size() - 1; i >= 0; --i) {
+ final ActivityStack stack = mStacks.get(i);
+ if (stack.isFocusableAndVisible()) {
+ return stack;
+ }
+ }
+
+ return null;
+ }
+
+ ActivityStack getNextFocusableStack() {
+ return getNextFocusableStack(null /* currentFocus */, false /* ignoreCurrent */);
+ }
+
+ ActivityStack getNextFocusableStack(ActivityStack currentFocus, boolean ignoreCurrent) {
+ final int currentWindowingMode = currentFocus != null
+ ? currentFocus.getWindowingMode() : WINDOWING_MODE_UNDEFINED;
+
+ ActivityStack candidate = null;
+ for (int i = mStacks.size() - 1; i >= 0; --i) {
+ final ActivityStack stack = mStacks.get(i);
+ if (ignoreCurrent && stack == currentFocus) {
+ continue;
+ }
+ if (!stack.isFocusableAndVisible()) {
+ continue;
+ }
+
+ if (currentWindowingMode == WINDOWING_MODE_SPLIT_SCREEN_SECONDARY
+ && candidate == null && stack.inSplitScreenPrimaryWindowingMode()) {
+ // If the currently focused stack is in split-screen secondary we save off the
+ // top primary split-screen stack as a candidate for focus because we might
+ // prefer focus to move to an other stack to avoid primary split-screen stack
+ // overlapping with a fullscreen stack when a fullscreen stack is higher in z
+ // than the next split-screen stack. Assistant stack, I am looking at you...
+ // We only move the focus to the primary-split screen stack if there isn't a
+ // better alternative.
+ candidate = stack;
+ continue;
+ }
+ if (candidate != null && stack.inSplitScreenSecondaryWindowingMode()) {
+ // Use the candidate stack since we are now at the secondary split-screen.
+ return candidate;
+ }
+ return stack;
+ }
+ return candidate;
+ }
+
+ ActivityRecord getResumedActivity() {
+ final ActivityStack focusedStack = getFocusedStack();
+ if (focusedStack == null) {
+ return null;
+ }
+ // TODO(b/111541062): Move this into ActivityStack#getResumedActivity()
+ // Check if the focused stack has the resumed activity
+ ActivityRecord resumedActivity = focusedStack.getResumedActivity();
+ if (resumedActivity == null || resumedActivity.app == null) {
+ // If there is no registered resumed activity in the stack or it is not running -
+ // try to use previously resumed one.
+ resumedActivity = focusedStack.mPausingActivity;
+ if (resumedActivity == null || resumedActivity.app == null) {
+ // If previously resumed activity doesn't work either - find the topmost running
+ // activity that can be focused.
+ resumedActivity = focusedStack.topRunningActivityLocked(true /* focusableOnly */);
+ }
+ }
+ return resumedActivity;
+ }
+
+ ActivityStack getLastFocusedStack() {
+ return mLastFocusedStack;
+ }
+
+ boolean allResumedActivitiesComplete() {
+ for (int stackNdx = mStacks.size() - 1; stackNdx >= 0; --stackNdx) {
+ final ActivityRecord r = mStacks.get(stackNdx).getResumedActivity();
+ if (r != null && !r.isState(RESUMED)) {
+ return false;
+ }
+ }
+ final ActivityStack currentFocusedStack = getFocusedStack();
+ if (DEBUG_STACK) {
+ Slog.d(TAG_STACK, "allResumedActivitiesComplete: mLastFocusedStack changing from="
+ + mLastFocusedStack + " to=" + currentFocusedStack);
+ }
+ mLastFocusedStack = currentFocusedStack;
+ return true;
+ }
+
+ /**
+ * Pause all activities in either all of the stacks or just the back stacks.
+ * @param userLeaving Passed to pauseActivity() to indicate whether to call onUserLeaving().
+ * @param resuming The resuming activity.
+ * @param dontWait The resuming activity isn't going to wait for all activities to be paused
+ * before resuming.
+ * @return true if any activity was paused as a result of this call.
+ */
+ boolean pauseBackStacks(boolean userLeaving, ActivityRecord resuming, boolean dontWait) {
+ boolean someActivityPaused = false;
+ for (int stackNdx = mStacks.size() - 1; stackNdx >= 0; --stackNdx) {
+ final ActivityStack stack = mStacks.get(stackNdx);
+ // TODO(b/111541062): Check if resumed activity on this display instead
+ if (!mSupervisor.isTopDisplayFocusedStack(stack)
+ && stack.getResumedActivity() != null) {
+ if (DEBUG_STATES) Slog.d(TAG_STATES, "pauseBackStacks: stack=" + stack +
+ " mResumedActivity=" + stack.getResumedActivity());
+ someActivityPaused |= stack.startPausingLocked(userLeaving, false, resuming,
+ dontWait);
+ }
+ }
+ return someActivityPaused;
+ }
+
+ /**
+ * Find task for putting the Activity in.
+ */
+ void findTaskLocked(final ActivityRecord r, final boolean isPreferredDisplay,
+ FindTaskResult result) {
+ mTmpFindTaskResult.clear();
+ for (int stackNdx = getChildCount() - 1; stackNdx >= 0; --stackNdx) {
+ final ActivityStack stack = getChildAt(stackNdx);
+ if (!r.hasCompatibleActivityType(stack)) {
+ if (DEBUG_TASKS) {
+ Slog.d(TAG_TASKS, "Skipping stack: (mismatch activity/stack) " + stack);
+ }
+ continue;
+ }
+
+ stack.findTaskLocked(r, mTmpFindTaskResult);
+ // It is possible to have tasks in multiple stacks with the same root affinity, so
+ // we should keep looking after finding an affinity match to see if there is a
+ // better match in another stack. Also, task affinity isn't a good enough reason
+ // to target a display which isn't the source of the intent, so skip any affinity
+ // matches not on the specified display.
+ if (mTmpFindTaskResult.mRecord != null) {
+ if (mTmpFindTaskResult.mIdealMatch) {
+ result.setTo(mTmpFindTaskResult);
+ return;
+ } else if (isPreferredDisplay) {
+ // Note: since the traversing through the stacks is top down, the floating
+ // tasks should always have lower priority than any affinity-matching tasks
+ // in the fullscreen stacks
+ result.setTo(mTmpFindTaskResult);
+ }
+ }
+ }
+ }
+
+ /**
+ * Removes stacks in the input windowing modes from the system if they are of activity type
+ * ACTIVITY_TYPE_STANDARD or ACTIVITY_TYPE_UNDEFINED
+ */
+ void removeStacksInWindowingModes(int... windowingModes) {
+ if (windowingModes == null || windowingModes.length == 0) {
+ return;
+ }
+
+ for (int j = windowingModes.length - 1 ; j >= 0; --j) {
+ final int windowingMode = windowingModes[j];
+ for (int i = mStacks.size() - 1; i >= 0; --i) {
+ final ActivityStack stack = mStacks.get(i);
+ if (!stack.isActivityTypeStandardOrUndefined()) {
+ continue;
+ }
+ if (stack.getWindowingMode() != windowingMode) {
+ continue;
+ }
+ mSupervisor.removeStack(stack);
+ }
+ }
+ }
+
+ void removeStacksWithActivityTypes(int... activityTypes) {
+ if (activityTypes == null || activityTypes.length == 0) {
+ return;
+ }
+
+ for (int j = activityTypes.length - 1 ; j >= 0; --j) {
+ final int activityType = activityTypes[j];
+ for (int i = mStacks.size() - 1; i >= 0; --i) {
+ final ActivityStack stack = mStacks.get(i);
+ if (stack.getActivityType() == activityType) {
+ mSupervisor.removeStack(stack);
+ }
+ }
+ }
+ }
+
+ void onStackWindowingModeChanged(ActivityStack stack) {
+ removeStackReferenceIfNeeded(stack);
+ addStackReferenceIfNeeded(stack);
+ }
+
+ private void addStackReferenceIfNeeded(ActivityStack stack) {
+ final int activityType = stack.getActivityType();
+ final int windowingMode = stack.getWindowingMode();
+
+ if (activityType == ACTIVITY_TYPE_HOME) {
+ if (mHomeStack != null && mHomeStack != stack) {
+ throw new IllegalArgumentException("addStackReferenceIfNeeded: home stack="
+ + mHomeStack + " already exist on display=" + this + " stack=" + stack);
+ }
+ mHomeStack = stack;
+ } else if (activityType == ACTIVITY_TYPE_RECENTS) {
+ if (mRecentsStack != null && mRecentsStack != stack) {
+ throw new IllegalArgumentException("addStackReferenceIfNeeded: recents stack="
+ + mRecentsStack + " already exist on display=" + this + " stack=" + stack);
+ }
+ mRecentsStack = stack;
+ }
+ if (windowingMode == WINDOWING_MODE_PINNED) {
+ if (mPinnedStack != null && mPinnedStack != stack) {
+ throw new IllegalArgumentException("addStackReferenceIfNeeded: pinned stack="
+ + mPinnedStack + " already exist on display=" + this
+ + " stack=" + stack);
+ }
+ mPinnedStack = stack;
+ } else if (windowingMode == WINDOWING_MODE_SPLIT_SCREEN_PRIMARY) {
+ if (mSplitScreenPrimaryStack != null && mSplitScreenPrimaryStack != stack) {
+ throw new IllegalArgumentException("addStackReferenceIfNeeded:"
+ + " split-screen-primary" + " stack=" + mSplitScreenPrimaryStack
+ + " already exist on display=" + this + " stack=" + stack);
+ }
+ mSplitScreenPrimaryStack = stack;
+ onSplitScreenModeActivated();
+ }
+ }
+
+ private void removeStackReferenceIfNeeded(ActivityStack stack) {
+ if (stack == mHomeStack) {
+ mHomeStack = null;
+ } else if (stack == mRecentsStack) {
+ mRecentsStack = null;
+ } else if (stack == mPinnedStack) {
+ mPinnedStack = null;
+ } else if (stack == mSplitScreenPrimaryStack) {
+ mSplitScreenPrimaryStack = null;
+ // Inform the reset of the system that split-screen mode was dismissed so things like
+ // resizing all the other stacks can take place.
+ onSplitScreenModeDismissed();
+ }
+ }
+
+ private void onSplitScreenModeDismissed() {
+ mSupervisor.mWindowManager.deferSurfaceLayout();
+ try {
+ // Adjust the windowing mode of any stack in secondary split-screen to fullscreen.
+ for (int i = mStacks.size() - 1; i >= 0; --i) {
+ final ActivityStack otherStack = mStacks.get(i);
+ if (!otherStack.inSplitScreenSecondaryWindowingMode()) {
+ continue;
+ }
+ otherStack.setWindowingMode(WINDOWING_MODE_UNDEFINED, false /* animate */,
+ false /* showRecents */, false /* enteringSplitScreenMode */,
+ true /* deferEnsuringVisibility */);
+ }
+ } finally {
+ final ActivityStack topFullscreenStack =
+ getTopStackInWindowingMode(WINDOWING_MODE_FULLSCREEN);
+ if (topFullscreenStack != null && mHomeStack != null && !isTopStack(mHomeStack)) {
+ // Whenever split-screen is dismissed we want the home stack directly behind the
+ // current top fullscreen stack so it shows up when the top stack is finished.
+ // TODO: Would be better to use ActivityDisplay.positionChildAt() for this, however
+ // ActivityDisplay doesn't have a direct controller to WM side yet. We can switch
+ // once we have that.
+ mHomeStack.moveToFront("onSplitScreenModeDismissed");
+ topFullscreenStack.moveToFront("onSplitScreenModeDismissed");
+ }
+ mSupervisor.mWindowManager.continueSurfaceLayout();
+ }
+ }
+
+ private void onSplitScreenModeActivated() {
+ mSupervisor.mWindowManager.deferSurfaceLayout();
+ try {
+ // Adjust the windowing mode of any affected by split-screen to split-screen secondary.
+ for (int i = mStacks.size() - 1; i >= 0; --i) {
+ final ActivityStack otherStack = mStacks.get(i);
+ if (otherStack == mSplitScreenPrimaryStack
+ || !otherStack.affectedBySplitScreenResize()) {
+ continue;
+ }
+ otherStack.setWindowingMode(WINDOWING_MODE_SPLIT_SCREEN_SECONDARY,
+ false /* animate */, false /* showRecents */,
+ true /* enteringSplitScreenMode */, true /* deferEnsuringVisibility */);
+ }
+ } finally {
+ mSupervisor.mWindowManager.continueSurfaceLayout();
+ }
+ }
+
+ /**
+ * Returns true if the {@param windowingMode} is supported based on other parameters passed in.
+ * @param windowingMode The windowing mode we are checking support for.
+ * @param supportsMultiWindow If we should consider support for multi-window mode in general.
+ * @param supportsSplitScreen If we should consider support for split-screen multi-window.
+ * @param supportsFreeform If we should consider support for freeform multi-window.
+ * @param supportsPip If we should consider support for picture-in-picture mutli-window.
+ * @param activityType The activity type under consideration.
+ * @return true if the windowing mode is supported.
+ */
+ private boolean isWindowingModeSupported(int windowingMode, boolean supportsMultiWindow,
+ boolean supportsSplitScreen, boolean supportsFreeform, boolean supportsPip,
+ int activityType) {
+
+ if (windowingMode == WINDOWING_MODE_UNDEFINED
+ || windowingMode == WINDOWING_MODE_FULLSCREEN) {
+ return true;
+ }
+ if (!supportsMultiWindow) {
+ return false;
+ }
+
+ final int displayWindowingMode = getWindowingMode();
+ if (windowingMode == WINDOWING_MODE_SPLIT_SCREEN_PRIMARY
+ || windowingMode == WINDOWING_MODE_SPLIT_SCREEN_SECONDARY) {
+ return supportsSplitScreen
+ && WindowConfiguration.supportSplitScreenWindowingMode(activityType)
+ // Freeform windows and split-screen windows don't mix well, so prevent
+ // split windowing modes on freeform displays.
+ && displayWindowingMode != WINDOWING_MODE_FREEFORM;
+ }
+
+ if (!supportsFreeform && windowingMode == WINDOWING_MODE_FREEFORM) {
+ return false;
+ }
+
+ if (!supportsPip && windowingMode == WINDOWING_MODE_PINNED) {
+ return false;
+ }
+ return true;
+ }
+
+ /**
+ * Resolves the windowing mode that an {@link ActivityRecord} would be in if started on this
+ * display with the provided parameters.
+ *
+ * @param r The ActivityRecord in question.
+ * @param options Options to start with.
+ * @param task The task within-which the activity would start.
+ * @param activityType The type of activity to start.
+ * @return The resolved (not UNDEFINED) windowing-mode that the activity would be in.
+ */
+ int resolveWindowingMode(@Nullable ActivityRecord r, @Nullable ActivityOptions options,
+ @Nullable TaskRecord task, int activityType) {
+
+ // First preference if the windowing mode in the activity options if set.
+ int windowingMode = (options != null)
+ ? options.getLaunchWindowingMode() : WINDOWING_MODE_UNDEFINED;
+
+ // If windowing mode is unset, then next preference is the candidate task, then the
+ // activity record.
+ if (windowingMode == WINDOWING_MODE_UNDEFINED) {
+ if (task != null) {
+ windowingMode = task.getWindowingMode();
+ }
+ if (windowingMode == WINDOWING_MODE_UNDEFINED && r != null) {
+ windowingMode = r.getWindowingMode();
+ }
+ if (windowingMode == WINDOWING_MODE_UNDEFINED) {
+ // Use the display's windowing mode.
+ windowingMode = getWindowingMode();
+ }
+ }
+ windowingMode = validateWindowingMode(windowingMode, r, task, activityType);
+ return windowingMode != WINDOWING_MODE_UNDEFINED
+ ? windowingMode : WINDOWING_MODE_FULLSCREEN;
+ }
+
+ /**
+ * Check that the requested windowing-mode is appropriate for the specified task and/or activity
+ * on this display.
+ *
+ * @param windowingMode The windowing-mode to validate.
+ * @param r The {@link ActivityRecord} to check against.
+ * @param task The {@link TaskRecord} to check against.
+ * @param activityType An activity type.
+ * @return The provided windowingMode or the closest valid mode which is appropriate.
+ */
+ int validateWindowingMode(int windowingMode, @Nullable ActivityRecord r,
+ @Nullable TaskRecord task, int activityType) {
+ // Make sure the windowing mode we are trying to use makes sense for what is supported.
+ final ActivityTaskManagerService service = mSupervisor.mService;
+ boolean supportsMultiWindow = service.mSupportsMultiWindow;
+ boolean supportsSplitScreen = service.mSupportsSplitScreenMultiWindow;
+ boolean supportsFreeform = service.mSupportsFreeformWindowManagement;
+ boolean supportsPip = service.mSupportsPictureInPicture;
+ if (supportsMultiWindow) {
+ if (task != null) {
+ supportsMultiWindow = task.isResizeable();
+ supportsSplitScreen = task.supportsSplitScreenWindowingMode();
+ // TODO: Do we need to check for freeform and Pip support here?
+ } else if (r != null) {
+ supportsMultiWindow = r.isResizeable();
+ supportsSplitScreen = r.supportsSplitScreenWindowingMode();
+ supportsFreeform = r.supportsFreeform();
+ supportsPip = r.supportsPictureInPicture();
+ }
+ }
+
+ final boolean inSplitScreenMode = hasSplitScreenPrimaryStack();
+ if (!inSplitScreenMode
+ && windowingMode == WINDOWING_MODE_FULLSCREEN_OR_SPLIT_SCREEN_SECONDARY) {
+ // Switch to the display's windowing mode if we are not in split-screen mode and we are
+ // trying to launch in split-screen secondary.
+ windowingMode = WINDOWING_MODE_UNDEFINED;
+ } else if (inSplitScreenMode && (windowingMode == WINDOWING_MODE_FULLSCREEN
+ || windowingMode == WINDOWING_MODE_UNDEFINED)
+ && supportsSplitScreen) {
+ windowingMode = WINDOWING_MODE_SPLIT_SCREEN_SECONDARY;
+ }
+
+ if (windowingMode != WINDOWING_MODE_UNDEFINED
+ && isWindowingModeSupported(windowingMode, supportsMultiWindow, supportsSplitScreen,
+ supportsFreeform, supportsPip, activityType)) {
+ return windowingMode;
+ }
+ return WINDOWING_MODE_UNDEFINED;
+ }
+
+ /**
+ * Get the topmost stack on the display. It may be different from focused stack, because
+ * some stacks are not focusable (e.g. PiP).
+ */
+ ActivityStack getTopStack() {
+ return mStacks.isEmpty() ? null : mStacks.get(mStacks.size() - 1);
+ }
+
+ boolean isTopStack(ActivityStack stack) {
+ return stack == getTopStack();
+ }
+
+ boolean isTopNotPinnedStack(ActivityStack stack) {
+ for (int i = mStacks.size() - 1; i >= 0; --i) {
+ final ActivityStack current = mStacks.get(i);
+ if (!current.inPinnedWindowingMode()) {
+ return current == stack;
+ }
+ }
+ return false;
+ }
+
+ ActivityStack getTopStackInWindowingMode(int windowingMode) {
+ for (int i = mStacks.size() - 1; i >= 0; --i) {
+ final ActivityStack current = mStacks.get(i);
+ if (windowingMode == current.getWindowingMode()) {
+ return current;
+ }
+ }
+ return null;
+ }
+
+ ActivityRecord topRunningActivity() {
+ return topRunningActivity(false /* considerKeyguardState */);
+ }
+
+ /**
+ * Returns the top running activity in the focused stack. In the case the focused stack has no
+ * such activity, the next focusable stack on this display is returned.
+ *
+ * @param considerKeyguardState Indicates whether the locked state should be considered. if
+ * {@code true} and the keyguard is locked, only activities that
+ * can be shown on top of the keyguard will be considered.
+ * @return The top running activity. {@code null} if none is available.
+ */
+ ActivityRecord topRunningActivity(boolean considerKeyguardState) {
+ ActivityRecord topRunning = null;
+ final ActivityStack focusedStack = getFocusedStack();
+ if (focusedStack != null) {
+ topRunning = focusedStack.topRunningActivityLocked();
+ }
+
+ // Look in other focusable stacks.
+ if (topRunning == null) {
+ for (int i = mStacks.size() - 1; i >= 0; --i) {
+ final ActivityStack stack = mStacks.get(i);
+ // Only consider focusable stacks other than the current focused one.
+ if (stack == focusedStack || !stack.isFocusable()) {
+ continue;
+ }
+ topRunning = stack.topRunningActivityLocked();
+ if (topRunning != null) {
+ break;
+ }
+ }
+ }
+
+ // This activity can be considered the top running activity if we are not considering
+ // the locked state, the keyguard isn't locked, or we can show when locked.
+ if (topRunning != null && considerKeyguardState
+ && mSupervisor.getKeyguardController().isKeyguardLocked()
+ && !topRunning.canShowWhenLocked()) {
+ return null;
+ }
+
+ return topRunning;
+ }
+
+ int getIndexOf(ActivityStack stack) {
+ return mStacks.indexOf(stack);
+ }
+
+ void onLockTaskPackagesUpdated() {
+ for (int i = mStacks.size() - 1; i >= 0; --i) {
+ mStacks.get(i).onLockTaskPackagesUpdated();
+ }
+ }
+
+ /** We are in the process of exiting split-screen mode. */
+ void onExitingSplitScreenMode() {
+ // Remove reference to the primary-split-screen stack so it no longer has any effect on the
+ // display. For example, we want to be able to create fullscreen stack for standard activity
+ // types when exiting split-screen mode.
+ mSplitScreenPrimaryStack = null;
+ }
+
+ ActivityStack getSplitScreenPrimaryStack() {
+ return mSplitScreenPrimaryStack;
+ }
+
+ boolean hasSplitScreenPrimaryStack() {
+ return mSplitScreenPrimaryStack != null;
+ }
+
+ PinnedActivityStack getPinnedStack() {
+ return (PinnedActivityStack) mPinnedStack;
+ }
+
+ boolean hasPinnedStack() {
+ return mPinnedStack != null;
+ }
+
+ @Override
+ public String toString() {
+ return "ActivityDisplay={" + mDisplayId + " numStacks=" + mStacks.size() + "}";
+ }
+
+ @Override
+ protected int getChildCount() {
+ return mStacks.size();
+ }
+
+ @Override
+ protected ActivityStack getChildAt(int index) {
+ return mStacks.get(index);
+ }
+
+ @Override
+ protected ConfigurationContainer getParent() {
+ return mSupervisor;
+ }
+
+ boolean isPrivate() {
+ return (mDisplay.getFlags() & FLAG_PRIVATE) != 0;
+ }
+
+ boolean isUidPresent(int uid) {
+ for (ActivityStack stack : mStacks) {
+ if (stack.isUidPresent(uid)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * @see #mRemoved
+ */
+ boolean isRemoved() {
+ return mRemoved;
+ }
+
+ void remove() {
+ final boolean destroyContentOnRemoval = shouldDestroyContentOnRemove();
+
+ // Stacks could be reparented from the removed display to other display. While
+ // reparenting the last stack of the removed display, the remove display is ready to be
+ // released (no more ActivityStack). But, we cannot release it at that moment or the
+ // related WindowContainer and WindowContainerController will also be removed. So, we
+ // set display as removed after reparenting stack finished.
+ for (int i = mStacks.size() - 1; i >= 0; --i) {
+ final ActivityStack stack = mStacks.get(i);
+ // Always finish non-standard type stacks.
+ if (destroyContentOnRemoval || !stack.isActivityTypeStandardOrUndefined()) {
+ stack.finishAllActivitiesLocked(true /* immediately */);
+ } else {
+ // If default display is in split-window mode, set windowing mode of the stack to
+ // split-screen secondary. Otherwise, set the windowing mode to undefined by
+ // default to let stack inherited the windowing mode from the new display.
+ int windowingMode = mSupervisor.getDefaultDisplay().hasSplitScreenPrimaryStack()
+ ? WINDOWING_MODE_SPLIT_SCREEN_SECONDARY : WINDOWING_MODE_UNDEFINED;
+ mSupervisor.moveStackToDisplayLocked(stack.mStackId, DEFAULT_DISPLAY, true);
+ stack.setWindowingMode(windowingMode);
+ }
+ }
+ mRemoved = true;
+
+ releaseSelfIfNeeded();
+
+ mSupervisor.getKeyguardController().onDisplayRemoved(mDisplayId);
+
+ if (!mAllSleepTokens.isEmpty()) {
+ mSupervisor.mSleepTokens.removeAll(mAllSleepTokens);
+ mAllSleepTokens.clear();
+ mSupervisor.mService.updateSleepIfNeededLocked();
+ }
+ }
+
+ private void releaseSelfIfNeeded() {
+ if (mStacks.isEmpty() && mRemoved) {
+ mWindowContainerController.removeContainer();
+ mWindowContainerController = null;
+ mSupervisor.removeChild(this);
+ }
+ }
+
+ /** Update and get all UIDs that are present on the display and have access to it. */
+ IntArray getPresentUIDs() {
+ mDisplayAccessUIDs.clear();
+ for (ActivityStack stack : mStacks) {
+ stack.getPresentUIDs(mDisplayAccessUIDs);
+ }
+ return mDisplayAccessUIDs;
+ }
+
+ /**
+ * @see Display#FLAG_SHOULD_SHOW_SYSTEM_DECORATIONS
+ */
+ boolean supportsSystemDecorations() {
+ return mDisplay.supportsSystemDecorations()
+ // TODO (b/111363427): Remove this and set the new FLAG_SHOULD_SHOW_LAUNCHER flag
+ // (b/114338689) whenever vr 2d display id is set.
+ || mDisplayId == mSupervisor.mService.mVr2dDisplayId;
+ }
+
+ private boolean shouldDestroyContentOnRemove() {
+ return mDisplay.getRemoveMode() == REMOVE_MODE_DESTROY_CONTENT;
+ }
+
+ boolean shouldSleep() {
+ return (mStacks.isEmpty() || !mAllSleepTokens.isEmpty())
+ && (mSupervisor.mService.mRunningVoice == null);
+ }
+
+ void setFocusedApp(ActivityRecord r, boolean moveFocusNow) {
+ mWindowContainerController.setFocusedApp(r.appToken, moveFocusNow);
+ }
+
+ /**
+ * @return the stack currently above the {@param stack}. Can be null if the {@param stack} is
+ * already top-most.
+ */
+ ActivityStack getStackAbove(ActivityStack stack) {
+ final int stackIndex = mStacks.indexOf(stack) + 1;
+ return (stackIndex < mStacks.size()) ? mStacks.get(stackIndex) : null;
+ }
+
+ /**
+ * Adjusts the {@param stack} behind the last visible stack in the display if necessary.
+ * Generally used in conjunction with {@link #moveStackBehindStack}.
+ */
+ void moveStackBehindBottomMostVisibleStack(ActivityStack stack) {
+ if (stack.shouldBeVisible(null)) {
+ // Skip if the stack is already visible
+ return;
+ }
+
+ // Move the stack to the bottom to not affect the following visibility checks
+ positionChildAtBottom(stack);
+
+ // Find the next position where the stack should be placed
+ final int numStacks = mStacks.size();
+ for (int stackNdx = 0; stackNdx < numStacks; stackNdx++) {
+ final ActivityStack s = mStacks.get(stackNdx);
+ if (s == stack) {
+ continue;
+ }
+ final int winMode = s.getWindowingMode();
+ final boolean isValidWindowingMode = winMode == WINDOWING_MODE_FULLSCREEN ||
+ winMode == WINDOWING_MODE_SPLIT_SCREEN_SECONDARY;
+ if (s.shouldBeVisible(null) && isValidWindowingMode) {
+ // Move the provided stack to behind this stack
+ positionChildAt(stack, Math.max(0, stackNdx - 1));
+ break;
+ }
+ }
+ }
+
+ /**
+ * Moves the {@param stack} behind the given {@param behindStack} if possible. If
+ * {@param behindStack} is not currently in the display, then then the stack is moved to the
+ * back. Generally used in conjunction with {@link #moveStackBehindBottomMostVisibleStack}.
+ */
+ void moveStackBehindStack(ActivityStack stack, ActivityStack behindStack) {
+ if (behindStack == null || behindStack == stack) {
+ return;
+ }
+
+ // Note that positionChildAt will first remove the given stack before inserting into the
+ // list, so we need to adjust the insertion index to account for the removed index
+ // TODO: Remove this logic when WindowContainer.positionChildAt() is updated to adjust the
+ // position internally
+ final int stackIndex = mStacks.indexOf(stack);
+ final int behindStackIndex = mStacks.indexOf(behindStack);
+ final int insertIndex = stackIndex <= behindStackIndex
+ ? behindStackIndex - 1 : behindStackIndex;
+ positionChildAt(stack, Math.max(0, insertIndex));
+ }
+
+ void moveHomeStackToFront(String reason) {
+ if (mHomeStack != null) {
+ mHomeStack.moveToFront(reason);
+ }
+ }
+
+ /** Returns true if the focus activity was adjusted to the home stack top activity. */
+ boolean moveHomeActivityToTop(String reason) {
+ final ActivityRecord top = getHomeActivity();
+ if (top == null) {
+ return false;
+ }
+ top.moveFocusableActivityToTop(reason);
+ return true;
+ }
+
+ @Nullable
+ ActivityStack getHomeStack() {
+ return mHomeStack;
+ }
+
+ @Nullable
+ ActivityRecord getHomeActivity() {
+ return getHomeActivityForUser(mSupervisor.mCurrentUser);
+ }
+
+ @Nullable
+ ActivityRecord getHomeActivityForUser(int userId) {
+ if (mHomeStack == null) {
+ return null;
+ }
+
+ final ArrayList<TaskRecord> tasks = mHomeStack.getAllTasks();
+ for (int taskNdx = tasks.size() - 1; taskNdx >= 0; --taskNdx) {
+ final TaskRecord task = tasks.get(taskNdx);
+ if (!task.isActivityTypeHome()) {
+ continue;
+ }
+
+ final ArrayList<ActivityRecord> activities = task.mActivities;
+ for (int activityNdx = activities.size() - 1; activityNdx >= 0; --activityNdx) {
+ final ActivityRecord r = activities.get(activityNdx);
+ if (r.isActivityTypeHome()
+ && ((userId == UserHandle.USER_ALL) || (r.userId == userId))) {
+ return r;
+ }
+ }
+ }
+ return null;
+ }
+
+ boolean isSleeping() {
+ return mSleeping;
+ }
+
+ void setIsSleeping(boolean asleep) {
+ mSleeping = asleep;
+ }
+
+ /**
+ * Adds a listener to be notified whenever the stack order in the display changes. Currently
+ * only used by the {@link RecentsAnimation} to determine whether to interrupt and cancel the
+ * current animation when the system state changes.
+ */
+ void registerStackOrderChangedListener(OnStackOrderChangedListener listener) {
+ if (!mStackOrderChangedCallbacks.contains(listener)) {
+ mStackOrderChangedCallbacks.add(listener);
+ }
+ }
+
+ /**
+ * Removes a previously registered stack order change listener.
+ */
+ void unregisterStackOrderChangedListener(OnStackOrderChangedListener listener) {
+ mStackOrderChangedCallbacks.remove(listener);
+ }
+
+ private void onStackOrderChanged() {
+ for (int i = mStackOrderChangedCallbacks.size() - 1; i >= 0; i--) {
+ mStackOrderChangedCallbacks.get(i).onStackOrderChanged();
+ }
+ }
+
+ /**
+ * See {@link DisplayWindowController#deferUpdateImeTarget()}
+ */
+ public void deferUpdateImeTarget() {
+ mWindowContainerController.deferUpdateImeTarget();
+ }
+
+ /**
+ * See {@link DisplayWindowController#deferUpdateImeTarget()}
+ */
+ public void continueUpdateImeTarget() {
+ mWindowContainerController.continueUpdateImeTarget();
+ }
+
+ public void dump(PrintWriter pw, String prefix) {
+ pw.println(prefix + "displayId=" + mDisplayId + " stacks=" + mStacks.size());
+ final String myPrefix = prefix + " ";
+ if (mHomeStack != null) {
+ pw.println(myPrefix + "mHomeStack=" + mHomeStack);
+ }
+ if (mRecentsStack != null) {
+ pw.println(myPrefix + "mRecentsStack=" + mRecentsStack);
+ }
+ if (mPinnedStack != null) {
+ pw.println(myPrefix + "mPinnedStack=" + mPinnedStack);
+ }
+ if (mSplitScreenPrimaryStack != null) {
+ pw.println(myPrefix + "mSplitScreenPrimaryStack=" + mSplitScreenPrimaryStack);
+ }
+ if (mPreferredTopFocusableStack != null) {
+ pw.println(myPrefix + "mPreferredTopFocusableStack=" + mPreferredTopFocusableStack);
+ }
+ if (mLastFocusedStack != null) {
+ pw.println(myPrefix + "mLastFocusedStack=" + mLastFocusedStack);
+ }
+ }
+
+ public void dumpStacks(PrintWriter pw) {
+ for (int i = mStacks.size() - 1; i >= 0; --i) {
+ pw.print(mStacks.get(i).mStackId);
+ if (i > 0) {
+ pw.print(",");
+ }
+ }
+ }
+
+ public void writeToProto(ProtoOutputStream proto, long fieldId) {
+ final long token = proto.start(fieldId);
+ super.writeToProto(proto, CONFIGURATION_CONTAINER, false /* trim */);
+ proto.write(ID, mDisplayId);
+ final ActivityStack focusedStack = getFocusedStack();
+ if (focusedStack != null) {
+ proto.write(FOCUSED_STACK_ID, focusedStack.mStackId);
+ final ActivityRecord focusedActivity = focusedStack.getDisplay().getResumedActivity();
+ if (focusedActivity != null) {
+ focusedActivity.writeIdentifierToProto(proto, RESUMED_ACTIVITY);
+ }
+ } else {
+ proto.write(FOCUSED_STACK_ID, INVALID_STACK_ID);
+ }
+ for (int stackNdx = mStacks.size() - 1; stackNdx >= 0; --stackNdx) {
+ final ActivityStack stack = mStacks.get(stackNdx);
+ stack.writeToProto(proto, STACKS);
+ }
+ proto.end(token);
+ }
+
+ /**
+ * Callback for when the order of the stacks in the display changes.
+ */
+ interface OnStackOrderChangedListener {
+ void onStackOrderChanged();
+ }
+}
diff --git a/services/core/java/com/android/server/wm/ActivityMetricsLogger.java b/services/core/java/com/android/server/wm/ActivityMetricsLogger.java
new file mode 100644
index 0000000..8bde7dd
--- /dev/null
+++ b/services/core/java/com/android/server/wm/ActivityMetricsLogger.java
@@ -0,0 +1,926 @@
+package com.android.server.wm;
+
+import static android.app.ActivityManager.START_SUCCESS;
+import static android.app.ActivityManager.START_TASK_TO_FRONT;
+import static android.app.ActivityManager.processStateAmToProto;
+import static android.app.WindowConfiguration.WINDOWING_MODE_FREEFORM;
+import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN;
+import static android.app.WindowConfiguration.WINDOWING_MODE_PINNED;
+import static android.app.WindowConfiguration.WINDOWING_MODE_SPLIT_SCREEN_PRIMARY;
+import static android.app.WindowConfiguration.WINDOWING_MODE_SPLIT_SCREEN_SECONDARY;
+import static android.app.WindowConfiguration.WINDOWING_MODE_UNDEFINED;
+
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.ACTION_ACTIVITY_START;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.APP_TRANSITION;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.APP_TRANSITION_BIND_APPLICATION_DELAY_MS;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.APP_TRANSITION_CALLING_PACKAGE_NAME;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.APP_TRANSITION_CANCELLED;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.APP_TRANSITION_DELAY_MS;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.APP_TRANSITION_DEVICE_UPTIME_SECONDS;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.APP_TRANSITION_IS_EPHEMERAL;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.APP_TRANSITION_PROCESS_RUNNING;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.APP_TRANSITION_REPORTED_DRAWN;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.APP_TRANSITION_REPORTED_DRAWN_MS;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.APP_TRANSITION_STARTING_WINDOW_DELAY_MS;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.APP_TRANSITION_WINDOWS_DRAWN_DELAY_MS;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.FIELD_ACTIVITY_RECORD_FLAGS;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.FIELD_ACTIVITY_RECORD_IS_FULLSCREEN;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.FIELD_ACTIVITY_RECORD_IS_NO_DISPLAY;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.FIELD_ACTIVITY_RECORD_IS_VISIBLE;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.FIELD_ACTIVITY_RECORD_IS_VISIBLE_IGNORING_KEYGUARD;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.FIELD_ACTIVITY_RECORD_LAUNCH_MODE;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.FIELD_ACTIVITY_RECORD_MILLIS_SINCE_LAST_LAUNCH;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.FIELD_ACTIVITY_RECORD_MILLIS_SINCE_LAST_VISIBLE;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.FIELD_ACTIVITY_RECORD_PROCESS_NAME;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.FIELD_ACTIVITY_RECORD_REAL_ACTIVITY;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.FIELD_ACTIVITY_RECORD_RESULT_TO_PKG_NAME;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.FIELD_ACTIVITY_RECORD_RESULT_TO_SHORT_COMPONENT_NAME;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.FIELD_ACTIVITY_RECORD_SHORT_COMPONENT_NAME;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.FIELD_ACTIVITY_RECORD_TARGET_ACTIVITY;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.FIELD_CALLING_PACKAGE_NAME;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.FIELD_CALLING_UID;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.FIELD_CALLING_UID_HAS_ANY_VISIBLE_WINDOW;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.FIELD_CALLING_UID_PROC_STATE;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.FIELD_CLASS_NAME;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.FIELD_COMING_FROM_PENDING_INTENT;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.FIELD_INSTANT_APP_LAUNCH_TOKEN;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.FIELD_INTENT_ACTION;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.FIELD_PROCESS_RECORD_CUR_PROC_STATE;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.FIELD_PROCESS_RECORD_HAS_CLIENT_ACTIVITIES;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.FIELD_PROCESS_RECORD_HAS_FOREGROUND_ACTIVITIES;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.FIELD_PROCESS_RECORD_HAS_FOREGROUND_SERVICES;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.FIELD_PROCESS_RECORD_HAS_OVERLAY_UI;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.FIELD_PROCESS_RECORD_HAS_TOP_UI;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.FIELD_PROCESS_RECORD_MILLIS_SINCE_FG_INTERACTION;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.FIELD_PROCESS_RECORD_MILLIS_SINCE_LAST_INTERACTION_EVENT;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.FIELD_PROCESS_RECORD_MILLIS_SINCE_UNIMPORTANT;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.FIELD_PROCESS_RECORD_PENDING_UI_CLEAN;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.FIELD_PROCESS_RECORD_PROCESS_NAME;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.FIELD_REAL_CALLING_UID;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.FIELD_REAL_CALLING_UID_HAS_ANY_VISIBLE_WINDOW;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.FIELD_REAL_CALLING_UID_PROC_STATE;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.FIELD_TARGET_PACKAGE_NAME;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.FIELD_TARGET_SHORT_COMPONENT_NAME;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.FIELD_TARGET_UID;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.FIELD_TARGET_UID_HAS_ANY_VISIBLE_WINDOW;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.FIELD_TARGET_UID_PROC_STATE;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.FIELD_TARGET_WHITELIST_TAG;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.PACKAGE_OPTIMIZATION_COMPILATION_FILTER;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.PACKAGE_OPTIMIZATION_COMPILATION_REASON;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.TYPE_TRANSITION_COLD_LAUNCH;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.TYPE_TRANSITION_HOT_LAUNCH;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.TYPE_TRANSITION_REPORTED_DRAWN_NO_BUNDLE;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.TYPE_TRANSITION_REPORTED_DRAWN_WITH_BUNDLE;
+import static com.android.internal.logging.nano.MetricsProto.MetricsEvent.TYPE_TRANSITION_WARM_LAUNCH;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_METRICS;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_ATM;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_WITH_CLASS_NAME;
+import static com.android.server.am.EventLogTags.AM_ACTIVITY_LAUNCH_TIME;
+import static com.android.server.am.MemoryStatUtil.MemoryStat;
+import static com.android.server.am.MemoryStatUtil.readMemoryStatFromFilesystem;
+import static com.android.server.wm.ActivityTaskManagerInternal.APP_TRANSITION_TIMEOUT;
+
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.dex.ArtManagerInternal;
+import android.content.pm.dex.PackageOptimizationInfo;
+import android.metrics.LogMaker;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.Message;
+import android.os.SystemClock;
+import android.os.Trace;
+import android.util.EventLog;
+import android.util.Log;
+import android.util.Slog;
+import android.util.SparseArray;
+import android.util.SparseIntArray;
+import android.util.StatsLog;
+import android.util.TimeUtils;
+
+import com.android.internal.logging.MetricsLogger;
+import com.android.internal.os.BackgroundThread;
+import com.android.internal.os.SomeArgs;
+import com.android.server.LocalServices;
+
+/**
+ * Listens to activity launches, transitions, visibility changes and window drawn callbacks to
+ * determine app launch times and draw delays. Source of truth for activity metrics and provides
+ * data for Tron, logcat, event logs and {@link android.app.WaitResult}.
+ *
+ * Tests:
+ * atest CtsActivityManagerDeviceTestCases:ActivityMetricsLoggerTests
+ */
+class ActivityMetricsLogger {
+
+ private static final String TAG = TAG_WITH_CLASS_NAME ? "ActivityMetricsLogger" : TAG_ATM;
+
+ // Window modes we are interested in logging. If we ever introduce a new type, we need to add
+ // a value here and increase the {@link #TRON_WINDOW_STATE_VARZ_STRINGS} array.
+ private static final int WINDOW_STATE_STANDARD = 0;
+ private static final int WINDOW_STATE_SIDE_BY_SIDE = 1;
+ private static final int WINDOW_STATE_FREEFORM = 2;
+ private static final int WINDOW_STATE_ASSISTANT = 3;
+ private static final int WINDOW_STATE_INVALID = -1;
+
+ private static final long INVALID_START_TIME = -1;
+ private static final int INVALID_DELAY = -1;
+ private static final int INVALID_TRANSITION_TYPE = -1;
+
+ private static final int MSG_CHECK_VISIBILITY = 0;
+
+ // Preallocated strings we are sending to tron, so we don't have to allocate a new one every
+ // time we log.
+ private static final String[] TRON_WINDOW_STATE_VARZ_STRINGS = {
+ "window_time_0", "window_time_1", "window_time_2", "window_time_3"};
+
+ private int mWindowState = WINDOW_STATE_STANDARD;
+ private long mLastLogTimeSecs;
+ private final ActivityStackSupervisor mSupervisor;
+ private final Context mContext;
+ private final MetricsLogger mMetricsLogger = new MetricsLogger();
+
+ private long mCurrentTransitionStartTime = INVALID_START_TIME;
+ private long mLastTransitionStartTime = INVALID_START_TIME;
+
+ private int mCurrentTransitionDeviceUptime;
+ private int mCurrentTransitionDelayMs;
+ private boolean mLoggedTransitionStarting;
+
+ private final SparseArray<WindowingModeTransitionInfo> mWindowingModeTransitionInfo =
+ new SparseArray<>();
+ private final SparseArray<WindowingModeTransitionInfo> mLastWindowingModeTransitionInfo =
+ new SparseArray<>();
+ private final H mHandler;
+
+ private ArtManagerInternal mArtManagerInternal;
+ private final StringBuilder mStringBuilder = new StringBuilder();
+
+ private final class H extends Handler {
+
+ public H(Looper looper) {
+ super(looper);
+ }
+
+ @Override
+ public void handleMessage(Message msg) {
+ switch (msg.what) {
+ case MSG_CHECK_VISIBILITY:
+ final SomeArgs args = (SomeArgs) msg.obj;
+ checkVisibility((TaskRecord) args.arg1, (ActivityRecord) args.arg2);
+ break;
+ }
+ }
+ }
+
+ private final class WindowingModeTransitionInfo {
+ private ActivityRecord launchedActivity;
+ private int startResult;
+ private boolean currentTransitionProcessRunning;
+ /** Elapsed time from when we launch an activity to when its windows are drawn. */
+ private int windowsDrawnDelayMs;
+ private int startingWindowDelayMs = INVALID_DELAY;
+ private int bindApplicationDelayMs = INVALID_DELAY;
+ private int reason = APP_TRANSITION_TIMEOUT;
+ private boolean loggedWindowsDrawn;
+ private boolean loggedStartingWindowDrawn;
+ private boolean launchTraceActive;
+ }
+
+ final class WindowingModeTransitionInfoSnapshot {
+ final private ApplicationInfo applicationInfo;
+ final private WindowProcessController processRecord;
+ final String packageName;
+ final String launchedActivityName;
+ final private String launchedActivityLaunchedFromPackage;
+ final private String launchedActivityLaunchToken;
+ final private String launchedActivityAppRecordRequiredAbi;
+ final String launchedActivityShortComponentName;
+ final private String processName;
+ final private int reason;
+ final private int startingWindowDelayMs;
+ final private int bindApplicationDelayMs;
+ final int windowsDrawnDelayMs;
+ final int type;
+ final int userId;
+ /**
+ * Elapsed time from when we launch an activity to when the app reported it was
+ * fully drawn. If this is not reported then the value is set to INVALID_DELAY.
+ */
+ final int windowsFullyDrawnDelayMs;
+ final int activityRecordIdHashCode;
+
+ private WindowingModeTransitionInfoSnapshot(WindowingModeTransitionInfo info) {
+ this(info, info.launchedActivity);
+ }
+
+ private WindowingModeTransitionInfoSnapshot(WindowingModeTransitionInfo info,
+ ActivityRecord launchedActivity) {
+ this(info, launchedActivity, INVALID_DELAY);
+ }
+
+ private WindowingModeTransitionInfoSnapshot(WindowingModeTransitionInfo info,
+ ActivityRecord launchedActivity, int windowsFullyDrawnDelayMs) {
+ applicationInfo = launchedActivity.appInfo;
+ packageName = launchedActivity.packageName;
+ launchedActivityName = launchedActivity.info.name;
+ launchedActivityLaunchedFromPackage = launchedActivity.launchedFromPackage;
+ launchedActivityLaunchToken = launchedActivity.info.launchToken;
+ launchedActivityAppRecordRequiredAbi = launchedActivity.app == null
+ ? null
+ : launchedActivity.app.getRequiredAbi();
+ reason = info.reason;
+ startingWindowDelayMs = info.startingWindowDelayMs;
+ bindApplicationDelayMs = info.bindApplicationDelayMs;
+ windowsDrawnDelayMs = info.windowsDrawnDelayMs;
+ type = getTransitionType(info);
+ processRecord = findProcessForActivity(launchedActivity);
+ processName = launchedActivity.processName;
+ userId = launchedActivity.userId;
+ launchedActivityShortComponentName = launchedActivity.shortComponentName;
+ activityRecordIdHashCode = System.identityHashCode(launchedActivity);
+ this.windowsFullyDrawnDelayMs = windowsFullyDrawnDelayMs;
+ }
+ }
+
+ ActivityMetricsLogger(ActivityStackSupervisor supervisor, Context context, Looper looper) {
+ mLastLogTimeSecs = SystemClock.elapsedRealtime() / 1000;
+ mSupervisor = supervisor;
+ mContext = context;
+ mHandler = new H(looper);
+ }
+
+ void logWindowState() {
+ final long now = SystemClock.elapsedRealtime() / 1000;
+ if (mWindowState != WINDOW_STATE_INVALID) {
+ // We log even if the window state hasn't changed, because the user might remain in
+ // home/fullscreen move forever and we would like to track this kind of behavior
+ // too.
+ MetricsLogger.count(mContext, TRON_WINDOW_STATE_VARZ_STRINGS[mWindowState],
+ (int) (now - mLastLogTimeSecs));
+ }
+ mLastLogTimeSecs = now;
+
+ mWindowState = WINDOW_STATE_INVALID;
+ ActivityStack stack = mSupervisor.getTopDisplayFocusedStack();
+ if (stack == null) {
+ return;
+ }
+
+ if (stack.isActivityTypeAssistant()) {
+ mWindowState = WINDOW_STATE_ASSISTANT;
+ return;
+ }
+
+ int windowingMode = stack.getWindowingMode();
+ if (windowingMode == WINDOWING_MODE_PINNED) {
+ stack = mSupervisor.findStackBehind(stack);
+ windowingMode = stack.getWindowingMode();
+ }
+ switch (windowingMode) {
+ case WINDOWING_MODE_FULLSCREEN:
+ mWindowState = WINDOW_STATE_STANDARD;
+ break;
+ case WINDOWING_MODE_SPLIT_SCREEN_PRIMARY:
+ case WINDOWING_MODE_SPLIT_SCREEN_SECONDARY:
+ mWindowState = WINDOW_STATE_SIDE_BY_SIDE;
+ break;
+ case WINDOWING_MODE_FREEFORM:
+ mWindowState = WINDOW_STATE_FREEFORM;
+ break;
+ default:
+ if (windowingMode != WINDOWING_MODE_UNDEFINED) {
+ throw new IllegalStateException("Unknown windowing mode for stack=" + stack
+ + " windowingMode=" + windowingMode);
+ }
+ }
+ }
+
+ /**
+ * Notifies the tracker at the earliest possible point when we are starting to launch an
+ * activity.
+ */
+ void notifyActivityLaunching() {
+ if (!isAnyTransitionActive()) {
+ if (DEBUG_METRICS) Slog.i(TAG, "notifyActivityLaunching");
+ mCurrentTransitionStartTime = SystemClock.uptimeMillis();
+ mLastTransitionStartTime = mCurrentTransitionStartTime;
+ }
+ }
+
+ /**
+ * Notifies the tracker that the activity is actually launching.
+ *
+ * @param resultCode one of the ActivityManager.START_* flags, indicating the result of the
+ * launch
+ * @param launchedActivity the activity that is being launched
+ */
+ void notifyActivityLaunched(int resultCode, ActivityRecord launchedActivity) {
+ final WindowProcessController processRecord = findProcessForActivity(launchedActivity);
+ final boolean processRunning = processRecord != null;
+
+ // We consider this a "process switch" if the process of the activity that gets launched
+ // didn't have an activity that was in started state. In this case, we assume that lot
+ // of caches might be purged so the time until it produces the first frame is very
+ // interesting.
+ final boolean processSwitch = processRecord == null
+ || !processRecord.hasStartedActivity(launchedActivity);
+
+ notifyActivityLaunched(resultCode, launchedActivity, processRunning, processSwitch);
+ }
+
+ /**
+ * Notifies the tracker the the activity is actually launching.
+ *
+ * @param resultCode one of the ActivityManager.START_* flags, indicating the result of the
+ * launch
+ * @param launchedActivity the activity being launched
+ * @param processRunning whether the process that will contains the activity is already running
+ * @param processSwitch whether the process that will contain the activity didn't have any
+ * activity that was stopped, i.e. the started activity is "switching"
+ * processes
+ */
+ private void notifyActivityLaunched(int resultCode, ActivityRecord launchedActivity,
+ boolean processRunning, boolean processSwitch) {
+
+ if (DEBUG_METRICS) Slog.i(TAG, "notifyActivityLaunched"
+ + " resultCode=" + resultCode
+ + " launchedActivity=" + launchedActivity
+ + " processRunning=" + processRunning
+ + " processSwitch=" + processSwitch);
+
+ final int windowingMode = launchedActivity != null
+ ? launchedActivity.getWindowingMode()
+ : WINDOWING_MODE_UNDEFINED;
+ final WindowingModeTransitionInfo info = mWindowingModeTransitionInfo.get(windowingMode);
+ if (mCurrentTransitionStartTime == INVALID_START_TIME) {
+ // No transition is active ignore this launch.
+ return;
+ }
+
+ if (launchedActivity != null && launchedActivity.nowVisible) {
+ // Launched activity is already visible. We cannot measure windows drawn delay.
+ reset(true /* abort */, info);
+ return;
+ }
+
+ if (launchedActivity != null && info != null) {
+ // If we are already in an existing transition, only update the activity name, but not
+ // the other attributes.
+ info.launchedActivity = launchedActivity;
+ return;
+ }
+
+ final boolean otherWindowModesLaunching =
+ mWindowingModeTransitionInfo.size() > 0 && info == null;
+ if ((!isLoggableResultCode(resultCode) || launchedActivity == null || !processSwitch
+ || windowingMode == WINDOWING_MODE_UNDEFINED) && !otherWindowModesLaunching) {
+ // Failed to launch or it was not a process switch, so we don't care about the timing.
+ reset(true /* abort */, info);
+ return;
+ } else if (otherWindowModesLaunching) {
+ // Don't log this windowing mode but continue with the other windowing modes.
+ return;
+ }
+
+ if (DEBUG_METRICS) Slog.i(TAG, "notifyActivityLaunched successful");
+
+ final WindowingModeTransitionInfo newInfo = new WindowingModeTransitionInfo();
+ newInfo.launchedActivity = launchedActivity;
+ newInfo.currentTransitionProcessRunning = processRunning;
+ newInfo.startResult = resultCode;
+ mWindowingModeTransitionInfo.put(windowingMode, newInfo);
+ mLastWindowingModeTransitionInfo.put(windowingMode, newInfo);
+ mCurrentTransitionDeviceUptime = (int) (SystemClock.uptimeMillis() / 1000);
+ startTraces(newInfo);
+ }
+
+ /**
+ * @return True if we should start logging an event for an activity start that returned
+ * {@code resultCode} and that we'll indeed get a windows drawn event.
+ */
+ private boolean isLoggableResultCode(int resultCode) {
+ return resultCode == START_SUCCESS || resultCode == START_TASK_TO_FRONT;
+ }
+
+ /**
+ * Notifies the tracker that all windows of the app have been drawn.
+ */
+ WindowingModeTransitionInfoSnapshot notifyWindowsDrawn(int windowingMode, long timestamp) {
+ if (DEBUG_METRICS) Slog.i(TAG, "notifyWindowsDrawn windowingMode=" + windowingMode);
+
+ final WindowingModeTransitionInfo info = mWindowingModeTransitionInfo.get(windowingMode);
+ if (info == null || info.loggedWindowsDrawn) {
+ return null;
+ }
+ info.windowsDrawnDelayMs = calculateDelay(timestamp);
+ info.loggedWindowsDrawn = true;
+ final WindowingModeTransitionInfoSnapshot infoSnapshot =
+ new WindowingModeTransitionInfoSnapshot(info);
+ if (allWindowsDrawn() && mLoggedTransitionStarting) {
+ reset(false /* abort */, info);
+ }
+ return infoSnapshot;
+ }
+
+ /**
+ * Notifies the tracker that the starting window was drawn.
+ */
+ void notifyStartingWindowDrawn(int windowingMode, long timestamp) {
+ final WindowingModeTransitionInfo info = mWindowingModeTransitionInfo.get(windowingMode);
+ if (info == null || info.loggedStartingWindowDrawn) {
+ return;
+ }
+ info.loggedStartingWindowDrawn = true;
+ info.startingWindowDelayMs = calculateDelay(timestamp);
+ }
+
+ /**
+ * Notifies the tracker that the app transition is starting.
+ *
+ * @param windowingModeToReason A map from windowing mode to a reason integer, which must be on
+ * of ActivityTaskManagerInternal.APP_TRANSITION_* reasons.
+ */
+ void notifyTransitionStarting(SparseIntArray windowingModeToReason, long timestamp) {
+ if (!isAnyTransitionActive() || mLoggedTransitionStarting) {
+ return;
+ }
+ if (DEBUG_METRICS) Slog.i(TAG, "notifyTransitionStarting");
+ mCurrentTransitionDelayMs = calculateDelay(timestamp);
+ mLoggedTransitionStarting = true;
+ for (int index = windowingModeToReason.size() - 1; index >= 0; index--) {
+ final int windowingMode = windowingModeToReason.keyAt(index);
+ final WindowingModeTransitionInfo info = mWindowingModeTransitionInfo.get(
+ windowingMode);
+ if (info == null) {
+ continue;
+ }
+ info.reason = windowingModeToReason.valueAt(index);
+ }
+ if (allWindowsDrawn()) {
+ reset(false /* abort */, null /* WindowingModeTransitionInfo */);
+ }
+ }
+
+ /**
+ * Notifies the tracker that the visibility of an app is changing.
+ *
+ * @param activityRecord the app that is changing its visibility
+ */
+ void notifyVisibilityChanged(ActivityRecord activityRecord) {
+ final WindowingModeTransitionInfo info = mWindowingModeTransitionInfo.get(
+ activityRecord.getWindowingMode());
+ if (info == null) {
+ return;
+ }
+ if (info.launchedActivity != activityRecord) {
+ return;
+ }
+ final TaskRecord t = activityRecord.getTask();
+ final SomeArgs args = SomeArgs.obtain();
+ args.arg1 = t;
+ args.arg2 = activityRecord;
+ mHandler.obtainMessage(MSG_CHECK_VISIBILITY, args).sendToTarget();
+ }
+
+ private void checkVisibility(TaskRecord t, ActivityRecord r) {
+ synchronized (mSupervisor.mService.mGlobalLock) {
+
+ final WindowingModeTransitionInfo info = mWindowingModeTransitionInfo.get(
+ r.getWindowingMode());
+
+ // If we have an active transition that's waiting on a certain activity that will be
+ // invisible now, we'll never get onWindowsDrawn, so abort the transition if necessary.
+ if (info != null && !t.isVisible()) {
+ if (DEBUG_METRICS) Slog.i(TAG, "notifyVisibilityChanged to invisible"
+ + " activity=" + r);
+ logAppTransitionCancel(info);
+ mWindowingModeTransitionInfo.remove(r.getWindowingMode());
+ if (mWindowingModeTransitionInfo.size() == 0) {
+ reset(true /* abort */, info);
+ }
+ }
+ }
+ }
+
+ /**
+ * Notifies the tracker that we called immediately before we call bindApplication on the client.
+ *
+ * @param appInfo The client into which we'll call bindApplication.
+ */
+ void notifyBindApplication(ApplicationInfo appInfo) {
+ for (int i = mWindowingModeTransitionInfo.size() - 1; i >= 0; i--) {
+ final WindowingModeTransitionInfo info = mWindowingModeTransitionInfo.valueAt(i);
+
+ // App isn't attached to record yet, so match with info.
+ if (info.launchedActivity.appInfo == appInfo) {
+ info.bindApplicationDelayMs = calculateCurrentDelay();
+ }
+ }
+ }
+
+ private boolean allWindowsDrawn() {
+ for (int index = mWindowingModeTransitionInfo.size() - 1; index >= 0; index--) {
+ if (!mWindowingModeTransitionInfo.valueAt(index).loggedWindowsDrawn) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ private boolean isAnyTransitionActive() {
+ return mCurrentTransitionStartTime != INVALID_START_TIME
+ && mWindowingModeTransitionInfo.size() > 0;
+ }
+
+ private void reset(boolean abort, WindowingModeTransitionInfo info) {
+ if (DEBUG_METRICS) Slog.i(TAG, "reset abort=" + abort);
+ if (!abort && isAnyTransitionActive()) {
+ logAppTransitionMultiEvents();
+ }
+ stopLaunchTrace(info);
+ mCurrentTransitionStartTime = INVALID_START_TIME;
+ mCurrentTransitionDelayMs = INVALID_DELAY;
+ mLoggedTransitionStarting = false;
+ mWindowingModeTransitionInfo.clear();
+ }
+
+ private int calculateCurrentDelay() {
+ // Shouldn't take more than 25 days to launch an app, so int is fine here.
+ return (int) (SystemClock.uptimeMillis() - mCurrentTransitionStartTime);
+ }
+
+ private int calculateDelay(long timestamp) {
+ // Shouldn't take more than 25 days to launch an app, so int is fine here.
+ return (int) (timestamp - mCurrentTransitionStartTime);
+ }
+
+ private void logAppTransitionCancel(WindowingModeTransitionInfo info) {
+ final int type = getTransitionType(info);
+ if (type == INVALID_TRANSITION_TYPE) {
+ return;
+ }
+ final LogMaker builder = new LogMaker(APP_TRANSITION_CANCELLED);
+ builder.setPackageName(info.launchedActivity.packageName);
+ builder.setType(type);
+ builder.addTaggedData(FIELD_CLASS_NAME, info.launchedActivity.info.name);
+ mMetricsLogger.write(builder);
+ StatsLog.write(
+ StatsLog.APP_START_CANCELED,
+ info.launchedActivity.appInfo.uid,
+ info.launchedActivity.packageName,
+ convertAppStartTransitionType(type),
+ info.launchedActivity.info.name);
+ }
+
+ private void logAppTransitionMultiEvents() {
+ if (DEBUG_METRICS) Slog.i(TAG, "logging transition events");
+ for (int index = mWindowingModeTransitionInfo.size() - 1; index >= 0; index--) {
+ final WindowingModeTransitionInfo info = mWindowingModeTransitionInfo.valueAt(index);
+ final int type = getTransitionType(info);
+ if (type == INVALID_TRANSITION_TYPE) {
+ return;
+ }
+
+ // Take a snapshot of the transition info before sending it to the handler for logging.
+ // This will avoid any races with other operations that modify the ActivityRecord.
+ final WindowingModeTransitionInfoSnapshot infoSnapshot =
+ new WindowingModeTransitionInfoSnapshot(info);
+ final int currentTransitionDeviceUptime = mCurrentTransitionDeviceUptime;
+ final int currentTransitionDelayMs = mCurrentTransitionDelayMs;
+ BackgroundThread.getHandler().post(() -> logAppTransition(
+ currentTransitionDeviceUptime, currentTransitionDelayMs, infoSnapshot));
+ BackgroundThread.getHandler().post(() -> logAppDisplayed(infoSnapshot));
+
+ info.launchedActivity.info.launchToken = null;
+ }
+ }
+
+ // This gets called on a background thread without holding the activity manager lock.
+ private void logAppTransition(int currentTransitionDeviceUptime, int currentTransitionDelayMs,
+ WindowingModeTransitionInfoSnapshot info) {
+ final LogMaker builder = new LogMaker(APP_TRANSITION);
+ builder.setPackageName(info.packageName);
+ builder.setType(info.type);
+ builder.addTaggedData(FIELD_CLASS_NAME, info.launchedActivityName);
+ final boolean isInstantApp = info.applicationInfo.isInstantApp();
+ if (info.launchedActivityLaunchedFromPackage != null) {
+ builder.addTaggedData(APP_TRANSITION_CALLING_PACKAGE_NAME,
+ info.launchedActivityLaunchedFromPackage);
+ }
+ String launchToken = info.launchedActivityLaunchToken;
+ if (launchToken != null) {
+ builder.addTaggedData(FIELD_INSTANT_APP_LAUNCH_TOKEN, launchToken);
+ }
+ builder.addTaggedData(APP_TRANSITION_IS_EPHEMERAL, isInstantApp ? 1 : 0);
+ builder.addTaggedData(APP_TRANSITION_DEVICE_UPTIME_SECONDS,
+ currentTransitionDeviceUptime);
+ builder.addTaggedData(APP_TRANSITION_DELAY_MS, currentTransitionDelayMs);
+ builder.setSubtype(info.reason);
+ if (info.startingWindowDelayMs != INVALID_DELAY) {
+ builder.addTaggedData(APP_TRANSITION_STARTING_WINDOW_DELAY_MS,
+ info.startingWindowDelayMs);
+ }
+ if (info.bindApplicationDelayMs != INVALID_DELAY) {
+ builder.addTaggedData(APP_TRANSITION_BIND_APPLICATION_DELAY_MS,
+ info.bindApplicationDelayMs);
+ }
+ builder.addTaggedData(APP_TRANSITION_WINDOWS_DRAWN_DELAY_MS, info.windowsDrawnDelayMs);
+ final ArtManagerInternal artManagerInternal = getArtManagerInternal();
+ final PackageOptimizationInfo packageOptimizationInfo =
+ (artManagerInternal == null) || (info.launchedActivityAppRecordRequiredAbi == null)
+ ? PackageOptimizationInfo.createWithNoInfo()
+ : artManagerInternal.getPackageOptimizationInfo(
+ info.applicationInfo,
+ info.launchedActivityAppRecordRequiredAbi);
+ builder.addTaggedData(PACKAGE_OPTIMIZATION_COMPILATION_REASON,
+ packageOptimizationInfo.getCompilationReason());
+ builder.addTaggedData(PACKAGE_OPTIMIZATION_COMPILATION_FILTER,
+ packageOptimizationInfo.getCompilationFilter());
+ mMetricsLogger.write(builder);
+ StatsLog.write(
+ StatsLog.APP_START_OCCURRED,
+ info.applicationInfo.uid,
+ info.packageName,
+ convertAppStartTransitionType(info.type),
+ info.launchedActivityName,
+ info.launchedActivityLaunchedFromPackage,
+ isInstantApp,
+ currentTransitionDeviceUptime * 1000,
+ info.reason,
+ currentTransitionDelayMs,
+ info.startingWindowDelayMs,
+ info.bindApplicationDelayMs,
+ info.windowsDrawnDelayMs,
+ launchToken,
+ packageOptimizationInfo.getCompilationReason(),
+ packageOptimizationInfo.getCompilationFilter());
+ logAppStartMemoryStateCapture(info);
+ }
+
+ private void logAppDisplayed(WindowingModeTransitionInfoSnapshot info) {
+ if (info.type != TYPE_TRANSITION_WARM_LAUNCH && info.type != TYPE_TRANSITION_COLD_LAUNCH) {
+ return;
+ }
+
+ EventLog.writeEvent(AM_ACTIVITY_LAUNCH_TIME,
+ info.userId, info.activityRecordIdHashCode, info.launchedActivityShortComponentName,
+ info.windowsDrawnDelayMs);
+
+ StringBuilder sb = mStringBuilder;
+ sb.setLength(0);
+ sb.append("Displayed ");
+ sb.append(info.launchedActivityShortComponentName);
+ sb.append(": ");
+ TimeUtils.formatDuration(info.windowsDrawnDelayMs, sb);
+ Log.i(TAG, sb.toString());
+ }
+
+ private int convertAppStartTransitionType(int tronType) {
+ if (tronType == TYPE_TRANSITION_COLD_LAUNCH) {
+ return StatsLog.APP_START_OCCURRED__TYPE__COLD;
+ }
+ if (tronType == TYPE_TRANSITION_WARM_LAUNCH) {
+ return StatsLog.APP_START_OCCURRED__TYPE__WARM;
+ }
+ if (tronType == TYPE_TRANSITION_HOT_LAUNCH) {
+ return StatsLog.APP_START_OCCURRED__TYPE__HOT;
+ }
+ return StatsLog.APP_START_OCCURRED__TYPE__UNKNOWN;
+ }
+
+ WindowingModeTransitionInfoSnapshot logAppTransitionReportedDrawn(ActivityRecord r,
+ boolean restoredFromBundle) {
+ final WindowingModeTransitionInfo info = mLastWindowingModeTransitionInfo.get(
+ r.getWindowingMode());
+ if (info == null) {
+ return null;
+ }
+
+ // Record the handling of the reportFullyDrawn callback in the trace system. This is not
+ // actually used to trace this function, but instead the logical task that this function
+ // fullfils (handling reportFullyDrawn() callbacks).
+ Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER,
+ "ActivityManager:ReportingFullyDrawn " + info.launchedActivity.packageName);
+
+ final LogMaker builder = new LogMaker(APP_TRANSITION_REPORTED_DRAWN);
+ builder.setPackageName(r.packageName);
+ builder.addTaggedData(FIELD_CLASS_NAME, r.info.name);
+ long startupTimeMs = SystemClock.uptimeMillis() - mLastTransitionStartTime;
+ builder.addTaggedData(APP_TRANSITION_REPORTED_DRAWN_MS, startupTimeMs);
+ builder.setType(restoredFromBundle
+ ? TYPE_TRANSITION_REPORTED_DRAWN_WITH_BUNDLE
+ : TYPE_TRANSITION_REPORTED_DRAWN_NO_BUNDLE);
+ builder.addTaggedData(APP_TRANSITION_PROCESS_RUNNING,
+ info.currentTransitionProcessRunning ? 1 : 0);
+ mMetricsLogger.write(builder);
+ StatsLog.write(
+ StatsLog.APP_START_FULLY_DRAWN,
+ info.launchedActivity.appInfo.uid,
+ info.launchedActivity.packageName,
+ restoredFromBundle
+ ? StatsLog.APP_START_FULLY_DRAWN__TYPE__WITH_BUNDLE
+ : StatsLog.APP_START_FULLY_DRAWN__TYPE__WITHOUT_BUNDLE,
+ info.launchedActivity.info.name,
+ info.currentTransitionProcessRunning,
+ startupTimeMs);
+
+ // Ends the trace started at the beginning of this function. This is located here to allow
+ // the trace slice to have a noticable duration.
+ Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
+
+ final WindowingModeTransitionInfoSnapshot infoSnapshot =
+ new WindowingModeTransitionInfoSnapshot(info, r, (int) startupTimeMs);
+ BackgroundThread.getHandler().post(() -> logAppFullyDrawn(infoSnapshot));
+ return infoSnapshot;
+ }
+
+ private void logAppFullyDrawn(WindowingModeTransitionInfoSnapshot info) {
+ if (info.type != TYPE_TRANSITION_WARM_LAUNCH && info.type != TYPE_TRANSITION_COLD_LAUNCH) {
+ return;
+ }
+
+ StringBuilder sb = mStringBuilder;
+ sb.setLength(0);
+ sb.append("Fully drawn ");
+ sb.append(info.launchedActivityShortComponentName);
+ sb.append(": ");
+ TimeUtils.formatDuration(info.windowsFullyDrawnDelayMs, sb);
+ Log.i(TAG, sb.toString());
+ }
+
+ void logActivityStart(Intent intent, WindowProcessController callerApp, ActivityRecord r,
+ int callingUid, String callingPackage, int callingUidProcState,
+ boolean callingUidHasAnyVisibleWindow,
+ int realCallingUid, int realCallingUidProcState,
+ boolean realCallingUidHasAnyVisibleWindow,
+ int targetUid, String targetPackage, int targetUidProcState,
+ boolean targetUidHasAnyVisibleWindow, String targetWhitelistTag,
+ boolean comingFromPendingIntent) {
+
+ final long nowElapsed = SystemClock.elapsedRealtime();
+ final long nowUptime = SystemClock.uptimeMillis();
+ final LogMaker builder = new LogMaker(ACTION_ACTIVITY_START);
+ builder.setTimestamp(System.currentTimeMillis());
+ builder.addTaggedData(FIELD_CALLING_UID, callingUid);
+ builder.addTaggedData(FIELD_CALLING_PACKAGE_NAME, callingPackage);
+ builder.addTaggedData(FIELD_CALLING_UID_PROC_STATE,
+ processStateAmToProto(callingUidProcState));
+ builder.addTaggedData(FIELD_CALLING_UID_HAS_ANY_VISIBLE_WINDOW,
+ callingUidHasAnyVisibleWindow ? 1 : 0);
+ builder.addTaggedData(FIELD_REAL_CALLING_UID, realCallingUid);
+ builder.addTaggedData(FIELD_REAL_CALLING_UID_PROC_STATE,
+ processStateAmToProto(realCallingUidProcState));
+ builder.addTaggedData(FIELD_REAL_CALLING_UID_HAS_ANY_VISIBLE_WINDOW,
+ realCallingUidHasAnyVisibleWindow ? 1 : 0);
+ builder.addTaggedData(FIELD_TARGET_UID, targetUid);
+ builder.addTaggedData(FIELD_TARGET_PACKAGE_NAME, targetPackage);
+ builder.addTaggedData(FIELD_TARGET_UID_PROC_STATE,
+ processStateAmToProto(targetUidProcState));
+ builder.addTaggedData(FIELD_TARGET_UID_HAS_ANY_VISIBLE_WINDOW,
+ targetUidHasAnyVisibleWindow ? 1 : 0);
+ builder.addTaggedData(FIELD_TARGET_WHITELIST_TAG, targetWhitelistTag);
+ builder.addTaggedData(FIELD_TARGET_SHORT_COMPONENT_NAME, r.shortComponentName);
+ builder.addTaggedData(FIELD_COMING_FROM_PENDING_INTENT, comingFromPendingIntent ? 1 : 0);
+ builder.addTaggedData(FIELD_INTENT_ACTION, intent.getAction());
+ if (callerApp != null) {
+ builder.addTaggedData(FIELD_PROCESS_RECORD_PROCESS_NAME, callerApp.mName);
+ builder.addTaggedData(FIELD_PROCESS_RECORD_CUR_PROC_STATE,
+ processStateAmToProto(callerApp.getCurrentProcState()));
+ builder.addTaggedData(FIELD_PROCESS_RECORD_HAS_CLIENT_ACTIVITIES,
+ callerApp.hasClientActivities() ? 1 : 0);
+ builder.addTaggedData(FIELD_PROCESS_RECORD_HAS_FOREGROUND_SERVICES,
+ callerApp.hasForegroundServices() ? 1 : 0);
+ builder.addTaggedData(FIELD_PROCESS_RECORD_HAS_FOREGROUND_ACTIVITIES,
+ callerApp.hasForegroundActivities() ? 1 : 0);
+ builder.addTaggedData(FIELD_PROCESS_RECORD_HAS_TOP_UI, callerApp.hasTopUi() ? 1 : 0);
+ builder.addTaggedData(FIELD_PROCESS_RECORD_HAS_OVERLAY_UI,
+ callerApp.hasOverlayUi() ? 1 : 0);
+ builder.addTaggedData(FIELD_PROCESS_RECORD_PENDING_UI_CLEAN,
+ callerApp.hasPendingUiClean() ? 1 : 0);
+ if (callerApp.getInteractionEventTime() != 0) {
+ builder.addTaggedData(FIELD_PROCESS_RECORD_MILLIS_SINCE_LAST_INTERACTION_EVENT,
+ (nowElapsed - callerApp.getInteractionEventTime()));
+ }
+ if (callerApp.getFgInteractionTime() != 0) {
+ builder.addTaggedData(FIELD_PROCESS_RECORD_MILLIS_SINCE_FG_INTERACTION,
+ (nowElapsed - callerApp.getFgInteractionTime()));
+ }
+ if (callerApp.getWhenUnimportant() != 0) {
+ builder.addTaggedData(FIELD_PROCESS_RECORD_MILLIS_SINCE_UNIMPORTANT,
+ (nowUptime - callerApp.getWhenUnimportant()));
+ }
+ }
+ builder.addTaggedData(FIELD_ACTIVITY_RECORD_LAUNCH_MODE, r.info.launchMode);
+ builder.addTaggedData(FIELD_ACTIVITY_RECORD_TARGET_ACTIVITY, r.info.targetActivity);
+ builder.addTaggedData(FIELD_ACTIVITY_RECORD_FLAGS, r.info.flags);
+ builder.addTaggedData(FIELD_ACTIVITY_RECORD_REAL_ACTIVITY, r.realActivity.toShortString());
+ builder.addTaggedData(FIELD_ACTIVITY_RECORD_SHORT_COMPONENT_NAME, r.shortComponentName);
+ builder.addTaggedData(FIELD_ACTIVITY_RECORD_PROCESS_NAME, r.processName);
+ builder.addTaggedData(FIELD_ACTIVITY_RECORD_IS_FULLSCREEN, r.fullscreen ? 1 : 0);
+ builder.addTaggedData(FIELD_ACTIVITY_RECORD_IS_NO_DISPLAY, r.noDisplay ? 1 : 0);
+ if (r.lastVisibleTime != 0) {
+ builder.addTaggedData(FIELD_ACTIVITY_RECORD_MILLIS_SINCE_LAST_VISIBLE,
+ (nowUptime - r.lastVisibleTime));
+ }
+ if (r.resultTo != null) {
+ builder.addTaggedData(FIELD_ACTIVITY_RECORD_RESULT_TO_PKG_NAME, r.resultTo.packageName);
+ builder.addTaggedData(FIELD_ACTIVITY_RECORD_RESULT_TO_SHORT_COMPONENT_NAME,
+ r.resultTo.shortComponentName);
+ }
+ builder.addTaggedData(FIELD_ACTIVITY_RECORD_IS_VISIBLE, r.visible ? 1 : 0);
+ builder.addTaggedData(FIELD_ACTIVITY_RECORD_IS_VISIBLE_IGNORING_KEYGUARD,
+ r.visibleIgnoringKeyguard ? 1 : 0);
+ if (r.lastLaunchTime != 0) {
+ builder.addTaggedData(FIELD_ACTIVITY_RECORD_MILLIS_SINCE_LAST_LAUNCH,
+ (nowUptime - r.lastLaunchTime));
+ }
+ mMetricsLogger.write(builder);
+ }
+
+ private int getTransitionType(WindowingModeTransitionInfo info) {
+ if (info.currentTransitionProcessRunning) {
+ if (info.startResult == START_SUCCESS) {
+ return TYPE_TRANSITION_WARM_LAUNCH;
+ } else if (info.startResult == START_TASK_TO_FRONT) {
+ return TYPE_TRANSITION_HOT_LAUNCH;
+ }
+ } else if (info.startResult == START_SUCCESS) {
+ return TYPE_TRANSITION_COLD_LAUNCH;
+ }
+ return INVALID_TRANSITION_TYPE;
+ }
+
+ private void logAppStartMemoryStateCapture(WindowingModeTransitionInfoSnapshot info) {
+ if (info.processRecord == null) {
+ if (DEBUG_METRICS) Slog.i(TAG, "logAppStartMemoryStateCapture processRecord null");
+ return;
+ }
+
+ final int pid = info.processRecord.getPid();
+ final int uid = info.applicationInfo.uid;
+ final MemoryStat memoryStat = readMemoryStatFromFilesystem(uid, pid);
+ if (memoryStat == null) {
+ if (DEBUG_METRICS) Slog.i(TAG, "logAppStartMemoryStateCapture memoryStat null");
+ return;
+ }
+
+ StatsLog.write(
+ StatsLog.APP_START_MEMORY_STATE_CAPTURED,
+ uid,
+ info.processName,
+ info.launchedActivityName,
+ memoryStat.pgfault,
+ memoryStat.pgmajfault,
+ memoryStat.rssInBytes,
+ memoryStat.cacheInBytes,
+ memoryStat.swapInBytes);
+ }
+
+ private WindowProcessController findProcessForActivity(ActivityRecord launchedActivity) {
+ return launchedActivity != null
+ ? mSupervisor.mService.mProcessNames.get(
+ launchedActivity.processName, launchedActivity.appInfo.uid)
+ : null;
+ }
+
+ private ArtManagerInternal getArtManagerInternal() {
+ if (mArtManagerInternal == null) {
+ // Note that this may be null.
+ // ArtManagerInternal is registered during PackageManagerService
+ // initialization which happens after ActivityManagerService.
+ mArtManagerInternal = LocalServices.getService(ArtManagerInternal.class);
+ }
+ return mArtManagerInternal;
+ }
+
+ /**
+ * Starts traces for app launch.
+ *
+ * @param info
+ * */
+ private void startTraces(WindowingModeTransitionInfo info) {
+ if (info == null) {
+ return;
+ }
+ int transitionType = getTransitionType(info);
+ if (!info.launchTraceActive && transitionType == TYPE_TRANSITION_WARM_LAUNCH
+ || transitionType == TYPE_TRANSITION_COLD_LAUNCH) {
+ Trace.asyncTraceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "launching: "
+ + info.launchedActivity.packageName, 0);
+ info.launchTraceActive = true;
+ }
+ }
+
+ private void stopLaunchTrace(WindowingModeTransitionInfo info) {
+ if (info == null) {
+ return;
+ }
+ if (info.launchTraceActive) {
+ Trace.asyncTraceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER, "launching: "
+ + info.launchedActivity.packageName, 0);
+ info.launchTraceActive = false;
+ }
+ }
+}
diff --git a/services/core/java/com/android/server/wm/ActivityRecord.java b/services/core/java/com/android/server/wm/ActivityRecord.java
new file mode 100644
index 0000000..8223693
--- /dev/null
+++ b/services/core/java/com/android/server/wm/ActivityRecord.java
@@ -0,0 +1,2956 @@
+/*
+ * Copyright (C) 2006 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.server.wm;
+
+import static android.app.ActivityManager.LOCK_TASK_MODE_NONE;
+import static android.app.ActivityManager.TaskDescription.ATTR_TASKDESCRIPTION_PREFIX;
+import static android.app.ActivityOptions.ANIM_SCENE_TRANSITION;
+import static android.app.ActivityTaskManager.INVALID_STACK_ID;
+import static android.app.AppOpsManager.MODE_ALLOWED;
+import static android.app.AppOpsManager.OP_PICTURE_IN_PICTURE;
+import static android.app.WaitResult.INVALID_DELAY;
+import static android.app.WindowConfiguration.ACTIVITY_TYPE_ASSISTANT;
+import static android.app.WindowConfiguration.ACTIVITY_TYPE_HOME;
+import static android.app.WindowConfiguration.ACTIVITY_TYPE_RECENTS;
+import static android.app.WindowConfiguration.ACTIVITY_TYPE_UNDEFINED;
+import static android.app.WindowConfiguration.activityTypeToString;
+import static android.content.Intent.ACTION_MAIN;
+import static android.content.Intent.CATEGORY_HOME;
+import static android.content.Intent.CATEGORY_LAUNCHER;
+import static android.content.Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS;
+import static android.content.Intent.FLAG_ACTIVITY_NO_HISTORY;
+import static android.content.pm.ActivityInfo.CONFIG_ORIENTATION;
+import static android.content.pm.ActivityInfo.CONFIG_SCREEN_LAYOUT;
+import static android.content.pm.ActivityInfo.CONFIG_SCREEN_SIZE;
+import static android.content.pm.ActivityInfo.CONFIG_SMALLEST_SCREEN_SIZE;
+import static android.content.pm.ActivityInfo.CONFIG_UI_MODE;
+import static android.content.pm.ActivityInfo.CONFIG_WINDOW_CONFIGURATION;
+import static android.content.pm.ActivityInfo.FLAG_ALWAYS_FOCUSABLE;
+import static android.content.pm.ActivityInfo.FLAG_EXCLUDE_FROM_RECENTS;
+import static android.content.pm.ActivityInfo.FLAG_IMMERSIVE;
+import static android.content.pm.ActivityInfo.FLAG_MULTIPROCESS;
+import static android.content.pm.ActivityInfo.FLAG_NO_HISTORY;
+import static android.content.pm.ActivityInfo.FLAG_SHOW_FOR_ALL_USERS;
+import static android.content.pm.ActivityInfo.FLAG_SHOW_WHEN_LOCKED;
+import static android.content.pm.ActivityInfo.FLAG_STATE_NOT_NEEDED;
+import static android.content.pm.ActivityInfo.FLAG_TURN_SCREEN_ON;
+import static android.content.pm.ActivityInfo.LAUNCH_MULTIPLE;
+import static android.content.pm.ActivityInfo.LAUNCH_SINGLE_INSTANCE;
+import static android.content.pm.ActivityInfo.LAUNCH_SINGLE_TASK;
+import static android.content.pm.ActivityInfo.LAUNCH_SINGLE_TOP;
+import static android.content.pm.ActivityInfo.LOCK_TASK_LAUNCH_MODE_ALWAYS;
+import static android.content.pm.ActivityInfo.LOCK_TASK_LAUNCH_MODE_DEFAULT;
+import static android.content.pm.ActivityInfo.LOCK_TASK_LAUNCH_MODE_IF_WHITELISTED;
+import static android.content.pm.ActivityInfo.LOCK_TASK_LAUNCH_MODE_NEVER;
+import static android.content.pm.ActivityInfo.PERSIST_ACROSS_REBOOTS;
+import static android.content.pm.ActivityInfo.PERSIST_ROOT_ONLY;
+import static android.content.pm.ActivityInfo.RESIZE_MODE_FORCE_RESIZEABLE;
+import static android.content.pm.ActivityInfo.RESIZE_MODE_RESIZEABLE;
+import static android.content.pm.ActivityInfo.RESIZE_MODE_RESIZEABLE_VIA_SDK_VERSION;
+import static android.content.pm.ActivityInfo.RESIZE_MODE_UNRESIZEABLE;
+import static android.content.pm.ActivityInfo.isFixedOrientationLandscape;
+import static android.content.pm.ActivityInfo.isFixedOrientationPortrait;
+import static android.content.res.Configuration.EMPTY;
+import static android.content.res.Configuration.ORIENTATION_LANDSCAPE;
+import static android.content.res.Configuration.ORIENTATION_PORTRAIT;
+import static android.content.res.Configuration.UI_MODE_TYPE_MASK;
+import static android.content.res.Configuration.UI_MODE_TYPE_VR_HEADSET;
+import static android.os.Build.VERSION_CODES.HONEYCOMB;
+import static android.os.Build.VERSION_CODES.O;
+import static android.os.Process.SYSTEM_UID;
+import static android.view.Display.INVALID_DISPLAY;
+import static android.view.WindowManagerPolicyConstants.NAV_BAR_LEFT;
+
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_CONFIGURATION;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_FOCUS;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_SAVED_STATE;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_STATES;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_SWITCH;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_VISIBILITY;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_CONFIGURATION;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_FOCUS;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_SAVED_STATE;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_STATES;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_SWITCH;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_VISIBILITY;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_ATM;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_WITH_CLASS_NAME;
+import static com.android.server.am.ActivityRecordProto.CONFIGURATION_CONTAINER;
+import static com.android.server.am.ActivityRecordProto.FRONT_OF_TASK;
+import static com.android.server.am.ActivityRecordProto.IDENTIFIER;
+import static com.android.server.am.ActivityRecordProto.PROC_ID;
+import static com.android.server.am.ActivityRecordProto.STATE;
+import static com.android.server.am.ActivityRecordProto.TRANSLUCENT;
+import static com.android.server.am.ActivityRecordProto.VISIBLE;
+import static com.android.server.wm.ActivityStack.ActivityState.INITIALIZING;
+import static com.android.server.wm.ActivityStack.ActivityState.PAUSED;
+import static com.android.server.wm.ActivityStack.ActivityState.PAUSING;
+import static com.android.server.wm.ActivityStack.ActivityState.RESUMED;
+import static com.android.server.wm.ActivityStack.ActivityState.STOPPED;
+import static com.android.server.wm.ActivityStack.ActivityState.STOPPING;
+import static com.android.server.wm.ActivityStack.LAUNCH_TICK;
+import static com.android.server.wm.ActivityStack.LAUNCH_TICK_MSG;
+import static com.android.server.wm.ActivityStack.PAUSE_TIMEOUT_MSG;
+import static com.android.server.wm.ActivityStack.STOP_TIMEOUT_MSG;
+import static com.android.server.wm.ActivityTaskManagerService.RELAUNCH_REASON_FREE_RESIZE;
+import static com.android.server.wm.ActivityTaskManagerService.RELAUNCH_REASON_NONE;
+import static com.android.server.wm.ActivityTaskManagerService.RELAUNCH_REASON_WINDOWING_MODE_RESIZE;
+import static com.android.server.am.EventLogTags.AM_RELAUNCH_ACTIVITY;
+import static com.android.server.am.EventLogTags.AM_RELAUNCH_RESUME_ACTIVITY;
+import static com.android.server.wm.TaskPersister.DEBUG;
+import static com.android.server.wm.TaskPersister.IMAGE_EXTENSION;
+import static android.app.ActivityTaskManager.INVALID_TASK_ID;
+import static com.android.server.wm.IdentifierProto.HASH_CODE;
+import static com.android.server.wm.IdentifierProto.TITLE;
+import static com.android.server.wm.IdentifierProto.USER_ID;
+
+import static org.xmlpull.v1.XmlPullParser.END_DOCUMENT;
+import static org.xmlpull.v1.XmlPullParser.END_TAG;
+import static org.xmlpull.v1.XmlPullParser.START_TAG;
+
+import android.annotation.NonNull;
+import android.app.ActivityManager.TaskDescription;
+import android.app.ActivityOptions;
+import android.app.PendingIntent;
+import android.app.PictureInPictureParams;
+import android.app.ResultInfo;
+import android.app.servertransaction.ActivityConfigurationChangeItem;
+import android.app.servertransaction.ActivityLifecycleItem;
+import android.app.servertransaction.ActivityRelaunchItem;
+import android.app.servertransaction.ClientTransaction;
+import android.app.servertransaction.ClientTransactionItem;
+import android.app.servertransaction.MoveToDisplayItem;
+import android.app.servertransaction.MultiWindowModeChangeItem;
+import android.app.servertransaction.NewIntentItem;
+import android.app.servertransaction.PauseActivityItem;
+import android.app.servertransaction.PipModeChangeItem;
+import android.app.servertransaction.ResumeActivityItem;
+import android.app.servertransaction.WindowVisibilityItem;
+import android.content.ComponentName;
+import android.content.Intent;
+import android.content.pm.ActivityInfo;
+import android.content.pm.ApplicationInfo;
+import android.content.res.CompatibilityInfo;
+import android.content.res.Configuration;
+import android.graphics.Bitmap;
+import android.graphics.Rect;
+import android.os.Binder;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.Debug;
+import android.os.IBinder;
+import android.os.Message;
+import android.os.PersistableBundle;
+import android.os.Process;
+import android.os.RemoteException;
+import android.os.SystemClock;
+import android.os.UserHandle;
+import android.os.storage.StorageManager;
+import android.service.voice.IVoiceInteractionSession;
+import android.util.EventLog;
+import android.util.Log;
+import android.util.MergedConfiguration;
+import android.util.Slog;
+import android.util.TimeUtils;
+import android.util.proto.ProtoOutputStream;
+import android.view.IApplicationToken;
+import android.view.RemoteAnimationDefinition;
+import android.view.WindowManager.LayoutParams;
+
+import com.android.internal.R;
+import com.android.internal.app.ResolverActivity;
+import com.android.internal.content.ReferrerIntent;
+import com.android.internal.util.XmlUtils;
+import com.android.server.AttributeCache;
+import com.android.server.AttributeCache.Entry;
+import com.android.server.am.AppTimeTracker;
+import com.android.server.am.PendingIntentRecord;
+import com.android.server.wm.ActivityMetricsLogger.WindowingModeTransitionInfoSnapshot;
+import com.android.server.wm.ActivityStack.ActivityState;
+import com.android.server.uri.UriPermissionOwner;
+
+import org.xmlpull.v1.XmlPullParser;
+import org.xmlpull.v1.XmlPullParserException;
+import org.xmlpull.v1.XmlSerializer;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Objects;
+
+/**
+ * An entry in the history stack, representing an activity.
+ */
+final class ActivityRecord extends ConfigurationContainer implements AppWindowContainerListener {
+ private static final String TAG = TAG_WITH_CLASS_NAME ? "ActivityRecord" : TAG_ATM;
+ private static final String TAG_CONFIGURATION = TAG + POSTFIX_CONFIGURATION;
+ private static final String TAG_SAVED_STATE = TAG + POSTFIX_SAVED_STATE;
+ private static final String TAG_STATES = TAG + POSTFIX_STATES;
+ private static final String TAG_SWITCH = TAG + POSTFIX_SWITCH;
+ private static final String TAG_VISIBILITY = TAG + POSTFIX_VISIBILITY;
+ private static final String TAG_FOCUS = TAG + POSTFIX_FOCUS;
+ // TODO(b/67864419): Remove once recents component is overridden
+ private static final String LEGACY_RECENTS_PACKAGE_NAME = "com.android.systemui.recents";
+
+ private static final boolean SHOW_ACTIVITY_START_TIME = true;
+
+ private static final String ATTR_ID = "id";
+ private static final String TAG_INTENT = "intent";
+ private static final String ATTR_USERID = "user_id";
+ private static final String TAG_PERSISTABLEBUNDLE = "persistable_bundle";
+ private static final String ATTR_LAUNCHEDFROMUID = "launched_from_uid";
+ private static final String ATTR_LAUNCHEDFROMPACKAGE = "launched_from_package";
+ private static final String ATTR_RESOLVEDTYPE = "resolved_type";
+ private static final String ATTR_COMPONENTSPECIFIED = "component_specified";
+ static final String ACTIVITY_ICON_SUFFIX = "_activity_icon_";
+
+ final ActivityTaskManagerService service; // owner
+ final IApplicationToken.Stub appToken; // window manager token
+ AppWindowContainerController mWindowContainerController;
+ final ActivityInfo info; // all about me
+ // TODO: This is duplicated state already contained in info.applicationInfo - remove
+ ApplicationInfo appInfo; // information about activity's app
+ final int launchedFromPid; // always the pid who started the activity.
+ final int launchedFromUid; // always the uid who started the activity.
+ final String launchedFromPackage; // always the package who started the activity.
+ final int userId; // Which user is this running for?
+ final Intent intent; // the original intent that generated us
+ final ComponentName realActivity; // the intent component, or target of an alias.
+ final String shortComponentName; // the short component name of the intent
+ final String resolvedType; // as per original caller;
+ final String packageName; // the package implementing intent's component
+ final String processName; // process where this component wants to run
+ final String taskAffinity; // as per ActivityInfo.taskAffinity
+ final boolean stateNotNeeded; // As per ActivityInfo.flags
+ boolean fullscreen; // The activity is opaque and fills the entire space of this task.
+ // TODO: See if it possible to combine this with the fullscreen field.
+ final boolean hasWallpaper; // Has a wallpaper window as a background.
+ final boolean noDisplay; // activity is not displayed?
+ private final boolean componentSpecified; // did caller specify an explicit component?
+ final boolean rootVoiceInteraction; // was this the root activity of a voice interaction?
+
+ private CharSequence nonLocalizedLabel; // the label information from the package mgr.
+ private int labelRes; // the label information from the package mgr.
+ private int icon; // resource identifier of activity's icon.
+ private int logo; // resource identifier of activity's logo.
+ private int theme; // resource identifier of activity's theme.
+ private int realTheme; // actual theme resource we will use, never 0.
+ private int windowFlags; // custom window flags for preview window.
+ private TaskRecord task; // the task this is in.
+ private long createTime = System.currentTimeMillis();
+ long lastVisibleTime; // last time this activity became visible
+ long cpuTimeAtResume; // the cpu time of host process at the time of resuming activity
+ long pauseTime; // last time we started pausing the activity
+ long launchTickTime; // base time for launch tick messages
+ // Last configuration reported to the activity in the client process.
+ private MergedConfiguration mLastReportedConfiguration;
+ private int mLastReportedDisplayId;
+ private boolean mLastReportedMultiWindowMode;
+ private boolean mLastReportedPictureInPictureMode;
+ CompatibilityInfo compat;// last used compatibility mode
+ ActivityRecord resultTo; // who started this entry, so will get our reply
+ final String resultWho; // additional identifier for use by resultTo.
+ final int requestCode; // code given by requester (resultTo)
+ ArrayList<ResultInfo> results; // pending ActivityResult objs we have received
+ HashSet<WeakReference<PendingIntentRecord>> pendingResults; // all pending intents for this act
+ ArrayList<ReferrerIntent> newIntents; // any pending new intents for single-top mode
+ ActivityOptions pendingOptions; // most recently given options
+ ActivityOptions returningOptions; // options that are coming back via convertToTranslucent
+ AppTimeTracker appTimeTracker; // set if we are tracking the time in this app/task/activity
+ ActivityServiceConnectionsHolder mServiceConnectionsHolder; // Service connections.
+ UriPermissionOwner uriPermissions; // current special URI access perms.
+ WindowProcessController app; // if non-null, hosting application
+ private ActivityState mState; // current state we are in
+ Bundle icicle; // last saved activity state
+ PersistableBundle persistentState; // last persistently saved activity state
+ // TODO: See if this is still needed.
+ boolean frontOfTask; // is this the root activity of its task?
+ boolean launchFailed; // set if a launched failed, to abort on 2nd try
+ boolean haveState; // have we gotten the last activity state?
+ boolean stopped; // is activity pause finished?
+ boolean delayedResume; // not yet resumed because of stopped app switches?
+ boolean finishing; // activity in pending finish list?
+ boolean deferRelaunchUntilPaused; // relaunch of activity is being deferred until pause is
+ // completed
+ boolean preserveWindowOnDeferredRelaunch; // activity windows are preserved on deferred relaunch
+ int configChangeFlags; // which config values have changed
+ private boolean keysPaused; // has key dispatching been paused for it?
+ int launchMode; // the launch mode activity attribute.
+ int lockTaskLaunchMode; // the lockTaskMode manifest attribute, subject to override
+ boolean visible; // does this activity's window need to be shown?
+ boolean visibleIgnoringKeyguard; // is this activity visible, ignoring the fact that Keyguard
+ // might hide this activity?
+ private boolean mDeferHidingClient; // If true we told WM to defer reporting to the client
+ // process that it is hidden.
+ boolean sleeping; // have we told the activity to sleep?
+ boolean nowVisible; // is this activity's window visible?
+ boolean mClientVisibilityDeferred;// was the visibility change message to client deferred?
+ boolean idle; // has the activity gone idle?
+ boolean hasBeenLaunched;// has this activity ever been launched?
+ boolean frozenBeforeDestroy;// has been frozen but not yet destroyed.
+ boolean immersive; // immersive mode (don't interrupt if possible)
+ boolean forceNewConfig; // force re-create with new config next time
+ boolean supportsEnterPipOnTaskSwitch; // This flag is set by the system to indicate that the
+ // activity can enter picture in picture while pausing (only when switching to another task)
+ PictureInPictureParams pictureInPictureArgs = new PictureInPictureParams.Builder().build();
+ // The PiP params used when deferring the entering of picture-in-picture.
+ int launchCount; // count of launches since last state
+ long lastLaunchTime; // time of last launch of this activity
+ ComponentName requestedVrComponent; // the requested component for handling VR mode.
+
+ String stringName; // for caching of toString().
+
+ private boolean inHistory; // are we in the history stack?
+ final ActivityStackSupervisor mStackSupervisor;
+
+ static final int STARTING_WINDOW_NOT_SHOWN = 0;
+ static final int STARTING_WINDOW_SHOWN = 1;
+ static final int STARTING_WINDOW_REMOVED = 2;
+ int mStartingWindowState = STARTING_WINDOW_NOT_SHOWN;
+ boolean mTaskOverlay = false; // Task is always on-top of other activities in the task.
+
+ // Marking the reason why this activity is being relaunched. Mainly used to track that this
+ // activity is being relaunched to fulfill a resize request due to compatibility issues, e.g. in
+ // pre-NYC apps that don't have a sense of being resized.
+ int mRelaunchReason = RELAUNCH_REASON_NONE;
+
+ TaskDescription taskDescription; // the recents information for this activity
+ boolean mLaunchTaskBehind; // this activity is actively being launched with
+ // ActivityOptions.setLaunchTaskBehind, will be cleared once launch is completed.
+
+ // These configurations are collected from application's resources based on size-sensitive
+ // qualifiers. For example, layout-w800dp will be added to mHorizontalSizeConfigurations as 800
+ // and drawable-sw400dp will be added to both as 400.
+ private int[] mVerticalSizeConfigurations;
+ private int[] mHorizontalSizeConfigurations;
+ private int[] mSmallestSizeConfigurations;
+
+ boolean pendingVoiceInteractionStart; // Waiting for activity-invoked voice session
+ IVoiceInteractionSession voiceSession; // Voice interaction session for this activity
+
+ // A hint to override the window specified rotation animation, or -1
+ // to use the window specified value. We use this so that
+ // we can select the right animation in the cases of starting
+ // windows, where the app hasn't had time to set a value
+ // on the window.
+ int mRotationAnimationHint = -1;
+
+ private boolean mShowWhenLocked;
+ private boolean mTurnScreenOn;
+
+ /**
+ * Temp configs used in {@link #ensureActivityConfiguration(int, boolean)}
+ */
+ private final Configuration mTmpConfig = new Configuration();
+ private final Rect mTmpBounds = new Rect();
+
+ private static String startingWindowStateToString(int state) {
+ switch (state) {
+ case STARTING_WINDOW_NOT_SHOWN:
+ return "STARTING_WINDOW_NOT_SHOWN";
+ case STARTING_WINDOW_SHOWN:
+ return "STARTING_WINDOW_SHOWN";
+ case STARTING_WINDOW_REMOVED:
+ return "STARTING_WINDOW_REMOVED";
+ default:
+ return "unknown state=" + state;
+ }
+ }
+
+ void dump(PrintWriter pw, String prefix) {
+ final long now = SystemClock.uptimeMillis();
+ pw.print(prefix); pw.print("packageName="); pw.print(packageName);
+ pw.print(" processName="); pw.println(processName);
+ pw.print(prefix); pw.print("launchedFromUid="); pw.print(launchedFromUid);
+ pw.print(" launchedFromPackage="); pw.print(launchedFromPackage);
+ pw.print(" userId="); pw.println(userId);
+ pw.print(prefix); pw.print("app="); pw.println(app);
+ pw.print(prefix); pw.println(intent.toInsecureStringWithClip());
+ pw.print(prefix); pw.print("frontOfTask="); pw.print(frontOfTask);
+ pw.print(" task="); pw.println(task);
+ pw.print(prefix); pw.print("taskAffinity="); pw.println(taskAffinity);
+ pw.print(prefix); pw.print("realActivity=");
+ pw.println(realActivity.flattenToShortString());
+ if (appInfo != null) {
+ pw.print(prefix); pw.print("baseDir="); pw.println(appInfo.sourceDir);
+ if (!Objects.equals(appInfo.sourceDir, appInfo.publicSourceDir)) {
+ pw.print(prefix); pw.print("resDir="); pw.println(appInfo.publicSourceDir);
+ }
+ pw.print(prefix); pw.print("dataDir="); pw.println(appInfo.dataDir);
+ if (appInfo.splitSourceDirs != null) {
+ pw.print(prefix); pw.print("splitDir=");
+ pw.println(Arrays.toString(appInfo.splitSourceDirs));
+ }
+ }
+ pw.print(prefix); pw.print("stateNotNeeded="); pw.print(stateNotNeeded);
+ pw.print(" componentSpecified="); pw.print(componentSpecified);
+ pw.print(" mActivityType="); pw.println(
+ activityTypeToString(getActivityType()));
+ if (rootVoiceInteraction) {
+ pw.print(prefix); pw.print("rootVoiceInteraction="); pw.println(rootVoiceInteraction);
+ }
+ pw.print(prefix); pw.print("compat="); pw.print(compat);
+ pw.print(" labelRes=0x"); pw.print(Integer.toHexString(labelRes));
+ pw.print(" icon=0x"); pw.print(Integer.toHexString(icon));
+ pw.print(" theme=0x"); pw.println(Integer.toHexString(theme));
+ pw.println(prefix + "mLastReportedConfigurations:");
+ mLastReportedConfiguration.dump(pw, prefix + " ");
+
+ pw.print(prefix); pw.print("CurrentConfiguration="); pw.println(getConfiguration());
+ if (!getOverrideConfiguration().equals(EMPTY)) {
+ pw.println(prefix + "OverrideConfiguration=" + getOverrideConfiguration());
+ }
+ if (!matchParentBounds()) {
+ pw.println(prefix + "bounds=" + getBounds());
+ }
+ if (resultTo != null || resultWho != null) {
+ pw.print(prefix); pw.print("resultTo="); pw.print(resultTo);
+ pw.print(" resultWho="); pw.print(resultWho);
+ pw.print(" resultCode="); pw.println(requestCode);
+ }
+ if (taskDescription != null) {
+ final String iconFilename = taskDescription.getIconFilename();
+ if (iconFilename != null || taskDescription.getLabel() != null ||
+ taskDescription.getPrimaryColor() != 0) {
+ pw.print(prefix); pw.print("taskDescription:");
+ pw.print(" label=\""); pw.print(taskDescription.getLabel());
+ pw.print("\"");
+ pw.print(" icon="); pw.print(taskDescription.getInMemoryIcon() != null
+ ? taskDescription.getInMemoryIcon().getByteCount() + " bytes"
+ : "null");
+ pw.print(" iconResource="); pw.print(taskDescription.getIconResource());
+ pw.print(" iconFilename="); pw.print(taskDescription.getIconFilename());
+ pw.print(" primaryColor=");
+ pw.println(Integer.toHexString(taskDescription.getPrimaryColor()));
+ pw.print(prefix + " backgroundColor=");
+ pw.println(Integer.toHexString(taskDescription.getBackgroundColor()));
+ pw.print(prefix + " statusBarColor=");
+ pw.println(Integer.toHexString(taskDescription.getStatusBarColor()));
+ pw.print(prefix + " navigationBarColor=");
+ pw.println(Integer.toHexString(taskDescription.getNavigationBarColor()));
+ }
+ }
+ if (results != null) {
+ pw.print(prefix); pw.print("results="); pw.println(results);
+ }
+ if (pendingResults != null && pendingResults.size() > 0) {
+ pw.print(prefix); pw.println("Pending Results:");
+ for (WeakReference<PendingIntentRecord> wpir : pendingResults) {
+ PendingIntentRecord pir = wpir != null ? wpir.get() : null;
+ pw.print(prefix); pw.print(" - ");
+ if (pir == null) {
+ pw.println("null");
+ } else {
+ pw.println(pir);
+ pir.dump(pw, prefix + " ");
+ }
+ }
+ }
+ if (newIntents != null && newIntents.size() > 0) {
+ pw.print(prefix); pw.println("Pending New Intents:");
+ for (int i=0; i<newIntents.size(); i++) {
+ Intent intent = newIntents.get(i);
+ pw.print(prefix); pw.print(" - ");
+ if (intent == null) {
+ pw.println("null");
+ } else {
+ pw.println(intent.toShortString(false, true, false, true));
+ }
+ }
+ }
+ if (pendingOptions != null) {
+ pw.print(prefix); pw.print("pendingOptions="); pw.println(pendingOptions);
+ }
+ if (appTimeTracker != null) {
+ appTimeTracker.dumpWithHeader(pw, prefix, false);
+ }
+ if (uriPermissions != null) {
+ uriPermissions.dump(pw, prefix);
+ }
+ pw.print(prefix); pw.print("launchFailed="); pw.print(launchFailed);
+ pw.print(" launchCount="); pw.print(launchCount);
+ pw.print(" lastLaunchTime=");
+ if (lastLaunchTime == 0) pw.print("0");
+ else TimeUtils.formatDuration(lastLaunchTime, now, pw);
+ pw.println();
+ pw.print(prefix); pw.print("haveState="); pw.print(haveState);
+ pw.print(" icicle="); pw.println(icicle);
+ pw.print(prefix); pw.print("state="); pw.print(mState);
+ pw.print(" stopped="); pw.print(stopped);
+ pw.print(" delayedResume="); pw.print(delayedResume);
+ pw.print(" finishing="); pw.println(finishing);
+ pw.print(prefix); pw.print("keysPaused="); pw.print(keysPaused);
+ pw.print(" inHistory="); pw.print(inHistory);
+ pw.print(" visible="); pw.print(visible);
+ pw.print(" sleeping="); pw.print(sleeping);
+ pw.print(" idle="); pw.print(idle);
+ pw.print(" mStartingWindowState=");
+ pw.println(startingWindowStateToString(mStartingWindowState));
+ pw.print(prefix); pw.print("fullscreen="); pw.print(fullscreen);
+ pw.print(" noDisplay="); pw.print(noDisplay);
+ pw.print(" immersive="); pw.print(immersive);
+ pw.print(" launchMode="); pw.println(launchMode);
+ pw.print(prefix); pw.print("frozenBeforeDestroy="); pw.print(frozenBeforeDestroy);
+ pw.print(" forceNewConfig="); pw.println(forceNewConfig);
+ pw.print(prefix); pw.print("mActivityType=");
+ pw.println(activityTypeToString(getActivityType()));
+ if (requestedVrComponent != null) {
+ pw.print(prefix);
+ pw.print("requestedVrComponent=");
+ pw.println(requestedVrComponent);
+ }
+ final boolean waitingVisible =
+ mStackSupervisor.mActivitiesWaitingForVisibleActivity.contains(this);
+ if (lastVisibleTime != 0 || waitingVisible || nowVisible) {
+ pw.print(prefix); pw.print("waitingVisible="); pw.print(waitingVisible);
+ pw.print(" nowVisible="); pw.print(nowVisible);
+ pw.print(" lastVisibleTime=");
+ if (lastVisibleTime == 0) pw.print("0");
+ else TimeUtils.formatDuration(lastVisibleTime, now, pw);
+ pw.println();
+ }
+ if (mDeferHidingClient) {
+ pw.println(prefix + "mDeferHidingClient=" + mDeferHidingClient);
+ }
+ if (deferRelaunchUntilPaused || configChangeFlags != 0) {
+ pw.print(prefix); pw.print("deferRelaunchUntilPaused="); pw.print(deferRelaunchUntilPaused);
+ pw.print(" configChangeFlags=");
+ pw.println(Integer.toHexString(configChangeFlags));
+ }
+ if (mServiceConnectionsHolder != null) {
+ pw.print(prefix); pw.print("connections="); pw.println(mServiceConnectionsHolder);
+ }
+ if (info != null) {
+ pw.println(prefix + "resizeMode=" + ActivityInfo.resizeModeToString(info.resizeMode));
+ pw.println(prefix + "mLastReportedMultiWindowMode=" + mLastReportedMultiWindowMode
+ + " mLastReportedPictureInPictureMode=" + mLastReportedPictureInPictureMode);
+ if (info.supportsPictureInPicture()) {
+ pw.println(prefix + "supportsPictureInPicture=" + info.supportsPictureInPicture());
+ pw.println(prefix + "supportsEnterPipOnTaskSwitch: "
+ + supportsEnterPipOnTaskSwitch);
+ }
+ if (info.maxAspectRatio != 0) {
+ pw.println(prefix + "maxAspectRatio=" + info.maxAspectRatio);
+ }
+ }
+ }
+
+ void updateApplicationInfo(ApplicationInfo aInfo) {
+ appInfo = aInfo;
+ info.applicationInfo = aInfo;
+ }
+
+ private boolean crossesHorizontalSizeThreshold(int firstDp, int secondDp) {
+ return crossesSizeThreshold(mHorizontalSizeConfigurations, firstDp, secondDp);
+ }
+
+ private boolean crossesVerticalSizeThreshold(int firstDp, int secondDp) {
+ return crossesSizeThreshold(mVerticalSizeConfigurations, firstDp, secondDp);
+ }
+
+ private boolean crossesSmallestSizeThreshold(int firstDp, int secondDp) {
+ return crossesSizeThreshold(mSmallestSizeConfigurations, firstDp, secondDp);
+ }
+
+ /**
+ * The purpose of this method is to decide whether the activity needs to be relaunched upon
+ * changing its size. In most cases the activities don't need to be relaunched, if the resize
+ * is small, all the activity content has to do is relayout itself within new bounds. There are
+ * cases however, where the activity's content would be completely changed in the new size and
+ * the full relaunch is required.
+ *
+ * The activity will report to us vertical and horizontal thresholds after which a relaunch is
+ * required. These thresholds are collected from the application resource qualifiers. For
+ * example, if application has layout-w600dp resource directory, then it needs a relaunch when
+ * we resize from width of 650dp to 550dp, as it crosses the 600dp threshold. However, if
+ * it resizes width from 620dp to 700dp, it won't be relaunched as it stays on the same side
+ * of the threshold.
+ */
+ private static boolean crossesSizeThreshold(int[] thresholds, int firstDp,
+ int secondDp) {
+ if (thresholds == null) {
+ return false;
+ }
+ for (int i = thresholds.length - 1; i >= 0; i--) {
+ final int threshold = thresholds[i];
+ if ((firstDp < threshold && secondDp >= threshold)
+ || (firstDp >= threshold && secondDp < threshold)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ void setSizeConfigurations(int[] horizontalSizeConfiguration,
+ int[] verticalSizeConfigurations, int[] smallestSizeConfigurations) {
+ mHorizontalSizeConfigurations = horizontalSizeConfiguration;
+ mVerticalSizeConfigurations = verticalSizeConfigurations;
+ mSmallestSizeConfigurations = smallestSizeConfigurations;
+ }
+
+ private void scheduleActivityMovedToDisplay(int displayId, Configuration config) {
+ if (!attachedToProcess()) {
+ if (DEBUG_SWITCH || DEBUG_CONFIGURATION) Slog.w(TAG,
+ "Can't report activity moved to display - client not running, activityRecord="
+ + this + ", displayId=" + displayId);
+ return;
+ }
+ try {
+ if (DEBUG_SWITCH || DEBUG_CONFIGURATION) Slog.v(TAG,
+ "Reporting activity moved to display" + ", activityRecord=" + this
+ + ", displayId=" + displayId + ", config=" + config);
+
+ service.getLifecycleManager().scheduleTransaction(app.getThread(), appToken,
+ MoveToDisplayItem.obtain(displayId, config));
+ } catch (RemoteException e) {
+ // If process died, whatever.
+ }
+ }
+
+ private void scheduleConfigurationChanged(Configuration config) {
+ if (!attachedToProcess()) {
+ if (DEBUG_CONFIGURATION) Slog.w(TAG,
+ "Can't report activity configuration update - client not running"
+ + ", activityRecord=" + this);
+ return;
+ }
+ try {
+ if (DEBUG_CONFIGURATION) Slog.v(TAG, "Sending new config to " + this + ", config: "
+ + config);
+
+ service.getLifecycleManager().scheduleTransaction(app.getThread(), appToken,
+ ActivityConfigurationChangeItem.obtain(config));
+ } catch (RemoteException e) {
+ // If process died, whatever.
+ }
+ }
+
+ void updateMultiWindowMode() {
+ if (task == null || task.getStack() == null || !attachedToProcess()) {
+ return;
+ }
+
+ if (task.getStack().deferScheduleMultiWindowModeChanged()) {
+ // Don't do anything if we are currently deferring multi-window mode change.
+ return;
+ }
+
+ // An activity is considered to be in multi-window mode if its task isn't fullscreen.
+ final boolean inMultiWindowMode = inMultiWindowMode();
+ if (inMultiWindowMode != mLastReportedMultiWindowMode) {
+ mLastReportedMultiWindowMode = inMultiWindowMode;
+ scheduleMultiWindowModeChanged(getConfiguration());
+ }
+ }
+
+ private void scheduleMultiWindowModeChanged(Configuration overrideConfig) {
+ try {
+ service.getLifecycleManager().scheduleTransaction(app.getThread(), appToken,
+ MultiWindowModeChangeItem.obtain(mLastReportedMultiWindowMode, overrideConfig));
+ } catch (Exception e) {
+ // If process died, I don't care.
+ }
+ }
+
+ void updatePictureInPictureMode(Rect targetStackBounds, boolean forceUpdate) {
+ if (task == null || task.getStack() == null || !attachedToProcess()) {
+ return;
+ }
+
+ final boolean inPictureInPictureMode = inPinnedWindowingMode() && targetStackBounds != null;
+ if (inPictureInPictureMode != mLastReportedPictureInPictureMode || forceUpdate) {
+ // Picture-in-picture mode changes also trigger a multi-window mode change as well, so
+ // update that here in order. Set the last reported MW state to the same as the PiP
+ // state since we haven't yet actually resized the task (these callbacks need to
+ // preceed the configuration change from the resiez.
+ // TODO(110009072): Once we move these callbacks to the client, remove all logic related
+ // to forcing the update of the picture-in-picture mode as a part of the PiP animation.
+ mLastReportedPictureInPictureMode = inPictureInPictureMode;
+ mLastReportedMultiWindowMode = inPictureInPictureMode;
+ final Configuration newConfig = task.computeNewOverrideConfigurationForBounds(
+ targetStackBounds, null);
+ schedulePictureInPictureModeChanged(newConfig);
+ scheduleMultiWindowModeChanged(newConfig);
+ }
+ }
+
+ private void schedulePictureInPictureModeChanged(Configuration overrideConfig) {
+ try {
+ service.getLifecycleManager().scheduleTransaction(app.getThread(), appToken,
+ PipModeChangeItem.obtain(mLastReportedPictureInPictureMode,
+ overrideConfig));
+ } catch (Exception e) {
+ // If process died, no one cares.
+ }
+ }
+
+ @Override
+ protected int getChildCount() {
+ // {@link ActivityRecord} is a leaf node and has no children.
+ return 0;
+ }
+
+ @Override
+ protected ConfigurationContainer getChildAt(int index) {
+ return null;
+ }
+
+ @Override
+ protected ConfigurationContainer getParent() {
+ return getTask();
+ }
+
+ TaskRecord getTask() {
+ return task;
+ }
+
+ /**
+ * Sets reference to the {@link TaskRecord} the {@link ActivityRecord} will treat as its parent.
+ * Note that this does not actually add the {@link ActivityRecord} as a {@link TaskRecord}
+ * children. However, this method will clean up references to this {@link ActivityRecord} in
+ * {@link ActivityStack}.
+ * @param task The new parent {@link TaskRecord}.
+ */
+ void setTask(TaskRecord task) {
+ setTask(task /* task */, false /* reparenting */);
+ }
+
+ /**
+ * This method should only be called by {@link TaskRecord#removeActivity(ActivityRecord)}.
+ * @param task The new parent task.
+ * @param reparenting Whether we're in the middle of reparenting.
+ */
+ void setTask(TaskRecord task, boolean reparenting) {
+ // Do nothing if the {@link TaskRecord} is the same as the current {@link getTask}.
+ if (task != null && task == getTask()) {
+ return;
+ }
+
+ final ActivityStack oldStack = getStack();
+ final ActivityStack newStack = task != null ? task.getStack() : null;
+
+ // Inform old stack (if present) of activity removal and new stack (if set) of activity
+ // addition.
+ if (oldStack != newStack) {
+ if (!reparenting && oldStack != null) {
+ oldStack.onActivityRemovedFromStack(this);
+ }
+
+ if (newStack != null) {
+ newStack.onActivityAddedToStack(this);
+ }
+ }
+
+ this.task = task;
+
+ if (!reparenting) {
+ onParentChanged();
+ }
+ }
+
+ /**
+ * See {@link AppWindowContainerController#setWillCloseOrEnterPip(boolean)}
+ */
+ void setWillCloseOrEnterPip(boolean willCloseOrEnterPip) {
+ getWindowContainerController().setWillCloseOrEnterPip(willCloseOrEnterPip);
+ }
+
+ static class Token extends IApplicationToken.Stub {
+ private final WeakReference<ActivityRecord> weakActivity;
+ private final String name;
+
+ Token(ActivityRecord activity, Intent intent) {
+ weakActivity = new WeakReference<>(activity);
+ name = intent.getComponent().flattenToShortString();
+ }
+
+ private static ActivityRecord tokenToActivityRecordLocked(Token token) {
+ if (token == null) {
+ return null;
+ }
+ ActivityRecord r = token.weakActivity.get();
+ if (r == null || r.getStack() == null) {
+ return null;
+ }
+ return r;
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder(128);
+ sb.append("Token{");
+ sb.append(Integer.toHexString(System.identityHashCode(this)));
+ sb.append(' ');
+ sb.append(weakActivity.get());
+ sb.append('}');
+ return sb.toString();
+ }
+
+ @Override
+ public String getName() {
+ return name;
+ }
+ }
+
+ static ActivityRecord forTokenLocked(IBinder token) {
+ try {
+ return Token.tokenToActivityRecordLocked((Token)token);
+ } catch (ClassCastException e) {
+ Slog.w(TAG, "Bad activity token: " + token, e);
+ return null;
+ }
+ }
+
+ boolean isResolverActivity() {
+ return ResolverActivity.class.getName().equals(realActivity.getClassName());
+ }
+
+ boolean isResolverOrChildActivity() {
+ if (!"android".equals(packageName)) {
+ return false;
+ }
+ try {
+ return ResolverActivity.class.isAssignableFrom(
+ Object.class.getClassLoader().loadClass(realActivity.getClassName()));
+ } catch (ClassNotFoundException e) {
+ return false;
+ }
+ }
+
+ ActivityRecord(ActivityTaskManagerService _service, WindowProcessController _caller,
+ int _launchedFromPid, int _launchedFromUid, String _launchedFromPackage, Intent _intent,
+ String _resolvedType, ActivityInfo aInfo, Configuration _configuration,
+ ActivityRecord _resultTo, String _resultWho, int _reqCode, boolean _componentSpecified,
+ boolean _rootVoiceInteraction, ActivityStackSupervisor supervisor,
+ ActivityOptions options, ActivityRecord sourceRecord) {
+ service = _service;
+ appToken = new Token(this, _intent);
+ info = aInfo;
+ launchedFromPid = _launchedFromPid;
+ launchedFromUid = _launchedFromUid;
+ launchedFromPackage = _launchedFromPackage;
+ userId = UserHandle.getUserId(aInfo.applicationInfo.uid);
+ intent = _intent;
+ shortComponentName = _intent.getComponent().flattenToShortString();
+ resolvedType = _resolvedType;
+ componentSpecified = _componentSpecified;
+ rootVoiceInteraction = _rootVoiceInteraction;
+ mLastReportedConfiguration = new MergedConfiguration(_configuration);
+ resultTo = _resultTo;
+ resultWho = _resultWho;
+ requestCode = _reqCode;
+ setState(INITIALIZING, "ActivityRecord ctor");
+ frontOfTask = false;
+ launchFailed = false;
+ stopped = false;
+ delayedResume = false;
+ finishing = false;
+ deferRelaunchUntilPaused = false;
+ keysPaused = false;
+ inHistory = false;
+ visible = false;
+ nowVisible = false;
+ idle = false;
+ hasBeenLaunched = false;
+ mStackSupervisor = supervisor;
+
+ // This starts out true, since the initial state of an activity is that we have everything,
+ // and we shouldn't never consider it lacking in state to be removed if it dies.
+ haveState = true;
+
+ // If the class name in the intent doesn't match that of the target, this is
+ // probably an alias. We have to create a new ComponentName object to keep track
+ // of the real activity name, so that FLAG_ACTIVITY_CLEAR_TOP is handled properly.
+ if (aInfo.targetActivity == null
+ || (aInfo.targetActivity.equals(_intent.getComponent().getClassName())
+ && (aInfo.launchMode == LAUNCH_MULTIPLE
+ || aInfo.launchMode == LAUNCH_SINGLE_TOP))) {
+ realActivity = _intent.getComponent();
+ } else {
+ realActivity = new ComponentName(aInfo.packageName, aInfo.targetActivity);
+ }
+ taskAffinity = aInfo.taskAffinity;
+ stateNotNeeded = (aInfo.flags & FLAG_STATE_NOT_NEEDED) != 0;
+ appInfo = aInfo.applicationInfo;
+ nonLocalizedLabel = aInfo.nonLocalizedLabel;
+ labelRes = aInfo.labelRes;
+ if (nonLocalizedLabel == null && labelRes == 0) {
+ ApplicationInfo app = aInfo.applicationInfo;
+ nonLocalizedLabel = app.nonLocalizedLabel;
+ labelRes = app.labelRes;
+ }
+ icon = aInfo.getIconResource();
+ logo = aInfo.getLogoResource();
+ theme = aInfo.getThemeResource();
+ realTheme = theme;
+ if (realTheme == 0) {
+ realTheme = aInfo.applicationInfo.targetSdkVersion < HONEYCOMB
+ ? android.R.style.Theme : android.R.style.Theme_Holo;
+ }
+ if ((aInfo.flags & ActivityInfo.FLAG_HARDWARE_ACCELERATED) != 0) {
+ windowFlags |= LayoutParams.FLAG_HARDWARE_ACCELERATED;
+ }
+ if ((aInfo.flags & FLAG_MULTIPROCESS) != 0 && _caller != null
+ && (aInfo.applicationInfo.uid == SYSTEM_UID
+ || aInfo.applicationInfo.uid == _caller.mInfo.uid)) {
+ processName = _caller.mName;
+ } else {
+ processName = aInfo.processName;
+ }
+
+ if ((aInfo.flags & FLAG_EXCLUDE_FROM_RECENTS) != 0) {
+ intent.addFlags(FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS);
+ }
+
+ packageName = aInfo.applicationInfo.packageName;
+ launchMode = aInfo.launchMode;
+
+ Entry ent = AttributeCache.instance().get(packageName,
+ realTheme, com.android.internal.R.styleable.Window, userId);
+
+ if (ent != null) {
+ fullscreen = !ActivityInfo.isTranslucentOrFloating(ent.array);
+ hasWallpaper = ent.array.getBoolean(R.styleable.Window_windowShowWallpaper, false);
+ noDisplay = ent.array.getBoolean(R.styleable.Window_windowNoDisplay, false);
+ } else {
+ hasWallpaper = false;
+ noDisplay = false;
+ }
+
+ setActivityType(_componentSpecified, _launchedFromUid, _intent, options, sourceRecord);
+
+ immersive = (aInfo.flags & FLAG_IMMERSIVE) != 0;
+
+ requestedVrComponent = (aInfo.requestedVrComponent == null) ?
+ null : ComponentName.unflattenFromString(aInfo.requestedVrComponent);
+
+ mShowWhenLocked = (aInfo.flags & FLAG_SHOW_WHEN_LOCKED) != 0;
+ mTurnScreenOn = (aInfo.flags & FLAG_TURN_SCREEN_ON) != 0;
+
+ mRotationAnimationHint = aInfo.rotationAnimation;
+ lockTaskLaunchMode = aInfo.lockTaskLaunchMode;
+ if (appInfo.isPrivilegedApp() && (lockTaskLaunchMode == LOCK_TASK_LAUNCH_MODE_ALWAYS
+ || lockTaskLaunchMode == LOCK_TASK_LAUNCH_MODE_NEVER)) {
+ lockTaskLaunchMode = LOCK_TASK_LAUNCH_MODE_DEFAULT;
+ }
+
+ if (options != null) {
+ pendingOptions = options;
+ mLaunchTaskBehind = options.getLaunchTaskBehind();
+
+ final int rotationAnimation = pendingOptions.getRotationAnimationHint();
+ // Only override manifest supplied option if set.
+ if (rotationAnimation >= 0) {
+ mRotationAnimationHint = rotationAnimation;
+ }
+ final PendingIntent usageReport = pendingOptions.getUsageTimeReport();
+ if (usageReport != null) {
+ appTimeTracker = new AppTimeTracker(usageReport);
+ }
+ final boolean useLockTask = pendingOptions.getLockTaskMode();
+ if (useLockTask && lockTaskLaunchMode == LOCK_TASK_LAUNCH_MODE_DEFAULT) {
+ lockTaskLaunchMode = LOCK_TASK_LAUNCH_MODE_IF_WHITELISTED;
+ }
+ }
+ }
+
+ void setProcess(WindowProcessController proc) {
+ app = proc;
+ final ActivityRecord root = task != null ? task.getRootActivity() : null;
+ if (root == this) {
+ task.setRootProcess(proc);
+ }
+ }
+
+ boolean hasProcess() {
+ return app != null;
+ }
+
+ boolean attachedToProcess() {
+ return hasProcess() && app.hasThread();
+ }
+
+ AppWindowContainerController getWindowContainerController() {
+ return mWindowContainerController;
+ }
+
+ void createWindowContainer() {
+ if (mWindowContainerController != null) {
+ throw new IllegalArgumentException("Window container=" + mWindowContainerController
+ + " already created for r=" + this);
+ }
+
+ inHistory = true;
+
+ final TaskWindowContainerController taskController = task.getWindowContainerController();
+
+ // TODO(b/36505427): Maybe this call should be moved inside updateOverrideConfiguration()
+ task.updateOverrideConfigurationFromLaunchBounds();
+ // Make sure override configuration is up-to-date before using to create window controller.
+ updateOverrideConfiguration();
+
+ mWindowContainerController = new AppWindowContainerController(taskController, appToken,
+ this, Integer.MAX_VALUE /* add on top */, info.screenOrientation, fullscreen,
+ (info.flags & FLAG_SHOW_FOR_ALL_USERS) != 0, info.configChanges,
+ task.voiceSession != null, mLaunchTaskBehind, isAlwaysFocusable(),
+ appInfo.targetSdkVersion, mRotationAnimationHint,
+ ActivityTaskManagerService.getInputDispatchingTimeoutLocked(this) * 1000000L);
+
+ task.addActivityToTop(this);
+
+ // When an activity is started directly into a split-screen fullscreen stack, we need to
+ // update the initial multi-window modes so that the callbacks are scheduled correctly when
+ // the user leaves that mode.
+ mLastReportedMultiWindowMode = inMultiWindowMode();
+ mLastReportedPictureInPictureMode = inPinnedWindowingMode();
+ }
+
+ void removeWindowContainer() {
+ // Do not try to remove a window container if we have already removed it.
+ if (mWindowContainerController == null) {
+ return;
+ }
+
+ // Resume key dispatching if it is currently paused before we remove the container.
+ resumeKeyDispatchingLocked();
+
+ mWindowContainerController.removeContainer(getDisplayId());
+ mWindowContainerController = null;
+ }
+
+ /**
+ * Reparents this activity into {@param newTask} at the provided {@param position}. The caller
+ * should ensure that the {@param newTask} is not already the parent of this activity.
+ */
+ void reparent(TaskRecord newTask, int position, String reason) {
+ final TaskRecord prevTask = task;
+ if (prevTask == newTask) {
+ throw new IllegalArgumentException(reason + ": task=" + newTask
+ + " is already the parent of r=" + this);
+ }
+
+ // TODO: Ensure that we do not directly reparent activities across stacks, as that may leave
+ // the stacks in strange states. For now, we should use Task.reparent() to ensure that
+ // the stack is left in an OK state.
+ if (prevTask != null && newTask != null && prevTask.getStack() != newTask.getStack()) {
+ throw new IllegalArgumentException(reason + ": task=" + newTask
+ + " is in a different stack (" + newTask.getStackId() + ") than the parent of"
+ + " r=" + this + " (" + prevTask.getStackId() + ")");
+ }
+
+ // Must reparent first in window manager
+ mWindowContainerController.reparent(newTask.getWindowContainerController(), position);
+
+ // Reparenting prevents informing the parent stack of activity removal in the case that
+ // the new stack has the same parent. we must manually signal here if this is not the case.
+ final ActivityStack prevStack = prevTask.getStack();
+
+ if (prevStack != newTask.getStack()) {
+ prevStack.onActivityRemovedFromStack(this);
+ }
+ // Remove the activity from the old task and add it to the new task.
+ prevTask.removeActivity(this, true /* reparenting */);
+
+ newTask.addActivityAtIndex(position, this);
+ }
+
+ private boolean isHomeIntent(Intent intent) {
+ return ACTION_MAIN.equals(intent.getAction())
+ && intent.hasCategory(CATEGORY_HOME)
+ && intent.getCategories().size() == 1
+ && intent.getData() == null
+ && intent.getType() == null;
+ }
+
+ static boolean isMainIntent(Intent intent) {
+ return ACTION_MAIN.equals(intent.getAction())
+ && intent.hasCategory(CATEGORY_LAUNCHER)
+ && intent.getCategories().size() == 1
+ && intent.getData() == null
+ && intent.getType() == null;
+ }
+
+ private boolean canLaunchHomeActivity(int uid, ActivityRecord sourceRecord) {
+ if (uid == Process.myUid() || uid == 0) {
+ // System process can launch home activity.
+ return true;
+ }
+ // Allow the recents component to launch the home activity.
+ final RecentTasks recentTasks = mStackSupervisor.mService.getRecentTasks();
+ if (recentTasks != null && recentTasks.isCallerRecents(uid)) {
+ return true;
+ }
+ // Resolver activity can launch home activity.
+ return sourceRecord != null && sourceRecord.isResolverActivity();
+ }
+
+ /**
+ * @return whether the given package name can launch an assist activity.
+ */
+ private boolean canLaunchAssistActivity(String packageName) {
+ final ComponentName assistComponent =
+ service.mActiveVoiceInteractionServiceComponent;
+ if (assistComponent != null) {
+ return assistComponent.getPackageName().equals(packageName);
+ }
+ return false;
+ }
+
+ private void setActivityType(boolean componentSpecified, int launchedFromUid, Intent intent,
+ ActivityOptions options, ActivityRecord sourceRecord) {
+ int activityType = ACTIVITY_TYPE_UNDEFINED;
+ if ((!componentSpecified || canLaunchHomeActivity(launchedFromUid, sourceRecord))
+ && isHomeIntent(intent) && !isResolverActivity()) {
+ // This sure looks like a home activity!
+ activityType = ACTIVITY_TYPE_HOME;
+
+ if (info.resizeMode == RESIZE_MODE_FORCE_RESIZEABLE
+ || info.resizeMode == RESIZE_MODE_RESIZEABLE_VIA_SDK_VERSION) {
+ // We only allow home activities to be resizeable if they explicitly requested it.
+ info.resizeMode = RESIZE_MODE_UNRESIZEABLE;
+ }
+ } else if (realActivity.getClassName().contains(LEGACY_RECENTS_PACKAGE_NAME)
+ || service.getRecentTasks().isRecentsComponent(realActivity, appInfo.uid)) {
+ activityType = ACTIVITY_TYPE_RECENTS;
+ } else if (options != null && options.getLaunchActivityType() == ACTIVITY_TYPE_ASSISTANT
+ && canLaunchAssistActivity(launchedFromPackage)) {
+ activityType = ACTIVITY_TYPE_ASSISTANT;
+ }
+ setActivityType(activityType);
+ }
+
+ void setTaskToAffiliateWith(TaskRecord taskToAffiliateWith) {
+ if (launchMode != LAUNCH_SINGLE_INSTANCE && launchMode != LAUNCH_SINGLE_TASK) {
+ task.setTaskToAffiliateWith(taskToAffiliateWith);
+ }
+ }
+
+ /**
+ * @return Stack value from current task, null if there is no task.
+ */
+ <T extends ActivityStack> T getStack() {
+ return task != null ? (T) task.getStack() : null;
+ }
+
+ int getStackId() {
+ return getStack() != null ? getStack().mStackId : INVALID_STACK_ID;
+ }
+
+ ActivityDisplay getDisplay() {
+ final ActivityStack stack = getStack();
+ return stack != null ? stack.getDisplay() : null;
+ }
+
+ boolean changeWindowTranslucency(boolean toOpaque) {
+ if (fullscreen == toOpaque) {
+ return false;
+ }
+
+ // Keep track of the number of fullscreen activities in this task.
+ task.numFullscreen += toOpaque ? +1 : -1;
+
+ fullscreen = toOpaque;
+ return true;
+ }
+
+ void takeFromHistory() {
+ if (inHistory) {
+ inHistory = false;
+ if (task != null && !finishing) {
+ task = null;
+ }
+ clearOptionsLocked();
+ }
+ }
+
+ boolean isInHistory() {
+ return inHistory;
+ }
+
+ boolean isInStackLocked() {
+ final ActivityStack stack = getStack();
+ return stack != null && stack.isInStackLocked(this) != null;
+ }
+
+ boolean isPersistable() {
+ return (info.persistableMode == PERSIST_ROOT_ONLY ||
+ info.persistableMode == PERSIST_ACROSS_REBOOTS) &&
+ (intent == null || (intent.getFlags() & FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS) == 0);
+ }
+
+ boolean isFocusable() {
+ return mStackSupervisor.isFocusable(this, isAlwaysFocusable());
+ }
+
+ boolean isResizeable() {
+ return ActivityInfo.isResizeableMode(info.resizeMode) || info.supportsPictureInPicture();
+ }
+
+ /**
+ * @return whether this activity is non-resizeable or forced to be resizeable
+ */
+ boolean isNonResizableOrForcedResizable() {
+ return info.resizeMode != RESIZE_MODE_RESIZEABLE
+ && info.resizeMode != RESIZE_MODE_RESIZEABLE_VIA_SDK_VERSION;
+ }
+
+ /**
+ * @return whether this activity supports PiP multi-window and can be put in the pinned stack.
+ */
+ boolean supportsPictureInPicture() {
+ return service.mSupportsPictureInPicture && isActivityTypeStandardOrUndefined()
+ && info.supportsPictureInPicture();
+ }
+
+ /**
+ * @return whether this activity supports split-screen multi-window and can be put in the docked
+ * stack.
+ */
+ @Override
+ public boolean supportsSplitScreenWindowingMode() {
+ // An activity can not be docked even if it is considered resizeable because it only
+ // supports picture-in-picture mode but has a non-resizeable resizeMode
+ return super.supportsSplitScreenWindowingMode()
+ && service.mSupportsSplitScreenMultiWindow && supportsResizeableMultiWindow();
+ }
+
+ /**
+ * @return whether this activity supports freeform multi-window and can be put in the freeform
+ * stack.
+ */
+ boolean supportsFreeform() {
+ return service.mSupportsFreeformWindowManagement && supportsResizeableMultiWindow();
+ }
+
+ /**
+ * @return whether this activity supports non-PiP multi-window.
+ */
+ private boolean supportsResizeableMultiWindow() {
+ return service.mSupportsMultiWindow && !isActivityTypeHome()
+ && (ActivityInfo.isResizeableMode(info.resizeMode)
+ || service.mForceResizableActivities);
+ }
+
+ /**
+ * Check whether this activity can be launched on the specified display.
+ *
+ * @param displayId Target display id.
+ * @return {@code true} if either it is the default display or this activity can be put on a
+ * secondary screen.
+ */
+ boolean canBeLaunchedOnDisplay(int displayId) {
+ return service.mStackSupervisor.canPlaceEntityOnDisplay(displayId, launchedFromPid,
+ launchedFromUid, info);
+ }
+
+ /**
+ * @param beforeStopping Whether this check is for an auto-enter-pip operation, that is to say
+ * the activity has requested to enter PiP when it would otherwise be stopped.
+ *
+ * @return whether this activity is currently allowed to enter PIP.
+ */
+ boolean checkEnterPictureInPictureState(String caller, boolean beforeStopping) {
+ if (!supportsPictureInPicture()) {
+ return false;
+ }
+
+ // Check app-ops and see if PiP is supported for this package
+ if (!checkEnterPictureInPictureAppOpsState()) {
+ return false;
+ }
+
+ // Check to see if we are in VR mode, and disallow PiP if so
+ if (service.shouldDisableNonVrUiLocked()) {
+ return false;
+ }
+
+ boolean isKeyguardLocked = service.isKeyguardLocked();
+ boolean isCurrentAppLocked =
+ service.getLockTaskModeState() != LOCK_TASK_MODE_NONE;
+ final ActivityDisplay display = getDisplay();
+ boolean hasPinnedStack = display != null && display.hasPinnedStack();
+ // Don't return early if !isNotLocked, since we want to throw an exception if the activity
+ // is in an incorrect state
+ boolean isNotLockedOrOnKeyguard = !isKeyguardLocked && !isCurrentAppLocked;
+
+ // We don't allow auto-PiP when something else is already pipped.
+ if (beforeStopping && hasPinnedStack) {
+ return false;
+ }
+
+ switch (mState) {
+ case RESUMED:
+ // When visible, allow entering PiP if the app is not locked. If it is over the
+ // keyguard, then we will prompt to unlock in the caller before entering PiP.
+ return !isCurrentAppLocked &&
+ (supportsEnterPipOnTaskSwitch || !beforeStopping);
+ case PAUSING:
+ case PAUSED:
+ // When pausing, then only allow enter PiP as in the resume state, and in addition,
+ // require that there is not an existing PiP activity and that the current system
+ // state supports entering PiP
+ return isNotLockedOrOnKeyguard && !hasPinnedStack
+ && supportsEnterPipOnTaskSwitch;
+ case STOPPING:
+ // When stopping in a valid state, then only allow enter PiP as in the pause state.
+ // Otherwise, fall through to throw an exception if the caller is trying to enter
+ // PiP in an invalid stopping state.
+ if (supportsEnterPipOnTaskSwitch) {
+ return isNotLockedOrOnKeyguard && !hasPinnedStack;
+ }
+ default:
+ return false;
+ }
+ }
+
+ /**
+ * @return Whether AppOps allows this package to enter picture-in-picture.
+ */
+ private boolean checkEnterPictureInPictureAppOpsState() {
+ return service.getAppOpsService().checkOperation(
+ OP_PICTURE_IN_PICTURE, appInfo.uid, packageName) == MODE_ALLOWED;
+ }
+
+ boolean isAlwaysFocusable() {
+ return (info.flags & FLAG_ALWAYS_FOCUSABLE) != 0;
+ }
+
+ /** Move activity with its stack to front and make the stack focused. */
+ boolean moveFocusableActivityToTop(String reason) {
+ if (!isFocusable()) {
+ if (DEBUG_FOCUS) {
+ Slog.d(TAG_FOCUS, "moveActivityStackToFront: unfocusable activity=" + this);
+ }
+ return false;
+ }
+
+ final TaskRecord task = getTask();
+ final ActivityStack stack = getStack();
+ if (stack == null) {
+ Slog.w(TAG, "moveActivityStackToFront: invalid task or stack: activity="
+ + this + " task=" + task);
+ return false;
+ }
+
+ if (mStackSupervisor.getTopResumedActivity() == this) {
+ if (DEBUG_FOCUS) {
+ Slog.d(TAG_FOCUS, "moveActivityStackToFront: already on top, activity=" + this);
+ }
+ return false;
+ }
+
+ if (DEBUG_FOCUS) {
+ Slog.d(TAG_FOCUS, "moveActivityStackToFront: activity=" + this);
+ }
+
+ stack.moveToFront(reason, task);
+ // Report top activity change to tracking services and WM
+ if (mStackSupervisor.getTopResumedActivity() == this) {
+ // TODO(b/111361570): Support multiple focused apps in WM
+ service.setResumedActivityUncheckLocked(this, reason);
+ }
+ return true;
+ }
+
+ /**
+ * @return true if the activity contains windows that have
+ * {@link LayoutParams#FLAG_DISMISS_KEYGUARD} set
+ */
+ boolean hasDismissKeyguardWindows() {
+ return service.mWindowManager.containsDismissKeyguardWindow(appToken);
+ }
+
+ void makeFinishingLocked() {
+ if (finishing) {
+ return;
+ }
+ finishing = true;
+ if (stopped) {
+ clearOptionsLocked();
+ }
+
+ if (service != null) {
+ service.getTaskChangeNotificationController().notifyTaskStackChanged();
+ }
+ }
+
+ UriPermissionOwner getUriPermissionsLocked() {
+ if (uriPermissions == null) {
+ uriPermissions = new UriPermissionOwner(service.mUgmInternal, this);
+ }
+ return uriPermissions;
+ }
+
+ void addResultLocked(ActivityRecord from, String resultWho,
+ int requestCode, int resultCode,
+ Intent resultData) {
+ ActivityResult r = new ActivityResult(from, resultWho,
+ requestCode, resultCode, resultData);
+ if (results == null) {
+ results = new ArrayList<ResultInfo>();
+ }
+ results.add(r);
+ }
+
+ void removeResultsLocked(ActivityRecord from, String resultWho,
+ int requestCode) {
+ if (results != null) {
+ for (int i=results.size()-1; i>=0; i--) {
+ ActivityResult r = (ActivityResult)results.get(i);
+ if (r.mFrom != from) continue;
+ if (r.mResultWho == null) {
+ if (resultWho != null) continue;
+ } else {
+ if (!r.mResultWho.equals(resultWho)) continue;
+ }
+ if (r.mRequestCode != requestCode) continue;
+
+ results.remove(i);
+ }
+ }
+ }
+
+ private void addNewIntentLocked(ReferrerIntent intent) {
+ if (newIntents == null) {
+ newIntents = new ArrayList<>();
+ }
+ newIntents.add(intent);
+ }
+
+ final boolean isSleeping() {
+ final ActivityStack stack = getStack();
+ return stack != null ? stack.shouldSleepActivities() : service.isSleepingLocked();
+ }
+
+ /**
+ * Deliver a new Intent to an existing activity, so that its onNewIntent()
+ * method will be called at the proper time.
+ */
+ final void deliverNewIntentLocked(int callingUid, Intent intent, String referrer) {
+ // The activity now gets access to the data associated with this Intent.
+ service.mUgmInternal.grantUriPermissionFromIntent(callingUid, packageName,
+ intent, getUriPermissionsLocked(), userId);
+ final ReferrerIntent rintent = new ReferrerIntent(intent, referrer);
+ boolean unsent = true;
+ final boolean isTopActivityWhileSleeping = isTopRunningActivity() && isSleeping();
+
+ // We want to immediately deliver the intent to the activity if:
+ // - It is currently resumed or paused. i.e. it is currently visible to the user and we want
+ // the user to see the visual effects caused by the intent delivery now.
+ // - The device is sleeping and it is the top activity behind the lock screen (b/6700897).
+ if ((mState == RESUMED || mState == PAUSED || isTopActivityWhileSleeping)
+ && attachedToProcess()) {
+ try {
+ ArrayList<ReferrerIntent> ar = new ArrayList<>(1);
+ ar.add(rintent);
+ service.getLifecycleManager().scheduleTransaction(
+ app.getThread(), appToken, NewIntentItem.obtain(ar, mState == PAUSED));
+ unsent = false;
+ } catch (RemoteException e) {
+ Slog.w(TAG, "Exception thrown sending new intent to " + this, e);
+ } catch (NullPointerException e) {
+ Slog.w(TAG, "Exception thrown sending new intent to " + this, e);
+ }
+ }
+ if (unsent) {
+ addNewIntentLocked(rintent);
+ }
+ }
+
+ void updateOptionsLocked(ActivityOptions options) {
+ if (options != null) {
+ if (pendingOptions != null) {
+ pendingOptions.abort();
+ }
+ pendingOptions = options;
+ }
+ }
+
+ void applyOptionsLocked() {
+ if (pendingOptions != null
+ && pendingOptions.getAnimationType() != ANIM_SCENE_TRANSITION) {
+ mWindowContainerController.applyOptionsLocked(pendingOptions, intent);
+ if (task == null) {
+ clearOptionsLocked(false /* withAbort */);
+ } else {
+ // This will clear the options for all the ActivityRecords for this Task.
+ task.clearAllPendingOptions();
+ }
+ }
+ }
+
+ ActivityOptions getOptionsForTargetActivityLocked() {
+ return pendingOptions != null ? pendingOptions.forTargetActivity() : null;
+ }
+
+ void clearOptionsLocked() {
+ clearOptionsLocked(true /* withAbort */);
+ }
+
+ void clearOptionsLocked(boolean withAbort) {
+ if (withAbort && pendingOptions != null) {
+ pendingOptions.abort();
+ }
+ pendingOptions = null;
+ }
+
+ ActivityOptions takeOptionsLocked() {
+ ActivityOptions opts = pendingOptions;
+ pendingOptions = null;
+ return opts;
+ }
+
+ void removeUriPermissionsLocked() {
+ if (uriPermissions != null) {
+ uriPermissions.removeUriPermissions();
+ uriPermissions = null;
+ }
+ }
+
+ void pauseKeyDispatchingLocked() {
+ if (!keysPaused) {
+ keysPaused = true;
+
+ if (mWindowContainerController != null) {
+ mWindowContainerController.pauseKeyDispatching();
+ }
+ }
+ }
+
+ void resumeKeyDispatchingLocked() {
+ if (keysPaused) {
+ keysPaused = false;
+
+ if (mWindowContainerController != null) {
+ mWindowContainerController.resumeKeyDispatching();
+ }
+ }
+ }
+
+ private void updateTaskDescription(CharSequence description) {
+ task.lastDescription = description;
+ }
+
+ void setDeferHidingClient(boolean deferHidingClient) {
+ if (mDeferHidingClient == deferHidingClient) {
+ return;
+ }
+ mDeferHidingClient = deferHidingClient;
+ if (!mDeferHidingClient && !visible) {
+ // Hiding the client is no longer deferred and the app isn't visible still, go ahead and
+ // update the visibility.
+ setVisibility(false);
+ }
+ }
+
+ void setVisibility(boolean visible) {
+ mWindowContainerController.setVisibility(visible, mDeferHidingClient);
+ mStackSupervisor.getActivityMetricsLogger().notifyVisibilityChanged(this);
+ }
+
+ // TODO: Look into merging with #setVisibility()
+ void setVisible(boolean newVisible) {
+ visible = newVisible;
+ mDeferHidingClient = !visible && mDeferHidingClient;
+ setVisibility(visible);
+ mStackSupervisor.mAppVisibilitiesChangedSinceLastPause = true;
+ }
+
+ void setState(ActivityState state, String reason) {
+ if (DEBUG_STATES) Slog.v(TAG_STATES, "State movement: " + this + " from:" + getState()
+ + " to:" + state + " reason:" + reason);
+
+ if (state == mState) {
+ // No need to do anything if state doesn't change.
+ if (DEBUG_STATES) Slog.v(TAG_STATES, "State unchanged from:" + state);
+ return;
+ }
+
+ mState = state;
+
+ final TaskRecord parent = getTask();
+
+ if (parent != null) {
+ parent.onActivityStateChanged(this, state, reason);
+ }
+
+ // The WindowManager interprets the app stopping signal as
+ // an indication that the Surface will eventually be destroyed.
+ // This however isn't necessarily true if we are going to sleep.
+ if (state == STOPPING && !isSleeping()) {
+ mWindowContainerController.notifyAppStopping();
+ }
+ }
+
+ ActivityState getState() {
+ return mState;
+ }
+
+ /**
+ * Returns {@code true} if the Activity is in the specified state.
+ */
+ boolean isState(ActivityState state) {
+ return state == mState;
+ }
+
+ /**
+ * Returns {@code true} if the Activity is in one of the specified states.
+ */
+ boolean isState(ActivityState state1, ActivityState state2) {
+ return state1 == mState || state2 == mState;
+ }
+
+ /**
+ * Returns {@code true} if the Activity is in one of the specified states.
+ */
+ boolean isState(ActivityState state1, ActivityState state2, ActivityState state3) {
+ return state1 == mState || state2 == mState || state3 == mState;
+ }
+
+ /**
+ * Returns {@code true} if the Activity is in one of the specified states.
+ */
+ boolean isState(ActivityState state1, ActivityState state2, ActivityState state3,
+ ActivityState state4) {
+ return state1 == mState || state2 == mState || state3 == mState || state4 == mState;
+ }
+
+ void notifyAppResumed(boolean wasStopped) {
+ mWindowContainerController.notifyAppResumed(wasStopped);
+ }
+
+ void notifyUnknownVisibilityLaunched() {
+
+ // No display activities never add a window, so there is no point in waiting them for
+ // relayout.
+ if (!noDisplay) {
+ mWindowContainerController.notifyUnknownVisibilityLaunched();
+ }
+ }
+
+ /**
+ * @return true if the input activity should be made visible, ignoring any effect Keyguard
+ * might have on the visibility
+ *
+ * @see {@link ActivityStack#checkKeyguardVisibility}
+ */
+ boolean shouldBeVisibleIgnoringKeyguard(boolean behindFullscreenActivity) {
+ if (!okToShowLocked()) {
+ return false;
+ }
+
+ return !behindFullscreenActivity || mLaunchTaskBehind;
+ }
+
+ void makeVisibleIfNeeded(ActivityRecord starting, boolean reportToClient) {
+ // This activity is not currently visible, but is running. Tell it to become visible.
+ if (mState == RESUMED || this == starting) {
+ if (DEBUG_VISIBILITY) Slog.d(TAG_VISIBILITY,
+ "Not making visible, r=" + this + " state=" + mState + " starting=" + starting);
+ return;
+ }
+
+ // If this activity is paused, tell it to now show its window.
+ if (DEBUG_VISIBILITY) Slog.v(TAG_VISIBILITY,
+ "Making visible and scheduling visibility: " + this);
+ final ActivityStack stack = getStack();
+ try {
+ if (stack.mTranslucentActivityWaiting != null) {
+ updateOptionsLocked(returningOptions);
+ stack.mUndrawnActivitiesBelowTopTranslucent.add(this);
+ }
+ setVisible(true);
+ sleeping = false;
+ app.postPendingUiCleanMsg(true);
+ if (reportToClient) {
+ makeClientVisible();
+ } else {
+ mClientVisibilityDeferred = true;
+ }
+ // The activity may be waiting for stop, but that is no longer appropriate for it.
+ mStackSupervisor.mStoppingActivities.remove(this);
+ mStackSupervisor.mGoingToSleepActivities.remove(this);
+ } catch (Exception e) {
+ // Just skip on any failure; we'll make it visible when it next restarts.
+ Slog.w(TAG, "Exception thrown making visible: " + intent.getComponent(), e);
+ }
+ handleAlreadyVisible();
+ }
+
+ /** Send visibility change message to the client and pause if needed. */
+ void makeClientVisible() {
+ mClientVisibilityDeferred = false;
+ try {
+ service.getLifecycleManager().scheduleTransaction(app.getThread(), appToken,
+ WindowVisibilityItem.obtain(true /* showWindow */));
+ if (shouldPauseWhenBecomingVisible()) {
+ // An activity must be in the {@link PAUSING} state for the system to validate
+ // the move to {@link PAUSED}.
+ setState(PAUSING, "makeVisibleIfNeeded");
+ service.getLifecycleManager().scheduleTransaction(app.getThread(), appToken,
+ PauseActivityItem.obtain(finishing, false /* userLeaving */,
+ configChangeFlags, false /* dontReport */));
+ }
+ } catch (Exception e) {
+ Slog.w(TAG, "Exception thrown sending visibility update: " + intent.getComponent(), e);
+ }
+ }
+
+ /** Check if activity should be moved to PAUSED state when it becomes visible. */
+ private boolean shouldPauseWhenBecomingVisible() {
+ // If the activity is stopped or stopping, cycle to the paused state. We avoid doing
+ // this when there is an activity waiting to become translucent as the extra binder
+ // calls will lead to noticeable jank. A later call to
+ // ActivityStack#ensureActivitiesVisibleLocked will bring the activity to the proper
+ // paused state. We also avoid doing this for the activity the stack supervisor
+ // considers the resumed activity, as normal means will bring the activity from STOPPED
+ // to RESUMED. Adding PAUSING in this scenario will lead to double lifecycles.
+ if (!isState(STOPPED, STOPPING) || getStack().mTranslucentActivityWaiting != null
+ || isResumedActivityOnDisplay()) {
+ return false;
+ }
+
+ // Check if position in task allows to become paused
+ final int positionInTask = task.mActivities.indexOf(this);
+ if (positionInTask == -1) {
+ throw new IllegalStateException("Activity not found in its task");
+ }
+ if (positionInTask == task.mActivities.size() - 1) {
+ // It's the topmost activity in the task - should become paused now
+ return true;
+ }
+ // Check if activity above is finishing now and this one becomes the topmost in task.
+ final ActivityRecord activityAbove = task.mActivities.get(positionInTask + 1);
+ if (activityAbove.finishing && results == null) {
+ // We will only allow pausing if activity above wasn't launched for result. Otherwise it
+ // will cause this activity to resume before getting result.
+ return true;
+ }
+ return false;
+ }
+
+ boolean handleAlreadyVisible() {
+ stopFreezingScreenLocked(false);
+ try {
+ if (returningOptions != null) {
+ app.getThread().scheduleOnNewActivityOptions(appToken, returningOptions.toBundle());
+ }
+ } catch(RemoteException e) {
+ }
+ return mState == RESUMED;
+ }
+
+ static void activityResumedLocked(IBinder token) {
+ final ActivityRecord r = ActivityRecord.forTokenLocked(token);
+ if (DEBUG_SAVED_STATE) Slog.i(TAG_STATES, "Resumed activity; dropping state of: " + r);
+ if (r != null) {
+ r.icicle = null;
+ r.haveState = false;
+ }
+ }
+
+ /**
+ * Once we know that we have asked an application to put an activity in the resumed state
+ * (either by launching it or explicitly telling it), this function updates the rest of our
+ * state to match that fact.
+ */
+ void completeResumeLocked() {
+ final boolean wasVisible = visible;
+ setVisible(true);
+ if (!wasVisible) {
+ // Visibility has changed, so take a note of it so we call the TaskStackChangedListener
+ mStackSupervisor.mAppVisibilitiesChangedSinceLastPause = true;
+ }
+ idle = false;
+ results = null;
+ newIntents = null;
+ stopped = false;
+
+ if (isActivityTypeHome()) {
+ WindowProcessController app = task.mActivities.get(0).app;
+ if (hasProcess() && app != service.mHomeProcess) {
+ service.mHomeProcess = app;
+ }
+ }
+
+ if (nowVisible) {
+ // We won't get a call to reportActivityVisibleLocked() so dismiss lockscreen now.
+ mStackSupervisor.reportActivityVisibleLocked(this);
+ }
+
+ // Schedule an idle timeout in case the app doesn't do it for us.
+ mStackSupervisor.scheduleIdleTimeoutLocked(this);
+
+ mStackSupervisor.reportResumedActivityLocked(this);
+
+ resumeKeyDispatchingLocked();
+ final ActivityStack stack = getStack();
+ mStackSupervisor.mNoAnimActivities.clear();
+
+ // Mark the point when the activity is resuming
+ // TODO: To be more accurate, the mark should be before the onCreate,
+ // not after the onResume. But for subsequent starts, onResume is fine.
+ if (hasProcess()) {
+ cpuTimeAtResume = app.getCpuTime();
+ } else {
+ cpuTimeAtResume = 0; // Couldn't get the cpu time of process
+ }
+
+ returningOptions = null;
+
+ if (canTurnScreenOn()) {
+ mStackSupervisor.wakeUp("turnScreenOnFlag");
+ } else {
+ // If the screen is going to turn on because the caller explicitly requested it and
+ // the keyguard is not showing don't attempt to sleep. Otherwise the Activity will
+ // pause and then resume again later, which will result in a double life-cycle event.
+ stack.checkReadyForSleep();
+ }
+ }
+
+ final void activityStoppedLocked(Bundle newIcicle, PersistableBundle newPersistentState,
+ CharSequence description) {
+ final ActivityStack stack = getStack();
+ if (mState != STOPPING) {
+ Slog.i(TAG, "Activity reported stop, but no longer stopping: " + this);
+ stack.mHandler.removeMessages(STOP_TIMEOUT_MSG, this);
+ return;
+ }
+ if (newPersistentState != null) {
+ persistentState = newPersistentState;
+ service.notifyTaskPersisterLocked(task, false);
+ }
+ if (DEBUG_SAVED_STATE) Slog.i(TAG_SAVED_STATE, "Saving icicle of " + this + ": " + icicle);
+
+ if (newIcicle != null) {
+ // If icicle is null, this is happening due to a timeout, so we haven't really saved
+ // the state.
+ icicle = newIcicle;
+ haveState = true;
+ launchCount = 0;
+ updateTaskDescription(description);
+ }
+ if (!stopped) {
+ if (DEBUG_STATES) Slog.v(TAG_STATES, "Moving to STOPPED: " + this + " (stop complete)");
+ stack.mHandler.removeMessages(STOP_TIMEOUT_MSG, this);
+ stopped = true;
+ setState(STOPPED, "activityStoppedLocked");
+
+ mWindowContainerController.notifyAppStopped();
+
+ if (finishing) {
+ clearOptionsLocked();
+ } else {
+ if (deferRelaunchUntilPaused) {
+ stack.destroyActivityLocked(this, true /* removeFromApp */, "stop-config");
+ mStackSupervisor.resumeFocusedStacksTopActivitiesLocked();
+ } else {
+ mStackSupervisor.updatePreviousProcessLocked(this);
+ }
+ }
+ }
+ }
+
+ void startLaunchTickingLocked() {
+ if (Build.IS_USER) {
+ return;
+ }
+ if (launchTickTime == 0) {
+ launchTickTime = SystemClock.uptimeMillis();
+ continueLaunchTickingLocked();
+ }
+ }
+
+ boolean continueLaunchTickingLocked() {
+ if (launchTickTime == 0) {
+ return false;
+ }
+
+ final ActivityStack stack = getStack();
+ if (stack == null) {
+ return false;
+ }
+
+ Message msg = stack.mHandler.obtainMessage(LAUNCH_TICK_MSG, this);
+ stack.mHandler.removeMessages(LAUNCH_TICK_MSG);
+ stack.mHandler.sendMessageDelayed(msg, LAUNCH_TICK);
+ return true;
+ }
+
+ void finishLaunchTickingLocked() {
+ launchTickTime = 0;
+ final ActivityStack stack = getStack();
+ if (stack != null) {
+ stack.mHandler.removeMessages(LAUNCH_TICK_MSG);
+ }
+ }
+
+ // IApplicationToken
+
+ public boolean mayFreezeScreenLocked(WindowProcessController app) {
+ // Only freeze the screen if this activity is currently attached to
+ // an application, and that application is not blocked or unresponding.
+ // In any other case, we can't count on getting the screen unfrozen,
+ // so it is best to leave as-is.
+ return hasProcess() && !app.isCrashing() && !app.isNotResponding();
+ }
+
+ public void startFreezingScreenLocked(WindowProcessController app, int configChanges) {
+ if (mayFreezeScreenLocked(app)) {
+ mWindowContainerController.startFreezingScreen(configChanges);
+ }
+ }
+
+ public void stopFreezingScreenLocked(boolean force) {
+ if (force || frozenBeforeDestroy) {
+ frozenBeforeDestroy = false;
+ mWindowContainerController.stopFreezingScreen(force);
+ }
+ }
+
+ public void reportFullyDrawnLocked(boolean restoredFromBundle) {
+ final WindowingModeTransitionInfoSnapshot info = mStackSupervisor
+ .getActivityMetricsLogger().logAppTransitionReportedDrawn(this, restoredFromBundle);
+ if (info != null) {
+ mStackSupervisor.reportActivityLaunchedLocked(false /* timeout */, this,
+ info.windowsFullyDrawnDelayMs);
+ }
+ }
+ @Override
+ public void onStartingWindowDrawn(long timestamp) {
+ synchronized (service.mGlobalLock) {
+ mStackSupervisor.getActivityMetricsLogger().notifyStartingWindowDrawn(
+ getWindowingMode(), timestamp);
+ }
+ }
+
+ @Override
+ public void onWindowsDrawn(long timestamp) {
+ synchronized (service.mGlobalLock) {
+ final WindowingModeTransitionInfoSnapshot info = mStackSupervisor
+ .getActivityMetricsLogger().notifyWindowsDrawn(getWindowingMode(), timestamp);
+ final int windowsDrawnDelayMs = info != null ? info.windowsDrawnDelayMs : INVALID_DELAY;
+ mStackSupervisor.reportActivityLaunchedLocked(false /* timeout */, this,
+ windowsDrawnDelayMs);
+ mStackSupervisor.sendWaitingVisibleReportLocked(this);
+ finishLaunchTickingLocked();
+ if (task != null) {
+ task.hasBeenVisible = true;
+ }
+ }
+ }
+
+ @Override
+ public void onWindowsVisible() {
+ synchronized (service.mGlobalLock) {
+ mStackSupervisor.reportActivityVisibleLocked(this);
+ if (DEBUG_SWITCH) Log.v(TAG_SWITCH, "windowsVisibleLocked(): " + this);
+ if (!nowVisible) {
+ nowVisible = true;
+ lastVisibleTime = SystemClock.uptimeMillis();
+ if (idle || mStackSupervisor.isStoppingNoHistoryActivity()) {
+ // If this activity was already idle or there is an activity that must be
+ // stopped immediately after visible, then we now need to make sure we perform
+ // the full stop of any activities that are waiting to do so. This is because
+ // we won't do that while they are still waiting for this one to become visible.
+ final int size = mStackSupervisor.mActivitiesWaitingForVisibleActivity.size();
+ if (size > 0) {
+ for (int i = 0; i < size; i++) {
+ final ActivityRecord r =
+ mStackSupervisor.mActivitiesWaitingForVisibleActivity.get(i);
+ if (DEBUG_SWITCH) Log.v(TAG_SWITCH, "Was waiting for visible: " + r);
+ }
+ mStackSupervisor.mActivitiesWaitingForVisibleActivity.clear();
+ mStackSupervisor.scheduleIdleLocked();
+ }
+ } else {
+ // Instead of doing the full stop routine here, let's just hide any activities
+ // we now can, and let them stop when the normal idle happens.
+ mStackSupervisor.processStoppingActivitiesLocked(null /* idleActivity */,
+ false /* remove */, true /* processPausingActivities */);
+ }
+ service.scheduleAppGcsLocked();
+ }
+ }
+ }
+
+ @Override
+ public void onWindowsGone() {
+ synchronized (service.mGlobalLock) {
+ if (DEBUG_SWITCH) Log.v(TAG_SWITCH, "windowsGone(): " + this);
+ nowVisible = false;
+ }
+ }
+
+ @Override
+ public boolean keyDispatchingTimedOut(String reason, int windowPid) {
+ ActivityRecord anrActivity;
+ WindowProcessController anrApp;
+ boolean windowFromSameProcessAsActivity;
+ synchronized (service.mGlobalLock) {
+ anrActivity = getWaitingHistoryRecordLocked();
+ anrApp = app;
+ windowFromSameProcessAsActivity =
+ !hasProcess() || app.getPid() == windowPid || windowPid == -1;
+ }
+
+ if (windowFromSameProcessAsActivity) {
+ return service.mAmInternal.inputDispatchingTimedOut(anrApp.mOwner,
+ anrActivity.shortComponentName, anrActivity.appInfo, shortComponentName,
+ app, false, reason);
+ } else {
+ // In this case another process added windows using this activity token. So, we call the
+ // generic service input dispatch timed out method so that the right process is blamed.
+ return service.mAmInternal.inputDispatchingTimedOut(
+ windowPid, false /* aboveSystem */, reason) < 0;
+ }
+ }
+
+ private ActivityRecord getWaitingHistoryRecordLocked() {
+ // First find the real culprit... if this activity is waiting for
+ // another activity to start or has stopped, then the key dispatching
+ // timeout should not be caused by this.
+ if (mStackSupervisor.mActivitiesWaitingForVisibleActivity.contains(this) || stopped) {
+ final ActivityStack stack = mStackSupervisor.getTopDisplayFocusedStack();
+ // Try to use the one which is closest to top.
+ ActivityRecord r = stack.getResumedActivity();
+ if (r == null) {
+ r = stack.mPausingActivity;
+ }
+ if (r != null) {
+ return r;
+ }
+ }
+ return this;
+ }
+
+ /** Checks whether the activity should be shown for current user. */
+ public boolean okToShowLocked() {
+ // We cannot show activities when the device is locked and the application is not
+ // encryption aware.
+ if (!StorageManager.isUserKeyUnlocked(userId)
+ && !info.applicationInfo.isEncryptionAware()) {
+ return false;
+ }
+
+ return (info.flags & FLAG_SHOW_FOR_ALL_USERS) != 0
+ || (mStackSupervisor.isCurrentProfileLocked(userId)
+ && service.mAmInternal.isUserRunning(userId, 0 /* flags */));
+ }
+
+ /**
+ * This method will return true if the activity is either visible, is becoming visible, is
+ * currently pausing, or is resumed.
+ */
+ public boolean isInterestingToUserLocked() {
+ return visible || nowVisible || mState == PAUSING || mState == RESUMED;
+ }
+
+ void setSleeping(boolean _sleeping) {
+ setSleeping(_sleeping, false);
+ }
+
+ void setSleeping(boolean _sleeping, boolean force) {
+ if (!force && sleeping == _sleeping) {
+ return;
+ }
+ if (attachedToProcess()) {
+ try {
+ app.getThread().scheduleSleeping(appToken, _sleeping);
+ if (_sleeping && !mStackSupervisor.mGoingToSleepActivities.contains(this)) {
+ mStackSupervisor.mGoingToSleepActivities.add(this);
+ }
+ sleeping = _sleeping;
+ } catch (RemoteException e) {
+ Slog.w(TAG, "Exception thrown when sleeping: " + intent.getComponent(), e);
+ }
+ }
+ }
+
+ static int getTaskForActivityLocked(IBinder token, boolean onlyRoot) {
+ final ActivityRecord r = ActivityRecord.forTokenLocked(token);
+ if (r == null) {
+ return INVALID_TASK_ID;
+ }
+ final TaskRecord task = r.task;
+ final int activityNdx = task.mActivities.indexOf(r);
+ if (activityNdx < 0 || (onlyRoot && activityNdx > task.findEffectiveRootIndex())) {
+ return INVALID_TASK_ID;
+ }
+ return task.taskId;
+ }
+
+ static ActivityRecord isInStackLocked(IBinder token) {
+ final ActivityRecord r = ActivityRecord.forTokenLocked(token);
+ return (r != null) ? r.getStack().isInStackLocked(r) : null;
+ }
+
+ static ActivityStack getStackLocked(IBinder token) {
+ final ActivityRecord r = ActivityRecord.isInStackLocked(token);
+ if (r != null) {
+ return r.getStack();
+ }
+ return null;
+ }
+
+ /**
+ * @return display id to which this record is attached,
+ * {@link android.view.Display#INVALID_DISPLAY} if not attached.
+ */
+ int getDisplayId() {
+ final ActivityStack stack = getStack();
+ if (stack == null) {
+ return INVALID_DISPLAY;
+ }
+ return stack.mDisplayId;
+ }
+
+ final boolean isDestroyable() {
+ if (finishing || !hasProcess()) {
+ // This would be redundant.
+ return false;
+ }
+ final ActivityStack stack = getStack();
+ if (stack == null || this == stack.getResumedActivity() || this == stack.mPausingActivity
+ || !haveState || !stopped) {
+ // We're not ready for this kind of thing.
+ return false;
+ }
+ if (visible) {
+ // The user would notice this!
+ return false;
+ }
+ return true;
+ }
+
+ private static String createImageFilename(long createTime, int taskId) {
+ return String.valueOf(taskId) + ACTIVITY_ICON_SUFFIX + createTime +
+ IMAGE_EXTENSION;
+ }
+
+ void setTaskDescription(TaskDescription _taskDescription) {
+ Bitmap icon;
+ if (_taskDescription.getIconFilename() == null &&
+ (icon = _taskDescription.getIcon()) != null) {
+ final String iconFilename = createImageFilename(createTime, task.taskId);
+ final File iconFile = new File(TaskPersister.getUserImagesDir(task.userId),
+ iconFilename);
+ final String iconFilePath = iconFile.getAbsolutePath();
+ service.getRecentTasks().saveImage(icon, iconFilePath);
+ _taskDescription.setIconFilename(iconFilePath);
+ }
+ taskDescription = _taskDescription;
+ }
+
+ void setVoiceSessionLocked(IVoiceInteractionSession session) {
+ voiceSession = session;
+ pendingVoiceInteractionStart = false;
+ }
+
+ void clearVoiceSessionLocked() {
+ voiceSession = null;
+ pendingVoiceInteractionStart = false;
+ }
+
+ void showStartingWindow(ActivityRecord prev, boolean newTask, boolean taskSwitch) {
+ showStartingWindow(prev, newTask, taskSwitch, false /* fromRecents */);
+ }
+
+ void showStartingWindow(ActivityRecord prev, boolean newTask, boolean taskSwitch,
+ boolean fromRecents) {
+ if (mWindowContainerController == null) {
+ return;
+ }
+ if (mTaskOverlay) {
+ // We don't show starting window for overlay activities.
+ return;
+ }
+ if (pendingOptions != null
+ && pendingOptions.getAnimationType() == ActivityOptions.ANIM_SCENE_TRANSITION) {
+ // Don't show starting window when using shared element transition.
+ return;
+ }
+
+ final CompatibilityInfo compatInfo =
+ service.compatibilityInfoForPackageLocked(info.applicationInfo);
+ final boolean shown = mWindowContainerController.addStartingWindow(packageName, theme,
+ compatInfo, nonLocalizedLabel, labelRes, icon, logo, windowFlags,
+ prev != null ? prev.appToken : null, newTask, taskSwitch, isProcessRunning(),
+ allowTaskSnapshot(),
+ mState.ordinal() >= RESUMED.ordinal() && mState.ordinal() <= STOPPED.ordinal(),
+ fromRecents);
+ if (shown) {
+ mStartingWindowState = STARTING_WINDOW_SHOWN;
+ }
+ }
+
+ void removeOrphanedStartingWindow(boolean behindFullscreenActivity) {
+ if (mStartingWindowState == STARTING_WINDOW_SHOWN && behindFullscreenActivity) {
+ if (DEBUG_VISIBILITY) Slog.w(TAG_VISIBILITY, "Found orphaned starting window " + this);
+ mStartingWindowState = STARTING_WINDOW_REMOVED;
+ mWindowContainerController.removeStartingWindow();
+ }
+ }
+
+ int getRequestedOrientation() {
+ return mWindowContainerController.getOrientation();
+ }
+
+ void setRequestedOrientation(int requestedOrientation) {
+ final int displayId = getDisplayId();
+ final Configuration displayConfig =
+ mStackSupervisor.getDisplayOverrideConfiguration(displayId);
+
+ final Configuration config = mWindowContainerController.setOrientation(requestedOrientation,
+ displayId, displayConfig, mayFreezeScreenLocked(app));
+ if (config != null) {
+ frozenBeforeDestroy = true;
+ if (!service.updateDisplayOverrideConfigurationLocked(config, this,
+ false /* deferResume */, displayId)) {
+ mStackSupervisor.resumeFocusedStacksTopActivitiesLocked();
+ }
+ }
+ service.getTaskChangeNotificationController().notifyActivityRequestedOrientationChanged(
+ task.taskId, requestedOrientation);
+ }
+
+ void setDisablePreviewScreenshots(boolean disable) {
+ mWindowContainerController.setDisablePreviewScreenshots(disable);
+ }
+
+ /**
+ * Set the last reported global configuration to the client. Should be called whenever a new
+ * global configuration is sent to the client for this activity.
+ */
+ void setLastReportedGlobalConfiguration(@NonNull Configuration config) {
+ mLastReportedConfiguration.setGlobalConfiguration(config);
+ }
+
+ /**
+ * Set the last reported configuration to the client. Should be called whenever
+ * a new merged configuration is sent to the client for this activity.
+ */
+ void setLastReportedConfiguration(@NonNull MergedConfiguration config) {
+ setLastReportedConfiguration(config.getGlobalConfiguration(),
+ config.getOverrideConfiguration());
+ }
+
+ private void setLastReportedConfiguration(Configuration global, Configuration override) {
+ mLastReportedConfiguration.setConfiguration(global, override);
+ }
+
+ // TODO(b/36505427): Consider moving this method and similar ones to ConfigurationContainer.
+ private void updateOverrideConfiguration() {
+ mTmpConfig.unset();
+ computeBounds(mTmpBounds);
+
+ if (mTmpBounds.equals(getOverrideBounds())) {
+ return;
+ }
+
+ setBounds(mTmpBounds);
+
+ final Rect updatedBounds = getOverrideBounds();
+
+ // Bounds changed...update configuration to match.
+ if (!matchParentBounds()) {
+ task.computeOverrideConfiguration(mTmpConfig, updatedBounds, null /* insetBounds */,
+ false /* overrideWidth */, false /* overrideHeight */);
+ }
+
+ onOverrideConfigurationChanged(mTmpConfig);
+ }
+
+ /** Returns true if the configuration is compatible with this activity. */
+ boolean isConfigurationCompatible(Configuration config) {
+ final int orientation = mWindowContainerController != null
+ ? mWindowContainerController.getOrientation() : info.screenOrientation;
+ if (isFixedOrientationPortrait(orientation)
+ && config.orientation != ORIENTATION_PORTRAIT) {
+ return false;
+ }
+ if (isFixedOrientationLandscape(orientation)
+ && config.orientation != ORIENTATION_LANDSCAPE) {
+ return false;
+ }
+ return true;
+ }
+
+ /**
+ * Computes the bounds to fit the Activity within the bounds of the {@link Configuration}.
+ */
+ // TODO(b/36505427): Consider moving this method and similar ones to ConfigurationContainer.
+ private void computeBounds(Rect outBounds) {
+ outBounds.setEmpty();
+ final float maxAspectRatio = info.maxAspectRatio;
+ final ActivityStack stack = getStack();
+ if (task == null || stack == null || task.inMultiWindowMode() || maxAspectRatio == 0
+ || isInVrUiMode(getConfiguration())) {
+ // We don't set override configuration if that activity task isn't fullscreen. I.e. the
+ // activity is in multi-window mode. Or, there isn't a max aspect ratio specified for
+ // the activity. This is indicated by an empty {@link outBounds}. We also don't set it
+ // if we are in VR mode.
+ return;
+ }
+
+ // We must base this on the parent configuration, because we set our override
+ // configuration's appBounds based on the result of this method. If we used our own
+ // configuration, it would be influenced by past invocations.
+ final Rect appBounds = getParent().getWindowConfiguration().getAppBounds();
+ final int containingAppWidth = appBounds.width();
+ final int containingAppHeight = appBounds.height();
+ int maxActivityWidth = containingAppWidth;
+ int maxActivityHeight = containingAppHeight;
+
+ if (containingAppWidth < containingAppHeight) {
+ // Width is the shorter side, so we use that to figure-out what the max. height
+ // should be given the aspect ratio.
+ maxActivityHeight = (int) ((maxActivityWidth * maxAspectRatio) + 0.5f);
+ } else {
+ // Height is the shorter side, so we use that to figure-out what the max. width
+ // should be given the aspect ratio.
+ maxActivityWidth = (int) ((maxActivityHeight * maxAspectRatio) + 0.5f);
+ }
+
+ if (containingAppWidth <= maxActivityWidth && containingAppHeight <= maxActivityHeight) {
+ // The display matches or is less than the activity aspect ratio, so nothing else to do.
+ // Return the existing bounds. If this method is running for the first time,
+ // {@link #getOverrideBounds()} will be empty (representing no override). If the method has run
+ // before, then effect of {@link #getOverrideBounds()} will already have been applied to the
+ // value returned from {@link getConfiguration}. Refer to
+ // {@link TaskRecord#computeOverrideConfiguration}.
+ outBounds.set(getOverrideBounds());
+ return;
+ }
+
+ // Compute configuration based on max supported width and height.
+ // Also account for the left / top insets (e.g. from display cutouts), which will be clipped
+ // away later in StackWindowController.adjustConfigurationForBounds(). Otherwise, the app
+ // bounds would end up too small.
+ outBounds.set(0, 0, maxActivityWidth + appBounds.left, maxActivityHeight + appBounds.top);
+
+ if (service.mWindowManager.getNavBarPosition() == NAV_BAR_LEFT) {
+ // Position the activity frame on the opposite side of the nav bar.
+ outBounds.left = appBounds.right - maxActivityWidth;
+ outBounds.right = appBounds.right;
+ }
+ }
+
+ /**
+ * @return {@code true} if this activity was reparented to another display but
+ * {@link #ensureActivityConfiguration} is not called.
+ */
+ boolean shouldUpdateConfigForDisplayChanged() {
+ return mLastReportedDisplayId != getDisplayId();
+ }
+
+ boolean ensureActivityConfiguration(int globalChanges, boolean preserveWindow) {
+ return ensureActivityConfiguration(globalChanges, preserveWindow,
+ false /* ignoreStopState */);
+ }
+
+ /**
+ * Make sure the given activity matches the current configuration. Ensures the HistoryRecord
+ * is updated with the correct configuration and all other bookkeeping is handled.
+ *
+ * @param globalChanges The changes to the global configuration.
+ * @param preserveWindow If the activity window should be preserved on screen if the activity
+ * is relaunched.
+ * @param ignoreStopState If we should try to relaunch the activity even if it is in the stopped
+ * state. This is useful for the case where we know the activity will be
+ * visible soon and we want to ensure its configuration before we make it
+ * visible.
+ * @return True if the activity was relaunched and false if it wasn't relaunched because we
+ * can't or the app handles the specific configuration that is changing.
+ */
+ boolean ensureActivityConfiguration(int globalChanges, boolean preserveWindow,
+ boolean ignoreStopState) {
+ final ActivityStack stack = getStack();
+ if (stack.mConfigWillChange) {
+ if (DEBUG_SWITCH || DEBUG_CONFIGURATION) Slog.v(TAG_CONFIGURATION,
+ "Skipping config check (will change): " + this);
+ return true;
+ }
+
+ // We don't worry about activities that are finishing.
+ if (finishing) {
+ if (DEBUG_SWITCH || DEBUG_CONFIGURATION) Slog.v(TAG_CONFIGURATION,
+ "Configuration doesn't matter in finishing " + this);
+ stopFreezingScreenLocked(false);
+ return true;
+ }
+
+ if (!ignoreStopState && (mState == STOPPING || mState == STOPPED)) {
+ if (DEBUG_SWITCH || DEBUG_CONFIGURATION) Slog.v(TAG_CONFIGURATION,
+ "Skipping config check stopped or stopping: " + this);
+ return true;
+ }
+
+ // TODO: We should add ActivityRecord.shouldBeVisible() that checks if the activity should
+ // be visible based on the stack, task, and lockscreen state and use that here instead. The
+ // method should be based on the logic in ActivityStack.ensureActivitiesVisibleLocked().
+ // Skip updating configuration for activity is a stack that shouldn't be visible.
+ if (!stack.shouldBeVisible(null /* starting */)) {
+ if (DEBUG_SWITCH || DEBUG_CONFIGURATION) Slog.v(TAG_CONFIGURATION,
+ "Skipping config check invisible stack: " + this);
+ return true;
+ }
+
+ if (DEBUG_SWITCH || DEBUG_CONFIGURATION) Slog.v(TAG_CONFIGURATION,
+ "Ensuring correct configuration: " + this);
+
+ final int newDisplayId = getDisplayId();
+ final boolean displayChanged = mLastReportedDisplayId != newDisplayId;
+ if (displayChanged) {
+ mLastReportedDisplayId = newDisplayId;
+ }
+ // TODO(b/36505427): Is there a better place to do this?
+ updateOverrideConfiguration();
+
+ // Short circuit: if the two full configurations are equal (the common case), then there is
+ // nothing to do. We test the full configuration instead of the global and merged override
+ // configurations because there are cases (like moving a task to the pinned stack) where
+ // the combine configurations are equal, but would otherwise differ in the override config
+ mTmpConfig.setTo(mLastReportedConfiguration.getMergedConfiguration());
+ if (getConfiguration().equals(mTmpConfig) && !forceNewConfig && !displayChanged) {
+ if (DEBUG_SWITCH || DEBUG_CONFIGURATION) Slog.v(TAG_CONFIGURATION,
+ "Configuration & display unchanged in " + this);
+ return true;
+ }
+
+ // Okay we now are going to make this activity have the new config.
+ // But then we need to figure out how it needs to deal with that.
+
+ // Find changes between last reported merged configuration and the current one. This is used
+ // to decide whether to relaunch an activity or just report a configuration change.
+ final int changes = getConfigurationChanges(mTmpConfig);
+
+ // Update last reported values.
+ final Configuration newMergedOverrideConfig = getMergedOverrideConfiguration();
+
+ setLastReportedConfiguration(service.getGlobalConfiguration(), newMergedOverrideConfig);
+
+ if (mState == INITIALIZING) {
+ // No need to relaunch or schedule new config for activity that hasn't been launched
+ // yet. We do, however, return after applying the config to activity record, so that
+ // it will use it for launch transaction.
+ if (DEBUG_SWITCH || DEBUG_CONFIGURATION) Slog.v(TAG_CONFIGURATION,
+ "Skipping config check for initializing activity: " + this);
+ return true;
+ }
+
+ if (changes == 0 && !forceNewConfig) {
+ if (DEBUG_SWITCH || DEBUG_CONFIGURATION) Slog.v(TAG_CONFIGURATION,
+ "Configuration no differences in " + this);
+ // There are no significant differences, so we won't relaunch but should still deliver
+ // the new configuration to the client process.
+ if (displayChanged) {
+ scheduleActivityMovedToDisplay(newDisplayId, newMergedOverrideConfig);
+ } else {
+ scheduleConfigurationChanged(newMergedOverrideConfig);
+ }
+ return true;
+ }
+
+ if (DEBUG_SWITCH || DEBUG_CONFIGURATION) Slog.v(TAG_CONFIGURATION,
+ "Configuration changes for " + this + ", allChanges="
+ + Configuration.configurationDiffToString(changes));
+
+ // If the activity isn't currently running, just leave the new configuration and it will
+ // pick that up next time it starts.
+ if (!attachedToProcess()) {
+ if (DEBUG_SWITCH || DEBUG_CONFIGURATION) Slog.v(TAG_CONFIGURATION,
+ "Configuration doesn't matter not running " + this);
+ stopFreezingScreenLocked(false);
+ forceNewConfig = false;
+ return true;
+ }
+
+ // Figure out how to handle the changes between the configurations.
+ if (DEBUG_SWITCH || DEBUG_CONFIGURATION) Slog.v(TAG_CONFIGURATION,
+ "Checking to restart " + info.name + ": changed=0x"
+ + Integer.toHexString(changes) + ", handles=0x"
+ + Integer.toHexString(info.getRealConfigChanged())
+ + ", mLastReportedConfiguration=" + mLastReportedConfiguration);
+
+ if (shouldRelaunchLocked(changes, mTmpConfig) || forceNewConfig) {
+ // Aha, the activity isn't handling the change, so DIE DIE DIE.
+ configChangeFlags |= changes;
+ startFreezingScreenLocked(app, globalChanges);
+ forceNewConfig = false;
+ preserveWindow &= isResizeOnlyChange(changes);
+ final boolean hasResizeChange = hasResizeChange(changes & ~info.getRealConfigChanged());
+ if (hasResizeChange) {
+ final boolean isDragResizing =
+ getTask().getWindowContainerController().isDragResizing();
+ mRelaunchReason = isDragResizing ? RELAUNCH_REASON_FREE_RESIZE
+ : RELAUNCH_REASON_WINDOWING_MODE_RESIZE;
+ } else {
+ mRelaunchReason = RELAUNCH_REASON_NONE;
+ }
+ if (!attachedToProcess()) {
+ if (DEBUG_SWITCH || DEBUG_CONFIGURATION) Slog.v(TAG_CONFIGURATION,
+ "Config is destroying non-running " + this);
+ stack.destroyActivityLocked(this, true, "config");
+ } else if (mState == PAUSING) {
+ // A little annoying: we are waiting for this activity to finish pausing. Let's not
+ // do anything now, but just flag that it needs to be restarted when done pausing.
+ if (DEBUG_SWITCH || DEBUG_CONFIGURATION) Slog.v(TAG_CONFIGURATION,
+ "Config is skipping already pausing " + this);
+ deferRelaunchUntilPaused = true;
+ preserveWindowOnDeferredRelaunch = preserveWindow;
+ return true;
+ } else if (mState == RESUMED) {
+ // Try to optimize this case: the configuration is changing and we need to restart
+ // the top, resumed activity. Instead of doing the normal handshaking, just say
+ // "restart!".
+ if (DEBUG_SWITCH || DEBUG_CONFIGURATION) Slog.v(TAG_CONFIGURATION,
+ "Config is relaunching resumed " + this);
+
+ if (DEBUG_STATES && !visible) {
+ Slog.v(TAG_STATES, "Config is relaunching resumed invisible activity " + this
+ + " called by " + Debug.getCallers(4));
+ }
+
+ relaunchActivityLocked(true /* andResume */, preserveWindow);
+ } else {
+ if (DEBUG_SWITCH || DEBUG_CONFIGURATION) Slog.v(TAG_CONFIGURATION,
+ "Config is relaunching non-resumed " + this);
+ relaunchActivityLocked(false /* andResume */, preserveWindow);
+ }
+
+ // All done... tell the caller we weren't able to keep this activity around.
+ return false;
+ }
+
+ // Default case: the activity can handle this new configuration, so hand it over.
+ // NOTE: We only forward the override configuration as the system level configuration
+ // changes is always sent to all processes when they happen so it can just use whatever
+ // system level configuration it last got.
+ if (displayChanged) {
+ scheduleActivityMovedToDisplay(newDisplayId, newMergedOverrideConfig);
+ } else {
+ scheduleConfigurationChanged(newMergedOverrideConfig);
+ }
+ stopFreezingScreenLocked(false);
+
+ return true;
+ }
+
+ /**
+ * When assessing a configuration change, decide if the changes flags and the new configurations
+ * should cause the Activity to relaunch.
+ *
+ * @param changes the changes due to the given configuration.
+ * @param changesConfig the configuration that was used to calculate the given changes via a
+ * call to getConfigurationChanges.
+ */
+ private boolean shouldRelaunchLocked(int changes, Configuration changesConfig) {
+ int configChanged = info.getRealConfigChanged();
+ boolean onlyVrUiModeChanged = onlyVrUiModeChanged(changes, changesConfig);
+
+ // Override for apps targeting pre-O sdks
+ // If a device is in VR mode, and we're transitioning into VR ui mode, add ignore ui mode
+ // to the config change.
+ // For O and later, apps will be required to add configChanges="uimode" to their manifest.
+ if (appInfo.targetSdkVersion < O
+ && requestedVrComponent != null
+ && onlyVrUiModeChanged) {
+ configChanged |= CONFIG_UI_MODE;
+ }
+
+ return (changes&(~configChanged)) != 0;
+ }
+
+ /**
+ * Returns true if the configuration change is solely due to the UI mode switching into or out
+ * of UI_MODE_TYPE_VR_HEADSET.
+ */
+ private boolean onlyVrUiModeChanged(int changes, Configuration lastReportedConfig) {
+ final Configuration currentConfig = getConfiguration();
+ return changes == CONFIG_UI_MODE && (isInVrUiMode(currentConfig)
+ != isInVrUiMode(lastReportedConfig));
+ }
+
+ private int getConfigurationChanges(Configuration lastReportedConfig) {
+ // Determine what has changed. May be nothing, if this is a config that has come back from
+ // the app after going idle. In that case we just want to leave the official config object
+ // now in the activity and do nothing else.
+ final Configuration currentConfig = getConfiguration();
+ int changes = lastReportedConfig.diff(currentConfig);
+ // We don't want to use size changes if they don't cross boundaries that are important to
+ // the app.
+ if ((changes & CONFIG_SCREEN_SIZE) != 0) {
+ final boolean crosses = crossesHorizontalSizeThreshold(lastReportedConfig.screenWidthDp,
+ currentConfig.screenWidthDp)
+ || crossesVerticalSizeThreshold(lastReportedConfig.screenHeightDp,
+ currentConfig.screenHeightDp);
+ if (!crosses) {
+ changes &= ~CONFIG_SCREEN_SIZE;
+ }
+ }
+ if ((changes & CONFIG_SMALLEST_SCREEN_SIZE) != 0) {
+ final int oldSmallest = lastReportedConfig.smallestScreenWidthDp;
+ final int newSmallest = currentConfig.smallestScreenWidthDp;
+ if (!crossesSmallestSizeThreshold(oldSmallest, newSmallest)) {
+ changes &= ~CONFIG_SMALLEST_SCREEN_SIZE;
+ }
+ }
+ // We don't want window configuration to cause relaunches.
+ if ((changes & CONFIG_WINDOW_CONFIGURATION) != 0) {
+ changes &= ~CONFIG_WINDOW_CONFIGURATION;
+ }
+
+ return changes;
+ }
+
+ private static boolean isResizeOnlyChange(int change) {
+ return (change & ~(CONFIG_SCREEN_SIZE | CONFIG_SMALLEST_SCREEN_SIZE | CONFIG_ORIENTATION
+ | CONFIG_SCREEN_LAYOUT)) == 0;
+ }
+
+ private static boolean hasResizeChange(int change) {
+ return (change & (CONFIG_SCREEN_SIZE | CONFIG_SMALLEST_SCREEN_SIZE | CONFIG_ORIENTATION
+ | CONFIG_SCREEN_LAYOUT)) != 0;
+ }
+
+ void relaunchActivityLocked(boolean andResume, boolean preserveWindow) {
+ if (service.mSuppressResizeConfigChanges && preserveWindow) {
+ configChangeFlags = 0;
+ return;
+ }
+
+ List<ResultInfo> pendingResults = null;
+ List<ReferrerIntent> pendingNewIntents = null;
+ if (andResume) {
+ pendingResults = results;
+ pendingNewIntents = newIntents;
+ }
+ if (DEBUG_SWITCH) Slog.v(TAG_SWITCH,
+ "Relaunching: " + this + " with results=" + pendingResults
+ + " newIntents=" + pendingNewIntents + " andResume=" + andResume
+ + " preserveWindow=" + preserveWindow);
+ EventLog.writeEvent(andResume ? AM_RELAUNCH_RESUME_ACTIVITY
+ : AM_RELAUNCH_ACTIVITY, userId, System.identityHashCode(this),
+ task.taskId, shortComponentName);
+
+ startFreezingScreenLocked(app, 0);
+
+ try {
+ if (DEBUG_SWITCH || DEBUG_STATES) Slog.i(TAG_SWITCH,
+ "Moving to " + (andResume ? "RESUMED" : "PAUSED") + " Relaunching " + this
+ + " callers=" + Debug.getCallers(6));
+ forceNewConfig = false;
+ mStackSupervisor.activityRelaunchingLocked(this);
+ final ClientTransactionItem callbackItem = ActivityRelaunchItem.obtain(pendingResults,
+ pendingNewIntents, configChangeFlags,
+ new MergedConfiguration(service.getGlobalConfiguration(),
+ getMergedOverrideConfiguration()),
+ preserveWindow);
+ final ActivityLifecycleItem lifecycleItem;
+ if (andResume) {
+ lifecycleItem = ResumeActivityItem.obtain(
+ getDisplay().getWindowContainerController().isNextTransitionForward());
+ } else {
+ lifecycleItem = PauseActivityItem.obtain();
+ }
+ final ClientTransaction transaction = ClientTransaction.obtain(app.getThread(), appToken);
+ transaction.addCallback(callbackItem);
+ transaction.setLifecycleStateRequest(lifecycleItem);
+ service.getLifecycleManager().scheduleTransaction(transaction);
+ // Note: don't need to call pauseIfSleepingLocked() here, because the caller will only
+ // request resume if this activity is currently resumed, which implies we aren't
+ // sleeping.
+ } catch (RemoteException e) {
+ if (DEBUG_SWITCH || DEBUG_STATES) Slog.i(TAG_SWITCH, "Relaunch failed", e);
+ }
+
+ if (andResume) {
+ if (DEBUG_STATES) {
+ Slog.d(TAG_STATES, "Resumed after relaunch " + this);
+ }
+ results = null;
+ newIntents = null;
+ service.getAppWarningsLocked().onResumeActivity(this);
+ } else {
+ final ActivityStack stack = getStack();
+ if (stack != null) {
+ stack.mHandler.removeMessages(PAUSE_TIMEOUT_MSG, this);
+ }
+ setState(PAUSED, "relaunchActivityLocked");
+ }
+
+ configChangeFlags = 0;
+ deferRelaunchUntilPaused = false;
+ preserveWindowOnDeferredRelaunch = false;
+ }
+
+ private boolean isProcessRunning() {
+ WindowProcessController proc = app;
+ if (proc == null) {
+ proc = service.mProcessNames.get(processName, info.applicationInfo.uid);
+ }
+ return proc != null && proc.hasThread();
+ }
+
+ /**
+ * @return Whether a task snapshot starting window may be shown.
+ */
+ private boolean allowTaskSnapshot() {
+ if (newIntents == null) {
+ return true;
+ }
+
+ // Restrict task snapshot starting window to launcher start, or there is no intent at all
+ // (eg. task being brought to front). If the intent is something else, likely the app is
+ // going to show some specific page or view, instead of what's left last time.
+ for (int i = newIntents.size() - 1; i >= 0; i--) {
+ final Intent intent = newIntents.get(i);
+ if (intent != null && !ActivityRecord.isMainIntent(intent)) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ /**
+ * Returns {@code true} if the associated activity has the no history flag set on it.
+ * {@code false} otherwise.
+ */
+ boolean isNoHistory() {
+ return (intent.getFlags() & FLAG_ACTIVITY_NO_HISTORY) != 0
+ || (info.flags & FLAG_NO_HISTORY) != 0;
+ }
+
+ void saveToXml(XmlSerializer out) throws IOException, XmlPullParserException {
+ out.attribute(null, ATTR_ID, String.valueOf(createTime));
+ out.attribute(null, ATTR_LAUNCHEDFROMUID, String.valueOf(launchedFromUid));
+ if (launchedFromPackage != null) {
+ out.attribute(null, ATTR_LAUNCHEDFROMPACKAGE, launchedFromPackage);
+ }
+ if (resolvedType != null) {
+ out.attribute(null, ATTR_RESOLVEDTYPE, resolvedType);
+ }
+ out.attribute(null, ATTR_COMPONENTSPECIFIED, String.valueOf(componentSpecified));
+ out.attribute(null, ATTR_USERID, String.valueOf(userId));
+
+ if (taskDescription != null) {
+ taskDescription.saveToXml(out);
+ }
+
+ out.startTag(null, TAG_INTENT);
+ intent.saveToXml(out);
+ out.endTag(null, TAG_INTENT);
+
+ if (isPersistable() && persistentState != null) {
+ out.startTag(null, TAG_PERSISTABLEBUNDLE);
+ persistentState.saveToXml(out);
+ out.endTag(null, TAG_PERSISTABLEBUNDLE);
+ }
+ }
+
+ static ActivityRecord restoreFromXml(XmlPullParser in,
+ ActivityStackSupervisor stackSupervisor) throws IOException, XmlPullParserException {
+ Intent intent = null;
+ PersistableBundle persistentState = null;
+ int launchedFromUid = 0;
+ String launchedFromPackage = null;
+ String resolvedType = null;
+ boolean componentSpecified = false;
+ int userId = 0;
+ long createTime = -1;
+ final int outerDepth = in.getDepth();
+ TaskDescription taskDescription = new TaskDescription();
+
+ for (int attrNdx = in.getAttributeCount() - 1; attrNdx >= 0; --attrNdx) {
+ final String attrName = in.getAttributeName(attrNdx);
+ final String attrValue = in.getAttributeValue(attrNdx);
+ if (DEBUG) Slog.d(TaskPersister.TAG,
+ "ActivityRecord: attribute name=" + attrName + " value=" + attrValue);
+ if (ATTR_ID.equals(attrName)) {
+ createTime = Long.parseLong(attrValue);
+ } else if (ATTR_LAUNCHEDFROMUID.equals(attrName)) {
+ launchedFromUid = Integer.parseInt(attrValue);
+ } else if (ATTR_LAUNCHEDFROMPACKAGE.equals(attrName)) {
+ launchedFromPackage = attrValue;
+ } else if (ATTR_RESOLVEDTYPE.equals(attrName)) {
+ resolvedType = attrValue;
+ } else if (ATTR_COMPONENTSPECIFIED.equals(attrName)) {
+ componentSpecified = Boolean.parseBoolean(attrValue);
+ } else if (ATTR_USERID.equals(attrName)) {
+ userId = Integer.parseInt(attrValue);
+ } else if (attrName.startsWith(ATTR_TASKDESCRIPTION_PREFIX)) {
+ taskDescription.restoreFromXml(attrName, attrValue);
+ } else {
+ Log.d(TAG, "Unknown ActivityRecord attribute=" + attrName);
+ }
+ }
+
+ int event;
+ while (((event = in.next()) != END_DOCUMENT) &&
+ (event != END_TAG || in.getDepth() >= outerDepth)) {
+ if (event == START_TAG) {
+ final String name = in.getName();
+ if (DEBUG)
+ Slog.d(TaskPersister.TAG, "ActivityRecord: START_TAG name=" + name);
+ if (TAG_INTENT.equals(name)) {
+ intent = Intent.restoreFromXml(in);
+ if (DEBUG)
+ Slog.d(TaskPersister.TAG, "ActivityRecord: intent=" + intent);
+ } else if (TAG_PERSISTABLEBUNDLE.equals(name)) {
+ persistentState = PersistableBundle.restoreFromXml(in);
+ if (DEBUG) Slog.d(TaskPersister.TAG,
+ "ActivityRecord: persistentState=" + persistentState);
+ } else {
+ Slog.w(TAG, "restoreActivity: unexpected name=" + name);
+ XmlUtils.skipCurrentTag(in);
+ }
+ }
+ }
+
+ if (intent == null) {
+ throw new XmlPullParserException("restoreActivity error intent=" + intent);
+ }
+
+ final ActivityTaskManagerService service = stackSupervisor.mService;
+ final ActivityInfo aInfo = stackSupervisor.resolveActivity(intent, resolvedType, 0, null,
+ userId, Binder.getCallingUid());
+ if (aInfo == null) {
+ throw new XmlPullParserException("restoreActivity resolver error. Intent=" + intent +
+ " resolvedType=" + resolvedType);
+ }
+ final ActivityRecord r = new ActivityRecord(service, null /* caller */,
+ 0 /* launchedFromPid */, launchedFromUid, launchedFromPackage, intent, resolvedType,
+ aInfo, service.getConfiguration(), null /* resultTo */, null /* resultWho */,
+ 0 /* reqCode */, componentSpecified, false /* rootVoiceInteraction */,
+ stackSupervisor, null /* options */, null /* sourceRecord */);
+
+ r.persistentState = persistentState;
+ r.taskDescription = taskDescription;
+ r.createTime = createTime;
+
+ return r;
+ }
+
+ private static boolean isInVrUiMode(Configuration config) {
+ return (config.uiMode & UI_MODE_TYPE_MASK) == UI_MODE_TYPE_VR_HEADSET;
+ }
+
+ int getUid() {
+ return info.applicationInfo.uid;
+ }
+
+ void setShowWhenLocked(boolean showWhenLocked) {
+ mShowWhenLocked = showWhenLocked;
+ mStackSupervisor.ensureActivitiesVisibleLocked(null, 0 /* configChanges */,
+ false /* preserveWindows */);
+ }
+
+ /**
+ * @return true if the activity windowing mode is not
+ * {@link android.app.WindowConfiguration#WINDOWING_MODE_PINNED} and activity contains
+ * windows that have {@link LayoutParams#FLAG_SHOW_WHEN_LOCKED} set or if the activity
+ * has set {@link #mShowWhenLocked}.
+ * Multi-windowing mode will be exited if true is returned.
+ */
+ boolean canShowWhenLocked() {
+ return !inPinnedWindowingMode() && (mShowWhenLocked
+ || service.mWindowManager.containsShowWhenLockedWindow(appToken));
+ }
+
+ void setTurnScreenOn(boolean turnScreenOn) {
+ mTurnScreenOn = turnScreenOn;
+ }
+
+ /**
+ * Determines whether this ActivityRecord can turn the screen on. It checks whether the flag
+ * {@link #mTurnScreenOn} is set and checks whether the ActivityRecord should be visible
+ * depending on Keyguard state
+ *
+ * @return true if the screen can be turned on, false otherwise.
+ */
+ boolean canTurnScreenOn() {
+ final ActivityStack stack = getStack();
+ return mTurnScreenOn && stack != null &&
+ stack.checkKeyguardVisibility(this, true /* shouldBeVisible */, true /* isTop */);
+ }
+
+ boolean getTurnScreenOnFlag() {
+ return mTurnScreenOn;
+ }
+
+ boolean isTopRunningActivity() {
+ return mStackSupervisor.topRunningActivityLocked() == this;
+ }
+
+ /**
+ * @return {@code true} if this is the resumed activity on its current display, {@code false}
+ * otherwise.
+ */
+ boolean isResumedActivityOnDisplay() {
+ final ActivityDisplay display = getDisplay();
+ return display != null && this == display.getResumedActivity();
+ }
+
+ void registerRemoteAnimations(RemoteAnimationDefinition definition) {
+ mWindowContainerController.registerRemoteAnimations(definition);
+ }
+
+ @Override
+ public String toString() {
+ if (stringName != null) {
+ return stringName + " t" + (task == null ? INVALID_TASK_ID : task.taskId) +
+ (finishing ? " f}" : "}");
+ }
+ StringBuilder sb = new StringBuilder(128);
+ sb.append("ActivityRecord{");
+ sb.append(Integer.toHexString(System.identityHashCode(this)));
+ sb.append(" u");
+ sb.append(userId);
+ sb.append(' ');
+ sb.append(intent.getComponent().flattenToShortString());
+ stringName = sb.toString();
+ return toString();
+ }
+
+ void writeIdentifierToProto(ProtoOutputStream proto, long fieldId) {
+ final long token = proto.start(fieldId);
+ proto.write(HASH_CODE, System.identityHashCode(this));
+ proto.write(USER_ID, userId);
+ proto.write(TITLE, intent.getComponent().flattenToShortString());
+ proto.end(token);
+ }
+
+ public void writeToProto(ProtoOutputStream proto, long fieldId) {
+ final long token = proto.start(fieldId);
+ super.writeToProto(proto, CONFIGURATION_CONTAINER, false /* trim */);
+ writeIdentifierToProto(proto, IDENTIFIER);
+ proto.write(STATE, mState.toString());
+ proto.write(VISIBLE, visible);
+ proto.write(FRONT_OF_TASK, frontOfTask);
+ if (hasProcess()) {
+ proto.write(PROC_ID, app.getPid());
+ }
+ proto.write(TRANSLUCENT, !fullscreen);
+ proto.end(token);
+ }
+}
diff --git a/services/core/java/com/android/server/wm/ActivityResult.java b/services/core/java/com/android/server/wm/ActivityResult.java
new file mode 100644
index 0000000..f2510de
--- /dev/null
+++ b/services/core/java/com/android/server/wm/ActivityResult.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2006 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.server.wm;
+
+import android.app.ResultInfo;
+import android.content.Intent;
+
+/**
+ * Pending result information to send back to an activity.
+ */
+final class ActivityResult extends ResultInfo {
+ final ActivityRecord mFrom;
+
+ public ActivityResult(ActivityRecord from, String resultWho,
+ int requestCode, int resultCode, Intent data) {
+ super(resultWho, requestCode, resultCode, data);
+ mFrom = from;
+ }
+}
diff --git a/services/core/java/com/android/server/wm/ActivityServiceConnectionsHolder.java b/services/core/java/com/android/server/wm/ActivityServiceConnectionsHolder.java
new file mode 100644
index 0000000..ad46248
--- /dev/null
+++ b/services/core/java/com/android/server/wm/ActivityServiceConnectionsHolder.java
@@ -0,0 +1,113 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.server.wm;
+
+import static com.android.server.wm.ActivityStack.ActivityState.PAUSING;
+import static com.android.server.wm.ActivityStack.ActivityState.RESUMED;
+
+import java.io.PrintWriter;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.function.Consumer;
+
+/**
+ * Class for tracking the connections to services on the AM side that activities on the
+ * WM side (in the future) bind with for things like oom score adjustment. Would normally be one
+ * instance of this per activity for tracking all services connected to that activity. AM will
+ * sometimes query this to bump the OOM score for the processes with services connected to visible
+ * activities.
+ */
+public class ActivityServiceConnectionsHolder<T> {
+
+ private final ActivityTaskManagerService mService;
+
+ /** The activity the owns this service connection object. */
+ private final ActivityRecord mActivity;
+
+ /**
+ * The service connection object bounded with the owning activity. They represent
+ * ConnectionRecord on the AM side, however we don't need to know their object representation
+ * on the WM side since we don't perform operations on the object. Mainly here for communication
+ * and booking with the AM side.
+ */
+ private HashSet<T> mConnections;
+
+ ActivityServiceConnectionsHolder(ActivityTaskManagerService service, ActivityRecord activity) {
+ mService = service;
+ mActivity = activity;
+ }
+
+ /** Adds a connection record that the activity has bound to a specific service. */
+ public void addConnection(T c) {
+ synchronized (mService.mGlobalLock) {
+ if (mConnections == null) {
+ mConnections = new HashSet<>();
+ }
+ mConnections.add(c);
+ }
+ }
+
+ /** Removed a connection record between the activity and a specific service. */
+ public void removeConnection(T c) {
+ synchronized (mService.mGlobalLock) {
+ if (mConnections == null) {
+ return;
+ }
+ mConnections.remove(c);
+ }
+ }
+
+ public boolean isActivityVisible() {
+ synchronized (mService.mGlobalLock) {
+ return mActivity.visible || mActivity.isState(RESUMED, PAUSING);
+ }
+ }
+
+ public int getActivityPid() {
+ synchronized (mService.mGlobalLock) {
+ return mActivity.hasProcess() ? mActivity.app.getPid() : -1;
+ }
+ }
+
+ public void forEachConnection(Consumer<T> consumer) {
+ synchronized (mService.mGlobalLock) {
+ if (mConnections == null || mConnections.isEmpty()) {
+ return;
+ }
+ final Iterator<T> it = mConnections.iterator();
+ while (it.hasNext()) {
+ T c = it.next();
+ consumer.accept(c);
+ }
+ }
+ }
+
+ /** Removes the connection between the activity and all services that were connected to it. */
+ void disconnectActivityFromServices() {
+ if (mConnections == null || mConnections.isEmpty()) {
+ return;
+ }
+ mService.mH.post(() -> mService.mAmInternal.disconnectActivityFromServices(this));
+ }
+
+ public void dump(PrintWriter pw, String prefix) {
+ synchronized (mService.mGlobalLock) {
+ pw.println(prefix + "activity=" + mActivity);
+ }
+ }
+
+}
diff --git a/services/core/java/com/android/server/wm/ActivityStack.java b/services/core/java/com/android/server/wm/ActivityStack.java
new file mode 100644
index 0000000..a8b4a9d
--- /dev/null
+++ b/services/core/java/com/android/server/wm/ActivityStack.java
@@ -0,0 +1,5462 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.server.wm;
+
+import static android.app.ITaskStackListener.FORCED_RESIZEABLE_REASON_SPLIT_SCREEN;
+import static android.app.WindowConfiguration.ACTIVITY_TYPE_ASSISTANT;
+import static android.app.WindowConfiguration.ACTIVITY_TYPE_HOME;
+import static android.app.WindowConfiguration.ACTIVITY_TYPE_RECENTS;
+import static android.app.WindowConfiguration.ACTIVITY_TYPE_STANDARD;
+import static android.app.WindowConfiguration.ACTIVITY_TYPE_UNDEFINED;
+import static android.app.WindowConfiguration.WINDOWING_MODE_FREEFORM;
+import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN;
+import static android.app.WindowConfiguration.WINDOWING_MODE_PINNED;
+import static android.app.WindowConfiguration.WINDOWING_MODE_SPLIT_SCREEN_PRIMARY;
+import static android.app.WindowConfiguration.WINDOWING_MODE_SPLIT_SCREEN_SECONDARY;
+import static android.app.WindowConfiguration.WINDOWING_MODE_UNDEFINED;
+import static android.app.WindowConfiguration.activityTypeToString;
+import static android.app.WindowConfiguration.windowingModeToString;
+import static android.content.pm.ActivityInfo.CONFIG_SCREEN_LAYOUT;
+import static android.content.pm.ActivityInfo.FLAG_RESUME_WHILE_PAUSING;
+import static android.content.pm.ActivityInfo.FLAG_SHOW_FOR_ALL_USERS;
+import static android.view.Display.DEFAULT_DISPLAY;
+import static android.view.Display.FLAG_CAN_SHOW_WITH_INSECURE_KEYGUARD;
+import static android.view.Display.INVALID_DISPLAY;
+import static android.view.WindowManager.TRANSIT_ACTIVITY_CLOSE;
+import static android.view.WindowManager.TRANSIT_ACTIVITY_OPEN;
+import static android.view.WindowManager.TRANSIT_CRASHING_ACTIVITY_CLOSE;
+import static android.view.WindowManager.TRANSIT_NONE;
+import static android.view.WindowManager.TRANSIT_TASK_CLOSE;
+import static android.view.WindowManager.TRANSIT_TASK_OPEN;
+import static android.view.WindowManager.TRANSIT_TASK_OPEN_BEHIND;
+import static android.view.WindowManager.TRANSIT_TASK_TO_BACK;
+import static android.view.WindowManager.TRANSIT_TASK_TO_FRONT;
+
+import static com.android.server.wm.ActivityDisplay.POSITION_BOTTOM;
+import static com.android.server.wm.ActivityDisplay.POSITION_TOP;
+import static com.android.server.wm.ActivityStack.ActivityState.DESTROYED;
+import static com.android.server.wm.ActivityStack.ActivityState.DESTROYING;
+import static com.android.server.wm.ActivityStack.ActivityState.FINISHING;
+import static com.android.server.wm.ActivityStack.ActivityState.PAUSED;
+import static com.android.server.wm.ActivityStack.ActivityState.PAUSING;
+import static com.android.server.wm.ActivityStack.ActivityState.RESUMED;
+import static com.android.server.wm.ActivityStack.ActivityState.STOPPED;
+import static com.android.server.wm.ActivityStack.ActivityState.STOPPING;
+import static com.android.server.am.ActivityStackProto.BOUNDS;
+import static com.android.server.am.ActivityStackProto.CONFIGURATION_CONTAINER;
+import static com.android.server.am.ActivityStackProto.DISPLAY_ID;
+import static com.android.server.am.ActivityStackProto.FULLSCREEN;
+import static com.android.server.am.ActivityStackProto.ID;
+import static com.android.server.am.ActivityStackProto.RESUMED_ACTIVITY;
+import static com.android.server.am.ActivityStackProto.TASKS;
+import static com.android.server.wm.ActivityStackSupervisor.FindTaskResult;
+import static com.android.server.wm.ActivityStackSupervisor.PAUSE_IMMEDIATELY;
+import static com.android.server.wm.ActivityStackSupervisor.PRESERVE_WINDOWS;
+import static com.android.server.wm.ActivityStackSupervisor.REMOVE_FROM_RECENTS;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_ADD_REMOVE;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_ALL;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_APP;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_CLEANUP;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_CONTAINERS;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_PAUSE;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_RELEASE;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_RESULTS;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_SAVED_STATE;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_STACK;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_STATES;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_SWITCH;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_TASKS;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_TRANSITION;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_USER_LEAVING;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_VISIBILITY;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_ADD_REMOVE;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_APP;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_CLEANUP;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_CONTAINERS;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_PAUSE;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_RELEASE;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_RESULTS;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_SAVED_STATE;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_STACK;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_STATES;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_SWITCH;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_TASKS;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_TRANSITION;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_USER_LEAVING;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_VISIBILITY;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_ATM;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_WITH_CLASS_NAME;
+import static com.android.server.wm.ActivityTaskManagerService.H.FIRST_ACTIVITY_STACK_MSG;
+import static com.android.server.wm.ActivityTaskManagerService.RELAUNCH_REASON_FREE_RESIZE;
+import static com.android.server.wm.ActivityTaskManagerService.RELAUNCH_REASON_WINDOWING_MODE_RESIZE;
+
+import static java.lang.Integer.MAX_VALUE;
+
+import android.app.Activity;
+import android.app.ActivityManager;
+import android.app.ActivityManagerInternal;
+import android.app.ActivityOptions;
+import android.app.AppGlobals;
+import android.app.IActivityController;
+import android.app.ResultInfo;
+import android.app.WindowConfiguration.ActivityType;
+import android.app.WindowConfiguration.WindowingMode;
+import android.app.servertransaction.ActivityResultItem;
+import android.app.servertransaction.ClientTransaction;
+import android.app.servertransaction.DestroyActivityItem;
+import android.app.servertransaction.NewIntentItem;
+import android.app.servertransaction.PauseActivityItem;
+import android.app.servertransaction.ResumeActivityItem;
+import android.app.servertransaction.StopActivityItem;
+import android.app.servertransaction.WindowVisibilityItem;
+import android.content.ComponentName;
+import android.content.Intent;
+import android.content.pm.ActivityInfo;
+import android.content.pm.ApplicationInfo;
+import android.content.res.Configuration;
+import android.graphics.Rect;
+import android.net.Uri;
+import android.os.Binder;
+import android.os.Debug;
+import android.os.Handler;
+import android.os.IBinder;
+import android.os.Looper;
+import android.os.Message;
+import android.os.RemoteException;
+import android.os.SystemClock;
+import android.os.UserHandle;
+import android.service.voice.IVoiceInteractionSession;
+import android.util.ArraySet;
+import android.util.EventLog;
+import android.util.IntArray;
+import android.util.Log;
+import android.util.Slog;
+import android.util.SparseArray;
+import android.util.proto.ProtoOutputStream;
+import android.view.Display;
+
+import com.android.internal.annotations.GuardedBy;
+import com.android.internal.annotations.VisibleForTesting;
+import com.android.internal.app.IVoiceInteractor;
+import com.android.internal.util.function.pooled.PooledLambda;
+import com.android.server.Watchdog;
+import com.android.server.am.ActivityManagerService;
+import com.android.server.am.ActivityManagerService.ItemMatcher;
+import com.android.server.am.AppTimeTracker;
+import com.android.server.am.EventLogTags;
+import com.android.server.am.PendingIntentRecord;
+
+import java.io.FileDescriptor;
+import java.io.PrintWriter;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+
+/**
+ * State and management of a single stack of activities.
+ */
+class ActivityStack<T extends StackWindowController> extends ConfigurationContainer
+ implements StackWindowListener {
+ private static final String TAG = TAG_WITH_CLASS_NAME ? "ActivityStack" : TAG_ATM;
+ private static final String TAG_ADD_REMOVE = TAG + POSTFIX_ADD_REMOVE;
+ private static final String TAG_APP = TAG + POSTFIX_APP;
+ private static final String TAG_CLEANUP = TAG + POSTFIX_CLEANUP;
+ private static final String TAG_CONTAINERS = TAG + POSTFIX_CONTAINERS;
+ private static final String TAG_PAUSE = TAG + POSTFIX_PAUSE;
+ private static final String TAG_RELEASE = TAG + POSTFIX_RELEASE;
+ private static final String TAG_RESULTS = TAG + POSTFIX_RESULTS;
+ private static final String TAG_SAVED_STATE = TAG + POSTFIX_SAVED_STATE;
+ private static final String TAG_STACK = TAG + POSTFIX_STACK;
+ private static final String TAG_STATES = TAG + POSTFIX_STATES;
+ private static final String TAG_SWITCH = TAG + POSTFIX_SWITCH;
+ private static final String TAG_TASKS = TAG + POSTFIX_TASKS;
+ private static final String TAG_TRANSITION = TAG + POSTFIX_TRANSITION;
+ private static final String TAG_USER_LEAVING = TAG + POSTFIX_USER_LEAVING;
+ private static final String TAG_VISIBILITY = TAG + POSTFIX_VISIBILITY;
+
+ // Ticks during which we check progress while waiting for an app to launch.
+ static final int LAUNCH_TICK = 500;
+
+ // How long we wait until giving up on the last activity to pause. This
+ // is short because it directly impacts the responsiveness of starting the
+ // next activity.
+ private static final int PAUSE_TIMEOUT = 500;
+
+ // How long we wait for the activity to tell us it has stopped before
+ // giving up. This is a good amount of time because we really need this
+ // from the application in order to get its saved state. Once the stop
+ // is complete we may start destroying client resources triggering
+ // crashes if the UI thread was hung. We put this timeout one second behind
+ // the ANR timeout so these situations will generate ANR instead of
+ // Surface lost or other errors.
+ private static final int STOP_TIMEOUT = 11 * 1000;
+
+ // How long we wait until giving up on an activity telling us it has
+ // finished destroying itself.
+ private static final int DESTROY_TIMEOUT = 10 * 1000;
+
+ // Set to false to disable the preview that is shown while a new activity
+ // is being started.
+ private static final boolean SHOW_APP_STARTING_PREVIEW = true;
+
+ // How long to wait for all background Activities to redraw following a call to
+ // convertToTranslucent().
+ private static final long TRANSLUCENT_CONVERSION_TIMEOUT = 2000;
+
+ // How many activities have to be scheduled to stop to force a stop pass.
+ private static final int MAX_STOPPING_TO_FORCE = 3;
+
+ @Override
+ protected int getChildCount() {
+ return mTaskHistory.size();
+ }
+
+ @Override
+ protected TaskRecord getChildAt(int index) {
+ return mTaskHistory.get(index);
+ }
+
+ @Override
+ protected ConfigurationContainer getParent() {
+ return getDisplay();
+ }
+
+ @Override
+ protected void onParentChanged() {
+ super.onParentChanged();
+ mStackSupervisor.updateUIDsPresentOnDisplay();
+ }
+
+ enum ActivityState {
+ INITIALIZING,
+ RESUMED,
+ PAUSING,
+ PAUSED,
+ STOPPING,
+ STOPPED,
+ FINISHING,
+ DESTROYING,
+ DESTROYED
+ }
+
+ @VisibleForTesting
+ /* The various modes for the method {@link #removeTask}. */
+ // Task is being completely removed from all stacks in the system.
+ protected static final int REMOVE_TASK_MODE_DESTROYING = 0;
+ // Task is being removed from this stack so we can add it to another stack. In the case we are
+ // moving we don't want to perform some operations on the task like removing it from window
+ // manager or recents.
+ static final int REMOVE_TASK_MODE_MOVING = 1;
+ // Similar to {@link #REMOVE_TASK_MODE_MOVING} and the task will be added to the top of its new
+ // stack and the new stack will be on top of all stacks.
+ static final int REMOVE_TASK_MODE_MOVING_TO_TOP = 2;
+
+ // The height/width divide used when fitting a task within a bounds with method
+ // {@link #fitWithinBounds}.
+ // We always want the task to to be visible in the bounds without affecting its size when
+ // fitting. To make sure this is the case, we don't adjust the task left or top side pass
+ // the input bounds right or bottom side minus the width or height divided by this value.
+ private static final int FIT_WITHIN_BOUNDS_DIVIDER = 3;
+
+ final ActivityTaskManagerService mService;
+ private final WindowManagerService mWindowManager;
+ T mWindowContainerController;
+
+ /**
+ * The back history of all previous (and possibly still
+ * running) activities. It contains #TaskRecord objects.
+ */
+ private final ArrayList<TaskRecord> mTaskHistory = new ArrayList<>();
+
+ /**
+ * List of running activities, sorted by recent usage.
+ * The first entry in the list is the least recently used.
+ * It contains HistoryRecord objects.
+ */
+ final ArrayList<ActivityRecord> mLRUActivities = new ArrayList<>();
+
+ /**
+ * When we are in the process of pausing an activity, before starting the
+ * next one, this variable holds the activity that is currently being paused.
+ */
+ ActivityRecord mPausingActivity = null;
+
+ /**
+ * This is the last activity that we put into the paused state. This is
+ * used to determine if we need to do an activity transition while sleeping,
+ * when we normally hold the top activity paused.
+ */
+ ActivityRecord mLastPausedActivity = null;
+
+ /**
+ * Activities that specify No History must be removed once the user navigates away from them.
+ * If the device goes to sleep with such an activity in the paused state then we save it here
+ * and finish it later if another activity replaces it on wakeup.
+ */
+ ActivityRecord mLastNoHistoryActivity = null;
+
+ /**
+ * Current activity that is resumed, or null if there is none.
+ */
+ ActivityRecord mResumedActivity = null;
+
+ // The topmost Activity passed to convertToTranslucent(). When non-null it means we are
+ // waiting for all Activities in mUndrawnActivitiesBelowTopTranslucent to be removed as they
+ // are drawn. When the last member of mUndrawnActivitiesBelowTopTranslucent is removed the
+ // Activity in mTranslucentActivityWaiting is notified via
+ // Activity.onTranslucentConversionComplete(false). If a timeout occurs prior to the last
+ // background activity being drawn then the same call will be made with a true value.
+ ActivityRecord mTranslucentActivityWaiting = null;
+ ArrayList<ActivityRecord> mUndrawnActivitiesBelowTopTranslucent = new ArrayList<>();
+
+ /**
+ * Set when we know we are going to be calling updateConfiguration()
+ * soon, so want to skip intermediate config checks.
+ */
+ boolean mConfigWillChange;
+
+ /**
+ * When set, will force the stack to report as invisible.
+ */
+ boolean mForceHidden = false;
+
+ private boolean mUpdateBoundsDeferred;
+ private boolean mUpdateBoundsDeferredCalled;
+ private final Rect mDeferredBounds = new Rect();
+ private final Rect mDeferredTaskBounds = new Rect();
+ private final Rect mDeferredTaskInsetBounds = new Rect();
+
+ int mCurrentUser;
+
+ final int mStackId;
+ /** The attached Display's unique identifier, or -1 if detached */
+ int mDisplayId;
+
+ /** Stores the override windowing-mode from before a transient mode change (eg. split) */
+ private int mRestoreOverrideWindowingMode = WINDOWING_MODE_UNDEFINED;
+
+ private final SparseArray<Rect> mTmpBounds = new SparseArray<>();
+ private final SparseArray<Rect> mTmpInsetBounds = new SparseArray<>();
+ private final Rect mTmpRect2 = new Rect();
+ private final ActivityOptions mTmpOptions = ActivityOptions.makeBasic();
+
+ /** List for processing through a set of activities */
+ private final ArrayList<ActivityRecord> mTmpActivities = new ArrayList<>();
+
+ /** Run all ActivityStacks through this */
+ protected final ActivityStackSupervisor mStackSupervisor;
+
+ private boolean mTopActivityOccludesKeyguard;
+ private ActivityRecord mTopDismissingKeyguardActivity;
+
+ static final int PAUSE_TIMEOUT_MSG = FIRST_ACTIVITY_STACK_MSG + 1;
+ static final int DESTROY_TIMEOUT_MSG = FIRST_ACTIVITY_STACK_MSG + 2;
+ static final int LAUNCH_TICK_MSG = FIRST_ACTIVITY_STACK_MSG + 3;
+ static final int STOP_TIMEOUT_MSG = FIRST_ACTIVITY_STACK_MSG + 4;
+ static final int DESTROY_ACTIVITIES_MSG = FIRST_ACTIVITY_STACK_MSG + 5;
+ static final int TRANSLUCENT_TIMEOUT_MSG = FIRST_ACTIVITY_STACK_MSG + 6;
+
+ private static class ScheduleDestroyArgs {
+ final WindowProcessController mOwner;
+ final String mReason;
+ ScheduleDestroyArgs(WindowProcessController owner, String reason) {
+ mOwner = owner;
+ mReason = reason;
+ }
+ }
+
+ final Handler mHandler;
+
+ private class ActivityStackHandler extends Handler {
+
+ ActivityStackHandler(Looper looper) {
+ super(looper);
+ }
+
+ @Override
+ public void handleMessage(Message msg) {
+ switch (msg.what) {
+ case PAUSE_TIMEOUT_MSG: {
+ ActivityRecord r = (ActivityRecord)msg.obj;
+ // We don't at this point know if the activity is fullscreen,
+ // so we need to be conservative and assume it isn't.
+ Slog.w(TAG, "Activity pause timeout for " + r);
+ synchronized (mService.mGlobalLock) {
+ if (r.hasProcess()) {
+ mService.logAppTooSlow(r.app, r.pauseTime, "pausing " + r);
+ }
+ activityPausedLocked(r.appToken, true);
+ }
+ } break;
+ case LAUNCH_TICK_MSG: {
+ ActivityRecord r = (ActivityRecord)msg.obj;
+ synchronized (mService.mGlobalLock) {
+ if (r.continueLaunchTickingLocked()) {
+ mService.logAppTooSlow(r.app, r.launchTickTime, "launching " + r);
+ }
+ }
+ } break;
+ case DESTROY_TIMEOUT_MSG: {
+ ActivityRecord r = (ActivityRecord)msg.obj;
+ // We don't at this point know if the activity is fullscreen,
+ // so we need to be conservative and assume it isn't.
+ Slog.w(TAG, "Activity destroy timeout for " + r);
+ synchronized (mService.mGlobalLock) {
+ activityDestroyedLocked(r != null ? r.appToken : null, "destroyTimeout");
+ }
+ } break;
+ case STOP_TIMEOUT_MSG: {
+ ActivityRecord r = (ActivityRecord)msg.obj;
+ // We don't at this point know if the activity is fullscreen,
+ // so we need to be conservative and assume it isn't.
+ Slog.w(TAG, "Activity stop timeout for " + r);
+ synchronized (mService.mGlobalLock) {
+ if (r.isInHistory()) {
+ r.activityStoppedLocked(null /* icicle */,
+ null /* persistentState */, null /* description */);
+ }
+ }
+ } break;
+ case DESTROY_ACTIVITIES_MSG: {
+ ScheduleDestroyArgs args = (ScheduleDestroyArgs)msg.obj;
+ synchronized (mService.mGlobalLock) {
+ destroyActivitiesLocked(args.mOwner, args.mReason);
+ }
+ } break;
+ case TRANSLUCENT_TIMEOUT_MSG: {
+ synchronized (mService.mGlobalLock) {
+ notifyActivityDrawnLocked(null);
+ }
+ } break;
+ }
+ }
+ }
+
+ int numActivities() {
+ int count = 0;
+ for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
+ count += mTaskHistory.get(taskNdx).mActivities.size();
+ }
+ return count;
+ }
+
+ ActivityStack(ActivityDisplay display, int stackId, ActivityStackSupervisor supervisor,
+ int windowingMode, int activityType, boolean onTop) {
+ mStackSupervisor = supervisor;
+ mService = supervisor.mService;
+ mHandler = new ActivityStackHandler(supervisor.mLooper);
+ mWindowManager = mService.mWindowManager;
+ mStackId = stackId;
+ mCurrentUser = mService.mAmInternal.getCurrentUserId();
+ mTmpRect2.setEmpty();
+ // Set display id before setting activity and window type to make sure it won't affect
+ // stacks on a wrong display.
+ mDisplayId = display.mDisplayId;
+ setActivityType(activityType);
+ setWindowingMode(windowingMode);
+ mWindowContainerController = createStackWindowController(display.mDisplayId, onTop,
+ mTmpRect2);
+ postAddToDisplay(display, mTmpRect2.isEmpty() ? null : mTmpRect2, onTop);
+ }
+
+ T createStackWindowController(int displayId, boolean onTop, Rect outBounds) {
+ return (T) new StackWindowController(mStackId, this, displayId, onTop, outBounds,
+ mStackSupervisor.mWindowManager);
+ }
+
+ T getWindowContainerController() {
+ return mWindowContainerController;
+ }
+
+ /**
+ * This should be called when an activity in a child task changes state. This should only
+ * be called from
+ * {@link TaskRecord#onActivityStateChanged(ActivityRecord, ActivityState, String)}.
+ * @param record The {@link ActivityRecord} whose state has changed.
+ * @param state The new state.
+ * @param reason The reason for the change.
+ */
+ void onActivityStateChanged(ActivityRecord record, ActivityState state, String reason) {
+ if (record == mResumedActivity && state != RESUMED) {
+ setResumedActivity(null, reason + " - onActivityStateChanged");
+ }
+
+ if (state == RESUMED) {
+ if (DEBUG_STACK) Slog.v(TAG_STACK, "set resumed activity to:" + record + " reason:"
+ + reason);
+ setResumedActivity(record, reason + " - onActivityStateChanged");
+ if (record == mStackSupervisor.getTopResumedActivity()) {
+ // TODO(b/111361570): Support multiple focused apps in WM
+ mService.setResumedActivityUncheckLocked(record, reason);
+ }
+ mStackSupervisor.mRecentTasks.add(record.getTask());
+ }
+ }
+
+ @Override
+ public void onConfigurationChanged(Configuration newParentConfig) {
+ final int prevWindowingMode = getWindowingMode();
+ final boolean prevIsAlwaysOnTop = isAlwaysOnTop();
+ super.onConfigurationChanged(newParentConfig);
+ final ActivityDisplay display = getDisplay();
+ if (display == null) {
+ return;
+ }
+ if (prevWindowingMode != getWindowingMode()) {
+ display.onStackWindowingModeChanged(this);
+ }
+ if (prevIsAlwaysOnTop != isAlwaysOnTop()) {
+ // Since always on top is only on when the stack is freeform or pinned, the state
+ // can be toggled when the windowing mode changes. We must make sure the stack is
+ // placed properly when always on top state changes.
+ display.positionChildAtTop(this, false /* includingParents */);
+ }
+ }
+
+ @Override
+ public void setWindowingMode(int windowingMode) {
+ setWindowingMode(windowingMode, false /* animate */, false /* showRecents */,
+ false /* enteringSplitScreenMode */, false /* deferEnsuringVisibility */);
+ }
+
+ /**
+ * A transient windowing mode is one which activities enter into temporarily. Examples of this
+ * are Split window modes and pip. Non-transient modes are modes that displays can adopt.
+ *
+ * @param windowingMode the windowingMode to test for transient-ness.
+ * @return {@code true} if the windowing mode is transient, {@code false} otherwise.
+ */
+ private static boolean isTransientWindowingMode(int windowingMode) {
+ // TODO(b/114842032): add PIP if/when it uses mode transitions instead of task reparenting
+ return windowingMode == WINDOWING_MODE_SPLIT_SCREEN_PRIMARY
+ || windowingMode == WINDOWING_MODE_SPLIT_SCREEN_SECONDARY;
+ }
+
+ /**
+ * Specialization of {@link #setWindowingMode(int)} for this subclass.
+ *
+ * @param preferredWindowingMode the preferred windowing mode. This may not be honored depending
+ * on the state of things. For example, WINDOWING_MODE_UNDEFINED will resolve to the
+ * previous non-transient mode if this stack is currently in a transient mode.
+ * @param animate Can be used to prevent animation.
+ * @param showRecents Controls whether recents is shown on the other side of a split while
+ * entering split mode.
+ * @param enteringSplitScreenMode {@code true} if entering split mode.
+ * @param deferEnsuringVisibility Whether visibility updates are deferred. This is set when
+ * many operations (which can effect visibility) are being performed in bulk.
+ */
+ void setWindowingMode(int preferredWindowingMode, boolean animate, boolean showRecents,
+ boolean enteringSplitScreenMode, boolean deferEnsuringVisibility) {
+ final boolean creating = mWindowContainerController == null;
+ final int currentMode = getWindowingMode();
+ final int currentOverrideMode = getOverrideWindowingMode();
+ final ActivityDisplay display = getDisplay();
+ final TaskRecord topTask = topTask();
+ final ActivityStack splitScreenStack = display.getSplitScreenPrimaryStack();
+ int windowingMode = preferredWindowingMode;
+ if (preferredWindowingMode == WINDOWING_MODE_UNDEFINED
+ && isTransientWindowingMode(currentMode)) {
+ // Leaving a transient mode. Interpret UNDEFINED as "restore"
+ windowingMode = mRestoreOverrideWindowingMode;
+ }
+ mTmpOptions.setLaunchWindowingMode(windowingMode);
+
+ // Need to make sure windowing mode is supported. If we in the process of creating the stack
+ // no need to resolve the windowing mode again as it is already resolved to the right mode.
+ if (!creating) {
+ windowingMode = display.validateWindowingMode(windowingMode,
+ null /* ActivityRecord */, topTask, getActivityType());
+ }
+ if (splitScreenStack == this
+ && windowingMode == WINDOWING_MODE_SPLIT_SCREEN_SECONDARY) {
+ // Resolution to split-screen secondary for the primary split-screen stack means
+ // we want to leave split-screen mode.
+ windowingMode = mRestoreOverrideWindowingMode;
+ }
+
+ final boolean alreadyInSplitScreenMode = display.hasSplitScreenPrimaryStack();
+
+ // Don't send non-resizeable notifications if the windowing mode changed was a side effect
+ // of us entering split-screen mode.
+ final boolean sendNonResizeableNotification = !enteringSplitScreenMode;
+ // Take any required action due to us not supporting the preferred windowing mode.
+ if (alreadyInSplitScreenMode && windowingMode == WINDOWING_MODE_FULLSCREEN
+ && sendNonResizeableNotification && isActivityTypeStandardOrUndefined()) {
+ final boolean preferredSplitScreen =
+ preferredWindowingMode == WINDOWING_MODE_SPLIT_SCREEN_PRIMARY
+ || preferredWindowingMode == WINDOWING_MODE_SPLIT_SCREEN_SECONDARY;
+ if (preferredSplitScreen || creating) {
+ // Looks like we can't launch in split screen mode or the stack we are launching
+ // doesn't support split-screen mode, go ahead an dismiss split-screen and display a
+ // warning toast about it.
+ mService.getTaskChangeNotificationController().notifyActivityDismissingDockedStack();
+ display.getSplitScreenPrimaryStack().setWindowingMode(WINDOWING_MODE_UNDEFINED,
+ false /* animate */, false /* showRecents */,
+ false /* enteringSplitScreenMode */, true /* deferEnsuringVisibility */);
+ }
+ }
+
+ if (currentMode == windowingMode) {
+ // You are already in the window mode, so we can skip most of the work below. However,
+ // it's possible that we have inherited the current windowing mode from a parent. So,
+ // fulfill this method's contract by setting the override mode directly.
+ getOverrideConfiguration().windowConfiguration.setWindowingMode(windowingMode);
+ return;
+ }
+
+ final WindowManagerService wm = mService.mWindowManager;
+ final ActivityRecord topActivity = getTopActivity();
+
+ // For now, assume that the Stack's windowing mode is what will actually be used
+ // by it's activities. In the future, there may be situations where this doesn't
+ // happen; so at that point, this message will need to handle that.
+ int likelyResolvedMode = windowingMode;
+ if (windowingMode == WINDOWING_MODE_UNDEFINED) {
+ final ConfigurationContainer parent = getParent();
+ likelyResolvedMode = parent != null ? parent.getWindowingMode()
+ : WINDOWING_MODE_FULLSCREEN;
+ }
+ if (sendNonResizeableNotification && likelyResolvedMode != WINDOWING_MODE_FULLSCREEN
+ && topActivity != null && topActivity.isNonResizableOrForcedResizable()
+ && !topActivity.noDisplay) {
+ // Inform the user that they are starting an app that may not work correctly in
+ // multi-window mode.
+ final String packageName = topActivity.appInfo.packageName;
+ mService.getTaskChangeNotificationController().notifyActivityForcedResizable(
+ topTask.taskId, FORCED_RESIZEABLE_REASON_SPLIT_SCREEN, packageName);
+ }
+
+ wm.deferSurfaceLayout();
+ try {
+ if (!animate && topActivity != null) {
+ mStackSupervisor.mNoAnimActivities.add(topActivity);
+ }
+ super.setWindowingMode(windowingMode);
+ // setWindowingMode triggers an onConfigurationChanged cascade which can result in a
+ // different resolved windowing mode (usually when preferredWindowingMode is UNDEFINED).
+ windowingMode = getWindowingMode();
+
+ if (creating) {
+ // Nothing else to do if we don't have a window container yet. E.g. call from ctor.
+ return;
+ }
+
+ if (windowingMode == WINDOWING_MODE_PINNED || currentMode == WINDOWING_MODE_PINNED) {
+ // TODO: Need to remove use of PinnedActivityStack for this to be supported.
+ // NOTE: Need to ASS.scheduleUpdatePictureInPictureModeIfNeeded() in
+ // setWindowModeUnchecked() when this support is added. See TaskRecord.reparent()
+ throw new IllegalArgumentException(
+ "Changing pinned windowing mode not currently supported");
+ }
+
+ if (windowingMode == WINDOWING_MODE_SPLIT_SCREEN_PRIMARY && splitScreenStack != null) {
+ // We already have a split-screen stack in this display, so just move the tasks over.
+ // TODO: Figure-out how to do all the stuff in
+ // AMS.setTaskWindowingModeSplitScreenPrimary
+ throw new IllegalArgumentException("Setting primary split-screen windowing mode"
+ + " while there is already one isn't currently supported");
+ //return;
+ }
+ if (isTransientWindowingMode(windowingMode) && !isTransientWindowingMode(currentMode)) {
+ mRestoreOverrideWindowingMode = currentOverrideMode;
+ }
+
+ mTmpRect2.setEmpty();
+ if (windowingMode != WINDOWING_MODE_FULLSCREEN) {
+ mWindowContainerController.getRawBounds(mTmpRect2);
+ }
+
+ if (!Objects.equals(getOverrideBounds(), mTmpRect2)) {
+ resize(mTmpRect2, null /* tempTaskBounds */, null /* tempTaskInsetBounds */);
+ }
+ } finally {
+ if (showRecents && !alreadyInSplitScreenMode && mDisplayId == DEFAULT_DISPLAY
+ && windowingMode == WINDOWING_MODE_SPLIT_SCREEN_PRIMARY) {
+ // Make sure recents stack exist when creating a dock stack as it normally needs to
+ // be on the other side of the docked stack and we make visibility decisions based
+ // on that.
+ // TODO: This is only here to help out with the case where recents stack doesn't
+ // exist yet. For that case the initial size of the split-screen stack will be the
+ // the one where the home stack is visible since recents isn't visible yet, but the
+ // divider will be off. I think we should just make the initial bounds that of home
+ // so that the divider matches and remove this logic.
+ // TODO: This is currently only called when entering split-screen while in another
+ // task, and from the tests
+ // TODO (b/78247419): Check if launcher and overview are same then move home stack
+ // instead of recents stack. Then fix the rotation animation from fullscreen to
+ // minimized mode
+ final ActivityStack recentStack = display.getOrCreateStack(
+ WINDOWING_MODE_SPLIT_SCREEN_SECONDARY, ACTIVITY_TYPE_RECENTS,
+ true /* onTop */);
+ recentStack.moveToFront("setWindowingMode");
+ // If task moved to docked stack - show recents if needed.
+ mService.mWindowManager.showRecentApps();
+ }
+ wm.continueSurfaceLayout();
+ }
+
+ if (!deferEnsuringVisibility) {
+ mStackSupervisor.ensureActivitiesVisibleLocked(null, 0, PRESERVE_WINDOWS);
+ mStackSupervisor.resumeFocusedStacksTopActivitiesLocked();
+ }
+ }
+
+ @Override
+ public boolean isCompatible(int windowingMode, int activityType) {
+ // TODO: Should we just move this to ConfigurationContainer?
+ if (activityType == ACTIVITY_TYPE_UNDEFINED) {
+ // Undefined activity types end up in a standard stack once the stack is created on a
+ // display, so they should be considered compatible.
+ activityType = ACTIVITY_TYPE_STANDARD;
+ }
+ return super.isCompatible(windowingMode, activityType);
+ }
+
+ /** Adds the stack to specified display and calls WindowManager to do the same. */
+ void reparent(ActivityDisplay activityDisplay, boolean onTop) {
+ // TODO: We should probably resolve the windowing mode for the stack on the new display here
+ // so that it end up in a compatible mode in the new display. e.g. split-screen secondary.
+ removeFromDisplay();
+ // Reparent the window container before we try to update the position when adding it to
+ // the new display below
+ mTmpRect2.setEmpty();
+ mWindowContainerController.reparent(activityDisplay.mDisplayId, mTmpRect2, onTop);
+ postAddToDisplay(activityDisplay, mTmpRect2.isEmpty() ? null : mTmpRect2, onTop);
+ adjustFocusToNextFocusableStack("reparent", true /* allowFocusSelf */);
+ mStackSupervisor.resumeFocusedStacksTopActivitiesLocked();
+ // Update visibility of activities before notifying WM. This way it won't try to resize
+ // windows that are no longer visible.
+ mStackSupervisor.ensureActivitiesVisibleLocked(null /* starting */, 0 /* configChanges */,
+ !PRESERVE_WINDOWS);
+ }
+
+ /**
+ * Updates internal state after adding to new display.
+ * @param activityDisplay New display to which this stack was attached.
+ * @param bounds Updated bounds.
+ */
+ private void postAddToDisplay(ActivityDisplay activityDisplay, Rect bounds, boolean onTop) {
+ mDisplayId = activityDisplay.mDisplayId;
+ setBounds(bounds);
+ onParentChanged();
+
+ activityDisplay.addChild(this, onTop ? POSITION_TOP : POSITION_BOTTOM);
+ if (inSplitScreenPrimaryWindowingMode()) {
+ // If we created a docked stack we want to resize it so it resizes all other stacks
+ // in the system.
+ mStackSupervisor.resizeDockedStackLocked(
+ getOverrideBounds(), null, null, null, null, PRESERVE_WINDOWS);
+ }
+ }
+
+ /**
+ * Updates the inner state of the stack to remove it from its current parent, so it can be
+ * either destroyed completely or re-parented.
+ */
+ private void removeFromDisplay() {
+ final ActivityDisplay display = getDisplay();
+ if (display != null) {
+ display.removeChild(this);
+ }
+ mDisplayId = INVALID_DISPLAY;
+ }
+
+ /** Removes the stack completely. Also calls WindowManager to do the same on its side. */
+ void remove() {
+ removeFromDisplay();
+ mWindowContainerController.removeContainer();
+ mWindowContainerController = null;
+ onParentChanged();
+ }
+
+ ActivityDisplay getDisplay() {
+ return mStackSupervisor.getActivityDisplay(mDisplayId);
+ }
+
+ /**
+ * @see #getStackDockedModeBounds(Rect, Rect, Rect, boolean)
+ */
+ void getStackDockedModeBounds(Rect currentTempTaskBounds, Rect outStackBounds,
+ Rect outTempTaskBounds, boolean ignoreVisibility) {
+ mWindowContainerController.getStackDockedModeBounds(currentTempTaskBounds,
+ outStackBounds, outTempTaskBounds, ignoreVisibility);
+ }
+
+ void prepareFreezingTaskBounds() {
+ mWindowContainerController.prepareFreezingTaskBounds();
+ }
+
+ void getWindowContainerBounds(Rect outBounds) {
+ if (mWindowContainerController != null) {
+ mWindowContainerController.getBounds(outBounds);
+ return;
+ }
+ outBounds.setEmpty();
+ }
+
+ void getBoundsForNewConfiguration(Rect outBounds) {
+ mWindowContainerController.getBoundsForNewConfiguration(outBounds);
+ }
+
+ void positionChildWindowContainerAtTop(TaskRecord child) {
+ mWindowContainerController.positionChildAtTop(child.getWindowContainerController(),
+ true /* includingParents */);
+ }
+
+ void positionChildWindowContainerAtBottom(TaskRecord child) {
+ // If there are other focusable stacks on the display, the z-order of the display should not
+ // be changed just because a task was placed at the bottom. E.g. if it is moving the topmost
+ // task to bottom, the next focusable stack on the same display should be focused.
+ final ActivityStack nextFocusableStack = getDisplay().getNextFocusableStack(
+ child.getStack(), true /* ignoreCurrent */);
+ mWindowContainerController.positionChildAtBottom(child.getWindowContainerController(),
+ nextFocusableStack == null /* includingParents */);
+ }
+
+ /**
+ * Returns whether to defer the scheduling of the multi-window mode.
+ */
+ boolean deferScheduleMultiWindowModeChanged() {
+ return false;
+ }
+
+ /**
+ * Defers updating the bounds of the stack. If the stack was resized/repositioned while
+ * deferring, the bounds will update in {@link #continueUpdateBounds()}.
+ */
+ void deferUpdateBounds() {
+ if (!mUpdateBoundsDeferred) {
+ mUpdateBoundsDeferred = true;
+ mUpdateBoundsDeferredCalled = false;
+ }
+ }
+
+ /**
+ * Continues updating bounds after updates have been deferred. If there was a resize attempt
+ * between {@link #deferUpdateBounds()} and {@link #continueUpdateBounds()}, the stack will
+ * be resized to that bounds.
+ */
+ void continueUpdateBounds() {
+ final boolean wasDeferred = mUpdateBoundsDeferred;
+ mUpdateBoundsDeferred = false;
+ if (wasDeferred && mUpdateBoundsDeferredCalled) {
+ resize(mDeferredBounds.isEmpty() ? null : mDeferredBounds,
+ mDeferredTaskBounds.isEmpty() ? null : mDeferredTaskBounds,
+ mDeferredTaskInsetBounds.isEmpty() ? null : mDeferredTaskInsetBounds);
+ }
+ }
+
+ boolean updateBoundsAllowed(Rect bounds, Rect tempTaskBounds,
+ Rect tempTaskInsetBounds) {
+ if (!mUpdateBoundsDeferred) {
+ return true;
+ }
+ if (bounds != null) {
+ mDeferredBounds.set(bounds);
+ } else {
+ mDeferredBounds.setEmpty();
+ }
+ if (tempTaskBounds != null) {
+ mDeferredTaskBounds.set(tempTaskBounds);
+ } else {
+ mDeferredTaskBounds.setEmpty();
+ }
+ if (tempTaskInsetBounds != null) {
+ mDeferredTaskInsetBounds.set(tempTaskInsetBounds);
+ } else {
+ mDeferredTaskInsetBounds.setEmpty();
+ }
+ mUpdateBoundsDeferredCalled = true;
+ return false;
+ }
+
+ @Override
+ public int setBounds(Rect bounds) {
+ return super.setBounds(!inMultiWindowMode() ? null : bounds);
+ }
+
+ ActivityRecord topRunningActivityLocked() {
+ return topRunningActivityLocked(false /* focusableOnly */);
+ }
+
+ void getAllRunningVisibleActivitiesLocked(ArrayList<ActivityRecord> outActivities) {
+ outActivities.clear();
+ for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
+ mTaskHistory.get(taskNdx).getAllRunningVisibleActivitiesLocked(outActivities);
+ }
+ }
+
+ ActivityRecord topRunningActivityLocked(boolean focusableOnly) {
+ for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
+ ActivityRecord r = mTaskHistory.get(taskNdx).topRunningActivityLocked();
+ if (r != null && (!focusableOnly || r.isFocusable())) {
+ return r;
+ }
+ }
+ return null;
+ }
+
+ ActivityRecord topRunningNonOverlayTaskActivity() {
+ for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
+ final TaskRecord task = mTaskHistory.get(taskNdx);
+ final ArrayList<ActivityRecord> activities = task.mActivities;
+ for (int activityNdx = activities.size() - 1; activityNdx >= 0; --activityNdx) {
+ final ActivityRecord r = activities.get(activityNdx);
+ if (!r.finishing && !r.mTaskOverlay) {
+ return r;
+ }
+ }
+ }
+ return null;
+ }
+
+ ActivityRecord topRunningNonDelayedActivityLocked(ActivityRecord notTop) {
+ for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
+ final TaskRecord task = mTaskHistory.get(taskNdx);
+ final ArrayList<ActivityRecord> activities = task.mActivities;
+ for (int activityNdx = activities.size() - 1; activityNdx >= 0; --activityNdx) {
+ ActivityRecord r = activities.get(activityNdx);
+ if (!r.finishing && !r.delayedResume && r != notTop && r.okToShowLocked()) {
+ return r;
+ }
+ }
+ }
+ return null;
+ }
+
+ /**
+ * This is a simplified version of topRunningActivityLocked that provides a number of
+ * optional skip-over modes. It is intended for use with the ActivityController hook only.
+ *
+ * @param token If non-null, any history records matching this token will be skipped.
+ * @param taskId If non-zero, we'll attempt to skip over records with the same task ID.
+ *
+ * @return Returns the HistoryRecord of the next activity on the stack.
+ */
+ final ActivityRecord topRunningActivityLocked(IBinder token, int taskId) {
+ for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
+ TaskRecord task = mTaskHistory.get(taskNdx);
+ if (task.taskId == taskId) {
+ continue;
+ }
+ ArrayList<ActivityRecord> activities = task.mActivities;
+ for (int i = activities.size() - 1; i >= 0; --i) {
+ final ActivityRecord r = activities.get(i);
+ // Note: the taskId check depends on real taskId fields being non-zero
+ if (!r.finishing && (token != r.appToken) && r.okToShowLocked()) {
+ return r;
+ }
+ }
+ }
+ return null;
+ }
+
+ ActivityRecord getTopActivity() {
+ for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
+ final ActivityRecord r = mTaskHistory.get(taskNdx).getTopActivity();
+ if (r != null) {
+ return r;
+ }
+ }
+ return null;
+ }
+
+ final TaskRecord topTask() {
+ final int size = mTaskHistory.size();
+ if (size > 0) {
+ return mTaskHistory.get(size - 1);
+ }
+ return null;
+ }
+
+ private TaskRecord bottomTask() {
+ if (mTaskHistory.isEmpty()) {
+ return null;
+ }
+ return mTaskHistory.get(0);
+ }
+
+ TaskRecord taskForIdLocked(int id) {
+ for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
+ final TaskRecord task = mTaskHistory.get(taskNdx);
+ if (task.taskId == id) {
+ return task;
+ }
+ }
+ return null;
+ }
+
+ ActivityRecord isInStackLocked(IBinder token) {
+ final ActivityRecord r = ActivityRecord.forTokenLocked(token);
+ return isInStackLocked(r);
+ }
+
+ ActivityRecord isInStackLocked(ActivityRecord r) {
+ if (r == null) {
+ return null;
+ }
+ final TaskRecord task = r.getTask();
+ final ActivityStack stack = r.getStack();
+ if (stack != null && task.mActivities.contains(r) && mTaskHistory.contains(task)) {
+ if (stack != this) Slog.w(TAG,
+ "Illegal state! task does not point to stack it is in.");
+ return r;
+ }
+ return null;
+ }
+
+ boolean isInStackLocked(TaskRecord task) {
+ return mTaskHistory.contains(task);
+ }
+
+ /** Checks if there are tasks with specific UID in the stack. */
+ boolean isUidPresent(int uid) {
+ for (TaskRecord task : mTaskHistory) {
+ for (ActivityRecord r : task.mActivities) {
+ if (r.getUid() == uid) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ /** Get all UIDs that are present in the stack. */
+ void getPresentUIDs(IntArray presentUIDs) {
+ for (TaskRecord task : mTaskHistory) {
+ for (ActivityRecord r : task.mActivities) {
+ presentUIDs.add(r.getUid());
+ }
+ }
+ }
+
+ final void removeActivitiesFromLRUListLocked(TaskRecord task) {
+ for (ActivityRecord r : task.mActivities) {
+ mLRUActivities.remove(r);
+ }
+ }
+
+ final boolean updateLRUListLocked(ActivityRecord r) {
+ final boolean hadit = mLRUActivities.remove(r);
+ mLRUActivities.add(r);
+ return hadit;
+ }
+
+ final boolean isHomeOrRecentsStack() {
+ return isActivityTypeHome() || isActivityTypeRecents();
+ }
+
+ final boolean isOnHomeDisplay() {
+ return mDisplayId == DEFAULT_DISPLAY;
+ }
+
+ private boolean returnsToHomeStack() {
+ return !inMultiWindowMode()
+ && !mTaskHistory.isEmpty()
+ && mTaskHistory.get(0).returnsToHomeStack();
+ }
+
+ void moveToFront(String reason) {
+ moveToFront(reason, null);
+ }
+
+ /**
+ * @param reason The reason for moving the stack to the front.
+ * @param task If non-null, the task will be moved to the top of the stack.
+ * */
+ void moveToFront(String reason, TaskRecord task) {
+ if (!isAttached()) {
+ return;
+ }
+
+ final ActivityDisplay display = getDisplay();
+
+ if (inSplitScreenSecondaryWindowingMode()) {
+ // If the stack is in split-screen seconardy mode, we need to make sure we move the
+ // primary split-screen stack forward in the case it is currently behind a fullscreen
+ // stack so both halves of the split-screen appear on-top and the fullscreen stack isn't
+ // cutting between them.
+ // TODO(b/70677280): This is a workaround until we can fix as part of b/70677280.
+ final ActivityStack topFullScreenStack =
+ display.getTopStackInWindowingMode(WINDOWING_MODE_FULLSCREEN);
+ if (topFullScreenStack != null) {
+ final ActivityStack primarySplitScreenStack = display.getSplitScreenPrimaryStack();
+ if (display.getIndexOf(topFullScreenStack)
+ > display.getIndexOf(primarySplitScreenStack)) {
+ primarySplitScreenStack.moveToFront(reason + " splitScreenToTop");
+ }
+ }
+ }
+
+ if (!isActivityTypeHome() && returnsToHomeStack()) {
+ // Make sure the home stack is behind this stack since that is where we should return to
+ // when this stack is no longer visible.
+ display.moveHomeStackToFront(reason + " returnToHome");
+ }
+
+ final boolean movingTask = task != null;
+ display.positionChildAtTop(this, !movingTask /* includingParents */, reason);
+ if (movingTask) {
+ // This also moves the entire hierarchy branch to top, including parents
+ insertTaskAtTop(task, null /* starting */);
+ }
+ }
+
+ /**
+ * @param reason The reason for moving the stack to the back.
+ * @param task If non-null, the task will be moved to the bottom of the stack.
+ **/
+ void moveToBack(String reason, TaskRecord task) {
+ if (!isAttached()) {
+ return;
+ }
+
+ /**
+ * The intent behind moving a primary split screen stack to the back is usually to hide
+ * behind the home stack. Exit split screen in this case.
+ */
+ if (getWindowingMode() == WINDOWING_MODE_SPLIT_SCREEN_PRIMARY) {
+ setWindowingMode(WINDOWING_MODE_UNDEFINED);
+ }
+
+ getDisplay().positionChildAtBottom(this, reason);
+ if (task != null) {
+ insertTaskAtBottom(task);
+ }
+ }
+
+ boolean isFocusable() {
+ final ActivityRecord r = topRunningActivityLocked();
+ return mStackSupervisor.isFocusable(this, r != null && r.isFocusable());
+ }
+
+ boolean isFocusableAndVisible() {
+ return isFocusable() && shouldBeVisible(null /* starting */);
+ }
+
+ final boolean isAttached() {
+ return getParent() != null;
+ }
+
+ /**
+ * Returns the top activity in any existing task matching the given Intent in the input result.
+ * Returns null if no such task is found.
+ */
+ void findTaskLocked(ActivityRecord target, FindTaskResult result) {
+ Intent intent = target.intent;
+ ActivityInfo info = target.info;
+ ComponentName cls = intent.getComponent();
+ if (info.targetActivity != null) {
+ cls = new ComponentName(info.packageName, info.targetActivity);
+ }
+ final int userId = UserHandle.getUserId(info.applicationInfo.uid);
+ boolean isDocument = intent != null & intent.isDocument();
+ // If documentData is non-null then it must match the existing task data.
+ Uri documentData = isDocument ? intent.getData() : null;
+
+ if (DEBUG_TASKS) Slog.d(TAG_TASKS, "Looking for task of " + target + " in " + this);
+ for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
+ final TaskRecord task = mTaskHistory.get(taskNdx);
+ if (task.voiceSession != null) {
+ // We never match voice sessions; those always run independently.
+ if (DEBUG_TASKS) Slog.d(TAG_TASKS, "Skipping " + task + ": voice session");
+ continue;
+ }
+ if (task.userId != userId) {
+ // Looking for a different task.
+ if (DEBUG_TASKS) Slog.d(TAG_TASKS, "Skipping " + task + ": different user");
+ continue;
+ }
+
+ // Overlays should not be considered as the task's logical top activity.
+ final ActivityRecord r = task.getTopActivity(false /* includeOverlays */);
+ if (r == null || r.finishing || r.userId != userId ||
+ r.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE) {
+ if (DEBUG_TASKS) Slog.d(TAG_TASKS, "Skipping " + task + ": mismatch root " + r);
+ continue;
+ }
+ if (!r.hasCompatibleActivityType(target)) {
+ if (DEBUG_TASKS) Slog.d(TAG_TASKS, "Skipping " + task + ": mismatch activity type");
+ continue;
+ }
+
+ final Intent taskIntent = task.intent;
+ final Intent affinityIntent = task.affinityIntent;
+ final boolean taskIsDocument;
+ final Uri taskDocumentData;
+ if (taskIntent != null && taskIntent.isDocument()) {
+ taskIsDocument = true;
+ taskDocumentData = taskIntent.getData();
+ } else if (affinityIntent != null && affinityIntent.isDocument()) {
+ taskIsDocument = true;
+ taskDocumentData = affinityIntent.getData();
+ } else {
+ taskIsDocument = false;
+ taskDocumentData = null;
+ }
+
+ if (DEBUG_TASKS) Slog.d(TAG_TASKS, "Comparing existing cls="
+ + taskIntent.getComponent().flattenToShortString()
+ + "/aff=" + r.getTask().rootAffinity + " to new cls="
+ + intent.getComponent().flattenToShortString() + "/aff=" + info.taskAffinity);
+ // TODO Refactor to remove duplications. Check if logic can be simplified.
+ if (taskIntent != null && taskIntent.getComponent() != null &&
+ taskIntent.getComponent().compareTo(cls) == 0 &&
+ Objects.equals(documentData, taskDocumentData)) {
+ if (DEBUG_TASKS) Slog.d(TAG_TASKS, "Found matching class!");
+ //dump();
+ if (DEBUG_TASKS) Slog.d(TAG_TASKS,
+ "For Intent " + intent + " bringing to top: " + r.intent);
+ result.mRecord = r;
+ result.mIdealMatch = true;
+ break;
+ } else if (affinityIntent != null && affinityIntent.getComponent() != null &&
+ affinityIntent.getComponent().compareTo(cls) == 0 &&
+ Objects.equals(documentData, taskDocumentData)) {
+ if (DEBUG_TASKS) Slog.d(TAG_TASKS, "Found matching class!");
+ //dump();
+ if (DEBUG_TASKS) Slog.d(TAG_TASKS,
+ "For Intent " + intent + " bringing to top: " + r.intent);
+ result.mRecord = r;
+ result.mIdealMatch = true;
+ break;
+ } else if (!isDocument && !taskIsDocument
+ && result.mRecord == null && task.rootAffinity != null) {
+ if (task.rootAffinity.equals(target.taskAffinity)) {
+ if (DEBUG_TASKS) Slog.d(TAG_TASKS, "Found matching affinity candidate!");
+ // It is possible for multiple tasks to have the same root affinity especially
+ // if they are in separate stacks. We save off this candidate, but keep looking
+ // to see if there is a better candidate.
+ result.mRecord = r;
+ result.mIdealMatch = false;
+ }
+ } else if (DEBUG_TASKS) Slog.d(TAG_TASKS, "Not a match: " + task);
+ }
+ }
+
+ /**
+ * Returns the first activity (starting from the top of the stack) that
+ * is the same as the given activity. Returns null if no such activity
+ * is found.
+ */
+ ActivityRecord findActivityLocked(Intent intent, ActivityInfo info,
+ boolean compareIntentFilters) {
+ ComponentName cls = intent.getComponent();
+ if (info.targetActivity != null) {
+ cls = new ComponentName(info.packageName, info.targetActivity);
+ }
+ final int userId = UserHandle.getUserId(info.applicationInfo.uid);
+
+ for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
+ final TaskRecord task = mTaskHistory.get(taskNdx);
+ final ArrayList<ActivityRecord> activities = task.mActivities;
+
+ for (int activityNdx = activities.size() - 1; activityNdx >= 0; --activityNdx) {
+ ActivityRecord r = activities.get(activityNdx);
+ if (!r.okToShowLocked()) {
+ continue;
+ }
+ if (!r.finishing && r.userId == userId) {
+ if (compareIntentFilters) {
+ if (r.intent.filterEquals(intent)) {
+ return r;
+ }
+ } else {
+ if (r.intent.getComponent().equals(cls)) {
+ return r;
+ }
+ }
+ }
+ }
+ }
+
+ return null;
+ }
+
+ /*
+ * Move the activities around in the stack to bring a user to the foreground.
+ */
+ final void switchUserLocked(int userId) {
+ if (mCurrentUser == userId) {
+ return;
+ }
+ mCurrentUser = userId;
+
+ // Move userId's tasks to the top.
+ int index = mTaskHistory.size();
+ for (int i = 0; i < index; ) {
+ final TaskRecord task = mTaskHistory.get(i);
+
+ if (task.okToShowLocked()) {
+ if (DEBUG_TASKS) Slog.d(TAG_TASKS, "switchUserLocked: stack=" + getStackId() +
+ " moving " + task + " to top");
+ mTaskHistory.remove(i);
+ mTaskHistory.add(task);
+ --index;
+ // Use same value for i.
+ } else {
+ ++i;
+ }
+ }
+ }
+
+ void minimalResumeActivityLocked(ActivityRecord r) {
+ if (DEBUG_STATES) Slog.v(TAG_STATES, "Moving to RESUMED: " + r + " (starting new instance)"
+ + " callers=" + Debug.getCallers(5));
+ r.setState(RESUMED, "minimalResumeActivityLocked");
+ r.completeResumeLocked();
+ if (DEBUG_SAVED_STATE) Slog.i(TAG_SAVED_STATE,
+ "Launch completed; removing icicle of " + r.icicle);
+ }
+
+ private void clearLaunchTime(ActivityRecord r) {
+ // Make sure that there is no activity waiting for this to launch.
+ if (!mStackSupervisor.mWaitingActivityLaunched.isEmpty()) {
+ mStackSupervisor.removeTimeoutsForActivityLocked(r);
+ mStackSupervisor.scheduleIdleTimeoutLocked(r);
+ }
+ }
+
+ void awakeFromSleepingLocked() {
+ // Ensure activities are no longer sleeping.
+ for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
+ final ArrayList<ActivityRecord> activities = mTaskHistory.get(taskNdx).mActivities;
+ for (int activityNdx = activities.size() - 1; activityNdx >= 0; --activityNdx) {
+ activities.get(activityNdx).setSleeping(false);
+ }
+ }
+ if (mPausingActivity != null) {
+ Slog.d(TAG, "awakeFromSleepingLocked: previously pausing activity didn't pause");
+ activityPausedLocked(mPausingActivity.appToken, true);
+ }
+ }
+
+ void updateActivityApplicationInfoLocked(ApplicationInfo aInfo) {
+ final String packageName = aInfo.packageName;
+ final int userId = UserHandle.getUserId(aInfo.uid);
+
+ for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
+ final List<ActivityRecord> activities = mTaskHistory.get(taskNdx).mActivities;
+ for (int activityNdx = activities.size() - 1; activityNdx >= 0; --activityNdx) {
+ final ActivityRecord ar = activities.get(activityNdx);
+
+ if ((userId == ar.userId) && packageName.equals(ar.packageName)) {
+ ar.updateApplicationInfo(aInfo);
+ }
+ }
+ }
+ }
+
+ void checkReadyForSleep() {
+ if (shouldSleepActivities() && goToSleepIfPossible(false /* shuttingDown */)) {
+ mStackSupervisor.checkReadyForSleepLocked(true /* allowDelay */);
+ }
+ }
+
+ /**
+ * Tries to put the activities in the stack to sleep.
+ *
+ * If the stack is not in a state where its activities can be put to sleep, this function will
+ * start any necessary actions to move the stack into such a state. It is expected that this
+ * function get called again when those actions complete.
+ *
+ * @param shuttingDown true when the called because the device is shutting down.
+ * @return true if the stack finished going to sleep, false if the stack only started the
+ * process of going to sleep (checkReadyForSleep will be called when that process finishes).
+ */
+ boolean goToSleepIfPossible(boolean shuttingDown) {
+ boolean shouldSleep = true;
+
+ if (mResumedActivity != null) {
+ // Still have something resumed; can't sleep until it is paused.
+ if (DEBUG_PAUSE) Slog.v(TAG_PAUSE, "Sleep needs to pause " + mResumedActivity);
+ if (DEBUG_USER_LEAVING) Slog.v(TAG_USER_LEAVING,
+ "Sleep => pause with userLeaving=false");
+
+ startPausingLocked(false, true, null, false);
+ shouldSleep = false ;
+ } else if (mPausingActivity != null) {
+ // Still waiting for something to pause; can't sleep yet.
+ if (DEBUG_PAUSE) Slog.v(TAG_PAUSE, "Sleep still waiting to pause " + mPausingActivity);
+ shouldSleep = false;
+ }
+
+ if (!shuttingDown) {
+ if (containsActivityFromStack(mStackSupervisor.mStoppingActivities)) {
+ // Still need to tell some activities to stop; can't sleep yet.
+ if (DEBUG_PAUSE) Slog.v(TAG_PAUSE, "Sleep still need to stop "
+ + mStackSupervisor.mStoppingActivities.size() + " activities");
+
+ mStackSupervisor.scheduleIdleLocked();
+ shouldSleep = false;
+ }
+
+ if (containsActivityFromStack(mStackSupervisor.mGoingToSleepActivities)) {
+ // Still need to tell some activities to sleep; can't sleep yet.
+ if (DEBUG_PAUSE) Slog.v(TAG_PAUSE, "Sleep still need to sleep "
+ + mStackSupervisor.mGoingToSleepActivities.size() + " activities");
+ shouldSleep = false;
+ }
+ }
+
+ if (shouldSleep) {
+ goToSleep();
+ }
+
+ return shouldSleep;
+ }
+
+ void goToSleep() {
+ // Ensure visibility without updating configuration, as activities are about to sleep.
+ ensureActivitiesVisibleLocked(null /* starting */, 0 /* configChanges */,
+ !PRESERVE_WINDOWS);
+
+ // Make sure any paused or stopped but visible activities are now sleeping.
+ // This ensures that the activity's onStop() is called.
+ for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
+ final ArrayList<ActivityRecord> activities = mTaskHistory.get(taskNdx).mActivities;
+ for (int activityNdx = activities.size() - 1; activityNdx >= 0; --activityNdx) {
+ final ActivityRecord r = activities.get(activityNdx);
+ if (r.isState(STOPPING, STOPPED, PAUSED, PAUSING)) {
+ r.setSleeping(true);
+ }
+ }
+ }
+ }
+
+ private boolean containsActivityFromStack(List<ActivityRecord> rs) {
+ for (ActivityRecord r : rs) {
+ if (r.getStack() == this) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Schedule a pause timeout in case the app doesn't respond. We don't give it much time because
+ * this directly impacts the responsiveness seen by the user.
+ */
+ private void schedulePauseTimeout(ActivityRecord r) {
+ final Message msg = mHandler.obtainMessage(PAUSE_TIMEOUT_MSG);
+ msg.obj = r;
+ r.pauseTime = SystemClock.uptimeMillis();
+ mHandler.sendMessageDelayed(msg, PAUSE_TIMEOUT);
+ if (DEBUG_PAUSE) Slog.v(TAG_PAUSE, "Waiting for pause to complete...");
+ }
+
+ /**
+ * Start pausing the currently resumed activity. It is an error to call this if there
+ * is already an activity being paused or there is no resumed activity.
+ *
+ * @param userLeaving True if this should result in an onUserLeaving to the current activity.
+ * @param uiSleeping True if this is happening with the user interface going to sleep (the
+ * screen turning off).
+ * @param resuming The activity we are currently trying to resume or null if this is not being
+ * called as part of resuming the top activity, so we shouldn't try to instigate
+ * a resume here if not null.
+ * @param pauseImmediately True if the caller does not want to wait for the activity callback to
+ * complete pausing.
+ * @return Returns true if an activity now is in the PAUSING state, and we are waiting for
+ * it to tell us when it is done.
+ */
+ final boolean startPausingLocked(boolean userLeaving, boolean uiSleeping,
+ ActivityRecord resuming, boolean pauseImmediately) {
+ if (mPausingActivity != null) {
+ Slog.wtf(TAG, "Going to pause when pause is already pending for " + mPausingActivity
+ + " state=" + mPausingActivity.getState());
+ if (!shouldSleepActivities()) {
+ // Avoid recursion among check for sleep and complete pause during sleeping.
+ // Because activity will be paused immediately after resume, just let pause
+ // be completed by the order of activity paused from clients.
+ completePauseLocked(false, resuming);
+ }
+ }
+ ActivityRecord prev = mResumedActivity;
+
+ if (prev == null) {
+ if (resuming == null) {
+ Slog.wtf(TAG, "Trying to pause when nothing is resumed");
+ mStackSupervisor.resumeFocusedStacksTopActivitiesLocked();
+ }
+ return false;
+ }
+
+ if (prev == resuming) {
+ Slog.wtf(TAG, "Trying to pause activity that is in process of being resumed");
+ return false;
+ }
+
+ if (DEBUG_STATES) Slog.v(TAG_STATES, "Moving to PAUSING: " + prev);
+ else if (DEBUG_PAUSE) Slog.v(TAG_PAUSE, "Start pausing: " + prev);
+ mPausingActivity = prev;
+ mLastPausedActivity = prev;
+ mLastNoHistoryActivity = (prev.intent.getFlags() & Intent.FLAG_ACTIVITY_NO_HISTORY) != 0
+ || (prev.info.flags & ActivityInfo.FLAG_NO_HISTORY) != 0 ? prev : null;
+ prev.setState(PAUSING, "startPausingLocked");
+ prev.getTask().touchActiveTime();
+ clearLaunchTime(prev);
+
+ mService.updateCpuStats();
+
+ if (prev.attachedToProcess()) {
+ if (DEBUG_PAUSE) Slog.v(TAG_PAUSE, "Enqueueing pending pause: " + prev);
+ try {
+ EventLogTags.writeAmPauseActivity(prev.userId, System.identityHashCode(prev),
+ prev.shortComponentName, "userLeaving=" + userLeaving);
+ mService.updateUsageStats(prev, false);
+
+ mService.getLifecycleManager().scheduleTransaction(prev.app.getThread(),
+ prev.appToken, PauseActivityItem.obtain(prev.finishing, userLeaving,
+ prev.configChangeFlags, pauseImmediately));
+ } catch (Exception e) {
+ // Ignore exception, if process died other code will cleanup.
+ Slog.w(TAG, "Exception thrown during pause", e);
+ mPausingActivity = null;
+ mLastPausedActivity = null;
+ mLastNoHistoryActivity = null;
+ }
+ } else {
+ mPausingActivity = null;
+ mLastPausedActivity = null;
+ mLastNoHistoryActivity = null;
+ }
+
+ // If we are not going to sleep, we want to ensure the device is
+ // awake until the next activity is started.
+ if (!uiSleeping && !mService.isSleepingOrShuttingDownLocked()) {
+ mStackSupervisor.acquireLaunchWakelock();
+ }
+
+ if (mPausingActivity != null) {
+ // Have the window manager pause its key dispatching until the new
+ // activity has started. If we're pausing the activity just because
+ // the screen is being turned off and the UI is sleeping, don't interrupt
+ // key dispatch; the same activity will pick it up again on wakeup.
+ if (!uiSleeping) {
+ prev.pauseKeyDispatchingLocked();
+ } else if (DEBUG_PAUSE) {
+ Slog.v(TAG_PAUSE, "Key dispatch not paused for screen off");
+ }
+
+ if (pauseImmediately) {
+ // If the caller said they don't want to wait for the pause, then complete
+ // the pause now.
+ completePauseLocked(false, resuming);
+ return false;
+
+ } else {
+ schedulePauseTimeout(prev);
+ return true;
+ }
+
+ } else {
+ // This activity failed to schedule the
+ // pause, so just treat it as being paused now.
+ if (DEBUG_PAUSE) Slog.v(TAG_PAUSE, "Activity not running, resuming next.");
+ if (resuming == null) {
+ mStackSupervisor.resumeFocusedStacksTopActivitiesLocked();
+ }
+ return false;
+ }
+ }
+
+ final void activityPausedLocked(IBinder token, boolean timeout) {
+ if (DEBUG_PAUSE) Slog.v(TAG_PAUSE,
+ "Activity paused: token=" + token + ", timeout=" + timeout);
+
+ final ActivityRecord r = isInStackLocked(token);
+ if (r != null) {
+ mHandler.removeMessages(PAUSE_TIMEOUT_MSG, r);
+ if (mPausingActivity == r) {
+ if (DEBUG_STATES) Slog.v(TAG_STATES, "Moving to PAUSED: " + r
+ + (timeout ? " (due to timeout)" : " (pause complete)"));
+ mService.mWindowManager.deferSurfaceLayout();
+ try {
+ completePauseLocked(true /* resumeNext */, null /* resumingActivity */);
+ } finally {
+ mService.mWindowManager.continueSurfaceLayout();
+ }
+ return;
+ } else {
+ EventLog.writeEvent(EventLogTags.AM_FAILED_TO_PAUSE,
+ r.userId, System.identityHashCode(r), r.shortComponentName,
+ mPausingActivity != null
+ ? mPausingActivity.shortComponentName : "(none)");
+ if (r.isState(PAUSING)) {
+ r.setState(PAUSED, "activityPausedLocked");
+ if (r.finishing) {
+ if (DEBUG_PAUSE) Slog.v(TAG,
+ "Executing finish of failed to pause activity: " + r);
+ finishCurrentActivityLocked(r, FINISH_AFTER_VISIBLE, false,
+ "activityPausedLocked");
+ }
+ }
+ }
+ }
+ mStackSupervisor.ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
+ }
+
+ private void completePauseLocked(boolean resumeNext, ActivityRecord resuming) {
+ ActivityRecord prev = mPausingActivity;
+ if (DEBUG_PAUSE) Slog.v(TAG_PAUSE, "Complete pause: " + prev);
+
+ if (prev != null) {
+ prev.setWillCloseOrEnterPip(false);
+ final boolean wasStopping = prev.isState(STOPPING);
+ prev.setState(PAUSED, "completePausedLocked");
+ if (prev.finishing) {
+ if (DEBUG_PAUSE) Slog.v(TAG_PAUSE, "Executing finish of activity: " + prev);
+ prev = finishCurrentActivityLocked(prev, FINISH_AFTER_VISIBLE, false,
+ "completedPausedLocked");
+ } else if (prev.hasProcess()) {
+ if (DEBUG_PAUSE) Slog.v(TAG_PAUSE, "Enqueue pending stop if needed: " + prev
+ + " wasStopping=" + wasStopping + " visible=" + prev.visible);
+ if (mStackSupervisor.mActivitiesWaitingForVisibleActivity.remove(prev)) {
+ if (DEBUG_SWITCH || DEBUG_PAUSE) Slog.v(TAG_PAUSE,
+ "Complete pause, no longer waiting: " + prev);
+ }
+ if (prev.deferRelaunchUntilPaused) {
+ // Complete the deferred relaunch that was waiting for pause to complete.
+ if (DEBUG_PAUSE) Slog.v(TAG_PAUSE, "Re-launching after pause: " + prev);
+ prev.relaunchActivityLocked(false /* andResume */,
+ prev.preserveWindowOnDeferredRelaunch);
+ } else if (wasStopping) {
+ // We are also stopping, the stop request must have gone soon after the pause.
+ // We can't clobber it, because the stop confirmation will not be handled.
+ // We don't need to schedule another stop, we only need to let it happen.
+ prev.setState(STOPPING, "completePausedLocked");
+ } else if (!prev.visible || shouldSleepOrShutDownActivities()) {
+ // Clear out any deferred client hide we might currently have.
+ prev.setDeferHidingClient(false);
+ // If we were visible then resumeTopActivities will release resources before
+ // stopping.
+ addToStopping(prev, true /* scheduleIdle */, false /* idleDelayed */);
+ }
+ } else {
+ if (DEBUG_PAUSE) Slog.v(TAG_PAUSE, "App died during pause, not stopping: " + prev);
+ prev = null;
+ }
+ // It is possible the activity was freezing the screen before it was paused.
+ // In that case go ahead and remove the freeze this activity has on the screen
+ // since it is no longer visible.
+ if (prev != null) {
+ prev.stopFreezingScreenLocked(true /*force*/);
+ }
+ mPausingActivity = null;
+ }
+
+ if (resumeNext) {
+ final ActivityStack topStack = mStackSupervisor.getTopDisplayFocusedStack();
+ if (!topStack.shouldSleepOrShutDownActivities()) {
+ mStackSupervisor.resumeFocusedStacksTopActivitiesLocked(topStack, prev, null);
+ } else {
+ checkReadyForSleep();
+ ActivityRecord top = topStack.topRunningActivityLocked();
+ if (top == null || (prev != null && top != prev)) {
+ // If there are no more activities available to run, do resume anyway to start
+ // something. Also if the top activity on the stack is not the just paused
+ // activity, we need to go ahead and resume it to ensure we complete an
+ // in-flight app switch.
+ mStackSupervisor.resumeFocusedStacksTopActivitiesLocked();
+ }
+ }
+ }
+
+ if (prev != null) {
+ prev.resumeKeyDispatchingLocked();
+
+ if (prev.hasProcess() && prev.cpuTimeAtResume > 0) {
+ final long diff = prev.app.getCpuTime() - prev.cpuTimeAtResume;
+ if (diff > 0) {
+ final Runnable r = PooledLambda.obtainRunnable(
+ ActivityManagerInternal::updateForegroundTimeIfOnBattery,
+ mService.mAmInternal, prev.info.packageName,
+ prev.info.applicationInfo.uid,
+ diff);
+ mService.mH.post(r);
+ }
+ }
+ prev.cpuTimeAtResume = 0; // reset it
+ }
+
+ // Notify when the task stack has changed, but only if visibilities changed (not just
+ // focus). Also if there is an active pinned stack - we always want to notify it about
+ // task stack changes, because its positioning may depend on it.
+ if (mStackSupervisor.mAppVisibilitiesChangedSinceLastPause
+ || getDisplay().hasPinnedStack()) {
+ mService.getTaskChangeNotificationController().notifyTaskStackChanged();
+ mStackSupervisor.mAppVisibilitiesChangedSinceLastPause = false;
+ }
+
+ mStackSupervisor.ensureActivitiesVisibleLocked(resuming, 0, !PRESERVE_WINDOWS);
+ }
+
+ private void addToStopping(ActivityRecord r, boolean scheduleIdle, boolean idleDelayed) {
+ if (!mStackSupervisor.mStoppingActivities.contains(r)) {
+ mStackSupervisor.mStoppingActivities.add(r);
+
+ // Some activity is waiting for another activity to become visible before it's being
+ // stopped, which means that we also want to wait with stopping this one to avoid
+ // flickers.
+ if (!mStackSupervisor.mActivitiesWaitingForVisibleActivity.isEmpty()
+ && !mStackSupervisor.mActivitiesWaitingForVisibleActivity.contains(r)) {
+ if (DEBUG_SWITCH) Slog.i(TAG_SWITCH, "adding to waiting visible activity=" + r
+ + " existing=" + mStackSupervisor.mActivitiesWaitingForVisibleActivity);
+ mStackSupervisor.mActivitiesWaitingForVisibleActivity.add(r);
+ }
+ }
+
+ // If we already have a few activities waiting to stop, then give up
+ // on things going idle and start clearing them out. Or if r is the
+ // last of activity of the last task the stack will be empty and must
+ // be cleared immediately.
+ boolean forceIdle = mStackSupervisor.mStoppingActivities.size() > MAX_STOPPING_TO_FORCE
+ || (r.frontOfTask && mTaskHistory.size() <= 1);
+ if (scheduleIdle || forceIdle) {
+ if (DEBUG_PAUSE) Slog.v(TAG_PAUSE, "Scheduling idle now: forceIdle="
+ + forceIdle + "immediate=" + !idleDelayed);
+ if (!idleDelayed) {
+ mStackSupervisor.scheduleIdleLocked();
+ } else {
+ mStackSupervisor.scheduleIdleTimeoutLocked(r);
+ }
+ } else {
+ checkReadyForSleep();
+ }
+ }
+
+ /**
+ * Returns true if the stack is translucent and can have other contents visible behind it if
+ * needed. A stack is considered translucent if it don't contain a visible or
+ * starting (about to be visible) activity that is fullscreen (opaque).
+ * @param starting The currently starting activity or null if there is none.
+ */
+ @VisibleForTesting
+ boolean isStackTranslucent(ActivityRecord starting) {
+ if (!isAttached() || mForceHidden) {
+ return true;
+ }
+ for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
+ final TaskRecord task = mTaskHistory.get(taskNdx);
+ final ArrayList<ActivityRecord> activities = task.mActivities;
+ for (int activityNdx = activities.size() - 1; activityNdx >= 0; --activityNdx) {
+ final ActivityRecord r = activities.get(activityNdx);
+
+ if (r.finishing) {
+ // We don't factor in finishing activities when determining translucency since
+ // they will be gone soon.
+ continue;
+ }
+
+ if (!r.visibleIgnoringKeyguard && r != starting) {
+ // Also ignore invisible activities that are not the currently starting
+ // activity (about to be visible).
+ continue;
+ }
+
+ if (r.fullscreen || r.hasWallpaper) {
+ // Stack isn't translucent if it has at least one fullscreen activity
+ // that is visible.
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+
+ boolean isTopStackOnDisplay() {
+ final ActivityDisplay display = getDisplay();
+ return display != null && display.isTopStack(this);
+ }
+
+ /**
+ * @return {@code true} if this is the focused stack on its current display, {@code false}
+ * otherwise.
+ */
+ boolean isFocusedStackOnDisplay() {
+ final ActivityDisplay display = getDisplay();
+ return display != null && this == display.getFocusedStack();
+ }
+
+ boolean isTopActivityVisible() {
+ final ActivityRecord topActivity = getTopActivity();
+ return topActivity != null && topActivity.visible;
+ }
+
+ /**
+ * Returns true if the stack should be visible.
+ *
+ * @param starting The currently starting activity or null if there is none.
+ */
+ boolean shouldBeVisible(ActivityRecord starting) {
+ if (!isAttached() || mForceHidden) {
+ return false;
+ }
+
+ final ActivityDisplay display = getDisplay();
+ boolean gotSplitScreenStack = false;
+ boolean gotOpaqueSplitScreenPrimary = false;
+ boolean gotOpaqueSplitScreenSecondary = false;
+ final int windowingMode = getWindowingMode();
+ final boolean isAssistantType = isActivityTypeAssistant();
+ for (int i = display.getChildCount() - 1; i >= 0; --i) {
+ final ActivityStack other = display.getChildAt(i);
+ final boolean hasRunningActivities = other.topRunningActivityLocked() != null;
+ if (other == this) {
+ // Should be visible if there is no other stack occluding it, unless it doesn't
+ // have any running activities, not starting one and not home stack.
+ return hasRunningActivities || isInStackLocked(starting) != null
+ || isActivityTypeHome();
+ }
+
+ if (!hasRunningActivities) {
+ continue;
+ }
+
+ final int otherWindowingMode = other.getWindowingMode();
+
+ if (otherWindowingMode == WINDOWING_MODE_FULLSCREEN) {
+ // In this case the home stack isn't resizeable even though we are in split-screen
+ // mode. We still want the primary splitscreen stack to be visible as there will be
+ // a slight hint of it in the status bar area above the non-resizeable home
+ // activity. In addition, if the fullscreen assistant is over primary splitscreen
+ // stack, the stack should still be visible in the background as long as the recents
+ // animation is running.
+ final int activityType = other.getActivityType();
+ if (windowingMode == WINDOWING_MODE_SPLIT_SCREEN_PRIMARY) {
+ if (activityType == ACTIVITY_TYPE_HOME
+ || (activityType == ACTIVITY_TYPE_ASSISTANT
+ && mWindowManager.getRecentsAnimationController() != null)) {
+ return true;
+ }
+ }
+ if (other.isStackTranslucent(starting)) {
+ // Can be visible behind a translucent fullscreen stack.
+ continue;
+ }
+ return false;
+ } else if (otherWindowingMode == WINDOWING_MODE_SPLIT_SCREEN_PRIMARY
+ && !gotOpaqueSplitScreenPrimary) {
+ gotSplitScreenStack = true;
+ gotOpaqueSplitScreenPrimary =
+ !other.isStackTranslucent(starting);
+ if (windowingMode == WINDOWING_MODE_SPLIT_SCREEN_PRIMARY
+ && gotOpaqueSplitScreenPrimary) {
+ // Can not be visible behind another opaque stack in split-screen-primary mode.
+ return false;
+ }
+ } else if (otherWindowingMode == WINDOWING_MODE_SPLIT_SCREEN_SECONDARY
+ && !gotOpaqueSplitScreenSecondary) {
+ gotSplitScreenStack = true;
+ gotOpaqueSplitScreenSecondary =
+ !other.isStackTranslucent(starting);
+ if (windowingMode == WINDOWING_MODE_SPLIT_SCREEN_SECONDARY
+ && gotOpaqueSplitScreenSecondary) {
+ // Can not be visible behind another opaque stack in split-screen-secondary mode.
+ return false;
+ }
+ }
+ if (gotOpaqueSplitScreenPrimary && gotOpaqueSplitScreenSecondary) {
+ // Can not be visible if we are in split-screen windowing mode and both halves of
+ // the screen are opaque.
+ return false;
+ }
+ if (isAssistantType && gotSplitScreenStack) {
+ // Assistant stack can't be visible behind split-screen. In addition to this not
+ // making sense, it also works around an issue here we boost the z-order of the
+ // assistant window surfaces in window manager whenever it is visible.
+ return false;
+ }
+ }
+
+ // Well, nothing is stopping you from being visible...
+ return true;
+ }
+
+ final int rankTaskLayers(int baseLayer) {
+ int layer = 0;
+ for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
+ final TaskRecord task = mTaskHistory.get(taskNdx);
+ ActivityRecord r = task.topRunningActivityLocked();
+ if (r == null || r.finishing || !r.visible) {
+ task.mLayerRank = -1;
+ } else {
+ task.mLayerRank = baseLayer + layer++;
+ }
+ }
+ return layer;
+ }
+
+ /**
+ * Make sure that all activities that need to be visible in the stack (that is, they
+ * currently can be seen by the user) actually are and update their configuration.
+ */
+ final void ensureActivitiesVisibleLocked(ActivityRecord starting, int configChanges,
+ boolean preserveWindows) {
+ ensureActivitiesVisibleLocked(starting, configChanges, preserveWindows,
+ true /* notifyClients */);
+ }
+
+ /**
+ * Ensure visibility with an option to also update the configuration of visible activities.
+ * @see #ensureActivitiesVisibleLocked(ActivityRecord, int, boolean)
+ * @see ActivityStackSupervisor#ensureActivitiesVisibleLocked(ActivityRecord, int, boolean)
+ */
+ // TODO: Should be re-worked based on the fact that each task as a stack in most cases.
+ final void ensureActivitiesVisibleLocked(ActivityRecord starting, int configChanges,
+ boolean preserveWindows, boolean notifyClients) {
+ mTopActivityOccludesKeyguard = false;
+ mTopDismissingKeyguardActivity = null;
+ mStackSupervisor.getKeyguardController().beginActivityVisibilityUpdate();
+ try {
+ ActivityRecord top = topRunningActivityLocked();
+ if (DEBUG_VISIBILITY) Slog.v(TAG_VISIBILITY, "ensureActivitiesVisible behind " + top
+ + " configChanges=0x" + Integer.toHexString(configChanges));
+ if (top != null) {
+ checkTranslucentActivityWaiting(top);
+ }
+
+ // If the top activity is not fullscreen, then we need to
+ // make sure any activities under it are now visible.
+ boolean aboveTop = top != null;
+ final boolean stackShouldBeVisible = shouldBeVisible(starting);
+ boolean behindFullscreenActivity = !stackShouldBeVisible;
+ boolean resumeNextActivity = mStackSupervisor.isTopDisplayFocusedStack(this)
+ && (isInStackLocked(starting) == null);
+ final boolean isTopNotPinnedStack =
+ isAttached() && getDisplay().isTopNotPinnedStack(this);
+ for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
+ final TaskRecord task = mTaskHistory.get(taskNdx);
+ final ArrayList<ActivityRecord> activities = task.mActivities;
+ for (int activityNdx = activities.size() - 1; activityNdx >= 0; --activityNdx) {
+ final ActivityRecord r = activities.get(activityNdx);
+ if (r.finishing) {
+ continue;
+ }
+ final boolean isTop = r == top;
+ if (aboveTop && !isTop) {
+ continue;
+ }
+ aboveTop = false;
+
+ // Check whether activity should be visible without Keyguard influence
+ final boolean visibleIgnoringKeyguard = r.shouldBeVisibleIgnoringKeyguard(
+ behindFullscreenActivity);
+ r.visibleIgnoringKeyguard = visibleIgnoringKeyguard;
+
+ // Now check whether it's really visible depending on Keyguard state.
+ final boolean reallyVisible = checkKeyguardVisibility(r,
+ visibleIgnoringKeyguard, isTop && isTopNotPinnedStack);
+ if (visibleIgnoringKeyguard) {
+ behindFullscreenActivity = updateBehindFullscreen(!stackShouldBeVisible,
+ behindFullscreenActivity, r);
+ }
+ if (reallyVisible) {
+ if (DEBUG_VISIBILITY) Slog.v(TAG_VISIBILITY, "Make visible? " + r
+ + " finishing=" + r.finishing + " state=" + r.getState());
+ // First: if this is not the current activity being started, make
+ // sure it matches the current configuration.
+ if (r != starting && notifyClients) {
+ r.ensureActivityConfiguration(0 /* globalChanges */, preserveWindows,
+ true /* ignoreStopState */);
+ }
+
+ if (!r.attachedToProcess()) {
+ if (makeVisibleAndRestartIfNeeded(starting, configChanges, isTop,
+ resumeNextActivity, r)) {
+ if (activityNdx >= activities.size()) {
+ // Record may be removed if its process needs to restart.
+ activityNdx = activities.size() - 1;
+ } else {
+ resumeNextActivity = false;
+ }
+ }
+ } else if (r.visible) {
+ // If this activity is already visible, then there is nothing to do here.
+ if (DEBUG_VISIBILITY) Slog.v(TAG_VISIBILITY,
+ "Skipping: already visible at " + r);
+
+ if (r.mClientVisibilityDeferred && notifyClients) {
+ r.makeClientVisible();
+ }
+
+ if (r.handleAlreadyVisible()) {
+ resumeNextActivity = false;
+ }
+ } else {
+ r.makeVisibleIfNeeded(starting, notifyClients);
+ }
+ // Aggregate current change flags.
+ configChanges |= r.configChangeFlags;
+ } else {
+ if (DEBUG_VISIBILITY) Slog.v(TAG_VISIBILITY, "Make invisible? " + r
+ + " finishing=" + r.finishing + " state=" + r.getState()
+ + " stackShouldBeVisible=" + stackShouldBeVisible
+ + " behindFullscreenActivity=" + behindFullscreenActivity
+ + " mLaunchTaskBehind=" + r.mLaunchTaskBehind);
+ makeInvisible(r);
+ }
+ }
+ final int windowingMode = getWindowingMode();
+ if (windowingMode == WINDOWING_MODE_FREEFORM) {
+ // The visibility of tasks and the activities they contain in freeform stack are
+ // determined individually unlike other stacks where the visibility or fullscreen
+ // status of an activity in a previous task affects other.
+ behindFullscreenActivity = !stackShouldBeVisible;
+ } else if (isActivityTypeHome()) {
+ if (DEBUG_VISIBILITY) Slog.v(TAG_VISIBILITY, "Home task: at " + task
+ + " stackShouldBeVisible=" + stackShouldBeVisible
+ + " behindFullscreenActivity=" + behindFullscreenActivity);
+ // No other task in the home stack should be visible behind the home activity.
+ // Home activities is usually a translucent activity with the wallpaper behind
+ // them. However, when they don't have the wallpaper behind them, we want to
+ // show activities in the next application stack behind them vs. another
+ // task in the home stack like recents.
+ behindFullscreenActivity = true;
+ }
+ }
+
+ if (mTranslucentActivityWaiting != null &&
+ mUndrawnActivitiesBelowTopTranslucent.isEmpty()) {
+ // Nothing is getting drawn or everything was already visible, don't wait for timeout.
+ notifyActivityDrawnLocked(null);
+ }
+ } finally {
+ mStackSupervisor.getKeyguardController().endActivityVisibilityUpdate();
+ }
+ }
+
+ void addStartingWindowsForVisibleActivities(boolean taskSwitch) {
+ for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
+ mTaskHistory.get(taskNdx).addStartingWindowsForVisibleActivities(taskSwitch);
+ }
+ }
+
+ /**
+ * @return true if the top visible activity wants to occlude the Keyguard, false otherwise
+ */
+ boolean topActivityOccludesKeyguard() {
+ return mTopActivityOccludesKeyguard;
+ }
+
+ /**
+ * Returns true if this stack should be resized to match the bounds specified by
+ * {@link ActivityOptions#setLaunchBounds} when launching an activity into the stack.
+ */
+ boolean resizeStackWithLaunchBounds() {
+ return inPinnedWindowingMode();
+ }
+
+ @Override
+ public boolean supportsSplitScreenWindowingMode() {
+ final TaskRecord topTask = topTask();
+ return super.supportsSplitScreenWindowingMode()
+ && (topTask == null || topTask.supportsSplitScreenWindowingMode());
+ }
+
+ /** @return True if the resizing of the primary-split-screen stack affects this stack size. */
+ boolean affectedBySplitScreenResize() {
+ if (!supportsSplitScreenWindowingMode()) {
+ return false;
+ }
+ final int windowingMode = getWindowingMode();
+ return windowingMode != WINDOWING_MODE_FREEFORM && windowingMode != WINDOWING_MODE_PINNED;
+ }
+
+ /**
+ * @return the top most visible activity that wants to dismiss Keyguard
+ */
+ ActivityRecord getTopDismissingKeyguardActivity() {
+ return mTopDismissingKeyguardActivity;
+ }
+
+ /**
+ * Checks whether {@param r} should be visible depending on Keyguard state and updates
+ * {@link #mTopActivityOccludesKeyguard} and {@link #mTopDismissingKeyguardActivity} if
+ * necessary.
+ *
+ * @return true if {@param r} is visible taken Keyguard state into account, false otherwise
+ */
+ boolean checkKeyguardVisibility(ActivityRecord r, boolean shouldBeVisible, boolean isTop) {
+ final int displayId = mDisplayId != INVALID_DISPLAY ? mDisplayId : DEFAULT_DISPLAY;
+ final boolean keyguardOrAodShowing = mStackSupervisor.getKeyguardController()
+ .isKeyguardOrAodShowing(displayId);
+ final boolean keyguardLocked = mStackSupervisor.getKeyguardController().isKeyguardLocked();
+ final boolean showWhenLocked = r.canShowWhenLocked();
+ final boolean dismissKeyguard = r.hasDismissKeyguardWindows();
+ if (shouldBeVisible) {
+ if (dismissKeyguard && mTopDismissingKeyguardActivity == null) {
+ mTopDismissingKeyguardActivity = r;
+ }
+
+ // Only the top activity may control occluded, as we can't occlude the Keyguard if the
+ // top app doesn't want to occlude it.
+ if (isTop) {
+ mTopActivityOccludesKeyguard |= showWhenLocked;
+ }
+
+ final boolean canShowWithKeyguard = canShowWithInsecureKeyguard()
+ && mStackSupervisor.getKeyguardController().canDismissKeyguard();
+ if (canShowWithKeyguard) {
+ return true;
+ }
+ }
+ if (keyguardOrAodShowing) {
+ // If keyguard is showing, nothing is visible, except if we are able to dismiss Keyguard
+ // right away and AOD isn't visible.
+ return shouldBeVisible && mStackSupervisor.getKeyguardController()
+ .canShowActivityWhileKeyguardShowing(r, dismissKeyguard);
+ } else if (keyguardLocked) {
+ return shouldBeVisible && mStackSupervisor.getKeyguardController().canShowWhileOccluded(
+ dismissKeyguard, showWhenLocked);
+ } else {
+ return shouldBeVisible;
+ }
+ }
+
+ /**
+ * Check if the display to which this stack is attached has
+ * {@link Display#FLAG_CAN_SHOW_WITH_INSECURE_KEYGUARD} applied.
+ */
+ private boolean canShowWithInsecureKeyguard() {
+ final ActivityDisplay activityDisplay = getDisplay();
+ if (activityDisplay == null) {
+ throw new IllegalStateException("Stack is not attached to any display, stackId="
+ + mStackId);
+ }
+
+ final int flags = activityDisplay.mDisplay.getFlags();
+ return (flags & FLAG_CAN_SHOW_WITH_INSECURE_KEYGUARD) != 0;
+ }
+
+ private void checkTranslucentActivityWaiting(ActivityRecord top) {
+ if (mTranslucentActivityWaiting != top) {
+ mUndrawnActivitiesBelowTopTranslucent.clear();
+ if (mTranslucentActivityWaiting != null) {
+ // Call the callback with a timeout indication.
+ notifyActivityDrawnLocked(null);
+ mTranslucentActivityWaiting = null;
+ }
+ mHandler.removeMessages(TRANSLUCENT_TIMEOUT_MSG);
+ }
+ }
+
+ private boolean makeVisibleAndRestartIfNeeded(ActivityRecord starting, int configChanges,
+ boolean isTop, boolean andResume, ActivityRecord r) {
+ // We need to make sure the app is running if it's the top, or it is just made visible from
+ // invisible. If the app is already visible, it must have died while it was visible. In this
+ // case, we'll show the dead window but will not restart the app. Otherwise we could end up
+ // thrashing.
+ if (isTop || !r.visible) {
+ // This activity needs to be visible, but isn't even running...
+ // get it started and resume if no other stack in this stack is resumed.
+ if (DEBUG_VISIBILITY) Slog.v(TAG_VISIBILITY, "Start and freeze screen for " + r);
+ if (r != starting) {
+ r.startFreezingScreenLocked(r.app, configChanges);
+ }
+ if (!r.visible || r.mLaunchTaskBehind) {
+ if (DEBUG_VISIBILITY) Slog.v(TAG_VISIBILITY, "Starting and making visible: " + r);
+ r.setVisible(true);
+ }
+ if (r != starting) {
+ mStackSupervisor.startSpecificActivityLocked(r, andResume, false);
+ return true;
+ }
+ }
+ return false;
+ }
+
+ // TODO: Should probably be moved into ActivityRecord.
+ private void makeInvisible(ActivityRecord r) {
+ if (!r.visible) {
+ if (DEBUG_VISIBILITY) Slog.v(TAG_VISIBILITY, "Already invisible: " + r);
+ return;
+ }
+ // Now for any activities that aren't visible to the user, make sure they no longer are
+ // keeping the screen frozen.
+ if (DEBUG_VISIBILITY) Slog.v(TAG_VISIBILITY, "Making invisible: " + r + " " + r.getState());
+ try {
+ final boolean canEnterPictureInPicture = r.checkEnterPictureInPictureState(
+ "makeInvisible", true /* beforeStopping */);
+ // Defer telling the client it is hidden if it can enter Pip and isn't current paused,
+ // stopped or stopping. This gives it a chance to enter Pip in onPause().
+ // TODO: There is still a question surrounding activities in multi-window mode that want
+ // to enter Pip after they are paused, but are still visible. I they should be okay to
+ // enter Pip in those cases, but not "auto-Pip" which is what this condition covers and
+ // the current contract for "auto-Pip" is that the app should enter it before onPause
+ // returns. Just need to confirm this reasoning makes sense.
+ final boolean deferHidingClient = canEnterPictureInPicture
+ && !r.isState(STOPPING, STOPPED, PAUSED);
+ r.setDeferHidingClient(deferHidingClient);
+ r.setVisible(false);
+
+ switch (r.getState()) {
+ case STOPPING:
+ case STOPPED:
+ if (r.attachedToProcess()) {
+ if (DEBUG_VISIBILITY) Slog.v(TAG_VISIBILITY,
+ "Scheduling invisibility: " + r);
+ mService.getLifecycleManager().scheduleTransaction(r.app.getThread(),
+ r.appToken, WindowVisibilityItem.obtain(false /* showWindow */));
+ }
+
+ // Reset the flag indicating that an app can enter picture-in-picture once the
+ // activity is hidden
+ r.supportsEnterPipOnTaskSwitch = false;
+ break;
+
+ case INITIALIZING:
+ case RESUMED:
+ case PAUSING:
+ case PAUSED:
+ addToStopping(r, true /* scheduleIdle */,
+ canEnterPictureInPicture /* idleDelayed */);
+ break;
+
+ default:
+ break;
+ }
+ } catch (Exception e) {
+ // Just skip on any failure; we'll make it visible when it next restarts.
+ Slog.w(TAG, "Exception thrown making hidden: " + r.intent.getComponent(), e);
+ }
+ }
+
+ private boolean updateBehindFullscreen(boolean stackInvisible, boolean behindFullscreenActivity,
+ ActivityRecord r) {
+ if (r.fullscreen) {
+ if (DEBUG_VISIBILITY) Slog.v(TAG_VISIBILITY, "Fullscreen: at " + r
+ + " stackInvisible=" + stackInvisible
+ + " behindFullscreenActivity=" + behindFullscreenActivity);
+ // At this point, nothing else needs to be shown in this task.
+ behindFullscreenActivity = true;
+ }
+ return behindFullscreenActivity;
+ }
+
+ void convertActivityToTranslucent(ActivityRecord r) {
+ mTranslucentActivityWaiting = r;
+ mUndrawnActivitiesBelowTopTranslucent.clear();
+ mHandler.sendEmptyMessageDelayed(TRANSLUCENT_TIMEOUT_MSG, TRANSLUCENT_CONVERSION_TIMEOUT);
+ }
+
+ void clearOtherAppTimeTrackers(AppTimeTracker except) {
+ for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
+ final TaskRecord task = mTaskHistory.get(taskNdx);
+ final ArrayList<ActivityRecord> activities = task.mActivities;
+ for (int activityNdx = activities.size() - 1; activityNdx >= 0; --activityNdx) {
+ final ActivityRecord r = activities.get(activityNdx);
+ if ( r.appTimeTracker != except) {
+ r.appTimeTracker = null;
+ }
+ }
+ }
+ }
+
+ /**
+ * Called as activities below the top translucent activity are redrawn. When the last one is
+ * redrawn notify the top activity by calling
+ * {@link Activity#onTranslucentConversionComplete}.
+ *
+ * @param r The most recent background activity to be drawn. Or, if r is null then a timeout
+ * occurred and the activity will be notified immediately.
+ */
+ void notifyActivityDrawnLocked(ActivityRecord r) {
+ if ((r == null)
+ || (mUndrawnActivitiesBelowTopTranslucent.remove(r) &&
+ mUndrawnActivitiesBelowTopTranslucent.isEmpty())) {
+ // The last undrawn activity below the top has just been drawn. If there is an
+ // opaque activity at the top, notify it that it can become translucent safely now.
+ final ActivityRecord waitingActivity = mTranslucentActivityWaiting;
+ mTranslucentActivityWaiting = null;
+ mUndrawnActivitiesBelowTopTranslucent.clear();
+ mHandler.removeMessages(TRANSLUCENT_TIMEOUT_MSG);
+
+ if (waitingActivity != null) {
+ mWindowManager.setWindowOpaque(waitingActivity.appToken, false);
+ if (waitingActivity.attachedToProcess()) {
+ try {
+ waitingActivity.app.getThread().scheduleTranslucentConversionComplete(
+ waitingActivity.appToken, r != null);
+ } catch (RemoteException e) {
+ }
+ }
+ }
+ }
+ }
+
+ /** If any activities below the top running one are in the INITIALIZING state and they have a
+ * starting window displayed then remove that starting window. It is possible that the activity
+ * in this state will never resumed in which case that starting window will be orphaned. */
+ void cancelInitializingActivities() {
+ final ActivityRecord topActivity = topRunningActivityLocked();
+ boolean aboveTop = true;
+ // We don't want to clear starting window for activities that aren't behind fullscreen
+ // activities as we need to display their starting window until they are done initializing.
+ boolean behindFullscreenActivity = false;
+
+ if (!shouldBeVisible(null)) {
+ // The stack is not visible, so no activity in it should be displaying a starting
+ // window. Mark all activities below top and behind fullscreen.
+ aboveTop = false;
+ behindFullscreenActivity = true;
+ }
+
+ for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
+ final ArrayList<ActivityRecord> activities = mTaskHistory.get(taskNdx).mActivities;
+ for (int activityNdx = activities.size() - 1; activityNdx >= 0; --activityNdx) {
+ final ActivityRecord r = activities.get(activityNdx);
+ if (aboveTop) {
+ if (r == topActivity) {
+ aboveTop = false;
+ }
+ behindFullscreenActivity |= r.fullscreen;
+ continue;
+ }
+
+ r.removeOrphanedStartingWindow(behindFullscreenActivity);
+ behindFullscreenActivity |= r.fullscreen;
+ }
+ }
+ }
+
+ /**
+ * Ensure that the top activity in the stack is resumed.
+ *
+ * @param prev The previously resumed activity, for when in the process
+ * of pausing; can be null to call from elsewhere.
+ * @param options Activity options.
+ *
+ * @return Returns true if something is being resumed, or false if
+ * nothing happened.
+ *
+ * NOTE: It is not safe to call this method directly as it can cause an activity in a
+ * non-focused stack to be resumed.
+ * Use {@link ActivityStackSupervisor#resumeFocusedStacksTopActivitiesLocked} to resume the
+ * right activity for the current system state.
+ */
+ @GuardedBy("mService")
+ boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
+ if (mStackSupervisor.inResumeTopActivity) {
+ // Don't even start recursing.
+ return false;
+ }
+
+ boolean result = false;
+ try {
+ // Protect against recursion.
+ mStackSupervisor.inResumeTopActivity = true;
+ result = resumeTopActivityInnerLocked(prev, options);
+
+ // When resuming the top activity, it may be necessary to pause the top activity (for
+ // example, returning to the lock screen. We suppress the normal pause logic in
+ // {@link #resumeTopActivityUncheckedLocked}, since the top activity is resumed at the
+ // end. We call the {@link ActivityStackSupervisor#checkReadyForSleepLocked} again here
+ // to ensure any necessary pause logic occurs. In the case where the Activity will be
+ // shown regardless of the lock screen, the call to
+ // {@link ActivityStackSupervisor#checkReadyForSleepLocked} is skipped.
+ final ActivityRecord next = topRunningActivityLocked(true /* focusableOnly */);
+ if (next == null || !next.canTurnScreenOn()) {
+ checkReadyForSleep();
+ }
+ } finally {
+ mStackSupervisor.inResumeTopActivity = false;
+ }
+
+ return result;
+ }
+
+ /**
+ * Returns the currently resumed activity.
+ */
+ protected ActivityRecord getResumedActivity() {
+ return mResumedActivity;
+ }
+
+ private void setResumedActivity(ActivityRecord r, String reason) {
+ if (mResumedActivity == r) {
+ return;
+ }
+
+ if (DEBUG_STACK) Slog.d(TAG_STACK, "setResumedActivity stack:" + this + " + from: "
+ + mResumedActivity + " to:" + r + " reason:" + reason);
+ mResumedActivity = r;
+ }
+
+ @GuardedBy("mService")
+ private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
+ if (!mService.isBooting() && !mService.isBooted()) {
+ // Not ready yet!
+ return false;
+ }
+
+ // Find the next top-most activity to resume in this stack that is not finishing and is
+ // focusable. If it is not focusable, we will fall into the case below to resume the
+ // top activity in the next focusable task.
+ final ActivityRecord next = topRunningActivityLocked(true /* focusableOnly */);
+
+ final boolean hasRunningActivity = next != null;
+
+ // TODO: Maybe this entire condition can get removed?
+ if (hasRunningActivity && !isAttached()) {
+ return false;
+ }
+
+ mStackSupervisor.cancelInitializingActivities();
+
+ // Remember how we'll process this pause/resume situation, and ensure
+ // that the state is reset however we wind up proceeding.
+ boolean userLeaving = mStackSupervisor.mUserLeaving;
+ mStackSupervisor.mUserLeaving = false;
+
+ if (!hasRunningActivity) {
+ // There are no activities left in the stack, let's look somewhere else.
+ return resumeTopActivityInNextFocusableStack(prev, options, "noMoreActivities");
+ }
+
+ next.delayedResume = false;
+ final ActivityDisplay display = getDisplay();
+
+ // If the top activity is the resumed one, nothing to do.
+ if (mResumedActivity == next && next.isState(RESUMED)
+ && display.allResumedActivitiesComplete()) {
+ // Make sure we have executed any pending transitions, since there
+ // should be nothing left to do at this point.
+ executeAppTransition(options);
+ if (DEBUG_STATES) Slog.d(TAG_STATES,
+ "resumeTopActivityLocked: Top activity resumed " + next);
+ if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
+ return false;
+ }
+
+ // If we are sleeping, and there is no resumed activity, and the top
+ // activity is paused, well that is the state we want.
+ if (shouldSleepOrShutDownActivities()
+ && mLastPausedActivity == next
+ && mStackSupervisor.allPausedActivitiesComplete()) {
+ // If the current top activity may be able to occlude keyguard but the occluded state
+ // has not been set, update visibility and check again if we should continue to resume.
+ boolean nothingToResume = true;
+ if (!mService.mShuttingDown && !mTopActivityOccludesKeyguard
+ && next.canShowWhenLocked()) {
+ ensureActivitiesVisibleLocked(null /* starting */, 0 /* configChanges */,
+ !PRESERVE_WINDOWS);
+ nothingToResume = shouldSleepActivities();
+ }
+ if (nothingToResume) {
+ // Make sure we have executed any pending transitions, since there
+ // should be nothing left to do at this point.
+ executeAppTransition(options);
+ if (DEBUG_STATES) Slog.d(TAG_STATES,
+ "resumeTopActivityLocked: Going to sleep and all paused");
+ if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
+ return false;
+ }
+ }
+
+ // Make sure that the user who owns this activity is started. If not,
+ // we will just leave it as is because someone should be bringing
+ // another user's activities to the top of the stack.
+ if (!mService.mAmInternal.hasStartedUserState(next.userId)) {
+ Slog.w(TAG, "Skipping resume of top activity " + next
+ + ": user " + next.userId + " is stopped");
+ if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
+ return false;
+ }
+
+ // The activity may be waiting for stop, but that is no longer
+ // appropriate for it.
+ mStackSupervisor.mStoppingActivities.remove(next);
+ mStackSupervisor.mGoingToSleepActivities.remove(next);
+ next.sleeping = false;
+ mStackSupervisor.mActivitiesWaitingForVisibleActivity.remove(next);
+
+ if (DEBUG_SWITCH) Slog.v(TAG_SWITCH, "Resuming " + next);
+
+ // If we are currently pausing an activity, then don't do anything until that is done.
+ if (!mStackSupervisor.allPausedActivitiesComplete()) {
+ if (DEBUG_SWITCH || DEBUG_PAUSE || DEBUG_STATES) Slog.v(TAG_PAUSE,
+ "resumeTopActivityLocked: Skip resume: some activity pausing.");
+ if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
+ return false;
+ }
+
+ mStackSupervisor.setLaunchSource(next.info.applicationInfo.uid);
+
+ boolean lastResumedCanPip = false;
+ ActivityRecord lastResumed = null;
+ final ActivityStack lastFocusedStack = display.getLastFocusedStack();
+ if (lastFocusedStack != null && lastFocusedStack != this) {
+ // So, why aren't we using prev here??? See the param comment on the method. prev doesn't
+ // represent the last resumed activity. However, the last focus stack does if it isn't null.
+ lastResumed = lastFocusedStack.mResumedActivity;
+ if (userLeaving && inMultiWindowMode() && lastFocusedStack.shouldBeVisible(next)) {
+ // The user isn't leaving if this stack is the multi-window mode and the last
+ // focused stack should still be visible.
+ if(DEBUG_USER_LEAVING) Slog.i(TAG_USER_LEAVING, "Overriding userLeaving to false"
+ + " next=" + next + " lastResumed=" + lastResumed);
+ userLeaving = false;
+ }
+ lastResumedCanPip = lastResumed != null && lastResumed.checkEnterPictureInPictureState(
+ "resumeTopActivity", userLeaving /* beforeStopping */);
+ }
+ // If the flag RESUME_WHILE_PAUSING is set, then continue to schedule the previous activity
+ // to be paused, while at the same time resuming the new resume activity only if the
+ // previous activity can't go into Pip since we want to give Pip activities a chance to
+ // enter Pip before resuming the next activity.
+ final boolean resumeWhilePausing = (next.info.flags & FLAG_RESUME_WHILE_PAUSING) != 0
+ && !lastResumedCanPip;
+
+ boolean pausing = getDisplay().pauseBackStacks(userLeaving, next, false);
+ if (mResumedActivity != null) {
+ if (DEBUG_STATES) Slog.d(TAG_STATES,
+ "resumeTopActivityLocked: Pausing " + mResumedActivity);
+ pausing |= startPausingLocked(userLeaving, false, next, false);
+ }
+ if (pausing && !resumeWhilePausing) {
+ if (DEBUG_SWITCH || DEBUG_STATES) Slog.v(TAG_STATES,
+ "resumeTopActivityLocked: Skip resume: need to start pausing");
+ // At this point we want to put the upcoming activity's process
+ // at the top of the LRU list, since we know we will be needing it
+ // very soon and it would be a waste to let it get killed if it
+ // happens to be sitting towards the end.
+ if (next.attachedToProcess()) {
+ next.app.updateProcessInfo(false /* updateServiceConnectionActivities */,
+ true /* updateLru */, true /* activityChange */, false /* updateOomAdj */);
+ }
+ if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
+ if (lastResumed != null) {
+ lastResumed.setWillCloseOrEnterPip(true);
+ }
+ return true;
+ } else if (mResumedActivity == next && next.isState(RESUMED)
+ && display.allResumedActivitiesComplete()) {
+ // It is possible for the activity to be resumed when we paused back stacks above if the
+ // next activity doesn't have to wait for pause to complete.
+ // So, nothing else to-do except:
+ // Make sure we have executed any pending transitions, since there
+ // should be nothing left to do at this point.
+ executeAppTransition(options);
+ if (DEBUG_STATES) Slog.d(TAG_STATES,
+ "resumeTopActivityLocked: Top activity resumed (dontWaitForPause) " + next);
+ if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
+ return true;
+ }
+
+ // If the most recent activity was noHistory but was only stopped rather
+ // than stopped+finished because the device went to sleep, we need to make
+ // sure to finish it as we're making a new activity topmost.
+ if (shouldSleepActivities() && mLastNoHistoryActivity != null &&
+ !mLastNoHistoryActivity.finishing) {
+ if (DEBUG_STATES) Slog.d(TAG_STATES,
+ "no-history finish of " + mLastNoHistoryActivity + " on new resume");
+ requestFinishActivityLocked(mLastNoHistoryActivity.appToken, Activity.RESULT_CANCELED,
+ null, "resume-no-history", false);
+ mLastNoHistoryActivity = null;
+ }
+
+ if (prev != null && prev != next) {
+ if (!mStackSupervisor.mActivitiesWaitingForVisibleActivity.contains(prev)
+ && next != null && !next.nowVisible) {
+ mStackSupervisor.mActivitiesWaitingForVisibleActivity.add(prev);
+ if (DEBUG_SWITCH) Slog.v(TAG_SWITCH,
+ "Resuming top, waiting visible to hide: " + prev);
+ } else {
+ // The next activity is already visible, so hide the previous
+ // activity's windows right now so we can show the new one ASAP.
+ // We only do this if the previous is finishing, which should mean
+ // it is on top of the one being resumed so hiding it quickly
+ // is good. Otherwise, we want to do the normal route of allowing
+ // the resumed activity to be shown so we can decide if the
+ // previous should actually be hidden depending on whether the
+ // new one is found to be full-screen or not.
+ if (prev.finishing) {
+ prev.setVisibility(false);
+ if (DEBUG_SWITCH) Slog.v(TAG_SWITCH,
+ "Not waiting for visible to hide: " + prev + ", waitingVisible="
+ + mStackSupervisor.mActivitiesWaitingForVisibleActivity.contains(prev)
+ + ", nowVisible=" + next.nowVisible);
+ } else {
+ if (DEBUG_SWITCH) Slog.v(TAG_SWITCH,
+ "Previous already visible but still waiting to hide: " + prev
+ + ", waitingVisible="
+ + mStackSupervisor.mActivitiesWaitingForVisibleActivity.contains(prev)
+ + ", nowVisible=" + next.nowVisible);
+ }
+ }
+ }
+
+ // Launching this app's activity, make sure the app is no longer
+ // considered stopped.
+ try {
+ AppGlobals.getPackageManager().setPackageStoppedState(
+ next.packageName, false, next.userId); /* TODO: Verify if correct userid */
+ } catch (RemoteException e1) {
+ } catch (IllegalArgumentException e) {
+ Slog.w(TAG, "Failed trying to unstop package "
+ + next.packageName + ": " + e);
+ }
+
+ // We are starting up the next activity, so tell the window manager
+ // that the previous one will be hidden soon. This way it can know
+ // to ignore it when computing the desired screen orientation.
+ boolean anim = true;
+ final DisplayWindowController dwc = getDisplay().getWindowContainerController();
+ if (prev != null) {
+ if (prev.finishing) {
+ if (DEBUG_TRANSITION) Slog.v(TAG_TRANSITION,
+ "Prepare close transition: prev=" + prev);
+ if (mStackSupervisor.mNoAnimActivities.contains(prev)) {
+ anim = false;
+ dwc.prepareAppTransition(TRANSIT_NONE, false);
+ } else {
+ dwc.prepareAppTransition(
+ prev.getTask() == next.getTask() ? TRANSIT_ACTIVITY_CLOSE
+ : TRANSIT_TASK_CLOSE, false);
+ }
+ prev.setVisibility(false);
+ } else {
+ if (DEBUG_TRANSITION) Slog.v(TAG_TRANSITION,
+ "Prepare open transition: prev=" + prev);
+ if (mStackSupervisor.mNoAnimActivities.contains(next)) {
+ anim = false;
+ dwc.prepareAppTransition(TRANSIT_NONE, false);
+ } else {
+ dwc.prepareAppTransition(
+ prev.getTask() == next.getTask() ? TRANSIT_ACTIVITY_OPEN
+ : next.mLaunchTaskBehind ? TRANSIT_TASK_OPEN_BEHIND
+ : TRANSIT_TASK_OPEN, false);
+ }
+ }
+ } else {
+ if (DEBUG_TRANSITION) Slog.v(TAG_TRANSITION, "Prepare open transition: no previous");
+ if (mStackSupervisor.mNoAnimActivities.contains(next)) {
+ anim = false;
+ dwc.prepareAppTransition(TRANSIT_NONE, false);
+ } else {
+ dwc.prepareAppTransition(TRANSIT_ACTIVITY_OPEN, false);
+ }
+ }
+
+ if (anim) {
+ next.applyOptionsLocked();
+ } else {
+ next.clearOptionsLocked();
+ }
+
+ mStackSupervisor.mNoAnimActivities.clear();
+
+ if (next.attachedToProcess()) {
+ if (DEBUG_SWITCH) Slog.v(TAG_SWITCH, "Resume running: " + next
+ + " stopped=" + next.stopped + " visible=" + next.visible);
+
+ // If the previous activity is translucent, force a visibility update of
+ // the next activity, so that it's added to WM's opening app list, and
+ // transition animation can be set up properly.
+ // For example, pressing Home button with a translucent activity in focus.
+ // Launcher is already visible in this case. If we don't add it to opening
+ // apps, maybeUpdateTransitToWallpaper() will fail to identify this as a
+ // TRANSIT_WALLPAPER_OPEN animation, and run some funny animation.
+ final boolean lastActivityTranslucent = lastFocusedStack != null
+ && (lastFocusedStack.inMultiWindowMode()
+ || (lastFocusedStack.mLastPausedActivity != null
+ && !lastFocusedStack.mLastPausedActivity.fullscreen));
+
+ // The contained logic must be synchronized, since we are both changing the visibility
+ // and updating the {@link Configuration}. {@link ActivityRecord#setVisibility} will
+ // ultimately cause the client code to schedule a layout. Since layouts retrieve the
+ // current {@link Configuration}, we must ensure that the below code updates it before
+ // the layout can occur.
+ synchronized(mWindowManager.getWindowManagerLock()) {
+ // This activity is now becoming visible.
+ if (!next.visible || next.stopped || lastActivityTranslucent) {
+ next.setVisibility(true);
+ }
+
+ // schedule launch ticks to collect information about slow apps.
+ next.startLaunchTickingLocked();
+
+ ActivityRecord lastResumedActivity =
+ lastFocusedStack == null ? null : lastFocusedStack.mResumedActivity;
+ final ActivityState lastState = next.getState();
+
+ mService.updateCpuStats();
+
+ if (DEBUG_STATES) Slog.v(TAG_STATES, "Moving to RESUMED: " + next
+ + " (in existing)");
+
+ next.setState(RESUMED, "resumeTopActivityInnerLocked");
+
+ next.app.updateProcessInfo(false /* updateServiceConnectionActivities */,
+ true /* updateLru */, true /* activityChange */, true /* updateOomAdj */);
+ updateLRUListLocked(next);
+
+ // Have the window manager re-evaluate the orientation of
+ // the screen based on the new activity order.
+ boolean notUpdated = true;
+
+ if (isFocusedStackOnDisplay()) {
+ // We have special rotation behavior when here is some active activity that
+ // requests specific orientation or Keyguard is locked. Make sure all activity
+ // visibilities are set correctly as well as the transition is updated if needed
+ // to get the correct rotation behavior. Otherwise the following call to update
+ // the orientation may cause incorrect configurations delivered to client as a
+ // result of invisible window resize.
+ // TODO: Remove this once visibilities are set correctly immediately when
+ // starting an activity.
+ notUpdated = !mStackSupervisor.ensureVisibilityAndConfig(next, mDisplayId,
+ true /* markFrozenIfConfigChanged */, false /* deferResume */);
+ }
+
+ if (notUpdated) {
+ // The configuration update wasn't able to keep the existing
+ // instance of the activity, and instead started a new one.
+ // We should be all done, but let's just make sure our activity
+ // is still at the top and schedule another run if something
+ // weird happened.
+ ActivityRecord nextNext = topRunningActivityLocked();
+ if (DEBUG_SWITCH || DEBUG_STATES) Slog.i(TAG_STATES,
+ "Activity config changed during resume: " + next
+ + ", new next: " + nextNext);
+ if (nextNext != next) {
+ // Do over!
+ mStackSupervisor.scheduleResumeTopActivities();
+ }
+ if (!next.visible || next.stopped) {
+ next.setVisibility(true);
+ }
+ next.completeResumeLocked();
+ if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
+ return true;
+ }
+
+ try {
+ final ClientTransaction transaction =
+ ClientTransaction.obtain(next.app.getThread(), next.appToken);
+ // Deliver all pending results.
+ ArrayList<ResultInfo> a = next.results;
+ if (a != null) {
+ final int N = a.size();
+ if (!next.finishing && N > 0) {
+ if (DEBUG_RESULTS) Slog.v(TAG_RESULTS,
+ "Delivering results to " + next + ": " + a);
+ transaction.addCallback(ActivityResultItem.obtain(a));
+ }
+ }
+
+ if (next.newIntents != null) {
+ transaction.addCallback(NewIntentItem.obtain(next.newIntents,
+ false /* andPause */));
+ }
+
+ // Well the app will no longer be stopped.
+ // Clear app token stopped state in window manager if needed.
+ next.notifyAppResumed(next.stopped);
+
+ EventLog.writeEvent(EventLogTags.AM_RESUME_ACTIVITY, next.userId,
+ System.identityHashCode(next), next.getTask().taskId,
+ next.shortComponentName);
+
+ next.sleeping = false;
+ mService.getAppWarningsLocked().onResumeActivity(next);
+ next.app.setPendingUiCleanAndForceProcessStateUpTo(mService.mTopProcessState);
+ next.clearOptionsLocked();
+ transaction.setLifecycleStateRequest(
+ ResumeActivityItem.obtain(next.app.getReportedProcState(),
+ getDisplay().getWindowContainerController()
+ .isNextTransitionForward()));
+ mService.getLifecycleManager().scheduleTransaction(transaction);
+
+ if (DEBUG_STATES) Slog.d(TAG_STATES, "resumeTopActivityLocked: Resumed "
+ + next);
+ } catch (Exception e) {
+ // Whoops, need to restart this activity!
+ if (DEBUG_STATES) Slog.v(TAG_STATES, "Resume failed; resetting state to "
+ + lastState + ": " + next);
+ next.setState(lastState, "resumeTopActivityInnerLocked");
+
+ // lastResumedActivity being non-null implies there is a lastStack present.
+ if (lastResumedActivity != null) {
+ lastResumedActivity.setState(RESUMED, "resumeTopActivityInnerLocked");
+ }
+
+ Slog.i(TAG, "Restarting because process died: " + next);
+ if (!next.hasBeenLaunched) {
+ next.hasBeenLaunched = true;
+ } else if (SHOW_APP_STARTING_PREVIEW && lastFocusedStack != null
+ && lastFocusedStack.isTopStackOnDisplay()) {
+ next.showStartingWindow(null /* prev */, false /* newTask */,
+ false /* taskSwitch */);
+ }
+ mStackSupervisor.startSpecificActivityLocked(next, true, false);
+ if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
+ return true;
+ }
+ }
+
+ // From this point on, if something goes wrong there is no way
+ // to recover the activity.
+ try {
+ next.completeResumeLocked();
+ } catch (Exception e) {
+ // If any exception gets thrown, toss away this
+ // activity and try the next one.
+ Slog.w(TAG, "Exception thrown during resume of " + next, e);
+ requestFinishActivityLocked(next.appToken, Activity.RESULT_CANCELED, null,
+ "resume-exception", true);
+ if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
+ return true;
+ }
+ } else {
+ // Whoops, need to restart this activity!
+ if (!next.hasBeenLaunched) {
+ next.hasBeenLaunched = true;
+ } else {
+ if (SHOW_APP_STARTING_PREVIEW) {
+ next.showStartingWindow(null /* prev */, false /* newTask */,
+ false /* taskSwich */);
+ }
+ if (DEBUG_SWITCH) Slog.v(TAG_SWITCH, "Restarting: " + next);
+ }
+ if (DEBUG_STATES) Slog.d(TAG_STATES, "resumeTopActivityLocked: Restarting " + next);
+ mStackSupervisor.startSpecificActivityLocked(next, true, true);
+ }
+
+ if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
+ return true;
+ }
+
+ private boolean resumeTopActivityInNextFocusableStack(ActivityRecord prev,
+ ActivityOptions options, String reason) {
+ final ActivityStack nextFocusedStack = adjustFocusToNextFocusableStack(reason);
+ if (nextFocusedStack != null) {
+ // Try to move focus to the next visible stack with a running activity if this
+ // stack is not covering the entire screen or is on a secondary display (with no home
+ // stack).
+ return mStackSupervisor.resumeFocusedStacksTopActivitiesLocked(nextFocusedStack, prev,
+ null /* targetOptions */);
+ }
+
+ // Let's just start up the Launcher...
+ ActivityOptions.abort(options);
+ if (DEBUG_STATES) Slog.d(TAG_STATES,
+ "resumeTopActivityInNextFocusableStack: " + reason + ", go home");
+ if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
+ return mStackSupervisor.resumeHomeActivity(prev, reason, mDisplayId);
+ }
+
+ /** Returns the position the input task should be placed in this stack. */
+ int getAdjustedPositionForTask(TaskRecord task, int suggestedPosition,
+ ActivityRecord starting) {
+
+ int maxPosition = mTaskHistory.size();
+ if ((starting != null && starting.okToShowLocked())
+ || (starting == null && task.okToShowLocked())) {
+ // If the task or starting activity can be shown, then whatever position is okay.
+ return Math.min(suggestedPosition, maxPosition);
+ }
+
+ // The task can't be shown, put non-current user tasks below current user tasks.
+ while (maxPosition > 0) {
+ final TaskRecord tmpTask = mTaskHistory.get(maxPosition - 1);
+ if (!mStackSupervisor.isCurrentProfileLocked(tmpTask.userId)
+ || tmpTask.topRunningActivityLocked() == null) {
+ break;
+ }
+ maxPosition--;
+ }
+
+ return Math.min(suggestedPosition, maxPosition);
+ }
+
+ /**
+ * Used from {@link ActivityStack#positionTask(TaskRecord, int)}.
+ * @see ActivityTaskManagerService#positionTaskInStack(int, int, int).
+ */
+ private void insertTaskAtPosition(TaskRecord task, int position) {
+ if (position >= mTaskHistory.size()) {
+ insertTaskAtTop(task, null);
+ return;
+ } else if (position <= 0) {
+ insertTaskAtBottom(task);
+ return;
+ }
+ position = getAdjustedPositionForTask(task, position, null /* starting */);
+ mTaskHistory.remove(task);
+ mTaskHistory.add(position, task);
+ mWindowContainerController.positionChildAt(task.getWindowContainerController(), position);
+ updateTaskMovement(task, true);
+ }
+
+ private void insertTaskAtTop(TaskRecord task, ActivityRecord starting) {
+ // TODO: Better place to put all the code below...may be addTask...
+ mTaskHistory.remove(task);
+ // Now put task at top.
+ final int position = getAdjustedPositionForTask(task, mTaskHistory.size(), starting);
+ mTaskHistory.add(position, task);
+ updateTaskMovement(task, true);
+ positionChildWindowContainerAtTop(task);
+ }
+
+ private void insertTaskAtBottom(TaskRecord task) {
+ mTaskHistory.remove(task);
+ final int position = getAdjustedPositionForTask(task, 0, null);
+ mTaskHistory.add(position, task);
+ updateTaskMovement(task, true);
+ positionChildWindowContainerAtBottom(task);
+ }
+
+ void startActivityLocked(ActivityRecord r, ActivityRecord focusedTopActivity,
+ boolean newTask, boolean keepCurTransition, ActivityOptions options) {
+ TaskRecord rTask = r.getTask();
+ final int taskId = rTask.taskId;
+ // mLaunchTaskBehind tasks get placed at the back of the task stack.
+ if (!r.mLaunchTaskBehind && (taskForIdLocked(taskId) == null || newTask)) {
+ // Last activity in task had been removed or ActivityManagerService is reusing task.
+ // Insert or replace.
+ // Might not even be in.
+ insertTaskAtTop(rTask, r);
+ }
+ TaskRecord task = null;
+ if (!newTask) {
+ // If starting in an existing task, find where that is...
+ boolean startIt = true;
+ for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
+ task = mTaskHistory.get(taskNdx);
+ if (task.getTopActivity() == null) {
+ // All activities in task are finishing.
+ continue;
+ }
+ if (task == rTask) {
+ // Here it is! Now, if this is not yet visible to the
+ // user, then just add it without starting; it will
+ // get started when the user navigates back to it.
+ if (!startIt) {
+ if (DEBUG_ADD_REMOVE) Slog.i(TAG, "Adding activity " + r + " to task "
+ + task, new RuntimeException("here").fillInStackTrace());
+ r.createWindowContainer();
+ ActivityOptions.abort(options);
+ return;
+ }
+ break;
+ } else if (task.numFullscreen > 0) {
+ startIt = false;
+ }
+ }
+ }
+
+ // Place a new activity at top of stack, so it is next to interact with the user.
+
+ // If we are not placing the new activity frontmost, we do not want to deliver the
+ // onUserLeaving callback to the actual frontmost activity
+ final TaskRecord activityTask = r.getTask();
+ if (task == activityTask && mTaskHistory.indexOf(task) != (mTaskHistory.size() - 1)) {
+ mStackSupervisor.mUserLeaving = false;
+ if (DEBUG_USER_LEAVING) Slog.v(TAG_USER_LEAVING,
+ "startActivity() behind front, mUserLeaving=false");
+ }
+
+ task = activityTask;
+
+ // Slot the activity into the history stack and proceed
+ if (DEBUG_ADD_REMOVE) Slog.i(TAG, "Adding activity " + r + " to stack to task " + task,
+ new RuntimeException("here").fillInStackTrace());
+ // TODO: Need to investigate if it is okay for the controller to already be created by the
+ // time we get to this point. I think it is, but need to double check.
+ // Use test in b/34179495 to trace the call path.
+ if (r.getWindowContainerController() == null) {
+ r.createWindowContainer();
+ }
+ task.setFrontOfTask();
+
+ if (!isHomeOrRecentsStack() || numActivities() > 0) {
+ final DisplayWindowController dwc = getDisplay().getWindowContainerController();
+ if (DEBUG_TRANSITION) Slog.v(TAG_TRANSITION,
+ "Prepare open transition: starting " + r);
+ if ((r.intent.getFlags() & Intent.FLAG_ACTIVITY_NO_ANIMATION) != 0) {
+ dwc.prepareAppTransition(TRANSIT_NONE, keepCurTransition);
+ mStackSupervisor.mNoAnimActivities.add(r);
+ } else {
+ int transit = TRANSIT_ACTIVITY_OPEN;
+ if (newTask) {
+ if (r.mLaunchTaskBehind) {
+ transit = TRANSIT_TASK_OPEN_BEHIND;
+ } else {
+ // If a new task is being launched, then mark the existing top activity as
+ // supporting picture-in-picture while pausing only if the starting activity
+ // would not be considered an overlay on top of the current activity
+ // (eg. not fullscreen, or the assistant)
+ if (canEnterPipOnTaskSwitch(focusedTopActivity,
+ null /* toFrontTask */, r, options)) {
+ focusedTopActivity.supportsEnterPipOnTaskSwitch = true;
+ }
+ transit = TRANSIT_TASK_OPEN;
+ }
+ }
+ dwc.prepareAppTransition(transit, keepCurTransition);
+ mStackSupervisor.mNoAnimActivities.remove(r);
+ }
+ boolean doShow = true;
+ if (newTask) {
+ // Even though this activity is starting fresh, we still need
+ // to reset it to make sure we apply affinities to move any
+ // existing activities from other tasks in to it.
+ // If the caller has requested that the target task be
+ // reset, then do so.
+ if ((r.intent.getFlags() & Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED) != 0) {
+ resetTaskIfNeededLocked(r, r);
+ doShow = topRunningNonDelayedActivityLocked(null) == r;
+ }
+ } else if (options != null && options.getAnimationType()
+ == ActivityOptions.ANIM_SCENE_TRANSITION) {
+ doShow = false;
+ }
+ if (r.mLaunchTaskBehind) {
+ // Don't do a starting window for mLaunchTaskBehind. More importantly make sure we
+ // tell WindowManager that r is visible even though it is at the back of the stack.
+ r.setVisibility(true);
+ ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
+ } else if (SHOW_APP_STARTING_PREVIEW && doShow) {
+ // Figure out if we are transitioning from another activity that is
+ // "has the same starting icon" as the next one. This allows the
+ // window manager to keep the previous window it had previously
+ // created, if it still had one.
+ TaskRecord prevTask = r.getTask();
+ ActivityRecord prev = prevTask.topRunningActivityWithStartingWindowLocked();
+ if (prev != null) {
+ // We don't want to reuse the previous starting preview if:
+ // (1) The current activity is in a different task.
+ if (prev.getTask() != prevTask) {
+ prev = null;
+ }
+ // (2) The current activity is already displayed.
+ else if (prev.nowVisible) {
+ prev = null;
+ }
+ }
+ r.showStartingWindow(prev, newTask, isTaskSwitch(r, focusedTopActivity));
+ }
+ } else {
+ // If this is the first activity, don't do any fancy animations,
+ // because there is nothing for it to animate on top of.
+ ActivityOptions.abort(options);
+ }
+ }
+
+ /**
+ * @return Whether the switch to another task can trigger the currently running activity to
+ * enter PiP while it is pausing (if supported). Only one of {@param toFrontTask} or
+ * {@param toFrontActivity} should be set.
+ */
+ private boolean canEnterPipOnTaskSwitch(ActivityRecord pipCandidate,
+ TaskRecord toFrontTask, ActivityRecord toFrontActivity, ActivityOptions opts) {
+ if (opts != null && opts.disallowEnterPictureInPictureWhileLaunching()) {
+ // Ensure the caller has requested not to trigger auto-enter PiP
+ return false;
+ }
+ if (pipCandidate == null || pipCandidate.inPinnedWindowingMode()) {
+ // Ensure that we do not trigger entering PiP an activity on the pinned stack
+ return false;
+ }
+ final ActivityStack targetStack = toFrontTask != null
+ ? toFrontTask.getStack() : toFrontActivity.getStack();
+ if (targetStack != null && targetStack.isActivityTypeAssistant()) {
+ // Ensure the task/activity being brought forward is not the assistant
+ return false;
+ }
+ return true;
+ }
+
+ private boolean isTaskSwitch(ActivityRecord r,
+ ActivityRecord topFocusedActivity) {
+ return topFocusedActivity != null && r.getTask() != topFocusedActivity.getTask();
+ }
+
+ /**
+ * Perform a reset of the given task, if needed as part of launching it.
+ * Returns the new HistoryRecord at the top of the task.
+ */
+ /**
+ * Helper method for #resetTaskIfNeededLocked.
+ * We are inside of the task being reset... we'll either finish this activity, push it out
+ * for another task, or leave it as-is.
+ * @param task The task containing the Activity (taskTop) that might be reset.
+ * @param forceReset
+ * @return An ActivityOptions that needs to be processed.
+ */
+ private ActivityOptions resetTargetTaskIfNeededLocked(TaskRecord task, boolean forceReset) {
+ ActivityOptions topOptions = null;
+
+ int replyChainEnd = -1;
+ boolean canMoveOptions = true;
+
+ // We only do this for activities that are not the root of the task (since if we finish
+ // the root, we may no longer have the task!).
+ final ArrayList<ActivityRecord> activities = task.mActivities;
+ final int numActivities = activities.size();
+ final int rootActivityNdx = task.findEffectiveRootIndex();
+ for (int i = numActivities - 1; i > rootActivityNdx; --i ) {
+ ActivityRecord target = activities.get(i);
+ if (target.frontOfTask)
+ break;
+
+ final int flags = target.info.flags;
+ final boolean finishOnTaskLaunch =
+ (flags & ActivityInfo.FLAG_FINISH_ON_TASK_LAUNCH) != 0;
+ final boolean allowTaskReparenting =
+ (flags & ActivityInfo.FLAG_ALLOW_TASK_REPARENTING) != 0;
+ final boolean clearWhenTaskReset =
+ (target.intent.getFlags() & Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET) != 0;
+
+ if (!finishOnTaskLaunch
+ && !clearWhenTaskReset
+ && target.resultTo != null) {
+ // If this activity is sending a reply to a previous
+ // activity, we can't do anything with it now until
+ // we reach the start of the reply chain.
+ // XXX note that we are assuming the result is always
+ // to the previous activity, which is almost always
+ // the case but we really shouldn't count on.
+ if (replyChainEnd < 0) {
+ replyChainEnd = i;
+ }
+ } else if (!finishOnTaskLaunch
+ && !clearWhenTaskReset
+ && allowTaskReparenting
+ && target.taskAffinity != null
+ && !target.taskAffinity.equals(task.affinity)) {
+ // If this activity has an affinity for another
+ // task, then we need to move it out of here. We will
+ // move it as far out of the way as possible, to the
+ // bottom of the activity stack. This also keeps it
+ // correctly ordered with any activities we previously
+ // moved.
+ final TaskRecord targetTask;
+ final ActivityRecord bottom =
+ !mTaskHistory.isEmpty() && !mTaskHistory.get(0).mActivities.isEmpty() ?
+ mTaskHistory.get(0).mActivities.get(0) : null;
+ if (bottom != null && target.taskAffinity != null
+ && target.taskAffinity.equals(bottom.getTask().affinity)) {
+ // If the activity currently at the bottom has the
+ // same task affinity as the one we are moving,
+ // then merge it into the same task.
+ targetTask = bottom.getTask();
+ if (DEBUG_TASKS) Slog.v(TAG_TASKS, "Start pushing activity " + target
+ + " out to bottom task " + targetTask);
+ } else {
+ targetTask = createTaskRecord(
+ mStackSupervisor.getNextTaskIdForUserLocked(target.userId),
+ target.info, null, null, null, false);
+ targetTask.affinityIntent = target.intent;
+ if (DEBUG_TASKS) Slog.v(TAG_TASKS, "Start pushing activity " + target
+ + " out to new task " + targetTask);
+ }
+
+ boolean noOptions = canMoveOptions;
+ final int start = replyChainEnd < 0 ? i : replyChainEnd;
+ for (int srcPos = start; srcPos >= i; --srcPos) {
+ final ActivityRecord p = activities.get(srcPos);
+ if (p.finishing) {
+ continue;
+ }
+
+ canMoveOptions = false;
+ if (noOptions && topOptions == null) {
+ topOptions = p.takeOptionsLocked();
+ if (topOptions != null) {
+ noOptions = false;
+ }
+ }
+ if (DEBUG_ADD_REMOVE) Slog.i(TAG_ADD_REMOVE,
+ "Removing activity " + p + " from task=" + task + " adding to task="
+ + targetTask + " Callers=" + Debug.getCallers(4));
+ if (DEBUG_TASKS) Slog.v(TAG_TASKS,
+ "Pushing next activity " + p + " out to target's task " + target);
+ p.reparent(targetTask, 0 /* position - bottom */, "resetTargetTaskIfNeeded");
+ }
+
+ positionChildWindowContainerAtBottom(targetTask);
+ replyChainEnd = -1;
+ } else if (forceReset || finishOnTaskLaunch || clearWhenTaskReset) {
+ // If the activity should just be removed -- either
+ // because it asks for it, or the task should be
+ // cleared -- then finish it and anything that is
+ // part of its reply chain.
+ int end;
+ if (clearWhenTaskReset) {
+ // In this case, we want to finish this activity
+ // and everything above it, so be sneaky and pretend
+ // like these are all in the reply chain.
+ end = activities.size() - 1;
+ } else if (replyChainEnd < 0) {
+ end = i;
+ } else {
+ end = replyChainEnd;
+ }
+ boolean noOptions = canMoveOptions;
+ for (int srcPos = i; srcPos <= end; srcPos++) {
+ ActivityRecord p = activities.get(srcPos);
+ if (p.finishing) {
+ continue;
+ }
+ canMoveOptions = false;
+ if (noOptions && topOptions == null) {
+ topOptions = p.takeOptionsLocked();
+ if (topOptions != null) {
+ noOptions = false;
+ }
+ }
+ if (DEBUG_TASKS) Slog.w(TAG_TASKS,
+ "resetTaskIntendedTask: calling finishActivity on " + p);
+ if (finishActivityLocked(
+ p, Activity.RESULT_CANCELED, null, "reset-task", false)) {
+ end--;
+ srcPos--;
+ }
+ }
+ replyChainEnd = -1;
+ } else {
+ // If we were in the middle of a chain, well the
+ // activity that started it all doesn't want anything
+ // special, so leave it all as-is.
+ replyChainEnd = -1;
+ }
+ }
+
+ return topOptions;
+ }
+
+ /**
+ * Helper method for #resetTaskIfNeededLocked. Processes all of the activities in a given
+ * TaskRecord looking for an affinity with the task of resetTaskIfNeededLocked.taskTop.
+ * @param affinityTask The task we are looking for an affinity to.
+ * @param task Task that resetTaskIfNeededLocked.taskTop belongs to.
+ * @param topTaskIsHigher True if #task has already been processed by resetTaskIfNeededLocked.
+ * @param forceReset Flag passed in to resetTaskIfNeededLocked.
+ */
+ private int resetAffinityTaskIfNeededLocked(TaskRecord affinityTask, TaskRecord task,
+ boolean topTaskIsHigher, boolean forceReset, int taskInsertionPoint) {
+ int replyChainEnd = -1;
+ final int taskId = task.taskId;
+ final String taskAffinity = task.affinity;
+
+ final ArrayList<ActivityRecord> activities = affinityTask.mActivities;
+ final int numActivities = activities.size();
+ final int rootActivityNdx = affinityTask.findEffectiveRootIndex();
+
+ // Do not operate on or below the effective root Activity.
+ for (int i = numActivities - 1; i > rootActivityNdx; --i) {
+ ActivityRecord target = activities.get(i);
+ if (target.frontOfTask)
+ break;
+
+ final int flags = target.info.flags;
+ boolean finishOnTaskLaunch = (flags & ActivityInfo.FLAG_FINISH_ON_TASK_LAUNCH) != 0;
+ boolean allowTaskReparenting = (flags & ActivityInfo.FLAG_ALLOW_TASK_REPARENTING) != 0;
+
+ if (target.resultTo != null) {
+ // If this activity is sending a reply to a previous
+ // activity, we can't do anything with it now until
+ // we reach the start of the reply chain.
+ // XXX note that we are assuming the result is always
+ // to the previous activity, which is almost always
+ // the case but we really shouldn't count on.
+ if (replyChainEnd < 0) {
+ replyChainEnd = i;
+ }
+ } else if (topTaskIsHigher
+ && allowTaskReparenting
+ && taskAffinity != null
+ && taskAffinity.equals(target.taskAffinity)) {
+ // This activity has an affinity for our task. Either remove it if we are
+ // clearing or move it over to our task. Note that
+ // we currently punt on the case where we are resetting a
+ // task that is not at the top but who has activities above
+ // with an affinity to it... this is really not a normal
+ // case, and we will need to later pull that task to the front
+ // and usually at that point we will do the reset and pick
+ // up those remaining activities. (This only happens if
+ // someone starts an activity in a new task from an activity
+ // in a task that is not currently on top.)
+ if (forceReset || finishOnTaskLaunch) {
+ final int start = replyChainEnd >= 0 ? replyChainEnd : i;
+ if (DEBUG_TASKS) Slog.v(TAG_TASKS,
+ "Finishing task at index " + start + " to " + i);
+ for (int srcPos = start; srcPos >= i; --srcPos) {
+ final ActivityRecord p = activities.get(srcPos);
+ if (p.finishing) {
+ continue;
+ }
+ finishActivityLocked(
+ p, Activity.RESULT_CANCELED, null, "move-affinity", false);
+ }
+ } else {
+ if (taskInsertionPoint < 0) {
+ taskInsertionPoint = task.mActivities.size();
+
+ }
+
+ final int start = replyChainEnd >= 0 ? replyChainEnd : i;
+ if (DEBUG_TASKS) Slog.v(TAG_TASKS,
+ "Reparenting from task=" + affinityTask + ":" + start + "-" + i
+ + " to task=" + task + ":" + taskInsertionPoint);
+ for (int srcPos = start; srcPos >= i; --srcPos) {
+ final ActivityRecord p = activities.get(srcPos);
+ p.reparent(task, taskInsertionPoint, "resetAffinityTaskIfNeededLocked");
+
+ if (DEBUG_ADD_REMOVE) Slog.i(TAG_ADD_REMOVE,
+ "Removing and adding activity " + p + " to stack at " + task
+ + " callers=" + Debug.getCallers(3));
+ if (DEBUG_TASKS) Slog.v(TAG_TASKS, "Pulling activity " + p
+ + " from " + srcPos + " in to resetting task " + task);
+ }
+ positionChildWindowContainerAtTop(task);
+
+ // Now we've moved it in to place... but what if this is
+ // a singleTop activity and we have put it on top of another
+ // instance of the same activity? Then we drop the instance
+ // below so it remains singleTop.
+ if (target.info.launchMode == ActivityInfo.LAUNCH_SINGLE_TOP) {
+ ArrayList<ActivityRecord> taskActivities = task.mActivities;
+ int targetNdx = taskActivities.indexOf(target);
+ if (targetNdx > 0) {
+ ActivityRecord p = taskActivities.get(targetNdx - 1);
+ if (p.intent.getComponent().equals(target.intent.getComponent())) {
+ finishActivityLocked(p, Activity.RESULT_CANCELED, null, "replace",
+ false);
+ }
+ }
+ }
+ }
+
+ replyChainEnd = -1;
+ }
+ }
+ return taskInsertionPoint;
+ }
+
+ final ActivityRecord resetTaskIfNeededLocked(ActivityRecord taskTop,
+ ActivityRecord newActivity) {
+ final boolean forceReset =
+ (newActivity.info.flags & ActivityInfo.FLAG_CLEAR_TASK_ON_LAUNCH) != 0;
+ final TaskRecord task = taskTop.getTask();
+
+ /** False until we evaluate the TaskRecord associated with taskTop. Switches to true
+ * for remaining tasks. Used for later tasks to reparent to task. */
+ boolean taskFound = false;
+
+ /** If ActivityOptions are moved out and need to be aborted or moved to taskTop. */
+ ActivityOptions topOptions = null;
+
+ // Preserve the location for reparenting in the new task.
+ int reparentInsertionPoint = -1;
+
+ for (int i = mTaskHistory.size() - 1; i >= 0; --i) {
+ final TaskRecord targetTask = mTaskHistory.get(i);
+
+ if (targetTask == task) {
+ topOptions = resetTargetTaskIfNeededLocked(task, forceReset);
+ taskFound = true;
+ } else {
+ reparentInsertionPoint = resetAffinityTaskIfNeededLocked(targetTask, task,
+ taskFound, forceReset, reparentInsertionPoint);
+ }
+ }
+
+ int taskNdx = mTaskHistory.indexOf(task);
+ if (taskNdx >= 0) {
+ do {
+ taskTop = mTaskHistory.get(taskNdx--).getTopActivity();
+ } while (taskTop == null && taskNdx >= 0);
+ }
+
+ if (topOptions != null) {
+ // If we got some ActivityOptions from an activity on top that
+ // was removed from the task, propagate them to the new real top.
+ if (taskTop != null) {
+ taskTop.updateOptionsLocked(topOptions);
+ } else {
+ topOptions.abort();
+ }
+ }
+
+ return taskTop;
+ }
+
+ void sendActivityResultLocked(int callingUid, ActivityRecord r,
+ String resultWho, int requestCode, int resultCode, Intent data) {
+
+ if (callingUid > 0) {
+ mService.mUgmInternal.grantUriPermissionFromIntent(callingUid, r.packageName,
+ data, r.getUriPermissionsLocked(), r.userId);
+ }
+
+ if (DEBUG_RESULTS) Slog.v(TAG, "Send activity result to " + r
+ + " : who=" + resultWho + " req=" + requestCode
+ + " res=" + resultCode + " data=" + data);
+ if (mResumedActivity == r && r.attachedToProcess()) {
+ try {
+ ArrayList<ResultInfo> list = new ArrayList<ResultInfo>();
+ list.add(new ResultInfo(resultWho, requestCode,
+ resultCode, data));
+ mService.getLifecycleManager().scheduleTransaction(r.app.getThread(), r.appToken,
+ ActivityResultItem.obtain(list));
+ return;
+ } catch (Exception e) {
+ Slog.w(TAG, "Exception thrown sending result to " + r, e);
+ }
+ }
+
+ r.addResultLocked(null, resultWho, requestCode, resultCode, data);
+ }
+
+ /** Returns true if the task is one of the task finishing on-top of the top running task. */
+ private boolean isATopFinishingTask(TaskRecord task) {
+ for (int i = mTaskHistory.size() - 1; i >= 0; --i) {
+ final TaskRecord current = mTaskHistory.get(i);
+ final ActivityRecord r = current.topRunningActivityLocked();
+ if (r != null) {
+ // We got a top running activity, so there isn't a top finishing task...
+ return false;
+ }
+ if (current == task) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private void adjustFocusedActivityStack(ActivityRecord r, String reason) {
+ if (!mStackSupervisor.isTopDisplayFocusedStack(this) ||
+ ((mResumedActivity != r) && (mResumedActivity != null))) {
+ return;
+ }
+
+ final ActivityRecord next = topRunningActivityLocked();
+ final String myReason = reason + " adjustFocus";
+
+ if (next == r) {
+ final ActivityRecord top = mStackSupervisor.topRunningActivityLocked();
+ if (top != null) {
+ top.moveFocusableActivityToTop(myReason);
+ }
+ return;
+ }
+
+ if (next != null && isFocusable()) {
+ // Keep focus in stack if we have a top running activity and are focusable.
+ return;
+ }
+
+ // Task is not guaranteed to be non-null. For example, destroying the
+ // {@link ActivityRecord} will disassociate the task from the activity.
+ final TaskRecord task = r.getTask();
+
+ if (task == null) {
+ throw new IllegalStateException("activity no longer associated with task:" + r);
+ }
+
+ // Move focus to next focusable stack if possible.
+ final ActivityStack nextFocusableStack = adjustFocusToNextFocusableStack(myReason);
+ if (nextFocusableStack != null) {
+ final ActivityRecord top = nextFocusableStack.topRunningActivityLocked();
+ if (top != null && top == mStackSupervisor.getTopResumedActivity()) {
+ // TODO(b/111361570): Remove this and update focused app per-display in
+ // WindowManager every time an activity becomes resumed in
+ // ActivityTaskManagerService#setResumedActivityUncheckLocked().
+ mService.setResumedActivityUncheckLocked(top, reason);
+ }
+ return;
+ }
+
+ // Whatever...go home.
+ getDisplay().moveHomeActivityToTop(myReason);
+ }
+
+ /**
+ * Find next proper focusable stack and make it focused.
+ * @return The stack that now got the focus, {@code null} if none found.
+ */
+ ActivityStack adjustFocusToNextFocusableStack(String reason) {
+ return adjustFocusToNextFocusableStack(reason, false /* allowFocusSelf */);
+ }
+
+ /**
+ * Find next proper focusable stack and make it focused.
+ * @param allowFocusSelf Is the focus allowed to remain on the same stack.
+ * @return The stack that now got the focus, {@code null} if none found.
+ */
+ private ActivityStack adjustFocusToNextFocusableStack(String reason, boolean allowFocusSelf) {
+ final ActivityStack stack =
+ mStackSupervisor.getNextFocusableStackLocked(this, !allowFocusSelf);
+ final String myReason = reason + " adjustFocusToNextFocusableStack";
+ if (stack == null) {
+ return null;
+ }
+
+ final ActivityRecord top = stack.topRunningActivityLocked();
+
+ if (stack.isActivityTypeHome() && (top == null || !top.visible)) {
+ // If we will be focusing on the home stack next and its current top activity isn't
+ // visible, then use the move the home stack task to top to make the activity visible.
+ stack.getDisplay().moveHomeActivityToTop(reason);
+ return stack;
+ }
+
+ stack.moveToFront(myReason);
+ return stack;
+ }
+
+ final void stopActivityLocked(ActivityRecord r) {
+ if (DEBUG_SWITCH) Slog.d(TAG_SWITCH, "Stopping: " + r);
+ if ((r.intent.getFlags()&Intent.FLAG_ACTIVITY_NO_HISTORY) != 0
+ || (r.info.flags&ActivityInfo.FLAG_NO_HISTORY) != 0) {
+ if (!r.finishing) {
+ if (!shouldSleepActivities()) {
+ if (DEBUG_STATES) Slog.d(TAG_STATES, "no-history finish of " + r);
+ if (requestFinishActivityLocked(r.appToken, Activity.RESULT_CANCELED, null,
+ "stop-no-history", false)) {
+ // If {@link requestFinishActivityLocked} returns {@code true},
+ // {@link adjustFocusedActivityStack} would have been already called.
+ r.resumeKeyDispatchingLocked();
+ return;
+ }
+ } else {
+ if (DEBUG_STATES) Slog.d(TAG_STATES, "Not finishing noHistory " + r
+ + " on stop because we're just sleeping");
+ }
+ }
+ }
+
+ if (r.attachedToProcess()) {
+ adjustFocusedActivityStack(r, "stopActivity");
+ r.resumeKeyDispatchingLocked();
+ try {
+ r.stopped = false;
+ if (DEBUG_STATES) Slog.v(TAG_STATES,
+ "Moving to STOPPING: " + r + " (stop requested)");
+ r.setState(STOPPING, "stopActivityLocked");
+ if (DEBUG_VISIBILITY) Slog.v(TAG_VISIBILITY,
+ "Stopping visible=" + r.visible + " for " + r);
+ if (!r.visible) {
+ r.setVisible(false);
+ }
+ EventLogTags.writeAmStopActivity(
+ r.userId, System.identityHashCode(r), r.shortComponentName);
+ mService.getLifecycleManager().scheduleTransaction(r.app.getThread(), r.appToken,
+ StopActivityItem.obtain(r.visible, r.configChangeFlags));
+ if (shouldSleepOrShutDownActivities()) {
+ r.setSleeping(true);
+ }
+ Message msg = mHandler.obtainMessage(STOP_TIMEOUT_MSG, r);
+ mHandler.sendMessageDelayed(msg, STOP_TIMEOUT);
+ } catch (Exception e) {
+ // Maybe just ignore exceptions here... if the process
+ // has crashed, our death notification will clean things
+ // up.
+ Slog.w(TAG, "Exception thrown during pause", e);
+ // Just in case, assume it to be stopped.
+ r.stopped = true;
+ if (DEBUG_STATES) Slog.v(TAG_STATES, "Stop failed; moving to STOPPED: " + r);
+ r.setState(STOPPED, "stopActivityLocked");
+ if (r.deferRelaunchUntilPaused) {
+ destroyActivityLocked(r, true, "stop-except");
+ }
+ }
+ }
+ }
+
+ /**
+ * @return Returns true if the activity is being finished, false if for
+ * some reason it is being left as-is.
+ */
+ final boolean requestFinishActivityLocked(IBinder token, int resultCode,
+ Intent resultData, String reason, boolean oomAdj) {
+ ActivityRecord r = isInStackLocked(token);
+ if (DEBUG_RESULTS || DEBUG_STATES) Slog.v(TAG_STATES,
+ "Finishing activity token=" + token + " r="
+ + ", result=" + resultCode + ", data=" + resultData
+ + ", reason=" + reason);
+ if (r == null) {
+ return false;
+ }
+
+ finishActivityLocked(r, resultCode, resultData, reason, oomAdj);
+ return true;
+ }
+
+ final void finishSubActivityLocked(ActivityRecord self, String resultWho, int requestCode) {
+ for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
+ ArrayList<ActivityRecord> activities = mTaskHistory.get(taskNdx).mActivities;
+ for (int activityNdx = activities.size() - 1; activityNdx >= 0; --activityNdx) {
+ ActivityRecord r = activities.get(activityNdx);
+ if (r.resultTo == self && r.requestCode == requestCode) {
+ if ((r.resultWho == null && resultWho == null) ||
+ (r.resultWho != null && r.resultWho.equals(resultWho))) {
+ finishActivityLocked(r, Activity.RESULT_CANCELED, null, "request-sub",
+ false);
+ }
+ }
+ }
+ }
+ mService.updateOomAdj();
+ }
+
+ /**
+ * Finish the topmost activity that belongs to the crashed app. We may also finish the activity
+ * that requested launch of the crashed one to prevent launch-crash loop.
+ * @param app The app that crashed.
+ * @param reason Reason to perform this action.
+ * @return The task that was finished in this stack, {@code null} if top running activity does
+ * not belong to the crashed app.
+ */
+ final TaskRecord finishTopCrashedActivityLocked(WindowProcessController app, String reason) {
+ ActivityRecord r = topRunningActivityLocked();
+ TaskRecord finishedTask = null;
+ if (r == null || r.app != app) {
+ return null;
+ }
+ Slog.w(TAG, " Force finishing activity "
+ + r.intent.getComponent().flattenToShortString());
+ finishedTask = r.getTask();
+ int taskNdx = mTaskHistory.indexOf(finishedTask);
+ final TaskRecord task = finishedTask;
+ int activityNdx = task.mActivities.indexOf(r);
+ getDisplay().getWindowContainerController().prepareAppTransition(
+ TRANSIT_CRASHING_ACTIVITY_CLOSE, false /* alwaysKeepCurrent */);
+ finishActivityLocked(r, Activity.RESULT_CANCELED, null, reason, false);
+ finishedTask = task;
+ // Also terminate any activities below it that aren't yet
+ // stopped, to avoid a situation where one will get
+ // re-start our crashing activity once it gets resumed again.
+ --activityNdx;
+ if (activityNdx < 0) {
+ do {
+ --taskNdx;
+ if (taskNdx < 0) {
+ break;
+ }
+ activityNdx = mTaskHistory.get(taskNdx).mActivities.size() - 1;
+ } while (activityNdx < 0);
+ }
+ if (activityNdx >= 0) {
+ r = mTaskHistory.get(taskNdx).mActivities.get(activityNdx);
+ if (r.isState(RESUMED, PAUSING, PAUSED)) {
+ if (!r.isActivityTypeHome() || mService.mHomeProcess != r.app) {
+ Slog.w(TAG, " Force finishing activity "
+ + r.intent.getComponent().flattenToShortString());
+ finishActivityLocked(r, Activity.RESULT_CANCELED, null, reason, false);
+ }
+ }
+ }
+ return finishedTask;
+ }
+
+ final void finishVoiceTask(IVoiceInteractionSession session) {
+ IBinder sessionBinder = session.asBinder();
+ boolean didOne = false;
+ for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
+ TaskRecord tr = mTaskHistory.get(taskNdx);
+ if (tr.voiceSession != null && tr.voiceSession.asBinder() == sessionBinder) {
+ for (int activityNdx = tr.mActivities.size() - 1; activityNdx >= 0; --activityNdx) {
+ ActivityRecord r = tr.mActivities.get(activityNdx);
+ if (!r.finishing) {
+ finishActivityLocked(r, Activity.RESULT_CANCELED, null, "finish-voice",
+ false);
+ didOne = true;
+ }
+ }
+ } else {
+ // Check if any of the activities are using voice
+ for (int activityNdx = tr.mActivities.size() - 1; activityNdx >= 0; --activityNdx) {
+ ActivityRecord r = tr.mActivities.get(activityNdx);
+ if (r.voiceSession != null && r.voiceSession.asBinder() == sessionBinder) {
+ // Inform of cancellation
+ r.clearVoiceSessionLocked();
+ try {
+ r.app.getThread().scheduleLocalVoiceInteractionStarted(
+ r.appToken, null);
+ } catch (RemoteException re) {
+ // Ok
+ }
+ mService.finishRunningVoiceLocked();
+ break;
+ }
+ }
+ }
+ }
+
+ if (didOne) {
+ mService.updateOomAdj();
+ }
+ }
+
+ final boolean finishActivityAffinityLocked(ActivityRecord r) {
+ ArrayList<ActivityRecord> activities = r.getTask().mActivities;
+ for (int index = activities.indexOf(r); index >= 0; --index) {
+ ActivityRecord cur = activities.get(index);
+ if (!Objects.equals(cur.taskAffinity, r.taskAffinity)) {
+ break;
+ }
+ finishActivityLocked(cur, Activity.RESULT_CANCELED, null, "request-affinity", true);
+ }
+ return true;
+ }
+
+ private void finishActivityResultsLocked(ActivityRecord r, int resultCode, Intent resultData) {
+ // send the result
+ ActivityRecord resultTo = r.resultTo;
+ if (resultTo != null) {
+ if (DEBUG_RESULTS) Slog.v(TAG_RESULTS, "Adding result to " + resultTo
+ + " who=" + r.resultWho + " req=" + r.requestCode
+ + " res=" + resultCode + " data=" + resultData);
+ if (resultTo.userId != r.userId) {
+ if (resultData != null) {
+ resultData.prepareToLeaveUser(r.userId);
+ }
+ }
+ if (r.info.applicationInfo.uid > 0) {
+ mService.mUgmInternal.grantUriPermissionFromIntent(r.info.applicationInfo.uid,
+ resultTo.packageName, resultData,
+ resultTo.getUriPermissionsLocked(), resultTo.userId);
+ }
+ resultTo.addResultLocked(r, r.resultWho, r.requestCode, resultCode, resultData);
+ r.resultTo = null;
+ }
+ else if (DEBUG_RESULTS) Slog.v(TAG_RESULTS, "No result destination from " + r);
+
+ // Make sure this HistoryRecord is not holding on to other resources,
+ // because clients have remote IPC references to this object so we
+ // can't assume that will go away and want to avoid circular IPC refs.
+ r.results = null;
+ r.pendingResults = null;
+ r.newIntents = null;
+ r.icicle = null;
+ }
+
+ /**
+ * See {@link #finishActivityLocked(ActivityRecord, int, Intent, String, boolean, boolean)}
+ */
+ final boolean finishActivityLocked(ActivityRecord r, int resultCode, Intent resultData,
+ String reason, boolean oomAdj) {
+ return finishActivityLocked(r, resultCode, resultData, reason, oomAdj, !PAUSE_IMMEDIATELY);
+ }
+
+ /**
+ * @return Returns true if this activity has been removed from the history
+ * list, or false if it is still in the list and will be removed later.
+ */
+ final boolean finishActivityLocked(ActivityRecord r, int resultCode, Intent resultData,
+ String reason, boolean oomAdj, boolean pauseImmediately) {
+ if (r.finishing) {
+ Slog.w(TAG, "Duplicate finish request for " + r);
+ return false;
+ }
+
+ mWindowManager.deferSurfaceLayout();
+ try {
+ r.makeFinishingLocked();
+ final TaskRecord task = r.getTask();
+ EventLog.writeEvent(EventLogTags.AM_FINISH_ACTIVITY,
+ r.userId, System.identityHashCode(r),
+ task.taskId, r.shortComponentName, reason);
+ final ArrayList<ActivityRecord> activities = task.mActivities;
+ final int index = activities.indexOf(r);
+ if (index < (activities.size() - 1)) {
+ task.setFrontOfTask();
+ if ((r.intent.getFlags() & Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET) != 0) {
+ // If the caller asked that this activity (and all above it)
+ // be cleared when the task is reset, don't lose that information,
+ // but propagate it up to the next activity.
+ ActivityRecord next = activities.get(index+1);
+ next.intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET);
+ }
+ }
+
+ r.pauseKeyDispatchingLocked();
+
+ adjustFocusedActivityStack(r, "finishActivity");
+
+ finishActivityResultsLocked(r, resultCode, resultData);
+
+ final boolean endTask = index <= 0 && !task.isClearingToReuseTask();
+ final int transit = endTask ? TRANSIT_TASK_CLOSE : TRANSIT_ACTIVITY_CLOSE;
+ if (mResumedActivity == r) {
+ if (DEBUG_VISIBILITY || DEBUG_TRANSITION) Slog.v(TAG_TRANSITION,
+ "Prepare close transition: finishing " + r);
+ if (endTask) {
+ mService.getTaskChangeNotificationController().notifyTaskRemovalStarted(
+ task.taskId);
+ }
+ getDisplay().getWindowContainerController().prepareAppTransition(transit, false);
+
+ // Tell window manager to prepare for this one to be removed.
+ r.setVisibility(false);
+
+ if (mPausingActivity == null) {
+ if (DEBUG_PAUSE) Slog.v(TAG_PAUSE, "Finish needs to pause: " + r);
+ if (DEBUG_USER_LEAVING) Slog.v(TAG_USER_LEAVING,
+ "finish() => pause with userLeaving=false");
+ startPausingLocked(false, false, null, pauseImmediately);
+ }
+
+ if (endTask) {
+ mService.getLockTaskController().clearLockedTask(task);
+ }
+ } else if (!r.isState(PAUSING)) {
+ // If the activity is PAUSING, we will complete the finish once
+ // it is done pausing; else we can just directly finish it here.
+ if (DEBUG_PAUSE) Slog.v(TAG_PAUSE, "Finish not pausing: " + r);
+ if (r.visible) {
+ prepareActivityHideTransitionAnimation(r, transit);
+ }
+
+ final int finishMode = (r.visible || r.nowVisible) ? FINISH_AFTER_VISIBLE
+ : FINISH_AFTER_PAUSE;
+ final boolean removedActivity = finishCurrentActivityLocked(r, finishMode, oomAdj,
+ "finishActivityLocked") == null;
+
+ // The following code is an optimization. When the last non-task overlay activity
+ // is removed from the task, we remove the entire task from the stack. However,
+ // since that is done after the scheduled destroy callback from the activity, that
+ // call to change the visibility of the task overlay activities would be out of
+ // sync with the activitiy visibility being set for this finishing activity above.
+ // In this case, we can set the visibility of all the task overlay activities when
+ // we detect the last one is finishing to keep them in sync.
+ if (task.onlyHasTaskOverlayActivities(true /* excludeFinishing */)) {
+ for (ActivityRecord taskOverlay : task.mActivities) {
+ if (!taskOverlay.mTaskOverlay) {
+ continue;
+ }
+ prepareActivityHideTransitionAnimation(taskOverlay, transit);
+ }
+ }
+ return removedActivity;
+ } else {
+ if (DEBUG_PAUSE) Slog.v(TAG_PAUSE, "Finish waiting for pause of: " + r);
+ }
+
+ return false;
+ } finally {
+ mWindowManager.continueSurfaceLayout();
+ }
+ }
+
+ private void prepareActivityHideTransitionAnimation(ActivityRecord r, int transit) {
+ final DisplayWindowController dwc = getDisplay().getWindowContainerController();
+ dwc.prepareAppTransition(transit, false);
+ r.setVisibility(false);
+ dwc.executeAppTransition();
+ if (!mStackSupervisor.mActivitiesWaitingForVisibleActivity.contains(r)) {
+ mStackSupervisor.mActivitiesWaitingForVisibleActivity.add(r);
+ }
+ }
+
+ static final int FINISH_IMMEDIATELY = 0;
+ static final int FINISH_AFTER_PAUSE = 1;
+ static final int FINISH_AFTER_VISIBLE = 2;
+
+ final ActivityRecord finishCurrentActivityLocked(ActivityRecord r, int mode, boolean oomAdj,
+ String reason) {
+ // First things first: if this activity is currently visible,
+ // and the resumed activity is not yet visible, then hold off on
+ // finishing until the resumed one becomes visible.
+
+ // The activity that we are finishing may be over the lock screen. In this case, we do not
+ // want to consider activities that cannot be shown on the lock screen as running and should
+ // proceed with finishing the activity if there is no valid next top running activity.
+ final ActivityDisplay display = getDisplay();
+ final ActivityRecord next = display.topRunningActivity(true /* considerKeyguardState */);
+
+ if (mode == FINISH_AFTER_VISIBLE && (r.visible || r.nowVisible)
+ && next != null && !next.nowVisible) {
+ if (!mStackSupervisor.mStoppingActivities.contains(r)) {
+ addToStopping(r, false /* scheduleIdle */, false /* idleDelayed */);
+ }
+ if (DEBUG_STATES) Slog.v(TAG_STATES,
+ "Moving to STOPPING: "+ r + " (finish requested)");
+ r.setState(STOPPING, "finishCurrentActivityLocked");
+ if (oomAdj) {
+ mService.updateOomAdj();
+ }
+ return r;
+ }
+
+ // make sure the record is cleaned out of other places.
+ mStackSupervisor.mStoppingActivities.remove(r);
+ mStackSupervisor.mGoingToSleepActivities.remove(r);
+ mStackSupervisor.mActivitiesWaitingForVisibleActivity.remove(r);
+ final ActivityState prevState = r.getState();
+ if (DEBUG_STATES) Slog.v(TAG_STATES, "Moving to FINISHING: " + r);
+
+ r.setState(FINISHING, "finishCurrentActivityLocked");
+ final boolean finishingInNonFocusedStackOrNoRunning = mode == FINISH_AFTER_VISIBLE
+ && prevState == PAUSED && (r.getStack() != display.getFocusedStack()
+ || (next == null && display.topRunningActivity() == null));
+
+ if (mode == FINISH_IMMEDIATELY
+ || (prevState == PAUSED
+ && (mode == FINISH_AFTER_PAUSE || inPinnedWindowingMode()))
+ || finishingInNonFocusedStackOrNoRunning
+ || prevState == STOPPING
+ || prevState == STOPPED
+ || prevState == ActivityState.INITIALIZING) {
+ r.makeFinishingLocked();
+ boolean activityRemoved = destroyActivityLocked(r, true, "finish-imm:" + reason);
+
+ if (finishingInNonFocusedStackOrNoRunning) {
+ // Finishing activity that was in paused state and it was in not currently focused
+ // stack, need to make something visible in its place. Also if the display does not
+ // have running activity, the configuration may need to be updated for restoring
+ // original orientation of the display.
+ mStackSupervisor.ensureVisibilityAndConfig(next, mDisplayId,
+ false /* markFrozenIfConfigChanged */, true /* deferResume */);
+ }
+ if (activityRemoved) {
+ mStackSupervisor.resumeFocusedStacksTopActivitiesLocked();
+ }
+ if (DEBUG_CONTAINERS) Slog.d(TAG_CONTAINERS,
+ "destroyActivityLocked: finishCurrentActivityLocked r=" + r +
+ " destroy returned removed=" + activityRemoved);
+ return activityRemoved ? null : r;
+ }
+
+ // Need to go through the full pause cycle to get this
+ // activity into the stopped state and then finish it.
+ if (DEBUG_ALL) Slog.v(TAG, "Enqueueing pending finish: " + r);
+ mStackSupervisor.mFinishingActivities.add(r);
+ r.resumeKeyDispatchingLocked();
+ mStackSupervisor.resumeFocusedStacksTopActivitiesLocked();
+ return r;
+ }
+
+ void finishAllActivitiesLocked(boolean immediately) {
+ boolean noActivitiesInStack = true;
+ for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
+ final ArrayList<ActivityRecord> activities = mTaskHistory.get(taskNdx).mActivities;
+ for (int activityNdx = activities.size() - 1; activityNdx >= 0; --activityNdx) {
+ final ActivityRecord r = activities.get(activityNdx);
+ noActivitiesInStack = false;
+ if (r.finishing && !immediately) {
+ continue;
+ }
+ Slog.d(TAG, "finishAllActivitiesLocked: finishing " + r + " immediately");
+ finishCurrentActivityLocked(r, FINISH_IMMEDIATELY, false,
+ "finishAllActivitiesLocked");
+ }
+ }
+ if (noActivitiesInStack) {
+ remove();
+ }
+ }
+
+ /** @return true if the stack behind this one is a standard activity type. */
+ boolean inFrontOfStandardStack() {
+ final ActivityDisplay display = getDisplay();
+ if (display == null) {
+ return false;
+ }
+ final int index = display.getIndexOf(this);
+ if (index == 0) {
+ return false;
+ }
+ final ActivityStack stackBehind = display.getChildAt(index - 1);
+ return stackBehind.isActivityTypeStandard();
+ }
+
+ boolean shouldUpRecreateTaskLocked(ActivityRecord srec, String destAffinity) {
+ // Basic case: for simple app-centric recents, we need to recreate
+ // the task if the affinity has changed.
+ if (srec == null || srec.getTask().affinity == null ||
+ !srec.getTask().affinity.equals(destAffinity)) {
+ return true;
+ }
+ // Document-centric case: an app may be split in to multiple documents;
+ // they need to re-create their task if this current activity is the root
+ // of a document, unless simply finishing it will return them to the the
+ // correct app behind.
+ final TaskRecord task = srec.getTask();
+ if (srec.frontOfTask && task.getBaseIntent() != null && task.getBaseIntent().isDocument()) {
+ // Okay, this activity is at the root of its task. What to do, what to do...
+ if (!inFrontOfStandardStack()) {
+ // Finishing won't return to an application, so we need to recreate.
+ return true;
+ }
+ // We now need to get the task below it to determine what to do.
+ int taskIdx = mTaskHistory.indexOf(task);
+ if (taskIdx <= 0) {
+ Slog.w(TAG, "shouldUpRecreateTask: task not in history for " + srec);
+ return false;
+ }
+ final TaskRecord prevTask = mTaskHistory.get(taskIdx);
+ if (!task.affinity.equals(prevTask.affinity)) {
+ // These are different apps, so need to recreate.
+ return true;
+ }
+ }
+ return false;
+ }
+
+ final boolean navigateUpToLocked(ActivityRecord srec, Intent destIntent, int resultCode,
+ Intent resultData) {
+ final TaskRecord task = srec.getTask();
+ final ArrayList<ActivityRecord> activities = task.mActivities;
+ final int start = activities.indexOf(srec);
+ if (!mTaskHistory.contains(task) || (start < 0)) {
+ return false;
+ }
+ int finishTo = start - 1;
+ ActivityRecord parent = finishTo < 0 ? null : activities.get(finishTo);
+ boolean foundParentInTask = false;
+ final ComponentName dest = destIntent.getComponent();
+ if (start > 0 && dest != null) {
+ for (int i = finishTo; i >= 0; i--) {
+ ActivityRecord r = activities.get(i);
+ if (r.info.packageName.equals(dest.getPackageName()) &&
+ r.info.name.equals(dest.getClassName())) {
+ finishTo = i;
+ parent = r;
+ foundParentInTask = true;
+ break;
+ }
+ }
+ }
+
+ // TODO: There is a dup. of this block of code in ActivityTaskManagerService.finishActivity
+ // We should consolidate.
+ IActivityController controller = mService.mController;
+ if (controller != null) {
+ ActivityRecord next = topRunningActivityLocked(srec.appToken, 0);
+ if (next != null) {
+ // ask watcher if this is allowed
+ boolean resumeOK = true;
+ try {
+ resumeOK = controller.activityResuming(next.packageName);
+ } catch (RemoteException e) {
+ mService.mController = null;
+ Watchdog.getInstance().setActivityController(null);
+ }
+
+ if (!resumeOK) {
+ return false;
+ }
+ }
+ }
+ final long origId = Binder.clearCallingIdentity();
+ for (int i = start; i > finishTo; i--) {
+ ActivityRecord r = activities.get(i);
+ requestFinishActivityLocked(r.appToken, resultCode, resultData, "navigate-up", true);
+ // Only return the supplied result for the first activity finished
+ resultCode = Activity.RESULT_CANCELED;
+ resultData = null;
+ }
+
+ if (parent != null && foundParentInTask) {
+ final int parentLaunchMode = parent.info.launchMode;
+ final int destIntentFlags = destIntent.getFlags();
+ if (parentLaunchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE ||
+ parentLaunchMode == ActivityInfo.LAUNCH_SINGLE_TASK ||
+ parentLaunchMode == ActivityInfo.LAUNCH_SINGLE_TOP ||
+ (destIntentFlags & Intent.FLAG_ACTIVITY_CLEAR_TOP) != 0) {
+ parent.deliverNewIntentLocked(srec.info.applicationInfo.uid, destIntent,
+ srec.packageName);
+ } else {
+ try {
+ ActivityInfo aInfo = AppGlobals.getPackageManager().getActivityInfo(
+ destIntent.getComponent(), ActivityManagerService.STOCK_PM_FLAGS,
+ srec.userId);
+ // TODO(b/64750076): Check if calling pid should really be -1.
+ final int res = mService.getActivityStartController()
+ .obtainStarter(destIntent, "navigateUpTo")
+ .setCaller(srec.app.getThread())
+ .setActivityInfo(aInfo)
+ .setResultTo(parent.appToken)
+ .setCallingPid(-1)
+ .setCallingUid(parent.launchedFromUid)
+ .setCallingPackage(parent.launchedFromPackage)
+ .setRealCallingPid(-1)
+ .setRealCallingUid(parent.launchedFromUid)
+ .setComponentSpecified(true)
+ .execute();
+ foundParentInTask = res == ActivityManager.START_SUCCESS;
+ } catch (RemoteException e) {
+ foundParentInTask = false;
+ }
+ requestFinishActivityLocked(parent.appToken, resultCode,
+ resultData, "navigate-top", true);
+ }
+ }
+ Binder.restoreCallingIdentity(origId);
+ return foundParentInTask;
+ }
+
+ /**
+ * Remove any state associated with the {@link ActivityRecord}. This should be called whenever
+ * an activity moves away from the stack.
+ */
+ void onActivityRemovedFromStack(ActivityRecord r) {
+ removeTimeoutsForActivityLocked(r);
+
+ if (mResumedActivity != null && mResumedActivity == r) {
+ setResumedActivity(null, "onActivityRemovedFromStack");
+ }
+ if (mPausingActivity != null && mPausingActivity == r) {
+ mPausingActivity = null;
+ }
+ }
+
+ void onActivityAddedToStack(ActivityRecord r) {
+ if(r.getState() == RESUMED) {
+ setResumedActivity(r, "onActivityAddedToStack");
+ }
+ }
+
+ /**
+ * Perform the common clean-up of an activity record. This is called both
+ * as part of destroyActivityLocked() (when destroying the client-side
+ * representation) and cleaning things up as a result of its hosting
+ * processing going away, in which case there is no remaining client-side
+ * state to destroy so only the cleanup here is needed.
+ *
+ * Note: Call before #removeActivityFromHistoryLocked.
+ */
+ private void cleanUpActivityLocked(ActivityRecord r, boolean cleanServices, boolean setState) {
+ onActivityRemovedFromStack(r);
+
+ r.deferRelaunchUntilPaused = false;
+ r.frozenBeforeDestroy = false;
+
+ if (setState) {
+ if (DEBUG_STATES) Slog.v(TAG_STATES, "Moving to DESTROYED: " + r + " (cleaning up)");
+ r.setState(DESTROYED, "cleanupActivityLocked");
+ if (DEBUG_APP) Slog.v(TAG_APP, "Clearing app during cleanUp for activity " + r);
+ r.app = null;
+ }
+
+ // Inform supervisor the activity has been removed.
+ mStackSupervisor.cleanupActivity(r);
+
+
+ // Remove any pending results.
+ if (r.finishing && r.pendingResults != null) {
+ for (WeakReference<PendingIntentRecord> apr : r.pendingResults) {
+ PendingIntentRecord rec = apr.get();
+ if (rec != null) {
+ mService.mPendingIntentController.cancelIntentSender(rec, false);
+ }
+ }
+ r.pendingResults = null;
+ }
+
+ if (cleanServices) {
+ cleanUpActivityServicesLocked(r);
+ }
+
+ // Get rid of any pending idle timeouts.
+ removeTimeoutsForActivityLocked(r);
+ // Clean-up activities are no longer relaunching (e.g. app process died). Notify window
+ // manager so it can update its bookkeeping.
+ mWindowManager.notifyAppRelaunchesCleared(r.appToken);
+ }
+
+ private void removeTimeoutsForActivityLocked(ActivityRecord r) {
+ mStackSupervisor.removeTimeoutsForActivityLocked(r);
+ mHandler.removeMessages(PAUSE_TIMEOUT_MSG, r);
+ mHandler.removeMessages(STOP_TIMEOUT_MSG, r);
+ mHandler.removeMessages(DESTROY_TIMEOUT_MSG, r);
+ r.finishLaunchTickingLocked();
+ }
+
+ private void removeActivityFromHistoryLocked(ActivityRecord r, String reason) {
+ finishActivityResultsLocked(r, Activity.RESULT_CANCELED, null);
+ r.makeFinishingLocked();
+ if (DEBUG_ADD_REMOVE) Slog.i(TAG_ADD_REMOVE,
+ "Removing activity " + r + " from stack callers=" + Debug.getCallers(5));
+
+ r.takeFromHistory();
+ removeTimeoutsForActivityLocked(r);
+ if (DEBUG_STATES) Slog.v(TAG_STATES,
+ "Moving to DESTROYED: " + r + " (removed from history)");
+ r.setState(DESTROYED, "removeActivityFromHistoryLocked");
+ if (DEBUG_APP) Slog.v(TAG_APP, "Clearing app during remove for activity " + r);
+ r.app = null;
+ r.removeWindowContainer();
+ final TaskRecord task = r.getTask();
+ final boolean lastActivity = task != null ? task.removeActivity(r) : false;
+ // If we are removing the last activity in the task, not including task overlay activities,
+ // then fall through into the block below to remove the entire task itself
+ final boolean onlyHasTaskOverlays = task != null
+ ? task.onlyHasTaskOverlayActivities(false /* excludingFinishing */) : false;
+
+ if (lastActivity || onlyHasTaskOverlays) {
+ if (DEBUG_STACK) {
+ Slog.i(TAG_STACK,
+ "removeActivityFromHistoryLocked: last activity removed from " + this
+ + " onlyHasTaskOverlays=" + onlyHasTaskOverlays);
+ }
+
+ // The following block can be executed multiple times if there is more than one overlay.
+ // {@link ActivityStackSupervisor#removeTaskByIdLocked} handles this by reverse lookup
+ // of the task by id and exiting early if not found.
+ if (onlyHasTaskOverlays) {
+ // When destroying a task, tell the supervisor to remove it so that any activity it
+ // has can be cleaned up correctly. This is currently the only place where we remove
+ // a task with the DESTROYING mode, so instead of passing the onlyHasTaskOverlays
+ // state into removeTask(), we just clear the task here before the other residual
+ // work.
+ // TODO: If the callers to removeTask() changes such that we have multiple places
+ // where we are destroying the task, move this back into removeTask()
+ mStackSupervisor.removeTaskByIdLocked(task.taskId, false /* killProcess */,
+ !REMOVE_FROM_RECENTS, PAUSE_IMMEDIATELY, reason);
+ }
+
+ // We must keep the task around until all activities are destroyed. The following
+ // statement will only execute once since overlays are also considered activities.
+ if (lastActivity) {
+ removeTask(task, reason, REMOVE_TASK_MODE_DESTROYING);
+ }
+ }
+ cleanUpActivityServicesLocked(r);
+ r.removeUriPermissionsLocked();
+ }
+
+ /**
+ * Perform clean-up of service connections in an activity record.
+ */
+ private void cleanUpActivityServicesLocked(ActivityRecord r) {
+ if (r.mServiceConnectionsHolder == null) {
+ return;
+ }
+ // Throw away any services that have been bound by this activity.
+ r.mServiceConnectionsHolder.disconnectActivityFromServices();
+ }
+
+ final void scheduleDestroyActivities(WindowProcessController owner, String reason) {
+ Message msg = mHandler.obtainMessage(DESTROY_ACTIVITIES_MSG);
+ msg.obj = new ScheduleDestroyArgs(owner, reason);
+ mHandler.sendMessage(msg);
+ }
+
+ private void destroyActivitiesLocked(WindowProcessController owner, String reason) {
+ boolean lastIsOpaque = false;
+ boolean activityRemoved = false;
+ for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
+ final ArrayList<ActivityRecord> activities = mTaskHistory.get(taskNdx).mActivities;
+ for (int activityNdx = activities.size() - 1; activityNdx >= 0; --activityNdx) {
+ final ActivityRecord r = activities.get(activityNdx);
+ if (r.finishing) {
+ continue;
+ }
+ if (r.fullscreen) {
+ lastIsOpaque = true;
+ }
+ if (owner != null && r.app != owner) {
+ continue;
+ }
+ if (!lastIsOpaque) {
+ continue;
+ }
+ if (r.isDestroyable()) {
+ if (DEBUG_SWITCH) Slog.v(TAG_SWITCH, "Destroying " + r
+ + " in state " + r.getState()
+ + " resumed=" + mResumedActivity
+ + " pausing=" + mPausingActivity + " for reason " + reason);
+ if (destroyActivityLocked(r, true, reason)) {
+ activityRemoved = true;
+ }
+ }
+ }
+ }
+ if (activityRemoved) {
+ mStackSupervisor.resumeFocusedStacksTopActivitiesLocked();
+ }
+ }
+
+ final boolean safelyDestroyActivityLocked(ActivityRecord r, String reason) {
+ if (r.isDestroyable()) {
+ if (DEBUG_SWITCH) Slog.v(TAG_SWITCH,
+ "Destroying " + r + " in state " + r.getState() + " resumed=" + mResumedActivity
+ + " pausing=" + mPausingActivity + " for reason " + reason);
+ return destroyActivityLocked(r, true, reason);
+ }
+ return false;
+ }
+
+ final int releaseSomeActivitiesLocked(WindowProcessController app, ArraySet<TaskRecord> tasks,
+ String reason) {
+ // Iterate over tasks starting at the back (oldest) first.
+ if (DEBUG_RELEASE) Slog.d(TAG_RELEASE, "Trying to release some activities in " + app);
+ int maxTasks = tasks.size() / 4;
+ if (maxTasks < 1) {
+ maxTasks = 1;
+ }
+ int numReleased = 0;
+ for (int taskNdx = 0; taskNdx < mTaskHistory.size() && maxTasks > 0; taskNdx++) {
+ final TaskRecord task = mTaskHistory.get(taskNdx);
+ if (!tasks.contains(task)) {
+ continue;
+ }
+ if (DEBUG_RELEASE) Slog.d(TAG_RELEASE, "Looking for activities to release in " + task);
+ int curNum = 0;
+ final ArrayList<ActivityRecord> activities = task.mActivities;
+ for (int actNdx = 0; actNdx < activities.size(); actNdx++) {
+ final ActivityRecord activity = activities.get(actNdx);
+ if (activity.app == app && activity.isDestroyable()) {
+ if (DEBUG_RELEASE) Slog.v(TAG_RELEASE, "Destroying " + activity
+ + " in state " + activity.getState() + " resumed=" + mResumedActivity
+ + " pausing=" + mPausingActivity + " for reason " + reason);
+ destroyActivityLocked(activity, true, reason);
+ if (activities.get(actNdx) != activity) {
+ // Was removed from list, back up so we don't miss the next one.
+ actNdx--;
+ }
+ curNum++;
+ }
+ }
+ if (curNum > 0) {
+ numReleased += curNum;
+ maxTasks--;
+ if (mTaskHistory.get(taskNdx) != task) {
+ // The entire task got removed, back up so we don't miss the next one.
+ taskNdx--;
+ }
+ }
+ }
+ if (DEBUG_RELEASE) Slog.d(TAG_RELEASE,
+ "Done releasing: did " + numReleased + " activities");
+ return numReleased;
+ }
+
+ /**
+ * Destroy the current CLIENT SIDE instance of an activity. This may be
+ * called both when actually finishing an activity, or when performing
+ * a configuration switch where we destroy the current client-side object
+ * but then create a new client-side object for this same HistoryRecord.
+ */
+ final boolean destroyActivityLocked(ActivityRecord r, boolean removeFromApp, String reason) {
+ if (DEBUG_SWITCH || DEBUG_CLEANUP) Slog.v(TAG_SWITCH,
+ "Removing activity from " + reason + ": token=" + r
+ + ", app=" + (r.hasProcess() ? r.app.mName : "(null)"));
+
+ if (r.isState(DESTROYING, DESTROYED)) {
+ if (DEBUG_STATES) Slog.v(TAG_STATES, "activity " + r + " already destroying."
+ + "skipping request with reason:" + reason);
+ return false;
+ }
+
+ EventLog.writeEvent(EventLogTags.AM_DESTROY_ACTIVITY,
+ r.userId, System.identityHashCode(r),
+ r.getTask().taskId, r.shortComponentName, reason);
+
+ boolean removedFromHistory = false;
+
+ cleanUpActivityLocked(r, false, false);
+
+ final boolean hadApp = r.hasProcess();
+
+ if (hadApp) {
+ if (removeFromApp) {
+ r.app.removeActivity(r);
+ if (!r.app.hasActivities()) {
+ mService.clearHeavyWeightProcessIfEquals(r.app);
+ }
+ if (!r.app.hasActivities()) {
+ // Update any services we are bound to that might care about whether
+ // their client may have activities.
+ // No longer have activities, so update LRU list and oom adj.
+ r.app.updateProcessInfo(true, true, false, true);
+ }
+ }
+
+ boolean skipDestroy = false;
+
+ try {
+ if (DEBUG_SWITCH) Slog.i(TAG_SWITCH, "Destroying: " + r);
+ mService.getLifecycleManager().scheduleTransaction(r.app.getThread(), r.appToken,
+ DestroyActivityItem.obtain(r.finishing, r.configChangeFlags));
+ } catch (Exception e) {
+ // We can just ignore exceptions here... if the process
+ // has crashed, our death notification will clean things
+ // up.
+ //Slog.w(TAG, "Exception thrown during finish", e);
+ if (r.finishing) {
+ removeActivityFromHistoryLocked(r, reason + " exceptionInScheduleDestroy");
+ removedFromHistory = true;
+ skipDestroy = true;
+ }
+ }
+
+ r.nowVisible = false;
+
+ // If the activity is finishing, we need to wait on removing it
+ // from the list to give it a chance to do its cleanup. During
+ // that time it may make calls back with its token so we need to
+ // be able to find it on the list and so we don't want to remove
+ // it from the list yet. Otherwise, we can just immediately put
+ // it in the destroyed state since we are not removing it from the
+ // list.
+ if (r.finishing && !skipDestroy) {
+ if (DEBUG_STATES) Slog.v(TAG_STATES, "Moving to DESTROYING: " + r
+ + " (destroy requested)");
+ r.setState(DESTROYING,
+ "destroyActivityLocked. finishing and not skipping destroy");
+ Message msg = mHandler.obtainMessage(DESTROY_TIMEOUT_MSG, r);
+ mHandler.sendMessageDelayed(msg, DESTROY_TIMEOUT);
+ } else {
+ if (DEBUG_STATES) Slog.v(TAG_STATES,
+ "Moving to DESTROYED: " + r + " (destroy skipped)");
+ r.setState(DESTROYED,
+ "destroyActivityLocked. not finishing or skipping destroy");
+ if (DEBUG_APP) Slog.v(TAG_APP, "Clearing app during destroy for activity " + r);
+ r.app = null;
+ }
+ } else {
+ // remove this record from the history.
+ if (r.finishing) {
+ removeActivityFromHistoryLocked(r, reason + " hadNoApp");
+ removedFromHistory = true;
+ } else {
+ if (DEBUG_STATES) Slog.v(TAG_STATES, "Moving to DESTROYED: " + r + " (no app)");
+ r.setState(DESTROYED, "destroyActivityLocked. not finishing and had no app");
+ if (DEBUG_APP) Slog.v(TAG_APP, "Clearing app during destroy for activity " + r);
+ r.app = null;
+ }
+ }
+
+ r.configChangeFlags = 0;
+
+ if (!mLRUActivities.remove(r) && hadApp) {
+ Slog.w(TAG, "Activity " + r + " being finished, but not in LRU list");
+ }
+
+ return removedFromHistory;
+ }
+
+ final void activityDestroyedLocked(IBinder token, String reason) {
+ final long origId = Binder.clearCallingIdentity();
+ try {
+ activityDestroyedLocked(ActivityRecord.forTokenLocked(token), reason);
+ } finally {
+ Binder.restoreCallingIdentity(origId);
+ }
+ }
+
+ /**
+ * This method is to only be called from the client via binder when the activity is destroyed
+ * AND finished.
+ */
+ final void activityDestroyedLocked(ActivityRecord record, String reason) {
+ if (record != null) {
+ mHandler.removeMessages(DESTROY_TIMEOUT_MSG, record);
+ }
+
+ if (DEBUG_CONTAINERS) Slog.d(TAG_CONTAINERS, "activityDestroyedLocked: r=" + record);
+
+ if (isInStackLocked(record) != null) {
+ if (record.isState(DESTROYING, DESTROYED)) {
+ cleanUpActivityLocked(record, true, false);
+ removeActivityFromHistoryLocked(record, reason);
+ }
+ }
+
+ mStackSupervisor.resumeFocusedStacksTopActivitiesLocked();
+ }
+
+ private void removeHistoryRecordsForAppLocked(ArrayList<ActivityRecord> list,
+ WindowProcessController app, String listName) {
+ int i = list.size();
+ if (DEBUG_CLEANUP) Slog.v(TAG_CLEANUP,
+ "Removing app " + app + " from list " + listName + " with " + i + " entries");
+ while (i > 0) {
+ i--;
+ ActivityRecord r = list.get(i);
+ if (DEBUG_CLEANUP) Slog.v(TAG_CLEANUP, "Record #" + i + " " + r);
+ if (r.app == app) {
+ if (DEBUG_CLEANUP) Slog.v(TAG_CLEANUP, "---> REMOVING this entry!");
+ list.remove(i);
+ removeTimeoutsForActivityLocked(r);
+ }
+ }
+ }
+
+ private boolean removeHistoryRecordsForAppLocked(WindowProcessController app) {
+ removeHistoryRecordsForAppLocked(mLRUActivities, app, "mLRUActivities");
+ removeHistoryRecordsForAppLocked(mStackSupervisor.mStoppingActivities, app,
+ "mStoppingActivities");
+ removeHistoryRecordsForAppLocked(mStackSupervisor.mGoingToSleepActivities, app,
+ "mGoingToSleepActivities");
+ removeHistoryRecordsForAppLocked(mStackSupervisor.mActivitiesWaitingForVisibleActivity, app,
+ "mActivitiesWaitingForVisibleActivity");
+ removeHistoryRecordsForAppLocked(mStackSupervisor.mFinishingActivities, app,
+ "mFinishingActivities");
+
+ boolean hasVisibleActivities = false;
+
+ // Clean out the history list.
+ int i = numActivities();
+ if (DEBUG_CLEANUP) Slog.v(TAG_CLEANUP,
+ "Removing app " + app + " from history with " + i + " entries");
+ for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
+ final ArrayList<ActivityRecord> activities = mTaskHistory.get(taskNdx).mActivities;
+ mTmpActivities.clear();
+ mTmpActivities.addAll(activities);
+
+ while (!mTmpActivities.isEmpty()) {
+ final int targetIndex = mTmpActivities.size() - 1;
+ final ActivityRecord r = mTmpActivities.remove(targetIndex);
+ if (DEBUG_CLEANUP) Slog.v(TAG_CLEANUP,
+ "Record #" + targetIndex + " " + r + ": app=" + r.app);
+
+ if (r.app == app) {
+ if (r.visible) {
+ hasVisibleActivities = true;
+ }
+ final boolean remove;
+ if ((r.mRelaunchReason == RELAUNCH_REASON_WINDOWING_MODE_RESIZE
+ || r.mRelaunchReason == RELAUNCH_REASON_FREE_RESIZE)
+ && r.launchCount < 3 && !r.finishing) {
+ // If the process crashed during a resize, always try to relaunch it, unless
+ // it has failed more than twice. Skip activities that's already finishing
+ // cleanly by itself.
+ remove = false;
+ } else if ((!r.haveState && !r.stateNotNeeded) || r.finishing) {
+ // Don't currently have state for the activity, or
+ // it is finishing -- always remove it.
+ remove = true;
+ } else if (!r.visible && r.launchCount > 2 &&
+ r.lastLaunchTime > (SystemClock.uptimeMillis() - 60000)) {
+ // We have launched this activity too many times since it was
+ // able to run, so give up and remove it.
+ // (Note if the activity is visible, we don't remove the record.
+ // We leave the dead window on the screen but the process will
+ // not be restarted unless user explicitly tap on it.)
+ remove = true;
+ } else {
+ // The process may be gone, but the activity lives on!
+ remove = false;
+ }
+ if (remove) {
+ if (DEBUG_ADD_REMOVE || DEBUG_CLEANUP) Slog.i(TAG_ADD_REMOVE,
+ "Removing activity " + r + " from stack at " + i
+ + ": haveState=" + r.haveState
+ + " stateNotNeeded=" + r.stateNotNeeded
+ + " finishing=" + r.finishing
+ + " state=" + r.getState() + " callers=" + Debug.getCallers(5));
+ if (!r.finishing) {
+ Slog.w(TAG, "Force removing " + r + ": app died, no saved state");
+ EventLog.writeEvent(EventLogTags.AM_FINISH_ACTIVITY,
+ r.userId, System.identityHashCode(r),
+ r.getTask().taskId, r.shortComponentName,
+ "proc died without state saved");
+ if (r.getState() == RESUMED) {
+ mService.updateUsageStats(r, false);
+ }
+ }
+ } else {
+ // We have the current state for this activity, so
+ // it can be restarted later when needed.
+ if (DEBUG_ALL) Slog.v(TAG, "Keeping entry, setting app to null");
+ if (DEBUG_APP) Slog.v(TAG_APP,
+ "Clearing app during removeHistory for activity " + r);
+ r.app = null;
+ // Set nowVisible to previous visible state. If the app was visible while
+ // it died, we leave the dead window on screen so it's basically visible.
+ // This is needed when user later tap on the dead window, we need to stop
+ // other apps when user transfers focus to the restarted activity.
+ r.nowVisible = r.visible;
+ if (!r.haveState) {
+ if (DEBUG_SAVED_STATE) Slog.i(TAG_SAVED_STATE,
+ "App died, clearing saved state of " + r);
+ r.icicle = null;
+ }
+ }
+ cleanUpActivityLocked(r, true, true);
+ if (remove) {
+ removeActivityFromHistoryLocked(r, "appDied");
+ }
+ }
+ }
+ }
+
+ return hasVisibleActivities;
+ }
+
+ private void updateTransitLocked(int transit, ActivityOptions options) {
+ if (options != null) {
+ ActivityRecord r = topRunningActivityLocked();
+ if (r != null && !r.isState(RESUMED)) {
+ r.updateOptionsLocked(options);
+ } else {
+ ActivityOptions.abort(options);
+ }
+ }
+ getDisplay().getWindowContainerController().prepareAppTransition(transit, false);
+ }
+
+ private void updateTaskMovement(TaskRecord task, boolean toFront) {
+ if (task.isPersistable) {
+ task.mLastTimeMoved = System.currentTimeMillis();
+ // Sign is used to keep tasks sorted when persisted. Tasks sent to the bottom most
+ // recently will be most negative, tasks sent to the bottom before that will be less
+ // negative. Similarly for recent tasks moved to the top which will be most positive.
+ if (!toFront) {
+ task.mLastTimeMoved *= -1;
+ }
+ }
+ mStackSupervisor.invalidateTaskLayers();
+ }
+
+ final void moveTaskToFrontLocked(TaskRecord tr, boolean noAnimation, ActivityOptions options,
+ AppTimeTracker timeTracker, String reason) {
+ if (DEBUG_SWITCH) Slog.v(TAG_SWITCH, "moveTaskToFront: " + tr);
+
+ final ActivityStack topStack = getDisplay().getTopStack();
+ final ActivityRecord topActivity = topStack != null ? topStack.getTopActivity() : null;
+ final int numTasks = mTaskHistory.size();
+ final int index = mTaskHistory.indexOf(tr);
+ if (numTasks == 0 || index < 0) {
+ // nothing to do!
+ if (noAnimation) {
+ ActivityOptions.abort(options);
+ } else {
+ updateTransitLocked(TRANSIT_TASK_TO_FRONT, options);
+ }
+ return;
+ }
+
+ if (timeTracker != null) {
+ // The caller wants a time tracker associated with this task.
+ for (int i = tr.mActivities.size() - 1; i >= 0; i--) {
+ tr.mActivities.get(i).appTimeTracker = timeTracker;
+ }
+ }
+
+ try {
+ // Defer updating the IME target since the new IME target will try to get computed
+ // before updating all closing and opening apps, which can cause the ime target to
+ // get calculated incorrectly.
+ getDisplay().deferUpdateImeTarget();
+
+ // Shift all activities with this task up to the top
+ // of the stack, keeping them in the same internal order.
+ insertTaskAtTop(tr, null);
+
+ // Don't refocus if invisible to current user
+ final ActivityRecord top = tr.getTopActivity();
+ if (top == null || !top.okToShowLocked()) {
+ if (top != null) {
+ mStackSupervisor.mRecentTasks.add(top.getTask());
+ }
+ ActivityOptions.abort(options);
+ return;
+ }
+
+ // Set focus to the top running activity of this stack.
+ final ActivityRecord r = topRunningActivityLocked();
+ if (r != null) {
+ r.moveFocusableActivityToTop(reason);
+ }
+
+ if (DEBUG_TRANSITION) Slog.v(TAG_TRANSITION, "Prepare to front transition: task=" + tr);
+ if (noAnimation) {
+ getDisplay().getWindowContainerController().prepareAppTransition(
+ TRANSIT_NONE, false);
+ if (r != null) {
+ mStackSupervisor.mNoAnimActivities.add(r);
+ }
+ ActivityOptions.abort(options);
+ } else {
+ updateTransitLocked(TRANSIT_TASK_TO_FRONT, options);
+ }
+ // If a new task is moved to the front, then mark the existing top activity as
+ // supporting
+
+ // picture-in-picture while paused only if the task would not be considered an oerlay
+ // on top
+ // of the current activity (eg. not fullscreen, or the assistant)
+ if (canEnterPipOnTaskSwitch(topActivity, tr, null /* toFrontActivity */,
+ options)) {
+ topActivity.supportsEnterPipOnTaskSwitch = true;
+ }
+
+ mStackSupervisor.resumeFocusedStacksTopActivitiesLocked();
+ EventLog.writeEvent(EventLogTags.AM_TASK_TO_FRONT, tr.userId, tr.taskId);
+
+ mService.getTaskChangeNotificationController().notifyTaskMovedToFront(tr.taskId);
+ } finally {
+ getDisplay().continueUpdateImeTarget();
+ }
+ }
+
+ /**
+ * Worker method for rearranging history stack. Implements the function of moving all
+ * activities for a specific task (gathering them if disjoint) into a single group at the
+ * bottom of the stack.
+ *
+ * If a watcher is installed, the action is preflighted and the watcher has an opportunity
+ * to premeptively cancel the move.
+ *
+ * @param taskId The taskId to collect and move to the bottom.
+ * @return Returns true if the move completed, false if not.
+ */
+ final boolean moveTaskToBackLocked(int taskId) {
+ final TaskRecord tr = taskForIdLocked(taskId);
+ if (tr == null) {
+ Slog.i(TAG, "moveTaskToBack: bad taskId=" + taskId);
+ return false;
+ }
+ Slog.i(TAG, "moveTaskToBack: " + tr);
+
+ // In LockTask mode, moving a locked task to the back of the stack may expose unlocked
+ // ones. Therefore we need to check if this operation is allowed.
+ if (!mService.getLockTaskController().canMoveTaskToBack(tr)) {
+ return false;
+ }
+
+ // If we have a watcher, preflight the move before committing to it. First check
+ // for *other* available tasks, but if none are available, then try again allowing the
+ // current task to be selected.
+ if (isTopStackOnDisplay() && mService.mController != null) {
+ ActivityRecord next = topRunningActivityLocked(null, taskId);
+ if (next == null) {
+ next = topRunningActivityLocked(null, 0);
+ }
+ if (next != null) {
+ // ask watcher if this is allowed
+ boolean moveOK = true;
+ try {
+ moveOK = mService.mController.activityResuming(next.packageName);
+ } catch (RemoteException e) {
+ mService.mController = null;
+ Watchdog.getInstance().setActivityController(null);
+ }
+ if (!moveOK) {
+ return false;
+ }
+ }
+ }
+
+ if (DEBUG_TRANSITION) Slog.v(TAG_TRANSITION, "Prepare to back transition: task=" + taskId);
+
+ mTaskHistory.remove(tr);
+ mTaskHistory.add(0, tr);
+ updateTaskMovement(tr, false);
+
+ getDisplay().getWindowContainerController().prepareAppTransition(
+ TRANSIT_TASK_TO_BACK, false);
+ moveToBack("moveTaskToBackLocked", tr);
+
+ if (inPinnedWindowingMode()) {
+ mStackSupervisor.removeStack(this);
+ return true;
+ }
+
+ mStackSupervisor.resumeFocusedStacksTopActivitiesLocked();
+ return true;
+ }
+
+ static void logStartActivity(int tag, ActivityRecord r, TaskRecord task) {
+ final Uri data = r.intent.getData();
+ final String strData = data != null ? data.toSafeString() : null;
+
+ EventLog.writeEvent(tag,
+ r.userId, System.identityHashCode(r), task.taskId,
+ r.shortComponentName, r.intent.getAction(),
+ r.intent.getType(), strData, r.intent.getFlags());
+ }
+
+ /**
+ * Ensures all visible activities at or below the input activity have the right configuration.
+ */
+ void ensureVisibleActivitiesConfigurationLocked(ActivityRecord start, boolean preserveWindow) {
+ if (start == null || !start.visible) {
+ return;
+ }
+
+ final TaskRecord startTask = start.getTask();
+ boolean behindFullscreen = false;
+ boolean updatedConfig = false;
+
+ for (int taskIndex = mTaskHistory.indexOf(startTask); taskIndex >= 0; --taskIndex) {
+ final TaskRecord task = mTaskHistory.get(taskIndex);
+ final ArrayList<ActivityRecord> activities = task.mActivities;
+ int activityIndex =
+ (start.getTask() == task) ? activities.indexOf(start) : activities.size() - 1;
+ for (; activityIndex >= 0; --activityIndex) {
+ final ActivityRecord r = activities.get(activityIndex);
+ updatedConfig |= r.ensureActivityConfiguration(0 /* globalChanges */,
+ preserveWindow);
+ if (r.fullscreen) {
+ behindFullscreen = true;
+ break;
+ }
+ }
+ if (behindFullscreen) {
+ break;
+ }
+ }
+ if (updatedConfig) {
+ // Ensure the resumed state of the focus activity if we updated the configuration of
+ // any activity.
+ mStackSupervisor.resumeFocusedStacksTopActivitiesLocked();
+ }
+ }
+
+ // TODO: Figure-out a way to consolidate with resize() method below.
+ @Override
+ public void requestResize(Rect bounds) {
+ mService.resizeStack(mStackId, bounds,
+ true /* allowResizeInDockedMode */, false /* preserveWindows */,
+ false /* animate */, -1 /* animationDuration */);
+ }
+
+ // TODO: Can only be called from special methods in ActivityStackSupervisor.
+ // Need to consolidate those calls points into this resize method so anyone can call directly.
+ void resize(Rect bounds, Rect tempTaskBounds, Rect tempTaskInsetBounds) {
+ if (!updateBoundsAllowed(bounds, tempTaskBounds, tempTaskInsetBounds)) {
+ return;
+ }
+
+ // Update override configurations of all tasks in the stack.
+ final Rect taskBounds = tempTaskBounds != null ? tempTaskBounds : bounds;
+ final Rect insetBounds = tempTaskInsetBounds != null ? tempTaskInsetBounds : taskBounds;
+
+ mTmpBounds.clear();
+ mTmpInsetBounds.clear();
+
+ synchronized (mWindowManager.getWindowManagerLock()) {
+ for (int i = mTaskHistory.size() - 1; i >= 0; i--) {
+ final TaskRecord task = mTaskHistory.get(i);
+ if (task.isResizeable()) {
+ if (inFreeformWindowingMode()) {
+ // TODO(b/71028874): Can be removed since each freeform task is its own
+ // stack.
+ // For freeform stack we don't adjust the size of the tasks to match that
+ // of the stack, but we do try to make sure the tasks are still contained
+ // with the bounds of the stack.
+ if (task.getOverrideBounds() != null) {
+ mTmpRect2.set(task.getOverrideBounds());
+ fitWithinBounds(mTmpRect2, bounds);
+ task.updateOverrideConfiguration(mTmpRect2);
+ }
+ } else {
+ task.updateOverrideConfiguration(taskBounds, insetBounds);
+ }
+ }
+
+ mTmpBounds.put(task.taskId, task.getOverrideBounds());
+ if (tempTaskInsetBounds != null) {
+ mTmpInsetBounds.put(task.taskId, tempTaskInsetBounds);
+ }
+ }
+
+ mWindowContainerController.resize(bounds, mTmpBounds, mTmpInsetBounds);
+ setBounds(bounds);
+ }
+ }
+
+ void onPipAnimationEndResize() {
+ mWindowContainerController.onPipAnimationEndResize();
+ }
+
+
+ /**
+ * Adjust bounds to stay within stack bounds.
+ *
+ * Since bounds might be outside of stack bounds, this method tries to move the bounds in a way
+ * that keep them unchanged, but be contained within the stack bounds.
+ *
+ * @param bounds Bounds to be adjusted.
+ * @param stackBounds Bounds within which the other bounds should remain.
+ */
+ private static void fitWithinBounds(Rect bounds, Rect stackBounds) {
+ if (stackBounds == null || stackBounds.isEmpty() || stackBounds.contains(bounds)) {
+ return;
+ }
+
+ if (bounds.left < stackBounds.left || bounds.right > stackBounds.right) {
+ final int maxRight = stackBounds.right
+ - (stackBounds.width() / FIT_WITHIN_BOUNDS_DIVIDER);
+ int horizontalDiff = stackBounds.left - bounds.left;
+ if ((horizontalDiff < 0 && bounds.left >= maxRight)
+ || (bounds.left + horizontalDiff >= maxRight)) {
+ horizontalDiff = maxRight - bounds.left;
+ }
+ bounds.left += horizontalDiff;
+ bounds.right += horizontalDiff;
+ }
+
+ if (bounds.top < stackBounds.top || bounds.bottom > stackBounds.bottom) {
+ final int maxBottom = stackBounds.bottom
+ - (stackBounds.height() / FIT_WITHIN_BOUNDS_DIVIDER);
+ int verticalDiff = stackBounds.top - bounds.top;
+ if ((verticalDiff < 0 && bounds.top >= maxBottom)
+ || (bounds.top + verticalDiff >= maxBottom)) {
+ verticalDiff = maxBottom - bounds.top;
+ }
+ bounds.top += verticalDiff;
+ bounds.bottom += verticalDiff;
+ }
+ }
+
+ boolean willActivityBeVisibleLocked(IBinder token) {
+ for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
+ final ArrayList<ActivityRecord> activities = mTaskHistory.get(taskNdx).mActivities;
+ for (int activityNdx = activities.size() - 1; activityNdx >= 0; --activityNdx) {
+ final ActivityRecord r = activities.get(activityNdx);
+ if (r.appToken == token) {
+ return true;
+ }
+ if (r.fullscreen && !r.finishing) {
+ return false;
+ }
+ }
+ }
+ final ActivityRecord r = ActivityRecord.forTokenLocked(token);
+ if (r == null) {
+ return false;
+ }
+ if (r.finishing) Slog.e(TAG, "willActivityBeVisibleLocked: Returning false,"
+ + " would have returned true for r=" + r);
+ return !r.finishing;
+ }
+
+ void closeSystemDialogsLocked() {
+ for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
+ final ArrayList<ActivityRecord> activities = mTaskHistory.get(taskNdx).mActivities;
+ for (int activityNdx = activities.size() - 1; activityNdx >= 0; --activityNdx) {
+ final ActivityRecord r = activities.get(activityNdx);
+ if ((r.info.flags&ActivityInfo.FLAG_FINISH_ON_CLOSE_SYSTEM_DIALOGS) != 0) {
+ finishActivityLocked(r, Activity.RESULT_CANCELED, null, "close-sys", true);
+ }
+ }
+ }
+ }
+
+ boolean finishDisabledPackageActivitiesLocked(String packageName, Set<String> filterByClasses,
+ boolean doit, boolean evenPersistent, int userId) {
+ boolean didSomething = false;
+ TaskRecord lastTask = null;
+ ComponentName homeActivity = null;
+ for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
+ final ArrayList<ActivityRecord> activities = mTaskHistory.get(taskNdx).mActivities;
+ mTmpActivities.clear();
+ mTmpActivities.addAll(activities);
+
+ while (!mTmpActivities.isEmpty()) {
+ ActivityRecord r = mTmpActivities.remove(0);
+ final boolean sameComponent =
+ (r.packageName.equals(packageName) && (filterByClasses == null
+ || filterByClasses.contains(r.realActivity.getClassName())))
+ || (packageName == null && r.userId == userId);
+ if ((userId == UserHandle.USER_ALL || r.userId == userId)
+ && (sameComponent || r.getTask() == lastTask)
+ && (r.app == null || evenPersistent || !r.app.isPersistent())) {
+ if (!doit) {
+ if (r.finishing) {
+ // If this activity is just finishing, then it is not
+ // interesting as far as something to stop.
+ continue;
+ }
+ return true;
+ }
+ if (r.isActivityTypeHome()) {
+ if (homeActivity != null && homeActivity.equals(r.realActivity)) {
+ Slog.i(TAG, "Skip force-stop again " + r);
+ continue;
+ } else {
+ homeActivity = r.realActivity;
+ }
+ }
+ didSomething = true;
+ Slog.i(TAG, " Force finishing activity " + r);
+ if (sameComponent) {
+ if (r.hasProcess()) {
+ r.app.setRemoved(true);
+ }
+ r.app = null;
+ }
+ lastTask = r.getTask();
+ finishActivityLocked(r, Activity.RESULT_CANCELED, null, "force-stop",
+ true);
+ }
+ }
+ }
+ return didSomething;
+ }
+
+ /**
+ * @return The set of running tasks through {@param tasksOut} that are available to the caller.
+ * If {@param ignoreActivityType} or {@param ignoreWindowingMode} are not undefined,
+ * then skip running tasks that match those types.
+ */
+ void getRunningTasks(List<TaskRecord> tasksOut, @ActivityType int ignoreActivityType,
+ @WindowingMode int ignoreWindowingMode, int callingUid, boolean allowed) {
+ boolean focusedStack = mStackSupervisor.getTopDisplayFocusedStack() == this;
+ boolean topTask = true;
+ for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
+ final TaskRecord task = mTaskHistory.get(taskNdx);
+ if (task.getTopActivity() == null) {
+ // Skip if there are no activities in the task
+ continue;
+ }
+ if (!allowed && !task.isActivityTypeHome() && task.effectiveUid != callingUid) {
+ // Skip if the caller can't fetch this task
+ continue;
+ }
+ if (ignoreActivityType != ACTIVITY_TYPE_UNDEFINED
+ && task.getActivityType() == ignoreActivityType) {
+ // Skip ignored activity type
+ continue;
+ }
+ if (ignoreWindowingMode != WINDOWING_MODE_UNDEFINED
+ && task.getWindowingMode() == ignoreWindowingMode) {
+ // Skip ignored windowing mode
+ continue;
+ }
+ if (focusedStack && topTask) {
+ // For the focused stack top task, update the last stack active time so that it can
+ // be used to determine the order of the tasks (it may not be set for newly created
+ // tasks)
+ task.lastActiveTime = SystemClock.elapsedRealtime();
+ topTask = false;
+ }
+ tasksOut.add(task);
+ }
+ }
+
+ void unhandledBackLocked() {
+ final int top = mTaskHistory.size() - 1;
+ if (DEBUG_SWITCH) Slog.d(TAG_SWITCH, "Performing unhandledBack(): top activity at " + top);
+ if (top >= 0) {
+ final ArrayList<ActivityRecord> activities = mTaskHistory.get(top).mActivities;
+ int activityTop = activities.size() - 1;
+ if (activityTop >= 0) {
+ finishActivityLocked(activities.get(activityTop), Activity.RESULT_CANCELED, null,
+ "unhandled-back", true);
+ }
+ }
+ }
+
+ /**
+ * Reset local parameters because an app's activity died.
+ * @param app The app of the activity that died.
+ * @return result from removeHistoryRecordsForAppLocked.
+ */
+ boolean handleAppDiedLocked(WindowProcessController app) {
+ if (mPausingActivity != null && mPausingActivity.app == app) {
+ if (DEBUG_PAUSE || DEBUG_CLEANUP) Slog.v(TAG_PAUSE,
+ "App died while pausing: " + mPausingActivity);
+ mPausingActivity = null;
+ }
+ if (mLastPausedActivity != null && mLastPausedActivity.app == app) {
+ mLastPausedActivity = null;
+ mLastNoHistoryActivity = null;
+ }
+
+ return removeHistoryRecordsForAppLocked(app);
+ }
+
+ void handleAppCrashLocked(WindowProcessController app) {
+ for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
+ final ArrayList<ActivityRecord> activities = mTaskHistory.get(taskNdx).mActivities;
+ for (int activityNdx = activities.size() - 1; activityNdx >= 0; --activityNdx) {
+ final ActivityRecord r = activities.get(activityNdx);
+ if (r.app == app) {
+ Slog.w(TAG, " Force finishing activity "
+ + r.intent.getComponent().flattenToShortString());
+ // Force the destroy to skip right to removal.
+ r.app = null;
+ getDisplay().getWindowContainerController().prepareAppTransition(
+ TRANSIT_CRASHING_ACTIVITY_CLOSE, false /* alwaysKeepCurrent */);
+ finishCurrentActivityLocked(r, FINISH_IMMEDIATELY, false,
+ "handleAppCrashedLocked");
+ }
+ }
+ }
+ }
+
+ boolean dumpActivitiesLocked(FileDescriptor fd, PrintWriter pw, boolean dumpAll,
+ boolean dumpClient, String dumpPackage, boolean needSep) {
+
+ if (mTaskHistory.isEmpty()) {
+ return false;
+ }
+ final String prefix = " ";
+ for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
+ final TaskRecord task = mTaskHistory.get(taskNdx);
+ if (needSep) {
+ pw.println("");
+ }
+ pw.println(prefix + "Task id #" + task.taskId);
+ pw.println(prefix + "mBounds=" + task.getOverrideBounds());
+ pw.println(prefix + "mMinWidth=" + task.mMinWidth);
+ pw.println(prefix + "mMinHeight=" + task.mMinHeight);
+ pw.println(prefix + "mLastNonFullscreenBounds=" + task.mLastNonFullscreenBounds);
+ pw.println(prefix + "* " + task);
+ task.dump(pw, prefix + " ");
+ ActivityStackSupervisor.dumpHistoryList(fd, pw, mTaskHistory.get(taskNdx).mActivities,
+ prefix, "Hist", true, !dumpAll, dumpClient, dumpPackage, false, null, task);
+ }
+ return true;
+ }
+
+ ArrayList<ActivityRecord> getDumpActivitiesLocked(String name) {
+ ArrayList<ActivityRecord> activities = new ArrayList<>();
+
+ if ("all".equals(name)) {
+ for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
+ activities.addAll(mTaskHistory.get(taskNdx).mActivities);
+ }
+ } else if ("top".equals(name)) {
+ final int top = mTaskHistory.size() - 1;
+ if (top >= 0) {
+ final ArrayList<ActivityRecord> list = mTaskHistory.get(top).mActivities;
+ int listTop = list.size() - 1;
+ if (listTop >= 0) {
+ activities.add(list.get(listTop));
+ }
+ }
+ } else {
+ ItemMatcher matcher = new ItemMatcher();
+ matcher.build(name);
+
+ for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
+ for (ActivityRecord r1 : mTaskHistory.get(taskNdx).mActivities) {
+ if (matcher.match(r1, r1.intent.getComponent())) {
+ activities.add(r1);
+ }
+ }
+ }
+ }
+
+ return activities;
+ }
+
+ ActivityRecord restartPackage(String packageName) {
+ ActivityRecord starting = topRunningActivityLocked();
+
+ // All activities that came from the package must be
+ // restarted as if there was a config change.
+ for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
+ final ArrayList<ActivityRecord> activities = mTaskHistory.get(taskNdx).mActivities;
+ for (int activityNdx = activities.size() - 1; activityNdx >= 0; --activityNdx) {
+ final ActivityRecord a = activities.get(activityNdx);
+ if (a.info.packageName.equals(packageName)) {
+ a.forceNewConfig = true;
+ if (starting != null && a == starting && a.visible) {
+ a.startFreezingScreenLocked(starting.app,
+ CONFIG_SCREEN_LAYOUT);
+ }
+ }
+ }
+ }
+
+ return starting;
+ }
+
+ /**
+ * Removes the input task from this stack.
+ * @param task to remove.
+ * @param reason for removal.
+ * @param mode task removal mode. Either {@link #REMOVE_TASK_MODE_DESTROYING},
+ * {@link #REMOVE_TASK_MODE_MOVING}, {@link #REMOVE_TASK_MODE_MOVING_TO_TOP}.
+ */
+ void removeTask(TaskRecord task, String reason, int mode) {
+ for (ActivityRecord record : task.mActivities) {
+ onActivityRemovedFromStack(record);
+ }
+
+ final boolean removed = mTaskHistory.remove(task);
+
+ if (removed) {
+ EventLog.writeEvent(EventLogTags.AM_REMOVE_TASK, task.taskId, getStackId());
+ }
+
+ removeActivitiesFromLRUListLocked(task);
+ updateTaskMovement(task, true);
+
+ if (mode == REMOVE_TASK_MODE_DESTROYING && task.mActivities.isEmpty()) {
+ // TODO: VI what about activity?
+ final boolean isVoiceSession = task.voiceSession != null;
+ if (isVoiceSession) {
+ try {
+ task.voiceSession.taskFinished(task.intent, task.taskId);
+ } catch (RemoteException e) {
+ }
+ }
+ if (task.autoRemoveFromRecents() || isVoiceSession) {
+ // Task creator asked to remove this when done, or this task was a voice
+ // interaction, so it should not remain on the recent tasks list.
+ mStackSupervisor.mRecentTasks.remove(task);
+ }
+
+ task.removeWindowContainer();
+ }
+
+ if (mTaskHistory.isEmpty()) {
+ if (DEBUG_STACK) Slog.i(TAG_STACK, "removeTask: removing stack=" + this);
+ // We only need to adjust focused stack if this stack is in focus and we are not in the
+ // process of moving the task to the top of the stack that will be focused.
+ if (mode != REMOVE_TASK_MODE_MOVING_TO_TOP
+ && mStackSupervisor.isTopDisplayFocusedStack(this)) {
+ String myReason = reason + " leftTaskHistoryEmpty";
+ if (!inMultiWindowMode() || adjustFocusToNextFocusableStack(myReason) == null) {
+ getDisplay().moveHomeStackToFront(myReason);
+ }
+ }
+ if (isAttached()) {
+ getDisplay().positionChildAtBottom(this);
+ }
+ if (!isActivityTypeHome() || getDisplay().isRemoved()) {
+ remove();
+ }
+ }
+
+ task.setStack(null);
+
+ // Notify if a task from the pinned stack is being removed (or moved depending on the mode)
+ if (inPinnedWindowingMode()) {
+ mService.getTaskChangeNotificationController().notifyActivityUnpinned();
+ }
+ }
+
+ TaskRecord createTaskRecord(int taskId, ActivityInfo info, Intent intent,
+ IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
+ boolean toTop) {
+ return createTaskRecord(taskId, info, intent, voiceSession, voiceInteractor, toTop,
+ null /*activity*/, null /*source*/, null /*options*/);
+ }
+
+ TaskRecord createTaskRecord(int taskId, ActivityInfo info, Intent intent,
+ IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
+ boolean toTop, ActivityRecord activity, ActivityRecord source,
+ ActivityOptions options) {
+ final TaskRecord task = TaskRecord.create(
+ mService, taskId, info, intent, voiceSession, voiceInteractor);
+ // add the task to stack first, mTaskPositioner might need the stack association
+ addTask(task, toTop, "createTaskRecord");
+ final int displayId = mDisplayId != INVALID_DISPLAY ? mDisplayId : DEFAULT_DISPLAY;
+ final boolean isLockscreenShown = mService.mStackSupervisor.getKeyguardController()
+ .isKeyguardOrAodShowing(displayId);
+ if (!mStackSupervisor.getLaunchParamsController()
+ .layoutTask(task, info.windowLayout, activity, source, options)
+ && !matchParentBounds() && task.isResizeable() && !isLockscreenShown) {
+ task.updateOverrideConfiguration(getOverrideBounds());
+ }
+ task.createWindowContainer(toTop, (info.flags & FLAG_SHOW_FOR_ALL_USERS) != 0);
+ return task;
+ }
+
+ ArrayList<TaskRecord> getAllTasks() {
+ return new ArrayList<>(mTaskHistory);
+ }
+
+ void addTask(final TaskRecord task, final boolean toTop, String reason) {
+ addTask(task, toTop ? MAX_VALUE : 0, true /* schedulePictureInPictureModeChange */, reason);
+ if (toTop) {
+ // TODO: figure-out a way to remove this call.
+ positionChildWindowContainerAtTop(task);
+ }
+ }
+
+ // TODO: This shouldn't allow automatic reparenting. Remove the call to preAddTask and deal
+ // with the fall-out...
+ void addTask(final TaskRecord task, int position, boolean schedulePictureInPictureModeChange,
+ String reason) {
+ // TODO: Is this remove really needed? Need to look into the call path for the other addTask
+ mTaskHistory.remove(task);
+ position = getAdjustedPositionForTask(task, position, null /* starting */);
+ final boolean toTop = position >= mTaskHistory.size();
+ final ActivityStack prevStack = preAddTask(task, reason, toTop);
+
+ mTaskHistory.add(position, task);
+ task.setStack(this);
+
+ updateTaskMovement(task, toTop);
+
+ postAddTask(task, prevStack, schedulePictureInPictureModeChange);
+ }
+
+ void positionChildAt(TaskRecord task, int index) {
+
+ if (task.getStack() != this) {
+ throw new IllegalArgumentException("AS.positionChildAt: task=" + task
+ + " is not a child of stack=" + this + " current parent=" + task.getStack());
+ }
+
+ task.updateOverrideConfigurationForStack(this);
+
+ final ActivityRecord topRunningActivity = task.topRunningActivityLocked();
+ final boolean wasResumed = topRunningActivity == task.getStack().mResumedActivity;
+ insertTaskAtPosition(task, index);
+ task.setStack(this);
+ postAddTask(task, null /* prevStack */, true /* schedulePictureInPictureModeChange */);
+
+ if (wasResumed) {
+ if (mResumedActivity != null) {
+ Log.wtf(TAG, "mResumedActivity was already set when moving mResumedActivity from"
+ + " other stack to this stack mResumedActivity=" + mResumedActivity
+ + " other mResumedActivity=" + topRunningActivity);
+ }
+ topRunningActivity.setState(RESUMED, "positionChildAt");
+ }
+
+ // The task might have already been running and its visibility needs to be synchronized with
+ // the visibility of the stack / windows.
+ ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
+ mStackSupervisor.resumeFocusedStacksTopActivitiesLocked();
+ }
+
+ private ActivityStack preAddTask(TaskRecord task, String reason, boolean toTop) {
+ final ActivityStack prevStack = task.getStack();
+ if (prevStack != null && prevStack != this) {
+ prevStack.removeTask(task, reason,
+ toTop ? REMOVE_TASK_MODE_MOVING_TO_TOP : REMOVE_TASK_MODE_MOVING);
+ }
+ return prevStack;
+ }
+
+ /**
+ * @param schedulePictureInPictureModeChange specifies whether or not to schedule the PiP mode
+ * change. Callers may set this to false if they are explicitly scheduling PiP mode
+ * changes themselves, like during the PiP animation
+ */
+ private void postAddTask(TaskRecord task, ActivityStack prevStack,
+ boolean schedulePictureInPictureModeChange) {
+ if (schedulePictureInPictureModeChange && prevStack != null) {
+ mStackSupervisor.scheduleUpdatePictureInPictureModeIfNeeded(task, prevStack);
+ } else if (task.voiceSession != null) {
+ try {
+ task.voiceSession.taskStarted(task.intent, task.taskId);
+ } catch (RemoteException e) {
+ }
+ }
+ }
+
+ public void setAlwaysOnTop(boolean alwaysOnTop) {
+ if (isAlwaysOnTop() == alwaysOnTop) {
+ return;
+ }
+ super.setAlwaysOnTop(alwaysOnTop);
+ final ActivityDisplay display = getDisplay();
+ // positionChildAtTop() must be called even when always on top gets turned off because we
+ // need to make sure that the stack is moved from among always on top windows to below other
+ // always on top windows. Since the position the stack should be inserted into is calculated
+ // properly in {@link ActivityDisplay#getTopInsertPosition()} in both cases, we can just
+ // request that the stack is put at top here.
+ display.positionChildAtTop(this, false /* includingParents */);
+ }
+
+ /** NOTE: Should only be called from {@link TaskRecord#reparent}. */
+ void moveToFrontAndResumeStateIfNeeded(ActivityRecord r, boolean moveToFront, boolean setResume,
+ boolean setPause, String reason) {
+ if (!moveToFront) {
+ return;
+ }
+
+ final ActivityState origState = r.getState();
+ // If the activity owns the last resumed activity, transfer that together,
+ // so that we don't resume the same activity again in the new stack.
+ // Apps may depend on onResume()/onPause() being called in pairs.
+ if (setResume) {
+ r.setState(RESUMED, "moveToFrontAndResumeStateIfNeeded");
+ updateLRUListLocked(r);
+ }
+ // If the activity was previously pausing, then ensure we transfer that as well
+ if (setPause) {
+ mPausingActivity = r;
+ schedulePauseTimeout(r);
+ }
+ // Move the stack in which we are placing the activity to the front.
+ moveToFront(reason);
+ // If the original state is resumed, there is no state change to update focused app.
+ // So here makes sure the activity focus is set if it is the top.
+ if (origState == RESUMED && r == mStackSupervisor.getTopResumedActivity()) {
+ // TODO(b/111361570): Support multiple focused apps in WM
+ mService.setResumedActivityUncheckLocked(r, reason);
+ }
+ }
+
+ public int getStackId() {
+ return mStackId;
+ }
+
+ @Override
+ public String toString() {
+ return "ActivityStack{" + Integer.toHexString(System.identityHashCode(this))
+ + " stackId=" + mStackId + " type=" + activityTypeToString(getActivityType())
+ + " mode=" + windowingModeToString(getWindowingMode())
+ + " visible=" + shouldBeVisible(null /* starting */)
+ + " translucent=" + isStackTranslucent(null /* starting */)
+ + ", "
+ + mTaskHistory.size() + " tasks}";
+ }
+
+ void onLockTaskPackagesUpdated() {
+ for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
+ mTaskHistory.get(taskNdx).setLockTaskAuth();
+ }
+ }
+
+ void executeAppTransition(ActivityOptions options) {
+ getDisplay().getWindowContainerController().executeAppTransition();
+ ActivityOptions.abort(options);
+ }
+
+ boolean shouldSleepActivities() {
+ final ActivityDisplay display = getDisplay();
+
+ // Do not sleep activities in this stack if we're marked as focused and the keyguard
+ // is in the process of going away.
+ if (isFocusedStackOnDisplay()
+ && mStackSupervisor.getKeyguardController().isKeyguardGoingAway()) {
+ return false;
+ }
+
+ return display != null ? display.isSleeping() : mService.isSleepingLocked();
+ }
+
+ boolean shouldSleepOrShutDownActivities() {
+ return shouldSleepActivities() || mService.mShuttingDown;
+ }
+
+ public void writeToProto(ProtoOutputStream proto, long fieldId) {
+ final long token = proto.start(fieldId);
+ super.writeToProto(proto, CONFIGURATION_CONTAINER, false /* trim */);
+ proto.write(ID, mStackId);
+ for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
+ final TaskRecord task = mTaskHistory.get(taskNdx);
+ task.writeToProto(proto, TASKS);
+ }
+ if (mResumedActivity != null) {
+ mResumedActivity.writeIdentifierToProto(proto, RESUMED_ACTIVITY);
+ }
+ proto.write(DISPLAY_ID, mDisplayId);
+ if (!matchParentBounds()) {
+ final Rect bounds = getOverrideBounds();
+ bounds.writeToProto(proto, BOUNDS);
+ }
+
+ // TODO: Remove, no longer needed with windowingMode.
+ proto.write(FULLSCREEN, matchParentBounds());
+ proto.end(token);
+ }
+}
diff --git a/services/core/java/com/android/server/wm/ActivityStackSupervisor.java b/services/core/java/com/android/server/wm/ActivityStackSupervisor.java
new file mode 100644
index 0000000..77b331e
--- /dev/null
+++ b/services/core/java/com/android/server/wm/ActivityStackSupervisor.java
@@ -0,0 +1,4892 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.server.wm;
+
+import static android.Manifest.permission.ACTIVITY_EMBEDDING;
+import static android.Manifest.permission.INTERNAL_SYSTEM_WINDOW;
+import static android.Manifest.permission.START_ANY_ACTIVITY;
+import static android.app.ActivityManager.LOCK_TASK_MODE_LOCKED;
+import static android.app.ActivityManager.START_DELIVERED_TO_TOP;
+import static android.app.ActivityManager.START_FLAG_DEBUG;
+import static android.app.ActivityManager.START_FLAG_NATIVE_DEBUGGING;
+import static android.app.ActivityManager.START_FLAG_TRACK_ALLOCATION;
+import static android.app.ActivityManager.START_TASK_TO_FRONT;
+import static android.app.ActivityTaskManager.INVALID_STACK_ID;
+import static android.app.ActivityTaskManager.INVALID_TASK_ID;
+import static android.app.ITaskStackListener.FORCED_RESIZEABLE_REASON_SECONDARY_DISPLAY;
+import static android.app.ITaskStackListener.FORCED_RESIZEABLE_REASON_SPLIT_SCREEN;
+import static android.app.WaitResult.INVALID_DELAY;
+import static android.app.WindowConfiguration.ACTIVITY_TYPE_ASSISTANT;
+import static android.app.WindowConfiguration.ACTIVITY_TYPE_HOME;
+import static android.app.WindowConfiguration.ACTIVITY_TYPE_RECENTS;
+import static android.app.WindowConfiguration.ACTIVITY_TYPE_STANDARD;
+import static android.app.WindowConfiguration.ACTIVITY_TYPE_UNDEFINED;
+import static android.app.WindowConfiguration.WINDOWING_MODE_FREEFORM;
+import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN;
+import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN_OR_SPLIT_SCREEN_SECONDARY;
+import static android.app.WindowConfiguration.WINDOWING_MODE_PINNED;
+import static android.app.WindowConfiguration.WINDOWING_MODE_SPLIT_SCREEN_PRIMARY;
+import static android.app.WindowConfiguration.WINDOWING_MODE_SPLIT_SCREEN_SECONDARY;
+import static android.app.WindowConfiguration.WINDOWING_MODE_UNDEFINED;
+import static android.app.WindowConfiguration.activityTypeToString;
+import static android.app.WindowConfiguration.windowingModeToString;
+import static android.content.Intent.FLAG_ACTIVITY_NEW_TASK;
+import static android.content.pm.ActivityInfo.LAUNCH_SINGLE_INSTANCE;
+import static android.content.pm.ActivityInfo.LAUNCH_SINGLE_TASK;
+import static android.content.pm.PackageManager.NOTIFY_PACKAGE_USE_ACTIVITY;
+import static android.content.pm.PackageManager.PERMISSION_DENIED;
+import static android.content.pm.PackageManager.PERMISSION_GRANTED;
+import static android.graphics.Rect.copyOrNull;
+import static android.os.PowerManager.PARTIAL_WAKE_LOCK;
+import static android.os.Process.SYSTEM_UID;
+import static android.os.Trace.TRACE_TAG_ACTIVITY_MANAGER;
+import static android.view.Display.DEFAULT_DISPLAY;
+import static android.view.Display.INVALID_DISPLAY;
+import static android.view.Display.TYPE_VIRTUAL;
+import static android.view.WindowManager.TRANSIT_DOCK_TASK_FROM_RECENTS;
+
+import static com.android.server.wm.ActivityStack.ActivityState.DESTROYED;
+import static com.android.server.wm.ActivityStack.ActivityState.INITIALIZING;
+import static com.android.server.wm.ActivityStack.ActivityState.PAUSED;
+import static com.android.server.wm.ActivityStack.ActivityState.PAUSING;
+import static com.android.server.wm.ActivityStack.ActivityState.RESUMED;
+import static com.android.server.wm.ActivityStack.ActivityState.STOPPED;
+import static com.android.server.wm.ActivityStack.ActivityState.STOPPING;
+import static com.android.server.wm.ActivityStack.REMOVE_TASK_MODE_MOVING;
+import static com.android.server.am.ActivityStackSupervisorProto.CONFIGURATION_CONTAINER;
+import static com.android.server.am.ActivityStackSupervisorProto.DISPLAYS;
+import static com.android.server.am.ActivityStackSupervisorProto.FOCUSED_STACK_ID;
+import static com.android.server.am.ActivityStackSupervisorProto.IS_HOME_RECENTS_COMPONENT;
+import static com.android.server.am.ActivityStackSupervisorProto.KEYGUARD_CONTROLLER;
+import static com.android.server.am.ActivityStackSupervisorProto.PENDING_ACTIVITIES;
+import static com.android.server.am.ActivityStackSupervisorProto.RESUMED_ACTIVITY;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_ALL;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_IDLE;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_PAUSE;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_RECENTS;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_RELEASE;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_STACK;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_STATES;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_SWITCH;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_TASKS;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_IDLE;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_PAUSE;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_RECENTS;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_RELEASE;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_STACK;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_STATES;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_SWITCH;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_TASKS;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_ATM;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_WITH_CLASS_NAME;
+import static com.android.server.wm.ActivityTaskManagerService.ANIMATE;
+import static com.android.server.wm.ActivityTaskManagerService.H.FIRST_SUPERVISOR_STACK_MSG;
+import static com.android.server.wm.ActivityTaskManagerService.RELAUNCH_REASON_NONE;
+import static com.android.server.wm.TaskRecord.LOCK_TASK_AUTH_LAUNCHABLE;
+import static com.android.server.wm.TaskRecord.LOCK_TASK_AUTH_LAUNCHABLE_PRIV;
+import static com.android.server.wm.TaskRecord.LOCK_TASK_AUTH_WHITELISTED;
+import static com.android.server.wm.TaskRecord.REPARENT_KEEP_STACK_AT_FRONT;
+import static com.android.server.wm.TaskRecord.REPARENT_LEAVE_STACK_IN_PLACE;
+import static com.android.server.wm.TaskRecord.REPARENT_MOVE_STACK_TO_FRONT;
+
+import static java.lang.Integer.MAX_VALUE;
+
+import android.Manifest;
+import android.annotation.IntDef;
+import android.annotation.NonNull;
+import android.annotation.Nullable;
+import android.annotation.UserIdInt;
+import android.app.Activity;
+import android.app.ActivityManager;
+import android.app.ActivityManager.RunningTaskInfo;
+import android.app.ActivityManager.StackInfo;
+import android.app.ActivityManagerInternal;
+import android.app.ActivityOptions;
+import android.app.AppGlobals;
+import android.app.AppOpsManager;
+import android.app.ProfilerInfo;
+import android.app.ResultInfo;
+import android.app.WaitResult;
+import android.app.WindowConfiguration.ActivityType;
+import android.app.WindowConfiguration.WindowingMode;
+import android.app.servertransaction.ActivityLifecycleItem;
+import android.app.servertransaction.ClientTransaction;
+import android.app.servertransaction.LaunchActivityItem;
+import android.app.servertransaction.PauseActivityItem;
+import android.app.servertransaction.ResumeActivityItem;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.ActivityInfo;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+import android.content.pm.ResolveInfo;
+import android.content.pm.UserInfo;
+import android.content.res.Configuration;
+import android.content.res.Resources;
+import android.graphics.Rect;
+import android.hardware.display.DisplayManager;
+import android.hardware.display.DisplayManager.DisplayListener;
+import android.hardware.display.DisplayManagerInternal;
+import android.hardware.power.V1_0.PowerHint;
+import android.os.Binder;
+import android.os.Bundle;
+import android.os.Debug;
+import android.os.FactoryTest;
+import android.os.Handler;
+import android.os.IBinder;
+import android.os.Looper;
+import android.os.Message;
+import android.os.PowerManager;
+import android.os.Process;
+import android.os.RemoteException;
+import android.os.SystemClock;
+import android.os.Trace;
+import android.os.UserHandle;
+import android.os.UserManager;
+import android.os.WorkSource;
+import android.provider.MediaStore;
+import android.service.voice.IVoiceInteractionSession;
+import android.util.ArrayMap;
+import android.util.ArraySet;
+import android.util.DisplayMetrics;
+import android.util.EventLog;
+import android.util.IntArray;
+import android.util.MergedConfiguration;
+import android.util.Slog;
+import android.util.SparseArray;
+import android.util.SparseIntArray;
+import android.util.TimeUtils;
+import android.util.proto.ProtoOutputStream;
+import android.view.Display;
+
+import com.android.internal.annotations.GuardedBy;
+import com.android.internal.annotations.VisibleForTesting;
+import com.android.internal.content.ReferrerIntent;
+import com.android.internal.os.TransferPipe;
+import com.android.internal.os.logging.MetricsLoggerWrapper;
+import com.android.internal.util.ArrayUtils;
+import com.android.internal.util.function.pooled.PooledLambda;
+import com.android.server.LocalServices;
+import com.android.server.am.ActivityManagerService;
+import com.android.server.am.AppTimeTracker;
+import com.android.server.am.EventLogTags;
+import com.android.server.am.UserState;
+import com.android.server.wm.ActivityStack.ActivityState;
+import com.android.server.wm.ActivityTaskManagerInternal.SleepToken;
+
+import java.io.FileDescriptor;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+
+public class ActivityStackSupervisor extends ConfigurationContainer implements DisplayListener,
+ RecentTasks.Callbacks, RootWindowContainerListener {
+ private static final String TAG = TAG_WITH_CLASS_NAME ? "ActivityStackSupervisor" : TAG_ATM;
+ private static final String TAG_IDLE = TAG + POSTFIX_IDLE;
+ private static final String TAG_PAUSE = TAG + POSTFIX_PAUSE;
+ private static final String TAG_RECENTS = TAG + POSTFIX_RECENTS;
+ private static final String TAG_RELEASE = TAG + POSTFIX_RELEASE;
+ private static final String TAG_STACK = TAG + POSTFIX_STACK;
+ private static final String TAG_SWITCH = TAG + POSTFIX_SWITCH;
+ static final String TAG_STATES = TAG + POSTFIX_STATES;
+ static final String TAG_TASKS = TAG + POSTFIX_TASKS;
+
+ /** How long we wait until giving up on the last activity telling us it is idle. */
+ static final int IDLE_TIMEOUT = 10 * 1000;
+
+ /** How long we can hold the sleep wake lock before giving up. */
+ static final int SLEEP_TIMEOUT = 5 * 1000;
+
+ // How long we can hold the launch wake lock before giving up.
+ static final int LAUNCH_TIMEOUT = 10 * 1000;
+
+ static final int IDLE_TIMEOUT_MSG = FIRST_SUPERVISOR_STACK_MSG;
+ static final int IDLE_NOW_MSG = FIRST_SUPERVISOR_STACK_MSG + 1;
+ static final int RESUME_TOP_ACTIVITY_MSG = FIRST_SUPERVISOR_STACK_MSG + 2;
+ static final int SLEEP_TIMEOUT_MSG = FIRST_SUPERVISOR_STACK_MSG + 3;
+ static final int LAUNCH_TIMEOUT_MSG = FIRST_SUPERVISOR_STACK_MSG + 4;
+ static final int LAUNCH_TASK_BEHIND_COMPLETE = FIRST_SUPERVISOR_STACK_MSG + 12;
+ static final int REPORT_MULTI_WINDOW_MODE_CHANGED_MSG = FIRST_SUPERVISOR_STACK_MSG + 14;
+ static final int REPORT_PIP_MODE_CHANGED_MSG = FIRST_SUPERVISOR_STACK_MSG + 15;
+
+ private static final String VIRTUAL_DISPLAY_BASE_NAME = "ActivityViewVirtualDisplay";
+
+ // Used to indicate if an object (e.g. stack) that we are trying to get
+ // should be created if it doesn't exist already.
+ static final boolean CREATE_IF_NEEDED = true;
+
+ // Used to indicate that windows of activities should be preserved during the resize.
+ static final boolean PRESERVE_WINDOWS = true;
+
+ // Used to indicate if an object (e.g. task) should be moved/created
+ // at the top of its container (e.g. stack).
+ static final boolean ON_TOP = true;
+
+ // Don't execute any calls to resume.
+ static final boolean DEFER_RESUME = true;
+
+ // Used to indicate that a task is removed it should also be removed from recents.
+ static final boolean REMOVE_FROM_RECENTS = true;
+
+ // Used to indicate that pausing an activity should occur immediately without waiting for
+ // the activity callback indicating that it has completed pausing
+ static final boolean PAUSE_IMMEDIATELY = true;
+
+ /** True if the docked stack is currently being resized. */
+ private boolean mDockedStackResizing;
+
+ /**
+ * True if there are pending docked bounds that need to be applied after
+ * {@link #mDockedStackResizing} is reset to false.
+ */
+ private boolean mHasPendingDockedBounds;
+ private Rect mPendingDockedBounds;
+ private Rect mPendingTempDockedTaskBounds;
+ private Rect mPendingTempDockedTaskInsetBounds;
+ private Rect mPendingTempOtherTaskBounds;
+ private Rect mPendingTempOtherTaskInsetBounds;
+
+ /**
+ * The modes which affect which tasks are returned when calling
+ * {@link ActivityStackSupervisor#anyTaskForIdLocked(int)}.
+ */
+ @Retention(RetentionPolicy.SOURCE)
+ @IntDef({
+ MATCH_TASK_IN_STACKS_ONLY,
+ MATCH_TASK_IN_STACKS_OR_RECENT_TASKS,
+ MATCH_TASK_IN_STACKS_OR_RECENT_TASKS_AND_RESTORE
+ })
+ public @interface AnyTaskForIdMatchTaskMode {}
+ // Match only tasks in the current stacks
+ static final int MATCH_TASK_IN_STACKS_ONLY = 0;
+ // Match either tasks in the current stacks, or in the recent tasks if not found in the stacks
+ static final int MATCH_TASK_IN_STACKS_OR_RECENT_TASKS = 1;
+ // Match either tasks in the current stacks, or in the recent tasks, restoring it to the
+ // provided stack id
+ static final int MATCH_TASK_IN_STACKS_OR_RECENT_TASKS_AND_RESTORE = 2;
+
+ // Activity actions an app cannot start if it uses a permission which is not granted.
+ private static final ArrayMap<String, String> ACTION_TO_RUNTIME_PERMISSION =
+ new ArrayMap<>();
+
+ static {
+ ACTION_TO_RUNTIME_PERMISSION.put(MediaStore.ACTION_IMAGE_CAPTURE,
+ Manifest.permission.CAMERA);
+ ACTION_TO_RUNTIME_PERMISSION.put(MediaStore.ACTION_VIDEO_CAPTURE,
+ Manifest.permission.CAMERA);
+ ACTION_TO_RUNTIME_PERMISSION.put(Intent.ACTION_CALL,
+ Manifest.permission.CALL_PHONE);
+ }
+
+ /** Action restriction: launching the activity is not restricted. */
+ private static final int ACTIVITY_RESTRICTION_NONE = 0;
+ /** Action restriction: launching the activity is restricted by a permission. */
+ private static final int ACTIVITY_RESTRICTION_PERMISSION = 1;
+ /** Action restriction: launching the activity is restricted by an app op. */
+ private static final int ACTIVITY_RESTRICTION_APPOP = 2;
+
+ // For debugging to make sure the caller when acquiring/releasing our
+ // wake lock is the system process.
+ static final boolean VALIDATE_WAKE_LOCK_CALLER = false;
+ /** The number of distinct task ids that can be assigned to the tasks of a single user */
+ private static final int MAX_TASK_IDS_PER_USER = UserHandle.PER_USER_RANGE;
+
+ ActivityTaskManagerService mService;
+
+ /** The historial list of recent tasks including inactive tasks */
+ RecentTasks mRecentTasks;
+
+ /** Helper class to abstract out logic for fetching the set of currently running tasks */
+ private RunningTasks mRunningTasks;
+
+ final ActivityStackSupervisorHandler mHandler;
+ final Looper mLooper;
+
+ /** Short cut */
+ WindowManagerService mWindowManager;
+ DisplayManager mDisplayManager;
+
+ private LaunchParamsController mLaunchParamsController;
+
+ /**
+ * Maps the task identifier that activities are currently being started in to the userId of the
+ * task. Each time a new task is created, the entry for the userId of the task is incremented
+ */
+ private final SparseIntArray mCurTaskIdForUser = new SparseIntArray(20);
+
+ /** The current user */
+ int mCurrentUser;
+
+ /** List of activities that are waiting for a new activity to become visible before completing
+ * whatever operation they are supposed to do. */
+ // TODO: Remove mActivitiesWaitingForVisibleActivity list and just remove activity from
+ // mStoppingActivities when something else comes up.
+ final ArrayList<ActivityRecord> mActivitiesWaitingForVisibleActivity = new ArrayList<>();
+
+ /** List of processes waiting to find out when a specific activity becomes visible. */
+ private final ArrayList<WaitInfo> mWaitingForActivityVisible = new ArrayList<>();
+
+ /** List of processes waiting to find out about the next launched activity. */
+ final ArrayList<WaitResult> mWaitingActivityLaunched = new ArrayList<>();
+
+ /** List of activities that are ready to be stopped, but waiting for the next activity to
+ * settle down before doing so. */
+ final ArrayList<ActivityRecord> mStoppingActivities = new ArrayList<>();
+
+ /** List of activities that are ready to be finished, but waiting for the previous activity to
+ * settle down before doing so. It contains ActivityRecord objects. */
+ final ArrayList<ActivityRecord> mFinishingActivities = new ArrayList<>();
+
+ /** List of activities that are in the process of going to sleep. */
+ final ArrayList<ActivityRecord> mGoingToSleepActivities = new ArrayList<>();
+
+ /** List of activities whose multi-window mode changed that we need to report to the
+ * application */
+ final ArrayList<ActivityRecord> mMultiWindowModeChangedActivities = new ArrayList<>();
+
+ /** List of activities whose picture-in-picture mode changed that we need to report to the
+ * application */
+ final ArrayList<ActivityRecord> mPipModeChangedActivities = new ArrayList<>();
+
+ /**
+ * Animations that for the current transition have requested not to
+ * be considered for the transition animation.
+ */
+ final ArrayList<ActivityRecord> mNoAnimActivities = new ArrayList<>();
+
+ /** The target stack bounds for the picture-in-picture mode changed that we need to report to
+ * the application */
+ Rect mPipModeChangedTargetStackBounds;
+
+ /** Used on user changes */
+ final ArrayList<UserState> mStartingUsers = new ArrayList<>();
+
+ /** Set to indicate whether to issue an onUserLeaving callback when a newly launched activity
+ * is being brought in front of us. */
+ boolean mUserLeaving = false;
+
+ /** Set when a power hint has started, but not ended. */
+ private boolean mPowerHintSent;
+
+ /**
+ * We don't want to allow the device to go to sleep while in the process
+ * of launching an activity. This is primarily to allow alarm intent
+ * receivers to launch an activity and get that to run before the device
+ * goes back to sleep.
+ */
+ PowerManager.WakeLock mLaunchingActivity;
+
+ /**
+ * Set when the system is going to sleep, until we have
+ * successfully paused the current activity and released our wake lock.
+ * At that point the system is allowed to actually sleep.
+ */
+ PowerManager.WakeLock mGoingToSleep;
+
+ /**
+ * A list of tokens that cause the top activity to be put to sleep.
+ * They are used by components that may hide and block interaction with underlying
+ * activities.
+ */
+ final ArrayList<SleepToken> mSleepTokens = new ArrayList<>();
+
+ /** Stack id of the front stack when user switched, indexed by userId. */
+ SparseIntArray mUserStackInFront = new SparseIntArray(2);
+
+ /** Reference to default display so we can quickly look it up. */
+ private ActivityDisplay mDefaultDisplay;
+
+ /**
+ * List of displays which contain activities, sorted by z-order.
+ * The last entry in the list is the topmost.
+ */
+ private final ArrayList<ActivityDisplay> mActivityDisplays = new ArrayList<>();
+
+ private final SparseArray<IntArray> mDisplayAccessUIDs = new SparseArray<>();
+
+ private DisplayManagerInternal mDisplayManagerInternal;
+
+ /** Used to keep resumeTopActivityUncheckedLocked() from being entered recursively */
+ boolean inResumeTopActivity;
+
+ /**
+ * Temporary rect used during docked stack resize calculation so we don't need to create a new
+ * object each time.
+ */
+ private final Rect tempRect = new Rect();
+ private final ActivityOptions mTmpOptions = ActivityOptions.makeBasic();
+
+ // The default minimal size that will be used if the activity doesn't specify its minimal size.
+ // It will be calculated when the default display gets added.
+ int mDefaultMinSizeOfResizeableTaskDp = -1;
+
+ // Whether tasks have moved and we need to rank the tasks before next OOM scoring
+ private boolean mTaskLayersChanged = true;
+
+ private ActivityMetricsLogger mActivityMetricsLogger;
+
+ private final ArrayList<ActivityRecord> mTmpActivityList = new ArrayList<>();
+
+ @Override
+ protected int getChildCount() {
+ return mActivityDisplays.size();
+ }
+
+ @Override
+ protected ActivityDisplay getChildAt(int index) {
+ return mActivityDisplays.get(index);
+ }
+
+ @Override
+ protected ConfigurationContainer getParent() {
+ return null;
+ }
+
+ Configuration getDisplayOverrideConfiguration(int displayId) {
+ final ActivityDisplay activityDisplay = getActivityDisplayOrCreateLocked(displayId);
+ if (activityDisplay == null) {
+ throw new IllegalArgumentException("No display found with id: " + displayId);
+ }
+
+ return activityDisplay.getOverrideConfiguration();
+ }
+
+ void setDisplayOverrideConfiguration(Configuration overrideConfiguration, int displayId) {
+ final ActivityDisplay activityDisplay = getActivityDisplayOrCreateLocked(displayId);
+ if (activityDisplay == null) {
+ throw new IllegalArgumentException("No display found with id: " + displayId);
+ }
+
+ activityDisplay.onOverrideConfigurationChanged(overrideConfiguration);
+ }
+
+ /** Check if placing task or activity on specified display is allowed. */
+ boolean canPlaceEntityOnDisplay(int displayId, int callingPid, int callingUid,
+ ActivityInfo activityInfo) {
+ if (displayId == DEFAULT_DISPLAY) {
+ // No restrictions for the default display.
+ return true;
+ }
+ if (!mService.mSupportsMultiDisplay) {
+ // Can't launch on secondary displays if feature is not supported.
+ return false;
+ }
+ if (!isCallerAllowedToLaunchOnDisplay(callingPid, callingUid, displayId, activityInfo)) {
+ // Can't place activities to a display that has restricted launch rules.
+ // In this case the request should be made by explicitly adding target display id and
+ // by caller with corresponding permissions. See #isCallerAllowedToLaunchOnDisplay().
+ return false;
+ }
+ return true;
+ }
+
+ /**
+ * Check if configuration of specified display matches current global config.
+ * Used to check if we can put a non-resizeable activity on a secondary display and it will get
+ * the same config as on the default display.
+ * @param displayId Id of the display to check.
+ * @return {@code true} if configuration matches.
+ */
+ private boolean displayConfigMatchesGlobal(int displayId) {
+ if (displayId == DEFAULT_DISPLAY) {
+ return true;
+ }
+ if (displayId == INVALID_DISPLAY) {
+ return false;
+ }
+ final ActivityDisplay targetDisplay = getActivityDisplayOrCreateLocked(displayId);
+ if (targetDisplay == null) {
+ throw new IllegalArgumentException("No display found with id: " + displayId);
+ }
+ return getConfiguration().equals(targetDisplay.getConfiguration());
+ }
+
+ static class FindTaskResult {
+ ActivityRecord mRecord;
+ boolean mIdealMatch;
+
+ void clear() {
+ mRecord = null;
+ mIdealMatch = false;
+ }
+
+ void setTo(FindTaskResult result) {
+ mRecord = result.mRecord;
+ mIdealMatch = result.mIdealMatch;
+ }
+ }
+
+ private final FindTaskResult mTmpFindTaskResult = new FindTaskResult();
+
+ /**
+ * Used to keep track whether app visibilities got changed since the last pause. Useful to
+ * determine whether to invoke the task stack change listener after pausing.
+ */
+ boolean mAppVisibilitiesChangedSinceLastPause;
+
+ /**
+ * Set of tasks that are in resizing mode during an app transition to fill the "void".
+ */
+ private final ArraySet<Integer> mResizingTasksDuringAnimation = new ArraySet<>();
+
+
+ /**
+ * If set to {@code false} all calls to resize the docked stack {@link #resizeDockedStackLocked}
+ * will be ignored. Useful for the case where the caller is handling resizing of other stack and
+ * moving tasks around and doesn't want dock stack to be resized due to an automatic trigger
+ * like the docked stack going empty.
+ */
+ private boolean mAllowDockedStackResize = true;
+
+ /**
+ * Is dock currently minimized.
+ */
+ boolean mIsDockMinimized;
+
+ private KeyguardController mKeyguardController;
+
+ private PowerManager mPowerManager;
+ private int mDeferResumeCount;
+
+ private boolean mInitialized;
+
+ private RootWindowContainerController mWindowContainerController;
+
+ /**
+ * Description of a request to start a new activity, which has been held
+ * due to app switches being disabled.
+ */
+ static class PendingActivityLaunch {
+ final ActivityRecord r;
+ final ActivityRecord sourceRecord;
+ final int startFlags;
+ final ActivityStack stack;
+ final WindowProcessController callerApp;
+
+ PendingActivityLaunch(ActivityRecord _r, ActivityRecord _sourceRecord,
+ int _startFlags, ActivityStack _stack, WindowProcessController app) {
+ r = _r;
+ sourceRecord = _sourceRecord;
+ startFlags = _startFlags;
+ stack = _stack;
+ callerApp = app;
+ }
+
+ void sendErrorResult(String message) {
+ try {
+ if (callerApp.hasThread()) {
+ callerApp.getThread().scheduleCrash(message);
+ }
+ } catch (RemoteException e) {
+ Slog.e(TAG, "Exception scheduling crash of failed "
+ + "activity launcher sourceRecord=" + sourceRecord, e);
+ }
+ }
+ }
+
+ public ActivityStackSupervisor(ActivityTaskManagerService service, Looper looper) {
+ mService = service;
+ mLooper = looper;
+ mHandler = new ActivityStackSupervisorHandler(looper);
+ }
+
+ @VisibleForTesting
+ void setService(ActivityTaskManagerService service) {
+ mService = service;
+ }
+
+ @VisibleForTesting
+ void setWindowContainerController(RootWindowContainerController controller) {
+ mWindowContainerController = controller;
+ }
+
+ public void initialize() {
+ if (mInitialized) {
+ return;
+ }
+
+ mInitialized = true;
+ mRunningTasks = createRunningTasks();
+ mActivityMetricsLogger = new ActivityMetricsLogger(this, mService.mContext, mHandler.getLooper());
+ mKeyguardController = new KeyguardController(mService, this);
+
+ mLaunchParamsController = new LaunchParamsController(mService);
+ mLaunchParamsController.registerDefaultModifiers(this);
+ }
+
+
+ public ActivityMetricsLogger getActivityMetricsLogger() {
+ return mActivityMetricsLogger;
+ }
+
+ public KeyguardController getKeyguardController() {
+ return mKeyguardController;
+ }
+
+ void setRecentTasks(RecentTasks recentTasks) {
+ mRecentTasks = recentTasks;
+ mRecentTasks.registerCallback(this);
+ }
+
+ @VisibleForTesting
+ RunningTasks createRunningTasks() {
+ return new RunningTasks();
+ }
+
+ /**
+ * At the time when the constructor runs, the power manager has not yet been
+ * initialized. So we initialize our wakelocks afterwards.
+ */
+ void initPowerManagement() {
+ mPowerManager = (PowerManager)mService.mContext.getSystemService(Context.POWER_SERVICE);
+ mGoingToSleep = mPowerManager
+ .newWakeLock(PARTIAL_WAKE_LOCK, "ActivityManager-Sleep");
+ mLaunchingActivity = mPowerManager.newWakeLock(PARTIAL_WAKE_LOCK, "*launch*");
+ mLaunchingActivity.setReferenceCounted(false);
+ }
+
+ void setWindowManager(WindowManagerService wm) {
+ mWindowManager = wm;
+ getKeyguardController().setWindowManager(wm);
+ setWindowContainerController(new RootWindowContainerController(this));
+
+ mDisplayManager = mService.mContext.getSystemService(DisplayManager.class);
+ mDisplayManager.registerDisplayListener(this, mHandler);
+ mDisplayManagerInternal = LocalServices.getService(DisplayManagerInternal.class);
+
+ final Display[] displays = mDisplayManager.getDisplays();
+ for (int displayNdx = 0; displayNdx < displays.length; ++displayNdx) {
+ final Display display = displays[displayNdx];
+ final ActivityDisplay activityDisplay = new ActivityDisplay(this, display);
+ if (activityDisplay.mDisplayId == DEFAULT_DISPLAY) {
+ mDefaultDisplay = activityDisplay;
+ }
+ addChild(activityDisplay, ActivityDisplay.POSITION_TOP);
+ }
+ calculateDefaultMinimalSizeOfResizeableTasks();
+
+ final ActivityDisplay defaultDisplay = getDefaultDisplay();
+
+ defaultDisplay.getOrCreateStack(WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_HOME, ON_TOP);
+ positionChildAt(defaultDisplay, ActivityDisplay.POSITION_TOP);
+ }
+
+ /** Change the z-order of the given display. */
+ private void positionChildAt(ActivityDisplay display, int position) {
+ if (position >= mActivityDisplays.size()) {
+ position = mActivityDisplays.size() - 1;
+ } else if (position < 0) {
+ position = 0;
+ }
+
+ if (mActivityDisplays.isEmpty()) {
+ mActivityDisplays.add(display);
+ } else if (mActivityDisplays.get(position) != display) {
+ mActivityDisplays.remove(display);
+ mActivityDisplays.add(position, display);
+ }
+ }
+
+ @Override
+ public void onChildPositionChanged(DisplayWindowController childController, int position) {
+ // Assume AM lock is held from positionChildAt of controller in each hierarchy.
+ final ActivityDisplay display = getActivityDisplay(childController.getDisplayId());
+ if (display != null) {
+ positionChildAt(display, position);
+ }
+ }
+
+ ActivityStack getTopDisplayFocusedStack() {
+ for (int i = mActivityDisplays.size() - 1; i >= 0; --i) {
+ final ActivityStack focusedStack = mActivityDisplays.get(i).getFocusedStack();
+ if (focusedStack != null) {
+ return focusedStack;
+ }
+ }
+ return null;
+ }
+
+ ActivityRecord getTopResumedActivity() {
+ final ActivityStack focusedStack = getTopDisplayFocusedStack();
+ if (focusedStack == null) {
+ return null;
+ }
+ final ActivityRecord resumedActivity = focusedStack.getResumedActivity();
+ if (resumedActivity != null && resumedActivity.app != null) {
+ return resumedActivity;
+ }
+ // The top focused stack might not have a resumed activity yet - look on all displays in
+ // focus order.
+ for (int i = mActivityDisplays.size() - 1; i >= 0; --i) {
+ final ActivityDisplay display = mActivityDisplays.get(i);
+ final ActivityRecord resumedActivityOnDisplay = display.getResumedActivity();
+ if (resumedActivityOnDisplay != null) {
+ return resumedActivityOnDisplay;
+ }
+ }
+ return null;
+ }
+
+ boolean isFocusable(ConfigurationContainer container, boolean alwaysFocusable) {
+ if (container.inSplitScreenPrimaryWindowingMode() && mIsDockMinimized) {
+ return false;
+ }
+
+ return container.getWindowConfiguration().canReceiveKeys() || alwaysFocusable;
+ }
+
+ boolean isTopDisplayFocusedStack(ActivityStack stack) {
+ return stack != null && stack == getTopDisplayFocusedStack();
+ }
+
+ void moveRecentsStackToFront(String reason) {
+ final ActivityStack recentsStack = getDefaultDisplay().getStack(
+ WINDOWING_MODE_UNDEFINED, ACTIVITY_TYPE_RECENTS);
+ if (recentsStack != null) {
+ recentsStack.moveToFront(reason);
+ }
+ }
+
+ boolean resumeHomeActivity(ActivityRecord prev, String reason, int displayId) {
+ if (!mService.isBooting() && !mService.isBooted()) {
+ // Not ready yet!
+ return false;
+ }
+
+ if (displayId == INVALID_DISPLAY) {
+ displayId = DEFAULT_DISPLAY;
+ }
+
+ final ActivityRecord r = getActivityDisplay(displayId).getHomeActivity();
+ final String myReason = reason + " resumeHomeActivity";
+
+ // Only resume home activity if isn't finishing.
+ if (r != null && !r.finishing) {
+ r.moveFocusableActivityToTop(myReason);
+ return resumeFocusedStacksTopActivitiesLocked(r.getStack(), prev, null);
+ }
+ return startHomeOnDisplay(mCurrentUser, myReason, displayId);
+ }
+
+ boolean canStartHomeOnDisplay(ActivityInfo homeInfo, int displayId) {
+ if (mService.mFactoryTest == FactoryTest.FACTORY_TEST_LOW_LEVEL
+ && mService.mTopAction == null) {
+ // We are running in factory test mode, but unable to find the factory test app, so
+ // just sit around displaying the error message and don't try to start anything.
+ return false;
+ }
+
+ final WindowProcessController app =
+ mService.getProcessController(homeInfo.processName, homeInfo.applicationInfo.uid);
+ if (app != null && app.isInstrumenting()) {
+ // Don't do this if the home app is currently being instrumented.
+ return false;
+ }
+
+ if (displayId == DEFAULT_DISPLAY || (displayId != INVALID_DISPLAY
+ && displayId == mService.mVr2dDisplayId)) {
+ // No restrictions to default display or vr 2d display.
+ return true;
+ }
+
+ final ActivityDisplay display = getActivityDisplay(displayId);
+ if (display == null || display.isRemoved() || !display.supportsSystemDecorations()) {
+ // Can't launch home on display that doesn't support system decorations.
+ return false;
+ }
+
+ final boolean supportMultipleInstance = homeInfo.launchMode != LAUNCH_SINGLE_TASK
+ && homeInfo.launchMode != LAUNCH_SINGLE_INSTANCE;
+ if (!supportMultipleInstance) {
+ // Can't launch home on other displays if it requested to be single instance.
+ return false;
+ }
+
+ return true;
+ }
+
+ TaskRecord anyTaskForIdLocked(int id) {
+ return anyTaskForIdLocked(id, MATCH_TASK_IN_STACKS_OR_RECENT_TASKS_AND_RESTORE);
+ }
+
+ TaskRecord anyTaskForIdLocked(int id, @AnyTaskForIdMatchTaskMode int matchMode) {
+ return anyTaskForIdLocked(id, matchMode, null, !ON_TOP);
+ }
+
+ /**
+ * Returns a {@link TaskRecord} for the input id if available. {@code null} otherwise.
+ * @param id Id of the task we would like returned.
+ * @param matchMode The mode to match the given task id in.
+ * @param aOptions The activity options to use for restoration. Can be null.
+ * @param onTop If the stack for the task should be the topmost on the display.
+ */
+ TaskRecord anyTaskForIdLocked(int id, @AnyTaskForIdMatchTaskMode int matchMode,
+ @Nullable ActivityOptions aOptions, boolean onTop) {
+ // If options are set, ensure that we are attempting to actually restore a task
+ if (matchMode != MATCH_TASK_IN_STACKS_OR_RECENT_TASKS_AND_RESTORE && aOptions != null) {
+ throw new IllegalArgumentException("Should not specify activity options for non-restore"
+ + " lookup");
+ }
+
+ int numDisplays = mActivityDisplays.size();
+ for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
+ final ActivityDisplay display = mActivityDisplays.get(displayNdx);
+ for (int stackNdx = display.getChildCount() - 1; stackNdx >= 0; --stackNdx) {
+ final ActivityStack stack = display.getChildAt(stackNdx);
+ final TaskRecord task = stack.taskForIdLocked(id);
+ if (task == null) {
+ continue;
+ }
+ if (aOptions != null) {
+ // Resolve the stack the task should be placed in now based on options
+ // and reparent if needed.
+ final ActivityStack launchStack = getLaunchStack(null, aOptions, task, onTop);
+ if (launchStack != null && stack != launchStack) {
+ final int reparentMode = onTop
+ ? REPARENT_MOVE_STACK_TO_FRONT : REPARENT_LEAVE_STACK_IN_PLACE;
+ task.reparent(launchStack, onTop, reparentMode, ANIMATE, DEFER_RESUME,
+ "anyTaskForIdLocked");
+ }
+ }
+ return task;
+ }
+ }
+
+ // If we are matching stack tasks only, return now
+ if (matchMode == MATCH_TASK_IN_STACKS_ONLY) {
+ return null;
+ }
+
+ // Otherwise, check the recent tasks and return if we find it there and we are not restoring
+ // the task from recents
+ if (DEBUG_RECENTS) Slog.v(TAG_RECENTS, "Looking for task id=" + id + " in recents");
+ final TaskRecord task = mRecentTasks.getTask(id);
+
+ if (task == null) {
+ if (DEBUG_RECENTS) {
+ Slog.d(TAG_RECENTS, "\tDidn't find task id=" + id + " in recents");
+ }
+
+ return null;
+ }
+
+ if (matchMode == MATCH_TASK_IN_STACKS_OR_RECENT_TASKS) {
+ return task;
+ }
+
+ // Implicitly, this case is MATCH_TASK_IN_STACKS_OR_RECENT_TASKS_AND_RESTORE
+ if (!restoreRecentTaskLocked(task, aOptions, onTop)) {
+ if (DEBUG_RECENTS) Slog.w(TAG_RECENTS,
+ "Couldn't restore task id=" + id + " found in recents");
+ return null;
+ }
+ if (DEBUG_RECENTS) Slog.w(TAG_RECENTS, "Restored task id=" + id + " from in recents");
+ return task;
+ }
+
+ ActivityRecord isInAnyStackLocked(IBinder token) {
+ int numDisplays = mActivityDisplays.size();
+ for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
+ final ActivityDisplay display = mActivityDisplays.get(displayNdx);
+ for (int stackNdx = display.getChildCount() - 1; stackNdx >= 0; --stackNdx) {
+ final ActivityStack stack = display.getChildAt(stackNdx);
+ final ActivityRecord r = stack.isInStackLocked(token);
+ if (r != null) {
+ return r;
+ }
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Detects whether we should show a lock screen in front of this task for a locked user.
+ * <p>
+ * We'll do this if either of the following holds:
+ * <ul>
+ * <li>The top activity explicitly belongs to {@param userId}.</li>
+ * <li>The top activity returns a result to an activity belonging to {@param userId}.</li>
+ * </ul>
+ *
+ * @return {@code true} if the top activity looks like it belongs to {@param userId}.
+ */
+ private boolean taskTopActivityIsUser(TaskRecord task, @UserIdInt int userId) {
+ // To handle the case that work app is in the task but just is not the top one.
+ final ActivityRecord activityRecord = task.getTopActivity();
+ final ActivityRecord resultTo = (activityRecord != null ? activityRecord.resultTo : null);
+
+ return (activityRecord != null && activityRecord.userId == userId)
+ || (resultTo != null && resultTo.userId == userId);
+ }
+
+ /**
+ * Find all visible task stacks containing {@param userId} and intercept them with an activity
+ * to block out the contents and possibly start a credential-confirming intent.
+ *
+ * @param userId user handle for the locked managed profile.
+ */
+ void lockAllProfileTasks(@UserIdInt int userId) {
+ mWindowManager.deferSurfaceLayout();
+ try {
+ for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
+ final ActivityDisplay display = mActivityDisplays.get(displayNdx);
+ for (int stackNdx = display.getChildCount() - 1; stackNdx >= 0; --stackNdx) {
+ final ActivityStack stack = display.getChildAt(stackNdx);
+ final List<TaskRecord> tasks = stack.getAllTasks();
+ for (int taskNdx = tasks.size() - 1; taskNdx >= 0; taskNdx--) {
+ final TaskRecord task = tasks.get(taskNdx);
+
+ // Check the task for a top activity belonging to userId, or returning a
+ // result to an activity belonging to userId. Example case: a document
+ // picker for personal files, opened by a work app, should still get locked.
+ if (taskTopActivityIsUser(task, userId)) {
+ mService.getTaskChangeNotificationController().notifyTaskProfileLocked(
+ task.taskId, userId);
+ }
+ }
+ }
+ }
+ } finally {
+ mWindowManager.continueSurfaceLayout();
+ }
+ }
+
+ void setNextTaskIdForUserLocked(int taskId, int userId) {
+ final int currentTaskId = mCurTaskIdForUser.get(userId, -1);
+ if (taskId > currentTaskId) {
+ mCurTaskIdForUser.put(userId, taskId);
+ }
+ }
+
+ static int nextTaskIdForUser(int taskId, int userId) {
+ int nextTaskId = taskId + 1;
+ if (nextTaskId == (userId + 1) * MAX_TASK_IDS_PER_USER) {
+ // Wrap around as there will be smaller task ids that are available now.
+ nextTaskId -= MAX_TASK_IDS_PER_USER;
+ }
+ return nextTaskId;
+ }
+
+ int getNextTaskIdForUserLocked(int userId) {
+ final int currentTaskId = mCurTaskIdForUser.get(userId, userId * MAX_TASK_IDS_PER_USER);
+ // for a userId u, a taskId can only be in the range
+ // [u*MAX_TASK_IDS_PER_USER, (u+1)*MAX_TASK_IDS_PER_USER-1], so if MAX_TASK_IDS_PER_USER
+ // was 10, user 0 could only have taskIds 0 to 9, user 1: 10 to 19, user 2: 20 to 29, so on.
+ int candidateTaskId = nextTaskIdForUser(currentTaskId, userId);
+ while (mRecentTasks.containsTaskId(candidateTaskId, userId)
+ || anyTaskForIdLocked(
+ candidateTaskId, MATCH_TASK_IN_STACKS_OR_RECENT_TASKS) != null) {
+ candidateTaskId = nextTaskIdForUser(candidateTaskId, userId);
+ if (candidateTaskId == currentTaskId) {
+ // Something wrong!
+ // All MAX_TASK_IDS_PER_USER task ids are taken up by running tasks for this user
+ throw new IllegalStateException("Cannot get an available task id."
+ + " Reached limit of " + MAX_TASK_IDS_PER_USER
+ + " running tasks per user.");
+ }
+ }
+ mCurTaskIdForUser.put(userId, candidateTaskId);
+ return candidateTaskId;
+ }
+
+ boolean attachApplicationLocked(WindowProcessController app) throws RemoteException {
+ final String processName = app.mName;
+ boolean didSomething = false;
+ for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
+ final ActivityDisplay display = mActivityDisplays.get(displayNdx);
+ for (int stackNdx = display.getChildCount() - 1; stackNdx >= 0; --stackNdx) {
+ final ActivityStack stack = display.getChildAt(stackNdx);
+ if (!isTopDisplayFocusedStack(stack)) {
+ continue;
+ }
+ stack.getAllRunningVisibleActivitiesLocked(mTmpActivityList);
+ final ActivityRecord top = stack.topRunningActivityLocked();
+ final int size = mTmpActivityList.size();
+ for (int i = 0; i < size; i++) {
+ final ActivityRecord activity = mTmpActivityList.get(i);
+ if (activity.app == null && app.mUid == activity.info.applicationInfo.uid
+ && processName.equals(activity.processName)) {
+ try {
+ if (realStartActivityLocked(activity, app,
+ top == activity /* andResume */, true /* checkConfig */)) {
+ didSomething = true;
+ }
+ } catch (RemoteException e) {
+ Slog.w(TAG, "Exception in new application when starting activity "
+ + top.intent.getComponent().flattenToShortString(), e);
+ throw e;
+ }
+ }
+ }
+ }
+ }
+ if (!didSomething) {
+ ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
+ }
+ return didSomething;
+ }
+
+ boolean allResumedActivitiesIdle() {
+ for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
+ final ActivityDisplay display = mActivityDisplays.get(displayNdx);
+ for (int stackNdx = display.getChildCount() - 1; stackNdx >= 0; --stackNdx) {
+ // We cannot only check the top stack on each display since there might have
+ // always-on-top stacks (e.g. pinned stack).
+ final ActivityStack stack = display.getChildAt(stackNdx);
+ if (stack.numActivities() == 0) {
+ continue;
+ }
+ final ActivityRecord resumedActivity = stack.getResumedActivity();
+ if (resumedActivity != null && !resumedActivity.idle) {
+ if (DEBUG_STATES) Slog.d(TAG_STATES, "allResumedActivitiesIdle: stack="
+ + stack.mStackId + " " + resumedActivity + " not idle");
+ return false;
+ }
+ }
+ }
+ // Send launch end powerhint when idle
+ sendPowerHintForLaunchEndIfNeeded();
+ return true;
+ }
+
+ private boolean allResumedActivitiesVisible() {
+ boolean foundResumed = false;
+ for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
+ final ActivityDisplay display = mActivityDisplays.get(displayNdx);
+ for (int stackNdx = display.getChildCount() - 1; stackNdx >= 0; --stackNdx) {
+ final ActivityStack stack = display.getChildAt(stackNdx);
+ final ActivityRecord r = stack.getResumedActivity();
+ if (r != null) {
+ if (!r.nowVisible || mActivitiesWaitingForVisibleActivity.contains(r)) {
+ return false;
+ }
+ foundResumed = true;
+ }
+ }
+ }
+ return foundResumed;
+ }
+
+ private void executeAppTransitionForAllDisplay() {
+ for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
+ final ActivityDisplay display = mActivityDisplays.get(displayNdx);
+ display.getWindowContainerController().executeAppTransition();
+ }
+ }
+
+ /**
+ * Pause all activities in either all of the stacks or just the back stacks.
+ * @param userLeaving Passed to pauseActivity() to indicate whether to call onUserLeaving().
+ * @param resuming The resuming activity.
+ * @param dontWait The resuming activity isn't going to wait for all activities to be paused
+ * before resuming.
+ * @return true if any activity was paused as a result of this call.
+ */
+ boolean pauseBackStacks(boolean userLeaving, ActivityRecord resuming, boolean dontWait) {
+ boolean someActivityPaused = false;
+ for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
+ someActivityPaused |= mActivityDisplays.get(displayNdx)
+ .pauseBackStacks(userLeaving, resuming, dontWait);
+ }
+ return someActivityPaused;
+ }
+
+ boolean allPausedActivitiesComplete() {
+ boolean pausing = true;
+ for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
+ final ActivityDisplay display = mActivityDisplays.get(displayNdx);
+ for (int stackNdx = display.getChildCount() - 1; stackNdx >= 0; --stackNdx) {
+ final ActivityStack stack = display.getChildAt(stackNdx);
+ final ActivityRecord r = stack.mPausingActivity;
+ if (r != null && !r.isState(PAUSED, STOPPED, STOPPING)) {
+ if (DEBUG_STATES) {
+ Slog.d(TAG_STATES,
+ "allPausedActivitiesComplete: r=" + r + " state=" + r.getState());
+ pausing = false;
+ } else {
+ return false;
+ }
+ }
+ }
+ }
+ return pausing;
+ }
+
+ void cancelInitializingActivities() {
+ for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
+ final ActivityDisplay display = mActivityDisplays.get(displayNdx);
+ for (int stackNdx = display.getChildCount() - 1; stackNdx >= 0; --stackNdx) {
+ final ActivityStack stack = display.getChildAt(stackNdx);
+ stack.cancelInitializingActivities();
+ }
+ }
+ }
+
+ void waitActivityVisible(ComponentName name, WaitResult result, long startTimeMs) {
+ final WaitInfo waitInfo = new WaitInfo(name, result, startTimeMs);
+ mWaitingForActivityVisible.add(waitInfo);
+ }
+
+ void cleanupActivity(ActivityRecord r) {
+ // Make sure this record is no longer in the pending finishes list.
+ // This could happen, for example, if we are trimming activities
+ // down to the max limit while they are still waiting to finish.
+ mFinishingActivities.remove(r);
+ mActivitiesWaitingForVisibleActivity.remove(r);
+
+ for (int i = mWaitingForActivityVisible.size() - 1; i >= 0; --i) {
+ if (mWaitingForActivityVisible.get(i).matches(r.realActivity)) {
+ mWaitingForActivityVisible.remove(i);
+ }
+ }
+ }
+
+ void reportActivityVisibleLocked(ActivityRecord r) {
+ sendWaitingVisibleReportLocked(r);
+ }
+
+ void sendWaitingVisibleReportLocked(ActivityRecord r) {
+ boolean changed = false;
+ for (int i = mWaitingForActivityVisible.size() - 1; i >= 0; --i) {
+ final WaitInfo w = mWaitingForActivityVisible.get(i);
+ if (w.matches(r.realActivity)) {
+ final WaitResult result = w.getResult();
+ changed = true;
+ result.timeout = false;
+ result.who = w.getComponent();
+ result.totalTime = SystemClock.uptimeMillis() - w.getStartTime();
+ mWaitingForActivityVisible.remove(w);
+ }
+ }
+ if (changed) {
+ mService.mGlobalLock.notifyAll();
+ }
+ }
+
+ void reportWaitingActivityLaunchedIfNeeded(ActivityRecord r, int result) {
+ if (mWaitingActivityLaunched.isEmpty()) {
+ return;
+ }
+
+ if (result != START_DELIVERED_TO_TOP && result != START_TASK_TO_FRONT) {
+ return;
+ }
+
+ boolean changed = false;
+
+ for (int i = mWaitingActivityLaunched.size() - 1; i >= 0; i--) {
+ WaitResult w = mWaitingActivityLaunched.remove(i);
+ if (w.who == null) {
+ changed = true;
+ w.result = result;
+
+ // Unlike START_TASK_TO_FRONT, When an intent is delivered to top, there
+ // will be no followup launch signals. Assign the result and launched component.
+ if (result == START_DELIVERED_TO_TOP) {
+ w.who = r.realActivity;
+ }
+ }
+ }
+
+ if (changed) {
+ mService.mGlobalLock.notifyAll();
+ }
+ }
+
+ void reportActivityLaunchedLocked(boolean timeout, ActivityRecord r, long totalTime) {
+ boolean changed = false;
+ for (int i = mWaitingActivityLaunched.size() - 1; i >= 0; i--) {
+ WaitResult w = mWaitingActivityLaunched.remove(i);
+ if (w.who == null) {
+ changed = true;
+ w.timeout = timeout;
+ if (r != null) {
+ w.who = new ComponentName(r.info.packageName, r.info.name);
+ }
+ w.totalTime = totalTime;
+ // Do not modify w.result.
+ }
+ }
+ if (changed) {
+ mService.mGlobalLock.notifyAll();
+ }
+ }
+
+ ActivityRecord topRunningActivityLocked() {
+ for (int i = mActivityDisplays.size() - 1; i >= 0; --i) {
+ final ActivityRecord topActivity = mActivityDisplays.get(i).topRunningActivity();
+ if (topActivity != null) {
+ return topActivity;
+ }
+ }
+ return null;
+ }
+
+ @VisibleForTesting
+ void getRunningTasks(int maxNum, List<RunningTaskInfo> list,
+ @ActivityType int ignoreActivityType, @WindowingMode int ignoreWindowingMode,
+ int callingUid, boolean allowed) {
+ mRunningTasks.getTasks(maxNum, list, ignoreActivityType, ignoreWindowingMode,
+ mActivityDisplays, callingUid, allowed);
+ }
+
+ ActivityInfo resolveActivity(Intent intent, ResolveInfo rInfo, int startFlags,
+ ProfilerInfo profilerInfo) {
+ final ActivityInfo aInfo = rInfo != null ? rInfo.activityInfo : null;
+ if (aInfo != null) {
+ // Store the found target back into the intent, because now that
+ // we have it we never want to do this again. For example, if the
+ // user navigates back to this point in the history, we should
+ // always restart the exact same activity.
+ intent.setComponent(new ComponentName(
+ aInfo.applicationInfo.packageName, aInfo.name));
+
+ // Don't debug things in the system process
+ if (!aInfo.processName.equals("system")) {
+ if ((startFlags & (START_FLAG_DEBUG | START_FLAG_NATIVE_DEBUGGING
+ | START_FLAG_TRACK_ALLOCATION)) != 0 || profilerInfo != null) {
+ /**
+ * Assume safe to call into AMS synchronously because the call that set these
+ * flags should have originated from AMS which will already have its lock held.
+ * @see ActivityManagerService#startActivityAndWait(IApplicationThread, String,
+ * Intent, String, IBinder, String, int, int, ProfilerInfo, Bundle, int)
+ * TODO(b/80414790): Investigate a better way of untangling this.
+ */
+ mService.mAmInternal.setDebugFlagsForStartingActivity(
+ aInfo, startFlags, profilerInfo);
+ }
+ }
+ final String intentLaunchToken = intent.getLaunchToken();
+ if (aInfo.launchToken == null && intentLaunchToken != null) {
+ aInfo.launchToken = intentLaunchToken;
+ }
+ }
+ return aInfo;
+ }
+
+ ResolveInfo resolveIntent(Intent intent, String resolvedType, int userId, int flags,
+ int filterCallingUid) {
+ synchronized (mService.mGlobalLock) {
+ try {
+ Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "resolveIntent");
+ int modifiedFlags = flags
+ | PackageManager.MATCH_DEFAULT_ONLY | ActivityManagerService.STOCK_PM_FLAGS;
+ if (intent.isWebIntent()
+ || (intent.getFlags() & Intent.FLAG_ACTIVITY_MATCH_EXTERNAL) != 0) {
+ modifiedFlags |= PackageManager.MATCH_INSTANT;
+ }
+
+ // In order to allow cross-profile lookup, we clear the calling identity here.
+ // Note the binder identity won't affect the result, but filterCallingUid will.
+
+ // Cross-user/profile call check are done at the entry points
+ // (e.g. AMS.startActivityAsUser).
+ final long token = Binder.clearCallingIdentity();
+ try {
+ return mService.getPackageManagerInternalLocked().resolveIntent(
+ intent, resolvedType, modifiedFlags, userId, true, filterCallingUid);
+ } finally {
+ Binder.restoreCallingIdentity(token);
+ }
+ } finally {
+ Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
+ }
+ }
+ }
+
+ ActivityInfo resolveActivity(Intent intent, String resolvedType, int startFlags,
+ ProfilerInfo profilerInfo, int userId, int filterCallingUid) {
+ final ResolveInfo rInfo = resolveIntent(intent, resolvedType, userId, 0, filterCallingUid);
+ return resolveActivity(intent, rInfo, startFlags, profilerInfo);
+ }
+
+ private boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,
+ boolean andResume, boolean checkConfig) throws RemoteException {
+
+ if (!allPausedActivitiesComplete()) {
+ // While there are activities pausing we skipping starting any new activities until
+ // pauses are complete. NOTE: that we also do this for activities that are starting in
+ // the paused state because they will first be resumed then paused on the client side.
+ if (DEBUG_SWITCH || DEBUG_PAUSE || DEBUG_STATES) Slog.v(TAG_PAUSE,
+ "realStartActivityLocked: Skipping start of r=" + r
+ + " some activities pausing...");
+ return false;
+ }
+
+ final TaskRecord task = r.getTask();
+ final ActivityStack stack = task.getStack();
+
+ beginDeferResume();
+
+ try {
+ r.startFreezingScreenLocked(proc, 0);
+
+ // schedule launch ticks to collect information about slow apps.
+ r.startLaunchTickingLocked();
+
+ r.setProcess(proc);
+
+ if (getKeyguardController().isKeyguardLocked()) {
+ r.notifyUnknownVisibilityLaunched();
+ }
+
+ // Have the window manager re-evaluate the orientation of the screen based on the new
+ // activity order. Note that as a result of this, it can call back into the activity
+ // manager with a new orientation. We don't care about that, because the activity is
+ // not currently running so we are just restarting it anyway.
+ if (checkConfig) {
+ // Deferring resume here because we're going to launch new activity shortly.
+ // We don't want to perform a redundant launch of the same record while ensuring
+ // configurations and trying to resume top activity of focused stack.
+ ensureVisibilityAndConfig(r, r.getDisplayId(),
+ false /* markFrozenIfConfigChanged */, true /* deferResume */);
+ }
+
+ if (r.getStack().checkKeyguardVisibility(r, true /* shouldBeVisible */,
+ true /* isTop */)) {
+ // We only set the visibility to true if the activity is allowed to be visible
+ // based on
+ // keyguard state. This avoids setting this into motion in window manager that is
+ // later cancelled due to later calls to ensure visible activities that set
+ // visibility back to false.
+ r.setVisibility(true);
+ }
+
+ final int applicationInfoUid =
+ (r.info.applicationInfo != null) ? r.info.applicationInfo.uid : -1;
+ if ((r.userId != proc.mUserId) || (r.appInfo.uid != applicationInfoUid)) {
+ Slog.wtf(TAG,
+ "User ID for activity changing for " + r
+ + " appInfo.uid=" + r.appInfo.uid
+ + " info.ai.uid=" + applicationInfoUid
+ + " old=" + r.app + " new=" + proc);
+ }
+
+ proc.clearWaitingToKill();
+ r.launchCount++;
+ r.lastLaunchTime = SystemClock.uptimeMillis();
+
+ if (DEBUG_ALL) Slog.v(TAG, "Launching: " + r);
+
+ proc.addActivityIfNeeded(r);
+ proc.updateProcessInfo(false, true, true, true);
+
+ final LockTaskController lockTaskController = mService.getLockTaskController();
+ if (task.mLockTaskAuth == LOCK_TASK_AUTH_LAUNCHABLE
+ || task.mLockTaskAuth == LOCK_TASK_AUTH_LAUNCHABLE_PRIV
+ || (task.mLockTaskAuth == LOCK_TASK_AUTH_WHITELISTED
+ && lockTaskController.getLockTaskModeState()
+ == LOCK_TASK_MODE_LOCKED)) {
+ lockTaskController.startLockTaskMode(task, false, 0 /* blank UID */);
+ }
+
+ try {
+ if (!proc.hasThread()) {
+ throw new RemoteException();
+ }
+ List<ResultInfo> results = null;
+ List<ReferrerIntent> newIntents = null;
+ if (andResume) {
+ // We don't need to deliver new intents and/or set results if activity is going
+ // to pause immediately after launch.
+ results = r.results;
+ newIntents = r.newIntents;
+ }
+ if (DEBUG_SWITCH) Slog.v(TAG_SWITCH,
+ "Launching: " + r + " icicle=" + r.icicle + " with results=" + results
+ + " newIntents=" + newIntents + " andResume=" + andResume);
+ EventLog.writeEvent(EventLogTags.AM_RESTART_ACTIVITY, r.userId,
+ System.identityHashCode(r), task.taskId, r.shortComponentName);
+ if (r.isActivityTypeHome()) {
+ // Home process is the root process of the task.
+ mService.mHomeProcess = task.mActivities.get(0).app;
+ }
+ mService.getPackageManagerInternalLocked().notifyPackageUse(
+ r.intent.getComponent().getPackageName(), NOTIFY_PACKAGE_USE_ACTIVITY);
+ r.sleeping = false;
+ r.forceNewConfig = false;
+ mService.getAppWarningsLocked().onStartActivity(r);
+ r.compat = mService.compatibilityInfoForPackageLocked(r.info.applicationInfo);
+ ProfilerInfo profilerInfo = proc.onStartActivity(mService.mTopProcessState);
+
+ // Because we could be starting an Activity in the system process this may not go
+ // across a Binder interface which would create a new Configuration. Consequently
+ // we have to always create a new Configuration here.
+
+ final MergedConfiguration mergedConfiguration = new MergedConfiguration(
+ proc.getConfiguration(), r.getMergedOverrideConfiguration());
+ r.setLastReportedConfiguration(mergedConfiguration);
+
+ logIfTransactionTooLarge(r.intent, r.icicle);
+
+
+ // Create activity launch transaction.
+ final ClientTransaction clientTransaction = ClientTransaction.obtain(
+ proc.getThread(), r.appToken);
+
+ final DisplayWindowController dwc = r.getDisplay().getWindowContainerController();
+ clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),
+ System.identityHashCode(r), r.info,
+ // TODO: Have this take the merged configuration instead of separate global
+ // and override configs.
+ mergedConfiguration.getGlobalConfiguration(),
+ mergedConfiguration.getOverrideConfiguration(), r.compat,
+ r.launchedFromPackage, task.voiceInteractor, proc.getReportedProcState(),
+ r.icicle, r.persistentState, results, newIntents,
+ dwc.isNextTransitionForward(), profilerInfo));
+
+ // Set desired final state.
+ final ActivityLifecycleItem lifecycleItem;
+ if (andResume) {
+ lifecycleItem = ResumeActivityItem.obtain(dwc.isNextTransitionForward());
+ } else {
+ lifecycleItem = PauseActivityItem.obtain();
+ }
+ clientTransaction.setLifecycleStateRequest(lifecycleItem);
+
+ // Schedule transaction.
+ mService.getLifecycleManager().scheduleTransaction(clientTransaction);
+
+ if ((proc.mInfo.privateFlags & ApplicationInfo.PRIVATE_FLAG_CANT_SAVE_STATE) != 0
+ && mService.mHasHeavyWeightFeature) {
+ // This may be a heavy-weight process! Note that the package manager will ensure
+ // that only activity can run in the main process of the .apk, which is the only
+ // thing that will be considered heavy-weight.
+ if (proc.mName.equals(proc.mInfo.packageName)) {
+ if (mService.mHeavyWeightProcess != null
+ && mService.mHeavyWeightProcess != proc) {
+ Slog.w(TAG, "Starting new heavy weight process " + proc
+ + " when already running "
+ + mService.mHeavyWeightProcess);
+ }
+ mService.setHeavyWeightProcess(r);
+ }
+ }
+
+ } catch (RemoteException e) {
+ if (r.launchFailed) {
+ // This is the second time we failed -- finish activity and give up.
+ Slog.e(TAG, "Second failure launching "
+ + r.intent.getComponent().flattenToShortString() + ", giving up", e);
+ proc.appDied();
+ stack.requestFinishActivityLocked(r.appToken, Activity.RESULT_CANCELED, null,
+ "2nd-crash", false);
+ return false;
+ }
+
+ // This is the first time we failed -- restart process and
+ // retry.
+ r.launchFailed = true;
+ proc.removeActivity(r);
+ throw e;
+ }
+ } finally {
+ endDeferResume();
+ }
+
+ r.launchFailed = false;
+ if (stack.updateLRUListLocked(r)) {
+ Slog.w(TAG, "Activity " + r + " being launched, but already in LRU list");
+ }
+
+ // TODO(lifecycler): Resume or pause requests are done as part of launch transaction,
+ // so updating the state should be done accordingly.
+ if (andResume && readyToResume()) {
+ // As part of the process of launching, ActivityThread also performs
+ // a resume.
+ stack.minimalResumeActivityLocked(r);
+ } else {
+ // This activity is not starting in the resumed state... which should look like we asked
+ // it to pause+stop (but remain visible), and it has done so and reported back the
+ // current icicle and other state.
+ if (DEBUG_STATES) Slog.v(TAG_STATES,
+ "Moving to PAUSED: " + r + " (starting in paused state)");
+ r.setState(PAUSED, "realStartActivityLocked");
+ }
+
+ // Launch the new version setup screen if needed. We do this -after-
+ // launching the initial activity (that is, home), so that it can have
+ // a chance to initialize itself while in the background, making the
+ // switch back to it faster and look better.
+ if (isTopDisplayFocusedStack(stack)) {
+ mService.getActivityStartController().startSetupActivity();
+ }
+
+ // Update any services we are bound to that might care about whether
+ // their client may have activities.
+ if (r.app != null) {
+ r.app.updateServiceConnectionActivities();
+ }
+
+ return true;
+ }
+
+ /**
+ * Ensure all activities visibility, update orientation and configuration.
+ *
+ * @param starting The currently starting activity or {@code null} if there is none.
+ * @param displayId The id of the display where operation is executed.
+ * @param markFrozenIfConfigChanged Whether to set {@link ActivityRecord#frozenBeforeDestroy} to
+ * {@code true} if config changed.
+ * @param deferResume Whether to defer resume while updating config.
+ * @return 'true' if starting activity was kept or wasn't provided, 'false' if it was relaunched
+ * because of configuration update.
+ */
+ boolean ensureVisibilityAndConfig(ActivityRecord starting, int displayId,
+ boolean markFrozenIfConfigChanged, boolean deferResume) {
+ // First ensure visibility without updating the config just yet. We need this to know what
+ // activities are affecting configuration now.
+ // Passing null here for 'starting' param value, so that visibility of actual starting
+ // activity will be properly updated.
+ ensureActivitiesVisibleLocked(null /* starting */, 0 /* configChanges */,
+ false /* preserveWindows */, false /* notifyClients */);
+
+ if (displayId == INVALID_DISPLAY) {
+ // The caller didn't provide a valid display id, skip updating config.
+ return true;
+ }
+
+ // Force-update the orientation from the WindowManager, since we need the true configuration
+ // to send to the client now.
+ final Configuration config = mWindowManager.updateOrientationFromAppTokens(
+ getDisplayOverrideConfiguration(displayId),
+ starting != null && starting.mayFreezeScreenLocked(starting.app)
+ ? starting.appToken : null,
+ displayId, true /* forceUpdate */);
+ if (starting != null && markFrozenIfConfigChanged && config != null) {
+ starting.frozenBeforeDestroy = true;
+ }
+
+ // Update the configuration of the activities on the display.
+ return mService.updateDisplayOverrideConfigurationLocked(config, starting, deferResume,
+ displayId);
+ }
+
+ private void logIfTransactionTooLarge(Intent intent, Bundle icicle) {
+ int extrasSize = 0;
+ if (intent != null) {
+ final Bundle extras = intent.getExtras();
+ if (extras != null) {
+ extrasSize = extras.getSize();
+ }
+ }
+ int icicleSize = (icicle == null ? 0 : icicle.getSize());
+ if (extrasSize + icicleSize > 200000) {
+ Slog.e(TAG, "Transaction too large, intent: " + intent + ", extras size: " + extrasSize
+ + ", icicle size: " + icicleSize);
+ }
+ }
+
+ void startSpecificActivityLocked(ActivityRecord r, boolean andResume, boolean checkConfig) {
+ // Is this activity's application already running?
+ final WindowProcessController wpc =
+ mService.getProcessController(r.processName, r.info.applicationInfo.uid);
+
+ if (wpc != null && wpc.hasThread()) {
+ try {
+ if ((r.info.flags & ActivityInfo.FLAG_MULTIPROCESS) == 0
+ || !"android".equals(r.info.packageName)) {
+ // Don't add this if it is a platform component that is marked to run in
+ // multiple processes, because this is actually part of the framework so doesn't
+ // make sense to track as a separate apk in the process.
+ wpc.addPackage(r.info.packageName, r.info.applicationInfo.longVersionCode);
+ }
+ realStartActivityLocked(r, wpc, andResume, checkConfig);
+ return;
+ } catch (RemoteException e) {
+ Slog.w(TAG, "Exception when starting activity "
+ + r.intent.getComponent().flattenToShortString(), e);
+ }
+
+ // If a dead object exception was thrown -- fall through to
+ // restart the application.
+ }
+
+ // Post message to start process to avoid possible deadlock of calling into AMS with the
+ // ATMS lock held.
+ final Message msg = PooledLambda.obtainMessage(
+ ActivityManagerInternal::startProcess, mService.mAmInternal, r.processName,
+ r.info.applicationInfo, true, "activity", r.intent.getComponent());
+ mService.mH.sendMessage(msg);
+ }
+
+ void sendPowerHintForLaunchStartIfNeeded(boolean forceSend, ActivityRecord targetActivity) {
+ boolean sendHint = forceSend;
+
+ if (!sendHint) {
+ // Send power hint if we don't know what we're launching yet
+ sendHint = targetActivity == null || targetActivity.app == null;
+ }
+
+ if (!sendHint) { // targetActivity != null
+ // Send power hint when the activity's process is different than the current resumed
+ // activity on all displays, or if there are no resumed activities in the system.
+ boolean noResumedActivities = true;
+ boolean allFocusedProcessesDiffer = true;
+ for (int displayNdx = 0; displayNdx < mActivityDisplays.size(); ++displayNdx) {
+ final ActivityDisplay activityDisplay = mActivityDisplays.get(displayNdx);
+ final ActivityRecord resumedActivity = activityDisplay.getResumedActivity();
+ final WindowProcessController resumedActivityProcess =
+ resumedActivity == null ? null : resumedActivity.app;
+
+ noResumedActivities &= resumedActivityProcess == null;
+ if (resumedActivityProcess != null) {
+ allFocusedProcessesDiffer &= !resumedActivityProcess.equals(targetActivity.app);
+ }
+ }
+ sendHint = noResumedActivities || allFocusedProcessesDiffer;
+ }
+
+ if (sendHint && mService.mPowerManagerInternal != null) {
+ mService.mPowerManagerInternal.powerHint(PowerHint.LAUNCH, 1);
+ mPowerHintSent = true;
+ }
+ }
+
+ void sendPowerHintForLaunchEndIfNeeded() {
+ // Trigger launch power hint if activity is launched
+ if (mPowerHintSent && mService.mPowerManagerInternal != null) {
+ mService.mPowerManagerInternal.powerHint(PowerHint.LAUNCH, 0);
+ mPowerHintSent = false;
+ }
+ }
+
+ boolean checkStartAnyActivityPermission(Intent intent, ActivityInfo aInfo, String resultWho,
+ int requestCode, int callingPid, int callingUid, String callingPackage,
+ boolean ignoreTargetSecurity, boolean launchingInTask,
+ WindowProcessController callerApp, ActivityRecord resultRecord,
+ ActivityStack resultStack) {
+ final boolean isCallerRecents = mService.getRecentTasks() != null
+ && mService.getRecentTasks().isCallerRecents(callingUid);
+ final int startAnyPerm = mService.checkPermission(START_ANY_ACTIVITY, callingPid,
+ callingUid);
+ if (startAnyPerm == PERMISSION_GRANTED || (isCallerRecents && launchingInTask)) {
+ // If the caller has START_ANY_ACTIVITY, ignore all checks below. In addition, if the
+ // caller is the recents component and we are specifically starting an activity in an
+ // existing task, then also allow the activity to be fully relaunched.
+ return true;
+ }
+ final int componentRestriction = getComponentRestrictionForCallingPackage(
+ aInfo, callingPackage, callingPid, callingUid, ignoreTargetSecurity);
+ final int actionRestriction = getActionRestrictionForCallingPackage(
+ intent.getAction(), callingPackage, callingPid, callingUid);
+ if (componentRestriction == ACTIVITY_RESTRICTION_PERMISSION
+ || actionRestriction == ACTIVITY_RESTRICTION_PERMISSION) {
+ if (resultRecord != null) {
+ resultStack.sendActivityResultLocked(-1,
+ resultRecord, resultWho, requestCode,
+ Activity.RESULT_CANCELED, null);
+ }
+ final String msg;
+ if (actionRestriction == ACTIVITY_RESTRICTION_PERMISSION) {
+ msg = "Permission Denial: starting " + intent.toString()
+ + " from " + callerApp + " (pid=" + callingPid
+ + ", uid=" + callingUid + ")" + " with revoked permission "
+ + ACTION_TO_RUNTIME_PERMISSION.get(intent.getAction());
+ } else if (!aInfo.exported) {
+ msg = "Permission Denial: starting " + intent.toString()
+ + " from " + callerApp + " (pid=" + callingPid
+ + ", uid=" + callingUid + ")"
+ + " not exported from uid " + aInfo.applicationInfo.uid;
+ } else {
+ msg = "Permission Denial: starting " + intent.toString()
+ + " from " + callerApp + " (pid=" + callingPid
+ + ", uid=" + callingUid + ")"
+ + " requires " + aInfo.permission;
+ }
+ Slog.w(TAG, msg);
+ throw new SecurityException(msg);
+ }
+
+ if (actionRestriction == ACTIVITY_RESTRICTION_APPOP) {
+ final String message = "Appop Denial: starting " + intent.toString()
+ + " from " + callerApp + " (pid=" + callingPid
+ + ", uid=" + callingUid + ")"
+ + " requires " + AppOpsManager.permissionToOp(
+ ACTION_TO_RUNTIME_PERMISSION.get(intent.getAction()));
+ Slog.w(TAG, message);
+ return false;
+ } else if (componentRestriction == ACTIVITY_RESTRICTION_APPOP) {
+ final String message = "Appop Denial: starting " + intent.toString()
+ + " from " + callerApp + " (pid=" + callingPid
+ + ", uid=" + callingUid + ")"
+ + " requires appop " + AppOpsManager.permissionToOp(aInfo.permission);
+ Slog.w(TAG, message);
+ return false;
+ }
+
+ return true;
+ }
+
+ /** Check if caller is allowed to launch activities on specified display. */
+ boolean isCallerAllowedToLaunchOnDisplay(int callingPid, int callingUid, int launchDisplayId,
+ ActivityInfo aInfo) {
+ if (DEBUG_TASKS) Slog.d(TAG, "Launch on display check: displayId=" + launchDisplayId
+ + " callingPid=" + callingPid + " callingUid=" + callingUid);
+
+ if (callingPid == -1 && callingUid == -1) {
+ if (DEBUG_TASKS) Slog.d(TAG, "Launch on display check: no caller info, skip check");
+ return true;
+ }
+
+ final ActivityDisplay activityDisplay = getActivityDisplayOrCreateLocked(launchDisplayId);
+ if (activityDisplay == null || activityDisplay.isRemoved()) {
+ Slog.w(TAG, "Launch on display check: display not found");
+ return false;
+ }
+
+ // Check if the caller has enough privileges to embed activities and launch to private
+ // displays.
+ final int startAnyPerm = mService.checkPermission(INTERNAL_SYSTEM_WINDOW, callingPid,
+ callingUid);
+ if (startAnyPerm == PERMISSION_GRANTED) {
+ if (DEBUG_TASKS) Slog.d(TAG, "Launch on display check:"
+ + " allow launch any on display");
+ return true;
+ }
+
+ // Check if caller is already present on display
+ final boolean uidPresentOnDisplay = activityDisplay.isUidPresent(callingUid);
+
+ final int displayOwnerUid = activityDisplay.mDisplay.getOwnerUid();
+ if (activityDisplay.mDisplay.getType() == TYPE_VIRTUAL && displayOwnerUid != SYSTEM_UID
+ && displayOwnerUid != aInfo.applicationInfo.uid) {
+ // Limit launching on virtual displays, because their contents can be read from Surface
+ // by apps that created them.
+ if ((aInfo.flags & ActivityInfo.FLAG_ALLOW_EMBEDDED) == 0) {
+ if (DEBUG_TASKS) Slog.d(TAG, "Launch on display check:"
+ + " disallow launch on virtual display for not-embedded activity.");
+ return false;
+ }
+ // Check if the caller is allowed to embed activities from other apps.
+ if (mService.checkPermission(ACTIVITY_EMBEDDING, callingPid, callingUid)
+ == PERMISSION_DENIED && !uidPresentOnDisplay) {
+ if (DEBUG_TASKS) Slog.d(TAG, "Launch on display check:"
+ + " disallow activity embedding without permission.");
+ return false;
+ }
+ }
+
+ if (!activityDisplay.isPrivate()) {
+ // Anyone can launch on a public display.
+ if (DEBUG_TASKS) Slog.d(TAG, "Launch on display check:"
+ + " allow launch on public display");
+ return true;
+ }
+
+ // Check if the caller is the owner of the display.
+ if (displayOwnerUid == callingUid) {
+ if (DEBUG_TASKS) Slog.d(TAG, "Launch on display check:"
+ + " allow launch for owner of the display");
+ return true;
+ }
+
+ if (uidPresentOnDisplay) {
+ if (DEBUG_TASKS) Slog.d(TAG, "Launch on display check:"
+ + " allow launch for caller present on the display");
+ return true;
+ }
+
+ Slog.w(TAG, "Launch on display check: denied");
+ return false;
+ }
+
+ /** Update lists of UIDs that are present on displays and have access to them. */
+ void updateUIDsPresentOnDisplay() {
+ mDisplayAccessUIDs.clear();
+ for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
+ final ActivityDisplay activityDisplay = mActivityDisplays.get(displayNdx);
+ // Only bother calculating the whitelist for private displays
+ if (activityDisplay.isPrivate()) {
+ mDisplayAccessUIDs.append(
+ activityDisplay.mDisplayId, activityDisplay.getPresentUIDs());
+ }
+ }
+ // Store updated lists in DisplayManager. Callers from outside of AM should get them there.
+ mDisplayManagerInternal.setDisplayAccessUIDs(mDisplayAccessUIDs);
+ }
+
+ UserInfo getUserInfo(int userId) {
+ final long identity = Binder.clearCallingIdentity();
+ try {
+ return UserManager.get(mService.mContext).getUserInfo(userId);
+ } finally {
+ Binder.restoreCallingIdentity(identity);
+ }
+ }
+
+ private int getComponentRestrictionForCallingPackage(ActivityInfo activityInfo,
+ String callingPackage, int callingPid, int callingUid, boolean ignoreTargetSecurity) {
+ if (!ignoreTargetSecurity && mService.checkComponentPermission(activityInfo.permission,
+ callingPid, callingUid, activityInfo.applicationInfo.uid, activityInfo.exported)
+ == PERMISSION_DENIED) {
+ return ACTIVITY_RESTRICTION_PERMISSION;
+ }
+
+ if (activityInfo.permission == null) {
+ return ACTIVITY_RESTRICTION_NONE;
+ }
+
+ final int opCode = AppOpsManager.permissionToOpCode(activityInfo.permission);
+ if (opCode == AppOpsManager.OP_NONE) {
+ return ACTIVITY_RESTRICTION_NONE;
+ }
+
+ if (mService.getAppOpsService().noteOperation(opCode, callingUid, callingPackage)
+ != AppOpsManager.MODE_ALLOWED) {
+ if (!ignoreTargetSecurity) {
+ return ACTIVITY_RESTRICTION_APPOP;
+ }
+ }
+
+ return ACTIVITY_RESTRICTION_NONE;
+ }
+
+ private int getActionRestrictionForCallingPackage(String action,
+ String callingPackage, int callingPid, int callingUid) {
+ if (action == null) {
+ return ACTIVITY_RESTRICTION_NONE;
+ }
+
+ String permission = ACTION_TO_RUNTIME_PERMISSION.get(action);
+ if (permission == null) {
+ return ACTIVITY_RESTRICTION_NONE;
+ }
+
+ final PackageInfo packageInfo;
+ try {
+ packageInfo = mService.mContext.getPackageManager()
+ .getPackageInfo(callingPackage, PackageManager.GET_PERMISSIONS);
+ } catch (PackageManager.NameNotFoundException e) {
+ Slog.i(TAG, "Cannot find package info for " + callingPackage);
+ return ACTIVITY_RESTRICTION_NONE;
+ }
+
+ if (!ArrayUtils.contains(packageInfo.requestedPermissions, permission)) {
+ return ACTIVITY_RESTRICTION_NONE;
+ }
+
+ if (mService.checkPermission(permission, callingPid, callingUid) == PERMISSION_DENIED) {
+ return ACTIVITY_RESTRICTION_PERMISSION;
+ }
+
+ final int opCode = AppOpsManager.permissionToOpCode(permission);
+ if (opCode == AppOpsManager.OP_NONE) {
+ return ACTIVITY_RESTRICTION_NONE;
+ }
+
+ if (mService.getAppOpsService().noteOperation(opCode, callingUid, callingPackage)
+ != AppOpsManager.MODE_ALLOWED) {
+ return ACTIVITY_RESTRICTION_APPOP;
+ }
+
+ return ACTIVITY_RESTRICTION_NONE;
+ }
+
+ void setLaunchSource(int uid) {
+ mLaunchingActivity.setWorkSource(new WorkSource(uid));
+ }
+
+ void acquireLaunchWakelock() {
+ if (VALIDATE_WAKE_LOCK_CALLER && Binder.getCallingUid() != Process.myUid()) {
+ throw new IllegalStateException("Calling must be system uid");
+ }
+ mLaunchingActivity.acquire();
+ if (!mHandler.hasMessages(LAUNCH_TIMEOUT_MSG)) {
+ // To be safe, don't allow the wake lock to be held for too long.
+ mHandler.sendEmptyMessageDelayed(LAUNCH_TIMEOUT_MSG, LAUNCH_TIMEOUT);
+ }
+ }
+
+ /**
+ * Called when all resumed tasks/stacks are idle.
+ * @return the state of mService.mAm.mBooting before this was called.
+ */
+ @GuardedBy("mService")
+ private boolean checkFinishBootingLocked() {
+ final boolean booting = mService.isBooting();
+ boolean enableScreen = false;
+ mService.setBooting(false);
+ if (!mService.isBooted()) {
+ mService.setBooted(true);
+ enableScreen = true;
+ }
+ if (booting || enableScreen) {
+ mService.postFinishBooting(booting, enableScreen);
+ }
+ return booting;
+ }
+
+ // Checked.
+ @GuardedBy("mService")
+ final ActivityRecord activityIdleInternalLocked(final IBinder token, boolean fromTimeout,
+ boolean processPausingActivities, Configuration config) {
+ if (DEBUG_ALL) Slog.v(TAG, "Activity idle: " + token);
+
+ ArrayList<ActivityRecord> finishes = null;
+ ArrayList<UserState> startingUsers = null;
+ int NS = 0;
+ int NF = 0;
+ boolean booting = false;
+ boolean activityRemoved = false;
+
+ ActivityRecord r = ActivityRecord.forTokenLocked(token);
+ if (r != null) {
+ if (DEBUG_IDLE) Slog.d(TAG_IDLE, "activityIdleInternalLocked: Callers="
+ + Debug.getCallers(4));
+ mHandler.removeMessages(IDLE_TIMEOUT_MSG, r);
+ r.finishLaunchTickingLocked();
+ if (fromTimeout) {
+ reportActivityLaunchedLocked(fromTimeout, r, INVALID_DELAY);
+ }
+
+ // This is a hack to semi-deal with a race condition
+ // in the client where it can be constructed with a
+ // newer configuration from when we asked it to launch.
+ // We'll update with whatever configuration it now says
+ // it used to launch.
+ if (config != null) {
+ r.setLastReportedGlobalConfiguration(config);
+ }
+
+ // We are now idle. If someone is waiting for a thumbnail from
+ // us, we can now deliver.
+ r.idle = true;
+
+ //Slog.i(TAG, "IDLE: mBooted=" + mBooted + ", fromTimeout=" + fromTimeout);
+
+ // Make sure we can finish booting when all resumed activities are idle.
+ if ((!mService.isBooted() && allResumedActivitiesIdle()) || fromTimeout) {
+ booting = checkFinishBootingLocked();
+ }
+
+ // When activity is idle, we consider the relaunch must be successful, so let's clear
+ // the flag.
+ r.mRelaunchReason = RELAUNCH_REASON_NONE;
+ }
+
+ if (allResumedActivitiesIdle()) {
+ if (r != null) {
+ mService.scheduleAppGcsLocked();
+ }
+
+ if (mLaunchingActivity.isHeld()) {
+ mHandler.removeMessages(LAUNCH_TIMEOUT_MSG);
+ if (VALIDATE_WAKE_LOCK_CALLER &&
+ Binder.getCallingUid() != Process.myUid()) {
+ throw new IllegalStateException("Calling must be system uid");
+ }
+ mLaunchingActivity.release();
+ }
+ ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
+ }
+
+ // Atomically retrieve all of the other things to do.
+ final ArrayList<ActivityRecord> stops = processStoppingActivitiesLocked(r,
+ true /* remove */, processPausingActivities);
+ NS = stops != null ? stops.size() : 0;
+ if ((NF = mFinishingActivities.size()) > 0) {
+ finishes = new ArrayList<>(mFinishingActivities);
+ mFinishingActivities.clear();
+ }
+
+ if (mStartingUsers.size() > 0) {
+ startingUsers = new ArrayList<>(mStartingUsers);
+ mStartingUsers.clear();
+ }
+
+ // Stop any activities that are scheduled to do so but have been
+ // waiting for the next one to start.
+ for (int i = 0; i < NS; i++) {
+ r = stops.get(i);
+ final ActivityStack stack = r.getStack();
+ if (stack != null) {
+ if (r.finishing) {
+ stack.finishCurrentActivityLocked(r, ActivityStack.FINISH_IMMEDIATELY, false,
+ "activityIdleInternalLocked");
+ } else {
+ stack.stopActivityLocked(r);
+ }
+ }
+ }
+
+ // Finish any activities that are scheduled to do so but have been
+ // waiting for the next one to start.
+ for (int i = 0; i < NF; i++) {
+ r = finishes.get(i);
+ final ActivityStack stack = r.getStack();
+ if (stack != null) {
+ activityRemoved |= stack.destroyActivityLocked(r, true, "finish-idle");
+ }
+ }
+
+ if (!booting) {
+ // Complete user switch
+ if (startingUsers != null) {
+ for (int i = 0; i < startingUsers.size(); i++) {
+ mService.mAmInternal.finishUserSwitch(startingUsers.get(i));
+ }
+ }
+ }
+
+ mService.mAmInternal.trimApplications();
+ //dump();
+ //mWindowManager.dump();
+
+ if (activityRemoved) {
+ resumeFocusedStacksTopActivitiesLocked();
+ }
+
+ return r;
+ }
+
+ boolean handleAppDiedLocked(WindowProcessController app) {
+ boolean hasVisibleActivities = false;
+ for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
+ final ActivityDisplay display = mActivityDisplays.get(displayNdx);
+ for (int stackNdx = display.getChildCount() - 1; stackNdx >= 0; --stackNdx) {
+ final ActivityStack stack = display.getChildAt(stackNdx);
+ hasVisibleActivities |= stack.handleAppDiedLocked(app);
+ }
+ }
+ return hasVisibleActivities;
+ }
+
+ void closeSystemDialogsLocked() {
+ for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
+ final ActivityDisplay display = mActivityDisplays.get(displayNdx);
+ for (int stackNdx = display.getChildCount() - 1; stackNdx >= 0; --stackNdx) {
+ final ActivityStack stack = display.getChildAt(stackNdx);
+ stack.closeSystemDialogsLocked();
+ }
+ }
+ }
+
+ void removeUserLocked(int userId) {
+ mUserStackInFront.delete(userId);
+ }
+
+ /**
+ * Update the last used stack id for non-current user (current user's last
+ * used stack is the focused stack)
+ */
+ void updateUserStackLocked(int userId, ActivityStack stack) {
+ if (userId != mCurrentUser) {
+ mUserStackInFront.put(userId, stack != null ? stack.getStackId()
+ : getDefaultDisplay().getHomeStack().mStackId);
+ }
+ }
+
+ /**
+ * @return true if some activity was finished (or would have finished if doit were true).
+ */
+ boolean finishDisabledPackageActivitiesLocked(String packageName, Set<String> filterByClasses,
+ boolean doit, boolean evenPersistent, int userId) {
+ boolean didSomething = false;
+ for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
+ final ActivityDisplay display = mActivityDisplays.get(displayNdx);
+ for (int stackNdx = display.getChildCount() - 1; stackNdx >= 0; --stackNdx) {
+ final ActivityStack stack = display.getChildAt(stackNdx);
+ if (stack.finishDisabledPackageActivitiesLocked(
+ packageName, filterByClasses, doit, evenPersistent, userId)) {
+ didSomething = true;
+ }
+ }
+ }
+ return didSomething;
+ }
+
+ void updatePreviousProcessLocked(ActivityRecord r) {
+ // Now that this process has stopped, we may want to consider
+ // it to be the previous app to try to keep around in case
+ // the user wants to return to it.
+
+ // First, found out what is currently the foreground app, so that
+ // we don't blow away the previous app if this activity is being
+ // hosted by the process that is actually still the foreground.
+ WindowProcessController fgApp = null;
+ for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
+ final ActivityDisplay display = mActivityDisplays.get(displayNdx);
+ for (int stackNdx = display.getChildCount() - 1; stackNdx >= 0; --stackNdx) {
+ final ActivityStack stack = display.getChildAt(stackNdx);
+ if (isTopDisplayFocusedStack(stack)) {
+ final ActivityRecord resumedActivity = stack.getResumedActivity();
+ if (resumedActivity != null) {
+ fgApp = resumedActivity.app;
+ } else if (stack.mPausingActivity != null) {
+ fgApp = stack.mPausingActivity.app;
+ }
+ break;
+ }
+ }
+ }
+
+ // Now set this one as the previous process, only if that really
+ // makes sense to.
+ if (r.hasProcess() && fgApp != null && r.app != fgApp
+ && r.lastVisibleTime > mService.mPreviousProcessVisibleTime
+ && r.app != mService.mHomeProcess) {
+ mService.mPreviousProcess = r.app;
+ mService.mPreviousProcessVisibleTime = r.lastVisibleTime;
+ }
+ }
+
+ boolean resumeFocusedStacksTopActivitiesLocked() {
+ return resumeFocusedStacksTopActivitiesLocked(null, null, null);
+ }
+
+ boolean resumeFocusedStacksTopActivitiesLocked(
+ ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
+
+ if (!readyToResume()) {
+ return false;
+ }
+
+ if (targetStack != null && (targetStack.isTopStackOnDisplay()
+ || getTopDisplayFocusedStack() == targetStack)) {
+ return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
+ }
+
+ // Resume all top activities in focused stacks on all displays.
+ for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
+ final ActivityDisplay display = mActivityDisplays.get(displayNdx);
+ final ActivityStack focusedStack = display.getFocusedStack();
+ if (focusedStack == null) {
+ continue;
+ }
+ final ActivityRecord r = focusedStack.topRunningActivityLocked();
+ if (r == null || !r.isState(RESUMED)) {
+ focusedStack.resumeTopActivityUncheckedLocked(null, null);
+ } else if (r.isState(RESUMED)) {
+ // Kick off any lingering app transitions form the MoveTaskToFront operation.
+ focusedStack.executeAppTransition(targetOptions);
+ }
+ }
+
+ return false;
+ }
+
+ void updateActivityApplicationInfoLocked(ApplicationInfo aInfo) {
+ for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
+ final ActivityDisplay display = mActivityDisplays.get(displayNdx);
+ for (int stackNdx = display.getChildCount() - 1; stackNdx >= 0; --stackNdx) {
+ final ActivityStack stack = display.getChildAt(stackNdx);
+ stack.updateActivityApplicationInfoLocked(aInfo);
+ }
+ }
+ }
+
+ /**
+ * Finish the topmost activities in all stacks that belong to the crashed app.
+ * @param app The app that crashed.
+ * @param reason Reason to perform this action.
+ * @return The task id that was finished in this stack, or INVALID_TASK_ID if none was finished.
+ */
+ int finishTopCrashedActivitiesLocked(WindowProcessController app, String reason) {
+ TaskRecord finishedTask = null;
+ ActivityStack focusedStack = getTopDisplayFocusedStack();
+ for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
+ final ActivityDisplay display = mActivityDisplays.get(displayNdx);
+ // It is possible that request to finish activity might also remove its task and stack,
+ // so we need to be careful with indexes in the loop and check child count every time.
+ for (int stackNdx = 0; stackNdx < display.getChildCount(); ++stackNdx) {
+ final ActivityStack stack = display.getChildAt(stackNdx);
+ final TaskRecord t = stack.finishTopCrashedActivityLocked(app, reason);
+ if (stack == focusedStack || finishedTask == null) {
+ finishedTask = t;
+ }
+ }
+ }
+ return finishedTask != null ? finishedTask.taskId : INVALID_TASK_ID;
+ }
+
+ void finishVoiceTask(IVoiceInteractionSession session) {
+ for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
+ final ActivityDisplay display = mActivityDisplays.get(displayNdx);
+ final int numStacks = display.getChildCount();
+ for (int stackNdx = 0; stackNdx < numStacks; ++stackNdx) {
+ final ActivityStack stack = display.getChildAt(stackNdx);
+ stack.finishVoiceTask(session);
+ }
+ }
+ }
+
+ /**
+ * This doesn't just find a task, it also moves the task to front.
+ */
+ void findTaskToMoveToFront(TaskRecord task, int flags, ActivityOptions options, String reason,
+ boolean forceNonResizeable) {
+ ActivityStack currentStack = task.getStack();
+ if (currentStack == null) {
+ Slog.e(TAG, "findTaskToMoveToFront: can't move task="
+ + task + " to front. Stack is null");
+ return;
+ }
+
+ if ((flags & ActivityManager.MOVE_TASK_NO_USER_ACTION) == 0) {
+ mUserLeaving = true;
+ }
+
+ reason = reason + " findTaskToMoveToFront";
+ boolean reparented = false;
+ if (task.isResizeable() && canUseActivityOptionsLaunchBounds(options)) {
+ final Rect bounds = options.getLaunchBounds();
+ task.updateOverrideConfiguration(bounds);
+
+ ActivityStack stack = getLaunchStack(null, options, task, ON_TOP);
+
+ if (stack != currentStack) {
+ moveHomeStackToFrontIfNeeded(flags, stack.getDisplay(), reason);
+ task.reparent(stack, ON_TOP, REPARENT_KEEP_STACK_AT_FRONT, !ANIMATE, DEFER_RESUME,
+ reason);
+ currentStack = stack;
+ reparented = true;
+ // task.reparent() should already placed the task on top,
+ // still need moveTaskToFrontLocked() below for any transition settings.
+ }
+ if (stack.resizeStackWithLaunchBounds()) {
+ resizeStackLocked(stack, bounds, null /* tempTaskBounds */,
+ null /* tempTaskInsetBounds */, !PRESERVE_WINDOWS,
+ true /* allowResizeInDockedMode */, !DEFER_RESUME);
+ } else {
+ // WM resizeTask must be done after the task is moved to the correct stack,
+ // because Task's setBounds() also updates dim layer's bounds, but that has
+ // dependency on the stack.
+ task.resizeWindowContainer();
+ }
+ }
+
+ if (!reparented) {
+ moveHomeStackToFrontIfNeeded(flags, currentStack.getDisplay(), reason);
+ }
+
+ final ActivityRecord r = task.getTopActivity();
+ currentStack.moveTaskToFrontLocked(task, false /* noAnimation */, options,
+ r == null ? null : r.appTimeTracker, reason);
+
+ if (DEBUG_STACK) Slog.d(TAG_STACK,
+ "findTaskToMoveToFront: moved to front of stack=" + currentStack);
+
+ handleNonResizableTaskIfNeeded(task, WINDOWING_MODE_UNDEFINED, DEFAULT_DISPLAY,
+ currentStack, forceNonResizeable);
+ }
+
+ private void moveHomeStackToFrontIfNeeded(int flags, ActivityDisplay display, String reason) {
+ final ActivityStack focusedStack = display.getFocusedStack();
+
+ if ((display.getWindowingMode() == WINDOWING_MODE_FULLSCREEN
+ && (flags & ActivityManager.MOVE_TASK_WITH_HOME) != 0)
+ || (focusedStack != null && focusedStack.isActivityTypeRecents())) {
+ // We move home stack to front when we are on a fullscreen display and caller has
+ // requested the home activity to move with it. Or the previous stack is recents.
+ display.moveHomeStackToFront(reason);
+ }
+ }
+
+ boolean canUseActivityOptionsLaunchBounds(ActivityOptions options) {
+ // We use the launch bounds in the activity options is the device supports freeform
+ // window management or is launching into the pinned stack.
+ if (options == null || options.getLaunchBounds() == null) {
+ return false;
+ }
+ return (mService.mSupportsPictureInPicture
+ && options.getLaunchWindowingMode() == WINDOWING_MODE_PINNED)
+ || mService.mSupportsFreeformWindowManagement;
+ }
+
+ LaunchParamsController getLaunchParamsController() {
+ return mLaunchParamsController;
+ }
+
+ protected <T extends ActivityStack> T getStack(int stackId) {
+ for (int i = mActivityDisplays.size() - 1; i >= 0; --i) {
+ final T stack = mActivityDisplays.get(i).getStack(stackId);
+ if (stack != null) {
+ return stack;
+ }
+ }
+ return null;
+ }
+
+ /** @see ActivityDisplay#getStack(int, int) */
+ private <T extends ActivityStack> T getStack(int windowingMode, int activityType) {
+ for (int i = mActivityDisplays.size() - 1; i >= 0; --i) {
+ final T stack = mActivityDisplays.get(i).getStack(windowingMode, activityType);
+ if (stack != null) {
+ return stack;
+ }
+ }
+ return null;
+ }
+
+ int resolveActivityType(@Nullable ActivityRecord r, @Nullable ActivityOptions options,
+ @Nullable TaskRecord task) {
+ // Preference is given to the activity type for the activity then the task since the type
+ // once set shouldn't change.
+ int activityType = r != null ? r.getActivityType() : ACTIVITY_TYPE_UNDEFINED;
+ if (activityType == ACTIVITY_TYPE_UNDEFINED && task != null) {
+ activityType = task.getActivityType();
+ }
+ if (activityType != ACTIVITY_TYPE_UNDEFINED) {
+ return activityType;
+ }
+ if (options != null) {
+ activityType = options.getLaunchActivityType();
+ }
+ return activityType != ACTIVITY_TYPE_UNDEFINED ? activityType : ACTIVITY_TYPE_STANDARD;
+ }
+
+ <T extends ActivityStack> T getLaunchStack(@Nullable ActivityRecord r,
+ @Nullable ActivityOptions options, @Nullable TaskRecord candidateTask, boolean onTop) {
+ return getLaunchStack(r, options, candidateTask, onTop, INVALID_DISPLAY);
+ }
+
+ /**
+ * Returns the right stack to use for launching factoring in all the input parameters.
+ *
+ * @param r The activity we are trying to launch. Can be null.
+ * @param options The activity options used to the launch. Can be null.
+ * @param candidateTask The possible task the activity might be launched in. Can be null.
+ *
+ * @return The stack to use for the launch or INVALID_STACK_ID.
+ */
+ <T extends ActivityStack> T getLaunchStack(@Nullable ActivityRecord r,
+ @Nullable ActivityOptions options, @Nullable TaskRecord candidateTask, boolean onTop,
+ int candidateDisplayId) {
+ int taskId = INVALID_TASK_ID;
+ int displayId = INVALID_DISPLAY;
+ //Rect bounds = null;
+
+ // We give preference to the launch preference in activity options.
+ if (options != null) {
+ taskId = options.getLaunchTaskId();
+ displayId = options.getLaunchDisplayId();
+ // TODO: Need to work this into the equation...
+ //bounds = options.getLaunchBounds();
+ }
+
+ // First preference for stack goes to the task Id set in the activity options. Use the stack
+ // associated with that if possible.
+ if (taskId != INVALID_TASK_ID) {
+ // Temporarily set the task id to invalid in case in re-entry.
+ options.setLaunchTaskId(INVALID_TASK_ID);
+ final TaskRecord task = anyTaskForIdLocked(taskId,
+ MATCH_TASK_IN_STACKS_OR_RECENT_TASKS_AND_RESTORE, options, onTop);
+ options.setLaunchTaskId(taskId);
+ if (task != null) {
+ return task.getStack();
+ }
+ }
+
+ final int activityType = resolveActivityType(r, options, candidateTask);
+ T stack = null;
+
+ // Next preference for stack goes to the display Id set in the activity options or the
+ // candidate display.
+ if (displayId == INVALID_DISPLAY) {
+ displayId = candidateDisplayId;
+ }
+ if (displayId != INVALID_DISPLAY && canLaunchOnDisplay(r, displayId)) {
+ if (r != null) {
+ stack = (T) getValidLaunchStackOnDisplay(displayId, r, candidateTask, options);
+ if (stack != null) {
+ return stack;
+ }
+ }
+ final ActivityDisplay display = getActivityDisplayOrCreateLocked(displayId);
+ if (display != null) {
+ stack = display.getOrCreateStack(r, options, candidateTask, activityType, onTop);
+ if (stack != null) {
+ return stack;
+ }
+ }
+ }
+
+ // Give preference to the stack and display of the input task and activity if they match the
+ // mode we want to launch into.
+ stack = null;
+ ActivityDisplay display = null;
+ if (candidateTask != null) {
+ stack = candidateTask.getStack();
+ }
+ if (stack == null && r != null) {
+ stack = r.getStack();
+ }
+ if (stack != null) {
+ display = stack.getDisplay();
+ if (display != null && canLaunchOnDisplay(r, display.mDisplayId)) {
+ final int windowingMode =
+ display.resolveWindowingMode(r, options, candidateTask, activityType);
+ if (stack.isCompatible(windowingMode, activityType)) {
+ return stack;
+ }
+ if (windowingMode == WINDOWING_MODE_FULLSCREEN_OR_SPLIT_SCREEN_SECONDARY
+ && display.getSplitScreenPrimaryStack() == stack
+ && candidateTask == stack.topTask()) {
+ // This is a special case when we try to launch an activity that is currently on
+ // top of split-screen primary stack, but is targeting split-screen secondary.
+ // In this case we don't want to move it to another stack.
+ // TODO(b/78788972): Remove after differentiating between preferred and required
+ // launch options.
+ return stack;
+ }
+ }
+ }
+
+ if (display == null || !canLaunchOnDisplay(r, display.mDisplayId)) {
+ display = getDefaultDisplay();
+ }
+
+ return display.getOrCreateStack(r, options, candidateTask, activityType, onTop);
+ }
+
+ /** @return true if activity record is null or can be launched on provided display. */
+ private boolean canLaunchOnDisplay(ActivityRecord r, int displayId) {
+ if (r == null) {
+ return true;
+ }
+ return r.canBeLaunchedOnDisplay(displayId);
+ }
+
+ /**
+ * Get a topmost stack on the display, that is a valid launch stack for specified activity.
+ * If there is no such stack, new dynamic stack can be created.
+ * @param displayId Target display.
+ * @param r Activity that should be launched there.
+ * @param candidateTask The possible task the activity might be put in.
+ * @return Existing stack if there is a valid one, new dynamic stack if it is valid or null.
+ */
+ ActivityStack getValidLaunchStackOnDisplay(int displayId, @NonNull ActivityRecord r,
+ @Nullable TaskRecord candidateTask, @Nullable ActivityOptions options) {
+ final ActivityDisplay activityDisplay = getActivityDisplayOrCreateLocked(displayId);
+ if (activityDisplay == null) {
+ throw new IllegalArgumentException(
+ "Display with displayId=" + displayId + " not found.");
+ }
+
+ if (!r.canBeLaunchedOnDisplay(displayId)) {
+ return null;
+ }
+
+ // If {@code r} is already in target display and its task is the same as the candidate task,
+ // the intention should be getting a launch stack for the reusable activity, so we can use
+ // the existing stack.
+ if (r.getDisplayId() == displayId && r.getTask() == candidateTask) {
+ return candidateTask.getStack();
+ }
+
+ // Return the topmost valid stack on the display.
+ for (int i = activityDisplay.getChildCount() - 1; i >= 0; --i) {
+ final ActivityStack stack = activityDisplay.getChildAt(i);
+ if (isValidLaunchStack(stack, displayId, r)) {
+ return stack;
+ }
+ }
+
+ // If there is no valid stack on the external display - check if new dynamic stack will do.
+ if (displayId != DEFAULT_DISPLAY) {
+ return activityDisplay.createStack(
+ options != null ? options.getLaunchWindowingMode() : r.getWindowingMode(),
+ options != null ? options.getLaunchActivityType() : r.getActivityType(),
+ true /*onTop*/);
+ }
+
+ Slog.w(TAG, "getValidLaunchStackOnDisplay: can't launch on displayId " + displayId);
+ return null;
+ }
+
+ ActivityStack getValidLaunchStackOnDisplay(int displayId, @NonNull ActivityRecord r,
+ @Nullable ActivityOptions options) {
+ return getValidLaunchStackOnDisplay(displayId, r, null /* candidateTask */, options);
+ }
+
+ // TODO: Can probably be consolidated into getLaunchStack()...
+ private boolean isValidLaunchStack(ActivityStack stack, int displayId, ActivityRecord r) {
+ switch (stack.getActivityType()) {
+ case ACTIVITY_TYPE_HOME: return r.isActivityTypeHome();
+ case ACTIVITY_TYPE_RECENTS: return r.isActivityTypeRecents();
+ case ACTIVITY_TYPE_ASSISTANT: return r.isActivityTypeAssistant();
+ }
+ // There is a 1-to-1 relationship between stack and task when not in
+ // primary split-windowing mode.
+ if (stack.getWindowingMode() != WINDOWING_MODE_SPLIT_SCREEN_PRIMARY) {
+ return false;
+ } else {
+ return r.supportsSplitScreenWindowingMode();
+ }
+ }
+
+ /**
+ * Get next focusable stack in the system. This will search through the stack on the same
+ * display as the current focused stack, looking for a focusable and visible stack, different
+ * from the target stack. If no valid candidates will be found, it will then go through all
+ * displays and stacks in last-focused order.
+ *
+ * @param currentFocus The stack that previously had focus.
+ * @param ignoreCurrent If we should ignore {@param currentFocus} when searching for next
+ * candidate.
+ * @return Next focusable {@link ActivityStack}, {@code null} if not found.
+ */
+ ActivityStack getNextFocusableStackLocked(@NonNull ActivityStack currentFocus,
+ boolean ignoreCurrent) {
+ // First look for next focusable stack on the same display
+ final ActivityDisplay preferredDisplay = currentFocus.getDisplay();
+ final ActivityStack preferredFocusableStack = preferredDisplay.getNextFocusableStack(
+ currentFocus, ignoreCurrent);
+ if (preferredFocusableStack != null) {
+ return preferredFocusableStack;
+ }
+ if (preferredDisplay.supportsSystemDecorations()) {
+ // Stop looking for focusable stack on other displays because the preferred display
+ // supports system decorations. Home activity would be launched on the same display if
+ // no focusable stack found.
+ return null;
+ }
+
+ // Now look through all displays
+ for (int i = mActivityDisplays.size() - 1; i >= 0; --i) {
+ final ActivityDisplay display = mActivityDisplays.get(i);
+ if (display == preferredDisplay) {
+ // We've already checked this one
+ continue;
+ }
+ final ActivityStack nextFocusableStack = display.getNextFocusableStack(currentFocus,
+ ignoreCurrent);
+ if (nextFocusableStack != null) {
+ return nextFocusableStack;
+ }
+ }
+
+ return null;
+ }
+
+ /**
+ * Get next valid stack for launching provided activity in the system. This will search across
+ * displays and stacks in last-focused order for a focusable and visible stack, except those
+ * that are on a currently focused display.
+ *
+ * @param r The activity that is being launched.
+ * @param currentFocus The display that previously had focus and thus needs to be ignored when
+ * searching for the next candidate.
+ * @return Next valid {@link ActivityStack}, null if not found.
+ */
+ ActivityStack getNextValidLaunchStackLocked(@NonNull ActivityRecord r, int currentFocus) {
+ for (int i = mActivityDisplays.size() - 1; i >= 0; --i) {
+ final ActivityDisplay display = mActivityDisplays.get(i);
+ if (display.mDisplayId == currentFocus) {
+ continue;
+ }
+ final ActivityStack stack = getValidLaunchStackOnDisplay(display.mDisplayId, r,
+ null /* options */);
+ if (stack != null) {
+ return stack;
+ }
+ }
+ return null;
+ }
+
+ ActivityRecord getDefaultDisplayHomeActivity() {
+ return getDefaultDisplayHomeActivityForUser(mCurrentUser);
+ }
+
+ ActivityRecord getDefaultDisplayHomeActivityForUser(int userId) {
+ getActivityDisplay(DEFAULT_DISPLAY).getHomeActivityForUser(userId);
+ return null;
+ }
+
+ void resizeStackLocked(ActivityStack stack, Rect bounds, Rect tempTaskBounds,
+ Rect tempTaskInsetBounds, boolean preserveWindows, boolean allowResizeInDockedMode,
+ boolean deferResume) {
+
+ if (stack.inSplitScreenPrimaryWindowingMode()) {
+ resizeDockedStackLocked(bounds, tempTaskBounds, tempTaskInsetBounds, null, null,
+ preserveWindows, deferResume);
+ return;
+ }
+
+ final boolean splitScreenActive = getDefaultDisplay().hasSplitScreenPrimaryStack();
+ if (!allowResizeInDockedMode
+ && !stack.getWindowConfiguration().tasksAreFloating() && splitScreenActive) {
+ // If the docked stack exists, don't resize non-floating stacks independently of the
+ // size computed from the docked stack size (otherwise they will be out of sync)
+ return;
+ }
+
+ Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "am.resizeStack_" + stack.mStackId);
+ mWindowManager.deferSurfaceLayout();
+ try {
+ if (stack.affectedBySplitScreenResize()) {
+ if (bounds == null && stack.inSplitScreenWindowingMode()) {
+ // null bounds = fullscreen windowing mode...at least for now.
+ stack.setWindowingMode(WINDOWING_MODE_FULLSCREEN);
+ } else if (splitScreenActive) {
+ // If we are in split-screen mode and this stack support split-screen, then
+ // it should be split-screen secondary mode. i.e. adjacent to the docked stack.
+ stack.setWindowingMode(WINDOWING_MODE_SPLIT_SCREEN_SECONDARY);
+ }
+ }
+ stack.resize(bounds, tempTaskBounds, tempTaskInsetBounds);
+ if (!deferResume) {
+ stack.ensureVisibleActivitiesConfigurationLocked(
+ stack.topRunningActivityLocked(), preserveWindows);
+ }
+ } finally {
+ mWindowManager.continueSurfaceLayout();
+ Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
+ }
+ }
+
+ void deferUpdateRecentsHomeStackBounds() {
+ deferUpdateBounds(ACTIVITY_TYPE_RECENTS);
+ deferUpdateBounds(ACTIVITY_TYPE_HOME);
+ }
+
+ void deferUpdateBounds(int activityType) {
+ final ActivityStack stack = getStack(WINDOWING_MODE_UNDEFINED, activityType);
+ if (stack != null) {
+ stack.deferUpdateBounds();
+ }
+ }
+
+ void continueUpdateRecentsHomeStackBounds() {
+ continueUpdateBounds(ACTIVITY_TYPE_RECENTS);
+ continueUpdateBounds(ACTIVITY_TYPE_HOME);
+ }
+
+ void continueUpdateBounds(int activityType) {
+ final ActivityStack stack = getStack(WINDOWING_MODE_UNDEFINED, activityType);
+ if (stack != null) {
+ stack.continueUpdateBounds();
+ }
+ }
+
+ void notifyAppTransitionDone() {
+ continueUpdateRecentsHomeStackBounds();
+ for (int i = mResizingTasksDuringAnimation.size() - 1; i >= 0; i--) {
+ final int taskId = mResizingTasksDuringAnimation.valueAt(i);
+ final TaskRecord task = anyTaskForIdLocked(taskId, MATCH_TASK_IN_STACKS_ONLY);
+ if (task != null) {
+ task.setTaskDockedResizing(false);
+ }
+ }
+ mResizingTasksDuringAnimation.clear();
+ }
+
+ /**
+ * TODO: This should just change the windowing mode and resize vs. actually moving task around.
+ * Can do that once we are no longer using static stack ids.
+ */
+ private void moveTasksToFullscreenStackInSurfaceTransaction(ActivityStack fromStack,
+ int toDisplayId, boolean onTop) {
+
+ mWindowManager.deferSurfaceLayout();
+ try {
+ final int windowingMode = fromStack.getWindowingMode();
+ final boolean inPinnedWindowingMode = windowingMode == WINDOWING_MODE_PINNED;
+ final ActivityDisplay toDisplay = getActivityDisplay(toDisplayId);
+
+ if (windowingMode == WINDOWING_MODE_SPLIT_SCREEN_PRIMARY) {
+ // Tell the display we are exiting split-screen mode.
+ toDisplay.onExitingSplitScreenMode();
+ // We are moving all tasks from the docked stack to the fullscreen stack,
+ // which is dismissing the docked stack, so resize all other stacks to
+ // fullscreen here already so we don't end up with resize trashing.
+ for (int i = toDisplay.getChildCount() - 1; i >= 0; --i) {
+ final ActivityStack otherStack = toDisplay.getChildAt(i);
+ if (!otherStack.inSplitScreenSecondaryWindowingMode()) {
+ continue;
+ }
+ otherStack.setWindowingMode(WINDOWING_MODE_UNDEFINED);
+ }
+
+ // Also disable docked stack resizing since we have manually adjusted the
+ // size of other stacks above and we don't want to trigger a docked stack
+ // resize when we remove task from it below and it is detached from the
+ // display because it no longer contains any tasks.
+ mAllowDockedStackResize = false;
+ }
+
+ // If we are moving from the pinned stack, then the animation takes care of updating
+ // the picture-in-picture mode.
+ final boolean schedulePictureInPictureModeChange = inPinnedWindowingMode;
+ final ArrayList<TaskRecord> tasks = fromStack.getAllTasks();
+
+ if (!tasks.isEmpty()) {
+ mTmpOptions.setLaunchWindowingMode(WINDOWING_MODE_FULLSCREEN);
+ final int size = tasks.size();
+ for (int i = 0; i < size; ++i) {
+ final TaskRecord task = tasks.get(i);
+ final ActivityStack toStack = toDisplay.getOrCreateStack(
+ null, mTmpOptions, task, task.getActivityType(), onTop);
+
+ if (onTop) {
+ final boolean isTopTask = i == (size - 1);
+ // Defer resume until all the tasks have been moved to the fullscreen stack
+ task.reparent(toStack, ON_TOP, REPARENT_MOVE_STACK_TO_FRONT,
+ isTopTask /* animate */, DEFER_RESUME,
+ schedulePictureInPictureModeChange,
+ "moveTasksToFullscreenStack - onTop");
+ MetricsLoggerWrapper.logPictureInPictureFullScreen(mService.mContext,
+ task.effectiveUid, task.realActivity.flattenToString());
+ } else {
+ // Position the tasks in the fullscreen stack in order at the bottom of the
+ // stack. Also defer resume until all the tasks have been moved to the
+ // fullscreen stack.
+ task.reparent(toStack, ON_TOP,
+ REPARENT_LEAVE_STACK_IN_PLACE, !ANIMATE, DEFER_RESUME,
+ schedulePictureInPictureModeChange,
+ "moveTasksToFullscreenStack - NOT_onTop");
+ }
+ }
+ }
+
+ ensureActivitiesVisibleLocked(null, 0, PRESERVE_WINDOWS);
+ resumeFocusedStacksTopActivitiesLocked();
+ } finally {
+ mAllowDockedStackResize = true;
+ mWindowManager.continueSurfaceLayout();
+ }
+ }
+
+ void moveTasksToFullscreenStackLocked(ActivityStack fromStack, boolean onTop) {
+ moveTasksToFullscreenStackLocked(fromStack, DEFAULT_DISPLAY, onTop);
+ }
+
+ void moveTasksToFullscreenStackLocked(ActivityStack fromStack, int toDisplayId, boolean onTop) {
+ mWindowManager.inSurfaceTransaction(() ->
+ moveTasksToFullscreenStackInSurfaceTransaction(fromStack, toDisplayId, onTop));
+ }
+
+ void setSplitScreenResizing(boolean resizing) {
+ if (resizing == mDockedStackResizing) {
+ return;
+ }
+
+ mDockedStackResizing = resizing;
+ mWindowManager.setDockedStackResizing(resizing);
+
+ if (!resizing && mHasPendingDockedBounds) {
+ resizeDockedStackLocked(mPendingDockedBounds, mPendingTempDockedTaskBounds,
+ mPendingTempDockedTaskInsetBounds, mPendingTempOtherTaskBounds,
+ mPendingTempOtherTaskInsetBounds, PRESERVE_WINDOWS);
+
+ mHasPendingDockedBounds = false;
+ mPendingDockedBounds = null;
+ mPendingTempDockedTaskBounds = null;
+ mPendingTempDockedTaskInsetBounds = null;
+ mPendingTempOtherTaskBounds = null;
+ mPendingTempOtherTaskInsetBounds = null;
+ }
+ }
+
+ void resizeDockedStackLocked(Rect dockedBounds, Rect tempDockedTaskBounds,
+ Rect tempDockedTaskInsetBounds, Rect tempOtherTaskBounds, Rect tempOtherTaskInsetBounds,
+ boolean preserveWindows) {
+ resizeDockedStackLocked(dockedBounds, tempDockedTaskBounds, tempDockedTaskInsetBounds,
+ tempOtherTaskBounds, tempOtherTaskInsetBounds, preserveWindows,
+ false /* deferResume */);
+ }
+
+ private void resizeDockedStackLocked(Rect dockedBounds, Rect tempDockedTaskBounds,
+ Rect tempDockedTaskInsetBounds, Rect tempOtherTaskBounds, Rect tempOtherTaskInsetBounds,
+ boolean preserveWindows, boolean deferResume) {
+
+ if (!mAllowDockedStackResize) {
+ // Docked stack resize currently disabled.
+ return;
+ }
+
+ final ActivityStack stack = getDefaultDisplay().getSplitScreenPrimaryStack();
+ if (stack == null) {
+ Slog.w(TAG, "resizeDockedStackLocked: docked stack not found");
+ return;
+ }
+
+ if (mDockedStackResizing) {
+ mHasPendingDockedBounds = true;
+ mPendingDockedBounds = copyOrNull(dockedBounds);
+ mPendingTempDockedTaskBounds = copyOrNull(tempDockedTaskBounds);
+ mPendingTempDockedTaskInsetBounds = copyOrNull(tempDockedTaskInsetBounds);
+ mPendingTempOtherTaskBounds = copyOrNull(tempOtherTaskBounds);
+ mPendingTempOtherTaskInsetBounds = copyOrNull(tempOtherTaskInsetBounds);
+ }
+
+ Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "am.resizeDockedStack");
+ mWindowManager.deferSurfaceLayout();
+ try {
+ // Don't allow re-entry while resizing. E.g. due to docked stack detaching.
+ mAllowDockedStackResize = false;
+ ActivityRecord r = stack.topRunningActivityLocked();
+ stack.resize(dockedBounds, tempDockedTaskBounds, tempDockedTaskInsetBounds);
+
+ // TODO: Checking for isAttached might not be needed as if the user passes in null
+ // dockedBounds then they want the docked stack to be dismissed.
+ if (stack.getWindowingMode() == WINDOWING_MODE_FULLSCREEN
+ || (dockedBounds == null && !stack.isAttached())) {
+ // The dock stack either was dismissed or went fullscreen, which is kinda the same.
+ // In this case we make all other static stacks fullscreen and move all
+ // docked stack tasks to the fullscreen stack.
+ moveTasksToFullscreenStackLocked(stack, ON_TOP);
+
+ // stack shouldn't contain anymore activities, so nothing to resume.
+ r = null;
+ } else {
+ // Docked stacks occupy a dedicated region on screen so the size of all other
+ // static stacks need to be adjusted so they don't overlap with the docked stack.
+ // We get the bounds to use from window manager which has been adjusted for any
+ // screen controls and is also the same for all stacks.
+ final ActivityDisplay display = getDefaultDisplay();
+ final Rect otherTaskRect = new Rect();
+ for (int i = display.getChildCount() - 1; i >= 0; --i) {
+ final ActivityStack current = display.getChildAt(i);
+ if (current.getWindowingMode() == WINDOWING_MODE_SPLIT_SCREEN_PRIMARY) {
+ continue;
+ }
+ if (!current.affectedBySplitScreenResize()) {
+ continue;
+ }
+ if (mDockedStackResizing && !current.isTopActivityVisible()) {
+ // Non-visible stacks get resized once we're done with the resize
+ // interaction.
+ continue;
+ }
+ // Need to set windowing mode here before we try to get the dock bounds.
+ current.setWindowingMode(WINDOWING_MODE_SPLIT_SCREEN_SECONDARY);
+ current.getStackDockedModeBounds(
+ tempOtherTaskBounds /* currentTempTaskBounds */,
+ tempRect /* outStackBounds */,
+ otherTaskRect /* outTempTaskBounds */, true /* ignoreVisibility */);
+
+ resizeStackLocked(current, !tempRect.isEmpty() ? tempRect : null,
+ !otherTaskRect.isEmpty() ? otherTaskRect : tempOtherTaskBounds,
+ tempOtherTaskInsetBounds, preserveWindows,
+ true /* allowResizeInDockedMode */, deferResume);
+ }
+ }
+ if (!deferResume) {
+ stack.ensureVisibleActivitiesConfigurationLocked(r, preserveWindows);
+ }
+ } finally {
+ mAllowDockedStackResize = true;
+ mWindowManager.continueSurfaceLayout();
+ Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
+ }
+ }
+
+ void resizePinnedStackLocked(Rect pinnedBounds, Rect tempPinnedTaskBounds) {
+ // TODO(multi-display): Pinned stack display should be passed in.
+ final PinnedActivityStack stack = getDefaultDisplay().getPinnedStack();
+ if (stack == null) {
+ Slog.w(TAG, "resizePinnedStackLocked: pinned stack not found");
+ return;
+ }
+
+ // It is possible for the bounds animation from the WM to call this but be delayed by
+ // another AM call that is holding the AMS lock. In such a case, the pinnedBounds may be
+ // incorrect if AMS.resizeStackWithBoundsFromWindowManager() is already called while waiting
+ // for the AMS lock to be freed. So check and make sure these bounds are still good.
+ final PinnedStackWindowController stackController = stack.getWindowContainerController();
+ if (stackController.pinnedStackResizeDisallowed()) {
+ return;
+ }
+
+ Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "am.resizePinnedStack");
+ mWindowManager.deferSurfaceLayout();
+ try {
+ ActivityRecord r = stack.topRunningActivityLocked();
+ Rect insetBounds = null;
+ if (tempPinnedTaskBounds != null && stack.isAnimatingBoundsToFullscreen()) {
+ // Use 0,0 as the position for the inset rect because we are headed for fullscreen.
+ insetBounds = tempRect;
+ insetBounds.top = 0;
+ insetBounds.left = 0;
+ insetBounds.right = tempPinnedTaskBounds.width();
+ insetBounds.bottom = tempPinnedTaskBounds.height();
+ }
+ if (pinnedBounds != null && tempPinnedTaskBounds == null) {
+ // We have finished the animation into PiP, and are resizing the tasks to match the
+ // stack bounds, while layouts are deferred, update any task state as a part of
+ // transitioning it from fullscreen into a floating state.
+ stack.onPipAnimationEndResize();
+ }
+ stack.resize(pinnedBounds, tempPinnedTaskBounds, insetBounds);
+ stack.ensureVisibleActivitiesConfigurationLocked(r, false);
+ } finally {
+ mWindowManager.continueSurfaceLayout();
+ Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
+ }
+ }
+
+ private void removeStackInSurfaceTransaction(ActivityStack stack) {
+ final ArrayList<TaskRecord> tasks = stack.getAllTasks();
+ if (stack.getWindowingMode() == WINDOWING_MODE_PINNED) {
+ /**
+ * Workaround: Force-stop all the activities in the pinned stack before we reparent them
+ * to the fullscreen stack. This is to guarantee that when we are removing a stack,
+ * that the client receives onStop() before it is reparented. We do this by detaching
+ * the stack from the display so that it will be considered invisible when
+ * ensureActivitiesVisibleLocked() is called, and all of its activitys will be marked
+ * invisible as well and added to the stopping list. After which we process the
+ * stopping list by handling the idle.
+ */
+ final PinnedActivityStack pinnedStack = (PinnedActivityStack) stack;
+ pinnedStack.mForceHidden = true;
+ pinnedStack.ensureActivitiesVisibleLocked(null, 0, PRESERVE_WINDOWS);
+ pinnedStack.mForceHidden = false;
+ activityIdleInternalLocked(null, false /* fromTimeout */,
+ true /* processPausingActivites */, null /* configuration */);
+
+ // Move all the tasks to the bottom of the fullscreen stack
+ moveTasksToFullscreenStackLocked(pinnedStack, !ON_TOP);
+ } else {
+ for (int i = tasks.size() - 1; i >= 0; i--) {
+ removeTaskByIdLocked(tasks.get(i).taskId, true /* killProcess */,
+ REMOVE_FROM_RECENTS, "remove-stack");
+ }
+ }
+ }
+
+ /**
+ * Removes the stack associated with the given {@param stack}. If the {@param stack} is the
+ * pinned stack, then its tasks are not explicitly removed when the stack is destroyed, but
+ * instead moved back onto the fullscreen stack.
+ */
+ void removeStack(ActivityStack stack) {
+ mWindowManager.inSurfaceTransaction(() -> removeStackInSurfaceTransaction(stack));
+ }
+
+ /**
+ * Removes stacks in the input windowing modes from the system if they are of activity type
+ * ACTIVITY_TYPE_STANDARD or ACTIVITY_TYPE_UNDEFINED
+ */
+ void removeStacksInWindowingModes(int... windowingModes) {
+ for (int i = mActivityDisplays.size() - 1; i >= 0; --i) {
+ mActivityDisplays.get(i).removeStacksInWindowingModes(windowingModes);
+ }
+ }
+
+ void removeStacksWithActivityTypes(int... activityTypes) {
+ for (int i = mActivityDisplays.size() - 1; i >= 0; --i) {
+ mActivityDisplays.get(i).removeStacksWithActivityTypes(activityTypes);
+ }
+ }
+
+ /**
+ * See {@link #removeTaskByIdLocked(int, boolean, boolean, boolean)}
+ */
+ boolean removeTaskByIdLocked(int taskId, boolean killProcess, boolean removeFromRecents,
+ String reason) {
+ return removeTaskByIdLocked(taskId, killProcess, removeFromRecents, !PAUSE_IMMEDIATELY,
+ reason);
+ }
+
+ /**
+ * Removes the task with the specified task id.
+ *
+ * @param taskId Identifier of the task to be removed.
+ * @param killProcess Kill any process associated with the task if possible.
+ * @param removeFromRecents Whether to also remove the task from recents.
+ * @param pauseImmediately Pauses all task activities immediately without waiting for the
+ * pause-complete callback from the activity.
+ * @return Returns true if the given task was found and removed.
+ */
+ boolean removeTaskByIdLocked(int taskId, boolean killProcess, boolean removeFromRecents,
+ boolean pauseImmediately, String reason) {
+ final TaskRecord tr = anyTaskForIdLocked(taskId, MATCH_TASK_IN_STACKS_OR_RECENT_TASKS);
+ if (tr != null) {
+ tr.removeTaskActivitiesLocked(pauseImmediately, reason);
+ cleanUpRemovedTaskLocked(tr, killProcess, removeFromRecents);
+ mService.getLockTaskController().clearLockedTask(tr);
+ if (tr.isPersistable) {
+ mService.notifyTaskPersisterLocked(null, true);
+ }
+ return true;
+ }
+ Slog.w(TAG, "Request to remove task ignored for non-existent task " + taskId);
+ return false;
+ }
+
+ void cleanUpRemovedTaskLocked(TaskRecord tr, boolean killProcess, boolean removeFromRecents) {
+ if (removeFromRecents) {
+ mRecentTasks.remove(tr);
+ }
+ ComponentName component = tr.getBaseIntent().getComponent();
+ if (component == null) {
+ Slog.w(TAG, "No component for base intent of task: " + tr);
+ return;
+ }
+
+ // Find any running services associated with this app and stop if needed.
+ final Message msg = PooledLambda.obtainMessage(ActivityManagerInternal::cleanUpServices,
+ mService.mAmInternal, tr.userId, component, new Intent(tr.getBaseIntent()));
+ mService.mH.sendMessage(msg);
+
+ if (!killProcess) {
+ return;
+ }
+
+ // Determine if the process(es) for this task should be killed.
+ final String pkg = component.getPackageName();
+ ArrayList<Object> procsToKill = new ArrayList<>();
+ ArrayMap<String, SparseArray<WindowProcessController>> pmap =
+ mService.mProcessNames.getMap();
+ for (int i = 0; i < pmap.size(); i++) {
+
+ SparseArray<WindowProcessController> uids = pmap.valueAt(i);
+ for (int j = 0; j < uids.size(); j++) {
+ WindowProcessController proc = uids.valueAt(j);
+ if (proc.mUserId != tr.userId) {
+ // Don't kill process for a different user.
+ continue;
+ }
+ if (proc == mService.mHomeProcess) {
+ // Don't kill the home process along with tasks from the same package.
+ continue;
+ }
+ if (!proc.mPkgList.contains(pkg)) {
+ // Don't kill process that is not associated with this task.
+ continue;
+ }
+
+ if (!proc.shouldKillProcessForRemovedTask(tr)) {
+ // Don't kill process(es) that has an activity in a different task that is also
+ // in recents, or has an activity not stopped.
+ return;
+ }
+
+ if (proc.hasForegroundServices()) {
+ // Don't kill process(es) with foreground service.
+ return;
+ }
+
+ // Add process to kill list.
+ procsToKill.add(proc);
+ }
+ }
+
+ // Kill the running processes. Post on handle since we don't want to hold the service lock
+ // while calling into AM.
+ final Message m = PooledLambda.obtainMessage(
+ ActivityManagerInternal::killProcessesForRemovedTask, mService.mAmInternal,
+ procsToKill);
+ mService.mH.sendMessage(m);
+ }
+
+ /**
+ * Called to restore the state of the task into the stack that it's supposed to go into.
+ *
+ * @param task The recent task to be restored.
+ * @param aOptions The activity options to use for restoration.
+ * @param onTop If the stack for the task should be the topmost on the display.
+ * @return true if the task has been restored successfully.
+ */
+ boolean restoreRecentTaskLocked(TaskRecord task, ActivityOptions aOptions, boolean onTop) {
+ final ActivityStack stack = getLaunchStack(null, aOptions, task, onTop);
+ final ActivityStack currentStack = task.getStack();
+ if (currentStack != null) {
+ // Task has already been restored once. See if we need to do anything more
+ if (currentStack == stack) {
+ // Nothing else to do since it is already restored in the right stack.
+ return true;
+ }
+ // Remove current stack association, so we can re-associate the task with the
+ // right stack below.
+ currentStack.removeTask(task, "restoreRecentTaskLocked", REMOVE_TASK_MODE_MOVING);
+ }
+
+ stack.addTask(task, onTop, "restoreRecentTask");
+ // TODO: move call for creation here and other place into Stack.addTask()
+ task.createWindowContainer(onTop, true /* showForAllUsers */);
+ if (DEBUG_RECENTS) Slog.v(TAG_RECENTS,
+ "Added restored task=" + task + " to stack=" + stack);
+ final ArrayList<ActivityRecord> activities = task.mActivities;
+ for (int activityNdx = activities.size() - 1; activityNdx >= 0; --activityNdx) {
+ activities.get(activityNdx).createWindowContainer();
+ }
+ return true;
+ }
+
+ @Override
+ public void onRecentTaskAdded(TaskRecord task) {
+ task.touchActiveTime();
+ }
+
+ @Override
+ public void onRecentTaskRemoved(TaskRecord task, boolean wasTrimmed, boolean killProcess) {
+ if (wasTrimmed) {
+ // Task was trimmed from the recent tasks list -- remove the active task record as well
+ // since the user won't really be able to go back to it
+ removeTaskByIdLocked(task.taskId, killProcess, false /* removeFromRecents */,
+ !PAUSE_IMMEDIATELY, "recent-task-trimmed");
+ }
+ task.removedFromRecents();
+ }
+
+ /**
+ * Move stack with all its existing content to specified display.
+ * @param stackId Id of stack to move.
+ * @param displayId Id of display to move stack to.
+ * @param onTop Indicates whether container should be place on top or on bottom.
+ */
+ void moveStackToDisplayLocked(int stackId, int displayId, boolean onTop) {
+ final ActivityDisplay activityDisplay = getActivityDisplayOrCreateLocked(displayId);
+ if (activityDisplay == null) {
+ throw new IllegalArgumentException("moveStackToDisplayLocked: Unknown displayId="
+ + displayId);
+ }
+ final ActivityStack stack = getStack(stackId);
+ if (stack == null) {
+ throw new IllegalArgumentException("moveStackToDisplayLocked: Unknown stackId="
+ + stackId);
+ }
+
+ final ActivityDisplay currentDisplay = stack.getDisplay();
+ if (currentDisplay == null) {
+ throw new IllegalStateException("moveStackToDisplayLocked: Stack with stack=" + stack
+ + " is not attached to any display.");
+ }
+
+ if (currentDisplay.mDisplayId == displayId) {
+ throw new IllegalArgumentException("Trying to move stack=" + stack
+ + " to its current displayId=" + displayId);
+ }
+
+ stack.reparent(activityDisplay, onTop);
+ // TODO(multi-display): resize stacks properly if moved from split-screen.
+ }
+
+ /**
+ * Returns the reparent target stack, creating the stack if necessary. This call also enforces
+ * the various checks on tasks that are going to be reparented from one stack to another.
+ */
+ // TODO: Look into changing users to this method to ActivityDisplay.resolveWindowingMode()
+ ActivityStack getReparentTargetStack(TaskRecord task, ActivityStack stack, boolean toTop) {
+ final ActivityStack prevStack = task.getStack();
+ final int stackId = stack.mStackId;
+ final boolean inMultiWindowMode = stack.inMultiWindowMode();
+
+ // Check that we aren't reparenting to the same stack that the task is already in
+ if (prevStack != null && prevStack.mStackId == stackId) {
+ Slog.w(TAG, "Can not reparent to same stack, task=" + task
+ + " already in stackId=" + stackId);
+ return prevStack;
+ }
+
+ // Ensure that we aren't trying to move into a multi-window stack without multi-window
+ // support
+ if (inMultiWindowMode && !mService.mSupportsMultiWindow) {
+ throw new IllegalArgumentException("Device doesn't support multi-window, can not"
+ + " reparent task=" + task + " to stack=" + stack);
+ }
+
+ // Ensure that we're not moving a task to a dynamic stack if device doesn't support
+ // multi-display.
+ if (stack.mDisplayId != DEFAULT_DISPLAY && !mService.mSupportsMultiDisplay) {
+ throw new IllegalArgumentException("Device doesn't support multi-display, can not"
+ + " reparent task=" + task + " to stackId=" + stackId);
+ }
+
+ // Ensure that we aren't trying to move into a freeform stack without freeform support
+ if (stack.getWindowingMode() == WINDOWING_MODE_FREEFORM
+ && !mService.mSupportsFreeformWindowManagement) {
+ throw new IllegalArgumentException("Device doesn't support freeform, can not reparent"
+ + " task=" + task);
+ }
+
+ // Leave the task in its current stack or a fullscreen stack if it isn't resizeable and the
+ // preferred stack is in multi-window mode.
+ if (inMultiWindowMode && !task.isResizeable()) {
+ Slog.w(TAG, "Can not move unresizeable task=" + task + " to multi-window stack=" + stack
+ + " Moving to a fullscreen stack instead.");
+ if (prevStack != null) {
+ return prevStack;
+ }
+ stack = stack.getDisplay().createStack(
+ WINDOWING_MODE_FULLSCREEN, stack.getActivityType(), toTop);
+ }
+ return stack;
+ }
+
+ boolean moveTopStackActivityToPinnedStackLocked(int stackId, Rect destBounds) {
+ final ActivityStack stack = getStack(stackId);
+ if (stack == null) {
+ throw new IllegalArgumentException(
+ "moveTopStackActivityToPinnedStackLocked: Unknown stackId=" + stackId);
+ }
+
+ final ActivityRecord r = stack.topRunningActivityLocked();
+ if (r == null) {
+ Slog.w(TAG, "moveTopStackActivityToPinnedStackLocked: No top running activity"
+ + " in stack=" + stack);
+ return false;
+ }
+
+ if (!mService.mForceResizableActivities && !r.supportsPictureInPicture()) {
+ Slog.w(TAG,
+ "moveTopStackActivityToPinnedStackLocked: Picture-In-Picture not supported for "
+ + " r=" + r);
+ return false;
+ }
+
+ moveActivityToPinnedStackLocked(r, null /* sourceBounds */, 0f /* aspectRatio */,
+ "moveTopActivityToPinnedStack");
+ return true;
+ }
+
+ void moveActivityToPinnedStackLocked(ActivityRecord r, Rect sourceHintBounds, float aspectRatio,
+ String reason) {
+
+ mWindowManager.deferSurfaceLayout();
+
+ final ActivityDisplay display = r.getStack().getDisplay();
+ PinnedActivityStack stack = display.getPinnedStack();
+
+ // This will clear the pinned stack by moving an existing task to the full screen stack,
+ // ensuring only one task is present.
+ if (stack != null) {
+ moveTasksToFullscreenStackLocked(stack, !ON_TOP);
+ }
+
+ // Need to make sure the pinned stack exist so we can resize it below...
+ stack = display.getOrCreateStack(WINDOWING_MODE_PINNED, r.getActivityType(), ON_TOP);
+
+ // Calculate the target bounds here before the task is reparented back into pinned windowing
+ // mode (which will reset the saved bounds)
+ final Rect destBounds = stack.getDefaultPictureInPictureBounds(aspectRatio);
+
+ try {
+ final TaskRecord task = r.getTask();
+ // Resize the pinned stack to match the current size of the task the activity we are
+ // going to be moving is currently contained in. We do this to have the right starting
+ // animation bounds for the pinned stack to the desired bounds the caller wants.
+ resizeStackLocked(stack, task.getOverrideBounds(), null /* tempTaskBounds */,
+ null /* tempTaskInsetBounds */, !PRESERVE_WINDOWS,
+ true /* allowResizeInDockedMode */, !DEFER_RESUME);
+
+ if (task.mActivities.size() == 1) {
+ // Defer resume until below, and do not schedule PiP changes until we animate below
+ task.reparent(stack, ON_TOP, REPARENT_MOVE_STACK_TO_FRONT, !ANIMATE, DEFER_RESUME,
+ false /* schedulePictureInPictureModeChange */, reason);
+ } else {
+ // There are multiple activities in the task and moving the top activity should
+ // reveal/leave the other activities in their original task.
+
+ // Currently, we don't support reparenting activities across tasks in two different
+ // stacks, so instead, just create a new task in the same stack, reparent the
+ // activity into that task, and then reparent the whole task to the new stack. This
+ // ensures that all the necessary work to migrate states in the old and new stacks
+ // is also done.
+ final TaskRecord newTask = task.getStack().createTaskRecord(
+ getNextTaskIdForUserLocked(r.userId), r.info, r.intent, null, null, true);
+ r.reparent(newTask, MAX_VALUE, "moveActivityToStack");
+
+ // Defer resume until below, and do not schedule PiP changes until we animate below
+ newTask.reparent(stack, ON_TOP, REPARENT_MOVE_STACK_TO_FRONT, !ANIMATE,
+ DEFER_RESUME, false /* schedulePictureInPictureModeChange */, reason);
+ }
+
+ // Reset the state that indicates it can enter PiP while pausing after we've moved it
+ // to the pinned stack
+ r.supportsEnterPipOnTaskSwitch = false;
+ } finally {
+ mWindowManager.continueSurfaceLayout();
+ }
+
+ stack.animateResizePinnedStack(sourceHintBounds, destBounds, -1 /* animationDuration */,
+ true /* fromFullscreen */);
+
+ // Update the visibility of all activities after the they have been reparented to the new
+ // stack. This MUST run after the animation above is scheduled to ensure that the windows
+ // drawn signal is scheduled after the bounds animation start call on the bounds animator
+ // thread.
+ ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
+ resumeFocusedStacksTopActivitiesLocked();
+
+ mService.getTaskChangeNotificationController().notifyActivityPinned(r);
+ }
+
+ ActivityRecord findTaskLocked(ActivityRecord r, int preferredDisplayId) {
+ if (DEBUG_TASKS) Slog.d(TAG_TASKS, "Looking for task of " + r);
+ mTmpFindTaskResult.clear();
+
+ // Looking up task on preferred display first
+ final ActivityDisplay preferredDisplay = getActivityDisplay(preferredDisplayId);
+ if (preferredDisplay != null) {
+ preferredDisplay.findTaskLocked(r, true /* isPreferredDisplay */, mTmpFindTaskResult);
+ if (mTmpFindTaskResult.mIdealMatch) {
+ return mTmpFindTaskResult.mRecord;
+ }
+ }
+
+ for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
+ final ActivityDisplay display = mActivityDisplays.get(displayNdx);
+ if (display.mDisplayId == preferredDisplayId) {
+ continue;
+ }
+
+ display.findTaskLocked(r, false /* isPreferredDisplay */, mTmpFindTaskResult);
+ if (mTmpFindTaskResult.mIdealMatch) {
+ return mTmpFindTaskResult.mRecord;
+ }
+ }
+
+ if (DEBUG_TASKS && mTmpFindTaskResult.mRecord == null) Slog.d(TAG_TASKS, "No task found");
+ return mTmpFindTaskResult.mRecord;
+ }
+
+ ActivityRecord findActivityLocked(Intent intent, ActivityInfo info,
+ boolean compareIntentFilters) {
+ for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
+ final ActivityDisplay display = mActivityDisplays.get(displayNdx);
+ for (int stackNdx = display.getChildCount() - 1; stackNdx >= 0; --stackNdx) {
+ final ActivityStack stack = display.getChildAt(stackNdx);
+ final ActivityRecord ar = stack.findActivityLocked(
+ intent, info, compareIntentFilters);
+ if (ar != null) {
+ return ar;
+ }
+ }
+ }
+ return null;
+ }
+
+ boolean hasAwakeDisplay() {
+ for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
+ final ActivityDisplay display = mActivityDisplays.get(displayNdx);
+ if (!display.shouldSleep()) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ void goingToSleepLocked() {
+ scheduleSleepTimeout();
+ if (!mGoingToSleep.isHeld()) {
+ mGoingToSleep.acquire();
+ if (mLaunchingActivity.isHeld()) {
+ if (VALIDATE_WAKE_LOCK_CALLER && Binder.getCallingUid() != Process.myUid()) {
+ throw new IllegalStateException("Calling must be system uid");
+ }
+ mLaunchingActivity.release();
+ mHandler.removeMessages(LAUNCH_TIMEOUT_MSG);
+ }
+ }
+
+ applySleepTokensLocked(false /* applyToStacks */);
+
+ checkReadyForSleepLocked(true /* allowDelay */);
+ }
+
+ void prepareForShutdownLocked() {
+ for (int i = 0; i < mActivityDisplays.size(); i++) {
+ createSleepTokenLocked("shutdown", mActivityDisplays.get(i).mDisplayId);
+ }
+ }
+
+ boolean shutdownLocked(int timeout) {
+ goingToSleepLocked();
+
+ boolean timedout = false;
+ final long endTime = System.currentTimeMillis() + timeout;
+ while (true) {
+ if (!putStacksToSleepLocked(true /* allowDelay */, true /* shuttingDown */)) {
+ long timeRemaining = endTime - System.currentTimeMillis();
+ if (timeRemaining > 0) {
+ try {
+ mService.mGlobalLock.wait(timeRemaining);
+ } catch (InterruptedException e) {
+ }
+ } else {
+ Slog.w(TAG, "Activity manager shutdown timed out");
+ timedout = true;
+ break;
+ }
+ } else {
+ break;
+ }
+ }
+
+ // Force checkReadyForSleep to complete.
+ checkReadyForSleepLocked(false /* allowDelay */);
+
+ return timedout;
+ }
+
+ void comeOutOfSleepIfNeededLocked() {
+ removeSleepTimeouts();
+ if (mGoingToSleep.isHeld()) {
+ mGoingToSleep.release();
+ }
+ }
+
+ void applySleepTokensLocked(boolean applyToStacks) {
+ for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
+ // Set the sleeping state of the display.
+ final ActivityDisplay display = mActivityDisplays.get(displayNdx);
+ final boolean displayShouldSleep = display.shouldSleep();
+ if (displayShouldSleep == display.isSleeping()) {
+ continue;
+ }
+ display.setIsSleeping(displayShouldSleep);
+
+ if (!applyToStacks) {
+ continue;
+ }
+
+ // Set the sleeping state of the stacks on the display.
+ for (int stackNdx = display.getChildCount() - 1; stackNdx >= 0; --stackNdx) {
+ final ActivityStack stack = display.getChildAt(stackNdx);
+ if (displayShouldSleep) {
+ stack.goToSleepIfPossible(false /* shuttingDown */);
+ } else {
+ stack.awakeFromSleepingLocked();
+ if (stack.isFocusedStackOnDisplay() && !getKeyguardController()
+ .isKeyguardOrAodShowing(display.mDisplayId)) {
+ // If the keyguard is unlocked - resume immediately.
+ // It is possible that the display will not be awake at the time we
+ // process the keyguard going away, which can happen before the sleep token
+ // is released. As a result, it is important we resume the activity here.
+ resumeFocusedStacksTopActivitiesLocked();
+ }
+ }
+ }
+
+ if (displayShouldSleep || mGoingToSleepActivities.isEmpty()) {
+ continue;
+ }
+ // The display is awake now, so clean up the going to sleep list.
+ for (Iterator<ActivityRecord> it = mGoingToSleepActivities.iterator(); it.hasNext(); ) {
+ final ActivityRecord r = it.next();
+ if (r.getDisplayId() == display.mDisplayId) {
+ it.remove();
+ }
+ }
+ }
+ }
+
+ void activitySleptLocked(ActivityRecord r) {
+ mGoingToSleepActivities.remove(r);
+ final ActivityStack s = r.getStack();
+ if (s != null) {
+ s.checkReadyForSleep();
+ } else {
+ checkReadyForSleepLocked(true);
+ }
+ }
+
+ void checkReadyForSleepLocked(boolean allowDelay) {
+ if (!mService.isSleepingOrShuttingDownLocked()) {
+ // Do not care.
+ return;
+ }
+
+ if (!putStacksToSleepLocked(allowDelay, false /* shuttingDown */)) {
+ return;
+ }
+
+ // Send launch end powerhint before going sleep
+ sendPowerHintForLaunchEndIfNeeded();
+
+ removeSleepTimeouts();
+
+ if (mGoingToSleep.isHeld()) {
+ mGoingToSleep.release();
+ }
+ if (mService.mShuttingDown) {
+ mService.mGlobalLock.notifyAll();
+ }
+ }
+
+ // Tries to put all activity stacks to sleep. Returns true if all stacks were
+ // successfully put to sleep.
+ private boolean putStacksToSleepLocked(boolean allowDelay, boolean shuttingDown) {
+ boolean allSleep = true;
+ for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
+ final ActivityDisplay display = mActivityDisplays.get(displayNdx);
+ for (int stackNdx = display.getChildCount() - 1; stackNdx >= 0; --stackNdx) {
+ final ActivityStack stack = display.getChildAt(stackNdx);
+ if (allowDelay) {
+ allSleep &= stack.goToSleepIfPossible(shuttingDown);
+ } else {
+ stack.goToSleep();
+ }
+ }
+ }
+ return allSleep;
+ }
+
+ boolean reportResumedActivityLocked(ActivityRecord r) {
+ // A resumed activity cannot be stopping. remove from list
+ mStoppingActivities.remove(r);
+
+ final ActivityStack stack = r.getStack();
+ if (isTopDisplayFocusedStack(stack)) {
+ mService.updateUsageStats(r, true);
+ }
+ if (stack.getDisplay().allResumedActivitiesComplete()) {
+ ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
+ // Make sure activity & window visibility should be identical
+ // for all displays in this stage.
+ executeAppTransitionForAllDisplay();
+ return true;
+ }
+ return false;
+ }
+
+ void handleAppCrashLocked(WindowProcessController app) {
+ for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
+ final ActivityDisplay display = mActivityDisplays.get(displayNdx);
+ for (int stackNdx = display.getChildCount() - 1; stackNdx >= 0; --stackNdx) {
+ final ActivityStack stack = display.getChildAt(stackNdx);
+ stack.handleAppCrashLocked(app);
+ }
+ }
+ }
+
+ // Called when WindowManager has finished animating the launchingBehind activity to the back.
+ private void handleLaunchTaskBehindCompleteLocked(ActivityRecord r) {
+ final TaskRecord task = r.getTask();
+ final ActivityStack stack = task.getStack();
+
+ r.mLaunchTaskBehind = false;
+ mRecentTasks.add(task);
+ mService.getTaskChangeNotificationController().notifyTaskStackChanged();
+ r.setVisibility(false);
+
+ // When launching tasks behind, update the last active time of the top task after the new
+ // task has been shown briefly
+ final ActivityRecord top = stack.getTopActivity();
+ if (top != null) {
+ top.getTask().touchActiveTime();
+ }
+ }
+
+ void scheduleLaunchTaskBehindComplete(IBinder token) {
+ mHandler.obtainMessage(LAUNCH_TASK_BEHIND_COMPLETE, token).sendToTarget();
+ }
+
+ /**
+ * Make sure that all activities that need to be visible in the system actually are and update
+ * their configuration.
+ */
+ void ensureActivitiesVisibleLocked(ActivityRecord starting, int configChanges,
+ boolean preserveWindows) {
+ ensureActivitiesVisibleLocked(starting, configChanges, preserveWindows,
+ true /* notifyClients */);
+ }
+
+ /**
+ * @see #ensureActivitiesVisibleLocked(ActivityRecord, int, boolean)
+ */
+ void ensureActivitiesVisibleLocked(ActivityRecord starting, int configChanges,
+ boolean preserveWindows, boolean notifyClients) {
+ getKeyguardController().beginActivityVisibilityUpdate();
+ try {
+ // First the front stacks. In case any are not fullscreen and are in front of home.
+ for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
+ final ActivityDisplay display = mActivityDisplays.get(displayNdx);
+ for (int stackNdx = display.getChildCount() - 1; stackNdx >= 0; --stackNdx) {
+ final ActivityStack stack = display.getChildAt(stackNdx);
+ stack.ensureActivitiesVisibleLocked(starting, configChanges, preserveWindows,
+ notifyClients);
+ }
+ }
+ } finally {
+ getKeyguardController().endActivityVisibilityUpdate();
+ }
+ }
+
+ void addStartingWindowsForVisibleActivities(boolean taskSwitch) {
+ for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
+ final ActivityDisplay display = mActivityDisplays.get(displayNdx);
+ for (int stackNdx = display.getChildCount() - 1; stackNdx >= 0; --stackNdx) {
+ final ActivityStack stack = display.getChildAt(stackNdx);
+ stack.addStartingWindowsForVisibleActivities(taskSwitch);
+ }
+ }
+ }
+
+ void invalidateTaskLayers() {
+ mTaskLayersChanged = true;
+ }
+
+ void rankTaskLayersIfNeeded() {
+ if (!mTaskLayersChanged) {
+ return;
+ }
+ mTaskLayersChanged = false;
+ for (int displayNdx = 0; displayNdx < mActivityDisplays.size(); displayNdx++) {
+ final ActivityDisplay display = mActivityDisplays.get(displayNdx);
+ int baseLayer = 0;
+ for (int stackNdx = display.getChildCount() - 1; stackNdx >= 0; --stackNdx) {
+ final ActivityStack stack = display.getChildAt(stackNdx);
+ baseLayer += stack.rankTaskLayers(baseLayer);
+ }
+ }
+ }
+
+ void clearOtherAppTimeTrackers(AppTimeTracker except) {
+ for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
+ final ActivityDisplay display = mActivityDisplays.get(displayNdx);
+ for (int stackNdx = display.getChildCount() - 1; stackNdx >= 0; --stackNdx) {
+ final ActivityStack stack = display.getChildAt(stackNdx);
+ stack.clearOtherAppTimeTrackers(except);
+ }
+ }
+ }
+
+ void scheduleDestroyAllActivities(WindowProcessController app, String reason) {
+ for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
+ final ActivityDisplay display = mActivityDisplays.get(displayNdx);
+ for (int stackNdx = display.getChildCount() - 1; stackNdx >= 0; --stackNdx) {
+ final ActivityStack stack = display.getChildAt(stackNdx);
+ stack.scheduleDestroyActivities(app, reason);
+ }
+ }
+ }
+
+ void releaseSomeActivitiesLocked(WindowProcessController app, String reason) {
+ // Tasks is non-null only if two or more tasks are found.
+ ArraySet<TaskRecord> tasks = app.getReleaseSomeActivitiesTasks();
+ if (tasks == null) {
+ if (DEBUG_RELEASE) Slog.d(TAG_RELEASE, "Didn't find two or more tasks to release");
+ return;
+ }
+ // If we have activities in multiple tasks that are in a position to be destroyed,
+ // let's iterate through the tasks and release the oldest one.
+ final int numDisplays = mActivityDisplays.size();
+ for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
+ final ActivityDisplay display = mActivityDisplays.get(displayNdx);
+ final int stackCount = display.getChildCount();
+ // Step through all stacks starting from behind, to hit the oldest things first.
+ for (int stackNdx = 0; stackNdx < stackCount; stackNdx++) {
+ final ActivityStack stack = display.getChildAt(stackNdx);
+ // Try to release activities in this stack; if we manage to, we are done.
+ if (stack.releaseSomeActivitiesLocked(app, tasks, reason) > 0) {
+ return;
+ }
+ }
+ }
+ }
+
+ boolean switchUserLocked(int userId, UserState uss) {
+ final int focusStackId = getTopDisplayFocusedStack().getStackId();
+ // We dismiss the docked stack whenever we switch users.
+ final ActivityStack dockedStack = getDefaultDisplay().getSplitScreenPrimaryStack();
+ if (dockedStack != null) {
+ moveTasksToFullscreenStackLocked(dockedStack, dockedStack.isFocusedStackOnDisplay());
+ }
+ // Also dismiss the pinned stack whenever we switch users. Removing the pinned stack will
+ // also cause all tasks to be moved to the fullscreen stack at a position that is
+ // appropriate.
+ removeStacksInWindowingModes(WINDOWING_MODE_PINNED);
+
+ mUserStackInFront.put(mCurrentUser, focusStackId);
+ final int restoreStackId =
+ mUserStackInFront.get(userId, getDefaultDisplay().getHomeStack().mStackId);
+ mCurrentUser = userId;
+
+ mStartingUsers.add(uss);
+ for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
+ final ActivityDisplay display = mActivityDisplays.get(displayNdx);
+ for (int stackNdx = display.getChildCount() - 1; stackNdx >= 0; --stackNdx) {
+ final ActivityStack stack = display.getChildAt(stackNdx);
+ stack.switchUserLocked(userId);
+ TaskRecord task = stack.topTask();
+ if (task != null) {
+ stack.positionChildWindowContainerAtTop(task);
+ }
+ }
+ }
+
+ ActivityStack stack = getStack(restoreStackId);
+ if (stack == null) {
+ stack = getDefaultDisplay().getHomeStack();
+ }
+ final boolean homeInFront = stack.isActivityTypeHome();
+ if (stack.isOnHomeDisplay()) {
+ stack.moveToFront("switchUserOnHomeDisplay");
+ } else {
+ // Stack was moved to another display while user was swapped out.
+ resumeHomeActivity(null, "switchUserOnOtherDisplay", DEFAULT_DISPLAY);
+ }
+ return homeInFront;
+ }
+
+ /** Checks whether the userid is a profile of the current user. */
+ boolean isCurrentProfileLocked(int userId) {
+ if (userId == mCurrentUser) return true;
+ return mService.mAmInternal.isCurrentProfile(userId);
+ }
+
+ /**
+ * Returns whether a stopping activity is present that should be stopped after visible, rather
+ * than idle.
+ * @return {@code true} if such activity is present. {@code false} otherwise.
+ */
+ boolean isStoppingNoHistoryActivity() {
+ // Activities that are marked as nohistory should be stopped immediately after the resumed
+ // activity has become visible.
+ for (ActivityRecord record : mStoppingActivities) {
+ if (record.isNoHistory()) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ final ArrayList<ActivityRecord> processStoppingActivitiesLocked(ActivityRecord idleActivity,
+ boolean remove, boolean processPausingActivities) {
+ ArrayList<ActivityRecord> stops = null;
+
+ final boolean nowVisible = allResumedActivitiesVisible();
+ for (int activityNdx = mStoppingActivities.size() - 1; activityNdx >= 0; --activityNdx) {
+ ActivityRecord s = mStoppingActivities.get(activityNdx);
+ boolean waitingVisible = mActivitiesWaitingForVisibleActivity.contains(s);
+ if (DEBUG_STATES) Slog.v(TAG, "Stopping " + s + ": nowVisible=" + nowVisible
+ + " waitingVisible=" + waitingVisible + " finishing=" + s.finishing);
+ if (waitingVisible && nowVisible) {
+ mActivitiesWaitingForVisibleActivity.remove(s);
+ waitingVisible = false;
+ if (s.finishing) {
+ // If this activity is finishing, it is sitting on top of
+ // everyone else but we now know it is no longer needed...
+ // so get rid of it. Otherwise, we need to go through the
+ // normal flow and hide it once we determine that it is
+ // hidden by the activities in front of it.
+ if (DEBUG_STATES) Slog.v(TAG, "Before stopping, can hide: " + s);
+ s.setVisibility(false);
+ }
+ }
+ if (remove) {
+ final ActivityStack stack = s.getStack();
+ final boolean shouldSleepOrShutDown = stack != null
+ ? stack.shouldSleepOrShutDownActivities()
+ : mService.isSleepingOrShuttingDownLocked();
+ if (!waitingVisible || shouldSleepOrShutDown) {
+ if (!processPausingActivities && s.isState(PAUSING)) {
+ // Defer processing pausing activities in this iteration and reschedule
+ // a delayed idle to reprocess it again
+ removeTimeoutsForActivityLocked(idleActivity);
+ scheduleIdleTimeoutLocked(idleActivity);
+ continue;
+ }
+
+ if (DEBUG_STATES) Slog.v(TAG, "Ready to stop: " + s);
+ if (stops == null) {
+ stops = new ArrayList<>();
+ }
+ stops.add(s);
+
+ // Make sure to remove it in all cases in case we entered this block with
+ // shouldSleepOrShutDown
+ mActivitiesWaitingForVisibleActivity.remove(s);
+ mStoppingActivities.remove(activityNdx);
+ }
+ }
+ }
+
+ return stops;
+ }
+
+ void validateTopActivitiesLocked() {
+ for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
+ final ActivityDisplay display = mActivityDisplays.get(displayNdx);
+ for (int stackNdx = display.getChildCount() - 1; stackNdx >= 0; --stackNdx) {
+ final ActivityStack stack = display.getChildAt(stackNdx);
+ final ActivityRecord r = stack.topRunningActivityLocked();
+ final ActivityState state = r == null ? DESTROYED : r.getState();
+ if (isTopDisplayFocusedStack(stack)) {
+ if (r == null) Slog.e(TAG,
+ "validateTop...: null top activity, stack=" + stack);
+ else {
+ final ActivityRecord pausing = stack.mPausingActivity;
+ if (pausing != null && pausing == r) Slog.e(TAG,
+ "validateTop...: top stack has pausing activity r=" + r
+ + " state=" + state);
+ if (state != INITIALIZING && state != RESUMED) Slog.e(TAG,
+ "validateTop...: activity in front not resumed r=" + r
+ + " state=" + state);
+ }
+ } else {
+ final ActivityRecord resumed = stack.getResumedActivity();
+ if (resumed != null && resumed == r) Slog.e(TAG,
+ "validateTop...: back stack has resumed activity r=" + r
+ + " state=" + state);
+ if (r != null && (state == INITIALIZING || state == RESUMED)) Slog.e(TAG,
+ "validateTop...: activity in back resumed r=" + r + " state=" + state);
+ }
+ }
+ }
+ }
+
+ public void dumpDisplays(PrintWriter pw) {
+ for (int i = mActivityDisplays.size() - 1; i >= 0; --i) {
+ final ActivityDisplay display = mActivityDisplays.get(i);
+ pw.print("[id:" + display.mDisplayId + " stacks:");
+ display.dumpStacks(pw);
+ pw.print("]");
+ }
+ }
+
+ public void dump(PrintWriter pw, String prefix) {
+ pw.println();
+ pw.println("ActivityStackSupervisor state:");
+ pw.print(prefix);
+ pw.println("topDisplayFocusedStack=" + getTopDisplayFocusedStack());
+ pw.print(prefix);
+ pw.println("mCurTaskIdForUser=" + mCurTaskIdForUser);
+ pw.print(prefix); pw.println("mUserStackInFront=" + mUserStackInFront);
+ for (int i = mActivityDisplays.size() - 1; i >= 0; --i) {
+ final ActivityDisplay display = mActivityDisplays.get(i);
+ display.dump(pw, prefix);
+ }
+ if (!mWaitingForActivityVisible.isEmpty()) {
+ pw.print(prefix); pw.println("mWaitingForActivityVisible=");
+ for (int i = 0; i < mWaitingForActivityVisible.size(); ++i) {
+ pw.print(prefix); pw.print(prefix); mWaitingForActivityVisible.get(i).dump(pw, prefix);
+ }
+ }
+ pw.print(prefix); pw.print("isHomeRecentsComponent=");
+ pw.print(mRecentTasks.isRecentsComponentHomeActivity(mCurrentUser));
+
+ getKeyguardController().dump(pw, prefix);
+ mService.getLockTaskController().dump(pw, prefix);
+ }
+
+ public void writeToProto(ProtoOutputStream proto, long fieldId) {
+ final long token = proto.start(fieldId);
+ super.writeToProto(proto, CONFIGURATION_CONTAINER, false /* trim */);
+ for (int displayNdx = 0; displayNdx < mActivityDisplays.size(); ++displayNdx) {
+ final ActivityDisplay activityDisplay = mActivityDisplays.get(displayNdx);
+ activityDisplay.writeToProto(proto, DISPLAYS);
+ }
+ getKeyguardController().writeToProto(proto, KEYGUARD_CONTROLLER);
+ // TODO(b/111541062): Update tests to look for resumed activities on all displays
+ final ActivityStack focusedStack = getTopDisplayFocusedStack();
+ if (focusedStack != null) {
+ proto.write(FOCUSED_STACK_ID, focusedStack.mStackId);
+ final ActivityRecord focusedActivity = focusedStack.getDisplay().getResumedActivity();
+ if (focusedActivity != null) {
+ focusedActivity.writeIdentifierToProto(proto, RESUMED_ACTIVITY);
+ }
+ } else {
+ proto.write(FOCUSED_STACK_ID, INVALID_STACK_ID);
+ }
+ proto.write(IS_HOME_RECENTS_COMPONENT,
+ mRecentTasks.isRecentsComponentHomeActivity(mCurrentUser));
+ mService.getActivityStartController().writeToProto(proto, PENDING_ACTIVITIES);
+ proto.end(token);
+ }
+
+ /**
+ * Dump all connected displays' configurations.
+ * @param prefix Prefix to apply to each line of the dump.
+ */
+ void dumpDisplayConfigs(PrintWriter pw, String prefix) {
+ pw.print(prefix); pw.println("Display override configurations:");
+ final int displayCount = mActivityDisplays.size();
+ for (int i = 0; i < displayCount; i++) {
+ final ActivityDisplay activityDisplay = mActivityDisplays.get(i);
+ pw.print(prefix); pw.print(" "); pw.print(activityDisplay.mDisplayId); pw.print(": ");
+ pw.println(activityDisplay.getOverrideConfiguration());
+ }
+ }
+
+ /**
+ * Dumps the activities matching the given {@param name} in the either the focused stack
+ * or all visible stacks if {@param dumpVisibleStacks} is true.
+ */
+ ArrayList<ActivityRecord> getDumpActivitiesLocked(String name, boolean dumpVisibleStacksOnly,
+ boolean dumpFocusedStackOnly) {
+ if (dumpFocusedStackOnly) {
+ return getTopDisplayFocusedStack().getDumpActivitiesLocked(name);
+ } else {
+ ArrayList<ActivityRecord> activities = new ArrayList<>();
+ int numDisplays = mActivityDisplays.size();
+ for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
+ final ActivityDisplay display = mActivityDisplays.get(displayNdx);
+ for (int stackNdx = display.getChildCount() - 1; stackNdx >= 0; --stackNdx) {
+ final ActivityStack stack = display.getChildAt(stackNdx);
+ if (!dumpVisibleStacksOnly || stack.shouldBeVisible(null)) {
+ activities.addAll(stack.getDumpActivitiesLocked(name));
+ }
+ }
+ }
+ return activities;
+ }
+ }
+
+ static boolean printThisActivity(PrintWriter pw, ActivityRecord activity, String dumpPackage,
+ boolean needSep, String prefix) {
+ if (activity != null) {
+ if (dumpPackage == null || dumpPackage.equals(activity.packageName)) {
+ if (needSep) {
+ pw.println();
+ }
+ pw.print(prefix);
+ pw.println(activity);
+ return true;
+ }
+ }
+ return false;
+ }
+
+ boolean dumpActivitiesLocked(FileDescriptor fd, PrintWriter pw, boolean dumpAll,
+ boolean dumpClient, String dumpPackage) {
+ boolean printed = false;
+ boolean needSep = false;
+ for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
+ ActivityDisplay activityDisplay = mActivityDisplays.get(displayNdx);
+ pw.print("Display #"); pw.print(activityDisplay.mDisplayId);
+ pw.println(" (activities from top to bottom):");
+ final ActivityDisplay display = mActivityDisplays.get(displayNdx);
+ for (int stackNdx = display.getChildCount() - 1; stackNdx >= 0; --stackNdx) {
+ final ActivityStack stack = display.getChildAt(stackNdx);
+ pw.println();
+ pw.println(" Stack #" + stack.mStackId
+ + ": type=" + activityTypeToString(stack.getActivityType())
+ + " mode=" + windowingModeToString(stack.getWindowingMode()));
+ pw.println(" isSleeping=" + stack.shouldSleepActivities());
+ pw.println(" mBounds=" + stack.getOverrideBounds());
+
+ printed |= stack.dumpActivitiesLocked(fd, pw, dumpAll, dumpClient, dumpPackage,
+ needSep);
+
+ printed |= dumpHistoryList(fd, pw, stack.mLRUActivities, " ", "Run", false,
+ !dumpAll, false, dumpPackage, true,
+ " Running activities (most recent first):", null);
+
+ needSep = printed;
+ boolean pr = printThisActivity(pw, stack.mPausingActivity, dumpPackage, needSep,
+ " mPausingActivity: ");
+ if (pr) {
+ printed = true;
+ needSep = false;
+ }
+ pr = printThisActivity(pw, stack.getResumedActivity(), dumpPackage, needSep,
+ " mResumedActivity: ");
+ if (pr) {
+ printed = true;
+ needSep = false;
+ }
+ if (dumpAll) {
+ pr = printThisActivity(pw, stack.mLastPausedActivity, dumpPackage, needSep,
+ " mLastPausedActivity: ");
+ if (pr) {
+ printed = true;
+ needSep = true;
+ }
+ printed |= printThisActivity(pw, stack.mLastNoHistoryActivity, dumpPackage,
+ needSep, " mLastNoHistoryActivity: ");
+ }
+ needSep = printed;
+ }
+ printThisActivity(pw, activityDisplay.getResumedActivity(), dumpPackage, needSep,
+ " ResumedActivity:");
+ }
+
+ printed |= dumpHistoryList(fd, pw, mFinishingActivities, " ", "Fin", false, !dumpAll,
+ false, dumpPackage, true, " Activities waiting to finish:", null);
+ printed |= dumpHistoryList(fd, pw, mStoppingActivities, " ", "Stop", false, !dumpAll,
+ false, dumpPackage, true, " Activities waiting to stop:", null);
+ printed |= dumpHistoryList(fd, pw, mActivitiesWaitingForVisibleActivity, " ", "Wait",
+ false, !dumpAll, false, dumpPackage, true,
+ " Activities waiting for another to become visible:", null);
+ printed |= dumpHistoryList(fd, pw, mGoingToSleepActivities, " ", "Sleep", false, !dumpAll,
+ false, dumpPackage, true, " Activities waiting to sleep:", null);
+
+ return printed;
+ }
+
+ static boolean dumpHistoryList(FileDescriptor fd, PrintWriter pw, List<ActivityRecord> list,
+ String prefix, String label, boolean complete, boolean brief, boolean client,
+ String dumpPackage, boolean needNL, String header, TaskRecord lastTask) {
+ String innerPrefix = null;
+ String[] args = null;
+ boolean printed = false;
+ for (int i=list.size()-1; i>=0; i--) {
+ final ActivityRecord r = list.get(i);
+ if (dumpPackage != null && !dumpPackage.equals(r.packageName)) {
+ continue;
+ }
+ if (innerPrefix == null) {
+ innerPrefix = prefix + " ";
+ args = new String[0];
+ }
+ printed = true;
+ final boolean full = !brief && (complete || !r.isInHistory());
+ if (needNL) {
+ pw.println("");
+ needNL = false;
+ }
+ if (header != null) {
+ pw.println(header);
+ header = null;
+ }
+ if (lastTask != r.getTask()) {
+ lastTask = r.getTask();
+ pw.print(prefix);
+ pw.print(full ? "* " : " ");
+ pw.println(lastTask);
+ if (full) {
+ lastTask.dump(pw, prefix + " ");
+ } else if (complete) {
+ // Complete + brief == give a summary. Isn't that obvious?!?
+ if (lastTask.intent != null) {
+ pw.print(prefix); pw.print(" ");
+ pw.println(lastTask.intent.toInsecureStringWithClip());
+ }
+ }
+ }
+ pw.print(prefix); pw.print(full ? " * " : " "); pw.print(label);
+ pw.print(" #"); pw.print(i); pw.print(": ");
+ pw.println(r);
+ if (full) {
+ r.dump(pw, innerPrefix);
+ } else if (complete) {
+ // Complete + brief == give a summary. Isn't that obvious?!?
+ pw.print(innerPrefix); pw.println(r.intent.toInsecureString());
+ if (r.app != null) {
+ pw.print(innerPrefix); pw.println(r.app);
+ }
+ }
+ if (client && r.attachedToProcess()) {
+ // flush anything that is already in the PrintWriter since the thread is going
+ // to write to the file descriptor directly
+ pw.flush();
+ try {
+ TransferPipe tp = new TransferPipe();
+ try {
+ r.app.getThread().dumpActivity(
+ tp.getWriteFd(), r.appToken, innerPrefix, args);
+ // Short timeout, since blocking here can deadlock with the application.
+ tp.go(fd, 2000);
+ } finally {
+ tp.kill();
+ }
+ } catch (IOException e) {
+ pw.println(innerPrefix + "Failure while dumping the activity: " + e);
+ } catch (RemoteException e) {
+ pw.println(innerPrefix + "Got a RemoteException while dumping the activity");
+ }
+ needNL = true;
+ }
+ }
+ return printed;
+ }
+
+ void scheduleIdleTimeoutLocked(ActivityRecord next) {
+ if (DEBUG_IDLE) Slog.d(TAG_IDLE,
+ "scheduleIdleTimeoutLocked: Callers=" + Debug.getCallers(4));
+ Message msg = mHandler.obtainMessage(IDLE_TIMEOUT_MSG, next);
+ mHandler.sendMessageDelayed(msg, IDLE_TIMEOUT);
+ }
+
+ final void scheduleIdleLocked() {
+ mHandler.sendEmptyMessage(IDLE_NOW_MSG);
+ }
+
+ void removeTimeoutsForActivityLocked(ActivityRecord r) {
+ if (DEBUG_IDLE) Slog.d(TAG_IDLE, "removeTimeoutsForActivity: Callers="
+ + Debug.getCallers(4));
+ mHandler.removeMessages(IDLE_TIMEOUT_MSG, r);
+ }
+
+ final void scheduleResumeTopActivities() {
+ if (!mHandler.hasMessages(RESUME_TOP_ACTIVITY_MSG)) {
+ mHandler.sendEmptyMessage(RESUME_TOP_ACTIVITY_MSG);
+ }
+ }
+
+ void removeSleepTimeouts() {
+ mHandler.removeMessages(SLEEP_TIMEOUT_MSG);
+ }
+
+ final void scheduleSleepTimeout() {
+ removeSleepTimeouts();
+ mHandler.sendEmptyMessageDelayed(SLEEP_TIMEOUT_MSG, SLEEP_TIMEOUT);
+ }
+
+ @Override
+ public void onDisplayAdded(int displayId) {
+ if (DEBUG_STACK) Slog.v(TAG, "Display added displayId=" + displayId);
+ synchronized (mService.mGlobalLock) {
+ getActivityDisplayOrCreateLocked(displayId);
+ startHomeOnDisplay(mCurrentUser, "displayAdded", displayId);
+ }
+ }
+
+ @Override
+ public void onDisplayRemoved(int displayId) {
+ if (DEBUG_STACK) Slog.v(TAG, "Display removed displayId=" + displayId);
+ if (displayId == DEFAULT_DISPLAY) {
+ throw new IllegalArgumentException("Can't remove the primary display.");
+ }
+
+ synchronized (mService.mGlobalLock) {
+ final ActivityDisplay activityDisplay = getActivityDisplay(displayId);
+ if (activityDisplay == null) {
+ return;
+ }
+
+ activityDisplay.remove();
+ }
+ }
+
+ @Override
+ public void onDisplayChanged(int displayId) {
+ if (DEBUG_STACK) Slog.v(TAG, "Display changed displayId=" + displayId);
+ synchronized (mService.mGlobalLock) {
+ final ActivityDisplay activityDisplay = getActivityDisplay(displayId);
+ if (activityDisplay != null) {
+ activityDisplay.onDisplayChanged();
+ }
+ }
+ }
+
+ /** Check if display with specified id is added to the list. */
+ boolean isDisplayAdded(int displayId) {
+ return getActivityDisplayOrCreateLocked(displayId) != null;
+ }
+
+ // TODO: Look into consolidating with getActivityDisplayOrCreateLocked()
+ ActivityDisplay getActivityDisplay(int displayId) {
+ for (int i = mActivityDisplays.size() - 1; i >= 0; --i) {
+ final ActivityDisplay activityDisplay = mActivityDisplays.get(i);
+ if (activityDisplay.mDisplayId == displayId) {
+ return activityDisplay;
+ }
+ }
+ return null;
+ }
+
+ // TODO(multi-display): Look at all callpoints to make sure they make sense in multi-display.
+ ActivityDisplay getDefaultDisplay() {
+ return mDefaultDisplay;
+ }
+
+ /**
+ * Get an existing instance of {@link ActivityDisplay} or create new if there is a
+ * corresponding record in display manager.
+ */
+ // TODO: Look into consolidating with getActivityDisplay()
+ ActivityDisplay getActivityDisplayOrCreateLocked(int displayId) {
+ ActivityDisplay activityDisplay = getActivityDisplay(displayId);
+ if (activityDisplay != null) {
+ return activityDisplay;
+ }
+ if (mDisplayManager == null) {
+ // The system isn't fully initialized yet.
+ return null;
+ }
+ final Display display = mDisplayManager.getDisplay(displayId);
+ if (display == null) {
+ // The display is not registered in DisplayManager.
+ return null;
+ }
+ // The display hasn't been added to ActivityManager yet, create a new record now.
+ activityDisplay = new ActivityDisplay(this, display);
+ addChild(activityDisplay, ActivityDisplay.POSITION_BOTTOM);
+ return activityDisplay;
+ }
+
+ boolean startHomeOnAllDisplays(int userId, String reason) {
+ boolean homeStarted = false;
+ for (int i = mActivityDisplays.size() - 1; i >= 0; i--) {
+ final int displayId = mActivityDisplays.get(i).mDisplayId;
+ homeStarted |= startHomeOnDisplay(userId, reason, displayId);
+ }
+ return homeStarted;
+ }
+
+ /**
+ * This starts home activity on displays that can have system decorations and only if the
+ * home activity can have multiple instances.
+ */
+ boolean startHomeOnDisplay(int userId, String reason, int displayId) {
+ final Intent homeIntent = mService.getHomeIntent();
+ final ActivityInfo aInfo = resolveHomeActivity(userId, homeIntent);
+ if (aInfo == null) {
+ return false;
+ }
+
+ if (!canStartHomeOnDisplay(aInfo, displayId)) {
+ return false;
+ }
+
+ // Update the reason for ANR debugging to verify if the user activity is the one that
+ // actually launched.
+ final String myReason = reason + ":" + userId + ":" + UserHandle.getUserId(
+ aInfo.applicationInfo.uid);
+ mService.getActivityStartController().startHomeActivity(homeIntent, aInfo, myReason,
+ displayId);
+ return true;
+ }
+
+ /**
+ * This resolves the home activity info and updates the home component of the given intent.
+ * @return the home activity info if any.
+ */
+ private ActivityInfo resolveHomeActivity(int userId, Intent homeIntent) {
+ final int flags = ActivityManagerService.STOCK_PM_FLAGS;
+ final ComponentName comp = homeIntent.getComponent();
+ ActivityInfo aInfo = null;
+ try {
+ if (comp != null) {
+ // Factory test.
+ aInfo = AppGlobals.getPackageManager().getActivityInfo(comp, flags, userId);
+ } else {
+ final String resolvedType =
+ homeIntent.resolveTypeIfNeeded(mService.mContext.getContentResolver());
+ final ResolveInfo info = AppGlobals.getPackageManager()
+ .resolveIntent(homeIntent, resolvedType, flags, userId);
+ if (info != null) {
+ aInfo = info.activityInfo;
+ }
+ }
+ } catch (RemoteException e) {
+ // ignore
+ }
+
+ if (aInfo == null) {
+ Slog.wtf(TAG, "No home screen found for " + homeIntent, new Throwable());
+ return null;
+ }
+
+ homeIntent.setComponent(new ComponentName(aInfo.applicationInfo.packageName, aInfo.name));
+ aInfo = new ActivityInfo(aInfo);
+ aInfo.applicationInfo = mService.getAppInfoForUser(aInfo.applicationInfo, userId);
+ homeIntent.setFlags(homeIntent.getFlags() | FLAG_ACTIVITY_NEW_TASK);
+ return aInfo;
+ }
+
+ @VisibleForTesting
+ void addChild(ActivityDisplay activityDisplay, int position) {
+ positionChildAt(activityDisplay, position);
+ mWindowContainerController.positionChildAt(
+ activityDisplay.getWindowContainerController(), position);
+ }
+
+ void removeChild(ActivityDisplay activityDisplay) {
+ // The caller must tell the controller of {@link ActivityDisplay} to release its container
+ // {@link DisplayContent}. That is done in {@link ActivityDisplay#releaseSelfIfNeeded}).
+ mActivityDisplays.remove(activityDisplay);
+ }
+
+ private void calculateDefaultMinimalSizeOfResizeableTasks() {
+ final Resources res = mService.mContext.getResources();
+ final float minimalSize = res.getDimension(
+ com.android.internal.R.dimen.default_minimal_size_resizable_task);
+ final DisplayMetrics dm = res.getDisplayMetrics();
+
+ mDefaultMinSizeOfResizeableTaskDp = (int) (minimalSize / dm.density);
+ }
+
+ SleepToken createSleepTokenLocked(String tag, int displayId) {
+ final ActivityDisplay display = getActivityDisplay(displayId);
+ if (display == null) {
+ throw new IllegalArgumentException("Invalid display: " + displayId);
+ }
+
+ final SleepTokenImpl token = new SleepTokenImpl(tag, displayId);
+ mSleepTokens.add(token);
+ display.mAllSleepTokens.add(token);
+ return token;
+ }
+
+ private void removeSleepTokenLocked(SleepTokenImpl token) {
+ mSleepTokens.remove(token);
+
+ final ActivityDisplay display = getActivityDisplay(token.mDisplayId);
+ if (display != null) {
+ display.mAllSleepTokens.remove(token);
+ if (display.mAllSleepTokens.isEmpty()) {
+ mService.updateSleepIfNeededLocked();
+ }
+ }
+ }
+
+ private StackInfo getStackInfo(ActivityStack stack) {
+ final int displayId = stack.mDisplayId;
+ final ActivityDisplay display = getActivityDisplay(displayId);
+ StackInfo info = new StackInfo();
+ stack.getWindowContainerBounds(info.bounds);
+ info.displayId = displayId;
+ info.stackId = stack.mStackId;
+ info.userId = stack.mCurrentUser;
+ info.visible = stack.shouldBeVisible(null);
+ // A stack might be not attached to a display.
+ info.position = display != null ? display.getIndexOf(stack) : 0;
+ info.configuration.setTo(stack.getConfiguration());
+
+ ArrayList<TaskRecord> tasks = stack.getAllTasks();
+ final int numTasks = tasks.size();
+ int[] taskIds = new int[numTasks];
+ String[] taskNames = new String[numTasks];
+ Rect[] taskBounds = new Rect[numTasks];
+ int[] taskUserIds = new int[numTasks];
+ for (int i = 0; i < numTasks; ++i) {
+ final TaskRecord task = tasks.get(i);
+ taskIds[i] = task.taskId;
+ taskNames[i] = task.origActivity != null ? task.origActivity.flattenToString()
+ : task.realActivity != null ? task.realActivity.flattenToString()
+ : task.getTopActivity() != null ? task.getTopActivity().packageName
+ : "unknown";
+ taskBounds[i] = new Rect();
+ task.getWindowContainerBounds(taskBounds[i]);
+ taskUserIds[i] = task.userId;
+ }
+ info.taskIds = taskIds;
+ info.taskNames = taskNames;
+ info.taskBounds = taskBounds;
+ info.taskUserIds = taskUserIds;
+
+ final ActivityRecord top = stack.topRunningActivityLocked();
+ info.topActivity = top != null ? top.intent.getComponent() : null;
+ return info;
+ }
+
+ StackInfo getStackInfo(int stackId) {
+ ActivityStack stack = getStack(stackId);
+ if (stack != null) {
+ return getStackInfo(stack);
+ }
+ return null;
+ }
+
+ StackInfo getStackInfo(int windowingMode, int activityType) {
+ final ActivityStack stack = getStack(windowingMode, activityType);
+ return (stack != null) ? getStackInfo(stack) : null;
+ }
+
+ ArrayList<StackInfo> getAllStackInfosLocked() {
+ ArrayList<StackInfo> list = new ArrayList<>();
+ for (int displayNdx = 0; displayNdx < mActivityDisplays.size(); ++displayNdx) {
+ final ActivityDisplay display = mActivityDisplays.get(displayNdx);
+ for (int stackNdx = display.getChildCount() - 1; stackNdx >= 0; --stackNdx) {
+ final ActivityStack stack = display.getChildAt(stackNdx);
+ list.add(getStackInfo(stack));
+ }
+ }
+ return list;
+ }
+
+ void handleNonResizableTaskIfNeeded(TaskRecord task, int preferredWindowingMode,
+ int preferredDisplayId, ActivityStack actualStack) {
+ handleNonResizableTaskIfNeeded(task, preferredWindowingMode, preferredDisplayId,
+ actualStack, false /* forceNonResizable */);
+ }
+
+ void handleNonResizableTaskIfNeeded(TaskRecord task, int preferredWindowingMode,
+ int preferredDisplayId, ActivityStack actualStack, boolean forceNonResizable) {
+ final boolean isSecondaryDisplayPreferred =
+ (preferredDisplayId != DEFAULT_DISPLAY && preferredDisplayId != INVALID_DISPLAY);
+ final boolean inSplitScreenMode = actualStack != null
+ && actualStack.getDisplay().hasSplitScreenPrimaryStack();
+ if (((!inSplitScreenMode && preferredWindowingMode != WINDOWING_MODE_SPLIT_SCREEN_PRIMARY)
+ && !isSecondaryDisplayPreferred) || !task.isActivityTypeStandardOrUndefined()) {
+ return;
+ }
+
+ // Handle incorrect launch/move to secondary display if needed.
+ if (isSecondaryDisplayPreferred) {
+ final int actualDisplayId = task.getStack().mDisplayId;
+ if (!task.canBeLaunchedOnDisplay(actualDisplayId)) {
+ throw new IllegalStateException("Task resolved to incompatible display");
+ }
+ if (preferredDisplayId != actualDisplayId) {
+ Slog.w(TAG, "Failed to put " + task + " on display " + preferredDisplayId);
+ // Display a warning toast that we failed to put a task on a secondary display.
+ mService.getTaskChangeNotificationController()
+ .notifyActivityLaunchOnSecondaryDisplayFailed();
+ return;
+ } else if (!forceNonResizable && handleForcedResizableTask(task,
+ FORCED_RESIZEABLE_REASON_SECONDARY_DISPLAY)) {
+ return;
+ }
+ }
+
+ if (!task.supportsSplitScreenWindowingMode() || forceNonResizable) {
+ // Display a warning toast that we tried to put an app that doesn't support split-screen
+ // in split-screen.
+ mService.getTaskChangeNotificationController().notifyActivityDismissingDockedStack();
+
+ // Dismiss docked stack. If task appeared to be in docked stack but is not resizable -
+ // we need to move it to top of fullscreen stack, otherwise it will be covered.
+
+ final ActivityStack dockedStack =
+ task.getStack().getDisplay().getSplitScreenPrimaryStack();
+ if (dockedStack != null) {
+ moveTasksToFullscreenStackLocked(dockedStack, actualStack == dockedStack);
+ }
+ return;
+ }
+
+ handleForcedResizableTask(task, FORCED_RESIZEABLE_REASON_SPLIT_SCREEN);
+ }
+
+ /**
+ * @return {@code true} if the top activity of the task is forced to be resizable and the user
+ * was notified about activity being forced resized.
+ */
+ private boolean handleForcedResizableTask(TaskRecord task, int reason) {
+ final ActivityRecord topActivity = task.getTopActivity();
+ if (topActivity != null && topActivity.isNonResizableOrForcedResizable()
+ && !topActivity.noDisplay) {
+ final String packageName = topActivity.appInfo.packageName;
+ mService.getTaskChangeNotificationController().notifyActivityForcedResizable(
+ task.taskId, reason, packageName);
+ return true;
+ }
+ return false;
+ }
+
+ void activityRelaunchedLocked(IBinder token) {
+ mWindowManager.notifyAppRelaunchingFinished(token);
+ final ActivityRecord r = ActivityRecord.isInStackLocked(token);
+ if (r != null) {
+ if (r.getStack().shouldSleepOrShutDownActivities()) {
+ r.setSleeping(true, true);
+ }
+ }
+ }
+
+ void activityRelaunchingLocked(ActivityRecord r) {
+ mWindowManager.notifyAppRelaunching(r.appToken);
+ }
+
+ void logStackState() {
+ mActivityMetricsLogger.logWindowState();
+ }
+
+ void scheduleUpdateMultiWindowMode(TaskRecord task) {
+ // If the stack is animating in a way where we will be forcing a multi-mode change at the
+ // end, then ensure that we defer all in between multi-window mode changes
+ if (task.getStack().deferScheduleMultiWindowModeChanged()) {
+ return;
+ }
+
+ for (int i = task.mActivities.size() - 1; i >= 0; i--) {
+ final ActivityRecord r = task.mActivities.get(i);
+ if (r.attachedToProcess()) {
+ mMultiWindowModeChangedActivities.add(r);
+ }
+ }
+
+ if (!mHandler.hasMessages(REPORT_MULTI_WINDOW_MODE_CHANGED_MSG)) {
+ mHandler.sendEmptyMessage(REPORT_MULTI_WINDOW_MODE_CHANGED_MSG);
+ }
+ }
+
+ void scheduleUpdatePictureInPictureModeIfNeeded(TaskRecord task, ActivityStack prevStack) {
+ final ActivityStack stack = task.getStack();
+ if (prevStack == null || prevStack == stack
+ || (!prevStack.inPinnedWindowingMode() && !stack.inPinnedWindowingMode())) {
+ return;
+ }
+
+ scheduleUpdatePictureInPictureModeIfNeeded(task, stack.getOverrideBounds());
+ }
+
+ void scheduleUpdatePictureInPictureModeIfNeeded(TaskRecord task, Rect targetStackBounds) {
+ for (int i = task.mActivities.size() - 1; i >= 0; i--) {
+ final ActivityRecord r = task.mActivities.get(i);
+ if (r.attachedToProcess()) {
+ mPipModeChangedActivities.add(r);
+ // If we are scheduling pip change, then remove this activity from multi-window
+ // change list as the processing of pip change will make sure multi-window changed
+ // message is processed in the right order relative to pip changed.
+ mMultiWindowModeChangedActivities.remove(r);
+ }
+ }
+ mPipModeChangedTargetStackBounds = targetStackBounds;
+
+ if (!mHandler.hasMessages(REPORT_PIP_MODE_CHANGED_MSG)) {
+ mHandler.sendEmptyMessage(REPORT_PIP_MODE_CHANGED_MSG);
+ }
+ }
+
+ void updatePictureInPictureMode(TaskRecord task, Rect targetStackBounds, boolean forceUpdate) {
+ mHandler.removeMessages(REPORT_PIP_MODE_CHANGED_MSG);
+ for (int i = task.mActivities.size() - 1; i >= 0; i--) {
+ final ActivityRecord r = task.mActivities.get(i);
+ if (r.attachedToProcess()) {
+ r.updatePictureInPictureMode(targetStackBounds, forceUpdate);
+ }
+ }
+ }
+
+ void setDockedStackMinimized(boolean minimized) {
+ // Get currently focused stack before setting mIsDockMinimized. We do this because if
+ // split-screen is active, primary stack will not be focusable (see #isFocusable) while
+ // still occluding other stacks. This will cause getTopDisplayFocusedStack() to return null.
+ final ActivityStack current = getTopDisplayFocusedStack();
+ mIsDockMinimized = minimized;
+ if (mIsDockMinimized) {
+ if (current.inSplitScreenPrimaryWindowingMode()) {
+ // The primary split-screen stack can't be focused while it is minimize, so move
+ // focus to something else.
+ current.adjustFocusToNextFocusableStack("setDockedStackMinimized");
+ }
+ }
+ }
+
+ void wakeUp(String reason) {
+ mPowerManager.wakeUp(SystemClock.uptimeMillis(), "android.server.am:TURN_ON:" + reason);
+ }
+
+ /**
+ * Begin deferring resume to avoid duplicate resumes in one pass.
+ */
+ private void beginDeferResume() {
+ mDeferResumeCount++;
+ }
+
+ /**
+ * End deferring resume and determine if resume can be called.
+ */
+ private void endDeferResume() {
+ mDeferResumeCount--;
+ }
+
+ /**
+ * @return True if resume can be called.
+ */
+ private boolean readyToResume() {
+ return mDeferResumeCount == 0;
+ }
+
+ private final class ActivityStackSupervisorHandler extends Handler {
+
+ public ActivityStackSupervisorHandler(Looper looper) {
+ super(looper);
+ }
+
+ void activityIdleInternal(ActivityRecord r, boolean processPausingActivities) {
+ synchronized (mService.mGlobalLock) {
+ activityIdleInternalLocked(r != null ? r.appToken : null, true /* fromTimeout */,
+ processPausingActivities, null);
+ }
+ }
+
+ @Override
+ public void handleMessage(Message msg) {
+ switch (msg.what) {
+ case REPORT_MULTI_WINDOW_MODE_CHANGED_MSG: {
+ synchronized (mService.mGlobalLock) {
+ for (int i = mMultiWindowModeChangedActivities.size() - 1; i >= 0; i--) {
+ final ActivityRecord r = mMultiWindowModeChangedActivities.remove(i);
+ r.updateMultiWindowMode();
+ }
+ }
+ } break;
+ case REPORT_PIP_MODE_CHANGED_MSG: {
+ synchronized (mService.mGlobalLock) {
+ for (int i = mPipModeChangedActivities.size() - 1; i >= 0; i--) {
+ final ActivityRecord r = mPipModeChangedActivities.remove(i);
+ r.updatePictureInPictureMode(mPipModeChangedTargetStackBounds,
+ false /* forceUpdate */);
+ }
+ }
+ } break;
+ case IDLE_TIMEOUT_MSG: {
+ if (DEBUG_IDLE) Slog.d(TAG_IDLE,
+ "handleMessage: IDLE_TIMEOUT_MSG: r=" + msg.obj);
+ // We don't at this point know if the activity is fullscreen,
+ // so we need to be conservative and assume it isn't.
+ activityIdleInternal((ActivityRecord) msg.obj,
+ true /* processPausingActivities */);
+ } break;
+ case IDLE_NOW_MSG: {
+ if (DEBUG_IDLE) Slog.d(TAG_IDLE, "handleMessage: IDLE_NOW_MSG: r=" + msg.obj);
+ activityIdleInternal((ActivityRecord) msg.obj,
+ false /* processPausingActivities */);
+ } break;
+ case RESUME_TOP_ACTIVITY_MSG: {
+ synchronized (mService.mGlobalLock) {
+ resumeFocusedStacksTopActivitiesLocked();
+ }
+ } break;
+ case SLEEP_TIMEOUT_MSG: {
+ synchronized (mService.mGlobalLock) {
+ if (mService.isSleepingOrShuttingDownLocked()) {
+ Slog.w(TAG, "Sleep timeout! Sleeping now.");
+ checkReadyForSleepLocked(false /* allowDelay */);
+ }
+ }
+ } break;
+ case LAUNCH_TIMEOUT_MSG: {
+ synchronized (mService.mGlobalLock) {
+ if (mLaunchingActivity.isHeld()) {
+ Slog.w(TAG, "Launch timeout has expired, giving up wake lock!");
+ if (VALIDATE_WAKE_LOCK_CALLER
+ && Binder.getCallingUid() != Process.myUid()) {
+ throw new IllegalStateException("Calling must be system uid");
+ }
+ mLaunchingActivity.release();
+ }
+ }
+ } break;
+ case LAUNCH_TASK_BEHIND_COMPLETE: {
+ synchronized (mService.mGlobalLock) {
+ ActivityRecord r = ActivityRecord.forTokenLocked((IBinder) msg.obj);
+ if (r != null) {
+ handleLaunchTaskBehindCompleteLocked(r);
+ }
+ }
+ } break;
+
+ }
+ }
+ }
+
+ ActivityStack findStackBehind(ActivityStack stack) {
+ final ActivityDisplay display = getActivityDisplay(stack.mDisplayId);
+ if (display != null) {
+ for (int i = display.getChildCount() - 1; i >= 0; i--) {
+ if (display.getChildAt(i) == stack && i > 0) {
+ return display.getChildAt(i - 1);
+ }
+ }
+ }
+ throw new IllegalStateException("Failed to find a stack behind stack=" + stack
+ + " in=" + display);
+ }
+
+ /**
+ * Puts a task into resizing mode during the next app transition.
+ *
+ * @param task The task to put into resizing mode
+ */
+ void setResizingDuringAnimation(TaskRecord task) {
+ mResizingTasksDuringAnimation.add(task.taskId);
+ task.setTaskDockedResizing(true);
+ }
+
+ int startActivityFromRecents(int callingPid, int callingUid, int taskId,
+ SafeActivityOptions options) {
+ TaskRecord task = null;
+ final String callingPackage;
+ final Intent intent;
+ final int userId;
+ int activityType = ACTIVITY_TYPE_UNDEFINED;
+ int windowingMode = WINDOWING_MODE_UNDEFINED;
+ final ActivityOptions activityOptions = options != null
+ ? options.getOptions(this)
+ : null;
+ if (activityOptions != null) {
+ activityType = activityOptions.getLaunchActivityType();
+ windowingMode = activityOptions.getLaunchWindowingMode();
+ }
+ if (activityType == ACTIVITY_TYPE_HOME || activityType == ACTIVITY_TYPE_RECENTS) {
+ throw new IllegalArgumentException("startActivityFromRecents: Task "
+ + taskId + " can't be launch in the home/recents stack.");
+ }
+
+ mWindowManager.deferSurfaceLayout();
+ try {
+ if (windowingMode == WINDOWING_MODE_SPLIT_SCREEN_PRIMARY) {
+ mWindowManager.setDockedStackCreateState(
+ activityOptions.getSplitScreenCreateMode(), null /* initialBounds */);
+
+ // Defer updating the stack in which recents is until the app transition is done, to
+ // not run into issues where we still need to draw the task in recents but the
+ // docked stack is already created.
+ deferUpdateRecentsHomeStackBounds();
+ // TODO(multi-display): currently recents animation only support default display.
+ mWindowManager.prepareAppTransition(TRANSIT_DOCK_TASK_FROM_RECENTS, false);
+ }
+
+ task = anyTaskForIdLocked(taskId, MATCH_TASK_IN_STACKS_OR_RECENT_TASKS_AND_RESTORE,
+ activityOptions, ON_TOP);
+ if (task == null) {
+ continueUpdateRecentsHomeStackBounds();
+ mWindowManager.executeAppTransition();
+ throw new IllegalArgumentException(
+ "startActivityFromRecents: Task " + taskId + " not found.");
+ }
+
+ if (windowingMode != WINDOWING_MODE_SPLIT_SCREEN_PRIMARY) {
+ // We always want to return to the home activity instead of the recents activity
+ // from whatever is started from the recents activity, so move the home stack
+ // forward.
+ // TODO (b/115289124): Multi-display supports for recents.
+ getDefaultDisplay().moveHomeStackToFront("startActivityFromRecents");
+ }
+
+ // If the user must confirm credentials (e.g. when first launching a work app and the
+ // Work Challenge is present) let startActivityInPackage handle the intercepting.
+ if (!mService.mAmInternal.shouldConfirmCredentials(task.userId)
+ && task.getRootActivity() != null) {
+ final ActivityRecord targetActivity = task.getTopActivity();
+
+ sendPowerHintForLaunchStartIfNeeded(true /* forceSend */, targetActivity);
+ mActivityMetricsLogger.notifyActivityLaunching();
+ try {
+ mService.moveTaskToFrontLocked(task.taskId, 0, options,
+ true /* fromRecents */);
+ } finally {
+ mActivityMetricsLogger.notifyActivityLaunched(START_TASK_TO_FRONT,
+ targetActivity);
+ }
+
+ mService.getActivityStartController().postStartActivityProcessingForLastStarter(
+ task.getTopActivity(), ActivityManager.START_TASK_TO_FRONT,
+ task.getStack());
+ return ActivityManager.START_TASK_TO_FRONT;
+ }
+ callingPackage = task.mCallingPackage;
+ intent = task.intent;
+ intent.addFlags(Intent.FLAG_ACTIVITY_LAUNCHED_FROM_HISTORY);
+ userId = task.userId;
+ return mService.getActivityStartController().startActivityInPackage(
+ task.mCallingUid, callingPid, callingUid, callingPackage, intent, null, null,
+ null, 0, 0, options, userId, task, "startActivityFromRecents",
+ false /* validateIncomingUser */, null /* originatingPendingIntent */);
+ } finally {
+ if (windowingMode == WINDOWING_MODE_SPLIT_SCREEN_PRIMARY && task != null) {
+ // If we are launching the task in the docked stack, put it into resizing mode so
+ // the window renders full-screen with the background filling the void. Also only
+ // call this at the end to make sure that tasks exists on the window manager side.
+ setResizingDuringAnimation(task);
+
+ final ActivityDisplay display = task.getStack().getDisplay();
+ final ActivityStack topSecondaryStack =
+ display.getTopStackInWindowingMode(WINDOWING_MODE_SPLIT_SCREEN_SECONDARY);
+ if (topSecondaryStack.isActivityTypeHome()) {
+ // If the home activity is the top split-screen secondary stack, then the
+ // primary split-screen stack is in the minimized mode which means it can't
+ // receive input keys, so we should move the focused app to the home app so that
+ // window manager can correctly calculate the focus window that can receive
+ // input keys.
+ display.moveHomeStackToFront(
+ "startActivityFromRecents: homeVisibleInSplitScreen");
+
+ // Immediately update the minimized docked stack mode, the upcoming animation
+ // for the docked activity (WMS.overridePendingAppTransitionMultiThumbFuture)
+ // will do the animation to the target bounds
+ mWindowManager.checkSplitScreenMinimizedChanged(false /* animate */);
+ }
+ }
+ mWindowManager.continueSurfaceLayout();
+ }
+ }
+
+ /**
+ * @return a list of activities which are the top ones in each visible stack. The first
+ * entry will be the focused activity.
+ */
+ List<IBinder> getTopVisibleActivities() {
+ final ArrayList<IBinder> topActivityTokens = new ArrayList<>();
+ final ActivityStack topFocusedStack = getTopDisplayFocusedStack();
+ // Traverse all displays.
+ for (int i = mActivityDisplays.size() - 1; i >= 0; i--) {
+ final ActivityDisplay display = mActivityDisplays.get(i);
+ // Traverse all stacks on a display.
+ for (int j = display.getChildCount() - 1; j >= 0; --j) {
+ final ActivityStack stack = display.getChildAt(j);
+ // Get top activity from a visible stack and add it to the list.
+ if (stack.shouldBeVisible(null /* starting */)) {
+ final ActivityRecord top = stack.getTopActivity();
+ if (top != null) {
+ if (stack == topFocusedStack) {
+ topActivityTokens.add(0, top.appToken);
+ } else {
+ topActivityTokens.add(top.appToken);
+ }
+ }
+ }
+ }
+ }
+ return topActivityTokens;
+ }
+
+ /**
+ * Internal container to store a match qualifier alongside a WaitResult.
+ */
+ static class WaitInfo {
+ private final ComponentName mTargetComponent;
+ private final WaitResult mResult;
+ /** Time stamp when we started to wait for {@link WaitResult}. */
+ private final long mStartTimeMs;
+
+ WaitInfo(ComponentName targetComponent, WaitResult result, long startTimeMs) {
+ this.mTargetComponent = targetComponent;
+ this.mResult = result;
+ this.mStartTimeMs = startTimeMs;
+ }
+
+ public boolean matches(ComponentName targetComponent) {
+ return mTargetComponent == null || mTargetComponent.equals(targetComponent);
+ }
+
+ public WaitResult getResult() {
+ return mResult;
+ }
+
+ public long getStartTime() {
+ return mStartTimeMs;
+ }
+
+ public ComponentName getComponent() {
+ return mTargetComponent;
+ }
+
+ public void dump(PrintWriter pw, String prefix) {
+ pw.println(prefix + "WaitInfo:");
+ pw.println(prefix + " mTargetComponent=" + mTargetComponent);
+ pw.println(prefix + " mResult=");
+ mResult.dump(pw, prefix);
+ }
+ }
+
+ private final class SleepTokenImpl extends SleepToken {
+ private final String mTag;
+ private final long mAcquireTime;
+ private final int mDisplayId;
+
+ public SleepTokenImpl(String tag, int displayId) {
+ mTag = tag;
+ mDisplayId = displayId;
+ mAcquireTime = SystemClock.uptimeMillis();
+ }
+
+ @Override
+ public void release() {
+ synchronized (mService.mGlobalLock) {
+ removeSleepTokenLocked(this);
+ }
+ }
+
+ @Override
+ public String toString() {
+ return "{\"" + mTag + "\", display " + mDisplayId
+ + ", acquire at " + TimeUtils.formatUptime(mAcquireTime) + "}";
+ }
+ }
+
+}
diff --git a/services/core/java/com/android/server/wm/ActivityStartController.java b/services/core/java/com/android/server/wm/ActivityStartController.java
new file mode 100644
index 0000000..904d9dd
--- /dev/null
+++ b/services/core/java/com/android/server/wm/ActivityStartController.java
@@ -0,0 +1,495 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.server.wm;
+
+import static android.app.ActivityManager.START_SUCCESS;
+import static android.app.WindowConfiguration.ACTIVITY_TYPE_HOME;
+import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN;
+import static android.content.Intent.FLAG_ACTIVITY_NEW_TASK;
+import static android.os.FactoryTest.FACTORY_TEST_LOW_LEVEL;
+
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_ATM;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_WITH_CLASS_NAME;
+
+import android.app.ActivityOptions;
+import android.app.IApplicationThread;
+import android.content.ComponentName;
+import android.content.ContentResolver;
+import android.content.Intent;
+import android.content.pm.ActivityInfo;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageManager;
+import android.content.pm.ResolveInfo;
+import android.os.Binder;
+import android.os.Handler;
+import android.os.IBinder;
+import android.os.Looper;
+import android.os.Message;
+import android.os.UserHandle;
+import android.provider.Settings;
+import android.util.Slog;
+import android.util.proto.ProtoOutputStream;
+import android.view.RemoteAnimationAdapter;
+
+import com.android.internal.annotations.VisibleForTesting;
+import com.android.server.am.ActivityManagerService;
+import com.android.server.am.PendingIntentRecord;
+import com.android.server.wm.ActivityStackSupervisor.PendingActivityLaunch;
+import com.android.server.wm.ActivityStarter.DefaultFactory;
+import com.android.server.wm.ActivityStarter.Factory;
+
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Controller for delegating activity launches.
+ *
+ * This class' main objective is to take external activity start requests and prepare them into
+ * a series of discrete activity launches that can be handled by an {@link ActivityStarter}. It is
+ * also responsible for handling logic that happens around an activity launch, but doesn't
+ * necessarily influence the activity start. Examples include power hint management, processing
+ * through the pending activity list, and recording home activity launches.
+ */
+public class ActivityStartController {
+ private static final String TAG = TAG_WITH_CLASS_NAME ? "ActivityStartController" : TAG_ATM;
+
+ private static final int DO_PENDING_ACTIVITY_LAUNCHES_MSG = 1;
+
+ private final ActivityTaskManagerService mService;
+ private final ActivityStackSupervisor mSupervisor;
+
+ /** Last home activity record we attempted to start. */
+ private ActivityRecord mLastHomeActivityStartRecord;
+
+ /** Temporary array to capture start activity results */
+ private ActivityRecord[] tmpOutRecord = new ActivityRecord[1];
+
+ /** The result of the last home activity we attempted to start. */
+ private int mLastHomeActivityStartResult;
+
+ /** A list of activities that are waiting to launch. */
+ private final ArrayList<ActivityStackSupervisor.PendingActivityLaunch>
+ mPendingActivityLaunches = new ArrayList<>();
+
+ private final Factory mFactory;
+
+ private final Handler mHandler;
+
+ private final PendingRemoteAnimationRegistry mPendingRemoteAnimationRegistry;
+
+ boolean mCheckedForSetup = false;
+
+ private final class StartHandler extends Handler {
+ public StartHandler(Looper looper) {
+ super(looper, null, true);
+ }
+
+ @Override
+ public void handleMessage(Message msg) {
+ switch(msg.what) {
+ case DO_PENDING_ACTIVITY_LAUNCHES_MSG:
+ synchronized (mService.mGlobalLock) {
+ doPendingActivityLaunches(true);
+ }
+ break;
+ }
+ }
+ }
+
+ /**
+ * TODO(b/64750076): Capture information necessary for dump and
+ * {@link #postStartActivityProcessingForLastStarter} rather than keeping the entire object
+ * around
+ */
+ private ActivityStarter mLastStarter;
+
+ ActivityStartController(ActivityTaskManagerService service) {
+ this(service, service.mStackSupervisor,
+ new DefaultFactory(service, service.mStackSupervisor,
+ new ActivityStartInterceptor(service, service.mStackSupervisor)));
+ }
+
+ @VisibleForTesting
+ ActivityStartController(ActivityTaskManagerService service, ActivityStackSupervisor supervisor,
+ Factory factory) {
+ mService = service;
+ mSupervisor = supervisor;
+ mHandler = new StartHandler(mService.mH.getLooper());
+ mFactory = factory;
+ mFactory.setController(this);
+ mPendingRemoteAnimationRegistry = new PendingRemoteAnimationRegistry(service,
+ service.mH);
+ }
+
+ /**
+ * @return A starter to configure and execute starting an activity. It is valid until after
+ * {@link ActivityStarter#execute} is invoked. At that point, the starter should be
+ * considered invalid and no longer modified or used.
+ */
+ ActivityStarter obtainStarter(Intent intent, String reason) {
+ return mFactory.obtain().setIntent(intent).setReason(reason);
+ }
+
+ void onExecutionComplete(ActivityStarter starter) {
+ if (mLastStarter == null) {
+ mLastStarter = mFactory.obtain();
+ }
+
+ mLastStarter.set(starter);
+ mFactory.recycle(starter);
+ }
+
+ /**
+ * TODO(b/64750076): usage of this doesn't seem right. We're making decisions based off the
+ * last starter for an arbitrary task record. Re-evaluate whether we can remove.
+ */
+ void postStartActivityProcessingForLastStarter(ActivityRecord r, int result,
+ ActivityStack targetStack) {
+ if (mLastStarter == null) {
+ return;
+ }
+
+ mLastStarter.postStartActivityProcessing(r, result, targetStack);
+ }
+
+ void startHomeActivity(Intent intent, ActivityInfo aInfo, String reason, int displayId) {
+ final ActivityOptions options = ActivityOptions.makeBasic();
+ options.setLaunchWindowingMode(WINDOWING_MODE_FULLSCREEN);
+ options.setLaunchActivityType(ACTIVITY_TYPE_HOME);
+ options.setLaunchDisplayId(displayId);
+ mLastHomeActivityStartResult = obtainStarter(intent, "startHomeActivity: " + reason)
+ .setOutActivity(tmpOutRecord)
+ .setCallingUid(0)
+ .setActivityInfo(aInfo)
+ .setActivityOptions(options.toBundle())
+ .execute();
+ mLastHomeActivityStartRecord = tmpOutRecord[0];
+ if (mSupervisor.inResumeTopActivity) {
+ // If we are in resume section already, home activity will be initialized, but not
+ // resumed (to avoid recursive resume) and will stay that way until something pokes it
+ // again. We need to schedule another resume.
+ mSupervisor.scheduleResumeTopActivities();
+ }
+ }
+
+ /**
+ * Starts the "new version setup screen" if appropriate.
+ */
+ void startSetupActivity() {
+ // Only do this once per boot.
+ if (mCheckedForSetup) {
+ return;
+ }
+
+ // We will show this screen if the current one is a different
+ // version than the last one shown, and we are not running in
+ // low-level factory test mode.
+ final ContentResolver resolver = mService.mContext.getContentResolver();
+ if (mService.mFactoryTest != FACTORY_TEST_LOW_LEVEL
+ && Settings.Global.getInt(resolver, Settings.Global.DEVICE_PROVISIONED, 0) != 0) {
+ mCheckedForSetup = true;
+
+ // See if we should be showing the platform update setup UI.
+ final Intent intent = new Intent(Intent.ACTION_UPGRADE_SETUP);
+ final List<ResolveInfo> ris =
+ mService.mContext.getPackageManager().queryIntentActivities(intent,
+ PackageManager.MATCH_SYSTEM_ONLY | PackageManager.GET_META_DATA
+ | ActivityManagerService.STOCK_PM_FLAGS);
+ if (!ris.isEmpty()) {
+ final ResolveInfo ri = ris.get(0);
+ String vers = ri.activityInfo.metaData != null
+ ? ri.activityInfo.metaData.getString(Intent.METADATA_SETUP_VERSION)
+ : null;
+ if (vers == null && ri.activityInfo.applicationInfo.metaData != null) {
+ vers = ri.activityInfo.applicationInfo.metaData.getString(
+ Intent.METADATA_SETUP_VERSION);
+ }
+ String lastVers = Settings.Secure.getString(
+ resolver, Settings.Secure.LAST_SETUP_SHOWN);
+ if (vers != null && !vers.equals(lastVers)) {
+ intent.setFlags(FLAG_ACTIVITY_NEW_TASK);
+ intent.setComponent(new ComponentName(
+ ri.activityInfo.packageName, ri.activityInfo.name));
+ obtainStarter(intent, "startSetupActivity")
+ .setCallingUid(0)
+ .setActivityInfo(ri.activityInfo)
+ .execute();
+ }
+ }
+ }
+ }
+
+ /**
+ * If {@code validateIncomingUser} is true, check {@code targetUserId} against the real calling
+ * user ID inferred from {@code realCallingUid}, then return the resolved user-id, taking into
+ * account "current user", etc.
+ *
+ * If {@code validateIncomingUser} is false, it skips the above check, but instead
+ * ensures {@code targetUserId} is a real user ID and not a special user ID such as
+ * {@link android.os.UserHandle#USER_ALL}, etc.
+ */
+ int checkTargetUser(int targetUserId, boolean validateIncomingUser,
+ int realCallingPid, int realCallingUid, String reason) {
+ if (validateIncomingUser) {
+ return mService.handleIncomingUser(
+ realCallingPid, realCallingUid, targetUserId, reason);
+ } else {
+ mService.mAmInternal.ensureNotSpecialUser(targetUserId);
+ return targetUserId;
+ }
+ }
+
+ final int startActivityInPackage(int uid, int realCallingPid, int realCallingUid,
+ String callingPackage, Intent intent, String resolvedType, IBinder resultTo,
+ String resultWho, int requestCode, int startFlags, SafeActivityOptions options,
+ int userId, TaskRecord inTask, String reason, boolean validateIncomingUser,
+ PendingIntentRecord originatingPendingIntent) {
+
+ userId = checkTargetUser(userId, validateIncomingUser, realCallingPid, realCallingUid,
+ reason);
+
+ // TODO: Switch to user app stacks here.
+ return obtainStarter(intent, reason)
+ .setCallingUid(uid)
+ .setRealCallingPid(realCallingPid)
+ .setRealCallingUid(realCallingUid)
+ .setCallingPackage(callingPackage)
+ .setResolvedType(resolvedType)
+ .setResultTo(resultTo)
+ .setResultWho(resultWho)
+ .setRequestCode(requestCode)
+ .setStartFlags(startFlags)
+ .setActivityOptions(options)
+ .setMayWait(userId)
+ .setInTask(inTask)
+ .setOriginatingPendingIntent(originatingPendingIntent)
+ .execute();
+ }
+
+ /**
+ * Start intents as a package.
+ *
+ * @param uid Make a call as if this UID did.
+ * @param callingPackage Make a call as if this package did.
+ * @param intents Intents to start.
+ * @param userId Start the intents on this user.
+ * @param validateIncomingUser Set true to skip checking {@code userId} with the calling UID.
+ * @param originatingPendingIntent PendingIntentRecord that originated this activity start or
+ * null if not originated by PendingIntent
+ */
+ final int startActivitiesInPackage(int uid, String callingPackage, Intent[] intents,
+ String[] resolvedTypes, IBinder resultTo, SafeActivityOptions options, int userId,
+ boolean validateIncomingUser, PendingIntentRecord originatingPendingIntent) {
+
+ final String reason = "startActivityInPackage";
+
+ userId = checkTargetUser(userId, validateIncomingUser, Binder.getCallingPid(),
+ Binder.getCallingUid(), reason);
+
+ // TODO: Switch to user app stacks here.
+ return startActivities(null, uid, callingPackage, intents, resolvedTypes, resultTo, options,
+ userId, reason, originatingPendingIntent);
+ }
+
+ int startActivities(IApplicationThread caller, int callingUid, String callingPackage,
+ Intent[] intents, String[] resolvedTypes, IBinder resultTo, SafeActivityOptions options,
+ int userId, String reason, PendingIntentRecord originatingPendingIntent) {
+ if (intents == null) {
+ throw new NullPointerException("intents is null");
+ }
+ if (resolvedTypes == null) {
+ throw new NullPointerException("resolvedTypes is null");
+ }
+ if (intents.length != resolvedTypes.length) {
+ throw new IllegalArgumentException("intents are length different than resolvedTypes");
+ }
+
+ final int realCallingPid = Binder.getCallingPid();
+ final int realCallingUid = Binder.getCallingUid();
+
+ int callingPid;
+ if (callingUid >= 0) {
+ callingPid = -1;
+ } else if (caller == null) {
+ callingPid = realCallingPid;
+ callingUid = realCallingUid;
+ } else {
+ callingPid = callingUid = -1;
+ }
+ final long origId = Binder.clearCallingIdentity();
+ try {
+ synchronized (mService.mGlobalLock) {
+ ActivityRecord[] outActivity = new ActivityRecord[1];
+ for (int i=0; i < intents.length; i++) {
+ Intent intent = intents[i];
+ if (intent == null) {
+ continue;
+ }
+
+ // Refuse possible leaked file descriptors
+ if (intent != null && intent.hasFileDescriptors()) {
+ throw new IllegalArgumentException("File descriptors passed in Intent");
+ }
+
+ boolean componentSpecified = intent.getComponent() != null;
+
+ // Don't modify the client's object!
+ intent = new Intent(intent);
+
+ // Collect information about the target of the Intent.
+ ActivityInfo aInfo = mSupervisor.resolveActivity(intent, resolvedTypes[i], 0,
+ null, userId, ActivityStarter.computeResolveFilterUid(
+ callingUid, realCallingUid, UserHandle.USER_NULL));
+ // TODO: New, check if this is correct
+ aInfo = mService.mAmInternal.getActivityInfoForUser(aInfo, userId);
+
+ if (aInfo != null &&
+ (aInfo.applicationInfo.privateFlags
+ & ApplicationInfo.PRIVATE_FLAG_CANT_SAVE_STATE) != 0) {
+ throw new IllegalArgumentException(
+ "FLAG_CANT_SAVE_STATE not supported here");
+ }
+
+ final boolean top = i == intents.length - 1;
+ final SafeActivityOptions checkedOptions = top
+ ? options
+ : null;
+ final int res = obtainStarter(intent, reason)
+ .setCaller(caller)
+ .setResolvedType(resolvedTypes[i])
+ .setActivityInfo(aInfo)
+ .setResultTo(resultTo)
+ .setRequestCode(-1)
+ .setCallingPid(callingPid)
+ .setCallingUid(callingUid)
+ .setCallingPackage(callingPackage)
+ .setRealCallingPid(realCallingPid)
+ .setRealCallingUid(realCallingUid)
+ .setActivityOptions(checkedOptions)
+ .setComponentSpecified(componentSpecified)
+ .setOutActivity(outActivity)
+
+ // Top activity decides on animation being run, so we allow only for the
+ // top one as otherwise an activity below might consume it.
+ .setAllowPendingRemoteAnimationRegistryLookup(top /* allowLookup*/)
+ .setOriginatingPendingIntent(originatingPendingIntent)
+ .execute();
+
+ if (res < 0) {
+ return res;
+ }
+
+ resultTo = outActivity[0] != null ? outActivity[0].appToken : null;
+ }
+ }
+ } finally {
+ Binder.restoreCallingIdentity(origId);
+ }
+
+ return START_SUCCESS;
+ }
+
+ void schedulePendingActivityLaunches(long delayMs) {
+ mHandler.removeMessages(DO_PENDING_ACTIVITY_LAUNCHES_MSG);
+ Message msg = mHandler.obtainMessage(DO_PENDING_ACTIVITY_LAUNCHES_MSG);
+ mHandler.sendMessageDelayed(msg, delayMs);
+ }
+
+ void doPendingActivityLaunches(boolean doResume) {
+ while (!mPendingActivityLaunches.isEmpty()) {
+ final PendingActivityLaunch pal = mPendingActivityLaunches.remove(0);
+ final boolean resume = doResume && mPendingActivityLaunches.isEmpty();
+ final ActivityStarter starter = obtainStarter(null /* intent */,
+ "pendingActivityLaunch");
+ try {
+ starter.startResolvedActivity(pal.r, pal.sourceRecord, null, null, pal.startFlags,
+ resume, pal.r.pendingOptions, null, null /* outRecords */);
+ } catch (Exception e) {
+ Slog.e(TAG, "Exception during pending activity launch pal=" + pal, e);
+ pal.sendErrorResult(e.getMessage());
+ }
+ }
+ }
+
+ void addPendingActivityLaunch(PendingActivityLaunch launch) {
+ mPendingActivityLaunches.add(launch);
+ }
+
+ boolean clearPendingActivityLaunches(String packageName) {
+ final int pendingLaunches = mPendingActivityLaunches.size();
+
+ for (int palNdx = pendingLaunches - 1; palNdx >= 0; --palNdx) {
+ final PendingActivityLaunch pal = mPendingActivityLaunches.get(palNdx);
+ final ActivityRecord r = pal.r;
+ if (r != null && r.packageName.equals(packageName)) {
+ mPendingActivityLaunches.remove(palNdx);
+ }
+ }
+ return mPendingActivityLaunches.size() < pendingLaunches;
+ }
+
+ void registerRemoteAnimationForNextActivityStart(String packageName,
+ RemoteAnimationAdapter adapter) {
+ mPendingRemoteAnimationRegistry.addPendingAnimation(packageName, adapter);
+ }
+
+ PendingRemoteAnimationRegistry getPendingRemoteAnimationRegistry() {
+ return mPendingRemoteAnimationRegistry;
+ }
+
+ void dump(PrintWriter pw, String prefix, String dumpPackage) {
+ pw.print(prefix);
+ pw.print("mLastHomeActivityStartResult=");
+ pw.println(mLastHomeActivityStartResult);
+
+ if (mLastHomeActivityStartRecord != null) {
+ pw.print(prefix);
+ pw.println("mLastHomeActivityStartRecord:");
+ mLastHomeActivityStartRecord.dump(pw, prefix + " ");
+ }
+
+ final boolean dumpPackagePresent = dumpPackage != null;
+
+ if (mLastStarter != null) {
+ final boolean dump = !dumpPackagePresent
+ || mLastStarter.relatedToPackage(dumpPackage)
+ || (mLastHomeActivityStartRecord != null
+ && dumpPackage.equals(mLastHomeActivityStartRecord.packageName));
+
+ if (dump) {
+ pw.print(prefix);
+ mLastStarter.dump(pw, prefix + " ");
+
+ if (dumpPackagePresent) {
+ return;
+ }
+ }
+ }
+
+ if (dumpPackagePresent) {
+ pw.print(prefix);
+ pw.println("(nothing)");
+ }
+ }
+
+ public void writeToProto(ProtoOutputStream proto, long fieldId) {
+ for (PendingActivityLaunch activity: mPendingActivityLaunches) {
+ activity.r.writeIdentifierToProto(proto, fieldId);
+ }
+ }
+}
diff --git a/services/core/java/com/android/server/wm/ActivityStartInterceptor.java b/services/core/java/com/android/server/wm/ActivityStartInterceptor.java
new file mode 100644
index 0000000..ee5a43c
--- /dev/null
+++ b/services/core/java/com/android/server/wm/ActivityStartInterceptor.java
@@ -0,0 +1,347 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.server.wm;
+
+import static android.app.ActivityManager.INTENT_SENDER_ACTIVITY;
+import static android.app.ActivityOptions.ANIM_OPEN_CROSS_PROFILE_APPS;
+import static android.app.PendingIntent.FLAG_CANCEL_CURRENT;
+import static android.app.PendingIntent.FLAG_IMMUTABLE;
+import static android.app.PendingIntent.FLAG_ONE_SHOT;
+import static android.app.admin.DevicePolicyManager.EXTRA_RESTRICTION;
+import static android.app.admin.DevicePolicyManager.POLICY_SUSPEND_PACKAGES;
+import static android.content.Context.KEYGUARD_SERVICE;
+import static android.content.Intent.EXTRA_INTENT;
+import static android.content.Intent.EXTRA_PACKAGE_NAME;
+import static android.content.Intent.EXTRA_TASK_ID;
+import static android.content.Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS;
+import static android.content.Intent.FLAG_ACTIVITY_NEW_TASK;
+import static android.content.Intent.FLAG_ACTIVITY_TASK_ON_HOME;
+import static android.content.pm.ApplicationInfo.FLAG_SUSPENDED;
+
+import static com.android.server.pm.PackageManagerService.PLATFORM_PACKAGE_NAME;
+
+import android.app.ActivityOptions;
+import android.app.KeyguardManager;
+import android.app.admin.DevicePolicyManagerInternal;
+import android.content.Context;
+import android.content.IIntentSender;
+import android.content.Intent;
+import android.content.IntentSender;
+import android.content.pm.ActivityInfo;
+import android.content.pm.PackageManagerInternal;
+import android.content.pm.ResolveInfo;
+import android.content.pm.SuspendDialogInfo;
+import android.content.pm.UserInfo;
+import android.os.Binder;
+import android.os.Bundle;
+import android.os.RemoteException;
+import android.os.UserHandle;
+import android.os.UserManager;
+
+import com.android.internal.annotations.VisibleForTesting;
+import com.android.internal.app.HarmfulAppWarningActivity;
+import com.android.internal.app.SuspendedAppActivity;
+import com.android.internal.app.UnlaunchableAppActivity;
+import com.android.server.LocalServices;
+import com.android.server.am.ActivityManagerService;
+
+/**
+ * A class that contains activity intercepting logic for {@link ActivityStarter#startActivityLocked}
+ * It's initialized via setStates and interception occurs via the intercept method.
+ *
+ * Note that this class is instantiated when {@link ActivityManagerService} gets created so there
+ * is no guarantee that other system services are already present.
+ */
+class ActivityStartInterceptor {
+
+ private final ActivityTaskManagerService mService;
+ private final ActivityStackSupervisor mSupervisor;
+ private final Context mServiceContext;
+
+ // UserManager cannot be final as it's not ready when this class is instantiated during boot
+ private UserManager mUserManager;
+
+ /*
+ * Per-intent states loaded from ActivityStarter than shouldn't be changed by any
+ * interception routines.
+ */
+ private int mRealCallingPid;
+ private int mRealCallingUid;
+ private int mUserId;
+ private int mStartFlags;
+ private String mCallingPackage;
+
+ /*
+ * Per-intent states that were load from ActivityStarter and are subject to modifications
+ * by the interception routines. After calling {@link #intercept} the caller should assign
+ * these values back to {@link ActivityStarter#startActivityLocked}'s local variables if
+ * {@link #intercept} returns true.
+ */
+ Intent mIntent;
+ int mCallingPid;
+ int mCallingUid;
+ ResolveInfo mRInfo;
+ ActivityInfo mAInfo;
+ String mResolvedType;
+ TaskRecord mInTask;
+ ActivityOptions mActivityOptions;
+
+ ActivityStartInterceptor(
+ ActivityTaskManagerService service, ActivityStackSupervisor supervisor) {
+ this(service, supervisor, service.mContext);
+ }
+
+ @VisibleForTesting
+ ActivityStartInterceptor(ActivityTaskManagerService service, ActivityStackSupervisor supervisor,
+ Context context) {
+ mService = service;
+ mSupervisor = supervisor;
+ mServiceContext = context;
+ }
+
+ /**
+ * Effectively initialize the class before intercepting the start intent. The values set in this
+ * method should not be changed during intercept.
+ */
+ void setStates(int userId, int realCallingPid, int realCallingUid, int startFlags,
+ String callingPackage) {
+ mRealCallingPid = realCallingPid;
+ mRealCallingUid = realCallingUid;
+ mUserId = userId;
+ mStartFlags = startFlags;
+ mCallingPackage = callingPackage;
+ }
+
+ private IntentSender createIntentSenderForOriginalIntent(int callingUid, int flags) {
+ Bundle activityOptions = deferCrossProfileAppsAnimationIfNecessary();
+ final IIntentSender target = mService.getIntentSenderLocked(
+ INTENT_SENDER_ACTIVITY, mCallingPackage, callingUid, mUserId, null /*token*/,
+ null /*resultCode*/, 0 /*requestCode*/,
+ new Intent[] { mIntent }, new String[] { mResolvedType },
+ flags, activityOptions);
+ return new IntentSender(target);
+ }
+
+ /**
+ * Intercept the launch intent based on various signals. If an interception happened the
+ * internal variables get assigned and need to be read explicitly by the caller.
+ *
+ * @return true if an interception occurred
+ */
+ boolean intercept(Intent intent, ResolveInfo rInfo, ActivityInfo aInfo, String resolvedType,
+ TaskRecord inTask, int callingPid, int callingUid, ActivityOptions activityOptions) {
+ mUserManager = UserManager.get(mServiceContext);
+
+ mIntent = intent;
+ mCallingPid = callingPid;
+ mCallingUid = callingUid;
+ mRInfo = rInfo;
+ mAInfo = aInfo;
+ mResolvedType = resolvedType;
+ mInTask = inTask;
+ mActivityOptions = activityOptions;
+
+ if (interceptSuspendedPackageIfNeeded()) {
+ // Skip the rest of interceptions as the package is suspended by device admin so
+ // no user action can undo this.
+ return true;
+ }
+ if (interceptQuietProfileIfNeeded()) {
+ // If work profile is turned off, skip the work challenge since the profile can only
+ // be unlocked when profile's user is running.
+ return true;
+ }
+ if (interceptHarmfulAppIfNeeded()) {
+ // If the app has a "harmful app" warning associated with it, we should ask to uninstall
+ // before issuing the work challenge.
+ return true;
+ }
+ return interceptWorkProfileChallengeIfNeeded();
+ }
+
+ /**
+ * If the activity option is the {@link ActivityOptions#ANIM_OPEN_CROSS_PROFILE_APPS} one,
+ * defer the animation until the original intent is started.
+ *
+ * @return the activity option used to start the original intent.
+ */
+ private Bundle deferCrossProfileAppsAnimationIfNecessary() {
+ if (mActivityOptions != null
+ && mActivityOptions.getAnimationType() == ANIM_OPEN_CROSS_PROFILE_APPS) {
+ mActivityOptions = null;
+ return ActivityOptions.makeOpenCrossProfileAppsAnimation().toBundle();
+ }
+ return null;
+ }
+
+ private boolean interceptQuietProfileIfNeeded() {
+ // Do not intercept if the user has not turned off the profile
+ if (!mUserManager.isQuietModeEnabled(UserHandle.of(mUserId))) {
+ return false;
+ }
+
+ IntentSender target = createIntentSenderForOriginalIntent(mCallingUid,
+ FLAG_CANCEL_CURRENT | FLAG_ONE_SHOT);
+
+ mIntent = UnlaunchableAppActivity.createInQuietModeDialogIntent(mUserId, target);
+ mCallingPid = mRealCallingPid;
+ mCallingUid = mRealCallingUid;
+ mResolvedType = null;
+
+ final UserInfo parent = mUserManager.getProfileParent(mUserId);
+ mRInfo = mSupervisor.resolveIntent(mIntent, mResolvedType, parent.id, 0, mRealCallingUid);
+ mAInfo = mSupervisor.resolveActivity(mIntent, mRInfo, mStartFlags, null /*profilerInfo*/);
+ return true;
+ }
+
+ private boolean interceptSuspendedByAdminPackage() {
+ DevicePolicyManagerInternal devicePolicyManager = LocalServices
+ .getService(DevicePolicyManagerInternal.class);
+ if (devicePolicyManager == null) {
+ return false;
+ }
+ mIntent = devicePolicyManager.createShowAdminSupportIntent(mUserId, true);
+ mIntent.putExtra(EXTRA_RESTRICTION, POLICY_SUSPEND_PACKAGES);
+
+ mCallingPid = mRealCallingPid;
+ mCallingUid = mRealCallingUid;
+ mResolvedType = null;
+
+ final UserInfo parent = mUserManager.getProfileParent(mUserId);
+ if (parent != null) {
+ mRInfo = mSupervisor.resolveIntent(mIntent, mResolvedType, parent.id, 0,
+ mRealCallingUid);
+ } else {
+ mRInfo = mSupervisor.resolveIntent(mIntent, mResolvedType, mUserId, 0,
+ mRealCallingUid);
+ }
+ mAInfo = mSupervisor.resolveActivity(mIntent, mRInfo, mStartFlags, null /*profilerInfo*/);
+ return true;
+ }
+
+ private boolean interceptSuspendedPackageIfNeeded() {
+ // Do not intercept if the package is not suspended
+ if (mAInfo == null || mAInfo.applicationInfo == null ||
+ (mAInfo.applicationInfo.flags & FLAG_SUSPENDED) == 0) {
+ return false;
+ }
+ final PackageManagerInternal pmi = mService.getPackageManagerInternalLocked();
+ if (pmi == null) {
+ return false;
+ }
+ final String suspendedPackage = mAInfo.applicationInfo.packageName;
+ final String suspendingPackage = pmi.getSuspendingPackage(suspendedPackage, mUserId);
+ if (PLATFORM_PACKAGE_NAME.equals(suspendingPackage)) {
+ return interceptSuspendedByAdminPackage();
+ }
+ final SuspendDialogInfo dialogInfo = pmi.getSuspendedDialogInfo(suspendedPackage, mUserId);
+ mIntent = SuspendedAppActivity.createSuspendedAppInterceptIntent(suspendedPackage,
+ suspendingPackage, dialogInfo, mUserId);
+ mCallingPid = mRealCallingPid;
+ mCallingUid = mRealCallingUid;
+ mResolvedType = null;
+ mRInfo = mSupervisor.resolveIntent(mIntent, mResolvedType, mUserId, 0, mRealCallingUid);
+ mAInfo = mSupervisor.resolveActivity(mIntent, mRInfo, mStartFlags, null /*profilerInfo*/);
+ return true;
+ }
+
+ private boolean interceptWorkProfileChallengeIfNeeded() {
+ final Intent interceptingIntent = interceptWithConfirmCredentialsIfNeeded(mAInfo, mUserId);
+ if (interceptingIntent == null) {
+ return false;
+ }
+ mIntent = interceptingIntent;
+ mCallingPid = mRealCallingPid;
+ mCallingUid = mRealCallingUid;
+ mResolvedType = null;
+ // If we are intercepting and there was a task, convert it into an extra for the
+ // ConfirmCredentials intent and unassign it, as otherwise the task will move to
+ // front even if ConfirmCredentials is cancelled.
+ if (mInTask != null) {
+ mIntent.putExtra(EXTRA_TASK_ID, mInTask.taskId);
+ mInTask = null;
+ }
+ if (mActivityOptions == null) {
+ mActivityOptions = ActivityOptions.makeBasic();
+ }
+
+ ActivityRecord homeActivityRecord = mSupervisor.getDefaultDisplayHomeActivity();
+ if (homeActivityRecord != null && homeActivityRecord.getTask() != null) {
+ // Showing credential confirmation activity in home task to avoid stopping multi-windowed
+ // mode after showing the full-screen credential confirmation activity.
+ mActivityOptions.setLaunchTaskId(homeActivityRecord.getTask().taskId);
+ }
+
+ final UserInfo parent = mUserManager.getProfileParent(mUserId);
+ mRInfo = mSupervisor.resolveIntent(mIntent, mResolvedType, parent.id, 0, mRealCallingUid);
+ mAInfo = mSupervisor.resolveActivity(mIntent, mRInfo, mStartFlags, null /*profilerInfo*/);
+ return true;
+ }
+
+ /**
+ * Creates an intent to intercept the current activity start with Confirm Credentials if needed.
+ *
+ * @return The intercepting intent if needed.
+ */
+ private Intent interceptWithConfirmCredentialsIfNeeded(ActivityInfo aInfo, int userId) {
+ if (!mService.mAmInternal.shouldConfirmCredentials(userId)) {
+ return null;
+ }
+ // TODO(b/28935539): should allow certain activities to bypass work challenge
+ final IntentSender target = createIntentSenderForOriginalIntent(Binder.getCallingUid(),
+ FLAG_CANCEL_CURRENT | FLAG_ONE_SHOT | FLAG_IMMUTABLE);
+ final KeyguardManager km = (KeyguardManager) mServiceContext
+ .getSystemService(KEYGUARD_SERVICE);
+ final Intent newIntent = km.createConfirmDeviceCredentialIntent(null, null, userId);
+ if (newIntent == null) {
+ return null;
+ }
+ newIntent.setFlags(FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS |
+ FLAG_ACTIVITY_TASK_ON_HOME);
+ newIntent.putExtra(EXTRA_PACKAGE_NAME, aInfo.packageName);
+ newIntent.putExtra(EXTRA_INTENT, target);
+ return newIntent;
+ }
+
+ private boolean interceptHarmfulAppIfNeeded() {
+ CharSequence harmfulAppWarning;
+ try {
+ harmfulAppWarning = mService.getPackageManager()
+ .getHarmfulAppWarning(mAInfo.packageName, mUserId);
+ } catch (RemoteException ex) {
+ return false;
+ }
+
+ if (harmfulAppWarning == null) {
+ return false;
+ }
+
+ final IntentSender target = createIntentSenderForOriginalIntent(mCallingUid,
+ FLAG_CANCEL_CURRENT | FLAG_ONE_SHOT | FLAG_IMMUTABLE);
+
+ mIntent = HarmfulAppWarningActivity.createHarmfulAppWarningIntent(mServiceContext,
+ mAInfo.packageName, target, harmfulAppWarning);
+
+ mCallingPid = mRealCallingPid;
+ mCallingUid = mRealCallingUid;
+ mResolvedType = null;
+
+ mRInfo = mSupervisor.resolveIntent(mIntent, mResolvedType, mUserId, 0, mRealCallingUid);
+ mAInfo = mSupervisor.resolveActivity(mIntent, mRInfo, mStartFlags, null /*profilerInfo*/);
+ return true;
+ }
+}
diff --git a/services/core/java/com/android/server/wm/ActivityStarter.java b/services/core/java/com/android/server/wm/ActivityStarter.java
new file mode 100644
index 0000000..e43a79a
--- /dev/null
+++ b/services/core/java/com/android/server/wm/ActivityStarter.java
@@ -0,0 +1,2704 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.server.wm;
+
+import static android.app.Activity.RESULT_CANCELED;
+import static android.app.ActivityManager.START_ABORTED;
+import static android.app.ActivityManager.START_CANCELED;
+import static android.app.ActivityManager.START_CLASS_NOT_FOUND;
+import static android.app.ActivityManager.START_DELIVERED_TO_TOP;
+import static android.app.ActivityManager.START_FLAG_ONLY_IF_NEEDED;
+import static android.app.ActivityManager.START_RETURN_INTENT_TO_CALLER;
+import static android.app.ActivityManager.START_RETURN_LOCK_TASK_MODE_VIOLATION;
+import static android.app.ActivityManager.START_SUCCESS;
+import static android.app.ActivityManager.START_TASK_TO_FRONT;
+import static android.app.WindowConfiguration.WINDOWING_MODE_FREEFORM;
+import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN;
+import static android.app.WindowConfiguration.WINDOWING_MODE_PINNED;
+import static android.app.WindowConfiguration.WINDOWING_MODE_SPLIT_SCREEN_PRIMARY;
+import static android.app.WindowConfiguration.WINDOWING_MODE_SPLIT_SCREEN_SECONDARY;
+import static android.app.WindowConfiguration.WINDOWING_MODE_UNDEFINED;
+import static android.content.Intent.FLAG_ACTIVITY_CLEAR_TASK;
+import static android.content.Intent.FLAG_ACTIVITY_CLEAR_TOP;
+import static android.content.Intent.FLAG_ACTIVITY_LAUNCH_ADJACENT;
+import static android.content.Intent.FLAG_ACTIVITY_MULTIPLE_TASK;
+import static android.content.Intent.FLAG_ACTIVITY_NEW_DOCUMENT;
+import static android.content.Intent.FLAG_ACTIVITY_NEW_TASK;
+import static android.content.Intent.FLAG_ACTIVITY_NO_ANIMATION;
+import static android.content.Intent.FLAG_ACTIVITY_NO_USER_ACTION;
+import static android.content.Intent.FLAG_ACTIVITY_PREVIOUS_IS_TOP;
+import static android.content.Intent.FLAG_ACTIVITY_REORDER_TO_FRONT;
+import static android.content.Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED;
+import static android.content.Intent.FLAG_ACTIVITY_RETAIN_IN_RECENTS;
+import static android.content.Intent.FLAG_ACTIVITY_SINGLE_TOP;
+import static android.content.pm.ActivityInfo.DOCUMENT_LAUNCH_ALWAYS;
+import static android.content.pm.ActivityInfo.LAUNCH_MULTIPLE;
+import static android.content.pm.ActivityInfo.LAUNCH_SINGLE_INSTANCE;
+import static android.content.pm.ActivityInfo.LAUNCH_SINGLE_TASK;
+import static android.content.pm.ActivityInfo.LAUNCH_SINGLE_TOP;
+import static android.view.Display.DEFAULT_DISPLAY;
+import static android.view.Display.INVALID_DISPLAY;
+
+import static com.android.server.wm.ActivityStack.ActivityState.RESUMED;
+import static com.android.server.wm.ActivityStackSupervisor.DEFER_RESUME;
+import static com.android.server.wm.ActivityStackSupervisor.ON_TOP;
+import static com.android.server.wm.ActivityStackSupervisor.PRESERVE_WINDOWS;
+import static com.android.server.wm.ActivityStackSupervisor.TAG_TASKS;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_CONFIGURATION;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_FOCUS;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_PERMISSIONS_REVIEW;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_RESULTS;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_STACK;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_TASKS;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_USER_LEAVING;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_CONFIGURATION;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_FOCUS;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_RESULTS;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_USER_LEAVING;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_ATM;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_WITH_CLASS_NAME;
+import static com.android.server.wm.ActivityTaskManagerService.ANIMATE;
+import static com.android.server.am.EventLogTags.AM_NEW_INTENT;
+import static com.android.server.wm.TaskRecord.REPARENT_KEEP_STACK_AT_FRONT;
+import static com.android.server.wm.TaskRecord.REPARENT_MOVE_STACK_TO_FRONT;
+
+import android.annotation.NonNull;
+import android.annotation.Nullable;
+import android.app.ActivityManager;
+import android.app.ActivityOptions;
+import android.app.IApplicationThread;
+import android.app.PendingIntent;
+import android.app.ProfilerInfo;
+import android.app.WaitResult;
+import android.content.IIntentSender;
+import android.content.Intent;
+import android.content.IntentSender;
+import android.content.pm.ActivityInfo;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.AuxiliaryResolveInfo;
+import android.content.pm.PackageManager;
+import android.content.pm.ResolveInfo;
+import android.content.pm.UserInfo;
+import android.content.res.Configuration;
+import android.graphics.Rect;
+import android.os.Binder;
+import android.os.Bundle;
+import android.os.IBinder;
+import android.os.RemoteException;
+import android.os.SystemClock;
+import android.os.Trace;
+import android.os.UserHandle;
+import android.os.UserManager;
+import android.service.voice.IVoiceInteractionSession;
+import android.text.TextUtils;
+import android.util.EventLog;
+import android.util.Pools.SynchronizedPool;
+import android.util.Slog;
+
+import com.android.internal.annotations.VisibleForTesting;
+import com.android.internal.app.HeavyWeightSwitcherActivity;
+import com.android.internal.app.IVoiceInteractor;
+import com.android.server.am.EventLogTags;
+import com.android.server.am.PendingIntentRecord;
+import com.android.server.wm.ActivityStackSupervisor.PendingActivityLaunch;
+import com.android.server.wm.LaunchParamsController.LaunchParams;
+import com.android.server.pm.InstantAppResolver;
+
+import java.io.PrintWriter;
+import java.text.DateFormat;
+import java.util.Date;
+
+/**
+ * Controller for interpreting how and then launching an activity.
+ *
+ * This class collects all the logic for determining how an intent and flags should be turned into
+ * an activity and associated task and stack.
+ */
+class ActivityStarter {
+ private static final String TAG = TAG_WITH_CLASS_NAME ? "ActivityStarter" : TAG_ATM;
+ private static final String TAG_RESULTS = TAG + POSTFIX_RESULTS;
+ private static final String TAG_FOCUS = TAG + POSTFIX_FOCUS;
+ private static final String TAG_CONFIGURATION = TAG + POSTFIX_CONFIGURATION;
+ private static final String TAG_USER_LEAVING = TAG + POSTFIX_USER_LEAVING;
+ private static final int INVALID_LAUNCH_MODE = -1;
+
+ private final ActivityTaskManagerService mService;
+ private final ActivityStackSupervisor mSupervisor;
+ private final ActivityStartInterceptor mInterceptor;
+ private final ActivityStartController mController;
+
+ // Share state variable among methods when starting an activity.
+ private ActivityRecord mStartActivity;
+ private Intent mIntent;
+ private int mCallingUid;
+ private ActivityOptions mOptions;
+
+ private int mLaunchMode;
+ private boolean mLaunchTaskBehind;
+ private int mLaunchFlags;
+
+ private LaunchParams mLaunchParams = new LaunchParams();
+
+ private ActivityRecord mNotTop;
+ private boolean mDoResume;
+ private int mStartFlags;
+ private ActivityRecord mSourceRecord;
+
+ // The display to launch the activity onto, barring any strong reason to do otherwise.
+ private int mPreferredDisplayId;
+
+ private TaskRecord mInTask;
+ private boolean mAddingToTask;
+ private TaskRecord mReuseTask;
+
+ private ActivityInfo mNewTaskInfo;
+ private Intent mNewTaskIntent;
+ private ActivityStack mSourceStack;
+ private ActivityStack mTargetStack;
+ private boolean mMovedToFront;
+ private boolean mNoAnimation;
+ private boolean mKeepCurTransition;
+ private boolean mAvoidMoveToFront;
+
+ // We must track when we deliver the new intent since multiple code paths invoke
+ // {@link #deliverNewIntent}. This is due to early returns in the code path. This flag is used
+ // inside {@link #deliverNewIntent} to suppress duplicate requests and ensure the intent is
+ // delivered at most once.
+ private boolean mIntentDelivered;
+
+ private IVoiceInteractionSession mVoiceSession;
+ private IVoiceInteractor mVoiceInteractor;
+
+ // Last activity record we attempted to start
+ private final ActivityRecord[] mLastStartActivityRecord = new ActivityRecord[1];
+ // The result of the last activity we attempted to start.
+ private int mLastStartActivityResult;
+ // Time in milli seconds we attempted to start the last activity.
+ private long mLastStartActivityTimeMs;
+ // The reason we were trying to start the last activity
+ private String mLastStartReason;
+
+ /*
+ * Request details provided through setter methods. Should be reset after {@link #execute()}
+ * to avoid unnecessarily retaining parameters. Note that the request is ignored when
+ * {@link #startResolvedActivity} is invoked directly.
+ */
+ private Request mRequest = new Request();
+
+ /**
+ * An interface that to provide {@link ActivityStarter} instances to the controller. This is
+ * used by tests to inject their own starter implementations for verification purposes.
+ */
+ @VisibleForTesting
+ interface Factory {
+ /**
+ * Sets the {@link ActivityStartController} to be passed to {@link ActivityStarter}.
+ */
+ void setController(ActivityStartController controller);
+
+ /**
+ * Generates an {@link ActivityStarter} that is ready to handle a new start request.
+ * @param controller The {@link ActivityStartController} which the starter who will own
+ * this instance.
+ * @return an {@link ActivityStarter}
+ */
+ ActivityStarter obtain();
+
+ /**
+ * Recycles a starter for reuse.
+ */
+ void recycle(ActivityStarter starter);
+ }
+
+ /**
+ * Default implementation of {@link StarterFactory}.
+ */
+ static class DefaultFactory implements Factory {
+ /**
+ * The maximum count of starters that should be active at one time:
+ * 1. last ran starter (for logging and post activity processing)
+ * 2. current running starter
+ * 3. starter from re-entry in (2)
+ */
+ private final int MAX_STARTER_COUNT = 3;
+
+ private ActivityStartController mController;
+ private ActivityTaskManagerService mService;
+ private ActivityStackSupervisor mSupervisor;
+ private ActivityStartInterceptor mInterceptor;
+
+ private SynchronizedPool<ActivityStarter> mStarterPool =
+ new SynchronizedPool<>(MAX_STARTER_COUNT);
+
+ DefaultFactory(ActivityTaskManagerService service,
+ ActivityStackSupervisor supervisor, ActivityStartInterceptor interceptor) {
+ mService = service;
+ mSupervisor = supervisor;
+ mInterceptor = interceptor;
+ }
+
+ @Override
+ public void setController(ActivityStartController controller) {
+ mController = controller;
+ }
+
+ @Override
+ public ActivityStarter obtain() {
+ ActivityStarter starter = mStarterPool.acquire();
+
+ if (starter == null) {
+ starter = new ActivityStarter(mController, mService, mSupervisor, mInterceptor);
+ }
+
+ return starter;
+ }
+
+ @Override
+ public void recycle(ActivityStarter starter) {
+ starter.reset(true /* clearRequest*/);
+ mStarterPool.release(starter);
+ }
+ }
+
+ /**
+ * Container for capturing initial start request details. This information is NOT reset until
+ * the {@link ActivityStarter} is recycled, allowing for multiple invocations with the same
+ * parameters.
+ *
+ * TODO(b/64750076): Investigate consolidating member variables of {@link ActivityStarter} with
+ * the request object. Note that some member variables are referenced in
+ * {@link #dump(PrintWriter, String)} and therefore cannot be cleared immediately after
+ * execution.
+ */
+ private static class Request {
+ private static final int DEFAULT_CALLING_UID = -1;
+ private static final int DEFAULT_CALLING_PID = 0;
+
+ IApplicationThread caller;
+ Intent intent;
+ Intent ephemeralIntent;
+ String resolvedType;
+ ActivityInfo activityInfo;
+ ResolveInfo resolveInfo;
+ IVoiceInteractionSession voiceSession;
+ IVoiceInteractor voiceInteractor;
+ IBinder resultTo;
+ String resultWho;
+ int requestCode;
+ int callingPid = DEFAULT_CALLING_UID;
+ int callingUid = DEFAULT_CALLING_PID;
+ String callingPackage;
+ int realCallingPid;
+ int realCallingUid;
+ int startFlags;
+ SafeActivityOptions activityOptions;
+ boolean ignoreTargetSecurity;
+ boolean componentSpecified;
+ boolean avoidMoveToFront;
+ ActivityRecord[] outActivity;
+ TaskRecord inTask;
+ String reason;
+ ProfilerInfo profilerInfo;
+ Configuration globalConfig;
+ int userId;
+ WaitResult waitResult;
+ int filterCallingUid;
+ PendingIntentRecord originatingPendingIntent;
+
+ /**
+ * If set to {@code true}, allows this activity start to look into
+ * {@link PendingRemoteAnimationRegistry}
+ */
+ boolean allowPendingRemoteAnimationRegistryLookup;
+
+ /**
+ * Indicates that we should wait for the result of the start request. This flag is set when
+ * {@link ActivityStarter#setMayWait(int)} is called.
+ * {@see ActivityStarter#startActivityMayWait}.
+ */
+ boolean mayWait;
+
+ /**
+ * Ensure constructed request matches reset instance.
+ */
+ Request() {
+ reset();
+ }
+
+ /**
+ * Sets values back to the initial state, clearing any held references.
+ */
+ void reset() {
+ caller = null;
+ intent = null;
+ ephemeralIntent = null;
+ resolvedType = null;
+ activityInfo = null;
+ resolveInfo = null;
+ voiceSession = null;
+ voiceInteractor = null;
+ resultTo = null;
+ resultWho = null;
+ requestCode = 0;
+ callingPid = DEFAULT_CALLING_PID;
+ callingUid = DEFAULT_CALLING_UID;
+ callingPackage = null;
+ realCallingPid = 0;
+ realCallingUid = 0;
+ startFlags = 0;
+ activityOptions = null;
+ ignoreTargetSecurity = false;
+ componentSpecified = false;
+ outActivity = null;
+ inTask = null;
+ reason = null;
+ profilerInfo = null;
+ globalConfig = null;
+ userId = 0;
+ waitResult = null;
+ mayWait = false;
+ avoidMoveToFront = false;
+ allowPendingRemoteAnimationRegistryLookup = true;
+ filterCallingUid = UserHandle.USER_NULL;
+ originatingPendingIntent = null;
+ }
+
+ /**
+ * Adopts all values from passed in request.
+ */
+ void set(Request request) {
+ caller = request.caller;
+ intent = request.intent;
+ ephemeralIntent = request.ephemeralIntent;
+ resolvedType = request.resolvedType;
+ activityInfo = request.activityInfo;
+ resolveInfo = request.resolveInfo;
+ voiceSession = request.voiceSession;
+ voiceInteractor = request.voiceInteractor;
+ resultTo = request.resultTo;
+ resultWho = request.resultWho;
+ requestCode = request.requestCode;
+ callingPid = request.callingPid;
+ callingUid = request.callingUid;
+ callingPackage = request.callingPackage;
+ realCallingPid = request.realCallingPid;
+ realCallingUid = request.realCallingUid;
+ startFlags = request.startFlags;
+ activityOptions = request.activityOptions;
+ ignoreTargetSecurity = request.ignoreTargetSecurity;
+ componentSpecified = request.componentSpecified;
+ outActivity = request.outActivity;
+ inTask = request.inTask;
+ reason = request.reason;
+ profilerInfo = request.profilerInfo;
+ globalConfig = request.globalConfig;
+ userId = request.userId;
+ waitResult = request.waitResult;
+ mayWait = request.mayWait;
+ avoidMoveToFront = request.avoidMoveToFront;
+ allowPendingRemoteAnimationRegistryLookup
+ = request.allowPendingRemoteAnimationRegistryLookup;
+ filterCallingUid = request.filterCallingUid;
+ originatingPendingIntent = request.originatingPendingIntent;
+ }
+ }
+
+ ActivityStarter(ActivityStartController controller, ActivityTaskManagerService service,
+ ActivityStackSupervisor supervisor, ActivityStartInterceptor interceptor) {
+ mController = controller;
+ mService = service;
+ mSupervisor = supervisor;
+ mInterceptor = interceptor;
+ reset(true);
+ }
+
+ /**
+ * Effectively duplicates the starter passed in. All state and request values will be
+ * mirrored.
+ * @param starter
+ */
+ void set(ActivityStarter starter) {
+ mStartActivity = starter.mStartActivity;
+ mIntent = starter.mIntent;
+ mCallingUid = starter.mCallingUid;
+ mOptions = starter.mOptions;
+
+ mLaunchTaskBehind = starter.mLaunchTaskBehind;
+ mLaunchFlags = starter.mLaunchFlags;
+ mLaunchMode = starter.mLaunchMode;
+
+ mLaunchParams.set(starter.mLaunchParams);
+
+ mNotTop = starter.mNotTop;
+ mDoResume = starter.mDoResume;
+ mStartFlags = starter.mStartFlags;
+ mSourceRecord = starter.mSourceRecord;
+ mPreferredDisplayId = starter.mPreferredDisplayId;
+
+ mInTask = starter.mInTask;
+ mAddingToTask = starter.mAddingToTask;
+ mReuseTask = starter.mReuseTask;
+
+ mNewTaskInfo = starter.mNewTaskInfo;
+ mNewTaskIntent = starter.mNewTaskIntent;
+ mSourceStack = starter.mSourceStack;
+
+ mTargetStack = starter.mTargetStack;
+ mMovedToFront = starter.mMovedToFront;
+ mNoAnimation = starter.mNoAnimation;
+ mKeepCurTransition = starter.mKeepCurTransition;
+ mAvoidMoveToFront = starter.mAvoidMoveToFront;
+
+ mVoiceSession = starter.mVoiceSession;
+ mVoiceInteractor = starter.mVoiceInteractor;
+
+ mIntentDelivered = starter.mIntentDelivered;
+
+ mRequest.set(starter.mRequest);
+ }
+
+ ActivityRecord getStartActivity() {
+ return mStartActivity;
+ }
+
+ boolean relatedToPackage(String packageName) {
+ return (mLastStartActivityRecord[0] != null
+ && packageName.equals(mLastStartActivityRecord[0].packageName))
+ || (mStartActivity != null && packageName.equals(mStartActivity.packageName));
+ }
+
+ /**
+ * Starts an activity based on the request parameters provided earlier.
+ * @return The starter result.
+ */
+ int execute() {
+ try {
+ // TODO(b/64750076): Look into passing request directly to these methods to allow
+ // for transactional diffs and preprocessing.
+ if (mRequest.mayWait) {
+ return startActivityMayWait(mRequest.caller, mRequest.callingUid,
+ mRequest.callingPackage, mRequest.intent, mRequest.resolvedType,
+ mRequest.voiceSession, mRequest.voiceInteractor, mRequest.resultTo,
+ mRequest.resultWho, mRequest.requestCode, mRequest.startFlags,
+ mRequest.profilerInfo, mRequest.waitResult, mRequest.globalConfig,
+ mRequest.activityOptions, mRequest.ignoreTargetSecurity, mRequest.userId,
+ mRequest.inTask, mRequest.reason,
+ mRequest.allowPendingRemoteAnimationRegistryLookup,
+ mRequest.originatingPendingIntent);
+ } else {
+ return startActivity(mRequest.caller, mRequest.intent, mRequest.ephemeralIntent,
+ mRequest.resolvedType, mRequest.activityInfo, mRequest.resolveInfo,
+ mRequest.voiceSession, mRequest.voiceInteractor, mRequest.resultTo,
+ mRequest.resultWho, mRequest.requestCode, mRequest.callingPid,
+ mRequest.callingUid, mRequest.callingPackage, mRequest.realCallingPid,
+ mRequest.realCallingUid, mRequest.startFlags, mRequest.activityOptions,
+ mRequest.ignoreTargetSecurity, mRequest.componentSpecified,
+ mRequest.outActivity, mRequest.inTask, mRequest.reason,
+ mRequest.allowPendingRemoteAnimationRegistryLookup,
+ mRequest.originatingPendingIntent);
+ }
+ } finally {
+ onExecutionComplete();
+ }
+ }
+
+ /**
+ * Starts an activity based on the provided {@link ActivityRecord} and environment parameters.
+ * Note that this method is called internally as well as part of {@link #startActivity}.
+ *
+ * @return The start result.
+ */
+ int startResolvedActivity(final ActivityRecord r, ActivityRecord sourceRecord,
+ IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
+ int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
+ ActivityRecord[] outActivity) {
+ try {
+ return startActivity(r, sourceRecord, voiceSession, voiceInteractor, startFlags,
+ doResume, options, inTask, outActivity);
+ } finally {
+ onExecutionComplete();
+ }
+ }
+
+ private int startActivity(IApplicationThread caller, Intent intent, Intent ephemeralIntent,
+ String resolvedType, ActivityInfo aInfo, ResolveInfo rInfo,
+ IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
+ IBinder resultTo, String resultWho, int requestCode, int callingPid, int callingUid,
+ String callingPackage, int realCallingPid, int realCallingUid, int startFlags,
+ SafeActivityOptions options, boolean ignoreTargetSecurity, boolean componentSpecified,
+ ActivityRecord[] outActivity, TaskRecord inTask, String reason,
+ boolean allowPendingRemoteAnimationRegistryLookup,
+ PendingIntentRecord originatingPendingIntent) {
+
+ if (TextUtils.isEmpty(reason)) {
+ throw new IllegalArgumentException("Need to specify a reason.");
+ }
+ mLastStartReason = reason;
+ mLastStartActivityTimeMs = System.currentTimeMillis();
+ mLastStartActivityRecord[0] = null;
+
+ mLastStartActivityResult = startActivity(caller, intent, ephemeralIntent, resolvedType,
+ aInfo, rInfo, voiceSession, voiceInteractor, resultTo, resultWho, requestCode,
+ callingPid, callingUid, callingPackage, realCallingPid, realCallingUid, startFlags,
+ options, ignoreTargetSecurity, componentSpecified, mLastStartActivityRecord,
+ inTask, allowPendingRemoteAnimationRegistryLookup, originatingPendingIntent);
+
+ if (outActivity != null) {
+ // mLastStartActivityRecord[0] is set in the call to startActivity above.
+ outActivity[0] = mLastStartActivityRecord[0];
+ }
+
+ return getExternalResult(mLastStartActivityResult);
+ }
+
+ static int getExternalResult(int result) {
+ // Aborted results are treated as successes externally, but we must track them internally.
+ return result != START_ABORTED ? result : START_SUCCESS;
+ }
+
+ /**
+ * Called when execution is complete. Sets state indicating completion and proceeds with
+ * recycling if appropriate.
+ */
+ private void onExecutionComplete() {
+ mController.onExecutionComplete(this);
+ }
+
+ private int startActivity(IApplicationThread caller, Intent intent, Intent ephemeralIntent,
+ String resolvedType, ActivityInfo aInfo, ResolveInfo rInfo,
+ IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
+ IBinder resultTo, String resultWho, int requestCode, int callingPid, int callingUid,
+ String callingPackage, int realCallingPid, int realCallingUid, int startFlags,
+ SafeActivityOptions options,
+ boolean ignoreTargetSecurity, boolean componentSpecified, ActivityRecord[] outActivity,
+ TaskRecord inTask, boolean allowPendingRemoteAnimationRegistryLookup,
+ PendingIntentRecord originatingPendingIntent) {
+ int err = ActivityManager.START_SUCCESS;
+ // Pull the optional Ephemeral Installer-only bundle out of the options early.
+ final Bundle verificationBundle
+ = options != null ? options.popAppVerificationBundle() : null;
+
+ WindowProcessController callerApp = null;
+ if (caller != null) {
+ callerApp = mService.getProcessController(caller);
+ if (callerApp != null) {
+ callingPid = callerApp.getPid();
+ callingUid = callerApp.mInfo.uid;
+ } else {
+ Slog.w(TAG, "Unable to find app for caller " + caller
+ + " (pid=" + callingPid + ") when starting: "
+ + intent.toString());
+ err = ActivityManager.START_PERMISSION_DENIED;
+ }
+ }
+
+ final int userId = aInfo != null && aInfo.applicationInfo != null
+ ? UserHandle.getUserId(aInfo.applicationInfo.uid) : 0;
+
+ if (err == ActivityManager.START_SUCCESS) {
+ Slog.i(TAG, "START u" + userId + " {" + intent.toShortString(true, true, true, false)
+ + "} from uid " + callingUid);
+ }
+
+ ActivityRecord sourceRecord = null;
+ ActivityRecord resultRecord = null;
+ if (resultTo != null) {
+ sourceRecord = mSupervisor.isInAnyStackLocked(resultTo);
+ if (DEBUG_RESULTS) Slog.v(TAG_RESULTS,
+ "Will send result to " + resultTo + " " + sourceRecord);
+ if (sourceRecord != null) {
+ if (requestCode >= 0 && !sourceRecord.finishing) {
+ resultRecord = sourceRecord;
+ }
+ }
+ }
+
+ final int launchFlags = intent.getFlags();
+
+ if ((launchFlags & Intent.FLAG_ACTIVITY_FORWARD_RESULT) != 0 && sourceRecord != null) {
+ // Transfer the result target from the source activity to the new
+ // one being started, including any failures.
+ if (requestCode >= 0) {
+ SafeActivityOptions.abort(options);
+ return ActivityManager.START_FORWARD_AND_REQUEST_CONFLICT;
+ }
+ resultRecord = sourceRecord.resultTo;
+ if (resultRecord != null && !resultRecord.isInStackLocked()) {
+ resultRecord = null;
+ }
+ resultWho = sourceRecord.resultWho;
+ requestCode = sourceRecord.requestCode;
+ sourceRecord.resultTo = null;
+ if (resultRecord != null) {
+ resultRecord.removeResultsLocked(sourceRecord, resultWho, requestCode);
+ }
+ if (sourceRecord.launchedFromUid == callingUid) {
+ // The new activity is being launched from the same uid as the previous
+ // activity in the flow, and asking to forward its result back to the
+ // previous. In this case the activity is serving as a trampoline between
+ // the two, so we also want to update its launchedFromPackage to be the
+ // same as the previous activity. Note that this is safe, since we know
+ // these two packages come from the same uid; the caller could just as
+ // well have supplied that same package name itself. This specifially
+ // deals with the case of an intent picker/chooser being launched in the app
+ // flow to redirect to an activity picked by the user, where we want the final
+ // activity to consider it to have been launched by the previous app activity.
+ callingPackage = sourceRecord.launchedFromPackage;
+ }
+ }
+
+ if (err == ActivityManager.START_SUCCESS && intent.getComponent() == null) {
+ // We couldn't find a class that can handle the given Intent.
+ // That's the end of that!
+ err = ActivityManager.START_INTENT_NOT_RESOLVED;
+ }
+
+ if (err == ActivityManager.START_SUCCESS && aInfo == null) {
+ // We couldn't find the specific class specified in the Intent.
+ // Also the end of the line.
+ err = ActivityManager.START_CLASS_NOT_FOUND;
+ }
+
+ if (err == ActivityManager.START_SUCCESS && sourceRecord != null
+ && sourceRecord.getTask().voiceSession != null) {
+ // If this activity is being launched as part of a voice session, we need
+ // to ensure that it is safe to do so. If the upcoming activity will also
+ // be part of the voice session, we can only launch it if it has explicitly
+ // said it supports the VOICE category, or it is a part of the calling app.
+ if ((launchFlags & FLAG_ACTIVITY_NEW_TASK) == 0
+ && sourceRecord.info.applicationInfo.uid != aInfo.applicationInfo.uid) {
+ try {
+ intent.addCategory(Intent.CATEGORY_VOICE);
+ if (!mService.getPackageManager().activitySupportsIntent(
+ intent.getComponent(), intent, resolvedType)) {
+ Slog.w(TAG,
+ "Activity being started in current voice task does not support voice: "
+ + intent);
+ err = ActivityManager.START_NOT_VOICE_COMPATIBLE;
+ }
+ } catch (RemoteException e) {
+ Slog.w(TAG, "Failure checking voice capabilities", e);
+ err = ActivityManager.START_NOT_VOICE_COMPATIBLE;
+ }
+ }
+ }
+
+ if (err == ActivityManager.START_SUCCESS && voiceSession != null) {
+ // If the caller is starting a new voice session, just make sure the target
+ // is actually allowing it to run this way.
+ try {
+ if (!mService.getPackageManager().activitySupportsIntent(intent.getComponent(),
+ intent, resolvedType)) {
+ Slog.w(TAG,
+ "Activity being started in new voice task does not support: "
+ + intent);
+ err = ActivityManager.START_NOT_VOICE_COMPATIBLE;
+ }
+ } catch (RemoteException e) {
+ Slog.w(TAG, "Failure checking voice capabilities", e);
+ err = ActivityManager.START_NOT_VOICE_COMPATIBLE;
+ }
+ }
+
+ final ActivityStack resultStack = resultRecord == null ? null : resultRecord.getStack();
+
+ if (err != START_SUCCESS) {
+ if (resultRecord != null) {
+ resultStack.sendActivityResultLocked(
+ -1, resultRecord, resultWho, requestCode, RESULT_CANCELED, null);
+ }
+ SafeActivityOptions.abort(options);
+ return err;
+ }
+
+ boolean abort = !mSupervisor.checkStartAnyActivityPermission(intent, aInfo, resultWho,
+ requestCode, callingPid, callingUid, callingPackage, ignoreTargetSecurity,
+ inTask != null, callerApp, resultRecord, resultStack);
+ abort |= !mService.mIntentFirewall.checkStartActivity(intent, callingUid,
+ callingPid, resolvedType, aInfo.applicationInfo);
+
+ // Merge the two options bundles, while realCallerOptions takes precedence.
+ ActivityOptions checkedOptions = options != null
+ ? options.getOptions(intent, aInfo, callerApp, mSupervisor) : null;
+ if (allowPendingRemoteAnimationRegistryLookup) {
+ checkedOptions = mService.getActivityStartController()
+ .getPendingRemoteAnimationRegistry()
+ .overrideOptionsIfNeeded(callingPackage, checkedOptions);
+ }
+ if (mService.mController != null) {
+ try {
+ // The Intent we give to the watcher has the extra data
+ // stripped off, since it can contain private information.
+ Intent watchIntent = intent.cloneFilter();
+ abort |= !mService.mController.activityStarting(watchIntent,
+ aInfo.applicationInfo.packageName);
+ } catch (RemoteException e) {
+ mService.mController = null;
+ }
+ }
+
+ mInterceptor.setStates(userId, realCallingPid, realCallingUid, startFlags, callingPackage);
+ if (mInterceptor.intercept(intent, rInfo, aInfo, resolvedType, inTask, callingPid,
+ callingUid, checkedOptions)) {
+ // activity start was intercepted, e.g. because the target user is currently in quiet
+ // mode (turn off work) or the target application is suspended
+ intent = mInterceptor.mIntent;
+ rInfo = mInterceptor.mRInfo;
+ aInfo = mInterceptor.mAInfo;
+ resolvedType = mInterceptor.mResolvedType;
+ inTask = mInterceptor.mInTask;
+ callingPid = mInterceptor.mCallingPid;
+ callingUid = mInterceptor.mCallingUid;
+ checkedOptions = mInterceptor.mActivityOptions;
+ }
+
+ if (abort) {
+ if (resultRecord != null) {
+ resultStack.sendActivityResultLocked(-1, resultRecord, resultWho, requestCode,
+ RESULT_CANCELED, null);
+ }
+ // We pretend to the caller that it was really started, but
+ // they will just get a cancel result.
+ ActivityOptions.abort(checkedOptions);
+ return START_ABORTED;
+ }
+
+ // If permissions need a review before any of the app components can run, we
+ // launch the review activity and pass a pending intent to start the activity
+ // we are to launching now after the review is completed.
+ if (aInfo != null) {
+ if (mService.getPackageManagerInternalLocked().isPermissionsReviewRequired(
+ aInfo.packageName, userId)) {
+ IIntentSender target = mService.getIntentSenderLocked(
+ ActivityManager.INTENT_SENDER_ACTIVITY, callingPackage,
+ callingUid, userId, null, null, 0, new Intent[]{intent},
+ new String[]{resolvedType}, PendingIntent.FLAG_CANCEL_CURRENT
+ | PendingIntent.FLAG_ONE_SHOT, null);
+
+ final int flags = intent.getFlags();
+ Intent newIntent = new Intent(Intent.ACTION_REVIEW_PERMISSIONS);
+ newIntent.setFlags(flags
+ | Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS);
+ newIntent.putExtra(Intent.EXTRA_PACKAGE_NAME, aInfo.packageName);
+ newIntent.putExtra(Intent.EXTRA_INTENT, new IntentSender(target));
+ if (resultRecord != null) {
+ newIntent.putExtra(Intent.EXTRA_RESULT_NEEDED, true);
+ }
+ intent = newIntent;
+
+ resolvedType = null;
+ callingUid = realCallingUid;
+ callingPid = realCallingPid;
+
+ rInfo = mSupervisor.resolveIntent(intent, resolvedType, userId, 0,
+ computeResolveFilterUid(
+ callingUid, realCallingUid, mRequest.filterCallingUid));
+ aInfo = mSupervisor.resolveActivity(intent, rInfo, startFlags,
+ null /*profilerInfo*/);
+
+ if (DEBUG_PERMISSIONS_REVIEW) {
+ final ActivityStack focusedStack = mSupervisor.getTopDisplayFocusedStack();
+ Slog.i(TAG, "START u" + userId + " {" + intent.toShortString(true, true,
+ true, false) + "} from uid " + callingUid + " on display "
+ + (focusedStack == null ? DEFAULT_DISPLAY : focusedStack.mDisplayId));
+ }
+ }
+ }
+
+ // If we have an ephemeral app, abort the process of launching the resolved intent.
+ // Instead, launch the ephemeral installer. Once the installer is finished, it
+ // starts either the intent we resolved here [on install error] or the ephemeral
+ // app [on install success].
+ if (rInfo != null && rInfo.auxiliaryInfo != null) {
+ intent = createLaunchIntent(rInfo.auxiliaryInfo, ephemeralIntent,
+ callingPackage, verificationBundle, resolvedType, userId);
+ resolvedType = null;
+ callingUid = realCallingUid;
+ callingPid = realCallingPid;
+
+ aInfo = mSupervisor.resolveActivity(intent, rInfo, startFlags, null /*profilerInfo*/);
+ }
+
+ ActivityRecord r = new ActivityRecord(mService, callerApp, callingPid, callingUid,
+ callingPackage, intent, resolvedType, aInfo, mService.getGlobalConfiguration(),
+ resultRecord, resultWho, requestCode, componentSpecified, voiceSession != null,
+ mSupervisor, checkedOptions, sourceRecord);
+ if (outActivity != null) {
+ outActivity[0] = r;
+ }
+
+ if (r.appTimeTracker == null && sourceRecord != null) {
+ // If the caller didn't specify an explicit time tracker, we want to continue
+ // tracking under any it has.
+ r.appTimeTracker = sourceRecord.appTimeTracker;
+ }
+
+ final ActivityStack stack = mSupervisor.getTopDisplayFocusedStack();
+
+ // If we are starting an activity that is not from the same uid as the currently resumed
+ // one, check whether app switches are allowed.
+ if (voiceSession == null && (stack.getResumedActivity() == null
+ || stack.getResumedActivity().info.applicationInfo.uid != realCallingUid)) {
+ if (!mService.checkAppSwitchAllowedLocked(callingPid, callingUid,
+ realCallingPid, realCallingUid, "Activity start")) {
+ mController.addPendingActivityLaunch(new PendingActivityLaunch(r,
+ sourceRecord, startFlags, stack, callerApp));
+ ActivityOptions.abort(checkedOptions);
+ return ActivityManager.START_SWITCHES_CANCELED;
+ }
+ }
+
+ mService.onStartActivitySetDidAppSwitch();
+ mController.doPendingActivityLaunches(false);
+
+ maybeLogActivityStart(callingUid, callingPackage, realCallingUid, intent, callerApp, r,
+ originatingPendingIntent);
+
+ return startActivity(r, sourceRecord, voiceSession, voiceInteractor, startFlags,
+ true /* doResume */, checkedOptions, inTask, outActivity);
+ }
+
+ private void maybeLogActivityStart(int callingUid, String callingPackage, int realCallingUid,
+ Intent intent, WindowProcessController callerApp, ActivityRecord r,
+ PendingIntentRecord originatingPendingIntent) {
+ boolean callerAppHasForegroundActivity =
+ callerApp != null && callerApp.hasForegroundActivities();
+ if (!mService.isActivityStartsLoggingEnabled() || callerAppHasForegroundActivity
+ || r == null) {
+ // skip logging in this case
+ return;
+ }
+
+ try {
+ Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "logActivityStart");
+ final int callingUidProcState = mService.getUidStateLocked(callingUid);
+ final boolean callingUidHasAnyVisibleWindow =
+ mService.mWindowManager.isAnyWindowVisibleForUid(callingUid);
+ final int realCallingUidProcState = (callingUid == realCallingUid)
+ ? callingUidProcState
+ : mService.getUidStateLocked(realCallingUid);
+ final boolean realCallingUidHasAnyVisibleWindow = (callingUid == realCallingUid)
+ ? callingUidHasAnyVisibleWindow
+ : mService.mWindowManager.isAnyWindowVisibleForUid(realCallingUid);
+ final String targetPackage = r.packageName;
+ final int targetUid = (r.appInfo != null) ? r.appInfo.uid : -1;
+ final int targetUidProcState = mService.getUidStateLocked(targetUid);
+ final boolean targetUidHasAnyVisibleWindow = (targetUid != -1)
+ ? mService.mWindowManager.isAnyWindowVisibleForUid(targetUid)
+ : false;
+ final String targetWhitelistTag = (targetUid != -1)
+ ? mService.getPendingTempWhitelistTagForUidLocked(targetUid)
+ : null;
+
+ mSupervisor.getActivityMetricsLogger().logActivityStart(intent, callerApp, r,
+ callingUid, callingPackage, callingUidProcState,
+ callingUidHasAnyVisibleWindow,
+ realCallingUid, realCallingUidProcState,
+ realCallingUidHasAnyVisibleWindow,
+ targetUid, targetPackage, targetUidProcState,
+ targetUidHasAnyVisibleWindow, targetWhitelistTag,
+ (originatingPendingIntent != null));
+ } finally {
+ Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
+ }
+ }
+
+ /**
+ * Creates a launch intent for the given auxiliary resolution data.
+ */
+ private @NonNull Intent createLaunchIntent(@Nullable AuxiliaryResolveInfo auxiliaryResponse,
+ Intent originalIntent, String callingPackage, Bundle verificationBundle,
+ String resolvedType, int userId) {
+ if (auxiliaryResponse != null && auxiliaryResponse.needsPhaseTwo) {
+ // request phase two resolution
+ mService.getPackageManagerInternalLocked().requestInstantAppResolutionPhaseTwo(
+ auxiliaryResponse, originalIntent, resolvedType, callingPackage,
+ verificationBundle, userId);
+ }
+ return InstantAppResolver.buildEphemeralInstallerIntent(
+ originalIntent,
+ InstantAppResolver.sanitizeIntent(originalIntent),
+ auxiliaryResponse == null ? null : auxiliaryResponse.failureIntent,
+ callingPackage,
+ verificationBundle,
+ resolvedType,
+ userId,
+ auxiliaryResponse == null ? null : auxiliaryResponse.installFailureActivity,
+ auxiliaryResponse == null ? null : auxiliaryResponse.token,
+ auxiliaryResponse != null && auxiliaryResponse.needsPhaseTwo,
+ auxiliaryResponse == null ? null : auxiliaryResponse.filters);
+ }
+
+ void postStartActivityProcessing(ActivityRecord r, int result,
+ ActivityStack startedActivityStack) {
+ if (ActivityManager.isStartResultFatalError(result)) {
+ return;
+ }
+
+ // We're waiting for an activity launch to finish, but that activity simply
+ // brought another activity to front. We must also handle the case where the task is already
+ // in the front as a result of the trampoline activity being in the same task (it will be
+ // considered focused as the trampoline will be finished). Let startActivityMayWait() know
+ // about this, so it waits for the new activity to become visible instead.
+ mSupervisor.reportWaitingActivityLaunchedIfNeeded(r, result);
+
+ if (startedActivityStack == null) {
+ return;
+ }
+
+ final int clearTaskFlags = FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_CLEAR_TASK;
+ boolean clearedTask = (mLaunchFlags & clearTaskFlags) == clearTaskFlags
+ && mReuseTask != null;
+ if (result == START_TASK_TO_FRONT || result == START_DELIVERED_TO_TOP || clearedTask) {
+ // The activity was already running so it wasn't started, but either brought to the
+ // front or the new intent was delivered to it since it was already in front. Notify
+ // anyone interested in this piece of information.
+ switch (startedActivityStack.getWindowingMode()) {
+ case WINDOWING_MODE_PINNED:
+ mService.getTaskChangeNotificationController().notifyPinnedActivityRestartAttempt(
+ clearedTask);
+ break;
+ case WINDOWING_MODE_SPLIT_SCREEN_PRIMARY:
+ final ActivityStack homeStack =
+ startedActivityStack.getDisplay().getHomeStack();
+ if (homeStack != null && homeStack.shouldBeVisible(null /* starting */)) {
+ mService.mWindowManager.showRecentApps();
+ }
+ break;
+ }
+ }
+ }
+
+ private int startActivityMayWait(IApplicationThread caller, int callingUid,
+ String callingPackage, Intent intent, String resolvedType,
+ IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
+ IBinder resultTo, String resultWho, int requestCode, int startFlags,
+ ProfilerInfo profilerInfo, WaitResult outResult,
+ Configuration globalConfig, SafeActivityOptions options, boolean ignoreTargetSecurity,
+ int userId, TaskRecord inTask, String reason,
+ boolean allowPendingRemoteAnimationRegistryLookup,
+ PendingIntentRecord originatingPendingIntent) {
+ // Refuse possible leaked file descriptors
+ if (intent != null && intent.hasFileDescriptors()) {
+ throw new IllegalArgumentException("File descriptors passed in Intent");
+ }
+ mSupervisor.getActivityMetricsLogger().notifyActivityLaunching();
+ boolean componentSpecified = intent.getComponent() != null;
+
+ final int realCallingPid = Binder.getCallingPid();
+ final int realCallingUid = Binder.getCallingUid();
+
+ int callingPid;
+ if (callingUid >= 0) {
+ callingPid = -1;
+ } else if (caller == null) {
+ callingPid = realCallingPid;
+ callingUid = realCallingUid;
+ } else {
+ callingPid = callingUid = -1;
+ }
+
+ // Save a copy in case ephemeral needs it
+ final Intent ephemeralIntent = new Intent(intent);
+ // Don't modify the client's object!
+ intent = new Intent(intent);
+ if (componentSpecified
+ && !(Intent.ACTION_VIEW.equals(intent.getAction()) && intent.getData() == null)
+ && !Intent.ACTION_INSTALL_INSTANT_APP_PACKAGE.equals(intent.getAction())
+ && !Intent.ACTION_RESOLVE_INSTANT_APP_PACKAGE.equals(intent.getAction())
+ && mService.getPackageManagerInternalLocked()
+ .isInstantAppInstallerComponent(intent.getComponent())) {
+ // intercept intents targeted directly to the ephemeral installer the
+ // ephemeral installer should never be started with a raw Intent; instead
+ // adjust the intent so it looks like a "normal" instant app launch
+ intent.setComponent(null /*component*/);
+ componentSpecified = false;
+ }
+
+ ResolveInfo rInfo = mSupervisor.resolveIntent(intent, resolvedType, userId,
+ 0 /* matchFlags */,
+ computeResolveFilterUid(
+ callingUid, realCallingUid, mRequest.filterCallingUid));
+ if (rInfo == null) {
+ UserInfo userInfo = mSupervisor.getUserInfo(userId);
+ if (userInfo != null && userInfo.isManagedProfile()) {
+ // Special case for managed profiles, if attempting to launch non-cryto aware
+ // app in a locked managed profile from an unlocked parent allow it to resolve
+ // as user will be sent via confirm credentials to unlock the profile.
+ UserManager userManager = UserManager.get(mService.mContext);
+ boolean profileLockedAndParentUnlockingOrUnlocked = false;
+ long token = Binder.clearCallingIdentity();
+ try {
+ UserInfo parent = userManager.getProfileParent(userId);
+ profileLockedAndParentUnlockingOrUnlocked = (parent != null)
+ && userManager.isUserUnlockingOrUnlocked(parent.id)
+ && !userManager.isUserUnlockingOrUnlocked(userId);
+ } finally {
+ Binder.restoreCallingIdentity(token);
+ }
+ if (profileLockedAndParentUnlockingOrUnlocked) {
+ rInfo = mSupervisor.resolveIntent(intent, resolvedType, userId,
+ PackageManager.MATCH_DIRECT_BOOT_AWARE
+ | PackageManager.MATCH_DIRECT_BOOT_UNAWARE,
+ computeResolveFilterUid(
+ callingUid, realCallingUid, mRequest.filterCallingUid));
+ }
+ }
+ }
+ // Collect information about the target of the Intent.
+ ActivityInfo aInfo = mSupervisor.resolveActivity(intent, rInfo, startFlags, profilerInfo);
+
+ synchronized (mService.mGlobalLock) {
+ final ActivityStack stack = mSupervisor.getTopDisplayFocusedStack();
+ stack.mConfigWillChange = globalConfig != null
+ && mService.getGlobalConfiguration().diff(globalConfig) != 0;
+ if (DEBUG_CONFIGURATION) Slog.v(TAG_CONFIGURATION,
+ "Starting activity when config will change = " + stack.mConfigWillChange);
+
+ final long origId = Binder.clearCallingIdentity();
+
+ if (aInfo != null &&
+ (aInfo.applicationInfo.privateFlags
+ & ApplicationInfo.PRIVATE_FLAG_CANT_SAVE_STATE) != 0 &&
+ mService.mHasHeavyWeightFeature) {
+ // This may be a heavy-weight process! Check to see if we already
+ // have another, different heavy-weight process running.
+ if (aInfo.processName.equals(aInfo.applicationInfo.packageName)) {
+ final WindowProcessController heavy = mService.mHeavyWeightProcess;
+ if (heavy != null && (heavy.mInfo.uid != aInfo.applicationInfo.uid
+ || !heavy.mName.equals(aInfo.processName))) {
+ int appCallingUid = callingUid;
+ if (caller != null) {
+ WindowProcessController callerApp =
+ mService.getProcessController(caller);
+ if (callerApp != null) {
+ appCallingUid = callerApp.mInfo.uid;
+ } else {
+ Slog.w(TAG, "Unable to find app for caller " + caller
+ + " (pid=" + callingPid + ") when starting: "
+ + intent.toString());
+ SafeActivityOptions.abort(options);
+ return ActivityManager.START_PERMISSION_DENIED;
+ }
+ }
+
+ IIntentSender target = mService.getIntentSenderLocked(
+ ActivityManager.INTENT_SENDER_ACTIVITY, "android",
+ appCallingUid, userId, null, null, 0, new Intent[] { intent },
+ new String[] { resolvedType }, PendingIntent.FLAG_CANCEL_CURRENT
+ | PendingIntent.FLAG_ONE_SHOT, null);
+
+ Intent newIntent = new Intent();
+ if (requestCode >= 0) {
+ // Caller is requesting a result.
+ newIntent.putExtra(HeavyWeightSwitcherActivity.KEY_HAS_RESULT, true);
+ }
+ newIntent.putExtra(HeavyWeightSwitcherActivity.KEY_INTENT,
+ new IntentSender(target));
+ heavy.updateIntentForHeavyWeightActivity(newIntent);
+ newIntent.putExtra(HeavyWeightSwitcherActivity.KEY_NEW_APP,
+ aInfo.packageName);
+ newIntent.setFlags(intent.getFlags());
+ newIntent.setClassName("android",
+ HeavyWeightSwitcherActivity.class.getName());
+ intent = newIntent;
+ resolvedType = null;
+ caller = null;
+ callingUid = Binder.getCallingUid();
+ callingPid = Binder.getCallingPid();
+ componentSpecified = true;
+ rInfo = mSupervisor.resolveIntent(intent, null /*resolvedType*/, userId,
+ 0 /* matchFlags */, computeResolveFilterUid(
+ callingUid, realCallingUid, mRequest.filterCallingUid));
+ aInfo = rInfo != null ? rInfo.activityInfo : null;
+ if (aInfo != null) {
+ aInfo = mService.mAmInternal.getActivityInfoForUser(aInfo, userId);
+ }
+ }
+ }
+ }
+
+ final ActivityRecord[] outRecord = new ActivityRecord[1];
+ int res = startActivity(caller, intent, ephemeralIntent, resolvedType, aInfo, rInfo,
+ voiceSession, voiceInteractor, resultTo, resultWho, requestCode, callingPid,
+ callingUid, callingPackage, realCallingPid, realCallingUid, startFlags, options,
+ ignoreTargetSecurity, componentSpecified, outRecord, inTask, reason,
+ allowPendingRemoteAnimationRegistryLookup, originatingPendingIntent);
+
+ Binder.restoreCallingIdentity(origId);
+
+ if (stack.mConfigWillChange) {
+ // If the caller also wants to switch to a new configuration,
+ // do so now. This allows a clean switch, as we are waiting
+ // for the current activity to pause (so we will not destroy
+ // it), and have not yet started the next activity.
+ mService.mAmInternal.enforceCallingPermission(android.Manifest.permission.CHANGE_CONFIGURATION,
+ "updateConfiguration()");
+ stack.mConfigWillChange = false;
+ if (DEBUG_CONFIGURATION) Slog.v(TAG_CONFIGURATION,
+ "Updating to new configuration after starting activity.");
+ mService.updateConfigurationLocked(globalConfig, null, false);
+ }
+
+ // Notify ActivityMetricsLogger that the activity has launched. ActivityMetricsLogger
+ // will then wait for the windows to be drawn and populate WaitResult.
+ mSupervisor.getActivityMetricsLogger().notifyActivityLaunched(res, outRecord[0]);
+ if (outResult != null) {
+ outResult.result = res;
+
+ final ActivityRecord r = outRecord[0];
+
+ switch(res) {
+ case START_SUCCESS: {
+ mSupervisor.mWaitingActivityLaunched.add(outResult);
+ do {
+ try {
+ mService.mGlobalLock.wait();
+ } catch (InterruptedException e) {
+ }
+ } while (outResult.result != START_TASK_TO_FRONT
+ && !outResult.timeout && outResult.who == null);
+ if (outResult.result == START_TASK_TO_FRONT) {
+ res = START_TASK_TO_FRONT;
+ }
+ break;
+ }
+ case START_DELIVERED_TO_TOP: {
+ outResult.timeout = false;
+ outResult.who = r.realActivity;
+ outResult.totalTime = 0;
+ break;
+ }
+ case START_TASK_TO_FRONT: {
+ // ActivityRecord may represent a different activity, but it should not be
+ // in the resumed state.
+ if (r.nowVisible && r.isState(RESUMED)) {
+ outResult.timeout = false;
+ outResult.who = r.realActivity;
+ outResult.totalTime = 0;
+ } else {
+ final long startTimeMs = SystemClock.uptimeMillis();
+ mSupervisor.waitActivityVisible(r.realActivity, outResult, startTimeMs);
+ // Note: the timeout variable is not currently not ever set.
+ do {
+ try {
+ mService.mGlobalLock.wait();
+ } catch (InterruptedException e) {
+ }
+ } while (!outResult.timeout && outResult.who == null);
+ }
+ break;
+ }
+ }
+ }
+
+ return res;
+ }
+ }
+
+ /**
+ * Compute the logical UID based on which the package manager would filter
+ * app components i.e. based on which the instant app policy would be applied
+ * because it is the logical calling UID.
+ *
+ * @param customCallingUid The UID on whose behalf to make the call.
+ * @param actualCallingUid The UID actually making the call.
+ * @param filterCallingUid The UID to be used to filter for instant apps.
+ * @return The logical UID making the call.
+ */
+ static int computeResolveFilterUid(int customCallingUid, int actualCallingUid,
+ int filterCallingUid) {
+ return filterCallingUid != UserHandle.USER_NULL
+ ? filterCallingUid
+ : (customCallingUid >= 0 ? customCallingUid : actualCallingUid);
+ }
+
+ private int startActivity(final ActivityRecord r, ActivityRecord sourceRecord,
+ IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
+ int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
+ ActivityRecord[] outActivity) {
+ int result = START_CANCELED;
+ final ActivityStack startedActivityStack;
+ try {
+ mService.mWindowManager.deferSurfaceLayout();
+ result = startActivityUnchecked(r, sourceRecord, voiceSession, voiceInteractor,
+ startFlags, doResume, options, inTask, outActivity);
+ } finally {
+ final ActivityStack currentStack = r.getStack();
+ startedActivityStack = currentStack != null ? currentStack : mTargetStack;
+
+ if (ActivityManager.isStartResultSuccessful(result)) {
+ if (startedActivityStack != null) {
+ // If there is no state change (e.g. a resumed activity is reparented to
+ // top of another display) to trigger a visibility/configuration checking,
+ // we have to update the configuration for changing to different display.
+ final ActivityRecord currentTop =
+ startedActivityStack.topRunningActivityLocked();
+ if (currentTop != null && currentTop.shouldUpdateConfigForDisplayChanged()) {
+ mSupervisor.ensureVisibilityAndConfig(currentTop, currentTop.getDisplayId(),
+ true /* markFrozenIfConfigChanged */, false /* deferResume */);
+ }
+ }
+ } else {
+ // If we are not able to proceed, disassociate the activity from the task.
+ // Leaving an activity in an incomplete state can lead to issues, such as
+ // performing operations without a window container.
+ final ActivityStack stack = mStartActivity.getStack();
+ if (stack != null) {
+ stack.finishActivityLocked(mStartActivity, RESULT_CANCELED,
+ null /* intentResultData */, "startActivity", true /* oomAdj */);
+ }
+ }
+ mService.mWindowManager.continueSurfaceLayout();
+ }
+
+ postStartActivityProcessing(r, result, startedActivityStack);
+
+ return result;
+ }
+
+ // Note: This method should only be called from {@link startActivity}.
+ private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
+ IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
+ int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
+ ActivityRecord[] outActivity) {
+
+ setInitialState(r, options, inTask, doResume, startFlags, sourceRecord, voiceSession,
+ voiceInteractor);
+ final int preferredWindowingMode = mLaunchParams.mWindowingMode;
+
+ // Do not start home activity if it cannot be launched on preferred display. We are not
+ // doing this in ActivityStackSupervisor#canPlaceEntityOnDisplay because it might
+ // fallback to launch on other displays.
+ if (r.isActivityTypeHome()
+ && !mSupervisor.canStartHomeOnDisplay(r.info, mPreferredDisplayId)) {
+ Slog.w(TAG, "Cannot launch home on display " + mPreferredDisplayId);
+ return START_CANCELED;
+ }
+
+ computeLaunchingTaskFlags();
+
+ computeSourceStack();
+
+ mIntent.setFlags(mLaunchFlags);
+
+ ActivityRecord reusedActivity = getReusableIntentActivity();
+
+ if (reusedActivity != null) {
+ // When the flags NEW_TASK and CLEAR_TASK are set, then the task gets reused but
+ // still needs to be a lock task mode violation since the task gets cleared out and
+ // the device would otherwise leave the locked task.
+ if (mService.getLockTaskController().isLockTaskModeViolation(reusedActivity.getTask(),
+ (mLaunchFlags & (FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_CLEAR_TASK))
+ == (FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_CLEAR_TASK))) {
+ Slog.e(TAG, "startActivityUnchecked: Attempt to violate Lock Task Mode");
+ return START_RETURN_LOCK_TASK_MODE_VIOLATION;
+ }
+
+ // True if we are clearing top and resetting of a standard (default) launch mode
+ // ({@code LAUNCH_MULTIPLE}) activity. The existing activity will be finished.
+ final boolean clearTopAndResetStandardLaunchMode =
+ (mLaunchFlags & (FLAG_ACTIVITY_CLEAR_TOP | FLAG_ACTIVITY_RESET_TASK_IF_NEEDED))
+ == (FLAG_ACTIVITY_CLEAR_TOP | FLAG_ACTIVITY_RESET_TASK_IF_NEEDED)
+ && mLaunchMode == LAUNCH_MULTIPLE;
+
+ // If mStartActivity does not have a task associated with it, associate it with the
+ // reused activity's task. Do not do so if we're clearing top and resetting for a
+ // standard launchMode activity.
+ if (mStartActivity.getTask() == null && !clearTopAndResetStandardLaunchMode) {
+ mStartActivity.setTask(reusedActivity.getTask());
+ }
+
+ if (reusedActivity.getTask().intent == null) {
+ // This task was started because of movement of the activity based on affinity...
+ // Now that we are actually launching it, we can assign the base intent.
+ reusedActivity.getTask().setIntent(mStartActivity);
+ }
+
+ // This code path leads to delivering a new intent, we want to make sure we schedule it
+ // as the first operation, in case the activity will be resumed as a result of later
+ // operations.
+ if ((mLaunchFlags & FLAG_ACTIVITY_CLEAR_TOP) != 0
+ || isDocumentLaunchesIntoExisting(mLaunchFlags)
+ || isLaunchModeOneOf(LAUNCH_SINGLE_INSTANCE, LAUNCH_SINGLE_TASK)) {
+ final TaskRecord task = reusedActivity.getTask();
+
+ // In this situation we want to remove all activities from the task up to the one
+ // being started. In most cases this means we are resetting the task to its initial
+ // state.
+ final ActivityRecord top = task.performClearTaskForReuseLocked(mStartActivity,
+ mLaunchFlags);
+
+ // The above code can remove {@code reusedActivity} from the task, leading to the
+ // the {@code ActivityRecord} removing its reference to the {@code TaskRecord}. The
+ // task reference is needed in the call below to
+ // {@link setTargetStackAndMoveToFrontIfNeeded}.
+ if (reusedActivity.getTask() == null) {
+ reusedActivity.setTask(task);
+ }
+
+ if (top != null) {
+ if (top.frontOfTask) {
+ // Activity aliases may mean we use different intents for the top activity,
+ // so make sure the task now has the identity of the new intent.
+ top.getTask().setIntent(mStartActivity);
+ }
+ deliverNewIntent(top);
+ }
+ }
+
+ mSupervisor.sendPowerHintForLaunchStartIfNeeded(false /* forceSend */, reusedActivity);
+
+ reusedActivity = setTargetStackAndMoveToFrontIfNeeded(reusedActivity);
+
+ final ActivityRecord outResult =
+ outActivity != null && outActivity.length > 0 ? outActivity[0] : null;
+
+ // When there is a reused activity and the current result is a trampoline activity,
+ // set the reused activity as the result.
+ if (outResult != null && (outResult.finishing || outResult.noDisplay)) {
+ outActivity[0] = reusedActivity;
+ }
+
+ if ((mStartFlags & START_FLAG_ONLY_IF_NEEDED) != 0) {
+ // We don't need to start a new activity, and the client said not to do anything
+ // if that is the case, so this is it! And for paranoia, make sure we have
+ // correctly resumed the top activity.
+ resumeTargetStackIfNeeded();
+ return START_RETURN_INTENT_TO_CALLER;
+ }
+
+ if (reusedActivity != null) {
+ setTaskFromIntentActivity(reusedActivity);
+
+ if (!mAddingToTask && mReuseTask == null) {
+ // We didn't do anything... but it was needed (a.k.a., client don't use that
+ // intent!) And for paranoia, make sure we have correctly resumed the top activity.
+
+ resumeTargetStackIfNeeded();
+ if (outActivity != null && outActivity.length > 0) {
+ outActivity[0] = reusedActivity;
+ }
+
+ return mMovedToFront ? START_TASK_TO_FRONT : START_DELIVERED_TO_TOP;
+ }
+ }
+ }
+
+ if (mStartActivity.packageName == null) {
+ final ActivityStack sourceStack = mStartActivity.resultTo != null
+ ? mStartActivity.resultTo.getStack() : null;
+ if (sourceStack != null) {
+ sourceStack.sendActivityResultLocked(-1 /* callingUid */, mStartActivity.resultTo,
+ mStartActivity.resultWho, mStartActivity.requestCode, RESULT_CANCELED,
+ null /* data */);
+ }
+ ActivityOptions.abort(mOptions);
+ return START_CLASS_NOT_FOUND;
+ }
+
+ // If the activity being launched is the same as the one currently at the top, then
+ // we need to check if it should only be launched once.
+ final ActivityStack topStack = mSupervisor.getTopDisplayFocusedStack();
+ final ActivityRecord topFocused = topStack.getTopActivity();
+ final ActivityRecord top = topStack.topRunningNonDelayedActivityLocked(mNotTop);
+ final boolean dontStart = top != null && mStartActivity.resultTo == null
+ && top.realActivity.equals(mStartActivity.realActivity)
+ && top.userId == mStartActivity.userId
+ && top.attachedToProcess()
+ && ((mLaunchFlags & FLAG_ACTIVITY_SINGLE_TOP) != 0
+ || isLaunchModeOneOf(LAUNCH_SINGLE_TOP, LAUNCH_SINGLE_TASK))
+ // This allows home activity to automatically launch on secondary display when
+ // display added, if home was the top activity on default display, instead of
+ // sending new intent to the home activity on default display.
+ && (!top.isActivityTypeHome() || top.getDisplayId() == mPreferredDisplayId);
+ if (dontStart) {
+ // For paranoia, make sure we have correctly resumed the top activity.
+ topStack.mLastPausedActivity = null;
+ if (mDoResume) {
+ mSupervisor.resumeFocusedStacksTopActivitiesLocked();
+ }
+ ActivityOptions.abort(mOptions);
+ if ((mStartFlags & START_FLAG_ONLY_IF_NEEDED) != 0) {
+ // We don't need to start a new activity, and the client said not to do
+ // anything if that is the case, so this is it!
+ return START_RETURN_INTENT_TO_CALLER;
+ }
+
+ deliverNewIntent(top);
+
+ // Don't use mStartActivity.task to show the toast. We're not starting a new activity
+ // but reusing 'top'. Fields in mStartActivity may not be fully initialized.
+ mSupervisor.handleNonResizableTaskIfNeeded(top.getTask(), preferredWindowingMode,
+ mPreferredDisplayId, topStack);
+
+ return START_DELIVERED_TO_TOP;
+ }
+
+ boolean newTask = false;
+ final TaskRecord taskToAffiliate = (mLaunchTaskBehind && mSourceRecord != null)
+ ? mSourceRecord.getTask() : null;
+
+ // Should this be considered a new task?
+ int result = START_SUCCESS;
+ if (mStartActivity.resultTo == null && mInTask == null && !mAddingToTask
+ && (mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) != 0) {
+ newTask = true;
+ result = setTaskFromReuseOrCreateNewTask(taskToAffiliate);
+ } else if (mSourceRecord != null) {
+ result = setTaskFromSourceRecord();
+ } else if (mInTask != null) {
+ result = setTaskFromInTask();
+ } else {
+ // This not being started from an existing activity, and not part of a new task...
+ // just put it in the top task, though these days this case should never happen.
+ setTaskToCurrentTopOrCreateNewTask();
+ }
+ if (result != START_SUCCESS) {
+ return result;
+ }
+
+ mService.mUgmInternal.grantUriPermissionFromIntent(mCallingUid, mStartActivity.packageName,
+ mIntent, mStartActivity.getUriPermissionsLocked(), mStartActivity.userId);
+ mService.getPackageManagerInternalLocked().grantEphemeralAccess(
+ mStartActivity.userId, mIntent, UserHandle.getAppId(mStartActivity.appInfo.uid),
+ UserHandle.getAppId(mCallingUid));
+ if (newTask) {
+ EventLog.writeEvent(EventLogTags.AM_CREATE_TASK, mStartActivity.userId,
+ mStartActivity.getTask().taskId);
+ }
+ ActivityStack.logStartActivity(
+ EventLogTags.AM_CREATE_ACTIVITY, mStartActivity, mStartActivity.getTask());
+ mTargetStack.mLastPausedActivity = null;
+
+ mSupervisor.sendPowerHintForLaunchStartIfNeeded(false /* forceSend */, mStartActivity);
+
+ mTargetStack.startActivityLocked(mStartActivity, topFocused, newTask, mKeepCurTransition,
+ mOptions);
+ if (mDoResume) {
+ final ActivityRecord topTaskActivity =
+ mStartActivity.getTask().topRunningActivityLocked();
+ if (!mTargetStack.isFocusable()
+ || (topTaskActivity != null && topTaskActivity.mTaskOverlay
+ && mStartActivity != topTaskActivity)) {
+ // If the activity is not focusable, we can't resume it, but still would like to
+ // make sure it becomes visible as it starts (this will also trigger entry
+ // animation). An example of this are PIP activities.
+ // Also, we don't want to resume activities in a task that currently has an overlay
+ // as the starting activity just needs to be in the visible paused state until the
+ // over is removed.
+ mTargetStack.ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
+ // Go ahead and tell window manager to execute app transition for this activity
+ // since the app transition will not be triggered through the resume channel.
+ mTargetStack.getDisplay().getWindowContainerController().executeAppTransition();
+ } else {
+ // If the target stack was not previously focusable (previous top running activity
+ // on that stack was not visible) then any prior calls to move the stack to the
+ // will not update the focused stack. If starting the new activity now allows the
+ // task stack to be focusable, then ensure that we now update the focused stack
+ // accordingly.
+ if (mTargetStack.isFocusable()
+ && !mSupervisor.isTopDisplayFocusedStack(mTargetStack)) {
+ mTargetStack.moveToFront("startActivityUnchecked");
+ }
+ mSupervisor.resumeFocusedStacksTopActivitiesLocked(mTargetStack, mStartActivity,
+ mOptions);
+ }
+ } else if (mStartActivity != null) {
+ mSupervisor.mRecentTasks.add(mStartActivity.getTask());
+ }
+ mSupervisor.updateUserStackLocked(mStartActivity.userId, mTargetStack);
+
+ mSupervisor.handleNonResizableTaskIfNeeded(mStartActivity.getTask(), preferredWindowingMode,
+ mPreferredDisplayId, mTargetStack);
+
+ return START_SUCCESS;
+ }
+
+ /**
+ * Resets the {@link ActivityStarter} state.
+ * @param clearRequest whether the request should be reset to default values.
+ */
+ void reset(boolean clearRequest) {
+ mStartActivity = null;
+ mIntent = null;
+ mCallingUid = -1;
+ mOptions = null;
+
+ mLaunchTaskBehind = false;
+ mLaunchFlags = 0;
+ mLaunchMode = INVALID_LAUNCH_MODE;
+
+ mLaunchParams.reset();
+
+ mNotTop = null;
+ mDoResume = false;
+ mStartFlags = 0;
+ mSourceRecord = null;
+ mPreferredDisplayId = INVALID_DISPLAY;
+
+ mInTask = null;
+ mAddingToTask = false;
+ mReuseTask = null;
+
+ mNewTaskInfo = null;
+ mNewTaskIntent = null;
+ mSourceStack = null;
+
+ mTargetStack = null;
+ mMovedToFront = false;
+ mNoAnimation = false;
+ mKeepCurTransition = false;
+ mAvoidMoveToFront = false;
+
+ mVoiceSession = null;
+ mVoiceInteractor = null;
+
+ mIntentDelivered = false;
+
+ if (clearRequest) {
+ mRequest.reset();
+ }
+ }
+
+ private void setInitialState(ActivityRecord r, ActivityOptions options, TaskRecord inTask,
+ boolean doResume, int startFlags, ActivityRecord sourceRecord,
+ IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor) {
+ reset(false /* clearRequest */);
+
+ mStartActivity = r;
+ mIntent = r.intent;
+ mOptions = options;
+ mCallingUid = r.launchedFromUid;
+ mSourceRecord = sourceRecord;
+ mVoiceSession = voiceSession;
+ mVoiceInteractor = voiceInteractor;
+
+ mLaunchParams.reset();
+
+ mSupervisor.getLaunchParamsController().calculate(inTask, r.info.windowLayout, r,
+ sourceRecord, options, mLaunchParams);
+
+ if (mLaunchParams.hasPreferredDisplay()) {
+ mPreferredDisplayId = mLaunchParams.mPreferredDisplayId;
+ } else {
+ mPreferredDisplayId = DEFAULT_DISPLAY;
+ }
+
+ mLaunchMode = r.launchMode;
+
+ mLaunchFlags = adjustLaunchFlagsToDocumentMode(
+ r, LAUNCH_SINGLE_INSTANCE == mLaunchMode,
+ LAUNCH_SINGLE_TASK == mLaunchMode, mIntent.getFlags());
+ mLaunchTaskBehind = r.mLaunchTaskBehind
+ && !isLaunchModeOneOf(LAUNCH_SINGLE_TASK, LAUNCH_SINGLE_INSTANCE)
+ && (mLaunchFlags & FLAG_ACTIVITY_NEW_DOCUMENT) != 0;
+
+ sendNewTaskResultRequestIfNeeded();
+
+ if ((mLaunchFlags & FLAG_ACTIVITY_NEW_DOCUMENT) != 0 && r.resultTo == null) {
+ mLaunchFlags |= FLAG_ACTIVITY_NEW_TASK;
+ }
+
+ // If we are actually going to launch in to a new task, there are some cases where
+ // we further want to do multiple task.
+ if ((mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) != 0) {
+ if (mLaunchTaskBehind
+ || r.info.documentLaunchMode == DOCUMENT_LAUNCH_ALWAYS) {
+ mLaunchFlags |= FLAG_ACTIVITY_MULTIPLE_TASK;
+ }
+ }
+
+ // We'll invoke onUserLeaving before onPause only if the launching
+ // activity did not explicitly state that this is an automated launch.
+ mSupervisor.mUserLeaving = (mLaunchFlags & FLAG_ACTIVITY_NO_USER_ACTION) == 0;
+ if (DEBUG_USER_LEAVING) Slog.v(TAG_USER_LEAVING,
+ "startActivity() => mUserLeaving=" + mSupervisor.mUserLeaving);
+
+ // If the caller has asked not to resume at this point, we make note
+ // of this in the record so that we can skip it when trying to find
+ // the top running activity.
+ mDoResume = doResume;
+ if (!doResume || !r.okToShowLocked()) {
+ r.delayedResume = true;
+ mDoResume = false;
+ }
+
+ if (mOptions != null) {
+ if (mOptions.getLaunchTaskId() != -1 && mOptions.getTaskOverlay()) {
+ r.mTaskOverlay = true;
+ if (!mOptions.canTaskOverlayResume()) {
+ final TaskRecord task = mSupervisor.anyTaskForIdLocked(
+ mOptions.getLaunchTaskId());
+ final ActivityRecord top = task != null ? task.getTopActivity() : null;
+ if (top != null && !top.isState(RESUMED)) {
+
+ // The caller specifies that we'd like to be avoided to be moved to the
+ // front, so be it!
+ mDoResume = false;
+ mAvoidMoveToFront = true;
+ }
+ }
+ } else if (mOptions.getAvoidMoveToFront()) {
+ mDoResume = false;
+ mAvoidMoveToFront = true;
+ }
+ }
+
+ mNotTop = (mLaunchFlags & FLAG_ACTIVITY_PREVIOUS_IS_TOP) != 0 ? r : null;
+
+ mInTask = inTask;
+ // In some flows in to this function, we retrieve the task record and hold on to it
+ // without a lock before calling back in to here... so the task at this point may
+ // not actually be in recents. Check for that, and if it isn't in recents just
+ // consider it invalid.
+ if (inTask != null && !inTask.inRecents) {
+ Slog.w(TAG, "Starting activity in task not in recents: " + inTask);
+ mInTask = null;
+ }
+
+ mStartFlags = startFlags;
+ // If the onlyIfNeeded flag is set, then we can do this if the activity being launched
+ // is the same as the one making the call... or, as a special case, if we do not know
+ // the caller then we count the current top activity as the caller.
+ if ((startFlags & START_FLAG_ONLY_IF_NEEDED) != 0) {
+ ActivityRecord checkedCaller = sourceRecord;
+ if (checkedCaller == null) {
+ checkedCaller = mSupervisor.getTopDisplayFocusedStack()
+ .topRunningNonDelayedActivityLocked(mNotTop);
+ }
+ if (!checkedCaller.realActivity.equals(r.realActivity)) {
+ // Caller is not the same as launcher, so always needed.
+ mStartFlags &= ~START_FLAG_ONLY_IF_NEEDED;
+ }
+ }
+
+ mNoAnimation = (mLaunchFlags & FLAG_ACTIVITY_NO_ANIMATION) != 0;
+ }
+
+ private void sendNewTaskResultRequestIfNeeded() {
+ final ActivityStack sourceStack = mStartActivity.resultTo != null
+ ? mStartActivity.resultTo.getStack() : null;
+ if (sourceStack != null && (mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) != 0) {
+ // For whatever reason this activity is being launched into a new task...
+ // yet the caller has requested a result back. Well, that is pretty messed up,
+ // so instead immediately send back a cancel and let the new task continue launched
+ // as normal without a dependency on its originator.
+ Slog.w(TAG, "Activity is launching as a new task, so cancelling activity result.");
+ sourceStack.sendActivityResultLocked(-1 /* callingUid */, mStartActivity.resultTo,
+ mStartActivity.resultWho, mStartActivity.requestCode, RESULT_CANCELED,
+ null /* data */);
+ mStartActivity.resultTo = null;
+ }
+ }
+
+ private void computeLaunchingTaskFlags() {
+ // If the caller is not coming from another activity, but has given us an explicit task into
+ // which they would like us to launch the new activity, then let's see about doing that.
+ if (mSourceRecord == null && mInTask != null && mInTask.getStack() != null) {
+ final Intent baseIntent = mInTask.getBaseIntent();
+ final ActivityRecord root = mInTask.getRootActivity();
+ if (baseIntent == null) {
+ ActivityOptions.abort(mOptions);
+ throw new IllegalArgumentException("Launching into task without base intent: "
+ + mInTask);
+ }
+
+ // If this task is empty, then we are adding the first activity -- it
+ // determines the root, and must be launching as a NEW_TASK.
+ if (isLaunchModeOneOf(LAUNCH_SINGLE_INSTANCE, LAUNCH_SINGLE_TASK)) {
+ if (!baseIntent.getComponent().equals(mStartActivity.intent.getComponent())) {
+ ActivityOptions.abort(mOptions);
+ throw new IllegalArgumentException("Trying to launch singleInstance/Task "
+ + mStartActivity + " into different task " + mInTask);
+ }
+ if (root != null) {
+ ActivityOptions.abort(mOptions);
+ throw new IllegalArgumentException("Caller with mInTask " + mInTask
+ + " has root " + root + " but target is singleInstance/Task");
+ }
+ }
+
+ // If task is empty, then adopt the interesting intent launch flags in to the
+ // activity being started.
+ if (root == null) {
+ final int flagsOfInterest = FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_MULTIPLE_TASK
+ | FLAG_ACTIVITY_NEW_DOCUMENT | FLAG_ACTIVITY_RETAIN_IN_RECENTS;
+ mLaunchFlags = (mLaunchFlags & ~flagsOfInterest)
+ | (baseIntent.getFlags() & flagsOfInterest);
+ mIntent.setFlags(mLaunchFlags);
+ mInTask.setIntent(mStartActivity);
+ mAddingToTask = true;
+
+ // If the task is not empty and the caller is asking to start it as the root of
+ // a new task, then we don't actually want to start this on the task. We will
+ // bring the task to the front, and possibly give it a new intent.
+ } else if ((mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) != 0) {
+ mAddingToTask = false;
+
+ } else {
+ mAddingToTask = true;
+ }
+
+ mReuseTask = mInTask;
+ } else {
+ mInTask = null;
+ // Launch ResolverActivity in the source task, so that it stays in the task bounds
+ // when in freeform workspace.
+ // Also put noDisplay activities in the source task. These by itself can be placed
+ // in any task/stack, however it could launch other activities like ResolverActivity,
+ // and we want those to stay in the original task.
+ if ((mStartActivity.isResolverActivity() || mStartActivity.noDisplay) && mSourceRecord != null
+ && mSourceRecord.inFreeformWindowingMode()) {
+ mAddingToTask = true;
+ }
+ }
+
+ if (mInTask == null) {
+ if (mSourceRecord == null) {
+ // This activity is not being started from another... in this
+ // case we -always- start a new task.
+ if ((mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) == 0 && mInTask == null) {
+ Slog.w(TAG, "startActivity called from non-Activity context; forcing " +
+ "Intent.FLAG_ACTIVITY_NEW_TASK for: " + mIntent);
+ mLaunchFlags |= FLAG_ACTIVITY_NEW_TASK;
+ }
+ } else if (mSourceRecord.launchMode == LAUNCH_SINGLE_INSTANCE) {
+ // The original activity who is starting us is running as a single
+ // instance... this new activity it is starting must go on its
+ // own task.
+ mLaunchFlags |= FLAG_ACTIVITY_NEW_TASK;
+ } else if (isLaunchModeOneOf(LAUNCH_SINGLE_INSTANCE, LAUNCH_SINGLE_TASK)) {
+ // The activity being started is a single instance... it always
+ // gets launched into its own task.
+ mLaunchFlags |= FLAG_ACTIVITY_NEW_TASK;
+ }
+ }
+ }
+
+ private void computeSourceStack() {
+ if (mSourceRecord == null) {
+ mSourceStack = null;
+ return;
+ }
+ if (!mSourceRecord.finishing) {
+ mSourceStack = mSourceRecord.getStack();
+ return;
+ }
+
+ // If the source is finishing, we can't further count it as our source. This is because the
+ // task it is associated with may now be empty and on its way out, so we don't want to
+ // blindly throw it in to that task. Instead we will take the NEW_TASK flow and try to find
+ // a task for it. But save the task information so it can be used when creating the new task.
+ if ((mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) == 0) {
+ Slog.w(TAG, "startActivity called from finishing " + mSourceRecord
+ + "; forcing " + "Intent.FLAG_ACTIVITY_NEW_TASK for: " + mIntent);
+ mLaunchFlags |= FLAG_ACTIVITY_NEW_TASK;
+ mNewTaskInfo = mSourceRecord.info;
+
+ // It is not guaranteed that the source record will have a task associated with it. For,
+ // example, if this method is being called for processing a pending activity launch, it
+ // is possible that the activity has been removed from the task after the launch was
+ // enqueued.
+ final TaskRecord sourceTask = mSourceRecord.getTask();
+ mNewTaskIntent = sourceTask != null ? sourceTask.intent : null;
+ }
+ mSourceRecord = null;
+ mSourceStack = null;
+ }
+
+ /**
+ * Decide whether the new activity should be inserted into an existing task. Returns null
+ * if not or an ActivityRecord with the task into which the new activity should be added.
+ */
+ private ActivityRecord getReusableIntentActivity() {
+ // We may want to try to place the new activity in to an existing task. We always
+ // do this if the target activity is singleTask or singleInstance; we will also do
+ // this if NEW_TASK has been requested, and there is not an additional qualifier telling
+ // us to still place it in a new task: multi task, always doc mode, or being asked to
+ // launch this as a new task behind the current one.
+ boolean putIntoExistingTask = ((mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) != 0 &&
+ (mLaunchFlags & FLAG_ACTIVITY_MULTIPLE_TASK) == 0)
+ || isLaunchModeOneOf(LAUNCH_SINGLE_INSTANCE, LAUNCH_SINGLE_TASK);
+ // If bring to front is requested, and no result is requested and we have not been given
+ // an explicit task to launch in to, and we can find a task that was started with this
+ // same component, then instead of launching bring that one to the front.
+ putIntoExistingTask &= mInTask == null && mStartActivity.resultTo == null;
+ ActivityRecord intentActivity = null;
+ if (mOptions != null && mOptions.getLaunchTaskId() != -1) {
+ final TaskRecord task = mSupervisor.anyTaskForIdLocked(mOptions.getLaunchTaskId());
+ intentActivity = task != null ? task.getTopActivity() : null;
+ } else if (putIntoExistingTask) {
+ if (LAUNCH_SINGLE_INSTANCE == mLaunchMode) {
+ // There can be one and only one instance of single instance activity in the
+ // history, and it is always in its own unique task, so we do a special search.
+ intentActivity = mSupervisor.findActivityLocked(mIntent, mStartActivity.info,
+ mStartActivity.isActivityTypeHome());
+ } else if ((mLaunchFlags & FLAG_ACTIVITY_LAUNCH_ADJACENT) != 0) {
+ // For the launch adjacent case we only want to put the activity in an existing
+ // task if the activity already exists in the history.
+ intentActivity = mSupervisor.findActivityLocked(mIntent, mStartActivity.info,
+ !(LAUNCH_SINGLE_TASK == mLaunchMode));
+ } else {
+ // Otherwise find the best task to put the activity in.
+ intentActivity = mSupervisor.findTaskLocked(mStartActivity, mPreferredDisplayId);
+ }
+ }
+
+ if (mStartActivity.isActivityTypeHome() && intentActivity != null
+ && intentActivity.getDisplayId() != mPreferredDisplayId) {
+ // Do not reuse home activity on other displays.
+ intentActivity = null;
+ }
+
+ return intentActivity;
+ }
+
+ /**
+ * Figure out which task and activity to bring to front when we have found an existing matching
+ * activity record in history. May also clear the task if needed.
+ * @param intentActivity Existing matching activity.
+ * @return {@link ActivityRecord} brought to front.
+ */
+ private ActivityRecord setTargetStackAndMoveToFrontIfNeeded(ActivityRecord intentActivity) {
+ mTargetStack = intentActivity.getStack();
+ mTargetStack.mLastPausedActivity = null;
+ // If the target task is not in the front, then we need to bring it to the front...
+ // except... well, with SINGLE_TASK_LAUNCH it's not entirely clear. We'd like to have
+ // the same behavior as if a new instance was being started, which means not bringing it
+ // to the front if the caller is not itself in the front.
+ final boolean differentTopTask;
+ if (mPreferredDisplayId == mTargetStack.mDisplayId) {
+ final ActivityStack focusStack = mTargetStack.getDisplay().getFocusedStack();
+ final ActivityRecord curTop = (focusStack == null)
+ ? null : focusStack.topRunningNonDelayedActivityLocked(mNotTop);
+ final TaskRecord topTask = curTop != null ? curTop.getTask() : null;
+ differentTopTask = topTask != null
+ && (topTask != intentActivity.getTask() || topTask != focusStack.topTask());
+ } else {
+ // The existing task should always be different from those in other displays.
+ differentTopTask = true;
+ }
+
+ if (differentTopTask && !mAvoidMoveToFront) {
+ mStartActivity.intent.addFlags(Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT);
+ if (mSourceRecord == null || (mSourceStack.getTopActivity() != null &&
+ mSourceStack.getTopActivity().getTask() == mSourceRecord.getTask())) {
+ // We really do want to push this one into the user's face, right now.
+ if (mLaunchTaskBehind && mSourceRecord != null) {
+ intentActivity.setTaskToAffiliateWith(mSourceRecord.getTask());
+ }
+
+ // If the launch flags carry both NEW_TASK and CLEAR_TASK, the task's activities
+ // will be cleared soon by ActivityStarter in setTaskFromIntentActivity().
+ // So no point resuming any of the activities here, it just wastes one extra
+ // resuming, plus enter AND exit transitions.
+ // Here we only want to bring the target stack forward. Transition will be applied
+ // to the new activity that's started after the old ones are gone.
+ final boolean willClearTask =
+ (mLaunchFlags & (FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_CLEAR_TASK))
+ == (FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_CLEAR_TASK);
+ if (!willClearTask) {
+ final ActivityStack launchStack = getLaunchStack(
+ mStartActivity, mLaunchFlags, mStartActivity.getTask(), mOptions);
+ final TaskRecord intentTask = intentActivity.getTask();
+ if (launchStack == null || launchStack == mTargetStack) {
+ // We only want to move to the front, if we aren't going to launch on a
+ // different stack. If we launch on a different stack, we will put the
+ // task on top there.
+ mTargetStack.moveTaskToFrontLocked(intentTask, mNoAnimation, mOptions,
+ mStartActivity.appTimeTracker, "bringingFoundTaskToFront");
+ mMovedToFront = true;
+ } else if (launchStack.inSplitScreenWindowingMode()) {
+ if ((mLaunchFlags & FLAG_ACTIVITY_LAUNCH_ADJACENT) != 0) {
+ // If we want to launch adjacent and mTargetStack is not the computed
+ // launch stack - move task to top of computed stack.
+ intentTask.reparent(launchStack, ON_TOP,
+ REPARENT_MOVE_STACK_TO_FRONT, ANIMATE, DEFER_RESUME,
+ "launchToSide");
+ } else {
+ // TODO: This should be reevaluated in MW v2.
+ // We choose to move task to front instead of launching it adjacent
+ // when specific stack was requested explicitly and it appeared to be
+ // adjacent stack, but FLAG_ACTIVITY_LAUNCH_ADJACENT was not set.
+ mTargetStack.moveTaskToFrontLocked(intentTask,
+ mNoAnimation, mOptions, mStartActivity.appTimeTracker,
+ "bringToFrontInsteadOfAdjacentLaunch");
+ }
+ mMovedToFront = launchStack != launchStack.getDisplay()
+ .getTopStackInWindowingMode(launchStack.getWindowingMode());
+ } else if (launchStack.mDisplayId != mTargetStack.mDisplayId) {
+ // Target and computed stacks are on different displays and we've
+ // found a matching task - move the existing instance to that display and
+ // move it to front.
+ intentActivity.getTask().reparent(launchStack, ON_TOP,
+ REPARENT_MOVE_STACK_TO_FRONT, ANIMATE, DEFER_RESUME,
+ "reparentToDisplay");
+ mMovedToFront = true;
+ } else if (launchStack.isActivityTypeHome()
+ && !mTargetStack.isActivityTypeHome()) {
+ // It is possible for the home activity to be in another stack initially.
+ // For example, the activity may have been initially started with an intent
+ // which placed it in the fullscreen stack. To ensure the proper handling of
+ // the activity based on home stack assumptions, we must move it over.
+ intentActivity.getTask().reparent(launchStack, ON_TOP,
+ REPARENT_MOVE_STACK_TO_FRONT, ANIMATE, DEFER_RESUME,
+ "reparentingHome");
+ mMovedToFront = true;
+ }
+ mOptions = null;
+
+ // We are moving a task to the front, use starting window to hide initial drawn
+ // delay.
+ intentActivity.showStartingWindow(null /* prev */, false /* newTask */,
+ true /* taskSwitch */);
+ }
+ }
+ }
+ // Need to update mTargetStack because if task was moved out of it, the original stack may
+ // be destroyed.
+ mTargetStack = intentActivity.getStack();
+ if (!mMovedToFront && mDoResume) {
+ if (DEBUG_TASKS) Slog.d(TAG_TASKS, "Bring to front target: " + mTargetStack
+ + " from " + intentActivity);
+ mTargetStack.moveToFront("intentActivityFound");
+ }
+
+ mSupervisor.handleNonResizableTaskIfNeeded(intentActivity.getTask(),
+ WINDOWING_MODE_UNDEFINED, DEFAULT_DISPLAY, mTargetStack);
+
+ // If the caller has requested that the target task be reset, then do so.
+ if ((mLaunchFlags & FLAG_ACTIVITY_RESET_TASK_IF_NEEDED) != 0) {
+ return mTargetStack.resetTaskIfNeededLocked(intentActivity, mStartActivity);
+ }
+ return intentActivity;
+ }
+
+ private void setTaskFromIntentActivity(ActivityRecord intentActivity) {
+ if ((mLaunchFlags & (FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_CLEAR_TASK))
+ == (FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_CLEAR_TASK)) {
+ // The caller has requested to completely replace any existing task with its new
+ // activity. Well that should not be too hard...
+ // Note: we must persist the {@link TaskRecord} first as intentActivity could be
+ // removed from calling performClearTaskLocked (For example, if it is being brought out
+ // of history or if it is finished immediately), thus disassociating the task. Also note
+ // that mReuseTask is reset as a result of {@link TaskRecord#performClearTaskLocked}
+ // launching another activity.
+ // TODO(b/36119896): We shouldn't trigger activity launches in this path since we are
+ // already launching one.
+ final TaskRecord task = intentActivity.getTask();
+ task.performClearTaskLocked();
+ mReuseTask = task;
+ mReuseTask.setIntent(mStartActivity);
+ } else if ((mLaunchFlags & FLAG_ACTIVITY_CLEAR_TOP) != 0
+ || isLaunchModeOneOf(LAUNCH_SINGLE_INSTANCE, LAUNCH_SINGLE_TASK)) {
+ ActivityRecord top = intentActivity.getTask().performClearTaskLocked(mStartActivity,
+ mLaunchFlags);
+ if (top == null) {
+ // A special case: we need to start the activity because it is not currently
+ // running, and the caller has asked to clear the current task to have this
+ // activity at the top.
+ mAddingToTask = true;
+
+ // We are no longer placing the activity in the task we previously thought we were.
+ mStartActivity.setTask(null);
+ // Now pretend like this activity is being started by the top of its task, so it
+ // is put in the right place.
+ mSourceRecord = intentActivity;
+ final TaskRecord task = mSourceRecord.getTask();
+ if (task != null && task.getStack() == null) {
+ // Target stack got cleared when we all activities were removed above.
+ // Go ahead and reset it.
+ mTargetStack = computeStackFocus(mSourceRecord, false /* newTask */,
+ mLaunchFlags, mOptions);
+ mTargetStack.addTask(task,
+ !mLaunchTaskBehind /* toTop */, "startActivityUnchecked");
+ }
+ }
+ } else if (mStartActivity.realActivity.equals(intentActivity.getTask().realActivity)) {
+ // In this case the top activity on the task is the same as the one being launched,
+ // so we take that as a request to bring the task to the foreground. If the top
+ // activity in the task is the root activity, deliver this new intent to it if it
+ // desires.
+ if (((mLaunchFlags & FLAG_ACTIVITY_SINGLE_TOP) != 0
+ || LAUNCH_SINGLE_TOP == mLaunchMode)
+ && intentActivity.realActivity.equals(mStartActivity.realActivity)) {
+ if (intentActivity.frontOfTask) {
+ intentActivity.getTask().setIntent(mStartActivity);
+ }
+ deliverNewIntent(intentActivity);
+ } else if (!intentActivity.getTask().isSameIntentFilter(mStartActivity)) {
+ // In this case we are launching the root activity of the task, but with a
+ // different intent. We should start a new instance on top.
+ mAddingToTask = true;
+ mSourceRecord = intentActivity;
+ }
+ } else if ((mLaunchFlags & FLAG_ACTIVITY_RESET_TASK_IF_NEEDED) == 0) {
+ // In this case an activity is being launched in to an existing task, without
+ // resetting that task. This is typically the situation of launching an activity
+ // from a notification or shortcut. We want to place the new activity on top of the
+ // current task.
+ mAddingToTask = true;
+ mSourceRecord = intentActivity;
+ } else if (!intentActivity.getTask().rootWasReset) {
+ // In this case we are launching into an existing task that has not yet been started
+ // from its front door. The current task has been brought to the front. Ideally,
+ // we'd probably like to place this new task at the bottom of its stack, but that's
+ // a little hard to do with the current organization of the code so for now we'll
+ // just drop it.
+ intentActivity.getTask().setIntent(mStartActivity);
+ }
+ }
+
+ private void resumeTargetStackIfNeeded() {
+ if (mDoResume) {
+ mSupervisor.resumeFocusedStacksTopActivitiesLocked(mTargetStack, null, mOptions);
+ } else {
+ ActivityOptions.abort(mOptions);
+ }
+ mSupervisor.updateUserStackLocked(mStartActivity.userId, mTargetStack);
+ }
+
+ private int setTaskFromReuseOrCreateNewTask(TaskRecord taskToAffiliate) {
+ mTargetStack = computeStackFocus(mStartActivity, true, mLaunchFlags, mOptions);
+
+ // Do no move the target stack to front yet, as we might bail if
+ // isLockTaskModeViolation fails below.
+
+ if (mReuseTask == null) {
+ final TaskRecord task = mTargetStack.createTaskRecord(
+ mSupervisor.getNextTaskIdForUserLocked(mStartActivity.userId),
+ mNewTaskInfo != null ? mNewTaskInfo : mStartActivity.info,
+ mNewTaskIntent != null ? mNewTaskIntent : mIntent, mVoiceSession,
+ mVoiceInteractor, !mLaunchTaskBehind /* toTop */, mStartActivity, mSourceRecord,
+ mOptions);
+ addOrReparentStartingActivity(task, "setTaskFromReuseOrCreateNewTask - mReuseTask");
+ updateBounds(mStartActivity.getTask(), mLaunchParams.mBounds);
+
+ if (DEBUG_TASKS) Slog.v(TAG_TASKS, "Starting new activity " + mStartActivity
+ + " in new task " + mStartActivity.getTask());
+ } else {
+ addOrReparentStartingActivity(mReuseTask, "setTaskFromReuseOrCreateNewTask");
+ }
+
+ if (taskToAffiliate != null) {
+ mStartActivity.setTaskToAffiliateWith(taskToAffiliate);
+ }
+
+ if (mService.getLockTaskController().isLockTaskModeViolation(mStartActivity.getTask())) {
+ Slog.e(TAG, "Attempted Lock Task Mode violation mStartActivity=" + mStartActivity);
+ return START_RETURN_LOCK_TASK_MODE_VIOLATION;
+ }
+
+ if (mDoResume) {
+ mTargetStack.moveToFront("reuseOrNewTask");
+ }
+ return START_SUCCESS;
+ }
+
+ private void deliverNewIntent(ActivityRecord activity) {
+ if (mIntentDelivered) {
+ return;
+ }
+
+ ActivityStack.logStartActivity(AM_NEW_INTENT, activity, activity.getTask());
+ activity.deliverNewIntentLocked(mCallingUid, mStartActivity.intent,
+ mStartActivity.launchedFromPackage);
+ mIntentDelivered = true;
+ }
+
+ private int setTaskFromSourceRecord() {
+ if (mService.getLockTaskController().isLockTaskModeViolation(mSourceRecord.getTask())) {
+ Slog.e(TAG, "Attempted Lock Task Mode violation mStartActivity=" + mStartActivity);
+ return START_RETURN_LOCK_TASK_MODE_VIOLATION;
+ }
+
+ final TaskRecord sourceTask = mSourceRecord.getTask();
+ final ActivityStack sourceStack = mSourceRecord.getStack();
+ // We only want to allow changing stack in two cases:
+ // 1. If the target task is not the top one. Otherwise we would move the launching task to
+ // the other side, rather than show two side by side.
+ // 2. If activity is not allowed on target display.
+ final int targetDisplayId = mTargetStack != null ? mTargetStack.mDisplayId
+ : sourceStack.mDisplayId;
+ final boolean moveStackAllowed = sourceStack.topTask() != sourceTask
+ || !mStartActivity.canBeLaunchedOnDisplay(targetDisplayId);
+ if (moveStackAllowed) {
+ mTargetStack = getLaunchStack(mStartActivity, mLaunchFlags, mStartActivity.getTask(),
+ mOptions);
+ // If target stack is not found now - we can't just rely on the source stack, as it may
+ // be not suitable. Let's check other displays.
+ if (mTargetStack == null && targetDisplayId != sourceStack.mDisplayId) {
+ // Can't use target display, lets find a stack on the source display.
+ mTargetStack = mSupervisor.getValidLaunchStackOnDisplay(
+ sourceStack.mDisplayId, mStartActivity, mOptions);
+ }
+ if (mTargetStack == null) {
+ // There are no suitable stacks on the target and source display(s). Look on all
+ // displays.
+ mTargetStack = mSupervisor.getNextValidLaunchStackLocked(
+ mStartActivity, -1 /* currentFocus */);
+ }
+ }
+
+ if (mTargetStack == null) {
+ mTargetStack = sourceStack;
+ } else if (mTargetStack != sourceStack) {
+ sourceTask.reparent(mTargetStack, ON_TOP, REPARENT_MOVE_STACK_TO_FRONT, !ANIMATE,
+ DEFER_RESUME, "launchToSide");
+ }
+
+ final TaskRecord topTask = mTargetStack.topTask();
+ if (topTask != sourceTask && !mAvoidMoveToFront) {
+ mTargetStack.moveTaskToFrontLocked(sourceTask, mNoAnimation, mOptions,
+ mStartActivity.appTimeTracker, "sourceTaskToFront");
+ } else if (mDoResume) {
+ mTargetStack.moveToFront("sourceStackToFront");
+ }
+
+ if (!mAddingToTask && (mLaunchFlags & FLAG_ACTIVITY_CLEAR_TOP) != 0) {
+ // In this case, we are adding the activity to an existing task, but the caller has
+ // asked to clear that task if the activity is already running.
+ ActivityRecord top = sourceTask.performClearTaskLocked(mStartActivity, mLaunchFlags);
+ mKeepCurTransition = true;
+ if (top != null) {
+ ActivityStack.logStartActivity(AM_NEW_INTENT, mStartActivity, top.getTask());
+ deliverNewIntent(top);
+ // For paranoia, make sure we have correctly resumed the top activity.
+ mTargetStack.mLastPausedActivity = null;
+ if (mDoResume) {
+ mSupervisor.resumeFocusedStacksTopActivitiesLocked();
+ }
+ ActivityOptions.abort(mOptions);
+ return START_DELIVERED_TO_TOP;
+ }
+ } else if (!mAddingToTask && (mLaunchFlags & FLAG_ACTIVITY_REORDER_TO_FRONT) != 0) {
+ // In this case, we are launching an activity in our own task that may already be
+ // running somewhere in the history, and we want to shuffle it to the front of the
+ // stack if so.
+ final ActivityRecord top = sourceTask.findActivityInHistoryLocked(mStartActivity);
+ if (top != null) {
+ final TaskRecord task = top.getTask();
+ task.moveActivityToFrontLocked(top);
+ top.updateOptionsLocked(mOptions);
+ ActivityStack.logStartActivity(AM_NEW_INTENT, mStartActivity, task);
+ deliverNewIntent(top);
+ mTargetStack.mLastPausedActivity = null;
+ if (mDoResume) {
+ mSupervisor.resumeFocusedStacksTopActivitiesLocked();
+ }
+ return START_DELIVERED_TO_TOP;
+ }
+ }
+
+ // An existing activity is starting this new activity, so we want to keep the new one in
+ // the same task as the one that is starting it.
+ addOrReparentStartingActivity(sourceTask, "setTaskFromSourceRecord");
+ if (DEBUG_TASKS) Slog.v(TAG_TASKS, "Starting new activity " + mStartActivity
+ + " in existing task " + mStartActivity.getTask() + " from source " + mSourceRecord);
+ return START_SUCCESS;
+ }
+
+ private int setTaskFromInTask() {
+ // The caller is asking that the new activity be started in an explicit
+ // task it has provided to us.
+ if (mService.getLockTaskController().isLockTaskModeViolation(mInTask)) {
+ Slog.e(TAG, "Attempted Lock Task Mode violation mStartActivity=" + mStartActivity);
+ return START_RETURN_LOCK_TASK_MODE_VIOLATION;
+ }
+
+ mTargetStack = mInTask.getStack();
+
+ // Check whether we should actually launch the new activity in to the task,
+ // or just reuse the current activity on top.
+ ActivityRecord top = mInTask.getTopActivity();
+ if (top != null && top.realActivity.equals(mStartActivity.realActivity)
+ && top.userId == mStartActivity.userId) {
+ if ((mLaunchFlags & FLAG_ACTIVITY_SINGLE_TOP) != 0
+ || isLaunchModeOneOf(LAUNCH_SINGLE_TOP, LAUNCH_SINGLE_TASK)) {
+ mTargetStack.moveTaskToFrontLocked(mInTask, mNoAnimation, mOptions,
+ mStartActivity.appTimeTracker, "inTaskToFront");
+ if ((mStartFlags & START_FLAG_ONLY_IF_NEEDED) != 0) {
+ // We don't need to start a new activity, and the client said not to do
+ // anything if that is the case, so this is it!
+ return START_RETURN_INTENT_TO_CALLER;
+ }
+ deliverNewIntent(top);
+ return START_DELIVERED_TO_TOP;
+ }
+ }
+
+ if (!mAddingToTask) {
+ mTargetStack.moveTaskToFrontLocked(mInTask, mNoAnimation, mOptions,
+ mStartActivity.appTimeTracker, "inTaskToFront");
+ // We don't actually want to have this activity added to the task, so just
+ // stop here but still tell the caller that we consumed the intent.
+ ActivityOptions.abort(mOptions);
+ return START_TASK_TO_FRONT;
+ }
+
+ if (!mLaunchParams.mBounds.isEmpty()) {
+ // TODO: Shouldn't we already know what stack to use by the time we get here?
+ ActivityStack stack = mSupervisor.getLaunchStack(null, null, mInTask, ON_TOP);
+ if (stack != mInTask.getStack()) {
+ mInTask.reparent(stack, ON_TOP, REPARENT_KEEP_STACK_AT_FRONT, !ANIMATE,
+ DEFER_RESUME, "inTaskToFront");
+ mTargetStack = mInTask.getStack();
+ }
+
+ updateBounds(mInTask, mLaunchParams.mBounds);
+ }
+
+ mTargetStack.moveTaskToFrontLocked(
+ mInTask, mNoAnimation, mOptions, mStartActivity.appTimeTracker, "inTaskToFront");
+
+ addOrReparentStartingActivity(mInTask, "setTaskFromInTask");
+ if (DEBUG_TASKS) Slog.v(TAG_TASKS, "Starting new activity " + mStartActivity
+ + " in explicit task " + mStartActivity.getTask());
+
+ return START_SUCCESS;
+ }
+
+ @VisibleForTesting
+ void updateBounds(TaskRecord task, Rect bounds) {
+ if (bounds.isEmpty()) {
+ return;
+ }
+
+ final ActivityStack stack = task.getStack();
+ if (stack != null && stack.resizeStackWithLaunchBounds()) {
+ mService.resizeStack(
+ stack.mStackId, bounds, true, !PRESERVE_WINDOWS, ANIMATE, -1);
+ } else {
+ task.updateOverrideConfiguration(bounds);
+ }
+ }
+
+ private void setTaskToCurrentTopOrCreateNewTask() {
+ mTargetStack = computeStackFocus(mStartActivity, false, mLaunchFlags, mOptions);
+ if (mDoResume) {
+ mTargetStack.moveToFront("addingToTopTask");
+ }
+ final ActivityRecord prev = mTargetStack.getTopActivity();
+ final TaskRecord task = (prev != null) ? prev.getTask() : mTargetStack.createTaskRecord(
+ mSupervisor.getNextTaskIdForUserLocked(mStartActivity.userId), mStartActivity.info,
+ mIntent, null, null, true, mStartActivity, mSourceRecord, mOptions);
+ addOrReparentStartingActivity(task, "setTaskToCurrentTopOrCreateNewTask");
+ mTargetStack.positionChildWindowContainerAtTop(task);
+ if (DEBUG_TASKS) Slog.v(TAG_TASKS, "Starting new activity " + mStartActivity
+ + " in new guessed " + mStartActivity.getTask());
+ }
+
+ private void addOrReparentStartingActivity(TaskRecord parent, String reason) {
+ if (mStartActivity.getTask() == null || mStartActivity.getTask() == parent) {
+ parent.addActivityToTop(mStartActivity);
+ } else {
+ mStartActivity.reparent(parent, parent.mActivities.size() /* top */, reason);
+ }
+ }
+
+ private int adjustLaunchFlagsToDocumentMode(ActivityRecord r, boolean launchSingleInstance,
+ boolean launchSingleTask, int launchFlags) {
+ if ((launchFlags & Intent.FLAG_ACTIVITY_NEW_DOCUMENT) != 0 &&
+ (launchSingleInstance || launchSingleTask)) {
+ // We have a conflict between the Intent and the Activity manifest, manifest wins.
+ Slog.i(TAG, "Ignoring FLAG_ACTIVITY_NEW_DOCUMENT, launchMode is " +
+ "\"singleInstance\" or \"singleTask\"");
+ launchFlags &=
+ ~(Intent.FLAG_ACTIVITY_NEW_DOCUMENT | FLAG_ACTIVITY_MULTIPLE_TASK);
+ } else {
+ switch (r.info.documentLaunchMode) {
+ case ActivityInfo.DOCUMENT_LAUNCH_NONE:
+ break;
+ case ActivityInfo.DOCUMENT_LAUNCH_INTO_EXISTING:
+ launchFlags |= Intent.FLAG_ACTIVITY_NEW_DOCUMENT;
+ break;
+ case ActivityInfo.DOCUMENT_LAUNCH_ALWAYS:
+ launchFlags |= Intent.FLAG_ACTIVITY_NEW_DOCUMENT;
+ break;
+ case ActivityInfo.DOCUMENT_LAUNCH_NEVER:
+ launchFlags &= ~FLAG_ACTIVITY_MULTIPLE_TASK;
+ break;
+ }
+ }
+ return launchFlags;
+ }
+
+ private ActivityStack computeStackFocus(ActivityRecord r, boolean newTask, int launchFlags,
+ ActivityOptions aOptions) {
+ final TaskRecord task = r.getTask();
+ ActivityStack stack = getLaunchStack(r, launchFlags, task, aOptions);
+ if (stack != null) {
+ return stack;
+ }
+
+ final ActivityStack currentStack = task != null ? task.getStack() : null;
+ final ActivityStack focusedStack = mSupervisor.getTopDisplayFocusedStack();
+ if (currentStack != null) {
+ if (focusedStack != currentStack) {
+ if (DEBUG_FOCUS || DEBUG_STACK) Slog.d(TAG_FOCUS,
+ "computeStackFocus: Setting " + "focused stack to r=" + r
+ + " task=" + task);
+ } else {
+ if (DEBUG_FOCUS || DEBUG_STACK) Slog.d(TAG_FOCUS,
+ "computeStackFocus: Focused stack already=" + focusedStack);
+ }
+ return currentStack;
+ }
+
+ if (canLaunchIntoFocusedStack(r, newTask)) {
+ if (DEBUG_FOCUS || DEBUG_STACK) Slog.d(TAG_FOCUS,
+ "computeStackFocus: Have a focused stack=" + focusedStack);
+ return focusedStack;
+ }
+
+ if (mPreferredDisplayId != DEFAULT_DISPLAY) {
+ // Try to put the activity in a stack on a secondary display.
+ stack = mSupervisor.getValidLaunchStackOnDisplay(mPreferredDisplayId, r, aOptions);
+ if (stack == null) {
+ // If source display is not suitable - look for topmost valid stack in the system.
+ if (DEBUG_FOCUS || DEBUG_STACK) Slog.d(TAG_FOCUS,
+ "computeStackFocus: Can't launch on mPreferredDisplayId="
+ + mPreferredDisplayId + ", looking on all displays.");
+ stack = mSupervisor.getNextValidLaunchStackLocked(r, mPreferredDisplayId);
+ }
+ }
+ if (stack == null) {
+ stack = mSupervisor.getLaunchStack(r, aOptions, task, ON_TOP);
+ }
+ if (DEBUG_FOCUS || DEBUG_STACK) Slog.d(TAG_FOCUS, "computeStackFocus: New stack r="
+ + r + " stackId=" + stack.mStackId);
+ return stack;
+ }
+
+ /** Check if provided activity record can launch in currently focused stack. */
+ // TODO: This method can probably be consolidated into getLaunchStack() below.
+ private boolean canLaunchIntoFocusedStack(ActivityRecord r, boolean newTask) {
+ final ActivityStack focusedStack = mSupervisor.getTopDisplayFocusedStack();
+ final boolean canUseFocusedStack;
+ if (focusedStack.isActivityTypeAssistant()) {
+ canUseFocusedStack = r.isActivityTypeAssistant();
+ } else {
+ switch (focusedStack.getWindowingMode()) {
+ case WINDOWING_MODE_FULLSCREEN:
+ // The fullscreen stack can contain any task regardless of if the task is
+ // resizeable or not. So, we let the task go in the fullscreen task if it is the
+ // focus stack.
+ canUseFocusedStack = true;
+ break;
+ case WINDOWING_MODE_SPLIT_SCREEN_PRIMARY:
+ case WINDOWING_MODE_SPLIT_SCREEN_SECONDARY:
+ // Any activity which supports split screen can go in the docked stack.
+ canUseFocusedStack = r.supportsSplitScreenWindowingMode();
+ break;
+ case WINDOWING_MODE_FREEFORM:
+ // Any activity which supports freeform can go in the freeform stack.
+ canUseFocusedStack = r.supportsFreeform();
+ break;
+ default:
+ // Dynamic stacks behave similarly to the fullscreen stack and can contain any
+ // resizeable task.
+ canUseFocusedStack = !focusedStack.isOnHomeDisplay()
+ && r.canBeLaunchedOnDisplay(focusedStack.mDisplayId);
+ }
+ }
+ return canUseFocusedStack && !newTask
+ // Using the focus stack isn't important enough to override the preferred display.
+ && (mPreferredDisplayId == focusedStack.mDisplayId);
+ }
+
+ private ActivityStack getLaunchStack(ActivityRecord r, int launchFlags, TaskRecord task,
+ ActivityOptions aOptions) {
+ // We are reusing a task, keep the stack!
+ if (mReuseTask != null) {
+ return mReuseTask.getStack();
+ }
+
+ if (((launchFlags & FLAG_ACTIVITY_LAUNCH_ADJACENT) == 0)
+ || mPreferredDisplayId != DEFAULT_DISPLAY) {
+ // We don't pass in the default display id into the get launch stack call so it can do a
+ // full resolution.
+ final int candidateDisplay =
+ mPreferredDisplayId != DEFAULT_DISPLAY ? mPreferredDisplayId : INVALID_DISPLAY;
+ return mSupervisor.getLaunchStack(r, aOptions, task, ON_TOP, candidateDisplay);
+ }
+ // Otherwise handle adjacent launch.
+
+ final ActivityStack focusedStack = mSupervisor.getTopDisplayFocusedStack();
+ // The parent activity doesn't want to launch the activity on top of itself, but
+ // instead tries to put it onto other side in side-by-side mode.
+ final ActivityStack parentStack = task != null ? task.getStack(): focusedStack;
+
+ if (parentStack != focusedStack) {
+ // If task's parent stack is not focused - use it during adjacent launch.
+ return parentStack;
+ } else {
+ if (focusedStack != null && task == focusedStack.topTask()) {
+ // If task is already on top of focused stack - use it. We don't want to move the
+ // existing focused task to adjacent stack, just deliver new intent in this case.
+ return focusedStack;
+ }
+
+ if (parentStack != null && parentStack.inSplitScreenPrimaryWindowingMode()) {
+ // If parent was in docked stack, the natural place to launch another activity
+ // will be fullscreen, so it can appear alongside the docked window.
+ final int activityType = mSupervisor.resolveActivityType(r, mOptions, task);
+ return parentStack.getDisplay().getOrCreateStack(
+ WINDOWING_MODE_SPLIT_SCREEN_SECONDARY, activityType, ON_TOP);
+ } else {
+ // If the parent is not in the docked stack, we check if there is docked window
+ // and if yes, we will launch into that stack. If not, we just put the new
+ // activity into parent's stack, because we can't find a better place.
+ final ActivityStack dockedStack =
+ mSupervisor.getDefaultDisplay().getSplitScreenPrimaryStack();
+ if (dockedStack != null && !dockedStack.shouldBeVisible(r)) {
+ // There is a docked stack, but it isn't visible, so we can't launch into that.
+ return mSupervisor.getLaunchStack(r, aOptions, task, ON_TOP);
+ } else {
+ return dockedStack;
+ }
+ }
+ }
+ }
+
+ private boolean isLaunchModeOneOf(int mode1, int mode2) {
+ return mode1 == mLaunchMode || mode2 == mLaunchMode;
+ }
+
+ static boolean isDocumentLaunchesIntoExisting(int flags) {
+ return (flags & Intent.FLAG_ACTIVITY_NEW_DOCUMENT) != 0 &&
+ (flags & Intent.FLAG_ACTIVITY_MULTIPLE_TASK) == 0;
+ }
+
+ ActivityStarter setIntent(Intent intent) {
+ mRequest.intent = intent;
+ return this;
+ }
+
+ @VisibleForTesting
+ Intent getIntent() {
+ return mRequest.intent;
+ }
+
+ ActivityStarter setReason(String reason) {
+ mRequest.reason = reason;
+ return this;
+ }
+
+ ActivityStarter setCaller(IApplicationThread caller) {
+ mRequest.caller = caller;
+ return this;
+ }
+
+ ActivityStarter setEphemeralIntent(Intent intent) {
+ mRequest.ephemeralIntent = intent;
+ return this;
+ }
+
+
+ ActivityStarter setResolvedType(String type) {
+ mRequest.resolvedType = type;
+ return this;
+ }
+
+ ActivityStarter setActivityInfo(ActivityInfo info) {
+ mRequest.activityInfo = info;
+ return this;
+ }
+
+ ActivityStarter setResolveInfo(ResolveInfo info) {
+ mRequest.resolveInfo = info;
+ return this;
+ }
+
+ ActivityStarter setVoiceSession(IVoiceInteractionSession voiceSession) {
+ mRequest.voiceSession = voiceSession;
+ return this;
+ }
+
+ ActivityStarter setVoiceInteractor(IVoiceInteractor voiceInteractor) {
+ mRequest.voiceInteractor = voiceInteractor;
+ return this;
+ }
+
+ ActivityStarter setResultTo(IBinder resultTo) {
+ mRequest.resultTo = resultTo;
+ return this;
+ }
+
+ ActivityStarter setResultWho(String resultWho) {
+ mRequest.resultWho = resultWho;
+ return this;
+ }
+
+ ActivityStarter setRequestCode(int requestCode) {
+ mRequest.requestCode = requestCode;
+ return this;
+ }
+
+ ActivityStarter setCallingPid(int pid) {
+ mRequest.callingPid = pid;
+ return this;
+ }
+
+ ActivityStarter setCallingUid(int uid) {
+ mRequest.callingUid = uid;
+ return this;
+ }
+
+ ActivityStarter setCallingPackage(String callingPackage) {
+ mRequest.callingPackage = callingPackage;
+ return this;
+ }
+
+ ActivityStarter setRealCallingPid(int pid) {
+ mRequest.realCallingPid = pid;
+ return this;
+ }
+
+ ActivityStarter setRealCallingUid(int uid) {
+ mRequest.realCallingUid = uid;
+ return this;
+ }
+
+ ActivityStarter setStartFlags(int startFlags) {
+ mRequest.startFlags = startFlags;
+ return this;
+ }
+
+ ActivityStarter setActivityOptions(SafeActivityOptions options) {
+ mRequest.activityOptions = options;
+ return this;
+ }
+
+ ActivityStarter setActivityOptions(Bundle bOptions) {
+ return setActivityOptions(SafeActivityOptions.fromBundle(bOptions));
+ }
+
+ ActivityStarter setIgnoreTargetSecurity(boolean ignoreTargetSecurity) {
+ mRequest.ignoreTargetSecurity = ignoreTargetSecurity;
+ return this;
+ }
+
+ ActivityStarter setFilterCallingUid(int filterCallingUid) {
+ mRequest.filterCallingUid = filterCallingUid;
+ return this;
+ }
+
+ ActivityStarter setComponentSpecified(boolean componentSpecified) {
+ mRequest.componentSpecified = componentSpecified;
+ return this;
+ }
+
+ ActivityStarter setOutActivity(ActivityRecord[] outActivity) {
+ mRequest.outActivity = outActivity;
+ return this;
+ }
+
+ ActivityStarter setInTask(TaskRecord inTask) {
+ mRequest.inTask = inTask;
+ return this;
+ }
+
+ ActivityStarter setWaitResult(WaitResult result) {
+ mRequest.waitResult = result;
+ return this;
+ }
+
+ ActivityStarter setProfilerInfo(ProfilerInfo info) {
+ mRequest.profilerInfo = info;
+ return this;
+ }
+
+ ActivityStarter setGlobalConfiguration(Configuration config) {
+ mRequest.globalConfig = config;
+ return this;
+ }
+
+ ActivityStarter setUserId(int userId) {
+ mRequest.userId = userId;
+ return this;
+ }
+
+ ActivityStarter setMayWait(int userId) {
+ mRequest.mayWait = true;
+ mRequest.userId = userId;
+
+ return this;
+ }
+
+ ActivityStarter setAllowPendingRemoteAnimationRegistryLookup(boolean allowLookup) {
+ mRequest.allowPendingRemoteAnimationRegistryLookup = allowLookup;
+ return this;
+ }
+
+ ActivityStarter setOriginatingPendingIntent(PendingIntentRecord originatingPendingIntent) {
+ mRequest.originatingPendingIntent = originatingPendingIntent;
+ return this;
+ }
+
+ void dump(PrintWriter pw, String prefix) {
+ prefix = prefix + " ";
+ pw.print(prefix);
+ pw.print("mCurrentUser=");
+ pw.println(mSupervisor.mCurrentUser);
+ pw.print(prefix);
+ pw.print("mLastStartReason=");
+ pw.println(mLastStartReason);
+ pw.print(prefix);
+ pw.print("mLastStartActivityTimeMs=");
+ pw.println(DateFormat.getDateTimeInstance().format(new Date(mLastStartActivityTimeMs)));
+ pw.print(prefix);
+ pw.print("mLastStartActivityResult=");
+ pw.println(mLastStartActivityResult);
+ ActivityRecord r = mLastStartActivityRecord[0];
+ if (r != null) {
+ pw.print(prefix);
+ pw.println("mLastStartActivityRecord:");
+ r.dump(pw, prefix + " ");
+ }
+ if (mStartActivity != null) {
+ pw.print(prefix);
+ pw.println("mStartActivity:");
+ mStartActivity.dump(pw, prefix + " ");
+ }
+ if (mIntent != null) {
+ pw.print(prefix);
+ pw.print("mIntent=");
+ pw.println(mIntent);
+ }
+ if (mOptions != null) {
+ pw.print(prefix);
+ pw.print("mOptions=");
+ pw.println(mOptions);
+ }
+ pw.print(prefix);
+ pw.print("mLaunchSingleTop=");
+ pw.print(LAUNCH_SINGLE_TOP == mLaunchMode);
+ pw.print(" mLaunchSingleInstance=");
+ pw.print(LAUNCH_SINGLE_INSTANCE == mLaunchMode);
+ pw.print(" mLaunchSingleTask=");
+ pw.println(LAUNCH_SINGLE_TASK == mLaunchMode);
+ pw.print(prefix);
+ pw.print("mLaunchFlags=0x");
+ pw.print(Integer.toHexString(mLaunchFlags));
+ pw.print(" mDoResume=");
+ pw.print(mDoResume);
+ pw.print(" mAddingToTask=");
+ pw.println(mAddingToTask);
+ }
+}
diff --git a/services/core/java/com/android/server/wm/ActivityTaskManagerDebugConfig.java b/services/core/java/com/android/server/wm/ActivityTaskManagerDebugConfig.java
new file mode 100644
index 0000000..7f09a07
--- /dev/null
+++ b/services/core/java/com/android/server/wm/ActivityTaskManagerDebugConfig.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.server.wm;
+
+/**
+ * Common class for the various debug {@link android.util.Log} output configuration relating to
+ * activities.
+ */
+public class ActivityTaskManagerDebugConfig {
+ // All output logs relating to acitvities use the {@link #TAG_ATM} string for tagging their log
+ // output. This makes it easy to identify the origin of the log message when sifting
+ // through a large amount of log output from multiple sources. However, it also makes trying
+ // to figure-out the origin of a log message while debugging the activity manager a little
+ // painful. By setting this constant to true, log messages from the activity manager package
+ // will be tagged with their class names instead fot the generic tag.
+ static final boolean TAG_WITH_CLASS_NAME = false;
+
+ // While debugging it is sometimes useful to have the category name of the log appended to the
+ // base log tag to make sifting through logs with the same base tag easier. By setting this
+ // constant to true, the category name of the log point will be appended to the log tag.
+ private static final boolean APPEND_CATEGORY_NAME = false;
+
+ // Default log tag for the activities.
+ static final String TAG_ATM = "ActivityTaskManager";
+
+ // Enable all debug log categories.
+ static final boolean DEBUG_ALL = false;
+
+ // Enable all debug log categories for activities.
+ private static final boolean DEBUG_ALL_ACTIVITIES = DEBUG_ALL || false;
+
+ static final boolean DEBUG_ADD_REMOVE = DEBUG_ALL_ACTIVITIES || false;
+ public static final boolean DEBUG_CONFIGURATION = DEBUG_ALL || false;
+ static final boolean DEBUG_CONTAINERS = DEBUG_ALL_ACTIVITIES || false;
+ static final boolean DEBUG_FOCUS = false;
+ static final boolean DEBUG_IMMERSIVE = DEBUG_ALL || false;
+ static final boolean DEBUG_LOCKTASK = DEBUG_ALL || false;
+ static final boolean DEBUG_PAUSE = DEBUG_ALL || false;
+ static final boolean DEBUG_RECENTS = DEBUG_ALL || false;
+ static final boolean DEBUG_RECENTS_TRIM_TASKS = DEBUG_RECENTS || false;
+ static final boolean DEBUG_SAVED_STATE = DEBUG_ALL_ACTIVITIES || false;
+ static final boolean DEBUG_STACK = DEBUG_ALL || false;
+ static final boolean DEBUG_STATES = DEBUG_ALL_ACTIVITIES || false;
+ public static final boolean DEBUG_SWITCH = DEBUG_ALL || false;
+ static final boolean DEBUG_TASKS = DEBUG_ALL || false;
+ static final boolean DEBUG_TRANSITION = DEBUG_ALL || false;
+ static final boolean DEBUG_VISIBILITY = DEBUG_ALL || false;
+ static final boolean DEBUG_APP = DEBUG_ALL_ACTIVITIES || false;
+ static final boolean DEBUG_IDLE = DEBUG_ALL_ACTIVITIES || false;
+ static final boolean DEBUG_RELEASE = DEBUG_ALL_ACTIVITIES || false;
+ static final boolean DEBUG_USER_LEAVING = DEBUG_ALL || false;
+ static final boolean DEBUG_PERMISSIONS_REVIEW = DEBUG_ALL || false;
+ static final boolean DEBUG_RESULTS = DEBUG_ALL || false;
+ public static final boolean DEBUG_CLEANUP = DEBUG_ALL || false;
+ public static final boolean DEBUG_METRICS = DEBUG_ALL || false;
+
+ static final String POSTFIX_APP = APPEND_CATEGORY_NAME ? "_App" : "";
+ static final String POSTFIX_CLEANUP = (APPEND_CATEGORY_NAME) ? "_Cleanup" : "";
+ static final String POSTFIX_IDLE = APPEND_CATEGORY_NAME ? "_Idle" : "";
+ static final String POSTFIX_RELEASE = APPEND_CATEGORY_NAME ? "_Release" : "";
+ static final String POSTFIX_USER_LEAVING = APPEND_CATEGORY_NAME ? "_UserLeaving" : "";
+ static final String POSTFIX_ADD_REMOVE = APPEND_CATEGORY_NAME ? "_AddRemove" : "";
+ public static final String POSTFIX_CONFIGURATION = APPEND_CATEGORY_NAME ? "_Configuration" : "";
+ static final String POSTFIX_CONTAINERS = APPEND_CATEGORY_NAME ? "_Containers" : "";
+ static final String POSTFIX_FOCUS = APPEND_CATEGORY_NAME ? "_Focus" : "";
+ static final String POSTFIX_IMMERSIVE = APPEND_CATEGORY_NAME ? "_Immersive" : "";
+ public static final String POSTFIX_LOCKTASK = APPEND_CATEGORY_NAME ? "_LockTask" : "";
+ static final String POSTFIX_PAUSE = APPEND_CATEGORY_NAME ? "_Pause" : "";
+ static final String POSTFIX_RECENTS = APPEND_CATEGORY_NAME ? "_Recents" : "";
+ static final String POSTFIX_SAVED_STATE = APPEND_CATEGORY_NAME ? "_SavedState" : "";
+ static final String POSTFIX_STACK = APPEND_CATEGORY_NAME ? "_Stack" : "";
+ static final String POSTFIX_STATES = APPEND_CATEGORY_NAME ? "_States" : "";
+ public static final String POSTFIX_SWITCH = APPEND_CATEGORY_NAME ? "_Switch" : "";
+ static final String POSTFIX_TASKS = APPEND_CATEGORY_NAME ? "_Tasks" : "";
+ static final String POSTFIX_TRANSITION = APPEND_CATEGORY_NAME ? "_Transition" : "";
+ static final String POSTFIX_VISIBILITY = APPEND_CATEGORY_NAME ? "_Visibility" : "";
+ static final String POSTFIX_RESULTS = APPEND_CATEGORY_NAME ? "_Results" : "";
+}
diff --git a/services/core/java/com/android/server/wm/ActivityTaskManagerInternal.java b/services/core/java/com/android/server/wm/ActivityTaskManagerInternal.java
index 9a38f68..dcc7bc5 100644
--- a/services/core/java/com/android/server/wm/ActivityTaskManagerInternal.java
+++ b/services/core/java/com/android/server/wm/ActivityTaskManagerInternal.java
@@ -36,12 +36,8 @@
import android.util.proto.ProtoOutputStream;
import com.android.internal.app.IVoiceInteractor;
-import com.android.server.am.ActivityServiceConnectionsHolder;
import com.android.server.am.PendingIntentRecord;
-import com.android.server.am.SafeActivityOptions;
-import com.android.server.am.TaskRecord;
import com.android.server.am.UserState;
-import com.android.server.am.WindowProcessController;
import java.io.FileDescriptor;
import java.io.PrintWriter;
diff --git a/services/core/java/com/android/server/wm/ActivityTaskManagerService.java b/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
new file mode 100644
index 0000000..3ede8bc8
--- /dev/null
+++ b/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
@@ -0,0 +1,6766 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.server.wm;
+
+import static android.Manifest.permission.BIND_VOICE_INTERACTION;
+import static android.Manifest.permission.CHANGE_CONFIGURATION;
+import static android.Manifest.permission.CONTROL_REMOTE_APP_TRANSITION_ANIMATIONS;
+import static android.Manifest.permission.INTERNAL_SYSTEM_WINDOW;
+import static android.Manifest.permission.MANAGE_ACTIVITY_STACKS;
+import static android.Manifest.permission.READ_FRAME_BUFFER;
+import static android.Manifest.permission.REMOVE_TASKS;
+import static android.Manifest.permission.START_TASKS_FROM_RECENTS;
+import static android.Manifest.permission.STOP_APP_SWITCHES;
+import static android.app.ActivityManager.LOCK_TASK_MODE_NONE;
+import static android.app.ActivityManager.PROCESS_STATE_NONEXISTENT;
+import static android.app.ActivityManagerInternal.ALLOW_FULL_ONLY;
+import static android.app.ActivityTaskManager.INVALID_TASK_ID;
+import static android.app.ActivityTaskManager.RESIZE_MODE_PRESERVE_WINDOW;
+import static android.app.ActivityTaskManager.SPLIT_SCREEN_CREATE_MODE_TOP_OR_LEFT;
+import static android.app.WindowConfiguration.ACTIVITY_TYPE_UNDEFINED;
+import static android.app.WindowConfiguration.WINDOWING_MODE_FREEFORM;
+import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN;
+import static android.app.WindowConfiguration.WINDOWING_MODE_PINNED;
+import static android.app.WindowConfiguration.WINDOWING_MODE_SPLIT_SCREEN_PRIMARY;
+import static android.app.WindowConfiguration.WINDOWING_MODE_SPLIT_SCREEN_SECONDARY;
+import static android.app.WindowConfiguration.WINDOWING_MODE_UNDEFINED;
+import static android.content.Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS;
+import static android.content.Intent.FLAG_ACTIVITY_NEW_TASK;
+import static android.content.Intent.FLAG_ACTIVITY_TASK_ON_HOME;
+import static android.content.pm.ApplicationInfo.FLAG_FACTORY_TEST;
+import static android.content.pm.ConfigurationInfo.GL_ES_VERSION_UNDEFINED;
+import static android.content.pm.PackageManager.FEATURE_ACTIVITIES_ON_SECONDARY_DISPLAYS;
+import static android.content.pm.PackageManager.FEATURE_FREEFORM_WINDOW_MANAGEMENT;
+import static android.content.pm.PackageManager.FEATURE_PC;
+import static android.content.pm.PackageManager.FEATURE_PICTURE_IN_PICTURE;
+import static android.content.pm.PackageManager.PERMISSION_GRANTED;
+import static android.content.res.Configuration.UI_MODE_TYPE_TELEVISION;
+import static android.os.Build.VERSION_CODES.N;
+import static android.os.FactoryTest.FACTORY_TEST_HIGH_LEVEL;
+import static android.os.FactoryTest.FACTORY_TEST_LOW_LEVEL;
+import static android.os.FactoryTest.FACTORY_TEST_OFF;
+import static android.os.Process.FIRST_APPLICATION_UID;
+import static android.os.Process.SYSTEM_UID;
+import static android.os.Trace.TRACE_TAG_ACTIVITY_MANAGER;
+import static android.provider.Settings.Global.ALWAYS_FINISH_ACTIVITIES;
+import static android.provider.Settings.Global.DEVELOPMENT_ENABLE_FREEFORM_WINDOWS_SUPPORT;
+import static android.provider.Settings.Global.DEVELOPMENT_FORCE_RESIZABLE_ACTIVITIES;
+import static android.provider.Settings.Global.DEVELOPMENT_FORCE_RTL;
+import static android.provider.Settings.Global.HIDE_ERROR_DIALOGS;
+import static android.provider.Settings.System.FONT_SCALE;
+import static android.service.voice.VoiceInteractionSession.SHOW_SOURCE_APPLICATION;
+import static android.view.Display.DEFAULT_DISPLAY;
+import static android.view.Display.INVALID_DISPLAY;
+import static android.view.WindowManager.TRANSIT_NONE;
+import static android.view.WindowManager.TRANSIT_TASK_IN_PLACE;
+
+import static com.android.server.am.ActivityManagerService.ANR_TRACE_DIR;
+import static com.android.server.am.ActivityManagerService.MY_PID;
+import static com.android.server.am.ActivityManagerService.STOCK_PM_FLAGS;
+import static com.android.server.am.ActivityManagerService.dumpStackTraces;
+import static com.android.server.am.ActivityManagerServiceDumpProcessesProto.CONFIG_WILL_CHANGE;
+import static com.android.server.am.ActivityManagerServiceDumpProcessesProto.CONTROLLER;
+import static com.android.server.am.ActivityManagerServiceDumpProcessesProto.CURRENT_TRACKER;
+import static com.android.server.am.ActivityManagerServiceDumpProcessesProto.Controller.IS_A_MONKEY;
+import static com.android.server.am.ActivityManagerServiceDumpProcessesProto.GLOBAL_CONFIGURATION;
+import static com.android.server.am.ActivityManagerServiceDumpProcessesProto.GOING_TO_SLEEP;
+import static com.android.server.am.ActivityManagerServiceDumpProcessesProto.HEAVY_WEIGHT_PROC;
+import static com.android.server.am.ActivityManagerServiceDumpProcessesProto.HOME_PROC;
+import static com.android.server.am.ActivityManagerServiceDumpProcessesProto.LAUNCHING_ACTIVITY;
+import static com.android.server.am.ActivityManagerServiceDumpProcessesProto.PREVIOUS_PROC;
+import static com.android.server.am.ActivityManagerServiceDumpProcessesProto
+ .PREVIOUS_PROC_VISIBLE_TIME_MS;
+import static com.android.server.am.ActivityManagerServiceDumpProcessesProto.SCREEN_COMPAT_PACKAGES;
+import static com.android.server.am.ActivityManagerServiceDumpProcessesProto.ScreenCompatPackage
+ .MODE;
+import static com.android.server.am.ActivityManagerServiceDumpProcessesProto.ScreenCompatPackage
+ .PACKAGE;
+import static com.android.server.wm.ActivityStack.REMOVE_TASK_MODE_DESTROYING;
+import static com.android.server.wm.ActivityStackSupervisor.DEFER_RESUME;
+import static com.android.server.wm.ActivityStackSupervisor.MATCH_TASK_IN_STACKS_ONLY;
+import static com.android.server.wm.ActivityStackSupervisor.MATCH_TASK_IN_STACKS_OR_RECENT_TASKS;
+import static com.android.server.wm.ActivityStackSupervisor.ON_TOP;
+import static com.android.server.wm.ActivityStackSupervisor.PRESERVE_WINDOWS;
+import static com.android.server.wm.ActivityStackSupervisor.REMOVE_FROM_RECENTS;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_ALL;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_CONFIGURATION;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_FOCUS;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_IMMERSIVE;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_LOCKTASK;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_STACK;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_SWITCH;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_TASKS;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_VISIBILITY;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_CONFIGURATION;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_FOCUS;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_IMMERSIVE;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_LOCKTASK;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_STACK;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_SWITCH;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_VISIBILITY;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_ATM;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_WITH_CLASS_NAME;
+import static com.android.server.wm.ActivityTaskManagerService.H.REPORT_TIME_TRACKER_MSG;
+import static com.android.server.wm.ActivityTaskManagerService.UiHandler.DISMISS_DIALOG_UI_MSG;
+import static com.android.server.wm.TaskRecord.LOCK_TASK_AUTH_DONT_LOCK;
+import static com.android.server.wm.TaskRecord.REPARENT_KEEP_STACK_AT_FRONT;
+import static com.android.server.wm.TaskRecord.REPARENT_LEAVE_STACK_IN_PLACE;
+import static com.android.server.wm.ActivityTaskManagerInternal.ASSIST_KEY_CONTENT;
+import static com.android.server.wm.ActivityTaskManagerInternal.ASSIST_KEY_DATA;
+import static com.android.server.wm.ActivityTaskManagerInternal.ASSIST_KEY_RECEIVER_EXTRAS;
+import static com.android.server.wm.ActivityTaskManagerInternal.ASSIST_KEY_STRUCTURE;
+import static com.android.server.wm.RecentsAnimationController.REORDER_KEEP_IN_PLACE;
+import static com.android.server.wm.RecentsAnimationController.REORDER_MOVE_TO_ORIGINAL_POSITION;
+
+import android.Manifest;
+import android.annotation.NonNull;
+import android.annotation.Nullable;
+import android.annotation.UserIdInt;
+import android.app.Activity;
+import android.app.ActivityManager;
+import android.app.ActivityManagerInternal;
+import android.app.ActivityOptions;
+import android.app.ActivityTaskManager;
+import android.app.ActivityThread;
+import android.app.AlertDialog;
+import android.app.AppGlobals;
+import android.app.Dialog;
+import android.app.IActivityController;
+import android.app.IActivityTaskManager;
+import android.app.IApplicationThread;
+import android.app.IAssistDataReceiver;
+import android.app.INotificationManager;
+import android.app.ITaskStackListener;
+import android.app.Notification;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.app.PictureInPictureParams;
+import android.app.ProfilerInfo;
+import android.app.RemoteAction;
+import android.app.WaitResult;
+import android.app.WindowConfiguration;
+import android.app.admin.DevicePolicyCache;
+import android.app.assist.AssistContent;
+import android.app.assist.AssistStructure;
+import android.app.usage.UsageStatsManagerInternal;
+import android.content.ActivityNotFoundException;
+import android.content.ComponentName;
+import android.content.ContentResolver;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.IIntentSender;
+import android.content.Intent;
+import android.content.pm.ActivityInfo;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.ConfigurationInfo;
+import android.content.pm.IPackageManager;
+import android.content.pm.PackageManager;
+import android.content.pm.PackageManagerInternal;
+import android.content.pm.ParceledListSlice;
+import android.content.pm.ResolveInfo;
+import android.content.res.CompatibilityInfo;
+import android.content.res.Configuration;
+import android.content.res.Resources;
+import android.database.ContentObserver;
+import android.graphics.Bitmap;
+import android.graphics.Point;
+import android.graphics.Rect;
+import android.metrics.LogMaker;
+import android.net.Uri;
+import android.os.Binder;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.FactoryTest;
+import android.os.FileUtils;
+import android.os.Handler;
+import android.os.IBinder;
+import android.os.IUserManager;
+import android.os.LocaleList;
+import android.os.Looper;
+import android.os.Message;
+import android.os.PersistableBundle;
+import android.os.PowerManager;
+import android.os.PowerManagerInternal;
+import android.os.RemoteException;
+import android.os.ServiceManager;
+import android.os.StrictMode;
+import android.os.SystemClock;
+import android.os.SystemProperties;
+import android.os.Trace;
+import android.os.UpdateLock;
+import android.os.UserHandle;
+import android.os.UserManager;
+import android.os.WorkSource;
+import android.os.storage.IStorageManager;
+import android.os.storage.StorageManager;
+import android.provider.Settings;
+import android.service.voice.IVoiceInteractionSession;
+import android.service.voice.VoiceInteractionManagerInternal;
+import android.telecom.TelecomManager;
+import android.text.TextUtils;
+import android.text.format.Time;
+import android.util.ArrayMap;
+import android.util.EventLog;
+import android.util.Log;
+import android.util.Slog;
+import android.util.SparseArray;
+import android.util.SparseIntArray;
+import android.util.StatsLog;
+import android.util.TimeUtils;
+import android.util.proto.ProtoOutputStream;
+import android.view.IRecentsAnimationRunner;
+import android.view.RemoteAnimationAdapter;
+import android.view.RemoteAnimationDefinition;
+import android.view.WindowManager;
+
+import com.android.internal.R;
+import com.android.internal.annotations.VisibleForTesting;
+import com.android.internal.app.AssistUtils;
+import com.android.internal.app.IAppOpsService;
+import com.android.internal.app.IVoiceInteractor;
+import com.android.internal.app.ProcessMap;
+import com.android.internal.logging.MetricsLogger;
+import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
+import com.android.internal.messages.nano.SystemMessageProto.SystemMessage;
+import com.android.internal.notification.SystemNotificationChannels;
+import com.android.internal.os.TransferPipe;
+import com.android.internal.os.logging.MetricsLoggerWrapper;
+import com.android.internal.policy.IKeyguardDismissCallback;
+import com.android.internal.policy.KeyguardDismissCallback;
+import com.android.internal.util.ArrayUtils;
+import com.android.internal.util.FastPrintWriter;
+import com.android.internal.util.Preconditions;
+import com.android.internal.util.function.pooled.PooledLambda;
+import com.android.server.AppOpsService;
+import com.android.server.AttributeCache;
+import com.android.server.LocalServices;
+import com.android.server.SystemService;
+import com.android.server.SystemServiceManager;
+import com.android.server.Watchdog;
+import com.android.server.am.ActivityManagerService;
+import com.android.server.am.ActivityManagerServiceDumpActivitiesProto;
+import com.android.server.am.ActivityManagerServiceDumpProcessesProto;
+import com.android.server.am.AppTimeTracker;
+import com.android.server.am.BaseErrorDialog;
+import com.android.server.am.EventLogTags;
+import com.android.server.am.PendingIntentController;
+import com.android.server.am.PendingIntentRecord;
+import com.android.server.am.UserState;
+import com.android.server.firewall.IntentFirewall;
+import com.android.server.pm.UserManagerService;
+import com.android.server.uri.UriGrantsManagerInternal;
+import com.android.server.vr.VrManagerInternal;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileDescriptor;
+import java.io.FileOutputStream;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.lang.ref.WeakReference;
+import java.text.DateFormat;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * System service for managing activities and their containers (task, stacks, displays,... ).
+ *
+ * {@hide}
+ */
+public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
+ private static final String TAG = TAG_WITH_CLASS_NAME ? "ActivityTaskManagerService" : TAG_ATM;
+ private static final String TAG_STACK = TAG + POSTFIX_STACK;
+ private static final String TAG_SWITCH = TAG + POSTFIX_SWITCH;
+ private static final String TAG_IMMERSIVE = TAG + POSTFIX_IMMERSIVE;
+ private static final String TAG_FOCUS = TAG + POSTFIX_FOCUS;
+ private static final String TAG_VISIBILITY = TAG + POSTFIX_VISIBILITY;
+ private static final String TAG_LOCKTASK = TAG + POSTFIX_LOCKTASK;
+ private static final String TAG_CONFIGURATION = TAG + POSTFIX_CONFIGURATION;
+
+ // How long we wait until we timeout on key dispatching.
+ public static final int KEY_DISPATCHING_TIMEOUT_MS = 5 * 1000;
+ // How long we wait until we timeout on key dispatching during instrumentation.
+ static final int INSTRUMENTATION_KEY_DISPATCHING_TIMEOUT_MS = 60 * 1000;
+
+ /** Used to indicate that an app transition should be animated. */
+ static final boolean ANIMATE = true;
+
+ /** Hardware-reported OpenGLES version. */
+ final int GL_ES_VERSION;
+
+ public static final String DUMP_ACTIVITIES_CMD = "activities" ;
+ public static final String DUMP_ACTIVITIES_SHORT_CMD = "a" ;
+ public static final String DUMP_LASTANR_CMD = "lastanr" ;
+ public static final String DUMP_LASTANR_TRACES_CMD = "lastanr-traces" ;
+ public static final String DUMP_STARTER_CMD = "starter" ;
+ public static final String DUMP_CONTAINERS_CMD = "containers" ;
+ public static final String DUMP_RECENTS_CMD = "recents" ;
+ public static final String DUMP_RECENTS_SHORT_CMD = "r" ;
+
+ /** This activity is not being relaunched, or being relaunched for a non-resize reason. */
+ public static final int RELAUNCH_REASON_NONE = 0;
+ /** This activity is being relaunched due to windowing mode change. */
+ public static final int RELAUNCH_REASON_WINDOWING_MODE_RESIZE = 1;
+ /** This activity is being relaunched due to a free-resize operation. */
+ public static final int RELAUNCH_REASON_FREE_RESIZE = 2;
+
+ Context mContext;
+
+ /**
+ * This Context is themable and meant for UI display (AlertDialogs, etc.). The theme can
+ * change at runtime. Use mContext for non-UI purposes.
+ */
+ final Context mUiContext;
+ final ActivityThread mSystemThread;
+ H mH;
+ UiHandler mUiHandler;
+ ActivityManagerInternal mAmInternal;
+ UriGrantsManagerInternal mUgmInternal;
+ private PackageManagerInternal mPmInternal;
+ private ActivityTaskManagerInternal mInternal;
+ PowerManagerInternal mPowerManagerInternal;
+ private UsageStatsManagerInternal mUsageStatsInternal;
+
+ PendingIntentController mPendingIntentController;
+ IntentFirewall mIntentFirewall;
+
+ /* Global service lock used by the package the owns this service. */
+ Object mGlobalLock;
+ ActivityStackSupervisor mStackSupervisor;
+ WindowManagerService mWindowManager;
+ private UserManagerService mUserManager;
+ private AppOpsService mAppOpsService;
+ /** All active uids in the system. */
+ private final SparseArray<Integer> mActiveUids = new SparseArray<>();
+ private final SparseArray<String> mPendingTempWhitelist = new SparseArray<>();
+ /** All processes currently running that might have a window organized by name. */
+ final ProcessMap<WindowProcessController> mProcessNames = new ProcessMap<>();
+ /** All processes we currently have running mapped by pid */
+ final SparseArray<WindowProcessController> mPidMap = new SparseArray<>();
+ /** This is the process holding what we currently consider to be the "home" activity. */
+ WindowProcessController mHomeProcess;
+ /** The currently running heavy-weight process, if any. */
+ WindowProcessController mHeavyWeightProcess = null;
+ boolean mHasHeavyWeightFeature;
+ /**
+ * This is the process holding the activity the user last visited that is in a different process
+ * from the one they are currently in.
+ */
+ WindowProcessController mPreviousProcess;
+ /** The time at which the previous process was last visible. */
+ long mPreviousProcessVisibleTime;
+
+ /** List of intents that were used to start the most recent tasks. */
+ private RecentTasks mRecentTasks;
+ /** State of external calls telling us if the device is awake or asleep. */
+ private boolean mKeyguardShown = false;
+
+ // Wrapper around VoiceInteractionServiceManager
+ private AssistUtils mAssistUtils;
+
+ // VoiceInteraction session ID that changes for each new request except when
+ // being called for multi-window assist in a single session.
+ private int mViSessionId = 1000;
+
+ // How long to wait in getAssistContextExtras for the activity and foreground services
+ // to respond with the result.
+ private static final int PENDING_ASSIST_EXTRAS_TIMEOUT = 500;
+
+ // How long top wait when going through the modern assist (which doesn't need to block
+ // on getting this result before starting to launch its UI).
+ private static final int PENDING_ASSIST_EXTRAS_LONG_TIMEOUT = 2000;
+
+ // How long to wait in getAutofillAssistStructure() for the activity to respond with the result.
+ private static final int PENDING_AUTOFILL_ASSIST_STRUCTURE_TIMEOUT = 2000;
+
+ private final ArrayList<PendingAssistExtras> mPendingAssistExtras = new ArrayList<>();
+
+ // Keeps track of the active voice interaction service component, notified from
+ // VoiceInteractionManagerService
+ ComponentName mActiveVoiceInteractionServiceComponent;
+
+ VrController mVrController;
+ KeyguardController mKeyguardController;
+ private final ClientLifecycleManager mLifecycleManager;
+ private TaskChangeNotificationController mTaskChangeNotificationController;
+ /** The controller for all operations related to locktask. */
+ private LockTaskController mLockTaskController;
+ private ActivityStartController mActivityStartController;
+
+ boolean mSuppressResizeConfigChanges;
+
+ private final UpdateConfigurationResult mTmpUpdateConfigurationResult =
+ new UpdateConfigurationResult();
+
+ static final class UpdateConfigurationResult {
+ // Configuration changes that were updated.
+ int changes;
+ // If the activity was relaunched to match the new configuration.
+ boolean activityRelaunched;
+
+ void reset() {
+ changes = 0;
+ activityRelaunched = false;
+ }
+ }
+
+ /** Current sequencing integer of the configuration, for skipping old configurations. */
+ private int mConfigurationSeq;
+ // To cache the list of supported system locales
+ private String[] mSupportedSystemLocales = null;
+
+ /**
+ * Temp object used when global and/or display override configuration is updated. It is also
+ * sent to outer world instead of {@link #getGlobalConfiguration} because we don't trust
+ * anyone...
+ */
+ private Configuration mTempConfig = new Configuration();
+
+ /** Temporary to avoid allocations. */
+ final StringBuilder mStringBuilder = new StringBuilder(256);
+
+ // Amount of time after a call to stopAppSwitches() during which we will
+ // prevent further untrusted switches from happening.
+ private static final long APP_SWITCH_DELAY_TIME = 5 * 1000;
+
+ /**
+ * The time at which we will allow normal application switches again,
+ * after a call to {@link #stopAppSwitches()}.
+ */
+ private long mAppSwitchesAllowedTime;
+ /**
+ * This is set to true after the first switch after mAppSwitchesAllowedTime
+ * is set; any switches after that will clear the time.
+ */
+ private boolean mDidAppSwitch;
+
+ IActivityController mController = null;
+ boolean mControllerIsAMonkey = false;
+
+ final int mFactoryTest;
+
+ /** Used to control how we initialize the service. */
+ ComponentName mTopComponent;
+ String mTopAction = Intent.ACTION_MAIN;
+ String mTopData;
+
+ /**
+ * Dump of the activity state at the time of the last ANR. Cleared after
+ * {@link WindowManagerService#LAST_ANR_LIFETIME_DURATION_MSECS}
+ */
+ String mLastANRState;
+
+ /**
+ * Used to retain an update lock when the foreground activity is in
+ * immersive mode.
+ */
+ private final UpdateLock mUpdateLock = new UpdateLock("immersive");
+
+ /**
+ * Packages that are being allowed to perform unrestricted app switches. Mapping is
+ * User -> Type -> uid.
+ */
+ final SparseArray<ArrayMap<String, Integer>> mAllowAppSwitchUids = new SparseArray<>();
+
+ /** The dimensions of the thumbnails in the Recents UI. */
+ private int mThumbnailWidth;
+ private int mThumbnailHeight;
+ private float mFullscreenThumbnailScale;
+
+ /**
+ * Flag that indicates if multi-window is enabled.
+ *
+ * For any particular form of multi-window to be enabled, generic multi-window must be enabled
+ * in {@link com.android.internal.R.bool#config_supportsMultiWindow} config or
+ * {@link Settings.Global#DEVELOPMENT_FORCE_RESIZABLE_ACTIVITIES} development option set.
+ * At least one of the forms of multi-window must be enabled in order for this flag to be
+ * initialized to 'true'.
+ *
+ * @see #mSupportsSplitScreenMultiWindow
+ * @see #mSupportsFreeformWindowManagement
+ * @see #mSupportsPictureInPicture
+ * @see #mSupportsMultiDisplay
+ */
+ boolean mSupportsMultiWindow;
+ boolean mSupportsSplitScreenMultiWindow;
+ boolean mSupportsFreeformWindowManagement;
+ boolean mSupportsPictureInPicture;
+ boolean mSupportsMultiDisplay;
+ boolean mForceResizableActivities;
+
+ final List<ActivityTaskManagerInternal.ScreenObserver> mScreenObservers = new ArrayList<>();
+
+ // VR Vr2d Display Id.
+ int mVr2dDisplayId = INVALID_DISPLAY;
+
+ /**
+ * Set while we are wanting to sleep, to prevent any
+ * activities from being started/resumed.
+ *
+ * TODO(b/33594039): Clarify the actual state transitions represented by mSleeping.
+ *
+ * Currently mSleeping is set to true when transitioning into the sleep state, and remains true
+ * while in the sleep state until there is a pending transition out of sleep, in which case
+ * mSleeping is set to false, and remains false while awake.
+ *
+ * Whether mSleeping can quickly toggled between true/false without the device actually
+ * display changing states is undefined.
+ */
+ private boolean mSleeping = false;
+
+ /**
+ * The process state used for processes that are running the top activities.
+ * This changes between TOP and TOP_SLEEPING to following mSleeping.
+ */
+ int mTopProcessState = ActivityManager.PROCESS_STATE_TOP;
+
+ // Whether we should show our dialogs (ANR, crash, etc) or just perform their default action
+ // automatically. Important for devices without direct input devices.
+ private boolean mShowDialogs = true;
+
+ /** Set if we are shutting down the system, similar to sleeping. */
+ boolean mShuttingDown = false;
+
+ /**
+ * We want to hold a wake lock while running a voice interaction session, since
+ * this may happen with the screen off and we need to keep the CPU running to
+ * be able to continue to interact with the user.
+ */
+ PowerManager.WakeLock mVoiceWakeLock;
+
+ /**
+ * Set while we are running a voice interaction. This overrides sleeping while it is active.
+ */
+ IVoiceInteractionSession mRunningVoice;
+
+ /**
+ * The last resumed activity. This is identical to the current resumed activity most
+ * of the time but could be different when we're pausing one activity before we resume
+ * another activity.
+ */
+ ActivityRecord mLastResumedActivity;
+
+ /**
+ * The activity that is currently being traced as the active resumed activity.
+ *
+ * @see #updateResumedAppTrace
+ */
+ private @Nullable ActivityRecord mTracedResumedActivity;
+
+ /** If non-null, we are tracking the time the user spends in the currently focused app. */
+ AppTimeTracker mCurAppTimeTracker;
+
+ private AppWarnings mAppWarnings;
+
+ /**
+ * Packages that the user has asked to have run in screen size
+ * compatibility mode instead of filling the screen.
+ */
+ CompatModePackages mCompatModePackages;
+
+ private FontScaleSettingObserver mFontScaleSettingObserver;
+
+ private final class FontScaleSettingObserver extends ContentObserver {
+ private final Uri mFontScaleUri = Settings.System.getUriFor(FONT_SCALE);
+ private final Uri mHideErrorDialogsUri = Settings.Global.getUriFor(HIDE_ERROR_DIALOGS);
+
+ public FontScaleSettingObserver() {
+ super(mH);
+ final ContentResolver resolver = mContext.getContentResolver();
+ resolver.registerContentObserver(mFontScaleUri, false, this, UserHandle.USER_ALL);
+ resolver.registerContentObserver(mHideErrorDialogsUri, false, this,
+ UserHandle.USER_ALL);
+ }
+
+ @Override
+ public void onChange(boolean selfChange, Uri uri, @UserIdInt int userId) {
+ if (mFontScaleUri.equals(uri)) {
+ updateFontScaleIfNeeded(userId);
+ } else if (mHideErrorDialogsUri.equals(uri)) {
+ synchronized (mGlobalLock) {
+ updateShouldShowDialogsLocked(getGlobalConfiguration());
+ }
+ }
+ }
+ }
+
+ ActivityTaskManagerService(Context context) {
+ mContext = context;
+ mFactoryTest = FactoryTest.getMode();
+ mSystemThread = ActivityThread.currentActivityThread();
+ mUiContext = mSystemThread.getSystemUiContext();
+ mLifecycleManager = new ClientLifecycleManager();
+ GL_ES_VERSION = SystemProperties.getInt("ro.opengles.version", GL_ES_VERSION_UNDEFINED);
+ }
+
+ public void onSystemReady() {
+ synchronized (mGlobalLock) {
+ mHasHeavyWeightFeature = mContext.getPackageManager().hasSystemFeature(
+ PackageManager.FEATURE_CANT_SAVE_STATE);
+ mAssistUtils = new AssistUtils(mContext);
+ mVrController.onSystemReady();
+ mRecentTasks.onSystemReadyLocked();
+ }
+ }
+
+ public void onInitPowerManagement() {
+ synchronized (mGlobalLock) {
+ mStackSupervisor.initPowerManagement();
+ final PowerManager pm = (PowerManager) mContext.getSystemService(Context.POWER_SERVICE);
+ mPowerManagerInternal = LocalServices.getService(PowerManagerInternal.class);
+ mVoiceWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "*voice*");
+ mVoiceWakeLock.setReferenceCounted(false);
+ }
+ }
+
+ public void installSystemProviders() {
+ mFontScaleSettingObserver = new FontScaleSettingObserver();
+ }
+
+ public void retrieveSettings(ContentResolver resolver) {
+ final boolean freeformWindowManagement =
+ mContext.getPackageManager().hasSystemFeature(FEATURE_FREEFORM_WINDOW_MANAGEMENT)
+ || Settings.Global.getInt(
+ resolver, DEVELOPMENT_ENABLE_FREEFORM_WINDOWS_SUPPORT, 0) != 0;
+
+ final boolean supportsMultiWindow = ActivityTaskManager.supportsMultiWindow(mContext);
+ final boolean supportsPictureInPicture = supportsMultiWindow &&
+ mContext.getPackageManager().hasSystemFeature(FEATURE_PICTURE_IN_PICTURE);
+ final boolean supportsSplitScreenMultiWindow =
+ ActivityTaskManager.supportsSplitScreenMultiWindow(mContext);
+ final boolean supportsMultiDisplay = mContext.getPackageManager()
+ .hasSystemFeature(FEATURE_ACTIVITIES_ON_SECONDARY_DISPLAYS);
+ final boolean alwaysFinishActivities =
+ Settings.Global.getInt(resolver, ALWAYS_FINISH_ACTIVITIES, 0) != 0;
+ final boolean forceRtl = Settings.Global.getInt(resolver, DEVELOPMENT_FORCE_RTL, 0) != 0;
+ final boolean forceResizable = Settings.Global.getInt(
+ resolver, DEVELOPMENT_FORCE_RESIZABLE_ACTIVITIES, 0) != 0;
+ final boolean isPc = mContext.getPackageManager().hasSystemFeature(FEATURE_PC);
+
+ // Transfer any global setting for forcing RTL layout, into a System Property
+ SystemProperties.set(DEVELOPMENT_FORCE_RTL, forceRtl ? "1":"0");
+
+ final Configuration configuration = new Configuration();
+ Settings.System.getConfiguration(resolver, configuration);
+ if (forceRtl) {
+ // This will take care of setting the correct layout direction flags
+ configuration.setLayoutDirection(configuration.locale);
+ }
+
+ synchronized (mGlobalLock) {
+ mForceResizableActivities = forceResizable;
+ final boolean multiWindowFormEnabled = freeformWindowManagement
+ || supportsSplitScreenMultiWindow
+ || supportsPictureInPicture
+ || supportsMultiDisplay;
+ if ((supportsMultiWindow || forceResizable) && multiWindowFormEnabled) {
+ mSupportsMultiWindow = true;
+ mSupportsFreeformWindowManagement = freeformWindowManagement;
+ mSupportsSplitScreenMultiWindow = supportsSplitScreenMultiWindow;
+ mSupportsPictureInPicture = supportsPictureInPicture;
+ mSupportsMultiDisplay = supportsMultiDisplay;
+ } else {
+ mSupportsMultiWindow = false;
+ mSupportsFreeformWindowManagement = false;
+ mSupportsSplitScreenMultiWindow = false;
+ mSupportsPictureInPicture = false;
+ mSupportsMultiDisplay = false;
+ }
+ mWindowManager.setForceResizableTasks(mForceResizableActivities);
+ mWindowManager.setSupportsPictureInPicture(mSupportsPictureInPicture);
+ mWindowManager.setSupportsFreeformWindowManagement(mSupportsFreeformWindowManagement);
+ mWindowManager.setIsPc(isPc);
+ // This happens before any activities are started, so we can change global configuration
+ // in-place.
+ updateConfigurationLocked(configuration, null, true);
+ final Configuration globalConfig = getGlobalConfiguration();
+ if (DEBUG_CONFIGURATION) Slog.v(TAG_CONFIGURATION, "Initial config: " + globalConfig);
+
+ // Load resources only after the current configuration has been set.
+ final Resources res = mContext.getResources();
+ mThumbnailWidth = res.getDimensionPixelSize(
+ com.android.internal.R.dimen.thumbnail_width);
+ mThumbnailHeight = res.getDimensionPixelSize(
+ com.android.internal.R.dimen.thumbnail_height);
+
+ if ((globalConfig.uiMode & UI_MODE_TYPE_TELEVISION) == UI_MODE_TYPE_TELEVISION) {
+ mFullscreenThumbnailScale = (float) res
+ .getInteger(com.android.internal.R.integer.thumbnail_width_tv) /
+ (float) globalConfig.screenWidthDp;
+ } else {
+ mFullscreenThumbnailScale = res.getFraction(
+ com.android.internal.R.fraction.thumbnail_fullscreen_scale, 1, 1);
+ }
+ }
+ }
+
+ // TODO: Will be converted to WM lock once transition is complete.
+ public void setActivityManagerService(Object globalLock, Looper looper,
+ IntentFirewall intentFirewall, PendingIntentController intentController) {
+ mGlobalLock = globalLock;
+ mH = new H(looper);
+ mUiHandler = new UiHandler();
+ mIntentFirewall = intentFirewall;
+ final File systemDir = SystemServiceManager.ensureSystemDir();
+ mAppWarnings = new AppWarnings(this, mUiContext, mH, mUiHandler, systemDir);
+ mCompatModePackages = new CompatModePackages(this, systemDir, mH);
+ mPendingIntentController = intentController;
+
+ mTempConfig.setToDefaults();
+ mTempConfig.setLocales(LocaleList.getDefault());
+ mConfigurationSeq = mTempConfig.seq = 1;
+ mStackSupervisor = createStackSupervisor();
+ mStackSupervisor.onConfigurationChanged(mTempConfig);
+
+ mTaskChangeNotificationController =
+ new TaskChangeNotificationController(mGlobalLock, mStackSupervisor, mH);
+ mLockTaskController = new LockTaskController(mContext, mStackSupervisor, mH);
+ mActivityStartController = new ActivityStartController(this);
+ mRecentTasks = createRecentTasks();
+ mStackSupervisor.setRecentTasks(mRecentTasks);
+ mVrController = new VrController(mGlobalLock);
+ mKeyguardController = mStackSupervisor.getKeyguardController();
+ }
+
+ public void onActivityManagerInternalAdded() {
+ synchronized (mGlobalLock) {
+ mAmInternal = LocalServices.getService(ActivityManagerInternal.class);
+ mUgmInternal = LocalServices.getService(UriGrantsManagerInternal.class);
+ }
+ }
+
+ int increaseConfigurationSeqLocked() {
+ mConfigurationSeq = Math.max(++mConfigurationSeq, 1);
+ return mConfigurationSeq;
+ }
+
+ protected ActivityStackSupervisor createStackSupervisor() {
+ final ActivityStackSupervisor supervisor = new ActivityStackSupervisor(this, mH.getLooper());
+ supervisor.initialize();
+ return supervisor;
+ }
+
+ public void setWindowManager(WindowManagerService wm) {
+ synchronized (mGlobalLock) {
+ mWindowManager = wm;
+ mLockTaskController.setWindowManager(wm);
+ mStackSupervisor.setWindowManager(wm);
+ }
+ }
+
+ public void setUsageStatsManager(UsageStatsManagerInternal usageStatsManager) {
+ synchronized (mGlobalLock) {
+ mUsageStatsInternal = usageStatsManager;
+ }
+ }
+
+ UserManagerService getUserManager() {
+ if (mUserManager == null) {
+ IBinder b = ServiceManager.getService(Context.USER_SERVICE);
+ mUserManager = (UserManagerService) IUserManager.Stub.asInterface(b);
+ }
+ return mUserManager;
+ }
+
+ AppOpsService getAppOpsService() {
+ if (mAppOpsService == null) {
+ IBinder b = ServiceManager.getService(Context.APP_OPS_SERVICE);
+ mAppOpsService = (AppOpsService) IAppOpsService.Stub.asInterface(b);
+ }
+ return mAppOpsService;
+ }
+
+ boolean hasUserRestriction(String restriction, int userId) {
+ return getUserManager().hasUserRestriction(restriction, userId);
+ }
+
+ protected RecentTasks createRecentTasks() {
+ return new RecentTasks(this, mStackSupervisor);
+ }
+
+ RecentTasks getRecentTasks() {
+ return mRecentTasks;
+ }
+
+ ClientLifecycleManager getLifecycleManager() {
+ return mLifecycleManager;
+ }
+
+ ActivityStartController getActivityStartController() {
+ return mActivityStartController;
+ }
+
+ TaskChangeNotificationController getTaskChangeNotificationController() {
+ return mTaskChangeNotificationController;
+ }
+
+ LockTaskController getLockTaskController() {
+ return mLockTaskController;
+ }
+
+ /**
+ * Return the global configuration used by the process corresponding to the input pid. This is
+ * usually the global configuration with some overrides specific to that process.
+ */
+ Configuration getGlobalConfigurationForCallingPid() {
+ final int pid = Binder.getCallingPid();
+ if (pid == MY_PID || pid < 0) {
+ return getGlobalConfiguration();
+ }
+ synchronized (mGlobalLock) {
+ final WindowProcessController app = mPidMap.get(pid);
+ return app != null ? app.getConfiguration() : getGlobalConfiguration();
+ }
+ }
+
+ /**
+ * Return the device configuration info used by the process corresponding to the input pid.
+ * The value is consistent with the global configuration for the process.
+ */
+ @Override
+ public ConfigurationInfo getDeviceConfigurationInfo() {
+ ConfigurationInfo config = new ConfigurationInfo();
+ synchronized (mGlobalLock) {
+ final Configuration globalConfig = getGlobalConfigurationForCallingPid();
+ config.reqTouchScreen = globalConfig.touchscreen;
+ config.reqKeyboardType = globalConfig.keyboard;
+ config.reqNavigation = globalConfig.navigation;
+ if (globalConfig.navigation == Configuration.NAVIGATION_DPAD
+ || globalConfig.navigation == Configuration.NAVIGATION_TRACKBALL) {
+ config.reqInputFeatures |= ConfigurationInfo.INPUT_FEATURE_FIVE_WAY_NAV;
+ }
+ if (globalConfig.keyboard != Configuration.KEYBOARD_UNDEFINED
+ && globalConfig.keyboard != Configuration.KEYBOARD_NOKEYS) {
+ config.reqInputFeatures |= ConfigurationInfo.INPUT_FEATURE_HARD_KEYBOARD;
+ }
+ config.reqGlEsVersion = GL_ES_VERSION;
+ }
+ return config;
+ }
+
+ private void start() {
+ mInternal = new LocalService();
+ LocalServices.addService(ActivityTaskManagerInternal.class, mInternal);
+ }
+
+ public static final class Lifecycle extends SystemService {
+ private final ActivityTaskManagerService mService;
+
+ public Lifecycle(Context context) {
+ super(context);
+ mService = new ActivityTaskManagerService(context);
+ }
+
+ @Override
+ public void onStart() {
+ publishBinderService(Context.ACTIVITY_TASK_SERVICE, mService);
+ mService.start();
+ }
+
+ public ActivityTaskManagerService getService() {
+ return mService;
+ }
+ }
+
+ @Override
+ public final int startActivity(IApplicationThread caller, String callingPackage,
+ Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
+ int startFlags, ProfilerInfo profilerInfo, Bundle bOptions) {
+ return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
+ resultWho, requestCode, startFlags, profilerInfo, bOptions,
+ UserHandle.getCallingUserId());
+ }
+
+ @Override
+ public final int startActivities(IApplicationThread caller, String callingPackage,
+ Intent[] intents, String[] resolvedTypes, IBinder resultTo, Bundle bOptions,
+ int userId) {
+ final String reason = "startActivities";
+ enforceNotIsolatedCaller(reason);
+ userId = handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(), userId, reason);
+ // TODO: Switch to user app stacks here.
+ return getActivityStartController().startActivities(caller, -1, callingPackage, intents,
+ resolvedTypes, resultTo, SafeActivityOptions.fromBundle(bOptions), userId, reason,
+ null /* originatingPendingIntent */);
+ }
+
+ @Override
+ public int startActivityAsUser(IApplicationThread caller, String callingPackage,
+ Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
+ int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId) {
+ return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
+ resultWho, requestCode, startFlags, profilerInfo, bOptions, userId,
+ true /*validateIncomingUser*/);
+ }
+
+ int startActivityAsUser(IApplicationThread caller, String callingPackage,
+ Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
+ int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId,
+ boolean validateIncomingUser) {
+ enforceNotIsolatedCaller("startActivityAsUser");
+
+ userId = getActivityStartController().checkTargetUser(userId, validateIncomingUser,
+ Binder.getCallingPid(), Binder.getCallingUid(), "startActivityAsUser");
+
+ // TODO: Switch to user app stacks here.
+ return getActivityStartController().obtainStarter(intent, "startActivityAsUser")
+ .setCaller(caller)
+ .setCallingPackage(callingPackage)
+ .setResolvedType(resolvedType)
+ .setResultTo(resultTo)
+ .setResultWho(resultWho)
+ .setRequestCode(requestCode)
+ .setStartFlags(startFlags)
+ .setProfilerInfo(profilerInfo)
+ .setActivityOptions(bOptions)
+ .setMayWait(userId)
+ .execute();
+
+ }
+
+ @Override
+ public int startActivityIntentSender(IApplicationThread caller, IIntentSender target,
+ IBinder whitelistToken, Intent fillInIntent, String resolvedType, IBinder resultTo,
+ String resultWho, int requestCode, int flagsMask, int flagsValues, Bundle bOptions) {
+ enforceNotIsolatedCaller("startActivityIntentSender");
+ // Refuse possible leaked file descriptors
+ if (fillInIntent != null && fillInIntent.hasFileDescriptors()) {
+ throw new IllegalArgumentException("File descriptors passed in Intent");
+ }
+
+ if (!(target instanceof PendingIntentRecord)) {
+ throw new IllegalArgumentException("Bad PendingIntent object");
+ }
+
+ PendingIntentRecord pir = (PendingIntentRecord)target;
+
+ synchronized (mGlobalLock) {
+ // If this is coming from the currently resumed activity, it is
+ // effectively saying that app switches are allowed at this point.
+ final ActivityStack stack = getTopDisplayFocusedStack();
+ if (stack.mResumedActivity != null &&
+ stack.mResumedActivity.info.applicationInfo.uid == Binder.getCallingUid()) {
+ mAppSwitchesAllowedTime = 0;
+ }
+ }
+ return pir.sendInner(0, fillInIntent, resolvedType, whitelistToken, null, null,
+ resultTo, resultWho, requestCode, flagsMask, flagsValues, bOptions);
+ }
+
+ @Override
+ public boolean startNextMatchingActivity(IBinder callingActivity, Intent intent,
+ Bundle bOptions) {
+ // Refuse possible leaked file descriptors
+ if (intent != null && intent.hasFileDescriptors()) {
+ throw new IllegalArgumentException("File descriptors passed in Intent");
+ }
+ SafeActivityOptions options = SafeActivityOptions.fromBundle(bOptions);
+
+ synchronized (mGlobalLock) {
+ final ActivityRecord r = ActivityRecord.isInStackLocked(callingActivity);
+ if (r == null) {
+ SafeActivityOptions.abort(options);
+ return false;
+ }
+ if (!r.attachedToProcess()) {
+ // The caller is not running... d'oh!
+ SafeActivityOptions.abort(options);
+ return false;
+ }
+ intent = new Intent(intent);
+ // The caller is not allowed to change the data.
+ intent.setDataAndType(r.intent.getData(), r.intent.getType());
+ // And we are resetting to find the next component...
+ intent.setComponent(null);
+
+ final boolean debug = ((intent.getFlags() & Intent.FLAG_DEBUG_LOG_RESOLUTION) != 0);
+
+ ActivityInfo aInfo = null;
+ try {
+ List<ResolveInfo> resolves =
+ AppGlobals.getPackageManager().queryIntentActivities(
+ intent, r.resolvedType,
+ PackageManager.MATCH_DEFAULT_ONLY | STOCK_PM_FLAGS,
+ UserHandle.getCallingUserId()).getList();
+
+ // Look for the original activity in the list...
+ final int N = resolves != null ? resolves.size() : 0;
+ for (int i=0; i<N; i++) {
+ ResolveInfo rInfo = resolves.get(i);
+ if (rInfo.activityInfo.packageName.equals(r.packageName)
+ && rInfo.activityInfo.name.equals(r.info.name)) {
+ // We found the current one... the next matching is
+ // after it.
+ i++;
+ if (i<N) {
+ aInfo = resolves.get(i).activityInfo;
+ }
+ if (debug) {
+ Slog.v(TAG, "Next matching activity: found current " + r.packageName
+ + "/" + r.info.name);
+ Slog.v(TAG, "Next matching activity: next is " + ((aInfo == null)
+ ? "null" : aInfo.packageName + "/" + aInfo.name));
+ }
+ break;
+ }
+ }
+ } catch (RemoteException e) {
+ }
+
+ if (aInfo == null) {
+ // Nobody who is next!
+ SafeActivityOptions.abort(options);
+ if (debug) Slog.d(TAG, "Next matching activity: nothing found");
+ return false;
+ }
+
+ intent.setComponent(new ComponentName(
+ aInfo.applicationInfo.packageName, aInfo.name));
+ intent.setFlags(intent.getFlags()&~(
+ Intent.FLAG_ACTIVITY_FORWARD_RESULT|
+ Intent.FLAG_ACTIVITY_CLEAR_TOP|
+ Intent.FLAG_ACTIVITY_MULTIPLE_TASK|
+ FLAG_ACTIVITY_NEW_TASK));
+
+ // Okay now we need to start the new activity, replacing the currently running activity.
+ // This is a little tricky because we want to start the new one as if the current one is
+ // finished, but not finish the current one first so that there is no flicker.
+ // And thus...
+ final boolean wasFinishing = r.finishing;
+ r.finishing = true;
+
+ // Propagate reply information over to the new activity.
+ final ActivityRecord resultTo = r.resultTo;
+ final String resultWho = r.resultWho;
+ final int requestCode = r.requestCode;
+ r.resultTo = null;
+ if (resultTo != null) {
+ resultTo.removeResultsLocked(r, resultWho, requestCode);
+ }
+
+ final long origId = Binder.clearCallingIdentity();
+ // TODO(b/64750076): Check if calling pid should really be -1.
+ final int res = getActivityStartController()
+ .obtainStarter(intent, "startNextMatchingActivity")
+ .setCaller(r.app.getThread())
+ .setResolvedType(r.resolvedType)
+ .setActivityInfo(aInfo)
+ .setResultTo(resultTo != null ? resultTo.appToken : null)
+ .setResultWho(resultWho)
+ .setRequestCode(requestCode)
+ .setCallingPid(-1)
+ .setCallingUid(r.launchedFromUid)
+ .setCallingPackage(r.launchedFromPackage)
+ .setRealCallingPid(-1)
+ .setRealCallingUid(r.launchedFromUid)
+ .setActivityOptions(options)
+ .execute();
+ Binder.restoreCallingIdentity(origId);
+
+ r.finishing = wasFinishing;
+ if (res != ActivityManager.START_SUCCESS) {
+ return false;
+ }
+ return true;
+ }
+ }
+
+ @Override
+ public final WaitResult startActivityAndWait(IApplicationThread caller, String callingPackage,
+ Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
+ int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId) {
+ final WaitResult res = new WaitResult();
+ synchronized (mGlobalLock) {
+ enforceNotIsolatedCaller("startActivityAndWait");
+ userId = handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(),
+ userId, "startActivityAndWait");
+ // TODO: Switch to user app stacks here.
+ getActivityStartController().obtainStarter(intent, "startActivityAndWait")
+ .setCaller(caller)
+ .setCallingPackage(callingPackage)
+ .setResolvedType(resolvedType)
+ .setResultTo(resultTo)
+ .setResultWho(resultWho)
+ .setRequestCode(requestCode)
+ .setStartFlags(startFlags)
+ .setActivityOptions(bOptions)
+ .setMayWait(userId)
+ .setProfilerInfo(profilerInfo)
+ .setWaitResult(res)
+ .execute();
+ }
+ return res;
+ }
+
+ @Override
+ public final int startActivityWithConfig(IApplicationThread caller, String callingPackage,
+ Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
+ int startFlags, Configuration config, Bundle bOptions, int userId) {
+ synchronized (mGlobalLock) {
+ enforceNotIsolatedCaller("startActivityWithConfig");
+ userId = handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(), userId,
+ "startActivityWithConfig");
+ // TODO: Switch to user app stacks here.
+ return getActivityStartController().obtainStarter(intent, "startActivityWithConfig")
+ .setCaller(caller)
+ .setCallingPackage(callingPackage)
+ .setResolvedType(resolvedType)
+ .setResultTo(resultTo)
+ .setResultWho(resultWho)
+ .setRequestCode(requestCode)
+ .setStartFlags(startFlags)
+ .setGlobalConfiguration(config)
+ .setActivityOptions(bOptions)
+ .setMayWait(userId)
+ .execute();
+ }
+ }
+
+ @Override
+ public final int startActivityAsCaller(IApplicationThread caller, String callingPackage,
+ Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
+ int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, boolean ignoreTargetSecurity,
+ int userId) {
+
+ // This is very dangerous -- it allows you to perform a start activity (including
+ // permission grants) as any app that may launch one of your own activities. So
+ // we will only allow this to be done from activities that are part of the core framework,
+ // and then only when they are running as the system.
+ final ActivityRecord sourceRecord;
+ final int targetUid;
+ final String targetPackage;
+ final boolean isResolver;
+ synchronized (mGlobalLock) {
+ if (resultTo == null) {
+ throw new SecurityException("Must be called from an activity");
+ }
+ sourceRecord = mStackSupervisor.isInAnyStackLocked(resultTo);
+ if (sourceRecord == null) {
+ throw new SecurityException("Called with bad activity token: " + resultTo);
+ }
+ if (!sourceRecord.info.packageName.equals("android")) {
+ throw new SecurityException(
+ "Must be called from an activity that is declared in the android package");
+ }
+ if (sourceRecord.app == null) {
+ throw new SecurityException("Called without a process attached to activity");
+ }
+ if (UserHandle.getAppId(sourceRecord.app.mUid) != SYSTEM_UID) {
+ // This is still okay, as long as this activity is running under the
+ // uid of the original calling activity.
+ if (sourceRecord.app.mUid != sourceRecord.launchedFromUid) {
+ throw new SecurityException(
+ "Calling activity in uid " + sourceRecord.app.mUid
+ + " must be system uid or original calling uid "
+ + sourceRecord.launchedFromUid);
+ }
+ }
+ if (ignoreTargetSecurity) {
+ if (intent.getComponent() == null) {
+ throw new SecurityException(
+ "Component must be specified with ignoreTargetSecurity");
+ }
+ if (intent.getSelector() != null) {
+ throw new SecurityException(
+ "Selector not allowed with ignoreTargetSecurity");
+ }
+ }
+ targetUid = sourceRecord.launchedFromUid;
+ targetPackage = sourceRecord.launchedFromPackage;
+ isResolver = sourceRecord.isResolverOrChildActivity();
+ }
+
+ if (userId == UserHandle.USER_NULL) {
+ userId = UserHandle.getUserId(sourceRecord.app.mUid);
+ }
+
+ // TODO: Switch to user app stacks here.
+ try {
+ return getActivityStartController().obtainStarter(intent, "startActivityAsCaller")
+ .setCallingUid(targetUid)
+ .setCallingPackage(targetPackage)
+ .setResolvedType(resolvedType)
+ .setResultTo(resultTo)
+ .setResultWho(resultWho)
+ .setRequestCode(requestCode)
+ .setStartFlags(startFlags)
+ .setActivityOptions(bOptions)
+ .setMayWait(userId)
+ .setIgnoreTargetSecurity(ignoreTargetSecurity)
+ .setFilterCallingUid(isResolver ? 0 /* system */ : targetUid)
+ .execute();
+ } catch (SecurityException e) {
+ // XXX need to figure out how to propagate to original app.
+ // A SecurityException here is generally actually a fault of the original
+ // calling activity (such as a fairly granting permissions), so propagate it
+ // back to them.
+ /*
+ StringBuilder msg = new StringBuilder();
+ msg.append("While launching");
+ msg.append(intent.toString());
+ msg.append(": ");
+ msg.append(e.getMessage());
+ */
+ throw e;
+ }
+ }
+
+ int handleIncomingUser(int callingPid, int callingUid, int userId, String name) {
+ return mAmInternal.handleIncomingUser(callingPid, callingUid, userId, false /* allowAll */,
+ ALLOW_FULL_ONLY, name, null /* callerPackage */);
+ }
+
+ @Override
+ public int startVoiceActivity(String callingPackage, int callingPid, int callingUid,
+ Intent intent, String resolvedType, IVoiceInteractionSession session,
+ IVoiceInteractor interactor, int startFlags, ProfilerInfo profilerInfo,
+ Bundle bOptions, int userId) {
+ mAmInternal.enforceCallingPermission(BIND_VOICE_INTERACTION, "startVoiceActivity()");
+ if (session == null || interactor == null) {
+ throw new NullPointerException("null session or interactor");
+ }
+ userId = handleIncomingUser(callingPid, callingUid, userId, "startVoiceActivity");
+ // TODO: Switch to user app stacks here.
+ return getActivityStartController().obtainStarter(intent, "startVoiceActivity")
+ .setCallingUid(callingUid)
+ .setCallingPackage(callingPackage)
+ .setResolvedType(resolvedType)
+ .setVoiceSession(session)
+ .setVoiceInteractor(interactor)
+ .setStartFlags(startFlags)
+ .setProfilerInfo(profilerInfo)
+ .setActivityOptions(bOptions)
+ .setMayWait(userId)
+ .execute();
+ }
+
+ @Override
+ public int startAssistantActivity(String callingPackage, int callingPid, int callingUid,
+ Intent intent, String resolvedType, Bundle bOptions, int userId) {
+ mAmInternal.enforceCallingPermission(BIND_VOICE_INTERACTION, "startAssistantActivity()");
+ userId = handleIncomingUser(callingPid, callingUid, userId, "startAssistantActivity");
+
+ return getActivityStartController().obtainStarter(intent, "startAssistantActivity")
+ .setCallingUid(callingUid)
+ .setCallingPackage(callingPackage)
+ .setResolvedType(resolvedType)
+ .setActivityOptions(bOptions)
+ .setMayWait(userId)
+ .execute();
+ }
+
+ @Override
+ public void startRecentsActivity(Intent intent, IAssistDataReceiver assistDataReceiver,
+ IRecentsAnimationRunner recentsAnimationRunner) {
+ enforceCallerIsRecentsOrHasPermission(MANAGE_ACTIVITY_STACKS, "startRecentsActivity()");
+ final int callingPid = Binder.getCallingPid();
+ final long origId = Binder.clearCallingIdentity();
+ try {
+ synchronized (mGlobalLock) {
+ final ComponentName recentsComponent = mRecentTasks.getRecentsComponent();
+ final int recentsUid = mRecentTasks.getRecentsComponentUid();
+
+ // Start a new recents animation
+ final RecentsAnimation anim = new RecentsAnimation(this, mStackSupervisor,
+ getActivityStartController(), mWindowManager, callingPid);
+ anim.startRecentsActivity(intent, recentsAnimationRunner, recentsComponent,
+ recentsUid, assistDataReceiver);
+ }
+ } finally {
+ Binder.restoreCallingIdentity(origId);
+ }
+ }
+
+ @Override
+ public final int startActivityFromRecents(int taskId, Bundle bOptions) {
+ enforceCallerIsRecentsOrHasPermission(START_TASKS_FROM_RECENTS,
+ "startActivityFromRecents()");
+
+ final int callingPid = Binder.getCallingPid();
+ final int callingUid = Binder.getCallingUid();
+ final SafeActivityOptions safeOptions = SafeActivityOptions.fromBundle(bOptions);
+ final long origId = Binder.clearCallingIdentity();
+ try {
+ synchronized (mGlobalLock) {
+ return mStackSupervisor.startActivityFromRecents(callingPid, callingUid, taskId,
+ safeOptions);
+ }
+ } finally {
+ Binder.restoreCallingIdentity(origId);
+ }
+ }
+
+ /**
+ * This is the internal entry point for handling Activity.finish().
+ *
+ * @param token The Binder token referencing the Activity we want to finish.
+ * @param resultCode Result code, if any, from this Activity.
+ * @param resultData Result data (Intent), if any, from this Activity.
+ * @param finishTask Whether to finish the task associated with this Activity.
+ *
+ * @return Returns true if the activity successfully finished, or false if it is still running.
+ */
+ @Override
+ public final boolean finishActivity(IBinder token, int resultCode, Intent resultData,
+ int finishTask) {
+ // Refuse possible leaked file descriptors
+ if (resultData != null && resultData.hasFileDescriptors()) {
+ throw new IllegalArgumentException("File descriptors passed in Intent");
+ }
+
+ synchronized (mGlobalLock) {
+ ActivityRecord r = ActivityRecord.isInStackLocked(token);
+ if (r == null) {
+ return true;
+ }
+ // Keep track of the root activity of the task before we finish it
+ TaskRecord tr = r.getTask();
+ ActivityRecord rootR = tr.getRootActivity();
+ if (rootR == null) {
+ Slog.w(TAG, "Finishing task with all activities already finished");
+ }
+ // Do not allow task to finish if last task in lockTask mode. Launchable priv-apps can
+ // finish.
+ if (getLockTaskController().activityBlockedFromFinish(r)) {
+ return false;
+ }
+
+ // TODO: There is a dup. of this block of code in ActivityStack.navigateUpToLocked
+ // We should consolidate.
+ if (mController != null) {
+ // Find the first activity that is not finishing.
+ ActivityRecord next = r.getStack().topRunningActivityLocked(token, 0);
+ if (next != null) {
+ // ask watcher if this is allowed
+ boolean resumeOK = true;
+ try {
+ resumeOK = mController.activityResuming(next.packageName);
+ } catch (RemoteException e) {
+ mController = null;
+ Watchdog.getInstance().setActivityController(null);
+ }
+
+ if (!resumeOK) {
+ Slog.i(TAG, "Not finishing activity because controller resumed");
+ return false;
+ }
+ }
+ }
+ final long origId = Binder.clearCallingIdentity();
+ try {
+ boolean res;
+ final boolean finishWithRootActivity =
+ finishTask == Activity.FINISH_TASK_WITH_ROOT_ACTIVITY;
+ if (finishTask == Activity.FINISH_TASK_WITH_ACTIVITY
+ || (finishWithRootActivity && r == rootR)) {
+ // If requested, remove the task that is associated to this activity only if it
+ // was the root activity in the task. The result code and data is ignored
+ // because we don't support returning them across task boundaries. Also, to
+ // keep backwards compatibility we remove the task from recents when finishing
+ // task with root activity.
+ res = mStackSupervisor.removeTaskByIdLocked(tr.taskId, false,
+ finishWithRootActivity, "finish-activity");
+ if (!res) {
+ Slog.i(TAG, "Removing task failed to finish activity");
+ }
+ // Explicitly dismissing the activity so reset its relaunch flag.
+ r.mRelaunchReason = RELAUNCH_REASON_NONE;
+ } else {
+ res = tr.getStack().requestFinishActivityLocked(token, resultCode,
+ resultData, "app-request", true);
+ if (!res) {
+ Slog.i(TAG, "Failed to finish by app-request");
+ }
+ }
+ return res;
+ } finally {
+ Binder.restoreCallingIdentity(origId);
+ }
+ }
+ }
+
+ @Override
+ public boolean finishActivityAffinity(IBinder token) {
+ synchronized (mGlobalLock) {
+ final long origId = Binder.clearCallingIdentity();
+ try {
+ ActivityRecord r = ActivityRecord.isInStackLocked(token);
+ if (r == null) {
+ return false;
+ }
+
+ // Do not allow task to finish if last task in lockTask mode. Launchable priv-apps
+ // can finish.
+ final TaskRecord task = r.getTask();
+ if (getLockTaskController().activityBlockedFromFinish(r)) {
+ return false;
+ }
+ return task.getStack().finishActivityAffinityLocked(r);
+ } finally {
+ Binder.restoreCallingIdentity(origId);
+ }
+ }
+ }
+
+ @Override
+ public final void activityIdle(IBinder token, Configuration config, boolean stopProfiling) {
+ final long origId = Binder.clearCallingIdentity();
+ try {
+ WindowProcessController proc = null;
+ synchronized (mGlobalLock) {
+ ActivityStack stack = ActivityRecord.getStackLocked(token);
+ if (stack == null) {
+ return;
+ }
+ final ActivityRecord r = mStackSupervisor.activityIdleInternalLocked(token,
+ false /* fromTimeout */, false /* processPausingActivities */, config);
+ if (r != null) {
+ proc = r.app;
+ }
+ if (stopProfiling && proc != null) {
+ proc.clearProfilerIfNeeded();
+ }
+ }
+ } finally {
+ Binder.restoreCallingIdentity(origId);
+ }
+ }
+
+ @Override
+ public final void activityResumed(IBinder token) {
+ final long origId = Binder.clearCallingIdentity();
+ synchronized (mGlobalLock) {
+ ActivityRecord.activityResumedLocked(token);
+ mWindowManager.notifyAppResumedFinished(token);
+ }
+ Binder.restoreCallingIdentity(origId);
+ }
+
+ @Override
+ public final void activityPaused(IBinder token) {
+ final long origId = Binder.clearCallingIdentity();
+ synchronized (mGlobalLock) {
+ ActivityStack stack = ActivityRecord.getStackLocked(token);
+ if (stack != null) {
+ stack.activityPausedLocked(token, false);
+ }
+ }
+ Binder.restoreCallingIdentity(origId);
+ }
+
+ @Override
+ public final void activityStopped(IBinder token, Bundle icicle,
+ PersistableBundle persistentState, CharSequence description) {
+ if (DEBUG_ALL) Slog.v(TAG, "Activity stopped: token=" + token);
+
+ // Refuse possible leaked file descriptors
+ if (icicle != null && icicle.hasFileDescriptors()) {
+ throw new IllegalArgumentException("File descriptors passed in Bundle");
+ }
+
+ final long origId = Binder.clearCallingIdentity();
+
+ synchronized (mGlobalLock) {
+ final ActivityRecord r = ActivityRecord.isInStackLocked(token);
+ if (r != null) {
+ r.activityStoppedLocked(icicle, persistentState, description);
+ }
+ }
+
+ mAmInternal.trimApplications();
+
+ Binder.restoreCallingIdentity(origId);
+ }
+
+ @Override
+ public final void activityDestroyed(IBinder token) {
+ if (DEBUG_SWITCH) Slog.v(TAG_SWITCH, "ACTIVITY DESTROYED: " + token);
+ synchronized (mGlobalLock) {
+ ActivityStack stack = ActivityRecord.getStackLocked(token);
+ if (stack != null) {
+ stack.activityDestroyedLocked(token, "activityDestroyed");
+ }
+ }
+ }
+
+ @Override
+ public final void activityRelaunched(IBinder token) {
+ final long origId = Binder.clearCallingIdentity();
+ synchronized (mGlobalLock) {
+ mStackSupervisor.activityRelaunchedLocked(token);
+ }
+ Binder.restoreCallingIdentity(origId);
+ }
+
+ public final void activitySlept(IBinder token) {
+ if (DEBUG_ALL) Slog.v(TAG, "Activity slept: token=" + token);
+
+ final long origId = Binder.clearCallingIdentity();
+
+ synchronized (mGlobalLock) {
+ final ActivityRecord r = ActivityRecord.isInStackLocked(token);
+ if (r != null) {
+ mStackSupervisor.activitySleptLocked(r);
+ }
+ }
+
+ Binder.restoreCallingIdentity(origId);
+ }
+
+ @Override
+ public void setRequestedOrientation(IBinder token, int requestedOrientation) {
+ synchronized (mGlobalLock) {
+ ActivityRecord r = ActivityRecord.isInStackLocked(token);
+ if (r == null) {
+ return;
+ }
+ final long origId = Binder.clearCallingIdentity();
+ try {
+ r.setRequestedOrientation(requestedOrientation);
+ } finally {
+ Binder.restoreCallingIdentity(origId);
+ }
+ }
+ }
+
+ @Override
+ public int getRequestedOrientation(IBinder token) {
+ synchronized (mGlobalLock) {
+ ActivityRecord r = ActivityRecord.isInStackLocked(token);
+ if (r == null) {
+ return ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED;
+ }
+ return r.getRequestedOrientation();
+ }
+ }
+
+ @Override
+ public void setImmersive(IBinder token, boolean immersive) {
+ synchronized (mGlobalLock) {
+ final ActivityRecord r = ActivityRecord.isInStackLocked(token);
+ if (r == null) {
+ throw new IllegalArgumentException();
+ }
+ r.immersive = immersive;
+
+ // update associated state if we're frontmost
+ if (r.isResumedActivityOnDisplay()) {
+ if (DEBUG_IMMERSIVE) Slog.d(TAG_IMMERSIVE, "Frontmost changed immersion: "+ r);
+ applyUpdateLockStateLocked(r);
+ }
+ }
+ }
+
+ void applyUpdateLockStateLocked(ActivityRecord r) {
+ // Modifications to the UpdateLock state are done on our handler, outside
+ // the activity manager's locks. The new state is determined based on the
+ // state *now* of the relevant activity record. The object is passed to
+ // the handler solely for logging detail, not to be consulted/modified.
+ final boolean nextState = r != null && r.immersive;
+ mH.post(() -> {
+ if (mUpdateLock.isHeld() != nextState) {
+ if (DEBUG_IMMERSIVE) Slog.d(TAG_IMMERSIVE,
+ "Applying new update lock state '" + nextState + "' for " + r);
+ if (nextState) {
+ mUpdateLock.acquire();
+ } else {
+ mUpdateLock.release();
+ }
+ }
+ });
+ }
+
+ @Override
+ public boolean isImmersive(IBinder token) {
+ synchronized (mGlobalLock) {
+ final ActivityRecord r = ActivityRecord.isInStackLocked(token);
+ if (r == null) {
+ throw new IllegalArgumentException();
+ }
+ return r.immersive;
+ }
+ }
+
+ @Override
+ public boolean isTopActivityImmersive() {
+ enforceNotIsolatedCaller("isTopActivityImmersive");
+ synchronized (mGlobalLock) {
+ final ActivityRecord r = getTopDisplayFocusedStack().topRunningActivityLocked();
+ return (r != null) ? r.immersive : false;
+ }
+ }
+
+ @Override
+ public void overridePendingTransition(IBinder token, String packageName,
+ int enterAnim, int exitAnim) {
+ synchronized (mGlobalLock) {
+ ActivityRecord self = ActivityRecord.isInStackLocked(token);
+ if (self == null) {
+ return;
+ }
+
+ final long origId = Binder.clearCallingIdentity();
+
+ if (self.isState(
+ ActivityStack.ActivityState.RESUMED, ActivityStack.ActivityState.PAUSING)) {
+ self.getDisplay().getWindowContainerController().overridePendingAppTransition(
+ packageName, enterAnim, exitAnim, null);
+ }
+
+ Binder.restoreCallingIdentity(origId);
+ }
+ }
+
+ @Override
+ public int getFrontActivityScreenCompatMode() {
+ enforceNotIsolatedCaller("getFrontActivityScreenCompatMode");
+ synchronized (mGlobalLock) {
+ final ActivityRecord r = getTopDisplayFocusedStack().topRunningActivityLocked();
+ if (r == null) {
+ return ActivityManager.COMPAT_MODE_UNKNOWN;
+ }
+ return mCompatModePackages.computeCompatModeLocked(r.info.applicationInfo);
+ }
+ }
+
+ @Override
+ public void setFrontActivityScreenCompatMode(int mode) {
+ mAmInternal.enforceCallingPermission(android.Manifest.permission.SET_SCREEN_COMPATIBILITY,
+ "setFrontActivityScreenCompatMode");
+ ApplicationInfo ai;
+ synchronized (mGlobalLock) {
+ final ActivityRecord r = getTopDisplayFocusedStack().topRunningActivityLocked();
+ if (r == null) {
+ Slog.w(TAG, "setFrontActivityScreenCompatMode failed: no top activity");
+ return;
+ }
+ ai = r.info.applicationInfo;
+ mCompatModePackages.setPackageScreenCompatModeLocked(ai, mode);
+ }
+ }
+
+ @Override
+ public int getLaunchedFromUid(IBinder activityToken) {
+ ActivityRecord srec;
+ synchronized (mGlobalLock) {
+ srec = ActivityRecord.forTokenLocked(activityToken);
+ }
+ if (srec == null) {
+ return -1;
+ }
+ return srec.launchedFromUid;
+ }
+
+ @Override
+ public String getLaunchedFromPackage(IBinder activityToken) {
+ ActivityRecord srec;
+ synchronized (mGlobalLock) {
+ srec = ActivityRecord.forTokenLocked(activityToken);
+ }
+ if (srec == null) {
+ return null;
+ }
+ return srec.launchedFromPackage;
+ }
+
+ @Override
+ public boolean convertFromTranslucent(IBinder token) {
+ final long origId = Binder.clearCallingIdentity();
+ try {
+ synchronized (mGlobalLock) {
+ final ActivityRecord r = ActivityRecord.isInStackLocked(token);
+ if (r == null) {
+ return false;
+ }
+ final boolean translucentChanged = r.changeWindowTranslucency(true);
+ if (translucentChanged) {
+ mStackSupervisor.ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
+ }
+ mWindowManager.setAppFullscreen(token, true);
+ return translucentChanged;
+ }
+ } finally {
+ Binder.restoreCallingIdentity(origId);
+ }
+ }
+
+ @Override
+ public boolean convertToTranslucent(IBinder token, Bundle options) {
+ SafeActivityOptions safeOptions = SafeActivityOptions.fromBundle(options);
+ final long origId = Binder.clearCallingIdentity();
+ try {
+ synchronized (mGlobalLock) {
+ final ActivityRecord r = ActivityRecord.isInStackLocked(token);
+ if (r == null) {
+ return false;
+ }
+ final TaskRecord task = r.getTask();
+ int index = task.mActivities.lastIndexOf(r);
+ if (index > 0) {
+ ActivityRecord under = task.mActivities.get(index - 1);
+ under.returningOptions = safeOptions != null ? safeOptions.getOptions(r) : null;
+ }
+ final boolean translucentChanged = r.changeWindowTranslucency(false);
+ if (translucentChanged) {
+ r.getStack().convertActivityToTranslucent(r);
+ }
+ mStackSupervisor.ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
+ mWindowManager.setAppFullscreen(token, false);
+ return translucentChanged;
+ }
+ } finally {
+ Binder.restoreCallingIdentity(origId);
+ }
+ }
+
+ @Override
+ public void notifyActivityDrawn(IBinder token) {
+ if (DEBUG_VISIBILITY) Slog.d(TAG_VISIBILITY, "notifyActivityDrawn: token=" + token);
+ synchronized (mGlobalLock) {
+ ActivityRecord r = mStackSupervisor.isInAnyStackLocked(token);
+ if (r != null) {
+ r.getStack().notifyActivityDrawnLocked(r);
+ }
+ }
+ }
+
+ @Override
+ public void reportActivityFullyDrawn(IBinder token, boolean restoredFromBundle) {
+ synchronized (mGlobalLock) {
+ ActivityRecord r = ActivityRecord.isInStackLocked(token);
+ if (r == null) {
+ return;
+ }
+ r.reportFullyDrawnLocked(restoredFromBundle);
+ }
+ }
+
+ @Override
+ public int getActivityDisplayId(IBinder activityToken) throws RemoteException {
+ synchronized (mGlobalLock) {
+ final ActivityStack stack = ActivityRecord.getStackLocked(activityToken);
+ if (stack != null && stack.mDisplayId != INVALID_DISPLAY) {
+ return stack.mDisplayId;
+ }
+ return DEFAULT_DISPLAY;
+ }
+ }
+
+ @Override
+ public ActivityManager.StackInfo getFocusedStackInfo() throws RemoteException {
+ enforceCallerIsRecentsOrHasPermission(MANAGE_ACTIVITY_STACKS, "getStackInfo()");
+ long ident = Binder.clearCallingIdentity();
+ try {
+ synchronized (mGlobalLock) {
+ ActivityStack focusedStack = getTopDisplayFocusedStack();
+ if (focusedStack != null) {
+ return mStackSupervisor.getStackInfo(focusedStack.mStackId);
+ }
+ return null;
+ }
+ } finally {
+ Binder.restoreCallingIdentity(ident);
+ }
+ }
+
+ @Override
+ public void setFocusedStack(int stackId) {
+ mAmInternal.enforceCallingPermission(MANAGE_ACTIVITY_STACKS, "setFocusedStack()");
+ if (DEBUG_FOCUS) Slog.d(TAG_FOCUS, "setFocusedStack: stackId=" + stackId);
+ final long callingId = Binder.clearCallingIdentity();
+ try {
+ synchronized (mGlobalLock) {
+ final ActivityStack stack = mStackSupervisor.getStack(stackId);
+ if (stack == null) {
+ Slog.w(TAG, "setFocusedStack: No stack with id=" + stackId);
+ return;
+ }
+ final ActivityRecord r = stack.topRunningActivityLocked();
+ if (r != null && r.moveFocusableActivityToTop("setFocusedStack")) {
+ mStackSupervisor.resumeFocusedStacksTopActivitiesLocked();
+ }
+ }
+ } finally {
+ Binder.restoreCallingIdentity(callingId);
+ }
+ }
+
+ @Override
+ public void setFocusedTask(int taskId) {
+ mAmInternal.enforceCallingPermission(MANAGE_ACTIVITY_STACKS, "setFocusedTask()");
+ if (DEBUG_FOCUS) Slog.d(TAG_FOCUS, "setFocusedTask: taskId=" + taskId);
+ final long callingId = Binder.clearCallingIdentity();
+ try {
+ synchronized (mGlobalLock) {
+ final TaskRecord task = mStackSupervisor.anyTaskForIdLocked(taskId,
+ MATCH_TASK_IN_STACKS_ONLY);
+ if (task == null) {
+ return;
+ }
+ final ActivityRecord r = task.topRunningActivityLocked();
+ if (r != null && r.moveFocusableActivityToTop("setFocusedTask")) {
+ mStackSupervisor.resumeFocusedStacksTopActivitiesLocked();
+ }
+ }
+ } finally {
+ Binder.restoreCallingIdentity(callingId);
+ }
+ }
+
+ @Override
+ public boolean removeTask(int taskId) {
+ enforceCallerIsRecentsOrHasPermission(REMOVE_TASKS, "removeTask()");
+ synchronized (mGlobalLock) {
+ final long ident = Binder.clearCallingIdentity();
+ try {
+ return mStackSupervisor.removeTaskByIdLocked(taskId, true, REMOVE_FROM_RECENTS,
+ "remove-task");
+ } finally {
+ Binder.restoreCallingIdentity(ident);
+ }
+ }
+ }
+
+ @Override
+ public void removeAllVisibleRecentTasks() {
+ enforceCallerIsRecentsOrHasPermission(REMOVE_TASKS, "removeAllVisibleRecentTasks()");
+ synchronized (mGlobalLock) {
+ final long ident = Binder.clearCallingIdentity();
+ try {
+ getRecentTasks().removeAllVisibleTasks();
+ } finally {
+ Binder.restoreCallingIdentity(ident);
+ }
+ }
+ }
+
+ @Override
+ public boolean shouldUpRecreateTask(IBinder token, String destAffinity) {
+ synchronized (mGlobalLock) {
+ final ActivityRecord srec = ActivityRecord.forTokenLocked(token);
+ if (srec != null) {
+ return srec.getStack().shouldUpRecreateTaskLocked(srec, destAffinity);
+ }
+ }
+ return false;
+ }
+
+ @Override
+ public boolean navigateUpTo(IBinder token, Intent destIntent, int resultCode,
+ Intent resultData) {
+
+ synchronized (mGlobalLock) {
+ final ActivityRecord r = ActivityRecord.forTokenLocked(token);
+ if (r != null) {
+ return r.getStack().navigateUpToLocked(r, destIntent, resultCode, resultData);
+ }
+ return false;
+ }
+ }
+
+ /**
+ * Attempts to move a task backwards in z-order (the order of activities within the task is
+ * unchanged).
+ *
+ * There are several possible results of this call:
+ * - if the task is locked, then we will show the lock toast
+ * - if there is a task behind the provided task, then that task is made visible and resumed as
+ * this task is moved to the back
+ * - otherwise, if there are no other tasks in the stack:
+ * - if this task is in the pinned stack, then we remove the stack completely, which will
+ * have the effect of moving the task to the top or bottom of the fullscreen stack
+ * (depending on whether it is visible)
+ * - otherwise, we simply return home and hide this task
+ *
+ * @param token A reference to the activity we wish to move
+ * @param nonRoot If false then this only works if the activity is the root
+ * of a task; if true it will work for any activity in a task.
+ * @return Returns true if the move completed, false if not.
+ */
+ @Override
+ public boolean moveActivityTaskToBack(IBinder token, boolean nonRoot) {
+ enforceNotIsolatedCaller("moveActivityTaskToBack");
+ synchronized (mGlobalLock) {
+ final long origId = Binder.clearCallingIdentity();
+ try {
+ int taskId = ActivityRecord.getTaskForActivityLocked(token, !nonRoot);
+ final TaskRecord task = mStackSupervisor.anyTaskForIdLocked(taskId);
+ if (task != null) {
+ return ActivityRecord.getStackLocked(token).moveTaskToBackLocked(taskId);
+ }
+ } finally {
+ Binder.restoreCallingIdentity(origId);
+ }
+ }
+ return false;
+ }
+
+ @Override
+ public Rect getTaskBounds(int taskId) {
+ mAmInternal.enforceCallingPermission(MANAGE_ACTIVITY_STACKS, "getTaskBounds()");
+ long ident = Binder.clearCallingIdentity();
+ Rect rect = new Rect();
+ try {
+ synchronized (mGlobalLock) {
+ final TaskRecord task = mStackSupervisor.anyTaskForIdLocked(taskId,
+ MATCH_TASK_IN_STACKS_OR_RECENT_TASKS);
+ if (task == null) {
+ Slog.w(TAG, "getTaskBounds: taskId=" + taskId + " not found");
+ return rect;
+ }
+ if (task.getStack() != null) {
+ // Return the bounds from window manager since it will be adjusted for various
+ // things like the presense of a docked stack for tasks that aren't resizeable.
+ task.getWindowContainerBounds(rect);
+ } else {
+ // Task isn't in window manager yet since it isn't associated with a stack.
+ // Return the persist value from activity manager
+ if (!task.matchParentBounds()) {
+ rect.set(task.getBounds());
+ } else if (task.mLastNonFullscreenBounds != null) {
+ rect.set(task.mLastNonFullscreenBounds);
+ }
+ }
+ }
+ } finally {
+ Binder.restoreCallingIdentity(ident);
+ }
+ return rect;
+ }
+
+ @Override
+ public ActivityManager.TaskDescription getTaskDescription(int id) {
+ synchronized (mGlobalLock) {
+ enforceCallerIsRecentsOrHasPermission(
+ MANAGE_ACTIVITY_STACKS, "getTaskDescription()");
+ final TaskRecord tr = mStackSupervisor.anyTaskForIdLocked(id,
+ MATCH_TASK_IN_STACKS_OR_RECENT_TASKS);
+ if (tr != null) {
+ return tr.lastTaskDescription;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public void setTaskWindowingMode(int taskId, int windowingMode, boolean toTop) {
+ if (windowingMode == WINDOWING_MODE_SPLIT_SCREEN_PRIMARY) {
+ setTaskWindowingModeSplitScreenPrimary(taskId, SPLIT_SCREEN_CREATE_MODE_TOP_OR_LEFT,
+ toTop, ANIMATE, null /* initialBounds */, true /* showRecents */);
+ return;
+ }
+ enforceCallerIsRecentsOrHasPermission(MANAGE_ACTIVITY_STACKS, "setTaskWindowingMode()");
+ synchronized (mGlobalLock) {
+ final long ident = Binder.clearCallingIdentity();
+ try {
+ final TaskRecord task = mStackSupervisor.anyTaskForIdLocked(taskId,
+ MATCH_TASK_IN_STACKS_ONLY);
+ if (task == null) {
+ Slog.w(TAG, "setTaskWindowingMode: No task for id=" + taskId);
+ return;
+ }
+
+ if (DEBUG_STACK) Slog.d(TAG_STACK, "setTaskWindowingMode: moving task=" + taskId
+ + " to windowingMode=" + windowingMode + " toTop=" + toTop);
+
+ if (!task.isActivityTypeStandardOrUndefined()) {
+ throw new IllegalArgumentException("setTaskWindowingMode: Attempt to move"
+ + " non-standard task " + taskId + " to windowing mode="
+ + windowingMode);
+ }
+
+ final ActivityStack stack = task.getStack();
+ if (toTop) {
+ stack.moveToFront("setTaskWindowingMode", task);
+ }
+ stack.setWindowingMode(windowingMode);
+ } finally {
+ Binder.restoreCallingIdentity(ident);
+ }
+ }
+ }
+
+ @Override
+ public String getCallingPackage(IBinder token) {
+ synchronized (mGlobalLock) {
+ ActivityRecord r = getCallingRecordLocked(token);
+ return r != null ? r.info.packageName : null;
+ }
+ }
+
+ @Override
+ public ComponentName getCallingActivity(IBinder token) {
+ synchronized (mGlobalLock) {
+ ActivityRecord r = getCallingRecordLocked(token);
+ return r != null ? r.intent.getComponent() : null;
+ }
+ }
+
+ private ActivityRecord getCallingRecordLocked(IBinder token) {
+ ActivityRecord r = ActivityRecord.isInStackLocked(token);
+ if (r == null) {
+ return null;
+ }
+ return r.resultTo;
+ }
+
+ @Override
+ public void unhandledBack() {
+ mAmInternal.enforceCallingPermission(android.Manifest.permission.FORCE_BACK, "unhandledBack()");
+
+ synchronized (mGlobalLock) {
+ final long origId = Binder.clearCallingIdentity();
+ try {
+ getTopDisplayFocusedStack().unhandledBackLocked();
+ } finally {
+ Binder.restoreCallingIdentity(origId);
+ }
+ }
+ }
+
+ /**
+ * TODO: Add mController hook
+ */
+ @Override
+ public void moveTaskToFront(int taskId, int flags, Bundle bOptions) {
+ mAmInternal.enforceCallingPermission(android.Manifest.permission.REORDER_TASKS, "moveTaskToFront()");
+
+ if (DEBUG_STACK) Slog.d(TAG_STACK, "moveTaskToFront: moving taskId=" + taskId);
+ synchronized (mGlobalLock) {
+ moveTaskToFrontLocked(taskId, flags, SafeActivityOptions.fromBundle(bOptions),
+ false /* fromRecents */);
+ }
+ }
+
+ void moveTaskToFrontLocked(int taskId, int flags, SafeActivityOptions options,
+ boolean fromRecents) {
+
+ if (!checkAppSwitchAllowedLocked(Binder.getCallingPid(),
+ Binder.getCallingUid(), -1, -1, "Task to front")) {
+ SafeActivityOptions.abort(options);
+ return;
+ }
+ final long origId = Binder.clearCallingIdentity();
+ try {
+ final TaskRecord task = mStackSupervisor.anyTaskForIdLocked(taskId);
+ if (task == null) {
+ Slog.d(TAG, "Could not find task for id: "+ taskId);
+ SafeActivityOptions.abort(options);
+ return;
+ }
+ if (getLockTaskController().isLockTaskModeViolation(task)) {
+ Slog.e(TAG, "moveTaskToFront: Attempt to violate Lock Task Mode");
+ SafeActivityOptions.abort(options);
+ return;
+ }
+ ActivityOptions realOptions = options != null
+ ? options.getOptions(mStackSupervisor)
+ : null;
+ mStackSupervisor.findTaskToMoveToFront(task, flags, realOptions, "moveTaskToFront",
+ false /* forceNonResizable */);
+
+ final ActivityRecord topActivity = task.getTopActivity();
+ if (topActivity != null) {
+
+ // We are reshowing a task, use a starting window to hide the initial draw delay
+ // so the transition can start earlier.
+ topActivity.showStartingWindow(null /* prev */, false /* newTask */,
+ true /* taskSwitch */, fromRecents);
+ }
+ } finally {
+ Binder.restoreCallingIdentity(origId);
+ }
+ }
+
+ boolean checkAppSwitchAllowedLocked(int sourcePid, int sourceUid,
+ int callingPid, int callingUid, String name) {
+ if (mAppSwitchesAllowedTime < SystemClock.uptimeMillis()) {
+ return true;
+ }
+
+ if (getRecentTasks().isCallerRecents(sourceUid)) {
+ return true;
+ }
+
+ int perm = checkComponentPermission(STOP_APP_SWITCHES, sourcePid, sourceUid, -1, true);
+ if (perm == PackageManager.PERMISSION_GRANTED) {
+ return true;
+ }
+ if (checkAllowAppSwitchUid(sourceUid)) {
+ return true;
+ }
+
+ // If the actual IPC caller is different from the logical source, then
+ // also see if they are allowed to control app switches.
+ if (callingUid != -1 && callingUid != sourceUid) {
+ perm = checkComponentPermission(STOP_APP_SWITCHES, callingPid, callingUid, -1, true);
+ if (perm == PackageManager.PERMISSION_GRANTED) {
+ return true;
+ }
+ if (checkAllowAppSwitchUid(callingUid)) {
+ return true;
+ }
+ }
+
+ Slog.w(TAG, name + " request from " + sourceUid + " stopped");
+ return false;
+ }
+
+ private boolean checkAllowAppSwitchUid(int uid) {
+ ArrayMap<String, Integer> types = mAllowAppSwitchUids.get(UserHandle.getUserId(uid));
+ if (types != null) {
+ for (int i = types.size() - 1; i >= 0; i--) {
+ if (types.valueAt(i).intValue() == uid) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ @Override
+ public void setActivityController(IActivityController controller, boolean imAMonkey) {
+ mAmInternal.enforceCallingPermission(android.Manifest.permission.SET_ACTIVITY_WATCHER,
+ "setActivityController()");
+ synchronized (mGlobalLock) {
+ mController = controller;
+ mControllerIsAMonkey = imAMonkey;
+ Watchdog.getInstance().setActivityController(controller);
+ }
+ }
+
+ public boolean isControllerAMonkey() {
+ synchronized (mGlobalLock) {
+ return mController != null && mControllerIsAMonkey;
+ }
+ }
+
+ @Override
+ public int getTaskForActivity(IBinder token, boolean onlyRoot) {
+ synchronized (mGlobalLock) {
+ return ActivityRecord.getTaskForActivityLocked(token, onlyRoot);
+ }
+ }
+
+ @Override
+ public List<ActivityManager.RunningTaskInfo> getTasks(int maxNum) {
+ return getFilteredTasks(maxNum, ACTIVITY_TYPE_UNDEFINED, WINDOWING_MODE_UNDEFINED);
+ }
+
+ @Override
+ public List<ActivityManager.RunningTaskInfo> getFilteredTasks(int maxNum,
+ @WindowConfiguration.ActivityType int ignoreActivityType,
+ @WindowConfiguration.WindowingMode int ignoreWindowingMode) {
+ final int callingUid = Binder.getCallingUid();
+ ArrayList<ActivityManager.RunningTaskInfo> list = new ArrayList<>();
+
+ synchronized (mGlobalLock) {
+ if (DEBUG_ALL) Slog.v(TAG, "getTasks: max=" + maxNum);
+
+ final boolean allowed = isGetTasksAllowed("getTasks", Binder.getCallingPid(),
+ callingUid);
+ mStackSupervisor.getRunningTasks(maxNum, list, ignoreActivityType,
+ ignoreWindowingMode, callingUid, allowed);
+ }
+
+ return list;
+ }
+
+ @Override
+ public final void finishSubActivity(IBinder token, String resultWho, int requestCode) {
+ synchronized (mGlobalLock) {
+ final long origId = Binder.clearCallingIdentity();
+ ActivityRecord r = ActivityRecord.isInStackLocked(token);
+ if (r != null) {
+ r.getStack().finishSubActivityLocked(r, resultWho, requestCode);
+ }
+ Binder.restoreCallingIdentity(origId);
+ }
+ }
+
+ @Override
+ public boolean willActivityBeVisible(IBinder token) {
+ synchronized (mGlobalLock) {
+ ActivityStack stack = ActivityRecord.getStackLocked(token);
+ if (stack != null) {
+ return stack.willActivityBeVisibleLocked(token);
+ }
+ return false;
+ }
+ }
+
+ @Override
+ public void moveTaskToStack(int taskId, int stackId, boolean toTop) {
+ enforceCallerIsRecentsOrHasPermission(MANAGE_ACTIVITY_STACKS, "moveTaskToStack()");
+ synchronized (mGlobalLock) {
+ final long ident = Binder.clearCallingIdentity();
+ try {
+ final TaskRecord task = mStackSupervisor.anyTaskForIdLocked(taskId);
+ if (task == null) {
+ Slog.w(TAG, "moveTaskToStack: No task for id=" + taskId);
+ return;
+ }
+
+ if (DEBUG_STACK) Slog.d(TAG_STACK, "moveTaskToStack: moving task=" + taskId
+ + " to stackId=" + stackId + " toTop=" + toTop);
+
+ final ActivityStack stack = mStackSupervisor.getStack(stackId);
+ if (stack == null) {
+ throw new IllegalStateException(
+ "moveTaskToStack: No stack for stackId=" + stackId);
+ }
+ if (!stack.isActivityTypeStandardOrUndefined()) {
+ throw new IllegalArgumentException("moveTaskToStack: Attempt to move task "
+ + taskId + " to stack " + stackId);
+ }
+ if (stack.inSplitScreenPrimaryWindowingMode()) {
+ mWindowManager.setDockedStackCreateState(
+ SPLIT_SCREEN_CREATE_MODE_TOP_OR_LEFT, null /* initialBounds */);
+ }
+ task.reparent(stack, toTop, REPARENT_KEEP_STACK_AT_FRONT, ANIMATE, !DEFER_RESUME,
+ "moveTaskToStack");
+ } finally {
+ Binder.restoreCallingIdentity(ident);
+ }
+ }
+ }
+
+ @Override
+ public void resizeStack(int stackId, Rect destBounds, boolean allowResizeInDockedMode,
+ boolean preserveWindows, boolean animate, int animationDuration) {
+ enforceCallerIsRecentsOrHasPermission(MANAGE_ACTIVITY_STACKS, "resizeStack()");
+
+ final long ident = Binder.clearCallingIdentity();
+ try {
+ synchronized (mGlobalLock) {
+ if (animate) {
+ final PinnedActivityStack stack = mStackSupervisor.getStack(stackId);
+ if (stack == null) {
+ Slog.w(TAG, "resizeStack: stackId " + stackId + " not found.");
+ return;
+ }
+ if (stack.getWindowingMode() != WINDOWING_MODE_PINNED) {
+ throw new IllegalArgumentException("Stack: " + stackId
+ + " doesn't support animated resize.");
+ }
+ stack.animateResizePinnedStack(null /* sourceHintBounds */, destBounds,
+ animationDuration, false /* fromFullscreen */);
+ } else {
+ final ActivityStack stack = mStackSupervisor.getStack(stackId);
+ if (stack == null) {
+ Slog.w(TAG, "resizeStack: stackId " + stackId + " not found.");
+ return;
+ }
+ mStackSupervisor.resizeStackLocked(stack, destBounds,
+ null /* tempTaskBounds */, null /* tempTaskInsetBounds */,
+ preserveWindows, allowResizeInDockedMode, !DEFER_RESUME);
+ }
+ }
+ } finally {
+ Binder.restoreCallingIdentity(ident);
+ }
+ }
+
+ /**
+ * Moves the specified task to the primary-split-screen stack.
+ *
+ * @param taskId Id of task to move.
+ * @param createMode The mode the primary split screen stack should be created in if it doesn't
+ * exist already. See
+ * {@link android.app.ActivityTaskManager#SPLIT_SCREEN_CREATE_MODE_TOP_OR_LEFT}
+ * and
+ * {@link android.app.ActivityTaskManager#SPLIT_SCREEN_CREATE_MODE_BOTTOM_OR_RIGHT}
+ * @param toTop If the task and stack should be moved to the top.
+ * @param animate Whether we should play an animation for the moving the task.
+ * @param initialBounds If the primary stack gets created, it will use these bounds for the
+ * stack. Pass {@code null} to use default bounds.
+ * @param showRecents If the recents activity should be shown on the other side of the task
+ * going into split-screen mode.
+ */
+ @Override
+ public boolean setTaskWindowingModeSplitScreenPrimary(int taskId, int createMode,
+ boolean toTop, boolean animate, Rect initialBounds, boolean showRecents) {
+ enforceCallerIsRecentsOrHasPermission(MANAGE_ACTIVITY_STACKS,
+ "setTaskWindowingModeSplitScreenPrimary()");
+ synchronized (mGlobalLock) {
+ final long ident = Binder.clearCallingIdentity();
+ try {
+ final TaskRecord task = mStackSupervisor.anyTaskForIdLocked(taskId,
+ MATCH_TASK_IN_STACKS_ONLY);
+ if (task == null) {
+ Slog.w(TAG, "setTaskWindowingModeSplitScreenPrimary: No task for id=" + taskId);
+ return false;
+ }
+ if (DEBUG_STACK) Slog.d(TAG_STACK,
+ "setTaskWindowingModeSplitScreenPrimary: moving task=" + taskId
+ + " to createMode=" + createMode + " toTop=" + toTop);
+ if (!task.isActivityTypeStandardOrUndefined()) {
+ throw new IllegalArgumentException("setTaskWindowingMode: Attempt to move"
+ + " non-standard task " + taskId + " to split-screen windowing mode");
+ }
+
+ mWindowManager.setDockedStackCreateState(createMode, initialBounds);
+ final int windowingMode = task.getWindowingMode();
+ final ActivityStack stack = task.getStack();
+ if (toTop) {
+ stack.moveToFront("setTaskWindowingModeSplitScreenPrimary", task);
+ }
+ stack.setWindowingMode(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY, animate, showRecents,
+ false /* enteringSplitScreenMode */, false /* deferEnsuringVisibility */);
+ return windowingMode != task.getWindowingMode();
+ } finally {
+ Binder.restoreCallingIdentity(ident);
+ }
+ }
+ }
+
+ /**
+ * Removes stacks in the input windowing modes from the system if they are of activity type
+ * ACTIVITY_TYPE_STANDARD or ACTIVITY_TYPE_UNDEFINED
+ */
+ @Override
+ public void removeStacksInWindowingModes(int[] windowingModes) {
+ enforceCallerIsRecentsOrHasPermission(MANAGE_ACTIVITY_STACKS,
+ "removeStacksInWindowingModes()");
+
+ synchronized (mGlobalLock) {
+ final long ident = Binder.clearCallingIdentity();
+ try {
+ mStackSupervisor.removeStacksInWindowingModes(windowingModes);
+ } finally {
+ Binder.restoreCallingIdentity(ident);
+ }
+ }
+ }
+
+ @Override
+ public void removeStacksWithActivityTypes(int[] activityTypes) {
+ enforceCallerIsRecentsOrHasPermission(MANAGE_ACTIVITY_STACKS,
+ "removeStacksWithActivityTypes()");
+
+ synchronized (mGlobalLock) {
+ final long ident = Binder.clearCallingIdentity();
+ try {
+ mStackSupervisor.removeStacksWithActivityTypes(activityTypes);
+ } finally {
+ Binder.restoreCallingIdentity(ident);
+ }
+ }
+ }
+
+ @Override
+ public ParceledListSlice<ActivityManager.RecentTaskInfo> getRecentTasks(int maxNum, int flags,
+ int userId) {
+ final int callingUid = Binder.getCallingUid();
+ userId = handleIncomingUser(Binder.getCallingPid(), callingUid, userId, "getRecentTasks");
+ final boolean allowed = isGetTasksAllowed("getRecentTasks", Binder.getCallingPid(),
+ callingUid);
+ final boolean detailed = checkGetTasksPermission(
+ android.Manifest.permission.GET_DETAILED_TASKS, Binder.getCallingPid(),
+ UserHandle.getAppId(callingUid))
+ == PackageManager.PERMISSION_GRANTED;
+
+ synchronized (mGlobalLock) {
+ return mRecentTasks.getRecentTasks(maxNum, flags, allowed, detailed, userId,
+ callingUid);
+ }
+ }
+
+ @Override
+ public List<ActivityManager.StackInfo> getAllStackInfos() {
+ enforceCallerIsRecentsOrHasPermission(MANAGE_ACTIVITY_STACKS, "getAllStackInfos()");
+ long ident = Binder.clearCallingIdentity();
+ try {
+ synchronized (mGlobalLock) {
+ return mStackSupervisor.getAllStackInfosLocked();
+ }
+ } finally {
+ Binder.restoreCallingIdentity(ident);
+ }
+ }
+
+ @Override
+ public ActivityManager.StackInfo getStackInfo(int windowingMode, int activityType) {
+ enforceCallerIsRecentsOrHasPermission(MANAGE_ACTIVITY_STACKS, "getStackInfo()");
+ long ident = Binder.clearCallingIdentity();
+ try {
+ synchronized (mGlobalLock) {
+ return mStackSupervisor.getStackInfo(windowingMode, activityType);
+ }
+ } finally {
+ Binder.restoreCallingIdentity(ident);
+ }
+ }
+
+ @Override
+ public void cancelRecentsAnimation(boolean restoreHomeStackPosition) {
+ enforceCallerIsRecentsOrHasPermission(MANAGE_ACTIVITY_STACKS, "cancelRecentsAnimation()");
+ final long callingUid = Binder.getCallingUid();
+ final long origId = Binder.clearCallingIdentity();
+ try {
+ synchronized (mGlobalLock) {
+ // Cancel the recents animation synchronously (do not hold the WM lock)
+ mWindowManager.cancelRecentsAnimationSynchronously(restoreHomeStackPosition
+ ? REORDER_MOVE_TO_ORIGINAL_POSITION
+ : REORDER_KEEP_IN_PLACE, "cancelRecentsAnimation/uid=" + callingUid);
+ }
+ } finally {
+ Binder.restoreCallingIdentity(origId);
+ }
+ }
+
+ @Override
+ public void startLockTaskModeByToken(IBinder token) {
+ synchronized (mGlobalLock) {
+ final ActivityRecord r = ActivityRecord.forTokenLocked(token);
+ if (r == null) {
+ return;
+ }
+ startLockTaskModeLocked(r.getTask(), false /* isSystemCaller */);
+ }
+ }
+
+ @Override
+ public void startSystemLockTaskMode(int taskId) {
+ mAmInternal.enforceCallingPermission(MANAGE_ACTIVITY_STACKS, "startSystemLockTaskMode");
+ // This makes inner call to look as if it was initiated by system.
+ long ident = Binder.clearCallingIdentity();
+ try {
+ synchronized (mGlobalLock) {
+ final TaskRecord task = mStackSupervisor.anyTaskForIdLocked(taskId,
+ MATCH_TASK_IN_STACKS_ONLY);
+ if (task == null) {
+ return;
+ }
+
+ // When starting lock task mode the stack must be in front and focused
+ task.getStack().moveToFront("startSystemLockTaskMode");
+ startLockTaskModeLocked(task, true /* isSystemCaller */);
+ }
+ } finally {
+ Binder.restoreCallingIdentity(ident);
+ }
+ }
+
+ @Override
+ public void stopLockTaskModeByToken(IBinder token) {
+ synchronized (mGlobalLock) {
+ final ActivityRecord r = ActivityRecord.forTokenLocked(token);
+ if (r == null) {
+ return;
+ }
+ stopLockTaskModeInternal(r.getTask(), false /* isSystemCaller */);
+ }
+ }
+
+ /**
+ * This API should be called by SystemUI only when user perform certain action to dismiss
+ * lock task mode. We should only dismiss pinned lock task mode in this case.
+ */
+ @Override
+ public void stopSystemLockTaskMode() throws RemoteException {
+ mAmInternal.enforceCallingPermission(MANAGE_ACTIVITY_STACKS, "stopSystemLockTaskMode");
+ stopLockTaskModeInternal(null, true /* isSystemCaller */);
+ }
+
+ private void startLockTaskModeLocked(@Nullable TaskRecord task, boolean isSystemCaller) {
+ if (DEBUG_LOCKTASK) Slog.w(TAG_LOCKTASK, "startLockTaskModeLocked: " + task);
+ if (task == null || task.mLockTaskAuth == LOCK_TASK_AUTH_DONT_LOCK) {
+ return;
+ }
+
+ final ActivityStack stack = mStackSupervisor.getTopDisplayFocusedStack();
+ if (stack == null || task != stack.topTask()) {
+ throw new IllegalArgumentException("Invalid task, not in foreground");
+ }
+
+ // {@code isSystemCaller} is used to distinguish whether this request is initiated by the
+ // system or a specific app.
+ // * System-initiated requests will only start the pinned mode (screen pinning)
+ // * App-initiated requests
+ // - will put the device in fully locked mode (LockTask), if the app is whitelisted
+ // - will start the pinned mode, otherwise
+ final int callingUid = Binder.getCallingUid();
+ long ident = Binder.clearCallingIdentity();
+ try {
+ // When a task is locked, dismiss the pinned stack if it exists
+ mStackSupervisor.removeStacksInWindowingModes(WINDOWING_MODE_PINNED);
+
+ getLockTaskController().startLockTaskMode(task, isSystemCaller, callingUid);
+ } finally {
+ Binder.restoreCallingIdentity(ident);
+ }
+ }
+
+ private void stopLockTaskModeInternal(@Nullable TaskRecord task, boolean isSystemCaller) {
+ final int callingUid = Binder.getCallingUid();
+ long ident = Binder.clearCallingIdentity();
+ try {
+ synchronized (mGlobalLock) {
+ getLockTaskController().stopLockTaskMode(task, isSystemCaller, callingUid);
+ }
+ // Launch in-call UI if a call is ongoing. This is necessary to allow stopping the lock
+ // task and jumping straight into a call in the case of emergency call back.
+ TelecomManager tm = (TelecomManager) mContext.getSystemService(Context.TELECOM_SERVICE);
+ if (tm != null) {
+ tm.showInCallScreen(false);
+ }
+ } finally {
+ Binder.restoreCallingIdentity(ident);
+ }
+ }
+
+ @Override
+ public void updateLockTaskPackages(int userId, String[] packages) {
+ final int callingUid = Binder.getCallingUid();
+ if (callingUid != 0 && callingUid != SYSTEM_UID) {
+ mAmInternal.enforceCallingPermission(Manifest.permission.UPDATE_LOCK_TASK_PACKAGES,
+ "updateLockTaskPackages()");
+ }
+ synchronized (this) {
+ if (DEBUG_LOCKTASK) Slog.w(TAG_LOCKTASK, "Whitelisting " + userId + ":"
+ + Arrays.toString(packages));
+ getLockTaskController().updateLockTaskPackages(userId, packages);
+ }
+ }
+
+ @Override
+ public boolean isInLockTaskMode() {
+ return getLockTaskModeState() != LOCK_TASK_MODE_NONE;
+ }
+
+ @Override
+ public int getLockTaskModeState() {
+ synchronized (mGlobalLock) {
+ return getLockTaskController().getLockTaskModeState();
+ }
+ }
+
+ @Override
+ public void setTaskDescription(IBinder token, ActivityManager.TaskDescription td) {
+ synchronized (mGlobalLock) {
+ ActivityRecord r = ActivityRecord.isInStackLocked(token);
+ if (r != null) {
+ r.setTaskDescription(td);
+ final TaskRecord task = r.getTask();
+ task.updateTaskDescription();
+ mTaskChangeNotificationController.notifyTaskDescriptionChanged(task.taskId, td);
+ }
+ }
+ }
+
+ @Override
+ public Bundle getActivityOptions(IBinder token) {
+ final long origId = Binder.clearCallingIdentity();
+ try {
+ synchronized (mGlobalLock) {
+ final ActivityRecord r = ActivityRecord.isInStackLocked(token);
+ if (r != null) {
+ final ActivityOptions activityOptions = r.takeOptionsLocked();
+ return activityOptions == null ? null : activityOptions.toBundle();
+ }
+ return null;
+ }
+ } finally {
+ Binder.restoreCallingIdentity(origId);
+ }
+ }
+
+ @Override
+ public List<IBinder> getAppTasks(String callingPackage) {
+ int callingUid = Binder.getCallingUid();
+ long ident = Binder.clearCallingIdentity();
+ try {
+ synchronized (mGlobalLock) {
+ return mRecentTasks.getAppTasksList(callingUid, callingPackage);
+ }
+ } finally {
+ Binder.restoreCallingIdentity(ident);
+ }
+ }
+
+ @Override
+ public void finishVoiceTask(IVoiceInteractionSession session) {
+ synchronized (mGlobalLock) {
+ final long origId = Binder.clearCallingIdentity();
+ try {
+ // TODO: VI Consider treating local voice interactions and voice tasks
+ // differently here
+ mStackSupervisor.finishVoiceTask(session);
+ } finally {
+ Binder.restoreCallingIdentity(origId);
+ }
+ }
+
+ }
+
+ @Override
+ public boolean isTopOfTask(IBinder token) {
+ synchronized (mGlobalLock) {
+ ActivityRecord r = ActivityRecord.isInStackLocked(token);
+ return r != null && r.getTask().getTopActivity() == r;
+ }
+ }
+
+ @Override
+ public void notifyLaunchTaskBehindComplete(IBinder token) {
+ mStackSupervisor.scheduleLaunchTaskBehindComplete(token);
+ }
+
+ @Override
+ public void notifyEnterAnimationComplete(IBinder token) {
+ mH.post(() -> {
+ synchronized (mGlobalLock) {
+ ActivityRecord r = ActivityRecord.forTokenLocked(token);
+ if (r != null && r.attachedToProcess()) {
+ try {
+ r.app.getThread().scheduleEnterAnimationComplete(r.appToken);
+ } catch (RemoteException e) {
+ }
+ }
+ }
+
+ });
+ }
+
+ /** Called from an app when assist data is ready. */
+ @Override
+ public void reportAssistContextExtras(IBinder token, Bundle extras, AssistStructure structure,
+ AssistContent content, Uri referrer) {
+ PendingAssistExtras pae = (PendingAssistExtras) token;
+ synchronized (pae) {
+ pae.result = extras;
+ pae.structure = structure;
+ pae.content = content;
+ if (referrer != null) {
+ pae.extras.putParcelable(Intent.EXTRA_REFERRER, referrer);
+ }
+ if (structure != null) {
+ structure.setHomeActivity(pae.isHome);
+ }
+ pae.haveResult = true;
+ pae.notifyAll();
+ if (pae.intent == null && pae.receiver == null) {
+ // Caller is just waiting for the result.
+ return;
+ }
+ }
+ // We are now ready to launch the assist activity.
+ IAssistDataReceiver sendReceiver = null;
+ Bundle sendBundle = null;
+ synchronized (mGlobalLock) {
+ buildAssistBundleLocked(pae, extras);
+ boolean exists = mPendingAssistExtras.remove(pae);
+ mUiHandler.removeCallbacks(pae);
+ if (!exists) {
+ // Timed out.
+ return;
+ }
+
+ if ((sendReceiver = pae.receiver) != null) {
+ // Caller wants result sent back to them.
+ sendBundle = new Bundle();
+ sendBundle.putBundle(ASSIST_KEY_DATA, pae.extras);
+ sendBundle.putParcelable(ASSIST_KEY_STRUCTURE, pae.structure);
+ sendBundle.putParcelable(ASSIST_KEY_CONTENT, pae.content);
+ sendBundle.putBundle(ASSIST_KEY_RECEIVER_EXTRAS, pae.receiverExtras);
+ }
+ }
+ if (sendReceiver != null) {
+ try {
+ sendReceiver.onHandleAssistData(sendBundle);
+ } catch (RemoteException e) {
+ }
+ return;
+ }
+
+ final long ident = Binder.clearCallingIdentity();
+ try {
+ if (TextUtils.equals(pae.intent.getAction(),
+ android.service.voice.VoiceInteractionService.SERVICE_INTERFACE)) {
+ pae.intent.putExtras(pae.extras);
+ mContext.startServiceAsUser(pae.intent, new UserHandle(pae.userHandle));
+ } else {
+ pae.intent.replaceExtras(pae.extras);
+ pae.intent.setFlags(FLAG_ACTIVITY_NEW_TASK
+ | Intent.FLAG_ACTIVITY_SINGLE_TOP
+ | Intent.FLAG_ACTIVITY_CLEAR_TOP);
+ mInternal.closeSystemDialogs("assist");
+
+ try {
+ mContext.startActivityAsUser(pae.intent, new UserHandle(pae.userHandle));
+ } catch (ActivityNotFoundException e) {
+ Slog.w(TAG, "No activity to handle assist action.", e);
+ }
+ }
+ } finally {
+ Binder.restoreCallingIdentity(ident);
+ }
+ }
+
+ @Override
+ public int addAppTask(IBinder activityToken, Intent intent,
+ ActivityManager.TaskDescription description, Bitmap thumbnail) throws RemoteException {
+ final int callingUid = Binder.getCallingUid();
+ final long callingIdent = Binder.clearCallingIdentity();
+
+ try {
+ synchronized (mGlobalLock) {
+ ActivityRecord r = ActivityRecord.isInStackLocked(activityToken);
+ if (r == null) {
+ throw new IllegalArgumentException("Activity does not exist; token="
+ + activityToken);
+ }
+ ComponentName comp = intent.getComponent();
+ if (comp == null) {
+ throw new IllegalArgumentException("Intent " + intent
+ + " must specify explicit component");
+ }
+ if (thumbnail.getWidth() != mThumbnailWidth
+ || thumbnail.getHeight() != mThumbnailHeight) {
+ throw new IllegalArgumentException("Bad thumbnail size: got "
+ + thumbnail.getWidth() + "x" + thumbnail.getHeight() + ", require "
+ + mThumbnailWidth + "x" + mThumbnailHeight);
+ }
+ if (intent.getSelector() != null) {
+ intent.setSelector(null);
+ }
+ if (intent.getSourceBounds() != null) {
+ intent.setSourceBounds(null);
+ }
+ if ((intent.getFlags()&Intent.FLAG_ACTIVITY_NEW_DOCUMENT) != 0) {
+ if ((intent.getFlags()&Intent.FLAG_ACTIVITY_RETAIN_IN_RECENTS) == 0) {
+ // The caller has added this as an auto-remove task... that makes no
+ // sense, so turn off auto-remove.
+ intent.addFlags(Intent.FLAG_ACTIVITY_RETAIN_IN_RECENTS);
+ }
+ }
+ final ActivityInfo ainfo = AppGlobals.getPackageManager().getActivityInfo(comp,
+ STOCK_PM_FLAGS, UserHandle.getUserId(callingUid));
+ if (ainfo.applicationInfo.uid != callingUid) {
+ throw new SecurityException(
+ "Can't add task for another application: target uid="
+ + ainfo.applicationInfo.uid + ", calling uid=" + callingUid);
+ }
+
+ final ActivityStack stack = r.getStack();
+ final TaskRecord task = stack.createTaskRecord(
+ mStackSupervisor.getNextTaskIdForUserLocked(r.userId), ainfo, intent,
+ null /* voiceSession */, null /* voiceInteractor */, !ON_TOP);
+ if (!mRecentTasks.addToBottom(task)) {
+ // The app has too many tasks already and we can't add any more
+ stack.removeTask(task, "addAppTask", REMOVE_TASK_MODE_DESTROYING);
+ return INVALID_TASK_ID;
+ }
+ task.lastTaskDescription.copyFrom(description);
+
+ // TODO: Send the thumbnail to WM to store it.
+
+ return task.taskId;
+ }
+ } finally {
+ Binder.restoreCallingIdentity(callingIdent);
+ }
+ }
+
+ @Override
+ public Point getAppTaskThumbnailSize() {
+ synchronized (mGlobalLock) {
+ return new Point(mThumbnailWidth, mThumbnailHeight);
+ }
+ }
+
+ @Override
+ public void setTaskResizeable(int taskId, int resizeableMode) {
+ synchronized (mGlobalLock) {
+ final TaskRecord task = mStackSupervisor.anyTaskForIdLocked(
+ taskId, MATCH_TASK_IN_STACKS_OR_RECENT_TASKS);
+ if (task == null) {
+ Slog.w(TAG, "setTaskResizeable: taskId=" + taskId + " not found");
+ return;
+ }
+ task.setResizeMode(resizeableMode);
+ }
+ }
+
+ @Override
+ public void resizeTask(int taskId, Rect bounds, int resizeMode) {
+ mAmInternal.enforceCallingPermission(MANAGE_ACTIVITY_STACKS, "resizeTask()");
+ long ident = Binder.clearCallingIdentity();
+ try {
+ synchronized (mGlobalLock) {
+ final TaskRecord task = mStackSupervisor.anyTaskForIdLocked(taskId,
+ MATCH_TASK_IN_STACKS_ONLY);
+ if (task == null) {
+ Slog.w(TAG, "resizeTask: taskId=" + taskId + " not found");
+ return;
+ }
+ // Place the task in the right stack if it isn't there already based on
+ // the requested bounds.
+ // The stack transition logic is:
+ // - a null bounds on a freeform task moves that task to fullscreen
+ // - a non-null bounds on a non-freeform (fullscreen OR docked) task moves
+ // that task to freeform
+ // - otherwise the task is not moved
+ ActivityStack stack = task.getStack();
+ if (!task.getWindowConfiguration().canResizeTask()) {
+ throw new IllegalArgumentException("resizeTask not allowed on task=" + task);
+ }
+ if (bounds == null && stack.getWindowingMode() == WINDOWING_MODE_FREEFORM) {
+ stack = stack.getDisplay().getOrCreateStack(
+ WINDOWING_MODE_FULLSCREEN, stack.getActivityType(), ON_TOP);
+ } else if (bounds != null && stack.getWindowingMode() != WINDOWING_MODE_FREEFORM) {
+ stack = stack.getDisplay().getOrCreateStack(
+ WINDOWING_MODE_FREEFORM, stack.getActivityType(), ON_TOP);
+ }
+
+ // Reparent the task to the right stack if necessary
+ boolean preserveWindow = (resizeMode & RESIZE_MODE_PRESERVE_WINDOW) != 0;
+ if (stack != task.getStack()) {
+ // Defer resume until the task is resized below
+ task.reparent(stack, ON_TOP, REPARENT_KEEP_STACK_AT_FRONT, ANIMATE,
+ DEFER_RESUME, "resizeTask");
+ preserveWindow = false;
+ }
+
+ // After reparenting (which only resizes the task to the stack bounds), resize the
+ // task to the actual bounds provided
+ task.resize(bounds, resizeMode, preserveWindow, !DEFER_RESUME);
+ }
+ } finally {
+ Binder.restoreCallingIdentity(ident);
+ }
+ }
+
+ @Override
+ public boolean releaseActivityInstance(IBinder token) {
+ synchronized (mGlobalLock) {
+ final long origId = Binder.clearCallingIdentity();
+ try {
+ ActivityRecord r = ActivityRecord.isInStackLocked(token);
+ if (r == null) {
+ return false;
+ }
+ return r.getStack().safelyDestroyActivityLocked(r, "app-req");
+ } finally {
+ Binder.restoreCallingIdentity(origId);
+ }
+ }
+ }
+
+ @Override
+ public void releaseSomeActivities(IApplicationThread appInt) {
+ synchronized (mGlobalLock) {
+ final long origId = Binder.clearCallingIdentity();
+ try {
+ final WindowProcessController app = getProcessController(appInt);
+ mStackSupervisor.releaseSomeActivitiesLocked(app, "low-mem");
+ } finally {
+ Binder.restoreCallingIdentity(origId);
+ }
+ }
+ }
+
+ @Override
+ public void setLockScreenShown(boolean keyguardShowing, boolean aodShowing,
+ int secondaryDisplayShowing) {
+ if (checkCallingPermission(android.Manifest.permission.DEVICE_POWER)
+ != PackageManager.PERMISSION_GRANTED) {
+ throw new SecurityException("Requires permission "
+ + android.Manifest.permission.DEVICE_POWER);
+ }
+
+ synchronized (mGlobalLock) {
+ long ident = Binder.clearCallingIdentity();
+ if (mKeyguardShown != keyguardShowing) {
+ mKeyguardShown = keyguardShowing;
+ final Message msg = PooledLambda.obtainMessage(
+ ActivityManagerInternal::reportCurKeyguardUsageEvent, mAmInternal,
+ keyguardShowing);
+ mH.sendMessage(msg);
+ }
+ try {
+ mKeyguardController.setKeyguardShown(keyguardShowing, aodShowing,
+ secondaryDisplayShowing);
+ } finally {
+ Binder.restoreCallingIdentity(ident);
+ }
+ }
+
+ mH.post(() -> {
+ for (int i = mScreenObservers.size() - 1; i >= 0; i--) {
+ mScreenObservers.get(i).onKeyguardStateChanged(keyguardShowing);
+ }
+ });
+ }
+
+ public void onScreenAwakeChanged(boolean isAwake) {
+ mH.post(() -> {
+ for (int i = mScreenObservers.size() - 1; i >= 0; i--) {
+ mScreenObservers.get(i).onAwakeStateChanged(isAwake);
+ }
+ });
+ }
+
+ @Override
+ public Bitmap getTaskDescriptionIcon(String filePath, int userId) {
+ userId = handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(),
+ userId, "getTaskDescriptionIcon");
+
+ final File passedIconFile = new File(filePath);
+ final File legitIconFile = new File(TaskPersister.getUserImagesDir(userId),
+ passedIconFile.getName());
+ if (!legitIconFile.getPath().equals(filePath)
+ || !filePath.contains(ActivityRecord.ACTIVITY_ICON_SUFFIX)) {
+ throw new IllegalArgumentException("Bad file path: " + filePath
+ + " passed for userId " + userId);
+ }
+ return mRecentTasks.getTaskDescriptionIcon(filePath);
+ }
+
+ @Override
+ public void startInPlaceAnimationOnFrontMostApplication(Bundle opts) {
+ final SafeActivityOptions safeOptions = SafeActivityOptions.fromBundle(opts);
+ final ActivityOptions activityOptions = safeOptions != null
+ ? safeOptions.getOptions(mStackSupervisor)
+ : null;
+ if (activityOptions == null
+ || activityOptions.getAnimationType() != ActivityOptions.ANIM_CUSTOM_IN_PLACE
+ || activityOptions.getCustomInPlaceResId() == 0) {
+ throw new IllegalArgumentException("Expected in-place ActivityOption " +
+ "with valid animation");
+ }
+ // Get top display of front most application.
+ final ActivityStack focusedStack = getTopDisplayFocusedStack();
+ if (focusedStack != null) {
+ final DisplayWindowController dwc =
+ focusedStack.getDisplay().getWindowContainerController();
+ dwc.prepareAppTransition(TRANSIT_TASK_IN_PLACE, false);
+ dwc.overridePendingAppTransitionInPlace(activityOptions.getPackageName(),
+ activityOptions.getCustomInPlaceResId());
+ dwc.executeAppTransition();
+ }
+ }
+
+ @Override
+ public void removeStack(int stackId) {
+ enforceCallerIsRecentsOrHasPermission(MANAGE_ACTIVITY_STACKS, "removeStack()");
+ synchronized (mGlobalLock) {
+ final long ident = Binder.clearCallingIdentity();
+ try {
+ final ActivityStack stack = mStackSupervisor.getStack(stackId);
+ if (stack == null) {
+ Slog.w(TAG, "removeStack: No stack with id=" + stackId);
+ return;
+ }
+ if (!stack.isActivityTypeStandardOrUndefined()) {
+ throw new IllegalArgumentException(
+ "Removing non-standard stack is not allowed.");
+ }
+ mStackSupervisor.removeStack(stack);
+ } finally {
+ Binder.restoreCallingIdentity(ident);
+ }
+ }
+ }
+
+ @Override
+ public void moveStackToDisplay(int stackId, int displayId) {
+ mAmInternal.enforceCallingPermission(INTERNAL_SYSTEM_WINDOW, "moveStackToDisplay()");
+
+ synchronized (mGlobalLock) {
+ final long ident = Binder.clearCallingIdentity();
+ try {
+ if (DEBUG_STACK) Slog.d(TAG_STACK, "moveStackToDisplay: moving stackId=" + stackId
+ + " to displayId=" + displayId);
+ mStackSupervisor.moveStackToDisplayLocked(stackId, displayId, ON_TOP);
+ } finally {
+ Binder.restoreCallingIdentity(ident);
+ }
+ }
+ }
+
+ @Override
+ public void exitFreeformMode(IBinder token) {
+ synchronized (mGlobalLock) {
+ long ident = Binder.clearCallingIdentity();
+ try {
+ final ActivityRecord r = ActivityRecord.forTokenLocked(token);
+ if (r == null) {
+ throw new IllegalArgumentException(
+ "exitFreeformMode: No activity record matching token=" + token);
+ }
+
+ final ActivityStack stack = r.getStack();
+ if (stack == null || !stack.inFreeformWindowingMode()) {
+ throw new IllegalStateException(
+ "exitFreeformMode: You can only go fullscreen from freeform.");
+ }
+
+ stack.setWindowingMode(WINDOWING_MODE_FULLSCREEN);
+ } finally {
+ Binder.restoreCallingIdentity(ident);
+ }
+ }
+ }
+
+ /** Sets the task stack listener that gets callbacks when a task stack changes. */
+ @Override
+ public void registerTaskStackListener(ITaskStackListener listener) {
+ enforceCallerIsRecentsOrHasPermission(MANAGE_ACTIVITY_STACKS,
+ "registerTaskStackListener()");
+ mTaskChangeNotificationController.registerTaskStackListener(listener);
+ }
+
+ /** Unregister a task stack listener so that it stops receiving callbacks. */
+ @Override
+ public void unregisterTaskStackListener(ITaskStackListener listener) {
+ enforceCallerIsRecentsOrHasPermission(MANAGE_ACTIVITY_STACKS,
+ "unregisterTaskStackListener()");
+ mTaskChangeNotificationController.unregisterTaskStackListener(listener);
+ }
+
+ @Override
+ public boolean requestAssistContextExtras(int requestType, IAssistDataReceiver receiver,
+ Bundle receiverExtras, IBinder activityToken, boolean focused, boolean newSessionId) {
+ return enqueueAssistContext(requestType, null, null, receiver, receiverExtras,
+ activityToken, focused, newSessionId, UserHandle.getCallingUserId(), null,
+ PENDING_ASSIST_EXTRAS_LONG_TIMEOUT, 0) != null;
+ }
+
+ @Override
+ public boolean requestAutofillData(IAssistDataReceiver receiver, Bundle receiverExtras,
+ IBinder activityToken, int flags) {
+ return enqueueAssistContext(ActivityManager.ASSIST_CONTEXT_AUTOFILL, null, null,
+ receiver, receiverExtras, activityToken, true, true, UserHandle.getCallingUserId(),
+ null, PENDING_AUTOFILL_ASSIST_STRUCTURE_TIMEOUT, flags) != null;
+ }
+
+ @Override
+ public boolean launchAssistIntent(Intent intent, int requestType, String hint, int userHandle,
+ Bundle args) {
+ return enqueueAssistContext(requestType, intent, hint, null, null, null,
+ true /* focused */, true /* newSessionId */, userHandle, args,
+ PENDING_ASSIST_EXTRAS_TIMEOUT, 0) != null;
+ }
+
+ @Override
+ public Bundle getAssistContextExtras(int requestType) {
+ PendingAssistExtras pae = enqueueAssistContext(requestType, null, null, null,
+ null, null, true /* focused */, true /* newSessionId */,
+ UserHandle.getCallingUserId(), null, PENDING_ASSIST_EXTRAS_TIMEOUT, 0);
+ if (pae == null) {
+ return null;
+ }
+ synchronized (pae) {
+ while (!pae.haveResult) {
+ try {
+ pae.wait();
+ } catch (InterruptedException e) {
+ }
+ }
+ }
+ synchronized (mGlobalLock) {
+ buildAssistBundleLocked(pae, pae.result);
+ mPendingAssistExtras.remove(pae);
+ mUiHandler.removeCallbacks(pae);
+ }
+ return pae.extras;
+ }
+
+ /**
+ * Binder IPC calls go through the public entry point.
+ * This can be called with or without the global lock held.
+ */
+ private static int checkCallingPermission(String permission) {
+ return checkPermission(
+ permission, Binder.getCallingPid(), UserHandle.getAppId(Binder.getCallingUid()));
+ }
+
+ /** This can be called with or without the global lock held. */
+ private void enforceCallerIsRecentsOrHasPermission(String permission, String func) {
+ if (!getRecentTasks().isCallerRecents(Binder.getCallingUid())) {
+ mAmInternal.enforceCallingPermission(permission, func);
+ }
+ }
+
+ @VisibleForTesting
+ int checkGetTasksPermission(String permission, int pid, int uid) {
+ return checkPermission(permission, pid, uid);
+ }
+
+ static int checkPermission(String permission, int pid, int uid) {
+ if (permission == null) {
+ return PackageManager.PERMISSION_DENIED;
+ }
+ return checkComponentPermission(permission, pid, uid, -1, true);
+ }
+
+ public static int checkComponentPermission(String permission, int pid, int uid,
+ int owningUid, boolean exported) {
+ return ActivityManagerService.checkComponentPermission(
+ permission, pid, uid, owningUid, exported);
+ }
+
+ boolean isGetTasksAllowed(String caller, int callingPid, int callingUid) {
+ if (getRecentTasks().isCallerRecents(callingUid)) {
+ // Always allow the recents component to get tasks
+ return true;
+ }
+
+ boolean allowed = checkGetTasksPermission(android.Manifest.permission.REAL_GET_TASKS,
+ callingPid, callingUid) == PackageManager.PERMISSION_GRANTED;
+ if (!allowed) {
+ if (checkGetTasksPermission(android.Manifest.permission.GET_TASKS,
+ callingPid, callingUid) == PackageManager.PERMISSION_GRANTED) {
+ // Temporary compatibility: some existing apps on the system image may
+ // still be requesting the old permission and not switched to the new
+ // one; if so, we'll still allow them full access. This means we need
+ // to see if they are holding the old permission and are a system app.
+ try {
+ if (AppGlobals.getPackageManager().isUidPrivileged(callingUid)) {
+ allowed = true;
+ if (DEBUG_TASKS) Slog.w(TAG, caller + ": caller " + callingUid
+ + " is using old GET_TASKS but privileged; allowing");
+ }
+ } catch (RemoteException e) {
+ }
+ }
+ if (DEBUG_TASKS) Slog.w(TAG, caller + ": caller " + callingUid
+ + " does not hold REAL_GET_TASKS; limiting output");
+ }
+ return allowed;
+ }
+
+ private PendingAssistExtras enqueueAssistContext(int requestType, Intent intent, String hint,
+ IAssistDataReceiver receiver, Bundle receiverExtras, IBinder activityToken,
+ boolean focused, boolean newSessionId, int userHandle, Bundle args, long timeout,
+ int flags) {
+ mAmInternal.enforceCallingPermission(android.Manifest.permission.GET_TOP_ACTIVITY_INFO,
+ "enqueueAssistContext()");
+
+ synchronized (mGlobalLock) {
+ ActivityRecord activity = getTopDisplayFocusedStack().getTopActivity();
+ if (activity == null) {
+ Slog.w(TAG, "getAssistContextExtras failed: no top activity");
+ return null;
+ }
+ if (!activity.attachedToProcess()) {
+ Slog.w(TAG, "getAssistContextExtras failed: no process for " + activity);
+ return null;
+ }
+ if (focused) {
+ if (activityToken != null) {
+ ActivityRecord caller = ActivityRecord.forTokenLocked(activityToken);
+ if (activity != caller) {
+ Slog.w(TAG, "enqueueAssistContext failed: caller " + caller
+ + " is not current top " + activity);
+ return null;
+ }
+ }
+ } else {
+ activity = ActivityRecord.forTokenLocked(activityToken);
+ if (activity == null) {
+ Slog.w(TAG, "enqueueAssistContext failed: activity for token=" + activityToken
+ + " couldn't be found");
+ return null;
+ }
+ if (!activity.attachedToProcess()) {
+ Slog.w(TAG, "enqueueAssistContext failed: no process for " + activity);
+ return null;
+ }
+ }
+
+ PendingAssistExtras pae;
+ Bundle extras = new Bundle();
+ if (args != null) {
+ extras.putAll(args);
+ }
+ extras.putString(Intent.EXTRA_ASSIST_PACKAGE, activity.packageName);
+ extras.putInt(Intent.EXTRA_ASSIST_UID, activity.app.mUid);
+
+ pae = new PendingAssistExtras(activity, extras, intent, hint, receiver, receiverExtras,
+ userHandle);
+ pae.isHome = activity.isActivityTypeHome();
+
+ // Increment the sessionId if necessary
+ if (newSessionId) {
+ mViSessionId++;
+ }
+ try {
+ activity.app.getThread().requestAssistContextExtras(activity.appToken, pae,
+ requestType, mViSessionId, flags);
+ mPendingAssistExtras.add(pae);
+ mUiHandler.postDelayed(pae, timeout);
+ } catch (RemoteException e) {
+ Slog.w(TAG, "getAssistContextExtras failed: crash calling " + activity);
+ return null;
+ }
+ return pae;
+ }
+ }
+
+ private void buildAssistBundleLocked(PendingAssistExtras pae, Bundle result) {
+ if (result != null) {
+ pae.extras.putBundle(Intent.EXTRA_ASSIST_CONTEXT, result);
+ }
+ if (pae.hint != null) {
+ pae.extras.putBoolean(pae.hint, true);
+ }
+ }
+
+ private void pendingAssistExtrasTimedOut(PendingAssistExtras pae) {
+ IAssistDataReceiver receiver;
+ synchronized (mGlobalLock) {
+ mPendingAssistExtras.remove(pae);
+ receiver = pae.receiver;
+ }
+ if (receiver != null) {
+ // Caller wants result sent back to them.
+ Bundle sendBundle = new Bundle();
+ // At least return the receiver extras
+ sendBundle.putBundle(ASSIST_KEY_RECEIVER_EXTRAS, pae.receiverExtras);
+ try {
+ pae.receiver.onHandleAssistData(sendBundle);
+ } catch (RemoteException e) {
+ }
+ }
+ }
+
+ public class PendingAssistExtras extends Binder implements Runnable {
+ public final ActivityRecord activity;
+ public boolean isHome;
+ public final Bundle extras;
+ public final Intent intent;
+ public final String hint;
+ public final IAssistDataReceiver receiver;
+ public final int userHandle;
+ public boolean haveResult = false;
+ public Bundle result = null;
+ public AssistStructure structure = null;
+ public AssistContent content = null;
+ public Bundle receiverExtras;
+
+ public PendingAssistExtras(ActivityRecord _activity, Bundle _extras, Intent _intent,
+ String _hint, IAssistDataReceiver _receiver, Bundle _receiverExtras,
+ int _userHandle) {
+ activity = _activity;
+ extras = _extras;
+ intent = _intent;
+ hint = _hint;
+ receiver = _receiver;
+ receiverExtras = _receiverExtras;
+ userHandle = _userHandle;
+ }
+
+ @Override
+ public void run() {
+ Slog.w(TAG, "getAssistContextExtras failed: timeout retrieving from " + activity);
+ synchronized (this) {
+ haveResult = true;
+ notifyAll();
+ }
+ pendingAssistExtrasTimedOut(this);
+ }
+ }
+
+ @Override
+ public boolean isAssistDataAllowedOnCurrentActivity() {
+ int userId;
+ synchronized (mGlobalLock) {
+ final ActivityStack focusedStack = getTopDisplayFocusedStack();
+ if (focusedStack == null || focusedStack.isActivityTypeAssistant()) {
+ return false;
+ }
+
+ final ActivityRecord activity = focusedStack.getTopActivity();
+ if (activity == null) {
+ return false;
+ }
+ userId = activity.userId;
+ }
+ return !DevicePolicyCache.getInstance().getScreenCaptureDisabled(userId);
+ }
+
+ @Override
+ public boolean showAssistFromActivity(IBinder token, Bundle args) {
+ long ident = Binder.clearCallingIdentity();
+ try {
+ synchronized (mGlobalLock) {
+ ActivityRecord caller = ActivityRecord.forTokenLocked(token);
+ ActivityRecord top = getTopDisplayFocusedStack().getTopActivity();
+ if (top != caller) {
+ Slog.w(TAG, "showAssistFromActivity failed: caller " + caller
+ + " is not current top " + top);
+ return false;
+ }
+ if (!top.nowVisible) {
+ Slog.w(TAG, "showAssistFromActivity failed: caller " + caller
+ + " is not visible");
+ return false;
+ }
+ }
+ return mAssistUtils.showSessionForActiveService(args, SHOW_SOURCE_APPLICATION, null,
+ token);
+ } finally {
+ Binder.restoreCallingIdentity(ident);
+ }
+ }
+
+ @Override
+ public boolean isRootVoiceInteraction(IBinder token) {
+ synchronized (mGlobalLock) {
+ ActivityRecord r = ActivityRecord.isInStackLocked(token);
+ if (r == null) {
+ return false;
+ }
+ return r.rootVoiceInteraction;
+ }
+ }
+
+ private void onLocalVoiceInteractionStartedLocked(IBinder activity,
+ IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor) {
+ ActivityRecord activityToCallback = ActivityRecord.forTokenLocked(activity);
+ if (activityToCallback == null) return;
+ activityToCallback.setVoiceSessionLocked(voiceSession);
+
+ // Inform the activity
+ try {
+ activityToCallback.app.getThread().scheduleLocalVoiceInteractionStarted(activity,
+ voiceInteractor);
+ long token = Binder.clearCallingIdentity();
+ try {
+ startRunningVoiceLocked(voiceSession, activityToCallback.appInfo.uid);
+ } finally {
+ Binder.restoreCallingIdentity(token);
+ }
+ // TODO: VI Should we cache the activity so that it's easier to find later
+ // rather than scan through all the stacks and activities?
+ } catch (RemoteException re) {
+ activityToCallback.clearVoiceSessionLocked();
+ // TODO: VI Should this terminate the voice session?
+ }
+ }
+
+ private void startRunningVoiceLocked(IVoiceInteractionSession session, int targetUid) {
+ Slog.d(TAG, "<<< startRunningVoiceLocked()");
+ mVoiceWakeLock.setWorkSource(new WorkSource(targetUid));
+ if (mRunningVoice == null || mRunningVoice.asBinder() != session.asBinder()) {
+ boolean wasRunningVoice = mRunningVoice != null;
+ mRunningVoice = session;
+ if (!wasRunningVoice) {
+ mVoiceWakeLock.acquire();
+ updateSleepIfNeededLocked();
+ }
+ }
+ }
+
+ void finishRunningVoiceLocked() {
+ if (mRunningVoice != null) {
+ mRunningVoice = null;
+ mVoiceWakeLock.release();
+ updateSleepIfNeededLocked();
+ }
+ }
+
+ @Override
+ public void setVoiceKeepAwake(IVoiceInteractionSession session, boolean keepAwake) {
+ synchronized (mGlobalLock) {
+ if (mRunningVoice != null && mRunningVoice.asBinder() == session.asBinder()) {
+ if (keepAwake) {
+ mVoiceWakeLock.acquire();
+ } else {
+ mVoiceWakeLock.release();
+ }
+ }
+ }
+ }
+
+ @Override
+ public ComponentName getActivityClassForToken(IBinder token) {
+ synchronized (mGlobalLock) {
+ ActivityRecord r = ActivityRecord.isInStackLocked(token);
+ if (r == null) {
+ return null;
+ }
+ return r.intent.getComponent();
+ }
+ }
+
+ @Override
+ public String getPackageForToken(IBinder token) {
+ synchronized (mGlobalLock) {
+ ActivityRecord r = ActivityRecord.isInStackLocked(token);
+ if (r == null) {
+ return null;
+ }
+ return r.packageName;
+ }
+ }
+
+ @Override
+ public void showLockTaskEscapeMessage(IBinder token) {
+ synchronized (mGlobalLock) {
+ final ActivityRecord r = ActivityRecord.forTokenLocked(token);
+ if (r == null) {
+ return;
+ }
+ getLockTaskController().showLockTaskToast();
+ }
+ }
+
+ @Override
+ public void keyguardGoingAway(int flags) {
+ enforceNotIsolatedCaller("keyguardGoingAway");
+ final long token = Binder.clearCallingIdentity();
+ try {
+ synchronized (mGlobalLock) {
+ mKeyguardController.keyguardGoingAway(flags);
+ }
+ } finally {
+ Binder.restoreCallingIdentity(token);
+ }
+ }
+
+ /**
+ * Try to place task to provided position. The final position might be different depending on
+ * current user and stacks state. The task will be moved to target stack if it's currently in
+ * different stack.
+ */
+ @Override
+ public void positionTaskInStack(int taskId, int stackId, int position) {
+ mAmInternal.enforceCallingPermission(MANAGE_ACTIVITY_STACKS, "positionTaskInStack()");
+ synchronized (mGlobalLock) {
+ long ident = Binder.clearCallingIdentity();
+ try {
+ if (DEBUG_STACK) Slog.d(TAG_STACK, "positionTaskInStack: positioning task="
+ + taskId + " in stackId=" + stackId + " at position=" + position);
+ final TaskRecord task = mStackSupervisor.anyTaskForIdLocked(taskId);
+ if (task == null) {
+ throw new IllegalArgumentException("positionTaskInStack: no task for id="
+ + taskId);
+ }
+
+ final ActivityStack stack = mStackSupervisor.getStack(stackId);
+
+ if (stack == null) {
+ throw new IllegalArgumentException("positionTaskInStack: no stack for id="
+ + stackId);
+ }
+ if (!stack.isActivityTypeStandardOrUndefined()) {
+ throw new IllegalArgumentException("positionTaskInStack: Attempt to change"
+ + " the position of task " + taskId + " in/to non-standard stack");
+ }
+
+ // TODO: Have the callers of this API call a separate reparent method if that is
+ // what they intended to do vs. having this method also do reparenting.
+ if (task.getStack() == stack) {
+ // Change position in current stack.
+ stack.positionChildAt(task, position);
+ } else {
+ // Reparent to new stack.
+ task.reparent(stack, position, REPARENT_LEAVE_STACK_IN_PLACE, !ANIMATE,
+ !DEFER_RESUME, "positionTaskInStack");
+ }
+ } finally {
+ Binder.restoreCallingIdentity(ident);
+ }
+ }
+ }
+
+ @Override
+ public void reportSizeConfigurations(IBinder token, int[] horizontalSizeConfiguration,
+ int[] verticalSizeConfigurations, int[] smallestSizeConfigurations) {
+ if (DEBUG_CONFIGURATION) Slog.v(TAG, "Report configuration: " + token + " "
+ + horizontalSizeConfiguration + " " + verticalSizeConfigurations);
+ synchronized (mGlobalLock) {
+ ActivityRecord record = ActivityRecord.isInStackLocked(token);
+ if (record == null) {
+ throw new IllegalArgumentException("reportSizeConfigurations: ActivityRecord not "
+ + "found for: " + token);
+ }
+ record.setSizeConfigurations(horizontalSizeConfiguration,
+ verticalSizeConfigurations, smallestSizeConfigurations);
+ }
+ }
+
+ /**
+ * Dismisses split-screen multi-window mode.
+ * @param toTop If true the current primary split-screen stack will be placed or left on top.
+ */
+ @Override
+ public void dismissSplitScreenMode(boolean toTop) {
+ enforceCallerIsRecentsOrHasPermission(
+ MANAGE_ACTIVITY_STACKS, "dismissSplitScreenMode()");
+ final long ident = Binder.clearCallingIdentity();
+ try {
+ synchronized (mGlobalLock) {
+ final ActivityStack stack =
+ mStackSupervisor.getDefaultDisplay().getSplitScreenPrimaryStack();
+ if (stack == null) {
+ Slog.w(TAG, "dismissSplitScreenMode: primary split-screen stack not found.");
+ return;
+ }
+
+ if (toTop) {
+ // Caller wants the current split-screen primary stack to be the top stack after
+ // it goes fullscreen, so move it to the front.
+ stack.moveToFront("dismissSplitScreenMode");
+ } else if (mStackSupervisor.isTopDisplayFocusedStack(stack)) {
+ // In this case the current split-screen primary stack shouldn't be the top
+ // stack after it goes fullscreen, but it current has focus, so we move the
+ // focus to the top-most split-screen secondary stack next to it.
+ final ActivityStack otherStack = stack.getDisplay().getTopStackInWindowingMode(
+ WINDOWING_MODE_SPLIT_SCREEN_SECONDARY);
+ if (otherStack != null) {
+ otherStack.moveToFront("dismissSplitScreenMode_other");
+ }
+ }
+
+ stack.setWindowingMode(WINDOWING_MODE_UNDEFINED);
+ }
+ } finally {
+ Binder.restoreCallingIdentity(ident);
+ }
+ }
+
+ /**
+ * Dismisses Pip
+ * @param animate True if the dismissal should be animated.
+ * @param animationDuration The duration of the resize animation in milliseconds or -1 if the
+ * default animation duration should be used.
+ */
+ @Override
+ public void dismissPip(boolean animate, int animationDuration) {
+ enforceCallerIsRecentsOrHasPermission(MANAGE_ACTIVITY_STACKS, "dismissPip()");
+ final long ident = Binder.clearCallingIdentity();
+ try {
+ synchronized (mGlobalLock) {
+ final PinnedActivityStack stack =
+ mStackSupervisor.getDefaultDisplay().getPinnedStack();
+ if (stack == null) {
+ Slog.w(TAG, "dismissPip: pinned stack not found.");
+ return;
+ }
+ if (stack.getWindowingMode() != WINDOWING_MODE_PINNED) {
+ throw new IllegalArgumentException("Stack: " + stack
+ + " doesn't support animated resize.");
+ }
+ if (animate) {
+ stack.animateResizePinnedStack(null /* sourceHintBounds */,
+ null /* destBounds */, animationDuration, false /* fromFullscreen */);
+ } else {
+ mStackSupervisor.moveTasksToFullscreenStackLocked(stack, true /* onTop */);
+ }
+ }
+ } finally {
+ Binder.restoreCallingIdentity(ident);
+ }
+ }
+
+ @Override
+ public void suppressResizeConfigChanges(boolean suppress) throws RemoteException {
+ mAmInternal.enforceCallingPermission(MANAGE_ACTIVITY_STACKS, "suppressResizeConfigChanges()");
+ synchronized (mGlobalLock) {
+ mSuppressResizeConfigChanges = suppress;
+ }
+ }
+
+ /**
+ * NOTE: For the pinned stack, this method is usually called after the bounds animation has
+ * animated the stack to the fullscreen, but can also be called if we are relaunching an
+ * activity and clearing the task at the same time.
+ */
+ @Override
+ // TODO: API should just be about changing windowing modes...
+ public void moveTasksToFullscreenStack(int fromStackId, boolean onTop) {
+ enforceCallerIsRecentsOrHasPermission(MANAGE_ACTIVITY_STACKS,
+ "moveTasksToFullscreenStack()");
+ synchronized (mGlobalLock) {
+ final long origId = Binder.clearCallingIdentity();
+ try {
+ final ActivityStack stack = mStackSupervisor.getStack(fromStackId);
+ if (stack != null){
+ if (!stack.isActivityTypeStandardOrUndefined()) {
+ throw new IllegalArgumentException(
+ "You can't move tasks from non-standard stacks.");
+ }
+ mStackSupervisor.moveTasksToFullscreenStackLocked(stack, onTop);
+ }
+ } finally {
+ Binder.restoreCallingIdentity(origId);
+ }
+ }
+ }
+
+ /**
+ * Moves the top activity in the input stackId to the pinned stack.
+ *
+ * @param stackId Id of stack to move the top activity to pinned stack.
+ * @param bounds Bounds to use for pinned stack.
+ *
+ * @return True if the top activity of the input stack was successfully moved to the pinned
+ * stack.
+ */
+ @Override
+ public boolean moveTopActivityToPinnedStack(int stackId, Rect bounds) {
+ enforceCallerIsRecentsOrHasPermission(MANAGE_ACTIVITY_STACKS,
+ "moveTopActivityToPinnedStack()");
+ synchronized (mGlobalLock) {
+ if (!mSupportsPictureInPicture) {
+ throw new IllegalStateException("moveTopActivityToPinnedStack:"
+ + "Device doesn't support picture-in-picture mode");
+ }
+
+ long ident = Binder.clearCallingIdentity();
+ try {
+ return mStackSupervisor.moveTopStackActivityToPinnedStackLocked(stackId, bounds);
+ } finally {
+ Binder.restoreCallingIdentity(ident);
+ }
+ }
+ }
+
+ @Override
+ public boolean isInMultiWindowMode(IBinder token) {
+ final long origId = Binder.clearCallingIdentity();
+ try {
+ synchronized (mGlobalLock) {
+ final ActivityRecord r = ActivityRecord.isInStackLocked(token);
+ if (r == null) {
+ return false;
+ }
+ // An activity is consider to be in multi-window mode if its task isn't fullscreen.
+ return r.inMultiWindowMode();
+ }
+ } finally {
+ Binder.restoreCallingIdentity(origId);
+ }
+ }
+
+ @Override
+ public boolean isInPictureInPictureMode(IBinder token) {
+ final long origId = Binder.clearCallingIdentity();
+ try {
+ synchronized (mGlobalLock) {
+ return isInPictureInPictureMode(ActivityRecord.forTokenLocked(token));
+ }
+ } finally {
+ Binder.restoreCallingIdentity(origId);
+ }
+ }
+
+ private boolean isInPictureInPictureMode(ActivityRecord r) {
+ if (r == null || r.getStack() == null || !r.inPinnedWindowingMode()
+ || r.getStack().isInStackLocked(r) == null) {
+ return false;
+ }
+
+ // If we are animating to fullscreen then we have already dispatched the PIP mode
+ // changed, so we should reflect that check here as well.
+ final PinnedActivityStack stack = r.getStack();
+ final PinnedStackWindowController windowController = stack.getWindowContainerController();
+ return !windowController.isAnimatingBoundsToFullscreen();
+ }
+
+ @Override
+ public boolean enterPictureInPictureMode(IBinder token, final PictureInPictureParams params) {
+ final long origId = Binder.clearCallingIdentity();
+ try {
+ synchronized (mGlobalLock) {
+ final ActivityRecord r = ensureValidPictureInPictureActivityParamsLocked(
+ "enterPictureInPictureMode", token, params);
+
+ // If the activity is already in picture in picture mode, then just return early
+ if (isInPictureInPictureMode(r)) {
+ return true;
+ }
+
+ // Activity supports picture-in-picture, now check that we can enter PiP at this
+ // point, if it is
+ if (!r.checkEnterPictureInPictureState("enterPictureInPictureMode",
+ false /* beforeStopping */)) {
+ return false;
+ }
+
+ final Runnable enterPipRunnable = () -> {
+ synchronized (mGlobalLock) {
+ // Only update the saved args from the args that are set
+ r.pictureInPictureArgs.copyOnlySet(params);
+ final float aspectRatio = r.pictureInPictureArgs.getAspectRatio();
+ final List<RemoteAction> actions = r.pictureInPictureArgs.getActions();
+ // Adjust the source bounds by the insets for the transition down
+ final Rect sourceBounds = new Rect(
+ r.pictureInPictureArgs.getSourceRectHint());
+ mStackSupervisor.moveActivityToPinnedStackLocked(
+ r, sourceBounds, aspectRatio, "enterPictureInPictureMode");
+ final PinnedActivityStack stack = r.getStack();
+ stack.setPictureInPictureAspectRatio(aspectRatio);
+ stack.setPictureInPictureActions(actions);
+ MetricsLoggerWrapper.logPictureInPictureEnter(mContext, r.appInfo.uid,
+ r.shortComponentName, r.supportsEnterPipOnTaskSwitch);
+ logPictureInPictureArgs(params);
+ }
+ };
+
+ if (isKeyguardLocked()) {
+ // If the keyguard is showing or occluded, then try and dismiss it before
+ // entering picture-in-picture (this will prompt the user to authenticate if the
+ // device is currently locked).
+ dismissKeyguard(token, new KeyguardDismissCallback() {
+ @Override
+ public void onDismissSucceeded() {
+ mH.post(enterPipRunnable);
+ }
+ }, null /* message */);
+ } else {
+ // Enter picture in picture immediately otherwise
+ enterPipRunnable.run();
+ }
+ return true;
+ }
+ } finally {
+ Binder.restoreCallingIdentity(origId);
+ }
+ }
+
+ @Override
+ public void setPictureInPictureParams(IBinder token, final PictureInPictureParams params) {
+ final long origId = Binder.clearCallingIdentity();
+ try {
+ synchronized (mGlobalLock) {
+ final ActivityRecord r = ensureValidPictureInPictureActivityParamsLocked(
+ "setPictureInPictureParams", token, params);
+
+ // Only update the saved args from the args that are set
+ r.pictureInPictureArgs.copyOnlySet(params);
+ if (r.inPinnedWindowingMode()) {
+ // If the activity is already in picture-in-picture, update the pinned stack now
+ // if it is not already expanding to fullscreen. Otherwise, the arguments will
+ // be used the next time the activity enters PiP
+ final PinnedActivityStack stack = r.getStack();
+ if (!stack.isAnimatingBoundsToFullscreen()) {
+ stack.setPictureInPictureAspectRatio(
+ r.pictureInPictureArgs.getAspectRatio());
+ stack.setPictureInPictureActions(r.pictureInPictureArgs.getActions());
+ }
+ }
+ logPictureInPictureArgs(params);
+ }
+ } finally {
+ Binder.restoreCallingIdentity(origId);
+ }
+ }
+
+ @Override
+ public int getMaxNumPictureInPictureActions(IBinder token) {
+ // Currently, this is a static constant, but later, we may change this to be dependent on
+ // the context of the activity
+ return 3;
+ }
+
+ private void logPictureInPictureArgs(PictureInPictureParams params) {
+ if (params.hasSetActions()) {
+ MetricsLogger.histogram(mContext, "tron_varz_picture_in_picture_actions_count",
+ params.getActions().size());
+ }
+ if (params.hasSetAspectRatio()) {
+ LogMaker lm = new LogMaker(MetricsEvent.ACTION_PICTURE_IN_PICTURE_ASPECT_RATIO_CHANGED);
+ lm.addTaggedData(MetricsEvent.PICTURE_IN_PICTURE_ASPECT_RATIO, params.getAspectRatio());
+ MetricsLogger.action(lm);
+ }
+ }
+
+ /**
+ * Checks the state of the system and the activity associated with the given {@param token} to
+ * verify that picture-in-picture is supported for that activity.
+ *
+ * @return the activity record for the given {@param token} if all the checks pass.
+ */
+ private ActivityRecord ensureValidPictureInPictureActivityParamsLocked(String caller,
+ IBinder token, PictureInPictureParams params) {
+ if (!mSupportsPictureInPicture) {
+ throw new IllegalStateException(caller
+ + ": Device doesn't support picture-in-picture mode.");
+ }
+
+ final ActivityRecord r = ActivityRecord.forTokenLocked(token);
+ if (r == null) {
+ throw new IllegalStateException(caller
+ + ": Can't find activity for token=" + token);
+ }
+
+ if (!r.supportsPictureInPicture()) {
+ throw new IllegalStateException(caller
+ + ": Current activity does not support picture-in-picture.");
+ }
+
+ if (params.hasSetAspectRatio()
+ && !mWindowManager.isValidPictureInPictureAspectRatio(r.getStack().mDisplayId,
+ params.getAspectRatio())) {
+ final float minAspectRatio = mContext.getResources().getFloat(
+ com.android.internal.R.dimen.config_pictureInPictureMinAspectRatio);
+ final float maxAspectRatio = mContext.getResources().getFloat(
+ com.android.internal.R.dimen.config_pictureInPictureMaxAspectRatio);
+ throw new IllegalArgumentException(String.format(caller
+ + ": Aspect ratio is too extreme (must be between %f and %f).",
+ minAspectRatio, maxAspectRatio));
+ }
+
+ // Truncate the number of actions if necessary
+ params.truncateActions(getMaxNumPictureInPictureActions(token));
+
+ return r;
+ }
+
+ @Override
+ public IBinder getUriPermissionOwnerForActivity(IBinder activityToken) {
+ enforceNotIsolatedCaller("getUriPermissionOwnerForActivity");
+ synchronized (mGlobalLock) {
+ ActivityRecord r = ActivityRecord.isInStackLocked(activityToken);
+ if (r == null) {
+ throw new IllegalArgumentException("Activity does not exist; token="
+ + activityToken);
+ }
+ return r.getUriPermissionsLocked().getExternalToken();
+ }
+ }
+
+ @Override
+ public void resizeDockedStack(Rect dockedBounds, Rect tempDockedTaskBounds,
+ Rect tempDockedTaskInsetBounds,
+ Rect tempOtherTaskBounds, Rect tempOtherTaskInsetBounds) {
+ enforceCallerIsRecentsOrHasPermission(MANAGE_ACTIVITY_STACKS, "resizeDockedStack()");
+ long ident = Binder.clearCallingIdentity();
+ try {
+ synchronized (mGlobalLock) {
+ mStackSupervisor.resizeDockedStackLocked(dockedBounds, tempDockedTaskBounds,
+ tempDockedTaskInsetBounds, tempOtherTaskBounds, tempOtherTaskInsetBounds,
+ PRESERVE_WINDOWS);
+ }
+ } finally {
+ Binder.restoreCallingIdentity(ident);
+ }
+ }
+
+ @Override
+ public void setSplitScreenResizing(boolean resizing) {
+ enforceCallerIsRecentsOrHasPermission(MANAGE_ACTIVITY_STACKS, "setSplitScreenResizing()");
+ final long ident = Binder.clearCallingIdentity();
+ try {
+ synchronized (mGlobalLock) {
+ mStackSupervisor.setSplitScreenResizing(resizing);
+ }
+ } finally {
+ Binder.restoreCallingIdentity(ident);
+ }
+ }
+
+ /**
+ * Check that we have the features required for VR-related API calls, and throw an exception if
+ * not.
+ */
+ public void enforceSystemHasVrFeature() {
+ if (!mContext.getPackageManager().hasSystemFeature(
+ PackageManager.FEATURE_VR_MODE_HIGH_PERFORMANCE)) {
+ throw new UnsupportedOperationException("VR mode not supported on this device!");
+ }
+ }
+
+ @Override
+ public int setVrMode(IBinder token, boolean enabled, ComponentName packageName) {
+ enforceSystemHasVrFeature();
+
+ final VrManagerInternal vrService = LocalServices.getService(VrManagerInternal.class);
+
+ ActivityRecord r;
+ synchronized (mGlobalLock) {
+ r = ActivityRecord.isInStackLocked(token);
+ }
+
+ if (r == null) {
+ throw new IllegalArgumentException();
+ }
+
+ int err;
+ if ((err = vrService.hasVrPackage(packageName, r.userId)) !=
+ VrManagerInternal.NO_ERROR) {
+ return err;
+ }
+
+ // Clear the binder calling uid since this path may call moveToTask().
+ final long callingId = Binder.clearCallingIdentity();
+ try {
+ synchronized (mGlobalLock) {
+ r.requestedVrComponent = (enabled) ? packageName : null;
+
+ // Update associated state if this activity is currently focused
+ if (r.isResumedActivityOnDisplay()) {
+ applyUpdateVrModeLocked(r);
+ }
+ return 0;
+ }
+ } finally {
+ Binder.restoreCallingIdentity(callingId);
+ }
+ }
+
+ @Override
+ public void startLocalVoiceInteraction(IBinder callingActivity, Bundle options) {
+ Slog.i(TAG, "Activity tried to startLocalVoiceInteraction");
+ synchronized (mGlobalLock) {
+ ActivityRecord activity = getTopDisplayFocusedStack().getTopActivity();
+ if (ActivityRecord.forTokenLocked(callingActivity) != activity) {
+ throw new SecurityException("Only focused activity can call startVoiceInteraction");
+ }
+ if (mRunningVoice != null || activity.getTask().voiceSession != null
+ || activity.voiceSession != null) {
+ Slog.w(TAG, "Already in a voice interaction, cannot start new voice interaction");
+ return;
+ }
+ if (activity.pendingVoiceInteractionStart) {
+ Slog.w(TAG, "Pending start of voice interaction already.");
+ return;
+ }
+ activity.pendingVoiceInteractionStart = true;
+ }
+ LocalServices.getService(VoiceInteractionManagerInternal.class)
+ .startLocalVoiceInteraction(callingActivity, options);
+ }
+
+ @Override
+ public void stopLocalVoiceInteraction(IBinder callingActivity) {
+ LocalServices.getService(VoiceInteractionManagerInternal.class)
+ .stopLocalVoiceInteraction(callingActivity);
+ }
+
+ @Override
+ public boolean supportsLocalVoiceInteraction() {
+ return LocalServices.getService(VoiceInteractionManagerInternal.class)
+ .supportsLocalVoiceInteraction();
+ }
+
+ /** Notifies all listeners when the pinned stack animation starts. */
+ @Override
+ public void notifyPinnedStackAnimationStarted() {
+ mTaskChangeNotificationController.notifyPinnedStackAnimationStarted();
+ }
+
+ /** Notifies all listeners when the pinned stack animation ends. */
+ @Override
+ public void notifyPinnedStackAnimationEnded() {
+ mTaskChangeNotificationController.notifyPinnedStackAnimationEnded();
+ }
+
+ @Override
+ public void resizePinnedStack(Rect pinnedBounds, Rect tempPinnedTaskBounds) {
+ enforceCallerIsRecentsOrHasPermission(MANAGE_ACTIVITY_STACKS, "resizePinnedStack()");
+ final long ident = Binder.clearCallingIdentity();
+ try {
+ synchronized (mGlobalLock) {
+ mStackSupervisor.resizePinnedStackLocked(pinnedBounds, tempPinnedTaskBounds);
+ }
+ } finally {
+ Binder.restoreCallingIdentity(ident);
+ }
+ }
+
+ @Override
+ public boolean updateDisplayOverrideConfiguration(Configuration values, int displayId) {
+ mAmInternal.enforceCallingPermission(CHANGE_CONFIGURATION, "updateDisplayOverrideConfiguration()");
+
+ synchronized (mGlobalLock) {
+ // Check if display is initialized in AM.
+ if (!mStackSupervisor.isDisplayAdded(displayId)) {
+ // Call might come when display is not yet added or has already been removed.
+ if (DEBUG_CONFIGURATION) {
+ Slog.w(TAG, "Trying to update display configuration for non-existing displayId="
+ + displayId);
+ }
+ return false;
+ }
+
+ if (values == null && mWindowManager != null) {
+ // sentinel: fetch the current configuration from the window manager
+ values = mWindowManager.computeNewConfiguration(displayId);
+ }
+
+ if (mWindowManager != null) {
+ final Message msg = PooledLambda.obtainMessage(
+ ActivityManagerInternal::updateOomLevelsForDisplay, mAmInternal, displayId);
+ mH.sendMessage(msg);
+ }
+
+ final long origId = Binder.clearCallingIdentity();
+ try {
+ if (values != null) {
+ Settings.System.clearConfiguration(values);
+ }
+ updateDisplayOverrideConfigurationLocked(values, null /* starting */,
+ false /* deferResume */, displayId, mTmpUpdateConfigurationResult);
+ return mTmpUpdateConfigurationResult.changes != 0;
+ } finally {
+ Binder.restoreCallingIdentity(origId);
+ }
+ }
+ }
+
+ @Override
+ public boolean updateConfiguration(Configuration values) {
+ mAmInternal.enforceCallingPermission(CHANGE_CONFIGURATION, "updateConfiguration()");
+
+ synchronized (mGlobalLock) {
+ if (values == null && mWindowManager != null) {
+ // sentinel: fetch the current configuration from the window manager
+ values = mWindowManager.computeNewConfiguration(DEFAULT_DISPLAY);
+ }
+
+ if (mWindowManager != null) {
+ final Message msg = PooledLambda.obtainMessage(
+ ActivityManagerInternal::updateOomLevelsForDisplay, mAmInternal,
+ DEFAULT_DISPLAY);
+ mH.sendMessage(msg);
+ }
+
+ final long origId = Binder.clearCallingIdentity();
+ try {
+ if (values != null) {
+ Settings.System.clearConfiguration(values);
+ }
+ updateConfigurationLocked(values, null, false, false /* persistent */,
+ UserHandle.USER_NULL, false /* deferResume */,
+ mTmpUpdateConfigurationResult);
+ return mTmpUpdateConfigurationResult.changes != 0;
+ } finally {
+ Binder.restoreCallingIdentity(origId);
+ }
+ }
+ }
+
+ @Override
+ public void dismissKeyguard(IBinder token, IKeyguardDismissCallback callback,
+ CharSequence message) {
+ if (message != null) {
+ mAmInternal.enforceCallingPermission(
+ Manifest.permission.SHOW_KEYGUARD_MESSAGE, "dismissKeyguard()");
+ }
+ final long callingId = Binder.clearCallingIdentity();
+ try {
+ synchronized (mGlobalLock) {
+ mKeyguardController.dismissKeyguard(token, callback, message);
+ }
+ } finally {
+ Binder.restoreCallingIdentity(callingId);
+ }
+ }
+
+ @Override
+ public void cancelTaskWindowTransition(int taskId) {
+ enforceCallerIsRecentsOrHasPermission(MANAGE_ACTIVITY_STACKS,
+ "cancelTaskWindowTransition()");
+ final long ident = Binder.clearCallingIdentity();
+ try {
+ synchronized (mGlobalLock) {
+ final TaskRecord task = mStackSupervisor.anyTaskForIdLocked(taskId,
+ MATCH_TASK_IN_STACKS_ONLY);
+ if (task == null) {
+ Slog.w(TAG, "cancelTaskWindowTransition: taskId=" + taskId + " not found");
+ return;
+ }
+ task.cancelWindowTransition();
+ }
+ } finally {
+ Binder.restoreCallingIdentity(ident);
+ }
+ }
+
+ @Override
+ public ActivityManager.TaskSnapshot getTaskSnapshot(int taskId, boolean reducedResolution) {
+ enforceCallerIsRecentsOrHasPermission(READ_FRAME_BUFFER, "getTaskSnapshot()");
+ final long ident = Binder.clearCallingIdentity();
+ try {
+ final TaskRecord task;
+ synchronized (mGlobalLock) {
+ task = mStackSupervisor.anyTaskForIdLocked(taskId,
+ MATCH_TASK_IN_STACKS_OR_RECENT_TASKS);
+ if (task == null) {
+ Slog.w(TAG, "getTaskSnapshot: taskId=" + taskId + " not found");
+ return null;
+ }
+ }
+ // Don't call this while holding the lock as this operation might hit the disk.
+ return task.getSnapshot(reducedResolution);
+ } finally {
+ Binder.restoreCallingIdentity(ident);
+ }
+ }
+
+ @Override
+ public void setDisablePreviewScreenshots(IBinder token, boolean disable) {
+ synchronized (mGlobalLock) {
+ final ActivityRecord r = ActivityRecord.isInStackLocked(token);
+ if (r == null) {
+ Slog.w(TAG, "setDisablePreviewScreenshots: Unable to find activity for token="
+ + token);
+ return;
+ }
+ final long origId = Binder.clearCallingIdentity();
+ try {
+ r.setDisablePreviewScreenshots(disable);
+ } finally {
+ Binder.restoreCallingIdentity(origId);
+ }
+ }
+ }
+
+ /** Return the user id of the last resumed activity. */
+ @Override
+ public @UserIdInt
+ int getLastResumedActivityUserId() {
+ mAmInternal.enforceCallingPermission(
+ Manifest.permission.INTERACT_ACROSS_USERS_FULL, "getLastResumedActivityUserId()");
+ synchronized (mGlobalLock) {
+ if (mLastResumedActivity == null) {
+ return getCurrentUserId();
+ }
+ return mLastResumedActivity.userId;
+ }
+ }
+
+ @Override
+ public void updateLockTaskFeatures(int userId, int flags) {
+ final int callingUid = Binder.getCallingUid();
+ if (callingUid != 0 && callingUid != SYSTEM_UID) {
+ mAmInternal.enforceCallingPermission(android.Manifest.permission.UPDATE_LOCK_TASK_PACKAGES,
+ "updateLockTaskFeatures()");
+ }
+ synchronized (mGlobalLock) {
+ if (DEBUG_LOCKTASK) Slog.w(TAG_LOCKTASK, "Allowing features " + userId + ":0x" +
+ Integer.toHexString(flags));
+ getLockTaskController().updateLockTaskFeatures(userId, flags);
+ }
+ }
+
+ @Override
+ public void setShowWhenLocked(IBinder token, boolean showWhenLocked) {
+ synchronized (mGlobalLock) {
+ final ActivityRecord r = ActivityRecord.isInStackLocked(token);
+ if (r == null) {
+ return;
+ }
+ final long origId = Binder.clearCallingIdentity();
+ try {
+ r.setShowWhenLocked(showWhenLocked);
+ } finally {
+ Binder.restoreCallingIdentity(origId);
+ }
+ }
+ }
+
+ @Override
+ public void setTurnScreenOn(IBinder token, boolean turnScreenOn) {
+ synchronized (mGlobalLock) {
+ final ActivityRecord r = ActivityRecord.isInStackLocked(token);
+ if (r == null) {
+ return;
+ }
+ final long origId = Binder.clearCallingIdentity();
+ try {
+ r.setTurnScreenOn(turnScreenOn);
+ } finally {
+ Binder.restoreCallingIdentity(origId);
+ }
+ }
+ }
+
+ @Override
+ public void registerRemoteAnimations(IBinder token, RemoteAnimationDefinition definition) {
+ mAmInternal.enforceCallingPermission(CONTROL_REMOTE_APP_TRANSITION_ANIMATIONS,
+ "registerRemoteAnimations");
+ definition.setCallingPid(Binder.getCallingPid());
+ synchronized (mGlobalLock) {
+ final ActivityRecord r = ActivityRecord.isInStackLocked(token);
+ if (r == null) {
+ return;
+ }
+ final long origId = Binder.clearCallingIdentity();
+ try {
+ r.registerRemoteAnimations(definition);
+ } finally {
+ Binder.restoreCallingIdentity(origId);
+ }
+ }
+ }
+
+ @Override
+ public void registerRemoteAnimationForNextActivityStart(String packageName,
+ RemoteAnimationAdapter adapter) {
+ mAmInternal.enforceCallingPermission(CONTROL_REMOTE_APP_TRANSITION_ANIMATIONS,
+ "registerRemoteAnimationForNextActivityStart");
+ adapter.setCallingPid(Binder.getCallingPid());
+ synchronized (mGlobalLock) {
+ final long origId = Binder.clearCallingIdentity();
+ try {
+ getActivityStartController().registerRemoteAnimationForNextActivityStart(
+ packageName, adapter);
+ } finally {
+ Binder.restoreCallingIdentity(origId);
+ }
+ }
+ }
+
+ /** @see android.app.ActivityManager#alwaysShowUnsupportedCompileSdkWarning */
+ @Override
+ public void alwaysShowUnsupportedCompileSdkWarning(ComponentName activity) {
+ synchronized (mGlobalLock) {
+ final long origId = Binder.clearCallingIdentity();
+ try {
+ mAppWarnings.alwaysShowUnsupportedCompileSdkWarning(activity);
+ } finally {
+ Binder.restoreCallingIdentity(origId);
+ }
+ }
+ }
+
+ @Override
+ public void setVrThread(int tid) {
+ enforceSystemHasVrFeature();
+ synchronized (mGlobalLock) {
+ final int pid = Binder.getCallingPid();
+ final WindowProcessController wpc = mPidMap.get(pid);
+ mVrController.setVrThreadLocked(tid, pid, wpc);
+ }
+ }
+
+ @Override
+ public void setPersistentVrThread(int tid) {
+ if (checkCallingPermission(Manifest.permission.RESTRICTED_VR_ACCESS)
+ != PERMISSION_GRANTED) {
+ final String msg = "Permission Denial: setPersistentVrThread() from pid="
+ + Binder.getCallingPid()
+ + ", uid=" + Binder.getCallingUid()
+ + " requires " + Manifest.permission.RESTRICTED_VR_ACCESS;
+ Slog.w(TAG, msg);
+ throw new SecurityException(msg);
+ }
+ enforceSystemHasVrFeature();
+ synchronized (mGlobalLock) {
+ final int pid = Binder.getCallingPid();
+ final WindowProcessController proc = mPidMap.get(pid);
+ mVrController.setPersistentVrThreadLocked(tid, pid, proc);
+ }
+ }
+
+ @Override
+ public void stopAppSwitches() {
+ enforceCallerIsRecentsOrHasPermission(STOP_APP_SWITCHES, "stopAppSwitches");
+ synchronized (mGlobalLock) {
+ mAppSwitchesAllowedTime = SystemClock.uptimeMillis() + APP_SWITCH_DELAY_TIME;
+ mDidAppSwitch = false;
+ getActivityStartController().schedulePendingActivityLaunches(APP_SWITCH_DELAY_TIME);
+ }
+ }
+
+ @Override
+ public void resumeAppSwitches() {
+ enforceCallerIsRecentsOrHasPermission(STOP_APP_SWITCHES, "resumeAppSwitches");
+ synchronized (mGlobalLock) {
+ // Note that we don't execute any pending app switches... we will
+ // let those wait until either the timeout, or the next start
+ // activity request.
+ mAppSwitchesAllowedTime = 0;
+ }
+ }
+
+ void onStartActivitySetDidAppSwitch() {
+ if (mDidAppSwitch) {
+ // This is the second allowed switch since we stopped switches, so now just generally
+ // allow switches. Use case:
+ // - user presses home (switches disabled, switch to home, mDidAppSwitch now true);
+ // - user taps a home icon (coming from home so allowed, we hit here and now allow
+ // anyone to switch again).
+ mAppSwitchesAllowedTime = 0;
+ } else {
+ mDidAppSwitch = true;
+ }
+ }
+
+ /** @return whether the system should disable UI modes incompatible with VR mode. */
+ boolean shouldDisableNonVrUiLocked() {
+ return mVrController.shouldDisableNonVrUiLocked();
+ }
+
+ private void applyUpdateVrModeLocked(ActivityRecord r) {
+ // VR apps are expected to run in a main display. If an app is turning on VR for
+ // itself, but lives in a dynamic stack, then make sure that it is moved to the main
+ // fullscreen stack before enabling VR Mode.
+ // TODO: The goal of this code is to keep the VR app on the main display. When the
+ // stack implementation changes in the future, keep in mind that the use of the fullscreen
+ // stack is a means to move the activity to the main display and a moveActivityToDisplay()
+ // option would be a better choice here.
+ if (r.requestedVrComponent != null && r.getDisplayId() != DEFAULT_DISPLAY) {
+ Slog.i(TAG, "Moving " + r.shortComponentName + " from stack " + r.getStackId()
+ + " to main stack for VR");
+ final ActivityStack stack = mStackSupervisor.getDefaultDisplay().getOrCreateStack(
+ WINDOWING_MODE_FULLSCREEN, r.getActivityType(), true /* toTop */);
+ moveTaskToStack(r.getTask().taskId, stack.mStackId, true /* toTop */);
+ }
+ mH.post(() -> {
+ if (!mVrController.onVrModeChanged(r)) {
+ return;
+ }
+ synchronized (mGlobalLock) {
+ final boolean disableNonVrUi = mVrController.shouldDisableNonVrUiLocked();
+ mWindowManager.disableNonVrUi(disableNonVrUi);
+ if (disableNonVrUi) {
+ // If we are in a VR mode where Picture-in-Picture mode is unsupported,
+ // then remove the pinned stack.
+ mStackSupervisor.removeStacksInWindowingModes(WINDOWING_MODE_PINNED);
+ }
+ }
+ });
+ }
+
+ @Override
+ public int getPackageScreenCompatMode(String packageName) {
+ enforceNotIsolatedCaller("getPackageScreenCompatMode");
+ synchronized (mGlobalLock) {
+ return mCompatModePackages.getPackageScreenCompatModeLocked(packageName);
+ }
+ }
+
+ @Override
+ public void setPackageScreenCompatMode(String packageName, int mode) {
+ mAmInternal.enforceCallingPermission(android.Manifest.permission.SET_SCREEN_COMPATIBILITY,
+ "setPackageScreenCompatMode");
+ synchronized (mGlobalLock) {
+ mCompatModePackages.setPackageScreenCompatModeLocked(packageName, mode);
+ }
+ }
+
+ @Override
+ public boolean getPackageAskScreenCompat(String packageName) {
+ enforceNotIsolatedCaller("getPackageAskScreenCompat");
+ synchronized (mGlobalLock) {
+ return mCompatModePackages.getPackageAskCompatModeLocked(packageName);
+ }
+ }
+
+ @Override
+ public void setPackageAskScreenCompat(String packageName, boolean ask) {
+ mAmInternal.enforceCallingPermission(android.Manifest.permission.SET_SCREEN_COMPATIBILITY,
+ "setPackageAskScreenCompat");
+ synchronized (mGlobalLock) {
+ mCompatModePackages.setPackageAskCompatModeLocked(packageName, ask);
+ }
+ }
+
+ public static String relaunchReasonToString(int relaunchReason) {
+ switch (relaunchReason) {
+ case RELAUNCH_REASON_WINDOWING_MODE_RESIZE:
+ return "window_resize";
+ case RELAUNCH_REASON_FREE_RESIZE:
+ return "free_resize";
+ default:
+ return null;
+ }
+ }
+
+ ActivityStack getTopDisplayFocusedStack() {
+ return mStackSupervisor.getTopDisplayFocusedStack();
+ }
+
+ /** Pokes the task persister. */
+ void notifyTaskPersisterLocked(TaskRecord task, boolean flush) {
+ mRecentTasks.notifyTaskPersisterLocked(task, flush);
+ }
+
+ boolean isKeyguardLocked() {
+ return mKeyguardController.isKeyguardLocked();
+ }
+
+ void dumpLastANRLocked(PrintWriter pw) {
+ pw.println("ACTIVITY MANAGER LAST ANR (dumpsys activity lastanr)");
+ if (mLastANRState == null) {
+ pw.println(" <no ANR has occurred since boot>");
+ } else {
+ pw.println(mLastANRState);
+ }
+ }
+
+ void dumpLastANRTracesLocked(PrintWriter pw) {
+ pw.println("ACTIVITY MANAGER LAST ANR TRACES (dumpsys activity lastanr-traces)");
+
+ final File[] files = new File(ANR_TRACE_DIR).listFiles();
+ if (ArrayUtils.isEmpty(files)) {
+ pw.println(" <no ANR has occurred since boot>");
+ return;
+ }
+ // Find the latest file.
+ File latest = null;
+ for (File f : files) {
+ if ((latest == null) || (latest.lastModified() < f.lastModified())) {
+ latest = f;
+ }
+ }
+ pw.print("File: ");
+ pw.print(latest.getName());
+ pw.println();
+ try (BufferedReader in = new BufferedReader(new FileReader(latest))) {
+ String line;
+ while ((line = in.readLine()) != null) {
+ pw.println(line);
+ }
+ } catch (IOException e) {
+ pw.print("Unable to read: ");
+ pw.print(e);
+ pw.println();
+ }
+ }
+
+ void dumpActivitiesLocked(FileDescriptor fd, PrintWriter pw, String[] args,
+ int opti, boolean dumpAll, boolean dumpClient, String dumpPackage) {
+ dumpActivitiesLocked(fd, pw, args, opti, dumpAll, dumpClient, dumpPackage,
+ "ACTIVITY MANAGER ACTIVITIES (dumpsys activity activities)");
+ }
+
+ void dumpActivitiesLocked(FileDescriptor fd, PrintWriter pw, String[] args,
+ int opti, boolean dumpAll, boolean dumpClient, String dumpPackage, String header) {
+ pw.println(header);
+
+ boolean printedAnything = mStackSupervisor.dumpActivitiesLocked(fd, pw, dumpAll, dumpClient,
+ dumpPackage);
+ boolean needSep = printedAnything;
+
+ boolean printed = ActivityStackSupervisor.printThisActivity(pw,
+ mStackSupervisor.getTopResumedActivity(), dumpPackage, needSep,
+ " ResumedActivity: ");
+ if (printed) {
+ printedAnything = true;
+ needSep = false;
+ }
+
+ if (dumpPackage == null) {
+ if (needSep) {
+ pw.println();
+ }
+ printedAnything = true;
+ mStackSupervisor.dump(pw, " ");
+ }
+
+ if (!printedAnything) {
+ pw.println(" (nothing)");
+ }
+ }
+
+ void dumpActivityContainersLocked(PrintWriter pw) {
+ pw.println("ACTIVITY MANAGER STARTER (dumpsys activity containers)");
+ mStackSupervisor.dumpChildrenNames(pw, " ");
+ pw.println(" ");
+ }
+
+ void dumpActivityStarterLocked(PrintWriter pw, String dumpPackage) {
+ pw.println("ACTIVITY MANAGER STARTER (dumpsys activity starter)");
+ getActivityStartController().dump(pw, "", dumpPackage);
+ }
+
+ /**
+ * There are three things that cmd can be:
+ * - a flattened component name that matches an existing activity
+ * - the cmd arg isn't the flattened component name of an existing activity:
+ * dump all activity whose component contains the cmd as a substring
+ * - A hex number of the ActivityRecord object instance.
+ *
+ * @param dumpVisibleStacksOnly dump activity with {@param name} only if in a visible stack
+ * @param dumpFocusedStackOnly dump activity with {@param name} only if in the focused stack
+ */
+ protected boolean dumpActivity(FileDescriptor fd, PrintWriter pw, String name, String[] args,
+ int opti, boolean dumpAll, boolean dumpVisibleStacksOnly, boolean dumpFocusedStackOnly) {
+ ArrayList<ActivityRecord> activities;
+
+ synchronized (mGlobalLock) {
+ activities = mStackSupervisor.getDumpActivitiesLocked(name, dumpVisibleStacksOnly,
+ dumpFocusedStackOnly);
+ }
+
+ if (activities.size() <= 0) {
+ return false;
+ }
+
+ String[] newArgs = new String[args.length - opti];
+ System.arraycopy(args, opti, newArgs, 0, args.length - opti);
+
+ TaskRecord lastTask = null;
+ boolean needSep = false;
+ for (int i = activities.size() - 1; i >= 0; i--) {
+ ActivityRecord r = activities.get(i);
+ if (needSep) {
+ pw.println();
+ }
+ needSep = true;
+ synchronized (mGlobalLock) {
+ final TaskRecord task = r.getTask();
+ if (lastTask != task) {
+ lastTask = task;
+ pw.print("TASK "); pw.print(lastTask.affinity);
+ pw.print(" id="); pw.print(lastTask.taskId);
+ pw.print(" userId="); pw.println(lastTask.userId);
+ if (dumpAll) {
+ lastTask.dump(pw, " ");
+ }
+ }
+ }
+ dumpActivity(" ", fd, pw, activities.get(i), newArgs, dumpAll);
+ }
+ return true;
+ }
+
+ /**
+ * Invokes IApplicationThread.dumpActivity() on the thread of the specified activity if
+ * there is a thread associated with the activity.
+ */
+ private void dumpActivity(String prefix, FileDescriptor fd, PrintWriter pw,
+ final ActivityRecord r, String[] args, boolean dumpAll) {
+ String innerPrefix = prefix + " ";
+ synchronized (mGlobalLock) {
+ pw.print(prefix); pw.print("ACTIVITY "); pw.print(r.shortComponentName);
+ pw.print(" "); pw.print(Integer.toHexString(System.identityHashCode(r)));
+ pw.print(" pid=");
+ if (r.hasProcess()) pw.println(r.app.getPid());
+ else pw.println("(not running)");
+ if (dumpAll) {
+ r.dump(pw, innerPrefix);
+ }
+ }
+ if (r.attachedToProcess()) {
+ // flush anything that is already in the PrintWriter since the thread is going
+ // to write to the file descriptor directly
+ pw.flush();
+ try {
+ TransferPipe tp = new TransferPipe();
+ try {
+ r.app.getThread().dumpActivity(tp.getWriteFd(),
+ r.appToken, innerPrefix, args);
+ tp.go(fd);
+ } finally {
+ tp.kill();
+ }
+ } catch (IOException e) {
+ pw.println(innerPrefix + "Failure while dumping the activity: " + e);
+ } catch (RemoteException e) {
+ pw.println(innerPrefix + "Got a RemoteException while dumping the activity");
+ }
+ }
+ }
+
+ void writeSleepStateToProto(ProtoOutputStream proto) {
+ for (ActivityTaskManagerInternal.SleepToken st : mStackSupervisor.mSleepTokens) {
+ proto.write(ActivityManagerServiceDumpProcessesProto.SleepStatus.SLEEP_TOKENS,
+ st.toString());
+ }
+
+ if (mRunningVoice != null) {
+ final long vrToken = proto.start(
+ ActivityManagerServiceDumpProcessesProto.RUNNING_VOICE);
+ proto.write(ActivityManagerServiceDumpProcessesProto.Voice.SESSION,
+ mRunningVoice.toString());
+ mVoiceWakeLock.writeToProto(
+ proto, ActivityManagerServiceDumpProcessesProto.Voice.WAKELOCK);
+ proto.end(vrToken);
+ }
+
+ proto.write(ActivityManagerServiceDumpProcessesProto.SleepStatus.SLEEPING, mSleeping);
+ proto.write(ActivityManagerServiceDumpProcessesProto.SleepStatus.SHUTTING_DOWN,
+ mShuttingDown);
+ mVrController.writeToProto(proto, ActivityManagerServiceDumpProcessesProto.VR_CONTROLLER);
+ }
+
+ int getCurrentUserId() {
+ return mAmInternal.getCurrentUserId();
+ }
+
+ private void enforceNotIsolatedCaller(String caller) {
+ if (UserHandle.isIsolated(Binder.getCallingUid())) {
+ throw new SecurityException("Isolated process not allowed to call " + caller);
+ }
+ }
+
+ public Configuration getConfiguration() {
+ Configuration ci;
+ synchronized(mGlobalLock) {
+ ci = new Configuration(getGlobalConfigurationForCallingPid());
+ ci.userSetLocale = false;
+ }
+ return ci;
+ }
+
+ /**
+ * Current global configuration information. Contains general settings for the entire system,
+ * also corresponds to the merged configuration of the default display.
+ */
+ Configuration getGlobalConfiguration() {
+ return mStackSupervisor.getConfiguration();
+ }
+
+ boolean updateConfigurationLocked(Configuration values, ActivityRecord starting,
+ boolean initLocale) {
+ return updateConfigurationLocked(values, starting, initLocale, false /* deferResume */);
+ }
+
+ boolean updateConfigurationLocked(Configuration values, ActivityRecord starting,
+ boolean initLocale, boolean deferResume) {
+ // pass UserHandle.USER_NULL as userId because we don't persist configuration for any user
+ return updateConfigurationLocked(values, starting, initLocale, false /* persistent */,
+ UserHandle.USER_NULL, deferResume);
+ }
+
+ public void updatePersistentConfiguration(Configuration values, @UserIdInt int userId) {
+ final long origId = Binder.clearCallingIdentity();
+ try {
+ synchronized (mGlobalLock) {
+ updateConfigurationLocked(values, null, false, true, userId,
+ false /* deferResume */);
+ }
+ } finally {
+ Binder.restoreCallingIdentity(origId);
+ }
+ }
+
+ private boolean updateConfigurationLocked(Configuration values, ActivityRecord starting,
+ boolean initLocale, boolean persistent, int userId, boolean deferResume) {
+ return updateConfigurationLocked(values, starting, initLocale, persistent, userId,
+ deferResume, null /* result */);
+ }
+
+ /**
+ * Do either or both things: (1) change the current configuration, and (2)
+ * make sure the given activity is running with the (now) current
+ * configuration. Returns true if the activity has been left running, or
+ * false if <var>starting</var> is being destroyed to match the new
+ * configuration.
+ *
+ * @param userId is only used when persistent parameter is set to true to persist configuration
+ * for that particular user
+ */
+ boolean updateConfigurationLocked(Configuration values, ActivityRecord starting,
+ boolean initLocale, boolean persistent, int userId, boolean deferResume,
+ ActivityTaskManagerService.UpdateConfigurationResult result) {
+ int changes = 0;
+ boolean kept = true;
+
+ if (mWindowManager != null) {
+ mWindowManager.deferSurfaceLayout();
+ }
+ try {
+ if (values != null) {
+ changes = updateGlobalConfigurationLocked(values, initLocale, persistent, userId,
+ deferResume);
+ }
+
+ kept = ensureConfigAndVisibilityAfterUpdate(starting, changes);
+ } finally {
+ if (mWindowManager != null) {
+ mWindowManager.continueSurfaceLayout();
+ }
+ }
+
+ if (result != null) {
+ result.changes = changes;
+ result.activityRelaunched = !kept;
+ }
+ return kept;
+ }
+
+ /** Update default (global) configuration and notify listeners about changes. */
+ private int updateGlobalConfigurationLocked(@NonNull Configuration values, boolean initLocale,
+ boolean persistent, int userId, boolean deferResume) {
+ mTempConfig.setTo(getGlobalConfiguration());
+ final int changes = mTempConfig.updateFrom(values);
+ if (changes == 0) {
+ // Since calling to Activity.setRequestedOrientation leads to freezing the window with
+ // setting WindowManagerService.mWaitingForConfig to true, it is important that we call
+ // performDisplayOverrideConfigUpdate in order to send the new display configuration
+ // (even if there are no actual changes) to unfreeze the window.
+ performDisplayOverrideConfigUpdate(values, deferResume, DEFAULT_DISPLAY);
+ return 0;
+ }
+
+ if (DEBUG_SWITCH || DEBUG_CONFIGURATION) Slog.i(TAG_CONFIGURATION,
+ "Updating global configuration to: " + values);
+
+ EventLog.writeEvent(EventLogTags.CONFIGURATION_CHANGED, changes);
+ StatsLog.write(StatsLog.RESOURCE_CONFIGURATION_CHANGED,
+ values.colorMode,
+ values.densityDpi,
+ values.fontScale,
+ values.hardKeyboardHidden,
+ values.keyboard,
+ values.keyboardHidden,
+ values.mcc,
+ values.mnc,
+ values.navigation,
+ values.navigationHidden,
+ values.orientation,
+ values.screenHeightDp,
+ values.screenLayout,
+ values.screenWidthDp,
+ values.smallestScreenWidthDp,
+ values.touchscreen,
+ values.uiMode);
+
+
+ if (!initLocale && !values.getLocales().isEmpty() && values.userSetLocale) {
+ final LocaleList locales = values.getLocales();
+ int bestLocaleIndex = 0;
+ if (locales.size() > 1) {
+ if (mSupportedSystemLocales == null) {
+ mSupportedSystemLocales = Resources.getSystem().getAssets().getLocales();
+ }
+ bestLocaleIndex = Math.max(0, locales.getFirstMatchIndex(mSupportedSystemLocales));
+ }
+ SystemProperties.set("persist.sys.locale",
+ locales.get(bestLocaleIndex).toLanguageTag());
+ LocaleList.setDefault(locales, bestLocaleIndex);
+
+ final Message m = PooledLambda.obtainMessage(
+ ActivityTaskManagerService::sendLocaleToMountDaemonMsg, this,
+ locales.get(bestLocaleIndex));
+ mH.sendMessage(m);
+ }
+
+ mTempConfig.seq = increaseConfigurationSeqLocked();
+
+ // Update stored global config and notify everyone about the change.
+ mStackSupervisor.onConfigurationChanged(mTempConfig);
+
+ Slog.i(TAG, "Config changes=" + Integer.toHexString(changes) + " " + mTempConfig);
+ // TODO(multi-display): Update UsageEvents#Event to include displayId.
+ mUsageStatsInternal.reportConfigurationChange(mTempConfig, mAmInternal.getCurrentUserId());
+
+ // TODO: If our config changes, should we auto dismiss any currently showing dialogs?
+ updateShouldShowDialogsLocked(mTempConfig);
+
+ AttributeCache ac = AttributeCache.instance();
+ if (ac != null) {
+ ac.updateConfiguration(mTempConfig);
+ }
+
+ // Make sure all resources in our process are updated right now, so that anyone who is going
+ // to retrieve resource values after we return will be sure to get the new ones. This is
+ // especially important during boot, where the first config change needs to guarantee all
+ // resources have that config before following boot code is executed.
+ mSystemThread.applyConfigurationToResources(mTempConfig);
+
+ // We need another copy of global config because we're scheduling some calls instead of
+ // running them in place. We need to be sure that object we send will be handled unchanged.
+ final Configuration configCopy = new Configuration(mTempConfig);
+ if (persistent && Settings.System.hasInterestingConfigurationChanges(changes)) {
+ final Message msg = PooledLambda.obtainMessage(
+ ActivityTaskManagerService::sendPutConfigurationForUserMsg,
+ this, userId, configCopy);
+ mH.sendMessage(msg);
+ }
+
+ for (int i = mPidMap.size() - 1; i >= 0; i--) {
+ final int pid = mPidMap.keyAt(i);
+ final WindowProcessController app = mPidMap.get(pid);
+ if (DEBUG_CONFIGURATION) {
+ Slog.v(TAG_CONFIGURATION, "Update process config of "
+ + app.mName + " to new config " + configCopy);
+ }
+ app.onConfigurationChanged(configCopy);
+ }
+
+ final Message msg = PooledLambda.obtainMessage(
+ ActivityManagerInternal::broadcastGlobalConfigurationChanged,
+ mAmInternal, changes, initLocale);
+ mH.sendMessage(msg);
+
+ // Override configuration of the default display duplicates global config, so we need to
+ // update it also. This will also notify WindowManager about changes.
+ performDisplayOverrideConfigUpdate(mStackSupervisor.getConfiguration(), deferResume,
+ DEFAULT_DISPLAY);
+
+ return changes;
+ }
+
+ boolean updateDisplayOverrideConfigurationLocked(Configuration values, ActivityRecord starting,
+ boolean deferResume, int displayId) {
+ return updateDisplayOverrideConfigurationLocked(values, starting, deferResume /* deferResume */,
+ displayId, null /* result */);
+ }
+
+ /**
+ * Updates override configuration specific for the selected display. If no config is provided,
+ * new one will be computed in WM based on current display info.
+ */
+ boolean updateDisplayOverrideConfigurationLocked(Configuration values,
+ ActivityRecord starting, boolean deferResume, int displayId,
+ ActivityTaskManagerService.UpdateConfigurationResult result) {
+ int changes = 0;
+ boolean kept = true;
+
+ if (mWindowManager != null) {
+ mWindowManager.deferSurfaceLayout();
+ }
+ try {
+ if (values != null) {
+ if (displayId == DEFAULT_DISPLAY) {
+ // Override configuration of the default display duplicates global config, so
+ // we're calling global config update instead for default display. It will also
+ // apply the correct override config.
+ changes = updateGlobalConfigurationLocked(values, false /* initLocale */,
+ false /* persistent */, UserHandle.USER_NULL /* userId */, deferResume);
+ } else {
+ changes = performDisplayOverrideConfigUpdate(values, deferResume, displayId);
+ }
+ }
+
+ kept = ensureConfigAndVisibilityAfterUpdate(starting, changes);
+ } finally {
+ if (mWindowManager != null) {
+ mWindowManager.continueSurfaceLayout();
+ }
+ }
+
+ if (result != null) {
+ result.changes = changes;
+ result.activityRelaunched = !kept;
+ }
+ return kept;
+ }
+
+ private int performDisplayOverrideConfigUpdate(Configuration values, boolean deferResume,
+ int displayId) {
+ mTempConfig.setTo(mStackSupervisor.getDisplayOverrideConfiguration(displayId));
+ final int changes = mTempConfig.updateFrom(values);
+ if (changes != 0) {
+ Slog.i(TAG, "Override config changes=" + Integer.toHexString(changes) + " "
+ + mTempConfig + " for displayId=" + displayId);
+ mStackSupervisor.setDisplayOverrideConfiguration(mTempConfig, displayId);
+
+ final boolean isDensityChange = (changes & ActivityInfo.CONFIG_DENSITY) != 0;
+ if (isDensityChange && displayId == DEFAULT_DISPLAY) {
+ mAppWarnings.onDensityChanged();
+
+ // Post message to start process to avoid possible deadlock of calling into AMS with
+ // the ATMS lock held.
+ final Message msg = PooledLambda.obtainMessage(
+ ActivityManagerInternal::killAllBackgroundProcessesExcept, mAmInternal,
+ N, ActivityManager.PROCESS_STATE_BOUND_FOREGROUND_SERVICE);
+ mH.sendMessage(msg);
+ }
+ }
+
+ // Update the configuration with WM first and check if any of the stacks need to be resized
+ // due to the configuration change. If so, resize the stacks now and do any relaunches if
+ // necessary. This way we don't need to relaunch again afterwards in
+ // ensureActivityConfiguration().
+ if (mWindowManager != null) {
+ final int[] resizedStacks =
+ mWindowManager.setNewDisplayOverrideConfiguration(mTempConfig, displayId);
+ if (resizedStacks != null) {
+ for (int stackId : resizedStacks) {
+ resizeStackWithBoundsFromWindowManager(stackId, deferResume);
+ }
+ }
+ }
+
+ return changes;
+ }
+
+ private void updateEventDispatchingLocked(boolean booted) {
+ mWindowManager.setEventDispatching(booted && !mShuttingDown);
+ }
+
+ private void sendPutConfigurationForUserMsg(int userId, Configuration config) {
+ final ContentResolver resolver = mContext.getContentResolver();
+ Settings.System.putConfigurationForUser(resolver, config, userId);
+ }
+
+ private void sendLocaleToMountDaemonMsg(Locale l) {
+ try {
+ IBinder service = ServiceManager.getService("mount");
+ IStorageManager storageManager = IStorageManager.Stub.asInterface(service);
+ Log.d(TAG, "Storing locale " + l.toLanguageTag() + " for decryption UI");
+ storageManager.setField(StorageManager.SYSTEM_LOCALE_KEY, l.toLanguageTag());
+ } catch (RemoteException e) {
+ Log.e(TAG, "Error storing locale for decryption UI", e);
+ }
+ }
+
+ boolean isActivityStartsLoggingEnabled() {
+ return mAmInternal.isActivityStartsLoggingEnabled();
+ }
+
+ void enableScreenAfterBoot(boolean booted) {
+ EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_ENABLE_SCREEN,
+ SystemClock.uptimeMillis());
+ mWindowManager.enableScreenAfterBoot();
+
+ synchronized (mGlobalLock) {
+ updateEventDispatchingLocked(booted);
+ }
+ }
+
+ static long getInputDispatchingTimeoutLocked(ActivityRecord r) {
+ if (r == null || !r.hasProcess()) {
+ return KEY_DISPATCHING_TIMEOUT_MS;
+ }
+ return getInputDispatchingTimeoutLocked(r.app);
+ }
+
+ private static long getInputDispatchingTimeoutLocked(WindowProcessController r) {
+ return r != null ? r.getInputDispatchingTimeout() : KEY_DISPATCHING_TIMEOUT_MS;
+ }
+
+ /**
+ * Decide based on the configuration whether we should show the ANR,
+ * crash, etc dialogs. The idea is that if there is no affordance to
+ * press the on-screen buttons, or the user experience would be more
+ * greatly impacted than the crash itself, we shouldn't show the dialog.
+ *
+ * A thought: SystemUI might also want to get told about this, the Power
+ * dialog / global actions also might want different behaviors.
+ */
+ private void updateShouldShowDialogsLocked(Configuration config) {
+ final boolean inputMethodExists = !(config.keyboard == Configuration.KEYBOARD_NOKEYS
+ && config.touchscreen == Configuration.TOUCHSCREEN_NOTOUCH
+ && config.navigation == Configuration.NAVIGATION_NONAV);
+ int modeType = config.uiMode & Configuration.UI_MODE_TYPE_MASK;
+ final boolean uiModeSupportsDialogs = (modeType != Configuration.UI_MODE_TYPE_CAR
+ && !(modeType == Configuration.UI_MODE_TYPE_WATCH && Build.IS_USER)
+ && modeType != Configuration.UI_MODE_TYPE_TELEVISION
+ && modeType != Configuration.UI_MODE_TYPE_VR_HEADSET);
+ final boolean hideDialogsSet = Settings.Global.getInt(mContext.getContentResolver(),
+ HIDE_ERROR_DIALOGS, 0) != 0;
+ mShowDialogs = inputMethodExists && uiModeSupportsDialogs && !hideDialogsSet;
+ }
+
+ private void updateFontScaleIfNeeded(@UserIdInt int userId) {
+ final float scaleFactor = Settings.System.getFloatForUser(mContext.getContentResolver(),
+ FONT_SCALE, 1.0f, userId);
+
+ synchronized (this) {
+ if (getGlobalConfiguration().fontScale == scaleFactor) {
+ return;
+ }
+
+ final Configuration configuration
+ = mWindowManager.computeNewConfiguration(DEFAULT_DISPLAY);
+ configuration.fontScale = scaleFactor;
+ updatePersistentConfiguration(configuration, userId);
+ }
+ }
+
+ // Actually is sleeping or shutting down or whatever else in the future
+ // is an inactive state.
+ boolean isSleepingOrShuttingDownLocked() {
+ return isSleepingLocked() || mShuttingDown;
+ }
+
+ boolean isSleepingLocked() {
+ return mSleeping;
+ }
+
+ /** Update AMS states when an activity is resumed. */
+ void setResumedActivityUncheckLocked(ActivityRecord r, String reason) {
+ final TaskRecord task = r.getTask();
+ if (task.isActivityTypeStandard()) {
+ if (mCurAppTimeTracker != r.appTimeTracker) {
+ // We are switching app tracking. Complete the current one.
+ if (mCurAppTimeTracker != null) {
+ mCurAppTimeTracker.stop();
+ mH.obtainMessage(
+ REPORT_TIME_TRACKER_MSG, mCurAppTimeTracker).sendToTarget();
+ mStackSupervisor.clearOtherAppTimeTrackers(r.appTimeTracker);
+ mCurAppTimeTracker = null;
+ }
+ if (r.appTimeTracker != null) {
+ mCurAppTimeTracker = r.appTimeTracker;
+ startTimeTrackingFocusedActivityLocked();
+ }
+ } else {
+ startTimeTrackingFocusedActivityLocked();
+ }
+ } else {
+ r.appTimeTracker = null;
+ }
+ // TODO: VI Maybe r.task.voiceInteractor || r.voiceInteractor != null
+ // TODO: Probably not, because we don't want to resume voice on switching
+ // back to this activity
+ if (task.voiceInteractor != null) {
+ startRunningVoiceLocked(task.voiceSession, r.info.applicationInfo.uid);
+ } else {
+ finishRunningVoiceLocked();
+
+ if (mLastResumedActivity != null) {
+ final IVoiceInteractionSession session;
+
+ final TaskRecord lastResumedActivityTask = mLastResumedActivity.getTask();
+ if (lastResumedActivityTask != null
+ && lastResumedActivityTask.voiceSession != null) {
+ session = lastResumedActivityTask.voiceSession;
+ } else {
+ session = mLastResumedActivity.voiceSession;
+ }
+
+ if (session != null) {
+ // We had been in a voice interaction session, but now focused has
+ // move to something different. Just finish the session, we can't
+ // return to it and retain the proper state and synchronization with
+ // the voice interaction service.
+ finishVoiceTask(session);
+ }
+ }
+ }
+
+ if (mLastResumedActivity != null && r.userId != mLastResumedActivity.userId) {
+ mAmInternal.sendForegroundProfileChanged(r.userId);
+ }
+ updateResumedAppTrace(r);
+ mLastResumedActivity = r;
+
+ r.getDisplay().setFocusedApp(r, true);
+
+ applyUpdateLockStateLocked(r);
+ applyUpdateVrModeLocked(r);
+
+ EventLogTags.writeAmSetResumedActivity(
+ r == null ? -1 : r.userId,
+ r == null ? "NULL" : r.shortComponentName,
+ reason);
+ }
+
+ ActivityTaskManagerInternal.SleepToken acquireSleepToken(String tag, int displayId) {
+ synchronized (mGlobalLock) {
+ final ActivityTaskManagerInternal.SleepToken token = mStackSupervisor.createSleepTokenLocked(tag, displayId);
+ updateSleepIfNeededLocked();
+ return token;
+ }
+ }
+
+ void updateSleepIfNeededLocked() {
+ final boolean shouldSleep = !mStackSupervisor.hasAwakeDisplay();
+ final boolean wasSleeping = mSleeping;
+ boolean updateOomAdj = false;
+
+ if (!shouldSleep) {
+ // If wasSleeping is true, we need to wake up activity manager state from when
+ // we started sleeping. In either case, we need to apply the sleep tokens, which
+ // will wake up stacks or put them to sleep as appropriate.
+ if (wasSleeping) {
+ mSleeping = false;
+ StatsLog.write(StatsLog.ACTIVITY_MANAGER_SLEEP_STATE_CHANGED,
+ StatsLog.ACTIVITY_MANAGER_SLEEP_STATE_CHANGED__STATE__AWAKE);
+ startTimeTrackingFocusedActivityLocked();
+ mTopProcessState = ActivityManager.PROCESS_STATE_TOP;
+ mStackSupervisor.comeOutOfSleepIfNeededLocked();
+ }
+ mStackSupervisor.applySleepTokensLocked(true /* applyToStacks */);
+ if (wasSleeping) {
+ updateOomAdj = true;
+ }
+ } else if (!mSleeping && shouldSleep) {
+ mSleeping = true;
+ StatsLog.write(StatsLog.ACTIVITY_MANAGER_SLEEP_STATE_CHANGED,
+ StatsLog.ACTIVITY_MANAGER_SLEEP_STATE_CHANGED__STATE__ASLEEP);
+ if (mCurAppTimeTracker != null) {
+ mCurAppTimeTracker.stop();
+ }
+ mTopProcessState = ActivityManager.PROCESS_STATE_TOP_SLEEPING;
+ mStackSupervisor.goingToSleepLocked();
+ updateResumedAppTrace(null /* resumed */);
+ updateOomAdj = true;
+ }
+ if (updateOomAdj) {
+ mH.post(mAmInternal::updateOomAdj);
+ }
+ }
+
+ void updateOomAdj() {
+ mH.post(mAmInternal::updateOomAdj);
+ }
+
+ void updateCpuStats() {
+ mH.post(mAmInternal::updateCpuStats);
+ }
+
+ void updateUsageStats(ActivityRecord component, boolean resumed) {
+ final Message m = PooledLambda.obtainMessage(ActivityManagerInternal::updateUsageStats,
+ mAmInternal, component.realActivity, component.app.mUid, component.userId, resumed);
+ mH.sendMessage(m);
+ }
+
+ void setBooting(boolean booting) {
+ mAmInternal.setBooting(booting);
+ }
+
+ boolean isBooting() {
+ return mAmInternal.isBooting();
+ }
+
+ void setBooted(boolean booted) {
+ mAmInternal.setBooted(booted);
+ }
+
+ boolean isBooted() {
+ return mAmInternal.isBooted();
+ }
+
+ void postFinishBooting(boolean finishBooting, boolean enableScreen) {
+ mH.post(() -> {
+ if (finishBooting) {
+ mAmInternal.finishBooting();
+ }
+ if (enableScreen) {
+ mInternal.enableScreenAfterBoot(isBooted());
+ }
+ });
+ }
+
+ void setHeavyWeightProcess(ActivityRecord root) {
+ mHeavyWeightProcess = root.app;
+ final Message m = PooledLambda.obtainMessage(
+ ActivityTaskManagerService::postHeavyWeightProcessNotification, this,
+ root.app, root.intent, root.userId);
+ mH.sendMessage(m);
+ }
+
+ void clearHeavyWeightProcessIfEquals(WindowProcessController proc) {
+ if (mHeavyWeightProcess == null || mHeavyWeightProcess != proc) {
+ return;
+ }
+
+ mHeavyWeightProcess = null;
+ final Message m = PooledLambda.obtainMessage(
+ ActivityTaskManagerService::cancelHeavyWeightProcessNotification, this,
+ proc.mUserId);
+ mH.sendMessage(m);
+ }
+
+ private void cancelHeavyWeightProcessNotification(int userId) {
+ final INotificationManager inm = NotificationManager.getService();
+ if (inm == null) {
+ return;
+ }
+ try {
+ inm.cancelNotificationWithTag("android", null,
+ SystemMessage.NOTE_HEAVY_WEIGHT_NOTIFICATION, userId);
+ } catch (RuntimeException e) {
+ Slog.w(TAG, "Error canceling notification for service", e);
+ } catch (RemoteException e) {
+ }
+
+ }
+
+ private void postHeavyWeightProcessNotification(
+ WindowProcessController proc, Intent intent, int userId) {
+ if (proc == null) {
+ return;
+ }
+
+ final INotificationManager inm = NotificationManager.getService();
+ if (inm == null) {
+ return;
+ }
+
+ try {
+ Context context = mContext.createPackageContext(proc.mInfo.packageName, 0);
+ String text = mContext.getString(R.string.heavy_weight_notification,
+ context.getApplicationInfo().loadLabel(context.getPackageManager()));
+ Notification notification =
+ new Notification.Builder(context,
+ SystemNotificationChannels.HEAVY_WEIGHT_APP)
+ .setSmallIcon(com.android.internal.R.drawable.stat_sys_adb)
+ .setWhen(0)
+ .setOngoing(true)
+ .setTicker(text)
+ .setColor(mContext.getColor(
+ com.android.internal.R.color.system_notification_accent_color))
+ .setContentTitle(text)
+ .setContentText(
+ mContext.getText(R.string.heavy_weight_notification_detail))
+ .setContentIntent(PendingIntent.getActivityAsUser(mContext, 0,
+ intent, PendingIntent.FLAG_CANCEL_CURRENT, null,
+ new UserHandle(userId)))
+ .build();
+ try {
+ inm.enqueueNotificationWithTag("android", "android", null,
+ SystemMessage.NOTE_HEAVY_WEIGHT_NOTIFICATION, notification, userId);
+ } catch (RuntimeException e) {
+ Slog.w(TAG, "Error showing notification for heavy-weight app", e);
+ } catch (RemoteException e) {
+ }
+ } catch (PackageManager.NameNotFoundException e) {
+ Slog.w(TAG, "Unable to create context for heavy notification", e);
+ }
+
+ }
+
+ IIntentSender getIntentSenderLocked(int type, String packageName, int callingUid, int userId,
+ IBinder token, String resultWho, int requestCode, Intent[] intents,
+ String[] resolvedTypes, int flags, Bundle bOptions) {
+
+ ActivityRecord activity = null;
+ if (type == ActivityManager.INTENT_SENDER_ACTIVITY_RESULT) {
+ activity = ActivityRecord.isInStackLocked(token);
+ if (activity == null) {
+ Slog.w(TAG, "Failed createPendingResult: activity " + token + " not in any stack");
+ return null;
+ }
+ if (activity.finishing) {
+ Slog.w(TAG, "Failed createPendingResult: activity " + activity + " is finishing");
+ return null;
+ }
+ }
+
+ final PendingIntentRecord rec = mPendingIntentController.getIntentSender(type, packageName,
+ callingUid, userId, token, resultWho, requestCode, intents, resolvedTypes, flags,
+ bOptions);
+ final boolean noCreate = (flags & PendingIntent.FLAG_NO_CREATE) != 0;
+ if (noCreate) {
+ return rec;
+ }
+ if (type == ActivityManager.INTENT_SENDER_ACTIVITY_RESULT) {
+ if (activity.pendingResults == null) {
+ activity.pendingResults = new HashSet<>();
+ }
+ activity.pendingResults.add(rec.ref);
+ }
+ return rec;
+ }
+
+ // TODO(b/111541062): Update app time tracking to make it aware of multiple resumed activities
+ private void startTimeTrackingFocusedActivityLocked() {
+ final ActivityRecord resumedActivity = mStackSupervisor.getTopResumedActivity();
+ if (!mSleeping && mCurAppTimeTracker != null && resumedActivity != null) {
+ mCurAppTimeTracker.start(resumedActivity.packageName);
+ }
+ }
+
+ private void updateResumedAppTrace(@Nullable ActivityRecord resumed) {
+ if (mTracedResumedActivity != null) {
+ Trace.asyncTraceEnd(TRACE_TAG_ACTIVITY_MANAGER,
+ constructResumedTraceName(mTracedResumedActivity.packageName), 0);
+ }
+ if (resumed != null) {
+ Trace.asyncTraceBegin(TRACE_TAG_ACTIVITY_MANAGER,
+ constructResumedTraceName(resumed.packageName), 0);
+ }
+ mTracedResumedActivity = resumed;
+ }
+
+ private String constructResumedTraceName(String packageName) {
+ return "focused app: " + packageName;
+ }
+
+ /** Helper method that requests bounds from WM and applies them to stack. */
+ private void resizeStackWithBoundsFromWindowManager(int stackId, boolean deferResume) {
+ final Rect newStackBounds = new Rect();
+ final ActivityStack stack = mStackSupervisor.getStack(stackId);
+
+ // TODO(b/71548119): Revert CL introducing below once cause of mismatch is found.
+ if (stack == null) {
+ final StringWriter writer = new StringWriter();
+ final PrintWriter printWriter = new PrintWriter(writer);
+ mStackSupervisor.dumpDisplays(printWriter);
+ printWriter.flush();
+
+ Log.wtf(TAG, "stack not found:" + stackId + " displays:" + writer);
+ }
+
+ stack.getBoundsForNewConfiguration(newStackBounds);
+ mStackSupervisor.resizeStackLocked(
+ stack, !newStackBounds.isEmpty() ? newStackBounds : null /* bounds */,
+ null /* tempTaskBounds */, null /* tempTaskInsetBounds */,
+ false /* preserveWindows */, false /* allowResizeInDockedMode */, deferResume);
+ }
+
+ /** Applies latest configuration and/or visibility updates if needed. */
+ private boolean ensureConfigAndVisibilityAfterUpdate(ActivityRecord starting, int changes) {
+ boolean kept = true;
+ final ActivityStack mainStack = mStackSupervisor.getTopDisplayFocusedStack();
+ // mainStack is null during startup.
+ if (mainStack != null) {
+ if (changes != 0 && starting == null) {
+ // If the configuration changed, and the caller is not already
+ // in the process of starting an activity, then find the top
+ // activity to check if its configuration needs to change.
+ starting = mainStack.topRunningActivityLocked();
+ }
+
+ if (starting != null) {
+ kept = starting.ensureActivityConfiguration(changes,
+ false /* preserveWindow */);
+ // And we need to make sure at this point that all other activities
+ // are made visible with the correct configuration.
+ mStackSupervisor.ensureActivitiesVisibleLocked(starting, changes,
+ !PRESERVE_WINDOWS);
+ }
+ }
+
+ return kept;
+ }
+
+ void scheduleAppGcsLocked() {
+ mH.post(() -> mAmInternal.scheduleAppGcs());
+ }
+
+ CompatibilityInfo compatibilityInfoForPackageLocked(ApplicationInfo ai) {
+ return mCompatModePackages.compatibilityInfoForPackageLocked(ai);
+ }
+
+ /**
+ * Returns the PackageManager. Used by classes hosted by {@link ActivityTaskManagerService}. The
+ * PackageManager could be unavailable at construction time and therefore needs to be accessed
+ * on demand.
+ */
+ IPackageManager getPackageManager() {
+ return AppGlobals.getPackageManager();
+ }
+
+ PackageManagerInternal getPackageManagerInternalLocked() {
+ if (mPmInternal == null) {
+ mPmInternal = LocalServices.getService(PackageManagerInternal.class);
+ }
+ return mPmInternal;
+ }
+
+ AppWarnings getAppWarningsLocked() {
+ return mAppWarnings;
+ }
+
+ Intent getHomeIntent() {
+ Intent intent = new Intent(mTopAction, mTopData != null ? Uri.parse(mTopData) : null);
+ intent.setComponent(mTopComponent);
+ intent.addFlags(Intent.FLAG_DEBUG_TRIAGED_MISSING);
+ if (mFactoryTest != FactoryTest.FACTORY_TEST_LOW_LEVEL) {
+ intent.addCategory(Intent.CATEGORY_HOME);
+ }
+ return intent;
+ }
+
+ ApplicationInfo getAppInfoForUser(ApplicationInfo info, int userId) {
+ if (info == null) return null;
+ ApplicationInfo newInfo = new ApplicationInfo(info);
+ newInfo.initForUser(userId);
+ return newInfo;
+ }
+
+ WindowProcessController getProcessController(String processName, int uid) {
+ if (uid == SYSTEM_UID) {
+ // The system gets to run in any process. If there are multiple processes with the same
+ // uid, just pick the first (this should never happen).
+ final SparseArray<WindowProcessController> procs =
+ mProcessNames.getMap().get(processName);
+ if (procs == null) return null;
+ final int procCount = procs.size();
+ for (int i = 0; i < procCount; i++) {
+ final int procUid = procs.keyAt(i);
+ if (UserHandle.isApp(procUid) || !UserHandle.isSameUser(procUid, uid)) {
+ // Don't use an app process or different user process for system component.
+ continue;
+ }
+ return procs.valueAt(i);
+ }
+ }
+
+ return mProcessNames.get(processName, uid);
+ }
+
+ WindowProcessController getProcessController(IApplicationThread thread) {
+ if (thread == null) {
+ return null;
+ }
+
+ final IBinder threadBinder = thread.asBinder();
+ final ArrayMap<String, SparseArray<WindowProcessController>> pmap = mProcessNames.getMap();
+ for (int i = pmap.size()-1; i >= 0; i--) {
+ final SparseArray<WindowProcessController> procs = pmap.valueAt(i);
+ for (int j = procs.size() - 1; j >= 0; j--) {
+ final WindowProcessController proc = procs.valueAt(j);
+ if (proc.hasThread() && proc.getThread().asBinder() == threadBinder) {
+ return proc;
+ }
+ }
+ }
+
+ return null;
+ }
+
+ int getUidStateLocked(int uid) {
+ return mActiveUids.get(uid, PROCESS_STATE_NONEXISTENT);
+ }
+
+ /**
+ * @return whitelist tag for a uid from mPendingTempWhitelist, null if not currently on
+ * the whitelist
+ */
+ String getPendingTempWhitelistTagForUidLocked(int uid) {
+ return mPendingTempWhitelist.get(uid);
+ }
+
+ void logAppTooSlow(WindowProcessController app, long startTime, String msg) {
+ if (true || Build.IS_USER) {
+ return;
+ }
+
+ StrictMode.ThreadPolicy oldPolicy = StrictMode.allowThreadDiskReads();
+ StrictMode.allowThreadDiskWrites();
+ try {
+ File tracesDir = new File("/data/anr");
+ File tracesFile = null;
+ try {
+ tracesFile = File.createTempFile("app_slow", null, tracesDir);
+
+ StringBuilder sb = new StringBuilder();
+ Time tobj = new Time();
+ tobj.set(System.currentTimeMillis());
+ sb.append(tobj.format("%Y-%m-%d %H:%M:%S"));
+ sb.append(": ");
+ TimeUtils.formatDuration(SystemClock.uptimeMillis()-startTime, sb);
+ sb.append(" since ");
+ sb.append(msg);
+ FileOutputStream fos = new FileOutputStream(tracesFile);
+ fos.write(sb.toString().getBytes());
+ if (app == null) {
+ fos.write("\n*** No application process!".getBytes());
+ }
+ fos.close();
+ FileUtils.setPermissions(tracesFile.getPath(), 0666, -1, -1); // -rw-rw-rw-
+ } catch (IOException e) {
+ Slog.w(TAG, "Unable to prepare slow app traces file: " + tracesFile, e);
+ return;
+ }
+
+ if (app != null && app.getPid() > 0) {
+ ArrayList<Integer> firstPids = new ArrayList<Integer>();
+ firstPids.add(app.getPid());
+ dumpStackTraces(tracesFile.getAbsolutePath(), firstPids, null, null);
+ }
+
+ File lastTracesFile = null;
+ File curTracesFile = null;
+ for (int i=9; i>=0; i--) {
+ String name = String.format(Locale.US, "slow%02d.txt", i);
+ curTracesFile = new File(tracesDir, name);
+ if (curTracesFile.exists()) {
+ if (lastTracesFile != null) {
+ curTracesFile.renameTo(lastTracesFile);
+ } else {
+ curTracesFile.delete();
+ }
+ }
+ lastTracesFile = curTracesFile;
+ }
+ tracesFile.renameTo(curTracesFile);
+ } finally {
+ StrictMode.setThreadPolicy(oldPolicy);
+ }
+ }
+
+ final class H extends Handler {
+ static final int REPORT_TIME_TRACKER_MSG = 1;
+ static final int FIRST_ACTIVITY_STACK_MSG = 100;
+ static final int FIRST_SUPERVISOR_STACK_MSG = 200;
+
+ public H(Looper looper) {
+ super(looper, null, true);
+ }
+
+ @Override
+ public void handleMessage(Message msg) {
+ switch (msg.what) {
+ case REPORT_TIME_TRACKER_MSG: {
+ AppTimeTracker tracker = (AppTimeTracker) msg.obj;
+ tracker.deliverResult(mContext);
+ } break;
+ }
+ }
+ }
+
+ final class UiHandler extends Handler {
+ static final int DISMISS_DIALOG_UI_MSG = 1;
+
+ public UiHandler() {
+ super(com.android.server.UiThread.get().getLooper(), null, true);
+ }
+
+ @Override
+ public void handleMessage(Message msg) {
+ switch (msg.what) {
+ case DISMISS_DIALOG_UI_MSG: {
+ final Dialog d = (Dialog) msg.obj;
+ d.dismiss();
+ break;
+ }
+ }
+ }
+ }
+
+ final class LocalService extends ActivityTaskManagerInternal {
+ @Override
+ public SleepToken acquireSleepToken(String tag, int displayId) {
+ Preconditions.checkNotNull(tag);
+ return ActivityTaskManagerService.this.acquireSleepToken(tag, displayId);
+ }
+
+ @Override
+ public ComponentName getHomeActivityForUser(int userId) {
+ synchronized (mGlobalLock) {
+ ActivityRecord homeActivity =
+ mStackSupervisor.getDefaultDisplayHomeActivityForUser(userId);
+ return homeActivity == null ? null : homeActivity.realActivity;
+ }
+ }
+
+ @Override
+ public void onLocalVoiceInteractionStarted(IBinder activity,
+ IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor) {
+ synchronized (mGlobalLock) {
+ onLocalVoiceInteractionStartedLocked(activity, voiceSession, voiceInteractor);
+ }
+ }
+
+ @Override
+ public void notifyAppTransitionStarting(SparseIntArray reasons, long timestamp) {
+ synchronized (mGlobalLock) {
+ mStackSupervisor.getActivityMetricsLogger().notifyTransitionStarting(
+ reasons, timestamp);
+ }
+ }
+
+ @Override
+ public void notifyAppTransitionFinished() {
+ synchronized (mGlobalLock) {
+ mStackSupervisor.notifyAppTransitionDone();
+ }
+ }
+
+ @Override
+ public void notifyAppTransitionCancelled() {
+ synchronized (mGlobalLock) {
+ mStackSupervisor.notifyAppTransitionDone();
+ }
+ }
+
+ @Override
+ public List<IBinder> getTopVisibleActivities() {
+ synchronized (mGlobalLock) {
+ return mStackSupervisor.getTopVisibleActivities();
+ }
+ }
+
+ @Override
+ public void notifyDockedStackMinimizedChanged(boolean minimized) {
+ synchronized (mGlobalLock) {
+ mStackSupervisor.setDockedStackMinimized(minimized);
+ }
+ }
+
+ @Override
+ public int startActivitiesAsPackage(String packageName, int userId, Intent[] intents,
+ Bundle bOptions) {
+ Preconditions.checkNotNull(intents, "intents");
+ final String[] resolvedTypes = new String[intents.length];
+
+ // UID of the package on user userId.
+ // "= 0" is needed because otherwise catch(RemoteException) would make it look like
+ // packageUid may not be initialized.
+ int packageUid = 0;
+ final long ident = Binder.clearCallingIdentity();
+
+ try {
+ for (int i = 0; i < intents.length; i++) {
+ resolvedTypes[i] =
+ intents[i].resolveTypeIfNeeded(mContext.getContentResolver());
+ }
+
+ packageUid = AppGlobals.getPackageManager().getPackageUid(
+ packageName, PackageManager.MATCH_DEBUG_TRIAGED_MISSING, userId);
+ } catch (RemoteException e) {
+ // Shouldn't happen.
+ } finally {
+ Binder.restoreCallingIdentity(ident);
+ }
+
+ synchronized (mGlobalLock) {
+ return getActivityStartController().startActivitiesInPackage(
+ packageUid, packageName,
+ intents, resolvedTypes, null /* resultTo */,
+ SafeActivityOptions.fromBundle(bOptions), userId,
+ false /* validateIncomingUser */, null /* originatingPendingIntent */);
+ }
+ }
+
+ @Override
+ public int startActivitiesInPackage(int uid, String callingPackage, Intent[] intents,
+ String[] resolvedTypes, IBinder resultTo, SafeActivityOptions options, int userId,
+ boolean validateIncomingUser, PendingIntentRecord originatingPendingIntent) {
+ synchronized (mGlobalLock) {
+ return getActivityStartController().startActivitiesInPackage(uid, callingPackage,
+ intents, resolvedTypes, resultTo, options, userId, validateIncomingUser,
+ originatingPendingIntent);
+ }
+ }
+
+ @Override
+ public int startActivityInPackage(int uid, int realCallingPid, int realCallingUid,
+ String callingPackage, Intent intent, String resolvedType, IBinder resultTo,
+ String resultWho, int requestCode, int startFlags, SafeActivityOptions options,
+ int userId, TaskRecord inTask, String reason, boolean validateIncomingUser,
+ PendingIntentRecord originatingPendingIntent) {
+ synchronized (mGlobalLock) {
+ return getActivityStartController().startActivityInPackage(uid, realCallingPid,
+ realCallingUid, callingPackage, intent, resolvedType, resultTo, resultWho,
+ requestCode, startFlags, options, userId, inTask, reason,
+ validateIncomingUser, originatingPendingIntent);
+ }
+ }
+
+ @Override
+ public int startActivityAsUser(IApplicationThread caller, String callerPacakge,
+ Intent intent, Bundle options, int userId) {
+ return ActivityTaskManagerService.this.startActivityAsUser(
+ caller, callerPacakge, intent,
+ intent.resolveTypeIfNeeded(mContext.getContentResolver()),
+ null, null, 0, Intent.FLAG_ACTIVITY_NEW_TASK, null, options, userId,
+ false /*validateIncomingUser*/);
+ }
+
+ @Override
+ public void notifyKeyguardFlagsChanged(@Nullable Runnable callback, int displayId) {
+ synchronized (mGlobalLock) {
+
+ // We might change the visibilities here, so prepare an empty app transition which
+ // might be overridden later if we actually change visibilities.
+ final DisplayWindowController dwc = mStackSupervisor.getActivityDisplay(displayId)
+ .getWindowContainerController();
+ final boolean wasTransitionSet = dwc.getPendingAppTransition() != TRANSIT_NONE;
+ if (!wasTransitionSet) {
+ dwc.prepareAppTransition(TRANSIT_NONE, false /* alwaysKeepCurrent */);
+ }
+ mStackSupervisor.ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
+
+ // If there was a transition set already we don't want to interfere with it as we
+ // might be starting it too early.
+ if (!wasTransitionSet) {
+ dwc.executeAppTransition();
+ }
+ }
+ if (callback != null) {
+ callback.run();
+ }
+ }
+
+ @Override
+ public void notifyKeyguardTrustedChanged() {
+ synchronized (mGlobalLock) {
+ if (mKeyguardController.isKeyguardShowing(DEFAULT_DISPLAY)) {
+ mStackSupervisor.ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
+ }
+ }
+ }
+
+ /**
+ * Called after virtual display Id is updated by
+ * {@link com.android.server.vr.Vr2dDisplay} with a specific
+ * {@param vrVr2dDisplayId}.
+ */
+ @Override
+ public void setVr2dDisplayId(int vr2dDisplayId) {
+ if (DEBUG_STACK) Slog.d(TAG, "setVr2dDisplayId called for: " + vr2dDisplayId);
+ synchronized (mGlobalLock) {
+ mVr2dDisplayId = vr2dDisplayId;
+ }
+ }
+
+ @Override
+ public void setFocusedActivity(IBinder token) {
+ synchronized (mGlobalLock) {
+ final ActivityRecord r = ActivityRecord.forTokenLocked(token);
+ if (r == null) {
+ throw new IllegalArgumentException(
+ "setFocusedActivity: No activity record matching token=" + token);
+ }
+ if (r.moveFocusableActivityToTop("setFocusedActivity")) {
+ mStackSupervisor.resumeFocusedStacksTopActivitiesLocked();
+ }
+ }
+ }
+
+ @Override
+ public void registerScreenObserver(ScreenObserver observer) {
+ mScreenObservers.add(observer);
+ }
+
+ @Override
+ public boolean isCallerRecents(int callingUid) {
+ return getRecentTasks().isCallerRecents(callingUid);
+ }
+
+ @Override
+ public boolean isRecentsComponentHomeActivity(int userId) {
+ return getRecentTasks().isRecentsComponentHomeActivity(userId);
+ }
+
+ @Override
+ public void cancelRecentsAnimation(boolean restoreHomeStackPosition) {
+ ActivityTaskManagerService.this.cancelRecentsAnimation(restoreHomeStackPosition);
+ }
+
+ @Override
+ public void enforceCallerIsRecentsOrHasPermission(String permission, String func) {
+ ActivityTaskManagerService.this.enforceCallerIsRecentsOrHasPermission(permission, func);
+ }
+
+ @Override
+ public void notifyActiveVoiceInteractionServiceChanged(ComponentName component) {
+ synchronized (mGlobalLock) {
+ mActiveVoiceInteractionServiceComponent = component;
+ }
+ }
+
+ @Override
+ public void setAllowAppSwitches(@NonNull String type, int uid, int userId) {
+ if (!mAmInternal.isUserRunning(userId, ActivityManager.FLAG_OR_STOPPED)) {
+ return;
+ }
+ synchronized (mGlobalLock) {
+ ArrayMap<String, Integer> types = mAllowAppSwitchUids.get(userId);
+ if (types == null) {
+ if (uid < 0) {
+ return;
+ }
+ types = new ArrayMap<>();
+ mAllowAppSwitchUids.put(userId, types);
+ }
+ if (uid < 0) {
+ types.remove(type);
+ } else {
+ types.put(type, uid);
+ }
+ }
+ }
+
+ @Override
+ public void onUserStopped(int userId) {
+ synchronized (mGlobalLock) {
+ getRecentTasks().unloadUserDataFromMemoryLocked(userId);
+ mAllowAppSwitchUids.remove(userId);
+ }
+ }
+
+ @Override
+ public boolean isGetTasksAllowed(String caller, int callingPid, int callingUid) {
+ synchronized (mGlobalLock) {
+ return ActivityTaskManagerService.this.isGetTasksAllowed(
+ caller, callingPid, callingUid);
+ }
+ }
+
+ @Override
+ public void onProcessAdded(WindowProcessController proc) {
+ synchronized (mGlobalLock) {
+ mProcessNames.put(proc.mName, proc.mUid, proc);
+ }
+ }
+
+ @Override
+ public void onProcessRemoved(String name, int uid) {
+ synchronized (mGlobalLock) {
+ mProcessNames.remove(name, uid);
+ }
+ }
+
+ @Override
+ public void onCleanUpApplicationRecord(WindowProcessController proc) {
+ synchronized (mGlobalLock) {
+ if (proc == mHomeProcess) {
+ mHomeProcess = null;
+ }
+ if (proc == mPreviousProcess) {
+ mPreviousProcess = null;
+ }
+ }
+ }
+
+ @Override
+ public int getTopProcessState() {
+ synchronized (mGlobalLock) {
+ return mTopProcessState;
+ }
+ }
+
+ @Override
+ public boolean isHeavyWeightProcess(WindowProcessController proc) {
+ synchronized (mGlobalLock) {
+ return proc == mHeavyWeightProcess;
+ }
+ }
+
+ @Override
+ public void clearHeavyWeightProcessIfEquals(WindowProcessController proc) {
+ synchronized (mGlobalLock) {
+ ActivityTaskManagerService.this.clearHeavyWeightProcessIfEquals(proc);
+ }
+ }
+
+ @Override
+ public void finishHeavyWeightApp() {
+ synchronized (mGlobalLock) {
+ if (mHeavyWeightProcess != null) {
+ mHeavyWeightProcess.finishActivities();
+ }
+ ActivityTaskManagerService.this.clearHeavyWeightProcessIfEquals(
+ mHeavyWeightProcess);
+ }
+ }
+
+ @Override
+ public boolean isSleeping() {
+ synchronized (mGlobalLock) {
+ return isSleepingLocked();
+ }
+ }
+
+ @Override
+ public boolean isShuttingDown() {
+ synchronized (mGlobalLock) {
+ return mShuttingDown;
+ }
+ }
+
+ @Override
+ public boolean shuttingDown(boolean booted, int timeout) {
+ synchronized (mGlobalLock) {
+ mShuttingDown = true;
+ mStackSupervisor.prepareForShutdownLocked();
+ updateEventDispatchingLocked(booted);
+ notifyTaskPersisterLocked(null, true);
+ return mStackSupervisor.shutdownLocked(timeout);
+ }
+ }
+
+ @Override
+ public void enableScreenAfterBoot(boolean booted) {
+ synchronized (mGlobalLock) {
+ EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_ENABLE_SCREEN,
+ SystemClock.uptimeMillis());
+ mWindowManager.enableScreenAfterBoot();
+ updateEventDispatchingLocked(booted);
+ }
+ }
+
+ @Override
+ public boolean showStrictModeViolationDialog() {
+ synchronized (mGlobalLock) {
+ return mShowDialogs && !mSleeping && !mShuttingDown;
+ }
+ }
+
+ @Override
+ public void showSystemReadyErrorDialogsIfNeeded() {
+ synchronized (mGlobalLock) {
+ try {
+ if (AppGlobals.getPackageManager().hasSystemUidErrors()) {
+ Slog.e(TAG, "UIDs on the system are inconsistent, you need to wipe your"
+ + " data partition or your device will be unstable.");
+ mUiHandler.post(() -> {
+ if (mShowDialogs) {
+ AlertDialog d = new BaseErrorDialog(mUiContext);
+ d.getWindow().setType(WindowManager.LayoutParams.TYPE_SYSTEM_ERROR);
+ d.setCancelable(false);
+ d.setTitle(mUiContext.getText(R.string.android_system_label));
+ d.setMessage(mUiContext.getText(R.string.system_error_wipe_data));
+ d.setButton(DialogInterface.BUTTON_POSITIVE,
+ mUiContext.getText(R.string.ok),
+ mUiHandler.obtainMessage(DISMISS_DIALOG_UI_MSG, d));
+ d.show();
+ }
+ });
+ }
+ } catch (RemoteException e) {
+ }
+
+ if (!Build.isBuildConsistent()) {
+ Slog.e(TAG, "Build fingerprint is not consistent, warning user");
+ mUiHandler.post(() -> {
+ if (mShowDialogs) {
+ AlertDialog d = new BaseErrorDialog(mUiContext);
+ d.getWindow().setType(WindowManager.LayoutParams.TYPE_SYSTEM_ERROR);
+ d.setCancelable(false);
+ d.setTitle(mUiContext.getText(R.string.android_system_label));
+ d.setMessage(mUiContext.getText(R.string.system_error_manufacturer));
+ d.setButton(DialogInterface.BUTTON_POSITIVE,
+ mUiContext.getText(R.string.ok),
+ mUiHandler.obtainMessage(DISMISS_DIALOG_UI_MSG, d));
+ d.show();
+ }
+ });
+ }
+ }
+ }
+
+ @Override
+ public void onProcessMapped(int pid, WindowProcessController proc) {
+ synchronized (mGlobalLock) {
+ mPidMap.put(pid, proc);
+ }
+ }
+
+ @Override
+ public void onProcessUnMapped(int pid) {
+ synchronized (mGlobalLock) {
+ mPidMap.remove(pid);
+ }
+ }
+
+ @Override
+ public void onPackageDataCleared(String name) {
+ synchronized (mGlobalLock) {
+ mCompatModePackages.handlePackageDataClearedLocked(name);
+ mAppWarnings.onPackageDataCleared(name);
+ }
+ }
+
+ @Override
+ public void onPackageUninstalled(String name) {
+ synchronized (mGlobalLock) {
+ mAppWarnings.onPackageUninstalled(name);
+ mCompatModePackages.handlePackageUninstalledLocked(name);
+ }
+ }
+
+ @Override
+ public void onPackageAdded(String name, boolean replacing) {
+ synchronized (mGlobalLock) {
+ mCompatModePackages.handlePackageAddedLocked(name, replacing);
+ }
+ }
+
+ @Override
+ public void onPackageReplaced(ApplicationInfo aInfo) {
+ synchronized (mGlobalLock) {
+ mStackSupervisor.updateActivityApplicationInfoLocked(aInfo);
+ }
+ }
+
+ @Override
+ public CompatibilityInfo compatibilityInfoForPackage(ApplicationInfo ai) {
+ synchronized (mGlobalLock) {
+ return compatibilityInfoForPackageLocked(ai);
+ }
+ }
+
+ /**
+ * Set the corresponding display information for the process global configuration. To be
+ * called when we need to show IME on a different display.
+ *
+ * @param pid The process id associated with the IME window.
+ * @param displayId The ID of the display showing the IME.
+ */
+ @Override
+ public void onImeWindowSetOnDisplay(final int pid, final int displayId) {
+ if (pid == MY_PID || pid < 0) {
+ if (DEBUG_CONFIGURATION) {
+ Slog.w(TAG,
+ "Trying to update display configuration for system/invalid process.");
+ }
+ return;
+ }
+ mH.post(() -> {
+ synchronized (mGlobalLock) {
+ final ActivityDisplay activityDisplay =
+ mStackSupervisor.getActivityDisplay(displayId);
+ if (activityDisplay == null) {
+ // Call might come when display is not yet added or has been removed.
+ if (DEBUG_CONFIGURATION) {
+ Slog.w(TAG, "Trying to update display configuration for non-existing "
+ + "displayId=" + displayId);
+ }
+ return;
+ }
+ final WindowProcessController process = mPidMap.get(pid);
+ if (process == null) {
+ if (DEBUG_CONFIGURATION) {
+ Slog.w(TAG, "Trying to update display configuration for invalid "
+ + "process, pid=" + pid);
+ }
+ return;
+ }
+ process.registerDisplayConfigurationListenerLocked(activityDisplay);
+ }
+ });
+
+ }
+
+ @Override
+ public void sendActivityResult(int callingUid, IBinder activityToken, String resultWho,
+ int requestCode, int resultCode, Intent data) {
+ synchronized (mGlobalLock) {
+ final ActivityRecord r = ActivityRecord.isInStackLocked(activityToken);
+ if (r != null && r.getStack() != null) {
+ r.getStack().sendActivityResultLocked(callingUid, r, resultWho, requestCode,
+ resultCode, data);
+ }
+ }
+ }
+
+ @Override
+ public void clearPendingResultForActivity(IBinder activityToken,
+ WeakReference<PendingIntentRecord> pir) {
+ synchronized (mGlobalLock) {
+ final ActivityRecord r = ActivityRecord.isInStackLocked(activityToken);
+ if (r != null && r.pendingResults != null) {
+ r.pendingResults.remove(pir);
+ }
+ }
+ }
+
+ @Override
+ public IIntentSender getIntentSender(int type, String packageName,
+ int callingUid, int userId, IBinder token, String resultWho,
+ int requestCode, Intent[] intents, String[] resolvedTypes, int flags,
+ Bundle bOptions) {
+ synchronized (mGlobalLock) {
+ return getIntentSenderLocked(type, packageName, callingUid, userId, token,
+ resultWho, requestCode, intents, resolvedTypes, flags, bOptions);
+ }
+ }
+
+ @Override
+ public ActivityServiceConnectionsHolder getServiceConnectionsHolder(IBinder token) {
+ synchronized (mGlobalLock) {
+ final ActivityRecord r = ActivityRecord.isInStackLocked(token);
+ if (r == null) {
+ return null;
+ }
+ if (r.mServiceConnectionsHolder == null) {
+ r.mServiceConnectionsHolder = new ActivityServiceConnectionsHolder(
+ ActivityTaskManagerService.this, r);
+ }
+
+ return r.mServiceConnectionsHolder;
+ }
+ }
+
+ @Override
+ public Intent getHomeIntent() {
+ synchronized (mGlobalLock) {
+ return ActivityTaskManagerService.this.getHomeIntent();
+ }
+ }
+
+ @Override
+ public boolean startHomeActivity(int userId, String reason) {
+ synchronized (mGlobalLock) {
+ return mStackSupervisor.startHomeOnDisplay(userId, reason, DEFAULT_DISPLAY);
+ }
+ }
+
+ @Override
+ public boolean startHomeOnAllDisplays(int userId, String reason) {
+ synchronized (mGlobalLock) {
+ return mStackSupervisor.startHomeOnAllDisplays(userId, reason);
+ }
+ }
+
+ @Override
+ public boolean isFactoryTestProcess(WindowProcessController wpc) {
+ synchronized (mGlobalLock) {
+ if (mFactoryTest == FACTORY_TEST_OFF) {
+ return false;
+ }
+ if (mFactoryTest == FACTORY_TEST_LOW_LEVEL && mTopComponent != null
+ && wpc.mName.equals(mTopComponent.getPackageName())) {
+ return true;
+ }
+ return mFactoryTest == FACTORY_TEST_HIGH_LEVEL
+ && (wpc.mInfo.flags & FLAG_FACTORY_TEST) != 0;
+ }
+ }
+
+ @Override
+ public void updateTopComponentForFactoryTest() {
+ synchronized (mGlobalLock) {
+ if (mFactoryTest != FACTORY_TEST_LOW_LEVEL) {
+ return;
+ }
+ final ResolveInfo ri = mContext.getPackageManager()
+ .resolveActivity(new Intent(Intent.ACTION_FACTORY_TEST), STOCK_PM_FLAGS);
+ final CharSequence errorMsg;
+ if (ri != null) {
+ final ActivityInfo ai = ri.activityInfo;
+ final ApplicationInfo app = ai.applicationInfo;
+ if ((app.flags & ApplicationInfo.FLAG_SYSTEM) != 0) {
+ mTopAction = Intent.ACTION_FACTORY_TEST;
+ mTopData = null;
+ mTopComponent = new ComponentName(app.packageName, ai.name);
+ errorMsg = null;
+ } else {
+ errorMsg = mContext.getResources().getText(
+ com.android.internal.R.string.factorytest_not_system);
+ }
+ } else {
+ errorMsg = mContext.getResources().getText(
+ com.android.internal.R.string.factorytest_no_action);
+ }
+ if (errorMsg == null) {
+ return;
+ }
+
+ mTopAction = null;
+ mTopData = null;
+ mTopComponent = null;
+ mUiHandler.post(() -> {
+ Dialog d = new FactoryErrorDialog(mUiContext, errorMsg);
+ d.show();
+ mAmInternal.ensureBootCompleted();
+ });
+ }
+ }
+
+ @Override
+ public void handleAppDied(WindowProcessController wpc, boolean restarting,
+ Runnable finishInstrumentationCallback) {
+ synchronized (mGlobalLock) {
+ // Remove this application's activities from active lists.
+ boolean hasVisibleActivities = mStackSupervisor.handleAppDiedLocked(wpc);
+
+ wpc.clearRecentTasks();
+ wpc.clearActivities();
+
+ if (wpc.isInstrumenting()) {
+ finishInstrumentationCallback.run();
+ }
+
+ mWindowManager.deferSurfaceLayout();
+ try {
+ if (!restarting && hasVisibleActivities
+ && !mStackSupervisor.resumeFocusedStacksTopActivitiesLocked()) {
+ // If there was nothing to resume, and we are not already restarting this
+ // process, but there is a visible activity that is hosted by the process...
+ // then make sure all visible activities are running, taking care of
+ // restarting this process.
+ mStackSupervisor.ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
+ }
+ } finally {
+ mWindowManager.continueSurfaceLayout();
+ }
+ }
+ }
+
+ @Override
+ public void closeSystemDialogs(String reason) {
+ enforceNotIsolatedCaller("closeSystemDialogs");
+
+ final int pid = Binder.getCallingPid();
+ final int uid = Binder.getCallingUid();
+ final long origId = Binder.clearCallingIdentity();
+ try {
+ synchronized (mGlobalLock) {
+ // Only allow this from foreground processes, so that background
+ // applications can't abuse it to prevent system UI from being shown.
+ if (uid >= FIRST_APPLICATION_UID) {
+ final WindowProcessController proc = mPidMap.get(pid);
+ if (!proc.isPerceptible()) {
+ Slog.w(TAG, "Ignoring closeSystemDialogs " + reason
+ + " from background process " + proc);
+ return;
+ }
+ }
+ mWindowManager.closeSystemDialogs(reason);
+
+ mStackSupervisor.closeSystemDialogsLocked();
+ }
+ // Call into AM outside the synchronized block.
+ mAmInternal.broadcastCloseSystemDialogs(reason);
+ } finally {
+ Binder.restoreCallingIdentity(origId);
+ }
+ }
+
+ @Override
+ public void cleanupDisabledPackageComponents(
+ String packageName, Set<String> disabledClasses, int userId, boolean booted) {
+ synchronized (mGlobalLock) {
+ // Clean-up disabled activities.
+ if (mStackSupervisor.finishDisabledPackageActivitiesLocked(
+ packageName, disabledClasses, true, false, userId) && booted) {
+ mStackSupervisor.resumeFocusedStacksTopActivitiesLocked();
+ mStackSupervisor.scheduleIdleLocked();
+ }
+
+ // Clean-up disabled tasks
+ getRecentTasks().cleanupDisabledPackageTasksLocked(
+ packageName, disabledClasses, userId);
+ }
+ }
+
+ @Override
+ public boolean onForceStopPackage(String packageName, boolean doit, boolean evenPersistent,
+ int userId) {
+ synchronized (mGlobalLock) {
+
+ boolean didSomething =
+ getActivityStartController().clearPendingActivityLaunches(packageName);
+ didSomething |= mStackSupervisor.finishDisabledPackageActivitiesLocked(packageName,
+ null, doit, evenPersistent, userId);
+ return didSomething;
+ }
+ }
+
+ @Override
+ public void resumeTopActivities(boolean scheduleIdle) {
+ synchronized (mGlobalLock) {
+ mStackSupervisor.resumeFocusedStacksTopActivitiesLocked();
+ if (scheduleIdle) {
+ mStackSupervisor.scheduleIdleLocked();
+ }
+ }
+ }
+
+ @Override
+ public void preBindApplication(WindowProcessController wpc) {
+ synchronized (mGlobalLock) {
+ mStackSupervisor.getActivityMetricsLogger().notifyBindApplication(wpc.mInfo);
+ }
+ }
+
+ @Override
+ public boolean attachApplication(WindowProcessController wpc) throws RemoteException {
+ synchronized (mGlobalLock) {
+ return mStackSupervisor.attachApplicationLocked(wpc);
+ }
+ }
+
+ @Override
+ public void notifyLockedProfile(@UserIdInt int userId, int currentUserId) {
+ try {
+ if (!AppGlobals.getPackageManager().isUidPrivileged(Binder.getCallingUid())) {
+ throw new SecurityException("Only privileged app can call notifyLockedProfile");
+ }
+ } catch (RemoteException ex) {
+ throw new SecurityException("Fail to check is caller a privileged app", ex);
+ }
+
+ synchronized (mGlobalLock) {
+ final long ident = Binder.clearCallingIdentity();
+ try {
+ if (mAmInternal.shouldConfirmCredentials(userId)) {
+ if (mKeyguardController.isKeyguardLocked()) {
+ // Showing launcher to avoid user entering credential twice.
+ startHomeActivity(currentUserId, "notifyLockedProfile");
+ }
+ mStackSupervisor.lockAllProfileTasks(userId);
+ }
+ } finally {
+ Binder.restoreCallingIdentity(ident);
+ }
+ }
+ }
+
+ @Override
+ public void startConfirmDeviceCredentialIntent(Intent intent, Bundle options) {
+ mAmInternal.enforceCallingPermission(
+ MANAGE_ACTIVITY_STACKS, "startConfirmDeviceCredentialIntent");
+
+ synchronized (mGlobalLock) {
+ final long ident = Binder.clearCallingIdentity();
+ try {
+ intent.addFlags(FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS |
+ FLAG_ACTIVITY_TASK_ON_HOME);
+ ActivityOptions activityOptions = options != null
+ ? new ActivityOptions(options) : ActivityOptions.makeBasic();
+ activityOptions.setLaunchTaskId(
+ mStackSupervisor.getDefaultDisplayHomeActivity().getTask().taskId);
+ mContext.startActivityAsUser(intent, activityOptions.toBundle(),
+ UserHandle.CURRENT);
+ } finally {
+ Binder.restoreCallingIdentity(ident);
+ }
+ }
+ }
+
+ @Override
+ public void writeActivitiesToProto(ProtoOutputStream proto) {
+ synchronized (mGlobalLock) {
+ // The output proto of "activity --proto activities"
+ // is ActivityManagerServiceDumpActivitiesProto
+ mStackSupervisor.writeToProto(proto,
+ ActivityManagerServiceDumpActivitiesProto.ACTIVITY_STACK_SUPERVISOR);
+ }
+ }
+
+ @Override
+ public void saveANRState(String reason) {
+ synchronized (mGlobalLock) {
+ final StringWriter sw = new StringWriter();
+ final PrintWriter pw = new FastPrintWriter(sw, false, 1024);
+ pw.println(" ANR time: " + DateFormat.getDateTimeInstance().format(new Date()));
+ if (reason != null) {
+ pw.println(" Reason: " + reason);
+ }
+ pw.println();
+ getActivityStartController().dump(pw, " ", null);
+ pw.println();
+ pw.println("-------------------------------------------------------------------------------");
+ dumpActivitiesLocked(null /* fd */, pw, null /* args */, 0 /* opti */,
+ true /* dumpAll */, false /* dumpClient */, null /* dumpPackage */,
+ "" /* header */);
+ pw.println();
+ pw.close();
+
+ mLastANRState = sw.toString();
+ }
+ }
+
+ @Override
+ public void clearSavedANRState() {
+ synchronized (mGlobalLock) {
+ mLastANRState = null;
+ }
+ }
+
+ @Override
+ public void dump(String cmd, FileDescriptor fd, PrintWriter pw, String[] args, int opti,
+ boolean dumpAll, boolean dumpClient, String dumpPackage) {
+ synchronized (mGlobalLock) {
+ if (DUMP_ACTIVITIES_CMD.equals(cmd) || DUMP_ACTIVITIES_SHORT_CMD.equals(cmd)) {
+ dumpActivitiesLocked(fd, pw, args, opti, dumpAll, dumpClient, dumpPackage);
+ } else if (DUMP_LASTANR_CMD.equals(cmd)) {
+ dumpLastANRLocked(pw);
+ } else if (DUMP_LASTANR_TRACES_CMD.equals(cmd)) {
+ dumpLastANRTracesLocked(pw);
+ } else if (DUMP_STARTER_CMD.equals(cmd)) {
+ dumpActivityStarterLocked(pw, dumpPackage);
+ } else if (DUMP_CONTAINERS_CMD.equals(cmd)) {
+ dumpActivityContainersLocked(pw);
+ } else if (DUMP_RECENTS_CMD.equals(cmd) || DUMP_RECENTS_SHORT_CMD.equals(cmd)) {
+ if (getRecentTasks() != null) {
+ getRecentTasks().dump(pw, dumpAll, dumpPackage);
+ }
+ }
+ }
+ }
+
+ @Override
+ public boolean dumpForProcesses(FileDescriptor fd, PrintWriter pw, boolean dumpAll,
+ String dumpPackage, int dumpAppId, boolean needSep, boolean testPssMode,
+ int wakefulness) {
+ synchronized (mGlobalLock) {
+ if (mHomeProcess != null && (dumpPackage == null
+ || mHomeProcess.mPkgList.contains(dumpPackage))) {
+ if (needSep) {
+ pw.println();
+ needSep = false;
+ }
+ pw.println(" mHomeProcess: " + mHomeProcess);
+ }
+ if (mPreviousProcess != null && (dumpPackage == null
+ || mPreviousProcess.mPkgList.contains(dumpPackage))) {
+ if (needSep) {
+ pw.println();
+ needSep = false;
+ }
+ pw.println(" mPreviousProcess: " + mPreviousProcess);
+ }
+ if (dumpAll && (mPreviousProcess == null || dumpPackage == null
+ || mPreviousProcess.mPkgList.contains(dumpPackage))) {
+ StringBuilder sb = new StringBuilder(128);
+ sb.append(" mPreviousProcessVisibleTime: ");
+ TimeUtils.formatDuration(mPreviousProcessVisibleTime, sb);
+ pw.println(sb);
+ }
+ if (mHeavyWeightProcess != null && (dumpPackage == null
+ || mHeavyWeightProcess.mPkgList.contains(dumpPackage))) {
+ if (needSep) {
+ pw.println();
+ needSep = false;
+ }
+ pw.println(" mHeavyWeightProcess: " + mHeavyWeightProcess);
+ }
+ if (dumpPackage == null) {
+ pw.println(" mGlobalConfiguration: " + getGlobalConfiguration());
+ mStackSupervisor.dumpDisplayConfigs(pw, " ");
+ }
+ if (dumpAll) {
+ if (dumpPackage == null) {
+ pw.println(" mConfigWillChange: "
+ + getTopDisplayFocusedStack().mConfigWillChange);
+ }
+ if (mCompatModePackages.getPackages().size() > 0) {
+ boolean printed = false;
+ for (Map.Entry<String, Integer> entry
+ : mCompatModePackages.getPackages().entrySet()) {
+ String pkg = entry.getKey();
+ int mode = entry.getValue();
+ if (dumpPackage != null && !dumpPackage.equals(pkg)) {
+ continue;
+ }
+ if (!printed) {
+ pw.println(" mScreenCompatPackages:");
+ printed = true;
+ }
+ pw.println(" " + pkg + ": " + mode);
+ }
+ }
+ }
+
+ if (dumpPackage == null) {
+ pw.println(" mWakefulness="
+ + PowerManagerInternal.wakefulnessToString(wakefulness));
+ pw.println(" mSleepTokens=" + mStackSupervisor.mSleepTokens);
+ if (mRunningVoice != null) {
+ pw.println(" mRunningVoice=" + mRunningVoice);
+ pw.println(" mVoiceWakeLock" + mVoiceWakeLock);
+ }
+ pw.println(" mSleeping=" + mSleeping);
+ pw.println(" mShuttingDown=" + mShuttingDown + " mTestPssMode=" + testPssMode);
+ pw.println(" mVrController=" + mVrController);
+ }
+ if (mCurAppTimeTracker != null) {
+ mCurAppTimeTracker.dumpWithHeader(pw, " ", true);
+ }
+ if (mAllowAppSwitchUids.size() > 0) {
+ boolean printed = false;
+ for (int i = 0; i < mAllowAppSwitchUids.size(); i++) {
+ ArrayMap<String, Integer> types = mAllowAppSwitchUids.valueAt(i);
+ for (int j = 0; j < types.size(); j++) {
+ if (dumpPackage == null ||
+ UserHandle.getAppId(types.valueAt(j).intValue()) == dumpAppId) {
+ if (needSep) {
+ pw.println();
+ needSep = false;
+ }
+ if (!printed) {
+ pw.println(" mAllowAppSwitchUids:");
+ printed = true;
+ }
+ pw.print(" User ");
+ pw.print(mAllowAppSwitchUids.keyAt(i));
+ pw.print(": Type ");
+ pw.print(types.keyAt(j));
+ pw.print(" = ");
+ UserHandle.formatUid(pw, types.valueAt(j).intValue());
+ pw.println();
+ }
+ }
+ }
+ }
+ if (dumpPackage == null) {
+ if (mController != null) {
+ pw.println(" mController=" + mController
+ + " mControllerIsAMonkey=" + mControllerIsAMonkey);
+ }
+ pw.println(" mGoingToSleep=" + mStackSupervisor.mGoingToSleep);
+ pw.println(" mLaunchingActivity=" + mStackSupervisor.mLaunchingActivity);
+ }
+
+ return needSep;
+ }
+ }
+
+ @Override
+ public void writeProcessesToProto(ProtoOutputStream proto, String dumpPackage) {
+ synchronized (mGlobalLock) {
+ if (dumpPackage == null) {
+ getGlobalConfiguration().writeToProto(proto, GLOBAL_CONFIGURATION);
+ proto.write(CONFIG_WILL_CHANGE, getTopDisplayFocusedStack().mConfigWillChange);
+ writeSleepStateToProto(proto);
+ if (mController != null) {
+ final long token = proto.start(CONTROLLER);
+ proto.write(CONTROLLER, mController.toString());
+ proto.write(IS_A_MONKEY, mControllerIsAMonkey);
+ proto.end(token);
+ }
+ mStackSupervisor.mGoingToSleep.writeToProto(proto, GOING_TO_SLEEP);
+ mStackSupervisor.mLaunchingActivity.writeToProto(proto, LAUNCHING_ACTIVITY);
+ }
+
+ if (mHomeProcess != null && (dumpPackage == null
+ || mHomeProcess.mPkgList.contains(dumpPackage))) {
+ mHomeProcess.writeToProto(proto, HOME_PROC);
+ }
+
+ if (mPreviousProcess != null && (dumpPackage == null
+ || mPreviousProcess.mPkgList.contains(dumpPackage))) {
+ mPreviousProcess.writeToProto(proto, PREVIOUS_PROC);
+ proto.write(PREVIOUS_PROC_VISIBLE_TIME_MS, mPreviousProcessVisibleTime);
+ }
+
+ if (mHeavyWeightProcess != null && (dumpPackage == null
+ || mHeavyWeightProcess.mPkgList.contains(dumpPackage))) {
+ mHeavyWeightProcess.writeToProto(proto, HEAVY_WEIGHT_PROC);
+ }
+
+ for (Map.Entry<String, Integer> entry
+ : mCompatModePackages.getPackages().entrySet()) {
+ String pkg = entry.getKey();
+ int mode = entry.getValue();
+ if (dumpPackage == null || dumpPackage.equals(pkg)) {
+ long compatToken = proto.start(SCREEN_COMPAT_PACKAGES);
+ proto.write(PACKAGE, pkg);
+ proto.write(MODE, mode);
+ proto.end(compatToken);
+ }
+ }
+
+ if (mCurAppTimeTracker != null) {
+ mCurAppTimeTracker.writeToProto(proto, CURRENT_TRACKER, true);
+ }
+
+ }
+ }
+
+ @Override
+ public boolean dumpActivity(FileDescriptor fd, PrintWriter pw, String name,
+ String[] args, int opti, boolean dumpAll, boolean dumpVisibleStacksOnly,
+ boolean dumpFocusedStackOnly) {
+ synchronized (mGlobalLock) {
+ return ActivityTaskManagerService.this.dumpActivity(fd, pw, name, args, opti,
+ dumpAll, dumpVisibleStacksOnly, dumpFocusedStackOnly);
+ }
+ }
+
+ @Override
+ public void dumpForOom(PrintWriter pw) {
+ synchronized (mGlobalLock) {
+ pw.println(" mHomeProcess: " + mHomeProcess);
+ pw.println(" mPreviousProcess: " + mPreviousProcess);
+ if (mHeavyWeightProcess != null) {
+ pw.println(" mHeavyWeightProcess: " + mHeavyWeightProcess);
+ }
+ }
+ }
+
+ @Override
+ public boolean canGcNow() {
+ synchronized (mGlobalLock) {
+ return isSleeping() || mStackSupervisor.allResumedActivitiesIdle();
+ }
+ }
+
+ @Override
+ public WindowProcessController getTopApp() {
+ synchronized (mGlobalLock) {
+ final ActivityRecord top = mStackSupervisor.getTopResumedActivity();
+ return top != null ? top.app : null;
+ }
+ }
+
+ @Override
+ public void rankTaskLayersIfNeeded() {
+ synchronized (mGlobalLock) {
+ if (mStackSupervisor != null) {
+ mStackSupervisor.rankTaskLayersIfNeeded();
+ }
+ }
+ }
+
+ @Override
+ public void scheduleDestroyAllActivities(String reason) {
+ synchronized (mGlobalLock) {
+ mStackSupervisor.scheduleDestroyAllActivities(null, reason);
+ }
+ }
+
+ @Override
+ public void removeUser(int userId) {
+ synchronized (mGlobalLock) {
+ mStackSupervisor.removeUserLocked(userId);
+ }
+ }
+
+ @Override
+ public boolean switchUser(int userId, UserState userState) {
+ synchronized (mGlobalLock) {
+ return mStackSupervisor.switchUserLocked(userId, userState);
+ }
+ }
+
+ @Override
+ public void onHandleAppCrash(WindowProcessController wpc) {
+ synchronized (mGlobalLock) {
+ mStackSupervisor.handleAppCrashLocked(wpc);
+ }
+ }
+
+ @Override
+ public int finishTopCrashedActivities(WindowProcessController crashedApp, String reason) {
+ synchronized (mGlobalLock) {
+ return mStackSupervisor.finishTopCrashedActivitiesLocked(crashedApp, reason);
+ }
+ }
+
+ @Override
+ public void onUidActive(int uid, int procState) {
+ synchronized (mGlobalLock) {
+ mActiveUids.put(uid, procState);
+ }
+ }
+
+ @Override
+ public void onUidInactive(int uid) {
+ synchronized (mGlobalLock) {
+ mActiveUids.remove(uid);
+ }
+ }
+
+ @Override
+ public void onActiveUidsCleared() {
+ synchronized (mGlobalLock) {
+ mActiveUids.clear();
+ }
+ }
+
+ @Override
+ public void onUidProcStateChanged(int uid, int procState) {
+ synchronized (mGlobalLock) {
+ if (mActiveUids.get(uid) != null) {
+ mActiveUids.put(uid, procState);
+ }
+ }
+ }
+
+ @Override
+ public void onUidAddedToPendingTempWhitelist(int uid, String tag) {
+ synchronized (mGlobalLock) {
+ mPendingTempWhitelist.put(uid, tag);
+ }
+ }
+
+ @Override
+ public void onUidRemovedFromPendingTempWhitelist(int uid) {
+ synchronized (mGlobalLock) {
+ mPendingTempWhitelist.remove(uid);
+ }
+ }
+
+ @Override
+ public boolean handleAppCrashInActivityController(String processName, int pid,
+ String shortMsg, String longMsg, long timeMillis, String stackTrace,
+ Runnable killCrashingAppCallback) {
+ synchronized (mGlobalLock) {
+ if (mController == null) {
+ return false;
+ }
+
+ try {
+ if (!mController.appCrashed(processName, pid, shortMsg, longMsg, timeMillis,
+ stackTrace)) {
+ killCrashingAppCallback.run();
+ return true;
+ }
+ } catch (RemoteException e) {
+ mController = null;
+ Watchdog.getInstance().setActivityController(null);
+ }
+ return false;
+ }
+ }
+
+ @Override
+ public void removeRecentTasksByPackageName(String packageName, int userId) {
+ synchronized (mGlobalLock) {
+ mRecentTasks.removeTasksByPackageName(packageName, userId);
+ }
+ }
+
+ @Override
+ public void cleanupRecentTasksForUser(int userId) {
+ synchronized (mGlobalLock) {
+ mRecentTasks.cleanupLocked(userId);
+ }
+ }
+
+ @Override
+ public void loadRecentTasksForUser(int userId) {
+ synchronized (mGlobalLock) {
+ mRecentTasks.loadUserRecentsLocked(userId);
+ }
+ }
+
+ @Override
+ public void onPackagesSuspendedChanged(String[] packages, boolean suspended, int userId) {
+ synchronized (mGlobalLock) {
+ mRecentTasks.onPackagesSuspendedChanged(packages, suspended, userId);
+ }
+ }
+
+ @Override
+ public void flushRecentTasks() {
+ mRecentTasks.flush();
+ }
+
+ @Override
+ public WindowProcessController getHomeProcess() {
+ synchronized (mGlobalLock) {
+ return mHomeProcess;
+ }
+ }
+
+ @Override
+ public WindowProcessController getPreviousProcess() {
+ synchronized (mGlobalLock) {
+ return mPreviousProcess;
+ }
+ }
+
+ @Override
+ public void clearLockedTasks(String reason) {
+ synchronized (mGlobalLock) {
+ getLockTaskController().clearLockedTasks(reason);
+ }
+ }
+
+ @Override
+ public void updateUserConfiguration() {
+ synchronized (mGlobalLock) {
+ final Configuration configuration = new Configuration(getGlobalConfiguration());
+ final int currentUserId = mAmInternal.getCurrentUserId();
+ Settings.System.adjustConfigurationForUser(mContext.getContentResolver(),
+ configuration, currentUserId, Settings.System.canWrite(mContext));
+ updateConfigurationLocked(configuration, null /* starting */,
+ false /* initLocale */, false /* persistent */, currentUserId,
+ false /* deferResume */);
+ }
+ }
+
+ @Override
+ public boolean canShowErrorDialogs() {
+ synchronized (mGlobalLock) {
+ return mShowDialogs && !mSleeping && !mShuttingDown
+ && !mKeyguardController.isKeyguardOrAodShowing(DEFAULT_DISPLAY)
+ && !hasUserRestriction(UserManager.DISALLOW_SYSTEM_ERROR_DIALOGS,
+ mAmInternal.getCurrentUserId())
+ && !(UserManager.isDeviceInDemoMode(mContext)
+ && mAmInternal.getCurrentUser().isDemo());
+ }
+ }
+ }
+}
diff --git a/services/core/java/com/android/server/wm/AppTaskImpl.java b/services/core/java/com/android/server/wm/AppTaskImpl.java
new file mode 100644
index 0000000..04fef02
--- /dev/null
+++ b/services/core/java/com/android/server/wm/AppTaskImpl.java
@@ -0,0 +1,163 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.server.wm;
+
+import static com.android.server.wm.ActivityStackSupervisor.MATCH_TASK_IN_STACKS_OR_RECENT_TASKS;
+import static com.android.server.wm.ActivityStackSupervisor.REMOVE_FROM_RECENTS;
+
+import android.app.ActivityManager;
+import android.app.IAppTask;
+import android.app.IApplicationThread;
+import android.content.Intent;
+import android.os.Binder;
+import android.os.Bundle;
+import android.os.IBinder;
+import android.os.UserHandle;
+
+/**
+ * An implementation of IAppTask, that allows an app to manage its own tasks via
+ * {@link android.app.ActivityManager.AppTask}. We keep track of the callingUid to ensure that
+ * only the process that calls getAppTasks() can call the AppTask methods.
+ */
+class AppTaskImpl extends IAppTask.Stub {
+ private ActivityTaskManagerService mService;
+
+ private int mTaskId;
+ private int mCallingUid;
+
+ public AppTaskImpl(ActivityTaskManagerService service, int taskId, int callingUid) {
+ mService = service;
+ mTaskId = taskId;
+ mCallingUid = callingUid;
+ }
+
+ private void checkCaller() {
+ if (mCallingUid != Binder.getCallingUid()) {
+ throw new SecurityException("Caller " + mCallingUid
+ + " does not match caller of getAppTasks(): " + Binder.getCallingUid());
+ }
+ }
+
+ @Override
+ public void finishAndRemoveTask() {
+ checkCaller();
+
+ synchronized (mService.mGlobalLock) {
+ long origId = Binder.clearCallingIdentity();
+ try {
+ // We remove the task from recents to preserve backwards
+ if (!mService.mStackSupervisor.removeTaskByIdLocked(mTaskId, false,
+ REMOVE_FROM_RECENTS, "finish-and-remove-task")) {
+ throw new IllegalArgumentException("Unable to find task ID " + mTaskId);
+ }
+ } finally {
+ Binder.restoreCallingIdentity(origId);
+ }
+ }
+ }
+
+ @Override
+ public ActivityManager.RecentTaskInfo getTaskInfo() {
+ checkCaller();
+
+ synchronized (mService.mGlobalLock) {
+ long origId = Binder.clearCallingIdentity();
+ try {
+ TaskRecord tr = mService.mStackSupervisor.anyTaskForIdLocked(mTaskId,
+ MATCH_TASK_IN_STACKS_OR_RECENT_TASKS);
+ if (tr == null) {
+ throw new IllegalArgumentException("Unable to find task ID " + mTaskId);
+ }
+ return mService.getRecentTasks().createRecentTaskInfo(tr);
+ } finally {
+ Binder.restoreCallingIdentity(origId);
+ }
+ }
+ }
+
+ @Override
+ public void moveToFront() {
+ checkCaller();
+ // Will bring task to front if it already has a root activity.
+ final int callingPid = Binder.getCallingPid();
+ final int callingUid = Binder.getCallingUid();
+ final long origId = Binder.clearCallingIdentity();
+ try {
+ synchronized (mService.mGlobalLock) {
+ mService.mStackSupervisor.startActivityFromRecents(callingPid, callingUid, mTaskId,
+ null);
+ }
+ } finally {
+ Binder.restoreCallingIdentity(origId);
+ }
+ }
+
+ @Override
+ public int startActivity(IBinder whoThread, String callingPackage,
+ Intent intent, String resolvedType, Bundle bOptions) {
+ checkCaller();
+
+ int callingUser = UserHandle.getCallingUserId();
+ TaskRecord tr;
+ IApplicationThread appThread;
+ synchronized (mService.mGlobalLock) {
+ tr = mService.mStackSupervisor.anyTaskForIdLocked(mTaskId,
+ MATCH_TASK_IN_STACKS_OR_RECENT_TASKS);
+ if (tr == null) {
+ throw new IllegalArgumentException("Unable to find task ID " + mTaskId);
+ }
+ appThread = IApplicationThread.Stub.asInterface(whoThread);
+ if (appThread == null) {
+ throw new IllegalArgumentException("Bad app thread " + appThread);
+ }
+ }
+
+ return mService.getActivityStartController().obtainStarter(intent, "AppTaskImpl")
+ .setCaller(appThread)
+ .setCallingPackage(callingPackage)
+ .setResolvedType(resolvedType)
+ .setActivityOptions(bOptions)
+ .setMayWait(callingUser)
+ .setInTask(tr)
+ .execute();
+ }
+
+ @Override
+ public void setExcludeFromRecents(boolean exclude) {
+ checkCaller();
+
+ synchronized (mService.mGlobalLock) {
+ long origId = Binder.clearCallingIdentity();
+ try {
+ TaskRecord tr = mService.mStackSupervisor.anyTaskForIdLocked(mTaskId,
+ MATCH_TASK_IN_STACKS_OR_RECENT_TASKS);
+ if (tr == null) {
+ throw new IllegalArgumentException("Unable to find task ID " + mTaskId);
+ }
+ Intent intent = tr.getBaseIntent();
+ if (exclude) {
+ intent.addFlags(Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS);
+ } else {
+ intent.setFlags(intent.getFlags()
+ & ~Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS);
+ }
+ } finally {
+ Binder.restoreCallingIdentity(origId);
+ }
+ }
+ }
+}
diff --git a/services/core/java/com/android/server/wm/AppWarnings.java b/services/core/java/com/android/server/wm/AppWarnings.java
new file mode 100644
index 0000000..0436857
--- /dev/null
+++ b/services/core/java/com/android/server/wm/AppWarnings.java
@@ -0,0 +1,569 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.server.wm;
+
+import android.annotation.UiThread;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.res.Configuration;
+import android.os.Build;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.Message;
+import android.util.AtomicFile;
+import android.util.DisplayMetrics;
+import android.util.Slog;
+import android.util.Xml;
+
+import com.android.internal.util.FastXmlSerializer;
+
+import org.xmlpull.v1.XmlPullParser;
+import org.xmlpull.v1.XmlPullParserException;
+import org.xmlpull.v1.XmlSerializer;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+
+/**
+ * Manages warning dialogs shown during application lifecycle.
+ */
+class AppWarnings {
+ private static final String TAG = "AppWarnings";
+ private static final String CONFIG_FILE_NAME = "packages-warnings.xml";
+
+ public static final int FLAG_HIDE_DISPLAY_SIZE = 0x01;
+ public static final int FLAG_HIDE_COMPILE_SDK = 0x02;
+ public static final int FLAG_HIDE_DEPRECATED_SDK = 0x04;
+
+ private final HashMap<String, Integer> mPackageFlags = new HashMap<>();
+
+ private final ActivityTaskManagerService mAtm;
+ private final Context mUiContext;
+ private final ConfigHandler mHandler;
+ private final UiHandler mUiHandler;
+ private final AtomicFile mConfigFile;
+
+ private UnsupportedDisplaySizeDialog mUnsupportedDisplaySizeDialog;
+ private UnsupportedCompileSdkDialog mUnsupportedCompileSdkDialog;
+ private DeprecatedTargetSdkVersionDialog mDeprecatedTargetSdkVersionDialog;
+
+ /** @see android.app.ActivityManager#alwaysShowUnsupportedCompileSdkWarning */
+ private HashSet<ComponentName> mAlwaysShowUnsupportedCompileSdkWarningActivities =
+ new HashSet<>();
+
+ /** @see android.app.ActivityManager#alwaysShowUnsupportedCompileSdkWarning */
+ void alwaysShowUnsupportedCompileSdkWarning(ComponentName activity) {
+ mAlwaysShowUnsupportedCompileSdkWarningActivities.add(activity);
+ }
+
+ /**
+ * Creates a new warning dialog manager.
+ * <p>
+ * <strong>Note:</strong> Must be called from the ActivityManagerService thread.
+ *
+ * @param atm
+ * @param uiContext
+ * @param handler
+ * @param uiHandler
+ * @param systemDir
+ */
+ public AppWarnings(ActivityTaskManagerService atm, Context uiContext, Handler handler,
+ Handler uiHandler, File systemDir) {
+ mAtm = atm;
+ mUiContext = uiContext;
+ mHandler = new ConfigHandler(handler.getLooper());
+ mUiHandler = new UiHandler(uiHandler.getLooper());
+ mConfigFile = new AtomicFile(new File(systemDir, CONFIG_FILE_NAME), "warnings-config");
+
+ readConfigFromFileAmsThread();
+ }
+
+ /**
+ * Shows the "unsupported display size" warning, if necessary.
+ *
+ * @param r activity record for which the warning may be displayed
+ */
+ public void showUnsupportedDisplaySizeDialogIfNeeded(ActivityRecord r) {
+ final Configuration globalConfig = mAtm.getGlobalConfiguration();
+ if (globalConfig.densityDpi != DisplayMetrics.DENSITY_DEVICE_STABLE
+ && r.appInfo.requiresSmallestWidthDp > globalConfig.smallestScreenWidthDp) {
+ mUiHandler.showUnsupportedDisplaySizeDialog(r);
+ }
+ }
+
+ /**
+ * Shows the "unsupported compile SDK" warning, if necessary.
+ *
+ * @param r activity record for which the warning may be displayed
+ */
+ public void showUnsupportedCompileSdkDialogIfNeeded(ActivityRecord r) {
+ if (r.appInfo.compileSdkVersion == 0 || r.appInfo.compileSdkVersionCodename == null) {
+ // We don't know enough about this package. Abort!
+ return;
+ }
+
+ // TODO(b/75318890): Need to move this to when the app actually crashes.
+ if (/*ActivityManager.isRunningInTestHarness()
+ &&*/ !mAlwaysShowUnsupportedCompileSdkWarningActivities.contains(r.realActivity)) {
+ // Don't show warning if we are running in a test harness and we don't have to always
+ // show for this activity.
+ return;
+ }
+
+ // If the application was built against an pre-release SDK that's older than the current
+ // platform OR if the current platform is pre-release and older than the SDK against which
+ // the application was built OR both are pre-release with the same SDK_INT but different
+ // codenames (e.g. simultaneous pre-release development), then we're likely to run into
+ // compatibility issues. Warn the user and offer to check for an update.
+ final int compileSdk = r.appInfo.compileSdkVersion;
+ final int platformSdk = Build.VERSION.SDK_INT;
+ final boolean isCompileSdkPreview = !"REL".equals(r.appInfo.compileSdkVersionCodename);
+ final boolean isPlatformSdkPreview = !"REL".equals(Build.VERSION.CODENAME);
+ if ((isCompileSdkPreview && compileSdk < platformSdk)
+ || (isPlatformSdkPreview && platformSdk < compileSdk)
+ || (isCompileSdkPreview && isPlatformSdkPreview && platformSdk == compileSdk
+ && !Build.VERSION.CODENAME.equals(r.appInfo.compileSdkVersionCodename))) {
+ mUiHandler.showUnsupportedCompileSdkDialog(r);
+ }
+ }
+
+ /**
+ * Shows the "deprecated target sdk" warning, if necessary.
+ *
+ * @param r activity record for which the warning may be displayed
+ */
+ public void showDeprecatedTargetDialogIfNeeded(ActivityRecord r) {
+ if (r.appInfo.targetSdkVersion < Build.VERSION.MIN_SUPPORTED_TARGET_SDK_INT) {
+ mUiHandler.showDeprecatedTargetDialog(r);
+ }
+ }
+
+ /**
+ * Called when an activity is being started.
+ *
+ * @param r record for the activity being started
+ */
+ public void onStartActivity(ActivityRecord r) {
+ showUnsupportedCompileSdkDialogIfNeeded(r);
+ showUnsupportedDisplaySizeDialogIfNeeded(r);
+ showDeprecatedTargetDialogIfNeeded(r);
+ }
+
+ /**
+ * Called when an activity was previously started and is being resumed.
+ *
+ * @param r record for the activity being resumed
+ */
+ public void onResumeActivity(ActivityRecord r) {
+ showUnsupportedDisplaySizeDialogIfNeeded(r);
+ }
+
+ /**
+ * Called by ActivityManagerService when package data has been cleared.
+ *
+ * @param name the package whose data has been cleared
+ */
+ public void onPackageDataCleared(String name) {
+ removePackageAndHideDialogs(name);
+ }
+
+ /**
+ * Called by ActivityManagerService when a package has been uninstalled.
+ *
+ * @param name the package that has been uninstalled
+ */
+ public void onPackageUninstalled(String name) {
+ removePackageAndHideDialogs(name);
+ }
+
+ /**
+ * Called by ActivityManagerService when the default display density has changed.
+ */
+ public void onDensityChanged() {
+ mUiHandler.hideUnsupportedDisplaySizeDialog();
+ }
+
+ /**
+ * Does what it says on the tin.
+ */
+ private void removePackageAndHideDialogs(String name) {
+ mUiHandler.hideDialogsForPackage(name);
+
+ synchronized (mPackageFlags) {
+ mPackageFlags.remove(name);
+ mHandler.scheduleWrite();
+ }
+ }
+
+ /**
+ * Hides the "unsupported display size" warning.
+ * <p>
+ * <strong>Note:</strong> Must be called on the UI thread.
+ */
+ @UiThread
+ private void hideUnsupportedDisplaySizeDialogUiThread() {
+ if (mUnsupportedDisplaySizeDialog != null) {
+ mUnsupportedDisplaySizeDialog.dismiss();
+ mUnsupportedDisplaySizeDialog = null;
+ }
+ }
+
+ /**
+ * Shows the "unsupported display size" warning for the given application.
+ * <p>
+ * <strong>Note:</strong> Must be called on the UI thread.
+ *
+ * @param ar record for the activity that triggered the warning
+ */
+ @UiThread
+ private void showUnsupportedDisplaySizeDialogUiThread(ActivityRecord ar) {
+ if (mUnsupportedDisplaySizeDialog != null) {
+ mUnsupportedDisplaySizeDialog.dismiss();
+ mUnsupportedDisplaySizeDialog = null;
+ }
+ if (ar != null && !hasPackageFlag(
+ ar.packageName, FLAG_HIDE_DISPLAY_SIZE)) {
+ mUnsupportedDisplaySizeDialog = new UnsupportedDisplaySizeDialog(
+ AppWarnings.this, mUiContext, ar.info.applicationInfo);
+ mUnsupportedDisplaySizeDialog.show();
+ }
+ }
+
+ /**
+ * Shows the "unsupported compile SDK" warning for the given application.
+ * <p>
+ * <strong>Note:</strong> Must be called on the UI thread.
+ *
+ * @param ar record for the activity that triggered the warning
+ */
+ @UiThread
+ private void showUnsupportedCompileSdkDialogUiThread(ActivityRecord ar) {
+ if (mUnsupportedCompileSdkDialog != null) {
+ mUnsupportedCompileSdkDialog.dismiss();
+ mUnsupportedCompileSdkDialog = null;
+ }
+ if (ar != null && !hasPackageFlag(
+ ar.packageName, FLAG_HIDE_COMPILE_SDK)) {
+ mUnsupportedCompileSdkDialog = new UnsupportedCompileSdkDialog(
+ AppWarnings.this, mUiContext, ar.info.applicationInfo);
+ mUnsupportedCompileSdkDialog.show();
+ }
+ }
+
+ /**
+ * Shows the "deprecated target sdk version" warning for the given application.
+ * <p>
+ * <strong>Note:</strong> Must be called on the UI thread.
+ *
+ * @param ar record for the activity that triggered the warning
+ */
+ @UiThread
+ private void showDeprecatedTargetSdkDialogUiThread(ActivityRecord ar) {
+ if (mDeprecatedTargetSdkVersionDialog != null) {
+ mDeprecatedTargetSdkVersionDialog.dismiss();
+ mDeprecatedTargetSdkVersionDialog = null;
+ }
+ if (ar != null && !hasPackageFlag(
+ ar.packageName, FLAG_HIDE_DEPRECATED_SDK)) {
+ mDeprecatedTargetSdkVersionDialog = new DeprecatedTargetSdkVersionDialog(
+ AppWarnings.this, mUiContext, ar.info.applicationInfo);
+ mDeprecatedTargetSdkVersionDialog.show();
+ }
+ }
+
+ /**
+ * Dismisses all warnings for the given package.
+ * <p>
+ * <strong>Note:</strong> Must be called on the UI thread.
+ *
+ * @param name the package for which warnings should be dismissed, or {@code null} to dismiss
+ * all warnings
+ */
+ @UiThread
+ private void hideDialogsForPackageUiThread(String name) {
+ // Hides the "unsupported display" dialog if necessary.
+ if (mUnsupportedDisplaySizeDialog != null && (name == null || name.equals(
+ mUnsupportedDisplaySizeDialog.getPackageName()))) {
+ mUnsupportedDisplaySizeDialog.dismiss();
+ mUnsupportedDisplaySizeDialog = null;
+ }
+
+ // Hides the "unsupported compile SDK" dialog if necessary.
+ if (mUnsupportedCompileSdkDialog != null && (name == null || name.equals(
+ mUnsupportedCompileSdkDialog.getPackageName()))) {
+ mUnsupportedCompileSdkDialog.dismiss();
+ mUnsupportedCompileSdkDialog = null;
+ }
+
+ // Hides the "deprecated target sdk version" dialog if necessary.
+ if (mDeprecatedTargetSdkVersionDialog != null && (name == null || name.equals(
+ mDeprecatedTargetSdkVersionDialog.getPackageName()))) {
+ mDeprecatedTargetSdkVersionDialog.dismiss();
+ mDeprecatedTargetSdkVersionDialog = null;
+ }
+ }
+
+ /**
+ * Returns the value of the flag for the given package.
+ *
+ * @param name the package from which to retrieve the flag
+ * @param flag the bitmask for the flag to retrieve
+ * @return {@code true} if the flag is enabled, {@code false} otherwise
+ */
+ boolean hasPackageFlag(String name, int flag) {
+ return (getPackageFlags(name) & flag) == flag;
+ }
+
+ /**
+ * Sets the flag for the given package to the specified value.
+ *
+ * @param name the package on which to set the flag
+ * @param flag the bitmask for flag to set
+ * @param enabled the value to set for the flag
+ */
+ void setPackageFlag(String name, int flag, boolean enabled) {
+ synchronized (mPackageFlags) {
+ final int curFlags = getPackageFlags(name);
+ final int newFlags = enabled ? (curFlags | flag) : (curFlags & ~flag);
+ if (curFlags != newFlags) {
+ if (newFlags != 0) {
+ mPackageFlags.put(name, newFlags);
+ } else {
+ mPackageFlags.remove(name);
+ }
+ mHandler.scheduleWrite();
+ }
+ }
+ }
+
+ /**
+ * Returns the bitmask of flags set for the specified package.
+ */
+ private int getPackageFlags(String name) {
+ synchronized (mPackageFlags) {
+ return mPackageFlags.getOrDefault(name, 0);
+ }
+ }
+
+ /**
+ * Handles messages on the system process UI thread.
+ */
+ private final class UiHandler extends Handler {
+ private static final int MSG_SHOW_UNSUPPORTED_DISPLAY_SIZE_DIALOG = 1;
+ private static final int MSG_HIDE_UNSUPPORTED_DISPLAY_SIZE_DIALOG = 2;
+ private static final int MSG_SHOW_UNSUPPORTED_COMPILE_SDK_DIALOG = 3;
+ private static final int MSG_HIDE_DIALOGS_FOR_PACKAGE = 4;
+ private static final int MSG_SHOW_DEPRECATED_TARGET_SDK_DIALOG = 5;
+
+ public UiHandler(Looper looper) {
+ super(looper, null, true);
+ }
+
+ @Override
+ public void handleMessage(Message msg) {
+ switch (msg.what) {
+ case MSG_SHOW_UNSUPPORTED_DISPLAY_SIZE_DIALOG: {
+ final ActivityRecord ar = (ActivityRecord) msg.obj;
+ showUnsupportedDisplaySizeDialogUiThread(ar);
+ } break;
+ case MSG_HIDE_UNSUPPORTED_DISPLAY_SIZE_DIALOG: {
+ hideUnsupportedDisplaySizeDialogUiThread();
+ } break;
+ case MSG_SHOW_UNSUPPORTED_COMPILE_SDK_DIALOG: {
+ final ActivityRecord ar = (ActivityRecord) msg.obj;
+ showUnsupportedCompileSdkDialogUiThread(ar);
+ } break;
+ case MSG_HIDE_DIALOGS_FOR_PACKAGE: {
+ final String name = (String) msg.obj;
+ hideDialogsForPackageUiThread(name);
+ } break;
+ case MSG_SHOW_DEPRECATED_TARGET_SDK_DIALOG: {
+ final ActivityRecord ar = (ActivityRecord) msg.obj;
+ showDeprecatedTargetSdkDialogUiThread(ar);
+ } break;
+ }
+ }
+
+ public void showUnsupportedDisplaySizeDialog(ActivityRecord r) {
+ removeMessages(MSG_SHOW_UNSUPPORTED_DISPLAY_SIZE_DIALOG);
+ obtainMessage(MSG_SHOW_UNSUPPORTED_DISPLAY_SIZE_DIALOG, r).sendToTarget();
+ }
+
+ public void hideUnsupportedDisplaySizeDialog() {
+ removeMessages(MSG_HIDE_UNSUPPORTED_DISPLAY_SIZE_DIALOG);
+ sendEmptyMessage(MSG_HIDE_UNSUPPORTED_DISPLAY_SIZE_DIALOG);
+ }
+
+ public void showUnsupportedCompileSdkDialog(ActivityRecord r) {
+ removeMessages(MSG_SHOW_UNSUPPORTED_COMPILE_SDK_DIALOG);
+ obtainMessage(MSG_SHOW_UNSUPPORTED_COMPILE_SDK_DIALOG, r).sendToTarget();
+ }
+
+ public void showDeprecatedTargetDialog(ActivityRecord r) {
+ removeMessages(MSG_SHOW_DEPRECATED_TARGET_SDK_DIALOG);
+ obtainMessage(MSG_SHOW_DEPRECATED_TARGET_SDK_DIALOG, r).sendToTarget();
+ }
+
+ public void hideDialogsForPackage(String name) {
+ obtainMessage(MSG_HIDE_DIALOGS_FOR_PACKAGE, name).sendToTarget();
+ }
+ }
+
+ /**
+ * Handles messages on the ActivityTaskManagerService thread.
+ */
+ private final class ConfigHandler extends Handler {
+ private static final int MSG_WRITE = 1;
+
+ private static final int DELAY_MSG_WRITE = 10000;
+
+ public ConfigHandler(Looper looper) {
+ super(looper, null, true);
+ }
+
+ @Override
+ public void handleMessage(Message msg) {
+ switch (msg.what) {
+ case MSG_WRITE:
+ writeConfigToFileAmsThread();
+ break;
+ }
+ }
+
+ public void scheduleWrite() {
+ removeMessages(MSG_WRITE);
+ sendEmptyMessageDelayed(MSG_WRITE, DELAY_MSG_WRITE);
+ }
+ }
+
+ /**
+ * Writes the configuration file.
+ * <p>
+ * <strong>Note:</strong> Should be called from the ActivityManagerService thread unless you
+ * don't care where you're doing I/O operations. But you <i>do</i> care, don't you?
+ */
+ private void writeConfigToFileAmsThread() {
+ // Create a shallow copy so that we don't have to synchronize on config.
+ final HashMap<String, Integer> packageFlags;
+ synchronized (mPackageFlags) {
+ packageFlags = new HashMap<>(mPackageFlags);
+ }
+
+ FileOutputStream fos = null;
+ try {
+ fos = mConfigFile.startWrite();
+
+ final XmlSerializer out = new FastXmlSerializer();
+ out.setOutput(fos, StandardCharsets.UTF_8.name());
+ out.startDocument(null, true);
+ out.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output", true);
+ out.startTag(null, "packages");
+
+ for (Map.Entry<String, Integer> entry : packageFlags.entrySet()) {
+ String pkg = entry.getKey();
+ int mode = entry.getValue();
+ if (mode == 0) {
+ continue;
+ }
+ out.startTag(null, "package");
+ out.attribute(null, "name", pkg);
+ out.attribute(null, "flags", Integer.toString(mode));
+ out.endTag(null, "package");
+ }
+
+ out.endTag(null, "packages");
+ out.endDocument();
+
+ mConfigFile.finishWrite(fos);
+ } catch (java.io.IOException e1) {
+ Slog.w(TAG, "Error writing package metadata", e1);
+ if (fos != null) {
+ mConfigFile.failWrite(fos);
+ }
+ }
+ }
+
+ /**
+ * Reads the configuration file and populates the package flags.
+ * <p>
+ * <strong>Note:</strong> Must be called from the constructor (and thus on the
+ * ActivityManagerService thread) since we don't synchronize on config.
+ */
+ private void readConfigFromFileAmsThread() {
+ FileInputStream fis = null;
+
+ try {
+ fis = mConfigFile.openRead();
+
+ final XmlPullParser parser = Xml.newPullParser();
+ parser.setInput(fis, StandardCharsets.UTF_8.name());
+
+ int eventType = parser.getEventType();
+ while (eventType != XmlPullParser.START_TAG &&
+ eventType != XmlPullParser.END_DOCUMENT) {
+ eventType = parser.next();
+ }
+ if (eventType == XmlPullParser.END_DOCUMENT) {
+ return;
+ }
+
+ String tagName = parser.getName();
+ if ("packages".equals(tagName)) {
+ eventType = parser.next();
+ do {
+ if (eventType == XmlPullParser.START_TAG) {
+ tagName = parser.getName();
+ if (parser.getDepth() == 2) {
+ if ("package".equals(tagName)) {
+ final String name = parser.getAttributeValue(null, "name");
+ if (name != null) {
+ final String flags = parser.getAttributeValue(
+ null, "flags");
+ int flagsInt = 0;
+ if (flags != null) {
+ try {
+ flagsInt = Integer.parseInt(flags);
+ } catch (NumberFormatException e) {
+ }
+ }
+ mPackageFlags.put(name, flagsInt);
+ }
+ }
+ }
+ }
+ eventType = parser.next();
+ } while (eventType != XmlPullParser.END_DOCUMENT);
+ }
+ } catch (XmlPullParserException e) {
+ Slog.w(TAG, "Error reading package metadata", e);
+ } catch (java.io.IOException e) {
+ if (fis != null) Slog.w(TAG, "Error reading package metadata", e);
+ } finally {
+ if (fis != null) {
+ try {
+ fis.close();
+ } catch (java.io.IOException e1) {
+ }
+ }
+ }
+ }
+}
diff --git a/services/core/java/com/android/server/wm/AssistDataReceiverProxy.java b/services/core/java/com/android/server/wm/AssistDataReceiverProxy.java
new file mode 100644
index 0000000..6756273
--- /dev/null
+++ b/services/core/java/com/android/server/wm/AssistDataReceiverProxy.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.server.wm;
+
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_ATM;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_WITH_CLASS_NAME;
+
+import android.app.IAssistDataReceiver;
+import android.graphics.Bitmap;
+import android.os.Binder;
+import android.os.Bundle;
+import android.os.RemoteException;
+import android.util.Log;
+
+import com.android.server.am.AssistDataRequester.AssistDataRequesterCallbacks;
+
+/**
+ * Proxies assist data to the given receiver, skipping all callbacks if the receiver dies.
+ */
+class AssistDataReceiverProxy implements AssistDataRequesterCallbacks,
+ Binder.DeathRecipient {
+
+ private static final String TAG = TAG_WITH_CLASS_NAME ? "AssistDataReceiverProxy" : TAG_ATM;
+
+ private String mCallerPackage;
+ private IAssistDataReceiver mReceiver;
+
+ public AssistDataReceiverProxy(IAssistDataReceiver receiver, String callerPackage) {
+ mReceiver = receiver;
+ mCallerPackage = callerPackage;
+ linkToDeath();
+ }
+
+ @Override
+ public boolean canHandleReceivedAssistDataLocked() {
+ // We are forwarding, so we can always receive this data
+ return true;
+ }
+
+ @Override
+ public void onAssistDataReceivedLocked(Bundle data, int activityIndex, int activityCount) {
+ if (mReceiver != null) {
+ try {
+ mReceiver.onHandleAssistData(data);
+ } catch (RemoteException e) {
+ Log.w(TAG, "Failed to proxy assist data to receiver in package="
+ + mCallerPackage, e);
+ }
+ }
+ }
+
+ @Override
+ public void onAssistScreenshotReceivedLocked(Bitmap screenshot) {
+ if (mReceiver != null) {
+ try {
+ mReceiver.onHandleAssistScreenshot(screenshot);
+ } catch (RemoteException e) {
+ Log.w(TAG, "Failed to proxy assist screenshot to receiver in package="
+ + mCallerPackage, e);
+ }
+ }
+ }
+
+ @Override
+ public void onAssistRequestCompleted() {
+ unlinkToDeath();
+ }
+
+ @Override
+ public void binderDied() {
+ unlinkToDeath();
+ }
+
+ private void linkToDeath() {
+ try {
+ mReceiver.asBinder().linkToDeath(this, 0);
+ } catch (RemoteException e) {
+ Log.w(TAG, "Could not link to client death", e);
+ }
+ }
+
+ private void unlinkToDeath() {
+ if (mReceiver != null) {
+ mReceiver.asBinder().unlinkToDeath(this, 0);
+ }
+ mReceiver = null;
+ }
+}
\ No newline at end of file
diff --git a/services/core/java/com/android/server/wm/ClientLifecycleManager.java b/services/core/java/com/android/server/wm/ClientLifecycleManager.java
new file mode 100644
index 0000000..7430f0f
--- /dev/null
+++ b/services/core/java/com/android/server/wm/ClientLifecycleManager.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.server.wm;
+
+import android.annotation.NonNull;
+import android.app.IApplicationThread;
+import android.app.servertransaction.ClientTransaction;
+import android.app.servertransaction.ClientTransactionItem;
+import android.app.servertransaction.ActivityLifecycleItem;
+import android.os.Binder;
+import android.os.IBinder;
+import android.os.RemoteException;
+
+/**
+ * Class that is able to combine multiple client lifecycle transition requests and/or callbacks,
+ * and execute them as a single transaction.
+ *
+ * @see ClientTransaction
+ */
+class ClientLifecycleManager {
+ // TODO(lifecycler): Implement building transactions or global transaction.
+ // TODO(lifecycler): Use object pools for transactions and transaction items.
+
+ /**
+ * Schedule a transaction, which may consist of multiple callbacks and a lifecycle request.
+ * @param transaction A sequence of client transaction items.
+ * @throws RemoteException
+ *
+ * @see ClientTransaction
+ */
+ void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
+ final IApplicationThread client = transaction.getClient();
+ transaction.schedule();
+ if (!(client instanceof Binder)) {
+ // If client is not an instance of Binder - it's a remote call and at this point it is
+ // safe to recycle the object. All objects used for local calls will be recycled after
+ // the transaction is executed on client in ActivityThread.
+ transaction.recycle();
+ }
+ }
+
+ /**
+ * Schedule a single lifecycle request or callback to client activity.
+ * @param client Target client.
+ * @param activityToken Target activity token.
+ * @param stateRequest A request to move target activity to a desired lifecycle state.
+ * @throws RemoteException
+ *
+ * @see ClientTransactionItem
+ */
+ void scheduleTransaction(@NonNull IApplicationThread client, @NonNull IBinder activityToken,
+ @NonNull ActivityLifecycleItem stateRequest) throws RemoteException {
+ final ClientTransaction clientTransaction = transactionWithState(client, activityToken,
+ stateRequest);
+ scheduleTransaction(clientTransaction);
+ }
+
+ /**
+ * Schedule a single callback delivery to client activity.
+ * @param client Target client.
+ * @param activityToken Target activity token.
+ * @param callback A request to deliver a callback.
+ * @throws RemoteException
+ *
+ * @see ClientTransactionItem
+ */
+ void scheduleTransaction(@NonNull IApplicationThread client, @NonNull IBinder activityToken,
+ @NonNull ClientTransactionItem callback) throws RemoteException {
+ final ClientTransaction clientTransaction = transactionWithCallback(client, activityToken,
+ callback);
+ scheduleTransaction(clientTransaction);
+ }
+
+ /**
+ * Schedule a single callback delivery to client application.
+ * @param client Target client.
+ * @param callback A request to deliver a callback.
+ * @throws RemoteException
+ *
+ * @see ClientTransactionItem
+ */
+ void scheduleTransaction(@NonNull IApplicationThread client,
+ @NonNull ClientTransactionItem callback) throws RemoteException {
+ final ClientTransaction clientTransaction = transactionWithCallback(client,
+ null /* activityToken */, callback);
+ scheduleTransaction(clientTransaction);
+ }
+
+ /**
+ * @return A new instance of {@link ClientTransaction} with a single lifecycle state request.
+ *
+ * @see ClientTransaction
+ * @see ClientTransactionItem
+ */
+ private static ClientTransaction transactionWithState(@NonNull IApplicationThread client,
+ @NonNull IBinder activityToken, @NonNull ActivityLifecycleItem stateRequest) {
+ final ClientTransaction clientTransaction = ClientTransaction.obtain(client, activityToken);
+ clientTransaction.setLifecycleStateRequest(stateRequest);
+ return clientTransaction;
+ }
+
+ /**
+ * @return A new instance of {@link ClientTransaction} with a single callback invocation.
+ *
+ * @see ClientTransaction
+ * @see ClientTransactionItem
+ */
+ private static ClientTransaction transactionWithCallback(@NonNull IApplicationThread client,
+ IBinder activityToken, @NonNull ClientTransactionItem callback) {
+ final ClientTransaction clientTransaction = ClientTransaction.obtain(client, activityToken);
+ clientTransaction.addCallback(callback);
+ return clientTransaction;
+ }
+}
diff --git a/services/core/java/com/android/server/wm/CompatModePackages.java b/services/core/java/com/android/server/wm/CompatModePackages.java
new file mode 100644
index 0000000..c8f8e82
--- /dev/null
+++ b/services/core/java/com/android/server/wm/CompatModePackages.java
@@ -0,0 +1,413 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.server.wm;
+
+import static com.android.server.wm.ActivityStackSupervisor.PRESERVE_WINDOWS;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_CONFIGURATION;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_CONFIGURATION;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_ATM;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_WITH_CLASS_NAME;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+import org.xmlpull.v1.XmlPullParser;
+import org.xmlpull.v1.XmlPullParserException;
+import org.xmlpull.v1.XmlSerializer;
+
+import com.android.internal.util.FastXmlSerializer;
+
+import android.app.ActivityManager;
+import android.app.AppGlobals;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.IPackageManager;
+import android.content.res.CompatibilityInfo;
+import android.content.res.Configuration;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.Message;
+import android.os.RemoteException;
+import android.util.AtomicFile;
+import android.util.Slog;
+import android.util.Xml;
+
+public final class CompatModePackages {
+ private static final String TAG = TAG_WITH_CLASS_NAME ? "CompatModePackages" : TAG_ATM;
+ private static final String TAG_CONFIGURATION = TAG + POSTFIX_CONFIGURATION;
+
+ private final ActivityTaskManagerService mService;
+ private final AtomicFile mFile;
+
+ // Compatibility state: no longer ask user to select the mode.
+ private static final int COMPAT_FLAG_DONT_ASK = 1<<0;
+ // Compatibility state: compatibility mode is enabled.
+ private static final int COMPAT_FLAG_ENABLED = 1<<1;
+
+ private final HashMap<String, Integer> mPackages = new HashMap<String, Integer>();
+
+ private static final int MSG_WRITE = 300;
+
+ private final CompatHandler mHandler;
+
+ private final class CompatHandler extends Handler {
+ public CompatHandler(Looper looper) {
+ super(looper, null, true);
+ }
+
+ @Override
+ public void handleMessage(Message msg) {
+ switch (msg.what) {
+ case MSG_WRITE:
+ saveCompatModes();
+ break;
+ }
+ }
+ };
+
+ public CompatModePackages(ActivityTaskManagerService service, File systemDir, Handler handler) {
+ mService = service;
+ mFile = new AtomicFile(new File(systemDir, "packages-compat.xml"), "compat-mode");
+ mHandler = new CompatHandler(handler.getLooper());
+
+ FileInputStream fis = null;
+ try {
+ fis = mFile.openRead();
+ XmlPullParser parser = Xml.newPullParser();
+ parser.setInput(fis, StandardCharsets.UTF_8.name());
+ int eventType = parser.getEventType();
+ while (eventType != XmlPullParser.START_TAG &&
+ eventType != XmlPullParser.END_DOCUMENT) {
+ eventType = parser.next();
+ }
+ if (eventType == XmlPullParser.END_DOCUMENT) {
+ return;
+ }
+
+ String tagName = parser.getName();
+ if ("compat-packages".equals(tagName)) {
+ eventType = parser.next();
+ do {
+ if (eventType == XmlPullParser.START_TAG) {
+ tagName = parser.getName();
+ if (parser.getDepth() == 2) {
+ if ("pkg".equals(tagName)) {
+ String pkg = parser.getAttributeValue(null, "name");
+ if (pkg != null) {
+ String mode = parser.getAttributeValue(null, "mode");
+ int modeInt = 0;
+ if (mode != null) {
+ try {
+ modeInt = Integer.parseInt(mode);
+ } catch (NumberFormatException e) {
+ }
+ }
+ mPackages.put(pkg, modeInt);
+ }
+ }
+ }
+ }
+ eventType = parser.next();
+ } while (eventType != XmlPullParser.END_DOCUMENT);
+ }
+ } catch (XmlPullParserException e) {
+ Slog.w(TAG, "Error reading compat-packages", e);
+ } catch (java.io.IOException e) {
+ if (fis != null) Slog.w(TAG, "Error reading compat-packages", e);
+ } finally {
+ if (fis != null) {
+ try {
+ fis.close();
+ } catch (java.io.IOException e1) {
+ }
+ }
+ }
+ }
+
+ public HashMap<String, Integer> getPackages() {
+ return mPackages;
+ }
+
+ private int getPackageFlags(String packageName) {
+ Integer flags = mPackages.get(packageName);
+ return flags != null ? flags : 0;
+ }
+
+ public void handlePackageDataClearedLocked(String packageName) {
+ // User has explicitly asked to clear all associated data.
+ removePackage(packageName);
+ }
+
+ public void handlePackageUninstalledLocked(String packageName) {
+ // Clear settings when app is uninstalled since this is an explicit
+ // signal from the user to remove the app and all associated data.
+ removePackage(packageName);
+ }
+
+ private void removePackage(String packageName) {
+ if (mPackages.containsKey(packageName)) {
+ mPackages.remove(packageName);
+ scheduleWrite();
+ }
+ }
+
+ public void handlePackageAddedLocked(String packageName, boolean updated) {
+ ApplicationInfo ai = null;
+ try {
+ ai = AppGlobals.getPackageManager().getApplicationInfo(packageName, 0, 0);
+ } catch (RemoteException e) {
+ }
+ if (ai == null) {
+ return;
+ }
+ CompatibilityInfo ci = compatibilityInfoForPackageLocked(ai);
+ final boolean mayCompat = !ci.alwaysSupportsScreen()
+ && !ci.neverSupportsScreen();
+
+ if (updated) {
+ // Update -- if the app no longer can run in compat mode, clear
+ // any current settings for it.
+ if (!mayCompat && mPackages.containsKey(packageName)) {
+ mPackages.remove(packageName);
+ scheduleWrite();
+ }
+ }
+ }
+
+ private void scheduleWrite() {
+ mHandler.removeMessages(MSG_WRITE);
+ Message msg = mHandler.obtainMessage(MSG_WRITE);
+ mHandler.sendMessageDelayed(msg, 10000);
+ }
+
+ public CompatibilityInfo compatibilityInfoForPackageLocked(ApplicationInfo ai) {
+ final Configuration globalConfig = mService.getGlobalConfiguration();
+ CompatibilityInfo ci = new CompatibilityInfo(ai, globalConfig.screenLayout,
+ globalConfig.smallestScreenWidthDp,
+ (getPackageFlags(ai.packageName)&COMPAT_FLAG_ENABLED) != 0);
+ //Slog.i(TAG, "*********** COMPAT FOR PKG " + ai.packageName + ": " + ci);
+ return ci;
+ }
+
+ public int computeCompatModeLocked(ApplicationInfo ai) {
+ final boolean enabled = (getPackageFlags(ai.packageName)&COMPAT_FLAG_ENABLED) != 0;
+ final Configuration globalConfig = mService.getGlobalConfiguration();
+ final CompatibilityInfo info = new CompatibilityInfo(ai, globalConfig.screenLayout,
+ globalConfig.smallestScreenWidthDp, enabled);
+ if (info.alwaysSupportsScreen()) {
+ return ActivityManager.COMPAT_MODE_NEVER;
+ }
+ if (info.neverSupportsScreen()) {
+ return ActivityManager.COMPAT_MODE_ALWAYS;
+ }
+ return enabled ? ActivityManager.COMPAT_MODE_ENABLED
+ : ActivityManager.COMPAT_MODE_DISABLED;
+ }
+
+ public boolean getPackageAskCompatModeLocked(String packageName) {
+ return (getPackageFlags(packageName)&COMPAT_FLAG_DONT_ASK) == 0;
+ }
+
+ public void setPackageAskCompatModeLocked(String packageName, boolean ask) {
+ setPackageFlagLocked(packageName, COMPAT_FLAG_DONT_ASK, ask);
+ }
+
+ private void setPackageFlagLocked(String packageName, int flag, boolean set) {
+ final int curFlags = getPackageFlags(packageName);
+ final int newFlags = set ? (curFlags & ~flag) : (curFlags | flag);
+ if (curFlags != newFlags) {
+ if (newFlags != 0) {
+ mPackages.put(packageName, newFlags);
+ } else {
+ mPackages.remove(packageName);
+ }
+ scheduleWrite();
+ }
+ }
+
+ public int getPackageScreenCompatModeLocked(String packageName) {
+ ApplicationInfo ai = null;
+ try {
+ ai = AppGlobals.getPackageManager().getApplicationInfo(packageName, 0, 0);
+ } catch (RemoteException e) {
+ }
+ if (ai == null) {
+ return ActivityManager.COMPAT_MODE_UNKNOWN;
+ }
+ return computeCompatModeLocked(ai);
+ }
+
+ public void setPackageScreenCompatModeLocked(String packageName, int mode) {
+ ApplicationInfo ai = null;
+ try {
+ ai = AppGlobals.getPackageManager().getApplicationInfo(packageName, 0, 0);
+ } catch (RemoteException e) {
+ }
+ if (ai == null) {
+ Slog.w(TAG, "setPackageScreenCompatMode failed: unknown package " + packageName);
+ return;
+ }
+ setPackageScreenCompatModeLocked(ai, mode);
+ }
+
+ void setPackageScreenCompatModeLocked(ApplicationInfo ai, int mode) {
+ final String packageName = ai.packageName;
+
+ int curFlags = getPackageFlags(packageName);
+
+ boolean enable;
+ switch (mode) {
+ case ActivityManager.COMPAT_MODE_DISABLED:
+ enable = false;
+ break;
+ case ActivityManager.COMPAT_MODE_ENABLED:
+ enable = true;
+ break;
+ case ActivityManager.COMPAT_MODE_TOGGLE:
+ enable = (curFlags&COMPAT_FLAG_ENABLED) == 0;
+ break;
+ default:
+ Slog.w(TAG, "Unknown screen compat mode req #" + mode + "; ignoring");
+ return;
+ }
+
+ int newFlags = curFlags;
+ if (enable) {
+ newFlags |= COMPAT_FLAG_ENABLED;
+ } else {
+ newFlags &= ~COMPAT_FLAG_ENABLED;
+ }
+
+ CompatibilityInfo ci = compatibilityInfoForPackageLocked(ai);
+ if (ci.alwaysSupportsScreen()) {
+ Slog.w(TAG, "Ignoring compat mode change of " + packageName
+ + "; compatibility never needed");
+ newFlags = 0;
+ }
+ if (ci.neverSupportsScreen()) {
+ Slog.w(TAG, "Ignoring compat mode change of " + packageName
+ + "; compatibility always needed");
+ newFlags = 0;
+ }
+
+ if (newFlags != curFlags) {
+ if (newFlags != 0) {
+ mPackages.put(packageName, newFlags);
+ } else {
+ mPackages.remove(packageName);
+ }
+
+ // Need to get compatibility info in new state.
+ ci = compatibilityInfoForPackageLocked(ai);
+
+ scheduleWrite();
+
+ final ActivityStack stack = mService.getTopDisplayFocusedStack();
+ ActivityRecord starting = stack.restartPackage(packageName);
+
+ // Tell all processes that loaded this package about the change.
+ for (int i = mService.mPidMap.size() - 1; i >= 0; i--) {
+ final WindowProcessController app = mService.mPidMap.valueAt(i);
+ if (!app.mPkgList.contains(packageName)) {
+ continue;
+ }
+ try {
+ if (app.hasThread()) {
+ if (DEBUG_CONFIGURATION) Slog.v(TAG_CONFIGURATION, "Sending to proc "
+ + app.mName + " new compat " + ci);
+ app.getThread().updatePackageCompatibilityInfo(packageName, ci);
+ }
+ } catch (Exception e) {
+ }
+ }
+
+ if (starting != null) {
+ starting.ensureActivityConfiguration(0 /* globalChanges */,
+ false /* preserveWindow */);
+ // And we need to make sure at this point that all other activities
+ // are made visible with the correct configuration.
+ stack.ensureActivitiesVisibleLocked(starting, 0, !PRESERVE_WINDOWS);
+ }
+ }
+ }
+
+ private void saveCompatModes() {
+ HashMap<String, Integer> pkgs;
+ synchronized (mService.mGlobalLock) {
+ pkgs = new HashMap<>(mPackages);
+ }
+
+ FileOutputStream fos = null;
+
+ try {
+ fos = mFile.startWrite();
+ XmlSerializer out = new FastXmlSerializer();
+ out.setOutput(fos, StandardCharsets.UTF_8.name());
+ out.startDocument(null, true);
+ out.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output", true);
+ out.startTag(null, "compat-packages");
+
+ final IPackageManager pm = AppGlobals.getPackageManager();
+ final Configuration globalConfig = mService.getGlobalConfiguration();
+ final int screenLayout = globalConfig.screenLayout;
+ final int smallestScreenWidthDp = globalConfig.smallestScreenWidthDp;
+ final Iterator<Map.Entry<String, Integer>> it = pkgs.entrySet().iterator();
+ while (it.hasNext()) {
+ Map.Entry<String, Integer> entry = it.next();
+ String pkg = entry.getKey();
+ int mode = entry.getValue();
+ if (mode == 0) {
+ continue;
+ }
+ ApplicationInfo ai = null;
+ try {
+ ai = pm.getApplicationInfo(pkg, 0, 0);
+ } catch (RemoteException e) {
+ }
+ if (ai == null) {
+ continue;
+ }
+ CompatibilityInfo info = new CompatibilityInfo(ai, screenLayout,
+ smallestScreenWidthDp, false);
+ if (info.alwaysSupportsScreen()) {
+ continue;
+ }
+ if (info.neverSupportsScreen()) {
+ continue;
+ }
+ out.startTag(null, "pkg");
+ out.attribute(null, "name", pkg);
+ out.attribute(null, "mode", Integer.toString(mode));
+ out.endTag(null, "pkg");
+ }
+
+ out.endTag(null, "compat-packages");
+ out.endDocument();
+
+ mFile.finishWrite(fos);
+ } catch (java.io.IOException e1) {
+ Slog.w(TAG, "Error writing compat packages", e1);
+ if (fos != null) {
+ mFile.failWrite(fos);
+ }
+ }
+ }
+}
diff --git a/services/core/java/com/android/server/wm/DeprecatedTargetSdkVersionDialog.java b/services/core/java/com/android/server/wm/DeprecatedTargetSdkVersionDialog.java
new file mode 100644
index 0000000..37244bd
--- /dev/null
+++ b/services/core/java/com/android/server/wm/DeprecatedTargetSdkVersionDialog.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.server.wm;
+
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_ATM;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_WITH_CLASS_NAME;
+
+import android.app.AlertDialog;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageItemInfo;
+import android.content.pm.PackageManager;
+import android.util.Log;
+import android.view.Window;
+import android.view.WindowManager;
+
+import com.android.internal.R;
+import com.android.server.utils.AppInstallerUtil;
+
+public class DeprecatedTargetSdkVersionDialog {
+ private static final String TAG = TAG_WITH_CLASS_NAME ? "DeprecatedTargetSdkVersionDialog" : TAG_ATM;
+
+ private final AlertDialog mDialog;
+ private final String mPackageName;
+
+ public DeprecatedTargetSdkVersionDialog(final AppWarnings manager, Context context,
+ ApplicationInfo appInfo) {
+ mPackageName = appInfo.packageName;
+
+ final PackageManager pm = context.getPackageManager();
+ final CharSequence label = appInfo.loadSafeLabel(pm,
+ PackageItemInfo.DEFAULT_MAX_LABEL_SIZE_PX,
+ PackageItemInfo.SAFE_LABEL_FLAG_FIRST_LINE
+ | PackageItemInfo.SAFE_LABEL_FLAG_TRIM);
+ final CharSequence message = context.getString(R.string.deprecated_target_sdk_message);
+
+ final AlertDialog.Builder builder = new AlertDialog.Builder(context)
+ .setPositiveButton(R.string.ok, (dialog, which) ->
+ manager.setPackageFlag(
+ mPackageName, AppWarnings.FLAG_HIDE_DEPRECATED_SDK, true))
+ .setMessage(message)
+ .setTitle(label);
+
+ // If we might be able to update the app, show a button.
+ final Intent installerIntent = AppInstallerUtil.createIntent(context, appInfo.packageName);
+ if (installerIntent != null) {
+ builder.setNeutralButton(R.string.deprecated_target_sdk_app_store,
+ (dialog, which) -> {
+ context.startActivity(installerIntent);
+ });
+ }
+
+ // Ensure the content view is prepared.
+ mDialog = builder.create();
+ mDialog.create();
+
+ final Window window = mDialog.getWindow();
+ window.setType(WindowManager.LayoutParams.TYPE_PHONE);
+
+ // DO NOT MODIFY. Used by CTS to verify the dialog is displayed.
+ window.getAttributes().setTitle("DeprecatedTargetSdkVersionDialog");
+ }
+
+ public String getPackageName() {
+ return mPackageName;
+ }
+
+ public void show() {
+ Log.w(TAG, "Showing SDK deprecation warning for package " + mPackageName);
+ mDialog.show();
+ }
+
+ public void dismiss() {
+ mDialog.dismiss();
+ }
+}
diff --git a/services/core/java/com/android/server/wm/FactoryErrorDialog.java b/services/core/java/com/android/server/wm/FactoryErrorDialog.java
new file mode 100644
index 0000000..88b5475
--- /dev/null
+++ b/services/core/java/com/android/server/wm/FactoryErrorDialog.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2006 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.server.wm;
+
+import android.content.Context;
+import android.content.DialogInterface;
+import android.os.Handler;
+import android.os.Message;
+import android.view.WindowManager;
+
+import com.android.server.am.BaseErrorDialog;
+
+final class FactoryErrorDialog extends BaseErrorDialog {
+ public FactoryErrorDialog(Context context, CharSequence msg) {
+ super(context);
+ setCancelable(false);
+ setTitle(context.getText(com.android.internal.R.string.factorytest_failed));
+ setMessage(msg);
+ setButton(DialogInterface.BUTTON_POSITIVE,
+ context.getText(com.android.internal.R.string.factorytest_reboot),
+ mHandler.obtainMessage(0));
+ WindowManager.LayoutParams attrs = getWindow().getAttributes();
+ attrs.setTitle("Factory Error");
+ getWindow().setAttributes(attrs);
+ }
+
+ public void onStop() {
+ }
+
+ private final Handler mHandler = new Handler() {
+ public void handleMessage(Message msg) {
+ throw new RuntimeException("Rebooting from failed factory test");
+ }
+ };
+}
diff --git a/services/core/java/com/android/server/wm/KeyguardController.java b/services/core/java/com/android/server/wm/KeyguardController.java
new file mode 100644
index 0000000..3560635
--- /dev/null
+++ b/services/core/java/com/android/server/wm/KeyguardController.java
@@ -0,0 +1,518 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.server.wm;
+
+import static android.os.Trace.TRACE_TAG_ACTIVITY_MANAGER;
+import static android.view.Display.DEFAULT_DISPLAY;
+import static android.view.Display.INVALID_DISPLAY;
+import static android.view.WindowManager.TRANSIT_FLAG_KEYGUARD_GOING_AWAY_NO_ANIMATION;
+import static android.view.WindowManager.TRANSIT_FLAG_KEYGUARD_GOING_AWAY_TO_SHADE;
+import static android.view.WindowManager.TRANSIT_FLAG_KEYGUARD_GOING_AWAY_WITH_WALLPAPER;
+import static android.view.WindowManager.TRANSIT_KEYGUARD_GOING_AWAY;
+import static android.view.WindowManager.TRANSIT_KEYGUARD_OCCLUDE;
+import static android.view.WindowManager.TRANSIT_KEYGUARD_UNOCCLUDE;
+import static android.view.WindowManager.TRANSIT_UNSET;
+import static android.view.WindowManagerPolicyConstants.KEYGUARD_GOING_AWAY_FLAG_NO_WINDOW_ANIMATIONS;
+import static android.view.WindowManagerPolicyConstants.KEYGUARD_GOING_AWAY_FLAG_TO_SHADE;
+import static android.view.WindowManagerPolicyConstants.KEYGUARD_GOING_AWAY_FLAG_WITH_WALLPAPER;
+
+import static com.android.server.wm.ActivityStackSupervisor.PRESERVE_WINDOWS;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_ATM;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_WITH_CLASS_NAME;
+import static com.android.server.am.KeyguardControllerProto.KEYGUARD_OCCLUDED_STATES;
+import static com.android.server.am.KeyguardControllerProto.KEYGUARD_SHOWING;
+import static com.android.server.am.KeyguardOccludedProto.DISPLAY_ID;
+import static com.android.server.am.KeyguardOccludedProto.KEYGUARD_OCCLUDED;
+
+import android.os.IBinder;
+import android.os.RemoteException;
+import android.os.Trace;
+import android.util.Slog;
+import android.util.SparseArray;
+import android.util.proto.ProtoOutputStream;
+
+import com.android.internal.policy.IKeyguardDismissCallback;
+import com.android.server.policy.WindowManagerPolicy;
+import com.android.server.wm.ActivityTaskManagerInternal.SleepToken;
+
+import java.io.PrintWriter;
+
+/**
+ * Controls Keyguard occluding, dismissing and transitions depending on what kind of activities are
+ * currently visible.
+ * <p>
+ * Note that everything in this class should only be accessed with the AM lock being held.
+ */
+class KeyguardController {
+
+ private static final String TAG = TAG_WITH_CLASS_NAME ? "KeyguardController" : TAG_ATM;
+
+ private final ActivityStackSupervisor mStackSupervisor;
+ private WindowManagerService mWindowManager;
+ private boolean mKeyguardShowing;
+ private boolean mAodShowing;
+ private boolean mKeyguardGoingAway;
+ private boolean mDismissalRequested;
+ private int mBeforeUnoccludeTransit;
+ private int mVisibilityTransactionDepth;
+ // TODO(b/111955725): Support multiple external displays
+ private int mSecondaryDisplayShowing = INVALID_DISPLAY;
+ private final SparseArray<KeyguardDisplayState> mDisplayStates = new SparseArray<>();
+ private final ActivityTaskManagerService mService;
+
+ KeyguardController(ActivityTaskManagerService service,
+ ActivityStackSupervisor stackSupervisor) {
+ mService = service;
+ mStackSupervisor = stackSupervisor;
+ }
+
+ void setWindowManager(WindowManagerService windowManager) {
+ mWindowManager = windowManager;
+ }
+
+ /**
+ * @return true if either Keyguard or AOD are showing, not going away, and not being occluded
+ * on the given display, false otherwise
+ */
+ boolean isKeyguardOrAodShowing(int displayId) {
+ return (mKeyguardShowing || mAodShowing) && !mKeyguardGoingAway
+ && !isDisplayOccluded(displayId);
+ }
+
+ /**
+ * @return true if Keyguard is showing, not going away, and not being occluded on the given
+ * display, false otherwise
+ */
+ boolean isKeyguardShowing(int displayId) {
+ return mKeyguardShowing && !mKeyguardGoingAway && !isDisplayOccluded(displayId);
+ }
+
+ /**
+ * @return true if Keyguard is either showing or occluded, but not going away
+ */
+ boolean isKeyguardLocked() {
+ return mKeyguardShowing && !mKeyguardGoingAway;
+ }
+
+ /**
+ * @return {@code true} if the keyguard is going away, {@code false} otherwise.
+ */
+ boolean isKeyguardGoingAway() {
+ // Also check keyguard showing in case value is stale.
+ return mKeyguardGoingAway && mKeyguardShowing;
+ }
+
+ /**
+ * Update the Keyguard showing state.
+ */
+ void setKeyguardShown(boolean keyguardShowing, boolean aodShowing,
+ int secondaryDisplayShowing) {
+ boolean showingChanged = keyguardShowing != mKeyguardShowing || aodShowing != mAodShowing;
+ // If keyguard is going away, but SystemUI aborted the transition, need to reset state.
+ showingChanged |= mKeyguardGoingAway && keyguardShowing;
+ if (!showingChanged && secondaryDisplayShowing == mSecondaryDisplayShowing) {
+ return;
+ }
+ mKeyguardShowing = keyguardShowing;
+ mAodShowing = aodShowing;
+ mSecondaryDisplayShowing = secondaryDisplayShowing;
+ mWindowManager.setAodShowing(aodShowing);
+ if (showingChanged) {
+ dismissDockedStackIfNeeded();
+ setKeyguardGoingAway(false);
+ // TODO(b/113840485): Check usage for non-default display
+ mWindowManager.setKeyguardOrAodShowingOnDefaultDisplay(
+ isKeyguardOrAodShowing(DEFAULT_DISPLAY));
+ if (keyguardShowing) {
+ mDismissalRequested = false;
+ }
+ }
+ mStackSupervisor.ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
+ updateKeyguardSleepToken();
+ }
+
+ /**
+ * Called when Keyguard is going away.
+ *
+ * @param flags See {@link WindowManagerPolicy#KEYGUARD_GOING_AWAY_FLAG_TO_SHADE}
+ * etc.
+ */
+ void keyguardGoingAway(int flags) {
+ if (!mKeyguardShowing) {
+ return;
+ }
+ Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "keyguardGoingAway");
+ mWindowManager.deferSurfaceLayout();
+ try {
+ setKeyguardGoingAway(true);
+ mStackSupervisor.getDefaultDisplay().getWindowContainerController()
+ .prepareAppTransition(TRANSIT_KEYGUARD_GOING_AWAY,
+ false /* alwaysKeepCurrent */, convertTransitFlags(flags),
+ false /* forceOverride */);
+ updateKeyguardSleepToken();
+
+ // Some stack visibility might change (e.g. docked stack)
+ mStackSupervisor.resumeFocusedStacksTopActivitiesLocked();
+ mStackSupervisor.ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
+ mStackSupervisor.addStartingWindowsForVisibleActivities(true /* taskSwitch */);
+ mWindowManager.executeAppTransition();
+ } finally {
+ Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "keyguardGoingAway: surfaceLayout");
+ mWindowManager.continueSurfaceLayout();
+ Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
+
+ Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
+ }
+ }
+
+ void dismissKeyguard(IBinder token, IKeyguardDismissCallback callback, CharSequence message) {
+ final ActivityRecord activityRecord = ActivityRecord.forTokenLocked(token);
+ if (activityRecord == null || !activityRecord.visibleIgnoringKeyguard) {
+ failCallback(callback);
+ return;
+ }
+ Slog.i(TAG, "Activity requesting to dismiss Keyguard: " + activityRecord);
+
+ // If the client has requested to dismiss the keyguard and the Activity has the flag to
+ // turn the screen on, wakeup the screen if it's the top Activity.
+ if (activityRecord.getTurnScreenOnFlag() && activityRecord.isTopRunningActivity()) {
+ mStackSupervisor.wakeUp("dismissKeyguard");
+ }
+
+ mWindowManager.dismissKeyguard(callback, message);
+ }
+
+ private void setKeyguardGoingAway(boolean keyguardGoingAway) {
+ mKeyguardGoingAway = keyguardGoingAway;
+ mWindowManager.setKeyguardGoingAway(keyguardGoingAway);
+ }
+
+ private void failCallback(IKeyguardDismissCallback callback) {
+ try {
+ callback.onDismissError();
+ } catch (RemoteException e) {
+ Slog.w(TAG, "Failed to call callback", e);
+ }
+ }
+
+ private int convertTransitFlags(int keyguardGoingAwayFlags) {
+ int result = 0;
+ if ((keyguardGoingAwayFlags & KEYGUARD_GOING_AWAY_FLAG_TO_SHADE) != 0) {
+ result |= TRANSIT_FLAG_KEYGUARD_GOING_AWAY_TO_SHADE;
+ }
+ if ((keyguardGoingAwayFlags & KEYGUARD_GOING_AWAY_FLAG_NO_WINDOW_ANIMATIONS) != 0) {
+ result |= TRANSIT_FLAG_KEYGUARD_GOING_AWAY_NO_ANIMATION;
+ }
+ if ((keyguardGoingAwayFlags & KEYGUARD_GOING_AWAY_FLAG_WITH_WALLPAPER) != 0) {
+ result |= TRANSIT_FLAG_KEYGUARD_GOING_AWAY_WITH_WALLPAPER;
+ }
+ return result;
+ }
+
+ /**
+ * Starts a batch of visibility updates.
+ */
+ void beginActivityVisibilityUpdate() {
+ mVisibilityTransactionDepth++;
+ }
+
+ /**
+ * Ends a batch of visibility updates. After all batches are done, this method makes sure to
+ * update lockscreen occluded/dismiss state if needed.
+ */
+ void endActivityVisibilityUpdate() {
+ mVisibilityTransactionDepth--;
+ if (mVisibilityTransactionDepth == 0) {
+ visibilitiesUpdated();
+ }
+ }
+
+ /**
+ * @return True if we may show an activity while Keyguard is showing because we are in the
+ * process of dismissing it anyways, false otherwise.
+ */
+ boolean canShowActivityWhileKeyguardShowing(ActivityRecord r, boolean dismissKeyguard) {
+
+ // Allow to show it when we are about to dismiss Keyguard. This isn't allowed if r is
+ // already the dismissing activity, in which case we don't allow it to repeatedly dismiss
+ // Keyguard.
+ return dismissKeyguard && canDismissKeyguard() && !mAodShowing
+ && (mDismissalRequested
+ || getDisplay(r.getDisplayId()).mDismissingKeyguardActivity != r);
+ }
+
+ /**
+ * @return True if we may show an activity while Keyguard is occluded, false otherwise.
+ */
+ boolean canShowWhileOccluded(boolean dismissKeyguard, boolean showWhenLocked) {
+ return showWhenLocked || dismissKeyguard && !mWindowManager.isKeyguardSecure();
+ }
+
+ private void visibilitiesUpdated() {
+ boolean requestDismissKeyguard = false;
+ for (int displayNdx = mStackSupervisor.getChildCount() - 1; displayNdx >= 0; displayNdx--) {
+ final ActivityDisplay display = mStackSupervisor.getChildAt(displayNdx);
+ final KeyguardDisplayState state = getDisplay(display.mDisplayId);
+ state.visibilitiesUpdated(this, display);
+ requestDismissKeyguard |= state.mRequestDismissKeyguard;
+ }
+
+ // Dismissing Keyguard happens globally using the information from all displays.
+ if (requestDismissKeyguard) {
+ handleDismissKeyguard();
+ }
+ }
+
+ /**
+ * Called when occluded state changed.
+ */
+ private void handleOccludedChanged() {
+ mWindowManager.onKeyguardOccludedChanged(isDisplayOccluded(DEFAULT_DISPLAY));
+ if (isKeyguardLocked()) {
+ mWindowManager.deferSurfaceLayout();
+ try {
+ mStackSupervisor.getDefaultDisplay().getWindowContainerController()
+ .prepareAppTransition(resolveOccludeTransit(),
+ false /* alwaysKeepCurrent */, 0 /* flags */,
+ true /* forceOverride */);
+ updateKeyguardSleepToken();
+ mStackSupervisor.ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
+ mWindowManager.executeAppTransition();
+ } finally {
+ mWindowManager.continueSurfaceLayout();
+ }
+ }
+ dismissDockedStackIfNeeded();
+ }
+
+ /**
+ * Called when somebody wants to dismiss the Keyguard via the flag.
+ */
+ private void handleDismissKeyguard() {
+ // We only allow dismissing Keyguard via the flag when Keyguard is secure for legacy
+ // reasons, because that's how apps used to dismiss Keyguard in the secure case. In the
+ // insecure case, we actually show it on top of the lockscreen. See #canShowWhileOccluded.
+ if (mWindowManager.isKeyguardSecure()) {
+ mWindowManager.dismissKeyguard(null /* callback */, null /* message */);
+ mDismissalRequested = true;
+
+ // If we are about to unocclude the Keyguard, but we can dismiss it without security,
+ // we immediately dismiss the Keyguard so the activity gets shown without a flicker.
+ final DisplayWindowController dwc =
+ mStackSupervisor.getDefaultDisplay().getWindowContainerController();
+ if (mKeyguardShowing && canDismissKeyguard()
+ && dwc.getPendingAppTransition() == TRANSIT_KEYGUARD_UNOCCLUDE) {
+ dwc.prepareAppTransition(mBeforeUnoccludeTransit, false /* alwaysKeepCurrent */,
+ 0 /* flags */, true /* forceOverride */);
+ mStackSupervisor.ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
+ mWindowManager.executeAppTransition();
+ }
+ }
+ }
+
+ private boolean isDisplayOccluded(int displayId) {
+ return getDisplay(displayId).mOccluded;
+ }
+
+ /**
+ * @return true if Keyguard can be currently dismissed without entering credentials.
+ */
+ boolean canDismissKeyguard() {
+ return mWindowManager.isKeyguardTrusted() || !mWindowManager.isKeyguardSecure();
+ }
+
+ private int resolveOccludeTransit() {
+ final DisplayWindowController dwc =
+ mStackSupervisor.getDefaultDisplay().getWindowContainerController();
+ if (mBeforeUnoccludeTransit != TRANSIT_UNSET
+ && dwc.getPendingAppTransition() == TRANSIT_KEYGUARD_UNOCCLUDE
+ // TODO(b/113840485): Handle app transition for individual display.
+ && isDisplayOccluded(DEFAULT_DISPLAY)) {
+
+ // Reuse old transit in case we are occluding Keyguard again, meaning that we never
+ // actually occclude/unocclude Keyguard, but just run a normal transition.
+ return mBeforeUnoccludeTransit;
+ // TODO(b/113840485): Handle app transition for individual display.
+ } else if (!isDisplayOccluded(DEFAULT_DISPLAY)) {
+
+ // Save transit in case we dismiss/occlude Keyguard shortly after.
+ mBeforeUnoccludeTransit = dwc.getPendingAppTransition();
+ return TRANSIT_KEYGUARD_UNOCCLUDE;
+ } else {
+ return TRANSIT_KEYGUARD_OCCLUDE;
+ }
+ }
+
+ private void dismissDockedStackIfNeeded() {
+ // TODO(b/113840485): Handle docked stack for individual display.
+ if (mKeyguardShowing && isDisplayOccluded(DEFAULT_DISPLAY)) {
+ // The lock screen is currently showing, but is occluded by a window that can
+ // show on top of the lock screen. In this can we want to dismiss the docked
+ // stack since it will be complicated/risky to try to put the activity on top
+ // of the lock screen in the right fullscreen configuration.
+ final ActivityStack stack = mStackSupervisor.getDefaultDisplay().getSplitScreenPrimaryStack();
+ if (stack == null) {
+ return;
+ }
+ mStackSupervisor.moveTasksToFullscreenStackLocked(stack,
+ stack.isFocusedStackOnDisplay());
+ }
+ }
+
+ private void updateKeyguardSleepToken() {
+ for (int displayNdx = mStackSupervisor.getChildCount() - 1; displayNdx >= 0; displayNdx--) {
+ final ActivityDisplay display = mStackSupervisor.getChildAt(displayNdx);
+ final KeyguardDisplayState state = getDisplay(display.mDisplayId);
+ if (isKeyguardOrAodShowing(display.mDisplayId) && state.mSleepToken == null) {
+ state.acquiredSleepToken();
+ } else if (!isKeyguardOrAodShowing(display.mDisplayId) && state.mSleepToken != null) {
+ state.releaseSleepToken();
+ }
+ }
+ }
+
+ private KeyguardDisplayState getDisplay(int displayId) {
+ if (mDisplayStates.get(displayId) == null) {
+ mDisplayStates.append(displayId,
+ new KeyguardDisplayState(mService, displayId));
+ }
+ return mDisplayStates.get(displayId);
+ }
+
+ void onDisplayRemoved(int displayId) {
+ if (mDisplayStates.get(displayId) != null) {
+ mDisplayStates.get(displayId).onRemoved();
+ mDisplayStates.remove(displayId);
+ }
+ }
+
+ /** Represents Keyguard state per individual display. */
+ private static class KeyguardDisplayState {
+ private final int mDisplayId;
+ private boolean mOccluded;
+ private ActivityRecord mDismissingKeyguardActivity;
+ private boolean mRequestDismissKeyguard;
+ private final ActivityTaskManagerService mService;
+ private SleepToken mSleepToken;
+
+ KeyguardDisplayState(ActivityTaskManagerService service, int displayId) {
+ mService = service;
+ mDisplayId = displayId;
+ }
+
+ void onRemoved() {
+ mDismissingKeyguardActivity = null;
+ releaseSleepToken();
+ }
+
+ void acquiredSleepToken() {
+ if (mSleepToken == null) {
+ mSleepToken = mService.acquireSleepToken("keyguard", mDisplayId);
+ }
+ }
+
+ void releaseSleepToken() {
+ if (mSleepToken != null) {
+ mSleepToken.release();
+ mSleepToken = null;
+ }
+ }
+
+ void visibilitiesUpdated(KeyguardController controller, ActivityDisplay display) {
+ final boolean lastOccluded = mOccluded;
+ final ActivityRecord lastDismissActivity = mDismissingKeyguardActivity;
+ mRequestDismissKeyguard = false;
+ mOccluded = false;
+ mDismissingKeyguardActivity = null;
+
+ // Only the top activity of the focused stack on each display may control it's
+ // occluded state.
+ final ActivityStack focusedStack = display.getFocusedStack();
+ if (focusedStack != null) {
+ final ActivityRecord topDismissing =
+ focusedStack.getTopDismissingKeyguardActivity();
+ mOccluded = focusedStack.topActivityOccludesKeyguard() || (topDismissing != null
+ && focusedStack.topRunningActivityLocked() == topDismissing
+ && controller.canShowWhileOccluded(
+ true /* dismissKeyguard */,
+ false /* showWhenLocked */));
+ if (focusedStack.getTopDismissingKeyguardActivity() != null) {
+ mDismissingKeyguardActivity = focusedStack.getTopDismissingKeyguardActivity();
+ }
+ mOccluded |= controller.mWindowManager.isShowingDream();
+ }
+
+ // TODO(b/113840485): Handle app transition for individual display.
+ // For now, only default display can change occluded.
+ if (lastOccluded != mOccluded && mDisplayId == DEFAULT_DISPLAY) {
+ controller.handleOccludedChanged();
+ }
+ if (lastDismissActivity != mDismissingKeyguardActivity && !mOccluded
+ && mDismissingKeyguardActivity != null
+ && controller.mWindowManager.isKeyguardSecure()) {
+ mRequestDismissKeyguard = true;
+ }
+ }
+
+ void dumpStatus(PrintWriter pw, String prefix) {
+ final StringBuilder sb = new StringBuilder();
+ sb.append(prefix);
+ sb.append(" Occluded=").append(mOccluded)
+ .append(" DismissingKeyguardActivity=")
+ .append(mDismissingKeyguardActivity)
+ .append(" at display=")
+ .append(mDisplayId);
+ pw.println(sb.toString());
+ }
+
+ void writeToProto(ProtoOutputStream proto, long fieldId) {
+ final long token = proto.start(fieldId);
+ proto.write(DISPLAY_ID, mDisplayId);
+ proto.write(KEYGUARD_OCCLUDED, mOccluded);
+ proto.end(token);
+ }
+ }
+
+ void dump(PrintWriter pw, String prefix) {
+ pw.println(prefix + "KeyguardController:");
+ pw.println(prefix + " mKeyguardShowing=" + mKeyguardShowing);
+ pw.println(prefix + " mAodShowing=" + mAodShowing);
+ pw.println(prefix + " mKeyguardGoingAway=" + mKeyguardGoingAway);
+ dumpDisplayStates(pw, prefix);
+ pw.println(prefix + " mDismissalRequested=" + mDismissalRequested);
+ pw.println(prefix + " mVisibilityTransactionDepth=" + mVisibilityTransactionDepth);
+ }
+
+ void writeToProto(ProtoOutputStream proto, long fieldId) {
+ final long token = proto.start(fieldId);
+ proto.write(KEYGUARD_SHOWING, mKeyguardShowing);
+ writeDisplayStatesToProto(proto, KEYGUARD_OCCLUDED_STATES);
+ proto.end(token);
+ }
+
+ private void dumpDisplayStates(PrintWriter pw, String prefix) {
+ for (int i = 0; i < mDisplayStates.size(); i++) {
+ mDisplayStates.valueAt(i).dumpStatus(pw, prefix);
+ }
+ }
+
+ private void writeDisplayStatesToProto(ProtoOutputStream proto, long fieldId) {
+ for (int i = 0; i < mDisplayStates.size(); i++) {
+ mDisplayStates.valueAt(i).writeToProto(proto, fieldId);
+ }
+ }
+}
diff --git a/services/core/java/com/android/server/wm/LaunchParamsController.java b/services/core/java/com/android/server/wm/LaunchParamsController.java
new file mode 100644
index 0000000..252f47c
--- /dev/null
+++ b/services/core/java/com/android/server/wm/LaunchParamsController.java
@@ -0,0 +1,276 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.server.wm;
+
+import static android.app.WindowConfiguration.WINDOWING_MODE_UNDEFINED;
+import static android.view.Display.DEFAULT_DISPLAY;
+import static android.view.Display.INVALID_DISPLAY;
+
+import static com.android.server.wm.LaunchParamsController.LaunchParamsModifier.RESULT_CONTINUE;
+import static com.android.server.wm.LaunchParamsController.LaunchParamsModifier.RESULT_DONE;
+import static com.android.server.wm.LaunchParamsController.LaunchParamsModifier.RESULT_SKIP;
+
+import android.annotation.IntDef;
+import android.app.ActivityOptions;
+import android.content.pm.ActivityInfo.WindowLayout;
+import android.graphics.Rect;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * {@link LaunchParamsController} calculates the {@link LaunchParams} by coordinating between
+ * registered {@link LaunchParamsModifier}s.
+ */
+class LaunchParamsController {
+ private final ActivityTaskManagerService mService;
+ private final List<LaunchParamsModifier> mModifiers = new ArrayList<>();
+
+ // Temporary {@link LaunchParams} for internal calculations. This is kept separate from
+ // {@code mTmpCurrent} and {@code mTmpResult} to prevent clobbering values.
+ private final LaunchParams mTmpParams = new LaunchParams();
+
+ private final LaunchParams mTmpCurrent = new LaunchParams();
+ private final LaunchParams mTmpResult = new LaunchParams();
+
+ LaunchParamsController(ActivityTaskManagerService service) {
+ mService = service;
+ }
+
+ /**
+ * Creates a {@link LaunchParamsController} with default registered
+ * {@link LaunchParamsModifier}s.
+ */
+ void registerDefaultModifiers(ActivityStackSupervisor supervisor) {
+ // {@link TaskLaunchParamsModifier} handles window layout preferences.
+ registerModifier(new TaskLaunchParamsModifier(supervisor));
+ }
+
+ /**
+ * Returns the {@link LaunchParams} calculated by the registered modifiers
+ * @param task The {@link TaskRecord} currently being positioned.
+ * @param layout The specified {@link WindowLayout}.
+ * @param activity The {@link ActivityRecord} currently being positioned.
+ * @param source The {@link ActivityRecord} from which activity was started from.
+ * @param options The {@link ActivityOptions} specified for the activity.
+ * @param result The resulting params.
+ */
+ void calculate(TaskRecord task, WindowLayout layout, ActivityRecord activity,
+ ActivityRecord source, ActivityOptions options, LaunchParams result) {
+ result.reset();
+
+ // We start at the last registered {@link LaunchParamsModifier} as this represents
+ // The modifier closest to the product level. Moving back through the list moves closer to
+ // the platform logic.
+ for (int i = mModifiers.size() - 1; i >= 0; --i) {
+ mTmpCurrent.set(result);
+ mTmpResult.reset();
+ final LaunchParamsModifier modifier = mModifiers.get(i);
+
+ switch(modifier.onCalculate(task, layout, activity, source, options, mTmpCurrent,
+ mTmpResult)) {
+ case RESULT_SKIP:
+ // Do not apply any results when we are told to skip
+ continue;
+ case RESULT_DONE:
+ // Set result and return immediately.
+ result.set(mTmpResult);
+ return;
+ case RESULT_CONTINUE:
+ // Set result and continue
+ result.set(mTmpResult);
+ break;
+ }
+ }
+
+ if (activity != null && activity.requestedVrComponent != null) {
+ // Check if the Activity is a VR activity. If so, it should be launched in main display.
+ result.mPreferredDisplayId = DEFAULT_DISPLAY;
+ } else if (mService.mVr2dDisplayId != INVALID_DISPLAY) {
+ // Get the virtual display ID from ActivityTaskManagerService. If that's set we
+ // should always use that.
+ result.mPreferredDisplayId = mService.mVr2dDisplayId;
+ }
+ }
+
+ /**
+ * A convenience method for laying out a task.
+ * @return {@code true} if bounds were set on the task. {@code false} otherwise.
+ */
+ boolean layoutTask(TaskRecord task, WindowLayout layout) {
+ return layoutTask(task, layout, null /*activity*/, null /*source*/, null /*options*/);
+ }
+
+ boolean layoutTask(TaskRecord task, WindowLayout layout, ActivityRecord activity,
+ ActivityRecord source, ActivityOptions options) {
+ calculate(task, layout, activity, source, options, mTmpParams);
+
+ // No changes, return.
+ if (mTmpParams.isEmpty()) {
+ return false;
+ }
+
+ mService.mWindowManager.deferSurfaceLayout();
+
+ try {
+ if (mTmpParams.hasPreferredDisplay()
+ && mTmpParams.mPreferredDisplayId != task.getStack().getDisplay().mDisplayId) {
+ mService.moveStackToDisplay(task.getStackId(), mTmpParams.mPreferredDisplayId);
+ }
+
+ if (mTmpParams.hasWindowingMode()
+ && mTmpParams.mWindowingMode != task.getStack().getWindowingMode()) {
+ task.getStack().setWindowingMode(mTmpParams.mWindowingMode);
+ }
+
+ if (!mTmpParams.mBounds.isEmpty()) {
+ task.updateOverrideConfiguration(mTmpParams.mBounds);
+ return true;
+ } else {
+ return false;
+ }
+ } finally {
+ mService.mWindowManager.continueSurfaceLayout();
+ }
+ }
+
+ /**
+ * Adds a modifier to participate in future bounds calculation. Note that the last registered
+ * {@link LaunchParamsModifier} will be the first to calculate the bounds.
+ */
+ void registerModifier(LaunchParamsModifier modifier) {
+ if (mModifiers.contains(modifier)) {
+ return;
+ }
+
+ mModifiers.add(modifier);
+ }
+
+ /**
+ * A container for holding launch related fields.
+ */
+ static class LaunchParams {
+ /** The bounds within the parent container. */
+ final Rect mBounds = new Rect();
+
+ /** The id of the display the {@link TaskRecord} would prefer to be on. */
+ int mPreferredDisplayId;
+
+ /** The windowing mode to be in. */
+ int mWindowingMode;
+
+ /** Sets values back to default. {@link #isEmpty} will return {@code true} once called. */
+ void reset() {
+ mBounds.setEmpty();
+ mPreferredDisplayId = INVALID_DISPLAY;
+ mWindowingMode = WINDOWING_MODE_UNDEFINED;
+ }
+
+ /** Copies the values set on the passed in {@link LaunchParams}. */
+ void set(LaunchParams params) {
+ mBounds.set(params.mBounds);
+ mPreferredDisplayId = params.mPreferredDisplayId;
+ mWindowingMode = params.mWindowingMode;
+ }
+
+ /** Returns {@code true} if no values have been explicitly set. */
+ boolean isEmpty() {
+ return mBounds.isEmpty() && mPreferredDisplayId == INVALID_DISPLAY
+ && mWindowingMode == WINDOWING_MODE_UNDEFINED;
+ }
+
+ boolean hasWindowingMode() {
+ return mWindowingMode != WINDOWING_MODE_UNDEFINED;
+ }
+
+ boolean hasPreferredDisplay() {
+ return mPreferredDisplayId != INVALID_DISPLAY;
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) return true;
+ if (o == null || getClass() != o.getClass()) return false;
+
+ LaunchParams that = (LaunchParams) o;
+
+ if (mPreferredDisplayId != that.mPreferredDisplayId) return false;
+ if (mWindowingMode != that.mWindowingMode) return false;
+ return mBounds != null ? mBounds.equals(that.mBounds) : that.mBounds == null;
+ }
+
+ @Override
+ public int hashCode() {
+ int result = mBounds != null ? mBounds.hashCode() : 0;
+ result = 31 * result + mPreferredDisplayId;
+ result = 31 * result + mWindowingMode;
+ return result;
+ }
+ }
+
+ /**
+ * An interface implemented by those wanting to participate in bounds calculation.
+ */
+ interface LaunchParamsModifier {
+ @Retention(RetentionPolicy.SOURCE)
+ @IntDef({RESULT_SKIP, RESULT_DONE, RESULT_CONTINUE})
+ @interface Result {}
+
+ /** Returned when the modifier does not want to influence the bounds calculation */
+ int RESULT_SKIP = 0;
+ /**
+ * Returned when the modifier has changed the bounds and would like its results to be the
+ * final bounds applied.
+ */
+ int RESULT_DONE = 1;
+ /**
+ * Returned when the modifier has changed the bounds but is okay with other modifiers
+ * influencing the bounds.
+ */
+ int RESULT_CONTINUE = 2;
+
+ /**
+ * Returns the launch params that the provided activity launch params should be overridden
+ * to. {@link LaunchParamsModifier} can use this for various purposes, including: 1)
+ * Providing default bounds if the launch bounds have not been provided. 2) Repositioning
+ * the task so it doesn't get placed over an existing task. 3) Resizing the task so that its
+ * dimensions match the activity's requested orientation.
+ *
+ * @param task Can be: 1) the target task in which the source activity wants to
+ * launch the target activity; 2) a newly created task that Android
+ * gives a chance to override its launching bounds; 3) {@code null} if
+ * this is called to override an activity's launching bounds.
+ * @param layout Desired layout when activity is first launched.
+ * @param activity Activity that is being started. This can be {@code null} on
+ * re-parenting an activity to a new task (e.g. for
+ * Picture-In-Picture). Tasks being created because an activity was
+ * launched should have this be non-null.
+ * @param source the Activity that launched a new task. Could be {@code null}.
+ * @param options {@link ActivityOptions} used to start the activity with.
+ * @param currentParams launching params after the process of last {@link
+ * LaunchParamsModifier}.
+ * @param outParams the result params to be set.
+ * @return see {@link LaunchParamsModifier.Result}
+ */
+ @Result
+ int onCalculate(TaskRecord task, WindowLayout layout, ActivityRecord activity,
+ ActivityRecord source, ActivityOptions options, LaunchParams currentParams,
+ LaunchParams outParams);
+ }
+}
diff --git a/services/core/java/com/android/server/wm/LaunchWarningWindow.java b/services/core/java/com/android/server/wm/LaunchWarningWindow.java
new file mode 100644
index 0000000..1c0093e
--- /dev/null
+++ b/services/core/java/com/android/server/wm/LaunchWarningWindow.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.server.wm;
+
+import com.android.internal.R;
+
+import android.app.Dialog;
+import android.content.Context;
+import android.util.TypedValue;
+import android.view.Window;
+import android.view.WindowManager;
+import android.widget.ImageView;
+import android.widget.TextView;
+
+public final class LaunchWarningWindow extends Dialog {
+ public LaunchWarningWindow(Context context, ActivityRecord cur, ActivityRecord next) {
+ super(context, R.style.Theme_Toast);
+
+ requestWindowFeature(Window.FEATURE_LEFT_ICON);
+ getWindow().setType(WindowManager.LayoutParams.TYPE_SYSTEM_ALERT);
+ getWindow().addFlags(WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
+ | WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE);
+
+ setContentView(R.layout.launch_warning);
+ setTitle(context.getText(R.string.launch_warning_title));
+
+ TypedValue out = new TypedValue();
+ getContext().getTheme().resolveAttribute(android.R.attr.alertDialogIcon, out, true);
+ getWindow().setFeatureDrawableResource(Window.FEATURE_LEFT_ICON, out.resourceId);
+
+ ImageView icon = (ImageView)findViewById(R.id.replace_app_icon);
+ icon.setImageDrawable(next.info.applicationInfo.loadIcon(context.getPackageManager()));
+ TextView text = (TextView)findViewById(R.id.replace_message);
+ text.setText(context.getResources().getString(R.string.launch_warning_replace,
+ next.info.applicationInfo.loadLabel(context.getPackageManager()).toString()));
+ icon = (ImageView)findViewById(R.id.original_app_icon);
+ icon.setImageDrawable(cur.info.applicationInfo.loadIcon(context.getPackageManager()));
+ text = (TextView)findViewById(R.id.original_message);
+ text.setText(context.getResources().getString(R.string.launch_warning_original,
+ cur.info.applicationInfo.loadLabel(context.getPackageManager()).toString()));
+ }
+}
diff --git a/services/core/java/com/android/server/wm/LockTaskController.java b/services/core/java/com/android/server/wm/LockTaskController.java
new file mode 100644
index 0000000..41d0777
--- /dev/null
+++ b/services/core/java/com/android/server/wm/LockTaskController.java
@@ -0,0 +1,900 @@
+/*
+ * Copyright 2017, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.server.wm;
+
+import static android.app.ActivityManager.LOCK_TASK_MODE_LOCKED;
+import static android.app.ActivityManager.LOCK_TASK_MODE_NONE;
+import static android.app.ActivityManager.LOCK_TASK_MODE_PINNED;
+import static android.app.WindowConfiguration.WINDOWING_MODE_UNDEFINED;
+import static android.content.Context.DEVICE_POLICY_SERVICE;
+import static android.content.Context.STATUS_BAR_SERVICE;
+import static android.content.Intent.ACTION_CALL_EMERGENCY;
+import static android.os.UserHandle.USER_ALL;
+import static android.os.UserHandle.USER_CURRENT;
+import static android.telecom.TelecomManager.EMERGENCY_DIALER_COMPONENT;
+import static android.view.Display.DEFAULT_DISPLAY;
+
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_LOCKTASK;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_LOCKTASK;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_ATM;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_WITH_CLASS_NAME;
+import static com.android.server.wm.TaskRecord.LOCK_TASK_AUTH_DONT_LOCK;
+import static com.android.server.wm.TaskRecord.LOCK_TASK_AUTH_LAUNCHABLE;
+import static com.android.server.wm.TaskRecord.LOCK_TASK_AUTH_LAUNCHABLE_PRIV;
+import static com.android.server.wm.TaskRecord.LOCK_TASK_AUTH_PINNABLE;
+import static com.android.server.wm.TaskRecord.LOCK_TASK_AUTH_WHITELISTED;
+
+import android.annotation.NonNull;
+import android.annotation.Nullable;
+import android.app.Activity;
+import android.app.ActivityManager;
+import android.app.StatusBarManager;
+import android.app.admin.DevicePolicyManager;
+import android.app.admin.IDevicePolicyManager;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Binder;
+import android.os.Debug;
+import android.os.Handler;
+import android.os.IBinder;
+import android.os.RemoteException;
+import android.os.ServiceManager;
+import android.provider.Settings;
+import android.telecom.TelecomManager;
+import android.util.Pair;
+import android.util.Slog;
+import android.util.SparseArray;
+import android.util.SparseIntArray;
+
+import com.android.internal.annotations.VisibleForTesting;
+import com.android.internal.policy.IKeyguardDismissCallback;
+import com.android.internal.statusbar.IStatusBarService;
+import com.android.internal.widget.LockPatternUtils;
+import com.android.server.LocalServices;
+import com.android.server.am.ActivityManagerService;
+import com.android.server.statusbar.StatusBarManagerInternal;
+
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+
+/**
+ * Helper class that deals with all things related to task locking. This includes the screen pinning
+ * mode that can be launched via System UI as well as the fully locked mode that can be achieved
+ * on fully managed devices.
+ *
+ * Note: All methods in this class should only be called with the ActivityTaskManagerService lock
+ * held.
+ *
+ * @see Activity#startLockTask()
+ * @see Activity#stopLockTask()
+ */
+public class LockTaskController {
+ private static final String TAG = TAG_WITH_CLASS_NAME ? "LockTaskController" : TAG_ATM;
+ private static final String TAG_LOCKTASK = TAG + POSTFIX_LOCKTASK;
+
+ @VisibleForTesting
+ static final int STATUS_BAR_MASK_LOCKED = StatusBarManager.DISABLE_MASK
+ & (~StatusBarManager.DISABLE_EXPAND)
+ & (~StatusBarManager.DISABLE_NOTIFICATION_TICKER)
+ & (~StatusBarManager.DISABLE_SYSTEM_INFO)
+ & (~StatusBarManager.DISABLE_BACK);
+ @VisibleForTesting
+ static final int STATUS_BAR_MASK_PINNED = StatusBarManager.DISABLE_MASK
+ & (~StatusBarManager.DISABLE_BACK)
+ & (~StatusBarManager.DISABLE_HOME)
+ & (~StatusBarManager.DISABLE_RECENT);
+
+ private static final SparseArray<Pair<Integer, Integer>> STATUS_BAR_FLAG_MAP_LOCKED;
+ static {
+ STATUS_BAR_FLAG_MAP_LOCKED = new SparseArray<>();
+
+ STATUS_BAR_FLAG_MAP_LOCKED.append(DevicePolicyManager.LOCK_TASK_FEATURE_SYSTEM_INFO,
+ new Pair<>(StatusBarManager.DISABLE_CLOCK, StatusBarManager.DISABLE2_SYSTEM_ICONS));
+
+ STATUS_BAR_FLAG_MAP_LOCKED.append(DevicePolicyManager.LOCK_TASK_FEATURE_NOTIFICATIONS,
+ new Pair<>(StatusBarManager.DISABLE_NOTIFICATION_ICONS
+ | StatusBarManager.DISABLE_NOTIFICATION_ALERTS,
+ StatusBarManager.DISABLE2_NOTIFICATION_SHADE));
+
+ STATUS_BAR_FLAG_MAP_LOCKED.append(DevicePolicyManager.LOCK_TASK_FEATURE_HOME,
+ new Pair<>(StatusBarManager.DISABLE_HOME, StatusBarManager.DISABLE2_NONE));
+
+ STATUS_BAR_FLAG_MAP_LOCKED.append(DevicePolicyManager.LOCK_TASK_FEATURE_OVERVIEW,
+ new Pair<>(StatusBarManager.DISABLE_RECENT, StatusBarManager.DISABLE2_NONE));
+
+ STATUS_BAR_FLAG_MAP_LOCKED.append(DevicePolicyManager.LOCK_TASK_FEATURE_GLOBAL_ACTIONS,
+ new Pair<>(StatusBarManager.DISABLE_NONE,
+ StatusBarManager.DISABLE2_GLOBAL_ACTIONS));
+ }
+
+ /** Tag used for disabling of keyguard */
+ private static final String LOCK_TASK_TAG = "Lock-to-App";
+
+ private final IBinder mToken = new Binder();
+ private final ActivityStackSupervisor mSupervisor;
+ private final Context mContext;
+
+ // The following system services cannot be final, because they do not exist when this class
+ // is instantiated during device boot
+ @VisibleForTesting
+ IStatusBarService mStatusBarService;
+ @VisibleForTesting
+ IDevicePolicyManager mDevicePolicyManager;
+ @VisibleForTesting
+ WindowManagerService mWindowManager;
+ @VisibleForTesting
+ LockPatternUtils mLockPatternUtils;
+ @VisibleForTesting
+ TelecomManager mTelecomManager;
+
+ /**
+ * The chain of tasks in LockTask mode, in the order of when they first entered LockTask mode.
+ *
+ * The first task in the list, which started the current LockTask session, is called the root
+ * task. It coincides with the Home task in a typical multi-app kiosk deployment. When there are
+ * more than one locked tasks, the root task can't be finished. Nor can it be moved to the back
+ * of the stack by {@link ActivityStack#moveTaskToBackLocked(int)};
+ *
+ * Calling {@link Activity#stopLockTask()} on the root task will finish all tasks but itself in
+ * this list, and the device will exit LockTask mode.
+ *
+ * The list is empty if LockTask is inactive.
+ */
+ private final ArrayList<TaskRecord> mLockTaskModeTasks = new ArrayList<>();
+
+ /**
+ * Packages that are allowed to be launched into the lock task mode for each user.
+ */
+ private final SparseArray<String[]> mLockTaskPackages = new SparseArray<>();
+
+ /**
+ * Features that are allowed by DPC to show during LockTask mode.
+ */
+ private final SparseIntArray mLockTaskFeatures = new SparseIntArray();
+
+ /**
+ * Store the current lock task mode. Possible values:
+ * {@link ActivityManager#LOCK_TASK_MODE_NONE}, {@link ActivityManager#LOCK_TASK_MODE_LOCKED},
+ * {@link ActivityManager#LOCK_TASK_MODE_PINNED}
+ */
+ private int mLockTaskModeState = LOCK_TASK_MODE_NONE;
+
+ /**
+ * This is ActivityStackSupervisor's Handler.
+ */
+ private final Handler mHandler;
+
+ LockTaskController(Context context, ActivityStackSupervisor supervisor,
+ Handler handler) {
+ mContext = context;
+ mSupervisor = supervisor;
+ mHandler = handler;
+ }
+
+ /**
+ * Set the window manager instance used in this class. This is necessary, because the window
+ * manager does not exist during instantiation of this class.
+ */
+ void setWindowManager(WindowManagerService windowManager) {
+ mWindowManager = windowManager;
+ }
+
+ /**
+ * @return the current lock task state. This can be any of
+ * {@link ActivityManager#LOCK_TASK_MODE_NONE}, {@link ActivityManager#LOCK_TASK_MODE_LOCKED},
+ * {@link ActivityManager#LOCK_TASK_MODE_PINNED}.
+ */
+ int getLockTaskModeState() {
+ return mLockTaskModeState;
+ }
+
+ /**
+ * @return whether the given task is locked at the moment. Locked tasks cannot be moved to the
+ * back of the stack.
+ */
+ @VisibleForTesting
+ boolean isTaskLocked(TaskRecord task) {
+ return mLockTaskModeTasks.contains(task);
+ }
+
+ /**
+ * @return {@code true} whether this task first started the current LockTask session.
+ */
+ private boolean isRootTask(TaskRecord task) {
+ return mLockTaskModeTasks.indexOf(task) == 0;
+ }
+
+ /**
+ * @return whether the given activity is blocked from finishing, because it is the only activity
+ * of the last locked task and finishing it would mean that lock task mode is ended illegally.
+ */
+ boolean activityBlockedFromFinish(ActivityRecord activity) {
+ final TaskRecord task = activity.getTask();
+ if (activity == task.getRootActivity()
+ && activity == task.getTopActivity()
+ && task.mLockTaskAuth != LOCK_TASK_AUTH_LAUNCHABLE_PRIV
+ && isRootTask(task)) {
+ Slog.i(TAG, "Not finishing task in lock task mode");
+ showLockTaskToast();
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * @return whether the given task can be moved to the back of the stack with
+ * {@link ActivityStack#moveTaskToBackLocked(int)}
+ * @see #mLockTaskModeTasks
+ */
+ boolean canMoveTaskToBack(TaskRecord task) {
+ if (isRootTask(task)) {
+ showLockTaskToast();
+ return false;
+ }
+ return true;
+ }
+
+ /**
+ * @return whether the requested task is allowed to be locked (either whitelisted, or declares
+ * lockTaskMode="always" in the manifest).
+ */
+ boolean isTaskWhitelisted(TaskRecord task) {
+ switch(task.mLockTaskAuth) {
+ case LOCK_TASK_AUTH_WHITELISTED:
+ case LOCK_TASK_AUTH_LAUNCHABLE:
+ case LOCK_TASK_AUTH_LAUNCHABLE_PRIV:
+ return true;
+ case LOCK_TASK_AUTH_PINNABLE:
+ case LOCK_TASK_AUTH_DONT_LOCK:
+ default:
+ return false;
+ }
+ }
+
+ /**
+ * @return whether the requested task is disallowed to be launched.
+ */
+ boolean isLockTaskModeViolation(TaskRecord task) {
+ return isLockTaskModeViolation(task, false);
+ }
+
+ /**
+ * @param isNewClearTask whether the task would be cleared as part of the operation.
+ * @return whether the requested task is disallowed to be launched.
+ */
+ boolean isLockTaskModeViolation(TaskRecord task, boolean isNewClearTask) {
+ if (isLockTaskModeViolationInternal(task, isNewClearTask)) {
+ showLockTaskToast();
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * @return the root task of the lock task.
+ */
+ TaskRecord getRootTask() {
+ if (mLockTaskModeTasks.isEmpty()) {
+ return null;
+ }
+ return mLockTaskModeTasks.get(0);
+ }
+
+ private boolean isLockTaskModeViolationInternal(TaskRecord task, boolean isNewClearTask) {
+ // TODO: Double check what's going on here. If the task is already in lock task mode, it's
+ // likely whitelisted, so will return false below.
+ if (isTaskLocked(task) && !isNewClearTask) {
+ // If the task is already at the top and won't be cleared, then allow the operation
+ return false;
+ }
+
+ // Allow recents activity if enabled by policy
+ if (task.isActivityTypeRecents() && isRecentsAllowed(task.userId)) {
+ return false;
+ }
+
+ // Allow emergency calling when the device is protected by a locked keyguard
+ if (isKeyguardAllowed(task.userId) && isEmergencyCallTask(task)) {
+ return false;
+ }
+
+ return !(isTaskWhitelisted(task) || mLockTaskModeTasks.isEmpty());
+ }
+
+ private boolean isRecentsAllowed(int userId) {
+ return (getLockTaskFeaturesForUser(userId)
+ & DevicePolicyManager.LOCK_TASK_FEATURE_OVERVIEW) != 0;
+ }
+
+ private boolean isKeyguardAllowed(int userId) {
+ return (getLockTaskFeaturesForUser(userId)
+ & DevicePolicyManager.LOCK_TASK_FEATURE_KEYGUARD) != 0;
+ }
+
+ private boolean isEmergencyCallTask(TaskRecord task) {
+ final Intent intent = task.intent;
+ if (intent == null) {
+ return false;
+ }
+
+ // 1. The emergency keypad activity launched on top of the keyguard
+ if (EMERGENCY_DIALER_COMPONENT.equals(intent.getComponent())) {
+ return true;
+ }
+
+ // 2. The intent sent by the keypad, which is handled by Telephony
+ if (ACTION_CALL_EMERGENCY.equals(intent.getAction())) {
+ return true;
+ }
+
+ // 3. Telephony then starts the default package for making the call
+ final TelecomManager tm = getTelecomManager();
+ final String dialerPackage = tm != null ? tm.getSystemDialerPackage() : null;
+ if (dialerPackage != null && dialerPackage.equals(intent.getComponent().getPackageName())) {
+ return true;
+ }
+
+ return false;
+ }
+
+ /**
+ * Stop the current lock task mode.
+ *
+ * This is called by {@link ActivityManagerService} and performs various checks before actually
+ * finishing the locked task.
+ *
+ * @param task the task that requested the end of lock task mode ({@code null} for quitting app
+ * pinning mode)
+ * @param isSystemCaller indicates whether this request comes from the system via
+ * {@link ActivityTaskManagerService#stopSystemLockTaskMode()}. If
+ * {@code true}, it means the user intends to stop pinned mode through UI;
+ * otherwise, it's called by an app and we need to stop locked or pinned
+ * mode, subject to checks.
+ * @param callingUid the caller that requested the end of lock task mode.
+ * @throws IllegalArgumentException if the calling task is invalid (e.g., {@code null} or not in
+ * foreground)
+ * @throws SecurityException if the caller is not authorized to stop the lock task mode, i.e. if
+ * they differ from the one that launched lock task mode.
+ */
+ void stopLockTaskMode(@Nullable TaskRecord task, boolean isSystemCaller, int callingUid) {
+ if (mLockTaskModeState == LOCK_TASK_MODE_NONE) {
+ return;
+ }
+
+ if (isSystemCaller) {
+ if (mLockTaskModeState == LOCK_TASK_MODE_PINNED) {
+ clearLockedTasks("stopAppPinning");
+ } else {
+ Slog.e(TAG_LOCKTASK, "Attempted to stop LockTask with isSystemCaller=true");
+ showLockTaskToast();
+ }
+
+ } else {
+ // Ensure calling activity is not null
+ if (task == null) {
+ throw new IllegalArgumentException("can't stop LockTask for null task");
+ }
+
+ // Ensure the same caller for startLockTaskMode and stopLockTaskMode.
+ // It is possible lockTaskMode was started by the system process because
+ // android:lockTaskMode is set to a locking value in the application manifest
+ // instead of the app calling startLockTaskMode. In this case
+ // {@link TaskRecord.mLockTaskUid} will be 0, so we compare the callingUid to the
+ // {@link TaskRecord.effectiveUid} instead. Also caller with
+ // {@link MANAGE_ACTIVITY_STACKS} can stop any lock task.
+ if (callingUid != task.mLockTaskUid
+ && (task.mLockTaskUid != 0 || callingUid != task.effectiveUid)) {
+ throw new SecurityException("Invalid uid, expected " + task.mLockTaskUid
+ + " callingUid=" + callingUid + " effectiveUid=" + task.effectiveUid);
+ }
+
+ // We don't care if it's pinned or locked mode; this will stop it anyways.
+ clearLockedTask(task);
+ }
+ }
+
+ /**
+ * Clear all locked tasks and request the end of LockTask mode.
+ *
+ * This method is called by UserController when starting a new foreground user, and,
+ * unlike {@link #stopLockTaskMode(TaskRecord, boolean, int)}, it doesn't perform the checks.
+ */
+ void clearLockedTasks(String reason) {
+ if (DEBUG_LOCKTASK) Slog.i(TAG_LOCKTASK, "clearLockedTasks: " + reason);
+ if (!mLockTaskModeTasks.isEmpty()) {
+ clearLockedTask(mLockTaskModeTasks.get(0));
+ }
+ }
+
+ /**
+ * Clear one locked task from LockTask mode.
+ *
+ * If the requested task is the root task (see {@link #mLockTaskModeTasks}), then all locked
+ * tasks are cleared. Otherwise, only the requested task is cleared. LockTask mode is stopped
+ * when the last locked task is cleared.
+ *
+ * @param task the task to be cleared from LockTask mode.
+ */
+ void clearLockedTask(final TaskRecord task) {
+ if (task == null || mLockTaskModeTasks.isEmpty()) return;
+
+ if (task == mLockTaskModeTasks.get(0)) {
+ // We're removing the root task while there are other locked tasks. Therefore we should
+ // clear all locked tasks in reverse order.
+ for (int taskNdx = mLockTaskModeTasks.size() - 1; taskNdx > 0; --taskNdx) {
+ clearLockedTask(mLockTaskModeTasks.get(taskNdx));
+ }
+ }
+
+ removeLockedTask(task);
+ if (mLockTaskModeTasks.isEmpty()) {
+ return;
+ }
+ task.performClearTaskLocked();
+ mSupervisor.resumeFocusedStacksTopActivitiesLocked();
+ }
+
+ /**
+ * Remove the given task from the locked task list. If this was the last task in the list,
+ * lock task mode is stopped.
+ */
+ private void removeLockedTask(final TaskRecord task) {
+ if (!mLockTaskModeTasks.remove(task)) {
+ return;
+ }
+ if (DEBUG_LOCKTASK) Slog.d(TAG_LOCKTASK, "removeLockedTask: removed " + task);
+ if (mLockTaskModeTasks.isEmpty()) {
+ if (DEBUG_LOCKTASK) Slog.d(TAG_LOCKTASK, "removeLockedTask: task=" + task +
+ " last task, reverting locktask mode. Callers=" + Debug.getCallers(3));
+ mHandler.post(() -> performStopLockTask(task.userId));
+ }
+ }
+
+ // This method should only be called on the handler thread
+ private void performStopLockTask(int userId) {
+ // When lock task ends, we enable the status bars.
+ try {
+ setStatusBarState(LOCK_TASK_MODE_NONE, userId);
+ setKeyguardState(LOCK_TASK_MODE_NONE, userId);
+ if (mLockTaskModeState == LOCK_TASK_MODE_PINNED) {
+ lockKeyguardIfNeeded();
+ }
+ if (getDevicePolicyManager() != null) {
+ getDevicePolicyManager().notifyLockTaskModeChanged(false, null, userId);
+ }
+ if (mLockTaskModeState == LOCK_TASK_MODE_PINNED) {
+ getStatusBarService().showPinningEnterExitToast(false /* entering */);
+ }
+ mWindowManager.onLockTaskStateChanged(LOCK_TASK_MODE_NONE);
+ } catch (RemoteException ex) {
+ throw new RuntimeException(ex);
+ } finally {
+ mLockTaskModeState = LOCK_TASK_MODE_NONE;
+ }
+ }
+
+ /**
+ * Show the lock task violation toast. Currently we only show toast for screen pinning mode, and
+ * no-op if the device is in locked mode.
+ */
+ void showLockTaskToast() {
+ if (mLockTaskModeState == LOCK_TASK_MODE_PINNED) {
+ try {
+ getStatusBarService().showPinningEscapeToast();
+ } catch (RemoteException e) {
+ Slog.e(TAG, "Failed to send pinning escape toast", e);
+ }
+ }
+ }
+
+ // Starting lock task
+
+ /**
+ * Method to start lock task mode on a given task.
+ *
+ * @param task the task that should be locked.
+ * @param isSystemCaller indicates whether this request was initiated by the system via
+ * {@link ActivityTaskManagerService#startSystemLockTaskMode(int)}. If
+ * {@code true}, this intends to start pinned mode; otherwise, we look
+ * at the calling task's mLockTaskAuth to decide which mode to start.
+ * @param callingUid the caller that requested the launch of lock task mode.
+ */
+ void startLockTaskMode(@NonNull TaskRecord task, boolean isSystemCaller, int callingUid) {
+ if (!isSystemCaller) {
+ task.mLockTaskUid = callingUid;
+ if (task.mLockTaskAuth == LOCK_TASK_AUTH_PINNABLE) {
+ // startLockTask() called by app, but app is not part of lock task whitelist. Show
+ // app pinning request. We will come back here with isSystemCaller true.
+ if (DEBUG_LOCKTASK) Slog.w(TAG_LOCKTASK, "Mode default, asking user");
+ StatusBarManagerInternal statusBarManager = LocalServices.getService(
+ StatusBarManagerInternal.class);
+ if (statusBarManager != null) {
+ statusBarManager.showScreenPinningRequest(task.taskId);
+ }
+ return;
+ }
+ }
+
+ // System can only initiate screen pinning, not full lock task mode
+ if (DEBUG_LOCKTASK) Slog.w(TAG_LOCKTASK,
+ isSystemCaller ? "Locking pinned" : "Locking fully");
+ setLockTaskMode(task, isSystemCaller ? LOCK_TASK_MODE_PINNED : LOCK_TASK_MODE_LOCKED,
+ "startLockTask", true);
+ }
+
+ /**
+ * Start lock task mode on the given task.
+ * @param lockTaskModeState whether fully locked or pinned mode.
+ * @param andResume whether the task should be brought to foreground as part of the operation.
+ */
+ private void setLockTaskMode(@NonNull TaskRecord task, int lockTaskModeState,
+ String reason, boolean andResume) {
+ // Should have already been checked, but do it again.
+ if (task.mLockTaskAuth == LOCK_TASK_AUTH_DONT_LOCK) {
+ if (DEBUG_LOCKTASK) Slog.w(TAG_LOCKTASK,
+ "setLockTaskMode: Can't lock due to auth");
+ return;
+ }
+ if (isLockTaskModeViolation(task)) {
+ Slog.e(TAG_LOCKTASK, "setLockTaskMode: Attempt to start an unauthorized lock task.");
+ return;
+ }
+
+ final Intent taskIntent = task.intent;
+ if (mLockTaskModeTasks.isEmpty() && taskIntent != null) {
+ mSupervisor.mRecentTasks.onLockTaskModeStateChanged(lockTaskModeState, task.userId);
+ // Start lock task on the handler thread
+ mHandler.post(() -> performStartLockTask(
+ taskIntent.getComponent().getPackageName(),
+ task.userId,
+ lockTaskModeState));
+ }
+ if (DEBUG_LOCKTASK) Slog.w(TAG_LOCKTASK, "setLockTaskMode: Locking to " + task +
+ " Callers=" + Debug.getCallers(4));
+
+ if (!mLockTaskModeTasks.contains(task)) {
+ mLockTaskModeTasks.add(task);
+ }
+
+ if (task.mLockTaskUid == -1) {
+ task.mLockTaskUid = task.effectiveUid;
+ }
+
+ if (andResume) {
+ mSupervisor.findTaskToMoveToFront(task, 0, null, reason,
+ lockTaskModeState != LOCK_TASK_MODE_NONE);
+ mSupervisor.resumeFocusedStacksTopActivitiesLocked();
+ final ActivityStack stack = task.getStack();
+ if (stack != null) {
+ stack.getDisplay().getWindowContainerController().executeAppTransition();
+ }
+ } else if (lockTaskModeState != LOCK_TASK_MODE_NONE) {
+ mSupervisor.handleNonResizableTaskIfNeeded(task, WINDOWING_MODE_UNDEFINED,
+ DEFAULT_DISPLAY, task.getStack(), true /* forceNonResizable */);
+ }
+ }
+
+ // This method should only be called on the handler thread
+ private void performStartLockTask(String packageName, int userId, int lockTaskModeState) {
+ // When lock task starts, we disable the status bars.
+ try {
+ if (lockTaskModeState == LOCK_TASK_MODE_PINNED) {
+ getStatusBarService().showPinningEnterExitToast(true /* entering */);
+ }
+ mWindowManager.onLockTaskStateChanged(lockTaskModeState);
+ mLockTaskModeState = lockTaskModeState;
+ setStatusBarState(lockTaskModeState, userId);
+ setKeyguardState(lockTaskModeState, userId);
+ if (getDevicePolicyManager() != null) {
+ getDevicePolicyManager().notifyLockTaskModeChanged(true, packageName, userId);
+ }
+ } catch (RemoteException ex) {
+ throw new RuntimeException(ex);
+ }
+ }
+
+ /**
+ * Update packages that are allowed to be launched in lock task mode.
+ * @param userId Which user this whitelist is associated with
+ * @param packages The whitelist of packages allowed in lock task mode
+ * @see #mLockTaskPackages
+ */
+ void updateLockTaskPackages(int userId, String[] packages) {
+ mLockTaskPackages.put(userId, packages);
+
+ boolean taskChanged = false;
+ for (int taskNdx = mLockTaskModeTasks.size() - 1; taskNdx >= 0; --taskNdx) {
+ final TaskRecord lockedTask = mLockTaskModeTasks.get(taskNdx);
+ final boolean wasWhitelisted = lockedTask.mLockTaskAuth == LOCK_TASK_AUTH_LAUNCHABLE
+ || lockedTask.mLockTaskAuth == LOCK_TASK_AUTH_WHITELISTED;
+ lockedTask.setLockTaskAuth();
+ final boolean isWhitelisted = lockedTask.mLockTaskAuth == LOCK_TASK_AUTH_LAUNCHABLE
+ || lockedTask.mLockTaskAuth == LOCK_TASK_AUTH_WHITELISTED;
+
+ if (mLockTaskModeState != LOCK_TASK_MODE_LOCKED
+ || lockedTask.userId != userId
+ || !wasWhitelisted || isWhitelisted) {
+ continue;
+ }
+
+ // Terminate locked tasks that have recently lost whitelist authorization.
+ if (DEBUG_LOCKTASK) Slog.d(TAG_LOCKTASK, "onLockTaskPackagesUpdated: removing " +
+ lockedTask + " mLockTaskAuth()=" + lockedTask.lockTaskAuthToString());
+ removeLockedTask(lockedTask);
+ lockedTask.performClearTaskLocked();
+ taskChanged = true;
+ }
+
+ for (int displayNdx = mSupervisor.getChildCount() - 1; displayNdx >= 0; --displayNdx) {
+ mSupervisor.getChildAt(displayNdx).onLockTaskPackagesUpdated();
+ }
+
+ final ActivityRecord r = mSupervisor.topRunningActivityLocked();
+ final TaskRecord task = (r != null) ? r.getTask() : null;
+ if (mLockTaskModeTasks.isEmpty() && task!= null
+ && task.mLockTaskAuth == LOCK_TASK_AUTH_LAUNCHABLE) {
+ // This task must have just been authorized.
+ if (DEBUG_LOCKTASK) Slog.d(TAG_LOCKTASK,
+ "onLockTaskPackagesUpdated: starting new locktask task=" + task);
+ setLockTaskMode(task, LOCK_TASK_MODE_LOCKED, "package updated", false);
+ taskChanged = true;
+ }
+
+ if (taskChanged) {
+ mSupervisor.resumeFocusedStacksTopActivitiesLocked();
+ }
+ }
+
+ boolean isPackageWhitelisted(int userId, String pkg) {
+ if (pkg == null) {
+ return false;
+ }
+ String[] whitelist;
+ whitelist = mLockTaskPackages.get(userId);
+ if (whitelist == null) {
+ return false;
+ }
+ for (String whitelistedPkg : whitelist) {
+ if (pkg.equals(whitelistedPkg)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Update the UI features that are enabled for LockTask mode.
+ * @param userId Which user these feature flags are associated with
+ * @param flags Bitfield of feature flags
+ * @see DevicePolicyManager#setLockTaskFeatures(ComponentName, int)
+ */
+ void updateLockTaskFeatures(int userId, int flags) {
+ int oldFlags = getLockTaskFeaturesForUser(userId);
+ if (flags == oldFlags) {
+ return;
+ }
+
+ mLockTaskFeatures.put(userId, flags);
+ if (!mLockTaskModeTasks.isEmpty() && userId == mLockTaskModeTasks.get(0).userId) {
+ mHandler.post(() -> {
+ if (mLockTaskModeState == LOCK_TASK_MODE_LOCKED) {
+ setStatusBarState(mLockTaskModeState, userId);
+ setKeyguardState(mLockTaskModeState, userId);
+ }
+ });
+ }
+ }
+
+ /**
+ * Helper method for configuring the status bar disabled state.
+ * Should only be called on the handler thread to avoid race.
+ */
+ private void setStatusBarState(int lockTaskModeState, int userId) {
+ IStatusBarService statusBar = getStatusBarService();
+ if (statusBar == null) {
+ Slog.e(TAG, "Can't find StatusBarService");
+ return;
+ }
+
+ // Default state, when lockTaskModeState == LOCK_TASK_MODE_NONE
+ int flags1 = StatusBarManager.DISABLE_NONE;
+ int flags2 = StatusBarManager.DISABLE2_NONE;
+
+ if (lockTaskModeState == LOCK_TASK_MODE_PINNED) {
+ flags1 = STATUS_BAR_MASK_PINNED;
+
+ } else if (lockTaskModeState == LOCK_TASK_MODE_LOCKED) {
+ int lockTaskFeatures = getLockTaskFeaturesForUser(userId);
+ Pair<Integer, Integer> statusBarFlags = getStatusBarDisableFlags(lockTaskFeatures);
+ flags1 = statusBarFlags.first;
+ flags2 = statusBarFlags.second;
+ }
+
+ try {
+ statusBar.disable(flags1, mToken, mContext.getPackageName());
+ statusBar.disable2(flags2, mToken, mContext.getPackageName());
+ } catch (RemoteException e) {
+ Slog.e(TAG, "Failed to set status bar flags", e);
+ }
+ }
+
+ /**
+ * Helper method for configuring the keyguard disabled state.
+ * Should only be called on the handler thread to avoid race.
+ */
+ private void setKeyguardState(int lockTaskModeState, int userId) {
+ if (lockTaskModeState == LOCK_TASK_MODE_NONE) {
+ mWindowManager.reenableKeyguard(mToken);
+
+ } else if (lockTaskModeState == LOCK_TASK_MODE_LOCKED) {
+ if (isKeyguardAllowed(userId)) {
+ mWindowManager.reenableKeyguard(mToken);
+ } else {
+ // If keyguard is not secure and it is locked, dismiss the keyguard before
+ // disabling it, which avoids the platform to think the keyguard is still on.
+ if (mWindowManager.isKeyguardLocked() && !mWindowManager.isKeyguardSecure()) {
+ mWindowManager.dismissKeyguard(new IKeyguardDismissCallback.Stub() {
+ @Override
+ public void onDismissError() throws RemoteException {
+ Slog.i(TAG, "setKeyguardState: failed to dismiss keyguard");
+ }
+
+ @Override
+ public void onDismissSucceeded() throws RemoteException {
+ mHandler.post(
+ () -> mWindowManager.disableKeyguard(mToken, LOCK_TASK_TAG));
+ }
+
+ @Override
+ public void onDismissCancelled() throws RemoteException {
+ Slog.i(TAG, "setKeyguardState: dismiss cancelled");
+ }
+ }, null);
+ } else {
+ mWindowManager.disableKeyguard(mToken, LOCK_TASK_TAG);
+ }
+ }
+
+ } else { // lockTaskModeState == LOCK_TASK_MODE_PINNED
+ mWindowManager.disableKeyguard(mToken, LOCK_TASK_TAG);
+ }
+ }
+
+ /**
+ * Helper method for locking the device immediately. This may be necessary when the device
+ * leaves the pinned mode.
+ */
+ private void lockKeyguardIfNeeded() {
+ try {
+ boolean shouldLockKeyguard = Settings.Secure.getIntForUser(
+ mContext.getContentResolver(),
+ Settings.Secure.LOCK_TO_APP_EXIT_LOCKED,
+ USER_CURRENT) != 0;
+ if (shouldLockKeyguard) {
+ mWindowManager.lockNow(null);
+ mWindowManager.dismissKeyguard(null /* callback */, null /* message */);
+ getLockPatternUtils().requireCredentialEntry(USER_ALL);
+ }
+ } catch (Settings.SettingNotFoundException e) {
+ // No setting, don't lock.
+ }
+ }
+
+ /**
+ * Translates from LockTask feature flags to StatusBarManager disable and disable2 flags.
+ * @param lockTaskFlags Bitfield of flags as per
+ * {@link DevicePolicyManager#setLockTaskFeatures(ComponentName, int)}
+ * @return A {@link Pair} of {@link StatusBarManager#disable(int)} and
+ * {@link StatusBarManager#disable2(int)} flags
+ */
+ @VisibleForTesting
+ Pair<Integer, Integer> getStatusBarDisableFlags(int lockTaskFlags) {
+ // Everything is disabled by default
+ int flags1 = StatusBarManager.DISABLE_MASK;
+ int flags2 = StatusBarManager.DISABLE2_MASK;
+ for (int i = STATUS_BAR_FLAG_MAP_LOCKED.size() - 1; i >= 0; i--) {
+ Pair<Integer, Integer> statusBarFlags = STATUS_BAR_FLAG_MAP_LOCKED.valueAt(i);
+ if ((STATUS_BAR_FLAG_MAP_LOCKED.keyAt(i) & lockTaskFlags) != 0) {
+ flags1 &= ~statusBarFlags.first;
+ flags2 &= ~statusBarFlags.second;
+ }
+ }
+ // Some flags are not used for LockTask purposes, so we mask them
+ flags1 &= STATUS_BAR_MASK_LOCKED;
+ return new Pair<>(flags1, flags2);
+ }
+
+ /**
+ * Gets the cached value of LockTask feature flags for a specific user.
+ */
+ private int getLockTaskFeaturesForUser(int userId) {
+ return mLockTaskFeatures.get(userId, DevicePolicyManager.LOCK_TASK_FEATURE_NONE);
+ }
+
+ // Should only be called on the handler thread
+ @Nullable
+ private IStatusBarService getStatusBarService() {
+ if (mStatusBarService == null) {
+ mStatusBarService = IStatusBarService.Stub.asInterface(
+ ServiceManager.checkService(STATUS_BAR_SERVICE));
+ if (mStatusBarService == null) {
+ Slog.w("StatusBarManager", "warning: no STATUS_BAR_SERVICE");
+ }
+ }
+ return mStatusBarService;
+ }
+
+ // Should only be called on the handler thread
+ @Nullable
+ private IDevicePolicyManager getDevicePolicyManager() {
+ if (mDevicePolicyManager == null) {
+ mDevicePolicyManager = IDevicePolicyManager.Stub.asInterface(
+ ServiceManager.checkService(DEVICE_POLICY_SERVICE));
+ if (mDevicePolicyManager == null) {
+ Slog.w(TAG, "warning: no DEVICE_POLICY_SERVICE");
+ }
+ }
+ return mDevicePolicyManager;
+ }
+
+ @NonNull
+ private LockPatternUtils getLockPatternUtils() {
+ if (mLockPatternUtils == null) {
+ // We don't preserve the LPU object to save memory
+ return new LockPatternUtils(mContext);
+ }
+ return mLockPatternUtils;
+ }
+
+ @Nullable
+ private TelecomManager getTelecomManager() {
+ if (mTelecomManager == null) {
+ // We don't preserve the TelecomManager object to save memory
+ return mContext.getSystemService(TelecomManager.class);
+ }
+ return mTelecomManager;
+ }
+
+ public void dump(PrintWriter pw, String prefix) {
+ pw.println(prefix + "LockTaskController");
+ prefix = prefix + " ";
+ pw.println(prefix + "mLockTaskModeState=" + lockTaskModeToString());
+ pw.println(prefix + "mLockTaskModeTasks=");
+ for (int i = 0; i < mLockTaskModeTasks.size(); ++i) {
+ pw.println(prefix + " #" + i + " " + mLockTaskModeTasks.get(i));
+ }
+ pw.println(prefix + "mLockTaskPackages (userId:packages)=");
+ for (int i = 0; i < mLockTaskPackages.size(); ++i) {
+ pw.println(prefix + " u" + mLockTaskPackages.keyAt(i)
+ + ":" + Arrays.toString(mLockTaskPackages.valueAt(i)));
+ }
+ }
+
+ private String lockTaskModeToString() {
+ switch (mLockTaskModeState) {
+ case LOCK_TASK_MODE_LOCKED:
+ return "LOCKED";
+ case LOCK_TASK_MODE_PINNED:
+ return "PINNED";
+ case LOCK_TASK_MODE_NONE:
+ return "NONE";
+ default: return "unknown=" + mLockTaskModeState;
+ }
+ }
+}
diff --git a/services/core/java/com/android/server/wm/PendingRemoteAnimationRegistry.java b/services/core/java/com/android/server/wm/PendingRemoteAnimationRegistry.java
new file mode 100644
index 0000000..dcb9a6a
--- /dev/null
+++ b/services/core/java/com/android/server/wm/PendingRemoteAnimationRegistry.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.server.wm;
+
+import android.annotation.Nullable;
+import android.app.ActivityOptions;
+import android.os.Handler;
+import android.util.ArrayMap;
+import android.view.RemoteAnimationAdapter;
+
+import com.android.server.am.ActivityManagerService;
+
+/**
+ * Registry to keep track of remote animations to be run for activity starts from a certain package.
+ *
+ * @see ActivityManagerService#registerRemoteAnimationForNextActivityStart
+ */
+class PendingRemoteAnimationRegistry {
+
+ private static final long TIMEOUT_MS = 3000;
+
+ private final ArrayMap<String, Entry> mEntries = new ArrayMap<>();
+ private final Handler mHandler;
+ private final ActivityTaskManagerService mService;
+
+ PendingRemoteAnimationRegistry(ActivityTaskManagerService service, Handler handler) {
+ mService = service;
+ mHandler = handler;
+ }
+
+ /**
+ * Adds a remote animation to be run for all activity starts originating from a certain package.
+ */
+ void addPendingAnimation(String packageName, RemoteAnimationAdapter adapter) {
+ mEntries.put(packageName, new Entry(packageName, adapter));
+ }
+
+ /**
+ * Overrides the activity options with a registered remote animation for a certain calling
+ * package if such a remote animation is registered.
+ */
+ ActivityOptions overrideOptionsIfNeeded(String callingPackage,
+ @Nullable ActivityOptions options) {
+ final Entry entry = mEntries.get(callingPackage);
+ if (entry == null) {
+ return options;
+ }
+ if (options == null) {
+ options = ActivityOptions.makeRemoteAnimation(entry.adapter);
+ } else {
+ options.setRemoteAnimationAdapter(entry.adapter);
+ }
+ mEntries.remove(callingPackage);
+ return options;
+ }
+
+ private class Entry {
+ final String packageName;
+ final RemoteAnimationAdapter adapter;
+
+ Entry(String packageName, RemoteAnimationAdapter adapter) {
+ this.packageName = packageName;
+ this.adapter = adapter;
+ mHandler.postDelayed(() -> {
+ synchronized (mService.mGlobalLock) {
+ final Entry entry = mEntries.get(packageName);
+ if (entry == this) {
+ mEntries.remove(packageName);
+ }
+ }
+ }, TIMEOUT_MS);
+ }
+ }
+}
diff --git a/services/core/java/com/android/server/wm/PersisterQueue.java b/services/core/java/com/android/server/wm/PersisterQueue.java
new file mode 100644
index 0000000..1cfc7ac
--- /dev/null
+++ b/services/core/java/com/android/server/wm/PersisterQueue.java
@@ -0,0 +1,282 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.server.wm;
+
+import android.os.Process;
+import android.os.SystemClock;
+import android.util.Slog;
+
+import com.android.internal.annotations.VisibleForTesting;
+
+import java.util.ArrayList;
+import java.util.function.Predicate;
+
+/**
+ * The common threading logic for persisters to use so that they can run in the same threads.
+ * Methods in this class are synchronized on its instance, so caller could also synchronize on
+ * its instance to perform modifications in items.
+ */
+class PersisterQueue {
+ private static final String TAG = "PersisterQueue";
+ private static final boolean DEBUG = false;
+
+ /** When not flushing don't write out files faster than this */
+ private static final long INTER_WRITE_DELAY_MS = 500;
+
+ /**
+ * When not flushing delay this long before writing the first file out. This gives the next task
+ * being launched a chance to load its resources without this occupying IO bandwidth.
+ */
+ private static final long PRE_TASK_DELAY_MS = 3000;
+
+ /** The maximum number of entries to keep in the queue before draining it automatically. */
+ private static final int MAX_WRITE_QUEUE_LENGTH = 6;
+
+ /** Special value for mWriteTime to mean don't wait, just write */
+ private static final long FLUSH_QUEUE = -1;
+
+ /** An {@link WriteQueueItem} that doesn't do anything. Used to trigger {@link
+ * Listener#onPreProcessItem}. */
+ static final WriteQueueItem EMPTY_ITEM = () -> { };
+
+ private final long mInterWriteDelayMs;
+ private final long mPreTaskDelayMs;
+ private final LazyTaskWriterThread mLazyTaskWriterThread;
+ private final ArrayList<WriteQueueItem> mWriteQueue = new ArrayList<>();
+
+ private final ArrayList<Listener> mListeners = new ArrayList<>();
+
+ /**
+ * Value determines write delay mode as follows: < 0 We are Flushing. No delays between writes
+ * until the image queue is drained and all tasks needing persisting are written to disk. There
+ * is no delay between writes. == 0 We are Idle. Next writes will be delayed by
+ * #PRE_TASK_DELAY_MS. > 0 We are Actively writing. Next write will be at this time. Subsequent
+ * writes will be delayed by #INTER_WRITE_DELAY_MS.
+ */
+ private long mNextWriteTime = 0;
+
+ PersisterQueue() {
+ this(INTER_WRITE_DELAY_MS, PRE_TASK_DELAY_MS);
+ }
+
+ /** Used for tests to reduce waiting time. */
+ @VisibleForTesting
+ PersisterQueue(long interWriteDelayMs, long preTaskDelayMs) {
+ if (interWriteDelayMs < 0 || preTaskDelayMs < 0) {
+ throw new IllegalArgumentException("Both inter-write delay and pre-task delay need to"
+ + "be non-negative. inter-write delay: " + interWriteDelayMs
+ + "ms pre-task delay: " + preTaskDelayMs);
+ }
+ mInterWriteDelayMs = interWriteDelayMs;
+ mPreTaskDelayMs = preTaskDelayMs;
+ mLazyTaskWriterThread = new LazyTaskWriterThread("LazyTaskWriterThread");
+ }
+
+ synchronized void startPersisting() {
+ if (!mLazyTaskWriterThread.isAlive()) {
+ mLazyTaskWriterThread.start();
+ }
+ }
+
+ /** Stops persisting thread. Should only be used in tests. */
+ @VisibleForTesting
+ void stopPersisting() throws InterruptedException {
+ if (!mLazyTaskWriterThread.isAlive()) {
+ return;
+ }
+
+ synchronized (this) {
+ mLazyTaskWriterThread.interrupt();
+ }
+ mLazyTaskWriterThread.join();
+ }
+
+ synchronized void addItem(WriteQueueItem item, boolean flush) {
+ mWriteQueue.add(item);
+
+ if (flush || mWriteQueue.size() > MAX_WRITE_QUEUE_LENGTH) {
+ mNextWriteTime = FLUSH_QUEUE;
+ } else if (mNextWriteTime == 0) {
+ mNextWriteTime = SystemClock.uptimeMillis() + mPreTaskDelayMs;
+ }
+ notify();
+ }
+
+ synchronized <T extends WriteQueueItem> T findLastItem(Predicate<T> predicate, Class<T> clazz) {
+ for (int i = mWriteQueue.size() - 1; i >= 0; --i) {
+ WriteQueueItem writeQueueItem = mWriteQueue.get(i);
+ if (clazz.isInstance(writeQueueItem)) {
+ T item = clazz.cast(writeQueueItem);
+ if (predicate.test(item)) {
+ return item;
+ }
+ }
+ }
+
+ return null;
+ }
+
+ synchronized <T extends WriteQueueItem> void removeItems(Predicate<T> predicate,
+ Class<T> clazz) {
+ for (int i = mWriteQueue.size() - 1; i >= 0; --i) {
+ WriteQueueItem writeQueueItem = mWriteQueue.get(i);
+ if (clazz.isInstance(writeQueueItem)) {
+ T item = clazz.cast(writeQueueItem);
+ if (predicate.test(item)) {
+ if (DEBUG) Slog.d(TAG, "Removing " + item + " from write queue.");
+ mWriteQueue.remove(i);
+ }
+ }
+ }
+ }
+
+ synchronized void flush() {
+ mNextWriteTime = FLUSH_QUEUE;
+ notifyAll();
+ do {
+ try {
+ wait();
+ } catch (InterruptedException e) {
+ }
+ } while (mNextWriteTime == FLUSH_QUEUE);
+ }
+
+ void yieldIfQueueTooDeep() {
+ boolean stall = false;
+ synchronized (this) {
+ if (mNextWriteTime == FLUSH_QUEUE) {
+ stall = true;
+ }
+ }
+ if (stall) {
+ Thread.yield();
+ }
+ }
+
+ void addListener(Listener listener) {
+ mListeners.add(listener);
+ }
+
+ @VisibleForTesting
+ boolean removeListener(Listener listener) {
+ return mListeners.remove(listener);
+ }
+
+ private void processNextItem() throws InterruptedException {
+ // This part is extracted into a method so that the GC can clearly see the end of the
+ // scope of the variable 'item'. If this part was in the loop in LazyTaskWriterThread, the
+ // last item it processed would always "leak".
+ // See https://b.corp.google.com/issues/64438652#comment7
+
+ // If mNextWriteTime, then don't delay between each call to saveToXml().
+ final WriteQueueItem item;
+ synchronized (this) {
+ if (mNextWriteTime != FLUSH_QUEUE) {
+ // The next write we don't have to wait so long.
+ mNextWriteTime = SystemClock.uptimeMillis() + mInterWriteDelayMs;
+ if (DEBUG) {
+ Slog.d(TAG, "Next write time may be in " + mInterWriteDelayMs
+ + " msec. (" + mNextWriteTime + ")");
+ }
+ }
+
+ while (mWriteQueue.isEmpty()) {
+ if (mNextWriteTime != 0) {
+ mNextWriteTime = 0; // idle.
+ notify(); // May need to wake up flush().
+ }
+ // Make sure we exit this thread correctly when interrupted before going to
+ // indefinite wait.
+ if (Thread.currentThread().isInterrupted()) {
+ throw new InterruptedException();
+ }
+ if (DEBUG) Slog.d(TAG, "LazyTaskWriter: waiting indefinitely.");
+ wait();
+ // Invariant: mNextWriteTime is either FLUSH_QUEUE or PRE_WRITE_DELAY_MS
+ // from now.
+ }
+ item = mWriteQueue.remove(0);
+
+ long now = SystemClock.uptimeMillis();
+ if (DEBUG) {
+ Slog.d(TAG, "LazyTaskWriter: now=" + now + " mNextWriteTime=" + mNextWriteTime
+ + " mWriteQueue.size=" + mWriteQueue.size());
+ }
+ while (now < mNextWriteTime) {
+ if (DEBUG) {
+ Slog.d(TAG, "LazyTaskWriter: waiting " + (mNextWriteTime - now));
+ }
+ wait(mNextWriteTime - now);
+ now = SystemClock.uptimeMillis();
+ }
+
+ // Got something to do.
+ }
+
+ item.process();
+ }
+
+ interface WriteQueueItem {
+ void process();
+ }
+
+ interface Listener {
+ /**
+ * Called before {@link PersisterQueue} tries to process next item.
+ *
+ * Note if the queue is empty, this callback will be called before the indefinite wait. This
+ * will be called once when {@link PersisterQueue} starts the internal thread before the
+ * indefinite wait.
+ *
+ * This callback is called w/o locking the instance of {@link PersisterQueue}.
+ *
+ * @param queueEmpty {@code true} if the queue is empty, which indicates {@link
+ * PersisterQueue} is likely to enter indefinite wait; or {@code false} if there is still
+ * item to process.
+ */
+ void onPreProcessItem(boolean queueEmpty);
+ }
+
+ private class LazyTaskWriterThread extends Thread {
+
+ private LazyTaskWriterThread(String name) {
+ super(name);
+ }
+
+ @Override
+ public void run() {
+ Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
+ try {
+ while (true) {
+ final boolean probablyDone;
+ synchronized (PersisterQueue.this) {
+ probablyDone = mWriteQueue.isEmpty();
+ }
+
+ for (int i = mListeners.size() - 1; i >= 0; --i) {
+ mListeners.get(i).onPreProcessItem(probablyDone);
+ }
+
+ processNextItem();
+ }
+ } catch (InterruptedException e) {
+ Slog.e(TAG, "Persister thread is exiting. Should never happen in prod, but"
+ + "it's OK in tests.");
+ }
+ }
+ }
+}
diff --git a/services/core/java/com/android/server/wm/PinnedActivityStack.java b/services/core/java/com/android/server/wm/PinnedActivityStack.java
new file mode 100644
index 0000000..af18077
--- /dev/null
+++ b/services/core/java/com/android/server/wm/PinnedActivityStack.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.server.wm;
+
+import static android.app.WindowConfiguration.ACTIVITY_TYPE_STANDARD;
+import static android.app.WindowConfiguration.WINDOWING_MODE_PINNED;
+
+import android.app.RemoteAction;
+import android.content.res.Configuration;
+import android.graphics.Rect;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * State and management of the pinned stack of activities.
+ */
+class PinnedActivityStack extends ActivityStack<PinnedStackWindowController>
+ implements PinnedStackWindowListener {
+
+ PinnedActivityStack(ActivityDisplay display, int stackId, ActivityStackSupervisor supervisor,
+ boolean onTop) {
+ super(display, stackId, supervisor, WINDOWING_MODE_PINNED, ACTIVITY_TYPE_STANDARD, onTop);
+ }
+
+ @Override
+ PinnedStackWindowController createStackWindowController(int displayId, boolean onTop,
+ Rect outBounds) {
+ return new PinnedStackWindowController(mStackId, this, displayId, onTop, outBounds,
+ mStackSupervisor.mWindowManager);
+ }
+
+ Rect getDefaultPictureInPictureBounds(float aspectRatio) {
+ return getWindowContainerController().getPictureInPictureBounds(aspectRatio,
+ null /* currentStackBounds */);
+ }
+
+ void animateResizePinnedStack(Rect sourceHintBounds, Rect toBounds, int animationDuration,
+ boolean fromFullscreen) {
+ if (skipResizeAnimation(toBounds == null /* toFullscreen */)) {
+ mService.moveTasksToFullscreenStack(mStackId, true /* onTop */);
+ } else {
+ getWindowContainerController().animateResizePinnedStack(toBounds, sourceHintBounds,
+ animationDuration, fromFullscreen);
+ }
+ }
+
+ private boolean skipResizeAnimation(boolean toFullscreen) {
+ if (!toFullscreen) {
+ return false;
+ }
+ final Configuration parentConfig = getParent().getConfiguration();
+ final ActivityRecord top = topRunningNonOverlayTaskActivity();
+ return top != null && !top.isConfigurationCompatible(parentConfig);
+ }
+
+ void setPictureInPictureAspectRatio(float aspectRatio) {
+ getWindowContainerController().setPictureInPictureAspectRatio(aspectRatio);
+ }
+
+ void setPictureInPictureActions(List<RemoteAction> actions) {
+ getWindowContainerController().setPictureInPictureActions(actions);
+ }
+
+ boolean isAnimatingBoundsToFullscreen() {
+ return getWindowContainerController().isAnimatingBoundsToFullscreen();
+ }
+
+ /**
+ * Returns whether to defer the scheduling of the multi-window mode.
+ */
+ boolean deferScheduleMultiWindowModeChanged() {
+ // For the pinned stack, the deferring of the multi-window mode changed is tied to the
+ // transition animation into picture-in-picture, and is called once the animation completes,
+ // or is interrupted in a way that would leave the stack in a non-fullscreen state.
+ // @see BoundsAnimationController
+ // @see BoundsAnimationControllerTests
+ return mWindowContainerController.deferScheduleMultiWindowModeChanged();
+ }
+
+ public void updatePictureInPictureModeForPinnedStackAnimation(Rect targetStackBounds,
+ boolean forceUpdate) {
+ // It is guaranteed that the activities requiring the update will be in the pinned stack at
+ // this point (either reparented before the animation into PiP, or before reparenting after
+ // the animation out of PiP)
+ synchronized (mService) {
+ ArrayList<TaskRecord> tasks = getAllTasks();
+ for (int i = 0; i < tasks.size(); i++ ) {
+ mStackSupervisor.updatePictureInPictureMode(tasks.get(i), targetStackBounds,
+ forceUpdate);
+ }
+ }
+ }
+}
diff --git a/services/core/java/com/android/server/wm/RecentTasks.java b/services/core/java/com/android/server/wm/RecentTasks.java
new file mode 100644
index 0000000..c995d3f
--- /dev/null
+++ b/services/core/java/com/android/server/wm/RecentTasks.java
@@ -0,0 +1,1621 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.server.wm;
+
+import static android.app.ActivityManager.FLAG_AND_UNLOCKED;
+import static android.app.ActivityManager.RECENT_IGNORE_UNAVAILABLE;
+import static android.app.ActivityManager.RECENT_WITH_EXCLUDED;
+import static android.app.WindowConfiguration.ACTIVITY_TYPE_ASSISTANT;
+import static android.app.WindowConfiguration.ACTIVITY_TYPE_HOME;
+import static android.app.WindowConfiguration.ACTIVITY_TYPE_RECENTS;
+import static android.app.WindowConfiguration.ACTIVITY_TYPE_UNDEFINED;
+import static android.app.WindowConfiguration.WINDOWING_MODE_PINNED;
+import static android.app.WindowConfiguration.WINDOWING_MODE_SPLIT_SCREEN_PRIMARY;
+import static android.app.WindowConfiguration.WINDOWING_MODE_UNDEFINED;
+import static android.content.Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS;
+import static android.content.Intent.FLAG_ACTIVITY_MULTIPLE_TASK;
+import static android.content.Intent.FLAG_ACTIVITY_NEW_DOCUMENT;
+import static android.content.Intent.FLAG_ACTIVITY_NEW_TASK;
+import static android.os.Process.SYSTEM_UID;
+import static android.view.Display.DEFAULT_DISPLAY;
+
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_RECENTS;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_RECENTS_TRIM_TASKS;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_TASKS;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_RECENTS;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_TASKS;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_ATM;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_WITH_CLASS_NAME;
+import static com.android.server.wm.ActivityStackSupervisor.REMOVE_FROM_RECENTS;
+import static android.app.ActivityTaskManager.INVALID_TASK_ID;
+
+import android.app.ActivityManager;
+import android.app.ActivityTaskManager;
+import android.app.AppGlobals;
+import android.content.ComponentName;
+import android.content.Intent;
+import android.content.pm.ActivityInfo;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.IPackageManager;
+import android.content.pm.PackageManager;
+import android.content.pm.ParceledListSlice;
+import android.content.pm.UserInfo;
+import android.content.res.Resources;
+import android.graphics.Bitmap;
+import android.os.Bundle;
+import android.os.Environment;
+import android.os.IBinder;
+import android.os.RemoteException;
+import android.os.SystemProperties;
+import android.os.UserHandle;
+import android.text.TextUtils;
+import android.util.ArraySet;
+import android.util.Slog;
+import android.util.SparseArray;
+import android.util.SparseBooleanArray;
+
+import com.android.internal.annotations.VisibleForTesting;
+import com.android.server.am.ActivityManagerService;
+import com.android.server.wm.TaskRecord.TaskActivitiesReport;
+
+import com.google.android.collect.Sets;
+
+import java.io.File;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Class for managing the recent tasks list. The list is ordered by most recent (index 0) to the
+ * least recent.
+ *
+ * The trimming logic can be boiled down to the following. For recent task list with a number of
+ * tasks, the visible tasks are an interleaving subset of tasks that would normally be presented to
+ * the user. Non-visible tasks are not considered for trimming. Of the visible tasks, only a
+ * sub-range are presented to the user, based on the device type, last task active time, or other
+ * task state. Tasks that are not in the visible range and are not returnable from the SystemUI
+ * (considering the back stack) are considered trimmable. If the device does not support recent
+ * tasks, then trimming is completely disabled.
+ *
+ * eg.
+ * L = [TTTTTTTTTTTTTTTTTTTTTTTTTT] // list of tasks
+ * [VVV VV VVVV V V V ] // Visible tasks
+ * [RRR RR XXXX X X X ] // Visible range tasks, eg. if the device only shows 5 tasks,
+ * // 'X' tasks are trimmed.
+ */
+class RecentTasks {
+ private static final String TAG = TAG_WITH_CLASS_NAME ? "RecentTasks" : TAG_ATM;
+ private static final String TAG_RECENTS = TAG + POSTFIX_RECENTS;
+ private static final String TAG_TASKS = TAG + POSTFIX_TASKS;
+
+ private static final int DEFAULT_INITIAL_CAPACITY = 5;
+
+ // Whether or not to move all affiliated tasks to the front when one of the tasks is launched
+ private static final boolean MOVE_AFFILIATED_TASKS_TO_FRONT = false;
+
+ // Comparator to sort by taskId
+ private static final Comparator<TaskRecord> TASK_ID_COMPARATOR =
+ (lhs, rhs) -> rhs.taskId - lhs.taskId;
+
+ // Placeholder variables to keep track of activities/apps that are no longer avialble while
+ // iterating through the recents list
+ private static final ActivityInfo NO_ACTIVITY_INFO_TOKEN = new ActivityInfo();
+ private static final ApplicationInfo NO_APPLICATION_INFO_TOKEN = new ApplicationInfo();
+
+ /**
+ * Callbacks made when manipulating the list.
+ */
+ interface Callbacks {
+ /**
+ * Called when a task is added to the recent tasks list.
+ */
+ void onRecentTaskAdded(TaskRecord task);
+
+ /**
+ * Called when a task is removed from the recent tasks list.
+ */
+ void onRecentTaskRemoved(TaskRecord task, boolean wasTrimmed, boolean killProcess);
+ }
+
+ /**
+ * Save recent tasks information across reboots.
+ */
+ private final TaskPersister mTaskPersister;
+ private final ActivityTaskManagerService mService;
+ private final ActivityStackSupervisor mSupervisor;
+
+ /**
+ * Keeps track of the static recents package/component which is granted additional permissions
+ * to call recents-related APIs.
+ */
+ private int mRecentsUid = -1;
+ private ComponentName mRecentsComponent = null;
+
+ /**
+ * Mapping of user id -> whether recent tasks have been loaded for that user.
+ */
+ private final SparseBooleanArray mUsersWithRecentsLoaded = new SparseBooleanArray(
+ DEFAULT_INITIAL_CAPACITY);
+
+ /**
+ * Stores for each user task ids that are taken by tasks residing in persistent storage. These
+ * tasks may or may not currently be in memory.
+ */
+ private final SparseArray<SparseBooleanArray> mPersistedTaskIds = new SparseArray<>(
+ DEFAULT_INITIAL_CAPACITY);
+
+ // List of all active recent tasks
+ private final ArrayList<TaskRecord> mTasks = new ArrayList<>();
+ private final ArrayList<Callbacks> mCallbacks = new ArrayList<>();
+
+ // These values are generally loaded from resources, but can be set dynamically in the tests
+ private boolean mHasVisibleRecentTasks;
+ private int mGlobalMaxNumTasks;
+ private int mMinNumVisibleTasks;
+ private int mMaxNumVisibleTasks;
+ private long mActiveTasksSessionDurationMs;
+
+ // Mainly to avoid object recreation on multiple calls.
+ private final ArrayList<TaskRecord> mTmpRecents = new ArrayList<>();
+ private final HashMap<ComponentName, ActivityInfo> mTmpAvailActCache = new HashMap<>();
+ private final HashMap<String, ApplicationInfo> mTmpAvailAppCache = new HashMap<>();
+ private final SparseBooleanArray mTmpQuietProfileUserIds = new SparseBooleanArray();
+ private final TaskActivitiesReport mTmpReport = new TaskActivitiesReport();
+
+ @VisibleForTesting
+ RecentTasks(ActivityTaskManagerService service, TaskPersister taskPersister) {
+ mService = service;
+ mSupervisor = mService.mStackSupervisor;
+ mTaskPersister = taskPersister;
+ mGlobalMaxNumTasks = ActivityTaskManager.getMaxRecentTasksStatic();
+ mHasVisibleRecentTasks = true;
+ }
+
+ RecentTasks(ActivityTaskManagerService service, ActivityStackSupervisor stackSupervisor) {
+ final File systemDir = Environment.getDataSystemDirectory();
+ final Resources res = service.mContext.getResources();
+ mService = service;
+ mSupervisor = mService.mStackSupervisor;
+ mTaskPersister = new TaskPersister(systemDir, stackSupervisor, service, this);
+ mGlobalMaxNumTasks = ActivityTaskManager.getMaxRecentTasksStatic();
+ mHasVisibleRecentTasks = res.getBoolean(com.android.internal.R.bool.config_hasRecents);
+ loadParametersFromResources(res);
+ }
+
+ @VisibleForTesting
+ void setParameters(int minNumVisibleTasks, int maxNumVisibleTasks,
+ long activeSessionDurationMs) {
+ mMinNumVisibleTasks = minNumVisibleTasks;
+ mMaxNumVisibleTasks = maxNumVisibleTasks;
+ mActiveTasksSessionDurationMs = activeSessionDurationMs;
+ }
+
+ @VisibleForTesting
+ void setGlobalMaxNumTasks(int globalMaxNumTasks) {
+ mGlobalMaxNumTasks = globalMaxNumTasks;
+ }
+
+ /**
+ * Loads the parameters from the system resources.
+ */
+ @VisibleForTesting
+ void loadParametersFromResources(Resources res) {
+ if (ActivityManager.isLowRamDeviceStatic()) {
+ mMinNumVisibleTasks = res.getInteger(
+ com.android.internal.R.integer.config_minNumVisibleRecentTasks_lowRam);
+ mMaxNumVisibleTasks = res.getInteger(
+ com.android.internal.R.integer.config_maxNumVisibleRecentTasks_lowRam);
+ } else if (SystemProperties.getBoolean("ro.recents.grid", false)) {
+ mMinNumVisibleTasks = res.getInteger(
+ com.android.internal.R.integer.config_minNumVisibleRecentTasks_grid);
+ mMaxNumVisibleTasks = res.getInteger(
+ com.android.internal.R.integer.config_maxNumVisibleRecentTasks_grid);
+ } else {
+ mMinNumVisibleTasks = res.getInteger(
+ com.android.internal.R.integer.config_minNumVisibleRecentTasks);
+ mMaxNumVisibleTasks = res.getInteger(
+ com.android.internal.R.integer.config_maxNumVisibleRecentTasks);
+ }
+ final int sessionDurationHrs = res.getInteger(
+ com.android.internal.R.integer.config_activeTaskDurationHours);
+ mActiveTasksSessionDurationMs = (sessionDurationHrs > 0)
+ ? TimeUnit.HOURS.toMillis(sessionDurationHrs)
+ : -1;
+ }
+
+ /**
+ * Loads the static recents component. This is called after the system is ready, but before
+ * any dependent services (like SystemUI) is started.
+ */
+ void loadRecentsComponent(Resources res) {
+ final String rawRecentsComponent = res.getString(
+ com.android.internal.R.string.config_recentsComponentName);
+ if (TextUtils.isEmpty(rawRecentsComponent)) {
+ return;
+ }
+
+ final ComponentName cn = ComponentName.unflattenFromString(rawRecentsComponent);
+ if (cn != null) {
+ try {
+ final ApplicationInfo appInfo = AppGlobals.getPackageManager()
+ .getApplicationInfo(cn.getPackageName(), 0, mService.mContext.getUserId());
+ if (appInfo != null) {
+ mRecentsUid = appInfo.uid;
+ mRecentsComponent = cn;
+ }
+ } catch (RemoteException e) {
+ Slog.w(TAG, "Could not load application info for recents component: " + cn);
+ }
+ }
+ }
+
+ /**
+ * @return whether the current caller has the same uid as the recents component.
+ */
+ boolean isCallerRecents(int callingUid) {
+ return UserHandle.isSameApp(callingUid, mRecentsUid);
+ }
+
+ /**
+ * @return whether the given component is the recents component and shares the same uid as the
+ * recents component.
+ */
+ boolean isRecentsComponent(ComponentName cn, int uid) {
+ return cn.equals(mRecentsComponent) && UserHandle.isSameApp(uid, mRecentsUid);
+ }
+
+ /**
+ * @return whether the home app is also the active handler of recent tasks.
+ */
+ boolean isRecentsComponentHomeActivity(int userId) {
+ final ComponentName defaultHomeActivity = mService.getPackageManagerInternalLocked()
+ .getDefaultHomeActivity(userId);
+ return defaultHomeActivity != null && mRecentsComponent != null &&
+ defaultHomeActivity.getPackageName().equals(mRecentsComponent.getPackageName());
+ }
+
+ /**
+ * @return the recents component.
+ */
+ ComponentName getRecentsComponent() {
+ return mRecentsComponent;
+ }
+
+ /**
+ * @return the uid for the recents component.
+ */
+ int getRecentsComponentUid() {
+ return mRecentsUid;
+ }
+
+ void registerCallback(Callbacks callback) {
+ mCallbacks.add(callback);
+ }
+
+ void unregisterCallback(Callbacks callback) {
+ mCallbacks.remove(callback);
+ }
+
+ private void notifyTaskAdded(TaskRecord task) {
+ for (int i = 0; i < mCallbacks.size(); i++) {
+ mCallbacks.get(i).onRecentTaskAdded(task);
+ }
+ }
+
+ private void notifyTaskRemoved(TaskRecord task, boolean wasTrimmed, boolean killProcess) {
+ for (int i = 0; i < mCallbacks.size(); i++) {
+ mCallbacks.get(i).onRecentTaskRemoved(task, wasTrimmed, killProcess);
+ }
+ }
+
+ /**
+ * Loads the persistent recentTasks for {@code userId} into this list from persistent storage.
+ * Does nothing if they are already loaded.
+ *
+ * @param userId the user Id
+ */
+ void loadUserRecentsLocked(int userId) {
+ if (mUsersWithRecentsLoaded.get(userId)) {
+ // User already loaded, return early
+ return;
+ }
+
+ // Load the task ids if not loaded.
+ loadPersistedTaskIdsForUserLocked(userId);
+
+ // Check if any tasks are added before recents is loaded
+ final SparseBooleanArray preaddedTasks = new SparseBooleanArray();
+ for (final TaskRecord task : mTasks) {
+ if (task.userId == userId && shouldPersistTaskLocked(task)) {
+ preaddedTasks.put(task.taskId, true);
+ }
+ }
+
+ Slog.i(TAG, "Loading recents for user " + userId + " into memory.");
+ mTasks.addAll(mTaskPersister.restoreTasksForUserLocked(userId, preaddedTasks));
+ cleanupLocked(userId);
+ mUsersWithRecentsLoaded.put(userId, true);
+
+ // If we have tasks added before loading recents, we need to update persistent task IDs.
+ if (preaddedTasks.size() > 0) {
+ syncPersistentTaskIdsLocked();
+ }
+ }
+
+ private void loadPersistedTaskIdsForUserLocked(int userId) {
+ // An empty instead of a null set here means that no persistent taskIds were present
+ // on file when we loaded them.
+ if (mPersistedTaskIds.get(userId) == null) {
+ mPersistedTaskIds.put(userId, mTaskPersister.loadPersistedTaskIdsForUser(userId));
+ Slog.i(TAG, "Loaded persisted task ids for user " + userId);
+ }
+ }
+
+ /**
+ * @return whether the {@param taskId} is currently in use for the given user.
+ */
+ boolean containsTaskId(int taskId, int userId) {
+ loadPersistedTaskIdsForUserLocked(userId);
+ return mPersistedTaskIds.get(userId).get(taskId);
+ }
+
+ /**
+ * @return all the task ids for the user with the given {@param userId}.
+ */
+ SparseBooleanArray getTaskIdsForUser(int userId) {
+ loadPersistedTaskIdsForUserLocked(userId);
+ return mPersistedTaskIds.get(userId);
+ }
+
+ /**
+ * Kicks off the task persister to write any pending tasks to disk.
+ */
+ void notifyTaskPersisterLocked(TaskRecord task, boolean flush) {
+ final ActivityStack stack = task != null ? task.getStack() : null;
+ if (stack != null && stack.isHomeOrRecentsStack()) {
+ // Never persist the home or recents stack.
+ return;
+ }
+ syncPersistentTaskIdsLocked();
+ mTaskPersister.wakeup(task, flush);
+ }
+
+ private void syncPersistentTaskIdsLocked() {
+ for (int i = mPersistedTaskIds.size() - 1; i >= 0; i--) {
+ int userId = mPersistedTaskIds.keyAt(i);
+ if (mUsersWithRecentsLoaded.get(userId)) {
+ // Recents are loaded only after task ids are loaded. Therefore, the set of taskids
+ // referenced here should not be null.
+ mPersistedTaskIds.valueAt(i).clear();
+ }
+ }
+ for (int i = mTasks.size() - 1; i >= 0; i--) {
+ final TaskRecord task = mTasks.get(i);
+ if (shouldPersistTaskLocked(task)) {
+ // Set of persisted taskIds for task.userId should not be null here
+ // TODO Investigate why it can happen. For now initialize with an empty set
+ if (mPersistedTaskIds.get(task.userId) == null) {
+ Slog.wtf(TAG, "No task ids found for userId " + task.userId + ". task=" + task
+ + " mPersistedTaskIds=" + mPersistedTaskIds);
+ mPersistedTaskIds.put(task.userId, new SparseBooleanArray());
+ }
+ mPersistedTaskIds.get(task.userId).put(task.taskId, true);
+ }
+ }
+ }
+
+ private static boolean shouldPersistTaskLocked(TaskRecord task) {
+ final ActivityStack stack = task.getStack();
+ return task.isPersistable && (stack == null || !stack.isHomeOrRecentsStack());
+ }
+
+ void onSystemReadyLocked() {
+ loadRecentsComponent(mService.mContext.getResources());
+ mTasks.clear();
+ mTaskPersister.onSystemReady();
+ }
+
+ Bitmap getTaskDescriptionIcon(String path) {
+ return mTaskPersister.getTaskDescriptionIcon(path);
+ }
+
+ void saveImage(Bitmap image, String path) {
+ mTaskPersister.saveImage(image, path);
+ }
+
+ void flush() {
+ synchronized (mService.mGlobalLock) {
+ syncPersistentTaskIdsLocked();
+ }
+ mTaskPersister.flush();
+ }
+
+ /**
+ * Returns all userIds for which recents from persistent storage are loaded into this list.
+ *
+ * @return an array of userIds.
+ */
+ int[] usersWithRecentsLoadedLocked() {
+ int[] usersWithRecentsLoaded = new int[mUsersWithRecentsLoaded.size()];
+ int len = 0;
+ for (int i = 0; i < usersWithRecentsLoaded.length; i++) {
+ int userId = mUsersWithRecentsLoaded.keyAt(i);
+ if (mUsersWithRecentsLoaded.valueAt(i)) {
+ usersWithRecentsLoaded[len++] = userId;
+ }
+ }
+ if (len < usersWithRecentsLoaded.length) {
+ // should never happen.
+ return Arrays.copyOf(usersWithRecentsLoaded, len);
+ }
+ return usersWithRecentsLoaded;
+ }
+
+ /**
+ * Removes recent tasks and any other state kept in memory for the passed in user. Does not
+ * touch the information present on persistent storage.
+ *
+ * @param userId the id of the user
+ */
+ void unloadUserDataFromMemoryLocked(int userId) {
+ if (mUsersWithRecentsLoaded.get(userId)) {
+ Slog.i(TAG, "Unloading recents for user " + userId + " from memory.");
+ mUsersWithRecentsLoaded.delete(userId);
+ removeTasksForUserLocked(userId);
+ }
+ mPersistedTaskIds.delete(userId);
+ mTaskPersister.unloadUserDataFromMemory(userId);
+ }
+
+ /** Remove recent tasks for a user. */
+ private void removeTasksForUserLocked(int userId) {
+ if(userId <= 0) {
+ Slog.i(TAG, "Can't remove recent task on user " + userId);
+ return;
+ }
+
+ for (int i = mTasks.size() - 1; i >= 0; --i) {
+ TaskRecord tr = mTasks.get(i);
+ if (tr.userId == userId) {
+ if(DEBUG_TASKS) Slog.i(TAG_TASKS,
+ "remove RecentTask " + tr + " when finishing user" + userId);
+ remove(tr);
+ }
+ }
+ }
+
+ void onPackagesSuspendedChanged(String[] packages, boolean suspended, int userId) {
+ final Set<String> packageNames = Sets.newHashSet(packages);
+ for (int i = mTasks.size() - 1; i >= 0; --i) {
+ final TaskRecord tr = mTasks.get(i);
+ if (tr.realActivity != null
+ && packageNames.contains(tr.realActivity.getPackageName())
+ && tr.userId == userId
+ && tr.realActivitySuspended != suspended) {
+ tr.realActivitySuspended = suspended;
+ if (suspended) {
+ mSupervisor.removeTaskByIdLocked(tr.taskId, false,
+ REMOVE_FROM_RECENTS, "suspended-package");
+ }
+ notifyTaskPersisterLocked(tr, false);
+ }
+ }
+ }
+
+ void onLockTaskModeStateChanged(int lockTaskModeState, int userId) {
+ if (lockTaskModeState != ActivityManager.LOCK_TASK_MODE_LOCKED) {
+ return;
+ }
+ for (int i = mTasks.size() - 1; i >= 0; --i) {
+ final TaskRecord tr = mTasks.get(i);
+ if (tr.userId == userId && !mService.getLockTaskController().isTaskWhitelisted(tr)) {
+ remove(tr);
+ }
+ }
+ }
+
+ void removeTasksByPackageName(String packageName, int userId) {
+ for (int i = mTasks.size() - 1; i >= 0; --i) {
+ final TaskRecord tr = mTasks.get(i);
+ final String taskPackageName =
+ tr.getBaseIntent().getComponent().getPackageName();
+ if (tr.userId != userId) continue;
+ if (!taskPackageName.equals(packageName)) continue;
+
+ mSupervisor.removeTaskByIdLocked(tr.taskId, true, REMOVE_FROM_RECENTS,
+ "remove-package-task");
+ }
+ }
+
+ void removeAllVisibleTasks() {
+ for (int i = mTasks.size() - 1; i >= 0; --i) {
+ final TaskRecord tr = mTasks.get(i);
+ if (isVisibleRecentTask(tr)) {
+ mTasks.remove(i);
+ notifyTaskRemoved(tr, true /* wasTrimmed */, true /* killProcess */);
+ }
+ }
+ }
+
+ void cleanupDisabledPackageTasksLocked(String packageName, Set<String> filterByClasses,
+ int userId) {
+ for (int i = mTasks.size() - 1; i >= 0; --i) {
+ final TaskRecord tr = mTasks.get(i);
+ if (userId != UserHandle.USER_ALL && tr.userId != userId) {
+ continue;
+ }
+
+ ComponentName cn = tr.intent != null ? tr.intent.getComponent() : null;
+ final boolean sameComponent = cn != null && cn.getPackageName().equals(packageName)
+ && (filterByClasses == null || filterByClasses.contains(cn.getClassName()));
+ if (sameComponent) {
+ mSupervisor.removeTaskByIdLocked(tr.taskId, false,
+ REMOVE_FROM_RECENTS, "disabled-package");
+ }
+ }
+ }
+
+ /**
+ * Update the recent tasks lists: make sure tasks should still be here (their
+ * applications / activities still exist), update their availability, fix-up ordering
+ * of affiliations.
+ */
+ void cleanupLocked(int userId) {
+ int recentsCount = mTasks.size();
+ if (recentsCount == 0) {
+ // Happens when called from the packagemanager broadcast before boot,
+ // or just any empty list.
+ return;
+ }
+
+ // Clear the temp lists
+ mTmpAvailActCache.clear();
+ mTmpAvailAppCache.clear();
+
+ final IPackageManager pm = AppGlobals.getPackageManager();
+ for (int i = recentsCount - 1; i >= 0; i--) {
+ final TaskRecord task = mTasks.get(i);
+ if (userId != UserHandle.USER_ALL && task.userId != userId) {
+ // Only look at tasks for the user ID of interest.
+ continue;
+ }
+ if (task.autoRemoveRecents && task.getTopActivity() == null) {
+ // This situation is broken, and we should just get rid of it now.
+ remove(task);
+ Slog.w(TAG, "Removing auto-remove without activity: " + task);
+ continue;
+ }
+ // Check whether this activity is currently available.
+ if (task.realActivity != null) {
+ ActivityInfo ai = mTmpAvailActCache.get(task.realActivity);
+ if (ai == null) {
+ try {
+ // At this first cut, we're only interested in
+ // activities that are fully runnable based on
+ // current system state.
+ ai = pm.getActivityInfo(task.realActivity,
+ PackageManager.MATCH_DEBUG_TRIAGED_MISSING
+ | ActivityManagerService.STOCK_PM_FLAGS, userId);
+ } catch (RemoteException e) {
+ // Will never happen.
+ continue;
+ }
+ if (ai == null) {
+ ai = NO_ACTIVITY_INFO_TOKEN;
+ }
+ mTmpAvailActCache.put(task.realActivity, ai);
+ }
+ if (ai == NO_ACTIVITY_INFO_TOKEN) {
+ // This could be either because the activity no longer exists, or the
+ // app is temporarily gone. For the former we want to remove the recents
+ // entry; for the latter we want to mark it as unavailable.
+ ApplicationInfo app = mTmpAvailAppCache
+ .get(task.realActivity.getPackageName());
+ if (app == null) {
+ try {
+ app = pm.getApplicationInfo(task.realActivity.getPackageName(),
+ PackageManager.MATCH_UNINSTALLED_PACKAGES, userId);
+ } catch (RemoteException e) {
+ // Will never happen.
+ continue;
+ }
+ if (app == null) {
+ app = NO_APPLICATION_INFO_TOKEN;
+ }
+ mTmpAvailAppCache.put(task.realActivity.getPackageName(), app);
+ }
+ if (app == NO_APPLICATION_INFO_TOKEN
+ || (app.flags & ApplicationInfo.FLAG_INSTALLED) == 0) {
+ // Doesn't exist any more! Good-bye.
+ remove(task);
+ Slog.w(TAG, "Removing no longer valid recent: " + task);
+ continue;
+ } else {
+ // Otherwise just not available for now.
+ if (DEBUG_RECENTS && task.isAvailable) Slog.d(TAG_RECENTS,
+ "Making recent unavailable: " + task);
+ task.isAvailable = false;
+ }
+ } else {
+ if (!ai.enabled || !ai.applicationInfo.enabled
+ || (ai.applicationInfo.flags
+ & ApplicationInfo.FLAG_INSTALLED) == 0) {
+ if (DEBUG_RECENTS && task.isAvailable) Slog.d(TAG_RECENTS,
+ "Making recent unavailable: " + task
+ + " (enabled=" + ai.enabled + "/"
+ + ai.applicationInfo.enabled
+ + " flags="
+ + Integer.toHexString(ai.applicationInfo.flags)
+ + ")");
+ task.isAvailable = false;
+ } else {
+ if (DEBUG_RECENTS && !task.isAvailable) Slog.d(TAG_RECENTS,
+ "Making recent available: " + task);
+ task.isAvailable = true;
+ }
+ }
+ }
+ }
+
+ // Verify the affiliate chain for each task.
+ int i = 0;
+ recentsCount = mTasks.size();
+ while (i < recentsCount) {
+ i = processNextAffiliateChainLocked(i);
+ }
+ // recent tasks are now in sorted, affiliated order.
+ }
+
+ /**
+ * @return whether the given {@param task} can be added to the list without causing another
+ * task to be trimmed as a result of that add.
+ */
+ private boolean canAddTaskWithoutTrim(TaskRecord task) {
+ return findRemoveIndexForAddTask(task) == -1;
+ }
+
+ /**
+ * Returns the list of {@link ActivityManager.AppTask}s.
+ */
+ ArrayList<IBinder> getAppTasksList(int callingUid, String callingPackage) {
+ final ArrayList<IBinder> list = new ArrayList<>();
+ final int size = mTasks.size();
+ for (int i = 0; i < size; i++) {
+ final TaskRecord tr = mTasks.get(i);
+ // Skip tasks that do not match the caller. We don't need to verify
+ // callingPackage, because we are also limiting to callingUid and know
+ // that will limit to the correct security sandbox.
+ if (tr.effectiveUid != callingUid) {
+ continue;
+ }
+ Intent intent = tr.getBaseIntent();
+ if (intent == null || !callingPackage.equals(intent.getComponent().getPackageName())) {
+ continue;
+ }
+ AppTaskImpl taskImpl = new AppTaskImpl(mService, tr.taskId, callingUid);
+ list.add(taskImpl.asBinder());
+ }
+ return list;
+ }
+
+ @VisibleForTesting
+ Set<Integer> getProfileIds(int userId) {
+ Set<Integer> userIds = new ArraySet<>();
+ final List<UserInfo> profiles = mService.getUserManager().getProfiles(userId,
+ false /* enabledOnly */);
+ for (int i = profiles.size() - 1; i >= 0; --i) {
+ userIds.add(profiles.get(i).id);
+ }
+ return userIds;
+ }
+
+ @VisibleForTesting
+ UserInfo getUserInfo(int userId) {
+ return mService.getUserManager().getUserInfo(userId);
+ }
+
+ @VisibleForTesting
+ int[] getCurrentProfileIds() {
+ return mService.mAmInternal.getCurrentProfileIds();
+ }
+
+ /**
+ * @return the list of recent tasks for presentation.
+ */
+ ParceledListSlice<ActivityManager.RecentTaskInfo> getRecentTasks(int maxNum, int flags,
+ boolean getTasksAllowed, boolean getDetailedTasks, int userId, int callingUid) {
+ return new ParceledListSlice<>(getRecentTasksImpl(maxNum, flags, getTasksAllowed,
+ getDetailedTasks, userId, callingUid));
+ }
+
+
+ /**
+ * @return the list of recent tasks for presentation.
+ */
+ ArrayList<ActivityManager.RecentTaskInfo> getRecentTasksImpl(int maxNum, int flags,
+ boolean getTasksAllowed, boolean getDetailedTasks, int userId, int callingUid) {
+ final boolean withExcluded = (flags & RECENT_WITH_EXCLUDED) != 0;
+
+ if (!mService.mAmInternal.isUserRunning(userId, FLAG_AND_UNLOCKED)) {
+ Slog.i(TAG, "user " + userId + " is still locked. Cannot load recents");
+ return new ArrayList<>();
+ }
+ loadUserRecentsLocked(userId);
+
+ final Set<Integer> includedUsers = getProfileIds(userId);
+ includedUsers.add(Integer.valueOf(userId));
+
+ final ArrayList<ActivityManager.RecentTaskInfo> res = new ArrayList<>();
+ final int size = mTasks.size();
+ int numVisibleTasks = 0;
+ for (int i = 0; i < size; i++) {
+ final TaskRecord tr = mTasks.get(i);
+
+ if (isVisibleRecentTask(tr)) {
+ numVisibleTasks++;
+ if (isInVisibleRange(tr, numVisibleTasks)) {
+ // Fall through
+ } else {
+ // Not in visible range
+ continue;
+ }
+ } else {
+ // Not visible
+ continue;
+ }
+
+ // Skip remaining tasks once we reach the requested size
+ if (res.size() >= maxNum) {
+ continue;
+ }
+
+ // Only add calling user or related users recent tasks
+ if (!includedUsers.contains(Integer.valueOf(tr.userId))) {
+ if (DEBUG_RECENTS) Slog.d(TAG_RECENTS, "Skipping, not user: " + tr);
+ continue;
+ }
+
+ if (tr.realActivitySuspended) {
+ if (DEBUG_RECENTS) Slog.d(TAG_RECENTS, "Skipping, activity suspended: " + tr);
+ continue;
+ }
+
+ // Return the entry if desired by the caller. We always return
+ // the first entry, because callers always expect this to be the
+ // foreground app. We may filter others if the caller has
+ // not supplied RECENT_WITH_EXCLUDED and there is some reason
+ // we should exclude the entry.
+
+ if (i == 0
+ || withExcluded
+ || (tr.intent == null)
+ || ((tr.intent.getFlags() & FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS)
+ == 0)) {
+ if (!getTasksAllowed) {
+ // If the caller doesn't have the GET_TASKS permission, then only
+ // allow them to see a small subset of tasks -- their own and home.
+ if (!tr.isActivityTypeHome() && tr.effectiveUid != callingUid) {
+ if (DEBUG_RECENTS) Slog.d(TAG_RECENTS, "Skipping, not allowed: " + tr);
+ continue;
+ }
+ }
+ if (tr.autoRemoveRecents && tr.getTopActivity() == null) {
+ // Don't include auto remove tasks that are finished or finishing.
+ if (DEBUG_RECENTS) Slog.d(TAG_RECENTS,
+ "Skipping, auto-remove without activity: " + tr);
+ continue;
+ }
+ if ((flags & RECENT_IGNORE_UNAVAILABLE) != 0 && !tr.isAvailable) {
+ if (DEBUG_RECENTS) Slog.d(TAG_RECENTS,
+ "Skipping, unavail real act: " + tr);
+ continue;
+ }
+
+ if (!tr.mUserSetupComplete) {
+ // Don't include task launched while user is not done setting-up.
+ if (DEBUG_RECENTS) Slog.d(TAG_RECENTS,
+ "Skipping, user setup not complete: " + tr);
+ continue;
+ }
+
+ final ActivityManager.RecentTaskInfo rti = createRecentTaskInfo(tr);
+ if (!getDetailedTasks) {
+ rti.baseIntent.replaceExtras((Bundle)null);
+ }
+
+ res.add(rti);
+ }
+ }
+ return res;
+ }
+
+ /**
+ * @return the list of persistable task ids.
+ */
+ void getPersistableTaskIds(ArraySet<Integer> persistentTaskIds) {
+ final int size = mTasks.size();
+ for (int i = 0; i < size; i++) {
+ final TaskRecord task = mTasks.get(i);
+ if (TaskPersister.DEBUG) Slog.d(TAG, "LazyTaskWriter: task=" + task
+ + " persistable=" + task.isPersistable);
+ final ActivityStack stack = task.getStack();
+ if ((task.isPersistable || task.inRecents)
+ && (stack == null || !stack.isHomeOrRecentsStack())) {
+ if (TaskPersister.DEBUG) Slog.d(TAG, "adding to persistentTaskIds task=" + task);
+ persistentTaskIds.add(task.taskId);
+ } else {
+ if (TaskPersister.DEBUG) Slog.d(TAG, "omitting from persistentTaskIds task="
+ + task);
+ }
+ }
+ }
+
+ @VisibleForTesting
+ ArrayList<TaskRecord> getRawTasks() {
+ return mTasks;
+ }
+
+ /**
+ * @return ids of tasks that are presented in Recents UI.
+ */
+ SparseBooleanArray getRecentTaskIds() {
+ final SparseBooleanArray res = new SparseBooleanArray();
+ final int size = mTasks.size();
+ int numVisibleTasks = 0;
+ for (int i = 0; i < size; i++) {
+ final TaskRecord tr = mTasks.get(i);
+ if (isVisibleRecentTask(tr)) {
+ numVisibleTasks++;
+ if (isInVisibleRange(tr, numVisibleTasks)) {
+ res.put(tr.taskId, true);
+ }
+ }
+ }
+ return res;
+ }
+
+ /**
+ * @return the task in the task list with the given {@param id} if one exists.
+ */
+ TaskRecord getTask(int id) {
+ final int recentsCount = mTasks.size();
+ for (int i = 0; i < recentsCount; i++) {
+ TaskRecord tr = mTasks.get(i);
+ if (tr.taskId == id) {
+ return tr;
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Add a new task to the recent tasks list.
+ */
+ void add(TaskRecord task) {
+ if (DEBUG_RECENTS_TRIM_TASKS) Slog.d(TAG, "add: task=" + task);
+
+ final boolean isAffiliated = task.mAffiliatedTaskId != task.taskId
+ || task.mNextAffiliateTaskId != INVALID_TASK_ID
+ || task.mPrevAffiliateTaskId != INVALID_TASK_ID;
+
+ int recentsCount = mTasks.size();
+ // Quick case: never add voice sessions.
+ // TODO: VI what about if it's just an activity?
+ // Probably nothing to do here
+ if (task.voiceSession != null) {
+ if (DEBUG_RECENTS) Slog.d(TAG_RECENTS,
+ "addRecent: not adding voice interaction " + task);
+ return;
+ }
+ // Another quick case: check if the top-most recent task is the same.
+ if (!isAffiliated && recentsCount > 0 && mTasks.get(0) == task) {
+ if (DEBUG_RECENTS) Slog.d(TAG_RECENTS, "addRecent: already at top: " + task);
+ return;
+ }
+ // Another quick case: check if this is part of a set of affiliated
+ // tasks that are at the top.
+ if (isAffiliated && recentsCount > 0 && task.inRecents
+ && task.mAffiliatedTaskId == mTasks.get(0).mAffiliatedTaskId) {
+ if (DEBUG_RECENTS) Slog.d(TAG_RECENTS, "addRecent: affiliated " + mTasks.get(0)
+ + " at top when adding " + task);
+ return;
+ }
+
+ boolean needAffiliationFix = false;
+
+ // Slightly less quick case: the task is already in recents, so all we need
+ // to do is move it.
+ if (task.inRecents) {
+ int taskIndex = mTasks.indexOf(task);
+ if (taskIndex >= 0) {
+ if (!isAffiliated || !MOVE_AFFILIATED_TASKS_TO_FRONT) {
+ // Simple case: this is not an affiliated task, so we just move it to the front.
+ mTasks.remove(taskIndex);
+ mTasks.add(0, task);
+ notifyTaskPersisterLocked(task, false);
+ if (DEBUG_RECENTS) Slog.d(TAG_RECENTS, "addRecent: moving to top " + task
+ + " from " + taskIndex);
+ return;
+ } else {
+ // More complicated: need to keep all affiliated tasks together.
+ if (moveAffiliatedTasksToFront(task, taskIndex)) {
+ // All went well.
+ return;
+ }
+
+ // Uh oh... something bad in the affiliation chain, try to rebuild
+ // everything and then go through our general path of adding a new task.
+ needAffiliationFix = true;
+ }
+ } else {
+ Slog.wtf(TAG, "Task with inRecent not in recents: " + task);
+ needAffiliationFix = true;
+ }
+ }
+
+ if (DEBUG_RECENTS) Slog.d(TAG_RECENTS, "addRecent: trimming tasks for " + task);
+ removeForAddTask(task);
+
+ task.inRecents = true;
+ if (!isAffiliated || needAffiliationFix) {
+ // If this is a simple non-affiliated task, or we had some failure trying to
+ // handle it as part of an affilated task, then just place it at the top.
+ mTasks.add(0, task);
+ notifyTaskAdded(task);
+ if (DEBUG_RECENTS) Slog.d(TAG_RECENTS, "addRecent: adding " + task);
+ } else if (isAffiliated) {
+ // If this is a new affiliated task, then move all of the affiliated tasks
+ // to the front and insert this new one.
+ TaskRecord other = task.mNextAffiliate;
+ if (other == null) {
+ other = task.mPrevAffiliate;
+ }
+ if (other != null) {
+ int otherIndex = mTasks.indexOf(other);
+ if (otherIndex >= 0) {
+ // Insert new task at appropriate location.
+ int taskIndex;
+ if (other == task.mNextAffiliate) {
+ // We found the index of our next affiliation, which is who is
+ // before us in the list, so add after that point.
+ taskIndex = otherIndex+1;
+ } else {
+ // We found the index of our previous affiliation, which is who is
+ // after us in the list, so add at their position.
+ taskIndex = otherIndex;
+ }
+ if (DEBUG_RECENTS) Slog.d(TAG_RECENTS,
+ "addRecent: new affiliated task added at " + taskIndex + ": " + task);
+ mTasks.add(taskIndex, task);
+ notifyTaskAdded(task);
+
+ // Now move everything to the front.
+ if (moveAffiliatedTasksToFront(task, taskIndex)) {
+ // All went well.
+ return;
+ }
+
+ // Uh oh... something bad in the affiliation chain, try to rebuild
+ // everything and then go through our general path of adding a new task.
+ needAffiliationFix = true;
+ } else {
+ if (DEBUG_RECENTS) Slog.d(TAG_RECENTS,
+ "addRecent: couldn't find other affiliation " + other);
+ needAffiliationFix = true;
+ }
+ } else {
+ if (DEBUG_RECENTS) Slog.d(TAG_RECENTS,
+ "addRecent: adding affiliated task without next/prev:" + task);
+ needAffiliationFix = true;
+ }
+ }
+
+ if (needAffiliationFix) {
+ if (DEBUG_RECENTS) Slog.d(TAG_RECENTS, "addRecent: regrouping affiliations");
+ cleanupLocked(task.userId);
+ }
+
+ // Trim the set of tasks to the active set
+ trimInactiveRecentTasks();
+ }
+
+ /**
+ * Add the task to the bottom if possible.
+ */
+ boolean addToBottom(TaskRecord task) {
+ if (!canAddTaskWithoutTrim(task)) {
+ // Adding this task would cause the task to be removed (since it's appended at
+ // the bottom and would be trimmed) so just return now
+ return false;
+ }
+
+ add(task);
+ return true;
+ }
+
+ /**
+ * Remove a task from the recent tasks list.
+ */
+ void remove(TaskRecord task) {
+ mTasks.remove(task);
+ notifyTaskRemoved(task, false /* wasTrimmed */, false /* killProcess */);
+ }
+
+ /**
+ * Trims the recents task list to the global max number of recents.
+ */
+ private void trimInactiveRecentTasks() {
+ int recentsCount = mTasks.size();
+
+ // Remove from the end of the list until we reach the max number of recents
+ while (recentsCount > mGlobalMaxNumTasks) {
+ final TaskRecord tr = mTasks.remove(recentsCount - 1);
+ notifyTaskRemoved(tr, true /* wasTrimmed */, false /* killProcess */);
+ recentsCount--;
+ if (DEBUG_RECENTS_TRIM_TASKS) Slog.d(TAG, "Trimming over max-recents task=" + tr
+ + " max=" + mGlobalMaxNumTasks);
+ }
+
+ // Remove any tasks that belong to currently quiet profiles
+ final int[] profileUserIds = getCurrentProfileIds();
+ mTmpQuietProfileUserIds.clear();
+ for (int userId : profileUserIds) {
+ final UserInfo userInfo = getUserInfo(userId);
+ if (userInfo != null && userInfo.isManagedProfile() && userInfo.isQuietModeEnabled()) {
+ mTmpQuietProfileUserIds.put(userId, true);
+ }
+ if (DEBUG_RECENTS_TRIM_TASKS) Slog.d(TAG, "User: " + userInfo
+ + " quiet=" + mTmpQuietProfileUserIds.get(userId));
+ }
+
+ // Remove any inactive tasks, calculate the latest set of visible tasks
+ int numVisibleTasks = 0;
+ for (int i = 0; i < mTasks.size();) {
+ final TaskRecord task = mTasks.get(i);
+
+ if (isActiveRecentTask(task, mTmpQuietProfileUserIds)) {
+ if (!mHasVisibleRecentTasks) {
+ // Keep all active tasks if visible recent tasks is not supported
+ i++;
+ continue;
+ }
+
+ if (!isVisibleRecentTask(task)) {
+ // Keep all active-but-invisible tasks
+ i++;
+ continue;
+ } else {
+ numVisibleTasks++;
+ if (isInVisibleRange(task, numVisibleTasks) || !isTrimmable(task)) {
+ // Keep visible tasks in range
+ i++;
+ continue;
+ } else {
+ // Fall through to trim visible tasks that are no longer in range and
+ // trimmable
+ if (DEBUG_RECENTS_TRIM_TASKS) Slog.d(TAG,
+ "Trimming out-of-range visible task=" + task);
+ }
+ }
+ } else {
+ // Fall through to trim inactive tasks
+ if (DEBUG_RECENTS_TRIM_TASKS) Slog.d(TAG, "Trimming inactive task=" + task);
+ }
+
+ // Task is no longer active, trim it from the list
+ mTasks.remove(task);
+ notifyTaskRemoved(task, true /* wasTrimmed */, false /* killProcess */);
+ notifyTaskPersisterLocked(task, false /* flush */);
+ }
+ }
+
+ /**
+ * @return whether the given task should be considered active.
+ */
+ private boolean isActiveRecentTask(TaskRecord task, SparseBooleanArray quietProfileUserIds) {
+ if (DEBUG_RECENTS_TRIM_TASKS) Slog.d(TAG, "isActiveRecentTask: task=" + task
+ + " globalMax=" + mGlobalMaxNumTasks);
+
+ if (quietProfileUserIds.get(task.userId)) {
+ // Quiet profile user's tasks are never active
+ if (DEBUG_RECENTS_TRIM_TASKS) Slog.d(TAG, "\tisQuietProfileTask=true");
+ return false;
+ }
+
+ if (task.mAffiliatedTaskId != INVALID_TASK_ID && task.mAffiliatedTaskId != task.taskId) {
+ // Keep the task active if its affiliated task is also active
+ final TaskRecord affiliatedTask = getTask(task.mAffiliatedTaskId);
+ if (affiliatedTask != null) {
+ if (!isActiveRecentTask(affiliatedTask, quietProfileUserIds)) {
+ if (DEBUG_RECENTS_TRIM_TASKS) Slog.d(TAG,
+ "\taffiliatedWithTask=" + affiliatedTask + " is not active");
+ return false;
+ }
+ }
+ }
+
+ // All other tasks are considered active
+ return true;
+ }
+
+ /**
+ * @return whether the given active task should be presented to the user through SystemUI.
+ */
+ private boolean isVisibleRecentTask(TaskRecord task) {
+ if (DEBUG_RECENTS_TRIM_TASKS) Slog.d(TAG, "isVisibleRecentTask: task=" + task
+ + " minVis=" + mMinNumVisibleTasks + " maxVis=" + mMaxNumVisibleTasks
+ + " sessionDuration=" + mActiveTasksSessionDurationMs
+ + " inactiveDuration=" + task.getInactiveDuration()
+ + " activityType=" + task.getActivityType()
+ + " windowingMode=" + task.getWindowingMode()
+ + " intentFlags=" + task.getBaseIntent().getFlags());
+
+ switch (task.getActivityType()) {
+ case ACTIVITY_TYPE_HOME:
+ case ACTIVITY_TYPE_RECENTS:
+ // Ignore certain activity types completely
+ return false;
+ case ACTIVITY_TYPE_ASSISTANT:
+ // Ignore assistant that chose to be excluded from Recents, even if it's a top
+ // task.
+ if ((task.getBaseIntent().getFlags() & FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS)
+ == FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS) {
+ return false;
+ }
+ }
+
+ // Ignore certain windowing modes
+ switch (task.getWindowingMode()) {
+ case WINDOWING_MODE_PINNED:
+ return false;
+ case WINDOWING_MODE_SPLIT_SCREEN_PRIMARY:
+ if (DEBUG_RECENTS_TRIM_TASKS) Slog.d(TAG, "\ttop=" + task.getStack().topTask());
+ final ActivityStack stack = task.getStack();
+ if (stack != null && stack.topTask() == task) {
+ // Only the non-top task of the primary split screen mode is visible
+ return false;
+ }
+ }
+
+ // If we're in lock task mode, ignore the root task
+ if (task == mService.getLockTaskController().getRootTask()) {
+ return false;
+ }
+
+ return true;
+ }
+
+ /**
+ * @return whether the given visible task is within the policy range.
+ */
+ private boolean isInVisibleRange(TaskRecord task, int numVisibleTasks) {
+ // Keep the last most task even if it is excluded from recents
+ final boolean isExcludeFromRecents =
+ (task.getBaseIntent().getFlags() & FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS)
+ == FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS;
+ if (isExcludeFromRecents) {
+ if (DEBUG_RECENTS_TRIM_TASKS) Slog.d(TAG, "\texcludeFromRecents=true");
+ return numVisibleTasks == 1;
+ }
+
+ if (mMinNumVisibleTasks >= 0 && numVisibleTasks <= mMinNumVisibleTasks) {
+ // Always keep up to the min number of recent tasks, after that fall through to the
+ // checks below
+ return true;
+ }
+
+ if (mMaxNumVisibleTasks >= 0) {
+ // Always keep up to the max number of recent tasks, but return false afterwards
+ return numVisibleTasks <= mMaxNumVisibleTasks;
+ }
+
+ if (mActiveTasksSessionDurationMs > 0) {
+ // Keep the task if the inactive time is within the session window, this check must come
+ // after the checks for the min/max visible task range
+ if (task.getInactiveDuration() <= mActiveTasksSessionDurationMs) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ /**
+ * @return whether the given task can be trimmed even if it is outside the visible range.
+ */
+ protected boolean isTrimmable(TaskRecord task) {
+ final ActivityStack stack = task.getStack();
+
+ // No stack for task, just trim it
+ if (stack == null) {
+ return true;
+ }
+
+ // Ignore tasks from different displays
+ // TODO (b/115289124): No Recents on non-default displays.
+ if (stack.mDisplayId != DEFAULT_DISPLAY) {
+ return false;
+ }
+
+ // Trim tasks that are in stacks that are behind the home stack
+ final ActivityDisplay display = stack.getDisplay();
+ return display.getIndexOf(stack) < display.getIndexOf(display.getHomeStack());
+ }
+
+ /**
+ * If needed, remove oldest existing entries in recents that are for the same kind
+ * of task as the given one.
+ */
+ private void removeForAddTask(TaskRecord task) {
+ final int removeIndex = findRemoveIndexForAddTask(task);
+ if (removeIndex == -1) {
+ // Nothing to trim
+ return;
+ }
+
+ // There is a similar task that will be removed for the addition of {@param task}, but it
+ // can be the same task, and if so, the task will be re-added in add(), so skip the
+ // callbacks here.
+ final TaskRecord removedTask = mTasks.remove(removeIndex);
+ if (removedTask != task) {
+ notifyTaskRemoved(removedTask, false /* wasTrimmed */, false /* killProcess */);
+ if (DEBUG_RECENTS_TRIM_TASKS) Slog.d(TAG, "Trimming task=" + removedTask
+ + " for addition of task=" + task);
+ }
+ notifyTaskPersisterLocked(removedTask, false /* flush */);
+ }
+
+ /**
+ * Find the task that would be removed if the given {@param task} is added to the recent tasks
+ * list (if any).
+ */
+ private int findRemoveIndexForAddTask(TaskRecord task) {
+ final int recentsCount = mTasks.size();
+ final Intent intent = task.intent;
+ final boolean document = intent != null && intent.isDocument();
+ int maxRecents = task.maxRecents - 1;
+ for (int i = 0; i < recentsCount; i++) {
+ final TaskRecord tr = mTasks.get(i);
+ if (task != tr) {
+ if (!hasCompatibleActivityTypeAndWindowingMode(task, tr)
+ || task.userId != tr.userId) {
+ continue;
+ }
+ final Intent trIntent = tr.intent;
+ final boolean sameAffinity =
+ task.affinity != null && task.affinity.equals(tr.affinity);
+ final boolean sameIntent = intent != null && intent.filterEquals(trIntent);
+ boolean multiTasksAllowed = false;
+ final int flags = intent.getFlags();
+ if ((flags & (FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_NEW_DOCUMENT)) != 0
+ && (flags & FLAG_ACTIVITY_MULTIPLE_TASK) != 0) {
+ multiTasksAllowed = true;
+ }
+ final boolean trIsDocument = trIntent != null && trIntent.isDocument();
+ final boolean bothDocuments = document && trIsDocument;
+ if (!sameAffinity && !sameIntent && !bothDocuments) {
+ continue;
+ }
+
+ if (bothDocuments) {
+ // Do these documents belong to the same activity?
+ final boolean sameActivity = task.realActivity != null
+ && tr.realActivity != null
+ && task.realActivity.equals(tr.realActivity);
+ if (!sameActivity) {
+ // If the document is open in another app or is not the same document, we
+ // don't need to trim it.
+ continue;
+ } else if (maxRecents > 0) {
+ --maxRecents;
+ if (!sameIntent || multiTasksAllowed) {
+ // We don't want to trim if we are not over the max allowed entries and
+ // the tasks are not of the same intent filter, or multiple entries for
+ // the task is allowed.
+ continue;
+ }
+ }
+ // Hit the maximum number of documents for this task. Fall through
+ // and remove this document from recents.
+ } else if (document || trIsDocument) {
+ // Only one of these is a document. Not the droid we're looking for.
+ continue;
+ }
+ }
+ return i;
+ }
+ return -1;
+ }
+
+ // Extract the affiliates of the chain containing recent at index start.
+ private int processNextAffiliateChainLocked(int start) {
+ final TaskRecord startTask = mTasks.get(start);
+ final int affiliateId = startTask.mAffiliatedTaskId;
+
+ // Quick identification of isolated tasks. I.e. those not launched behind.
+ if (startTask.taskId == affiliateId && startTask.mPrevAffiliate == null &&
+ startTask.mNextAffiliate == null) {
+ // There is still a slim chance that there are other tasks that point to this task
+ // and that the chain is so messed up that this task no longer points to them but
+ // the gain of this optimization outweighs the risk.
+ startTask.inRecents = true;
+ return start + 1;
+ }
+
+ // Remove all tasks that are affiliated to affiliateId and put them in mTmpRecents.
+ mTmpRecents.clear();
+ for (int i = mTasks.size() - 1; i >= start; --i) {
+ final TaskRecord task = mTasks.get(i);
+ if (task.mAffiliatedTaskId == affiliateId) {
+ mTasks.remove(i);
+ mTmpRecents.add(task);
+ }
+ }
+
+ // Sort them all by taskId. That is the order they were create in and that order will
+ // always be correct.
+ Collections.sort(mTmpRecents, TASK_ID_COMPARATOR);
+
+ // Go through and fix up the linked list.
+ // The first one is the end of the chain and has no next.
+ final TaskRecord first = mTmpRecents.get(0);
+ first.inRecents = true;
+ if (first.mNextAffiliate != null) {
+ Slog.w(TAG, "Link error 1 first.next=" + first.mNextAffiliate);
+ first.setNextAffiliate(null);
+ notifyTaskPersisterLocked(first, false);
+ }
+ // Everything in the middle is doubly linked from next to prev.
+ final int tmpSize = mTmpRecents.size();
+ for (int i = 0; i < tmpSize - 1; ++i) {
+ final TaskRecord next = mTmpRecents.get(i);
+ final TaskRecord prev = mTmpRecents.get(i + 1);
+ if (next.mPrevAffiliate != prev) {
+ Slog.w(TAG, "Link error 2 next=" + next + " prev=" + next.mPrevAffiliate +
+ " setting prev=" + prev);
+ next.setPrevAffiliate(prev);
+ notifyTaskPersisterLocked(next, false);
+ }
+ if (prev.mNextAffiliate != next) {
+ Slog.w(TAG, "Link error 3 prev=" + prev + " next=" + prev.mNextAffiliate +
+ " setting next=" + next);
+ prev.setNextAffiliate(next);
+ notifyTaskPersisterLocked(prev, false);
+ }
+ prev.inRecents = true;
+ }
+ // The last one is the beginning of the list and has no prev.
+ final TaskRecord last = mTmpRecents.get(tmpSize - 1);
+ if (last.mPrevAffiliate != null) {
+ Slog.w(TAG, "Link error 4 last.prev=" + last.mPrevAffiliate);
+ last.setPrevAffiliate(null);
+ notifyTaskPersisterLocked(last, false);
+ }
+
+ // Insert the group back into mTmpTasks at start.
+ mTasks.addAll(start, mTmpRecents);
+ mTmpRecents.clear();
+
+ // Let the caller know where we left off.
+ return start + tmpSize;
+ }
+
+ private boolean moveAffiliatedTasksToFront(TaskRecord task, int taskIndex) {
+ int recentsCount = mTasks.size();
+ TaskRecord top = task;
+ int topIndex = taskIndex;
+ while (top.mNextAffiliate != null && topIndex > 0) {
+ top = top.mNextAffiliate;
+ topIndex--;
+ }
+ if (DEBUG_RECENTS) Slog.d(TAG_RECENTS, "addRecent: adding affilliates starting at "
+ + topIndex + " from intial " + taskIndex);
+ // Find the end of the chain, doing a sanity check along the way.
+ boolean sane = top.mAffiliatedTaskId == task.mAffiliatedTaskId;
+ int endIndex = topIndex;
+ TaskRecord prev = top;
+ while (endIndex < recentsCount) {
+ TaskRecord cur = mTasks.get(endIndex);
+ if (DEBUG_RECENTS) Slog.d(TAG_RECENTS, "addRecent: looking at next chain @"
+ + endIndex + " " + cur);
+ if (cur == top) {
+ // Verify start of the chain.
+ if (cur.mNextAffiliate != null || cur.mNextAffiliateTaskId != INVALID_TASK_ID) {
+ Slog.wtf(TAG, "Bad chain @" + endIndex
+ + ": first task has next affiliate: " + prev);
+ sane = false;
+ break;
+ }
+ } else {
+ // Verify middle of the chain's next points back to the one before.
+ if (cur.mNextAffiliate != prev
+ || cur.mNextAffiliateTaskId != prev.taskId) {
+ Slog.wtf(TAG, "Bad chain @" + endIndex
+ + ": middle task " + cur + " @" + endIndex
+ + " has bad next affiliate "
+ + cur.mNextAffiliate + " id " + cur.mNextAffiliateTaskId
+ + ", expected " + prev);
+ sane = false;
+ break;
+ }
+ }
+ if (cur.mPrevAffiliateTaskId == INVALID_TASK_ID) {
+ // Chain ends here.
+ if (cur.mPrevAffiliate != null) {
+ Slog.wtf(TAG, "Bad chain @" + endIndex
+ + ": last task " + cur + " has previous affiliate "
+ + cur.mPrevAffiliate);
+ sane = false;
+ }
+ if (DEBUG_RECENTS) Slog.d(TAG_RECENTS, "addRecent: end of chain @" + endIndex);
+ break;
+ } else {
+ // Verify middle of the chain's prev points to a valid item.
+ if (cur.mPrevAffiliate == null) {
+ Slog.wtf(TAG, "Bad chain @" + endIndex
+ + ": task " + cur + " has previous affiliate "
+ + cur.mPrevAffiliate + " but should be id "
+ + cur.mPrevAffiliate);
+ sane = false;
+ break;
+ }
+ }
+ if (cur.mAffiliatedTaskId != task.mAffiliatedTaskId) {
+ Slog.wtf(TAG, "Bad chain @" + endIndex
+ + ": task " + cur + " has affiliated id "
+ + cur.mAffiliatedTaskId + " but should be "
+ + task.mAffiliatedTaskId);
+ sane = false;
+ break;
+ }
+ prev = cur;
+ endIndex++;
+ if (endIndex >= recentsCount) {
+ Slog.wtf(TAG, "Bad chain ran off index " + endIndex
+ + ": last task " + prev);
+ sane = false;
+ break;
+ }
+ }
+ if (sane) {
+ if (endIndex < taskIndex) {
+ Slog.wtf(TAG, "Bad chain @" + endIndex
+ + ": did not extend to task " + task + " @" + taskIndex);
+ sane = false;
+ }
+ }
+ if (sane) {
+ // All looks good, we can just move all of the affiliated tasks
+ // to the top.
+ for (int i=topIndex; i<=endIndex; i++) {
+ if (DEBUG_RECENTS) Slog.d(TAG_RECENTS, "addRecent: moving affiliated " + task
+ + " from " + i + " to " + (i-topIndex));
+ TaskRecord cur = mTasks.remove(i);
+ mTasks.add(i - topIndex, cur);
+ }
+ if (DEBUG_RECENTS) Slog.d(TAG_RECENTS, "addRecent: done moving tasks " + topIndex
+ + " to " + endIndex);
+ return true;
+ }
+
+ // Whoops, couldn't do it.
+ return false;
+ }
+
+ void dump(PrintWriter pw, boolean dumpAll, String dumpPackage) {
+ pw.println("ACTIVITY MANAGER RECENT TASKS (dumpsys activity recents)");
+ pw.println("mRecentsUid=" + mRecentsUid);
+ pw.println("mRecentsComponent=" + mRecentsComponent);
+ if (mTasks.isEmpty()) {
+ return;
+ }
+
+ // Dump raw recent task list
+ boolean printedAnything = false;
+ boolean printedHeader = false;
+ final int size = mTasks.size();
+ for (int i = 0; i < size; i++) {
+ final TaskRecord tr = mTasks.get(i);
+ if (dumpPackage != null && (tr.realActivity == null ||
+ !dumpPackage.equals(tr.realActivity.getPackageName()))) {
+ continue;
+ }
+
+ if (!printedHeader) {
+ pw.println(" Recent tasks:");
+ printedHeader = true;
+ printedAnything = true;
+ }
+ pw.print(" * Recent #"); pw.print(i); pw.print(": ");
+ pw.println(tr);
+ if (dumpAll) {
+ tr.dump(pw, " ");
+ }
+ }
+
+ // Dump visible recent task list
+ if (mHasVisibleRecentTasks) {
+ // Reset the header flag for the next block
+ printedHeader = false;
+ ArrayList<ActivityManager.RecentTaskInfo> tasks = getRecentTasksImpl(Integer.MAX_VALUE,
+ 0, true /* getTasksAllowed */, false /* getDetailedTasks */,
+ mService.getCurrentUserId(), SYSTEM_UID);
+ for (int i = 0; i < tasks.size(); i++) {
+ final ActivityManager.RecentTaskInfo taskInfo = tasks.get(i);
+ if (!printedHeader) {
+ if (printedAnything) {
+ // Separate from the last block if it printed
+ pw.println();
+ }
+ pw.println(" Visible recent tasks (most recent first):");
+ printedHeader = true;
+ printedAnything = true;
+ }
+
+ pw.print(" * RecentTaskInfo #"); pw.print(i); pw.print(": ");
+ taskInfo.dump(pw, " ");
+ }
+ }
+
+ if (!printedAnything) {
+ pw.println(" (nothing)");
+ }
+ }
+
+ /**
+ * Creates a new RecentTaskInfo from a TaskRecord.
+ */
+ ActivityManager.RecentTaskInfo createRecentTaskInfo(TaskRecord tr) {
+ ActivityManager.RecentTaskInfo rti = new ActivityManager.RecentTaskInfo();
+ tr.fillTaskInfo(rti, mTmpReport);
+ // Fill in some deprecated values
+ rti.id = rti.isRunning ? rti.taskId : INVALID_TASK_ID;
+ rti.persistentId = rti.taskId;
+ return rti;
+ }
+
+ /**
+ * @return Whether the activity types and windowing modes of the two tasks are considered
+ * compatible. This is necessary because we currently don't persist the activity type
+ * or the windowing mode with the task, so they can be undefined when restored.
+ */
+ private boolean hasCompatibleActivityTypeAndWindowingMode(TaskRecord t1, TaskRecord t2) {
+ final int activityType = t1.getActivityType();
+ final int windowingMode = t1.getWindowingMode();
+ final boolean isUndefinedType = activityType == ACTIVITY_TYPE_UNDEFINED;
+ final boolean isUndefinedMode = windowingMode == WINDOWING_MODE_UNDEFINED;
+ final int otherActivityType = t2.getActivityType();
+ final int otherWindowingMode = t2.getWindowingMode();
+ final boolean isOtherUndefinedType = otherActivityType == ACTIVITY_TYPE_UNDEFINED;
+ final boolean isOtherUndefinedMode = otherWindowingMode == WINDOWING_MODE_UNDEFINED;
+
+ // An activity type and windowing mode is compatible if they are the exact same type/mode,
+ // or if one of the type/modes is undefined
+ final boolean isCompatibleType = activityType == otherActivityType
+ || isUndefinedType || isOtherUndefinedType;
+ final boolean isCompatibleMode = windowingMode == otherWindowingMode
+ || isUndefinedMode || isOtherUndefinedMode;
+
+ return isCompatibleType && isCompatibleMode;
+ }
+}
diff --git a/services/core/java/com/android/server/wm/RecentsAnimation.java b/services/core/java/com/android/server/wm/RecentsAnimation.java
new file mode 100644
index 0000000..7a1ebf2
--- /dev/null
+++ b/services/core/java/com/android/server/wm/RecentsAnimation.java
@@ -0,0 +1,376 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.server.wm;
+
+import static android.app.ActivityManager.START_TASK_TO_FRONT;
+import static android.app.AppOpsManager.OP_ASSIST_STRUCTURE;
+import static android.app.AppOpsManager.OP_NONE;
+import static android.app.WindowConfiguration.ACTIVITY_TYPE_HOME;
+import static android.app.WindowConfiguration.ACTIVITY_TYPE_RECENTS;
+import static android.app.WindowConfiguration.WINDOWING_MODE_UNDEFINED;
+import static android.content.Intent.FLAG_ACTIVITY_NEW_TASK;
+import static android.content.Intent.FLAG_ACTIVITY_NO_ANIMATION;
+import static android.os.Trace.TRACE_TAG_ACTIVITY_MANAGER;
+import static android.view.WindowManager.TRANSIT_NONE;
+import static com.android.server.wm.ActivityStackSupervisor.PRESERVE_WINDOWS;
+import static com.android.server.wm.RecentsAnimationController.REORDER_KEEP_IN_PLACE;
+import static com.android.server.wm.RecentsAnimationController.REORDER_MOVE_TO_ORIGINAL_POSITION;
+import static com.android.server.wm.RecentsAnimationController.REORDER_MOVE_TO_TOP;
+
+import android.app.ActivityOptions;
+import android.app.AppOpsManager;
+import android.app.IAssistDataReceiver;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.os.RemoteException;
+import android.os.Trace;
+import android.util.Slog;
+import android.view.IRecentsAnimationRunner;
+
+import com.android.server.wm.AssistDataReceiverProxy;
+import com.android.server.am.AssistDataRequester;
+import com.android.server.wm.RecentsAnimationController.RecentsAnimationCallbacks;
+
+/**
+ * Manages the recents animation, including the reordering of the stacks for the transition and
+ * cleanup. See {@link com.android.server.wm.RecentsAnimationController}.
+ */
+class RecentsAnimation implements RecentsAnimationCallbacks,
+ ActivityDisplay.OnStackOrderChangedListener {
+ private static final String TAG = RecentsAnimation.class.getSimpleName();
+ private static final boolean DEBUG = false;
+
+ private final ActivityTaskManagerService mService;
+ private final ActivityStackSupervisor mStackSupervisor;
+ private final ActivityStartController mActivityStartController;
+ private final WindowManagerService mWindowManager;
+ private final ActivityDisplay mDefaultDisplay;
+ private final int mCallingPid;
+
+ private int mTargetActivityType;
+ private AssistDataRequester mAssistDataRequester;
+
+ // The stack to restore the target stack behind when the animation is finished
+ private ActivityStack mRestoreTargetBehindStack;
+
+ RecentsAnimation(ActivityTaskManagerService atm, ActivityStackSupervisor stackSupervisor,
+ ActivityStartController activityStartController, WindowManagerService wm,
+ int callingPid) {
+ mService = atm;
+ mStackSupervisor = stackSupervisor;
+ mDefaultDisplay = stackSupervisor.getDefaultDisplay();
+ mActivityStartController = activityStartController;
+ mWindowManager = wm;
+ mCallingPid = callingPid;
+ }
+
+ void startRecentsActivity(Intent intent, IRecentsAnimationRunner recentsAnimationRunner,
+ ComponentName recentsComponent, int recentsUid,
+ IAssistDataReceiver assistDataReceiver) {
+ if (DEBUG) Slog.d(TAG, "startRecentsActivity(): intent=" + intent
+ + " assistDataReceiver=" + assistDataReceiver);
+ Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "RecentsAnimation#startRecentsActivity");
+
+ // TODO(multi-display) currently only support recents animation in default display.
+ final DisplayWindowController dwc =
+ mStackSupervisor.getDefaultDisplay().getWindowContainerController();
+ if (!mWindowManager.canStartRecentsAnimation()) {
+ notifyAnimationCancelBeforeStart(recentsAnimationRunner);
+ if (DEBUG) Slog.d(TAG, "Can't start recents animation, nextAppTransition="
+ + dwc.getPendingAppTransition());
+ return;
+ }
+
+ // If the activity is associated with the recents stack, then try and get that first
+ mTargetActivityType = intent.getComponent() != null
+ && recentsComponent.equals(intent.getComponent())
+ ? ACTIVITY_TYPE_RECENTS
+ : ACTIVITY_TYPE_HOME;
+ final ActivityStack targetStack = mDefaultDisplay.getStack(WINDOWING_MODE_UNDEFINED,
+ mTargetActivityType);
+ ActivityRecord targetActivity = getTargetActivity(targetStack, intent.getComponent());
+ final boolean hasExistingActivity = targetActivity != null;
+ if (hasExistingActivity) {
+ final ActivityDisplay display = targetActivity.getDisplay();
+ mRestoreTargetBehindStack = display.getStackAbove(targetStack);
+ if (mRestoreTargetBehindStack == null) {
+ notifyAnimationCancelBeforeStart(recentsAnimationRunner);
+ if (DEBUG) Slog.d(TAG, "No stack above target stack=" + targetStack);
+ return;
+ }
+ }
+
+ // Send launch hint if we are actually launching the target. If it's already visible
+ // (shouldn't happen in general) we don't need to send it.
+ if (targetActivity == null || !targetActivity.visible) {
+ mStackSupervisor.sendPowerHintForLaunchStartIfNeeded(true /* forceSend */,
+ targetActivity);
+ }
+
+ mStackSupervisor.getActivityMetricsLogger().notifyActivityLaunching();
+
+ mService.mAmInternal.setRunningRemoteAnimation(mCallingPid, true);
+
+ mWindowManager.deferSurfaceLayout();
+ try {
+ // Kick off the assist data request in the background before showing the target activity
+ if (assistDataReceiver != null) {
+ final AppOpsManager appOpsManager = (AppOpsManager)
+ mService.mContext.getSystemService(Context.APP_OPS_SERVICE);
+ final AssistDataReceiverProxy proxy = new AssistDataReceiverProxy(
+ assistDataReceiver, recentsComponent.getPackageName());
+ mAssistDataRequester = new AssistDataRequester(mService.mContext,
+ mWindowManager, appOpsManager, proxy, this, OP_ASSIST_STRUCTURE, OP_NONE);
+ mAssistDataRequester.requestAssistData(mStackSupervisor.getTopVisibleActivities(),
+ true /* fetchData */, false /* fetchScreenshots */,
+ true /* allowFetchData */, false /* allowFetchScreenshots */,
+ recentsUid, recentsComponent.getPackageName());
+ }
+
+ if (hasExistingActivity) {
+ // Move the recents activity into place for the animation if it is not top most
+ mDefaultDisplay.moveStackBehindBottomMostVisibleStack(targetStack);
+ if (DEBUG) Slog.d(TAG, "Moved stack=" + targetStack + " behind stack="
+ + mDefaultDisplay.getStackAbove(targetStack));
+
+ // If there are multiple tasks in the target stack (ie. the home stack, with 3p
+ // and default launchers coexisting), then move the task to the top as a part of
+ // moving the stack to the front
+ if (targetStack.topTask() != targetActivity.getTask()) {
+ targetStack.addTask(targetActivity.getTask(), true /* toTop */,
+ "startRecentsActivity");
+ }
+ } else {
+ // No recents activity
+ ActivityOptions options = ActivityOptions.makeBasic();
+ options.setLaunchActivityType(mTargetActivityType);
+ options.setAvoidMoveToFront();
+ intent.addFlags(FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_NO_ANIMATION);
+
+ mActivityStartController
+ .obtainStarter(intent, "startRecentsActivity_noTargetActivity")
+ .setCallingUid(recentsUid)
+ .setCallingPackage(recentsComponent.getPackageName())
+ .setActivityOptions(SafeActivityOptions.fromBundle(options.toBundle()))
+ .setMayWait(mService.getCurrentUserId())
+ .execute();
+ mWindowManager.prepareAppTransition(TRANSIT_NONE, false);
+ mWindowManager.executeAppTransition();
+
+ targetActivity = mDefaultDisplay.getStack(WINDOWING_MODE_UNDEFINED,
+ mTargetActivityType).getTopActivity();
+
+ // TODO: Maybe wait for app to draw in this particular case?
+
+ if (DEBUG) Slog.d(TAG, "Started intent=" + intent);
+ }
+
+ // Mark the target activity as launch-behind to bump its visibility for the
+ // duration of the gesture that is driven by the recents component
+ targetActivity.mLaunchTaskBehind = true;
+
+ // Fetch all the surface controls and pass them to the client to get the animation
+ // started. Cancel any existing recents animation running synchronously (do not hold the
+ // WM lock)
+ mWindowManager.cancelRecentsAnimationSynchronously(REORDER_MOVE_TO_ORIGINAL_POSITION,
+ "startRecentsActivity");
+ mWindowManager.initializeRecentsAnimation(mTargetActivityType, recentsAnimationRunner,
+ this, mDefaultDisplay.mDisplayId,
+ mStackSupervisor.mRecentTasks.getRecentTaskIds());
+
+ // If we updated the launch-behind state, update the visibility of the activities after
+ // we fetch the visible tasks to be controlled by the animation
+ mStackSupervisor.ensureActivitiesVisibleLocked(null, 0, PRESERVE_WINDOWS);
+
+ mStackSupervisor.getActivityMetricsLogger().notifyActivityLaunched(START_TASK_TO_FRONT,
+ targetActivity);
+
+ // Register for stack order changes
+ mDefaultDisplay.registerStackOrderChangedListener(this);
+ } catch (Exception e) {
+ Slog.e(TAG, "Failed to start recents activity", e);
+ throw e;
+ } finally {
+ mWindowManager.continueSurfaceLayout();
+ Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
+ }
+ }
+
+ private void finishAnimation(@RecentsAnimationController.ReorderMode int reorderMode) {
+ synchronized (mService.mGlobalLock) {
+ if (DEBUG) Slog.d(TAG, "onAnimationFinished(): controller="
+ + mWindowManager.getRecentsAnimationController()
+ + " reorderMode=" + reorderMode);
+
+ // Cancel the associated assistant data request
+ if (mAssistDataRequester != null) {
+ mAssistDataRequester.cancel();
+ mAssistDataRequester = null;
+ }
+
+ // Unregister for stack order changes
+ mDefaultDisplay.unregisterStackOrderChangedListener(this);
+
+ if (mWindowManager.getRecentsAnimationController() == null) return;
+
+ // Just to be sure end the launch hint in case the target activity was never launched.
+ // However, if we're keeping the activity and making it visible, we can leave it on.
+ if (reorderMode != REORDER_KEEP_IN_PLACE) {
+ mStackSupervisor.sendPowerHintForLaunchEndIfNeeded();
+ }
+
+ mService.mAmInternal.setRunningRemoteAnimation(mCallingPid, false);
+
+ mWindowManager.inSurfaceTransaction(() -> {
+ Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER,
+ "RecentsAnimation#onAnimationFinished_inSurfaceTransaction");
+ mWindowManager.deferSurfaceLayout();
+ try {
+ mWindowManager.cleanupRecentsAnimation(reorderMode);
+
+ final ActivityStack targetStack = mDefaultDisplay.getStack(
+ WINDOWING_MODE_UNDEFINED, mTargetActivityType);
+ final ActivityRecord targetActivity = targetStack != null
+ ? targetStack.getTopActivity()
+ : null;
+ if (DEBUG) Slog.d(TAG, "onAnimationFinished(): targetStack=" + targetStack
+ + " targetActivity=" + targetActivity
+ + " mRestoreTargetBehindStack=" + mRestoreTargetBehindStack);
+ if (targetActivity == null) {
+ return;
+ }
+
+ // Restore the launched-behind state
+ targetActivity.mLaunchTaskBehind = false;
+
+ if (reorderMode == REORDER_MOVE_TO_TOP) {
+ // Bring the target stack to the front
+ mStackSupervisor.mNoAnimActivities.add(targetActivity);
+ targetStack.moveToFront("RecentsAnimation.onAnimationFinished()");
+ if (DEBUG) {
+ final ActivityStack topStack = getTopNonAlwaysOnTopStack();
+ if (topStack != targetStack) {
+ Slog.w(TAG, "Expected target stack=" + targetStack
+ + " to be top most but found stack=" + topStack);
+ }
+ }
+ } else if (reorderMode == REORDER_MOVE_TO_ORIGINAL_POSITION){
+ // Restore the target stack to its previous position
+ final ActivityDisplay display = targetActivity.getDisplay();
+ display.moveStackBehindStack(targetStack, mRestoreTargetBehindStack);
+ if (DEBUG) {
+ final ActivityStack aboveTargetStack =
+ mDefaultDisplay.getStackAbove(targetStack);
+ if (mRestoreTargetBehindStack != null
+ && aboveTargetStack != mRestoreTargetBehindStack) {
+ Slog.w(TAG, "Expected target stack=" + targetStack
+ + " to restored behind stack=" + mRestoreTargetBehindStack
+ + " but it is behind stack=" + aboveTargetStack);
+ }
+ }
+ } else {
+ // Keep target stack in place, nothing changes, so ignore the transition
+ // logic below
+ return;
+ }
+
+ mWindowManager.prepareAppTransition(TRANSIT_NONE, false);
+ mStackSupervisor.ensureActivitiesVisibleLocked(null, 0, false);
+ mStackSupervisor.resumeFocusedStacksTopActivitiesLocked();
+
+ // No reason to wait for the pausing activity in this case, as the hiding of
+ // surfaces needs to be done immediately.
+ mWindowManager.executeAppTransition();
+
+ // After reordering the stacks, reset the minimized state. At this point, either
+ // the target activity is now top-most and we will stay minimized (if in
+ // split-screen), or we will have returned to the app, and the minimized state
+ // should be reset
+ mWindowManager.checkSplitScreenMinimizedChanged(true /* animate */);
+ } catch (Exception e) {
+ Slog.e(TAG, "Failed to clean up recents activity", e);
+ throw e;
+ } finally {
+ mWindowManager.continueSurfaceLayout();
+ Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
+ }
+ });
+ }
+ }
+
+ @Override
+ public void onAnimationFinished(@RecentsAnimationController.ReorderMode int reorderMode,
+ boolean runSychronously) {
+ if (runSychronously) {
+ finishAnimation(reorderMode);
+ } else {
+ mService.mH.post(() -> finishAnimation(reorderMode));
+ }
+ }
+
+ @Override
+ public void onStackOrderChanged() {
+ // If the activity display stack order changes, cancel any running recents animation in
+ // place
+ mWindowManager.cancelRecentsAnimationSynchronously(REORDER_KEEP_IN_PLACE,
+ "stackOrderChanged");
+ }
+
+ /**
+ * Called only when the animation should be canceled prior to starting.
+ */
+ private void notifyAnimationCancelBeforeStart(IRecentsAnimationRunner recentsAnimationRunner) {
+ try {
+ recentsAnimationRunner.onAnimationCanceled();
+ } catch (RemoteException e) {
+ Slog.e(TAG, "Failed to cancel recents animation before start", e);
+ }
+ }
+
+ /**
+ * @return The top stack that is not always-on-top.
+ */
+ private ActivityStack getTopNonAlwaysOnTopStack() {
+ for (int i = mDefaultDisplay.getChildCount() - 1; i >= 0; i--) {
+ final ActivityStack s = mDefaultDisplay.getChildAt(i);
+ if (s.getWindowConfiguration().isAlwaysOnTop()) {
+ continue;
+ }
+ return s;
+ }
+ return null;
+ }
+
+ /**
+ * @return the top activity in the {@param targetStack} matching the {@param component}, or just
+ * the top activity of the top task if no task matches the component.
+ */
+ private ActivityRecord getTargetActivity(ActivityStack targetStack, ComponentName component) {
+ if (targetStack == null) {
+ return null;
+ }
+
+ for (int i = targetStack.getChildCount() - 1; i >= 0; i--) {
+ final TaskRecord task = (TaskRecord) targetStack.getChildAt(i);
+ if (task.getBaseIntent().getComponent().equals(component)) {
+ return task.getTopActivity();
+ }
+ }
+ return targetStack.getTopActivity();
+ }
+}
diff --git a/services/core/java/com/android/server/wm/RunningTasks.java b/services/core/java/com/android/server/wm/RunningTasks.java
new file mode 100644
index 0000000..34282cd
--- /dev/null
+++ b/services/core/java/com/android/server/wm/RunningTasks.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.server.wm;
+
+import android.app.ActivityManager.RunningTaskInfo;
+import android.app.WindowConfiguration.ActivityType;
+import android.app.WindowConfiguration.WindowingMode;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.List;
+import java.util.TreeSet;
+
+/**
+ * Class for resolving the set of running tasks in the system.
+ */
+class RunningTasks {
+
+ // Comparator to sort by last active time (descending)
+ private static final Comparator<TaskRecord> LAST_ACTIVE_TIME_COMPARATOR =
+ (o1, o2) -> Long.signum(o2.lastActiveTime - o1.lastActiveTime);
+
+ private final TaskRecord.TaskActivitiesReport mTmpReport =
+ new TaskRecord.TaskActivitiesReport();
+ private final TreeSet<TaskRecord> mTmpSortedSet = new TreeSet<>(LAST_ACTIVE_TIME_COMPARATOR);
+ private final ArrayList<TaskRecord> mTmpStackTasks = new ArrayList<>();
+
+ void getTasks(int maxNum, List<RunningTaskInfo> list, @ActivityType int ignoreActivityType,
+ @WindowingMode int ignoreWindowingMode, ArrayList<ActivityDisplay> activityDisplays,
+ int callingUid, boolean allowed) {
+ // Return early if there are no tasks to fetch
+ if (maxNum <= 0) {
+ return;
+ }
+
+ // Gather all of the tasks across all of the tasks, and add them to the sorted set
+ mTmpSortedSet.clear();
+ final int numDisplays = activityDisplays.size();
+ for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
+ final ActivityDisplay display = activityDisplays.get(displayNdx);
+ for (int stackNdx = display.getChildCount() - 1; stackNdx >= 0; --stackNdx) {
+ final ActivityStack stack = display.getChildAt(stackNdx);
+ mTmpStackTasks.clear();
+ stack.getRunningTasks(mTmpStackTasks, ignoreActivityType, ignoreWindowingMode,
+ callingUid, allowed);
+ mTmpSortedSet.addAll(mTmpStackTasks);
+ }
+ }
+
+ // Take the first {@param maxNum} tasks and create running task infos for them
+ final Iterator<TaskRecord> iter = mTmpSortedSet.iterator();
+ while (iter.hasNext()) {
+ if (maxNum == 0) {
+ break;
+ }
+
+ final TaskRecord task = iter.next();
+ list.add(createRunningTaskInfo(task));
+ maxNum--;
+ }
+ }
+
+ /**
+ * Constructs a {@link RunningTaskInfo} from a given {@param task}.
+ */
+ private RunningTaskInfo createRunningTaskInfo(TaskRecord task) {
+ final RunningTaskInfo rti = new RunningTaskInfo();
+ task.fillTaskInfo(rti, mTmpReport);
+ // Fill in some deprecated values
+ rti.id = rti.taskId;
+ return rti;
+ }
+}
diff --git a/services/core/java/com/android/server/wm/SafeActivityOptions.java b/services/core/java/com/android/server/wm/SafeActivityOptions.java
new file mode 100644
index 0000000..ac90283
--- /dev/null
+++ b/services/core/java/com/android/server/wm/SafeActivityOptions.java
@@ -0,0 +1,247 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.server.wm;
+
+import static android.Manifest.permission.CONTROL_REMOTE_APP_TRANSITION_ANIMATIONS;
+import static android.Manifest.permission.START_TASKS_FROM_RECENTS;
+import static android.content.pm.PackageManager.PERMISSION_DENIED;
+import static android.content.pm.PackageManager.PERMISSION_GRANTED;
+import static android.view.Display.INVALID_DISPLAY;
+import static android.app.ActivityTaskManager.INVALID_TASK_ID;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_ATM;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_WITH_CLASS_NAME;
+
+import android.annotation.Nullable;
+import android.app.ActivityOptions;
+import android.app.PendingIntent;
+import android.content.Intent;
+import android.content.pm.ActivityInfo;
+import android.os.Binder;
+import android.os.Bundle;
+import android.os.Process;
+import android.os.UserHandle;
+import android.util.Slog;
+import android.view.RemoteAnimationAdapter;
+
+import com.android.internal.annotations.VisibleForTesting;
+
+/**
+ * Wraps {@link ActivityOptions}, records binder identity, and checks permission when retrieving
+ * the inner options. Also supports having two set of options: Once from the original caller, and
+ * once from the caller that is overriding it, which happens when sending a {@link PendingIntent}.
+ */
+public class SafeActivityOptions {
+
+ private static final String TAG = TAG_WITH_CLASS_NAME ? "SafeActivityOptions" : TAG_ATM;
+
+ private final int mOriginalCallingPid;
+ private final int mOriginalCallingUid;
+ private int mRealCallingPid;
+ private int mRealCallingUid;
+ private final @Nullable ActivityOptions mOriginalOptions;
+ private @Nullable ActivityOptions mCallerOptions;
+
+ /**
+ * Constructs a new instance from a bundle and records {@link Binder#getCallingPid}/
+ * {@link Binder#getCallingUid}. Thus, calling identity MUST NOT be cleared when constructing
+ * this object.
+ *
+ * @param bOptions The {@link ActivityOptions} as {@link Bundle}.
+ */
+ public static SafeActivityOptions fromBundle(Bundle bOptions) {
+ return bOptions != null
+ ? new SafeActivityOptions(ActivityOptions.fromBundle(bOptions))
+ : null;
+ }
+
+ /**
+ * Constructs a new instance and records {@link Binder#getCallingPid}/
+ * {@link Binder#getCallingUid}. Thus, calling identity MUST NOT be cleared when constructing
+ * this object.
+ *
+ * @param options The options to wrap.
+ */
+ public SafeActivityOptions(@Nullable ActivityOptions options) {
+ mOriginalCallingPid = Binder.getCallingPid();
+ mOriginalCallingUid = Binder.getCallingUid();
+ mOriginalOptions = options;
+ }
+
+ /**
+ * Overrides options with options from a caller and records {@link Binder#getCallingPid}/
+ * {@link Binder#getCallingUid}. Thus, calling identity MUST NOT be cleared when calling this
+ * method.
+ */
+ public void setCallerOptions(@Nullable ActivityOptions options) {
+ mRealCallingPid = Binder.getCallingPid();
+ mRealCallingUid = Binder.getCallingUid();
+ mCallerOptions = options;
+ }
+
+ /**
+ * Performs permission check and retrieves the options.
+ *
+ * @param r The record of the being started activity.
+ */
+ ActivityOptions getOptions(ActivityRecord r) throws SecurityException {
+ return getOptions(r.intent, r.info, r.app, r.mStackSupervisor);
+ }
+
+ /**
+ * Performs permission check and retrieves the options when options are not being used to launch
+ * a specific activity (i.e. a task is moved to front).
+ */
+ ActivityOptions getOptions(ActivityStackSupervisor supervisor) throws SecurityException {
+ return getOptions(null, null, null, supervisor);
+ }
+
+ /**
+ * Performs permission check and retrieves the options.
+ *
+ * @param intent The intent that is being launched.
+ * @param aInfo The info of the activity being launched.
+ * @param callerApp The record of the caller.
+ */
+ ActivityOptions getOptions(@Nullable Intent intent, @Nullable ActivityInfo aInfo,
+ @Nullable WindowProcessController callerApp,
+ ActivityStackSupervisor supervisor) throws SecurityException {
+ if (mOriginalOptions != null) {
+ checkPermissions(intent, aInfo, callerApp, supervisor, mOriginalOptions,
+ mOriginalCallingPid, mOriginalCallingUid);
+ setCallingPidForRemoteAnimationAdapter(mOriginalOptions, mOriginalCallingPid);
+ }
+ if (mCallerOptions != null) {
+ checkPermissions(intent, aInfo, callerApp, supervisor, mCallerOptions,
+ mRealCallingPid, mRealCallingUid);
+ setCallingPidForRemoteAnimationAdapter(mCallerOptions, mRealCallingPid);
+ }
+ return mergeActivityOptions(mOriginalOptions, mCallerOptions);
+ }
+
+ private void setCallingPidForRemoteAnimationAdapter(ActivityOptions options, int callingPid) {
+ final RemoteAnimationAdapter adapter = options.getRemoteAnimationAdapter();
+ if (adapter == null) {
+ return;
+ }
+ if (callingPid == Process.myPid()) {
+ Slog.wtf(TAG, "Safe activity options constructed after clearing calling id");
+ return;
+ }
+ adapter.setCallingPid(callingPid);
+ }
+
+ /**
+ * @see ActivityOptions#popAppVerificationBundle
+ */
+ Bundle popAppVerificationBundle() {
+ return mOriginalOptions != null ? mOriginalOptions.popAppVerificationBundle() : null;
+ }
+
+ private void abort() {
+ if (mOriginalOptions != null) {
+ ActivityOptions.abort(mOriginalOptions);
+ }
+ if (mCallerOptions != null) {
+ ActivityOptions.abort(mCallerOptions);
+ }
+ }
+
+ static void abort(@Nullable SafeActivityOptions options) {
+ if (options != null) {
+ options.abort();
+ }
+ }
+
+ /**
+ * Merges two activity options into one, with {@code options2} taking precedence in case of a
+ * conflict.
+ */
+ @VisibleForTesting
+ @Nullable ActivityOptions mergeActivityOptions(@Nullable ActivityOptions options1,
+ @Nullable ActivityOptions options2) {
+ if (options1 == null) {
+ return options2;
+ }
+ if (options2 == null) {
+ return options1;
+ }
+ final Bundle b1 = options1.toBundle();
+ final Bundle b2 = options2.toBundle();
+ b1.putAll(b2);
+ return ActivityOptions.fromBundle(b1);
+ }
+
+ private void checkPermissions(@Nullable Intent intent, @Nullable ActivityInfo aInfo,
+ @Nullable WindowProcessController callerApp, ActivityStackSupervisor supervisor,
+ ActivityOptions options, int callingPid, int callingUid) {
+ // If a launch task id is specified, then ensure that the caller is the recents
+ // component or has the START_TASKS_FROM_RECENTS permission
+ if (options.getLaunchTaskId() != INVALID_TASK_ID
+ && !supervisor.mRecentTasks.isCallerRecents(callingUid)) {
+ final int startInTaskPerm = ActivityTaskManagerService.checkPermission(
+ START_TASKS_FROM_RECENTS, callingPid, callingUid);
+ if (startInTaskPerm == PERMISSION_DENIED) {
+ final String msg = "Permission Denial: starting " + getIntentString(intent)
+ + " from " + callerApp + " (pid=" + callingPid
+ + ", uid=" + callingUid + ") with launchTaskId="
+ + options.getLaunchTaskId();
+ Slog.w(TAG, msg);
+ throw new SecurityException(msg);
+ }
+ }
+ // Check if someone tries to launch an activity on a private display with a different
+ // owner.
+ final int launchDisplayId = options.getLaunchDisplayId();
+ if (aInfo != null && launchDisplayId != INVALID_DISPLAY
+ && !supervisor.isCallerAllowedToLaunchOnDisplay(callingPid, callingUid,
+ launchDisplayId, aInfo)) {
+ final String msg = "Permission Denial: starting " + getIntentString(intent)
+ + " from " + callerApp + " (pid=" + callingPid
+ + ", uid=" + callingUid + ") with launchDisplayId="
+ + launchDisplayId;
+ Slog.w(TAG, msg);
+ throw new SecurityException(msg);
+ }
+ // Check if someone tries to launch an unwhitelisted activity into LockTask mode.
+ final boolean lockTaskMode = options.getLockTaskMode();
+ if (aInfo != null && lockTaskMode
+ && !supervisor.mService.getLockTaskController().isPackageWhitelisted(
+ UserHandle.getUserId(callingUid), aInfo.packageName)) {
+ final String msg = "Permission Denial: starting " + getIntentString(intent)
+ + " from " + callerApp + " (pid=" + callingPid
+ + ", uid=" + callingUid + ") with lockTaskMode=true";
+ Slog.w(TAG, msg);
+ throw new SecurityException(msg);
+ }
+
+ // Check permission for remote animations
+ final RemoteAnimationAdapter adapter = options.getRemoteAnimationAdapter();
+ if (adapter != null && supervisor.mService.checkPermission(
+ CONTROL_REMOTE_APP_TRANSITION_ANIMATIONS, callingPid, callingUid)
+ != PERMISSION_GRANTED) {
+ final String msg = "Permission Denial: starting " + getIntentString(intent)
+ + " from " + callerApp + " (pid=" + callingPid
+ + ", uid=" + callingUid + ") with remoteAnimationAdapter";
+ Slog.w(TAG, msg);
+ throw new SecurityException(msg);
+ }
+ }
+
+ private String getIntentString(Intent intent) {
+ return intent != null ? intent.toString() : "(no intent)";
+ }
+}
diff --git a/services/core/java/com/android/server/wm/Task.java b/services/core/java/com/android/server/wm/Task.java
index 2a529d9..3f394a2 100644
--- a/services/core/java/com/android/server/wm/Task.java
+++ b/services/core/java/com/android/server/wm/Task.java
@@ -227,7 +227,7 @@
}
}
- /** @see com.android.server.am.ActivityTaskManagerService#positionTaskInStack(int, int, int). */
+ /** @see ActivityTaskManagerService#positionTaskInStack(int, int, int). */
void positionAt(int position) {
mStack.positionChildAt(position, this, false /* includingParents */);
}
diff --git a/services/core/java/com/android/server/wm/TaskChangeNotificationController.java b/services/core/java/com/android/server/wm/TaskChangeNotificationController.java
new file mode 100644
index 0000000..3b3feac
--- /dev/null
+++ b/services/core/java/com/android/server/wm/TaskChangeNotificationController.java
@@ -0,0 +1,424 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.server.wm;
+
+import android.app.ActivityManager.TaskSnapshot;
+import android.app.ITaskStackListener;
+import android.app.ActivityManager.TaskDescription;
+import android.content.ComponentName;
+import android.os.Binder;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.Message;
+import android.os.RemoteCallbackList;
+import android.os.RemoteException;
+
+import java.util.ArrayList;
+
+class TaskChangeNotificationController {
+ private static final int LOG_STACK_STATE_MSG = 1;
+ private static final int NOTIFY_TASK_STACK_CHANGE_LISTENERS_MSG = 2;
+ private static final int NOTIFY_ACTIVITY_PINNED_LISTENERS_MSG = 3;
+ private static final int NOTIFY_PINNED_ACTIVITY_RESTART_ATTEMPT_LISTENERS_MSG = 4;
+ private static final int NOTIFY_PINNED_STACK_ANIMATION_ENDED_LISTENERS_MSG = 5;
+ private static final int NOTIFY_FORCED_RESIZABLE_MSG = 6;
+ private static final int NOTIFY_ACTIVITY_DISMISSING_DOCKED_STACK_MSG = 7;
+ private static final int NOTIFY_TASK_ADDED_LISTENERS_MSG = 8;
+ private static final int NOTIFY_TASK_REMOVED_LISTENERS_MSG = 9;
+ private static final int NOTIFY_TASK_MOVED_TO_FRONT_LISTENERS_MSG = 10;
+ private static final int NOTIFY_TASK_DESCRIPTION_CHANGED_LISTENERS_MSG = 11;
+ private static final int NOTIFY_ACTIVITY_REQUESTED_ORIENTATION_CHANGED_LISTENERS = 12;
+ private static final int NOTIFY_TASK_REMOVAL_STARTED_LISTENERS = 13;
+ private static final int NOTIFY_TASK_PROFILE_LOCKED_LISTENERS_MSG = 14;
+ private static final int NOTIFY_TASK_SNAPSHOT_CHANGED_LISTENERS_MSG = 15;
+ private static final int NOTIFY_PINNED_STACK_ANIMATION_STARTED_LISTENERS_MSG = 16;
+ private static final int NOTIFY_ACTIVITY_UNPINNED_LISTENERS_MSG = 17;
+ private static final int NOTIFY_ACTIVITY_LAUNCH_ON_SECONDARY_DISPLAY_FAILED_MSG = 18;
+
+ // Delay in notifying task stack change listeners (in millis)
+ private static final int NOTIFY_TASK_STACK_CHANGE_LISTENERS_DELAY = 100;
+
+ // Global lock used by the service the instantiate objects of this class.
+ private final Object mServiceLock;
+ private final ActivityStackSupervisor mStackSupervisor;
+ private final Handler mHandler;
+
+ // Task stack change listeners in a remote process.
+ private final RemoteCallbackList<ITaskStackListener> mRemoteTaskStackListeners =
+ new RemoteCallbackList<>();
+
+ /*
+ * Task stack change listeners in a local process. Tracked separately so that they can be
+ * called on the same thread.
+ */
+ private final ArrayList<ITaskStackListener> mLocalTaskStackListeners = new ArrayList<>();
+
+ private final TaskStackConsumer mNotifyTaskStackChanged = (l, m) -> {
+ l.onTaskStackChanged();
+ };
+
+ private final TaskStackConsumer mNotifyTaskCreated = (l, m) -> {
+ l.onTaskCreated(m.arg1, (ComponentName) m.obj);
+ };
+
+ private final TaskStackConsumer mNotifyTaskRemoved = (l, m) -> {
+ l.onTaskRemoved(m.arg1);
+ };
+
+ private final TaskStackConsumer mNotifyTaskMovedToFront = (l, m) -> {
+ l.onTaskMovedToFront(m.arg1);
+ };
+
+ private final TaskStackConsumer mNotifyTaskDescriptionChanged = (l, m) -> {
+ l.onTaskDescriptionChanged(m.arg1, (TaskDescription) m.obj);
+ };
+
+ private final TaskStackConsumer mNotifyActivityRequestedOrientationChanged = (l, m) -> {
+ l.onActivityRequestedOrientationChanged(m.arg1, m.arg2);
+ };
+
+ private final TaskStackConsumer mNotifyTaskRemovalStarted = (l, m) -> {
+ l.onTaskRemovalStarted(m.arg1);
+ };
+
+ private final TaskStackConsumer mNotifyActivityPinned = (l, m) -> {
+ l.onActivityPinned((String) m.obj /* packageName */, m.sendingUid /* userId */,
+ m.arg1 /* taskId */, m.arg2 /* stackId */);
+ };
+
+ private final TaskStackConsumer mNotifyActivityUnpinned = (l, m) -> {
+ l.onActivityUnpinned();
+ };
+
+ private final TaskStackConsumer mNotifyPinnedActivityRestartAttempt = (l, m) -> {
+ l.onPinnedActivityRestartAttempt(m.arg1 != 0);
+ };
+
+ private final TaskStackConsumer mNotifyPinnedStackAnimationStarted = (l, m) -> {
+ l.onPinnedStackAnimationStarted();
+ };
+
+ private final TaskStackConsumer mNotifyPinnedStackAnimationEnded = (l, m) -> {
+ l.onPinnedStackAnimationEnded();
+ };
+
+ private final TaskStackConsumer mNotifyActivityForcedResizable = (l, m) -> {
+ l.onActivityForcedResizable((String) m.obj, m.arg1, m.arg2);
+ };
+
+ private final TaskStackConsumer mNotifyActivityDismissingDockedStack = (l, m) -> {
+ l.onActivityDismissingDockedStack();
+ };
+
+ private final TaskStackConsumer mNotifyActivityLaunchOnSecondaryDisplayFailed = (l, m) -> {
+ l.onActivityLaunchOnSecondaryDisplayFailed();
+ };
+
+ private final TaskStackConsumer mNotifyTaskProfileLocked = (l, m) -> {
+ l.onTaskProfileLocked(m.arg1, m.arg2);
+ };
+
+ private final TaskStackConsumer mNotifyTaskSnapshotChanged = (l, m) -> {
+ l.onTaskSnapshotChanged(m.arg1, (TaskSnapshot) m.obj);
+ };
+
+ @FunctionalInterface
+ public interface TaskStackConsumer {
+ void accept(ITaskStackListener t, Message m) throws RemoteException;
+ }
+
+ private class MainHandler extends Handler {
+ public MainHandler(Looper looper) {
+ super(looper);
+ }
+
+ @Override
+ public void handleMessage(Message msg) {
+ switch (msg.what) {
+ case LOG_STACK_STATE_MSG: {
+ synchronized (mServiceLock) {
+ mStackSupervisor.logStackState();
+ }
+ break;
+ }
+ case NOTIFY_TASK_STACK_CHANGE_LISTENERS_MSG:
+ forAllRemoteListeners(mNotifyTaskStackChanged, msg);
+ break;
+ case NOTIFY_TASK_ADDED_LISTENERS_MSG:
+ forAllRemoteListeners(mNotifyTaskCreated, msg);
+ break;
+ case NOTIFY_TASK_REMOVED_LISTENERS_MSG:
+ forAllRemoteListeners(mNotifyTaskRemoved, msg);
+ break;
+ case NOTIFY_TASK_MOVED_TO_FRONT_LISTENERS_MSG:
+ forAllRemoteListeners(mNotifyTaskMovedToFront, msg);
+ break;
+ case NOTIFY_TASK_DESCRIPTION_CHANGED_LISTENERS_MSG:
+ forAllRemoteListeners(mNotifyTaskDescriptionChanged, msg);
+ break;
+ case NOTIFY_ACTIVITY_REQUESTED_ORIENTATION_CHANGED_LISTENERS:
+ forAllRemoteListeners(mNotifyActivityRequestedOrientationChanged, msg);
+ break;
+ case NOTIFY_TASK_REMOVAL_STARTED_LISTENERS:
+ forAllRemoteListeners(mNotifyTaskRemovalStarted, msg);
+ break;
+ case NOTIFY_ACTIVITY_PINNED_LISTENERS_MSG:
+ forAllRemoteListeners(mNotifyActivityPinned, msg);
+ break;
+ case NOTIFY_ACTIVITY_UNPINNED_LISTENERS_MSG:
+ forAllRemoteListeners(mNotifyActivityUnpinned, msg);
+ break;
+ case NOTIFY_PINNED_ACTIVITY_RESTART_ATTEMPT_LISTENERS_MSG:
+ forAllRemoteListeners(mNotifyPinnedActivityRestartAttempt, msg);
+ break;
+ case NOTIFY_PINNED_STACK_ANIMATION_STARTED_LISTENERS_MSG:
+ forAllRemoteListeners(mNotifyPinnedStackAnimationStarted, msg);
+ break;
+ case NOTIFY_PINNED_STACK_ANIMATION_ENDED_LISTENERS_MSG:
+ forAllRemoteListeners(mNotifyPinnedStackAnimationEnded, msg);
+ break;
+ case NOTIFY_FORCED_RESIZABLE_MSG:
+ forAllRemoteListeners(mNotifyActivityForcedResizable, msg);
+ break;
+ case NOTIFY_ACTIVITY_DISMISSING_DOCKED_STACK_MSG:
+ forAllRemoteListeners(mNotifyActivityDismissingDockedStack, msg);
+ break;
+ case NOTIFY_ACTIVITY_LAUNCH_ON_SECONDARY_DISPLAY_FAILED_MSG:
+ forAllRemoteListeners(mNotifyActivityLaunchOnSecondaryDisplayFailed, msg);
+ break;
+ case NOTIFY_TASK_PROFILE_LOCKED_LISTENERS_MSG:
+ forAllRemoteListeners(mNotifyTaskProfileLocked, msg);
+ break;
+ case NOTIFY_TASK_SNAPSHOT_CHANGED_LISTENERS_MSG:
+ forAllRemoteListeners(mNotifyTaskSnapshotChanged, msg);
+ break;
+ }
+ }
+ }
+
+ public TaskChangeNotificationController(Object serviceLock,
+ ActivityStackSupervisor stackSupervisor, Handler handler) {
+ mServiceLock = serviceLock;
+ mStackSupervisor = stackSupervisor;
+ mHandler = new MainHandler(handler.getLooper());
+ }
+
+ public void registerTaskStackListener(ITaskStackListener listener) {
+ synchronized (mServiceLock) {
+ if (listener != null) {
+ if (Binder.getCallingPid() == android.os.Process.myPid()) {
+ if (!mLocalTaskStackListeners.contains(listener)) {
+ mLocalTaskStackListeners.add(listener);
+ }
+ } else {
+ mRemoteTaskStackListeners.register(listener);
+ }
+ }
+ }
+ }
+
+ public void unregisterTaskStackListener(ITaskStackListener listener) {
+ synchronized (mServiceLock) {
+ if (listener != null) {
+ if (Binder.getCallingPid() == android.os.Process.myPid()) {
+ mLocalTaskStackListeners.remove(listener);
+ } else {
+ mRemoteTaskStackListeners.unregister(listener);
+ }
+ }
+ }
+ }
+
+ private void forAllRemoteListeners(TaskStackConsumer callback, Message message) {
+ synchronized (mServiceLock) {
+ for (int i = mRemoteTaskStackListeners.beginBroadcast() - 1; i >= 0; i--) {
+ try {
+ // Make a one-way callback to the listener
+ callback.accept(mRemoteTaskStackListeners.getBroadcastItem(i), message);
+ } catch (RemoteException e) {
+ // Handled by the RemoteCallbackList.
+ }
+ }
+ mRemoteTaskStackListeners.finishBroadcast();
+ }
+ }
+
+ private void forAllLocalListeners(TaskStackConsumer callback, Message message) {
+ synchronized (mServiceLock) {
+ for (int i = mLocalTaskStackListeners.size() - 1; i >= 0; i--) {
+ try {
+ callback.accept(mLocalTaskStackListeners.get(i), message);
+ } catch (RemoteException e) {
+ // Never thrown since this is called locally.
+ }
+ }
+ }
+ }
+
+ /** Notifies all listeners when the task stack has changed. */
+ void notifyTaskStackChanged() {
+ mHandler.sendEmptyMessage(LOG_STACK_STATE_MSG);
+ mHandler.removeMessages(NOTIFY_TASK_STACK_CHANGE_LISTENERS_MSG);
+ final Message msg = mHandler.obtainMessage(NOTIFY_TASK_STACK_CHANGE_LISTENERS_MSG);
+ forAllLocalListeners(mNotifyTaskStackChanged, msg);
+ // Only the main task stack change notification requires a delay.
+ mHandler.sendMessageDelayed(msg, NOTIFY_TASK_STACK_CHANGE_LISTENERS_DELAY);
+ }
+
+ /** Notifies all listeners when an Activity is pinned. */
+ void notifyActivityPinned(ActivityRecord r) {
+ mHandler.removeMessages(NOTIFY_ACTIVITY_PINNED_LISTENERS_MSG);
+ final Message msg = mHandler.obtainMessage(NOTIFY_ACTIVITY_PINNED_LISTENERS_MSG,
+ r.getTask().taskId, r.getStackId(), r.packageName);
+ msg.sendingUid = r.userId;
+ forAllLocalListeners(mNotifyActivityPinned, msg);
+ msg.sendToTarget();
+ }
+
+ /** Notifies all listeners when an Activity is unpinned. */
+ void notifyActivityUnpinned() {
+ mHandler.removeMessages(NOTIFY_ACTIVITY_UNPINNED_LISTENERS_MSG);
+ final Message msg = mHandler.obtainMessage(NOTIFY_ACTIVITY_UNPINNED_LISTENERS_MSG);
+ forAllLocalListeners(mNotifyActivityUnpinned, msg);
+ msg.sendToTarget();
+ }
+
+ /**
+ * Notifies all listeners when an attempt was made to start an an activity that is already
+ * running in the pinned stack and the activity was not actually started, but the task is
+ * either brought to the front or a new Intent is delivered to it.
+ */
+ void notifyPinnedActivityRestartAttempt(boolean clearedTask) {
+ mHandler.removeMessages(NOTIFY_PINNED_ACTIVITY_RESTART_ATTEMPT_LISTENERS_MSG);
+ final Message msg =
+ mHandler.obtainMessage(NOTIFY_PINNED_ACTIVITY_RESTART_ATTEMPT_LISTENERS_MSG,
+ clearedTask ? 1 : 0, 0);
+ forAllLocalListeners(mNotifyPinnedActivityRestartAttempt, msg);
+ msg.sendToTarget();
+ }
+
+ /** Notifies all listeners when the pinned stack animation starts. */
+ void notifyPinnedStackAnimationStarted() {
+ mHandler.removeMessages(NOTIFY_PINNED_STACK_ANIMATION_STARTED_LISTENERS_MSG);
+ final Message msg =
+ mHandler.obtainMessage(NOTIFY_PINNED_STACK_ANIMATION_STARTED_LISTENERS_MSG);
+ forAllLocalListeners(mNotifyPinnedStackAnimationStarted, msg);
+ msg.sendToTarget();
+ }
+
+ /** Notifies all listeners when the pinned stack animation ends. */
+ void notifyPinnedStackAnimationEnded() {
+ mHandler.removeMessages(NOTIFY_PINNED_STACK_ANIMATION_ENDED_LISTENERS_MSG);
+ final Message msg =
+ mHandler.obtainMessage(NOTIFY_PINNED_STACK_ANIMATION_ENDED_LISTENERS_MSG);
+ forAllLocalListeners(mNotifyPinnedStackAnimationEnded, msg);
+ msg.sendToTarget();
+ }
+
+ void notifyActivityDismissingDockedStack() {
+ mHandler.removeMessages(NOTIFY_ACTIVITY_DISMISSING_DOCKED_STACK_MSG);
+ final Message msg = mHandler.obtainMessage(NOTIFY_ACTIVITY_DISMISSING_DOCKED_STACK_MSG);
+ forAllLocalListeners(mNotifyActivityDismissingDockedStack, msg);
+ msg.sendToTarget();
+ }
+
+ void notifyActivityForcedResizable(int taskId, int reason, String packageName) {
+ mHandler.removeMessages(NOTIFY_FORCED_RESIZABLE_MSG);
+ final Message msg = mHandler.obtainMessage(NOTIFY_FORCED_RESIZABLE_MSG, taskId, reason,
+ packageName);
+ forAllLocalListeners(mNotifyActivityForcedResizable, msg);
+ msg.sendToTarget();
+ }
+
+ void notifyActivityLaunchOnSecondaryDisplayFailed() {
+ mHandler.removeMessages(NOTIFY_ACTIVITY_LAUNCH_ON_SECONDARY_DISPLAY_FAILED_MSG);
+ final Message msg = mHandler.obtainMessage(
+ NOTIFY_ACTIVITY_LAUNCH_ON_SECONDARY_DISPLAY_FAILED_MSG);
+ forAllLocalListeners(mNotifyActivityLaunchOnSecondaryDisplayFailed, msg);
+ msg.sendToTarget();
+ }
+
+ void notifyTaskCreated(int taskId, ComponentName componentName) {
+ final Message msg = mHandler.obtainMessage(NOTIFY_TASK_ADDED_LISTENERS_MSG,
+ taskId, 0 /* unused */, componentName);
+ forAllLocalListeners(mNotifyTaskCreated, msg);
+ msg.sendToTarget();
+ }
+
+ void notifyTaskRemoved(int taskId) {
+ final Message msg = mHandler.obtainMessage(NOTIFY_TASK_REMOVED_LISTENERS_MSG,
+ taskId, 0 /* unused */);
+ forAllLocalListeners(mNotifyTaskRemoved, msg);
+ msg.sendToTarget();
+ }
+
+ void notifyTaskMovedToFront(int taskId) {
+ final Message msg = mHandler.obtainMessage(NOTIFY_TASK_MOVED_TO_FRONT_LISTENERS_MSG,
+ taskId, 0 /* unused */);
+ forAllLocalListeners(mNotifyTaskMovedToFront, msg);
+ msg.sendToTarget();
+ }
+
+ void notifyTaskDescriptionChanged(int taskId, TaskDescription taskDescription) {
+ final Message msg = mHandler.obtainMessage(NOTIFY_TASK_DESCRIPTION_CHANGED_LISTENERS_MSG,
+ taskId, 0 /* unused */, taskDescription);
+ forAllLocalListeners(mNotifyTaskDescriptionChanged, msg);
+ msg.sendToTarget();
+
+ }
+
+ void notifyActivityRequestedOrientationChanged(int taskId, int orientation) {
+ final Message msg = mHandler.obtainMessage(
+ NOTIFY_ACTIVITY_REQUESTED_ORIENTATION_CHANGED_LISTENERS, taskId, orientation);
+ forAllLocalListeners(mNotifyActivityRequestedOrientationChanged, msg);
+ msg.sendToTarget();
+ }
+
+ /**
+ * Notify listeners that the task is about to be finished before its surfaces are removed from
+ * the window manager. This allows interested parties to perform relevant animations before
+ * the window disappears.
+ */
+ void notifyTaskRemovalStarted(int taskId) {
+ final Message msg = mHandler.obtainMessage(NOTIFY_TASK_REMOVAL_STARTED_LISTENERS, taskId,
+ 0 /* unused */);
+ forAllLocalListeners(mNotifyTaskRemovalStarted, msg);
+ msg.sendToTarget();
+
+ }
+
+ /**
+ * Notify listeners that the task has been put in a locked state because one or more of the
+ * activities inside it belong to a managed profile user that has been locked.
+ */
+ void notifyTaskProfileLocked(int taskId, int userId) {
+ final Message msg = mHandler.obtainMessage(NOTIFY_TASK_PROFILE_LOCKED_LISTENERS_MSG, taskId,
+ userId);
+ forAllLocalListeners(mNotifyTaskProfileLocked, msg);
+ msg.sendToTarget();
+ }
+
+ /**
+ * Notify listeners that the snapshot of a task has changed.
+ */
+ void notifyTaskSnapshotChanged(int taskId, TaskSnapshot snapshot) {
+ final Message msg = mHandler.obtainMessage(NOTIFY_TASK_SNAPSHOT_CHANGED_LISTENERS_MSG,
+ taskId, 0, snapshot);
+ forAllLocalListeners(mNotifyTaskSnapshotChanged, msg);
+ msg.sendToTarget();
+ }
+}
diff --git a/services/core/java/com/android/server/wm/TaskLaunchParamsModifier.java b/services/core/java/com/android/server/wm/TaskLaunchParamsModifier.java
new file mode 100644
index 0000000..b7804e8
--- /dev/null
+++ b/services/core/java/com/android/server/wm/TaskLaunchParamsModifier.java
@@ -0,0 +1,810 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.server.wm;
+
+import static android.app.WindowConfiguration.WINDOWING_MODE_FREEFORM;
+import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN;
+import static android.app.WindowConfiguration.WINDOWING_MODE_PINNED;
+import static android.app.WindowConfiguration.WINDOWING_MODE_UNDEFINED;
+import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE;
+import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_LOCKED;
+import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_NOSENSOR;
+import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
+import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE;
+import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT;
+import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE;
+import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT;
+import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED;
+import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_USER_LANDSCAPE;
+import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_USER_PORTRAIT;
+import static android.util.DisplayMetrics.DENSITY_DEFAULT;
+import static android.view.Display.DEFAULT_DISPLAY;
+import static android.view.Display.INVALID_DISPLAY;
+
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_ATM;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_WITH_CLASS_NAME;
+
+import android.annotation.NonNull;
+import android.annotation.Nullable;
+import android.app.ActivityOptions;
+import android.app.WindowConfiguration;
+import android.content.pm.ActivityInfo;
+import android.content.pm.ApplicationInfo;
+import android.graphics.Rect;
+import android.os.Build;
+import android.util.Slog;
+import android.view.Gravity;
+
+import com.android.server.wm.LaunchParamsController.LaunchParams;
+import com.android.server.wm.LaunchParamsController.LaunchParamsModifier;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * The class that defines the default launch params for tasks.
+ */
+class TaskLaunchParamsModifier implements LaunchParamsModifier {
+ private static final String TAG = TAG_WITH_CLASS_NAME ? "TaskLaunchParamsModifier" : TAG_ATM;
+ private static final boolean DEBUG = false;
+
+ // A mask for SUPPORTS_SCREEN that indicates the activity supports resize.
+ private static final int SUPPORTS_SCREEN_RESIZEABLE_MASK =
+ ApplicationInfo.FLAG_SUPPORTS_SCREEN_DENSITIES
+ | ApplicationInfo.FLAG_SUPPORTS_LARGE_SCREENS
+ | ApplicationInfo.FLAG_SUPPORTS_SMALL_SCREENS
+ | ApplicationInfo.FLAG_RESIZEABLE_FOR_SCREENS
+ | ApplicationInfo.FLAG_SUPPORTS_SCREEN_DENSITIES
+ | ApplicationInfo.FLAG_SUPPORTS_XLARGE_SCREENS;
+
+ // Screen size of Nexus 5x
+ private static final int DEFAULT_PORTRAIT_PHONE_WIDTH_DP = 412;
+ private static final int DEFAULT_PORTRAIT_PHONE_HEIGHT_DP = 732;
+
+ // Allowance of size matching.
+ private static final int EPSILON = 2;
+
+ // Cascade window offset.
+ private static final int CASCADING_OFFSET_DP = 75;
+
+ // Threshold how close window corners have to be to call them colliding.
+ private static final int BOUNDS_CONFLICT_THRESHOLD = 4;
+
+ // Divide display size by this number to get each step to adjust bounds to avoid conflict.
+ private static final int STEP_DENOMINATOR = 16;
+
+ // We always want to step by at least this.
+ private static final int MINIMAL_STEP = 1;
+
+ private final ActivityStackSupervisor mSupervisor;
+ private final Rect mTmpBounds = new Rect();
+ private final int[] mTmpDirections = new int[2];
+
+ private StringBuilder mLogBuilder;
+
+ TaskLaunchParamsModifier(ActivityStackSupervisor supervisor) {
+ mSupervisor = supervisor;
+ }
+
+ @Override
+ public int onCalculate(TaskRecord task, ActivityInfo.WindowLayout layout,
+ ActivityRecord activity, ActivityRecord source, ActivityOptions options,
+ LaunchParams currentParams, LaunchParams outParams) {
+ initLogBuilder(task, activity);
+ final int result = calculate(task, layout, activity, source, options, currentParams,
+ outParams);
+ outputLog();
+ return result;
+ }
+
+ private int calculate(TaskRecord task, ActivityInfo.WindowLayout layout,
+ ActivityRecord activity, ActivityRecord source, ActivityOptions options,
+ LaunchParams currentParams, LaunchParams outParams) {
+ final ActivityRecord root;
+ if (task != null) {
+ root = task.getRootActivity() == null ? activity : task.getRootActivity();
+ } else {
+ root = activity;
+ }
+
+ // TODO: Investigate whether we can safely ignore all cases where we don't have root
+ // activity available. Note we can't know if the bounds are valid if we're not sure of the
+ // requested orientation of the root activity. Therefore if we found such a case we may need
+ // to pass the activity into this modifier in that case.
+ if (root == null) {
+ // There is a case that can lead us here. The caller is moving the top activity that is
+ // in a task that has multiple activities to PIP mode. For that the caller is creating a
+ // new task to host the activity so that we only move the top activity to PIP mode and
+ // keep other activities in the previous task. There is no point to apply the launch
+ // logic in this case.
+ return RESULT_SKIP;
+ }
+
+ // STEP 1: Determine the display to launch the activity/task.
+ final int displayId = getPreferredLaunchDisplay(task, options, source, currentParams);
+ outParams.mPreferredDisplayId = displayId;
+ ActivityDisplay display = mSupervisor.getActivityDisplay(displayId);
+ if (DEBUG) {
+ appendLog("display-id=" + outParams.mPreferredDisplayId + " display-windowing-mode="
+ + display.getWindowingMode());
+ }
+
+ // STEP 2: Resolve launch windowing mode.
+ // STEP 2.1: Determine if any parameter has specified initial bounds. That might be the
+ // launch bounds from activity options, or size/gravity passed in layout. It also treats the
+ // launch windowing mode in options as a suggestion for future resolution.
+ int launchMode = options != null ? options.getLaunchWindowingMode()
+ : WINDOWING_MODE_UNDEFINED;
+ // hasInitialBounds is set if either activity options or layout has specified bounds. If
+ // that's set we'll skip some adjustments later to avoid overriding the initial bounds.
+ boolean hasInitialBounds = false;
+ final boolean canApplyFreeformPolicy = canApplyFreeformWindowPolicy(display, launchMode);
+ if (mSupervisor.canUseActivityOptionsLaunchBounds(options)
+ && (canApplyFreeformPolicy || canApplyPipWindowPolicy(launchMode))) {
+ hasInitialBounds = true;
+ launchMode = launchMode == WINDOWING_MODE_UNDEFINED
+ ? WINDOWING_MODE_FREEFORM
+ : launchMode;
+ outParams.mBounds.set(options.getLaunchBounds());
+ if (DEBUG) appendLog("activity-options-bounds=" + outParams.mBounds);
+ } else if (launchMode == WINDOWING_MODE_PINNED) {
+ // System controls PIP window's bounds, so don't apply launch bounds.
+ if (DEBUG) appendLog("empty-window-layout-for-pip");
+ } else if (launchMode == WINDOWING_MODE_FULLSCREEN) {
+ if (DEBUG) appendLog("activity-options-fullscreen=" + outParams.mBounds);
+ } else if (layout != null && canApplyFreeformPolicy) {
+ getLayoutBounds(display, root, layout, mTmpBounds);
+ if (!mTmpBounds.isEmpty()) {
+ launchMode = WINDOWING_MODE_FREEFORM;
+ outParams.mBounds.set(mTmpBounds);
+ hasInitialBounds = true;
+ if (DEBUG) appendLog("bounds-from-layout=" + outParams.mBounds);
+ } else {
+ if (DEBUG) appendLog("empty-window-layout");
+ }
+ }
+
+ // STEP 2.2: Check if previous modifier or the controller (referred as "callers" below) has
+ // some opinions on launch mode and launch bounds. If they have opinions and there is no
+ // initial bounds set in parameters. Note the check on display ID is also input param
+ // related because we always defer to callers' suggestion if there is no specific display ID
+ // in options or from source activity.
+ //
+ // If opinions from callers don't need any further resolution, we try to honor that as is as
+ // much as possible later.
+
+ // Flag to indicate if current param needs no further resolution. It's true it current
+ // param isn't freeform mode, or it already has launch bounds.
+ boolean fullyResolvedCurrentParam = false;
+ // We inherit launch params from previous modifiers or LaunchParamsController if options,
+ // layout and display conditions are not contradictory to their suggestions. It's important
+ // to carry over their values because LaunchParamsController doesn't automatically do that.
+ if (!currentParams.isEmpty() && !hasInitialBounds
+ && (!currentParams.hasPreferredDisplay()
+ || displayId == currentParams.mPreferredDisplayId)) {
+ if (currentParams.hasWindowingMode()) {
+ launchMode = currentParams.mWindowingMode;
+ fullyResolvedCurrentParam = (launchMode != WINDOWING_MODE_FREEFORM);
+ if (DEBUG) {
+ appendLog("inherit-" + WindowConfiguration.windowingModeToString(launchMode));
+ }
+ }
+
+ if (!currentParams.mBounds.isEmpty()) {
+ outParams.mBounds.set(currentParams.mBounds);
+ fullyResolvedCurrentParam = true;
+ if (DEBUG) appendLog("inherit-bounds=" + outParams.mBounds);
+ }
+ }
+
+ // STEP 2.3: Adjust launch parameters as needed for freeform display. We enforce the policy
+ // that legacy (pre-D) apps and those apps that can't handle multiple screen density well
+ // are forced to be maximized. The rest of this step is to define the default policy when
+ // there is no initial bounds or a fully resolved current params from callers. Right now we
+ // launch all possible tasks/activities that can handle freeform into freeform mode.
+ if (display.inFreeformWindowingMode()) {
+ if (launchMode == WINDOWING_MODE_PINNED) {
+ if (DEBUG) appendLog("picture-in-picture");
+ } else if (isTaskForcedMaximized(root)) {
+ // We're launching an activity that probably can't handle resizing nicely, so force
+ // it to be maximized even someone suggests launching it in freeform using launch
+ // options.
+ launchMode = WINDOWING_MODE_FULLSCREEN;
+ outParams.mBounds.setEmpty();
+ if (DEBUG) appendLog("forced-maximize");
+ } else if (fullyResolvedCurrentParam) {
+ // Don't adjust launch mode if that's inherited, except when we're launching an
+ // activity that should be forced to maximize.
+ if (DEBUG) appendLog("skip-adjustment-fully-resolved-params");
+ } else if (launchMode != WINDOWING_MODE_FREEFORM
+ && (isNOrGreater(root) || isPreNResizeable(root))) {
+ // We're launching a pre-N and post-D activity that supports resizing, or a post-N
+ // activity. They can handle freeform nicely so launch them in freeform.
+ // Use undefined because we know we're in a freeform display.
+ launchMode = WINDOWING_MODE_UNDEFINED;
+ if (DEBUG) appendLog("should-be-freeform");
+ }
+ } else {
+ if (DEBUG) appendLog("non-freeform-display");
+ }
+ // If launch mode matches display windowing mode, let it inherit from display.
+ outParams.mWindowingMode = launchMode == display.getWindowingMode()
+ ? WINDOWING_MODE_UNDEFINED : launchMode;
+
+ // STEP 3: Determine final launch bounds based on resolved windowing mode and activity
+ // requested orientation. We set bounds to empty for fullscreen mode and keep bounds as is
+ // for all other windowing modes that's not freeform mode. One can read comments in
+ // relevant methods to further understand this step.
+ //
+ // We skip making adjustments if the params are fully resolved from previous results and
+ // trust that they are valid.
+ if (!fullyResolvedCurrentParam) {
+ final int resolvedMode = (launchMode != WINDOWING_MODE_UNDEFINED) ? launchMode
+ : display.getWindowingMode();
+ if (source != null && source.inFreeformWindowingMode()
+ && resolvedMode == WINDOWING_MODE_FREEFORM
+ && outParams.mBounds.isEmpty()
+ && source.getDisplayId() == display.mDisplayId) {
+ // Set bounds to be not very far from source activity.
+ cascadeBounds(source.getBounds(), display, outParams.mBounds);
+ }
+ getTaskBounds(root, display, layout, resolvedMode, hasInitialBounds, outParams.mBounds);
+ }
+
+ return RESULT_CONTINUE;
+ }
+
+ private int getPreferredLaunchDisplay(@Nullable TaskRecord task,
+ @Nullable ActivityOptions options, ActivityRecord source, LaunchParams currentParams) {
+ int displayId = INVALID_DISPLAY;
+ final int optionLaunchId = options != null ? options.getLaunchDisplayId() : INVALID_DISPLAY;
+ if (optionLaunchId != INVALID_DISPLAY) {
+ if (DEBUG) appendLog("display-from-option=" + optionLaunchId);
+ displayId = optionLaunchId;
+ }
+
+ if (displayId == INVALID_DISPLAY && source != null) {
+ final int sourceDisplayId = source.getDisplayId();
+ if (DEBUG) appendLog("display-from-source=" + sourceDisplayId);
+ displayId = sourceDisplayId;
+ }
+
+ ActivityStack stack =
+ (displayId == INVALID_DISPLAY && task != null) ? task.getStack() : null;
+ if (stack != null) {
+ if (DEBUG) appendLog("display-from-task=" + stack.mDisplayId);
+ displayId = stack.mDisplayId;
+ }
+
+ if (displayId != INVALID_DISPLAY && mSupervisor.getActivityDisplay(displayId) == null) {
+ displayId = INVALID_DISPLAY;
+ }
+ displayId = (displayId == INVALID_DISPLAY) ? currentParams.mPreferredDisplayId : displayId;
+
+ displayId = (displayId == INVALID_DISPLAY) ? DEFAULT_DISPLAY : displayId;
+
+ return displayId;
+ }
+
+ private boolean canApplyFreeformWindowPolicy(@NonNull ActivityDisplay display, int launchMode) {
+ return mSupervisor.mService.mSupportsFreeformWindowManagement
+ && (display.inFreeformWindowingMode() || launchMode == WINDOWING_MODE_FREEFORM);
+ }
+
+ private boolean canApplyPipWindowPolicy(int launchMode) {
+ return mSupervisor.mService.mSupportsPictureInPicture
+ && launchMode == WINDOWING_MODE_PINNED;
+ }
+
+ private void getLayoutBounds(@NonNull ActivityDisplay display, @NonNull ActivityRecord root,
+ @NonNull ActivityInfo.WindowLayout windowLayout, @NonNull Rect outBounds) {
+ final int verticalGravity = windowLayout.gravity & Gravity.VERTICAL_GRAVITY_MASK;
+ final int horizontalGravity = windowLayout.gravity & Gravity.HORIZONTAL_GRAVITY_MASK;
+ if (!windowLayout.hasSpecifiedSize() && verticalGravity == 0 && horizontalGravity == 0) {
+ outBounds.setEmpty();
+ return;
+ }
+
+ final Rect bounds = display.getBounds();
+ final int defaultWidth = bounds.width();
+ final int defaultHeight = bounds.height();
+
+ int width;
+ int height;
+ if (!windowLayout.hasSpecifiedSize()) {
+ outBounds.setEmpty();
+ getTaskBounds(root, display, windowLayout, WINDOWING_MODE_FREEFORM,
+ /* hasInitialBounds */ false, outBounds);
+ width = outBounds.width();
+ height = outBounds.height();
+ } else {
+ width = defaultWidth;
+ if (windowLayout.width > 0 && windowLayout.width < defaultWidth) {
+ width = windowLayout.width;
+ } else if (windowLayout.widthFraction > 0 && windowLayout.widthFraction < 1.0f) {
+ width = (int) (width * windowLayout.widthFraction);
+ }
+
+ height = defaultHeight;
+ if (windowLayout.height > 0 && windowLayout.height < defaultHeight) {
+ height = windowLayout.height;
+ } else if (windowLayout.heightFraction > 0 && windowLayout.heightFraction < 1.0f) {
+ height = (int) (height * windowLayout.heightFraction);
+ }
+ }
+
+ final float fractionOfHorizontalOffset;
+ switch (horizontalGravity) {
+ case Gravity.LEFT:
+ fractionOfHorizontalOffset = 0f;
+ break;
+ case Gravity.RIGHT:
+ fractionOfHorizontalOffset = 1f;
+ break;
+ default:
+ fractionOfHorizontalOffset = 0.5f;
+ }
+
+ final float fractionOfVerticalOffset;
+ switch (verticalGravity) {
+ case Gravity.TOP:
+ fractionOfVerticalOffset = 0f;
+ break;
+ case Gravity.BOTTOM:
+ fractionOfVerticalOffset = 1f;
+ break;
+ default:
+ fractionOfVerticalOffset = 0.5f;
+ }
+
+ outBounds.set(0, 0, width, height);
+ final int xOffset = (int) (fractionOfHorizontalOffset * (defaultWidth - width));
+ final int yOffset = (int) (fractionOfVerticalOffset * (defaultHeight - height));
+ outBounds.offset(xOffset, yOffset);
+ }
+
+ /**
+ * Returns if task is forced to maximize.
+ *
+ * There are several cases where we force a task to maximize:
+ * 1) Root activity is targeting pre-Donut, which by default can't handle multiple screen
+ * densities, so resizing will likely cause issues;
+ * 2) Root activity doesn't declare any flag that it supports any screen density, so resizing
+ * may also cause issues;
+ * 3) Root activity is not resizeable, for which we shouldn't allow user resize it.
+ *
+ * @param root the root activity to check against.
+ * @return {@code true} if it should be forced to maximize; {@code false} otherwise.
+ */
+ private boolean isTaskForcedMaximized(@NonNull ActivityRecord root) {
+ if (root.appInfo.targetSdkVersion < Build.VERSION_CODES.DONUT
+ || (root.appInfo.flags & SUPPORTS_SCREEN_RESIZEABLE_MASK) == 0) {
+ return true;
+ }
+
+ return !root.isResizeable();
+ }
+
+ private boolean isNOrGreater(@NonNull ActivityRecord root) {
+ return root.appInfo.targetSdkVersion >= Build.VERSION_CODES.N;
+ }
+
+ /**
+ * Resolves activity requested orientation to 4 categories:
+ * 1) {@link ActivityInfo#SCREEN_ORIENTATION_LOCKED} indicating app wants to lock down
+ * orientation;
+ * 2) {@link ActivityInfo#SCREEN_ORIENTATION_LANDSCAPE} indicating app wants to be in landscape;
+ * 3) {@link ActivityInfo#SCREEN_ORIENTATION_PORTRAIT} indicating app wants to be in portrait;
+ * 4) {@link ActivityInfo#SCREEN_ORIENTATION_UNSPECIFIED} indicating app can handle any
+ * orientation.
+ *
+ * @param activity the activity to check
+ * @return corresponding resolved orientation value.
+ */
+ private int resolveOrientation(@NonNull ActivityRecord activity) {
+ int orientation = activity.info.screenOrientation;
+ switch (orientation) {
+ case SCREEN_ORIENTATION_NOSENSOR:
+ case SCREEN_ORIENTATION_LOCKED:
+ orientation = SCREEN_ORIENTATION_LOCKED;
+ break;
+ case SCREEN_ORIENTATION_SENSOR_LANDSCAPE:
+ case SCREEN_ORIENTATION_REVERSE_LANDSCAPE:
+ case SCREEN_ORIENTATION_USER_LANDSCAPE:
+ case SCREEN_ORIENTATION_LANDSCAPE:
+ if (DEBUG) appendLog("activity-requested-landscape");
+ orientation = SCREEN_ORIENTATION_LANDSCAPE;
+ break;
+ case SCREEN_ORIENTATION_SENSOR_PORTRAIT:
+ case SCREEN_ORIENTATION_REVERSE_PORTRAIT:
+ case SCREEN_ORIENTATION_USER_PORTRAIT:
+ case SCREEN_ORIENTATION_PORTRAIT:
+ if (DEBUG) appendLog("activity-requested-portrait");
+ orientation = SCREEN_ORIENTATION_PORTRAIT;
+ break;
+ default:
+ orientation = SCREEN_ORIENTATION_UNSPECIFIED;
+ }
+
+ return orientation;
+ }
+
+ private boolean isPreNResizeable(ActivityRecord root) {
+ return root.appInfo.targetSdkVersion < Build.VERSION_CODES.N && root.isResizeable();
+ }
+
+ private void cascadeBounds(@NonNull Rect srcBounds, @NonNull ActivityDisplay display,
+ @NonNull Rect outBounds) {
+ outBounds.set(srcBounds);
+ float density = (float) display.getConfiguration().densityDpi / DENSITY_DEFAULT;
+ final int defaultOffset = (int) (CASCADING_OFFSET_DP * density + 0.5f);
+
+ display.getBounds(mTmpBounds);
+ final int dx = Math.min(defaultOffset, Math.max(0, mTmpBounds.right - srcBounds.right));
+ final int dy = Math.min(defaultOffset, Math.max(0, mTmpBounds.bottom - srcBounds.bottom));
+ outBounds.offset(dx, dy);
+ }
+
+ private void getTaskBounds(@NonNull ActivityRecord root, @NonNull ActivityDisplay display,
+ @NonNull ActivityInfo.WindowLayout layout, int resolvedMode, boolean hasInitialBounds,
+ @NonNull Rect inOutBounds) {
+ if (resolvedMode == WINDOWING_MODE_FULLSCREEN) {
+ // We don't handle letterboxing here. Letterboxing will be handled by valid checks
+ // later.
+ inOutBounds.setEmpty();
+ if (DEBUG) appendLog("maximized-bounds");
+ return;
+ }
+
+ if (resolvedMode != WINDOWING_MODE_FREEFORM) {
+ // We don't apply freeform bounds adjustment to other windowing modes.
+ if (DEBUG) {
+ appendLog("skip-bounds-" + WindowConfiguration.windowingModeToString(resolvedMode));
+ }
+ return;
+ }
+
+ final int orientation = resolveOrientation(root, display, inOutBounds);
+ if (orientation != SCREEN_ORIENTATION_PORTRAIT
+ && orientation != SCREEN_ORIENTATION_LANDSCAPE) {
+ throw new IllegalStateException(
+ "Orientation must be one of portrait or landscape, but it's "
+ + ActivityInfo.screenOrientationToString(orientation));
+ }
+
+ // First we get the default size we want.
+ getDefaultFreeformSize(display, layout, orientation, mTmpBounds);
+ if (hasInitialBounds || sizeMatches(inOutBounds, mTmpBounds)) {
+ // We're here because either input parameters specified initial bounds, or the suggested
+ // bounds have the same size of the default freeform size. We should use the suggested
+ // bounds if possible -- so if app can handle the orientation we just use it, and if not
+ // we transpose the suggested bounds in-place.
+ if (orientation == orientationFromBounds(inOutBounds)) {
+ if (DEBUG) appendLog("freeform-size-orientation-match=" + inOutBounds);
+ } else {
+ // Meh, orientation doesn't match. Let's rotate inOutBounds in-place.
+ centerBounds(display, inOutBounds.height(), inOutBounds.width(), inOutBounds);
+ if (DEBUG) appendLog("freeform-orientation-mismatch=" + inOutBounds);
+ }
+ } else {
+ // We are here either because there is no suggested bounds, or the suggested bounds is
+ // a cascade from source activity. We should use the default freeform size and center it
+ // to the center of suggested bounds (or the display if no suggested bounds). The
+ // default size might be too big to center to source activity bounds in display, so we
+ // may need to move it back to the display.
+ centerBounds(display, mTmpBounds.width(), mTmpBounds.height(), inOutBounds);
+ adjustBoundsToFitInDisplay(display, inOutBounds);
+ if (DEBUG) appendLog("freeform-size-mismatch=" + inOutBounds);
+ }
+
+ // Lastly we adjust bounds to avoid conflicts with other tasks as much as possible.
+ adjustBoundsToAvoidConflict(display, inOutBounds);
+ }
+
+ private int resolveOrientation(@NonNull ActivityRecord root, @NonNull ActivityDisplay display,
+ @NonNull Rect bounds) {
+ int orientation = resolveOrientation(root);
+
+ if (orientation == SCREEN_ORIENTATION_LOCKED) {
+ orientation = bounds.isEmpty() ? display.getConfiguration().orientation
+ : orientationFromBounds(bounds);
+ if (DEBUG) {
+ appendLog(bounds.isEmpty() ? "locked-orientation-from-display=" + orientation
+ : "locked-orientation-from-bounds=" + bounds);
+ }
+ }
+
+ if (orientation == SCREEN_ORIENTATION_UNSPECIFIED) {
+ orientation = bounds.isEmpty() ? SCREEN_ORIENTATION_PORTRAIT
+ : orientationFromBounds(bounds);
+ if (DEBUG) {
+ appendLog(bounds.isEmpty() ? "default-portrait"
+ : "orientation-from-bounds=" + bounds);
+ }
+ }
+
+ return orientation;
+ }
+
+ private void getDefaultFreeformSize(@NonNull ActivityDisplay display,
+ @NonNull ActivityInfo.WindowLayout layout, int orientation, @NonNull Rect bounds) {
+ // Default size, which is letterboxing/pillarboxing in display. That's to say the large
+ // dimension of default size is the small dimension of display size, and the small dimension
+ // of default size is calculated to keep the same aspect ratio as the display's.
+ Rect displayBounds = display.getBounds();
+ final int portraitHeight = Math.min(displayBounds.width(), displayBounds.height());
+ final int otherDimension = Math.max(displayBounds.width(), displayBounds.height());
+ final int portraitWidth = (portraitHeight * portraitHeight) / otherDimension;
+ final int defaultWidth = (orientation == SCREEN_ORIENTATION_LANDSCAPE) ? portraitHeight
+ : portraitWidth;
+ final int defaultHeight = (orientation == SCREEN_ORIENTATION_LANDSCAPE) ? portraitWidth
+ : portraitHeight;
+
+ // Get window size based on Nexus 5x screen, we assume that this is enough to show content
+ // of activities.
+ final float density = (float) display.getConfiguration().densityDpi / DENSITY_DEFAULT;
+ final int phonePortraitWidth = (int) (DEFAULT_PORTRAIT_PHONE_WIDTH_DP * density + 0.5f);
+ final int phonePortraitHeight = (int) (DEFAULT_PORTRAIT_PHONE_HEIGHT_DP * density + 0.5f);
+ final int phoneWidth = (orientation == SCREEN_ORIENTATION_LANDSCAPE) ? phonePortraitHeight
+ : phonePortraitWidth;
+ final int phoneHeight = (orientation == SCREEN_ORIENTATION_LANDSCAPE) ? phonePortraitWidth
+ : phonePortraitHeight;
+
+ // Minimum layout requirements.
+ final int layoutMinWidth = (layout == null) ? -1 : layout.minWidth;
+ final int layoutMinHeight = (layout == null) ? -1 : layout.minHeight;
+
+ // Final result.
+ final int width = Math.min(defaultWidth, Math.max(phoneWidth, layoutMinWidth));
+ final int height = Math.min(defaultHeight, Math.max(phoneHeight, layoutMinHeight));
+
+ bounds.set(0, 0, width, height);
+ }
+
+ /**
+ * Gets centered bounds of width x height. If inOutBounds is not empty, the result bounds
+ * centers at its center or display's center if inOutBounds is empty.
+ */
+ private void centerBounds(@NonNull ActivityDisplay display, int width, int height,
+ @NonNull Rect inOutBounds) {
+ if (inOutBounds.isEmpty()) {
+ display.getBounds(inOutBounds);
+ }
+ final int left = inOutBounds.centerX() - width / 2;
+ final int top = inOutBounds.centerY() - height / 2;
+ inOutBounds.set(left, top, left + width, top + height);
+ }
+
+ private void adjustBoundsToFitInDisplay(@NonNull ActivityDisplay display,
+ @NonNull Rect inOutBounds) {
+ final Rect displayBounds = display.getBounds();
+
+ if (displayBounds.width() < inOutBounds.width()
+ || displayBounds.height() < inOutBounds.height()) {
+ // There is no way for us to fit the bounds in the display without changing width
+ // or height. Don't even try it.
+ return;
+ }
+
+ final int dx;
+ if (inOutBounds.right > displayBounds.right) {
+ // Right edge is out of display.
+ dx = displayBounds.right - inOutBounds.right;
+ } else if (inOutBounds.left < displayBounds.left) {
+ // Left edge is out of display.
+ dx = displayBounds.left - inOutBounds.left;
+ } else {
+ // Vertical edges are all in display.
+ dx = 0;
+ }
+
+ final int dy;
+ if (inOutBounds.top < displayBounds.top) {
+ // Top edge is out of display.
+ dy = displayBounds.top - inOutBounds.top;
+ } else if (inOutBounds.bottom > displayBounds.bottom) {
+ // Bottom edge is out of display.
+ dy = displayBounds.bottom - inOutBounds.bottom;
+ } else {
+ // Horizontal edges are all in display.
+ dy = 0;
+ }
+ inOutBounds.offset(dx, dy);
+ }
+
+ /**
+ * Adjusts input bounds to avoid conflict with existing tasks in the display.
+ *
+ * If the input bounds conflict with existing tasks, this method scans the bounds in a series of
+ * directions to find a location where the we can put the bounds in display without conflict
+ * with any other tasks.
+ *
+ * It doesn't try to adjust bounds that's not fully in the given display.
+ *
+ * @param display the display which tasks are to check
+ * @param inOutBounds the bounds used to input initial bounds and output result bounds
+ */
+ private void adjustBoundsToAvoidConflict(@NonNull ActivityDisplay display,
+ @NonNull Rect inOutBounds) {
+ final Rect displayBounds = display.getBounds();
+ if (!displayBounds.contains(inOutBounds)) {
+ // The initial bounds are already out of display. The scanning algorithm below doesn't
+ // work so well with them.
+ return;
+ }
+
+ final List<TaskRecord> tasksToCheck = new ArrayList<>();
+ for (int i = 0; i < display.getChildCount(); ++i) {
+ ActivityStack<?> stack = display.getChildAt(i);
+ if (!stack.inFreeformWindowingMode()) {
+ continue;
+ }
+
+ for (int j = 0; j < stack.getChildCount(); ++j) {
+ tasksToCheck.add(stack.getChildAt(j));
+ }
+ }
+
+ if (!boundsConflict(tasksToCheck, inOutBounds)) {
+ // Current proposal doesn't conflict with any task. Early return to avoid unnecessary
+ // calculation.
+ return;
+ }
+
+ calculateCandidateShiftDirections(displayBounds, inOutBounds);
+ for (int direction : mTmpDirections) {
+ if (direction == Gravity.NO_GRAVITY) {
+ // We exhausted candidate directions, give up.
+ break;
+ }
+
+ mTmpBounds.set(inOutBounds);
+ while (boundsConflict(tasksToCheck, mTmpBounds) && displayBounds.contains(mTmpBounds)) {
+ shiftBounds(direction, displayBounds, mTmpBounds);
+ }
+
+ if (!boundsConflict(tasksToCheck, mTmpBounds) && displayBounds.contains(mTmpBounds)) {
+ // Found a candidate. Just use this.
+ inOutBounds.set(mTmpBounds);
+ if (DEBUG) appendLog("avoid-bounds-conflict=" + inOutBounds);
+ return;
+ }
+
+ // Didn't find a conflict free bounds here. Try the next candidate direction.
+ }
+
+ // We failed to find a conflict free location. Just keep the original result.
+ }
+
+ /**
+ * Determines scanning directions and their priorities to avoid bounds conflict.
+ *
+ * @param availableBounds bounds that the result must be in
+ * @param initialBounds initial bounds when start scanning
+ */
+ private void calculateCandidateShiftDirections(@NonNull Rect availableBounds,
+ @NonNull Rect initialBounds) {
+ for (int i = 0; i < mTmpDirections.length; ++i) {
+ mTmpDirections[i] = Gravity.NO_GRAVITY;
+ }
+
+ final int oneThirdWidth = (2 * availableBounds.left + availableBounds.right) / 3;
+ final int twoThirdWidth = (availableBounds.left + 2 * availableBounds.right) / 3;
+ final int centerX = initialBounds.centerX();
+ if (centerX < oneThirdWidth) {
+ // Too close to left, just scan to the right.
+ mTmpDirections[0] = Gravity.RIGHT;
+ return;
+ } else if (centerX > twoThirdWidth) {
+ // Too close to right, just scan to the left.
+ mTmpDirections[0] = Gravity.LEFT;
+ return;
+ }
+
+ final int oneThirdHeight = (2 * availableBounds.top + availableBounds.bottom) / 3;
+ final int twoThirdHeight = (availableBounds.top + 2 * availableBounds.bottom) / 3;
+ final int centerY = initialBounds.centerY();
+ if (centerY < oneThirdHeight || centerY > twoThirdHeight) {
+ // Too close to top or bottom boundary and we're in the middle horizontally, scan
+ // horizontally in both directions.
+ mTmpDirections[0] = Gravity.RIGHT;
+ mTmpDirections[1] = Gravity.LEFT;
+ return;
+ }
+
+ // We're in the center region both horizontally and vertically. Scan in both directions of
+ // primary diagonal.
+ mTmpDirections[0] = Gravity.BOTTOM | Gravity.RIGHT;
+ mTmpDirections[1] = Gravity.TOP | Gravity.LEFT;
+ }
+
+ private boolean boundsConflict(@NonNull List<TaskRecord> tasks, @NonNull Rect bounds) {
+ for (TaskRecord task : tasks) {
+ final Rect taskBounds = task.getBounds();
+ final boolean leftClose = Math.abs(taskBounds.left - bounds.left)
+ < BOUNDS_CONFLICT_THRESHOLD;
+ final boolean topClose = Math.abs(taskBounds.top - bounds.top)
+ < BOUNDS_CONFLICT_THRESHOLD;
+ final boolean rightClose = Math.abs(taskBounds.right - bounds.right)
+ < BOUNDS_CONFLICT_THRESHOLD;
+ final boolean bottomClose = Math.abs(taskBounds.bottom - bounds.bottom)
+ < BOUNDS_CONFLICT_THRESHOLD;
+
+ if ((leftClose && topClose) || (leftClose && bottomClose) || (rightClose && topClose)
+ || (rightClose && bottomClose)) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ private void shiftBounds(int direction, @NonNull Rect availableRect,
+ @NonNull Rect inOutBounds) {
+ final int horizontalOffset;
+ switch (direction & Gravity.HORIZONTAL_GRAVITY_MASK) {
+ case Gravity.LEFT:
+ horizontalOffset = -Math.max(MINIMAL_STEP,
+ availableRect.width() / STEP_DENOMINATOR);
+ break;
+ case Gravity.RIGHT:
+ horizontalOffset = Math.max(MINIMAL_STEP, availableRect.width() / STEP_DENOMINATOR);
+ break;
+ default:
+ horizontalOffset = 0;
+ }
+
+ final int verticalOffset;
+ switch (direction & Gravity.VERTICAL_GRAVITY_MASK) {
+ case Gravity.TOP:
+ verticalOffset = -Math.max(MINIMAL_STEP, availableRect.height() / STEP_DENOMINATOR);
+ break;
+ case Gravity.BOTTOM:
+ verticalOffset = Math.max(MINIMAL_STEP, availableRect.height() / STEP_DENOMINATOR);
+ break;
+ default:
+ verticalOffset = 0;
+ }
+
+ inOutBounds.offset(horizontalOffset, verticalOffset);
+ }
+
+ private void initLogBuilder(TaskRecord task, ActivityRecord activity) {
+ if (DEBUG) {
+ mLogBuilder = new StringBuilder("TaskLaunchParamsModifier:task=" + task
+ + " activity=" + activity);
+ }
+ }
+
+ private void appendLog(String log) {
+ if (DEBUG) mLogBuilder.append(" ").append(log);
+ }
+
+ private void outputLog() {
+ if (DEBUG) Slog.d(TAG, mLogBuilder.toString());
+ }
+
+ private static int orientationFromBounds(Rect bounds) {
+ return bounds.width() > bounds.height() ? SCREEN_ORIENTATION_LANDSCAPE
+ : SCREEN_ORIENTATION_PORTRAIT;
+ }
+
+ private static boolean sizeMatches(Rect left, Rect right) {
+ return (Math.abs(right.width() - left.width()) < EPSILON)
+ && (Math.abs(right.height() - left.height()) < EPSILON);
+ }
+}
diff --git a/services/core/java/com/android/server/wm/TaskPersister.java b/services/core/java/com/android/server/wm/TaskPersister.java
new file mode 100644
index 0000000..9705d42
--- /dev/null
+++ b/services/core/java/com/android/server/wm/TaskPersister.java
@@ -0,0 +1,641 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.server.wm;
+
+import static com.android.server.wm.ActivityStackSupervisor.MATCH_TASK_IN_STACKS_OR_RECENT_TASKS;
+
+import android.annotation.NonNull;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.os.Debug;
+import android.os.Environment;
+import android.os.FileUtils;
+import android.os.SystemClock;
+import android.util.ArraySet;
+import android.util.AtomicFile;
+import android.util.Slog;
+import android.util.SparseArray;
+import android.util.SparseBooleanArray;
+import android.util.Xml;
+
+import com.android.internal.annotations.VisibleForTesting;
+import com.android.internal.util.FastXmlSerializer;
+import com.android.internal.util.XmlUtils;
+
+import libcore.io.IoUtils;
+
+import org.xmlpull.v1.XmlPullParser;
+import org.xmlpull.v1.XmlPullParserException;
+import org.xmlpull.v1.XmlSerializer;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.StringWriter;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+/**
+ * Persister that saves recent tasks into disk.
+ */
+public class TaskPersister implements PersisterQueue.Listener {
+ static final String TAG = "TaskPersister";
+ static final boolean DEBUG = false;
+ static final String IMAGE_EXTENSION = ".png";
+
+ private static final String TASKS_DIRNAME = "recent_tasks";
+ private static final String TASK_FILENAME_SUFFIX = "_task.xml";
+ private static final String IMAGES_DIRNAME = "recent_images";
+ private static final String PERSISTED_TASK_IDS_FILENAME = "persisted_taskIds.txt";
+
+ private static final String TAG_TASK = "task";
+
+ private final ActivityTaskManagerService mService;
+ private final ActivityStackSupervisor mStackSupervisor;
+ private final RecentTasks mRecentTasks;
+ private final SparseArray<SparseBooleanArray> mTaskIdsInFile = new SparseArray<>();
+ private final File mTaskIdsDir;
+ // To lock file operations in TaskPersister
+ private final Object mIoLock = new Object();
+ private final PersisterQueue mPersisterQueue;
+
+ private final ArraySet<Integer> mTmpTaskIds = new ArraySet<>();
+
+ TaskPersister(File systemDir, ActivityStackSupervisor stackSupervisor,
+ ActivityTaskManagerService service, RecentTasks recentTasks) {
+
+ final File legacyImagesDir = new File(systemDir, IMAGES_DIRNAME);
+ if (legacyImagesDir.exists()) {
+ if (!FileUtils.deleteContents(legacyImagesDir) || !legacyImagesDir.delete()) {
+ Slog.i(TAG, "Failure deleting legacy images directory: " + legacyImagesDir);
+ }
+ }
+
+ final File legacyTasksDir = new File(systemDir, TASKS_DIRNAME);
+ if (legacyTasksDir.exists()) {
+ if (!FileUtils.deleteContents(legacyTasksDir) || !legacyTasksDir.delete()) {
+ Slog.i(TAG, "Failure deleting legacy tasks directory: " + legacyTasksDir);
+ }
+ }
+
+ mTaskIdsDir = new File(Environment.getDataDirectory(), "system_de");
+ mStackSupervisor = stackSupervisor;
+ mService = service;
+ mRecentTasks = recentTasks;
+ mPersisterQueue = new PersisterQueue();
+ mPersisterQueue.addListener(this);
+ }
+
+ @VisibleForTesting
+ TaskPersister(File workingDir) {
+ mTaskIdsDir = workingDir;
+ mStackSupervisor = null;
+ mService = null;
+ mRecentTasks = null;
+ mPersisterQueue = new PersisterQueue();
+ mPersisterQueue.addListener(this);
+ }
+
+ void onSystemReady() {
+ mPersisterQueue.startPersisting();
+ }
+
+ private void removeThumbnails(TaskRecord task) {
+ mPersisterQueue.removeItems(
+ item -> {
+ File file = new File(item.mFilePath);
+ return file.getName().startsWith(Integer.toString(task.taskId));
+ },
+ ImageWriteQueueItem.class);
+ }
+
+ @NonNull
+ SparseBooleanArray loadPersistedTaskIdsForUser(int userId) {
+ if (mTaskIdsInFile.get(userId) != null) {
+ return mTaskIdsInFile.get(userId).clone();
+ }
+ final SparseBooleanArray persistedTaskIds = new SparseBooleanArray();
+ synchronized (mIoLock) {
+ BufferedReader reader = null;
+ String line;
+ try {
+ reader = new BufferedReader(new FileReader(getUserPersistedTaskIdsFile(userId)));
+ while ((line = reader.readLine()) != null) {
+ for (String taskIdString : line.split("\\s+")) {
+ int id = Integer.parseInt(taskIdString);
+ persistedTaskIds.put(id, true);
+ }
+ }
+ } catch (FileNotFoundException e) {
+ // File doesn't exist. Ignore.
+ } catch (Exception e) {
+ Slog.e(TAG, "Error while reading taskIds file for user " + userId, e);
+ } finally {
+ IoUtils.closeQuietly(reader);
+ }
+ }
+ mTaskIdsInFile.put(userId, persistedTaskIds);
+ return persistedTaskIds.clone();
+ }
+
+
+ @VisibleForTesting
+ void writePersistedTaskIdsForUser(@NonNull SparseBooleanArray taskIds, int userId) {
+ if (userId < 0) {
+ return;
+ }
+ final File persistedTaskIdsFile = getUserPersistedTaskIdsFile(userId);
+ synchronized (mIoLock) {
+ BufferedWriter writer = null;
+ try {
+ writer = new BufferedWriter(new FileWriter(persistedTaskIdsFile));
+ for (int i = 0; i < taskIds.size(); i++) {
+ if (taskIds.valueAt(i)) {
+ writer.write(String.valueOf(taskIds.keyAt(i)));
+ writer.newLine();
+ }
+ }
+ } catch (Exception e) {
+ Slog.e(TAG, "Error while writing taskIds file for user " + userId, e);
+ } finally {
+ IoUtils.closeQuietly(writer);
+ }
+ }
+ }
+
+ void unloadUserDataFromMemory(int userId) {
+ mTaskIdsInFile.delete(userId);
+ }
+
+ void wakeup(TaskRecord task, boolean flush) {
+ synchronized (mPersisterQueue) {
+ if (task != null) {
+ final TaskWriteQueueItem item = mPersisterQueue.findLastItem(
+ queueItem -> task == queueItem.mTask, TaskWriteQueueItem.class);
+ if (item != null && !task.inRecents) {
+ removeThumbnails(task);
+ }
+
+ if (item == null && task.isPersistable) {
+ mPersisterQueue.addItem(new TaskWriteQueueItem(task, mService), flush);
+ }
+ } else {
+ // Dummy. Ensures removeObsoleteFiles is called when LazyTaskThreadWriter is
+ // notified.
+ mPersisterQueue.addItem(PersisterQueue.EMPTY_ITEM, flush);
+ }
+ if (DEBUG) {
+ Slog.d(TAG, "wakeup: task=" + task + " flush=" + flush + " Callers="
+ + Debug.getCallers(4));
+ }
+ }
+
+ mPersisterQueue.yieldIfQueueTooDeep();
+ }
+
+ void flush() {
+ mPersisterQueue.flush();
+ }
+
+ void saveImage(Bitmap image, String filePath) {
+ synchronized (mPersisterQueue) {
+ final ImageWriteQueueItem item = mPersisterQueue.findLastItem(
+ queueItem -> queueItem.mFilePath.equals(filePath), ImageWriteQueueItem.class);
+ if (item != null) {
+ // replace the Bitmap with the new one.
+ item.mImage = image;
+ } else {
+ mPersisterQueue.addItem(new ImageWriteQueueItem(filePath, image),
+ /* flush */ false);
+ }
+ if (DEBUG) Slog.d(TAG, "saveImage: filePath=" + filePath + " now=" +
+ SystemClock.uptimeMillis() + " Callers=" + Debug.getCallers(4));
+ }
+
+ mPersisterQueue.yieldIfQueueTooDeep();
+ }
+
+ Bitmap getTaskDescriptionIcon(String filePath) {
+ // See if it is in the write queue
+ final Bitmap icon = getImageFromWriteQueue(filePath);
+ if (icon != null) {
+ return icon;
+ }
+ return restoreImage(filePath);
+ }
+
+ private Bitmap getImageFromWriteQueue(String filePath) {
+ final ImageWriteQueueItem item = mPersisterQueue.findLastItem(
+ queueItem -> queueItem.mFilePath.equals(filePath), ImageWriteQueueItem.class);
+ return item != null ? item.mImage : null;
+ }
+
+ private String fileToString(File file) {
+ final String newline = System.lineSeparator();
+ try {
+ BufferedReader reader = new BufferedReader(new FileReader(file));
+ StringBuffer sb = new StringBuffer((int) file.length() * 2);
+ String line;
+ while ((line = reader.readLine()) != null) {
+ sb.append(line + newline);
+ }
+ reader.close();
+ return sb.toString();
+ } catch (IOException ioe) {
+ Slog.e(TAG, "Couldn't read file " + file.getName());
+ return null;
+ }
+ }
+
+ private TaskRecord taskIdToTask(int taskId, ArrayList<TaskRecord> tasks) {
+ if (taskId < 0) {
+ return null;
+ }
+ for (int taskNdx = tasks.size() - 1; taskNdx >= 0; --taskNdx) {
+ final TaskRecord task = tasks.get(taskNdx);
+ if (task.taskId == taskId) {
+ return task;
+ }
+ }
+ Slog.e(TAG, "Restore affiliation error looking for taskId=" + taskId);
+ return null;
+ }
+
+ List<TaskRecord> restoreTasksForUserLocked(final int userId, SparseBooleanArray preaddedTasks) {
+ final ArrayList<TaskRecord> tasks = new ArrayList<TaskRecord>();
+ ArraySet<Integer> recoveredTaskIds = new ArraySet<Integer>();
+
+ File userTasksDir = getUserTasksDir(userId);
+
+ File[] recentFiles = userTasksDir.listFiles();
+ if (recentFiles == null) {
+ Slog.e(TAG, "restoreTasksForUserLocked: Unable to list files from " + userTasksDir);
+ return tasks;
+ }
+
+ for (int taskNdx = 0; taskNdx < recentFiles.length; ++taskNdx) {
+ File taskFile = recentFiles[taskNdx];
+ if (DEBUG) {
+ Slog.d(TAG, "restoreTasksForUserLocked: userId=" + userId
+ + ", taskFile=" + taskFile.getName());
+ }
+
+ if (!taskFile.getName().endsWith(TASK_FILENAME_SUFFIX)) {
+ continue;
+ }
+ try {
+ final int taskId = Integer.parseInt(taskFile.getName().substring(
+ 0 /* beginIndex */,
+ taskFile.getName().length() - TASK_FILENAME_SUFFIX.length()));
+ if (preaddedTasks.get(taskId, false)) {
+ Slog.w(TAG, "Task #" + taskId +
+ " has already been created so we don't restore again");
+ continue;
+ }
+ } catch (NumberFormatException e) {
+ Slog.w(TAG, "Unexpected task file name", e);
+ continue;
+ }
+
+ BufferedReader reader = null;
+ boolean deleteFile = false;
+ try {
+ reader = new BufferedReader(new FileReader(taskFile));
+ final XmlPullParser in = Xml.newPullParser();
+ in.setInput(reader);
+
+ int event;
+ while (((event = in.next()) != XmlPullParser.END_DOCUMENT) &&
+ event != XmlPullParser.END_TAG) {
+ final String name = in.getName();
+ if (event == XmlPullParser.START_TAG) {
+ if (DEBUG) Slog.d(TAG, "restoreTasksForUserLocked: START_TAG name=" + name);
+ if (TAG_TASK.equals(name)) {
+ final TaskRecord task = TaskRecord.restoreFromXml(in, mStackSupervisor);
+ if (DEBUG) Slog.d(TAG, "restoreTasksForUserLocked: restored task="
+ + task);
+ if (task != null) {
+ // XXX Don't add to write queue... there is no reason to write
+ // out the stuff we just read, if we don't write it we will
+ // read the same thing again.
+ // mWriteQueue.add(new TaskWriteQueueItem(task));
+
+ final int taskId = task.taskId;
+ if (mStackSupervisor.anyTaskForIdLocked(taskId,
+ MATCH_TASK_IN_STACKS_OR_RECENT_TASKS) != null) {
+ // Should not happen.
+ Slog.wtf(TAG, "Existing task with taskId " + taskId + "found");
+ } else if (userId != task.userId) {
+ // Should not happen.
+ Slog.wtf(TAG, "Task with userId " + task.userId + " found in "
+ + userTasksDir.getAbsolutePath());
+ } else {
+ // Looks fine.
+ mStackSupervisor.setNextTaskIdForUserLocked(taskId, userId);
+ task.isPersistable = true;
+ tasks.add(task);
+ recoveredTaskIds.add(taskId);
+ }
+ } else {
+ Slog.e(TAG, "restoreTasksForUserLocked: Unable to restore taskFile="
+ + taskFile + ": " + fileToString(taskFile));
+ }
+ } else {
+ Slog.wtf(TAG, "restoreTasksForUserLocked: Unknown xml event=" + event
+ + " name=" + name);
+ }
+ }
+ XmlUtils.skipCurrentTag(in);
+ }
+ } catch (Exception e) {
+ Slog.wtf(TAG, "Unable to parse " + taskFile + ". Error ", e);
+ Slog.e(TAG, "Failing file: " + fileToString(taskFile));
+ deleteFile = true;
+ } finally {
+ IoUtils.closeQuietly(reader);
+ if (deleteFile) {
+ if (DEBUG) Slog.d(TAG, "Deleting file=" + taskFile.getName());
+ taskFile.delete();
+ }
+ }
+ }
+
+ if (!DEBUG) {
+ removeObsoleteFiles(recoveredTaskIds, userTasksDir.listFiles());
+ }
+
+ // Fix up task affiliation from taskIds
+ for (int taskNdx = tasks.size() - 1; taskNdx >= 0; --taskNdx) {
+ final TaskRecord task = tasks.get(taskNdx);
+ task.setPrevAffiliate(taskIdToTask(task.mPrevAffiliateTaskId, tasks));
+ task.setNextAffiliate(taskIdToTask(task.mNextAffiliateTaskId, tasks));
+ }
+
+ Collections.sort(tasks, new Comparator<TaskRecord>() {
+ @Override
+ public int compare(TaskRecord lhs, TaskRecord rhs) {
+ final long diff = rhs.mLastTimeMoved - lhs.mLastTimeMoved;
+ if (diff < 0) {
+ return -1;
+ } else if (diff > 0) {
+ return +1;
+ } else {
+ return 0;
+ }
+ }
+ });
+ return tasks;
+ }
+
+ @Override
+ public void onPreProcessItem(boolean queueEmpty) {
+ // We can't lock mService while locking the queue, but we don't want to
+ // call removeObsoleteFiles before every item, only the last time
+ // before going to sleep. The risk is that we call removeObsoleteFiles()
+ // successively.
+ if (queueEmpty) {
+ if (DEBUG) Slog.d(TAG, "Looking for obsolete files.");
+ mTmpTaskIds.clear();
+ synchronized (mService.mGlobalLock) {
+ if (DEBUG) Slog.d(TAG, "mRecents=" + mRecentTasks);
+ mRecentTasks.getPersistableTaskIds(mTmpTaskIds);
+ mService.mWindowManager.removeObsoleteTaskFiles(mTmpTaskIds,
+ mRecentTasks.usersWithRecentsLoadedLocked());
+ }
+ removeObsoleteFiles(mTmpTaskIds);
+ }
+ writeTaskIdsFiles();
+ }
+
+ private static void removeObsoleteFiles(ArraySet<Integer> persistentTaskIds, File[] files) {
+ if (DEBUG) Slog.d(TAG, "removeObsoleteFiles: persistentTaskIds=" + persistentTaskIds +
+ " files=" + files);
+ if (files == null) {
+ Slog.e(TAG, "File error accessing recents directory (directory doesn't exist?).");
+ return;
+ }
+ for (int fileNdx = 0; fileNdx < files.length; ++fileNdx) {
+ File file = files[fileNdx];
+ String filename = file.getName();
+ final int taskIdEnd = filename.indexOf('_');
+ if (taskIdEnd > 0) {
+ final int taskId;
+ try {
+ taskId = Integer.parseInt(filename.substring(0, taskIdEnd));
+ if (DEBUG) Slog.d(TAG, "removeObsoleteFiles: Found taskId=" + taskId);
+ } catch (Exception e) {
+ Slog.wtf(TAG, "removeObsoleteFiles: Can't parse file=" + file.getName());
+ file.delete();
+ continue;
+ }
+ if (!persistentTaskIds.contains(taskId)) {
+ if (DEBUG) Slog.d(TAG, "removeObsoleteFiles: deleting file=" + file.getName());
+ file.delete();
+ }
+ }
+ }
+ }
+
+ private void writeTaskIdsFiles() {
+ SparseArray<SparseBooleanArray> changedTaskIdsPerUser = new SparseArray<>();
+ synchronized (mService.mGlobalLock) {
+ for (int userId : mRecentTasks.usersWithRecentsLoadedLocked()) {
+ SparseBooleanArray taskIdsToSave = mRecentTasks.getTaskIdsForUser(userId);
+ SparseBooleanArray persistedIdsInFile = mTaskIdsInFile.get(userId);
+ if (persistedIdsInFile != null && persistedIdsInFile.equals(taskIdsToSave)) {
+ continue;
+ } else {
+ SparseBooleanArray taskIdsToSaveCopy = taskIdsToSave.clone();
+ mTaskIdsInFile.put(userId, taskIdsToSaveCopy);
+ changedTaskIdsPerUser.put(userId, taskIdsToSaveCopy);
+ }
+ }
+ }
+ for (int i = 0; i < changedTaskIdsPerUser.size(); i++) {
+ writePersistedTaskIdsForUser(changedTaskIdsPerUser.valueAt(i),
+ changedTaskIdsPerUser.keyAt(i));
+ }
+ }
+
+ private void removeObsoleteFiles(ArraySet<Integer> persistentTaskIds) {
+ int[] candidateUserIds;
+ synchronized (mService.mGlobalLock) {
+ // Remove only from directories of the users who have recents in memory synchronized
+ // with persistent storage.
+ candidateUserIds = mRecentTasks.usersWithRecentsLoadedLocked();
+ }
+ for (int userId : candidateUserIds) {
+ removeObsoleteFiles(persistentTaskIds, getUserImagesDir(userId).listFiles());
+ removeObsoleteFiles(persistentTaskIds, getUserTasksDir(userId).listFiles());
+ }
+ }
+
+ static Bitmap restoreImage(String filename) {
+ if (DEBUG) Slog.d(TAG, "restoreImage: restoring " + filename);
+ return BitmapFactory.decodeFile(filename);
+ }
+
+ private File getUserPersistedTaskIdsFile(int userId) {
+ File userTaskIdsDir = new File(mTaskIdsDir, String.valueOf(userId));
+ if (!userTaskIdsDir.exists() && !userTaskIdsDir.mkdirs()) {
+ Slog.e(TAG, "Error while creating user directory: " + userTaskIdsDir);
+ }
+ return new File(userTaskIdsDir, PERSISTED_TASK_IDS_FILENAME);
+ }
+
+ static File getUserTasksDir(int userId) {
+ File userTasksDir = new File(Environment.getDataSystemCeDirectory(userId), TASKS_DIRNAME);
+
+ if (!userTasksDir.exists()) {
+ if (!userTasksDir.mkdir()) {
+ Slog.e(TAG, "Failure creating tasks directory for user " + userId + ": "
+ + userTasksDir);
+ }
+ }
+ return userTasksDir;
+ }
+
+ static File getUserImagesDir(int userId) {
+ return new File(Environment.getDataSystemCeDirectory(userId), IMAGES_DIRNAME);
+ }
+
+ private static boolean createParentDirectory(String filePath) {
+ File parentDir = new File(filePath).getParentFile();
+ return parentDir.exists() || parentDir.mkdirs();
+ }
+
+ private static class TaskWriteQueueItem implements PersisterQueue.WriteQueueItem {
+ private final ActivityTaskManagerService mService;
+ private final TaskRecord mTask;
+
+ TaskWriteQueueItem(TaskRecord task, ActivityTaskManagerService service) {
+ mTask = task;
+ mService = service;
+ }
+
+ private StringWriter saveToXml(TaskRecord task) throws IOException, XmlPullParserException {
+ if (DEBUG) Slog.d(TAG, "saveToXml: task=" + task);
+ final XmlSerializer xmlSerializer = new FastXmlSerializer();
+ StringWriter stringWriter = new StringWriter();
+ xmlSerializer.setOutput(stringWriter);
+
+ if (DEBUG) {
+ xmlSerializer.setFeature(
+ "http://xmlpull.org/v1/doc/features.html#indent-output", true);
+ }
+
+ // save task
+ xmlSerializer.startDocument(null, true);
+
+ xmlSerializer.startTag(null, TAG_TASK);
+ task.saveToXml(xmlSerializer);
+ xmlSerializer.endTag(null, TAG_TASK);
+
+ xmlSerializer.endDocument();
+ xmlSerializer.flush();
+
+ return stringWriter;
+ }
+
+ @Override
+ public void process() {
+ // Write out one task.
+ StringWriter stringWriter = null;
+ TaskRecord task = mTask;
+ if (DEBUG) Slog.d(TAG, "Writing task=" + task);
+ synchronized (mService.mGlobalLock) {
+ if (task.inRecents) {
+ // Still there.
+ try {
+ if (DEBUG) Slog.d(TAG, "Saving task=" + task);
+ stringWriter = saveToXml(task);
+ } catch (IOException e) {
+ } catch (XmlPullParserException e) {
+ }
+ }
+ }
+ if (stringWriter != null) {
+ // Write out xml file while not holding mService lock.
+ FileOutputStream file = null;
+ AtomicFile atomicFile = null;
+ try {
+ atomicFile = new AtomicFile(new File(
+ getUserTasksDir(task.userId),
+ String.valueOf(task.taskId) + TASK_FILENAME_SUFFIX));
+ file = atomicFile.startWrite();
+ file.write(stringWriter.toString().getBytes());
+ file.write('\n');
+ atomicFile.finishWrite(file);
+ } catch (IOException e) {
+ if (file != null) {
+ atomicFile.failWrite(file);
+ }
+ Slog.e(TAG,
+ "Unable to open " + atomicFile + " for persisting. " + e);
+ }
+ }
+ }
+
+ @Override
+ public String toString() {
+ return "TaskWriteQueueItem{task=" + mTask + "}";
+ }
+ }
+
+ private static class ImageWriteQueueItem implements PersisterQueue.WriteQueueItem {
+ final String mFilePath;
+ Bitmap mImage;
+
+ ImageWriteQueueItem(String filePath, Bitmap image) {
+ mFilePath = filePath;
+ mImage = image;
+ }
+
+ @Override
+ public void process() {
+ final String filePath = mFilePath;
+ if (!createParentDirectory(filePath)) {
+ Slog.e(TAG, "Error while creating images directory for file: " + filePath);
+ return;
+ }
+ final Bitmap bitmap = mImage;
+ if (DEBUG) Slog.d(TAG, "writing bitmap: filename=" + filePath);
+ FileOutputStream imageFile = null;
+ try {
+ imageFile = new FileOutputStream(new File(filePath));
+ bitmap.compress(Bitmap.CompressFormat.PNG, 100, imageFile);
+ } catch (Exception e) {
+ Slog.e(TAG, "saveImage: unable to save " + filePath, e);
+ } finally {
+ IoUtils.closeQuietly(imageFile);
+ }
+ }
+
+ @Override
+ public String toString() {
+ return "ImageWriteQueueItem{path=" + mFilePath
+ + ", image=(" + mImage.getWidth() + "x" + mImage.getHeight() + ")}";
+ }
+ }
+}
diff --git a/services/core/java/com/android/server/wm/TaskRecord.java b/services/core/java/com/android/server/wm/TaskRecord.java
new file mode 100644
index 0000000..d697f28
--- /dev/null
+++ b/services/core/java/com/android/server/wm/TaskRecord.java
@@ -0,0 +1,2543 @@
+/*
+ * Copyright (C) 2006 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.server.wm;
+
+import static android.app.ActivityTaskManager.INVALID_STACK_ID;
+import static android.app.ActivityTaskManager.INVALID_TASK_ID;
+import static android.app.ActivityTaskManager.RESIZE_MODE_FORCED;
+import static android.app.ActivityTaskManager.RESIZE_MODE_SYSTEM;
+import static android.app.WindowConfiguration.ACTIVITY_TYPE_STANDARD;
+import static android.app.WindowConfiguration.ACTIVITY_TYPE_UNDEFINED;
+import static android.app.WindowConfiguration.WINDOWING_MODE_FREEFORM;
+import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN;
+import static android.app.WindowConfiguration.WINDOWING_MODE_PINNED;
+import static android.app.WindowConfiguration.WINDOWING_MODE_SPLIT_SCREEN_PRIMARY;
+import static android.app.WindowConfiguration.WINDOWING_MODE_SPLIT_SCREEN_SECONDARY;
+import static android.content.Intent.FLAG_ACTIVITY_NEW_DOCUMENT;
+import static android.content.Intent.FLAG_ACTIVITY_NEW_TASK;
+import static android.content.Intent.FLAG_ACTIVITY_RETAIN_IN_RECENTS;
+import static android.content.Intent.FLAG_ACTIVITY_TASK_ON_HOME;
+import static android.content.pm.ActivityInfo.FLAG_RELINQUISH_TASK_IDENTITY;
+import static android.content.pm.ActivityInfo.LOCK_TASK_LAUNCH_MODE_ALWAYS;
+import static android.content.pm.ActivityInfo.LOCK_TASK_LAUNCH_MODE_DEFAULT;
+import static android.content.pm.ActivityInfo.LOCK_TASK_LAUNCH_MODE_IF_WHITELISTED;
+import static android.content.pm.ActivityInfo.LOCK_TASK_LAUNCH_MODE_NEVER;
+import static android.content.pm.ActivityInfo.RESIZE_MODE_FORCE_RESIZABLE_LANDSCAPE_ONLY;
+import static android.content.pm.ActivityInfo.RESIZE_MODE_FORCE_RESIZABLE_PORTRAIT_ONLY;
+import static android.content.pm.ActivityInfo.RESIZE_MODE_FORCE_RESIZABLE_PRESERVE_ORIENTATION;
+import static android.content.pm.ActivityInfo.RESIZE_MODE_FORCE_RESIZEABLE;
+import static android.content.pm.ActivityInfo.RESIZE_MODE_RESIZEABLE;
+import static android.content.pm.ActivityInfo.RESIZE_MODE_RESIZEABLE_AND_PIPABLE_DEPRECATED;
+import static android.content.pm.ActivityInfo.RESIZE_MODE_RESIZEABLE_VIA_SDK_VERSION;
+import static android.os.Trace.TRACE_TAG_ACTIVITY_MANAGER;
+import static android.provider.Settings.Secure.USER_SETUP_COMPLETE;
+import static android.view.Display.DEFAULT_DISPLAY;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_ADD_REMOVE;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_LOCKTASK;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_RECENTS;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_TASKS;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_ADD_REMOVE;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_LOCKTASK;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_RECENTS;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_TASKS;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_ATM;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_WITH_CLASS_NAME;
+import static com.android.server.wm.ActivityRecord.STARTING_WINDOW_SHOWN;
+import static com.android.server.wm.ActivityStack.REMOVE_TASK_MODE_MOVING;
+import static com.android.server.wm.ActivityStack.REMOVE_TASK_MODE_MOVING_TO_TOP;
+import static com.android.server.wm.ActivityStackSupervisor.ON_TOP;
+import static com.android.server.wm.ActivityStackSupervisor.PAUSE_IMMEDIATELY;
+import static com.android.server.wm.ActivityStackSupervisor.PRESERVE_WINDOWS;
+import static com.android.server.am.TaskRecordProto.ACTIVITIES;
+import static com.android.server.am.TaskRecordProto.ACTIVITY_TYPE;
+import static com.android.server.am.TaskRecordProto.BOUNDS;
+import static com.android.server.am.TaskRecordProto.CONFIGURATION_CONTAINER;
+import static com.android.server.am.TaskRecordProto.FULLSCREEN;
+import static com.android.server.am.TaskRecordProto.ID;
+import static com.android.server.am.TaskRecordProto.LAST_NON_FULLSCREEN_BOUNDS;
+import static com.android.server.am.TaskRecordProto.MIN_HEIGHT;
+import static com.android.server.am.TaskRecordProto.MIN_WIDTH;
+import static com.android.server.am.TaskRecordProto.ORIG_ACTIVITY;
+import static com.android.server.am.TaskRecordProto.REAL_ACTIVITY;
+import static com.android.server.am.TaskRecordProto.RESIZE_MODE;
+import static com.android.server.am.TaskRecordProto.STACK_ID;
+import static java.lang.Integer.MAX_VALUE;
+
+import android.annotation.IntDef;
+import android.annotation.Nullable;
+import android.app.Activity;
+import android.app.ActivityManager;
+import android.app.ActivityManager.TaskDescription;
+import android.app.ActivityManager.TaskSnapshot;
+import android.app.ActivityOptions;
+import android.app.ActivityTaskManager;
+import android.app.AppGlobals;
+import android.app.TaskInfo;
+import android.content.ComponentName;
+import android.content.Intent;
+import android.content.pm.ActivityInfo;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.IPackageManager;
+import android.content.pm.PackageManager;
+import android.content.res.Configuration;
+import android.graphics.Rect;
+import android.os.Debug;
+import android.os.RemoteException;
+import android.os.SystemClock;
+import android.os.Trace;
+import android.os.UserHandle;
+import android.provider.Settings;
+import android.service.voice.IVoiceInteractionSession;
+import android.util.DisplayMetrics;
+import android.util.Slog;
+import android.util.proto.ProtoOutputStream;
+
+import com.android.internal.annotations.VisibleForTesting;
+import com.android.internal.app.IVoiceInteractor;
+import com.android.internal.util.XmlUtils;
+import com.android.server.wm.ActivityStack.ActivityState;
+
+import org.xmlpull.v1.XmlPullParser;
+import org.xmlpull.v1.XmlPullParserException;
+import org.xmlpull.v1.XmlSerializer;
+
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.ArrayList;
+import java.util.Objects;
+
+// TODO: Make package private again once move to WM package is complete.
+public class TaskRecord extends ConfigurationContainer implements TaskWindowContainerListener {
+ private static final String TAG = TAG_WITH_CLASS_NAME ? "TaskRecord" : TAG_ATM;
+ private static final String TAG_ADD_REMOVE = TAG + POSTFIX_ADD_REMOVE;
+ private static final String TAG_RECENTS = TAG + POSTFIX_RECENTS;
+ private static final String TAG_LOCKTASK = TAG + POSTFIX_LOCKTASK;
+ private static final String TAG_TASKS = TAG + POSTFIX_TASKS;
+
+ private static final String ATTR_TASKID = "task_id";
+ private static final String TAG_INTENT = "intent";
+ private static final String TAG_AFFINITYINTENT = "affinity_intent";
+ private static final String ATTR_REALACTIVITY = "real_activity";
+ private static final String ATTR_REALACTIVITY_SUSPENDED = "real_activity_suspended";
+ private static final String ATTR_ORIGACTIVITY = "orig_activity";
+ private static final String TAG_ACTIVITY = "activity";
+ private static final String ATTR_AFFINITY = "affinity";
+ private static final String ATTR_ROOT_AFFINITY = "root_affinity";
+ private static final String ATTR_ROOTHASRESET = "root_has_reset";
+ private static final String ATTR_AUTOREMOVERECENTS = "auto_remove_recents";
+ private static final String ATTR_ASKEDCOMPATMODE = "asked_compat_mode";
+ private static final String ATTR_USERID = "user_id";
+ private static final String ATTR_USER_SETUP_COMPLETE = "user_setup_complete";
+ private static final String ATTR_EFFECTIVE_UID = "effective_uid";
+ @Deprecated
+ private static final String ATTR_TASKTYPE = "task_type";
+ private static final String ATTR_LASTDESCRIPTION = "last_description";
+ private static final String ATTR_LASTTIMEMOVED = "last_time_moved";
+ private static final String ATTR_NEVERRELINQUISH = "never_relinquish_identity";
+ private static final String ATTR_TASK_AFFILIATION = "task_affiliation";
+ private static final String ATTR_PREV_AFFILIATION = "prev_affiliation";
+ private static final String ATTR_NEXT_AFFILIATION = "next_affiliation";
+ private static final String ATTR_TASK_AFFILIATION_COLOR = "task_affiliation_color";
+ private static final String ATTR_CALLING_UID = "calling_uid";
+ private static final String ATTR_CALLING_PACKAGE = "calling_package";
+ private static final String ATTR_SUPPORTS_PICTURE_IN_PICTURE = "supports_picture_in_picture";
+ private static final String ATTR_RESIZE_MODE = "resize_mode";
+ private static final String ATTR_NON_FULLSCREEN_BOUNDS = "non_fullscreen_bounds";
+ private static final String ATTR_MIN_WIDTH = "min_width";
+ private static final String ATTR_MIN_HEIGHT = "min_height";
+ private static final String ATTR_PERSIST_TASK_VERSION = "persist_task_version";
+
+ // Current version of the task record we persist. Used to check if we need to run any upgrade
+ // code.
+ private static final int PERSIST_TASK_VERSION = 1;
+
+ private static final int INVALID_MIN_SIZE = -1;
+
+ /**
+ * The modes to control how the stack is moved to the front when calling
+ * {@link TaskRecord#reparent}.
+ */
+ @Retention(RetentionPolicy.SOURCE)
+ @IntDef({
+ REPARENT_MOVE_STACK_TO_FRONT,
+ REPARENT_KEEP_STACK_AT_FRONT,
+ REPARENT_LEAVE_STACK_IN_PLACE
+ })
+ @interface ReparentMoveStackMode {}
+ // Moves the stack to the front if it was not at the front
+ static final int REPARENT_MOVE_STACK_TO_FRONT = 0;
+ // Only moves the stack to the front if it was focused or front most already
+ static final int REPARENT_KEEP_STACK_AT_FRONT = 1;
+ // Do not move the stack as a part of reparenting
+ static final int REPARENT_LEAVE_STACK_IN_PLACE = 2;
+
+ /**
+ * The factory used to create {@link TaskRecord}. This allows OEM subclass {@link TaskRecord}.
+ */
+ private static TaskRecordFactory sTaskRecordFactory;
+
+ final int taskId; // Unique identifier for this task.
+ String affinity; // The affinity name for this task, or null; may change identity.
+ String rootAffinity; // Initial base affinity, or null; does not change from initial root.
+ final IVoiceInteractionSession voiceSession; // Voice interaction session driving task
+ final IVoiceInteractor voiceInteractor; // Associated interactor to provide to app
+ Intent intent; // The original intent that started the task. Note that this value can
+ // be null.
+ Intent affinityIntent; // Intent of affinity-moved activity that started this task.
+ int effectiveUid; // The current effective uid of the identity of this task.
+ ComponentName origActivity; // The non-alias activity component of the intent.
+ ComponentName realActivity; // The actual activity component that started the task.
+ boolean realActivitySuspended; // True if the actual activity component that started the
+ // task is suspended.
+ boolean inRecents; // Actually in the recents list?
+ long lastActiveTime; // Last time this task was active in the current device session,
+ // including sleep. This time is initialized to the elapsed time when
+ // restored from disk.
+ boolean isAvailable; // Is the activity available to be launched?
+ boolean rootWasReset; // True if the intent at the root of the task had
+ // the FLAG_ACTIVITY_RESET_TASK_IF_NEEDED flag.
+ boolean autoRemoveRecents; // If true, we should automatically remove the task from
+ // recents when activity finishes
+ boolean askedCompatMode;// Have asked the user about compat mode for this task.
+ boolean hasBeenVisible; // Set if any activities in the task have been visible to the user.
+
+ String stringName; // caching of toString() result.
+ int userId; // user for which this task was created
+ boolean mUserSetupComplete; // The user set-up is complete as of the last time the task activity
+ // was changed.
+
+ int numFullscreen; // Number of fullscreen activities.
+
+ int mResizeMode; // The resize mode of this task and its activities.
+ // Based on the {@link ActivityInfo#resizeMode} of the root activity.
+ private boolean mSupportsPictureInPicture; // Whether or not this task and its activities
+ // support PiP. Based on the {@link ActivityInfo#FLAG_SUPPORTS_PICTURE_IN_PICTURE} flag
+ // of the root activity.
+ /** Can't be put in lockTask mode. */
+ final static int LOCK_TASK_AUTH_DONT_LOCK = 0;
+ /** Can enter app pinning with user approval. Can never start over existing lockTask task. */
+ final static int LOCK_TASK_AUTH_PINNABLE = 1;
+ /** Starts in LOCK_TASK_MODE_LOCKED automatically. Can start over existing lockTask task. */
+ final static int LOCK_TASK_AUTH_LAUNCHABLE = 2;
+ /** Can enter lockTask without user approval. Can start over existing lockTask task. */
+ final static int LOCK_TASK_AUTH_WHITELISTED = 3;
+ /** Priv-app that starts in LOCK_TASK_MODE_LOCKED automatically. Can start over existing
+ * lockTask task. */
+ final static int LOCK_TASK_AUTH_LAUNCHABLE_PRIV = 4;
+ int mLockTaskAuth = LOCK_TASK_AUTH_PINNABLE;
+
+ int mLockTaskUid = -1; // The uid of the application that called startLockTask().
+
+ // This represents the last resolved activity values for this task
+ // NOTE: This value needs to be persisted with each task
+ TaskDescription lastTaskDescription = new TaskDescription();
+
+ /** List of all activities in the task arranged in history order */
+ final ArrayList<ActivityRecord> mActivities;
+
+ /** Current stack. Setter must always be used to update the value. */
+ private ActivityStack mStack;
+
+ /** The process that had previously hosted the root activity of this task.
+ * Used to know that we should try harder to keep this process around, in case the
+ * user wants to return to it. */
+ private WindowProcessController mRootProcess;
+
+ /** Takes on same value as first root activity */
+ boolean isPersistable = false;
+ int maxRecents;
+
+ /** Only used for persistable tasks, otherwise 0. The last time this task was moved. Used for
+ * determining the order when restoring. Sign indicates whether last task movement was to front
+ * (positive) or back (negative). Absolute value indicates time. */
+ long mLastTimeMoved = System.currentTimeMillis();
+
+ /** If original intent did not allow relinquishing task identity, save that information */
+ private boolean mNeverRelinquishIdentity = true;
+
+ // Used in the unique case where we are clearing the task in order to reuse it. In that case we
+ // do not want to delete the stack when the task goes empty.
+ private boolean mReuseTask = false;
+
+ CharSequence lastDescription; // Last description captured for this item.
+
+ int mAffiliatedTaskId; // taskId of parent affiliation or self if no parent.
+ int mAffiliatedTaskColor; // color of the parent task affiliation.
+ TaskRecord mPrevAffiliate; // previous task in affiliated chain.
+ int mPrevAffiliateTaskId = INVALID_TASK_ID; // previous id for persistence.
+ TaskRecord mNextAffiliate; // next task in affiliated chain.
+ int mNextAffiliateTaskId = INVALID_TASK_ID; // next id for persistence.
+
+ // For relaunching the task from recents as though it was launched by the original launcher.
+ int mCallingUid;
+ String mCallingPackage;
+
+ final ActivityTaskManagerService mService;
+
+ private final Rect mTmpStableBounds = new Rect();
+ private final Rect mTmpNonDecorBounds = new Rect();
+ private final Rect mTmpRect = new Rect();
+
+ // Last non-fullscreen bounds the task was launched in or resized to.
+ // The information is persisted and used to determine the appropriate stack to launch the
+ // task into on restore.
+ Rect mLastNonFullscreenBounds = null;
+ // Minimal width and height of this task when it's resizeable. -1 means it should use the
+ // default minimal width/height.
+ int mMinWidth;
+ int mMinHeight;
+
+ // Ranking (from top) of this task among all visible tasks. (-1 means it's not visible)
+ // This number will be assigned when we evaluate OOM scores for all visible tasks.
+ int mLayerRank = -1;
+
+ /** Helper object used for updating override configuration. */
+ private Configuration mTmpConfig = new Configuration();
+
+ private TaskWindowContainerController mWindowContainerController;
+
+ /**
+ * Don't use constructor directly. Use {@link #create(ActivityTaskManagerService, int,
+ * ActivityInfo, Intent, TaskDescription)} instead.
+ */
+ TaskRecord(ActivityTaskManagerService service, int _taskId, ActivityInfo info, Intent _intent,
+ IVoiceInteractionSession _voiceSession, IVoiceInteractor _voiceInteractor) {
+ mService = service;
+ userId = UserHandle.getUserId(info.applicationInfo.uid);
+ taskId = _taskId;
+ lastActiveTime = SystemClock.elapsedRealtime();
+ mAffiliatedTaskId = _taskId;
+ voiceSession = _voiceSession;
+ voiceInteractor = _voiceInteractor;
+ isAvailable = true;
+ mActivities = new ArrayList<>();
+ mCallingUid = info.applicationInfo.uid;
+ mCallingPackage = info.packageName;
+ setIntent(_intent, info);
+ setMinDimensions(info);
+ touchActiveTime();
+ mService.getTaskChangeNotificationController().notifyTaskCreated(_taskId, realActivity);
+ }
+
+ /**
+ * Don't use constructor directly.
+ * Use {@link #create(ActivityTaskManagerService, int, ActivityInfo,
+ * Intent, IVoiceInteractionSession, IVoiceInteractor)} instead.
+ */
+ TaskRecord(ActivityTaskManagerService service, int _taskId, ActivityInfo info, Intent _intent,
+ TaskDescription _taskDescription) {
+ mService = service;
+ userId = UserHandle.getUserId(info.applicationInfo.uid);
+ taskId = _taskId;
+ lastActiveTime = SystemClock.elapsedRealtime();
+ mAffiliatedTaskId = _taskId;
+ voiceSession = null;
+ voiceInteractor = null;
+ isAvailable = true;
+ mActivities = new ArrayList<>();
+ mCallingUid = info.applicationInfo.uid;
+ mCallingPackage = info.packageName;
+ setIntent(_intent, info);
+ setMinDimensions(info);
+
+ isPersistable = true;
+ // Clamp to [1, max].
+ maxRecents = Math.min(Math.max(info.maxRecents, 1),
+ ActivityTaskManager.getMaxAppRecentsLimitStatic());
+
+ lastTaskDescription = _taskDescription;
+ touchActiveTime();
+ mService.getTaskChangeNotificationController().notifyTaskCreated(_taskId, realActivity);
+ }
+
+ /**
+ * Don't use constructor directly. This is only used by XML parser.
+ */
+ TaskRecord(ActivityTaskManagerService service, int _taskId, Intent _intent,
+ Intent _affinityIntent, String _affinity, String _rootAffinity,
+ ComponentName _realActivity, ComponentName _origActivity, boolean _rootWasReset,
+ boolean _autoRemoveRecents, boolean _askedCompatMode, int _userId,
+ int _effectiveUid, String _lastDescription, ArrayList<ActivityRecord> activities,
+ long lastTimeMoved, boolean neverRelinquishIdentity,
+ TaskDescription _lastTaskDescription, int taskAffiliation, int prevTaskId,
+ int nextTaskId, int taskAffiliationColor, int callingUid, String callingPackage,
+ int resizeMode, boolean supportsPictureInPicture, boolean _realActivitySuspended,
+ boolean userSetupComplete, int minWidth, int minHeight) {
+ mService = service;
+ taskId = _taskId;
+ intent = _intent;
+ affinityIntent = _affinityIntent;
+ affinity = _affinity;
+ rootAffinity = _rootAffinity;
+ voiceSession = null;
+ voiceInteractor = null;
+ realActivity = _realActivity;
+ realActivitySuspended = _realActivitySuspended;
+ origActivity = _origActivity;
+ rootWasReset = _rootWasReset;
+ isAvailable = true;
+ autoRemoveRecents = _autoRemoveRecents;
+ askedCompatMode = _askedCompatMode;
+ userId = _userId;
+ mUserSetupComplete = userSetupComplete;
+ effectiveUid = _effectiveUid;
+ lastActiveTime = SystemClock.elapsedRealtime();
+ lastDescription = _lastDescription;
+ mActivities = activities;
+ mLastTimeMoved = lastTimeMoved;
+ mNeverRelinquishIdentity = neverRelinquishIdentity;
+ lastTaskDescription = _lastTaskDescription;
+ mAffiliatedTaskId = taskAffiliation;
+ mAffiliatedTaskColor = taskAffiliationColor;
+ mPrevAffiliateTaskId = prevTaskId;
+ mNextAffiliateTaskId = nextTaskId;
+ mCallingUid = callingUid;
+ mCallingPackage = callingPackage;
+ mResizeMode = resizeMode;
+ mSupportsPictureInPicture = supportsPictureInPicture;
+ mMinWidth = minWidth;
+ mMinHeight = minHeight;
+ mService.getTaskChangeNotificationController().notifyTaskCreated(_taskId, realActivity);
+ }
+
+ TaskWindowContainerController getWindowContainerController() {
+ return mWindowContainerController;
+ }
+
+ void createWindowContainer(boolean onTop, boolean showForAllUsers) {
+ if (mWindowContainerController != null) {
+ throw new IllegalArgumentException("Window container=" + mWindowContainerController
+ + " already created for task=" + this);
+ }
+
+ final Rect bounds = updateOverrideConfigurationFromLaunchBounds();
+ setWindowContainerController(new TaskWindowContainerController(taskId, this,
+ getStack().getWindowContainerController(), userId, bounds,
+ mResizeMode, mSupportsPictureInPicture, onTop,
+ showForAllUsers, lastTaskDescription));
+ }
+
+ /**
+ * Should only be invoked from {@link #createWindowContainer(boolean, boolean)}.
+ */
+ @VisibleForTesting
+ protected void setWindowContainerController(TaskWindowContainerController controller) {
+ if (mWindowContainerController != null) {
+ throw new IllegalArgumentException("Window container=" + mWindowContainerController
+ + " already created for task=" + this);
+ }
+
+ mWindowContainerController = controller;
+ }
+
+ void removeWindowContainer() {
+ mService.getLockTaskController().clearLockedTask(this);
+ mWindowContainerController.removeContainer();
+ if (!getWindowConfiguration().persistTaskBounds()) {
+ // Reset current bounds for task whose bounds shouldn't be persisted so it uses
+ // default configuration the next time it launches.
+ updateOverrideConfiguration(null);
+ }
+ mService.getTaskChangeNotificationController().notifyTaskRemoved(taskId);
+ mWindowContainerController = null;
+ }
+
+ @Override
+ public void onSnapshotChanged(TaskSnapshot snapshot) {
+ mService.getTaskChangeNotificationController().notifyTaskSnapshotChanged(taskId, snapshot);
+ }
+
+ void setResizeMode(int resizeMode) {
+ if (mResizeMode == resizeMode) {
+ return;
+ }
+ mResizeMode = resizeMode;
+ mWindowContainerController.setResizeable(resizeMode);
+ mService.mStackSupervisor.ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
+ mService.mStackSupervisor.resumeFocusedStacksTopActivitiesLocked();
+ }
+
+ void setTaskDockedResizing(boolean resizing) {
+ mWindowContainerController.setTaskDockedResizing(resizing);
+ }
+
+ // TODO: Consolidate this with the resize() method below.
+ @Override
+ public void requestResize(Rect bounds, int resizeMode) {
+ mService.resizeTask(taskId, bounds, resizeMode);
+ }
+
+ boolean resize(Rect bounds, int resizeMode, boolean preserveWindow, boolean deferResume) {
+ mService.mWindowManager.deferSurfaceLayout();
+
+ try {
+ if (!isResizeable()) {
+ Slog.w(TAG, "resizeTask: task " + this + " not resizeable.");
+ return true;
+ }
+
+ // If this is a forced resize, let it go through even if the bounds is not changing,
+ // as we might need a relayout due to surface size change (to/from fullscreen).
+ final boolean forced = (resizeMode & RESIZE_MODE_FORCED) != 0;
+ if (equivalentOverrideBounds(bounds) && !forced) {
+ // Nothing to do here...
+ return true;
+ }
+
+ if (mWindowContainerController == null) {
+ // Task doesn't exist in window manager yet (e.g. was restored from recents).
+ // All we can do for now is update the bounds so it can be used when the task is
+ // added to window manager.
+ updateOverrideConfiguration(bounds);
+ if (!inFreeformWindowingMode()) {
+ // re-restore the task so it can have the proper stack association.
+ mService.mStackSupervisor.restoreRecentTaskLocked(this, null, !ON_TOP);
+ }
+ return true;
+ }
+
+ if (!canResizeToBounds(bounds)) {
+ throw new IllegalArgumentException("resizeTask: Can not resize task=" + this
+ + " to bounds=" + bounds + " resizeMode=" + mResizeMode);
+ }
+
+ // Do not move the task to another stack here.
+ // This method assumes that the task is already placed in the right stack.
+ // we do not mess with that decision and we only do the resize!
+
+ Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "am.resizeTask_" + taskId);
+
+ final boolean updatedConfig = updateOverrideConfiguration(bounds);
+ // This variable holds information whether the configuration didn't change in a significant
+
+ // way and the activity was kept the way it was. If it's false, it means the activity
+ // had
+ // to be relaunched due to configuration change.
+ boolean kept = true;
+ if (updatedConfig) {
+ final ActivityRecord r = topRunningActivityLocked();
+ if (r != null && !deferResume) {
+ kept = r.ensureActivityConfiguration(0 /* globalChanges */,
+ preserveWindow);
+ // Preserve other windows for resizing because if resizing happens when there
+ // is a dialog activity in the front, the activity that still shows some
+ // content to the user will become black and cause flickers. Note in most cases
+ // this won't cause tons of irrelevant windows being preserved because only
+ // activities in this task may experience a bounds change. Configs for other
+ // activities stay the same.
+ mService.mStackSupervisor.ensureActivitiesVisibleLocked(r, 0,
+ preserveWindow);
+ if (!kept) {
+ mService.mStackSupervisor.resumeFocusedStacksTopActivitiesLocked();
+ }
+ }
+ }
+ mWindowContainerController.resize(kept, forced);
+
+ Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
+ return kept;
+ } finally {
+ mService.mWindowManager.continueSurfaceLayout();
+ }
+ }
+
+ // TODO: Investigate combining with the resize() method above.
+ void resizeWindowContainer() {
+ mWindowContainerController.resize(false /* relayout */, false /* forced */);
+ }
+
+ void getWindowContainerBounds(Rect bounds) {
+ mWindowContainerController.getBounds(bounds);
+ }
+
+ /**
+ * Convenience method to reparent a task to the top or bottom position of the stack.
+ */
+ boolean reparent(ActivityStack preferredStack, boolean toTop,
+ @ReparentMoveStackMode int moveStackMode, boolean animate, boolean deferResume,
+ String reason) {
+ return reparent(preferredStack, toTop ? MAX_VALUE : 0, moveStackMode, animate, deferResume,
+ true /* schedulePictureInPictureModeChange */, reason);
+ }
+
+ /**
+ * Convenience method to reparent a task to the top or bottom position of the stack, with
+ * an option to skip scheduling the picture-in-picture mode change.
+ */
+ boolean reparent(ActivityStack preferredStack, boolean toTop,
+ @ReparentMoveStackMode int moveStackMode, boolean animate, boolean deferResume,
+ boolean schedulePictureInPictureModeChange, String reason) {
+ return reparent(preferredStack, toTop ? MAX_VALUE : 0, moveStackMode, animate,
+ deferResume, schedulePictureInPictureModeChange, reason);
+ }
+
+ /** Convenience method to reparent a task to a specific position of the stack. */
+ boolean reparent(ActivityStack preferredStack, int position,
+ @ReparentMoveStackMode int moveStackMode, boolean animate, boolean deferResume,
+ String reason) {
+ return reparent(preferredStack, position, moveStackMode, animate, deferResume,
+ true /* schedulePictureInPictureModeChange */, reason);
+ }
+
+ /**
+ * Reparents the task into a preferred stack, creating it if necessary.
+ *
+ * @param preferredStack the target stack to move this task
+ * @param position the position to place this task in the new stack
+ * @param animate whether or not we should wait for the new window created as a part of the
+ * reparenting to be drawn and animated in
+ * @param moveStackMode whether or not to move the stack to the front always, only if it was
+ * previously focused & in front, or never
+ * @param deferResume whether or not to update the visibility of other tasks and stacks that may
+ * have changed as a result of this reparenting
+ * @param schedulePictureInPictureModeChange specifies whether or not to schedule the PiP mode
+ * change. Callers may set this to false if they are explicitly scheduling PiP mode
+ * changes themselves, like during the PiP animation
+ * @param reason the caller of this reparenting
+ * @return whether the task was reparented
+ */
+ // TODO: Inspect all call sites and change to just changing windowing mode of the stack vs.
+ // re-parenting the task. Can only be done when we are no longer using static stack Ids.
+ boolean reparent(ActivityStack preferredStack, int position,
+ @ReparentMoveStackMode int moveStackMode, boolean animate, boolean deferResume,
+ boolean schedulePictureInPictureModeChange, String reason) {
+ final ActivityStackSupervisor supervisor = mService.mStackSupervisor;
+ final WindowManagerService windowManager = mService.mWindowManager;
+ final ActivityStack sourceStack = getStack();
+ final ActivityStack toStack = supervisor.getReparentTargetStack(this, preferredStack,
+ position == MAX_VALUE);
+ if (toStack == sourceStack) {
+ return false;
+ }
+ if (!canBeLaunchedOnDisplay(toStack.mDisplayId)) {
+ return false;
+ }
+
+ final int toStackWindowingMode = toStack.getWindowingMode();
+ final ActivityRecord topActivity = getTopActivity();
+
+ final boolean mightReplaceWindow = topActivity != null
+ && replaceWindowsOnTaskMove(getWindowingMode(), toStackWindowingMode);
+ if (mightReplaceWindow) {
+ // We are about to relaunch the activity because its configuration changed due to
+ // being maximized, i.e. size change. The activity will first remove the old window
+ // and then add a new one. This call will tell window manager about this, so it can
+ // preserve the old window until the new one is drawn. This prevents having a gap
+ // between the removal and addition, in which no window is visible. We also want the
+ // entrance of the new window to be properly animated.
+ // Note here we always set the replacing window first, as the flags might be needed
+ // during the relaunch. If we end up not doing any relaunch, we clear the flags later.
+ windowManager.setWillReplaceWindow(topActivity.appToken, animate);
+ }
+
+ windowManager.deferSurfaceLayout();
+ boolean kept = true;
+ try {
+ final ActivityRecord r = topRunningActivityLocked();
+ final boolean wasFocused = r != null && supervisor.isTopDisplayFocusedStack(sourceStack)
+ && (topRunningActivityLocked() == r);
+ final boolean wasResumed = r != null && sourceStack.getResumedActivity() == r;
+ final boolean wasPaused = r != null && sourceStack.mPausingActivity == r;
+
+ // In some cases the focused stack isn't the front stack. E.g. pinned stack.
+ // Whenever we are moving the top activity from the front stack we want to make sure to
+ // move the stack to the front.
+ final boolean wasFront = r != null && sourceStack.isTopStackOnDisplay()
+ && (sourceStack.topRunningActivityLocked() == r);
+
+ // Adjust the position for the new parent stack as needed.
+ position = toStack.getAdjustedPositionForTask(this, position, null /* starting */);
+
+ // Must reparent first in window manager to avoid a situation where AM can delete the
+ // we are coming from in WM before we reparent because it became empty.
+ mWindowContainerController.reparent(toStack.getWindowContainerController(), position,
+ moveStackMode == REPARENT_MOVE_STACK_TO_FRONT);
+
+ final boolean moveStackToFront = moveStackMode == REPARENT_MOVE_STACK_TO_FRONT
+ || (moveStackMode == REPARENT_KEEP_STACK_AT_FRONT && (wasFocused || wasFront));
+ // Move the task
+ sourceStack.removeTask(this, reason, moveStackToFront
+ ? REMOVE_TASK_MODE_MOVING_TO_TOP : REMOVE_TASK_MODE_MOVING);
+ toStack.addTask(this, position, false /* schedulePictureInPictureModeChange */, reason);
+
+ if (schedulePictureInPictureModeChange) {
+ // Notify of picture-in-picture mode changes
+ supervisor.scheduleUpdatePictureInPictureModeIfNeeded(this, sourceStack);
+ }
+
+ // TODO: Ensure that this is actually necessary here
+ // Notify the voice session if required
+ if (voiceSession != null) {
+ try {
+ voiceSession.taskStarted(intent, taskId);
+ } catch (RemoteException e) {
+ }
+ }
+
+ // If the task had focus before (or we're requested to move focus), move focus to the
+ // new stack by moving the stack to the front.
+ if (r != null) {
+ toStack.moveToFrontAndResumeStateIfNeeded(r, moveStackToFront, wasResumed,
+ wasPaused, reason);
+ }
+ if (!animate) {
+ mService.mStackSupervisor.mNoAnimActivities.add(topActivity);
+ }
+
+ // We might trigger a configuration change. Save the current task bounds for freezing.
+ // TODO: Should this call be moved inside the resize method in WM?
+ toStack.prepareFreezingTaskBounds();
+
+ // Make sure the task has the appropriate bounds/size for the stack it is in.
+ final boolean toStackSplitScreenPrimary =
+ toStackWindowingMode == WINDOWING_MODE_SPLIT_SCREEN_PRIMARY;
+ final Rect configBounds = getOverrideBounds();
+ if ((toStackWindowingMode == WINDOWING_MODE_FULLSCREEN
+ || toStackWindowingMode == WINDOWING_MODE_SPLIT_SCREEN_SECONDARY)
+ && !Objects.equals(configBounds, toStack.getOverrideBounds())) {
+ kept = resize(toStack.getOverrideBounds(), RESIZE_MODE_SYSTEM, !mightReplaceWindow,
+ deferResume);
+ } else if (toStackWindowingMode == WINDOWING_MODE_FREEFORM) {
+ Rect bounds = getLaunchBounds();
+ if (bounds == null) {
+ mService.mStackSupervisor.getLaunchParamsController().layoutTask(this, null);
+ bounds = configBounds;
+ }
+ kept = resize(bounds, RESIZE_MODE_FORCED, !mightReplaceWindow, deferResume);
+ } else if (toStackSplitScreenPrimary || toStackWindowingMode == WINDOWING_MODE_PINNED) {
+ if (toStackSplitScreenPrimary && moveStackMode == REPARENT_KEEP_STACK_AT_FRONT) {
+ // Move recents to front so it is not behind home stack when going into docked
+ // mode
+ mService.mStackSupervisor.moveRecentsStackToFront(reason);
+ }
+ kept = resize(toStack.getOverrideBounds(), RESIZE_MODE_SYSTEM, !mightReplaceWindow,
+ deferResume);
+ }
+ } finally {
+ windowManager.continueSurfaceLayout();
+ }
+
+ if (mightReplaceWindow) {
+ // If we didn't actual do a relaunch (indicated by kept==true meaning we kept the old
+ // window), we need to clear the replace window settings. Otherwise, we schedule a
+ // timeout to remove the old window if the replacing window is not coming in time.
+ windowManager.scheduleClearWillReplaceWindows(topActivity.appToken, !kept);
+ }
+
+ if (!deferResume) {
+ // The task might have already been running and its visibility needs to be synchronized
+ // with the visibility of the stack / windows.
+ supervisor.ensureActivitiesVisibleLocked(null, 0, !mightReplaceWindow);
+ supervisor.resumeFocusedStacksTopActivitiesLocked();
+ }
+
+ // TODO: Handle incorrect request to move before the actual move, not after.
+ supervisor.handleNonResizableTaskIfNeeded(this, preferredStack.getWindowingMode(),
+ DEFAULT_DISPLAY, toStack);
+
+ return (preferredStack == toStack);
+ }
+
+ /**
+ * @return True if the windows of tasks being moved to the target stack from the source stack
+ * should be replaced, meaning that window manager will keep the old window around until the new
+ * is ready.
+ */
+ private static boolean replaceWindowsOnTaskMove(
+ int sourceWindowingMode, int targetWindowingMode) {
+ return sourceWindowingMode == WINDOWING_MODE_FREEFORM
+ || targetWindowingMode == WINDOWING_MODE_FREEFORM;
+ }
+
+ void cancelWindowTransition() {
+ mWindowContainerController.cancelWindowTransition();
+ }
+
+ /**
+ * DO NOT HOLD THE ACTIVITY MANAGER LOCK WHEN CALLING THIS METHOD!
+ */
+ TaskSnapshot getSnapshot(boolean reducedResolution) {
+
+ // TODO: Move this to {@link TaskWindowContainerController} once recent tasks are more
+ // synchronized between AM and WM.
+ return mService.mWindowManager.getTaskSnapshot(taskId, userId, reducedResolution);
+ }
+
+ void touchActiveTime() {
+ lastActiveTime = SystemClock.elapsedRealtime();
+ }
+
+ long getInactiveDuration() {
+ return SystemClock.elapsedRealtime() - lastActiveTime;
+ }
+
+ /** Sets the original intent, and the calling uid and package. */
+ void setIntent(ActivityRecord r) {
+ mCallingUid = r.launchedFromUid;
+ mCallingPackage = r.launchedFromPackage;
+ setIntent(r.intent, r.info);
+ setLockTaskAuth(r);
+ }
+
+ /** Sets the original intent, _without_ updating the calling uid or package. */
+ private void setIntent(Intent _intent, ActivityInfo info) {
+ if (intent == null) {
+ mNeverRelinquishIdentity =
+ (info.flags & FLAG_RELINQUISH_TASK_IDENTITY) == 0;
+ } else if (mNeverRelinquishIdentity) {
+ return;
+ }
+
+ affinity = info.taskAffinity;
+ if (intent == null) {
+ // If this task already has an intent associated with it, don't set the root
+ // affinity -- we don't want it changing after initially set, but the initially
+ // set value may be null.
+ rootAffinity = affinity;
+ }
+ effectiveUid = info.applicationInfo.uid;
+ stringName = null;
+
+ if (info.targetActivity == null) {
+ if (_intent != null) {
+ // If this Intent has a selector, we want to clear it for the
+ // recent task since it is not relevant if the user later wants
+ // to re-launch the app.
+ if (_intent.getSelector() != null || _intent.getSourceBounds() != null) {
+ _intent = new Intent(_intent);
+ _intent.setSelector(null);
+ _intent.setSourceBounds(null);
+ }
+ }
+ if (DEBUG_TASKS) Slog.v(TAG_TASKS, "Setting Intent of " + this + " to " + _intent);
+ intent = _intent;
+ realActivity = _intent != null ? _intent.getComponent() : null;
+ origActivity = null;
+ } else {
+ ComponentName targetComponent = new ComponentName(
+ info.packageName, info.targetActivity);
+ if (_intent != null) {
+ Intent targetIntent = new Intent(_intent);
+ targetIntent.setComponent(targetComponent);
+ targetIntent.setSelector(null);
+ targetIntent.setSourceBounds(null);
+ if (DEBUG_TASKS) Slog.v(TAG_TASKS,
+ "Setting Intent of " + this + " to target " + targetIntent);
+ intent = targetIntent;
+ realActivity = targetComponent;
+ origActivity = _intent.getComponent();
+ } else {
+ intent = null;
+ realActivity = targetComponent;
+ origActivity = new ComponentName(info.packageName, info.name);
+ }
+ }
+
+ final int intentFlags = intent == null ? 0 : intent.getFlags();
+ if ((intentFlags & Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED) != 0) {
+ // Once we are set to an Intent with this flag, we count this
+ // task as having a true root activity.
+ rootWasReset = true;
+ }
+ userId = UserHandle.getUserId(info.applicationInfo.uid);
+ mUserSetupComplete = Settings.Secure.getIntForUser(mService.mContext.getContentResolver(),
+ USER_SETUP_COMPLETE, 0, userId) != 0;
+ if ((info.flags & ActivityInfo.FLAG_AUTO_REMOVE_FROM_RECENTS) != 0) {
+ // If the activity itself has requested auto-remove, then just always do it.
+ autoRemoveRecents = true;
+ } else if ((intentFlags & (FLAG_ACTIVITY_NEW_DOCUMENT | FLAG_ACTIVITY_RETAIN_IN_RECENTS))
+ == FLAG_ACTIVITY_NEW_DOCUMENT) {
+ // If the caller has not asked for the document to be retained, then we may
+ // want to turn on auto-remove, depending on whether the target has set its
+ // own document launch mode.
+ if (info.documentLaunchMode != ActivityInfo.DOCUMENT_LAUNCH_NONE) {
+ autoRemoveRecents = false;
+ } else {
+ autoRemoveRecents = true;
+ }
+ } else {
+ autoRemoveRecents = false;
+ }
+ mResizeMode = info.resizeMode;
+ mSupportsPictureInPicture = info.supportsPictureInPicture();
+ }
+
+ /** Sets the original minimal width and height. */
+ private void setMinDimensions(ActivityInfo info) {
+ if (info != null && info.windowLayout != null) {
+ mMinWidth = info.windowLayout.minWidth;
+ mMinHeight = info.windowLayout.minHeight;
+ } else {
+ mMinWidth = INVALID_MIN_SIZE;
+ mMinHeight = INVALID_MIN_SIZE;
+ }
+ }
+
+ /**
+ * Return true if the input activity has the same intent filter as the intent this task
+ * record is based on (normally the root activity intent).
+ */
+ boolean isSameIntentFilter(ActivityRecord r) {
+ final Intent intent = new Intent(r.intent);
+ // Correct the activity intent for aliasing. The task record intent will always be based on
+ // the real activity that will be launched not the alias, so we need to use an intent with
+ // the component name pointing to the real activity not the alias in the activity record.
+ intent.setComponent(r.realActivity);
+ return intent.filterEquals(this.intent);
+ }
+
+ boolean returnsToHomeStack() {
+ final int returnHomeFlags = FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_TASK_ON_HOME;
+ return intent != null && (intent.getFlags() & returnHomeFlags) == returnHomeFlags;
+ }
+
+ void setPrevAffiliate(TaskRecord prevAffiliate) {
+ mPrevAffiliate = prevAffiliate;
+ mPrevAffiliateTaskId = prevAffiliate == null ? INVALID_TASK_ID : prevAffiliate.taskId;
+ }
+
+ void setNextAffiliate(TaskRecord nextAffiliate) {
+ mNextAffiliate = nextAffiliate;
+ mNextAffiliateTaskId = nextAffiliate == null ? INVALID_TASK_ID : nextAffiliate.taskId;
+ }
+
+ <T extends ActivityStack> T getStack() {
+ return (T) mStack;
+ }
+
+ /**
+ * Must be used for setting parent stack because it performs configuration updates.
+ * Must be called after adding task as a child to the stack.
+ */
+ void setStack(ActivityStack stack) {
+ if (stack != null && !stack.isInStackLocked(this)) {
+ throw new IllegalStateException("Task must be added as a Stack child first.");
+ }
+ final ActivityStack oldStack = mStack;
+ mStack = stack;
+
+ // If the new {@link TaskRecord} is from a different {@link ActivityStack}, remove this
+ // {@link ActivityRecord} from its current {@link ActivityStack}.
+
+ if (oldStack != mStack) {
+ for (int i = getChildCount() - 1; i >= 0; --i) {
+ final ActivityRecord activity = getChildAt(i);
+
+ if (oldStack != null) {
+ oldStack.onActivityRemovedFromStack(activity);
+ }
+
+ if (mStack != null) {
+ stack.onActivityAddedToStack(activity);
+ }
+ }
+ }
+
+ onParentChanged();
+ }
+
+ /**
+ * @return Id of current stack, {@link INVALID_STACK_ID} if no stack is set.
+ */
+ int getStackId() {
+ return mStack != null ? mStack.mStackId : INVALID_STACK_ID;
+ }
+
+ @Override
+ protected int getChildCount() {
+ return mActivities.size();
+ }
+
+ @Override
+ protected ActivityRecord getChildAt(int index) {
+ return mActivities.get(index);
+ }
+
+ @Override
+ protected ConfigurationContainer getParent() {
+ return mStack;
+ }
+
+ @Override
+ protected void onParentChanged() {
+ super.onParentChanged();
+ mService.mStackSupervisor.updateUIDsPresentOnDisplay();
+ }
+
+ // Close up recents linked list.
+ private void closeRecentsChain() {
+ if (mPrevAffiliate != null) {
+ mPrevAffiliate.setNextAffiliate(mNextAffiliate);
+ }
+ if (mNextAffiliate != null) {
+ mNextAffiliate.setPrevAffiliate(mPrevAffiliate);
+ }
+ setPrevAffiliate(null);
+ setNextAffiliate(null);
+ }
+
+ void removedFromRecents() {
+ closeRecentsChain();
+ if (inRecents) {
+ inRecents = false;
+ mService.notifyTaskPersisterLocked(this, false);
+ }
+
+ clearRootProcess();
+
+ // TODO: Use window container controller once tasks are better synced between AM and WM
+ mService.mWindowManager.notifyTaskRemovedFromRecents(taskId, userId);
+ }
+
+ void setTaskToAffiliateWith(TaskRecord taskToAffiliateWith) {
+ closeRecentsChain();
+ mAffiliatedTaskId = taskToAffiliateWith.mAffiliatedTaskId;
+ mAffiliatedTaskColor = taskToAffiliateWith.mAffiliatedTaskColor;
+ // Find the end
+ while (taskToAffiliateWith.mNextAffiliate != null) {
+ final TaskRecord nextRecents = taskToAffiliateWith.mNextAffiliate;
+ if (nextRecents.mAffiliatedTaskId != mAffiliatedTaskId) {
+ Slog.e(TAG, "setTaskToAffiliateWith: nextRecents=" + nextRecents + " affilTaskId="
+ + nextRecents.mAffiliatedTaskId + " should be " + mAffiliatedTaskId);
+ if (nextRecents.mPrevAffiliate == taskToAffiliateWith) {
+ nextRecents.setPrevAffiliate(null);
+ }
+ taskToAffiliateWith.setNextAffiliate(null);
+ break;
+ }
+ taskToAffiliateWith = nextRecents;
+ }
+ taskToAffiliateWith.setNextAffiliate(this);
+ setPrevAffiliate(taskToAffiliateWith);
+ setNextAffiliate(null);
+ }
+
+ /** Returns the intent for the root activity for this task */
+ Intent getBaseIntent() {
+ return intent != null ? intent : affinityIntent;
+ }
+
+ /** Returns the first non-finishing activity from the root. */
+ ActivityRecord getRootActivity() {
+ for (int i = 0; i < mActivities.size(); i++) {
+ final ActivityRecord r = mActivities.get(i);
+ if (r.finishing) {
+ continue;
+ }
+ return r;
+ }
+ return null;
+ }
+
+ ActivityRecord getTopActivity() {
+ return getTopActivity(true /* includeOverlays */);
+ }
+
+ ActivityRecord getTopActivity(boolean includeOverlays) {
+ for (int i = mActivities.size() - 1; i >= 0; --i) {
+ final ActivityRecord r = mActivities.get(i);
+ if (r.finishing || (!includeOverlays && r.mTaskOverlay)) {
+ continue;
+ }
+ return r;
+ }
+ return null;
+ }
+
+ ActivityRecord topRunningActivityLocked() {
+ if (mStack != null) {
+ for (int activityNdx = mActivities.size() - 1; activityNdx >= 0; --activityNdx) {
+ ActivityRecord r = mActivities.get(activityNdx);
+ if (!r.finishing && r.okToShowLocked()) {
+ return r;
+ }
+ }
+ }
+ return null;
+ }
+
+ boolean isVisible() {
+ for (int i = mActivities.size() - 1; i >= 0; --i) {
+ final ActivityRecord r = mActivities.get(i);
+ if (r.visible) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ void getAllRunningVisibleActivitiesLocked(ArrayList<ActivityRecord> outActivities) {
+ if (mStack != null) {
+ for (int activityNdx = mActivities.size() - 1; activityNdx >= 0; --activityNdx) {
+ ActivityRecord r = mActivities.get(activityNdx);
+ if (!r.finishing && r.okToShowLocked() && r.visibleIgnoringKeyguard) {
+ outActivities.add(r);
+ }
+ }
+ }
+ }
+
+ ActivityRecord topRunningActivityWithStartingWindowLocked() {
+ if (mStack != null) {
+ for (int activityNdx = mActivities.size() - 1; activityNdx >= 0; --activityNdx) {
+ ActivityRecord r = mActivities.get(activityNdx);
+ if (r.mStartingWindowState != STARTING_WINDOW_SHOWN
+ || r.finishing || !r.okToShowLocked()) {
+ continue;
+ }
+ return r;
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Return the number of running activities, and the number of non-finishing/initializing
+ * activities in the provided {@param reportOut} respectively.
+ */
+ void getNumRunningActivities(TaskActivitiesReport reportOut) {
+ reportOut.reset();
+ for (int i = mActivities.size() - 1; i >= 0; --i) {
+ final ActivityRecord r = mActivities.get(i);
+ if (r.finishing) {
+ continue;
+ }
+
+ reportOut.base = r;
+
+ // Increment the total number of non-finishing activities
+ reportOut.numActivities++;
+
+ if (reportOut.top == null || (reportOut.top.isState(ActivityState.INITIALIZING))) {
+ reportOut.top = r;
+ // Reset the number of running activities until we hit the first non-initializing
+ // activity
+ reportOut.numRunning = 0;
+ }
+ if (r.attachedToProcess()) {
+ // Increment the number of actually running activities
+ reportOut.numRunning++;
+ }
+ }
+ }
+
+ boolean okToShowLocked() {
+ // NOTE: If {@link TaskRecord#topRunningActivityLocked} return is not null then it is
+ // okay to show the activity when locked.
+ return mService.mStackSupervisor.isCurrentProfileLocked(userId)
+ || topRunningActivityLocked() != null;
+ }
+
+ /** Call after activity movement or finish to make sure that frontOfTask is set correctly */
+ final void setFrontOfTask() {
+ boolean foundFront = false;
+ final int numActivities = mActivities.size();
+ for (int activityNdx = 0; activityNdx < numActivities; ++activityNdx) {
+ final ActivityRecord r = mActivities.get(activityNdx);
+ if (foundFront || r.finishing) {
+ r.frontOfTask = false;
+ } else {
+ r.frontOfTask = true;
+ // Set frontOfTask false for every following activity.
+ foundFront = true;
+ }
+ }
+ if (!foundFront && numActivities > 0) {
+ // All activities of this task are finishing. As we ought to have a frontOfTask
+ // activity, make the bottom activity front.
+ mActivities.get(0).frontOfTask = true;
+ }
+ }
+
+ /**
+ * Reorder the history stack so that the passed activity is brought to the front.
+ */
+ final void moveActivityToFrontLocked(ActivityRecord newTop) {
+ if (DEBUG_ADD_REMOVE) Slog.i(TAG_ADD_REMOVE,
+ "Removing and adding activity " + newTop
+ + " to stack at top callers=" + Debug.getCallers(4));
+
+ mActivities.remove(newTop);
+ mActivities.add(newTop);
+
+ // Make sure window manager is aware of the position change.
+ mWindowContainerController.positionChildAtTop(newTop.mWindowContainerController);
+ updateEffectiveIntent();
+
+ setFrontOfTask();
+ }
+
+ void addActivityAtBottom(ActivityRecord r) {
+ addActivityAtIndex(0, r);
+ }
+
+ void addActivityToTop(ActivityRecord r) {
+ addActivityAtIndex(mActivities.size(), r);
+ }
+
+ @Override
+ /*@WindowConfiguration.ActivityType*/
+ public int getActivityType() {
+ final int applicationType = super.getActivityType();
+ if (applicationType != ACTIVITY_TYPE_UNDEFINED || mActivities.isEmpty()) {
+ return applicationType;
+ }
+ return mActivities.get(0).getActivityType();
+ }
+
+ /**
+ * Adds an activity {@param r} at the given {@param index}. The activity {@param r} must either
+ * be in the current task or unparented to any task.
+ */
+ void addActivityAtIndex(int index, ActivityRecord r) {
+ TaskRecord task = r.getTask();
+ if (task != null && task != this) {
+ throw new IllegalArgumentException("Can not add r=" + " to task=" + this
+ + " current parent=" + task);
+ }
+
+ r.setTask(this);
+
+ // Remove r first, and if it wasn't already in the list and it's fullscreen, count it.
+ if (!mActivities.remove(r) && r.fullscreen) {
+ // Was not previously in list.
+ numFullscreen++;
+ }
+ // Only set this based on the first activity
+ if (mActivities.isEmpty()) {
+ if (r.getActivityType() == ACTIVITY_TYPE_UNDEFINED) {
+ // Normally non-standard activity type for the activity record will be set when the
+ // object is created, however we delay setting the standard application type until
+ // this point so that the task can set the type for additional activities added in
+ // the else condition below.
+ r.setActivityType(ACTIVITY_TYPE_STANDARD);
+ }
+ setActivityType(r.getActivityType());
+ isPersistable = r.isPersistable();
+ mCallingUid = r.launchedFromUid;
+ mCallingPackage = r.launchedFromPackage;
+ // Clamp to [1, max].
+ maxRecents = Math.min(Math.max(r.info.maxRecents, 1),
+ ActivityTaskManager.getMaxAppRecentsLimitStatic());
+ } else {
+ // Otherwise make all added activities match this one.
+ r.setActivityType(getActivityType());
+ }
+
+ final int size = mActivities.size();
+
+ if (index == size && size > 0) {
+ final ActivityRecord top = mActivities.get(size - 1);
+ if (top.mTaskOverlay) {
+ // Place below the task overlay activity since the overlay activity should always
+ // be on top.
+ index--;
+ }
+ }
+
+ index = Math.min(size, index);
+ mActivities.add(index, r);
+
+ updateEffectiveIntent();
+ if (r.isPersistable()) {
+ mService.notifyTaskPersisterLocked(this, false);
+ }
+
+ // Sync. with window manager
+ updateOverrideConfigurationFromLaunchBounds();
+ final AppWindowContainerController appController = r.getWindowContainerController();
+ if (appController != null) {
+ // Only attempt to move in WM if the child has a controller. It is possible we haven't
+ // created controller for the activity we are starting yet.
+ mWindowContainerController.positionChildAt(appController, index);
+ }
+
+ // Make sure the list of display UID whitelists is updated
+ // now that this record is in a new task.
+ mService.mStackSupervisor.updateUIDsPresentOnDisplay();
+ }
+
+ /**
+ * Removes the specified activity from this task.
+ * @param r The {@link ActivityRecord} to remove.
+ * @return true if this was the last activity in the task.
+ */
+ boolean removeActivity(ActivityRecord r) {
+ return removeActivity(r, false /* reparenting */);
+ }
+
+ boolean removeActivity(ActivityRecord r, boolean reparenting) {
+ if (r.getTask() != this) {
+ throw new IllegalArgumentException(
+ "Activity=" + r + " does not belong to task=" + this);
+ }
+
+ r.setTask(null /* task */, reparenting /* reparenting */);
+
+ if (mActivities.remove(r) && r.fullscreen) {
+ // Was previously in list.
+ numFullscreen--;
+ }
+ if (r.isPersistable()) {
+ mService.notifyTaskPersisterLocked(this, false);
+ }
+
+ if (inPinnedWindowingMode()) {
+ // We normally notify listeners of task stack changes on pause, however pinned stack
+ // activities are normally in the paused state so no notification will be sent there
+ // before the activity is removed. We send it here so instead.
+ mService.getTaskChangeNotificationController().notifyTaskStackChanged();
+ }
+
+ if (mActivities.isEmpty()) {
+ return !mReuseTask;
+ }
+ updateEffectiveIntent();
+ return false;
+ }
+
+ /**
+ * @return whether or not there are ONLY task overlay activities in the stack.
+ * If {@param excludeFinishing} is set, then ignore finishing activities in the check.
+ * If there are no task overlay activities, this call returns false.
+ */
+ boolean onlyHasTaskOverlayActivities(boolean excludeFinishing) {
+ int count = 0;
+ for (int i = mActivities.size() - 1; i >= 0; i--) {
+ final ActivityRecord r = mActivities.get(i);
+ if (excludeFinishing && r.finishing) {
+ continue;
+ }
+ if (!r.mTaskOverlay) {
+ return false;
+ }
+ count++;
+ }
+ return count > 0;
+ }
+
+ boolean autoRemoveFromRecents() {
+ // We will automatically remove the task either if it has explicitly asked for
+ // this, or it is empty and has never contained an activity that got shown to
+ // the user.
+ return autoRemoveRecents || (mActivities.isEmpty() && !hasBeenVisible);
+ }
+
+ /**
+ * Completely remove all activities associated with an existing
+ * task starting at a specified index.
+ */
+ final void performClearTaskAtIndexLocked(int activityNdx, boolean pauseImmediately,
+ String reason) {
+ int numActivities = mActivities.size();
+ for ( ; activityNdx < numActivities; ++activityNdx) {
+ final ActivityRecord r = mActivities.get(activityNdx);
+ if (r.finishing) {
+ continue;
+ }
+ if (mStack == null) {
+ // Task was restored from persistent storage.
+ r.takeFromHistory();
+ mActivities.remove(activityNdx);
+ --activityNdx;
+ --numActivities;
+ } else if (mStack.finishActivityLocked(r, Activity.RESULT_CANCELED, null,
+ reason, false, pauseImmediately)) {
+ --activityNdx;
+ --numActivities;
+ }
+ }
+ }
+
+ /**
+ * Completely remove all activities associated with an existing task.
+ */
+ void performClearTaskLocked() {
+ mReuseTask = true;
+ performClearTaskAtIndexLocked(0, !PAUSE_IMMEDIATELY, "clear-task-all");
+ mReuseTask = false;
+ }
+
+ ActivityRecord performClearTaskForReuseLocked(ActivityRecord newR, int launchFlags) {
+ mReuseTask = true;
+ final ActivityRecord result = performClearTaskLocked(newR, launchFlags);
+ mReuseTask = false;
+ return result;
+ }
+
+ /**
+ * Perform clear operation as requested by
+ * {@link Intent#FLAG_ACTIVITY_CLEAR_TOP}: search from the top of the
+ * stack to the given task, then look for
+ * an instance of that activity in the stack and, if found, finish all
+ * activities on top of it and return the instance.
+ *
+ * @param newR Description of the new activity being started.
+ * @return Returns the old activity that should be continued to be used,
+ * or null if none was found.
+ */
+ final ActivityRecord performClearTaskLocked(ActivityRecord newR, int launchFlags) {
+ int numActivities = mActivities.size();
+ for (int activityNdx = numActivities - 1; activityNdx >= 0; --activityNdx) {
+ ActivityRecord r = mActivities.get(activityNdx);
+ if (r.finishing) {
+ continue;
+ }
+ if (r.realActivity.equals(newR.realActivity)) {
+ // Here it is! Now finish everything in front...
+ final ActivityRecord ret = r;
+
+ for (++activityNdx; activityNdx < numActivities; ++activityNdx) {
+ r = mActivities.get(activityNdx);
+ if (r.finishing) {
+ continue;
+ }
+ ActivityOptions opts = r.takeOptionsLocked();
+ if (opts != null) {
+ ret.updateOptionsLocked(opts);
+ }
+ if (mStack != null && mStack.finishActivityLocked(
+ r, Activity.RESULT_CANCELED, null, "clear-task-stack", false)) {
+ --activityNdx;
+ --numActivities;
+ }
+ }
+
+ // Finally, if this is a normal launch mode (that is, not
+ // expecting onNewIntent()), then we will finish the current
+ // instance of the activity so a new fresh one can be started.
+ if (ret.launchMode == ActivityInfo.LAUNCH_MULTIPLE
+ && (launchFlags & Intent.FLAG_ACTIVITY_SINGLE_TOP) == 0
+ && !ActivityStarter.isDocumentLaunchesIntoExisting(launchFlags)) {
+ if (!ret.finishing) {
+ if (mStack != null) {
+ mStack.finishActivityLocked(
+ ret, Activity.RESULT_CANCELED, null, "clear-task-top", false);
+ }
+ return null;
+ }
+ }
+
+ return ret;
+ }
+ }
+
+ return null;
+ }
+
+ void removeTaskActivitiesLocked(boolean pauseImmediately, String reason) {
+ // Just remove the entire task.
+ performClearTaskAtIndexLocked(0, pauseImmediately, reason);
+ }
+
+ String lockTaskAuthToString() {
+ switch (mLockTaskAuth) {
+ case LOCK_TASK_AUTH_DONT_LOCK: return "LOCK_TASK_AUTH_DONT_LOCK";
+ case LOCK_TASK_AUTH_PINNABLE: return "LOCK_TASK_AUTH_PINNABLE";
+ case LOCK_TASK_AUTH_LAUNCHABLE: return "LOCK_TASK_AUTH_LAUNCHABLE";
+ case LOCK_TASK_AUTH_WHITELISTED: return "LOCK_TASK_AUTH_WHITELISTED";
+ case LOCK_TASK_AUTH_LAUNCHABLE_PRIV: return "LOCK_TASK_AUTH_LAUNCHABLE_PRIV";
+ default: return "unknown=" + mLockTaskAuth;
+ }
+ }
+
+ void setLockTaskAuth() {
+ setLockTaskAuth(getRootActivity());
+ }
+
+ private void setLockTaskAuth(@Nullable ActivityRecord r) {
+ if (r == null) {
+ mLockTaskAuth = LOCK_TASK_AUTH_PINNABLE;
+ return;
+ }
+
+ final String pkg = (realActivity != null) ? realActivity.getPackageName() : null;
+ final LockTaskController lockTaskController = mService.getLockTaskController();
+ switch (r.lockTaskLaunchMode) {
+ case LOCK_TASK_LAUNCH_MODE_DEFAULT:
+ mLockTaskAuth = lockTaskController.isPackageWhitelisted(userId, pkg)
+ ? LOCK_TASK_AUTH_WHITELISTED : LOCK_TASK_AUTH_PINNABLE;
+ break;
+
+ case LOCK_TASK_LAUNCH_MODE_NEVER:
+ mLockTaskAuth = LOCK_TASK_AUTH_DONT_LOCK;
+ break;
+
+ case LOCK_TASK_LAUNCH_MODE_ALWAYS:
+ mLockTaskAuth = LOCK_TASK_AUTH_LAUNCHABLE_PRIV;
+ break;
+
+ case LOCK_TASK_LAUNCH_MODE_IF_WHITELISTED:
+ mLockTaskAuth = lockTaskController.isPackageWhitelisted(userId, pkg)
+ ? LOCK_TASK_AUTH_LAUNCHABLE : LOCK_TASK_AUTH_PINNABLE;
+ break;
+ }
+ if (DEBUG_LOCKTASK) Slog.d(TAG_LOCKTASK, "setLockTaskAuth: task=" + this +
+ " mLockTaskAuth=" + lockTaskAuthToString());
+ }
+
+ private boolean isResizeable(boolean checkSupportsPip) {
+ return (mService.mForceResizableActivities || ActivityInfo.isResizeableMode(mResizeMode)
+ || (checkSupportsPip && mSupportsPictureInPicture));
+ }
+
+ boolean isResizeable() {
+ return isResizeable(true /* checkSupportsPip */);
+ }
+
+ @Override
+ public boolean supportsSplitScreenWindowingMode() {
+ // A task can not be docked even if it is considered resizeable because it only supports
+ // picture-in-picture mode but has a non-resizeable resizeMode
+ return super.supportsSplitScreenWindowingMode()
+ && mService.mSupportsSplitScreenMultiWindow
+ && (mService.mForceResizableActivities
+ || (isResizeable(false /* checkSupportsPip */)
+ && !ActivityInfo.isPreserveOrientationMode(mResizeMode)));
+ }
+
+ /**
+ * Check whether this task can be launched on the specified display.
+ *
+ * @param displayId Target display id.
+ * @return {@code true} if either it is the default display or this activity can be put on a
+ * secondary display.
+ */
+ boolean canBeLaunchedOnDisplay(int displayId) {
+ return mService.mStackSupervisor.canPlaceEntityOnDisplay(displayId,
+ -1 /* don't check PID */, -1 /* don't check UID */, null /* activityInfo */);
+ }
+
+ /**
+ * Check that a given bounds matches the application requested orientation.
+ *
+ * @param bounds The bounds to be tested.
+ * @return True if the requested bounds are okay for a resizing request.
+ */
+ private boolean canResizeToBounds(Rect bounds) {
+ if (bounds == null || !inFreeformWindowingMode()) {
+ // Note: If not on the freeform workspace, we ignore the bounds.
+ return true;
+ }
+ final boolean landscape = bounds.width() > bounds.height();
+ final Rect configBounds = getOverrideBounds();
+ if (mResizeMode == RESIZE_MODE_FORCE_RESIZABLE_PRESERVE_ORIENTATION) {
+ return configBounds.isEmpty()
+ || landscape == (configBounds.width() > configBounds.height());
+ }
+ return (mResizeMode != RESIZE_MODE_FORCE_RESIZABLE_PORTRAIT_ONLY || !landscape)
+ && (mResizeMode != RESIZE_MODE_FORCE_RESIZABLE_LANDSCAPE_ONLY || landscape);
+ }
+
+ /**
+ * @return {@code true} if the task is being cleared for the purposes of being reused.
+ */
+ boolean isClearingToReuseTask() {
+ return mReuseTask;
+ }
+
+ /**
+ * Find the activity in the history stack within the given task. Returns
+ * the index within the history at which it's found, or < 0 if not found.
+ */
+ final ActivityRecord findActivityInHistoryLocked(ActivityRecord r) {
+ final ComponentName realActivity = r.realActivity;
+ for (int activityNdx = mActivities.size() - 1; activityNdx >= 0; --activityNdx) {
+ ActivityRecord candidate = mActivities.get(activityNdx);
+ if (candidate.finishing) {
+ continue;
+ }
+ if (candidate.realActivity.equals(realActivity)) {
+ return candidate;
+ }
+ }
+ return null;
+ }
+
+ /** Updates the last task description values. */
+ void updateTaskDescription() {
+ // Traverse upwards looking for any break between main task activities and
+ // utility activities.
+ int activityNdx;
+ final int numActivities = mActivities.size();
+ final boolean relinquish = numActivities != 0 &&
+ (mActivities.get(0).info.flags & FLAG_RELINQUISH_TASK_IDENTITY) != 0;
+ for (activityNdx = Math.min(numActivities, 1); activityNdx < numActivities;
+ ++activityNdx) {
+ final ActivityRecord r = mActivities.get(activityNdx);
+ if (relinquish && (r.info.flags & FLAG_RELINQUISH_TASK_IDENTITY) == 0) {
+ // This will be the top activity for determining taskDescription. Pre-inc to
+ // overcome initial decrement below.
+ ++activityNdx;
+ break;
+ }
+ if (r.intent != null &&
+ (r.intent.getFlags() & Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET) != 0) {
+ break;
+ }
+ }
+ if (activityNdx > 0) {
+ // Traverse downwards starting below break looking for set label, icon.
+ // Note that if there are activities in the task but none of them set the
+ // recent activity values, then we do not fall back to the last set
+ // values in the TaskRecord.
+ String label = null;
+ String iconFilename = null;
+ int iconResource = -1;
+ int colorPrimary = 0;
+ int colorBackground = 0;
+ int statusBarColor = 0;
+ int navigationBarColor = 0;
+ boolean topActivity = true;
+ for (--activityNdx; activityNdx >= 0; --activityNdx) {
+ final ActivityRecord r = mActivities.get(activityNdx);
+ if (r.mTaskOverlay) {
+ continue;
+ }
+ if (r.taskDescription != null) {
+ if (label == null) {
+ label = r.taskDescription.getLabel();
+ }
+ if (iconResource == -1) {
+ iconResource = r.taskDescription.getIconResource();
+ }
+ if (iconFilename == null) {
+ iconFilename = r.taskDescription.getIconFilename();
+ }
+ if (colorPrimary == 0) {
+ colorPrimary = r.taskDescription.getPrimaryColor();
+ }
+ if (topActivity) {
+ colorBackground = r.taskDescription.getBackgroundColor();
+ statusBarColor = r.taskDescription.getStatusBarColor();
+ navigationBarColor = r.taskDescription.getNavigationBarColor();
+ }
+ }
+ topActivity = false;
+ }
+ lastTaskDescription = new TaskDescription(label, null, iconResource, iconFilename,
+ colorPrimary, colorBackground, statusBarColor, navigationBarColor);
+ if (mWindowContainerController != null) {
+ mWindowContainerController.setTaskDescription(lastTaskDescription);
+ }
+ // Update the task affiliation color if we are the parent of the group
+ if (taskId == mAffiliatedTaskId) {
+ mAffiliatedTaskColor = lastTaskDescription.getPrimaryColor();
+ }
+ }
+ }
+
+ int findEffectiveRootIndex() {
+ int effectiveNdx = 0;
+ final int topActivityNdx = mActivities.size() - 1;
+ for (int activityNdx = 0; activityNdx <= topActivityNdx; ++activityNdx) {
+ final ActivityRecord r = mActivities.get(activityNdx);
+ if (r.finishing) {
+ continue;
+ }
+ effectiveNdx = activityNdx;
+ if ((r.info.flags & FLAG_RELINQUISH_TASK_IDENTITY) == 0) {
+ break;
+ }
+ }
+ return effectiveNdx;
+ }
+
+ void updateEffectiveIntent() {
+ final int effectiveRootIndex = findEffectiveRootIndex();
+ final ActivityRecord r = mActivities.get(effectiveRootIndex);
+ setIntent(r);
+
+ // Update the task description when the activities change
+ updateTaskDescription();
+ }
+
+ private void adjustForMinimalTaskDimensions(Rect bounds) {
+ if (bounds == null) {
+ return;
+ }
+ int minWidth = mMinWidth;
+ int minHeight = mMinHeight;
+ // If the task has no requested minimal size, we'd like to enforce a minimal size
+ // so that the user can not render the task too small to manipulate. We don't need
+ // to do this for the pinned stack as the bounds are controlled by the system.
+ if (!inPinnedWindowingMode()) {
+ final int defaultMinSizeDp =
+ mService.mStackSupervisor.mDefaultMinSizeOfResizeableTaskDp;
+ final ActivityDisplay display =
+ mService.mStackSupervisor.getActivityDisplay(mStack.mDisplayId);
+ final float density =
+ (float) display.getConfiguration().densityDpi / DisplayMetrics.DENSITY_DEFAULT;
+ final int defaultMinSize = (int) (defaultMinSizeDp * density);
+
+ if (minWidth == INVALID_MIN_SIZE) {
+ minWidth = defaultMinSize;
+ }
+ if (minHeight == INVALID_MIN_SIZE) {
+ minHeight = defaultMinSize;
+ }
+ }
+ final boolean adjustWidth = minWidth > bounds.width();
+ final boolean adjustHeight = minHeight > bounds.height();
+ if (!(adjustWidth || adjustHeight)) {
+ return;
+ }
+
+ final Rect configBounds = getOverrideBounds();
+ if (adjustWidth) {
+ if (!configBounds.isEmpty() && bounds.right == configBounds.right) {
+ bounds.left = bounds.right - minWidth;
+ } else {
+ // Either left bounds match, or neither match, or the previous bounds were
+ // fullscreen and we default to keeping left.
+ bounds.right = bounds.left + minWidth;
+ }
+ }
+ if (adjustHeight) {
+ if (!configBounds.isEmpty() && bounds.bottom == configBounds.bottom) {
+ bounds.top = bounds.bottom - minHeight;
+ } else {
+ // Either top bounds match, or neither match, or the previous bounds were
+ // fullscreen and we default to keeping top.
+ bounds.bottom = bounds.top + minHeight;
+ }
+ }
+ }
+
+ /**
+ * @return a new Configuration for this Task, given the provided {@param bounds} and
+ * {@param insetBounds}.
+ */
+ Configuration computeNewOverrideConfigurationForBounds(Rect bounds, Rect insetBounds) {
+ // Compute a new override configuration for the given bounds, if fullscreen bounds
+ // (bounds == null), then leave the override config unset
+ final Configuration newOverrideConfig = new Configuration();
+ if (bounds != null) {
+ newOverrideConfig.setTo(getOverrideConfiguration());
+ mTmpRect.set(bounds);
+ adjustForMinimalTaskDimensions(mTmpRect);
+ computeOverrideConfiguration(newOverrideConfig, mTmpRect, insetBounds,
+ mTmpRect.right != bounds.right, mTmpRect.bottom != bounds.bottom);
+ }
+
+ return newOverrideConfig;
+ }
+
+ /**
+ * Update task's override configuration based on the bounds.
+ * @param bounds The bounds of the task.
+ * @return True if the override configuration was updated.
+ */
+ boolean updateOverrideConfiguration(Rect bounds) {
+ return updateOverrideConfiguration(bounds, null /* insetBounds */);
+ }
+
+ void setLastNonFullscreenBounds(Rect bounds) {
+ if (mLastNonFullscreenBounds == null) {
+ mLastNonFullscreenBounds = new Rect(bounds);
+ } else {
+ mLastNonFullscreenBounds.set(bounds);
+ }
+ }
+
+ /**
+ * Update task's override configuration based on the bounds.
+ * @param bounds The bounds of the task.
+ * @param insetBounds The bounds used to calculate the system insets, which is used here to
+ * subtract the navigation bar/status bar size from the screen size reported
+ * to the application. See {@link IActivityTaskManager#resizeDockedStack}.
+ * @return True if the override configuration was updated.
+ */
+ boolean updateOverrideConfiguration(Rect bounds, @Nullable Rect insetBounds) {
+ if (equivalentOverrideBounds(bounds)) {
+ return false;
+ }
+ final Rect currentBounds = getOverrideBounds();
+
+ mTmpConfig.setTo(getOverrideConfiguration());
+ final Configuration newConfig = getOverrideConfiguration();
+
+ final boolean matchParentBounds = bounds == null || bounds.isEmpty();
+ final boolean persistBounds = getWindowConfiguration().persistTaskBounds();
+ if (matchParentBounds) {
+ if (!currentBounds.isEmpty() && persistBounds) {
+ setLastNonFullscreenBounds(currentBounds);
+ }
+ setBounds(null);
+ newConfig.unset();
+ } else {
+ mTmpRect.set(bounds);
+ adjustForMinimalTaskDimensions(mTmpRect);
+ setBounds(mTmpRect);
+
+ if (mStack == null || persistBounds) {
+ setLastNonFullscreenBounds(getOverrideBounds());
+ }
+ computeOverrideConfiguration(newConfig, mTmpRect, insetBounds,
+ mTmpRect.right != bounds.right, mTmpRect.bottom != bounds.bottom);
+ }
+ onOverrideConfigurationChanged(newConfig);
+ return !mTmpConfig.equals(newConfig);
+ }
+
+ /**
+ * This should be called when an child activity changes state. This should only
+ * be called from
+ * {@link ActivityRecord#setState(ActivityState, String)} .
+ * @param record The {@link ActivityRecord} whose state has changed.
+ * @param state The new state.
+ * @param reason The reason for the change.
+ */
+ void onActivityStateChanged(ActivityRecord record, ActivityState state, String reason) {
+ final ActivityStack parent = getStack();
+
+ if (parent != null) {
+ parent.onActivityStateChanged(record, state, reason);
+ }
+ }
+
+ @Override
+ public void onConfigurationChanged(Configuration newParentConfig) {
+ final boolean wasInMultiWindowMode = inMultiWindowMode();
+ super.onConfigurationChanged(newParentConfig);
+ if (wasInMultiWindowMode != inMultiWindowMode()) {
+ mService.mStackSupervisor.scheduleUpdateMultiWindowMode(this);
+ }
+ // TODO: Should also take care of Pip mode changes here.
+ }
+
+ /** Clears passed config and fills it with new override values. */
+ // TODO(b/36505427): TaskRecord.computeOverrideConfiguration() is a utility method that doesn't
+ // depend on task or stacks, but uses those object to get the display to base the calculation
+ // on. Probably best to centralize calculations like this in ConfigurationContainer.
+ void computeOverrideConfiguration(Configuration config, Rect bounds, Rect insetBounds,
+ boolean overrideWidth, boolean overrideHeight) {
+ mTmpNonDecorBounds.set(bounds);
+ mTmpStableBounds.set(bounds);
+
+ config.unset();
+ final Configuration parentConfig = getParent().getConfiguration();
+
+ final float density = parentConfig.densityDpi * DisplayMetrics.DENSITY_DEFAULT_SCALE;
+
+ if (mStack != null) {
+ final StackWindowController stackController = mStack.getWindowContainerController();
+ stackController.adjustConfigurationForBounds(bounds, insetBounds,
+ mTmpNonDecorBounds, mTmpStableBounds, overrideWidth, overrideHeight, density,
+ config, parentConfig, getWindowingMode());
+ } else {
+ throw new IllegalArgumentException("Expected stack when calculating override config");
+ }
+
+ config.orientation = (config.screenWidthDp <= config.screenHeightDp)
+ ? Configuration.ORIENTATION_PORTRAIT
+ : Configuration.ORIENTATION_LANDSCAPE;
+
+ // For calculating screen layout, we need to use the non-decor inset screen area for the
+ // calculation for compatibility reasons, i.e. screen area without system bars that could
+ // never go away in Honeycomb.
+ final int compatScreenWidthDp = (int) (mTmpNonDecorBounds.width() / density);
+ final int compatScreenHeightDp = (int) (mTmpNonDecorBounds.height() / density);
+ // We're only overriding LONG, SIZE and COMPAT parts of screenLayout, so we start override
+ // calculation with partial default.
+ // Reducing the screen layout starting from its parent config.
+ final int sl = parentConfig.screenLayout &
+ (Configuration.SCREENLAYOUT_LONG_MASK | Configuration.SCREENLAYOUT_SIZE_MASK);
+ final int longSize = Math.max(compatScreenHeightDp, compatScreenWidthDp);
+ final int shortSize = Math.min(compatScreenHeightDp, compatScreenWidthDp);
+ config.screenLayout = Configuration.reduceScreenLayout(sl, longSize, shortSize);
+ }
+
+ Rect updateOverrideConfigurationFromLaunchBounds() {
+ final Rect bounds = getLaunchBounds();
+ updateOverrideConfiguration(bounds);
+ if (bounds != null && !bounds.isEmpty()) {
+ // TODO: Review if we actually want to do this - we are setting the launch bounds
+ // directly here.
+ bounds.set(getOverrideBounds());
+ }
+ return bounds;
+ }
+
+ /** Updates the task's bounds and override configuration to match what is expected for the
+ * input stack. */
+ void updateOverrideConfigurationForStack(ActivityStack inStack) {
+ if (mStack != null && mStack == inStack) {
+ return;
+ }
+
+ if (inStack.inFreeformWindowingMode()) {
+ if (!isResizeable()) {
+ throw new IllegalArgumentException("Can not position non-resizeable task="
+ + this + " in stack=" + inStack);
+ }
+ if (!matchParentBounds()) {
+ return;
+ }
+ if (mLastNonFullscreenBounds != null) {
+ updateOverrideConfiguration(mLastNonFullscreenBounds);
+ } else {
+ mService.mStackSupervisor.getLaunchParamsController().layoutTask(this, null);
+ }
+ } else {
+ updateOverrideConfiguration(inStack.getOverrideBounds());
+ }
+ }
+
+ /** Returns the bounds that should be used to launch this task. */
+ Rect getLaunchBounds() {
+ if (mStack == null) {
+ return null;
+ }
+
+ final int windowingMode = getWindowingMode();
+ if (!isActivityTypeStandardOrUndefined()
+ || windowingMode == WINDOWING_MODE_FULLSCREEN
+ || (windowingMode == WINDOWING_MODE_SPLIT_SCREEN_PRIMARY && !isResizeable())) {
+ return isResizeable() ? mStack.getOverrideBounds() : null;
+ } else if (!getWindowConfiguration().persistTaskBounds()) {
+ return mStack.getOverrideBounds();
+ }
+ return mLastNonFullscreenBounds;
+ }
+
+ void addStartingWindowsForVisibleActivities(boolean taskSwitch) {
+ for (int activityNdx = mActivities.size() - 1; activityNdx >= 0; --activityNdx) {
+ final ActivityRecord r = mActivities.get(activityNdx);
+ if (r.visible) {
+ r.showStartingWindow(null /* prev */, false /* newTask */, taskSwitch);
+ }
+ }
+ }
+
+ void setRootProcess(WindowProcessController proc) {
+ clearRootProcess();
+ if (intent != null &&
+ (intent.getFlags() & Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS) == 0) {
+ mRootProcess = proc;
+ mRootProcess.addRecentTask(this);
+ }
+ }
+
+ void clearRootProcess() {
+ if (mRootProcess != null) {
+ mRootProcess.removeRecentTask(this);
+ mRootProcess = null;
+ }
+ }
+
+ void clearAllPendingOptions() {
+ for (int i = getChildCount() - 1; i >= 0; i--) {
+ getChildAt(i).clearOptionsLocked(false /* withAbort */);
+ }
+ }
+
+ /**
+ * Fills in a {@link TaskInfo} with information from this task.
+ * @param info the {@link TaskInfo} to fill in
+ * @param reuseActivitiesReport a temporary activities report that we can reuse to fetch the
+ * running activities
+ */
+ void fillTaskInfo(TaskInfo info, TaskActivitiesReport reuseActivitiesReport) {
+ getNumRunningActivities(reuseActivitiesReport);
+ info.userId = userId;
+ info.stackId = getStackId();
+ info.taskId = taskId;
+ info.isRunning = getTopActivity() != null;
+ info.baseIntent = getBaseIntent();
+ info.baseActivity = reuseActivitiesReport.base != null
+ ? reuseActivitiesReport.base.intent.getComponent()
+ : null;
+ info.topActivity = reuseActivitiesReport.top != null
+ ? reuseActivitiesReport.top.intent.getComponent()
+ : null;
+ info.origActivity = origActivity;
+ info.realActivity = realActivity;
+ info.numActivities = reuseActivitiesReport.numActivities;
+ info.lastActiveTime = lastActiveTime;
+ info.taskDescription = new ActivityManager.TaskDescription(lastTaskDescription);
+ info.supportsSplitScreenMultiWindow = supportsSplitScreenWindowingMode();
+ info.resizeMode = mResizeMode;
+ info.configuration.setTo(getConfiguration());
+ }
+
+ void dump(PrintWriter pw, String prefix) {
+ pw.print(prefix); pw.print("userId="); pw.print(userId);
+ pw.print(" effectiveUid="); UserHandle.formatUid(pw, effectiveUid);
+ pw.print(" mCallingUid="); UserHandle.formatUid(pw, mCallingUid);
+ pw.print(" mUserSetupComplete="); pw.print(mUserSetupComplete);
+ pw.print(" mCallingPackage="); pw.println(mCallingPackage);
+ if (affinity != null || rootAffinity != null) {
+ pw.print(prefix); pw.print("affinity="); pw.print(affinity);
+ if (affinity == null || !affinity.equals(rootAffinity)) {
+ pw.print(" root="); pw.println(rootAffinity);
+ } else {
+ pw.println();
+ }
+ }
+ if (voiceSession != null || voiceInteractor != null) {
+ pw.print(prefix); pw.print("VOICE: session=0x");
+ pw.print(Integer.toHexString(System.identityHashCode(voiceSession)));
+ pw.print(" interactor=0x");
+ pw.println(Integer.toHexString(System.identityHashCode(voiceInteractor)));
+ }
+ if (intent != null) {
+ StringBuilder sb = new StringBuilder(128);
+ sb.append(prefix); sb.append("intent={");
+ intent.toShortString(sb, false, true, false, true);
+ sb.append('}');
+ pw.println(sb.toString());
+ }
+ if (affinityIntent != null) {
+ StringBuilder sb = new StringBuilder(128);
+ sb.append(prefix); sb.append("affinityIntent={");
+ affinityIntent.toShortString(sb, false, true, false, true);
+ sb.append('}');
+ pw.println(sb.toString());
+ }
+ if (origActivity != null) {
+ pw.print(prefix); pw.print("origActivity=");
+ pw.println(origActivity.flattenToShortString());
+ }
+ if (realActivity != null) {
+ pw.print(prefix); pw.print("realActivity=");
+ pw.println(realActivity.flattenToShortString());
+ }
+ if (autoRemoveRecents || isPersistable || !isActivityTypeStandard() || numFullscreen != 0) {
+ pw.print(prefix); pw.print("autoRemoveRecents="); pw.print(autoRemoveRecents);
+ pw.print(" isPersistable="); pw.print(isPersistable);
+ pw.print(" numFullscreen="); pw.print(numFullscreen);
+ pw.print(" activityType="); pw.println(getActivityType());
+ }
+ if (rootWasReset || mNeverRelinquishIdentity || mReuseTask
+ || mLockTaskAuth != LOCK_TASK_AUTH_PINNABLE) {
+ pw.print(prefix); pw.print("rootWasReset="); pw.print(rootWasReset);
+ pw.print(" mNeverRelinquishIdentity="); pw.print(mNeverRelinquishIdentity);
+ pw.print(" mReuseTask="); pw.print(mReuseTask);
+ pw.print(" mLockTaskAuth="); pw.println(lockTaskAuthToString());
+ }
+ if (mAffiliatedTaskId != taskId || mPrevAffiliateTaskId != INVALID_TASK_ID
+ || mPrevAffiliate != null || mNextAffiliateTaskId != INVALID_TASK_ID
+ || mNextAffiliate != null) {
+ pw.print(prefix); pw.print("affiliation="); pw.print(mAffiliatedTaskId);
+ pw.print(" prevAffiliation="); pw.print(mPrevAffiliateTaskId);
+ pw.print(" (");
+ if (mPrevAffiliate == null) {
+ pw.print("null");
+ } else {
+ pw.print(Integer.toHexString(System.identityHashCode(mPrevAffiliate)));
+ }
+ pw.print(") nextAffiliation="); pw.print(mNextAffiliateTaskId);
+ pw.print(" (");
+ if (mNextAffiliate == null) {
+ pw.print("null");
+ } else {
+ pw.print(Integer.toHexString(System.identityHashCode(mNextAffiliate)));
+ }
+ pw.println(")");
+ }
+ pw.print(prefix); pw.print("Activities="); pw.println(mActivities);
+ if (!askedCompatMode || !inRecents || !isAvailable) {
+ pw.print(prefix); pw.print("askedCompatMode="); pw.print(askedCompatMode);
+ pw.print(" inRecents="); pw.print(inRecents);
+ pw.print(" isAvailable="); pw.println(isAvailable);
+ }
+ if (lastDescription != null) {
+ pw.print(prefix); pw.print("lastDescription="); pw.println(lastDescription);
+ }
+ if (mRootProcess != null) {
+ pw.print(prefix); pw.print("mRootProcess="); pw.println(mRootProcess);
+ }
+ pw.print(prefix); pw.print("stackId="); pw.println(getStackId());
+ pw.print(prefix + "hasBeenVisible=" + hasBeenVisible);
+ pw.print(" mResizeMode=" + ActivityInfo.resizeModeToString(mResizeMode));
+ pw.print(" mSupportsPictureInPicture=" + mSupportsPictureInPicture);
+ pw.print(" isResizeable=" + isResizeable());
+ pw.print(" lastActiveTime=" + lastActiveTime);
+ pw.println(" (inactive for " + (getInactiveDuration() / 1000) + "s)");
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder(128);
+ if (stringName != null) {
+ sb.append(stringName);
+ sb.append(" U=");
+ sb.append(userId);
+ sb.append(" StackId=");
+ sb.append(getStackId());
+ sb.append(" sz=");
+ sb.append(mActivities.size());
+ sb.append('}');
+ return sb.toString();
+ }
+ sb.append("TaskRecord{");
+ sb.append(Integer.toHexString(System.identityHashCode(this)));
+ sb.append(" #");
+ sb.append(taskId);
+ if (affinity != null) {
+ sb.append(" A=");
+ sb.append(affinity);
+ } else if (intent != null) {
+ sb.append(" I=");
+ sb.append(intent.getComponent().flattenToShortString());
+ } else if (affinityIntent != null && affinityIntent.getComponent() != null) {
+ sb.append(" aI=");
+ sb.append(affinityIntent.getComponent().flattenToShortString());
+ } else {
+ sb.append(" ??");
+ }
+ stringName = sb.toString();
+ return toString();
+ }
+
+ public void writeToProto(ProtoOutputStream proto, long fieldId) {
+ final long token = proto.start(fieldId);
+ super.writeToProto(proto, CONFIGURATION_CONTAINER, false /* trim */);
+ proto.write(ID, taskId);
+ for (int i = mActivities.size() - 1; i >= 0; i--) {
+ ActivityRecord activity = mActivities.get(i);
+ activity.writeToProto(proto, ACTIVITIES);
+ }
+ proto.write(STACK_ID, mStack.mStackId);
+ if (mLastNonFullscreenBounds != null) {
+ mLastNonFullscreenBounds.writeToProto(proto, LAST_NON_FULLSCREEN_BOUNDS);
+ }
+ if (realActivity != null) {
+ proto.write(REAL_ACTIVITY, realActivity.flattenToShortString());
+ }
+ if (origActivity != null) {
+ proto.write(ORIG_ACTIVITY, origActivity.flattenToShortString());
+ }
+ proto.write(ACTIVITY_TYPE, getActivityType());
+ proto.write(RESIZE_MODE, mResizeMode);
+ // TODO: Remove, no longer needed with windowingMode.
+ proto.write(FULLSCREEN, matchParentBounds());
+
+ if (!matchParentBounds()) {
+ final Rect bounds = getOverrideBounds();
+ bounds.writeToProto(proto, BOUNDS);
+ }
+ proto.write(MIN_WIDTH, mMinWidth);
+ proto.write(MIN_HEIGHT, mMinHeight);
+ proto.end(token);
+ }
+
+ /**
+ * See {@link #getNumRunningActivities(TaskActivitiesReport)}.
+ */
+ static class TaskActivitiesReport {
+ int numRunning;
+ int numActivities;
+ ActivityRecord top;
+ ActivityRecord base;
+
+ void reset() {
+ numRunning = numActivities = 0;
+ top = base = null;
+ }
+ }
+
+ /**
+ * Saves this {@link TaskRecord} to XML using given serializer.
+ */
+ void saveToXml(XmlSerializer out) throws IOException, XmlPullParserException {
+ if (DEBUG_RECENTS) Slog.i(TAG_RECENTS, "Saving task=" + this);
+
+ out.attribute(null, ATTR_TASKID, String.valueOf(taskId));
+ if (realActivity != null) {
+ out.attribute(null, ATTR_REALACTIVITY, realActivity.flattenToShortString());
+ }
+ out.attribute(null, ATTR_REALACTIVITY_SUSPENDED, String.valueOf(realActivitySuspended));
+ if (origActivity != null) {
+ out.attribute(null, ATTR_ORIGACTIVITY, origActivity.flattenToShortString());
+ }
+ // Write affinity, and root affinity if it is different from affinity.
+ // We use the special string "@" for a null root affinity, so we can identify
+ // later whether we were given a root affinity or should just make it the
+ // same as the affinity.
+ if (affinity != null) {
+ out.attribute(null, ATTR_AFFINITY, affinity);
+ if (!affinity.equals(rootAffinity)) {
+ out.attribute(null, ATTR_ROOT_AFFINITY, rootAffinity != null ? rootAffinity : "@");
+ }
+ } else if (rootAffinity != null) {
+ out.attribute(null, ATTR_ROOT_AFFINITY, rootAffinity != null ? rootAffinity : "@");
+ }
+ out.attribute(null, ATTR_ROOTHASRESET, String.valueOf(rootWasReset));
+ out.attribute(null, ATTR_AUTOREMOVERECENTS, String.valueOf(autoRemoveRecents));
+ out.attribute(null, ATTR_ASKEDCOMPATMODE, String.valueOf(askedCompatMode));
+ out.attribute(null, ATTR_USERID, String.valueOf(userId));
+ out.attribute(null, ATTR_USER_SETUP_COMPLETE, String.valueOf(mUserSetupComplete));
+ out.attribute(null, ATTR_EFFECTIVE_UID, String.valueOf(effectiveUid));
+ out.attribute(null, ATTR_LASTTIMEMOVED, String.valueOf(mLastTimeMoved));
+ out.attribute(null, ATTR_NEVERRELINQUISH, String.valueOf(mNeverRelinquishIdentity));
+ if (lastDescription != null) {
+ out.attribute(null, ATTR_LASTDESCRIPTION, lastDescription.toString());
+ }
+ if (lastTaskDescription != null) {
+ lastTaskDescription.saveToXml(out);
+ }
+ out.attribute(null, ATTR_TASK_AFFILIATION_COLOR, String.valueOf(mAffiliatedTaskColor));
+ out.attribute(null, ATTR_TASK_AFFILIATION, String.valueOf(mAffiliatedTaskId));
+ out.attribute(null, ATTR_PREV_AFFILIATION, String.valueOf(mPrevAffiliateTaskId));
+ out.attribute(null, ATTR_NEXT_AFFILIATION, String.valueOf(mNextAffiliateTaskId));
+ out.attribute(null, ATTR_CALLING_UID, String.valueOf(mCallingUid));
+ out.attribute(null, ATTR_CALLING_PACKAGE, mCallingPackage == null ? "" : mCallingPackage);
+ out.attribute(null, ATTR_RESIZE_MODE, String.valueOf(mResizeMode));
+ out.attribute(null, ATTR_SUPPORTS_PICTURE_IN_PICTURE,
+ String.valueOf(mSupportsPictureInPicture));
+ if (mLastNonFullscreenBounds != null) {
+ out.attribute(
+ null, ATTR_NON_FULLSCREEN_BOUNDS, mLastNonFullscreenBounds.flattenToString());
+ }
+ out.attribute(null, ATTR_MIN_WIDTH, String.valueOf(mMinWidth));
+ out.attribute(null, ATTR_MIN_HEIGHT, String.valueOf(mMinHeight));
+ out.attribute(null, ATTR_PERSIST_TASK_VERSION, String.valueOf(PERSIST_TASK_VERSION));
+
+ if (affinityIntent != null) {
+ out.startTag(null, TAG_AFFINITYINTENT);
+ affinityIntent.saveToXml(out);
+ out.endTag(null, TAG_AFFINITYINTENT);
+ }
+
+ if (intent != null) {
+ out.startTag(null, TAG_INTENT);
+ intent.saveToXml(out);
+ out.endTag(null, TAG_INTENT);
+ }
+
+ final ArrayList<ActivityRecord> activities = mActivities;
+ final int numActivities = activities.size();
+ for (int activityNdx = 0; activityNdx < numActivities; ++activityNdx) {
+ final ActivityRecord r = activities.get(activityNdx);
+ if (r.info.persistableMode == ActivityInfo.PERSIST_ROOT_ONLY || !r.isPersistable() ||
+ ((r.intent.getFlags() & FLAG_ACTIVITY_NEW_DOCUMENT
+ | FLAG_ACTIVITY_RETAIN_IN_RECENTS) == FLAG_ACTIVITY_NEW_DOCUMENT) &&
+ activityNdx > 0) {
+ // Stop at first non-persistable or first break in task (CLEAR_WHEN_TASK_RESET).
+ break;
+ }
+ out.startTag(null, TAG_ACTIVITY);
+ r.saveToXml(out);
+ out.endTag(null, TAG_ACTIVITY);
+ }
+ }
+
+ @VisibleForTesting
+ static TaskRecordFactory getTaskRecordFactory() {
+ if (sTaskRecordFactory == null) {
+ setTaskRecordFactory(new TaskRecordFactory());
+ }
+ return sTaskRecordFactory;
+ }
+
+ static void setTaskRecordFactory(TaskRecordFactory factory) {
+ sTaskRecordFactory = factory;
+ }
+
+ static TaskRecord create(ActivityTaskManagerService service, int taskId, ActivityInfo info,
+ Intent intent, IVoiceInteractionSession voiceSession,
+ IVoiceInteractor voiceInteractor) {
+ return getTaskRecordFactory().create(
+ service, taskId, info, intent, voiceSession, voiceInteractor);
+ }
+
+ static TaskRecord create(ActivityTaskManagerService service, int taskId, ActivityInfo info,
+ Intent intent, TaskDescription taskDescription) {
+ return getTaskRecordFactory().create(service, taskId, info, intent, taskDescription);
+ }
+
+ static TaskRecord restoreFromXml(XmlPullParser in, ActivityStackSupervisor stackSupervisor)
+ throws IOException, XmlPullParserException {
+ return getTaskRecordFactory().restoreFromXml(in, stackSupervisor);
+ }
+
+ /**
+ * A factory class used to create {@link TaskRecord} or its subclass if any. This can be
+ * specified when system boots by setting it with
+ * {@link #setTaskRecordFactory(TaskRecordFactory)}.
+ */
+ static class TaskRecordFactory {
+
+ TaskRecord create(ActivityTaskManagerService service, int taskId, ActivityInfo info,
+ Intent intent, IVoiceInteractionSession voiceSession,
+ IVoiceInteractor voiceInteractor) {
+ return new TaskRecord(
+ service, taskId, info, intent, voiceSession, voiceInteractor);
+ }
+
+ TaskRecord create(ActivityTaskManagerService service, int taskId, ActivityInfo info,
+ Intent intent, TaskDescription taskDescription) {
+ return new TaskRecord(service, taskId, info, intent, taskDescription);
+ }
+
+ /**
+ * Should only be used when we're restoring {@link TaskRecord} from storage.
+ */
+ TaskRecord create(ActivityTaskManagerService service, int taskId, Intent intent,
+ Intent affinityIntent, String affinity, String rootAffinity,
+ ComponentName realActivity, ComponentName origActivity, boolean rootWasReset,
+ boolean autoRemoveRecents, boolean askedCompatMode, int userId,
+ int effectiveUid, String lastDescription, ArrayList<ActivityRecord> activities,
+ long lastTimeMoved, boolean neverRelinquishIdentity,
+ TaskDescription lastTaskDescription, int taskAffiliation, int prevTaskId,
+ int nextTaskId, int taskAffiliationColor, int callingUid, String callingPackage,
+ int resizeMode, boolean supportsPictureInPicture, boolean realActivitySuspended,
+ boolean userSetupComplete, int minWidth, int minHeight) {
+ return new TaskRecord(service, taskId, intent, affinityIntent, affinity,
+ rootAffinity, realActivity, origActivity, rootWasReset, autoRemoveRecents,
+ askedCompatMode, userId, effectiveUid, lastDescription, activities,
+ lastTimeMoved, neverRelinquishIdentity, lastTaskDescription, taskAffiliation,
+ prevTaskId, nextTaskId, taskAffiliationColor, callingUid, callingPackage,
+ resizeMode, supportsPictureInPicture, realActivitySuspended, userSetupComplete,
+ minWidth, minHeight);
+ }
+
+ TaskRecord restoreFromXml(XmlPullParser in, ActivityStackSupervisor stackSupervisor)
+ throws IOException, XmlPullParserException {
+ Intent intent = null;
+ Intent affinityIntent = null;
+ ArrayList<ActivityRecord> activities = new ArrayList<>();
+ ComponentName realActivity = null;
+ boolean realActivitySuspended = false;
+ ComponentName origActivity = null;
+ String affinity = null;
+ String rootAffinity = null;
+ boolean hasRootAffinity = false;
+ boolean rootHasReset = false;
+ boolean autoRemoveRecents = false;
+ boolean askedCompatMode = false;
+ int taskType = 0;
+ int userId = 0;
+ boolean userSetupComplete = true;
+ int effectiveUid = -1;
+ String lastDescription = null;
+ long lastTimeOnTop = 0;
+ boolean neverRelinquishIdentity = true;
+ int taskId = INVALID_TASK_ID;
+ final int outerDepth = in.getDepth();
+ TaskDescription taskDescription = new TaskDescription();
+ int taskAffiliation = INVALID_TASK_ID;
+ int taskAffiliationColor = 0;
+ int prevTaskId = INVALID_TASK_ID;
+ int nextTaskId = INVALID_TASK_ID;
+ int callingUid = -1;
+ String callingPackage = "";
+ int resizeMode = RESIZE_MODE_FORCE_RESIZEABLE;
+ boolean supportsPictureInPicture = false;
+ Rect lastNonFullscreenBounds = null;
+ int minWidth = INVALID_MIN_SIZE;
+ int minHeight = INVALID_MIN_SIZE;
+ int persistTaskVersion = 0;
+
+ for (int attrNdx = in.getAttributeCount() - 1; attrNdx >= 0; --attrNdx) {
+ final String attrName = in.getAttributeName(attrNdx);
+ final String attrValue = in.getAttributeValue(attrNdx);
+ if (TaskPersister.DEBUG) Slog.d(TaskPersister.TAG, "TaskRecord: attribute name=" +
+ attrName + " value=" + attrValue);
+ switch (attrName) {
+ case ATTR_TASKID:
+ if (taskId == INVALID_TASK_ID) taskId = Integer.parseInt(attrValue);
+ break;
+ case ATTR_REALACTIVITY:
+ realActivity = ComponentName.unflattenFromString(attrValue);
+ break;
+ case ATTR_REALACTIVITY_SUSPENDED:
+ realActivitySuspended = Boolean.valueOf(attrValue);
+ break;
+ case ATTR_ORIGACTIVITY:
+ origActivity = ComponentName.unflattenFromString(attrValue);
+ break;
+ case ATTR_AFFINITY:
+ affinity = attrValue;
+ break;
+ case ATTR_ROOT_AFFINITY:
+ rootAffinity = attrValue;
+ hasRootAffinity = true;
+ break;
+ case ATTR_ROOTHASRESET:
+ rootHasReset = Boolean.parseBoolean(attrValue);
+ break;
+ case ATTR_AUTOREMOVERECENTS:
+ autoRemoveRecents = Boolean.parseBoolean(attrValue);
+ break;
+ case ATTR_ASKEDCOMPATMODE:
+ askedCompatMode = Boolean.parseBoolean(attrValue);
+ break;
+ case ATTR_USERID:
+ userId = Integer.parseInt(attrValue);
+ break;
+ case ATTR_USER_SETUP_COMPLETE:
+ userSetupComplete = Boolean.parseBoolean(attrValue);
+ break;
+ case ATTR_EFFECTIVE_UID:
+ effectiveUid = Integer.parseInt(attrValue);
+ break;
+ case ATTR_TASKTYPE:
+ taskType = Integer.parseInt(attrValue);
+ break;
+ case ATTR_LASTDESCRIPTION:
+ lastDescription = attrValue;
+ break;
+ case ATTR_LASTTIMEMOVED:
+ lastTimeOnTop = Long.parseLong(attrValue);
+ break;
+ case ATTR_NEVERRELINQUISH:
+ neverRelinquishIdentity = Boolean.parseBoolean(attrValue);
+ break;
+ case ATTR_TASK_AFFILIATION:
+ taskAffiliation = Integer.parseInt(attrValue);
+ break;
+ case ATTR_PREV_AFFILIATION:
+ prevTaskId = Integer.parseInt(attrValue);
+ break;
+ case ATTR_NEXT_AFFILIATION:
+ nextTaskId = Integer.parseInt(attrValue);
+ break;
+ case ATTR_TASK_AFFILIATION_COLOR:
+ taskAffiliationColor = Integer.parseInt(attrValue);
+ break;
+ case ATTR_CALLING_UID:
+ callingUid = Integer.parseInt(attrValue);
+ break;
+ case ATTR_CALLING_PACKAGE:
+ callingPackage = attrValue;
+ break;
+ case ATTR_RESIZE_MODE:
+ resizeMode = Integer.parseInt(attrValue);
+ break;
+ case ATTR_SUPPORTS_PICTURE_IN_PICTURE:
+ supportsPictureInPicture = Boolean.parseBoolean(attrValue);
+ break;
+ case ATTR_NON_FULLSCREEN_BOUNDS:
+ lastNonFullscreenBounds = Rect.unflattenFromString(attrValue);
+ break;
+ case ATTR_MIN_WIDTH:
+ minWidth = Integer.parseInt(attrValue);
+ break;
+ case ATTR_MIN_HEIGHT:
+ minHeight = Integer.parseInt(attrValue);
+ break;
+ case ATTR_PERSIST_TASK_VERSION:
+ persistTaskVersion = Integer.parseInt(attrValue);
+ break;
+ default:
+ if (attrName.startsWith(TaskDescription.ATTR_TASKDESCRIPTION_PREFIX)) {
+ taskDescription.restoreFromXml(attrName, attrValue);
+ } else {
+ Slog.w(TAG, "TaskRecord: Unknown attribute=" + attrName);
+ }
+ }
+ }
+
+ int event;
+ while (((event = in.next()) != XmlPullParser.END_DOCUMENT) &&
+ (event != XmlPullParser.END_TAG || in.getDepth() >= outerDepth)) {
+ if (event == XmlPullParser.START_TAG) {
+ final String name = in.getName();
+ if (TaskPersister.DEBUG) Slog.d(TaskPersister.TAG,
+ "TaskRecord: START_TAG name=" + name);
+ if (TAG_AFFINITYINTENT.equals(name)) {
+ affinityIntent = Intent.restoreFromXml(in);
+ } else if (TAG_INTENT.equals(name)) {
+ intent = Intent.restoreFromXml(in);
+ } else if (TAG_ACTIVITY.equals(name)) {
+ ActivityRecord activity =
+ ActivityRecord.restoreFromXml(in, stackSupervisor);
+ if (TaskPersister.DEBUG) Slog.d(TaskPersister.TAG, "TaskRecord: activity=" +
+ activity);
+ if (activity != null) {
+ activities.add(activity);
+ }
+ } else {
+ handleUnknownTag(name, in);
+ }
+ }
+ }
+ if (!hasRootAffinity) {
+ rootAffinity = affinity;
+ } else if ("@".equals(rootAffinity)) {
+ rootAffinity = null;
+ }
+ if (effectiveUid <= 0) {
+ Intent checkIntent = intent != null ? intent : affinityIntent;
+ effectiveUid = 0;
+ if (checkIntent != null) {
+ IPackageManager pm = AppGlobals.getPackageManager();
+ try {
+ ApplicationInfo ai = pm.getApplicationInfo(
+ checkIntent.getComponent().getPackageName(),
+ PackageManager.MATCH_UNINSTALLED_PACKAGES
+ | PackageManager.MATCH_DISABLED_COMPONENTS, userId);
+ if (ai != null) {
+ effectiveUid = ai.uid;
+ }
+ } catch (RemoteException e) {
+ }
+ }
+ Slog.w(TAG, "Updating task #" + taskId + " for " + checkIntent
+ + ": effectiveUid=" + effectiveUid);
+ }
+
+ if (persistTaskVersion < 1) {
+ // We need to convert the resize mode of home activities saved before version one if
+ // they are marked as RESIZE_MODE_RESIZEABLE to
+ // RESIZE_MODE_RESIZEABLE_VIA_SDK_VERSION since we didn't have that differentiation
+ // before version 1 and the system didn't resize home activities before then.
+ if (taskType == 1 /* old home type */ && resizeMode == RESIZE_MODE_RESIZEABLE) {
+ resizeMode = RESIZE_MODE_RESIZEABLE_VIA_SDK_VERSION;
+ }
+ } else {
+ // This activity has previously marked itself explicitly as both resizeable and
+ // supporting picture-in-picture. Since there is no longer a requirement for
+ // picture-in-picture activities to be resizeable, we can mark this simply as
+ // resizeable and supporting picture-in-picture separately.
+ if (resizeMode == RESIZE_MODE_RESIZEABLE_AND_PIPABLE_DEPRECATED) {
+ resizeMode = RESIZE_MODE_RESIZEABLE;
+ supportsPictureInPicture = true;
+ }
+ }
+
+ final TaskRecord task = create(stackSupervisor.mService,
+ taskId, intent, affinityIntent,
+ affinity, rootAffinity, realActivity, origActivity, rootHasReset,
+ autoRemoveRecents, askedCompatMode, userId, effectiveUid, lastDescription,
+ activities, lastTimeOnTop, neverRelinquishIdentity, taskDescription,
+ taskAffiliation, prevTaskId, nextTaskId, taskAffiliationColor, callingUid,
+ callingPackage, resizeMode, supportsPictureInPicture, realActivitySuspended,
+ userSetupComplete, minWidth, minHeight);
+ task.mLastNonFullscreenBounds = lastNonFullscreenBounds;
+ task.setBounds(lastNonFullscreenBounds);
+
+ for (int activityNdx = activities.size() - 1; activityNdx >=0; --activityNdx) {
+ activities.get(activityNdx).setTask(task);
+ }
+
+ if (DEBUG_RECENTS) Slog.d(TAG_RECENTS, "Restored task=" + task);
+ return task;
+ }
+
+ void handleUnknownTag(String name, XmlPullParser in)
+ throws IOException, XmlPullParserException {
+ Slog.e(TAG, "restoreTask: Unexpected name=" + name);
+ XmlUtils.skipCurrentTag(in);
+ }
+ }
+}
diff --git a/services/core/java/com/android/server/wm/UnsupportedCompileSdkDialog.java b/services/core/java/com/android/server/wm/UnsupportedCompileSdkDialog.java
new file mode 100644
index 0000000..6a878b9
--- /dev/null
+++ b/services/core/java/com/android/server/wm/UnsupportedCompileSdkDialog.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.server.wm;
+
+import android.app.AlertDialog;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageItemInfo;
+import android.content.pm.PackageManager;
+import android.view.Window;
+import android.view.WindowManager;
+import android.widget.CheckBox;
+
+import com.android.internal.R;
+import com.android.server.utils.AppInstallerUtil;
+
+public class UnsupportedCompileSdkDialog {
+ private final AlertDialog mDialog;
+ private final String mPackageName;
+
+ public UnsupportedCompileSdkDialog(final AppWarnings manager, Context context,
+ ApplicationInfo appInfo) {
+ mPackageName = appInfo.packageName;
+
+ final PackageManager pm = context.getPackageManager();
+ final CharSequence label = appInfo.loadSafeLabel(pm,
+ PackageItemInfo.DEFAULT_MAX_LABEL_SIZE_PX,
+ PackageItemInfo.SAFE_LABEL_FLAG_FIRST_LINE
+ | PackageItemInfo.SAFE_LABEL_FLAG_TRIM);
+ final CharSequence message = context.getString(R.string.unsupported_compile_sdk_message,
+ label);
+
+ final AlertDialog.Builder builder = new AlertDialog.Builder(context)
+ .setPositiveButton(R.string.ok, null)
+ .setMessage(message)
+ .setView(R.layout.unsupported_compile_sdk_dialog_content);
+
+ // If we might be able to update the app, show a button.
+ final Intent installerIntent = AppInstallerUtil.createIntent(context, appInfo.packageName);
+ if (installerIntent != null) {
+ builder.setNeutralButton(R.string.unsupported_compile_sdk_check_update,
+ (dialog, which) -> context.startActivity(installerIntent));
+ }
+
+ // Ensure the content view is prepared.
+ mDialog = builder.create();
+ mDialog.create();
+
+ final Window window = mDialog.getWindow();
+ window.setType(WindowManager.LayoutParams.TYPE_PHONE);
+
+ // DO NOT MODIFY. Used by CTS to verify the dialog is displayed.
+ window.getAttributes().setTitle("UnsupportedCompileSdkDialog");
+
+ final CheckBox alwaysShow = mDialog.findViewById(R.id.ask_checkbox);
+ alwaysShow.setChecked(true);
+ alwaysShow.setOnCheckedChangeListener((buttonView, isChecked) -> manager.setPackageFlag(
+ mPackageName, AppWarnings.FLAG_HIDE_COMPILE_SDK, !isChecked));
+ }
+
+ public String getPackageName() {
+ return mPackageName;
+ }
+
+ public void show() {
+ mDialog.show();
+ }
+
+ public void dismiss() {
+ mDialog.dismiss();
+ }
+}
diff --git a/services/core/java/com/android/server/wm/UnsupportedDisplaySizeDialog.java b/services/core/java/com/android/server/wm/UnsupportedDisplaySizeDialog.java
new file mode 100644
index 0000000..4a800c4
--- /dev/null
+++ b/services/core/java/com/android/server/wm/UnsupportedDisplaySizeDialog.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.server.wm;
+
+import com.android.internal.R;
+
+import android.app.AlertDialog;
+import android.content.Context;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageItemInfo;
+import android.content.pm.PackageManager;
+import android.view.Window;
+import android.view.WindowManager;
+import android.widget.CheckBox;
+
+public class UnsupportedDisplaySizeDialog {
+ private final AlertDialog mDialog;
+ private final String mPackageName;
+
+ public UnsupportedDisplaySizeDialog(final AppWarnings manager, Context context,
+ ApplicationInfo appInfo) {
+ mPackageName = appInfo.packageName;
+
+ final PackageManager pm = context.getPackageManager();
+ final CharSequence label = appInfo.loadSafeLabel(pm,
+ PackageItemInfo.DEFAULT_MAX_LABEL_SIZE_PX,
+ PackageItemInfo.SAFE_LABEL_FLAG_FIRST_LINE
+ | PackageItemInfo.SAFE_LABEL_FLAG_TRIM);
+ final CharSequence message = context.getString(
+ R.string.unsupported_display_size_message, label);
+
+ mDialog = new AlertDialog.Builder(context)
+ .setPositiveButton(R.string.ok, null)
+ .setMessage(message)
+ .setView(R.layout.unsupported_display_size_dialog_content)
+ .create();
+
+ // Ensure the content view is prepared.
+ mDialog.create();
+
+ final Window window = mDialog.getWindow();
+ window.setType(WindowManager.LayoutParams.TYPE_PHONE);
+
+ // DO NOT MODIFY. Used by CTS to verify the dialog is displayed.
+ window.getAttributes().setTitle("UnsupportedDisplaySizeDialog");
+
+ final CheckBox alwaysShow = mDialog.findViewById(R.id.ask_checkbox);
+ alwaysShow.setChecked(true);
+ alwaysShow.setOnCheckedChangeListener((buttonView, isChecked) -> manager.setPackageFlag(
+ mPackageName, AppWarnings.FLAG_HIDE_DISPLAY_SIZE, !isChecked));
+ }
+
+ public String getPackageName() {
+ return mPackageName;
+ }
+
+ public void show() {
+ mDialog.show();
+ }
+
+ public void dismiss() {
+ mDialog.dismiss();
+ }
+}
diff --git a/services/core/java/com/android/server/wm/VrController.java b/services/core/java/com/android/server/wm/VrController.java
new file mode 100644
index 0000000..abe40a7
--- /dev/null
+++ b/services/core/java/com/android/server/wm/VrController.java
@@ -0,0 +1,451 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.server.wm;
+
+import android.content.ComponentName;
+import android.os.Process;
+import android.service.vr.IPersistentVrStateCallbacks;
+import android.util.Slog;
+import android.util.proto.ProtoOutputStream;
+import android.util.proto.ProtoUtils;
+
+import com.android.server.LocalServices;
+import com.android.server.am.ActivityManagerService;
+import com.android.server.am.ProcessList;
+import com.android.server.am.VrControllerProto;
+import com.android.server.vr.VrManagerInternal;
+
+/**
+ * Helper class for {@link ActivityManagerService} responsible for VrMode-related ActivityManager
+ * functionality.
+ *
+ * <p>Specifically, this class is responsible for:
+ * <ul>
+ * <li>Adjusting the scheduling of VR render threads while in VR mode.
+ * <li>Handling ActivityManager calls to set a VR or a 'persistent' VR thread.
+ * <li>Tracking the state of ActivityManagerService's view of VR-related behavior flags.
+ * </ul>
+ *
+ * <p>This is NOT the class that manages the system VR mode lifecycle. The class responsible for
+ * handling everything related to VR mode state changes (e.g. the lifecycles of the associated
+ * VrListenerService, VrStateCallbacks, VR HAL etc.) is VrManagerService.
+ *
+ * <p>This class is exclusively for use by ActivityManagerService. Do not add callbacks or other
+ * functionality to this for things that belong in VrManagerService.
+ */
+final class VrController {
+ private static final String TAG = "VrController";
+
+ // VR state flags.
+ private static final int FLAG_NON_VR_MODE = 0;
+ private static final int FLAG_VR_MODE = 1;
+ private static final int FLAG_PERSISTENT_VR_MODE = 2;
+
+ // Keep the enum lists in sync
+ private static int[] ORIG_ENUMS = new int[] {
+ FLAG_NON_VR_MODE,
+ FLAG_VR_MODE,
+ FLAG_PERSISTENT_VR_MODE,
+ };
+ private static int[] PROTO_ENUMS = new int[] {
+ VrControllerProto.FLAG_NON_VR_MODE,
+ VrControllerProto.FLAG_VR_MODE,
+ VrControllerProto.FLAG_PERSISTENT_VR_MODE,
+ };
+
+ // Invariants maintained for mVrState
+ //
+ // Always true:
+ // - Only a single VR-related thread will have elevated scheduling priorities at a time
+ // across all threads in all processes (and for all possible running modes).
+ //
+ // Always true while FLAG_PERSISTENT_VR_MODE is set:
+ // - An application has set a flag to run in persistent VR mode the next time VR mode is
+ // entered. The device may or may not be in VR mode.
+ // - mVrState will contain FLAG_PERSISTENT_VR_MODE
+ // - An application may set a persistent VR thread that gains elevated scheduling
+ // priorities via a call to setPersistentVrThread.
+ // - Calls to set a regular (non-persistent) VR thread via setVrThread will fail, and
+ // thread that had previously elevated its scheduling priority in this way is returned
+ // to its normal scheduling priority.
+ //
+ // Always true while FLAG_VR_MODE is set:
+ // - The current top application is running in VR mode.
+ // - mVrState will contain FLAG_VR_MODE
+ //
+ // While FLAG_VR_MODE is set without FLAG_PERSISTENT_VR_MODE:
+ // - The current top application may set one of its threads to run at an elevated
+ // scheduling priority via a call to setVrThread.
+ //
+ // While FLAG_VR_MODE is set with FLAG_PERSISTENT_VR_MODE:
+ // - The current top application may NOT set one of its threads to run at an elevated
+ // scheduling priority via a call to setVrThread (instead, the persistent VR thread will
+ // be kept if an application has set one).
+ //
+ // While mVrState == FLAG_NON_VR_MODE:
+ // - Calls to setVrThread will fail.
+ // - Calls to setPersistentVrThread will fail.
+ // - No threads will have elevated scheduling priority for VR.
+ //
+ private int mVrState = FLAG_NON_VR_MODE;
+
+ // The single VR render thread on the device that is given elevated scheduling priority.
+ private int mVrRenderThreadTid = 0;
+
+ private final Object mGlobalAmLock;
+
+ private final IPersistentVrStateCallbacks mPersistentVrModeListener =
+ new IPersistentVrStateCallbacks.Stub() {
+ @Override
+ public void onPersistentVrStateChanged(boolean enabled) {
+ synchronized(mGlobalAmLock) {
+ // Note: This is the only place where mVrState should have its
+ // FLAG_PERSISTENT_VR_MODE setting changed.
+ if (enabled) {
+ setVrRenderThreadLocked(0, ProcessList.SCHED_GROUP_TOP_APP, true);
+ mVrState |= FLAG_PERSISTENT_VR_MODE;
+ } else {
+ setPersistentVrRenderThreadLocked(0, true);
+ mVrState &= ~FLAG_PERSISTENT_VR_MODE;
+ }
+ }
+ }
+ };
+
+ /**
+ * Create new VrController instance.
+ *
+ * @param globalAmLock the global ActivityManagerService lock.
+ */
+ public VrController(final Object globalAmLock) {
+ mGlobalAmLock = globalAmLock;
+ }
+
+ /**
+ * Called when ActivityManagerService receives its systemReady call during boot.
+ */
+ public void onSystemReady() {
+ VrManagerInternal vrManagerInternal = LocalServices.getService(VrManagerInternal.class);
+ if (vrManagerInternal != null) {
+ vrManagerInternal.addPersistentVrModeStateListener(mPersistentVrModeListener);
+ }
+ }
+
+ /**
+ * Called when ActivityManagerService's TOP_APP process has changed.
+ *
+ * <p>Note: This must be called with the global ActivityManagerService lock held.
+ *
+ * @param proc is the WindowProcessController of the process that entered or left the TOP_APP
+ * scheduling group.
+ */
+ public void onTopProcChangedLocked(WindowProcessController proc) {
+ final int curSchedGroup = proc.getCurrentSchedulingGroup();
+ if (curSchedGroup == ProcessList.SCHED_GROUP_TOP_APP) {
+ setVrRenderThreadLocked(proc.mVrThreadTid, curSchedGroup, true);
+ } else {
+ if (proc.mVrThreadTid == mVrRenderThreadTid) {
+ clearVrRenderThreadLocked(true);
+ }
+ }
+ }
+
+ /**
+ * Called when ActivityManagerService is switching VR mode for the TOP_APP process.
+ *
+ * @param record the ActivityRecord of the activity changing the system VR mode.
+ * @return {@code true} if the VR state changed.
+ */
+ public boolean onVrModeChanged(ActivityRecord record) {
+ // This message means that the top focused activity enabled VR mode (or an activity
+ // that previously set this has become focused).
+ VrManagerInternal vrService = LocalServices.getService(VrManagerInternal.class);
+ if (vrService == null) {
+ // VR mode isn't supported on this device.
+ return false;
+ }
+ boolean vrMode;
+ ComponentName requestedPackage;
+ ComponentName callingPackage;
+ int userId;
+ int processId = -1;
+ boolean changed = false;
+ synchronized (mGlobalAmLock) {
+ vrMode = record.requestedVrComponent != null;
+ requestedPackage = record.requestedVrComponent;
+ userId = record.userId;
+ callingPackage = record.info.getComponentName();
+
+ // Tell the VrController that a VR mode change is requested.
+ changed = changeVrModeLocked(vrMode, record.app);
+
+ if (record.app != null) {
+ processId = record.app.getPid();
+ }
+ }
+
+ // Tell VrManager that a VR mode changed is requested, VrManager will handle
+ // notifying all non-AM dependencies if needed.
+ vrService.setVrMode(vrMode, requestedPackage, userId, processId, callingPackage);
+ return changed;
+ }
+
+ /**
+ * Called to set an application's VR thread.
+ *
+ * <p>This will fail if the system is not in VR mode, the system has the persistent VR flag set,
+ * or the scheduling group of the thread is not for the current top app. If this succeeds, any
+ * previous VR thread will be returned to a normal sheduling priority; if this fails, the
+ * scheduling for the previous thread will be unaffected.
+ *
+ * <p>Note: This must be called with the global ActivityManagerService lock and the
+ * mPidsSelfLocked object locks held.
+ *
+ * @param tid the tid of the thread to set, or 0 to unset the current thread.
+ * @param pid the pid of the process owning the thread to set.
+ * @param proc the WindowProcessController of the process owning the thread to set.
+ */
+ public void setVrThreadLocked(int tid, int pid, WindowProcessController proc) {
+ if (hasPersistentVrFlagSet()) {
+ Slog.w(TAG, "VR thread cannot be set in persistent VR mode!");
+ return;
+ }
+ if (proc == null) {
+ Slog.w(TAG, "Persistent VR thread not set, calling process doesn't exist!");
+ return;
+ }
+ if (tid != 0) {
+ enforceThreadInProcess(tid, pid);
+ }
+ if (!inVrMode()) {
+ Slog.w(TAG, "VR thread cannot be set when not in VR mode!");
+ } else {
+ setVrRenderThreadLocked(tid, proc.getCurrentSchedulingGroup(), false);
+ }
+ proc.mVrThreadTid = (tid > 0) ? tid : 0;
+ }
+
+ /**
+ * Called to set an application's persistent VR thread.
+ *
+ * <p>This will fail if the system does not have the persistent VR flag set. If this succeeds,
+ * any previous VR thread will be returned to a normal sheduling priority; if this fails,
+ * the scheduling for the previous thread will be unaffected.
+ *
+ * <p>Note: This must be called with the global ActivityManagerService lock and the
+ * mPidsSelfLocked object locks held.
+ *
+ * @param tid the tid of the thread to set, or 0 to unset the current thread.
+ * @param pid the pid of the process owning the thread to set.
+ * @param proc the process owning the thread to set.
+ */
+ public void setPersistentVrThreadLocked(int tid, int pid, WindowProcessController proc) {
+ if (!hasPersistentVrFlagSet()) {
+ Slog.w(TAG, "Persistent VR thread may only be set in persistent VR mode!");
+ return;
+ }
+ if (proc == null) {
+ Slog.w(TAG, "Persistent VR thread not set, calling process doesn't exist!");
+ return;
+ }
+ if (tid != 0) {
+ enforceThreadInProcess(tid, pid);
+ }
+ setPersistentVrRenderThreadLocked(tid, false);
+ }
+
+ /**
+ * Return {@code true} when UI features incompatible with VR mode should be disabled.
+ *
+ * <p>Note: This must be called with the global ActivityManagerService lock held.
+ */
+ public boolean shouldDisableNonVrUiLocked() {
+ return mVrState != FLAG_NON_VR_MODE;
+ }
+
+ /**
+ * Called when to update this VrController instance's state when the system VR mode is being
+ * changed.
+ *
+ * <p>Note: This must be called with the global ActivityManagerService lock held.
+ *
+ * @param vrMode {@code true} if the system VR mode is being enabled.
+ * @param proc the WindowProcessController of the process enabling the system VR mode.
+ *
+ * @return {@code true} if our state changed.
+ */
+ private boolean changeVrModeLocked(boolean vrMode, WindowProcessController proc) {
+ final int oldVrState = mVrState;
+
+ // This is the only place where mVrState should have its FLAG_VR_MODE setting
+ // changed.
+ if (vrMode) {
+ mVrState |= FLAG_VR_MODE;
+ } else {
+ mVrState &= ~FLAG_VR_MODE;
+ }
+
+ boolean changed = (oldVrState != mVrState);
+
+ if (changed) {
+ if (proc != null) {
+ if (proc.mVrThreadTid > 0) {
+ setVrRenderThreadLocked(
+ proc.mVrThreadTid, proc.getCurrentSchedulingGroup(), false);
+ }
+ } else {
+ clearVrRenderThreadLocked(false);
+ }
+ }
+ return changed;
+ }
+
+ /**
+ * Set the given thread as the new VR thread, and give it special scheduling priority.
+ *
+ * <p>If the current thread is this thread, do nothing. If the current thread is different from
+ * the given thread, the current thread will be returned to a normal scheduling priority.
+ *
+ * @param newTid the tid of the thread to set, or 0 to unset the current thread.
+ * @param suppressLogs {@code true} if any error logging should be disabled.
+ *
+ * @return the tid of the thread configured to run at the scheduling priority for VR
+ * mode after this call completes (this may be the previous thread).
+ */
+ private int updateVrRenderThreadLocked(int newTid, boolean suppressLogs) {
+ if (mVrRenderThreadTid == newTid) {
+ return mVrRenderThreadTid;
+ }
+
+ if (mVrRenderThreadTid > 0) {
+ ActivityManagerService.scheduleAsRegularPriority(mVrRenderThreadTid, suppressLogs);
+ mVrRenderThreadTid = 0;
+ }
+
+ if (newTid > 0) {
+ mVrRenderThreadTid = newTid;
+ ActivityManagerService.scheduleAsFifoPriority(mVrRenderThreadTid, suppressLogs);
+ }
+ return mVrRenderThreadTid;
+ }
+
+ /**
+ * Set special scheduling for the given application persistent VR thread, if allowed.
+ *
+ * <p>This will fail if the system does not have the persistent VR flag set. If this succeeds,
+ * any previous VR thread will be returned to a normal sheduling priority; if this fails,
+ * the scheduling for the previous thread will be unaffected.
+ *
+ * @param newTid the tid of the thread to set, or 0 to unset the current thread.
+ * @param suppressLogs {@code true} if any error logging should be disabled.
+ *
+ * @return the tid of the thread configured to run at the scheduling priority for VR
+ * mode after this call completes (this may be the previous thread).
+ */
+ private int setPersistentVrRenderThreadLocked(int newTid, boolean suppressLogs) {
+ if (!hasPersistentVrFlagSet()) {
+ if (!suppressLogs) {
+ Slog.w(TAG, "Failed to set persistent VR thread, "
+ + "system not in persistent VR mode.");
+ }
+ return mVrRenderThreadTid;
+ }
+ return updateVrRenderThreadLocked(newTid, suppressLogs);
+ }
+
+ /**
+ * Set special scheduling for the given application VR thread, if allowed.
+ *
+ * <p>This will fail if the system is not in VR mode, the system has the persistent VR flag set,
+ * or the scheduling group of the thread is not for the current top app. If this succeeds, any
+ * previous VR thread will be returned to a normal sheduling priority; if this fails, the
+ * scheduling for the previous thread will be unaffected.
+ *
+ * @param newTid the tid of the thread to set, or 0 to unset the current thread.
+ * @param schedGroup the current scheduling group of the thread to set.
+ * @param suppressLogs {@code true} if any error logging should be disabled.
+ *
+ * @return the tid of the thread configured to run at the scheduling priority for VR
+ * mode after this call completes (this may be the previous thread).
+ */
+ private int setVrRenderThreadLocked(int newTid, int schedGroup, boolean suppressLogs) {
+ boolean inVr = inVrMode();
+ boolean inPersistentVr = hasPersistentVrFlagSet();
+ if (!inVr || inPersistentVr || schedGroup != ProcessList.SCHED_GROUP_TOP_APP) {
+ if (!suppressLogs) {
+ String reason = "caller is not the current top application.";
+ if (!inVr) {
+ reason = "system not in VR mode.";
+ } else if (inPersistentVr) {
+ reason = "system in persistent VR mode.";
+ }
+ Slog.w(TAG, "Failed to set VR thread, " + reason);
+ }
+ return mVrRenderThreadTid;
+ }
+ return updateVrRenderThreadLocked(newTid, suppressLogs);
+ }
+
+ /**
+ * Unset any special scheduling used for the current VR render thread, and return it to normal
+ * scheduling priority.
+ *
+ * @param suppressLogs {@code true} if any error logging should be disabled.
+ */
+ private void clearVrRenderThreadLocked(boolean suppressLogs) {
+ updateVrRenderThreadLocked(0, suppressLogs);
+ }
+
+ /**
+ * Check that the given tid is running in the process for the given pid, and throw an exception
+ * if not.
+ */
+ private void enforceThreadInProcess(int tid, int pid) {
+ if (!Process.isThreadInProcess(pid, tid)) {
+ throw new IllegalArgumentException("VR thread does not belong to process");
+ }
+ }
+
+ /**
+ * True when the system is in VR mode.
+ */
+ private boolean inVrMode() {
+ return (mVrState & FLAG_VR_MODE) != 0;
+ }
+
+ /**
+ * True when the persistent VR mode flag has been set.
+ *
+ * Note: Currently this does not necessarily mean that the system is in VR mode.
+ */
+ private boolean hasPersistentVrFlagSet() {
+ return (mVrState & FLAG_PERSISTENT_VR_MODE) != 0;
+ }
+
+ @Override
+ public String toString() {
+ return String.format("[VrState=0x%x,VrRenderThreadTid=%d]", mVrState, mVrRenderThreadTid);
+ }
+
+ void writeToProto(ProtoOutputStream proto, long fieldId) {
+ final long token = proto.start(fieldId);
+ ProtoUtils.writeBitWiseFlagsToProtoEnum(proto, VrControllerProto.VR_MODE,
+ mVrState, ORIG_ENUMS, PROTO_ENUMS);
+ proto.write(VrControllerProto.RENDER_THREAD_ID, mVrRenderThreadTid);
+ proto.end(token);
+ }
+}
diff --git a/services/core/java/com/android/server/wm/WindowProcessController.java b/services/core/java/com/android/server/wm/WindowProcessController.java
new file mode 100644
index 0000000..bb17254
--- /dev/null
+++ b/services/core/java/com/android/server/wm/WindowProcessController.java
@@ -0,0 +1,902 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.server.wm;
+
+import static android.app.ActivityManager.PROCESS_STATE_NONEXISTENT;
+import static android.view.Display.INVALID_DISPLAY;
+
+import static com.android.server.am.ActivityManagerService.MY_PID;
+import static com.android.server.wm.ActivityStack.ActivityState.DESTROYED;
+import static com.android.server.wm.ActivityStack.ActivityState.DESTROYING;
+import static com.android.server.wm.ActivityStack.ActivityState.PAUSED;
+import static com.android.server.wm.ActivityStack.ActivityState.PAUSING;
+import static com.android.server.wm.ActivityStack.ActivityState.RESUMED;
+import static com.android.server.wm.ActivityStack.ActivityState.STOPPING;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_CONFIGURATION;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.DEBUG_RELEASE;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_CONFIGURATION;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.POSTFIX_RELEASE;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_ATM;
+import static com.android.server.wm.ActivityTaskManagerDebugConfig.TAG_WITH_CLASS_NAME;
+import static com.android.server.wm.ActivityTaskManagerService
+ .INSTRUMENTATION_KEY_DISPATCHING_TIMEOUT_MS;
+import static com.android.server.wm.ActivityTaskManagerService.KEY_DISPATCHING_TIMEOUT_MS;
+import static com.android.server.wm.ActivityTaskManagerService.RELAUNCH_REASON_NONE;
+
+import android.app.Activity;
+import android.app.ActivityThread;
+import android.app.IApplicationThread;
+import android.app.ProfilerInfo;
+import android.app.servertransaction.ConfigurationChangeItem;
+import android.content.Intent;
+import android.content.pm.ApplicationInfo;
+import android.content.res.Configuration;
+import android.os.Message;
+import android.os.RemoteException;
+import android.util.ArraySet;
+import android.util.Log;
+import android.util.Slog;
+import android.util.proto.ProtoOutputStream;
+
+import com.android.internal.app.HeavyWeightSwitcherActivity;
+import com.android.internal.util.function.pooled.PooledLambda;
+import com.android.server.Watchdog;
+
+import java.io.PrintWriter;
+import java.util.ArrayList;
+
+/**
+ * The Activity Manager (AM) package manages the lifecycle of processes in the system through
+ * ProcessRecord. However, it is important for the Window Manager (WM) package to be aware
+ * of the processes and their state since it affects how WM manages windows and activities. This
+ * class that allows the ProcessRecord object in the AM package to communicate important
+ * changes to its state to the WM package in a structured way. WM package also uses
+ * {@link WindowProcessListener} to request changes to the process state on the AM side.
+ * Note that public calls into this class are assumed to be originating from outside the
+ * window manager so the window manager lock is held and appropriate permissions are checked before
+ * calls are allowed to proceed.
+ */
+public class WindowProcessController extends ConfigurationContainer<ConfigurationContainer>
+ implements ConfigurationContainerListener {
+ private static final String TAG = TAG_WITH_CLASS_NAME ? "WindowProcessController" : TAG_ATM;
+ private static final String TAG_RELEASE = TAG + POSTFIX_RELEASE;
+ private static final String TAG_CONFIGURATION = TAG + POSTFIX_CONFIGURATION;
+
+ // all about the first app in the process
+ final ApplicationInfo mInfo;
+ final String mName;
+ final int mUid;
+ // The process of this application; 0 if none
+ private volatile int mPid;
+ // user of process.
+ final int mUserId;
+ // The owner of this window process controller object. Mainly for identification when we
+ // communicate back to the activity manager side.
+ public final Object mOwner;
+ // List of packages running in the process
+ final ArraySet<String> mPkgList = new ArraySet<>();
+ private final WindowProcessListener mListener;
+ private final ActivityTaskManagerService mAtm;
+ // The actual proc... may be null only if 'persistent' is true (in which case we are in the
+ // process of launching the app)
+ private volatile IApplicationThread mThread;
+ // Currently desired scheduling class
+ private volatile int mCurSchedGroup;
+ // Currently computed process state
+ private volatile int mCurProcState = PROCESS_STATE_NONEXISTENT;
+ // Last reported process state;
+ private volatile int mRepProcState = PROCESS_STATE_NONEXISTENT;
+ // are we in the process of crashing?
+ private volatile boolean mCrashing;
+ // does the app have a not responding dialog?
+ private volatile boolean mNotResponding;
+ // always keep this application running?
+ private volatile boolean mPersistent;
+ // The ABI this process was launched with
+ private volatile String mRequiredAbi;
+ // Running any services that are foreground?
+ private volatile boolean mHasForegroundServices;
+ // Running any activities that are foreground?
+ private volatile boolean mHasForegroundActivities;
+ // Are there any client services with activities?
+ private volatile boolean mHasClientActivities;
+ // Is this process currently showing a non-activity UI that the user is interacting with?
+ // E.g. The status bar when it is expanded, but not when it is minimized. When true the process
+ // will be set to use the ProcessList#SCHED_GROUP_TOP_APP scheduling group to boost performance.
+ private volatile boolean mHasTopUi;
+ // Is the process currently showing a non-activity UI that overlays on-top of activity UIs on
+ // screen. E.g. display a window of type
+ // android.view.WindowManager.LayoutParams#TYPE_APPLICATION_OVERLAY When true the process will
+ // oom adj score will be set to ProcessList#PERCEPTIBLE_APP_ADJ at minimum to reduce the chance
+ // of the process getting killed.
+ private volatile boolean mHasOverlayUi;
+ // Want to clean up resources from showing UI?
+ private volatile boolean mPendingUiClean;
+ // The time we sent the last interaction event
+ private volatile long mInteractionEventTime;
+ // When we became foreground for interaction purposes
+ private volatile long mFgInteractionTime;
+ // When (uptime) the process last became unimportant
+ private volatile long mWhenUnimportant;
+ // was app launched for debugging?
+ private volatile boolean mDebugging;
+ // Active instrumentation running in process?
+ private volatile boolean mInstrumenting;
+ // This process it perceptible by the user.
+ private volatile boolean mPerceptible;
+ // Set to true when process was launched with a wrapper attached
+ private volatile boolean mUsingWrapper;
+
+ // Thread currently set for VR scheduling
+ int mVrThreadTid;
+
+ // all activities running in the process
+ private final ArrayList<ActivityRecord> mActivities = new ArrayList<>();
+ // any tasks this process had run root activities in
+ private final ArrayList<TaskRecord> mRecentTasks = new ArrayList<>();
+
+ // Last configuration that was reported to the process.
+ private final Configuration mLastReportedConfiguration;
+ // Registered display id as a listener to override config change
+ private int mDisplayId;
+
+ public WindowProcessController(ActivityTaskManagerService atm, ApplicationInfo info,
+ String name, int uid, int userId, Object owner, WindowProcessListener listener) {
+ mInfo = info;
+ mName = name;
+ mUid = uid;
+ mUserId = userId;
+ mOwner = owner;
+ mListener = listener;
+ mAtm = atm;
+ mLastReportedConfiguration = new Configuration();
+ mDisplayId = INVALID_DISPLAY;
+ if (atm != null) {
+ onConfigurationChanged(atm.getGlobalConfiguration());
+ }
+ }
+
+ public void setPid(int pid) {
+ mPid = pid;
+ }
+
+ public int getPid() {
+ return mPid;
+ }
+
+ public void setThread(IApplicationThread thread) {
+ mThread = thread;
+ }
+
+ IApplicationThread getThread() {
+ return mThread;
+ }
+
+ boolean hasThread() {
+ return mThread != null;
+ }
+
+ public void setCurrentSchedulingGroup(int curSchedGroup) {
+ mCurSchedGroup = curSchedGroup;
+ }
+
+ int getCurrentSchedulingGroup() {
+ return mCurSchedGroup;
+ }
+
+ public void setCurrentProcState(int curProcState) {
+ mCurProcState = curProcState;
+ }
+
+ int getCurrentProcState() {
+ return mCurProcState;
+ }
+
+ public void setReportedProcState(int repProcState) {
+ mRepProcState = repProcState;
+ }
+
+ int getReportedProcState() {
+ return mRepProcState;
+ }
+
+ public void setCrashing(boolean crashing) {
+ mCrashing = crashing;
+ }
+
+ boolean isCrashing() {
+ return mCrashing;
+ }
+
+ public void setNotResponding(boolean notResponding) {
+ mNotResponding = notResponding;
+ }
+
+ boolean isNotResponding() {
+ return mNotResponding;
+ }
+
+ public void setPersistent(boolean persistent) {
+ mPersistent = persistent;
+ }
+
+ boolean isPersistent() {
+ return mPersistent;
+ }
+
+ public void setHasForegroundServices(boolean hasForegroundServices) {
+ mHasForegroundServices = hasForegroundServices;
+ }
+
+ boolean hasForegroundServices() {
+ return mHasForegroundServices;
+ }
+
+ public void setHasForegroundActivities(boolean hasForegroundActivities) {
+ mHasForegroundActivities = hasForegroundActivities;
+ }
+
+ boolean hasForegroundActivities() {
+ return mHasForegroundActivities;
+ }
+
+ public void setHasClientActivities(boolean hasClientActivities) {
+ mHasClientActivities = hasClientActivities;
+ }
+
+ boolean hasClientActivities() {
+ return mHasClientActivities;
+ }
+
+ public void setHasTopUi(boolean hasTopUi) {
+ mHasTopUi = hasTopUi;
+ }
+
+ boolean hasTopUi() {
+ return mHasTopUi;
+ }
+
+ public void setHasOverlayUi(boolean hasOverlayUi) {
+ mHasOverlayUi = hasOverlayUi;
+ }
+
+ boolean hasOverlayUi() {
+ return mHasOverlayUi;
+ }
+
+ public void setPendingUiClean(boolean hasPendingUiClean) {
+ mPendingUiClean = hasPendingUiClean;
+ }
+
+ boolean hasPendingUiClean() {
+ return mPendingUiClean;
+ }
+
+ void postPendingUiCleanMsg(boolean pendingUiClean) {
+ if (mListener == null) return;
+ // Posting on handler so WM lock isn't held when we call into AM.
+ final Message m = PooledLambda.obtainMessage(
+ WindowProcessListener::setPendingUiClean, mListener, pendingUiClean);
+ mAtm.mH.sendMessage(m);
+ }
+
+ public void setInteractionEventTime(long interactionEventTime) {
+ mInteractionEventTime = interactionEventTime;
+ }
+
+ long getInteractionEventTime() {
+ return mInteractionEventTime;
+ }
+
+ public void setFgInteractionTime(long fgInteractionTime) {
+ mFgInteractionTime = fgInteractionTime;
+ }
+
+ long getFgInteractionTime() {
+ return mFgInteractionTime;
+ }
+
+ public void setWhenUnimportant(long whenUnimportant) {
+ mWhenUnimportant = whenUnimportant;
+ }
+
+ long getWhenUnimportant() {
+ return mWhenUnimportant;
+ }
+
+ public void setRequiredAbi(String requiredAbi) {
+ mRequiredAbi = requiredAbi;
+ }
+
+ String getRequiredAbi() {
+ return mRequiredAbi;
+ }
+
+ public void setDebugging(boolean debugging) {
+ mDebugging = debugging;
+ }
+
+ boolean isDebugging() {
+ return mDebugging;
+ }
+
+ public void setUsingWrapper(boolean usingWrapper) {
+ mUsingWrapper = usingWrapper;
+ }
+
+ boolean isUsingWrapper() {
+ return mUsingWrapper;
+ }
+
+ public void setInstrumenting(boolean instrumenting) {
+ mInstrumenting = instrumenting;
+ }
+
+ boolean isInstrumenting() {
+ return mInstrumenting;
+ }
+
+ public void setPerceptible(boolean perceptible) {
+ mPerceptible = perceptible;
+ }
+
+ boolean isPerceptible() {
+ return mPerceptible;
+ }
+
+ @Override
+ protected int getChildCount() {
+ return 0;
+ }
+
+ @Override
+ protected ConfigurationContainer getChildAt(int index) {
+ return null;
+ }
+
+ @Override
+ protected ConfigurationContainer getParent() {
+ return null;
+ }
+
+ public void addPackage(String packageName) {
+ synchronized (mAtm.mGlobalLock) {
+ mPkgList.add(packageName);
+ }
+ }
+
+ public void clearPackageList() {
+ synchronized (mAtm.mGlobalLock) {
+ mPkgList.clear();
+ }
+ }
+
+ void addActivityIfNeeded(ActivityRecord r) {
+ if (mActivities.contains(r)) {
+ return;
+ }
+ mActivities.add(r);
+ }
+
+ void removeActivity(ActivityRecord r) {
+ mActivities.remove(r);
+ }
+
+ public void clearActivities() {
+ synchronized (mAtm.mGlobalLock) {
+ mActivities.clear();
+ }
+ }
+
+ public boolean hasActivities() {
+ synchronized (mAtm.mGlobalLock) {
+ return !mActivities.isEmpty();
+ }
+ }
+
+ public boolean hasVisibleActivities() {
+ synchronized (mAtm.mGlobalLock) {
+ for (int i = mActivities.size() - 1; i >= 0; --i) {
+ final ActivityRecord r = mActivities.get(i);
+ if (r.visible) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ public boolean hasActivitiesOrRecentTasks() {
+ synchronized (mAtm.mGlobalLock) {
+ return !mActivities.isEmpty() || !mRecentTasks.isEmpty();
+ }
+ }
+
+ public void stopFreezingActivities() {
+ synchronized (mAtm.mGlobalLock) {
+ int i = mActivities.size();
+ while (i > 0) {
+ i--;
+ mActivities.get(i).stopFreezingScreenLocked(true);
+ }
+ }
+ }
+
+ public void finishActivities() {
+ synchronized (mAtm.mGlobalLock) {
+ ArrayList<ActivityRecord> activities = new ArrayList<>(mActivities);
+ for (int i = 0; i < activities.size(); i++) {
+ final ActivityRecord r = activities.get(i);
+ if (!r.finishing && r.isInStackLocked()) {
+ r.getStack().finishActivityLocked(r, Activity.RESULT_CANCELED,
+ null, "finish-heavy", true);
+ }
+ }
+ }
+ }
+
+ public boolean isInterestingToUser() {
+ synchronized (mAtm.mGlobalLock) {
+ final int size = mActivities.size();
+ for (int i = 0; i < size; i++) {
+ ActivityRecord r = mActivities.get(i);
+ if (r.isInterestingToUserLocked()) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ public boolean hasRunningActivity(String packageName) {
+ synchronized (mAtm.mGlobalLock) {
+ for (int i = mActivities.size() - 1; i >= 0; --i) {
+ final ActivityRecord r = mActivities.get(i);
+ if (packageName.equals(r.packageName)) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ public void clearPackagePreferredForHomeActivities() {
+ synchronized (mAtm.mGlobalLock) {
+ for (int i = mActivities.size() - 1; i >= 0; --i) {
+ final ActivityRecord r = mActivities.get(i);
+ if (r.isActivityTypeHome()) {
+ Log.i(TAG, "Clearing package preferred activities from " + r.packageName);
+ try {
+ ActivityThread.getPackageManager()
+ .clearPackagePreferredActivities(r.packageName);
+ } catch (RemoteException c) {
+ // pm is in same process, this will never happen.
+ }
+ }
+ }
+ }
+ }
+
+ boolean hasStartedActivity(ActivityRecord launchedActivity) {
+ for (int i = mActivities.size() - 1; i >= 0; i--) {
+ final ActivityRecord activity = mActivities.get(i);
+ if (launchedActivity == activity) {
+ continue;
+ }
+ if (!activity.stopped) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+
+ public void updateIntentForHeavyWeightActivity(Intent intent) {
+ synchronized (mAtm.mGlobalLock) {
+ if (mActivities.isEmpty()) {
+ return;
+ }
+ ActivityRecord hist = mActivities.get(0);
+ intent.putExtra(HeavyWeightSwitcherActivity.KEY_CUR_APP, hist.packageName);
+ intent.putExtra(HeavyWeightSwitcherActivity.KEY_CUR_TASK, hist.getTask().taskId);
+ }
+ }
+
+ boolean shouldKillProcessForRemovedTask(TaskRecord tr) {
+ for (int k = 0; k < mActivities.size(); k++) {
+ final ActivityRecord activity = mActivities.get(k);
+ if (!activity.stopped) {
+ // Don't kill process(es) that has an activity not stopped.
+ return false;
+ }
+ final TaskRecord otherTask = activity.getTask();
+ if (tr.taskId != otherTask.taskId && otherTask.inRecents) {
+ // Don't kill process(es) that has an activity in a different task that is
+ // also in recents.
+ return false;
+ }
+ }
+ return true;
+ }
+
+ ArraySet<TaskRecord> getReleaseSomeActivitiesTasks() {
+ // Examine all activities currently running in the process.
+ TaskRecord firstTask = null;
+ // Tasks is non-null only if two or more tasks are found.
+ ArraySet<TaskRecord> tasks = null;
+ if (DEBUG_RELEASE) Slog.d(TAG_RELEASE, "Trying to release some activities in " + this);
+ for (int i = 0; i < mActivities.size(); i++) {
+ final ActivityRecord r = mActivities.get(i);
+ // First, if we find an activity that is in the process of being destroyed,
+ // then we just aren't going to do anything for now; we want things to settle
+ // down before we try to prune more activities.
+ if (r.finishing || r.isState(DESTROYING, DESTROYED)) {
+ if (DEBUG_RELEASE) Slog.d(TAG_RELEASE, "Abort release; already destroying: " + r);
+ return null;
+ }
+ // Don't consider any activies that are currently not in a state where they
+ // can be destroyed.
+ if (r.visible || !r.stopped || !r.haveState
+ || r.isState(RESUMED, PAUSING, PAUSED, STOPPING)) {
+ if (DEBUG_RELEASE) Slog.d(TAG_RELEASE, "Not releasing in-use activity: " + r);
+ continue;
+ }
+
+ final TaskRecord task = r.getTask();
+ if (task != null) {
+ if (DEBUG_RELEASE) Slog.d(TAG_RELEASE, "Collecting release task " + task
+ + " from " + r);
+ if (firstTask == null) {
+ firstTask = task;
+ } else if (firstTask != task) {
+ if (tasks == null) {
+ tasks = new ArraySet<>();
+ tasks.add(firstTask);
+ }
+ tasks.add(task);
+ }
+ }
+ }
+
+ return tasks;
+ }
+
+ public interface ComputeOomAdjCallback {
+ void onVisibleActivity();
+ void onPausedActivity();
+ void onStoppingActivity(boolean finishing);
+ void onOtherActivity();
+ }
+
+ public int computeOomAdjFromActivities(int minTaskLayer, ComputeOomAdjCallback callback) {
+ synchronized (mAtm.mGlobalLock) {
+ final int activitiesSize = mActivities.size();
+ for (int j = 0; j < activitiesSize; j++) {
+ final ActivityRecord r = mActivities.get(j);
+ if (r.app != this) {
+ Log.e(TAG, "Found activity " + r + " in proc activity list using " + r.app
+ + " instead of expected " + this);
+ if (r.app == null || (r.app.mUid == mUid)) {
+ // Only fix things up when they look sane
+ r.setProcess(this);
+ } else {
+ continue;
+ }
+ }
+ if (r.visible) {
+ callback.onVisibleActivity();
+ final TaskRecord task = r.getTask();
+ if (task != null && minTaskLayer > 0) {
+ final int layer = task.mLayerRank;
+ if (layer >= 0 && minTaskLayer > layer) {
+ minTaskLayer = layer;
+ }
+ }
+ break;
+ } else if (r.isState(PAUSING, PAUSED)) {
+ callback.onPausedActivity();
+ } else if (r.isState(STOPPING)) {
+ callback.onStoppingActivity(r.finishing);
+ } else {
+ callback.onOtherActivity();
+ }
+ }
+ }
+
+ return minTaskLayer;
+ }
+
+ public int computeRelaunchReason() {
+ synchronized (mAtm.mGlobalLock) {
+ final int activitiesSize = mActivities.size();
+ for (int i = activitiesSize - 1; i >= 0; i--) {
+ final ActivityRecord r = mActivities.get(i);
+ if (r.mRelaunchReason != RELAUNCH_REASON_NONE) {
+ return r.mRelaunchReason;
+ }
+ }
+ }
+ return RELAUNCH_REASON_NONE;
+ }
+
+ public long getInputDispatchingTimeout() {
+ synchronized (mAtm.mGlobalLock) {
+ return isInstrumenting() || isUsingWrapper()
+ ? INSTRUMENTATION_KEY_DISPATCHING_TIMEOUT_MS : KEY_DISPATCHING_TIMEOUT_MS;
+ }
+ }
+
+ void clearProfilerIfNeeded() {
+ if (mListener == null) return;
+ // Posting on handler so WM lock isn't held when we call into AM.
+ mAtm.mH.sendMessage(PooledLambda.obtainMessage(
+ WindowProcessListener::clearProfilerIfNeeded, mListener));
+ }
+
+ void updateProcessInfo(boolean updateServiceConnectionActivities, boolean updateLru,
+ boolean activityChange, boolean updateOomAdj) {
+ if (mListener == null) return;
+ // Posting on handler so WM lock isn't held when we call into AM.
+ final Message m = PooledLambda.obtainMessage(WindowProcessListener::updateProcessInfo,
+ mListener, updateServiceConnectionActivities, updateLru, activityChange,
+ updateOomAdj);
+ mAtm.mH.sendMessage(m);
+ }
+
+ void updateServiceConnectionActivities() {
+ if (mListener == null) return;
+ // Posting on handler so WM lock isn't held when we call into AM.
+ mAtm.mH.sendMessage(PooledLambda.obtainMessage(
+ WindowProcessListener::updateServiceConnectionActivities, mListener));
+ }
+
+ void setPendingUiCleanAndForceProcessStateUpTo(int newState) {
+ if (mListener == null) return;
+ // Posting on handler so WM lock isn't held when we call into AM.
+ final Message m = PooledLambda.obtainMessage(
+ WindowProcessListener::setPendingUiCleanAndForceProcessStateUpTo,
+ mListener, newState);
+ mAtm.mH.sendMessage(m);
+ }
+
+ void setRemoved(boolean removed) {
+ if (mListener == null) return;
+ // Posting on handler so WM lock isn't held when we call into AM.
+ final Message m = PooledLambda.obtainMessage(
+ WindowProcessListener::setRemoved, mListener, removed);
+ mAtm.mH.sendMessage(m);
+ }
+
+ void clearWaitingToKill() {
+ if (mListener == null) return;
+ // Posting on handler so WM lock isn't held when we call into AM.
+ final Message m = PooledLambda.obtainMessage(
+ WindowProcessListener::clearWaitingToKill, mListener);
+ mAtm.mH.sendMessage(m);
+ }
+
+ void addPackage(String pkg, long versionCode) {
+ // TODO(b/80414790): Calling directly into AM for now which can lead to deadlock once we are
+ // using WM lock. Need to figure-out if it is okay to do this asynchronously.
+ if (mListener == null) return;
+ mListener.addPackage(pkg, versionCode);
+ }
+
+ ProfilerInfo onStartActivity(int topProcessState) {
+ // TODO(b/80414790): Calling directly into AM for now which can lead to deadlock once we are
+ // using WM lock. Need to figure-out if it is okay to do this asynchronously.
+ if (mListener == null) return null;
+ return mListener.onStartActivity(topProcessState);
+ }
+
+ public void appDied() {
+ // TODO(b/80414790): Calling directly into AM for now which can lead to deadlock once we are
+ // using WM lock. Need to figure-out if it is okay to do this asynchronously.
+ if (mListener == null) return;
+ mListener.appDied();
+ }
+
+ void registerDisplayConfigurationListenerLocked(ActivityDisplay activityDisplay) {
+ if (activityDisplay == null) {
+ return;
+ }
+ // A process can only register to one display to listener to the override configuration
+ // change. Unregister existing listener if it has one before register the new one.
+ unregisterDisplayConfigurationListenerLocked();
+ mDisplayId = activityDisplay.mDisplayId;
+ activityDisplay.registerConfigurationChangeListener(this);
+ }
+
+ private void unregisterDisplayConfigurationListenerLocked() {
+ if (mDisplayId == INVALID_DISPLAY) {
+ return;
+ }
+ final ActivityDisplay activityDisplay =
+ mAtm.mStackSupervisor.getActivityDisplay(mDisplayId);
+ if (activityDisplay != null) {
+ mAtm.mStackSupervisor.getActivityDisplay(
+ mDisplayId).unregisterConfigurationChangeListener(this);
+ }
+ mDisplayId = INVALID_DISPLAY;
+ }
+
+ @Override
+ public void onConfigurationChanged(Configuration newGlobalConfig) {
+ super.onConfigurationChanged(newGlobalConfig);
+ updateConfiguration();
+ }
+
+ @Override
+ public void onOverrideConfigurationChanged(Configuration newOverrideConfig) {
+ super.onOverrideConfigurationChanged(newOverrideConfig);
+ updateConfiguration();
+ }
+
+ private void updateConfiguration() {
+ final Configuration config = getConfiguration();
+ if (mLastReportedConfiguration.diff(config) == 0) {
+ // Nothing changed.
+ return;
+ }
+
+ try {
+ if (mThread == null) {
+ return;
+ }
+ if (DEBUG_CONFIGURATION) {
+ Slog.v(TAG_CONFIGURATION, "Sending to proc " + mName
+ + " new config " + config);
+ }
+ config.seq = mAtm.increaseConfigurationSeqLocked();
+ mAtm.getLifecycleManager().scheduleTransaction(mThread,
+ ConfigurationChangeItem.obtain(config));
+ setLastReportedConfiguration(config);
+ } catch (Exception e) {
+ Slog.e(TAG_CONFIGURATION, "Failed to schedule configuration change", e);
+ }
+ }
+
+ private void setLastReportedConfiguration(Configuration config) {
+ mLastReportedConfiguration.setTo(config);
+ }
+
+ Configuration getLastReportedConfiguration() {
+ return mLastReportedConfiguration;
+ }
+
+ /** Returns the total time (in milliseconds) spent executing in both user and system code. */
+ public long getCpuTime() {
+ return (mListener != null) ? mListener.getCpuTime() : 0;
+ }
+
+ void addRecentTask(TaskRecord task) {
+ mRecentTasks.add(task);
+ }
+
+ void removeRecentTask(TaskRecord task) {
+ mRecentTasks.remove(task);
+ }
+
+ public boolean hasRecentTasks() {
+ synchronized (mAtm.mGlobalLock) {
+ return !mRecentTasks.isEmpty();
+ }
+ }
+
+ public void clearRecentTasks() {
+ synchronized (mAtm.mGlobalLock) {
+ for (int i = mRecentTasks.size() - 1; i >= 0; i--) {
+ mRecentTasks.get(i).clearRootProcess();
+ }
+ mRecentTasks.clear();
+ }
+ }
+
+ public void appEarlyNotResponding(String annotation, Runnable killAppCallback) {
+ synchronized (mAtm.mGlobalLock) {
+ if (mAtm.mController == null) {
+ return;
+ }
+
+ try {
+ // 0 == continue, -1 = kill process immediately
+ int res = mAtm.mController.appEarlyNotResponding(mName, mPid, annotation);
+ if (res < 0 && mPid != MY_PID) {
+ killAppCallback.run();
+ }
+ } catch (RemoteException e) {
+ mAtm.mController = null;
+ Watchdog.getInstance().setActivityController(null);
+ }
+ }
+ }
+
+ public boolean appNotResponding(String info, Runnable killAppCallback,
+ Runnable serviceTimeoutCallback) {
+ synchronized (mAtm.mGlobalLock) {
+ if (mAtm.mController == null) {
+ return false;
+ }
+
+ try {
+ // 0 == show dialog, 1 = keep waiting, -1 = kill process immediately
+ int res = mAtm.mController.appNotResponding(mName, mPid, info);
+ if (res != 0) {
+ if (res < 0 && mPid != MY_PID) {
+ killAppCallback.run();
+ } else {
+ serviceTimeoutCallback.run();
+ }
+ return true;
+ }
+ } catch (RemoteException e) {
+ mAtm.mController = null;
+ Watchdog.getInstance().setActivityController(null);
+ }
+ return false;
+ }
+ }
+
+ public void onTopProcChanged() {
+ synchronized (mAtm.mGlobalLock) {
+ mAtm.mVrController.onTopProcChangedLocked(this);
+ }
+ }
+
+ public boolean isHomeProcess() {
+ synchronized (mAtm.mGlobalLock) {
+ return this == mAtm.mHomeProcess;
+ }
+ }
+
+ public boolean isPreviousProcess() {
+ synchronized (mAtm.mGlobalLock) {
+ return this == mAtm.mPreviousProcess;
+ }
+ }
+
+ public void dump(PrintWriter pw, String prefix) {
+ synchronized (mAtm.mGlobalLock) {
+ if (mActivities.size() > 0) {
+ pw.print(prefix); pw.println("Activities:");
+ for (int i = 0; i < mActivities.size(); i++) {
+ pw.print(prefix); pw.print(" - "); pw.println(mActivities.get(i));
+ }
+ }
+
+ if (mRecentTasks.size() > 0) {
+ pw.println(prefix + "Recent Tasks:");
+ for (int i = 0; i < mRecentTasks.size(); i++) {
+ pw.println(prefix + " - " + mRecentTasks.get(i));
+ }
+ }
+
+ if (mVrThreadTid != 0) {
+ pw.print(prefix); pw.print("mVrThreadTid="); pw.println(mVrThreadTid);
+ }
+ }
+ pw.println(prefix + " Configuration=" + getConfiguration());
+ pw.println(prefix + " OverrideConfiguration=" + getOverrideConfiguration());
+ pw.println(prefix + " mLastReportedConfiguration=" + mLastReportedConfiguration);
+ }
+
+ void writeToProto(ProtoOutputStream proto, long fieldId) {
+ if (mListener != null) {
+ mListener.writeToProto(proto, fieldId);
+ }
+ }
+}
diff --git a/services/core/java/com/android/server/wm/WindowProcessListener.java b/services/core/java/com/android/server/wm/WindowProcessListener.java
new file mode 100644
index 0000000..7f20f4b
--- /dev/null
+++ b/services/core/java/com/android/server/wm/WindowProcessListener.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.server.wm;
+
+import android.app.ProfilerInfo;
+import android.util.proto.ProtoOutputStream;
+
+/**
+ * Interface used by the owner/creator of a process that owns windows to listen to changes from the
+ * WM side.
+ * @see WindowProcessController
+ */
+public interface WindowProcessListener {
+
+ /** Clear the profiler record if we are currently profiling this process. */
+ void clearProfilerIfNeeded();
+
+ /** Update the service connection for this process based on activities it might have. */
+ void updateServiceConnectionActivities();
+
+ /** Set or clear flag that we would like to clean-up UI resources for this process. */
+ void setPendingUiClean(boolean pendingUiClean);
+
+ /**
+ * Set flag that we would like to clean-up UI resources for this process and force new process
+ * state.
+ */
+ void setPendingUiCleanAndForceProcessStateUpTo(int newState);
+
+ /** Update the process information. */
+ void updateProcessInfo(boolean updateServiceConnectionActivities, boolean updateLru,
+ boolean activityChange, boolean updateOomAdj);
+
+ /** Set process package been removed from device. */
+ void setRemoved(boolean removed);
+
+ /** Returns the total time (in milliseconds) spent executing in both user and system code. */
+ long getCpuTime();
+
+ /** Clears the waiting to kill reason for this process. */
+ void clearWaitingToKill();
+
+ /** Adds the package to the process. */
+ void addPackage(String pkg, long versionCode);
+
+ /** Called when we are in the process on starting an activity. */
+ ProfilerInfo onStartActivity(int topProcessState);
+
+ /** App died :(...oh well */
+ void appDied();
+ void writeToProto(ProtoOutputStream proto, long fieldId);
+}