1 de 36

SDK Integration

In this section, you will find all the necessary information to implement the SDKs of the Unico IDCloud platform

Android SDK

In this section, you will find all the necessary information to implement the Android SDK of the Unico IDCloud platform

Installation Guide

In this section, you will find all the information needed to install the Unico IDCloud platform SDK in your Android applications

Development Environment Preconditions

Ensure your development environment meets the following preconditions:

The capture component provided through the Android SDK supports versions equal to or higher for the following technologies:

Android: 5.0 (API 21);
Kotlin: 1.6.

Compatible Devices

This SDK does not function on emulators, it is only supported on physical devices.

The Android SDK is compatible with the vast majority of devices running Android 5.0 (API level 21) or higher.

The table below lists the devices tested in our lab, along with the availability of vendor/manufacturer extensions. Some listed extensions may be subject to specific manufacturer APIs or SKUs. Click below to view the tested devices:

Installing the Android SDK

To implement the Unico IDCloud platform’s Android SDK in your Android app, follow the steps below:

Configuring the Maven Repository

The Android SDK is available via a Maven repository. Add it to the repositories block in the root-level build.gradle file:

/build.gradle

// Top-level build file where you can add configuration options common to all sub-projects/modules.
allprojects 
{
    repositories {
        google()
        jcenter()
        maven { 
            url "https://maven-sdk.unico.run/sdk-mobile" 
        }
    }
}

Enable AndroidX support in your gradle.properties file in the root of your project. This ensures better performance and proper functioning of the capture framework.

gradle.properties

# Project-wide Gradle settings.
# https://developer.android.com/topic/libraries/support-library/androidx-rn
android.useAndroidX=true
# Automatically convert third-party libraries to use AndroidX
android.enableJetifier=true

Camera and Internet Permissions

To use the camera and internet in your project, add the following permissions to your AndroidManifest.xml:

AndroidManifest.xml

<uses-permission android:name="android.permission.CAMERA" />
<uses-permission android:name="android.permission.INTERNET" />

Adding the Dependency

After configuring the Android SDK, import it into your project by adding acessobio-android to the dependencies block in app/build.gradle.

Use the module-specific build.gradle file, not the project-level one:

app/build.gradle

/* unico */
implementation 'io.unico:capture:$version'

If you encounter the error:

Invoke-customs are only supported starting with android 0 --min-api 26

Add the following lines to the compileOptions block in app/build.gradle:

android { 
    compileOptions { 
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8 
      } 
}

Obtaining Credentials

Contact the CSs and/or Onboarding team.
Request the SDK Key by entering the identifiers of your applications. Bundle Identifier for iOS, PackageID for Android and Host for WEB.
The identifiers of your applications will be linked to the SDK Key by the Unico team.
You receive your SDK Key to implement the AccessBioConfigDataSource.

Embedding Credentials in Your Project

Implement the AcessoBioConfigDataSource protocol in your class:

package <package_name>

import com.acesso.acessobio_android.onboarding.AcessoBioConfigDataSource;

public class UnicoConfig implements AcessoBioConfigDataSource {
    @Override
    public String getBundleIdentifier() {
        return BUNDLE_IDENTIFIER;
    }
        
    @Override
    public String getHostKey() {
        return SDK_KEY;
    }
}

package <package_name>

import com.acesso.acessobio_android.onboarding.AcessoBioConfigDataSource

class UnicoConfig : AcessoBioConfigDataSource {
    override fun getBundleIdentifier(): String {
        return BUNDLE_IDENTIFIER
    }

    override fun getHostKey(): String {
        return SDK_KEY
    }
}

Depracated Method - Java

package <package_name>

import com.acesso.acessobio_android.onboarding.AcessoBioConfigDataSource;

public class UnicoConfig implements AcessoBioConfigDataSource {
    @Override
    public String getProjectNumber() {
        return PROJECT_NUMBER;
    }
    
    @Override
    public String getProjectId() {
        return PROJECT_ID;
    }
    
    @Override
    public String getMobileSdkAppId() {
        return MOBILE_SDK_APP_ID;
    }
    
    @Override
    public String getBundleIdentifier() {
        return BUNDLE_IDENTIFIER;
    }
    
    @Override
    public String getHostInfo() {
        return HOST_INFO;
    }
    
    @Override
    public String getHostKey() {
        return HOST_KEY;
    }
}

Deprecated Method - Kotlin

package <package_name>

import com.acesso.acessobio_android.onboarding.AcessoBioConfigDataSource

class UnicoConfig : AcessoBioConfigDataSource {
    override fun getProjectNumber(): String {
        return PROJECT_NUMBER
    }

    override fun getProjectId(): String {
        return PROJECT_ID
    }

    override fun getMobileSdkAppId(): String {
        return MOBILE_SDK_APP_ID
    }

    override fun getBundleIdentifier(): String {
        return BUNDLE_IDENTIFIER
    }

    override fun getHostInfo(): String {
        return HOST_INFO
    }

    override fun getHostKey(): String {
        return HOST_KEY
    }
}

Once the SDK installation is complete, proceed to the implementation by reading the following Usage and Integration Guide:

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.

Usage and Integration Guide

In this section, you will find all the necessary information for using and integrating the Unico IDCloud platform SDK into your Android applications

Selfie Capture

In this section, you will find all the necessary information for using and integrating the Unico IDCloud platform SDK into your Android applications for selfie capture

This guide has been designed to help you quickly and easily implement the Android SDK. Below, you'll find the step-by-step process for the complete integration. If you wish to customize the experience further, check out the Android Customization section.

Initializing the SDK

Create an instance of the builder (generated through the IAcessoBioBuilder interface), providing the relevant context and implementing the AcessoBioListener class. The implementation of this class is straightforward and can be achieved with just a few lines of code. Simply instantiate the builder with the relevant context and override 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)
}

Environment configuration

Configure the environment that will be used to run the SDK. Use the enumerated environment that contains the following enumerates:

Environment.PROD: for production environment;
Environment.UAT: for approval environment.

See how to implement it in the example below:

acessoBioBuilder.setEnvironment(Environment.UAT);

acessoBioBuilder.setEnvironment(Environment.UAT);

Implementing Callback Functions

Note that implementing the AcessoBioListener class is largely about setting up callback methods. Each method is triggered in a specific SDK return scenario. Override the methods exemplified above with your application’s business logic.

onErrorAcessoBio(ErrorBio errorBio)

This method is invoked whenever any implementation error occurs using any SDK method. It receives an ErrorBio parameter that contains error details. See the Error Handling section for more about ErrorBio.

onUserClosedCameraManually()

This method is invoked when the user manually closes the camera, such as by clicking the "Back" button.

onSystemClosedCameraTimeoutSession()

This method is invoked when the maximum session time is reached (without capturing an image).

You can configure the session timeout in seconds using setTimeoutSession. The default and minimum timeout is 40 seconds.

onSystemChangedTypeCameraTimeoutFaceInference()

This method is invoked when the maximum time for face detection is reached without detection.

The maximum time is 13 seconds. The mode is then switched to manual capture to facilitate the user’s action.

All the above methods must be created as indicated in your project (even without any logic); otherwise, the project won’t compile successfully.

Configuring Camera Mode

The SDK is preconfigured with intelligent framing and automatic capture. Configure the camera mode in the builder as follows:

UnicoCheckCamera unicoCheckCamera = acessoBioBuilder
    .setAutoCapture(true)
    .setSmartFrame(true)
    .build();

val unicoCheckCamera: UnicoCheckCamera = acessoBioBuilder
    .setAutoCapture(true)
    .setSmartFrame(true)
    .build()

The false/true values in the above methods do not alter the capture experience; they are solely used for the SDK's internal logic.

Implementing Listeners for Camera Events

Implement these listener methods using an instance of the iAcessoBioSelfie class

The camera opening method, which is called in the next step, needs to know what to do when an image is successfully captured or if an error occurs in the process. You must specify "what to do" in the camera opening method by implementing listeners, which are triggered in success or error situations.

Through listener configuration, you can define what happens in your app in cases of an error (onErrorSelfie method) or success (onSuccessSelfie method) when capturing images.

To configure the listeners, you need to implement:

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

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

`onSucessSelfie` Method

Upon successful image capture, this method returns a ResultCamera object for subsequent API requests:

public void onSuccessSelfie(ResultCamera result) { }

The ResultCamera object provides two attributes: base64 and encrypted:

Use base64 for preview in the app;
Use encrypted for sending to REST APIs.

