<key>NSCameraUsageDescription</key>
<string>Open camera</string>

 pod 'TensorFlowLiteSwift', '2.11.0'
 pod 'PromiseKit', '6.8'
 pod 'OpenSSL-Universal', '1.1.2301' # if you are using module NFC
 pod 'CryptoSwift', '1.7.1'

 post_install do |installer|
   installer.pods_project.targets.each do |target|
   // If when compiling your project, "Undefined symbol" occurs, please add the module name which is having the error here
   // add OpenSSL-Universal if you are using module NFC
     if ['TensorFlowLiteC', 'TensorFlowLiteSwift', 'PromiseKit', 'OpenSSL-Universal', 'CryptoSwift'].include? "#{target}"
       target.build_configurations.each do |config|
          config.build_settings['BUILD_LIBRARY_FOR_DISTRIBUTION'] = 'YES'
          config.build_settings["EXCLUDED_ARCHS[sdk=iphonesimulator*]"] = "arm64"
       end
     end
   end
 end

import TrustVisionCoreSDK
import TrustVisionAPI
import TrustVisionSDK

        let initConfiguration = TVInitializeConfigurationBuilder()
            .setAccessKeyId("accessKey")
            .setAccessKeySecret("secretKey")
            .setBaseUrl("endpoint")
            .setClientSettingsJsonString(nil)
            .setClientSettings(nil)
            .setFlowId(nil)
            .setLanguageCode(nil)
            .setSslCertificates(nil)
            .setXRequestId(nil)
            .setXRequestId2(nil)
            .setEnableDebuggingLog(false)
            .setImageEncryptionKey(nil)
            .setSecurityPublicKey(nil)
            .setHeaders(nil)
            .setEnableGetClientSetting(true)
            .setLogServerAccess("accessKey for log event")
            .setLogServerSecret("secretKey for log event")
            .setLogServerBaseUrl("endpoint for log event")
            .build()

        TrustVisionSdk.shared.initialize(
            config: initConfiguration,
            success: {
            // sdk is initialized
        }, failure: { (error) in
             // sdk is failed to initialize
        }) { (event) in
             // sdk is initialized with event
        }

TrustVisionSdk.shared.initialize(
    accessKeyId: "your_access_key",
    accessKeySecret: "your_secret_key",
    baseUrl: "baseUrl",
    localizationFiles: nil,
    clientSettingsJsonString: nil,
    localizationFiles: nil,
    languageCode: "vi",
    theme: TVTheme(),
    xRequestId: nil,
    xRequestId2: nil,
    isForced: false,
    enableDebuggingLog: false,
    tvCertificate: TVCertificate(name:"your_name_ssl_pining_certificate_file", type: "your_name_ssl_pining_certificate_type"),
    imageEncryptionKey: "your_key",
    securityPublicKey: "your_security_public_key"
    success: {
        // sdk is initialized
    }, failure: { error in
        // sdk is failed to initialize
    }, onEvent: { event in
        // sdk is initialized with event
    }
)

TrustVisionSdk.shared.changeLanguageCode(languageCode: String)
TrustVisionSdk.shared.getLanguageCode() -> String?
TrustVisionSdk.shared.getSupportedLanguageCodes() -> []

let config = TVIdCardConfiguration(
    cardTypes: [TVCardType],
    cardSide: TVIdCardConfiguration.TVCardSide.front,
    isSoundEnable: false,
    isReadBothSide: false,
    idTamperingLevel: nil,
    skipConfirmScreen: false,
    idCaptureOnlyMode: false,
    isEnablePhotoGalleryPicker: false,
    isEnableScanQr: true,
    isEnableScanNfc: true,
    isEnableVerifyNfc: true,
    isSanityRequired: false,
    isIdCardTamperingDetectionEnable: false,
    isEnableReadCardInfo: false,
    isEnableUploadFrames: true,
    isEnableUploadImages: true,
    isEnableCallApiOcrNfc: true
)

