O Google tem o compromisso de promover a igualdade racial para as comunidades negras. Saiba como.

Introdução ao Firebase Authentication em C++

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Você pode usar o Firebase Authentication para permitir que os usuários façam login no seu aplicativo usando um ou mais métodos de login, incluindo login por endereço de e-mail e senha e provedores de identidade federados, como Login do Google e Login do Facebook. Este tutorial é uma introdução ao Firebase Authentication mostrando como adicionar o login de endereço de e-mail e senha ao seu aplicativo.

Conecte seu projeto C++ ao Firebase

Antes de usar o Firebase Authentication , você precisa:

  • Registre seu projeto C++ e configure-o para usar o Firebase.

    Se seu projeto C++ já usa o Firebase, ele já está registrado e configurado para o Firebase.

  • Adicione o SDK C++ do Firebase ao seu projeto C++.

Observe que adicionar o Firebase ao seu projeto C++ envolve tarefas no console do Firebase e no seu projeto C++ aberto (por exemplo, você faz o download dos arquivos de configuração do Firebase do console e os move para o seu projeto C++).

Inscreva-se novos usuários

Crie um formulário que permita que novos usuários se registrem no seu aplicativo usando o endereço de e-mail e uma senha. Quando um usuário preencher o formulário, valide o endereço de e-mail e a senha fornecidos pelo usuário e, em seguida, passe-os para o método CreateUserWithEmailAndPassword :

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

Você pode verificar o status da operação de criação de conta registrando um retorno de chamada no objeto CreateUserWithEmailAndPasswordLastResult Future ou, se estiver escrevendo um jogo ou aplicativo com algum tipo de loop de atualização periódico, pesquisando o status no loop de atualização.

Por exemplo, usando um 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);

Ou, para usar a pesquisa, faça algo como o exemplo a seguir no loop de atualização do seu jogo:

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());
  }
}

Fazer login de usuários existentes

Crie um formulário que permita que os usuários existentes entrem usando seu endereço de e-mail e senha. Quando um usuário preencher o formulário, chame o método SignInWithEmailAndPassword :

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

Obtenha o resultado da operação de entrada da mesma forma que obteve o resultado da inscrição.

Defina um ouvinte de estado de autenticação e obtenha dados da conta

Para responder a eventos de entrada e saída, anexe um ouvinte ao objeto de autenticação global. Esse ouvinte é chamado sempre que o estado de entrada do usuário é alterado. Como o ouvinte é executado somente após a inicialização completa do objeto de autenticação e após a conclusão de todas as chamadas de rede, é o melhor local para obter informações sobre o usuário conectado.

Crie o ouvinte implementando a classe abstrata firebase::auth::AuthStateListener . Por exemplo, para criar um listener que obtenha informações sobre o usuário quando um usuário fizer login com êxito:

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

Anexe o listener ao método AddAuthStateListener do objeto AddAuthStateListener firebase::auth::Auth :

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

Próximos passos

Saiba como adicionar suporte para outros provedores de identidade e contas de convidados anônimos: