@trustchex/react-native-sdk 1.163.7 → 1.163.10

package/TrustchexSDK.podspec

@@ -18,7 +18,6 @@ Pod::Spec.new do |s|
 
   # ML Kit dependencies
   s.dependency "MLKitTextRecognition", "7.0.0"
-  s.dependency "MLKitBarcodeScanning", "8.0.0"
   s.dependency "MLKitFaceDetection", "8.0.0"
 
   # Camera dependency

package/ios/VisionCameraPlugins/BarcodeScanner/BarcodeScannerFrameProcessorPlugin-Bridging-Header.h

@@ -0,0 +1,9 @@
+#ifndef BarcodeScannerFrameProcessorPlugin_Bridging_Header_h
+#define BarcodeScannerFrameProcessorPlugin_Bridging_Header_h
+
+#if VISION_CAMERA_ENABLE_FRAME_PROCESSORS
+#import <VisionCamera/FrameProcessorPlugin.h>
+#import <VisionCamera/Frame.h>
+#endif
+
+#endif /* BarcodeScannerFrameProcessorPlugin_Bridging_Header_h */

package/ios/VisionCameraPlugins/BarcodeScanner/BarcodeScannerFrameProcessorPlugin.swift

@@ -1,172 +1,188 @@
 import Foundation
-import VisionCamera
 import Vision
