qrdnicapacitor 1.0.3

package/android/src/main/java/com/cqesolutions/qrdnicapacitor/jj2000/MyFileFormatReader.java

@@ -0,0 +1,204 @@
+package com.cqesolutions.qrdnicapacitor.jj2000;
+
+import java.io.EOFException;
+import java.io.IOException;
+import java.util.Vector;
+
+
+import jj2000.j2k.fileformat.FileFormatBoxes;
+import jj2000.j2k.io.RandomAccessIO;
+import jj2000.j2k.util.FacilityManager;
+
+
+public class MyFileFormatReader implements FileFormatBoxes {
+    private RandomAccessIO in;
+    private Vector codeStreamPos;
+    private Vector codeStreamLength;
+    public boolean JP2FFUsed;
+
+    public MyFileFormatReader(RandomAccessIO in) {
+        this.in = in;
+    }
+
+    public void readFileFormat() throws IOException, EOFException {
+        boolean foundCodeStreamBoxes = false;
+        long longLength = 0L;
+        boolean jp2HeaderBoxFound = false;
+        boolean lastBoxFound = false;
+
+        try {
+           /* if(this.in.readInt() != 12)
+                throw new IOException("File is neither valid JP2 file nor valid JPEG 2000 codestream");
+            else if(this.in.readInt() != 1783636000)
+                throw new IOException("File is neither valid JP2 file nor valid JPEG 2000 codestream");
+            else if(this.in.readInt() != 218793738)
+            //if(this.in.readInt() != 12 || this.in.readInt() != 1783636000 || this.in.readInt() != 218793738)
+            {
+                this.in.seek(0);
+                short marker = this.in.readShort();
+                if(marker != -177) {
+                    throw new Error("File is neither valid JP2 file nor valid JPEG 2000 codestream");
+                }
+
+                this.JP2FFUsed = false;
+                this.in.seek(0);
+                return;
+            }
+
+            this.JP2FFUsed = true;
+            if(!this.readFileTypeBox()) {
+                throw new Error("Invalid JP2 file: File Type box missing");
+            }*/
+
+            this.in.seek(0); // <--- pruebas. para intentar posicionar el buffer.
+
+            while(!lastBoxFound) {
+                int pos = this.in.getPos();
+                int length = this.in.readInt();
+                if(pos + length == this.in.length()) {
+                    lastBoxFound = true;
+                }
+
+                int box = this.in.readInt();
+                if(length == 0) {
+                    lastBoxFound = true;
+                    length = this.in.length() - this.in.getPos();
+                } else {
+                    if(length == 1) {
+                        longLength = this.in.readLong();
+                        throw new IOException("File too long.");
+                    }
+
+                    longLength = 0L;
+                }
+
+                switch(box) {
+                case 1685074537:
+                    this.readIntPropertyBox(length);
+                    break;
+                case 1785737827:
+                    if(!jp2HeaderBoxFound) {
+                        throw new Error("Invalid JP2 file: JP2Header box not found before Contiguous codestream box ");
+                    }
+
+                    this.readContiguousCodeStreamBox((long)pos, length, longLength);
+                    break;
+                case 1785737832:
+                    if(jp2HeaderBoxFound) {
+                        throw new Error("Invalid JP2 file: Multiple JP2Header boxes found");
+                    }
+
+                    this.readJP2HeaderBox((long)pos, length, longLength);
+                    jp2HeaderBoxFound = true;
+                    break;
+                case 1969843814:
+                    this.readUUIDInfoBox(length);
+                    break;
+                case 1970628964:
+                    this.readUUIDBox(length);
+                    break;
+                case 2020437024:
+                    this.readXMLBox(length);
+                    break;
+                default:
+                    FacilityManager.getMsgLogger().printmsg(2, "Unknown box-type: 0x" + Integer.toHexString(box));
+                }
+
+                if(!lastBoxFound) {
+                    this.in.seek(pos + length);
+                }
+            }
+        } catch (EOFException var11) {
+            throw new Error("EOF reached before finding Contiguous Codestream Box");
+        }
+
+        if(this.codeStreamPos.size() == 0) {
+            throw new Error("Invalid JP2 file: Contiguous codestream box missing");
+        }
+    }
+
+    public boolean readFileTypeBox() throws IOException, EOFException {
+        long longLength = 0L;
+        boolean foundComp = false;
+        int pos = this.in.getPos();
+        int length = this.in.readInt();
+        if(length == 0) {
+            throw new Error("Zero-length of Profile Box");
+        } else if(this.in.readInt() != 1718909296) {
+            return false;
+        } else if(length == 1) {
+            longLength = this.in.readLong();
+            throw new IOException("File too long.");
+        } else {
+            this.in.readInt();
+            this.in.readInt();
+            int nComp = (length - 16) / 4;
+
+            for(int i = nComp; i > 0; --i) {
+                if(this.in.readInt() == 1785737760) {
+                    foundComp = true;
+                }
+            }
+
+            if(!foundComp) {
+                return false;
+            } else {
+                return true;
+            }
+        }
+    }
+
+    public boolean readJP2HeaderBox(long pos, int length, long longLength) throws IOException, EOFException {
+        if(length == 0) {
+            throw new Error("Zero-length of JP2Header Box");
+        } else {
+            return true;
+        }
+    }
+
+    public boolean readContiguousCodeStreamBox(long pos, int length, long longLength) throws IOException, EOFException {
+        int ccpos = this.in.getPos();
+        if(this.codeStreamPos == null) {
+            this.codeStreamPos = new Vector();
+        }
+
+        this.codeStreamPos.addElement(new Integer(ccpos));
+        if(this.codeStreamLength == null) {
+            this.codeStreamLength = new Vector();
+        }
+
+        this.codeStreamLength.addElement(new Integer(length));
+        return true;
+    }
+
+    public void readIntPropertyBox(int length) {
+    }
+
+    public void readXMLBox(int length) {
+    }
+
+    public void readUUIDBox(int length) {
+    }
+
+    public void readUUIDInfoBox(int length) {
+    }
+
+    public long[] getCodeStreamPos() {
+        int size = this.codeStreamPos.size();
+        long[] pos = new long[size];
+
+        for(int i = 0; i < size; ++i) {
+            pos[i] = ((Integer)((Integer)this.codeStreamPos.elementAt(i))).longValue();
+        }
+
+        return pos;
+    }
+
+    public int getFirstCodeStreamPos() {
+        return ((Integer)((Integer)this.codeStreamPos.elementAt(0))).intValue();
+    }
+
+    public int getFirstCodeStreamLength() {
+        return ((Integer)((Integer)this.codeStreamLength.elementAt(0))).intValue();
+    }
+}

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