let vc = TrustVisionSdk.shared.startIdCapturing(configuration: config, framesRecordedCallback: { batchId, frames, metadata, currentBatchIds in

}, readIdCardNumber: { (image) in
  return ""
}, success: { (result) in

}, failure: { (error) in

}, cancellation: { (cancellation) in
    // sdk is canceled
})

  var frontCardFrameBatchIdsDictionary: [String: String] = [:]
  var backCardFrameBatchIdsDictionary: [String: String] = [:]
  . . .
  framesRecordedCallback = { batchId, frames, metadata, currentBatchIds in
        let batchDict = frames.merging(["metadata": metadata, "label": "The card type"]) { $1 }
        let jsonToBeUploaded = try JSONSerialization.data(withJSONObject: batchDict, options: .prettyPrinted)
    // upload frame batch to server using this api:
    // https://ekyc.trustingsocial.com/api-reference/customer-api/#upload-videoaudioframes
    doYourUploadFrameBatchHere(withJSON: jsonToBeUploaded) { uploadingResult in
      if cardSide == TVIdCardConfiguration.TVCardSide.front {
        frontCardFrameBatchIdsDictionary.updateValue(uploadingResult.fileId, forKey: batchId)
      }
      else {
        backCardFrameBatchIdsDictionary.updateValue(uploadingResult.fileId, forKey: batchId)
      }
    }
  }

// These lists contain all valid frame batch ids that responded by server
var validFrontCardServerFrameBatchIds: [String] = []
var validBackCardServerFrameBatchIds: [String] = []
private func removeRedudantFrameBatchIds(batchIdsDictionary: [String: String], validIdsFromSDK: [String]) -> [String] {
    return batchIdsDictionary.compactMap({
        if validIdsFromSDK.contains($0.key) {
            return $0.value
        }
        else {
            return nil
        }
    })
}
. . .
success = { result in
    // result.frontCardFrameBatchIds && result.backCardFrameBatchIds is empty when Frame Recording feature is disabled by client settings.
    // Wait until every Frame batch has been uploaded to server before calling this
    if(everyFrameBatchUploadingCompleted) {
        if (!result.frontCardFrameBatchIds.isEmpty) {
            validFrontCardServerFrameBatchIds = removeRedudantFrameBatchIds(frontCardFrameBatchIdsDictionary, result.frontCardFrameBatchIds)
        }
        if (!result.backCardFrameBatchIds.isEmpty) {
            validBackCardServerFrameBatchIds = removeRedudantFrameBatchIds(backCardFrameBatchIdsDictionary, result.backCardFrameBatchIds)
        }
    }
}

{
  "file": "<dataToUpload>",
  "label": "proper label, check the API document for detail"
}

let dataToUpload = result.frontIdQr.images[i].imageByteArray
let qrId = yourMethodToUploadImage(dataToUpload)

{
    "image": {
        "id": "<frontCardId>"
    },
     "image2": {
        "id": "<backCardId>"
    },
    "qr1_images": [{
        "id": "<qrId>"
    }],
    "card_type": "<result.cardType.id>",
    "videos": [{
          "id": "<validFrontCardServerFrameBatchIds[index]>"
      },
      {
          "id": "<validFrontCardServerFrameBatchIds[index + 1]>"
      },
      ...
      {
          "id": "<validBackCardServerFrameBatchIds[index]>"
      },
      {
          "id": "<validBackCardServerFrameBatchIds[index + 1]>"
      },
      ...
    ]
}

readIdCardNumber: { [weak self] (image) in
  var idNumber = ""
  // call api or do any thing to read and return id number
  // TODO
  return idNumber
}

let config = TVSelfieConfiguration(
                cameraOption: TVCameraOption.front,
                isSoundEnable: true,
                skipConfirmScreen: true,
                livenessMode: TVLivenessMode.flash_16,
                isSanityRequired: true,
                isEnableVerifyLiveness: true,
                isEnableUploadFrames: true,
                isEnableUploadImages: true,
                isEnableExitConfirmPopup: false)

let vc = TrustVisionSdk.shared.startSelfieCapturing(configuration: config,
framesRecordedCallback: { batchId, frames, metadata, currentBatchIds in

}, success: { (result) in

}, failure: { (error) in

}, cancellation: { (cancellation) in
    // sdk is canceled
})

  // this dictionary will be used for Liveness verification
  var selfieFrameBatchIdsDictionary: [String: String] = [:]
  . . .
  framesRecordedCallback = { batchId, frames, metadata, currentBatchIds in
    let batchDict = frames.merging(["metadata": metadata, "label": "video"]) { $1 }
    let jsonToBeUploaded = try JSONSerialization.data(withJSONObject: batchDict, options: .prettyPrinted)
    // upload frame batch to server using this api:
    // https://ekyc.trustingsocial.com/api-reference/customer-api/#upload-videoaudioframes
    doYourUploadFrameBatchHere(withJSON: jsonToBeUploaded) { uploadingResult in
        // Keep the id that generated by the SDK corresponding with the one responded from server
        selfieFrameBatchIdsDictionary.updateValue(uploadingResult.fileId, forKey: batchId)
    }
  }

