Example usage for android.hardware.usb UsbConstants USB_ENDPOINT_XFER_INT

List of usage examples for android.hardware.usb UsbConstants USB_ENDPOINT_XFER_INT

Introduction

In this page you can find the example usage for android.hardware.usb UsbConstants USB_ENDPOINT_XFER_INT.

Prototype

int USB_ENDPOINT_XFER_INT

To view the source code for android.hardware.usb UsbConstants USB_ENDPOINT_XFER_INT.

Click Source Link

Document

Interrupt endpoint type

Usage

From source file:com.googlecode.android_scripting.facade.USBHostSerialFacade.java

/**
 * openDevice: open the USB device {{{1/*from ww w.ja  v a 2s .  c o m*/
 */
private void openDevice(UsbDevice device) {
    switch (device.getDeviceClass()) {
    case UsbConstants.USB_CLASS_PER_INTERFACE:
        // / 78K Trg-USB Serial
        Log.d("USB openDevice, device => USB_CLASS_PER_INTERFACE");
        break;
    case UsbConstants.USB_CLASS_COMM:
        // / PIC24 USB CDC
        Log.d("USB openDevice, device => USB_CLASS_COMM");
        break;
    default:
        Log.d("USB openDevice, device is not serial...");
        return;
    }

    UsbSerialConnection conn;
    try {
        conn = getConnection(device);
    } catch (IOException e) {
        Log.d("USB openDevice, can't get from connections 1");
        return;
    }
    if (conn == null) {
        Log.d("USB openDevice, can't get from connections 2");
        return;
    }

    Log.d("USB openDevice, try to open...");

    UsbDeviceConnection connection = mUsbManager.openDevice(device);
    if (connection == null) {
        Log.d("connection failed at openDevice...");
        // conn.close();
        return;
    }

    int i, j;

    Log.d("USB open SUCCESS");
    if (conn.mConnection != null) {
        Log.i("already connected? => stop thread");
        conn.stop();
    }
    conn.mConnection = connection;

    if (options.contains("trg78k")) {
        Log.d("USB Host Serial: reset the device (trg78k)");
        // conn.mConnection.controlTransfer(0x21, 0x22, 0x00, 0, null, 0, 0);
        byte[] data = { (byte) 0x03, (byte) 0x01 };
        conn.mConnection.controlTransfer(0x40, 0x00, 0x00, 0, null, 0, 0);
        conn.mConnection.controlTransfer(0x40, 0x0b, 0x00, 0, data, 2, 300);
    }

    for (i = 0; i < device.getInterfaceCount(); i++) {
        UsbInterface ui = device.getInterface(i);
        for (j = 0; j < ui.getEndpointCount(); j++) {
            Log.d(String.format("EndPoint loop...(%d, %d)", i, j));
            UsbEndpoint endPoint = ui.getEndpoint(j);
            switch (endPoint.getType()) {
            case UsbConstants.USB_ENDPOINT_XFER_BULK:
                if (endPoint.getDirection() == UsbConstants.USB_DIR_IN) {
                    conn.mInterfaceIn = ui;
                    conn.mEndpointIn = endPoint;
                    Log.d("USB mEndpointIn initialized!");
                } else {
                    conn.mInterfaceOut = ui;
                    conn.mEndpointOut = endPoint;
                    Log.d("USB mEndpointOut initialized!");
                }
                break;
            case UsbConstants.USB_ENDPOINT_XFER_CONTROL:
                break;
            case UsbConstants.USB_ENDPOINT_XFER_INT:
                conn.mEndpointIntr = endPoint;
                Log.d("USB mEndpointIntr initialized!");
                break;
            case UsbConstants.USB_ENDPOINT_XFER_ISOC:
                break;
            }
        }
    }

    if (options.contains("pl2303")) {
        Log.d("USB Host Serial: setup device (pl2303)");
        int ret;
        byte[] data = new byte[10];
        final byte rdReq = 0x01;
        final byte rdReqType = (byte) 0xC0;
        final byte wrReq = 0x01;
        final byte wrReqType = 0x40;
        final byte glReq = 0x21;
        final byte glReqType = (byte) 0xA1;
        final byte slReq = 0x20;
        final byte slReqType = (byte) 0x21;
        final byte bkReq = 0x23;
        final byte bkReqType = 0x21;
        int pl2303type = 1;

        UsbInterface ui = device.getInterface(0);
        connection.claimInterface(ui, true);
        /*
         * try { /// this cause device close by native_claiminterface. Thread.sleep(1000); } catch
         * (InterruptedException e) { Log.d("USB Host Serial: failed to sleep(1000)"); }
         */
        // / after API Level 13: if (connection.getRawDescriptors()[7] == 64) {
        // pl2303type = 1;
        // }

        connection.controlTransfer(rdReqType, rdReq, 0x8484, 0, data, 1, 100);
        connection.controlTransfer(wrReqType, wrReq, 0x0404, 0, null, 0, 100);
        connection.controlTransfer(rdReqType, rdReq, 0x8484, 0, data, 1, 100);
        connection.controlTransfer(rdReqType, rdReq, 0x8383, 0, data, 1, 100);
        connection.controlTransfer(rdReqType, rdReq, 0x8484, 0, data, 1, 100);
        connection.controlTransfer(wrReqType, wrReq, 0x0404, 1, null, 0, 100);
        connection.controlTransfer(rdReqType, rdReq, 0x8484, 0, data, 1, 100);
        connection.controlTransfer(rdReqType, rdReq, 0x8383, 0, data, 1, 100);
        connection.controlTransfer(wrReqType, wrReq, 0x0000, 1, null, 0, 100);
        connection.controlTransfer(wrReqType, wrReq, 0x0001, 0, null, 0, 100);

        // **type HX**
        // device class != 2
        // packet size == 64
        if (pl2303type == 1) {
            connection.controlTransfer(wrReqType, wrReq, 0x0002, 0x44, null, 0, 100);
        } else {
            connection.controlTransfer(wrReqType, wrReq, 0x0002, 0x24, null, 0, 100);
        }

        /*
         * // reset the device (HX) if (type != 2) { // TODO: halt } else {
         * connection.controlTransfer(wrReqType, wrReq, 0x0008, 0, null, 0, 100);
         * connection.controlTransfer(wrReqType, wrReq, 0x0009, 0, null, 0, 100); }
         */
        // initilize serial
        ret = connection.controlTransfer(glReqType, glReq, 0x0000, 0x00, data, 7, 100);
        Log.d(String.format("pl2303: GetLineRequest: %x => %x-%x-%x-%x-%x-%x-%x", ret, data[0], data[1],
                data[2], data[3], data[4], data[5], data[6]));

        // ret = connection.controlTransfer(wrReqType, wrReq, 0x0000, 0x01, null, 0, 100);
        // Log.d(String.format("pl2303: WriteRequest: %x", ret));

        int baud = 9600;
        data[0] = (byte) (baud & 0xFF);
        data[1] = (byte) ((baud >> 8) & 0xFF);
        data[2] = (byte) ((baud >> 16) & 0xFF);
        data[3] = (byte) ((baud >> 24) & 0xFF);
        data[4] = 0; // stopbit: 1bit, 1: 1.5bits, 2: 2bits
        data[5] = 0; // parity: None, 1:odd, 2:even, 3:mark, 4:space
        data[6] = 8; // data size: 8, 5, 6, 7
        data[7] = 0x00;
        ret = connection.controlTransfer(slReqType, slReq, 0x0000, 0x00, data, 7, 100);
        Log.d(String.format("pl2303: SetLineRequest: %x", ret));

        // set break off
        ret = connection.controlTransfer(bkReqType, bkReq, 0x0000, 0x00, null, 0, 100);

        if (pl2303type == 1) {
            // for RTSCTS and HX device
            ret = connection.controlTransfer(wrReqType, wrReq, 0x0000, 0x61, null, 0, 100);
        } else {
            // for not RTSCTS
            ret = connection.controlTransfer(wrReqType, wrReq, 0x0000, 0x00, null, 0, 100);
        }

        // connection.releaseInterface(ui);
    }

    if (!conn.isConnected()) {
        connectionFailed();
        return;
    }
    conn.start();
}

