Google se compromete a impulsar la igualdad racial para las comunidades afrodescendientes. Obtén información al respecto.

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

Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Puede usar Firebase Authentication para permitir que sus 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 su aplicación.

Antes de que empieces

  1. Agregue Firebase a su proyecto de C++ .
  2. Si aún no ha conectado su aplicación a su proyecto de Firebase, hágalo desde la consola de Firebase .
  3. Habilitar inicio de sesión con correo electrónico/contraseña:
    1. En Firebase console , abra 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 con correo electrónico/contraseña y haga clic en Guardar .

Accede a la firebase::auth::Auth

La clase Auth es la puerta de enlace para todas las llamadas a la API.
  1. Agregue los archivos de encabezado Auth y App:
    #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 firebase::auth::Auth para su firebase::App . Hay 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 mediante el formulario de registro de su aplicación, complete todos los pasos de validación de la nueva cuenta que requiera su aplicación, como verificar que la contraseña de la nueva cuenta se haya ingresado 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::User*> result =
        auth->CreateUserWithEmailAndPassword(email, password);
    
  3. Si su programa tiene un ciclo de actualización que se ejecuta regularmente (por ejemplo, 30 o 60 veces por segundo), puede verificar los resultados una vez por actualización con Auth::CreateUserWithEmailAndPasswordLastResult :
    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());
      }
    }
    
    O, si su programa está basado en eventos, puede preferir para registrar una devolución de llamada en el futuro .

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

Los pasos para iniciar sesión como usuario con 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 inicie 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::User*> result =
        auth->SignInWithEmailAndPassword(email, password);
    
  2. Si su programa tiene un ciclo de actualización que se ejecuta con regularidad (por ejemplo, 30 o 60 veces por segundo), puede verificar los resultados una vez por actualización con Auth::SignInWithEmailAndPasswordLastResult :
    firebase::Future<firebase::auth::User*> result =
        auth->SignInWithEmailAndPasswordLastResult();
    if (result.status() == firebase::kFutureStatusComplete) {
      if (result.error() == firebase::auth::kAuthErrorNone) {
        firebase::auth::User* user = *result.result();
        printf("Sign in succeeded for email %s\n", user->email().c_str());
      } else {
        printf("Sign in failed with error '%s'\n", result.error_message());
      }
    }
    
    O, si su programa está basado en eventos, puede preferir para registrar una devolución de llamada en el futuro .

Registrar una devolución de llamada en un futuro

Algunos programas tienen funciones de 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 se basa en 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::User*> 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::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);
}

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 del objeto firebase::auth::User :

    firebase::auth::User* user = auth->current_user();
    if (user != nullptr) {
      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 sus Reglas de seguridad de Firebase Realtime Database y Cloud Storage, puede obtener el ID de usuario único del usuario que inició sesión 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 varios 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();