หน้านี้ได้รับการแปลโดย 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 อเนกประสงค์

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

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

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

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

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

ข้อมูลเข้าสู่ระบบที่ใช้ทางเลือกนี้อิงตาม API ของ Java สําหรับ App Engine ของ Google App Engine 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 มีหน้าที่ดูแล "Refresh" โทเค็นโดยอัตโนมัติ ซึ่งหมายความว่าจะได้รับโทเค็นเพื่อการเข้าถึงใหม่ ซึ่งทําได้โดยใช้โทเค็นการรีเฟรชที่ใช้ได้นาน ซึ่งมักจะได้รับมาพร้อมกับโทเค็นเพื่อการเข้าถึงหากคุณใช้พารามิเตอร์ access_type=offline ระหว่างขั้นตอนรหัสการให้สิทธิ์ (ดู GoogleAuthorizationCodeFlow.Builder.setAccessType(String))

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

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

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

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

โฟลว์รหัสการให้สิทธิ์

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

ขั้นตอนนี้ทําโดยใช้ GoogleAuthorizationCodeFlow ขั้นตอนมีดังต่อไปนี้

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

แต่หากไม่ได้ใช้ GoogleAuthorizationCodeFlow คุณจะใช้คลาสระดับล่างกว่าได้

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

ความแตกต่างหลักๆ จากกรณีของเซิร์ฟเล็ตคือคุณให้คลาสย่อยที่เป็นรูปธรรมของ AbstractAppEngineAuthorizationCodeServlet และ AbstractAppEngineAuthorizationCodeCallbackServlet (จาก google-oauth-client-appengine โดยขยายคลาสเซิร์ฟเล็ตเชิงนามธรรมและนําเมธอด getUserId ไปใช้สําหรับคุณโดยใช้ User 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

ตัวอย่างโค้ดที่ได้จาก 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 เพื่อประมวลผลโทเค็นเพื่อการเข้าถึงในส่วน 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 ในไลบรารีของไคลเอ็นต์ 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 พิเศษที่ใช้ได้เช่นกัน เช่น &"Manage your tasks" คือชื่อแทนของตัวอย่าง 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;
  }
}