S'authentifier avec Twitter et C++

Vous pouvez autoriser vos utilisateurs à s'authentifier avec Firebase à l'aide de leurs comptes Twitter en intégrant l'authentification Twitter à votre application.

Avant de commencer

  1. Ajoutez Firebase à votre projet C++.
  2. Dans la console Firebase, ouvrez la section Authentification.
  3. Dans l'onglet Mode de connexion, activez le fournisseur Twitter.
  4. Ajoutez la clé API et le code secret de l'API de la console pour développeur de ce fournisseur au configuration du fournisseur:
    1. Enregistrez votre application en tant qu'application de développement sur Twitter, puis obtenez la clé API et le secret API OAuth de votre application.
    2. Assurez-vous que votre URI de redirection OAuth Firebase (par exemple, my-app-12345.firebaseapp.com/__/auth/handler) est définie comme URL de rappel d'autorisation sur la page des paramètres de votre application Configuration de l'application Twitter
  5. Cliquez sur Enregistrer.

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

La classe Auth est la passerelle pour tous les appels d'API.
  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. Procurez-vous 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);

Authentifier avec Firebase

  1. Suivez le Se connecter avec Twitter pour obtenir un jeton d'accès et un secret OAuth.
  2. Une fois l'utilisateur connecté, échangez le jeton et le secret contre des identifiants Firebase, puis authentifiez-vous avec Firebase à l'aide des identifiants Firebase :
    firebase::auth::Credential credential =
        firebase::auth::TwitterAuthProvider::GetCredential(token, secret);
    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());
      }
    }
    Ou, si votre programme est basé sur des événements, vous pouvez préférer enregistrer un rappel sur le Future.

Enregistrer un rappel sur un objet Future

Certains programmes comportent des fonctions Update appelées 30 ou 60 fois par seconde. Par exemple, de nombreux jeux suivent ce modèle. Ces programmes peuvent appeler le LastResult pour interroger les appels asynchrones. Toutefois, si votre programme est basé sur des événements, vous préférerez peut-être enregistrer des fonctions de rappel. Une fonction de rappel est appelée à la fin de l'objet 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);
}
Si vous préférez, la fonction de rappel peut également être un lambda.
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és aux identifiants, c'est-à-dire au nom d'utilisateur et au mot de passe, ou des informations sur le fournisseur d'authentification, c'est-à-dire l'utilisateur avec lequel l'utilisateur s'est connecté. Cette nouvelle est stocké dans votre projet Firebase et peut servir à identifier un utilisateur dans toutes les applications de votre projet, quelle que soit la façon dont l'utilisateur se connecte.

  • 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 appli à l'aide de plusieurs authentifications fournisseurs en associant leurs identifiants compte utilisateur existant.

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

auth->SignOut();