Optimize activity snapshot for shell transition. (ed874650) · Commits · e / os / android_frameworks_base

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

+194 −95

Original line number	Original line	Diff line number	Diff line
	@@ -16,16 +16,14 @@

	package com.android.server.wm;		package com.android.server.wm;

	import static com.android.server.wm.SnapshotController.ACTIVITY_CLOSE;		import static android.os.Trace.TRACE_TAG_WINDOW_MANAGER;
	import static com.android.server.wm.SnapshotController.ACTIVITY_OPEN;
	import static com.android.server.wm.SnapshotController.TASK_CLOSE;
	import static com.android.server.wm.SnapshotController.TASK_OPEN;

	import android.annotation.NonNull;		import android.annotation.NonNull;
	import android.annotation.Nullable;		import android.annotation.Nullable;
	import android.app.ActivityManager;		import android.app.ActivityManager;
	import android.os.Environment;		import android.os.Environment;
	import android.os.SystemProperties;		import android.os.SystemProperties;
			import android.os.Trace;
	import android.util.ArraySet;		import android.util.ArraySet;
	import android.util.Slog;		import android.util.Slog;
	import android.util.SparseArray;		import android.util.SparseArray;
	@@ -35,7 +33,6 @@ import com.android.internal.annotations.VisibleForTesting;
	import com.android.server.LocalServices;		import com.android.server.LocalServices;
	import com.android.server.pm.UserManagerInternal;		import com.android.server.pm.UserManagerInternal;
	import com.android.server.wm.BaseAppSnapshotPersister.PersistInfoProvider;		import com.android.server.wm.BaseAppSnapshotPersister.PersistInfoProvider;
	import com.android.server.wm.SnapshotController.TransitionState;

	import java.io.File;		import java.io.File;
	import java.util.ArrayList;		import java.util.ArrayList;
	@@ -61,12 +58,6 @@ class ActivitySnapshotController extends AbsAppSnapshotController<ActivityRecord

	static final String SNAPSHOTS_DIRNAME = "activity_snapshots";		static final String SNAPSHOTS_DIRNAME = "activity_snapshots";

	/**
	* The pending activities which should capture snapshot when process transition finish.
	*/
	@VisibleForTesting
	final ArraySet<ActivityRecord> mPendingCaptureActivity = new ArraySet<>();

	/**		/**
	* The pending activities which should remove snapshot from memory when process transition		* The pending activities which should remove snapshot from memory when process transition
	* finish.		* finish.
	@@ -86,6 +77,10 @@ class ActivitySnapshotController extends AbsAppSnapshotController<ActivityRecord
	@VisibleForTesting		@VisibleForTesting
	final ArraySet<ActivityRecord> mPendingLoadActivity = new ArraySet<>();		final ArraySet<ActivityRecord> mPendingLoadActivity = new ArraySet<>();

			private final ArraySet<ActivityRecord> mOnBackPressedActivities = new ArraySet<>();

			private final ArrayList<ActivityRecord> mTmpBelowActivities = new ArrayList<>();
			private final ArrayList<WindowContainer> mTmpTransitionParticipants = new ArrayList<>();
	private final SnapshotPersistQueue mSnapshotPersistQueue;		private final SnapshotPersistQueue mSnapshotPersistQueue;
	private final PersistInfoProvider mPersistInfoProvider;		private final PersistInfoProvider mPersistInfoProvider;
	private final AppSnapshotLoader mSnapshotLoader;		private final AppSnapshotLoader mSnapshotLoader;
	@@ -117,20 +112,6 @@ class ActivitySnapshotController extends AbsAppSnapshotController<ActivityRecord
	setSnapshotEnabled(snapshotEnabled);		setSnapshotEnabled(snapshotEnabled);
	}		}

	void systemReady() {
	if (shouldDisableSnapshots()) {
	return;
	}
	mService.mSnapshotController.registerTransitionStateConsumer(
	ACTIVITY_OPEN, this::handleOpenActivityTransition);
	mService.mSnapshotController.registerTransitionStateConsumer(
	ACTIVITY_CLOSE, this::handleCloseActivityTransition);
	mService.mSnapshotController.registerTransitionStateConsumer(
	TASK_OPEN, this::handleOpenTaskTransition);
	mService.mSnapshotController.registerTransitionStateConsumer(
	TASK_CLOSE, this::handleCloseTaskTransition);
	}

	@Override		@Override
	protected float initSnapshotScale() {		protected float initSnapshotScale() {
	final float config = mService.mContext.getResources().getFloat(		final float config = mService.mContext.getResources().getFloat(
	@@ -173,6 +154,7 @@ class ActivitySnapshotController extends AbsAppSnapshotController<ActivityRecord

	@Override		@Override
	void write() {		void write() {
			Trace.traceBegin(TRACE_TAG_WINDOW_MANAGER, "cleanUpUserFiles");
	final File file = mPersistInfoProvider.getDirectory(userId);		final File file = mPersistInfoProvider.getDirectory(userId);
	if (file.exists()) {		if (file.exists()) {
	final File[] contents = file.listFiles();		final File[] contents = file.listFiles();
	@@ -182,15 +164,30 @@ class ActivitySnapshotController extends AbsAppSnapshotController<ActivityRecord
	}		}
	}		}
	}		}
			Trace.traceEnd(TRACE_TAG_WINDOW_MANAGER);
	}		}
	});		});
	}		}
	}		}

			void addOnBackPressedActivity(ActivityRecord ar) {
			if (shouldDisableSnapshots()) {
			return;
			}
			mOnBackPressedActivities.add(ar);
			}

			void clearOnBackPressedActivities() {
			if (shouldDisableSnapshots()) {
			return;
			}
			mOnBackPressedActivities.clear();
			}

	/**		/**
	* Prepare to handle on transition start. Clear all temporary fields.		* Prepare to collect any change for snapshots processing. Clear all temporary fields.
	*/		*/
	void preTransitionStart() {		void beginSnapshotProcess() {
	if (shouldDisableSnapshots()) {		if (shouldDisableSnapshots()) {
	return;		return;
	}		}
	@@ -198,18 +195,22 @@ class ActivitySnapshotController extends AbsAppSnapshotController<ActivityRecord
	}		}

	/**		/**
	* on transition start has notified, start process data.		* End collect any change for snapshots processing, start process data.
	*/		*/
	void postTransitionStart() {		void endSnapshotProcess() {
	if (shouldDisableSnapshots()) {		if (shouldDisableSnapshots()) {
	return;		return;
	}		}
	onCommitTransition();		for (int i = mOnBackPressedActivities.size() - 1; i >= 0; --i) {
			handleActivityTransition(mOnBackPressedActivities.valueAt(i));
			}
			mOnBackPressedActivities.clear();
			mTmpTransitionParticipants.clear();
			postProcess();
	}		}

	@VisibleForTesting		@VisibleForTesting
	void resetTmpFields() {		void resetTmpFields() {
	mPendingCaptureActivity.clear();
	mPendingRemoveActivity.clear();		mPendingRemoveActivity.clear();
	mPendingDeleteActivity.clear();		mPendingDeleteActivity.clear();
	mPendingLoadActivity.clear();		mPendingLoadActivity.clear();
	@@ -218,31 +219,13 @@ class ActivitySnapshotController extends AbsAppSnapshotController<ActivityRecord
	/**		/**
	* Start process all pending activities for a transition.		* Start process all pending activities for a transition.
	*/		*/
	private void onCommitTransition() {		private void postProcess() {
	if (DEBUG) {		if (DEBUG) {
	Slog.d(TAG, "ActivitySnapshotController#onCommitTransition result:"		Slog.d(TAG, "ActivitySnapshotController#postProcess result:"
	+ " capture " + mPendingCaptureActivity
	+ " remove " + mPendingRemoveActivity		+ " remove " + mPendingRemoveActivity
	+ " delete " + mPendingDeleteActivity		+ " delete " + mPendingDeleteActivity
	+ " load " + mPendingLoadActivity);		+ " load " + mPendingLoadActivity);
	}		}
	// task snapshots
	for (int i = mPendingCaptureActivity.size() - 1; i >= 0; i--) {
	recordSnapshot(mPendingCaptureActivity.valueAt(i));
	}
	// clear mTmpRemoveActivity from cache
	for (int i = mPendingRemoveActivity.size() - 1; i >= 0; i--) {
	final ActivityRecord ar = mPendingRemoveActivity.valueAt(i);
	final int code = getSystemHashCode(ar);
	mCache.onIdRemoved(code);
	}
	// clear snapshot on cache and delete files
	for (int i = mPendingDeleteActivity.size() - 1; i >= 0; i--) {
	final ActivityRecord ar = mPendingDeleteActivity.valueAt(i);
	final int code = getSystemHashCode(ar);
	mCache.onIdRemoved(code);
	removeIfUserSavedFileExist(code, ar.mUserId);
	}
	// load snapshot to cache		// load snapshot to cache
	for (int i = mPendingLoadActivity.size() - 1; i >= 0; i--) {		for (int i = mPendingLoadActivity.size() - 1; i >= 0; i--) {
	final ActivityRecord ar = mPendingLoadActivity.valueAt(i);		final ActivityRecord ar = mPendingLoadActivity.valueAt(i);
	@@ -258,6 +241,8 @@ class ActivitySnapshotController extends AbsAppSnapshotController<ActivityRecord
	new SnapshotPersistQueue.WriteQueueItem(mPersistInfoProvider) {		new SnapshotPersistQueue.WriteQueueItem(mPersistInfoProvider) {
	@Override		@Override
	void write() {		void write() {
			Trace.traceBegin(TRACE_TAG_WINDOW_MANAGER,
			"load_activity_snapshot");
	final TaskSnapshot snapshot = mSnapshotLoader.loadTask(code,		final TaskSnapshot snapshot = mSnapshotLoader.loadTask(code,
	userId, false /* loadLowResolutionBitmap */);		userId, false /* loadLowResolutionBitmap */);
	synchronized (mService.getWindowManagerLock()) {		synchronized (mService.getWindowManagerLock()) {
	@@ -265,16 +250,36 @@ class ActivitySnapshotController extends AbsAppSnapshotController<ActivityRecord
	mCache.putSnapshot(ar, snapshot);		mCache.putSnapshot(ar, snapshot);
	}		}
	}		}
			Trace.traceEnd(TRACE_TAG_WINDOW_MANAGER);
	}		}
	});		});
	}		}
	}		}
	}		}
			// clear mTmpRemoveActivity from cache
			for (int i = mPendingRemoveActivity.size() - 1; i >= 0; i--) {
			final ActivityRecord ar = mPendingRemoveActivity.valueAt(i);
			final int code = getSystemHashCode(ar);
			mCache.onIdRemoved(code);
			}
			// clear snapshot on cache and delete files
			for (int i = mPendingDeleteActivity.size() - 1; i >= 0; i--) {
			final ActivityRecord ar = mPendingDeleteActivity.valueAt(i);
			final int code = getSystemHashCode(ar);
			mCache.onIdRemoved(code);
			removeIfUserSavedFileExist(code, ar.mUserId);
			}
	// don't keep any reference		// don't keep any reference
	resetTmpFields();		resetTmpFields();
	}		}

	private void recordSnapshot(ActivityRecord activity) {		void recordSnapshot(ActivityRecord activity) {
			if (shouldDisableSnapshots()) {
			return;
			}
			if (DEBUG) {
			Slog.d(TAG, "ActivitySnapshotController#recordSnapshot " + activity);
			}
	final TaskSnapshot snapshot = recordSnapshotInner(activity, false /* allowSnapshotHome */);		final TaskSnapshot snapshot = recordSnapshotInner(activity, false /* allowSnapshotHome */);
	if (snapshot != null) {		if (snapshot != null) {
	final int code = getSystemHashCode(activity);		final int code = getSystemHashCode(activity);
	@@ -285,15 +290,20 @@ class ActivitySnapshotController extends AbsAppSnapshotController<ActivityRecord
	/**		/**
	* Called when the visibility of an app changes outside the regular app transition flow.		* Called when the visibility of an app changes outside the regular app transition flow.
	*/		*/
	void notifyAppVisibilityChanged(ActivityRecord appWindowToken, boolean visible) {		void notifyAppVisibilityChanged(ActivityRecord ar, boolean visible) {
	if (shouldDisableSnapshots()) {		if (shouldDisableSnapshots()) {
	return;		return;
	}		}
			final Task task = ar.getTask();
			if (task == null) {
			return;
			}
			// Doesn't need to capture activity snapshot when it converts from translucent.
	if (!visible) {		if (!visible) {
	resetTmpFields();		resetTmpFields();
	addBelowTopActivityIfExist(appWindowToken.getTask(), mPendingRemoveActivity,		addBelowActivityIfExist(ar, mPendingRemoveActivity, false,
	"remove-snapshot");		"remove-snapshot");
	onCommitTransition();		postProcess();
	}		}
	}		}

	@@ -301,65 +311,146 @@ class ActivitySnapshotController extends AbsAppSnapshotController<ActivityRecord
	return System.identityHashCode(activity);		return System.identityHashCode(activity);
	}		}

	void handleOpenActivityTransition(TransitionState<ActivityRecord> transitionState) {		@VisibleForTesting
	ArraySet<ActivityRecord> participant = transitionState.getParticipant(false /* open */);		void handleTransitionFinish(@NonNull ArrayList<WindowContainer> windows) {
	for (ActivityRecord ar : participant) {		mTmpTransitionParticipants.clear();
	mPendingCaptureActivity.add(ar);		mTmpTransitionParticipants.addAll(windows);
	// remove the snapshot for the one below close		for (int i = mTmpTransitionParticipants.size() - 1; i >= 0; --i) {
	final ActivityRecord below = ar.getTask().getActivityBelow(ar);		final WindowContainer next = mTmpTransitionParticipants.get(i);
	if (below != null) {		if (next.asTask() != null) {
	mPendingRemoveActivity.add(below);		handleTaskTransition(next.asTask());
			} else if (next.asTaskFragment() != null) {
			final TaskFragment tf = next.asTaskFragment();
			final ActivityRecord ar = tf.getTopMostActivity();
			if (ar != null) {
			handleActivityTransition(ar);
			}
			} else if (next.asActivityRecord() != null) {
			handleActivityTransition(next.asActivityRecord());
	}		}
	}		}
	}		}

	void handleCloseActivityTransition(TransitionState<ActivityRecord> transitionState) {		private void handleActivityTransition(@NonNull ActivityRecord ar) {
	ArraySet<ActivityRecord> participant = transitionState.getParticipant(true /* open */);		if (shouldDisableSnapshots()) {
	for (ActivityRecord ar : participant) {		return;
			}
			if (ar.isVisibleRequested()) {
	mPendingDeleteActivity.add(ar);		mPendingDeleteActivity.add(ar);
	// load next one if exists.		// load next one if exists.
	final ActivityRecord below = ar.getTask().getActivityBelow(ar);		addBelowActivityIfExist(ar, mPendingLoadActivity, true, "load-snapshot");
	if (below != null) {		} else {
	mPendingLoadActivity.add(below);		// remove the snapshot for the one below close
	}		addBelowActivityIfExist(ar, mPendingRemoveActivity, true, "remove-snapshot");
	}		}
	}		}

	void handleCloseTaskTransition(TransitionState<Task> closeTaskTransitionRecord) {		private void handleTaskTransition(Task task) {
	ArraySet<Task> participant = closeTaskTransitionRecord.getParticipant(false /* open */);		if (shouldDisableSnapshots()) {
	for (Task close : participant) {		return;
	// this is close task transition
	// remove the N - 1 from cache
	addBelowTopActivityIfExist(close, mPendingRemoveActivity, "remove-snapshot");
	}		}
			final ActivityRecord topActivity = task.getTopMostActivity();
			if (topActivity == null) {
			return;
	}		}
			if (task.isVisibleRequested()) {
	void handleOpenTaskTransition(TransitionState<Task> openTaskTransitionRecord) {		// this is open task transition
	ArraySet<Task> participant = openTaskTransitionRecord.getParticipant(true /* open */);		// load the N - 1 to cache
	for (Task open : participant) {		addBelowActivityIfExist(topActivity, mPendingLoadActivity, true, "load-snapshot");
	// this is close task transition
	// remove the N - 1 from cache
	addBelowTopActivityIfExist(open, mPendingLoadActivity, "load-snapshot");
	// Move the activities to top of mSavedFilesInOrder, so when purge happen, there		// Move the activities to top of mSavedFilesInOrder, so when purge happen, there
	// will trim the persisted files from the most non-accessed.		// will trim the persisted files from the most non-accessed.
	adjustSavedFileOrder(open);		adjustSavedFileOrder(task);
			} else {
			// this is close task transition
			// remove the N - 1 from cache
			addBelowActivityIfExist(topActivity, mPendingRemoveActivity, true, "remove-snapshot");
	}		}
	}		}

	// Add the top -1 activity to a set if it exists.		/**
	private void addBelowTopActivityIfExist(Task task, ArraySet<ActivityRecord> set,		* Add the top -1 activity to a set if it exists.
	String debugMessage) {		* @param inTransition true if the activity must participant in transition.
	final ActivityRecord topActivity = task.getTopMostActivity();		*/
	if (topActivity != null) {		private void addBelowActivityIfExist(ActivityRecord currentActivity,
	final ActivityRecord below = task.getActivityBelow(topActivity);		ArraySet<ActivityRecord> set, boolean inTransition, String debugMessage) {
	if (below != null) {		getActivityBelow(currentActivity, inTransition, mTmpBelowActivities);
	set.add(below);		for (int i = mTmpBelowActivities.size() - 1; i >= 0; --i) {
			set.add(mTmpBelowActivities.get(i));
	if (DEBUG) {		if (DEBUG) {
	Slog.d(TAG, "ActivitySnapshotController#addBelowTopActivityIfExist "		Slog.d(TAG, "ActivitySnapshotController#addBelowTopActivityIfExist "
	+ below + " from " + debugMessage);		+ mTmpBelowActivities.get(i) + " from " + debugMessage);
	}		}
	}		}
			mTmpBelowActivities.clear();
	}		}

			private void getActivityBelow(ActivityRecord currentActivity, boolean inTransition,
			ArrayList<ActivityRecord> result) {
			final Task currentTask = currentActivity.getTask();
			if (currentTask == null) {
			return;
			}
			final ActivityRecord initPrev = currentTask.getActivityBelow(currentActivity);
			if (initPrev == null) {
			return;
			}
			final TaskFragment currTF = currentActivity.getTaskFragment();
			final TaskFragment prevTF = initPrev.getTaskFragment();
			final TaskFragment prevAdjacentTF = prevTF != null
			? prevTF.getAdjacentTaskFragment() : null;
			if (currTF == prevTF && currTF != null \|\| prevAdjacentTF == null) {
			// Current activity and previous one is in the same task fragment, or
			// previous activity is not in a task fragment, or
			// previous activity's task fragment doesn't adjacent to any others.
			if (!inTransition \|\| isInParticipant(initPrev, mTmpTransitionParticipants)) {
			result.add(initPrev);
			}
			return;
			}

			if (prevAdjacentTF == currTF) {
			// previous activity A is adjacent to current activity B.
			// Try to find anyone below previous activityA, which are C and D if exists.
			// A \| B
			// C (\| D)
			getActivityBelow(initPrev, inTransition, result);
			} else {
			// previous activity C isn't adjacent to current activity A.
			// A
			// B \| C
			final Task prevAdjacentTask = prevAdjacentTF.getTask();
			if (prevAdjacentTask == currentTask) {
			final int currentIndex = currTF != null
			? currentTask.mChildren.indexOf(currTF)
			: currentTask.mChildren.indexOf(currentActivity);
			final int prevAdjacentIndex =
			prevAdjacentTask.mChildren.indexOf(prevAdjacentTF);
			// prevAdjacentTF already above currentActivity
			if (prevAdjacentIndex > currentIndex) {
			return;
			}
			}
			if (!inTransition \|\| isInParticipant(initPrev, mTmpTransitionParticipants)) {
			result.add(initPrev);
			}
			// prevAdjacentTF is adjacent to another one
			final ActivityRecord prevAdjacentActivity = prevAdjacentTF.getTopMostActivity();
			if (prevAdjacentActivity != null && (!inTransition
			\|\| isInParticipant(prevAdjacentActivity, mTmpTransitionParticipants))) {
			result.add(prevAdjacentActivity);
			}
			}
			}

			static boolean isInParticipant(ActivityRecord ar,
			ArrayList<WindowContainer> transitionParticipants) {
			for (int i = transitionParticipants.size() - 1; i >= 0; --i) {
			final WindowContainer wc = transitionParticipants.get(i);
			if (ar == wc \|\| ar.isDescendantOf(wc)) {
			return true;
			}
			}
			return false;
	}		}

	private void adjustSavedFileOrder(Task nextTopTask) {		private void adjustSavedFileOrder(Task nextTopTask) {
	@@ -376,6 +467,9 @@ class ActivitySnapshotController extends AbsAppSnapshotController<ActivityRecord

	@Override		@Override
	void onAppRemoved(ActivityRecord activity) {		void onAppRemoved(ActivityRecord activity) {
			if (shouldDisableSnapshots()) {
			return;
			}
	super.onAppRemoved(activity);		super.onAppRemoved(activity);
	final int code = getSystemHashCode(activity);		final int code = getSystemHashCode(activity);
	removeIfUserSavedFileExist(code, activity.mUserId);		removeIfUserSavedFileExist(code, activity.mUserId);
	@@ -386,6 +480,9 @@ class ActivitySnapshotController extends AbsAppSnapshotController<ActivityRecord

	@Override		@Override
	void onAppDied(ActivityRecord activity) {		void onAppDied(ActivityRecord activity) {
			if (shouldDisableSnapshots()) {
			return;
			}
	super.onAppDied(activity);		super.onAppDied(activity);
	final int code = getSystemHashCode(activity);		final int code = getSystemHashCode(activity);
	removeIfUserSavedFileExist(code, activity.mUserId);		removeIfUserSavedFileExist(code, activity.mUserId);
	@@ -440,7 +537,7 @@ class ActivitySnapshotController extends AbsAppSnapshotController<ActivityRecord
	private void removeIfUserSavedFileExist(int code, int userId) {		private void removeIfUserSavedFileExist(int code, int userId) {
	final UserSavedFile usf = getUserFiles(userId).get(code);		final UserSavedFile usf = getUserFiles(userId).get(code);
	if (usf != null) {		if (usf != null) {
	mUserSavedFiles.remove(code);		mUserSavedFiles.get(userId).remove(code);
	mSavedFilesInOrder.remove(usf);		mSavedFilesInOrder.remove(usf);
	mPersister.removeSnap(code, userId);		mPersister.removeSnap(code, userId);
	}		}
	@@ -490,11 +587,13 @@ class ActivitySnapshotController extends AbsAppSnapshotController<ActivityRecord
	new SnapshotPersistQueue.WriteQueueItem(mPersistInfoProvider) {		new SnapshotPersistQueue.WriteQueueItem(mPersistInfoProvider) {
	@Override		@Override
	void write() {		void write() {
			Trace.traceBegin(TRACE_TAG_WINDOW_MANAGER, "activity_remove_files");
	for (int i = files.size() - 1; i >= 0; --i) {		for (int i = files.size() - 1; i >= 0; --i) {
	final UserSavedFile usf = files.get(i);		final UserSavedFile usf = files.get(i);
	mSnapshotPersistQueue.deleteSnapshot(		mSnapshotPersistQueue.deleteSnapshot(
	usf.mFileId, usf.mUserId, mPersistInfoProvider);		usf.mFileId, usf.mUserId, mPersistInfoProvider);
	}		}
			Trace.traceEnd(TRACE_TAG_WINDOW_MANAGER);
	}		}
	});		});
	}		}

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

+7 −0

Original line number	Original line	Diff line number	Diff line
	@@ -1177,6 +1177,8 @@ class BackNavigationController {
	if (!composeAnimations(mCloseTarget, mOpenTarget, openActivity)) {		if (!composeAnimations(mCloseTarget, mOpenTarget, openActivity)) {
	return null;		return null;
	}		}
			mCloseTarget.mTransitionController.mSnapshotController
			.mActivitySnapshotController.clearOnBackPressedActivities();
	applyPreviewStrategy(mOpenAdaptor, openActivity);		applyPreviewStrategy(mOpenAdaptor, openActivity);

	final IBackAnimationFinishedCallback callback = makeAnimationFinishedCallback();		final IBackAnimationFinishedCallback callback = makeAnimationFinishedCallback();
	@@ -1222,6 +1224,8 @@ class BackNavigationController {
	// Call it again to make sure the activity could be visible while handling the pending		// Call it again to make sure the activity could be visible while handling the pending
	// animation.		// animation.
	activity.commitVisibility(true, true);		activity.commitVisibility(true, true);
			activity.mTransitionController.mSnapshotController
			.mActivitySnapshotController.addOnBackPressedActivity(activity);
	}		}
	activity.mLaunchTaskBehind = true;		activity.mLaunchTaskBehind = true;

	@@ -1248,6 +1252,9 @@ class BackNavigationController {
	// Restore the launch-behind state.		// Restore the launch-behind state.
	activity.mTaskSupervisor.scheduleLaunchTaskBehindComplete(activity.token);		activity.mTaskSupervisor.scheduleLaunchTaskBehindComplete(activity.token);
	activity.mLaunchTaskBehind = false;		activity.mLaunchTaskBehind = false;
			// Ignore all change
			activity.mTransitionController.mSnapshotController
			.mActivitySnapshotController.clearOnBackPressedActivities();
	ProtoLog.d(WM_DEBUG_BACK_PREVIEW,		ProtoLog.d(WM_DEBUG_BACK_PREVIEW,
	"Setting Activity.mLauncherTaskBehind to false. Activity=%s",		"Setting Activity.mLauncherTaskBehind to false. Activity=%s",
	activity);		activity);

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

+54 −253

File changed.

Preview size limit exceeded, changes collapsed.

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

+6 −0

Original line number	Original line	Diff line number	Diff line
	@@ -17,6 +17,7 @@
	package com.android.server.wm;		package com.android.server.wm;

	import static android.graphics.Bitmap.CompressFormat.JPEG;		import static android.graphics.Bitmap.CompressFormat.JPEG;
			import static android.os.Trace.TRACE_TAG_WINDOW_MANAGER;

	import static com.android.server.wm.WindowManagerDebugConfig.TAG_WITH_CLASS_NAME;		import static com.android.server.wm.WindowManagerDebugConfig.TAG_WITH_CLASS_NAME;
	import static com.android.server.wm.WindowManagerDebugConfig.TAG_WM;		import static com.android.server.wm.WindowManagerDebugConfig.TAG_WM;
	@@ -26,6 +27,7 @@ import android.annotation.TestApi;
	import android.graphics.Bitmap;		import android.graphics.Bitmap;
	import android.os.Process;		import android.os.Process;
	import android.os.SystemClock;		import android.os.SystemClock;
			import android.os.Trace;
	import android.util.AtomicFile;		import android.util.AtomicFile;
	import android.util.Slog;		import android.util.Slog;
	import android.window.TaskSnapshot;		import android.window.TaskSnapshot;
	@@ -249,6 +251,7 @@ class SnapshotPersistQueue {

	@Override		@Override
	void write() {		void write() {
			Trace.traceBegin(TRACE_TAG_WINDOW_MANAGER, "StoreWriteQueueItem");
	if (!mPersistInfoProvider.createDirectory(mUserId)) {		if (!mPersistInfoProvider.createDirectory(mUserId)) {
	Slog.e(TAG, "Unable to create snapshot directory for user dir="		Slog.e(TAG, "Unable to create snapshot directory for user dir="
	+ mPersistInfoProvider.getDirectory(mUserId));		+ mPersistInfoProvider.getDirectory(mUserId));
	@@ -263,6 +266,7 @@ class SnapshotPersistQueue {
	if (failed) {		if (failed) {
	deleteSnapshot(mId, mUserId, mPersistInfoProvider);		deleteSnapshot(mId, mUserId, mPersistInfoProvider);
	}		}
			Trace.traceEnd(TRACE_TAG_WINDOW_MANAGER);
	}		}

	boolean writeProto() {		boolean writeProto() {
	@@ -373,7 +377,9 @@ class SnapshotPersistQueue {

	@Override		@Override
	void write() {		void write() {
			Trace.traceBegin(TRACE_TAG_WINDOW_MANAGER, "DeleteWriteQueueItem");
	deleteSnapshot(mId, mUserId, mPersistInfoProvider);		deleteSnapshot(mId, mUserId, mPersistInfoProvider);
			Trace.traceEnd(TRACE_TAG_WINDOW_MANAGER);
	}		}
	}		}
	}		}

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

+11 −16

Original line number	Original line	Diff line number	Diff line
	@@ -16,7 +16,6 @@

	package com.android.server.wm;		package com.android.server.wm;

	import static com.android.server.wm.SnapshotController.TASK_CLOSE;
	import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_SCREENSHOT;		import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_SCREENSHOT;
	import static com.android.server.wm.WindowManagerDebugConfig.TAG_WM;		import static com.android.server.wm.WindowManagerDebugConfig.TAG_WM;

	@@ -77,13 +76,6 @@ class TaskSnapshotController extends AbsAppSnapshotController<Task, TaskSnapshot
	setSnapshotEnabled(snapshotEnabled);		setSnapshotEnabled(snapshotEnabled);
	}		}

	void systemReady() {
	if (!shouldDisableSnapshots()) {
	mService.mSnapshotController.registerTransitionStateConsumer(TASK_CLOSE,
	this::handleTaskClose);
	}
	}

	static PersistInfoProvider createPersistInfoProvider(WindowManagerService service,		static PersistInfoProvider createPersistInfoProvider(WindowManagerService service,
	BaseAppSnapshotPersister.DirectoryResolver resolver) {		BaseAppSnapshotPersister.DirectoryResolver resolver) {
	final float highResTaskSnapshotScale = service.mContext.getResources().getFloat(		final float highResTaskSnapshotScale = service.mContext.getResources().getFloat(
	@@ -116,20 +108,23 @@ class TaskSnapshotController extends AbsAppSnapshotController<Task, TaskSnapshot
	enableLowResSnapshots, lowResScaleFactor, use16BitFormat);		enableLowResSnapshots, lowResScaleFactor, use16BitFormat);
	}		}

	void handleTaskClose(SnapshotController.TransitionState<Task> closeTaskTransitionRecord) {		// Still needed for legacy transition.(AppTransitionControllerTest)
			void handleClosingApps(ArraySet<ActivityRecord> closingApps) {
	if (shouldDisableSnapshots()) {		if (shouldDisableSnapshots()) {
	return;		return;
	}		}
			// We need to take a snapshot of the task if and only if all activities of the task are
			// either closing or hidden.
	mTmpTasks.clear();		mTmpTasks.clear();
	final ArraySet<Task> tasks = closeTaskTransitionRecord.getParticipant(false /* open */);		for (int i = closingApps.size() - 1; i >= 0; i--) {
	if (mService.mAtmService.getTransitionController().isShellTransitionsEnabled()) {		final ActivityRecord activity = closingApps.valueAt(i);
	mTmpTasks.addAll(tasks);		final Task task = activity.getTask();
	} else {		if (task == null) continue;
	for (Task task : tasks) {
	getClosingTasksInner(task, mTmpTasks);		getClosingTasksInner(task, mTmpTasks);
	}		}
	}
	snapshotTasks(mTmpTasks);		snapshotTasks(mTmpTasks);
			mTmpTasks.clear();
	mSkipClosingAppSnapshotTasks.clear();		mSkipClosingAppSnapshotTasks.clear();
	}		}