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

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

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

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

Apple डेवलपर प्रोग्राम में शामिल हों

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

ऐप्पल के साथ साइन इन कॉन्फ़िगर करें

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

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

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

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

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

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

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

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

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

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

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

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

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

Firebase SDK के साथ साइन-इन प्रवाह को प्रबंधित करें

Android पर, अपने Apple खातों का उपयोग करके अपने उपयोगकर्ताओं को Firebase से प्रमाणित करने का सबसे आसान तरीका है, Firebase Android SDK के साथ संपूर्ण साइन-इन प्रवाह को संभालना।

Firebase Android SDK के साथ साइन-इन प्रवाह को संभालने के लिए, इन चरणों का पालन करें:

  1. प्रदाता आईडी apple.com के साथ अपने बिल्डर का उपयोग करके OAuthProvider का एक उदाहरण बनाएं:

    Java

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

    Kotlin+KTX

    val provider = OAuthProvider.newBuilder("apple.com")
    
  2. वैकल्पिक: डिफ़ॉल्ट से परे अतिरिक्त OAuth 2.0 स्कोप निर्दिष्ट करें जिसका आप प्रमाणीकरण प्रदाता से अनुरोध करना चाहते हैं।

    Java

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

    Kotlin+KTX

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

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

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

    Java

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

    Kotlin+KTX

    // Localize the Apple authentication screen in French.
    provider.addCustomParameter("locale", "fr")
    
  4. OAuth प्रदाता ऑब्जेक्ट का उपयोग करके Firebase से प्रमाणित करें। ध्यान दें कि अन्य FirebaseAuth संचालनों के विपरीत, यह कस्टम Chrome टैब खोलकर आपके UI को नियंत्रित करेगा। नतीजतन, OnSuccessListener और OnFailureListener में अपनी गतिविधि का संदर्भ न दें जिसे आप संलग्न करते हैं क्योंकि जब ऑपरेशन UI शुरू होता है तो वे तुरंत अलग हो जाएंगे।

    आपको पहले जांच करनी चाहिए कि क्या आपको पहले ही कोई प्रतिक्रिया मिली है। इस पद्धति से साइन इन करने से आपकी गतिविधि पृष्ठभूमि में आ जाती है, जिसका अर्थ है कि साइन इन प्रवाह के दौरान सिस्टम द्वारा इसे पुनः प्राप्त किया जा सकता है। यह सुनिश्चित करने के लिए कि यदि ऐसा होता है तो आप उपयोगकर्ता को फिर से प्रयास करने के लिए नहीं कहते हैं, आपको यह जांचना चाहिए कि कोई परिणाम पहले से मौजूद है या नहीं।

    यह जांचने के लिए कि क्या कोई परिणाम लंबित है, getPendingAuthResult() पर कॉल करें:

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

    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")
    }
    

    यदि कोई लंबित परिणाम नहीं है, तो startActivityForSignInWithProvider() पर कॉल करके साइन इन प्रवाह प्रारंभ करें:

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

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

    Firebase Auth द्वारा समर्थित अन्य प्रदाताओं के विपरीत, Apple एक फोटो URL प्रदान नहीं करता है।

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

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

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

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

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

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

और, आप विभिन्न पहचान प्रदाताओं को मौजूदा खातों से जोड़ने के लिए linkWithCredential() का उपयोग कर सकते हैं।

ध्यान दें कि आपके द्वारा उनके Apple खातों को अन्य डेटा से लिंक करने से पहले Apple के लिए आपको उपयोगकर्ताओं से स्पष्ट सहमति प्राप्त करने की आवश्यकता है।

उदाहरण के लिए, किसी Facebook खाते को वर्तमान Firebase खाते से लिंक करने के लिए, उपयोगकर्ता को 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.
        }
      }
    });

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

उन्नत: साइन-इन प्रवाह को मैन्युअल रूप से प्रबंधित करें

आप या तो Apple साइन-इन JS SDK का उपयोग करके, मैन्युअल रूप से OAuth प्रवाह बनाकर या AppAuth जैसी OAuth लाइब्रेरी का उपयोग करके साइन-इन प्रवाह को प्रबंधित करके Apple खाते का उपयोग करके Firebase से प्रमाणित कर सकते हैं।

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

    आप Android पर SecureRandom के साथ एक क्रिप्टोग्राफ़िक रूप से सुरक्षित गैर उत्पन्न कर सकते हैं, जैसा कि निम्न उदाहरण में है:

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

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

    फिर, गैर के SHA246 हैश को हेक्स स्ट्रिंग के रूप में प्राप्त करें:

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

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

    आप अपने साइन-इन अनुरोध के साथ गैर का SHA256 हैश भेजेंगे, जिसे Apple प्रतिक्रिया में अपरिवर्तित कर देगा। फायरबेस मूल गैर को हैश करके और ऐप्पल द्वारा पारित मूल्य से तुलना करके प्रतिक्रिया को मान्य करता है।

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

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

    Java

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

    Kotlin+KTX

    val credential =  OAuthProvider.newCredentialBuilder("apple.com")
        .setIdTokenWithRawNonce(appleIdToken, rawUnhashedNonce)
        .build()
    
  4. Firebase क्रेडेंशियल का उपयोग करके Firebase से प्रमाणित करें:

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

    Kotlin+KTX

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

यदि signInWithCredential का कॉल सफल होता है, तो आप उपयोगकर्ता के खाते का डेटा प्राप्त करने के लिए getCurrentUser विधि का उपयोग कर सकते हैं।

अगले कदम

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

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

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

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

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

Java

FirebaseAuth.getInstance().signOut();

Kotlin+KTX

Firebase.auth.signOut()