The encrypted attribute is strictly intended for sending the image through the by Client APIs. It should not be opened or serialized, as its characteristics may change without prior notice. Its use must be exclusive to interactions with the APIs to ensure the integrity and security of the data. Unico is not responsible for any damages arising from this practice, as modifications may occur unexpectedly.
The base64 and encrypted files can vary in size due to several factors, including the quality of the devices and the photos generated, as well as Unico's business rules. To avoid issues in your application, do not restrict the size of the string generated by the SDK for these files in your programming logic or infrastructure.

If it is necessary to convert the base64 string to a bitmap, the standard method does not work for Android. You need to perform a split at the comma (,) for it to function correctly. If you want to learn more, read the article: How to convert a Base64 string into a Bitmap image to show it in a ImageView?.

`onErrorSelfie` Method

If an error occurs during image capture, this method returns an ErrorBio object

public void onErrorSelfie(ErrorBio errorBio) { }

Learn more about ErrorBio types in the SDK Error Handling section.

Preparing and Opening the Camera

The openCameraSelfie method is used to open the camera. This method receives as a parameter the implementation of the UnicoSelfie class and the JSON with the credentials, generated in the step above.

The following example illustrates the steps for configuring listeners and opening the camera:

_opener.openCameraSelfie(jsonFileName: androidJsonFileName, listener: this)

Making a POST Request to the Client API

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

For security reasons, the interval between the generation of the encrypted data and the sending through one of the available flows must be no more than 10 minutes. Submissions made beyond this period will be automatically rejected by the API.

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.

Document Capture

In this section, you will find all the necessary information for using and integrating the Unico IDCloud SDK into your Android applications for 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.

The SDK does not perform any validation of what is being captured.

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.

onErrorAcessoBio(ErrorBio errorBio)

This method is invoked with a parameter of type ErrorBio that contains details about the error. Learn more about the ErrorBio type in the error handling section.

onUserClosedCameraManually()

This method is invoked whenever the user manually closes the camera, such as by clicking the "Back" button.

onSystemClosedCameraTimeoutSession()

This method is invoked once the maximum session time is reached (without capturing any image).

You can configure the session timeout in seconds using setTimeoutSession. The default and minimum timeout is 40 seconds.

onSystemChangedTypeCameraTimeoutFaceInference()

This method is invoked when the maximum time for face detection is reached without detection.

The maximum time is 13 seconds. The mode is then switched to manual capture to facilitate the user’s action.

All the above methods must be created as indicated in your project (even without any logic); otherwise, the project won’t compile successfully.

Implementing Listeners for Camera Events

The implementation of these listener methods should be done through an instance of the iAcessoBioSelfie class.

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

Learn more about the types of ErrorBio in the SDK's error handling section.

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:

If you need to capture a document for which there is no specific frame (e.g., RNE, among others), use the DocumentCameraType.None frame, which will allow you to use a generic rectangular frame to guide any capture.

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.

Error Handling Guide

In this section, you will find all the necessary information for handling errors from the Unico IDCloud SDK in your Android applications

`ErrorBio` Object

This object is returned whenever an error occurs in the Android SDK.

Available Methods

Method Name

Description

Below is a list of possible error codes from the Android SDK:

Code

Description

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.

Android Customization

In this section, you will find all the information necessary for customizing the SDK of the Unico IDCloud platform in your Android applications

The Android SDK allows for some customizations to be made. Below are all the possible customizations for this SDK.

Customize Language

It is possible to configure the experience of the informational messages in the capture frames by changing their language. Use the enumerated type LocaleTypes, which contains the following values:

LocaleTypes.PT_BR: for Portuguese(Brazil);
LocaleTypes.ES_MX: for Spanish(Mexico);
LocaleTypes.ES_ES: for Spanish(Spain);
LocaleTypes.EN_US: for English(USA).

See how to implement it in the example below:

unicoCheck.setLocale(LocaleTypes.EN_US);

unicoCheck.setLocale(LocaleTypes.EN_US);

A remote activation may be required to be used, if you wish to use it, notify your project manager or Unico support.
If not configured, the SDK will use Portuguese as the default language.

Customize Capture Process Experience

Customize Selfie Capture Experience

This is an optional step, but it is highly recommended to give the capture process the visual identity of your company. You can customize some objects in the frame according to the camera mode used through the setTheme() method.

The supported types for color representation are Color Resource or a String containing the hexadecimal color code. E.g., R.color.red or #FF0000.

All methods are available below:

IAcessoBioTheme unicoTheme = new IAcessoBioTheme() {
    @Override
    public Object getColorBackground() { 
        return R.color.your_color;
    }

    @Override
    public Object getColorBoxMessage() { 
        return R.color.your_color;
    }

    @Override
    public Object getColorTextMessage() { 
        return R.color.your_color;
    }

    @Override
    public Object getColorBackgroundPopupError() { 
        return R.color.your_color;
    }

    @Override
    public Object getColorTextPopupError() { 
        return R.color.your_color;
    }

    @Override
    public Object getColorBackgroundButtonPopupError() { 
        return R.color.your_color;
    }

    @Override
    public Object getColorTextButtonPopupError() { 
        return R.color.your_color;
    }

    @Override
    public Object getColorBackgroundTakePictureButton() { 
        return R.color.your_color;
    }

    @Override
    public Object getColorIconTakePictureButton() { 
        return R.color.your_color;
    }

    @Override
    public Object getColorBackgroundBottomDocument() { 
        return R.color.your_color;
    }

    @Override
    public Object getColorTextBottomDocument() { 
        return R.color.your_color;
    }

    @Override
    public Object getColorSilhouetteSuccess() { 
        return R.color.your_color;
    }

    @Override
    public Object getColorSilhouetteError() { 
        return R.color.your_color;
    }

    @Override
    public Object getColorProgressBar() { 
        return R.color.your_color;
    }
};
    
acessoBioBuilder.setTheme(unicoTheme);

val unicoTheme = object: IAcessoBioTheme {

    override fun getColorBackground() = R.color.your_color
    override fun getColorBoxMessage() = R.color.your_color
    override fun getColorTextMessage() = R.color.your_color
    override fun getColorBackgroundPopupError() = R.color.your_color
    override fun getColorTextPopupError() = R.color.your_color
    override fun getColorBackgroundButtonPopupError() = R.color.your_color
    override fun getColorTextButtonPopupError() = R.color.your_color
    override fun getColorBackgroundTakePictureButton() = R.color.your_color
    override fun getColorIconTakePictureButton() = R.color.your_color
    override fun getColorBackgroundBottomDocument() = R.color.your_color
    override fun getColorTextBottomDocument() = R.color.your_color
    override fun getColorSilhouetteSuccess() = R.color.your_color
    override fun getColorSilhouetteError() = R.color.your_color 
    override fun getColorSilhouetteNeutral() = R.color.your_color
    override fun getColorProgressBar() = R.color.your_color
}

acessoBioBuilder.setTheme(unicoTheme)

It is also possible to make static customizations. In your colors.xml file, add the following code:

<color name="unico_color_background"> #YourColor </color> 
<color name="unico_color_silhouette_success"> #YourColor </color> 
<color name="unico_color_silhouette_error"> #YourColor </color> 
<color name="unico_color_silhouette_neutral"> #YourColor </color> 
<color name="unico_color_box_message"> #YourColor </color> 
<color name="unico_color_text_message"> #YourColor </color> 
<color name="unico_color_background_popup_error"> #YourColor </color> 
<color name="unico_color_text_popup_error"> #YourColor </color> 
<color name="unico_color_background_button_popup_error"> #YourColor </color> 
<color name="unico_color_text_button_popup_error"> #YourColor </color> 
<color name="unico_color_background_take_picture_button"> #YourColor </color> 
<color name="unico_color_icon_take_picture_button"> #YourColor </color> 
<color name="unico_color_background_bottom_document"> #YourColor </color> 
<color name="unico_color_text_bottom_document"> #YourColor </color> 
<color name="unico_color_button_cancel"> #YourColor </color> 
<color name="unico_color_progress_bar_capture"> #YourColor </color>

Below, check the specification of the customization fields:

Customize Document Capture Experience

The supported types for color representation are Color Resource or a String containing the hexadecimal color code. E.g., R.color.red or #FF0000.

All methods are available below:

