ใช้ข้อมูลเข้าสู่ระบบการกู้คืนด้วยเครื่องมือจัดการข้อมูลเข้าสู่ระบบ

หน้านี้อธิบายวิธีสร้าง ลงชื่อเข้าใช้ และลบคีย์การกู้คืน

ความเข้ากันได้ของเวอร์ชัน

Credential Manager's การกู้คืนข้อมูลเข้าสู่ระบบใช้งานได้ในอุปกรณ์ที่ใช้ Android 9 (ระดับ API 28) ขึ้นไป, บริการ Google Play (GMS) Core เวอร์ชัน 242200000 (v24.22) ขึ้นไป และไลบรารี androidx.credentials เวอร์ชัน 1.5.0 ขึ้นไป ในอุปกรณ์ที่ไม่มีบริการ Google Play หรือมี GMS เวอร์ชันเก่า ให้ตรวจจับ CreateCredentialProviderConfigurationException และ GetCredentialProviderConfigurationException เพื่อให้แอปของคุณเปลี่ยนกลับไปใช้การลงชื่อเข้าใช้มาตรฐานได้อย่างราบรื่น

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

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

ความสัมพันธ์

เพิ่มทรัพยากร Dependency ต่อไปนี้ลงในไฟล์ build.gradle ของโมดูลแอป

Kotlin

dependencies {
    implementation("androidx.credentials:credentials:1.7.0-alpha02")
    implementation("androidx.credentials:credentials-play-services-auth:1.7.0-alpha02")
}

Groovy

dependencies {
    implementation "androidx.credentials:credentials:1.7.0-alpha02"
    implementation "androidx.credentials:credentials-play-services-auth:1.7.0-alpha02"
}

Restore Credentials พร้อมใช้งานในไลบรารี androidx.credentials เวอร์ชัน 1.5.0 ขึ้นไป อย่างไรก็ตาม เราขอแนะนำให้ใช้ทรัพยากร Dependency เวอร์ชันเสถียรล่าสุดหากเป็นไปได้

android:allowBackup ส่งผลต่อการกู้คืนข้อมูลเข้าสู่ระบบอย่างไร

แอตทริบิวต์ไฟล์ Manifest android:allowBackup จะควบคุมการสำรองข้อมูลแอป ซึ่งโต้ตอบกับ Restore Credentials ได้ 3 วิธี ดังนี้

  • กู้คืนการโอนคีย์ (ไม่ขึ้นอยู่กับ allowBackup): บริการ Google Play จะโอนคู่คีย์ RestoreCredential โดยใช้การสำรองข้อมูลในระบบคลาวด์ที่เข้ารหัสจากต้นทางถึงปลายทางหรือการโอนจากอุปกรณ์หนึ่งไปยังอีกอุปกรณ์หนึ่ง (D2D) ในเครื่อง ไม่ว่า android:allowBackup จะเป็น true หรือ false ก็ตาม สำหรับการโอนแบบ D2D ระบบจะโอนคีย์การกู้คืนเสมอ โดยเงื่อนไขเดียวที่จะไม่มีการโอนคีย์คือในระหว่างการสำรองข้อมูลในระบบคลาวด์เมื่อผู้ใช้เลือกไม่ใช้การสำรองข้อมูลในระบบคลาวด์ในการตั้งค่า Android
  • การกู้คืนในเบื้องหลังใน BackupAgent (ต้องใช้ android:allowBackup="true"): การลงชื่อเข้าใช้ในเบื้องหลังแบบไม่แสดงข้อความแจ้งก่อนที่ผู้ใช้จะเปิดแอปในอุปกรณ์ใหม่ (BackupAgent.onRestoreFinished()) จะทำงานเมื่อมีการกำหนดค่า android:allowBackup="true" และ android:backupAgent ในไฟล์ Manifest เท่านั้น หากandroid:allowBackup="false" ให้กู้คืนเซสชันเมื่อผู้ใช้เปิดActivityหลักของคุณเป็นครั้งแรก นอกจากนี้ คุณยังใช้ทั้ง 2 วิธีเพื่อทำให้การกู้คืนมีประสิทธิภาพมากขึ้นได้ด้วย
  • การทดสอบการสำรองข้อมูลในระบบคลาวด์ของ Android Studio (ต้องใช้ android:allowBackup="true"): การทดสอบประเภทการสำรองข้อมูลในระบบคลาวด์ในเครื่องมือสำรองและกู้คืนข้อมูลของ Android Studio ต้องใช้ android:allowBackup="true" ส่วนการทดสอบแบบอุปกรณ์ต่ออุปกรณ์จะทำงานได้โดยไม่ต้องใช้ allowBackup

