> 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

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 aplicativos em que 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 do Face Liveness.
{% endhint %}

## Instalação

### Requisitos

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

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

### Permissões

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

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 arquivo `settings.gradle.kts` do projeto:

{% hint style="info" %}
Para projetos baseados em Groovy, inclua os seguintes repositórios no `settings.gradle` do seu projeto.
{% 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 seu `build.gradle.kts` do projeto:

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

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

{% endcode %}

## Iniciando o Liveness

Para iniciar o fluxo de Liveness, chame `CafFaceLivenessLite.instance.startLiveness()` e passe um `CafLivenessConfig` objeto.

{% hint style="info" %}
Este método aceita um callback para tratar os resultados e eventos disparados durante o fluxo de Liveness.
{% endhint %}

{% tabs %}
{% tab title="Kotlin" %}
{% code expandable="true" %}

```kotlin
val livenessConfig = CafLivenessConfig(
    mobileToken = "<YOUR_MOBILE_TOKEN>",
    stage = CafStage.PROD,
    personId = "<PERSON_ID>",
    showLoading = true,
    enableSecurity = true
)
CafFaceLivenessLite.instance.startLiveness(context, livenessConfig) { 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 -> {
            // Exibir um indicador de carregamento
        }
        LivenessLiteEvent.Loaded -> {
            // Ocultar o indicador de carregamento
        }
    }
}
```

{% endcode %}
{% endtab %}

{% tab title="Java" %}

```java
CafLivenessConfig livenessConfig = new CafLivenessConfig(
    "<YOUR_MOBILE_TOKEN>",  // mobileToken
    CafStage.PROD,          // stage
    "<PERSON_ID>",          // personId
    true,                   // loading
    true                    // enableSecurity
);
CafFaceLivenessLite.Companion.getInstance().startLiveness(context, livenessConfig, event -> {
    if (event instanceof LivenessLiteEvent.Success) {
        // Tratar sucesso
    } else if (event instanceof LivenessLiteEvent.Failure) {
        // Tratar falha
    } else if (event instanceof LivenessLiteEvent.Error) {
        // Tratar erro
    } else if (event instanceof LivenessLiteEvent.Cancelled) {
        // O usuário abandonou o fluxo
    } else if (event instanceof LivenessLiteEvent.Loading) {
        // Exibir um indicador de carregamento
    } else if (event instanceof LivenessLiteEvent.Loaded) {
        // Ocultar o indicador de carregamento
    }
});
```

{% endtab %}
{% endtabs %}

### `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`          | —      | **Obrigatório.** Ambiente de destino: `PROD`, `BETA`, ou `DEV`.                               |
| `personId`       | —      | **Obrigatório.** Identifica o usuário para o processo de liveness.                            |
| `showLoading`    | `true` | Exibe indicadores de carregamento durante o processamento quando **true**.                    |
| `enableSecurity` | `true` | Quando **ativado**, executa validação de segurança do dispositivo antes e durante o liveness. |

### Entendendo eventos e resultados de Liveness

Para tratar o resultado do fluxo de Liveness, passe um callback para a `CafFaceLivenessLite.instance.startLiveness()` método para escutar **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 campos `isAlive` e `isMatch` . Não execute essas validações no lado do cliente.
{% endhint %}

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

O pipeline de captura e liveness foi bem-sucedido. **signedResponse** é um JWT contendo 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 é uma falha de negócio:

1. **`signedResponse`**: O payload assinado retornado pelo servidor. Pode estar vazio para falhas no nível de captura.
2. **`tipo`**: Um `CafFailureType` valor enum que identifica exatamente por que o processo não teve êxito, como problemas de ambiente, timeout, nenhuma face detectada 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 tratar o `tipo` da falha, consulte Tratamento de falhas.
{% endhint %}

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

Disparado quando um bloqueador técnico impede que o SDK inicie ou conclua o processo, como permissões de câmera negadas, ausência de conexão com a internet ou falhas na inicialização do hardware.

| CafLivenessErrorType      | Causa típica                                                          |
| ------------------------- | --------------------------------------------------------------------- |
| `CONFIGURATION_EXCEPTION` | **`mobileToken`** ou **`personId`** não fornecido.                    |
| `TOKEN_EXCEPTION`         | Inválido **`mobileToken`** detectado.                                 |
| `CAMERA_PERMISSION`       | Permissão da câmera (ou relacionada) negada.                          |
| `NETWORK_EXCEPTION`       | Problemas de conectividade são tratados como erros da classe de rede. |
| `SERVER_EXCEPTION`        | Problemas no lado do 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 o plano de fundo.

#### **`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 interface.

### Liberação de recursos

Chame `release()` quando o SDK não for mais necessário ou antes de iniciar uma nova sessão com um diferente `CafLivenessConfig`:

{% tabs %}
{% tab title="Kotlin" %}

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

{% endtab %}

{% tab title="Java" %}

```java
CafFaceLivenessLite.Companion.getInstance().release();
```

{% endtab %}
{% endtabs %}

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" %}
[Tratando 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 UI](/caf-sdk/caf-sdk-pt-br/android/standalone-modules/caffacelivenesslite/personalizacao-da-ui.md)
{% endcontent-ref %}

{% content-ref url="/pages/fe433841f24be5e1ede569091ecfd49f66b5007b" %}
[Registro de alterações](/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.