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

ภาพรวม

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

สรุป: หากต้องการเข้าถึงข้อมูลที่ได้รับการปกป้องซึ่งจัดเก็บไว้ในบริการของ Google ให้ใช้ OAuth 2.0 เพื่อให้สิทธิ์ Google APIs รองรับกระบวนการ 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 APIs ได้ คุณต้องตั้งค่าโปรเจ็กต์ในคอนโซล 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();
}

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

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

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

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

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

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

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

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

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

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

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

ความแตกต่างหลักจากกรณีของ Servlet คือคุณต้องระบุคลาสย่อยที่เฉพาะเจาะจงของ AbstractAppEngineAuthorizationCodeServlet และ AbstractAppEngineAuthorizationCodeCallbackServlet (จาก google-oauth-client-appengine โดยจะขยายคลาส Servlet แบบนามธรรมและใช้เมธอด getUserId ให้คุณโดยใช้ Users Java API 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

ตัวอย่างการใช้งาน

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 สำหรับแอปพลิเคชันฝั่งไคลเอ็นต์ โดยปกติคุณจะต้องทำตามขั้นตอนต่อไปนี้

1. เปลี่ยนเส้นทางผู้ใช้ปลายทางในเบราว์เซอร์ไปยังหน้าการให้สิทธิ์โดยใช้ GoogleBrowserClientRequestUrl เพื่อให้สิทธิ์เข้าถึงข้อมูลที่ได้รับการปกป้องของผู้ใช้ปลายทางแก่แอปพลิเคชันเบราว์เซอร์
2. ใช้ไลบรารีของไคลเอ็นต์ 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

@Beta

คลังที่จะใช้กับ Android

หากคุณกำลังพัฒนาแอปสำหรับ Android และ Google API ที่ต้องการใช้รวมอยู่ใน ไลบรารีของ Google Play Services ให้ใช้ไลบรารีดังกล่าวเพื่อประสิทธิภาพและประสบการณ์การใช้งานที่ดีที่สุด หาก Google API ที่คุณต้องการใช้กับ Android ไม่ได้อยู่ในไลบรารีบริการ Google Play คุณสามารถใช้ไลบรารีของไคลเอ็นต์ Google API สำหรับ Java ซึ่งรองรับ Android 4.0 (Ice Cream Sandwich) ขึ้นไป และมีคำอธิบายอยู่ที่นี่ การรองรับ Android ในไลบรารีของไคลเอ็นต์ Google 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 ด้วย ไม่เช่นนั้น โทเค็นที่ 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;
  }
}