ภาพรวม

Restore Credentials มีวงจร 3 ระยะในอุปกรณ์เครื่องเก่าและเครื่องใหม่ของผู้ใช้ ดังนี้

  1. สร้างคีย์การกู้คืนในอุปกรณ์เครื่องก่อนหน้า: หลังจากผู้ใช้ลงชื่อเข้าใช้ (หรือเมื่อแอปเริ่มต้นทำงานหากผู้ใช้ลงชื่อเข้าใช้อยู่แล้วและไม่มีการบันทึกคีย์การกู้คืนในพื้นที่เก็บข้อมูลในเครื่อง) ให้ดึงข้อมูลตัวเลือกการสร้างจากเซิร์ฟเวอร์ของฝ่ายที่เกี่ยวข้องและเรียกใช้ credentialManager.createCredential()
  2. ลงชื่อเข้าใช้ด้วยคีย์การกู้คืนในอุปกรณ์เครื่องใหม่: ดึงข้อมูล RestoreCredential ที่โอนมาโดยใช้กลยุทธ์ 2 ระดับ ได้แก่ ระดับแรกแบบไม่มีการแจ้งเตือนใน BackupAgent.onRestoreFinished() (เมื่อ android:allowBackup="true") เพื่อให้การซิงค์ในเบื้องหลังและข้อความ Push กลับมาทำงานทันที และระดับที่ 2 เป็นทางเลือกสำรองใน Launcher Activity.onCreate() เมื่อเปิดแอปครั้งแรก
  3. ลบคีย์การกู้คืนเมื่อออกจากระบบ: เมื่อผู้ใช้ออกจากระบบหรือเซสชันของผู้ใช้ถูกเซิร์ฟเวอร์ทำให้ใช้งานไม่ได้ ให้เรียกใช้ credentialManager.clearCredentialState() ด้วย ClearCredentialStateRequest(ClearCredentialStateRequest.TYPE_CLEAR_RESTORE_CREDENTIAL) และล้างแฟล็กการซิงค์ในเครื่อง

สร้างคีย์การกู้คืน

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

  • หากผู้ใช้ลงชื่อเข้าใช้และยังไม่ได้สร้างคีย์การกู้คืน (เช่น ในเมธอด onCreate() สำหรับ Activity หลัก)
  • เมื่อผู้ใช้ลงชื่อเข้าใช้หรือทำตามขั้นตอนการลงทะเบียนบัญชีใหม่จนเสร็จสมบูรณ์

เพื่อหลีกเลี่ยงการเรียกใช้ createCredential() ทุกครั้งที่เปิดแอป ให้จัดเก็บแฟล็กการซิงค์ในเครื่อง เช่น has_synced_restore_credential ไว้ในพื้นที่เก็บข้อมูลในเครื่อง อย่าจัดเก็บแฟล็กนี้ใน SharedPreferences หรือ DataStore ที่สำรองข้อมูลไว้โดยค่าเริ่มต้น เว้นแต่ไฟล์นั้นจะได้รับการยกเว้นใน data_extraction_rules.xml มิฉะนั้นการสำรองข้อมูลอัตโนมัติจะคัดลอก has_synced_restore_credential = true ไปยังอุปกรณ์ใหม่และป้องกันไม่ให้อุปกรณ์ใหม่สร้างหรือหมุนเวียนคีย์การกู้คืนของตนเอง

สร้างอินสแตนซ์ Credential Manager

ใช้บริบทกิจกรรมของแอปเพื่อสร้างอินสแตนซ์ออบเจ็กต์ CredentialManager

// Use your app or activity context to instantiate a client instance of
// CredentialManager.
private val credentialManager = CredentialManager.create(context)

รับตัวเลือกการสร้างข้อมูลเข้าสู่ระบบจากเซิร์ฟเวอร์แอป

