Android पर OpenID Connect का इस्तेमाल करके पुष्टि करें

अगर आपके पास Firebase Authentication with Identity Platform पर अपग्रेड किया गया है, तो इससे अपने उपयोगकर्ताओं की पुष्टि की जा सकती है: आपकी पसंद के हिसाब से बनी, Open Connect (OIDC) कंपनी का इस्तेमाल करने वाला Firebase. यह इससे ऐसे आइडेंटिटी प्रोवाइडर का इस्तेमाल किया जा सकता है जो Firebase में नेटिव तौर पर काम नहीं करता.

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

किसी OIDC कंपनी का इस्तेमाल करके साइन इन करने के लिए, आपको पहले कुछ जानकारी इकट्ठा करनी होगी से ठीक है:

  • Client-ID: सेवा देने वाली कंपनी के लिए यूनीक स्ट्रिंग, जो आपके ऐप्लिकेशन की पहचान करती है. आपका ऐसा हो सकता है कि सेवा देने वाली कंपनी, आपके साथ काम करने वाले हर प्लैटफ़ॉर्म के लिए आपको एक अलग क्लाइंट आईडी असाइन करे. यह आईडी टोकन में aud दावे की वैल्यू में से एक है कंपनी.

  • क्लाइंट सीक्रेट: ऐसी सीक्रेट स्ट्रिंग जिसका इस्तेमाल सेवा देने वाली कंपनी, मालिकाना हक की पुष्टि करने के लिए करती है डालें. हर क्लाइंट आईडी के लिए, आपके पास मैच करने वाला क्लाइंट सीक्रेट होना चाहिए. (यह वैल्यू सिर्फ़ तब ज़रूरी होती है, जब ऑथराइज़ेशन कोड फ़्लो का इस्तेमाल किया जा रहा हो, जो का सुझाव दिया जाता है.)

  • जारी करने वाला: ऐसी स्ट्रिंग जिससे सेवा देने वाली कंपनी की पहचान होती है. यह मान एक URL होना चाहिए जिसे /.well-known/openid-configuration के साथ जोड़े जाने पर, जगह को हटाने का अनुरोध किया है. उदाहरण के लिए, अगर जारी करने वाला https://auth.example.com, खोज से जुड़ा दस्तावेज़ यहां उपलब्ध होना चाहिए https://auth.example.com/.well-known/openid-configuration.

ऊपर दी गई जानकारी मिलने के बाद, साइन इन के तौर पर OpenID Connect को चालू करें कंपनी:

  1. अपने Android प्रोजेक्ट में Firebase जोड़ें.

  2. अगर आपने Firebase Authentication with Identity Platform पर अपग्रेड नहीं किया है, तो ऐसा करें. OpenID Connect से पुष्टि करना केवल अपग्रेड किए गए प्रोजेक्ट में उपलब्ध है.

  3. साइन-इन करने की सुविधा देने वाली कंपनियों पर Firebase कंसोल के पेज पर जाएं, नई कंपनी जोड़ें पर क्लिक करें और फिर OpenID Connect.

  4. चुनें कि आपको ऑथराइज़ेशन कोड फ़्लो का इस्तेमाल करना है या इंप्लिसिट ग्रांट फ़्लो.

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

  5. सेवा देने वाली इस कंपनी को कोई नाम दें. जनरेट किए गए, सेवा देने वाले के आईडी को नोट करें: oidc.example-provider जैसा कुछ. खातों को जोड़ते समय आपको इस आईडी की ज़रूरत होगी अपने ऐप्लिकेशन में साइन-इन कोड डालें.

  6. अपना क्लाइंट आईडी, क्लाइंट सीक्रेट, और सेवा देने वाली कंपनी के जारी करने वाले की स्ट्रिंग के बारे में बताएं. ये वैल्यू, उन वैल्यू से पूरी तरह मेल खानी चाहिए जो आपको सेवा देने वाली कंपनी ने असाइन की हैं.

  7. बदलावों को सेव करें.

Firebase SDK टूल की मदद से साइन-इन की प्रोसेस को मैनेज करना

अगर आपको कोई Android ऐप्लिकेशन बनाना है, तो अपने उपयोगकर्ताओं की पुष्टि करने का सबसे आसान तरीका का इस्तेमाल करते हैं, तो आपके OIDC प्रोवाइडर का इस्तेमाल करके, Firebase के Firebase Android SDK टूल.