From source file:com.dslr.dashboard.PtpService.java

private void initUsbConnection() {

    try {/*from   w  ww .java 2 s  .  c  o  m*/
        if (mUsbDevice != null) {
            if (mUsbIntf == null) {
                for (int i = 0; i < mUsbDevice.getInterfaceCount(); i++) {
                    UsbInterface uintf = mUsbDevice.getInterface(i);
                    if (uintf.getInterfaceClass() == UsbConstants.USB_CLASS_STILL_IMAGE) {
                        // we have a still image interface
                        // Log.d(MainActivity.TAG, "Imaging USB interface found");
                        mUsbIntf = uintf;
                        break;
                    }
                }
                if (mUsbIntf != null) {
                    // get the endpoints
                    for (int i = 0; i < mUsbIntf.getEndpointCount(); i++) {
                        UsbEndpoint ep = mUsbIntf.getEndpoint(i);
                        if (ep.getDirection() == UsbConstants.USB_DIR_OUT) {
                            if (ep.getType() == UsbConstants.USB_ENDPOINT_XFER_BULK) {
                                mUsbWriteEp = ep;
                                // Log.d(MainActivity.TAG, "write endpoint found");
                            }
                        } else {
                            switch (ep.getType()) {
                            case UsbConstants.USB_ENDPOINT_XFER_BULK:
                                mUsbReadEp = ep;
                                // Log.d(MainActivity.TAG, "read endpoint found");
                                break;
                            case UsbConstants.USB_ENDPOINT_XFER_INT:
                                mUsbInterruptEp = ep;
                                // Log.d(MainActivity.TAG, "interrupt endpoint found");
                                break;
                            }
                        }
                    }
                } else
                    Log.d(TAG, "No compatible USB interface found");
            } else
                Log.d(TAG, "USB interface found");
            // if we have read and write endpoints then we good to go
            if (mUsbReadEp != null && mUsbWriteEp != null) {
                if (!mIsUsbDeviceInitialized) {
                    mUsbConnection = mUsbManager.openDevice(mUsbDevice);
                    mIsUsbDeviceInitialized = mUsbConnection != null;
                }
                if (mIsUsbDeviceInitialized) {
                    // Log.d(TAG, "USB Device Initialized");
                    if (!mIsUsbInterfaceClaimed) {
                        mIsUsbInterfaceClaimed = mUsbConnection.claimInterface(mUsbIntf, true);
                        // Log.d(TAG, "USB Interface claimed: " + isInterfaceClaimed);
                    }
                    sendPtpServiceEvent(PtpServiceEvent.UsbDeviceInitialized);
                    // create the USB communicator
                    PtpUsbCommunicator communicator = new PtpUsbCommunicator(new PtpSession());
                    // initialize the USB communicator
                    communicator.initCommunicator(mUsbConnection, mUsbWriteEp, mUsbReadEp, mUsbInterruptEp);
                    // initialize the PTP device
                    mPtpDevice.initialize(mUsbDevice.getVendorId(), mUsbDevice.getProductId(), communicator);
                }
            }

        } else
            Log.d(TAG, "No USB device present");

    } catch (Exception e) {
        Log.d(TAG, "InitUsb exception: " + e.getMessage());
    }
}

From source file:org.chromium.ChromeUsb.java

static String endpointTypeName(int type) {
    switch (type) {
    case UsbConstants.USB_ENDPOINT_XFER_BULK:
        return "bulk";
    case UsbConstants.USB_ENDPOINT_XFER_CONTROL:
        return "control";
    case UsbConstants.USB_ENDPOINT_XFER_INT:
        return "interrupt";
    case UsbConstants.USB_ENDPOINT_XFER_ISOC:
        return "isochronous";
    default://from   w  ww  . j  av  a2 s .c  o  m
        return "ERR:" + type;
    }
}