Catch up on everything we announced at this year's Firebase Summit. Learn more

Inizia con l'autenticazione Firebase in C++

Puoi utilizzare l'autenticazione Firebase per consentire agli utenti di accedere alla tua app utilizzando uno o più metodi di accesso, inclusi indirizzo e-mail e password, e provider di identità federati come Google Sign-in e Facebook Login. Questo tutorial ti consente di iniziare con l'autenticazione Firebase mostrandoti come aggiungere l'indirizzo e-mail e la password di accesso alla tua app.

Connetti il ​​tuo progetto C++ a Firebase

Prima di poter utilizzare l'autenticazione Firebase , è necessario:

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

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

  • Aggiungere la Firebase SDK C ++ al progetto il vostro C ++.

Si noti che l'aggiunta di Firebase al C ++ progetto prevede attività sia nella console Firebase e nel progetto aperto C ++ (per esempio, si scaricano i file di configurazione Firebase dalla console, poi li sposta nel vostro C ++ del progetto).

Registra nuovi utenti

Crea un modulo che consenta ai nuovi utenti di registrarsi alla tua app utilizzando il loro indirizzo email e una password. Quando un utente compila il modulo, convalidare l'indirizzo email e la password fornita dall'utente, per poi passare al CreateUserWithEmailAndPassword metodo:

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

È possibile controllare lo stato dell'operazione di creazione dell'account o registrando un callback sulla CreateUserWithEmailAndPasswordLastResult oggetto futuro, o, se si sta scrivendo un gioco o app con un qualche tipo di ciclo di aggiornamento periodico, dal polling lo stato nel ciclo di aggiornamento.

Ad esempio, utilizzando un Futuro:

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

// The lambda has the same signature as the callback function.
result.OnCompletion(
    [](const firebase::Future<firebase::auth::User*>& 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);

Oppure, per usare il polling, fai qualcosa come il seguente esempio nel ciclo di aggiornamento del tuo gioco:

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

Accedi utenti esistenti

Crea un modulo che consenta agli utenti esistenti di accedere utilizzando il loro indirizzo email e la password. Quando un utente completa il modulo, chiamare il SignInWithEmailAndPassword metodo:

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

Ottieni il risultato dell'operazione di accesso nello 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 disconnessione, collegare un listener all'oggetto di autenticazione globale. Questo listener viene chiamato ogni volta che cambia lo stato di accesso dell'utente. Poiché il listener viene eseguito solo dopo che l'oggetto di autenticazione è stato completamente inizializzato e dopo il completamento di tutte le chiamate di rete, è il posto migliore per ottenere informazioni sull'utente che ha eseguito l'accesso.

Creare l'ascoltatore implementando la firebase::auth::AuthStateListener classe astratta. Ad esempio, per creare un listener che ottiene informazioni sull'utente quando un utente accede correttamente:

class MyAuthStateListener : public firebase::auth::AuthStateListener {
 public:
  void OnAuthStateChanged(firebase::auth::Auth* auth) override {
    firebase::auth::User* user = auth->current_user();
    if (user != nullptr) {
      // 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");
    }
    // ...
  }
};

Fissare l'ascoltatore con la firebase::auth::Auth dell'oggetto AddAuthStateListener metodo:

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

Prossimi passi

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