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

Initializing the SDK

To get started, follow these 3 simple steps in your project:

Instantiate a new Builder:

const unicoCameraBuilder = new UnicoCheckBuilder();

Specify the path of additional files (if added to your project):

unicoCameraBuilder.setResourceDirectory("/resources");

Specify the path of the AI model files if you are using the Smart Camera functionality:

unicoCameraBuilder.setModelsPath("https://meusite.com.br/models");

Environment Configuration

It is possible to configure which environment will be used during SDK execution. Use the SDKEnvironmentTypes enumeration, which includes the following options:

• SDKEnvironmentTypes.PROD: for the Production environment;

• SDKEnvironmentTypes.UAT: for the Staging environment.

Here is an example of how to implement it:

import {
  ...
  UnicoCheckBuilder,
  SDKEnvironmentTypes
  ...
} from "unico-webframe"

unicoCameraBuilder.setEnvironment(SDKEnvironmentTypes.UAT);

Implementing the Callback Functions

One of the objects that must be passed as a parameter to the method responsible for rendering the capture frame is the callback object. This object should contain callback functions for success and error cases, as shown below:

  const callback = {
    on: {
      success: (obj) => {
        console.log(obj.base64);
        console.log(obj.encrypted);        
      },
      error: (error) => {
        console.error(error)
        //confira na aba "Referências" sobre os erros possíveis
      }
    }
  };

his object is mandatory, and if not implemented correctly (covering all success or error events), it will throw an exception that, if not handled, will be displayed in the user's console.

Configure and Start

To start the camera with the settings made so far, you need to create an instance of the builder using the build() method.

const unicoCamera = unicoCameraBuilder.build();

Then, once the camera is "built", you need to configure the camera capture mode. The camera setup will be done through the prepareSelfieCamera() method available from the builder. This method takes 2 parameters:

• The UnicoConfig class obtained in this step;

• The desired camera mode, which can be:

  • SelfieCameraTypes.NORMAL for normal camera mode;

  • SelfieCameraTypes.SMART for smart camera mode.

This method returns a promise that, when resolved, provides an object used to actually open the camera through the open method, which takes the callback functions as parameters.

To use automatic capture, pass the Unico.SelfieCameraTypes.SMART parameter to the prepareSelfieCamera method. For smart capture, the computer vision models must also be loaded through the setModelsPath method, as explained in the first step of this guide.

Using the UnicoConfig class:

const config = new UnicoConfig()
  .setProjectNumber("<YOUR_PROJECT_NUMBER>")
  .setProjectId("<YOUR_PROJECT_ID>")
  .setMobileSdkAppId("<YOUR_MOBILE_SDK_APP_ID>")
  .setHostname("<YOUR_HOSTNAME>")
  .setHostInfo("<YOUR_HOST_INFO>")
  .setHostKey("<YOUR_HOST_KEY>");

  unicoCamera.prepareSelfieCamera(
    config, 
    SelfieCameraTypes.SMART
  ).then(cameraOpener => {
    cameraOpener.open(callback);
  }).catch(error => {
    console.error(error);
    // confira na aba "Referências" sobre os erros possíveis
  });

Configure Capture Mode in iFrames

It is possible to use the SDK Web with Interactive Liveness embedded in an iFrame. To do this, follow a similar implementation to the previous section in preparing the camera. The camera setup will be done through the prepareSelfieCameraForIFrame() method, also available from the builder. This method takes the same parameters as prepareSelfieCamera():

const unicoCamera = unicoCameraBuilder.build();

const config = new UnicoConfig()
  .setProjectNumber("<YOUR_PROJECT_NUMBER>")
  .setProjectId("<YOUR_PROJECT_ID>")
  .setMobileSdkAppId("<YOUR_MOBILE_SDK_APP_ID>")
  .setHostname("<YOUR_HOSTNAME>")
  .setHostInfo("<YOUR_HOST_INFO>")
  .setHostKey("<YOUR_HOST_KEY>");

  unicoCamera.prepareSelfieCameraForIFrame(
    config, 
    SelfieCameraTypes.SMART
  ).then(cameraOpener => {
    cameraOpener.open(callback);
  }).catch(error => {
    console.error(error);
    // confira na aba "Referências" sobre os erros possíveis
  });

Implementing the iFrame Element

