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

Firebase SDK टूल का इस्तेमाल करके, अपने उपयोगकर्ताओं को Apple आईडी की मदद से Firebase में पुष्टि करने की अनुमति दी जा सकती है. इसके लिए, OAuth 2.0 के साइन-इन फ़्लो को एंड-टू-एंड लागू करना होगा.

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

Apple का इस्तेमाल करके उपयोगकर्ताओं को साइन इन करने की अनुमति देने के लिए, सबसे पहले Apple की डेवलपर साइट पर 'Apple से साइन इन करें' सुविधा कॉन्फ़िगर करें. इसके बाद, अपने Firebase प्रोजेक्ट के लिए, Apple को साइन-इन करने की सुविधा देने वाले प्रोवाइडर के तौर पर चालू करें.

Apple Developer Program में शामिल होना

Apple Developer Program के सदस्य ही, 'Apple से साइन इन करें' सुविधा को कॉन्फ़िगर कर सकते हैं.

'Apple से साइन इन करें' सुविधा को कॉन्फ़िगर करना

Apple की Apple Developer साइट पर, यह काम करें:

  1. अपनी वेबसाइट को अपने ऐप्लिकेशन से जोड़ें. इसके लिए, वेब के लिए 'Apple से साइन इन करें' सुविधा को कॉन्फ़िगर करें लेख का पहला सेक्शन देखें. प्रॉम्प्ट मिलने पर, इस यूआरएल को रिटर्न यूआरएल के तौर पर रजिस्टर करें:

    https://YOUR_FIREBASE_PROJECT_ID.firebaseapp.com/__/auth/handler

    Firebase कंसोल की सेटिंग सेटिंग > सामान्य टैब में, आपको अपना Firebase प्रोजेक्ट आईडी मिल सकता है.Firebase

    इसके बाद, अपने नए सर्विस आईडी को नोट करें. इसकी ज़रूरत अगले सेक्शन में पड़ेगी.

  2. 'Apple से साइन इन करें' सुविधा के लिए, निजी कुंजी बनाएं. अगले सेक्शन में, आपको अपनी नई निजी कुंजी और कुंजी आईडी की ज़रूरत पड़ेगी.

  3. अगर Firebase Authentication की किसी ऐसी सुविधा का इस्तेमाल किया जाता है जिससे उपयोगकर्ताओं को ईमेल भेजे जाते हैं, तो Apple की निजी ईमेल रिले सेवा को कॉन्फ़िगर करें. साथ ही, noreply@YOUR_FIREBASE_PROJECT_ID.firebaseapp.com (या अपने हिसाब से बनाए गए ईमेल टेंप्लेट का डोमेन) रजिस्टर करें. ऐसा करने से, Apple, Firebase Authentication से भेजे गए ईमेल को, Apple के गुमनाम ईमेल पतों पर रिले कर पाएगा. इन सुविधाओं में, ईमेल लिंक से साइन इन करना, ईमेल पते की पुष्टि करना, खाता बदलने की अनुमति वापस लेना वगैरह शामिल हैं.

Apple को साइन-इन करने की सुविधा देने वाले प्रोवाइडर के तौर पर चालू करना

  1. अपने Android प्रोजेक्ट में Firebase जोड़ें.
  2. अगर आपने पहले से अपने ऐप्लिकेशन का SHA-1 फ़िंगरप्रिंट नहीं बताया है, तो उसे बताएं.
    1. Firebase कंसोल में, सेटिंग सेटिंग > सामान्य टैब पर जाएं.
    2. नीचे की ओर स्क्रोल करके, आपके ऐप्लिकेशन कार्ड पर जाएं. इसके बाद, अपना Android ऐप्लिकेशन चुनें और SHA सर्टिफ़िकेट के फ़िंगरप्रिंट फ़ील्ड में अपना SHA-1 फ़िंगरप्रिंट जोड़ें.
  3. Firebase कंसोल में, सुरक्षा > पुष्टि करना पर जाएं.
  4. साइन-इन करने का तरीका टैब में, Apple को साइन-इन करने की सुविधा देने वाले प्रोवाइडर के तौर पर चालू करें. पिछले सेक्शन में बनाया गया सर्विस आईडी डालें. इसके अलावा, OAuth कोड फ़्लो कॉन्फ़िगरेशन सेक्शन में, अपना Apple टीम आईडी और पिछले सेक्शन में बनाई गई निजी कुंजी और कुंजी आईडी डालें.

