Fingerprint Introduction FragmentActivity

Introducing MVVM architecture & fragments to biometric settings.
Here, we modify the first page of FingerprintEnrollIntroduction to use
new MVVM with Fragment architecture.

And with this new architecture, unit test and screen order will be
easier to be written or changed.

Bug: 236072782
Test: atest FingerprintEnrollmentViewModelTest AutoCredentialViewModelTest
	    FingerprintEnrollIntroViewModelTest FingerprintRepositoryTest
Change-Id: Icf12c91625db86c2c99081a0108203e607e77f74

AndroidManifest.xml

@@ -2384,6 +2384,11 @@
             </intent-filter>
         </activity>
 
+        <activity android:name=".biometrics2.ui.view.FingerprintEnrollmentActivity"
+            android:exported="true"
+            android:permission="android.permission.MANAGE_FINGERPRINT"
+            android:theme="@style/GlifTheme.Light"/>
+
         <activity android:name=".biometrics.fingerprint.FingerprintEnrollIntroductionInternal"
                   android:exported="false"
                   android:theme="@style/GlifTheme.Light"

res/layout/biometric_enrollment_container.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<androidx.fragment.app.FragmentContainerView
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:id="@+id/fragment_container_view"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent" />

src/com/android/settings/activityembedding/ActivityEmbeddingRulesController.java

@@ -39,6 +39,7 @@ import com.android.settings.SubSettings;
 import com.android.settings.biometrics.fingerprint.FingerprintEnrollEnrolling;
 import com.android.settings.biometrics.fingerprint.FingerprintEnrollIntroduction;
 import com.android.settings.biometrics.fingerprint.FingerprintEnrollIntroductionInternal;
+import com.android.settings.biometrics2.ui.view.FingerprintEnrollmentActivity;
 import com.android.settings.core.FeatureFlags;
 import com.android.settings.homepage.DeepLinkHomepageActivity;
 import com.android.settings.homepage.DeepLinkHomepageActivityInternal;
@@ -225,6 +226,7 @@ public class ActivityEmbeddingRulesController {
                     .buildSearchIntent(mContext, SettingsEnums.SETTINGS_HOMEPAGE);
             addActivityFilter(activityFilters, searchIntent);
         }
+        addActivityFilter(activityFilters, FingerprintEnrollmentActivity.class);
         addActivityFilter(activityFilters, FingerprintEnrollIntroduction.class);
         addActivityFilter(activityFilters, FingerprintEnrollIntroductionInternal.class);
         addActivityFilter(activityFilters, FingerprintEnrollEnrolling.class);

src/com/android/settings/biometrics/BiometricUtils.java

@@ -25,6 +25,7 @@ import android.content.IntentSender;
 import android.hardware.biometrics.SensorProperties;
 import android.hardware.face.FaceManager;
 import android.hardware.face.FaceSensorPropertiesInternal;
+import android.os.Bundle;
 import android.os.storage.StorageManager;
 import android.util.Log;
 import android.view.Surface;
@@ -145,6 +146,31 @@ public class BiometricUtils {
         }
     }
 
+    /**
+     * @param context caller's context
+     * @param isSuw if it is running in setup wizard flows
+     * @param suwExtras setup wizard extras for new intent
+     * @return Intent for starting ChooseLock*
+     */
+    public static Intent getChooseLockIntent(@NonNull Context context,
+            boolean isSuw, @NonNull Bundle suwExtras) {
+        if (isSuw) {
+            // Default to PIN lock in setup wizard
+            Intent intent = new Intent(context, SetupChooseLockGeneric.class);
+            if (StorageManager.isFileEncrypted()) {
+                intent.putExtra(
+                        LockPatternUtils.PASSWORD_TYPE_KEY,
+                        DevicePolicyManager.PASSWORD_QUALITY_NUMERIC);
+                intent.putExtra(ChooseLockGeneric.ChooseLockGenericFragment
+                        .EXTRA_SHOW_OPTIONS_BUTTON, true);
+            }
+            intent.putExtras(suwExtras);
+            return intent;
+        } else {
+            return new Intent(context, ChooseLockGeneric.class);
+        }
+    }
+
     /**
      * @param context caller's context
      * @param activityIntent The intent that started the caller's activity

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

@@ -32,7 +32,7 @@ public class SetupFingerprintEnrollIntroduction extends FingerprintEnrollIntrodu
     /**
      * Returns the number of fingerprint enrolled.
      */
-    private static final String EXTRA_FINGERPRINT_ENROLLED_COUNT = "fingerprint_enrolled_count";
+    public static final String EXTRA_FINGERPRINT_ENROLLED_COUNT = "fingerprint_enrolled_count";
 
     private static final String KEY_LOCK_SCREEN_PRESENT = "wasLockScreenPresent";
 

src/com/android/settings/biometrics2/data/repository/FingerprintRepository.java

@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2022 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.biometrics2.data.repository;
+
+import static android.hardware.biometrics.BiometricAuthenticator.TYPE_FINGERPRINT;
+
+import android.app.admin.DevicePolicyManager;
+import android.content.Context;
+import android.content.res.Resources;
+import android.hardware.fingerprint.Fingerprint;
+import android.hardware.fingerprint.FingerprintManager;
+import android.hardware.fingerprint.FingerprintSensorPropertiesInternal;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.android.settings.R;
+import com.android.settings.biometrics.ParentalControlsUtils;
+import com.android.settingslib.RestrictedLockUtilsInternal;
+
+import java.util.List;
+
+/**
+ * This repository is used to call all APIs in {@link FingerprintManager}
+ */
+public class FingerprintRepository {
+
+    @NonNull private final FingerprintManager mFingerprintManager;
+
+    public FingerprintRepository(@NonNull FingerprintManager fingerprintManager) {
+        mFingerprintManager = fingerprintManager;
+    }
+
+    /**
+     * The first sensor type is UDFPS sensor or not
+     */
+    public boolean canAssumeUdfps() {
+        FingerprintSensorPropertiesInternal prop = getFirstFingerprintSensorPropertiesInternal();
+        return prop != null && prop.isAnyUdfpsType();
+    }
+
+    /**
+     * Get max possible number of fingerprints for a user
+     */
+    public int getMaxFingerprints() {
+        FingerprintSensorPropertiesInternal prop = getFirstFingerprintSensorPropertiesInternal();
+        return prop != null ? prop.maxEnrollmentsPerUser : 0;
+    }
+
+    /**
+     * Get number of fingerprints that this user enrolled.
+     */
+    public int getNumOfEnrolledFingerprintsSize(int userId) {
+        final List<Fingerprint> list = mFingerprintManager.getEnrolledFingerprints(userId);
+        return list != null ? list.size() : 0;
+    }
+
+    /**
+     * Get maximum possible fingerprints in setup wizard flow
+     */
+    public int getMaxFingerprintsInSuw(@NonNull Resources resources) {
+        return resources.getInteger(R.integer.suw_max_fingerprints_enrollable);
+    }
+
+    @Nullable
+    private FingerprintSensorPropertiesInternal getFirstFingerprintSensorPropertiesInternal() {
+        final List<FingerprintSensorPropertiesInternal> props =
+                mFingerprintManager.getSensorPropertiesInternal();
+        return props.size() > 0 ? props.get(0) : null;
+    }
+
+    /**
+     * Call FingerprintManager to generate challenge for first sensor
+     */
+    public void generateChallenge(int userId,
+            @NonNull FingerprintManager.GenerateChallengeCallback callback) {
+        mFingerprintManager.generateChallenge(userId, callback);
+    }
+
+    /**
+     * Get parental consent required or not during enrollment process
+     */
+    public boolean isParentalConsentRequired(@NonNull Context context) {
+        return ParentalControlsUtils.parentConsentRequired(context, TYPE_FINGERPRINT) != null;
+    }
+
+    /**
+     * Get fingerprint is disable by admin or not
+     */
+    public boolean isDisabledByAdmin(@NonNull Context context, int userId) {
+        return RestrictedLockUtilsInternal.checkIfKeyguardFeaturesDisabled(
+                context, DevicePolicyManager.KEYGUARD_DISABLE_FINGERPRINT, userId) != null;
+    }
+}

src/com/android/settings/biometrics2/factory/BiometricsFragmentFactory.java

@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2022 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.biometrics2.factory;
+
+import android.app.Application;
+import android.app.admin.DevicePolicyManager;
+
+import androidx.annotation.NonNull;
+import androidx.fragment.app.Fragment;
+import androidx.fragment.app.FragmentFactory;
+import androidx.lifecycle.ViewModelProvider;
+
+import com.android.settings.biometrics2.ui.view.FingerprintEnrollIntroFragment;
+
+/**
+ * Fragment factory for biometrics
+ */
+public class BiometricsFragmentFactory extends FragmentFactory {
+
+    private final Application mApplication;
+    private final ViewModelProvider mViewModelProvider;
+
+    public BiometricsFragmentFactory(Application application,
+            ViewModelProvider viewModelProvider) {
+        mApplication = application;
+        mViewModelProvider = viewModelProvider;
+    }
+
+    @NonNull
+    @Override
+    public Fragment instantiate(@NonNull ClassLoader classLoader, @NonNull String className) {
+        final Class<? extends Fragment> clazz = loadFragmentClass(classLoader, className);
+        if (FingerprintEnrollIntroFragment.class.equals(clazz)) {
+            final DevicePolicyManager devicePolicyManager =
+                    mApplication.getSystemService(DevicePolicyManager.class);
+            if (devicePolicyManager != null) {
+                return new FingerprintEnrollIntroFragment(mViewModelProvider,
+                        devicePolicyManager.getResources());
+            }
+        }
+        return super.instantiate(classLoader, className);
+    }
+}

src/com/android/settings/biometrics2/factory/BiometricsRepositoryProvider.java

@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2022 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.biometrics2.factory;
+
+import android.app.Application;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.android.settings.biometrics2.data.repository.FingerprintRepository;
+
+/**
+ * Interface for BiometricsRepositoryProvider
+ */
+public interface BiometricsRepositoryProvider {
+
+    /**
+     * Get FingerprintRepository
+     */
+    @Nullable
+    FingerprintRepository getFingerprintRepository(@NonNull Application application);
+}

src/com/android/settings/biometrics2/factory/BiometricsRepositoryProviderImpl.java

@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2022 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.biometrics2.factory;
+
+import android.app.Application;
+import android.hardware.fingerprint.FingerprintManager;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.android.settings.Utils;
+import com.android.settings.biometrics2.data.repository.FingerprintRepository;
+
+/**
+ * Implementation for BiometricsRepositoryProvider
+ */
+public class BiometricsRepositoryProviderImpl implements BiometricsRepositoryProvider {
+
+    /**
+     * Get FingerprintRepository
+     */
+    @Nullable
+    @Override
+    public FingerprintRepository getFingerprintRepository(@NonNull Application application) {
+        final FingerprintManager fingerprintManager =
+                Utils.getFingerprintManagerOrNull(application);
+        if (fingerprintManager == null) {
+            return null;
+        }
+        return new FingerprintRepository(fingerprintManager);
+    }
+}

src/com/android/settings/biometrics2/factory/BiometricsViewModelFactory.java

@@ -0,0 +1,84 @@
+/*
+ * Copyright (C) 2022 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.biometrics2.factory;
+
+import android.app.Application;
+import android.app.KeyguardManager;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.lifecycle.ViewModel;
+import androidx.lifecycle.ViewModelProvider;
+import androidx.lifecycle.ViewModelProvider.AndroidViewModelFactory;
+import androidx.lifecycle.viewmodel.CreationExtras;
+
+import com.android.internal.widget.LockPatternUtils;
+import com.android.settings.biometrics2.data.repository.FingerprintRepository;
+import com.android.settings.biometrics2.ui.viewmodel.AutoCredentialViewModel;
+import com.android.settings.biometrics2.ui.viewmodel.AutoCredentialViewModel.ChallengeGenerator;
+import com.android.settings.biometrics2.ui.viewmodel.FingerprintEnrollIntroViewModel;
+import com.android.settings.biometrics2.ui.viewmodel.FingerprintEnrollmentViewModel;
+import com.android.settings.overlay.FeatureFactory;
+
+/**
+ * View model factory for biometric enrollment fragment
+ */
+public class BiometricsViewModelFactory implements ViewModelProvider.Factory {
+
+    private static final String TAG = "BiometricsViewModelFact";
+
+    public static final CreationExtras.Key<ChallengeGenerator> CHALLENGE_GENERATOR =
+            new CreationExtras.Key<>() {};
+
+    @NonNull
+    @Override
+    @SuppressWarnings("unchecked")
+    public <T extends ViewModel> T create(@NonNull Class<T> modelClass,
+            @NonNull CreationExtras extras) {
+        final Application application = extras.get(AndroidViewModelFactory.APPLICATION_KEY);
+
+        if (application == null) {
+            Log.w(TAG, "create, null application");
+            return create(modelClass);
+        }
+        final FeatureFactory featureFactory = FeatureFactory.getFactory(application);
+        final BiometricsRepositoryProvider provider = FeatureFactory.getFactory(application)
+                .getBiometricsRepositoryProvider();
+
+        if (modelClass.isAssignableFrom(FingerprintEnrollIntroViewModel.class)) {
+            final FingerprintRepository repository = provider.getFingerprintRepository(application);
+            if (repository != null) {
+                return (T) new FingerprintEnrollIntroViewModel(application, repository);
+            }
+        } else if (modelClass.isAssignableFrom(FingerprintEnrollmentViewModel.class)) {
+            final FingerprintRepository repository = provider.getFingerprintRepository(application);
+            if (repository != null) {
+                return (T) new FingerprintEnrollmentViewModel(application, repository,
+                        application.getSystemService(KeyguardManager.class));
+            }
+        } else if (modelClass.isAssignableFrom(AutoCredentialViewModel.class)) {
+            final LockPatternUtils lockPatternUtils =
+                    featureFactory.getSecurityFeatureProvider().getLockPatternUtils(application);
+            final ChallengeGenerator challengeGenerator = extras.get(CHALLENGE_GENERATOR);
+            if (challengeGenerator != null) {
+                return (T) new AutoCredentialViewModel(application, lockPatternUtils,
+                        challengeGenerator);
+            }
+        }
+        return create(modelClass);
+    }
+}

src/com/android/settings/biometrics2/ui/model/CredentialModel.java

@@ -0,0 +1,202 @@
+/*
+ * Copyright (C) 2022 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.biometrics2.ui.model;
+
+import static com.android.settings.biometrics.BiometricEnrollBase.EXTRA_KEY_CHALLENGE;
+import static com.android.settings.biometrics.BiometricEnrollBase.EXTRA_KEY_SENSOR_ID;
+import static com.android.settings.password.ChooseLockSettingsHelper.EXTRA_KEY_CHALLENGE_TOKEN;
+import static com.android.settings.password.ChooseLockSettingsHelper.EXTRA_KEY_GK_PW_HANDLE;
+
+import android.content.Intent;
+import android.os.UserHandle;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.VisibleForTesting;
+
+import java.time.Clock;
+
+/**
+ * Secret credential data including
+ * 1. userId
+ * 2. sensorId
+ * 3. challenge
+ * 4. token
+ * 5. gkPwHandle
+ */
+public final class CredentialModel {
+
+    /**
+     * Default value for an invalid challenge
+     */
+    @VisibleForTesting
+    public static final long INVALID_CHALLENGE = -1L;
+
+    /**
+     * Default value if GkPwHandle is invalid.
+     */
+    public static final long INVALID_GK_PW_HANDLE = 0L;
+
+    /**
+     * Default value for a invalid sensor id
+     */
+    @VisibleForTesting
+    public static final int INVALID_SENSOR_ID = -1;
+
+    private final Clock mClock;
+
+    private final long mInitMillis;
+
+    private final int mUserId;
+
+    private int mSensorId;
+    @Nullable
+    private Long mUpdateSensorIdMillis = null;
+
+    private long mChallenge;
+    @Nullable
+    private Long mUpdateChallengeMillis = null;
+
+    @Nullable
+    private byte[] mToken;
+    @Nullable
+    private Long mUpdateTokenMillis = null;
+
+    private long mGkPwHandle;
+    @Nullable
+    private Long mClearGkPwHandleMillis = null;
+
+    public CredentialModel(@NonNull Intent intent, @NonNull Clock clock) {
+        mUserId = intent.getIntExtra(Intent.EXTRA_USER_ID, UserHandle.myUserId());
+        mSensorId = intent.getIntExtra(EXTRA_KEY_SENSOR_ID, INVALID_SENSOR_ID);
+        mChallenge = intent.getLongExtra(EXTRA_KEY_CHALLENGE, INVALID_CHALLENGE);
+        mToken = intent.getByteArrayExtra(EXTRA_KEY_CHALLENGE_TOKEN);
+        mGkPwHandle = intent.getLongExtra(EXTRA_KEY_GK_PW_HANDLE,
+                INVALID_GK_PW_HANDLE);
+        mClock = clock;
+        mInitMillis = mClock.millis();
+    }
+
+    /**
+     * Get userId for this credential
+     */
+    public int getUserId() {
+        return mUserId;
+    }
+
+    /**
+     * Check user id is valid or not
+     */
+    public static boolean isValidUserId(int userId) {
+        return userId != UserHandle.USER_NULL;
+    }
+
+    /**
+     * Get challenge
+     */
+    public long getChallenge() {
+        return mChallenge;
+    }
+
+    /**
+     * Set challenge
+     */
+    public void setChallenge(long value) {
+        mUpdateChallengeMillis = mClock.millis();
+        mChallenge = value;
+    }
+
+    /**
+     * Get challenge token
+     */
+    @Nullable
+    public byte[] getToken() {
+        return mToken;
+    }
+
+    /**
+     * Set challenge token
+     */
+    public void setToken(@Nullable byte[] value) {
+        mUpdateTokenMillis = mClock.millis();
+        mToken = value;
+    }
+
+    /**
+     * Check challengeToken is valid or not
+     */
+    public static boolean isValidToken(@Nullable byte[] token) {
+        return token != null;
+    }
+
+    /**
+     * Get gatekeeper password handle
+     */
+    public long getGkPwHandle() {
+        return mGkPwHandle;
+    }
+
+    /**
+     * Clear gatekeeper password handle data
+     */
+    public void clearGkPwHandle() {
+        mClearGkPwHandleMillis = mClock.millis();
+        mGkPwHandle = INVALID_GK_PW_HANDLE;
+    }
+
+    /**
+     * Check gkPwHandle is valid or not
+     */
+    public static boolean isValidGkPwHandle(long gkPwHandle) {
+        return gkPwHandle != INVALID_GK_PW_HANDLE;
+    }
+
+    /**
+     * Get sensor id
+     */
+    public int getSensorId() {
+        return mSensorId;
+    }
+
+    /**
+     * Set sensor id
+     */
+    public void setSensorId(int value) {
+        mUpdateSensorIdMillis = mClock.millis();
+        mSensorId = value;
+    }
+
+    /**
+     * Returns a string representation of the object
+     */
+    @Override
+    public String toString() {
+        final int gkPwHandleLen = ("" + mGkPwHandle).length();
+        final int tokenLen = mToken == null ? 0 : mToken.length;
+        final int challengeLen = ("" + mChallenge).length();
+        return getClass().getSimpleName() + ":{initMillis:" + mInitMillis
+                + ", userId:" + mUserId
+                + ", challenge:{len:" + challengeLen
+                + ", updateMillis:" + mUpdateChallengeMillis + "}"
+                + ", token:{len:" + tokenLen + ", isValid:" + isValidToken(mToken)
+                + ", updateMillis:" + mUpdateTokenMillis + "}"
+                + ", gkPwHandle:{len:" + gkPwHandleLen + ", isValid:"
+                + isValidGkPwHandle(mGkPwHandle) + ", clearMillis:" + mClearGkPwHandleMillis + "}"
+                + ", mSensorId:{id:" + mSensorId + ", updateMillis:" + mUpdateSensorIdMillis + "}"
+                + " }";
+    }
+}

