Android
smartcard

Smartcard verzenden en ontvangen

Voor verbinding is hier een fragment om u te helpen begrijpen:

//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);
}

Nu moet je begrijpen dat in Java de communicatie plaatsvindt met behulp van het pakket javax.smarcard dat niet beschikbaar is voor Android, dus kijk hier voor een idee hoe je APDU kunt communiceren of verzenden / ontvangen (smartcardopdracht).

Nu zoals verteld in het bovengenoemde antwoord

U kunt niet eenvoudig een APDU (smartcard-opdracht) over het bulk-eindpunt verzenden en verwachten een respons-APDU over het bulk-eindpunt te ontvangen. Raadpleeg het onderstaande codefragment voor het verkrijgen van de eindpunten:

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;
                }
            }
        }
    }

Nu hebt u de bulk-in en bulk-out eindpunten om APDU-opdracht en APDU-reactieblokken te verzenden en te ontvangen:

Zie het onderstaande codefragment voor het verzenden van opdrachten:

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));
    }
}

En voor het ontvangen / lezen van een reactie, zie het codefragment hieronder:

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;
}

Als u dit antwoord hier ziet, is de eerste opdracht die moet worden verzonden:

PC_to_RDR_IccPowerOn commando om de kaart te activeren.

die u kunt maken door sectie 6.1.1 van de documentatie over de USB Device Class-specificaties hier te lezen.

Laten we nu een voorbeeld nemen van dit commando zoals hier: 62000000000000000000 Hoe u dit kunt verzenden is:

write(connection, epOut, "62000000000000000000");

Nadat u de APDU-opdracht hebt verzonden, kunt u het antwoord lezen met:

read(connection, epIn);

En ontvang zoiets als

80 18000000 00 00 00 00 00 3BBF11008131FE45455041000000000000000000000000F1

Het antwoord dat hier in de code wordt ontvangen, bevindt zich nu in de result van de methode read() van code