क्रेडेंशियल देने वाले अपने समाधान के साथ क्रेडेंशियल मैनेजर को इंटिग्रेट करें

Credential Manager, Android 14 में लॉन्च किए गए एपीआई के एक सेट को कहते हैं. ये एपीआई, साइन इन करने के कई तरीकों के साथ काम करते हैं. जैसे, उपयोगकर्ता नाम-पासवर्ड, पासकी, और फ़ेडरेटेड साइन-इन के समाधान (जैसे, 'Google से साइन इन करें'). Credential Manager API का इस्तेमाल करने पर, Android सिस्टम डिवाइस पर इंस्टॉल किए गए सभी क्रेडेंशियल प्रोवाइडर से क्रेडेंशियल इकट्ठा करता है. इस दस्तावेज़ में उन एपीआई के सेट के बारे में बताया गया है जो इन क्रेडेंशियल की सेवा देने वाली कंपनियों के लिए इंटिग्रेशन एंडपॉइंट उपलब्ध कराते हैं.

सेटअप

क्रेडेंशियल की सुविधा देने वाली कंपनी में यह सुविधा लागू करने से पहले, नीचे दिए गए सेक्शन में दिए गए सेटअप के चरणों को पूरा करें.

डिपेंडेंसी का एलान करना

अपने मॉड्यूल की build.gradle फ़ाइल में, क्रेडेंशियल मैनेजर लाइब्रेरी के नए वर्शन का इस्तेमाल करके, डिपेंडेंसी का एलान करें:

implementation "androidx.credentials:credentials:1.2.0-{latest}"

मेनिफ़ेस्ट फ़ाइल में सेवा एलिमेंट की जानकारी देना

अपने ऐप्लिकेशन की मेनिफ़ेस्ट फ़ाइल AndroidManifest.xml में, androidx.credentials लाइब्रेरी से CredentialProviderService क्लास को एक्सटेंड करने वाली सेवा क्लास के लिए <service> एलान शामिल करें, जैसा कि नीचे दिए गए उदाहरण में दिखाया गया है.

<service android:name=".MyCredentialProviderService"
         android:enabled="true"
         android:exported="true"
         android:label="My Credential Provider"
         android:icon="<any drawable icon>"
         android:permission="android.permission.BIND_CREDENTIAL_PROVIDER_SERVICE">
    <intent-filter>
        <action android:name="android.service.credentials.CredentialProviderService"/>
    </intent-filter>
    <meta-data
         android:name="android.credentials.provider"
         android:resource="@xml/provider"/>
</service>

ऊपर दिखाए गए अनुमति और इंटेंट फ़िल्टर, क्रेडेंशियल मैनेजर फ़्लो के सही तरीके से काम करने के लिए ज़रूरी हैं. इस अनुमति की ज़रूरत इसलिए है, ताकि सिर्फ़ Android सिस्टम इस सेवा से कनेक्ट हो सके. इंटेंट फ़िल्टर का इस्तेमाल, इस सेवा को क्रेडेंशियल मैनेजर के ज़रिए इस्तेमाल किए जाने वाले क्रेडेंशियल प्रोवाइडर के तौर पर खोजने के लिए किया जाता है.

इस्तेमाल किए जा सकने वाले क्रेडेंशियल टाइप की जानकारी देना

अपनी res/xml डायरेक्ट्री में, provider.xml नाम की एक नई फ़ाइल बनाएं. इस फ़ाइल में, उन क्रेडेंशियल टाइप के बारे में बताएं जिनका इस्तेमाल आपकी सेवा के साथ किया जा सकता है. इसके लिए, लाइब्रेरी में हर क्रेडेंशियल टाइप के लिए तय की गई स्थिर वैल्यू का इस्तेमाल करें. यहां दिए गए उदाहरण में, यह सेवा सामान्य पासवर्ड के साथ-साथ पासकी के साथ भी काम करती है. इन पासकी के लिए, TYPE_PASSWORD_CREDENTIAL और TYPE_PUBLIC_KEY_CREDENTIAL के तौर पर कॉन्स्टेंट तय किए गए हैं:

<?xml version="1.0" encoding="utf-8"?>
<credential-provider xmlns:android="http://schemas.android.com/apk/res/android">
   <capabilities>
       <capability name="android.credentials.TYPE_PASSWORD_CREDENTIAL" />
       <capability name="androidx.credentials.TYPE_PUBLIC_KEY_CREDENTIAL" />
   </capabilities>
</credential-provider>

एपीआई के पिछले लेवल पर, क्रेडेंशियल प्रोवाइडर, पासवर्ड और अन्य डेटा के लिए ऑटोमैटिक भरने की सुविधा जैसे एपीआई के साथ इंटिग्रेट होते हैं. ये सेवा देने वाली कंपनियां, मौजूदा क्रेडेंशियल टाइप को सेव करने के लिए, उसी इंटरनल इन्फ़्रास्ट्रक्चर का इस्तेमाल कर सकती हैं. साथ ही, इसे पासकी के साथ-साथ अन्य क्रेडेंशियल टाइप के साथ काम करने के लिए भी बढ़ाया जा सकता है.

सेवा देने वाली कंपनी के साथ इंटरैक्ट करने के लिए दो चरणों वाला तरीका

