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

   1 /*
   2  * Copyright (C) 2017 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package com.android.systemui.doze;
  18
  19 import static com.android.systemui.doze.DozeMachine.State.DOZE;
  20 import static com.android.systemui.doze.DozeMachine.State.DOZE_AOD;
  21 import static com.android.systemui.doze.DozeMachine.State.DOZE_AOD_PAUSED;
  22 import static com.android.systemui.doze.DozeMachine.State.DOZE_AOD_PAUSING;
  23 import static com.android.systemui.doze.DozeMachine.State.DOZE_PULSE_DONE;
  24 import static com.android.systemui.doze.DozeMachine.State.DOZE_PULSING;
  25 import static com.android.systemui.doze.DozeMachine.State.DOZE_REQUEST_PULSE;
  26 import static com.android.systemui.doze.DozeMachine.State.FINISH;
  27 import static com.android.systemui.doze.DozeMachine.State.INITIALIZED;
  28 import static com.android.systemui.doze.DozeMachine.State.UNINITIALIZED;
  29
  30 import static org.junit.Assert.assertEquals;
  31 import static org.junit.Assert.assertFalse;
  32 import static org.junit.Assert.assertNotEquals;
  33 import static org.junit.Assert.assertThat;
  34 import static org.junit.Assert.assertTrue;
  35
  36 import android.os.PowerManager;
  37 import android.support.test.filters.SmallTest;
  38 import android.support.test.runner.AndroidJUnit4;
  39
  40 import com.android.systemui.SysuiTestCase;
  41 import com.android.systemui.utils.hardware.FakeSensorManager;
  42
  43 import org.junit.Before;
  44 import org.junit.Test;
  45 import org.junit.runner.RunWith;
  46
  47 @RunWith(AndroidJUnit4.class)
  48 @SmallTest
  49 public class DozeScreenBrightnessTest extends SysuiTestCase {
  50
  51     static final int DEFAULT_BRIGHTNESS = 10;
  52     static final int[] SENSOR_TO_BRIGHTNESS = new int[]{-1, 1, 2, 3, 4};
  53     static final int[] SENSOR_TO_OPACITY = new int[]{-1, 10, 0, 0, 0};
  54
  55     DozeServiceFake mServiceFake;
  56     DozeScreenBrightness mScreen;
  57     FakeSensorManager.FakeGenericSensor mSensor;
  58     FakeSensorManager mSensorManager;
  59     DozeHostFake mHostFake;
  60
  61     @Before
  62     public void setUp() throws Exception {
  63         mServiceFake = new DozeServiceFake();
  64         mHostFake = new DozeHostFake();
  65         mSensorManager = new FakeSensorManager(mContext);
  66         mSensor = mSensorManager.getFakeLightSensor();
  67         mScreen = new DozeScreenBrightness(mContext, mServiceFake, mSensorManager,
  68                 mSensor.getSensor(), mHostFake, null /* handler */,
  69                 DEFAULT_BRIGHTNESS, SENSOR_TO_BRIGHTNESS, SENSOR_TO_OPACITY);
  70     }
  71
  72     @Test
  73     public void testInitialize_setsScreenBrightnessToValidValue() throws Exception {
  74         mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
  75
  76         assertEquals(DEFAULT_BRIGHTNESS, mServiceFake.screenBrightness);
  77         assertTrue(mServiceFake.screenBrightness <= PowerManager.BRIGHTNESS_ON);
  78     }
  79
  80     @Test
  81     public void testAod_usesLightSensor() throws Exception {
  82         mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
  83         mScreen.transitionTo(INITIALIZED, DOZE_AOD);
  84
  85         mSensor.sendSensorEvent(3);
  86
  87         assertEquals(3, mServiceFake.screenBrightness);
  88     }
  89
  90     @Test
  91     public void testPausingAod_doesntPauseLightSensor() throws Exception {
  92         mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
  93         mScreen.transitionTo(INITIALIZED, DOZE_AOD);
  94
  95         mSensor.sendSensorEvent(1);
  96
  97         mScreen.transitionTo(DOZE_AOD, DOZE_AOD_PAUSING);
  98         mScreen.transitionTo(DOZE_AOD_PAUSING, DOZE_AOD_PAUSED);
  99
 100         mSensor.sendSensorEvent(2);
 101
 102         assertEquals(2, mServiceFake.screenBrightness);
 103     }
 104
 105     @Test
 106     public void testPausingAod_doesNotResetBrightness() throws Exception {
 107         mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
 108         mScreen.transitionTo(INITIALIZED, DOZE_AOD);
 109
 110         mSensor.sendSensorEvent(1);
 111
 112         mScreen.transitionTo(DOZE_AOD, DOZE_AOD_PAUSING);
 113         mScreen.transitionTo(DOZE_AOD_PAUSING, DOZE_AOD_PAUSED);
 114
 115         assertEquals(1, mServiceFake.screenBrightness);
 116     }
 117
 118     @Test
 119     public void testPulsing_usesLightSensor() throws Exception {
 120         mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
 121         mScreen.transitionTo(INITIALIZED, DOZE);
 122         mScreen.transitionTo(DOZE, DOZE_REQUEST_PULSE);
 123
 124         mSensor.sendSensorEvent(1);
 125
 126         assertEquals(1, mServiceFake.screenBrightness);
 127     }
 128
 129     @Test
 130     public void testDozingAfterPulsing_pausesLightSensor() throws Exception {
 131         mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
 132         mScreen.transitionTo(INITIALIZED, DOZE);
 133         mScreen.transitionTo(DOZE, DOZE_REQUEST_PULSE);
 134         mScreen.transitionTo(DOZE_REQUEST_PULSE, DOZE_PULSING);
 135         mScreen.transitionTo(DOZE_PULSING, DOZE_PULSE_DONE);
 136         mScreen.transitionTo(DOZE_PULSE_DONE, DOZE);
 137
 138         mSensor.sendSensorEvent(1);
 139
 140         assertEquals(DEFAULT_BRIGHTNESS, mServiceFake.screenBrightness);
 141     }
 142
 143     @Test
 144     public void testNullSensor() throws Exception {
 145         mScreen = new DozeScreenBrightness(mContext, mServiceFake, mSensorManager,
 146                 null /* sensor */, mHostFake, null /* handler */,
 147                 DEFAULT_BRIGHTNESS, SENSOR_TO_BRIGHTNESS, SENSOR_TO_OPACITY);
 148
 149         mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
 150         mScreen.transitionTo(INITIALIZED, DOZE_AOD);
 151         mScreen.transitionTo(DOZE_AOD, DOZE_AOD_PAUSING);
 152         mScreen.transitionTo(DOZE_AOD_PAUSING, DOZE_AOD_PAUSED);
 153     }
 154
 155     @Test
 156     public void testNoBrightnessDeliveredAfterFinish() throws Exception {
 157         mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
 158         mScreen.transitionTo(INITIALIZED, DOZE_AOD);
 159         mScreen.transitionTo(DOZE_AOD, FINISH);
 160
 161         mSensor.sendSensorEvent(1);
 162
 163         assertNotEquals(1, mServiceFake.screenBrightness);
 164     }
 165
 166     @Test
 167     public void testNonPositiveBrightness_keepsPreviousBrightnessAndScrim() throws Exception {
 168         mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
 169         mScreen.transitionTo(INITIALIZED, DOZE_AOD);
 170
 171         mSensor.sendSensorEvent(1);
 172         mSensor.sendSensorEvent(0);
 173
 174         assertEquals(1, mServiceFake.screenBrightness);
 175         assertEquals(10/255f, mHostFake.aodDimmingScrimOpacity, 0.001f /* delta */);
 176     }
 177
 178     @Test
 179     public void pausingAod_softBlanks() throws Exception {
 180         mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
 181         mScreen.transitionTo(INITIALIZED, DOZE_AOD);
 182
 183         mSensor.sendSensorEvent(2);
 184
 185         mScreen.transitionTo(DOZE_AOD, DOZE_AOD_PAUSING);
 186         mScreen.transitionTo(DOZE_AOD_PAUSING, DOZE_AOD_PAUSED);
 187
 188         assertEquals(1f, mHostFake.aodDimmingScrimOpacity, 0.001f /* delta */);
 189
 190         mSensor.sendSensorEvent(0);
 191         assertEquals(1f, mHostFake.aodDimmingScrimOpacity, 0.001f /* delta */);
 192
 193         mScreen.transitionTo(DOZE_AOD_PAUSED, DOZE_AOD);
 194         assertEquals(1f, mHostFake.aodDimmingScrimOpacity, 0.001f /* delta */);
 195     }
 196
 197     @Test
 198     public void pausingAod_softBlanks_withSpuriousSensorDuringPause() throws Exception {
 199         mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
 200         mScreen.transitionTo(INITIALIZED, DOZE_AOD);
 201         mScreen.transitionTo(DOZE_AOD, DOZE_AOD_PAUSING);
 202         mScreen.transitionTo(DOZE_AOD_PAUSING, DOZE_AOD_PAUSED);
 203
 204         mSensor.sendSensorEvent(1);
 205         assertEquals(1f, mHostFake.aodDimmingScrimOpacity, 0.001f /* delta */);
 206     }
 207
 208     @Test
 209     public void pausingAod_unblanksAfterSensor() throws Exception {
 210         mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
 211         mScreen.transitionTo(INITIALIZED, DOZE_AOD);
 212
 213         mSensor.sendSensorEvent(2);
 214
 215         mScreen.transitionTo(DOZE_AOD, DOZE_AOD_PAUSING);
 216         mScreen.transitionTo(DOZE_AOD_PAUSING, DOZE_AOD_PAUSED);
 217
 218         mSensor.sendSensorEvent(0);
 219
 220         mScreen.transitionTo(DOZE_AOD_PAUSED, DOZE_AOD);
 221
 222         mSensor.sendSensorEvent(2);
 223
 224         assertEquals(0f, mHostFake.aodDimmingScrimOpacity, 0.001f /* delta */);
 225     }
 226
 227     @Test
 228     public void pausingAod_unblanksIfSensorWasAlwaysReady() throws Exception {
 229         mScreen.transitionTo(UNINITIALIZED, INITIALIZED);
 230         mScreen.transitionTo(INITIALIZED, DOZE_AOD);
 231
 232         mSensor.sendSensorEvent(2);
 233
 234         mScreen.transitionTo(DOZE_AOD, DOZE_AOD_PAUSING);
 235         mScreen.transitionTo(DOZE_AOD_PAUSING, DOZE_AOD_PAUSED);
 236         mScreen.transitionTo(DOZE_AOD_PAUSED, DOZE_AOD);
 237
 238         assertEquals(0f, mHostFake.aodDimmingScrimOpacity, 0.001f /* delta */);
 239     }
 240 }