@trustchex/react-native-sdk 1.161.0

package/ios/VisionCameraPlugins/TextRecognition/TextRecognitionFrameProcessorPlugin.swift

@@ -0,0 +1,144 @@
+import Foundation
+import VisionCamera
+import MLKitVision
+import MLKitTextRecognition
+
+import Foundation
+import VisionCamera
+import MLKitVision
+import MLKitTextRecognition
+
+@objc(TextRecognitionFrameProcessorPlugin)
+public class TextRecognitionFrameProcessorPlugin: FrameProcessorPlugin {
+
+    private var textRecognizer = TextRecognizer()
+    private static let latinOptions = TextRecognizerOptions()
+    private var data: [String: Any] = [:]
+
+
+    public override init(proxy: VisionCameraProxyHolder, options: [AnyHashable: Any]! = [:]) {
+        super.init(proxy: proxy, options: options)
+        self.textRecognizer = TextRecognizer.textRecognizer(options: TextRecognitionFrameProcessorPlugin.latinOptions)
+    }
+
+
+    public override func callback(_ frame: Frame, withArguments arguments: [AnyHashable: Any]?) -> Any {
+        let buffer = frame.buffer
+        let image = VisionImage(buffer: buffer)
+        image.orientation = getOrientation(orientation: frame.orientation)
+
+        do {
+            let result = try self.textRecognizer.results(in: image)
+            let blocks = TextRecognitionFrameProcessorPlugin.processBlocks(blocks: result.blocks)
+            data["resultText"] = result.text
+            data["blocks"] = blocks
+            if result.text.isEmpty {
+                return [:]
+            }else{
+                return data
+            }
+        } catch {
+            print("Failed to recognize text: \(error.localizedDescription).")
+            return [:]
+        }
+    }
+
+      static func processBlocks(blocks:[TextBlock]) -> Array<Any> {
+        var blocksArray : [Any] = []
+        for block in blocks {
+            var blockData : [String:Any] = [:]
+            blockData["blockText"] = block.text
+            blockData["blockCornerPoints"] = processCornerPoints(block.cornerPoints)
+            blockData["blockFrame"] = processFrame(block.frame)
+            blockData["lines"] = processLines(lines: block.lines)
+            blocksArray.append(blockData)
+        }
+        return blocksArray
+    }
+
+    private static func processLines(lines:[TextLine]) -> Array<Any> {
+        var linesArray : [Any] = []
+        for line in lines {
+            var lineData : [String:Any] = [:]
+            lineData["lineText"] = line.text
+            lineData["lineLanguages"] = processRecognizedLanguages(line.recognizedLanguages)
+            lineData["lineCornerPoints"] = processCornerPoints(line.cornerPoints)
+            lineData["lineFrame"] = processFrame(line.frame)
+            lineData["elements"] = processElements(elements: line.elements)
+            linesArray.append(lineData)
+        }
+        return linesArray
+    }
+
+    private static func processElements(elements:[TextElement]) -> Array<Any> {
+        var elementsArray : [Any] = []
+
+        for element in elements {
+            var elementData : [String:Any] = [:]
+              elementData["elementText"] = element.text
+              elementData["elementCornerPoints"] = processCornerPoints(element.cornerPoints)
+              elementData["elementFrame"] = processFrame(element.frame)
+
+            elementsArray.append(elementData)
+          }
+
+        return elementsArray
+    }
+
+    private static func processRecognizedLanguages(_ languages: [TextRecognizedLanguage]) -> [String] {
+
+            var languageArray: [String] = []
+
+            for language in languages {
+                guard let code = language.languageCode else {
+                    print("No language code exists")
+                    break;
+                }
+                if code.isEmpty{
+                    languageArray.append("und")
+                }else {
+                    languageArray.append(code)
+
+                }
+            }
+
+            return languageArray
+        }
+
+    private static func processCornerPoints(_ cornerPoints: [NSValue]) -> [[String: CGFloat]] {
+        return cornerPoints.compactMap { $0.cgPointValue }.map { ["x": $0.x, "y": $0.y] }
+    }
+
+    private static func processFrame(_ frameRect: CGRect) -> [String: CGFloat] {
+        let offsetX = (frameRect.midX - ceil(frameRect.width)) / 2.0
+        let offsetY = (frameRect.midY - ceil(frameRect.height)) / 2.0
+
+        let x = frameRect.maxX + offsetX
+        let y = frameRect.minY + offsetY
+
+        return [
+            "x": frameRect.midX + (frameRect.midX - x),
+            "y": frameRect.midY + (y - frameRect.midY),
+            "width": frameRect.width,
+            "height": frameRect.height,
+            "boundingCenterX": frameRect.midX,
+            "boundingCenterY": frameRect.midY
+        ]
+    }
+
+    private func getOrientation(orientation: UIImage.Orientation) -> UIImage.Orientation {
+        switch orientation {
+        case .up:
+          return .up
+        case .left:
+          return .right
+        case .down:
+          return .down
+        case .right:
+          return .left
+        default:
+          return .up
+        }
+    }
+
+}

