Separate Change Encryption Password Entry (1 of 2) (681fb8e8) · Commits · e / os / android_packages_apps_Settings

AndroidManifest.xml

+4 −0

Original line number	Diff line number	Diff line
		@@ -1206,11 +1206,15 @@
		<activity android:name="ChooseLockPassword" android:exported="false"
		android:windowSoftInputMode="stateVisible\|adjustResize"/>

		<activity android:name="ChooseEncryptionPassword" android:exported="false"
		android:windowSoftInputMode="stateVisible\|adjustResize"/>

		<!-- Runs in the phone process since it needs access to the Phone object -->
		<activity android:name=".deviceinfo.msim.MSimSubscriptionStatus"
		android:label="@string/device_status_activity_title"
		android:theme="@android:style/Theme.Holo.DialogWhenLarge"
		android:process="com.android.phone">

		<intent-filter>
		<action android:name="android.intent.action.MAIN" />
		<category android:name="android.intent.category.DEFAULT" />

res/values/cm_strings.xml

+9 −0

Original line number	Diff line number	Diff line
		@@ -26,6 +26,15 @@
		<!-- Wi-Fi settings screen, setting summary for setting the Wi-Fi priority-->
		<string name="wifi_setting_priority_summary">Specify the priority of the Wi-Fi networks</string>

		<!-- Title for PreferenceScreen to change encryption password [CHAR LIMIT=22] -->
		<string name="change_crypt_password_title">Change password</string>

		<!-- Summary for PreferenceScreen to change encryption password [CHAR LIMIT=45] -->
		<string name="change_crypt_password_summary">Change the password used for device encryption</string>

		<!-- Header on first screen of choose encryption password [CHAR LIMIT=30] -->
		<string name="encryptionpassword_choose_your_password_header">Set encryption password</string>

		<string name="lock_screen_title">Lock screen</string>

		<string name="increasing_ring_title">Ascending ringtone</string>

res/xml/security_settings_encrypted.xml

+9 −0

Original line number	Diff line number	Diff line
		@@ -26,6 +26,15 @@
		android:summary="@string/crypt_keeper_encrypted_summary"
		/>

		<Preference
		android:key="change_crypt_password"
		android:title="@string/change_crypt_password_title"
		android:summary="@string/change_crypt_password_summary">

		<intent android:action="android.intent.action.MAIN"
		android:targetPackage="com.android.settings"
		android:targetClass="com.android.settings.ChooseEncryptionPassword" />
		</Preference>
		</PreferenceCategory>

src/com/android/settings/ChooseEncryptionPassword.java

0 → 100644

+483 −0

