चेतावनी: यह डेटा Google उपयोगकर्ता डेटा नीति के तहत प्रदान किया गया है। कृपया नीति की समीक्षा करें और उसका पालन करें। ऐसा करने में विफलता के परिणामस्वरूप परियोजना निलंबन या खाता निलंबन हो सकता है।

उपयोगकर्ताओं को उनके सहेजे गए क्रेडेंशियल के साथ साइन इन करें

उपयोगकर्ता द्वारा आपके ऐप में साइन इन करने के लिए पहले उपयोग किए गए क्रेडेंशियल्स में से एक को पुनः प्राप्त करने के लिए अनुमति का अनुरोध करने के लिए वन टैप साइन-इन क्लाइंट का उपयोग करें। ये क्रेडेंशियल या तो Google खाता या उपयोगकर्ता नाम-पासवर्ड संयोजन हो सकते हैं जिन्हें उन्होंने क्रोम, एंड्रॉइड ऑटोफिल या पासवर्ड के लिए स्मार्ट लॉक का उपयोग करके Google के साथ सहेजा है।

एक-टैप साइन-इन UI

जब क्रेडेंशियल सफलतापूर्वक पुनर्प्राप्त हो जाते हैं, तो आप उपयोगकर्ता को अपने ऐप में बिना किसी बाधा के साइन इन करने के लिए उनका उपयोग कर सकते हैं।

यदि उपयोगकर्ता ने कोई क्रेडेंशियल सहेजा नहीं है, तो कोई UI प्रस्तुत नहीं किया जाता है, और आप अपना सामान्य साइन-आउट अनुभव प्रदान कर सकते हैं।

मुझे वन टैप साइन-इन का उपयोग कहां करना चाहिए?

यदि आपके ऐप के लिए उपयोगकर्ताओं को साइन इन करने की आवश्यकता है, तो अपनी साइन-इन स्क्रीन पर वन टैप UI प्रदर्शित करें। यह तब भी मददगार हो सकता है, जब आपके पास पहले से ही "Google से साइन इन करें" बटन हो: क्योंकि वन टैप UI को केवल उन क्रेडेंशियल्स को दिखाने के लिए कॉन्फ़िगर किया जा सकता है, जिनका उपयोग उपयोगकर्ता पहले साइन-इन करने के लिए करता था, यह उन उपयोगकर्ताओं के लिए एक रिमाइंडर हो सकता है जो बार-बार साइन इन करते हैं। उन्होंने पिछली बार कैसे साइन इन किया था, और उन्हें गलती से आपके ऐप के साथ नए खाते बनाने से रोक दिया था।

यदि साइन-इन आपके ऐप के लिए वैकल्पिक है, तो किसी भी स्क्रीन पर वन टैप साइन-इन का उपयोग करने पर विचार करें, जिसमें साइन इन करके अनुभव बढ़ाया गया है। उदाहरण के लिए, यदि उपयोगकर्ता साइन आउट होने पर आपके ऐप के साथ सामग्री ब्राउज़ कर सकते हैं, लेकिन केवल टिप्पणियां पोस्ट कर सकते हैं या साइन इन करने के बाद शॉपिंग कार्ट में आइटम जोड़ें, यह वन टैप साइन-इन के लिए एक समझदार संदर्भ होगा।

साइन-इन वैकल्पिक ऐप्स को भी ऊपर बताए गए कारणों से अपनी साइन-इन स्क्रीन पर वन टैप साइन-इन का उपयोग करना चाहिए।

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

1. वन टैप साइन-इन क्लाइंट को कॉन्फ़िगर करें

आप उपयोगकर्ताओं को सहेजे गए पासवर्ड, सहेजे गए Google खातों, या या तो साइन इन करने के लिए वन टैप साइन-इन क्लाइंट को कॉन्फ़िगर कर सकते हैं। (नए उपयोगकर्ताओं के लिए एक-टैप खाता निर्माण सक्षम करने और अधिक से अधिक लौटने वाले उपयोगकर्ताओं के लिए स्वचालित या एक-टैप साइन-इन सक्षम करने के लिए दोनों का समर्थन करने की अनुशंसा की जाती है।)

