drgreen/android_frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Add a generic account chooser/add account flow for apps." into ics-factoryrom

Browse Source
This commit is contained in:
Fred Quintana
2011-09-16 12:13:30 -07:00
committed by Android (Google) Code Review
parent ebdcae732f 1121bb5e6f
commit 3d5759b527
7 changed files with 600 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
api/14.txt
View File

@ -2072,6 +2072,7 @@ package android.accounts {
method public java.lang.String getUserData(android.accounts.Account, java.lang.String);
method public android.accounts.AccountManagerFuture<java.lang.Boolean> hasFeatures(android.accounts.Account, java.lang.String[], android.accounts.AccountManagerCallback<java.lang.Boolean>, android.os.Handler);
method public void invalidateAuthToken(java.lang.String, java.lang.String);
method public static android.content.Intent newChooseAccountIntent(android.accounts.Account, java.util.ArrayList<android.accounts.Account>, java.lang.String[], android.os.Bundle);
method public java.lang.String peekAuthToken(android.accounts.Account, java.lang.String);
method public android.accounts.AccountManagerFuture<java.lang.Boolean> removeAccount(android.accounts.Account, android.accounts.AccountManagerCallback<java.lang.Boolean>, android.os.Handler);
method public void removeOnAccountsUpdatedListener(android.accounts.OnAccountsUpdateListener);

1
api/current.txt
View File

@ -2072,6 +2072,7 @@ package android.accounts {
method public java.lang.String getUserData(android.accounts.Account, java.lang.String);
method public android.accounts.AccountManagerFuture<java.lang.Boolean> hasFeatures(android.accounts.Account, java.lang.String[], android.accounts.AccountManagerCallback<java.lang.Boolean>, android.os.Handler);
method public void invalidateAuthToken(java.lang.String, java.lang.String);
method public static android.content.Intent newChooseAccountIntent(android.accounts.Account, java.util.ArrayList<android.accounts.Account>, java.lang.String[], android.os.Bundle);
method public java.lang.String peekAuthToken(android.accounts.Account, java.lang.String);
method public android.accounts.AccountManagerFuture<java.lang.Boolean> removeAccount(android.accounts.Account, android.accounts.AccountManagerCallback<java.lang.Boolean>, android.os.Handler);
method public void removeOnAccountsUpdatedListener(android.accounts.OnAccountsUpdateListener);

40
core/java/android/accounts/AccountManager.java
View File

@ -32,6 +32,7 @@ import android.util.Log;
import android.text.TextUtils;
import java.io.IOException;
import java.util.ArrayList;
import java.util.concurrent.Callable;
import java.util.concurrent.CancellationException;
import java.util.concurrent.ExecutionException;
@ -41,6 +42,7 @@ import java.util.concurrent.TimeUnit;
import java.util.HashMap;
import java.util.Map;
import com.google.android.collect.Lists;
import com.google.android.collect.Maps;
/**
@ -1769,6 +1771,44 @@ public class AccountManager {
return task;
}
/**
* Returns an intent to an {@link Activity} that prompts the user to choose from a list of
* accounts.
* The caller will then typically start the activity by calling
* <code>startActivityWithResult(intent, ...);</code>.
* <p>
* On success the activity returns a Bundle with the account name and type specified using
* keys {@link #KEY_ACCOUNT_NAME} and {@link #KEY_ACCOUNT_TYPE}.
* <p>
* The most common case is to call this with one account type, e.g.:
* <p>
* <pre> newChooseAccountsIntent(null, null, new String[]{"com.google"}, null);</pre>
* @param selectedAccount if specified, indicates that the {@link Account} is the currently
* selected one, according to the caller's definition of selected.
* @param allowableAccounts an optional {@link ArrayList} of accounts that are allowed to be
* shown. If not specified then this field will not limit the displayed accounts.
* @param allowableAccountTypes an optional string array of account types. These are used
* both to filter the shown accounts and to filter the list of account types that are shown
* when adding an account.
* @param addAccountOptions This {@link Bundle} is passed as the addAccount options
* @return an {@link Intent} that can be used to launch the ChooseAccount activity flow.
*/
static public Intent newChooseAccountIntent(Account selectedAccount,
ArrayList<Account> allowableAccounts,
String[] allowableAccountTypes,
Bundle addAccountOptions) {
Intent intent = new Intent();
intent.setClassName("android", "android.accounts.ChooseTypeAndAccountActivity");
intent.putExtra(ChooseTypeAndAccountActivity.EXTRA_ALLOWABLE_ACCOUNTS_ARRAYLIST,
allowableAccounts);
intent.putExtra(ChooseTypeAndAccountActivity.EXTRA_ALLOWABLE_ACCOUNT_TYPES_ARRAYLIST,
allowableAccountTypes != null ? Lists.newArrayList(allowableAccountTypes) : 0);
intent.putExtra(ChooseTypeAndAccountActivity.EXTRA_ADD_ACCOUNT_OPTIONS_BUNDLE,
addAccountOptions);
intent.putExtra(ChooseTypeAndAccountActivity.EXTRA_SELECTED_ACCOUNT, selectedAccount);
return intent;
}
private final HashMap<OnAccountsUpdateListener, Handler> mAccountsUpdatedListeners =
Maps.newHashMap();

220
core/java/android/accounts/ChooseAccountTypeActivity.java Normal file
View File

@ -0,0 +1,220 @@
/*
* 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.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.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.Map;
import java.util.Set;
/**
* @hide
*/
public class ChooseAccountTypeActivity extends Activity implements AccountManagerCallback<Bundle> {
private static final String TAG = "AccountManager";
private HashMap<String, AuthInfo> mTypeToAuthenticatorInfo = new HashMap<String, AuthInfo>();
private ArrayList<AuthInfo> mAuthenticatorInfosToDisplay;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.choose_account);
// Read the validAccountTypes, if present, and add them to the setOfAllowableAccountTypes
Set<String> setOfAllowableAccountTypes = null;
ArrayList<String> validAccountTypes = getIntent().getStringArrayListExtra(
ChooseTypeAndAccountActivity.EXTRA_ALLOWABLE_ACCOUNT_TYPES_ARRAYLIST);
if (validAccountTypes != null) {
setOfAllowableAccountTypes = new HashSet<String>(validAccountTypes.size());
for (String type : validAccountTypes) {
setOfAllowableAccountTypes.add(type);
}
}
// create a map of account authenticators
buildTypeToAuthDescriptionMap();
// Create a list of authenticators that are allowable. Filter out those that
// don't match the allowable account types, if provided.
mAuthenticatorInfosToDisplay = new ArrayList<AuthInfo>(mTypeToAuthenticatorInfo.size());
for (Map.Entry<String, AuthInfo> entry: mTypeToAuthenticatorInfo.entrySet()) {
final String type = entry.getKey();
final AuthInfo info = entry.getValue();
if (setOfAllowableAccountTypes != null
&& !setOfAllowableAccountTypes.contains(type)) {
continue;
}
mAuthenticatorInfosToDisplay.add(info);
}
if (mAuthenticatorInfosToDisplay.isEmpty()) {
Bundle bundle = new Bundle();
bundle.putString(AccountManager.KEY_ERROR_MESSAGE, "no allowable account types");
setResult(Activity.RESULT_OK, new Intent().putExtras(bundle));
finish();
return;
}
if (mAuthenticatorInfosToDisplay.size() == 1) {
runAddAccountForAuthenticator(mAuthenticatorInfosToDisplay.get(0));
return;
}
// Setup the list
ListView list = (ListView) findViewById(android.R.id.list);
// Use an existing ListAdapter that will map an array of strings to TextViews
list.setAdapter(new AccountArrayAdapter(this,
android.R.layout.simple_list_item_1, mAuthenticatorInfosToDisplay));
list.setChoiceMode(ListView.CHOICE_MODE_NONE);
list.setTextFilterEnabled(false);
list.setOnItemClickListener(new AdapterView.OnItemClickListener() {
public void onItemClick(AdapterView<?> parent, View v, int position, long id) {
runAddAccountForAuthenticator(mAuthenticatorInfosToDisplay.get(position));
}
});
}
private void buildTypeToAuthDescriptionMap() {
for(AuthenticatorDescription desc : AccountManager.get(this).getAuthenticatorTypes()) {
String name = null;
Drawable icon = null;
try {
Context authContext = createPackageContext(desc.packageName, 0);
icon = authContext.getResources().getDrawable(desc.iconId);
final CharSequence sequence = authContext.getResources().getText(desc.labelId);
if (sequence != null) {
name = sequence.toString();
}
name = sequence.toString();
} 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 " + desc.type);
}
} 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 " + desc.type);
}
}
AuthInfo authInfo = new AuthInfo(desc, name, icon);
mTypeToAuthenticatorInfo.put(desc.type, authInfo);
}
}
protected void runAddAccountForAuthenticator(AuthInfo authInfo) {
Log.d(TAG, "selected account type " + authInfo.name);
Bundle options = getIntent().getBundleExtra(
ChooseTypeAndAccountActivity.EXTRA_ADD_ACCOUNT_OPTIONS_BUNDLE);
AccountManager.get(this).addAccount(authInfo.desc.type, null, null, options,
this, this, null);
}
public void run(final AccountManagerFuture<Bundle> accountManagerFuture) {
try {
Bundle accountManagerResult = accountManagerFuture.getResult();
Bundle bundle = new Bundle();
bundle.putString(AccountManager.KEY_ACCOUNT_NAME,
accountManagerResult.getString(AccountManager.KEY_ACCOUNT_NAME));
bundle.putString(AccountManager.KEY_ACCOUNT_TYPE,
accountManagerResult.getString(AccountManager.KEY_ACCOUNT_TYPE));
setResult(Activity.RESULT_OK, new Intent().putExtras(bundle));
finish();
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 static class AuthInfo {
final AuthenticatorDescription desc;
final String name;
final Drawable drawable;
AuthInfo(AuthenticatorDescription desc, String name, Drawable drawable) {
this.desc = desc;
this.name = name;
this.drawable = drawable;
}
}
private static class ViewHolder {
ImageView icon;
TextView text;
}
private static class AccountArrayAdapter extends ArrayAdapter<AuthInfo> {
private LayoutInflater mLayoutInflater;
private ArrayList<AuthInfo> mInfos;
public AccountArrayAdapter(Context context, int textViewResourceId,
ArrayList<AuthInfo> 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_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);
convertView.setTag(holder);
} else {
holder = (ViewHolder) convertView.getTag();
}
holder.text.setText(mInfos.get(position).name);
holder.icon.setImageDrawable(mInfos.get(position).drawable);
return convertView;
}
}
}