For the capture to work correctly, the <iframe> element must be implemented as shown below:

<iframe allow="fullscreen;camera;geolocation" allowFullScreen src="your_app_url"></iframe>

Fullscreen Behavior

To execute the capture, the browser must be in fullscreen mode so that the SDK can automatically resize itself. Therefore, when starting the capture, the SDK will display a screen requesting the frame to open in fullscreen mode. See the following example:

After allowing fullscreen usage, the capture frame will open normally:

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.

It is essential that all clients maintain a routine of updating the SDK, as new forms of attack are developed all the time. The best way to protect your business against new types of injection and liveness fraud is to use the most up-to-date version of the Unico SDK.

It is the client's responsibility to maintain a healthy routine of SDK updates, ensuring the minimum version for the proper functioning of our solutions in their operations. Likewise, it is Unico's responsibility to provide updated versions concerning the threats that arise in the market and to keep our clients informed about the topic. With this in mind, Unico has created an SDK update policy.

Why do we have an SDK update policy?

With outdated SDKs, our clients are vulnerable to attacks from fraudsters. Considering that Unico values the utmost security of its clients, along with the urgency of the topic and the need for an agile update process, the SDK update policy was created to safeguard our clients against the newest frauds that constantly appear in the market. The only way to be secure is to stay updated.

Categories of Updates

Unico categorizes all SDK updates as Critical and Non-Critical, based on the severity of the frauds we block with the new version.

• Critical Updates: These updates aim to protect our clients against recent frauds and attacks in the market. They must be implemented within 5 (five) calendar days, considering the real threat that the operation is exposed to. After this period, we will no longer provide support for previous versions. In practice, clients contacting us with a version prior to the latest will be required to update the SDK to receive assistance.

• Non-Critical Updates: These are simpler updates aimed at improving technology. They can be implemented within 60 (sixty) calendar days. It is worth emphasizing that the more up-to-date the version, the higher the chances of avoiding bugs and errors. Therefore, we recommend that updates be made as soon as possible. After this period, we will no longer provide technical support, and the client must update their SDK for us to assist in their cases.

We identify critical updates in the Release Notes with a tag just below the version, as shown in the example below:

These periods apply to all Unico clients, regardless of the capacity used.

How do I update?​

You can follow the standard update or installation process described for the version you are using: Web, iOS, Android, and Flutter.

Can there be API contract breaks due to this policy?​

API contract breaks are restricted only to Major version releases (learn more about semantic versioning here). This means that significant changes in the API contract can only occur with major changes in the SDK, not in minor revisions. We have a practice of avoiding any Major version breaks as much as possible since it impacts significant changes in integration with the client, which is not our goal. We will only do this in cases of extreme necessity and always with the objective of ensuring security in all operations.

Where can I see what’s new in the versions?

Each version has its own release notes as per the links below, presenting new features or bug fixes / fraud blocks: Android, iOS, Flutter, and Web.

How do I know when a new version is released?

Whenever there is a new SDK version, the website https://unico-auto-1.gitbook.io/idcloud/sdks is updated. If you are a Unico client, you will receive an email with updates and information about the changes. If you are not receiving this, please contact your CSM.

• For critical updates: We will send an email as soon as the new version is available, with reinforcement from the Customer Success team, informing the urgency of the matter and the 5 (five) calendar days for updating.

• For non-critical updates: To avoid overloading client teams, we will send a monthly email summarizing non-critical updates, informing the main points of change and the 60 (sixty) calendar days for updating.

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.

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.

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

Implementing Listeners for Camera Events

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.

onErrorSelfie Method

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

public void onErrorSelfie(ErrorBio errorBio) { }

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.

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.

Introduction

The Unico IDCloud platform SDKs aim to enhance the security of your business and your clients, allowing for customization of the user experience by applying your brand's visual identity. The SDKs abstract the complexity of manipulating the users' device cameras and capturing images (selfies and documents), making life easier for developers and reducing the time to deliver the final product. Other advantages include:

• Liveness: The SDKs are used in conjunction with the Proof of Life capability to ensure that the user is alive at the time of the selfie capture.

• Image Capture Accuracy: The SDKs feature tools that assist the user in obtaining biometrically valid photos, reducing image drop rates compared to captures made by standard device cameras. SmartFrames, which are "key elements" that automatically adjust to the user's silhouette and screen proportions, are added to enable better image capture.