यदि आपके ऐप का उपयोग करता है पासवर्ड आधारित साइन-इन, उपयोग setPasswordRequestOptions() पासवर्ड क्रेडेंशियल अनुरोध सक्षम करने के लिए।

अपने ऐप को Google साइन-इन, उपयोग का उपयोग करता है setGoogleIdTokenRequestOptions() को सक्षम और कॉन्फ़िगर गूगल आईडी टोकन अनुरोध करने के लिए:

  • करने के लिए सर्वर क्लाइंट आईडी सेट आईडी आप Google API कंसोल में बनाया । ध्यान दें कि यह आपके सर्वर की क्लाइंट आईडी है, न कि आपकी Android क्लाइंट आईडी।

  • अधिकृत खातों द्वारा फ़िल्टर करने के लिए क्लाइंट को कॉन्फ़िगर करें। जब आप इस विकल्प को सक्षम करते हैं, तो वन टैप क्लाइंट केवल उपयोगकर्ताओं को आपके ऐप में उन Google खातों के साथ साइन इन करने का संकेत देता है जिनका वे पहले से उपयोग कर चुके हैं। ऐसा करने से उपयोगकर्ताओं को सफलतापूर्वक साइन इन करने में मदद मिल सकती है जब वे सुनिश्चित नहीं होते हैं कि उनके पास पहले से ही एक खाता है या उन्होंने किस Google खाते का उपयोग किया है, और उपयोगकर्ताओं को गलती से आपके ऐप के साथ नए खाते बनाने से रोकता है।

  • आप स्वचालित रूप से जब संभव में उन पर हस्ताक्षर करना चाहते हैं, के साथ सुविधा को सक्षम setAutoSelectEnabled() । निम्नलिखित मानदंड पूरे होने पर स्वचालित साइन-इन संभव है:

    • उपयोगकर्ता के पास आपके ऐप के लिए ठीक एक क्रेडेंशियल सहेजा गया है। यानी एक सेव किया हुआ पासवर्ड या एक सेव किया हुआ गूगल अकाउंट।
    • उपयोगकर्ता अक्षम नहीं किया स्वचालित साइन-इन उनके में Google खाता सेटिंग
  • वैकल्पिक होने पर, हम अनुशंसा करते हैं कि आप साइन-इन सुरक्षा को बेहतर बनाने और फिर से चलाने के हमलों से बचने के लिए गैर का उपयोग करने पर दृढ़ता से विचार करें। का प्रयोग करें setNonce प्रत्येक अनुरोध में एक अस्थायी रूप से शामिल करने के लिए। SafetyNet देखें है एक अस्थायी रूप से प्राप्त एक अस्थायी रूप से पैदा करने पर सुझाव के लिए खंड और अतिरिक्त विस्तार।

जावा

public class YourActivity extends AppCompatActivity {
  // ...

  private SignInClient oneTapClient;
  private BeginSignInRequest signInRequest;

  @Override
  public void onCreate(@Nullable Bundle savedInstanceState,
                       @Nullable PersistableBundle persistentState) {
      super.onCreate(savedInstanceState, persistentState);

      oneTapClient = Identity.getSignInClient(this);
      signInRequest = BeginSignInRequest.builder()
              .setPasswordRequestOptions(PasswordRequestOptions.builder()
                      .setSupported(true)
                      .build())
              .setGoogleIdTokenRequestOptions(GoogleIdTokenRequestOptions.builder()
                      .setSupported(true)
                      // Your server's client ID, not your Android client ID.
                      .setServerClientId(getString(R.string.default_web_client_id))
                      // Only show accounts previously used to sign in.
                      .setFilterByAuthorizedAccounts(true)
                      .build())
              // Automatically sign in when exactly one credential is retrieved.
              .setAutoSelectEnabled(true)
              .build();
      // ...
  }
  // ...
}

Kotlin

class YourActivity : AppCompatActivity() {
    // ...

