Merge "Show a dialog preventing fingerprint enrollment in split mode." into udc-dev

res/values/strings.xml

@@ -871,6 +871,12 @@
     <string name="biometric_settings_use_face_or_fingerprint_preference_summary">Using face or fingerprint</string>
     <!-- Button text shown during enrollment to proceed after a child user has handed the device to a parent or guardian. [CHAR LIMIT=22] -->
     <string name="biometric_settings_hand_back_to_guardian_ok">OK</string>
+    <!-- Dialog title for dialog which shows when trying to add fingerprint in split mode. [CHAR LIMIT=45] -->
+    <string name="biometric_settings_add_fingerprint_in_split_mode_title">Can\u2019t set up fingerprint</string>
+    <!-- Dialog message for dialog which shows when trying to add fingerprint in split mode. [CHAR LIMIT=45] -->
+    <string name="biometric_settings_add_fingerprint_in_split_mode_message">Exit split screen to set up Fingerprint Unlock</string>
+    <!-- Button text shown in adding fingerprint dialog that allows the user to go back to the settings page [CHAR LIMIT=22] -->
+    <string name="biometric_settings_add_fingerprint_in_split_mode_ok">OK</string>
 
     <!-- Title of dialog shown when the user tries to skip setting up a screen lock, warning them of potential consequences of not doing so [CHAR LIMIT=30]-->
     <string name="lock_screen_intro_skip_title">Skip screen lock?</string>

src/com/android/settings/biometrics/combination/BiometricsSettingsBase.java

@@ -41,6 +41,7 @@ import com.android.settings.R;
 import com.android.settings.Utils;
 import com.android.settings.biometrics.BiometricEnrollBase;
 import com.android.settings.biometrics.BiometricUtils;
+import com.android.settings.biometrics.fingerprint.FingerprintSettings.FingerprintSettingsFragment;
 import com.android.settings.core.SettingsBaseActivity;
 import com.android.settings.dashboard.DashboardFragment;
 import com.android.settings.password.ChooseLockGeneric;