ใช้ไลบรารีที่สอดคล้องกับ FIDO ในเซิร์ฟเวอร์แอปเพื่อส่ง JSON PublicKeyCredentialCreationOptions ที่จำเป็นสำหรับการสร้างข้อมูลเข้าสู่ระบบสำหรับการกู้คืนไปยังแอปไคลเอ็นต์ ดูข้อมูลเพิ่มเติมเกี่ยวกับการใช้งานฝั่งเซิร์ฟเวอร์ได้ที่คำแนะนำฝั่งเซิร์ฟเวอร์

JSON ของตัวเลือกการสร้างจะเป็นไปตามโครงสร้างเดียวกับการลงทะเบียนพาสคีย์ ดังนี้

{
  "challenge": "<base64url-encoded challenge>",
  "rp": {
    "name": "<relying party name>",
    "id": "<relying party host name>"
  },
  "user": {
    "id": "<base64url-encoded user ID>",
    "name": "<user name>",
    "displayName": "<user display name>"
  },
  "pubKeyCredParams": [
    {
      "type": "public-key",
      "alg": -7
    }
  ],
  "attestation": "none",
  "excludeCredentials": [
    {
        "id": "<base64url-encoded credential ID to exclude>", 
        "type": "public-key"
    }
  ],
  "authenticatorSelection": {
    "requireResidentKey": true,
    "residentKey": "required",
    "userVerification": "required"
  }
}

ตรวจสอบว่า JSON ของตัวเลือกการสร้างเป็นไปตามข้อกำหนดต่อไปนี้

  • challenge และ user.id: เข้ารหัสทั้ง 2 ค่าเป็นสตริง Base64URL ที่ไม่มีการเติม (แทนที่ + ด้วย -, / ด้วย _ และตัด = ต่อท้ายออก) อักขระ Base64 มาตรฐานหรือรหัสจำนวนเต็มดิบจะทำให้เกิด CreateRestoreCredentialDomException หรือ IllegalArgumentException
  • rp.id: ตั้งค่าเป็นโดเมนของฝ่ายที่เชื่อถือ (เช่น example.com)
  • pubKeyCredParams: รวม {"type": "public-key", "alg": -7} (ES256) และ {"type": "public-key", "alg": -257} (RS256)

สร้างคีย์การกู้คืน

หลังจากได้รับ JSON ของตัวเลือกการสร้างคีย์สาธารณะจากเซิร์ฟเวอร์แล้ว ให้รวม JSON ไว้ในออบเจ็กต์ CreateRestoreCredentialRequest แล้วเรียกใช้ createCredential() ในออบเจ็กต์ CredentialManager

// createRestoreRequest contains the details sent by the server 
val response = credentialManager.createCredential(context, createRestoreRequest)

ประเด็นสำคัญเกี่ยวกับโค้ด

  • ออบเจ็กต์ CreateRestoreCredentialRequest มีช่องต่อไปนี้

    • requestJson: ตัวเลือกการสร้างข้อมูลเข้าสู่ระบบที่เซิร์ฟเวอร์แอปส่งในรูปแบบ Web Authentication API สำหรับ PublicKeyCredentialCreationOptionsJSON

    • isCloudBackupEnabled: ช่อง Boolean เพื่อระบุว่าควรสำรองข้อมูลคีย์การกู้คืนไปยังระบบคลาวด์หรือไม่ โดยค่าเริ่มต้น แฟล็กนี้จะเป็น true ช่องนี้มีค่าต่อไปนี้

      • true: (แนะนำ) ค่านี้จะเปิดใช้การสำรองข้อมูลคีย์การกู้คืนไปยังระบบคลาวด์หากผู้ใช้เปิดใช้ Google Backup และการเข้ารหัสจากต้นทางถึงปลายทาง เช่น การล็อกหน้าจอ
      • false: ค่านี้จะบันทึกคีย์ไว้ในเครื่อง ไม่ใช่ในระบบคลาวด์ คีย์จะไม่พร้อมใช้งานในอุปกรณ์ใหม่หากผู้ใช้เลือกที่จะกู้คืนจากระบบคลาวด์ แต่จะยังคงโอนระหว่างการตั้งค่าแบบอุปกรณ์ต่ออุปกรณ์ (D2D) ผ่านสายหรือ Wi-Fi ในเครื่อง

จัดการการตอบกลับการสร้างข้อมูลเข้าสู่ระบบ

