<activity android:name="ChooseLockGeneric"
android:label="@string/lockpassword_choose_lock_generic_header"
+ android:excludeFromRecents="true"
+ android:exported="false" />
+
+ <activity android:name=".password.SetNewPasswordActivity"
+ android:theme="@android:style/Theme.NoDisplay"
android:excludeFromRecents="true" >
<intent-filter android:priority="1">
<action android:name="android.app.action.SET_NEW_PASSWORD" />
-->
<TextView xmlns:android="http://schemas.android.com/apk/res/android"
+ android:id="@+id/fingerprint_header_description"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:gravity="center_vertical"
android:paddingStart="?android:attr/listPreferredItemPaddingStart"
android:paddingEnd="?android:attr/listPreferredItemPaddingEnd"
android:text="@string/lock_settings_picker_fingerprint_message"
- android:textAppearance="@android:style/TextAppearance.Material.Subhead" />
+ style="@style/FingerprintHeaderStyle" />
<!-- Title for preference that guides the user through creating a backup unlock password for fingerprint [CHAR LIMIT=45]-->
<string name="fingerprint_unlock_set_unlock_password">Fingerprint + Password</string>
+ <!-- Title for preference that guides the user to skip fingerprint setup [CHAR LIMIT=60]-->
+ <string name="fingerprint_unlock_skip_fingerprint">Continue without fingerprint</string>
+
+ <!-- Message shown in screen lock picker while setting up the new screen lock with fingerprint option. [CHAR LIMIT=NONE]-->
+ <string name="fingerprint_unlock_title">You can unlock your phone using your fingerprint. For security, this option requires a backup screen lock.</string>
+
<!-- Summary for preference that has been disabled by because of the DevicePolicyAdmin, or because device encryption is enabled, or because there are credentials in the credential storage [CHAR LIMIT=50] -->
<string name="unlock_set_unlock_disabled_summary">Disabled by administrator, encryption policy, or credential storage</string>
<item name="android:paddingEnd">56dp</item>
</style>
+ <style name="FingerprintHeaderStyle" parent="android:style/TextAppearance.Material.Subhead">
+ <item name="android:paddingTop">16dp</item>
+ <item name="android:textColor">@color/primary_dark_material_light</item>
+ <item name="android:lineSpacingMultiplier">1.2</item>
+ </style>
+
</resources>
android:key="unlock_set_managed"
android:persistent="false"/>
+ <com.android.settingslib.RestrictedPreference
+ android:key="unlock_skip_fingerprint"
+ android:title="@string/fingerprint_unlock_skip_fingerprint"
+ android:persistent="false"/>
+
</PreferenceScreen>
package com.android.settings;
+import static android.app.admin.DevicePolicyManager.ACTION_SET_NEW_PARENT_PROFILE_PASSWORD;
+import static android.app.admin.DevicePolicyManager.ACTION_SET_NEW_PASSWORD;
+import static com.android.settings.ChooseLockPassword.ChooseLockPasswordFragment.RESULT_FINISHED;
+import static com.android.settingslib.RestrictedLockUtils.EnforcedAdmin;
+
import android.accessibilityservice.AccessibilityServiceInfo;
import android.app.Activity;
import android.app.AlertDialog;
import android.util.EventLog;
import android.util.Log;
import android.view.accessibility.AccessibilityManager;
+import android.widget.TextView;
import com.android.internal.logging.MetricsProto.MetricsEvent;
import com.android.internal.widget.LockPatternUtils;
+import com.android.settings.fingerprint.FingerprintEnrollBase;
+import com.android.settings.fingerprint.FingerprintEnrollFindSensor;
import com.android.settingslib.RestrictedLockUtils;
import com.android.settingslib.RestrictedPreference;
import java.util.List;
-import static com.android.settingslib.RestrictedLockUtils.EnforcedAdmin;
-
public class ChooseLockGeneric extends SettingsActivity {
public static final String CONFIRM_CREDENTIALS = "confirm_credentials";
modIntent.putExtra(EXTRA_SHOW_FRAGMENT, getFragmentClass().getName());
String action = modIntent.getAction();
- if (DevicePolicyManager.ACTION_SET_NEW_PASSWORD.equals(action)
- || DevicePolicyManager.ACTION_SET_NEW_PARENT_PROFILE_PASSWORD.equals(action)) {
+ if (ACTION_SET_NEW_PASSWORD.equals(action)
+ || ACTION_SET_NEW_PARENT_PROFILE_PASSWORD.equals(action)) {
modIntent.putExtra(EXTRA_HIDE_DRAWER, true);
}
return modIntent;
private static final String KEY_UNLOCK_SET_PASSWORD = "unlock_set_password";
private static final String KEY_UNLOCK_SET_PATTERN = "unlock_set_pattern";
private static final String KEY_UNLOCK_SET_MANAGED = "unlock_set_managed";
+ private static final String KEY_SKIP_FINGERPRINT = "unlock_skip_fingerprint";
private static final String PASSWORD_CONFIRMED = "password_confirmed";
private static final String WAITING_FOR_CONFIRMATION = "waiting_for_confirmation";
public static final String MINIMUM_QUALITY_KEY = "minimum_quality";
private static final int CONFIRM_EXISTING_REQUEST = 100;
private static final int ENABLE_ENCRYPTION_REQUEST = 101;
private static final int CHOOSE_LOCK_REQUEST = 102;
+ private static final int CHOOSE_LOCK_BEFORE_FINGERPRINT_REQUEST = 103;
+ private static final int SKIP_FINGERPRINT_REQUEST = 104;
private ChooseLockSettingsHelper mChooseLockSettingsHelper;
private DevicePolicyManager mDPM;
private int mUserId;
private boolean mHideDrawer = false;
private ManagedLockPasswordProvider mManagedPasswordProvider;
+ private boolean mIsSetNewPassword = false;
protected boolean mForFingerprint = false;
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
+ String chooseLockAction = getActivity().getIntent().getAction();
mFingerprintManager =
(FingerprintManager) getActivity().getSystemService(Context.FINGERPRINT_SERVICE);
mDPM = (DevicePolicyManager) getSystemService(Context.DEVICE_POLICY_SERVICE);
mKeyStore = KeyStore.getInstance();
mChooseLockSettingsHelper = new ChooseLockSettingsHelper(this.getActivity());
mLockPatternUtils = new LockPatternUtils(getActivity());
+ mIsSetNewPassword = ACTION_SET_NEW_PARENT_PROFILE_PASSWORD.equals(chooseLockAction)
+ || ACTION_SET_NEW_PASSWORD.equals(chooseLockAction);
// Defaults to needing to confirm credentials
final boolean confirmCredentials = getActivity().getIntent()
ChooseLockSettingsHelper.EXTRA_KEY_FOR_FINGERPRINT, false);
mForChangeCredRequiredForBoot = getArguments() != null && getArguments().getBoolean(
ChooseLockSettingsHelper.EXTRA_KEY_FOR_CHANGE_CRED_REQUIRED_FOR_BOOT);
+ if (mIsSetNewPassword) {
+ // In ACTION_SET_NEW_PARENT_PROFILE_PASSWORD or ACTION_SET_NEW_PASSWORD, the user
+ // will be asked to confirm the password if one has been set.
+ // On fingerprint supported device, fingerprint options are represented in the
+ // options. If the user chooses to skip fingerprint setup, ChooseLockGeneric is
+ // relaunched to only show options without fingerprint. In this case, we shouldn't
+ // ask the user to confirm the password again.
+ mPasswordConfirmed = getActivity().getIntent().getBooleanExtra(
+ PASSWORD_CONFIRMED, false);
+ }
if (savedInstanceState != null) {
mPasswordConfirmed = savedInstanceState.getBoolean(PASSWORD_CONFIRMED);
UserManager.get(getActivity()),
null,
getActivity().getIntent().getExtras()).getIdentifier();
- if (DevicePolicyManager.ACTION_SET_NEW_PARENT_PROFILE_PASSWORD.equals(
- getActivity().getIntent().getAction()) ||
- !mLockPatternUtils.isSeparateProfileChallengeAllowed(targetUser)) {
+ if (ACTION_SET_NEW_PARENT_PROFILE_PASSWORD.equals(chooseLockAction)
+ || !mLockPatternUtils.isSeparateProfileChallengeAllowed(targetUser)) {
// Always use parent if explicitely requested or if profile challenge is not
// supported
Bundle arguments = getArguments();
mUserId = targetUser;
}
- if (DevicePolicyManager.ACTION_SET_NEW_PASSWORD
- .equals(getActivity().getIntent().getAction())
+ if (ACTION_SET_NEW_PASSWORD.equals(chooseLockAction)
&& Utils.isManagedProfile(UserManager.get(getActivity()), mUserId)
&& mLockPatternUtils.isSeparateProfileChallengeEnabled(mUserId)) {
getActivity().setTitle(R.string.lock_settings_picker_title_profile);
protected void addHeaderView() {
if (mForFingerprint) {
setHeaderView(R.layout.choose_lock_generic_fingerprint_header);
+ if (mIsSetNewPassword) {
+ ((TextView) getHeaderView().findViewById(R.id.fingerprint_header_description))
+ .setText(R.string.fingerprint_unlock_title);
+ }
}
}
// unlock method to an insecure one
showFactoryResetProtectionWarningDialog(key);
return true;
+ } else if (KEY_SKIP_FINGERPRINT.equals(key)) {
+ Intent chooseLockGenericIntent = new Intent(getActivity(), ChooseLockGeneric.class);
+ chooseLockGenericIntent.setAction(getIntent().getAction());
+ chooseLockGenericIntent.putExtra(PASSWORD_CONFIRMED, mPasswordConfirmed);
+ startActivityForResult(chooseLockGenericIntent, SKIP_FINGERPRINT_REQUEST);
+ return true;
} else {
return setUnlockMethod(key);
}
getActivity().setResult(resultCode, data);
finish();
}
+ } else if (requestCode == CHOOSE_LOCK_BEFORE_FINGERPRINT_REQUEST
+ && resultCode == FingerprintEnrollBase.RESULT_FINISHED) {
+ Intent intent = new Intent(getActivity(), FingerprintEnrollFindSensor.class);
+ if (data != null) {
+ intent.putExtras(data.getExtras());
+ }
+ startActivity(intent);
+ finish();
+ } else if (requestCode == SKIP_FINGERPRINT_REQUEST) {
+ if (resultCode != RESULT_CANCELED) {
+ getActivity().setResult(
+ resultCode == RESULT_FINISHED ? RESULT_OK : resultCode, data);
+ finish();
+ }
} else {
getActivity().setResult(Activity.RESULT_CANCELED);
finish();
} else {
removePreference(KEY_UNLOCK_SET_MANAGED);
}
+
+ if (!(mForFingerprint && mIsSetNewPassword)) {
+ removePreference(KEY_SKIP_FINGERPRINT);
+ }
}
private void updateCurrentPreference() {
quality = upgradeQuality(quality);
Intent intent = getIntentForUnlockMethod(quality, disabled);
if (intent != null) {
- startActivityForResult(intent, CHOOSE_LOCK_REQUEST);
+ startActivityForResult(intent,
+ mIsSetNewPassword && mHasChallenge
+ ? CHOOSE_LOCK_BEFORE_FINGERPRINT_REQUEST
+ : CHOOSE_LOCK_REQUEST);
return;
}
mLockPatternUtils.setSeparateProfileChallengeEnabled(mUserId, true, mUserPassword);
mChooseLockSettingsHelper.utils().clearLock(mUserId);
mChooseLockSettingsHelper.utils().setLockScreenDisabled(disabled, mUserId);
- removeAllFingerprintForUserAndFinish(mUserId);
getActivity().setResult(Activity.RESULT_OK);
+ removeAllFingerprintForUserAndFinish(mUserId);
} else {
removeAllFingerprintForUserAndFinish(mUserId);
}
*/
public abstract class FingerprintEnrollBase extends InstrumentedActivity
implements View.OnClickListener {
- static final int RESULT_FINISHED = FingerprintSettings.RESULT_FINISHED;
+ public static final int RESULT_FINISHED = FingerprintSettings.RESULT_FINISHED;
static final int RESULT_SKIP = FingerprintSettings.RESULT_SKIP;
static final int RESULT_TIMEOUT = FingerprintSettings.RESULT_TIMEOUT;
--- /dev/null
+/*
+ * Copyright (C) 2016 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.password;
+
+import android.annotation.Nullable;
+import android.app.Activity;
+import android.app.admin.DevicePolicyManager;
+import android.content.Intent;
+import android.os.Bundle;
+
+import com.android.settings.ChooseLockGeneric;
+
+/**
+ * Trampolines {@link DevicePolicyManager#ACTION_SET_NEW_PASSWORD} and
+ * {@link DevicePolicyManager#ACTION_SET_NEW_PARENT_PROFILE_PASSWORD} intent to the appropriate UI
+ * activity for handling set new password.
+ */
+public class SetNewPasswordActivity extends Activity implements SetNewPasswordController.Ui {
+ private String mNewPasswordAction;
+ private SetNewPasswordController mSetNewPasswordController;
+
+ @Override
+ protected void onCreate(Bundle savedState) {
+ super.onCreate(savedState);
+
+ mNewPasswordAction = getIntent().getAction();
+ mSetNewPasswordController = new SetNewPasswordController(this, this);
+ mSetNewPasswordController.dispatchSetNewPasswordIntent();
+ }
+
+ @Override
+ public void launchChooseLock(@Nullable Bundle chooseLockFingerprintExtras) {
+ Intent intent = new Intent(this, ChooseLockGeneric.class)
+ .setAction(mNewPasswordAction);
+ if (chooseLockFingerprintExtras != null) {
+ intent.putExtras(chooseLockFingerprintExtras);
+ }
+ startActivity(intent);
+ finish();
+ }
+}
--- /dev/null
+/*
+ * Copyright (C) 2016 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.password;
+
+import static com.android.internal.util.Preconditions.checkNotNull;
+
+import android.annotation.Nullable;
+import android.app.admin.DevicePolicyManager;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.hardware.fingerprint.FingerprintManager;
+import android.os.Bundle;
+import android.os.UserHandle;
+
+import com.android.internal.annotations.VisibleForTesting;
+import com.android.settings.ChooseLockGeneric;
+import com.android.settings.ChooseLockSettingsHelper;
+
+/**
+ * Business logic for {@link SetNewPasswordActivity}.
+ *
+ * <p>On devices that supports fingerprint, this controller directs the user to configure
+ * fingerprint + a backup password if the device admin allows fingerprint for keyguard and
+ * the user has never configured a fingerprint before.
+ */
+final class SetNewPasswordController {
+
+ interface Ui {
+ /** Starts the {@link ChooseLockGeneric} activity with the given extras. */
+ void launchChooseLock(@Nullable Bundle chooseLockFingerprintExtras);
+ }
+
+ private final int mCurrentUserId;
+ private final PackageManager mPackageManager;
+ @Nullable private final FingerprintManager mFingerprintManager;
+ private final DevicePolicyManager mDevicePolicyManager;
+ private final Ui mUi;
+
+ public SetNewPasswordController(Context context, Ui ui) {
+ this(context.getUserId(),
+ context.getPackageManager(),
+ (FingerprintManager) context.getSystemService(Context.FINGERPRINT_SERVICE),
+ (DevicePolicyManager) context.getSystemService(Context.DEVICE_POLICY_SERVICE),
+ ui);
+ }
+
+ @VisibleForTesting
+ SetNewPasswordController(
+ int currentUserId,
+ PackageManager packageManager,
+ FingerprintManager fingerprintManager,
+ DevicePolicyManager devicePolicyManager,
+ Ui ui) {
+ mCurrentUserId = currentUserId;
+ mPackageManager = checkNotNull(packageManager);
+ mFingerprintManager = fingerprintManager;
+ mDevicePolicyManager = checkNotNull(devicePolicyManager);
+ mUi = checkNotNull(ui);
+ }
+
+ /**
+ * Dispatches the set new password intent to the correct activity that handles it.
+ */
+ public void dispatchSetNewPasswordIntent() {
+ if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_FINGERPRINT)
+ && mFingerprintManager != null
+ && mFingerprintManager.isHardwareDetected()
+ && !mFingerprintManager.hasEnrolledFingerprints()
+ && !isFingerprintDisabledByAdmin()) {
+ mUi.launchChooseLock(getFingerprintChooseLockExtras());
+ } else {
+ mUi.launchChooseLock(null);
+ }
+ }
+
+ private Bundle getFingerprintChooseLockExtras() {
+ Bundle chooseLockExtras = new Bundle();
+ if (mFingerprintManager != null) {
+ long challenge = mFingerprintManager.preEnroll();
+ chooseLockExtras.putInt(ChooseLockGeneric.ChooseLockGenericFragment.MINIMUM_QUALITY_KEY,
+ DevicePolicyManager.PASSWORD_QUALITY_SOMETHING);
+ chooseLockExtras.putBoolean(
+ ChooseLockGeneric.ChooseLockGenericFragment.HIDE_DISABLED_PREFS, true);
+ chooseLockExtras.putBoolean(ChooseLockSettingsHelper.EXTRA_KEY_HAS_CHALLENGE, true);
+ chooseLockExtras.putLong(ChooseLockSettingsHelper.EXTRA_KEY_CHALLENGE, challenge);
+ chooseLockExtras.putBoolean(ChooseLockSettingsHelper.EXTRA_KEY_FOR_FINGERPRINT, true);
+ if (mCurrentUserId != UserHandle.USER_NULL) {
+ chooseLockExtras.putInt(Intent.EXTRA_USER_ID, mCurrentUserId);
+ }
+ }
+ return chooseLockExtras;
+ }
+
+ private boolean isFingerprintDisabledByAdmin() {
+ int disabledFeatures = mDevicePolicyManager.getKeyguardDisabledFeatures(
+ null, mCurrentUserId);
+ return (disabledFeatures & DevicePolicyManager.KEYGUARD_DISABLE_FINGERPRINT) != 0;
+ }
+}
--- /dev/null
+/*
+ * Copyright (C) 2016 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.password;
+
+import static android.content.pm.PackageManager.FEATURE_FINGERPRINT;
+import static com.android.settings.ChooseLockGeneric.ChooseLockGenericFragment.HIDE_DISABLED_PREFS;
+import static com.android.settings.ChooseLockGeneric.ChooseLockGenericFragment.MINIMUM_QUALITY_KEY;
+import static com.android.settings.ChooseLockSettingsHelper.EXTRA_KEY_CHALLENGE;
+import static com.android.settings.ChooseLockSettingsHelper.EXTRA_KEY_FOR_FINGERPRINT;
+import static com.android.settings.ChooseLockSettingsHelper.EXTRA_KEY_HAS_CHALLENGE;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import android.app.admin.DevicePolicyManager;
+import android.content.ComponentName;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.hardware.fingerprint.FingerprintManager;
+import android.os.Bundle;
+
+import com.android.settings.TestConfig;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.annotation.Config;
+
+/**
+ * Tests for {@link SetNewPasswordController}.
+ */
+@RunWith(RobolectricTestRunner.class)
+@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
+public final class SetNewPasswordControllerTest {
+ private static final int CURRENT_UID = 101;
+ private static final long FINGERPRINT_CHALLENGE = -9876512313131L;
+
+ @Mock PackageManager mPackageManager;
+ @Mock FingerprintManager mFingerprintManager;
+ @Mock DevicePolicyManager mDevicePolicyManager;
+
+ @Mock private SetNewPasswordController.Ui mUi;
+ private SetNewPasswordController mSetNewPasswordController;
+
+ @Before
+ public void setUp() {
+ MockitoAnnotations.initMocks(this);
+
+ mSetNewPasswordController = new SetNewPasswordController(
+ CURRENT_UID, mPackageManager, mFingerprintManager, mDevicePolicyManager, mUi);
+
+ when(mFingerprintManager.preEnroll()).thenReturn(FINGERPRINT_CHALLENGE);
+ when(mPackageManager.hasSystemFeature(eq(FEATURE_FINGERPRINT))).thenReturn(true);
+ }
+
+ @Test
+ public void launchChooseLockWithFingerprint() {
+ // GIVEN the device supports fingerprint.
+ when(mFingerprintManager.isHardwareDetected()).thenReturn(true);
+ // GIVEN there are no enrolled fingerprints.
+ when(mFingerprintManager.hasEnrolledFingerprints()).thenReturn(false);
+ // GIVEN DPC does not disallow fingerprint for keyguard usage.
+ when(mDevicePolicyManager.getKeyguardDisabledFeatures(any(ComponentName.class)))
+ .thenReturn(0);
+
+ // WHEN the controller dispatches a set new password intent.
+ mSetNewPasswordController.dispatchSetNewPasswordIntent();
+
+ // THEN the choose lock activity is launched with fingerprint extras.
+ ArgumentCaptor<Bundle> bundleArgumentCaptor = ArgumentCaptor.forClass(Bundle.class);
+ verify(mUi).launchChooseLock(bundleArgumentCaptor.capture());
+ // THEN the extras have all values for fingerprint setup.
+ compareFingerprintExtras(bundleArgumentCaptor.getValue());
+ }
+
+ @Test
+ public void launchChooseLockWithoutFingerprint_noFingerprintFeature() {
+ // GIVEN the device does NOT support fingerprint feature.
+ when(mPackageManager.hasSystemFeature(eq(FEATURE_FINGERPRINT))).thenReturn(false);
+
+ // WHEN the controller dispatches a set new password intent.
+ mSetNewPasswordController.dispatchSetNewPasswordIntent();
+
+ // THEN the choose lock activity is launched without fingerprint extras.
+ verify(mUi).launchChooseLock(null);
+ }
+
+ @Test
+ public void launchChooseLockWithoutFingerprint_noFingerprintSensor() {
+ // GIVEN the device does NOT support fingerprint.
+ when(mFingerprintManager.isHardwareDetected()).thenReturn(false);
+ // GIVEN there are no enrolled fingerprints.
+ when(mFingerprintManager.hasEnrolledFingerprints()).thenReturn(false);
+ // GIVEN DPC does not disallow fingerprint for keyguard usage.
+ when(mDevicePolicyManager.getKeyguardDisabledFeatures(any(ComponentName.class)))
+ .thenReturn(0);
+
+ // WHEN the controller dispatches a set new password intent.
+ mSetNewPasswordController.dispatchSetNewPasswordIntent();
+
+ // THEN the choose lock activity is launched without fingerprint extras.
+ verify(mUi).launchChooseLock(null);
+ }
+
+ @Test
+ public void launchChooseLockWithoutFingerprint_hasFingerprintEnrolled() {
+ // GIVEN the device supports fingerprint.
+ when(mFingerprintManager.isHardwareDetected()).thenReturn(true);
+ // GIVEN there are no enrolled fingerprints.
+ when(mFingerprintManager.hasEnrolledFingerprints()).thenReturn(true);
+ // GIVEN DPC does not disallow fingerprint for keyguard usage.
+ when(mDevicePolicyManager.getKeyguardDisabledFeatures(any(ComponentName.class)))
+ .thenReturn(0);
+
+ // WHEN the controller dispatches a set new password intent.
+ mSetNewPasswordController.dispatchSetNewPasswordIntent();
+
+ // THEN the choose lock activity is launched without fingerprint extras.
+ verify(mUi).launchChooseLock(null);
+ }
+
+ @Test
+ public void launchChooseLockWithoutFingerprint_deviceAdminDisallowFingerprintForKeyguard() {
+ // GIVEN the device supports fingerprint.
+ when(mFingerprintManager.isHardwareDetected()).thenReturn(true);
+ // GIVEN there is an enrolled fingerprint.
+ when(mFingerprintManager.hasEnrolledFingerprints()).thenReturn(true);
+ // GIVEN DPC disallows fingerprint for keyguard usage.
+ when(mDevicePolicyManager.getKeyguardDisabledFeatures(any(ComponentName.class)))
+ .thenReturn(DevicePolicyManager.KEYGUARD_DISABLE_FINGERPRINT);
+
+ // WHEN the controller dispatches a set new password intent.
+ mSetNewPasswordController.dispatchSetNewPasswordIntent();
+
+ // THEN the choose lock activity is launched without fingerprint extras.
+ verify(mUi).launchChooseLock(null);
+ }
+
+ private void compareFingerprintExtras(Bundle actualBundle) {
+ assertEquals(
+ "Password quality must be something in order to config fingerprint.",
+ DevicePolicyManager.PASSWORD_QUALITY_SOMETHING,
+ actualBundle.getInt(MINIMUM_QUALITY_KEY));
+ assertTrue(
+ "All disabled preference should be removed.",
+ actualBundle.getBoolean(HIDE_DISABLED_PREFS));
+ assertTrue(
+ "There must be a fingerprint challenge.",
+ actualBundle.getBoolean(EXTRA_KEY_HAS_CHALLENGE));
+ assertEquals(
+ "The fingerprint challenge must come from the FingerprintManager",
+ FINGERPRINT_CHALLENGE,
+ actualBundle.getLong(EXTRA_KEY_CHALLENGE));
+ assertTrue(
+ "The request must be a fingerprint set up request.",
+ actualBundle.getBoolean(EXTRA_KEY_FOR_FINGERPRINT));
+ assertEquals(
+ "User id must be equaled to the input one.",
+ CURRENT_UID,
+ actualBundle.getInt(Intent.EXTRA_USER_ID));
+ }
+}
OSDN Git Service