// These lists contain all valid frame batch ids that responded by server
var validServerFrameBatchIds: [String] = []
private func removeRedudantFrameBatchIds(batchIdsDictionary: [String: String], validIdsFromSDK: [String]) -> [String] {
    return batchIdsDictionary.compactMap({
        if validIdsFromSDK.contains($0.key) {
            return $0.value
        }
        else {
            return nil
        }
    })
}
. . .
success = { result in
    // result.livenessFrameBatchIds is empty when Frame Recording feature is disabled by client settings.
    // Wait until every Frame batch has been uploaded to server before calling this
    if(everyFrameBatchUploadingCompleted) {
        if (!result.livenessFrameBatchIds.isEmpty) {
            validServerFrameBatchIds = removeRedudantFrameBatchIds(selfieFrameBatchIdsDictionary, result.livenessFrameBatchIds)
        }
    }
}

// with frontal images
let dataToUpload = result.selfieImages[i].frontalImage.imageByteArray

// with gesture images
let dataToUpload = result.selfieImages[i].gestureImage.imageByteArray

{
  "images": [
    {
      "id": "<result.selfieImages[index].frontalImage.imageId>"
    },
    {
      "id": "<result.selfieImages[index + 1].frontalImage.imageId>"
    },
    ...
  ]
}

{
  "gesture_images": [
    {
      "gesture": "<result.selfieImages[index].gestureType.description>",
      "images": [{
          "id":  "<result.selfieImages[index].gestureImage.imageId>"
      }]
    },
    {
      "gesture": "<result.selfieImages[index + 1].gestureType.description>",
      "images": [{
          "id":  "<result.selfieImages[index + 1].gestureImage.imageId>"
      }]
    },
    ...
  ]
}

{
  "videos": [
    {
      "id": "<validServerFrameBatchIds[index]>"
    },
    {
      "id": "<validServerFrameBatchIds[index + 1]>"
    },
    ...
  ]
}

{
  "metadata": "<result.livenessMetadata>"
}

let config = TVQRConfiguration(
    cardTypes: [TVCardType],
    cardSide: TVIdCardConfiguration.TVCardSide.front,
    skipConfirmScreen: true,
    isEnableUploadFrames: false,
    isEnableUploadImages: false
)

let vc = TrustVisionSdk.shared.startQRScanning(configuration: config, success: { (result) in

}, failure: { (error) in

}, cancellation: { (cancellation) in
    // sdk is canceled
})

<key>NFCReaderUsageDescription</key>
<string>This app would like to use NFC to scan CCCD chip</string>

<key>com.apple.developer.nfc.readersession.iso7816.select-identifiers</key>
    <array>
        <string>A0000002471001</string>
        <string>A0000002472001</string>
        <string>00000000000000</string>
    </array>

let config = TVIdNfcConfiguration(
    nfcCode: nfcCode,
    nfcSod: sod,
    cardIssueDate: issueDate,
    nfcCacheFields: nfcCacheFields,
    isRequestReadImageNfc: true,
    isRequestCloneDetectionNfc: true,
    isRequestIntegrityCheckNfc: true,
    nfcMaxRetries: 5,
    isEnableCheckNfcData: true,
    isEnableVerifyNfc: true,
    dateOfBirth:  "dd/MM/yyyy",
    dateOfExpiry : "dd/MM/yyyy"
)

let vc = TrustVisionSdk.shared.startNfcScanning(configuration: config, success: { (result) in

}, failure: { (error) in

}, cancellation: { (cancellation) in
    // sdk is canceled
})

let authenConfigurationComponents = TVAuthenConfigurationComponents(
    selfieConfig: selfieConfig,
    cardConfig: cardConfig,
    nfcConfig: nfcConfig)

let config = TVFaceAuthenConfiguration(
    type: TVFaceAuthenType.register,
    userId: "user_id",
    method: TVFaceAuthenMethod.active,
    authenConfigurationComponents: authenConfigurationComponents,
    isEnableFaceAuthentication: true,
    isEnableFaceRegistration: true
)

let vc = try TrustVisionSdk.shared.startFaceAuthen(
config: config,
framesRecordedCallback: { batchId, frames, metadata, currentBatchIds in

},
onLoading: {
},
success: { [weak self] (result) in

},
failure: { (error) in

}, cancellation: { (cancellation) in
  // sdk is canceled
})

