Java के लिए, Google API क्लाइंट लाइब्रेरी के साथ OAuth 2.0 का इस्तेमाल करना

खास जानकारी

मकसद: इस दस्तावेज़ में, GoogleCredential यूटिलिटी क्लास का इस्तेमाल करके, Google की सेवाओं के साथ OAuth 2.0 ऑथराइज़ेशन करने का तरीका बताया गया है. हम जो सामान्य OAuth 2.0 फ़ंक्शन उपलब्ध कराते हैं उनके बारे में जानकारी पाने के लिए, OAuth 2.0 और Java के लिए Google OAuth क्लाइंट लाइब्रेरी लेख पढ़ें.

खास जानकारी: Google की सेवाओं पर सेव किए गए सुरक्षित डेटा को ऐक्सेस करने के लिए, अनुमति देने के लिए OAuth 2.0 का इस्तेमाल करें. Google APIs, अलग-अलग तरह के क्लाइंट ऐप्लिकेशन के लिए OAuth 2.0 फ़्लो के साथ काम करते हैं. इन सभी फ़्लो में, क्लाइंट ऐप्लिकेशन ऐसे ऐक्सेस टोकन का अनुरोध करता है जो सिर्फ़ आपके क्लाइंट ऐप्लिकेशन और ऐक्सेस किए जा रहे सुरक्षित डेटा के मालिक से जुड़ा होता है. ऐक्सेस टोकन, सीमित स्कोप से भी जुड़ा होता है. इससे यह तय होता है कि आपके क्लाइंट ऐप्लिकेशन के पास किस तरह के डेटा का ऐक्सेस है. उदाहरण के लिए, "अपने टास्क मैनेज करें". OAuth 2.0 का मुख्य मकसद, सुरक्षित किए गए डेटा को सुरक्षित और आसानी से ऐक्सेस करने की सुविधा देना है. साथ ही, अगर ऐक्सेस टोकन चोरी हो जाता है, तो उसके असर को कम करना है.

Java के लिए Google API Client Library में मौजूद OAuth 2.0 पैकेज, सामान्य मकसद के लिए इस्तेमाल होने वाली Java के लिए Google OAuth 2.0 Client Library पर बनाए गए हैं.

ज़्यादा जानकारी के लिए, यहां दिए गए पैकेज के लिए Javadoc दस्तावेज़ देखें:

Google API (एपीआई) कंसोल

Google API को ऐक्सेस करने से पहले, आपको पुष्टि करने और बिलिंग के लिए Google API Console पर एक प्रोजेक्ट सेट अप करना होगा. भले ही, आपका क्लाइंट कोई इंस्टॉल किया गया ऐप्लिकेशन, मोबाइल ऐप्लिकेशन, वेब सर्वर या ब्राउज़र में चलने वाला क्लाइंट हो.

क्रेडेंशियल को सही तरीके से सेट अप करने के निर्देशों के लिए, API Console का सहायता केंद्र देखें.

क्रेडेंशियल

GoogleCredential

GoogleCredential, थ्रेड-सेफ़ हेल्पर क्लास है. इसका इस्तेमाल OAuth 2.0 के लिए किया जाता है. इसकी मदद से, ऐक्सेस टोकन का इस्तेमाल करके सुरक्षित संसाधनों को ऐक्सेस किया जा सकता है. उदाहरण के लिए, अगर आपके पास पहले से ही ऐक्सेस टोकन है, तो इस तरह अनुरोध किया जा सकता है:

GoogleCredential credential = new GoogleCredential().setAccessToken(accessToken);
Plus plus = new Plus.builder(new NetHttpTransport(),
                             GsonFactory.getDefaultInstance(),
                             credential)
    .setApplicationName("Google-PlusSample/1.0")
    .build();

Google App Engine की पहचान

यह वैकल्पिक क्रेडेंशियल, Google App Engine App Identity Java API पर आधारित है. क्रेडेंशियल में, क्लाइंट ऐप्लिकेशन किसी एंड-यूज़र के डेटा को ऐक्सेस करने का अनुरोध करता है. हालांकि, App Identity API, क्लाइंट ऐप्लिकेशन को उसके खुद के डेटा को ऐक्सेस करने की अनुमति देता है.

