Twórz nowe konta jednym kliknięciem

Jeśli obsługujesz logowanie za pomocą kont Google, możesz użyć klienta logowania jednym dotknięciem, aby zapewnić użytkownikom bezproblemowe tworzenie konta bez opuszczania kontekstu aplikacji.

Interfejs rejestracji jednym dotknięciem

Gdy wyświetlisz interfejs jedno dotknięcie, użytkownicy zobaczą prośbę o utworzenie nowego konta w aplikacji za pomocą jednego z kont Google na urządzeniu. Jeśli użytkownik zdecyduje się kontynuować, otrzymasz token identyfikatora z podstawowymi informacjami o profilu – imieniem i nazwiskiem, zdjęciem profilowym oraz zweryfikowanym adresem e-mail – których możesz użyć do utworzenia nowego konta.

Wdrożenie tworzenia konta za pomocą One Tap składa się z 2 części:

  • Integracja klienta jedno dotknięcie z aplikacją, co opisujemy na tej stronie. Jest to w większości takie samo jak logowanie jednym dotknięciem, ale z pewnymi różnicami w konfiguracji.
  • Dodanie do backendu możliwości tworzenia kont użytkowników na podstawie tokenów identyfikatora Google, co opisujemy w sekcji Używanie tokenów identyfikatora w backendzie.

Gdzie mogę używać rejestracji jednym dotknięciem?

Najlepszym miejscem, w którym możesz zaoferować użytkownikom rejestrację jednym dotknięciem, jest kontekst, w którym logowanie umożliwi korzystanie z nowych funkcji. Najpierw spróbuj zalogować użytkownika za pomocą zapisanych danych logowania. Jeśli nie znajdziesz zapisanych danych logowania, zaproponuj użytkownikowi utworzenie nowego konta.

Zanim zaczniesz

Skonfiguruj projekt w Konsoli interfejsów API Google i projekt aplikacji na Androida zgodnie z opisem w Pierwsze kroki z logowaniem jednym dotknięciem.

1. Skonfiguruj klienta One Tap

Aby skonfigurować klienta jedno dotknięcie do tworzenia konta:

  • Nie włączaj żądań danych logowania. (Rejestracja jednym dotknięciem jest możliwa tylko w przypadku uwierzytelniania opartego na tokenach).

  • Włącz żądania tokenów identyfikatora Google za pomocą setGoogleIdTokenRequestOptions() i tych ustawień:

Java

public class YourActivity extends AppCompatActivity {

  // ...

  private SignInClient oneTapClient;
  private BeginSignInRequest signUpRequest;

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

      oneTapClient = Identity.getSignInClient(this);
      signUpRequest = BeginSignInRequest.builder()
              .setGoogleIdTokenRequestOptions(GoogleIdTokenRequestOptions.builder()
                      .setSupported(true)
                      // Your server's client ID, not your Android client ID.
                      .setServerClientId(getString(R.string.your_web_client_id))
                      // Show all accounts on the device.
                      .setFilterByAuthorizedAccounts(false)
                      .build())
              .build();

      // ...
  }
}

Kotlin

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

    private lateinit var oneTapClient: SignInClient
    private lateinit var signUpRequest: BeginSignInRequest

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

        oneTapClient = Identity.getSignInClient(this)
        signUpRequest = BeginSignInRequest.builder()
            .setGoogleIdTokenRequestOptions(
                BeginSignInRequest.GoogleIdTokenRequestOptions.builder()
                    .setSupported(true)
                    // Your server's client ID, not your Android client ID.
                    .setServerClientId(getString(R.string.your_web_client_id))
                    // Show all accounts on the device.
                    .setFilterByAuthorizedAccounts(false)
                    .build())
            .build()
        // ...
    }
    // ...
}

2. Śledź anulowanie interfejsu jedno dotknięcie

Musisz śledzić, czy użytkownik odrzucił już rejestrację jednym dotknięciem, zamykając okno lub klikając poza nim. Może to być tak proste jak właściwość logiczna Twojej aktywności. (Patrz sekcja Przestań wyświetlać interfejs jedno dotknięcie UI poniżej).

3. Wyświetl interfejs rejestracji jednym dotknięciem

Jeśli użytkownik nie odrzucił rejestracji jednym dotknięciem, wywołaj metodę beginSignIn() obiektu klienta i dołącz do niej detektory Task. Aplikacje zwykle wykonują ten krok, gdy żądanie logowania jednym dotknięciem nie znajduje zapisanych danych logowania, czyli w detektorze niepowodzenia żądania logowania.

Klient jedno dotknięcie wywoła detektor sukcesu, jeśli użytkownik ma na urządzeniu co najmniej 1 skonfigurowane konto Google. W detektorze sukcesu pobierz intencję oczekującą z wyniku Task i przekaż ją do startIntentSenderForResult(), aby uruchomić interfejs jedno dotknięcie.