क्रेडेंशियल मैनेजर, क्रेडेंशियल देने वाली सेवाओं के साथ दो चरणों में इंटरैक्ट करता है:

  1. पहला चरण, शुरू/क्वेरी चरण है. इसमें सिस्टम, क्रेडेंशियल देने वाली सेवाओं से जुड़ता है और Begin… अनुरोधों के साथ onBeginGetCredentialRequest(), onBeginCreateCredentialRequest() या onClearCredentialStateRequest() तरीकों को लागू करता है. सेवा देने वाली कंपनियों को इन अनुरोधों को प्रोसेस करना होगा और Begin… जवाबों के साथ जवाब देना होगा. साथ ही, उन्हें उन एंट्री से भरना होगा जो खाता चुनने वाले टूल पर दिखाए जाने वाले विज़ुअल विकल्पों को दिखाती हैं. हर एंट्री में PendingIntent सेट होना चाहिए.
  2. जब उपयोगकर्ता कोई एंट्री चुनता है, तो चुने जाने का फ़ेज़ शुरू हो जाता है और एंट्री से जुड़ा PendingIntent ट्रिगर हो जाता है. इससे, संबंधित सेवा देने वाली कंपनी की गतिविधि दिखती है. जब उपयोगकर्ता इस गतिविधि के साथ इंटरैक्ट करना बंद कर दे, तो क्रेडेंशियल देने वाली कंपनी को गतिविधि को खत्म करने से पहले, गतिविधि के नतीजे के लिए जवाब सेट करना होगा. इसके बाद, यह जवाब उस क्लाइंट ऐप्लिकेशन को भेजा जाता है जिसने क्रेडेंशियल मैनेजर को शुरू किया था.

पासकी बनाने की सुविधा को मैनेज करना

पासकी बनाने के लिए क्वेरी मैनेज करना

जब कोई क्लाइंट ऐप्लिकेशन पासकी बनाना चाहता है और उसे क्रेडेंशियल उपलब्ध कराने वाली सेवा के साथ सेव करना चाहता है, तो वह createCredential एपीआई को कॉल करता है. क्रेडेंशियल उपलब्ध कराने वाली सेवा में इस अनुरोध को इस तरह मैनेज करें कि पासकी आपके स्टोरेज में सेव हो जाए. इसके लिए, नीचे दिए गए सेक्शन में दिया गया तरीका अपनाएं.

  1. CredentialProviderService से एक्सटेंड की गई अपनी सेवा में, onBeginCreateCredentialRequest() के तरीके को बदलें.
  2. BeginCreateCredentialRequest को हैंडल करने के लिए, उससे मिलता-जुलता BeginCreateCredentialResponse बनाएं और उसे कॉलबैक में पास करें.
  3. BeginCreateCredentialResponse बनाते समय, ज़रूरी CreateEntries जोड़ें. हर CreateEntry, उस खाते से जुड़ा होना चाहिए जहां क्रेडेंशियल सेव किए जा सकते हैं. साथ ही, उसमें ज़रूरी मेटाडेटा के साथ PendingIntent सेट होना चाहिए.

नीचे दिए गए उदाहरण में, इन चरणों को लागू करने का तरीका बताया गया है.

override fun onBeginCreateCredentialRequest(
  request: BeginCreateCredentialRequest,
  cancellationSignal: CancellationSignal,
  callback: OutcomeReceiver<BeginCreateCredentialResponse, CreateCredentialException>,
) {
  val response: BeginCreateCredentialResponse? = processCreateCredentialRequest(request)
  if (response != null) {
    callback.onResult(response)
  } else {
    callback.onError(CreateCredentialUnknownException())
  }
}

fun processCreateCredentialRequest(request: BeginCreateCredentialRequest): BeginCreateCredentialResponse? {
  when (request) {
    is BeginCreatePublicKeyCredentialRequest -> {
      // Request is passkey type
      return handleCreatePasskeyQuery(request)
    }
  }
  // Request not supported
  return null
}

private fun handleCreatePasskeyQuery(
    request: BeginCreatePublicKeyCredentialRequest
    ): BeginCreateCredentialResponse {

    // Adding two create entries - one for storing credentials to the 'Personal'
    // account, and one for storing them to the 'Family' account. These
    // accounts are local to this sample app only.
    val createEntries: MutableList<CreateEntry> = mutableListOf()
    createEntries.add( CreateEntry(
        PERSONAL_ACCOUNT_ID,
        createNewPendingIntent(PERSONAL_ACCOUNT_ID, CREATE_PASSKEY_INTENT)
    ))

    createEntries.add( CreateEntry(
        FAMILY_ACCOUNT_ID,
        createNewPendingIntent(FAMILY_ACCOUNT_ID, CREATE_PASSKEY_INTENT)
    ))

    return BeginCreateCredentialResponse(createEntries)
}

private fun createNewPendingIntent(accountId: String, action: String): PendingIntent {
    val intent = Intent(action).setPackage(PACKAGE_NAME)

    // Add your local account ID as an extra to the intent, so that when
    // user selects this entry, the credential can be saved to this
    // account
    intent.putExtra(EXTRA_KEY_ACCOUNT_ID, accountId)

    return PendingIntent.getActivity(
        applicationContext, UNIQUE_REQ_CODE,
        intent, (
            PendingIntent.FLAG_MUTABLE
            or PendingIntent.FLAG_UPDATE_CURRENT
        )
    )
}

आपके PendingIntent का कॉन्स्ट्रक्शन इन बातों के मुताबिक होना चाहिए:

  • गतिविधि को इस तरह से सेट अप किया जाना चाहिए कि ज़रूरी होने पर, बायोमेट्रिक पुष्टि करने के लिए कहा जा सके, पुष्टि करने के लिए कहा जा सके या कोई विकल्प चुना जा सके.
  • जब संबंधित गतिविधि शुरू की जाती है, तब सेवा देने वाली कंपनी को जो भी ज़रूरी डेटा चाहिए उसे उस इंटेंट पर एक्स्ट्रा के तौर पर सेट किया जाना चाहिए जिसका इस्तेमाल आपके PendingIntent को बनाने के लिए किया जाता है. जैसे, बनाने के फ़्लो में accountId.
  • आपके PendingIntent को फ़्लैग PendingIntent.FLAG_MUTABLE के साथ बनाया जाना चाहिए, ताकि सिस्टम इंटेंट एक्सट्रा में फ़ाइनल अनुरोध जोड़ सके.
  • आपके PendingIntent को फ़्लैग PendingIntent.FLAG_ONE_SHOT के साथ नहीं बनाया जाना चाहिए, क्योंकि उपयोगकर्ता किसी एंट्री को चुन सकता है, वापस जा सकता है, और उसे फिर से चुन सकता है. इससे PendingIntent दो बार ट्रिगर होगा.
  • आपका PendingIntent, एक यूनीक अनुरोध कोड के साथ बनाया जाना चाहिए, ताकि हर एंट्री का अपना PendingIntent हो.