• Enhanced Security: The SDKs include encryption resources and security measures against image injection, as well as functionalities that prevent fraud adapted to different camera modes. Security layers work complementarily, both at the application level and regarding the data that is transmitted between the SDKs and the backend. The SDK also includes code obfuscation, emulator blocking, and application bundle verification.

Capturing images through the SDKs is just the first part of your journey. Therefore, it is extremely important to understand the basic concepts and functionality of the biometric engine APIs. For more information, see the REST API documentation for by Client.

Operational Diagram

The SDK (Client-side) is responsible for simplifying your integration with the Unico IDCloud platform, absorbing all the complexities of camera manipulation and image capture.

If the capture is successful, the SDK returns an object that should be sent to the biometric engine API, thus completing the biometric validation, as exemplified in the diagram below:

Requirements Supported by Each Client SDK

Below are the necessary information and requirements officially supported by each Unico Client SDK:

Versioning of the SDKs

The SDKs of the Unico IDCloud platform follow semantic versioning, which means there is a version number in the format "MAJOR.MINOR.PATCH," described as follows:

• Major Version (MAJOR): When making incompatible changes to the API;

• Minor Version (MINOR): When adding functionality while maintaining compatibility;

• Patch Version (PATCH): When fixing bugs while maintaining compatibility.

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.

Development Environment Preconditions

Ensure your development environment meets the following preconditions:

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

// 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" 
        }
    }
}

# 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

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

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

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

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

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

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.

ErrorBio Object

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

Available Methods

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

Code Obfuscation

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:

Obfuscation via ProGuard

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

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:

It should now be updated to the new repository:

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:

It should now be updated to the new dependency:

Development Environment Preconditions

Ensure your development environment meets the following preconditions:

Installing the iOS SDK

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

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

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.

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:

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:

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

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.

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:

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.

All methods are available below:

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

Below, check the specification of the customization fields:

Customize Document 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.

All methods are available below:

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

Below, check the specification of the customization fields:

Code Obfuscation

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:

- (void)onSuccessSelfie:(SelfieResult *)result {
    [self dismissViewControllerAnimated:YES completion:nil];
    // your code
} 

func onSuccessSelfie(_ result: AcessoBio.SelfieResult!) {
    navigationController?.popViewController(animated: true)
    // your code
 }

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:

1. Open the Podfile file.

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

bitcode_strip_path = `xcrun --find bitcode_strip`.chop!
  def strip_bitcode_from_framework(bitcode_strip_path, framework_relative_path)
    framework_path = File.join(Dir.pwd, framework_relative_path)
    command = "#{bitcode_strip_path} #{framework_path} -r -o #{framework_path}"
    puts "Stripping bitcode: #{command}"
    system(command)
  end

  framework_paths = [
    "Pods/unicocheck-ios/DeviceProfiling.xcframework/ios-arm64/DeviceProfiling.framework/DeviceProfiling",
    "Pods/unicocheck-ios/UnicoSdkLogger.xcframework/ios-arm64/UnicoSdkLogger.framework/UnicoSdkLogger"
  ]

  framework_paths.each do |framework_relative_path|
    strip_bitcode_from_framework(bitcode_strip_path, framework_relative_path)
  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;

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

post_install do |installer|
bitcode_strip_path = `xcrun --find bitcode_strip`.chop!
  def strip_bitcode_from_framework(bitcode_strip_path, framework_relative_path)
    framework_path = File.join(Dir.pwd, framework_relative_path)
    command = "#{bitcode_strip_path} #{framework_path} -r -o #{framework_path}"
    puts "Stripping bitcode: #{command}"
    system(command)
  end

  framework_paths = [
    "Pods/unicocheck-ios/DeviceProfiling.xcframework/ios-arm64/DeviceProfiling.framework/DeviceProfiling",
    "Pods/unicocheck-ios/UnicoSdkLogger.xcframework/ios-arm64/UnicoSdkLogger.framework/UnicoSdkLogger"
  ]

  framework_paths.each do |framework_relative_path|
    strip_bitcode_from_framework(bitcode_strip_path, framework_relative_path)
  end

Source: Bitrise, Xcode 16 release notes, Stackoverflow.

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.

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 iOS Customization section.

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.