Credential Manager API จะแสดงผลการตอบกลับประเภท CreateRestoreCredentialResponse การตอบกลับนี้จะเก็บการตอบกลับการลงทะเบียนข้อมูลเข้าสู่ระบบคีย์สาธารณะในรูปแบบ JSON

ส่ง response.registrationResponseJson จากแอปไปยังเซิร์ฟเวอร์ของฝ่ายที่อาศัยเพื่อยืนยันและจัดเก็บคีย์สาธารณะไว้ข้างบัญชีของผู้ใช้ จากนั้นบันทึกเครื่องหมายการซิงค์ในเครื่องไว้ในพื้นที่เก็บข้อมูลในเครื่อง ดูข้อมูลเพิ่มเติมเกี่ยวกับการยืนยันฝั่งเซิร์ฟเวอร์ได้ที่คำแนะนำสำหรับพาสคีย์

ในระหว่างกระบวนการสร้างคีย์การกู้คืน ให้จัดการข้อยกเว้นต่อไปนี้

  • CreateRestoreCredentialDomException: ข้อยกเว้นนี้จะเกิดขึ้นหาก requestJson ไม่ถูกต้องและไม่เป็นไปตามรูปแบบ WebAuthn สำหรับ PublicKeyCredentialCreationOptionsJSON
  • E2eeUnavailableException: ข้อยกเว้นนี้จะเกิดขึ้นหาก isCloudBackupEnabled เป็น true แต่อุปกรณ์ของผู้ใช้ไม่มีการสำรองข้อมูลหรือการเข้ารหัสจากต้นทางถึงปลายทาง เช่น การล็อกหน้าจอ
    เพื่อให้มั่นใจว่าระบบจะสร้างข้อมูลเข้าสู่ระบบสำหรับการกู้คืนสำหรับการโอนจากอุปกรณ์หนึ่งไปยังอีกอุปกรณ์หนึ่ง (D2D) ในเครื่อง แม้ว่า E2EE ในระบบคลาวด์จะไม่พร้อมใช้งาน ให้ตรวจจับ E2eeUnavailableException และลองอีกครั้งทันที createCredential() ด้วย CreateRestoreCredentialRequest(requestJson, isCloudBackupEnabled = false)
  • IllegalArgumentException: ข้อยกเว้นนี้จะเกิดขึ้นหาก requestJson ว่างเปล่า ไม่ใช่ JSON ที่ถูกต้อง หรือไม่มี user.id ที่เข้ารหัส Base64URL ที่ถูกต้องซึ่งเป็นไปตามข้อกำหนดของ WebAuthn

ลงชื่อเข้าใช้ด้วยคีย์การกู้คืน

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

รับตัวเลือกการดึงข้อมูลเข้าสู่ระบบจากเซิร์ฟเวอร์แอป

ก่อนเรียกใช้ getCredential() ในอุปกรณ์ใหม่ ให้ขอคำถาม WebAuthn PublicKeyCredentialRequestOptions JSON จากเซิร์ฟเวอร์แอป เนื่องจากแอปในอุปกรณ์ใหม่ยังไม่ทราบว่าผู้ใช้รายใดกำลังลงชื่อเข้าใช้ ปลายทางนี้จึงต้องไม่ได้รับการตรวจสอบสิทธิ์ (การค้นพบแบบไม่มีผู้ใช้) ดูคำแนะนำเกี่ยวกับเซิร์ฟเวอร์ที่เกี่ยวข้องได้ที่ลงชื่อเข้าใช้ด้วยพาสคีย์และคู่มือการตรวจสอบสิทธิ์ฝั่งเซิร์ฟเวอร์

JSON ของตัวเลือกการดึงข้อมูลมีโครงสร้างดังนี้

{
  "challenge": "<your app challenge>",
  "allowCredentials": [],
  "rpId": "<your app server domain>"
}

