Move ensure activity visibility processing to helper class (72/n) (076c3b1b) · Commits · e / os / android_frameworks_base

services/core/java/com/android/server/wm/ActivityDisplay.java

+1 −1

Original line number	Diff line number	Diff line
		@@ -1408,7 +1408,7 @@ class ActivityDisplay extends ConfigurationContainer<ActivityStack> {
		boolean preserveWindows, boolean notifyClients) {
		for (int stackNdx = getChildCount() - 1; stackNdx >= 0; --stackNdx) {
		final ActivityStack stack = getChildAt(stackNdx);
		stack.ensureActivitiesVisibleLocked(starting, configChanges, preserveWindows,
		stack.ensureActivitiesVisible(starting, configChanges, preserveWindows,
		notifyClients);
		}
		}

services/core/java/com/android/server/wm/ActivityRecord.java

+1 −1

Original line number	Diff line number	Diff line
		@@ -4569,7 +4569,7 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A
		// If the activity is stopped, stopping, cycle to an active 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 a proper
		// ActivityStack#ensureActivitiesVisible will bring the activity to a proper
		// active state.
		if (!isState(STARTED, RESUMED, PAUSED, STOPPED, STOPPING)
		\|\| getActivityStack().mTranslucentActivityWaiting != null) {

services/core/java/com/android/server/wm/ActivityStack.java

+16 −142

Original line number	Diff line number	Diff line
		@@ -213,7 +213,7 @@ class ActivityStack extends WindowContainer<Task> implements BoundsAnimationTarg
		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;
		static final String TAG_VISIBILITY = TAG + POSTFIX_VISIBILITY;

		// Ticks during which we check progress while waiting for an app to launch.
		private static final int LAUNCH_TICK = 500;
		@@ -515,6 +515,8 @@ class ActivityStack extends WindowContainer<Task> implements BoundsAnimationTarg
		}

		private static final ResetTargetTaskHelper sResetTargetTaskHelper = new ResetTargetTaskHelper();
		private final EnsureActivitiesVisibleHelper mEnsureActivitiesVisibleHelper =
		new EnsureActivitiesVisibleHelper(this);

		int numActivities() {
		int count = 0;
		@@ -1492,8 +1494,7 @@ class ActivityStack extends WindowContainer<Task> implements BoundsAnimationTarg

		void goToSleep() {
		// Ensure visibility without updating configuration, as activities are about to sleep.
		ensureActivitiesVisibleLocked(null /* starting /, 0 / configChanges */,
		!PRESERVE_WINDOWS);
		ensureActivitiesVisible(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.
		@@ -1979,127 +1980,25 @@ class ActivityStack extends WindowContainer<Task> implements BoundsAnimationTarg
		* 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,
		void ensureActivitiesVisible(ActivityRecord starting, int configChanges,
		boolean preserveWindows) {
		ensureActivitiesVisibleLocked(starting, configChanges, preserveWindows,
		true /* notifyClients */);
		ensureActivitiesVisible(starting, configChanges, preserveWindows, true /* notifyClients */);
		}

		/**
		* Ensure visibility with an option to also update the configuration of visible activities.
		* @see #ensureActivitiesVisibleLocked(ActivityRecord, int, boolean)
		* @see #ensureActivitiesVisible(ActivityRecord, int, boolean)
		* @see RootActivityContainer#ensureActivitiesVisible(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,
		void ensureActivitiesVisible(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;
		// We should not resume activities that being launched behind because these
		// activities are actually behind other fullscreen activities, but still required
		// to be visible (such as performing Recents animation).
		final boolean resumeTopActivity = isFocusable() && isInStackLocked(starting) == null
		&& top != null && !top.mLaunchTaskBehind;
		for (int taskNdx = getChildCount() - 1; taskNdx >= 0; --taskNdx) {
		final Task task = getChildAt(taskNdx);
		for (int activityNdx = task.getChildCount() - 1; activityNdx >= 0; --activityNdx) {
		final ActivityRecord r = task.getChildAt(activityNdx);
		final boolean isTop = r == top;
		if (aboveTop && !isTop) {
		continue;
		}
		aboveTop = false;

		final boolean reallyVisible = r.shouldBeVisible(behindFullscreenActivity,
		false /* ignoringKeyguard */);
		// Check whether activity should be visible without Keyguard influence
		if (r.visibleIgnoringKeyguard) {
		if (r.occludesParent()) {
		// At this point, nothing else needs to be shown in this task.
		if (DEBUG_VISIBILITY) Slog.v(TAG_VISIBILITY, "Fullscreen: at " + r
		+ " stackVisible=" + stackShouldBeVisible
		+ " behindFullscreen=" + behindFullscreenActivity);
		behindFullscreenActivity = true;
		} else {
		behindFullscreenActivity = false;
		}
		}

		if (reallyVisible) {
		if (r.finishing) {
		continue;
		}
		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 /* ignoreVisibility */);
		}

		if (!r.attachedToProcess()) {
		makeVisibleAndRestartIfNeeded(starting, configChanges, isTop,
		resumeTopActivity && isTop, r);
		} else if (r.mVisibleRequested) {
		// 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();
		}

		r.handleAlreadyVisible();
		if (notifyClients) {
		r.makeActiveIfNeeded(starting);
		}
		} 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);
		r.makeInvisible();
		}
		}
		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;
		}
		}
		mEnsureActivitiesVisibleHelper.process(
		starting, configChanges, preserveWindows, notifyClients);

		if (mTranslucentActivityWaiting != null &&
		mUndrawnActivitiesBelowTopTranslucent.isEmpty()) {
		@@ -2214,7 +2113,7 @@ class ActivityStack extends WindowContainer<Task> implements BoundsAnimationTarg
		return (flags & FLAG_CAN_SHOW_WITH_INSECURE_KEYGUARD) != 0;
		}

		private void checkTranslucentActivityWaiting(ActivityRecord top) {
		void checkTranslucentActivityWaiting(ActivityRecord top) {
		if (mTranslucentActivityWaiting != top) {
		mUndrawnActivitiesBelowTopTranslucent.clear();
		if (mTranslucentActivityWaiting != null) {
		@@ -2226,31 +2125,6 @@ class ActivityStack extends WindowContainer<Task> implements BoundsAnimationTarg
		}
		}

		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.mVisibleRequested) {
		// 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(configChanges);
		}
		if (!r.mVisibleRequested \|\| r.mLaunchTaskBehind) {
		if (DEBUG_VISIBILITY) Slog.v(TAG_VISIBILITY, "Starting and making visible: " + r);
		r.setVisibility(true);
		}
		if (r != starting) {
		mStackSupervisor.startSpecificActivityLocked(r, andResume, true /* checkConfig */);
		return true;
		}
		}
		return false;
		}

		void convertActivityToTranslucent(ActivityRecord r) {
		mTranslucentActivityWaiting = r;
		mUndrawnActivitiesBelowTopTranslucent.clear();
		@@ -2490,7 +2364,7 @@ class ActivityStack extends WindowContainer<Task> implements BoundsAnimationTarg
		&& next.containsDismissKeyguardWindow();

		if (canShowWhenLocked \|\| mayDismissKeyguard) {
		ensureActivitiesVisibleLocked(null /* starting /, 0 / configChanges */,
		ensureActivitiesVisible(null /* starting /, 0 / configChanges */,
		!PRESERVE_WINDOWS);
		nothingToResume = shouldSleepActivities();
		}
		@@ -2819,7 +2693,7 @@ class ActivityStack extends WindowContainer<Task> implements BoundsAnimationTarg
		next.showStartingWindow(null /* prev /, false / newTask */,
		false /* taskSwitch */);
		}
		mStackSupervisor.startSpecificActivityLocked(next, true, false);
		mStackSupervisor.startSpecificActivity(next, true, false);
		return true;
		}

		@@ -2846,7 +2720,7 @@ class ActivityStack extends WindowContainer<Task> implements BoundsAnimationTarg
		if (DEBUG_SWITCH) Slog.v(TAG_SWITCH, "Restarting: " + next);
		}
		if (DEBUG_STATES) Slog.d(TAG_STATES, "resumeTopActivityLocked: Restarting " + next);
		mStackSupervisor.startSpecificActivityLocked(next, true, true);
		mStackSupervisor.startSpecificActivity(next, true, true);
		}

		return true;
		@@ -2991,7 +2865,7 @@ class ActivityStack extends WindowContainer<Task> implements BoundsAnimationTarg
		// 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);
		ensureActivitiesVisible(null, 0, !PRESERVE_WINDOWS);
		// Go ahead to execute app transition for this activity since the app transition
		// will not be triggered through the resume channel.
		getDisplay().mDisplayContent.executeAppTransition();
		@@ -4381,7 +4255,7 @@ class ActivityStack extends WindowContainer<Task> implements BoundsAnimationTarg

		// 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);
		ensureActivitiesVisible(null, 0, !PRESERVE_WINDOWS);
		mRootActivityContainer.resumeFocusedStacksTopActivities();
		}