पासकी बनाने के अनुरोधों के लिए, एंट्री चुनने की सुविधा को मैनेज करना

  1. जब उपयोगकर्ता, पहले से भरे हुए किसी CreateEntry को चुनता है, तो उससे जुड़ा PendingIntent चालू हो जाता है और उससे जुड़ा प्रोवाइडर Activity बन जाता है.
  2. आपकी गतिविधि के onCreate तरीके को शुरू करने के बाद, उससे जुड़ा इंटेंट ऐक्सेस करें और ProviderCreateCredentialRequest पाने के लिए, उसे PendingIntentHander क्लास में पास करें.
  3. अनुरोध से requestJson, callingAppInfo, और clientDataHash को निकालें.
  4. इंटेंट एक्सट्रा से स्थानीय accountId निकालें. यह किसी ऐप्लिकेशन के लिए लागू करने का सैंपल है. इसे लागू करना ज़रूरी नहीं है. इस खाता आईडी का इस्तेमाल, इस क्रेडेंशियल को इस खाता आईडी के साथ सेव करने के लिए किया जा सकता है.
  5. requestJson की पुष्टि करें. यहां दिए गए उदाहरण में, PublicKeyCredentialCreationOptions जैसी लोकल डेटा क्लास का इस्तेमाल किया गया है. इससे, इनपुट जेएसओएन को WebAuthn स्पेसिफ़िकेशन के मुताबिक स्ट्रक्चर्ड क्लास में बदला जा सकता है. क्रेडेंशियल उपलब्ध कराने वाले के तौर पर, इसे अपने पार्सर से बदला जा सकता है.
  6. अगर कॉल किसी नेटिव Android ऐप्लिकेशन से किया है, तो कॉल करने वाले ऐप्लिकेशन के लिए asset-link देखें.
  7. पुष्टि करने के लिए प्रॉम्प्ट दिखाएं. नीचे दिए गए उदाहरण में, Android के बायोमेट्रिक एपीआई का इस्तेमाल किया गया है.
  8. पुष्टि हो जाने के बाद, credentialId और एक कुंजी जोड़ी जनरेट करें.
  9. निजी कुंजी को अपने स्थानीय डेटाबेस में callingAppInfo.packageName के लिए सेव करें.
  10. Web Authentication API का JSON रिस्पॉन्स बनाएं. इसमें सार्वजनिक कुंजी और credentialId शामिल होना चाहिए. यहां दिए गए उदाहरण में, AuthenticatorAttestationResponse और FidoPublicKeyCredential जैसी लोकल यूटिलिटी क्लास का इस्तेमाल किया गया है. इनकी मदद से, पहले बताए गए स्पेसिफ़िकेशन के आधार पर जेएसओएन बनाया जा सकता है. क्रेडेंशियल उपलब्ध कराने वाले के तौर पर, इन क्लास को अपने बिल्डर से बदला जा सकता है.
  11. ऊपर जनरेट किए गए JSON का इस्तेमाल करके, CreatePublicKeyCredentialResponse बनाएं.
  12. PendingIntentHander.setCreateCredentialResponse() की मदद से, Intent पर CreatePublicKeyCredentialResponse को एक्सट्रा के तौर पर सेट करें. साथ ही, उस इंटेंट को गतिविधि के नतीजे पर सेट करें.
  13. गतिविधि पूरी करें.

नीचे दिए गए कोड के उदाहरण में इन चरणों के बारे में बताया गया है. onCreate() को ट्रिगर करने के बाद, इस कोड को अपनी गतिविधि क्लास में मैनेज करना होगा.

val request =
  PendingIntentHandler.retrieveProviderCreateCredentialRequest(intent)

val accountId = intent.getStringExtra(CredentialsRepo.EXTRA_KEY_ACCOUNT_ID)
if (request != null && request.callingRequest is CreatePublicKeyCredentialRequest) {
  val publicKeyRequest: CreatePublicKeyCredentialRequest =
    request.callingRequest as CreatePublicKeyCredentialRequest
  createPasskey(
    publicKeyRequest.requestJson,
    request.callingAppInfo,
    publicKeyRequest.clientDataHash,
    accountId
  )
}