กำหนดค่า JSON ของตัวเลือกการดึงข้อมูลในเซิร์ฟเวอร์ดังนี้

  • allowCredentials: ละเว้นช่องนี้หรือส่งอาร์เรย์ว่าง ([]) เนื่องจากไม่ทราบบัญชีของผู้ใช้ก่อนการกู้คืน หลังจาก getCredential() แสดงผล เซิร์ฟเวอร์จะระบุผู้ใช้จากช่อง response.userHandle (ซึ่งตรงกับ user.id ที่ลงทะเบียนไว้ระหว่างการสร้าง) และค้นหาคีย์สาธารณะตาม id (credentialId)
  • userVerification: ตั้งค่าเป็น "discouraged" (หรือ "preferred") เนื่องจาก Restore Credentials ทำงานโดยไม่มี UI ไบโอเมตริกหรือการล็อกหน้าจอ Android จึงลบล้าง "required" เป็น "discouraged" และข้อมูล Authenticator ที่ส่งกลับไปยังเซิร์ฟเวอร์ของคุณจะมีการตั้งค่าแฟล็ก User Verified (uv) เป็น false กำหนดค่าเครื่องมือตรวจสอบเซิร์ฟเวอร์ WebAuthn ให้ยอมรับ uv = false สำหรับการยืนยันคีย์การกู้คืน

รับคีย์การกู้คืน

หากต้องการรับคีย์การกู้คืนในอุปกรณ์ใหม่ ให้รวม requestJson ของเซิร์ฟเวอร์ไว้ใน GetRestoreCredentialOption ภายใน GetCredentialRequest แล้วเรียกใช้ getCredential() ในออบเจ็กต์ CredentialManager

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

  • ระดับ 1 (การกู้คืนในเบื้องหลังใน BackupAgent.onRestoreFinished()): หากเปิดใช้การสำรองข้อมูลแอป (android:allowBackup="true") ให้สร้างคลาสย่อย BackupAgent และลบล้าง onRestoreFinished() (อย่าใช้ onRestore() ซึ่งจะเรียกใช้สำหรับการสำรองข้อมูลคีย์-ค่าเดิมเท่านั้น) เนื่องจาก onRestoreFinished() เป็นแบบซิงโครนัสและ getCredential() เป็นฟังก์ชัน suspend ของ Kotlin ให้เชื่อมต่อการเรียกใช้โดยใช้ runBlocking(Dispatchers.IO) ตรวจจับ NoCredentialException อย่างเงียบๆ เมื่อไม่มีคีย์การกู้คืน
  • ระดับที่ 2 (การสำรองข้อมูลในเบื้องหน้าใน Launcher Activity.onCreate()): เมื่อเปิดแอปครั้งแรกเมื่อไม่มีเซสชันในเครื่อง ให้เรียกใช้ getCredential() จาก lifecycleScope ก่อนแสดงหน้าจอเข้าสู่ระบบ ซึ่งจะจัดการแอปที่มี android:allowBackup="false" และกู้คืนหากอุปกรณ์ออฟไลน์เมื่อ onRestoreFinished() ทำงาน

หากคุณเพิ่ม BackupAgent ใหม่ลงในแอปที่ใช้การสำรองข้อมูลอัตโนมัติกับ android:allowBackup="true" อยู่แล้ว ให้ตั้งค่า android:fullBackupOnly="true" ในองค์ประกอบ <application> ใน AndroidManifest.xml ด้วย เพื่อให้ Android ใช้การสำรองข้อมูลอัตโนมัติต่อไปแทนที่จะเปลี่ยนไปใช้การสำรองข้อมูลคีย์-ค่าแบบเดิม

// Fetch the options required to get the restore key
val authenticationJson = fetchAuthenticationJson()

// Create the GetRestoreCredentialRequest object
val options = GetRestoreCredentialOption(authenticationJson)
val getRequest = GetCredentialRequest(listOf(options))

val response = credentialManager.getCredential(context, getRequest)

// Type-check and extract the restore credential
val credential = response.credential as RestoreCredential

Credential Manager API จะแสดงผล GetCredentialResponse ซึ่งพร็อพเพอร์ตี้ credential เป็น RestoreCredential (ไม่ใช่ PublicKeyCredential) ที่มี authenticationResponseJson

จัดการการตอบกลับการลงชื่อเข้าใช้

