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

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

अहम जानकारी: Apple खाते से साइन इन करने के लिए ज़रूरी है कि:

• आपके पास दो तरीकों से पुष्टि (2FA) की सुविधा वाला Apple ID होना चाहिए.
• Apple डिवाइस पर iCloud में साइन इन होना चाहिए.

ऐसा करने का तरीका देखें 'Apple से साइन इन करें' सुविधा का इस्तेमाल करें. आपको ये ज़रूरी शर्तें भी पूरी करनी होंगी इसका इस्तेमाल करके, 'Apple से साइन इन करें' सुविधा के साथ अपने इंटिग्रेशन की जांच की जा सकती है.

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

Apple का इस्तेमाल करके साइन इन करने के लिए, पहले 'Apple से साइन इन करें' सुविधा को कॉन्फ़िगर करें Apple की डेवलपर साइट पर जाएं, तो Apple को अपने Firebase प्रोजेक्ट.

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

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

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

Apple पर डेवलपर साइट पर जाकर, ये काम करें:

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

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

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

   काम पूरा होने के बाद, अपना नया सेवा आईडी नोट कर लें. आपको अपनी नई सेवा आईडी को अगला सेक्शन देखें.

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

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

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

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

उपयोगकर्ताओं की पहचान छिपाकर, Apple की डेटा से जुड़ी ज़रूरी शर्तों को पूरा करते हैं

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

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

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

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

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

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

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

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

   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 के दस्तावेज़ों से साइन इन करना का इस्तेमाल करें.

   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 टैब खोल रही हूँ. इस वजह से, Google Ads खाते में अपनी गतिविधि का 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 के साथ शेयर न करने का विकल्प चुनता है उस उपयोगकर्ता के लिए एक अद्वितीय ईमेल पता (फ़ॉर्म के रूप में) [e-mail]), जिसे यह आपके ऐप्लिकेशन के साथ शेयर करता है. अगर आपको निजी ईमेल रिले सेवा को कॉन्फ़िगर किया है, तो Apple इस पर भेजे गए ईमेल फ़ॉरवर्ड करता है उपयोगकर्ता के असली ईमेल पते पर, पहचान छिपाई गई हो.

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

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

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 Sign-In JS SDK का इस्तेमाल करें और मैन्युअल तरीके से OAuth फ़्लो या OAuth लाइब्रेरी का इस्तेमाल करके, जैसे कि AppAuth.

1. हर साइन-इन अनुरोध के लिए, एक रैंडम स्ट्रिंग जनरेट करें—a "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 से साइन इन करने और AuthResult पाने के लिए, startActivityForSignInWithProvider() तरीके का इस्तेमाल करें.

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 API का इस्तेमाल करके, टोकन को रद्द करें.

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

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

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

   Kotlin+KTX

   Firebase.auth.signOut()
   MainActivity.kt

   Java

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