การตรวจสอบสิทธิ์ในอุปกรณ์ที่สวมใส่ได้: เครื่องมือจัดการข้อมูลเข้าสู่ระบบ

จัดทุกอย่างให้เป็นระเบียบอยู่เสมอด้วยคอลเล็กชัน บันทึกและจัดหมวดหมู่เนื้อหาตามค่ากำหนดของคุณ

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

คู่มือนี้จะแสดงวิธีการสำหรับวิธีการตรวจสอบสิทธิ์ที่แนะนำสำหรับเครื่องมือจัดการข้อมูลเข้าสู่ระบบของแอป Wear OS

ดูข้อมูลเพิ่มเติมเกี่ยวกับวิธีออกแบบประสบการณ์การลงชื่อเข้าใช้ที่ดีได้ที่คู่มือ UX การลงชื่อเข้าใช้

สิ่งที่ควรพิจารณาเบื้องต้น

โปรดพิจารณาประเด็นต่อไปนี้ก่อนเริ่มการติดตั้งใช้งาน

โหมดผู้มาเยือน

ไม่ต้องมีการตรวจสอบสิทธิ์สำหรับฟังก์ชันการทำงานทั้งหมด แต่ให้มอบฟีเจอร์ให้ผู้ใช้มากที่สุดโดยไม่ต้องลงชื่อเข้าใช้

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

อุปกรณ์บางเครื่องอาจปลดล็อกค้างไว้นานขึ้น

ในอุปกรณ์ที่รองรับซึ่งใช้ Wear OS 5 ขึ้นไป ระบบจะตรวจจับว่าผู้ใช้กำลังสวมใส่อุปกรณ์ไว้ที่ข้อมือหรือไม่ หากผู้ใช้ปิดการตรวจจับข้อมือแล้วถอดอุปกรณ์ออกจากข้อมือ ระบบจะปลดล็อกอุปกรณ์ไว้นานกว่าปกติ

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

val wristDetectionEnabled =
        isWristDetectionAutoLockingEnabled(applicationContext)

หากผลลัพธ์ของเมธอดนี้คือ false ให้แจ้งให้ผู้ใช้ลงชื่อเข้าใช้บัญชีในแอปก่อนแสดงเนื้อหาเฉพาะผู้ใช้

Credential Manager

Credential Manager เป็น API ที่แนะนําสําหรับการตรวจสอบสิทธิ์ใน Wear OS ซึ่งจะสร้างสภาพแวดล้อมที่ปลอดภัยยิ่งขึ้นสำหรับผู้ใช้ในการลงชื่อเข้าใช้แอปพลิเคชัน Wear OS ในการตั้งค่าแบบสแตนด์อโลน โดยไม่จำเป็นต้องมีโทรศัพท์ที่เชื่อมต่อและไม่ต้องจำรหัสผ่าน

เอกสารนี้ระบุข้อมูลที่จําเป็นสําหรับนักพัฒนาแอปในการใช้โซลูชันเครื่องมือจัดการข้อมูลเข้าสู่ระบบกับกลไกการตรวจสอบสิทธิ์มาตรฐานที่โฮสต์ไว้ ซึ่งได้แก่

• พาสคีย์
• รหัสผ่าน
• ข้อมูลประจำตัวแบบรวมศูนย์ (เช่น ฟีเจอร์ลงชื่อเข้าใช้ด้วย Google)

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

พาสคีย์ใน Wear OS

เราขอแนะนำให้นักพัฒนาแอปใช้พาสคีย์ในการติดตั้งใช้งานเครื่องมือจัดการข้อมูลเข้าสู่ระบบของ Wear OS พาสคีย์เป็นมาตรฐานใหม่ของอุตสาหกรรมสำหรับการตรวจสอบสิทธิ์ผู้ใช้ปลายทาง และพาสคีย์มีประโยชน์ที่สำคัญหลายประการสำหรับผู้ใช้

พาสคีย์ใช้งานง่ายกว่า

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

พาสคีย์ปลอดภัยกว่า

