Google is committed to advancing racial equity for Black communities. See how.
इस पेज का अनुवाद Cloud Translation API से किया गया है.
Switch to English

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

आप वेब-आधारित जेनेरिक OAuth लॉगिन को अपने ऐप में Firebase के उपयोग से अपने उपयोगकर्ताओं को Firebase के साथ प्रमाणित करने दे सकते हैं, साइन-इन प्रवाह के अंत को समाप्त करने के लिए Firebase SDK का उपयोग करके अपने ऐप में लॉगिन करें।

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

GitHub खातों का उपयोग करने वाले उपयोगकर्ताओं में साइन इन करने के लिए, आपको सबसे पहले GitHub को अपने फायरबेस के लिए साइन-इन प्रदाता के रूप में सक्षम करना होगा:

  1. यदि आप पहले से नहीं है, तो अपने Android प्रोजेक्ट में Firebase जोड़ें

  2. में Firebase कंसोल , प्राधिकरण अनुभाग खोलें।
  3. साइन इन विधि टैब पर, GitHub प्रदाता को सक्षम करें।
  4. उस प्रदाता के डेवलपर कंसोल से क्लाइंट आईडी और क्लाइंट सीक्रेट को प्रदाता कॉन्फ़िगरेशन में जोड़ें:
    1. GitHub पर डेवलपर एप्लिकेशन के रूप में अपना ऐप पंजीकृत करें और अपने ऐप का OAuth 2.0 क्लाइंट आईडी और क्लाइंट सीक्रेट प्राप्त करें
    2. सुनिश्चित करें कि आपका Firebase OAuth रीडायरेक्ट URI (जैसे my-app-12345.firebaseapp.com/__/auth/handler ) आपके my-app-12345.firebaseapp.com/__/auth/handler ऐप के कॉन्फ़िगरेशन पर आपके ऐप के सेटिंग पृष्ठ में आपके प्राधिकरण कॉलबैक URL के रूप में सेट है।
  5. सहेजें पर क्लिक करें
  6. अपने प्रोजेक्ट-लेवल build.gradle फ़ाइल में, अपने buildscript और allprojects दोनों वर्गों में Google के buildscript रिपॉजिटरी को शामिल करना सुनिश्चित करें।

  7. अपने मॉड्यूल (ऐप-स्तरीय) ग्रेड फ़ाइल (आमतौर पर app/build.gradle ) के लिए app/build.gradle प्रमाणीकरण एंड्रॉइड लाइब्रेरी के लिए निर्भरता जोड़ें:

    implementation 'com.google.firebase:firebase-auth:19.4.0'
    
  8. यदि आपने अभी तक अपने ऐप के SHA-1 फिंगरप्रिंट को निर्दिष्ट नहीं किया है, तो फायरबेस कंसोल के सेटिंग पेज से ऐसा करें। अपने ऐप के SHA-1 फ़िंगरप्रिंट प्राप्त करने के तरीके के विवरण के लिए अपने ग्राहक को प्रमाणित करने का संदर्भ लें।

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

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

