Autenticar com Firebase usando contas baseadas em senha usando C++

Você pode usar o Firebase Authentication para permitir que seus usuários se autentiquem no Firebase usando endereços de e-mail e senhas e para gerenciar as contas baseadas em senha do seu aplicativo.

Antes de você começar

  1. Adicione o Firebase ao seu projeto C++ .
  2. Se você ainda não conectou seu aplicativo ao projeto do Firebase, faça isso no console do Firebase .
  3. Ative o login por e-mail/senha:
    1. No console do Firebase , abra a seção Auth .
    2. Na guia Método de login , ative o método de login por e-mail/senha e clique em Salvar .

Acesse a classe firebase::auth::Auth

A classe Auth é o gateway para todas as chamadas de API.
  1. Adicione os arquivos de cabeçalho Auth e App:
    #include "firebase/app.h"
#include "firebase/auth.h"
  2. No seu código de inicialização, crie uma classe firebase::App .
    #if defined(__ANDROID__)
  firebase::App* app =
      firebase::App::Create(firebase::AppOptions(), my_jni_env, my_activity);
#else
  firebase::App* app = firebase::App::Create(firebase::AppOptions());
#endif  // defined(__ANDROID__)
  3. Adquira a classe firebase::auth::Auth para seu firebase::App . Há um mapeamento individual entre App e Auth .
    firebase::auth::Auth* auth = firebase::auth::Auth::GetAuth(app);

Crie uma conta baseada em senha

Para criar uma nova conta de usuário com senha, conclua as etapas a seguir no código de login do seu aplicativo:

  1. Quando um novo usuário se inscreve usando o formulário de inscrição do seu aplicativo, conclua todas as novas etapas de validação de conta exigidas pelo seu aplicativo, como verificar se a senha da nova conta foi digitada corretamente e atende aos seus requisitos de complexidade.
  2. Crie uma nova conta passando o endereço de e-mail e a senha do novo usuário para Auth::CreateUserWithEmailAndPassword :
    firebase::Future<firebase::auth::AuthResult> result =
    auth->CreateUserWithEmailAndPassword(email, password);
  3. Se o seu programa tiver um loop de atualização executado regularmente (digamos, 30 ou 60 vezes por segundo), você poderá verificar os resultados uma vez por atualização com Auth::CreateUserWithEmailAndPasswordLastResult :
    firebase::Future<firebase::auth::AuthResult> result =
    auth->CreateUserWithEmailAndPasswordLastResult();
if (result.status() == firebase::kFutureStatusComplete) {
  if (result.error() == firebase::auth::kAuthErrorNone) {
    const 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());
  }
}
    Ou, se o seu programa for orientado a eventos, você pode preferir para registrar um retorno de chamada no Future .

Faça login em um usuário com um endereço de e-mail e senha

As etapas para fazer login de um usuário com senha são semelhantes às etapas para criar uma nova conta. Na função de login do seu aplicativo, faça o seguinte:

  1. Quando um usuário fizer login no seu aplicativo, passe o endereço de e-mail e a senha do usuário para firebase::auth::Auth::SignInWithEmailAndPassword :
    firebase::Future<firebase::auth::AuthResult> result =
    auth->SignInWithEmailAndPassword(email, password);
  2. Se o seu programa tiver um loop de atualização executado regularmente (digamos, 30 ou 60 vezes por segundo), você poderá verificar os resultados uma vez por atualização com Auth::SignInWithEmailAndPasswordLastResult :
    firebase::Future<firebase::auth::AuthResult> result =
    auth->SignInWithEmailAndPasswordLastResult();
if (result.status() == firebase::kFutureStatusComplete) {
  if (result.error() == firebase::auth::kAuthErrorNone) {
    const firebase::auth::AuthResult auth_result = *result.result();
    printf("Sign in succeeded for email %s\n",
           auth_result.user.email().c_str());
  } else {
    printf("Sign in failed with error '%s'\n", result.error_message());
  }
}
    Ou, se o seu programa for orientado a eventos, você pode preferir para registrar um retorno de chamada no Future .

Registre um retorno de chamada em um futuro