274
core/java/android/accounts/ChooseTypeAndAccountActivity.java Normal file
View File

@ -0,0 +1,274 @@
/*
* 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.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.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;
/**
* @hide
*/
public class ChooseTypeAndAccountActivity extends Activity {
private static final String TAG = "AccountManager";
/**
* 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_ARRAYLIST = "allowableAccountTypes";
/**
* This is passed as the options bundle in AccountManager.addAccount() if it is called.
*/
public static final String EXTRA_ADD_ACCOUNT_OPTIONS_BUNDLE = "addAccountOptions";
/**
* If set then the specified account is already "selected".
*/
public static final String EXTRA_SELECTED_ACCOUNT = "selectedAccount";
private ArrayList<AccountInfo> mAccountInfos;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.choose_type_and_account);
final AccountManager accountManager = AccountManager.get(this);
// 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 =
getIntent().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 ArrayList<String> validAccountTypes =
getIntent().getStringArrayListExtra(EXTRA_ALLOWABLE_ACCOUNT_TYPES_ARRAYLIST);
if (validAccountTypes != null) {
setOfAllowableAccountTypes = new HashSet<String>(validAccountTypes.size());
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)));
}
// 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 (mAccountInfos.size() == 1) {
Account account = mAccountInfos.get(0).account;
setResultAndFinish(account.name, account.type);
return;
}
// 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.setTextFilterEnabled(false);
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();
}
});
}
// 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 (resultCode == RESULT_OK && data != null) {
String accountName = data.getStringExtra(AccountManager.KEY_ACCOUNT_NAME);
String accountType = data.getStringExtra(AccountManager.KEY_ACCOUNT_TYPE);
if (accountName != null && accountType != null) {
setResultAndFinish(accountName, accountType);
return;
}
}
setResult(Activity.RESULT_CANCELED);
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));
finish();
}
private void startChooseAccountTypeActivity() {
final Intent intent = new Intent(this, ChooseAccountTypeActivity.class);
intent.putStringArrayListExtra(EXTRA_ALLOWABLE_ACCOUNT_TYPES_ARRAYLIST,
getIntent().getStringArrayListExtra(EXTRA_ALLOWABLE_ACCOUNT_TYPES_ARRAYLIST));
intent.putExtra(EXTRA_ADD_ACCOUNT_OPTIONS_BUNDLE,
getIntent().getBundleExtra(EXTRA_ALLOWABLE_ACCOUNT_TYPES_ARRAYLIST));
startActivityForResult(intent, 0);
}
private static class AccountInfo {
final Account account;
final Drawable drawable;
AccountInfo(Account account, Drawable drawable) {
this.account = account;
this.drawable = drawable;
}
}
private static class ViewHolder {
ImageView icon;
TextView text;
}
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_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);
convertView.setTag(holder);
} else {
holder = (ViewHolder) convertView.getTag();
}
holder.text.setText(mInfos.get(position).account.name);
holder.icon.setImageDrawable(mInfos.get(position).drawable);
return convertView;
}
}
}

