Merge tag 'android-6.0.0_r26' into HEAD

Android 6.0.0 release 26

Conflicts:
	res/values-fr/strings.xml
	res/values-it/strings.xml
	res/values-ja/strings.xml
	res/values-nl/strings.xml
	res/values-pl/strings.xml
	res/values-ro/strings.xml
	res/values-ru/strings.xml
	res/values-zh-rCN/strings.xml
	res/values/bools.xml
	res/values/strings.xml
	res/xml/development_prefs.xml
	src/com/android/settings/DevelopmentSettings.java
	src/com/android/settings/DeviceInfoSettings.java
	src/com/android/settings/DisplaySettings.java

Change-Id: I9fd9e793cf6097d950f8a1e30771c8bdf5067906

1 files changed, 88 insertions, 69 deletions

diff --git a/src/com/android/settings/ChooseLockPattern.java b/src/com/android/settings/ChooseLockPattern.java
index 087a23edf..1dd24f206 100644
--- a/src/com/android/settings/ChooseLockPattern.java
+++ b/src/com/android/settings/ChooseLockPattern.java
@@ -19,8 +19,8 @@ package com.android.settings;
 import com.android.internal.logging.MetricsLogger;
 import com.google.android.collect.Lists;
 import com.android.internal.widget.LinearLayoutWithDefaultTouchRecepient;
-import com.android.internal.widget.LockPatternChecker;
 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.settings.notification.RedactionInterstitial;
@@ -31,7 +31,6 @@ import android.app.Activity;
 import android.app.Fragment;
 import android.content.Context;
 import android.content.Intent;
-import android.os.AsyncTask;
 import android.os.Bundle;
 import android.os.UserHandle;
 import android.util.Log;
@@ -125,7 +124,7 @@ public class ChooseLockPattern extends SettingsActivity {
     }
 
     public static class ChooseLockPatternFragment extends InstrumentedFragment
