Ir a la consola

Administra usuarios en Firebase

Crea un usuario

Para crear un usuario nuevo en tu proyecto de Firebase, puedes llamar al método CreateUserWithEmailAndPassword o hacer que el usuario acceda por primera vez con un proveedor de identidad federada, como Acceso con Google o Acceso con Facebook.

También puedes crear nuevos usuarios autenticados con contraseña en la sección Authentication de Firebase console, en la página Usuarios.

Obtén el usuario con sesión activa

La manera recomendada de obtener el usuario actual es establecer un objeto de escucha en el objeto Auth:

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());
    } else {
      // User is signed out
      printf("OnAuthStateChanged: signed_out\n");
    }
    // ...
  }
};
// ... initialization code
// Test notification on registration.
MyAuthStateListener state_change_listener;
auth->AddAuthStateListener(&state_change_listener);

Cuando usas un agente de escucha, se garantiza que el objeto Auth no esté en un estado intermedio, como la inicialización, cuando obtengas el usuario actual.

También puedes llamar a current_user para obtener el usuario que accedió. Si ningún usuario accedió, current_user muestra el valor nullptr.

Obtén el perfil de un usuario

Para obtener la información del perfil de un usuario, puedes usar el método de acceso de una instancia de firebase::auth::User. Por ejemplo:

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

Obtén la información de perfil de un usuario específica de un proveedor

Para obtener la información de perfil vinculada con un usuario recuperada del proveedor de acceso, puedes usar el método ProviderData. Por ejemplo:

firebase::auth::User* user = auth->current_user();
if (user != nullptr) {
  for (auto it = user->provider_data().begin();
       it != user->provider_data().end(); ++it) {
    firebase::auth::UserInfoInterface* profile = *it;
    // Id of the provider (ex: google.com)
    std::string providerId = profile->provider_id();

    // UID specific to the provider
    std::string uid = profile->uid();

    // Name, email address, and profile photo Url
    std::string name = profile->display_name();
    std::string email = profile->email();
    std::string photoUrl = profile->photo_url();
  }
}

Actualiza el perfil de un usuario

Para actualizar la información de perfil básica de un usuario (el nombre visible y la URL de la foto de perfil), puedes usar el método UpdateUserProfile. Por ejemplo:

firebase::auth::User* user = auth->current_user();
if (user != nullptr) {
  firebase::auth::User::UserProfile profile;
  profile.display_name = "Jane Q. User";
  profile.photo_url = "https://example.com/jane-q-user/profile.jpg";
  user->UpdateUserProfile(profile).OnCompletion(
      [](const firebase::Future<void>& completed_future, void* user_data) {
        // We are probably in a different thread right now.
        if (completed_future.error() == 0) {
          printf("User profile updated.");
        }
      },
      nullptr);  // pass user_data here.
}

Configura la dirección de correo electrónico de un usuario

Puedes configurar la dirección de correo electrónico de un usuario con el método UpdateEmail. Por ejemplo:

firebase::auth::User* user = auth->current_user();
if (user != nullptr) {
  user->UpdateEmail("user@example.com")
      .OnCompletion(
          [](const firebase::Future<void>& completed_future,
             void* user_data) {
            // We are probably in a different thread right now.
            if (completed_future.error() == 0) {
              printf("User email address updated.");
            }
          },
          nullptr);
}

Envía un mensaje de verificación a un usuario

Para enviar un mensaje de verificación de dirección a un usuario, puedes usar el método SendEmailVerification. Por ejemplo:

firebase::auth::User* user = auth->current_user();
if (user != nullptr) {
  user->SendEmailVerification().OnCompletion(
      [](const firebase::Future<void>& completed_future, void* user_data) {
        // We are probably in a different thread right now.
        if (completed_future.error() == 0) {
          printf("Email sent.");
        }
      },
      nullptr);
}

Puedes personalizar la plantilla de correo electrónico que se usa en la sección Authentication de Firebase console, en la página Plantillas de correo electrónico. Consulta Plantillas de correo electrónico en el Centro de ayuda de Firebase.

Configura la contraseña de un usuario

Para configurar la contraseña de un usuario, puedes usar el método UpdatePassword. Por ejemplo:

firebase::auth::User* user = auth->current_user();
std::string newPassword = "SOME-SECURE-PASSWORD";

if (user != nullptr) {
  user->UpdatePassword(newPassword.c_str())
      .OnCompletion(
          [](const firebase::Future<void>& completed_future,
             void* user_data) {
            // We are probably in a different thread right now.
            if (completed_future.error() == 0) {
              printf("password updated.");
            }
          },
          nullptr);
}

Envía un correo electrónico de restablecimiento de la contraseña

Para enviar un correo electrónico de restablecimiento de contraseña a un usuario, puedes usar el método SendPasswordResetEmail. Por ejemplo:

std::string emailAddress = "user@example.com";

auth->SendPasswordResetEmail(emailAddress.c_str())
    .OnCompletion(
        [](const firebase::Future<void>& completed_future,
           void* user_data) {
          // We are probably in a different thread right now.
          if (completed_future.error() == 0) {
            // Email sent.
          } else {
            // An error happened.
            printf("Error %d: %s", completed_future.error(),
                   completed_future.error_message());
          }
        },
        nullptr);

Puedes personalizar la plantilla de correo electrónico que se usa en la sección Authentication de Firebase console, en la página Plantillas de correo electrónico. Consulta Plantillas de correo electrónico en el Centro de ayuda de Firebase.

También puedes enviar correos electrónicos de restablecimiento de contraseña desde Firebase console.

Borra un usuario

Para borrar una cuenta de usuario, puedes usar el método Delete. Por ejemplo:

firebase::auth::User* user = auth->current_user();
if (user != nullptr) {
  user->Delete().OnCompletion(
      [](const firebase::Future<void>& completed_future, void* user_data) {
        if (completed_future.error() == 0) {
          // User deleted.
        } else {
          // An error happened.
          printf("Error %d: %s", completed_future.error(),
                 completed_future.error_message());
        }
      },
      nullptr);
}

También puedes borrar usuarios en la sección Authentication de Firebase console, en la página Usuarios.

Vuelve a autenticar un usuario

Por motivos de seguridad, algunas acciones, como borrar una cuenta, configurar una dirección de correo electrónico principal y cambiar una contraseña, no se pueden realizar si el usuario no accedió a su cuenta recientemente. Si transcurrió demasiado tiempo desde que el usuario accedió a su cuenta, cualquier intento de realizar estas acciones fallará.

Cuando esto sucede, es necesario obtener nuevas credenciales de acceso del usuario y pasarlas a Reauthenticate para volver a autenticar la sesión. Por ejemplo:

firebase::auth::User* user = auth->current_user();

// Get auth credentials from the user for re-authentication. The example
// below shows email and password credentials but there are multiple
// possible providers, such as GoogleAuthProvider or FacebookAuthProvider.
firebase::auth::Credential credential =
    firebase::auth::EmailAuthProvider::GetCredential("user@example.com",
                                                     "password1234");

if (user != nullptr) {
  user->Reauthenticate(credential)
      .OnCompletion(
          [](const firebase::Future<void>& completed_future,
             void* user_data) {
            if (completed_future.error() == 0) {
              printf("User re-authenticated.");
            }
          },
          nullptr);
}

Importa cuentas de usuario

Para importar cuentas de usuario desde un archivo al proyecto de Firebase, puedes usar el comando auth:import de Firebase CLI. Por ejemplo:

firebase auth:import users.json --hash-algo=scrypt --rounds=8 --mem-cost=14