หน้านี้ได้รับการแปลโดย Cloud Translation API

การใช้ OAuth 2.0 กับไลบรารีของไคลเอ็นต์ Google API สำหรับ Java

ภาพรวม

วัตถุประสงค์: เอกสารนี้จะอธิบายวิธีใช้ GoogleCredential คลาสยูทิลิตีเพื่อทำการให้สิทธิ์ OAuth 2.0 กับบริการของ Google สำหรับ ข้อมูลเกี่ยวกับฟังก์ชัน OAuth 2.0 ทั่วไปที่เรามีให้ โปรดดู OAuth 2.0 และไลบรารีของไคลเอ็นต์ OAuth ของ Google สำหรับ Java

สรุป: หากต้องการเข้าถึงข้อมูลที่มีการป้องกันซึ่งจัดเก็บไว้ในบริการของ Google โปรดใช้ OAuth 2.0 สำหรับการให้สิทธิ์ Google API รองรับขั้นตอน OAuth 2.0 สำหรับแอปพลิเคชันไคลเอ็นต์ประเภทต่างๆ ในขั้นตอนทั้งหมดนี้ แอปพลิเคชันไคลเอ็นต์จะขอโทเค็นเพื่อการเข้าถึงที่ เชื่อมโยงกับแอปพลิเคชันไคลเอ็นต์และเจ้าของข้อมูลที่ได้รับการคุ้มครองเท่านั้น มีการเข้าถึง โทเค็นเพื่อการเข้าถึงยังเชื่อมโยงกับขอบเขตที่จำกัดซึ่ง กำหนดประเภทข้อมูลที่แอปพลิเคชันไคลเอ็นต์ของคุณมีสิทธิ์เข้าถึง (เช่น "จัดการงานของคุณ") เป้าหมายสำคัญของ OAuth 2.0 คือการให้ เข้าถึงข้อมูลที่ได้รับการคุ้มครองได้อย่างสะดวก ขณะเดียวกันก็ลดผลกระทบที่อาจเกิดขึ้น หากโทเค็นเพื่อการเข้าถึงถูกขโมย

แพ็กเกจ OAuth 2.0 ในไลบรารีของไคลเอ็นต์ Google API สำหรับ Java นั้นสร้างขึ้นบน เพื่อวัตถุประสงค์ทั่วไป ไลบรารีของไคลเอ็นต์ Google OAuth 2.0 สำหรับ Java

โปรดดูรายละเอียดที่เอกสารประกอบของ Javadoc สำหรับแพ็กเกจต่อไปนี้

com.google.api.client.googleapis.auth.oauth2 (จาก google-api-client)
com.google.api.client.googleapis.extensions.appengine.auth.oauth2 (จาก google-api-client-appengine)

คอนโซล Google API

ก่อนที่คุณจะสามารถเข้าถึง Google API คุณต้องตั้งค่าโปรเจ็กต์ใน คอนโซล Google API สำหรับการตรวจสอบสิทธิ์และการเรียกเก็บเงิน ไม่ว่าจะเป็นแอปพลิเคชันที่ติดตั้ง แอปพลิเคชันบนมือถือ เว็บเซิร์ฟเวอร์ หรือไคลเอ็นต์ที่ทำงานในเบราว์เซอร์

หากต้องการดูวิธีการตั้งค่าข้อมูลเข้าสู่ระบบอย่างถูกต้อง โปรดดูหัวข้อ ความช่วยเหลือสำหรับคอนโซล API

ข้อมูลเข้าสู่ระบบ

GoogleCredential

GoogleCredential เป็นคลาสตัวช่วยแบบ Thread-safe สำหรับ 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();
}

ที่เก็บข้อมูล

โทเค็นเพื่อการเข้าถึงมักจะมีวันหมดอายุ 1 ชั่วโมง หลังจากนั้นคุณจะต้อง ได้รับข้อผิดพลาดหากพยายามใช้งาน GoogleCredential จะทำการ "รีเฟรช" โดยอัตโนมัติ โทเค็น ซึ่งหมายถึงการ โทเค็นเพื่อการเข้าถึงใหม่ ซึ่งทำโดยใช้โทเค็นการรีเฟรชที่ใช้ได้นาน มักจะได้รับพร้อมกับโทเค็นเพื่อการเข้าถึงหากคุณใช้ พารามิเตอร์ access_type=offline ในระหว่างขั้นตอนรหัสการให้สิทธิ์ (โปรดดู GoogleAuthorizationCodeFlow.Builder.setAccessType(String))