fun createPasskey(
  requestJson: String,
  callingAppInfo: CallingAppInfo?,
  clientDataHash: ByteArray?,
  accountId: String?
) {
  val request = PublicKeyCredentialCreationOptions(requestJson)

  val biometricPrompt = BiometricPrompt(
    this,
    <executor>,
    object : BiometricPrompt.AuthenticationCallback() {
      override fun onAuthenticationError(
        errorCode: Int, errString: CharSequence
      ) {
        super.onAuthenticationError(errorCode, errString)
        finish()
      }

      override fun onAuthenticationFailed() {
        super.onAuthenticationFailed()
        finish()
      }

      override fun onAuthenticationSucceeded(
        result: BiometricPrompt.AuthenticationResult
      ) {
        super.onAuthenticationSucceeded(result)

        // Generate a credentialId
        val credentialId = ByteArray(32)
        SecureRandom().nextBytes(credentialId)

        // Generate a credential key pair
        val spec = ECGenParameterSpec("secp256r1")
        val keyPairGen = KeyPairGenerator.getInstance("EC");
        keyPairGen.initialize(spec)
        val keyPair = keyPairGen.genKeyPair()

        // Save passkey in your database as per your own implementation

        // Create AuthenticatorAttestationResponse object to pass to
        // FidoPublicKeyCredential

        val response = AuthenticatorAttestationResponse(
          requestOptions = request,
          credentialId = credentialId,
          credentialPublicKey = getPublicKeyFromKeyPair(keyPair),
          origin = appInfoToOrigin(callingAppInfo),
          up = true,
          uv = true,
          be = true,
          bs = true,
          packageName = callingAppInfo.packageName
        )

        val credential = FidoPublicKeyCredential(
          rawId = credentialId, response = response
        )
        val result = Intent()

        val createPublicKeyCredResponse =
          CreatePublicKeyCredentialResponse(credential.json())

        // Set the CreateCredentialResponse as the result of the Activity
        PendingIntentHandler.setCreateCredentialResponse(
          result, createPublicKeyCredResponse
        )
        setResult(Activity.RESULT_OK, result)
        finish()
      }
    }
  )

  val promptInfo = BiometricPrompt.PromptInfo.Builder()
    .setTitle("Use your screen lock")
    .setSubtitle("Create passkey for ${request.rp.name}")
    .setAllowedAuthenticators(
        BiometricManager.Authenticators.BIOMETRIC_STRONG
        /* or BiometricManager.Authenticators.DEVICE_CREDENTIAL */
      )
    .build()
  biometricPrompt.authenticate(promptInfo)
}

fun appInfoToOrigin(info: CallingAppInfo): String {
  val cert = info.signingInfo.apkContentsSigners[0].toByteArray()
  val md = MessageDigest.getInstance("SHA-256");
  val certHash = md.digest(cert)
  // This is the format for origin
  return "android:apk-key-hash:${b64Encode(certHash)}"
}

पासवर्ड बनाने के अनुरोधों से जुड़ी क्वेरी मैनेज करना

पासवर्ड बनाने के अनुरोधों से जुड़ी क्वेरी को मैनेज करने के लिए, यह तरीका अपनाएं:

  • पिछले सेक्शन में बताए गए processCreateCredentialRequest() तरीके में, पासवर्ड के अनुरोधों को मैनेज करने के लिए, स्विच ब्लॉक में एक और केस जोड़ें.
  • BeginCreateCredentialResponse बनाते समय, ज़रूरी CreateEntries जोड़ें.
  • हर CreateEntry, किसी ऐसे खाते से जुड़ा होना चाहिए जहां क्रेडेंशियल सेव किया जा सकता हो. साथ ही, उस पर अन्य मेटाडेटा के साथ PendingIntent सेट होना चाहिए.

नीचे दिए गए उदाहरण में, इन चरणों को लागू करने का तरीका बताया गया है:

fun processCreateCredentialRequest(
    request: BeginCreateCredentialRequest
  ): BeginCreateCredentialResponse? {
  when (request) {
    is BeginCreatePublicKeyCredentialRequest -> {
      // Request is passkey type
      return handleCreatePasskeyQuery(request)
    }

    is BeginCreatePasswordCredentialRequest -> {
    // Request is password type
      return handleCreatePasswordQuery(request)
    }
  }
  return null
}

private fun handleCreatePasswordQuery(
    request: BeginCreatePasswordCredentialRequest
  ): BeginCreateCredentialResponse {
  val createEntries: MutableList<CreateEntry> = mutableListOf()

  // Adding two create entries - one for storing credentials to the 'Personal'
  // account, and one for storing them to the 'Family' account. These
  // accounts are local to this sample app only.
  createEntries.add(
    CreateEntry(
      PERSONAL_ACCOUNT_ID,
      createNewPendingIntent(PERSONAL_ACCOUNT_ID, CREATE_PASSWORD_INTENT)
    )
  )
  createEntries.add(
    CreateEntry(
      FAMILY_ACCOUNT_ID,
      createNewPendingIntent(FAMILY_ACCOUNT_ID, CREATE_PASSWORD_INTENT)
    )
  )

  return BeginCreateCredentialResponse(createEntries)
}

पासवर्ड बनाने के अनुरोधों के लिए, एंट्री चुनने की सुविधा को मैनेज करना

जब उपयोगकर्ता, जानकारी से भरा हुआ कोई CreateEntry चुनता है, तो उससे जुड़ा PendingIntent लागू हो जाता है और उससे जुड़ी गतिविधि दिखने लगती है. onCreate में पास किए गए, इससे जुड़े इंटेंट को ऐक्सेस करें और ProviderCreateCredentialRequest तरीका पाने के लिए, उसे PendingIntentHander क्लास में पास करें.

नीचे दिए गए उदाहरण में, इस प्रोसेस को लागू करने का तरीका बताया गया है. इस कोड को आपकी गतिविधि के onCreate() मेथड में मैनेज करना होगा.

val createRequest = PendingIntentHandler.retrieveProviderCreateCredentialRequest(intent)
val accountId = intent.getStringExtra(CredentialsRepo.EXTRA_KEY_ACCOUNT_ID)

val request: CreatePasswordRequest = createRequest.callingRequest as CreatePasswordRequest

// Fetch the ID and password from the request and save it in your database
<your_database>.addNewPassword(
    PasswordInfo(
        request.id,
        request.password,
        createRequest.callingAppInfo.packageName
    )
)

//Set the final response back
val result = Intent()
val response = CreatePasswordResponse()
PendingIntentHandler.setCreateCredentialResponse(result, response)
setResult(Activity.RESULT_OK, result)
this@<activity>.finish()

उपयोगकर्ता के साइन इन करने की प्रोसेस को मैनेज करना

