O Google tem o compromisso de promover a igualdade racial para as comunidades negras. Saiba como.

Autenticar usando o login do Facebook e C++

Você pode permitir que seus usuários se autentiquem no Firebase usando suas contas do Facebook integrando o Login do Facebook ao seu aplicativo.

Antes de você começar

  1. Adicione o Firebase ao seu projeto C++ .
  2. No site do Facebook para desenvolvedores , obtenha o ID do aplicativo e um segredo do aplicativo para seu aplicativo.
  3. Ativar login no Facebook:
    1. No console do Firebase , abra a seção Auth .
    2. Na guia Método de login , ative o método de login do Facebook e especifique o ID do aplicativo e o segredo do aplicativo que você obteve do Facebook.
    3. Em seguida, verifique se o URI de redirecionamento OAuth (por exemplo my-app-12345.firebaseapp.com/__/auth/handler ) está listado como um dos URIs de redirecionamento OAuth na página de configurações do aplicativo do Facebook no site do Facebook para desenvolvedores no produto Configurações > Configuração de login do Facebook .

Acesse a classe firebase::auth::Auth

A classe Auth é o gateway para todas as chamadas de API.
  1. Adicione os arquivos de cabeçalho Auth e App:
    #include "firebase/app.h"
    #include "firebase/auth.h"
    
  2. Em seu código de inicialização, crie uma 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. Adquira a classe firebase::auth::Auth para seu firebase::App . Há um mapeamento um para um entre App e Auth .
    firebase::auth::Auth* auth = firebase::auth::Auth::GetAuth(app);
    

Autenticar com o Firebase

  1. Siga as instruções para Android e iOS+ para obter um token de acesso para o usuário do Facebook conectado.
  2. Depois que um usuário fizer login, troque o token de acesso por uma credencial do Firebase e autentique-se no Firebase usando a credencial do Firebase:
    firebase::auth::Credential credential =
        firebase::auth::FacebookAuthProvider::GetCredential(access_token);
    firebase::Future<firebase::auth::User*> result =
        auth->SignInWithCredential(credential);
    
  3. Se o seu programa tiver um loop de atualização que é executado regularmente (digamos, 30 ou 60 vezes por segundo), você pode verificar os resultados uma vez por atualização com 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());
      }
    }
    
    Ou, se o seu programa for orientado a eventos, você pode preferir para registrar um retorno de chamada no Future .

Registrar um retorno de chamada em um Future

Alguns programas têm funções de Update que são chamadas 30 ou 60 vezes por segundo. Por exemplo, muitos jogos seguem esse modelo. Esses programas podem chamar as funções LastResult para pesquisar chamadas assíncronas. No entanto, se o seu programa for orientado a eventos, você pode preferir registrar funções de retorno de chamada. Uma função de retorno de chamada é chamada após a conclusão do 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::User*> result =
      auth->CreateUserWithEmailAndPasswordLastResult();

  // `&my_program_context` is passed verbatim to OnCreateCallback().
  result.OnCompletion(OnCreateCallback, &my_program_context);
}
A função callback também pode ser um lambda, se você preferir.
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);
}

Próximos passos

Depois que um usuário entra pela primeira vez, uma nova conta de usuário é criada e vinculada às credenciais, ou seja, o nome de usuário e a senha, o número de telefone ou as informações do provedor de autenticação com as quais o usuário fez login. Essa nova conta é armazenada como parte do seu projeto do Firebase e pode ser usada para identificar um usuário em todos os aplicativos do projeto, independentemente de como o usuário faça login.

  • Nos seus aplicativos, você pode obter as informações básicas do perfil do usuário no objeto firebase::auth::User :

    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();
    }
    
  • Nas regras de segurança do Firebase Realtime Database e do Cloud Storage , você pode obter o ID de usuário exclusivo do usuário conectado na variável de auth e usá-lo para controlar quais dados um usuário pode acessar.

Você pode permitir que os usuários façam login no seu aplicativo usando vários provedores de autenticação vinculando as credenciais do provedor de autenticação a uma conta de usuário existente.

Para desconectar um usuário, chame SignOut() :

auth->SignOut();