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

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

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

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

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

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

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

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

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

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

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

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

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

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

Apple को साइन-इन करने की सेवा देने वाली कंपनी के तौर पर चालू करें

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

पहचान ज़ाहिर किए बिना Apple के डेटा से जुड़ी ज़रूरी शर्तों का पालन करना

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

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

  • पहचान छिपाने वाले Apple ID से कोई ईमेल पता लिंक करें. इसी तरह, पहचान छिपाने वाले Apple ID से कोई ईमेल पता लिंक करें.
  • किसी फ़ोन नंबर को बिना पहचान वाले Apple ID से लिंक करें या इसी तरह के Apple ID से अपना फ़ोन नंबर लिंक करें
  • बिना पहचान वाले सोशल क्रेडेंशियल (Facebook, Google वगैरह) को पहचान छिपाने वाले Apple ID से लिंक करें. इसी तरह, तीसरे पक्ष के किसी ऐसे सोशल क्रेडेंशियल को भी लिंक करें जिसकी पहचान छिपाई गई हो.

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

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

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

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

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

    Kotlin+KTX 

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

    Java 

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

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

    Kotlin+KTX 

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

    Java 

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

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

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

    Kotlin+KTX 

    // 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+KTX 

    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+KTX 

    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 पुष्टि के साथ काम करने वाली दूसरी कंपनियों के उलट, Apple किसी फ़ोटो का यूआरएल नहीं देता.

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

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

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

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

Kotlin+KTX 

// 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 खातों को अन्य डेटा से लिंक करने से पहले, आपको उपयोगकर्ताओं से साफ़ तौर पर सहमति लेनी होगी.

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

Kotlin+KTX 

// 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 साइन-इन JS SDK टूल का इस्तेमाल किया जा सकता है. इसके अलावा, मैन्युअल तरीके से OAuth फ़्लो को बनाया जा सकता है या AppAuth जैसी OAuth लाइब्रेरी का इस्तेमाल भी किया जा सकता है.

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

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

    Kotlin+KTX 

    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();
}

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

    Kotlin+KTX 

    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();
}

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

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

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

    Kotlin+KTX 

    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+KTX 

    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 का इस्तेमाल करके साइन इन करने के लिए startActivityForSignInWithProvider() तरीके का इस्तेमाल करें और AuthResult पाएं.

  2. Apple की सेवा देने वाली कंपनी के लिए ऐक्सेस टोकन पाएं.

    Kotlin+KTX 

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

    Java 

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

  3. revokeAccessToken एपीआई का इस्तेमाल करके, टोकन को रद्द करें.

    Kotlin+KTX 

    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 रीयल टाइम डेटाबेस और Cloud Storage के सुरक्षा नियमों में, auth वैरिएबल से, साइन इन किए हुए उपयोगकर्ता का यूनीक यूज़र आईडी पाया जा सकता है. साथ ही, इसका इस्तेमाल यह कंट्रोल करने के लिए किया जा सकता है कि उपयोगकर्ता कौनसा डेटा ऐक्सेस कर सकता है.

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

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

    Kotlin+KTX

    Firebase.auth.signOut()
    MainActivity.kt

    Java

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