+ * <intent-filter> + * <action android:name="android.accounts.AccountAuthenticator" /> + * </intent-filter> + * <meta-data android:name="android.accounts.AccountAuthenticator" + * android:resource="@xml/authenticator" /> + *+ * The
android:resource attribute must point to a resource that looks like:
+ * + * <account-authenticator xmlns:android="http://schemas.android.com/apk/res/android" + * android:accountType="typeOfAuthenticator" + * android:icon="@drawable/icon" + * android:smallIcon="@drawable/miniIcon" + * android:label="@string/label" + * android:accountPreferences="@xml/account_preferences" + * /> + *+ * Replace the icons and labels with your own resources. The
android:accountType
+ * attribute must be a string that uniquely identifies your authenticator and will be the same
+ * string that user will use when making calls on the {@link AccountManager} and it also
+ * corresponds to {@link Account#type} for your accounts. One user of the android:icon is the
+ * "Account & Sync" settings page and one user of the android:smallIcon is the Contact Application's
+ * tab panels.
+ * + * The preferences attribute points to an PreferenceScreen xml hierarchy that contains + * a list of PreferenceScreens that can be invoked to manage the authenticator. An example is: + *
+ * <PreferenceScreen xmlns:android="http://schemas.android.com/apk/res/android"> + * <PreferenceCategory android:title="@string/title_fmt" /> + * <PreferenceScreen + * android:key="key1" + * android:title="@string/key1_action" + * android:summary="@string/key1_summary"> + * <intent + * android:action="key1.ACTION" + * android:targetPackage="key1.package" + * android:targetClass="key1.class" /> + * </PreferenceScreen> + * </PreferenceScreen> + *+ * + *
+ * The standard pattern for implementing any of the abstract methods is the following: + *
+ * The activity needs to return the final result when it is complete so the Intent should contain + * the {@link AccountAuthenticatorResponse} as {@link AccountManager#KEY_ACCOUNT_MANAGER_RESPONSE}. + * The activity must then call {@link AccountAuthenticatorResponse#onResult} or + * {@link AccountAuthenticatorResponse#onError} when it is complete. + *
+ * The following descriptions of each of the abstract authenticator methods will not describe the + * possible asynchronous nature of the request handling and will instead just describe the input + * parameters and the expected result. + *
+ * When writing an activity to satisfy these requests one must pass in the AccountManagerResponse + * and return the result via that response when the activity finishes (or whenever else the + * activity author deems it is the correct time to respond). + * The {@link AccountAuthenticatorActivity} handles this, so one may wish to extend that when + * writing activities to handle these requests. */ public abstract class AbstractAccountAuthenticator { private final Context mContext; @@ -239,19 +308,135 @@ public abstract class AbstractAccountAuthenticator { */ public abstract Bundle editProperties(AccountAuthenticatorResponse response, String accountType); + + /** + * Adds an account of the specified accountType. + * @param response to send the result back to the AccountManager, will never be null + * @param accountType the type of account to add, will never be null + * @param authTokenType the type of auth token to retrieve after adding the account, may be null + * @param requiredFeatures a String array of authenticator-specific features that the added + * account must support, may be null + * @param options a Bundle of authenticator-specific options, may be null + * @return a Bundle result or null if the result is to be returned via the response. The result + * will contain either: + *
+ * AbstractAccountAuthenticator. If the AbstractAccountAuthenticator needs to use an activity + * to handle the request then it can have the activity extend AccountAuthenticatorActivity. + * The AbstractAccountAuthenticator passes in the response to the intent using the following: + *
* intent.putExtra(Constants.ACCOUNT_AUTHENTICATOR_RESPONSE_KEY, response); - *+ * The activity then sets the result that is to be handed to the response via + * {@link #setAccountAuthenticatorResult(android.os.Bundle)}. * This result will be sent as the result of the request when the activity finishes. If this - * is never set or if it is set to null then the request will be canceled when the activity - * finishes. + * is never set or if it is set to null then error {@link AccountManager#ERROR_CODE_CANCELED} + * will be called on the response. */ public class AccountAuthenticatorActivity extends Activity { private AccountAuthenticatorResponse mAccountAuthenticatorResponse = null; diff --git a/core/java/android/accounts/AccountManager.java b/core/java/android/accounts/AccountManager.java index d03244977de2f..153d95f559b44 100644 --- a/core/java/android/accounts/AccountManager.java +++ b/core/java/android/accounts/AccountManager.java @@ -42,13 +42,34 @@ import java.util.Map; import com.google.android.collect.Maps; /** - * A class that helps with interactions with the AccountManagerService. It provides + * A class that helps with interactions with the AccountManager Service. It provides * methods to allow for account, password, and authtoken management for all accounts on the * device. One accesses the {@link AccountManager} by calling: + *- * The activity that it launches should extend the AccountAuthenticatorActivity. If this - * activity has a result that satisfies the original request it sets it via: - *
- * setAccountAuthenticatorResult(result) - *
+ *
* AccountManager accountManager = AccountManager.get(context); + ** *
- * TODO(fredq) this interface is still in flux + * The AccountManager Service provides storage for the accounts known to the system, + * provides methods to manage them, and allows the registration of authenticators to + * which operations such as addAccount and getAuthToken are delegated. + *
+ * Many of the calls take an {@link AccountManagerCallback} and {@link Handler} as parameters. + * These calls return immediately but run asynchronously. If a callback is provided then + * {@link AccountManagerCallback#run} will be invoked wen the request completes, successfully + * or not. An {@link AccountManagerFuture} is returned by these requests and also passed into the + * callback. The result if retrieved by calling {@link AccountManagerFuture#getResult()} which + * either returns the result or throws an exception as appropriate. + *
+ * The asynchronous request can be made blocking by not providing a callback and instead + * calling {@link AccountManagerFuture#getResult()} on the future that is returned. This will + * cause the running thread to block until the result is returned. Keep in mind that one + * should not block the main thread in this way. Instead one should either use a callback, + * thus making the call asynchronous, or make the blocking call on a separate thread. + *
+ * If one wants to ensure that the callback is invoked from a specific handler then they should + * pass the handler to the request. This makes it easier to ensure thread-safety by running + * all of one's logic from a single handler. */ public class AccountManager { private static final String TAG = "AccountManager"; @@ -60,6 +81,7 @@ public class AccountManager { public static final int ERROR_CODE_UNSUPPORTED_OPERATION = 6; public static final int ERROR_CODE_BAD_ARGUMENTS = 7; public static final int ERROR_CODE_BAD_REQUEST = 8; + public static final String KEY_ACCOUNTS = "accounts"; public static final String KEY_AUTHENTICATOR_TYPES = "authenticator_types"; public static final String KEY_USERDATA = "userdata"; @@ -110,10 +132,26 @@ public class AccountManager { mMainHandler = handler; } + /** + * Retrieve an AccountManager instance that is associated with the context that is passed in. + * Certain calls such as {@link #addOnAccountsUpdatedListener} use this context internally, + * so the caller must take care to use a {@link Context} whose lifetime is associated with + * the listener registration. + * @param context The {@link Context} to use when necessary + * @return an {@link AccountManager} instance that is associated with context + */ public static AccountManager get(Context context) { return (AccountManager) context.getSystemService(Context.ACCOUNT_SERVICE); } + /** + * Get the password that is associated with the account. Returns null if the account does + * not exist. + *
+ * Requires that the caller has permission + * {@link android.Manifest.permission#AUTHENTICATE_ACCOUNTS} and is running + * with the same UID as the Authenticator for the account. + */ public String getPassword(final Account account) { try { return mService.getPassword(account); @@ -123,6 +161,14 @@ public class AccountManager { } } + /** + * Get the user data named by "key" that is associated with the account. + * Returns null if the account does not exist or if it does not have a value for key. + *
+ * Requires that the caller has permission + * {@link android.Manifest.permission#AUTHENTICATE_ACCOUNTS} and is running + * with the same UID as the Authenticator for the account. + */ public String getUserData(final Account account, final String key) { try { return mService.getUserData(account, key); @@ -132,6 +178,14 @@ public class AccountManager { } } + /** + * Query the AccountManager Service for an array that contains a + * {@link AuthenticatorDescription} for each registered authenticator. + * @return an array that contains all the authenticators known to the AccountManager service. + * This array will be empty if there are no authenticators and will never return null. + *
+ * No permission is required to make this call. + */ public AuthenticatorDescription[] getAuthenticatorTypes() { try { return mService.getAuthenticatorTypes(); @@ -141,6 +195,13 @@ public class AccountManager { } } + /** + * Query the AccountManager Service for all accounts. + * @return an array that contains all the accounts known to the AccountManager service. + * This array will be empty if there are no accounts and will never return null. + *
+ * Requires that the caller has permission {@link android.Manifest.permission#GET_ACCOUNTS} + */ public Account[] getAccounts() { try { return mService.getAccounts(null); @@ -150,6 +211,15 @@ public class AccountManager { } } + /** + * Query the AccountManager for the set of accounts that have a given type. If null + * is passed as the type than all accounts are returned. + * @param type the account type by which to filter, or null to get all accounts + * @return an array that contains the accounts that match the specified type. This array + * will be empty if no accounts match. It will never return null. + *
+ * Requires that the caller has permission {@link android.Manifest.permission#GET_ACCOUNTS} + */ public Account[] getAccountsByType(String type) { try { return mService.getAccounts(type); @@ -159,6 +229,18 @@ public class AccountManager { } } + /** + * Add an account to the AccountManager's set of known accounts. + *
+ * Requires that the caller has permission + * {@link android.Manifest.permission#AUTHENTICATE_ACCOUNTS} and is running + * with the same UID as the Authenticator for the account. + * @param account The account to add + * @param password The password to associate with the account. May be null. + * @param extras A bundle of key/value pairs to set as the account's userdata. May be null. + * @return true if the account was sucessfully added, false otherwise, for example, + * if the account already exists or if the account is null + */ public boolean addAccountExplicitly(Account account, String password, Bundle extras) { try { return mService.addAccount(account, password, extras); @@ -168,6 +250,29 @@ public class AccountManager { } } + /** + * Removes the given account. If this account does not exist then this call has no effect. + *
+ * This call returns immediately but runs asynchronously and the result is accessed via the + * {@link AccountManagerFuture} that is returned. This future is also passed as the sole + * parameter to the {@link AccountManagerCallback}. If the caller wished to use this + * method asynchronously then they will generally pass in a callback object that will get + * invoked with the {@link AccountManagerFuture}. If they wish to use it synchronously then + * they will generally pass null for the callback and instead call + * {@link android.accounts.AccountManagerFuture#getResult()} on this method's return value, + * which will then block until the request completes. + *
+ * Requires that the caller has permission {@link android.Manifest.permission#MANAGE_ACCOUNTS}.
+ *
+ * @param account The {@link Account} to remove
+ * @param callback A callback to invoke when the request completes. If null then
+ * no callback is invoked.
+ * @param handler The {@link Handler} to use to invoke the callback. If null then the
+ * main thread's {@link Handler} is used.
+ * @return an {@link AccountManagerFuture} that represents the future result of the call.
+ * The future result is a {@link Boolean} that is true if the account is successfully removed
+ * or false if the authenticator refuses to remove the account.
+ */
public AccountManagerFuture
+ * Requires that the caller has permission {@link android.Manifest.permission#MANAGE_ACCOUNTS}.
+ * @param accountType the account type of the authtoken to invalidate
+ * @param authToken the authtoken to invalidate
+ */
public void invalidateAuthToken(final String accountType, final String authToken) {
try {
mService.invalidateAuthToken(accountType, authToken);
@@ -192,6 +305,20 @@ public class AccountManager {
}
}
+ /**
+ * Gets the authtoken named by "authTokenType" for the specified account if it is cached
+ * by the AccountManager. If no authtoken is cached then null is returned rather than
+ * asking the authenticaticor to generate one. If the account or the
+ * authtoken do not exist then null is returned.
+ *
+ * Requires that the caller has permission
+ * {@link android.Manifest.permission#AUTHENTICATE_ACCOUNTS} and is running
+ * with the same UID as the Authenticator for the account.
+ * @param account the account whose authtoken is to be retrieved, must not be null
+ * @param authTokenType the type of authtoken to retrieve
+ * @return an authtoken for the given account and authTokenType, if one is cached by the
+ * AccountManager, null otherwise.
+ */
public String peekAuthToken(final Account account, final String authTokenType) {
try {
return mService.peekAuthToken(account, authTokenType);
@@ -201,6 +328,16 @@ public class AccountManager {
}
}
+ /**
+ * Sets the password for the account. The password may be null. If the account does not exist
+ * then this call has no affect.
+ *
+ * Requires that the caller has permission
+ * {@link android.Manifest.permission#AUTHENTICATE_ACCOUNTS} and is running
+ * with the same UID as the Authenticator for the account.
+ * @param account the account whose password is to be set. Must not be null.
+ * @param password the password to set for the account. May be null.
+ */
public void setPassword(final Account account, final String password) {
try {
mService.setPassword(account, password);
@@ -210,6 +347,13 @@ public class AccountManager {
}
}
+ /**
+ * Sets the password for account to null. If the account does not exist then this call
+ * has no effect.
+ *
+ * Requires that the caller has permission {@link android.Manifest.permission#MANAGE_ACCOUNTS}.
+ * @param account the account whose password is to be cleared. Must not be null.
+ */
public void clearPassword(final Account account) {
try {
mService.clearPassword(account);
@@ -219,6 +363,17 @@ public class AccountManager {
}
}
+ /**
+ * Sets account's userdata named "key" to the specified value. If the account does not
+ * exist then this call has no effect.
+ *
+ * Requires that the caller has permission
+ * {@link android.Manifest.permission#AUTHENTICATE_ACCOUNTS} and is running
+ * with the same UID as the Authenticator for the account.
+ * @param account the account whose userdata is to be set. Must not be null.
+ * @param key the key of the userdata to set. Must not be null.
+ * @param value the value to set. May be null.
+ */
public void setUserData(final Account account, final String key, final String value) {
try {
mService.setUserData(account, key, value);
@@ -228,6 +383,17 @@ public class AccountManager {
}
}
+ /**
+ * Sets the authtoken named by "authTokenType" to the value specified by authToken.
+ * If the account does not exist then this call has no effect.
+ *
+ * Requires that the caller has permission
+ * {@link android.Manifest.permission#AUTHENTICATE_ACCOUNTS} and is running
+ * with the same UID as the Authenticator for the account.
+ * @param account the account whose authtoken is to be set. Must not be null.
+ * @param authTokenType the type of the authtoken to set. Must not be null.
+ * @param authToken the authToken to set. May be null.
+ */
public void setAuthToken(Account account, final String authTokenType, final String authToken) {
try {
mService.setAuthToken(account, authTokenType, authToken);
@@ -237,6 +403,25 @@ public class AccountManager {
}
}
+ /**
+ * Convenience method that makes a blocking call to
+ * {@link #getAuthToken(Account, String, boolean, AccountManagerCallback, Handler)}
+ * then extracts and returns the value of {@link #KEY_AUTHTOKEN} from its result.
+ *
+ * Requires that the caller has permission {@link android.Manifest.permission#USE_CREDENTIALS}.
+ * @param account the account whose authtoken is to be retrieved, must not be null
+ * @param authTokenType the type of authtoken to retrieve
+ * @param notifyAuthFailure if true, cause the AccountManager to put up a "sign-on" notification
+ * for the account if no authtoken is cached by the AccountManager and the the authenticator
+ * does not have valid credentials to get an authtoken.
+ * @return an authtoken for the given account and authTokenType, if one is cached by the
+ * AccountManager, null otherwise.
+ * @throws AuthenticatorException if the authenticator is not present, unreachable or returns
+ * an invalid response.
+ * @throws OperationCanceledException if the request is canceled for any reason
+ * @throws java.io.IOException if the authenticator experiences an IOException while attempting
+ * to communicate with its backend server.
+ */
public String blockingGetAuthToken(Account account, String authTokenType,
boolean notifyAuthFailure)
throws OperationCanceledException, IOException, AuthenticatorException {
@@ -246,16 +431,47 @@ public class AccountManager {
}
/**
- * Request the auth token for this account/authTokenType. If this succeeds then the
- * auth token will then be passed to the activity. If this results in an authentication
- * failure then a login intent will be returned that can be invoked to prompt the user to
- * update their credentials. This login activity will return the auth token to the calling
- * activity. If activity is null then the login intent will not be invoked.
+ * Request that an authtoken of the specified type be returned for an account.
+ * If the Account Manager has a cached authtoken of the requested type then it will
+ * service the request itself. Otherwise it will pass the request on to the authenticator.
+ * The authenticator can try to service this request with information it already has stored
+ * in the AccountManager but may need to launch an activity to prompt the
+ * user to enter credentials. If it is able to retrieve the authtoken it will be returned
+ * in the result.
+ *
+ * If the authenticator needs to prompt the user for credentials it will return an intent to
+ * the activity that will do the prompting. If an activity is supplied then that activity
+ * will be used to launch the intent and the result will come from it. Otherwise a result will
+ * be returned that contains the intent.
+ *
+ * This call returns immediately but runs asynchronously and the result is accessed via the
+ * {@link AccountManagerFuture} that is returned. This future is also passed as the sole
+ * parameter to the {@link AccountManagerCallback}. If the caller wished to use this
+ * method asynchronously then they will generally pass in a callback object that will get
+ * invoked with the {@link AccountManagerFuture}. If they wish to use it synchronously then
+ * they will generally pass null for the callback and instead call
+ * {@link android.accounts.AccountManagerFuture#getResult()} on this method's return value,
+ * which will then block until the request completes.
+ *
+ * Requires that the caller has permission {@link android.Manifest.permission#USE_CREDENTIALS}.
*
- * @param account the account whose auth token should be retrieved
- * @param authTokenType the auth token type that should be retrieved
- * @param loginOptions
- * @param activity the activity to launch the login intent, if necessary, and to which
+ * @param account The account whose credentials are to be updated.
+ * @param authTokenType the auth token to retrieve as part of updating the credentials.
+ * May be null.
+ * @param loginOptions authenticator specific options for the request
+ * @param activity If the authenticator returns a {@link #KEY_INTENT} in the result then
+ * the intent will be started with this activity. If activity is null then the result will
+ * be returned as-is.
+ * @param callback A callback to invoke when the request completes. If null then
+ * no callback is invoked.
+ * @param handler The {@link Handler} to use to invoke the callback. If null then the
+ * main thread's {@link Handler} is used.
+ * @return an {@link AccountManagerFuture} that represents the future result of the call.
+ * The future result is a {@link Bundle} that contains:
+ *
+ * If the authenticator needs to prompt the user for credentials it will return an intent for
+ * an activity that will do the prompting. If an intent is returned and notifyAuthFailure
+ * is true then a notification will be created that launches this intent.
+ *
+ * This call returns immediately but runs asynchronously and the result is accessed via the
+ * {@link AccountManagerFuture} that is returned. This future is also passed as the sole
+ * parameter to the {@link AccountManagerCallback}. If the caller wished to use this
+ * method asynchronously then they will generally pass in a callback object that will get
+ * invoked with the {@link AccountManagerFuture}. If they wish to use it synchronously then
+ * they will generally pass null for the callback and instead call
+ * {@link android.accounts.AccountManagerFuture#getResult()} on this method's return value,
+ * which will then block until the request completes.
+ *
+ * Requires that the caller has permission {@link android.Manifest.permission#USE_CREDENTIALS}.
+ *
+ * @param account The account whose credentials are to be updated.
+ * @param authTokenType the auth token to retrieve as part of updating the credentials.
+ * May be null.
+ * @param notifyAuthFailure if true and the authenticator returns a {@link #KEY_INTENT} in the
+ * result then a "sign-on needed" notification will be created that will launch this intent.
+ * @param callback A callback to invoke when the request completes. If null then
+ * no callback is invoked.
+ * @param handler The {@link Handler} to use to invoke the callback. If null then the
+ * main thread's {@link Handler} is used.
+ * @return an {@link AccountManagerFuture} that represents the future result of the call.
+ * The future result is a {@link Bundle} that contains either:
+ *
+ * This call returns immediately but runs asynchronously and the result is accessed via the
+ * {@link AccountManagerFuture} that is returned. This future is also passed as the sole
+ * parameter to the {@link AccountManagerCallback}. If the caller wished to use this
+ * method asynchronously then they will generally pass in a callback object that will get
+ * invoked with the {@link AccountManagerFuture}. If they wish to use it synchronously then
+ * they will generally pass null for the callback and instead call
+ * {@link android.accounts.AccountManagerFuture#getResult()} on this method's return value,
+ * which will then block until the request completes.
+ *
+ * Requires that the caller has permission {@link android.Manifest.permission#MANAGE_ACCOUNTS}.
+ *
+ * @param accountType The type of account to add. This must not be null.
+ * @param authTokenType The account that is added should be able to service this auth token
+ * type. This may be null.
+ * @param requiredFeatures The account that is added should support these features.
+ * This array may be null or empty.
+ * @param addAccountOptions A bundle of authenticator-specific options that is passed on
+ * to the authenticator. This may be null.
+ * @param activity If the authenticator returns a {@link #KEY_INTENT} in the result then
+ * the intent will be started with this activity. If activity is null then the result will
+ * be returned as-is.
+ * @param callback A callback to invoke when the request completes. If null then
+ * no callback is invoked.
+ * @param handler The {@link Handler} to use to invoke the callback. If null then the
+ * main thread's {@link Handler} is used.
+ * @return an {@link AccountManagerFuture} that represents the future result of the call.
+ * The future result is a {@link Bundle} that contains either:
+ *
+ * This call returns immediately but runs asynchronously and the result is accessed via the
+ * {@link AccountManagerFuture} that is returned. This future is also passed as the sole
+ * parameter to the {@link AccountManagerCallback}. If the caller wished to use this
+ * method asynchronously then they will generally pass in a callback object that will get
+ * invoked with the {@link AccountManagerFuture}. If they wish to use it synchronously then
+ * they will generally pass null for the callback and instead call
+ * {@link android.accounts.AccountManagerFuture#getResult()} on this method's return value,
+ * which will then block until the request completes.
+ *
+ * Requires that the caller has permission {@link android.Manifest.permission#MANAGE_ACCOUNTS}.
+ *
+ * @param account The account whose credentials are to be checked
+ * @param options authenticator specific options for the request
+ * @param activity If the authenticator returns a {@link #KEY_INTENT} in the result then
+ * the intent will be started with this activity. If activity is null then the result will
+ * be returned as-is.
+ * @param callback A callback to invoke when the request completes. If null then
+ * no callback is invoked.
+ * @param handler The {@link Handler} to use to invoke the callback. If null then the
+ * main thread's {@link Handler} is used.
+ * @return an {@link AccountManagerFuture} that represents the future result of the call.
+ * The future result is a {@link Bundle} that contains either:
+ *
+ * This call returns immediately but runs asynchronously and the result is accessed via the
+ * {@link AccountManagerFuture} that is returned. This future is also passed as the sole
+ * parameter to the {@link AccountManagerCallback}. If the caller wished to use this
+ * method asynchronously then they will generally pass in a callback object that will get
+ * invoked with the {@link AccountManagerFuture}. If they wish to use it synchronously then
+ * they will generally pass null for the callback and instead call
+ * {@link android.accounts.AccountManagerFuture#getResult()} on this method's return value,
+ * which will then block until the request completes.
+ *
+ * Requires that the caller has permission {@link android.Manifest.permission#MANAGE_ACCOUNTS}.
+ *
+ * @param account The account whose credentials are to be updated.
+ * @param authTokenType the auth token to retrieve as part of updating the credentials.
+ * May be null.
+ * @param loginOptions authenticator specific options for the request
+ * @param activity If the authenticator returns a {@link #KEY_INTENT} in the result then
+ * the intent will be started with this activity. If activity is null then the result will
+ * be returned as-is.
+ * @param callback A callback to invoke when the request completes. If null then
+ * no callback is invoked.
+ * @param handler The {@link Handler} to use to invoke the callback. If null then the
+ * main thread's {@link Handler} is used.
+ * @return an {@link AccountManagerFuture} that represents the future result of the call.
+ * The future result is a {@link Bundle} that contains either:
+ *
+ * This call returns immediately but runs asynchronously and the result is accessed via the
+ * {@link AccountManagerFuture} that is returned. This future is also passed as the sole
+ * parameter to the {@link AccountManagerCallback}. If the caller wished to use this
+ * method asynchronously then they will generally pass in a callback object that will get
+ * invoked with the {@link AccountManagerFuture}. If they wish to use it synchronously then
+ * they will generally pass null for the callback and instead call
+ * {@link android.accounts.AccountManagerFuture#getResult()} on this method's return value,
+ * which will then block until the request completes.
+ *
+ * Requires that the caller has permission {@link android.Manifest.permission#MANAGE_ACCOUNTS}.
+ *
+ * @param accountType The account type of the authenticator whose properties are to be edited.
+ * @param activity If the authenticator returns a {@link #KEY_INTENT} in the result then
+ * the intent will be started with this activity. If activity is null then the result will
+ * be returned as-is.
+ * @param callback A callback to invoke when the request completes. If null then
+ * no callback is invoked.
+ * @param handler The {@link Handler} to use to invoke the callback. If null then the
+ * main thread's {@link Handler} is used.
+ * @return an {@link AccountManagerFuture} that represents the future result of the call.
+ * The future result is a {@link Bundle} that contains either:
+ *
+ * This call returns immediately but runs asynchronously and the result is accessed via the
+ * {@link AccountManagerFuture} that is returned. This future is also passed as the sole
+ * parameter to the {@link AccountManagerCallback}. If the caller wished to use this
+ * method asynchronously then they will generally pass in a callback object that will get
+ * invoked with the {@link AccountManagerFuture}. If they wish to use it synchronously then
+ * they will generally pass null for the callback and instead call
+ * {@link android.accounts.AccountManagerFuture#getResult()} on this method's return value,
+ * which will then block until the request completes.
+ *
+ * Requires that the caller has permission {@link android.Manifest.permission#MANAGE_ACCOUNTS}.
+ *
+ * @param accountType the accountType to query; this must be non-null
+ * @param authTokenType the type of authtoken to retrieve; this must be non-null
+ * @param features a filter for the accounts. See {@link #getAccountsByTypeAndFeatures}.
+ * @param activityForPrompting The activity used to start any account management
+ * activities that are required to fulfill this request. This may be null.
+ * @param addAccountOptions authenticator-specific options used if an account needs to be added
+ * @param loginOptions authenticator-specific options passed to getAuthToken
+ * @param callback A callback to invoke when the request completes. If null then
+ * no callback is invoked.
+ * @param handler The {@link Handler} to use to invoke the callback. If null then the
+ * main thread's {@link Handler} is used.
+ * @return an {@link AccountManagerFuture} that represents the future result of the call.
+ * The future result is a {@link Bundle} that contains either:
+ *
+ *
+ * If the user presses "back" then the request will be canceled.
*/
public AccountManagerFuture
+ *
+ * If the user presses "back" then the request will be canceled.
+ */
public AccountManagerFuture
+ *
+ */
public AccountManagerFuture
+ *
+ * If the user presses "back" then the request will be canceled.
+ */
public AccountManagerFuture
+ *
+ * If the user presses "back" then the request will be canceled.
+ */
+ public AccountManagerFuture
+ *
+ * If the user presses "back" then the request will be canceled.
+ */
+ public AccountManagerFuture
+ *
+ * If the user presses "back" then the request will be canceled.
+ */
public AccountManagerFuture