Questa pagina è stata tradotta dall'API Cloud Translation.
Switch to English

Inizia con Firebase Authentication in C ++

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

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, allora è già registrato e configurato per Firebase.

  • Nel tuo file build.gradle livello di build.gradle , assicurati di includere il repository Maven di Google in entrambe le sezioni buildscript e allprojects .

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

Tieni presente che l'aggiunta di Firebase al tuo progetto C ++ implica attività sia nella console Firebase che nel tuo progetto C ++ aperto (ad esempio, scarichi i file di configurazione di Firebase dalla console, quindi li sposti nel tuo progetto C ++).

Iscrivi nuovi utenti

Crea un modulo che consenta ai nuovi utenti di registrarsi con la tua app utilizzando il loro indirizzo email e una password. Quando un utente completa il modulo, convalida l'indirizzo e-mail e la password forniti dall'utente, quindi CreateUserWithEmailAndPassword metodo CreateUserWithEmailAndPassword :

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

Puoi controllare lo stato dell'operazione di creazione dell'account registrando un callback sull'oggetto CreateUserWithEmailAndPasswordLastResult Future oppure, se stai scrivendo un gioco o un'app con una sorta di ciclo di aggiornamento periodico, eseguendo il polling dello 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 utilizzare 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 agli utenti esistenti

Crea un modulo che consenta agli utenti esistenti di accedere utilizzando il proprio indirizzo e-mail e la password. Quando un utente completa il modulo, chiama il metodo SignInWithEmailAndPassword :

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 dell'iscrizione.

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

Per rispondere agli eventi di accesso e disconnessione, collega un listener all'oggetto di autenticazione globale. Questo listener viene chiamato ogni volta che lo stato di accesso dell'utente cambia. Poiché il listener viene eseguito solo dopo che l'oggetto di autenticazione è stato completamente inizializzato e dopo che tutte le chiamate di rete sono state completate, è il posto migliore per ottenere informazioni sull'utente connesso.

Crea il listener implementando la classe astratta firebase::auth::AuthStateListener . Ad esempio, per creare un listener che ottiene informazioni sull'utente quando un utente accede con successo:

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

Collega il listener con il metodo AddAuthStateListener dell'oggetto firebase::auth::Auth :

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

Prossimi passi

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