'Google से साइन इन करें' सुविधा लागू करना

इस गाइड में, 'Google से साइन इन करें' सुविधा को लागू करने का तरीका बताया गया है. इसमें ये चरण शामिल हैं:

अपने ऐप्लिकेशन में डिपेंडेंसी जोड़ना.
CredentialManager को इंस्टैंशिएट करना.
बॉटम शीट फ़्लो बनाना.
बटन फ़्लो बनाना.
साइन-इन के जवाब को मैनेज करना.
गड़बड़ियों को ठीक करना.
साइन-आउट को मैनेज करना.

अपने ऐप्लिकेशन में डिपेंडेंसी जोड़ना

अपने मॉड्यूल की build.gradle फ़ाइल में, Credential Manager, Play Services Auth, और googleid के सबसे नए वर्शन का इस्तेमाल करके डिपेंडेंसी के बारे में बताएं:

Kotlin

dependencies {
    implementation("androidx.credentials:credentials:1.7.0-alpha01")
    implementation("androidx.credentials:credentials-play-services-auth:1.7.0-alpha01")
    implementation("com.google.android.libraries.identity.googleid:googleid:<latest version>")
}

Groovy

dependencies {
    implementation "androidx.credentials:credentials:1.7.0-alpha01"
    implementation "androidx.credentials:credentials-play-services-auth:1.7.0-alpha01"
    implementation "com.google.android.libraries.identity.googleid:googleid:<latest version>"
}

Credential Manager को इंस्टैंशिएट करना

CredentialManager ऑब्जेक्ट बनाने के लिए, अपने ऐप्लिकेशन या ऐक्टिविटी के कॉन्टेक्स्ट का इस्तेमाल करें.

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

बॉटम शीट फ़्लो बनाना

बॉटम शीट, Credential Manager का इनबिल्ट यूज़र इंटरफ़ेस (यूआई) है. इस यूआई का इस्तेमाल करने से, पुष्टि करने के सभी तरीकों में एक जैसा अनुभव मिलता है. जैसे, पासवर्ड, पासकी, और 'Google से साइन इन करें'.

पहले से अनुमति वाले खातों के लिए, साइन-इन का अनुरोध कॉन्फ़िगर करना

उपयोगकर्ता का Google आईडी टोकन पाने के लिए, GetGoogleIdOption के साथ 'Google से साइन इन करें' सुविधा के लिए अनुरोध करें.

यहां दिए गए स्निपेट से यह पता चलता है कि खाता, अनुमति वाला खाता है या नहीं.

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

val googleIdOption: GetGoogleIdOption = GetGoogleIdOption.Builder()
    .setFilterByAuthorizedAccounts(true)
    .setServerClientId(WEB_CLIENT_ID)
    .setAutoSelectEnabled(true)
    .setNonce(generateSecureRandomNonce())
    .build()

googleIdOption ऑब्जेक्ट के लिए अनुरोध को इस तरह कॉन्फ़िगर किया जाता है:

पहले से अनुमति वाले खातों को फ़िल्टर करना: अनुमति वाले उन खातों को पाने के लिए जिनका इस्तेमाल पहले आपके ऐप्लिकेशन में साइन इन करने के लिए किया गया था, setFilterByAuthorizedAccounts को true पर सेट करें.

ध्यान दें कि setFilterByAuthorizedAccounts की डिफ़ॉल्ट वैल्यू true होती है. इसका मतलब है कि बॉटम शीट यूआई का डिफ़ॉल्ट व्यवहार, पहले से अनुमति वाले खातों को ही दिखाना है.
सर्वर क्लाइंट आईडी सेट करना: setServerClientId पैरामीटर सेट करें. The webClientId वह वेब क्लाइंट आईडी है जिसे आपने ज़रूरी शर्तें पूरी करते समय, अपने Google Cloud Project में OAuth के लिए सेट अप किया था.
अपने-आप साइन-इन होने की सुविधा चालू करना (ज़रूरी नहीं): वापस आने वाले उपयोगकर्ताओं के लिए, अपने-आप साइन-इन होने की सुविधा चालू करने के लिए, setAutoSelectEnabled(true) और setFilterByAuthorizedAccounts(true) का इस्तेमाल करें. अगर आपके ऐप्लिकेशन के उपयोगकर्ता पहले से साइन इन हैं, तो इससे उन्हें बार-बार साइन इन करने की ज़रूरत नहीं पड़ेगी.

