928ddbe731
And create PreferenceControllers for each setting The page is still pretty janky and controllers are invoked manually. Next CL will clean these up. Bug: 32953042 Test: TODO Change-Id: I1d7478324f5de4fdb464d79f89086f7e79c0ee67
1022 lines
44 KiB
Java
1022 lines
44 KiB
Java
/*
|
|
* Copyright (C) 2015 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.fingerprint;
|
|
|
|
|
|
import android.app.Activity;
|
|
import android.app.AlertDialog;
|
|
import android.app.Dialog;
|
|
import android.app.admin.DevicePolicyManager;
|
|
import android.content.ActivityNotFoundException;
|
|
import android.content.Context;
|
|
import android.content.DialogInterface;
|
|
import android.content.Intent;
|
|
import android.graphics.Typeface;
|
|
import android.graphics.drawable.Drawable;
|
|
import android.hardware.fingerprint.Fingerprint;
|
|
import android.hardware.fingerprint.FingerprintManager;
|
|
import android.os.Bundle;
|
|
import android.os.CancellationSignal;
|
|
import android.os.Handler;
|
|
import android.os.UserHandle;
|
|
import android.os.UserManager;
|
|
import android.support.annotation.VisibleForTesting;
|
|
import android.support.v7.preference.Preference;
|
|
import android.support.v7.preference.Preference.OnPreferenceChangeListener;
|
|
import android.support.v7.preference.Preference.OnPreferenceClickListener;
|
|
import android.support.v7.preference.PreferenceGroup;
|
|
import android.support.v7.preference.PreferenceScreen;
|
|
import android.support.v7.preference.PreferenceViewHolder;
|
|
import android.text.Annotation;
|
|
import android.text.SpannableString;
|
|
import android.text.SpannableStringBuilder;
|
|
import android.text.TextPaint;
|
|
import android.text.TextUtils;
|
|
import android.text.style.URLSpan;
|
|
import android.util.Log;
|
|
import android.view.View;
|
|
import android.view.WindowManager;
|
|
import android.widget.EditText;
|
|
import android.widget.Toast;
|
|
|
|
import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
|
|
import com.android.settings.R;
|
|
import com.android.settings.SettingsPreferenceFragment;
|
|
import com.android.settings.SubSettings;
|
|
import com.android.settings.Utils;
|
|
import com.android.settings.core.instrumentation.InstrumentedDialogFragment;
|
|
import com.android.settings.password.ChooseLockGeneric;
|
|
import com.android.settings.password.ChooseLockSettingsHelper;
|
|
import com.android.settingslib.HelpUtils;
|
|
import com.android.settingslib.RestrictedLockUtils;
|
|
import com.android.settingslib.RestrictedLockUtils.EnforcedAdmin;
|
|
import com.android.settingslib.TwoTargetPreference;
|
|
import com.android.settingslib.widget.FooterPreference;
|
|
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
|
|
/**
|
|
* Settings screen for fingerprints
|
|
*/
|
|
public class FingerprintSettings extends SubSettings {
|
|
|
|
private static final String TAG = "FingerprintSettings";
|
|
|
|
/**
|
|
* Used by the choose fingerprint wizard to indicate the wizard is
|
|
* finished, and each activity in the wizard should finish.
|
|
* <p>
|
|
* Previously, each activity in the wizard would finish itself after
|
|
* starting the next activity. However, this leads to broken 'Back'
|
|
* behavior. So, now an activity does not finish itself until it gets this
|
|
* result.
|
|
*/
|
|
protected static final int RESULT_FINISHED = RESULT_FIRST_USER;
|
|
|
|
/**
|
|
* Used by the enrolling screen during setup wizard to skip over setting up fingerprint, which
|
|
* will be useful if the user accidentally entered this flow.
|
|
*/
|
|
protected static final int RESULT_SKIP = RESULT_FIRST_USER + 1;
|
|
|
|
/**
|
|
* Like {@link #RESULT_FINISHED} except this one indicates enrollment failed because the
|
|
* device was left idle. This is used to clear the credential token to require the user to
|
|
* re-enter their pin/pattern/password before continuing.
|
|
*/
|
|
protected static final int RESULT_TIMEOUT = RESULT_FIRST_USER + 2;
|
|
|
|
private static final long LOCKOUT_DURATION = 30000; // time we have to wait for fp to reset, ms
|
|
|
|
public static final String KEY_FINGERPRINT_SETTINGS = "fingerprint_settings";
|
|
|
|
@Override
|
|
public Intent getIntent() {
|
|
Intent modIntent = new Intent(super.getIntent());
|
|
modIntent.putExtra(EXTRA_SHOW_FRAGMENT, FingerprintSettingsFragment.class.getName());
|
|
return modIntent;
|
|
}
|
|
|
|
@Override
|
|
protected boolean isValidFragment(String fragmentName) {
|
|
if (FingerprintSettingsFragment.class.getName().equals(fragmentName)) return true;
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public void onCreate(Bundle savedInstanceState) {
|
|
super.onCreate(savedInstanceState);
|
|
CharSequence msg = getText(R.string.security_settings_fingerprint_preference_title);
|
|
setTitle(msg);
|
|
}
|
|
|
|
public static class FingerprintSettingsFragment extends SettingsPreferenceFragment
|
|
implements OnPreferenceChangeListener, FingerprintPreference.OnDeleteClickListener {
|
|
private static final int RESET_HIGHLIGHT_DELAY_MS = 500;
|
|
|
|
private static final String TAG = "FingerprintSettings";
|
|
private static final String KEY_FINGERPRINT_ITEM_PREFIX = "key_fingerprint_item";
|
|
private static final String KEY_FINGERPRINT_ADD = "key_fingerprint_add";
|
|
private static final String KEY_FINGERPRINT_ENABLE_KEYGUARD_TOGGLE =
|
|
"fingerprint_enable_keyguard_toggle";
|
|
private static final String KEY_LAUNCHED_CONFIRM = "launched_confirm";
|
|
|
|
private static final int MSG_REFRESH_FINGERPRINT_TEMPLATES = 1000;
|
|
private static final int MSG_FINGER_AUTH_SUCCESS = 1001;
|
|
private static final int MSG_FINGER_AUTH_FAIL = 1002;
|
|
private static final int MSG_FINGER_AUTH_ERROR = 1003;
|
|
private static final int MSG_FINGER_AUTH_HELP = 1004;
|
|
|
|
private static final int CONFIRM_REQUEST = 101;
|
|
private static final int CHOOSE_LOCK_GENERIC_REQUEST = 102;
|
|
|
|
private static final int ADD_FINGERPRINT_REQUEST = 10;
|
|
|
|
protected static final boolean DEBUG = true;
|
|
|
|
private FingerprintManager mFingerprintManager;
|
|
private boolean mInFingerprintLockout;
|
|
private byte[] mToken;
|
|
private boolean mLaunchedConfirm;
|
|
private Drawable mHighlightDrawable;
|
|
private int mUserId;
|
|
|
|
private static final String TAG_AUTHENTICATE_SIDECAR = "authenticate_sidecar";
|
|
private static final String TAG_REMOVAL_SIDECAR = "removal_sidecar";
|
|
private FingerprintAuthenticateSidecar mAuthenticateSidecar;
|
|
private FingerprintRemoveSidecar mRemovalSidecar;
|
|
private HashMap<Integer, String> mFingerprintsRenaming;
|
|
|
|
FingerprintAuthenticateSidecar.Listener mAuthenticateListener =
|
|
new FingerprintAuthenticateSidecar.Listener() {
|
|
@Override
|
|
public void onAuthenticationSucceeded(
|
|
FingerprintManager.AuthenticationResult result) {
|
|
int fingerId = result.getFingerprint().getFingerId();
|
|
mHandler.obtainMessage(MSG_FINGER_AUTH_SUCCESS, fingerId, 0).sendToTarget();
|
|
}
|
|
|
|
@Override
|
|
public void onAuthenticationFailed() {
|
|
mHandler.obtainMessage(MSG_FINGER_AUTH_FAIL).sendToTarget();
|
|
}
|
|
|
|
@Override
|
|
public void onAuthenticationError(int errMsgId, CharSequence errString) {
|
|
mHandler.obtainMessage(MSG_FINGER_AUTH_ERROR, errMsgId, 0, errString)
|
|
.sendToTarget();
|
|
}
|
|
|
|
@Override
|
|
public void onAuthenticationHelp(int helpMsgId, CharSequence helpString) {
|
|
mHandler.obtainMessage(MSG_FINGER_AUTH_HELP, helpMsgId, 0, helpString)
|
|
.sendToTarget();
|
|
}
|
|
};
|
|
|
|
FingerprintRemoveSidecar.Listener mRemovalListener =
|
|
new FingerprintRemoveSidecar.Listener() {
|
|
public void onRemovalSucceeded(Fingerprint fingerprint) {
|
|
mHandler.obtainMessage(MSG_REFRESH_FINGERPRINT_TEMPLATES,
|
|
fingerprint.getFingerId(), 0).sendToTarget();
|
|
updateDialog();
|
|
}
|
|
|
|
public void onRemovalError(Fingerprint fp, int errMsgId, CharSequence errString) {
|
|
final Activity activity = getActivity();
|
|
if (activity != null) {
|
|
Toast.makeText(activity, errString, Toast.LENGTH_SHORT);
|
|
}
|
|
updateDialog();
|
|
}
|
|
|
|
private void updateDialog() {
|
|
RenameDialog renameDialog = (RenameDialog) getFragmentManager().
|
|
findFragmentByTag(RenameDialog.class.getName());
|
|
if (renameDialog != null) {
|
|
renameDialog.enableDelete();
|
|
}
|
|
}
|
|
};
|
|
|
|
private final Handler mHandler = new Handler() {
|
|
@Override
|
|
public void handleMessage(android.os.Message msg) {
|
|
switch (msg.what) {
|
|
case MSG_REFRESH_FINGERPRINT_TEMPLATES:
|
|
removeFingerprintPreference(msg.arg1);
|
|
updateAddPreference();
|
|
retryFingerprint();
|
|
break;
|
|
case MSG_FINGER_AUTH_SUCCESS:
|
|
highlightFingerprintItem(msg.arg1);
|
|
retryFingerprint();
|
|
break;
|
|
case MSG_FINGER_AUTH_FAIL:
|
|
// No action required... fingerprint will allow up to 5 of these
|
|
break;
|
|
case MSG_FINGER_AUTH_ERROR:
|
|
handleError(msg.arg1 /* errMsgId */, (CharSequence) msg.obj /* errStr */ );
|
|
break;
|
|
case MSG_FINGER_AUTH_HELP: {
|
|
// Not used
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @param errMsgId
|
|
*/
|
|
protected void handleError(int errMsgId, CharSequence msg) {
|
|
switch (errMsgId) {
|
|
case FingerprintManager.FINGERPRINT_ERROR_CANCELED:
|
|
return; // Only happens if we get preempted by another activity. Ignored.
|
|
case FingerprintManager.FINGERPRINT_ERROR_LOCKOUT:
|
|
mInFingerprintLockout = true;
|
|
// We've been locked out. Reset after 30s.
|
|
if (!mHandler.hasCallbacks(mFingerprintLockoutReset)) {
|
|
mHandler.postDelayed(mFingerprintLockoutReset,
|
|
LOCKOUT_DURATION);
|
|
}
|
|
break;
|
|
case FingerprintManager.FINGERPRINT_ERROR_LOCKOUT_PERMANENT:
|
|
mInFingerprintLockout = true;
|
|
break;
|
|
}
|
|
|
|
if (mInFingerprintLockout) {
|
|
// Activity can be null on a screen rotation.
|
|
final Activity activity = getActivity();
|
|
if (activity != null) {
|
|
Toast.makeText(activity, msg , Toast.LENGTH_SHORT).show();
|
|
}
|
|
}
|
|
retryFingerprint(); // start again
|
|
}
|
|
|
|
private void retryFingerprint() {
|
|
if (mRemovalSidecar.inProgress()
|
|
|| 0 == mFingerprintManager.getEnrolledFingerprints(mUserId).size()) {
|
|
return;
|
|
}
|
|
// Don't start authentication if ChooseLockGeneric is showing, otherwise if the user
|
|
// is in FP lockout, a toast will show on top
|
|
if (mLaunchedConfirm) {
|
|
return;
|
|
}
|
|
if (!mInFingerprintLockout) {
|
|
mAuthenticateSidecar.startAuthentication(mUserId);
|
|
mAuthenticateSidecar.setListener(mAuthenticateListener);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public int getMetricsCategory() {
|
|
return MetricsEvent.FINGERPRINT;
|
|
}
|
|
|
|
@Override
|
|
public void onCreate(Bundle savedInstanceState) {
|
|
super.onCreate(savedInstanceState);
|
|
|
|
Activity activity = getActivity();
|
|
mFingerprintManager = Utils.getFingerprintManagerOrNull(activity);
|
|
|
|
mAuthenticateSidecar = (FingerprintAuthenticateSidecar)
|
|
getFragmentManager().findFragmentByTag(TAG_AUTHENTICATE_SIDECAR);
|
|
if (mAuthenticateSidecar == null) {
|
|
mAuthenticateSidecar = new FingerprintAuthenticateSidecar();
|
|
getFragmentManager().beginTransaction()
|
|
.add(mAuthenticateSidecar, TAG_AUTHENTICATE_SIDECAR).commit();
|
|
}
|
|
mAuthenticateSidecar.setFingerprintManager(mFingerprintManager);
|
|
|
|
mRemovalSidecar = (FingerprintRemoveSidecar)
|
|
getFragmentManager().findFragmentByTag(TAG_REMOVAL_SIDECAR);
|
|
if (mRemovalSidecar == null) {
|
|
mRemovalSidecar = new FingerprintRemoveSidecar();
|
|
getFragmentManager().beginTransaction()
|
|
.add(mRemovalSidecar, TAG_REMOVAL_SIDECAR).commit();
|
|
}
|
|
mRemovalSidecar.setFingerprintManager(mFingerprintManager);
|
|
mRemovalSidecar.setListener(mRemovalListener);
|
|
|
|
RenameDialog renameDialog = (RenameDialog) getFragmentManager().
|
|
findFragmentByTag(RenameDialog.class.getName());
|
|
if (renameDialog != null) {
|
|
renameDialog.setDeleteInProgress(mRemovalSidecar.inProgress());
|
|
}
|
|
|
|
mFingerprintsRenaming = new HashMap<Integer, String>();
|
|
|
|
if (savedInstanceState != null) {
|
|
mFingerprintsRenaming = (HashMap<Integer, String>)
|
|
savedInstanceState.getSerializable("mFingerprintsRenaming");
|
|
mToken = savedInstanceState.getByteArray(
|
|
ChooseLockSettingsHelper.EXTRA_KEY_CHALLENGE_TOKEN);
|
|
mLaunchedConfirm = savedInstanceState.getBoolean(
|
|
KEY_LAUNCHED_CONFIRM, false);
|
|
}
|
|
mUserId = getActivity().getIntent().getIntExtra(
|
|
Intent.EXTRA_USER_ID, UserHandle.myUserId());
|
|
|
|
// Need to authenticate a session token if none
|
|
if (mToken == null && mLaunchedConfirm == false) {
|
|
mLaunchedConfirm = true;
|
|
launchChooseOrConfirmLock();
|
|
}
|
|
|
|
final FooterPreference pref = mFooterPreferenceMixin.createFooterPreference();
|
|
final EnforcedAdmin admin = RestrictedLockUtils.checkIfKeyguardFeaturesDisabled(
|
|
activity, DevicePolicyManager.KEYGUARD_DISABLE_FINGERPRINT, mUserId);
|
|
pref.setTitle(LearnMoreSpan.linkify(getText(admin != null
|
|
? R.string.security_settings_fingerprint_enroll_disclaimer_lockscreen_disabled
|
|
: R.string.security_settings_fingerprint_enroll_disclaimer),
|
|
getString(getHelpResource()), admin));
|
|
}
|
|
|
|
protected void removeFingerprintPreference(int fingerprintId) {
|
|
String name = genKey(fingerprintId);
|
|
Preference prefToRemove = findPreference(name);
|
|
if (prefToRemove != null) {
|
|
if (!getPreferenceScreen().removePreference(prefToRemove)) {
|
|
Log.w(TAG, "Failed to remove preference with key " + name);
|
|
}
|
|
} else {
|
|
Log.w(TAG, "Can't find preference to remove: " + name);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Important!
|
|
*
|
|
* Don't forget to update the SecuritySearchIndexProvider if you are doing any change in the
|
|
* logic or adding/removing preferences here.
|
|
*/
|
|
private PreferenceScreen createPreferenceHierarchy() {
|
|
PreferenceScreen root = getPreferenceScreen();
|
|
if (root != null) {
|
|
root.removeAll();
|
|
}
|
|
addPreferencesFromResource(R.xml.security_settings_fingerprint);
|
|
root = getPreferenceScreen();
|
|
addFingerprintItemPreferences(root);
|
|
setPreferenceScreen(root);
|
|
return root;
|
|
}
|
|
|
|
private void addFingerprintItemPreferences(PreferenceGroup root) {
|
|
root.removeAll();
|
|
final List<Fingerprint> items = mFingerprintManager.getEnrolledFingerprints(mUserId);
|
|
final int fingerprintCount = items.size();
|
|
for (int i = 0; i < fingerprintCount; i++) {
|
|
final Fingerprint item = items.get(i);
|
|
FingerprintPreference pref = new FingerprintPreference(root.getContext(),
|
|
this /* onDeleteClickListener */);
|
|
pref.setKey(genKey(item.getFingerId()));
|
|
pref.setTitle(item.getName());
|
|
pref.setFingerprint(item);
|
|
pref.setPersistent(false);
|
|
pref.setIcon(R.drawable.ic_fingerprint_24dp);
|
|
if (mRemovalSidecar.isRemovingFingerprint(item.getFingerId())) {
|
|
pref.setEnabled(false);
|
|
}
|
|
if (mFingerprintsRenaming.containsKey(item.getFingerId())) {
|
|
pref.setTitle(mFingerprintsRenaming.get(item.getFingerId()));
|
|
}
|
|
root.addPreference(pref);
|
|
pref.setOnPreferenceChangeListener(this);
|
|
}
|
|
Preference addPreference = new Preference(root.getContext());
|
|
addPreference.setKey(KEY_FINGERPRINT_ADD);
|
|
addPreference.setTitle(R.string.fingerprint_add_title);
|
|
addPreference.setIcon(R.drawable.ic_menu_add);
|
|
root.addPreference(addPreference);
|
|
addPreference.setOnPreferenceChangeListener(this);
|
|
updateAddPreference();
|
|
}
|
|
|
|
private void updateAddPreference() {
|
|
if (getActivity() == null) return; // Activity went away
|
|
|
|
/* Disable preference if too many fingerprints added */
|
|
final int max = getContext().getResources().getInteger(
|
|
com.android.internal.R.integer.config_fingerprintMaxTemplatesPerUser);
|
|
boolean tooMany = mFingerprintManager.getEnrolledFingerprints(mUserId).size() >= max;
|
|
// retryFingerprint() will be called when remove finishes
|
|
// need to disable enroll or have a way to determine if enroll is in progress
|
|
final boolean removalInProgress = mRemovalSidecar.inProgress();
|
|
CharSequence maxSummary = tooMany ?
|
|
getContext().getString(R.string.fingerprint_add_max, max) : "";
|
|
Preference addPreference = findPreference(KEY_FINGERPRINT_ADD);
|
|
addPreference.setSummary(maxSummary);
|
|
addPreference.setEnabled(!tooMany && !removalInProgress);
|
|
}
|
|
|
|
private static String genKey(int id) {
|
|
return KEY_FINGERPRINT_ITEM_PREFIX + "_" + id;
|
|
}
|
|
|
|
@Override
|
|
public void onResume() {
|
|
super.onResume();
|
|
mInFingerprintLockout = false;
|
|
// Make sure we reload the preference hierarchy since fingerprints may be added,
|
|
// deleted or renamed.
|
|
updatePreferences();
|
|
if (mRemovalSidecar != null) {
|
|
mRemovalSidecar.setListener(mRemovalListener);
|
|
}
|
|
}
|
|
|
|
private void updatePreferences() {
|
|
createPreferenceHierarchy();
|
|
retryFingerprint();
|
|
}
|
|
|
|
@Override
|
|
public void onPause() {
|
|
super.onPause();
|
|
if (mRemovalSidecar != null) {
|
|
mRemovalSidecar.setListener(null);
|
|
}
|
|
if (mAuthenticateSidecar != null) {
|
|
mAuthenticateSidecar.setListener(null);
|
|
mAuthenticateSidecar.stopAuthentication();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onSaveInstanceState(final Bundle outState) {
|
|
outState.putByteArray(ChooseLockSettingsHelper.EXTRA_KEY_CHALLENGE_TOKEN,
|
|
mToken);
|
|
outState.putBoolean(KEY_LAUNCHED_CONFIRM, mLaunchedConfirm);
|
|
outState.putSerializable("mFingerprintsRenaming", mFingerprintsRenaming);
|
|
}
|
|
|
|
@Override
|
|
public boolean onPreferenceTreeClick(Preference pref) {
|
|
final String key = pref.getKey();
|
|
if (KEY_FINGERPRINT_ADD.equals(key)) {
|
|
Intent intent = new Intent();
|
|
intent.setClassName("com.android.settings",
|
|
FingerprintEnrollEnrolling.class.getName());
|
|
intent.putExtra(Intent.EXTRA_USER_ID, mUserId);
|
|
intent.putExtra(ChooseLockSettingsHelper.EXTRA_KEY_CHALLENGE_TOKEN, mToken);
|
|
startActivityForResult(intent, ADD_FINGERPRINT_REQUEST);
|
|
} else if (pref instanceof FingerprintPreference) {
|
|
FingerprintPreference fpref = (FingerprintPreference) pref;
|
|
final Fingerprint fp = fpref.getFingerprint();
|
|
showRenameDialog(fp);
|
|
}
|
|
return super.onPreferenceTreeClick(pref);
|
|
}
|
|
|
|
@Override
|
|
public void onDeleteClick(FingerprintPreference p) {
|
|
final boolean hasMultipleFingerprint =
|
|
mFingerprintManager.getEnrolledFingerprints(mUserId).size() > 1;
|
|
final Fingerprint fp = p.getFingerprint();
|
|
|
|
if (hasMultipleFingerprint) {
|
|
if (mRemovalSidecar.inProgress()) {
|
|
Log.d(TAG, "Fingerprint delete in progress, skipping");
|
|
return;
|
|
}
|
|
DeleteFingerprintDialog.newInstance(fp, this /* target */)
|
|
.show(getFragmentManager(), DeleteFingerprintDialog.class.getName());
|
|
} else {
|
|
ConfirmLastDeleteDialog lastDeleteDialog = new ConfirmLastDeleteDialog();
|
|
final boolean isProfileChallengeUser =
|
|
UserManager.get(getContext()).isManagedProfile(mUserId);
|
|
final Bundle args = new Bundle();
|
|
args.putParcelable("fingerprint", fp);
|
|
args.putBoolean("isProfileChallengeUser", isProfileChallengeUser);
|
|
lastDeleteDialog.setArguments(args);
|
|
lastDeleteDialog.setTargetFragment(this, 0);
|
|
lastDeleteDialog.show(getFragmentManager(),
|
|
ConfirmLastDeleteDialog.class.getName());
|
|
}
|
|
}
|
|
|
|
private void showRenameDialog(final Fingerprint fp) {
|
|
RenameDialog renameDialog = new RenameDialog();
|
|
Bundle args = new Bundle();
|
|
if (mFingerprintsRenaming.containsKey(fp.getFingerId())) {
|
|
final Fingerprint f = new Fingerprint(mFingerprintsRenaming.get(fp.getFingerId()),
|
|
fp.getGroupId(), fp.getFingerId(), fp.getDeviceId());
|
|
args.putParcelable("fingerprint", f);
|
|
} else {
|
|
args.putParcelable("fingerprint", fp);
|
|
}
|
|
renameDialog.setDeleteInProgress(mRemovalSidecar.inProgress());
|
|
renameDialog.setArguments(args);
|
|
renameDialog.setTargetFragment(this, 0);
|
|
renameDialog.show(getFragmentManager(), RenameDialog.class.getName());
|
|
}
|
|
|
|
@Override
|
|
public boolean onPreferenceChange(Preference preference, Object value) {
|
|
boolean result = true;
|
|
final String key = preference.getKey();
|
|
if (KEY_FINGERPRINT_ENABLE_KEYGUARD_TOGGLE.equals(key)) {
|
|
// TODO
|
|
} else {
|
|
Log.v(TAG, "Unknown key:" + key);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
@Override
|
|
public int getHelpResource() {
|
|
return R.string.help_url_fingerprint;
|
|
}
|
|
|
|
@Override
|
|
public void onActivityResult(int requestCode, int resultCode, Intent data) {
|
|
super.onActivityResult(requestCode, resultCode, data);
|
|
if (requestCode == CHOOSE_LOCK_GENERIC_REQUEST
|
|
|| requestCode == CONFIRM_REQUEST) {
|
|
mLaunchedConfirm = false;
|
|
if (resultCode == RESULT_FINISHED || resultCode == RESULT_OK) {
|
|
// The lock pin/pattern/password was set. Start enrolling!
|
|
if (data != null) {
|
|
mToken = data.getByteArrayExtra(
|
|
ChooseLockSettingsHelper.EXTRA_KEY_CHALLENGE_TOKEN);
|
|
}
|
|
}
|
|
} else if (requestCode == ADD_FINGERPRINT_REQUEST) {
|
|
if (resultCode == RESULT_TIMEOUT) {
|
|
Activity activity = getActivity();
|
|
activity.setResult(RESULT_TIMEOUT);
|
|
activity.finish();
|
|
}
|
|
}
|
|
|
|
if (mToken == null) {
|
|
// Didn't get an authentication, finishing
|
|
getActivity().finish();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onDestroy() {
|
|
super.onDestroy();
|
|
if (getActivity().isFinishing()) {
|
|
int result = mFingerprintManager.postEnroll();
|
|
if (result < 0) {
|
|
Log.w(TAG, "postEnroll failed: result = " + result);
|
|
}
|
|
}
|
|
}
|
|
|
|
private Drawable getHighlightDrawable() {
|
|
if (mHighlightDrawable == null) {
|
|
final Activity activity = getActivity();
|
|
if (activity != null) {
|
|
mHighlightDrawable = activity.getDrawable(R.drawable.preference_highlight);
|
|
}
|
|
}
|
|
return mHighlightDrawable;
|
|
}
|
|
|
|
private void highlightFingerprintItem(int fpId) {
|
|
String prefName = genKey(fpId);
|
|
FingerprintPreference fpref = (FingerprintPreference) findPreference(prefName);
|
|
final Drawable highlight = getHighlightDrawable();
|
|
if (highlight != null && fpref != null) {
|
|
final View view = fpref.getView();
|
|
final int centerX = view.getWidth() / 2;
|
|
final int centerY = view.getHeight() / 2;
|
|
highlight.setHotspot(centerX, centerY);
|
|
view.setBackground(highlight);
|
|
view.setPressed(true);
|
|
view.setPressed(false);
|
|
mHandler.postDelayed(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
view.setBackground(null);
|
|
}
|
|
}, RESET_HIGHLIGHT_DELAY_MS);
|
|
}
|
|
}
|
|
|
|
private void launchChooseOrConfirmLock() {
|
|
Intent intent = new Intent();
|
|
long challenge = mFingerprintManager.preEnroll();
|
|
ChooseLockSettingsHelper helper = new ChooseLockSettingsHelper(getActivity(), this);
|
|
if (!helper.launchConfirmationActivity(CONFIRM_REQUEST,
|
|
getString(R.string.security_settings_fingerprint_preference_title),
|
|
null, null, challenge, mUserId)) {
|
|
intent.setClassName("com.android.settings", ChooseLockGeneric.class.getName());
|
|
intent.putExtra(ChooseLockGeneric.ChooseLockGenericFragment.MINIMUM_QUALITY_KEY,
|
|
DevicePolicyManager.PASSWORD_QUALITY_SOMETHING);
|
|
intent.putExtra(ChooseLockGeneric.ChooseLockGenericFragment.HIDE_DISABLED_PREFS,
|
|
true);
|
|
intent.putExtra(ChooseLockSettingsHelper.EXTRA_KEY_HAS_CHALLENGE, true);
|
|
intent.putExtra(Intent.EXTRA_USER_ID, mUserId);
|
|
intent.putExtra(ChooseLockSettingsHelper.EXTRA_KEY_CHALLENGE, challenge);
|
|
intent.putExtra(Intent.EXTRA_USER_ID, mUserId);
|
|
startActivityForResult(intent, CHOOSE_LOCK_GENERIC_REQUEST);
|
|
}
|
|
}
|
|
|
|
@VisibleForTesting
|
|
void deleteFingerPrint(Fingerprint fingerPrint) {
|
|
mRemovalSidecar.startRemove(fingerPrint, mUserId);
|
|
String name = genKey(fingerPrint.getFingerId());
|
|
Preference prefToRemove = findPreference(name);
|
|
prefToRemove.setEnabled(false);
|
|
updateAddPreference();
|
|
}
|
|
|
|
private void renameFingerPrint(int fingerId, String newName) {
|
|
mFingerprintManager.rename(fingerId, mUserId, newName);
|
|
if (!TextUtils.isEmpty(newName)) {
|
|
mFingerprintsRenaming.put(fingerId, newName);
|
|
}
|
|
updatePreferences();
|
|
}
|
|
|
|
private final Runnable mFingerprintLockoutReset = new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
mInFingerprintLockout = false;
|
|
retryFingerprint();
|
|
}
|
|
};
|
|
|
|
public static class DeleteFingerprintDialog extends InstrumentedDialogFragment
|
|
implements DialogInterface.OnClickListener {
|
|
|
|
private static final String KEY_FINGERPRINT = "fingerprint";
|
|
private Fingerprint mFp;
|
|
private AlertDialog mAlertDialog;
|
|
|
|
public static DeleteFingerprintDialog newInstance(Fingerprint fp,
|
|
FingerprintSettingsFragment target) {
|
|
final DeleteFingerprintDialog dialog = new DeleteFingerprintDialog();
|
|
final Bundle bundle = new Bundle();
|
|
bundle.putParcelable(KEY_FINGERPRINT, fp);
|
|
dialog.setArguments(bundle);
|
|
dialog.setTargetFragment(target, 0 /* requestCode */);
|
|
return dialog;
|
|
}
|
|
|
|
@Override
|
|
public int getMetricsCategory() {
|
|
return MetricsEvent.DIALOG_FINGERPINT_EDIT;
|
|
}
|
|
|
|
@Override
|
|
public Dialog onCreateDialog(Bundle savedInstanceState) {
|
|
mFp = getArguments().getParcelable(KEY_FINGERPRINT);
|
|
final String title = getString(R.string.fingerprint_delete_title, mFp.getName());
|
|
|
|
mAlertDialog = new AlertDialog.Builder(getActivity())
|
|
.setTitle(title)
|
|
.setMessage(R.string.fingerprint_delete_message)
|
|
.setPositiveButton(
|
|
R.string.security_settings_fingerprint_enroll_dialog_delete,
|
|
this /* onClickListener */)
|
|
.setNegativeButton(R.string.cancel, null /* onClickListener */)
|
|
.create();
|
|
return mAlertDialog;
|
|
}
|
|
|
|
@Override
|
|
public void onClick(DialogInterface dialog, int which) {
|
|
if (which == DialogInterface.BUTTON_POSITIVE) {
|
|
final int fingerprintId = mFp.getFingerId();
|
|
Log.v(TAG, "Removing fpId=" + fingerprintId);
|
|
mMetricsFeatureProvider.action(getContext(),
|
|
MetricsEvent.ACTION_FINGERPRINT_DELETE,
|
|
fingerprintId);
|
|
FingerprintSettingsFragment parent
|
|
= (FingerprintSettingsFragment) getTargetFragment();
|
|
parent.deleteFingerPrint(mFp);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static class RenameDialog extends InstrumentedDialogFragment {
|
|
|
|
private Fingerprint mFp;
|
|
private EditText mDialogTextField;
|
|
private String mFingerName;
|
|
private Boolean mTextHadFocus;
|
|
private int mTextSelectionStart;
|
|
private int mTextSelectionEnd;
|
|
private AlertDialog mAlertDialog;
|
|
private boolean mDeleteInProgress;
|
|
|
|
public void setDeleteInProgress(boolean deleteInProgress) {
|
|
mDeleteInProgress = deleteInProgress;
|
|
}
|
|
|
|
@Override
|
|
public Dialog onCreateDialog(Bundle savedInstanceState) {
|
|
mFp = getArguments().getParcelable("fingerprint");
|
|
if (savedInstanceState != null) {
|
|
mFingerName = savedInstanceState.getString("fingerName");
|
|
mTextHadFocus = savedInstanceState.getBoolean("textHadFocus");
|
|
mTextSelectionStart = savedInstanceState.getInt("startSelection");
|
|
mTextSelectionEnd = savedInstanceState.getInt("endSelection");
|
|
}
|
|
mAlertDialog = new AlertDialog.Builder(getActivity())
|
|
.setView(R.layout.fingerprint_rename_dialog)
|
|
.setPositiveButton(R.string.security_settings_fingerprint_enroll_dialog_ok,
|
|
new DialogInterface.OnClickListener() {
|
|
@Override
|
|
public void onClick(DialogInterface dialog, int which) {
|
|
final String newName =
|
|
mDialogTextField.getText().toString();
|
|
final CharSequence name = mFp.getName();
|
|
if (!TextUtils.equals(newName, name)) {
|
|
Log.d(TAG, "rename " + name + " to " + newName);
|
|
mMetricsFeatureProvider.action(getContext(),
|
|
MetricsEvent.ACTION_FINGERPRINT_RENAME,
|
|
mFp.getFingerId());
|
|
FingerprintSettingsFragment parent
|
|
= (FingerprintSettingsFragment)
|
|
getTargetFragment();
|
|
parent.renameFingerPrint(mFp.getFingerId(),
|
|
newName);
|
|
}
|
|
dialog.dismiss();
|
|
}
|
|
})
|
|
.create();
|
|
mAlertDialog.setOnShowListener(new DialogInterface.OnShowListener() {
|
|
@Override
|
|
public void onShow(DialogInterface dialog) {
|
|
mDialogTextField = (EditText) mAlertDialog.findViewById(
|
|
R.id.fingerprint_rename_field);
|
|
CharSequence name = mFingerName == null ? mFp.getName() : mFingerName;
|
|
mDialogTextField.setText(name);
|
|
if (mTextHadFocus == null) {
|
|
mDialogTextField.selectAll();
|
|
} else {
|
|
mDialogTextField.setSelection(mTextSelectionStart, mTextSelectionEnd);
|
|
}
|
|
if (mDeleteInProgress) {
|
|
mAlertDialog.getButton(AlertDialog.BUTTON_NEGATIVE).setEnabled(false);
|
|
}
|
|
}
|
|
});
|
|
if (mTextHadFocus == null || mTextHadFocus) {
|
|
// Request the IME
|
|
mAlertDialog.getWindow().setSoftInputMode(
|
|
WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
|
|
}
|
|
return mAlertDialog;
|
|
}
|
|
|
|
public void enableDelete() {
|
|
mDeleteInProgress = false;
|
|
if (mAlertDialog != null) {
|
|
mAlertDialog.getButton(AlertDialog.BUTTON_NEGATIVE).setEnabled(true);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onSaveInstanceState(Bundle outState) {
|
|
super.onSaveInstanceState(outState);
|
|
if (mDialogTextField != null) {
|
|
outState.putString("fingerName", mDialogTextField.getText().toString());
|
|
outState.putBoolean("textHadFocus", mDialogTextField.hasFocus());
|
|
outState.putInt("startSelection", mDialogTextField.getSelectionStart());
|
|
outState.putInt("endSelection", mDialogTextField.getSelectionEnd());
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public int getMetricsCategory() {
|
|
return MetricsEvent.DIALOG_FINGERPINT_EDIT;
|
|
}
|
|
}
|
|
|
|
public static class ConfirmLastDeleteDialog extends InstrumentedDialogFragment {
|
|
|
|
private Fingerprint mFp;
|
|
|
|
@Override
|
|
public int getMetricsCategory() {
|
|
return MetricsEvent.DIALOG_FINGERPINT_DELETE_LAST;
|
|
}
|
|
|
|
@Override
|
|
public Dialog onCreateDialog(Bundle savedInstanceState) {
|
|
mFp = getArguments().getParcelable("fingerprint");
|
|
final boolean isProfileChallengeUser =
|
|
getArguments().getBoolean("isProfileChallengeUser");
|
|
final AlertDialog alertDialog = new AlertDialog.Builder(getActivity())
|
|
.setTitle(R.string.fingerprint_last_delete_title)
|
|
.setMessage((isProfileChallengeUser)
|
|
? R.string.fingerprint_last_delete_message_profile_challenge
|
|
: R.string.fingerprint_last_delete_message)
|
|
.setPositiveButton(R.string.fingerprint_last_delete_confirm,
|
|
new DialogInterface.OnClickListener() {
|
|
@Override
|
|
public void onClick(DialogInterface dialog, int which) {
|
|
FingerprintSettingsFragment parent
|
|
= (FingerprintSettingsFragment) getTargetFragment();
|
|
parent.deleteFingerPrint(mFp);
|
|
dialog.dismiss();
|
|
}
|
|
})
|
|
.setNegativeButton(
|
|
R.string.cancel,
|
|
new DialogInterface.OnClickListener() {
|
|
@Override
|
|
public void onClick(DialogInterface dialog, int which) {
|
|
dialog.dismiss();
|
|
}
|
|
})
|
|
.create();
|
|
return alertDialog;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static class FingerprintPreference extends TwoTargetPreference {
|
|
|
|
private final OnDeleteClickListener mOnDeleteClickListener;
|
|
|
|
private Fingerprint mFingerprint;
|
|
private View mView;
|
|
private View mDeleteView;
|
|
|
|
public interface OnDeleteClickListener {
|
|
void onDeleteClick(FingerprintPreference p);
|
|
}
|
|
|
|
public FingerprintPreference(Context context, OnDeleteClickListener onDeleteClickListener) {
|
|
super(context);
|
|
mOnDeleteClickListener = onDeleteClickListener;
|
|
}
|
|
|
|
public View getView() {
|
|
return mView;
|
|
}
|
|
|
|
public void setFingerprint(Fingerprint item) {
|
|
mFingerprint = item;
|
|
}
|
|
|
|
public Fingerprint getFingerprint() {
|
|
return mFingerprint;
|
|
}
|
|
|
|
@Override
|
|
protected int getSecondTargetResId() {
|
|
return R.layout.preference_widget_delete;
|
|
}
|
|
|
|
@Override
|
|
public void onBindViewHolder(PreferenceViewHolder view) {
|
|
super.onBindViewHolder(view);
|
|
mView = view.itemView;
|
|
mDeleteView = view.itemView.findViewById(R.id.delete_button);
|
|
mDeleteView.setOnClickListener(new View.OnClickListener() {
|
|
@Override
|
|
public void onClick(View v) {
|
|
if (mOnDeleteClickListener != null) {
|
|
mOnDeleteClickListener.onDeleteClick(FingerprintPreference.this);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
private static class LearnMoreSpan extends URLSpan {
|
|
private static final String TAG = "LearnMoreSpan";
|
|
private static final Typeface TYPEFACE_MEDIUM =
|
|
Typeface.create("sans-serif-medium", Typeface.NORMAL);
|
|
|
|
private static final String ANNOTATION_URL = "url";
|
|
private static final String ANNOTATION_ADMIN_DETAILS = "admin_details";
|
|
|
|
private EnforcedAdmin mEnforcedAdmin = null;
|
|
|
|
private LearnMoreSpan(String url) {
|
|
super(url);
|
|
}
|
|
|
|
private LearnMoreSpan(EnforcedAdmin admin) {
|
|
super((String) null);
|
|
mEnforcedAdmin = admin;
|
|
}
|
|
|
|
@Override
|
|
public void onClick(View widget) {
|
|
Context ctx = widget.getContext();
|
|
if (mEnforcedAdmin != null) {
|
|
RestrictedLockUtils.sendShowAdminSupportDetailsIntent(ctx, mEnforcedAdmin);
|
|
} else {
|
|
Intent intent = HelpUtils.getHelpIntent(ctx, getURL(), ctx.getClass().getName());
|
|
if (intent == null) {
|
|
Log.w(LearnMoreSpan.TAG, "Null help intent.");
|
|
return;
|
|
}
|
|
try {
|
|
widget.startActivityForResult(intent, 0);
|
|
} catch (ActivityNotFoundException e) {
|
|
Log.w(FingerprintSettingsFragment.TAG,
|
|
"Actvity was not found for intent, " + intent.toString());
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void updateDrawState(TextPaint ds) {
|
|
super.updateDrawState(ds);
|
|
ds.setUnderlineText(false);
|
|
ds.setTypeface(TYPEFACE_MEDIUM);
|
|
}
|
|
|
|
public static CharSequence linkify(CharSequence rawText, String uri, EnforcedAdmin admin) {
|
|
SpannableString msg = new SpannableString(rawText);
|
|
Annotation[] spans = msg.getSpans(0, msg.length(), Annotation.class);
|
|
SpannableStringBuilder builder = new SpannableStringBuilder(msg);
|
|
for (Annotation annotation : spans) {
|
|
final String key = annotation.getValue();
|
|
int start = msg.getSpanStart(annotation);
|
|
int end = msg.getSpanEnd(annotation);
|
|
LearnMoreSpan link = null;
|
|
if (ANNOTATION_URL.equals(key)) {
|
|
link = new LearnMoreSpan(uri);
|
|
} else if (ANNOTATION_ADMIN_DETAILS.equals(key)) {
|
|
link = new LearnMoreSpan(admin);
|
|
}
|
|
if (link != null) {
|
|
builder.setSpan(link, start, end, msg.getSpanFlags(link));
|
|
}
|
|
}
|
|
return builder;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @deprecated in favor of new SecuritySettings.
|
|
*/
|
|
@Deprecated
|
|
public static Preference getFingerprintPreferenceForUser(Context context, final int userId) {
|
|
final FingerprintManager fpm = Utils.getFingerprintManagerOrNull(context);
|
|
if (fpm == null || !fpm.isHardwareDetected()) {
|
|
Log.v(TAG, "No fingerprint hardware detected!!");
|
|
return null;
|
|
}
|
|
Preference fingerprintPreference = new Preference(context);
|
|
fingerprintPreference.setKey(KEY_FINGERPRINT_SETTINGS);
|
|
fingerprintPreference.setTitle(R.string.security_settings_fingerprint_preference_title);
|
|
final List<Fingerprint> items = fpm.getEnrolledFingerprints(userId);
|
|
final int fingerprintCount = items != null ? items.size() : 0;
|
|
final String clazz;
|
|
if (fingerprintCount > 0) {
|
|
fingerprintPreference.setSummary(context.getResources().getQuantityString(
|
|
R.plurals.security_settings_fingerprint_preference_summary,
|
|
fingerprintCount, fingerprintCount));
|
|
clazz = FingerprintSettings.class.getName();
|
|
} else {
|
|
fingerprintPreference.setSummary(
|
|
R.string.security_settings_fingerprint_preference_summary_none);
|
|
clazz = FingerprintEnrollIntroduction.class.getName();
|
|
}
|
|
fingerprintPreference.setOnPreferenceClickListener(new OnPreferenceClickListener() {
|
|
@Override
|
|
public boolean onPreferenceClick(Preference preference) {
|
|
final Context context = preference.getContext();
|
|
final UserManager userManager = UserManager.get(context);
|
|
if (Utils.startQuietModeDialogIfNecessary(context, userManager,
|
|
userId)) {
|
|
return false;
|
|
}
|
|
Intent intent = new Intent();
|
|
intent.setClassName("com.android.settings", clazz);
|
|
intent.putExtra(Intent.EXTRA_USER_ID, userId);
|
|
context.startActivity(intent);
|
|
return true;
|
|
}
|
|
});
|
|
return fingerprintPreference;
|
|
}
|
|
}
|