blob: 9c558748697adc883117fb72bf115094bc04181c [file] [log] [blame]
Lucas Dupin9e3fa102017-11-08 17:16:55 -08001/*
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
17package com.android.systemui.statusbar.phone;
18
Lucas Dupin82aa1632017-12-13 00:13:57 -080019import static com.android.systemui.statusbar.phone.ScrimController.VISIBILITY_FULLY_OPAQUE;
20import static com.android.systemui.statusbar.phone.ScrimController.VISIBILITY_FULLY_TRANSPARENT;
21import static com.android.systemui.statusbar.phone.ScrimController.VISIBILITY_SEMI_TRANSPARENT;
22
23import static org.mockito.ArgumentMatchers.any;
24import static org.mockito.ArgumentMatchers.anyInt;
25import static org.mockito.ArgumentMatchers.anyLong;
Lucas Dupin9e3fa102017-11-08 17:16:55 -080026import static org.mockito.Mockito.mock;
27import static org.mockito.Mockito.never;
Lucas Dupin82aa1632017-12-13 00:13:57 -080028import static org.mockito.Mockito.reset;
Lucas Dupin067136c2018-03-27 18:03:25 -070029import static org.mockito.Mockito.spy;
Lucas Dupin9e3fa102017-11-08 17:16:55 -080030import static org.mockito.Mockito.verify;
Lucas Dupineea53b32017-12-18 13:47:14 -080031import static org.mockito.Mockito.verifyZeroInteractions;
Lucas Dupin9e3fa102017-11-08 17:16:55 -080032import static org.mockito.Mockito.when;
33
34import android.animation.Animator;
Lucas Dupin80a3fcc2018-02-07 10:49:55 -080035import android.animation.ValueAnimator;
Lucas Dupin82aa1632017-12-13 00:13:57 -080036import android.app.AlarmManager;
Lucas Dupin9e3fa102017-11-08 17:16:55 -080037import android.graphics.Color;
38import android.os.Handler;
39import android.os.Looper;
40import android.support.test.filters.SmallTest;
41import android.testing.AndroidTestingRunner;
42import android.testing.TestableLooper;
43import android.view.View;
44
shawnlin317db372018-04-09 19:49:48 +080045import com.android.internal.colorextraction.ColorExtractor.GradientColors;
Yohei Yukawa795f0102018-04-13 14:55:30 -070046import com.android.internal.util.function.TriConsumer;
Lucas Dupin9e3fa102017-11-08 17:16:55 -080047import com.android.systemui.SysuiTestCase;
48import com.android.systemui.statusbar.ScrimView;
49import com.android.systemui.util.wakelock.WakeLock;
50import com.android.systemui.utils.os.FakeHandler;
51
52import org.junit.Assert;
53import org.junit.Before;
54import org.junit.Test;
55import org.junit.runner.RunWith;
56
Lucas Dupin78949b82018-04-03 18:54:39 -070057import java.util.Arrays;
58import java.util.HashSet;
Lucas Dupin9e3fa102017-11-08 17:16:55 -080059import java.util.function.Consumer;
60
61@RunWith(AndroidTestingRunner.class)
62@TestableLooper.RunWithLooper
63@SmallTest
64public class ScrimControllerTest extends SysuiTestCase {
65
66 private SynchronousScrimController mScrimController;
67 private ScrimView mScrimBehind;
68 private ScrimView mScrimInFront;
Yohei Yukawa795f0102018-04-13 14:55:30 -070069 private ScrimState mScrimState;
shawnlin317db372018-04-09 19:49:48 +080070 private float mScrimBehindAlpha;
71 private GradientColors mScrimInFrontColor;
Lucas Dupin82aa1632017-12-13 00:13:57 -080072 private int mScrimVisibility;
Lucas Dupin9e3fa102017-11-08 17:16:55 -080073 private DozeParameters mDozeParamenters;
74 private WakeLock mWakeLock;
75 private boolean mAlwaysOnEnabled;
Lucas Dupin82aa1632017-12-13 00:13:57 -080076 private AlarmManager mAlarmManager;
Lucas Dupin9e3fa102017-11-08 17:16:55 -080077
Yohei Yukawa795f0102018-04-13 14:55:30 -070078
Lucas Dupin9e3fa102017-11-08 17:16:55 -080079 @Before
80 public void setup() {
Lucas Dupin067136c2018-03-27 18:03:25 -070081 mScrimBehind = spy(new ScrimView(getContext()));
Lucas Dupin9e3fa102017-11-08 17:16:55 -080082 mScrimInFront = new ScrimView(getContext());
Lucas Dupin9e3fa102017-11-08 17:16:55 -080083 mWakeLock = mock(WakeLock.class);
Lucas Dupin82aa1632017-12-13 00:13:57 -080084 mAlarmManager = mock(AlarmManager.class);
Lucas Dupin9e3fa102017-11-08 17:16:55 -080085 mAlwaysOnEnabled = true;
Lucas Dupin9e3fa102017-11-08 17:16:55 -080086 mDozeParamenters = mock(DozeParameters.class);
87 when(mDozeParamenters.getAlwaysOn()).thenAnswer(invocation -> mAlwaysOnEnabled);
Lucas Dupin43d0d732017-11-16 11:23:49 -080088 when(mDozeParamenters.getDisplayNeedsBlanking()).thenReturn(true);
shawnlin317db372018-04-09 19:49:48 +080089 mScrimController = new SynchronousScrimController(mScrimBehind, mScrimInFront,
Yohei Yukawa795f0102018-04-13 14:55:30 -070090 (scrimState, scrimBehindAlpha, scrimInFrontColor) -> {
91 mScrimState = scrimState;
92 mScrimBehindAlpha = scrimBehindAlpha;
93 mScrimInFrontColor = scrimInFrontColor;
94 },
95 visible -> mScrimVisibility = visible, mDozeParamenters, mAlarmManager);
Lucas Dupinf8463ee2018-06-11 16:18:15 -070096 mScrimController.setHasBackdrop(false);
Lucas Dupin9e3fa102017-11-08 17:16:55 -080097 }
98
99 @Test
100 public void initialState() {
101 Assert.assertEquals("ScrimController should start initialized",
102 mScrimController.getState(), ScrimState.UNINITIALIZED);
103 }
104
105 @Test
106 public void transitionToKeyguard() {
107 mScrimController.transitionTo(ScrimState.KEYGUARD);
108 mScrimController.finishAnimationsImmediately();
109 // Front scrim should be transparent
110 // Back scrim should be visible without tint
Lucas Dupin82aa1632017-12-13 00:13:57 -0800111 assertScrimVisibility(VISIBILITY_FULLY_TRANSPARENT, VISIBILITY_SEMI_TRANSPARENT);
Lucas Dupin9e3fa102017-11-08 17:16:55 -0800112 assertScrimTint(mScrimBehind, false /* tinted */);
113 }
114
115 @Test
Lucas Dupin7517b5d2017-08-22 12:51:25 -0700116 public void transitionToAod_withRegularWallpaper() {
117 mScrimController.transitionTo(ScrimState.AOD);
118 mScrimController.finishAnimationsImmediately();
119 // Front scrim should be transparent
120 // Back scrim should be visible with tint
Lucas Dupin82aa1632017-12-13 00:13:57 -0800121 assertScrimVisibility(VISIBILITY_FULLY_TRANSPARENT, VISIBILITY_FULLY_OPAQUE);
Lucas Dupin7517b5d2017-08-22 12:51:25 -0700122 assertScrimTint(mScrimBehind, true /* tinted */);
123 assertScrimTint(mScrimInFront, true /* tinted */);
124 }
125
126 @Test
127 public void transitionToAod_withAodWallpaper() {
128 mScrimController.setWallpaperSupportsAmbientMode(true);
129 mScrimController.transitionTo(ScrimState.AOD);
130 mScrimController.finishAnimationsImmediately();
131 // Front scrim should be transparent
132 // Back scrim should be transparent
Lucas Dupin82aa1632017-12-13 00:13:57 -0800133 assertScrimVisibility(VISIBILITY_FULLY_TRANSPARENT, VISIBILITY_FULLY_TRANSPARENT);
134
135 // Move on to PULSING and check if the back scrim is still transparent
136 mScrimController.transitionTo(ScrimState.PULSING);
137 mScrimController.finishAnimationsImmediately();
138 assertScrimVisibility(VISIBILITY_FULLY_TRANSPARENT, VISIBILITY_FULLY_TRANSPARENT);
Lucas Dupin7517b5d2017-08-22 12:51:25 -0700139 }
140
141 @Test
142 public void transitionToAod_withAodWallpaperAndLockScreenWallpaper() {
Lucas Dupinf8463ee2018-06-11 16:18:15 -0700143 mScrimController.setHasBackdrop(true);
Lucas Dupin7517b5d2017-08-22 12:51:25 -0700144 mScrimController.setWallpaperSupportsAmbientMode(true);
Lucas Dupin9e3fa102017-11-08 17:16:55 -0800145 mScrimController.transitionTo(ScrimState.AOD);
146 mScrimController.finishAnimationsImmediately();
147 // Front scrim should be transparent
148 // Back scrim should be visible with tint
Lucas Dupin82aa1632017-12-13 00:13:57 -0800149 assertScrimVisibility(VISIBILITY_FULLY_TRANSPARENT, VISIBILITY_FULLY_OPAQUE);
Lucas Dupin9e3fa102017-11-08 17:16:55 -0800150 assertScrimTint(mScrimBehind, true /* tinted */);
151 assertScrimTint(mScrimInFront, true /* tinted */);
152 }
153
154 @Test
Lucas Dupin9bee5822018-07-09 14:32:53 -0700155 public void setHasBackdrop_withAodWallpaperAndAlbumArt() {
156 mScrimController.setWallpaperSupportsAmbientMode(true);
157 mScrimController.transitionTo(ScrimState.AOD);
158 mScrimController.finishAnimationsImmediately();
159 mScrimController.setHasBackdrop(true);
160 mScrimController.finishAnimationsImmediately();
161 // Front scrim should be transparent
162 // Back scrim should be visible with tint
163 assertScrimVisibility(VISIBILITY_FULLY_TRANSPARENT, VISIBILITY_FULLY_OPAQUE);
164 assertScrimTint(mScrimBehind, true /* tinted */);
165 assertScrimTint(mScrimInFront, true /* tinted */);
166 }
167
168 @Test
Michael Wrightcae88752018-04-16 23:13:54 +0100169 public void transitionToAod_withFrontAlphaUpdates() {
170 // Assert that setting the AOD front scrim alpha doesn't take effect in a non-AOD state.
171 mScrimController.transitionTo(ScrimState.KEYGUARD);
172 mScrimController.setAodFrontScrimAlpha(0.5f);
173 mScrimController.finishAnimationsImmediately();
174 // Front scrim should be transparent
175 // Back scrim should be visible without tint
176 assertScrimVisibility(VISIBILITY_FULLY_TRANSPARENT, VISIBILITY_SEMI_TRANSPARENT);
177
178 // ... but that it does take effect once we enter the AOD state.
179 mScrimController.transitionTo(ScrimState.AOD);
180 mScrimController.finishAnimationsImmediately();
181 // Front scrim should be semi-transparent
182 // Back scrim should be visible
183 assertScrimVisibility(VISIBILITY_SEMI_TRANSPARENT, VISIBILITY_FULLY_OPAQUE);
184
185 // ... and that if we set it while we're in AOD, it does take immediate effect.
186 mScrimController.setAodFrontScrimAlpha(1f);
187 assertScrimVisibility(VISIBILITY_FULLY_OPAQUE, VISIBILITY_FULLY_OPAQUE);
188
189 // ... and make sure we recall the previous front scrim alpha even if we transition away
190 // for a bit.
191 mScrimController.transitionTo(ScrimState.UNLOCKED);
192 mScrimController.transitionTo(ScrimState.AOD);
193 mScrimController.finishAnimationsImmediately();
194 assertScrimVisibility(VISIBILITY_FULLY_OPAQUE, VISIBILITY_FULLY_OPAQUE);
195
Lucas Dupin69bda602018-05-18 17:24:52 -0700196 // ... and alpha updates should be completely ignored if always_on is off.
197 // Passing it forward would mess up the wake-up transition.
198 mAlwaysOnEnabled = false;
199 mScrimController.transitionTo(ScrimState.UNLOCKED);
200 mScrimController.transitionTo(ScrimState.AOD);
201 mScrimController.finishAnimationsImmediately();
202 mScrimController.setAodFrontScrimAlpha(0.3f);
203 Assert.assertEquals(ScrimState.AOD.getFrontAlpha(), mScrimInFront.getViewAlpha(), 0.001f);
204 Assert.assertNotEquals(0.3f, mScrimInFront.getViewAlpha(), 0.001f);
205
Michael Wrightcae88752018-04-16 23:13:54 +0100206 // Reset value since enums are static.
207 mScrimController.setAodFrontScrimAlpha(0f);
208 }
209
210 @Test
Lucas Dupin9e3fa102017-11-08 17:16:55 -0800211 public void transitionToPulsing() {
Lucas Dupin82aa1632017-12-13 00:13:57 -0800212 // Pre-condition
213 // Need to go to AoD first because PULSING doesn't change
214 // the back scrim opacity - otherwise it would hide AoD wallpapers.
215 mScrimController.setWallpaperSupportsAmbientMode(false);
216 mScrimController.transitionTo(ScrimState.AOD);
217 mScrimController.finishAnimationsImmediately();
218 assertScrimVisibility(VISIBILITY_FULLY_TRANSPARENT, VISIBILITY_FULLY_OPAQUE);
219
Lucas Dupin9e3fa102017-11-08 17:16:55 -0800220 mScrimController.transitionTo(ScrimState.PULSING);
221 mScrimController.finishAnimationsImmediately();
222 // Front scrim should be transparent
223 // Back scrim should be visible with tint
224 // Pulse callback should have been invoked
Lucas Dupin82aa1632017-12-13 00:13:57 -0800225 assertScrimVisibility(VISIBILITY_FULLY_TRANSPARENT, VISIBILITY_FULLY_OPAQUE);
Lucas Dupin9e3fa102017-11-08 17:16:55 -0800226 assertScrimTint(mScrimBehind, true /* tinted */);
227 }
228
229 @Test
Lucas Dupinbc9aac12018-03-04 20:18:15 -0800230 public void transitionToKeyguardBouncer() {
Lucas Dupin9e3fa102017-11-08 17:16:55 -0800231 mScrimController.transitionTo(ScrimState.BOUNCER);
232 mScrimController.finishAnimationsImmediately();
233 // Front scrim should be transparent
234 // Back scrim should be visible without tint
Lucas Dupinbc9aac12018-03-04 20:18:15 -0800235 assertScrimVisibility(VISIBILITY_FULLY_TRANSPARENT, VISIBILITY_SEMI_TRANSPARENT);
236 assertScrimTint(mScrimBehind, false /* tinted */);
237 }
238
239 @Test
240 public void transitionToBouncer() {
Lucas Dupin05726cd2018-03-13 14:00:24 -0700241 mScrimController.transitionTo(ScrimState.BOUNCER_SCRIMMED);
Lucas Dupinbc9aac12018-03-04 20:18:15 -0800242 mScrimController.finishAnimationsImmediately();
243 // Front scrim should be transparent
244 // Back scrim should be visible without tint
245 assertScrimVisibility(VISIBILITY_SEMI_TRANSPARENT, VISIBILITY_FULLY_TRANSPARENT);
Lucas Dupin9e3fa102017-11-08 17:16:55 -0800246 assertScrimTint(mScrimBehind, false /* tinted */);
247 }
248
249 @Test
250 public void transitionToUnlocked() {
Lucas Dupin80a3fcc2018-02-07 10:49:55 -0800251 mScrimController.setPanelExpansion(0f);
Lucas Dupin9e3fa102017-11-08 17:16:55 -0800252 mScrimController.transitionTo(ScrimState.UNLOCKED);
253 mScrimController.finishAnimationsImmediately();
254 // Front scrim should be transparent
255 // Back scrim should be transparent
Lucas Dupin82aa1632017-12-13 00:13:57 -0800256 assertScrimVisibility(VISIBILITY_FULLY_TRANSPARENT, VISIBILITY_FULLY_TRANSPARENT);
Lucas Dupin9e3fa102017-11-08 17:16:55 -0800257 assertScrimTint(mScrimBehind, false /* tinted */);
258 assertScrimTint(mScrimInFront, false /* tinted */);
259
260 // Back scrim should be visible after start dragging
261 mScrimController.setPanelExpansion(0.5f);
Lucas Dupin82aa1632017-12-13 00:13:57 -0800262 assertScrimVisibility(VISIBILITY_FULLY_TRANSPARENT, VISIBILITY_SEMI_TRANSPARENT);
Lucas Dupin9e3fa102017-11-08 17:16:55 -0800263 }
264
265 @Test
Yohei Yukawa795f0102018-04-13 14:55:30 -0700266 public void scrimStateCallback() {
267 mScrimController.transitionTo(ScrimState.UNLOCKED);
268 mScrimController.finishAnimationsImmediately();
269 Assert.assertEquals(mScrimState, ScrimState.UNLOCKED);
270
271 mScrimController.transitionTo(ScrimState.BOUNCER);
272 mScrimController.finishAnimationsImmediately();
273 Assert.assertEquals(mScrimState, ScrimState.BOUNCER);
274
275 mScrimController.transitionTo(ScrimState.BOUNCER_SCRIMMED);
276 mScrimController.finishAnimationsImmediately();
277 Assert.assertEquals(mScrimState, ScrimState.BOUNCER_SCRIMMED);
278 }
279
280 @Test
shawnlin317db372018-04-09 19:49:48 +0800281 public void panelExpansion() {
282 mScrimController.setPanelExpansion(0f);
283 mScrimController.setPanelExpansion(0.5f);
284 mScrimController.transitionTo(ScrimState.UNLOCKED);
285 mScrimController.finishAnimationsImmediately();
286
287 reset(mScrimBehind);
288 mScrimController.setPanelExpansion(0f);
289 mScrimController.setPanelExpansion(1.0f);
290 mScrimController.onPreDraw();
291
292 Assert.assertEquals("Scrim alpha should change after setPanelExpansion",
293 mScrimBehindAlpha, mScrimBehind.getViewAlpha(), 0.01f);
294
295 mScrimController.setPanelExpansion(0f);
296 mScrimController.onPreDraw();
297
298 Assert.assertEquals("Scrim alpha should change after setPanelExpansion",
299 mScrimBehindAlpha, mScrimBehind.getViewAlpha(), 0.01f);
300 }
301
302 @Test
Lucas Dupin67f02632018-03-12 11:08:31 -0700303 public void panelExpansionAffectsAlpha() {
304 mScrimController.setPanelExpansion(0f);
305 mScrimController.setPanelExpansion(0.5f);
306 mScrimController.transitionTo(ScrimState.UNLOCKED);
307 mScrimController.finishAnimationsImmediately();
308
309 final float scrimAlpha = mScrimBehind.getViewAlpha();
Lucas Dupin067136c2018-03-27 18:03:25 -0700310 reset(mScrimBehind);
Lucas Dupin67f02632018-03-12 11:08:31 -0700311 mScrimController.setExpansionAffectsAlpha(false);
312 mScrimController.setPanelExpansion(0.8f);
Lucas Dupin067136c2018-03-27 18:03:25 -0700313 verifyZeroInteractions(mScrimBehind);
Lucas Dupin67f02632018-03-12 11:08:31 -0700314 Assert.assertEquals("Scrim opacity shouldn't change when setExpansionAffectsAlpha "
315 + "is false", scrimAlpha, mScrimBehind.getViewAlpha(), 0.01f);
316
317 mScrimController.setExpansionAffectsAlpha(true);
318 mScrimController.setPanelExpansion(0.1f);
319 Assert.assertNotEquals("Scrim opacity should change when setExpansionAffectsAlpha "
320 + "is true", scrimAlpha, mScrimBehind.getViewAlpha(), 0.01f);
321 }
322
323 @Test
Lucas Dupin9e3fa102017-11-08 17:16:55 -0800324 public void transitionToUnlockedFromAod() {
325 // Simulate unlock with fingerprint
326 mScrimController.transitionTo(ScrimState.AOD);
Lucas Dupin80a3fcc2018-02-07 10:49:55 -0800327 mScrimController.setPanelExpansion(0f);
Lucas Dupin9e3fa102017-11-08 17:16:55 -0800328 mScrimController.finishAnimationsImmediately();
329 mScrimController.transitionTo(ScrimState.UNLOCKED);
330 // Immediately tinted after the transition starts
331 assertScrimTint(mScrimInFront, true /* tinted */);
332 assertScrimTint(mScrimBehind, true /* tinted */);
333 mScrimController.finishAnimationsImmediately();
334 // Front scrim should be transparent
335 // Back scrim should be transparent
336 // Neither scrims should be tinted anymore after the animation.
Lucas Dupin82aa1632017-12-13 00:13:57 -0800337 assertScrimVisibility(VISIBILITY_FULLY_TRANSPARENT, VISIBILITY_FULLY_TRANSPARENT);
Lucas Dupin9e3fa102017-11-08 17:16:55 -0800338 assertScrimTint(mScrimInFront, false /* tinted */);
339 assertScrimTint(mScrimBehind, false /* tinted */);
340 }
341
342 @Test
Lucas Dupinea0116e2018-04-05 10:09:29 -0700343 public void scrimBlanksBeforeLeavingAod() {
Lucas Dupin9e3fa102017-11-08 17:16:55 -0800344 // Simulate unlock with fingerprint
345 mScrimController.transitionTo(ScrimState.AOD);
346 mScrimController.finishAnimationsImmediately();
347 mScrimController.transitionTo(ScrimState.UNLOCKED,
348 new ScrimController.Callback() {
349 @Override
350 public void onDisplayBlanked() {
351 // Front scrim should be black in the middle of the transition
352 Assert.assertTrue("Scrim should be visible during transition. Alpha: "
353 + mScrimInFront.getViewAlpha(), mScrimInFront.getViewAlpha() > 0);
354 assertScrimTint(mScrimInFront, true /* tinted */);
Lucas Dupin82aa1632017-12-13 00:13:57 -0800355 Assert.assertSame("Scrim should be visible during transition.",
356 mScrimVisibility, VISIBILITY_FULLY_OPAQUE);
Lucas Dupin9e3fa102017-11-08 17:16:55 -0800357 }
358 });
359 mScrimController.finishAnimationsImmediately();
360 }
361
362 @Test
Lucas Dupineb840ea2018-06-01 00:28:58 -0700363 public void scrimBlanksWhenUnlockingFromPulse() {
364 boolean[] blanked = {false};
365 // Simulate unlock with fingerprint
366 mScrimController.transitionTo(ScrimState.PULSING);
367 mScrimController.finishAnimationsImmediately();
368 mScrimController.transitionTo(ScrimState.UNLOCKED,
369 new ScrimController.Callback() {
370 @Override
371 public void onDisplayBlanked() {
372 blanked[0] = true;
373 }
374 });
375 mScrimController.finishAnimationsImmediately();
376 Assert.assertTrue("Scrim should blank when unlocking from pulse.", blanked[0]);
377 }
378
379 @Test
Lucas Dupin9e3fa102017-11-08 17:16:55 -0800380 public void testScrimCallback() {
381 int[] callOrder = {0, 0, 0};
382 int[] currentCall = {0};
383 mScrimController.transitionTo(ScrimState.AOD, new ScrimController.Callback() {
384 @Override
385 public void onStart() {
386 callOrder[0] = ++currentCall[0];
387 }
388
389 @Override
390 public void onDisplayBlanked() {
391 callOrder[1] = ++currentCall[0];
392 }
393
394 @Override
395 public void onFinished() {
396 callOrder[2] = ++currentCall[0];
397 }
398 });
399 mScrimController.finishAnimationsImmediately();
400 Assert.assertEquals("onStart called in wrong order", 1, callOrder[0]);
401 Assert.assertEquals("onDisplayBlanked called in wrong order", 2, callOrder[1]);
402 Assert.assertEquals("onFinished called in wrong order", 3, callOrder[2]);
403 }
404
405 @Test
406 public void testScrimCallbacksWithoutAmbientDisplay() {
407 mAlwaysOnEnabled = false;
408 testScrimCallback();
409 }
410
411 @Test
412 public void testScrimCallbackCancelled() {
413 boolean[] cancelledCalled = {false};
414 mScrimController.transitionTo(ScrimState.AOD, new ScrimController.Callback() {
415 @Override
416 public void onCancelled() {
417 cancelledCalled[0] = true;
418 }
419 });
420 mScrimController.transitionTo(ScrimState.PULSING);
421 Assert.assertTrue("onCancelled should have been called", cancelledCalled[0]);
422 }
423
424 @Test
Lucas Dupineea53b32017-12-18 13:47:14 -0800425 public void testHoldsWakeLock_whenAOD() {
Lucas Dupin9e3fa102017-11-08 17:16:55 -0800426 mScrimController.transitionTo(ScrimState.AOD);
Lucas Dupin82aa1632017-12-13 00:13:57 -0800427 verify(mWakeLock).acquire();
Lucas Dupin9e3fa102017-11-08 17:16:55 -0800428 verify(mWakeLock, never()).release();
429 mScrimController.finishAnimationsImmediately();
Lucas Dupin82aa1632017-12-13 00:13:57 -0800430 verify(mWakeLock).release();
Lucas Dupin9e3fa102017-11-08 17:16:55 -0800431 }
432
Lucas Dupin19aba8e2017-12-11 12:42:26 -0800433 @Test
Lucas Dupineea53b32017-12-18 13:47:14 -0800434 public void testDoesNotHoldWakeLock_whenUnlocking() {
435 mScrimController.transitionTo(ScrimState.UNLOCKED);
436 mScrimController.finishAnimationsImmediately();
437 verifyZeroInteractions(mWakeLock);
438 }
439
440 @Test
Lucas Dupin19aba8e2017-12-11 12:42:26 -0800441 public void testCallbackInvokedOnSameStateTransition() {
442 mScrimController.transitionTo(ScrimState.UNLOCKED);
443 mScrimController.finishAnimationsImmediately();
444 ScrimController.Callback callback = mock(ScrimController.Callback.class);
445 mScrimController.transitionTo(ScrimState.UNLOCKED, callback);
Lucas Dupin82aa1632017-12-13 00:13:57 -0800446 verify(callback).onFinished();
447 }
448
449 @Test
450 public void testHoldsAodWallpaperAnimationLock() {
451 // Pre-conditions
452 mScrimController.transitionTo(ScrimState.AOD);
453 mScrimController.finishAnimationsImmediately();
454 reset(mWakeLock);
455
456 mScrimController.onHideWallpaperTimeout();
457 verify(mWakeLock).acquire();
458 verify(mWakeLock, never()).release();
459 mScrimController.finishAnimationsImmediately();
460 verify(mWakeLock).release();
461 }
462
463 @Test
Lucas Dupin16cfe452018-02-08 13:14:50 -0800464 public void testWillHideAodWallpaper() {
Lucas Dupin82aa1632017-12-13 00:13:57 -0800465 mScrimController.setWallpaperSupportsAmbientMode(true);
466 mScrimController.transitionTo(ScrimState.AOD);
467 verify(mAlarmManager).setExact(anyInt(), anyLong(), any(), any(), any());
468 mScrimController.transitionTo(ScrimState.KEYGUARD);
469 verify(mAlarmManager).cancel(any(AlarmManager.OnAlarmListener.class));
Lucas Dupin19aba8e2017-12-11 12:42:26 -0800470 }
471
Lucas Dupin80a3fcc2018-02-07 10:49:55 -0800472 @Test
473 public void testConservesExpansionOpacityAfterTransition() {
474 mScrimController.transitionTo(ScrimState.UNLOCKED);
475 mScrimController.setPanelExpansion(0.5f);
476 mScrimController.finishAnimationsImmediately();
477
478 final float expandedAlpha = mScrimBehind.getViewAlpha();
479
480 mScrimController.transitionTo(ScrimState.BRIGHTNESS_MIRROR);
481 mScrimController.finishAnimationsImmediately();
482 mScrimController.transitionTo(ScrimState.UNLOCKED);
483 mScrimController.finishAnimationsImmediately();
484
485 Assert.assertEquals("Scrim expansion opacity wasn't conserved when transitioning back",
486 expandedAlpha, mScrimBehind.getViewAlpha(), 0.01f);
487 }
488
489 @Test
490 public void cancelsOldAnimationBeforeBlanking() {
491 mScrimController.transitionTo(ScrimState.AOD);
492 mScrimController.finishAnimationsImmediately();
493 // Consume whatever value we had before
494 mScrimController.wasAnimationJustCancelled();
495
496 mScrimController.transitionTo(ScrimState.KEYGUARD);
497 mScrimController.finishAnimationsImmediately();
498 Assert.assertTrue(mScrimController.wasAnimationJustCancelled());
499 }
500
Lucas Dupinb380c882018-02-25 21:57:17 -0800501 /**
502 * Number of visible notifications affects scrim opacity.
503 */
504 @Test
505 public void testNotificationDensity() {
506 mScrimController.transitionTo(ScrimState.KEYGUARD);
507 mScrimController.finishAnimationsImmediately();
508
509 mScrimController.setNotificationCount(0);
510 mScrimController.finishAnimationsImmediately();
511 Assert.assertEquals("lower density when no notifications",
512 ScrimController.GRADIENT_SCRIM_ALPHA, mScrimBehind.getViewAlpha(), 0.01f);
513
514 mScrimController.setNotificationCount(3);
515 mScrimController.finishAnimationsImmediately();
516 Assert.assertEquals("stronger density when notifications are visible",
517 ScrimController.GRADIENT_SCRIM_ALPHA_BUSY, mScrimBehind.getViewAlpha(), 0.01f);
518 }
519
520 /**
521 * Moving from/to states conserves old notification density.
522 */
523 @Test
524 public void testConservesNotificationDensity() {
525 testConservesNotificationDensity(0 /* count */, ScrimController.GRADIENT_SCRIM_ALPHA);
526 testConservesNotificationDensity(3 /* count */, ScrimController.GRADIENT_SCRIM_ALPHA_BUSY);
527 }
528
Lucas Dupin3daf3b02018-02-27 17:23:41 -0800529 @Test
Lucas Dupin38962d72018-03-14 12:41:39 -0700530 public void testScrimFocus() {
531 mScrimController.transitionTo(ScrimState.AOD);
532 Assert.assertFalse("Should not be focusable on AOD", mScrimBehind.isFocusable());
533 Assert.assertFalse("Should not be focusable on AOD", mScrimInFront.isFocusable());
534
535 mScrimController.transitionTo(ScrimState.KEYGUARD);
536 Assert.assertTrue("Should be focusable on keyguard", mScrimBehind.isFocusable());
537 Assert.assertTrue("Should be focusable on keyguard", mScrimInFront.isFocusable());
538 }
539
Lucas Dupind5107302018-03-19 15:30:29 -0700540 @Test
541 public void testHidesShowWhenLockedActivity() {
542 mScrimController.setWallpaperSupportsAmbientMode(true);
543 mScrimController.setKeyguardOccluded(true);
544 mScrimController.transitionTo(ScrimState.AOD);
545 mScrimController.finishAnimationsImmediately();
546 assertScrimVisibility(VISIBILITY_FULLY_TRANSPARENT, VISIBILITY_FULLY_OPAQUE);
547
548 mScrimController.transitionTo(ScrimState.PULSING);
549 mScrimController.finishAnimationsImmediately();
550 assertScrimVisibility(VISIBILITY_FULLY_TRANSPARENT, VISIBILITY_FULLY_OPAQUE);
551 }
552
Lucas Dupin78949b82018-04-03 18:54:39 -0700553 @Test
Lucas Dupin63d72172018-06-06 11:42:55 -0700554 public void testHidesShowWhenLockedActivity_whenAlreadyInAod() {
555 mScrimController.setWallpaperSupportsAmbientMode(true);
556 mScrimController.transitionTo(ScrimState.AOD);
557 mScrimController.finishAnimationsImmediately();
558 assertScrimVisibility(VISIBILITY_FULLY_TRANSPARENT, VISIBILITY_FULLY_TRANSPARENT);
559
560 mScrimController.setKeyguardOccluded(true);
561 mScrimController.finishAnimationsImmediately();
562 assertScrimVisibility(VISIBILITY_FULLY_TRANSPARENT, VISIBILITY_FULLY_OPAQUE);
563 }
564
565 @Test
Lucas Dupin78949b82018-04-03 18:54:39 -0700566 public void testEatsTouchEvent() {
567 HashSet<ScrimState> eatsTouches =
568 new HashSet<>(Arrays.asList(ScrimState.AOD, ScrimState.PULSING));
569 for (ScrimState state : ScrimState.values()) {
570 if (state == ScrimState.UNINITIALIZED) {
571 continue;
572 }
573 mScrimController.transitionTo(state);
574 mScrimController.finishAnimationsImmediately();
575 Assert.assertEquals("Should be clickable unless AOD or PULSING, was: " + state,
576 mScrimBehind.getViewAlpha() != 0 && !eatsTouches.contains(state),
577 mScrimBehind.isClickable());
578 }
579 }
580
Lucas Dupinea0116e2018-04-05 10:09:29 -0700581 @Test
582 public void testAnimatesTransitionToAod() {
583 when(mDozeParamenters.shouldControlScreenOff()).thenReturn(false);
584 ScrimState.AOD.prepare(ScrimState.KEYGUARD);
585 Assert.assertFalse("No animation when ColorFade kicks in",
586 ScrimState.AOD.getAnimateChange());
587
588 reset(mDozeParamenters);
589 when(mDozeParamenters.shouldControlScreenOff()).thenReturn(true);
590 ScrimState.AOD.prepare(ScrimState.KEYGUARD);
591 Assert.assertTrue("Animate scrims when ColorFade won't be triggered",
592 ScrimState.AOD.getAnimateChange());
593 }
594
Lucas Dupin373356b2018-04-07 10:50:25 -0700595 @Test
596 public void testViewsDontHaveFocusHighlight() {
597 Assert.assertFalse("Scrim shouldn't have focus highlight",
598 mScrimInFront.getDefaultFocusHighlightEnabled());
599 Assert.assertFalse("Scrim shouldn't have focus highlight",
600 mScrimBehind.getDefaultFocusHighlightEnabled());
601 }
602
Lucas Dupinb380c882018-02-25 21:57:17 -0800603 /**
604 * Conserves old notification density after leaving state and coming back.
605 *
606 * @param count How many notification.
607 * @param expectedAlpha Expected alpha.
608 */
609 private void testConservesNotificationDensity(int count, float expectedAlpha) {
610 mScrimController.setNotificationCount(count);
611 mScrimController.transitionTo(ScrimState.UNLOCKED);
612 mScrimController.finishAnimationsImmediately();
613
614 mScrimController.transitionTo(ScrimState.KEYGUARD);
615 mScrimController.finishAnimationsImmediately();
616
617 Assert.assertEquals("Doesn't respect notification busyness after transition",
618 expectedAlpha, mScrimBehind.getViewAlpha(), 0.01f);
619 }
620
Lucas Dupin9e3fa102017-11-08 17:16:55 -0800621 private void assertScrimTint(ScrimView scrimView, boolean tinted) {
622 final boolean viewIsTinted = scrimView.getTint() != Color.TRANSPARENT;
623 final String name = scrimView == mScrimInFront ? "front" : "back";
624 Assert.assertEquals("Tint test failed at state " + mScrimController.getState()
625 +" with scrim: " + name + " and tint: " + Integer.toHexString(scrimView.getTint()),
626 tinted, viewIsTinted);
627 }
628
Lucas Dupin82aa1632017-12-13 00:13:57 -0800629 private void assertScrimVisibility(int inFront, int behind) {
630 boolean inFrontVisible = inFront != ScrimController.VISIBILITY_FULLY_TRANSPARENT;
631 boolean behindVisible = behind != ScrimController.VISIBILITY_FULLY_TRANSPARENT;
Lucas Dupin9e3fa102017-11-08 17:16:55 -0800632 Assert.assertEquals("Unexpected front scrim visibility. Alpha is "
Lucas Dupin82aa1632017-12-13 00:13:57 -0800633 + mScrimInFront.getViewAlpha(), inFrontVisible, mScrimInFront.getViewAlpha() > 0);
Lucas Dupin9e3fa102017-11-08 17:16:55 -0800634 Assert.assertEquals("Unexpected back scrim visibility. Alpha is "
Lucas Dupin82aa1632017-12-13 00:13:57 -0800635 + mScrimBehind.getViewAlpha(), behindVisible, mScrimBehind.getViewAlpha() > 0);
636
637 final int visibility;
638 if (inFront == VISIBILITY_FULLY_OPAQUE || behind == VISIBILITY_FULLY_OPAQUE) {
639 visibility = VISIBILITY_FULLY_OPAQUE;
640 } else if (inFront > VISIBILITY_FULLY_TRANSPARENT || behind > VISIBILITY_FULLY_TRANSPARENT) {
641 visibility = VISIBILITY_SEMI_TRANSPARENT;
642 } else {
643 visibility = VISIBILITY_FULLY_TRANSPARENT;
644 }
645 Assert.assertEquals("Invalid visibility.", visibility, mScrimVisibility);
Lucas Dupin9e3fa102017-11-08 17:16:55 -0800646 }
647
648 /**
649 * Special version of ScrimController where animations have 0 duration for test purposes.
650 */
651 private class SynchronousScrimController extends ScrimController {
652
653 private FakeHandler mHandler;
Lucas Dupin80a3fcc2018-02-07 10:49:55 -0800654 private boolean mAnimationCancelled;
Lucas Dupin16cfe452018-02-08 13:14:50 -0800655 boolean mOnPreDrawCalled;
Lucas Dupin9e3fa102017-11-08 17:16:55 -0800656
shawnlin317db372018-04-09 19:49:48 +0800657 SynchronousScrimController(ScrimView scrimBehind, ScrimView scrimInFront,
Yohei Yukawa795f0102018-04-13 14:55:30 -0700658 TriConsumer<ScrimState, Float, GradientColors> scrimStateListener,
Lucas Dupin82aa1632017-12-13 00:13:57 -0800659 Consumer<Integer> scrimVisibleListener, DozeParameters dozeParameters,
660 AlarmManager alarmManager) {
Yohei Yukawa795f0102018-04-13 14:55:30 -0700661 super(scrimBehind, scrimInFront, scrimStateListener, scrimVisibleListener,
662 dozeParameters, alarmManager);
Lucas Dupin9e3fa102017-11-08 17:16:55 -0800663 mHandler = new FakeHandler(Looper.myLooper());
664 }
665
Lucas Dupin16cfe452018-02-08 13:14:50 -0800666 @Override
667 public boolean onPreDraw() {
668 mOnPreDrawCalled = true;
669 return super.onPreDraw();
670 }
671
Lucas Dupin3503c5f2018-03-02 19:04:00 -0800672 void finishAnimationsImmediately() {
Lucas Dupin9e3fa102017-11-08 17:16:55 -0800673 boolean[] animationFinished = {false};
674 setOnAnimationFinished(()-> animationFinished[0] = true);
675
676 // Execute code that will trigger animations.
677 onPreDraw();
678
679 // Force finish screen blanking.
Lucas Dupin9e3fa102017-11-08 17:16:55 -0800680 mHandler.dispatchQueuedMessages();
681 // Force finish all animations.
682 endAnimation(mScrimBehind, TAG_KEY_ANIM);
683 endAnimation(mScrimInFront, TAG_KEY_ANIM);
684
685 if (!animationFinished[0]) {
686 throw new IllegalStateException("Animation never finished");
687 }
688 }
689
Lucas Dupin3503c5f2018-03-02 19:04:00 -0800690 boolean wasAnimationJustCancelled() {
Lucas Dupin80a3fcc2018-02-07 10:49:55 -0800691 final boolean wasCancelled = mAnimationCancelled;
692 mAnimationCancelled = false;
693 return wasCancelled;
694 }
695
Lucas Dupin3daf3b02018-02-27 17:23:41 -0800696 private void endAnimation(View scrimView, int tag) {
Lucas Dupin9e3fa102017-11-08 17:16:55 -0800697 Animator animator = (Animator) scrimView.getTag(tag);
698 if (animator != null) {
699 animator.end();
700 }
701 }
702
703 @Override
Lucas Dupin80a3fcc2018-02-07 10:49:55 -0800704 protected void cancelAnimator(ValueAnimator previousAnimator) {
705 super.cancelAnimator(previousAnimator);
706 mAnimationCancelled = true;
707 }
708
709 @Override
Lucas Dupin9e3fa102017-11-08 17:16:55 -0800710 protected Handler getHandler() {
711 return mHandler;
712 }
713
714 @Override
715 protected WakeLock createWakeLock() {
716 return mWakeLock;
717 }
Lucas Dupin8c7cb022018-02-05 10:49:03 -0800718
719 /**
720 * Do not wait for a frame since we're in a test environment.
721 * @param callback What to execute.
722 */
723 @Override
Lucas Dupin0791d972018-03-26 13:32:16 -0700724 protected void doOnTheNextFrame(Runnable callback) {
725 callback.run();
Lucas Dupin8c7cb022018-02-05 10:49:03 -0800726 }
Lucas Dupin9e3fa102017-11-08 17:16:55 -0800727 }
728
729}