การตรวจสอบสิทธิ์ในอุปกรณ์ที่สวมใส่ได้

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

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

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

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

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

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

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

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

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

val wristDetectionEnabled =
        isWristDetectionAutoLockingEnabled(applicationContext)

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

วิธีการตรวจสอบสิทธิ์ที่แนะนำ

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

ส่งโทเค็นโดยใช้ชั้นข้อมูล

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

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

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

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

val token = "..." // Auth token to transmit to the wearable 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)

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

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 interstitial screen to notify the user they are 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 ตามที่ระบุไว้ใน RFC 8628

หมายเหตุ: เปิดใช้ "เปิดอยู่เสมอ" โดยใช้ AmbientModeSupport.attach ในกิจกรรมที่ดำเนินการตรวจสอบสิทธิ์ เพื่อช่วยไม่ให้แอปปิดเมื่อนาฬิกาเข้าสู่โหมดแอมเบียนท์ ดูข้อมูลเพิ่มเติมเกี่ยวกับแนวทางปฏิบัติแนะนำในโหมดแอมเบียนท์ได้ที่ทำให้แอปแสดงใน Wear อยู่เสมอ

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 error
        }
    }
)

คำขอนี้จะทริกเกอร์การเรียกใช้แอปที่ใช้ร่วมกัน ซึ่งจะแสดง 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 การตอบกลับและส่งต่อคําตอบไปยังแอปนาฬิกาของบุคคลที่สามโดยใช้ onAuthorizationResponse API

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

หมายเหตุ: เมื่อสร้าง OAuthRequest แล้ว คุณจะดู URL เปลี่ยนเส้นทางได้โดยไปที่ redirectUrl

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

เมื่อใช้การให้สิทธิ์การอนุญาตอุปกรณ์ ผู้ใช้จะเปิด 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 เพื่อขัดจังหวะความตั้งใจนี้ในแอปแทนที่จะใช้เบราว์เซอร์ให้สิทธิ์โทเค็น

วิธีการตรวจสอบสิทธิ์อื่นๆ

Wear OS รองรับวิธีการลงชื่อเข้าใช้เพิ่มเติมตามที่อธิบายไว้ในส่วนต่อไปนี้

Google Sign-In

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

หลังจากวิธีการตรวจสอบสิทธิ์ที่แนะนำซึ่งอธิบายไว้ก่อนหน้านี้ Google Sign-In เป็นวิธีถัดไปที่แนะนำเนื่องจากใช้งานได้ดีใน iOS ด้วย ส่วนต่อไปนี้จะอธิบายวิธีผสานรวม Google Sign-In ขั้นพื้นฐาน

สิ่งที่ต้องมีก่อน

คุณต้องกำหนดค่าโปรเจ็กต์คอนโซล Google API และตั้งค่าโปรเจ็กต์ Android Studio ก่อนจึงจะเริ่มผสานรวม Google Sign-In ในแอป Wear OS ได้ ดูข้อมูลเพิ่มเติมได้ที่ เริ่มผสานรวม Google Sign-In เข้ากับแอป Android

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

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

ผสานรวม Google Sign-In เข้ากับแอป

ตรวจสอบและทําตามขั้นตอนต่อไปนี้ ซึ่งจะอธิบายอย่างละเอียดในส่วนถัดไป เพื่อผสานรวม Google Sign-In เข้ากับแอป Wear OS

  1. กําหนดค่า Google Sign-In
  2. เพิ่มปุ่มลงชื่อเข้าใช้ด้วย Google
  3. เริ่มขั้นตอนการลงชื่อเข้าใช้เมื่อมีการแตะปุ่มลงชื่อเข้าใช้

กำหนดค่า Google Sign-In และสร้างออบเจ็กต์ GoogleApiClient