IAcessoBioTheme unicoTheme = new IAcessoBioTheme() {
    @Override
    public Object getColorBackground() { 
        return R.color.your_color;
    }
    @Override
    public Object getColorBoxMessage() { 
        return R.color.your_color;
    }
    @Override
    public Object getColorTextMessage() { 
        return R.color.your_color;
    }
    @Override
    public Object getColorBackgroundPopupError() { 
        return R.color.your_color;
    }
    @Override
    public Object getColorTextPopupError() { 
        return R.color.your_color;
    }
    @Override
    public Object getColorBackgroundButtonPopupError() { 
        return R.color.your_color;
    }
    @Override
    public Object getColorTextButtonPopupError() { 
        return R.color.your_color;
    }
    @Override
    public Object getColorBackgroundTakePictureButton() { 
        return R.color.your_color;
    }
    @Override
    public Object getColorIconTakePictureButton() { 
        return R.color.your_color;
    }
    @Override
    public Object getColorBackgroundBottomDocument() { 
        return R.color.your_color;
    }
    @Override
    public Object getColorTextBottomDocument() { 
        return R.color.your_color;
    }
    @Override
    public Object getColorSilhouetteSuccess() { 
        return R.color.your_color;
    }
    @Override
    public Object getColorSilhouetteError() { 
        return R.color.your_color;
    }

    @Override
    public Object getColorProgressBar() { 
        return R.color.your_color;
    }
};
    
acessoBioBuilder.setTheme(unicoTheme);

val unicoTheme = object: IAcessoBioTheme {
    override fun getColorBackground() = R.color.your_color
    override fun getColorBoxMessage() = R.color.your_color
    override fun getColorTextMessage() = R.color.your_color
    override fun getColorBackgroundPopupError() = R.color.your_color
    override fun getColorTextPopupError() = R.color.your_color
    override fun getColorBackgroundButtonPopupError() = R.color.your_color
    override fun getColorTextButtonPopupError() = R.color.your_color
    override fun getColorBackgroundTakePictureButton() = R.color.your_color
    override fun getColorIconTakePictureButton() = R.color.your_color
    override fun getColorBackgroundBottomDocument() = R.color.your_color
    override fun getColorTextBottomDocument() = R.color.your_color
    override fun getColorSilhouetteSuccess() = R.color.your_color
    override fun getColorSilhouetteError() = R.color.your_color
    override fun getColorSilhouetteNeutral() = R.color.your_color
    override fun getColorProgressBar() = R.color.your_color
}
acessoBioBuilder.setTheme(unicoTheme)

It is also possible to make static customizations. In your colors.xml file, add the following code:

<color name="unico_color_background"> #YourColor </color> 
<color name="unico_color_silhouette_success"> #YourColor </color> 
<color name="unico_color_silhouette_error"> #YourColor </color> 
<color name="unico_color_silhouette_neutral"> #YourColor </color> 
<color name="unico_color_box_message"> #YourColor </color> 
<color name="unico_color_text_message"> #YourColor </color> 
<color name="unico_color_background_popup_error"> #YourColor 
<color name="unico_color_text_popup_error"> #YourColor </color> 
<color name="unico_color_background_button_popup_error"> #YourColor 
<color name="unico_color_text_button_popup_error"> #YourColor </color> 
<color name="unico_color_background_take_picture_button"> #YourColor </color> 
<color name="unico_color_icon_take_picture_button"> #YourColor </color> 
<color name="unico_color_background_bottom_document"> #YourColor </color> 
<color name="unico_color_text_bottom_document"> #YourColor </color> 
<color name="unico_color_button_cancel"> #YourColor </color> 
<color name="unico_color_progress_bar_capture"> #YourColor </color>

Below, check the specification of the customization fields:

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.

Troubleshooting

In this section, you will find solutions to some common issues encountered during the integration of the Unico IDCloud SDK into your Android applications

Code Obfuscation

The obfuscation material aims to assist developers in navigating obfuscation issues in their applications. The client's obfuscator can affect the SDK's functionality; therefore, it is essential that it does not obfuscate the SDK code. Unico disclaims any responsibility regarding obfuscation conflicts with the SDK.

Obfuscation is a process of transforming bytecode into a form that is less readable to humans, thereby making reverse engineering more difficult. This process involves removing debugging-related information such as variable tables, line numbers, and renaming packages, classes, and methods. When integrating the Android SDK into an application, failures may occur.

Obfuscation via DexGuard

When obfuscation is performed using DexGuard, if a failure occurs, use the following rules:

-keep class kotlin.coroutines.**
-keep class kotlinx.coroutines.**

-keep class com.facetec.sdk.** { *; }
-keep class com.acesso.acessobio_android.** { *; }
-keep class io.unico.** { *; }

-keep class br.com.makrosystems.haven.** { *; }
-keep class HavenSDK.**{ *; }
-keep class HavenSDK** { *; }

Obfuscation via ProGuard

When obfuscation is performed using ProGuard, if a failure occurs, use the following rules:

-keep class kotlin.coroutines.**
-keep class kotlinx.coroutines.**

-keep class com.facetec.sdk.** { *; }
-keep class com.acesso.acessobio_android.** { *; }
-keep class io.unico.** { *; }

-keep class br.com.makrosystems.haven.** { *; }
-keep class HavenSDK.**{ *; }
-keep class HavenSDK** { *; }

SDK Update - Version 4.3.x

Starting from version 4.4.x of the SDK, Unico began using its own Maven repository to distribute the Android SDK and changed the SDK dependency name, in addition to adjustments to ProGuard and DexGuard rules for clients using the GuardSquare library, as described in the Code Obfuscation section above.

Update the Maven Repository:

Change the Maven repository to the new repository in the project’s build.gradle file. The implementation was previously done as follows:

build.gradle

// Top-level build file where you can add configuration options common to all sub-projects/modules.
allprojects {
    repositories {
        google()
        jcenter()
        maven { url 'https://jitpack.io'}
    }
}

It should now be updated to the new repository:

build.gradle

// Top-level build file where you can add configuration options common to all sub-projects/modules.
allprojects {
    repositories {
        google()
        jcenter()
        maven { 
            url "https://maven-sdk.unico.run/sdk-mobile" 
        }
    }
}

Change the SDK Dependency

Update the SDK dependency to the new dependency in the project’s app/build.gradle file. The implementation was previously done as follows:

app/build.gradle

/* unico */
dependencies {
    implementation 'com.github.acesso-io:acessobio-android:$version'
}

It should now be updated to the new dependency:

app/build.gradle

/* unico */
dependencies {
    implementation "io.unico:capture:$version"
}

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.

Release notes

In this section, you will find all the updates for the Unico IDCloud Android SDK

Keep your Android SDK always up to date with the latest available version. Semantic versioning is used to number the versions. For more information, please refer to the article Overview.

Version 5.26.0 - 11/21/2024

Update SDK and Server version of Liveness with interaction.

Version 5.25.0 - 11/04/2024

Update SDK and Server version of Liveness with interaction.

Version 5.24.0 - 10/17/2024

SDK Update and Liveness Server Interaction;
Internal Improvements.

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.

iOS SDK

In this section, you will find all the necessary information to implement the Unico IDCloud platform's iOS SDK

Installation Guide

In this section, you will find all the information needed to install the Unico IDCloud platform SDK in your iOS applications

Development Environment Preconditions

Ensure your development environment meets the following preconditions:

The capture component provided by the iOS SDK is compatible with all devices running iOS 11 or later. You can check the list of compatible devices on Apple’s official support channels.

Installing the iOS SDK

To integrate the Unico IDCloud iOS SDK into your iOS app, follow the steps below:

Using CocoaPods

CocoaPods is a dependency manager for Cocoa projects. For usage and installation instructions, refer to the official CocoaPods documentation. To integrate the iOS SDK into your Xcode project with CocoaPods, follow these steps:

Add unicocheck-ios to your Podfile:

podfile

pod ‘unicocheck-ios’

Run the following command in your terminal to install the dependencies:

pod install

If you are running the project in .xcodeproj, you must open it in .xcworkspace.

Using Swift Package Manager (SPM)

Swift Package Manager is a dependency manager for Swift projects. It integrates with the Swift build system to automate the downloading, compiling, and linking of dependencies. To integrate the iOS SDK into your project with SPM, follow these steps:

Add the dependency to your Package.swift file:

Package.swift

<uses-dependencies: [
    .package(url: "https://github.com/acesso-io/unico-check-ios.git", .upToNextMajor(from: "2.12.0"))
]

Camera Usage Permissions

To use the camera-opening method in your project, add the necessary permissions before compiling your application:

Info.plist

<key>NSCameraUsageDescription</key>
<string>Camera usage description</string>

Obtaining Credentials