AppIdentityCredential (from google-api-client-appengine) का इस्तेमाल करें. यह क्रेडेंशियल बहुत आसान है, क्योंकि Google App Engine सभी जानकारी का ध्यान रखता है. सिर्फ़ उस OAuth 2.0 स्कोप के बारे में बताएं जिसकी आपको ज़रूरत है.

urlshortener-robots-appengine-sample से लिया गया कोड का उदाहरण:

static Urlshortener newUrlshortener() {
  AppIdentityCredential credential =
      new AppIdentityCredential(
          Collections.singletonList(UrlshortenerScopes.URLSHORTENER));
  return new Urlshortener.Builder(new UrlFetchTransport(),
                                  GsonFactory.getDefaultInstance(),
                                  credential)
      .build();
}

डेटा स्टोर

आम तौर पर, ऐक्सेस टोकन की समयसीमा एक घंटे की होती है. इसके बाद, इसका इस्तेमाल करने पर आपको गड़बड़ी का मैसेज दिखेगा. GoogleCredential टोकन को अपने-आप "रीफ़्रेश" करता है. इसका मतलब है कि यह नया ऐक्सेस टोकन हासिल करता है. ऐसा लंबे समय तक मान्य रहने वाले रीफ़्रेश टोकन की मदद से किया जाता है. अगर ऑथराइज़ेशन कोड फ़्लो के दौरान access_type=offline पैरामीटर का इस्तेमाल किया जाता है, तो आम तौर पर यह ऐक्सेस टोकन के साथ मिलता है. इसके बारे में ज़्यादा जानने के लिए, GoogleAuthorizationCodeFlow.Builder.setAccessType(String) देखें.

ज़्यादातर ऐप्लिकेशन को क्रेडेंशियल के ऐक्सेस टोकन और/या रीफ़्रेश टोकन को सेव करके रखना होगा. क्रेडेंशियल के ऐक्सेस और/या रीफ़्रेश टोकन को सेव करने के लिए, StoredCredential के साथ DataStoreFactory का अपना वर्शन इस्तेमाल किया जा सकता है; इसके अलावा, लाइब्रेरी की ओर से उपलब्ध कराए गए इन वर्शन में से किसी एक का इस्तेमाल किया जा सकता है:

AppEngineDataStoreFactory: Google App Engine Data Store API का इस्तेमाल करके क्रेडेंशियल सेव करता है.
MemoryDataStoreFactory: यह क्रेडेंशियल को मेमोरी में "बनाए रखता है". यह सिर्फ़ प्रोसेस के लाइफ़टाइम के लिए, कम समय के स्टोरेज के तौर पर काम करता है.
FileDataStoreFactory: persists the credential in a file.

AppEngine के उपयोगकर्ताओं के लिए: AppEngineCredentialStore अब काम नहीं करता. इसे जल्द ही हटा दिया जाएगा. हमारा सुझाव है कि आप StoredCredential के साथ AppEngineDataStoreFactory का इस्तेमाल करें. अगर आपके पास पुराने तरीके से सेव किए गए क्रेडेंशियल हैं, तो माइग्रेट करने के लिए, जोड़े गए हेल्पर तरीकों migrateTo(AppEngineDataStoreFactory) या migrateTo(DataStore) का इस्तेमाल किया जा सकता है.

DataStoreCredentialRefreshListener का इस्तेमाल किया जा सकता है. साथ ही, GoogleCredential.Builder.addRefreshListener(CredentialRefreshListener) का इस्तेमाल करके, इसे क्रेडेंशियल के लिए सेट किया जा सकता है.

ऑथराइज़ेशन कोड का फ़्लो

अनुमति कोड फ़्लो का इस्तेमाल करें, ताकि असली उपयोगकर्ता आपके ऐप्लिकेशन को Google API पर मौजूद अपने सुरक्षित डेटा को ऐक्सेस करने की अनुमति दे सके. इस फ़्लो के लिए प्रोटोकॉल, Authorization Code Grant में बताया गया है.

इस फ़्लो को GoogleAuthorizationCodeFlow का इस्तेमाल करके लागू किया जाता है. चरण इस प्रकार हैं:

जब असली उपयोगकर्ता आपके ऐप्लिकेशन में लॉग इन करता है. आपको उस उपयोगकर्ता को ऐसे यूज़र आईडी से जोड़ना होगा जो आपके ऐप्लिकेशन के लिए यूनीक हो.
यूज़र आईडी के आधार पर, AuthorizationCodeFlow.loadCredential(String)) को कॉल करें. इससे यह पता चलेगा कि क्या उपयोगकर्ता के क्रेडेंशियल पहले से मौजूद हैं. अगर ऐसा है, तो हमारा काम हो गया.
अगर ऐसा नहीं है, तो AuthorizationCodeFlow.newAuthorizationUrl() को कॉल करें और एंड-यूज़र के ब्राउज़र को अनुमति वाले पेज पर भेजें, ताकि आपके ऐप्लिकेशन को उनके सुरक्षित डेटा को ऐक्सेस करने की अनुमति मिल सके.
इसके बाद, Google का ऑथराइज़ेशन सर्वर, ब्राउज़र को आपके ऐप्लिकेशन के बताए गए रीडायरेक्ट यूआरएल पर वापस भेज देगा. साथ ही, code क्वेरी पैरामीटर भी भेजेगा. code पैरामीटर का इस्तेमाल करके, ऐक्सेस टोकन का अनुरोध करें. इसके लिए, AuthorizationCodeFlow.newTokenRequest(String)) का इस्तेमाल करें.
सुरक्षित संसाधनों को ऐक्सेस करने के लिए क्रेडेंशियल को सेव करने और पाने के लिए, AuthorizationCodeFlow.createAndStoreCredential(TokenResponse, String) का इस्तेमाल करें.

इसके अलावा, अगर GoogleAuthorizationCodeFlow का इस्तेमाल नहीं किया जा रहा है, तो यहां दी गई लोअर-लेवल क्लास का इस्तेमाल किया जा सकता है:

यूज़र आईडी के आधार पर, स्टोर से क्रेडेंशियल लोड करने के लिए DataStore.get(String) का इस्तेमाल करें.
ब्राउज़र को ऑथराइज़ेशन पेज पर ले जाने के लिए, GoogleAuthorizationCodeRequestUrl का इस्तेमाल करें.
ऑथराइज़ेशन के जवाब को प्रोसेस करने और ऑथराइज़ेशन कोड को पार्स करने के लिए, AuthorizationCodeResponseUrl का इस्तेमाल करें.
ऐक्सेस टोकन और रीफ़्रेश टोकन का अनुरोध करने के लिए, GoogleAuthorizationCodeTokenRequest का इस्तेमाल करें.
एक नया GoogleCredential बनाएं और उसे DataStore.set(String, V) का इस्तेमाल करके सेव करें.
GoogleCredential का इस्तेमाल करके, सुरक्षित किए गए संसाधनों को ऐक्सेस करें. समयसीमा खत्म हो चुके ऐक्सेस टोकन, रीफ़्रेश टोकन का इस्तेमाल करके अपने-आप रीफ़्रेश हो जाएंगे. हालांकि, ऐसा सिर्फ़ तब होगा, जब रीफ़्रेश टोकन उपलब्ध हो. DataStoreCredentialRefreshListener का इस्तेमाल करना न भूलें. साथ ही, GoogleCredential.Builder.addRefreshListener(CredentialRefreshListener) का इस्तेमाल करके, इसे क्रेडेंशियल के लिए सेट करें.

Google API Console में अपना प्रोजेक्ट सेट अप करते समय, आपको अलग-अलग क्रेडेंशियल में से किसी एक को चुनना होता है. यह इस बात पर निर्भर करता है कि आपने कौनसे फ़्लो का इस्तेमाल किया है. ज़्यादा जानकारी के लिए, OAuth 2.0 सेट अप करना और OAuth 2.0 के उदाहरण लेख पढ़ें. हर फ़्लो के लिए कोड स्निपेट यहां दिए गए हैं.

वेब सर्वर ऐप्लिकेशन

इस फ़्लो के प्रोटोकॉल के बारे में, वेब सर्वर ऐप्लिकेशन के लिए OAuth 2.0 का इस्तेमाल करना लेख में बताया गया है.