-            implements View.OnClickListener {
+            implements View.OnClickListener, SaveAndFinishWorker.Listener {
 
         public static final int CONFIRM_EXISTING_REQUEST = 55;
 
@@ -137,6 +136,8 @@ public class ChooseLockPattern extends SettingsActivity {
 
         private static final int ID_EMPTY_MESSAGE = -1;
 
+        private static final String FRAGMENT_TAG_SAVE_AND_FINISH = "save_and_finish_worker";
+
         private String mCurrentPattern;
         private boolean mHasChallenge;
         private long mChallenge;
@@ -346,7 +347,6 @@ public class ChooseLockPattern extends SettingsActivity {
         }
 
         private Stage mUiStage = Stage.Introduction;
-        private boolean mDone = false;
 
         private Runnable mClearPatternRunnable = new Runnable() {
             public void run() {
@@ -355,7 +355,7 @@ public class ChooseLockPattern extends SettingsActivity {
         };
 
         private ChooseLockSettingsHelper mChooseLockSettingsHelper;
-        private AsyncTask<?, ?, ?> mPendingLockCheck;
+        private SaveAndFinishWorker mSaveAndFinishWorker;
 
         private static final String KEY_UI_STAGE = "uiStage";
         private static final String KEY_PATTERN_CHOICE = "chosenPattern";
@@ -434,22 +434,29 @@ public class ChooseLockPattern extends SettingsActivity {
                     mCurrentPattern = savedInstanceState.getString(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);
             }
-            mDone = false;
         }
 
         @Override
         public void onResume() {
             super.onResume();
-            mLockPatternView.enableInput();
+            updateStage(mUiStage);
+
+            if (mSaveAndFinishWorker != null) {
+                setRightButtonEnabled(false);
+                mSaveAndFinishWorker.setListener(this);
+            }
         }
 
         @Override
         public void onPause() {
             super.onPause();
-            if (mPendingLockCheck != null) {
-                mPendingLockCheck.cancel(false);
-                mPendingLockCheck = null;
+            if (mSaveAndFinishWorker != null) {
+                mSaveAndFinishWorker.setListener(null);
             }
         }
 
@@ -483,7 +490,7 @@ public class ChooseLockPattern extends SettingsActivity {
                     throw new IllegalStateException("expected ui stage " + Stage.ChoiceConfirmed
                             + " when button is " + RightButtonMode.Confirm);
                 }
-                saveChosenPatternAndFinish();
+                startSaveAndFinish();
             } else if (mUiStage.rightMode == RightButtonMode.Ok) {
                 if (mUiStage != Stage.HelpScreen) {
                     throw new IllegalStateException("Help screen is only mode with ok button, "
@@ -570,7 +577,7 @@ public class ChooseLockPattern extends SettingsActivity {
             setRightButtonText(stage.rightMode.text);
             setRightButtonEnabled(stage.rightMode.enabled);
 
-            // same for whether the patten is enabled
+            // same for whether the pattern is enabled
             if (stage.patternEnabled) {
                 mLockPatternView.enableInput();
             } else {
@@ -615,7 +622,6 @@ public class ChooseLockPattern extends SettingsActivity {
             }
         }
 
-
         // clear the wrong pattern unless they have started a new one
         // already
         private void postClearPatternRunnable() {
@@ -623,77 +629,90 @@ public class ChooseLockPattern extends SettingsActivity {
             mLockPatternView.postDelayed(mClearPatternRunnable, WRONG_PATTERN_CLEAR_TIMEOUT_MS);
         }
 
-        private void saveChosenPatternAndFinish() {
-            if (mDone) return;
-            LockPatternUtils utils = mChooseLockSettingsHelper.utils();
-            final boolean lockVirgin = !utils.isPatternEverChosen(UserHandle.myUserId());
+        private void startSaveAndFinish() {
+            if (mSaveAndFinishWorker != null) {
+                Log.w(TAG, "startSaveAndFinish with an existing SaveAndFinishWorker.");
+                return;
+            }
+
+            setRightButtonEnabled(false);
 
-            boolean wasSecureBefore = utils.isSecure(UserHandle.myUserId());
+            mSaveAndFinishWorker = new SaveAndFinishWorker();
+            getFragmentManager().beginTransaction().add(mSaveAndFinishWorker,
+                    FRAGMENT_TAG_SAVE_AND_FINISH).commit();
+            mSaveAndFinishWorker.setListener(this);
 
             final boolean required = getActivity().getIntent().getBooleanExtra(
                     EncryptionInterstitial.EXTRA_REQUIRE_PASSWORD, true);
+            mSaveAndFinishWorker.start(mChooseLockSettingsHelper.utils(), required,
+                    mHasChallenge, mChallenge, mChosenPattern, mCurrentPattern);
+        }
 
-            utils.setCredentialRequiredToDecrypt(required);
-            utils.saveLockPattern(mChosenPattern, mCurrentPattern, UserHandle.myUserId());
+        @Override
+        public void onChosenLockSaveFinished(boolean wasSecureBefore, Intent resultData) {
+            getActivity().setResult(RESULT_FINISHED, resultData);
+            getActivity().finish();
 
-            if (lockVirgin) {
-                utils.setVisiblePatternEnabled(true, UserHandle.myUserId());
+            if (!wasSecureBefore) {
+                Intent intent = getRedactionInterstitialIntent(getActivity());
+                if (intent != null) {
+                    startActivity(intent);
+                }
             }
+        }
+    }
+
+    private static class SaveAndFinishWorker extends SaveChosenLockWorkerBase {
+
+        private List<LockPatternView.Cell> mChosenPattern;
+        private String mCurrentPattern;
+        private boolean mLockVirgin;
+
+        public void start(LockPatternUtils utils, boolean credentialRequired,
+                boolean hasChallenge, long challenge,
+                List<LockPatternView.Cell> chosenPattern, String currentPattern) {
+            prepare(utils, credentialRequired, hasChallenge, challenge);
+
+            mCurrentPattern = currentPattern;
+            mChosenPattern = chosenPattern;
+
+            mLockVirgin = !mUtils.isPatternEverChosen(UserHandle.myUserId());
+
+            start();
+        }
+
+        @Override
+        protected Intent saveAndVerifyInBackground() {
+            Intent result = null;
+            final int userId = UserHandle.myUserId();
+            mUtils.saveLockPattern(mChosenPattern, mCurrentPattern, userId);
 
             if (mHasChallenge) {
-                startVerifyPattern(utils, wasSecureBefore);
-            } else {
-                if (!wasSecureBefore) {
-                    Intent intent = getRedactionInterstitialIntent(getActivity());
-                    if (intent != null) {
-                        startActivity(intent);
-                    }
+                byte[] token;
+                try {
+                    token = mUtils.verifyPattern(mChosenPattern, mChallenge, userId);
+                } catch (RequestThrottledException e) {
+                    token = null;
+                }
+
+                if (token == null) {
+                    Log.e(TAG, "critical: no token returned for known good pattern");
                 }
-                getActivity().setResult(RESULT_FINISHED);
-                doFinish();
-            }
-        }
 
-        private void startVerifyPattern(LockPatternUtils utils, final boolean wasSecureBefore) {
-            mLockPatternView.disableInput();
-            if (mPendingLockCheck != null) {
-                mPendingLockCheck.cancel(false);
+                result = new Intent();
+                result.putExtra(ChooseLockSettingsHelper.EXTRA_KEY_CHALLENGE_TOKEN, token);
             }
 
-            mPendingLockCheck = LockPatternChecker.verifyPattern(
-                    utils,
-                    mChosenPattern,
-                    mChallenge,
-                    UserHandle.myUserId(),
-                    new LockPatternChecker.OnVerifyCallback() {
-                        @Override
-                        public void onVerified(byte[] token, int timeoutMs) {
-                            if (token == null) {
-                                Log.e(TAG, "critical: no token returned for known good pattern");
-                            }
-
-                            mLockPatternView.enableInput();
-                            mPendingLockCheck = null;
-
-                            if (!wasSecureBefore) {
-                                Intent intent = getRedactionInterstitialIntent(getActivity());
-                                if (intent != null) {
-                                    startActivity(intent);
-                                }
-                            }
-
-                            Intent intent = new Intent();
-                            intent.putExtra(
-                                    ChooseLockSettingsHelper.EXTRA_KEY_CHALLENGE_TOKEN, token);
-                            getActivity().setResult(RESULT_FINISHED, intent);
-                            doFinish();
-                        }
-                    });
+            return result;
         }
 
-        private void doFinish() {
-            getActivity().finish();
-            mDone = true;
+        @Override
+        protected void finish(Intent resultData) {
+            if (mLockVirgin) {
+                mUtils.setVisiblePatternEnabled(true, UserHandle.myUserId());
+            }
+
+            super.finish(resultData);
         }
     }
 }