packages/apps/Settings/src/com/android/settings/ChooseLockPattern.java

   1 /*
   2  * Copyright (C) 2007 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
  17 package com.android.settings;
  18
  19 import com.google.android.collect.Lists;
  20
  21 import com.android.internal.widget.LinearLayoutWithDefaultTouchRecepient;
  22 import com.android.internal.widget.LockPatternUtils;
  23 import com.android.internal.widget.LockPatternView;
  24 import com.android.internal.widget.LockPatternView.Cell;
  25 import static com.android.internal.widget.LockPatternView.DisplayMode;
  26
  27 import android.app.Activity;
  28 import android.content.Intent;
  29 import android.os.Bundle;
  30 import android.view.KeyEvent;
  31 import android.view.View;
  32 import android.view.Window;
  33 import android.widget.TextView;
  34
  35 import java.util.ArrayList;
  36 import java.util.Collections;
  37 import java.util.List;
  38
  39 /**
  40  * If the user has a lock pattern set already, makes them confirm the existing one.
  41  *
  42  * Then, prompts the user to choose a lock pattern:
  43  * - prompts for initial pattern
  44  * - asks for confirmation / restart
  45  * - saves chosen password when confirmed
  46  */
  47 public class ChooseLockPattern extends Activity implements View.OnClickListener{
  48     /**
  49      * Used by the choose lock pattern wizard to indicate the wizard is
  50      * finished, and each activity in the wizard should finish.
  51      * <p>
  52      * Previously, each activity in the wizard would finish itself after
  53      * starting the next activity. However, this leads to broken 'Back'
  54      * behavior. So, now an activity does not finish itself until it gets this
  55      * result.
  56      */
  57     static final int RESULT_FINISHED = RESULT_FIRST_USER;
  58
  59     public static final int CONFIRM_EXISTING_REQUEST = 55;
  60
  61     // how long after a confirmation message is shown before moving on
  62     static final int INFORMATION_MSG_TIMEOUT_MS = 3000;
  63
  64     // how long we wait to clear a wrong pattern
  65     private static final int WRONG_PATTERN_CLEAR_TIMEOUT_MS = 2000;
  66
  67     private static final int ID_EMPTY_MESSAGE = -1;
  68
  69     protected TextView mHeaderText;
  70     protected LockPatternView mLockPatternView;
  71     protected TextView mFooterText;
  72     private TextView mFooterLeftButton;
  73     private TextView mFooterRightButton;
  74     protected List<LockPatternView.Cell> mChosenPattern = null;
  75
  76     /**
  77      * The patten used during the help screen to show how to draw a pattern.
  78      */
  79     private final List<LockPatternView.Cell> mAnimatePattern =
  80             Collections.unmodifiableList(Lists.newArrayList(
  81                     LockPatternView.Cell.of(0, 0),
  82                     LockPatternView.Cell.of(0, 1),
  83                     LockPatternView.Cell.of(1, 1),
  84                     LockPatternView.Cell.of(2, 1)
  85             ));
  86
  87     @Override
  88     protected void onActivityResult(int requestCode, int resultCode,
  89             Intent data) {
  90         super.onActivityResult(requestCode, resultCode, data);
  91         switch (requestCode) {
  92             case CONFIRM_EXISTING_REQUEST:
  93                 if (resultCode != Activity.RESULT_OK) {
  94                     setResult(RESULT_FINISHED);
  95                     finish();
  96                 }
  97                 updateStage(Stage.Introduction);
  98                 break;
  99         }
 100     }
 101
 102     /**
 103      * The pattern listener that responds according to a user choosing a new
 104      * lock pattern.
 105      */
 106     protected LockPatternView.OnPatternListener mChooseNewLockPatternListener = new LockPatternView.OnPatternListener() {
 107
 108             public void onPatternStart() {
 109                 mLockPatternView.removeCallbacks(mClearPatternRunnable);
 110                 patternInProgress();
 111             }
 112
 113             public void onPatternCleared() {
 114                 mLockPatternView.removeCallbacks(mClearPatternRunnable);
 115             }
 116
 117             public void onPatternDetected(List<LockPatternView.Cell> pattern) {
 118                 if (mUiStage == Stage.NeedToConfirm || mUiStage == Stage.ConfirmWrong) {
 119                     if (mChosenPattern == null) throw new IllegalStateException("null chosen pattern in stage 'need to confirm");
 120                     if (mChosenPattern.equals(pattern)) {
 121                         updateStage(Stage.ChoiceConfirmed);
 122                     } else {
 123                         updateStage(Stage.ConfirmWrong);
 124                     }
 125                 } else if (mUiStage == Stage.Introduction || mUiStage == Stage.ChoiceTooShort){
 126                     if (pattern.size() < LockPatternUtils.MIN_LOCK_PATTERN_SIZE) {
 127                         updateStage(Stage.ChoiceTooShort);
 128                     } else {
 129                         mChosenPattern = new ArrayList<LockPatternView.Cell>(pattern);
 130                         updateStage(Stage.FirstChoiceValid);
 131                     }
 132                 } else {
 133                     throw new IllegalStateException("Unexpected stage " + mUiStage + " when "
 134                             + "entering the pattern.");
 135                 }
 136             }
 137
 138             public void onPatternCellAdded(List<Cell> pattern) {
 139
 140             }
 141
 142             private void patternInProgress() {
 143                 mHeaderText.setText(R.string.lockpattern_recording_inprogress);
 144                 mFooterText.setText("");
 145                 mFooterLeftButton.setEnabled(false);
 146                 mFooterRightButton.setEnabled(false);
 147             }
 148      };
 149
 150
 151     /**
 152      * The states of the left footer button.
 153      */
 154     enum LeftButtonMode {
 155         Cancel(R.string.cancel, true),
 156         CancelDisabled(R.string.cancel, false),
 157         Retry(R.string.lockpattern_retry_button_text, true),
 158         RetryDisabled(R.string.lockpattern_retry_button_text, false),
 159         Gone(ID_EMPTY_MESSAGE, false);
 160
 161
 162         /**
 163          * @param text The displayed text for this mode.
 164          * @param enabled Whether the button should be enabled.
 165          */
 166         LeftButtonMode(int text, boolean enabled) {
 167             this.text = text;
 168             this.enabled = enabled;
 169         }
 170
 171         final int text;
 172         final boolean enabled;
 173     }
 174
 175     /**
 176      * The states of the right button.
 177      */
 178     enum RightButtonMode {
 179         Continue(R.string.lockpattern_continue_button_text, true),
 180         ContinueDisabled(R.string.lockpattern_continue_button_text, false),
 181         Confirm(R.string.lockpattern_confirm_button_text, true),
 182         ConfirmDisabled(R.string.lockpattern_confirm_button_text, false),
 183         Ok(android.R.string.ok, true);
 184
 185         /**
 186          * @param text The displayed text for this mode.
 187          * @param enabled Whether the button should be enabled.
 188          */
 189         RightButtonMode(int text, boolean enabled) {
 190             this.text = text;
 191             this.enabled = enabled;
 192         }
 193
 194         final int text;
 195         final boolean enabled;
 196     }
 197
 198     /**
 199      * Keep track internally of where the user is in choosing a pattern.
 200      */
 201     protected enum Stage {
 202
 203         Introduction(
 204                 R.string.lockpattern_recording_intro_header,
 205                 LeftButtonMode.Cancel, RightButtonMode.ContinueDisabled,
 206                 R.string.lockpattern_recording_intro_footer, true),
 207         HelpScreen(
 208                 R.string.lockpattern_settings_help_how_to_record,
 209                 LeftButtonMode.Gone, RightButtonMode.Ok, ID_EMPTY_MESSAGE, false),
 210         ChoiceTooShort(
 211                 R.string.lockpattern_recording_incorrect_too_short,
 212                 LeftButtonMode.Retry, RightButtonMode.ContinueDisabled,
 213                 ID_EMPTY_MESSAGE, true),
 214         FirstChoiceValid(
 215                 R.string.lockpattern_pattern_entered_header,
 216                 LeftButtonMode.Retry, RightButtonMode.Continue, ID_EMPTY_MESSAGE, false),
 217         NeedToConfirm(
 218                 R.string.lockpattern_need_to_confirm,
 219                 LeftButtonMode.CancelDisabled, RightButtonMode.ConfirmDisabled,
 220                 ID_EMPTY_MESSAGE, true),
 221         ConfirmWrong(
 222                 R.string.lockpattern_need_to_unlock_wrong,
 223                 LeftButtonMode.Cancel, RightButtonMode.ConfirmDisabled,
 224                 ID_EMPTY_MESSAGE, true),
 225         ChoiceConfirmed(
 226                 R.string.lockpattern_pattern_confirmed_header,
 227                 LeftButtonMode.Cancel, RightButtonMode.Confirm, ID_EMPTY_MESSAGE, false);
 228
 229
 230         /**
 231          * @param headerMessage The message displayed at the top.
 232          * @param leftMode The mode of the left button.
 233          * @param rightMode The mode of the right button.
 234          * @param footerMessage The footer message.
 235          * @param patternEnabled Whether the pattern widget is enabled.
 236          */
 237         Stage(int headerMessage,
 238                 LeftButtonMode leftMode,
 239                 RightButtonMode rightMode,
 240                 int footerMessage, boolean patternEnabled) {
 241             this.headerMessage = headerMessage;
 242             this.leftMode = leftMode;
 243             this.rightMode = rightMode;
 244             this.footerMessage = footerMessage;
 245             this.patternEnabled = patternEnabled;
 246         }
 247
 248         final int headerMessage;
 249         final LeftButtonMode leftMode;
 250         final RightButtonMode rightMode;
 251         final int footerMessage;
 252         final boolean patternEnabled;
 253     }
 254
 255     private Stage mUiStage = Stage.Introduction;
 256
 257     private Runnable mClearPatternRunnable = new Runnable() {
 258         public void run() {
 259             mLockPatternView.clearPattern();
 260         }
 261     };
 262
 263     private ChooseLockSettingsHelper mChooseLockSettingsHelper;
 264
 265     private static final String KEY_UI_STAGE = "uiStage";
 266     private static final String KEY_PATTERN_CHOICE = "chosenPattern";
 267
 268     @Override
 269     protected void onCreate(Bundle savedInstanceState) {
 270         super.onCreate(savedInstanceState);
 271         mChooseLockSettingsHelper = new ChooseLockSettingsHelper(this);
 272         requestWindowFeature(Window.FEATURE_NO_TITLE);
 273
 274         setupViews();
 275
 276         // make it so unhandled touch events within the unlock screen go to the
 277         // lock pattern view.
 278         final LinearLayoutWithDefaultTouchRecepient topLayout
 279                 = (LinearLayoutWithDefaultTouchRecepient) findViewById(
 280                 R.id.topLayout);
 281         topLayout.setDefaultTouchRecepient(mLockPatternView);
 282
 283         final boolean confirmCredentials = getIntent().getBooleanExtra("confirm_credentials", true);
 284
 285         if (savedInstanceState == null) {
 286             if (confirmCredentials) {
 287                 // first launch. As a security measure, we're in NeedToConfirm mode until we know
 288                 // there isn't an existing password or the user confirms their password.
 289                 updateStage(Stage.NeedToConfirm);
 290                 boolean launchedConfirmationActivity =
 291                     mChooseLockSettingsHelper.launchConfirmationActivity(CONFIRM_EXISTING_REQUEST,
 292                             null, null);
 293                 if (!launchedConfirmationActivity) {
 294                     updateStage(Stage.Introduction);
 295                 }
 296             } else {
 297                 updateStage(Stage.Introduction);
 298             }
 299         } else {
 300             // restore from previous state
 301             final String patternString = savedInstanceState.getString(KEY_PATTERN_CHOICE);
 302             if (patternString != null) {
 303                 mChosenPattern = LockPatternUtils.stringToPattern(patternString);
 304             }
 305             updateStage(Stage.values()[savedInstanceState.getInt(KEY_UI_STAGE)]);
 306         }
 307     }
 308
 309     /**
 310      * Keep all "find view" related stuff confined to this function since in
 311      * case someone needs to subclass and customize.
 312      */
 313     protected void setupViews() {
 314         setContentView(R.layout.choose_lock_pattern);
 315
 316         mHeaderText = (TextView) findViewById(R.id.headerText);
 317
 318         mLockPatternView = (LockPatternView) findViewById(R.id.lockPattern);
 319         mLockPatternView.setOnPatternListener(mChooseNewLockPatternListener);
 320         mLockPatternView.setTactileFeedbackEnabled(
 321                 mChooseLockSettingsHelper.utils().isTactileFeedbackEnabled());
 322
 323         mFooterText = (TextView) findViewById(R.id.footerText);
 324
 325         mFooterLeftButton = (TextView) findViewById(R.id.footerLeftButton);
 326         mFooterRightButton = (TextView) findViewById(R.id.footerRightButton);
 327
 328         mFooterLeftButton.setOnClickListener(this);
 329         mFooterRightButton.setOnClickListener(this);
 330     }
 331
 332     public void onClick(View v) {
 333         if (v == mFooterLeftButton) {
 334             if (mUiStage.leftMode == LeftButtonMode.Retry) {
 335                 mChosenPattern = null;
 336                 mLockPatternView.clearPattern();
 337                 updateStage(Stage.Introduction);
 338             } else if (mUiStage.leftMode == LeftButtonMode.Cancel) {
 339                 // They are canceling the entire wizard
 340                 setResult(RESULT_FINISHED);
 341                 finish();
 342             } else {
 343                 throw new IllegalStateException("left footer button pressed, but stage of " +
 344                     mUiStage + " doesn't make sense");
 345             }
 346         } else if (v == mFooterRightButton) {
 347
 348             if (mUiStage.rightMode == RightButtonMode.Continue) {
 349                 if (mUiStage != Stage.FirstChoiceValid) {
 350                     throw new IllegalStateException("expected ui stage " + Stage.FirstChoiceValid
 351                             + " when button is " + RightButtonMode.Continue);
 352                 }
 353                 updateStage(Stage.NeedToConfirm);
 354             } else if (mUiStage.rightMode == RightButtonMode.Confirm) {
 355                 if (mUiStage != Stage.ChoiceConfirmed) {
 356                     throw new IllegalStateException("expected ui stage " + Stage.ChoiceConfirmed
 357                             + " when button is " + RightButtonMode.Confirm);
 358                 }
 359                 saveChosenPatternAndFinish();
 360             } else if (mUiStage.rightMode == RightButtonMode.Ok) {
 361                 if (mUiStage != Stage.HelpScreen) {
 362                     throw new IllegalStateException("Help screen is only mode with ok button, but " +
 363                             "stage is " + mUiStage);
 364                 }
 365                 mLockPatternView.clearPattern();
 366                 mLockPatternView.setDisplayMode(DisplayMode.Correct);
 367                 updateStage(Stage.Introduction);
 368             }
 369         }
 370     }
 371
 372     @Override
 373     public boolean onKeyDown(int keyCode, KeyEvent event) {
 374         if (keyCode == KeyEvent.KEYCODE_BACK && event.getRepeatCount() == 0) {
 375             if (mUiStage == Stage.HelpScreen) {
 376                 updateStage(Stage.Introduction);
 377                 return true;
 378             }
 379         }
 380         if (keyCode == KeyEvent.KEYCODE_MENU && mUiStage == Stage.Introduction) {
 381             updateStage(Stage.HelpScreen);
 382             return true;
 383         }
 384
 385         return super.onKeyDown(keyCode, event);
 386     }
 387
 388     @Override
 389     protected void onSaveInstanceState(Bundle outState) {
 390         super.onSaveInstanceState(outState);
 391
 392         outState.putInt(KEY_UI_STAGE, mUiStage.ordinal());
 393         if (mChosenPattern != null) {
 394             outState.putString(KEY_PATTERN_CHOICE, LockPatternUtils.patternToString(mChosenPattern));
 395         }
 396     }
 397
 398
 399     /**
 400      * Updates the messages and buttons appropriate to what stage the user
 401      * is at in choosing a view.  This doesn't handle clearing out the pattern;
 402      * the pattern is expected to be in the right state.
 403      * @param stage
 404      */
 405     protected void updateStage(Stage stage) {
 406
 407         mUiStage = stage;
 408
 409         // header text, footer text, visibility and
 410         // enabled state all known from the stage
 411         if (stage == Stage.ChoiceTooShort) {
 412             mHeaderText.setText(
 413                     getResources().getString(
 414                             stage.headerMessage,
 415                             LockPatternUtils.MIN_LOCK_PATTERN_SIZE));
 416         } else {
 417             mHeaderText.setText(stage.headerMessage);
 418         }
 419         if (stage.footerMessage == ID_EMPTY_MESSAGE) {
 420             mFooterText.setText("");
 421         } else {
 422             mFooterText.setText(stage.footerMessage);
 423         }
 424
 425         if (stage.leftMode == LeftButtonMode.Gone) {
 426             mFooterLeftButton.setVisibility(View.GONE);
 427         } else {
 428             mFooterLeftButton.setVisibility(View.VISIBLE);
 429             mFooterLeftButton.setText(stage.leftMode.text);
 430             mFooterLeftButton.setEnabled(stage.leftMode.enabled);
 431         }
 432
 433         mFooterRightButton.setText(stage.rightMode.text);
 434         mFooterRightButton.setEnabled(stage.rightMode.enabled);
 435
 436         // same for whether the patten is enabled
 437         if (stage.patternEnabled) {
 438             mLockPatternView.enableInput();
 439         } else {
 440             mLockPatternView.disableInput();
 441         }
 442
 443         // the rest of the stuff varies enough that it is easier just to handle
 444         // on a case by case basis.
 445         mLockPatternView.setDisplayMode(DisplayMode.Correct);
 446
 447         switch (mUiStage) {
 448             case Introduction:
 449                 mLockPatternView.clearPattern();
 450                 break;
 451             case HelpScreen:
 452                 mLockPatternView.setPattern(DisplayMode.Animate, mAnimatePattern);
 453                 break;
 454             case ChoiceTooShort:
 455                 mLockPatternView.setDisplayMode(DisplayMode.Wrong);
 456                 postClearPatternRunnable();
 457                 break;
 458             case FirstChoiceValid:
 459                 break;
 460             case NeedToConfirm:
 461                 mLockPatternView.clearPattern();
 462                 break;
 463             case ConfirmWrong:
 464                 mLockPatternView.setDisplayMode(DisplayMode.Wrong);
 465                 postClearPatternRunnable();
 466                 break;
 467             case ChoiceConfirmed:
 468                 break;
 469         }
 470     }
 471
 472
 473     // clear the wrong pattern unless they have started a new one
 474     // already
 475     private void postClearPatternRunnable() {
 476         mLockPatternView.removeCallbacks(mClearPatternRunnable);
 477         mLockPatternView.postDelayed(mClearPatternRunnable, WRONG_PATTERN_CLEAR_TIMEOUT_MS);
 478     }
 479
 480     private void saveChosenPatternAndFinish() {
 481         LockPatternUtils utils = mChooseLockSettingsHelper.utils();
 482         final boolean lockVirgin = !utils.isPatternEverChosen();
 483
 484         utils.saveLockPattern(mChosenPattern);
 485         utils.setLockPatternEnabled(true);
 486
 487         if (lockVirgin) {
 488             utils.setVisiblePatternEnabled(true);
 489             utils.setTactileFeedbackEnabled(false);
 490         }
 491
 492         setResult(RESULT_FINISHED);
 493         finish();
 494     }
 495 }