/*
* Copyright (C) 2011 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 android.accounts;
import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.content.res.Resources;
import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.os.Parcelable;
import android.text.TextUtils;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.ListView;
import android.widget.TextView;
import com.android.internal.R;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;
/**
* @hide
*/
public class ChooseTypeAndAccountActivity extends Activity
implements AccountManagerCallback<Bundle> {
private static final String TAG = "AccountChooser";
/**
* A Parcelable ArrayList of Account objects that limits the choosable accounts to those
* in this list, if this parameter is supplied.
*/
public static final String EXTRA_ALLOWABLE_ACCOUNTS_ARRAYLIST = "allowableAccounts";
/**
* A Parcelable ArrayList of String objects that limits the accounts to choose to those
* that match the types in this list, if this parameter is supplied. This list is also
* used to filter the allowable account types if add account is selected.
*/
public static final String EXTRA_ALLOWABLE_ACCOUNT_TYPES_STRING_ARRAY = "allowableAccountTypes";
/**
* This is passed as the addAccountOptions parameter in AccountManager.addAccount()
* if it is called.
*/
public static final String EXTRA_ADD_ACCOUNT_OPTIONS_BUNDLE = "addAccountOptions";
/**
* This is passed as the requiredFeatures parameter in AccountManager.addAccount()
* if it is called.
*/
public static final String EXTRA_ADD_ACCOUNT_REQUIRED_FEATURES_STRING_ARRAY =
"addAccountRequiredFeatures";
/**
* This is passed as the authTokenType string in AccountManager.addAccount()
* if it is called.
*/
public static final String EXTRA_ADD_ACCOUNT_AUTH_TOKEN_TYPE_STRING = "authTokenType";
/**
* If set then the specified account is already "selected".
*/
public static final String EXTRA_SELECTED_ACCOUNT = "selectedAccount";
/**
* If true then display the account selection list even if there is just
* one account to choose from. boolean.
*/
public static final String EXTRA_ALWAYS_PROMPT_FOR_ACCOUNT =
"alwaysPromptForAccount";
/**
* If set then this string willb e used as the description rather than
* the default.
*/
public static final String EXTRA_DESCRIPTION_TEXT_OVERRIDE =
"descriptionTextOverride";
public static final int REQUEST_NULL = 0;
public static final int REQUEST_CHOOSE_TYPE = 1;
public static final int REQUEST_ADD_ACCOUNT = 2;
private static final String KEY_INSTANCE_STATE_PENDING_REQUEST = "pendingRequest";
private static final String KEY_INSTANCE_STATE_EXISTING_ACCOUNTS = "existingAccounts";
private ArrayList<AccountInfo> mAccountInfos;
private int mPendingRequest = REQUEST_NULL;
private Parcelable[] mExistingAccounts = null;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
if (Log.isLoggable(TAG, Log.VERBOSE)) {
Log.v(TAG, "ChooseTypeAndAccountActivity.onCreate(savedInstanceState="
+ savedInstanceState + ")");
}
setContentView(R.layout.choose_type_and_account);
if (savedInstanceState != null) {
mPendingRequest = savedInstanceState.getInt(KEY_INSTANCE_STATE_PENDING_REQUEST);
mExistingAccounts =
savedInstanceState.getParcelableArray(KEY_INSTANCE_STATE_EXISTING_ACCOUNTS);
} else {
mPendingRequest = REQUEST_NULL;
mExistingAccounts = null;
}
// save some items we use frequently
final AccountManager accountManager = AccountManager.get(this);
final Intent intent = getIntent();
// override the description text if supplied
final String descriptionOverride =
intent.getStringExtra(EXTRA_DESCRIPTION_TEXT_OVERRIDE);
if (!TextUtils.isEmpty(descriptionOverride)) {
((TextView)findViewById(R.id.description)).setText(descriptionOverride);
}
// If the selected account matches one in the list we will place a
// checkmark next to it.
final Account selectedAccount =
(Account)intent.getParcelableExtra(EXTRA_SELECTED_ACCOUNT);
// build an efficiently queryable map of account types to authenticator descriptions
final HashMap<String, AuthenticatorDescription> typeToAuthDescription =
new HashMap<String, AuthenticatorDescription>();
for(AuthenticatorDescription desc : accountManager.getAuthenticatorTypes()) {
typeToAuthDescription.put(desc.type, desc);
}
// Read the validAccounts, if present, and add them to the setOfAllowableAccounts
Set<Account> setOfAllowableAccounts = null;
final ArrayList<Parcelable> validAccounts =
intent.getParcelableArrayListExtra(EXTRA_ALLOWABLE_ACCOUNTS_ARRAYLIST);
if (validAccounts != null) {
setOfAllowableAccounts = new HashSet<Account>(validAccounts.size());
for (Parcelable parcelable : validAccounts) {
setOfAllowableAccounts.add((Account)parcelable);
}
}
// Read the validAccountTypes, if present, and add them to the setOfAllowableAccountTypes
Set<String> setOfAllowableAccountTypes = null;
final String[] validAccountTypes =
intent.getStringArrayExtra(EXTRA_ALLOWABLE_ACCOUNT_TYPES_STRING_ARRAY);
if (validAccountTypes != null) {
setOfAllowableAccountTypes = new HashSet<String>(validAccountTypes.length);
for (String type : validAccountTypes) {
setOfAllowableAccountTypes.add(type);
}
}
// Create a list of AccountInfo objects for each account that is allowable. Filter out
// accounts that don't match the allowable types, if provided, or that don't match the
// allowable accounts, if provided.
final Account[] accounts = accountManager.getAccounts();
mAccountInfos = new ArrayList<AccountInfo>(accounts.length);
for (Account account : accounts) {
if (setOfAllowableAccounts != null
&& !setOfAllowableAccounts.contains(account)) {
continue;
}
if (setOfAllowableAccountTypes != null
&& !setOfAllowableAccountTypes.contains(account.type)) {
continue;
}
mAccountInfos.add(new AccountInfo(account,
getDrawableForType(typeToAuthDescription, account.type),
account.equals(selectedAccount)));
}
// there is more than one allowable account. initialize the list adapter to allow
// the user to select an account.
ListView list = (ListView) findViewById(android.R.id.list);
list.setAdapter(new AccountArrayAdapter(this,
android.R.layout.simple_list_item_1, mAccountInfos));
list.setChoiceMode(ListView.CHOICE_MODE_SINGLE);
list.setOnItemClickListener(new AdapterView.OnItemClickListener() {
public void onItemClick(AdapterView<?> parent, View v, int position, long id) {
onListItemClick((ListView)parent, v, position, id);
}
});
// set the listener for the addAccount button
Button addAccountButton = (Button) findViewById(R.id.addAccount);
addAccountButton.setOnClickListener(new View.OnClickListener() {
public void onClick(final View v) {
startChooseAccountTypeActivity();
}
});
if (mPendingRequest == REQUEST_NULL) {
// If there are no allowable accounts go directly to add account
if (mAccountInfos.isEmpty()) {
startChooseAccountTypeActivity();
return;
}
// if there is only one allowable account return it
if (!intent.getBooleanExtra(EXTRA_ALWAYS_PROMPT_FOR_ACCOUNT, false)
&& mAccountInfos.size() == 1) {
Account account = mAccountInfos.get(0).account;
setResultAndFinish(account.name, account.type);
return;
}
}
}
@Override
protected void onDestroy() {
if (Log.isLoggable(TAG, Log.VERBOSE)) {
Log.v(TAG, "ChooseTypeAndAccountActivity.onDestroy()");
}
super.onDestroy();
}
@Override
protected void onSaveInstanceState(final Bundle outState) {
super.onSaveInstanceState(outState);
outState.putInt(KEY_INSTANCE_STATE_PENDING_REQUEST, mPendingRequest);
if (mPendingRequest == REQUEST_ADD_ACCOUNT) {
outState.putParcelableArray(KEY_INSTANCE_STATE_EXISTING_ACCOUNTS, mExistingAccounts);
}
}
// Called when the choose account type activity (for adding an account) returns.
// If it was a success read the account and set it in the result. In all cases
// return the result and finish this activity.
@Override
protected void onActivityResult(final int requestCode, final int resultCode,
final Intent data) {
if (Log.isLoggable(TAG, Log.VERBOSE)) {
if (data != null && data.getExtras() != null) data.getExtras().keySet();
Bundle extras = data != null ? data.getExtras() : null;
Log.v(TAG, "ChooseTypeAndAccountActivity.onActivityResult(reqCode=" + requestCode
+ ", resCode=" + resultCode + ", extras=" + extras + ")");
}
// we got our result, so clear the fact that we had a pending request
mPendingRequest = REQUEST_NULL;
if (resultCode == RESULT_CANCELED) {
return;
}
if (resultCode == RESULT_OK) {
if (requestCode == REQUEST_CHOOSE_TYPE) {
if (data != null) {
String accountType = data.getStringExtra(AccountManager.KEY_ACCOUNT_TYPE);
if (accountType != null) {
runAddAccountForAuthenticator(accountType);
return;
}
}
Log.d(TAG, "ChooseTypeAndAccountActivity.onActivityResult: unable to find account "
+ "type, pretending the request was canceled");
} else if (requestCode == REQUEST_ADD_ACCOUNT) {
String accountName = null;
String accountType = null;
if (data != null) {
accountName = data.getStringExtra(AccountManager.KEY_ACCOUNT_NAME);
accountType = data.getStringExtra(AccountManager.KEY_ACCOUNT_TYPE);
}
if (accountName == null || accountType == null) {
Account[] currentAccounts = AccountManager.get(this).getAccounts();
Set<Account> preExistingAccounts = new HashSet<Account>();
for (Parcelable accountParcel : mExistingAccounts) {
preExistingAccounts.add((Account) accountParcel);
}
for (Account account : currentAccounts) {
if (!preExistingAccounts.contains(account)) {
accountName = account.name;
accountType = account.type;
break;
}
}
}
if (accountName != null || accountType != null) {
setResultAndFinish(accountName, accountType);
return;
}
}
Log.d(TAG, "ChooseTypeAndAccountActivity.onActivityResult: unable to find added "
+ "account, pretending the request was canceled");
}
if (Log.isLoggable(TAG, Log.VERBOSE)) {
Log.v(TAG, "ChooseTypeAndAccountActivity.onActivityResult: canceled");
}
setResult(Activity.RESULT_CANCELED);
finish();
}
protected void runAddAccountForAuthenticator(String type) {
if (Log.isLoggable(TAG, Log.VERBOSE)) {
Log.v(TAG, "runAddAccountForAuthenticator: " + type);
}
final Bundle options = getIntent().getBundleExtra(
ChooseTypeAndAccountActivity.EXTRA_ADD_ACCOUNT_OPTIONS_BUNDLE);
final String[] requiredFeatures = getIntent().getStringArrayExtra(
ChooseTypeAndAccountActivity.EXTRA_ADD_ACCOUNT_REQUIRED_FEATURES_STRING_ARRAY);
final String authTokenType = getIntent().getStringExtra(
ChooseTypeAndAccountActivity.EXTRA_ADD_ACCOUNT_AUTH_TOKEN_TYPE_STRING);
AccountManager.get(this).addAccount(type, authTokenType, requiredFeatures,
options, null /* activity */, this /* callback */, null /* Handler */);
}
public void run(final AccountManagerFuture<Bundle> accountManagerFuture) {
try {
final Bundle accountManagerResult = accountManagerFuture.getResult();
final Intent intent = (Intent)accountManagerResult.getParcelable(
AccountManager.KEY_INTENT);
if (intent != null) {
mPendingRequest = REQUEST_ADD_ACCOUNT;
mExistingAccounts = AccountManager.get(this).getAccounts();
intent.setFlags(intent.getFlags() & ~Intent.FLAG_ACTIVITY_NEW_TASK);
startActivityForResult(intent, REQUEST_ADD_ACCOUNT);
return;
}
} catch (OperationCanceledException e) {
setResult(Activity.RESULT_CANCELED);
finish();
return;
} catch (IOException e) {
} catch (AuthenticatorException e) {
}
Bundle bundle = new Bundle();
bundle.putString(AccountManager.KEY_ERROR_MESSAGE, "error communicating with server");
setResult(Activity.RESULT_OK, new Intent().putExtras(bundle));
finish();
}
private Drawable getDrawableForType(
final HashMap<String, AuthenticatorDescription> typeToAuthDescription,
String accountType) {
Drawable icon = null;
if (typeToAuthDescription.containsKey(accountType)) {
try {
AuthenticatorDescription desc = typeToAuthDescription.get(accountType);
Context authContext = createPackageContext(desc.packageName, 0);
icon = authContext.getResources().getDrawable(desc.iconId);
} catch (PackageManager.NameNotFoundException e) {
// Nothing we can do much here, just log
if (Log.isLoggable(TAG, Log.WARN)) {
Log.w(TAG, "No icon name for account type " + accountType);
}
} catch (Resources.NotFoundException e) {
// Nothing we can do much here, just log
if (Log.isLoggable(TAG, Log.WARN)) {
Log.w(TAG, "No icon resource for account type " + accountType);
}
}
}
return icon;
}
protected void onListItemClick(ListView l, View v, int position, long id) {
AccountInfo accountInfo = mAccountInfos.get(position);
Log.d(TAG, "selected account " + accountInfo.account);
setResultAndFinish(accountInfo.account.name, accountInfo.account.type);
}
private void setResultAndFinish(final String accountName, final String accountType) {
Bundle bundle = new Bundle();
bundle.putString(AccountManager.KEY_ACCOUNT_NAME, accountName);
bundle.putString(AccountManager.KEY_ACCOUNT_TYPE, accountType);
setResult(Activity.RESULT_OK, new Intent().putExtras(bundle));
if (Log.isLoggable(TAG, Log.VERBOSE)) {
Log.v(TAG, "ChooseTypeAndAccountActivity.setResultAndFinish: "
+ "selected account " + accountName + ", " + accountType);
}
finish();
}
private void startChooseAccountTypeActivity() {
if (Log.isLoggable(TAG, Log.VERBOSE)) {
Log.v(TAG, "ChooseAccountTypeActivity.startChooseAccountTypeActivity()");
}
final Intent intent = new Intent(this, ChooseAccountTypeActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET);
intent.putExtra(EXTRA_ALLOWABLE_ACCOUNT_TYPES_STRING_ARRAY,
getIntent().getStringArrayExtra(EXTRA_ALLOWABLE_ACCOUNT_TYPES_STRING_ARRAY));
intent.putExtra(EXTRA_ADD_ACCOUNT_OPTIONS_BUNDLE,
getIntent().getBundleExtra(EXTRA_ADD_ACCOUNT_OPTIONS_BUNDLE));
intent.putExtra(EXTRA_ADD_ACCOUNT_REQUIRED_FEATURES_STRING_ARRAY,
getIntent().getStringArrayExtra(EXTRA_ADD_ACCOUNT_REQUIRED_FEATURES_STRING_ARRAY));
intent.putExtra(EXTRA_ADD_ACCOUNT_AUTH_TOKEN_TYPE_STRING,
getIntent().getStringExtra(EXTRA_ADD_ACCOUNT_AUTH_TOKEN_TYPE_STRING));
startActivityForResult(intent, REQUEST_CHOOSE_TYPE);
mPendingRequest = REQUEST_CHOOSE_TYPE;
}
private static class AccountInfo {
final Account account;
final Drawable drawable;
private final boolean checked;
AccountInfo(Account account, Drawable drawable, boolean checked) {
this.account = account;
this.drawable = drawable;
this.checked = checked;
}
}
private static class ViewHolder {
ImageView icon;
TextView text;
ImageView checkmark;
}
private static class AccountArrayAdapter extends ArrayAdapter<AccountInfo> {
private LayoutInflater mLayoutInflater;
private ArrayList<AccountInfo> mInfos;
public AccountArrayAdapter(Context context, int textViewResourceId,
ArrayList<AccountInfo> infos) {
super(context, textViewResourceId, infos);
mInfos = infos;
mLayoutInflater = (LayoutInflater) context.getSystemService(
Context.LAYOUT_INFLATER_SERVICE);
}
@Override
public View getView(int position, View convertView, ViewGroup parent) {
ViewHolder holder;
if (convertView == null) {
convertView = mLayoutInflater.inflate(R.layout.choose_selected_account_row, null);
holder = new ViewHolder();
holder.text = (TextView) convertView.findViewById(R.id.account_row_text);
holder.icon = (ImageView) convertView.findViewById(R.id.account_row_icon);
holder.checkmark = (ImageView) convertView.findViewById(R.id.account_row_checkmark);
convertView.setTag(holder);
} else {
holder = (ViewHolder) convertView.getTag();
}
holder.text.setText(mInfos.get(position).account.name);
holder.icon.setImageDrawable(mInfos.get(position).drawable);
final int displayCheckmark =
mInfos.get(position).checked ? View.VISIBLE : View.INVISIBLE;
holder.checkmark.setVisibility(displayCheckmark);
return convertView;
}
}
}