GoogleAuthUtil

Change types that can be represented in an AccountChangeEvent.

A rename event that will contain extra data indicating the original account name.

A rename event that will contain extra data indicating the new account name.

Google Account type string. Used for various calls to AccountManager.

Bundle key for specifying which user's app activity (moment) types can be written to Google. The list of activity types are represented as a space-separated string passed in the extras Bundle when calling getToken(Context, String, String, Bundle).

This bundle key should be included in the extras Bundle when calling getToken(Context, String, String, Bundle) and should only be used when requesting the PLUS_LOGIN OAuth 2.0 scope. See Types of moments for the full list of valid activity types. Example usage:

     Bundle bundle = new Bundle();
     bundle.putString(GoogleAuthUtil.KEY_REQUEST_ACTIONS,
              "http://schemas.google.com/AddActivity http://schemas.google.com/BuyActivity");
     String token = GoogleAuthUtil.getToken(context, accountName, Scopes.PLUS_LOGIN, bundle);
 

See KEY_REQUEST_ACTIONS

Adding KEY_SUPPRESS_PROGRESS will suppress the progress screen shown when getting a token when added as a boolean true option while calling getToken(Context, String, String, Bundle). This is useful for apps that provide their own splash screens on initialization.

Clear the specified token in local cache with respect to the Context. Note that the context must be the same as that used to initialize the token in a previous call to getToken(Context, String, String) or getToken(Context, String, String, Bundle).

Get a list of events for the given account. The result is in reverse chronological order.

Gets a stable account id for the given account name. In the event of a missing id, user intervention may be required. In such cases, a UserRecoverableAuthException will be thrown. To initiate the user recovery workflow, clients must start the Intent returned by getIntent() for result. Upon successfully returning a client should invoke this method again to get an id.

See getToken(Context, String, String, Bundle).

Gets a token to be consumed by some specified services on behalf of a specified user account. How the token is consumed depends on the scope string provided. Note that this method requires substantial network IO and thus should be run off the UI thread. In the event of an error, one of several Exceptions will be thrown.

In the case of a transient (typically network related) error a IOException will be thrown. It is left to clients to implement a backoff/abandonment strategy appropriate to their latency requirements. If user intervention is required to provide consent, enter a password, etc, a UserRecoverableAuthException will be thrown. To initiate the user recovery workflow, clients must start the Intent returned by getIntent() for result. Upon successfully returning a client should invoke this method again to get a token. In the cases of errors that are neither transient nor recoverable by the the user, a GoogleAuthException will be thrown. These errors will typically result from client errors (e.g. providing an invalid scope).

By way of example, client code might have a block of code executing in a locally declared implementation of Thread or AsyncTask as follows:

 String token = null;
 try {
     token = GoogleAuthUtil.getToken(context, accountName, scope, bundle);
 } catch (GooglePlayServicesAvailabilityException playEx) {
     Dialog dialog = GooglePlayServicesUtil.getErrorDialog(
         playEx.getConnectionStatusCode(),
         Activity.this,
         AUTH_REQUEST_CODE);
     // Use the dialog to present to the user.
 } catch (UserRecoverableAuthException recoverableException) {
     Intent recoveryIntent = recoverableException.buildIntent();
     // Use the intent in a custom dialog or just startActivityForResult.
     Activity.this.startActivityForResult(recoveryIntent, REQUEST_CODE);
 } catch (GoogleAuthException authEx) {
     // This is likely unrecoverable.
     Log.e(TAG, "Unrecoverable authentication exception: " + authEx.getMessage(), authEx);
     return;
 } catch (IOException ioEx) {
     Log.i(TAG, "transient error encountered: " + ioEx.getMessage());
     doExponentialBackoff();
     return;
 }
 if (token != null) {
     makeNetworkApiCallwithToken(token);
 }
 

Those clients that have their own splash screens may wish to suppress the progress screen provided by Google Play services. The "Signing in..." progress screen provided by Google Play services by including setting KEY_SUPPRESS_PROGRESS_SCREEN to true in the supplied options Bundle.

