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

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

अहम जानकारी: Apple खाते से साइन इन करने के लिए, उपयोगकर्ताओं को यह करना होगा:

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

Apple से साइन इन करने का तरीका देखें. आपको 'Sign In with Apple' के साथ इंटिग्रेशन की जांच करने के लिए, ये ज़रूरी शर्तें भी पूरी करनी होंगी.

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

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 Authentication की ऐसी सुविधाओं का इस्तेमाल किया जाता है जो लोगों को ईमेल भेजती हैं, तो Apple की निजी ईमेल रिले सेवा को कॉन्फ़िगर करें. इन सुविधाओं में, ईमेल लिंक से साइन इन करने की सुविधा, ईमेल पते की पुष्टि करने की सुविधा, खाता बदलने की सुविधा, और अन्य सुविधाएं शामिल हैं. साथ ही, noreply@YOUR_FIREBASE_PROJECT_ID.firebaseapp.com या अपने पसंद के ईमेल टेंप्लेट डोमेन को रजिस्टर करें, ताकि Apple, Firebase Authentication से भेजे गए ईमेल को Apple के ऐसे ईमेल पतों पर रिले कर सके जिनकी पहचान ज़ाहिर नहीं की गई है.

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

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

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

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

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

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

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

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

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

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

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

   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 से कोई स्कोप का अनुरोध नहीं करता है. हालांकि, ऐसा तब तक होता है, जब तक कि आपने स्कोप तय न किए हों.

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

उदाहरण के लिए, किसी Facebook खाते को मौजूदा Firebase खाते से लिंक करने के लिए, उस ऐक्सेस टोकन का इस्तेमाल करें जो आपको 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. साइन इन करने के हर अनुरोध के लिए, एक रैंडम स्ट्रिंग जनरेट करें. इसे "नॉन्स" कहा जाता है. इसका इस्तेमाल यह पक्का करने के लिए किया जाएगा कि आपको मिला आईडी टोकन, खास तौर पर आपके ऐप्लिकेशन के पुष्टि करने के अनुरोध के जवाब में दिया गया था. यह चरण, रीप्ले अटैक को रोकने के लिए ज़रूरी है.

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

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

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

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

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

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

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

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

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

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

   Kotlin

   Firebase.auth.signOut()
   MainActivity.kt

   Java

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