    private lateinit var oneTapClient: SignInClient
    private lateinit var signInRequest: BeginSignInRequest

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        oneTapClient = Identity.getSignInClient(this)
        signInRequest = BeginSignInRequest.builder()
            .setPasswordRequestOptions(BeginSignInRequest.PasswordRequestOptions.builder()
                .setSupported(true)
                .build())
            .setGoogleIdTokenRequestOptions(
                BeginSignInRequest.GoogleIdTokenRequestOptions.builder()
                    .setSupported(true)
                    // Your server's client ID, not your Android client ID.
                    .setServerClientId(getString(R.string.your_web_client_id))
                    // Only show accounts previously used to sign in.
                    .setFilterByAuthorizedAccounts(true)
                    .build())
            // Automatically sign in when exactly one credential is retrieved.
            .setAutoSelectEnabled(true)
            .build()
        // ...
    }
    // ...
}

2. साइन-इन किए हुए उपयोगकर्ता की जांच करें

यदि आपकी गतिविधि का उपयोग साइन-इन उपयोगकर्ता या साइन-आउट उपयोगकर्ता द्वारा किया जा सकता है, तो वन टैप साइन-इन UI प्रदर्शित करने से पहले उपयोगकर्ता की स्थिति जांचें।

आपको यह भी ट्रैक करना चाहिए कि क्या उपयोगकर्ता ने पहले ही एक टैप साइन-इन का उपयोग करने से मना कर दिया है या तो प्रॉम्प्ट को बंद करके या इसके बाहर टैप करके। यह आपकी गतिविधि की बूलियन संपत्ति जितना आसान हो सकता है। (देखें बंद करो एक नल यूआई प्रदर्शित नीचे दिए गए।)

3. वन टैप साइन-इन UI प्रदर्शित करें

उपयोगकर्ता साइन इन नहीं कर रहा है और पहले से ही उपयोग करने के लिए एक नल साइन-इन से इनकार कर दिया नहीं किया गया है, ग्राहक वस्तु की फोन beginSignIn() विधि, और करने के लिए श्रोताओं देते Task वापस करती है। Apps का आम तौर पर गतिविधि के दशक में ऐसा करने onCreate() विधि या स्क्रीन संक्रमण के बाद जब एक एकल गतिविधि वास्तुकला का प्रयोग।

वन टैप क्लाइंट सफल श्रोता को कॉल करेगा यदि उपयोगकर्ता के पास आपके ऐप के लिए कोई सहेजे गए क्रेडेंशियल हैं। सफलता श्रोता में, से आशय लंबित मिल Task परिणाम और इसे करने के लिए पारित startIntentSenderForResult() एक नल साइन-इन यूआई शुरू करने के लिए।

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

जावा

oneTapClient.beginSignIn(signUpRequest)
        .addOnSuccessListener(this, new OnSuccessListener<BeginSignInResult>() {
            @Override
            public void onSuccess(BeginSignInResult result) {
                try {
                    startIntentSenderForResult(
                            result.getPendingIntent().getIntentSender(), REQ_ONE_TAP,
                            null, 0, 0, 0);
                } catch (IntentSender.SendIntentException e) {
                    Log.e(TAG, "Couldn't start One Tap UI: " + e.getLocalizedMessage());
                }
            }
        })
        .addOnFailureListener(this, new OnFailureListener() {
            @Override
            public void onFailure(@NonNull Exception e) {
                // No saved credentials found. Launch the One Tap sign-up flow, or
                // do nothing and continue presenting the signed-out UI.
                Log.d(TAG, e.getLocalizedMessage());
            }
        });

Kotlin

oneTapClient.beginSignIn(signInRequest)
    .addOnSuccessListener(this) { result ->
        try {
            startIntentSenderForResult(
                result.pendingIntent.intentSender, REQ_ONE_TAP,
                null, 0, 0, 0, null)
        } catch (e: IntentSender.SendIntentException) {
            Log.e(TAG, "Couldn't start One Tap UI: ${e.localizedMessage}")
        }
    }
    .addOnFailureListener(this) { e ->
        // No saved credentials found. Launch the One Tap sign-up flow, or
        // do nothing and continue presenting the signed-out UI.
        Log.d(TAG, e.localizedMessage)
    }

4. उपयोगकर्ता की प्रतिक्रिया को संभालें

एक नल प्रवेश करने का संकेत करने के लिए उपयोगकर्ता की प्रतिक्रिया आपकी गतिविधि के उपयोग करके आपके एप्लिकेशन को दे दी जाएगी onActivityResult() विधि। यदि उपयोगकर्ता ने साइन इन करना चुना है, तो परिणाम एक सहेजा गया क्रेडेंशियल होगा। उपयोगकर्ता, प्रवेश करने के लिए या तो एक नल यूआई बंद करने या इसे बाहर दोहन से मना कर दिया, तो परिणाम कोड के साथ वापस आ जाएगी RESULT_CANCELED । आपके ऐप को दोनों संभावनाओं को संभालने की जरूरत है।

पुनः प्राप्त क्रेडेंशियल के साथ साइन इन करें

उपयोगकर्ता ने आपके ऐप के साथ साझा क्रेडेंशियल्स चुना है, तो आप उन लोगों से आशय डेटा पास करके प्राप्त कर सकते हैं onActivityResult() एक नल ग्राहक के लिए getSignInCredentialFromIntent() विधि। क्रेडेंशियल एक गैर-शून्य होगा googleIdToken संपत्ति यदि उपयोगकर्ता ने आपके ऐप से Google खाता क्रेडेंशियल, या एक गैर-शून्य साझा password यदि उपयोगकर्ता सहेजा गया पासवर्ड साझा संपत्ति।

अपने ऐप के बैकएंड के साथ प्रमाणित करने के लिए क्रेडेंशियल का उपयोग करें।

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

जावा

public class YourActivity extends AppCompatActivity {

  // ...
  private static final int REQ_ONE_TAP = 2;  // Can be any integer unique to the Activity.
  private boolean showOneTapUI = true;
  // ...

  @Override
  protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
      super.onActivityResult(requestCode, resultCode, data);

      switch (requestCode) {
          case REQ_ONE_TAP:
              try {
                  SignInCredential credential = oneTapClient.getSignInCredentialFromIntent(data);
                  String idToken = credential.getGoogleIdToken();
                  String username = credential.getId();
                  String password = credential.getPassword();
                  if (idToken !=  null) {
                      // Got an ID token from Google. Use it to authenticate
                      // with your backend.
                      Log.d(TAG, "Got ID token.");
                  } else if (password != null) {
                      // Got a saved username and password. Use them to authenticate
                      // with your backend.
                      Log.d(TAG, "Got password.");
                  }
              } catch (ApiException e) {
                  // ...
              }
              break;
      }
  }
}

Kotlin

class YourActivity : AppCompatActivity() {

    // ...
    private val REQ_ONE_TAP = 2  // Can be any integer unique to the Activity
    private var showOneTapUI = true
    // ...

    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)

        when (requestCode) {
             REQ_ONE_TAP -> {
                try {
                    val credential = oneTapClient.getSignInCredentialFromIntent(data)
                    val idToken = credential.googleIdToken
                    val username = credential.id
                    val password = credential.password
                    when {
                        idToken != null -> {
                            // Got an ID token from Google. Use it to authenticate
                            // with your backend.
                            Log.d(TAG, "Got ID token.")
                        }
                        password != null -> {
                            // Got a saved username and password. Use them to authenticate
                            // with your backend.
                            Log.d(TAG, "Got password.")
                        }
                        else -> {
                            // Shouldn't happen.
                            Log.d(TAG, "No ID token or password!")
                        }
                    }
                } catch (e: ApiException) {
                    // ...
                }
            }
        }
    }
    // ...
}

वन टैप यूआई प्रदर्शित करना बंद करें

