8e78aabf3a
Fixes an ambiguous import involving OperationCanceledException. Change-Id: Ie96b1225b44342eabb70e25ce6e43dc027b65489
535 lines
24 KiB
Java
535 lines
24 KiB
Java
/*
|
|
* Copyright (C) 2009 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.development;
|
|
|
|
import android.accounts.Account;
|
|
import android.accounts.AccountManager;
|
|
import android.accounts.AccountManagerCallback;
|
|
import android.accounts.AccountManagerFuture;
|
|
import android.accounts.AuthenticatorDescription;
|
|
import android.accounts.AuthenticatorException;
|
|
import android.accounts.OnAccountsUpdateListener;
|
|
import android.accounts.OperationCanceledException;
|
|
import android.app.Activity;
|
|
import android.app.AlertDialog;
|
|
import android.app.Dialog;
|
|
import android.content.Context;
|
|
import android.content.DialogInterface;
|
|
import android.content.pm.PackageManager;
|
|
import android.content.res.Resources;
|
|
import android.os.Bundle;
|
|
import android.os.Handler;
|
|
import android.os.Parcelable;
|
|
import android.text.TextUtils;
|
|
import android.util.Log;
|
|
import android.view.ContextMenu;
|
|
import android.view.LayoutInflater;
|
|
import android.view.MenuInflater;
|
|
import android.view.MenuItem;
|
|
import android.view.View;
|
|
import android.view.ViewGroup;
|
|
import android.widget.AdapterView;
|
|
import android.widget.ArrayAdapter;
|
|
import android.widget.EditText;
|
|
import android.widget.ImageView;
|
|
import android.widget.ListView;
|
|
import android.widget.Spinner;
|
|
import android.widget.TextView;
|
|
|
|
import java.io.IOException;
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
|
|
public class AccountsTester extends Activity implements OnAccountsUpdateListener {
|
|
private static final String TAG = "AccountsTester";
|
|
private Spinner mAccountTypesSpinner;
|
|
private ListView mAccountsListView;
|
|
private AccountManager mAccountManager;
|
|
private Account mLongPressedAccount = null;
|
|
private AuthenticatorDescription[] mAuthenticatorDescs;
|
|
|
|
private static final int GET_AUTH_TOKEN_DIALOG_ID = 1;
|
|
private static final int UPDATE_CREDENTIALS_DIALOG_ID = 2;
|
|
private static final int INVALIDATE_AUTH_TOKEN_DIALOG_ID = 3;
|
|
private static final int TEST_HAS_FEATURES_DIALOG_ID = 4;
|
|
private static final int MESSAGE_DIALOG_ID = 5;
|
|
private static final int GET_AUTH_TOKEN_BY_TYPE_AND_FEATURE_DIALOG_ID = 6;
|
|
|
|
private EditText mDesiredAuthTokenTypeEditText;
|
|
private EditText mDesiredFeaturesEditText;
|
|
private volatile CharSequence mDialogMessage;
|
|
|
|
@Override
|
|
protected void onCreate(Bundle savedInstanceState) {
|
|
super.onCreate(savedInstanceState);
|
|
mAccountManager = AccountManager.get(this);
|
|
setContentView(R.layout.accounts_tester);
|
|
ButtonClickListener buttonClickListener = new ButtonClickListener();
|
|
|
|
mAccountTypesSpinner = (Spinner) findViewById(R.id.accounts_tester_account_types_spinner);
|
|
mAccountsListView = (ListView) findViewById(R.id.accounts_tester_accounts_list);
|
|
registerForContextMenu(mAccountsListView);
|
|
initializeAuthenticatorsSpinner();
|
|
findViewById(R.id.accounts_tester_get_all_accounts).setOnClickListener(buttonClickListener);
|
|
findViewById(R.id.accounts_tester_get_accounts_by_type).setOnClickListener(
|
|
buttonClickListener);
|
|
findViewById(R.id.accounts_tester_add_account).setOnClickListener(buttonClickListener);
|
|
findViewById(R.id.accounts_tester_edit_properties).setOnClickListener(buttonClickListener);
|
|
findViewById(R.id.accounts_tester_get_auth_token_by_type_and_feature).setOnClickListener(
|
|
buttonClickListener);
|
|
mDesiredAuthTokenTypeEditText =
|
|
(EditText) findViewById(R.id.accounts_tester_desired_authtokentype);
|
|
mDesiredFeaturesEditText = (EditText) findViewById(R.id.accounts_tester_desired_features);
|
|
}
|
|
|
|
private class AccountArrayAdapter extends ArrayAdapter<Account> {
|
|
protected LayoutInflater mInflater;
|
|
|
|
public AccountArrayAdapter(Context context, Account[] accounts) {
|
|
super(context, R.layout.account_list_item, accounts);
|
|
mInflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
|
|
}
|
|
|
|
class ViewHolder {
|
|
TextView name;
|
|
ImageView icon;
|
|
Account account;
|
|
}
|
|
|
|
@Override
|
|
public View getView(int position, View convertView, ViewGroup parent) {
|
|
// A ViewHolder keeps references to children views to avoid unneccessary calls
|
|
// to findViewById() on each row.
|
|
ViewHolder holder;
|
|
|
|
// When convertView is not null, we can reuse it directly, there is no need
|
|
// to reinflate it. We only inflate a new View when the convertView supplied
|
|
// by ListView is null.
|
|
if (convertView == null) {
|
|
convertView = mInflater.inflate(R.layout.account_list_item, null);
|
|
|
|
// Creates a ViewHolder and store references to the two children views
|
|
// we want to bind data to.
|
|
holder = new ViewHolder();
|
|
holder.name = (TextView) convertView.findViewById(
|
|
R.id.accounts_tester_account_name);
|
|
holder.icon = (ImageView) convertView.findViewById(
|
|
R.id.accounts_tester_account_type_icon);
|
|
|
|
convertView.setTag(holder);
|
|
} else {
|
|
// Get the ViewHolder back to get fast access to the TextView
|
|
// and the ImageView.
|
|
holder = (ViewHolder) convertView.getTag();
|
|
}
|
|
|
|
final Account account = getItem(position);
|
|
holder.account = account;
|
|
holder.icon.setVisibility(View.INVISIBLE);
|
|
for (AuthenticatorDescription desc : mAuthenticatorDescs) {
|
|
if (desc.type.equals(account.type)) {
|
|
final String packageName = desc.packageName;
|
|
try {
|
|
final Context authContext = getContext().createPackageContext(packageName,
|
|
0);
|
|
holder.icon.setImageDrawable(authContext.getResources().getDrawable(
|
|
desc.iconId));
|
|
holder.icon.setVisibility(View.VISIBLE);
|
|
} catch (PackageManager.NameNotFoundException e) {
|
|
Log.d(TAG, "error getting the Package Context for " + packageName, e);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Set text field
|
|
holder.name.setText(account.name);
|
|
return convertView;
|
|
}
|
|
}
|
|
|
|
private void initializeAuthenticatorsSpinner() {
|
|
mAuthenticatorDescs = mAccountManager.getAuthenticatorTypes();
|
|
List<String> names = new ArrayList(mAuthenticatorDescs.length);
|
|
for (int i = 0; i < mAuthenticatorDescs.length; i++) {
|
|
Context authContext;
|
|
try {
|
|
authContext = createPackageContext(mAuthenticatorDescs[i].packageName, 0);
|
|
} catch (PackageManager.NameNotFoundException e) {
|
|
continue;
|
|
}
|
|
try {
|
|
names.add(authContext.getString(mAuthenticatorDescs[i].labelId));
|
|
} catch (Resources.NotFoundException e) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
String[] namesArray = names.toArray(new String[names.size()]);
|
|
ArrayAdapter<String> adapter =
|
|
new ArrayAdapter<String>(AccountsTester.this,
|
|
android.R.layout.simple_spinner_item, namesArray);
|
|
mAccountTypesSpinner.setAdapter(adapter);
|
|
}
|
|
|
|
public void onAccountsUpdated(Account[] accounts) {
|
|
Log.d(TAG, "onAccountsUpdated: \n " + TextUtils.join("\n ", accounts));
|
|
mAccountsListView.setAdapter(new AccountArrayAdapter(this, accounts));
|
|
}
|
|
|
|
protected void onStart() {
|
|
super.onStart();
|
|
final Handler mainHandler = new Handler(getMainLooper());
|
|
mAccountManager.addOnAccountsUpdatedListener(this, mainHandler,
|
|
true /* updateImmediately */);
|
|
}
|
|
|
|
protected void onStop() {
|
|
super.onStop();
|
|
mAccountManager.removeOnAccountsUpdatedListener(this);
|
|
}
|
|
|
|
class ButtonClickListener implements View.OnClickListener {
|
|
public void onClick(View v) {
|
|
if (R.id.accounts_tester_get_all_accounts == v.getId()) {
|
|
onAccountsUpdated(mAccountManager.getAccounts());
|
|
} else if (R.id.accounts_tester_get_accounts_by_type == v.getId()) {
|
|
String type = getSelectedAuthenticator().type;
|
|
onAccountsUpdated(mAccountManager.getAccountsByType(type));
|
|
} else if (R.id.accounts_tester_add_account == v.getId()) {
|
|
String authTokenType = mDesiredAuthTokenTypeEditText.getText().toString();
|
|
if (TextUtils.isEmpty(authTokenType)) {
|
|
authTokenType = null;
|
|
}
|
|
String featureString = mDesiredFeaturesEditText.getText().toString();
|
|
String[] requiredFeatures = TextUtils.split(featureString, " ");
|
|
if (requiredFeatures.length == 0) {
|
|
requiredFeatures = null;
|
|
}
|
|
mAccountManager.addAccount(getSelectedAuthenticator().type,
|
|
authTokenType, requiredFeatures, null /* options */,
|
|
AccountsTester.this,
|
|
new CallbackToDialog(AccountsTester.this, "add account"),
|
|
null /* handler */);
|
|
} else if (R.id.accounts_tester_edit_properties == v.getId()) {
|
|
mAccountManager.editProperties(getSelectedAuthenticator().type,
|
|
AccountsTester.this,
|
|
new CallbackToDialog(AccountsTester.this, "edit properties"),
|
|
null /* handler */);
|
|
} else if (R.id.accounts_tester_get_auth_token_by_type_and_feature == v.getId()) {
|
|
showDialog(GET_AUTH_TOKEN_BY_TYPE_AND_FEATURE_DIALOG_ID);
|
|
} else {
|
|
// unknown button
|
|
}
|
|
}
|
|
}
|
|
|
|
private AuthenticatorDescription getSelectedAuthenticator() {
|
|
return mAuthenticatorDescs[mAccountTypesSpinner.getSelectedItemPosition()];
|
|
}
|
|
|
|
@Override
|
|
public void onCreateContextMenu(ContextMenu menu, View v,
|
|
ContextMenu.ContextMenuInfo menuInfo) {
|
|
menu.setHeaderTitle(R.string.accounts_tester_account_context_menu_title);
|
|
|
|
AdapterView.AdapterContextMenuInfo info = (AdapterView.AdapterContextMenuInfo)menuInfo;
|
|
|
|
MenuInflater inflater = getMenuInflater();
|
|
inflater.inflate(R.layout.account_list_context_menu, menu);
|
|
AccountArrayAdapter.ViewHolder holder =
|
|
(AccountArrayAdapter.ViewHolder)info.targetView.getTag();
|
|
mLongPressedAccount = holder.account;
|
|
}
|
|
|
|
protected void onSaveInstanceState(Bundle outState) {
|
|
outState.putParcelable("account", mLongPressedAccount);
|
|
}
|
|
|
|
protected void onRestoreInstanceState(Bundle savedInstanceState) {
|
|
mLongPressedAccount = savedInstanceState.getParcelable("account");
|
|
}
|
|
|
|
@Override
|
|
public boolean onContextItemSelected(MenuItem item) {
|
|
if (item.getItemId() == R.id.accounts_tester_remove_account) {
|
|
final Account account = mLongPressedAccount;
|
|
mAccountManager.removeAccount(account, new AccountManagerCallback<Boolean>() {
|
|
public void run(AccountManagerFuture<Boolean> future) {
|
|
try {
|
|
Log.d(TAG, "removeAccount(" + account + ") = " + future.getResult());
|
|
} catch (OperationCanceledException e) {
|
|
} catch (IOException e) {
|
|
} catch (AuthenticatorException e) {
|
|
}
|
|
}
|
|
}, null /* handler */);
|
|
} else if (item.getItemId() == R.id.accounts_tester_clear_password) {
|
|
final Account account = mLongPressedAccount;
|
|
mAccountManager.clearPassword(account);
|
|
showMessageDialog("cleared");
|
|
} else if (item.getItemId() == R.id.accounts_tester_get_auth_token) {
|
|
showDialog(GET_AUTH_TOKEN_DIALOG_ID);
|
|
} else if (item.getItemId() == R.id.accounts_tester_test_has_features) {
|
|
showDialog(TEST_HAS_FEATURES_DIALOG_ID);
|
|
} else if (item.getItemId() == R.id.accounts_tester_invalidate_auth_token) {
|
|
showDialog(INVALIDATE_AUTH_TOKEN_DIALOG_ID);
|
|
} else if (item.getItemId() == R.id.accounts_tester_update_credentials) {
|
|
showDialog(UPDATE_CREDENTIALS_DIALOG_ID);
|
|
} else if (item.getItemId() == R.id.accounts_tester_confirm_credentials) {
|
|
mAccountManager.confirmCredentials(mLongPressedAccount, null,
|
|
AccountsTester.this, new CallbackToDialog(this, "confirm credentials"),
|
|
null /* handler */);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
protected Dialog onCreateDialog(final int id) {
|
|
switch (id) {
|
|
case GET_AUTH_TOKEN_DIALOG_ID:
|
|
case INVALIDATE_AUTH_TOKEN_DIALOG_ID:
|
|
case UPDATE_CREDENTIALS_DIALOG_ID:
|
|
case TEST_HAS_FEATURES_DIALOG_ID: {
|
|
final View view = LayoutInflater.from(this).inflate(R.layout.get_auth_token_view,
|
|
null);
|
|
AlertDialog.Builder builder = new AlertDialog.Builder(this);
|
|
builder.setPositiveButton(R.string.accounts_tester_ok_button,
|
|
new DialogInterface.OnClickListener() {
|
|
public void onClick(DialogInterface dialog, int which) {
|
|
EditText value = (EditText) view.findViewById(
|
|
R.id.accounts_tester_auth_token_type);
|
|
|
|
String authTokenType = value.getText().toString();
|
|
final Account account = mLongPressedAccount;
|
|
if (id == GET_AUTH_TOKEN_DIALOG_ID) {
|
|
mAccountManager.getAuthToken(account,
|
|
authTokenType,
|
|
null /* loginOptions */,
|
|
AccountsTester.this,
|
|
new CallbackToDialog(AccountsTester.this,
|
|
"get auth token"),
|
|
null /* handler */);
|
|
} else if (id == INVALIDATE_AUTH_TOKEN_DIALOG_ID) {
|
|
mAccountManager.getAuthToken(account, authTokenType, false,
|
|
new GetAndInvalidateAuthTokenCallback(account), null);
|
|
} else if (id == TEST_HAS_FEATURES_DIALOG_ID) {
|
|
String[] features = TextUtils.split(authTokenType, ",");
|
|
mAccountManager.hasFeatures(account, features,
|
|
new TestHasFeaturesCallback(), null);
|
|
} else {
|
|
mAccountManager.updateCredentials(
|
|
account,
|
|
authTokenType, null /* loginOptions */,
|
|
AccountsTester.this,
|
|
new CallbackToDialog(AccountsTester.this, "update"),
|
|
null /* handler */);
|
|
}
|
|
}
|
|
});
|
|
builder.setView(view);
|
|
return builder.create();
|
|
}
|
|
|
|
case GET_AUTH_TOKEN_BY_TYPE_AND_FEATURE_DIALOG_ID: {
|
|
final View view = LayoutInflater.from(this).inflate(R.layout.get_features_view,
|
|
null);
|
|
AlertDialog.Builder builder = new AlertDialog.Builder(this);
|
|
builder.setPositiveButton(R.string.accounts_tester_ok_button,
|
|
new DialogInterface.OnClickListener() {
|
|
public void onClick(DialogInterface dialog, int which) {
|
|
EditText value = (EditText) view.findViewById(
|
|
R.id.accounts_tester_auth_token_type);
|
|
|
|
String authTokenType = value.getText().toString();
|
|
|
|
value = (EditText) view.findViewById(
|
|
R.id.accounts_tester_features);
|
|
|
|
String features = value.getText().toString();
|
|
|
|
final Account account = mLongPressedAccount;
|
|
mAccountManager.getAuthTokenByFeatures(
|
|
getSelectedAuthenticator().type,
|
|
authTokenType,
|
|
TextUtils.isEmpty(features) ? null : features.split(" "),
|
|
AccountsTester.this,
|
|
null /* addAccountOptions */,
|
|
null /* getAuthTokenOptions */,
|
|
new CallbackToDialog(AccountsTester.this,
|
|
"get auth token by features"),
|
|
null /* handler */);
|
|
}
|
|
});
|
|
builder.setView(view);
|
|
return builder.create();
|
|
}
|
|
|
|
case MESSAGE_DIALOG_ID: {
|
|
AlertDialog.Builder builder = new AlertDialog.Builder(this);
|
|
builder.setMessage(mDialogMessage);
|
|
return builder.create();
|
|
}
|
|
}
|
|
|
|
return super.onCreateDialog(id);
|
|
}
|
|
|
|
AccountManagerCallback<Bundle> newAccountsCallback(String type, String[] features) {
|
|
return new GetAccountsCallback(type, features);
|
|
}
|
|
|
|
class GetAccountsCallback implements AccountManagerCallback<Bundle> {
|
|
final String[] mFeatures;
|
|
final String mAccountType;
|
|
|
|
public GetAccountsCallback(String type, String[] features) {
|
|
mFeatures = features;
|
|
mAccountType = type;
|
|
}
|
|
|
|
public void run(AccountManagerFuture<Bundle> future) {
|
|
Log.d(TAG, "GetAccountsCallback: type " + mAccountType
|
|
+ ", features "
|
|
+ (mFeatures == null ? "none" : TextUtils.join(",", mFeatures)));
|
|
try {
|
|
Bundle result = future.getResult();
|
|
Parcelable[] accounts = result.getParcelableArray(AccountManager.KEY_ACCOUNTS);
|
|
Log.d(TAG, "found " + accounts.length + " accounts");
|
|
for (Parcelable account : accounts) {
|
|
Log.d(TAG, " " + account);
|
|
}
|
|
} catch (OperationCanceledException e) {
|
|
Log.d(TAG, "failure", e);
|
|
} catch (IOException e) {
|
|
Log.d(TAG, "failure", e);
|
|
} catch (AuthenticatorException e) {
|
|
Log.d(TAG, "failure", e);
|
|
}
|
|
}
|
|
}
|
|
|
|
AccountManagerCallback<Bundle> newAuthTokensCallback(String type, String authTokenType,
|
|
String[] features) {
|
|
return new GetAuthTokenCallback(type, authTokenType, features);
|
|
}
|
|
|
|
class GetAuthTokenCallback implements AccountManagerCallback<Bundle> {
|
|
final String[] mFeatures;
|
|
final String mAccountType;
|
|
final String mAuthTokenType;
|
|
|
|
public GetAuthTokenCallback(String type, String authTokenType, String[] features) {
|
|
mFeatures = features;
|
|
mAccountType = type;
|
|
mAuthTokenType = authTokenType;
|
|
}
|
|
|
|
public void run(AccountManagerFuture<Bundle> future) {
|
|
Log.d(TAG, "GetAuthTokenCallback: type " + mAccountType
|
|
+ ", features "
|
|
+ (mFeatures == null ? "none" : TextUtils.join(",", mFeatures)));
|
|
getAndLogResult(future, "get auth token");
|
|
}
|
|
}
|
|
|
|
private class GetAndInvalidateAuthTokenCallback implements AccountManagerCallback<Bundle> {
|
|
private final Account mAccount;
|
|
|
|
private GetAndInvalidateAuthTokenCallback(Account account) {
|
|
mAccount = account;
|
|
}
|
|
|
|
public void run(AccountManagerFuture<Bundle> future) {
|
|
Bundle result = getAndLogResult(future, "get and invalidate");
|
|
if (result != null) {
|
|
String authToken = result.getString(AccountManager.KEY_AUTHTOKEN);
|
|
mAccountManager.invalidateAuthToken(mAccount.type, authToken);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void showMessageDialog(String message) {
|
|
mDialogMessage = message;
|
|
removeDialog(MESSAGE_DIALOG_ID);
|
|
showDialog(MESSAGE_DIALOG_ID);
|
|
}
|
|
|
|
private class TestHasFeaturesCallback implements AccountManagerCallback<Boolean> {
|
|
public void run(AccountManagerFuture<Boolean> future) {
|
|
try {
|
|
Boolean hasFeatures = future.getResult();
|
|
Log.d(TAG, "hasFeatures: " + hasFeatures);
|
|
showMessageDialog("hasFeatures: " + hasFeatures);
|
|
} catch (OperationCanceledException e) {
|
|
Log.d(TAG, "interrupted");
|
|
showMessageDialog("operation was canceled");
|
|
} catch (IOException e) {
|
|
Log.d(TAG, "error", e);
|
|
showMessageDialog("operation got an IOException");
|
|
} catch (AuthenticatorException e) {
|
|
Log.d(TAG, "error", e);
|
|
showMessageDialog("operation got an AuthenticationException");
|
|
}
|
|
}
|
|
}
|
|
|
|
private static class CallbackToDialog implements AccountManagerCallback<Bundle> {
|
|
private final AccountsTester mActivity;
|
|
private final String mLabel;
|
|
|
|
private CallbackToDialog(AccountsTester activity, String label) {
|
|
mActivity = activity;
|
|
mLabel = label;
|
|
}
|
|
|
|
public void run(AccountManagerFuture<Bundle> future) {
|
|
mActivity.getAndLogResult(future, mLabel);
|
|
}
|
|
}
|
|
|
|
private Bundle getAndLogResult(AccountManagerFuture<Bundle> future, String label) {
|
|
try {
|
|
Bundle result = future.getResult();
|
|
result.keySet();
|
|
Log.d(TAG, label + ": " + result);
|
|
StringBuffer sb = new StringBuffer();
|
|
sb.append(label).append(" result:");
|
|
for (String key : result.keySet()) {
|
|
Object value = result.get(key);
|
|
if (AccountManager.KEY_AUTHTOKEN.equals(key)) {
|
|
value = "<redacted>";
|
|
}
|
|
sb.append("\n ").append(key).append(" -> ").append(value);
|
|
}
|
|
showMessageDialog(sb.toString());
|
|
return result;
|
|
} catch (OperationCanceledException e) {
|
|
Log.d(TAG, label + " failed", e);
|
|
showMessageDialog(label + " was canceled");
|
|
return null;
|
|
} catch (IOException e) {
|
|
Log.d(TAG, label + " failed", e);
|
|
showMessageDialog(label + " failed with IOException: " + e.getMessage());
|
|
return null;
|
|
} catch (AuthenticatorException e) {
|
|
Log.d(TAG, label + " failed", e);
|
|
showMessageDialog(label + " failed with an AuthenticatorException: " + e.getMessage());
|
|
return null;
|
|
}
|
|
}
|
|
}
|