@trustchex/react-native-sdk 1.362.6 → 1.381.0

package/src/Shared/Components/IdentityDocumentCamera.types.ts

@@ -0,0 +1,136 @@
+export type SecurityFeature =
+  | 'icao_photo' // ICAO uyumlu fotoğraf - ICAO compliant photo
+  | 'barcode' // Barkod
+  | 'hologram' // DOVID/OVD - hologram
+  | 'wet_signature' // Islak imza - wet signature
+  | 'guilloche' // Giyoş - complex line patterns
+  | 'rainbow_print' // Gökkuşağı baskı - color gradient
+  | 'ovi' // Optik değişken mürekkep - color-shifting ink
+  | 'latent_image' // Gizli görüntü - visible at angles
+  | 'microtext'; // Mikro yazı - tiny text
+
+export type DocumentScannedData = {
+  documentType: 'ID_FRONT' | 'ID_BACK' | 'PASSPORT' | 'UNKNOWN';
+  image: string;
+  faceImage?: string;
+  secondaryFaceImage?: string;
+  hologramImage?: string;
+  barcodeValue?: string;
+  mrzText?: string;
+  mrzFields?: MRZFields;
+  // BDDK Madde 7 - Visual security validation (NFC fallback)
+  securityFeaturesDetected?: SecurityFeature[];
+  documentTiltValidated?: boolean;
+  interactiveTouchValidated?: boolean;
+  serialNumberVerified?: boolean;
+  transitionPointsValidated?: boolean;
+};
+
+export type BlockText = {
+  blocks: BlocksData[];
+  resultText: string;
+  mrzOnlyText?: string;
+};
+
+export type BlocksData = {
+  blockFrame: FrameType;
+  blockCornerPoints: CornerPointsType;
+  lines: LinesData;
+  blockLanguages: string[] | [];
+  blockText: string;
+};
+
+export type CornerPointsType = [{ x: number; y: number }];
+
+export type FrameType = {
+  boundingCenterX: number;
+  boundingCenterY: number;
+  height: number;
+  width: number;
+  x: number;
+  y: number;
+};
+
+export type LinesData = [
+  lineCornerPoints: CornerPointsType,
+  elements: ElementsData,
+  lineFrame: FrameType,
+  lineLanguages: string[] | [],
+  lineText: string,
+];
+
+export type ElementsData = [
+  elementCornerPoints: CornerPointsType,
+  elementFrame: FrameType,
+  elementText: string,
+];
+
+export type PhotoOptions = {
+  uri: string;
+  orientation?:
+    | 'landscapeRight'
+    | 'portrait'
+    | 'portraitUpsideDown'
+    | 'landscapeLeft';
+};
+
+export interface IdentityDocumentCameraProps {
+  onlyMRZScan: boolean;
+  onIdentityDocumentScanned: (scannedData: DocumentScannedData) => void;
+  testMode?: boolean;
+}
+
+export interface Face {
+  bounds: { x: number; y: number; width: number; height: number };
+  rollAngle?: number;
+  pitchAngle?: number;
+  yawAngle?: number;
+  leftEyeOpenProbability?: number;
+  rightEyeOpenProbability?: number;
+  smilingProbability?: number;
+}
+
+export interface Barcode {
+  rawValue: string;
+  displayValue: string;
+  format: number;
+  boundingBox: { left: number; top: number; right: number; bottom: number };
+  cornerPoints: Array<{ x: number; y: number }>;
+  value?: string;
+}
+
+import type { MRZFields } from '../Types/mrzFields';
+
+export type ScanStep =
+  | 'SCAN_ID_FRONT_OR_PASSPORT'
+  | 'SCAN_ID_BACK'
+  | 'SCAN_HOLOGRAM'
+  | 'COMPLETED';
+
+export type ScanStatus = 'SEARCHING' | 'SCANNING' | 'SCANNED' | 'INCORRECT';
+
+export type DocumentType = 'ID_FRONT' | 'ID_BACK' | 'PASSPORT' | 'UNKNOWN';
+
+export type CompletedStep =
+  | 'SCAN_ID_FRONT_OR_PASSPORT'
+  | 'SCAN_ID_BACK'
+  | 'SCAN_HOLOGRAM'
+  | null;
+
+export type BoundsWithRotation = {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  rollAngle?: number;
+  cropPadding?: number;
+};
+
+export type BoundsWithAngle = {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  angle?: number;
+  corners?: Array<{ x: number; y: number }>;
+};