उपयोगकर्ता के साइन इन करने की प्रोसेस को इन चरणों में मैनेज किया जाता है:

  • जब कोई क्लाइंट ऐप्लिकेशन किसी उपयोगकर्ता को साइन इन करने की कोशिश करता है, तो वह एक GetCredentialRequest इंस्टेंस तैयार करता है.
  • Android फ़्रेमवर्क, इन सेवाओं से जुड़कर इस अनुरोध को क्रेडेंशियल उपलब्ध कराने वाली सभी सेवाओं को भेजता है.
  • इसके बाद, सेवा देने वाली कंपनी को एक BeginGetCredentialRequest मिलता है. इसमें BeginGetCredentialOption की सूची होती है. हर BeginGetCredentialOption में ऐसे पैरामीटर होते हैं जिनका इस्तेमाल, मैच होने वाले क्रेडेंशियल वापस पाने के लिए किया जा सकता है.

क्रेडेंशियल की सेवा देने वाली अपनी कंपनी में इस अनुरोध को मैनेज करने के लिए, यह तरीका अपनाएं:

  1. अनुरोध को मैनेज करने के लिए, onBeginGetCredentialRequest() तरीके को बदलें. ध्यान दें कि अगर आपके क्रेडेंशियल लॉक हैं, तो जवाब पर तुरंत AuthenticationAction सेट किया जा सकता है और कॉलबैक को ट्रिगर किया जा सकता है.

    private val unlockEntryTitle = "Authenticate to continue"

override fun onBeginGetCredentialRequest(
    request: BeginGetCredentialRequest,
    cancellationSignal: CancellationSignal,
    callback: OutcomeReceiver<BeginGetCredentialResponse, GetCredentialException>,
) {
    if (isAppLocked()) {
        callback.onResult(BeginGetCredentialResponse(
            authenticationActions = mutableListOf(AuthenticationAction(
                unlockEntryTitle, createUnlockPendingIntent())
                )
            )
        )
        return
    }
    try {
        response = processGetCredentialRequest(request)
        callback.onResult(response)
    } catch (e: GetCredentialException) {
        callback.onError(GetCredentialUnknownException())
    }
}

    जिन सेवा देने वाली कंपनियों को कोई credentialEntries दिखाने से पहले, क्रेडेंशियल अनलॉक करने की ज़रूरत होती है उन्हें एक पेंडिंग इंटेंट सेट अप करना होगा. इससे उपयोगकर्ता, ऐप्लिकेशन के अनलॉक फ़्लो पर पहुंच जाएगा:

    private fun createUnlockPendingIntent(): PendingIntent {
    val intent = Intent(UNLOCK_INTENT).setPackage(PACKAGE_NAME)
    return PendingIntent.getActivity(
    applicationContext, UNIQUE_REQUEST_CODE, intent, (
        PendingIntent.FLAG_MUTABLE
        or PendingIntent.FLAG_UPDATE_CURRENT
        )
    )
}

  2. अपने स्थानीय डेटाबेस से क्रेडेंशियल वापस पाएं और उन्हें सेलेक्ट करने वाले टूल पर दिखाने के लिए, CredentialEntries का इस्तेमाल करके सेट अप करें. पासकी के लिए, credentialId को इंटेंट पर एक अतिरिक्त के तौर पर सेट किया जा सकता है, ताकि यह पता चल सके कि उपयोगकर्ता इस एंट्री को चुनने पर, यह किस क्रेडेंशियल से मैप होती है.

    companion object {
    // These intent actions are specified for corresponding activities
    // that are to be invoked through the PendingIntent(s)
    private const val GET_PASSKEY_INTENT_ACTION = "PACKAGE_NAME.GET_PASSKEY"
    private const val GET_PASSWORD_INTENT_ACTION = "PACKAGE_NAME.GET_PASSWORD"

}

fun processGetCredentialsRequest(
request: BeginGetCredentialRequest
): BeginGetCredentialResponse {
    val callingPackage = request.callingAppInfo?.packageName
    val credentialEntries: MutableList<CredentialEntry> = mutableListOf()

    for (option in request.beginGetCredentialOptions) {
        when (option) {
            is BeginGetPasswordOption -> {
                credentialEntries.addAll(
                        populatePasswordData(
                            callingPackage,
                            option
                        )
                    )
                }
                is BeginGetPublicKeyCredentialOption -> {
                    credentialEntries.addAll(
                        populatePasskeyData(
                            callingPackage,
                            option
                        )
                    )
                )
            } else -> {
                Log.i(TAG, "Request not supported")
            }
        }
    }
    return BeginGetCredentialResponse(credentialEntries)
}

  3. अपने डेटाबेस से क्रेडेंशियल की क्वेरी करें. साथ ही, अपने-आप जानकारी भरने के लिए पासकी और पासवर्ड की एंट्री बनाएं.

    private fun populatePasskeyData(
    callingAppInfo: CallingAppInfo,
    option: BeginGetPublicKeyCredentialOption
): List<CredentialEntry> {
  val passkeyEntries: MutableList<CredentialEntry> = mutableListOf()
  val request = PublicKeyCredentialRequestOptions(option.requestJson)
  // Get your credentials from database where you saved during creation flow
  val creds = <getCredentialsFromInternalDb(request.rpId)>
  val passkeys = creds.passkeys
  for (passkey in passkeys) {
      val data = Bundle()
      data.putString("credId", passkey.credId)
      passkeyEntries.add(
          PublicKeyCredentialEntry(
              context = applicationContext,
              username = passkey.username,
              pendingIntent = createNewPendingIntent(
                  GET_PASSKEY_INTENT_ACTION,
                  data
              ),
              beginPublicKeyCredentialOption = option,
              displayName = passkey.displayName,
              icon = passkey.icon
          )
      )
  }
  return passkeyEntries
}

