Examples with UsbInterface android.hardware.usb.UsbInterface used on opensource projects

Example 1 with UsbInterface

use of android.hardware.usb.UsbInterface in project platform_frameworks_base by android.

the class UsbHostManager method addUsbConfiguration.

/* Called from JNI in monitorUsbHostBus() to report new USB configuration for the device
       currently being added.  Returns true if successful, false in case of error.
     */
private void addUsbConfiguration(int id, String name, int attributes, int maxPower) {
    if (mNewConfiguration != null) {
        mNewConfiguration.setInterfaces(mNewInterfaces.toArray(new UsbInterface[mNewInterfaces.size()]));
        mNewInterfaces.clear();
    }
    mNewConfiguration = new UsbConfiguration(id, name, attributes, maxPower);
    mNewConfigurations.add(mNewConfiguration);
}

Example 2 with UsbInterface

use of android.hardware.usb.UsbInterface in project platform_frameworks_base by android.

the class SinkActivity method connect.

private void connect(UsbDevice device) {
    if (mConnected) {
        disconnect();
    }
    // Check whether we have permission to access the device.
    if (!mUsbManager.hasPermission(device)) {
        mLogger.log("Prompting the user for access to the device.");
        Intent intent = new Intent(ACTION_USB_DEVICE_PERMISSION);
        intent.setPackage(getPackageName());
        PendingIntent pendingIntent = PendingIntent.getBroadcast(this, 0, intent, PendingIntent.FLAG_ONE_SHOT);
        mUsbManager.requestPermission(device, pendingIntent);
        return;
    }
    // Claim the device.
    UsbDeviceConnection conn = mUsbManager.openDevice(device);
    if (conn == null) {
        mLogger.logError("Could not obtain device connection.");
        return;
    }
    UsbInterface iface = device.getInterface(0);
    UsbEndpoint controlEndpoint = iface.getEndpoint(0);
    if (!conn.claimInterface(iface, true)) {
        mLogger.logError("Could not claim interface.");
        return;
    }
    try {
        // If already in accessory mode, then connect to the device.
        if (isAccessory(device)) {
            mLogger.log("Connecting to accessory...");
            int protocolVersion = getProtocol(conn);
            if (protocolVersion < 1) {
                mLogger.logError("Device does not support accessory protocol.");
                return;
            }
            mLogger.log("Protocol version: " + protocolVersion);
            // Setup bulk endpoints.
            UsbEndpoint bulkIn = null;
            UsbEndpoint bulkOut = null;
            for (int i = 0; i < iface.getEndpointCount(); i++) {
                UsbEndpoint ep = iface.getEndpoint(i);
                if (ep.getDirection() == UsbConstants.USB_DIR_IN) {
                    if (bulkIn == null) {
                        mLogger.log(String.format("Bulk IN endpoint: %d", i));
                        bulkIn = ep;
                    }
                } else {
                    if (bulkOut == null) {
                        mLogger.log(String.format("Bulk OUT endpoint: %d", i));
                        bulkOut = ep;
                    }
                }
            }
            if (bulkIn == null || bulkOut == null) {
                mLogger.logError("Unable to find bulk endpoints");
                return;
            }
            mLogger.log("Connected");
            mConnected = true;
            mDevice = device;
            mProtocolVersion = protocolVersion;
            mAccessoryInterface = iface;
            mAccessoryConnection = conn;
            mControlEndpoint = controlEndpoint;
            mTransport = new UsbAccessoryBulkTransport(mLogger, conn, bulkIn, bulkOut);
            if (mProtocolVersion >= 2) {
                registerHid();
            }
            startServices();
            mTransport.startReading();
            return;
        }
        // Do accessory negotiation.
        mLogger.log("Attempting to switch device to accessory mode...");
        // Send get protocol.
        int protocolVersion = getProtocol(conn);
        if (protocolVersion < 1) {
            mLogger.logError("Device does not support accessory protocol.");
            return;
        }
        mLogger.log("Protocol version: " + protocolVersion);
        // Send identifying strings.
        sendString(conn, UsbAccessoryConstants.ACCESSORY_STRING_MANUFACTURER, MANUFACTURER);
        sendString(conn, UsbAccessoryConstants.ACCESSORY_STRING_MODEL, MODEL);
        sendString(conn, UsbAccessoryConstants.ACCESSORY_STRING_DESCRIPTION, DESCRIPTION);
        sendString(conn, UsbAccessoryConstants.ACCESSORY_STRING_VERSION, VERSION);
        sendString(conn, UsbAccessoryConstants.ACCESSORY_STRING_URI, URI);
        sendString(conn, UsbAccessoryConstants.ACCESSORY_STRING_SERIAL, SERIAL);
        // Send start.
        // The device should re-enumerate as an accessory.
        mLogger.log("Sending accessory start request.");
        int len = conn.controlTransfer(UsbConstants.USB_DIR_OUT | UsbConstants.USB_TYPE_VENDOR, UsbAccessoryConstants.ACCESSORY_START, 0, 0, null, 0, 10000);
        if (len != 0) {
            mLogger.logError("Device refused to switch to accessory mode.");
        } else {
            mLogger.log("Waiting for device to re-enumerate...");
        }
    } finally {
        if (!mConnected) {
            conn.releaseInterface(iface);
        }
    }
}

Example 3 with UsbInterface

use of android.hardware.usb.UsbInterface in project android_frameworks_base by ParanoidAndroid.

the class UsbHostManager method usbDeviceAdded.