यह लाइब्रेरी, बुनियादी इस्तेमाल के उदाहरणों के लिए, अनुमति देने वाले कोड के फ़्लो को काफ़ी हद तक आसान बनाने के लिए, servlet हेल्पर क्लास उपलब्ध कराती है. आपको सिर्फ़ AbstractAuthorizationCodeServlet और AbstractAuthorizationCodeCallbackServlet (google-oauth-client-servlet से) के कॉंक्रीट सबक्लास देने होते हैं. इसके बाद, उन्हें अपनी web.xml फ़ाइल में जोड़ना होता है. ध्यान दें कि आपको अपने वेब ऐप्लिकेशन के लिए उपयोगकर्ता के लॉगिन का ध्यान रखना होगा और यूज़र आईडी निकालना होगा.

public class CalendarServletSample extends AbstractAuthorizationCodeServlet {

  @Override
  protected void doGet(HttpServletRequest request, HttpServletResponse response)
      throws IOException {
    // do stuff
  }

  @Override
  protected String getRedirectUri(HttpServletRequest req) throws ServletException, IOException {
    GenericUrl url = new GenericUrl(req.getRequestURL().toString());
    url.setRawPath("/oauth2callback");
    return url.build();
  }

  @Override
  protected AuthorizationCodeFlow initializeFlow() throws IOException {
    return new GoogleAuthorizationCodeFlow.Builder(
        new NetHttpTransport(), GsonFactory.getDefaultInstance(),
        "[[ENTER YOUR CLIENT ID]]", "[[ENTER YOUR CLIENT SECRET]]",
        Collections.singleton(CalendarScopes.CALENDAR)).setDataStoreFactory(
        DATA_STORE_FACTORY).setAccessType("offline").build();
  }

  @Override
  protected String getUserId(HttpServletRequest req) throws ServletException, IOException {
    // return user ID
  }
}

public class CalendarServletCallbackSample extends AbstractAuthorizationCodeCallbackServlet {

  @Override
  protected void onSuccess(HttpServletRequest req, HttpServletResponse resp, Credential credential)
      throws ServletException, IOException {
    resp.sendRedirect("/");
  }

  @Override
  protected void onError(
      HttpServletRequest req, HttpServletResponse resp, AuthorizationCodeResponseUrl errorResponse)
      throws ServletException, IOException {
    // handle error
  }

  @Override
  protected String getRedirectUri(HttpServletRequest req) throws ServletException, IOException {
    GenericUrl url = new GenericUrl(req.getRequestURL().toString());
    url.setRawPath("/oauth2callback");
    return url.build();
  }

  @Override
  protected AuthorizationCodeFlow initializeFlow() throws IOException {
    return new GoogleAuthorizationCodeFlow.Builder(
        new NetHttpTransport(), GsonFactory.getDefaultInstance()
        "[[ENTER YOUR CLIENT ID]]", "[[ENTER YOUR CLIENT SECRET]]",
        Collections.singleton(CalendarScopes.CALENDAR)).setDataStoreFactory(
        DATA_STORE_FACTORY).setAccessType("offline").build();
  }

  @Override
  protected String getUserId(HttpServletRequest req) throws ServletException, IOException {
    // return user ID
  }
}

Google App Engine ऐप्लिकेशन

App Engine पर ऑथराइज़ेशन कोड फ़्लो, servlet ऑथराइज़ेशन कोड फ़्लो के जैसा ही होता है. हालांकि, इसमें हम Google App Engine के Users Java API का इस्तेमाल कर सकते हैं. Users Java API को चालू करने के लिए, उपयोगकर्ता को लॉग इन करना होगा. अगर उपयोगकर्ता ने पहले से लॉग इन नहीं किया है, तो उसे लॉगिन पेज पर रीडायरेक्ट करने के बारे में जानकारी के लिए, सुरक्षा और पुष्टि (web.xml में) देखें.

Servlet के मामले में मुख्य अंतर यह है कि आपको google-oauth-client-appengine से AbstractAppEngineAuthorizationCodeServlet और AbstractAppEngineAuthorizationCodeCallbackServlet की कॉंक्रीट सबक्लास उपलब्ध करानी होती हैं. ये ऐब्स्ट्रैक्ट सर्वलेट क्लास को बढ़ाते हैं और Users Java API का इस्तेमाल करके, आपके लिए getUserId तरीके को लागू करते हैं. Google App Engine Data Store API का इस्तेमाल करके क्रेडेंशियल को सेव करने के लिए, AppEngineDataStoreFactory (from google-http-client-appengine) एक अच्छा विकल्प है.

