S'authentifier avec Facebook Login et C++

Vous pouvez autoriser vos utilisateurs à s'authentifier auprès de Firebase à l'aide de leur compte Facebook en intégrant Facebook Login dans votre application.

Avant de commencer

1. Ajoutez Firebase à votre projet C++.
2. Sur le site Facebook pour les développeurs, obtenez l'ID d'application et le code secret de l'application pour votre application.
3. Activez Facebook Login :
   1. Dans la console Firebase, ouvrez la section Authentification.
   2. Dans l'onglet Méthode de connexion, activez la méthode de connexion Facebook, puis spécifiez l'ID d'application et le code secret de l'application que vous avez obtenus auprès de Facebook.
   3. Assurez-vous ensuite que votre URI de redirection OAuth (par exemple, my-app-12345.firebaseapp.com/__/auth/handler) figure parmi vos URI de redirection OAuth sur la page des paramètres de votre application Facebook sur le site Facebook pour les développeurs, dans la configuration Paramètres du produit > Connexion avec Facebook.

Accéder au cours firebase::auth::Auth

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

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

2. Dans votre code d'initialisation, créez une 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. Acquérez la classe firebase::auth::Auth pour votre firebase::App. Il existe une correspondance un-à-un entre App et Auth.

   firebase::auth::Auth* auth = firebase::auth::Auth::GetAuth(app);

S'authentifier avec Firebase

1. Suivez les instructions pour Android et iOS+ afin d'obtenir un jeton d'accès pour l'utilisateur Facebook connecté.
2. Une fois l'utilisateur connecté, échangez le jeton d'accès contre un identifiant Firebase, puis authentifiez-vous auprès de Firebase à l'aide de l'identifiant Firebase :

   firebase::auth::Credential credential =
       firebase::auth::FacebookAuthProvider::GetCredential(access_token);
   firebase::Future<firebase::auth::AuthResult> result =
       auth->SignInAndRetrieveDataWithCredential(credential);

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

   Si votre programme est axé sur les événements, vous pouvez également enregistrer un rappel sur l'objet Future.

Enregistrer un rappel sur un 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);
}

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 de l'utilisateur.

• Dans vos applications, vous pouvez obtenir les informations de profil de base 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 règles de sécurité Firebase Realtime Database et Cloud Storage, 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();