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