Android पर Apple का उपयोग करके प्रमाणित करें

आप एंड-टू-एंड OAuth 2.0 साइन-इन प्रवाह को पूरा करने के लिए Firebase SDK का उपयोग करके अपने उपयोगकर्ताओं को उनकी Apple ID का उपयोग करके Firebase से प्रमाणित करने दे सकते हैं।

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

Apple का उपयोग करने वाले उपयोगकर्ताओं को साइन इन करने के लिए, पहले Apple की डेवलपर साइट पर साइन इन विथ Apple कॉन्फ़िगर करें, फिर Apple को अपने फायरबेस प्रोजेक्ट के लिए साइन-इन प्रदाता के रूप में सक्षम करें।

Apple डेवलपर प्रोग्राम से जुड़ें

Apple के साथ साइन इन केवल Apple डेवलपर प्रोग्राम के सदस्यों द्वारा ही कॉन्फ़िगर किया जा सकता है।

Apple के साथ साइन इन कॉन्फ़िगर करें

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

1. अपनी वेबसाइट को अपने ऐप के साथ संबद्ध करें जैसा कि वेब के लिए ऐप्पल के साथ कॉन्फिगर साइन इन के पहले खंड में बताया गया है। संकेत मिलने पर, निम्नलिखित यूआरएल को रिटर्न यूआरएल के रूप में पंजीकृत करें:

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

   आप अपना फायरबेस प्रोजेक्ट आईडी फायरबेस कंसोल सेटिंग पेज पर प्राप्त कर सकते हैं।

   जब आपका काम पूरा हो जाए, तो अपनी नई सेवा आईडी पर ध्यान दें, जिसकी आपको अगले भाग में आवश्यकता होगी।

2. Apple निजी कुंजी के साथ साइन इन बनाएं । आपको अगले अनुभाग में अपनी नई निजी कुंजी और कुंजी आईडी की आवश्यकता होगी।

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

Apple को साइन-इन प्रदाता के रूप में सक्षम करें

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

Apple अज्ञात डेटा आवश्यकताओं का अनुपालन करें

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

इसमें किसी भी सीधे पहचान वाली व्यक्तिगत जानकारी को अज्ञात ऐप्पल आईडी के साथ जोड़ने से पहले किसी भी आवश्यक उपयोगकर्ता की सहमति प्राप्त करना शामिल है। फायरबेस प्रमाणीकरण का उपयोग करते समय, इसमें निम्नलिखित क्रियाएं शामिल हो सकती हैं:

• किसी ईमेल पते को अज्ञात Apple ID से लिंक करें या इसके विपरीत।
• किसी फ़ोन नंबर को अज्ञात Apple ID से लिंक करें या इसके विपरीत
• एक गैर-गुमनाम सामाजिक क्रेडेंशियल (फेसबुक, गूगल, आदि) को एक अज्ञात ऐप्पल आईडी से लिंक करें या इसके विपरीत।

उपरोक्त सूची संपूर्ण नहीं है. यह सुनिश्चित करने के लिए कि आपका ऐप Apple की आवश्यकताओं को पूरा करता है, अपने डेवलपर खाते के सदस्यता अनुभाग में Apple डेवलपर प्रोग्राम लाइसेंस अनुबंध देखें।

फायरबेस एसडीके के साथ साइन-इन प्रवाह को संभालें

Android पर, अपने उपयोगकर्ताओं को उनके Apple खातों का उपयोग करके Firebase के साथ प्रमाणित करने का सबसे आसान तरीका 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);
   

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

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 प्रदाता ऑब्जेक्ट का उपयोग करके फ़ायरबेस से प्रमाणित करें। ध्यान दें कि अन्य FirebaseAuth ऑपरेशनों के विपरीत, यह एक कस्टम Chrome टैब खोलकर आपके UI को नियंत्रित करेगा। नतीजतन, अपनी गतिविधि को 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);
                       }
                   });
   

   फायरबेस ऑथ द्वारा समर्थित अन्य प्रदाताओं के विपरीत, ऐप्पल एक फोटो यूआरएल प्रदान नहीं करता है।

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

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

पुनःप्रमाणीकरण और खाता लिंकिंग

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

// 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.
    })

// 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 खातों को अन्य डेटा से लिंक करने से पहले आपको उपयोगकर्ताओं से स्पष्ट सहमति प्राप्त करने की आवश्यकता है।

उदाहरण के लिए, किसी फेसबुक खाते को वर्तमान फायरबेस खाते से लिंक करने के लिए, उपयोगकर्ता को फेसबुक पर साइन इन करने से प्राप्त एक्सेस टोकन का उपयोग करें:

