Flutter Component SDK

The Assentify SDK has several capabilities and functionalities that empower developers to take complete control of the identity extraction process.

The Assentify SDK complements the Assentify DXP platform (SaaS). The developer leverages the available data by using the response information from the supported components, or data provided by the app user. The SDK allows the developer to submit all extracted data to Assentify to gain access to further features such as Compliance, AML, client profile, and other capabilities that the DXP covers.

The key components supported and available in the SDK are:

• BlockLoader : the core context component for a submission.
• Identification Document Capture : extract information from an ID card, passport, or other document.
• Face Capture / Matching : match a live source face against a target image.
• Context-aware signing : create token pre-filled documents and add a signature.
• Submission : send the collected data to Assentify DXP.

The Assentify Component SDK is available for Android native, iOS native, Flutter, and React Native. Before you initialize the SDK you will require the following variables, all of which can be retrieved from the Assentify DXP portal:

Add the Assentify Component SDK to your Flutter project. Then run flutter pub get to fetch the package.

The capture components use the device camera, and NFC document reading uses the device NFC reader. Ensure your Android and iOS projects declare the permissions required for camera access, and, where you use startNfc, NFC capabilities. Configure these per the standard Flutter platform channels for your Android and iOS targets.

To leverage the capabilities of the Assentify Component SDK, the developer must initialize the SDK on each application start-up. Initialization ensures the developer has the key information required to begin using the Component SDK.

1. environmentalConditions configuration

2. assentifySdk configuration

The assentifySdk object is an instance of AssentifySdk and is initialized with several parameters.

Retrieving your values from the DXP portal

1. Visit the Assentify DXP and click the Developers section, then click Flow Configuration.
2. Select the flow you want to use with your application, then from the drop-down menu select the Engagement block you would like to target.
3. With the block selected, review the flow information and retrieve the Tenant Identifier from this section.
4. To retrieve the API Key, create a new API Key or leverage an existing one. Assign Claims to an API Key to limit the amount of access it has.
5. To fetch the Interaction Hash, click Flow Manager and select your flow. When the Digital Engagement Link loads on the right side panel in the format https://platform.assentify.com?interaction={HASH}, copy the HASH part.

Initialization events

The Assentify BlockLoader is a core component provided to the developer to perform several functions and capabilities. The BlockLoader provides the developer with core properties that give context to the Assentify DXP platform:

• DeviceName
• FlowName
• TimeStarted
• Application
• UserAgent
• InstanceHash

These properties are built into the BlockLoader. The developer can also access the DXP and add additional properties if needed, for example phoneNumber and clientIdentifier. These custom properties can transfer custom information to Assentify DXP, which can later be mapped to WebHooks or other platform capabilities. The developer has no limit on the number of properties that can be added to the BlockLoader.

How to add a property to the BlockLoader

1. Go to the Flow Manager and select the flow you want to edit.
2. Click the view more button on the Engagement Block.
3. In the input field, type the name of the property, then press the add button.
4. Completed.

How to use the BlockLoader properties as a developer

Once the developer adds these properties using the DXP, the developer defines those properties inside their application and uses them to set the BlockLoader Step for Submission. All custom properties added can be used to perform additional capabilities on the Assentify DXP, such as running decisions and mapping webhooks. To make use of the custom properties added on the Assentify DXP, declare these properties inside your app. Assentify uses the OnBoardMe_Property_{propertyName} naming nomenclature for all custom properties.

The Identification Document Capture is a standalone, event-driven component that provides a means by which the developer can extract information from an ID card. The ID type is determined by the configuration set in Assentify DXP. The developer or business user can log in to Assentify and manage these configurations at any time, even after the application has gone live. This provides the flexibility to support as many ID cards as possible without recompiling and deploying the application.

This component returns many different types of information depending on the ID type being scanned, such as a Civil ID versus a Driving License, using dynamic keys and mappings built into the SDK. A global model is available for developers to extract information from the base model and the available property dictionary. The developer has complete freedom to perform additional operations on the data as necessary for specific business scenarios.

The component has a built-in user interface that can be used by default, or the developer can use their own custom user interface by turning off the guides and default interface. The component can fully leverage the native tools while giving complete control of what is displayed on the user interface using the events fired as part of the scanning process.

Methods

startScanIDCard parameters

startScanPassport parameters

startScanOther parameters

startContextAwareSigning parameters

startNfc parameters

How to initialize the ID card scanning

1. Initialize the Assentify SDK object.
2. Call AssentifySdk.startScanIDCard().
3. Configure the startScanIDCard parameters.
4. The startScanIDCard accepts a List<KycDocumentDetails> parameter that includes all the available templates that are retrieved.

How to initialize the passport scanning

1. Initialize the Assentify SDK object.
2. Call AssentifySdk.startScanPassport().
3. Configure the startScanPassport parameters.
4. Completed.

How to initialize the NFC scanning

1. Initialize the Assentify SDK object.
2. Scan the passport using startScanPassport().
3. Call AssentifySdk.startNfc().
4. Configure the startNfc parameters.

How to initialize other ID scanning

1. Initialize the Assentify SDK object.
2. Call AssentifySdk.startScanOther().
3. Configure the startScanOther parameters.
4. Completed.