package/src/Shared/Components/IdentityDocumentCamera.utils.ts

@@ -0,0 +1,364 @@
+import { Dimensions } from 'react-native';
+import type {
+  ScanStep,
+  ScanStatus,
+  DocumentType,
+  Face,
+} from './IdentityDocumentCamera.types';
+import type { MRZFields } from '../Types/mrzFields';
+import {
+  SIGNATURE_REGEX,
+  PASSPORT_MRZ_PATTERN,
+} from './IdentityDocumentCamera.constants';
+import { debugLog, isDebugEnabled } from '../Libs/debug.utils';
+
+/**
+ * Frame-to-screen coordinate transform using FILL_CENTER scaling
+ */
+export function getFrameToScreenTransform(
+  frameWidth: number,
+  frameHeight: number
+) {
+  const screen = Dimensions.get('window');
+  const frameAspect = frameWidth / frameHeight;
+  const screenAspect = screen.width / screen.height;
+
+  let scale: number;
+  let offsetX = 0;
+  let offsetY = 0;
+
+  if (frameAspect > screenAspect) {
+    scale = screen.height / frameHeight;
+    offsetX = (frameWidth * scale - screen.width) / 2;
+  } else {
+    scale = screen.width / frameWidth;
+    offsetY = (frameHeight * scale - screen.height) / 2;
+  }
+
+  return { scale, offsetX, offsetY, screen };
+}
+
+/**
+ * Compute scan area bounds in frame coordinates
+ */
+export function getScanAreaBounds(frameWidth: number, frameHeight: number) {
+  const { scale, offsetX, offsetY, screen } = getFrameToScreenTransform(
+    frameWidth,
+    frameHeight
+  );
+
+  const scanLeft = (screen.width * 0.05 + offsetX) / scale;
+  const scanTop = (screen.height * 0.36 + offsetY) / scale;
+  const scanRight = (screen.width * 0.95 + offsetX) / scale;
+  const scanBottom = (screen.height * 0.64 + offsetY) / scale;
+
+  const isInsideScan = (x: number, y: number, w: number, h: number) =>
+    x >= scanLeft && y >= scanTop && x + w <= scanRight && y + h <= scanBottom;
+
+  return { scanLeft, scanTop, scanRight, scanBottom, isInsideScan };
+}
+
+/**
+ * Transform frame-space bounds to screen-space bounds
+ */
+export function transformBoundsToScreen(
+  bounds: { x: number; y: number; width: number; height: number },
+  scale: number,
+  offsetX: number,
+  offsetY: number
+) {
+  return {
+    x: bounds.x * scale - offsetX,
+    y: bounds.y * scale - offsetY,
+    width: bounds.width * scale,
+    height: bounds.height * scale,
+  };
+}
+
+/**
+ * Unified status message logic used by both voice guidance and render text.
+ * Returns the appropriate i18n key arguments for the current scan state.
+ */
+export function getStatusMessage(
+  nextStep: ScanStep,
+  status: ScanStatus,
+  detectedDocumentType: DocumentType,
+  isBrightnessLow: boolean,
+  isFrameBlurry: boolean,
+  allElementsDetected: boolean,
+  elementsOutsideScanArea: string[],
+  t: (key: string, params?: Record<string, unknown>) => string
+): string {
+  if (nextStep === 'COMPLETED') {
+    return t('identityDocumentCamera.scanCompleted');
+  }
+
+  if (status === 'INCORRECT') {
+    if (nextStep === 'SCAN_ID_FRONT_OR_PASSPORT') {
+      return t('identityDocumentCamera.alignIDFront');
+    }
+    if (nextStep === 'SCAN_ID_BACK') {
+      return t('identityDocumentCamera.alignIDBack');
+    }
+    if (nextStep === 'SCAN_HOLOGRAM') {
+      return t('identityDocumentCamera.alignIDFront');
+    }
+    return t('identityDocumentCamera.alignPhotoSide');
+  }
+
+  if (isBrightnessLow) {
+    return t('identityDocumentCamera.lowBrightness');
+  }
+
+  if (isFrameBlurry) {
+    return t('identityDocumentCamera.avoidBlur');
+  }
+
+  if (
+    status === 'SCANNING' &&
+    allElementsDetected &&
+    elementsOutsideScanArea.length === 0
+  ) {
+    if (nextStep === 'SCAN_ID_BACK') {
+      return t('identityDocumentCamera.idCardBackDetected');
+    }
+    if (detectedDocumentType === 'PASSPORT') {
+      return t('identityDocumentCamera.passportDetected');
+    }
+    if (detectedDocumentType === 'ID_FRONT') {
+      return t('identityDocumentCamera.idCardFrontDetected');
+    }
+    if (nextStep === 'SCAN_HOLOGRAM') {
+      return t('identityDocumentCamera.alignHologram');
+    }
+    return t('identityDocumentCamera.readingDocument');
+  }
+
+  if (elementsOutsideScanArea.length > 0) {
+    return t('identityDocumentCamera.centerDocument');
+  }
+
+  if (
+    (status === 'SCANNING' || status === 'SEARCHING') &&
+    !allElementsDetected
+  ) {
+    if (nextStep === 'SCAN_ID_BACK') {
+      return t('identityDocumentCamera.alignIDBack');
+    }
+    if (nextStep === 'SCAN_ID_FRONT_OR_PASSPORT') {
+      if (detectedDocumentType === 'PASSPORT') {
+        return t('identityDocumentCamera.alignPassport');
+      }
+      if (detectedDocumentType === 'ID_FRONT') {
+        return t('identityDocumentCamera.alignIDFront');
+      }
+      return t('identityDocumentCamera.alignPhotoSide');
+    }
+    if (nextStep === 'SCAN_HOLOGRAM') {
+      return t('identityDocumentCamera.alignHologram');
+    }
+    return t('identityDocumentCamera.readingDocument');
+  }
+
+  // Default fallback
+  if (nextStep === 'SCAN_ID_FRONT_OR_PASSPORT') {
+    return status === 'SCANNING'
+      ? t('identityDocumentCamera.readingDocument')
+      : t('identityDocumentCamera.alignPhotoSide');
+  }
+  if (nextStep === 'SCAN_HOLOGRAM') {
+    return t('identityDocumentCamera.alignHologram');
+  }
+  if (nextStep === 'SCAN_ID_BACK') {
+    return status === 'SCANNING'
+      ? t('identityDocumentCamera.readingDocument')
+      : t('identityDocumentCamera.alignIDBackSide');
+  }
+
+  return '';
+}
+
+/**
+ * Calculate angle from two points in degrees
+ */
+export function angleBetweenPoints(
+  p1: { x: number; y: number },
+  p2: { x: number; y: number }
+): number {
+  const dx = p2.x - p1.x;
+  const dy = p2.y - p1.y;
+  return Math.atan2(dy, dx) * (180 / Math.PI);
+}
+
+/**
+ * Calculate distance between two points
+ */
+export function distanceBetweenPoints(
+  p1: { x: number; y: number },
+  p2: { x: number; y: number }
+): number {
+  const dx = p2.x - p1.x;
+  const dy = p2.y - p1.y;
+  return Math.sqrt(dx * dx + dy * dy);
+}
+
+/**
+ * Detect document type based on faces, OCR text, and MRZ fields
+ */
+export function detectDocumentType(
+  faces: Face[],
+  ocrText: string,
+  mrzFields?: MRZFields,
+  frameWidth?: number,
+  mrzText?: string | null
+): DocumentType {
+  // Relaxed signature detection: matches signature/imza variants and OCR errors
+  const hasSignatureMatch = SIGNATURE_REGEX.test(ocrText);
+
+  if (isDebugEnabled()) {
+    debugLog('IdentityDocumentCamera.utils', '[DocType] Detection', {
+      faces: faces.length,
+      hasMRZ: !!mrzFields,
+      hasMRZText: !!mrzText,
+      textLength: ocrText?.length,
+      hasSignature: hasSignatureMatch,
+    });
+  }
+
+  // ID Back: no face + ID MRZ
+  if (faces.length === 0 && mrzFields?.documentCode === 'I') {
+    return 'ID_BACK';
+  }
+
+  // Passport: face + passport MRZ
+  if (faces.length > 0 && mrzFields?.documentCode === 'P') {
+    return 'PASSPORT';
+  }
+
+  // Check for PASSPORT MRZ pattern BEFORE classifying as ID_FRONT
+  // Both passports and ID cards have face + signature, so we MUST check MRZ first
+  // Check BOTH parsed mrzText AND raw ocrText — MRZ parsing can fail while
+  // the raw OCR still contains P<TUR/P<USA pattern
+  const hasPassportMRZPattern =
+    (mrzText && mrzText.length > 20 && PASSPORT_MRZ_PATTERN.test(mrzText)) ||
+    PASSPORT_MRZ_PATTERN.test(ocrText);
+
+  if (hasPassportMRZPattern) {
+    // Passport MRZ pattern detected (P<TUR, P<USA, etc.)
+    // Even if not fully parsed, this is definitely a passport, not ID card
+    return 'PASSPORT';
+  }
+
+  // ID Front: face detected
+  // CRITICAL: Only classify as ID_FRONT when we're confident it's NOT a passport
+  // This means we must have either:
+  // 1. MRZ code 'I' (definitive ID card), OR
+  // 2. Face + signature but NO passport MRZ pattern visible
+  if (faces.length > 0 && ocrText?.length >= 5) {
+    // Filter to card-sized faces only (min 5% of frame width to exclude tiny background faces)
+    const cardSizedFaces = frameWidth
+      ? faces.filter(
+          (face) =>
+            face.bounds.width >= frameWidth * 0.05 &&
+            face.bounds.height >= frameWidth * 0.05
+        )
+      : faces;
+
+    if (cardSizedFaces.length > 0) {
+      // If we have MRZ code 'I', it's definitely an ID card
+      if (mrzFields?.documentCode === 'I') {
+        return 'ID_FRONT';
+      }
+
+      // If signature present and NO passport MRZ pattern, likely ID_FRONT
+      // But we can't be 100% sure yet - passport MRZ might appear in next frames
+      const hasSignature = hasSignatureMatch;
+      if (hasSignature && !hasPassportMRZPattern) {
+        return 'ID_FRONT';
+      }
+    }
+  }
+
+  return 'UNKNOWN';
+}
+
+/**
+ * Determine the document type to set based on current frame analysis
+ * Handles correction of misdetections and passport pattern checking
+ */
+export function determineDocumentTypeToSet(
+  documentType: DocumentType,
+  cardSizedFaces: Face[],
+  parsedMRZFields?: MRZFields,
+  mrzText?: string | null
+): DocumentType {
+  // CRITICAL: Passport MRZ always takes precedence over other detections
+  const hasPassportMRZ =
+    (mrzText && mrzText.length > 20 && PASSPORT_MRZ_PATTERN.test(mrzText)) ||
+    parsedMRZFields?.documentCode === 'P';
+
+  if (hasPassportMRZ) {
+    return 'PASSPORT';
+  }
+
+  // After passport MRZ check, accept the detected type directly
+  if (documentType === 'PASSPORT') return 'PASSPORT';
+  if (documentType === 'ID_FRONT') return 'ID_FRONT';
+  return 'UNKNOWN';
+}
+
+/**
+ * Compare MRZ field values (ignore raw text variations)
+ */
+export function areMRZFieldsEqual(fields1: any, fields2: any): boolean {
+  if (!fields1 || !fields2) return false;
+  // Compare critical fields that define document identity
+  return (
+    fields1.documentNumber === fields2.documentNumber &&
+    fields1.birthDate === fields2.birthDate &&
+    fields1.expirationDate === fields2.expirationDate &&
+    fields1.firstName === fields2.firstName &&
+    fields1.lastName === fields2.lastName &&
+    fields1.issuingState === fields2.issuingState
+  );
+}
+
+/**
+ * Check if all required MRZ fields are present
+ */
+export function hasRequiredMRZFields(fields: any): boolean {
+  return (
+    !!fields?.firstName &&
+    !!fields?.lastName &&
+    !!fields?.documentNumber &&
+    !!fields?.birthDate
+  );
+}
+
+/**
+ * Validate if face position has changed within acceptable tolerance
+ * Returns true if position is valid (within tolerance)
+ */
+export function validateFacePosition(
+  currentBounds: { x: number; y: number; width: number; height: number },
+  referenceBounds: { x: number; y: number; width: number; height: number },
+  isHologramStep: boolean
+): boolean {
+  const xDiff = Math.abs(currentBounds.x - referenceBounds.x);
+  const yDiff = Math.abs(currentBounds.y - referenceBounds.y);
+  const widthDiff = Math.abs(currentBounds.width - referenceBounds.width);
+  const heightDiff = Math.abs(currentBounds.height - referenceBounds.height);
+
+  // Use looser tolerance during hologram step since flash toggling causes position jitter
+  const tolerance = isHologramStep ? 0.5 : 0.2;
+  const xTolerance = referenceBounds.width * tolerance;
+  const yTolerance = referenceBounds.height * tolerance;
+  const sizeTolerance = referenceBounds.width * tolerance;
+
+  return (
+    xDiff <= xTolerance &&
+    yDiff <= yTolerance &&
+    widthDiff <= sizeTolerance &&
+    heightDiff <= sizeTolerance
+  );
+}

