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

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

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

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

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

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

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

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

ในอุปกรณ์ที่รองรับซึ่งใช้ 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 ขั้นตอนตามที่อธิบายไว้ในส่วน ที่เป็นไปตาม:

  • การให้สิทธิ์รหัสการให้สิทธิ์พร้อมคีย์หลักฐานสำหรับการแลกเปลี่ยนโค้ด (PKCE) ตามที่กำหนดไว้ใน RFC 7636
  • การให้สิทธิ์อุปกรณ์ตามที่ระบุไว้ใน RFC 8628

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

คีย์พิสูจน์สำหรับการแลกเปลี่ยนโค้ด (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 Sign-In ช่วยให้ผู้ใช้ลงชื่อเข้าใช้ด้วยบัญชี 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 Sign-In

  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 ได้จาก Horologist ตัวอย่างการลงชื่อเข้าใช้ Google ใน GitHub

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

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

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

ขั้นตอนการตรวจสอบสิทธิ์สำหรับการตั้งค่านี้ทำงานดังต่อไปนี้

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

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

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

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