इस पेज का अनुवाद Cloud Translation API से किया गया है.

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

खास जानकारी

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

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

Java के लिए Google API क्लाइंट लाइब्रेरी में मौजूद OAuth 2.0 पैकेज, अलग-अलग कामों के लिए बनाए गए हैं.Java के लिए Google OAuth 2.0 क्लाइंट लाइब्रेरी.

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

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

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

अपने क्रेडेंशियल को ठीक से सेट अप करने के निर्देशों के लिए, 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 का इस्तेमाल करें (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: फ़ाइल में क्रेडेंशियल को बनाए रखता है.

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

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

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

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

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

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

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

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

Google API (एपीआई) कंसोल में अपना प्रोजेक्ट सेट अप करते समय, आप जिस फ़्लो का इस्तेमाल कर रहे हैं उसके आधार पर अलग-अलग क्रेडेंशियल में से कोई एक क्रेडेंशियल चुनते हैं. ज़्यादा जानकारी के लिए, OAuth 2.0 सेट अप करना और OAuth 2.0 स्थितियां देखें. हर फ़्लो के लिए कोड स्निपेट नीचे दिए गए हैं.

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

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

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

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 पर ऑथराइज़ेशन कोड का फ़्लो, सर्वलेट के ऑथराइज़ेशन कोड फ़्लो के जैसा होता है. हालांकि, हम Google App Engine के Users Java API के फ़्लो का इस्तेमाल कर सकते हैं. उपयोगकर्ता को उपयोगकर्ताओं के Java API के लिए लॉग इन करना होगा. अगर उपयोगकर्ताओं ने पहले से लॉग इन नहीं किया है, तो उन्हें लॉगिन पेज पर रीडायरेक्ट करने के बारे में जानकारी पाने के लिए, सुरक्षा और पुष्टि करना (web.xml में) देखें.

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

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 कंसोल से डाउनलोड की गई निजी कुंजी का इस्तेमाल करके, ऐक्सेस टोकन के अनुरोध पर हस्ताक्षर करता है.

plus-serviceaccount-cmdline-sample से लिया गया कोड का उदाहरण:

HttpTransport httpTransport = GoogleNetHttpTransport.newTrustedTransport();
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 एडमिन कंसोल में सेट की गई नीति, सेवा खातों पर लागू नहीं होगी.

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

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

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

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

plus-cmdline-sample से मिला स्निपेट का उदाहरण:

public static void main(String[] args) {
  try {
    httpTransport = GoogleNetHttpTransport.newTrustedTransport();
    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 कंसोल में रजिस्टर किए गए रीडायरेक्ट यूआरआई पर, यूआरएल फ़्रैगमेंट में मिले ऐक्सेस टोकन को प्रोसेस करने के लिए, JavaScript के लिए Google API क्लाइंट लाइब्रेरी का इस्तेमाल करें.

वेब ऐप्लिकेशन के लिए इस्तेमाल का सैंपल:

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

@बीटा वर्शन

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

अगर इसे Android के लिए डेवलप किया जा रहा है और आपको जिस Google API का इस्तेमाल करना है वह Google Play services की लाइब्रेरी में शामिल है, तो उस लाइब्रेरी का इस्तेमाल बेहतरीन परफ़ॉर्मेंस और अनुभव के लिए करें. अगर आपको Android के साथ जिस Google API का इस्तेमाल करना है वह Google Play Services की लाइब्रेरी का हिस्सा नहीं है, तो Java के लिए Google API क्लाइंट लाइब्रेरी का इस्तेमाल किया जा सकता है. यह सुविधा Android 4.0 (Ice Cream witch) (या इसके बाद के वर्शन) पर काम करती है. इसके बारे में यहां बताया गया है. Java के लिए Google API क्लाइंट लाइब्रेरी में, 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 कंसोल से भी एपीआई पासकोड तय करना होगा. अगर ऐसा नहीं है, तो 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;
  }
}