Java Code Examples for com.google.api.client.auth.oauth2.Credential#setAccessToken()

private static Credential loadCredential(String userId, DataStore<StoredCredential> credentialDataStore)
        throws IOException {
    Credential credential = newCredential(userId, credentialDataStore);
    if (credentialDataStore != null) {
        StoredCredential stored = credentialDataStore.get(userId);
        if (stored == null) {
            return null;
        }
        credential.setAccessToken(stored.getAccessToken());
        credential.setRefreshToken(stored.getRefreshToken());
        credential.setExpirationTimeMilliseconds(stored.getExpirationTimeMilliseconds());
        if (logger.isDebugEnabled()) {
            logger.debug("Loaded credential");
            logger.debug("device access token: {}", stored.getAccessToken());
            logger.debug("device refresh_token: {}", stored.getRefreshToken());
            logger.debug("device expires_in: {}", stored.getExpirationTimeMilliseconds());
        }
    }
    return credential;
}
 

@Override
public boolean load(String userId, Credential credential) {
  DatastoreService datastore = DatastoreServiceFactory.getDatastoreService();
  Key key = KeyFactory.createKey(KIND, userId);
  try {
    Entity entity = datastore.get(key);
    credential.setAccessToken((String) entity.getProperty("accessToken"));
    credential.setRefreshToken((String) entity.getProperty("refreshToken"));
    credential.setExpirationTimeMilliseconds((Long) entity.getProperty("expirationTimeMillis"));
    return true;
  } catch (EntityNotFoundException exception) {
    return false;
  }
}
 

/**
 * @param credential credential whose {@link Credential#setAccessToken access token},
 *        {@link Credential#setRefreshToken refresh token}, and
 *        {@link Credential#setExpirationTimeMilliseconds expiration time} need to be set if the
 *        credential already exists in storage
 */
void load(Credential credential) {
  credential.setAccessToken(accessToken);
  credential.setRefreshToken(refreshToken);
  credential.setExpirationTimeMilliseconds(expirationTimeMillis);
  if (credential instanceof OAuthHmacCredential) {
      OAuthHmacCredential oauth10aCredential = (OAuthHmacCredential) credential;
      oauth10aCredential.setTokenSharedSecret(tokenSharedSecret);
      oauth10aCredential.setConsumerKey(consumerKey);
      oauth10aCredential.setSharedSecret(sharedSecret);
  }
}
 

/**
 * Deletes Google Spreadsheets row.
 * 
 * @param context the context
 * @param accountName the account name
 * @param trackName the track name
 * @return true if deletion is success.
 */
public static boolean deleteSpreadsheetsRow(
    Context context, String accountName, String trackName) {
  try {
    // Get spreadsheet Id
    List<File> files = searchSpreadsheets(context, accountName);
    if (files == null || files.size() == 0) {
      return false;
    }
    String spreadsheetId = files.get(0).getId();

    // Get spreadsheet service
    SpreadsheetService spreadsheetService = new SpreadsheetService(
        "MyTracks-" + SystemUtils.getMyTracksVersion(context));
    Credential credential = new Credential(BearerToken.authorizationHeaderAccessMethod());
    credential.setAccessToken(
        SendToGoogleUtils.getToken(context, accountName, SendToGoogleUtils.SPREADSHEETS_SCOPE));
    spreadsheetService.setOAuth2Credentials(credential);

    // Get work sheet
    WorksheetFeed worksheetFeed = spreadsheetService.getFeed(new URL(
        String.format(Locale.US, SendSpreadsheetsAsyncTask.GET_WORKSHEETS_URI, spreadsheetId)),
        WorksheetFeed.class);
    Iterator<WorksheetEntry> worksheetEntryIterator = worksheetFeed.getEntries().iterator();
    while (worksheetEntryIterator.hasNext()) {
      WorksheetEntry worksheetEntry = (WorksheetEntry) worksheetEntryIterator.next();
      String worksheetTitle = worksheetEntry.getTitle().getPlainText();
      if (worksheetTitle.equals(SPREADSHEETS_WORKSHEET_NAME)) {
        URL url = worksheetEntry.getListFeedUrl();
        Iterator<ListEntry> listEntryIterator = spreadsheetService.getFeed(url, ListFeed.class)
            .getEntries().iterator();
        while (listEntryIterator.hasNext()) {
          ListEntry listEntry = (ListEntry) listEntryIterator.next();
          String name = listEntry.getCustomElements().getValue(SPREADSHEETS_TRANCK_NAME_COLUMN);
          if (name.equals(trackName)) {
            listEntry.delete();
            return true;
          }
        }
      }
    }
  } catch (Exception e) {
    Log.e(TAG, "Unable to delete spreadsheets row.", e);
  }
  return false;
}
 

