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.keyguard; 18 19 import static android.content.res.Configuration.ORIENTATION_LANDSCAPE; 20 import static android.content.res.Configuration.ORIENTATION_PORTRAIT; 21 import static android.provider.Settings.Global.ONE_HANDED_KEYGUARD_SIDE; 22 import static android.provider.Settings.Global.ONE_HANDED_KEYGUARD_SIDE_LEFT; 23 import static android.provider.Settings.Global.ONE_HANDED_KEYGUARD_SIDE_RIGHT; 24 import static android.view.WindowInsets.Type.ime; 25 import static android.view.WindowInsets.Type.systemBars; 26 27 import static androidx.constraintlayout.widget.ConstraintSet.CHAIN_SPREAD; 28 import static androidx.constraintlayout.widget.ConstraintSet.MATCH_CONSTRAINT; 29 import static androidx.constraintlayout.widget.ConstraintSet.PARENT_ID; 30 import static androidx.constraintlayout.widget.ConstraintSet.WRAP_CONTENT; 31 32 import static com.android.keyguard.KeyguardSecurityContainer.MODE_DEFAULT; 33 import static com.android.keyguard.KeyguardSecurityContainer.MODE_ONE_HANDED; 34 import static com.android.keyguard.KeyguardSecurityContainer.MODE_USER_SWITCHER; 35 36 import static com.google.common.truth.Truth.assertThat; 37 38 import static org.mockito.ArgumentMatchers.any; 39 import static org.mockito.ArgumentMatchers.anyInt; 40 import static org.mockito.Mockito.mock; 41 import static org.mockito.Mockito.verify; 42 import static org.mockito.Mockito.when; 43 44 import android.content.pm.UserInfo; 45 import android.content.res.Configuration; 46 import android.graphics.Insets; 47 import android.testing.TestableLooper; 48 import android.view.MotionEvent; 49 import android.view.View; 50 import android.view.ViewGroup; 51 import android.view.WindowInsets; 52 import android.window.BackEvent; 53 import android.window.OnBackAnimationCallback; 54 55 import androidx.constraintlayout.widget.ConstraintSet; 56 import androidx.test.ext.junit.runners.AndroidJUnit4; 57 import androidx.test.filters.SmallTest; 58 59 import com.android.systemui.SysuiTestCase; 60 import com.android.systemui.classifier.FalsingA11yDelegate; 61 import com.android.systemui.plugins.FalsingManager; 62 import com.android.systemui.res.R; 63 import com.android.systemui.statusbar.policy.UserSwitcherController; 64 import com.android.systemui.statusbar.policy.UserSwitcherController.UserSwitchCallback; 65 import com.android.systemui.user.data.source.UserRecord; 66 import com.android.systemui.util.concurrency.FakeExecutor; 67 import com.android.systemui.util.settings.GlobalSettings; 68 import com.android.systemui.util.time.FakeSystemClock; 69 70 import org.junit.Before; 71 import org.junit.Rule; 72 import org.junit.Test; 73 import org.junit.runner.RunWith; 74 import org.mockito.ArgumentCaptor; 75 import org.mockito.Captor; 76 import org.mockito.Mock; 77 import org.mockito.junit.MockitoJUnit; 78 import org.mockito.junit.MockitoRule; 79 80 import java.util.ArrayList; 81 82 @SmallTest 83 @RunWith(AndroidJUnit4.class) 84 @TestableLooper.RunWithLooper() 85 public class KeyguardSecurityContainerTest extends SysuiTestCase { 86 87 private static final int VIEW_WIDTH = 1600; 88 private static final int VIEW_HEIGHT = 900; 89 90 @Rule 91 public MockitoRule mRule = MockitoJUnit.rule(); 92 93 private KeyguardSecurityViewFlipper mSecurityViewFlipper; 94 @Mock 95 private GlobalSettings mGlobalSettings; 96 @Mock 97 private FalsingManager mFalsingManager; 98 @Mock 99 private UserSwitcherController mUserSwitcherController; 100 @Mock 101 private FalsingA11yDelegate mFalsingA11yDelegate; 102 @Captor 103 private ArgumentCaptor<UserSwitchCallback> mUserSwitchCallbackCaptor = 104 ArgumentCaptor.forClass(UserSwitchCallback.class); 105 106 private KeyguardSecurityContainer mKeyguardSecurityContainer; 107 private FakeExecutor mExecutor = new FakeExecutor(new FakeSystemClock()); 108 109 @Before setup()110 public void setup() { 111 // Needed here, otherwise when mKeyguardSecurityContainer is created below, it'll cache 112 // the real references (rather than the TestableResources that this call creates). 113 mContext.ensureTestableResources(); 114 115 mSecurityViewFlipper = new KeyguardSecurityViewFlipper(getContext()); 116 mSecurityViewFlipper.setId(View.generateViewId()); 117 mKeyguardSecurityContainer = new KeyguardSecurityContainer(getContext()); 118 mKeyguardSecurityContainer.setBackgroundExecutor(mExecutor); 119 mKeyguardSecurityContainer.setRight(VIEW_WIDTH); 120 mKeyguardSecurityContainer.setLeft(0); 121 mKeyguardSecurityContainer.setTop(0); 122 mKeyguardSecurityContainer.setBottom(VIEW_HEIGHT); 123 mKeyguardSecurityContainer.setId(View.generateViewId()); 124 mKeyguardSecurityContainer.mSecurityViewFlipper = mSecurityViewFlipper; 125 mKeyguardSecurityContainer.addView(mSecurityViewFlipper, new ViewGroup.LayoutParams( 126 ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT)); 127 128 when(mUserSwitcherController.getCurrentUserName()).thenReturn("Test User"); 129 when(mUserSwitcherController.isKeyguardShowing()).thenReturn(true); 130 } 131 132 @Test testOnApplyWindowInsets()133 public void testOnApplyWindowInsets() { 134 int paddingBottom = getContext().getResources() 135 .getDimensionPixelSize(R.dimen.keyguard_security_view_bottom_margin); 136 int imeInsetAmount = paddingBottom + 1; 137 int systemBarInsetAmount = 0; 138 initMode(MODE_DEFAULT); 139 140 Insets imeInset = Insets.of(0, 0, 0, imeInsetAmount); 141 Insets systemBarInset = Insets.of(0, 0, 0, systemBarInsetAmount); 142 143 WindowInsets insets = new WindowInsets.Builder() 144 .setInsets(ime(), imeInset) 145 .setInsetsIgnoringVisibility(systemBars(), systemBarInset) 146 .build(); 147 148 mKeyguardSecurityContainer.onApplyWindowInsets(insets); 149 assertThat(mKeyguardSecurityContainer.getPaddingBottom()).isEqualTo(imeInsetAmount); 150 } 151 152 @Test testOnApplyWindowInsets_largerSystembar()153 public void testOnApplyWindowInsets_largerSystembar() { 154 int imeInsetAmount = 0; 155 int paddingBottom = getContext().getResources() 156 .getDimensionPixelSize(R.dimen.keyguard_security_view_bottom_margin); 157 int systemBarInsetAmount = paddingBottom + 1; 158 159 initMode(MODE_DEFAULT); 160 161 Insets imeInset = Insets.of(0, 0, 0, imeInsetAmount); 162 Insets systemBarInset = Insets.of(0, 0, 0, systemBarInsetAmount); 163 164 WindowInsets insets = new WindowInsets.Builder() 165 .setInsets(ime(), imeInset) 166 .setInsetsIgnoringVisibility(systemBars(), systemBarInset) 167 .build(); 168 169 mKeyguardSecurityContainer.onApplyWindowInsets(insets); 170 assertThat(mKeyguardSecurityContainer.getPaddingBottom()).isEqualTo(systemBarInsetAmount); 171 } 172 173 @Test testOnApplyWindowInsets_disappearAnimation_paddingNotSet()174 public void testOnApplyWindowInsets_disappearAnimation_paddingNotSet() { 175 int paddingBottom = getContext().getResources() 176 .getDimensionPixelSize(R.dimen.keyguard_security_view_bottom_margin); 177 int imeInsetAmount = paddingBottom + 1; 178 int systemBarInsetAmount = 0; 179 initMode(MODE_DEFAULT); 180 181 Insets imeInset = Insets.of(0, 0, 0, imeInsetAmount); 182 Insets systemBarInset = Insets.of(0, 0, 0, systemBarInsetAmount); 183 184 WindowInsets insets = new WindowInsets.Builder() 185 .setInsets(ime(), imeInset) 186 .setInsetsIgnoringVisibility(systemBars(), systemBarInset) 187 .build(); 188 189 ensureViewFlipperIsMocked(); 190 mKeyguardSecurityContainer.startDisappearAnimation( 191 KeyguardSecurityModel.SecurityMode.Password); 192 mKeyguardSecurityContainer.onApplyWindowInsets(insets); 193 assertThat(mKeyguardSecurityContainer.getPaddingBottom()).isNotEqualTo(imeInsetAmount); 194 } 195 196 @Test testDefaultViewMode()197 public void testDefaultViewMode() { 198 initMode(MODE_ONE_HANDED); 199 initMode(MODE_DEFAULT); 200 ConstraintSet.Constraint viewFlipperConstraint = 201 getViewConstraint(mSecurityViewFlipper.getId()); 202 assertThat(viewFlipperConstraint.layout.topToTop).isEqualTo(PARENT_ID); 203 assertThat(viewFlipperConstraint.layout.startToStart).isEqualTo(PARENT_ID); 204 assertThat(viewFlipperConstraint.layout.endToEnd).isEqualTo(PARENT_ID); 205 assertThat(viewFlipperConstraint.layout.bottomToBottom).isEqualTo(PARENT_ID); 206 } 207 208 @Test testUserSwitcherToOneHandedRemovesViews()209 public void testUserSwitcherToOneHandedRemovesViews() { 210 // Can happen when a SIM is inserted into a large screen device 211 initMode(MODE_USER_SWITCHER); 212 { 213 View view1 = mKeyguardSecurityContainer.findViewById( 214 R.id.keyguard_bouncer_user_switcher); 215 View view2 = mKeyguardSecurityContainer.findViewById(R.id.user_switcher_header); 216 assertThat(view1).isNotNull(); 217 assertThat(view2).isNotNull(); 218 } 219 220 initMode(MODE_ONE_HANDED); 221 { 222 View view1 = mKeyguardSecurityContainer.findViewById( 223 R.id.keyguard_bouncer_user_switcher); 224 View view2 = mKeyguardSecurityContainer.findViewById(R.id.user_switcher_header); 225 assertThat(view1).isNull(); 226 assertThat(view2).isNull(); 227 } 228 } 229 230 @Test updatePosition_movesKeyguard()231 public void updatePosition_movesKeyguard() { 232 setupForUpdateKeyguardPosition(/* oneHandedMode= */ true); 233 mKeyguardSecurityContainer.updatePositionByTouchX( 234 mKeyguardSecurityContainer.getWidth() - 1f); 235 236 verify(mGlobalSettings).putInt(ONE_HANDED_KEYGUARD_SIDE, ONE_HANDED_KEYGUARD_SIDE_RIGHT); 237 ConstraintSet.Constraint viewFlipperConstraint = 238 getViewConstraint(mSecurityViewFlipper.getId()); 239 assertThat(viewFlipperConstraint.layout.widthPercent).isEqualTo(0.5f); 240 assertThat(viewFlipperConstraint.layout.topToTop).isEqualTo(PARENT_ID); 241 assertThat(viewFlipperConstraint.layout.rightToRight).isEqualTo(PARENT_ID); 242 assertThat(viewFlipperConstraint.layout.leftToLeft).isEqualTo(-1); 243 244 mKeyguardSecurityContainer.updatePositionByTouchX(1f); 245 verify(mGlobalSettings).putInt(ONE_HANDED_KEYGUARD_SIDE, ONE_HANDED_KEYGUARD_SIDE_LEFT); 246 247 viewFlipperConstraint = 248 getViewConstraint(mSecurityViewFlipper.getId()); 249 assertThat(viewFlipperConstraint.layout.widthPercent).isEqualTo(0.5f); 250 assertThat(viewFlipperConstraint.layout.topToTop).isEqualTo(PARENT_ID); 251 assertThat(viewFlipperConstraint.layout.leftToLeft).isEqualTo(PARENT_ID); 252 assertThat(viewFlipperConstraint.layout.rightToRight).isEqualTo(-1); 253 } 254 255 @Test updatePosition_doesntMoveTwoHandedKeyguard()256 public void updatePosition_doesntMoveTwoHandedKeyguard() { 257 setupForUpdateKeyguardPosition(/* oneHandedMode= */ false); 258 259 mKeyguardSecurityContainer.updatePositionByTouchX( 260 mKeyguardSecurityContainer.getWidth() - 1f); 261 ConstraintSet.Constraint viewFlipperConstraint = 262 getViewConstraint(mSecurityViewFlipper.getId()); 263 assertThat(viewFlipperConstraint.layout.rightToRight).isEqualTo(-1); 264 assertThat(viewFlipperConstraint.layout.leftToLeft).isEqualTo(-1); 265 266 mKeyguardSecurityContainer.updatePositionByTouchX(1f); 267 viewFlipperConstraint = 268 getViewConstraint(mSecurityViewFlipper.getId()); 269 assertThat(viewFlipperConstraint.layout.rightToRight).isEqualTo(-1); 270 assertThat(viewFlipperConstraint.layout.leftToLeft).isEqualTo(-1); 271 } 272 273 @Test testUserSwitcherModeViewPositionLandscape()274 public void testUserSwitcherModeViewPositionLandscape() { 275 // GIVEN one user has been setup and in landscape 276 when(mUserSwitcherController.getUsers()).thenReturn(buildUserRecords(1)); 277 Configuration landscapeConfig = configuration(ORIENTATION_LANDSCAPE); 278 when(getContext().getResources().getConfiguration()).thenReturn(landscapeConfig); 279 280 // WHEN UserSwitcherViewMode is initialized and config has changed 281 setupUserSwitcher(); 282 mKeyguardSecurityContainer.onConfigurationChanged(landscapeConfig); 283 284 ConstraintSet.Constraint viewFlipperConstraint = 285 getViewConstraint(mSecurityViewFlipper.getId()); 286 ConstraintSet.Constraint userSwitcherConstraint = 287 getViewConstraint(R.id.keyguard_bouncer_user_switcher); 288 assertThat(viewFlipperConstraint.layout.endToEnd).isEqualTo(PARENT_ID); 289 assertThat(viewFlipperConstraint.layout.startToEnd).isEqualTo( 290 R.id.keyguard_bouncer_user_switcher); 291 assertThat(userSwitcherConstraint.layout.startToStart).isEqualTo(PARENT_ID); 292 assertThat(userSwitcherConstraint.layout.endToStart).isEqualTo( 293 mSecurityViewFlipper.getId()); 294 assertThat(viewFlipperConstraint.layout.topToTop).isEqualTo(PARENT_ID); 295 assertThat(viewFlipperConstraint.layout.bottomToBottom).isEqualTo(PARENT_ID); 296 assertThat(userSwitcherConstraint.layout.topToTop).isEqualTo(PARENT_ID); 297 assertThat(userSwitcherConstraint.layout.bottomToBottom).isEqualTo(PARENT_ID); 298 assertThat(viewFlipperConstraint.layout.horizontalChainStyle).isEqualTo(CHAIN_SPREAD); 299 assertThat(userSwitcherConstraint.layout.horizontalChainStyle).isEqualTo(CHAIN_SPREAD); 300 assertThat(viewFlipperConstraint.layout.mHeight).isEqualTo(MATCH_CONSTRAINT); 301 assertThat(userSwitcherConstraint.layout.mHeight).isEqualTo(MATCH_CONSTRAINT); 302 } 303 304 @Test testUserSwitcherModeViewPositionPortrait()305 public void testUserSwitcherModeViewPositionPortrait() { 306 // GIVEN one user has been setup and in landscape 307 when(mUserSwitcherController.getUsers()).thenReturn(buildUserRecords(1)); 308 Configuration portraitConfig = configuration(ORIENTATION_PORTRAIT); 309 when(getContext().getResources().getConfiguration()).thenReturn(portraitConfig); 310 311 // WHEN UserSwitcherViewMode is initialized and config has changed 312 setupUserSwitcher(); 313 mKeyguardSecurityContainer.onConfigurationChanged(portraitConfig); 314 315 ConstraintSet.Constraint viewFlipperConstraint = 316 getViewConstraint(mSecurityViewFlipper.getId()); 317 ConstraintSet.Constraint userSwitcherConstraint = 318 getViewConstraint(R.id.keyguard_bouncer_user_switcher); 319 320 assertThat(viewFlipperConstraint.layout.topToBottom).isEqualTo( 321 R.id.keyguard_bouncer_user_switcher); 322 assertThat(viewFlipperConstraint.layout.bottomToBottom).isEqualTo(PARENT_ID); 323 assertThat(userSwitcherConstraint.layout.topToTop).isEqualTo(PARENT_ID); 324 assertThat(userSwitcherConstraint.layout.bottomToTop).isEqualTo( 325 mSecurityViewFlipper.getId()); 326 assertThat(userSwitcherConstraint.layout.topMargin).isEqualTo( 327 getContext().getResources().getDimensionPixelSize( 328 R.dimen.bouncer_user_switcher_y_trans)); 329 assertThat(viewFlipperConstraint.layout.leftToLeft).isEqualTo(PARENT_ID); 330 assertThat(viewFlipperConstraint.layout.rightToRight).isEqualTo(PARENT_ID); 331 assertThat(userSwitcherConstraint.layout.leftToLeft).isEqualTo(PARENT_ID); 332 assertThat(userSwitcherConstraint.layout.rightToRight).isEqualTo(PARENT_ID); 333 assertThat(viewFlipperConstraint.layout.verticalChainStyle).isEqualTo(CHAIN_SPREAD); 334 assertThat(userSwitcherConstraint.layout.verticalChainStyle).isEqualTo(CHAIN_SPREAD); 335 assertThat(viewFlipperConstraint.layout.mHeight).isEqualTo(MATCH_CONSTRAINT); 336 assertThat(userSwitcherConstraint.layout.mHeight).isEqualTo(WRAP_CONTENT); 337 assertThat(userSwitcherConstraint.layout.mWidth).isEqualTo(WRAP_CONTENT); 338 } 339 340 @Test testLessThanTwoUsersDoesNotAllowDropDown()341 public void testLessThanTwoUsersDoesNotAllowDropDown() { 342 // GIVEN one user has been setup 343 when(mUserSwitcherController.getUsers()).thenReturn(buildUserRecords(1)); 344 345 // WHEN UserSwitcherViewMode is initialized 346 setupUserSwitcher(); 347 348 // THEN the UserSwitcher anchor should not be clickable 349 ViewGroup anchor = mKeyguardSecurityContainer.findViewById(R.id.user_switcher_anchor); 350 assertThat(anchor.isClickable()).isFalse(); 351 } 352 353 @Test testTwoOrMoreUsersDoesAllowDropDown()354 public void testTwoOrMoreUsersDoesAllowDropDown() { 355 // GIVEN two users have been setup 356 ArrayList<UserRecord> records = buildUserRecords(2); 357 when(mUserSwitcherController.getCurrentUserRecord()).thenReturn(records.get(0)); 358 when(mUserSwitcherController.getUsers()).thenReturn(records); 359 360 // WHEN UserSwitcherViewMode is initialized 361 setupUserSwitcher(); 362 363 // THEN the UserSwitcher anchor should be clickable 364 ViewGroup anchor = mKeyguardSecurityContainer.findViewById(R.id.user_switcher_anchor); 365 assertThat(anchor.isClickable()).isTrue(); 366 } 367 368 @Test goingOutOfUserSwitcherRemovesCallback()369 public void goingOutOfUserSwitcherRemovesCallback() { 370 // WHEN UserSwitcherViewMode is initialized 371 setupUserSwitcher(); 372 verify(mUserSwitcherController).addUserSwitchCallback(mUserSwitchCallbackCaptor.capture()); 373 374 // Back to default mode, as SIM PIN would be 375 initMode(MODE_DEFAULT); 376 verify(mUserSwitcherController).removeUserSwitchCallback( 377 mUserSwitchCallbackCaptor.getValue()); 378 } 379 380 @Test testOnDensityOrFontScaleChanged()381 public void testOnDensityOrFontScaleChanged() { 382 setupUserSwitcher(); 383 View oldUserSwitcher = mKeyguardSecurityContainer.findViewById( 384 R.id.keyguard_bouncer_user_switcher); 385 mKeyguardSecurityContainer.onDensityOrFontScaleChanged(); 386 View newUserSwitcher = mKeyguardSecurityContainer.findViewById( 387 R.id.keyguard_bouncer_user_switcher); 388 assertThat(oldUserSwitcher).isNotEqualTo(newUserSwitcher); 389 } 390 391 @Test testTouchesAreRecognizedAsBeingOnTheOtherSideOfSecurity()392 public void testTouchesAreRecognizedAsBeingOnTheOtherSideOfSecurity() { 393 setupUserSwitcher(); 394 setViewWidth(VIEW_WIDTH); 395 396 // security is on the right side by default 397 assertThat(mKeyguardSecurityContainer.isTouchOnTheOtherSideOfSecurity( 398 touchEventLeftSide())).isTrue(); 399 assertThat(mKeyguardSecurityContainer.isTouchOnTheOtherSideOfSecurity( 400 touchEventRightSide())).isFalse(); 401 402 // move security to the left side 403 when(mGlobalSettings.getInt(any(), anyInt())).thenReturn(ONE_HANDED_KEYGUARD_SIDE_LEFT); 404 mKeyguardSecurityContainer.onConfigurationChanged(new Configuration()); 405 406 assertThat(mKeyguardSecurityContainer.isTouchOnTheOtherSideOfSecurity( 407 touchEventLeftSide())).isFalse(); 408 assertThat(mKeyguardSecurityContainer.isTouchOnTheOtherSideOfSecurity( 409 touchEventRightSide())).isTrue(); 410 } 411 412 @Test testSecuritySwitchesSidesInLandscapeUserSwitcherMode()413 public void testSecuritySwitchesSidesInLandscapeUserSwitcherMode() { 414 when(getContext().getResources().getConfiguration()) 415 .thenReturn(configuration(ORIENTATION_LANDSCAPE)); 416 setupUserSwitcher(); 417 418 // switch sides 419 when(mGlobalSettings.getInt(any(), anyInt())).thenReturn(ONE_HANDED_KEYGUARD_SIDE_LEFT); 420 mKeyguardSecurityContainer.onConfigurationChanged(new Configuration()); 421 422 ConstraintSet.Constraint viewFlipperConstraint = getViewConstraint( 423 mSecurityViewFlipper.getId()); 424 assertThat(viewFlipperConstraint.layout.startToStart).isEqualTo(PARENT_ID); 425 } 426 427 @Test testPlayBackAnimation()428 public void testPlayBackAnimation() { 429 OnBackAnimationCallback backCallback = mKeyguardSecurityContainer.getBackCallback(); 430 backCallback.onBackStarted(createBackEvent(0, 0)); 431 mKeyguardSecurityContainer.getBackCallback().onBackProgressed( 432 createBackEvent(0, 1)); 433 assertThat(mKeyguardSecurityContainer.getScaleX()).isEqualTo( 434 KeyguardSecurityContainer.MIN_BACK_SCALE); 435 assertThat(mKeyguardSecurityContainer.getScaleY()).isEqualTo( 436 KeyguardSecurityContainer.MIN_BACK_SCALE); 437 438 // reset scale 439 mKeyguardSecurityContainer.resetScale(); 440 assertThat(mKeyguardSecurityContainer.getScaleX()).isEqualTo(1); 441 assertThat(mKeyguardSecurityContainer.getScaleY()).isEqualTo(1); 442 } 443 444 @Test testDisappearAnimationPassword()445 public void testDisappearAnimationPassword() { 446 ensureViewFlipperIsMocked(); 447 KeyguardPasswordView keyguardPasswordView = mock(KeyguardPasswordView.class); 448 when(mSecurityViewFlipper.getSecurityView()).thenReturn(keyguardPasswordView); 449 450 mKeyguardSecurityContainer 451 .startDisappearAnimation(KeyguardSecurityModel.SecurityMode.Password); 452 verify(keyguardPasswordView).setDisappearAnimationListener(any()); 453 } 454 455 @Test setupForDelayedAppear()456 public void setupForDelayedAppear() { 457 mKeyguardSecurityContainer.setupForDelayedAppear(); 458 assertThat(mKeyguardSecurityContainer.getTranslationY()).isEqualTo(0f); 459 assertThat(mKeyguardSecurityContainer.getAlpha()).isEqualTo(0f); 460 assertThat(mKeyguardSecurityContainer.isAppearAnimationDelayed()).isTrue(); 461 } 462 createBackEvent(float touchX, float progress)463 private BackEvent createBackEvent(float touchX, float progress) { 464 return new BackEvent(0, 0, progress, BackEvent.EDGE_LEFT); 465 } 466 configuration(@onfiguration.Orientation int orientation)467 private Configuration configuration(@Configuration.Orientation int orientation) { 468 Configuration config = new Configuration(); 469 config.orientation = orientation; 470 return config; 471 } 472 setViewWidth(int width)473 private void setViewWidth(int width) { 474 mKeyguardSecurityContainer.setRight(width); 475 mKeyguardSecurityContainer.setLeft(0); 476 } 477 touchEventLeftSide()478 private MotionEvent touchEventLeftSide() { 479 return MotionEvent.obtain( 480 /* downTime= */0, 481 /* eventTime= */0, 482 MotionEvent.ACTION_DOWN, 483 /* x= */VIEW_WIDTH / 3f, 484 /* y= */0, 485 /* metaState= */0); 486 } 487 touchEventRightSide()488 private MotionEvent touchEventRightSide() { 489 return MotionEvent.obtain( 490 /* downTime= */0, 491 /* eventTime= */0, 492 MotionEvent.ACTION_DOWN, 493 /* x= */(VIEW_WIDTH / 3f) * 2, 494 /* y= */0, 495 /* metaState= */0); 496 } 497 setupUserSwitcher()498 private void setupUserSwitcher() { 499 when(mGlobalSettings.getInt(any(), anyInt())).thenReturn(ONE_HANDED_KEYGUARD_SIDE_RIGHT); 500 initMode(MODE_USER_SWITCHER); 501 } 502 buildUserRecords(int count)503 private ArrayList<UserRecord> buildUserRecords(int count) { 504 ArrayList<UserRecord> users = new ArrayList<>(); 505 for (int i = 0; i < count; ++i) { 506 UserInfo info = new UserInfo(i /* id */, "Name: " + i, null /* iconPath */, 507 0 /* flags */); 508 users.add(new UserRecord(info, null, false /* isGuest */, false /* isCurrent */, 509 false /* isAddUser */, false /* isRestricted */, true /* isSwitchToEnabled */, 510 false /* isAddSupervisedUser */, false /* isSignOut */, 511 null /* enforcedAdmin */, false /* isManageUsers */)); 512 } 513 return users; 514 } 515 setupForUpdateKeyguardPosition(boolean oneHandedMode)516 private void setupForUpdateKeyguardPosition(boolean oneHandedMode) { 517 int mode = oneHandedMode ? MODE_ONE_HANDED : MODE_DEFAULT; 518 initMode(mode); 519 } 520 521 /** Get the ConstraintLayout constraint of the view. */ getViewConstraint(int viewId)522 private ConstraintSet.Constraint getViewConstraint(int viewId) { 523 ConstraintSet constraintSet = new ConstraintSet(); 524 constraintSet.clone(mKeyguardSecurityContainer); 525 return constraintSet.getConstraint(viewId); 526 } 527 initMode(int mode)528 private void initMode(int mode) { 529 mKeyguardSecurityContainer.initMode(mode, mGlobalSettings, mFalsingManager, 530 mUserSwitcherController, () -> { 531 }, mFalsingA11yDelegate); 532 } 533 ensureViewFlipperIsMocked()534 private void ensureViewFlipperIsMocked() { 535 mSecurityViewFlipper = mock(KeyguardSecurityViewFlipper.class); 536 KeyguardPasswordView keyguardPasswordView = mock(KeyguardPasswordView.class); 537 when(mSecurityViewFlipper.getSecurityView()).thenReturn(keyguardPasswordView); 538 mKeyguardSecurityContainer.mSecurityViewFlipper = mSecurityViewFlipper; 539 } 540 541 } 542