/* * Copyright (C) 2007 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.password; import static com.android.settings.password.ChooseLockSettingsHelper.EXTRA_KEY_UNIFICATION_PROFILE_CREDENTIAL; import static com.android.settings.password.ChooseLockSettingsHelper.EXTRA_KEY_UNIFICATION_PROFILE_ID; import android.app.Activity; import android.app.settings.SettingsEnums; import android.content.Context; import android.content.Intent; import android.content.res.ColorStateList; import android.content.res.Resources.Theme; import android.os.Bundle; import android.os.UserHandle; import android.util.Log; import android.util.Pair; import android.util.TypedValue; import android.view.KeyEvent; import android.view.LayoutInflater; import android.view.View; import android.view.ViewGroup; import android.widget.ScrollView; import android.widget.TextView; import androidx.fragment.app.Fragment; import com.android.internal.annotations.VisibleForTesting; import com.android.internal.widget.LinearLayoutWithDefaultTouchRecepient; import com.android.internal.widget.LockPatternUtils; import com.android.internal.widget.LockPatternUtils.RequestThrottledException; import com.android.internal.widget.LockPatternView; import com.android.internal.widget.LockPatternView.Cell; import com.android.internal.widget.LockPatternView.DisplayMode; import com.android.internal.widget.LockscreenCredential; import com.android.settings.EncryptionInterstitial; import com.android.settings.R; import com.android.settings.SettingsActivity; import com.android.settings.SetupWizardUtils; import com.android.settings.Utils; import com.android.settings.core.InstrumentedFragment; import com.android.settings.notification.RedactionInterstitial; import com.android.settings.password.ChooseLockPassword.IntentBuilder; import com.google.android.collect.Lists; import com.google.android.setupcompat.template.FooterBarMixin; import com.google.android.setupcompat.template.FooterButton; import com.google.android.setupdesign.GlifLayout; import java.util.Collections; import java.util.List; /** * If the user has a lock pattern set already, makes them confirm the existing one. * * Then, prompts the user to choose a lock pattern: * - prompts for initial pattern * - asks for confirmation / restart * - saves chosen password when confirmed */ public class ChooseLockPattern extends SettingsActivity { /** * Used by the choose lock pattern wizard to indicate the wizard is * finished, and each activity in the wizard should finish. *

* Previously, each activity in the wizard would finish itself after * starting the next activity. However, this leads to broken 'Back' * behavior. So, now an activity does not finish itself until it gets this * result. */ static final int RESULT_FINISHED = RESULT_FIRST_USER; private static final String TAG = "ChooseLockPattern"; @Override public Intent getIntent() { Intent modIntent = new Intent(super.getIntent()); modIntent.putExtra(EXTRA_SHOW_FRAGMENT, getFragmentClass().getName()); return modIntent; } @Override protected void onApplyThemeResource(Theme theme, int resid, boolean first) { resid = SetupWizardUtils.getTheme(getIntent()); super.onApplyThemeResource(theme, resid, first); } public static class IntentBuilder { private final Intent mIntent; public IntentBuilder(Context context) { mIntent = new Intent(context, ChooseLockPattern.class); mIntent.putExtra(EncryptionInterstitial.EXTRA_REQUIRE_PASSWORD, false); mIntent.putExtra(ChooseLockGeneric.CONFIRM_CREDENTIALS, false); mIntent.putExtra(ChooseLockSettingsHelper.EXTRA_KEY_HAS_CHALLENGE, false); } public IntentBuilder setUserId(int userId) { mIntent.putExtra(Intent.EXTRA_USER_ID, userId); return this; } public IntentBuilder setChallenge(long challenge) { mIntent.putExtra(ChooseLockSettingsHelper.EXTRA_KEY_HAS_CHALLENGE, true); mIntent.putExtra(ChooseLockSettingsHelper.EXTRA_KEY_CHALLENGE, challenge); return this; } public IntentBuilder setPattern(LockscreenCredential pattern) { mIntent.putExtra(ChooseLockSettingsHelper.EXTRA_KEY_PASSWORD, pattern); return this; } public IntentBuilder setForFingerprint(boolean forFingerprint) { mIntent.putExtra(ChooseLockSettingsHelper.EXTRA_KEY_FOR_FINGERPRINT, forFingerprint); return this; } public IntentBuilder setForFace(boolean forFace) { mIntent.putExtra(ChooseLockSettingsHelper.EXTRA_KEY_FOR_FACE, forFace); return this; } /** * Configures the launch such that at the end of the pattern enrollment, one of its * managed profile (specified by {@code profileId}) will have its lockscreen unified * to the parent user. The profile's current lockscreen credential needs to be specified by * {@code credential}. */ public IntentBuilder setProfileToUnify(int profileId, LockscreenCredential credential) { mIntent.putExtra(ChooseLockSettingsHelper.EXTRA_KEY_UNIFICATION_PROFILE_ID, profileId); mIntent.putExtra(ChooseLockSettingsHelper.EXTRA_KEY_UNIFICATION_PROFILE_CREDENTIAL, credential); return this; } public Intent build() { return mIntent; } } @Override protected boolean isValidFragment(String fragmentName) { if (ChooseLockPatternFragment.class.getName().equals(fragmentName)) return true; return false; } /* package */ Class getFragmentClass() { return ChooseLockPatternFragment.class; } @Override protected void onCreate(Bundle savedInstanceState) { // requestWindowFeature(Window.FEATURE_NO_TITLE); super.onCreate(savedInstanceState); final boolean forFingerprint = getIntent() .getBooleanExtra(ChooseLockSettingsHelper.EXTRA_KEY_FOR_FINGERPRINT, false); final boolean forFace = getIntent() .getBooleanExtra(ChooseLockSettingsHelper.EXTRA_KEY_FOR_FACE, false); int msg = R.string.lockpassword_choose_your_screen_lock_header; if (forFingerprint) { msg = R.string.lockpassword_choose_your_pattern_header_for_fingerprint; } else if (forFace) { msg = R.string.lockpassword_choose_your_pattern_header_for_face; } setTitle(msg); findViewById(R.id.content_parent).setFitsSystemWindows(false); } @Override public boolean onKeyDown(int keyCode, KeyEvent event) { // *** TODO *** // chooseLockPatternFragment.onKeyDown(keyCode, event); return super.onKeyDown(keyCode, event); } public static class ChooseLockPatternFragment extends InstrumentedFragment implements SaveAndFinishWorker.Listener { public static final int CONFIRM_EXISTING_REQUEST = 55; // how long after a confirmation message is shown before moving on static final int INFORMATION_MSG_TIMEOUT_MS = 3000; // how long we wait to clear a wrong pattern private static final int WRONG_PATTERN_CLEAR_TIMEOUT_MS = 2000; protected static final int ID_EMPTY_MESSAGE = -1; private static final String FRAGMENT_TAG_SAVE_AND_FINISH = "save_and_finish_worker"; private LockscreenCredential mCurrentCredential; private boolean mHasChallenge; private long mChallenge; protected TextView mTitleText; protected TextView mHeaderText; protected TextView mMessageText; protected LockPatternView mLockPatternView; protected TextView mFooterText; protected FooterButton mSkipOrClearButton; private FooterButton mNextButton; @VisibleForTesting protected LockscreenCredential mChosenPattern; private ColorStateList mDefaultHeaderColorList; // ScrollView that contains title and header, only exist in land mode private ScrollView mTitleHeaderScrollView; /** * The patten used during the help screen to show how to draw a pattern. */ private final List mAnimatePattern = Collections.unmodifiableList(Lists.newArrayList( LockPatternView.Cell.of(0, 0), LockPatternView.Cell.of(0, 1), LockPatternView.Cell.of(1, 1), LockPatternView.Cell.of(2, 1) )); @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 { mCurrentCredential = data.getParcelableExtra( ChooseLockSettingsHelper.EXTRA_KEY_PASSWORD); } updateStage(Stage.Introduction); break; } } protected void setRightButtonEnabled(boolean enabled) { mNextButton.setEnabled(enabled); } protected void setRightButtonText(int text) { mNextButton.setText(getActivity(), text); } /** * The pattern listener that responds according to a user choosing a new * lock pattern. */ protected LockPatternView.OnPatternListener mChooseNewLockPatternListener = new LockPatternView.OnPatternListener() { public void onPatternStart() { mLockPatternView.removeCallbacks(mClearPatternRunnable); patternInProgress(); } public void onPatternCleared() { mLockPatternView.removeCallbacks(mClearPatternRunnable); } public void onPatternDetected(List pattern) { if (mUiStage == Stage.NeedToConfirm || mUiStage == Stage.ConfirmWrong) { if (mChosenPattern == null) throw new IllegalStateException( "null chosen pattern in stage 'need to confirm"); try (LockscreenCredential confirmPattern = LockscreenCredential.createPattern(pattern)) { if (mChosenPattern.equals(confirmPattern)) { updateStage(Stage.ChoiceConfirmed); } else { updateStage(Stage.ConfirmWrong); } } } else if (mUiStage == Stage.Introduction || mUiStage == Stage.ChoiceTooShort){ if (pattern.size() < LockPatternUtils.MIN_LOCK_PATTERN_SIZE) { updateStage(Stage.ChoiceTooShort); } else { mChosenPattern = LockscreenCredential.createPattern(pattern); updateStage(Stage.FirstChoiceValid); } } else { throw new IllegalStateException("Unexpected stage " + mUiStage + " when " + "entering the pattern."); } } public void onPatternCellAdded(List pattern) { } private void patternInProgress() { mHeaderText.setText(R.string.lockpattern_recording_inprogress); if (mDefaultHeaderColorList != null) { mHeaderText.setTextColor(mDefaultHeaderColorList); } mFooterText.setText(""); mNextButton.setEnabled(false); if (mTitleHeaderScrollView != null) { mTitleHeaderScrollView.post(new Runnable() { @Override public void run() { mTitleHeaderScrollView.fullScroll(ScrollView.FOCUS_DOWN); } }); } } }; @Override public int getMetricsCategory() { return SettingsEnums.CHOOSE_LOCK_PATTERN; } /** * The states of the left footer button. */ enum LeftButtonMode { Retry(R.string.lockpattern_retry_button_text, true), RetryDisabled(R.string.lockpattern_retry_button_text, false), Gone(ID_EMPTY_MESSAGE, false); /** * @param text The displayed text for this mode. * @param enabled Whether the button should be enabled. */ LeftButtonMode(int text, boolean enabled) { this.text = text; this.enabled = enabled; } final int text; final boolean enabled; } /** * The states of the right button. */ enum RightButtonMode { Continue(R.string.next_label, true), ContinueDisabled(R.string.next_label, false), Confirm(R.string.lockpattern_confirm_button_text, true), ConfirmDisabled(R.string.lockpattern_confirm_button_text, false), Ok(android.R.string.ok, true); /** * @param text The displayed text for this mode. * @param enabled Whether the button should be enabled. */ RightButtonMode(int text, boolean enabled) { this.text = text; this.enabled = enabled; } final int text; final boolean enabled; } /** * Keep track internally of where the user is in choosing a pattern. */ protected enum Stage { Introduction( R.string.lock_settings_picker_biometrics_added_security_message, R.string.lockpassword_choose_your_pattern_message, R.string.lockpattern_recording_intro_header, LeftButtonMode.Gone, RightButtonMode.ContinueDisabled, ID_EMPTY_MESSAGE, true), HelpScreen( ID_EMPTY_MESSAGE, ID_EMPTY_MESSAGE, R.string.lockpattern_settings_help_how_to_record, LeftButtonMode.Gone, RightButtonMode.Ok, ID_EMPTY_MESSAGE, false), ChoiceTooShort( R.string.lock_settings_picker_biometrics_added_security_message, R.string.lockpassword_choose_your_pattern_message, R.string.lockpattern_recording_incorrect_too_short, LeftButtonMode.Retry, RightButtonMode.ContinueDisabled, ID_EMPTY_MESSAGE, true), FirstChoiceValid( R.string.lock_settings_picker_biometrics_added_security_message, R.string.lockpassword_choose_your_pattern_message, R.string.lockpattern_pattern_entered_header, LeftButtonMode.Retry, RightButtonMode.Continue, ID_EMPTY_MESSAGE, false), NeedToConfirm( ID_EMPTY_MESSAGE, ID_EMPTY_MESSAGE, R.string.lockpattern_need_to_confirm, LeftButtonMode.Gone, RightButtonMode.ConfirmDisabled, ID_EMPTY_MESSAGE, true), ConfirmWrong( ID_EMPTY_MESSAGE, ID_EMPTY_MESSAGE, R.string.lockpattern_need_to_unlock_wrong, LeftButtonMode.Gone, RightButtonMode.ConfirmDisabled, ID_EMPTY_MESSAGE, true), ChoiceConfirmed( ID_EMPTY_MESSAGE, ID_EMPTY_MESSAGE, R.string.lockpattern_pattern_confirmed_header, LeftButtonMode.Gone, RightButtonMode.Confirm, ID_EMPTY_MESSAGE, false); /** * @param messageForBiometrics The message displayed at the top, above header for * fingerprint flow. * @param message The message displayed at the top. * @param headerMessage The message displayed at the top. * @param leftMode The mode of the left button. * @param rightMode The mode of the right button. * @param footerMessage The footer message. * @param patternEnabled Whether the pattern widget is enabled. */ Stage(int messageForBiometrics, int message, int headerMessage, LeftButtonMode leftMode, RightButtonMode rightMode, int footerMessage, boolean patternEnabled) { this.headerMessage = headerMessage; this.messageForBiometrics = messageForBiometrics; this.message = message; this.leftMode = leftMode; this.rightMode = rightMode; this.footerMessage = footerMessage; this.patternEnabled = patternEnabled; } final int headerMessage; final int messageForBiometrics; final int message; final LeftButtonMode leftMode; final RightButtonMode rightMode; final int footerMessage; final boolean patternEnabled; } private Stage mUiStage = Stage.Introduction; private Runnable mClearPatternRunnable = new Runnable() { public void run() { mLockPatternView.clearPattern(); } }; private ChooseLockSettingsHelper mChooseLockSettingsHelper; private SaveAndFinishWorker mSaveAndFinishWorker; protected int mUserId; protected boolean mForFingerprint; protected boolean mForFace; private static final String KEY_UI_STAGE = "uiStage"; private static final String KEY_PATTERN_CHOICE = "chosenPattern"; private static final String KEY_CURRENT_PATTERN = "currentPattern"; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); mChooseLockSettingsHelper = new ChooseLockSettingsHelper(getActivity()); if (!(getActivity() instanceof ChooseLockPattern)) { throw new SecurityException("Fragment contained in wrong activity"); } Intent intent = getActivity().getIntent(); // Only take this argument into account if it belongs to the current profile. mUserId = Utils.getUserIdFromBundle(getActivity(), intent.getExtras()); if (intent.getBooleanExtra( ChooseLockSettingsHelper.EXTRA_KEY_FOR_CHANGE_CRED_REQUIRED_FOR_BOOT, false)) { SaveAndFinishWorker w = new SaveAndFinishWorker(); final boolean required = getActivity().getIntent().getBooleanExtra( EncryptionInterstitial.EXTRA_REQUIRE_PASSWORD, true); LockscreenCredential current = intent.getParcelableExtra( ChooseLockSettingsHelper.EXTRA_KEY_PASSWORD); w.setBlocking(true); w.setListener(this); w.start(mChooseLockSettingsHelper.utils(), required, false, 0, current, current, mUserId); } mForFingerprint = intent.getBooleanExtra( ChooseLockSettingsHelper.EXTRA_KEY_FOR_FINGERPRINT, false); mForFace = intent.getBooleanExtra( ChooseLockSettingsHelper.EXTRA_KEY_FOR_FACE, false); } @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { final GlifLayout layout = (GlifLayout) inflater.inflate( R.layout.choose_lock_pattern, container, false); layout.setHeaderText(getActivity().getTitle()); if (getResources().getBoolean(R.bool.config_lock_pattern_minimal_ui)) { View iconView = layout.findViewById(R.id.sud_layout_icon); if (iconView != null) { iconView.setVisibility(View.GONE); } } else { if (mForFingerprint) { layout.setIcon(getActivity().getDrawable(R.drawable.ic_fingerprint_header)); } else if (mForFace) { layout.setIcon(getActivity().getDrawable(R.drawable.ic_face_header)); } } final FooterBarMixin mixin = layout.getMixin(FooterBarMixin.class); mixin.setSecondaryButton( new FooterButton.Builder(getActivity()) .setText(R.string.lockpattern_tutorial_cancel_label) .setListener(this::onSkipOrClearButtonClick) .setButtonType(FooterButton.ButtonType.OTHER) .setTheme(R.style.SudGlifButton_Secondary) .build() ); mixin.setPrimaryButton( new FooterButton.Builder(getActivity()) .setText(R.string.lockpattern_tutorial_continue_label) .setListener(this::onNextButtonClick) .setButtonType(FooterButton.ButtonType.NEXT) .setTheme(R.style.SudGlifButton_Primary) .build() ); mSkipOrClearButton = mixin.getSecondaryButton(); mNextButton = mixin.getPrimaryButton(); return layout; } @Override public void onViewCreated(View view, Bundle savedInstanceState) { super.onViewCreated(view, savedInstanceState); mTitleText = view.findViewById(R.id.suc_layout_title); mHeaderText = (TextView) view.findViewById(R.id.headerText); mDefaultHeaderColorList = mHeaderText.getTextColors(); mMessageText = view.findViewById(R.id.sud_layout_description); mLockPatternView = (LockPatternView) view.findViewById(R.id.lockPattern); mLockPatternView.setOnPatternListener(mChooseNewLockPatternListener); mLockPatternView.setTactileFeedbackEnabled( mChooseLockSettingsHelper.utils().isTactileFeedbackEnabled()); mLockPatternView.setFadePattern(false); mFooterText = (TextView) view.findViewById(R.id.footerText); mTitleHeaderScrollView = (ScrollView) view.findViewById(R.id .scroll_layout_title_header); // make it so unhandled touch events within the unlock screen go to the // lock pattern view. final LinearLayoutWithDefaultTouchRecepient topLayout = (LinearLayoutWithDefaultTouchRecepient) view.findViewById( R.id.topLayout); topLayout.setDefaultTouchRecepient(mLockPatternView); final boolean confirmCredentials = getActivity().getIntent() .getBooleanExtra(ChooseLockGeneric.CONFIRM_CREDENTIALS, true); Intent intent = getActivity().getIntent(); mCurrentCredential = intent.getParcelableExtra(ChooseLockSettingsHelper.EXTRA_KEY_PASSWORD); mHasChallenge = intent.getBooleanExtra( ChooseLockSettingsHelper.EXTRA_KEY_HAS_CHALLENGE, false); mChallenge = intent.getLongExtra(ChooseLockSettingsHelper.EXTRA_KEY_CHALLENGE, 0); if (savedInstanceState == null) { 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, getString(R.string.unlock_set_unlock_launch_picker_title), true, mUserId); if (!launchedConfirmationActivity) { updateStage(Stage.Introduction); } } else { updateStage(Stage.Introduction); } } else { // restore from previous state mChosenPattern = savedInstanceState.getParcelable(KEY_PATTERN_CHOICE); if (mCurrentCredential == null) { mCurrentCredential = savedInstanceState.getParcelable(KEY_CURRENT_PATTERN); } updateStage(Stage.values()[savedInstanceState.getInt(KEY_UI_STAGE)]); // Re-attach to the exiting worker if there is one. mSaveAndFinishWorker = (SaveAndFinishWorker) getFragmentManager().findFragmentByTag( FRAGMENT_TAG_SAVE_AND_FINISH); } } @Override public void onResume() { super.onResume(); updateStage(mUiStage); if (mSaveAndFinishWorker != null) { setRightButtonEnabled(false); mSaveAndFinishWorker.setListener(this); } } @Override public void onPause() { super.onPause(); if (mSaveAndFinishWorker != null) { mSaveAndFinishWorker.setListener(null); } } @Override public void onDestroy() { super.onDestroy(); if (mCurrentCredential != null) { mCurrentCredential.zeroize(); } // Force a garbage collection immediately to remove remnant of user password shards // from memory. System.gc(); System.runFinalization(); System.gc(); } protected Intent getRedactionInterstitialIntent(Context context) { return RedactionInterstitial.createStartIntent(context, mUserId); } public void handleLeftButton() { if (mUiStage.leftMode == LeftButtonMode.Retry) { if (mChosenPattern != null) { mChosenPattern.zeroize(); mChosenPattern = null; } mLockPatternView.clearPattern(); updateStage(Stage.Introduction); } else { throw new IllegalStateException("left footer button pressed, but stage of " + mUiStage + " doesn't make sense"); } } public void handleRightButton() { if (mUiStage.rightMode == RightButtonMode.Continue) { if (mUiStage != Stage.FirstChoiceValid) { throw new IllegalStateException("expected ui stage " + Stage.FirstChoiceValid + " when button is " + RightButtonMode.Continue); } updateStage(Stage.NeedToConfirm); } else if (mUiStage.rightMode == RightButtonMode.Confirm) { if (mUiStage != Stage.ChoiceConfirmed) { throw new IllegalStateException("expected ui stage " + Stage.ChoiceConfirmed + " when button is " + RightButtonMode.Confirm); } startSaveAndFinish(); } else if (mUiStage.rightMode == RightButtonMode.Ok) { if (mUiStage != Stage.HelpScreen) { throw new IllegalStateException("Help screen is only mode with ok button, " + "but stage is " + mUiStage); } mLockPatternView.clearPattern(); mLockPatternView.setDisplayMode(DisplayMode.Correct); updateStage(Stage.Introduction); } } protected void onSkipOrClearButtonClick(View view) { handleLeftButton(); } protected void onNextButtonClick(View view) { handleRightButton(); } public boolean onKeyDown(int keyCode, KeyEvent event) { if (keyCode == KeyEvent.KEYCODE_BACK && event.getRepeatCount() == 0) { if (mUiStage == Stage.HelpScreen) { updateStage(Stage.Introduction); return true; } } if (keyCode == KeyEvent.KEYCODE_MENU && mUiStage == Stage.Introduction) { updateStage(Stage.HelpScreen); return true; } return false; } public void onSaveInstanceState(Bundle outState) { super.onSaveInstanceState(outState); outState.putInt(KEY_UI_STAGE, mUiStage.ordinal()); if (mChosenPattern != null) { outState.putParcelable(KEY_PATTERN_CHOICE, mChosenPattern); } if (mCurrentCredential != null) { outState.putParcelable(KEY_CURRENT_PATTERN, mCurrentCredential); } } /** * Updates the messages and buttons appropriate to what stage the user * is at in choosing a view. This doesn't handle clearing out the pattern; * the pattern is expected to be in the right state. * @param stage */ protected void updateStage(Stage stage) { final Stage previousStage = mUiStage; mUiStage = stage; // header text, footer text, visibility and // enabled state all known from the stage if (stage == Stage.ChoiceTooShort) { mHeaderText.setText( getResources().getString( stage.headerMessage, LockPatternUtils.MIN_LOCK_PATTERN_SIZE)); } else { mHeaderText.setText(stage.headerMessage); } final boolean forBiometrics = mForFingerprint || mForFace; int message = forBiometrics ? stage.messageForBiometrics : stage.message; if (message == ID_EMPTY_MESSAGE) { mMessageText.setText(""); } else { mMessageText.setText(message); } if (stage.footerMessage == ID_EMPTY_MESSAGE) { mFooterText.setText(""); } else { mFooterText.setText(stage.footerMessage); } if (stage == Stage.ConfirmWrong || stage == Stage.ChoiceTooShort) { TypedValue typedValue = new TypedValue(); Theme theme = getActivity().getTheme(); theme.resolveAttribute(R.attr.colorError, typedValue, true); mHeaderText.setTextColor(typedValue.data); } else { if (mDefaultHeaderColorList != null) { mHeaderText.setTextColor(mDefaultHeaderColorList); } if (stage == Stage.NeedToConfirm && forBiometrics) { mHeaderText.setText(""); mTitleText.setText(R.string.lockpassword_draw_your_pattern_again_header); } } updateFooterLeftButton(stage); setRightButtonText(stage.rightMode.text); setRightButtonEnabled(stage.rightMode.enabled); // same for whether the pattern is enabled if (stage.patternEnabled) { mLockPatternView.enableInput(); } else { mLockPatternView.disableInput(); } // the rest of the stuff varies enough that it is easier just to handle // on a case by case basis. mLockPatternView.setDisplayMode(DisplayMode.Correct); boolean announceAlways = false; switch (mUiStage) { case Introduction: mLockPatternView.clearPattern(); break; case HelpScreen: mLockPatternView.setPattern(DisplayMode.Animate, mAnimatePattern); break; case ChoiceTooShort: mLockPatternView.setDisplayMode(DisplayMode.Wrong); postClearPatternRunnable(); announceAlways = true; break; case FirstChoiceValid: break; case NeedToConfirm: mLockPatternView.clearPattern(); break; case ConfirmWrong: mLockPatternView.setDisplayMode(DisplayMode.Wrong); postClearPatternRunnable(); announceAlways = true; break; case ChoiceConfirmed: break; } // If the stage changed, announce the header for accessibility. This // is a no-op when accessibility is disabled. if (previousStage != stage || announceAlways) { mHeaderText.announceForAccessibility(mHeaderText.getText()); } } protected void updateFooterLeftButton(Stage stage) { if (stage.leftMode == LeftButtonMode.Gone) { mSkipOrClearButton.setVisibility(View.GONE); } else { mSkipOrClearButton.setVisibility(View.VISIBLE); mSkipOrClearButton.setText(getActivity(), stage.leftMode.text); mSkipOrClearButton.setEnabled(stage.leftMode.enabled); } } // clear the wrong pattern unless they have started a new one // already private void postClearPatternRunnable() { mLockPatternView.removeCallbacks(mClearPatternRunnable); mLockPatternView.postDelayed(mClearPatternRunnable, WRONG_PATTERN_CLEAR_TIMEOUT_MS); } private void startSaveAndFinish() { if (mSaveAndFinishWorker != null) { Log.w(TAG, "startSaveAndFinish with an existing SaveAndFinishWorker."); return; } setRightButtonEnabled(false); mSaveAndFinishWorker = new SaveAndFinishWorker(); mSaveAndFinishWorker.setListener(this); getFragmentManager().beginTransaction().add(mSaveAndFinishWorker, FRAGMENT_TAG_SAVE_AND_FINISH).commit(); getFragmentManager().executePendingTransactions(); final Intent intent = getActivity().getIntent(); final boolean required = intent.getBooleanExtra( EncryptionInterstitial.EXTRA_REQUIRE_PASSWORD, true); if (intent.hasExtra(EXTRA_KEY_UNIFICATION_PROFILE_ID)) { try (LockscreenCredential profileCredential = (LockscreenCredential) intent.getParcelableExtra(EXTRA_KEY_UNIFICATION_PROFILE_CREDENTIAL)) { mSaveAndFinishWorker.setProfileToUnify( intent.getIntExtra(EXTRA_KEY_UNIFICATION_PROFILE_ID, UserHandle.USER_NULL), profileCredential); } } mSaveAndFinishWorker.start(mChooseLockSettingsHelper.utils(), required, mHasChallenge, mChallenge, mChosenPattern, mCurrentCredential, mUserId); } @Override public void onChosenLockSaveFinished(boolean wasSecureBefore, Intent resultData) { getActivity().setResult(RESULT_FINISHED, resultData); if (mChosenPattern != null) { mChosenPattern.zeroize(); } if (mCurrentCredential != null) { mCurrentCredential.zeroize(); } if (!wasSecureBefore) { Intent intent = getRedactionInterstitialIntent(getActivity()); if (intent != null) { startActivity(intent); } } getActivity().finish(); } } public static class SaveAndFinishWorker extends SaveChosenLockWorkerBase { private LockscreenCredential mChosenPattern; private LockscreenCredential mCurrentCredential; private boolean mLockVirgin; public void start(LockPatternUtils utils, boolean credentialRequired, boolean hasChallenge, long challenge, LockscreenCredential chosenPattern, LockscreenCredential currentCredential, int userId) { prepare(utils, credentialRequired, hasChallenge, challenge, userId); mCurrentCredential = currentCredential != null ? currentCredential : LockscreenCredential.createNone(); mChosenPattern = chosenPattern; mUserId = userId; mLockVirgin = !mUtils.isPatternEverChosen(mUserId); start(); } @Override protected Pair saveAndVerifyInBackground() { final int userId = mUserId; final boolean success = mUtils.setLockCredential(mChosenPattern, mCurrentCredential, userId); if (success) { unifyProfileCredentialIfRequested(); } Intent result = null; if (success && mHasChallenge) { byte[] token; try { token = mUtils.verifyCredential(mChosenPattern, mChallenge, userId); } catch (RequestThrottledException e) { token = null; } if (token == null) { Log.e(TAG, "critical: no token returned for known good pattern"); } result = new Intent(); result.putExtra(ChooseLockSettingsHelper.EXTRA_KEY_CHALLENGE_TOKEN, token); } return Pair.create(success, result); } @Override protected void finish(Intent resultData) { if (mLockVirgin) { mUtils.setVisiblePatternEnabled(true, mUserId); } super.finish(resultData); } } }