• นักพัฒนาแอปจะบันทึกเฉพาะคีย์สาธารณะลงในเซิร์ฟเวอร์แทนที่จะบันทึกรหัสผ่าน ซึ่งหมายความว่าผู้ไม่ประสงค์ดีจะแฮ็กเซิร์ฟเวอร์ได้ยากขึ้นมาก และจะต้องดำเนินการล้างข้อมูลน้อยลงในกรณีที่มีการละเมิด
• พาสคีย์ให้การปกป้องที่ปลอดภัยจากฟิชชิง พาสคีย์จะทำงานได้บนเว็บไซต์และแอปที่ลงทะเบียนเท่านั้น ผู้ใช้จะไม่ถูกหลอกให้ตรวจสอบสิทธิ์ในเว็บไซต์ที่หลอกลวงเนื่องจากเบราว์เซอร์หรือระบบปฏิบัติการจะจัดการการยืนยัน
• พาสคีย์ช่วยลดความจำเป็นในการส่ง SMS ซึ่งทำให้การตรวจสอบสิทธิ์มีประสิทธิภาพมากขึ้น

ใช้พาสคีย์

รวมถึงการตั้งค่าและคำแนะนำสำหรับการติดตั้งใช้งานทุกประเภท

ตั้งค่า

1. ตั้งค่าระดับ API เป้าหมายเป็น 35 ในไฟล์ build.gradle ของโมดูลแอปพลิเคชัน

   android {
       defaultConfig {
           targetSdkVersion(35)
       }
   }
   

2. เพิ่มบรรทัดต่อไปนี้ลงในไฟล์ build.gradle สําหรับแอปหรือโมดูล โดยใช้เวอร์ชันล่าสุดที่เสถียรจากข้อมูลอ้างอิงandroidx.credentials releases

   androidx.credentials:credentials:1.5.0
   androidx.credentials:credentials-play-services-auth:1.5.0
   

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

เนื่องจากเครื่องมือจัดการข้อมูลเข้าสู่ระบบเป็น API แบบรวม ขั้นตอนการใช้งานสำหรับ Wear OS จึงเหมือนกับอุปกรณ์ประเภทอื่นๆ

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

ขั้นตอนในการเพิ่มการรองรับฟีเจอร์ลงชื่อเข้าใช้ด้วย Google ลงในเครื่องมือจัดการข้อมูลเข้าสู่ระบบมีไว้สำหรับการพัฒนาแอปบนอุปกรณ์เคลื่อนที่ แต่ขั้นตอนจะเหมือนกันใน Wear OS ดูส่วนการเปลี่ยนจากฟีเจอร์ลงชื่อเข้าใช้ด้วย Google แบบเดิมเพื่อดูข้อควรพิจารณาพิเศษสำหรับกรณีนี้

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

วิธีการตรวจสอบสิทธิ์สำรอง

วิธีการตรวจสอบสิทธิ์อื่นๆ ที่ยอมรับสำหรับแอป Wear OS มี 2 วิธี ได้แก่ OAuth 2.0 (ทั้ง 2 รูปแบบ) และการแชร์เลเยอร์ข้อมูลโทเค็นการตรวจสอบสิทธิ์บนอุปกรณ์เคลื่อนที่ แม้ว่าเมธอดเหล่านี้จะไม่มีจุดผสานรวมใน Credential Manager API แต่ก็สามารถรวมไว้ในขั้นตอนการนำส่งข้อมูลเข้าสู่ระบบของ Credential Manager เป็นทางเลือกในกรณีที่ผู้ใช้ปิดหน้าจอ Credential Manager

หากต้องการจัดการการดำเนินการของผู้ใช้ในการปิดหน้าจอเครื่องมือจัดการข้อมูลเข้าสู่ระบบ ให้จับ NoCredentialException เป็นส่วนหนึ่งของตรรกะ GetCredential แล้วไปยัง UI การตรวจสอบสิทธิ์ที่กําหนดเอง

yourCoroutineScope.launch {
    try {
      val response = credentialManager.getCredential(activity, request)
      signInWithCredential(response.credential)
    } catch (e: GetCredentialCancellationException) {
      navigateToFallbackAuthMethods()
    }
}