Firebase Android SDK टूल की मदद से साइन इन फ़्लो मैनेज करने के लिए, यह तरीका अपनाएं:

  1. OAuthProvider का एक इंस्टेंस बनाने के लिए, इसके बिल्डर का इस्तेमाल सेवा देने वाली कंपनी का आईडी

    Kotlin+KTX 

    val providerBuilder = OAuthProvider.newBuilder("oidc.example-provider")
    GenericIdpActivity.kt

    Java 

    OAuthProvider.Builder providerBuilder = OAuthProvider.newBuilder("oidc.example-provider");
    GenericIdpActivity.java

  2. ज़रूरी नहीं: ऐसे अतिरिक्त कस्टम OAuth पैरामीटर तय करें जिन्हें आपको इस्तेमाल करना है OAuth अनुरोध के साथ भेजें.

    Kotlin+KTX 

    // Target specific email with login hint.
providerBuilder.addCustomParameter("login_hint", "user@example.com")
    GenericIdpActivity.kt

    Java 

    // Target specific email with login hint.
providerBuilder.addCustomParameter("login_hint", "user@example.com");
    GenericIdpActivity.java

    OIDC की सेवा देने वाली कंपनी से संपर्क करके जानें कि वे किन पैरामीटर के साथ काम करते हैं. ध्यान दें कि आप Firebase के लिए ज़रूरी पैरामीटर को setCustomParameters(). ये पैरामीटर client_id हैं, response_type, redirect_uri, राज्य, स्कोप, और response_mode का इस्तेमाल नहीं किया जा सकेगा.

  3. ज़रूरी नहीं: बेसिक प्रोफ़ाइल के अलावा, OAuth 2.0 के अन्य दायरे तय करें. पुष्टि करने की सेवा देने वाली कंपनी से अनुरोध करें.

    Kotlin+KTX 

    // Request read access to a user's email addresses.
// This must be preconfigured in the app's API permissions.
providerBuilder.scopes = listOf("mail.read", "calendars.read")
    GenericIdpActivity.kt

    Java 

    // Request read access to a user's email addresses.
// This must be preconfigured in the app's API permissions.
List<String> scopes =
        new ArrayList<String>() {
            {
                add("mail.read");
                add("calendars.read");
            }
        };
providerBuilder.setScopes(scopes);
    GenericIdpActivity.java

    OIDC की सेवा देने वाली कंपनी से पता करें कि वह किन दायरों का इस्तेमाल करता है.

  4. OAuth प्रोवाइडर ऑब्जेक्ट का इस्तेमाल करके, Firebase से पुष्टि करें. ध्यान दें कि नापसंद अन्य FirebaseAuth कार्रवाइयों के लिए, यह पॉप-अप विंडो में पॉप-अप करके आपके यूज़र इंटरफ़ेस (यूआई) को कंट्रोल करेगा कस्टम Chrome टैब. इस वजह से, OnSuccessListener में अपनी गतिविधि का रेफ़रंस न दें और OnFailureListener को अटैचमेंट के तौर पर इस्तेमाल करें, ताकि वे तुरंत अलग हो जाएं तो कार्रवाई यूज़र इंटरफ़ेस (यूआई) शुरू करती है.

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

    यह देखने के लिए कि कोई नतीजा फ़ेच किया गया है या नहीं, getPendingAuthResult पर कॉल करें:

    Kotlin+KTX 

    val pendingResultTask = firebaseAuth.pendingAuthResult
if (pendingResultTask != null) {
    // There's something already here! Finish the sign-in for your user.
    pendingResultTask
        .addOnSuccessListener {
            // User is signed in.
            // IdP data available in
            // authResult.getAdditionalUserInfo().getProfile().
            // The OAuth access token can also be retrieved:
            // ((OAuthCredential)authResult.getCredential()).getAccessToken().
            // The OAuth secret can be retrieved by calling:
            // ((OAuthCredential)authResult.getCredential()).getSecret().
        }
        .addOnFailureListener {
            // Handle failure.
        }
} else {
    // There's no pending result so you need to start the sign-in flow.
    // See below.
}
    GenericIdpActivity.kt

    Java 

    Task<AuthResult> pendingResultTask = firebaseAuth.getPendingAuthResult();