+import VisionCamera
 
 @objc(BarcodeScannerFrameProcessorPlugin)
 public class BarcodeScannerFrameProcessorPlugin: FrameProcessorPlugin {
 
-    public override func callback(_ frame: Frame, withArguments arguments: [AnyHashable: Any]?) -> Any? {
-        guard let imageBuffer = CMSampleBufferGetImageBuffer(frame.buffer) else {
-            return []
-        }
+  public override init(proxy: VisionCameraProxyHolder, options: [AnyHashable: Any]! = [:]) {
+    super.init(proxy: proxy, options: options)
+    print(
+      "BarcodeScannerFrameProcessorPlugin: Initialized with options: \(String(describing: options))"
+    )
+  }
+
+  public override func callback(_ frame: Frame, withArguments arguments: [AnyHashable: Any]?)
+    -> Any?
+  {
+    print("BarcodeScannerFrameProcessorPlugin: callback called")
+
+    // Get the pixel buffer from the frame
+    guard let imageBuffer = CMSampleBufferGetImageBuffer(frame.buffer) else {
+      print("BarcodeScannerFrameProcessorPlugin: Could not get pixel buffer from frame")
+      return []
+    }
 
-        let visionImage = VNImageRequestHandler(cvPixelBuffer: imageBuffer, orientation: .up, options: [:])
-
-        // Configure barcode types
-        var symbologies: [VNBarcodeSymbology] = [
-            .aztec, .code128, .code39, .code93, .dataMatrix,
-            .ean13, .ean8, .i2of5, .pdf417, .qr, .upce, .codabar
-        ]
-
-        // Filter by specified barcode types if provided
-        if let arguments = arguments,
-           let barcodeTypes = arguments["barcodeTypes"] as? [String] {
-            symbologies = barcodeTypes.compactMap { type in
-                switch type {
-                case "aztec":
-                    return .aztec
-                case "codabar":
-                    return .codabar
-                case "code-128":
-                    return .code128
-                case "code-39":
-                    return .code39
-                case "code-93":
-                    return .code93
-                case "data-matrix":
-                    return .dataMatrix
-                case "ean-13":
-                    return .ean13
-                case "ean-8":
-                    return .ean8
-                case "itf":
-                    return .i2of5
-                case "pdf-417":
-                    return .pdf417
-                case "qr":
-                    return .qr
-                case "upc-e":
-                    return .upce
-                default:
-                    return nil
-                }
-            }
+    // Parse barcode types from arguments (default to QR codes)
+    var symbologies: [VNBarcodeSymbology] = [.qr]
+
+    if let arguments = arguments,
+      let barcodeTypes = arguments["barcodeTypes"] as? [String]
+    {
+      symbologies = barcodeTypes.compactMap { type in
+        switch type {
+        case "aztec": return .aztec
+        case "codabar": return .codabar
+        case "code-128": return .code128
+        case "code-39": return .code39
+        case "code-93": return .code93
+        case "data-matrix": return .dataMatrix
+        case "ean-13": return .ean13
+        case "ean-8": return .ean8
+        case "itf": return .i2of5
+        case "pdf-417": return .pdf417
+        case "qr": return .qr
+        case "upc-a": return .ean13  // UPC-A is subset of EAN-13
+        case "upc-e": return .upce
+        default: return nil
         }
+      }
+    }
 
-        let request = VNDetectBarcodesRequest { [weak self] request, error in
-            // This callback runs asynchronously
-        }
-        request.symbologies = symbologies
+    // Use semaphore to make async Vision calls synchronous for frame processor
+    let semaphore = DispatchSemaphore(value: 0)
+    var detectedBarcodes: [VNBarcodeObservation] = []
+    var visionError: Error? = nil
 
-        var detectedBarcodes: [VNBarcodeObservation] = []
+    // Create Vision request handler
+    let handler = VNImageRequestHandler(cvPixelBuffer: imageBuffer, options: [:])
 
-        do {
-            try visionImage.perform([request])
-            detectedBarcodes = request.results as? [VNBarcodeObservation] ?? []
-        } catch {
-            return []
-        }
+    // Create barcode detection request
+    let request = VNDetectBarcodesRequest { (request, error) in
+      defer { semaphore.signal() }
 
-        let result = detectedBarcodes.map { barcode -> [String: Any] in
-            var barcodeDict: [String: Any] = [:]
-
-            // Add barcode value
-            barcodeDict["value"] = barcode.payloadStringValue
-
-            // Add barcode type
-            let type: String
-            switch barcode.symbology {
-            case .aztec:
-                type = "aztec"
-            case .codabar:
-                type = "codabar"
-            case .code128:
-                type = "code-128"
-            case .code39:
-                type = "code-39"
-            case .code93:
-                type = "code-93"
-            case .dataMatrix:
-                type = "data-matrix"
-            case .ean13:
-                type = "ean-13"
-            case .ean8:
-                type = "ean-8"
-            case .i2of5, .i2of5Checksum, .itf14:
-                type = "itf"
-            case .pdf417:
-                type = "pdf-417"
-            case .qr:
-                type = "qr"
-            case .upce:
-                type = "upc-e"
-            default:
-                type = "unknown"
-            }
-            barcodeDict["type"] = type
-
-            // Convert bounding box to our format
-            let boundingBox = barcode.boundingBox
-            let imageSize = CGSize(width: CVPixelBufferGetWidth(imageBuffer), height: CVPixelBufferGetHeight(imageBuffer))
-
-            // Vision framework uses normalized coordinates (0-1), convert to pixel coordinates
-            let origin = CGPoint(
-                x: boundingBox.origin.x * imageSize.width,
-                y: (1 - boundingBox.origin.y - boundingBox.size.height) * imageSize.height // Flip Y coordinate
-            )
-            let size = CGSize(
-                width: boundingBox.size.width * imageSize.width,
-                height: boundingBox.size.height * imageSize.height
-            )
-
-            barcodeDict["boundingBox"] = [
-                "origin": [
-                    "x": origin.x,
-                    "y": origin.y
-                ],
-                "size": [
-                    "width": size.width,
-                    "height": size.height
-                ]
-            ]
-
-            // Convert corner points to our format
-            let topLeft = CGPoint(
-                x: barcode.topLeft.x * imageSize.width,
-                y: (1 - barcode.topLeft.y) * imageSize.height
-            )
-            let topRight = CGPoint(
-                x: barcode.topRight.x * imageSize.width,
-                y: (1 - barcode.topRight.y) * imageSize.height
-            )
-            let bottomLeft = CGPoint(
-                x: barcode.bottomLeft.x * imageSize.width,
-                y: (1 - barcode.bottomLeft.y) * imageSize.height
-            )
-            let bottomRight = CGPoint(
-                x: barcode.bottomRight.x * imageSize.width,
-                y: (1 - barcode.bottomRight.y) * imageSize.height
-            )
-
-            barcodeDict["cornerPoints"] = [
-                ["x": topLeft.x, "y": topLeft.y],
-                ["x": topRight.x, "y": topRight.y],
-                ["x": bottomRight.x, "y": bottomRight.y],
-                ["x": bottomLeft.x, "y": bottomLeft.y]
-            ]
-
-            // Add native data
-            var nativeDict: [String: Any] = [:]
-
-            if let descriptor = barcode.barcodeDescriptor {
-                nativeDict["descriptor"] = descriptor
-            }
-
-            barcodeDict["native"] = nativeDict
-
-            return barcodeDict
-        }
+      if let error = error {
+        print("BarcodeScannerFrameProcessorPlugin: Vision error: \(error.localizedDescription)")
+        visionError = error
+        return
+      }
 
-        return result
+      detectedBarcodes = request.results as? [VNBarcodeObservation] ?? []
+      print("BarcodeScannerFrameProcessorPlugin: Detected \(detectedBarcodes.count) barcodes")
     }
+
+    // Set symbologies
+    request.symbologies = symbologies
+
+    // Perform the request
+    do {
+      try handler.perform([request])
+    } catch {
+      print(
+        "BarcodeScannerFrameProcessorPlugin: Error performing Vision request: \(error.localizedDescription)"
+      )
+      return []
+    }
+
+    // Wait for completion with timeout
+    let waitResult = semaphore.wait(timeout: .now() + 0.1)  // 100ms timeout
+    if waitResult == .timedOut {
+      print("BarcodeScannerFrameProcessorPlugin: Vision request timed out")
+      return []
+    }
+
+    // Check for errors
+    if let error = visionError {
+      print(
+        "BarcodeScannerFrameProcessorPlugin: Vision processing failed: \(error.localizedDescription)"
+      )
+      return []
+    }
+
+    // Convert results to pixel coordinates at iOS level
+    let result = detectedBarcodes.compactMap { barcode -> [String: Any]? in
+      guard let barcodeValue = barcode.payloadStringValue, !barcodeValue.isEmpty else {
+        return nil
+      }
+
+      print("BarcodeScannerFrameProcessorPlugin: Processing barcode: \(barcodeValue)")
+
+      var map: [String: Any] = [:]
+
+      // Main value that TypeScript interface expects
+      map["value"] = barcodeValue
+
+      // Convert from normalized (0-1) coordinates to pixel coordinates
+      let frameWidth = frame.width
+      let frameHeight = frame.height
+      let boundingBox = barcode.boundingBox
+
+      // Convert from normalized (0-1) with bottom-left origin to pixel coordinates with top-left origin
+      let left = boundingBox.origin.x * CGFloat(frameWidth)
+      let bottom = boundingBox.origin.y * CGFloat(frameHeight)
+      let width = boundingBox.size.width * CGFloat(frameWidth)
+      let height = boundingBox.size.height * CGFloat(frameHeight)
+      let top = CGFloat(frameHeight) - bottom - height  // Flip Y coordinate from bottom-left to top-left
+
+      // Create bounding box in pixel coordinates with top-left origin
+      map["boundingBox"] = [
+        "origin": [
+          "x": Int(left),
+          "y": Int(top),
+        ],
+        "size": [
+          "width": Int(width),
+          "height": Int(height),
+        ],
+      ]
+
+      // Convert corner points to pixel coordinates with top-left origin
+      let cornerPoints = [
+        [
+          "x": Int(barcode.topLeft.x * CGFloat(frameWidth)),
+          "y": Int((1.0 - barcode.topLeft.y) * CGFloat(frameHeight)),
+        ],
+        [
+          "x": Int(barcode.topRight.x * CGFloat(frameWidth)),
+          "y": Int((1.0 - barcode.topRight.y) * CGFloat(frameHeight)),
+        ],
+        [
+          "x": Int(barcode.bottomRight.x * CGFloat(frameWidth)),
+          "y": Int((1.0 - barcode.bottomRight.y) * CGFloat(frameHeight)),
+        ],
+        [
+          "x": Int(barcode.bottomLeft.x * CGFloat(frameWidth)),
+          "y": Int((1.0 - barcode.bottomLeft.y) * CGFloat(frameHeight)),
+        ],
+      ]
+      map["cornerPoints"] = cornerPoints
+
+      // Map barcode symbology to TypeScript BarcodeType strings
+      let typeString: String
+      switch barcode.symbology {
+      case .aztec: typeString = "aztec"
+      case .codabar: typeString = "codabar"
+      case .code128: typeString = "code-128"
+      case .code39: typeString = "code-39"
+      case .code93: typeString = "code-93"
+      case .dataMatrix: typeString = "data-matrix"
+      case .ean13: typeString = "ean-13"
+      case .ean8: typeString = "ean-8"
+      case .i2of5, .i2of5Checksum, .itf14: typeString = "itf"
+      case .pdf417: typeString = "pdf-417"
+      case .qr: typeString = "qr"
+      case .upce: typeString = "upc-e"
+      default: typeString = "unknown"
+      }
+      map["type"] = typeString
+
+      print(
+        "BarcodeScannerFrameProcessorPlugin: Converted barcode - value: \(barcodeValue), type: \(typeString), boundingBox: \(map["boundingBox"] ?? "nil")"
+      )
+      return map
+    }
+
+    print("BarcodeScannerFrameProcessorPlugin: Returning \(result.count) processed barcodes")
+    return result
+  }
 }

package/lib/module/Shared/Components/QrCodeScannerCamera.js

@@ -1,7 +1,7 @@
 "use strict";
 
 import React, { useEffect } from 'react';
-import { View, StyleSheet, ActivityIndicator, Text as TextView, Text, Linking } from 'react-native';
+import { View, StyleSheet, ActivityIndicator, Text as TextView, Text, Linking, Platform } from 'react-native';
 import { Camera, useCameraDevice, useCameraFormat, useCameraPermission, useFrameProcessor } from 'react-native-vision-camera';
 import { useRunOnJS, useSharedValue } from 'react-native-worklets-core';
 import { useKeepAwake } from "../Libs/native-keep-awake.utils.js";
@@ -71,8 +71,20 @@ const QrCodeScannerCamera = ({
     return false;
   };
   const handleQrCode = useRunOnJS((code, width, height, orientation) => {
-    if (isInScanningFrame(code, width, height, orientation) && code.value) {
-      onQrCodeScanned(code.value);
+    // TODO: Fix iOS coordinates - iOS coordinate system conversion may be incorrect
+    // causing frame checking to fail. Need to verify coordinate normalization
+    // between iOS Vision framework and React Native coordinate systems.
+
+    // On iOS, skip frame checking and scan any QR code found
+    if (Platform.OS === 'ios') {
+      if (code.value) {
+        onQrCodeScanned(code.value);
+      }
+    } else {
+      // On Android, continue with frame checking
+      if (isInScanningFrame(code, width, height, orientation) && code.value) {
+        onQrCodeScanned(code.value);
+      }
     }
   }, [onQrCodeScanned]);
   const frameProcessor = useFrameProcessor(frame => {

package/lib/module/Shared/EIDReader/constants/eidConstants.js

@@ -0,0 +1,65 @@
+"use strict";
+
+/**
+ * Constants used throughout the EID Reader module.
+ * This file helps avoid circular dependencies by centralizing shared constants.
+ */
+
+export const EID_CONSTANTS = {
+  // Transceive lengths
+  EXTENDED_MAX_TRANSCEIVE_LENGTH: 65536,
+  NORMAL_MAX_TRANSCEIVE_LENGTH: 256,
+  DEFAULT_MAX_BLOCKSIZE: 223,
+  // File identifiers
+  EF_CARD_ACCESS: 0x011c,
+  EF_CARD_SECURITY: 0x011d,
+  EF_DG1: 0x0101,
+  EF_DG2: 0x0102,
+  EF_DG3: 0x0103,
+  EF_DG4: 0x0104,
+  EF_DG5: 0x0105,
+  EF_DG6: 0x0106,
+  EF_DG7: 0x0107,
+  EF_DG8: 0x0108,
+  EF_DG9: 0x0109,
+  EF_DG10: 0x010a,
+  EF_DG11: 0x010b,
+  EF_DG12: 0x010c,
+  EF_DG13: 0x010d,
+  EF_DG14: 0x010e,
+  EF_DG15: 0x010f,
+  EF_DG16: 0x0110,
+  EF_SOD: 0x011d,
+  EF_COM: 0x011e,
+  EF_CVCA: 0x011c,
+  // Short file identifiers
+  SFI_CARD_ACCESS: 0x1c,
+  SFI_CARD_SECURITY: 0x1d,
+  SFI_DG1: 0x01,
+  SFI_DG2: 0x02,
+  SFI_DG3: 0x03,
+  SFI_DG4: 0x04,
+  SFI_DG5: 0x05,
+  SFI_DG6: 0x06,
+  SFI_DG7: 0x07,
+  SFI_DG8: 0x08,
+  SFI_DG9: 0x09,
+  SFI_DG10: 0x0a,
+  SFI_DG11: 0x0b,
+  SFI_DG12: 0x0c,
+  SFI_DG13: 0x0d,
+  SFI_DG14: 0x0e,
+  SFI_DG15: 0x0f,
+  SFI_DG16: 0x10,
+  SFI_COM: 0x1e,
+  SFI_SOD: 0x1d,
+  SFI_CVCA: 0x1c,
+  // PACE key references
+  NO_PACE_KEY_REFERENCE: 0x00,
+  MRZ_PACE_KEY_REFERENCE: 0x01,
+  CAN_PACE_KEY_REFERENCE: 0x02,
+  PIN_PACE_KEY_REFERENCE: 0x03,
+  PUK_PACE_KEY_REFERENCE: 0x04,
+  // Applet AID
+  APPLET_AID: new Uint8Array([0xa0, 0x00, 0x00, 0x02, 0x47, 0x10, 0x01])
+};

package/lib/module/Shared/EIDReader/data/country.js

@@ -1,25 +1,20 @@
 "use strict";
 
-import { ISOCountry } from "./isoCountry.js";
-import { UnicodeCountry } from "./unicodeCountry.js";
 export class Country {
-  static SUB_CLASSES = [ISOCountry, UnicodeCountry];
   static getInstance(code) {
+    // Note: This will be dynamically resolved at runtime
+    const {
+      CountryRegistry
+    } = require('./countryRegistry');
     if (typeof code === 'number') {
-      const values = Country.values();
-      for (const country of values) {
-        if (country.valueOf() === code) {
-          return country;
-        }
-      }
-      throw new Error('Illegal country code ' + code.toString(16));
+      return CountryRegistry.fromNumericCode(code);
     } else if (typeof code === 'string') {
       code = code.trim();
       switch (code.length) {
         case 2:
-          return Country.fromAlpha2(code);
+          return CountryRegistry.fromAlpha2(code);
         case 3:
-          return Country.fromAlpha3(code);
+          return CountryRegistry.fromAlpha3(code);
         default:
           throw new Error('Illegal country code ' + code);
       }
@@ -28,39 +23,21 @@ export class Country {
     }
   }
   static values() {
-    const result = [];
-    for (const subClass of Country.SUB_CLASSES) {
-      if (Country.isAssignable(subClass)) {
-        try {
-          const method = subClass.values;
-          const subClassValues = method.call(null);
-          result.push(...subClassValues);
-        } catch (e) {
-          console.debug(`Exception: ${e}`);
-        }
-      }
-    }
-    return result;
-  }
-  static fromAlpha2(code) {
-    const values = Country.values();
-    for (const country of values) {
-      if (country.toAlpha2Code() === code) {
-        return country;
-      }
-    }
-    throw new Error('Unknown country code ' + code);
+    const {
+      CountryRegistry
+    } = require('./countryRegistry');
+    return CountryRegistry.values();
   }
-  static fromAlpha3(code) {
-    const values = Country.values();
-    for (const country of values) {
-      if (country.toAlpha3Code() === code) {
-        return country;
-      }
-    }
-    throw new Error('Unknown country code ' + code);
+  static fromAlpha2(alpha2Code) {
+    const {
+      CountryRegistry
+    } = require('./countryRegistry');
+    return CountryRegistry.fromAlpha2(alpha2Code);
   }
-  static isAssignable(subClass) {
-    return subClass.prototype instanceof Country;
+  static fromAlpha3(alpha3Code) {
+    const {
+      CountryRegistry
+    } = require('./countryRegistry');
+    return CountryRegistry.fromAlpha3(alpha3Code);
   }
 }

package/lib/module/Shared/EIDReader/data/countryInterface.js

@@ -0,0 +1 @@
+"use strict";

package/lib/module/Shared/EIDReader/data/countryRegistry.js

@@ -0,0 +1,65 @@
+"use strict";
+
+/**
+ * Registry for country implementations to avoid circular dependencies.
+ */
+export class CountryRegistry {
+  static countryTypes = [];
+  static register(countryType) {
+    if (!CountryRegistry.countryTypes.includes(countryType)) {
+      CountryRegistry.countryTypes.push(countryType);
+    }
+  }
+  static getRegisteredTypes() {
+    return [...CountryRegistry.countryTypes];
+  }
+  static values() {
+    const result = [];
+    for (const countryType of CountryRegistry.countryTypes) {
+      try {
+        const values = countryType.values?.();
+        if (Array.isArray(values)) {
+          result.push(...values);
+        }
+      } catch (e) {
+        console.debug(`Exception getting values from ${countryType.name}: ${e}`);
+      }
+    }
+    return result;
+  }
+  static fromAlpha2(alpha2Code) {
+    for (const countryType of CountryRegistry.countryTypes) {
+      try {
+        const country = countryType.fromAlpha2?.(alpha2Code);
+        if (country) {
+          return country;
+        }
+      } catch (e) {
+        // Continue to next type
+      }
+    }
+    throw new Error(`Unknown country code: ${alpha2Code}`);
+  }
+  static fromAlpha3(alpha3Code) {
+    for (const countryType of CountryRegistry.countryTypes) {
+      try {
+        const country = countryType.fromAlpha3?.(alpha3Code);
+        if (country) {
+          return country;
+        }
+      } catch (e) {
+        // Continue to next type
+      }
+    }
+    throw new Error(`Unknown country code: ${alpha3Code}`);
+  }
+  static fromNumericCode(numericCode) {
+    const values = CountryRegistry.values();
+    for (const country of values) {
+      if (country.valueOf() === numericCode) {
+        return country;
+      }
+    }
+    throw new Error(`Unknown country code: ${numericCode.toString(16)}`);
+  }
+}

package/lib/module/Shared/EIDReader/data/isoCountry.js

@@ -1,6 +1,7 @@
 "use strict";
 
 import { Country } from "./country.js";
+import { CountryRegistry } from "./countryRegistry.js";
 export class ISOCountry extends Country {
   static AD = new ISOCountry(32, 'AD', 'AND', 'Andorra', 'Andorran');
   static AE = new ISOCountry(1924, 'AE', 'ARE', 'United Arab Emirates', 'Emirati, Emirian');
@@ -280,4 +281,7 @@ export class ISOCountry extends Country {
   toAlpha3Code() {
     return this.alpha3Code;
   }
-}
+}
+
+// Register this country type with the registry
+CountryRegistry.register(ISOCountry);

package/lib/module/Shared/EIDReader/data/unicodeCountry.js

@@ -1,6 +1,7 @@
 "use strict";
 
 import { Country } from "./country.js";
+import { CountryRegistry } from "./countryRegistry.js";
 export class UnicodeCountry extends Country {
   static AD = new UnicodeCountry(32, 'AD', 'AND', 'Andorra', 'Andorran');
   static AE = new UnicodeCountry(1924, 'AE', 'ARE', 'United Arab Emirates', 'Emirati, Emirian');
@@ -275,4 +276,7 @@ export class UnicodeCountry extends Country {
   toAlpha3Code() {
     return this.alpha3Code;
   }
-}
+}
+
+// Register this country type with the registry
+CountryRegistry.register(UnicodeCountry);

package/lib/module/Shared/EIDReader/defaultFileSystem.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import { EIDService } from "./eidService.js";
+import { EID_CONSTANTS } from "./constants/eidConstants.js";
 import { ByteArrayInputStream } from "./java/byteArrayInputStream.js";
 import { DefaultFileInfo } from "./defaultFileInfo.js";
 import { ISO7816_SW } from "./smartcards/iso7816.js";
@@ -19,7 +19,7 @@ export class DefaultFileSystem {
     this.isSelected = false;
     this.isSFIEnabled = isSFIEnabled;
     this.fidToSFI = fidToSFI;
-    this.maxReadBinaryLength = EIDService.EXTENDED_MAX_TRANSCEIVE_LENGTH;
+    this.maxReadBinaryLength = EID_CONSTANTS.EXTENDED_MAX_TRANSCEIVE_LENGTH;
   }
   setWrapper(wrapper) {
     this.oldWrapper = this.wrapper;
@@ -90,9 +90,9 @@ export class DefaultFileSystem {
       return result;
     } catch (error) {
       const sw = error.getSW();
-      if ((sw & ISO7816_SW.WRONG_LENGTH) === ISO7816_SW.WRONG_LENGTH && this.maxReadBinaryLength > EIDService.DEFAULT_MAX_BLOCKSIZE) {
+      if ((sw & ISO7816_SW.WRONG_LENGTH) === ISO7816_SW.WRONG_LENGTH && this.maxReadBinaryLength > EID_CONSTANTS.DEFAULT_MAX_BLOCKSIZE) {
         this.wrapper = this.oldWrapper;
-        this.maxReadBinaryLength = EIDService.DEFAULT_MAX_BLOCKSIZE;
+        this.maxReadBinaryLength = EID_CONSTANTS.DEFAULT_MAX_BLOCKSIZE;
         return new Uint8Array(0);
       }
       throw new Error(`Read binary failed on file ${fileInfo == null ? this.selectedFID.toString(16) : fileInfo}`);