Initialization

What is IDV Mobile

IDV (Identity Verification) is the Flow that allows verifying and authenticating a person's identity through the capture and validation of biometric traits.

The Flow is configured beforehand on the Facephi platform and is executed in the application through its identifier (flowId).

Required dependencies

To run IDV Flows on Android, you must add, in addition to the base SDK, the specific components that take part in the process.

implementation("com.facephi.androidsdk:sdk:$version") 
implementation("com.facephi.androidsdk:tracking_component:$version") 
implementation("com.facephi.androidsdk:selphi_component:$version") 
implementation("com.facephi.androidsdk:selphid_component:$version")
implementation("com.facephi.androidsdk:video_recording_component:$version")
implementation("com.facephi.androidsdk:nfc_component:$version")

Add only the components needed according to the Flow configured on the platform. The SDK and Tracking components must be integrated mandatorily regardless of the required Flow.

To facilitate the Integration process, a table is provided that refers to the dependency of each component:

Component	Dependency	Controller
Selfie	com.facephi.androidsdk:selphi_component	FSelphiController
Selfie (with IAD functionality)	com.facephi.androidsdk:selphi_iad_component	FSelphiController
Document	"com.facephi.androidsdk:selphid_component	FSelphIDController
Video recording	com.facephi.androidsdk:video_recording_component	FStartVideoRecordingController / FStopVideoRecordingController
NFC	com.facephi.androidsdk:nfc_component	FNFCController

SDK Initialization

The SDK is managed through a main controller (SDKController) that must be initialized before launching any Flow.

The License apiKey is provided by the Facephi team once the Integration has been published.

val sdkConfig = SdkConfigurationData(
    sdkApplication = SdkApplication(application),
    licensing = LicensingOnline(EnvironmentLicensingData(
        apiKey = "..."
    )),
    trackingController = TrackingController()
)
val result = SDKController.initSdk(sdkConfig)
when (result) {
    is SdkResult.Error -> {
        Log.d("INIT SDK ERROR: ${result.error}")
    }
    is SdkResult.Success -> {
        Log.d("INIT SDK OK")
    }
}

After a successful Initialization, the SDK is ready to execute the configured Flows.

Launch an IDV Flow

The IDV Flow is launched through a FlowController, indicating:

• The Flow ID configured on the platform (flowId).

• The Customer ID (customerId).

• The list of controllers that participate in the process.

• Optionally, the authentication ID (authenticationId) to associate the Flow with a specific authentication.

• Optionally, the identifiers resumeOperationId and resumeSessionId to continue an existing operation or session.

Common controller examples:

• FSelphiController → Face Capture.

• FSelphIDController → Document capture.

• FStartVideoRecordingController / FStopVideoRecordingController → Process recording.

val flowController = FlowController (
     FlowConfigurationData(
            id = "flowId",
            controllers = listOf(FSelphiController(), FSelphIDController()),
            customerId = "customerId",
            authenticationId = "authenticationId",
            resumeOperationId = "operationId",
            resumeSessionId = "sessionId",
        ))
SDKController.launch(flowController)

If you do not need to resume an operation, you can omit authenticationId, resumeOperationId and resumeSessionId. The SDK will create the internal identifiers during Flow startup.

To receive the Flow output, observe stateFlow before or during launch:

viewModelScope.launch {
    flowController.stateFlow.collect { flowResult ->
        val result = flowResult.result
        when (result) {
            is SdkResult.Success -> {
                val step = flowResult.step
                val data = result.data
                val isFlowFinished = flowResult.flowFinish
            }
            is SdkResult.Error -> {
                val error = result.error
            }
        }
    }
}

Each emission returns an SdkFlowResult with the step (step), the result of the step or operation (result) and the flowFinish, which indicates whether the Flow has finished.

Check available Flows

If you need to retrieve the available Flows before launching one of them, use:

val list = SDKController.getFlowIntegrationData()

The function returns a list with the Flow IDs and its operation type.