// Fetch password credentials and create password entries to populate to
// the user
private fun populatePasswordData(
callingPackage: String,
option: BeginGetPasswordOption
): List<CredentialEntry> {
    val passwordEntries: MutableList<CredentialEntry> = mutableListOf()

    // Get your password credentials from database where you saved during
    // creation flow
    val creds = <getCredentialsFromInternalDb(callingPackage)>
    val passwords = creds.passwords
    for (password in passwords) {
        passwordEntries.add(
            PasswordCredentialEntry(
                context = applicationContext,
                username = password.username,
                pendingIntent = createNewPendingIntent(
                GET_PASSWORD_INTENT
                ),
                beginGetPasswordOption = option
                    displayName = password.username,
                icon = password.icon
            )
        )
    }
    return passwordEntries
}

private fun createNewPendingIntent(
    action: String,
    extra: Bundle? = null
): PendingIntent {
    val intent = Intent(action).setPackage(PACKAGE_NAME)
    if (extra != null) {
        intent.putExtra("CREDENTIAL_DATA", extra)
    }

    return PendingIntent.getActivity(
        applicationContext, UNIQUE_REQUEST_CODE, intent,
        (PendingIntent.FLAG_MUTABLE or PendingIntent.FLAG_UPDATE_CURRENT)
    )
}

  4. क्रेडेंशियल की क्वेरी करने और उन्हें भरने के बाद, आपको उपयोगकर्ता के चुने गए क्रेडेंशियल के लिए, चुनने का चरण मैनेज करना होगा. भले ही, वह पासकी हो या पासवर्ड.

पासकी के लिए उपयोगकर्ता के चुने गए विकल्प को मैनेज करना

  1. उससे जुड़ी गतिविधि के onCreate तरीके में, उससे जुड़ा इंटेंट पाएं और PendingIntentHandler.retrieveProviderGetCredentialRequest() को पास करें.
  2. ऊपर दिए गए अनुरोध से GetPublicKeyCredentialOption निकालें. इसके बाद, इस विकल्प से requestJson और clientDataHash को अलग करें.
  3. इंटेंट एक्सट्रा से credentialId निकालें. इसे क्रेडेंशियल उपलब्ध कराने वाली कंपनी ने, PendingIntent सेट अप करते समय भरा था.
  4. ऊपर ऐक्सेस किए गए अनुरोध पैरामीटर का इस्तेमाल करके, अपने लोकल डेटाबेस से पासकी निकालें.

  5. यह पुष्टि करें कि पासकी, निकाले गए मेटाडेटा और उपयोगकर्ता की पुष्टि के साथ मान्य है.

    val getRequest =
    PendingIntentHandler.retrieveProviderGetCredentialRequest(intent)
val publicKeyRequest =
getRequest.credentialOption as GetPublicKeyCredentialOption

val requestInfo = intent.getBundleExtra("CREDENTIAL_DATA")
val credIdEnc = requestInfo.getString("credId")

// Get the saved passkey from your database based on the credential ID
// from the publickeyRequest
val passkey = <your database>.getPasskey(credIdEnc)

// Decode the credential ID, private key and user ID
val credId = b64Decode(credIdEnc)
val privateKey = b64Decode(passkey.credPrivateKey)
val uid = b64Decode(passkey.uid)

val origin = appInfoToOrigin(getRequest.callingAppInfo)
val packageName = getRequest.callingAppInfo.packageName

validatePasskey(
    publicKeyRequest.requestJson,
    origin,
    packageName,
    uid,
    passkey.username,
    credId,
    privateKey
)

  6. उपयोगकर्ता की पुष्टि करने के लिए, बायोमेट्रिक प्रॉम्प्ट (या पुष्टि करने का कोई दूसरा तरीका) दिखाएं. नीचे दिया गया कोड स्निपेट, Android Biometric API का इस्तेमाल करता है.

  7. पुष्टि हो जाने के बाद, W3 Web Authentication Assertion spec के आधार पर JSON रिस्पॉन्स बनाएं. नीचे दिए गए कोड स्निपेट में, AuthenticatorAssertionResponse जैसी हेल्पर डेटा क्लास का इस्तेमाल, स्ट्रक्चर्ड पैरामीटर को शामिल करने और उन्हें ज़रूरी JSON फ़ॉर्मैट में बदलने के लिए किया जाता है. रिस्पॉन्स में, WebAuthn क्रेडेंशियल की निजी कुंजी से मिला डिजिटल हस्ताक्षर शामिल होता है. भरोसा करने वाली पार्टी का सर्वर, साइन इन करने से पहले उपयोगकर्ता की पुष्टि करने के लिए, इस हस्ताक्षर की पुष्टि कर सकता है.

  8. ऊपर जनरेट किए गए JSON का इस्तेमाल करके, PublicKeyCredential बनाएं और इसे GetCredentialResponse पर सेट करें. इस गतिविधि के नतीजे के आधार पर, यह आखिरी जवाब सेट करें.

नीचे दिए गए उदाहरण में, इन चरणों को लागू करने का तरीका बताया गया है:

val request = PublicKeyCredentialRequestOptions(requestJson)
val privateKey: ECPrivateKey = convertPrivateKey(privateKeyBytes)

val biometricPrompt = BiometricPrompt(
    this,
    <executor>,
    object : BiometricPrompt.AuthenticationCallback() {
        override fun onAuthenticationError(
        errorCode: Int, errString: CharSequence
        ) {
            super.onAuthenticationError(errorCode, errString)
            finish()
        }

        override fun onAuthenticationFailed() {
            super.onAuthenticationFailed()
            finish()
        }

        override fun onAuthenticationSucceeded(
        result: BiometricPrompt.AuthenticationResult
        ) {
        super.onAuthenticationSucceeded(result)
        val response = AuthenticatorAssertionResponse(
            requestOptions = request,
            credentialId = credId,
            origin = origin,
            up = true,
            uv = true,
            be = true,
            bs = true,
            userHandle = uid,
            packageName = packageName
        )

        val sig = Signature.getInstance("SHA256withECDSA");
        sig.initSign(privateKey)
        sig.update(response.dataToSign())
        response.signature = sig.sign()

        val credential = FidoPublicKeyCredential(
            rawId = credId, response = response
        )
        val result = Intent()
        val passkeyCredential = PublicKeyCredential(credential.json)
        PendingIntentHandler.setGetCredentialResponse(
            result, GetCredentialResponse(passkeyCredential)
        )
        setResult(RESULT_OK, result)
        finish()
        }
    }
)

