Uwierzytelnij się za pomocą logowania do Facebooka i C++

Możesz pozwolić swoim użytkownikom na uwierzytelnianie się w Firebase przy użyciu ich kont na Facebooku, integrując logowanie Facebook ze swoją aplikacją.

Zanim zaczniesz

  1. Dodaj Firebase do projektu C ++ .
  2. Na Facebook dla programistów miejscu, uzyskać identyfikator aplikacji i aplikacji tajemnicą swojej aplikacji.
  3. Włącz logowanie przez Facebooka:
    1. W konsoli Firebase otwórz sekcję Auth.
    2. Na karcie Logowanie w metodzie umożliwienia logowania metody Facebook i podać identyfikator aplikacji i aplikacji sekret, którego dostał od Facebooka.
    3. Następnie upewnij się, że OAuth przekierowanie URI (np my-app-12345.firebaseapp.com/__/auth/handler ) jest wymieniony jako jeden z OAuth URI przekierowania na strony Facebook ustawień aplikacji na Facebook dla programistów miejscu w produkcie Ustawienia> Facebook Login config.

Uzyskaj dostęp do firebase::auth::Auth klasę

Auth klasa jest bramą do wszystkich wywołań API.
  1. Dodaj pliki nagłówka uwierzytelniania i aplikacji:
    #include "firebase/app.h"
    #include "firebase/auth.h"
    
  2. W kodzie inicjującym utwórz firebase::App klasy.
    #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. Nabyć firebase::auth::Auth klasę dla firebase::App . Istnieje odwzorowanie jeden do jednego między App i Auth .
    firebase::auth::Auth* auth = firebase::auth::Auth::GetAuth(app);
    

Uwierzytelnij się w Firebase

  1. Postępuj zgodnie z instrukcjami wyświetlanymi na Androida i iOS + , aby uzyskać dostęp do tokena dla zalogowanych użytkowników Facebook.
  2. Po użytkownik pomyślnie znaki, wymienić token dostępu do poświadczeń Firebase oraz uwierzytelniania Firebase pomocą Firebase poświadczenia:
    firebase::auth::Credential credential =
        firebase::auth::FacebookAuthProvider::GetCredential(access_token);
    firebase::Future<firebase::auth::User*> result =
        auth->SignInWithCredential(credential);
    
  3. Jeśli program ma pętlę aktualizacji, który kursuje regularnie (powiedzmy na 30 lub 60 razy na sekundę), można sprawdzić wyniki raz w aktualizacji z Auth::SignInWithCredentialLastResult :
    firebase::Future<firebase::auth::User*> result =
        auth->SignInWithCredentialLastResult();
    if (result.status() == firebase::kFutureStatusComplete) {
      if (result.error() == firebase::auth::kAuthErrorNone) {
        firebase::auth::User* user = *result.result();
        printf("Sign in succeeded for `%s`\n", user->display_name().c_str());
      } else {
        printf("Sign in failed with error '%s'\n", result.error_message());
      }
    }
    
    lub, jeśli program jest sterowany zdarzeniami, może wolisz aby zarejestrować wywołania zwrotnego na przyszłość .

Zarejestruj oddzwonienie w przyszłości

Niektóre programy mają Update funkcje, które nazywane są 30 lub 60 razy na sekundę. Na przykład wiele gier jest zgodnych z tym modelem. Programy te mogą wywołać LastResult funkcje odpytywanie połączeń asynchronicznych. Jeśli jednak Twój program jest sterowany zdarzeniami, możesz chcieć zarejestrować funkcje wywołania zwrotnego. Funkcja wywołania zwrotnego jest wywoływana po zakończeniu przyszłości.
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);
}
Funkcja zwrotna może być również lambda, jeśli wolisz.
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);
}

Następne kroki

Gdy użytkownik zaloguje się po raz pierwszy, zostanie utworzone nowe konto użytkownika i połączone z poświadczeniami — czyli nazwą użytkownika i hasłem, numerem telefonu lub informacjami o dostawcy uwierzytelniania — przy użyciu których użytkownik się zalogował. To nowe konto jest przechowywane jako część projektu Firebase i może służyć do identyfikowania użytkownika w każdej aplikacji w projekcie, niezależnie od tego, jak się on loguje.

  • W aplikacjach, można uzyskać podstawowe informacje o profilu użytkownika z firebase::auth::User obiektu:

    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();
    }
    
  • W bazie danych Firebase Realtime i Cloud Storage zasad bezpieczeństwa , można uzyskać podpisanego w unikalnym identyfikatorem użytkownika użytkownika z auth zmiennej i użyć go do kontroli, jakie dane dostępu może użytkownik.

Można zezwolić użytkownikom na logowanie się do aplikacji przy użyciu wielu dostawców uwierzytelniania przez łączenie auth poświadczenia dostawcy do istniejącego konta użytkownika.

Aby wylogować użytkownika, zadzwoń SignOut() :

auth->SignOut();