Apple के गुमनाम डेटा से जुड़ी ज़रूरी शर्तों का पालन करना

'Apple से साइन इन करें' सुविधा, उपयोगकर्ताओं को साइन इन करते समय अपना डेटा गुमनाम करने का विकल्प देती है. इसमें उनका ईमेल पता भी शामिल है. इस विकल्प को चुनने वाले उपयोगकर्ताओं के ईमेल पते में, privaterelay.appleid.com डोमेन होता है. अपने ऐप्लिकेशन में 'Apple से साइन इन करें' सुविधा का इस्तेमाल करते समय, आपको Apple की डेवलपर नीतियों या इन गुमनाम Apple आईडी से जुड़ी शर्तों का पालन करना होगा.

इसमें, सीधे तौर पर पहचान करने वाली निजी जानकारी को गुमनाम Apple आईडी से जोड़ने से पहले, उपयोगकर्ता की ज़रूरी सहमति लेना शामिल है. Firebase से पुष्टि करने की सुविधा का इस्तेमाल करते समय, इसमें ये कार्रवाइयां शामिल हो सकती हैं:

  • किसी ईमेल पते को गुमनाम Apple आईडी से लिंक करना या इसके उलट.
  • किसी फ़ोन नंबर को गुमनाम Apple आईडी से लिंक करना या इसके उलट
  • किसी गैर-गुमनाम सोशल क्रेडेंशियल (Facebook, Google वगैरह) को एक गुमनाम Apple आईडी से लिंक करना या इसके उलट.

ऊपर दी गई सूची पूरी नहीं है. पक्का करें कि आपका ऐप्लिकेशन, Apple की ज़रूरी शर्तें पूरी करता हो. इसके लिए, अपने डेवलपर खाते के सदस्यता सेक्शन में, Apple Developer Program के लाइसेंस समझौते को देखें.

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

Android पर, Apple खातों का इस्तेमाल करके अपने उपयोगकर्ताओं की पुष्टि करने का सबसे आसान तरीका यह है कि Firebase Android SDK टूल की मदद से, पूरे साइन-इन फ़्लो को मैनेज किया जाए.

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

  1. OAuthProvider का कोई इंस्टेंस बनाएं. इसके लिए, बिल्डर का इस्तेमाल करें. साथ ही, प्रोवाइडर आईडी apple.com का इस्तेमाल करें:

    Kotlin 

    val provider = OAuthProvider.newBuilder("apple.com")

    Java 

    OAuthProvider.Builder provider = OAuthProvider.newBuilder("apple.com");

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

    Kotlin 

    provider.setScopes(arrayOf("email", "name"))

    Java 

    List<String> scopes =
    new ArrayList<String>() {
      {
        add("email");
        add("name");
      }
    };
provider.setScopes(scopes);

    डिफ़ॉल्ट रूप से, हर ईमेल पते के लिए एक खाता चालू होने पर, Firebase, ईमेल और नाम के दायरों के लिए अनुरोध करता है. अगर इस सेटिंग को हर ईमेल पते के लिए कई खाते पर सेट किया जाता है, तो Firebase, Apple से किसी भी दायरे के लिए अनुरोध नहीं करता. हालांकि, अगर आपने दायरे तय किए हैं, तो Firebase, Apple से उन दायरों के लिए अनुरोध करेगा.

  3. ज़रूरी नहीं: अगर आपको Apple की साइन-इन स्क्रीन को अंग्रेज़ी के अलावा किसी दूसरी भाषा में दिखाना है, तो locale पैरामीटर सेट करें. काम करने वाली भाषाओं के बारे में जानने के लिए, 'Apple से साइन इन करें' सुविधा के दस्तावेज़ देखें.

    Kotlin 

    // Localize the Apple authentication screen in French.
provider.addCustomParameter("locale", "fr")

    Java 

    // Localize the Apple authentication screen in French.
provider.addCustomParameter("locale", "fr");

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

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

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

    Kotlin 

    val pending = auth.pendingAuthResult
if (pending != null) {
    pending.addOnSuccessListener { authResult ->
        Log.d(TAG, "checkPending:onSuccess:$authResult")
        // Get the user profile with authResult.getUser() and
        // authResult.getAdditionalUserInfo(), and the ID
        // token from Apple with authResult.getCredential().
    }.addOnFailureListener { e ->
        Log.w(TAG, "checkPending:onFailure", e)
    }
} else {
    Log.d(TAG, "pending: null")
}

    Java 

    mAuth = FirebaseAuth.getInstance();
