Document Verification

// Initialize IDV SDK
private func initializeIdvSDK() {
    do {
        try TSIdentityVerification.initializeSDK()
        TSIdentityVerification.delegate = self
    } catch {
        debugPrint("[DEBUG]: initialization error: \(error)")
    }
}
// TSIdoDelegate TSIdoDidReceiveResult function implementation
func TSIdoDidReceiveResult(_ result: Result<TSIdoServiceResponse, TSIdoJourneyError>) {
    switch result {
    case .success(let response):
        self.handleIdoResponse(response)
    case .failure(let error):
        // Handle error
    }
}
private func handleIdoResponse(_ response: TSIdoServiceResponse) {
    guard let stepId = response.journeyStepId else {
        debugPrint("[DEBUG] Missing step id in the journey response")
        return
    }

    if stepId == .identityVerification {
        guard let payload = response.data["payload"] as? [String: Any],
              let startToken = payload["start_token"] as? String {
                  debugPrint("[DEBUG] Start token is missing")
                  return
              }

        initializeIdvSDK()

        requestCameraPermissionsAndStartSDK(startToken: startToken)
    }
}

// Before starting the IDV, requesting camera permissions is required
private func requestCameraPermissionsAndStartSDK(startToken: String) {
    switch AVCaptureDevice.authorizationStatus(for: .video) {
    case .authorized: // the user has already authorized to access the camera
        self.startIdv(startToken: startToken)

    case .notDetermined: // the user has not yet asked for camera access
        AVCaptureDevice.requestAccess(for: .video) { (granted) in
            if granted { // if user has granted to access the camera
                self.startIdv(startToken: startToken)
            } else {
                // Handle this case
            }
        }

    case .denied, .restricted:
        // Handle this case
    @unknown default:
        // Handle this case
    }
}

// Start IDV SDK
private func startIdv(startToken: String) {
    TSIdentityVerification.start(startToken: startToken)
}

// TSIdentityVerificationDelegate functions implementation
extension ViewController: TSIdentityVerificationDelegate {
    func verificationDidComplete() {
        debugPrint("[DEBUG]: verification process did complete")

        // Submit parameters to IDO SDK
        TSIdo.submitClientResponse(clientResponseOptionId: .clientInput)
    }

    func verificationDidFail(with error: IdentityVerification.TSIdentityVerificationError) {
        debugPrint("[DEBUG]: Verification process did fail with error: \(error)")

        // Submit failure to IDO SDK
        TSIdo.submitClientResponse(clientResponseOptionId: .fail)
    }
}

private fun processServiceResponse(idoResponse: TSIdoServiceResponse) {
    when(idoResponse.journeyStepId) {
        ...
        TSIdoJourneyActionType.IdentityVerification.type -> handleIdentityVerification(idoResponse)
        ...
    }
}

private fun handleIdentityVerification(
        result: TSIdoServiceResponse
    ) {
            // Check if the camera permission is granted
                if (ContextCompat.checkSelfPermission(context, android.Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED) {
                    // Extract the start_token and base_endpoint from IDO response
                    val idvStartToken = (result.data as JSONObject).optJSONObject("payload").optString("start_token")
                    val idvBaseEndpoint = (result.data as JSONObject).optJSONObject("payload").optString("base_endpoint")

                    // Start the identity verification process using the IDV SDK
                    TSIdentityVerification.initialize(context, CLIENT_ID, idvBaseEndpoint)
                    TSIdentityVerification.registerForStatus(this) //"this" implements ITSIdentityVerificationStatus interface
                    TSIdentityVerification.start(it, idvStartToken)
                } else {
                    // Request camera permission
                    ActivityCompat.requestPermissions(activity, arrayOf(android.Manifest.permission.CAMERA),
                        101
                    )
                }
    }
// This method is implemented by the listener that implements the ITSIdentityVerificationStatus interface
override fun verificationCompleted() {
        val session = (idoResponse.data as JSONObject).optJSONObject("payload").optString("session")
        val state = (idoResponse.data as JSONObject).optJSONObject("payload").optString("state")
        val payload = IDVResponsePayload(session, state)
        // Submit response to IDO SDK
        TSIdo.submitClientResponse(TSIdoClientResponseOptionType.ClientInput.type, IDVResult(payload), callback)

    }
...
data class IDVResponsePayload(val sessionId: String, val state: String)
data class IDVResult(val payload: IDVResponsePayload)