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

Autenticar usando OpenID Connect no Android

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Se você fez upgrade para o Firebase Authentication com Identity Platform, poderá autenticar seus usuários com o Firebase usando o provedor compatível com OpenID Connect (OIDC) de sua escolha. Isso possibilita o uso de provedores de identidade não suportados nativamente pelo Firebase.

Antes de você começar

Para fazer login de usuários usando um provedor OIDC, você deve primeiro coletar algumas informações do provedor:

  • ID do cliente : uma string exclusiva do provedor que identifica seu aplicativo. Seu provedor pode atribuir a você um ID de cliente diferente para cada plataforma compatível. Este é um dos valores da declaração aud em tokens de identificação emitidos pelo seu provedor.

  • Segredo do cliente : uma string secreta que o provedor usa para confirmar a propriedade de um ID do cliente. Para cada ID de cliente, você precisará de um segredo de cliente correspondente. (Esse valor é necessário apenas se você estiver usando o fluxo de código de autenticação , o que é altamente recomendado.)

  • Emissor : uma string que identifica seu provedor. Esse valor deve ser um URL que, quando anexado com /.well-known/openid-configuration , seja o local do documento de descoberta OIDC do provedor. Por exemplo, se o emissor for https://auth.example.com , o documento de descoberta deverá estar disponível em https://auth.example.com/.well-known/openid-configuration .

Depois de obter as informações acima, ative o OpenID Connect como um provedor de login para seu projeto do Firebase:

  1. Adicione o Firebase ao seu projeto Android .

  2. Se você não fez upgrade para o Firebase Authentication com Identity Platform, faça isso. A autenticação OpenID Connect está disponível apenas em projetos atualizados.

  3. Na página Provedores de login do console do Firebase, clique em Adicionar novo provedor e em OpenID Connect .

  4. Selecione se você usará o fluxo de código de autorização ou o fluxo de concessão implícito .

    Você deve usar sempre o fluxo de código se o seu provedor oferecer suporte . O fluxo implícito é menos seguro e seu uso é fortemente desencorajado.

  5. Dê um nome a este provedor. Observe o ID do provedor gerado: algo como oidc.example-provider . Você precisará desse ID ao adicionar o código de login ao seu aplicativo.

  6. Especifique seu ID e segredo do cliente e a string do emissor do seu provedor. Esses valores devem corresponder exatamente aos valores que seu provedor atribuiu a você.

  7. Salve suas alterações.