Task<AuthResult> pending = mAuth.getPendingAuthResult();
if (pending != null) {
    pending.addOnSuccessListener(new OnSuccessListener<AuthResult>() {
        @Override
        public void onSuccess(AuthResult authResult) {
            Log.d(TAG, "checkPending:onSuccess:" + authResult);
            // Get the user profile with authResult.getUser() and
            // authResult.getAdditionalUserInfo(), and the ID
            // token from Apple with authResult.getCredential().
        }
    }).addOnFailureListener(new OnFailureListener() {
        @Override
        public void onFailure(@NonNull Exception e) {
            Log.w(TAG, "checkPending:onFailure", e);
        }
    });
} else {
    Log.d(TAG, "pending: null");
}

    अगर कोई नतीजा पेंडिंग नहीं है, तो startActivityForSignInWithProvider() को कॉल करके, साइन इन फ़्लो शुरू करें:

    Kotlin 

    auth.startActivityForSignInWithProvider(this, provider.build())
        .addOnSuccessListener { authResult ->
            // Sign-in successful!
            Log.d(TAG, "activitySignIn:onSuccess:${authResult.user}")
            val user = authResult.user
            // ...
        }
        .addOnFailureListener { e ->
            Log.w(TAG, "activitySignIn:onFailure", e)
        }

    Java 

    mAuth.startActivityForSignInWithProvider(this, provider.build())
        .addOnSuccessListener(
                new OnSuccessListener<AuthResult>() {
                    @Override
                    public void onSuccess(AuthResult authResult) {
                        // Sign-in successful!
                        Log.d(TAG, "activitySignIn:onSuccess:" + authResult.getUser());
                        FirebaseUser user = authResult.getUser();
                        // ...
                    }
                })
        .addOnFailureListener(
                new OnFailureListener() {
                    @Override
                    public void onFailure(@NonNull Exception e) {
                        Log.w(TAG, "activitySignIn:onFailure", e);
                    }
                });

    Firebase Auth के साथ काम करने वाले अन्य प्रोवाइडर के उलट, Apple, फ़ोटो का यूआरएल उपलब्ध नहीं कराता.

    इसके अलावा, जब उपयोगकर्ता अपना ईमेल पता ऐप्लिकेशन के साथ शेयर नहीं करता है, तो Apple उस उपयोगकर्ता के लिए एक यूनीक ईमेल पता (जैसे, xyz@privaterelay.appleid.com) उपलब्ध कराता है. यह ईमेल पता, आपके ऐप्लिकेशन के साथ शेयर किया जाता है. अगर आपने निजी ईमेल रिले सेवा को कॉन्फ़िगर किया है, तो Apple, गुमनाम पते पर भेजे गए ईमेल को उपयोगकर्ता के असली ईमेल पते पर फ़ॉरवर्ड करता है.

    Apple, उपयोगकर्ता की जानकारी सिर्फ़ पहली बार साइन इन करने पर, ऐप्लिकेशन के साथ शेयर करता है. जैसे, डिसप्ले नेम. आम तौर पर, Firebase, Apple से पहली बार साइन इन करने पर, डिसप्ले नेम को सेव करता है. इसे getCurrentUser().getDisplayName() की मदद से पाया जा सकता है. हालांकि, अगर आपने पहले Firebase का इस्तेमाल किए बिना, Apple की मदद से किसी उपयोगकर्ता को ऐप्लिकेशन में साइन इन कराया है, तो Apple, Firebase को उपयोगकर्ता का डिसप्ले नेम उपलब्ध नहीं कराएगा.

फिर से पुष्टि करना और खाते लिंक करना

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

Kotlin 

// The user is already signed-in.
val firebaseUser = auth.getCurrentUser()

firebaseUser
    .startActivityForReauthenticateWithProvider(/* activity= */ this, provider.build())
    .addOnSuccessListener( 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( e -> {
        // Handle failure.
    })

Java 

// The user is already signed-in.
FirebaseUser firebaseUser = mAuth.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.
          }
        });