@@ -166,6 +167,14 @@ public abstract class BiometricsSettingsBase extends DashboardFragment {
             return true;
         } else if (getFingerprintPreferenceKey().equals(key)) {
             mDoNotFinishActivity = true;
+
+            if (shouldSkipForUdfpsInMultiWindowMode()) {
+                new FingerprintSettingsFragment.FingerprintSplitScreenDialog().show(
+                        getActivity().getSupportFragmentManager(),
+                        FingerprintSettingsFragment.FingerprintSplitScreenDialog.class.getName());
+                return true;
+            }
+
             mFingerprintManager.generateChallenge(mUserId, (sensorId, userId, challenge) -> {
                 try {
                     final byte[] token = requestGatekeeperHat(context, mGkPwHandle, mUserId,
@@ -377,4 +386,27 @@ public abstract class BiometricsSettingsBase extends DashboardFragment {
             return 0;
         }
     }
+
+    /**
+     * Returns whether the click should be skipped.
+     * True if the following conditions are all met:
+     * 1. It's split mode.
+     * 2. It's udfps.
+     * 3. There is no enrolled fingerprint. (If there is enrolled fingerprint, FingerprintSettings
+     * will handle the adding fingerprint.
+     */
+    private boolean shouldSkipForUdfpsInMultiWindowMode() {
+        if (!getActivity().isInMultiWindowMode() || mFingerprintManager.hasEnrolledFingerprints(
+                mUserId)) {
+            return false;
+        }
+
+        for (FingerprintSensorPropertiesInternal prop :
+                mFingerprintManager.getSensorPropertiesInternal()) {
+            if (prop.isAnyUdfpsType()) {
+                return true;
+            }
+        }
+        return false;
+    }
 }

src/com/android/settings/biometrics/fingerprint/FingerprintSettings.java

@@ -159,7 +159,8 @@ public class FingerprintSettings extends SubSettings {
 
         private static final String TAG = "FingerprintSettings";
         private static final String KEY_FINGERPRINT_ITEM_PREFIX = "key_fingerprint_item";
-        private static final String KEY_FINGERPRINT_ADD = "key_fingerprint_add";
+        @VisibleForTesting
+        static final String KEY_FINGERPRINT_ADD = "key_fingerprint_add";
         private static final String KEY_FINGERPRINT_ENABLE_KEYGUARD_TOGGLE =
                 "fingerprint_enable_keyguard_toggle";
         private static final String KEY_LAUNCHED_CONFIRM = "launched_confirm";
@@ -178,8 +179,8 @@ public class FingerprintSettings extends SubSettings {
 
         private static final int CONFIRM_REQUEST = 101;
         private static final int CHOOSE_LOCK_GENERIC_REQUEST = 102;
-
+        @VisibleForTesting
-        private static final int ADD_FINGERPRINT_REQUEST = 10;
+        static final int ADD_FINGERPRINT_REQUEST = 10;
         private static final int AUTO_ADD_FIRST_FINGERPRINT_REQUEST = 11;
 
         protected static final boolean DEBUG = false;
@@ -694,6 +695,15 @@ public class FingerprintSettings extends SubSettings {
         public boolean onPreferenceTreeClick(Preference pref) {
             final String key = pref.getKey();
             if (KEY_FINGERPRINT_ADD.equals(key)) {
+                // If it's udfps in split mode, show the error dialog and don't need to show adding
+                // fingerprint intent.
+                if (shouldSkipForUdfpsInMultiWindowMode()) {
+                    new FingerprintSplitScreenDialog().show(
+                            getActivity().getSupportFragmentManager(),
+                            FingerprintSplitScreenDialog.class.getName());
+                    return true;
+                }
+
                 mIsEnrolling = true;
                 Intent intent = new Intent();
                 if (FeatureFlagUtils.isEnabled(getContext(),
@@ -997,6 +1007,14 @@ public class FingerprintSettings extends SubSettings {
             updatePreferences();
         }
 
+        /**
+         * Returns whether the click should be skipped.
+         * True if it's udfps and it's in split mode.
+         */
+        private boolean shouldSkipForUdfpsInMultiWindowMode() {
+            return getActivity().isInMultiWindowMode() && isUdfps();
+        }
+
         private final Runnable mFingerprintLockoutReset = new Runnable() {
             @Override
             public void run() {
@@ -1246,6 +1264,29 @@ public class FingerprintSettings extends SubSettings {
                 return alertDialog;
             }
         }
+
+        /**
+         * This alert dialog shows when fingerprint is being added in multi window mode.
+         */
+        public static class FingerprintSplitScreenDialog extends InstrumentedDialogFragment {
+            @Override
+            public Dialog onCreateDialog(Bundle savedInstanceState) {
+                AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
+                builder.setTitle(
+                                R.string.biometric_settings_add_fingerprint_in_split_mode_title)
+                        .setMessage(
+                                R.string.biometric_settings_add_fingerprint_in_split_mode_message)
+                        .setPositiveButton(
+                                R.string.biometric_settings_add_fingerprint_in_split_mode_ok,
+                                (DialogInterface.OnClickListener) (dialog, which) -> dialog.dismiss());
+                return builder.create();
+            }
+
+            @Override
+            public int getMetricsCategory() {
+                return SettingsEnums.DIALOG_ADD_FINGERPRINT_ERROR_IN_SPLIT_MODE;
+            }
+        }
     }
 
     public static class FingerprintPreference extends TwoTargetPreference {

tests/robotests/src/com/android/settings/biometrics/combination/CombinedBiometricProfileSettingsTest.java

@@ -16,7 +16,11 @@
 
 package com.android.settings.biometrics.combination;
 
+import static android.hardware.fingerprint.FingerprintSensorProperties.TYPE_POWER_BUTTON;
+import static android.hardware.fingerprint.FingerprintSensorProperties.TYPE_UDFPS_OPTICAL;
+
 import static com.android.settings.biometrics.combination.BiometricsSettingsBase.CONFIRM_REQUEST;
+import static com.android.settings.biometrics.fingerprint.FingerprintSettings.FingerprintSettingsFragment;
 import static com.android.settings.password.ChooseLockPattern.RESULT_FINISHED;
 
 import static com.google.common.truth.Truth.assertThat;
@@ -24,17 +28,24 @@ import static com.google.common.truth.Truth.assertThat;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyInt;
 import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 
 import android.content.Context;
 import android.content.Intent;
+import android.hardware.biometrics.ComponentInfoInternal;
+import android.hardware.biometrics.SensorProperties;
 import android.hardware.face.FaceManager;
 import android.hardware.fingerprint.FingerprintManager;
+import android.hardware.fingerprint.FingerprintSensorProperties;
+import android.hardware.fingerprint.FingerprintSensorPropertiesInternal;
 import android.os.Bundle;
 import android.view.LayoutInflater;
 import android.view.View;
@@ -43,6 +54,8 @@ import android.view.ViewGroup;
 import androidx.annotation.NonNull;
 import androidx.annotation.XmlRes;
 import androidx.fragment.app.FragmentActivity;
+import androidx.fragment.app.FragmentManager;
+import androidx.fragment.app.FragmentTransaction;
 import androidx.preference.Preference;
 import androidx.preference.PreferenceManager;
 import androidx.preference.PreferenceScreen;
@@ -56,6 +69,7 @@ import com.android.settings.testutils.shadow.ShadowSettingsPreferenceFragment;
 import com.android.settings.testutils.shadow.ShadowUtils;
 import com.android.settingslib.core.AbstractPreferenceController;
 
+import org.junit.After;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
@@ -80,6 +94,7 @@ public class CombinedBiometricProfileSettingsTest {
 
     private TestCombinedBiometricProfileSettings mFragment;
     private Context mContext;
+    private FragmentActivity mActivity;
 
     @Rule
     public final MockitoRule mMockitoRule = MockitoJUnit.rule();
@@ -91,6 +106,8 @@ public class CombinedBiometricProfileSettingsTest {
     private BiometricSettingsAppPreferenceController mBiometricSettingsAppPreferenceController;
     @Mock
     private FaceManager mFaceManager;
+    @Mock
+    private FragmentTransaction mFragmentTransaction;
 
     @Before
     public void setUp() {
@@ -98,11 +115,11 @@ public class CombinedBiometricProfileSettingsTest {
         ShadowUtils.setFaceManager(mFaceManager);
         FakeFeatureFactory.setupForTest();
 
-        FragmentActivity activity = Robolectric.buildActivity(FragmentActivity.class,
+        mActivity = spy(Robolectric.buildActivity(FragmentActivity.class,
-                new Intent().putExtra(ChooseLockSettingsHelper.EXTRA_KEY_GK_PW_HANDLE, 1L)).get();
+                new Intent().putExtra(ChooseLockSettingsHelper.EXTRA_KEY_GK_PW_HANDLE, 1L)).get());
         mContext = spy(ApplicationProvider.getApplicationContext());
         mFragment = spy(new TestCombinedBiometricProfileSettings(mContext));
-        doReturn(activity).when(mFragment).getActivity();
+        doReturn(mActivity).when(mFragment).getActivity();
 
         ReflectionHelpers.setField(mFragment, "mDashboardFeatureProvider",
                 FakeFeatureFactory.setupForTest().dashboardFeatureProvider);
@@ -121,6 +138,11 @@ public class CombinedBiometricProfileSettingsTest {
         }).when(mFragment).findPreference(any());
     }
 
+    @After
+    public void tearDown() {
+        ShadowUtils.reset();
+    }
+
     @Test
     public void testClickFingerprintUnlockWithValidGkPwHandle() {
         doAnswer(invocation -> {
@@ -299,6 +321,84 @@ public class CombinedBiometricProfileSettingsTest {
         assertThat(capturedPreferences.get(0).getKey()).isEqualTo(mFragment.getFacePreferenceKey());
     }
 
+    @Test
+    public void testClickFingerprintUnlockInMultiWindow_onUdfpsDevice_withoutEnrolledFp_showsDialog() {
+        clickFingerprintUnlockInSplitScreenMode(TYPE_UDFPS_OPTICAL, /*hasEnrolledFingerprint*/
+                false);
+
+        verify(mBiometricSettingsAppPreferenceController, times(0)).handlePreferenceTreeClick(
+                any());
+        verify(mFragmentTransaction).add(any(),
+                eq(FingerprintSettingsFragment.FingerprintSplitScreenDialog.class.getName()));
+    }
+
+    @Test
+    public void testClickFingerprintUnlockInMultiWindow_onUdfpsDevice_withEnrolledFp_noDialog() {
+        clickFingerprintUnlockInSplitScreenMode(TYPE_UDFPS_OPTICAL, /*hasEnrolledFingerprint*/true);
+
+        verify(mBiometricSettingsAppPreferenceController).handlePreferenceTreeClick(
+                mPreferenceCaptor.capture());
+        List<Preference> capturedPreferences = mPreferenceCaptor.getAllValues();
+        assertThat(capturedPreferences.size()).isEqualTo(1);
+        assertThat(capturedPreferences.get(0).getKey()).isEqualTo(
+                mFragment.getFingerprintPreferenceKey());
+        verify(mFragmentTransaction, never()).add(any(),
+                eq(FingerprintSettingsFragment.FingerprintSplitScreenDialog.class.getName()));
+    }
+
+    @Test
+    public void testClickFingerprintUnlockInMultiWindow_onSfpsDevice_withoutEnrolledFp_noDialog() {
+        clickFingerprintUnlockInSplitScreenMode(TYPE_POWER_BUTTON, /*hasEnrolledFingerprint*/false);
+
+        verify(mBiometricSettingsAppPreferenceController).handlePreferenceTreeClick(
+                mPreferenceCaptor.capture());
+        List<Preference> capturedPreferences = mPreferenceCaptor.getAllValues();
+        assertThat(capturedPreferences.size()).isEqualTo(1);
+        assertThat(capturedPreferences.get(0).getKey()).isEqualTo(
+                mFragment.getFingerprintPreferenceKey());
+        verify(mFragmentTransaction, never()).add(any(),
+                eq(FingerprintSettingsFragment.FingerprintSplitScreenDialog.class.getName()));
+    }
+
+    private void clickFingerprintUnlockInSplitScreenMode(
+            @FingerprintSensorProperties.SensorType int sensorType,
+            boolean hasEnrolledFingerprint) {
+        final ArrayList<FingerprintSensorPropertiesInternal> props = new ArrayList<>();
+        props.add(new FingerprintSensorPropertiesInternal(
+                0 /* sensorId */,
+                SensorProperties.STRENGTH_STRONG,
+                1 /* maxEnrollmentsPerUser */,
+                new ArrayList<ComponentInfoInternal>(),
+                sensorType,
+                true /* resetLockoutRequiresHardwareAuthToken */));
+        doReturn(props).when(mFingerprintManager).getSensorPropertiesInternal();
+
+        doAnswer(invocation -> {
+            final FingerprintManager.GenerateChallengeCallback callback =
+                    invocation.getArgument(1);
+            callback.onChallengeGenerated(0, 0, 1L);
+            return null;
+        }).when(mFingerprintManager).generateChallenge(anyInt(), any());
+        doReturn(new byte[]{1}).when(mFragment).requestGatekeeperHat(any(), anyLong(), anyInt(),
+                anyLong());
+        FragmentManager fragmentManager = mock(FragmentManager.class);
+        doReturn(fragmentManager).when(mActivity).getSupportFragmentManager();
+        doReturn(mFragmentTransaction).when(fragmentManager).beginTransaction();
+        doReturn(true).when(mActivity).isInMultiWindowMode();
+        doReturn(hasEnrolledFingerprint).when(mFingerprintManager).hasEnrolledFingerprints(
+                anyInt());
+
+        // Start fragment
+        mFragment.onAttach(mContext);
+        mFragment.onCreate(null);
+        mFragment.onCreateView(LayoutInflater.from(mContext), mock(ViewGroup.class), Bundle.EMPTY);
+        mFragment.onResume();
+
+        // User clicks on "Fingerprint Unlock"
+        final Preference preference = new Preference(mContext);
+        preference.setKey(mFragment.getFingerprintPreferenceKey());
+        mFragment.onPreferenceTreeClick(preference);
+    }
     /**
      * a test fragment that initializes PreferenceScreen for testing.
      */

tests/robotests/src/com/android/settings/biometrics/fingerprint/FingerprintSettingsFragmentTest.java

@@ -0,0 +1,197 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.settings.biometrics.fingerprint;
+
+import static android.hardware.fingerprint.FingerprintSensorProperties.TYPE_POWER_BUTTON;
+import static android.hardware.fingerprint.FingerprintSensorProperties.TYPE_UDFPS_OPTICAL;
+
+import static com.android.settings.biometrics.fingerprint.FingerprintSettings.FingerprintSettingsFragment;
+import static com.android.settings.biometrics.fingerprint.FingerprintSettings.FingerprintSettingsFragment.ADD_FINGERPRINT_REQUEST;
+import static com.android.settings.biometrics.fingerprint.FingerprintSettings.FingerprintSettingsFragment.KEY_FINGERPRINT_ADD;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+import android.content.Context;
+import android.content.Intent;
+import android.hardware.biometrics.ComponentInfoInternal;
+import android.hardware.biometrics.SensorProperties;
+import android.hardware.fingerprint.FingerprintManager;
+import android.hardware.fingerprint.FingerprintSensorProperties;
+import android.hardware.fingerprint.FingerprintSensorPropertiesInternal;
+import android.os.Bundle;
+import android.view.LayoutInflater;
+import android.view.ViewGroup;
+
+import androidx.fragment.app.FragmentActivity;
+import androidx.fragment.app.FragmentManager;
+import androidx.fragment.app.FragmentTransaction;
+import androidx.preference.Preference;
+import androidx.test.core.app.ApplicationProvider;
+
+import com.android.settings.password.ChooseLockSettingsHelper;
+import com.android.settings.testutils.FakeFeatureFactory;
+import com.android.settings.testutils.shadow.ShadowFragment;
+import com.android.settings.testutils.shadow.ShadowSettingsPreferenceFragment;
+import com.android.settings.testutils.shadow.ShadowUserManager;
+import com.android.settings.testutils.shadow.ShadowUtils;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+import org.robolectric.Robolectric;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.annotation.Config;
+
+import java.util.ArrayList;
+
+@RunWith(RobolectricTestRunner.class)
+@Config(shadows = {ShadowSettingsPreferenceFragment.class, ShadowUtils.class, ShadowFragment.class,
+        ShadowUserManager.class})
+public class FingerprintSettingsFragmentTest {
+    private FingerprintSettingsFragment mFragment;
+    private Context mContext;
+    private FragmentActivity mActivity;
+
+    @Rule
+    public final MockitoRule mMockitoRule = MockitoJUnit.rule();
+    @Mock
+    private FingerprintManager mFingerprintManager;
+    @Mock
+    private FragmentTransaction mFragmentTransaction;
+
+    @Before
+    public void setUp() {
+        doReturn(true).when(mFingerprintManager).isHardwareDetected();
+        ShadowUtils.setFingerprintManager(mFingerprintManager);
+        FakeFeatureFactory.setupForTest();
+
+        Intent intent = new Intent();
+        intent.putExtra(ChooseLockSettingsHelper.EXTRA_KEY_CHALLENGE_TOKEN, new byte[0]);
+        intent.putExtra(ChooseLockSettingsHelper.EXTRA_KEY_GK_PW_HANDLE, 1L);
+        mActivity = spy(Robolectric.buildActivity(FragmentActivity.class, intent).get());
+        mContext = spy(ApplicationProvider.getApplicationContext());
+
+        mFragment = spy(new FingerprintSettingsFragment());
+        doReturn(mActivity).when(mFragment).getActivity();
+        doReturn(mContext).when(mFragment).getContext();
+
+        FragmentManager fragmentManager = mock(FragmentManager.class);
+        doReturn(mFragmentTransaction).when(fragmentManager).beginTransaction();
+        doReturn(mFragmentTransaction).when(mFragmentTransaction).add(any(), anyString());
+        doReturn(fragmentManager).when(mFragment).getFragmentManager();
+        doReturn(fragmentManager).when(mActivity).getSupportFragmentManager();
+
+        doNothing().when(mFragment).startActivityForResult(any(Intent.class), anyInt());
+    }
+
+    @After
+    public void tearDown() {
+        ShadowUtils.reset();
+    }
+
+    @Test
+    public void testAddFingerprint_onUdfpsDevice_inFullScreen_noDialog() {
+        setSensorType(TYPE_UDFPS_OPTICAL);
+
+        // Start fragment
+        mFragment.onAttach(mContext);
+        mFragment.onCreate(null);
+        mFragment.onCreateView(LayoutInflater.from(mContext), mock(ViewGroup.class), Bundle.EMPTY);
+        mFragment.onResume();
+
+        // Click "Add Fingerprint"
+        final Preference preference = new Preference(mContext);
+        preference.setKey(KEY_FINGERPRINT_ADD);
+        mFragment.onPreferenceTreeClick(preference);
+
+        verify(mFragment).startActivityForResult(any(), eq(ADD_FINGERPRINT_REQUEST));
+        verify(mFragmentTransaction, never()).add(any(),
+                eq(FingerprintSettingsFragment.FingerprintSplitScreenDialog.class.getName()));
+
+    }
+
+    @Test
+    public void testAddFingerprint_onUdfpsDevice_inMultiWindow_showsDialog() {
+        setSensorType(TYPE_UDFPS_OPTICAL);
+
+        // Start fragment
+        mFragment.onAttach(mContext);
+        mFragment.onCreate(null);
+        mFragment.onCreateView(LayoutInflater.from(mContext), mock(ViewGroup.class), Bundle.EMPTY);
+        mFragment.onResume();
+
+        doReturn(true).when(mActivity).isInMultiWindowMode();
+
+        // Click "Add Fingerprint"
+        final Preference preference = new Preference(mContext);
+        preference.setKey(KEY_FINGERPRINT_ADD);
+        mFragment.onPreferenceTreeClick(preference);
+
+        verify(mFragment, times(0)).startActivityForResult(any(), eq(ADD_FINGERPRINT_REQUEST));
+        verify(mFragmentTransaction).add(any(),
+                eq(FingerprintSettingsFragment.FingerprintSplitScreenDialog.class.getName()));
+    }
+
+    @Test
+    public void testAddFingerprint_onSfpsDevice_inMultiWindow_noDialog() {
+        setSensorType(TYPE_POWER_BUTTON);
+
+        // Start fragment
+        mFragment.onAttach(mContext);
+        mFragment.onCreate(null);
+        mFragment.onCreateView(LayoutInflater.from(mContext), mock(ViewGroup.class), Bundle.EMPTY);
+        mFragment.onResume();
+
+        doReturn(true).when(mActivity).isInMultiWindowMode();
+
+        // Click "Add Fingerprint"
+        final Preference preference = new Preference(mContext);
+        preference.setKey(KEY_FINGERPRINT_ADD);
+        mFragment.onPreferenceTreeClick(preference);
+
+        verify(mFragment).startActivityForResult(any(), eq(ADD_FINGERPRINT_REQUEST));
+        verify(mFragmentTransaction, never()).add(any(),
+                eq(FingerprintSettingsFragment.FingerprintSplitScreenDialog.class.getName()));
+    }
+
+    private void setSensorType(@FingerprintSensorProperties.SensorType int sensorType) {
+        final ArrayList<FingerprintSensorPropertiesInternal> props = new ArrayList<>();
+        props.add(new FingerprintSensorPropertiesInternal(
+                0 /* sensorId */,
+                SensorProperties.STRENGTH_STRONG,
+                1 /* maxEnrollmentsPerUser */,
+                new ArrayList<ComponentInfoInternal>(),
+                sensorType,
+                true /* resetLockoutRequiresHardwareAuthToken */));
+        doReturn(props).when(mFingerprintManager).getSensorPropertiesInternal();
+    }
+}