Contact the CSs and/or Onboarding team.
Request the SDK Key by entering the identifiers of your applications. Bundle Identifier for iOS, PackageID for Android and Host for WEB.
The identifiers of your applications will be linked to the SDK Key by the Unico team.
You receive your SDK Key to implement the AccessBioConfigDataSource.

Embedding the Credentials in Your Project

Implement the AcessoBioConfigDataSource protocol in your class:

.h:
#import <AcessoBio/AcessoBioManager.h>
#import <AcessoBio/AcessoBio-Swift.h>

@interface YourUnicoConfigClass: AcessoBioConfigDataSource {}
@end

.m:
@implementation YourUnicoConfigClass

- (NSString * _Nonnull)getBundleIdentifier {
    return @"<YOUR_MOBILE_BUNDLE_IDENTIFIER>";
}

- (NSString * _Nonnull)getHostKey {
    return @"<YOUR_SDK_KEY>";
}

@end

import AcessoBio

class YourUnicoConfigClass: AcessoBioConfigDataSource {
          
    func getBundleIdentifier() -> String {
        return "<YOUR_MOBILE_BUNDLE_IDENTIFIER>"
    }
        
    func getHostKey() -> String {
        return "<YOUR_SDK_KEY>"
    }
}

Deprecated Method - Objective-C

.h:
#import <AcessoBio/AcessoBioManager.h>
#import <AcessoBio/AcessoBio-Swift.h>

@interface YourUnicoConfigClass: AcessoBioConfigDataSource {}
@end

.m:
@implementation YourUnicoConfigClass

- (NSString * _Nonnull)getBundleIdentifier {
    return @"<YOUR_MOBILE_BUNDLE_IDENTIFIER>";
}

- (NSString * _Nonnull)getHostInfo {
    return @"<YOUR_HOST_INFO>";
}

- (NSString * _Nonnull)getHostKey {
    return @"<YOUR_HOST_KEY>";
}

- (NSString * _Nonnull)getMobileSdkAppId {
    return @"<YOUR_MOBILE_SDK_APP_ID>";
}

- (NSString * _Nonnull)getProjectId {
    return @"<YOUR_PROJECT_ID>";
}

- (NSString * _Nonnull)getProjectNumber {
    return @"<YOUR_PROJECT_NUMBER>";
}

@end

Deprecated Method - Swift

import AcessoBio

class YourUnicoConfigClass: AcessoBioConfigDataSource {
        
    func getProjectNumber() -> String {
        return "<YOUR_PROJECT_NUMBER>"
    }
    
    func getProjectId() -> String {
        return "<YOUR_PROJECT_ID>"
    }
    
    func getMobileSdkAppId() -> String {
        return "<YOUR_MOBILE_SDK_APP_ID>"
    }
    
    func getBundleIdentifier() -> String {
        eturn "<YOUR_MOBILE_BUNDLE_IDENTIFIER>"
    }
    
    func getHostInfo() -> String {
        return "<YOUR_HOST_INFO>"
    }
    
    func getHostKey() -> String {
        return "<YOUR_HOST_KEY>"
    }
}

Once the SDK installation is complete, proceed to the implementation by reading the following Usage and Integration Guide:

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.

Usage and Integration Guide

In this section, you will find all the necessary information for using and integrating the Unico IDCloud platform SDK into your iOS applications

Selfie Capture

In this section, you will find all the necessary information for using and integrating the Unico IDCloud platform SDK into your iOS applications for selfie capture

Initializing the SDK

To get started with the Unico Check iOS SDK, import the SDK and implement the AcessoBioManagerDelegate interface within the ViewController you want to use. The implementation of this class is straightforward and can be done with just a few lines of code.

All you need to do is instantiate the builder with the relevant context and override the callback methods with your application’s business logic:

.m:
#import "ViewController.h"
#import <AcessoBio/AcessoBio.h>

@implementation ViewController: UIViewController
- (void)viewDidLoad {
    [super viewDidLoad];  
    unicoCheck = [[AcessoBioManager alloc]initWithViewController:self];
}

- (void)onErrorAcessoBioManager:(ErrorBio *)error {
  // your code
}

- (void)onSystemChangedTypeCameraTimeoutFaceInference {
  // your code
}

- (void)onSystemClosedCameraTimeoutSession {
  // your code
}

- (void)onUserClosedCameraManually {
  // your code
}
@end

import UIKit
import AcessoBio

class ViewController: UIViewController, AcessoBioManagerDelegate {
  var unicoCheck: AcessoBioManager!

  override func viewDidLoad() {
    super.viewDidLoad()      
    unicoCheck = AcessoBioManager(viewController: self)
  }

  func onErrorAcessoBioManager(_ error: ErrorBio!) {
      // your code
  }

  func onUserClosedCameraManually() {
      // your code
  }

  func onSystemClosedCameraTimeoutSession() {
      // your code
  }

  func onSystemChangedTypeCameraTimeoutFaceInference() {
      // your code 
  }
}

Environment configuration

Configure the environment that will be used to run the SDK. Use the enumerated environment that contains the following enumerates:

PROD: for production environment;
UAT: for approval environment.

See how to implement it in the example below:

  [unicoCheck setEnvironment:UAT];

 unicoCheck.setEnvironment(.UAT);

Implementing the Callback Functions

As shown in the previous example, the main task when implementing the AcessoBioManagerDelegate interface is configuring the callback methods. Each method is called in response to a specific return from the SDK.

Simply override the methods illustrated in the previous step with your application’s business logic:

onErrorAcessoBioManager(_ error: ErrorBio!)

onUserClosedCameraManually()

This method is invoked when the user manually closes the camera, such as by clicking the "Back" button.

onSystemClosedCameraTimeoutSession()

This method is invoked when the maximum session time is reached (without capturing an image).

You can configure the session timeout in seconds using setTimeoutSession. The default and minimum timeout is 40 seconds.

onSystemChangedTypeCameraTimeoutFaceInference()

This method is invoked when the maximum time for face detection is reached without detection.

The maximum time is 13 seconds. The mode is then switched to manual capture to facilitate the user’s action.

All the above methods must be created as indicated in your project (even without any logic); otherwise, the project won’t compile successfully.

Configuring Camera Mode

The SDK is preconfigured with intelligent framing and automatic capture. Configure the camera mode in the builder as follows:

.m:
- (IBAction)configureSmartCamera:(UIButton *)sender {
   [unicoCheck setSmartFrame:true];
   [unicoCheck setAutoCapture:true];
}

@IBAction func configureSmartCamera(_ sender: Any) {
    unicoCheck.setSmartFrame(true)
    unicoCheck.setAutoCapture(true)    
}

The false/true values in the above methods do not alter the capture experience; they are solely used for the SDK's internal logic.

Implementing Delegates for Camera Events

The camera launch method needs to know how to handle situations when an image is successfully captured or when an error occurs during the process. The handling instructions are passed to the camera launch method by setting delegates, which are called in cases of success or error.

Through delegate configuration, you can specify what actions your app should take in the event of an error (using the onErrorSelfie method) or success (using the onSuccessSelfie method) in capturing images.

To set up the delegates, you must implement the SelfieCameraDelegate and AcessoBioSelfieDelegate interfaces:

.h:
#import <UIKit/UIKit.h>
#import <AcessoBio/AcessoBio.h>
#import "SelfieCameraDelegate.h"

@interface ViewController: UIViewController <AcessoBioManagerDelegate, SelfieCameraDelegate,
   AcessoBioSelfieDelegate> {
  AcessoBioManager *unicoCheck;
  // Your code from previous and next steps here
}

import UIKit
import AcessoBio

class ViewController: UIViewController, AcessoBioManagerDelegate,
                      SelfieCameraDelegate, AcessoBioSelfieDelegate {    
  //Your code from previous and next steps here
}

`onSuccessSelfie` Method

Upon successful image capture, this method returns a SelfieResult object for subsequent API requests:

- (void)onSuccessSelfie:(SelfieResult *)result {
    NSLog(@"%@", result.base64);
}

func onSuccessSelfie(_ result: AcessoBio.SelfieResult!) {
    // Your code
 }

The SelfieResult object provides two attributes: base64 and encrypted:

Use base64 for preview in the app;
Use encrypted for sending to REST APIs.

The encrypted attribute is strictly intended for sending the image through the by Client APIs. It should not be opened or serialized, as its characteristics may change without prior notice. Its use must be exclusive to interactions with the APIs to ensure the integrity and security of the data. Unico is not responsible for any damages arising from this practice, as modifications may occur unexpectedly.
The base64 and encrypted files can vary in size due to several factors, including the quality of the devices and the photos generated, as well as Unico's business rules. To avoid issues in your application, do not restrict the size of the string generated by the SDK for these files in your programming logic or infrastructure.

