It is safe to call this method from the main thread. + *
This method can be called safely from the main thread. It is
+ * equivalent to calling getAccountsByType(null).
*
- *
Clients of this method that have not been granted the - * {@link android.Manifest.permission#GET_ACCOUNTS} permission, - * will only see those accounts managed by AbstractAccountAuthenticators whose - * signature matches the client. + *
NOTE: Apps declaring a {@code targetSdkVersion<=23} in their + * manifests will continue to behave as they did on devices that support + * API level 23. In particular the GET_ACCOUNTS permission is required to + * see all the Accounts registered with the AccountManager. See docs for + * this function in API level 23 for more information. * - * @return An array of {@link Account}, one for each account. Empty - * (never null) if no accounts have been added. + * @return Array of Accounts. The array may be empty if no accounts are + * available to the caller. */ @NonNull - @RequiresPermission(GET_ACCOUNTS) public Account[] getAccounts() { - try { - return mService.getAccounts(null, mContext.getOpPackageName()); - } catch (RemoteException e) { - // won't ever happen - throw new RuntimeException(e); - } + return getAccountsByType(null); } /** * @hide - * Lists all accounts of any type registered on the device for a given - * user id. Equivalent to getAccountsByType(null). + * List every {@link Account} registered on the device for a specific User + * that are managed by applications whose signatures match the caller. * - *
It is safe to call this method from the main thread. + *
NOTE: Apps declaring a {@code targetSdkVersion<=23} in their + * manifests will continue to behave as they did on devices that support + * API level 23. In particular the GET_ACCOUNTS permission is required to + * see all the Accounts registered with the AccountManager for the + * specified userId. See docs for this function in API level 23 for more + * information. * - *
Clients of this method that have not been granted the - * {@link android.Manifest.permission#GET_ACCOUNTS} permission, - * will only see those accounts managed by AbstractAccountAuthenticators whose - * signature matches the client. + *
This method can be called safely from the main thread. * - * @return An array of {@link Account}, one for each account. Empty - * (never null) if no accounts have been added. + * @param int userId associated with the User whose accounts should be + * queried. + * @return Array of Accounts. The array may be empty if no accounts are + * available to the caller. */ @NonNull - @RequiresPermission(GET_ACCOUNTS) public Account[] getAccountsAsUser(int userId) { try { return mService.getAccountsAsUser(null, userId, mContext.getOpPackageName()); @@ -501,10 +500,11 @@ public class AccountManager { /** * Returns the accounts visible to the specified package, in an environment where some apps * are not authorized to view all accounts. This method can only be called by system apps. + * * @param type The type of accounts to return, null to retrieve all accounts * @param packageName The package name of the app for which the accounts are to be returned - * @return An array of {@link Account}, one per matching account. Empty - * (never null) if no accounts of the specified type have been added. + * @return Array of Accounts. The array may be empty if no accounts of th + * specified type are visible to the caller. */ @NonNull public Account[] getAccountsByTypeForPackage(String type, String packageName) { @@ -518,29 +518,22 @@ public class AccountManager { } /** - * Lists all accounts of a particular type. The account type is a - * string token corresponding to the authenticator and useful domain - * of the account. For example, there are types corresponding to Google - * and Facebook. The exact string token to use will be published somewhere - * associated with the authenticator in question. + * List every {@link Account} of a specified type managed by applications + * whose signatures match the caller. * - *
It is safe to call this method from the main thread. + *
NOTE: Apps declaring a {@code targetSdkVersion<=23} in their + * manifests will continue to behave as they did on devices that support + * API level 23. See docs for this function in API level 23 for more + * information. * - *
Clients of this method that have not been granted the - * {@link android.Manifest.permission#GET_ACCOUNTS} permission, - * will only see those accounts managed by AbstractAccountAuthenticators whose - * signature matches the client. + *
This method can be called safely from the main thread. * - *
NOTE: If targeting your app to work on API level 22 and before,
- * GET_ACCOUNTS permission is needed for those platforms, irrespective of uid
- * or signature match. See docs for this function in API level 22.
- *
- * @param type The type of accounts to return, null to retrieve all accounts
- * @return An array of {@link Account}, one per matching account. Empty
- * (never null) if no accounts of the specified type have been added.
+ * @param type String denoting the type of the accounts to return,
+ * {@code null} to retrieve all accounts visible to the caller.
+ * @return An array of Accounts. Empty (never null) if no accounts
+ * are available to the caller.
*/
@NonNull
- @RequiresPermission(GET_ACCOUNTS)
public Account[] getAccountsByType(String type) {
return getAccountsByTypeAsUser(type, Process.myUserHandle());
}
@@ -586,6 +579,7 @@ public class AccountManager {
* @return a future containing the label string
* @hide
*/
+ @NonNull
public AccountManagerFuture This method may be called from any thread, but the returned
* {@link AccountManagerFuture} must not be used on the main thread.
*
- * This method requires the caller to hold the permission
- * {@link android.Manifest.permission#GET_ACCOUNTS} or be a signature
- * match with the AbstractAccountAuthenticator that manages the account.
+ * Note:The specified account must be managed by an application
+ * whose signature matches the caller.
+ *
+ * Further note:Apps targeting API level 23 or earlier will continue to
+ * behave as they did on devices that support API level 23. In particular
+ * they may still require the GET_ACCOUNTS permission. See docs for this
+ * function in API level 23.
*
* @param account The {@link Account} to test
* @param features An array of the account features to check
@@ -628,9 +626,11 @@ public class AccountManager {
* @param handler {@link Handler} identifying the callback thread,
* null for the main thread
* @return An {@link AccountManagerFuture} which resolves to a Boolean,
- * true if the account exists and has all of the specified features.
+ * true if the account exists and has all of the specified features.
+ * @throws SecurityException if the specified account is managed by an
+ * application whose signature doesn't match the caller's signature.
*/
- @RequiresPermission(GET_ACCOUNTS)
+ @NonNull
public AccountManagerFuture Unlike {@link #getAccountsByType}, this method calls the authenticator,
* which may contact the server or do other work to check account features,
@@ -662,19 +663,14 @@ public class AccountManager {
* This method may be called from any thread, but the returned
* {@link AccountManagerFuture} must not be used on the main thread.
*
- * Clients of this method that have not been granted the
- * {@link android.Manifest.permission#GET_ACCOUNTS} permission,
- * will only see those accounts managed by AbstractAccountAuthenticators whose
- * signature matches the client.
+ * NOTE: Apps targeting API level 23 or earlier will continue to
+ * behave as they did on devices that support API level 23. In particular
+ * they may still require the GET_ACCOUNTS permission. See docs for this
+ * function in API level 23.
*
* @param type The type of accounts to return, must not be null
* @param features An array of the account features to require,
* may be null or empty
- *
- * NOTE: If targeting your app to work on API level 22 and before,
- * GET_ACCOUNTS permission is needed for those platforms, irrespective of uid
- * or signature match. See docs for this function in API level 22.
- *
* @param callback Callback to invoke when the request completes,
* null for no callback
* @param handler {@link Handler} identifying the callback thread,
@@ -683,7 +679,7 @@ public class AccountManager {
* {@link Account}, one per account of the specified type which
* matches the requested features.
*/
- @RequiresPermission(GET_ACCOUNTS)
+ @NonNull
public AccountManagerFuture Android devices can store multiple accounts from many different providers.
-When you query {@link android.accounts.AccountManager} for account names, you can choose to filter
-by
-account type. The account type is a string that uniquely identifies the entity
-that issued the account. For instance, Google accounts have type "com.google,"
-while Twitter uses "com.twitter.android.auth.login." In order to get a list of accounts on the device, your app needs the {@link
-android.Manifest.permission#GET_ACCOUNTS}
-permission. Add a {@code
- Once an account type has been determined, you can prompt the user with an
+account chooser as follows:
Once you decide what account type you're interested in, you need to query for accounts of that
-type. Get an instance of {@link android.accounts.AccountManager} by calling {@link
-android.accounts.AccountManager#get(android.content.Context) AccountManager.get()}. Then use that
-instance to call {@link android.accounts.AccountManager#getAccountsByType(java.lang.String)
-getAccountsByType()}. Once the chooser intent is started, the user will be presented with a list of
+appropriately typed accounts. From this list they will select one which will be
+returned to your app upon onActivityResult as follows:
This returns an array of {@link android.accounts.Account} objects. If there's more than one
-{@link android.accounts.Account} in
-the array, you should present a dialog asking the user to select one. The {@link android.accounts.Account} object contains an account name, which for Google accounts
diff --git a/services/core/java/com/android/server/accounts/AccountManagerService.java b/services/core/java/com/android/server/accounts/AccountManagerService.java
index b86b3fd47e072..df6b127f0ba2e 100644
--- a/services/core/java/com/android/server/accounts/AccountManagerService.java
+++ b/services/core/java/com/android/server/accounts/AccountManagerService.java
@@ -4255,21 +4255,6 @@ public class AccountManagerService
}
}
- private boolean isPermitted(String opPackageName, int callingUid, String... permissions) {
- for (String perm : permissions) {
- if (mContext.checkCallingOrSelfPermission(perm) == PackageManager.PERMISSION_GRANTED) {
- if (Log.isLoggable(TAG, Log.VERBOSE)) {
- Log.v(TAG, " caller uid " + callingUid + " has " + perm);
- }
- final int opCode = AppOpsManager.permissionToOpCode(perm);
- if (opCode == AppOpsManager.OP_NONE || mAppOpsManager.noteOp(
- opCode, callingUid, opPackageName) == AppOpsManager.MODE_ALLOWED) {
- return true;
- }
- }
- }
- return false;
- }
private int handleIncomingUser(int userId) {
try {
@@ -4344,12 +4329,50 @@ public class AccountManagerService
private List
-
Decide What Type of Account to Use
Query the user for an Account
-Request GET_ACCOUNT permission
-
-
-<manifest ... >
- <uses-permission android:name="android.permission.GET_ACCOUNTS" />
- ...
-</manifest>
+AccountManager am = AccountManager.get(this); // "this" reference the current Context
+Intent chooserIntent = am.newChooseAccountIntent(
+ null, // currently select account
+ null, // list of accounts that are allowed to be shown
+ new String[] { "com.google" }, // Only allow the user to select Google accounts
+ false,
+ null, // description text
+ null, // add account auth token type
+ null, // required features for added accounts
+ null); // options for adding an account
+this.startActivityForResult(chooserIntent, MY_REQUEST_CODE);
-
-Query AccountManager for a List of Accounts
-
-
-AccountManager am = AccountManager.get(this); // "this" references the current Context
-
-Account[] accounts = am.getAccountsByType("com.google");
+protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+ if (requestCode == MY_REQUEST_CODE && resultCode == RESULT_OK) {
+ String name = data.getStringExtra(AccountManage.KEY_ACCOUNT_NAME);
+ String type = data.getStringExtra(AccountManage.KEY_ACCOUNT_TYPE);
+ Account selectedAccount = new Account(name, type);
+ doSomethingWithSelectedAccount(selectedAccount);
+ }
+}
-Use the Account Object to Personalize Your App