यह उदाहरण, calendar-appengine-sample से लिया गया है. इसमें थोड़ा बदलाव किया गया है:

public class CalendarAppEngineSample extends AbstractAppEngineAuthorizationCodeServlet {

  @Override
  protected void doGet(HttpServletRequest request, HttpServletResponse response)
      throws IOException {
    // do stuff
  }

  @Override
  protected String getRedirectUri(HttpServletRequest req) throws ServletException, IOException {
    return Utils.getRedirectUri(req);
  }

  @Override
  protected AuthorizationCodeFlow initializeFlow() throws IOException {
    return Utils.newFlow();
  }
}

class Utils {
  static String getRedirectUri(HttpServletRequest req) {
    GenericUrl url = new GenericUrl(req.getRequestURL().toString());
    url.setRawPath("/oauth2callback");
    return url.build();
  }

  static GoogleAuthorizationCodeFlow newFlow() throws IOException {
    return new GoogleAuthorizationCodeFlow.Builder(HTTP_TRANSPORT, JSON_FACTORY,
        getClientCredential(), Collections.singleton(CalendarScopes.CALENDAR)).setDataStoreFactory(
        DATA_STORE_FACTORY).setAccessType("offline").build();
  }
}

public class OAuth2Callback extends AbstractAppEngineAuthorizationCodeCallbackServlet {

  private static final long serialVersionUID = 1L;

  @Override
  protected void onSuccess(HttpServletRequest req, HttpServletResponse resp, Credential credential)
      throws ServletException, IOException {
    resp.sendRedirect("/");
  }

  @Override
  protected void onError(
      HttpServletRequest req, HttpServletResponse resp, AuthorizationCodeResponseUrl errorResponse)
      throws ServletException, IOException {
    String nickname = UserServiceFactory.getUserService().getCurrentUser().getNickname();
    resp.getWriter().print("<h3>" + nickname + ", why don't you want to play with me?</h1>");
    resp.setStatus(200);
    resp.addHeader("Content-Type", "text/html");
  }

  @Override
  protected String getRedirectUri(HttpServletRequest req) throws ServletException, IOException {
    return Utils.getRedirectUri(req);
  }

  @Override
  protected AuthorizationCodeFlow initializeFlow() throws IOException {
    return Utils.newFlow();
  }
}

एक और सैंपल के लिए, storage-serviceaccount-appengine-sample देखें.

सेवा खाते

GoogleCredential, सेवा खातों के साथ भी काम करता है. क्लाइंट ऐप्लिकेशन, एंड-यूज़र के डेटा को ऐक्सेस करने का अनुरोध करने के लिए जिस क्रेडेंशियल का इस्तेमाल करता है उससे अलग, सेवा खाते क्लाइंट ऐप्लिकेशन को उसके खुद के डेटा का ऐक्सेस देते हैं. आपका क्लाइंट ऐप्लिकेशन, Google API Console से डाउनलोड की गई निजी कुंजी का इस्तेमाल करके, ऐक्सेस टोकन के लिए अनुरोध पर हस्ताक्षर करता है.

इस्तेमाल का उदाहरण:

HttpTransport httpTransport = new NetHttpTransport();
JsonFactory jsonFactory = GsonFactory.getDefaultInstance();
...
// Build service account credential.

GoogleCredential credential = GoogleCredential.fromStream(new FileInputStream("MyProject-1234.json"))
    .createScoped(Collections.singleton(PlusScopes.PLUS_ME));
// Set up global Plus instance.
plus = new Plus.Builder(httpTransport, jsonFactory, credential)
    .setApplicationName(APPLICATION_NAME).build();
...

एक और उदाहरण के लिए, storage-serviceaccount-cmdline-sample देखें.

ध्यान दें: Google Apps डोमेन से चलने वाले ऐप्लिकेशन में सेवा खातों का इस्तेमाल किया जा सकता है. हालांकि, सेवा खाते आपके Google Apps खाते के सदस्य नहीं होते हैं. साथ ही, इन पर Google Apps एडमिन की ओर से सेट की गई डोमेन नीतियां लागू नहीं होती हैं. उदाहरण के लिए, Google Apps एडमिन कंसोल में सेट की गई ऐसी नीति जो Apps के असली उपयोगकर्ताओं को डोमेन के बाहर दस्तावेज़ शेयर करने से रोकती है, वह सेवा खातों पर लागू नहीं होगी.