Jeśli użytkownik nie ma na urządzeniu żadnego konta Google, klient jedno dotknięcie wywoła detektor niepowodzenia. W takim przypadku nie musisz nic robić. Możesz po prostu kontynuować wyświetlanie aplikacji w stanie wylogowania, a użytkownik może zarejestrować się za pomocą zwykłego procesu tworzenia konta.

Java

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 Google Accounts found. Just continue presenting the signed-out UI.
                Log.d(TAG, e.getLocalizedMessage());
            }
        });

Kotlin

oneTapClient.beginSignIn(signUpRequest)
    .addOnSuccessListener(this) { result ->
        try {
            startIntentSenderForResult(
                result.pendingIntent.intentSender, REQ_ONE_TAP,
                null, 0, 0, 0)
        } catch (e: IntentSender.SendIntentException) {
            Log.e(TAG, "Couldn't start One Tap UI: ${e.localizedMessage}")
        }
    }
    .addOnFailureListener(this) { e ->
        // No Google Accounts found. Just continue presenting the signed-out UI.
        Log.d(TAG, e.localizedMessage)
    }

4. Obsłuż odpowiedź użytkownika

Odpowiedź użytkownika na prośbę o rejestrację jednym dotknięciem zostanie zgłoszona do aplikacji za pomocą metody onActivityResult() aktywności. Jeśli użytkownik zdecyduje się utworzyć konto, wynikiem będzie token identyfikatora Google. Jeśli użytkownik odrzuci rejestrację, zamykając interfejs jedno dotknięcie lub klikając poza nim, wynik zostanie zwrócony z kodem RESULT_CANCELED. Twoja aplikacja musi obsługiwać obie te możliwości.

Utwórz konto za pomocą tokena identyfikatora Google

Jeśli użytkownik zdecyduje się zarejestrować za pomocą konta Google, możesz uzyskać token identyfikatora, przekazując dane intencji z onActivityResult() do metody getSignInCredentialFromIntent() klienta jedno dotknięcie. Poświadczenie będzie miało właściwość googleIdToken o wartości innej niż null.

Użyj tokena identyfikatora, aby utworzyć konto w backendzie (patrz Uwierzytelnianie w backendzie za pomocą tokenów identyfikatora) i zalogować użytkownika.

Dane logowania zawierają też dodatkowe informacje, o które prosisz, np. zweryfikowany numer telefonu powiązany z kontem, jeśli jest dostępny.

Java

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();
                  if (idToken !=  null) {
                      // Got an ID token from Google. Use it to authenticate
                      // with your backend.
                      Log.d(TAG, "Got ID token.");
                  }
              } 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
                    when {
                        idToken != null -> {
                            // Got an ID token from Google. Use it to authenticate
                            // with your backend.
                            Log.d(TAG, "Got ID token.")
                        }
                        else -> {
                            // Shouldn't happen.
                            Log.d(TAG, "No ID token!")
                        }
                    }
                } catch (e: ApiException) {
                    // ...
            }
        }
    }
    // ...
}

Przestań wyświetlać interfejs jedno dotknięcie

Jeśli użytkownik odrzuci logowanie, wywołanie getSignInCredentialFromIntent() spowoduje zgłoszenie ApiException z kodem stanu CommonStatusCodes.CANCELED. W takim przypadku tymczasowo przestań wyświetlać interfejs logowania jednym dotknięciem, aby nie irytować użytkowników powtarzającymi się prośbami. W tym przykładzie osiągamy to, ustawiając właściwość w aktywności, która służy do określania, czy oferować użytkownikowi logowanie jednym dotknięciem. Możesz też jednak zapisać wartość w SharedPreferences lub użyć innej metody.

Ważne jest, aby wdrożyć własne ograniczanie liczby żądań wyświetleń próśb o logowanie jednym dotknięciem. Jeśli tego nie zrobisz, a użytkownik odrzuci kilka próśb z rzędu, klient jedno dotknięcie nie będzie wyświetlał próśb przez następne 24 godziny.

Java

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

Dalsze kroki

Gdy użytkownik zakończy proces rejestracji jednym dotknięciem, otrzymasz token identyfikatora Google, który zawiera podstawowe informacje o profilu: adres e-mail, imię i nazwisko oraz adres URL zdjęcia profilowego. W przypadku wielu aplikacji te informacje wystarczą do uwierzytelnienia użytkownika w backendzie i utworzenia nowego konta.

Jeśli do utworzenia konta potrzebujesz dodatkowych informacji, np. daty urodzenia użytkownika, wyświetl użytkownikowi proces podawania szczegółów rejestracji, w którym poprosisz o te dodatkowe informacje. Następnie wyślij je do backendu, aby dokończyć tworzenie konta.