Document Capture

This guide has been designed to help you implement the Android SDK quickly and easily. Below, you will find a step-by-step process for the entire integration. After that, if you wish to customize the experience, be sure to check the Android Customization section.

Available Document Frames

In this camera mode, there is a capture frame to assist the user in positioning the document correctly. Once the document is properly positioned, the user must click the button to take a photo of the document.

In this camera mode, it is possible to capture the following documents:

• CPF: Capture the front of the CPF;

• CNH: Capture the open CNH;

• CNH Front: Capture the front of the CNH;

• CNH Back: Capture the back of the CNH;

• RG Front: Capture the front of the RG;

• RG Back: Capture the back of the RG;

• Others: Capture any other document.

Initializing the SDK

Create an instance of the builder (generated through the IAcessoBioBuilder interface), providing the relevant context as a parameter and implementing the AcessoBioListener class. The implementation of this class is quite simple and can be done with just a few lines of code. All you need to do is instantiate the builder, specifying the relevant context and overriding the callback methods with your application's business logic:

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);
}

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)
}

Implementing Callback Functions

Note that the implementation of the AcessoBioListener class largely consists of configuring the callback methods. Each method is called in a specific situation based on the SDK's return.

Override the methods exemplified above with your application’s business logic.

Implementing Listeners for Camera Events

The camera opening method, which is called in the next step, needs to know what to do upon successfully capturing an image or encountering an error during the process. It is necessary to inform "what to do" to the camera opening method by implementing listeners that are called in success or error situations.

By configuring the listeners, you can specify what happens in your app in case of an error (method onErrorDocument) or success (method onSuccessDocument) in capturing images. The example below illustrates the configuration of the listeners, building, and opening the camera:

iAcessoBioDocument cameraListener = new iAcessoBioDocument() {
    @Override
    public void onSuccessDocument(ResultCamera result) { }

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

unicoCheckCamera.prepareDocumentCamera(unicoConfig, new DocumentCameraListener() {
    @Override
    public void onCameraReady(UnicoCheckCameraOpener.Document cameraOpener) {
        cameraOpener.open(DocumentType.CNH, cameraListener);
    }

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

val cameraListener: iAcessoBioDocument = object : iAcessoBioDocument {
    override fun onSuccessDocument(result: ResultCamera?) {}

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

unicoCheckCamera.prepareDocumentCamera(unicoConfig, object : DocumentCameraListener {
    override fun onCameraReady(cameraOpener: UnicoCheckCameraOpener.Document?) {
        cameraOpener?.open(DocumentType.CNH, cameraListener)
    }

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

onSucessDocument Method

When successfully capturing an image, this method is invoked and returns an object of type ResultCamera, which is used later in the REST API requests:

public void onSuccessDocument(ResultCamera result) { }

The ResultCamera object returns two attributes: base64 and encrypted.

• The base64 attribute can be used if you want to display a preview of the image in your app.

• Both the encrypted and base64 attributes can be sent in the REST API calls of the by Client.

onErrorDocument Method

If an error occurs during the image capture, this method is invoked and returns an object of type ErrorBio:

public void onErrorDocument(ErrorBio errorBio) { }

Preparing and Opening the Camera

It is necessary to create an instance of the builder using the build() method. This method is provided by the object generated with the IAcessoBioBuilder interface and the AcessoBio class:

UnicoCheckCamera unicoCheckCamera = acessoBioBuilder.build();  

val unicoCheckCamera = acessoBioBuilder.build()

The next step is to prepare the camera using the prepareDocumentCamera() method with the object returned by the builder (named UnicoCheckCamera in the example above). The prepareDocumentCamera() method generates an object of type UnicoCheckCameraOpener.Document, which is used to open the camera with its open() method, receiving the type of document to be captured as a parameter:

Making a POST Request to the Client API

After capturing images, the next step is to send the generated base64 image from the SDK to the Client APIs.

Still need help?​

Didn't find something or still need help? If you're already a client or partner, you can reach out through our Help Center.