/*
* Copyright (C) 2014 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.email.activity.setup;
import android.accounts.AccountAuthenticatorResponse;
import android.accounts.AccountManager;
import android.app.ActionBar;
import android.app.ActivityManager;
import android.app.AlertDialog;
import android.app.Dialog;
import android.app.DialogFragment;
import android.app.Fragment;
import android.app.FragmentManager;
import android.app.FragmentTransaction;
import android.app.LoaderManager;
import android.app.ProgressDialog;
import android.content.Context;
import android.content.CursorLoader;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.Loader;
import android.database.Cursor;
import android.os.Bundle;
import android.provider.ContactsContract;
import android.support.annotation.NonNull;
import android.text.TextUtils;
import android.view.View;
import android.view.inputmethod.InputMethodManager;
import android.widget.Toast;
import com.android.email.R;
import com.android.email.setup.AuthenticatorSetupIntentHelper;
import com.android.email.service.EmailServiceUtils;
import com.android.emailcommon.VendorPolicyLoader;
import com.android.emailcommon.provider.Account;
import com.android.emailcommon.provider.HostAuth;
import com.android.emailcommon.service.SyncWindow;
import com.android.mail.analytics.Analytics;
import com.android.mail.providers.MailAppProvider;
import com.android.mail.providers.UIProvider;
import com.android.mail.utils.LogUtils;
import java.net.URISyntaxException;
import java.util.HashMap;
import java.util.Map;
public class AccountSetupFinal extends AccountSetupActivity
implements AccountFinalizeFragment.Callback,
AccountSetupNoteDialogFragment.Callback, AccountCreationFragment.Callback,
AccountCheckSettingsFragment.Callback, SecurityRequiredDialogFragment.Callback,
CheckSettingsErrorDialogFragment.Callback, CheckSettingsProgressDialogFragment.Callback,
AccountSetupTypeFragment.Callback, AccountSetupNamesFragment.Callback,
AccountSetupOptionsFragment.Callback, AccountSetupBasicsFragment.Callback,
AccountServerBaseFragment.Callback, AccountSetupCredentialsFragment.Callback,
DuplicateAccountDialogFragment.Callback, AccountSetupABFragment.Callback {
/**
* Direct access for forcing account creation
* For use by continuous automated test system (e.g. in conjunction with monkey tests)
*
* === Support for automated testing ==
* This activity can also be launched directly via INTENT_FORCE_CREATE_ACCOUNT. This is intended
* only for use by continuous test systems, and is currently only available when
* {@link ActivityManager#isRunningInTestHarness()} is set. To use this mode, you must
* construct an intent which contains all necessary information to create the account. No
* connection checking is done, so the account may or may not actually work. Here is a sample
* command, for a gmail account "test_account" with a password of "test_password".
*
* $ adb shell am start -a com.android.email.FORCE_CREATE_ACCOUNT \
* -e EMAIL test_account@gmail.com \
* -e USER "Test Account Name" \
* -e INCOMING imap+ssl+://test_account:test_password@imap.gmail.com \
* -e OUTGOING smtp+ssl+://test_account:test_password@smtp.gmail.com
*
* Note: For accounts that require the full email address in the login, encode the @ as %40.
* Note: Exchange accounts that require device security policies cannot be created
* automatically.
*
* For accounts that correspond to services in providers.xml you can also use the following form
*
* $adb shell am start -a com.android.email.FORCE_CREATE_ACCOUNT \
* -e EMAIL test_account@gmail.com \
* -e PASSWORD test_password
*
* and the appropriate incoming/outgoing information will be filled in automatically.
*/
private static String INTENT_FORCE_CREATE_ACCOUNT;
private static final String EXTRA_CREATE_ACCOUNT_EMAIL = "EMAIL";
private static final String EXTRA_CREATE_ACCOUNT_USER = "USER";
private static final String EXTRA_CREATE_ACCOUNT_PASSWORD = "PASSWORD";
private static final String EXTRA_CREATE_ACCOUNT_INCOMING = "INCOMING";
private static final String EXTRA_CREATE_ACCOUNT_OUTGOING = "OUTGOING";
private static final String EXTRA_CREATE_ACCOUNT_SYNC_LOOKBACK = "SYNC_LOOKBACK";
private static final String CREATE_ACCOUNT_SYNC_ALL_VALUE = "ALL";
private static final Boolean DEBUG_ALLOW_NON_TEST_HARNESS_CREATION = false;
protected static final String ACTION_JUMP_TO_INCOMING = "jumpToIncoming";
protected static final String ACTION_JUMP_TO_OUTGOING = "jumpToOutgoing";
protected static final String ACTION_JUMP_TO_OPTIONS = "jumpToOptions";
private static final String SAVESTATE_KEY_IS_PROCESSING = "AccountSetupFinal.is_processing";
private static final String SAVESTATE_KEY_STATE = "AccountSetupFinal.state";
private static final String SAVESTATE_KEY_PROVIDER = "AccountSetupFinal.provider";
private static final String SAVESTATE_KEY_AUTHENTICATOR_RESPONSE = "AccountSetupFinal.authResp";
private static final String SAVESTATE_KEY_REPORT_AUTHENTICATOR_ERROR =
"AccountSetupFinal.authErr";
private static final String SAVESTATE_KEY_IS_PRE_CONFIGURED = "AccountSetupFinal.preconfig";
private static final String SAVESTATE_KEY_SKIP_AUTO_DISCOVER = "AccountSetupFinal.noAuto";
private static final String SAVESTATE_KEY_PASSWORD_FAILED = "AccountSetupFinal.passwordFailed";
private static final String CONTENT_FRAGMENT_TAG = "AccountSetupContentFragment";
private static final String CREDENTIALS_BACKSTACK_TAG = "AccountSetupCredentialsFragment";
// Collecting initial email and password
private static final int STATE_BASICS = 0;
// Show the user some interstitial message after email entry
private static final int STATE_BASICS_POST = 1;
// Account is not pre-configured, query user for account type
private static final int STATE_TYPE = 2;
// Account is pre-configured, but the user picked a different protocol
private static final int STATE_AB = 3;
// Collect initial password or oauth token
private static final int STATE_CREDENTIALS = 4;
// Account is a pre-configured account, run the checker
private static final int STATE_CHECKING_PRECONFIGURED = 5;
// Auto-discovering exchange account info, possibly other protocols later
private static final int STATE_AUTO_DISCOVER = 6;
// User is entering incoming settings
private static final int STATE_MANUAL_INCOMING = 7;
// We're checking incoming settings
private static final int STATE_CHECKING_INCOMING = 8;
// User is entering outgoing settings
private static final int STATE_MANUAL_OUTGOING = 9;
// We're checking outgoing settings
private static final int STATE_CHECKING_OUTGOING = 10;
// User is entering sync options
private static final int STATE_OPTIONS = 11;
// We're creating the account
private static final int STATE_CREATING = 12;
// User is entering account name and real name
private static final int STATE_NAMES = 13;
// we're finalizing the account
private static final int STATE_FINALIZE = 14;
private int mState = STATE_BASICS;
private boolean mIsProcessing = false;
private boolean mForceCreate = false;
private boolean mReportAccountAuthenticatorError;
private AccountAuthenticatorResponse mAccountAuthenticatorResponse;
// True if this provider is found in our providers.xml, set after Basics
private boolean mIsPreConfiguredProvider = false;
// True if the user selected manual setup
private boolean mSkipAutoDiscover = false;
// True if validating the pre-configured provider failed and we want manual setup
private boolean mPreConfiguredFailed = false;
private VendorPolicyLoader.Provider mProvider;
private boolean mPasswordFailed;
private static final int OWNER_NAME_LOADER_ID = 0;
private String mOwnerName;
private static final int EXISTING_ACCOUNTS_LOADER_ID = 1;
private Map<String, String> mExistingAccountsMap;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
final Intent intent = getIntent();
final String action = intent.getAction();
if (INTENT_FORCE_CREATE_ACCOUNT == null) {
INTENT_FORCE_CREATE_ACCOUNT = getString(R.string.intent_force_create_email_account);
}
setContentView(R.layout.account_setup_activity);
final ActionBar actionBar = getActionBar();
if (actionBar != null) {
// Hide the app icon.
actionBar.setIcon(android.R.color.transparent);
actionBar.setDisplayUseLogoEnabled(false);
}
if (savedInstanceState != null) {
mIsProcessing = savedInstanceState.getBoolean(SAVESTATE_KEY_IS_PROCESSING, false);
mState = savedInstanceState.getInt(SAVESTATE_KEY_STATE, STATE_OPTIONS);
mProvider = (VendorPolicyLoader.Provider)
savedInstanceState.getSerializable(SAVESTATE_KEY_PROVIDER);
mAccountAuthenticatorResponse =
savedInstanceState.getParcelable(SAVESTATE_KEY_AUTHENTICATOR_RESPONSE);
mReportAccountAuthenticatorError =
savedInstanceState.getBoolean(SAVESTATE_KEY_REPORT_AUTHENTICATOR_ERROR);
mIsPreConfiguredProvider =
savedInstanceState.getBoolean(SAVESTATE_KEY_IS_PRE_CONFIGURED);
mSkipAutoDiscover = savedInstanceState.getBoolean(SAVESTATE_KEY_SKIP_AUTO_DISCOVER);
mPasswordFailed = savedInstanceState.getBoolean(SAVESTATE_KEY_PASSWORD_FAILED);
} else {
// If we're not restoring from a previous state, we want to configure the initial screen
// Set aside incoming AccountAuthenticatorResponse, if there was any
mAccountAuthenticatorResponse = getIntent()
.getParcelableExtra(AccountManager.KEY_ACCOUNT_AUTHENTICATOR_RESPONSE);
if (mAccountAuthenticatorResponse != null) {
// When this Activity is called as part of account authentification flow,
// we are responsible for eventually reporting the result (success or failure) to
// the account manager. Most exit paths represent an failed or abandoned setup,
// so the default is to report the error. Success will be reported by the code in
// AccountSetupOptions that commits the finally created account.
mReportAccountAuthenticatorError = true;
}
// Initialize the SetupDataFragment
if (INTENT_FORCE_CREATE_ACCOUNT.equals(action)) {
mSetupData.setFlowMode(AuthenticatorSetupIntentHelper.FLOW_MODE_FORCE_CREATE);
} else {
final int intentFlowMode = intent.getIntExtra(
AuthenticatorSetupIntentHelper.EXTRA_FLOW_MODE,
AuthenticatorSetupIntentHelper.FLOW_MODE_UNSPECIFIED);
final String flowAccountType = intent.getStringExtra(
AuthenticatorSetupIntentHelper.EXTRA_FLOW_ACCOUNT_TYPE);
mSetupData.setAmProtocol(
EmailServiceUtils.getProtocolFromAccountType(this, flowAccountType));
mSetupData.setFlowMode(intentFlowMode);
}
mState = STATE_BASICS;
// Support unit testing individual screens
if (TextUtils.equals(ACTION_JUMP_TO_INCOMING, action)) {
mState = STATE_MANUAL_INCOMING;
} else if (TextUtils.equals(ACTION_JUMP_TO_OUTGOING, action)) {
mState = STATE_MANUAL_OUTGOING;
} else if (TextUtils.equals(ACTION_JUMP_TO_OPTIONS, action)) {
mState = STATE_OPTIONS;
}
updateContentFragment(false /* addToBackstack */);
mPasswordFailed = false;
}
if (!mIsProcessing && mSetupData.getFlowMode() ==
AuthenticatorSetupIntentHelper.FLOW_MODE_FORCE_CREATE) {
/**
* To support continuous testing, we allow the forced creation of accounts.
* This works in a manner fairly similar to automatic setup, in which the complete
* server Uri's are available, except that we will also skip checking (as if both
* checks were true) and all other UI.
*
* email: The email address for the new account
* user: The user name for the new account
* incoming: The URI-style string defining the incoming account
* outgoing: The URI-style string defining the outgoing account
*/
final String email = intent.getStringExtra(EXTRA_CREATE_ACCOUNT_EMAIL);
final String user = intent.getStringExtra(EXTRA_CREATE_ACCOUNT_USER);
final String password = intent.getStringExtra(EXTRA_CREATE_ACCOUNT_PASSWORD);
final String incoming = intent.getStringExtra(EXTRA_CREATE_ACCOUNT_INCOMING);
final String outgoing = intent.getStringExtra(EXTRA_CREATE_ACCOUNT_OUTGOING);
final String syncLookbackText = intent.getStringExtra(EXTRA_CREATE_ACCOUNT_SYNC_LOOKBACK);
final int syncLookback;
if (TextUtils.equals(syncLookbackText, CREATE_ACCOUNT_SYNC_ALL_VALUE)) {
syncLookback = SyncWindow.SYNC_WINDOW_ALL;
} else {
syncLookback = -1;
}
// If we've been explicitly provided with all the details to fill in the account, we
// can use them
final boolean explicitForm = !(TextUtils.isEmpty(user) ||
TextUtils.isEmpty(incoming) || TextUtils.isEmpty(outgoing));
// If we haven't been provided the details, but we have the password, we can look up
// the info from providers.xml
final boolean implicitForm = !TextUtils.isEmpty(password) && !explicitForm;
if (TextUtils.isEmpty(email) || !(explicitForm || implicitForm)) {
LogUtils.e(LogUtils.TAG, "Force account create requires extras EMAIL, " +
"USER, INCOMING, OUTGOING, or EMAIL and PASSWORD");
finish();
return;
}
if (implicitForm) {
final String[] emailParts = email.split("@");
final String domain = emailParts[1].trim();
mProvider = AccountSettingsUtils.findProviderForDomain(this, domain);
if (mProvider == null) {
LogUtils.e(LogUtils.TAG, "findProviderForDomain couldn't find provider");
finish();
return;
}
mIsPreConfiguredProvider = true;
mSetupData.setEmail(email);
boolean autoSetupCompleted = finishAutoSetup();
if (!autoSetupCompleted) {
LogUtils.e(LogUtils.TAG, "Force create account failed to create account");
finish();
return;
}
final Account account = mSetupData.getAccount();
final HostAuth recvAuth = account.getOrCreateHostAuthRecv(this);
recvAuth.mPassword = password;
final HostAuth sendAuth = account.getOrCreateHostAuthSend(this);
sendAuth.mPassword = password;
} else {
final Account account = mSetupData.getAccount();
try {
final HostAuth recvAuth = account.getOrCreateHostAuthRecv(this);
recvAuth.setHostAuthFromString(incoming);
final HostAuth sendAuth = account.getOrCreateHostAuthSend(this);
sendAuth.setHostAuthFromString(outgoing);
} catch (URISyntaxException e) {
// If we can't set up the URL, don't continue
Toast.makeText(this, R.string.account_setup_username_password_toast,
Toast.LENGTH_LONG)
.show();
finish();
return;
}
populateSetupData(user, email);
// We need to do this after calling populateSetupData(), because that will
// overwrite it with the default values.
if (syncLookback >= SyncWindow.SYNC_WINDOW_ACCOUNT &&
syncLookback <= SyncWindow.SYNC_WINDOW_ALL) {
account.mSyncLookback = syncLookback;
}
}
mState = STATE_OPTIONS;
updateContentFragment(false /* addToBackstack */);
getFragmentManager().executePendingTransactions();
if (!DEBUG_ALLOW_NON_TEST_HARNESS_CREATION &&
!ActivityManager.isRunningInTestHarness()) {
LogUtils.e(LogUtils.TAG,
"ERROR: Force account create only allowed while in test harness");
finish();
return;
}
mForceCreate = true;
}
// Launch a loader to look up the owner name. It should be ready well in advance of
// the time the user clicks next or manual.
getLoaderManager().initLoader(OWNER_NAME_LOADER_ID, null, new OwnerNameLoaderCallbacks());
// Launch a loader to cache some info about existing accounts so we can dupe-check against
// them.
getLoaderManager().initLoader(EXISTING_ACCOUNTS_LOADER_ID, null,
new ExistingAccountsLoaderCallbacks());
}
private class OwnerNameLoaderCallbacks implements LoaderManager.LoaderCallbacks<Cursor> {
@Override
public Loader<Cursor> onCreateLoader(final int id, final Bundle args) {
return new CursorLoader(AccountSetupFinal.this,
ContactsContract.Profile.CONTENT_URI,
new String[] {ContactsContract.Profile.DISPLAY_NAME_PRIMARY},
null, null, null);
}
@Override
public void onLoadFinished(final Loader<Cursor> loader, final Cursor data) {
if (data != null && data.moveToFirst()) {
mOwnerName = data.getString(data.getColumnIndex(
ContactsContract.Profile.DISPLAY_NAME_PRIMARY));
}
}
@Override
public void onLoaderReset(final Loader<Cursor> loader) {}
}
private class ExistingAccountsLoaderCallbacks implements LoaderManager.LoaderCallbacks<Cursor> {
@Override
public Loader<Cursor> onCreateLoader(final int id, final Bundle args) {
return new CursorLoader(AccountSetupFinal.this, MailAppProvider.getAccountsUri(),
new String[] {UIProvider.AccountColumns.ACCOUNT_MANAGER_NAME,
UIProvider.AccountColumns.NAME},
null, null, null);
}
@Override
public void onLoadFinished(final Loader<Cursor> loader, final Cursor data) {
if (data == null || !data.moveToFirst()) {
mExistingAccountsMap = null;
return;
}
mExistingAccountsMap = new HashMap<>();
final int emailColumnIndex = data.getColumnIndex(
UIProvider.AccountColumns.ACCOUNT_MANAGER_NAME);
final int displayNameColumnIndex =
data.getColumnIndex(UIProvider.AccountColumns.NAME);
do {
final String email = data.getString(emailColumnIndex);
final String displayName = data.getString(displayNameColumnIndex);
mExistingAccountsMap.put(email,
TextUtils.isEmpty(displayName) ? email : displayName);
} while (data.moveToNext());
}
@Override
public void onLoaderReset(final Loader<Cursor> loader) {
mExistingAccountsMap = null;
}
}
@Override
protected void onStart() {
super.onStart();
Analytics.getInstance().activityStart(this);
}
@Override
protected void onResume() {
super.onResume();
if (mForceCreate) {
mForceCreate = false;
// We need to do this after onCreate so that we can ensure that the fragment is
// fully created before querying it.
// This will call initiateAccountCreation() for us
proceed();
}
}
@Override
public void onSaveInstanceState(@NonNull Bundle outState) {
super.onSaveInstanceState(outState);
outState.putBoolean(SAVESTATE_KEY_IS_PROCESSING, mIsProcessing);
outState.putInt(SAVESTATE_KEY_STATE, mState);
outState.putSerializable(SAVESTATE_KEY_PROVIDER, mProvider);
outState.putParcelable(SAVESTATE_KEY_AUTHENTICATOR_RESPONSE, mAccountAuthenticatorResponse);
outState.putBoolean(SAVESTATE_KEY_REPORT_AUTHENTICATOR_ERROR,
mReportAccountAuthenticatorError);
outState.putBoolean(SAVESTATE_KEY_IS_PRE_CONFIGURED, mIsPreConfiguredProvider);
outState.putBoolean(SAVESTATE_KEY_PASSWORD_FAILED, mPasswordFailed);
}
@Override
protected void onStop() {
super.onStop();
Analytics.getInstance().activityStop(this);
}
/**
* Swap in the new fragment according to mState. This pushes the current fragment onto the back
* stack, so only call it once per transition.
*/
private void updateContentFragment(boolean addToBackstack) {
final AccountSetupFragment f;
String backstackTag = null;
switch (mState) {
case STATE_BASICS:
f = AccountSetupBasicsFragment.newInstance();
break;
case STATE_TYPE:
f = AccountSetupTypeFragment.newInstance();
break;
case STATE_AB:
f = AccountSetupABFragment.newInstance(mSetupData.getEmail(),
mSetupData.getAmProtocol(), mSetupData.getIncomingProtocol(this));
break;
case STATE_CREDENTIALS:
f = AccountSetupCredentialsFragment.newInstance(mSetupData.getEmail(),
mSetupData.getIncomingProtocol(this), mSetupData.getClientCert(this),
mPasswordFailed, false /* standalone */);
backstackTag = CREDENTIALS_BACKSTACK_TAG;
break;
case STATE_MANUAL_INCOMING:
f = AccountSetupIncomingFragment.newInstance(false);
break;
case STATE_MANUAL_OUTGOING:
f = AccountSetupOutgoingFragment.newInstance(false);
break;
case STATE_OPTIONS:
f = AccountSetupOptionsFragment.newInstance();
break;
case STATE_NAMES:
f = AccountSetupNamesFragment.newInstance();
break;
default:
throw new IllegalStateException("Incorrect state " + mState);
}
f.setState(mState);
final FragmentTransaction ft = getFragmentManager().beginTransaction();
ft.setCustomAnimations(R.anim.fade_in, R.anim.fade_out, R.anim.fade_in, R.anim.fade_out);
ft.replace(R.id.setup_fragment_container, f, CONTENT_FRAGMENT_TAG);
if (addToBackstack) {
ft.addToBackStack(backstackTag);
}
ft.commit();
final InputMethodManager imm =
(InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
final View fragment_container = findViewById(R.id.setup_fragment_container);
imm.hideSoftInputFromWindow(fragment_container.getWindowToken(),
0 /* flags: always hide */);
}
/**
* Retrieve the current content fragment
* @return The content fragment or null if it wasn't found for some reason
*/
private AccountSetupFragment getContentFragment() {
return (AccountSetupFragment) getFragmentManager().findFragmentByTag(CONTENT_FRAGMENT_TAG);
}
/**
* Reads the flow state saved into the current fragment and restores mState to it, also
* resetting the headline at the same time.
*/
private void resetStateFromCurrentFragment() {
AccountSetupFragment f = getContentFragment();
mState = f.getState();
}
/**
* Main choreography function to handle moving forward through scenes. Moving back should be
* generally handled for us by the back stack
*/
protected void proceed() {
mIsProcessing = false;
final AccountSetupFragment oldContentFragment = getContentFragment();
if (oldContentFragment != null) {
oldContentFragment.setNextButtonEnabled(true);
}
getFragmentManager().executePendingTransactions();
switch (mState) {
case STATE_BASICS:
final boolean advance = onBasicsComplete();
if (!advance) {
mState = STATE_BASICS_POST;
break;
} // else fall through
case STATE_BASICS_POST:
if (shouldDivertToManual()) {
mSkipAutoDiscover = true;
mIsPreConfiguredProvider = false;
mState = STATE_TYPE;
} else {
mSkipAutoDiscover = false;
if (mIsPreConfiguredProvider) {
if (!TextUtils.isEmpty(mSetupData.getAmProtocol()) &&
!TextUtils.equals(mSetupData.getAmProtocol(),
mSetupData.getIncomingProtocol(this))) {
mState = STATE_AB;
} else {
mState = STATE_CREDENTIALS;
if (possiblyDivertToGmail()) {
return;
}
}
} else {
final String amProtocol = mSetupData.getAmProtocol();
if (!TextUtils.isEmpty(amProtocol)) {
mSetupData.setIncomingProtocol(this, amProtocol);
final Account account = mSetupData.getAccount();
setDefaultsForProtocol(account);
mState = STATE_CREDENTIALS;
} else {
mState = STATE_TYPE;
}
}
}
updateContentFragment(true /* addToBackstack */);
break;
case STATE_TYPE:
// We either got here through "Manual Setup" or because we didn't find the provider
mState = STATE_CREDENTIALS;
updateContentFragment(true /* addToBackstack */);
break;
case STATE_AB:
if (possiblyDivertToGmail()) {
return;
}
mState = STATE_CREDENTIALS;
updateContentFragment(true /* addToBackstack */);
break;
case STATE_CREDENTIALS:
collectCredentials();
if (mIsPreConfiguredProvider) {
mState = STATE_CHECKING_PRECONFIGURED;
initiateCheckSettingsFragment(SetupDataFragment.CHECK_INCOMING
| SetupDataFragment.CHECK_OUTGOING);
} else {
populateHostAuthsFromSetupData();
if (mSkipAutoDiscover) {
mState = STATE_MANUAL_INCOMING;
updateContentFragment(true /* addToBackstack */);
} else {
mState = STATE_AUTO_DISCOVER;
initiateAutoDiscover();
}
}
break;
case STATE_CHECKING_PRECONFIGURED:
if (mPreConfiguredFailed) {
if (mPasswordFailed) {
// Get rid of the previous instance of the AccountSetupCredentialsFragment.
FragmentManager fm = getFragmentManager();
fm.popBackStackImmediate(CREDENTIALS_BACKSTACK_TAG, 0);
final AccountSetupCredentialsFragment f = (AccountSetupCredentialsFragment)
getContentFragment();
f.setPasswordFailed(mPasswordFailed);
resetStateFromCurrentFragment();
} else {
mState = STATE_MANUAL_INCOMING;
updateContentFragment(true /* addToBackstack */);
}
} else {
mState = STATE_OPTIONS;
updateContentFragment(true /* addToBackstack */);
}
break;
case STATE_AUTO_DISCOVER:
// TODO: figure out if we can skip past manual setup
mState = STATE_MANUAL_INCOMING;
updateContentFragment(true);
break;
case STATE_MANUAL_INCOMING:
onIncomingComplete();
mState = STATE_CHECKING_INCOMING;
initiateCheckSettingsFragment(SetupDataFragment.CHECK_INCOMING);
break;
case STATE_CHECKING_INCOMING:
final EmailServiceUtils.EmailServiceInfo serviceInfo =
mSetupData.getIncomingServiceInfo(this);
if (serviceInfo.usesSmtp) {
mState = STATE_MANUAL_OUTGOING;
} else {
mState = STATE_OPTIONS;
}
updateContentFragment(true /* addToBackstack */);
break;
case STATE_MANUAL_OUTGOING:
onOutgoingComplete();
mState = STATE_CHECKING_OUTGOING;
initiateCheckSettingsFragment(SetupDataFragment.CHECK_OUTGOING);
break;
case STATE_CHECKING_OUTGOING:
mState = STATE_OPTIONS;
updateContentFragment(true /* addToBackstack */);
break;
case STATE_OPTIONS:
mState = STATE_CREATING;
initiateAccountCreation();
break;
case STATE_CREATING:
mState = STATE_NAMES;
updateContentFragment(true /* addToBackstack */);
if (mSetupData.getFlowMode() ==
AuthenticatorSetupIntentHelper.FLOW_MODE_FORCE_CREATE) {
getFragmentManager().executePendingTransactions();
initiateAccountFinalize();
}
break;
case STATE_NAMES:
initiateAccountFinalize();
break;
case STATE_FINALIZE:
finish();
break;
default:
LogUtils.wtf(LogUtils.TAG, "Unknown state %d", mState);
break;
}
}
/**
* Check if we should divert to creating a Gmail account instead
* @return true if we diverted
*/
private boolean possiblyDivertToGmail() {
// TODO: actually divert here
final EmailServiceUtils.EmailServiceInfo info =
mSetupData.getIncomingServiceInfo(this);
if (TextUtils.equals(info.protocol, "gmail")) {
final Bundle options = new Bundle(1);
options.putBoolean("allowSkip", false);
AccountManager.get(this).addAccount("com.google",
"mail" /* authTokenType */,
null,
options,
this, null, null);
finish();
return true;
}
return false;
}
/**
* Block the back key if we are currently processing the "next" key"
*/
@Override
public void onBackPressed() {
if (mIsProcessing) {
return;
}
if (mState == STATE_NAMES) {
finish();
} else {
super.onBackPressed();
}
// After super.onBackPressed() our fragment should be in place, so query the state we
// installed it for
resetStateFromCurrentFragment();
}
@Override
public void setAccount(Account account) {
mSetupData.setAccount(account);
}
@Override
public void finish() {
// If the account manager initiated the creation, and success was not reported,
// then we assume that we're giving up (for any reason) - report failure.
if (mReportAccountAuthenticatorError) {
if (mAccountAuthenticatorResponse != null) {
mAccountAuthenticatorResponse
.onError(AccountManager.ERROR_CODE_CANCELED, "canceled");
mAccountAuthenticatorResponse = null;
}
}
super.finish();
}
@Override
public void onNextButton() {
// Some states are handled without UI, block double-presses here
if (!mIsProcessing) {
proceed();
}
}
/**
* @return true to proceed, false to remain on the current screen
*/
private boolean onBasicsComplete() {
final AccountSetupBasicsFragment f = (AccountSetupBasicsFragment) getContentFragment();
final String email = f.getEmail();
// Reset the protocol choice in case the user has back-navigated here
mSetupData.setIncomingProtocol(this, null);
if (!TextUtils.equals(email, mSetupData.getEmail())) {
// If the user changes their email address, clear the password failed state
mPasswordFailed = false;
}
mSetupData.setEmail(email);
final String[] emailParts = email.split("@");
final String domain = emailParts[1].trim();
mProvider = AccountSettingsUtils.findProviderForDomain(this, domain);
if (mProvider != null) {
mIsPreConfiguredProvider = true;
if (mProvider.note != null) {
final AccountSetupNoteDialogFragment dialogFragment =
AccountSetupNoteDialogFragment.newInstance(mProvider.note);
dialogFragment.show(getFragmentManager(), AccountSetupNoteDialogFragment.TAG);
return false;
} else {
return finishAutoSetup();
}
} else {
mIsPreConfiguredProvider = false;
final String existingAccountName =
mExistingAccountsMap != null ? mExistingAccountsMap.get(email) : null;
if (!TextUtils.isEmpty(existingAccountName)) {
showDuplicateAccountDialog(existingAccountName);
return false;
} else {
populateSetupData(mOwnerName, email);
mSkipAutoDiscover = false;
return true;
}
}
}
private void showDuplicateAccountDialog(final String existingAccountName) {
final DuplicateAccountDialogFragment dialogFragment =
DuplicateAccountDialogFragment.newInstance(existingAccountName);
dialogFragment.show(getFragmentManager(), DuplicateAccountDialogFragment.TAG);
}
@Override
public void onDuplicateAccountDialogDismiss() {
resetStateFromCurrentFragment();
}
private boolean shouldDivertToManual() {
final AccountSetupBasicsFragment f = (AccountSetupBasicsFragment) getContentFragment();
return f.isManualSetup();
}
@Override
public void onCredentialsComplete(Bundle results) {
proceed();
}
private void collectCredentials() {
final AccountSetupCredentialsFragment f = (AccountSetupCredentialsFragment)
getContentFragment();
final Bundle results = f.getCredentialResults();
mSetupData.setCredentialResults(results);
final Account account = mSetupData.getAccount();
final HostAuth recvAuth = account.getOrCreateHostAuthRecv(this);
AccountSetupCredentialsFragment.populateHostAuthWithResults(this, recvAuth,
mSetupData.getCredentialResults());
mSetupData.setIncomingCredLoaded(true);
final EmailServiceUtils.EmailServiceInfo info = mSetupData.getIncomingServiceInfo(this);
if (info.usesSmtp) {
final HostAuth sendAuth = account.getOrCreateHostAuthSend(this);
AccountSetupCredentialsFragment.populateHostAuthWithResults(this, sendAuth,
mSetupData.getCredentialResults());
mSetupData.setOutgoingCredLoaded(true);
}
}
@Override
public void onNoteDialogComplete() {
finishAutoSetup();
proceed();
}
@Override
public void onNoteDialogCancel() {
resetStateFromCurrentFragment();
}
/**
* Finish the auto setup process, in some cases after showing a warning dialog.
* Happens after onBasicsComplete
* @return true to proceed, false to remain on the current screen
*/
private boolean finishAutoSetup() {
final String email = mSetupData.getEmail();
try {
mProvider.expandTemplates(email);
final String primaryProtocol = HostAuth.getProtocolFromString(mProvider.incomingUri);
EmailServiceUtils.EmailServiceInfo info =
EmailServiceUtils.getServiceInfo(this, primaryProtocol);
// If the protocol isn't one we can use, and we're not diverting to gmail, try the alt
if (!info.isGmailStub && !EmailServiceUtils.isServiceAvailable(this, info.protocol)) {
LogUtils.d(LogUtils.TAG, "Protocol %s not available, using alternate",
info.protocol);
mProvider.expandAlternateTemplates(email);
final String alternateProtocol = HostAuth.getProtocolFromString(
mProvider.incomingUri);
info = EmailServiceUtils.getServiceInfo(this, alternateProtocol);
}
final Account account = mSetupData.getAccount();
final HostAuth recvAuth = account.getOrCreateHostAuthRecv(this);
recvAuth.setHostAuthFromString(mProvider.incomingUri);
recvAuth.setUserName(mProvider.incomingUsername);
recvAuth.mPort =
((recvAuth.mFlags & HostAuth.FLAG_SSL) != 0) ? info.portSsl : info.port;
if (info.usesSmtp) {
final HostAuth sendAuth = account.getOrCreateHostAuthSend(this);
sendAuth.setHostAuthFromString(mProvider.outgoingUri);
sendAuth.setUserName(mProvider.outgoingUsername);
}
// Populate the setup data, assuming that the duplicate account check will succeed
populateSetupData(mOwnerName, email);
final String duplicateAccountName =
mExistingAccountsMap != null ? mExistingAccountsMap.get(email) : null;
if (duplicateAccountName != null) {
showDuplicateAccountDialog(duplicateAccountName);
return false;
}
} catch (URISyntaxException e) {
mSkipAutoDiscover = false;
mPreConfiguredFailed = true;
}
return true;
}
/**
* Helper method to fill in some per-protocol defaults
* @param account Account object to fill in
*/
public void setDefaultsForProtocol(Account account) {
final EmailServiceUtils.EmailServiceInfo info = mSetupData.getIncomingServiceInfo(this);
if (info == null) return;
account.mSyncInterval = info.defaultSyncInterval;
account.mSyncLookback = info.defaultLookback;
if (info.offerLocalDeletes) {
account.setDeletePolicy(info.defaultLocalDeletes);
}
}
/**
* Populate SetupData's account with complete setup info, assumes that the receive auth is
* created and its protocol is set
*/
private void populateSetupData(String senderName, String senderEmail) {
final Account account = mSetupData.getAccount();
account.setSenderName(senderName);
account.setEmailAddress(senderEmail);
account.setDisplayName(senderEmail);
setDefaultsForProtocol(account);
}
private void onIncomingComplete() {
AccountSetupIncomingFragment f = (AccountSetupIncomingFragment) getContentFragment();
f.collectUserInput();
}
private void onOutgoingComplete() {
AccountSetupOutgoingFragment f = (AccountSetupOutgoingFragment) getContentFragment();
f.collectUserInput();
}
// This callback method is only applicable to using Incoming/Outgoing fragments in settings mode
@Override
public void onAccountServerUIComplete(int checkMode) {}
// This callback method is only applicable to using Incoming/Outgoing fragments in settings mode
@Override
public void onAccountServerSaveComplete() {}
private void populateHostAuthsFromSetupData() {
final String email = mSetupData.getEmail();
final String[] emailParts = email.split("@");
final String domain = emailParts[1];
final Account account = mSetupData.getAccount();
final EmailServiceUtils.EmailServiceInfo info =
mSetupData.getIncomingServiceInfo(this);
final HostAuth recvAuth = account.getOrCreateHostAuthRecv(this);
recvAuth.setUserName(email);
recvAuth.setConnection(mSetupData.getIncomingProtocol(), domain,
HostAuth.PORT_UNKNOWN, info.offerTls ? HostAuth.FLAG_TLS : HostAuth.FLAG_SSL);
AccountSetupCredentialsFragment.populateHostAuthWithResults(this, recvAuth,
mSetupData.getCredentialResults());
mSetupData.setIncomingCredLoaded(true);
if (info.usesSmtp) {
final HostAuth sendAuth = account.getOrCreateHostAuthSend(this);
sendAuth.setUserName(email);
sendAuth.setConnection(HostAuth.LEGACY_SCHEME_SMTP, domain,
HostAuth.PORT_UNKNOWN, HostAuth.FLAG_TLS);
AccountSetupCredentialsFragment.populateHostAuthWithResults(this, sendAuth,
mSetupData.getCredentialResults());
mSetupData.setOutgoingCredLoaded(true);
}
}
private void initiateAutoDiscover() {
// Populate the setup data, assuming that the duplicate account check will succeed
initiateCheckSettingsFragment(SetupDataFragment.CHECK_AUTODISCOVER);
}
private void initiateCheckSettingsFragment(int checkMode) {
final Fragment f = AccountCheckSettingsFragment.newInstance(checkMode);
final Fragment d = CheckSettingsProgressDialogFragment.newInstance(checkMode);
getFragmentManager().beginTransaction()
.add(f, AccountCheckSettingsFragment.TAG)
.add(d, CheckSettingsProgressDialogFragment.TAG)
.commit();
}
@Override
public void onCheckSettingsProgressDialogCancel() {
dismissCheckSettingsFragment();
resetStateFromCurrentFragment();
}
private void dismissCheckSettingsFragment() {
final Fragment f = getFragmentManager().findFragmentByTag(AccountCheckSettingsFragment.TAG);
final Fragment d =
getFragmentManager().findFragmentByTag(CheckSettingsProgressDialogFragment.TAG);
getFragmentManager().beginTransaction()
.remove(f)
.remove(d)
.commit();
}
@Override
public void onCheckSettingsError(int reason, String message) {
if (reason == CheckSettingsErrorDialogFragment.REASON_AUTHENTICATION_FAILED ||
reason == CheckSettingsErrorDialogFragment.REASON_CERTIFICATE_REQUIRED) {
// TODO: possibly split password and cert error conditions
mPasswordFailed = true;
}
dismissCheckSettingsFragment();
final DialogFragment f =
CheckSettingsErrorDialogFragment.newInstance(reason, message);
f.show(getFragmentManager(), CheckSettingsErrorDialogFragment.TAG);
}
@Override
public void onCheckSettingsErrorDialogEditCertificate() {
if (mState == STATE_CHECKING_PRECONFIGURED) {
mPreConfiguredFailed = true;
proceed();
} else {
resetStateFromCurrentFragment();
}
final AccountSetupIncomingFragment f = (AccountSetupIncomingFragment) getContentFragment();
f.onCertificateRequested();
}
@Override
public void onCheckSettingsErrorDialogEditSettings() {
// If we're checking pre-configured, set a flag that we failed and navigate forwards to
// incoming settings
if (mState == STATE_CHECKING_PRECONFIGURED || mState == STATE_AUTO_DISCOVER) {
mPreConfiguredFailed = true;
proceed();
} else {
resetStateFromCurrentFragment();
}
}
@Override
public void onCheckSettingsComplete() {
mPreConfiguredFailed = false;
mPasswordFailed = false;
dismissCheckSettingsFragment();
proceed();
}
@Override
public void onCheckSettingsAutoDiscoverComplete(int result) {
dismissCheckSettingsFragment();
proceed();
}
@Override
public void onCheckSettingsSecurityRequired(String hostName) {
dismissCheckSettingsFragment();
final DialogFragment f = SecurityRequiredDialogFragment.newInstance(hostName);
f.show(getFragmentManager(), SecurityRequiredDialogFragment.TAG);
}
@Override
public void onSecurityRequiredDialogResult(boolean ok) {
if (ok) {
proceed();
} else {
resetStateFromCurrentFragment();
}
}
@Override
public void onChooseProtocol(String protocol) {
mSetupData.setIncomingProtocol(this, protocol);
final Account account = mSetupData.getAccount();
setDefaultsForProtocol(account);
proceed();
}
@Override
public void onABProtocolDisambiguated(String chosenProtocol) {
if (!TextUtils.equals(mSetupData.getIncomingProtocol(this), chosenProtocol)) {
mIsPreConfiguredProvider = false;
mSetupData.setIncomingProtocol(this, chosenProtocol);
final Account account = mSetupData.getAccount();
setDefaultsForProtocol(account);
}
proceed();
}
/**
* Ths is called when the user clicks the "done" button.
* It collects the data from the UI, updates the setup account record, and launches a fragment
* which handles creating the account in the system and database.
*/
private void initiateAccountCreation() {
mIsProcessing = true;
getContentFragment().setNextButtonEnabled(false);
final Account account = mSetupData.getAccount();
if (account.mHostAuthRecv == null) {
throw new IllegalStateException("in AccountSetupOptions with null mHostAuthRecv");
}
final AccountSetupOptionsFragment fragment = (AccountSetupOptionsFragment)
getContentFragment();
if (fragment == null) {
throw new IllegalStateException("Fragment missing!");
}
account.setDisplayName(account.getEmailAddress());
int newFlags = account.getFlags() & ~(Account.FLAGS_BACKGROUND_ATTACHMENTS);
final EmailServiceUtils.EmailServiceInfo serviceInfo =
mSetupData.getIncomingServiceInfo(this);
if (serviceInfo.offerAttachmentPreload && fragment.getBackgroundAttachmentsValue()) {
newFlags |= Account.FLAGS_BACKGROUND_ATTACHMENTS;
}
final HostAuth hostAuth = account.getOrCreateHostAuthRecv(this);
if (hostAuth.mProtocol.equals(getString(R.string.protocol_eas))) {
try {
final double protocolVersionDouble = Double.parseDouble(account.mProtocolVersion);
if (protocolVersionDouble >= 12.0) {
// If the the account is EAS and the protocol version is above 12.0,
// we know that SmartForward is enabled and the various search flags
// should be enabled first.
// TODO: Move this into protocol specific code in the future.
newFlags |= Account.FLAGS_SUPPORTS_SMART_FORWARD |
Account.FLAGS_SUPPORTS_GLOBAL_SEARCH | Account.FLAGS_SUPPORTS_SEARCH;
}
} catch (NumberFormatException e) {
LogUtils.wtf(LogUtils.TAG, e, "Exception thrown parsing the protocol version.");
}
}
account.setFlags(newFlags);
account.setSyncInterval(fragment.getCheckFrequencyValue());
final Integer syncWindowValue = fragment.getAccountSyncWindowValue();
if (syncWindowValue != null) {
account.setSyncLookback(syncWindowValue);
}
// Finish setting up the account, and commit it to the database
if (mSetupData.getPolicy() != null) {
account.mFlags |= Account.FLAGS_SECURITY_HOLD;
account.mPolicy = mSetupData.getPolicy();
}
// Finally, write the completed account (for the first time) and then
// install it into the Account manager as well. These are done off-thread.
// The account manager will report back via the callback, which will take us to
// the next operations.
final boolean syncEmail = fragment.getSyncEmailValue();
final boolean syncCalendar = serviceInfo.syncCalendar && fragment.getSyncCalendarValue();
final boolean syncContacts = serviceInfo.syncContacts && fragment.getSyncContactsValue();
final boolean enableNotifications = fragment.getNotifyValue();
final Fragment f = AccountCreationFragment.newInstance(account, syncEmail, syncCalendar,
syncContacts, enableNotifications);
final FragmentTransaction ft = getFragmentManager().beginTransaction();
ft.add(f, AccountCreationFragment.TAG);
ft.commit();
showCreateAccountDialog();
}
/**
* Called by the account creation fragment after it has completed.
* We do a small amount of work here before moving on to the next state.
*/
@Override
public void onAccountCreationFragmentComplete() {
destroyAccountCreationFragment();
// If the account manager initiated the creation, and success was not reported,
// then we assume that we're giving up (for any reason) - report failure.
if (mAccountAuthenticatorResponse != null) {
final EmailServiceUtils.EmailServiceInfo info = mSetupData.getIncomingServiceInfo(this);
final Bundle b = new Bundle(2);
b.putString(AccountManager.KEY_ACCOUNT_NAME, mSetupData.getEmail());
b.putString(AccountManager.KEY_ACCOUNT_TYPE, info.accountType);
mAccountAuthenticatorResponse.onResult(b);
mAccountAuthenticatorResponse = null;
mReportAccountAuthenticatorError = false;
}
setResult(RESULT_OK);
proceed();
}
@Override
public void destroyAccountCreationFragment() {
dismissCreateAccountDialog();
final Fragment f = getFragmentManager().findFragmentByTag(AccountCreationFragment.TAG);
if (f == null) {
LogUtils.wtf(LogUtils.TAG, "Couldn't find AccountCreationFragment to destroy");
}
getFragmentManager().beginTransaction()
.remove(f)
.commit();
}
public static class CreateAccountDialogFragment extends DialogFragment {
public static final String TAG = "CreateAccountDialogFragment";
public CreateAccountDialogFragment() {}
public static CreateAccountDialogFragment newInstance() {
return new CreateAccountDialogFragment();
}
@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
/// Show "Creating account..." dialog
setCancelable(false);
final ProgressDialog d = new ProgressDialog(getActivity());
d.setIndeterminate(true);
d.setMessage(getString(R.string.account_setup_creating_account_msg));
return d;
}
}
protected void showCreateAccountDialog() {
CreateAccountDialogFragment.newInstance()
.show(getFragmentManager(), CreateAccountDialogFragment.TAG);
}
protected void dismissCreateAccountDialog() {
final DialogFragment f = (DialogFragment)
getFragmentManager().findFragmentByTag(CreateAccountDialogFragment.TAG);
if (f != null) {
f.dismiss();
}
}
public static class CreateAccountErrorDialogFragment extends DialogFragment
implements DialogInterface.OnClickListener {
public CreateAccountErrorDialogFragment() {}
@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
final String message = getString(R.string.account_setup_failed_dlg_auth_message,
R.string.system_account_create_failed);
setCancelable(false);
return new AlertDialog.Builder(getActivity())
.setIconAttribute(android.R.attr.alertDialogIcon)
.setTitle(R.string.account_setup_failed_dlg_title)
.setMessage(message)
.setPositiveButton(android.R.string.ok, this)
.create();
}
@Override
public void onClick(DialogInterface dialog, int which) {
getActivity().finish();
}
}
/**
* This is called if MailService.setupAccountManagerAccount() fails for some reason
*/
@Override
public void showCreateAccountErrorDialog() {
new CreateAccountErrorDialogFragment().show(getFragmentManager(), null);
}
/**
* Collect the data from AccountSetupNames and finish up account creation
*/
private void initiateAccountFinalize() {
mIsProcessing = true;
getContentFragment().setNextButtonEnabled(false);
AccountSetupNamesFragment fragment = (AccountSetupNamesFragment) getContentFragment();
// Update account object from UI
final Account account = mSetupData.getAccount();
final String description = fragment.getDescription();
if (!TextUtils.isEmpty(description)) {
account.setDisplayName(description);
}
account.setSenderName(fragment.getSenderName());
final Fragment f = AccountFinalizeFragment.newInstance(account);
final FragmentTransaction ft = getFragmentManager().beginTransaction();
ft.add(f, AccountFinalizeFragment.TAG);
ft.commit();
}
/**
* Called when the AccountFinalizeFragment has finished its tasks
*/
@Override
public void onAccountFinalizeFragmentComplete() {
finish();
}
}