Toda la lógica vive en C. Java solo administra el ciclo de vida del USB en Android; no hay reglas de negocio en la capa Java.

Este driver es un port de APDUGT.dll. Solo cambió la capa de transporte: todo lo que interpreta la tarjeta se mantiene byte por byte.

Nueve funciones exportadas desde include/apdugt.h, con extern "C" para consumo desde C++.

/* Inicializa la conexión con el lector USB.
   fd, ep_out y ep_in provienen de la capa Java. */
int  APDUGT_Init(int fd, int ep_out, int ep_in);
void APDUGT_Release(void);

int  APDUGT_IsCardPresent(void);
int  APDUGT_GetATR(char* atr);
int  APDUGT_GetChipVersion(char* version);

int  APDUGT_ReadDPI(APDUGT_DPIData* data);
void APDUGT_FreeDPIData(APDUGT_DPIData* data);

La clase studio.bitmedia.APDUGT carga libapdugt.so y expone la API nativa como métodos estáticos.

package studio.bitmedia;

import studio.bitmedia.android.model.DPIData;

public class APDUGT {
    static { System.loadLibrary("apdugt"); }

    /* Inicializa con el file descriptor USB y sus endpoints */
    public static native int     init(int fd, int epOut, int epIn);
    public static native void    close();
    public static native boolean isCardPresent();
    public static native String  getATR();
    public static native String  getChipVersion();
    public static native int     readDPI(DPIData dpiData);
}

// 1. Localizar el lector CCID y pedir permiso USB
val reader = USBReaderManager(context)
reader.setCallback(object : USBReaderManager.ReaderCallback {
    override fun onReaderConnected(device: UsbDevice) { /* listo para leer */ }
    override fun onReaderDisconnected() { }
    override fun onPermissionDenied() { }
    override fun onDPIRead(data: DPIData) { }
    override fun onError(message: String) { }
})
reader.registerReceiver()
reader.findReader()

// 2. Leer la tarjeta
val data = reader.readDPI()
if (data != null && data.isValid) {
    Log.i(TAG, "Chip:   ${data.chipVersion}")
    Log.i(TAG, "CUI:    ${data.cui}")
    Log.i(TAG, "Nombre: ${data.nombreCompleto}")

    // La foto llega como JPEG listo para decodificar
    val foto = BitmapFactory.decodeByteArray(data.photoData, 0, data.photoSize)
}

// 3. Liberar
reader.disconnect()

// fd viene de UsbDeviceConnection.getFileDescriptor()
int rc = APDUGT.init(fd, epOut, epIn);

if (rc == 0 && APDUGT.isCardPresent()) {
    String version = APDUGT.getChipVersion();   // "2009" … "2024"
    DPIData data = new DPIData();

    if (APDUGT.readDPI(data) == 0) {
        Log.i(TAG, data.cui + " — " + data.nombreCompleto);
    } else {
        Log.e(TAG, "SW=" + data.lastSW1 + "/" + data.lastSW2);
    }
}

APDUGT.close();

USBReaderManager resuelve todo lo que Android exige alrededor del USB Host, para que la aplicación no tenga que tocar la API de bajo nivel.

• Detección por clase, no por modelo — recorre los dispositivos conectados y toma el primero cuya interfaz sea de clase CCID (0x0B), en lugar de mantener una lista de VID/PID
• Permiso USB en tiempo de ejecución — solicita el permiso con PendingIntent, aplicando FLAG_MUTABLE en API 31+
• Endpoints automáticos — localiza los endpoints bulk IN y OUT recorriendo la interfaz, sin valores fijos en el código
• Reconexión ante detach espurio — el BroadcastReceiver reintenta la conexión tras 500 ms antes de reportar el lector como desconectado
• Compatible con Android 13+ — registra el receiver con RECEIVER_NOT_EXPORTED en TIRAMISU y superiores
• Callbacks explícitos — onReaderConnected, onReaderDisconnected, onPermissionDenied, onDPIRead y onError

Una sola lectura llena un objeto DPIData con todos los campos del documento. El JNI escribe cada campo por reflexión, así que no hay parsing en Java.

El driver identifica la generación del chip comparando el ATR y despacha al parser correspondiente. La aplicación no necesita saber qué tarjeta tiene enfrente.

Toda la API devuelve 0 en éxito o un código negativo. APDUGT_GetErrorMessage() traduce cada código a un mensaje legible en español.

Cualquier lector de contacto que exponga una interfaz USB de clase CCID debería funcionar. Estos son los verificados:

Se distribuye libapdugt.so compilada para las cuatro ABIs de Android:

El SDK se compila con el NDK dentro de tu propio proyecto, mediante externalNativeBuild.

app/src/main/cpp/APDUGT/

android {
    ndkVersion "26.0.10792818"

    externalNativeBuild {
        cmake {
            path "src/main/cpp/APDUGT/CMakeLists.txt"
        }
    }
}

<uses-feature android:name="android.hardware.usb.host" />

La versión 1.0 cerró un ciclo completo de endurecimiento con un objetivo concreto: lecturas consecutivas sin caídas, sin fugas de memoria y sin bloqueos.

• Memoria acotada — las reservas en pila bajaron de 65 KB a menos de 2 KB, con validación de límites en cada copia de datos provenientes del hardware
• JNI en heap — la estructura de datos se asigna en heap dentro del JNI, eliminando un marco de pila de más de 15 KB
• Acceso serializado — pthread_mutex en los siete puntos de entrada públicos
• Detección no destructiva — la presencia de tarjeta se consulta con GetSlotStatus, sin reiniciar la sesión
• Recuperación ante fallos USB — reintento con backoff de 50 ms y 100 ms, y recuperación de sesión ante errores transitorios
• Respuestas fragmentadas — encadenamiento GET RESPONSE resuelto de forma transparente dentro del transporte
• Status word verificado — SW1/SW2 comprobados en los 34 puntos donde se transmite un APDU, y propagados hasta Java
• Criptografía validada — SHA-1, 3DES y MAC contrastados contra vectores de prueba conocidos (KAT) del NIST
• Binario endurecido — -fstack-protector-strong, _FORTIFY_SOURCE=2, relro, now y noexecstack

• Dispositivo Android con soporte USB Host (OTG)
• Lector de smartcard de contacto con interfaz USB CCID
• Android Studio con NDK y CMake instalados desde el SDK Manager
• Permiso USB concedido por el usuario en tiempo de ejecución
• No requiere root ni permisos de sistema