val promptInfo = BiometricPrompt.PromptInfo.Builder()
    .setTitle("Use your screen lock")
    .setSubtitle("Use passkey for ${request.rpId}")
    .setAllowedAuthenticators(
            BiometricManager.Authenticators.BIOMETRIC_STRONG
            /* or BiometricManager.Authenticators.DEVICE_CREDENTIAL */
        )
    .build()
biometricPrompt.authenticate(promptInfo)

पासवर्ड की पुष्टि करने के लिए, उपयोगकर्ता के चुने गए तरीके को मैनेज करना

  1. अपनी गतिविधि में, onCreate में पास किए गए इंटेंट को ऐक्सेस करें और PendingIntentHandler का इस्तेमाल करके ProviderGetCredentialRequest को निकालें.

  2. आने वाले पैकेज के नाम के लिए पासवर्ड के क्रेडेंशियल वापस पाने के लिए, अनुरोध में GetPasswordOption का इस्तेमाल करें.

    val getRequest =
PendingIntentHandler.retrieveProviderGetCredentialRequest(intent)

val passwordOption = getRequest.credentialOption as GetPasswordCredentialOption

val username = passwordOption.username
// Fetch the credentials for the calling app package name
val creds = <your_database>.getCredentials(callingAppInfo.packageName)
val passwords = creds.passwords
val it = passwords.iterator()
var password = ""
while (it.hasNext() == true) {
    val passwordItemCurrent = it.next()
    if (passwordItemCurrent.username == username) {
       password = passwordItemCurrent.password
       break
    }
}

  3. पासवर्ड वापस पाने के बाद, चुने गए पासवर्ड क्रेडेंशियल के लिए जवाब सेट करें.

    // Set the response back
val result = Intent()
val passwordCredential = PasswordCredential(username, password)
PendingIntentHandler.setGetCredentialResponse(
result, GetCredentialResponse(passwordCredential)
)
setResult(Activity.RESULT_OK, result)
finish()

पुष्टि करने की कार्रवाई की एंट्री चुनना

जैसा कि पहले बताया गया है, अगर क्रेडेंशियल लॉक हैं, तो क्रेडेंशियल देने वाली कंपनी AuthenticationAction सेट कर सकती है. अगर उपयोगकर्ता इस एंट्री को चुनता है, तो PendingIntent में सेट की गई इंटेंट ऐक्शन से जुड़ी ऐक्टिविटी शुरू हो जाती है. इसके बाद, क्रेडेंशियल देने वाली कंपनियां, क्रेडेंशियल अनलॉक करने के लिए, बायोमेट्रिक पुष्टि करने का तरीका या मिलता-जुलता तरीका दिखा सकती हैं. पुष्टि हो जाने के बाद, क्रेडेंशियल उपलब्ध कराने वाली कंपनी को BeginGetCredentialResponse बनाना होगा. यह BeginGetCredentialResponse, उपयोगकर्ता के साइन इन करने के तरीके के बारे में ऊपर बताए गए तरीके से मिलता-जुलता होना चाहिए. ऐसा इसलिए, क्योंकि क्रेडेंशियल अब अनलॉक हो गए हैं. इसके बाद, इस जवाब को PendingIntentHandler.setBeginGetCredentialResponse() तरीके से सेट किया जाना चाहिए. इसके बाद ही, तैयार किए गए इंटेंट को नतीजे के तौर पर सेट किया जाएगा और गतिविधि पूरी हो जाएगी.

क्रेडेंशियल के अनुरोध मिटाना

कोई क्लाइंट ऐप्लिकेशन, क्रेडेंशियल चुनने के लिए सेव की गई किसी भी स्थिति को हटाने का अनुरोध कर सकता है. उदाहरण के लिए, क्रेडेंशियल देने वाली कंपनी, पहले चुने गए क्रेडेंशियल को याद रख सकती है और अगली बार सिर्फ़ उसे दिखा सकती है. कोई क्लाइंट ऐप्लिकेशन इस एपीआई को कॉल करता है और उम्मीद करता है कि स्टिक सिलेक्शन हट जाए. क्रेडेंशियल देने वाली सेवा, onClearCredentialStateRequest() तरीके को बदलकर, इस अनुरोध को मैनेज कर सकती है:

override fun onClearCredentialStateRequest(
    request: android.service.credentials.ClearCredentialStateRequest,
    cancellationSignal: CancellationSignal,
    callback: OutcomeReceiver<Void?, ClearCredentialException>,
  ) {
    // Delete any maintained state as appropriate.
}

उपयोगकर्ताओं को पासवर्ड, पासकी, और ऑटोमैटिक भरने की सुविधा वाली स्क्रीन से, क्रेडेंशियल की सेवा देने वाली कंपनी की सेटिंग खोलने की अनुमति देने के लिए, क्रेडेंशियल की सेवा देने वाले ऐप्लिकेशन को res/xml/provider.xml में credential-provider settingsActivity मेनिफ़ेस्ट एट्रिब्यूट लागू करना चाहिए. इस एट्रिब्यूट की मदद से, किसी इंटेंट का इस्तेमाल करके अपने ऐप्लिकेशन की सेटिंग स्क्रीन खोली जा सकती है. ऐसा तब होता है, जब कोई उपयोगकर्ता सेवाओं की पासवर्ड, पासकी, और ऑटोमैटिक भरने की सुविधा की सूची में, सेवा देने वाली कंपनी के नाम पर क्लिक करता है. इस एट्रिब्यूट की वैल्यू को, सेटिंग स्क्रीन से लॉन्च की जाने वाली गतिविधि के नाम पर सेट करें.