ส่ง restoreCredential.authenticationResponseJson จากแอปไปยังเซิร์ฟเวอร์ของบุคคลที่เชื่อถือเพื่อยืนยันการยืนยันการเข้ารหัสและออกโทเค็นของเซสชันใหม่ให้แก่ผู้ใช้ ดูรายละเอียดการยืนยันฝั่งเซิร์ฟเวอร์ได้ที่หัวข้อลงชื่อเข้าใช้ด้วยพาสคีย์

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

  • แยกความแตกต่างระหว่างคีย์การกู้คืนกับพาสคีย์ของผู้ใช้: ติดแท็กคีย์การกู้คืนในฐานข้อมูลเพื่อให้คีย์เหล่านั้นซ่อนจากหน้าจอการจัดการพาสคีย์ที่แสดงต่อผู้ใช้ และได้รับการยกเว้นจากการตรวจสอบการยืนยันผู้ใช้ (uv = true)
  • รองรับอุปกรณ์ที่ใช้งานอยู่หลายเครื่องต่อผู้ใช้ 1 คน: ผู้ใช้สามารถมีอุปกรณ์หลายเครื่อง (เช่น โทรศัพท์และแท็บเล็ต) อนุญาตให้มีคีย์การกู้คืนที่ใช้งานอยู่หลายคีย์ต่อบัญชีผู้ใช้ (เช่น คีย์ตามอุปกรณ์หรือรหัสการติดตั้ง) แทนการเขียนทับแถวเดียว
  • ตั้งค่า TTL ที่เหมาะสมและล้างคีย์ที่ไม่มีความเกี่ยวข้อง: การถอนการติดตั้งแอปหรือการล้างข้อมูลแอปจะลบคีย์การกู้คืนในเครื่องโดยไม่แจ้งให้เซิร์ฟเวอร์ทราบ เก็บคีย์การกู้คืนไว้นานพอที่จะคงอยู่ตลอดระยะเวลาการอัปเกรดอุปกรณ์ (แม้ว่าผู้ใช้จะออกจากระบบในอุปกรณ์เครื่องเก่าหลังจากโอนแล้วก็ตาม) และตัดคีย์ที่ไม่มีการใช้งานออกตาม TTL ที่ไม่มีการใช้งานหรือขีดจำกัดคีย์ต่อผู้ใช้

ลบคีย์การกู้คืน

Credential Manager เป็นแบบไม่เก็บสถานะและไม่ทราบกิจกรรมของผู้ใช้ จึงไม่ลบคีย์การกู้คืนโดยอัตโนมัติหลังการใช้งาน หากต้องการลบคีย์การกู้คืน ให้เรียกใช้เมธอด clearCredentialState() เพื่อความปลอดภัย ให้ลบคีย์เมื่อใดก็ตามที่ผู้ใช้ลงชื่อออก เพื่อไม่ให้มีการลงชื่อเข้าใช้กลับโดยอัตโนมัติเมื่อเปิดแอปครั้งถัดไป

ระบบจะนำคีย์การกู้คืนออกในสถานการณ์ต่อไปนี้เท่านั้น

  • การดำเนินการระดับระบบ: ผู้ใช้ถอนการติดตั้งแอปหรือล้างข้อมูลแอป
  • การเรียกใช้ระดับแอป: ลบคีย์แบบเป็นโปรแกรมโดยเรียกใช้ clearCredentialState() เมื่อจัดการการออกจากระบบของผู้ใช้ในโค้ดของแอป

เนื่องจาก ClearCredentialStateRequest() เริ่มต้นจะล้างเฉพาะสถานะเซสชันมาตรฐานและปล่อยคีย์การกู้คืนไว้เหมือนเดิม ให้ทำการล้างแบบคู่เมื่อออกจากระบบ โดยทำดังนี้

  1. เรียกใช้ credentialManager.clearCredentialState(ClearCredentialStateRequest()) เพื่อล้างสถานะเซสชันของผู้ให้บริการข้อมูลเข้าสู่ระบบที่ใช้งานอยู่
  2. เรียกใช้ credentialManager.clearCredentialState() ด้วย ClearCredentialStateRequest(ClearCredentialStateRequest.TYPE_CLEAR_RESTORE_CREDENTIAL) เพื่อลบ RestoreCredential ที่จัดเก็บไว้
  3. ลบเครื่องหมาย has_synced_restore_credential ในเครื่องออกจากพื้นที่เก็บข้อมูลในเครื่อง
// Create a ClearCredentialStateRequest object
val clearRequest = ClearCredentialStateRequest(TYPE_CLEAR_RESTORE_CREDENTIAL)

// When the user logs out, delete the restore key
val response = credentialManager.clearCredentialState(clearRequest)

ขั้นตอนถัดไป