if (pendingResultTask != null) {
    // There's something already here! Finish the sign-in for your user.
    pendingResultTask
            .addOnSuccessListener(
                    new OnSuccessListener<AuthResult>() {
                        @Override
                        public void onSuccess(AuthResult authResult) {
                            // User is signed in.
                            // IdP data available in
                            // authResult.getAdditionalUserInfo().getProfile().
                            // The OAuth access token can also be retrieved:
                            // ((OAuthCredential)authResult.getCredential()).getAccessToken().
                            // The OAuth secret can be retrieved by calling:
                            // ((OAuthCredential)authResult.getCredential()).getSecret().
                        }
                    })
            .addOnFailureListener(
                    new OnFailureListener() {
                        @Override
                        public void onFailure(@NonNull Exception e) {
                            // Handle failure.
                        }
                    });
} else {
    // There's no pending result so you need to start the sign-in flow.
    // See below.
}
    GenericIdpActivity.java

    साइन इन फ़्लो शुरू करने के लिए, startActivityForSignInWithProvider को कॉल करें:

    Kotlin+KTX 

    firebaseAuth
    .startActivityForSignInWithProvider(activity, provider.build())
    .addOnSuccessListener {
        // User is signed in.
        // IdP data available in
        // authResult.getAdditionalUserInfo().getProfile().
        // The OAuth access token can also be retrieved:
        // ((OAuthCredential)authResult.getCredential()).getAccessToken().
        // The OAuth secret can be retrieved by calling:
        // ((OAuthCredential)authResult.getCredential()).getSecret().
    }
    .addOnFailureListener {
        // Handle failure.
    }
    GenericIdpActivity.kt

    Java 

    firebaseAuth
        .startActivityForSignInWithProvider(/* activity= */ this, provider.build())
        .addOnSuccessListener(
                new OnSuccessListener<AuthResult>() {
                    @Override
                    public void onSuccess(AuthResult authResult) {
                        // User is signed in.
                        // IdP data available in
                        // authResult.getAdditionalUserInfo().getProfile().
                        // The OAuth access token can also be retrieved:
                        // ((OAuthCredential)authResult.getCredential()).getAccessToken().
                        // The OAuth secret can be retrieved by calling:
                        // ((OAuthCredential)authResult.getCredential()).getSecret().
                    }
                })
        .addOnFailureListener(
                new OnFailureListener() {
                    @Override
                    public void onFailure(@NonNull Exception e) {
                        // Handle failure.
                    }
                });
    GenericIdpActivity.java

  5. ऊपर दिए गए उदाहरण, साइन-इन करने के फ़्लो पर फ़ोकस करते हैं. हालांकि, आपके पास इसका इस्तेमाल करके, OIDC की सेवा देने वाली कंपनी को किसी मौजूदा उपयोगकर्ता से लिंक करने की सुविधा startActivityForLinkWithProvider. उदाहरण के लिए, आप एक से ज़्यादा साथ ही, साइन इन करने के लिए भी एक ही उपयोगकर्ता को अनुमति देनी होगी.

    Kotlin+KTX 

    // The user is already signed-in.
val firebaseUser = firebaseAuth.currentUser!!
firebaseUser
    .startActivityForLinkWithProvider(activity, provider.build())
    .addOnSuccessListener {
        // Provider credential is linked to the current user.
        // IdP data available in
        // authResult.getAdditionalUserInfo().getProfile().
        // The OAuth access token can also be retrieved:
        // authResult.getCredential().getAccessToken().
        // The OAuth secret can be retrieved by calling:
        // authResult.getCredential().getSecret().
    }
    .addOnFailureListener {
        // Handle failure.
    }
    GenericIdpActivity.kt

    Java 

    // The user is already signed-in.
FirebaseUser firebaseUser = firebaseAuth.getCurrentUser();