<credential-provider
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:settingsSubtitle="Example settings provider name"
    android:settingsActivity="com.example.SettingsActivity">
    <capabilities>
        <capability name="android.credentials.TYPE_PUBLIC_KEY_CREDENTIAL" />
    </capabilities>
</credential-provider>
बदलाव और खोलने वाले बटन के फ़ंक्शन दिखाने वाला डायग्राम
पहली इमेज: बदलें बटन, चुने गए विकल्प वाला मौजूदा डायलॉग बॉक्स खोलता है. इससे उपयोगकर्ता को अपने पसंदीदा क्रेडेंशियल प्रोवाइडर को चुनने की सुविधा मिलती है. खोलें बटन, मेनिफ़ेस्ट में किए गए बदलाव में बताई गई सेटिंग गतिविधि को लॉन्च करता है. साथ ही, उस सेवा देने वाली कंपनी के लिए खास तौर पर सेटिंग पेज खोलता है.

सेटिंग इंटेंट

सेटिंग खोलें: android.settings.CREDENTIAL_PROVIDER के ज़रिए, सेटिंग स्क्रीन खुलती है. यहां उपयोगकर्ता, अपने पसंदीदा और अन्य क्रेडेंशियल प्रोवाइडर चुन सकता है.

पासवर्ड, पासकी, और ऑटोमैटिक भरने की सेटिंग वाली स्क्रीन
दूसरी इमेज: पासवर्ड, पासकी, और ऑटोमैटिक भरने की सेटिंग वाली स्क्रीन.

पसंदीदा क्रेडेंशियल सेवा: ACTION_REQUEST_SET_AUTOFILL_SERVICE इंटेंट, उपयोगकर्ता को सेवा देने वाली पसंदीदा कंपनी चुनने की स्क्रीन पर रीडायरेक्ट करता है. इस स्क्रीन पर चुने गए क्रेडेंशियल और ऑटोमैटिक भरने की सुविधा देने वाली कंपनी, आपके लिए प्राथमिकता बन जाती है.

बदलाव और खोलने वाले बटन के फ़ंक्शन दिखाने वाला डायग्राम
तीसरा इमेज: पासवर्ड, पासकी, और ऑटोमैटिक भरने की सुविधा के लिए,
पसंदीदा सेवा की सेटिंग वाली स्क्रीन.

खास सुविधाओं वाले ऐप्लिकेशन की अनुमति वाली सूची पाना

वेब ब्राउज़र जैसे ऐप्लिकेशन, क्रेडेंशियल मैनेजर GetCredentialRequest() और CreatePublicKeyCredentialRequest() तरीकों में origin पैरामीटर सेट करके, भरोसेमंद अन्य पक्षों की ओर से क्रेडेंशियल मैनेजर कॉल करते हैं. इन अनुरोधों को प्रोसेस करने के लिए, क्रेडेंशियल उपलब्ध कराने वाली कंपनी, getOrigin() एपीआई का इस्तेमाल करके origin को वापस लाती है.

origin को वापस पाने के लिए, क्रेडेंशियल उपलब्ध कराने वाले ऐप्लिकेशन को androidx.credentials.provider.CallingAppInfo's getOrigin() एपीआई को, विशेषाधिकार वाले और भरोसेमंद कॉलर की सूची भेजनी होगी. यह अनुमति सूची, मान्य JSON ऑब्जेक्ट होनी चाहिए. origin तब दिखाया जाता है, जब packageName और signingInfo से मिले सर्टिफ़िकेट के फ़िंगरप्रिंट, getOrigin() एपीआई को पास किए गए privilegedAllowlist में मौजूद ऐप्लिकेशन के फ़िंगरप्रिंट से मेल खाते हों. origin वैल्यू मिलने के बाद, सेवा देने वाले ऐप्लिकेशन को इसे एक खास कॉल माना जाना चाहिए. साथ ही, कॉल करने वाले ऐप्लिकेशन के हस्ताक्षर का इस्तेमाल करके origin का हिसाब लगाने के बजाय, AuthenticatorResponse में origin को क्लाइंट डेटा पर सेट करना चाहिए.

अगर आपको कोई origin मिलता है, तो हस्ताक्षर के अनुरोध के दौरान clientDataJSON को इकट्ठा और हैश करने के बजाय, सीधे CreatePublicKeyCredentialRequest() या GetPublicKeyCredentialOption() में दिए गए clientDataHash का इस्तेमाल करें. JSON को पार्स करने से जुड़ी समस्याओं से बचने के लिए, पुष्टि और एश्योरेशन के जवाब में clientDataJSON के लिए प्लेसहोल्डर वैल्यू सेट करें. Google Password Manager, getOrigin() को कॉल करने के लिए, सार्वजनिक तौर पर उपलब्ध अनुमति वाली सूची का इस्तेमाल करता है. क्रेडेंशियल उपलब्ध कराने वाली कंपनी के तौर पर, आपके पास इस सूची का इस्तेमाल करने या एपीआई के बताए गए JSON फ़ॉर्मैट में अपनी सूची उपलब्ध कराने का विकल्प होता है. यह सेवा देने वाली कंपनी तय करती है कि किस सूची का इस्तेमाल किया जाए. क्रेडेंशियल उपलब्ध कराने वाली तीसरे पक्ष की कंपनियों से खास ऐक्सेस पाने के लिए, तीसरे पक्ष के दिए गए दस्तावेज़ देखें.

किसी डिवाइस पर सेवा देने वाली कंपनियों को चालू करना

उपयोगकर्ताओं को डिवाइस की सेटिंग > पासवर्ड और खाते > सेवा देने वाली कंपनी > चालू या बंद करें पर जाकर, सेवा देने वाली कंपनी को चालू करना होगा.

fun createSettingsPendingIntent(): PendingIntent