From 2d6aa76f7c765ac129d5ac163460eb8e62080afa Mon Sep 17 00:00:00 2001
From: Daniel Micay <danielmicay@gmail.com>
Date: Mon, 15 Jun 2015 10:06:33 -0400
Subject: [PATCH] support setting a separate encryption password

---
 AndroidManifest.xml                                |   3 +
 res/values/strings.xml                             |   9 +
 res/xml/security_settings_encrypted.xml            |  10 +
 .../android/settings/ChooseEncryptionPassword.java | 682 +++++++++++++++++++++
 4 files changed, 704 insertions(+)
 create mode 100644 src/com/android/settings/ChooseEncryptionPassword.java

diff --git a/AndroidManifest.xml b/AndroidManifest.xml
index 63648fc..a561d7e 100755
--- a/AndroidManifest.xml
+++ b/AndroidManifest.xml
@@ -1524,6 +1524,9 @@
         <activity android:name="ChooseLockPassword" android:exported="false"
             android:windowSoftInputMode="stateVisible|adjustResize"/>
 
+        <activity android:name="ChooseEncryptionPassword" android:exported="false"
+            android:windowSoftInputMode="stateVisible|adjustResize"/>
+
         <activity android:name=".SetupEncryptionInterstitial"
             android:taskAffinity="com.android.wizard"
             android:theme="@style/SetupWizardDisableAppStartingTheme"/>
diff --git a/res/values/strings.xml b/res/values/strings.xml
index 3072f33..d5324f1 100755
--- a/res/values/strings.xml
+++ b/res/values/strings.xml
@@ -937,6 +937,15 @@
     <!-- Image button description to switch input method -->
     <string name="crypt_keeper_switch_input_method">Switch input method</string>
 
+    <!--  Title for PreferenceScreen to change encryption password [CHAR LIMIT=22]  -->
+    <string name="crypt_keeper_change_password_title">Change encryption password</string>
+
+    <!--  Summary for PreferenceScreen to change encryption password [CHAR LIMIT=45]  -->
+    <string name="crypt_keeper_change_password_summary">Change the password used for device encryption</string>
+
+    <!-- Header on first screen of choose encryption password [CHAR LIMIT=30] -->
+    <string name="crypt_keeper_choose_your_password_header">Set encryption password</string>
+
     <!-- Unlock Picker Settings --><skip />
 
     <!-- Security Picker --><skip />
diff --git a/res/xml/security_settings_encrypted.xml b/res/xml/security_settings_encrypted.xml
index 2399243..f05bad5 100644
--- a/res/xml/security_settings_encrypted.xml
+++ b/res/xml/security_settings_encrypted.xml
@@ -27,6 +27,16 @@
             android:title="@string/crypt_keeper_encrypt_title"
             android:summary="@string/crypt_keeper_encrypted_summary"/>
 
+        <Preference
+            android:key="crypt_keeper_change_password"
+            android:title="@string/crypt_keeper_change_password_title"
+            android:summary="@string/crypt_keeper_change_password_summary">
+
+                <intent android:action="android.intent.action.MAIN"
+                    android:targetPackage="com.android.settings"
+                    android:targetClass="com.android.settings.ChooseEncryptionPassword" />
+        </Preference>
+
     </PreferenceCategory>
 
 
diff --git a/src/com/android/settings/ChooseEncryptionPassword.java b/src/com/android/settings/ChooseEncryptionPassword.java
new file mode 100644
index 0000000..43e2b0e
--- /dev/null
+++ b/src/com/android/settings/ChooseEncryptionPassword.java
@@ -0,0 +1,682 @@
+/*
+ * 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;
+
+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 ChooseEncryptionPassword 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 = "ChooseEncryptionPassword";
+
+    @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, ChooseEncryptionPassword.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 (ChooseEncryptionPasswordFragment.class.getName().equals(fragmentName)) return true;
+        return false;
+    }
+
+    /* package */ Class<? extends Fragment> getFragmentClass() {
+        return ChooseEncryptionPasswordFragment.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 ChooseEncryptionPasswordFragment 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_ALPHABETIC;
+        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 ChooseEncryptionPasswordFragment() {
+
+        }
+
+        @Override
+        public void onCreate(Bundle savedInstanceState) {
+            super.onCreate(savedInstanceState);
+            mLockPatternUtils = new LockPatternUtils(getActivity());
+            Intent intent = getActivity().getIntent();
+            if (!(getActivity() instanceof ChooseEncryptionPassword)) {
+                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.setCredentialRequiredToDecrypt(true);
+            mUtils.setSeparateEncryptionPassword(mChosenPassword);
+
+            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;
+        }
+    }
+}