Gerencie 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 com o Firebase usando seu provedor OIDC é 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. Construir uma instância de um OAuthProvider usando seu Builder com o ID do provedor

    Kotlin+KTX

    val providerBuilder = OAuthProvider.newBuilder("oidc.example-provider")
    

    Java

    OAuthProvider.Builder providerBuilder = OAuthProvider.newBuilder("oidc.example-provider");
    
  2. Opcional : especifique parâmetros OAuth personalizados adicionais que você deseja enviar com a solicitação OAuth.

    Kotlin+KTX

    // Target specific email with login hint.
    providerBuilder.addCustomParameter("login_hint", "user@example.com")
    

    Java

    // Target specific email with login hint.
    providerBuilder.addCustomParameter("login_hint", "user@example.com");
    

    Verifique com seu provedor OIDC os parâmetros que eles suportam. Observe que você não pode passar parâmetros obrigatórios do 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 ao provedor de autenticação.

    Kotlin+KTX

    val scopes = arrayListOf("mail.read", "calendars.read")
    providerBuilder.setScopes(scopes)
    

    Java

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

    Verifique com seu provedor OIDC os escopos que eles usam.

  4. Autentique-se com o Firebase usando o objeto do provedor OAuth. Observe que, ao contrário de outras operações do FirebaseAuth, isso assumirá o controle de sua interface do usuário, exibindo uma guia personalizada do Chrome . Como resultado, não faça referência à sua atividade no OnSuccessListener e no OnFailureListener que você anexar, 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. Fazer login com esse método coloca sua atividade em segundo plano, o que significa que ela pode ser recuperada pelo sistema durante o fluxo de login. Para garantir que você não faça o usuário 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.getInstance().pendingAuthResult
    if (pendingResultTask != null) {
        // There's something already here! Finish the sign-in for your user.
        pendingResultTask
            .addOnSuccessListener { authResult ->
                // User is signed in.
    
                // IdP data available in
                //   authResult.additionalUserInfo.profile
    
                // The OAuth access token and ID token can also be retrieved:
                val credential = authResult.credential
                if (credential !is OAuthCredential)
                    return@addOnSuccessListener
                val accessToken = credential.accessToken
                val idToken = credential.idToken
            }
            .addOnFailureListener { e ->
                // 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 ID token can also be retrieved:
                  // ((OAuthCredential)authResult.getCredential()).getIdToken().
                }
              })
          .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.getInstance()
        .startActivityForSignInWithProvider(/* activity= */ this, providerBuilder.build())
        .addOnSuccessListener { authResult ->
            // User is signed in.
    
            // IdP data available in:
            //    authResult.additionalUserInfo.profile
    
            // The OAuth access token and ID token can also be retrieved:
            val credential = authResult.credential
            if (credential !is OAuthCredential)
                return@addOnSuccessListener
            val accessToken = credential.accessToken
            val idToken = credential.idToken
        }
        .addOnFailureListener { e ->
            // Handle failure.
        }
    

    Java

    firebaseAuth
        .startActivityForSignInWithProvider(/* activity= */ this, providerBuilder.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 ID token can also be retrieved:
                // authResult.getCredential().getIdToken().
              }
            })
        .addOnFailureListener(
            new OnFailureListener() {
              @Override
              public void onFailure(@NonNull Exception e) {
                // Handle failure.
              }
            });
    
  5. Embora os exemplos acima se concentrem em fluxos de entrada, você também pode vincular um provedor OIDC a um usuário existente usando startActivityForLinkWithProvider . Por exemplo, você pode vincular vários provedores ao mesmo usuário, permitindo que eles entrem com qualquer um deles.

    Kotlin+KTX

    // The user is already signed-in.
    val firebaseUser = FirebaseAuth.getInstance().currentUser
    
    firebaseUser
        ?.startActivityForLinkWithProvider(/* activity= */ this, providerBuilder.build())
        ?.addOnSuccessListener { authResult ->
            // OIDC credential is linked to the current user.
    
            // IdP data available in:
            //   authResult.additionalUserInfo.profile
    
            // The OAuth access token and ID token can also be retrieved:
            val credential = authResult.credential
            if (credential !is OAuthCredential)
                return@addOnSuccessListener
            val accessToken = credential.accessToken
            val idToken = credential.idToken
        }
        ?.addOnFailureListener { e ->
            // 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) {
                // 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 ID token can also be retrieved:
                // authResult.getCredential().getIdToken().
              }
            })
        .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.getInstance().currentUser
    
    firebaseUser
        ?.startActivityForReauthenticateWithProvider(/* activity= */ this, providerBuilder.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.
              }
            });
    

Gerenciar o fluxo de login manualmente

Se você já implementou o fluxo de login do OpenID Connect no seu aplicativo, pode usar o token de ID diretamente para autenticar com o Firebase:

Kotlin+KTX

      val credential = OAuthProvider
          .newCredentialBuilder("oidc.example-provider")  // As registered in Firebase console.
          .setIdToken(idToken)  // ID token from OpenID Connect flow.
          .build()
      FirebaseAuth.getInstance()
          .signInWithCredential(credential)
          .addOnSuccessListener { authResult ->
              // User is signed in.

              // IdP data available in:
              //    authResult.additionalUserInfo.profile
          }
          .addOnFailureListener { e ->
              // Handle failure.
          }

Java

AuthCredential credential = OAuthProvider
        .newCredentialBuilder("oidc.example-provider")  // As registered in Firebase console.
        .setIdToken(idToken)  // ID token from OpenID Connect flow.
        .build();
FirebaseAuth.getInstance()
        .signInWithCredential(credential)
        .addOnSuccessListener(new OnSuccessListener<AuthResult>() {
            @Override
            public void onSuccess(AuthResult authResult) {
                // User is signed in.

                // IdP data available in:
                //    authResult.getAdditionalUserInfo().getProfile()
            }
        })
        .addOnFailureListener(new OnFailureListener() {
            @Override
            public void onFailure(@NonNull Exception e) {
                // Handle failure.
            }
        });

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 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 a partir da 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 :

Java

FirebaseAuth.getInstance().signOut();

Kotlin+KTX

Firebase.auth.signOut()