Original line number	Diff line number	Diff line
		/*
		* 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.widget.LockPatternUtils;
		import com.android.internal.widget.PasswordEntryKeyboardHelper;
		import com.android.internal.widget.PasswordEntryKeyboardView;

		import android.app.Activity;
		import android.app.Fragment;
		import android.app.admin.DevicePolicyManager;
		import android.content.Intent;
		import android.inputmethodservice.KeyboardView;
		import android.os.Bundle;
		import android.os.Handler;
		import android.os.Message;
		import android.preference.PreferenceActivity;
		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.view.KeyEvent;
		import android.view.LayoutInflater;
		import android.view.View;
		import android.view.ViewGroup;
		import android.view.View.OnClickListener;
		import android.view.accessibility.AccessibilityEvent;
		import android.view.inputmethod.EditorInfo;
		import android.widget.Button;
		import android.widget.TextView;
		import android.widget.TextView.OnEditorActionListener;

		public class ChooseEncryptionPassword extends PreferenceActivity {
		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";

		@Override
		public Intent getIntent() {
		Intent modIntent = new Intent(super.getIntent());
		modIntent.putExtra(EXTRA_SHOW_FRAGMENT, ChooseEncryptionPasswordFragment.class.getName());
		modIntent.putExtra(EXTRA_NO_HEADERS, true);
		return modIntent;
		}

		@Override
		protected boolean isValidFragment(String fragmentName) {
		if (ChooseEncryptionPasswordFragment.class.getName().equals(fragmentName)) return true;
		return false;
		}

		@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);
		showBreadCrumbs(msg, msg);
		}

		public static class ChooseEncryptionPasswordFragment extends Fragment
		implements OnClickListener, OnEditorActionListener, TextWatcher {
		private static final String KEY_FIRST_PIN = "first_pin";
		private static final String KEY_UI_STAGE = "ui_stage";
		private TextView mPasswordEntry;
		private int mPasswordMinLength = 4;
		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 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.encryptionpassword_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);

		/**
		* @param headerMessage The message displayed at the top.
		*/
		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());
		mPasswordMinLength = Math.max(
		intent.getIntExtra(PASSWORD_MIN_KEY, mPasswordMinLength), mLockPatternUtils
		.getRequestedMinimumPasswordLength());
		mPasswordMaxLength = intent.getIntExtra(PASSWORD_MAX_KEY, mPasswordMaxLength);
		mPasswordMinLetters = Math.max(intent.getIntExtra(PASSWORD_MIN_LETTERS_KEY,
		mPasswordMinLetters), mLockPatternUtils.getRequestedPasswordMinimumLetters());
		mPasswordMinUpperCase = Math.max(intent.getIntExtra(PASSWORD_MIN_UPPERCASE_KEY,
		mPasswordMinUpperCase), mLockPatternUtils.getRequestedPasswordMinimumUpperCase());
		mPasswordMinLowerCase = Math.max(intent.getIntExtra(PASSWORD_MIN_LOWERCASE_KEY,
		mPasswordMinLowerCase), mLockPatternUtils.getRequestedPasswordMinimumLowerCase());
		mPasswordMinNumeric = Math.max(intent.getIntExtra(PASSWORD_MIN_NUMERIC_KEY,
		mPasswordMinNumeric), mLockPatternUtils.getRequestedPasswordMinimumNumeric());
		mPasswordMinSymbols = Math.max(intent.getIntExtra(PASSWORD_MIN_SYMBOLS_KEY,
		mPasswordMinSymbols), mLockPatternUtils.getRequestedPasswordMinimumSymbols());
		mPasswordMinNonLetter = Math.max(intent.getIntExtra(PASSWORD_MIN_NONLETTER_KEY,
		mPasswordMinNonLetter), mLockPatternUtils.getRequestedPasswordMinimumNonLetter());

		mChooseLockSettingsHelper = new ChooseLockSettingsHelper(getActivity());
		}

		@Override
		public View onCreateView(LayoutInflater inflater, ViewGroup container,
		Bundle savedInstanceState) {

		View view = inflater.inflate(R.layout.choose_lock_password, null);

		mCancelButton = (Button) view.findViewById(R.id.cancel_button);
		mCancelButton.setOnClickListener(this);
		mNextButton = (Button) view.findViewById(R.id.next_button);
		mNextButton.setOnClickListener(this);

		mIsAlphaMode = true;
		mKeyboardView = (PasswordEntryKeyboardView) view.findViewById(R.id.keyboard);
		mPasswordEntry = (TextView) view.findViewById(R.id.password_entry);
		mPasswordEntry.setOnEditorActionListener(this);
		mPasswordEntry.addTextChangedListener(this);

		final Activity activity = getActivity();
		mKeyboardHelper = new PasswordEntryKeyboardHelper(activity,
		mKeyboardView, mPasswordEntry);
		mKeyboardHelper.setKeyboardMode(PasswordEntryKeyboardHelper.KEYBOARD_MODE_ALPHA);

		mHeaderText = (TextView) view.findViewById(R.id.headerText);
		mKeyboardView.requestFocus();

		int currentType = mPasswordEntry.getInputType();
		mPasswordEntry.setInputType(currentType);

		Intent intent = getActivity().getIntent();
		final boolean confirmCredentials = false;
		if (savedInstanceState == null) {
		updateStage(Stage.Introduction);
		} else {
		mFirstPin = savedInstanceState.getString(KEY_FIRST_PIN);
		final String state = savedInstanceState.getString(KEY_UI_STAGE);
		if (state != null) {
		mUiStage = Stage.valueOf(state);
		updateStage(mUiStage);
		}
		}
		// Update the breadcrumb (title) if this is embedded in a PreferenceActivity
		if (activity instanceof PreferenceActivity) {
		final PreferenceActivity preferenceActivity = (PreferenceActivity) activity;
		int id = R.string.encryptionpassword_choose_your_password_header;
		CharSequence title = getText(id);
		preferenceActivity.showBreadCrumbs(title, title);
		}

		return view;
		}

		@Override
		public void onResume() {
		super.onResume();
		updateStage(mUiStage);
		mKeyboardView.requestFocus();
		}

		@Override
		public void onPause() {
		mHandler.removeMessages(MSG_SHOW_ERROR);

		super.onPause();
		}

		@Override
		public void onSaveInstanceState(Bundle outState) {
		super.onSaveInstanceState(outState);
		outState.putString(KEY_UI_STAGE, mUiStage.name());
		outState.putString(KEY_FIRST_PIN, mFirstPin);
		}

		@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();
		}
		break;
		}
		}

		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
		&& (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);
		} 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)) {
		return getString(R.string.lockpassword_password_recently_used);
		}
		return null;
		}

		private void handleNext() {
		final String pin = mPasswordEntry.getText().toString();
		if (TextUtils.isEmpty(pin)) {
		return;
		}
		String errorMsg = null;
		if (mUiStage == Stage.Introduction) {
		errorMsg = validatePassword(pin);
		if (errorMsg == null) {
		mFirstPin = pin;
		mPasswordEntry.setText("");
		updateStage(Stage.NeedToConfirm);
		}
		} else if (mUiStage == Stage.NeedToConfirm) {
		if (mFirstPin.equals(pin)) {
		mLockPatternUtils.saveEncryptionPassword(pin);
		getActivity().finish();
		} else {
		CharSequence tmp = mPasswordEntry.getText();
		if (tmp != null) {
		Selection.setSelection((Spannable) tmp, 0, tmp.length());
		}
		updateStage(Stage.ConfirmWrong);
		}
		}
		if (errorMsg != null) {
		showError(errorMsg, mUiStage);
		}
		}

		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 && length > 0) {
		if (length < mPasswordMinLength) {
		String msg = getString(mIsAlphaMode ? R.string.lockpassword_password_too_short
		: R.string.lockpassword_pin_too_short, mPasswordMinLength);
		mHeaderText.setText(msg);
		mNextButton.setEnabled(false);
		} else {
		String error = validatePassword(password);
		if (error != null) {
		mHeaderText.setText(error);
		mNextButton.setEnabled(false);
		} else {
		mHeaderText.setText(R.string.lockpassword_press_continue);
		mNextButton.setEnabled(true);
		}
		}
		} else {
		mHeaderText.setText(mIsAlphaMode ? mUiStage.alphaHint : mUiStage.numericHint);
		mNextButton.setEnabled(length > 0);
		}
		mNextButton.setText(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) {

		}
		}
		}