package/src/Shared/Components/QrCodeScannerCamera.tsx

@@ -20,7 +20,6 @@ import { useKeepAwake } from '../Libs/native-keep-awake.utils';
 import { useIsFocused } from '@react-navigation/native';
 import { useTranslation } from 'react-i18next';
 import { debugLog, logError } from '../Libs/debug.utils';
-import LottieView from 'lottie-react-native';
 import StyledButton from './StyledButton';
 import { useTheme } from '../Contexts/ThemeContext';
 import { useSafeAreaInsets } from 'react-native-safe-area-context';
@@ -193,14 +192,7 @@ const QrCodeScannerCamera = ({
       <View style={styles.leftZone} />
       <View style={styles.rightZone} />
       <View style={styles.bottomZone} />
-      <View style={styles.scanArea}>
-        <LottieView
-          source={require('../../Shared/Animations/scanning.json')}
-          style={styles.animation}
-          loop={true}
-          autoPlay
-        />
-      </View>
+      <View style={styles.scanArea} />
       {onClose && (
         <TouchableOpacity
           onPress={onClose}

package/src/Shared/Components/TrustchexCamera.tsx

@@ -102,6 +102,7 @@ interface TrustchexCameraProps {
   torchEnabled?: boolean;
   enableFrameProcessing?: boolean;
   targetFps?: number;
+  resolution?: string;
   // ML Kit detection modes — processing runs natively, results arrive in Frame
   enableFaceDetection?: boolean;
   enableTextRecognition?: boolean;