The Tor Browser: comparison mobile/android/base/fxa/activities/FxAccountAbstractSetupActivity.java

--1:000000000000
+:a4c97fa78268
+/* This Source Code Form is subject to the terms of the Mozilla Public
+* License, v. 2.0. If a copy of the MPL was not distributed with this
+* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+package org.mozilla.gecko.fxa.activities;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import org.mozilla.gecko.R;
+import org.mozilla.gecko.background.common.log.Logger;
+import org.mozilla.gecko.background.fxa.FxAccountClient10.RequestDelegate;
+import org.mozilla.gecko.background.fxa.FxAccountClient20.LoginResponse;
+import org.mozilla.gecko.background.fxa.FxAccountClientException.FxAccountClientRemoteException;
+import org.mozilla.gecko.background.fxa.FxAccountUtils;
+import org.mozilla.gecko.background.fxa.PasswordStretcher;
+import org.mozilla.gecko.background.fxa.QuickPasswordStretcher;
+import org.mozilla.gecko.fxa.FxAccountConstants;
+import org.mozilla.gecko.fxa.activities.FxAccountSetupTask.ProgressDisplay;
+import org.mozilla.gecko.fxa.authenticator.AndroidFxAccount;
+import org.mozilla.gecko.fxa.login.Engaged;
+import org.mozilla.gecko.fxa.login.State;
+import org.mozilla.gecko.sync.SyncConfiguration;
+import org.mozilla.gecko.sync.setup.Constants;
+import org.mozilla.gecko.sync.setup.activities.ActivityUtils;
+import android.accounts.Account;
+import android.accounts.AccountManager;
+import android.content.Context;
+import android.content.Intent;
+import android.os.AsyncTask;
+import android.text.Editable;
+import android.text.TextWatcher;
+import android.text.method.PasswordTransformationMethod;
+import android.text.method.SingleLineTransformationMethod;
+import android.util.Patterns;
+import android.view.KeyEvent;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.view.View.OnFocusChangeListener;
+import android.widget.ArrayAdapter;
+import android.widget.AutoCompleteTextView;
+import android.widget.Button;
+import android.widget.EditText;
+import android.widget.ProgressBar;
+import android.widget.TextView;
+import android.widget.TextView.OnEditorActionListener;
+abstract public class FxAccountAbstractSetupActivity extends FxAccountAbstractActivity implements ProgressDisplay {
+public FxAccountAbstractSetupActivity() {
+super(CANNOT_RESUME_WHEN_ACCOUNTS_EXIST | CANNOT_RESUME_WHEN_LOCKED_OUT);
+}
+protected FxAccountAbstractSetupActivity(int resume) {
+super(resume);
+}
+private static final String LOG_TAG = FxAccountAbstractSetupActivity.class.getSimpleName();
+protected int minimumPasswordLength = 8;
+protected AutoCompleteTextView emailEdit;
+protected EditText passwordEdit;
+protected Button showPasswordButton;
+protected TextView remoteErrorTextView;
+protected Button button;
+protected ProgressBar progressBar;
+protected void createShowPasswordButton() {
+showPasswordButton.setOnClickListener(new OnClickListener() {
+@SuppressWarnings("deprecation")
+@Override
+public void onClick(View v) {
+boolean isShown = passwordEdit.getTransformationMethod() instanceof SingleLineTransformationMethod;
+// Changing input type loses position in edit text; let's try to maintain it.
+int start = passwordEdit.getSelectionStart();
+int stop = passwordEdit.getSelectionEnd();
+if (isShown) {
+passwordEdit.setTransformationMethod(PasswordTransformationMethod.getInstance());
+showPasswordButton.setText(R.string.fxaccount_password_show);
+showPasswordButton.setBackgroundDrawable(getResources().getDrawable(R.drawable.fxaccount_password_button_show_background));
+showPasswordButton.setTextColor(getResources().getColor(R.color.fxaccount_password_show_textcolor));
+} else {
+passwordEdit.setTransformationMethod(SingleLineTransformationMethod.getInstance());
+showPasswordButton.setText(R.string.fxaccount_password_hide);
+showPasswordButton.setBackgroundDrawable(getResources().getDrawable(R.drawable.fxaccount_password_button_hide_background));
+showPasswordButton.setTextColor(getResources().getColor(R.color.fxaccount_password_hide_textcolor));
+}
+passwordEdit.setSelection(start, stop);
+}
+});
+}
+protected void linkifyPolicy() {
+TextView policyView = (TextView) ensureFindViewById(null, R.id.policy, "policy links");
+final String linkTerms = getString(R.string.fxaccount_link_tos);
+final String linkPrivacy = getString(R.string.fxaccount_link_pn);
+final String linkedTOS = "<a href=\"" + linkTerms + "\">" + getString(R.string.fxaccount_policy_linktos) + "</a>";
+final String linkedPN = "<a href=\"" + linkPrivacy + "\">" + getString(R.string.fxaccount_policy_linkprivacy) + "</a>";
+policyView.setText(getString(R.string.fxaccount_create_account_policy_text, linkedTOS, linkedPN));
+final boolean underlineLinks = true;
+ActivityUtils.linkifyTextView(policyView, underlineLinks);
+}
+protected void hideRemoteError() {
+remoteErrorTextView.setVisibility(View.INVISIBLE);
+}
+protected void showRemoteError(Exception e, int defaultResourceId) {
+if (e instanceof IOException) {
+remoteErrorTextView.setText(R.string.fxaccount_remote_error_COULD_NOT_CONNECT);
+} else if (e instanceof FxAccountClientRemoteException) {
+showClientRemoteException((FxAccountClientRemoteException) e);
+} else {
+remoteErrorTextView.setText(defaultResourceId);
+}
+Logger.warn(LOG_TAG, "Got exception; showing error message: " + remoteErrorTextView.getText().toString(), e);
+remoteErrorTextView.setVisibility(View.VISIBLE);
+}
+protected void showClientRemoteException(final FxAccountClientRemoteException e) {
+remoteErrorTextView.setText(e.getErrorMessageStringResource());
+}
+protected void addListeners() {
+TextChangedListener textChangedListener = new TextChangedListener();
+EditorActionListener editorActionListener = new EditorActionListener();
+FocusChangeListener focusChangeListener = new FocusChangeListener();
+emailEdit.addTextChangedListener(textChangedListener);
+emailEdit.setOnEditorActionListener(editorActionListener);
+emailEdit.setOnFocusChangeListener(focusChangeListener);
+passwordEdit.addTextChangedListener(textChangedListener);
+passwordEdit.setOnEditorActionListener(editorActionListener);
+passwordEdit.setOnFocusChangeListener(focusChangeListener);
+}
+protected class FocusChangeListener implements OnFocusChangeListener {
+@Override
+public void onFocusChange(View v, boolean hasFocus) {
+if (hasFocus) {
+return;
+}
+updateButtonState();
+}
+}
+protected class EditorActionListener implements OnEditorActionListener {
+@Override
+public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
+updateButtonState();
+return false;
+}
+}
+protected class TextChangedListener implements TextWatcher {
+@Override
+public void afterTextChanged(Editable s) {
+updateButtonState();
+}
+@Override
+public void beforeTextChanged(CharSequence s, int start, int count, int after) {
+// Do nothing.
+}
+@Override
+public void onTextChanged(CharSequence s, int start, int before, int count) {
+// Do nothing.
+}
+}
+protected boolean shouldButtonBeEnabled() {
+final String email = emailEdit.getText().toString();
+final String password = passwordEdit.getText().toString();
+boolean enabled =
+(email.length() > 0) &&
+Patterns.EMAIL_ADDRESS.matcher(email).matches() &&
+(password.length() >= minimumPasswordLength);
+return enabled;
+}
+protected boolean updateButtonState() {
+boolean enabled = shouldButtonBeEnabled();
+if (!enabled) {
+// The user needs to do something before you can interact with the button;
+// presumably that interaction will fix whatever error is shown.
+hideRemoteError();
+}
+if (enabled != button.isEnabled()) {
+Logger.debug(LOG_TAG, (enabled ? "En" : "Dis") + "abling button.");
+button.setEnabled(enabled);
+}
+return enabled;
+}
+@Override
+public void showProgress() {
+progressBar.setVisibility(View.VISIBLE);
+button.setVisibility(View.INVISIBLE);
+}
+@Override
+public void dismissProgress() {
+progressBar.setVisibility(View.INVISIBLE);
+button.setVisibility(View.VISIBLE);
+}
+public Intent makeSuccessIntent(String email, LoginResponse result) {
+Intent successIntent;
+if (result.verified) {
+successIntent = new Intent(this, FxAccountVerifiedAccountActivity.class);
+} else {
+successIntent = new Intent(this, FxAccountConfirmAccountActivity.class);
+}
+// Per http://stackoverflow.com/a/8992365, this triggers a known bug with
+// the soft keyboard not being shown for the started activity. Why, Android, why?
+successIntent.setFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION);
+return successIntent;
+}
+protected abstract class AddAccountDelegate implements RequestDelegate<LoginResponse> {
+public final String email;
+public final PasswordStretcher passwordStretcher;
+public final String serverURI;
+public final Map<String, Boolean> selectedEngines;
+public AddAccountDelegate(String email, PasswordStretcher passwordStretcher, String serverURI) {
+this(email, passwordStretcher, serverURI, null);
+}
+public AddAccountDelegate(String email, PasswordStretcher passwordStretcher, String serverURI, Map<String, Boolean> selectedEngines) {
+if (email == null) {
+throw new IllegalArgumentException("email must not be null");
+}
+if (passwordStretcher == null) {
+throw new IllegalArgumentException("passwordStretcher must not be null");
+}
+if (serverURI == null) {
+throw new IllegalArgumentException("serverURI must not be null");
+}
+this.email = email;
+this.passwordStretcher = passwordStretcher;
+this.serverURI = serverURI;
+// selectedEngines can be null, which means don't write
+// userSelectedEngines to prefs. This makes any created meta/global record
+// have the default set of engines to sync.
+this.selectedEngines = selectedEngines;
+}
+@Override
+public void handleSuccess(LoginResponse result) {
+Logger.info(LOG_TAG, "Got success response; adding Android account.");
+// We're on the UI thread, but it's okay to create the account here.
+AndroidFxAccount fxAccount;
+try {
+final String profile = Constants.DEFAULT_PROFILE;
+final String tokenServerURI = FxAccountConstants.DEFAULT_TOKEN_SERVER_ENDPOINT;
+// It is crucial that we use the email address provided by the server
+// (rather than whatever the user entered), because the user's keys are
+// wrapped and salted with the initial email they provided to
+// /create/account. Of course, we want to pass through what the user
+// entered locally as much as possible, so we create the Android account
+// with their entered email address, etc.
+// The passwordStretcher should have seen this email address before, so
+// we shouldn't be calculating the expensive stretch twice.
+byte[] quickStretchedPW = passwordStretcher.getQuickStretchedPW(result.remoteEmail.getBytes("UTF-8"));
+byte[] unwrapkB = FxAccountUtils.generateUnwrapBKey(quickStretchedPW);
+State state = new Engaged(email, result.uid, result.verified, unwrapkB, result.sessionToken, result.keyFetchToken);
+fxAccount = AndroidFxAccount.addAndroidAccount(getApplicationContext(),
+email,
+profile,
+serverURI,
+tokenServerURI,
+state);
+if (fxAccount == null) {
+throw new RuntimeException("Could not add Android account.");
+}
+if (selectedEngines != null) {
+Logger.info(LOG_TAG, "User has selected engines; storing to prefs.");
+SyncConfiguration.storeSelectedEnginesToPrefs(fxAccount.getSyncPrefs(), selectedEngines);
+}
+} catch (Exception e) {
+handleError(e);
+return;
+}
+// For great debugging.
+if (FxAccountConstants.LOG_PERSONAL_INFORMATION) {
+fxAccount.dump();
+}
+// The GetStarted activity has called us and needs to return a result to the authenticator.
+final Intent intent = new Intent();
+intent.putExtra(AccountManager.KEY_ACCOUNT_NAME, email);
+intent.putExtra(AccountManager.KEY_ACCOUNT_TYPE, FxAccountConstants.ACCOUNT_TYPE);
+// intent.putExtra(AccountManager.KEY_AUTHTOKEN, accountType);
+setResult(RESULT_OK, intent);
+// Show success activity depending on verification status.
+Intent successIntent = makeSuccessIntent(email, result);
+startActivity(successIntent);
+finish();
+}
+}
+/**
+* Factory function that produces a new PasswordStretcher instance.
+*
+* @return PasswordStretcher instance.
+*/
+protected PasswordStretcher makePasswordStretcher(String password) {
+return new QuickPasswordStretcher(password);
+}
+protected abstract static class GetAccountsAsyncTask extends AsyncTask<Void, Void, Account[]> {
+protected final Context context;
+public GetAccountsAsyncTask(Context context) {
+super();
+this.context = context;
+}
+@Override
+protected Account[] doInBackground(Void... params) {
+return AccountManager.get(context).getAccounts();
+}
+}
+/**
+* This updates UI, so needs to be done on the foreground thread.
+*/
+protected void populateEmailAddressAutocomplete(Account[] accounts) {
+// First a set, since we don't want repeats.
+final Set<String> emails = new HashSet<String>();
+for (Account account : accounts) {
+if (!Patterns.EMAIL_ADDRESS.matcher(account.name).matches()) {
+continue;
+}
+emails.add(account.name);
+}
+// And then sorted in alphabetical order.
+final String[] sortedEmails = emails.toArray(new String[0]);
+Arrays.sort(sortedEmails);
+final ArrayAdapter<String> adapter = new ArrayAdapter<String>(this, android.R.layout.simple_dropdown_item_1line, sortedEmails);
+emailEdit.setAdapter(adapter);
+}
+@Override
+public void onResume() {
+super.onResume();
+// Getting Accounts accesses databases on disk, so needs to be done on a
+// background thread.
+final GetAccountsAsyncTask task = new GetAccountsAsyncTask(this) {
+@Override
+public void onPostExecute(Account[] accounts) {
+populateEmailAddressAutocomplete(accounts);
+}
+};
+task.execute();
+}
+}

The Tor Browser / file comparison

comparison: mobile/android/base/fxa/activities/FxAccountAbstractSetupActivity.java

mobile/android/base/fxa/activities/FxAccountAbstractSetupActivity.java