If it is necessary to convert the base64 string to a bitmap, the standard method does not work for Android. You need to perform a split at the comma (,) for it to function correctly. If you want to learn more, read the article:How to convert a Base64 string into a Bitmap image to show it in a ImageView?.

`onErrorSelfie` Method

If an error occurs during image capture, this method returns an ErrorBio object:

- (void)onErrorSelfie:(ErrorBio *)errorBio {
  // Your code
}

func onErrorSelfie(_ errorBio: ErrorBio!) {
  // Your code
 }

Learn more about ErrorBio types in the SDK Error Handling section.

Environment Configuration

If not configured, the SDK will use the environment set in the configuration file (getHostKey). If getHostKey is not being used, an error will be returned.

You can configure the environment to be used during SDK execution by using the EnvironmentEnum enumeration, which contains the following options:

EnvironmentEnum.PROD: for the Production environment
EnvironmentEnum.UAT: for the Testing (UAT) environment

See the implementation example below:

[unicoCheck setEnvironment:PROD];

unicoCheck.setEnvironment(.PROD);

Prepare and Open Camera

To proceed with opening the camera, you must first prepare it using the prepareSelfieCamera method. This method takes two parameters: the implementation of the SelfieCameraDelegate class and the JSON with the credentials generated in the previous step.

.h:
#import <UIKit/UIKit.h>
#import <AcessoBio/AcessoBio.h>
#import "SelfieCameraDelegate.h"

@interface ViewController: UIViewController <AcessoBioManagerDelegate,
SelfieCameraDelegate, AcessoBioSelfieDelegate> {
    AcessoBioManager *unicoCheck;
}

.m:
- (IBAction)openCamera:(UIButton *)sender {
    [[unicoCheck build] prepareSelfieCamera:self config:[YourUnicoConfigClass new]];
}

import UIKit
import AcessoBio

class ViewController: UIViewController, AcessoBioManagerDelegate,
  SelfieCameraDelegate, AcessoBioSelfieDelegate {
    @IBAction func openCamera(_ sender: Any) {
        unicoCheck.build().prepareSelfieCamera(self, config: YourUnicoConfigClass())
    }
}

When the camera is prepared, the onCameraReady event is triggered, receiving an object of type AcessoBioCameraOpenerDelegate as a parameter. You should override this method to open the camera using the object received through the open() method:

- (void)onCameraReady:(id)cameraOpener {
    [cameraOpener open:self];
}

- (void)onCameraFailed:(ErrorPrepare *)message {
    // Your code
}

func onCameraReady(_ cameraOpener: AcessoBioCameraOpenerDelegate!) {
    cameraOpener.open(self)
 }
 
func onCameraFailed(_ message: ErrorPrepare!) {
    // Your code
 }

The ErrorPrepare type is an extension of ErrorBio, containing all of its properties. Learn more about the ErrorBio type in the SDK error handling section.

If an error occurs while preparing the camera, the onCameraFailed event is triggered. You should implement this method according to your app's business logic.

Making a POST Request to the Client API

After capturing images, the next step is to send the generated encrypted 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.

Document Capture

In this section, you will find all the necessary information for using and integrating the Unico IDCloud SDK into your iOS applications for document capture

Available Document Frames

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

The SDK does not perform any type of validation on what is being captured.

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

RG: Capture of the RG (separate front and back).
CNH: Capture of the CNH opened.
CNH Front: Capture of the front of the CNH.
CNH Back: Capture of the back of the CNH.
CPF: Capture of the CPF document.
Without Silhouette: Capture of a generic document.

Initializing the SDK

To get started with the Unico IDCloud iOS SDK, import the SDK and implement the AcessoBioManagerDelegate interface in the ViewController you wish to use. The implementation of this class is straightforward and can be done with just a few lines of code. All you need to do is instantiate the builder while providing the appropriate context and override the callback methods with the business logic of your application.

.m:
#import "ViewController.h"
#import <AcessoBio/AcessoBio.h>

@interface ViewController ()
@end

@implementation ViewController
- (void)viewDidLoad {
    [super viewDidLoad];   
    unicoCheck = [[AcessoBioManager alloc]initWithViewController:self];
}
   
- (void)onErrorAcessoBioManager:(ErrorBio *)error {
  // Your code
}

- (void)onSystemChangedTypeCameraTimeoutFaceInference {
  // Your code
}

- (void)onSystemClosedCameraTimeoutSession {
  // Your code
}

- (void)onUserClosedCameraManually {
  // Your code
}

@end

import UIKit
import AcessoBio

class ViewController: UIViewController, AcessoBioManagerDelegate {
  var unicoCheck: AcessoBioManager!

  override func viewDidLoad() {
    super.viewDidLoad()
    
    unicoCheck = AcessoBioManager(viewController: self)
  }

  func onErrorAcessoBioManager(_ error: ErrorBio!) {
    // Your code
  }

  func onUserClosedCameraManually() {
    // Your code
  }

  func onSystemClosedCameraTimeoutSession() {
    // Your code
  }

  func onSystemChangedTypeCameraTimeoutFaceInference() {
    // Your code
  }
}

Implementing Callback Functions

Note that, as in the previous example, the implementation work for the AcessoBioManagerDelegate interface mainly involves configuring the callback methods. Each method is called in a specific situation based on the SDK's return status.

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

onErrorAcessoBioManager(_ error: ErrorBio!)

onUserClosedCameraManually()

This method is invoked when the user manually closes the camera, such as by clicking the "Back" button.

onSystemClosedCameraTimeoutSession()

This method is invoked when the maximum session time is reached (without capturing an image).

You can configure the session timeout in seconds using setTimeoutSession. The default and minimum timeout is 40 seconds.

onSystemChangedTypeCameraTimeoutFaceInference()

This method is invoked when the maximum time for face detection is reached without detection.

The maximum time is 13 seconds. The mode is then switched to manual capture to facilitate the user’s action.

All the above methods must be created as indicated in your project (even without any logic); otherwise, the project won’t compile successfully.

Implementing Delegates for Camera Events

The method to open the camera (which is called in the next step) needs to know what to do when an image is successfully captured or if there is an error in the process. You specify "what to do" to the camera opening method through the configuration of delegates that are invoked in success or error situations.

By configuring the delegates, you can define the behavior of your app in case of an error (using the onErrorDocument method) or success (using the onSuccessDocument method) during image capture.

To set up the delegates, you should implement the DocumentCameraDelegate and AcessoBioDocumentDelegate interfaces:

.h:
#import <UIKit/UIKit.h>
#import <AcessoBio/AcessoBio.h>
#import "SelfieCameraDelegate.h"

@interface ViewController: UIViewController <AcessoBioManagerDelegate, DocumentCameraDelegate, 
  AcessoBioDocumentDelegate> {
  AcessoBioManager *unicoCheck;
  // Your code from previous and next steps here
}

import UIKit
import AcessoBio

class ViewController: UIViewController, AcessoBioManagerDelegate, DocumentCameraDelegate, 
  AcessoBioDocumentDelegate {    
  // Your code from previous and next steps here
}

