> 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/comecando-com-o-sdk.md). # Começando com o SDK ## Conheça o CafSDK Essa documentação técnica aborda a **implementação do CafSDK para Android**, com detalhes sobre a configuração, inicialização, execução dos fluxos de captura e personalizações avançadas. Atualmente, o CafSDK integra 2 módulos principais: **Face Liveness (FL)** e **Document Detector (DD)**, executados de forma sequencial com uma interface de configuração unificada. ## O que é Face Liveness É o módulo que valida a autenticidade de um rosto capturado por aplicativo de foto, garantindo que a imagem corresponda a uma pessoa real. ### Características técnicas: * Configuração de URLs para autenticação (`authBaseUrl`) e verificação de prova de vida (liveness) (`livenessBaseUrl`). * Flags para habilitar captura de tela (screen capture) e modo de depuração (debug mode). * Suporte a múltiplos provedores de autenticação. ## O que é Document Detector É o módulo que permite a captura e o processamento de documentos (Ex.: RG, CPF, Passaporte, etc.). ### Características técnicas: * Configuração de um fluxo de etapas (flow) definidas por `DocumentDetectorStep` para a captura do documento. * Parâmetros operacionais, como timeout, flags de captura manual, entre outras configurações. * Possibilidade de uso da câmera para validações de enquadramento, ou upload de arquivo do documento. *** ## Comece a usar o SDK ### Adicione a dependência Para que seu projeto Android utilize o CafSDK, é preciso configurar corretamente os repositórios Maven e declarar as dependências do SDK no seu projeto. Essa etapa garante que os artefatos (bibliotecas) sejam baixados e integrados durante o build. ### Requisitos para adicionar #### Para Face Liveness Os requisitos mínimos para o módulo **Caf Face Liveness**, incluem: | Requisito | Versão | | --------------------------------------------------- | ------ | | Android SDK API - versão mínima (minSdk) | 26 | | Android SDK API - versão para compilar (compileSDK) | 34 | | Kotlin | 1.9.10 | | Gradle | 8.4 | | Plugin do Android Gradle (AGP) | 8.3.2 | {% hint style="warning" %} `nome da versão` e `código da versão` são obrigatórios para o funcionamento correto do SDK. {% endhint %} #### Para Document Detector Os requisitos mínimos para o módulo **Caf** **Detector de Documentos**, incluem: | Requisito | Versão | | --------------------------------------------------- | ------ | | Android SDK API - versão mínima (minSdk) | 26 | | Android SDK API - versão para compilar (compileSDK) | 34 | | Kotlin | 1.9.10 | | Gradle | 8.4 | | Plugin do Android Gradle (AGP) | 8.3.2 | ### Passo a passo para adicionar #### Passo 1 - Adicionar o repositório Maven Nessa etapa, é preciso informar ao Gradle onde localizar os artefatos do CafSDK e de dependências adicionais que podem ser utilizadas (como os relacionados ao Caf Face Liveness ou ao FingerPrintJS). Para isso, configure o arquivo `settings.gradle.kts` do projeto (geralmente localizado no nível raiz), incluindo os seguintes repositórios: * **Repositório Caf:** onde estão hospedados os artefatos do CafSDK. * **Repositório iProov:** necessário se você estiver utilizando o módulo CafFaceLiveness, que depende dos artefatos da iProov para um processamento seguro. * **Repositório do FingerPrintJS:** dependência interna dos módulos. * **JitPack:** para dependências hospedadas via JitPack (Github). **Exemplo de configuração:** ```kotlin repositories { // Repositório Caf – artefatos oficiais do CafSDK maven { url = uri("https://repo.combateafraude.com/android/release") } // Repositório iProov – utilizado no caso do uso do CafFaceLiveness maven { url = uri("https://raw.githubusercontent.com/iProov/android/master/maven/") } // Repositório do FingerPrintJS maven { setUrl("https://maven.fpregistry.io/releases") } // JitPack – para dependências adicionais que estejam hospedadas via JitPack maven { setUrl("https://jitpack.io") } } ``` #### Mais detalhes * **Flexibilidade:** essa configuração permite que o projeto baixe todas as dependências necessárias de diferentes fontes, garantindo compatibilidade e versões atualizadas. * **Manutenção:** caso haja atualizações nos repositórios ou mudanças na estrutura de publicação, basta atualizar essa seção para refletir as novas URLs. * **Contexto:** a inclusão dos repositórios é feita uma única vez no nível do projeto, garantindo que todos os módulos possam acessar os artefatos necessários. #### Passo 2 - Incluir a dependência no CafSDK Após configurar os repositórios, é necessário declarar as dependências específicas do CafSDK no arquivo `build.gradle.kts` do módulo da sua aplicação. Essa etapa declara quais módulos do SDK serão utilizados, permitindo que o Gradle gerencie as versões e resolva as dependências corretamente. **Exemplo de declaração de dependências:** ```kotlin dependencies { // Declaração do Caf BoM (Bill of Materials) para gerenciar as versões de forma centralizada. implementation("io.caf.sdk:caf-sdk-bom:1.3.0") // Declaração dos módulos que serão utilizados na aplicação. // Se você utiliza Protobuf Java: implementation("io.caf.sdk:caffaceliveness-lite") // ou use "io.caf.sdk:caffaceliveness-ui-lite" se desejar com a interface customizada. // Se você utiliza Protobuf JavaLite, adicione a dependência correspondente: // implementation("io.caf.sdk:caffaceliveness-core") // ou "io.caf.sdk:caffaceliveness-ui-core" se desejar com a interface customizada. // Dependência do módulo Document Detector: implementation("io.caf.sdk:document-detector") // versão com interface customizada ainda não disponível } ``` ### Pontos importantes **Caf BoM (Lista de Materiais)**\ Utilizar o BoM ajuda a centralizar a gestão das versões de todos os módulos do CafSDK. Assim, todas as dependências relacionadas ao SDK usarão a mesma versão definida, evitando conflitos e facilitando atualizações. **Módulos de Captura** **Caf Face Liveness:** escolha a dependência apropriada, de acordo com o tipo de Java que sua aplicação usa (Protobuf Java ou JavaLite). * A versão "Lite" é otimizada para desempenho e tamanho. Também usa internamente a versão do Protobuf o JavaLite. * A versão "Core" pode oferecer funcionalidades adicionais ou compatibilidade com outros recursos, pois utiliza o Protobuf Java (versão completa). * Também é possível escolher entre a versão padrão ou a versão que contém as interfaces gráficas da Caf (indicada pelo sufixo `-ui`), conforme a necessidade de personalização da experiência do usuário. **Caf Document Detector:** até o momento, apenas o SDK sem interface gráfica está disponível. Teremos novidades em breve. **Verificação de versão**\ Sempre confira a versão mais recente do CafSDK na página de [notas de versão *alterar link*](https://docs.caf.io/caf-sdk/android/cafsdk) para garantir que está utilizando as versões mais atualizadas e compatíveis. Essa configuração assegura que seu projeto esteja preparado para integrar o CafSDK, garantindo que todos os artefatos necessários sejam localizados e incorporados durante o build. Caso ocorra alguma alteração nos repositórios ou novas dependências sejam introduzidas, atualize as configurações. *** ## Como inicializar o SDK ### Permissões Para que os módulos operem corretamente, algumas permissões precisam ser declaradas no arquivo **AndroidManifest.xml**,confira: **Para Face Liveness** | Permissão | Descrição | Necessidade | | ----------------------------- | -------------------------------------------------------------------------------- | ----------- | | `android.permission.CAMERA` | Permite acesso à câmera para capturar imagens e verificação de face (liveness). | Obrigatório | | `android.permission.INTERNET` | Permite a comunicação com os serviços de autenticação e verificação (HTTPS/WSS). | Obrigatório | **Para Document Detector** | Permissão | Descrição | Necessidade | | ------------------------------------------ | -------------------------------------------------------------------------------------------- | -------------------- | | `android.permission.CAMERA` | Permite o acesso à câmera para capturar imagens dos documentos. | Somente para captura | | `android.permission.INTERNET` | Permite que imagens capturadas sejam enviadas aos servidores para processamento e validação. | Obrigatório | | `android.permission.READ_EXTERNAL_STORAGE` | Permite acesso a arquivos e imagens armazenadas para processamento, se necessário. | Somente para upload | ### Configurações É preciso configurar o SDK para que ele entenda qual o fluxo de execução e os parâmetros específicos de cada módulo. O processo de inicialização é dividido em 2 partes: a configuração global e a configuração específica dos módulos. **Configuração global** Nesta etapa, você cria um objeto do tipo `CafSdkConfiguration`, que serve como contêiner central para todas as configurações do fluxo de captura. 1. **Ordem de apresentação dos módulos (presentationOrder):** * Defina a sequência na qual os módulos serão executados. Essa ordem é crucial para garantir que o fluxo de captura siga a lógica de negócio definida pelo seu projeto. * Por exemplo, se o fluxo exige que o documento seja capturado antes da verificação de liveness, a ordem deve colocar o módulo **Detector de Documentos** antes do **Face Liveness**. * Importante: dependendo da implementação, podem acontecer variações de nomes, como `CafModuleType.FACE_LIVENESS` ou `CafModuleType.FACE_LIVENESS_UI`, que indicam se uma versão sem interface ou uma versão com interface será utilizada. **Exemplo de código para criação da configuração global:** ```kotlin val sdkConfiguration = CafSdkConfiguration( presentationOrder = listOf( CafModuleType.FACE_LIVENESS, // ou CafModuleType.FACE_LIVENESS_UI dependendo do que for desejado CafModuleType.DOCUMENT_DETECTOR, ) ) ``` #### Configuração específica de módulos Após definir as configurações globais, é preciso configurar os módulos individualmente. Essa configuração específica permite ajustar parâmetros operacionais específicos, garantindo que eles se comportem conforme os requisitos do seu fluxo de captura. #### Configuração Document Detector O módulo **Detector de Documentos** é responsável por capturar e processar documentos. Sua configuração envolve diversos parâmetros. **Parâmetro obrigatório:** * **Fluxo de captura (flow):** * Define uma lista de etapas ([`DocumentDetectorStep _alterar link_`](https://docs.caf.io/caf-sdk/android/cafsdk)) que especifica qual documento será capturado. * Esse fluxo pode ser customizado conforme os tipos de documentos a serem validados pela aplicação. * **Parâmetros operacionais:** * `useAdb`, `useDebug` e `useDeveloperMode` são flags que ativam modos específicos para testes e desenvolvimento, permitindo maior flexibilidade durante a fase de integração. * `manualCaptureEnabled` e `manualCaptureTime` controlam se a captura manual é permitida e, em caso afirmativo, definem o tempo limite (em segundos) para que a pessoa usuária realize a ação manualmente. * `requestTimeout` define o tempo máximo (em segundos) que o sistema aguardará por uma resposta do servidor. * `showPopup` determina se um pop-up de confirmação ou instrução será exibido para a pessoa usuária após a captura do documento. **Exemplo de código para configuração do Document Detector:** ```kotlin sdkConfiguration.setDocumentDetectorConfig( CafDocumentDetectorConfig( flow = listOf(DocumentDetectorStep(Document.RG_FRONT), DocumentDetectorStep(Document.RG_BACK)), useAdb = true, useDebug = true, useDeveloperMode = true, manualCaptureEnabled = true, manualCaptureTime = 45, requestTimeout = 60, showPopup = true ) ) ``` **Configuração Face Liveness** A configuração do módulo **Face Liveness** é essencial para garantir a segurança e a confiabilidade do processo de verificação facial, já que ele tem a função de validar se a face capturada pertence a uma pessoa real. Os principais parâmetros são: * **Loading (Tela de carregamento):** * A flag `loading` define se uma tela de carregamento deve ser exibida enquanto o módulo realiza o processamento. Isso melhora a experiência da pessoa usuária, ao informar que o processo está em andamento. * **URLs de serviço:** * `authBaseUrl` e `livenessBaseUrl` são os endpoints para os serviços de autenticação e verificação de liveness, respectivamente. * Esses valores devem ser configurados com URLs válidas, onde o `authBaseUrl` geralmente utiliza o protocolo HTTPS para segurança, e o `livenessBaseUrl` utiliza WSS (WebSocket seguro). * **Certificados:** * Ao atribuir valores nas urls de serviço, também é necessário informar a lista `certificates`, com certificados digitais que garante comunicações seguras e com servidores confiáveis. * **Opções adicionais:** * `screenCaptureEnabled` ativa ou desativa a capacidade de capturar a tela durante o processo de verificação. * `debugModeEnabled` permite que logs e informações adicionais sejam disponibilizados durante a execução, facilitando a depuração. **Exemplo de código para configuração do Face Liveness:** ```kotlin sdkConfiguration.setFaceLivenessConfig( CafFaceLivenessConfig( loading = true, // Exibe tela de carregamento durante o processamento authBaseUrl = "https://seu-auth-base-url.com", // Endpoint para autenticação livenessBaseUrl = "wss://seu-liveness-base-url.com", // Endpoint para verificação de liveness certificates = listOf("certificado1", "certificado2"), screenCaptureEnabled = true, // Permite captura de tela se necessário debugModeEnabled = true // Habilita modo debug para logs detalhados ) ) ``` Essas configurações iniciais são fundamentais para garantir que o SDK opere conforme o esperado. Cada parâmetro foi pensado para oferecer flexibilidade e segurança, permitindo que o fluxo de captura seja adaptado às necessidades específicas da sua aplicação. Ao finalizar essas configurações, o SDK estará pronto para ser inicializado e executado, garantindo uma integração robusta e eficiente com os módulos. *** ## Inicialização do Builder A inicialização do Builder é a etapa onde o fluxo de captura do CafSDK é configurado para a execução. Utilizando a classe `CafSdkProvider.Builder`, você configura os parâmetros essenciais que definem o comportamento do fluxo e prepara o SDK para ser iniciado. ### Parâmetros essenciais * **mobileToken:** token que autentica a requisição e garante que apenas clientes autorizados iniciem o fluxo. * **personId:** identificador único de usuário para o qual o fluxo será executado. * **environment:** define o ambiente de execução, por exemplo, `CafEnvironment.PROD` para produção. Isso possibilita a alternância entre ambientes de desenvolvimento, homologação e produção. * **configuration:** o objeto `CafSdkConfiguration` previamente configurado, contém tanto a ordem de execução dos módulos quanto as configurações específicas. * **callback:** um callback unificado, onde todos os eventos gerados pelos módulos (como carregamento, sucesso, erro e cancelamento) são tratados de forma centralizada. **Exemplo detalhado de código:** ```kotlin val sdkBuilder = CafSdkProvider.Builder( mobileToken = "seu-mobile-token", // Token de autenticação personId = "seu-person-id", // Identificador do usuário environment = CafEnvironment.PROD, // Ambiente de produção configuration = sdkConfiguration, // Configuração global com ordem e parâmetros dos módulos callback = ::callbackEvent ).build() ``` ### Callback unificado O callback unificado é um dos pilares do CafSDK, responsável por notificar a aplicação sobre o estado de cada etapa do fluxo de captura. Ele centraliza os eventos disparados pelos módulos e permite que o desenvolvedor implemente lógicas de resposta, registros de log e tratamento de erros. #### Tipos de eventos no Callback: * **Log:** captura mensagens de log com diferentes níveis (DEBUG, USAGE, INFO). Essas mensagens ajudam a identificar o comportamento interno do fluxo. * **Carregando:** indica o início do processamento de um módulo. Útil para exibir indicadores visuais de progresso. * **Carregado:** confirma que determinada ação foi realizada. Útil para ocultar identificadores visuais de progresso. * **Sucesso:** ao finalizar com êxito, cada módulo dispara um evento contendo um objeto [`CafUnifiedResponse _alterar link_`](https://docs.caf.io/caf-sdk/android/cafsdk). * **Erro:** caso ocorra um problema durante a execução, esse evento é disparado com a mensagem de erro, permitindo que a aplicação trate a falha. * **Cancelado:** indica que o usuário ou o sistema interrompeu o fluxo, possibilitando ações de recuperação ou notificações. **Exemplos de códigos:** ```kotlin private fun callbackEvent(event: CafUnifiedEvent): Unit = when(event) { is CafUnifiedEvent.Log -> { // Logs informativos, úteis para depuração e monitoramento log("[LOG] ${event.level}: ${event.message}") } is CafUnifiedEvent.Loading -> { // Indica alguma execução foi iniciada internamente (pode exibir uma tela de carregamento) log("[LOADING] Iniciando módulo...") } is CafUnifiedEvent.Loaded -> { // Indica execução interna foi concluída (pode ocultar uma tela de carregamento) log("[LOADED] Módulo carregado.") } is CafUnifiedEvent.Success -> { // Quando o módulo é concluído com sucesso, o callback recebe o nome do módulo e os resultados log("[SUCCESS] Módulo: ${event.response.moduleName}") log("[SUCCESS] Resultado: ${event.response.result}") } is CafUnifiedEvent.Error -> { // Captura erros ocorridos durante a execução e permite implementar lógica de tratamento de falhas log("[ERRO] ${event.message}") } is CafUnifiedEvent.Cancelled -> { // Informa que a operação foi cancelada pelo usuário ou por alguma falha na execução log("[CANCELLED] Operação cancelada.") } } ``` ### Início do fluxo configurado Após a construção do objeto `sdkBuilder` com todas as configurações e o callback definidos, o fluxo de captura é iniciado chamando o método `start()`. Esse método recebe o contexto (é recomendado o contexto da aplicação), e dá início à execução sequencial dos módulos configurados. **Código para iniciar o fluxo:** ```kotlin sdkBuilder.start(this) ``` #### Detalhes do processo * **Contexto:** o parâmetro passado para `start()` deve ser um contexto válido (por exemplo, a instância atual da `aplicação`), permitindo que o SDK exiba as telas de captura e gerencie as transições de UI. * **Execução sequencial:** o SDK inicia os módulos na ordem definida em `presentationOrder`. Cada módulo é executado sequencialmente e, ao concluir, aciona o próximo, garantindo que o fluxo siga a lógica estabelecida. * **Integração com o Callback:** durante a execução, o SDK utiliza o callback unificado para enviar os eventos correspondentes (loading, loaded, success, etc.), permitindo que a aplicação reaja em tempo real conforme o estado do fluxo. ## Concluir uma sessão A finalização ou conclusão de uma sessão no CafSDK ocorre quando todos os módulos configurados foram executados, ou quando ocorre um erro/cancelamento no fluxo. **Definição de sessão completa** * **Execução completa:** a sessão é considerada concluída quando cada módulo no fluxo de captura dispara um evento `Sucesso`, indicando que todas as operações foram realizadas com êxito. * **Interrupção do fluxo:** se ocorrer um erro ou se a pessoa usuária cancelar o processo em algum ponto, a sessão é interrompida e o evento `Error` ou `Cancelado` é disparado, permitindo que a aplicação tome as medidas necessárias. **Eventos de Finalização** * **Sucesso:**\ Cada módulo que termina com sucesso envia um evento do tipo `CafUnifiedEvent.Success`, que inclui: * `moduleName:` identifica o módulo que completou a operação (Ex.: `"documentDetector"` ou `"faceLiveness"`). * `result:` um mapa (`Map`) contendo os dados do resultado obtido pela execução do módulo. Esses dados podem incluir informações relevantes para o processo, como imagens capturadas ou resultados da validação. * **Error/Cancelled:**\ Caso o fluxo seja interrompido por uma falha ou cancelamento: * **Erro:** um evento `CafUnifiedEvent.Error` é disparado com uma mensagem descritiva do problema, permitindo implementar lógicas de recuperação ou notificações aos usuários. * **Cancelado:** se o processo for cancelado (por exemplo, pela pessoa usuária), o evento `CafUnifiedEvent.Cancelled` é disparado, permitindo a limpeza de recursos ou a exibição de mensagens informativas. {% hint style="info" %} Essas etapas garantem que você tenha uma visão completa e técnica do processo de inicialização e finalização do fluxo do CafSDK, permitindo uma integração simplificada e a implementação de estratégias adequadas para o tratamento de cada etapa do fluxo de captura. {% endhint %} ## Exemplo de uma implementação ```kotlin private fun startCaf() { val sdkConfiguration = CafSdkConfiguration( presentationOrder = listOf(CafModuleType.FACE_LIVENESS, CafModuleType.DOCUMENT_DETECTOR) ).apply { setDocumentDetectorConfig( CafDocumentDetectorConfig( flow = listOf(DocumentDetectorStep(Document.RG_FRONT), DocumentDetectorStep(Document.RG_BACK)), useAdb = true, useDebug = true, useDeveloperMode = true, manualCaptureEnabled = true, manualCaptureTime = 45, requestTimeout = 60, showPopup = true ) ) setFaceLivenessConfig( CafFaceLivenessConfig( loading = true, debugModeEnabled = true ) ) } CafSdkProvider.Builder( mobileToken = MOBILE_TOKEN, personId = PERSON_ID, environment = CafEnvironment.PROD, configuration = sdkConfiguration, callback = ::callbackEvent ) .build() .start(requireContext().applicationContext) } private fun callbackEvent(event: CafUnifiedEvent): Unit = when (event) { is CafUnifiedEvent.Log -> { // Logs informativos, úteis para depuração e monitoramento log("[LOG] ${event.level}: ${event.message}") } is CafUnifiedEvent.Loading -> { // Indica que um módulo iniciou seu processo (pode exibir uma tela de carregamento) log("[LOADING] Iniciando módulo...") } is CafUnifiedEvent.Loaded -> { // Notifica que o módulo terminou de carregar e está pronto para execução log("[LOADED] Módulo carregado.") } is CafUnifiedEvent.Success -> { // Quando o módulo é concluído com sucesso, o callback recebe o nome do módulo e os resultados log("[SUCCESS] Módulo: ${event.response.moduleName}") log("[SUCCESS] Resultado: ${event.response.result}") } is CafUnifiedEvent.Error -> { // Captura erros ocorridos durante a execução e permite implementar lógica de tratamento de falhas log("[ERRO] ${event.message}") } is CafUnifiedEvent.Cancelled -> { // Informa que a operação foi cancelada pelo usuário ou por alguma falha na execução log("[CANCELLED] Operação cancelada.") } } ``` *** ## Personalização avançada de fluxo Saiba como personalizar e ajustar o fluxo de captura do CafSDK para atender requisitos específicos de negócio e experiência do usuário. **Ordem de execução** * A ordem em que os módulos serão executados é definida no campo `presentationOrder` do objeto `CafSdkConfiguration`. * Essa sequência é fundamental, pois impacta diretamente na lógica do fluxo. Por exemplo, se o processo exige que o documento seja capturado antes da verificação facial, a ordem deve refletir essa prioridade. **Exemplo de código:** ```kotlin val sdkConfiguration = CafSdkConfiguration( presentationOrder = listOf( CafModuleType.DOCUMENT_DETECTOR, CafModuleType.FACE_LIVENESS ), colorConfig = CafColorConfiguration( primaryColor = "#0000FF", secondaryColor = "#00FF00" ) ) ``` **Configuração específica** Para personalizar os módulos individualmente, utilize os métodos `setDocumentDetectorConfig` e `setFaceLivenessConfig`. Eles permitem ajustar parâmetros críticos, como: * **Tempo de captura:** define o tempo limite para que o usuário realize a captura manual. * **Tempo limite:** estabelece o limite máximo de espera para a resposta de um serviço. * **Flags de depuração:** habilitam ou desabilitam modos de depuração para facilitar a identificação de problemas durante o desenvolvimento. * **Layout e outros parâmetros:** permitem configurar elementos visuais e operacionais específicos de cada módulo. **Personalização visual** Com o objeto `CafColorConfiguration`, é possível alinhar a identidade visual do fluxo de captura com a marca da sua aplicação. Essa personalização garante que os elementos visuais (botões, fundos e indicadores) mantenham consistência com o design do aplicativo. **Logging e monitoramento** O callback unificado implementa diferentes níveis de log (DEBUG, USAGE, INFO), o que possibilita uma visão detalhada de cada etapa do fluxo. Esses logs são essenciais para integrar com ferramentas de monitoramento, ajustar o desempenho ou identificar problemas em tempo real. **Exemplo no Callback:** ```kotlin callback = { event -> when (event) { is CafUnifiedEvent.Log -> { // Níveis de log possibilitam um monitoramento granular do fluxo log("[LOG] ${event.level}: ${event.message}") } // Outros casos são tratados conforme mostrado em seções anteriores... } } ``` *** ## Configuração do Face Liveness A integração do módulo **Caf Face Liveness (FL)** é realizada por sua configuração no objeto `CafSdkConfiguration`. Assim que definido, o fluxo executa automaticamente o módulo na posição correspondente definida na ordem de apresentação. A configuração do Face Liveness é feita por meio do objeto `CafFaceLivenessConfig`, onde são informados os parâmetros que o SDK utilizará durante sua execução. Confira os principais métodos de configuração disponíveis: | Método | Tipo | Descrição | | ------------------------- | ----------------------- | ------------------------------------------------------------------------------------------------------------- | | `setLoading` | Boolean | Habilita ou desabilita a tela de carregamento. O padrão é `false`. | | `setAuthBaseUrl` | String | Define a URL do proxy reverso para autenticação. Deve utilizar o protocolo HTTPS. | | `setLivenessBaseUrl` | String | Define a URL do proxy reverso para a verificação de Face Liveness. Deve utilizar o protocolo WSS. | | `setCertificates` | List | Define os certificados codificados em Base64 (SHA-256) para o proxy reverso. | | `setScreenCaptureEnabled` | Boolean | Habilita ou desabilita a captura de tela. O padrão é `false`. | | `setDebugModeEnabled` | Boolean | Habilita ou desabilita a geração de logs para auxiliar na depuração durante a integração. O padrão é `false`. | | `setSdkType` | CafFaceLivenessPlatform | Informa qual plataforma está executando o SDK. O padrão é `CafFaceLivenessPlatform.NATIVE_ANDROID`. | **Exemplo de configuração para Face Liveness:** ```kotlin sdkConfiguration.setFaceLivenessConfig( CafFaceLivenessConfig( loading = true, authBaseUrl = "https://seu-auth-base-url.com", livenessBaseUrl = "wss://seu-liveness-base-url.com", certificates = listOf("certificado1", "certificado2"), screenCaptureEnabled = true, debugModeEnabled = true ) ) ``` ### Resultado Após a execução bem-sucedida do módulo, é disparado um evento do tipo `CafUnifiedEvent.Success`, que contém: * **moduleName:** o nome identificador do módulo (Ex.: `"faceLiveness"`). * **result:** um mapa (`Map`) com os dados da verificação. Então, esses dados são processados pelo callback unificado, permitindo a atualização da interface da pessoa usuária ou a continuidade do fluxo, conforme necessário. ## Configurações personalizadas - Face Liveness Use configurações personalizadas para direcionar as requisições através de proxies seguros e garantir que os protocolos corretos (WSS para Face Liveness e HTTPS para autenticação) sejam utilizados. ### Configuração de proxy reverso Essa configuração avançada permite que você direcione as conexões do módulo Face Liveness através de um proxy reverso, utilizando o protocolo WSS (Web Socket Secure). Siga as etapas para configurar corretamente: 1. **URL do Proxy:** defina seu proxy para se comunicar com o endpoint desejado. Por exemplo, você pode utilizar:`wss://us.rp.secure.iproov.me/ws` ou outro URL compatível. 2. **Configuração da URL do Face Liveness:** use o método `.setLivenessBaseUrl` para configurar a URL do Face Liveness. Lembre-se de que o protocolo deve ser **WSS**. 3. **Definição dos certificados:**t use o método `.setCertificates` para definir os certificados necessários. Esses certificados devem ser os hashes SHA256 codificados em Base64 dos certificados do proxy. #### Exemplo de código: ```kotlin sdkConfiguration.setFaceLivenessConfig( CafFaceLivenessConfig( livenessBaseUrl = "wss://my.proxy.io/ws/", certificates = listOf( "4d69f16113bed7d62ca56feb68d32a0fcb7293d3960=", "50f71c5dda30741ee4be1ac378e12539b0d1d511f99=", "9f85e26c1ae41f7ac97adc4099be7f2a40759510ab9=" ) ) ) ``` ### Proxy reverso para autenticação Para a comunicação de autenticação, é necessário configurar o proxy reverso com uma URL HTTPS. Essa configuração direciona as requisições de autenticação para o ambiente adequado. 1. **URL do Proxy:** defina o seu proxy para se comunicar. Por exemplo, você pode utilizar: `https://api.public.caf.io/` . 2. **Configuração da URL de autenticação:** use o método `.setAuthBaseUrl` para especificar a URL de autenticação, garantindo que o protocolo HTTPS seja utilizado. #### Exemplo de código: ```kotlin sdkConfiguration.setFaceLivenessConfig( CafFaceLivenessConfig( authBaseUrl = "https://my.proxy.io/v1/faces/" ) ) ``` > **Observação:** na prática, ambas as configurações (para autenticação e para Face Liveness) podem ser combinadas em uma única instância de `CafFaceLivenessConfig`. ## Estruturas de configuração Ao usar o módulo de UI (com sufixo `-ui`), você estará utilizando telas proprietárias da Caf, que têm algumas possibilidades de personalização. Confira os detalhes: ### CafFaceLivenessInstructionsScreen Essa estrutura permite personalizar a tela de instruções do Face Liveness. | Propriedade | Tipo | Descrição | Valor padrão | | ------------ | --------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- | ------------ | | `imagem` | `String?` | Imagem exibida no cabeçalho da tela. O valor pode ser uma URL, o ID do resource (no formato string) ou o nome do resource presente na pasta drawable. | `null` | | `título` | `String?` | Título da tela (Ex.: "Instruções para Escanear o Rosto"). | `null` | | `descrição` | `String?` | Texto descritivo breve (ex.: "Siga os passos abaixo"). | `null` | | `steps` | `List?` | Lista ordenada de instruções (Ex.: listOf ("Mantenha o telefone estável"; "Boa iluminação"). | `null` | | `buttonText` | `String?` | Texto para o botão de confirmação (Ex.: "Iniciar escaneamento"). | `null` | ### CafColorConfiguration Essa estrutura permite personalizar as cores globais de todas as interfaces. As cores seguem o padrão `RGB` ou `ARGB`. | Propriedade | Tipo | Descrição | Formato | | ---------------- | -------- | --------------------------------------------------- | --------------------------- | | `primaryColor` | `String` | Cor principal para botões e destaques. | Código Hex (ex.: `#FF0000`) | | `secondaryColor` | `String` | Cor secundária para elementos complementares. | Código Hex | | `cor de fundo` | `String` | Cor de fundo da tela. | Código Hex | | `contentColor` | `String` | Cor utilizada para textos e ícones. | Código Hex | | `mediumColor` | `String` | Cor neutra para elementos como barras de progresso. | Código Hex | ## Exemplos de código Confira no exemplo como configurar o módulo Face Liveness com instruções, proxy reverso (para autenticação e verificação) e personalização da interface. ```kotlin val sdkConfiguration = CafSdkConfiguration( presentationOrder = listOf(...), colorConfig = CafColorConfiguration( primaryColor = "#FF0000", secondaryColor = "#00FF00", backgroundColor = "#FFFFFF", contentColor = "#000000", mediumColor = "#D1D1D1" ) ) sdkConfiguration.setFaceLivenessConfig( CafFaceLivenessConfig( loading = true, authBaseUrl = "https://seu-auth-base-url.com", livenessBaseUrl = "wss://seu-liveness-base-url.com", certificates = listOf("certificado1", "certificado2"), screenCaptureEnabled = true, debugModeEnabled = true ) ) sdkConfiguration.setCafFaceLivenessInstructionsScreen( CafFaceLivenessInstructionsScreen( image = R.drawable.scan_icon.toString() title = "Escaneie seu Rosto", description = "Siga os passos abaixo:", steps = listOf("Mantenha o telefone estável", "Garanta boa iluminação"), buttonText = "Iniciar Escaneamento", ) ) ``` *** ## Mais informações ### Requisitos de certificados * **Certificados:** devem ser os hashes SHA-256 codificados em Base64 do SPKI (Subject Public Key Info) do certificado. ### Aplicação dos protocolos * **Face Liveness:** a URL para Face Liveness **deve** **utilizar** o protocolo `wss://`. * **Autenticação:** a URL para autenticação **deve** **utilizar** o protocolo `https://`. *** ## Configuração do Detector de Documentos O módulo **Caf Detector de Documentos (DD)** é configurado de forma semelhante ao Face Liveness, mas com foco na captura e processamento de documentos. ### Configuração e execução Não `CafSdkConfiguration`, configure os parâmetros específicos do Document Detector, que determinam o comportamento da captura de documentos. #### Parâmetros principais: * `o fluxo`: uma lista de etapas (`DocumentDetectorStep`) que define qual documento e quais ângulos ou partes devem ser capturados. * `useAdb`, `useDebug` e `useDeveloperMode`: flags que auxiliam no desenvolvimento e na execução em ambientes de teste. * `manualCaptureEnabled` e `manualCaptureTime`: configuram se a captura manual é permitida e qual o tempo limite para a ação. * `requestTimeout`: tempo máximo para aguardar respostas de servidores ou ações de usuários. * `showPopup`: determina se uma mensagem de confirmação ou instrução será apresentada à pessoa usuária. **Exemplo de configuração para Document Detector:** ```kotlin sdkConfiguration.setDocumentDetectorConfig( CafDocumentDetectorConfig( flow = listOf(DocumentDetectorStep(Document.RG_FRONT)), useAdb = true, useDebug = true, useDeveloperMode = true, manualCaptureEnabled = true, manualCaptureTime = 45, requestTimeout = 60, showPopup = true ) ) ``` ### Resultado * Ao concluir a captura e o processamento do documento, o módulo Document Detector dispara um evento `CafUnifiedEvent.Success`. * Esse evento inclui o `moduleName` (Ex.: `"documentDetector"`) e um `resultado` contendo os dados capturados. * O callback unificado pode então usar essas informações para avançar para o próximo passo ou para armazenar os resultados conforme necessário. ## Configurações personalizadas - Detector de Documentos Para configurar o Caf Detector de Documentos, use a estrutura `CafDocumentDetectorConfig`, que inclui: * Etapas do fluxo de captura de documentos. * Personalização do layout da interface (UI). * Mensagens de feedback. * Comportamento do upload. * Configurações de proxy. ### Configuração principal Propriedades de `CafDocumentDetectorConfig`. | Propriedade | Tipo | Descrição | Padrão | | ---------------------------- | ------------------------ | -------------------------------------------------------------- | ---------------- | | `o fluxo` | `[DocumentDetectorStep]` | Lista ordenada das etapas de captura de documentos. | `[]` | | `o layout` | `DocumentDetectorLayout` | Personalização de UI (cores, botões, fontes). | Layout padrão | | `as configurações de upload` | `CafUploadSettings` | Controla o comportamento do upload de documento. | `enable: false` | | `manualCaptureEnabled` | `Bool` | Habilita o botão de captura manual. | `true` | | `manualCaptureTime` | `TimeInterval` | Tempo limite (segundos) para captura manual. | `45` | | `requestTimeout` | `TimeInterval` | Tempo limite da requisição HTTP. | `60` | | `showPopup` | `Bool` | Exibe/oculta o pop-up de instruções iniciais. | `true` | | `proxySettings` | `CafProxySettings?` | Configuração de proxy reverso (host, porta, autenticação). | `nil` | | `previewShow` | `Bool` | Habilita a tela de preview após a captura. | `false` | | `previewTitle` | `String?` | Texto do título na tela de preview. | `nil` | | `previewSubtitle` | `String?` | Texto do subtítulo na tela de preview. | `nil` | | `previewConfirmLabel` | `String?` | Texto para o botão de confirmação no preview. | `nil` | | `previewRetryLabel` | `String?` | Texto para o botão de nova tentativa no preview. | `nil` | | `messageSettings` | `CafMessageSettings` | Mensagens de feedback personalizáveis. | Mensagens padrão | | `enableMultiLanguage` | `Bool` | Habilita a tradução automática das mensagens padrão. | `true` | | `allowedPassportCountryList` | `[CafCountryCodes]?` | Lista de países de passaportes permitidos (Ex.: `.BR`, `.US`). | `nil` | ### Personalização de layout Propriedades de `DocumentDetectorLayout`. | Propriedade | Tipo | Descrição | Padrão | | ------------------------ | ------------------------ | ----------------------------------------------------------- | ------------------ | | `closeButtonImage` | `UIImage?` | Imagem para o botão fechar. | Padrão do sistema | | `closeButtonColor` | `UIColor?` | Cor para o botão fechar. | Cor primária | | `closeButtonSize` | `CGFloat?` | Tamanho (largura/altura) para o botão fechar. | `44` | | `closeButtonContentMode` | `UIView.ContentMode?` | Modo de conteúdo para a imagem do botão fechar. | `.scaleAspectFit` | | `uploadBackGroundColor` | `UIColor` | Cor de fundo durante o upload. | Cor primária | | `previewBackGroundColor` | `UIColor` | Cor de fundo na tela de preview. | `.white` | | `primaryColor` | `UIColor` | Cor para botões/indicadores de progresso. | `#34D690` (verde) | | `feedbackColors` | `DocumentFeedbackColors` | Cores para sobreposições de feedback (padrão/erro/sucesso). | Cores predefinidas | | `fonte` | `String?` | Nome da fonte personalizada (Ex.: "Avenir-Bold"). | Fonte do sistema | #### Exemplo de código: ```swift let layout = DocumentDetectorLayout() layout.closeButtonImage = UIImage(named: "close_icon") layout.primaryColor = .blue layout.font = "Helvetica-Bold" layout.feedbackColors = DocumentFeedbackColors( defaultColor: .gray, errorColor: .red, successColor: .green ) ``` ### Personalização de mensagens Propriedades de `CafMessageSettings`. | Propriedade | Descrição | Valor padrão | | --------------------------- | ------------------------------------------- | --------------------------------- | | `waitMessage` | Exibido durante a inicialização do SDK. | "Aguarde" (aguardando) | | `fitTheDocumentMessage` | Informa para alinhar o documento à máscara. | "Encaixe o documento na marcação" | | `verifyingQualityMessage` | Exibido durante a verificação de qualidade. | "Verificando qualidade…" | | `lowQualityDocumentMessage` | Exibido em caso de falha na captura. | "Ops, tente novamente" | | `sensorLuminosityMessage` | Aviso de baixa luminosidade. | "Ambiente muito escuro" | | `sensorOrientationMessage` | Aviso de orientação do dispositivo. | "Celular não está na horizontal" | | `aiScanDocumentMessage` | Mensagem para escanear um documento. | "Escaneie um documento" | | `aiGetCloserMessage` | Mensagem para se aproximar. | "Se aproxime do documento" | | `aiCapturedMessage` | Confirmação de captura bem-sucedida. | "Capturando o documento" | **Lista completa**: mais de 20 mensagens. Use `.set[MessageName](message: String)` para personalizar qualquer texto. #### Exemplo de código: ```swift let messages = CafMessageSettings() .setWaitMessage(message: "Aguarde...") .setLowQualityDocumentMessage(message: "Qualidade ruim. Tente novamente.") ``` ## Fluxo de captura de documento Propriedades de `DocumentDetectorStep`. | Propriedade | Tipo | Descrição | Obrigatório | | --------------- | ------------- | ------------------------------------------------- | ------------ | | `document` | `CafDocument` | Tipo de documento para captura (Ex.: `.RG_FRONT`) | Sim | | `stepLabel` | `String?` | Texto exibido na parte inferior da tela. | Não | | `illustration` | `UIImage?` | Imagem exibida no pop-up de instrução. | Não | | `showStepLabel` | `Bool` | Alterna a visibilidade do rótulo da etapa. | Não (`true`) | #### Exemplo de código: ```swift let step = DocumentDetectorStep( document: .RG_FRONT, stepLabel: "Frente do documento de identidade", illustration: UIImage(named: "id_front_icon") ) ``` ## Configurações de upload Propriedades de `CafUploadSettings`. | Propriedade | Tipo | Descrição | Padrão | | ----------------- | -------------- | ----------------------------------------------------- | ----------------- | | `ativar` | `Bool` | Ativa a funcionalidade de carregamento de documentos. | `false` | | `comprimir` | `Bool` | Comprime os arquivos antes do upload. | `true` | | `fileFormats` | `[FileFormat]` | Formatos permitidos: `.png`, `.jpeg`, `.pdf`. | Todos os formatos | | `maximumFileSize` | `Int` | Tamanho máximo do arquivo em KB. | `10000` (10MB) | #### Exemplo de código: ```swift let uploadSettings = CafUploadSettings( enable: true, fileFormats: [.jpeg, .pdf], maximumFileSize: 5000 ) ``` ## Configurações de Proxy Propriedades de `CafProxySettings`. | Propriedade | Tipo | Descrição | Obrigatório | | ----------- | --------- | --------------------------------- | ----------- | | `hostname` | `String` | Host do proxy (Ex.: "proxy.com"). | Sim | | `port` | `Int` | Porta do proxy (Ex.: `8080`). | Sim | | `user` | `String?` | Nome de usuário de autenticação. | Não | | `password` | `String?` | Senha de autenticação. | Não | #### Exemplo de código: ```swift let proxy = CafProxySettings(hostname: "my.proxy.io", port: 443) .setAutentication(user: "admin", password: "secret") ``` ## Documentos suportados no Detector de Documentos Use esses valores estáticos de `CafDocument`: | Tipo de documento | Descrição | | ----------------- | ------------------------------------------------ | | `.RG_FRONT` | Frente do RG brasileiro | | `.RG_BACK` | Verso do RG brasileiro | | `.RG_FULL` | RG brasileiro (aberto, mostrando frente e verso) | | `.CNH_FRONT` | Frente da CNH brasileira | | `.CNH_BACK` | Verso da CNH brasileira | | `.CNH_FULL` | CNH brasileira (aberta) | | `.CRLV` | CRLV brasileiro | | `.RNE_FRONT` | Frente do RNE brasileiro | | `.RNE_BACK` | Verso do RNE brasileiro | | `.CTPS_FRONT` | Frente da CTPS brasileira | | `.CTPS_BACK` | Verso da CTPS brasileira | | `.PASSPORT` | Passaporte (qualquer país) | | `.ANY` | Documento genérico (sem validação específica) | #### Exemplo de código: ```swift let layout = DocumentDetectorLayout() layout.primaryColor = .blue layout.closeButtonImage = UIImage(named: "close") let config = CafDocumentDetectorConfig( flow: [ DocumentDetectorStep(document: .RG_FRONT), DocumentDetectorStep(document: .RG_BACK) ], layout: layout, uploadSettings: CafUploadSettings(enable: true), proxySettings: CafProxySettings(hostname: "proxy.example.com", port: 8443), messageSettings: CafMessageSettings() .setWaitMessage(message: "Inicializando...") .setLowQualityDocumentMessage(message: "Tente capturar novamente") ) ``` *** ## Recursos adicionais ### Regras do ProGuard/R8 Confira o bloco de código com as regras ProGuard/R8 necessárias para que o CafSDK e suas dependências funcionem corretamente mesmo após a ofuscação e otimização do código. Essas regras preservam informações essenciais (como assinaturas, anotações e classes internas) e evitam que classes críticas sejam removidas ou alteradas. ```proguard # O pré-handler do Android para exceções é carregado por reflexão (via ServiceLoader). -keep class kotlinx.coroutines.experimental.android.AndroidExceptionPreHandler { *; } ### GSON ################################################################## # O Gson usa informações de tipos genéricos armazenadas em um arquivo de classe ao trabalhar com campos. # O ProGuard remove essas informações por padrão, então configure-o para manter todas elas. -keepattributes Signature # Para usar a anotação @Expose do GSON -keepattributes *Annotation* ### END GSON ################################################################## ### Retrofit ################################################################## # Preservar assinaturas genéricas, classes internas e métodos envolventes para reflexão do Retrofit. -keepattributes Signature, InnerClasses, EnclosingMethod # Reter anotações visíveis em tempo de execução em métodos e parâmetros. -keepattributes RuntimeVisibleAnnotations, RuntimeVisibleParameterAnnotations # Manter os valores padrão das anotações. -keepattributes AnnotationDefault # Reter os parâmetros dos métodos de serviço para interfaces com anotações do Retrofit. -keepclassmembers,allowshrinking,allowobfuscation interface * { @retrofit2.http.* ; } # Suprimir avisos para ferramentas de build e certas anotações JSR 305. -dontwarn org.codehaus.mojo.animal_sniffer.IgnoreJRERequirement -dontwarn javax.annotation.** -dontwarn kotlin.Unit -dontwarn retrofit2.KotlinExtensions -dontwarn retrofit2.KotlinExtensions$* # Manter explicitamente as interfaces do Retrofit para evitar sua anulação pelo R8. -if interface * { @retrofit2.http.* ; } -keep,allowobfuscation interface <1> -if interface * { @retrofit2.http.* ; } -keep,allowobfuscation interface * extends <1> # Preservar continuations usadas por funções suspend do Kotlin. -keep,allowobfuscation,allowshrinking class kotlin.coroutines.Continuation # Para o modo completo do R8: manter tipos de retorno genéricos para métodos do Retrofit. -if interface * { @retrofit2.http.* public *** *(...); } -keep,allowoptimization,allowshrinking,allowobfuscation class <3> # Preservar a classe Response do Retrofit. -keep,allowobfuscation,allowshrinking class retrofit2.Response ### END Retrofit ############################################################## ### OkHttp #################################################################### # Suprimir avisos para anotações JSR 305. -dontwarn javax.annotation.** # Adaptar nomes de arquivos de recursos para o banco de dados interno de sufixos públicos. -adaptresourcefilenames okhttp3/internal/publicsuffix/PublicSuffixDatabase.gz # Suprimir avisos para Animal Sniffer e classes específicas de plataforma. -dontwarn org.codehaus.mojo.animal_sniffer.* -dontwarn okhttp3.internal.platform.** -dontwarn org.conscrypt.** -dontwarn org.bouncycastle.** -dontwarn org.openjsse.** # Manter todas as classes do OkHttp e do Okio. -keep class okhttp3.** { *; } -dontwarn okhttp3.** -keep class okio.** { *; } -dontwarn okio.** -dontwarn javax.annotation.Nullable -dontwarn javax.annotation.ParametersAreNonnullByDefault ### END OkHttp ################################################################ ### Kotlin Serialization ###################################################### # Manter objetos Companion para classes serializáveis. -if @kotlinx.serialization.Serializable class ** -keepclassmembers class <1> { static <1>$Companion Companion; } # Manter as funções de serializer nos objetos companion. -if @kotlinx.serialization.Serializable class ** { static **$* *; } -keepclassmembers class <2>$<3> { kotlinx.serialization.KSerializer serializer(...); } # Reter INSTANCE e serializer para objetos serializáveis. -if @kotlinx.serialization.Serializable class ** { public static ** INSTANCE; } -keepclassmembers class <1> { public static <1> INSTANCE; kotlinx.serialization.KSerializer serializer(...); } # Preservar objetos Companion em kotlinx.serialization.json. -keepclassmembers class kotlinx.serialization.json.** { *** Companion; } -keepclasseswithmembers class kotlinx.serialization.json.** { kotlinx.serialization.KSerializer serializer(...); } # Preservar a busca do serializer para classes serializáveis (ajuste o nome do pacote conforme necessário). -keepclassmembers @kotlinx.serialization.Serializable class packeage.** { *** Companion; *** INSTANCE; kotlinx.serialization.KSerializer serializer(...); } ### FIM Kotlin Serialization ################################################# ### AutoValue ################################################################ -dontwarn com.google.auto.** -dontwarn autovalue.shaded.com.** -dontwarn sun.misc.Unsafe -dontwarn javax.lang.model.element.Modifier ### FIM AutoValue ############################################################ ### CAF - Combate a Fraude ###################################################### # Manter atributos de exceções. -keepattributes Exceptions # Preservar todas as classes, interfaces e membros de classe para os módulos CAF. -keep class com.caf.facelivenessiproov.** { *; } -keep class com.combateafraude.documentdetector.** { *; } -keep class com.combateafraude.** { *; } -keep interface com.combateafraude.** { *; } -keepclassmembers class com.combateafraude.** { *; } # Suprimir avisos para java.nio.file e certas classes internas do OkHttp. -dontwarn java.nio.file.* -dontwarn com.squareup.okhttp.internal.Platform # Manter campos em classes que estendem GeneratedMessageLite (para uso do Tink). -keepclassmembers class * extends com.google.crypto.tink.shaded.protobuf.GeneratedMessageLite { ; } # Preservar classes do TensorFlow. -keep class org.tensorflow.** { *; } -keep class org.tensorflow.**$* { *; } -dontwarn org.tensorflow.** # Preservar classes do IProov e classes Protobuf. -keep public class com.iproov.sdk.IProov { public *; } -keep class com.iproov.** { *; } -keep class com.iproov.**$* { *; } -keep class com.google.protobuf.** { *; } -keep class com.google.protobuf.**$* { *; } -dontwarn com.google.protobuf.** # Suprimir avisos para classes Flow concorrentes. -dontwarn java.util.concurrent.Flow* # Preservar classes do Kotlin e kotlinx. -keep class kotlin.** { *; } -keep class kotlinx.** { *; } ### FIM CAF - Combate a Fraude ################################################## ``` *** ## Suporte técnico e Dicas de uso **Suporte técnico**\ Em caso de dúvidas ou dificuldades na integração, entre em contato com o suporte técnico da Caf. **Dicas de uso** * **Realize testes:** execute testes em dispositivos reais para validar os requisitos e o desempenho do fluxo. * **Explore customizações:** utilize as opções de customização avançada para adaptar o fluxo às necessidades do seu projeto. * **Monitore o desempenho:** integre ferramentas de monitoramento para acompanhar os logs e o desempenho do fluxo em produção. --- # 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/comecando-com-o-sdk.md?ask=&goal= ``` `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.