किसी दूसरे के नाम पर काम करना

आपके पास सेवा खाते के फ़्लो का इस्तेमाल करके, उस डोमेन में किसी उपयोगकर्ता के तौर पर काम करने का विकल्प भी होता है जिसका मालिकाना हक आपके पास है. यह ऊपर दिए गए सेवा खाते के फ़्लो से काफ़ी मिलता-जुलता है. हालांकि, इसमें आपको GoogleCredential.Builder.setServiceAccountUser(String) को कॉल करना होता है.

इंस्‍टॉल किए गए ऐप्स

यह कमांड-लाइन ऑथराइज़ेशन कोड फ़्लो है. इसके बारे में इंस्टॉल किए गए ऐप्लिकेशन के लिए OAuth 2.0 का इस्तेमाल करना लेख में बताया गया है.

इस्तेमाल का उदाहरण:

public static void main(String[] args) {
  try {
    httpTransport = new NetHttpTransport();
    dataStoreFactory = new FileDataStoreFactory(DATA_STORE_DIR);
    // authorization
    Credential credential = authorize();
    // set up global Plus instance
    plus = new Plus.Builder(httpTransport, JSON_FACTORY, credential).setApplicationName(
        APPLICATION_NAME).build();
   // ...
}

private static Credential authorize() throws Exception {
  // load client secrets
  GoogleClientSecrets clientSecrets = GoogleClientSecrets.load(JSON_FACTORY,
      new InputStreamReader(PlusSample.class.getResourceAsStream("/client_secrets.json")));
  // set up authorization code flow
  GoogleAuthorizationCodeFlow flow = new GoogleAuthorizationCodeFlow.Builder(
      httpTransport, JSON_FACTORY, clientSecrets,
      Collections.singleton(PlusScopes.PLUS_ME)).setDataStoreFactory(
      dataStoreFactory).build();
  // authorize
  return new AuthorizationCodeInstalledApp(flow, new LocalServerReceiver()).authorize("user");
}

क्लाइंट-साइड ऐप्लिकेशन

क्लाइंट-साइड ऐप्लिकेशन के लिए OAuth 2.0 का इस्तेमाल करना में बताए गए ब्राउज़र पर आधारित क्लाइंट फ़्लो का इस्तेमाल करने के लिए, आम तौर पर यह तरीका अपनाया जाता है:

GoogleBrowserClientRequestUrl का इस्तेमाल करके, असली उपयोगकर्ता को ब्राउज़र में अनुमति वाले पेज पर रीडायरेक्ट करें, ताकि आपके ब्राउज़र ऐप्लिकेशन को असली उपयोगकर्ता के सुरक्षित डेटा का ऐक्सेस मिल सके.
Google API Console में रजिस्टर किए गए रीडायरेक्ट यूआरआई पर, यूआरएल फ़्रैगमेंट में मिले ऐक्सेस टोकन को प्रोसेस करने के लिए, JavaScript के लिए Google API Client Library का इस्तेमाल करें.

वेब ऐप्लिकेशन के लिए इस्तेमाल का उदाहरण:

public void doGet(HttpServletRequest request, HttpServletResponse response)throws IOException {
  String url = new GoogleBrowserClientRequestUrl("812741506391.apps.googleusercontent.com",
      "https://oauth2.example.com/oauthcallback", Arrays.asList(
          "https://www.googleapis.com/auth/userinfo.email",
          "https://www.googleapis.com/auth/userinfo.profile")).setState("/profile").build();
  response.sendRedirect(url);
}

Android

@Beta

Android के साथ कौनसी लाइब्रेरी इस्तेमाल की जा सकती है:

अगर आपको Android के लिए कोई ऐप्लिकेशन डेवलप करना है और आपको जिस Google API का इस्तेमाल करना है वह Google Play services की लाइब्रेरी में शामिल है, तो बेहतर परफ़ॉर्मेंस और अनुभव के लिए उस लाइब्रेरी का इस्तेमाल करें. अगर Android के साथ इस्तेमाल किया जाने वाला Google API, Google Play services लाइब्रेरी का हिस्सा नहीं है, तो Java के लिए Google API की क्लाइंट लाइब्रेरी का इस्तेमाल किया जा सकता है. यह Android 4.0 (Ice Cream Sandwich) या इसके बाद के वर्शन के साथ काम करती है. इसके बारे में यहां बताया गया है. Google API Client Library for Java में Android के लिए सहायता @Beta है.

बुनियादी जानकारी:

Eclair (SDK 2.1) से, Android डिवाइस पर उपयोगकर्ता खातों को मैनेज करने के लिए, खाता मैनेजर का इस्तेमाल किया जाता है. Android ऐप्लिकेशन के लिए अनुमति देने की प्रोसेस को SDK टूल, AccountManager का इस्तेमाल करके मैनेज करता है. आपको OAuth 2.0 का वह स्कोप तय करना होता है जिसकी आपके ऐप्लिकेशन को ज़रूरत है. इसके बाद, यह आपको इस्तेमाल करने के लिए ऐक्सेस टोकन देता है.

OAuth 2.0 स्कोप को authTokenType पैरामीटर के ज़रिए, oauth2: के साथ-साथ स्कोप के तौर पर तय किया जाता है. उदाहरण के लिए:

oauth2:https://www.googleapis.com/auth/tasks

इससे Google Tasks API के लिए, पढ़ने/लिखने का ऐक्सेस मिलता है. अगर आपको एक से ज़्यादा OAuth 2.0 स्कोप की ज़रूरत है, तो स्पेस से अलग की गई सूची का इस्तेमाल करें.

कुछ एपीआई में खास authTokenType पैरामीटर होते हैं, जो काम करते हैं. उदाहरण के लिए, "अपने टास्क मैनेज करें" ऊपर दिखाए गए authtokenType उदाहरण का एलियास है.

आपको Google API Console से मिली एपीआई कुंजी भी देनी होगी. ऐसा न करने पर, AccountManager से मिलने वाला टोकन आपको सिर्फ़ गुमनाम कोटा देता है. यह कोटा आम तौर पर बहुत कम होता है. इसके उलट, एपीआई कुंजी देने पर आपको ज़्यादा मुफ़्त कोटा मिलता है. साथ ही, आपके पास उस कोटे से ज़्यादा इस्तेमाल करने पर बिलिंग सेट अप करने का विकल्प होता है.

tasks-android-sample से लिया गया कोड स्निपेट का उदाहरण:

com.google.api.services.tasks.Tasks service;

@Override
public void onCreate(Bundle savedInstanceState) {
  credential =
      GoogleAccountCredential.usingOAuth2(this, Collections.singleton(TasksScopes.TASKS));
  SharedPreferences settings = getPreferences(Context.MODE_PRIVATE);
  credential.setSelectedAccountName(settings.getString(PREF_ACCOUNT_NAME, null));
  service =
      new com.google.api.services.tasks.Tasks.Builder(httpTransport, jsonFactory, credential)
          .setApplicationName("Google-TasksAndroidSample/1.0").build();
}

private void chooseAccount() {
  startActivityForResult(credential.newChooseAccountIntent(), REQUEST_ACCOUNT_PICKER);
}

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
  super.onActivityResult(requestCode, resultCode, data);
  switch (requestCode) {
    case REQUEST_GOOGLE_PLAY_SERVICES:
      if (resultCode == Activity.RESULT_OK) {
        haveGooglePlayServices();
      } else {
        checkGooglePlayServicesAvailable();
      }
      break;
    case REQUEST_AUTHORIZATION:
      if (resultCode == Activity.RESULT_OK) {
        AsyncLoadTasks.run(this);
      } else {
        chooseAccount();
      }
      break;
    case REQUEST_ACCOUNT_PICKER:
      if (resultCode == Activity.RESULT_OK && data != null && data.getExtras() != null) {
        String accountName = data.getExtras().getString(AccountManager.KEY_ACCOUNT_NAME);
        if (accountName != null) {
          credential.setSelectedAccountName(accountName);
          SharedPreferences settings = getPreferences(Context.MODE_PRIVATE);
          SharedPreferences.Editor editor = settings.edit();
          editor.putString(PREF_ACCOUNT_NAME, accountName);
          editor.commit();
          AsyncLoadTasks.run(this);
        }
      }
      break;
  }
}