การตรวจสอบสิทธิ์สำหรับ GDK Glassware

หาก GDK Glassware ต้องตรวจสอบสิทธิ์ผู้ใช้กับบริการบนเว็บ GDK มี API ที่ให้ผู้ใช้ป้อนข้อมูลเข้าสู่ระบบเมื่อ ติดตั้ง Glassware ของคุณ

การใช้ API นี้หมายถึงคุณได้ สำหรับผู้ใช้ Glass และหลีกเลี่ยงค่าใช้จ่ายในการติดตั้ง แผนการตรวจสอบสิทธิ์ที่กำหนดเอง

การสร้างบัญชีบริการ Google API

เมื่อตั้งค่าการตรวจสอบสิทธิ์อย่างถูกต้องแล้ว แบ็กเอนด์ของเว็บแอป ใช้ Mirror API เพื่อพุชผู้ใช้ ข้อมูลบัญชีไปยัง Glass หลังจากตรวจสอบสิทธิ์กับบริการของคุณ

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

วิธีสร้างบัญชีนี้

  1. ไปที่ Google Developers Console
  2. คลิกปุ่มสร้างโปรเจ็กต์ แล้วป้อนข้อมูลที่ระบบขอ
  3. เมื่อสร้างโปรเจ็กต์แล้ว ให้จดบันทึกหมายเลขโครงการ คุณจะต้องใช้ในภายหลัง
  4. ในส่วน API และ auth คลิก API และเปิดใช้ Google Mirror API ให้กับโปรเจ็กต์ใหม่ได้เลย
  5. ในส่วน API และ auth คลิกข้อมูลรับรอง แล้วคลิกสร้างไคลเอ็นต์ใหม่ บัตรประจำตัว เลือกช่องบัญชีบริการเพื่อสร้าง OAuth 2.0 ใหม่ รหัสไคลเอ็นต์ของโปรเจ็กต์
  6. หน้าต่างป๊อปอัปจะแจ้งให้ทราบว่ากำลังดาวน์โหลดคีย์ส่วนตัว ในคอมพิวเตอร์ของคุณ และแจ้งรหัสผ่านสำหรับคีย์ส่วนตัวนั้น เมื่อปิดหน้าต่างนี้ คุณจะดาวน์โหลดส่วนแบบส่วนตัวไม่ได้ หรือดูรหัสผ่านอีกครั้ง หากมีการสูญหายไป คุณต้องสร้างใหม่ ข้อ 1
  7. จดบันทึกอีเมลของบัญชีบริการ ซึ่งคุณจะต้องใช้ ในภายหลัง เพื่อเรียกใช้ API

การให้ข้อมูลเมตาเกี่ยวกับ Glassware ของคุณ

เมื่อพร้อมที่จะส่ง Glassware ของคุณแล้ว คุณจะต้องให้ ข้อมูลต่อไปนี้ วิธีนี้จะช่วยให้เราสามารถตั้งค่า Glassware ของคุณเพื่อ ถูกต้องเมื่อคุณติดตั้งใช้งาน

  • URL การตรวจสอบสิทธิ์ที่ระบบจะเปลี่ยนเส้นทางผู้ใช้ไปเมื่อ พวกเขาจะเปิดกลาสแวร์ของคุณใน MyGlass
  • ประเภทบัญชี (สตริงที่คุณจะใช้เมื่อเรียกเมธอด Android AccountManager API ในอุปกรณ์ Glass)
  • ชื่อแพ็กเกจของแอปพลิเคชันจาก AndroidManifest.xml
  • ตัวเลขรหัสโปรเจ็กต์ Google API ของโปรเจ็กต์ที่คุณสร้าง สูงกว่า
  • APK ที่จะอัปโหลดบน MyGlass สำหรับการทดสอบ คุณเพียงต้องระบุ APK นี้ครั้งเดียวเพื่อจัดการการดาวน์โหลดครั้งแรกเมื่อ Glassware ของคุณ เปิดจาก MyGlass หลังจากนั้นคุณสามารถทำซ้ำและแก้ไขข้อบกพร่องในเครื่อง ด้วยการเขียนทับ APK บนอุปกรณ์ของคุณ โปรดทราบว่า APK นี้ต้องเป็นไปตาม เกณฑ์ต่อไปนี้
    • ต้องอยู่ในรูป ZIP
    • คุณต้องไม่ทำการเปลี่ยนแปลงชื่อแพ็กเกจหรือลายเซ็นส่วนตัว หลังจากนั้น (โปรแกรมจัดการแพ็กเกจ Android ไม่อนุญาตให้อัปเกรด) หากมีการเปลี่ยนแปลงใดๆ เหล่านี้)
    • ต้องมีขนาดเล็กกว่า 50 เมกะไบต์
    • โดยจะต้องคอมไพล์โดยใช้ GDK เวอร์ชันล่าสุด