उपयोगकर्ता को प्रवेश करने से मना कर दिया, तो करने के लिए कॉल getSignInCredentialFromIntent() एक फेंक होगा ApiException एक साथ CommonStatusCodes.CANCELED स्थिति कोड। जब ऐसा होता है, तो आपको वन टैप साइन-इन UI को अस्थायी रूप से अक्षम कर देना चाहिए ताकि आप अपने उपयोगकर्ताओं को बार-बार संकेतों से परेशान न करें। निम्नलिखित उदाहरण गतिविधि पर एक संपत्ति सेट करके इसे पूरा करता है, जिसका उपयोग यह निर्धारित करने के लिए करता है कि उपयोगकर्ता को वन टैप साइन-इन की पेशकश की जाए या नहीं; हालांकि, आप भी करने के लिए एक मूल्य की बचत हो सकती SharedPreferences या किसी अन्य विधि का उपयोग करें।

वन टैप साइन-इन संकेतों की अपनी सीमित दर को लागू करना महत्वपूर्ण है। यदि आप ऐसा नहीं करते हैं, और कोई उपयोगकर्ता लगातार कई संकेतों को रद्द करता है, तो वन टैप क्लाइंट अगले 24 घंटों के लिए उपयोगकर्ता को संकेत नहीं देगा।

जावा

public class YourActivity extends AppCompatActivity {

  // ...
  private static final int REQ_ONE_TAP = 2;  // Can be any integer unique to the Activity.
  private boolean showOneTapUI = true;
  // ...

  @Override
  protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
      super.onActivityResult(requestCode, resultCode, data);

      switch (requestCode) {
          case REQ_ONE_TAP:
              try {
                  // ...
              } catch (ApiException e) {
                  switch (e.getStatusCode()) {
                      case CommonStatusCodes.CANCELED:
                          Log.d(TAG, "One-tap dialog was closed.");
                          // Don't re-prompt the user.
                          showOneTapUI = false;
                          break;
                      case CommonStatusCodes.NETWORK_ERROR:
                          Log.d(TAG, "One-tap encountered a network error.");
                          // Try again or just ignore.
                          break;
                      default:
                          Log.d(TAG, "Couldn't get credential from result."
                                  + e.getLocalizedMessage());
                          break;
                  }
              }
              break;
      }
  }
}

Kotlin

class YourActivity : AppCompatActivity() {

    // ...
    private val REQ_ONE_TAP = 2  // Can be any integer unique to the Activity
    private var showOneTapUI = true
    // ...

    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)

        when (requestCode) {
            REQ_ONE_TAP -> {
                try {
                    // ...
                } catch (e: ApiException) {
                    when (e.statusCode) {
                        CommonStatusCodes.CANCELED -> {
                            Log.d(TAG, "One-tap dialog was closed.")
                            // Don't re-prompt the user.
                            showOneTapUI = false
                        }
                        CommonStatusCodes.NETWORK_ERROR -> {
                            Log.d(TAG, "One-tap encountered a network error.")
                            // Try again or just ignore.
                        }
                        else -> {
                            Log.d(TAG, "Couldn't get credential from result." +
                                " (${e.localizedMessage})")
                        }
                    }
                }
            }
        }
    }
    // ...
}

5. साइन-आउट संभालें

जब कोई उपयोगकर्ता साइन अपने अनुप्रयोग से बाहर, एक नल ग्राहक के फोन signOut() विधि। कॉलिंग signOut() स्वचालित साइन-इन अक्षम कर देता है फिर में उपयोगकर्ता के प्रवेश जब तक।

यहां तक ​​कि अगर आप स्वचालित साइन-इन का उपयोग नहीं करते हैं, तो भी यह चरण महत्वपूर्ण है क्योंकि यह सुनिश्चित करता है कि जब उपयोगकर्ता आपके ऐप से साइन आउट करते हैं, तो आपके द्वारा उपयोग की जाने वाली किसी भी Play सेवा API की प्रमाणीकरण स्थिति भी रीसेट हो जाती है।

अगला कदम

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

आप Google साइन-इन का समर्थन, तो आप भी करने के लिए ग्राहक एक नल का उपयोग कर सकते घर्षणहीन खाता निर्माण को अपने ऐप्लिकेशन पर बहती जोड़ने