Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit b5988ce2 authored by Michael Wachenschwanz's avatar Michael Wachenschwanz
Browse files

Move PSC async Activity update methods to a helper class 

The new ActivityStateAsyncUpdater is purpose built for Window Manager to
update ProcessStateController about Activity state changes that can
affect importance computations.

Flag: com.android.server.am.push_activity_state_to_oomadjuster
Bug: 401350380
Test: atest MockingOomAdjusterTests
Change-Id: Iaa1faac9e82f67e23a7448c428a4c67ff2d9b98e
parent f3299957

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.