// 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.
        }
      });

// 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 साइन-इन JS SDK का उपयोग करके, मैन्युअल रूप से OAuth प्रवाह का निर्माण करके या AppAuth जैसी OAuth लाइब्रेरी का उपयोग करके साइन-इन प्रवाह को संभालकर Apple खाते का उपयोग करके फायरबेस के साथ प्रमाणित कर सकते हैं।

1. प्रत्येक साइन-इन अनुरोध के लिए, एक यादृच्छिक स्ट्रिंग उत्पन्न करें - एक "नॉन्स" - जिसका उपयोग आप यह सुनिश्चित करने के लिए करेंगे कि आपको प्राप्त आईडी टोकन विशेष रूप से आपके ऐप के प्रमाणीकरण अनुरोध के जवाब में प्रदान किया गया था। रीप्ले हमलों को रोकने के लिए यह कदम महत्वपूर्ण है।

   आप एंड्रॉइड पर 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 प्रतिक्रिया में अपरिवर्तित कर देगा। फायरबेस मूल नॉन को हैश करके और ऐप्पल द्वारा पारित मूल्य से तुलना करके प्रतिक्रिया को मान्य करता है।

2. अपनी OAuth लाइब्रेरी या अन्य विधि का उपयोग करके Apple का साइन-इन प्रवाह आरंभ करें। अपने अनुरोध में पैरामीटर के रूप में हैशेड नॉन को शामिल करना सुनिश्चित करें।

3. ऐप्पल की प्रतिक्रिया प्राप्त करने के बाद, प्रतिक्रिया से आईडी टोकन प्राप्त करें और एक 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. फ़ायरबेस क्रेडेंशियल का उपयोग करके फ़ायरबेस से प्रमाणित करें:

   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 विधि का उपयोग कर सकते हैं।

टोकन निरस्तीकरण

ऐप्पल के लिए आवश्यक है कि जो ऐप खाता निर्माण का समर्थन करते हैं, उन्हें उपयोगकर्ताओं को ऐप के भीतर अपना खाता हटाने की अनुमति देनी चाहिए, जैसा कि ऐप स्टोर समीक्षा दिशानिर्देशों में बताया गया है।

इसके अलावा, जो ऐप्स ऐप्पल के साथ साइन इन का समर्थन करते हैं, उन्हें उपयोगकर्ता टोकन को रद्द करने के लिए साइन इन विद ऐप्पल रेस्ट एपीआई का उपयोग करना चाहिए।

इस आवश्यकता को पूरा करने के लिए, निम्नलिखित चरणों को लागू करें:

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. अंत में, उपयोगकर्ता खाता (और सभी संबद्ध डेटा) हटा दें

   अगले कदम

   किसी उपयोगकर्ता द्वारा पहली बार साइन इन करने के बाद, एक नया उपयोगकर्ता खाता बनाया जाता है और क्रेडेंशियल्स से लिंक किया जाता है - यानी, उपयोगकर्ता नाम और पासवर्ड, फोन नंबर, या ऑथ प्रदाता जानकारी - जिस उपयोगकर्ता के साथ साइन इन किया जाता है। यह नया खाता आपके फायरबेस प्रोजेक्ट के हिस्से के रूप में संग्रहीत है, और इसका उपयोग आपके प्रोजेक्ट के प्रत्येक ऐप में उपयोगकर्ता की पहचान करने के लिए किया जा सकता है, भले ही उपयोगकर्ता कैसे भी साइन इन करता हो।

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

   • अपने फायरबेस रीयलटाइम डेटाबेस और क्लाउड स्टोरेज सुरक्षा नियमों में, आप साइन-इन किए गए उपयोगकर्ता की अद्वितीय उपयोगकर्ता आईडी को auth वेरिएबल से प्राप्त कर सकते हैं, और इसका उपयोग यह नियंत्रित करने के लिए कर सकते हैं कि उपयोगकर्ता किस डेटा तक पहुंच सकता है।

   आप किसी मौजूदा उपयोगकर्ता खाते से प्रमाणीकरण प्रदाता क्रेडेंशियल्स को लिंक करके उपयोगकर्ताओं को एकाधिक प्रमाणीकरण प्रदाताओं का उपयोग करके अपने ऐप में साइन इन करने की अनुमति दे सकते हैं।

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

   Kotlin+KTX

   Firebase.auth.signOut()
   MainActivity.kt

   Java

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