Autenticar usando GitHub no Android

Você pode permitir que seus usuários se autentiquem com o Firebase usando suas contas do GitHub integrando o login OAuth genérico baseado na Web em seu aplicativo usando o Firebase SDK para realizar o fluxo de login de ponta a ponta.

Antes de você começar

Para fazer login de usuários usando contas do GitHub, primeiro você precisa ativar o GitHub como provedor de login para seu projeto do Firebase:

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

  2. No console do Firebase , abra a seção Auth .
  3. Na guia Método de login , habilite o provedor GitHub .
  4. Adicione o ID do cliente e o segredo do cliente do console do desenvolvedor desse provedor à configuração do provedor:
    1. Registre seu aplicativo como um aplicativo de desenvolvedor no GitHub e obtenha o Client ID e o Client Secret do OAuth 2.0 do seu aplicativo.
    2. Certifique-se de que seu URI de redirecionamento do Firebase OAuth (por exemplo, my-app-12345.firebaseapp.com/__/auth/handler ) esteja definido como seu URL de retorno de chamada de autorização na página de configurações do seu aplicativo no config do seu aplicativo GitHub .
  5. Clique em Salvar .
  6. No arquivo Gradle do módulo (nível do aplicativo) (geralmente <project>/<app-module>/build.gradle.kts ou <project>/<app-module>/build.gradle ), adicione a dependência para o Firebase Authentication biblioteca para Android. Recomendamos usar o Firebase Android BoM para controlar o controle de versão da biblioteca.

    dependencies {
        // Import the BoM for the Firebase platform
        implementation(platform("com.google.firebase:firebase-bom:32.8.0"))
    
        // Add the dependency for the Firebase Authentication library
        // When using the BoM, you don't specify versions in Firebase library dependencies
        implementation("com.google.firebase:firebase-auth")
    }
    

    Ao usar o Firebase Android BoM , seu aplicativo sempre usará versões compatíveis das bibliotecas do Firebase Android.

    (Alternativa) Adicionar dependências da biblioteca Firebase sem usar o BoM

    Se você optar por não usar o Firebase BoM, deverá especificar cada versão da biblioteca do Firebase em sua linha de dependência.

    Observe que se você usa várias bibliotecas do Firebase no seu aplicativo, é altamente recomendável usar a BoM para gerenciar as versões da biblioteca, o que garante que todas as versões sejam compatíveis.

    dependencies {
        // Add the dependency for the Firebase Authentication library
        // When NOT using the BoM, you must specify versions in Firebase library dependencies
        implementation("com.google.firebase:firebase-auth:22.3.1")
    }
    
    Procurando um módulo de biblioteca específico para Kotlin? A partir de outubro de 2023 (Firebase BoM 32.5.0) , tanto os desenvolvedores Kotlin quanto os Java podem depender do módulo da biblioteca principal (para obter detalhes, consulte o FAQ sobre esta iniciativa ).

  7. Se você ainda não especificou a impressão digital SHA-1 do seu aplicativo, faça isso na página Configurações do console do Firebase. Consulte Autenticando seu cliente para obter detalhes sobre como obter a impressão digital SHA-1 do seu aplicativo.

Lidar com o fluxo de login com o SDK do Firebase

Se você estiver criando um aplicativo Android, a maneira mais fácil de autenticar seus usuários no Firebase usando suas contas do GitHub é lidar com todo o fluxo de login com o Firebase Android SDK.