@@ -0,0 +1,130 @@
+package com.cqesolutions.qrdnicapacitor;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.util.Base64;
+
+import com.cqesolutions.qrdnicapacitor.jj2000.J2kStreamDecoder;
+import com.getcapacitor.JSObject;
+import com.cqesolutions.qrdnidroid_project.QRDNIdroid;
+import com.cqesolutions.qrdnidroid_project.bean.EstadoLicencia;
+import com.cqesolutions.qrdnidroid_project.bean.MiDNIData;
+
+import org.json.JSONObject;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.util.Map;
+
+public class qrdni {
+
+    public JSObject configure(Context context, String license, Map<String, String> certConfig) {
+        // Convertimos el Map de certificados a un String JSON para tu librería
+        String jsonConfig = null;
+        if (certConfig != null && !certConfig.isEmpty()) {
+            jsonConfig = new JSONObject(certConfig).toString();
+        }
+
+        EstadoLicencia estado = QRDNIdroid.getInstance(context).initialize(license, jsonConfig);
+
+        JSObject ret = new JSObject();
+        ret.put("descripcion", estado.descripcion);
+        ret.put("APIKeyValida", estado.apiKeyValida);
+        ret.put("lecturaQRHabilitada", estado.lecturaQRHabilitada);
+        return ret;
+    }
+
+    public void validaMiDNIQR(Context context, String base64Data, QRDNIdroid.ResultCallback callback) {
+        try {
+            byte[] rawBytes = Base64.decode(base64Data, Base64.DEFAULT);
+            QRDNIdroid.getInstance(context).processQR(rawBytes, callback);
+        } catch (Exception e) {
+            callback.onError("Error decodificando Base64: " + e.getMessage());
+        }
+    }
+
+    // Mapeo manual similar al que hiciste en Swift
+    public JSObject mapMiDNIDataToJS(MiDNIData data) {
+        JSObject json = new JSObject();
+        json.put("dni", data.dni);
+        json.put("name", data.name);
+        json.put("surnames", data.surnames);
+        json.put("birthDate", data.birthDate);
+        json.put("expiryDate", data.expiryDate);
+        json.put("gender", data.gender);
+        json.put("address", data.address);
+        json.put("nationality", data.nationality);
+        json.put("parents", data.parents);
+        json.put("supportNumber", data.supportNumber);
+        json.put("birthPlace1", data.birthPlace1);
+        json.put("birthPlace2", data.birthPlace2);
+        json.put("birthPlace3", data.birthPlace3);
+
+        // Manejo de foto
+        if (data.photoData != null) {
+            try {
+                // 1. Decodificar el J2K usando el .jar que acabas de añadir
+                J2kStreamDecoder j2k = new J2kStreamDecoder();
+                ByteArrayInputStream bis = new ByteArrayInputStream(data.photoData);
+                Bitmap bitmap = j2k.decode(bis);
+
+                if (bitmap != null) {
+                    // 2. Convertir a JPEG estándar para que Ionic lo entienda
+                    ByteArrayOutputStream out = new ByteArrayOutputStream();
+                    bitmap.compress(Bitmap.CompressFormat.JPEG, 90, out);
+                    byte[] jpegBytes = out.toByteArray();
+
+                    // 3. Enviar a la parte web como Base64
+                    json.put("photoData", Base64.encodeToString(jpegBytes, Base64.NO_WRAP));
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+                json.put("photoData", ""); // Evitamos enviar datos corruptos
+            }
+        } else {
+            json.put("photoData", "");
+        }
+
+        json.put("isAdult", data.isAdult);
+        
+        // Criptografía y firmas
+        json.put("rawSignature", data.rawSignature != null ? Base64.encodeToString(data.rawSignature, Base64.NO_WRAP) : "");
+        json.put("signedData", data.signedData != null ? Base64.encodeToString(data.signedData, Base64.NO_WRAP) : "");
+        json.put("certificateRef", data.certificateRef);
+        json.put("type", data.type);
+
+        // Verificación (Status Mapping)
+        JSObject verificationJson = new JSObject();
+        if (data.verificationResult != null) {
+            String statusNative = data.verificationResult.status.name(); // .name() para obtener el String del Enum
+
+            switch (statusNative) {
+                case "VALID":
+                    verificationJson.put("status", "VALID");
+                    // Si tienes el certificado, añádelo aquí
+                    // verificationJson.put("certificate", data.getCertificate());
+                    break;
+                case "INVALID":
+                    verificationJson.put("status", "INVALID");
+                    break;
+                case "NO_CERTIFICATES":
+                    verificationJson.put("status", "NO_CERTIFICATES");
+                    break;
+                case "EXPIRED_QR":
+                    verificationJson.put("status", "EXPIRED_QR");
+                    break;
+                default:
+                    verificationJson.put("status", "INVALID");
+                    break;
+            }
+        } else {
+            verificationJson.put("status", "UNKNOWN");
+        }
+        json.put("verificationResult", verificationJson);
+
+        json.put("qrDataExpiry", data.qrDataExpiry);
+        json.put("fullBirthPlace", data.getFullBirthPlace());
+
+        return json;
+    }
+}

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

@@ -0,0 +1,109 @@
+package com.cqesolutions.qrdnicapacitor;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.util.Base64;
+
+import androidx.activity.result.ActivityResult;
+
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+import com.cqesolutions.qrdnidroid_project.QRDNIdroid;
+import com.cqesolutions.qrdnidroid_project.bean.MiDNIData;
+
+import java.nio.charset.StandardCharsets;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+@CapacitorPlugin(name = "qrdni", requestCodes = {12345})
+public class qrdniPlugin extends Plugin {
+    public static final String KEY_QR_CODE = "qr_code";
+    private qrdni implementation = new qrdni();
+
+    @PluginMethod
+    public void configure(PluginCall call) {
+        String license = call.getString("license", "");
+        JSObject certsObj = call.getObject("certs");
+        
+        // Convertimos JSObject a Map<String, String>
+        Map<String, String> certMap = new HashMap<>();
+        if (certsObj != null) {
+            Iterator<String> keys = certsObj.keys();
+            while (keys.hasNext()) {
+                String key = keys.next();
+                certMap.put(key, certsObj.getString(key));
+            }
+        }
+
+        JSObject result = implementation.configure(getContext(), license, certMap);
+        call.resolve(result);
+    }
+
+    @PluginMethod
+    public void validaMiDNIQR(PluginCall call) {
+        String base64Data = call.getString("data");
+
+        if (base64Data == null) {
+            call.reject("No se proporcionó el QR");
+            return;
+        }
+
+        // Llamamos a la implementación pasando un callback para manejar el hilo principal
+        implementation.validaMiDNIQR(getContext(), base64Data, new QRDNIdroid.ResultCallback() {
+            @Override
+            public void onSuccess(MiDNIData data) {
+                JSObject result = implementation.mapMiDNIDataToJS(data);
+                call.resolve(result);
+            }
+
+            @Override
+            public void onError(String errorMessage) {
+                call.reject(errorMessage);
+            }
+        });
+    }
+
+    @PluginMethod
+    public void abrirEscaner(PluginCall call) {
+        saveCall(call);
+        Intent intent = new Intent(getContext(), QrCodeScanner.class);
+        intent.putExtra("returnString", false);
+        // El número 12345 es un identificador cualquiera
+        startActivityForResult(call, intent, 12345);
+    }
+
+    @Override
+    protected void handleOnActivityResult(int requestCode, int resultCode, Intent data) {
+        super.handleOnActivityResult(requestCode, resultCode, data);
+
+        if (requestCode != 12345) {
+            return;
+        }
+        // Recuperamos la llamada guardada
+        PluginCall call = getSavedCall();
+
+        if (call == null) return;
+
+        if (resultCode == Activity.RESULT_OK && data != null) {
+            String base64QR = data.getStringExtra(KEY_QR_CODE);
+
+            // LLAMADA A LA LIBRERÍA
+            implementation.validaMiDNIQR(getContext(), base64QR, new QRDNIdroid.ResultCallback() {
+                @Override
+                public void onSuccess(MiDNIData data) {
+                    call.resolve(implementation.mapMiDNIDataToJS(data));
+                }
+                @Override
+                public void onError(String errorMessage) {
+                    call.reject(errorMessage);
+                }
+            });
+        } else {
+            call.reject("Escaneo cancelado");
+        }
+    }
+}

package/dist/docs.json

@@ -0,0 +1,255 @@
+{
+  "api": {
+    "name": "qrdniPlugin",
+    "slug": "qrdniplugin",
+    "docs": "",
+    "tags": [],
+    "methods": [
+      {
+        "name": "configure",
+        "signature": "(options: { license: string; certs?: { [key: string]: string; } | undefined; }) => Promise<EstadoLicencia>",
+        "parameters": [
+          {
+            "name": "options",
+            "docs": "",
+            "type": "{ license: string; certs?: { [key: string]: string; } | undefined; }"
+          }
+        ],
+        "returns": "Promise<EstadoLicencia>",
+        "tags": [],
+        "docs": "",
+        "complexTypes": [
+          "EstadoLicencia"
+        ],
+        "slug": "configure"
+      },
+      {
+        "name": "validaMiDNIQR",
+        "signature": "(options: { data: string; }) => Promise<MiDNIData>",
+        "parameters": [
+          {
+            "name": "options",
+            "docs": "",
+            "type": "{ data: string; }"
+          }
+        ],
+        "returns": "Promise<MiDNIData>",
+        "tags": [],
+        "docs": "",
+        "complexTypes": [
+          "MiDNIData"
+        ],
+        "slug": "validamidniqr"
+      },
+      {
+        "name": "abrirEscaner",
+        "signature": "() => Promise<any>",
+        "parameters": [],
+        "returns": "Promise<any>",
+        "tags": [],
+        "docs": "",
+        "complexTypes": [],
+        "slug": "abrirescaner"
+      }
+    ],
+    "properties": []
+  },
+  "interfaces": [
+    {
+      "name": "EstadoLicencia",
+      "slug": "estadolicencia",
+      "docs": "",
+      "tags": [],
+      "methods": [],
+      "properties": [
+        {
+          "name": "descripcion",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "APIKeyValida",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "boolean"
+        },
+        {
+          "name": "lecturaQRHabilitada",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "boolean"
+        }
+      ]
+    },
+    {
+      "name": "MiDNIData",
+      "slug": "midnidata",
+      "docs": "",
+      "tags": [],
+      "methods": [],
+      "properties": [
+        {
+          "name": "dni",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "name",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "surnames",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "birthDate",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "expiryDate",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "gender",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "address",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "nationality",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "parents",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "supportNumber",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "birthPlace1",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "birthPlace2",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "birthPlace3",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "photoData",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "isAdult",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "boolean | undefined"
+        },
+        {
+          "name": "rawSignature",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "signedData",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "certificateRef",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "type",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "number | undefined"
+        },
+        {
+          "name": "verificationResult",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "{ status: 'VALID' | 'INVALID' | 'NO_CERTIFICATES' | 'INVALID_QR' | 'EXPIRED_QR' | 'UNKNOWN'; certificate?: string | undefined; }"
+        },
+        {
+          "name": "qrDataExpiry",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "fullBirthPlace",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "string"
+        }
+      ]
+    }
+  ],
+  "enums": [],
+  "typeAliases": [],
+  "pluginConfigs": []
+}