> For the complete documentation index, see [llms.txt](https://docs.caf.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.caf.io/caf-sdk/caf-sdk-pt-br/android/standalone-modules/caffacelivenesslite.md).

# Face Liveness Lite

SDK leve de verificação de vivacidade facial para Android. Oferece um fluxo simplificado para verificar se um rosto capturado está vivo, com integração simples e baixo consumo de recursos.

O SDK Face Liveness Lite é uma alternativa leve ao SDK Face Liveness. Ele oferece a mesma verificação passiva de liveness com uma pegada mínima, tornando-o ideal para apps onde o tamanho do download é uma prioridade.

### Comparação de tamanho

<table><thead><tr><th width="371.890625">SDK</th><th>Tamanho</th></tr></thead><tbody><tr><td>Face Liveness (<code>caf-face-liveness</code>)</td><td>~25,6 MB </td></tr><tr><td>Face Liveness Lite (<code>caf-face-liveness-lite</code>)</td><td>~3,9 MB </td></tr></tbody></table>

{% hint style="success" %}
O SDK Lite é aproximadamente **85% menor** (6,6x) do que o SDK completo Face Liveness.
{% endhint %}

## Instalação

### Requisitos

Antes de integrar, verifique se o seu ambiente atende aos requisitos mínimos do SDK Face Liveness Lite:

| Requisito                                    | Versão |
| -------------------------------------------- | ------ |
| Versão mínima do SDK (minSdk)                | 26     |
| Versão de compilação do Android (compileSDK) | 36     |
| Versão mínima do Kotlin                      | 1.9.10 |
| Versão do Gradle                             | 8.4    |
| Plugin do Android Gradle (AGP)               | 8.3.2  |

### Permissões

Para habilitar a funcionalidade necessária de rede e câmera, declare as permissões e recursos de hardware apropriados no arquivo do seu projeto `AndroidManifest.xml` arquivo.

Adicione as seguintes linhas dentro da sua `<manifest>` tag:

{% code title="AndroidManifest.xml" %}

```xml
<uses-feature android:name="android.hardware.camera" />
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.CAMERA" />
```

{% endcode %}

### Adicionando repositórios

Para baixar o SDK Face Liveness Lite, adicione a URL do repositório necessária ao `dependencyResolutionManagement` bloco localizado na raiz do projeto `settings.gradle.kts` arquivo:

{% hint style="info" %}
Para projetos baseados em Groovy, inclua os seguintes repositórios no `settings.gradle` arquivo.
{% endhint %}

{% tabs %}
{% tab title="Script Kotlin" %}
{% code title="settings.gradle.kts" %}

```kts
dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        maven { url = uri("https://repo.combateafraude.com/android/release") }
    }
}
```

{% endcode %}
{% endtab %}

{% tab title="Groovy" %}
{% code title="settings.gradle" %}

```groovy
dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        maven { url "https://repo.combateafraude.com/android/release" }
    }
}
```

{% endcode %}
{% endtab %}
{% endtabs %}

### Adicionando dependências

Adicione a dependência Face Liveness Lite ao nível do seu módulo (nível do app) `build.gradle.kts` arquivo:

{% code title="build.gradle.kts" %}

```kts
dependencies {
    implementation("io.caf.sdk:caf-face-liveness-lite:7.25.0")
}
```

{% endcode %}

## Iniciando o Liveness

O fluxo de Liveness tem três etapas:

1. **`configure()`** — forneça suas credenciais ao SDK, uma única vez.
2. **`prewarm()`** — busque a sessão de liveness enquanto o usuário ainda estiver na tela anterior.
3. **`startLiveness()`** — abra a câmera e receba o resultado.

{% hint style="info" %}
Dividir o trabalho dessa forma permite que a solicitação de rede aconteça antes que o usuário peça a câmera, então a câmera abre visivelmente mais rápido.
{% endhint %}

### Configurar

Crie uma `CafLivenessConfig` e passe-a para `configure()`. Isso armazena apenas o contexto e a configuração.&#x20;

{% code title="MainActivity.kt" %}

```kotlin
val livenessConfig = CafLivenessConfig(
    mobileToken = "<YOUR_MOBILE_TOKEN>",
    stage = CafStage.PROD,
    personId = "<PERSON_ID>",
    showLoading = true,
    enableSecurity = true
)
CafFaceLivenessLite.instance.configure(context, livenessConfig)
```

{% endcode %}

#### `CafLivenessConfig` Parâmetros

| Parâmetro        | Padrão | Descrição                                                                                       |
| ---------------- | ------ | ----------------------------------------------------------------------------------------------- |
| `mobileToken`    | —      | **Obrigatório.** Token de autenticação móvel usado para autenticação no backend.                |
| `stage`          | `PROD` | **Obrigatório.** Ambiente de destino: `PROD`, `BETA`, ou `DEV`.                                 |
| `personId`       | —      | **Obrigatório.** Identifica o usuário para o processo de liveness.                              |
| `showLoading`    | `true` | Mostra indicadores de carregamento durante o processamento quando **true**.                     |
| `enableSecurity` | `true` | Quando **ativado**, executa a validação de segurança do dispositivo antes e durante o liveness. |

### Pré-aquecimento

Chame `prewarm()` assim que você souber que o Liveness está chegando — quando o usuário chegar à tela anterior ou quando o botão "Start" ficar visível. O SDK cria a sessão de Liveness em segundo plano para `startLiveness()` não precise esperar por isso.

```kotlin
CafFaceLivenessLite.instance.prewarm()
```

`prewarm()` não recebe parâmetros, retorna imediatamente e não informa nada — o trabalho continua em segundo plano. Requer `configure()` ter sido chamado primeiro.

{% hint style="info" %}
`prewarm()` é opcional. Se você pular isso, `startLiveness()` cria a sessão por conta própria e tudo funciona exatamente da mesma forma — só sem o ganho de velocidade.
{% endhint %}

{% hint style="warning" %}
A sessão pré-aquecida é válida por 90 segundos e é usada no máximo uma vez. Se a janela expirar, ou a sessão já tiver sido usada por uma execução anterior `startLiveness()`, uma nova é obtida automaticamente.
{% endhint %}

### Iniciar o Liveness

Chame `startLiveness()` com um callback para tratar os resultados e os eventos disparados durante o fluxo de Liveness.

```kotlin
CafFaceLivenessLite.instance.startLiveness { event ->
    when (event) {
        is LivenessLiteEvent.Success -> {
            // Tratar sucesso
        }
        is LivenessLiteEvent.Failure -> {
            // Tratar falha
        }
        is LivenessLiteEvent.Error -> {
            // Tratar erro
        }
        LivenessLiteEvent.Cancelled -> {
            // O usuário abandonou o fluxo
        }
        LivenessLiteEvent.Loading -> {
            // Mostrar um indicador de carregamento
        }
        LivenessLiteEvent.Loaded -> {
            // Ocultar o indicador de carregamento
        }
    }
}
```

{% hint style="info" %}
Se um pré-aquecimento ainda estiver em execução quando `startLiveness()` for chamado, o SDK espera por ele em vez de iniciar uma segunda solicitação — então chamar `prewarm()` pouco antes nunca é desperdiçado.
{% endhint %}

### Exemplo completo

```kotlin
class SelfieIntroFragment : Fragment() {

    private val livenessConfig = CafLivenessConfig(
        mobileToken = "<YOUR_MOBILE_TOKEN>",
        stage = CafStage.PROD,
        personId = "<PERSON_ID>",
        showLoading = true,
        enableSecurity = true
    )

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)

        // O usuário está na tela anterior ao Liveness: prepare a sessão agora.
        CafFaceLivenessLite.instance.configure(requireContext(), livenessConfig)
        CafFaceLivenessLite.instance.prewarm()

        startButton.setOnClickListener {
            CafFaceLivenessLite.instance.startLiveness { event ->
                // Tratar eventos
            }
        }
    }
}
```

## Entendendo eventos e resultados do Liveness

Para lidar com o resultado do fluxo de Liveness, passe um callback para o `CafFaceLivenessLite.instance.startLiveness()` método para ouvir **sucesso**, **falha**, ou **erro** eventos.

{% hint style="warning" %}
Certifique-se de que a resposta JWT seja avaliada no backend. Esse processo deve incluir a validação da assinatura do token e a verificação dos `isAlive` e `isMatch` campos. Não realize essas validações no lado do cliente.
{% endhint %}

#### **`LivenessLiteEvent.Success(`**`signedResponse`**`: String)`**

O pipeline de captura e liveness foi concluído com sucesso. **signedResponse** é um JWT que contém os dados de resultado obtidos durante a execução do Liveness. Esses dados podem incluir informações relevantes para o processo, como imagens capturadas ou resultados de validação.

#### **`LivenessLiteEvent.Failure(signedResponse: String, type: CafFailureType, description: String)`**

O Liveness foi executado, mas o resultado foi uma falha de negócio:

1. **`signedResponse`**&#x4F; payload assinado retornado pelo servidor. Pode estar vazio em falhas no nível da captura.
2. **`tipo`**: Um `CafFailureType` valor de enumeração que identifica exatamente por que o processo não teve sucesso, como problemas de ambiente, timeout, nenhum rosto detectado ou uma autenticação facial rejeitada.
3. **`descrição`**: Uma descrição legível por humanos destinada a diagnósticos ou mensagens de UX.

{% hint style="info" %}
Para entender e lidar com o `tipo` da falha, consulte Tratamento de falhas.
{% endhint %}

#### **`LivenessLiteEvent.Error(type: CafLivenessErrorType, description: Stringm cause:`**` ``Throwable`**`)`**

Disparado quando um bloqueio técnico impede o SDK de iniciar ou concluir o processo, como permissões da câmera negadas, sem conexão com a internet ou falhas na inicialização do hardware.

| CafLivenessErrorType      | Causa típica                                                          |
| ------------------------- | --------------------------------------------------------------------- |
| `CONFIGURATION_EXCEPTION` | **`mobileToken`** ou **`personId`** não fornecida.                    |
| `TOKEN_EXCEPTION`         | Inválido **`mobileToken`** detectado.                                 |
| `CAMERA_PERMISSION`       | Permissão da câmera (ou relacionada) negada.                          |
| `NETWORK_EXCEPTION`       | Problemas de conectividade aparecem como erros da classe de rede.     |
| `SERVER_EXCEPTION`        | Problemas no servidor ao criar ou validar a sessão.                   |
| `LIVENESS_EXCEPTION`      | O mecanismo de captura de liveness falhou ao inicializar ou executar. |
| `SECURITY_EXCEPTION`      | As verificações de segurança falharam.                                |
| `UNSUPPORTED_DEVICE`      | O dispositivo não atende aos requisitos de hardware.                  |
| `GENERIC_EXCEPTION`       | Outras falhas não mapeadas para um caso específico.                   |

#### **`LivenessLiteEvent.Cancelled`**

Ocorre quando o usuário abandona o fluxo antes da conclusão, como ao pressionar o botão voltar ou enviar o app para segundo plano.

#### **`LivenessLiteEvent.Loading` / `LivenessLiteEvent.Loaded`**

Eventos de ciclo de vida emitidos enquanto a sessão está sendo preparada. Use-os para mostrar ou ocultar um indicador de carregamento na sua UI.

## Alterando o usuário ou as credenciais

Se você chamar `configure()` novamente com um(a) diferente `mobileToken` ou `personId`, qualquer sessão pré-aquecida será descartada, pois pertence ao usuário anterior. Chame `prewarm()` novamente após reconfigurar.

## Liberando o SDK

`release()` cancela o Liveness em andamento e descarta qualquer sessão pré-aquecida. A configuração de `configure()` é mantida, então você pode chamar `prewarm()` ou `startLiveness()` novamente sem reconfigurar.

```kotlin
CafFaceLivenessLite.instance.release()
```

Links:

{% content-ref url="/pages/dc4cd36c7463361a88fcc7d56b9c2bd341ce5b6e" %}
[Face Liveness Lite](/caf-sdk/caf-sdk-pt-br/android/standalone-modules/caffacelivenesslite.md)
{% endcontent-ref %}

{% content-ref url="/pages/81448022d7df70d98c5eb3cf72e49fe05e6df99b" %}
[Tratamento de falhas](/caf-sdk/caf-sdk-pt-br/android/getting-started-with-the-sdk/handling-failures.md)
{% endcontent-ref %}

{% content-ref url="/pages/4f5e1dfedd1017d3b6433c571a904439a138bbf1" %}
[Personalização da interface](/caf-sdk/caf-sdk-pt-br/android/standalone-modules/caffacelivenesslite/ui-customization.md)
{% endcontent-ref %}

{% content-ref url="/pages/fe433841f24be5e1ede569091ecfd49f66b5007b" %}
[Notas de versão](/caf-sdk/caf-sdk-pt-br/android/standalone-modules/caffacelivenesslite/changelog.md)
{% endcontent-ref %}


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.caf.io/caf-sdk/caf-sdk-pt-br/android/standalone-modules/caffacelivenesslite.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.