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:

unicoCheck.setLocale(LocaleTypes.EN_US);

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

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

class _MyHomePageState extends State<MyHomePage> implements UnicoListener {

    late UnicoCheckBuilder _unicoCheck;

    
      @override
      void onErrorUnico(UnicoError error) {}

      @override
      void onUserClosedCameraManually() {}

      @override
      void onSystemChangedTypeCameraTimeoutFaceInference() {}

      @override
      void onSystemClosedCameraTimeoutSession() {}
}

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:

 _unicoCheck.setEnvironment(unicoEnvironment: UnicoEnvironment.UAT);

Implementing the 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:

UnicoCheckCameraOpener _opener = new UnicoCheck (this)
    .setAutoCapture(autoCapture: true)
    .setSmartFrame(smartFrame: 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.

onSucessSelfie Method

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

@override
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 UnicoError object:

@override
void onErrorSelfie(UnicoError error) { }

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:

_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.

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

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.

UnicoError​ Object

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

Available Methods

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

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

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

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.

class _MyHomePageState extends State<MyHomePage> implements UnicoListener {

    late UnicoCheckBuilder _unicoCheck;

    /// Unico callbacks
      @override
      void onErrorUnico(UnicoError error) {}

      @override
      void onUserClosedCameraManually() {}

      @override
      void onSystemChangedTypeCameraTimeoutFaceInference() {}

      @override
      void onSystemClosedCameraTimeoutSession() {}

      /// Document callbacks
      @override
      void onSuccessDocument(ResultCamera resultCamera) { }

      @override
      void onErrorDocument(UnicoError error) { }

}

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.

Implementing Listeners for Camera Events

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:

public void onSuccessDocument(ResultCamera resultCamera) { }

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:

public void onErrorDocument(UnicoError error) { }

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:

Example using the open CNH:

 _unicoCheck.build().openCameraDocument(
        jsonFileName: androidJsonFileName,
        documentType: DocumentType.CNH,
        listener: this);

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.

Development Environment Preconditions

Ensure your development environment meets the following preconditions:

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

$ flutter pub add unico_check

dependencies:
  unico_check: ^2.0.2

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

import 'package:unico_check/unico_check.dart';

  final _configIos = UnicoConfig(
      getBundleIdentifier: "Your BundleIdentifier Ios",
      getHostKey: "Your HostKey Ios"); 

  final _configAndroid = UnicoConfig(
      getBundleIdentifier: "Your BundleIdentifier Android",
      getHostKey: "Your HostKey Android");

  void initUnicoCamera() {
    _unicoCheck = new UnicoCheck(
        listener: this,
        unicoConfigIos: _configIos,
        unicoConfigAndroid: _configAndroid);
  }

  final _configIos = UnicoConfig(
      getProjectNumber: "Your ProjectNumber Ios",
      getProjectId: "Your ProjectId Ios",
      getMobileSdkAppId: "Your MobileSdkAppId Ios",
      getBundleIdentifier: "Your BundleIdentifier Ios",
      getHostInfo: "Your HostInfo Ios",
      getHostKey: "Your HostKey Ios");

  final _configAndroid = UnicoConfig(
      getProjectNumber: "Your ProjectNumber Android",
      getProjectId: "Your ProjectId Android",
      getMobileSdkAppId: "Your MobileSdkAppId Android",
      getBundleIdentifier: "Your BundleIdentifier Android",
      getHostInfo: "Your HostInfo Android",
      getHostKey: "Your HostKey Android");

@override
  void initState() {
    super.initState();
    initUnicoCamera();
    configUnicoCamera();
  }

  void initUnicoCamera() {
    _unicoCheck = new UnicoCheck(
        listener: this,
        unicoConfigIos: _configIos,
        unicoConfigAndroid: _configAndroid);
  }

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.

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?