फायरबेस एंड्रॉइड एसडीके के साथ साइन-इन प्रवाह को संभालने के लिए, इन चरणों का पालन करें:

  1. प्रदाता ID github.com के साथ अपने बिल्डर का उपयोग करके OAuthProvider की एक आवृत्ति का निर्माण करें

    OAuthProvider.Builder provider = OAuthProvider.newBuilder("github.com");
    
  2. वैकल्पिक : अतिरिक्त कस्टम OAuth पैरामीटर निर्दिष्ट करें जिसे आप OAuth अनुरोध के साथ भेजना चाहते हैं।

    // Target specific email with login hint.
    provider.addCustomParameter("login", "your-email@gmail.com");
    

    GitHub के मापदंडों के लिए, GitHub OAuth प्रलेखन देखें । ध्यान दें कि आप setCustomParameters() साथ setCustomParameters() -आवश्यक पैरामीटर पास नहीं कर सकते। ये पैरामीटर हैं client_id , response_type , redirect_uri , state , गुंजाइश और response_mode

  3. वैकल्पिक : मूल प्रोफ़ाइल से परे अतिरिक्त OAuth 2.0 स्कोप निर्दिष्ट करें जिसे आप प्रमाणीकरण प्रदाता से अनुरोध करना चाहते हैं। यदि आपके एप्लिकेशन को GitHub API से निजी उपयोगकर्ता डेटा तक पहुंच की आवश्यकता है, तो आपको GitHub डेवलपर कंसोल में API API के तहत GitHubs तक पहुंचने के लिए अनुमति का अनुरोध करना होगा। अनुरोधित OAuth स्कोप्स को ऐप के एपीआई अनुमतियों में पूर्व-निर्धारित लोगों के लिए सटीक मिलान होना चाहिए।

    // Request read access to a user's email addresses.
    // This must be preconfigured in the app's API permissions.
    List<String> scopes =
        new ArrayList<String>() {
          {
            add("user:email");
          }
        };
    provider.setScopes(scopes);
    
  4. OAuth प्रदाता ऑब्जेक्ट का उपयोग करके Firebase के साथ प्रमाणीकरण। ध्यान दें कि अन्य FirebaseAuth संचालन के विपरीत, यह कस्टम Chrome टैब को पॉप अप करके आपके UI का नियंत्रण लेगा। परिणामस्वरूप, OnSuccessListener और OnFailureListener में अपनी गतिविधि का संदर्भ न OnFailureListener जिसे आप ऑपरेशन के रूप में यूआई शुरू होने पर तुरंत अलग कर देंगे।

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

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

    Task<AuthResult> pendingResultTask = firebaseAuth.getPendingAuthResult();
    if (pendingResultTask != null) {
      // There's something already here! Finish the sign-in for your user.
      pendingResultTask
          .addOnSuccessListener(
              new OnSuccessListener<AuthResult>() {
                @Override
                public void onSuccess(AuthResult authResult) {
                  // User is signed in.
                  // IdP data available in
                  // authResult.getAdditionalUserInfo().getProfile().
                  // The OAuth access token can also be retrieved:
                  // authResult.getCredential().getAccessToken().
                }
              })
          .addOnFailureListener(
              new OnFailureListener() {
                @Override
                public void onFailure(@NonNull Exception e) {
                  // Handle failure.
                }
              });
    } else {
      // There's no pending result so you need to start the sign-in flow.
      // See below.
    }
    

    साइन इन फ्लो शुरू करने के लिए, startActivityForSignInWithProvider :

    firebaseAuth
        .startActivityForSignInWithProvider(/* activity= */ this, provider.build())
        .addOnSuccessListener(
            new OnSuccessListener<AuthResult>() {
              @Override
              public void onSuccess(AuthResult authResult) {
                // User is signed in.
                // IdP data available in
                // authResult.getAdditionalUserInfo().getProfile().
                // The OAuth access token can also be retrieved:
                // authResult.getCredential().getAccessToken().
              }
            })
        .addOnFailureListener(
            new OnFailureListener() {
              @Override
              public void onFailure(@NonNull Exception e) {
                // Handle failure.
              }
            });
    

    सफल समापन पर, प्रदाता के साथ जुड़े OAuth पहुंच टोकन को OAuthCredential गए OAuthCredential ऑब्जेक्ट से पुनर्प्राप्त किया जा सकता है।

    OAuth एक्सेस टोकन का उपयोग करके, आप GitHub API को कॉल कर सकते हैं।

    उदाहरण के लिए, बुनियादी प्रोफ़ाइल जानकारी प्राप्त करने के लिए, आप REST API को कॉल कर सकते हैं, Authorization शीर्षलेख में पहुँच टोकन पास कर सकते हैं:

  5. हालांकि उपरोक्त उदाहरण साइन-इन फ्लो पर ध्यान केंद्रित करते हैं, आपके पास एक मौजूदा उपयोगकर्ता के लिए एक GitHub प्रदाता को startActivityForLinkWithProvider का उपयोग करके लिंक करने की क्षमता भी है। उदाहरण के लिए, आप एक से अधिक प्रदाताओं को एक ही उपयोगकर्ता से लिंक कर सकते हैं जिससे वे या तो साइन इन कर सकते हैं।

    // The user is already signed-in.
    FirebaseUser firebaseUser = firebaseAuth.getCurrentUser();
    
    firebaseUser
        .startActivityForLinkWithProvider(/* activity= */ this, provider.build())
        .addOnSuccessListener(
            new OnSuccessListener<AuthResult>() {
              @Override
              public void onSuccess(AuthResult authResult) {
                // GitHub credential is linked to the current user.
                // IdP data available in
                // authResult.getAdditionalUserInfo().getProfile().
                // The OAuth access token can also be retrieved:
                // authResult.getCredential().getAccessToken().
              }
            })
        .addOnFailureListener(
            new OnFailureListener() {
              @Override
              public void onFailure(@NonNull Exception e) {
                // Handle failure.
              }
            });
    
    
  6. उसी पैटर्न का उपयोग startActivityForReauthenticateWithProvider साथ किया जा सकता है जिसका उपयोग हाल के लॉगिन की आवश्यकता वाले संवेदनशील संचालन के लिए नए क्रेडेंशियल्स प्राप्त करने के लिए किया जा सकता है।

    // The user is already signed-in.
    FirebaseUser firebaseUser = firebaseAuth.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.
              }
            });
    

अगला कदम

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

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

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

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

एक उपयोगकर्ता प्रस्थान करने के लिए फोन signOut :

जावा

FirebaseAuth.getInstance().signOut();

Kotlin + KTX

Firebase.auth.signOut()