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

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 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. उस क्रेडेंशियल के उलट जिसमें क्लाइंट ऐप्लिकेशन किसी है, तो ऐप्लिकेशन पहचान 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)).

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

AppEngineDataStoreFactory: Google App Engine Data Store API का उपयोग करके क्रेडेंशियल बना रहता है.
MemoryDataStoreFactory: "नियमित तौर पर" मेमोरी में मौजूद क्रेडेंशियल, जो प्रोसेस के दौरान सिर्फ़ कुछ समय के लिए स्टोरेज के तौर पर काम करता है.
FileDataStoreFactory: किसी फ़ाइल में क्रेडेंशियल बना रहता है.

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

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

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

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

यह फ़्लो 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 कंसोल में अपना प्रोजेक्ट सेट अप करने पर, अपने इस्तेमाल किए जा रहे फ़्लो के हिसाब से, अलग-अलग क्रेडेंशियल में से किसी एक को चुनें. ज़्यादा जानकारी के लिए, OAuth 2.0 सेट अप करना लेख देखें और OAuth 2.0 के हालात. हर फ़्लो के लिए कोड स्निपेट नीचे दिए गए हैं.

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

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

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

सर्वलेट केस से मुख्य अंतर यह है कि कंक्रीट इसकी सब-क्लास AbstractAppEngineAuthorizationCodeServlet और AbstractAppEngineAuthorizationCodeCallbackServlet (google-oauth-client-appengine से. वे ऐब्स्ट्रैक्ट सर्वलेट क्लास को बढ़ाते हैं और getUserId तरीके को लागू करते हैं उपयोगकर्ता जावा API का उपयोग करके आपके लिए बनाया गया है. AppEngineDataStoreFactory (google-http-client-appengine से) Google App Engine डेटा का इस्तेमाल करके क्रेडेंशियल को बनाए रखने का एक अच्छा विकल्प है 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 व्यवस्थापक में सेट की गई नीति के बाहर दस्तावेज़ों को साझा करने की 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 ताकि आपके ब्राउज़र ऐप्लिकेशन को असली उपयोगकर्ता के सुरक्षित डेटा का ऐक्सेस मिल सके.
JavaScript के लिए Google API क्लाइंट लाइब्रेरी का इस्तेमाल करना रीडायरेक्ट यूआरआई के यूआरएल फ़्रैगमेंट में मिले ऐक्सेस टोकन को प्रोसेस करने के लिए 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 लाइब्रेरी, उस लाइब्रेरी का इस्तेमाल बेहतर परफ़ॉर्मेंस और अनुभव के लिए कर सकते हैं. अगर Google API को Google Play Services की लाइब्रेरी का हिस्सा नहीं है, तो आपको Android पर Java के लिए Google API क्लाइंट लाइब्रेरी का इस्तेमाल किया जा सकता है, जो Android 4.0 (Ice Cream रिच) का समर्थन करता है (या इससे ज़्यादा), जिसकी जानकारी यहां दी गई है. Google में Android के लिए समर्थन Java के लिए एपीआई क्लाइंट लाइब्रेरी, @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 कंसोल. अगर ऐसा नहीं है, तो खाता मैनेजर से मिला टोकन आपको सिर्फ़ यह जानकारी देता है अनाम कोटा, जो आमतौर पर बहुत कम होता है. इसके उलट, एपीआई तय करके कुंजी आपको उच्च मुफ़्त कोटा प्राप्त होती है, और आप वैकल्पिक रूप से उपयोग के लिए बिलिंग सेट कर सकते हैं .

उदाहरण: कोड स्निपेट यहां से लिया गया 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;
  }
}