Example usage for android.hardware.usb UsbEndpoint getDirection

List of usage examples for android.hardware.usb UsbEndpoint getDirection

Introduction

In this page you can find the example usage for android.hardware.usb UsbEndpoint getDirection.

Prototype

public int getDirection() 

Source Link

Document

Returns the endpoint's direction.

Usage

From source file:org.ros.android.android_acm_serial.AcmDevice.java

/**
 * Goes through the given UsbInterface's endpoints and finds the incoming
 * and outgoing bulk transfer endpoints.
 * @return Array with incoming (first) and outgoing (second) USB endpoints
 * @return <code>null</code>  in case either of the endpoints is not found
 *//* www .  jav a  2s .c  om*/
private AcmUsbEndpoints getAcmEndpoints(UsbInterface usbInterface) {
    UsbEndpoint outgoingEndpoint = null;
    UsbEndpoint incomingEndpoint = null;
    for (int i = 0; i < usbInterface.getEndpointCount(); i++) {
        UsbEndpoint endpoint = usbInterface.getEndpoint(i);
        log.info("Interface: " + i + "/" + "Class: " + usbInterface.getInterfaceClass());
        if (usbInterface.getInterfaceClass() == UsbConstants.USB_CLASS_CDC_DATA) {
            if (endpoint.getDirection() == UsbConstants.USB_DIR_OUT) {
                log.info("Endpoint " + i + "/" + usbInterface.getEndpointCount() + ": " + endpoint + ". Type = "
                        + endpoint.getType());
                outgoingEndpoint = endpoint;
            } else if (endpoint.getDirection() == UsbConstants.USB_DIR_IN) {
                log.info("Endpoint " + i + "/" + usbInterface.getEndpointCount() + ": " + endpoint + ". Type = "
                        + endpoint.getType());
                incomingEndpoint = endpoint;
            }
        }
    }
    if (outgoingEndpoint == null || incomingEndpoint == null) {
        return null;
    } else {
        return new AcmUsbEndpoints(incomingEndpoint, outgoingEndpoint);
    }
}

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

private void initUsbConnection() {

    try {/* w w  w  .j  av  a 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:aws.apps.usbDeviceEnumerator.ui.usbinfo.AndroidUsbInfoFragment.java

private String getEndpointText(final UsbEndpoint endpoint, final int index) {
    final String addressInBinary = CommonLogic.padLeft(Integer.toBinaryString(endpoint.getAddress()), "0", 8);

    String endpointText = "#" + index + "\n";
    endpointText += getString(R.string.address_) + endpoint.getAddress() + " (" + addressInBinary + ")\n";
    endpointText += getString(R.string.number_) + endpoint.getEndpointNumber() + "\n";
    endpointText += getString(R.string.direction_)
            + UsbConstants.resolveUsbEndpointDirection(endpoint.getDirection()) + "\n";
    endpointText += getString(R.string.type_) + UsbConstants.resolveUsbEndpointType(endpoint.getType()) + "\n";
    endpointText += getString(R.string.poll_interval_) + endpoint.getInterval() + "\n";
    endpointText += getString(R.string.max_packet_size_) + endpoint.getMaxPacketSize() + "\n";
    endpointText += getString(R.string.attributes_)
            + CommonLogic.padLeft(Integer.toBinaryString(endpoint.getAttributes()), "0", 8);

    return endpointText;
}

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

/**
 * openDevice: open the USB device {{{1/*from   w ww.jav a 2  s  .  c om*/
 */
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();
}