ในเมธอด onCreate() ของกิจกรรมการลงชื่อเข้าใช้ ให้กําหนดค่า Google Sign-In เพื่อขอข้อมูลผู้ใช้ที่จําเป็นสําหรับแอป จากนั้นสร้างออบเจ็กต์ GoogleApiClient ที่มีสิทธิ์เข้าถึง Google Sign-In API และตัวเลือกที่คุณระบุ ขั้นตอนเหล่านี้แสดงอยู่ในตัวอย่างต่อไปนี้ 

public class MyNewActivity extends AppCompatActivity {

    private static final int RC_SIGN_IN = 9001;

    private GoogleSignInClient mSignInClient;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        GoogleSignInOptions options =
                new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
                        .build();

        mSignInClient = GoogleSignIn.getClient(this, options);
    }
}

เพิ่มปุ่มลงชื่อเข้าใช้ด้วย Google ลงในแอป

ทําตามขั้นตอนต่อไปนี้เพื่อเพิ่มปุ่มลงชื่อเข้าใช้ด้วย Google

  1. เพิ่ม SignInButton ลงในเลย์เอาต์ของแอป 
    2.  <com.google.android.gms.common.SignInButton
 android:id="@+id/sign_in_button"
 android:layout_width="wrap_content"
 android:layout_height="wrap_content" />
  2. ในเมธอด onCreate() ของแอป ให้ลงทะเบียน OnClickListener ของปุ่มเพื่อลงชื่อเข้าใช้ผู้ใช้เมื่อมีการแตะ ดังนี้

    3. Kotlin

    findViewById<View>(R.id.sign_in_button).setOnClickListener(this)

    Java

    findViewById(R.id.sign_in_button).setOnClickListener(this);

สร้าง Intent การลงชื่อเข้าใช้และเริ่มขั้นตอนการลงชื่อเข้าใช้

จัดการการแตะปุ่มลงชื่อเข้าใช้ในonCLick()วิธีของคุณโดยสร้าง Intent การลงชื่อเข้าใช้ด้วยวิธี getSignInIntent() จากนั้นเริ่มความตั้งใจด้วยเมธอด startActivityForResult() 

Intent intent = mSignInClient.getSignInIntent();
startActivityForResult(intent, RC_SIGN_IN);

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

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

Kotlin

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent) {
    super.onActivityResult(requestCode, resultCode, data)

    // Result returned from launching the Intent from GoogleSignInApi.getSignInIntent(...).
    if (requestCode == RC_SIGN_IN) {
        Auth.GoogleSignInApi.getSignInResultFromIntent(data)?.apply {
            if (isSuccess) {
                // Get account information.
                fullName = signInAccount?.displayName
                mGivenName = signInAccount?.givenName
                mFamilyName = signInAccount?.familyName
                mEmail = signInAccount?.email
            }
        }
    }
}

Java

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);

    // Result returned from launching the Intent from GoogleSignInApi.getSignInIntent(...).
    if (requestCode == RC_SIGN_IN) {
        GoogleSignInResult signInResult = Auth.GoogleSignInApi.getSignInResultFromIntent(data);
        if (signInResult.isSuccess()) {
            GoogleSignInAccount acct = signInResult.getSignInAccount();

            // Get account information.
            fullName = acct.getDisplayName();
            givenName = acct.getGivenName();
            familyName = acct.getFamilyName();
            email = acct.getEmail();
        }
    }
}

หากต้องการดูตัวอย่างแอปที่ใช้ Google Sign-In โปรดดู ตัวอย่าง Google Sign-In ของ Horologist ใน GitHub

การตรวจสอบสิทธิ์ด้วยโค้ดที่กำหนดเอง

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

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

ขั้นตอนการให้สิทธิ์สําหรับการตั้งค่านี้จะทํางานดังนี้

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

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

หมายเหตุ: รหัสที่ผู้ใช้สร้างขึ้นต้องเป็นตัวเลขล้วนและต้องไม่มีอักขระที่เป็นตัวอักษร

ขั้นตอนการตรวจสอบสิทธิ์นี้แสดงในแผนภูมิต่อไปนี้