Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Android पर Google से पुष्टि करें

आपके पास यह विकल्प होता है कि उपयोगकर्ता अपने Google खातों का इस्तेमाल करके, Firebase से पुष्टि कर सकें.

शुरू करने से पहले

अगर आपने पहले से ही A/B टेस्टिंग नहीं बनाई है, तो अपने Android प्रोजेक्ट में Firebase जोड़ें.
अपने मॉड्यूल (ऐप्लिकेशन-लेवल) की Gradle फ़ाइल (आम तौर पर, <project>/<app-module>/build.gradle.kts या <project>/<app-module>/build.gradle), में, Android के लिए Firebase Authentication लाइब्रेरी की डिपेंडेंसी जोड़ें. हमारा सुझाव है कि लाइब्रेरी के वर्शन को कंट्रोल करने के लिए, Firebase Android BoM का इस्तेमाल करें.

इसके अलावा, Firebase Authentication सेट अप करने के लिए, आपको अपने ऐप्लिकेशन में Credential Manager SDK टूल जोड़ना होगा.
```
dependencies {
    // Import the BoM for the Firebase platform
    implementation(platform("com.google.firebase:firebase-bom:34.12.0"))

    // Add the dependency for the Firebase Authentication library
    // When using the BoM, you don't specify versions in Firebase library dependencies
    implementation("com.google.firebase:firebase-auth")

    // Also add the dependencies for the Credential Manager libraries and specify their versions
    implementation("androidx.credentials:credentials:1.3.0")
    implementation("androidx.credentials:credentials-play-services-auth:1.3.0")
    implementation("com.google.android.libraries.identity.googleid:googleid:1.1.1")
}
```
Firebase Android BoM का इस्तेमाल करने पर, आपका ऐप्लिकेशन हमेशा Firebase Android लाइब्रेरी के ऐसे वर्शन का इस्तेमाल करेगा जो एक-दूसरे के साथ काम करते हैं.
(दूसरा तरीका) BoM का इस्तेमाल किए बिना, Firebase लाइब्रेरी की डिपेंडेंसी जोड़नाBoM

अगर Firebase BoM का इस्तेमाल नहीं किया जाता है, तो आपको हर Firebase लाइब्रेरी का वर्शन उसकी डिपेंडेंसी लाइन में बताना होगा.

ध्यान दें कि अगर आपके ऐप्लिकेशन में एक से ज़्यादा Firebase लाइब्रेरी का इस्तेमाल किया जाता है, तो हमारा सुझाव है कि लाइब्रेरी के वर्शन मैनेज करने के लिए, BoM का इस्तेमाल करें. इससे यह पक्का होता है कि सभी वर्शन एक-दूसरे के साथ काम करते हैं.
```
dependencies {
    // Add the dependency for the Firebase Authentication library
    // When NOT using the BoM, you must specify versions in Firebase library dependencies
    implementation("com.google.firebase:firebase-auth:24.0.1")

    // Also add the dependencies for the Credential Manager libraries and specify their versions
    implementation("androidx.credentials:credentials:1.3.0")
    implementation("androidx.credentials:credentials-play-services-auth:1.3.0")
    implementation("com.google.android.libraries.identity.googleid:googleid:1.1.1")
}
```
अगर आपने अब तक अपने ऐप्लिकेशन का SHA फ़िंगरप्रिंट नहीं बताया है, तो सेटिंग पेज पर जाकर ऐसा करें.Firebase अपने ऐप्लिकेशन का SHA फ़िंगरप्रिंट पाने के तरीके के बारे में जानने के लिए, क्लाइंट की पुष्टि करना लेख पढ़ें.
Firebase कंसोल में, Google को साइन-इन करने के तरीके के तौर पर चालू करें:
1. Firebase Firebase कंसोल में, Auth सेक्शन खोलें.
2. साइन-इन करने का तरीका टैब पर, Google से साइन-इन करने का तरीका चालू करें और सेव करें पर क्लिक करें.
अहम जानकारी: अगर आपको Firebase CLI का इस्तेमाल करना है, तो पुष्टि करने वाले प्रोवाइडर को कॉन्फ़िगर करने के लिए firebase init auth चलाएं. इसके बाद, अपने प्रोजेक्ट में बदलाव लागू करने के लिए firebase deploy --only auth चलाएं.
कंसोल में पूछे जाने पर, अपडेट की गई Firebase कॉन्फ़िगरेशन फ़ाइल (google-services.json) डाउनलोड करें. इसमें अब Google से साइन-इन करने के लिए ज़रूरी OAuth क्लाइंट की जानकारी शामिल है.
अपडेट की गई इस कॉन्फ़िगरेशन फ़ाइल को अपने Android Studio प्रोजेक्ट में ले जाएं. साथ ही, इसकी जगह, अब पुरानी हो चुकी कॉन्फ़िगरेशन फ़ाइल को हटा दें. (कृपया अपने Android प्रोजेक्ट में Firebase जोड़ना देखें.)