การใช้ขั้นตอนการตรวจสอบสิทธิ์

แผนภาพต่อไปนี้จะแสดงขั้นตอนการตรวจสอบสิทธิ์พื้นฐานสำหรับ เครื่องแก้ว GDK:

วิธีใช้ขั้นตอนการตรวจสอบสิทธิ์

  1. เมื่อผู้ใช้เปิด Glassware ใน MyGlass ระบบจะเปลี่ยนเส้นทางผู้ใช้ ลงใน URL การตรวจสอบสิทธิ์ คำขอเหล่านี้มีพารามิเตอร์การค้นหาที่ชื่อว่า userTokenที่คุณจำเป็นต้องใช้ภายหลัง

  2. ผู้ใช้ป้อนข้อมูลเข้าสู่ระบบในหน้าการตรวจสอบสิทธิ์

  3. เซิร์ฟเวอร์จะตรวจสอบข้อมูลเข้าสู่ระบบของผู้ใช้ หากข้อมูลเข้าสู่ระบบถูกต้อง เรียก API มิเรอร์ไปยังเมธอด mirror.accounts.insert วิธีนี้ คุณต้องระบุ https://www.googleapis.com/auth/glass.thirdpartyauth ขอบเขตเมื่อคุณสร้าง มิเรอร์ออบเจ็กต์บริการ ตัวอย่างการเรียก API นี้โดยใช้ข้อมูลดิบ HTTP หรือ Java จะแสดงในตัวอย่างการสร้างบัญชี

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

    ชื่อพร็อพเพอร์ตี้ ค่า คำอธิบาย
    features[] รายการสตริง รายการฟีเจอร์ (โปรดดู AccountManager.hasFeatures)
    password สตริง รหัสผ่านของบัญชี (โปรดดู AccountManager.getPassword) คำแนะนำจากเรา ซึ่งคุณไม่ได้จัดเก็บรหัสผ่านจริงของผู้ใช้ ฟิลด์นี้ แต่ใช้เพื่อเก็บข้อมูลส่วนตัวที่ใช้ได้นานแทน เช่น โทเค็นการรีเฟรช
    userData[] รายการออบเจ็กต์ ข้อมูลผู้ใช้อย่างน้อย 1 คู่ที่เชื่อมโยงกับบัญชี (โปรดดู AccountManager.getUserData)
    userData[].key สตริง คีย์ที่เชื่อมโยงกับคีย์-ค่าข้อมูลผู้ใช้ที่เฉพาะเจาะจง คู่กัน
    userData[].value สตริง ค่าที่เชื่อมโยงกับคีย์-ค่าข้อมูลผู้ใช้ที่เฉพาะเจาะจง คู่กัน
    authTokens[] รายการออบเจ็กต์ โทเค็นการตรวจสอบสิทธิ์อย่างน้อย 1 รายการที่เชื่อมโยงกับบัญชี (โปรดดู AccountManager.getAuthToken)
    authTokens[].type สตริง ประเภทของโทเค็นการตรวจสอบสิทธิ์
    authTokens[].authToken สตริง โทเค็นการตรวจสอบสิทธิ์

  4. เมื่อได้รับคำขอ mirror.account.insert แล้ว Mirror API จะพุช บัญชีไปยังอุปกรณ์ Glass ของผู้ใช้ ซึ่งคุณจะสามารถเข้าถึงได้ โดยใช้ชั้นเรียน AccountManager

ทำตามหลักเกณฑ์ต่อไปนี้เพื่อใช้ขั้นตอนการตรวจสอบสิทธิ์ที่ใช้งานง่าย

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

หากต้องการรักษาความสอดคล้องในการตรวจสอบสิทธิ์ Glassware ให้ใช้รายการใดรายการหนึ่งต่อไปนี้ ขั้นตอนการตรวจสอบสิทธิ์

