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

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.

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.

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.

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
 }

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:

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
}

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.