साथ ही, मौजूदा खातों से अलग-अलग आइडेंटिटी प्रोवाइडर को लिंक करने के लिए, linkWithCredential() का इस्तेमाल किया जा सकता है.

ध्यान दें कि Apple के लिए, उपयोगकर्ताओं के Apple खातों को अन्य डेटा से लिंक करने से पहले, उनसे साफ़ तौर पर सहमति लेना ज़रूरी है.

उदाहरण के लिए, मौजूदा Firebase खाते से Facebook खाता लिंक करने के लिए, उस ऐक्सेस टोकन का इस्तेमाल करें जो आपको Facebook में उपयोगकर्ता को साइन इन कराने पर मिला था:

Kotlin 

// Initialize a Facebook credential with a Facebook access token.
val credential = FacebookAuthProvider.getCredential(token.getToken())

// Assuming the current user is an Apple user linking a Facebook provider.
mAuth.getCurrentUser().linkWithCredential(credential)
    .addOnCompleteListener(this, task -> {
        if (task.isSuccessful()) {
          // Facebook credential is linked to the current Apple user.
          // The user can now sign in to the same account
          // with either Apple or Facebook.
        }
      });

Java 

// Initialize a Facebook credential with a Facebook access token.
AuthCredential credential = FacebookAuthProvider.getCredential(token.getToken());

// Assuming the current user is an Apple user linking a Facebook provider.
mAuth.getCurrentUser().linkWithCredential(credential)
    .addOnCompleteListener(this, new OnCompleteListener<AuthResult>() {
      @Override
      public void onComplete(@NonNull Task<AuthResult> task) {
        if (task.isSuccessful()) {
          // Facebook credential is linked to the current Apple user.
          // The user can now sign in to the same account
          // with either Apple or Facebook.
        }
      }
    });

बेहतर सुविधा: साइन-इन फ़्लो को मैन्युअल तरीके से मैनेज करना

Apple खाते का इस्तेमाल करके, Firebase में पुष्टि की जा सकती है. इसके लिए, साइन-इन फ़्लो को Apple Sign-In JS SDK टूल का इस्तेमाल करके, OAuth फ़्लो को मैन्युअल तरीके से बनाकर या AppAuth जैसी OAuth लाइब्रेरी का इस्तेमाल करके मैनेज किया जा सकता है.

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

    Android पर, क्रिप्टोग्राफ़िक तौर पर सुरक्षित nonce जनरेट करने के लिए, SecureRandom का इस्तेमाल किया जा सकता है. जैसे, इस उदाहरण में दिखाया गया है:

    Kotlin 

    private fun generateNonce(length: Int): String {
    val generator = SecureRandom()

    val charsetDecoder = StandardCharsets.US_ASCII.newDecoder()
    charsetDecoder.onUnmappableCharacter(CodingErrorAction.IGNORE)
    charsetDecoder.onMalformedInput(CodingErrorAction.IGNORE)

    val bytes = ByteArray(length)
    val inBuffer = ByteBuffer.wrap(bytes)
    val outBuffer = CharBuffer.allocate(length)
    while (outBuffer.hasRemaining()) {
        generator.nextBytes(bytes)
        inBuffer.rewind()
        charsetDecoder.reset()
        charsetDecoder.decode(inBuffer, outBuffer, false)
    }
    outBuffer.flip()
    return outBuffer.toString()
}

    Java 

    private String generateNonce(int length) {
    SecureRandom generator = new SecureRandom();

    CharsetDecoder charsetDecoder = StandardCharsets.US_ASCII.newDecoder();
    charsetDecoder.onUnmappableCharacter(CodingErrorAction.IGNORE);
    charsetDecoder.onMalformedInput(CodingErrorAction.IGNORE);

    byte[] bytes = new byte[length];
    ByteBuffer inBuffer = ByteBuffer.wrap(bytes);
    CharBuffer outBuffer = CharBuffer.allocate(length);
    while (outBuffer.hasRemaining()) {
        generator.nextBytes(bytes);
        inBuffer.rewind();
        charsetDecoder.reset();
        charsetDecoder.decode(inBuffer, outBuffer, false);
    }
    outBuffer.flip();
    return outBuffer.toString();
}

    इसके बाद, nonce का SHA246 हैश, हेक्स स्ट्रिंग के तौर पर पाएं:

    Kotlin 

    private fun sha256(s: String): String {
    val md = MessageDigest.getInstance("SHA-256")
    val digest = md.digest(s.toByteArray())
    val hash = StringBuilder()
    for (c in digest) {
        hash.append(String.format("%02x", c))
    }
    return hash.toString()
}

    Java 

    private String sha256(String s) throws NoSuchAlgorithmException {
    MessageDigest md = MessageDigest.getInstance("SHA-256");
    byte[] digest = md.digest(s.getBytes());
    StringBuilder hash = new StringBuilder();
    for (byte c: digest) {
        hash.append(String.format("%02x", c));
    }
    return hash.toString();
}

    साइन-इन के अनुरोध के साथ, nonce का SHA256 हैश भेजा जाएगा. Apple, जवाब में इसे बिना किसी बदलाव के पास करेगा. Firebase, ओरिजनल nonce को हैश करके और Apple से मिली वैल्यू से तुलना करके, जवाब की पुष्टि करता है.

  2. अपनी OAuth लाइब्रेरी या किसी अन्य तरीके का इस्तेमाल करके, Apple के साइन-इन फ़्लो को शुरू करें. पक्का करें कि आपने अपने अनुरोध में, हैश किए गए nonce को पैरामीटर के तौर पर शामिल किया हो.

  3. Apple से जवाब मिलने के बाद, जवाब से आईडी टोकन पाएं. इसके बाद, AuthCredential बनाने के लिए, इसका और हैश न किए गए nonce का इस्तेमाल करें:

    Kotlin 

    val credential =  OAuthProvider.newCredentialBuilder("apple.com")
    .setIdTokenWithRawNonce(appleIdToken, rawUnhashedNonce)
    .build()

    Java 

    AuthCredential credential =  OAuthProvider.newCredentialBuilder("apple.com")
    .setIdTokenWithRawNonce(appleIdToken, rawUnhashedNonce)
    .build();

  4. Firebase क्रेडेंशियल का इस्तेमाल करके, Firebase में पुष्टि करें:

    Kotlin 

    auth.signInWithCredential(credential)
      .addOnCompleteListener(this) { task ->
          if (task.isSuccessful) {
            // User successfully signed in with Apple ID token.
            // ...
          }
      }

    Java 

    mAuth.signInWithCredential(credential)
    .addOnCompleteListener(this, new OnCompleteListener<AuthResult>() {
      @Override
      public void onComplete(@NonNull Task<AuthResult> task) {
        if (task.isSuccessful()) {
          // User successfully signed in with Apple ID token.
          // ...
        }
      }
    });

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