แอปพลิเคชันส่วนใหญ่จะต้องเก็บโทเค็นการเข้าถึงของข้อมูลเข้าสู่ระบบไว้และ/หรือ โทเค็นการรีเฟรช หากต้องการยืนยันสิทธิ์เข้าถึงของข้อมูลเข้าสู่ระบบและ/หรือรีเฟรชโทเค็น คุณสามารถดำเนินการ ติดตั้งใช้งาน DataStoreFactory ของคุณเอง โดยใช้ StoredCredential หรือคุณสามารถใช้วิธีการติดตั้งใช้งานอย่างใดอย่างหนึ่งต่อไปนี้จากไลบรารี

AppEngineDataStoreFactory: เก็บเอกสารรับรองโดยใช้ Google App Engine Data Store API
MemoryDataStoreFactory: "ถาวร" ข้อมูลเข้าสู่ระบบในหน่วยความจำ ซึ่งจะเป็นประโยชน์เฉพาะในฐานะพื้นที่เก็บข้อมูลระยะสั้นตลอดอายุของกระบวนการ
FileDataStoreFactory: เก็บข้อมูลเข้าสู่ระบบในไฟล์

ผู้ใช้ AppEngine AppEngineCredentialStore เลิกใช้งานแล้ว และจะนำออกเร็วๆ นี้ เราขอแนะนำให้คุณใช้ AppEngineDataStoreFactory ที่มี StoredCredential หากคุณมีข้อมูลประจำตัวที่จัดเก็บแบบดั้งเดิม คุณสามารถใช้ เมธอดของ Helper migrateTo(AppEngineDataStoreFactory) หรือ migrateTo(DataStore) ย้ายข้อมูลได้

คุณอาจใช้ DataStoreCredentialRefreshListener และตั้งค่าเป็นข้อมูลเข้าสู่ระบบโดยใช้ GoogleCredential.Builder.addRefreshListener(CredentialRefreshListener))

ขั้นตอนสำหรับรหัสการให้สิทธิ์

ใช้ขั้นตอนรหัสการให้สิทธิ์เพื่ออนุญาตให้ผู้ใช้ปลายทางให้สิทธิ์แอปพลิเคชันของคุณ เข้าถึงข้อมูลที่มีการป้องกันใน Google APIs โปรโตคอลสำหรับขั้นตอนนี้คือ ที่ระบุใน การให้สิทธิ์รหัสการให้สิทธิ์

ขั้นตอนนี้ดำเนินการโดยใช้ GoogleAuthorizationCodeFlow ขั้นตอนมีดังต่อไปนี้

ผู้ใช้ปลายทางจะเข้าสู่ระบบแอปพลิเคชันของคุณ คุณจะต้องเชื่อมโยงผู้ใช้รายนั้น พร้อมด้วย User-ID ที่ไม่ซ้ำกันสำหรับแอปพลิเคชันของคุณ
เรียกใช้ AuthorizationCodeFlow.loadCredential(String)) ตาม User-ID เพื่อตรวจสอบว่าทราบข้อมูลเข้าสู่ระบบของผู้ใช้ปลายทางอยู่แล้วหรือไม่ ถ้าใช่ นั่นแสดงเสร็จแล้ว
หากไม่เห็น โปรดเรียกใช้ AuthorizationCodeFlow.newAuthorizationUrl() และให้เบราว์เซอร์ของผู้ใช้ปลายทางไปยังหน้าการให้สิทธิ์ ของแอปพลิเคชันเข้าถึงข้อมูลที่มีการป้องกัน
จากนั้นเซิร์ฟเวอร์การให้สิทธิ์ของ Google จะเปลี่ยนเส้นทางเบราว์เซอร์กลับไปยัง URL เปลี่ยนเส้นทางที่ระบุโดยแอปพลิเคชันของคุณ พร้อมกับคำค้นหา code พารามิเตอร์ ใช้พารามิเตอร์ code เพื่อขอโทเค็นเพื่อการเข้าถึงโดยใช้ AuthorizationCodeFlow.newTokenRequest(String))
ใช้ AuthorizationCodeFlow.createAndStoreCredential(TokenResponse, String)) เพื่อจัดเก็บและรับข้อมูลรับรองสำหรับการเข้าถึงทรัพยากรที่มีการป้องกัน