अपने-आप साइन-इन होने की सुविधा सिर्फ़ तब काम करती है, जब ये शर्तें पूरी होती हैं:
- डिवाइस पर सिर्फ़ एक अनुमति वाला खाता मौजूद हो और उस अनुमति वाले खाते का इस्तेमाल, पहले डिवाइस पर ऐप्लिकेशन में साइन इन करने के लिए किया गया हो. डिवाइस पर एक से ज़्यादा अनुमति वाले खाते होने पर, अपने-आप साइन-इन होने की सुविधा बंद हो जाती है.
- उपयोगकर्ता ने अपने पिछले सेशन के दौरान, ऐप्लिकेशन से साफ़ तौर पर साइन आउट न किया हो.
- उपयोगकर्ता ने अपनी Google खाते की सेटिंग में, अपने-आप साइन-इन होने की सुविधा बंद न की हो.
नॉनस सेट करना (ज़रूरी नहीं): बेहतर सुरक्षा के लिए, सर्वर-साइड पुष्टि के लिए नॉनस सेट करें. रिप्ले हमलों को रोकने के लिए, setNonce() के साथ सर्वर-साइड पुष्टि के लिए नॉनस शामिल किया जा सकता है. पक्का करें कि आपका सर्वर-साइड कोड, यह पुष्टि करे कि अनुरोध और जवाब के नॉनस एक जैसे हैं.

नॉनस जनरेट करने के लिए, इस तरह का फ़ंक्शन इस्तेमाल करें. यह फ़ंक्शन, तय की गई लंबाई का क्रिप्टोग्राफ़िक तौर पर मज़बूत रैंडम नॉनस जनरेट करता है और उसे Base64 का इस्तेमाल करके एनकोड करता है:

fun generateSecureRandomNonce(byteLength: Int = 32): String {
    val randomBytes = ByteArray(byteLength)
    SecureRandom().nextBytes(randomBytes)
    return Base64.encodeToString(randomBytes, Base64.NO_WRAP or Base64.URL_SAFE or Base64.NO_PADDING)
}

getCredential तरीके को कॉल करके, यह देखें कि उपयोगकर्ता के पास डिवाइस पर अनुमति वाला खाता है या नहीं:

val request: GetCredentialRequest = GetCredentialRequest.Builder()
    .addCredentialOption(googleIdOption)
    .build()

coroutineScope {
    try {
        val result = credentialManager.getCredential(
            request = request,
            context = activityContext,
        )
        handleSignIn(result)
    } catch (e: GetCredentialException) {
        // Handle failures
    }
}

अगर अनुमति वाले खाते उपलब्ध नहीं हैं, तो साइन-इन के अनुरोध को कॉन्फ़िगर करना

अगर डिवाइस पर आपके ऐप्लिकेशन के लिए अनुमति वाले उपयोगकर्ता नहीं हैं, तो CredentialManager, NoCredentialException दिखाता है. ऐसे में, अनुमति वाले खातों के फ़िल्टर को बंद करें, ताकि उपयोगकर्ता साइन अप करने के लिए किसी दूसरे खाते का इस्तेमाल कर सके.

val googleIdOption: GetGoogleIdOption = GetGoogleIdOption.Builder()
    .setFilterByAuthorizedAccounts(false)
    .setServerClientId(WEB_CLIENT_ID)
    .setNonce(generateSecureRandomNonce())
    .build()

इसके बाद, साइन-इन का अनुरोध उसी तरह करें जैसे आपने अनुमति वाले खातों के लिए किया था.

बटन फ़्लो बनाना

अगर आपको यह सुविधा देनी है कि उपयोगकर्ता इन स्थितियों में 'Google से साइन इन करें' बटन का इस्तेमाल कर सकें, तो बटन का इस्तेमाल करें:

उपयोगकर्ता ने Credential Manager बॉटम शीट यूआई को खारिज कर दिया हो.
डिवाइस पर कोई Google खाता न हो.
डिवाइस पर मौजूद खातों की फिर से पुष्टि करनी हो.

बटन यूआई बनाना

इसे Jetpack Compose बटन की मदद से किया जा सकता है. हालांकि, 'Google से साइन इन करें' सुविधा के ब्रैंडिंग से जुड़ी गाइडलाइन वाले पेज से, पहले से मंज़ूरी मिला ब्रैंड आइकॉन इस्तेमाल किया जा सकता है.

Google आईडी टोकन पाने के लिए, GetSignInWithGoogleOption के साथ 'Google से साइन इन करें' सुविधा के लिए अनुरोध करें.

val signInWithGoogleOption: GetSignInWithGoogleOption = GetSignInWithGoogleOption.Builder(
    serverClientId = WEB_CLIENT_ID
).setNonce(generateSecureRandomNonce())
    .build()

इसके बाद, साइन-इन का अनुरोध उसी तरह करें जैसे आपने बॉटम शीट यूआई के लिए किया था.

