Inizia a utilizzare Firebase Authentication in C++

Puoi utilizzare Firebase Authentication per consentire agli utenti di accedere alla tua app usandone uno o più metodi di accesso, tra cui accesso tramite indirizzo email e password, e Provider di identità federati come Accedi con Google e Accesso a Facebook. Questo il tutorial inizia a usare Firebase Authentication mostrandoti come aggiungere per accedere alla tua app tramite indirizzo email e password.

Collega il tuo progetto C++ a Firebase

Prima di poter utilizzare Firebase Authentication, devi:

  • Registra il tuo progetto C++ e configuralo per utilizzare Firebase.

    Se il tuo progetto C++ utilizza già Firebase, significa che è già registrato e configurato per Firebase.

  • Aggiungi l'SDK Firebase C++ al tuo progetto C++.

di Gemini Advanced.

Tieni presente che l'aggiunta di Firebase al tuo progetto C++ comporta attività sia nel Console Firebase e nel tuo progetto C++ aperto (ad esempio, scarichi di configurazione di Firebase dalla console, quindi spostali nel progetto C++).

Registrazione di nuovi utenti

Crea un modulo che consenta ai nuovi utenti di registrarsi alla tua app utilizzando il loro un indirizzo email e una password. Quando un utente compila il modulo, convalida il l'indirizzo email e la password forniti dall'utente, quindi passali al Metodo CreateUserWithEmailAndPassword:

firebase::Future<firebase::auth::AuthResult> result =
    auth->CreateUserWithEmailAndPassword(email, password);

Puoi controllare lo stato dell'operazione di creazione dell'account registrandoti un callback sull'oggetto futuro CreateUserWithEmailAndPasswordLastResult; oppure se stai scrivendo un gioco o un'app con un qualche tipo di ciclo di aggiornamento periodico, che esegue il polling dello stato nel loop di aggiornamento.

Ad esempio, utilizzando un Future:

firebase::Future<firebase::auth::AuthResult> result =
    auth->CreateUserWithEmailAndPasswordLastResult();

// The lambda has the same signature as the callback function.
result.OnCompletion(
    [](const firebase::Future<firebase::auth::AuthResult>& result,
       void* user_data) {
      // `user_data` is the same as &my_program_context, below.
      // Note that we can't capture this value in the [] because std::function
      // is not supported by our minimum compiler spec (which is pre C++11).
      MyProgramContext* program_context =
          static_cast<MyProgramContext*>(user_data);

      // Process create user result...
      (void)program_context;
    },
    &my_program_context);

In alternativa, per usare i sondaggi, fai qualcosa come l'esempio seguente nella loop di aggiornamento:

firebase::Future<firebase::auth::AuthResult> result =
    auth->CreateUserWithEmailAndPasswordLastResult();
if (result.status() == firebase::kFutureStatusComplete) {
  if (result.error() == firebase::auth::kAuthErrorNone) {
    firebase::auth::AuthResult* auth_result = *result.result();
    printf("Create user succeeded for email %s\n", auth_result.user.email().c_str());
  } else {
    printf("Created user failed with error '%s'\n", result.error_message());
  }
}

Accedere agli utenti esistenti

Crea un modulo che consenta agli utenti esistenti di accedere con il proprio indirizzo email. e password. Quando un utente compila il modulo, richiama il metodo Metodo SignInWithEmailAndPassword:

firebase::Future<firebase::auth::AuthResult> result =
    auth->SignInWithEmailAndPassword(email, password);

Ottieni il risultato dell'operazione di accesso allo stesso modo in cui hai ottenuto il risultato della registrazione.

Imposta un listener dello stato di autenticazione e ottieni i dati dell'account

Per rispondere agli eventi di accesso e uscita, allega un listener alla finestra globale di autenticazione. Questo listener viene chiamato ogni volta che l'utente esegue l'accesso modifiche dello stato. Poiché il listener viene eseguito solo dopo che l'oggetto di autenticazione è sia completamente inizializzato e al termine delle chiamate di rete, per ottenere informazioni sull'utente che ha eseguito l'accesso.

Crea il listener implementando firebase::auth::AuthStateListener una classe astratta. Ad esempio, per creare un listener che riceva informazioni su Quando un utente esegue l'accesso:

class MyAuthStateListener : public firebase::auth::AuthStateListener {
 public:
  void OnAuthStateChanged(firebase::auth::Auth* auth) override {
    firebase::auth::User user = auth.current_user();
    if (user.is_valid()) {
      // User is signed in
      printf("OnAuthStateChanged: signed_in %s\n", user.uid().c_str());
      const std::string displayName = user.DisplayName();
      const std::string emailAddress = user.Email();
      const std::string photoUrl = user.PhotoUrl();
    } else {
      // User is signed out
      printf("OnAuthStateChanged: signed_out\n");
    }
    // ...
  }
};

Collega il listener con l'oggetto firebase::auth::Auth Metodo AddAuthStateListener:

MyAuthStateListener state_change_listener;
auth->AddAuthStateListener(&state_change_listener);

Passaggi successivi

Scopri come aggiungere il supporto di altri provider di identità e account ospite anonimi: