Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Introduce new doze state for docking

Browse Source 
Bug: 140915138, 136070077
Test: atest SystemUITests.java
Change-Id: I03d92c809074fd66b857cd406fc3a200a05e53e9
This commit is contained in:
Jerry Chang
2019-10-16 18:45:03 +08:00
parent 6f7e2d5674
commit ae4dc4b798
16 changed files with 177 additions and 208 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
packages/SystemUI/src/com/android/systemui/dock/DockManager.java
View File

@@ -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 {
/**

5
packages/SystemUI/src/com/android/systemui/dock/DockManagerImpl.java
View File

@@ -38,4 +38,9 @@ public class DockManagerImpl implements DockManager {
public boolean isDocked() {
return false;
}
@Override
public boolean isHidden() {
return false;
}
}

82
packages/SystemUI/src/com/android/systemui/doze/DozeDockHandler.java
View File

@@ -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() {

5
packages/SystemUI/src/com/android/systemui/doze/DozeFactory.java
View File

@@ -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)
});

18
packages/SystemUI/src/com/android/systemui/doze/DozeMachine.java
View File

@@ -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 {

1
packages/SystemUI/src/com/android/systemui/doze/DozeScreenBrightness.java
View File

@@ -113,6 +113,7 @@ public class DozeScreenBrightness extends BroadcastReceiver implements DozeMachi
break;
case DOZE_AOD:
case DOZE_REQUEST_PULSE:
case DOZE_AOD_DOCKED:
setLightSensorEnabled(true);
break;
case DOZE:

13
packages/SystemUI/src/com/android/systemui/doze/DozeScreenState.java
View File

@@ -18,6 +18,7 @@ package com.android.systemui.doze;
import static com.android.systemui.doze.DozeMachine.State.DOZE;
import static com.android.systemui.doze.DozeMachine.State.DOZE_AOD;
import static com.android.systemui.doze.DozeMachine.State.DOZE_AOD_DOCKED;
import static com.android.systemui.doze.DozeMachine.State.DOZE_AOD_PAUSED;
import static com.android.systemui.doze.DozeMachine.State.DOZE_AOD_PAUSING;
import static com.android.systemui.doze.DozeMachine.State.DOZE_PULSE_DONE;
@@ -89,10 +90,10 @@ public class DozeScreenState implements DozeMachine.Part {
}
final boolean messagePending = mHandler.hasCallbacks(mApplyPendingScreenState);
final boolean pulseEnding = oldState == DOZE_PULSE_DONE && newState == DOZE_AOD;
final boolean turningOn = (oldState == DOZE_AOD_PAUSED
|| oldState == DOZE) && newState == DOZE_AOD;
final boolean turningOff = (oldState == DOZE_AOD && newState == DOZE)
final boolean pulseEnding = oldState == DOZE_PULSE_DONE && isAlwaysOnState(newState);
final boolean turningOn = (oldState == DOZE_AOD_PAUSED || oldState == DOZE)
&& isAlwaysOnState(newState);
final boolean turningOff = (isAlwaysOnState(oldState) && newState == DOZE)
|| (oldState == DOZE_AOD_PAUSING && newState == DOZE_AOD_PAUSED);
final boolean justInitialized = oldState == DozeMachine.State.INITIALIZED;
if (messagePending || justInitialized || pulseEnding || turningOn) {
@@ -131,6 +132,10 @@ public class DozeScreenState implements DozeMachine.Part {
}
}
private boolean isAlwaysOnState(DozeMachine.State state) {
return state == DOZE_AOD || state == DOZE_AOD_DOCKED;
}
private void applyPendingScreenState() {
applyScreenState(mPendingScreenState);
mPendingScreenState = Display.STATE_UNKNOWN;

12
packages/SystemUI/src/com/android/systemui/doze/DozeTriggers.java
View File

@@ -304,9 +304,7 @@ public class DozeTriggers implements DozeMachine.Part {
case INITIALIZED:
mBroadcastReceiver.register(mBroadcastDispatcher);
mDozeHost.addCallback(mHostCallback);
if (mDockManager != null) {
mDockManager.addListener(mDockEventListener);
}
mDockManager.addListener(mDockEventListener);
mDozeSensors.requestTemporaryDisable();
checkTriggersAtInit();
break;
@@ -326,6 +324,7 @@ public class DozeTriggers implements DozeMachine.Part {
break;
case DOZE_PULSING:
case DOZE_PULSING_BRIGHT:
case DOZE_AOD_DOCKED:
mDozeSensors.setTouchscreenSensorsListening(false);
mDozeSensors.setProxListening(true);
mDozeSensors.setPaused(false);
@@ -339,9 +338,7 @@ public class DozeTriggers implements DozeMachine.Part {
case FINISH:
mBroadcastReceiver.unregister(mBroadcastDispatcher);
mDozeHost.removeCallback(mHostCallback);
if (mDockManager != null) {
mDockManager.removeListener(mDockEventListener);
}
mDockManager.removeListener(mDockEventListener);
mDozeSensors.setListening(false);
mDozeSensors.setProxListening(false);
break;
@@ -399,7 +396,8 @@ public class DozeTriggers implements DozeMachine.Part {
private boolean canPulse() {
return mMachine.getState() == DozeMachine.State.DOZE
|| mMachine.getState() == DozeMachine.State.DOZE_AOD;
|| mMachine.getState() == DozeMachine.State.DOZE_AOD
|| mMachine.getState() == DozeMachine.State.DOZE_AOD_DOCKED;
}
private void continuePulseRequest(int reason) {

1
packages/SystemUI/src/com/android/systemui/doze/DozeUi.java
View File

@@ -121,6 +121,7 @@ public class DozeUi implements DozeMachine.Part {
public void transitionTo(DozeMachine.State oldState, DozeMachine.State newState) {
switch (newState) {
case DOZE_AOD:
case DOZE_AOD_DOCKED:
if (oldState == DOZE_AOD_PAUSED || oldState == DOZE) {
// Whenever turning on the display, it's necessary to push a new frame.
// The display buffers will be empty and need to be filled.

1
packages/SystemUI/src/com/android/systemui/doze/DozeWallpaperState.java
View File

@@ -54,6 +54,7 @@ public class DozeWallpaperState implements DozeMachine.Part {
switch (newState) {
case DOZE:
case DOZE_AOD:
case DOZE_AOD_DOCKED:
case DOZE_AOD_PAUSING:
case DOZE_AOD_PAUSED:
case DOZE_REQUEST_PULSE:

5
packages/SystemUI/tests/src/com/android/systemui/dock/DockManagerFake.java
View File

@@ -37,6 +37,11 @@ public class DockManagerFake implements DockManager {
return false;
}
@Override
public boolean isHidden() {
return false;
}
public void setDockEvent(int event) {
mCallback.onEvent(event);
}

138
packages/SystemUI/tests/src/com/android/systemui/doze/DozeDockHandlerTest.java
View File

@@ -20,16 +20,11 @@ import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import android.hardware.display.AmbientDisplayConfiguration;
import android.os.Handler;
import android.os.Looper;
import android.testing.AndroidTestingRunner;
import android.testing.TestableLooper;
import android.testing.TestableLooper.RunWithLooper;
import androidx.test.filters.SmallTest;
@@ -49,10 +44,7 @@ import org.mockito.MockitoAnnotations;
@RunWith(AndroidTestingRunner.class)
@RunWithLooper
public class DozeDockHandlerTest extends SysuiTestCase {
@Mock
private DozeMachine mMachine;
@Mock
private DozeHost mHost;
@Mock private DozeMachine mMachine;
private AmbientDisplayConfiguration mConfig;
private DockManagerFake mDockManagerFake;
private DozeDockHandler mDockHandler;
@@ -61,146 +53,52 @@ public class DozeDockHandlerTest extends SysuiTestCase {
public void setUp() throws Exception {
MockitoAnnotations.initMocks(this);
mConfig = DozeConfigurationUtil.createMockConfig();
doReturn(false).when(mConfig).alwaysOnEnabled(anyInt());
mDockManagerFake = spy(new DockManagerFake());
mDockHandler = new DozeDockHandler(mContext, mMachine, mHost, mConfig,
Handler.createAsync(Looper.myLooper()), mDockManagerFake);
mDockHandler = new DozeDockHandler(mConfig, mMachine, mDockManagerFake);
doReturn(true).when(mConfig).alwaysOnEnabled(anyInt());
mDockHandler.transitionTo(DozeMachine.State.UNINITIALIZED, DozeMachine.State.INITIALIZED);
}
@Test
public void testDockEventListener_registerAndUnregister() {
mDockHandler.transitionTo(DozeMachine.State.UNINITIALIZED, DozeMachine.State.INITIALIZED);
public void transitionToInitialized_registersDockEventListener() {
verify(mDockManagerFake).addListener(any());
}
mDockHandler.transitionTo(DozeMachine.State.DOZE, DozeMachine.State.FINISH);
@Test
public void transitionToFinish_unregistersDockEventListener() {
mDockHandler.transitionTo(DozeMachine.State.INITIALIZED, DozeMachine.State.FINISH);
verify(mDockManagerFake).removeListener(any());
}
@Test
public void testOnEvent_dockedWhenDoze_requestPulse() {
mDockHandler.transitionTo(DozeMachine.State.UNINITIALIZED, DozeMachine.State.INITIALIZED);
when(mMachine.getState()).thenReturn(DozeMachine.State.DOZE);
public void onEvent_docked_requestsDockedAodState() {
mDockManagerFake.setDockEvent(DockManager.STATE_DOCKED);
verify(mMachine).requestPulse(eq(DozeEvent.PULSE_REASON_DOCKING));
verify(mMachine).requestState(eq(State.DOZE_AOD_DOCKED));
}
@Test
public void testOnEvent_dockedWhenDozeAoD_requestPulse() {
mDockHandler.transitionTo(DozeMachine.State.UNINITIALIZED, DozeMachine.State.INITIALIZED);
when(mMachine.getState()).thenReturn(DozeMachine.State.DOZE_AOD);
mDockManagerFake.setDockEvent(DockManager.STATE_DOCKED);
verify(mMachine).requestPulse(eq(DozeEvent.PULSE_REASON_DOCKING));
}
@Test
public void testOnEvent_dockedHideWhenPulsing_requestPulseOut() {
mDockHandler.transitionTo(DozeMachine.State.UNINITIALIZED, DozeMachine.State.INITIALIZED);
when(mMachine.getState()).thenReturn(State.DOZE_PULSING);
when(mMachine.getPulseReason()).thenReturn(DozeEvent.PULSE_REASON_DOCKING);
mDockManagerFake.setDockEvent(DockManager.STATE_DOCKED_HIDE);
verify(mHost).stopPulsing();
}
@Test
public void testOnEvent_undockedWhenPulsing_requestPulseOut() {
mDockHandler.transitionTo(DozeMachine.State.UNINITIALIZED, DozeMachine.State.INITIALIZED);
when(mMachine.getState()).thenReturn(DozeMachine.State.DOZE_PULSING);
when(mMachine.getPulseReason()).thenReturn(DozeEvent.PULSE_REASON_DOCKING);
mDockManagerFake.setDockEvent(DockManager.STATE_NONE);
verify(mHost).stopPulsing();
}
@Test
public void testOnEvent_undockedWhenDoze_neverRequestPulseOut() {
mDockHandler.transitionTo(DozeMachine.State.UNINITIALIZED, DozeMachine.State.INITIALIZED);
when(mMachine.getState()).thenReturn(DozeMachine.State.DOZE);
mDockManagerFake.setDockEvent(DockManager.STATE_NONE);
verify(mHost, never()).stopPulsing();
}
@Test
public void testOnEvent_undockedWhenDozeAndEnabledAoD_requestDozeAoD() {
doReturn(true).when(mConfig).alwaysOnEnabled(anyInt());
mDockHandler.transitionTo(DozeMachine.State.UNINITIALIZED, DozeMachine.State.INITIALIZED);
when(mMachine.getState()).thenReturn(DozeMachine.State.DOZE);
public void onEvent_noneWhileEnabledAod_requestsAodState() {
mDockManagerFake.setDockEvent(DockManager.STATE_NONE);
verify(mMachine).requestState(eq(State.DOZE_AOD));
}
@Test
public void testTransitionToDoze_whenDocked_requestPulse() {
mDockHandler.transitionTo(DozeMachine.State.UNINITIALIZED, DozeMachine.State.INITIALIZED);
when(mMachine.getState()).thenReturn(DozeMachine.State.INITIALIZED);
mDockManagerFake.setDockEvent(DockManager.STATE_DOCKED);
when(mMachine.getState()).thenReturn(DozeMachine.State.DOZE);
mDockHandler.transitionTo(State.INITIALIZED, DozeMachine.State.DOZE);
public void onEvent_noneWhileDisabledAod_requestsDozeState() {
doReturn(false).when(mConfig).alwaysOnEnabled(anyInt());
TestableLooper.get(this).processAllMessages();
verify(mMachine).requestPulse(eq(DozeEvent.PULSE_REASON_DOCKING));
}
@Test
public void testTransitionToDozeAoD_whenDocked_requestPulse() {
mDockHandler.transitionTo(DozeMachine.State.UNINITIALIZED, DozeMachine.State.INITIALIZED);
when(mMachine.getState()).thenReturn(DozeMachine.State.INITIALIZED);
mDockManagerFake.setDockEvent(DockManager.STATE_DOCKED);
when(mMachine.getState()).thenReturn(DozeMachine.State.DOZE_AOD);
mDockHandler.transitionTo(State.INITIALIZED, DozeMachine.State.DOZE_AOD);
TestableLooper.get(this).processAllMessages();
verify(mMachine).requestPulse(eq(DozeEvent.PULSE_REASON_DOCKING));
}
@Test
public void testTransitionToDoze_whenDockedHide_neverRequestPulse() {
mDockHandler.transitionTo(DozeMachine.State.UNINITIALIZED, DozeMachine.State.INITIALIZED);
when(mMachine.getState()).thenReturn(DozeMachine.State.INITIALIZED);
mDockManagerFake.setDockEvent(DockManager.STATE_DOCKED_HIDE);
when(mMachine.getState()).thenReturn(DozeMachine.State.DOZE);
mDockHandler.transitionTo(DozeMachine.State.INITIALIZED, DozeMachine.State.DOZE);
verify(mMachine, never()).requestPulse(eq(DozeEvent.PULSE_REASON_DOCKING));
}
@Test
public void testTransitionToDozeAoD_whenDockedHide_requestDoze() {
mDockHandler.transitionTo(DozeMachine.State.UNINITIALIZED, DozeMachine.State.INITIALIZED);
when(mMachine.getState()).thenReturn(DozeMachine.State.INITIALIZED);
mDockManagerFake.setDockEvent(DockManager.STATE_DOCKED_HIDE);
when(mMachine.getState()).thenReturn(DozeMachine.State.DOZE_AOD);
mDockHandler.transitionTo(DozeMachine.State.INITIALIZED, State.DOZE_AOD);
mDockManagerFake.setDockEvent(DockManager.STATE_NONE);
verify(mMachine).requestState(eq(State.DOZE));
}
@Test
public void testTransitionToPulsing_whenDockedHide_requestPulseOut() {
mDockHandler.transitionTo(DozeMachine.State.UNINITIALIZED, DozeMachine.State.INITIALIZED);
when(mMachine.getState()).thenReturn(DozeMachine.State.DOZE_PULSING);
when(mMachine.getPulseReason()).thenReturn(DozeEvent.PULSE_REASON_DOCKING);
public void onEvent_hide_requestsDozeState() {
mDockManagerFake.setDockEvent(DockManager.STATE_DOCKED_HIDE);
mDockHandler.transitionTo(DozeMachine.State.INITIALIZED, State.DOZE_PULSING);
verify(mHost).stopPulsing();
verify(mMachine).requestState(eq(State.DOZE));
}
}

57
packages/SystemUI/tests/src/com/android/systemui/doze/DozeMachineTest.java
View File

@@ -18,6 +18,7 @@ package com.android.systemui.doze;
import static com.android.systemui.doze.DozeMachine.State.DOZE;
import static com.android.systemui.doze.DozeMachine.State.DOZE_AOD;
import static com.android.systemui.doze.DozeMachine.State.DOZE_AOD_DOCKED;
import static com.android.systemui.doze.DozeMachine.State.DOZE_PULSE_DONE;
import static com.android.systemui.doze.DozeMachine.State.DOZE_PULSING;
import static com.android.systemui.doze.DozeMachine.State.DOZE_REQUEST_PULSE;
@@ -45,6 +46,7 @@ import android.testing.UiThreadTest;
import androidx.test.filters.SmallTest;
import com.android.systemui.SysuiTestCase;
import com.android.systemui.dock.DockManager;
import com.android.systemui.keyguard.WakefulnessLifecycle;
import com.android.systemui.statusbar.policy.BatteryController;
import com.android.systemui.util.wakelock.WakeLockFake;
@@ -66,6 +68,7 @@ public class DozeMachineTest extends SysuiTestCase {
private WakefulnessLifecycle mWakefulnessLifecycle;
@Mock
private DozeLog mDozeLog;
@Mock private DockManager mDockManager;
private DozeServiceFake mServiceFake;
private WakeLockFake mWakeLockFake;
private AmbientDisplayConfiguration mConfigMock;
@@ -78,9 +81,11 @@ public class DozeMachineTest extends SysuiTestCase {
mWakeLockFake = new WakeLockFake();
mConfigMock = mock(AmbientDisplayConfiguration.class);
mPartMock = mock(DozeMachine.Part.class);
when(mDockManager.isDocked()).thenReturn(false);
when(mDockManager.isHidden()).thenReturn(false);
mMachine = new DozeMachine(mServiceFake, mConfigMock, mWakeLockFake,
mWakefulnessLifecycle, mock(BatteryController.class), mDozeLog);
mWakefulnessLifecycle, mock(BatteryController.class), mDozeLog, mDockManager);
mMachine.setParts(new DozeMachine.Part[]{mPartMock});
}
@@ -111,6 +116,28 @@ public class DozeMachineTest extends SysuiTestCase {
assertEquals(DOZE_AOD, mMachine.getState());
}
@Test
public void testInitialize_afterDocked_goesToDockedAod() {
when(mDockManager.isDocked()).thenReturn(true);
mMachine.requestState(INITIALIZED);
verify(mPartMock).transitionTo(INITIALIZED, DOZE_AOD_DOCKED);
assertEquals(DOZE_AOD_DOCKED, mMachine.getState());
}
@Test
public void testInitialize_afterDockPaused_goesToDoze() {
when(mConfigMock.alwaysOnEnabled(anyInt())).thenReturn(true);
when(mDockManager.isDocked()).thenReturn(true);
when(mDockManager.isHidden()).thenReturn(true);
mMachine.requestState(INITIALIZED);
verify(mPartMock).transitionTo(INITIALIZED, DOZE);
assertEquals(DOZE, mMachine.getState());
}
@Test
public void testPulseDone_goesToDoze() {
when(mConfigMock.alwaysOnEnabled(anyInt())).thenReturn(false);
@@ -137,6 +164,34 @@ public class DozeMachineTest extends SysuiTestCase {
assertEquals(DOZE_AOD, mMachine.getState());
}
@Test
public void testPulseDone_afterDocked_goesToDockedAoD() {
when(mDockManager.isDocked()).thenReturn(true);
mMachine.requestState(INITIALIZED);
mMachine.requestPulse(DozeEvent.PULSE_REASON_NOTIFICATION);
mMachine.requestState(DOZE_PULSING);
mMachine.requestState(DOZE_PULSE_DONE);
verify(mPartMock).transitionTo(DOZE_PULSE_DONE, DOZE_AOD_DOCKED);
assertEquals(DOZE_AOD_DOCKED, mMachine.getState());
}
@Test
public void testPulseDone_afterDockPaused_goesToDoze() {
when(mConfigMock.alwaysOnEnabled(anyInt())).thenReturn(true);
when(mDockManager.isDocked()).thenReturn(true);
when(mDockManager.isHidden()).thenReturn(true);
mMachine.requestState(INITIALIZED);
mMachine.requestPulse(DozeEvent.PULSE_REASON_NOTIFICATION);
mMachine.requestState(DOZE_PULSING);
mMachine.requestState(DOZE_PULSE_DONE);
verify(mPartMock).transitionTo(DOZE_PULSE_DONE, DOZE);
assertEquals(DOZE, mMachine.getState());
}
@Test
public void testFinished_staysFinished() {
mMachine.requestState(INITIALIZED);

11
packages/SystemUI/tests/src/com/android/systemui/doze/DozeScreenBrightnessTest.java
View File

@@ -18,6 +18,7 @@ package com.android.systemui.doze;
import static com.android.systemui.doze.DozeMachine.State.DOZE;
import static com.android.systemui.doze.DozeMachine.State.DOZE_AOD;
import static com.android.systemui.doze.DozeMachine.State.DOZE_AOD_DOCKED;
import static com.android.systemui.doze.DozeMachine.State.DOZE_AOD_PAUSED;
import static com.android.systemui.doze.DozeMachine.State.DOZE_AOD_PAUSING;
import static com.android.systemui.doze.DozeMachine.State.DOZE_PULSE_DONE;
@@ -171,6 +172,16 @@ public class DozeScreenBrightnessTest extends SysuiTestCase {
assertEquals(1, mServiceFake.screenBrightness);
}
@Test
public void testDockedAod_usesLightSensor() {
mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
mScreen.transitionTo(INITIALIZED, DOZE_AOD_DOCKED);
mSensor.sendSensorEvent(3);
assertEquals(3, mServiceFake.screenBrightness);
}
@Test
public void testDozingAfterPulsing_pausesLightSensor() throws Exception {
mScreen.transitionTo(UNINITIALIZED, INITIALIZED);

9
packages/SystemUI/tests/src/com/android/systemui/doze/DozeScreenStateTest.java
View File

@@ -18,6 +18,7 @@ package com.android.systemui.doze;
import static com.android.systemui.doze.DozeMachine.State.DOZE;
import static com.android.systemui.doze.DozeMachine.State.DOZE_AOD;
import static com.android.systemui.doze.DozeMachine.State.DOZE_AOD_DOCKED;
import static com.android.systemui.doze.DozeMachine.State.DOZE_AOD_PAUSED;
import static com.android.systemui.doze.DozeMachine.State.DOZE_AOD_PAUSING;
import static com.android.systemui.doze.DozeMachine.State.DOZE_PULSING;
@@ -127,6 +128,14 @@ public class DozeScreenStateTest extends SysuiTestCase {
assertEquals(Display.STATE_OFF, mServiceFake.screenState);
}
@Test
public void testScreen_onInDockedAod() {
mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
mScreen.transitionTo(INITIALIZED, DOZE_AOD_DOCKED);
assertEquals(Display.STATE_ON, mServiceFake.screenState);
}
@Test
public void test_initialScreenStatePostedToHandler() {
mHandlerFake.setMode(QUEUEING);

22
packages/SystemUI/tests/src/com/android/systemui/doze/DozeTriggersTest.java
View File

@@ -69,10 +69,11 @@ public class DozeTriggersTest extends SysuiTestCase {
private AlarmManager mAlarmManager;
@Mock
private BroadcastDispatcher mBroadcastDispatcher;
@Mock
private DockManager mDockManager;
private DozeTriggers mTriggers;
private FakeSensorManager mSensors;
private Sensor mTapSensor;
private DockManager mDockManagerFake;
private FakeProximitySensor mProximitySensor;
@Before
@@ -83,14 +84,13 @@ public class DozeTriggersTest extends SysuiTestCase {
mSensors = spy(new FakeSensorManager(mContext));
mTapSensor = mSensors.getFakeTapSensor().getSensor();
WakeLock wakeLock = new WakeLockFake();
mDockManagerFake = mock(DockManager.class);
AsyncSensorManager asyncSensorManager =
new AsyncSensorManager(mSensors, null, new Handler());
mProximitySensor = new FakeProximitySensor(getContext().getResources(), asyncSensorManager);
mTriggers = new DozeTriggers(mContext, mMachine, mHost, mAlarmManager, config, parameters,
asyncSensorManager, Handler.createAsync(Looper.myLooper()), wakeLock, true,
mDockManagerFake, mProximitySensor, mock(DozeLog.class), mBroadcastDispatcher);
mDockManager, mProximitySensor, mock(DozeLog.class), mBroadcastDispatcher);
waitForSensorManager();
}
@@ -141,13 +141,25 @@ public class DozeTriggersTest extends SysuiTestCase {
verify(mSensors).requestTriggerSensor(any(), eq(mTapSensor));
}
@Test
public void transitionToDockedAod_disablesTouchSensors() {
mTriggers.transitionTo(DozeMachine.State.INITIALIZED, DozeMachine.State.DOZE);
waitForSensorManager();
verify(mSensors).requestTriggerSensor(any(), eq(mTapSensor));
mTriggers.transitionTo(DozeMachine.State.DOZE, DozeMachine.State.DOZE_AOD_DOCKED);
waitForSensorManager();
verify(mSensors).cancelTriggerSensor(any(), eq(mTapSensor));
}
@Test
public void testDockEventListener_registerAndUnregister() {
mTriggers.transitionTo(DozeMachine.State.UNINITIALIZED, DozeMachine.State.INITIALIZED);
verify(mDockManagerFake).addListener(any());
verify(mDockManager).addListener(any());
mTriggers.transitionTo(DozeMachine.State.DOZE, DozeMachine.State.FINISH);
verify(mDockManagerFake).removeListener(any());
verify(mDockManager).removeListener(any());
}
@Test