จากนั้น UI การตรวจสอบสิทธิ์ที่กําหนดเองจะระบุวิธีการตรวจสอบสิทธิ์อื่นๆ ที่ยอมรับได้ตามที่อธิบายไว้ในคู่มือ UX การลงชื่อเข้าใช้

การแชร์โทเค็นชั้นข้อมูล

แอปที่ใช้ร่วมกันของโทรศัพท์สามารถโอนข้อมูลการตรวจสอบสิทธิ์ไปยังแอป Wear OS อย่างปลอดภัยโดยใช้ Wearable Data Layer API โอนข้อมูลเข้าสู่ระบบเป็นข้อความหรือเป็นรายการข้อมูล

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

สำคัญ: แอป Wear OS ของคุณต้องมีวิธีการตรวจสอบสิทธิ์อื่นอย่างน้อย 1 วิธี เนื่องจากตัวเลือกนี้จะใช้ได้กับนาฬิกาที่จับคู่กับ Android เท่านั้นเมื่อมีการติดตั้งแอปบนอุปกรณ์เคลื่อนที่ที่เกี่ยวข้อง ระบุวิธีการตรวจสอบสิทธิ์อื่นสำหรับผู้ใช้ที่ไม่มีแอปบนอุปกรณ์เคลื่อนที่ที่เกี่ยวข้องหรืออุปกรณ์ Wear OS ที่จับคู่กับอุปกรณ์ iOS

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

val token = "..." // Auth token to transmit to the Wear OS device.
val dataClient: DataClient = Wearable.getDataClient(context)
val putDataReq: PutDataRequest = PutDataMapRequest.create("/auth").run {
    dataMap.putString("token", token)
    asPutDataRequest()
}
val putDataTask: Task<DataItem> = dataClient.putDataItem(putDataReq)

รอรับเหตุการณ์การเปลี่ยนแปลงข้อมูลในแอป Wear OS ดังที่แสดงในตัวอย่างต่อไปนี้

val dataClient: DataClient = Wearable.getDataClient(context)
dataClient.addListener{ dataEvents ->
    dataEvents.forEach { event ->
        if (event.type == DataEvent.TYPE_CHANGED) {
            val dataItemPath = event.dataItem.uri.path ?: ""
            if (dataItemPath.startsWith("/auth")) {
                val token = DataMapItem.fromDataItem(event.dataItem).dataMap.getString("token")
                // Display an interstitial screen to notify the user that
                // they're being signed in.
                // Then, store the token and use it in network requests.
            }
        }
    }
}

ดูข้อมูลเพิ่มเติมเกี่ยวกับการใช้เลเยอร์ข้อมูลอุปกรณ์ที่สวมใส่ได้ที่หัวข้อส่งและซิงค์ข้อมูลใน Wear OS

ใช้ OAuth 2.0

Wear OS รองรับขั้นตอนตาม OAuth 2.0 2 ขั้นตอนตามที่อธิบายไว้ในส่วนต่อไปนี้

• การให้สิทธิ์รหัสการให้สิทธิ์ด้วย Proof Key for Code Exchange (PKCE) ตามที่ระบุไว้ใน RFC 7636
• Device Authorization Grant (DAG) ตามที่ระบุไว้ใน RFC 8628

Proof Key for Code Exchange (PKCE)

หากต้องการใช้ PKCE อย่างมีประสิทธิภาพ ให้ใช้ RemoteAuthClient จากนั้นหากต้องการส่งคําขอการตรวจสอบสิทธิ์จากแอป Wear OS ไปยังผู้ให้บริการ OAuth ให้สร้างออบเจ็กต์ OAuthRequest ออบเจ็กต์นี้ประกอบด้วย URL ไปยังปลายทาง OAuth ของคุณสําหรับรับโทเค็นและออบเจ็กต์ CodeChallenge

โค้ดต่อไปนี้แสดงตัวอย่างการสร้างคําขอการให้สิทธิ์

