PawletOS/app_Settings
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Fix 2579923: Make changing lock screen method more discoverable." into froyo

Browse Source
This commit is contained in:
Jim Miller
2010-04-12 13:48:36 -07:00
committed by Android (Google) Code Review
parent 3957b3c147 bbb4afa19f
commit 0b326a6fad
13 changed files with 283 additions and 182 deletions
Download Patch File Download Diff File Expand all files Collapse all files

154
src/com/android/settings/ChooseLockGeneric.java
View File

@@ -18,52 +18,180 @@ package com.android.settings;
import com.android.internal.widget.LockPatternUtils;
import android.app.Activity;
import android.app.admin.DevicePolicyManager;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.preference.Preference;
import android.preference.PreferenceActivity;
import android.preference.PreferenceCategory;
import android.preference.PreferenceScreen;
public class ChooseLockGeneric extends PreferenceActivity {
private static final int MIN_PASSWORD_LENGTH = 4;
private static final String KEY_UNLOCK_SET_NONE = "unlock_set_none";
private static final String KEY_UNLOCK_SET_PIN = "unlock_set_pin";
private static final String KEY_UNLOCK_SET_PASSWORD = "unlock_set_password";
private static final String KEY_UNLOCK_SET_PATTERN = "unlock_set_pattern";
private static final int CONFIRM_EXISTING_REQUEST = 100;
private static final String PASSWORD_CONFIRMED = "password_confirmed";
private static final String CONFIRM_CREDENTIALS = "confirm_credentials";
public class ChooseLockGeneric extends Activity {
private ChooseLockSettingsHelper mChooseLockSettingsHelper;
DevicePolicyManager mDPM;
private DevicePolicyManager mDPM;
private boolean mPasswordConfirmed = false;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mDPM = (DevicePolicyManager)getSystemService(Context.DEVICE_POLICY_SERVICE);
mDPM = (DevicePolicyManager) getSystemService(Context.DEVICE_POLICY_SERVICE);
mChooseLockSettingsHelper = new ChooseLockSettingsHelper(this);
final LockPatternUtils lockPatternUtils = mChooseLockSettingsHelper.utils();
if (savedInstanceState != null) {
mPasswordConfirmed = savedInstanceState.getBoolean(PASSWORD_CONFIRMED);
}
if (!mPasswordConfirmed) {
ChooseLockSettingsHelper helper = new ChooseLockSettingsHelper(this);
if (!helper.launchConfirmationActivity(CONFIRM_EXISTING_REQUEST)) {
mPasswordConfirmed = true; // no password set, so no need to confirm
updatePreferencesOrFinish();
}
} else {
updatePreferencesOrFinish();
}
}
@Override
public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen,
Preference preference) {
final String key = preference.getKey();
boolean handled = true;
if (KEY_UNLOCK_SET_NONE.equals(key)) {
updateUnlockMethodAndFinish(DevicePolicyManager.PASSWORD_QUALITY_UNSPECIFIED);
} else if (KEY_UNLOCK_SET_PATTERN.equals(key)) {
updateUnlockMethodAndFinish(DevicePolicyManager.PASSWORD_QUALITY_SOMETHING);
} else if (KEY_UNLOCK_SET_PIN.equals(key)) {
updateUnlockMethodAndFinish(DevicePolicyManager.PASSWORD_QUALITY_NUMERIC);
} else if (KEY_UNLOCK_SET_PASSWORD.equals(key)) {
updateUnlockMethodAndFinish(DevicePolicyManager.PASSWORD_QUALITY_ALPHABETIC);
} else {
handled = false;
}
return handled;
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);
if (requestCode == CONFIRM_EXISTING_REQUEST && resultCode == RESULT_OK) {
mPasswordConfirmed = true;
updatePreferencesOrFinish();
} else {
setResult(RESULT_CANCELED);
finish();
}
}
@Override
protected void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
// Saved so we don't force user to re-enter their password if configuration changes
outState.putBoolean(PASSWORD_CONFIRMED, mPasswordConfirmed);
}
private void updatePreferencesOrFinish() {
int quality = getIntent().getIntExtra(LockPatternUtils.PASSWORD_TYPE_KEY, -1);
if (quality == -1) {
quality = lockPatternUtils.getKeyguardStoredPasswordQuality();
// If caller didn't specify password quality, show the UI and allow the user to choose.
quality = mChooseLockSettingsHelper.utils().getKeyguardStoredPasswordQuality();
final PreferenceScreen prefScreen = getPreferenceScreen();
if (prefScreen != null) {
prefScreen.removeAll();
}
addPreferencesFromResource(R.xml.security_settings_picker);
disableUnusablePreferences(mDPM.getPasswordQuality(null));
} else {
updateUnlockMethodAndFinish(quality);
}
}
/***
* Disables preferences that are less secure than required quality.
*
* @param quality the requested quality.
*/
private void disableUnusablePreferences(final int quality) {
final Preference picker = getPreferenceScreen().findPreference("security_picker_category");
final PreferenceCategory cat = (PreferenceCategory) picker;
final int preferenceCount = cat.getPreferenceCount();
for (int i = 0; i < preferenceCount; i++) {
Preference pref = cat.getPreference(i);
if (pref instanceof PreferenceScreen) {
final String key = ((PreferenceScreen) pref).getKey();
boolean enabled = true;
if (KEY_UNLOCK_SET_NONE.equals(key)) {
enabled = quality <= DevicePolicyManager.PASSWORD_QUALITY_UNSPECIFIED;
} else if (KEY_UNLOCK_SET_PATTERN.equals(key)) {
enabled = quality <= DevicePolicyManager.PASSWORD_QUALITY_SOMETHING;
} else if (KEY_UNLOCK_SET_PIN.equals(key)) {
enabled = quality <= DevicePolicyManager.PASSWORD_QUALITY_NUMERIC;
} else if (KEY_UNLOCK_SET_PASSWORD.equals(key)) {
enabled = quality <= DevicePolicyManager.PASSWORD_QUALITY_ALPHANUMERIC;
}
if (!enabled) {
pref.setSummary(R.string.unlock_set_unlock_disabled_summary);
pref.setEnabled(false);
}
}
}
}
/**
* Invokes an activity to change the user's pattern, password or PIN based on given quality
* and minimum quality specified by DevicePolicyManager. If quality is
* {@link DevicePolicyManager#PASSWORD_QUALITY_UNSPECIFIED}, password is cleared.
*
* @param quality the desired quality. Ignored if DevicePolicyManager requires more security.
*/
void updateUnlockMethodAndFinish(int quality) {
// Sanity check. We should never get here without confirming user's existing password first.
if (!mPasswordConfirmed) {
throw new IllegalStateException("Tried to update password without confirming first");
}
// Compare minimum allowed password quality and launch appropriate security setting method
int minQuality = mDPM.getPasswordQuality(null);
if (quality < minQuality) {
quality = minQuality;
}
if (quality >= DevicePolicyManager.PASSWORD_QUALITY_NUMERIC) {
int minLength = mDPM.getPasswordMinimumLength(null);
if (minLength < 4) {
minLength = 4;
if (minLength < MIN_PASSWORD_LENGTH) {
minLength = MIN_PASSWORD_LENGTH;
}
final int maxLength = mDPM.getPasswordMaximumLength(quality);
Intent intent = new Intent().setClass(this, ChooseLockPassword.class);
intent.putExtra(LockPatternUtils.PASSWORD_TYPE_KEY, quality);
intent.putExtra(ChooseLockPassword.PASSWORD_MIN_KEY, minLength);
intent.putExtra(ChooseLockPassword.PASSWORD_MAX_KEY, maxLength);
intent.putExtra(CONFIRM_CREDENTIALS, false);
intent.addFlags(Intent.FLAG_ACTIVITY_FORWARD_RESULT);
startActivity(intent);
} else {
boolean showTutorial = !lockPatternUtils.isPatternEverChosen();
} else if (quality == DevicePolicyManager.PASSWORD_QUALITY_SOMETHING) {
boolean showTutorial = !mChooseLockSettingsHelper.utils().isPatternEverChosen();
Intent intent = new Intent();
intent.setClass(this, showTutorial
? ChooseLockPatternTutorial.class
: ChooseLockPattern.class);
intent.addFlags(Intent.FLAG_ACTIVITY_FORWARD_RESULT);
intent.putExtra("key_lock_method", "pattern");
intent.putExtra(CONFIRM_CREDENTIALS, false);
startActivity(intent);
} else if (quality == DevicePolicyManager.PASSWORD_QUALITY_UNSPECIFIED) {
mChooseLockSettingsHelper.utils().clearLock();
setResult(RESULT_OK);
}
finish();
}

6
src/com/android/settings/ChooseLockPassword.java
View File

@@ -104,6 +104,8 @@ public class ChooseLockPassword extends Activity implements OnClickListener, OnE
mRequestedQuality = getIntent().getIntExtra(LockPatternUtils.PASSWORD_TYPE_KEY, mRequestedQuality);
mPasswordMinLength = getIntent().getIntExtra(PASSWORD_MIN_KEY, mPasswordMinLength);
mPasswordMaxLength = getIntent().getIntExtra(PASSWORD_MAX_KEY, mPasswordMaxLength);
final boolean confirmCredentials = getIntent().getBooleanExtra("confirm_credentials", true);
int minMode = mLockPatternUtils.getRequestedPasswordQuality();
if (mRequestedQuality < minMode) {
mRequestedQuality = minMode;
@@ -116,7 +118,9 @@ public class ChooseLockPassword extends Activity implements OnClickListener, OnE
mChooseLockSettingsHelper = new ChooseLockSettingsHelper(this);
if (savedInstanceState == null) {
updateStage(Stage.Introduction);
mChooseLockSettingsHelper.launchConfirmationActivity(CONFIRM_EXISTING_REQUEST);
if (confirmCredentials) {
mChooseLockSettingsHelper.launchConfirmationActivity(CONFIRM_EXISTING_REQUEST);
}
}
}

16
src/com/android/settings/ChooseLockPattern.java
View File

@@ -280,11 +280,19 @@ public class ChooseLockPattern extends Activity implements View.OnClickListener{
R.id.topLayout);
topLayout.setDefaultTouchRecepient(mLockPatternView);
final boolean confirmCredentials = getIntent().getBooleanExtra("confirm_credentials", true);
if (savedInstanceState == null) {
// first launch. As a security measure, we're in NeedToConfirm mode until we know
// there isn't an existing password or the user confirms their password.
updateStage(Stage.NeedToConfirm);
if (!mChooseLockSettingsHelper.launchConfirmationActivity(CONFIRM_EXISTING_REQUEST)) {
if (confirmCredentials) {
// first launch. As a security measure, we're in NeedToConfirm mode until we know
// there isn't an existing password or the user confirms their password.
updateStage(Stage.NeedToConfirm);
boolean launchedConfirmationActivity =
mChooseLockSettingsHelper.launchConfirmationActivity(CONFIRM_EXISTING_REQUEST);
if (!launchedConfirmationActivity) {
updateStage(Stage.Introduction);
}
} else {
updateStage(Stage.Introduction);
}
} else {

29
src/com/android/settings/ChooseLockPatternExample.java
View File

@@ -25,7 +25,6 @@ import android.view.View;
import android.widget.ImageView;
public class ChooseLockPatternExample extends Activity implements View.OnClickListener {
private static final int REQUESTCODE_CHOOSE = 1;
private static final long START_DELAY = 1000;
protected static final String TAG = "Settings";
private View mNextButton;
@@ -38,26 +37,26 @@ public class ChooseLockPatternExample extends Activity implements View.OnClickLi
startAnimation(mAnimation);
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.choose_lock_pattern_example);
initViews();
}
@Override
protected void onResume() {
super.onResume();
mHandler.postDelayed(mRunnable, START_DELAY);
}
@Override
protected void onPause() {
super.onPause();
stopAnimation(mAnimation);
}
public void onClick(View v) {
if (v == mSkipButton) {
// Canceling, so finish all
@@ -66,37 +65,31 @@ public class ChooseLockPatternExample extends Activity implements View.OnClickLi
} else if (v == mNextButton) {
stopAnimation(mAnimation);
Intent intent = new Intent(this, ChooseLockPattern.class);
startActivityForResult(intent, REQUESTCODE_CHOOSE);
}
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
if (requestCode == REQUESTCODE_CHOOSE && resultCode == ChooseLockPattern.RESULT_FINISHED) {
setResult(resultCode);
intent.addFlags(Intent.FLAG_ACTIVITY_FORWARD_RESULT);
startActivity(intent);
finish();
}
}
private void initViews() {
mNextButton = findViewById(R.id.next_button);
mNextButton.setOnClickListener(this);
mSkipButton = findViewById(R.id.skip_button);
mSkipButton.setOnClickListener(this);
mImageView = (ImageView) findViewById(R.id.lock_anim);
mImageView.setBackgroundResource(R.drawable.lock_anim);
mImageView.setOnClickListener(this);
mAnimation = (AnimationDrawable) mImageView.getBackground();
}
protected void startAnimation(final AnimationDrawable animation) {
if (animation != null && !animation.isRunning()) {
animation.run();
}
}
protected void stopAnimation(final AnimationDrawable animation) {
if (animation != null && animation.isRunning()) animation.stop();
}

19
src/com/android/settings/ChooseLockPatternTutorial.java
View File

@@ -24,8 +24,6 @@ import android.os.Bundle;
import android.view.View;
public class ChooseLockPatternTutorial extends Activity implements View.OnClickListener {
private static final int REQUESTCODE_EXAMPLE = 1;
private View mNextButton;
private View mSkipButton;
@@ -35,8 +33,8 @@ public class ChooseLockPatternTutorial extends Activity implements View.OnClickL
// Don't show the tutorial if the user has seen it before.
LockPatternUtils lockPatternUtils = new LockPatternUtils(this);
if (savedInstanceState == null && lockPatternUtils.isPatternEverChosen()) {
Intent intent = new Intent();
intent.setClass(this, ChooseLockPattern.class);
Intent intent = new Intent(this, ChooseLockPattern.class);
intent.setFlags(Intent.FLAG_ACTIVITY_FORWARD_RESULT);
startActivity(intent);
finish();
} else {
@@ -58,18 +56,11 @@ public class ChooseLockPatternTutorial extends Activity implements View.OnClickL
setResult(ChooseLockPattern.RESULT_FINISHED);
finish();
} else if (v == mNextButton) {
startActivityForResult(new Intent(this, ChooseLockPatternExample.class),
REQUESTCODE_EXAMPLE);
}
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
if (requestCode == REQUESTCODE_EXAMPLE && resultCode == ChooseLockPattern.RESULT_FINISHED) {
setResult(resultCode);
Intent intent = new Intent(this, ChooseLockPatternExample.class);
intent.addFlags(Intent.FLAG_ACTIVITY_FORWARD_RESULT);
startActivity(intent);
finish();
}
}
}

88
src/com/android/settings/SecuritySettings.java
View File

@@ -56,25 +56,15 @@ import com.android.internal.widget.LockPatternUtils;
* Gesture lock pattern settings.
*/
public class SecuritySettings extends PreferenceActivity {
private static final String KEY_UNLOCK_SET_OR_CHANGE = "unlock_set_or_change";
private static final String KEY_UNLOCK_SET_PASSWORD = "unlock_set_password";
private static final String KEY_UNLOCK_SET_PIN = "unlock_set_pin";
private static final String KEY_UNLOCK_SET_PATTERN = "unlock_set_pattern";
private static final String KEY_UNLOCK_METHOD_CHANGE_CURRENT = "unlock_method_change_current";
private static final String KEY_UNLOCK_METHOD_DISABLE = "unlock_method_disable";
// Lock Settings
private static final String PACKAGE = "com.android.settings";
private static final String LOCK_PATTERN_TUTORIAL = PACKAGE + ".ChooseLockPatternTutorial";
private static final String ICC_LOCK_SETTINGS = PACKAGE + ".IccLockSettings";
private static final String CHOOSE_LOCK_PATTERN = PACKAGE + ".ChooseLockPattern";
private static final String CHOOSE_LOCK_PIN = PACKAGE + ".ChooseLockPassword";
private static final String KEY_LOCK_ENABLED = "lockenabled";
private static final String KEY_VISIBLE_PATTERN = "visiblepattern";
private static final String KEY_TACTILE_FEEDBACK_ENABLED = "unlock_tactile_feedback";
private static final String KEY_UNLOCK_METHOD = "unlock_method";
private static final int UPDATE_PASSWORD_REQUEST = 56;
private static final int CONFIRM_EXISTING_REQUEST = 57;
private CheckBoxPreference mVisiblePattern;
private CheckBoxPreference mTactileFeedback;
@@ -82,14 +72,10 @@ public class SecuritySettings extends PreferenceActivity {
private CheckBoxPreference mShowPassword;
// Location Settings
private static final String LOCATION_CATEGORY = "location_category";
private static final String LOCATION_NETWORK = "location_network";
private static final String LOCATION_GPS = "location_gps";
private static final String ASSISTED_GPS = "assisted_gps";
// Default password lengths if device policy isn't in effect. Ignored otherwise.
private static final int PASSWORD_MIN_LENGTH = 4;
private static final int PASSWORD_MAX_LENGTH = 16;
private static final int SET_OR_CHANGE_LOCK_METHOD_REQUEST = 123;
// Credential storage
private CredentialStorage mCredentialStorage = new CredentialStorage();
@@ -106,8 +92,6 @@ public class SecuritySettings extends PreferenceActivity {
private ContentQueryMap mContentQueryMap;
private ChooseLockSettingsHelper mChooseLockSettingsHelper;
private LockPatternUtils mLockPatternUtils;
private PreferenceScreen mDisableUnlock;
private PreferenceScreen mChangeCurrent;
private final class SettingsObserver implements Observer {
public void update(Observable o, Object arg) {
updateToggles();
@@ -169,11 +153,8 @@ public class SecuritySettings extends PreferenceActivity {
}
}
// disable current pattern. Should be common to all unlock preference screens.
mDisableUnlock = (PreferenceScreen) pm.findPreference(KEY_UNLOCK_METHOD_DISABLE);
// change current. Should be common to all unlock preference screens
mChangeCurrent = (PreferenceScreen) pm.findPreference(KEY_UNLOCK_METHOD_CHANGE_CURRENT);
// set or change current. Should be common to all unlock preference screens
// mSetOrChange = (PreferenceScreen) pm.findPreference(KEY_UNLOCK_SET_OR_CHANGE);
// visible pattern
mVisiblePattern = (CheckBoxPreference) pm.findPreference(KEY_VISIBLE_PATTERN);
@@ -181,7 +162,6 @@ public class SecuritySettings extends PreferenceActivity {
// tactile feedback. Should be common to all unlock preference screens.
mTactileFeedback = (CheckBoxPreference) pm.findPreference(KEY_TACTILE_FEEDBACK_ENABLED);
int activePhoneType = TelephonyManager.getDefault().getPhoneType();
// do not display SIM lock for CDMA phone
@@ -232,46 +212,6 @@ public class SecuritySettings extends PreferenceActivity {
return root;
}
protected void handleUpdateUnlockMethod(String value) {
// NULL means update the current password/pattern/pin
if (value == null) {
int mode = mLockPatternUtils.getKeyguardStoredPasswordQuality();
if (DevicePolicyManager.PASSWORD_QUALITY_SOMETHING == mode) {
value = "pattern";
} else if (DevicePolicyManager.PASSWORD_QUALITY_ALPHABETIC == mode
|| DevicePolicyManager.PASSWORD_QUALITY_ALPHANUMERIC == mode) {
value = "password";
} else if (DevicePolicyManager.PASSWORD_QUALITY_NUMERIC == mode) {
value = "pin";
} else {
throw new IllegalStateException("Unknown password mode: " + value);
}
}
if ("none".equals(value)) {
if (mDPM.getPasswordQuality(null) == DevicePolicyManager.PASSWORD_QUALITY_UNSPECIFIED) {
mChooseLockSettingsHelper.launchConfirmationActivity(CONFIRM_EXISTING_REQUEST);
}
} else {
int reqMode;
if ("password".equals(value)) {
reqMode = DevicePolicyManager.PASSWORD_QUALITY_ALPHABETIC;
} else if ( "pin".equals(value)) {
reqMode = DevicePolicyManager.PASSWORD_QUALITY_NUMERIC;
} else {
reqMode = DevicePolicyManager.PASSWORD_QUALITY_SOMETHING;
}
int minMode = mDPM.getPasswordQuality(null);
if (reqMode < minMode) {
reqMode = minMode;
}
Intent intent = new Intent();
intent.setClass(this, ChooseLockGeneric.class);
intent.putExtra(LockPatternUtils.PASSWORD_TYPE_KEY, reqMode);
startActivityForResult(intent, UPDATE_PASSWORD_REQUEST);
}
}
@Override
protected void onResume() {
super.onResume();
@@ -296,16 +236,9 @@ public class SecuritySettings extends PreferenceActivity {
final String key = preference.getKey();
final LockPatternUtils lockPatternUtils = mChooseLockSettingsHelper.utils();
if (KEY_UNLOCK_SET_PATTERN.equals(key)) {
handleUpdateUnlockMethod("pattern");
} else if (KEY_UNLOCK_SET_PIN.equals(key)) {
handleUpdateUnlockMethod("pin");
} else if (KEY_UNLOCK_SET_PASSWORD.equals(key)) {
handleUpdateUnlockMethod("password");
} else if (KEY_UNLOCK_METHOD_DISABLE.equals(key)) {
handleUpdateUnlockMethod("none");
} else if (KEY_UNLOCK_METHOD_CHANGE_CURRENT.equals(key)) {
handleUpdateUnlockMethod(null);
if (KEY_UNLOCK_SET_OR_CHANGE.equals(key)) {
Intent intent = new Intent(this, ChooseLockGeneric.class);
startActivityForResult(intent, SET_OR_CHANGE_LOCK_METHOD_REQUEST);
} else if (KEY_LOCK_ENABLED.equals(key)) {
lockPatternUtils.setLockPatternEnabled(isToggled(preference));
} else if (KEY_VISIBLE_PATTERN.equals(key)) {
@@ -360,13 +293,6 @@ public class SecuritySettings extends PreferenceActivity {
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);
final boolean resultOk = resultCode == Activity.RESULT_OK;
LockPatternUtils lockPatternUtils = mChooseLockSettingsHelper.utils();
if ((requestCode == CONFIRM_EXISTING_REQUEST) && resultOk) {
lockPatternUtils.clearLock();
}
createPreferenceHierarchy();
}