Para lidar com o fluxo de login com o Firebase Android SDK, siga estas etapas:

  1. Construa uma instância de um OAuthProvider usando seu Builder com o ID do provedor github.com

    Kotlin+KTX

    val provider = OAuthProvider.newBuilder("github.com")

    Java

    OAuthProvider.Builder provider = OAuthProvider.newBuilder("github.com");

  2. Opcional : Especifique parâmetros OAuth customizados adicionais que você deseja enviar com a solicitação OAuth.

    Kotlin+KTX

    // Target specific email with login hint.
    provider.addCustomParameter("login", "your-email@gmail.com")

    Java

    // Target specific email with login hint.
    provider.addCustomParameter("login", "your-email@gmail.com");

    Para os parâmetros suportados pelo GitHub, consulte a documentação do GitHub OAuth . Observe que você não pode passar parâmetros exigidos pelo Firebase com setCustomParameters() . Esses parâmetros são client_id , Response_Type , Redirect_uri , State , Scope e Response_mode .

  3. Opcional : Especifique escopos adicionais do OAuth 2.0 além do perfil básico que você deseja solicitar do provedor de autenticação. Se o seu aplicativo exigir acesso a dados privados do usuário das APIs do GitHub, você precisará solicitar permissões para acessar as APIs do GitHub em Permissões de API no console do desenvolvedor do GitHub. Os escopos OAuth solicitados devem corresponder exatamente aos pré-configurados nas permissões da API do aplicativo.

    Kotlin+KTX

    // Request read access to a user's email addresses.
    // This must be preconfigured in the app's API permissions.
    provider.scopes = listOf("user:email")

    Java

    // Request read access to a user's email addresses.
    // This must be preconfigured in the app's API permissions.
    List<String> scopes =
            new ArrayList<String>() {
                {
                    add("user:email");
                }
            };
    provider.setScopes(scopes);

  4. Autentique-se com o Firebase usando o objeto do provedor OAuth. Observe que, diferentemente de outras operações do FirebaseAuth, isso assumirá o controle da sua IU abrindo uma guia personalizada do Chrome . Como resultado, não faça referência à sua atividade no OnSuccessListener e OnFailureListener anexados, pois eles serão desconectados imediatamente quando a operação iniciar a interface do usuário.

    Você deve primeiro verificar se 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 ter certeza de que o usuário não tentará novamente se isso acontecer, você deve verificar se um resultado já está presente.

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

    Kotlin+KTX

    val pendingResultTask = firebaseAuth.pendingAuthResult
    if (pendingResultTask != null) {
        // There's something already here! Finish the sign-in for your user.
        pendingResultTask
            .addOnSuccessListener {
                // User is signed in.
                // IdP data available in
                // authResult.getAdditionalUserInfo().getProfile().
                // The OAuth access token can also be retrieved:
                // ((OAuthCredential)authResult.getCredential()).getAccessToken().
                // The OAuth secret can be retrieved by calling:
                // ((OAuthCredential)authResult.getCredential()).getSecret().
            }
            .addOnFailureListener {
                // Handle failure.
            }
    } else {
        // There's no pending result so you need to start the sign-in flow.
        // See below.
    }

    Java

    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:
                                // ((OAuthCredential)authResult.getCredential()).getAccessToken().
                                // The OAuth secret can be retrieved by calling:
                                // ((OAuthCredential)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 :

    Kotlin+KTX

    firebaseAuth
        .startActivityForSignInWithProvider(activity, provider.build())
        .addOnSuccessListener {
            // User is signed in.
            // IdP data available in
            // authResult.getAdditionalUserInfo().getProfile().
            // The OAuth access token can also be retrieved:
            // ((OAuthCredential)authResult.getCredential()).getAccessToken().
            // The OAuth secret can be retrieved by calling:
            // ((OAuthCredential)authResult.getCredential()).getSecret().
        }
        .addOnFailureListener {
            // Handle failure.
        }

    Java

    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:
                            // ((OAuthCredential)authResult.getCredential()).getAccessToken().
                            // The OAuth secret can be retrieved by calling:
                            // ((OAuthCredential)authResult.getCredential()).getSecret().
                        }
                    })
            .addOnFailureListener(
                    new OnFailureListener() {
                        @Override
                        public void onFailure(@NonNull Exception e) {
                            // Handle failure.
                        }
                    });

    Após a conclusão bem-sucedida, o token de acesso OAuth associado ao provedor poderá ser recuperado do objeto OAuthCredential retornado.

    Usando o token de acesso OAuth, você pode chamar a API GitHub .

    Por exemplo, para obter informações básicas de perfil, você pode chamar a API REST, passando o token de acesso no cabeçalho Authorization :

  5. Embora os exemplos acima se concentrem em fluxos de login, você também tem a capacidade de vincular um provedor GitHub a um usuário existente usando startActivityForLinkWithProvider . Por exemplo, você pode vincular vários provedores ao mesmo usuário, permitindo que eles façam login com qualquer um deles.

    Kotlin+KTX

    // The user is already signed-in.
    val firebaseUser = firebaseAuth.currentUser!!
    firebaseUser
        .startActivityForLinkWithProvider(activity, provider.build())
        .addOnSuccessListener {
            // Provider 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 {
            // Handle failure.
        }

    Java

    // 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) {
                            // Provider 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.
                        }
                    });

  6. O mesmo padrão pode ser usado com startActivityForReauthenticateWithProvider , que pode ser usado para recuperar novas credenciais para operações confidenciais que exigem login recente.

    Kotlin+KTX

    // The user is already signed-in.
    val firebaseUser = firebaseAuth.currentUser!!
    firebaseUser
        .startActivityForReauthenticateWithProvider(activity, provider.build())
        .addOnSuccessListener {
            // User is re-authenticated with fresh tokens and
            // should be able to perform sensitive operations
            // like account deletion and email or password
            // update.
        }
        .addOnFailureListener {
            // Handle failure.
        }

    Java

    // 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óximos passos

Depois que um usuário faz login pela primeira vez, uma nova conta de usuário é criada e vinculada às credenciais (ou seja, nome de usuário e senha, número de telefone ou 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 seu projeto, independentemente de como o usuário faz login.

  • Nos seus aplicativos, você pode obter informações básicas do perfil do usuário no objeto FirebaseUser . Consulte Gerenciar usuários .

  • 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 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 :

Kotlin+KTX

Firebase.auth.signOut()

Java

FirebaseAuth.getInstance().signOut();