1f8fb0f8ce
Change https://googleplex-android-review.git.corp.google.com/#/c/742462/ removed the mDone since graying out the button seemed to remove the need for this. However, you can also enter this command repeatedly from the soft keyboard. Put mDone back. Bug: 23181625 Change-Id: I42e8ecb9824b17825778c9c113130506cc3a200b
676 lines
30 KiB
Java
676 lines
30 KiB
Java
/*
|
|
* Copyright (C) 2010 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;
|
|
|
|
import com.android.internal.logging.MetricsLogger;
|
|
import com.android.internal.widget.LockPatternChecker;
|
|
import com.android.internal.widget.LockPatternUtils;
|
|
import com.android.internal.widget.PasswordEntryKeyboardHelper;
|
|
import com.android.internal.widget.PasswordEntryKeyboardView;
|
|
import com.android.internal.widget.TextViewInputDisabler;
|
|
import com.android.settings.notification.RedactionInterstitial;
|
|
|
|
import android.app.Activity;
|
|
import android.app.Fragment;
|
|
import android.app.admin.DevicePolicyManager;
|
|
import android.content.Context;
|
|
import android.content.Intent;
|
|
import android.inputmethodservice.KeyboardView;
|
|
import android.os.AsyncTask;
|
|
import android.os.Bundle;
|
|
import android.os.Handler;
|
|
import android.os.Message;
|
|
import android.os.UserHandle;
|
|
import android.text.Editable;
|
|
import android.text.InputType;
|
|
import android.text.Selection;
|
|
import android.text.Spannable;
|
|
import android.text.TextUtils;
|
|
import android.text.TextWatcher;
|
|
import android.util.Log;
|
|
import android.view.KeyEvent;
|
|
import android.view.LayoutInflater;
|
|
import android.view.View;
|
|
import android.view.ViewGroup;
|
|
import android.view.View.OnClickListener;
|
|
import android.view.inputmethod.EditorInfo;
|
|
import android.widget.Button;
|
|
import android.widget.TextView;
|
|
import android.widget.TextView.OnEditorActionListener;
|
|
|
|
public class ChooseLockPassword extends SettingsActivity {
|
|
public static final String PASSWORD_MIN_KEY = "lockscreen.password_min";
|
|
public static final String PASSWORD_MAX_KEY = "lockscreen.password_max";
|
|
public static final String PASSWORD_MIN_LETTERS_KEY = "lockscreen.password_min_letters";
|
|
public static final String PASSWORD_MIN_LOWERCASE_KEY = "lockscreen.password_min_lowercase";
|
|
public static final String PASSWORD_MIN_UPPERCASE_KEY = "lockscreen.password_min_uppercase";
|
|
public static final String PASSWORD_MIN_NUMERIC_KEY = "lockscreen.password_min_numeric";
|
|
public static final String PASSWORD_MIN_SYMBOLS_KEY = "lockscreen.password_min_symbols";
|
|
public static final String PASSWORD_MIN_NONLETTER_KEY = "lockscreen.password_min_nonletter";
|
|
|
|
private static final String TAG = "ChooseLockPassword";
|
|
|
|
@Override
|
|
public Intent getIntent() {
|
|
Intent modIntent = new Intent(super.getIntent());
|
|
modIntent.putExtra(EXTRA_SHOW_FRAGMENT, getFragmentClass().getName());
|
|
return modIntent;
|
|
}
|
|
|
|
public static Intent createIntent(Context context, int quality,
|
|
int minLength, final int maxLength, boolean requirePasswordToDecrypt,
|
|
boolean confirmCredentials) {
|
|
Intent intent = new Intent().setClass(context, ChooseLockPassword.class);
|
|
intent.putExtra(LockPatternUtils.PASSWORD_TYPE_KEY, quality);
|
|
intent.putExtra(PASSWORD_MIN_KEY, minLength);
|
|
intent.putExtra(PASSWORD_MAX_KEY, maxLength);
|
|
intent.putExtra(ChooseLockGeneric.CONFIRM_CREDENTIALS, confirmCredentials);
|
|
intent.putExtra(EncryptionInterstitial.EXTRA_REQUIRE_PASSWORD, requirePasswordToDecrypt);
|
|
return intent;
|
|
}
|
|
|
|
public static Intent createIntent(Context context, int quality,
|
|
int minLength, final int maxLength, boolean requirePasswordToDecrypt, String password) {
|
|
Intent intent = createIntent(context, quality, minLength, maxLength,
|
|
requirePasswordToDecrypt, false);
|
|
intent.putExtra(ChooseLockSettingsHelper.EXTRA_KEY_PASSWORD, password);
|
|
return intent;
|
|
}
|
|
|
|
public static Intent createIntent(Context context, int quality,
|
|
int minLength, final int maxLength, boolean requirePasswordToDecrypt, long challenge) {
|
|
Intent intent = createIntent(context, quality, minLength, maxLength,
|
|
requirePasswordToDecrypt, false);
|
|
intent.putExtra(ChooseLockSettingsHelper.EXTRA_KEY_HAS_CHALLENGE, true);
|
|
intent.putExtra(ChooseLockSettingsHelper.EXTRA_KEY_CHALLENGE, challenge);
|
|
return intent;
|
|
}
|
|
|
|
@Override
|
|
protected boolean isValidFragment(String fragmentName) {
|
|
if (ChooseLockPasswordFragment.class.getName().equals(fragmentName)) return true;
|
|
return false;
|
|
}
|
|
|
|
/* package */ Class<? extends Fragment> getFragmentClass() {
|
|
return ChooseLockPasswordFragment.class;
|
|
}
|
|
|
|
@Override
|
|
public void onCreate(Bundle savedInstanceState) {
|
|
// TODO: Fix on phones
|
|
// Disable IME on our window since we provide our own keyboard
|
|
//getWindow().setFlags(WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM,
|
|
//WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM);
|
|
super.onCreate(savedInstanceState);
|
|
CharSequence msg = getText(R.string.lockpassword_choose_your_password_header);
|
|
setTitle(msg);
|
|
}
|
|
|
|
public static class ChooseLockPasswordFragment extends InstrumentedFragment
|
|
implements OnClickListener, OnEditorActionListener, TextWatcher {
|
|
private static final String KEY_FIRST_PIN = "first_pin";
|
|
private static final String KEY_UI_STAGE = "ui_stage";
|
|
private static final String KEY_CURRENT_PASSWORD = "current_password";
|
|
|
|
private String mCurrentPassword;
|
|
private String mChosenPassword;
|
|
private boolean mHasChallenge;
|
|
private long mChallenge;
|
|
private TextView mPasswordEntry;
|
|
private TextViewInputDisabler mPasswordEntryInputDisabler;
|
|
private int mPasswordMinLength = LockPatternUtils.MIN_LOCK_PASSWORD_SIZE;
|
|
private int mPasswordMaxLength = 16;
|
|
private int mPasswordMinLetters = 0;
|
|
private int mPasswordMinUpperCase = 0;
|
|
private int mPasswordMinLowerCase = 0;
|
|
private int mPasswordMinSymbols = 0;
|
|
private int mPasswordMinNumeric = 0;
|
|
private int mPasswordMinNonLetter = 0;
|
|
private LockPatternUtils mLockPatternUtils;
|
|
private AsyncTask<?, ?, ?> mPendingLockCheck;
|
|
private int mRequestedQuality = DevicePolicyManager.PASSWORD_QUALITY_NUMERIC;
|
|
private ChooseLockSettingsHelper mChooseLockSettingsHelper;
|
|
private Stage mUiStage = Stage.Introduction;
|
|
|
|
// True once we have confirmed new PIN/password to prevent virtual keyboard
|
|
// re-entries of the same PIN
|
|
private boolean mDone = false;
|
|
private TextView mHeaderText;
|
|
private String mFirstPin;
|
|
private KeyboardView mKeyboardView;
|
|
private PasswordEntryKeyboardHelper mKeyboardHelper;
|
|
private boolean mIsAlphaMode;
|
|
private Button mCancelButton;
|
|
private Button mNextButton;
|
|
private static final int CONFIRM_EXISTING_REQUEST = 58;
|
|
static final int RESULT_FINISHED = RESULT_FIRST_USER;
|
|
private static final long ERROR_MESSAGE_TIMEOUT = 3000;
|
|
private static final int MSG_SHOW_ERROR = 1;
|
|
|
|
private Handler mHandler = new Handler() {
|
|
@Override
|
|
public void handleMessage(Message msg) {
|
|
if (msg.what == MSG_SHOW_ERROR) {
|
|
updateStage((Stage) msg.obj);
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Keep track internally of where the user is in choosing a pattern.
|
|
*/
|
|
protected enum Stage {
|
|
|
|
Introduction(R.string.lockpassword_choose_your_password_header,
|
|
R.string.lockpassword_choose_your_pin_header,
|
|
R.string.lockpassword_continue_label),
|
|
|
|
NeedToConfirm(R.string.lockpassword_confirm_your_password_header,
|
|
R.string.lockpassword_confirm_your_pin_header,
|
|
R.string.lockpassword_ok_label),
|
|
|
|
ConfirmWrong(R.string.lockpassword_confirm_passwords_dont_match,
|
|
R.string.lockpassword_confirm_pins_dont_match,
|
|
R.string.lockpassword_continue_label);
|
|
|
|
Stage(int hintInAlpha, int hintInNumeric, int nextButtonText) {
|
|
this.alphaHint = hintInAlpha;
|
|
this.numericHint = hintInNumeric;
|
|
this.buttonText = nextButtonText;
|
|
}
|
|
|
|
public final int alphaHint;
|
|
public final int numericHint;
|
|
public final int buttonText;
|
|
}
|
|
|
|
// required constructor for fragments
|
|
public ChooseLockPasswordFragment() {
|
|
|
|
}
|
|
|
|
@Override
|
|
public void onCreate(Bundle savedInstanceState) {
|
|
super.onCreate(savedInstanceState);
|
|
mLockPatternUtils = new LockPatternUtils(getActivity());
|
|
Intent intent = getActivity().getIntent();
|
|
if (!(getActivity() instanceof ChooseLockPassword)) {
|
|
throw new SecurityException("Fragment contained in wrong activity");
|
|
}
|
|
mRequestedQuality = Math.max(intent.getIntExtra(LockPatternUtils.PASSWORD_TYPE_KEY,
|
|
mRequestedQuality), mLockPatternUtils.getRequestedPasswordQuality(
|
|
UserHandle.myUserId()));
|
|
mPasswordMinLength = Math.max(Math.max(
|
|
LockPatternUtils.MIN_LOCK_PASSWORD_SIZE,
|
|
intent.getIntExtra(PASSWORD_MIN_KEY, mPasswordMinLength)),
|
|
mLockPatternUtils.getRequestedMinimumPasswordLength(UserHandle.myUserId()));
|
|
mPasswordMaxLength = intent.getIntExtra(PASSWORD_MAX_KEY, mPasswordMaxLength);
|
|
mPasswordMinLetters = Math.max(intent.getIntExtra(PASSWORD_MIN_LETTERS_KEY,
|
|
mPasswordMinLetters), mLockPatternUtils.getRequestedPasswordMinimumLetters(
|
|
UserHandle.myUserId()));
|
|
mPasswordMinUpperCase = Math.max(intent.getIntExtra(PASSWORD_MIN_UPPERCASE_KEY,
|
|
mPasswordMinUpperCase), mLockPatternUtils.getRequestedPasswordMinimumUpperCase(
|
|
UserHandle.myUserId()));
|
|
mPasswordMinLowerCase = Math.max(intent.getIntExtra(PASSWORD_MIN_LOWERCASE_KEY,
|
|
mPasswordMinLowerCase), mLockPatternUtils.getRequestedPasswordMinimumLowerCase(
|
|
UserHandle.myUserId()));
|
|
mPasswordMinNumeric = Math.max(intent.getIntExtra(PASSWORD_MIN_NUMERIC_KEY,
|
|
mPasswordMinNumeric), mLockPatternUtils.getRequestedPasswordMinimumNumeric(
|
|
UserHandle.myUserId()));
|
|
mPasswordMinSymbols = Math.max(intent.getIntExtra(PASSWORD_MIN_SYMBOLS_KEY,
|
|
mPasswordMinSymbols), mLockPatternUtils.getRequestedPasswordMinimumSymbols(
|
|
UserHandle.myUserId()));
|
|
mPasswordMinNonLetter = Math.max(intent.getIntExtra(PASSWORD_MIN_NONLETTER_KEY,
|
|
mPasswordMinNonLetter), mLockPatternUtils.getRequestedPasswordMinimumNonLetter(
|
|
UserHandle.myUserId()));
|
|
|
|
mChooseLockSettingsHelper = new ChooseLockSettingsHelper(getActivity());
|
|
}
|
|
|
|
@Override
|
|
public View onCreateView(LayoutInflater inflater, ViewGroup container,
|
|
Bundle savedInstanceState) {
|
|
return inflater.inflate(R.layout.choose_lock_password, container, false);
|
|
}
|
|
|
|
@Override
|
|
public void onViewCreated(View view, Bundle savedInstanceState) {
|
|
super.onViewCreated(view, savedInstanceState);
|
|
|
|
mCancelButton = (Button) view.findViewById(R.id.cancel_button);
|
|
mCancelButton.setOnClickListener(this);
|
|
mNextButton = (Button) view.findViewById(R.id.next_button);
|
|
mNextButton.setOnClickListener(this);
|
|
|
|
mIsAlphaMode = DevicePolicyManager.PASSWORD_QUALITY_ALPHABETIC == mRequestedQuality
|
|
|| DevicePolicyManager.PASSWORD_QUALITY_ALPHANUMERIC == mRequestedQuality
|
|
|| DevicePolicyManager.PASSWORD_QUALITY_COMPLEX == mRequestedQuality;
|
|
mKeyboardView = (PasswordEntryKeyboardView) view.findViewById(R.id.keyboard);
|
|
mPasswordEntry = (TextView) view.findViewById(R.id.password_entry);
|
|
mPasswordEntry.setOnEditorActionListener(this);
|
|
mPasswordEntry.addTextChangedListener(this);
|
|
mPasswordEntryInputDisabler = new TextViewInputDisabler(mPasswordEntry);
|
|
|
|
final Activity activity = getActivity();
|
|
mKeyboardHelper = new PasswordEntryKeyboardHelper(activity,
|
|
mKeyboardView, mPasswordEntry);
|
|
mKeyboardHelper.setKeyboardMode(mIsAlphaMode ?
|
|
PasswordEntryKeyboardHelper.KEYBOARD_MODE_ALPHA
|
|
: PasswordEntryKeyboardHelper.KEYBOARD_MODE_NUMERIC);
|
|
|
|
mHeaderText = (TextView) view.findViewById(R.id.headerText);
|
|
mKeyboardView.requestFocus();
|
|
|
|
int currentType = mPasswordEntry.getInputType();
|
|
mPasswordEntry.setInputType(mIsAlphaMode ? currentType
|
|
: (InputType.TYPE_CLASS_NUMBER | InputType.TYPE_NUMBER_VARIATION_PASSWORD));
|
|
|
|
Intent intent = getActivity().getIntent();
|
|
final boolean confirmCredentials = intent.getBooleanExtra(
|
|
ChooseLockGeneric.CONFIRM_CREDENTIALS, true);
|
|
mCurrentPassword = intent.getStringExtra(ChooseLockSettingsHelper.EXTRA_KEY_PASSWORD);
|
|
mHasChallenge = intent.getBooleanExtra(
|
|
ChooseLockSettingsHelper.EXTRA_KEY_HAS_CHALLENGE, false);
|
|
mChallenge = intent.getLongExtra(ChooseLockSettingsHelper.EXTRA_KEY_CHALLENGE, 0);
|
|
if (savedInstanceState == null) {
|
|
updateStage(Stage.Introduction);
|
|
if (confirmCredentials) {
|
|
mChooseLockSettingsHelper.launchConfirmationActivity(CONFIRM_EXISTING_REQUEST,
|
|
getString(R.string.unlock_set_unlock_launch_picker_title), true);
|
|
}
|
|
} else {
|
|
// restore from previous state
|
|
mFirstPin = savedInstanceState.getString(KEY_FIRST_PIN);
|
|
final String state = savedInstanceState.getString(KEY_UI_STAGE);
|
|
if (state != null) {
|
|
mUiStage = Stage.valueOf(state);
|
|
updateStage(mUiStage);
|
|
}
|
|
|
|
if (mCurrentPassword == null) {
|
|
mCurrentPassword = savedInstanceState.getString(KEY_CURRENT_PASSWORD);
|
|
}
|
|
}
|
|
mDone = false;
|
|
if (activity instanceof SettingsActivity) {
|
|
final SettingsActivity sa = (SettingsActivity) activity;
|
|
int id = mIsAlphaMode ? R.string.lockpassword_choose_your_password_header
|
|
: R.string.lockpassword_choose_your_pin_header;
|
|
CharSequence title = getText(id);
|
|
sa.setTitle(title);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
protected int getMetricsCategory() {
|
|
return MetricsLogger.CHOOSE_LOCK_PASSWORD;
|
|
}
|
|
|
|
@Override
|
|
public void onResume() {
|
|
super.onResume();
|
|
updateStage(mUiStage);
|
|
mPasswordEntryInputDisabler.setInputEnabled(true);
|
|
mKeyboardView.requestFocus();
|
|
}
|
|
|
|
@Override
|
|
public void onPause() {
|
|
mHandler.removeMessages(MSG_SHOW_ERROR);
|
|
if (mPendingLockCheck != null) {
|
|
mPendingLockCheck.cancel(false);
|
|
mPendingLockCheck = null;
|
|
}
|
|
|
|
super.onPause();
|
|
}
|
|
|
|
@Override
|
|
public void onSaveInstanceState(Bundle outState) {
|
|
super.onSaveInstanceState(outState);
|
|
outState.putString(KEY_UI_STAGE, mUiStage.name());
|
|
outState.putString(KEY_FIRST_PIN, mFirstPin);
|
|
outState.putString(KEY_CURRENT_PASSWORD, mCurrentPassword);
|
|
}
|
|
|
|
@Override
|
|
public void onActivityResult(int requestCode, int resultCode,
|
|
Intent data) {
|
|
super.onActivityResult(requestCode, resultCode, data);
|
|
switch (requestCode) {
|
|
case CONFIRM_EXISTING_REQUEST:
|
|
if (resultCode != Activity.RESULT_OK) {
|
|
getActivity().setResult(RESULT_FINISHED);
|
|
getActivity().finish();
|
|
} else {
|
|
mCurrentPassword = data.getStringExtra(
|
|
ChooseLockSettingsHelper.EXTRA_KEY_PASSWORD);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
protected Intent getRedactionInterstitialIntent(Context context) {
|
|
return RedactionInterstitial.createStartIntent(context);
|
|
}
|
|
|
|
protected void updateStage(Stage stage) {
|
|
final Stage previousStage = mUiStage;
|
|
mUiStage = stage;
|
|
updateUi();
|
|
|
|
// If the stage changed, announce the header for accessibility. This
|
|
// is a no-op when accessibility is disabled.
|
|
if (previousStage != stage) {
|
|
mHeaderText.announceForAccessibility(mHeaderText.getText());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Validates PIN and returns a message to display if PIN fails test.
|
|
* @param password the raw password the user typed in
|
|
* @return error message to show to user or null if password is OK
|
|
*/
|
|
private String validatePassword(String password) {
|
|
if (password.length() < mPasswordMinLength) {
|
|
return getString(mIsAlphaMode ?
|
|
R.string.lockpassword_password_too_short
|
|
: R.string.lockpassword_pin_too_short, mPasswordMinLength);
|
|
}
|
|
if (password.length() > mPasswordMaxLength) {
|
|
return getString(mIsAlphaMode ?
|
|
R.string.lockpassword_password_too_long
|
|
: R.string.lockpassword_pin_too_long, mPasswordMaxLength + 1);
|
|
}
|
|
int letters = 0;
|
|
int numbers = 0;
|
|
int lowercase = 0;
|
|
int symbols = 0;
|
|
int uppercase = 0;
|
|
int nonletter = 0;
|
|
for (int i = 0; i < password.length(); i++) {
|
|
char c = password.charAt(i);
|
|
// allow non control Latin-1 characters only
|
|
if (c < 32 || c > 127) {
|
|
return getString(R.string.lockpassword_illegal_character);
|
|
}
|
|
if (c >= '0' && c <= '9') {
|
|
numbers++;
|
|
nonletter++;
|
|
} else if (c >= 'A' && c <= 'Z') {
|
|
letters++;
|
|
uppercase++;
|
|
} else if (c >= 'a' && c <= 'z') {
|
|
letters++;
|
|
lowercase++;
|
|
} else {
|
|
symbols++;
|
|
nonletter++;
|
|
}
|
|
}
|
|
if (DevicePolicyManager.PASSWORD_QUALITY_NUMERIC == mRequestedQuality
|
|
|| DevicePolicyManager.PASSWORD_QUALITY_NUMERIC_COMPLEX == mRequestedQuality) {
|
|
if (letters > 0 || symbols > 0) {
|
|
// This shouldn't be possible unless user finds some way to bring up
|
|
// soft keyboard
|
|
return getString(R.string.lockpassword_pin_contains_non_digits);
|
|
}
|
|
// Check for repeated characters or sequences (e.g. '1234', '0000', '2468')
|
|
final int sequence = LockPatternUtils.maxLengthSequence(password);
|
|
if (DevicePolicyManager.PASSWORD_QUALITY_NUMERIC_COMPLEX == mRequestedQuality
|
|
&& sequence > LockPatternUtils.MAX_ALLOWED_SEQUENCE) {
|
|
return getString(R.string.lockpassword_pin_no_sequential_digits);
|
|
}
|
|
} else if (DevicePolicyManager.PASSWORD_QUALITY_COMPLEX == mRequestedQuality) {
|
|
if (letters < mPasswordMinLetters) {
|
|
return String.format(getResources().getQuantityString(
|
|
R.plurals.lockpassword_password_requires_letters, mPasswordMinLetters),
|
|
mPasswordMinLetters);
|
|
} else if (numbers < mPasswordMinNumeric) {
|
|
return String.format(getResources().getQuantityString(
|
|
R.plurals.lockpassword_password_requires_numeric, mPasswordMinNumeric),
|
|
mPasswordMinNumeric);
|
|
} else if (lowercase < mPasswordMinLowerCase) {
|
|
return String.format(getResources().getQuantityString(
|
|
R.plurals.lockpassword_password_requires_lowercase, mPasswordMinLowerCase),
|
|
mPasswordMinLowerCase);
|
|
} else if (uppercase < mPasswordMinUpperCase) {
|
|
return String.format(getResources().getQuantityString(
|
|
R.plurals.lockpassword_password_requires_uppercase, mPasswordMinUpperCase),
|
|
mPasswordMinUpperCase);
|
|
} else if (symbols < mPasswordMinSymbols) {
|
|
return String.format(getResources().getQuantityString(
|
|
R.plurals.lockpassword_password_requires_symbols, mPasswordMinSymbols),
|
|
mPasswordMinSymbols);
|
|
} else if (nonletter < mPasswordMinNonLetter) {
|
|
return String.format(getResources().getQuantityString(
|
|
R.plurals.lockpassword_password_requires_nonletter, mPasswordMinNonLetter),
|
|
mPasswordMinNonLetter);
|
|
}
|
|
} else {
|
|
final boolean alphabetic = DevicePolicyManager.PASSWORD_QUALITY_ALPHABETIC
|
|
== mRequestedQuality;
|
|
final boolean alphanumeric = DevicePolicyManager.PASSWORD_QUALITY_ALPHANUMERIC
|
|
== mRequestedQuality;
|
|
if ((alphabetic || alphanumeric) && letters == 0) {
|
|
return getString(R.string.lockpassword_password_requires_alpha);
|
|
}
|
|
if (alphanumeric && numbers == 0) {
|
|
return getString(R.string.lockpassword_password_requires_digit);
|
|
}
|
|
}
|
|
if(mLockPatternUtils.checkPasswordHistory(password, UserHandle.myUserId())) {
|
|
return getString(mIsAlphaMode ? R.string.lockpassword_password_recently_used
|
|
: R.string.lockpassword_pin_recently_used);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private class SaveChosenPasswordAndFinish extends AsyncTask<Void, Void, Void> {
|
|
boolean mWasSecureBefore;
|
|
|
|
@Override
|
|
public void onPreExecute() {
|
|
mWasSecureBefore = mLockPatternUtils.isSecure(UserHandle.myUserId());
|
|
final boolean required = getActivity().getIntent().getBooleanExtra(
|
|
EncryptionInterstitial.EXTRA_REQUIRE_PASSWORD, true);
|
|
mLockPatternUtils.setCredentialRequiredToDecrypt(required);
|
|
}
|
|
|
|
@Override
|
|
public Void doInBackground(Void... v) {
|
|
mLockPatternUtils.saveLockPassword(mChosenPassword, mCurrentPassword, mRequestedQuality,
|
|
UserHandle.myUserId());
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
public void onPostExecute(Void v) {
|
|
if (mHasChallenge) {
|
|
startVerifyPassword(mChosenPassword, mWasSecureBefore);
|
|
return;
|
|
} else {
|
|
getActivity().setResult(RESULT_FINISHED);
|
|
}
|
|
finishConfirmStage(mWasSecureBefore);
|
|
}
|
|
}
|
|
|
|
|
|
public void handleNext() {
|
|
if (mDone) return;
|
|
mChosenPassword = mPasswordEntry.getText().toString();
|
|
if (TextUtils.isEmpty(mChosenPassword)) {
|
|
return;
|
|
}
|
|
String errorMsg = null;
|
|
if (mUiStage == Stage.Introduction) {
|
|
errorMsg = validatePassword(mChosenPassword);
|
|
if (errorMsg == null) {
|
|
mFirstPin = mChosenPassword;
|
|
mPasswordEntry.setText("");
|
|
updateStage(Stage.NeedToConfirm);
|
|
}
|
|
} else if (mUiStage == Stage.NeedToConfirm) {
|
|
if (mFirstPin.equals(mChosenPassword)) {
|
|
setNextEnabled(false);
|
|
mDone = true;
|
|
new SaveChosenPasswordAndFinish().execute();
|
|
} else {
|
|
CharSequence tmp = mPasswordEntry.getText();
|
|
if (tmp != null) {
|
|
Selection.setSelection((Spannable) tmp, 0, tmp.length());
|
|
}
|
|
updateStage(Stage.ConfirmWrong);
|
|
}
|
|
}
|
|
if (errorMsg != null) {
|
|
showError(errorMsg, mUiStage);
|
|
}
|
|
}
|
|
|
|
private void startVerifyPassword(final String pin, final boolean wasSecureBefore) {
|
|
mPasswordEntryInputDisabler.setInputEnabled(false);
|
|
setNextEnabled(false);
|
|
if (mPendingLockCheck != null) {
|
|
mPendingLockCheck.cancel(false);
|
|
}
|
|
|
|
mPendingLockCheck = LockPatternChecker.verifyPassword(
|
|
mLockPatternUtils,
|
|
pin,
|
|
mChallenge,
|
|
UserHandle.myUserId(),
|
|
new LockPatternChecker.OnVerifyCallback() {
|
|
@Override
|
|
public void onVerified(byte[] token, int timeoutMs) {
|
|
if (token == null) {
|
|
Log.e(TAG, "critical: no token returned from known good password");
|
|
}
|
|
|
|
mPasswordEntryInputDisabler.setInputEnabled(true);
|
|
setNextEnabled(true);
|
|
mPendingLockCheck = null;
|
|
|
|
Intent intent = new Intent();
|
|
intent.putExtra(
|
|
ChooseLockSettingsHelper.EXTRA_KEY_CHALLENGE_TOKEN,
|
|
token);
|
|
getActivity().setResult(RESULT_FINISHED, intent);
|
|
finishConfirmStage(wasSecureBefore);
|
|
}
|
|
});
|
|
}
|
|
|
|
private void finishConfirmStage(boolean wasSecureBefore) {
|
|
getActivity().finish();
|
|
if (!wasSecureBefore) {
|
|
Intent intent = getRedactionInterstitialIntent(getActivity());
|
|
if (intent != null) {
|
|
startActivity(intent);
|
|
}
|
|
}
|
|
}
|
|
|
|
protected void setNextEnabled(boolean enabled) {
|
|
mNextButton.setEnabled(enabled);
|
|
}
|
|
|
|
protected void setNextText(int text) {
|
|
mNextButton.setText(text);
|
|
}
|
|
|
|
public void onClick(View v) {
|
|
switch (v.getId()) {
|
|
case R.id.next_button:
|
|
handleNext();
|
|
break;
|
|
|
|
case R.id.cancel_button:
|
|
getActivity().finish();
|
|
break;
|
|
}
|
|
}
|
|
|
|
private void showError(String msg, final Stage next) {
|
|
mHeaderText.setText(msg);
|
|
mHeaderText.announceForAccessibility(mHeaderText.getText());
|
|
Message mesg = mHandler.obtainMessage(MSG_SHOW_ERROR, next);
|
|
mHandler.removeMessages(MSG_SHOW_ERROR);
|
|
mHandler.sendMessageDelayed(mesg, ERROR_MESSAGE_TIMEOUT);
|
|
}
|
|
|
|
public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
|
|
// Check if this was the result of hitting the enter or "done" key
|
|
if (actionId == EditorInfo.IME_NULL
|
|
|| actionId == EditorInfo.IME_ACTION_DONE
|
|
|| actionId == EditorInfo.IME_ACTION_NEXT) {
|
|
handleNext();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Update the hint based on current Stage and length of password entry
|
|
*/
|
|
private void updateUi() {
|
|
String password = mPasswordEntry.getText().toString();
|
|
final int length = password.length();
|
|
if (mUiStage == Stage.Introduction) {
|
|
if (length < mPasswordMinLength) {
|
|
String msg = getString(mIsAlphaMode ? R.string.lockpassword_password_too_short
|
|
: R.string.lockpassword_pin_too_short, mPasswordMinLength);
|
|
mHeaderText.setText(msg);
|
|
setNextEnabled(false);
|
|
} else {
|
|
String error = validatePassword(password);
|
|
if (error != null) {
|
|
mHeaderText.setText(error);
|
|
setNextEnabled(false);
|
|
} else {
|
|
mHeaderText.setText(R.string.lockpassword_press_continue);
|
|
setNextEnabled(true);
|
|
}
|
|
}
|
|
} else {
|
|
mHeaderText.setText(mIsAlphaMode ? mUiStage.alphaHint : mUiStage.numericHint);
|
|
setNextEnabled(length > 0);
|
|
}
|
|
setNextText(mUiStage.buttonText);
|
|
}
|
|
|
|
public void afterTextChanged(Editable s) {
|
|
// Changing the text while error displayed resets to NeedToConfirm state
|
|
if (mUiStage == Stage.ConfirmWrong) {
|
|
mUiStage = Stage.NeedToConfirm;
|
|
}
|
|
updateUi();
|
|
}
|
|
|
|
public void beforeTextChanged(CharSequence s, int start, int count, int after) {
|
|
|
|
}
|
|
|
|
public void onTextChanged(CharSequence s, int start, int before, int count) {
|
|
|
|
}
|
|
}
|
|
}
|