Firebase से पुष्टि करना

Credential Manager के दस्तावेज़ में दिए गए चरणों को पूरा करके, अपने ऐप्लिकेशन में 'Google से साइन इन करें' सुविधा को इंटिग्रेट करें. यहां सामान्य निर्देश दिए गए हैं:

GetGoogleIdOption का इस्तेमाल करके, Google से साइन इन करने का अनुरोध शुरू करें. इसके बाद, Credential Manager अनुरोध बनाने के लिए GetCredentialRequest का इस्तेमाल करें:

Kotlin

// Instantiate a Google sign-in request
val googleIdOption = GetGoogleIdOption.Builder()
    // Your server's client ID, not your Android client ID.
    .setServerClientId(getString(R.string.default_web_client_id))
    // Only show accounts previously used to sign in.
    .setFilterByAuthorizedAccounts(true)
    .build()

// Create the Credential Manager request
val request = GetCredentialRequest.Builder()
    .addCredentialOption(googleIdOption)
    .build()GoogleSignInActivity.kt

Java

// Instantiate a Google sign-in request
GetGoogleIdOption googleIdOption = new GetGoogleIdOption.Builder()
        .setFilterByAuthorizedAccounts(true)
        .setServerClientId(getString(R.string.default_web_client_id))
        .build();

// Create the Credential Manager request
GetCredentialRequest request = new GetCredentialRequest.Builder()
        .addCredentialOption(googleIdOption)
        .build();GoogleSignInActivity.java

ऊपर दिए गए अनुरोध में, आपको "सर्वर" क्लाइंट आईडी को setServerClientId तरीके में पास करना होगा. OAuth 2.0 क्लाइंट आईडी ढूंढने के लिए:

Google Cloud कंसोल में, क्रेडेंशियल पेज खोलें.
The Web application type client ID is your backend server's OAuth 2.0 client ID.

पक्का करें कि 'Google से साइन इन करें' सुविधा को इंटिग्रेट करने के बाद, आपकी साइन-इन गतिविधि में, इस तरह का कोड हो:

Kotlin

private fun handleSignIn(credential: Credential) {
    // Check if credential is of type Google ID
    if (credential is CustomCredential && credential.type == TYPE_GOOGLE_ID_TOKEN_CREDENTIAL) {
        // Create Google ID Token
        val googleIdTokenCredential = GoogleIdTokenCredential.createFrom(credential.data)

        // Sign in to Firebase with using the token
        firebaseAuthWithGoogle(googleIdTokenCredential.idToken)
    } else {
        Log.w(TAG, "Credential is not of type Google ID!")
    }
}GoogleSignInActivity.kt

Java

private void handleSignIn(Credential credential) {
    // Check if credential is of type Google ID
    if (credential instanceof CustomCredential customCredential
            && credential.getType().equals(TYPE_GOOGLE_ID_TOKEN_CREDENTIAL)) {
        // Create Google ID Token
        Bundle credentialData = customCredential.getData();
        GoogleIdTokenCredential googleIdTokenCredential = GoogleIdTokenCredential.createFrom(credentialData);

        // Sign in to Firebase with using the token
        firebaseAuthWithGoogle(googleIdTokenCredential.getIdToken());
    } else {
        Log.w(TAG, "Credential is not of type Google ID!");
    }
}GoogleSignInActivity.java

अपनी साइन-इन गतिविधि के onCreate तरीके में, FirebaseAuth ऑब्जेक्ट का शेयर किया गया इंस्टेंस पाएं:

Kotlin

private lateinit var auth: FirebaseAuth
// ...
// Initialize Firebase Auth
auth = Firebase.authGoogleSignInActivity.kt

Java

private FirebaseAuth mAuth;
// ...
// Initialize Firebase Auth
mAuth = FirebaseAuth.getInstance();GoogleSignInActivity.java

अपनी गतिविधि शुरू करते समय, देखें कि उपयोगकर्ता फ़िलहाल साइन इन है या नहीं:

Kotlin

override fun onStart() {
    super.onStart()
    // Check if user is signed in (non-null) and update UI accordingly.
    val currentUser = auth.currentUser
    updateUI(currentUser)
}GoogleSignInActivity.kt

Java

@Override
public void onStart() {
    super.onStart();
    // Check if user is signed in (non-null) and update UI accordingly.
    FirebaseUser currentUser = mAuth.getCurrentUser();
    updateUI(currentUser);
}GoogleSignInActivity.java

अब पहले चरण में बनाया गया, उपयोगकर्ता का Google आईडी टोकन पाएं. इसके बाद, इसे Firebase क्रेडेंशियल के लिए बदलें. साथ ही, Firebase क्रेडेंशियल का इस्तेमाल करके, Firebase से पुष्टि करें:

Kotlin

