Autenticar usando o Twitter no Android

Permita que os usuários se autentiquem com o Firebase usando a própria conta do Twitter. Basta integrar o login genérico do OAuth baseado na Web ao seu app usando o SDK do Firebase para realizar o fluxo de login completo.

Antes de começar

Para fazer login de usuários usando contas do Twitter, primeiro ative o Twitter como provedor de login do seu projeto do Firebase:

  1. Adicione o Firebase ao projeto para Android, caso ainda não tenha feito isso.

  2. No Console do Firebase, abra a seção Authentication.
  3. Na guia Método de login, ative o provedor Twitter.
  4. Adicione a chave de API e a chave secreta da API do console de desenvolvimento às configurações do provedor.
    1. Registre o app como um aplicativo de desenvolvedor no Twitter e receba a chave de API e a chave secreta da API do seu app OAuth.
    2. Verifique se o URI de redirecionamento do Firebase OAuth (por exemplo, my-app-12345.firebaseapp.com/__/auth/handler) está definido como seu URL de retorno de chamada de autorização na página de configurações do aplicativo do Twitter .
  5. Clique em Save.
  6. No arquivo build.gradle no nível do projeto, inclua o repositório Maven do Google nas seções buildscript e allprojects.

  7. Adicione as dependências da biblioteca do Firebase Authentication para Android ao arquivo do Gradle no nível do aplicativo do módulo (geralmente app/build.gradle):

    implementation 'com.google.firebase:firebase-auth:19.1.0'
    
  8. Caso você ainda não tenha especificado a impressão digital SHA-1 do seu app, faça isso na página de configurações do Console do Firebase. Consulte Como autenticar seu cliente para mais detalhes sobre como conseguir a impressão digital SHA-1 do seu app.

Processar o fluxo de login com o SDK do Firebase

Se você está desenvolvendo um app Android, a maneira mais fácil de autenticar seus usuários com o Firebase usando contas do Twitter é processando todo o fluxo de login com o SDK do Firebase para Android.

