---
description: >-
  Nesta seção, você encontrará todas as informações necessárias para o uso e
  integração do SDK da plataforma Unico IDCloud em seus aplicativos Android para
  a captura da selfie
---

# Captura de Selfie

***



Este guia foi elaborado para ajudá-lo a implementar o **SDK Android** de forma rápida e fácil. Abaixo veja o passo a passo de todo o processo de integração. Após isso, caso deseje personalizar a experiência, não deixe de ver a seção [<mark style="color:blue;">**Personalização Android**</mark>](https://unicoidtech.gitbook.io/idcloud/integracao/sdk/integracao-sdks/sdk-android/personalizacao-android)**.**



## Inicializar o SDK

***

Crie uma instância do builder (Gerado através da interface **`IAcessoBioBuilder`**), fornecendo como parâmetro o &#x63;_&#x6F;ntexto_ e _ambiente_ em questão e a implementação da classe **`AcessoBioListener`**.

A implementação dessa classe é bem simples e pode ser feita com poucas linhas de código. Tudo que precisa fazer é instanciar o **builder** informando o contexto em questão e sobrescrever os métodos de **callback** com as lógicas de negócio de sua aplicação:

{% tabs %}
{% tab title="Java" %}
```java
public class MainActivity extends AppCompatActivity {

    private AcessoBioListener callback = new AcessoBioListener() {
        @Override
        public void onErrorAcessoBio(ErrorBio errorBio) { }

        @Override
        public void onUserClosedCameraManually() { }

        @Override
        public void onSystemClosedCameraTimeoutSession() { }

        @Override
        public void onSystemChangedTypeCameraTimeoutFaceInference() { }
    };

    private IAcessoBioBuilder acessoBioBuilder = new AcessoBio(this, callback);
}
```
{% endtab %}

{% tab title="Kotlin" %}
```kotlin
internal class MainActivity : AppCompatActivity() {

    private val callback = object : AcessoBioListener {
        override fun onErrorAcessoBio(errorBio: ErrorBio?) { }
    
        override fun onUserClosedCameraManually() { }
    
        override fun onSystemClosedCameraTimeoutSession() { }
    
        override fun onSystemChangedTypeCameraTimeoutFaceInference() { }
    }

    private val acessoBioBuilder: IAcessoBioBuilder = AcessoBio(this, callback)
}
```
{% endtab %}
{% endtabs %}



## **Configuração de ambientes**

***

Configure o ambiente que será utilizado na execução da SDK. Utilize o enumerado `Environment` que contém os seguintes enumerados:

* `Environment.PROD`: para ambiente de Produção;
* `Environment.UAT`: para ambiente de Homologação.

Veja como implementar no exemplo abaixo:

{% tabs %}
{% tab title="Java" %}
```java
acessoBioBuilder.setEnvironment(Environment.UAT);
```
{% endtab %}

{% tab title="Kotlin" %}
```kotlin
acessoBioBuilder.setEnvironment(Environment.UAT);
```
{% endtab %}
{% endtabs %}



## Implementar as funções de callback

***

Note que, o trabalho de implementação da classe **`AcessoBioListener`** é, em grande parte, a configuração dos métodos de **callback**. Cada método é chamado em uma situação específica de retorno do SDK.

Basta sobrescrever os métodos exemplificados no passo anterior com as lógicas de negócio de sua aplicação.

Este método é invocado sempre que qualquer erro de implementação ocorrer ao utilizar algum de nossos métodos:

{% stepper %}
{% step %}
**`onErrorAcessoBio(ErrorBio errorBio)`**

Ao ser invocado, o método recebe um parâmetro do tipo **ErrorBio** que contem detalhes do erro. Saiba mais sobre o tipo **`ErrorBio`** na seção de [<mark style="color:blue;">**tratamento de erros**</mark>](https://unicoidtech.gitbook.io/idcloud/integracao/sdk/integracao-sdks/sdk-android/guia-de-tratamento-de-erros).


{% endstep %}

{% step %}
**`onUserClosedCameraManually()`**

Este método é invocado sempre quando o usuário fechar a câmera de forma manual, como por exemplo, ao clicar no botão "Voltar".


{% endstep %}

{% step %}
**`onSystemClosedCameraTimeoutSession()`**

Este método é invocado assim que o tempo máximo de sessão for atingido (Sem capturar nenhuma imagem).

{% hint style="warning" %}
Pode ser configurado no **builder** através do método **setTimeoutSession**. Este método deve receber o tempo máximo da sessão em **segundos**. É possível alterar o tempo máximo de sessão do seu usuário ao utilizar a funcionalidade de detecção do rosto **(Câmera de selfie com captura inteligente)**. Caso ele ultrapasse o tempo determinado em seu processo para capturar a foto, você pode apresentar alguma mensagem personalizável ou instrução ao usuário. O valor padrão é de **40 segundos** e seu **valor mínimo também é de 40 segundos**.
{% endhint %}


{% endstep %}

{% step %}
**`onSystemChangedTypeCameraTimeoutFaceInference()`**

Este método é invocado assim que o tempo máximo para detecção do rosto de um usuário for atingido (Sem ter nada detectado). Neste caso, o modo de câmera é alterado automaticamente para o modo de captura manual (Sem a silhueta de captura inteligente).

{% hint style="warning" %}
O tempo máximo de captura ao utilizar a detecção do rosto (Câmera de selfie com captura inteligente) é de **13 segundos**. Se o usuário encontra alguma dificuldade para captura da foto através da detecção do rosto e ultrapasse o tempo determinado em seu processo, a captura é alterada automaticamente para a manual, tendo como objetivo facilitar a ação para o usuário **(TimeoutToFaceInference)**.
{% endhint %}


{% endstep %}
{% endstepper %}

{% hint style="danger" %}
Todos os métodos acima devem ser criados da forma indicada em seu projeto (Mesmo que sem nenhuma lógica). Caso contrário, o projeto não compila com sucesso.
{% endhint %}



## Configurar modo de câmera

***

O SDK tem configurado e habilitado por padrão o **enquadramento inteligente** e a **captura automática**. Em função disso, deve-se configurar o modo de câmera no seu **builder** da seguinte forma:

{% tabs %}
{% tab title="Java" %}
```java
UnicoCheckCamera unicoCheckCamera = acessoBioBuilder
    .setAutoCapture(true)
    .setSmartFrame(true)
    .build();
```
{% endtab %}

{% tab title="Kotlin" %}
```kotlin
val unicoCheckCamera: UnicoCheckCamera = acessoBioBuilder
    .setAutoCapture(true)
    .setSmartFrame(true)
    .build()
```
{% endtab %}
{% endtabs %}

{% hint style="success" %}
Os valores false/true dos métodos acima não alteram a experiência de captura, servem apenas para a lógica interna do funcionamento do SDK.
{% endhint %}





## Implementar _listeners_ para eventos da câmera

***

{% hint style="info" %}
A implementação destes métodos **listeners** deve ser feita através de uma instância da classe **`iAcessoBioSelfie`**.
{% endhint %}

O método de abertura da câmera, que é chamado na próxima etapa, precisa saber o que fazer ao conseguir capturar uma imagem com **sucesso** ou ao ocorrer algum **erro** no processo. É necessário informar "o que fazer" ao método de abertura da câmera através da implantação de **listeners** que são chamados em situações de sucesso ou erro.

Através da configuração dos **listeners**, você pode especificar o que acontece em seu App em situações de erro (Método **`onErrorSelfie`**) ou sucesso (Método **`onSuccessSelfie`**) na captura de imagens.

{% hint style="warning" %}
Mudanças da nomenclatura para as versões inferiores a 4.2.1:

* Do método **`prepareCamera`** que antes era **`prepareSelfieCamera`**;
* Da classe **`CameraListener`** que antes era **`SelfieCameraListener`**;
* Do objeto **`UnicoCheckCameraOpener.Camera`** que antes era **`UnicoCheckCameraOpener.Selfie`**.
{% endhint %}

Para a configuração dos listeners, é necessário implementar:

{% tabs %}
{% tab title="Java" %}
```java
iAcessoBioSelfie cameraListener = new iAcessoBioSelfie() {
    @Override
    public void onSuccessSelfie(ResultCamera result) { }

    @Override
    public void onErrorSelfie(ErrorBio errorBio) { }
};

unicoCheckCamera.prepareCamera(unicoConfig, new CameraListener() {
    @Override
    public void onCameraReady(UnicoCheckCameraOpener.Camera cameraOpener) {
        cameraOpener.open(cameraListener);
    }

    @Override
    public void onCameraFailed(String message) {
        Log.e(TAG, message);
    }
});
```
{% endtab %}

{% tab title="Kotlin" %}
```kotlin
val cameraListener: iAcessoBioSelfie = object : iAcessoBioSelfie {
    override fun onSuccessSelfie(result: ResultCamera?) {}

    override fun onErrorSelfie(errorBio: ErrorBio?) {}
}

unicoCheckCamera.prepareCamera(unicoConfig, object : CameraListener {
    override fun onCameraReady(cameraOpener: UnicoCheckCameraOpener.Camera?) {
        cameraOpener?.open(cameraListener)
    }

    override fun onCameraFailed(message: String?) {
        Log.e(TAG, message)
    }
})
```
{% endtab %}
{% endtabs %}



## Preparar e abrir câmera

***

Para seguir com a abertura da câmera, primeiro é necessário prepará-la utilizando o método **prepareCamera**. Este método recebe como parâmetro a implementação da classe **`CameraListener`**, a classe ou o JSON com as credenciais, gerado [<mark style="color:blue;">**nessa etapa**</mark>](https://unico-auto-1.gitbook.io/idcloud/sdks/sdk-android/guia-de-instalacao#obtendo-as-credenciais).

Quando a câmera estiver preparada, é disparado o evento **`onCameraReady`**, que recebe como parâmetro um objeto do tipo **`UnicoCheckCameraOpener.Camera`**.

É necessário sobrescrever este método, efetuando a abertura da câmera com o objeto recebido através do método **`open()`**. O método **`open()`** deve receber como parâmetro os **listeners** configurados nos passos acima.



### Método `onSucessSelfie`

***

Ao efetuar uma captura de imagem com **sucesso**, este método é invocado e retorna um objeto do tipo **`ResultCamera`** que é utilizado posteriormente na chamada das APIs REST:

```java
public void onSuccessSelfie(ResultCamera result) { }
```

O objeto **`ResultCamera`** retorna 2 atributos: **`base64`** e **`encrypted`**:

* O atributo **`base64`** pode ser utilizado se quiser exibir uma prévia da imagem em seu app;
* O atributo **`encrypted`** deve ser enviado na chamada das APIs REST do [<mark style="color:blue;">**by Client**</mark>](https://unico-auto-1.gitbook.io/idcloud/integracao/integracao-by-client/apis-by-client/createprocess).

{% hint style="danger" %}
- O atributo **`encrypted`** é destinado estritamente ao envio da imagem através das APIs do by Client. Não se deve abrir e serializar esse atributo, pois suas características podem ser alteradas sem aviso prévio. Seu uso deve ser exclusivo nas interações com as APIs para garantir a integridade e segurança dos dados. **A Unico não se responsabiliza por quaisquer danos decorrentes dessa prática, uma vez que as modificações podem ocorrer de maneira imprevista**.
- Os arquivos `base64/encrypted` podem sofrer variações de tamanho de acordo com diversas variáveis, dentre elas, a qualidade dos aparelhos e das fotos geradas pelos mesmos e regras de negócio da Unico. Para não encontrar problemas em sua aplicação, **não limite em sua lógica de programação ou sua infraestrutura o tamanho da string gerada pela SDK para os arquivos**.
{% endhint %}



### Método `onErrorSelfie`

***

Ao ocorrer algum **erro** na captura de imagem, este método é invocado e retorna um objeto do tipo **`ErrorBio`**:

```java
public void onErrorSelfie(ErrorBio errorBio) { }
```

{% hint style="info" %}
Saiba mais sobre os tipos de **`ErrorBio`** na seção de [<mark style="color:blue;">**tratamento de erros**</mark>](https://unico-auto-1.gitbook.io/idcloud/sdks/sdk-android/guia-de-tratamento-de-erros) do SDK.
{% endhint %}

{% hint style="success" %}
Se for necessário converter o base64 para bitmap, a maneira padrão não funciona para o Android. É necessário realizar o split a partir da vírgula(`,`) para que funcione. Se quiser saber mais, leia o artigo: [<mark style="color:blue;">How to convert a Base64 string into a Bitmap image to show it in a ImageView?</mark>](https://stackoverflow.com/questions/4837110/how-to-convert-a-base64-string-into-a-bitmap-image-to-show-it-in-a-imageview).
{% endhint %}



## Realize um requisição POST na API REST do by Client

***

A captura das imagens é apenas a primeira parte da jornada. Após capturar a imagem, é necessário enviar o **`encrypted`** gerado pelo SDK para as APIs REST do by Client. Saiba mais na seção [<mark style="color:blue;">**CreateProcess do by Client**</mark>](https://unicoidtech.gitbook.io/idcloud/integracao/integracao-by-client/apis/createprocess).

{% hint style="danger" %}
Por motivos de segurança, o intervalo entre a geração do `encrypted` e o envio via um dos fluxos disponíveis deve ser de até no máximo 10 minutos. Envios feitos além deste período serão rejeitados automaticamente pela API.
{% endhint %}

***



#### Dúvidas?​ <a href="#duvidas" id="duvidas"></a>

Não encontrou algo ou ainda precisa de ajuda? Se já é um cliente ou parceiro, pode entrar em contato através da [<mark style="color:blue;">Central de Ajuda</mark>](https://empresas.unico.io/hc/pt-br/p/atendimentoparaempresas).