20
core/res/AndroidManifest.xml
View File

@ -1530,6 +1530,26 @@
android:process=":ui">
</activity>
<activity android:name="android.accounts.ChooseTypeAndAccountActivity"
android:excludeFromRecents="true"
android:exported="true"
android:theme="@android:style/Theme.Holo.Dialog"
android:label="@string/choose_account_label"
android:process=":ui">
<intent-filter>
<action android:name="android.intent.action.PICK" />
<category android:name="android.intent.category.ACCOUNT" />
</intent-filter>
</activity>
<activity android:name="android.accounts.ChooseAccountTypeActivity"
android:excludeFromRecents="true"
android:exported="true"
android:theme="@android:style/Theme.Holo.Dialog"
android:label="@string/choose_account_label"
android:process=":ui">
</activity>
<activity android:name="android.accounts.GrantCredentialsPermissionActivity"
android:excludeFromRecents="true"
android:exported="true"

44
core/res/res/layout/choose_type_and_account.xml Normal file
View File

@ -0,0 +1,44 @@
<?xml version="1.0" encoding="utf-8"?>
<!--
/* //device/apps/common/assets/res/layout/list_content.xml
**
** Copyright 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.
*/
-->
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
android:paddingLeft="16dip"
android:paddingRight="16dip">
<ListView xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@android:id/list"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_weight="1"
android:drawSelectorOnTop="false"
android:scrollbarAlwaysDrawVerticalTrack="true" />
<Button android:id="@+id/addAccount"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_weight="2"
android:layout_marginLeft="2dip"
android:layout_marginRight="2dip"
android:textAppearance="?android:attr/textAppearanceLarge"
android:textStyle="bold"
/>
</LinearLayout>