Integrar a criação de chaves de acesso com toque único e login com solicitações biométricas

No Android 15, o Gerenciador de credenciais oferece suporte a um fluxo de um toque para criação e recuperação de credenciais. Nesse fluxo, as informações da credencial que está sendo criada ou usada são mostradas diretamente no comando biométrico, junto com um ponto de entrada para mais opções. Esse processo simplificado cria um processo de criação e recuperação de credenciais mais eficiente e simplificado.

Requisitos:

• A biometria foi configurada no dispositivo do usuário, e ele permite a autenticação em aplicativos.
• Para fluxos de login, esse recurso é ativado apenas para cenários de conta única, mesmo que haja várias credenciais (como chave de acesso e senha) disponíveis para essa conta.

Ativar o toque único em fluxos de criação de chaves de acesso

As etapas de criação desse método correspondem ao processo de criação de credenciais atual. Na BeginCreatePublicKeyCredentialRequest, use handleCreatePasskeyQuery() para processar a solicitação, se ela for para uma chave de acesso.

is BeginCreatePublicKeyCredentialRequest -> {
  Log.i(TAG, "Request is passkey type")
  return handleCreatePasskeyQuery(request, passwordCount, passkeyCount)
}

No handleCreatePasskeyQuery(), inclua BiometricPromptData com a classe CreateEntry:

val createEntry = CreateEntry(
  // Additional properties...
  biometricPromptData = BiometricPromptData(
    allowedAuthenticators = allowedAuthenticator
  )
)

Os provedores de credenciais precisam definir explicitamente a propriedade allowedAuthenticator na instância BiometricPromptData. Se essa propriedade não for definida, o valor padrão será DEVICE_WEAK. Defina a propriedade cryptoObject opcional, se necessário, para seu caso de uso.

Observação: se o dispositivo estiver configurado para usar DEVICE_CREDENTIALS para exigir um PIN ou uma senha para autenticação, mesmo que a biometria esteja disponível ou ativada, o fluxo padrão do gerenciador de credenciais será usado em vez do fluxo de um toque. Isso significa que o provedor sempre vai receber um valor null para biometricPromptResult nesses cenários.

Ativar o fluxo de chave de acesso de toque único no login

Assim como o fluxo de criação de chaves de acesso, ele vai seguir a configuração atual para processar o login do usuário. Em BeginGetPublicKeyCredentialOption, use populatePasskeyData() para coletar as informações relevantes sobre a solicitação de autenticação:

is BeginGetPublicKeyCredentialOption -> {
  // ... other logic

  populatePasskeyData(
    origin,
    option,
    responseBuilder,
    autoSelectEnabled,
    allowedAuthenticator
  )

  // ... other logic as needed
}

Semelhante a CreateEntry, uma instância BiometricPromptData é definida como a instância PublicKeyCredentialEntry. Se não estiver definido explicitamente, allowedAuthenticator assumirá como padrão BIOMETRIC_WEAK.

PublicKeyCredentialEntry(
  // other properties...

  biometricPromptData = BiometricPromptData(
    allowedAuthenticators = allowedAuthenticator
  )
)

Observação: o usuário vai receber uma opção de autenticação biométrica se o dispositivo for compatível e ele tiver concedido permissão para o uso. O código é semelhante ao exemplo anterior, com a adição de um cryptoObject.

Processar a seleção de entrada de credencial

Ao processar a seleção de entrada de credencial para criação de chave de acesso ou seleção de chave de acesso durante o login, chame PendingIntentHandler's retrieveProviderCreateCredentialRequest ou retrieveProviderGetCredentialRequest, conforme apropriado. Eles retornam objetos que contêm os metadados necessários para o provedor. Por exemplo, ao processar a seleção de entrada de criação de chave de acesso, atualize seu código como mostrado:

val createRequest = PendingIntentHandler.retrieveProviderCreateCredentialRequest(intent)
if (createRequest == null) {
  Log.i(TAG, "request is null")
  setUpFailureResponseAndFinish("Unable to extract request from intent")
  return
}
// Other logic...

val biometricPromptResult = createRequest.biometricPromptResult

// Add your logic based on what needs to be done
// after getting biometrics

if (createRequest.callingRequest is CreatePublicKeyCredentialRequest) {
  val publicKeyRequest: CreatePublicKeyCredentialRequest =
    createRequest.callingRequest as CreatePublicKeyCredentialRequest

  if (biometricPromptResult == null) {
    // Do your own authentication flow, if needed
  }
  else if (biometricPromptResult.isSuccessful) {
    createPasskey(
        publicKeyRequest.requestJson,
        createRequest.callingAppInfo,
        publicKeyRequest.clientDataHash,
        accountId
    )
  } else {
    val error = biometricPromptResult.authenitcationError
    // Process the error
}

  // Other logic...
}

Este exemplo contém informações sobre o sucesso do fluxo biométrico. Ela também contém outras informações sobre a credencial. Se o fluxo falhar, use o código de erro em biometricPromptResult.authenticationError para tomar decisões. Os códigos de erro retornados como parte de biometricPromptResult.authenticationError.errorCode são os mesmos códigos de erro definidos na biblioteca androidx.biometric, como androidx.biometric.BiometricPrompt.NO_SPACE, androidx.biometric.BiometricPrompt.UNABLE_TO_PROCESS, androidx.biometric.BiometricPrompt.ERROR_TIMEOUT e similares. O authenticationError também vai conter uma mensagem de erro associada ao errorCode, que pode ser mostrada em uma interface.

Da mesma forma, extraia metadados durante o retrieveProviderGetCredentialRequest. Verifique se o fluxo biométrico é null. Se sim, configure sua própria biometria para autenticação. Isso é semelhante à forma como a operação de busca é instrumentada:

val getRequest =
    PendingIntentHandler.retrieveProviderGetCredentialRequest(intent)

if (getRequest == null) {
  Log.i(TAG, "request is null")
  setUpFailureResponseAndFinish("Unable to extract request from intent")
  return
}

// Other logic...

val biometricPromptResult = getRequest.biometricPromptResult

// Add your logic based on what needs to be done
// after getting biometrics

if (biometricPromptResult == null)
{
  // Do your own authentication flow, if necessary
} else if (biometricPromptResult.isSuccessful) {

Log.i(TAG, "The response from the biometricPromptResult was ${biometricPromptResult.authenticationResult.authenticationType}")

validatePasskey(
    publicKeyRequest.requestJson,
    origin,
    packageName,
    uid,
    passkey.username,
    credId,
    privateKey
)
  } else {
    val error = biometricPromptResult.authenitcationError
    // Process the error
}

  // Other logic...