> 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/ios/standalone-modules/deprecated-sdks/document-detector-deprecated.md).

# DocumentDetector v7 ou inferior (Obsoleto)

## **Documentos suportados**

Atualmente, os documentos suportados no iOS são:

```swift
Document.RG_FRONT, // frente do RG, onde fica a foto
Document.RG_BACK, // verso do RG, onde ficam os dados
Document.RG_FULL, // RG aberto, mostrando a frente e o verso
Document.CNH_FRONT, // frente da CNH, onde fica a foto
Document.CNH_BACK, // verso da CNH, onde fica a assinatura
Document.CNH_FULL, // CNH aberta, mostrando a frente e o verso
Document.CRLV, // CRLV
Document.RNE_FRONT, // frente do RNE e do RNM, a parte com os dados
Document.RNE_BACK, // verso do RNE e do RNM, a parte com a foto
Document.PASSPORT, // Passaporte
Document.CTPS_FRONT, // frente da CTPS
Document.CTPS_BACK, // verso da CTPS
Document.OTHERS, // outros documentos de identificação em geral, como RNE, carteira militar, OAB e CRLV
Document.ANY; // permite enviar qualquer captura
```

## **Permissões obrigatórias**

No **`info.plist`** arquivo, adicione as permissões abaixo:

| **Permissão**                                               | **Motivo**                              | **Obrigatório?**                                       |
| ----------------------------------------------------------- | --------------------------------------- | ------------------------------------------------------ |
| **`Privacidade - Descrição de Uso da Câmera`**              | Para capturar a(s) foto(s) do documento | Não, apenas necessário no fluxo de captura pela câmera |
| **`Privacidade - Descrição de Uso da Biblioteca de Fotos`** | Para realizar a abertura da galeria.    | Não, necessário apenas no fluxo de upload              |

NSPhotoLibraryUsageDescription

## **Utilização**

Primeiro, instancie um objeto do tipo **`DocumentDetectorSdk`**:

```swift
let documentDetector = DocumentDetectorSdk.Builder(mobileToken: "mobileToken") // enableMultiLanguage true por padrão
    // veja a tabela abaixo
    .build()
```

### **DocumentDetectorSdk.Builder**