बॉटम शीट और बटन के लिए, शेयर किया गया साइन-इन फ़ंक्शन बनाना

साइन-इन को मैनेज करने के लिए, यह तरीका अपनाएं:

CredentialManager के getCredential() फ़ंक्शन का इस्तेमाल करें. अगर जवाब सही है, तो CustomCredential को एक्सट्रैक्ट करें. यह GoogleIdTokenCredential.TYPE_GOOGLE_ID_TOKEN_CREDENTIAL टाइप का होना चाहिए.
ऑब्जेक्ट को GoogleIdTokenCredential में बदलें. इसके लिए, GoogleIdTokenCredential.createFrom() तरीके का इस्तेमाल करें.

**ध्यान दें:** अगर कन्वर्ज़न GoogleIdTokenParsingException की वजह से नहीं हो पाता है, तो आपको 'Google से साइन इन करें' सुविधा की लाइब्रेरी का वर्शन अपडेट करना पड़ सकता है.
अपनी रिलाइंग पार्टी के सर्वर पर क्रेडेंशियल की पुष्टि करें.
पक्का करें कि आपने गड़बड़ियों को ठीक से मैनेज किया हो.

ध्यान दें: अपने ऐप्लिकेशन में उपयोगकर्ता को साइन इन करने के लिए, आपको मिले आईडी टोकन पर भरोसा करने से पहले, उस टोकन की पुष्टि करनी होगी. टोकन की पुष्टि करने के लिए, googleIdTokenCredential.getIdToken() को अपने सर्वर पर भेजें. सर्वर-साइड पुष्टि के बारे में ज़्यादा जानने के लिए, अपने सर्वर साइड पर Google आईडी टोकन की पुष्टि करना लेख पढ़ें.

fun handleSign(result: GetCredentialResponse) {
    // Handle the successfully returned credential.
    val credential = result.credential

    when (credential) {
        is CustomCredential -> {
            if (credential.type == GoogleIdTokenCredential.TYPE_GOOGLE_ID_TOKEN_CREDENTIAL) {
                try {
                    // Use googleIdTokenCredential and extract the ID for server-side validation.
                    val googleIdTokenCredential = GoogleIdTokenCredential
                        .createFrom(credential.data)
                } catch (e: GoogleIdTokenParsingException) {
                    Log.e(TAG, "Received an invalid google id token response", e)
                }
            } else {
                // Catch any unrecognized credential type here.
                Log.e(TAG, "Unexpected type of credential")
            }
        }

        else -> {
            // Catch any unrecognized credential type here.
            Log.e(TAG, "Unexpected type of credential")
        }
    }
}

गड़बड़ियों को ठीक करना

समस्या हल करना लेख में बताई गई गड़बड़ियों की समीक्षा करें, ताकि यह पक्का किया जा सके कि आपका कोड, गड़बड़ी की सभी संभावित स्थितियों को मैनेज करता है.

साइन-आउट को मैनेज करना

यह ज़रूरी है कि उपयोगकर्ताओं को आपके ऐप्लिकेशन से साइन आउट करने का विकल्प मिले. उदाहरण के लिए, हो सकता है कि किसी उपयोगकर्ता के पास डिवाइस पर एक से ज़्यादा Google खाते हों और वह किसी दूसरे खाते से साइन इन करना चाहे. यह विकल्प, उदाहरण के लिए, सेटिंग पेज पर दिया जा सकता है.

क्रेडेंशियल की सेवा देने वाली कंपनी, चालू क्रेडेंशियल सेशन को सेव कर सकती है और इसका इस्तेमाल, आने वाले समय में साइन-इन के अनुरोधों के लिए, साइन-इन के विकल्पों को सीमित करने के लिए कर सकती है. उदाहरण के लिए, यह उपलब्ध किसी भी अन्य क्रेडेंशियल के मुकाबले, चालू क्रेडेंशियल को प्राथमिकता दे सकती है.

जब कोई उपयोगकर्ता आपके ऐप्लिकेशन से साइन आउट करता है, तो सभी क्रेडेंशियल की सेवा देने वाली कंपनियों से, मौजूदा उपयोगकर्ता के क्रेडेंशियल की स्थिति को मिटाने के लिए, एपीआई clearCredentialState() तरीके को कॉल करें. इससे, क्रेडेंशियल की सेवा देने वाली सभी कंपनियों को सूचना मिलेगी कि दिए गए ऐप्लिकेशन के लिए सेव किए गए क्रेडेंशियल सेशन को मिटा दिया जाए. इससे, अगली बार उपयोगकर्ताओं को साइन-इन के सभी विकल्प मिलेंगे.