src/com/android/settings/biometrics2/ui/model/EnrollmentRequest.java

@@ -0,0 +1,99 @@
+/*
+ * Copyright (C) 2022 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.biometrics2.ui.model;
+
+import static com.android.settings.biometrics.BiometricEnrollBase.EXTRA_FROM_SETTINGS_SUMMARY;
+
+import static com.google.android.setupcompat.util.WizardManagerHelper.EXTRA_IS_SUW_SUGGESTED_ACTION_FLOW;
+
+import android.content.Context;
+import android.content.Intent;
+import android.os.Bundle;
+
+import androidx.annotation.NonNull;
+
+import com.android.settings.SetupWizardUtils;
+
+import com.google.android.setupcompat.util.WizardManagerHelper;
+
+/**
+ * Biometric enrollment generic intent data, which includes
+ * 1. isSuw
+ * 2. isAfterSuwOrSuwSuggestedAction
+ * 3. theme
+ * 4. isFromSettingsSummery
+ * 5. a helper method, getSetupWizardExtras
+ */
+public final class EnrollmentRequest {
+
+    private final boolean mIsSuw;
+    private final boolean mIsAfterSuwOrSuwSuggestedAction;
+    private final boolean mIsFromSettingsSummery;
+    private final int mTheme;
+    private final Bundle mSuwExtras;
+
+    public EnrollmentRequest(@NonNull Intent intent, @NonNull Context context) {
+        mIsSuw = WizardManagerHelper.isAnySetupWizard(intent);
+        mIsAfterSuwOrSuwSuggestedAction = WizardManagerHelper.isDeferredSetupWizard(intent)
+                || WizardManagerHelper.isPortalSetupWizard(intent)
+                || intent.getBooleanExtra(EXTRA_IS_SUW_SUGGESTED_ACTION_FLOW, false);
+        mSuwExtras = getSuwExtras(mIsSuw, intent);
+        mIsFromSettingsSummery = intent.getBooleanExtra(EXTRA_FROM_SETTINGS_SUMMARY, false);
+        mTheme = SetupWizardUtils.getTheme(context, intent);
+    }
+
+    public boolean isSuw() {
+        return mIsSuw;
+    }
+
+    public boolean isAfterSuwOrSuwSuggestedAction() {
+        return mIsAfterSuwOrSuwSuggestedAction;
+    }
+
+    public boolean isFromSettingsSummery() {
+        return mIsFromSettingsSummery;
+    }
+
+    public int getTheme() {
+        return mTheme;
+    }
+
+    @NonNull
+    public Bundle getSuwExtras() {
+        return new Bundle(mSuwExtras);
+    }
+
+    /**
+     * Returns a string representation of the object
+     */
+    @Override
+    public String toString() {
+        return getClass().getSimpleName() + ":{isSuw:" + mIsSuw
+                + ", isAfterSuwOrSuwSuggestedAction:" + mIsAfterSuwOrSuwSuggestedAction
+                + ", isFromSettingsSummery:" + mIsFromSettingsSummery
+                + "}";
+    }
+
+    @NonNull
+    private static Bundle getSuwExtras(boolean isSuw, @NonNull Intent intent) {
+        final Intent toIntent = new Intent();
+        if (isSuw) {
+            SetupWizardUtils.copySetupExtras(intent, toIntent);
+        }
+        return toIntent.getExtras() != null ? toIntent.getExtras() : new Bundle();
+    }
+}

src/com/android/settings/biometrics2/ui/model/FingerprintEnrollIntroStatus.java

@@ -0,0 +1,81 @@
+/*
+ * Copyright (C) 2022 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.biometrics2.ui.model;
+
+import android.annotation.IntDef;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/**
+ * Fingerprint onboarding introduction page data, it contains following information which needs
+ * to be passed from view model to view.
+ * 1. mEnrollableStatus: User is allowed to enroll a new fingerprint or not.
+ * 2. mHasScrollToBottom: User has scrolled to the bottom of this page or not.
+ */
+public final class FingerprintEnrollIntroStatus {
+
+    /**
+     * Unconfirmed case, it means that this value is invalid, and view shall bypass this value.
+     */
+    public static final int FINGERPRINT_ENROLLABLE_UNKNOWN = -1;
+
+    /**
+     * User is allowed to enrolled a new fingerprint.
+     */
+    public static final int FINGERPRINT_ENROLLABLE_OK = 0;
+
+    /**
+     * User is not allowed to enrolled a new fingerprint because the number of enrolled fingerprint
+     * has reached maximum.
+     */
+    public static final int FINGERPRINT_ENROLLABLE_ERROR_REACH_MAX = 1;
+
+    @IntDef(prefix = {"FINGERPRINT_ENROLLABLE_"}, value = {
+            FINGERPRINT_ENROLLABLE_UNKNOWN,
+            FINGERPRINT_ENROLLABLE_OK,
+            FINGERPRINT_ENROLLABLE_ERROR_REACH_MAX
+    })
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface FingerprintEnrollableStatus {
+    }
+
+    private final boolean mHasScrollToBottom;
+
+    @FingerprintEnrollableStatus
+    private final int mEnrollableStatus;
+
+    public FingerprintEnrollIntroStatus(boolean hasScrollToBottom, int enrollableStatus) {
+        mEnrollableStatus = enrollableStatus;
+        mHasScrollToBottom = hasScrollToBottom;
+    }
+
+    /**
+     * Get enrollable status. It means that user is allowed to enroll a new fingerprint or not.
+     */
+    @FingerprintEnrollableStatus
+    public int getEnrollableStatus() {
+        return mEnrollableStatus;
+    }
+
+    /**
+     * Get info for this onboarding introduction page has scrolled to bottom or not
+     */
+    public boolean hasScrollToBottom() {
+        return mHasScrollToBottom;
+    }
+}

src/com/android/settings/biometrics2/ui/view/FingerprintEnrollIntroFragment.java

@@ -0,0 +1,288 @@
+/*
+ * Copyright (C) 2022 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.biometrics2.ui.view;
+
+import static android.app.admin.DevicePolicyResources.Strings.Settings.FINGERPRINT_UNLOCK_DISABLED;
+
+import static com.android.settings.biometrics2.ui.model.FingerprintEnrollIntroStatus.FINGERPRINT_ENROLLABLE_ERROR_REACH_MAX;
+import static com.android.settings.biometrics2.ui.model.FingerprintEnrollIntroStatus.FINGERPRINT_ENROLLABLE_OK;
+import static com.android.settings.biometrics2.ui.model.FingerprintEnrollIntroStatus.FINGERPRINT_ENROLLABLE_UNKNOWN;
+
+import static com.google.android.setupdesign.util.DynamicColorPalette.ColorType.ACCENT;
+
+import android.app.Activity;
+import android.app.admin.DevicePolicyResourcesManager;
+import android.content.Context;
+import android.graphics.PorterDuff;
+import android.graphics.PorterDuffColorFilter;
+import android.os.Bundle;
+import android.text.Html;
+import android.text.TextUtils;
+import android.text.method.LinkMovementMethod;
+import android.util.Log;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ImageView;
+import android.widget.TextView;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.StringRes;
+import androidx.fragment.app.Fragment;
+import androidx.lifecycle.ViewModelProvider;
+
+import com.android.settings.R;
+import com.android.settings.biometrics2.ui.model.FingerprintEnrollIntroStatus;
+import com.android.settings.biometrics2.ui.viewmodel.FingerprintEnrollIntroViewModel;
+
+import com.google.android.setupcompat.template.FooterBarMixin;
+import com.google.android.setupcompat.template.FooterButton;
+import com.google.android.setupdesign.GlifLayout;
+import com.google.android.setupdesign.template.RequireScrollMixin;
+import com.google.android.setupdesign.util.DynamicColorPalette;
+
+/**
+ * Fingerprint intro onboarding page fragment implementation
+ */
+public class FingerprintEnrollIntroFragment extends Fragment {
+
+    private static final String TAG = "FingerprintEnrollIntroFragment";
+
+    @NonNull private final ViewModelProvider mViewModelProvider;
+    @Nullable private final DevicePolicyResourcesManager mDevicePolicyMgrRes;
+
+    private FingerprintEnrollIntroViewModel mViewModel = null;
+
+    private View mView = null;
+    private FooterButton mPrimaryFooterButton = null;
+    private FooterButton mSecondaryFooterButton = null;
+    private ImageView mIconShield = null;
+    private TextView mFooterMessage6 = null;
+    @Nullable private PorterDuffColorFilter mIconColorFilter;
+
+    public FingerprintEnrollIntroFragment(
+            @NonNull ViewModelProvider viewModelProvider,
+            @Nullable DevicePolicyResourcesManager devicePolicyMgrRes) {
+        super();
+        mViewModelProvider = viewModelProvider;
+        mDevicePolicyMgrRes = devicePolicyMgrRes;
+    }
+
+    @Nullable
+    @Override
+    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container,
+            @Nullable Bundle savedInstanceState) {
+
+        final Context context = inflater.getContext();
+        mView = inflater.inflate(R.layout.fingerprint_enroll_introduction, container);
+
+        final ImageView iconFingerprint = mView.findViewById(R.id.icon_fingerprint);
+        final ImageView iconDeviceLocked = mView.findViewById(R.id.icon_device_locked);
+        final ImageView iconTrashCan = mView.findViewById(R.id.icon_trash_can);
+        final ImageView iconInfo = mView.findViewById(R.id.icon_info);
+        mIconShield = mView.findViewById(R.id.icon_shield);
+        final ImageView iconLink = mView.findViewById(R.id.icon_link);
+        iconFingerprint.getDrawable().setColorFilter(getIconColorFilter(context));
+        iconDeviceLocked.getDrawable().setColorFilter(getIconColorFilter(context));
+        iconTrashCan.getDrawable().setColorFilter(getIconColorFilter(context));
+        iconInfo.getDrawable().setColorFilter(getIconColorFilter(context));
+        mIconShield.getDrawable().setColorFilter(getIconColorFilter(context));
+        iconLink.getDrawable().setColorFilter(getIconColorFilter(context));
+
+        final TextView footerMessage2 = mView.findViewById(R.id.footer_message_2);
+        final TextView footerMessage3 = mView.findViewById(R.id.footer_message_3);
+        final TextView footerMessage4 = mView.findViewById(R.id.footer_message_4);
+        final TextView footerMessage5 = mView.findViewById(R.id.footer_message_5);
+        mFooterMessage6 = mView.findViewById(R.id.footer_message_6);
+        footerMessage2.setText(
+                R.string.security_settings_fingerprint_v2_enroll_introduction_footer_message_2);
+        footerMessage3.setText(
+                R.string.security_settings_fingerprint_v2_enroll_introduction_footer_message_3);
+        footerMessage4.setText(
+                R.string.security_settings_fingerprint_v2_enroll_introduction_footer_message_4);
+        footerMessage5.setText(
+                R.string.security_settings_fingerprint_v2_enroll_introduction_footer_message_5);
+        mFooterMessage6.setText(
+                R.string.security_settings_fingerprint_v2_enroll_introduction_footer_message_6);
+
+        final TextView footerTitle1 = mView.findViewById(R.id.footer_title_1);
+        final TextView footerTitle2 = mView.findViewById(R.id.footer_title_2);
+        footerTitle1.setText(
+                R.string.security_settings_fingerprint_enroll_introduction_footer_title_1);
+        footerTitle2.setText(
+                R.string.security_settings_fingerprint_enroll_introduction_footer_title_2);
+
+        return mView;
+    }
+
+    @Override
+    public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
+        super.onViewCreated(view, savedInstanceState);
+
+        final Context context = view.getContext();
+
+        final TextView footerLink = mView.findViewById(R.id.footer_learn_more);
+        footerLink.setMovementMethod(LinkMovementMethod.getInstance());
+        final String footerLinkStr = getContext().getString(
+                R.string.security_settings_fingerprint_v2_enroll_introduction_message_learn_more,
+                Html.FROM_HTML_MODE_LEGACY);
+        footerLink.setText(Html.fromHtml(footerLinkStr));
+
+        // footer buttons
+        mPrimaryFooterButton = new FooterButton.Builder(context)
+                .setText(R.string.security_settings_fingerprint_enroll_introduction_agree)
+                .setListener(mViewModel::onNextButtonClick)
+                .setButtonType(FooterButton.ButtonType.OPT_IN)
+                .setTheme(R.style.SudGlifButton_Primary)
+                .build();
+        mSecondaryFooterButton = new FooterButton.Builder(context)
+                .setListener(mViewModel::onSkipOrCancelButtonClick)
+                .setButtonType(FooterButton.ButtonType.NEXT)
+                .setTheme(R.style.SudGlifButton_Primary)
+                .build();
+        getFooterBarMixin().setPrimaryButton(mPrimaryFooterButton);
+        getFooterBarMixin().setSecondaryButton(mSecondaryFooterButton, true /* usePrimaryStyle */);
+
+        if (mViewModel.canAssumeUdfps()) {
+            mFooterMessage6.setVisibility(View.VISIBLE);
+            mIconShield.setVisibility(View.VISIBLE);
+        } else {
+            mFooterMessage6.setVisibility(View.GONE);
+            mIconShield.setVisibility(View.GONE);
+        }
+        mSecondaryFooterButton.setText(getContext(),
+                mViewModel.getEnrollmentRequest().isAfterSuwOrSuwSuggestedAction()
+                ? R.string.security_settings_fingerprint_enroll_introduction_cancel
+                : R.string.security_settings_fingerprint_enroll_introduction_no_thanks);
+
+        if (mViewModel.isBiometricUnlockDisabledByAdmin()
+                && !mViewModel.isParentalConsentRequired()) {
+            setHeaderText(
+                    getActivity(),
+                    R.string.security_settings_fingerprint_enroll_introduction_title_unlock_disabled
+            );
+            getLayout().setDescriptionText(getDescriptionDisabledByAdmin(context));
+        } else {
+            setHeaderText(getActivity(),
+                    R.string.security_settings_fingerprint_enroll_introduction_title);
+        }
+
+        mViewModel.getPageStatusLiveData().observe(this, this::updateFooterButtons);
+
+        final RequireScrollMixin requireScrollMixin = getLayout()
+                .getMixin(RequireScrollMixin.class);
+        requireScrollMixin.requireScrollWithButton(getActivity(), mPrimaryFooterButton,
+                getMoreButtonTextRes(), mViewModel::onNextButtonClick);
+        requireScrollMixin.setOnRequireScrollStateChangedListener(scrollNeeded -> {
+            if (!scrollNeeded) {
+                mViewModel.setHasScrolledToBottom();
+            }
+        });
+    }
+
+    @Override
+    public void onAttach(@NonNull Context context) {
+        mViewModel = mViewModelProvider.get(FingerprintEnrollIntroViewModel.class);
+        getLifecycle().addObserver(mViewModel);
+        super.onAttach(context);
+    }
+
+    @Override
+    public void onDetach() {
+        getLifecycle().removeObserver(mViewModel);
+        super.onDetach();
+    }
+
+    @NonNull
+    private PorterDuffColorFilter getIconColorFilter(@NonNull Context context) {
+        if (mIconColorFilter == null) {
+            mIconColorFilter = new PorterDuffColorFilter(
+                    DynamicColorPalette.getColor(context, ACCENT),
+                    PorterDuff.Mode.SRC_IN);
+        }
+        return mIconColorFilter;
+    }
+
+    private GlifLayout getLayout() {
+        return mView.findViewById(R.id.setup_wizard_layout);
+    }
+
+    @NonNull
+    private FooterBarMixin getFooterBarMixin() {
+        final GlifLayout layout = getLayout();
+        return layout.getMixin(FooterBarMixin.class);
+    }
+
+    @NonNull
+    private String getDescriptionDisabledByAdmin(@NonNull Context context) {
+        final int defaultStrId =
+                R.string.security_settings_fingerprint_enroll_introduction_message_unlock_disabled;
+        if (mDevicePolicyMgrRes == null) {
+            Log.w(TAG, "getDescriptionDisabledByAdmin, null device policy manager res");
+            return "";
+        }
+        return mDevicePolicyMgrRes.getString(FINGERPRINT_UNLOCK_DISABLED,
+                () -> context.getString(defaultStrId));
+    }
+
+    private void setHeaderText(@NonNull Activity activity, int resId) {
+        TextView layoutTitle = getLayout().getHeaderTextView();
+        CharSequence previousTitle = layoutTitle.getText();
+        CharSequence title = activity.getText(resId);
+        if (previousTitle != title) {
+            if (!TextUtils.isEmpty(previousTitle)) {
+                layoutTitle.setAccessibilityLiveRegion(View.ACCESSIBILITY_LIVE_REGION_POLITE);
+            }
+            getLayout().setHeaderText(title);
+            getLayout().getHeaderTextView().setContentDescription(title);
+            activity.setTitle(title);
+        }
+        getLayout().getHeaderTextView().setContentDescription(activity.getText(resId));
+    }
+
+    void updateFooterButtons(@NonNull FingerprintEnrollIntroStatus status) {
+        @StringRes final int scrollToBottomPrimaryResId =
+                status.getEnrollableStatus() == FINGERPRINT_ENROLLABLE_OK
+                        ? R.string.security_settings_fingerprint_enroll_introduction_agree
+                        : R.string.done;
+
+        mPrimaryFooterButton.setText(getContext(),
+                status.hasScrollToBottom() ? scrollToBottomPrimaryResId : getMoreButtonTextRes());
+        mSecondaryFooterButton.setVisibility(
+                status.hasScrollToBottom() ? View.VISIBLE : View.INVISIBLE);
+
+        final TextView errorTextView = mView.findViewById(R.id.error_text);
+        switch (status.getEnrollableStatus()) {
+            case FINGERPRINT_ENROLLABLE_OK:
+                errorTextView.setText(null);
+                errorTextView.setVisibility(View.GONE);
+                break;
+            case FINGERPRINT_ENROLLABLE_ERROR_REACH_MAX:
+                errorTextView.setText(R.string.fingerprint_intro_error_max);
+                errorTextView.setVisibility(View.VISIBLE);
+                break;
+            case FINGERPRINT_ENROLLABLE_UNKNOWN:
+                // default case, do nothing.
+        }
+    }
+
+    @StringRes
+    private int getMoreButtonTextRes() {
+        return R.string.security_settings_face_enroll_introduction_more;
+    }
+}