| **Parâmetro**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | **Obrigatório?**                                                                                                |
| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- |
| <p><strong><code>String mobileToken</code></strong></p><p>Token de uso associado à sua conta CAF</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | Sim                                                                                                             |
| <p><strong><code>.setDocumentDetectorFlow(flow :\[DocumentDetectorStep])</code></strong></p><p>Define o fluxo de captura de documentos, conforme explicado <a href="https://github.com/combateafraude/public-docs/blob/docs-sdks/ios/deprecated-sdks/v8-or-below.md#documentdetectorstep">aqui</a></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | Sim                                                                                                             |
| <p><strong><code>.setPeopleId(peopleId: String?)</code></strong></p><p>Identificador do usuário com a finalidade de identificar um perfil fraudulento</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | Não, é usado apenas para [analytics](https://github.com/combateafraude/public-docs/blob/docs-sdks/analytics.md) |
| <p><strong><code>.setAnalyticsSettings(useAnalytics: Bool)</code></strong></p><p>Habilita/desabilita a coleta de dados para <a href="https://github.com/combateafraude/public-docs/blob/docs-sdks/analytics.md">analytics</a></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | Não, o padrão é **`true`**                                                                                      |
| <p><strong><code>.setPopupSettings(show: Bool)</code></strong></p><p>Altera a configuração dos popups ampliados antes de cada documento</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | Não, o padrão é **`true`**                                                                                      |
| <p><strong><code>.setDetectionSettings(detectionThreshold : Float)</code></strong></p><p>Altera a configuração padrão de detecção de documento, o limiar de confiança do enquadramento (de 0.0 a 1.0, onde 1.0 indica que o SDK só aceitará o documento com um enquadramento perfeito)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | Não. O padrão é 0,91                                                                                            |
| <p><strong><code>.setQualitySettings(verifyQuality: Bool, qualityThreshold: Double?)</code></strong></p><p>Altera a configuração padrão para verificar a qualidade das capturas, indicando se você deseja realizar essa verificação (leva cerca de 2 segundos) e se pode ser definido o limiar de qualidade para essas fotos (valor de 1.0 a 5.0). Além disso, o SDK retornará a URL da imagem na variável <code>DocumentDetectorResult.Capture.ImageUrl</code>. <strong>Cuidado</strong>, se você decidir verificar a qualidade neste parâmetro e ocorrer uma falha de conexão durante o envio das imagens, o SDK será encerrado com um erro de internet.</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | Não. O padrão é true e 1.8, respectivamente                                                                     |
| <p><strong><code>.setLayout(layout: DocumentDetectorLayout)</code></strong></p><p>Altera as máscaras de documento de sucesso, falha e normal.</p><p>Também permite alterar o som e os botões de cancelar no topo da tela. Veja a <a href="https://github.com/combateafraude/public-docs/blob/docs-sdks/customization/README.md">exemplo</a>.</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Não                                                                                                             |
| <p><strong><code>.setColorTheme(color: UIColor)</code></strong></p><p>Altere a cor dos botões de som e cancelar que ficam no topo da tela. Também altere a cor dos botões do popup, exibidos antes de cada documento.</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | Não                                                                                                             |
| <p><strong><code>.enableSound(enableSound: Bool)</code></strong></p><p>Habilita/desabilita os sons e o ícone de som no SDK</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | Não, o padrão é **`true`**                                                                                      |
| <p><strong><code>.showStepLabel(show: Bool)</code></strong></p><p>Mostrar/ocultar o rótulo central inferior (que contém o nome do documento)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Não, o padrão é **`true`**                                                                                      |
| <p><strong><code>.showStatusLabel(show: Bool)</code></strong></p><p>Mostrar/ocultar o rótulo central (que contém o status)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | Não, o padrão é **`true`**                                                                                      |
| <p><strong><code>.setNetworkSettings(requestTimeout:TimeInterval)</code></strong></p><p>Altere as configurações padrão de rede</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | Não. O padrão é 60 (segundos)                                                                                   |
| <p><strong><code>.setLuminositySensorSettings(luminosityThreshold :Float?)</code></strong></p><p>Define o limiar entre luminosidade ambiente aceitável/inaceitável. O limiar deste sensor é um número que varia de negativo a positivo.</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | Não. A configuração padrão é -3.                                                                                |
| <p><strong><code>.setOrientationSensorSettings(orientationThreshold: Double?)</code></strong></p><p>Define o limiar entre a orientação correta/incorreta do dispositivo. Quanto maior o valor, mais flexível ele será. O limiar deste sensor é a aceleração do dispositivo</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | Não. A configuração padrão é 0.3.                                                                               |
| <p><strong><code>.setStabilitySensorSettings(stabilityThreshold: Double?)</code></strong></p><p>Altera as configurações padrão do sensor de estabilidade. O limite deste sensor está na faixa das duas últimas acelerações coletadas do dispositivo.</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | Não. A configuração padrão é 0.3.                                                                               |
| <p><strong><code>.setProxySettings(proxySettings: ProxySettings?)</code></strong></p><p>Define as configurações do proxy, conforme explicado <a href="https://github.com/combateafraude/public-docs/blob/docs-sdks/configurations/proxy-configuration.md">aqui</a></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | Não. O padrão é **`null`**                                                                                      |
| <p><strong><code>.showPreview(\_ show: Bool, title: String?, subtitle: String?, confirmLabel: String?, retryLabel: String?)</code></strong></p><p>Ativa/desativa a pré-visualização da captura. Se <strong><code>mostrar</code></strong> tem <strong><code>true</code></strong>, após cada captura, o SDK fornece uma tela para o usuário aprovar ou refazer a captura. Para os demais parâmetros, informe <strong><code>nil</code></strong> para usar o valor padrão ou uma String para um texto personalizado.</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | Não. O padrão é **`false`**                                                                                     |
| <p><strong><code>.setMessageSettings(waitMessage: String?, fitTheDocumentMessage: String?, verifyingQualityMessage: String?, lowQualityDocumentMessage: String?, uploadingImageMessage: String?, popupDocumentSubtitleMessage: String?, unsupportedDocumentMessage: String?, wrongDocumentMessage\_RG\_FRONT: String?, wrongDocumentMessage\_RG\_BACK: String?, wrongDocumentMessage\_RG\_FULL: String?, wrongDocumentMessage\_CNH\_FRONT: String?, wrongDocumentMessage\_CNH\_BACK: String?, wrongDocumentMessage\_CNH\_FULL: String?, wrongDocumentMessage\_CRLV: String?, wrongDocumentMessage\_RNE\_FRONT: String?, wrongDocumentMessage\_RNE\_BACK: String?, sensorLuminosityMessage: String?, sensorOrientationMessage: String?, sensorStabilityMessage: String?)</code></strong></p><p>Permite personalizar as mensagens exibidas no balão de "status" durante o processo de captura e análise. <a href="https://github.com/combateafraude/public-docs/blob/docs-sdks/ios/deprecated-sdks/v8-or-below.md#messagesettings">exemplo</a></p>                                                                                                                                                                                                                                                                                                                                    | Não.                                                                                                            |
| <p><strong><code>.setCompressSettings(compressionQuality: CGFloat)</code></strong></p><p>Permite definir a qualidade no processo de compressão. Por padrão, todas as capturas são compactadas. O método espera valores entre 0 e 1.0 como parâmetros, sendo 1.0 a melhor qualidade de compressão (recomendada).</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | Não. O padrão é 1.0                                                                                             |
| <p><strong><code>.setManualCaptureSettings(enable: Bool, time: TimeInterval)</code></strong></p><p>Ativa/desativa a captura manual. O parâmetro de tempo define o <strong><code>tempo</code></strong> para que o modo de captura seja ativado.</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | Não. O padrão é desativado                                                                                      |
| <p><strong><code>.enableMultiLanguage(\_ enable: Bool)</code></strong></p><p>Ativa/desativa o suporte a vários idiomas.</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | Não. O padrão é ativado                                                                                         |
| <p><strong><code>.setGetImageUrlExpireTime(expireTime: String)</code></strong></p><p>Define por quanto tempo a URL da imagem ficará disponível no servidor até expirar. Espere receber um intervalo de tempo entre "30m" e "30d".</p><p>Exemplos:</p><p><strong><code>setGetImageUrlExpireTime("30m")</code>:</strong> Para definir apenas minutos</p><p><strong><code>setGetImageUrlExpireTime("24h")</code>:</strong> Para definir apenas hora(s)</p><p><strong><code>setGetImageUrlExpireTime("1h 10m")</code>:</strong> Para definir hora(s) e minuto(s)</p><p><strong><code>setGetImageUrlExpireTime("10d")</code>:</strong> Para definir dia(s)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | Não. O padrão é **`3h`**                                                                                        |
| <p><strong><code>.setMask(type: MaskType)</code></strong></p><p>Define o tipo de máscara usado nas capturas. Há três tipos:</p><p><code>.</code><strong><code>padrão</code></strong>, com o padrão pontilhado no formato do documento;</p><p><code>.</code><strong><code>vazia</code></strong>, que remove completamente a máscara.</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | Não. O padrão é **`.standard`**                                                                                 |
| <p><strong><code>.setCurrentStepDoneDelay(currentStepDoneDelay: TimeInterval)</code></strong></p><p>Atrasa a atividade após a conclusão de cada etapa. Este método pode ser usado para exibir uma mensagem de sucesso na própria tela após a captura, por exemplo.</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | Não. O padrão é **`false`**                                                                                     |
| <p><strong><code>.setUploadSettings(UploadSettings uploadSettings)</code></strong></p><p>Define as configurações para upload de documentos. Ao ativar essa opção, o fluxo do SDK solicitará ao usuário que envie os arquivos do documento em vez de capturá-los com a câmera do dispositivo. Essa opção também inclui verificações de qualidade do documento. <a href="https://github.com/combateafraude/public-docs/blob/docs-sdks/ios/deprecated-sdks/v8-or-below.md#uploadsettings">exemplo</a> da implementação.</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | Não. Por padrão essa opção está desativada.                                                                     |
| <p><strong><code>.setResolutionSettings(resolution: Resolution)</code></strong></p><p>Permite definir a resolução da captura. O método recebe como parâmetro uma Resolution, que possui as seguintes opções:</p><ul><li><code>low</code> Especifica as configurações de captura apropriadas para taxas de bits de vídeo e áudio de saída adequadas para compartilhamento via 3G</li><li><code>medium</code> Especifica as configurações de captura apropriadas para as taxas de bits de vídeo e áudio de saída adequadas para compartilhamento via WiFi</li><li><code>high</code> Especifica as configurações de captura apropriadas para saída de vídeo e áudio em alta qualidade</li><li><code>photo</code> Especifica as configurações de captura apropriadas para saída de qualidade de foto em alta resolução</li><li><code>inputPriority</code> Especifica as configurações de captura apropriadas para saída de qualidade de foto em alta resolução</li><li><code>hd1280x720</code> Especifica as configurações de captura apropriadas para saída de vídeo em qualidade 720p (1280 x 720 pixels)</li><li><code>hd1920x1080</code> Configurações de captura adequadas para saída de vídeo em qualidade 1080p (1920 x 1080 pixels)</li><li><code>hd4K3840x2160</code> Configurações de captura adequadas para saída de vídeo em qualidade 2160p (3840 x 2160 pixels)</li></ul> | Não. O padrão é **`hd1920x1080`**                                                                               |
| <p><strong><code>.setAllowedPassportCountriesList(passportList: \[CountryCodes])</code></strong></p><p>Ativa a opção de permitir passaportes de apenas um determinado país emissor ou de uma lista de países. Veja a lista completa em: <a href="https://en.wikipedia.org/wiki/ISO_3166-1_alpha-3">ISO 3166-1 alpha-3</a></p><p>Exemplo:</p><ul><li><strong><code>.setAllowedPassportList(passportList: \[CountryCodes.BRA])</code></strong></li></ul>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | Não. Por padrão, são aceitos passaportes emitidos por qualquer país.                                            |

### **DocumentDetectorStep**

Para criar um fluxo de captura, você precisará criar um array de **`DocumentDetectorStep`**, em que cada elemento será uma etapa de captura. Para construir cada **`DocumentDetectorStep`** objeto, você pode inserir os seguintes elementos:

| **Parâmetro**                                                                                                                                                                                                                               | **Obrigatório?**                            |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------- |
| <p><strong>document: Document</strong></p><p>Identifica qual documento você deseja capturar na respectiva etapa</p>                                                                                                                         | Sim                                         |
| <p><strong>rótuloDaEtapa: String?</strong></p><p>Texto a ser exibido na parte inferior do layout</p>                                                                                                                                        | Não. Há um padrão para **`Documento`** Tipo |
| <p><strong>ilustração: UIImage?</strong></p><p>Ilustração a ser exibida no popup antes da captura</p>                                                                                                                                       | Não. Há um padrão para **`Documento`** Tipo |
| <p><strong>audio: URL?</strong></p><p>Áudio a ser reproduzido no início da etapa. <a href="https://github.com/combateafraude/public-docs/blob/docs-sdks/ios/deprecated-sdks/v8-or-below.md#how-to-get-the-url-of-an-audio">Exemplo</a>.</p> | Não. Há um padrão para **`Documento`** Tipo |

### **MessageSettings**

| **Atributo**                                                                                                                                                                                                   | **Valor Padrão**                                                                               |
| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------- |
| <p><strong><code>waitMessage: String</code></strong></p><p>Mensagem exibida quando o SDK está em processo de abertura.</p>                                                                                     | "Por favor, aguarde…"                                                                          |
| <p><strong><code>fitTheDocumentMessage: String</code></strong></p><p>Mensagem que orienta a ajustar o documento à máscara.</p>                                                                                 | "Ajuste o documento na marcação"                                                               |
| <p><strong><code>verifyingQualityMessage: String</code></strong></p><p>Mensagem exibida quando o SDK faz uma solicitação ao backend para verificar a qualidade.</p>                                            | "Verificando qualidade…"                                                                       |
| <p><strong><code>lowQualityDocumentMessage: String</code></strong></p><p>Mensagem exibida quando a qualidade da captura falha.</p>                                                                             | "Ops, não foi possível ler as informações. Tente novamente"                                    |
| <p><strong><code>uploadingImageMessage: String</code></strong></p><p>Mensagem exibida quando não há verificação de qualidade e a captura está sendo salva nos servidores.</p>                                  | "Enviando imagem…"                                                                             |
| <p><strong><code>popupDocumentSubtitleMessage: String</code></strong></p><p>Texto exibido no pop-up de inicialização da etapa.</p>                                                                             | "Coloque o documento sobre uma mesa, centralize-o na marcação e aguarde a captura automática." |
| <p><strong><code>unsupportedDocumentMessage: String</code></strong></p><p>Mensagem exibida quando um tipo inesperado de documento é exibido para captura.</p>                                                  | "Ops, parece que este documento não é compatível. Entre em contato conosco!"                   |
| <p><strong><code>wrongDocumentMessage\_RG\_FRONT: String</code></strong></p><p>Mensagem exibida quando a frente do RG (carteira de identidade brasileira) é exibida em um fluxo diferente do esperado.</p>     | "Ops, esta é a Frente do RG"                                                                   |
| <p><strong><code>wrongDocumentMessage\_RG\_BACK: String</code></strong></p><p>Mensagem exibida quando a versão do RG (carteira de identidade brasileira) é exibida em um fluxo diferente do esperado.</p>      | "Ops, este é o Verso do RG"                                                                    |
| <p><strong><code>wrongDocumentMessage\_RG\_FULL: String</code></strong></p><p>Mensagem exibida quando o RG aberto (carteira de identidade brasileira) é exibido em um fluxo diferente do esperado.</p>         | "Ops, este é o RG Aberto"                                                                      |
| <p><strong><code>wrongDocumentMessage\_CNH\_FRONT: String</code></strong></p><p>Mensagem exibida quando a frente da CNH (Carteira Nacional de Habilitação) é exibida em um fluxo diferente do esperado.</p>    | "Ops, esta é a Frente da CNH"                                                                  |
| <p><strong><code>wrongDocumentMessage\_CNH\_BACK: String</code></strong></p><p>Mensagem exibida quando a versão da CNH (Carteira Nacional de Habilitação) é exibida em um fluxo diferente do esperado.</p>     | "Ops, este é o Verso da CNH"                                                                   |
| <p><strong><code>wrongDocumentMessage\_CNH\_FULL: String</code></strong></p><p>Mensagem exibida quando a CNH aberta (Carteira Nacional de Habilitação) é exibida em um fluxo diferente do esperado.</p>        | "Ops, esta é a CNH Aberta"                                                                     |
| <p><strong><code>wrongDocumentMessage\_CRLV: String</code></strong></p><p>Mensagem exibida quando o CRLV (Certificado de Registro e Licenciamento de Veículo) é exibido em um fluxo diferente do esperado.</p> | "Ops, este é o CRLV"                                                                           |
| <p><strong><code>wrongDocumentMessage\_RNE\_FRONT: String</code></strong></p><p>Mensagem exibida quando a frente do RNE (Registro Nacional de Estrangeiros) é exibida em um fluxo diferente do esperado.</p>   | "Ops, esta é a Frente do RNE"                                                                  |
| <p><strong><code>wrongDocumentMessage\_RNE\_BACK: String</code></strong></p><p>Mensagem exibida quando o verso do RNE (Registro Nacional de Estrangeiros) é exibido em um fluxo diferente do esperado.</p>     | "Ops, este é o Verso do RNE"                                                                   |
| <p><strong><code>sensorLuminosityMessage: String</code></strong></p><p>Mensagem exibida quando o limite de brilho é menor do que o esperado.</p>                                                               | "A área próxima a você está escura demais"                                                     |
| <p><strong><code>sensorOrientationMessage: String</code></strong></p><p>Mensagem exibida quando o limite de orientação é menor do que o esperado.</p>                                                          | "O dispositivo não está na horizontal"                                                         |
| <p><strong><code>sensorStabilityMessage: String</code></strong></p><p>Mensagem exibida quando o limite de orientação é menor do que o esperado.</p>                                                            | "Mantenha o dispositivo parado"                                                                |

### **UploadSettings**

Para ativar a funcionalidade de upload de documentos, é necessário instanciar um objeto do tipo **`UploadSettings`()** e definir seus parâmetros:

| **Parâmetro**                                                                                                          | **Obrigatório?**                                 |
| ---------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------ |
| <p><strong><code>ativar</code></strong></p><p>Ativa/desativa este recurso.</p>                                         | Não. O padrão é **`true`**                       |
| <p><strong><code>comprimir</code></strong></p><p>Ativa/desativa a compressão de arquivos antes do envio.</p>           | Não. O padrão é **`true`**                       |
| <p><strong><code>fileFormats</code></strong></p><p>Define o(s) formato(s) de arquivo que serão aceitos para envio.</p> | Não. Por padrão, .PDF , .JPEG e .PNG são aceitos |
| <p><strong><code>maximumFileSize</code></strong></p><p>Define o limite máximo em KB do arquivo a ser enviado.</p>      | Não. O limite padrão é 10000 KB (10 MB).         |

Atualmente, os formatos de arquivo suportados são:

```swift
public enum FileFormat: String {
    case png
    case jpeg
    case pdf
}
```

## **Obtendo o resultado**

Para obter o resultado, você deve implementar o **`DocumentDetectorControllerDelegate`** delegate no seu controlador:

```swift
class YouController: UIViewController, DocumentDetectorControllerDelegate{
    
    // MARK: - Delegados de Detecção de Documento
    
    func documentDetectionController(_ scanner: DocumentDetectorController, didFinishWithResults results: DocumentDetectorResult) {
        //Chamado quando o processo foi executado com sucesso
        //A variável result contém os dados obtidos
    }
    
    func documentDetectionControllerDidCancel(_ scanner: DocumentDetectorController) {
        // Chamado quando o usuário cancelar
    }
    
    func documentDetectionController(_ scanner: DocumentDetectorController, didFailWithError error: DocumentDetectorFailure) {
        //Chamado quando o processo termina com um erro
        //A variável error contém informações sobre o erro
    }
}
```

Depois de criar o **`DocumentDetector`** objeto, inicie o **`DocumentDetectorController`** passando este objeto como parâmetro no construtor:

```swift
let scannerVC = DocumentDetectorController(documentDetector: documentDetector)
scannerVC.documentDetectorDelegate = self
present(scannerVC, animated: true, completion: nil)
```

### **DocumentDetectorResult**

| **Parâmetro**                                                                                                                                                                                                                                                                                                      | **Pode ser nulo?**                                                                               |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------ |
| <p><strong><code>captures:\[Capture]</code></strong></p><p>O array com as capturas correspondentes dos documentos parametrizados</p>                                                                                                                                                                               | Sim, em caso de erro                                                                             |
| <p><strong>tipo: String</strong></p><p>A classe do fluxo do documento lido. Este parâmetro é útil em uma integração com nossa rota de OCR. Os tipos existentes são: <strong><code>\["blank", "cnh", "cnh\_new", "generic", "rg", "rg\_new", "rne", "rnm", "ctps", "passport, crlv, crlv\_new"]</code></strong></p> | Sim, em caso de erro                                                                             |
| <p><strong>trackingId: String?</strong></p><p>Identificador desta execução em nossos servidores. Se possível, salve este campo e envie-o para nossa API. Dessa forma, teremos mais dados sobre como o usuário se comportou durante a execução</p>                                                                  | Sim, se o usuário definir **`useAnalytics = false`** ou as chamadas de analytics não funcionarem |

### **Captura**

| **Parâmetro**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | **Pode ser nulo?**                                         |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------- |
| <p><strong><code>imagem: UIImage</code></strong></p><p>Imagem do documento</p>                                                                                                                                                                                                                                                                                                                                                                                                                    | Não                                                        |
| <p><strong><code>imageUrl :String</code></strong></p><p>URL do documento no servidor da CAF. Se você quiser essa URL, mantenha ativado o parâmetro que verifica a qualidade da imagem</p>                                                                                                                                                                                                                                                                                                         | Sim, se você optar por não verificar a qualidade da imagem |
| <p><strong><code>scannedLabel :String</code></strong></p><p>Rótulo do respectivo documento entre as seguintes possibilidades: <strong><code>\["blank", "cnh\_back", "cnh\_front", "cnh\_full", "new\_cnh\_back", "new\_cnh\_front", "new\_cnh\_full", "crlv", "crlv\_new", "generic", "rg\_back", "rg\_front", "rg\_full", "rg\_new\_back", "rg\_new\_front", "rg\_new\_full", "rne\_back", "rne\_front", "rnm\_back", "rnm\_front", "ctps\_back", "ctps\_front", "passport"]</code></strong></p> | Não                                                        |
| <p><strong><code>quality :Double</code></strong></p><p>Qualidade inferida pelo algoritmo de qualidade do documento, quando ativado. Varia entre 1.0 e 5.0</p>                                                                                                                                                                                                                                                                                                                                     | Pode ser 0, se o SDK não verificar a qualidade             |
| <p><strong><code>lensFacing: Int</code></strong></p><p>Define o lado da câmera que foi usado. Use <strong><code>DocumentDetectorResult.LENS\_FACING\_FRONT</code></strong> ou <strong><code>DocumentDetectorResult.LENS\_FACING\_FRONT</code></strong> para validar.</p>                                                                                                                                                                                                                          | Não                                                        |

### **DocumentDetectorFailure**

Superclasse que leva ao encerramento do SDK. Para descobrir qual foi o motivo, descubra qual classe de objeto possui o método \*\*`isKindOfClass()` \*\*, equivalente a **`instanceof`** em Java e **`is`** em Dart:

| **isKindOfClass()**      | **Descrição**                                                    | **Exemplo**                                                                   |
| ------------------------ | ---------------------------------------------------------------- | ----------------------------------------------------------------------------- |
| **`InvalidTokenReason`** | O token informado não é válido para o produto correspondente     | Parametrize "test123" como token no builder do SDK                            |
| **`PermissionReason`**   | Falta alguma permissão obrigatória para executar o SDK           | Iniciar o DocumentDetector sem permissão de câmera concedida                  |
| **`NetworkReason`**      | Falha na conexão com a internet                                  | O usuário estava sem internet durante o facematch no FaceAuthenticator        |
| **`ServerReason`**       | Quando uma requisição do SDK recebe um código de status de falha | Em teoria, isso não deveria acontecer. Se acontecer, nos avise!               |
| **`StorageReason`**      | Não há espaço no armazenamento interno do dispositivo do usuário | Quando não há espaço no armazenamento interno ao capturar a foto do documento |

## **Exemplos**

### **Personalizando o layout**

Você pode personalizar o layout criando um objeto do tipo **`DocumentDetectorLayout`** e passando-o como parâmetro em **`DocumentDetectorBuilder`**:

```swift
let layout = DocumentDetectorLayout()

layout.changeMaskImages(
    greenMask: UIImage(named: "my_green_mask"),
    whiteMask: UIImage(named: "my_white_mask"),
    redMask: UIImage(named: "my_red_mask"))

layout.changeSoundImages(soundOn: UIImage(named: "my_sound_on_image"),
                        soundOff: UIImage(named: "my_sound_off_image"))
                        
layout.closeImage = UIImage(named: "my_close_image")
layout.buttonSize = CGFloat(50)
layout.buttonContentMode = .scaleAspectFill

layout.setFont = UIImage(named: "my_font")

let documentDetectorConfiguration = DocumentDetectorBuilder(apiToken: "API_TOKEN")
    .setDocumentDetectorFlow(flow: DocumentDetectorBuilder.RG_FLOW)
    .setLayout(layout: layout)
    .build()
```

### **Como obter a URL de um áudio**

```swift
let bundle = Bundle.init(for: type(of: self))
let audioURL = URL(fileURLWithPath: bundle.path(forResource: "my_audio_file", ofType: "mp3")!)
```


---

# 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/ios/standalone-modules/deprecated-sdks/document-detector-deprecated.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.
