Main component

It is the most important component of the SDK, as it contains the libraries necessary for everything to work properly.

The installation of the Core Plugin is mandatory, regardless of the products required for use and the use case that has been defined. It contains basic features for the operation of the SDK, as well as other cross-cutting and necessary features for auxiliary plugins.

Dependencies

Cordova:

cordova plugin add @facephi/sdk-core-cordova@<Version>

Android - Gradle:

api "com.facephi.androidsdk:sdk:$version"
api "com.facephi.androidsdk:core:$version"
implementation "com.facephi.androidsdk:tracking_component:$version"

iOS - CocoaPods:

s.dependency 'FPHISDKMainComponent', '~> $version'
s.dependency 'FPHISDKTrackingComponent', '~> $version'
s.dependency 'FPHISDKLicensingComponent', '~> $version'
s.dependency 'FPHISDKTokenizeComponent', '~> $version'
s.dependency 'FPHISDKStatusComponent', '~> $version'

Available methods

This component contains several methods that execute different functionalities:

Method	Description
launchInitSession	Main controller of the component, which is responsible for validating licenses, among other things.
launchInitOperation	Method responsible for generating a new operation. Its id is retrieved in the result object, data parameter.
launchGetExtraData	The getExtraData method allows generating the identifiers necessary for an operation that must continue in the Facephi Validation Service (Backend).
launchCloseSession	Before the application is destroyed, the SDK session must be closed to notify the platform of its completion.

launchInitSession

Before any component can be used, the SDK session must be initialized. This initialization should be done as soon as possible, preferably at the start of the application. At the same time, once all operations with the SDK Mobile have been completed, the session must also be closed.

The current component can be initialized in two ways, depending on how you want to inject the license.

The new licensing method allows licenses to be managed transparently for the integrator. The license can be injected in two ways:

• a. Obtaining the license through a service via a URL and API-KEY

• b. Injecting the license directly as String

In both cases, the result will be returned via a Promise, which contains an object of the class CoreResult.

exports.launchInitSession = function (cfg) {
    return new Promise((resolve, reject) => {
        var config = [];
        try {
            config = [{
                config: cfg
            }];
        } catch (e) {
            console.log(e);
        }

        exec(resolve, reject, 'SdkCore', 'launchInitSession', config);
    });
};

Basic configuration

To launch the current component, an object must be created InitSessionConfiguration which will be the configuration of the component controller.

The basic configuration required for it is as follows:

export interface InitSessionConfiguration {
    license?: string;
    licenseUrl?: string;
    licenseApiKey?: string;
    enableTracking?: boolean;
    enableFlow?: boolean;
    enableSecurityMode?: boolean;
    internalOptions?: Record<string, string>;
    locale?: string;
}

Advanced component configuration

Below are all the fields that are part of this class.

Init Session Configuration

---

launchInitOperation

When starting a process or flow, always the call to the method launchInitOperation

exports.launchInitOperation = function (cfg) {
    return new Promise((resolve, reject) => {
        var config = [];
        try {
            config = [{
                config: cfg
            }];
        } catch (e) {
            console.log(e);
        }

        exec(resolve, reject, 'SdkCore', 'launchInitOperation', config);
    });
};

Basic configuration

To launch the current component, an object must be created InitOperationConfiguration which will be the configuration of the component controller.

The basic configuration required for it is as follows:

export interface InitOperationConfiguration {
    type: SdkOperationType;
    steps?: string[];
    customerId: string;
}

Advanced component configuration

Below are all the fields that are part of this class.

Init Operation Configuration

---

launchCloseSession

Before the application is destroyed, the SDK session must be closed to notify the platform of its completion. For this, the following code snippet is executed:

exports.launchCloseSession = function (cfg) {
    return new Promise((resolve, reject) => {
        var config = [];
        try {
            config = [{
                config: cfg
            }];
        } catch (e) {
            console.log(e);
        }

        exec(resolve, reject, 'SdkCore', 'launchCloseSession', config);
    });
};

---

launchGetExtraData

The method getExtraData allows generating the identifiers necessary for an operation that must continue in the Facephi Validation Service (Backend). This situation usually occurs in cases where, once the necessary information has been obtained in the client application, that information must be sent to a specific service for subsequent validation or analysis. If the results of those processes must be tracked in the Platform, it must be able to unify the first part of the process performed on the client with the last part performed in the service, since in the end they are part of the same operation.

exports.launchGetExtraData = function () {
    return new Promise((resolve, reject) => {
        var config = [];
        try {
            config = [];
        } catch (e) {
            console.log(e);
        }

        exec(resolve, reject, 'SdkCore', 'launchGetExtraData', config);
    });
};

IDV launch

The IDV process allows launching a Flow configured on the platform from its ID (flowID). For this, two methods will need to be invoked: launchInitFlow + launchStartFlow.

launchInitFlow

In this method, the necessary configuration will be set. The ID of the flow configured in the platform (flowID) and the ID of the client (customerID). See code:

await facephi.plugins.sdkcore.launchInitFlow({
     "customerId": "[email protected]",
     "flow": "f40c098c-a878-4976-aef1-xxxxxxx"
})

To configure the flow controller, a list of the controllers for the components that will participate in the process will be created, which allows them to be initialized correctly. The order in which they are defined is not important; the flow itself will indicate the order in which they will be executed. For example:

• setSelphiFlow: Face Capture

• setSelphidFlow: Document Capture

Launch code:

/* Results are listened to by implementing a listener */
setTimeout(function()
{
    if (typeof facephi.plugins.sdkcore !== "undefined")
    {
        facephi.plugins.sdkcore.startListeningTrackingEvents(
            (event) => {
                console.log('📡 startListeningTrackingEvents received:', event);
            },
            (err) => {
                console.error('❌ Error:', err);
            }
        );
        facephi.plugins.sdkcore.startListeningFlowEvents(
            (event) => {
                console.log('📡 startListeningFlowEvents received:', event);
            },
            (err) => {
                console.error('❌ Error:', err);
            }
        );
    }
}, 2000);

await facephi.plugins.sdkcore.launchInitFlow({
     "customerId": "[email protected]",
     "flow": "f40c098c-a878-4976-aef1-xxxxxxx"
 })
.then(
    async (result) =>
    {
        if (parseInt(result.finishStatus) == SdkMobileFinishStatus.Ok)
        {
            console.log("launchInitFlow result", result);
            await facephi.plugins.sdkselphid.setSelphidFlow()
            .then(
                (result) => { console.log("setSelphidFlow result", result); },
                (err) => console.log(err),
            );
            await facephi.plugins.sdkselphi.setSelphiFlow()
            .then(
                (result) => { console.log("setSelphiFlow result", result); },
                (err) => console.log(err),
            );
            await facephi.plugins.sdkselphi.setSignatureSelphiFlow()
            .then(
                (result) => { console.log("setSignatureSelphiFlow result", result); },
                (err) => console.log(err),
            );
            
            /* At the end of adding the Flows, launchStartFlow is launched (as long as the previous methods do not fail) */
            await facephi.plugins.sdkcore.launchStartFlow()
            .then(
                (result) => { console.log("launchStartFlow result", result); },
                (err) => console.log(err),
            );
        }
    },
    (err) => console.log(err),
);

Receiving the result

The launch of ALL the methods will return the information in format CoreResult. Being able to distinguish between a successful and an unsuccessful launch:

export interface CoreResult {
    finishStatus: number;
    finishStatusDescription?: string;
    errorType: string;
    errorMessage?: string;
    data?: string;
}

Core Result