ChooseLockPassword.java revision 9757e30dfa0ab691c4c15366568367e166071a7d 
1/*
2 * Copyright (C) 2010 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package com.android.settings;
18
19import com.android.internal.widget.LockPatternUtils;
20import com.android.internal.widget.PasswordEntryKeyboardHelper;
21import com.android.internal.widget.PasswordEntryKeyboardView;
22
23import android.app.Activity;
24import android.app.Fragment;
25import android.app.admin.DevicePolicyManager;
26import android.content.Intent;
27import android.inputmethodservice.KeyboardView;
28import android.os.Bundle;
29import android.os.Handler;
30import android.preference.PreferenceActivity;
31import android.text.Editable;
32import android.text.InputType;
33import android.text.Selection;
34import android.text.Spannable;
35import android.text.TextUtils;
36import android.text.TextWatcher;
37import android.view.KeyEvent;
38import android.view.LayoutInflater;
39import android.view.View;
40import android.view.ViewGroup;
41import android.view.View.OnClickListener;
42import android.view.inputmethod.EditorInfo;
43import android.widget.Button;
44import android.widget.TextView;
45import android.widget.TextView.OnEditorActionListener;
46
47
48public class ChooseLockPassword extends PreferenceActivity {
49    public static final String PASSWORD_MIN_KEY = "lockscreen.password_min";
50    public static final String PASSWORD_MAX_KEY = "lockscreen.password_max";
51    public static final String PASSWORD_MIN_LETTERS_KEY = "lockscreen.password_min_letters";
52    public static final String PASSWORD_MIN_LOWERCASE_KEY = "lockscreen.password_min_lowercase";
53    public static final String PASSWORD_MIN_UPPERCASE_KEY = "lockscreen.password_min_uppercase";
54    public static final String PASSWORD_MIN_NUMERIC_KEY = "lockscreen.password_min_numeric";
55    public static final String PASSWORD_MIN_SYMBOLS_KEY = "lockscreen.password_min_symbols";
56    public static final String PASSWORD_MIN_NONLETTER_KEY = "lockscreen.password_min_nonletter";
57
58    @Override
59    public Intent getIntent() {
60        Intent modIntent = new Intent(super.getIntent());
61        modIntent.putExtra(EXTRA_SHOW_FRAGMENT, ChooseLockPasswordFragment.class.getName());
62        modIntent.putExtra(EXTRA_NO_HEADERS, true);
63        return modIntent;
64    }
65
66    @Override
67    public void onCreate(Bundle savedInstanceState) {
68        // TODO: Fix on phones
69        // Disable IME on our window since we provide our own keyboard
70        //getWindow().setFlags(WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM,
71                //WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM);
72        super.onCreate(savedInstanceState);
73    }
74
75    public static class ChooseLockPasswordFragment extends Fragment
76            implements OnClickListener, OnEditorActionListener,  TextWatcher {
77        private static final String KEY_FIRST_PIN = "first_pin";
78        private static final String KEY_UI_STAGE = "ui_stage";
79        private TextView mPasswordEntry;
80        private int mPasswordMinLength = 4;
81        private int mPasswordMaxLength = 16;
82        private int mPasswordMinLetters = 0;
83        private int mPasswordMinUpperCase = 0;
84        private int mPasswordMinLowerCase = 0;
85        private int mPasswordMinSymbols = 0;
86        private int mPasswordMinNumeric = 0;
87        private int mPasswordMinNonLetter = 0;
88        private LockPatternUtils mLockPatternUtils;
89        private int mRequestedQuality = DevicePolicyManager.PASSWORD_QUALITY_NUMERIC;
90        private ChooseLockSettingsHelper mChooseLockSettingsHelper;
91        private Stage mUiStage = Stage.Introduction;
92        private TextView mHeaderText;
93        private String mFirstPin;
94        private KeyboardView mKeyboardView;
95        private PasswordEntryKeyboardHelper mKeyboardHelper;
96        private boolean mIsAlphaMode;
97        private Button mCancelButton;
98        private Button mNextButton;
99        private static Handler mHandler = new Handler();
100        private static final int CONFIRM_EXISTING_REQUEST = 58;
101        static final int RESULT_FINISHED = RESULT_FIRST_USER;
102        private static final long ERROR_MESSAGE_TIMEOUT = 3000;
103
104        /**
105         * Keep track internally of where the user is in choosing a pattern.
106         */
107        protected enum Stage {
108
109            Introduction(R.string.lockpassword_choose_your_password_header,
110                    R.string.lockpassword_choose_your_pin_header,
111                    R.string.lockpassword_continue_label),
112
113            NeedToConfirm(R.string.lockpassword_confirm_your_password_header,
114                    R.string.lockpassword_confirm_your_pin_header,
115                    R.string.lockpassword_ok_label),
116
117            ConfirmWrong(R.string.lockpassword_confirm_passwords_dont_match,
118                    R.string.lockpassword_confirm_pins_dont_match,
119                    R.string.lockpassword_continue_label);
120
121            /**
122             * @param headerMessage The message displayed at the top.
123             */
124            Stage(int hintInAlpha, int hintInNumeric, int nextButtonText) {
125                this.alphaHint = hintInAlpha;
126                this.numericHint = hintInNumeric;
127                this.buttonText = nextButtonText;
128            }
129
130            public final int alphaHint;
131            public final int numericHint;
132            public final int buttonText;
133        }
134
135        // required constructor for fragments
136        public ChooseLockPasswordFragment() {
137
138        }
139
140        @Override
141        public void onCreate(Bundle savedInstanceState) {
142            super.onCreate(savedInstanceState);
143            mLockPatternUtils = new LockPatternUtils(getActivity());
144            Intent intent = getActivity().getIntent();
145            mRequestedQuality = Math.max(intent.getIntExtra(LockPatternUtils.PASSWORD_TYPE_KEY,
146                    mRequestedQuality), mLockPatternUtils.getRequestedPasswordQuality());
147            mPasswordMinLength = Math.max(
148                    intent.getIntExtra(PASSWORD_MIN_KEY, mPasswordMinLength), mLockPatternUtils
149                            .getRequestedMinimumPasswordLength());
150            mPasswordMaxLength = intent.getIntExtra(PASSWORD_MAX_KEY, mPasswordMaxLength);
151            mPasswordMinLetters = Math.max(intent.getIntExtra(PASSWORD_MIN_LETTERS_KEY,
152                    mPasswordMinLetters), mLockPatternUtils.getRequestedPasswordMinimumLetters());
153            mPasswordMinUpperCase = Math.max(intent.getIntExtra(PASSWORD_MIN_UPPERCASE_KEY,
154                    mPasswordMinUpperCase), mLockPatternUtils.getRequestedPasswordMinimumUpperCase());
155            mPasswordMinLowerCase = Math.max(intent.getIntExtra(PASSWORD_MIN_LOWERCASE_KEY,
156                    mPasswordMinLowerCase), mLockPatternUtils.getRequestedPasswordMinimumLowerCase());
157            mPasswordMinNumeric = Math.max(intent.getIntExtra(PASSWORD_MIN_NUMERIC_KEY,
158                    mPasswordMinNumeric), mLockPatternUtils.getRequestedPasswordMinimumNumeric());
159            mPasswordMinSymbols = Math.max(intent.getIntExtra(PASSWORD_MIN_SYMBOLS_KEY,
160                    mPasswordMinSymbols), mLockPatternUtils.getRequestedPasswordMinimumSymbols());
161            mPasswordMinNonLetter = Math.max(intent.getIntExtra(PASSWORD_MIN_NONLETTER_KEY,
162                    mPasswordMinNonLetter), mLockPatternUtils.getRequestedPasswordMinimumNonLetter());
163
164            mChooseLockSettingsHelper = new ChooseLockSettingsHelper(getActivity());
165        }
166
167        @Override
168        public View onCreateView(LayoutInflater inflater, ViewGroup container,
169                Bundle savedInstanceState) {
170
171            View view = inflater.inflate(R.layout.choose_lock_password, null);
172
173            mCancelButton = (Button) view.findViewById(R.id.cancel_button);
174            mCancelButton.setOnClickListener(this);
175            mNextButton = (Button) view.findViewById(R.id.next_button);
176            mNextButton.setOnClickListener(this);
177
178            mIsAlphaMode = DevicePolicyManager.PASSWORD_QUALITY_ALPHABETIC == mRequestedQuality
179                    || DevicePolicyManager.PASSWORD_QUALITY_ALPHANUMERIC == mRequestedQuality
180                    || DevicePolicyManager.PASSWORD_QUALITY_COMPLEX == mRequestedQuality;
181            mKeyboardView = (PasswordEntryKeyboardView) view.findViewById(R.id.keyboard);
182            mPasswordEntry = (TextView) view.findViewById(R.id.password_entry);
183            mPasswordEntry.setOnEditorActionListener(this);
184            mPasswordEntry.addTextChangedListener(this);
185
186            final Activity activity = getActivity();
187            mKeyboardHelper = new PasswordEntryKeyboardHelper(activity,
188                    mKeyboardView, mPasswordEntry);
189            mKeyboardHelper.setKeyboardMode(mIsAlphaMode ?
190                    PasswordEntryKeyboardHelper.KEYBOARD_MODE_ALPHA
191                    : PasswordEntryKeyboardHelper.KEYBOARD_MODE_NUMERIC);
192
193            mHeaderText = (TextView) view.findViewById(R.id.headerText);
194            mKeyboardView.requestFocus();
195
196            int currentType = mPasswordEntry.getInputType();
197            mPasswordEntry.setInputType(mIsAlphaMode ? currentType
198                    : (currentType | InputType.TYPE_CLASS_NUMBER));
199
200            Intent intent = getActivity().getIntent();
201            final boolean confirmCredentials = intent.getBooleanExtra("confirm_credentials", true);
202            if (savedInstanceState == null) {
203                updateStage(Stage.Introduction);
204                if (confirmCredentials) {
205                    mChooseLockSettingsHelper.launchConfirmationActivity(CONFIRM_EXISTING_REQUEST,
206                            null, null);
207                }
208            } else {
209                mFirstPin = savedInstanceState.getString(KEY_FIRST_PIN);
210                final String state = savedInstanceState.getString(KEY_UI_STAGE);
211                if (state != null) {
212                    mUiStage = Stage.valueOf(state);
213                    updateStage(mUiStage);
214                }
215            }
216            // Update the breadcrumb (title) if this is embedded in a PreferenceActivity
217            if (activity instanceof PreferenceActivity) {
218                final PreferenceActivity preferenceActivity = (PreferenceActivity) activity;
219                int id = mIsAlphaMode ? R.string.lockpassword_confirm_your_password_header
220                        : R.string.lockpassword_confirm_your_pin_header;
221                CharSequence title = getText(id);
222                preferenceActivity.showBreadCrumbs(title, title);
223            }
224
225            return view;
226        }
227
228        @Override
229        public void onResume() {
230            super.onResume();
231            updateStage(mUiStage);
232            mKeyboardView.requestFocus();
233        }
234
235        @Override
236        public void onSaveInstanceState(Bundle outState) {
237            super.onSaveInstanceState(outState);
238            outState.putString(KEY_UI_STAGE, mUiStage.name());
239            outState.putString(KEY_FIRST_PIN, mFirstPin);
240        }
241
242        @Override
243        public void onActivityResult(int requestCode, int resultCode,
244                Intent data) {
245            super.onActivityResult(requestCode, resultCode, data);
246            switch (requestCode) {
247                case CONFIRM_EXISTING_REQUEST:
248                    if (resultCode != Activity.RESULT_OK) {
249                        getActivity().setResult(RESULT_FINISHED);
250                        getActivity().finish();
251                    }
252                    break;
253            }
254        }
255
256        protected void updateStage(Stage stage) {
257            mUiStage = stage;
258            updateUi();
259        }
260
261        /**
262         * Validates PIN and returns a message to display if PIN fails test.
263         * @param password the raw password the user typed in
264         * @return error message to show to user or null if password is OK
265         */
266        private String validatePassword(String password) {
267            if (password.length() < mPasswordMinLength) {
268                return getString(mIsAlphaMode ?
269                        R.string.lockpassword_password_too_short
270                        : R.string.lockpassword_pin_too_short, mPasswordMinLength);
271            }
272            if (password.length() > mPasswordMaxLength) {
273                return getString(mIsAlphaMode ?
274                        R.string.lockpassword_password_too_long
275                        : R.string.lockpassword_pin_too_long, mPasswordMaxLength);
276            }
277            int letters = 0;
278            int numbers = 0;
279            int lowercase = 0;
280            int symbols = 0;
281            int uppercase = 0;
282            int nonletter = 0;
283            for (int i = 0; i < password.length(); i++) {
284                char c = password.charAt(i);
285                // allow non white space Latin-1 characters only
286                if (c <= 32 || c > 127) {
287                    return getString(R.string.lockpassword_illegal_character);
288                }
289                if (c >= '0' && c <= '9') {
290                    numbers++;
291                    nonletter++;
292                } else if (c >= 'A' && c <= 'Z') {
293                    letters++;
294                    uppercase++;
295                } else if (c >= 'a' && c <= 'z') {
296                    letters++;
297                    lowercase++;
298                } else {
299                    symbols++;
300                    nonletter++;
301                }
302            }
303            if (DevicePolicyManager.PASSWORD_QUALITY_NUMERIC == mRequestedQuality
304                    && (letters > 0 || symbols > 0)) {
305                // This shouldn't be possible unless user finds some way to bring up
306                // soft keyboard
307                return getString(R.string.lockpassword_pin_contains_non_digits);
308            } else if (DevicePolicyManager.PASSWORD_QUALITY_COMPLEX == mRequestedQuality) {
309                if (letters < mPasswordMinLetters) {
310                    return String.format(getResources().getQuantityString(
311                            R.plurals.lockpassword_password_requires_letters, mPasswordMinLetters),
312                            mPasswordMinLetters);
313                } else if (numbers < mPasswordMinNumeric) {
314                    return String.format(getResources().getQuantityString(
315                            R.plurals.lockpassword_password_requires_numeric, mPasswordMinNumeric),
316                            mPasswordMinNumeric);
317                } else if (lowercase < mPasswordMinLowerCase) {
318                    return String.format(getResources().getQuantityString(
319                            R.plurals.lockpassword_password_requires_lowercase, mPasswordMinLowerCase),
320                            mPasswordMinLowerCase);
321                } else if (uppercase < mPasswordMinUpperCase) {
322                    return String.format(getResources().getQuantityString(
323                            R.plurals.lockpassword_password_requires_uppercase, mPasswordMinUpperCase),
324                            mPasswordMinUpperCase);
325                } else if (symbols < mPasswordMinSymbols) {
326                    return String.format(getResources().getQuantityString(
327                            R.plurals.lockpassword_password_requires_symbols, mPasswordMinSymbols),
328                            mPasswordMinSymbols);
329                } else if (nonletter < mPasswordMinNonLetter) {
330                    return String.format(getResources().getQuantityString(
331                            R.plurals.lockpassword_password_requires_nonletter, mPasswordMinNonLetter),
332                            mPasswordMinNonLetter);
333                }
334            } else {
335                final boolean alphabetic = DevicePolicyManager.PASSWORD_QUALITY_ALPHABETIC
336                        == mRequestedQuality;
337                final boolean alphanumeric = DevicePolicyManager.PASSWORD_QUALITY_ALPHANUMERIC
338                        == mRequestedQuality;
339                if ((alphabetic || alphanumeric) && letters == 0) {
340                    return getString(R.string.lockpassword_password_requires_alpha);
341                }
342                if (alphanumeric && numbers == 0) {
343                    return getString(R.string.lockpassword_password_requires_digit);
344                }
345            }
346            if(mLockPatternUtils.checkPasswordHistory(password)) {
347                return getString(mIsAlphaMode ? R.string.lockpassword_password_recently_used
348                        : R.string.lockpassword_pin_recently_used);
349            }
350            return null;
351        }
352
353        private void handleNext() {
354            final String pin = mPasswordEntry.getText().toString();
355            if (TextUtils.isEmpty(pin)) {
356                return;
357            }
358            String errorMsg = null;
359            if (mUiStage == Stage.Introduction) {
360                errorMsg = validatePassword(pin);
361                if (errorMsg == null) {
362                    mFirstPin = pin;
363                    updateStage(Stage.NeedToConfirm);
364                    mPasswordEntry.setText("");
365                }
366            } else if (mUiStage == Stage.NeedToConfirm) {
367                if (mFirstPin.equals(pin)) {
368                    mLockPatternUtils.clearLock();
369                    mLockPatternUtils.saveLockPassword(pin, mRequestedQuality);
370                    getActivity().finish();
371                } else {
372                    updateStage(Stage.ConfirmWrong);
373                    CharSequence tmp = mPasswordEntry.getText();
374                    if (tmp != null) {
375                        Selection.setSelection((Spannable) tmp, 0, tmp.length());
376                    }
377                }
378            }
379            if (errorMsg != null) {
380                showError(errorMsg, mUiStage);
381            }
382        }
383
384        public void onClick(View v) {
385            switch (v.getId()) {
386                case R.id.next_button:
387                    handleNext();
388                    break;
389
390                case R.id.cancel_button:
391                    getActivity().finish();
392                    break;
393            }
394        }
395
396        private void showError(String msg, final Stage next) {
397            mHeaderText.setText(msg);
398            mHandler.postDelayed(new Runnable() {
399                public void run() {
400                    updateStage(next);
401                }
402            }, ERROR_MESSAGE_TIMEOUT);
403        }
404
405        public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
406            // Check if this was the result of hitting the enter key
407            if (actionId == EditorInfo.IME_NULL && event.getAction() == KeyEvent.ACTION_DOWN) {
408                handleNext();
409                return true;
410            }
411            return false;
412        }
413
414        /**
415         * Update the hint based on current Stage and length of password entry
416         */
417        private void updateUi() {
418            String password = mPasswordEntry.getText().toString();
419            final int length = password.length();
420            if (mUiStage == Stage.Introduction && length > 0) {
421                if (length < mPasswordMinLength) {
422                    String msg = getString(mIsAlphaMode ? R.string.lockpassword_password_too_short
423                            : R.string.lockpassword_pin_too_short, mPasswordMinLength);
424                    mHeaderText.setText(msg);
425                    mNextButton.setEnabled(false);
426                } else {
427                    String error = validatePassword(password);
428                    if (error != null) {
429                        mHeaderText.setText(error);
430                        mNextButton.setEnabled(false);
431                    } else {
432                        mHeaderText.setText(R.string.lockpassword_press_continue);
433                        mNextButton.setEnabled(true);
434                    }
435                }
436            } else {
437                mHeaderText.setText(mIsAlphaMode ? mUiStage.alphaHint : mUiStage.numericHint);
438                mNextButton.setEnabled(length > 0);
439            }
440            mNextButton.setText(mUiStage.buttonText);
441        }
442
443        public void afterTextChanged(Editable s) {
444            // Changing the text while error displayed resets to NeedToConfirm state
445            if (mUiStage == Stage.ConfirmWrong) {
446                mUiStage = Stage.NeedToConfirm;
447            }
448            updateUi();
449        }
450
451        public void beforeTextChanged(CharSequence s, int start, int count, int after) {
452
453        }
454
455        public void onTextChanged(CharSequence s, int start, int before, int count) {
456
457        }
458    }
459}
460