`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:

- (void)onSuccessDocument:(DocumentResult *)result {
    NSLog(@"%@", result.base64);
}

func onSuccessDocument(_ result: DocumentResult!) {
    // Your code
 }

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.

If it is necessary to convert the base64 string to a bitmap, the standard method does not work for Android. You need to perform a split at the comma (,) for it to function correctly. If you want to learn more, read the article:How to convert a Base64 string into a Bitmap image to show it in a ImageView?.

Método `onErrorDocument`

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

- (void)onErrorDocument:(ErrorBio *)errorBio {
    // Your code
}

func onErrorDocument(_ errorBio: ErrorBio!) {
    // Your code
 }

Learn more about the types of ErrorBio in the SDK's error handling section.

Preparing and Opening the Camera

To open the camera, it is necessary to prepare it using the prepareDocumentCamera method. This method takes as parameters the implementation of the DocumentCameraDelegate class and the JSON with the credentials, generated in the previous step.

.h:
#import <UIKit/UIKit.h>
#import <AcessoBio/AcessoBio.h>
#import "SelfieCameraDelegate.h"

@interface ViewController: UIViewController < AcessoBioManagerDelegate,
DocumentCameraDelegate, AcessoBioDocumentDelegate> {
    AcessoBioManager *unicoCheck;
}

.m:
- (IBAction)openCamera:(UIButton *)sender {
    [[unicoCheck build] prepareDocumentCamera:self config:[YourUnicoConfigClass new]];
}

import UIKit
import AcessoBio

class ViewController: UIViewController, AcessoBioManagerDelegate, 
DocumentCameraDelegate, AcessoBioDocumentDelegate {
    @IBAction func openCamera(_ sender: Any) {
        unicoCheck.build().prepareDocumentCamera(self, config: YourUnicoConfigClass())
    }
}

When the camera is ready, the onCameraReadyDocument event is triggered, which receives a parameter of type AcessoBioCameraOpenerDelegate. You should override this method to open the camera using the object received through the openDocument() method, receiving the parameters for the type of document to be captured, which are:

If you need to capture a document for which there is no specific frame (e.g., RNE, among others), use the DocumentEnums.none frame, which will allow you to use a generic rectangular frame to guide any capture.

The delegates implemented above (described here as Self):

- (void)onCameraReadyDocument:(id)cameraOpener {
    [cameraOpener openDocument:DocumentCNH delegate:self];
}

- (void)onCameraFailedDocument:(ErrorPrepare *)message {
  // Your code
}

func onCameraReadyDocument(_ cameraOpener: AcessoBioCameraOpenerDelegate!) {
    cameraOpener.openDocument(DocumentEnums.CNH, delegate: self)
}
 
func onCameraFailedDocument(_ message: ErrorPrepare!) {
  // Your code
}

The ErrorPrepare type is an extension of ErrorBio, thus containing all its properties. Learn more about the ErrorBio type in the error handling section of the SDK.

If an error occurs while preparing the camera, the onCameraFailedDocument event is triggered. You should implement this method according to your app's business logic. In case of success, the onSuccessDocument event is triggered, as explained in the section above.

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.

Error Handling Guide

In this section, you will find all the necessary information for handling errors from the Unico IDCloud SDK in your Android applications

`ErrorBio` Object

This object is returned whenever an error occurs in the iOS SDK.

Available Methods

Method Name

Description

Below is a list of possible error codes from the iOS SDK:

Code

Description

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.

iOS Customization

In this section, you will find all the information necessary for customizing the SDK of the Unico IDCloud platform in your Android applications

The Android SDK allows for some customizations to be made. Below are all the possible customizations for this SDK.

Customize Language

It is possible to configure the experience of the informational messages in the capture frames by changing their language. Use the enumerated type LocaleTypes, which contains the following values:

LocaleTypes.PT_BR: for Portuguese(Brazil);
LocaleTypes.ES_MX: for Spanish(Mexico);
LocaleTypes.ES_ES: for Spanish(Spain);
LocaleTypes.EN_US: for English(USA).

See how to implement it in the example below:

[unicoCheck setLocale:EN_US];

unicoCheck.setLocale(.EN_US);

A remote activation may be required to be used, if you wish to use it, notify your project manager or Unico support.
If not configured, the SDK will use Portuguese as the default language.

Customize Capture Experience

Os tipos suportados para representação de cor são Color Resource ou String contendo o código hexadecimal da cor. Ex: R.color.red ou #FF0000.

All methods are available below:

Here are some examples of how you can use the above methods in your project:

.h:
#import "AcessoBioThemeDelegate.h"

@interface ViewController : UIViewController  {

@end

.m:
#import "ViewController.h"
#import <AcessoBio/AcessoBio.h>

@interface ViewController ()

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];

    unicoCheck = [[AcessoBioManager alloc]initWithViewController:self];
}

- (id)getColorBackground {
    code
}

- (id)getColorBackgroundBottomDocument {
    code
}

- (id)getColorBackgroundButtonPopupError {
    code
}

- (id)getColorBackgroundPopupError {
    code
}

- (id)getColorBackgroundTakePictureButton {
    code
}

- (id)getColorBoxMessage {
    code
}

- (id)getColorIconTakePictureButton {
    code
}

- (id)getColorSilhouetteError {
    code
}

- (id)getColorSilhouetteSuccess {
    code
}

- (id)getColorTextBottomDocument {
    code
}

- (id)getColorTextButtonPopupError {
    code
}

- (id)getColorTextMessage {
    code
}

- (id)getColorTextPopupError {
    code
}

- (id) getProgressBarColor {
    code
}

- (id) getCancelButtonIconColor {
    code
}

@end

import UIKit
import AcessoBio

class ViewController: UIViewController, AcessoBioManagerDelegate, AcessoBioThemeDelegate {

    var unicoCheck: AcessoBioManager!

    override func viewDidLoad() {
        super.viewDidLoad()
        
        unicoCheck = AcessoBioManager(viewController: self)
        unicoCheck.setTheme(self)
    }
 

    func getColorBackground() -> Any! {
        code
    }

    func getColorBoxMessage() -> Any! {
        code
    }

    func getColorTextMessage() -> Any! {
        code
    }

    func getColorBackgroundPopupError() -> Any! {
        code
    }

    func getColorTextPopupError() -> Any! {
        code
    }

    func getColorBackgroundButtonPopupError() -> Any! {
        code
    }

    func getColorTextButtonPopupError() -> Any! {
        code
    }

    func getColorBackgroundTakePictureButton() -> Any! {
        code
    }

    func getColorIconTakePictureButton() -> Any! {
        code
    }

    func getColorBackgroundBottomDocument() -> Any! {
        code
    }

    func getColorTextBottomDocument() -> Any! {
        code
    }

    func getColorSilhouetteSuccess() -> Any! {
        code
    }

    func getColorSilhouetteError() -> Any! {
        code
    } 

    func getProgressBarColor() -> Any! {
        code
    }

    func getCancelButtonIconColor() -> Any! {
        code
    }
}

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.

Troubleshooting

In this section, you will find solutions to some common issues encountered during the integration of the Unico IDCloud SDK into your iOS applications

Code Obfuscation

The obfuscation guide aims to help developers handle obfuscation issues in their applications. The client's obfuscator may affect the SDK's functionality, and it is necessary that it does not obfuscate the SDK's code. Unico is not responsible for any obfuscation conflicts with the SDK.

Obfuscation is the process of transforming bytecode into a less human-readable form, thus making reverse engineering more difficult. This process involves removing debug information, such as variable tables and line numbers, and renaming packages, classes, and methods. When embedding the Android SDK in an application, errors may occur.

Obfuscation via iXGuard

When using the iXGuard tool for obfuscation, we recommend version 4.11.0 or later.

Shadow at the End of Flow after Updating to Version 2.4.0

The responsibility for flow control is delegated to the caller of the SDK. Therefore, if a shadow appears or the screen does not close after successful capture, it is suggested to implement a way to release this screen. The release may vary according to the implemented navigation stack. To implement this, add the release method preferably within the delegate method onSuccessSelfie. Here are some release examples that can be used:

Bitcode Error in App Distribution using Xcode 16

After the official release of Xcode 16 on September 17, 2024, we identified an issue when using the SDK on the App Store that flags the use of bitcode in two internal dependencies when using CocoaPods as the dependency manager. These are DeviceProfiling and UnicoSdkLogger. To avoid blocking new releases, you can follow the steps below until a permanent fix is provided in a future SDK release:

Open the Podfile file.
Add the following lines after the post_install command (do |installer|) and before the last end:

2.1. If there is existing code, insert this snippet before it;

2.2. f bitcode removal is already done manually, explicitly add the paths listed in framework_paths;

If there is no post_install do |installer| command in the Podfile, add it as follows before the last end:

Release notes

In this section, you will find all the updates for the Unico IDCloud iOS SDK

Keep your iOS SDK always up to date with the latest available version. Semantic versioning is used to number the versions. For more information, please refer to the article Overview.

Version 2.16.4 - 10/16/2024

SDK Update and Liveness Server Interaction.

Starting with Xcode 15, Apple has dropped support for iOS 11. Unico will discontinue support for iOS 11 in the Unico Check iOS SDK in a future version.

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 .

Flutter SDK

Nesta seção, você encontrará todas as informações necessárias pra implementar o SDK Flutter da plataforma Unico IDCloud

Installation Guide

In this section, you will find all the information needed to install the Unico IDCloud platform SDK in your Flutter applications

Development Environment Preconditions

Ensure your development environment meets the following preconditions:

The capture component provided through the Flutter SDK supports versions equal to or higher for the following technologies:

Android: 5.0 (API 21);
iOS: 11.

Compatible Devices

This SDK does not function on emulators, it is only supported on physical devices.

iOS Devices:

iOS: It is compatible with almost all devices running iOS 11.

You can check the list of these devices on Apple's official support channels.

Android Devices:

It is compatible with the vast majority of devices running Android 5.0 (API level 21) or higher.

The table below lists the devices tested in the lab, along with the availability of vendor/manufacturer extensions. Some listed extensions may be subject to specific manufacturer APIs or SKUs. Click below to view the tested devices:

Installing the Flutter SDK

To implement the Unico IDCloud Flutter SDK in your Flutter application, follow the step-by-step instructions listed below:

Using the Flutter CLI

To add the Unico Check Flutter SDK to your project, run the following command using the Flutter CLI:

This command adds the following line to your package's pubspec.yaml file:

Obtaining Packages Manually: The flutter pub add unico_check command implicitly triggers the flutter pub get command. If the package was not installed correctly, ensure that unico_check is in your pubspec.yaml file and run flutter pub get manually.

Permissions for Camera and Internet Usage

To use the camera opening method in your project, you must add the permissions before compiling your application. Here’s an example:

Including the Dependency

After configuring the Android SDK, simply import it into your project. To do this, import the package in your Dart code:

Obtaining the Credentials

Contact the CSs and/or Onboarding team.
Request the SDK Key by entering the identifiers of your applications. Bundle Identifier for iOS, PackageID for Android and Host for WEB.
The identifiers of your applications will be linked to the SDK Key by the Unico team.
You receive your SDK Key to implement the AccessBioConfigDataSource.

Embedding the Credentials in Your Project

To configure the credentials in your project, simply pass the JSON file data as parameters when instantiating the UnicoCheck interface. The parameters should be sent as objects generated from the UnicoConfig method. Check the example below:

Deprecated Method - Dart

Once the SDK installation is complete, proceed to the implementation by reading the following Usage and Integration Guide:

Usage and Integration Guide

In this section, you will find all the necessary information for using and integrating the Unico IDCloud platform SDK into your Flutter applications

Selfie Capture

In this section, you will find all the necessary information for using and integrating the Unico IDCloud platform SDK into your Flutter applications for selfie capture

This guide has been designed to help you quickly and easily implement the Flutter SDK. Below, you'll find the step-by-step process for the complete integration. If you wish to customize the experience further, check out the Flutter Customization section.

Initializing the SDK

To get started, create an instance of the builder (generated through the UnicoCheckBuilder interface) by providing the relevant context and the implementation of the UnicoListener class as parameters. The implementation of this class is quite simple and can be done in just a few lines of code. All you need to do is override the callback methods with the business logic of your application.

Environment configuration

Configure the environment that will be used to run the SDK. Use the enumerated environment that contains the following enumerates:

UnicoEnvironment.PROD: for production environment;
UnicoEnvironment.UAT: for approval environment.

See how to implement it in the example below:

Implementing the Callback functions

onErrorUnico(UnicoError error)

onUserClosedCameraManually()

This method is invoked when the user manually closes the camera, such as by clicking the "Back" button.

onSystemClosedCameraTimeoutSession()

This method is invoked when the maximum session time is reached (without capturing an image).

You can configure the session timeout in seconds using setTimeoutSession. The default and minimum timeout is 40 seconds.

onSystemChangedTypeCameraTimeoutFaceInference()

This method is invoked when the maximum time for face detection is reached without detection.

The maximum time is 13 seconds. The mode is then switched to manual capture to facilitate the user’s action.

All the above methods must be created as indicated in your project (even without any logic); otherwise, the project won’t compile successfully.

Configuring Camera Mode

The SDK is preconfigured with intelligent framing and automatic capture. Configure the camera mode in the builder as follows:

The false/true values in the above methods do not alter the capture experience; they are solely used for the SDK's internal logic.

Implementing Listeners for Camera Events

mplement these listener methods using an instance of the UnicoSelfie class.

Through listener configuration, you can define what happens in your app in cases of an error (onErrorSelfie method) or success (onSuccessSelfie method) when capturing images.

`onSucessSelfie` Method

Upon successful image capture, this method returns a ResultCamera object for subsequent API requests:

The ResultCamera object provides two attributes: base64 and encrypted:

Use base64 for preview in the app;
Use encrypted for sending to REST APIs.

The encrypted attribute is strictly intended for sending the image through the by Client APIs. It should not be opened or serialized, as its characteristics may change without prior notice. Its use must be exclusive to interactions with the APIs to ensure the integrity and security of the data. Unico is not responsible for any damages arising from this practice, as modifications may occur unexpectedly.
The base64 and encrypted files can vary in size due to several factors, including the quality of the devices and the photos generated, as well as Unico's business rules. To avoid issues in your application, do not restrict the size of the string generated by the SDK for these files in your programming logic or infrastructure.

`onErrorSelfie` Method

If an error occurs during image capture, this method returns an UnicoError object:

Learn more about ErrorBio types in the SDK Error Handling section.

Preparing and Opening the Camera

The openCameraSelfie method is used to open the camera. This method takes as parameters the implementation of the UnicoSelfie class and the JSON with the credentials generated in the previous step. The following example illustrates the steps for configuring the listeners and opening the camera:

Making a POST Request to the Client API

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

Document Capture

In this section, you will find all the necessary information for using and integrating the Unico IDCloud SDK into your Flutter applications for document capture

This guide has been designed to help you implement the Flutter 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 Flutter Customization section.

Available Document Frames

The SDK does not perform any validation of what is being captured.

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

To get started, create an instance of the builder (generated through the UnicoCheckBuilder interface), providing the relevant context and the implementation of the UnicoListener class as parameters.

The implementation of this class is straightforward and can be done with just a few lines of code. All you need to do is override the callback methods with the business logic of your application.

Implementing the callback functions

Note that, as in the previous example, the implementation work of the UnicoListener class is largely about configuring the callback methods. Each method is called in a specific situation based on the SDK's response.

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

onErrorUnico(UnicoError error)

This method is invoked with a parameter of type ErrorBio that contains details about the error. Learn more about the ErrorBio type in the error handling section.

onUserClosedCameraManually()

EThis method is invoked whenever the user manually closes the camera, such as by clicking the "Back" button.

onSystemClosedCameraTimeoutSession()

This method is invoked once the maximum session time is reached (without capturing any image).

You can configure the session timeout in seconds using setTimeoutSession. The default and minimum timeout is 40 seconds.

onSystemChangedTypeCameraTimeoutFaceInference()

This method is invoked when the maximum time for face detection is reached without detection.

The maximum time is 13 seconds. The mode is then switched to manual capture to facilitate the user’s action.

All the above methods must be created as indicated in your project (even without any logic); otherwise, the project won’t compile successfully.

Implementing Listeners for Camera Events

The implementation of these listener methods should be done through an instance of the iAcessoBioSelfie class.

The camera open method needs to know what to do when an image is successfully captured or when an error occurs during the process. The camera's behavior is informed through the deployment of listeners, which are invoked in both success and error scenarios.

By implementing the listeners, you can specify what happens in your app in the event of an error (e.g., the onErrorDocument method) or success (e.g., the onSuccessDocument method) during the image capture process.

`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:

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 typeUnicoError:

Learn more about the types of ErrorBio in the SDK's error handling section.

Preparing and Opening the Camera

To open the camera, the openCameraDocument() method is used. This method is made available through the object generated by an instance of the UnicoCheck class.

This method accepts the following parameters:

A JSON file containing the credentials, generated in the credentials configuration step.
The listeners configured above.
The type of document to be captured, which can be one of the following:

If you need to capture a document for which there is no specific frame (e.g., RNE, among others), use the DocumentCameraTypes.OUTROS("descrição") frame, which will allow you to use a generic rectangular frame to guide any capture.

Example using the open CNH:

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.

Error Handling Guide

In this section, you will find all the necessary information for handling errors from the Unico IDCloud SDK in your Android applications

`UnicoError` Object

This object is returned whenever an error occurs in the Flutter SDK.

Available Methods

Method Name

Description

Below is a list of possible error codes from the Flutter SDK:

Code

Description

Flutter Customization

In this section, you will find all the information necessary for customizing the SDK of the Unico IDCloud platform in your Flutter applications

The Flutter SDK allows for some customizations to be made. Below are all the possible customizations for this SDK.

Customize Language

It is possible to configure the experience of the informational messages in the capture frames by changing their language. Use the enumerated type LocaleTypes, which contains the following values:

LocaleTypes.PT_BR: for Portuguese(Brazil);
LocaleTypes.ES_MX: for Spanish(Mexico);
LocaleTypes.ES_ES: for Spanish(Spain);
LocaleTypes.EN_US: for English(USA).