Para processar o fluxo de login dessa forma, siga estas etapas:

  1. Crie uma instância de um OAuthProvider usando o Builder com o código de provedor Twitter.com.

    OAuthProvider.Builder provider = OAuthProvider.newBuilder("twitter.com");
    
  2. Opcional: especifique os parâmetros OAuth personalizados que você quer enviar com a solicitação OAuth.

    // Target specific email with login hint.
    provider.addCustomParameter("lang", "fr");
    

    Para saber quais parâmetros são aceitos pelo Twitter, consulte a documentação do Twitter para OAuth (em inglês). Não é possível transmitir os parâmetros exigidos pelo Firebase com setCustomParameters(). Esses parâmetros são client_id, response_type, redirect_uri, state, scope e response_mode.

  3. Use o objeto de provedor do OAuth para a autenticação no Firebase. Lembre-se de que, ao contrário de outras operações do FirebaseAuth, isso assumirá o controle da sua IU mostrando uma guia personalizada do Chrome (em inglês). Como resultado, não faça referência à sua atividade nos OnSuccessListener e OnFailureListener anexados, porque eles serão imediatamente desconectados quando a operação iniciar a interface do usuário.

    Primeiro, verifique se você já recebeu uma resposta. O login por meio desse método coloca sua atividade em segundo plano, o que significa que ela pode ser recuperada pelo sistema durante o fluxo de login. Para evitar uma nova tentativa do usuário caso isso acontecer, verifique se um resultado já está presente.

    Para verificar se há um resultado pendente, chame getPendingAuthResult:

    Task<AuthResult> pendingResultTask = firebaseAuth.getPendingAuthResult();
    if (pendingResultTask != null) {
      // There's something already here! Finish the sign-in for your user.
      pendingResultTask
          .addOnSuccessListener(
              new OnSuccessListener<AuthResult>() {
                @Override
                public void onSuccess(AuthResult authResult) {
                  // User is signed in.
                  // IdP data available in
                  // authResult.getAdditionalUserInfo().getProfile().
                  // The OAuth access token can also be retrieved:
                  // authResult.getCredential().getAccessToken().
                  // The OAuth secret can be retrieved by calling:
                  // authResult.getCredential().getSecret().
                }
              })
          .addOnFailureListener(
              new OnFailureListener() {
                @Override
                public void onFailure(@NonNull Exception e) {
                  // Handle failure.
                }
              });
    } else {
      // There's no pending result so you need to start the sign-in flow.
      // See below.
    }
    

    Para iniciar o fluxo de login, chame startActivityForSignInWithProvider:

    firebaseAuth
        .startActivityForSignInWithProvider(/* activity= */ this, provider.build())
        .addOnSuccessListener(
            new OnSuccessListener<AuthResult>() {
              @Override
              public void onSuccess(AuthResult authResult) {
                // User is signed in.
                // IdP data available in
                // authResult.getAdditionalUserInfo().getProfile().
                // The OAuth access token can also be retrieved:
                // authResult.getCredential().getAccessToken().
                // The OAuth secret can be retrieved by calling:
                // authResult.getCredential().getSecret().
              }
            })
        .addOnFailureListener(
            new OnFailureListener() {
              @Override
              public void onFailure(@NonNull Exception e) {
                // Handle failure.
              }
            });
    

    Se o processo foi bem-sucedido, o token de acesso de OAuth associado ao provedor pode ser recuperado com o objeto OAuthCredential retornado.

    Com o token de acesso de OAuth, é possível chamar a API Twitter (em inglês).

    Por exemplo, para receber informações básicas de perfil, chame a API REST transmitindo o token de acesso no cabeçalho Authorization:

  4. Os exemplos acima se concentram nos fluxos de login, mas também é possível vincular um provedor do Twitter a um usuário atual usando startActivityForLinkWithProvider. Por exemplo, vincule vários provedores ao mesmo usuário e permita o login com qualquer um deles.

    // The user is already signed-in.
    FirebaseUser firebaseUser = firebaseAuth.getCurrentUser();
    
    firebaseUser
        .startActivityForLinkWithProvider(/* activity= */ this, provider.build())
        .addOnSuccessListener(
            new OnSuccessListener<AuthResult>() {
              @Override
              public void onSuccess(AuthResult authResult) {
                // Twitter credential is linked to the current user.
                // IdP data available in
                // authResult.getAdditionalUserInfo().getProfile().
                // The OAuth access token can also be retrieved:
                // authResult.getCredential().getAccessToken().
                // The OAuth secret can be retrieved by calling:
                // authResult.getCredential().getSecret().
              }
            })
        .addOnFailureListener(
            new OnFailureListener() {
              @Override
              public void onFailure(@NonNull Exception e) {
                // Handle failure.
              }
            });
    
    
  5. É possível usar o mesmo padrão com startActivityForReauthenticateWithProvider, que pode ser utilizado para recuperar credenciais novas de operações confidenciais que exigem um login recente.

    // The user is already signed-in.
    FirebaseUser firebaseUser = firebaseAuth.getCurrentUser();
    
    firebaseUser
        .startActivityForReauthenticateWithProvider(/* activity= */ this, provider.build())
        .addOnSuccessListener(
            new OnSuccessListener<AuthResult>() {
              @Override
              public void onSuccess(AuthResult authResult) {
                // User is re-authenticated with fresh tokens and
                // should be able to perform sensitive operations
                // like account deletion and email or password
                // update.
              }
            })
        .addOnFailureListener(
            new OnFailureListener() {
              @Override
              public void onFailure(@NonNull Exception e) {
                // Handle failure.
              }
            });
    

Próximas etapas

Depois que um usuário faz login pela primeira vez, uma nova conta é criada e vinculada às credenciais, que podem ser o número do telefone, o nome de usuário e a senha ou as informações do provedor de autenticação. Essa nova conta é armazenada como parte do projeto do Firebase e pode ser usada para identificar um usuário em todos os apps do projeto, seja qual for o método de login utilizado.

  • Nos seus apps, use o objeto FirebaseUser para receber as informações básicas de perfil do usuário. Consulte Gerenciar usuários.

  • Nas Regras de segurança do Firebase Realtime Database e do Cloud Storage, é possível usar a variável auth para encontrar o ID exclusivo do usuário conectado. Utilize essa informação para controlar o acesso dele aos dados.

Os usuários podem fazer login no app usando vários provedores de autenticação. Basta vincular as credenciais desses provedores a uma conta de usuário.

Para desconectar um usuário, chame signOut:

Java

FirebaseAuth.getInstance().signOut();

Kotlin

FirebaseAuth.getInstance().signOut()