Authenticates the user and returns a valid Google authentication token, or throws an Exception if there was an error while getting the token.

This method is specifically provided for background tasks. In the event of an error that needs user intervention, this method takes care of pushing relevant notification.

The exception thrown depends upon the underlying error and support for recovery. UserRecoverableNotifiedException will be thrown if the error can be resolved by user intervention and a notification has already been posted to address it. IOExceptions will be thrown if the underlying error might be solved by some intelligent retry strategy. Alternatively, GoogleAuthExceptions represent a broad class of Exceptions that cannot be recovered programmatically.

 String token;
 try {
     token = GoogleAuthUtil.getTokenWithNotification(context, accountName, scope, extras);
 } catch (UserRecoverableNotifiedException userNotifiedException) {
     // Notification has already been pushed.
     // Continue without token or stop background task.
 } catch (GoogleAuthException authEx) {
     // This is likely unrecoverable.
     Log.e(TAG, "Unrecoverable authentication exception: " + authEx.getMessage(), authEx);
 } catch (IOException ioEx) {
     Log.i(TAG, "transient error encountered: " + ioEx.getMessage());
     doExponentialBackoff();
 }
 

Authenticates the user and returns a valid Google authentication token, or throws an Exception if there was an error while getting the token.

This method is specifically provided for background tasks. In the event of an error that needs user intervention, this method takes care of pushing relevant notification. After the user addresses the notification, the callback is broadcasted. If the user cancels then the callback is not fired.

The exception thrown depends upon the underlying error and support for recovery. UserRecoverableNotifiedException will be thrown if the error can be resolved by user intervention and a notification has already been posted to address it. IOExceptions will be thrown if the underlying error might be solved by some intelligent retry strategy. Alternatively, GoogleAuthExceptions represent a broad class of Exceptions that cannot be recovered programmatically.

 String token;
 try {
     token = GoogleAuthUtil.getTokenWithNotification(
         context, accountName, scope, extras, callback);
 } catch (UserRecoverableNotifiedException userNotifiedException) {
     // Notification has already been pushed.
     // Continue without token or stop background task.
 } catch (GoogleAuthException authEx) {
     // This is likely unrecoverable.
     Log.e(TAG, "Unrecoverable authentication exception: " + authEx.getMessage(), authEx);
 } catch (IOException ioEx) {
     Log.i(TAG, "transient error encountered: " + ioEx.getMessage());
     doExponentialBackoff();
 }
 

Authenticates the user and returns a valid Google authentication token, or throws an Exception if there was an error while getting the token.

This method is specifically provided for sync adaptors. In the event of an error that needs user intervention, this method takes care of pushing relevant notification. After the user addresses the notification, a sync request will be kicked off using the given params. If the user cancels then the sync is not fired.

The exception thrown depends upon the underlying error and support for recovery. UserRecoverableNotifiedException will be thrown if the error can be resolved by user intervention and a notification has already been posted to address it. IOExceptions will be thrown if the underlying error might be solved by some intelligent retry strategy. Alternatively, GoogleAuthExceptions represent a broad class of Exceptions that cannot be recovered programmatically.

 String token;
 try {
     token = GoogleAuthUtil.getTokenWithNotification(
         context, accountName, scope, extras, authority, syncBundle);
 } catch (UserRecoverableNotifiedException userNotifiedException) {
     // Notification has already been pushed.
     // Continue without token or stop background task.
 } catch (GoogleAuthException authEx) {
     // This is likely unrecoverable.
     Log.e(TAG, "Unrecoverable authentication exception: " + authEx.getMessage(), authEx);
 } catch (IOException ioEx) {
     Log.i(TAG, "transient error encountered: " + ioEx.getMessage());
     doExponentialBackoff();
 }
 

Invalidates the specified token with respect to the Context. Note that the context must be the same as that used to initialize the token in a previous call to getToken(Context, String, String) or getToken(Context, String, String, Bundle).