/* Called from JNI in monitorUsbHostBus() to report new USB devices */
private void usbDeviceAdded(String deviceName, int vendorID, int productID, int deviceClass, int deviceSubclass, int deviceProtocol, /* array of quintuples containing id, class, subclass, protocol
               and number of endpoints for each interface */
int[] interfaceValues, /* array of quadruples containing address, attributes, max packet size
              and interval for each endpoint */
int[] endpointValues) {
    if (isBlackListed(deviceName) || isBlackListed(deviceClass, deviceSubclass, deviceProtocol)) {
        return;
    }
    synchronized (mLock) {
        if (mDevices.get(deviceName) != null) {
            Slog.w(TAG, "device already on mDevices list: " + deviceName);
            return;
        }
        int numInterfaces = interfaceValues.length / 5;
        Parcelable[] interfaces = new UsbInterface[numInterfaces];
        try {
            // repackage interfaceValues as an array of UsbInterface
            int intf, endp, ival = 0, eval = 0;
            for (intf = 0; intf < numInterfaces; intf++) {
                int interfaceId = interfaceValues[ival++];
                int interfaceClass = interfaceValues[ival++];
                int interfaceSubclass = interfaceValues[ival++];
                int interfaceProtocol = interfaceValues[ival++];
                int numEndpoints = interfaceValues[ival++];
                Parcelable[] endpoints = new UsbEndpoint[numEndpoints];
                for (endp = 0; endp < numEndpoints; endp++) {
                    int address = endpointValues[eval++];
                    int attributes = endpointValues[eval++];
                    int maxPacketSize = endpointValues[eval++];
                    int interval = endpointValues[eval++];
                    endpoints[endp] = new UsbEndpoint(address, attributes, maxPacketSize, interval);
                }
                // don't allow if any interfaces are blacklisted
                if (isBlackListed(interfaceClass, interfaceSubclass, interfaceProtocol)) {
                    return;
                }
                interfaces[intf] = new UsbInterface(interfaceId, interfaceClass, interfaceSubclass, interfaceProtocol, endpoints);
            }
        } catch (Exception e) {
            // beware of index out of bound exceptions, which might happen if
            // a device does not set bNumEndpoints correctly
            Slog.e(TAG, "error parsing USB descriptors", e);
            return;
        }
        UsbDevice device = new UsbDevice(deviceName, vendorID, productID, deviceClass, deviceSubclass, deviceProtocol, interfaces);
        mDevices.put(deviceName, device);
        getCurrentSettings().deviceAttached(device);
    }
}

Example 4 with UsbInterface

use of android.hardware.usb.UsbInterface in project android_frameworks_base by ResurrectionRemix.

the class UsbHostManager method addUsbInterface.

/* Called from JNI in monitorUsbHostBus() to report new USB interface for the device
       currently being added.  Returns true if successful, false in case of error.
     */
private void addUsbInterface(int id, String name, int altSetting, int Class, int subClass, int protocol) {
    if (mNewInterface != null) {
        mNewInterface.setEndpoints(mNewEndpoints.toArray(new UsbEndpoint[mNewEndpoints.size()]));
        mNewEndpoints.clear();
    }
    mNewInterface = new UsbInterface(id, altSetting, name, Class, subClass, protocol);
    mNewInterfaces.add(mNewInterface);
}

Example 5 with UsbInterface

use of android.hardware.usb.UsbInterface in project android_frameworks_base by ResurrectionRemix.

the class UsbHostManager method beginUsbDeviceAdded.

/* Called from JNI in monitorUsbHostBus() to report new USB devices
       Returns true if successful, in which case the JNI code will continue adding configurations,
       interfaces and endpoints, and finally call endUsbDeviceAdded after all descriptors
       have been processed
     */
private boolean beginUsbDeviceAdded(String deviceName, int vendorID, int productID, int deviceClass, int deviceSubclass, int deviceProtocol, String manufacturerName, String productName, int version, String serialNumber) {
    if (DEBUG) {
        Slog.d(TAG, "usb:UsbHostManager.beginUsbDeviceAdded(" + deviceName + ")");
        // Audio Class Codes:
        // Audio: 0x01
        // Audio Subclass Codes:
        // undefined: 0x00
        // audio control: 0x01
        // audio streaming: 0x02
        // midi streaming: 0x03
        // some useful debugging info
        Slog.d(TAG, "usb: nm:" + deviceName + " vnd:" + vendorID + " prd:" + productID + " cls:" + deviceClass + " sub:" + deviceSubclass + " proto:" + deviceProtocol);
    }
    if (isBlackListed(deviceName) || isBlackListed(deviceClass, deviceSubclass, deviceProtocol)) {
        return false;
    }
    synchronized (mLock) {
        if (mDevices.get(deviceName) != null) {
            Slog.w(TAG, "device already on mDevices list: " + deviceName);
            return false;
        }
        if (mNewDevice != null) {
            Slog.e(TAG, "mNewDevice is not null in endUsbDeviceAdded");
            return false;
        }
        // Create version string in "%.%" format
        String versionString = Integer.toString(version >> 8) + "." + (version & 0xFF);
        mNewDevice = new UsbDevice(deviceName, vendorID, productID, deviceClass, deviceSubclass, deviceProtocol, manufacturerName, productName, versionString, serialNumber);
        mNewConfigurations = new ArrayList<UsbConfiguration>();
        mNewInterfaces = new ArrayList<UsbInterface>();
        mNewEndpoints = new ArrayList<UsbEndpoint>();
    }
    return true;
}