Android
Carte à puce

Carte à puce envoyer et recevoir

Pour la connexion, voici un extrait pour vous aider à comprendre:

//Allows you to enumerate and communicate with connected USB devices.
UsbManager mUsbManager = (UsbManager) getSystemService(Context.USB_SERVICE);
//Explicitly asking for permission
final String ACTION_USB_PERMISSION = "com.android.example.USB_PERMISSION";
PendingIntent mPermissionIntent = PendingIntent.getBroadcast(this, 0, new Intent(ACTION_USB_PERMISSION), 0);
HashMap<String, UsbDevice> deviceList = mUsbManager.getDeviceList();

UsbDevice device = deviceList.get("//the device you want to work with");
if (device != null) {
    mUsbManager.requestPermission(device, mPermissionIntent);
}

Maintenant, vous devez comprendre que dans Java, la communication a lieu en utilisant le package javax.smarcard qui n'est pas disponible pour Android, alors jetez un oeil ici pour avoir une idée de la façon de communiquer ou envoyer / recevoir APDU (commande smartcard).

Maintenant, comme indiqué dans la réponse mentionnée ci-dessus

Vous ne pouvez pas simplement envoyer une commande APDU (commande de carte à puce) sur le point de terminaison de la sortie groupée et espérer recevoir une unité APDU de réponse sur le point de terminaison en bloc. Pour obtenir les points de terminaison, consultez l'extrait de code ci-dessous:

UsbEndpoint epOut = null, epIn = null;
UsbInterface usbInterface;

UsbDeviceConnection connection = mUsbManager.openDevice(device);

    for (int i = 0; i < device.getInterfaceCount(); i++) {
        usbInterface = device.getInterface(i);
        connection.claimInterface(usbInterface, true);

        for (int j = 0; j < usbInterface.getEndpointCount(); j++) {
            UsbEndpoint ep = usbInterface.getEndpoint(j);

            if (ep.getType() == UsbConstants.USB_ENDPOINT_XFER_BULK) {
                if (ep.getDirection() == UsbConstants.USB_DIR_OUT) {
                    // from host to device
                    epOut = ep;

                } else if (ep.getDirection() == UsbConstants.USB_DIR_IN) {
                    // from device to host
                    epIn = ep;
                }
            }
        }
    }

Maintenant, vous avez les points de terminaison en entrée et en sortie pour envoyer et recevoir des blocs de réponse APDU et de commande APDU:

Pour envoyer des commandes, consultez l'extrait de code ci-dessous:

public void write(UsbDeviceConnection connection, UsbEndpoint epOut, byte[] command) {
    result = new StringBuilder();
    connection.bulkTransfer(epOut, command, command.length, TIMEOUT);
    //For Printing logs you can use result variable
    for (byte bb : command) {
        result.append(String.format(" %02X ", bb));
    }
}

Et pour recevoir / lire une réponse, voir l'extrait de code ci-dessous:

public int read(UsbDeviceConnection connection, UsbEndpoint epIn) {
result = new StringBuilder();
final byte[] buffer = new byte[epIn.getMaxPacketSize()];
int byteCount = 0;
byteCount = connection.bulkTransfer(epIn, buffer, buffer.length, TIMEOUT);

//For Printing logs you can use result variable
if (byteCount >= 0) {
    for (byte bb : buffer) {
        result.append(String.format(" %02X ", bb));
    }

    //Buffer received was : result.toString()
} else {
    //Something went wrong as count was : " + byteCount
}

return byteCount;
}

Maintenant, si vous voyez cette réponse ici, la 1ère commande à envoyer est la suivante:

PC_to_RDR_IccPowerOn commande pour activer la carte.

que vous pouvez créer en lisant la section 6.1.1 du document Spécifications des classes de périphérique USB ici.

Prenons maintenant un exemple de cette commande comme celui-ci: 62000000000000000000 Comment vous pouvez envoyer ceci:

write(connection, epOut, "62000000000000000000");

Maintenant, après avoir envoyé avec succès la commande APDU, vous pouvez lire la réponse en utilisant:

read(connection, epIn);

Et recevoir quelque chose comme

80 18000000 00 00 00 00 00 3BBF11008131FE45455041000000000000000000000000F1

Maintenant, la réponse reçue dans le code ici sera dans la variable result de la méthode read() du code