Autenticarse con Firebase usando cuentas basadas en contraseña usando C++

Puedes usar Firebase Authentication para permitir que tus usuarios se autentiquen con Firebase usando sus direcciones de correo electrónico y contraseñas, y para administrar las cuentas basadas en contraseñas de tu aplicación.

Antes de que empieces

  1. Agrega Firebase a tu proyecto de C++ .
  2. Si aún no has conectado tu aplicación a tu proyecto de Firebase, hazlo desde Firebase console .
  3. Habilite el inicio de sesión por correo electrónico/contraseña:
    1. En Firebase console , abre la sección Auth .
    2. En la pestaña Método de inicio de sesión , habilite el método de inicio de sesión por correo electrónico/contraseña y haga clic en Guardar .

Acceda a la clase firebase::auth::Auth

La clase Auth es la puerta de entrada para todas las llamadas API.
  1. Agregue los archivos de encabezado de autenticación y aplicación:
    #include "firebase/app.h"
#include "firebase/auth.h"
  2. En su código de inicialización, cree una clase 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. Adquiera la clase firebase::auth::Auth para su firebase::App . Existe una asignación uno a uno entre App y Auth .
    firebase::auth::Auth* auth = firebase::auth::Auth::GetAuth(app);

Crear una cuenta basada en contraseña

Para crear una nueva cuenta de usuario con una contraseña, complete los siguientes pasos en el código de inicio de sesión de su aplicación:

  1. Cuando un nuevo usuario se registre utilizando el formulario de registro de su aplicación, complete los pasos de validación de cuenta nueva que su aplicación requiera, como verificar que la contraseña de la nueva cuenta se haya escrito correctamente y cumpla con sus requisitos de complejidad.
  2. Cree una nueva cuenta pasando la dirección de correo electrónico y la contraseña del nuevo usuario a Auth::CreateUserWithEmailAndPassword :
    firebase::Future<firebase::auth::AuthResult> result =
    auth->CreateUserWithEmailAndPassword(email, password);
  3. Si su programa tiene un ciclo de actualización que se ejecuta regularmente (digamos, 30 o 60 veces por segundo), puede verificar los resultados una vez por actualización con 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());
  }
}
    O, si su programa está controlado por eventos, tal vez prefiera para registrar una devolución de llamada en el futuro .

Iniciar sesión como usuario con una dirección de correo electrónico y contraseña

Los pasos para iniciar sesión como usuario con una contraseña son similares a los pasos para crear una cuenta nueva. En la función de inicio de sesión de su aplicación, haga lo siguiente:

  1. Cuando un usuario inicia sesión en su aplicación, pase la dirección de correo electrónico y la contraseña del usuario a firebase::auth::Auth::SignInWithEmailAndPassword :
    firebase::Future<firebase::auth::AuthResult> result =
    auth->SignInWithEmailAndPassword(email, password);
  2. Si su programa tiene un ciclo de actualización que se ejecuta regularmente (digamos, 30 o 60 veces por segundo), puede verificar los resultados una vez por actualización con 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());
  }
}
    O, si su programa está controlado por eventos, tal vez prefiera para registrar una devolución de llamada en el futuro .

Registrar una devolución de llamada en un futuro

Algunos programas tienen funciones Update que se llaman 30 o 60 veces por segundo. Por ejemplo, muchos juegos siguen este modelo. Estos programas pueden llamar a las funciones LastResult para sondear llamadas asincrónicas. Sin embargo, si su programa está controlado por eventos, es posible que prefiera registrar funciones de devolución de llamada. Se llama a una función de devolución de llamada al finalizar el futuro.
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);
}
La función de devolución de llamada también puede ser una lambda, si lo prefiere.
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: habilitar la protección de enumeración de correo electrónico

Algunos métodos de autenticación de Firebase que toman direcciones de correo electrónico como parámetros arrojan errores específicos si la dirección de correo electrónico no está registrada cuando debe registrarse (por ejemplo, al iniciar sesión con una dirección de correo electrónico y contraseña) o si no está registrada cuando no debe usarse (por ejemplo, al cambiar la dirección de correo electrónico de un usuario). Si bien esto puede ser útil para sugerir soluciones específicas a los usuarios, actores malintencionados también pueden abusar de él para descubrir las direcciones de correo electrónico registradas por sus usuarios.

Para mitigar este riesgo, le recomendamos habilitar la protección de enumeración de correo electrónico para su proyecto mediante la herramienta gcloud de Google Cloud. Tenga en cuenta que habilitar esta función cambia el comportamiento de informe de errores de Firebase Authentication: asegúrese de que su aplicación no dependa de errores más específicos.

Próximos pasos

Después de que un usuario inicia sesión por primera vez, se crea una nueva cuenta de usuario y se vincula a las credenciales (es decir, el nombre de usuario y la contraseña, el número de teléfono o la información del proveedor de autenticación) con las que el usuario inició sesión. Esta nueva cuenta se almacena como parte de su proyecto de Firebase y se puede usar para identificar a un usuario en cada aplicación de su proyecto, independientemente de cómo inicie sesión el usuario.

  • En sus aplicaciones, puede obtener la información básica del perfil del usuario desde firebase::auth::User objeto:

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

  • En las reglas de seguridad de Firebase Realtime Database y Cloud Storage, puede obtener el ID de usuario único del usuario que inició sesión a partir de la variable auth y usarlo para controlar a qué datos puede acceder un usuario.

Puede permitir que los usuarios inicien sesión en su aplicación utilizando múltiples proveedores de autenticación vinculando las credenciales del proveedor de autenticación a una cuenta de usuario existente.

Para cerrar la sesión de un usuario, llame a SignOut() :

auth->SignOut();