@trustchex/react-native-sdk 1.512.0 → 1.513.0

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

@@ -1,9 +1,10 @@
 "use strict";
 
 import React, { useContext, useEffect, useRef, useState } from 'react';
-import { SafeAreaView, View, Text, StyleSheet, ScrollView, Image, TouchableOpacity } from 'react-native';
+import { SafeAreaView, View, Text, StyleSheet, Image, TouchableOpacity, ActivityIndicator, NativeModules } from 'react-native';
 import { useSafeAreaInsets } from 'react-native-safe-area-context';
 import { useTranslation } from 'react-i18next';
+import LottieView from 'lottie-react-native';
 import { TrustchexCamera } from "../../Shared/Components/TrustchexCamera.js";
 import NavigationManager from "../../Shared/Components/NavigationManager.js";
 import AppContext from "../../Shared/Contexts/AppContext.js";
@@ -11,6 +12,50 @@ import StyledButton from "../../Shared/Components/StyledButton.js";
 import { useStatusBarWhiteBackground } from "../../Shared/Libs/status-bar.utils.js";
 import { useScreenTracking, trackVerificationStart, trackVerificationComplete } from "../../Shared/Libs/analytics.utils.js";
 import { useKeepAwake } from "../../Shared/Libs/native-keep-awake.utils.js";
