Twórz nowe konta jednym kliknięciem

Jeśli obsługujesz logowanie za pomocą kont Google, możesz użyć klienta logowania One Tap, aby umożliwić użytkownikom bezproblemowe tworzenie kont bez konieczności opuszczania kontekstu aplikacji.

Logowanie jednym dotknięciem

Gdy wyświetlisz interfejs One Tap, 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 identyfikacyjny z podstawowymi informacjami z profilu (nazwą, zdjęciem profilowym i zweryfikowanym adresem e-mail), których możesz użyć do utworzenia nowego konta.

Wdrożenie tworzenia konta za pomocą rejestracji jednym dotknięciem składa się z 2 części:

  • zintegrowanie klienta One Tap z aplikacją (opis na tej stronie); Jest to w większości takie samo jak logowanie jednym dotknięciem, ale z niektórymi różnicami w konfiguracji.
  • Dodanie do backendu możliwości tworzenia kont użytkowników na podstawie tokenów identyfikacyjnych Google, o których mowa w artykule Korzystanie z tokenów identyfikacyjnych na backendzie.

W jakich sytuacjach należy używać rejestracji jednym dotknięciem?

Najlepszym miejscem na zaoferowanie użytkownikom rejestracji jednym dotknięciem jest kontekst, w którym zalogowanie umożliwi korzystanie z nowych funkcji. Najpierw spróbuj zalogować użytkownika za pomocą zapisanych danych logowania. Jeśli nie uda się znaleźć zapisanych danych logowania, zaproponuj użytkownikowi utworzenie nowego konta.

Zanim zaczniesz

Skonfiguruj projekt interfejsów API Google i projekt na Androida zgodnie z opisem w artykule Pierwsze kroki z logowaniem za pomocą jednego kliknięcia.

1. Konfigurowanie klienta One Tap

Aby skonfigurować klienta One Tap do tworzenia kont:

  • Nie zezwalaj na żądania dotyczące danych logowania. (Rejestracja jednym dotknięciem jest możliwa tylko w przypadku uwierzytelniania za pomocą tokena).

  • Włącz żądania tokena 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. Śledzenie anulowania interfejsu logowania jednym dotknięciem

Pamiętaj, aby śledzić, czy użytkownik zrezygnował z rejestracji za pomocą jednego kliknięcia, zamykając prompt lub klikając poza nim. Może to być coś tak prostego jak logiczna właściwość aktywności. (patrz sekcja Wyłączanie interfejsu One Tap poniżej).

3. Wyświetlanie interfejsu rejestracji jednym dotknięciem

Jeśli użytkownik nie odrzucił użycia One Tap do utworzenia nowego konta, wywołaj metodę beginSignIn() obiektu klienta i dołącz do niej odbiorców zdarzeń Task. Aplikacje zwykle wykonują ten krok, gdy żądanie logowania za pomocą One Tap nie znajdzie żadnych zapisanych danych logowania. Dzieje się tak w słuchaczu niepowodzenia żądania logowania.

Jeśli na urządzeniu użytkownika jest skonfigurowane co najmniej 1 konto Google, klient logowania jednym dotknięciem wywoła metodę success listener. W słuchaczu sukcesu pobierz oczekujący zamiar z wyniku Task i przekaż go do startIntentSenderForResult(), aby uruchomić interfejs One Tap.

Jeśli użytkownik nie ma na urządzeniu żadnych kont Google, klient One Tap wywoła odbiornik błędów. W tym przypadku nie musisz nic robić: możesz po prostu kontynuować wyświetlanie aplikacji w trybie niezalogowanym, a użytkownik może się zarejestrować, korzystając z normalnego 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ługa odpowiedzi użytkownika

Odpowiedź użytkownika na prośbę o rejestrację w One Tap zostanie przekazana do Twojej aplikacji za pomocą metody onActivityResult() aktywności. Jeśli użytkownik zdecyduje się utworzyć konto, otrzyma token identyfikatora Google. Jeśli użytkownik odmówi rejestracji, zamknie interfejs One Tap lub kliknie poza nim, wynik zostanie zwrócony z kodem RESULT_CANCELED. Aplikacja musi obsługiwać obie te możliwości.

Tworzenie konta za pomocą tokena Google ID

Jeśli użytkownik zdecyduje się zarejestrować za pomocą konta Google, możesz uzyskać token tożsamości tego użytkownika, przekazując dane o intencji z onActivityResult() do metody getSignInCredentialFromIntent() klienta One Tap. Uprawnienia będą miały niepustą właściwość googleIdToken.

Użyj tokena ID, aby utworzyć konto na zapleczu (patrz Uwierzytelnianie za pomocą zaplecza za pomocą tokenów ID), i zaloguj użytkownika.

Uwierzytelnienie zawiera też wszelkie dodatkowe informacje, o które prosisz, np. zweryfikowany numer telefonu konta (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 logowania jednym dotknięciem,

Jeśli użytkownik odmówi zalogowania się, wywołanie metody getSignInCredentialFromIntent() zwróci wartość ApiException z kodem stanu CommonStatusCodes.CANCELED. W takim przypadku tymczasowo wyłącz wyświetlanie interfejsu logowania One Tap, aby nie irytować użytkowników powtarzającymi się prośbami. W tym przykładzie jest to osiągane przez ustawienie właściwości w działaniu, która służy do określenia, czy użytkownikowi ma zostać zaoferowane logowanie za pomocą jednego kliknięcia. Możesz też zapisać wartość w ustawieniu SharedPreferences lub użyć innej metody.

Ważne jest, aby wdrożyć własne ograniczenie szybkości wyświetlania promptów logowania jednym dotknięciem. Jeśli tego nie zrobisz, a użytkownik anuluje kilka kolejnych próśb o dostęp, klient One Tap nie będzie wyświetlać próśb przez kolejne 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 ukończy proces rejestracji za pomocą funkcji One Tap, otrzymasz token Google ID, który zawiera podstawowe informacje z profilu: adres e-mail użytkownika, imię i nazwisko oraz adres URL zdjęcia profilowego. W przypadku wielu aplikacji te informacje wystarczą do uwierzytelniania użytkownika na zapleczu i tworzenia nowego konta.

Jeśli do utworzenia konta potrzebne są dodatkowe informacje, np. data urodzenia użytkownika, wyświetl użytkownikowi formularz rejestracji, w którym poprosisz o te dane. Następnie prześlij je do backendu, aby utworzyć konto.