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

Commit 2d31be6b authored by Darrell Shi's avatar Darrell Shi
Browse files

Introduce AmbientLightModeMonitor. 

Move light sensor logic to AmbientLightModeMonitor, which will apply
debouncing in the following CL.

Test: atest AmbientLightModeMonitorTest IdleHostViewControllerTest
Bug: 201657509
Change-Id: I03bf5a1daa97c91af6da9a2afdd4d4e535d27985
parent 7c7bb9ab

packages/SystemUI/src/com/android/systemui/idle/AmbientLightModeMonitor.kt

0 → 100644
+127 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2021 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



package com.android.systemui.idle



import android.annotation.IntDef

import android.hardware.Sensor

import android.hardware.SensorEvent

import android.hardware.SensorEventListener

import android.hardware.SensorManager

import android.util.Log

import com.android.systemui.util.sensors.AsyncSensorManager

import javax.inject.Inject

import kotlin.properties.Delegates



/**

 * Monitors ambient light signals, applies a debouncing algorithm, and produces the current

 * [AmbientLightMode].

 *

 * For debouncer behavior, refer to go/titan-light-sensor-debouncer.

 *

 * @property sensorManager the sensor manager used to register sensor event updates.

 */

class AmbientLightModeMonitor @Inject constructor(

    private val sensorManager: AsyncSensorManager

) {

    companion object {

        private const val TAG = "AmbientLightModeMonitor"

        private val DEBUG = Log.isLoggable(TAG, Log.DEBUG)



        const val AMBIENT_LIGHT_MODE_LIGHT = 0

        const val AMBIENT_LIGHT_MODE_DARK = 1

        const val AMBIENT_LIGHT_MODE_UNDECIDED = 2

    }



    // Light sensor used to detect ambient lighting conditions.

    private val lightSensor: Sensor = sensorManager.getDefaultSensor(Sensor.TYPE_LIGHT)



    // Registered callback, which gets triggered when the ambient light mode changes.

    private var callback: Callback? = null



    // Represents all ambient light modes.

    @Retention(AnnotationRetention.SOURCE)

    @IntDef(AMBIENT_LIGHT_MODE_LIGHT, AMBIENT_LIGHT_MODE_DARK, AMBIENT_LIGHT_MODE_UNDECIDED)

    annotation class AmbientLightMode



    // The current ambient light mode.

    @AmbientLightMode private var mode: Int by Delegates.observable(AMBIENT_LIGHT_MODE_UNDECIDED

    ) { _, old, new ->

        if (old != new) {

            callback?.onChange(new)

        }

    }



    /**

     * Start monitoring the current ambient light mode.

     *

     * @param callback callback that gets triggered when the ambient light mode changes. It also

     * gets triggered immediately to update the current value when this function is called.

     */

    fun start(callback: Callback) {

        if (DEBUG) Log.d(TAG, "start monitoring ambient light mode")



        if (this.callback != null) {

            if (DEBUG) Log.w(TAG, "already started")

            return

        }



        this.callback = callback

        callback.onChange(mode)



        sensorManager.registerListener(mSensorEventListener, lightSensor,

                SensorManager.SENSOR_DELAY_NORMAL)

    }



    /**

     * Stop monitoring the current ambient light mode.

     */

    fun stop() {

        if (DEBUG) Log.d(TAG, "stop monitoring ambient light mode")



        if (callback == null) {

            if (DEBUG) Log.w(TAG, "haven't started")

            return

        }



        callback = null

        sensorManager.unregisterListener(mSensorEventListener)

    }



    private val mSensorEventListener: SensorEventListener = object : SensorEventListener {

        override fun onSensorChanged(event: SensorEvent) {

            if (event.values.isEmpty()) {

                if (DEBUG) Log.w(TAG, "SensorEvent doesn't have any value")

                return

            }



            // TODO(b/201657509): add debouncing logic.

            val shouldBeLowLight = event.values[0] < 10

            mode = if (shouldBeLowLight) AMBIENT_LIGHT_MODE_DARK else AMBIENT_LIGHT_MODE_LIGHT

        }



        override fun onAccuracyChanged(sensor: Sensor, accuracy: Int) {

            // Do nothing.

        }

    }



    /**

     * Interface of the ambient light mode callback, which gets triggered when the mode changes.

     */

    interface Callback {

        fun onChange(@AmbientLightMode mode: Int)

    }

}
 
 No newline at end of file