टोकन निरस्त करना

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

इसके अलावा, 'Apple से साइन इन करें' सुविधा देने वाले ऐप्लिकेशन को, उपयोगकर्ता के टोकन निरस्त करने के लिए, 'Apple से साइन इन करें' सुविधा के REST API का इस्तेमाल करना चाहिए.

इस ज़रूरी शर्त को पूरा करने के लिए, यह तरीका अपनाएं:

  1. Apple का इस्तेमाल करके साइन-इन करने और AuthResult पाने के लिए, startActivityForSignInWithProvider() तरीके का इस्तेमाल करें.

  2. Apple प्रोवाइडर के लिए ऐक्सेस टोकन पाएं.

    Kotlin 

    val oauthCredential: OAuthCredential =  authResult.credential
val accessToken = oauthCredential.accessToken

    Java 

    OAuthCredential oauthCredential = (OAuthCredential) authResult.getCredential();
String accessToken = oauthCredential.getAccessToken();

  3. revokeAccessToken API का इस्तेमाल करके, टोकन निरस्त करें.

    Kotlin 

    mAuth.revokeAccessToken(accessToken)
  .addOnCompleteListener(this) { task ->
    if (task.isSuccessful) {
      // Access token successfully revoked
      // for the user ...
    }
}

    Java 

    mAuth.revokeAccessToken(accessToken)
    .addOnCompleteListener(this, new OnCompleteListener<Void>() {
        @Override
        public void onComplete(@NonNull Task<Void> task) {
          if (task.isSuccessful()) {
            // Access token successfully revoked
            // for the user ...
          }
        }
  });
  1. आखिर में, उपयोगकर्ता का खाता मिटाएं (और उससे जुड़ा सारा डेटा)

    अगले चरण

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

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

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

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

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

    Kotlin

    Firebase.auth.signOut()

    Java

    FirebaseAuth.getInstance().signOut();