/* * 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.LockPatternUtils; import com.android.internal.widget.PasswordEntryKeyboardHelper; import com.android.internal.widget.PasswordEntryKeyboardView; import com.android.internal.widget.TextViewInputDisabler; import com.android.internal.widget.LockPatternUtils.RequestThrottledException; 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.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 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, SaveAndFinishWorker.Listener { 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 static final String FRAGMENT_TAG_SAVE_AND_FINISH = "save_and_finish_worker"; 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 SaveAndFinishWorker mSaveAndFinishWorker; private int mRequestedQuality = DevicePolicyManager.PASSWORD_QUALITY_NUMERIC; private ChooseLockSettingsHelper mChooseLockSettingsHelper; private Stage mUiStage = Stage.Introduction; 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); } // Re-attach to the exiting worker if there is one. mSaveAndFinishWorker = (SaveAndFinishWorker) getFragmentManager().findFragmentByTag( FRAGMENT_TAG_SAVE_AND_FINISH); } 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); if (mSaveAndFinishWorker != null) { mSaveAndFinishWorker.setListener(this); } else { mKeyboardView.requestFocus(); } } @Override public void onPause() { mHandler.removeMessages(MSG_SHOW_ERROR); if (mSaveAndFinishWorker != null) { mSaveAndFinishWorker.setListener(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; } public void handleNext() { if (mSaveAndFinishWorker != null) 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)) { startSaveAndFinish(); } else { CharSequence tmp = mPasswordEntry.getText(); if (tmp != null) { Selection.setSelection((Spannable) tmp, 0, tmp.length()); } updateStage(Stage.ConfirmWrong); } } if (errorMsg != null) { showError(errorMsg, mUiStage); } } 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() { final boolean canInput = mSaveAndFinishWorker == null; 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(canInput && length > 0); } setNextText(mUiStage.buttonText); mPasswordEntryInputDisabler.setInputEnabled(canInput); } 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) { } private void startSaveAndFinish() { if (mSaveAndFinishWorker != null) { Log.w(TAG, "startSaveAndFinish with an existing SaveAndFinishWorker."); return; } mPasswordEntryInputDisabler.setInputEnabled(false); setNextEnabled(false); mSaveAndFinishWorker = new SaveAndFinishWorker(); getFragmentManager().beginTransaction().add(mSaveAndFinishWorker, FRAGMENT_TAG_SAVE_AND_FINISH).commit(); mSaveAndFinishWorker.setListener(this); final boolean required = getActivity().getIntent().getBooleanExtra( EncryptionInterstitial.EXTRA_REQUIRE_PASSWORD, true); mSaveAndFinishWorker.start(mLockPatternUtils, required, mHasChallenge, mChallenge, mChosenPassword, mCurrentPassword, mRequestedQuality); } @Override public void onChosenLockSaveFinished(boolean wasSecureBefore, Intent resultData) { getActivity().setResult(RESULT_FINISHED, resultData); getActivity().finish(); if (!wasSecureBefore) { Intent intent = getRedactionInterstitialIntent(getActivity()); if (intent != null) { startActivity(intent); } } } } private static class SaveAndFinishWorker extends SaveChosenLockWorkerBase { private String mChosenPassword; private String mCurrentPassword; private int mRequestedQuality; public void start(LockPatternUtils utils, boolean required, boolean hasChallenge, long challenge, String chosenPassword, String currentPassword, int requestedQuality) { prepare(utils, required, hasChallenge, challenge); mChosenPassword = chosenPassword; mCurrentPassword = currentPassword; mRequestedQuality = requestedQuality; start(); } @Override protected Intent saveAndVerifyInBackground() { Intent result = null; final int userId = UserHandle.myUserId(); mUtils.saveLockPassword(mChosenPassword, mCurrentPassword, mRequestedQuality, userId); if (mHasChallenge) { byte[] token; try { token = mUtils.verifyPassword(mChosenPassword, mChallenge, userId); } catch (RequestThrottledException e) { token = null; } if (token == null) { Log.e(TAG, "critical: no token returned for known good password."); } result = new Intent(); result.putExtra(ChooseLockSettingsHelper.EXTRA_KEY_CHALLENGE_TOKEN, token); } return result; } } }