The Face Capture and Matching step is a standalone, event-driven component that allows the developer to perform face matching between a live source and a target image. The developer offers the target image, while the selfie camera captures the source image. All features and capabilities of the Face Capture / Matching component are driven by the configuration the developer or business user configures on Assentify DXP. The developer may choose to override this configuration.

How to use the Face Acquisition component

1. Initialize the Assentify SDK object.
2. Call AssentifySdk.startFaceMatch().
3. Configure the startFaceMatch parameters.
4. Supply the target base-64 encoded face image.
5. Show a count down 3, 2, 1 before starting the scan.

The context-aware step allows developers to programmatically create files that are pre-filled with tokens. These tokens are retrieved from the Assentify DXP. After the file is created and populated with the necessary data, the method enables the addition of a user signature. This process ensures the generation and management of context-aware files.

How to use the context-aware method

1. Initialize the Assentify SDK object.
2. Call AssentifySdk.startContextAwareSigning() to initialize the contextAwareSigning object.
3. Retrieve the document tokens from the previous step and create a map object using these document tokens as the keys. Fill the map with the desired values. Then call the createUserDocument method from AssentifySdk().contextAwareSigning and pass the map object you created.
4. Retrieve the createUserDocumentResponseModel returned from the onCreateUserDocumentInstance callback and convert the templateInstance object from createUserDocumentResponseModel from base64 to a PDF file.
5. Add a signature image as a base64 string and call the signature method from AssentifySdk().contextAwareSigning with createUserDocumentResponseModel as a documentId and createUserDocumentResponseModel.templateInstanceId as a documentInstanceId.

Submission is a built-in function of the SDK that allows the developer to initiate the data transmission from the integrating app to Assentify DXP. Submission can be used to add additional properties to the BlockLoader and perform data aggregation and manipulation before sending it to Assentify. For example, the developer may want to send additional eKYC information, user-specific data, or data to bridge between the Assentify DXP and the back-end services of the integrating application. The developer may also perform additional functions such as custom date formatting, translation, transliteration, and calculations.

These tools let the developer customize any flow that requires ID Capture and face-matching operations, while also empowering the business to send additional data for further processing by leveraging the full capabilities of the Assentify DXP.

How to submit data to Assentify DXP

One of the key features of the Assentify Component SDK is being able to submit all the collected data to Assentify DXP so business users can review it. The simplest way to submit is to leverage the existing code provided in the demo application (Android, iOS).

Define variables for the BlockLoader. The data is submitted with the language you chose during the scan. You can add custom keys, such as a phone number. Prepare your list of steps with the outputProperties obtained for each step, for example:

sharedStepDefinitionsStepFace = SubmitRequestModel(item.stepId, StepsName.FaceMatch, values);
sharedStepDefinitionsStepDoc  = SubmitRequestModel(item.stepId, StepsName.DocumentCapture, values);

TemplatesByCountry

KycDocumentDetails

Templates

ConfigModel

StepDefinitions

OutputProperties

Customization

PassportExtractedModel

OtherExtractedModel

IDExtractedModel

FaceExtractedModel

IdentificationDocumentCapture

DocumentTokensModel

A list of LanguageTransformationModel objects is created and populated with different language transformation configurations.

languageTransformationList is a list containing LanguageTransformationModel objects. Each model specifies the type of language transformation (either translation or transliteration), a key-value pair, the target language, and the data type for that transformation.

LanguageTransformationModel defines the structure for each language transformation and requires the following parameters:

Can you set what data the ResponseModels have from the admin page?

No, the response models are static and are based on responses from the core ID orchestrator.

When the onComplete callback is triggered (for example for the passport), can that data be retrieved or a hook triggered on our backend?

When the callback is triggered, the application receives all the information. It is the responsibility of the application to transfer that data to any specific backend at this point. If the data can be transferred at a later stage or once it has been submitted to the platform, you can define a webhook in the connector block to be triggered after submission to inform your backend or send you specific data.

What are the KycDocumentDetails on the ScanIDCard? How would I know how many to add to the list?

The template chosen from the getTemplates() callback.

Are there any actions allowed to be triggered programmatically on the scan screens (ScanIDCard, FaceMatch, etc.)?

For features like ScanIDCard and FaceMatch, these are returned as fragments, allowing you to draw on top of them. For ScanIDCard, you receive each page in order via the onComplete callback. The camera automatically starts scanning the next page after each callback.

On the FaceMatchActivity there is a static document image being loaded to be matched against the face. How can I get the document scanned on the previous step to pass it to the face match?

You can obtain the imageUrl from the onComplete callback for document scanning, convert it to base64, and use it in face match.

What happens if the document has multiple sides? How can I find which side had the photo of the user to pass to the FaceMatch?

You must choose an order (page) that contains a face to set it for face match. When the document URL is retrieved from the document scan, Assentify flags that it has a face extracted based on the template.

What data should you submit on startSubmitData? Are these specified from the admin page?

You must prepare your list of steps with the outputProperties obtained for each step, for example a SubmitRequestModel for FaceMatch and one for DocumentCapture.

On the StepNames file there are various keys used for uploading the data on startSubmitData. How do these correlate with the admin page? Where can I find this mapping?

In Flow Builder, after selecting a flow from Flow Manager, you are presented with the blocks that make up the flow. To view the additional keys per flow, select the magnifier icon on the BlockLoader to see all the data there. You can also define and add new data points.