private fun firebaseAuthWithGoogle(idToken: String) {
    val credential = GoogleAuthProvider.getCredential(idToken, null)
    auth.signInWithCredential(credential)
        .addOnCompleteListener(this) { task ->
            if (task.isSuccessful) {
                // Sign in success, update UI with the signed-in user's information
                Log.d(TAG, "signInWithCredential:success")
                val user = auth.currentUser
                updateUI(user)
            } else {
                // If sign in fails, display a message to the user
                Log.w(TAG, "signInWithCredential:failure", task.exception)
                updateUI(null)
            }
        }
}GoogleSignInActivity.kt

Java

private void firebaseAuthWithGoogle(String idToken) {
    AuthCredential credential = GoogleAuthProvider.getCredential(idToken, null);
    mAuth.signInWithCredential(credential)
            .addOnCompleteListener(this, task -> {
                if (task.isSuccessful()) {
                    // Sign in success, update UI with the signed-in user's information
                    Log.d(TAG, "signInWithCredential:success");
                    FirebaseUser user = mAuth.getCurrentUser();
                    updateUI(user);
                } else {
                    // If sign in fails, display a message to the user
                    Log.w(TAG, "signInWithCredential:failure", task.getException());
                    updateUI(null);
                }
            });
}GoogleSignInActivity.java

अगर signInWithCredential को कॉल करने की प्रोसेस पूरी हो जाती है, तो उपयोगकर्ता के खाते का डेटा पाने के लिए, getCurrentUser तरीके का इस्तेमाल किया जा सकता है.

अगले चरण

जब कोई उपयोगकर्ता पहली बार साइन इन करता है, तो एक नया उपयोगकर्ता खाता बनता है. यह खाता, उन क्रेडेंशियल से लिंक होता है जिनका इस्तेमाल करके उपयोगकर्ता ने साइन इन किया है. जैसे, उपयोगकर्ता नाम और पासवर्ड, फ़ोन नंबर या पुष्टि करने वाले प्रोवाइडर की जानकारी. यह नया खाता, आपके Firebase प्रोजेक्ट के हिस्से के तौर पर सेव होता है. इसका इस्तेमाल, आपके प्रोजेक्ट में मौजूद हर ऐप्लिकेशन में किसी उपयोगकर्ता की पहचान करने के लिए किया जा सकता है. भले ही, उपयोगकर्ता किसी भी तरीके से साइन इन करे.

अपने ऐप्लिकेशन में, उपयोगकर्ता की बुनियादी प्रोफ़ाइल की जानकारी FirebaseUser ऑब्जेक्ट से पाई जा सकती है. उपयोगकर्ताओं को मैनेज करना लेख पढ़ें.
अपने Firebase Realtime Database और Cloud Storage सुरक्षा नियमों में, आप साइन-इन किए हुए उपयोगकर्ता का यूनीक उपयोगकर्ता आईडी auth वैरिएबल से पा सकते हैं. इसका इस्तेमाल, यह कंट्रोल करने के लिए किया जा सकता है कि कोई उपयोगकर्ता किस डेटा को ऐक्सेस कर सकता है.

आपके पास यह विकल्प होता है कि उपयोगकर्ताओं को पुष्टि करने वाले एक से ज़्यादा authentication providers का इस्तेमाल करके, अपने ऐप्लिकेशन में साइन इन करने की अनुमति दी जा सके. इसके लिए, पुष्टि करने वाले प्रोवाइडर के क्रेडेंशियल को किसी existing user account से लिंक करना होगा.

किसी उपयोगकर्ता को साइन आउट करने के लिए, signOut को कॉल करें. आपको सभी क्रेडेंशियल प्रोवाइडर से, मौजूदा उपयोगकर्ता के क्रेडेंशियल की स्थिति भी साफ़ करनी होगी. Credential Manager के दस्तावेज़ में ऐसा करने का सुझाव दिया गया है:

Kotlin

private fun signOut() {
    // Firebase sign out
    auth.signOut()

    // When a user signs out, clear the current user credential state from all credential providers.
    lifecycleScope.launch {
        try {
            val clearRequest = ClearCredentialStateRequest()
            credentialManager.clearCredentialState(clearRequest)
            updateUI(null)
        } catch (e: ClearCredentialException) {
            Log.e(TAG, "Couldn't clear user credentials: ${e.localizedMessage}")
        }
    }
}GoogleSignInActivity.kt

Java

private void signOut() {
    // Firebase sign out
    mAuth.signOut();

    // When a user signs out, clear the current user credential state from all credential providers.
    ClearCredentialStateRequest clearRequest = new ClearCredentialStateRequest();
    credentialManager.clearCredentialStateAsync(
            clearRequest,
            new CancellationSignal(),
            Executors.newSingleThreadExecutor(),
            new CredentialManagerCallback<>() {
                @Override
                public void onResult(@NonNull Void result) {
                    updateUI(null);
                }

                @Override
                public void onError(@NonNull ClearCredentialException e) {
                    Log.e(TAG, "Couldn't clear user credentials: " + e.getLocalizedMessage());
                }
            });
}GoogleSignInActivity.java