มิเรอร์หรือแบบผสมโดยไม่มีบัญชี

  1. หลังจากสลับใน MyGlass แล้ว URL การตรวจสอบสิทธิ์ของคุณจะเปิดขึ้นในป๊อปอัป
  2. การดำเนินการนี้จะส่งผู้ใช้ไปยังขอบเขตเพื่อยอมรับโดยตรง
  3. หลังจากผู้ใช้ยอมรับหรือยกเลิกขอบเขตแล้ว ให้ปิดป๊อปอัป

มิเรอร์ด้วยบัญชี

  1. หลังจากสลับใน MyGlass แล้ว URL การตรวจสอบสิทธิ์ของคุณจะเปิดขึ้นในป๊อปอัป
    • หากผู้ใช้ลงชื่อเข้าใช้บริการของคุณอยู่แล้ว ให้ส่งผู้ใช้โดยตรง ขอบเขตได้ด้วย
    • หากผู้ใช้ไม่ได้ลงชื่อเข้าใช้ ให้แสดงช่องการลงชื่อเข้าใช้เพื่ออนุญาตให้ผู้ใช้ลงชื่อเข้าใช้ ไปยังบริการของคุณ แล้วจึงส่งไปยังขอบเขต
    • หากผู้ใช้ไม่มีบัญชี ให้ระบุลิงก์เพื่อสร้าง ของคุณได้ ผู้ใช้ต้องมีวิธีสร้างบัญชีเพื่อเป็นส่วนหนึ่งของ ขั้นตอนการติดตั้ง
  2. ผู้ใช้ยอมรับขอบเขต
    • หาก Glassware ของคุณมีการตั้งค่าที่สามารถกำหนดค่าได้ ให้ส่งผู้ใช้ไปยัง ที่มีการเลือกค่าเริ่มต้นที่สมเหตุสมผลไว้
    • หาก Glassware ไม่มีการตั้งค่าที่สามารถกำหนดค่าได้ ให้ส่งผู้ใช้ไปที่ หน้ายืนยัน ปิดป๊อปอัป ถ้าไม่มีการกำหนดค่าเพิ่มเติม ต้องระบุ

ใช้รูปแบบผสมกับบัญชี

  1. หลังจากสลับใน MyGlass แล้ว URL การตรวจสอบสิทธิ์ของคุณจะเปิดขึ้นในป๊อปอัป
    • หากผู้ใช้ลงชื่อเข้าใช้บริการของคุณอยู่แล้ว ให้ส่งผู้ใช้โดยตรง ขอบเขตได้ด้วย
    • หากผู้ใช้ไม่ได้ลงชื่อเข้าใช้ ให้แสดงช่องการลงชื่อเข้าใช้เพื่ออนุญาตให้ผู้ใช้ลงชื่อเข้าใช้ แล้วส่งไปยังขอบเขต
    • หากผู้ใช้ไม่มีบัญชี ให้ระบุลิงก์เพื่อสร้างบัญชี
  2. ผู้ใช้ยอมรับขอบเขต
  3. ส่งคำขอไปยัง Mirror API เพื่อแทรกบัญชี GDK
    • ส่งผู้ใช้ไปยังหน้าการตั้งค่าโดยเลือกค่าเริ่มต้นที่สมเหตุสมผล
    • ส่งหน้ายืนยันให้ผู้ใช้ ปิดป๊อปอัปหากไม่มีตัวเลือกเพิ่มเติม ต้องมีการกำหนดค่า

มิเรอร์หรือแบบผสมด้วยบัญชีและขอบเขตที่กำหนดเอง

  1. หลังจากสลับใน MyGlass แล้ว URL การตรวจสอบสิทธิ์ของคุณจะเปิดขึ้นในป๊อปอัป
    • หากผู้ใช้ลงชื่อเข้าใช้บริการของคุณแล้ว ให้ส่งผู้ใช้ไปยัง ขอบเขตภายใน
    • หากผู้ใช้ไม่ได้ลงชื่อเข้าใช้ ให้แสดงช่องการลงชื่อเข้าใช้เพื่ออนุญาตให้ผู้ใช้ลงชื่อเข้าใช้ แล้วส่งไปยังขอบเขตภายใน
    • หากผู้ใช้ไม่มีบัญชี ให้ระบุลิงก์เพื่อสร้างบัญชี
  2. เมื่อผู้ใช้ยอมรับขอบเขตที่กำหนดเอง ให้ส่งผู้ใช้ไปยังขอบเขตของ Google
  3. ส่งคำขอไปยัง Mirror API เพื่อแทรกบัญชี GDK
    • ส่งผู้ใช้ไปยังหน้าการตั้งค่าโดยเลือกค่าเริ่มต้นที่สมเหตุสมผล
    • ส่งหน้ายืนยันให้ผู้ใช้ ปิดป๊อปอัปหากไม่มีตัวเลือกเพิ่มเติม ต้องมีการกำหนดค่า