// Define configs as you need. Example:
let selfieConfig = TVSelfieConfiguration(
                cameraOption: .front,
                isSoundEnable: true,
                skipConfirmScreen: true,
                livenessMode: .active,
                isSanityRequired: false,
                isEnableVerifyLiveness: false,
                isEnableUploadFrames: false,
                isEnableUploadImages: false
            )
let cardConfig = TVIdCardConfiguration(
                cardTypes: [TVCardType.id],
                cardSide: .front,
                isSoundEnable: true,
                isReadBothSide: false,
                idTamperingLevel: nil,
                skipConfirmScreen: false,
                idCaptureOnlyMode: false,
                isEnablePhotoGalleryPicker: false,
                isEnableScanQr: true,
                isEnableScanNfc: true,
                isEnableVerifyNfc: true,
                isSanityRequired: false,
                isIdCardTamperingDetectionEnable: false,
                isEnableReadCardInfo: false,
                isEnableUploadFrames: true,
                isEnableUploadImages: true
            )
let nfcConfig = TVIdConfirmationTheme(
                nfcCode: "nfc_code",
                nfcSod: "nfc_sod",
                cardIssueDate: "card_issue_date",
                nfcCacheFields: ["nfc_cache_field"],
                isRequestReadImageNfc: true,
                isRequestCloneDetectionNfc: true,
                isRequestIntegrityCheckNfc: true,
                nfcMaxRetries: 5,
                isEnableCheckNfcData: true,
                isEnableVerifyNfc: true
            )
// Set up config for face authentication
let authenConfigurationComponents = TVAuthenConfigurationComponents(
                selfieConfig: selfieConfig,
                cardConfig: cardConfig,
                nfcConfig: nfcConfig)

let config = TVFaceAuthenConfiguration(
                type: .register,
                userId: cusUserId,
                method: TVFaceAuthSession.shared.registerFaceMethod,
                authenConfigurationComponents: authenConfigurationComponents,
                isEnableFaceAuthentication: false,
                isEnableFaceRegistration: false
            )

// Start face authentication
TrustVisionSdk.shared.startFaceAuthen(
    config: config,
    framesRecordedCallback: { batchId, frames, metadata, currentBatchIds in
        // Handle frame recorded callback
    },
    onLoading: {
        // Handle loading screen at your side when the SDK is processing for request face authentication
        // Leave it if you do need it, do not forget to stop loading after the SDK returns success, failed, or canceled
    },
    success: { [weak self] (result) in
        // Handle success
        self?.handleSuccessFaceAuthen(result)
    },
    failure: { (error) in
        // Handle failure
    },
    cancellation: { (cancellation) in
        // Handle cancellation
    }

func handleSuccessFaceAuthen(_ result: TVDetectionResult) {
    var selfieImages = result.selfieImages
    let videos: [TVRequestVideo] = result.livenessFrameBatchIds.map{TVRequestVideo(id: $0)}
    var faces : [TVRequestImage] = result.faces.map{TVRequestImage(id: $0.imageId)}
    var gestures : [TVGestureFace] = result.gestureFaces.map{TVGestureFace(gesture: $0.gestureType.description.lowercased(), images: [TVRequestImage(id: $0.gestureImage.imageId)])

    // call api to verify face authentication
    // /api-docs/face-authentication-api/authenticate/
    let faceAuthenRequest = TVRequestFaceAuthen(
        cusUserId
        images: faces,
        gestureImages: gestures,
        videos: videos,
        "selfie",
        "transfer"
    )
    yourMethodToCallFaceAuthenticationAPI(request)
}

TrustVisionSdk.shared.[FlowStartingFunc]
   (config: ...,
   error: { [weak self] error in
   // Handle error
    self?.handleError(error)
   })

func handleError(_ error: TVError) {
    switch error.category {
    case .local:
        // Handle SDK error
        switch error.errorCode {
        case "unidentified":
            // unidentified error (general)
        case "authentication_missing_error":
            // sdk is not initialized
        case "sdk_canceled":
            // sdk is canceled by user
        case "permission_missing_error":
            // permission missing error (example: camera permission)
        case "setupSDK":
            // fail to set up sdk
        case "max_retry_reached":
           // When the SDK reaches the maximum timeout, this only applies to FlashLiveness

        default:
            // Handle other local errors
        }
    case .server:
        // Handle server error
        // The SDK has an unexpected error when calling API
        // https://ekyc.trustingsocial.com/api-reference/customer-api#response-errors
    }
}

TrustVisionSdk.shared.isNfcSupport() -> Bool

DeviceInfo info = TrustVisionSDK.INSTANCE.getDeviceInfo(Context);