services/core/java/com/android/server/wm/ActivityStackSupervisor.java

+4 −4

Original line number	Diff line number	Diff line
		@@ -975,7 +975,7 @@ public class ActivityStackSupervisor implements RecentTasks.Callbacks {
		}
		}

		void startSpecificActivityLocked(ActivityRecord r, boolean andResume, boolean checkConfig) {
		void startSpecificActivity(ActivityRecord r, boolean andResume, boolean checkConfig) {
		// Is this activity's application already running?
		final WindowProcessController wpc =
		mService.getProcessController(r.processName, r.info.applicationInfo.uid);
		@@ -1742,12 +1742,12 @@ public class ActivityStackSupervisor implements RecentTasks.Callbacks {
		* 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
		* ensureActivitiesVisible() 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.
		*/
		stack.mForceHidden = true;
		stack.ensureActivitiesVisibleLocked(null, 0, PRESERVE_WINDOWS);
		stack.ensureActivitiesVisible(null, 0, PRESERVE_WINDOWS);
		stack.mForceHidden = false;
		activityIdleInternalLocked(null, false /* fromTimeout */,
		true /* processPausingActivites /, null / configuration */);
		@@ -2072,7 +2072,7 @@ public class ActivityStackSupervisor implements RecentTasks.Callbacks {

		mRecentTasks.add(task);
		mService.getTaskChangeNotificationController().notifyTaskStackChanged();
		stack.ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
		stack.ensureActivitiesVisible(null, 0, !PRESERVE_WINDOWS);

		// When launching tasks behind, update the last active time of the top task after the new
		// task has been shown briefly

services/core/java/com/android/server/wm/ActivityStarter.java

+1 −1

Original line number	Diff line number	Diff line
		@@ -1574,7 +1574,7 @@ class ActivityStarter {
		// 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(mStartActivity, 0, !PRESERVE_WINDOWS);
		mTargetStack.ensureActivitiesVisible(mStartActivity, 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().mDisplayContent.executeAppTransition();