packages/SystemUI/src/com/android/systemui/idle/IdleHostViewController.java

+34 −41
Original line number Diff line number Diff line
@@ -24,10 +24,6 @@ import android.content.Context; 
import android.content.Intent;

import android.content.IntentFilter;

import android.content.res.Resources;

import android.hardware.Sensor;

import android.hardware.SensorEvent;

import android.hardware.SensorEventListener;

import android.hardware.SensorManager;

import android.os.Looper;

import android.os.PowerManager;

import android.os.SystemClock;
@@ -44,7 +40,6 @@ import com.android.systemui.shared.system.InputMonitorCompat; 
import com.android.systemui.statusbar.policy.KeyguardStateController;

import com.android.systemui.util.ViewController;

import com.android.systemui.util.concurrency.DelayableExecutor;

import com.android.systemui.util.sensors.AsyncSensorManager;



import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;
@@ -56,8 +51,7 @@ import javax.inject.Provider; 
/**

 * {@link IdleHostViewController} processes signals to control the lifecycle of the idle screen.

 */

public class IdleHostViewController extends ViewController<IdleHostView> implements

        SensorEventListener {

public class IdleHostViewController extends ViewController<IdleHostView> {

    private static final String INPUT_MONITOR_IDENTIFIER = "IdleHostViewController";

    private static final String TAG = "IdleHostViewController";

    private static final boolean DEBUG = Log.isLoggable(TAG, Log.DEBUG);
@@ -114,11 +108,6 @@ public class IdleHostViewController extends ViewController<IdleHostView> impleme 


    private final PowerManager mPowerManager;



    private final AsyncSensorManager mSensorManager;



    // Light sensor used to detect low light condition.

    private final Sensor mSensor;



    // Runnable for canceling enabling idle.

    private Runnable mCancelEnableIdling;
@@ -146,6 +135,9 @@ public class IdleHostViewController extends ViewController<IdleHostView> impleme 
    // Intent filter for receiving dream broadcasts.

    private IntentFilter mDreamIntentFilter;



    // Monitor for the current ambient light mode. Used to trigger / exit low-light mode.

    private final AmbientLightModeMonitor mAmbientLightModeMonitor;



    // Delayed callback for starting idling.

    private final Runnable mEnableIdlingCallback = () -> {

        if (DEBUG) {
@@ -181,6 +173,31 @@ public class IdleHostViewController extends ViewController<IdleHostView> impleme 
        }

    };



    private final AmbientLightModeMonitor.Callback mAmbientLightModeCallback =

            mode -> {

                boolean shouldBeLowLight;

                switch (mode) {

                    case AmbientLightModeMonitor.AMBIENT_LIGHT_MODE_UNDECIDED:

                        return;

                    case AmbientLightModeMonitor.AMBIENT_LIGHT_MODE_LIGHT:

                        shouldBeLowLight = false;

                        break;

                    case AmbientLightModeMonitor.AMBIENT_LIGHT_MODE_DARK:

                        shouldBeLowLight = true;

                        break;

                    default:

                        Log.w(TAG, "invalid ambient light mode");

                        return;

                }



                if (DEBUG) Log.d(TAG, "ambient light mode changed to " + mode);



                final boolean isLowLight = getState(STATE_LOW_LIGHT);

                if (shouldBeLowLight != isLowLight) {

                    setState(STATE_LOW_LIGHT, shouldBeLowLight);

                }

            };



    final Provider<View> mIdleViewProvider;



    @Inject
@@ -188,7 +205,6 @@ public class IdleHostViewController extends ViewController<IdleHostView> impleme 
            Context context,

            BroadcastDispatcher broadcastDispatcher,

            PowerManager powerManager,

            AsyncSensorManager sensorManager,

            IdleHostView view, InputMonitorFactory factory,

            @Main DelayableExecutor delayableExecutor,

            @Main Resources resources,
@@ -197,18 +213,19 @@ public class IdleHostViewController extends ViewController<IdleHostView> impleme 
            Choreographer choreographer,

            KeyguardStateController keyguardStateController,

            StatusBarStateController statusBarStateController,

            DreamHelper dreamHelper) {

            DreamHelper dreamHelper,

            AmbientLightModeMonitor ambientLightModeMonitor) {

        super(view);

        mContext = context;

        mBroadcastDispatcher = broadcastDispatcher;

        mPowerManager = powerManager;

        mSensorManager = sensorManager;

        mIdleViewProvider = idleViewProvider;

        mKeyguardStateController = keyguardStateController;

        mStatusBarStateController = statusBarStateController;

        mLooper = looper;

        mChoreographer = choreographer;

        mDreamHelper = dreamHelper;

        mAmbientLightModeMonitor = ambientLightModeMonitor;



        mState = STATE_KEYGUARD_SHOWING;
@@ -222,7 +239,6 @@ public class IdleHostViewController extends ViewController<IdleHostView> impleme 
        mIdleTimeout = resources.getInteger(R.integer.config_idleModeTimeout);

        mInputMonitorFactory = factory;

        mDelayableExecutor = delayableExecutor;

        mSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_LIGHT);



        if (DEBUG) {

            Log.d(TAG, "initial state:" + mState + " enabled:" + enabled
@@ -405,11 +421,10 @@ public class IdleHostViewController extends ViewController<IdleHostView> impleme 


        if (mIsMonitoringLowLight) {

            if (DEBUG) Log.d(TAG, "enable low light monitoring");

            mSensorManager.registerListener(this /*listener*/, mSensor,

                    SensorManager.SENSOR_DELAY_NORMAL);

            mAmbientLightModeMonitor.start(mAmbientLightModeCallback);

        } else {

            if (DEBUG) Log.d(TAG, "disable low light monitoring");

            mSensorManager.unregisterListener(this);

            mAmbientLightModeMonitor.stop();

        }

    }
@@ -449,28 +464,6 @@ public class IdleHostViewController extends ViewController<IdleHostView> impleme 
        mStatusBarStateController.removeCallback(mStatusBarCallback);

    }



    @Override

    public void onSensorChanged(SensorEvent event) {

        if (event.values.length == 0) {

            if (DEBUG) Log.w(TAG, "SensorEvent doesn't have value");

            return;

        }



        final boolean shouldBeLowLight = event.values[0] < 10;

        final boolean isLowLight = getState(STATE_LOW_LIGHT);



        if (shouldBeLowLight != isLowLight) {

            setState(STATE_LOW_LIGHT, shouldBeLowLight);

        }

    }



    @Override

    public void onAccuracyChanged(Sensor sensor, int accuracy) {

        if (DEBUG) {

            Log.d(TAG, "onAccuracyChanged accuracy=" + accuracy);

        }

    }



    // Returns whether the device just stopped idling by comparing the previous state with the

    // current one.

    private boolean stoppedIdling(int oldState) {

packages/SystemUI/tests/src/com/android/systemui/idle/AmbientLightModeMonitorTest.kt

0 → 100644
+160 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2021 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



package com.android.systemui.idle



import android.hardware.Sensor

import android.hardware.SensorEvent

import android.hardware.SensorEventListener

import android.testing.AndroidTestingRunner

import androidx.test.filters.SmallTest

import com.android.systemui.SysuiTestCase

import com.android.systemui.util.sensors.AsyncSensorManager

import org.junit.Before

import org.junit.Test

import org.junit.runner.RunWith

import org.mockito.ArgumentCaptor

import org.mockito.Mock

import org.mockito.Mockito.verify

import org.mockito.Mockito.reset

import org.mockito.Mockito.mock

import org.mockito.Mockito.never

import org.mockito.Mockito.anyInt

import org.mockito.Mockito.any

import org.mockito.Mockito.`when`

import org.mockito.MockitoAnnotations



@SmallTest

@RunWith(AndroidTestingRunner::class)

class AmbientLightModeMonitorTest : SysuiTestCase() {

    @Mock private lateinit var sensorManager: AsyncSensorManager

    @Mock private lateinit var sensor: Sensor



    private lateinit var ambientLightModeMonitor: AmbientLightModeMonitor



    @Before

    fun setUp() {

        MockitoAnnotations.initMocks(this)



        `when`(sensorManager.getDefaultSensor(Sensor.TYPE_LIGHT)).thenReturn(sensor)

        ambientLightModeMonitor = AmbientLightModeMonitor(sensorManager)

    }



    @Test

    fun shouldTriggerCallbackImmediatelyOnStart() {

        val callback = mock(AmbientLightModeMonitor.Callback::class.java)

        ambientLightModeMonitor.start(callback)



        // Monitor just started, should receive UNDECIDED.

        verify(callback).onChange(AmbientLightModeMonitor.AMBIENT_LIGHT_MODE_UNDECIDED)



        // Receives SensorEvent, and now mode is LIGHT.

        val sensorEventListener = captureSensorEventListener()

        sensorEventListener.onSensorChanged(sensorEventWithSingleValue(15f))



        // Stop monitor.

        ambientLightModeMonitor.stop()



        // Restart monitor.

        reset(callback)

        ambientLightModeMonitor.start(callback)



        // Verify receiving current mode (LIGHT) immediately.

        verify(callback).onChange(AmbientLightModeMonitor.AMBIENT_LIGHT_MODE_LIGHT)

    }



    @Test

    fun shouldReportDarkModeWhenSensorValueIsLessThanTen() {

        val callback = mock(AmbientLightModeMonitor.Callback::class.java)

        ambientLightModeMonitor.start(callback)



        val sensorEventListener = captureSensorEventListener()

        reset(callback)



        sensorEventListener.onSensorChanged(sensorEventWithSingleValue(0f))

        verify(callback).onChange(AmbientLightModeMonitor.AMBIENT_LIGHT_MODE_DARK)



        sensorEventListener.onSensorChanged(sensorEventWithSingleValue(1f))

        verify(callback).onChange(AmbientLightModeMonitor.AMBIENT_LIGHT_MODE_DARK)



        sensorEventListener.onSensorChanged(sensorEventWithSingleValue(5f))

        verify(callback).onChange(AmbientLightModeMonitor.AMBIENT_LIGHT_MODE_DARK)



        sensorEventListener.onSensorChanged(sensorEventWithSingleValue(9.9f))

        verify(callback).onChange(AmbientLightModeMonitor.AMBIENT_LIGHT_MODE_DARK)

    }



    @Test

    fun shouldReportLightModeWhenSensorValueIsGreaterThanOrEqualToTen() {

        val callback = mock(AmbientLightModeMonitor.Callback::class.java)

        ambientLightModeMonitor.start(callback)



        val sensorEventListener = captureSensorEventListener()

        reset(callback)



        sensorEventListener.onSensorChanged(sensorEventWithSingleValue(10f))

        verify(callback).onChange(AmbientLightModeMonitor.AMBIENT_LIGHT_MODE_LIGHT)



        sensorEventListener.onSensorChanged(sensorEventWithSingleValue(10.1f))

        verify(callback).onChange(AmbientLightModeMonitor.AMBIENT_LIGHT_MODE_LIGHT)



        sensorEventListener.onSensorChanged(sensorEventWithSingleValue(15f))

        verify(callback).onChange(AmbientLightModeMonitor.AMBIENT_LIGHT_MODE_LIGHT)



        sensorEventListener.onSensorChanged(sensorEventWithSingleValue(100f))

        verify(callback).onChange(AmbientLightModeMonitor.AMBIENT_LIGHT_MODE_LIGHT)

    }



    @Test

    fun shouldOnlyTriggerCallbackWhenValueChanges() {

        val callback = mock(AmbientLightModeMonitor.Callback::class.java)

        ambientLightModeMonitor.start(callback)



        val sensorEventListener = captureSensorEventListener()



        // Light mode, should trigger callback.

        reset(callback)

        sensorEventListener.onSensorChanged(sensorEventWithSingleValue(20f))

        verify(callback).onChange(AmbientLightModeMonitor.AMBIENT_LIGHT_MODE_LIGHT)



        // Light mode again, should NOT trigger callback.

        reset(callback)

        sensorEventListener.onSensorChanged(sensorEventWithSingleValue(25f))

        verify(callback, never()).onChange(AmbientLightModeMonitor.AMBIENT_LIGHT_MODE_LIGHT)



        // Dark mode, should trigger callback.

        reset(callback)

        sensorEventListener.onSensorChanged(sensorEventWithSingleValue(2f))

        verify(callback).onChange(AmbientLightModeMonitor.AMBIENT_LIGHT_MODE_DARK)



        // Dark mode again, should not trigger callback.

        reset(callback)

        sensorEventListener.onSensorChanged(sensorEventWithSingleValue(3f))

        verify(callback, never()).onChange(AmbientLightModeMonitor.AMBIENT_LIGHT_MODE_DARK)

    }



    // Captures [SensorEventListener], assuming it has been registered with [sensorManager].

    private fun captureSensorEventListener(): SensorEventListener {

        val captor = ArgumentCaptor.forClass(SensorEventListener::class.java)

        verify(sensorManager).registerListener(captor.capture(), any(), anyInt())

        return captor.value

    }



    // Returns a [SensorEvent] with a single [value].

    private fun sensorEventWithSingleValue(value: Float): SensorEvent {

        return SensorEvent(sensor, 1, 1, FloatArray(1) { value })

    }

}

packages/SystemUI/tests/src/com/android/systemui/idle/IdleHostViewControllerTest.java

+32 −34
Original line number Diff line number Diff line
@@ -28,8 +28,6 @@ import static org.mockito.Mockito.when; 
import android.content.BroadcastReceiver;

import android.content.Intent;

import android.content.res.Resources;

import android.hardware.Sensor;

import android.hardware.SensorEvent;

import android.os.Looper;

import android.os.PowerManager;

import android.testing.AndroidTestingRunner;
@@ -46,7 +44,6 @@ import com.android.systemui.shared.system.InputChannelCompat; 
import com.android.systemui.shared.system.InputMonitorCompat;

import com.android.systemui.statusbar.policy.KeyguardStateController;

import com.android.systemui.util.concurrency.DelayableExecutor;

import com.android.systemui.util.sensors.AsyncSensorManager;



import org.junit.Before;

import org.junit.Test;
@@ -55,8 +52,6 @@ import org.mockito.ArgumentCaptor; 
import org.mockito.Mock;

import org.mockito.MockitoAnnotations;



import java.time.Instant;



import javax.inject.Provider;



@SmallTest
@@ -64,7 +59,6 @@ import javax.inject.Provider; 
public class IdleHostViewControllerTest extends SysuiTestCase {

    @Mock private BroadcastDispatcher mBroadcastDispatcher;

    @Mock private PowerManager mPowerManager;

    @Mock private AsyncSensorManager mSensorManager;

    @Mock private IdleHostView mIdleHostView;

    @Mock private InputMonitorFactory mInputMonitorFactory;

    @Mock private DelayableExecutor mDelayableExecutor;
@@ -74,12 +68,11 @@ public class IdleHostViewControllerTest extends SysuiTestCase { 
    @Mock private Choreographer mChoreographer;

    @Mock private KeyguardStateController mKeyguardStateController;

    @Mock private StatusBarStateController mStatusBarStateController;

    @Mock private Sensor mSensor;

    @Mock private DreamHelper mDreamHelper;

    @Mock private InputMonitorCompat mInputMonitor;

    @Mock private InputChannelCompat.InputEventReceiver mInputEventReceiver;

    @Mock private AmbientLightModeMonitor mAmbientLightModeMonitor;



    private final long mTimestamp = Instant.now().toEpochMilli();

    private KeyguardStateController.Callback mKeyguardStateCallback;

    private StatusBarStateController.StateListener mStatusBarStateListener;

    private IdleHostViewController mController;
@@ -90,15 +83,15 @@ public class IdleHostViewControllerTest extends SysuiTestCase { 


        when(mResources.getBoolean(R.bool.config_enableIdleMode)).thenReturn(true);

        when(mStatusBarStateController.isDozing()).thenReturn(false);

        when(mSensorManager.getDefaultSensor(Sensor.TYPE_LIGHT)).thenReturn(mSensor);

        when(mInputMonitorFactory.getInputMonitor("IdleHostViewController"))

                .thenReturn(mInputMonitor);

        when(mInputMonitor.getInputReceiver(any(), any(), any())).thenReturn(mInputEventReceiver);



        mController = new IdleHostViewController(mContext,

                mBroadcastDispatcher, mPowerManager, mSensorManager, mIdleHostView,

                mBroadcastDispatcher, mPowerManager, mIdleHostView,

                mInputMonitorFactory, mDelayableExecutor, mResources, mLooper, mViewProvider,

                mChoreographer, mKeyguardStateController, mStatusBarStateController, mDreamHelper);

                mChoreographer, mKeyguardStateController, mStatusBarStateController, mDreamHelper,

                mAmbientLightModeMonitor);

        mController.init();

        mController.onViewAttached();
@@ -122,9 +115,9 @@ public class IdleHostViewControllerTest extends SysuiTestCase { 
        mKeyguardStateCallback.onKeyguardShowingChanged();



        // Regular ambient lighting.

        final SensorEvent sensorEvent = new SensorEvent(mSensor, 3, mTimestamp,

                new float[]{90});

        mController.onSensorChanged(sensorEvent);

        final AmbientLightModeMonitor.Callback lightMonitorCallback =

                captureAmbientLightModeMonitorCallback();

        lightMonitorCallback.onChange(AmbientLightModeMonitor.AMBIENT_LIGHT_MODE_LIGHT);



        // Times out.

        ArgumentCaptor<Runnable> callbackCapture = ArgumentCaptor.forClass(Runnable.class);
@@ -149,9 +142,9 @@ public class IdleHostViewControllerTest extends SysuiTestCase { 
        final BroadcastReceiver dreamBroadcastReceiver = dreamBroadcastReceiverCaptor.getValue();



        // Low ambient lighting.

        final SensorEvent sensorEvent = new SensorEvent(mSensor, 3, mTimestamp,

                new float[]{5});

        mController.onSensorChanged(sensorEvent);

        final AmbientLightModeMonitor.Callback lightMonitorCallback =

                captureAmbientLightModeMonitorCallback();

        lightMonitorCallback.onChange(AmbientLightModeMonitor.AMBIENT_LIGHT_MODE_DARK);



        // Verifies it goes to sleep because of low light.

        verify(mPowerManager).goToSleep(anyLong(), anyInt(), anyInt());
@@ -179,15 +172,15 @@ public class IdleHostViewControllerTest extends SysuiTestCase { 


    @Test

    public void testTransitionBetweenIdleAndLowLightMode() {

        // Regular ambient lighting.

        final SensorEvent sensorEventRegularLight = new SensorEvent(mSensor, 3, mTimestamp,

                new float[]{90});

        mController.onSensorChanged(sensorEventRegularLight);



        // Keyguard showing.

        when(mKeyguardStateController.isShowing()).thenReturn(true);

        mKeyguardStateCallback.onKeyguardShowingChanged();



        // Regular ambient lighting.

        final AmbientLightModeMonitor.Callback lightMonitorCallback =

                captureAmbientLightModeMonitorCallback();

        lightMonitorCallback.onChange(AmbientLightModeMonitor.AMBIENT_LIGHT_MODE_LIGHT);



        // Times out.

        ArgumentCaptor<Runnable> callbackCapture = ArgumentCaptor.forClass(Runnable.class);

        verify(mDelayableExecutor).executeDelayed(callbackCapture.capture(), anyLong());
@@ -198,15 +191,13 @@ public class IdleHostViewControllerTest extends SysuiTestCase { 
        clearInvocations(mDreamHelper);



        // Ambient lighting becomes dim.

        final SensorEvent sensorEventLowLight = new SensorEvent(mSensor, 3, mTimestamp,

                new float[]{5});

        mController.onSensorChanged(sensorEventLowLight);

        lightMonitorCallback.onChange(AmbientLightModeMonitor.AMBIENT_LIGHT_MODE_DARK);



        // Verifies in low light mode (dozing).

        verify(mPowerManager).goToSleep(anyLong(), anyInt(), anyInt());



        // Ambient lighting becomes bright again.

        mController.onSensorChanged(sensorEventRegularLight);

        lightMonitorCallback.onChange(AmbientLightModeMonitor.AMBIENT_LIGHT_MODE_LIGHT);



        // Verifies in idle mode (dreaming).

        verify(mDreamHelper).startDreaming(any());
@@ -214,22 +205,20 @@ public class IdleHostViewControllerTest extends SysuiTestCase { 


    @Test

    public void testStartDozingWhenLowLight() {

        // Regular ambient lighting.

        final SensorEvent sensorEventRegularLight = new SensorEvent(mSensor, 3, mTimestamp,

                new float[]{90});

        mController.onSensorChanged(sensorEventRegularLight);



        // Keyguard showing.

        when(mKeyguardStateController.isShowing()).thenReturn(true);

        mKeyguardStateCallback.onKeyguardShowingChanged();



        // Regular ambient lighting.

        final AmbientLightModeMonitor.Callback lightMonitorCallback =

                captureAmbientLightModeMonitorCallback();

        lightMonitorCallback.onChange(AmbientLightModeMonitor.AMBIENT_LIGHT_MODE_LIGHT);



        // Verifies it doesn't go to sleep yet.

        verify(mPowerManager, never()).goToSleep(anyLong(), anyInt(), anyInt());



        // Ambient lighting becomes dim.

        final SensorEvent sensorEventLowLight = new SensorEvent(mSensor, 3, mTimestamp,

                new float[]{5});

        mController.onSensorChanged(sensorEventLowLight);

        lightMonitorCallback.onChange(AmbientLightModeMonitor.AMBIENT_LIGHT_MODE_DARK);



        // Verifies it goes to sleep.

        verify(mPowerManager).goToSleep(anyLong(), anyInt(), anyInt());
@@ -251,4 +240,13 @@ public class IdleHostViewControllerTest extends SysuiTestCase { 
        // Should dispose input event receiver.

        verify(mInputEventReceiver).dispose();

    }



    // Captures [AmbientLightModeMonitor.Callback] assuming that the ambient light mode monitor

    // has been started.

    private AmbientLightModeMonitor.Callback captureAmbientLightModeMonitorCallback() {

        ArgumentCaptor<AmbientLightModeMonitor.Callback> captor =

                ArgumentCaptor.forClass(AmbientLightModeMonitor.Callback.class);

        verify(mAmbientLightModeMonitor).start(captor.capture());

        return captor.getValue();

    }

}