firebaseUser
        .startActivityForLinkWithProvider(/* activity= */ this, provider.build())
        .addOnSuccessListener(
                new OnSuccessListener<AuthResult>() {
                    @Override
                    public void onSuccess(AuthResult authResult) {
                        // Provider credential is linked to the current user.
                        // IdP data available in
                        // authResult.getAdditionalUserInfo().getProfile().
                        // The OAuth access token can also be retrieved:
                        // authResult.getCredential().getAccessToken().
                        // The OAuth secret can be retrieved by calling:
                        // authResult.getCredential().getSecret().
                    }
                })
        .addOnFailureListener(
                new OnFailureListener() {
                    @Override
                    public void onFailure(@NonNull Exception e) {
                        // Handle failure.
                    }
                });
    GenericIdpActivity.java

  6. एक ही पैटर्न का इस्तेमाल इनके साथ किया जा सकता है startActivityForReauthenticateWithProvider, जिसका इस्तेमाल वापस पाने के लिए किया जा सकता है संवेदनशील कार्रवाइयों के लिए नए क्रेडेंशियल, जिनमें हाल ही में लॉगिन करने की ज़रूरत होती है.

    Kotlin+KTX 

    // The user is already signed-in.
val firebaseUser = firebaseAuth.currentUser!!
firebaseUser
    .startActivityForReauthenticateWithProvider(activity, provider.build())
    .addOnSuccessListener {
        // User is re-authenticated with fresh tokens and
        // should be able to perform sensitive operations
        // like account deletion and email or password
        // update.
    }
    .addOnFailureListener {
        // Handle failure.
    }
    GenericIdpActivity.kt

    Java 

    // The user is already signed-in.
FirebaseUser firebaseUser = firebaseAuth.getCurrentUser();

firebaseUser
        .startActivityForReauthenticateWithProvider(/* activity= */ this, provider.build())
        .addOnSuccessListener(
                new OnSuccessListener<AuthResult>() {
                    @Override
                    public void onSuccess(AuthResult authResult) {
                        // User is re-authenticated with fresh tokens and
                        // should be able to perform sensitive operations
                        // like account deletion and email or password
                        // update.
                    }
                })
        .addOnFailureListener(
                new OnFailureListener() {
                    @Override
                    public void onFailure(@NonNull Exception e) {
                        // Handle failure.
                    }
                });
    GenericIdpActivity.java

साइन-इन की प्रोसेस को मैन्युअल तरीके से मैनेज करना

अगर आपने अपने ऐप्लिकेशन में, Open Connect का साइन इन करने का फ़्लो पहले ही लागू कर दिया है, तो Firebase से पुष्टि करने के लिए, सीधे आईडी टोकन का इस्तेमाल कर सकते हैं:

Kotlin+KTX 

val providerId = "oidc.example-provider" // As registered in Firebase console.
val credential = oAuthCredential(providerId) {
    setIdToken(idToken) // ID token from OpenID Connect flow.
}
Firebase.auth
    .signInWithCredential(credential)
    .addOnSuccessListener { authResult ->
        // User is signed in.

        // IdP data available in:
        //    authResult.additionalUserInfo.profile
    }
    .addOnFailureListener { e ->
        // Handle failure.
    }
GenericIdpActivity.kt

Java 

AuthCredential credential = OAuthProvider
        .newCredentialBuilder("oidc.example-provider")  // As registered in Firebase console.
        .setIdToken(idToken)  // ID token from OpenID Connect flow.
        .build();
FirebaseAuth.getInstance()
        .signInWithCredential(credential)
        .addOnSuccessListener(new OnSuccessListener<AuthResult>() {
            @Override
            public void onSuccess(AuthResult authResult) {
                // User is signed in.

                // IdP data available in:
                //    authResult.getAdditionalUserInfo().getProfile()
            }
        })
        .addOnFailureListener(new OnFailureListener() {
            @Override
            public void onFailure(@NonNull Exception e) {
                // Handle failure.
            }
        });
GenericIdpActivity.java

अगले चरण

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

  • अपने ऐप्लिकेशन में, उपयोगकर्ता की बुनियादी प्रोफ़ाइल जानकारी को FirebaseUser ऑब्जेक्ट. देखें उपयोगकर्ताओं को मैनेज करना.

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

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

उपयोगकर्ता को साइन आउट करने के लिए पर कॉल करें signOut:

Kotlin+KTX

Firebase.auth.signOut()
MainActivity.kt

Java

FirebaseAuth.getInstance().signOut();
MainActivity.java