Alguns programas possuem funções Update que são chamadas 30 ou 60 vezes por segundo. Por exemplo, muitos jogos seguem este modelo. Esses programas podem chamar as funções LastResult para sondar chamadas assíncronas. No entanto, se o seu programa for orientado a eventos, você pode preferir registrar funções de retorno de chamada. Uma função de retorno de chamada é chamada após a conclusão do Future.
void OnCreateCallback(const firebase::Future<firebase::auth::User*>& result,
                      void* user_data) {
  // The callback is called when the Future enters the `complete` state.
  assert(result.status() == firebase::kFutureStatusComplete);

  // Use `user_data` to pass-in program context, if you like.
  MyProgramContext* program_context = static_cast<MyProgramContext*>(user_data);

  // Important to handle both success and failure situations.
  if (result.error() == firebase::auth::kAuthErrorNone) {
    firebase::auth::User* user = *result.result();
    printf("Create user succeeded for email %s\n", user->email().c_str());

    // Perform other actions on User, if you like.
    firebase::auth::User::UserProfile profile;
    profile.display_name = program_context->display_name;
    user->UpdateUserProfile(profile);

  } else {
    printf("Created user failed with error '%s'\n", result.error_message());
  }
}

void CreateUser(firebase::auth::Auth* auth) {
  // Callbacks work the same for any firebase::Future.
  firebase::Future<firebase::auth::AuthResult> result =
      auth->CreateUserWithEmailAndPasswordLastResult();

  // `&my_program_context` is passed verbatim to OnCreateCallback().
  result.OnCompletion(OnCreateCallback, &my_program_context);
}
A função de retorno de chamada também pode ser um lambda, se preferir.
void CreateUserUsingLambda(firebase::auth::Auth* auth) {
  // Callbacks work the same for any firebase::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::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);
}

Recomendado: ativar a proteção de enumeração de e-mail

Alguns métodos do Firebase Authentication que usam endereços de e-mail como parâmetros geram erros específicos se o endereço de e-mail não for registrado quando precisar ser registrado (por exemplo, ao fazer login com um endereço de e-mail e senha) ou registrado quando não precisar ser usado (por exemplo, ao alterar o endereço de e-mail de um usuário). Embora isso possa ser útil para sugerir soluções específicas aos usuários, também pode ser usado por agentes mal-intencionados para descobrir os endereços de e-mail registrados por seus usuários.

Para mitigar esse risco, recomendamos que você ative a proteção de enumeração de e-mail para seu projeto usando a ferramenta gcloud do Google Cloud. Observe que a ativação desse recurso altera o comportamento de relatório de erros do Firebase Authentication: certifique-se de que seu aplicativo não dependa de erros mais específicos.

Próximos passos

Depois que um usuário faz login pela primeira vez, uma nova conta de usuário é criada e vinculada às credenciais (ou seja, nome de usuário e senha, número de telefone ou informações do provedor de autenticação) com as quais o usuário fez login. Essa nova conta é armazenada como parte do seu projeto do Firebase e pode ser usada para identificar um usuário em todos os aplicativos do seu projeto, independentemente de como o usuário faz login.

  • Nos seus aplicativos, você pode obter as informações básicas do perfil do usuário no objeto firebase::auth::User :

    firebase::auth::User user = auth->current_user();
if (user.is_valid()) {
  std::string name = user.display_name();
  std::string email = user.email();
  std::string photo_url = user.photo_url();
  // The user's ID, unique to the Firebase project.
  // Do NOT use this value to authenticate with your backend server,
  // if you have one. Use firebase::auth::User::Token() instead.
  std::string uid = user.uid();
}

  • Nas regras de segurança do Firebase Realtime Database e do Cloud Storage , você pode obter o ID de usuário exclusivo do usuário conectado na variável auth e usá-lo para controlar quais dados um usuário pode acessar.

Você pode permitir que os usuários façam login no seu aplicativo usando vários provedores de autenticação vinculando as credenciais do provedor de autenticação a uma conta de usuário existente.

Para desconectar um usuário, chame SignOut() :

auth->SignOut();