/*
* Copyright (C) 2008 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 com.android.email.AccountBackupRestore;
import com.android.email.Email;
import com.android.email.EmailAddressValidator;
import com.android.email.R;
import com.android.email.Utility;
import com.android.email.VendorPolicyLoader;
import com.android.email.activity.Debug;
import com.android.email.activity.MessageList;
import com.android.email.activity.setup.AccountSettingsUtils.Provider;
import com.android.email.provider.EmailContent;
import com.android.email.provider.EmailContent.Account;
import com.android.email.provider.EmailContent.Mailbox;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.Dialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.database.Cursor;
import android.os.Bundle;
import android.text.Editable;
import android.text.TextWatcher;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.CheckBox;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.Toast;
import java.net.URI;
import java.net.URISyntaxException;
/**
* Prompts the user for the email address and password. Also prompts for
* "Use this account as default" if this is the 2nd+ account being set up.
* Attempts to lookup default settings for the domain the user specified. If the
* domain is known the settings are handed off to the AccountSetupCheckSettings
* activity. If no settings are found the settings are handed off to the
* AccountSetupAccountType activity.
*/
public class AccountSetupBasics extends Activity
implements OnClickListener, TextWatcher {
private final static boolean ENTER_DEBUG_SCREEN = true;
private final static String EXTRA_ACCOUNT = "com.android.email.AccountSetupBasics.account";
public final static String EXTRA_EAS_FLOW = "com.android.email.extra.eas_flow";
// Action asking us to return to our original caller (i.e. finish)
private static final String ACTION_RETURN_TO_CALLER =
"com.android.email.AccountSetupBasics.return";
// Action asking us to restart the task from the Welcome activity (which will figure out the
// right place to go) and finish
private static final String ACTION_START_AT_MESSAGE_LIST =
"com.android.email.AccountSetupBasics.messageList";
private final static String EXTRA_USERNAME = "com.android.email.AccountSetupBasics.username";
private final static String EXTRA_PASSWORD = "com.android.email.AccountSetupBasics.password";
private final static int DIALOG_NOTE = 1;
private final static int DIALOG_DUPLICATE_ACCOUNT = 2;
private final static String STATE_KEY_PROVIDER =
"com.android.email.AccountSetupBasics.provider";
// NOTE: If you change this value, confirm that the new interval exists in arrays.xml
private final static int DEFAULT_ACCOUNT_CHECK_INTERVAL = 15;
private EditText mEmailView;
private EditText mPasswordView;
private CheckBox mDefaultView;
private Button mNextButton;
private Button mManualSetupButton;
private EmailContent.Account mAccount;
private Provider mProvider;
private boolean mEasFlowMode;
private String mDuplicateAccountName;
private EmailAddressValidator mEmailValidator = new EmailAddressValidator();
public static void actionNewAccount(Activity fromActivity) {
Intent i = new Intent(fromActivity, AccountSetupBasics.class);
fromActivity.startActivity(i);
}
public static void actionNewAccountWithCredentials(Activity fromActivity,
String username, String password, boolean easFlow) {
Intent i = new Intent(fromActivity, AccountSetupBasics.class);
i.putExtra(EXTRA_USERNAME, username);
i.putExtra(EXTRA_PASSWORD, password);
i.putExtra(EXTRA_EAS_FLOW, easFlow);
fromActivity.startActivity(i);
}
/**
* This creates an intent that can be used to start a self-contained account creation flow
* for exchange accounts.
*/
public static Intent actionSetupExchangeIntent(Context context) {
Intent i = new Intent(context, AccountSetupBasics.class);
i.putExtra(EXTRA_EAS_FLOW, true);
return i;
}
public static void actionAccountCreateFinishedEas(Activity fromActivity) {
Intent i= new Intent(fromActivity, AccountSetupBasics.class);
// If we're in the "eas flow" (from AccountManager), we want to return to the caller
// (in the settings app)
i.putExtra(AccountSetupBasics.ACTION_RETURN_TO_CALLER, true);
i.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
fromActivity.startActivity(i);
}
public static void actionAccountCreateFinished(Activity fromActivity, long accountId) {
Intent i= new Intent(fromActivity, AccountSetupBasics.class);
// If we're not in the "eas flow" (from AccountManager), we want to show the message list
// for the new inbox
i.putExtra(AccountSetupBasics.ACTION_START_AT_MESSAGE_LIST, accountId);
i.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
fromActivity.startActivity(i);
}
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Intent intent = getIntent();
if (intent.getBooleanExtra(ACTION_RETURN_TO_CALLER, false)) {
// Return to the caller who initiated account creation
finish();
return;
} else {
long accountId = intent.getLongExtra(ACTION_START_AT_MESSAGE_LIST, -1);
if (accountId >= 0) {
// Show the message list for the new account
MessageList.actionHandleAccount(this, accountId, Mailbox.TYPE_INBOX);
finish();
return;
}
}
setContentView(R.layout.account_setup_basics);
mEmailView = (EditText)findViewById(R.id.account_email);
mPasswordView = (EditText)findViewById(R.id.account_password);
mDefaultView = (CheckBox)findViewById(R.id.account_default);
mNextButton = (Button)findViewById(R.id.next);
mManualSetupButton = (Button)findViewById(R.id.manual_setup);
mNextButton.setOnClickListener(this);
mManualSetupButton.setOnClickListener(this);
mEmailView.addTextChangedListener(this);
mPasswordView.addTextChangedListener(this);
// Find out how many accounts we have, and if there one or more, then we have a choice
// about being default or not.
Cursor c = null;
try {
c = getContentResolver().query(
EmailContent.Account.CONTENT_URI,
EmailContent.Account.ID_PROJECTION,
null, null, null);
if (c.getCount() > 0) {
mDefaultView.setVisibility(View.VISIBLE);
}
} finally {
if (c != null) {
c.close();
}
}
mEasFlowMode = intent.getBooleanExtra(EXTRA_EAS_FLOW, false);
if (mEasFlowMode) {
// No need for manual button -> next is appropriate
mManualSetupButton.setVisibility(View.GONE);
// Swap welcome text for EAS-specific text
TextView welcomeView = (TextView) findViewById(R.id.instructions);
final boolean alternateStrings =
VendorPolicyLoader.getInstance(this).useAlternateExchangeStrings();
setTitle(alternateStrings
? R.string.account_setup_basics_exchange_title_alternate
: R.string.account_setup_basics_exchange_title);
welcomeView.setText(alternateStrings
? R.string.accounts_welcome_exchange_alternate
: R.string.accounts_welcome_exchange);
}
if (intent.hasExtra(EXTRA_USERNAME)) {
mEmailView.setText(intent.getStringExtra(EXTRA_USERNAME));
}
if (intent.hasExtra(EXTRA_PASSWORD)) {
mPasswordView.setText(intent.getStringExtra(EXTRA_PASSWORD));
}
if (savedInstanceState != null && savedInstanceState.containsKey(EXTRA_ACCOUNT)) {
mAccount = (EmailContent.Account)savedInstanceState.getParcelable(EXTRA_ACCOUNT);
}
if (savedInstanceState != null && savedInstanceState.containsKey(STATE_KEY_PROVIDER)) {
mProvider = (Provider)savedInstanceState.getSerializable(STATE_KEY_PROVIDER);
}
}
@Override
public void onResume() {
super.onResume();
validateFields();
}
@Override
public void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
outState.putParcelable(EXTRA_ACCOUNT, mAccount);
if (mProvider != null) {
outState.putSerializable(STATE_KEY_PROVIDER, mProvider);
}
}
public void afterTextChanged(Editable s) {
validateFields();
}
public void beforeTextChanged(CharSequence s, int start, int count, int after) {
}
public void onTextChanged(CharSequence s, int start, int before, int count) {
}
private void validateFields() {
boolean valid = Utility.requiredFieldValid(mEmailView)
&& Utility.requiredFieldValid(mPasswordView)
&& mEmailValidator.isValid(mEmailView.getText().toString().trim());
mNextButton.setEnabled(valid);
mManualSetupButton.setEnabled(valid);
/*
* Dim the next button's icon to 50% if the button is disabled.
* TODO this can probably be done with a stateful drawable. Check into it.
* android:state_enabled
*/
Utility.setCompoundDrawablesAlpha(mNextButton, mNextButton.isEnabled() ? 255 : 128);
}
private String getOwnerName() {
String name = null;
/* TODO figure out another way to get the owner name
String projection[] = {
ContactMethods.NAME
};
Cursor c = getContentResolver().query(
Uri.withAppendedPath(Contacts.People.CONTENT_URI, "owner"), projection, null, null,
null);
if (c != null) {
if (c.moveToFirst()) {
name = c.getString(0);
}
c.close();
}
*/
if (name == null || name.length() == 0) {
long defaultId = Account.getDefaultAccountId(this);
if (defaultId != -1) {
Account account = Account.restoreAccountWithId(this, defaultId);
if (account != null) {
name = account.getSenderName();
}
}
}
return name;
}
@Override
public Dialog onCreateDialog(int id) {
if (id == DIALOG_NOTE) {
if (mProvider != null && mProvider.note != null) {
return new AlertDialog.Builder(this)
.setIcon(android.R.drawable.ic_dialog_alert)
.setTitle(android.R.string.dialog_alert_title)
.setMessage(mProvider.note)
.setPositiveButton(
getString(R.string.okay_action),
new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
finishAutoSetup();
}
})
.setNegativeButton(
getString(R.string.cancel_action),
null)
.create();
}
} else if (id == DIALOG_DUPLICATE_ACCOUNT) {
return new AlertDialog.Builder(this)
.setIcon(android.R.drawable.ic_dialog_alert)
.setTitle(R.string.account_duplicate_dlg_title)
.setMessage(getString(R.string.account_duplicate_dlg_message_fmt,
mDuplicateAccountName))
.setPositiveButton(R.string.okay_action,
new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
dismissDialog(DIALOG_DUPLICATE_ACCOUNT);
}
})
.create();
}
return null;
}
/**
* Update a cached dialog with current values (e.g. account name)
*/
@Override
public void onPrepareDialog(int id, Dialog dialog) {
switch (id) {
case DIALOG_NOTE:
if (mProvider != null && mProvider.note != null) {
AlertDialog alert = (AlertDialog) dialog;
alert.setMessage(mProvider.note);
}
break;
case DIALOG_DUPLICATE_ACCOUNT:
if (mDuplicateAccountName != null) {
AlertDialog alert = (AlertDialog) dialog;
alert.setMessage(getString(R.string.account_duplicate_dlg_message_fmt,
mDuplicateAccountName));
}
break;
}
}
private void finishAutoSetup() {
String email = mEmailView.getText().toString().trim();
String password = mPasswordView.getText().toString().trim();
String[] emailParts = email.split("@");
String user = emailParts[0];
String domain = emailParts[1];
URI incomingUri = null;
URI outgoingUri = null;
try {
String incomingUsername = mProvider.incomingUsernameTemplate;
incomingUsername = incomingUsername.replaceAll("\\$email", email);
incomingUsername = incomingUsername.replaceAll("\\$user", user);
incomingUsername = incomingUsername.replaceAll("\\$domain", domain);
URI incomingUriTemplate = mProvider.incomingUriTemplate;
incomingUri = new URI(incomingUriTemplate.getScheme(), incomingUsername + ":"
+ password, incomingUriTemplate.getHost(), incomingUriTemplate.getPort(),
incomingUriTemplate.getPath(), null, null);
String outgoingUsername = mProvider.outgoingUsernameTemplate;
outgoingUsername = outgoingUsername.replaceAll("\\$email", email);
outgoingUsername = outgoingUsername.replaceAll("\\$user", user);
outgoingUsername = outgoingUsername.replaceAll("\\$domain", domain);
URI outgoingUriTemplate = mProvider.outgoingUriTemplate;
outgoingUri = new URI(outgoingUriTemplate.getScheme(), outgoingUsername + ":"
+ password, outgoingUriTemplate.getHost(), outgoingUriTemplate.getPort(),
outgoingUriTemplate.getPath(), null, null);
// Stop here if the login credentials duplicate an existing account
mDuplicateAccountName = Utility.findDuplicateAccount(this, -1,
incomingUri.getHost(), incomingUsername);
if (mDuplicateAccountName != null) {
this.showDialog(DIALOG_DUPLICATE_ACCOUNT);
return;
}
} catch (URISyntaxException use) {
/*
* If there is some problem with the URI we give up and go on to
* manual setup. Technically speaking, AutoDiscover is OK here, since user clicked
* "Next" to get here. This would never happen in practice because we don't expect
* to find any EAS accounts in the providers list.
*/
onManualSetup(true);
return;
}
mAccount = new EmailContent.Account();
mAccount.setSenderName(getOwnerName());
mAccount.setEmailAddress(email);
mAccount.setStoreUri(this, incomingUri.toString());
mAccount.setSenderUri(this, outgoingUri.toString());
/* TODO figure out the best way to implement this concept
mAccount.setDraftsFolderName(getString(R.string.special_mailbox_name_drafts));
mAccount.setTrashFolderName(getString(R.string.special_mailbox_name_trash));
mAccount.setOutboxFolderName(getString(R.string.special_mailbox_name_outbox));
mAccount.setSentFolderName(getString(R.string.special_mailbox_name_sent));
*/
if (incomingUri.toString().startsWith("imap")) {
// Delete policy must be set explicitly, because IMAP does not provide a UI selection
// for it. This logic needs to be followed in the auto setup flow as well.
mAccount.setDeletePolicy(EmailContent.Account.DELETE_POLICY_ON_DELETE);
}
mAccount.setSyncInterval(DEFAULT_ACCOUNT_CHECK_INTERVAL);
AccountSetupCheckSettings.actionValidateSettings(this, mAccount, true, true);
}
private void onNext() {
// If this is EAS flow, don't try to find a provider for the domain!
if (!mEasFlowMode) {
String email = mEmailView.getText().toString().trim();
String[] emailParts = email.split("@");
String domain = emailParts[1].trim();
mProvider = AccountSettingsUtils.findProviderForDomain(this, domain);
if (mProvider != null) {
if (mProvider.note != null) {
showDialog(DIALOG_NOTE);
} else {
finishAutoSetup();
}
return;
}
}
// Can't use auto setup (although EAS accounts may still be able to AutoDiscover)
onManualSetup(true);
}
/**
* This is used in automatic setup mode to jump directly down to the names screen.
*
* NOTE: With this organization, it is *not* possible to auto-create an exchange account,
* because certain necessary actions happen during AccountSetupOptions (which we are
* skipping here).
*/
@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
if (resultCode == RESULT_OK) {
String email = mAccount.getEmailAddress();
boolean isDefault = mDefaultView.isChecked();
mAccount.setDisplayName(email);
mAccount.setDefaultAccount(isDefault);
// At this point we write the Account object to the DB for the first time.
// From now on we'll only pass the accountId around.
mAccount.save(this);
// Update the backup (side copy) of the accounts
AccountBackupRestore.backupAccounts(this);
Email.setServicesEnabled(this);
AccountSetupNames.actionSetNames(this, mAccount.mId, false);
finish();
}
}
/**
* @param allowAutoDiscover - true if the user clicked 'next' and (if the account is EAS)
* it's OK to use autodiscover. false to prevent autodiscover and go straight to manual setup.
* Ignored for IMAP & POP accounts.
*/
private void onManualSetup(boolean allowAutoDiscover) {
String email = mEmailView.getText().toString().trim();
String password = mPasswordView.getText().toString().trim();
String[] emailParts = email.split("@");
String user = emailParts[0].trim();
String domain = emailParts[1].trim();
// Alternate entry to the debug options screen (for devices without a physical keyboard:
// Username: d@d.d
// Password: debug
if (ENTER_DEBUG_SCREEN && "d@d.d".equals(email) && "debug".equals(password)) {
mEmailView.setText("");
mPasswordView.setText("");
startActivity(new Intent(this, Debug.class));
return;
}
mAccount = new EmailContent.Account();
mAccount.setSenderName(getOwnerName());
mAccount.setEmailAddress(email);
try {
URI uri = new URI("placeholder", user + ":" + password, domain, -1, null, null, null);
mAccount.setStoreUri(this, uri.toString());
mAccount.setSenderUri(this, uri.toString());
} catch (URISyntaxException use) {
// If we can't set up the URL, don't continue - account setup pages will fail too
Toast.makeText(this, R.string.account_setup_username_password_toast, Toast.LENGTH_LONG)
.show();
mAccount = null;
return;
}
/* TODO figure out the best way to implement this concept
mAccount.setDraftsFolderName(getString(R.string.special_mailbox_name_drafts));
mAccount.setTrashFolderName(getString(R.string.special_mailbox_name_trash));
mAccount.setOutboxFolderName(getString(R.string.special_mailbox_name_outbox));
mAccount.setSentFolderName(getString(R.string.special_mailbox_name_sent));
*/
mAccount.setSyncInterval(DEFAULT_ACCOUNT_CHECK_INTERVAL);
AccountSetupAccountType.actionSelectAccountType(this, mAccount, mDefaultView.isChecked(),
mEasFlowMode, allowAutoDiscover);
}
public void onClick(View v) {
switch (v.getId()) {
case R.id.next:
onNext();
break;
case R.id.manual_setup:
// no AutoDiscover - user clicked "manual"
onManualSetup(false);
break;
}
}
}