Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

S'authentifier avec Google Sign-In et C++

Vous pouvez autoriser vos utilisateurs à s'authentifier auprès de Firebase à l'aide de leur compte Google en intégrant Google Sign-In à votre application.

Avant de commencer

Ajoutez Firebase à votre projet C++.
Activez Google comme fournisseur de connexion pour votre projet Firebase :
1. Dans la console Firebase, accédez à Sécurité > Authentification.
2. Dans l'onglet Mode de connexion, activez le fournisseur de connexion Google.
3. Cliquez sur Enregistrer.
Conseil : Si vous préférez utiliser la Firebase CLI, exécutez firebase init auth pour configurer les fournisseurs d'authentification, puis firebase deploy --only auth pour déployer les modifications dans votre projet.
Mettez à jour votre fichier de configuration Firebase.
1. Lorsque vous y êtes invité dans la Firebase console, téléchargez le fichier de configuration Firebase mis à jour (google-services.json), qui contient désormais les informations client OAuth requises pour la connexion avec Google.
2. Déplacez ce fichier de configuration mis à jour dans votre projet Android Studio, en remplaçant le fichier de configuration correspondant, qui est désormais obsolète. (Consultez Ajouter Firebase à votre projet Android.)

Accéder à la classe `firebase::auth::Auth`

La classe Auth est la passerelle pour tous les appels d'API.

Ajoutez les fichiers d'en-tête Auth et App :

#include "firebase/app.h"
#include "firebase/auth.h"

Dans votre code d'initialisation, créez une firebase::App classe.

#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__)

Acquérez la classe firebase::auth::Auth pour votre firebase::App. Il existe un mappage un-à-un entre App et Auth.
```
firebase::auth::Auth* auth = firebase::auth::Auth::GetAuth(app);
```

S'authentifier auprès de Firebase

Suivez les instructions pour Android et iOS+ afin d'obtenir un jeton d'ID pour la connexion avec Google.

Une fois qu'un utilisateur s'est connecté, échangez le jeton d'ID contre un identifiant Firebase, puis authentifiez-vous auprès de Firebase à l'aide de l'identifiant Firebase :

firebase::auth::Credential credential =
    firebase::auth::GoogleAuthProvider::GetCredential(google_id_token,
                                                      nullptr);
firebase::Future<firebase::auth::AuthResult> result =
    auth->SignInAndRetrieveDataWithCredential(credential);

Si votre programme comporte une boucle de mise à jour qui s'exécute régulièrement (par exemple, 30 ou 60 fois par seconde), vous pouvez vérifier les résultats une fois par mise à jour avec Auth::SignInAndRetrieveDataWithCredentialLastResult :

firebase::Future<firebase::auth::AuthResult> result =
    auth->SignInAndRetrieveDataWithCredentialLastResult();
if (result.status() == firebase::kFutureStatusComplete) {
  if (result.error() == firebase::auth::kAuthErrorNone) {
    firebase::auth::AuthResult auth_result = *result.result();
    printf("Sign in succeeded for `%s`\n",
           auth_result.user.display_name().c_str());
  } else {
    printf("Sign in failed with error '%s'\n", result.error_message());
  }
}

Vous pouvez également enregistrer un rappel sur l'objet Future si votre programme est axé sur les événements.

Enregistrer un rappel sur un objet Future

Certains programmes comportent des fonctions Update qui sont appelées 30 ou 60 fois par seconde. Par exemple, de nombreux jeux suivent ce modèle. Ces programmes peuvent appeler les fonctions LastResult pour interroger les appels asynchrones. Toutefois, si votre programme est axé sur les événements, vous pouvez préférer enregistrer des fonctions de rappel. Une fonction de rappel est appelée une fois l'objet Future terminé.

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

Vous pouvez également utiliser une expression lambda comme fonction de rappel.

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

Étapes suivantes

Lorsqu'un utilisateur se connecte pour la première fois, un compte utilisateur est créé et associé aux identifiants (nom d'utilisateur et mot de passe, numéro de téléphone ou informations du fournisseur d'authentification) avec lesquels il s'est connecté. Ce nouveau compte est stocké dans votre projet Firebase et peut être utilisé pour identifier un utilisateur dans toutes les applications de votre projet, quelle que soit la méthode de connexion utilisée.

Dans vos applications, vous pouvez obtenir les informations de base du profil de l'utilisateur à partir de l'objet 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();
}

Dans vos Firebase Realtime Database et Cloud Storage règles de sécurité, vous pouvez obtenir l'ID utilisateur unique de l'utilisateur connecté à partir de la variable auth, et l'utiliser pour contrôler les données auxquelles un utilisateur peut accéder.

Vous pouvez autoriser les utilisateurs à se connecter à votre application à l'aide de plusieurs fournisseurs d'authentification en associant les identifiants du fournisseur d'authentification à un compte utilisateur existant.

Pour déconnecter un utilisateur, appelez SignOut() :

auth->SignOut();