หากไม่ได้ใช้ GoogleAuthorizationCodeFlow คุณอาจใช้คลาสระดับต่ำลงมาได้ดังนี้

ใช้ DataStore.get(String) เพื่อโหลดข้อมูลเข้าสู่ระบบจาก Store ตามรหัสผู้ใช้
ใช้ 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 สำหรับแอปพลิเคชันเว็บเซิร์ฟเวอร์

ไลบรารีนี้มีชั้นเรียนตัวช่วยของเซิร์ฟเล็ตเพื่อลดความซับซ้อนของ ขั้นตอนรหัสการให้สิทธิ์สำหรับ Use Case พื้นฐาน คุณเพียงแค่ให้คลาสย่อยที่เป็นรูปธรรม ของ 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 แทบจะเหมือนกันทุกประการกับเซิร์ฟเล็ต ขั้นตอนรหัสการให้สิทธิ์ ยกเว้นว่าเราสามารถใช้ประโยชน์จาก JavaScript API ของผู้ใช้ ผู้ใช้ ต้องเข้าสู่ระบบเพื่อใช้ Java API ของผู้ใช้ เพื่อดูข้อมูลเกี่ยวกับ การเปลี่ยนเส้นทางผู้ใช้ไปยังหน้าเข้าสู่ระบบ หากผู้ใช้ยังไม่ได้เข้าสู่ระบบ โปรดดู ความปลอดภัยและการตรวจสอบสิทธิ์ (ใน web.xml)

ข้อแตกต่างหลักจากกรณีของเซิร์ฟเล็ตคือคุณให้ข้อมูลที่เป็นรูปธรรม คลาสย่อยของ AbstractAppEngineAuthorizationCodeServlet และ AbstractAppEngineAuthorizationCodeCallbackServlet (จาก google-oauth-client-appengine พวกเขาขยายคลาสเซิร์ฟเล็ตเชิงนามธรรมและนำเมธอด getUserId ให้คุณโดยใช้ Users Java 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 เช่น นโยบายที่ตั้งค่าไว้ในผู้ดูแลระบบ 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 เพื่อให้สิทธิ์แอปพลิเคชันเบราว์เซอร์ในการเข้าถึงข้อมูลที่มีการป้องกันของผู้ใช้ปลายทาง
ใช้ไลบรารีของไคลเอ็นต์ Google API สำหรับ JavaScript เพื่อประมวลผลโทเค็นเพื่อการเข้าถึงที่พบในส่วนย่อย URL ที่ URI การเปลี่ยนเส้นทาง ซึ่งลงทะเบียนในคอนโซล 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 ให้ใช้ไลบรารีดังกล่าวเพื่อประสิทธิภาพและประสบการณ์ที่ดีที่สุด หาก Google API ที่ต้องการใช้กับ Android ไม่ได้เป็นส่วนหนึ่งของไลบรารีบริการ Google Play คุณ สามารถใช้ไลบรารีของไคลเอ็นต์ Google API สำหรับ Java ซึ่งรองรับ Android 4.0 (Ice Cream Sandwich) (หรือสูงกว่า) ซึ่งมีคำอธิบายไว้ที่นี่ การสนับสนุนสำหรับ Android ใน ไลบรารีของไคลเอ็นต์ API สำหรับ 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 โปรดใช้รายการที่คั่นด้วยช่องว่าง

API บางรายการมีพารามิเตอร์ authTokenType พิเศษที่สามารถใช้งานได้ ตัวอย่างเช่น "จัดการงานของคุณ" เป็นชื่อแทนสำหรับตัวอย่าง authtokenType ที่แสดงด้านบน

นอกจากนี้ คุณต้องระบุคีย์ API จาก Google API Console มิฉะนั้น โทเค็นที่ AccountManager ให้คุณมอบให้คุณเท่านั้น โควต้าที่ไม่ระบุตัวตน ซึ่งปกติจะต่ำมาก แต่การระบุ 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;
  }
}