src/com/android/settings/biometrics2/ui/view/FingerprintEnrollmentActivity.java

@@ -0,0 +1,276 @@
+/*
+ * Copyright (C) 2022 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.biometrics2.ui.view;
+
+import static androidx.lifecycle.ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY;
+
+import static com.android.settings.biometrics2.factory.BiometricsViewModelFactory.CHALLENGE_GENERATOR;
+import static com.android.settings.biometrics2.ui.viewmodel.AutoCredentialViewModel.CREDENTIAL_FAIL_DURING_GENERATE_CHALLENGE;
+import static com.android.settings.biometrics2.ui.viewmodel.AutoCredentialViewModel.CREDENTIAL_FAIL_NEED_TO_CHOOSE_LOCK;
+import static com.android.settings.biometrics2.ui.viewmodel.AutoCredentialViewModel.CREDENTIAL_FAIL_NEED_TO_CONFIRM_LOCK;
+import static com.android.settings.biometrics2.ui.viewmodel.FingerprintEnrollIntroViewModel.FINGERPRINT_ENROLL_INTRO_ACTION_CONTINUE_ENROLL;
+import static com.android.settings.biometrics2.ui.viewmodel.FingerprintEnrollIntroViewModel.FINGERPRINT_ENROLL_INTRO_ACTION_DONE_AND_FINISH;
+import static com.android.settings.biometrics2.ui.viewmodel.FingerprintEnrollIntroViewModel.FINGERPRINT_ENROLL_INTRO_ACTION_SKIP_OR_CANCEL;
+
+import android.app.Activity;
+import android.app.Application;
+import android.content.Intent;
+import android.content.res.ColorStateList;
+import android.graphics.Color;
+import android.os.Bundle;
+import android.os.SystemClock;
+import android.util.Log;
+
+import androidx.activity.result.ActivityResult;
+import androidx.activity.result.ActivityResultLauncher;
+import androidx.activity.result.contract.ActivityResultContracts;
+import androidx.annotation.ColorInt;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.fragment.app.FragmentActivity;
+import androidx.fragment.app.FragmentManager;
+import androidx.lifecycle.ViewModelProvider;
+import androidx.lifecycle.viewmodel.CreationExtras;
+import androidx.lifecycle.viewmodel.MutableCreationExtras;
+
+import com.android.settings.R;
+import com.android.settings.Utils;
+import com.android.settings.biometrics.BiometricEnrollBase;
+import com.android.settings.biometrics.fingerprint.FingerprintEnrollFindSensor;
+import com.android.settings.biometrics.fingerprint.SetupFingerprintEnrollEnrolling;
+import com.android.settings.biometrics2.data.repository.FingerprintRepository;
+import com.android.settings.biometrics2.factory.BiometricsFragmentFactory;
+import com.android.settings.biometrics2.factory.BiometricsViewModelFactory;
+import com.android.settings.biometrics2.ui.model.CredentialModel;
+import com.android.settings.biometrics2.ui.model.EnrollmentRequest;
+import com.android.settings.biometrics2.ui.viewmodel.AutoCredentialViewModel;
+import com.android.settings.biometrics2.ui.viewmodel.AutoCredentialViewModel.FingerprintChallengeGenerator;
+import com.android.settings.biometrics2.ui.viewmodel.FingerprintEnrollIntroViewModel;
+import com.android.settings.biometrics2.ui.viewmodel.FingerprintEnrollmentViewModel;
+import com.android.settings.overlay.FeatureFactory;
+
+import com.google.android.setupdesign.util.ThemeHelper;
+
+/**
+ * Fingerprint enrollment activity implementation
+ */
+public class FingerprintEnrollmentActivity extends FragmentActivity {
+
+    private static final String TAG = "FingerprintEnrollmentActivity";
+
+    protected static final int LAUNCH_CONFIRM_LOCK_ACTIVITY = 1;
+
+    private FingerprintEnrollmentViewModel mViewModel;
+    private AutoCredentialViewModel mAutoCredentialViewModel;
+    private ActivityResultLauncher<Intent> mNextActivityLauncher;
+    private ActivityResultLauncher<Intent> mChooseLockLauncher;
+
+    @Override
+    protected void onCreate(@Nullable Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        mNextActivityLauncher = registerForActivityResult(
+                new ActivityResultContracts.StartActivityForResult(),
+                (it) -> mViewModel.onContinueEnrollActivityResult(
+                        it,
+                        mAutoCredentialViewModel.getUserId())
+        );
+        mChooseLockLauncher = registerForActivityResult(
+                new ActivityResultContracts.StartActivityForResult(),
+                (it) -> onChooseOrConfirmLockResult(true, it)
+        );
+
+        ViewModelProvider viewModelProvider = new ViewModelProvider(this);
+
+        mViewModel = viewModelProvider.get(FingerprintEnrollmentViewModel.class);
+        mViewModel.setRequest(new EnrollmentRequest(getIntent(), getApplicationContext()));
+        mViewModel.setSavedInstanceState(savedInstanceState);
+        getLifecycle().addObserver(mViewModel);
+
+        mAutoCredentialViewModel = viewModelProvider.get(AutoCredentialViewModel.class);
+        mAutoCredentialViewModel.setCredentialModel(new CredentialModel(getIntent(),
+                SystemClock.elapsedRealtimeClock()));
+        getLifecycle().addObserver(mAutoCredentialViewModel);
+
+        mViewModel.getSetResultLiveData().observe(this, this::onSetActivityResult);
+        mAutoCredentialViewModel.getActionLiveData().observe(this, this::onCredentialAction);
+
+        // Theme
+        setTheme(mViewModel.getRequest().getTheme());
+        ThemeHelper.trySetDynamicColor(this);
+        getWindow().setStatusBarColor(android.graphics.Color.TRANSPARENT);
+
+        // fragment
+        setContentView(R.layout.biometric_enrollment_container);
+        final FragmentManager fragmentManager = getSupportFragmentManager();
+        fragmentManager.setFragmentFactory(
+                new BiometricsFragmentFactory(getApplication(), viewModelProvider));
+
+        final FingerprintEnrollIntroViewModel fingerprintEnrollIntroViewModel =
+                viewModelProvider.get(FingerprintEnrollIntroViewModel.class);
+        fingerprintEnrollIntroViewModel.setEnrollmentRequest(mViewModel.getRequest());
+        fingerprintEnrollIntroViewModel.setUserId(mAutoCredentialViewModel.getUserId());
+        fingerprintEnrollIntroViewModel.getActionLiveData().observe(
+                this, this::observeIntroAction);
+        final String tag = "FingerprintEnrollIntroFragment";
+        fragmentManager.beginTransaction()
+                .setReorderingAllowed(true)
+                .add(R.id.fragment_container_view, FingerprintEnrollIntroFragment.class, null, tag)
+                .commit();
+    }
+
+    private void onSetActivityResult(@NonNull ActivityResult result) {
+        setResult(mViewModel.getRequest().isAfterSuwOrSuwSuggestedAction()
+                        ? RESULT_CANCELED
+                        : result.getResultCode(),
+                result.getData());
+        finish();
+    }
+
+    private void onCredentialAction(@NonNull Integer action) {
+        switch (action) {
+            case CREDENTIAL_FAIL_NEED_TO_CHOOSE_LOCK: {
+                final Intent intent = mAutoCredentialViewModel.getChooseLockIntent(this,
+                        mViewModel.getRequest().isSuw(), mViewModel.getRequest().getSuwExtras());
+                if (!mViewModel.isWaitingActivityResult().compareAndSet(false, true)) {
+                    Log.w(TAG, "chooseLock, fail to set isWaiting flag to true");
+                }
+                mChooseLockLauncher.launch(intent);
+                return;
+            }
+            case CREDENTIAL_FAIL_NEED_TO_CONFIRM_LOCK: {
+                final boolean launched = mAutoCredentialViewModel.getConfirmLockLauncher(
+                        this,
+                        LAUNCH_CONFIRM_LOCK_ACTIVITY,
+                        getString(R.string.security_settings_fingerprint_preference_title)
+                ).launch();
+                if (!launched) {
+                    // This shouldn't happen, as we should only end up at this step if a lock thingy
+                    // is already set.
+                    Log.e(TAG, "confirmLock, launched is true");
+                    finish();
+                } else if (!mViewModel.isWaitingActivityResult().compareAndSet(false, true)) {
+                    Log.w(TAG, "confirmLock, fail to set isWaiting flag to true");
+                }
+                return;
+            }
+            case CREDENTIAL_FAIL_DURING_GENERATE_CHALLENGE: {
+                Log.w(TAG, "observeCredentialLiveData, finish with action:" + action);
+                if (mViewModel.getRequest().isAfterSuwOrSuwSuggestedAction()) {
+                    setResult(Activity.RESULT_CANCELED);
+                }
+                finish();
+            }
+        }
+    }
+
+    private void onChooseOrConfirmLockResult(boolean isChooseLock,
+            @NonNull ActivityResult activityResult) {
+        if (!mViewModel.isWaitingActivityResult().compareAndSet(true, false)) {
+            Log.w(TAG, "isChooseLock:" + isChooseLock + ", fail to unset waiting flag");
+        }
+        if (mAutoCredentialViewModel.checkNewCredentialFromActivityResult(
+                isChooseLock, activityResult)) {
+            overridePendingTransition(R.anim.sud_slide_next_in, R.anim.sud_slide_next_out);
+        }
+    }
+
+    private void observeIntroAction(@NonNull Integer action) {
+        switch (action) {
+            case FINGERPRINT_ENROLL_INTRO_ACTION_DONE_AND_FINISH: {
+                onSetActivityResult(
+                        new ActivityResult(BiometricEnrollBase.RESULT_FINISHED, null));
+                return;
+            }
+            case FINGERPRINT_ENROLL_INTRO_ACTION_SKIP_OR_CANCEL: {
+                onSetActivityResult(
+                        new ActivityResult(BiometricEnrollBase.RESULT_SKIP, null));
+                return;
+            }
+            case FINGERPRINT_ENROLL_INTRO_ACTION_CONTINUE_ENROLL: {
+                final boolean isSuw = mViewModel.getRequest().isSuw();
+                if (!mViewModel.isWaitingActivityResult().compareAndSet(false, true)) {
+                    Log.w(TAG, "startNext, isSuw:" + isSuw + ", fail to set isWaiting flag");
+                }
+                final Intent intent = new Intent(this, isSuw
+                        ? SetupFingerprintEnrollEnrolling.class
+                        : FingerprintEnrollFindSensor.class);
+                intent.putExtras(mAutoCredentialViewModel.getCredentialBundle());
+                intent.putExtras(mViewModel.getNextActivityBaseIntentExtras());
+                mNextActivityLauncher.launch(intent);
+            }
+        }
+    }
+
+    @Override
+    protected void onPause() {
+        super.onPause();
+        mViewModel.checkFinishActivityDuringOnPause(isFinishing(), isChangingConfigurations());
+    }
+
+    @Override
+    protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
+        if (requestCode == LAUNCH_CONFIRM_LOCK_ACTIVITY) {
+            onChooseOrConfirmLockResult(false, new ActivityResult(resultCode, data));
+            return;
+        }
+        super.onActivityResult(requestCode, resultCode, data);
+    }
+
+    @NonNull
+    @Override
+    public CreationExtras getDefaultViewModelCreationExtras() {
+        final Application application =
+                super.getDefaultViewModelCreationExtras().get(APPLICATION_KEY);
+        final MutableCreationExtras ret = new MutableCreationExtras();
+        ret.set(APPLICATION_KEY, application);
+        final FingerprintRepository repository = FeatureFactory.getFactory(application)
+                .getBiometricsRepositoryProvider().getFingerprintRepository(application);
+        ret.set(CHALLENGE_GENERATOR, new FingerprintChallengeGenerator(repository));
+        return ret;
+    }
+
+    @NonNull
+    @Override
+    public ViewModelProvider.Factory getDefaultViewModelProviderFactory() {
+        return new BiometricsViewModelFactory();
+    }
+
+    @Override
+    public void onAttachedToWindow() {
+        super.onAttachedToWindow();
+        getWindow().setStatusBarColor(getBackgroundColor());
+    }
+
+    @ColorInt
+    private int getBackgroundColor() {
+        final ColorStateList stateList = Utils.getColorAttr(this, android.R.attr.windowBackground);
+        return stateList != null ? stateList.getDefaultColor() : Color.TRANSPARENT;
+    }
+
+    @Override
+    protected void onDestroy() {
+        getLifecycle().removeObserver(mViewModel);
+        super.onDestroy();
+    }
+
+    @Override
+    protected void onSaveInstanceState(@NonNull Bundle outState) {
+        super.onSaveInstanceState(outState);
+        mViewModel.onSaveInstanceState(outState);
+    }
+}

src/com/android/settings/biometrics2/ui/viewmodel/AutoCredentialViewModel.java