package/lib/module/NativeTrustchexSDK.js

@@ -0,0 +1,4 @@
+"use strict";
+
+import { TurboModuleRegistry } from 'react-native';
+export default TurboModuleRegistry.getEnforcing('TrustchexSDK');

package/lib/module/Screens/Dynamic/ContractAcceptanceScreen.js

@@ -0,0 +1,141 @@
+"use strict";
+
+import React, { useState, useContext, useCallback, useEffect, useRef } from 'react';
+import { SafeAreaView, View, Text, StyleSheet } from 'react-native';
+import WebView from 'react-native-webview';
+import NavigationManager from "../../Shared/Components/NavigationManager.js";
+import AppContext from "../../Shared/Contexts/AppContext.js";
+import { getI18n, useTranslation } from 'react-i18next';
+import { Button } from 'react-native-paper';
+import NativeDeviceInfo from "../../Shared/Libs/native-device-info.utils.js";
+import { speakWithDebounce } from "../../Shared/Libs/tts.utils.js";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+const ContractAcceptanceScreen = () => {
+  const [isEnabled, setIsEnabled] = useState(false);
+  const [isReady, setIsReady] = useState(false);
+  const appContext = useContext(AppContext);
+  const navigationManagerRef = React.useRef(null);
+  const [acceptedContractId, setAcceptedContractId] = useState();
+  const [contractUrl, setContractUrl] = useState();
+  const atTheEnd = useRef(false);
+  const {
+    t
+  } = useTranslation();
+  useEffect(() => {
+    const contracts = appContext.currentWorkflowStep?.data?.contracts;
+    if (!contracts) {
+      return;
+    }
+    const lang = getI18n().language.substring(0, 2).toLowerCase();
+    if (lang === 'tr') {
+      setAcceptedContractId(contracts?.tr.id);
+      setContractUrl(contracts?.tr.url);
+    } else {
+      setAcceptedContractId(contracts?.en.id);
+      setContractUrl(contracts?.en.url);
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [getI18n().language, appContext.currentWorkflowStep]);
+  const hasReachedEnd = useCallback(event => {
+    const {
+      layoutMeasurement,
+      contentOffset,
+      contentSize
+    } = event.nativeEvent;
+    const paddingToBottom = 10;
+    if (layoutMeasurement.height + contentOffset.y >= contentSize.height - paddingToBottom && isReady) {
+      setIsEnabled(true);
+      if (!atTheEnd.current) {
+        atTheEnd.current = true;
+        if (appContext.currentWorkflowStep?.data?.voiceGuidanceActive) {
+          speakWithDebounce(t('termsOfUseAndDataPrivacyScreen.footerTextSRO'));
+        }
+      }
+    } else {
+      setIsEnabled(false);
+      atTheEnd.current = false;
+    }
+  }, [appContext.currentWorkflowStep?.data?.voiceGuidanceActive, isReady, t]);
+  const generateHumanReadableIdentifier = useCallback(async () => {
+    return await NativeDeviceInfo.generateHumanReadableIdentifier();
+  }, []);
+  return /*#__PURE__*/_jsxs(SafeAreaView, {
+    style: styles.container,
+    children: [/*#__PURE__*/_jsx(WebView, {
+      source: {
+        uri: contractUrl || ''
+      },
+      javaScriptEnabled: true,
+      domStorageEnabled: false,
+      scalesPageToFit: false,
+      scrollEnabled: true,
+      style: styles.webView,
+      onLoadEnd: event => {
+        if (event.nativeEvent.url === contractUrl) {
+          setIsReady(true);
+          if (appContext.currentWorkflowStep?.data?.voiceGuidanceActive) {
+            speakWithDebounce(t('termsOfUseAndDataPrivacyScreen.footerText'));
+          }
+        }
+      },
+      onScroll: hasReachedEnd
+    }), /*#__PURE__*/_jsxs(View, {
+      style: styles.footer,
+      children: [/*#__PURE__*/_jsx(Text, {
+        style: styles.footerText,
+        children: t('termsOfUseAndDataPrivacyScreen.footerText')
+      }), /*#__PURE__*/_jsx(Button, {
+        mode: "contained",
+        disabled: !isEnabled,
+        onPress: async () => {
+          if (!acceptedContractId) {
+            return;
+          }
+          if (!appContext.identificationInfo.consent) {
+            appContext.identificationInfo.consent = {
+              contractIds: [],
+              deviceInfo: ''
+            };
+          }
+          const {
+            consent
+          } = appContext.identificationInfo;
+          if (!consent.contractIds.includes(acceptedContractId)) {
+            consent.contractIds.push(acceptedContractId);
+            consent.deviceInfo = await generateHumanReadableIdentifier();
+          }
+          navigationManagerRef.current?.navigateToNextStep();
+        },
+        children: t('termsOfUseAndDataPrivacyScreen.acceptAndContinue')
+      })]
+    }), /*#__PURE__*/_jsx(NavigationManager, {
+      ref: navigationManagerRef
+    })]
+  });
+};
+const styles = StyleSheet.create({
+  safeAreaContainer: {
+    flex: 1,
+    backgroundColor: 'white'
+  },
+  container: {
+    flex: 1
+  },
+  webView: {
+    flex: 1,
+    width: '100%',
+    height: '100%',
+    resizeMode: 'contain'
+  },
+  footer: {
+    flex: 0,
+    justifyContent: 'flex-end',
+    padding: 10
+  },
+  footerText: {
+    textAlign: 'center',
+    color: 'black',
+    marginBottom: 10
+  }
+});
+export default ContractAcceptanceScreen;

package/lib/module/Screens/Dynamic/IdentityDocumentEIDScanningScreen.js

@@ -0,0 +1,140 @@
+"use strict";
+
+import React, { useContext, useEffect, useState } from 'react';
+import { Alert, SafeAreaView, StyleSheet, View } from 'react-native';
+import EIDScanner from "../../Shared/Components/EIDScanner.js";
+import NavigationManager from "../../Shared/Components/NavigationManager.js";
+import AppContext from "../../Shared/Contexts/AppContext.js";
+import IdentityDocumentCamera from "../../Shared/Components/IdentityDocumentCamera.js";
+import { useTranslation } from 'react-i18next';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+const IdentityDocumentEIDScanningScreen = () => {
+  const appContext = useContext(AppContext);
+  const navigationManagerRef = React.useRef(null);
+  const [idFrontSideData, setIDFrontSideData] = useState(null);
+  const [idBackSideData, setIDBackSideData] = useState(null);
+  const [passportData, setPassportData] = useState();
+  const [documentNumber, setDocumentNumber] = useState();
+  const [dateOfBirth, setDateOfBirth] = useState();
+  const [dateOfExpiry, setDateOfExpiry] = useState();
+  const [documentType, setDocumentType] = useState();
+  const [isNFCSupported, setIsNFCSupported] = useState(false);
+  const {
+    t
+  } = useTranslation();
+  const [allowedDocumentTypes, setAllowedDocumentTypes] = useState(null);
+  const [allowedCountries, setAllowedCountries] = useState(null);
+  useEffect(() => {
+    if (appContext.identificationInfo.scannedDocument?.mrzFields) {
+      const {
+        documentNumber: dn,
+        birthDate: bd,
+        expirationDate: ed,
+        documentCode: dc
+      } = appContext.identificationInfo.scannedDocument.mrzFields;
+      if (dn && bd && ed) {
+        setDocumentNumber(dn);
+        setDateOfBirth(bd);
+        setDateOfExpiry(ed);
+        setDocumentType(dc === 'I' ? 'ID' : dc === 'P' ? 'PASSPORT' : 'UNKNOWN');
+      }
+    }
+  }, [appContext.identificationInfo.scannedDocument]);
+  useEffect(() => {
+    setAllowedDocumentTypes(appContext.currentWorkflowStep?.data?.allowedDocumentTypes ?? null);
+    setAllowedCountries(appContext.currentWorkflowStep?.data?.allowedCountries ?? null);
+  }, [appContext.currentWorkflowStep]);
+  return /*#__PURE__*/_jsxs(SafeAreaView, {
+    style: styles.safeAreaContainer,
+    children: [documentNumber && dateOfBirth && dateOfExpiry ? /*#__PURE__*/_jsx(View, {
+      style: styles.container,
+      children: /*#__PURE__*/_jsx(EIDScanner, {
+        documentNumber: documentNumber,
+        dateOfBirth: dateOfBirth,
+        dateOfExpiry: dateOfExpiry,
+        documentType: documentType,
+        onScanSuccess: (mrzFields, faceImage, mimeType) => {
+          if (mrzFields && faceImage && mimeType) {
+            if (!appContext.identificationInfo.scannedDocument) {
+              appContext.identificationInfo.scannedDocument = {
+                documentType: 'UNKNOWN',
+                dataSource: 'UNKNOWN'
+              };
+            }
+            appContext.identificationInfo.scannedDocument.dataSource = 'EID';
+            appContext.identificationInfo.scannedDocument.mrzFields = mrzFields;
+            appContext.identificationInfo.scannedDocument.faceImage = faceImage;
+            appContext.identificationInfo.scannedDocument.faceImageMimeType = mimeType;
+            appContext.identificationInfo.scannedDocument.mrzText ||= idBackSideData?.mrzText || passportData?.mrzText;
+            appContext.identificationInfo.scannedDocument.frontImage ||= idFrontSideData?.image || passportData?.image;
+            appContext.identificationInfo.scannedDocument.backImage ||= idBackSideData?.image;
+            appContext.identificationInfo.scannedDocument.barcodeValue ||= idBackSideData?.barcodeValue;
+            appContext.identificationInfo.scannedDocument.documentType = mrzFields.documentCode === 'I' ? 'ID' : mrzFields.documentCode === 'P' ? 'PASSPORT' : 'UNKNOWN';
+            if (allowedCountries && allowedCountries.length > 0) {
+              const countryCode = mrzFields.issuingState;
+              if (!allowedCountries.includes(countryCode)) {
+                Alert.alert(t('general.error'), t('general.countryNotAllowed'));
+                appContext.onError?.(t('general.countryNotAllowed'));
+                navigationManagerRef.current?.reset();
+                return;
+              }
+            }
+            if (allowedDocumentTypes && allowedDocumentTypes.length > 0) {
+              const documentCode = mrzFields.documentCode;
+              if (!allowedDocumentTypes.includes(documentCode)) {
+                Alert.alert(t('general.error'), t('general.documentTypeNotAllowed'));
+                appContext.onError?.(t('general.documentTypeNotAllowed'));
+                navigationManagerRef.current?.reset();
+                return;
+              }
+            }
+            navigationManagerRef.current?.navigateToNextStep();
+          }
+        },
+        isNFCSupported: setIsNFCSupported
+      })
+    }) : /*#__PURE__*/_jsx(IdentityDocumentCamera, {
+      onlyMRZScan: true,
+      onIdentityDocumentScanned: data => {
+        if (data.documentType === 'ID_FRONT') {
+          setIDFrontSideData(data);
+        } else if (data.documentType === 'ID_BACK') {
+          setIDBackSideData(data);
+        } else if (data.documentType === 'PASSPORT') {
+          setPassportData(data);
+        }
+        if (data.mrzFields && data.mrzFields.documentNumber && data.mrzFields.birthDate && data.mrzFields.expirationDate) {
+          setDocumentNumber(data.mrzFields.documentNumber);
+          setDateOfBirth(data.mrzFields.birthDate);
+          setDateOfExpiry(data.mrzFields.expirationDate);
+          setDocumentType(data.mrzFields.documentCode === 'I' ? 'ID' : data.mrzFields?.documentCode === 'P' ? 'PASSPORT' : 'UNKNOWN');
+        }
+      },
+      showDebugImages: false
+    }), /*#__PURE__*/_jsx(View, {
+      style: styles.footer,
+      children: /*#__PURE__*/_jsx(NavigationManager, {
+        canSkipStep: !isNFCSupported && !!appContext.identificationInfo.scannedDocument?.faceImage && !!appContext.identificationInfo.scannedDocument?.frontImage && !!appContext.identificationInfo.scannedDocument?.mrzText,
+        ref: navigationManagerRef
+      })
+    })]
+  });
+};
+const styles = StyleSheet.create({
+  safeAreaContainer: {
+    flex: 1,
+    backgroundColor: 'white'
+  },
+  container: {
+    flex: 1,
+    flexDirection: 'column'
+  },
+  footer: {
+    flex: 0,
+    position: 'absolute',
+    bottom: 0,
+    width: '100%',
+    zIndex: 10
+  }
+});
+export default IdentityDocumentEIDScanningScreen;

package/lib/module/Screens/Dynamic/IdentityDocumentScanningScreen.js

@@ -0,0 +1,100 @@
+"use strict";
+
+import React, { useContext, useEffect, useState } from 'react';
+import { Alert, SafeAreaView, StyleSheet, View } from 'react-native';
+import IdentityDocumentCamera from "../../Shared/Components/IdentityDocumentCamera.js";
+import AppContext from "../../Shared/Contexts/AppContext.js";
+import NavigationManager from "../../Shared/Components/NavigationManager.js";
+import { useTranslation } from 'react-i18next';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+const IdentityDocumentScanningScreen = () => {
+  const [idFrontSideData, setIDFrontSideData] = useState(null);
+  const [idBackSideData, setIDBackSideData] = useState(null);
+  const [passportData, setPassportData] = useState();
+  const navigationManagerRef = React.useRef(null);
+  const appContext = useContext(AppContext);
+  const {
+    t
+  } = useTranslation();
+  const [allowedDocumentTypes, setAllowedDocumentTypes] = useState(null);
+  const [allowedCountries, setAllowedCountries] = useState(null);
+  useEffect(() => {
+    if ((idFrontSideData && idBackSideData || passportData) && appContext.identificationInfo && !appContext.identificationInfo.scannedDocument) {
+      appContext.identificationInfo.scannedDocument = {
+        documentType: 'UNKNOWN',
+        dataSource: 'UNKNOWN'
+      };
+      const mrzFields = idBackSideData?.mrzFields || passportData?.mrzFields;
+      const mrzText = idBackSideData?.mrzText || passportData?.mrzText;
+      appContext.identificationInfo.scannedDocument.dataSource = 'MRZ';
+      appContext.identificationInfo.scannedDocument.mrzFields = mrzFields;
+      appContext.identificationInfo.scannedDocument.mrzText = mrzText;
+      appContext.identificationInfo.scannedDocument.frontImage = idFrontSideData?.image || passportData?.image;
+      appContext.identificationInfo.scannedDocument.backImage = idBackSideData?.image;
+      appContext.identificationInfo.scannedDocument.faceImage = idFrontSideData?.faceImage || passportData?.faceImage;
+      appContext.identificationInfo.scannedDocument.faceImageMimeType = 'image/jpeg';
+      appContext.identificationInfo.scannedDocument.secondaryFaceImage = idFrontSideData?.secondaryFaceImage;
+      appContext.identificationInfo.scannedDocument.hologramImage = idFrontSideData?.hologramImage || passportData?.hologramImage;
+      appContext.identificationInfo.scannedDocument.barcodeValue = idBackSideData?.barcodeValue;
+      appContext.identificationInfo.scannedDocument.documentType = mrzFields.documentCode === 'I' ? 'ID' : mrzFields.documentCode === 'P' ? 'PASSPORT' : 'UNKNOWN';
+      if (allowedCountries && allowedCountries.length > 0) {
+        const countryCode = mrzFields.issuingState;
+        if (!allowedCountries.includes(countryCode)) {
+          Alert.alert(t('general.error'), t('general.countryNotAllowed'));
+          appContext.onError?.(t('general.countryNotAllowed'));
+          navigationManagerRef.current?.reset();
+          return;
+        }
+      }
+      if (allowedDocumentTypes && allowedDocumentTypes.length > 0) {
+        const documentCode = mrzFields.documentCode;
+        if (!allowedDocumentTypes.includes(documentCode)) {
+          Alert.alert(t('general.error'), t('general.documentTypeNotAllowed'));
+          appContext.onError?.(t('general.documentTypeNotAllowed'));
+          navigationManagerRef.current?.reset();
+          return;
+        }
+      }
+      setTimeout(() => navigationManagerRef.current?.navigateToNextStep(), 1000);
+    }
+  }, [idFrontSideData, idBackSideData, passportData, appContext.identificationInfo, allowedCountries, allowedDocumentTypes, t, appContext]);
+  useEffect(() => {
+    setAllowedDocumentTypes(appContext.currentWorkflowStep?.data?.allowedDocumentTypes ?? null);
+    setAllowedCountries(appContext.currentWorkflowStep?.data?.allowedCountries ?? null);
+  }, [appContext.currentWorkflowStep]);
+  return /*#__PURE__*/_jsxs(SafeAreaView, {
+    style: styles.container,
+    children: [/*#__PURE__*/_jsx(IdentityDocumentCamera, {
+      onlyMRZScan: false,
+      onIdentityDocumentScanned: data => {
+        if (data.documentType === 'ID_FRONT') {
+          setIDFrontSideData(data);
+        } else if (data.documentType === 'ID_BACK') {
+          setIDBackSideData(data);
+        } else if (data.documentType === 'PASSPORT') {
+          setPassportData(data);
+        }
+      },
+      showDebugImages: false
+    }), /*#__PURE__*/_jsx(View, {
+      style: styles.footer,
+      children: /*#__PURE__*/_jsx(NavigationManager, {
+        ref: navigationManagerRef
+      })
+    })]
+  });
+};
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+    backgroundColor: 'white'
+  },
+  footer: {
+    flex: 0,
+    position: 'absolute',
+    bottom: 0,
+    width: '100%',
+    zIndex: 10
+  }
+});
+export default IdentityDocumentScanningScreen;