See how to implement it in the example below:

A remote activation may be required to be used, if you wish to use it, notify your project manager or Unico support.
If not configured, the SDK will use Portuguese as the default language.

Customize Capture Experience

The supported types for color representation are Color Resource or a String containing the hexadecimal color code. E.g., R.color.red or #FF0000.

All methods are available below:

Troubleshooting

In this section, you will find solutions to some common issues encountered during the integration of the Unico IDCloud SDK into your Flutter applications

Code Obfuscation

Obfuscation via DexGuard

When obfuscation is performed using DexGuard, if a failure occurs, use the following rules:

Obfuscation via ProGuard

When obfuscation is performed using ProGuard, if a failure occurs, use the following rules:

Bitcode Error in App Distribution using Xcode 16

Open the Podfile file.
Add the following lines after the post_install command (do |installer|) and before the last end:

2.1. If there is existing code, insert this snippet before it;

2.2. f bitcode removal is already done manually, explicitly add the paths listed in framework_paths;

If there is no post_install do |installer| command in the Podfile, add it as follows before the last end:

Release notes

In this section, you will find all the updates for the Unico IDCloud Flutter SDK

Keep your Android SDK always up to date with the latest available version. Semantic versioning is used to number the versions. For more information, please refer to the article Overview.

Version 4.20.0 - 11/05/2024

Native SDK Update:
- Android version 5.25.0 .

Version 4.19.0 - 10/18/2024

Native SDK Update:
- Android version 5.24.0 ;
- iOS version 2.16.4 .

Still need help?

Web SDK

In this section, you will find all the necessary information to implement the Web SDK of the Unico IDCloud platform

Installation Guide

In this section, you will find all the information needed to install the Unico IDCloud platform SDK in your Web applications

Compatible Browsers

The capture frame provided through the SDK is compatible with the following combinations of browsers and operating systems:

Operational System

Chrome

Firefox

Safari

Samsung Internet

Opera

Edge

In general, the SDK supports WebRTC and newer versions of the browsers listed above. Due to compatibility and security reasons, functionality in very old versions of these browsers is not guaranteed.

The capture component provided through the Flutter SDK supports versions equal to or higher for the following technologies:

Android: 5.0 (API 21);
iOS: 11.

Webview Operation

It is a system component that allows Android or iOS applications to display web content directly inside the app, based on the same code project. It is responsible for navigation on websites and web content within apps.

Preconditions

It is necessary to have implemented the Web SDK in an application that contains a secure domain with the https protocol.

Compatibility with Operating Systems

Android:

The Web SDK is compatible with webviews running on Android 8 (API 26) or higher. For the SDK to function correctly, it is necessary to add some permissions and configurations to the AndroidManifest file, which are as follows:

It is recommended to use Chromium-based webviews with some customizations for better JavaScript performance. You can find an implementation example through our PoCs here.

iOS

The Web SDK is compatible with webviews running on iOS 13 or higher. For the SDK to function correctly, it is necessary to add some permissions and configurations to the info.plist file, which are as follows:

iOS provides two ways to use Webviews in applications: WKWebView and SFSafariViewController. We recommend using SFSafariViewController for better compatibility with DOM features. You can find an implementation example through our PoCs here.

Compatibility with Hybrid Frameworks

The component is certified only for native layers. To be used in hybrid frameworks (Flutter or React Native), it is necessary to implement it in the native layer of Android and/or iOS.

When running, the SDK will request permission to open the camera for the webview, which will then request the same permission from the native application. It is mandatory for your native application to have the necessary permissions set in the configuration files.

Our support is restricted to applications developed directly on native Android and iOS platforms, using their respective native modules. Currently, we do not offer support for applications developed in hybrid frameworks, such as React Native, Ionic, or other cross-platform development technologies.

Installing the Web SDK

To implement the Unico IDCloud Web SDK into your Android app, follow the steps listed below:

Content Security Policy (CSP) Setting

The Web SDK employs the use of Web Workers to enhance security and performance. Therefore, you need to add the following settings to your Content Security Policy (CSP):

If your application has a CSP, this configuration is mandatory to ensure the correct functioning of the SDK.

Obtaining Credentials

Contact the CSs and/or Onboarding team.
Request the SDK Key by entering the identifiers of your applications. Bundle Identifier for iOS, PackageID for Android and Host for WEB.
The identifiers of your applications will be linked to the SDK Key by the Unico team.
You receive your SDK Key to implement the AccessBioConfigDataSource.

Embedding the Credentials in Your Project

Implement the UnicoConfig class in your class:

Depracated Method:

Embedding Other Files in Your Project

The table below lists additional resource files available for inclusion in your project. You must download them and include them in your project to perform the life proof capture:

Download the AI files for the SDK

All additional files must be in a publicly accessible and visible location within your project.

Installation

The Web SDK is available through an npm package or cdn. For installation, follow the steps below according to your preference:

Or via yarn, with the following command:

To install the SDK into your project through the cdn, simply download the file below and import it into your project.

Importing

After installing the SDK, simply import it correctly into your project.

If you installed the package via npm:

If you installed the package via cdn:

Once the SDK installation is complete, proceed to the implementation by reading the following Usage and Integration Guide:

Usage and Integration Guide

In this section, you will find all the necessary information for using and integrating the Unico IDCloud platform SDK into your Webapplications

Error Handling Guide

In this section, you will find all the necessary information for handling errors from the Unico IDCloud SDK in your Web applications

`ErrorBio` Object

This object is returned whenever an error occurs in the Web SDK.

Available Methods

Method Name

Description

Below is a list of possible error codes from the Web SDK, in the prepareCamera method:

Below is a list of possible error codes from the Web SDK, in the openCamera method:

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.

SDK Integration

Android SDK

Installation Guide

Development Environment Preconditions

Compatible Devices

Installing the Android SDK

Configuring the Maven Repository

Camera and Internet Permissions

Adding the Dependency

Obtaining Credentials

Embedding Credentials in Your Project

Usage and Integration Guide

Selfie Capture

Initializing the SDK

Environment configuration

Implementing Callback Functions

Configuring Camera Mode

Implementing Listeners for Camera Events

onSucessSelfie Method

onErrorSelfie Method

Preparing and Opening the Camera

Making a POST Request to the Client API

Document Capture

Available Document Frames

Initializing the SDK

Implementing Callback Functions

Implementing Listeners for Camera Events

onSucessDocument Method

onErrorDocument Method

Preparing and Opening the Camera

Making a POST Request to the Client API

Error Handling Guide

ErrorBio​ Object

Available Methods

Android Customization

Customize Language

Customize Capture Process Experience

Customize Selfie Capture Experience

Customize Document Capture Experience

Troubleshooting

Code Obfuscation

Obfuscation via DexGuard

Obfuscation via ProGuard

SDK Update - Version 4.3.x

Update the Maven Repository:

Change the SDK Dependency

Release notes

Version 5.26.0​ - 11/21/2024

Version 5.25.0​ - 11/04/2024

Version 5.24.0​ - 10/17/2024

iOS SDK

Installation Guide

Development Environment Preconditions

Installing the iOS SDK

Using CocoaPods

Using Swift Package Manager (SPM)

Camera Usage Permissions

Obtaining Credentials

Embedding the Credentials in Your Project

Usage and Integration Guide

Selfie Capture

Initializing the SDK

Environment configuration

Implementing the Callback Functions

Configuring Camera Mode

Implementing Delegates for Camera Events

onSuccessSelfie Method

onErrorSelfie Method

Environment Configuration

Prepare and Open Camera

Making a POST Request to the Client API

Document Capture

Available Document Frames

Initializing the SDK

Implementing Callback Functions

Implementing Delegates for Camera Events

onSucessDocument Method

Método onErrorDocument

Preparing and Opening the Camera

Making a POST Request to the Client API

`onSucessSelfie` Method

`onErrorSelfie` Method

`onSucessDocument` Method

`onErrorDocument` Method

`ErrorBio` Object

Version 5.26.0 - 11/21/2024

Version 5.25.0 - 11/04/2024

Version 5.24.0 - 10/17/2024

`onSuccessSelfie` Method

`onErrorSelfie` Method

`onSucessDocument` Method

Método `onErrorDocument`

`ErrorBio` Object

`onSucessSelfie` Method

`onErrorSelfie` Method

`onSucessDocument` Method

`onErrorDocument` Method

`UnicoError` Object