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

Commit eabb9a88 authored by Sunny Goyal's avatar Sunny Goyal
Browse files

Moving task stack change listener management out of ActivityManagerWrapper 

Will eventually remove static initialization and thread restrictions
in ActivityManagerWrapper

Bug: 170648272
Test: Verified apk locally
Change-Id: I9abffc622c7a31df007970235e265554a9039b1f
parent 526abec2

packages/SystemUI/shared/src/com/android/systemui/shared/system/ActivityManagerWrapper.java

+4 −13
Original line number Diff line number Diff line
@@ -46,7 +46,6 @@ import android.graphics.Rect; 
import android.os.Bundle;

import android.os.Handler;

import android.os.IBinder;

import android.os.Looper;

import android.os.RemoteException;

import android.os.ServiceManager;

import android.os.SystemClock;
@@ -82,13 +81,11 @@ public class ActivityManagerWrapper { 


    private final PackageManager mPackageManager;

    private final BackgroundExecutor mBackgroundExecutor;

    private final TaskStackChangeListeners mTaskStackChangeListeners;



    private ActivityManagerWrapper() {

        final Context context = AppGlobals.getInitialApplication();

        mPackageManager = context.getPackageManager();

        mBackgroundExecutor = BackgroundExecutor.get();

        mTaskStackChangeListeners = new TaskStackChangeListeners(Looper.getMainLooper());

    }



    public static ActivityManagerWrapper getInstance() {
@@ -360,23 +357,17 @@ public class ActivityManagerWrapper { 
    }



    /**

     * Registers a task stack listener with the system.

     * This should be called on the main thread.

     * @deprecated use {@link TaskStackChangeListeners#registerTaskStackListener}

     */

    public void registerTaskStackListener(TaskStackChangeListener listener) {

        synchronized (mTaskStackChangeListeners) {

            mTaskStackChangeListeners.addListener(ActivityManager.getService(), listener);

        }

        TaskStackChangeListeners.getInstance().registerTaskStackListener(listener);

    }



    /**

     * Unregisters a task stack listener with the system.

     * This should be called on the main thread.

     * @deprecated use {@link TaskStackChangeListeners#unregisterTaskStackListener}

     */

    public void unregisterTaskStackListener(TaskStackChangeListener listener) {

        synchronized (mTaskStackChangeListeners) {

            mTaskStackChangeListeners.removeListener(listener);

        }

        TaskStackChangeListeners.getInstance().unregisterTaskStackListener(listener);

    }



    /**

packages/SystemUI/shared/src/com/android/systemui/shared/system/TaskStackChangeListeners.java

+222 −198
Original line number Diff line number Diff line
@@ -19,14 +19,12 @@ package com.android.systemui.shared.system; 
import android.app.ActivityManager.RunningTaskInfo;

import android.app.ActivityManager.TaskSnapshot;

import android.app.ActivityTaskManager;

import android.app.IActivityManager;

import android.app.TaskStackListener;

import android.content.ComponentName;

import android.os.Handler;

import android.os.IBinder;

import android.os.Looper;

import android.os.Message;

import android.os.RemoteException;

import android.os.Trace;

import android.util.Log;
@@ -42,6 +40,63 @@ import java.util.List; 
public class TaskStackChangeListeners extends TaskStackListener {



    private static final String TAG = TaskStackChangeListeners.class.getSimpleName();

    private static final TaskStackChangeListeners INSTANCE = new TaskStackChangeListeners();



    private final Impl mImpl;



    private TaskStackChangeListeners() {

        mImpl = new Impl(Looper.getMainLooper());

    }



    public static TaskStackChangeListeners getInstance() {

        return INSTANCE;

    }



    /**

     * Registers a task stack listener with the system.

     * This should be called on the main thread.

     */

    public void registerTaskStackListener(TaskStackChangeListener listener) {

        synchronized (mImpl) {

            mImpl.addListener(listener);

        }

    }



    /**

     * Unregisters a task stack listener with the system.

     * This should be called on the main thread.

     */

    public void unregisterTaskStackListener(TaskStackChangeListener listener) {

        synchronized (mImpl) {

            mImpl.removeListener(listener);

        }

    }



    private static class Impl extends TaskStackListener implements Handler.Callback {



        private static final int ON_TASK_STACK_CHANGED = 1;

        private static final int ON_TASK_SNAPSHOT_CHANGED = 2;

        private static final int ON_ACTIVITY_PINNED = 3;

        private static final int ON_ACTIVITY_RESTART_ATTEMPT = 4;

        private static final int ON_ACTIVITY_FORCED_RESIZABLE = 6;

        private static final int ON_ACTIVITY_DISMISSING_DOCKED_STACK = 7;

        private static final int ON_TASK_PROFILE_LOCKED = 8;

        private static final int ON_ACTIVITY_UNPINNED = 10;

        private static final int ON_ACTIVITY_LAUNCH_ON_SECONDARY_DISPLAY_FAILED = 11;

        private static final int ON_TASK_CREATED = 12;

        private static final int ON_TASK_REMOVED = 13;

        private static final int ON_TASK_MOVED_TO_FRONT = 14;

        private static final int ON_ACTIVITY_REQUESTED_ORIENTATION_CHANGE = 15;

        private static final int ON_ACTIVITY_LAUNCH_ON_SECONDARY_DISPLAY_REROUTED = 16;

        private static final int ON_SIZE_COMPAT_MODE_ACTIVITY_CHANGED = 17;

        private static final int ON_BACK_PRESSED_ON_TASK_ROOT = 18;

        private static final int ON_SINGLE_TASK_DISPLAY_DRAWN = 19;

        private static final int ON_TASK_DISPLAY_CHANGED = 20;

        private static final int ON_TASK_LIST_UPDATED = 21;

        private static final int ON_SINGLE_TASK_DISPLAY_EMPTY = 22;

        private static final int ON_TASK_LIST_FROZEN_UNFROZEN = 23;

        private static final int ON_TASK_DESCRIPTION_CHANGED = 24;

        private static final int ON_ACTIVITY_ROTATION = 25;



        /**

         * List of {@link TaskStackChangeListener} registered from {@link #addListener}.
@@ -52,11 +107,11 @@ public class TaskStackChangeListeners extends TaskStackListener { 
        private final Handler mHandler;

        private boolean mRegistered;



    public TaskStackChangeListeners(Looper looper) {

        mHandler = new H(looper);

        Impl(Looper looper) {

            mHandler = new Handler(looper, this);

        }



    public void addListener(IActivityManager am, TaskStackChangeListener listener) {

        public void addListener(TaskStackChangeListener listener) {

            synchronized (mTaskStackListeners) {

                mTaskStackListeners.add(listener);

            }
@@ -89,9 +144,9 @@ public class TaskStackChangeListeners extends TaskStackListener { 
        }



        @Override

    public void onTaskStackChanged() throws RemoteException {

        // Call the task changed callback for the non-ui thread listeners first. Copy to a set of

        // temp listeners so that we don't lock on mTaskStackListeners while calling all the

        public void onTaskStackChanged() {

            // Call the task changed callback for the non-ui thread listeners first. Copy to a set

            // of temp listeners so that we don't lock on mTaskStackListeners while calling all the

            // callbacks. This call is always on the same binder thread, so we can just synchronize

            // on the copying of the listener list.

            synchronized (mTaskStackListeners) {
@@ -102,179 +157,146 @@ public class TaskStackChangeListeners extends TaskStackListener { 
            }

            mTmpListeners.clear();



        mHandler.removeMessages(H.ON_TASK_STACK_CHANGED);

        mHandler.sendEmptyMessage(H.ON_TASK_STACK_CHANGED);

            mHandler.removeMessages(ON_TASK_STACK_CHANGED);

            mHandler.sendEmptyMessage(ON_TASK_STACK_CHANGED);

        }



        @Override

    public void onActivityPinned(String packageName, int userId, int taskId, int stackId)

            throws RemoteException {

        mHandler.removeMessages(H.ON_ACTIVITY_PINNED);

        mHandler.obtainMessage(H.ON_ACTIVITY_PINNED,

        public void onActivityPinned(String packageName, int userId, int taskId, int stackId) {

            mHandler.removeMessages(ON_ACTIVITY_PINNED);

            mHandler.obtainMessage(ON_ACTIVITY_PINNED,

                    new PinnedActivityInfo(packageName, userId, taskId, stackId)).sendToTarget();

        }



        @Override

    public void onActivityUnpinned() throws RemoteException {

        mHandler.removeMessages(H.ON_ACTIVITY_UNPINNED);

        mHandler.sendEmptyMessage(H.ON_ACTIVITY_UNPINNED);

        public void onActivityUnpinned() {

            mHandler.removeMessages(ON_ACTIVITY_UNPINNED);

            mHandler.sendEmptyMessage(ON_ACTIVITY_UNPINNED);

        }



        @Override

        public void onActivityRestartAttempt(RunningTaskInfo task, boolean homeTaskVisible,

            boolean clearedTask, boolean wasVisible) throws RemoteException {

                boolean clearedTask, boolean wasVisible) {

            final SomeArgs args = SomeArgs.obtain();

            args.arg1 = task;

            args.argi1 = homeTaskVisible ? 1 : 0;

            args.argi2 = clearedTask ? 1 : 0;

            args.argi3 = wasVisible ? 1 : 0;

        mHandler.removeMessages(H.ON_ACTIVITY_RESTART_ATTEMPT);

        mHandler.obtainMessage(H.ON_ACTIVITY_RESTART_ATTEMPT, args).sendToTarget();

            mHandler.removeMessages(ON_ACTIVITY_RESTART_ATTEMPT);

            mHandler.obtainMessage(ON_ACTIVITY_RESTART_ATTEMPT, args).sendToTarget();

        }



        @Override

    public void onActivityForcedResizable(String packageName, int taskId, int reason)

            throws RemoteException {

        mHandler.obtainMessage(H.ON_ACTIVITY_FORCED_RESIZABLE, taskId, reason, packageName)

        public void onActivityForcedResizable(String packageName, int taskId, int reason) {

            mHandler.obtainMessage(ON_ACTIVITY_FORCED_RESIZABLE, taskId, reason, packageName)

                    .sendToTarget();

        }



        @Override

    public void onActivityDismissingDockedStack() throws RemoteException {

        mHandler.sendEmptyMessage(H.ON_ACTIVITY_DISMISSING_DOCKED_STACK);

        public void onActivityDismissingDockedStack() {

            mHandler.sendEmptyMessage(ON_ACTIVITY_DISMISSING_DOCKED_STACK);

        }



        @Override

        public void onActivityLaunchOnSecondaryDisplayFailed(RunningTaskInfo taskInfo,

            int requestedDisplayId) throws RemoteException {

        mHandler.obtainMessage(H.ON_ACTIVITY_LAUNCH_ON_SECONDARY_DISPLAY_FAILED, requestedDisplayId,

                int requestedDisplayId) {

            mHandler.obtainMessage(ON_ACTIVITY_LAUNCH_ON_SECONDARY_DISPLAY_FAILED,

                    requestedDisplayId,

                    0 /* unused */,

                    taskInfo).sendToTarget();

        }



        @Override

        public void onActivityLaunchOnSecondaryDisplayRerouted(RunningTaskInfo taskInfo,

            int requestedDisplayId) throws RemoteException {

        mHandler.obtainMessage(H.ON_ACTIVITY_LAUNCH_ON_SECONDARY_DISPLAY_REROUTED,

                int requestedDisplayId) {

            mHandler.obtainMessage(ON_ACTIVITY_LAUNCH_ON_SECONDARY_DISPLAY_REROUTED,

                    requestedDisplayId, 0 /* unused */, taskInfo).sendToTarget();

        }



        @Override

    public void onTaskProfileLocked(int taskId, int userId) throws RemoteException {

        mHandler.obtainMessage(H.ON_TASK_PROFILE_LOCKED, taskId, userId).sendToTarget();

        public void onTaskProfileLocked(int taskId, int userId) {

            mHandler.obtainMessage(ON_TASK_PROFILE_LOCKED, taskId, userId).sendToTarget();

        }



        @Override

    public void onTaskSnapshotChanged(int taskId, TaskSnapshot snapshot) throws RemoteException {

        mHandler.obtainMessage(H.ON_TASK_SNAPSHOT_CHANGED, taskId, 0, snapshot).sendToTarget();

        public void onTaskSnapshotChanged(int taskId, TaskSnapshot snapshot) {

            mHandler.obtainMessage(ON_TASK_SNAPSHOT_CHANGED, taskId, 0, snapshot).sendToTarget();

        }



        @Override

    public void onTaskCreated(int taskId, ComponentName componentName) throws RemoteException {

        mHandler.obtainMessage(H.ON_TASK_CREATED, taskId, 0, componentName).sendToTarget();

        public void onTaskCreated(int taskId, ComponentName componentName) {

            mHandler.obtainMessage(ON_TASK_CREATED, taskId, 0, componentName).sendToTarget();

        }



        @Override

    public void onTaskRemoved(int taskId) throws RemoteException {

        mHandler.obtainMessage(H.ON_TASK_REMOVED, taskId, 0).sendToTarget();

        public void onTaskRemoved(int taskId) {

            mHandler.obtainMessage(ON_TASK_REMOVED, taskId, 0).sendToTarget();

        }



        @Override

    public void onTaskMovedToFront(RunningTaskInfo taskInfo)

            throws RemoteException {

        mHandler.obtainMessage(H.ON_TASK_MOVED_TO_FRONT, taskInfo).sendToTarget();

        public void onTaskMovedToFront(RunningTaskInfo taskInfo) {

            mHandler.obtainMessage(ON_TASK_MOVED_TO_FRONT, taskInfo).sendToTarget();

        }



        @Override

    public void onBackPressedOnTaskRoot(RunningTaskInfo taskInfo) throws RemoteException {

        mHandler.obtainMessage(H.ON_BACK_PRESSED_ON_TASK_ROOT, taskInfo).sendToTarget();

        public void onBackPressedOnTaskRoot(RunningTaskInfo taskInfo) {

            mHandler.obtainMessage(ON_BACK_PRESSED_ON_TASK_ROOT, taskInfo).sendToTarget();

        }



        @Override

    public void onActivityRequestedOrientationChanged(int taskId, int requestedOrientation)

            throws RemoteException {

        mHandler.obtainMessage(H.ON_ACTIVITY_REQUESTED_ORIENTATION_CHANGE, taskId,

        public void onActivityRequestedOrientationChanged(int taskId, int requestedOrientation) {

            mHandler.obtainMessage(ON_ACTIVITY_REQUESTED_ORIENTATION_CHANGE, taskId,

                    requestedOrientation).sendToTarget();

        }



        @Override

    public void onSizeCompatModeActivityChanged(int displayId, IBinder activityToken)

            throws RemoteException {

        mHandler.obtainMessage(H.ON_SIZE_COMPAT_MODE_ACTIVITY_CHANGED, displayId, 0 /* unused */,

        public void onSizeCompatModeActivityChanged(int displayId, IBinder activityToken) {

            mHandler.obtainMessage(ON_SIZE_COMPAT_MODE_ACTIVITY_CHANGED, displayId,

                    0 /* unused */,

                    activityToken).sendToTarget();

        }



        @Override

    public void onSingleTaskDisplayDrawn(int displayId) throws RemoteException {

        mHandler.obtainMessage(H.ON_SINGLE_TASK_DISPLAY_DRAWN, displayId,

        public void onSingleTaskDisplayDrawn(int displayId) {

            mHandler.obtainMessage(ON_SINGLE_TASK_DISPLAY_DRAWN, displayId,

                    0 /* unused */).sendToTarget();

        }



        @Override

    public void onSingleTaskDisplayEmpty(int displayId) throws RemoteException {

        mHandler.obtainMessage(H.ON_SINGLE_TASK_DISPLAY_EMPTY, displayId,

        public void onSingleTaskDisplayEmpty(int displayId) {

            mHandler.obtainMessage(ON_SINGLE_TASK_DISPLAY_EMPTY, displayId,

                    0 /* unused */).sendToTarget();

        }



        @Override

    public void onTaskDisplayChanged(int taskId, int newDisplayId) throws RemoteException {

        mHandler.obtainMessage(H.ON_TASK_DISPLAY_CHANGED, taskId, newDisplayId).sendToTarget();

        public void onTaskDisplayChanged(int taskId, int newDisplayId) {

            mHandler.obtainMessage(ON_TASK_DISPLAY_CHANGED, taskId, newDisplayId).sendToTarget();

        }



        @Override

    public void onRecentTaskListUpdated() throws RemoteException {

        mHandler.obtainMessage(H.ON_TASK_LIST_UPDATED).sendToTarget();

        public void onRecentTaskListUpdated() {

            mHandler.obtainMessage(ON_TASK_LIST_UPDATED).sendToTarget();

        }



        @Override

        public void onRecentTaskListFrozenChanged(boolean frozen) {

        mHandler.obtainMessage(H.ON_TASK_LIST_FROZEN_UNFROZEN, frozen ? 1 : 0, 0 /* unused */)

            mHandler.obtainMessage(ON_TASK_LIST_FROZEN_UNFROZEN, frozen ? 1 : 0, 0 /* unused */)

                    .sendToTarget();

        }



        @Override

        public void onTaskDescriptionChanged(RunningTaskInfo taskInfo) {

        mHandler.obtainMessage(H.ON_TASK_DESCRIPTION_CHANGED, taskInfo).sendToTarget();

            mHandler.obtainMessage(ON_TASK_DESCRIPTION_CHANGED, taskInfo).sendToTarget();

        }



        @Override

        public void onActivityRotation(int displayId) {

        mHandler.obtainMessage(H.ON_ACTIVITY_ROTATION, displayId, 0 /* unused */)

            mHandler.obtainMessage(ON_ACTIVITY_ROTATION, displayId, 0 /* unused */)

                    .sendToTarget();

        }



    private final class H extends Handler {

        private static final int ON_TASK_STACK_CHANGED = 1;

        private static final int ON_TASK_SNAPSHOT_CHANGED = 2;

        private static final int ON_ACTIVITY_PINNED = 3;

        private static final int ON_ACTIVITY_RESTART_ATTEMPT = 4;

        private static final int ON_ACTIVITY_FORCED_RESIZABLE = 6;

        private static final int ON_ACTIVITY_DISMISSING_DOCKED_STACK = 7;

        private static final int ON_TASK_PROFILE_LOCKED = 8;

        private static final int ON_ACTIVITY_UNPINNED = 10;

        private static final int ON_ACTIVITY_LAUNCH_ON_SECONDARY_DISPLAY_FAILED = 11;

        private static final int ON_TASK_CREATED = 12;

        private static final int ON_TASK_REMOVED = 13;

        private static final int ON_TASK_MOVED_TO_FRONT = 14;

        private static final int ON_ACTIVITY_REQUESTED_ORIENTATION_CHANGE = 15;

        private static final int ON_ACTIVITY_LAUNCH_ON_SECONDARY_DISPLAY_REROUTED = 16;

        private static final int ON_SIZE_COMPAT_MODE_ACTIVITY_CHANGED = 17;

        private static final int ON_BACK_PRESSED_ON_TASK_ROOT = 18;

        private static final int ON_SINGLE_TASK_DISPLAY_DRAWN = 19;

        private static final int ON_TASK_DISPLAY_CHANGED = 20;

        private static final int ON_TASK_LIST_UPDATED = 21;

        private static final int ON_SINGLE_TASK_DISPLAY_EMPTY = 22;

        private static final int ON_TASK_LIST_FROZEN_UNFROZEN = 23;

        private static final int ON_TASK_DESCRIPTION_CHANGED = 24;

        private static final int ON_ACTIVITY_ROTATION = 25;





        public H(Looper looper) {

            super(looper);

        }



        @Override

        public void handleMessage(Message msg) {

        public boolean handleMessage(Message msg) {

            synchronized (mTaskStackListeners) {

                switch (msg.what) {

                    case ON_TASK_STACK_CHANGED: {
@@ -298,7 +320,8 @@ public class TaskStackChangeListeners extends TaskStackListener { 
                        final PinnedActivityInfo info = (PinnedActivityInfo) msg.obj;

                        for (int i = mTaskStackListeners.size() - 1; i >= 0; i--) {

                            mTaskStackListeners.get(i).onActivityPinned(

                                    info.mPackageName, info.mUserId, info.mTaskId, info.mStackId);

                                    info.mPackageName, info.mUserId, info.mTaskId,

                                    info.mStackId);

                        }

                        break;

                    }
@@ -404,8 +427,7 @@ public class TaskStackChangeListeners extends TaskStackListener { 
                    }

                    case ON_SINGLE_TASK_DISPLAY_EMPTY: {

                        for (int i = mTaskStackListeners.size() - 1; i >= 0; i--) {

                            mTaskStackListeners.get(i).onSingleTaskDisplayEmpty(

                                    msg.arg1);

                            mTaskStackListeners.get(i).onSingleTaskDisplayEmpty(msg.arg1);

                        }

                        break;

                    }
@@ -423,7 +445,8 @@ public class TaskStackChangeListeners extends TaskStackListener { 
                    }

                    case ON_TASK_LIST_FROZEN_UNFROZEN: {

                        for (int i = mTaskStackListeners.size() - 1; i >= 0; i--) {

                            mTaskStackListeners.get(i).onRecentTaskListFrozenChanged(msg.arg1 != 0);

                            mTaskStackListeners.get(i).onRecentTaskListFrozenChanged(

                                    msg.arg1 != 0);

                        }

                        break;

                    }
@@ -445,6 +468,7 @@ public class TaskStackChangeListeners extends TaskStackListener { 
            if (msg.obj instanceof SomeArgs) {

                ((SomeArgs) msg.obj).recycle();

            }

            return true;

        }

    }

packages/SystemUI/src/com/android/keyguard/KeyguardUpdateMonitor.java

+3 −3
Original line number Diff line number Diff line
@@ -100,8 +100,8 @@ import com.android.systemui.dagger.qualifiers.Background; 
import com.android.systemui.dagger.qualifiers.Main;

import com.android.systemui.dump.DumpManager;

import com.android.systemui.plugins.statusbar.StatusBarStateController;

import com.android.systemui.shared.system.ActivityManagerWrapper;

import com.android.systemui.shared.system.TaskStackChangeListener;

import com.android.systemui.shared.system.TaskStackChangeListeners;

import com.android.systemui.statusbar.StatusBarState;

import com.android.systemui.statusbar.phone.KeyguardBypassController;

import com.android.systemui.util.Assert;
@@ -1796,7 +1796,7 @@ public class KeyguardUpdateMonitor implements TrustManager.TrustListener, Dumpab 


        mIsAutomotive = isAutomotive();



        ActivityManagerWrapper.getInstance().registerTaskStackListener(mTaskStackListener);

        TaskStackChangeListeners.getInstance().registerTaskStackListener(mTaskStackListener);

        mUserManager = context.getSystemService(UserManager.class);

        mIsPrimaryUser = mUserManager.isPrimaryUser();

        int user = ActivityManager.getCurrentUser();
@@ -2965,7 +2965,7 @@ public class KeyguardUpdateMonitor implements TrustManager.TrustListener, Dumpab 
            Log.d(TAG, "RemoteException onDestroy. cannot unregister userSwitchObserver");

        }



        ActivityManagerWrapper.getInstance().unregisterTaskStackListener(mTaskStackListener);

        TaskStackChangeListeners.getInstance().unregisterTaskStackListener(mTaskStackListener);



        mBroadcastDispatcher.unregisterReceiver(mBroadcastReceiver);

        mBroadcastDispatcher.unregisterReceiver(mBroadcastAllReceiver);

packages/SystemUI/src/com/android/systemui/SizeCompatModeActivityController.java

+3 −3
Original line number Diff line number Diff line
@@ -42,8 +42,8 @@ import android.widget.PopupWindow; 


import com.android.internal.annotations.VisibleForTesting;

import com.android.systemui.dagger.SysUISingleton;

import com.android.systemui.shared.system.ActivityManagerWrapper;

import com.android.systemui.shared.system.TaskStackChangeListener;

import com.android.systemui.shared.system.TaskStackChangeListeners;

import com.android.systemui.statusbar.CommandQueue;



import java.lang.ref.WeakReference;
@@ -66,11 +66,11 @@ public class SizeCompatModeActivityController extends SystemUI implements Comman 


    @VisibleForTesting

    @Inject

    SizeCompatModeActivityController(Context context, ActivityManagerWrapper am,

    SizeCompatModeActivityController(Context context, TaskStackChangeListeners listeners,

            CommandQueue commandQueue) {

        super(context);

        mCommandQueue = commandQueue;

        am.registerTaskStackListener(new TaskStackChangeListener() {

        listeners.registerTaskStackListener(new TaskStackChangeListener() {

            @Override

            public void onSizeCompatModeActivityChanged(int displayId, IBinder activityToken) {

                // Note the callback already runs on main thread.

packages/SystemUI/src/com/android/systemui/assist/AssistHandleReminderExpBehavior.java

+6 −2
Original line number Diff line number Diff line
@@ -47,6 +47,7 @@ import com.android.systemui.shared.system.ActivityManagerWrapper; 
import com.android.systemui.shared.system.PackageManagerWrapper;

import com.android.systemui.shared.system.QuickStepContract;

import com.android.systemui.shared.system.TaskStackChangeListener;

import com.android.systemui.shared.system.TaskStackChangeListeners;

import com.android.systemui.statusbar.StatusBarState;



import java.io.PrintWriter;
@@ -171,6 +172,7 @@ final class AssistHandleReminderExpBehavior implements BehaviorController { 
    private final DeviceConfigHelper mDeviceConfigHelper;

    private final Lazy<StatusBarStateController> mStatusBarStateController;

    private final Lazy<ActivityManagerWrapper> mActivityManagerWrapper;

    private final Lazy<TaskStackChangeListeners> mTaskStackChangeListeners;

    private final Lazy<OverviewProxyService> mOverviewProxyService;

    private final Lazy<SysUiState> mSysUiFlagContainer;

    private final Lazy<WakefulnessLifecycle> mWakefulnessLifecycle;
@@ -207,6 +209,7 @@ final class AssistHandleReminderExpBehavior implements BehaviorController { 
            DeviceConfigHelper deviceConfigHelper,

            Lazy<StatusBarStateController> statusBarStateController,

            Lazy<ActivityManagerWrapper> activityManagerWrapper,

            Lazy<TaskStackChangeListeners> taskStackChangeListeners,

            Lazy<OverviewProxyService> overviewProxyService,

            Lazy<SysUiState> sysUiFlagContainer,

            Lazy<WakefulnessLifecycle> wakefulnessLifecycle,
@@ -218,6 +221,7 @@ final class AssistHandleReminderExpBehavior implements BehaviorController { 
        mDeviceConfigHelper = deviceConfigHelper;

        mStatusBarStateController = statusBarStateController;

        mActivityManagerWrapper = activityManagerWrapper;

        mTaskStackChangeListeners = taskStackChangeListeners;

        mOverviewProxyService = overviewProxyService;

        mSysUiFlagContainer = sysUiFlagContainer;

        mWakefulnessLifecycle = wakefulnessLifecycle;
@@ -245,7 +249,7 @@ final class AssistHandleReminderExpBehavior implements BehaviorController { 
        ActivityManager.RunningTaskInfo runningTaskInfo =

                mActivityManagerWrapper.get().getRunningTask();

        mRunningTaskId = runningTaskInfo == null ? 0 : runningTaskInfo.taskId;

        mActivityManagerWrapper.get().registerTaskStackListener(mTaskStackChangeListener);

        mTaskStackChangeListeners.get().registerTaskStackListener(mTaskStackChangeListener);

        mOverviewProxyService.get().addCallback(mOverviewProxyListener);

        mSysUiFlagContainer.get().addCallback(mSysUiStateCallback);

        mIsAwake = mWakefulnessLifecycle.get().getWakefulness()
@@ -300,7 +304,7 @@ final class AssistHandleReminderExpBehavior implements BehaviorController { 
            mContext = null;

        }

        mStatusBarStateController.get().removeCallback(mStatusBarStateListener);

        mActivityManagerWrapper.get().unregisterTaskStackListener(mTaskStackChangeListener);

        mTaskStackChangeListeners.get().unregisterTaskStackListener(mTaskStackChangeListener);

        mOverviewProxyService.get().removeCallback(mOverviewProxyListener);

        mSysUiFlagContainer.get().removeCallback(mSysUiStateCallback);

        mWakefulnessLifecycle.get().removeObserver(mWakefulnessLifecycleObserver);