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

Commit ae4dc4b7 authored by Jerry Chang's avatar Jerry Chang
Browse files

Introduce new doze state for docking 

Bug: 140915138, 136070077
Test: atest SystemUITests.java
Change-Id: I03d92c809074fd66b857cd406fc3a200a05e53e9
parent 6f7e2d56

packages/SystemUI/src/com/android/systemui/dock/DockManager.java

+5 −0
Original line number Diff line number Diff line
@@ -53,6 +53,11 @@ public interface DockManager { 
    */

    boolean isDocked();



    /**

     * Returns true if it is hiding docking UI.

     */

    boolean isHidden();



    /** Callback for receiving dock events */

    interface DockEventListener {

        /**

packages/SystemUI/src/com/android/systemui/dock/DockManagerImpl.java

+5 −0
Original line number Diff line number Diff line
@@ -38,4 +38,9 @@ public class DockManagerImpl implements DockManager { 
    public boolean isDocked() {

        return false;

    }



    @Override

    public boolean isHidden() {

        return false;

    }

}

packages/SystemUI/src/com/android/systemui/doze/DozeDockHandler.java

+18 −64
Original line number Diff line number Diff line
@@ -16,9 +16,7 @@ 


package com.android.systemui.doze;



import android.content.Context;

import android.hardware.display.AmbientDisplayConfiguration;

import android.os.Handler;

import android.os.UserHandle;

import android.util.Log;
@@ -35,23 +33,19 @@ public class DozeDockHandler implements DozeMachine.Part { 
    private static final String TAG = "DozeDockHandler";

    private static final boolean DEBUG = DozeService.DEBUG;



    private final DozeMachine mMachine;

    private final DozeHost mDozeHost;

    private final AmbientDisplayConfiguration mConfig;

    private final Handler mHandler;

    private final DockEventListener mDockEventListener = new DockEventListener();

    private final DozeMachine mMachine;

    private final DockManager mDockManager;

    private final DockEventListener mDockEventListener;



    private int mDockState = DockManager.STATE_NONE;

    private boolean mPulsePending;



    public DozeDockHandler(Context context, DozeMachine machine, DozeHost dozeHost,

            AmbientDisplayConfiguration config, Handler handler, DockManager dockManager) {

    public DozeDockHandler(AmbientDisplayConfiguration config, DozeMachine machine,

            DockManager dockManager) {

        mMachine = machine;

        mDozeHost = dozeHost;

        mConfig = config;

        mHandler = handler;

        mDockManager = dockManager;

        mDockEventListener = new DockEventListener();

    }



    @Override
@@ -60,18 +54,6 @@ public class DozeDockHandler implements DozeMachine.Part { 
            case INITIALIZED:

                mDockEventListener.register();

                break;

            case DOZE_AOD:

                if (mDockState == DockManager.STATE_DOCKED_HIDE) {

                    mMachine.requestState(State.DOZE);

                    break;

                }

                // continue below

            case DOZE:

                if (mDockState == DockManager.STATE_DOCKED && !mPulsePending) {

                    mPulsePending = true;

                    mHandler.post(() -> requestPulse(newState));

                }

                break;

            case FINISH:

                mDockEventListener.unregister();

                break;
@@ -80,64 +62,36 @@ public class DozeDockHandler implements DozeMachine.Part { 
        }

    }



    private void requestPulse(State dozeState) {

        if (!mDozeHost.isPulsingBlocked() && dozeState.canPulse()) {

            mMachine.requestPulse(DozeEvent.PULSE_REASON_DOCKING);

        }

        mPulsePending = false;

    }



    private void requestPulseOutNow(State dozeState) {

        if (dozeState == State.DOZE_REQUEST_PULSE || dozeState == State.DOZE_PULSING

                || dozeState == State.DOZE_PULSING_BRIGHT) {

            final int pulseReason = mMachine.getPulseReason();

            if (pulseReason == DozeEvent.PULSE_REASON_DOCKING) {

                mDozeHost.stopPulsing();

            }

        }

    }



    private boolean isDocked() {

        return mDockState == DockManager.STATE_DOCKED

                || mDockState == DockManager.STATE_DOCKED_HIDE;

    }



    @Override

    public void dump(PrintWriter pw) {

        pw.print(" DozeDockTriggers docking="); pw.println(isDocked());

        pw.println("DozeDockHandler:");

        pw.println(" dockState=" + mDockState);

    }



    private class DockEventListener implements DockManager.DockEventListener {

        private boolean mRegistered;



        @Override

        public void onEvent(int event) {

            if (DEBUG) Log.d(TAG, "dock event = " + event);

            final DozeMachine.State dozeState = mMachine.getState();

            mDockState = event;

        public void onEvent(int dockState) {

            if (DEBUG) Log.d(TAG, "dock event = " + dockState);

            final DozeMachine.State nextState;

            mDockState = dockState;

            switch (mDockState) {

                case DockManager.STATE_DOCKED:

                    requestPulse(dozeState);

                    nextState = State.DOZE_AOD_DOCKED;

                    break;

                case DockManager.STATE_NONE:

                    if (dozeState == State.DOZE

                            && mConfig.alwaysOnEnabled(UserHandle.USER_CURRENT)) {

                        mMachine.requestState(State.DOZE_AOD);

                    }

                    else {

                        requestPulseOutNow(dozeState);

                    }

                    nextState = mConfig.alwaysOnEnabled(UserHandle.USER_CURRENT) ? State.DOZE_AOD

                            : State.DOZE;

                    break;

                case DockManager.STATE_DOCKED_HIDE:

                    if (dozeState == State.DOZE_AOD) {

                        mMachine.requestState(State.DOZE);

                    } else {

                        requestPulseOutNow(dozeState);

                    }

                    nextState = State.DOZE;

                    break;

                default:

                    // no-op

                    return;

            }



            mMachine.requestState(nextState);

        }



        void register() {

packages/SystemUI/src/com/android/systemui/doze/DozeFactory.java

+2 −3
Original line number Diff line number Diff line
@@ -102,7 +102,7 @@ public class DozeFactory { 
                wrappedService, mDozeParameters);



        DozeMachine machine = new DozeMachine(wrappedService, config, wakeLock,

                                              mWakefulnessLifecycle, mBatteryController, mDozeLog);

                mWakefulnessLifecycle, mBatteryController, mDozeLog, mDockManager);

        machine.setParts(new DozeMachine.Part[]{

                new DozePauser(mHandler, machine, mAlarmManager, mDozeParameters.getPolicy()),

                new DozeFalsingManagerAdapter(mFalsingManager),
@@ -117,8 +117,7 @@ public class DozeFactory { 
                        mDozeServiceHost, mDozeParameters, mHandler),

                new DozeWallpaperState(mWallpaperManager, mBiometricUnlockController,

                        mDozeParameters),

                new DozeDockHandler(dozeService, machine, mDozeServiceHost, config, mHandler,

                        mDockManager),

                new DozeDockHandler(config, machine, mDockManager),

                new DozeAuthRemover(dozeService)

        });

packages/SystemUI/src/com/android/systemui/doze/DozeMachine.java

+14 −4
Original line number Diff line number Diff line
@@ -24,6 +24,7 @@ import android.util.Log; 
import android.view.Display;



import com.android.internal.util.Preconditions;

import com.android.systemui.dock.DockManager;

import com.android.systemui.keyguard.WakefulnessLifecycle;

import com.android.systemui.keyguard.WakefulnessLifecycle.Wakefulness;

import com.android.systemui.statusbar.phone.DozeParameters;
@@ -72,7 +73,9 @@ public class DozeMachine { 
        /** AOD, but the display is temporarily off. */

        DOZE_AOD_PAUSED,

        /** AOD, prox is near, transitions to DOZE_AOD_PAUSED after a timeout. */

        DOZE_AOD_PAUSING;

        DOZE_AOD_PAUSING,

        /** Always-on doze. Device is awake, showing docking UI and listening for pulse triggers. */

        DOZE_AOD_DOCKED;



        boolean canPulse() {

            switch (this) {
@@ -80,6 +83,7 @@ public class DozeMachine { 
                case DOZE_AOD:

                case DOZE_AOD_PAUSED:

                case DOZE_AOD_PAUSING:

                case DOZE_AOD_DOCKED:

                    return true;

                default:

                    return false;
@@ -91,6 +95,7 @@ public class DozeMachine { 
                case DOZE_REQUEST_PULSE:

                case DOZE_PULSING:

                case DOZE_PULSING_BRIGHT:

                case DOZE_AOD_DOCKED:

                    return true;

                default:

                    return false;
@@ -109,6 +114,7 @@ public class DozeMachine { 
                    return Display.STATE_OFF;

                case DOZE_PULSING:

                case DOZE_PULSING_BRIGHT:

                case DOZE_AOD_DOCKED:

                    return Display.STATE_ON;

                case DOZE_AOD:

                case DOZE_AOD_PAUSING:
@@ -130,16 +136,18 @@ public class DozeMachine { 
    private State mState = State.UNINITIALIZED;

    private int mPulseReason;

    private boolean mWakeLockHeldForCurrentState = false;

    private DockManager mDockManager;



    public DozeMachine(Service service, AmbientDisplayConfiguration config,

            WakeLock wakeLock, WakefulnessLifecycle wakefulnessLifecycle,

            BatteryController batteryController, DozeLog dozeLog) {

    public DozeMachine(Service service, AmbientDisplayConfiguration config, WakeLock wakeLock,

            WakefulnessLifecycle wakefulnessLifecycle, BatteryController batteryController,

            DozeLog dozeLog, DockManager dockManager) {

        mDozeService = service;

        mConfig = config;

        mWakefulnessLifecycle = wakefulnessLifecycle;

        mWakeLock = wakeLock;

        mBatteryController = batteryController;

        mDozeLog = dozeLog;

        mDockManager = dockManager;

    }



    /** Initializes the set of {@link Part}s. Must be called exactly once after construction. */
@@ -352,6 +360,8 @@ public class DozeMachine { 
                if (wakefulness == WakefulnessLifecycle.WAKEFULNESS_AWAKE

                        || wakefulness == WakefulnessLifecycle.WAKEFULNESS_WAKING) {

                    nextState = State.FINISH;

                } else if (mDockManager.isDocked()) {

                    nextState = mDockManager.isHidden() ? State.DOZE : State.DOZE_AOD_DOCKED;

                } else if (mConfig.alwaysOnEnabled(UserHandle.USER_CURRENT)) {

                    nextState = State.DOZE_AOD;

                } else {