Ir para o console

Autenticar com a Microsoft no Android

Permita que os usuários se autentiquem com o Firebase usando provedores OAuth, como o Microsoft Azure Active Directory. Basta integrar o login genérico do OAuth 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 da Microsoft (Azure Active Directory e contas pessoais da Microsoft), primeiro ative a Microsoft como um provedor de login do seu projeto do Firebase:

  1. Adicione o Firebase ao projeto do Android.

  2. No Console do Firebase, abra a seção Auth.
  3. Na guia Método de login, ative o provedor Microsoft.
  4. Adicione o ID do cliente e a chave secreta do cliente do console de desenvolvimento às configurações do provedor.
    1. Para registrar um cliente OAuth da Microsoft, siga as instruções em Guia de início rápido: como registrar um app com o endpoint do Azure Active Directive 2.0 (em inglês). Observe que esse endpoint é compatível com login por meio de contas pessoais da Microsoft, bem como de contas do Azure Active Directory. Saiba mais sobre o Azure Active Directory v2.0 (em inglês).
    2. Ao registrar apps nesses provedores, registre o domínio *.firebaseapp.com do seu projeto como o domínio de redirecionamento do seu aplicativo.
  5. Clique em Salvar.
  6. No arquivo build.gradle do nível de projeto, certifique-se de incluir repositório Maven do Google, nas seções buildscript e allprojects.

  7. 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 da Microsoft é processando o fluxo de login com o SDK do Firebase para Android.

Para processar o fluxo de login com o SDK do Firebase para Android, siga estas etapas:

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

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

    // Force re-consent.
    provider.addCustomParameter("prompt", "consent");
    
    // Target specific email with login hint.
    provider.addCustomParameter("login_hint", "user@firstadd.onmicrosoft.com");
    

    Para saber quais parâmetros são aceitos pela Microsoft, consulte a documentação do OAuth da Microsoft (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.

    Para permitir que apenas usuários de um determinado locatário do Azure AD façam login no aplicativo, o nome de domínio do locatário do Azure AD ou o identificador de GUID do locatário pode ser usado. Isso pode ser feito ao especificar o campo "locatário" no objeto de parâmetros personalizados.

    // Optional "tenant" parameter in case you are using an Azure AD tenant.
    // eg. '8eaef023-2b34-4da1-9baa-8bc8c9d6a490' or 'contoso.onmicrosoft.com'
    // or "common" for tenant-independent tokens.
    // The default value is "common".
    provider.addCustomParameter("tenant", "TENANT_ID");
    
  3. Opcional: especifique os outros escopos de OAuth 2.0 além do perfil básico que você quer solicitar ao provedor de autenticação.

    List<String> scopes =
        new ArrayList<String>() {
          {
            add("mail.read");
            add("calendars.read");
          }
        };
    provider.setScopes(scopes);
    

    Para saber mais, consulte a documentação de permissões e consentimento da Microsoft (em inglês).

  4. 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 no OnSuccessListener e no 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().
                }
              })
          .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().
              }
            })
        .addOnFailureListener(
            new OnFailureListener() {
              @Override
              public void onFailure(@NonNull Exception e) {
                // Handle failure.
              }
            });
    

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

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

    Ao contrário de outros provedores compatíveis com o Firebase Auth, a Microsoft não fornece um URL de foto. Em vez disso, os dados binários de uma foto de perfil precisam ser solicitados por meio da API Microsoft Graph (em inglês).

  5. Embora os exemplos acima se concentrem nos fluxos de login, também é possível vincular um provedor da Microsoft a um usuário existente usando startActivityForLinkWithProvider. Por exemplo, você pode vincular vários provedores ao mesmo usuário permitindo 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) {
                // Microsoft 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().
              }
            })
        .addOnFailureListener(
            new OnFailureListener() {
              @Override
              public void onFailure(@NonNull Exception e) {
                // Handle failure.
              }
            });
    
    
  6. É 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.
              }
            });
    

A seguir

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 apps, é possível acessar informações básicas de perfil do usuário por meio do objeto FirebaseUser. 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 código exclusivo do usuário conectado. Use essa informação para controlar os dados que os usuários podem acessar.

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
Android

FirebaseAuth.getInstance().signOut();

Kotlin
Android

FirebaseAuth.getInstance().signOut()