+import { assessAddressProof } from "../../Shared/Libs/addressProofHeuristic.js";
+import { recognizeVizBlocks } from "../../Shared/Libs/vizName.js";
+import { MIN_BRIGHTNESS_THRESHOLD } from "../../Shared/Components/IdentityDocumentCamera.constants.js";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+const {
+  OpenCVModule
+} = NativeModules;
+
+// Quality thresholds for the captured proof photo. The darkness floor is shared
+// with the document camera (MIN_BRIGHTNESS_THRESHOLD) so a tuning pass applies
+// to both. The upper bound here is a FULL-FRAME mean-brightness cap for a
+// washed-out capture — deliberately looser than the document camera's
+// MAX_BRIGHTNESS_THRESHOLD (210), which is a REGION glare threshold, not a
+// full-frame mean.
+const MIN_BRIGHTNESS = MIN_BRIGHTNESS_THRESHOLD; // below → too dark
+const MAX_BRIGHTNESS = 245; // full-frame mean above → washed out / glare
+const BLUR_THRESHOLD = 50; // Laplacian variance below → too blurry
+
+/**
+ * Assess a captured proof photo. Brightness comes from the camera Frame (Y-plane
+ * luminance, computed natively per frame — no extra decode); only the blur check
+ * needs the image (native OpenCV Laplacian variance). Best-effort: returns ok
+ * when the native check is unavailable or throws, so an error never blocks.
+ */
+const assessImageQuality = async (base64Image, frameBrightness) => {
+  // Prefer the frame's native brightness; only fall back to a decode when the
+  // frame didn't carry one.
+  try {
+    let brightness = frameBrightness;
+    if (brightness == null && OpenCVModule) {
+      brightness = await OpenCVModule.getAverageBrightness(base64Image);
+    }
+    if (brightness != null) {
+      if (brightness < MIN_BRIGHTNESS) return 'dark';
+      if (brightness > MAX_BRIGHTNESS) return 'bright';
+    }
+    if (!OpenCVModule) return null;
+    const isBlurry = await OpenCVModule.checkBlurry(base64Image, BLUR_THRESHOLD);
+    if (isBlurry) return 'blurry';
+    return null;
+  } catch {
+    return null;
+  }
+};
 
 /**
  * ADDRESS_CAPTURE step (MASAK Tebliğ No. 32 Article 4/C(1)(d)). The user confirms
@@ -18,7 +63,6 @@ import { useKeepAwake } from "../../Shared/Libs/native-keep-awake.utils.js";
  * captures a proof document (residence cert / utility bill ≤3 months / public-
  * authority doc). The address is verified later by an operator (manual review).
  */
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 const AddressCaptureScreen = () => {
   useKeepAwake();
   useStatusBarWhiteBackground();
@@ -35,24 +79,103 @@ const AddressCaptureScreen = () => {
   // collects a PROOF-DOCUMENT photo for the operator's manual review. We show
   // the chip address read-only for context when available.
   const chipAddress = appContext.identificationInfo.address?.addressText ?? appContext.lastDocumentRead?.document.address ?? '';
+
+  // Holder name parts (chip/MRZ), used to check the captured proof actually
+  // shows this person's name. Prefer the corrected display name when available.
+  const docName = appContext.lastDocumentRead?.name;
+  const nameParts = [docName?.displayFirst, docName?.displayLast, docName?.rawFirst, docName?.rawLast];
+
+  // Whether the proof is mandatory is governed by the step's own `required`
+  // flag (like every other step) — there is no separate config. A required
+  // step blocks Continue until a proof photo is captured; an optional step
+  // lets the user proceed (and skip) without one. The skip affordance is the
+  // NavigationManager's, rendered on the guide for optional steps.
+
   const [proofImage, setProofImage] = useState();
   const [isCameraOpen, setIsCameraOpen] = useState(false);
+  const [isPreviewOpen, setIsPreviewOpen] = useState(false);
+  const [capturing, setCapturing] = useState(false);
+  const [qualityReason, setQualityReason] = useState(null);
+  // Soft content warning shown on the preview when the OCR text doesn't look
+  // like an address document with the holder's name. Never blocks Continue.
+  const [contentWarning, setContentWarning] = useState(null);
   const captureNextFrame = useRef(false);
+  // Mirrors proofImage for the async OCR guard (a stale OCR result must only
+  // apply to the photo currently being previewed).
+  const proofImageRef = useRef(undefined);
+  proofImageRef.current = proofImage;
   useEffect(() => {
     trackVerificationStart('ADDRESS_CAPTURE');
   }, []);
+  const openCamera = () => {
+    setQualityReason(null);
+    setContentWarning(null);
+    setIsPreviewOpen(false);
+    setIsCameraOpen(true);
+  };
   const onFrameAvailable = frame => {
-    if (!captureNextFrame.current) return;
+    if (!captureNextFrame.current || capturing) return;
     const b64 = frame.base64Image;
-    if (b64) {
-      captureNextFrame.current = false;
+    if (!b64) return;
+    captureNextFrame.current = false;
+    const frameBrightness = frame.brightness;
+    setCapturing(true);
+    // Gate acceptance on a quality check: a too-dark / too-bright / blurry
+    // photo keeps the camera open with a retake message instead of accepting it.
+    assessImageQuality(b64, frameBrightness).then(reason => {
+      setCapturing(false);
+      if (reason) {
+        setQualityReason(reason);
+        return;
+      }
+      setQualityReason(null);
+      setContentWarning(null);
       setProofImage(b64);
+      // Show the captured photo immediately (Retake / Continue) — don't make
+      // the user wait on OCR before seeing their photo.
       setIsCameraOpen(false);
-    }
+      setIsPreviewOpen(true);
+      // Soft content check runs in the background and fills in the warning. We
+      // OCR the FULL captured image (not frame.resultText, which the native
+      // camera crops to the MRZ ROI), so the name/address is actually in view.
+      // Best-effort: any failure → no warning, never blocks Continue.
+      assessProofContent(b64).then(warning => {
+        // Only apply if the user is still viewing THIS captured photo.
+        if (proofImageRef.current === b64) setContentWarning(warning);
+      });
+    });
   };
 
-  // A proof photo is the whole point of this step.
-  const canContinue = !!proofImage;
+  /// OCR the full captured image and run the address-proof heuristic. Returns
+  /// the warning key ('noName' | 'noAddress' | 'noText') or null when it looks
+  /// fine or the check can't run.
+  const assessProofContent = async b64 => {
+    try {
+      const blocks = await recognizeVizBlocks(b64);
+      const ocrText = blocks.map(b => b.text).join('\n');
+      const signals = assessAddressProof(ocrText, {
+        nameParts,
+        chipAddress
+      });
+      if (signals.ok) return null;
+      if (!signals.hasName && !signals.hasAddress) return 'noText';
+      return signals.hasName ? 'noAddress' : 'noName';
+    } catch {
+      return null;
+    }
+  };
+  const qualityMessage = () => {
+    switch (qualityReason) {
+      case 'dark':
+        return t('addressCaptureScreen.retakeTooDark');
+      case 'bright':
+        return t('addressCaptureScreen.retakeTooBright');
+      case 'blurry':
+        return t('addressCaptureScreen.retakeBlurry');
+      default:
+        return t('addressCaptureScreen.proofCameraHint');
+    }
+  };
   const onContinue = () => {
     // Attach the proof to the existing (chip-sourced) address without changing
     // the address text or fromChip flag. If for some reason no address object
@@ -64,175 +187,367 @@ const AddressCaptureScreen = () => {
       proofImage,
       proofImageMimeType: proofImage ? 'image/jpeg' : undefined
     };
+    setIsPreviewOpen(false);
     trackVerificationComplete('ADDRESS_CAPTURE', true, 1);
     navigationManagerRef.current?.navigateToNextStep();
   };
-  if (isCameraOpen) {
+
+  // Post-capture preview — confirm the photo, then Continue or Retake.
+  if (isPreviewOpen && proofImage) {
     return /*#__PURE__*/_jsxs(SafeAreaView, {
+      style: styles.previewContainer,
+      children: [/*#__PURE__*/_jsx(View, {
+        style: styles.previewImageWrap,
+        children: /*#__PURE__*/_jsx(Image, {
+          source: {
+            uri: `data:image/jpeg;base64,${proofImage}`
+          },
+          style: styles.previewImage,
+          resizeMode: "contain"
+        })
+      }), contentWarning ? /*#__PURE__*/_jsx(View, {
+        style: styles.previewWarning,
+        children: /*#__PURE__*/_jsx(Text, {
+          style: styles.previewWarningText,
+          children: contentWarning === 'noName' ? t('addressCaptureScreen.warnNoName') : contentWarning === 'noAddress' ? t('addressCaptureScreen.warnNoAddress') : t('addressCaptureScreen.warnNoText')
+        })
+      }) : /*#__PURE__*/_jsx(Text, {
+        style: styles.previewHint,
+        children: t('addressCaptureScreen.previewHint')
+      }), /*#__PURE__*/_jsxs(View, {
+        style: [styles.previewFooter, {
+          paddingBottom: insets.bottom + 12
+        }],
+        children: [/*#__PURE__*/_jsxs(View, {
+          style: styles.previewActions,
+          children: [/*#__PURE__*/_jsx(View, {
+            style: styles.previewActionItem,
+            children: /*#__PURE__*/_jsx(StyledButton, {
+              mode: "outlined",
+              onPress: openCamera,
+              children: t('addressCaptureScreen.retakeProof')
+            })
+          }), /*#__PURE__*/_jsx(View, {
+            style: styles.previewActionItem,
+            children: /*#__PURE__*/_jsx(StyledButton, {
+              onPress: onContinue,
+              children: t('general.continue')
+            })
+          })]
+        }), /*#__PURE__*/_jsx(NavigationManager, {
+          ref: navigationManagerRef
+        })]
+      })]
+    });
+  }
+  if (isCameraOpen) {
+    return /*#__PURE__*/_jsxs(View, {
       style: styles.cameraContainer,
       children: [/*#__PURE__*/_jsx(TrustchexCamera, {
-        style: styles.camera,
+        style: StyleSheet.absoluteFill,
+        cameraType: "back"
+        // The native camera emits onFrameAvailable when frame processing is on
+        // AND either a detector is enabled or includeBase64 is set. We only
+        // want the JPEG (no per-frame OCR), so includeBase64 alone keeps frames
+        // flowing; the proof photo is OCR'd once, on the still, at capture.
+        ,
+        enableFrameProcessing: true,
         includeBase64: true,
+        targetFps: 8,
         onFrameAvailable: e => onFrameAvailable(e.nativeEvent.frame)
+      }), /*#__PURE__*/_jsx(View, {
+        style: [styles.frameGuide, {
+          top: insets.top + 64,
+          bottom: insets.bottom + 210
+        }],
+        pointerEvents: "none"
+      }), /*#__PURE__*/_jsx(TouchableOpacity, {
+        style: [styles.cancelButton, {
+          top: insets.top + 12
+        }],
+        accessibilityLabel: t('general.cancel'),
+        onPress: () => {
+          captureNextFrame.current = false;
+          // Back to the guide (the only non-camera/non-preview screen).
+          setIsCameraOpen(false);
+        },
+        children: /*#__PURE__*/_jsx(Text, {
+          style: styles.cancelGlyph,
+          children: "\u2715"
+        })
       }), /*#__PURE__*/_jsxs(View, {
-        style: [styles.cameraControls, {
-          paddingBottom: insets.bottom + 16
+        style: [styles.cameraBottom, {
+          paddingBottom: insets.bottom + 28
         }],
-        children: [/*#__PURE__*/_jsx(Text, {
-          style: styles.cameraHint,
-          children: t('addressCaptureScreen.proofCameraHint')
-        }), /*#__PURE__*/_jsx(StyledButton, {
-          onPress: () => captureNextFrame.current = true,
-          children: t('addressCaptureScreen.capture')
-        }), /*#__PURE__*/_jsx(TouchableOpacity, {
-          onPress: () => setIsCameraOpen(false),
+        pointerEvents: "box-none",
+        children: [/*#__PURE__*/_jsx(View, {
+          style: [styles.cameraHintPill, qualityReason ? styles.cameraHintPillError : null],
           children: /*#__PURE__*/_jsx(Text, {
-            style: styles.cancel,
-            children: t('general.cancel')
+            style: styles.cameraHint,
+            children: qualityMessage()
+          })
+        }), /*#__PURE__*/_jsx(TouchableOpacity, {
+          style: styles.shutter,
+          disabled: capturing,
+          accessibilityLabel: t('addressCaptureScreen.capture'),
+          onPress: () => {
+            captureNextFrame.current = true;
+          },
+          children: capturing ? /*#__PURE__*/_jsx(ActivityIndicator, {
+            color: "#111"
+          }) : /*#__PURE__*/_jsx(View, {
+            style: styles.shutterInner
           })
         })]
       })]
     });
   }
+
+  // No interim form: the guide is the only non-camera/non-preview screen.
+  // Reached only if the camera was cancelled — fall back to the guide.
   return /*#__PURE__*/_jsxs(SafeAreaView, {
-    style: styles.container,
-    children: [/*#__PURE__*/_jsxs(ScrollView, {
-      contentContainerStyle: [styles.content, {
-        paddingBottom: insets.bottom + 24
-      }],
-      keyboardShouldPersistTaps: "handled",
-      children: [/*#__PURE__*/_jsx(Text, {
-        style: styles.title,
-        children: t('addressCaptureScreen.title')
+    style: styles.guideContainer,
+    children: [/*#__PURE__*/_jsxs(View, {
+      style: styles.guideContent,
+      children: [/*#__PURE__*/_jsx(LottieView, {
+        source: require('../../Shared/Animations/address-scan.json'),
+        style: styles.guideAnimation,
+        loop: true,
+        autoPlay: true
       }), /*#__PURE__*/_jsx(Text, {
-        style: styles.subtitle,
-        children: t('addressCaptureScreen.subtitle')
-      }), chipAddress ? /*#__PURE__*/_jsxs(_Fragment, {
+        style: styles.guideHeader,
+        children: t('addressCaptureScreen.guideHeader')
+      }), /*#__PURE__*/_jsxs(View, {
+        style: styles.guidePoints,
+        children: [/*#__PURE__*/_jsx(Text, {
+          style: styles.guideText,
+          children: t('addressCaptureScreen.guideText')
+        }), /*#__PURE__*/_jsxs(Text, {
+          style: styles.guidePoint,
+          children: ["\u2022 ", t('addressCaptureScreen.guidePointWholeDocument')]
+        }), /*#__PURE__*/_jsxs(Text, {
+          style: styles.guidePoint,
+          children: ["\u2022 ", t('addressCaptureScreen.guidePointLighting')]
+        }), /*#__PURE__*/_jsxs(Text, {
+          style: styles.guidePoint,
+          children: ["\u2022 ", t('addressCaptureScreen.guidePointSteady')]
+        }), /*#__PURE__*/_jsxs(Text, {
+          style: styles.guidePoint,
+          children: ["\u2022 ", t('addressCaptureScreen.guidePointDocuments')]
+        })]
+      }), chipAddress ? /*#__PURE__*/_jsxs(View, {
+        style: styles.chipAddressBox,
         children: [/*#__PURE__*/_jsx(Text, {
-          style: styles.label,
+          style: styles.chipAddressLabel,
           children: t('addressCaptureScreen.addressLabel')
-        }), /*#__PURE__*/_jsx(View, {
-          style: styles.readonlyAddress,
-          children: /*#__PURE__*/_jsx(Text, {
-            style: styles.readonlyAddressText,
-            children: chipAddress
-          })
         }), /*#__PURE__*/_jsx(Text, {
-          style: styles.chipHint,
+          style: styles.chipAddressText,
+          children: chipAddress
+        }), /*#__PURE__*/_jsx(Text, {
+          style: styles.chipAddressHint,
           children: t('addressCaptureScreen.prefilledFromChip')
         })]
-      }) : null, /*#__PURE__*/_jsx(Text, {
-        style: styles.label,
-        children: t('addressCaptureScreen.proofLabel')
-      }), /*#__PURE__*/_jsx(Text, {
-        style: styles.proofHint,
-        children: t('addressCaptureScreen.proofHint')
-      }), proofImage ? /*#__PURE__*/_jsx(Image, {
-        source: {
-          uri: `data:image/jpeg;base64,${proofImage}`
-        },
-        style: styles.proofPreview,
-        resizeMode: "cover"
-      }) : null, /*#__PURE__*/_jsx(StyledButton, {
-        onPress: () => setIsCameraOpen(true),
-        children: proofImage ? t('addressCaptureScreen.retakeProof') : t('addressCaptureScreen.captureProof')
+      }) : null, /*#__PURE__*/_jsx(View, {
+        style: styles.guideButton,
+        children: /*#__PURE__*/_jsx(StyledButton, {
+          onPress: openCamera,
+          children: t('general.letsGo')
+        })
       })]
-    }), /*#__PURE__*/_jsx(View, {
-      style: [styles.footer, {
-        paddingBottom: insets.bottom + 12
-      }],
-      children: /*#__PURE__*/_jsx(StyledButton, {
-        disabled: !canContinue,
-        onPress: onContinue,
-        children: t('general.continue')
-      })
     }), /*#__PURE__*/_jsx(NavigationManager, {
       ref: navigationManagerRef
     })]
   });
 };
 const styles = StyleSheet.create({
-  container: {
+  // Start guide — centered vertically + horizontally, like the other guides.
+  guideContainer: {
     flex: 1,
     backgroundColor: '#FFFFFF'
   },
-  content: {
-    padding: 20
+  // Inner wrapper carries the horizontal padding + centering, so it always
+  // applies regardless of the SafeAreaView's own inset handling on iOS.
+  guideContent: {
+    flex: 1,
+    paddingHorizontal: 24,
+    justifyContent: 'center',
+    alignItems: 'center'
   },
-  title: {
-    fontSize: 22,
-    fontWeight: '700',
-    color: '#111',
+  guideAnimation: {
+    width: 220,
+    height: 220,
     marginBottom: 8
   },
-  subtitle: {
-    fontSize: 15,
-    color: '#555',
-    marginBottom: 16
+  guideHeader: {
+    fontSize: 18,
+    fontWeight: '700',
+    color: '#000',
+    textAlign: 'center',
+    marginBottom: 10
   },
-  chipHint: {
-    fontSize: 13,
-    color: '#2E7D32',
+  // Subtitle + bullets: left-aligned block, full width.
+  guidePoints: {
+    alignSelf: 'stretch',
+    marginTop: 4
+  },
+  guideText: {
+    fontSize: 14,
+    color: '#000',
+    textAlign: 'left',
     marginBottom: 12
   },
-  label: {
+  guidePoint: {
     fontSize: 14,
-    fontWeight: '600',
-    color: '#222',
-    marginTop: 16,
-    marginBottom: 6
+    color: '#000',
+    textAlign: 'left',
+    lineHeight: 20,
+    marginTop: 10
   },
-  readonlyAddress: {
+  chipAddressBox: {
+    alignSelf: 'stretch',
+    marginTop: 16,
+    padding: 12,
     borderWidth: 1,
     borderColor: '#E0E0E0',
     backgroundColor: '#F7F7F7',
-    borderRadius: 8,
-    padding: 12,
-    minHeight: 56
+    borderRadius: 8
   },
-  readonlyAddressText: {
+  chipAddressLabel: {
+    fontSize: 13,
+    fontWeight: '600',
+    color: '#222',
+    marginBottom: 4
+  },
+  chipAddressText: {
     fontSize: 15,
     color: '#111'
   },
-  proofHint: {
-    fontSize: 13,
-    color: '#777',
-    marginBottom: 10
+  chipAddressHint: {
+    fontSize: 12,
+    color: '#2E7D32',
+    marginTop: 4
   },
-  proofPreview: {
+  guideButton: {
+    alignSelf: 'stretch',
+    marginTop: 24
+  },
+  // Post-capture preview — white screen, matching the rest of the app.
+  previewContainer: {
+    flex: 1,
+    backgroundColor: '#FFFFFF'
+  },
+  previewImageWrap: {
+    flex: 1,
+    padding: 16
+  },
+  previewImage: {
+    flex: 1,
     width: '100%',
-    height: 180,
-    borderRadius: 8,
+    borderRadius: 12
+  },
+  previewHint: {
+    color: '#555',
+    fontSize: 13,
+    textAlign: 'center',
+    paddingHorizontal: 20,
+    marginBottom: 12
+  },
+  previewWarning: {
+    marginHorizontal: 16,
     marginBottom: 12,
-    backgroundColor: '#EEE'
+    paddingHorizontal: 14,
+    paddingVertical: 10,
+    borderRadius: 8,
+    backgroundColor: '#FFF4E5',
+    borderWidth: 1,
+    borderColor: '#F0B27A'
   },
-  footer: {
+  previewWarningText: {
+    color: '#92400E',
+    fontSize: 13,
+    textAlign: 'center'
+  },
+  previewFooter: {
     paddingHorizontal: 20,
     paddingTop: 8,
-    backgroundColor: '#FFFFFF'
+    backgroundColor: '#FFFFFF',
+    gap: 4
+  },
+  previewActions: {
+    flexDirection: 'row',
+    gap: 12
+  },
+  previewActionItem: {
+    flex: 1
   },
   cameraContainer: {
     flex: 1,
     backgroundColor: '#000'
   },
-  camera: {
-    flex: 1
+  frameGuide: {
+    position: 'absolute',
+    left: 20,
+    right: 20,
+    borderWidth: 2,
+    borderColor: 'rgba(255,255,255,0.7)',
+    borderRadius: 12,
+    zIndex: 1
   },
-  cameraControls: {
-    paddingHorizontal: 20,
-    gap: 12,
-    backgroundColor: '#000'
+  cancelButton: {
+    position: 'absolute',
+    left: 16,
+    width: 44,
+    height: 44,
+    borderRadius: 22,
+    backgroundColor: 'rgba(0,0,0,0.45)',
+    alignItems: 'center',
+    justifyContent: 'center',
+    zIndex: 2
   },
-  cameraHint: {
+  cancelGlyph: {
     color: '#FFF',
-    textAlign: 'center',
-    marginBottom: 8
+    fontSize: 22,
+    fontWeight: '600',
+    lineHeight: 24
   },
-  cancel: {
+  cameraBottom: {
+    position: 'absolute',
+    left: 0,
+    right: 0,
+    bottom: 0,
+    alignItems: 'center'
+  },
+  cameraHintPill: {
+    maxWidth: '88%',
+    paddingHorizontal: 16,
+    paddingVertical: 10,
+    borderRadius: 10,
+    backgroundColor: 'rgba(0,0,0,0.55)',
+    marginBottom: 20
+  },
+  cameraHintPillError: {
+    backgroundColor: 'rgba(176,0,32,0.85)'
+  },
+  cameraHint: {
     color: '#FFF',
     textAlign: 'center',
-    marginTop: 8,
-    fontSize: 15
+    fontSize: 14
+  },
+  shutter: {
+    width: 74,
+    height: 74,
+    borderRadius: 37,
+    borderWidth: 4,
+    borderColor: 'rgba(255,255,255,0.85)',
+    backgroundColor: 'rgba(255,255,255,0.25)',
+    alignItems: 'center',
+    justifyContent: 'center'
+  },
+  shutterInner: {
+    width: 56,
+    height: 56,
+    borderRadius: 28,
+    backgroundColor: '#FFF'
   }
 });
 export default AddressCaptureScreen;

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

@@ -88,11 +88,16 @@ const IdentityDocumentEIDScanningScreen = () => {
         passportData?.mrzFields ?? idBackSideData?.mrzFields ?? idFrontSideData?.mrzFields ?? appContext.identificationInfo.scannedDocument?.mrzFields,
         vizImage:
         // Full data-page image from the EID step's camera scan. EIDScanner
-        // runs a one-shot OCR pass over it to recover the diacritic printed
-        // name when the chip's DG11 is absent or one-sided (e.g. Turkish
-        // passports). The live camera only OCRs a cropped MRZ region, so the
-        // printed name must be recovered from the full image here.
+        // OCRs it to recover the diacritic printed name when the chip's
+        // DG11 is absent or one-sided (e.g. Turkish passports). The live
+        // camera only OCRs a cropped MRZ region, so the printed name must
+        // be recovered from the full image here.
         passportData?.image ?? idFrontSideData?.image ?? idBackSideData?.image,
+        vizImages:
+        // All available captures — EIDScanner OCRs each and votes on the
+        // recovered name so a single noisy pass can't corrupt it. De-dup
+        // happens in EIDScanner, so overlap with `vizImage` is harmless.
+        [passportData?.image, idFrontSideData?.image, idBackSideData?.image],
         onScanSuccess: (mrzFields, faceImage, mimeType) => {
           if (mrzFields && faceImage && mimeType) {
             if (!appContext.identificationInfo.scannedDocument) {