@@ -0,0 +1,354 @@
+/*
+ * Copyright (C) 2022 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.biometrics2.ui.viewmodel;
+
+import static android.app.admin.DevicePolicyManager.PASSWORD_QUALITY_UNSPECIFIED;
+
+import static com.android.settings.biometrics.BiometricEnrollBase.EXTRA_KEY_CHALLENGE;
+import static com.android.settings.biometrics.BiometricEnrollBase.EXTRA_KEY_SENSOR_ID;
+import static com.android.settings.biometrics2.ui.model.CredentialModel.INVALID_GK_PW_HANDLE;
+import static com.android.settings.password.ChooseLockSettingsHelper.EXTRA_KEY_CHALLENGE_TOKEN;
+import static com.android.settings.password.ChooseLockSettingsHelper.EXTRA_KEY_GK_PW_HANDLE;
+
+import android.annotation.IntDef;
+import android.app.Activity;
+import android.app.Application;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Bundle;
+import android.util.Log;
+
+import androidx.activity.result.ActivityResult;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.lifecycle.AndroidViewModel;
+import androidx.lifecycle.DefaultLifecycleObserver;
+import androidx.lifecycle.LifecycleOwner;
+import androidx.lifecycle.LiveData;
+import androidx.lifecycle.MutableLiveData;
+
+import com.android.internal.widget.LockPatternUtils;
+import com.android.internal.widget.VerifyCredentialResponse;
+import com.android.settings.biometrics.BiometricUtils;
+import com.android.settings.biometrics2.data.repository.FingerprintRepository;
+import com.android.settings.biometrics2.ui.model.CredentialModel;
+import com.android.settings.password.ChooseLockGeneric;
+import com.android.settings.password.ChooseLockPattern;
+import com.android.settings.password.ChooseLockSettingsHelper;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/**
+ * AutoCredentialViewModel which uses CredentialModel to determine next actions for activity, like
+ * start ChooseLockActivity, start ConfirmLockActivity, GenerateCredential, or do nothing.
+ */
+public class AutoCredentialViewModel extends AndroidViewModel implements DefaultLifecycleObserver {
+
+    private static final String TAG = "AutoCredentialViewModel";
+    private static final boolean DEBUG = true;
+
+    /**
+     * Need activity to run choose lock
+     */
+    public static final int CREDENTIAL_FAIL_NEED_TO_CHOOSE_LOCK = 1;
+
+    /**
+     * Need activity to run confirm lock
+     */
+    public static final int CREDENTIAL_FAIL_NEED_TO_CONFIRM_LOCK = 2;
+
+    /**
+     * Fail to use challenge from hardware generateChallenge(), shall finish activity with proper
+     * error code
+     */
+    public static final int CREDENTIAL_FAIL_DURING_GENERATE_CHALLENGE = 3;
+
+    @IntDef(prefix = { "CREDENTIAL_" }, value = {
+            CREDENTIAL_FAIL_NEED_TO_CHOOSE_LOCK,
+            CREDENTIAL_FAIL_NEED_TO_CONFIRM_LOCK,
+            CREDENTIAL_FAIL_DURING_GENERATE_CHALLENGE
+    })
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface CredentialAction {}
+
+    /**
+     * Generic callback for FingerprintManager#generateChallenge or FaceManager#generateChallenge
+     */
+    public interface GenerateChallengeCallback {
+        /**
+         * Generic generateChallenge method for FingerprintManager or FaceManager
+         */
+        void onChallengeGenerated(int sensorId, int userId, long challenge);
+    }
+
+    /**
+     * A generic interface class for calling different generateChallenge from FingerprintManager or
+     * FaceManager
+     */
+    public interface ChallengeGenerator {
+        /**
+         * Get callback that will be called later after challenge generated
+         */
+        @Nullable
+        GenerateChallengeCallback getCallback();
+
+        /**
+         * Set callback that will be called later after challenge generated
+         */
+        void setCallback(@Nullable GenerateChallengeCallback callback);
+
+        /**
+         * Method for generating challenge from FingerprintManager or FaceManager
+         */
+        void generateChallenge(int userId);
+    }
+
+    /**
+     * Used to generate challenge through FingerprintRepository
+     */
+    public static class FingerprintChallengeGenerator implements ChallengeGenerator {
+
+        private static final String TAG = "FingerprintChallengeGenerator";
+
+        @NonNull
+        private final FingerprintRepository mFingerprintRepository;
+
+        @Nullable
+        private GenerateChallengeCallback mCallback = null;
+
+        public FingerprintChallengeGenerator(@NonNull FingerprintRepository fingerprintRepository) {
+            mFingerprintRepository = fingerprintRepository;
+        }
+
+        @Nullable
+        @Override
+        public GenerateChallengeCallback getCallback() {
+            return mCallback;
+        }
+
+        @Override
+        public void setCallback(@Nullable GenerateChallengeCallback callback) {
+            mCallback = callback;
+        }
+
+        @Override
+        public void generateChallenge(int userId) {
+            final GenerateChallengeCallback callback = mCallback;
+            if (callback == null) {
+                Log.e(TAG, "generateChallenge, null callback");
+                return;
+            }
+            mFingerprintRepository.generateChallenge(userId, callback::onChallengeGenerated);
+        }
+    }
+
+
+    @NonNull private final LockPatternUtils mLockPatternUtils;
+    @NonNull private final ChallengeGenerator mChallengeGenerator;
+    private CredentialModel mCredentialModel = null;
+    @NonNull private final MutableLiveData<Integer> mActionLiveData =
+            new MutableLiveData<>();
+
+    public AutoCredentialViewModel(
+            @NonNull Application application,
+            @NonNull LockPatternUtils lockPatternUtils,
+            @NonNull ChallengeGenerator challengeGenerator) {
+        super(application);
+        mLockPatternUtils = lockPatternUtils;
+        mChallengeGenerator = challengeGenerator;
+    }
+
+    public void setCredentialModel(@NonNull CredentialModel credentialModel) {
+        mCredentialModel = credentialModel;
+    }
+
+    /**
+     * Observe ActionLiveData for actions about choosing lock, confirming lock, or finishing
+     * activity
+     */
+    @NonNull
+    public LiveData<Integer> getActionLiveData() {
+        return mActionLiveData;
+    }
+
+    @Override
+    public void onCreate(@NonNull LifecycleOwner owner) {
+        checkCredential();
+    }
+
+    /**
+     * Check credential status for biometric enrollment.
+     */
+    private void checkCredential() {
+        if (isValidCredential()) {
+            return;
+        }
+        final long gkPwHandle = mCredentialModel.getGkPwHandle();
+        if (isUnspecifiedPassword()) {
+            mActionLiveData.postValue(CREDENTIAL_FAIL_NEED_TO_CHOOSE_LOCK);
+        } else if (CredentialModel.isValidGkPwHandle(gkPwHandle)) {
+            generateChallenge(gkPwHandle);
+        } else {
+            mActionLiveData.postValue(CREDENTIAL_FAIL_NEED_TO_CONFIRM_LOCK);
+        }
+    }
+
+    private void generateChallenge(long gkPwHandle) {
+        mChallengeGenerator.setCallback((sensorId, userId, challenge) -> {
+            mCredentialModel.setSensorId(sensorId);
+            mCredentialModel.setChallenge(challenge);
+            try {
+                final byte[] newToken = requestGatekeeperHat(gkPwHandle, challenge, userId);
+                mCredentialModel.setToken(newToken);
+            } catch (IllegalStateException e) {
+                Log.e(TAG, "generateChallenge, IllegalStateException", e);
+                mActionLiveData.postValue(CREDENTIAL_FAIL_DURING_GENERATE_CHALLENGE);
+                return;
+            }
+
+            mLockPatternUtils.removeGatekeeperPasswordHandle(gkPwHandle);
+            mCredentialModel.clearGkPwHandle();
+
+            if (DEBUG) {
+                Log.d(TAG, "generateChallenge " + mCredentialModel);
+            }
+
+            // Check credential again
+            if (!isValidCredential()) {
+                Log.w(TAG, "generateChallenge, invalid Credential");
+                mActionLiveData.postValue(CREDENTIAL_FAIL_DURING_GENERATE_CHALLENGE);
+            }
+        });
+        mChallengeGenerator.generateChallenge(getUserId());
+    }
+
+    private boolean isValidCredential() {
+        return !isUnspecifiedPassword()
+                && CredentialModel.isValidToken(mCredentialModel.getToken());
+    }
+
+    private boolean isUnspecifiedPassword() {
+        return mLockPatternUtils.getActivePasswordQuality(getUserId())
+                == PASSWORD_QUALITY_UNSPECIFIED;
+    }
+
+    /**
+     * Handle activity result from ChooseLockGeneric, ConfirmLockPassword, or ConfirmLockPattern
+     * @param isChooseLock true if result is coming from ChooseLockGeneric. False if result is
+     *                     coming from ConfirmLockPassword or ConfirmLockPattern
+     * @param result activity result
+     * @return if it is a valid result
+     */
+    public boolean checkNewCredentialFromActivityResult(boolean isChooseLock,
+            @NonNull ActivityResult result) {
+        if ((isChooseLock && result.getResultCode() == ChooseLockPattern.RESULT_FINISHED)
+                || (!isChooseLock && result.getResultCode() == Activity.RESULT_OK)) {
+            final Intent data = result.getData();
+            if (data != null) {
+                final long gkPwHandle = result.getData().getLongExtra(
+                        EXTRA_KEY_GK_PW_HANDLE, INVALID_GK_PW_HANDLE);
+                generateChallenge(gkPwHandle);
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Get userId for this credential
+     */
+    public int getUserId() {
+        return mCredentialModel.getUserId();
+    }
+
+    @Nullable
+    private byte[] requestGatekeeperHat(long gkPwHandle, long challenge, int userId)
+            throws IllegalStateException {
+        final VerifyCredentialResponse response = mLockPatternUtils
+                .verifyGatekeeperPasswordHandle(gkPwHandle, challenge, userId);
+        if (!response.isMatched()) {
+            throw new IllegalStateException("Unable to request Gatekeeper HAT");
+        }
+        return response.getGatekeeperHAT();
+    }
+
+    /**
+     * Get Credential bundle which will be used to launch next activity.
+     */
+    @NonNull
+    public Bundle getCredentialBundle() {
+        final Bundle retBundle = new Bundle();
+        final long gkPwHandle = mCredentialModel.getGkPwHandle();
+        if (CredentialModel.isValidGkPwHandle(gkPwHandle)) {
+            retBundle.putLong(EXTRA_KEY_GK_PW_HANDLE, gkPwHandle);
+        }
+        final byte[] token = mCredentialModel.getToken();
+        if (CredentialModel.isValidToken(token)) {
+            retBundle.putByteArray(EXTRA_KEY_CHALLENGE_TOKEN, token);
+        }
+        final int userId = getUserId();
+        if (CredentialModel.isValidUserId(userId)) {
+            retBundle.putInt(Intent.EXTRA_USER_ID, userId);
+        }
+        retBundle.putLong(EXTRA_KEY_CHALLENGE, mCredentialModel.getChallenge());
+        retBundle.putInt(EXTRA_KEY_SENSOR_ID, mCredentialModel.getSensorId());
+        return retBundle;
+    }
+
+    /**
+     * Get Intent for choosing lock
+     */
+    @NonNull
+    public Intent getChooseLockIntent(@NonNull Context context, boolean isSuw,
+            @NonNull Bundle suwExtras) {
+        final Intent intent = BiometricUtils.getChooseLockIntent(context, isSuw,
+                suwExtras);
+        intent.putExtra(ChooseLockGeneric.ChooseLockGenericFragment.HIDE_INSECURE_OPTIONS,
+                true);
+        intent.putExtra(ChooseLockSettingsHelper.EXTRA_KEY_REQUEST_GK_PW_HANDLE, true);
+        intent.putExtra(ChooseLockSettingsHelper.EXTRA_KEY_FOR_FINGERPRINT, true);
+
+        final int userId = getUserId();
+        if (CredentialModel.isValidUserId(userId)) {
+            intent.putExtra(Intent.EXTRA_USER_ID, userId);
+        }
+        return intent;
+    }
+
+    /**
+     * Get ConfirmLockLauncher
+     */
+    @NonNull
+    public ChooseLockSettingsHelper getConfirmLockLauncher(@NonNull Activity activity,
+            int requestCode, @NonNull String title) {
+        final ChooseLockSettingsHelper.Builder builder =
+                new ChooseLockSettingsHelper.Builder(activity);
+        builder.setRequestCode(requestCode)
+                .setTitle(title)
+                .setRequestGatekeeperPasswordHandle(true)
+                .setForegroundOnly(true)
+                .setReturnCredentials(true);
+
+        final int userId = mCredentialModel.getUserId();
+        if (CredentialModel.isValidUserId(userId)) {
+            builder.setUserId(userId);
+        }
+        return builder.build();
+    }
+
+}

src/com/android/settings/biometrics2/ui/viewmodel/FingerprintEnrollIntroViewModel.java

@@ -0,0 +1,211 @@
+/*
+ * Copyright (C) 2022 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.biometrics2.ui.viewmodel;
+
+import static com.android.settings.biometrics2.ui.model.FingerprintEnrollIntroStatus.FINGERPRINT_ENROLLABLE_ERROR_REACH_MAX;
+import static com.android.settings.biometrics2.ui.model.FingerprintEnrollIntroStatus.FINGERPRINT_ENROLLABLE_OK;
+import static com.android.settings.biometrics2.ui.model.FingerprintEnrollIntroStatus.FINGERPRINT_ENROLLABLE_UNKNOWN;
+
+import android.annotation.IntDef;
+import android.app.Application;
+import android.os.UserHandle;
+import android.util.Log;
+import android.view.View;
+
+import androidx.annotation.NonNull;
+import androidx.lifecycle.AndroidViewModel;
+import androidx.lifecycle.DefaultLifecycleObserver;
+import androidx.lifecycle.LifecycleOwner;
+import androidx.lifecycle.LiveData;
+import androidx.lifecycle.MediatorLiveData;
+import androidx.lifecycle.MutableLiveData;
+
+import com.android.settings.biometrics2.data.repository.FingerprintRepository;
+import com.android.settings.biometrics2.ui.model.EnrollmentRequest;
+import com.android.settings.biometrics2.ui.model.FingerprintEnrollIntroStatus;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/**
+ * Fingerprint intro onboarding page view model implementation
+ */
+public class FingerprintEnrollIntroViewModel extends AndroidViewModel
+        implements DefaultLifecycleObserver {
+
+    private static final String TAG = "FingerprintEnrollIntroViewModel";
+    private static final boolean HAS_SCROLLED_TO_BOTTOM_DEFAULT = false;
+    private static final int ENROLLABLE_STATUS_DEFAULT = FINGERPRINT_ENROLLABLE_UNKNOWN;
+
+    /**
+     * User clicks 'Done' button on this page
+     */
+    public static final int FINGERPRINT_ENROLL_INTRO_ACTION_DONE_AND_FINISH = 0;
+
+    /**
+     * User clicks 'Agree' button on this page
+     */
+    public static final int FINGERPRINT_ENROLL_INTRO_ACTION_CONTINUE_ENROLL = 1;
+
+    /**
+     * User clicks 'Skip' button on this page
+     */
+    public static final int FINGERPRINT_ENROLL_INTRO_ACTION_SKIP_OR_CANCEL = 2;
+
+    @IntDef(prefix = { "FINGERPRINT_ENROLL_INTRO_ACTION_" }, value = {
+            FINGERPRINT_ENROLL_INTRO_ACTION_DONE_AND_FINISH,
+            FINGERPRINT_ENROLL_INTRO_ACTION_CONTINUE_ENROLL,
+            FINGERPRINT_ENROLL_INTRO_ACTION_SKIP_OR_CANCEL
+    })
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface FingerprintEnrollIntroAction {}
+
+    @NonNull private final FingerprintRepository mFingerprintRepository;
+
+    private final MutableLiveData<Boolean> mHasScrolledToBottomLiveData =
+            new MutableLiveData<>(HAS_SCROLLED_TO_BOTTOM_DEFAULT);
+    private final MutableLiveData<Integer> mEnrollableStatusLiveData =
+            new MutableLiveData<>(ENROLLABLE_STATUS_DEFAULT);
+    private final MediatorLiveData<FingerprintEnrollIntroStatus> mPageStatusLiveData =
+            new MediatorLiveData<>();
+    private final MutableLiveData<Integer> mActionLiveData = new MutableLiveData<>();
+    private int mUserId = UserHandle.myUserId();
+    private EnrollmentRequest mEnrollmentRequest = null;
+
+    public FingerprintEnrollIntroViewModel(@NonNull Application application,
+            @NonNull FingerprintRepository fingerprintRepository) {
+        super(application);
+        mFingerprintRepository = fingerprintRepository;
+
+        mPageStatusLiveData.addSource(
+                mEnrollableStatusLiveData,
+                enrollable -> {
+                    final Boolean toBottomValue = mHasScrolledToBottomLiveData.getValue();
+                    final FingerprintEnrollIntroStatus status = new FingerprintEnrollIntroStatus(
+                            toBottomValue != null ? toBottomValue : HAS_SCROLLED_TO_BOTTOM_DEFAULT,
+                            enrollable);
+                    mPageStatusLiveData.setValue(status);
+                });
+        mPageStatusLiveData.addSource(
+                mHasScrolledToBottomLiveData,
+                hasScrolledToBottom -> {
+                    final Integer enrollableValue = mEnrollableStatusLiveData.getValue();
+                    final FingerprintEnrollIntroStatus status = new FingerprintEnrollIntroStatus(
+                            hasScrolledToBottom,
+                            enrollableValue != null ? enrollableValue : ENROLLABLE_STATUS_DEFAULT);
+                    mPageStatusLiveData.setValue(status);
+                });
+    }
+
+    public void setUserId(int userId) {
+        mUserId = userId;
+    }
+
+    public void setEnrollmentRequest(@NonNull EnrollmentRequest enrollmentRequest) {
+        mEnrollmentRequest = enrollmentRequest;
+    }
+
+    /**
+     * Get enrollment request
+     */
+    public EnrollmentRequest getEnrollmentRequest() {
+        return mEnrollmentRequest;
+    }
+
+    private void updateEnrollableStatus() {
+        final int num = mFingerprintRepository.getNumOfEnrolledFingerprintsSize(mUserId);
+        final int max =
+                mEnrollmentRequest.isSuw() && !mEnrollmentRequest.isAfterSuwOrSuwSuggestedAction()
+                ? mFingerprintRepository.getMaxFingerprintsInSuw(getApplication().getResources())
+                : mFingerprintRepository.getMaxFingerprints();
+        mEnrollableStatusLiveData.postValue(num >= max
+                ? FINGERPRINT_ENROLLABLE_ERROR_REACH_MAX
+                : FINGERPRINT_ENROLLABLE_OK);
+    }
+
+    /**
+     * Get enrollable status and hasScrollToBottom live data
+     */
+    public LiveData<FingerprintEnrollIntroStatus> getPageStatusLiveData() {
+        return mPageStatusLiveData;
+    }
+
+    /**
+     * Get user's action live data (like clicking Agree, Skip, or Done)
+     */
+    public LiveData<Integer> getActionLiveData() {
+        return mActionLiveData;
+    }
+
+    /**
+     * The first sensor type is UDFPS sensor or not
+     */
+    public boolean canAssumeUdfps() {
+        return mFingerprintRepository.canAssumeUdfps();
+    }
+
+    /**
+     * Update onboarding intro page has scrolled to bottom
+     */
+    public void setHasScrolledToBottom() {
+        mHasScrolledToBottomLiveData.postValue(true);
+    }
+
+    /**
+     * Get parental consent required or not during enrollment process
+     */
+    public boolean isParentalConsentRequired() {
+        return mFingerprintRepository.isParentalConsentRequired(getApplication());
+    }
+
+    /**
+     * Get fingerprint is disable by admin or not
+     */
+    public boolean isBiometricUnlockDisabledByAdmin() {
+        return mFingerprintRepository.isDisabledByAdmin(getApplication(), mUserId);
+    }
+
+    /**
+     * User clicks next button
+     */
+    public void onNextButtonClick(View ignoredView) {
+        final Integer status = mEnrollableStatusLiveData.getValue();
+        switch (status != null ? status : ENROLLABLE_STATUS_DEFAULT) {
+            case FINGERPRINT_ENROLLABLE_ERROR_REACH_MAX:
+                mActionLiveData.postValue(FINGERPRINT_ENROLL_INTRO_ACTION_DONE_AND_FINISH);
+                break;
+            case FINGERPRINT_ENROLLABLE_OK:
+                mActionLiveData.postValue(FINGERPRINT_ENROLL_INTRO_ACTION_CONTINUE_ENROLL);
+                break;
+            default:
+                Log.w(TAG, "fail to click next, enrolled:" + status);
+        }
+    }
+
+    /**
+     * User clicks skip/cancel button
+     */
+    public void onSkipOrCancelButtonClick(View ignoredView) {
+        mActionLiveData.postValue(FINGERPRINT_ENROLL_INTRO_ACTION_SKIP_OR_CANCEL);
+    }
+
+    @Override
+    public void onStart(@NonNull LifecycleOwner owner) {
+        updateEnrollableStatus();
+    }
+
+}

src/com/android/settings/biometrics2/ui/viewmodel/FingerprintEnrollmentViewModel.java

@@ -0,0 +1,185 @@
+/*
+ * Copyright (C) 2022 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.biometrics2.ui.viewmodel;
+
+import static com.android.settings.biometrics.BiometricEnrollBase.EXTRA_FROM_SETTINGS_SUMMARY;
+import static com.android.settings.biometrics.BiometricEnrollBase.RESULT_FINISHED;
+import static com.android.settings.biometrics.BiometricEnrollBase.RESULT_SKIP;
+import static com.android.settings.biometrics.BiometricEnrollBase.RESULT_TIMEOUT;
+import static com.android.settings.biometrics.fingerprint.SetupFingerprintEnrollIntroduction.EXTRA_FINGERPRINT_ENROLLED_COUNT;
+
+import android.app.Application;
+import android.app.KeyguardManager;
+import android.content.Intent;
+import android.os.Bundle;
+import android.util.Log;
+
+import androidx.activity.result.ActivityResult;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.VisibleForTesting;
+import androidx.lifecycle.AndroidViewModel;
+import androidx.lifecycle.DefaultLifecycleObserver;
+import androidx.lifecycle.LiveData;
+import androidx.lifecycle.MutableLiveData;
+
+import com.android.settings.biometrics.BiometricEnrollBase;
+import com.android.settings.biometrics2.data.repository.FingerprintRepository;
+import com.android.settings.biometrics2.ui.model.EnrollmentRequest;
+import com.android.settings.password.SetupSkipDialog;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * Fingerprint enrollment view model implementation
+ */
+public class FingerprintEnrollmentViewModel extends AndroidViewModel implements
+        DefaultLifecycleObserver {
+
+    private static final String TAG = "FingerprintEnrollmentViewModel";
+
+    @VisibleForTesting
+    static final String SAVED_STATE_IS_WAITING_ACTIVITY_RESULT = "is_waiting_activity_result";
+
+    @NonNull private final FingerprintRepository mFingerprintRepository;
+    @Nullable private final KeyguardManager mKeyguardManager;
+
+    private final AtomicBoolean mIsWaitingActivityResult = new AtomicBoolean(false);
+    private final MutableLiveData<ActivityResult> mSetResultLiveData = new MutableLiveData<>();
+
+    /**
+     * Even this variable may be nullable, but activity will call setIntent() immediately during
+     * its onCreate(), we do not assign @Nullable for this variable here.
+     */
+    private EnrollmentRequest mRequest = null;
+
+    public FingerprintEnrollmentViewModel(
+            @NonNull Application application,
+            @NonNull FingerprintRepository fingerprintRepository,
+            @Nullable KeyguardManager keyguardManager) {
+        super(application);
+        mFingerprintRepository = fingerprintRepository;
+        mKeyguardManager = keyguardManager;
+    }
+
+    /**
+     * Set EnrollmentRequest
+     */
+    public void setRequest(@NonNull EnrollmentRequest request) {
+        mRequest = request;
+    }
+
+    /**
+     * Get EnrollmentRequest
+     */
+    public EnrollmentRequest getRequest() {
+        return mRequest;
+    }
+
+    /**
+     * Copy necessary extra data from activity intent
+     */
+    @NonNull
+    public Bundle getNextActivityBaseIntentExtras() {
+        final Bundle bundle = mRequest.getSuwExtras();
+        bundle.putBoolean(EXTRA_FROM_SETTINGS_SUMMARY, mRequest.isFromSettingsSummery());
+        return bundle;
+    }
+
+    /**
+     * Handle activity result from FingerprintFindSensor
+     */
+    public void onContinueEnrollActivityResult(@NonNull ActivityResult result, int userId) {
+        if (mIsWaitingActivityResult.compareAndSet(true, false)) {
+            Log.w(TAG, "fail to reset isWaiting flag for enrollment");
+        }
+        if (result.getResultCode() == RESULT_FINISHED
+                || result.getResultCode() == RESULT_TIMEOUT) {
+            Intent data = result.getData();
+            if (mRequest.isSuw() && isKeyguardSecure()
+                    && result.getResultCode() == RESULT_FINISHED) {
+                if (data == null) {
+                    data = new Intent();
+                }
+                data.putExtras(getSuwFingerprintCountExtra(userId));
+            }
+            mSetResultLiveData.postValue(new ActivityResult(result.getResultCode(), data));
+        } else if (result.getResultCode() == RESULT_SKIP
+                || result.getResultCode() == SetupSkipDialog.RESULT_SKIP) {
+            mSetResultLiveData.postValue(result);
+        }
+    }
+
+
+
+    private boolean isKeyguardSecure() {
+        return mKeyguardManager != null && mKeyguardManager.isKeyguardSecure();
+    }
+
+    /**
+     * Activity calls this method during onPause() to finish itself when back to background.
+     *
+     * @param isActivityFinishing Activity has called finish() or not
+     * @param isChangingConfigurations Activity is finished because of configuration changed or not.
+     */
+    public void checkFinishActivityDuringOnPause(boolean isActivityFinishing,
+            boolean isChangingConfigurations) {
+        if (isChangingConfigurations || isActivityFinishing || mRequest.isSuw()
+                || isWaitingActivityResult().get()) {
+            return;
+        }
+
+        mSetResultLiveData.postValue(new ActivityResult(BiometricEnrollBase.RESULT_TIMEOUT, null));
+    }
+
+    @NonNull
+    private Bundle getSuwFingerprintCountExtra(int userId) {
+        final Bundle bundle = new Bundle();
+        bundle.putInt(EXTRA_FINGERPRINT_ENROLLED_COUNT,
+                mFingerprintRepository.getNumOfEnrolledFingerprintsSize(userId));
+        return bundle;
+    }
+
+    @NonNull
+    public LiveData<ActivityResult> getSetResultLiveData() {
+        return mSetResultLiveData;
+    }
+
+    @NonNull
+    public AtomicBoolean isWaitingActivityResult() {
+        return mIsWaitingActivityResult;
+    }
+
+    /**
+     * Handle savedInstanceState from activity onCreated()
+     */
+    public void setSavedInstanceState(@Nullable Bundle savedInstanceState) {
+        if (savedInstanceState == null) {
+            return;
+        }
+        mIsWaitingActivityResult.set(
+                savedInstanceState.getBoolean(SAVED_STATE_IS_WAITING_ACTIVITY_RESULT, false)
+        );
+    }
+
+    /**
+     * Handle onSaveInstanceState from activity
+     */
+    public void onSaveInstanceState(@NonNull Bundle outState) {
+        outState.putBoolean(SAVED_STATE_IS_WAITING_ACTIVITY_RESULT, mIsWaitingActivityResult.get());
+    }
+}

src/com/android/settings/overlay/FeatureFactory.java

@@ -29,6 +29,7 @@ import com.android.settings.accounts.AccountFeatureProvider;
 import com.android.settings.applications.ApplicationFeatureProvider;
 import com.android.settings.aware.AwareFeatureProvider;
 import com.android.settings.biometrics.face.FaceFeatureProvider;
+import com.android.settings.biometrics2.factory.BiometricsRepositoryProvider;
 import com.android.settings.bluetooth.BluetoothFeatureProvider;
 import com.android.settings.dashboard.DashboardFeatureProvider;
 import com.android.settings.dashboard.suggestions.SuggestionFeatureProvider;
@@ -161,6 +162,11 @@ public abstract class FeatureFactory {
 
     public abstract FaceFeatureProvider getFaceFeatureProvider();
 
+    /**
+     * Gets implementation for Biometrics repository provider.
+     */
+    public abstract BiometricsRepositoryProvider getBiometricsRepositoryProvider();
+
     /**
      * Gets implementation for the WifiTrackerLib.
      */

src/com/android/settings/overlay/FeatureFactoryImpl.java

@@ -37,6 +37,8 @@ import com.android.settings.aware.AwareFeatureProvider;
 import com.android.settings.aware.AwareFeatureProviderImpl;
 import com.android.settings.biometrics.face.FaceFeatureProvider;
 import com.android.settings.biometrics.face.FaceFeatureProviderImpl;
+import com.android.settings.biometrics2.factory.BiometricsRepositoryProvider;
+import com.android.settings.biometrics2.factory.BiometricsRepositoryProviderImpl;
 import com.android.settings.bluetooth.BluetoothFeatureProvider;
 import com.android.settings.bluetooth.BluetoothFeatureProviderImpl;
 import com.android.settings.connecteddevice.dock.DockUpdaterFeatureProviderImpl;
@@ -104,6 +106,7 @@ public class FeatureFactoryImpl extends FeatureFactory {
     private BluetoothFeatureProvider mBluetoothFeatureProvider;
     private AwareFeatureProvider mAwareFeatureProvider;
     private FaceFeatureProvider mFaceFeatureProvider;
+    private BiometricsRepositoryProvider mBiometricsRepositoryProvider;
     private WifiTrackerLibProvider mWifiTrackerLibProvider;
     private SecuritySettingsFeatureProvider mSecuritySettingsFeatureProvider;
     private AccessibilitySearchFeatureProvider mAccessibilitySearchFeatureProvider;
@@ -305,6 +308,14 @@ public class FeatureFactoryImpl extends FeatureFactory {
         return mFaceFeatureProvider;
     }
 
+    @Override
+    public BiometricsRepositoryProvider getBiometricsRepositoryProvider() {
+        if (mBiometricsRepositoryProvider == null) {
+            mBiometricsRepositoryProvider = new BiometricsRepositoryProviderImpl();
+        }
+        return mBiometricsRepositoryProvider;
+    }
+
     @Override
     public WifiTrackerLibProvider getWifiTrackerLibProvider() {
         if (mWifiTrackerLibProvider == null) {

tests/robotests/src/com/android/settings/testutils/FakeFeatureFactory.java

@@ -27,6 +27,7 @@ import com.android.settings.accounts.AccountFeatureProvider;
 import com.android.settings.applications.ApplicationFeatureProvider;
 import com.android.settings.aware.AwareFeatureProvider;
 import com.android.settings.biometrics.face.FaceFeatureProvider;
+import com.android.settings.biometrics2.factory.BiometricsRepositoryProvider;
 import com.android.settings.bluetooth.BluetoothFeatureProvider;
 import com.android.settings.dashboard.DashboardFeatureProvider;
 import com.android.settings.dashboard.suggestions.SuggestionFeatureProvider;
@@ -78,6 +79,7 @@ public class FakeFeatureFactory extends FeatureFactory {
     public final BluetoothFeatureProvider mBluetoothFeatureProvider;
     public final AwareFeatureProvider mAwareFeatureProvider;
     public final FaceFeatureProvider mFaceFeatureProvider;
+    public final BiometricsRepositoryProvider mBiometricsRepositoryProvider;
 
     public PanelFeatureProvider panelFeatureProvider;
     public SlicesFeatureProvider slicesFeatureProvider;
@@ -134,6 +136,7 @@ public class FakeFeatureFactory extends FeatureFactory {
         mBluetoothFeatureProvider = mock(BluetoothFeatureProvider.class);
         mAwareFeatureProvider = mock(AwareFeatureProvider.class);
         mFaceFeatureProvider = mock(FaceFeatureProvider.class);
+        mBiometricsRepositoryProvider = mock(BiometricsRepositoryProvider.class);
         wifiTrackerLibProvider = mock(WifiTrackerLibProvider.class);
         securitySettingsFeatureProvider = mock(SecuritySettingsFeatureProvider.class);
         mAccessibilitySearchFeatureProvider = mock(AccessibilitySearchFeatureProvider.class);
@@ -256,6 +259,11 @@ public class FakeFeatureFactory extends FeatureFactory {
         return mFaceFeatureProvider;
     }
 
+    @Override
+    public BiometricsRepositoryProvider getBiometricsRepositoryProvider() {
+        return mBiometricsRepositoryProvider;
+    }
+
     @Override
     public WifiTrackerLibProvider getWifiTrackerLibProvider() {
         return wifiTrackerLibProvider;

tests/spa_unit/src/com/android/settings/testutils/FakeFeatureFactory.kt

@@ -23,6 +23,7 @@ import com.android.settings.accounts.AccountFeatureProvider
 import com.android.settings.applications.ApplicationFeatureProvider
 import com.android.settings.aware.AwareFeatureProvider
 import com.android.settings.biometrics.face.FaceFeatureProvider
+import com.android.settings.biometrics2.factory.BiometricsRepositoryProvider
 import com.android.settings.bluetooth.BluetoothFeatureProvider
 import com.android.settings.dashboard.DashboardFeatureProvider
 import com.android.settings.dashboard.suggestions.SuggestionFeatureProvider
@@ -153,6 +154,10 @@ class FakeFeatureFactory : FeatureFactory() {
         TODO("Not yet implemented")
     }
 
+    override fun getBiometricsRepositoryProvider(): BiometricsRepositoryProvider {
+        TODO("Not yet implemented")
+    }
+
     override fun getWifiTrackerLibProvider(): WifiTrackerLibProvider {
         TODO("Not yet implemented")
     }

tests/unit/src/com/android/settings/biometrics2/data/repository/FingerprintRepositoryTest.java

@@ -0,0 +1,125 @@
+/*
+ * Copyright (C) 2022 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.biometrics2.data.repository;
+
+import static android.hardware.fingerprint.FingerprintSensorProperties.TYPE_HOME_BUTTON;
+import static android.hardware.fingerprint.FingerprintSensorProperties.TYPE_POWER_BUTTON;
+import static android.hardware.fingerprint.FingerprintSensorProperties.TYPE_REAR;
+import static android.hardware.fingerprint.FingerprintSensorProperties.TYPE_UDFPS_OPTICAL;
+import static android.hardware.fingerprint.FingerprintSensorProperties.TYPE_UDFPS_ULTRASONIC;
+import static android.hardware.fingerprint.FingerprintSensorProperties.TYPE_UNKNOWN;
+
+import static com.android.settings.biometrics2.util.FingerprintManagerUtil.setupFingerprintEnrolledFingerprints;
+import static com.android.settings.biometrics2.util.FingerprintManagerUtil.setupFingerprintFirstSensor;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.Mockito.when;
+
+import android.content.Context;
+import android.content.res.Resources;
+import android.hardware.fingerprint.FingerprintManager;
+
+import androidx.annotation.NonNull;
+import androidx.test.core.app.ApplicationProvider;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+
+import com.android.settings.testutils.ResourcesUtils;
+
+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;
+
+@RunWith(AndroidJUnit4.class)
+public class FingerprintRepositoryTest {
+
+    @Rule public final MockitoRule mockito = MockitoJUnit.rule();
+
+    @Mock private Resources mResources;
+    @Mock private FingerprintManager mFingerprintManager;
+
+    private Context mContext;
+    private FingerprintRepository mFingerprintRepository;
+
+    @Before
+    public void setUp() {
+        mContext = ApplicationProvider.getApplicationContext();
+        mFingerprintRepository = new FingerprintRepository(mFingerprintManager);
+    }
+
+    @Test
+    public void testCanAssumeSensorType() {
+        setupFingerprintFirstSensor(mFingerprintManager, TYPE_UNKNOWN, 1);
+        assertThat(mFingerprintRepository.canAssumeUdfps()).isFalse();
+
+        setupFingerprintFirstSensor(mFingerprintManager, TYPE_REAR, 1);
+        assertThat(mFingerprintRepository.canAssumeUdfps()).isFalse();
+
+        setupFingerprintFirstSensor(mFingerprintManager, TYPE_UDFPS_ULTRASONIC, 1);
+        assertThat(mFingerprintRepository.canAssumeUdfps()).isTrue();
+
+        setupFingerprintFirstSensor(mFingerprintManager, TYPE_UDFPS_OPTICAL, 1);
+        assertThat(mFingerprintRepository.canAssumeUdfps()).isTrue();
+
+        setupFingerprintFirstSensor(mFingerprintManager, TYPE_POWER_BUTTON, 1);
+        assertThat(mFingerprintRepository.canAssumeUdfps()).isFalse();
+
+        setupFingerprintFirstSensor(mFingerprintManager, TYPE_HOME_BUTTON, 1);
+        assertThat(mFingerprintRepository.canAssumeUdfps()).isFalse();
+    }
+
+    @Test
+    public void testGetMaxFingerprints() {
+        setupFingerprintFirstSensor(mFingerprintManager, TYPE_UNKNOWN, 44);
+        assertThat(mFingerprintRepository.getMaxFingerprints()).isEqualTo(44);
+
+        setupFingerprintFirstSensor(mFingerprintManager, TYPE_UNKNOWN, 999);
+        assertThat(mFingerprintRepository.getMaxFingerprints()).isEqualTo(999);
+    }
+
+    @Test
+    public void testGetNumOfEnrolledFingerprintsSize() {
+        setupFingerprintEnrolledFingerprints(mFingerprintManager, 10, 3);
+        setupFingerprintEnrolledFingerprints(mFingerprintManager, 22, 99);
+
+        assertThat(mFingerprintRepository.getNumOfEnrolledFingerprintsSize(10)).isEqualTo(3);
+        assertThat(mFingerprintRepository.getNumOfEnrolledFingerprintsSize(22)).isEqualTo(99);
+    }
+
+    @Test
+    public void testGetMaxFingerprintsInSuw() {
+        setupSuwMaxFingerprintsEnrollable(mContext, mResources, 333);
+        assertThat(mFingerprintRepository.getMaxFingerprintsInSuw(mResources))
+                .isEqualTo(333);
+
+        setupSuwMaxFingerprintsEnrollable(mContext, mResources, 20);
+        assertThat(mFingerprintRepository.getMaxFingerprintsInSuw(mResources)).isEqualTo(20);
+    }
+
+    public static void setupSuwMaxFingerprintsEnrollable(
+            @NonNull Context context,
+            @NonNull Resources mockedResources,
+            int numOfFp) {
+        final int resId = ResourcesUtils.getResourcesId(context, "integer",
+                "suw_max_fingerprints_enrollable");
+        when(mockedResources.getInteger(resId)).thenReturn(numOfFp);
+    }
+}

tests/unit/src/com/android/settings/biometrics2/ui/viewmodel/AutoCredentialViewModelTest.java

@@ -0,0 +1,380 @@
+/*
+ * Copyright (C) 2022 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.biometrics2.ui.viewmodel;
+
+import static android.app.admin.DevicePolicyManager.PASSWORD_QUALITY_ALPHABETIC;
+import static android.app.admin.DevicePolicyManager.PASSWORD_QUALITY_NUMERIC;
+import static android.app.admin.DevicePolicyManager.PASSWORD_QUALITY_SOMETHING;
+import static android.app.admin.DevicePolicyManager.PASSWORD_QUALITY_UNSPECIFIED;
+
+import static com.android.settings.biometrics.BiometricEnrollBase.EXTRA_KEY_CHALLENGE;
+import static com.android.settings.biometrics.BiometricEnrollBase.EXTRA_KEY_SENSOR_ID;
+import static com.android.settings.biometrics2.ui.model.CredentialModel.INVALID_CHALLENGE;
+import static com.android.settings.biometrics2.ui.model.CredentialModel.INVALID_SENSOR_ID;
+import static com.android.settings.biometrics2.ui.viewmodel.AutoCredentialViewModel.CREDENTIAL_FAIL_NEED_TO_CHOOSE_LOCK;
+import static com.android.settings.biometrics2.ui.viewmodel.AutoCredentialViewModel.CREDENTIAL_FAIL_NEED_TO_CONFIRM_LOCK;
+import static com.android.settings.biometrics2.ui.viewmodel.AutoCredentialViewModel.ChallengeGenerator;
+import static com.android.settings.biometrics2.ui.viewmodel.AutoCredentialViewModel.CredentialAction;
+import static com.android.settings.biometrics2.ui.viewmodel.AutoCredentialViewModel.GenerateChallengeCallback;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.Mockito.when;
+
+import android.annotation.NonNull;
+import android.app.Activity;
+import android.content.Intent;
+import android.os.SystemClock;
+import android.os.UserHandle;
+
+import androidx.activity.result.ActivityResult;
+import androidx.annotation.Nullable;
+import androidx.lifecycle.LifecycleOwner;
+import androidx.test.core.app.ApplicationProvider;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+
+import com.android.internal.widget.LockPatternUtils;
+import com.android.internal.widget.VerifyCredentialResponse;
+import com.android.settings.biometrics2.ui.model.CredentialModel;
+import com.android.settings.password.ChooseLockPattern;
+import com.android.settings.password.ChooseLockSettingsHelper;
+import com.android.settings.testutils.InstantTaskExecutorRule;
+
+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;
+
+@RunWith(AndroidJUnit4.class)
+public class AutoCredentialViewModelTest {
+
+    @Rule public final MockitoRule mockito = MockitoJUnit.rule();
+    @Rule public final InstantTaskExecutorRule mTaskExecutorRule = new InstantTaskExecutorRule();
+
+    @Mock private LifecycleOwner mLifecycleOwner;
+    @Mock private LockPatternUtils mLockPatternUtils;
+    private TestChallengeGenerator mChallengeGenerator = null;
+    private AutoCredentialViewModel mAutoCredentialViewModel;
+
+    @Before
+    public void setUp() {
+        mChallengeGenerator = new TestChallengeGenerator();
+        mAutoCredentialViewModel = new AutoCredentialViewModel(
+                ApplicationProvider.getApplicationContext(),
+                mLockPatternUtils,
+                mChallengeGenerator);
+    }
+
+    private CredentialModel newCredentialModel(int userId, long challenge,
+            @Nullable byte[] token, long gkPwHandle) {
+        final Intent intent = new Intent();
+        intent.putExtra(Intent.EXTRA_USER_ID, userId);
+        intent.putExtra(EXTRA_KEY_SENSOR_ID, 1);
+        intent.putExtra(EXTRA_KEY_CHALLENGE, challenge);
+        intent.putExtra(ChooseLockSettingsHelper.EXTRA_KEY_CHALLENGE_TOKEN, token);
+        intent.putExtra(ChooseLockSettingsHelper.EXTRA_KEY_GK_PW_HANDLE, gkPwHandle);
+        return new CredentialModel(intent, SystemClock.elapsedRealtimeClock());
+    }
+
+    private CredentialModel newValidTokenCredentialModel(int userId) {
+        return newCredentialModel(userId, 1L, new byte[] { 0 }, 0L);
+    }
+
+    private CredentialModel newInvalidChallengeCredentialModel(int userId) {
+        return newCredentialModel(userId, INVALID_CHALLENGE, null, 0L);
+    }
+
+    private CredentialModel newGkPwHandleCredentialModel(int userId, long gkPwHandle) {
+        return newCredentialModel(userId, INVALID_CHALLENGE, null, gkPwHandle);
+    }
+
+    private void verifyNothingHappen() {
+        assertThat(mAutoCredentialViewModel.getActionLiveData().getValue()).isNull();
+    }
+
+    private void verifyOnlyActionLiveData(@CredentialAction int action) {
+        final Integer value = mAutoCredentialViewModel.getActionLiveData().getValue();
+        assertThat(value).isEqualTo(action);
+    }
+
+    private void setupGenerateTokenFlow(long gkPwHandle, int userId, int newSensorId,
+            long newChallenge) {
+        when(mLockPatternUtils.getActivePasswordQuality(userId)).thenReturn(
+                PASSWORD_QUALITY_SOMETHING);
+        mChallengeGenerator.mUserId = userId;
+        mChallengeGenerator.mSensorId = newSensorId;
+        mChallengeGenerator.mChallenge = newChallenge;
+        when(mLockPatternUtils.verifyGatekeeperPasswordHandle(gkPwHandle, newChallenge, userId))
+                .thenReturn(newGoodCredential(gkPwHandle, new byte[] { 1 }));
+    }
+
+    @Test
+    public void checkCredential_validCredentialCase() {
+        final int userId = 99;
+        mAutoCredentialViewModel.setCredentialModel(newValidTokenCredentialModel(userId));
+        when(mLockPatternUtils.getActivePasswordQuality(userId)).thenReturn(
+                PASSWORD_QUALITY_SOMETHING);
+
+        // Run credential check
+        mAutoCredentialViewModel.onCreate(mLifecycleOwner);
+
+        verifyNothingHappen();
+    }
+
+    @Test
+    public void checkCredential_needToChooseLock() {
+        final int userId = 100;
+        mAutoCredentialViewModel.setCredentialModel(newInvalidChallengeCredentialModel(userId));
+        when(mLockPatternUtils.getActivePasswordQuality(userId)).thenReturn(
+                PASSWORD_QUALITY_UNSPECIFIED);
+
+        // Run credential check
+        mAutoCredentialViewModel.onCreate(mLifecycleOwner);
+
+        verifyOnlyActionLiveData(CREDENTIAL_FAIL_NEED_TO_CHOOSE_LOCK);
+    }
+
+    @Test
+    public void checkCredential_needToConfirmLockFoSomething() {
+        final int userId = 101;
+        mAutoCredentialViewModel.setCredentialModel(newInvalidChallengeCredentialModel(userId));
+        when(mLockPatternUtils.getActivePasswordQuality(userId)).thenReturn(
+                PASSWORD_QUALITY_SOMETHING);
+
+        // Run credential check
+        mAutoCredentialViewModel.onCreate(mLifecycleOwner);
+
+        verifyOnlyActionLiveData(CREDENTIAL_FAIL_NEED_TO_CONFIRM_LOCK);
+    }
+
+    @Test
+    public void checkCredential_needToConfirmLockForNumeric() {
+        final int userId = 102;
+        mAutoCredentialViewModel.setCredentialModel(newInvalidChallengeCredentialModel(userId));
+        when(mLockPatternUtils.getActivePasswordQuality(userId)).thenReturn(
+                PASSWORD_QUALITY_NUMERIC);
+
+        // Run credential check
+        mAutoCredentialViewModel.onCreate(mLifecycleOwner);
+
+        verifyOnlyActionLiveData(CREDENTIAL_FAIL_NEED_TO_CONFIRM_LOCK);
+    }
+
+    @Test
+    public void checkCredential_needToConfirmLockForAlphabetic() {
+        final int userId = 103;
+        mAutoCredentialViewModel.setCredentialModel(newInvalidChallengeCredentialModel(userId));
+        when(mLockPatternUtils.getActivePasswordQuality(userId)).thenReturn(
+                PASSWORD_QUALITY_ALPHABETIC);
+
+        // Run credential check
+        mAutoCredentialViewModel.onCreate(mLifecycleOwner);
+
+        verifyOnlyActionLiveData(CREDENTIAL_FAIL_NEED_TO_CONFIRM_LOCK);
+    }
+
+    @Test
+    public void checkCredential_generateChallenge() {
+        final int userId = 104;
+        final long gkPwHandle = 1111L;
+        final CredentialModel credentialModel = newGkPwHandleCredentialModel(userId, gkPwHandle);
+        mAutoCredentialViewModel.setCredentialModel(credentialModel);
+        when(mLockPatternUtils.getActivePasswordQuality(userId)).thenReturn(
+                PASSWORD_QUALITY_SOMETHING);
+
+        final int newSensorId = 10;
+        final long newChallenge = 20L;
+        setupGenerateTokenFlow(gkPwHandle, userId, newSensorId, newChallenge);
+
+        // Run credential check
+        mAutoCredentialViewModel.onCreate(mLifecycleOwner);
+
+        assertThat(mAutoCredentialViewModel.getActionLiveData().getValue()).isNull();
+        assertThat(credentialModel.getSensorId()).isEqualTo(newSensorId);
+        assertThat(credentialModel.getChallenge()).isEqualTo(newChallenge);
+        assertThat(CredentialModel.isValidToken(credentialModel.getToken())).isTrue();
+        assertThat(CredentialModel.isValidGkPwHandle(credentialModel.getGkPwHandle())).isFalse();
+        assertThat(mChallengeGenerator.mCallbackRunCount).isEqualTo(1);
+    }
+
+    @Test
+    public void testGetUserId() {
+        final int userId = 106;
+        mAutoCredentialViewModel.setCredentialModel(newInvalidChallengeCredentialModel(userId));
+
+        // Get userId
+        assertThat(mAutoCredentialViewModel.getUserId()).isEqualTo(userId);
+    }
+
+    @Test
+    public void testCheckNewCredentialFromActivityResult_invalidChooseLock() {
+        final int userId = 107;
+        final long gkPwHandle = 3333L;
+        mAutoCredentialViewModel.setCredentialModel(
+                newGkPwHandleCredentialModel(userId, gkPwHandle));
+        final Intent intent = new Intent();
+        intent.putExtra(ChooseLockSettingsHelper.EXTRA_KEY_GK_PW_HANDLE, gkPwHandle);
+
+        // run checkNewCredentialFromActivityResult()
+        final boolean ret = mAutoCredentialViewModel.checkNewCredentialFromActivityResult(true,
+                new ActivityResult(ChooseLockPattern.RESULT_FINISHED + 1, intent));
+
+        assertThat(ret).isFalse();
+        verifyNothingHappen();
+    }
+
+    @Test
+    public void testCheckNewCredentialFromActivityResult_invalidConfirmLock() {
+        final int userId = 107;
+        final long gkPwHandle = 3333L;
+        mAutoCredentialViewModel.setCredentialModel(
+                newGkPwHandleCredentialModel(userId, gkPwHandle));
+        final Intent intent = new Intent();
+        intent.putExtra(ChooseLockSettingsHelper.EXTRA_KEY_GK_PW_HANDLE, gkPwHandle);
+
+        // run checkNewCredentialFromActivityResult()
+        final boolean ret = mAutoCredentialViewModel.checkNewCredentialFromActivityResult(false,
+                new ActivityResult(Activity.RESULT_OK + 1, intent));
+
+        assertThat(ret).isFalse();
+        verifyNothingHappen();
+    }
+
+    @Test
+    public void testCheckNewCredentialFromActivityResult_nullDataChooseLock() {
+        final int userId = 108;
+        final long gkPwHandle = 4444L;
+        mAutoCredentialViewModel.setCredentialModel(
+                newGkPwHandleCredentialModel(userId, gkPwHandle));
+
+        // run checkNewCredentialFromActivityResult()
+        final boolean ret = mAutoCredentialViewModel.checkNewCredentialFromActivityResult(true,
+                new ActivityResult(ChooseLockPattern.RESULT_FINISHED, null));
+
+        assertThat(ret).isFalse();
+        verifyNothingHappen();
+    }
+
+    @Test
+    public void testCheckNewCredentialFromActivityResult_nullDataConfirmLock() {
+        final int userId = 109;
+        mAutoCredentialViewModel.setCredentialModel(newInvalidChallengeCredentialModel(userId));
+
+        // run checkNewCredentialFromActivityResult()
+        final boolean ret = mAutoCredentialViewModel.checkNewCredentialFromActivityResult(false,
+                new ActivityResult(Activity.RESULT_OK, null));
+
+        assertThat(ret).isFalse();
+        verifyNothingHappen();
+    }
+
+    @Test
+    public void testCheckNewCredentialFromActivityResult_validChooseLock() {
+        final int userId = 108;
+        final CredentialModel credentialModel = newInvalidChallengeCredentialModel(userId);
+        mAutoCredentialViewModel.setCredentialModel(credentialModel);
+        when(mLockPatternUtils.getActivePasswordQuality(userId)).thenReturn(
+                PASSWORD_QUALITY_SOMETHING);
+
+        final long gkPwHandle = 6666L;
+        final int newSensorId = 50;
+        final long newChallenge = 60L;
+        setupGenerateTokenFlow(gkPwHandle, userId, newSensorId, newChallenge);
+        final Intent intent = new Intent();
+        intent.putExtra(ChooseLockSettingsHelper.EXTRA_KEY_GK_PW_HANDLE, gkPwHandle);
+
+        // Run checkNewCredentialFromActivityResult()
+        final boolean ret = mAutoCredentialViewModel.checkNewCredentialFromActivityResult(true,
+                new ActivityResult(ChooseLockPattern.RESULT_FINISHED, intent));
+
+        assertThat(ret).isTrue();
+        assertThat(mAutoCredentialViewModel.getActionLiveData().getValue()).isNull();
+        assertThat(credentialModel.getSensorId()).isEqualTo(newSensorId);
+        assertThat(credentialModel.getChallenge()).isEqualTo(newChallenge);
+        assertThat(CredentialModel.isValidToken(credentialModel.getToken())).isTrue();
+        assertThat(CredentialModel.isValidGkPwHandle(credentialModel.getGkPwHandle())).isFalse();
+        assertThat(mChallengeGenerator.mCallbackRunCount).isEqualTo(1);
+    }
+
+
+    @Test
+    public void testCheckNewCredentialFromActivityResult_validConfirmLock() {
+        final int userId = 109;
+        final CredentialModel credentialModel = newInvalidChallengeCredentialModel(userId);
+        mAutoCredentialViewModel.setCredentialModel(credentialModel);
+        when(mLockPatternUtils.getActivePasswordQuality(userId)).thenReturn(
+                PASSWORD_QUALITY_SOMETHING);
+
+        final long gkPwHandle = 5555L;
+        final int newSensorId = 80;
+        final long newChallenge = 90L;
+        setupGenerateTokenFlow(gkPwHandle, userId, newSensorId, newChallenge);
+        final Intent intent = new Intent();
+        intent.putExtra(ChooseLockSettingsHelper.EXTRA_KEY_GK_PW_HANDLE, gkPwHandle);
+
+        // Run checkNewCredentialFromActivityResult()
+        final boolean ret = mAutoCredentialViewModel.checkNewCredentialFromActivityResult(false,
+                new ActivityResult(Activity.RESULT_OK, intent));
+
+        assertThat(ret).isTrue();
+        assertThat(mAutoCredentialViewModel.getActionLiveData().getValue()).isNull();
+        assertThat(credentialModel.getSensorId()).isEqualTo(newSensorId);
+        assertThat(credentialModel.getChallenge()).isEqualTo(newChallenge);
+        assertThat(CredentialModel.isValidToken(credentialModel.getToken())).isTrue();
+        assertThat(CredentialModel.isValidGkPwHandle(credentialModel.getGkPwHandle())).isFalse();
+        assertThat(mChallengeGenerator.mCallbackRunCount).isEqualTo(1);
+    }
+
+    public static class TestChallengeGenerator implements ChallengeGenerator {
+        public int mSensorId = INVALID_SENSOR_ID;
+        public int mUserId = UserHandle.myUserId();
+        public long mChallenge = INVALID_CHALLENGE;
+        public int mCallbackRunCount = 0;
+        private GenerateChallengeCallback mCallback;
+
+        @Nullable
+        @Override
+        public GenerateChallengeCallback getCallback() {
+            return mCallback;
+        }
+
+        @Override
+        public void setCallback(@Nullable GenerateChallengeCallback callback) {
+            mCallback = callback;
+        }
+
+        @Override
+        public void generateChallenge(int userId) {
+            final GenerateChallengeCallback callback = mCallback;
+            if (callback == null) {
+                return;
+            }
+            callback.onChallengeGenerated(mSensorId, mUserId, mChallenge);
+            ++mCallbackRunCount;
+        }
+    }
+
+    private VerifyCredentialResponse newGoodCredential(long gkPwHandle, @NonNull byte[] hat) {
+        return new VerifyCredentialResponse.Builder()
+                .setGatekeeperPasswordHandle(gkPwHandle)
+                .setGatekeeperHAT(hat)
+                .build();
+    }
+}

tests/unit/src/com/android/settings/biometrics2/ui/viewmodel/FingerprintEnrollIntroViewModelTest.java

@@ -0,0 +1,259 @@
+/*
+ * Copyright (C) 2022 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.biometrics2.ui.viewmodel;
+
+import static android.hardware.fingerprint.FingerprintSensorProperties.TYPE_REAR;
+import static android.hardware.fingerprint.FingerprintSensorProperties.TYPE_UDFPS_OPTICAL;
+import static android.hardware.fingerprint.FingerprintSensorProperties.TYPE_UDFPS_ULTRASONIC;
+
+import static com.android.settings.biometrics2.data.repository.FingerprintRepositoryTest.setupSuwMaxFingerprintsEnrollable;
+import static com.android.settings.biometrics2.ui.model.FingerprintEnrollIntroStatus.FINGERPRINT_ENROLLABLE_ERROR_REACH_MAX;
+import static com.android.settings.biometrics2.ui.model.FingerprintEnrollIntroStatus.FINGERPRINT_ENROLLABLE_OK;
+import static com.android.settings.biometrics2.ui.model.FingerprintEnrollIntroStatus.FINGERPRINT_ENROLLABLE_UNKNOWN;
+import static com.android.settings.biometrics2.ui.viewmodel.FingerprintEnrollIntroViewModel.FINGERPRINT_ENROLL_INTRO_ACTION_CONTINUE_ENROLL;
+import static com.android.settings.biometrics2.ui.viewmodel.FingerprintEnrollIntroViewModel.FINGERPRINT_ENROLL_INTRO_ACTION_DONE_AND_FINISH;
+import static com.android.settings.biometrics2.ui.viewmodel.FingerprintEnrollIntroViewModel.FINGERPRINT_ENROLL_INTRO_ACTION_SKIP_OR_CANCEL;
+import static com.android.settings.biometrics2.util.EnrollmentRequestUtil.newAllFalseRequest;
+import static com.android.settings.biometrics2.util.EnrollmentRequestUtil.newIsSuwDeferredRequest;
+import static com.android.settings.biometrics2.util.EnrollmentRequestUtil.newIsSuwPortalRequest;
+import static com.android.settings.biometrics2.util.EnrollmentRequestUtil.newIsSuwRequest;
+import static com.android.settings.biometrics2.util.EnrollmentRequestUtil.newIsSuwSuggestedActionFlowRequest;
+import static com.android.settings.biometrics2.util.FingerprintManagerUtil.setupFingerprintEnrolledFingerprints;
+import static com.android.settings.biometrics2.util.FingerprintManagerUtil.setupFingerprintFirstSensor;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import android.app.Application;
+import android.content.res.Resources;
+import android.hardware.fingerprint.FingerprintManager;
+
+import androidx.annotation.NonNull;
+import androidx.lifecycle.LifecycleOwner;
+import androidx.test.core.app.ApplicationProvider;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+
+import com.android.settings.biometrics2.data.repository.FingerprintRepository;
+import com.android.settings.biometrics2.ui.model.EnrollmentRequest;
+import com.android.settings.biometrics2.ui.model.FingerprintEnrollIntroStatus;
+import com.android.settings.testutils.InstantTaskExecutorRule;
+
+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;
+
+@RunWith(AndroidJUnit4.class)
+public class FingerprintEnrollIntroViewModelTest {
+
+    @Rule public final MockitoRule mockito = MockitoJUnit.rule();
+    @Rule public final InstantTaskExecutorRule mTaskExecutorRule = new InstantTaskExecutorRule();
+
+    @Mock private Resources mResources;
+    @Mock private LifecycleOwner mLifecycleOwner;
+    @Mock private FingerprintManager mFingerprintManager;
+
+    private Application mApplication;
+    private FingerprintRepository mFingerprintRepository;
+    private FingerprintEnrollIntroViewModel mViewModel;
+
+    @Before
+    public void setUp() {
+        mApplication = ApplicationProvider.getApplicationContext();
+        mFingerprintRepository = new FingerprintRepository(mFingerprintManager);
+        mViewModel = new FingerprintEnrollIntroViewModel(mApplication, mFingerprintRepository);
+        // MediatorLiveData won't update itself unless observed
+        mViewModel.getPageStatusLiveData().observeForever(event -> {});
+    }
+
+    @Test
+    public void testPageStatusLiveDataDefaultValue() {
+        final FingerprintEnrollIntroStatus status = mViewModel.getPageStatusLiveData().getValue();
+        assertThat(status.hasScrollToBottom()).isFalse();
+        assertThat(status.getEnrollableStatus()).isEqualTo(FINGERPRINT_ENROLLABLE_UNKNOWN);
+    }
+
+    @Test
+    public void testGetEnrollmentRequest() {
+        final EnrollmentRequest request = newAllFalseRequest(mApplication);
+
+        mViewModel.setEnrollmentRequest(request);
+
+        assertThat(mViewModel.getEnrollmentRequest()).isEqualTo(request);
+    }
+
+    @Test
+    public void testOnStartToUpdateEnrollableStatus_isSuw() {
+        final int userId = 44;
+        mViewModel.setUserId(userId);
+        mViewModel.setEnrollmentRequest(newIsSuwRequest(mApplication));
+
+        setupFingerprintEnrolledFingerprints(mFingerprintManager, userId, 0);
+        setupSuwMaxFingerprintsEnrollable(mApplication, mResources, 1);
+        mViewModel.onStart(mLifecycleOwner);
+        FingerprintEnrollIntroStatus status = mViewModel.getPageStatusLiveData().getValue();
+        assertThat(status.getEnrollableStatus()).isEqualTo(FINGERPRINT_ENROLLABLE_OK);
+
+        setupFingerprintEnrolledFingerprints(mFingerprintManager, userId, 1);
+        setupSuwMaxFingerprintsEnrollable(mApplication, mResources, 1);
+        mViewModel.onStart(mLifecycleOwner);
+        status = mViewModel.getPageStatusLiveData().getValue();
+        assertThat(status.getEnrollableStatus()).isEqualTo(FINGERPRINT_ENROLLABLE_ERROR_REACH_MAX);
+    }
+
+    @Test
+    public void testOnStartToUpdateEnrollableStatus_isNotSuw() {
+        testOnStartToUpdateEnrollableStatus(newAllFalseRequest(mApplication));
+    }
+
+    @Test
+    public void testOnStartToUpdateEnrollableStatus_isSuwDeferred() {
+        testOnStartToUpdateEnrollableStatus(newIsSuwDeferredRequest(mApplication));
+    }
+
+    @Test
+    public void testOnStartToUpdateEnrollableStatus_isSuwPortal() {
+        testOnStartToUpdateEnrollableStatus(newIsSuwPortalRequest(mApplication));
+    }
+
+    @Test
+    public void testOnStartToUpdateEnrollableStatus_isSuwSuggestedActionFlow() {
+        testOnStartToUpdateEnrollableStatus(newIsSuwSuggestedActionFlowRequest(mApplication));
+    }
+
+    private void testOnStartToUpdateEnrollableStatus(@NonNull EnrollmentRequest request) {
+        final int userId = 45;
+        mViewModel.setUserId(userId);
+        mViewModel.setEnrollmentRequest(request);
+
+        setupFingerprintEnrolledFingerprints(mFingerprintManager, userId, 0);
+        setupFingerprintFirstSensor(mFingerprintManager, TYPE_UDFPS_OPTICAL, 5);
+        mViewModel.onStart(mLifecycleOwner);
+        FingerprintEnrollIntroStatus status = mViewModel.getPageStatusLiveData().getValue();
+        assertThat(status.getEnrollableStatus()).isEqualTo(FINGERPRINT_ENROLLABLE_OK);
+
+        setupFingerprintEnrolledFingerprints(mFingerprintManager, userId, 5);
+        setupFingerprintFirstSensor(mFingerprintManager, TYPE_UDFPS_OPTICAL, 5);
+        mViewModel.onStart(mLifecycleOwner);
+        status = mViewModel.getPageStatusLiveData().getValue();
+        assertThat(status.getEnrollableStatus()).isEqualTo(FINGERPRINT_ENROLLABLE_ERROR_REACH_MAX);
+    }
+
+    @Test
+    public void textCanAssumeUdfps() {
+        setupFingerprintFirstSensor(mFingerprintManager, TYPE_UDFPS_ULTRASONIC, 1);
+        assertThat(mViewModel.canAssumeUdfps()).isEqualTo(true);
+
+        setupFingerprintFirstSensor(mFingerprintManager, TYPE_REAR, 1);
+        assertThat(mViewModel.canAssumeUdfps()).isEqualTo(false);
+    }
+
+    @Test
+    public void testIsParentalConsentRequired() {
+        // We shall not mock FingerprintRepository, but
+        // FingerprintRepository.isParentalConsentRequired() calls static method inside, we can't
+        // mock static method
+        final FingerprintRepository fingerprintRepository = mock(FingerprintRepository.class);
+        mViewModel = new FingerprintEnrollIntroViewModel(mApplication, fingerprintRepository);
+
+        when(fingerprintRepository.isParentalConsentRequired(mApplication)).thenReturn(true);
+        assertThat(mViewModel.isParentalConsentRequired()).isEqualTo(true);
+
+        when(fingerprintRepository.isParentalConsentRequired(mApplication)).thenReturn(false);
+        assertThat(mViewModel.isParentalConsentRequired()).isEqualTo(false);
+    }
+
+    @Test
+    public void testIsBiometricUnlockDisabledByAdmin() {
+        // We shall not mock FingerprintRepository, but
+        // FingerprintRepository.isDisabledByAdmin() calls static method inside, we can't mock
+        // static method
+        final FingerprintRepository fingerprintRepository = mock(FingerprintRepository.class);
+        mViewModel = new FingerprintEnrollIntroViewModel(mApplication, fingerprintRepository);
+
+        final int userId = 33;
+        mViewModel.setUserId(userId);
+
+        when(fingerprintRepository.isDisabledByAdmin(mApplication, userId)).thenReturn(true);
+        assertThat(mViewModel.isBiometricUnlockDisabledByAdmin()).isEqualTo(true);
+
+        when(fingerprintRepository.isDisabledByAdmin(mApplication, userId)).thenReturn(false);
+        assertThat(mViewModel.isBiometricUnlockDisabledByAdmin()).isEqualTo(false);
+    }
+
+    @Test
+    public void testSetHasScrolledToBottom() {
+        mViewModel.setHasScrolledToBottom();
+
+        FingerprintEnrollIntroStatus status = mViewModel.getPageStatusLiveData().getValue();
+
+        assertThat(status.hasScrollToBottom()).isEqualTo(true);
+    }
+
+    @Test
+    public void testOnNextButtonClick_enrollNext() {
+        final int userId = 46;
+        mViewModel.setUserId(userId);
+        mViewModel.setEnrollmentRequest(newIsSuwRequest(mApplication));
+
+        // Set latest status to FINGERPRINT_ENROLLABLE_OK
+        setupFingerprintEnrolledFingerprints(mFingerprintManager, userId, 0);
+        setupSuwMaxFingerprintsEnrollable(mApplication, mResources, 1);
+        mViewModel.onStart(mLifecycleOwner);
+        FingerprintEnrollIntroStatus status = mViewModel.getPageStatusLiveData().getValue();
+        assertThat(status.getEnrollableStatus()).isEqualTo(FINGERPRINT_ENROLLABLE_OK);
+
+        // Perform click on `next`
+        mViewModel.onNextButtonClick(null);
+
+        assertThat(mViewModel.getActionLiveData().getValue())
+                .isEqualTo(FINGERPRINT_ENROLL_INTRO_ACTION_CONTINUE_ENROLL);
+    }
+
+    @Test
+    public void testOnNextButtonClick_doneAndFinish() {
+        final int userId = 46;
+        mViewModel.setUserId(userId);
+        mViewModel.setEnrollmentRequest(newIsSuwRequest(mApplication));
+
+        // Set latest status to FINGERPRINT_ENROLLABLE_ERROR_REACH_MAX
+        setupFingerprintEnrolledFingerprints(mFingerprintManager, userId, 1);
+        setupSuwMaxFingerprintsEnrollable(mApplication, mResources, 1);
+        mViewModel.onStart(mLifecycleOwner);
+        FingerprintEnrollIntroStatus status = mViewModel.getPageStatusLiveData().getValue();
+        assertThat(status.getEnrollableStatus()).isEqualTo(FINGERPRINT_ENROLLABLE_ERROR_REACH_MAX);
+
+        // Perform click on `next`
+        mViewModel.onNextButtonClick(null);
+
+        assertThat(mViewModel.getActionLiveData().getValue())
+                .isEqualTo(FINGERPRINT_ENROLL_INTRO_ACTION_DONE_AND_FINISH);
+    }
+
+    @Test
+    public void testOnSkipOrCancelButtonClick() {
+        mViewModel.onSkipOrCancelButtonClick(null);
+
+        assertThat(mViewModel.getActionLiveData().getValue())
+                .isEqualTo(FINGERPRINT_ENROLL_INTRO_ACTION_SKIP_OR_CANCEL);
+    }
+}

tests/unit/src/com/android/settings/biometrics2/ui/viewmodel/FingerprintEnrollmentViewModelTest.java

@@ -0,0 +1,252 @@
+/*
+ * Copyright (C) 2022 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.biometrics2.ui.viewmodel;
+
+import static com.android.settings.biometrics.BiometricEnrollBase.RESULT_FINISHED;
+import static com.android.settings.biometrics.BiometricEnrollBase.RESULT_SKIP;
+import static com.android.settings.biometrics.BiometricEnrollBase.RESULT_TIMEOUT;
+import static com.android.settings.biometrics.fingerprint.SetupFingerprintEnrollIntroduction.EXTRA_FINGERPRINT_ENROLLED_COUNT;
+import static com.android.settings.biometrics2.ui.viewmodel.FingerprintEnrollmentViewModel.SAVED_STATE_IS_WAITING_ACTIVITY_RESULT;
+import static com.android.settings.biometrics2.util.EnrollmentRequestUtil.newAllFalseRequest;
+import static com.android.settings.biometrics2.util.EnrollmentRequestUtil.newIsSuwRequest;
+import static com.android.settings.biometrics2.util.FingerprintManagerUtil.setupFingerprintEnrolledFingerprints;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.Mockito.when;
+
+import android.app.Application;
+import android.app.KeyguardManager;
+import android.content.Intent;
+import android.hardware.fingerprint.FingerprintManager;
+import android.os.Bundle;
+
+import androidx.activity.result.ActivityResult;
+import androidx.test.core.app.ApplicationProvider;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+
+import com.android.settings.biometrics2.data.repository.FingerprintRepository;
+import com.android.settings.biometrics2.ui.model.EnrollmentRequest;
+import com.android.settings.password.SetupSkipDialog;
+import com.android.settings.testutils.InstantTaskExecutorRule;
+
+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;
+
+@RunWith(AndroidJUnit4.class)
+public class FingerprintEnrollmentViewModelTest {
+
+    @Rule public final MockitoRule mockito = MockitoJUnit.rule();
+    @Rule public final InstantTaskExecutorRule mTaskExecutorRule = new InstantTaskExecutorRule();
+
+    @Mock private FingerprintManager mFingerprintManager;
+    @Mock private KeyguardManager mKeyguardManager;
+
+    private Application mApplication;
+    private FingerprintRepository mFingerprintRepository;
+    private FingerprintEnrollmentViewModel mViewModel;
+
+    @Before
+    public void setUp() {
+        mApplication = ApplicationProvider.getApplicationContext();
+        mFingerprintRepository = new FingerprintRepository(mFingerprintManager);
+        mViewModel = new FingerprintEnrollmentViewModel(mApplication, mFingerprintRepository,
+                mKeyguardManager);
+    }
+
+    @Test
+    public void testGetRequest() {
+        when(mKeyguardManager.isKeyguardSecure()).thenReturn(true);
+        assertThat(mViewModel.getRequest()).isNull();
+
+        final EnrollmentRequest request = newAllFalseRequest(mApplication);
+        mViewModel.setRequest(request);
+        assertThat(mViewModel.getRequest()).isEqualTo(request);
+    }
+
+    @Test
+    public void testGetNextActivityBaseIntentExtras() {
+        mViewModel.setRequest(newAllFalseRequest(mApplication));
+        assertThat(mViewModel.getNextActivityBaseIntentExtras()).isNotNull();
+    }
+
+    @Test
+    public void testOnContinueEnrollActivityResult_shouldRelaySkip1Result() {
+        mViewModel.setRequest(newAllFalseRequest(mApplication));
+        final ActivityResult result = new ActivityResult(RESULT_SKIP, null);
+
+        // Run onContinueEnrollActivityResult
+        mViewModel.onContinueEnrollActivityResult(result, 100);
+
+        assertThat(mViewModel.getSetResultLiveData().getValue()).isEqualTo(result);
+    }
+
+    @Test
+    public void testOnContinueEnrollActivityResult_shouldRelaySkip2Result() {
+        mViewModel.setRequest(newAllFalseRequest(mApplication));
+        final ActivityResult result = new ActivityResult(SetupSkipDialog.RESULT_SKIP, null);
+
+        // Run onContinueEnrollActivityResult
+        mViewModel.onContinueEnrollActivityResult(result, 100);
+
+        assertThat(mViewModel.getSetResultLiveData().getValue()).isEqualTo(result);
+    }
+
+    @Test
+    public void testOnContinueEnrollActivityResult_shouldRelayNullDataTimeoutResult() {
+        mViewModel.setRequest(newAllFalseRequest(mApplication));
+        final ActivityResult result = new ActivityResult(RESULT_TIMEOUT, null);
+
+        // Run onContinueEnrollActivityResult
+        mViewModel.onContinueEnrollActivityResult(result, 100);
+        final ActivityResult setResult = mViewModel.getSetResultLiveData().getValue();
+
+        assertThat(setResult).isNotNull();
+        assertThat(setResult.getResultCode()).isEqualTo(result.getResultCode());
+        assertThat(setResult.getData()).isEqualTo(result.getData());
+    }
+
+    @Test
+    public void testOnContinueEnrollActivityResult_shouldRelayWithDataTimeoutResult() {
+        mViewModel.setRequest(newAllFalseRequest(mApplication));
+        final Intent intent = new Intent("testAction");
+        intent.putExtra("testKey", "testValue");
+        final ActivityResult result = new ActivityResult(RESULT_TIMEOUT, intent);
+
+        // Run onContinueEnrollActivityResult
+        mViewModel.onContinueEnrollActivityResult(result, 100);
+        final ActivityResult setResult = mViewModel.getSetResultLiveData().getValue();
+
+        assertThat(setResult).isNotNull();
+        assertThat(setResult.getResultCode()).isEqualTo(result.getResultCode());
+        assertThat(setResult.getData()).isEqualTo(intent);
+    }
+
+    @Test
+    public void testOnContinueEnrollActivityResult_shouldRelayNullDataFinishResult() {
+        mViewModel.setRequest(newAllFalseRequest(mApplication));
+        final ActivityResult result = new ActivityResult(RESULT_FINISHED, null);
+
+        // Run onContinueEnrollActivityResult
+        mViewModel.onContinueEnrollActivityResult(result, 100);
+        final ActivityResult setResult = mViewModel.getSetResultLiveData().getValue();
+
+        assertThat(setResult).isNotNull();
+        assertThat(setResult.getResultCode()).isEqualTo(result.getResultCode());
+        assertThat(setResult.getData()).isEqualTo(result.getData());
+    }
+
+    @Test
+    public void testOnContinueEnrollActivityResult_shouldRelayWithDataFinishResult() {
+        mViewModel.setRequest(newAllFalseRequest(mApplication));
+        final Intent intent = new Intent("testAction");
+        intent.putExtra("testKey", "testValue");
+        final ActivityResult result = new ActivityResult(RESULT_FINISHED, intent);
+
+        // Run onContinueEnrollActivityResult
+        mViewModel.onContinueEnrollActivityResult(result, 100);
+        final ActivityResult setResult = mViewModel.getSetResultLiveData().getValue();
+
+        assertThat(setResult).isNotNull();
+        assertThat(setResult.getResultCode()).isEqualTo(result.getResultCode());
+        assertThat(setResult.getData()).isEqualTo(intent);
+    }
+
+    @Test
+    public void testOnContinueEnrollActivityResult_shouldRelayNullDataFinishResultAsNewData() {
+        when(mKeyguardManager.isKeyguardSecure()).thenReturn(true);
+        final int userId = 111;
+        final int numOfFp = 4;
+        setupFingerprintEnrolledFingerprints(mFingerprintManager, userId, numOfFp);
+        mViewModel.setRequest(newIsSuwRequest(mApplication));
+        final ActivityResult result = new ActivityResult(RESULT_FINISHED, null);
+
+        // Run onContinueEnrollActivityResult
+        mViewModel.onContinueEnrollActivityResult(result, userId);
+        final ActivityResult setResult = mViewModel.getSetResultLiveData().getValue();
+
+        assertThat(setResult).isNotNull();
+        assertThat(setResult.getResultCode()).isEqualTo(result.getResultCode());
+        assertThat(setResult.getData()).isNotNull();
+        assertThat(setResult.getData().getExtras()).isNotNull();
+        assertThat(setResult.getData().getExtras().getInt(EXTRA_FINGERPRINT_ENROLLED_COUNT, -1))
+                .isEqualTo(numOfFp);
+    }
+
+    @Test
+    public void testOnContinueEnrollActivityResult_shouldRelayWithDataFinishResultAsNewData() {
+        when(mKeyguardManager.isKeyguardSecure()).thenReturn(true);
+        final int userId = 20;
+        final int numOfFp = 9;
+        setupFingerprintEnrolledFingerprints(mFingerprintManager, userId, numOfFp);
+        mViewModel.setRequest(newIsSuwRequest(mApplication));
+        final String action = "testAction";
+        final String key = "testKey";
+        final String value = "testValue";
+        final Intent intent = new Intent(action);
+        intent.putExtra(key, value);
+        final ActivityResult result = new ActivityResult(RESULT_FINISHED, intent);
+
+        // Run onContinueEnrollActivityResult
+        mViewModel.onContinueEnrollActivityResult(result, userId);
+        final ActivityResult setResult = mViewModel.getSetResultLiveData().getValue();
+
+        assertThat(setResult).isNotNull();
+        assertThat(setResult.getResultCode()).isEqualTo(result.getResultCode());
+        assertThat(setResult.getData()).isNotNull();
+        assertThat(setResult.getData().getExtras()).isNotNull();
+        assertThat(setResult.getData().getExtras().getInt(EXTRA_FINGERPRINT_ENROLLED_COUNT, -1))
+                .isEqualTo(numOfFp);
+        assertThat(setResult.getData().getExtras().getString(key)).isEqualTo(value);
+    }
+
+    @Test
+    public void testSetSavedInstanceState() {
+        final Bundle bundle = new Bundle();
+        mViewModel.isWaitingActivityResult().set(true);
+
+        // setSavedInstanceState() as false
+        bundle.putBoolean(SAVED_STATE_IS_WAITING_ACTIVITY_RESULT, false);
+        mViewModel.setSavedInstanceState(bundle);
+        assertThat(mViewModel.isWaitingActivityResult().get()).isFalse();
+
+        // setSavedInstanceState() as false
+        bundle.putBoolean(SAVED_STATE_IS_WAITING_ACTIVITY_RESULT, true);
+        mViewModel.setSavedInstanceState(bundle);
+        assertThat(mViewModel.isWaitingActivityResult().get()).isTrue();
+    }
+
+    @Test
+    public void testOnSaveInstanceState() {
+        final Bundle bundle = new Bundle();
+
+        // setSavedInstanceState() as false
+        mViewModel.isWaitingActivityResult().set(false);
+        mViewModel.onSaveInstanceState(bundle);
+        assertThat(bundle.getBoolean(SAVED_STATE_IS_WAITING_ACTIVITY_RESULT)).isFalse();
+
+        // setSavedInstanceState() as false
+        mViewModel.isWaitingActivityResult().set(true);
+        mViewModel.onSaveInstanceState(bundle);
+        assertThat(bundle.getBoolean(SAVED_STATE_IS_WAITING_ACTIVITY_RESULT)).isTrue();
+    }
+}

tests/unit/src/com/android/settings/biometrics2/util/EnrollmentRequestUtil.java

@@ -0,0 +1,81 @@
+/*
+ * Copyright (C) 2022 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.biometrics2.util;
+
+import static com.android.settings.biometrics.BiometricEnrollBase.EXTRA_FROM_SETTINGS_SUMMARY;
+
+import static com.google.android.setupcompat.util.WizardManagerHelper.EXTRA_IS_DEFERRED_SETUP;
+import static com.google.android.setupcompat.util.WizardManagerHelper.EXTRA_IS_FIRST_RUN;
+import static com.google.android.setupcompat.util.WizardManagerHelper.EXTRA_IS_PORTAL_SETUP;
+import static com.google.android.setupcompat.util.WizardManagerHelper.EXTRA_IS_SETUP_FLOW;
+import static com.google.android.setupcompat.util.WizardManagerHelper.EXTRA_IS_SUW_SUGGESTED_ACTION_FLOW;
+import static com.google.android.setupcompat.util.WizardManagerHelper.EXTRA_THEME;
+
+import android.content.Context;
+import android.content.Intent;
+import android.text.TextUtils;
+
+import androidx.annotation.NonNull;
+
+import com.android.settings.biometrics2.ui.model.EnrollmentRequest;
+
+public class EnrollmentRequestUtil {
+
+    @NonNull
+    public static EnrollmentRequest newAllFalseRequest(@NonNull Context context) {
+        return newRequest(context, false, false, false, false, false, false, null);
+    }
+
+    @NonNull
+    public static EnrollmentRequest newIsSuwRequest(@NonNull Context context) {
+        return newRequest(context, true, false, false, false, false, false, null);
+    }
+
+    @NonNull
+    public static EnrollmentRequest newIsSuwDeferredRequest(@NonNull Context context) {
+        return newRequest(context, true, true, false, false, false, false, null);
+    }
+
+    @NonNull
+    public static EnrollmentRequest newIsSuwPortalRequest(@NonNull Context context) {
+        return newRequest(context, true, false, true, false, false, false, null);
+    }
+
+    @NonNull
+    public static EnrollmentRequest newIsSuwSuggestedActionFlowRequest(
+            @NonNull Context context) {
+        return newRequest(context, true, false, false, true, false, false, null);
+    }
+
+    @NonNull
+    public static EnrollmentRequest newRequest(@NonNull Context context, boolean isSuw,
+            boolean isSuwDeferred, boolean isSuwPortal, boolean isSuwSuggestedActionFlow,
+            boolean isSuwFirstRun, boolean isFromSettingsSummery, String theme) {
+        Intent i = new Intent();
+        i.putExtra(EXTRA_IS_SETUP_FLOW, isSuw);
+        i.putExtra(EXTRA_IS_DEFERRED_SETUP, isSuwDeferred);
+        i.putExtra(EXTRA_IS_PORTAL_SETUP, isSuwPortal);
+        i.putExtra(EXTRA_IS_SUW_SUGGESTED_ACTION_FLOW, isSuwSuggestedActionFlow);
+        i.putExtra(EXTRA_IS_FIRST_RUN, isSuwFirstRun);
+        i.putExtra(EXTRA_FROM_SETTINGS_SUMMARY, isFromSettingsSummery);
+        if (!TextUtils.isEmpty(theme)) {
+            i.putExtra(EXTRA_THEME, theme);
+        }
+        return new EnrollmentRequest(i, context);
+    }
+
+}

tests/unit/src/com/android/settings/biometrics2/util/FingerprintManagerUtil.java

@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2022 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.biometrics2.util;
+
+import static org.mockito.Mockito.when;
+
+import android.hardware.biometrics.SensorProperties;
+import android.hardware.fingerprint.Fingerprint;
+import android.hardware.fingerprint.FingerprintManager;
+import android.hardware.fingerprint.FingerprintSensorProperties;
+import android.hardware.fingerprint.FingerprintSensorPropertiesInternal;
+
+import androidx.annotation.NonNull;
+
+import java.util.ArrayList;
+
+public class FingerprintManagerUtil {
+
+    public static void setupFingerprintFirstSensor(
+            @NonNull FingerprintManager mockedFingerprintManager,
+            @FingerprintSensorProperties.SensorType int sensorType,
+            int maxEnrollmentsPerUser) {
+        final ArrayList<FingerprintSensorPropertiesInternal> props = new ArrayList<>();
+        props.add(new FingerprintSensorPropertiesInternal(
+                0 /* sensorId */,
+                SensorProperties.STRENGTH_STRONG,
+                maxEnrollmentsPerUser,
+                new ArrayList<>() /* componentInfo */,
+                sensorType,
+                true /* resetLockoutRequiresHardwareAuthToken */));
+        when(mockedFingerprintManager.getSensorPropertiesInternal()).thenReturn(props);
+    }
+
+    public static void setupFingerprintEnrolledFingerprints(
+            @NonNull FingerprintManager mockedFingerprintManager,
+            int userId,
+            int enrolledFingerprints) {
+        final ArrayList<Fingerprint> ret = new ArrayList<>();
+        for (int i = 0; i < enrolledFingerprints; ++i) {
+            ret.add(new Fingerprint("name", 0, 0, 0L));
+        }
+        when(mockedFingerprintManager.getEnrolledFingerprints(userId)).thenReturn(ret);
+    }
+}

tests/unit/src/com/android/settings/testutils/FakeFeatureFactory.java

@@ -25,6 +25,7 @@ import com.android.settings.accounts.AccountFeatureProvider;
 import com.android.settings.applications.ApplicationFeatureProvider;
 import com.android.settings.aware.AwareFeatureProvider;
 import com.android.settings.biometrics.face.FaceFeatureProvider;
+import com.android.settings.biometrics2.factory.BiometricsRepositoryProvider;
 import com.android.settings.bluetooth.BluetoothFeatureProvider;
 import com.android.settings.dashboard.DashboardFeatureProvider;
 import com.android.settings.dashboard.suggestions.SuggestionFeatureProvider;
@@ -73,6 +74,7 @@ public class FakeFeatureFactory extends FeatureFactory {
     public final BluetoothFeatureProvider mBluetoothFeatureProvider;
     public final AwareFeatureProvider mAwareFeatureProvider;
     public final FaceFeatureProvider mFaceFeatureProvider;
+    public final BiometricsRepositoryProvider mBiometricsRepositoryProvider;
 
     public PanelFeatureProvider panelFeatureProvider;
     public SlicesFeatureProvider slicesFeatureProvider;
@@ -120,6 +122,7 @@ public class FakeFeatureFactory extends FeatureFactory {
         mBluetoothFeatureProvider = mock(BluetoothFeatureProvider.class);
         mAwareFeatureProvider = mock(AwareFeatureProvider.class);
         mFaceFeatureProvider = mock(FaceFeatureProvider.class);
+        mBiometricsRepositoryProvider = mock(BiometricsRepositoryProvider.class);
         wifiTrackerLibProvider = mock(WifiTrackerLibProvider.class);
         securitySettingsFeatureProvider = mock(SecuritySettingsFeatureProvider.class);
         mAccessibilitySearchFeatureProvider = mock(AccessibilitySearchFeatureProvider.class);
@@ -242,6 +245,11 @@ public class FakeFeatureFactory extends FeatureFactory {
         return mFaceFeatureProvider;
     }
 
+    @Override
+    public BiometricsRepositoryProvider getBiometricsRepositoryProvider() {
+        return mBiometricsRepositoryProvider;
+    }
+
     @Override
     public WifiTrackerLibProvider getWifiTrackerLibProvider() {
         return wifiTrackerLibProvider;

tests/unit/src/com/android/settings/testutils/InstantTaskExecutorRule.java

@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2022 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.testutils;
+
+import androidx.arch.core.executor.ArchTaskExecutor;
+import androidx.arch.core.executor.TaskExecutor;
+
+import org.junit.rules.TestWatcher;
+import org.junit.runner.Description;
+
+/**
+ * A JUnit Test Rule that swaps the background executor used by the Architecture Components with a
+ * different one which executes each task synchronously.
+ *
+ * We can't refer it in prebuilt androidX library.
+ * Copied it from androidx/arch/core/executor/testing/InstantTaskExecutorRule.java
+ */
+public class InstantTaskExecutorRule extends TestWatcher {
+    @Override
+    protected void starting(Description description) {
+        super.starting(description);
+        ArchTaskExecutor.getInstance().setDelegate(new TaskExecutor() {
+            @Override
+            public void executeOnDiskIO(Runnable runnable) {
+                runnable.run();
+            }
+
+            @Override
+            public void postToMainThread(Runnable runnable) {
+                runnable.run();
+            }
+
+            @Override
+            public boolean isMainThread() {
+                return true;
+            }
+        });
+    }
+
+    @Override
+    protected void finished(Description description) {
+        super.finished(description);
+        ArchTaskExecutor.getInstance().setDelegate(null);
+    }
+}