มิเรอร์หรือไฮบริดด้วยแอป Android/iPhone

  1. หลังจากสลับใน MyGlass แล้ว URL การตรวจสอบสิทธิ์ของคุณจะเปิดขึ้นในป๊อปอัป
  2. การดำเนินการนี้จะส่งผู้ใช้ไปยังขอบเขตเพื่อยอมรับโดยตรง
  3. หลังจากที่ผู้ใช้ยอมรับขอบเขตแล้ว ให้ทำดังนี้
    • หากผู้ใช้มีแอปที่ใช้ร่วมกันและได้รับการตรวจสอบสิทธิ์แล้ว ให้ปิดป๊อปอัป
    • แต่หากไม่เป็นเช่นนั้น ให้ส่งผู้ใช้ไปยังโฆษณาคั่นระหว่างหน้าที่นำผู้ใช้ไปยังหน้าดาวน์โหลด แอปจาก Google Play Store หรือ iOS Store
  4. หลังจากติดตั้งแอปและการตรวจสอบสิทธิ์แล้ว ให้ปิดหน้าต่างป๊อปอัป

GDK และไม่มีบัญชี

คุณจำเป็นต้องดำเนินการต่อไปนี้เพื่อเปิด Glassware ใน MyGlass

GDK กับบัญชี

  1. หลังจากสลับใน MyGlass แล้ว URL การตรวจสอบสิทธิ์ของคุณจะเปิดขึ้นในป๊อปอัป
    • หากผู้ใช้ลงชื่อเข้าใช้บริการของคุณแล้ว ให้ส่งผู้ใช้ไปยัง หน้าจอยืนยัน
    • หากผู้ใช้ไม่ได้ลงชื่อเข้าใช้ ให้แสดงช่องการลงชื่อเข้าใช้เพื่ออนุญาตให้ผู้ใช้ ลงชื่อเข้าใช้ แล้วส่งผู้ใช้ไปยังหน้าจอยืนยัน
    • หากผู้ใช้ไม่มีบัญชี ให้ระบุลิงก์เพื่อสร้างบัญชี
  2. ผู้ใช้ยอมรับขอบเขต
  3. ส่งคำขอไปยัง Mirror API เพื่อแทรกบัญชี GDK
  4. แสดงหน้าจอการยืนยัน และปิดหน้าจอหลังจากแสดงเป็นเวลา ระยะเวลาสั้นๆ

ตัวอย่างการสร้างบัญชี

ใช้ไลบรารีของไคลเอ็นต์ สำหรับ Mirror API เมื่อเป็นไปได้ การดำเนินการนี้จะทำให้โทรหา mirror.accounts.insert สร้างบัญชีได้ง่ายขึ้น

ตัวอย่าง HTTP ดิบ

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

วิธีการส่งคำขอและ URL:

POST https://www.googleapis.com/mirror/v1/accounts/{userToken}/com.example.myapp/username%40email.com

เนื้อหาคำขอ:

{
    "features": ["a", "b", "c"],
    "userData": [
        { "key": "realName", "value": "Rusty Shackleford" },
        { "key": "foo", "value": "bar" }
    ],
    "authTokens": [
        { "type": "your_token_type", "authToken": "zT419Ma3X2pBr0L..." }
    ]
}

แทนที่ {userToken} ใน URL ของคำขอด้วยโทเค็นที่ส่งไปยัง URL การตรวจสอบสิทธิ์ในขั้นตอนที่ 1 ของ การใช้ขั้นตอนการตรวจสอบสิทธิ์

ตัวอย่าง Java

ตัวอย่างนี้แสดงวิธีใช้ไลบรารีของไคลเอ็นต์ Java ในการเรียกใช้ mirror.accounts.insert