@Test
public void useCustomDataStore() throws Exception {
    Credential credential = new Credential.Builder(BearerToken.authorizationHeaderAccessMethod())
            .setTransport(new MockHttpTransport())
            .setJsonFactory(new MockJsonFactory())
            .setClientAuthentication(Mockito.mock(HttpExecuteInterceptor.class))
            .setTokenServerUrl(new GenericUrl(TOKEN_REQUEST_URL))
            .build();

    credential.setAccessToken("accessToken2");
    credential.setRefreshToken("refreshToken2");
    credential.setExpiresInSeconds(1000L);

    DataStore mockDataStore = Mockito.mock(DataStore.class);
    MockDataStoreFactory mockDataStoreFactory = new MockDataStoreFactory(mockDataStore);
    Mockito.when(mockDataStore.get(eq("userId"))).thenReturn(new StoredCredential(credential));

    OAuth2Credentials oAuth2Credentials = new OAuth2Credentials.Builder()
            .setClientSecrets("CLIENT_ID", "CLIENT_SECRET")
            .setRedirectUri("http://redirect")
            .setHttpTransport(mockHttpTransport)
            .setCredentialDataStoreFactory(mockDataStoreFactory)
            .setScopes(Arrays.asList(Scope.PROFILE, Scope.REQUEST))
            .build();

    Credential storedCredential = oAuth2Credentials.authenticate("authorizationCode", "userId");
    Credential loadedCredential = oAuth2Credentials.loadCredential("userId");

    assertEquals("Refresh token does not match.", "refreshToken", storedCredential.getRefreshToken());
    assertTrue("Expected expires_in between 0 and 3600. Was actually: " + storedCredential.getExpiresInSeconds(),
            storedCredential.getExpiresInSeconds() > 0 && storedCredential.getExpiresInSeconds() <= 3600);
    assertEquals("Access token does not match.", "accessToken", storedCredential.getAccessToken());
    assertEquals("Access method (Bearer) does not match",
            BearerToken.authorizationHeaderAccessMethod().getClass(), storedCredential.getMethod().getClass());

    assertEquals("Refresh token does not match.", "refreshToken2", loadedCredential.getRefreshToken());
    assertTrue("Expected expires_in between 0 and 1000. Was actually: " + loadedCredential.getExpiresInSeconds(),
            loadedCredential.getExpiresInSeconds() > 0 && loadedCredential.getExpiresInSeconds() <= 1000L);
    assertEquals("Access token does not match.", "accessToken2", loadedCredential.getAccessToken());
    assertEquals("Access method (Bearer) does not match",
            BearerToken.authorizationHeaderAccessMethod().getClass(), loadedCredential.getMethod().getClass());
}
 

/**
 * @param credential credential whose {@link Credential#setAccessToken access token},
 *        {@link Credential#setRefreshToken refresh token}, and
 *        {@link Credential#setExpirationTimeMilliseconds expiration time} need to be set if the
 *        credential already exists in storage
 */
void load(Credential credential) {
  credential.setAccessToken(accessToken);
  credential.setRefreshToken(refreshToken);
  credential.setExpirationTimeMilliseconds(expirationTimeMillis);
}
 

/**
 * @param credential credential whose {@link Credential#setAccessToken access token},
 *        {@link Credential#setRefreshToken refresh token}, and
 *        {@link Credential#setExpirationTimeMilliseconds expiration time} need to be set if the
 *        credential already exists in storage
 */
void load(Credential credential) {
  credential.setAccessToken(accessToken);
  credential.setRefreshToken(refreshToken);
  credential.setExpirationTimeMilliseconds(expirationTimeMillis);
}