Merge "Move PSC async Activity update methods to a helper class" into main (a0f0b18c) · Commits · e / os / android_frameworks_base

services/core/java/com/android/server/am/ActivityManagerService.java

+0 −1

Original line number	Diff line number	Diff line
		@@ -2489,7 +2489,6 @@ public class ActivityManagerService extends IActivityManager.Stub
		final Looper activityTaskLooper = DisplayThread.get().getLooper();
		mProcessStateController = new ProcessStateController.Builder(this, mProcessList, activeUids)
		.setLockObject(this)
		.setActivityStateLooper(activityTaskLooper)
		.setTopProcessChangeCallback(this::updateTopAppListeners)
		.build();
		mOomAdjuster = mProcessStateController.getOomAdjuster();

services/core/java/com/android/server/am/ProcessStateController.java

+185 −180

Original line number	Diff line number	Diff line
		@@ -58,8 +58,6 @@ public class ProcessStateController {
		private final Object mLock;
		private final Object mProcLock;

		private final Handler mActivityStateHandler;

		private final Consumer<ProcessRecord> mTopChangeCallback;

		private final GlobalState mGlobalState = new GlobalState();
		@@ -67,14 +65,12 @@ public class ProcessStateController {
		private ProcessStateController(ActivityManagerService ams, ProcessList processList,
		ActiveUids activeUids, ServiceThread handlerThread,
		CachedAppOptimizer cachedAppOptimizer, Object lock, Object procLock,
		Looper activityStateLooper, Consumer<ProcessRecord> topChangeCallback,
		OomAdjuster.Injector oomAdjInjector) {
		Consumer<ProcessRecord> topChangeCallback, OomAdjuster.Injector oomAdjInjector) {
		mOomAdjuster = new OomAdjusterImpl(ams, processList, activeUids, handlerThread,
		mGlobalState, cachedAppOptimizer, oomAdjInjector);

		mLock = lock;
		mProcLock = procLock;
		mActivityStateHandler = new Handler(activityStateLooper);
		mTopChangeCallback = topChangeCallback;
		final Handler serviceHandler = new Handler(handlerThread.getLooper());
		mServiceBinderCallUpdater = (cr, hasOngoingCalls) -> serviceHandler.post(() -> {
		@@ -147,6 +143,15 @@ public class ProcessStateController {
		mOomAdjuster.updateOomAdjFollowUpTargetsLocked();
		}

		/**
		* Create an ActivityStateAsyncUpdater to asynchronously update ProcessStateController with
		* important Activity state changes.
		* @param looper which looper to post the async work to.
		*/
		public ActivityStateAsyncUpdater createActivityStateAsyncUpdater(Looper looper) {
		return new ActivityStateAsyncUpdater(this, looper);
		}

		/**
		* Returns a {@link BoundServiceSession} for the given {@link ConnectionRecord}. Creates and
		* associates a new one if required.
		@@ -241,76 +246,17 @@ public class ProcessStateController {
		}

		/************************* Global State Events *************************/
		/**
		* Set which process state Top processes should get.
		*/
		public void setTopProcessStateAsync(@ActivityManager.ProcessState int procState) {
		if (!Flags.pushActivityStateToOomadjuster()) return;

		mActivityStateHandler.post(() -> {
		synchronized (mLock) {
		setTopProcessState(procState);
		}
		});
		}

		@GuardedBy("mLock")
		private void setTopProcessState(@ActivityManager.ProcessState int procState) {
		mGlobalState.mTopProcessState = procState;
		}

		/**
		* Set whether the device is currently unlocking.
		* Note: this does not require locking on {@link #mLock}
		*/
		public void setDeviceUnlocking(boolean unlocking) {
		if (!Flags.pushActivityStateToOomadjuster()) return;

		// This method is called from locations with uncertain ordering guarantees.
		// Just stage the state and commit it right before an OomAdjuster update.
		mGlobalState.mUnlockingStaged = unlocking;
		}

		/**
		* Set whether the top process is occluded by the notification shade.
		*/
		public void setExpandedNotificationShadeAsync(boolean expandedShade) {
		if (!Flags.pushActivityStateToOomadjuster()) return;

		mActivityStateHandler.post(() -> {
		synchronized (mLock) {
		setExpandedNotificationShade(expandedShade);
		}
		});
		}

		@GuardedBy("mLock")
		private void setExpandedNotificationShade(boolean expandedShade) {
		mGlobalState.mExpandedNotificationShade = expandedShade;
		}

		/**
		* Set the Top process, also clear the Previous process and demotion reason, if necessary.
		*/
		public void setTopProcessAsync(@Nullable WindowProcessController wpc, boolean clearPrev,
		boolean cancelExpandedShade) {
		if (!Flags.pushActivityStateToOomadjuster()) return;

		final ProcessRecord top = wpc != null ? (ProcessRecord) wpc.mOwner : null;

		mActivityStateHandler.post(() -> {
		synchronized (mLock) {
		setTopProcess(top);
		if (clearPrev) {
		setPreviousProcess(null);
		}
		if (cancelExpandedShade) {
		setExpandedNotificationShade(false);
		}
		}
		});
		}

		@GuardedBy("mLock")
		private void setTopProcess(@Nullable ProcessRecord proc) {
		if (mGlobalState.mTopProcess == proc) return;
		@@ -318,77 +264,21 @@ public class ProcessStateController {
		mTopChangeCallback.accept(proc);
		}

		/**
		* Set which process is considered the Previous process, if any.
		*/
		public void setPreviousProcessAsync(@Nullable WindowProcessController wpc) {
		if (!Flags.pushActivityStateToOomadjuster()) return;

		final ProcessRecord prev = wpc != null ? (ProcessRecord) wpc.mOwner : null;
		mActivityStateHandler.post(() -> {
		synchronized (mLock) {
		setPreviousProcess(prev);
		}
		});
		}

		@GuardedBy("mLock")
		private void setPreviousProcess(@Nullable ProcessRecord proc) {
		mGlobalState.mPreviousProcess = proc;
		}

		/**
		* Set which process is considered the Home process, if any.
		*/
		public void setHomeProcessAsync(@Nullable WindowProcessController wpc) {
		if (!Flags.pushActivityStateToOomadjuster()) return;

		final ProcessRecord home = wpc != null ? (ProcessRecord) wpc.mOwner : null;
		mActivityStateHandler.post(() -> {
		synchronized (mLock) {
		setHomeProcess(home);
		}
		});
		}

		@GuardedBy("mLock")
		private void setHomeProcess(@Nullable ProcessRecord proc) {
		mGlobalState.mHomeProcess = proc;
		}

		/**
		* Set which process is considered the Heavy Weight process, if any.
		*/
		public void setHeavyWeightProcessAsync(@Nullable WindowProcessController wpc) {
		if (!Flags.pushActivityStateToOomadjuster()) return;

		final ProcessRecord heavy = wpc != null ? (ProcessRecord) wpc.mOwner : null;
		mActivityStateHandler.post(() -> {
		synchronized (mLock) {
		setHeavyWeightProcess(heavy);
		}
		});
		}

		@GuardedBy("mLock")
		private void setHeavyWeightProcess(@Nullable ProcessRecord proc) {
		mGlobalState.mHeavyWeightProcess = proc;
		}

		/**
		* Set which process is showing UI while the screen is off, if any.
		*/
		public void setVisibleDozeUiProcessAsync(@Nullable WindowProcessController wpc) {
		if (!Flags.pushActivityStateToOomadjuster()) return;

		final ProcessRecord dozeUi = wpc != null ? (ProcessRecord) wpc.mOwner : null;
		mActivityStateHandler.post(() -> {
		synchronized (mLock) {
		setVisibleDozeUiProcess(dozeUi);
		}
		});
		}

		@GuardedBy("mLock")
		private void setVisibleDozeUiProcess(@Nullable ProcessRecord proc) {
		mGlobalState.mShowingUiWhileDozingProcess = proc;
		@@ -549,41 +439,11 @@ public class ProcessStateController {
		proc.mState.setHasShownUi(hasShownUi);
		}

		/**
		* Note whether the process has an activity or not.
		*/
		public void setHasActivityAsync(@NonNull WindowProcessController wpc, boolean hasActivity) {
		if (!Flags.pushActivityStateToOomadjuster()) return;

		final ProcessRecord activity = (ProcessRecord) wpc.mOwner;
		mActivityStateHandler.post(() -> {
		synchronized (mLock) {
		setHasActivity(activity, hasActivity);
		}
		});
		}

		@GuardedBy("mLock")
		private void setHasActivity(@NonNull ProcessRecord proc, boolean hasActivity) {
		proc.mState.setHasActivities(hasActivity);
		}

		/**
		* Set the Activity State for a process, including the Activity state flags and when a
		*/
		public void setActivityStateAsync(@NonNull WindowProcessController wpc, int flags,
		long perceptibleStopTimeMs) {
		if (!Flags.pushActivityStateToOomadjuster()) return;

		final ProcessRecord activity = (ProcessRecord) wpc.mOwner;
		mActivityStateHandler.post(() -> {
		synchronized (mLock) {
		setActivityStateFlags(activity, flags);
		setPerceptibleTaskStoppedTimeMillis(activity, perceptibleStopTimeMs);
		}
		});
		}

		@GuardedBy("mLock")
		private void setActivityStateFlags(@NonNull ProcessRecord proc, int flags) {
		proc.mState.setActivityStateFlags(flags);
		@@ -594,21 +454,6 @@ public class ProcessStateController {
		proc.mState.setPerceptibleTaskStoppedTimeMillis(uptimeMs);
		}

		/**
		* Set whether a process has had any recent tasks.
		*/
		public void setHasRecentTasksAsync(@NonNull WindowProcessController wpc,
		boolean hasRecentTasks) {
		if (!Flags.pushActivityStateToOomadjuster()) return;

		final ProcessRecord proc = (ProcessRecord) wpc.mOwner;
		mActivityStateHandler.post(() -> {
		synchronized (mLock) {
		setHasRecentTasks(proc, hasRecentTasks);
		}
		});
		}

		@GuardedBy("mLock")
		private void setHasRecentTasks(@NonNull ProcessRecord proc, boolean hasRecentTasks) {
		proc.mState.setHasRecentTask(hasRecentTasks);
		@@ -927,6 +772,179 @@ public class ProcessStateController {
		}
		}

		/**
		* Helper class for sending Activity related state from Window Manager to
		* ProcessStateController. Because ProcessStateController is guarded by a lock WindowManager
		* avoids acquiring, all of the work will posted to the provided Looper's thread with the
		* provided lock object.
		*/
		public static class ActivityStateAsyncUpdater {
		private final ProcessStateController mPsc;
		private final Handler mHandler;

		private ActivityStateAsyncUpdater(ProcessStateController psc, Looper looper) {
		mPsc = psc;
		mHandler = new Handler(looper);
		}

		/**
		* Set whether the device is currently unlocking.
		*/
		public void setDeviceUnlocking(boolean unlocking) {
		if (!Flags.pushActivityStateToOomadjuster()) return;

		mPsc.mGlobalState.mUnlockingStaged = unlocking;
		}

		/**
		* Set whether the top process is occluded by the notification shade.
		*/
		public void setExpandedNotificationShadeAsync(boolean expandedShade) {
		if (!Flags.pushActivityStateToOomadjuster()) return;

		mHandler.post(() -> {
		synchronized (mPsc.mLock) {
		mPsc.setExpandedNotificationShade(expandedShade);
		}
		});
		}

		/**
		* Set the Top process, also clear the Previous process and demotion reason, if necessary.
		*/
		public void setTopProcessAsync(@Nullable WindowProcessController wpc, boolean clearPrev,
		boolean cancelExpandedShade) {
		if (!Flags.pushActivityStateToOomadjuster()) return;

		final ProcessRecord top = wpc != null ? (ProcessRecord) wpc.mOwner : null;
		mHandler.post(() -> {
		synchronized (mPsc.mLock) {
		mPsc.setTopProcess(top);
		if (clearPrev) {
		mPsc.setPreviousProcess(null);
		}
		if (cancelExpandedShade) {
		mPsc.setExpandedNotificationShade(false);
		}
		}
		});
		}

		/**
		* Set which process state Top processes should get.
		*/
		public void setTopProcessStateAsync(@ActivityManager.ProcessState int procState) {
		if (!Flags.pushActivityStateToOomadjuster()) return;

		mHandler.post(() -> {
		synchronized (mPsc.mLock) {
		mPsc.setTopProcessState(procState);
		}
		});
		}

		/**
		* Set which process is considered the Previous process, if any.
		*/
		public void setPreviousProcessAsync(@Nullable WindowProcessController wpc) {
		if (!Flags.pushActivityStateToOomadjuster()) return;

		final ProcessRecord prev = wpc != null ? (ProcessRecord) wpc.mOwner : null;
		mHandler.post(() -> {
		synchronized (mPsc.mLock) {
		mPsc.setPreviousProcess(prev);
		}
		});
		}

		/**
		* Set which process is considered the Home process, if any.
		*/
		public void setHomeProcessAsync(@Nullable WindowProcessController wpc) {
		if (!Flags.pushActivityStateToOomadjuster()) return;

		final ProcessRecord home = wpc != null ? (ProcessRecord) wpc.mOwner : null;
		mHandler.post(() -> {
		synchronized (mPsc.mLock) {
		mPsc.setHomeProcess(home);
		}
		});
		}

		/**
		* Set which process is considered the Heavy Weight process, if any.
		*/
		public void setHeavyWeightProcessAsync(@Nullable WindowProcessController wpc) {
		if (!Flags.pushActivityStateToOomadjuster()) return;

		final ProcessRecord heavy = wpc != null ? (ProcessRecord) wpc.mOwner : null;
		mHandler.post(() -> {
		synchronized (mPsc.mLock) {
		mPsc.setHeavyWeightProcess(heavy);
		}
		});
		}

		/**
		* Set which process is showing UI while the screen is off, if any.
		*/
		public void setVisibleDozeUiProcessAsync(@Nullable WindowProcessController wpc) {
		if (!Flags.pushActivityStateToOomadjuster()) return;

		final ProcessRecord dozeUi = wpc != null ? (ProcessRecord) wpc.mOwner : null;
		mHandler.post(() -> {
		synchronized (mPsc.mLock) {
		mPsc.setVisibleDozeUiProcess(dozeUi);
		}
		});
		}

		/**
		* Note whether the process has an activity or not.
		*/
		public void setHasActivityAsync(@NonNull WindowProcessController wpc, boolean hasActivity) {
		if (!Flags.pushActivityStateToOomadjuster()) return;

		final ProcessRecord activity = (ProcessRecord) wpc.mOwner;
		mHandler.post(() -> {
		synchronized (mPsc.mLock) {
		mPsc.setHasActivity(activity, hasActivity);
		}
		});
		}

		/**
		* Set the Activity State for a process, including the Activity state flags and when a
		*/
		public void setActivityStateAsync(@NonNull WindowProcessController wpc, int flags,
		long perceptibleStopTimeMs) {
		if (!Flags.pushActivityStateToOomadjuster()) return;

		final ProcessRecord activity = (ProcessRecord) wpc.mOwner;
		mHandler.post(() -> {
		synchronized (mPsc.mLock) {
		mPsc.setActivityStateFlags(activity, flags);
		mPsc.setPerceptibleTaskStoppedTimeMillis(activity, perceptibleStopTimeMs);
		}
		});
		}

		/**
		* Set whether a process has had any recent tasks.
		*/
		public void setHasRecentTasksAsync(@NonNull WindowProcessController wpc,
		boolean hasRecentTasks) {
		if (!Flags.pushActivityStateToOomadjuster()) return;

		final ProcessRecord proc = (ProcessRecord) wpc.mOwner;
		mHandler.post(() -> {
		synchronized (mPsc.mLock) {
		mPsc.setHasRecentTasks(proc, hasRecentTasks);
		}
		});
		}
		}

		/**
		* Builder for ProcessStateController.
		*/
		@@ -939,7 +957,6 @@ public class ProcessStateController {
		private CachedAppOptimizer mCachedAppOptimizer = null;
		private Object mLock = null;
		private Consumer<ProcessRecord> mTopChangeCallback = null;
		private Looper mActivityStateLooper = null;
		private OomAdjuster.Injector mOomAdjInjector = null;

		public Builder(ActivityManagerService ams, ProcessList processList, ActiveUids activeUids) {
		@@ -961,10 +978,6 @@ public class ProcessStateController {
		if (mLock == null) {
		mLock = new Object();
		}
		if (mActivityStateLooper == null) {
		// Just use the OomAdjuster Looper.
		mActivityStateLooper = mHandlerThread.getLooper();
		}
		if (mTopChangeCallback == null) {
		mTopChangeCallback = proc -> {};
		}
		@@ -972,8 +985,8 @@ public class ProcessStateController {
		mOomAdjInjector = new OomAdjuster.Injector();
		}
		return new ProcessStateController(mAms, mProcessList, mActiveUids, mHandlerThread,
		mCachedAppOptimizer, mLock, mAms.mProcLock, mActivityStateLooper,
		mTopChangeCallback, mOomAdjInjector);
		mCachedAppOptimizer, mLock, mAms.mProcLock, mTopChangeCallback,
		mOomAdjInjector);
		}

		/**
		@@ -1011,14 +1024,6 @@ public class ProcessStateController {
		return this;
		}

		/**
		* Set what looper async Activity state changes are processed on.
		*/
		public Builder setActivityStateLooper(Looper looper) {
		mActivityStateLooper = looper;
		return this;
		}

		/**
		* Set a callback for when ProcessStateController is informed about the Top process
		* changing.

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

+16 −16

Original line number	Diff line number	Diff line
		@@ -397,7 +397,7 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
		PendingIntentController mPendingIntentController;
		IntentFirewall mIntentFirewall;

		ProcessStateController mProcessStateController;
		ProcessStateController.ActivityStateAsyncUpdater mActivityStateUpdater;

		final VisibleActivityProcessTracker mVisibleActivityProcessTracker;

		@@ -1030,7 +1030,7 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
		mAppWarnings = createAppWarnings(mUiContext, mH, mUiHandler, systemDir);
		mCompatModePackages = new CompatModePackages(this, systemDir, mH);
		mPendingIntentController = intentController;
		mProcessStateController = processStateController;
		mActivityStateUpdater = processStateController.createActivityStateAsyncUpdater(looper);
		mTaskSupervisor = createTaskSupervisor();
		mActivityClientController = new ActivityClientController(this);

		@@ -3152,7 +3152,7 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
		// unlock is either completed or canceled.
		if ((mDemoteTopAppReasons & DEMOTE_TOP_REASON_DURING_UNLOCKING) != 0) {
		mDemoteTopAppReasons &= ~DEMOTE_TOP_REASON_DURING_UNLOCKING;
		mProcessStateController.setDeviceUnlocking(false);
		mActivityStateUpdater.setDeviceUnlocking(false);
		// The scheduling group of top process was demoted by unlocking, so recompute
		// to restore its real top priority if possible.
		if (mTopApp != null) {
		@@ -3213,7 +3213,7 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
		final WindowProcessController proc;
		synchronized (mGlobalLockWithoutBoost) {
		mDemoteTopAppReasons &= ~DEMOTE_TOP_REASON_DURING_UNLOCKING;
		mProcessStateController.setDeviceUnlocking(false);
		mActivityStateUpdater.setDeviceUnlocking(false);
		final WindowState notificationShade = mRootWindowContainer.getDefaultDisplay()
		.getDisplayPolicy().getNotificationShade();
		proc = notificationShade != null ? notificationShade.getProcess() : null;
		@@ -4007,7 +4007,7 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
		} else if (mKeyguardShown) {
		// Only set if it is not unlocking to launcher which may also animate.
		mDemoteTopAppReasons \|= DEMOTE_TOP_REASON_DURING_UNLOCKING;
		mProcessStateController.setDeviceUnlocking(true);
		mActivityStateUpdater.setDeviceUnlocking(true);
		}

		final boolean wasNoResumed = mTopApp == null \|\| !mTopApp.hasResumedActivity();
		@@ -5236,7 +5236,7 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
		mH.removeMessages(H.END_POWER_MODE_UNKNOWN_VISIBILITY_MSG);
		}
		mRetainPowerModeAndTopProcessState = true;
		mProcessStateController.setTopProcessStateAsync(mInternal.getTopProcessState());
		mActivityStateUpdater.setTopProcessStateAsync(mInternal.getTopProcessState());
		mH.sendEmptyMessageDelayed(H.END_POWER_MODE_UNKNOWN_VISIBILITY_MSG,
		POWER_MODE_UNKNOWN_VISIBILITY_TIMEOUT_MS);
		Slog.d(TAG, "Temporarily retain top process state for launching app");
		@@ -5271,7 +5271,7 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
		if (allResolved) {
		mPowerModeReasons &= ~POWER_MODE_REASON_UNKNOWN_VISIBILITY;
		mRetainPowerModeAndTopProcessState = false;
		mProcessStateController.setTopProcessStateAsync(mInternal.getTopProcessState());
		mActivityStateUpdater.setTopProcessStateAsync(mInternal.getTopProcessState());
		mH.removeMessages(H.END_POWER_MODE_UNKNOWN_VISIBILITY_MSG);
		}
		}
		@@ -5538,7 +5538,7 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
		mTopApp.addToPendingTop();
		}
		mTopProcessState = ActivityManager.PROCESS_STATE_TOP;
		mProcessStateController.setTopProcessStateAsync(mInternal.getTopProcessState());
		mActivityStateUpdater.setTopProcessStateAsync(mInternal.getTopProcessState());
		Slog.d(TAG, "Top Process State changed to PROCESS_STATE_TOP");
		mTaskSupervisor.comeOutOfSleepIfNeededLocked();
		updateOomAdj = true;
		@@ -5552,7 +5552,7 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
		mCurAppTimeTracker.stop();
		}
		mTopProcessState = ActivityManager.PROCESS_STATE_TOP_SLEEPING;
		mProcessStateController.setTopProcessStateAsync(mInternal.getTopProcessState());
		mActivityStateUpdater.setTopProcessStateAsync(mInternal.getTopProcessState());
		Slog.d(TAG, "Top Process State changed to PROCESS_STATE_TOP_SLEEPING");
		mTaskSupervisor.goingToSleepLocked();
		updateResumedAppTrace(null /* resumed */);
		@@ -5598,7 +5598,7 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
		} else {
		cancelExpandedShade = false;
		}
		mProcessStateController.setTopProcessAsync(topApp, clearPrevious, cancelExpandedShade);
		mActivityStateUpdater.setTopProcessAsync(topApp, clearPrevious, cancelExpandedShade);
		}

		/**
		@@ -5620,7 +5620,7 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
		final WindowProcessController previousProcess = stoppedActivity.app;
		mPreviousProcess = previousProcess;
		mPreviousProcessVisibleTime = stoppedActivity.lastVisibleTime;
		mProcessStateController.setPreviousProcessAsync(previousProcess);
		mActivityStateUpdater.setPreviousProcessAsync(previousProcess);
		}
		}

		@@ -5705,7 +5705,7 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
		ActivityTaskManagerService::postHeavyWeightProcessNotification, this,
		wpc, root.intent, root.mUserId);
		mH.sendMessage(m);
		mProcessStateController.setHeavyWeightProcessAsync(wpc);
		mActivityStateUpdater.setHeavyWeightProcessAsync(wpc);
		}

		void clearHeavyWeightProcessIfEquals(WindowProcessController proc) {
		@@ -5718,7 +5718,7 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
		ActivityTaskManagerService::cancelHeavyWeightProcessNotification, this,
		proc.mUserId);
		mH.sendMessage(m);
		mProcessStateController.setHeavyWeightProcessAsync(null);
		mActivityStateUpdater.setHeavyWeightProcessAsync(null);
		}

		private void cancelHeavyWeightProcessNotification(int userId) {
		@@ -6314,7 +6314,7 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
		case END_POWER_MODE_UNKNOWN_VISIBILITY_MSG: {
		synchronized (mGlobalLock) {
		mRetainPowerModeAndTopProcessState = false;
		mProcessStateController.setTopProcessStateAsync(
		mActivityStateUpdater.setTopProcessStateAsync(
		mInternal.getTopProcessState());
		endPowerMode(POWER_MODE_REASON_UNKNOWN_VISIBILITY);
		if (mTopApp != null
		@@ -6659,11 +6659,11 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
		synchronized (mGlobalLockWithoutBoost) {
		if (proc == mHomeProcess) {
		mHomeProcess = null;
		mProcessStateController.setHomeProcessAsync(null);
		mActivityStateUpdater.setHomeProcessAsync(null);
		}
		if (proc == mPreviousProcess) {
		mPreviousProcess = null;
		mProcessStateController.setPreviousProcessAsync(null);
		mActivityStateUpdater.setPreviousProcessAsync(null);
		}
		}
		}

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

+1 −1

Original line number	Diff line number	Diff line
		@@ -1121,7 +1121,7 @@ public class ActivityTaskSupervisor implements RecentTasks.Callbacks {
		if (app != null && mService.mHomeProcess != app) {
		scheduleStartHome("homeChanged");
		mService.mHomeProcess = app;
		mService.mProcessStateController.setHomeProcessAsync(app);
		mService.mActivityStateUpdater.setHomeProcessAsync(app);
		}
		}

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

+2 −2

File changed.

Preview size limit exceeded, changes collapsed.