import com.google.api.client.googleapis.auth.oauth2.GoogleCredential;
import com.google.api.client.http.HttpTransport;
import com.google.api.client.http.javanet.NetHttpTransport;
import com.google.api.client.json.JsonFactory;
import com.google.api.client.json.jackson.JacksonFactory;
import com.google.api.services.mirror.Mirror;
import com.google.api.services.mirror.model.Account;
import com.google.api.services.mirror.model.AuthToken;
import com.google.common.collect.Lists;
...

/** Email of the Service Account */
private static final String SERVICE_ACCOUNT_EMAIL =
    "<some-id>@developer.gserviceaccount.com";

/** Path to the Service Account's Private Key file */
private static final String SERVICE_ACCOUNT_PKCS12_FILE_PATH =
    "/path/to/<public_key_fingerprint>-privatekey.p12";

/** The account type, usually based on your company or app's package. */
private static final String ACCOUNT_TYPE = "com.example.myapp";

/** The Mirror API scopes needed to access the API. */
private static final String MIRROR_ACCOUNT_SCOPES =
    "https://www.googleapis.com/auth/glass.thirdpartyauth";

/**
 * Build and returns a Mirror service object authorized with the service accounts.
 *
 * @return Mirror service object that is ready to make requests.
 */
public static Mirror getMirrorService() throws GeneralSecurityException,
    IOException, URISyntaxException {
  HttpTransport httpTransport = new NetHttpTransport();
  JacksonFactory jsonFactory = new JacksonFactory();
  GoogleCredential credential = new GoogleCredential.Builder()
      .setTransport(httpTransport)
      .setJsonFactory(jsonFactory)
      .setServiceAccountId(SERVICE_ACCOUNT_EMAIL)
      .setServiceAccountScopes(MIRROR_ACCOUNT_SCOPES)
      .setServiceAccountPrivateKeyFromP12File(
          new java.io.File(SERVICE_ACCOUNT_PKCS12_FILE_PATH))
      .build();
  Mirror service = new Mirror.Builder(httpTransport, jsonFactory, null)
      .setHttpRequestInitializer(credential).build();
  return service;
}

/**
 * Creates an account and causes it to be synced up with the user's Glass.
 * This example only supports one auth token; modify it if you need to add
 * more than one, or to add features, user data, or the password field.
 *
 * @param mirror the service returned by getMirrorService()
 * @param userToken the user token sent to your auth callback URL
 * @param accountName the account name for this particular user
 * @param authTokenType the type of the auth token (chosen by you)
 * @param authToken the auth token
 */
public static void createAccount(Mirror mirror, String userToken, String accountName,
    String authTokenType, String authToken) {
  try {
    Account account = new Account();
    List<AuthToken> authTokens = Lists.newArrayList(
        new AuthToken().setType(authTokenType).setAuthToken(authToken));
    account.setAuthTokens(authTokens);
    mirror.accounts().insert(
        userToken, ACCOUNT_TYPE, accountName, account).execute();
  } catch (IOException e) {
    e.printStackTrace();
  }
}

การเรียกข้อมูลบัญชีใน Glass

กำลังดึงข้อมูลและใช้ Account บน Glass คล้ายกับ การใช้ Android มาตรฐาน AccountManager

  1. ประกาศสิทธิ์ต่อไปนี้ในไฟล์ Manifest ในไฟล์ AndroidManifest.xml

    <uses-permission android:name="android.permission.GET_ACCOUNTS" />
<uses-permission android:name="android.permission.USE_CREDENTIALS" />

  2. เรียกข้อมูลบัญชีของ Glassware:

    AccountManager accountManager = AccountManager.get(mContext);
// Use your Glassware's account type.
Account[] accounts = accountManager.getAccountsByType("com.example");

// Pick an account from the list of returned accounts.

  3. เรียกโทเค็นการตรวจสอบสิทธิ์จาก Account:

    // Your auth token type.
final String AUTH_TOKEN_TYPE = "oauth2:https://www.example.com/auth/login";

accountManager.getAuthToken(account, AUTH_TOKEN_TYPE, null, activity, new AccountManagerCallback<Bundle>() {
    public void run(AccountManagerFuture<Bundle> future) {
        try {
            String token = future.getResult().getString(AccountManager.KEY_AUTHTOKEN);
            // Use the token.
        } catch (Exception e) {
            // Handle exception.
        }
    }
}, null);