qrdnicapacitor 1.0.8 → 1.0.9

package/Package.swift

@@ -11,7 +11,7 @@ let package = Package(
     ],
     dependencies: [
         .package(url: "https://github.com/ionic-team/capacitor-swift-pm.git", from: "8.0.0"),
-        .package(url: "https://github.com/diegocidm4/iQRDNI.git", from: "1.0.3"),
+        .package(url: "https://github.com/diegocidm4/iQRDNI.git", from: "1.0.4"),
         .package(url: "https://github.com/krzyzanowskim/CryptoSwift.git", exact: "1.6.0")
     ],
     targets: [

package/android/build.gradle

@@ -53,7 +53,7 @@ dependencies {
     //implementation(name: 'qrdnidroid-release', ext: 'aar')
     implementation files('libs/jpeg2000.jar')
     implementation fileTree(dir: 'libs', include: ['*.jar', '*.aar'])
-    implementation ('me.dm7.barcodescanner:zxing:1.9.8') {
+    implementation ('com.journeyapps:zxing-android-embedded:4.3.0'){
         exclude group: 'com.android.support'
     }
     implementation project(':capacitor-android')

package/android/src/main/java/com/cqesolutions/qrdnicapacitor/QrCodeScanner.java

@@ -7,78 +7,165 @@ import android.util.Log;
 
 import androidx.appcompat.app.AppCompatActivity;
 
+import com.google.zxing.BarcodeFormat;
+import com.google.zxing.DecodeHintType;
 import com.google.zxing.Result;
+import com.google.zxing.ResultMetadataType;
+import com.google.zxing.ResultPoint;
+import com.journeyapps.barcodescanner.BarcodeCallback;
+import com.journeyapps.barcodescanner.BarcodeResult;
+import com.journeyapps.barcodescanner.BarcodeView;
+import com.journeyapps.barcodescanner.DefaultDecoderFactory;
 
-import me.dm7.barcodescanner.zxing.ZXingScannerView;
+import java.io.ByteArrayOutputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
 
-public class QrCodeScanner extends AppCompatActivity implements ZXingScannerView.ResultHandler {
+
+
+public class QrCodeScanner extends AppCompatActivity {
     public static final String KEY_QR_CODE = "qr_code";
-    private ZXingScannerView mScannerView;
+    private BarcodeView mBarcodeView;
     private Boolean returnString = true;
+    private boolean handled = false; // evita procesar el mismo QR dos veces
+
     @Override
     public void onCreate(Bundle state) {
         super.onCreate(state);
-        // Programmatically initialize the scanner view
-        mScannerView = new ZXingScannerView(this);
-        // Set the scanner view as the content view
-        if(getIntent().hasExtra("returnString")) {
+
+        if (getIntent().hasExtra("returnString")) {
             returnString = (Boolean) getIntent().getExtras().get("returnString");
         }
 
-        setContentView(mScannerView);
+        mBarcodeView = new BarcodeView(this);
+
+        // CONFIGURACIÓN CLAVE: forzar ISO-8859-1 para que los segmentos byte
+        // se decodifiquen 1:1 y getText() reconstruya el payload sin pérdida
+        Map<DecodeHintType, Object> hints = new HashMap<>();
+        hints.put(DecodeHintType.CHARACTER_SET, "ISO-8859-1");
+        hints.put(DecodeHintType.TRY_HARDER, Boolean.TRUE);
+
+        mBarcodeView.setDecoderFactory(new DefaultDecoderFactory(
+                Collections.singletonList(BarcodeFormat.QR_CODE), // solo QR
+                hints,
+                "ISO-8859-1",
+                0)); // 0 = scan normal
+
+        mBarcodeView.setFramingRectSize(new com.journeyapps.barcodescanner.Size(1200, 1200));
+
+        setContentView(mBarcodeView);
+        mBarcodeView.decodeContinuous(callback);
     }
 
     @Override
     public void onResume() {
         super.onResume();
-        // Register ourselves as a handler for scan results.
-        mScannerView.setResultHandler(this);
-        // Start camera on resume
-        mScannerView.startCamera();
+        mBarcodeView.resume();
     }
 
     @Override
     public void onPause() {
         super.onPause();
-        // Stop camera on pause
-        mScannerView.stopCamera();
+        mBarcodeView.pause();
     }
+    private final BarcodeCallback callback = new BarcodeCallback() {
+        @Override
+        public void barcodeResult(BarcodeResult barcodeResult) {
+            handleResult(barcodeResult.getResult()); // Result original de ZXing
+        }
 
-    @Override
-    public void handleResult(Result rawResult) {
-        if(returnString)
-        {
+        @Override
+        public void possibleResultPoints(List<ResultPoint> resultPoints) {
+            // No necesario
+        }
+    };
+
+    private void handleResult(Result rawResult) {
+        if (handled) return;
+
+        if (returnString) {
+            handled = true;
             Intent intent = new Intent();
-            intent.putExtra(KEY_QR_CODE, rawResult.getText());
+            intent.putExtra(Constantes.KEY_QR_CODE, normalizeText(rawResult.getText()));
             setResult(RESULT_OK, intent);
             finish();
-        }
-        else {
+        } else {
             Log.i("QrCodeScanner", "QR detectado");
-            // 1. OBTENER BYTES CRUDOS (CRÍTICO PARA DNI 4.0)
-            // No uses getText() para datos binarios
-            byte[] rawBytes = rawResult.getRawBytes();
 
-            if (rawBytes != null && rawBytes.length > 0) {
+            byte[] rawBytes = extractPayload(rawResult);
 
-                // 2. CONVERTIR A BASE64
-                // Como tu fragmento 'DatosMiDnie' espera un String y hace un Base64.decode,
-                // aquí debemos hacer el Base64.encode.
+            if (rawBytes != null && rawBytes.length > 0) {
+                handled = true;
                 String base64Result = Base64.encodeToString(rawBytes, Base64.NO_WRAP);
-
-                // Debug: Ver longitud
                 Log.d("QrCodeScanner", "Bytes leídos: " + rawBytes.length);
 
-                // 3. RETORNAR EL RESULTADO
                 Intent intent = new Intent();
-                intent.putExtra(KEY_QR_CODE, base64Result);
+                intent.putExtra(Constantes.KEY_QR_CODE, base64Result);
                 setResult(RESULT_OK, intent);
                 finish();
             } else {
-                // Si falla la lectura de bytes, reanudamos la cámara
-                mScannerView.resumeCameraPreview(this);
+                // En modo continuo no hace falta reanudar nada:
+                // el escáner sigue intentándolo solo
+                Log.w("QrCodeScanner", "Payload vacío, reintentando...");
+            }
+        }
+    }
+
+    private byte[] extractPayload(Result result) {
+        // 1. Reconstrucción vía texto (con ISO-8859-1 forzado es determinista)
+        String text = result.getText();
+        if (text != null && !text.isEmpty()) {
+            byte[] full = text.getBytes(StandardCharsets.ISO_8859_1);
+            if (full.length > 2 && (full[0] & 0xFF) == 0xDC && (full[1] & 0xFF) == 0x03) {
+                Log.d("QrCodeScanner", "Payload vía getText (completo)");
+                return full;
+            }
+        }
+
+        // 2. Fallback: byte segments
+        Map<ResultMetadataType, Object> meta = result.getResultMetadata();
+        if (meta != null && meta.containsKey(ResultMetadataType.BYTE_SEGMENTS)) {
+            List<byte[]> segments = (List<byte[]>) meta.get(ResultMetadataType.BYTE_SEGMENTS);
+            if (segments != null && !segments.isEmpty()) {
+                ByteArrayOutputStream bos = new ByteArrayOutputStream();
+                for (byte[] seg : segments) {
+                    bos.write(seg, 0, seg.length);
+                }
+                byte[] payload = bos.toByteArray();
+                if (payload.length > 0) {
+                    Log.d("QrCodeScanner", "Payload vía BYTE_SEGMENTS (fallback)");
+                    return payload;
+                }
             }
         }
+        return result.getRawBytes(); // último recurso
     }
 
+    /**
+     * El decoder está forzado a ISO-8859-1 (necesario para QRs binarios del DNI).
+     * Para QRs de texto, eso convierte el UTF-8 real en mojibake (ñ, á...).
+     * Como ISO-8859-1 es 1:1 con los bytes, podemos recuperar los bytes originales
+     * y re-decodificarlos como UTF-8 si son UTF-8 válido.
+     */
+    private String normalizeText(String text) {
+        if (text == null || text.isEmpty()) return text;
+        byte[] raw = text.getBytes(StandardCharsets.ISO_8859_1);
+        if (isValidUtf8(raw)) {
+            return new String(raw, StandardCharsets.UTF_8);
+        }
+        return text; // ASCII puro o Latin-1 real: se queda como está
+    }
+
+    private boolean isValidUtf8(byte[] bytes) {
+        java.nio.charset.CharsetDecoder decoder = StandardCharsets.UTF_8.newDecoder();
+        try {
+            decoder.decode(java.nio.ByteBuffer.wrap(bytes));
+            return true;
+        } catch (java.nio.charset.CharacterCodingException e) {
+            return false;
+        }
+    }
 }

package/ios/Sources/qrdniPlugin/QRSegmentDecoder.swift

@@ -0,0 +1,102 @@
+//
+//  QRSegmentDecoder.swift
+//  TramiteFoto
+//
+//  Created by CQeSolutions on 07/06/2026.
+//  Copyright © 2026 Diego. All rights reserved.
+//
+
+
+//  QRSegmentDecoder.swift
+//  Reensambla el payload lógico de un QR a partir del stream de bits
+//  del errorCorrectedPayload, segmento a segmento (byte, alfanumérico,
+//  numérico), igual que hacen los decodificadores completos.
+
+import Foundation
+
+enum QRSegmentDecoder {
+
+    static func reassemble(payload: Data, version: Int) -> Data? {
+        let bytes = [UInt8](payload)
+        var bitPos = 0
+        let totalBits = bytes.count * 8
+
+        func readBits(_ n: Int) -> Int? {
+            guard n > 0, bitPos + n <= totalBits else { return nil }
+            var value = 0
+            for _ in 0..<n {
+                let byteIndex = bitPos >> 3
+                let bitIndex = 7 - (bitPos & 7)
+                value = (value << 1) | Int((bytes[byteIndex] >> UInt8(bitIndex)) & 1)
+                bitPos += 1
+            }
+            return value
+        }
+
+        func countBits(forMode mode: Int) -> Int? {
+            switch mode {
+            case 0b0001: return version <= 9 ? 10 : (version <= 26 ? 12 : 14) // numérico
+            case 0b0010: return version <= 9 ? 9  : (version <= 26 ? 11 : 13) // alfanumérico
+            case 0b0100: return version <= 9 ? 8  : 16                        // byte
+            default: return nil
+            }
+        }
+
+        let alphaTable = Array("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:".utf8)
+        var out = [UInt8]()
+
+        while bitPos + 4 <= totalBits {
+            guard let mode = readBits(4) else { break }
+            if mode == 0b0000 { break } // terminador
+
+            if mode == 0b0111 { // ECI: saltar el designador (1, 2 o 3 bytes)
+                guard let first = readBits(8) else { return nil }
+                if first & 0x80 != 0 {
+                    if first & 0x40 == 0 { _ = readBits(8) } else { _ = readBits(16) }
+                }
+                continue
+            }
+
+            guard let cBits = countBits(forMode: mode),
+                  let count = readBits(cBits) else { return nil }
+
+            switch mode {
+            case 0b0100: // BYTE: count bytes tal cual
+                for _ in 0..<count {
+                    guard let b = readBits(8) else { return nil }
+                    out.append(UInt8(b))
+                }
+            case 0b0010: // ALFANUMÉRICO: 11 bits por par de caracteres
+                var remaining = count
+                while remaining >= 2 {
+                    guard let v = readBits(11), v < 45 * 45 else { return nil }
+                    out.append(alphaTable[v / 45])
+                    out.append(alphaTable[v % 45])
+                    remaining -= 2
+                }
+                if remaining == 1 {
+                    guard let v = readBits(6), v < 45 else { return nil }
+                    out.append(alphaTable[v])
+                }
+            case 0b0001: // NUMÉRICO: 10 bits por trío de dígitos
+                var remaining = count
+                while remaining >= 3 {
+                    guard let v = readBits(10) else { return nil }
+                    out.append(contentsOf: String(format: "%03d", v).utf8)
+                    remaining -= 3
+                }
+                if remaining == 2 {
+                    guard let v = readBits(7) else { return nil }
+                    out.append(contentsOf: String(format: "%02d", v).utf8)
+                } else if remaining == 1 {
+                    guard let v = readBits(4) else { return nil }
+                    out.append(contentsOf: String(v).utf8)
+                }
+            default:
+                return nil // modo no soportado (kanji...): abortar al fallback
+            }
+        }
+
+        return out.isEmpty ? nil : Data(out)
+    }
+}

package/ios/Sources/qrdniPlugin/ScannerViewController.swift

@@ -8,65 +8,63 @@
 import AVFoundation
 import UIKit
 
+import AVFoundation
+import UIKit
+
 class ScannerViewController: UIViewController, AVCaptureMetadataOutputObjectsDelegate {
     var captureSession: AVCaptureSession!
     var previewLayer: AVCaptureVideoPreviewLayer!
     var returnString: Bool = true
-    
-    
+
     public func inicializa(returnString: Bool) {
         self.returnString = returnString
     }
-    
+
     override func viewDidLoad() {
         super.viewDidLoad()
-        view.backgroundColor = .black
 
-        // Creamos la sesión
+        view.backgroundColor = UIColor.black
         captureSession = AVCaptureSession()
 
-        // Ejecutamos la configuración pesada en segundo plano
-        DispatchQueue.global(qos: .userInitiated).async { [weak self] in
-            guard let self = self else { return }
-            
-            guard let videoCaptureDevice = AVCaptureDevice.default(for: .video) else { return }
-            let videoInput: AVCaptureDeviceInput
-
-            do {
-                videoInput = try AVCaptureDeviceInput(device: videoCaptureDevice)
-            } catch {
-                return
-            }
+        guard let videoCaptureDevice = AVCaptureDevice.default(for: .video) else { return }
+        let videoInput: AVCaptureDeviceInput
 
-            if (self.captureSession.canAddInput(videoInput)) {
-                self.captureSession.addInput(videoInput)
-            }
+        do {
+            videoInput = try AVCaptureDeviceInput(device: videoCaptureDevice)
+        } catch {
+            return
+        }
 
-            let metadataOutput = AVCaptureMetadataOutput()
+        if captureSession.canAddInput(videoInput) {
+            captureSession.addInput(videoInput)
+        } else {
+            failed()
+            return
+        }
 
-            if (self.captureSession.canAddOutput(metadataOutput)) {
-                self.captureSession.addOutput(metadataOutput)
-                metadataOutput.setMetadataObjectsDelegate(self, queue: DispatchQueue.main)
-                metadataOutput.metadataObjectTypes = [.qr]
-            }
+        let metadataOutput = AVCaptureMetadataOutput()
 
-            // La UI sí se actualiza en el Main Thread
-            DispatchQueue.main.async {
-                self.previewLayer = AVCaptureVideoPreviewLayer(session: self.captureSession)
-                self.previewLayer.frame = self.view.layer.bounds
-                self.previewLayer.videoGravity = .resizeAspectFill
-                self.view.layer.addSublayer(self.previewLayer)
-                
-                // Iniciamos la sesión fuera del hilo principal de nuevo
-                DispatchQueue.global(qos: .userInitiated).async {
-                    self.captureSession.startRunning()
-                }
-            }
+        if captureSession.canAddOutput(metadataOutput) {
+            captureSession.addOutput(metadataOutput)
+            metadataOutput.setMetadataObjectsDelegate(self, queue: DispatchQueue.main)
+            metadataOutput.metadataObjectTypes = [.qr]
+        } else {
+            failed()
+            return
         }
+
+        previewLayer = AVCaptureVideoPreviewLayer(session: captureSession)
+        previewLayer.frame = view.layer.bounds
+        previewLayer.videoGravity = .resizeAspectFill
+        view.layer.addSublayer(previewLayer)
+
+        captureSession.startRunning()
     }
-    
+
     func failed() {
-        let ac = UIAlertController(title: "Scanning not supported", message: "Your device does not support scanning a code from an item. Please use a device with a camera.", preferredStyle: .alert)
+        let ac = UIAlertController(title: "Scanning not supported",
+                                   message: "Your device does not support scanning a code from an item. Please use a device with a camera.",
+                                   preferredStyle: .alert)
         ac.addAction(UIAlertAction(title: "OK", style: .default))
         present(ac, animated: true)
         captureSession = nil
@@ -74,90 +72,64 @@ class ScannerViewController: UIViewController, AVCaptureMetadataOutputObjectsDel
 
     override func viewWillAppear(_ animated: Bool) {
         super.viewWillAppear(animated)
-
-        if (captureSession?.isRunning == false) {
+        if captureSession?.isRunning == false {
             captureSession.startRunning()
         }
     }
 
     override func viewWillDisappear(_ animated: Bool) {
         super.viewWillDisappear(animated)
-
-        if (captureSession?.isRunning == true) {
+        if captureSession?.isRunning == true {
             captureSession.stopRunning()
         }
     }
-/*
-    func metadataOutput(_ output: AVCaptureMetadataOutput, didOutput metadataObjects: [AVMetadataObject], from connection: AVCaptureConnection) {
-        captureSession.stopRunning()
-
-        var parametros: [String: Any] = [String: Any] ()
-        if(self.returnString)
-        {
-            if let metadataObject = metadataObjects.first {
-                guard let readableObject = metadataObject as? AVMetadataMachineReadableCodeObject else { return }
-                guard let stringValue = readableObject.stringValue else { return }
-                AudioServicesPlaySystemSound(SystemSoundID(kSystemSoundID_Vibrate))
-                parametros["qrcode"] = stringValue
+
+    func metadataOutput(_ output: AVCaptureMetadataOutput,
+                        didOutput metadataObjects: [AVMetadataObject],
+                        from connection: AVCaptureConnection) {
+
+        guard let readableObject = metadataObjects.first as? AVMetadataMachineReadableCodeObject else { return }
+
+        var parametros: [String: Any] = [:]
+
+        if returnString {
+            guard let stringValue = readableObject.stringValue else { return }
+            captureSession.stopRunning()
+            AudioServicesPlaySystemSound(SystemSoundID(kSystemSoundID_Vibrate))
+            parametros["qrcode"] = stringValue
+        } else {
+            // Le pasamos el OBJETO completo, no el payload:
+            // dentro decide entre stringValue (vía buena) y descriptor (fallback)
+            guard let payload = extractPayload(from: readableObject) else {
+                // Lectura inservible: no paramos la sesión, seguimos escaneando
+                return
             }
+            captureSession.stopRunning()
+            AudioServicesPlaySystemSound(SystemSoundID(kSystemSoundID_Vibrate))
+            parametros["qrcodeData"] = payload
         }
-        else {
-            if let metadataObject = metadataObjects.first as? AVMetadataMachineReadableCodeObject {
-                    
-                    // IMPORTANTE: Accedemos al descriptor, no al stringValue.
-                    // El descriptor contiene los bytes crudos (RAW) del QR.
-                    if let descriptor = metadataObject.descriptor as? CIQRCodeDescriptor {
-                        
-                        let rawPayload = descriptor.errorCorrectedPayload
-                        //print("Datos brutos: \(rawPayload.toPrettyHexString())")
-                        parametros["qrcodeData"] = rawPayload
-                    }
-                }
-        }
-        
-        NotificationCenter.default.post(name: NSNotification.Name(rawValue: "lecturaQR"), object: nil, userInfo: parametros)
+
+        NotificationCenter.default.post(name: NSNotification.Name(rawValue: "lecturaQR"),
+                                        object: nil,
+                                        userInfo: parametros)
     }
-*/
-    
-    func metadataOutput(_ output: AVCaptureMetadataOutput, didOutput metadataObjects: [AVMetadataObject], from connection: AVCaptureConnection) {
-        
-        // 1. Detenemos la sesión inmediatamente para evitar múltiples lecturas
-        // startRunning/stopRunning siempre fuera del hilo principal si es posible
-        DispatchQueue.global(qos: .userInitiated).async {
-            if self.captureSession.isRunning {
-                self.captureSession.stopRunning()
-            }
-        }
 
-        // 2. Procesamos los datos
-        guard let metadataObject = metadataObjects.first as? AVMetadataMachineReadableCodeObject,
-              let descriptor = metadataObject.descriptor as? CIQRCodeDescriptor else {
-            // Si falla, reiniciamos sesión
-            DispatchQueue.global(qos: .userInitiated).async { self.captureSession.startRunning() }
-            return
-        }
+    func extractPayload(from object: AVMetadataMachineReadableCodeObject) -> Data? {
+        guard let descriptor = object.descriptor as? CIQRCodeDescriptor else { return nil }
 
-        let rawPayload = descriptor.errorCorrectedPayload
-        let base64String = rawPayload.base64EncodedString()
-        
-        // Feedback táctico
-        AudioServicesPlaySystemSound(SystemSoundID(kSystemSoundID_Vibrate))
-
-        // 3. TODO el proceso pesado de validación y cierre debe ir fuera del hilo UI
-        // pero el 'dismiss' debe volver al Main para no congelar la pantalla
-        DispatchQueue.main.async {
-            let parametros: [String: Any] = ["qrcode": base64String]
-            
-            // Notificamos al Plugin
-            NotificationCenter.default.post(
-                name: NSNotification.Name(rawValue: "lecturaQR"),
-                object: nil,
-                userInfo: parametros
-            )
-            
-            // Cerramos la cámara
-            self.dismiss(animated: true, completion: nil)
-        }
+        let raw = descriptor.errorCorrectedPayload
+        let version = descriptor.symbolVersion
+
+        // 1. Reensamblado de segmentos a nivel de bits (la vía correcta)
+        if let reassembled = QRSegmentDecoder.reassemble(payload: raw, version: version),
+           reassembled.count > 2,
+           reassembled[reassembled.startIndex] == 0xDC,
+           reassembled[reassembled.startIndex + 1] == 0x03 {
+            return reassembled
+           }
+
+        // 2. Fallback: payload crudo; alignToMagicByte del parser lo intentará
+        return raw
     }
     
     override var prefersStatusBarHidden: Bool {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qrdnicapacitor",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "description": "Lectura y validación de códigos QR generados por la app MiDNI",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",