val request = OAuthRequest.Builder(this.applicationContext)
    .setAuthProviderUrl(Uri.parse("https://...."))
    .setClientId(clientId)
    .setCodeChallenge(codeChallenge)
    .build()

หลังจากสร้างคําขอการให้สิทธิ์แล้ว ให้ส่งคําขอไปยังแอปที่ใช้ร่วมกันโดยใช้เมธอด sendAuthorizationRequest() ดังนี้

val client = RemoteAuthClient.create(this)
client.sendAuthorizationRequest(request,
    { command -> command?.run() },
    object : RemoteAuthClient.Callback() {
        override fun onAuthorizationResponse(
            request: OAuthRequest,
            response: OAuthResponse
        ) {
            // Extract the token from the response, store it, and use it in
            // network requests.
        }

        override fun onAuthorizationError(errorCode: Int) {
            // Handle any errors.
        }
    }
)

คำขอนี้จะทริกเกอร์การเรียกใช้แอปที่ใช้ร่วมกัน ซึ่งจะแสดง UI การให้สิทธิ์ในเว็บเบราว์เซอร์บนโทรศัพท์มือถือของผู้ใช้ ผู้ให้บริการ OAuth 2.0 จะตรวจสอบสิทธิ์ผู้ใช้และขอความยินยอมจากผู้ใช้สำหรับสิทธิ์ที่ขอ ระบบจะส่งการตอบกลับไปยัง URL เปลี่ยนเส้นทางที่สร้างขึ้นโดยอัตโนมัติ

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

คำตอบอยู่ในรูปแบบสตริงการค้นหาและมีลักษณะดังตัวอย่างต่อไปนี้

  https://wear.googleapis.com/3p_auth/com.your.package.name?code=xyz
  https://wear.googleapis-cn.com/3p_auth/com.your.package.name?code=xyz

ซึ่งจะโหลดหน้าที่นําผู้ใช้ไปยังแอปที่ใช้ร่วมกัน แอปที่ใช้ร่วมกันจะยืนยัน URL การตอบกลับและส่งต่อคำตอบไปยังแอป Wear OS โดยใช้ onAuthorizationResponse API

จากนั้นแอปในนาฬิกาจะเปลี่ยนรหัสการให้สิทธิ์เป็นโทเค็นการเข้าถึงได้

การมอบสิทธิ์ให้อุปกรณ์

เมื่อใช้การให้สิทธิ์การอนุญาตอุปกรณ์ ผู้ใช้จะเปิด URI การยืนยันในอุปกรณ์เครื่องอื่น จากนั้นเซิร์ฟเวอร์การให้สิทธิ์จะขอให้ผู้ใช้อนุมัติหรือปฏิเสธคำขอ

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

// Request access from the authorization server and receive Device Authorization
// Response.
val verificationUri = "..." // Extracted from the Device Authorization Response.
RemoteActivityHelper.startRemoteActivity(
    this,
    Intent(Intent.ACTION_VIEW)
        .addCategory(Intent.CATEGORY_BROWSABLE)
        .setData(Uri.parse(verificationUri)),
    null
)
// Poll the authorization server to find out if the user completed the user
// authorization step on their mobile device.

หากมีแอป iOS ให้ใช้ Universal Link เพื่อขัดจังหวะความตั้งใจนี้ในแอปแทนที่จะใช้เบราว์เซอร์ให้สิทธิ์โทเค็น

เลิกใช้งานฟีเจอร์ลงชื่อเข้าใช้ด้วย Google แบบเดิม

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

// Define a basic SDK check.
fun isCredentialManagerAvailable(): Boolean {
 return android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.VANILLA_ICE_CREAM
}

// Elsewhere in the code, use it to selectively disable the legacy option.
Button(
  onClick = {
    if (isCredentialManagerAvailable()) {
      Log.w(TAG, "Devices on API level 35 or higher should use
                  Credential Manager for Sign in with Google")
    } else {
      navigateToSignInWithGoogle()
    }},
  enabled = !isCredentialManagerAvailable(),
  label = { Text(text = stringResource(R.string.sign_in_with_google)) },
  secondaryLabel = { Text(text = "Disabled on API level 35+")
  }
)