New APIs for USB host support:

UsbManager:
- is now a service retrievable via Context.getSystemService(Context.USB_SERVICE).
- provides support for returning a list all connected USB devices
- broadcasts ACTION_USB_DEVICE_ATTACHED and USB_DEVICE_DETACHED when devices
  are added and removed from the USB host bus

UsbDevice:
- represents an attached USB device.

UsbInterface:
- represents an interface on a USB device
- devices may have multiple interfaces if they provide multiple
   sets of functionality (for example, android phones typically have interfaces
   for both USB mass storage and adb)

UsbEndpoint:
- represents an endpoint on a USB interface
- endpoints are used for sending or receiving data
  (only in one or the other direction)

UsbRequest:
- encapsulates a send or receive request to be sent over an endpoint

Change-Id: Ieef3e434c62760770ea839070cf5eba1a705967a
Signed-off-by: Mike Lockwood <lockwood@android.com>

10 files changed, 1110 insertions, 3 deletions

diff --git a/core/java/android/hardware/IUsbManager.aidl b/core/java/android/hardware/IUsbManager.aidl
new file mode 100644
index 0000000..b50b6b9
--- /dev/null
+++ b/core/java/android/hardware/IUsbManager.aidl
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.hardware;
+
+import android.os.Bundle;
+import android.os.ParcelFileDescriptor;
+
+/** @hide */
+interface IUsbManager
+{
+    /* Returns a list of all currently attached USB devices */
+    void getDeviceList(out Bundle devices);
+    ParcelFileDescriptor openDevice(String deviceName);
+}
diff --git a/core/java/android/hardware/UsbConstants.java b/core/java/android/hardware/UsbConstants.java
new file mode 100644
index 0000000..29a335c
--- /dev/null
+++ b/core/java/android/hardware/UsbConstants.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.hardware;
+
+/**
+ * Contains constants for the USB protocol.
+ * These constants correspond to definitions in linux/usb/ch9.h in the linux kernel.
+ */
+public final class UsbConstants {
+
+    public static final int USB_ENDPOINT_DIR_MASK = 0x80;
+    public static final int USB_DIR_OUT = 0;
+    public static final int USB_DIR_IN = 0x80;
+
+    public static final int USB_TYPE_MASK = (0x03 << 5);
+    public static final int USB_TYPE_STANDARD = (0x00 << 5);
+    public static final int USB_TYPE_CLASS = (0x01 << 5);
+    public static final int USB_TYPE_VENDOR = (0x02 << 5);
+    public static final int USB_TYPE_RESERVED = (0x03 << 5);
+
+    public static final int USB_ENDPOINT_NUMBER_MASK = 0x0f;
+
+    // flags for endpoint attributes
+    public static final int USB_ENDPOINT_XFERTYPE_MASK = 0x03;
+    public static final int USB_ENDPOINT_XFER_CONTROL = 0;
+    public static final int USB_ENDPOINT_XFER_ISOC = 1;
+    public static final int USB_ENDPOINT_XFER_BULK = 2;
+    public static final int USB_ENDPOINT_XFER_INT = 3;
+
+    public static final int USB_CLASS_PER_INTERFACE = 0;
+    public static final int USB_CLASS_AUDIO = 1;
+    public static final int USB_CLASS_COMM = 2;
+    public static final int USB_CLASS_HID = 3;
+    public static final int USB_CLASS_PHYSICA = 5;
+    public static final int USB_CLASS_STILL_IMAGE = 6;
+    public static final int USB_CLASS_PRINTER = 7;
+    public static final int USB_CLASS_MASS_STORAGE = 8;
+    public static final int USB_CLASS_HUB = 9;
+    public static final int USB_CLASS_CDC_DATA = 0x0a;
+    public static final int USB_CLASS_CSCID = 0x0b;
+    public static final int USB_CLASS_CONTENT_SEC = 0x0d;
+    public static final int USB_CLASS_VIDEO = 0x0e;
+    public static final int USB_CLASS_WIRELESS_CONTROLLER = 0xe0;
+    public static final int USB_CLASS_MISC = 0xef;
+    public static final int USB_CLASS_APP_SPEC = 0xfe;
+    public static final int USB_CLASS_VENDOR_SPEC = 0xff;
+    public static final int USB_SUBCLASS_VENDOR_SPEC = 0xff;
+
+}
\ No newline at end of file
diff --git a/core/java/android/hardware/UsbDevice.aidl b/core/java/android/hardware/UsbDevice.aidl
new file mode 100644
index 0000000..6dfd43f
--- /dev/null
+++ b/core/java/android/hardware/UsbDevice.aidl
@@ -0,0 +1,19 @@
+/*
+ * Copyright (C) 2010, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.hardware;
+
+parcelable UsbDevice;
diff --git a/core/java/android/hardware/UsbDevice.java b/core/java/android/hardware/UsbDevice.java
new file mode 100644
index 0000000..e6b38be
--- /dev/null
+++ b/core/java/android/hardware/UsbDevice.java
@@ -0,0 +1,314 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.hardware;
+
+import android.os.Bundle;
+import android.os.Parcel;
+import android.os.Parcelable;
+import android.os.ParcelFileDescriptor;
+import android.util.Log;
+
+import java.io.FileDescriptor;
+
+
+/**
+ * A class representing a USB device.
+ */
+public final class UsbDevice implements Parcelable {
+
+    private static final String TAG = "UsbDevice";
+
+    private String mName;
+    private int mVendorId;
+    private int mProductId;
+    private int mClass;
+    private int mSubclass;
+    private int mProtocol;
+    private Parcelable[] mInterfaces;
+
+    // used by the JNI code
+    private int mNativeContext;
+
+    private UsbDevice() {
+    }
+
+
+    /**
+     * UsbDevice should only be instantiated by UsbService implementation
+     * @hide
+     */
+    public UsbDevice(String name, int vendorId, int productId,
+            int Class, int subClass, int protocol, Parcelable[] interfaces) {
+        mName = name;
+        mVendorId = vendorId;
+        mProductId = productId;
+        mClass = Class;
+        mSubclass = subClass;
+        mProtocol = protocol;
+        mInterfaces = interfaces;
+    }
+
+    /**
+     * Returns the name of the device.
+     * In the standard implementation, this is the path of the device file
+     * for the device in the usbfs file system.
+     *
+     * @return the device name
+     */
+    public String getDeviceName() {
+        return mName;
+    }
+
+    /**
+     * Returns a unique integer ID for the device.
+     * This is a convenience for clients that want to use an integer to represent
+     * the device, rather than the device name.
+     * IDs are not persistent across USB disconnects.
+     *
+     * @return the device ID
+     */
+    public int getDeviceId() {
+        return getDeviceId(mName);
+    }
+
+    /**
+     * Returns a vendor ID for the device.
+     *
+     * @return the device vendor ID
+     */
+    public int getVendorId() {
+        return mVendorId;
+    }
+
+    /**
+     * Returns a product ID for the device.
+     *
+     * @return the device product ID
+     */
+    public int getProductId() {
+        return mProductId;
+    }
+
+    /**
+     * Returns the devices's class field.
+     * Some useful constants for USB device classes can be found in
+     * {@link android.hardware.UsbConstants}
+     *
+     * @return the devices's class
+     */
+    public int getDeviceClass() {
+        return mClass;
+    }
+
+    /**
+     * Returns the device's subclass field.
+     *
+     * @return the device's subclass
+     */
+    public int getDeviceSubclass() {
+        return mSubclass;
+    }
+
+    /**
+     * Returns the device's subclass field.
+     *
+     * @return the device's protocol
+     */
+    public int getDeviceProtocol() {
+        return mProtocol;
+    }
+
+    /**
+     * Returns the number of {@link android.hardware.UsbInterface}s this device contains.
+     *
+     * @return the number of interfaces
+     */
+    public int getInterfaceCount() {
+        return mInterfaces.length;
+    }
+
+    /**
+     * Returns the {@link android.hardware.UsbInterface} at the given index.
+     *
+     * @return the interface
+     */
+    public UsbInterface getInterface(int index) {
+        return (UsbInterface)mInterfaces[index];
+    }
+
+    /* package */ boolean open(ParcelFileDescriptor pfd) {
+        return native_open(mName, pfd.getFileDescriptor());
+    }
+
+    /**
+     * Releases all system resources related to the device.
+     */
+    public void close() {
+        native_close();
+    }
+
+    /**
+     * Returns an integer file descriptor for the device, or
+     * -1 if the device is not opened.
+     * This is intended for passing to native code to access the device
+     */
+    public int getFileDescriptor() {
+        return native_get_fd();
+    }
+
+    /**
+     * Claims exclusive access to a {@link android.hardware.UsbInterface}.
+     * This must be done before sending or receiving data on any
+     * {@link android.hardware.UsbEndpoint}s belonging to the interface
+     * @param intf the interface to claim
+     * @param force true to disconnect kernel driver if necessary
+     * @return true if the interface was successfully claimed
+     */
+    public boolean claimInterface(UsbInterface intf, boolean force) {
+        return native_claim_interface(intf.getId(), force);
+    }
+
+    /**
+     * Releases exclusive access to a {@link android.hardware.UsbInterface}.
+     *
+     * @return true if the interface was successfully released
+     */
+    public boolean releaseInterface(UsbInterface intf) {
+        return native_release_interface(intf.getId());
+    }
+
+    /**
+     * Performs a control transaction on endpoint zero for this device.
+     *
+     * @param requestType request type for this transaction
+     * @param request request ID for this transaction
+     * @param value value field for this transaction
+     * @param index index field for this transaction
+     * @param buffer buffer for data portion of transaction,
+     * or null if no data needs to be sent or received
+     * @param length the length of the data to send or receive
+     * @return length of data transferred (or zero) for success,
+     * or negative value for failure
+     */
+    public int sendControlRequest(int requestType, int request, int value,
+            int index, byte[] buffer, int length) {
+        return native_control_request(requestType, request, value, index, buffer, length);
+    }
+
+    /**
+     * Waits for the result of a {@link android.hardware.UsbRequest#queue} operation
+     * Note that this may return requests queued on multiple {@link android.hardware.UsbEndpoint}s.
+     * When multiple endpoints are in use, {@link android.hardware.UsbRequest#getEndpoint} and
+     * {@link android.hardware.UsbRequest#getClientData} can be useful in determining how to process
+     * the result of this function.
+     *
+     * @return a completed USB request, or null if an error occurred
+     */
+    public UsbRequest requestWait() {
+        UsbRequest request = native_request_wait();
+        if (request != null) {
+            request.dequeue();
+        }
+        return request;
+    }
+
+    /**
+     * Returns the serial number for the device.
+     * This will return null if the device has not been opened.
+     *
+     * @return the device serial number
+     */
+    public String getSerial() {
+        return native_get_serial();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (o instanceof UsbDevice) {
+            return ((UsbDevice)o).mName.equals(mName);
+        } else if (o instanceof String) {
+            return ((String)o).equals(mName);
+        } else {
+            return false;
+        }
+    }
+
+    @Override
+    public String toString() {
+        return "UsbDevice[mName=" + mName + ",mVendorId=" + mVendorId +
+                ",mProductId=" + mProductId + ",mClass=" + mClass +
+                ",mSubclass=" + mSubclass + ",mProtocol=" + mProtocol +
+                ",mInterfaces=" + mInterfaces + "]";
+    }
+
+    public static final Parcelable.Creator<UsbDevice> CREATOR =
+        new Parcelable.Creator<UsbDevice>() {
+        public UsbDevice createFromParcel(Parcel in) {
+            String name = in.readString();
+            int vendorId = in.readInt();
+            int productId = in.readInt();
+            int clasz = in.readInt();
+            int subClass = in.readInt();
+            int protocol = in.readInt();
+            Parcelable[] interfaces = in.readParcelableArray(UsbInterface.class.getClassLoader());
+            UsbDevice result = new UsbDevice(name, vendorId, productId, clasz, subClass, protocol, interfaces);
+            for (int i = 0; i < interfaces.length; i++) {
+                ((UsbInterface)interfaces[i]).setDevice(result);
+            }
+            return result;
+        }
+
+        public UsbDevice[] newArray(int size) {
+            return new UsbDevice[size];
+        }
+    };
+
+    public int describeContents() {
+        return 0;
+    }
+
+    public void writeToParcel(Parcel parcel, int flags) {
+        parcel.writeString(mName);
+        parcel.writeInt(mVendorId);
+        parcel.writeInt(mProductId);
+        parcel.writeInt(mClass);
+        parcel.writeInt(mSubclass);
+        parcel.writeInt(mProtocol);
+        parcel.writeParcelableArray(mInterfaces, 0);
+   }
+
+    public static int getDeviceId(String name) {
+        return native_get_device_id(name);
+    }
+
+    public static String getDeviceName(int id) {
+        return native_get_device_name(id);
+    }
+
+    private native boolean native_open(String deviceName, FileDescriptor pfd);
+    private native void native_close();
+    private native int native_get_fd();
+    private native boolean native_claim_interface(int interfaceID, boolean force);
+    private native boolean native_release_interface(int interfaceID);
+    private native int native_control_request(int requestType, int request, int value,
+            int index, byte[] buffer, int length);
+    private native UsbRequest native_request_wait();
+    private native String native_get_serial();
+
+    private static native int native_get_device_id(String name);
+    private static native String native_get_device_name(int id);
+}
diff --git a/core/java/android/hardware/UsbEndpoint.aidl b/core/java/android/hardware/UsbEndpoint.aidl
new file mode 100644
index 0000000..51fc67b
--- /dev/null
+++ b/core/java/android/hardware/UsbEndpoint.aidl
@@ -0,0 +1,19 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.hardware;
+
+parcelable UsbEndpoint;
diff --git a/core/java/android/hardware/UsbEndpoint.java b/core/java/android/hardware/UsbEndpoint.java
new file mode 100644
index 0000000..8d4099d
--- /dev/null
+++ b/core/java/android/hardware/UsbEndpoint.java
@@ -0,0 +1,176 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.hardware;
+
+import android.os.Bundle;
+import android.os.Parcel;
+import android.os.Parcelable;
+
+/**
+ * A class representing an endpoint on a {@link android.hardware.UsbInterface}.
+ */
+public final class UsbEndpoint implements Parcelable {
+
+    private int mAddress;
+    private int mAttributes;
+    private int mMaxPacketSize;
+    private int mInterval;
+    private UsbInterface mInterface;
+
+    private UsbEndpoint() {
+    }
+
+    /**
+     * UsbEndpoint should only be instantiated by UsbService implementation
+     * @hide
+     */
+    public UsbEndpoint(int address, int attributes, int maxPacketSize, int interval) {
+        mAddress = address;
+        mAttributes = attributes;
+        mMaxPacketSize = maxPacketSize;
+        mInterval = interval;
+    }
+
+    /**
+     * Returns the endpoint's address field.
+     *
+     * @return the endpoint's address
+     */
+    public int getAddress() {
+        return mAddress;
+    }
+
+    /**
+     * Extracts the endpoint's endpoint number from its address
+     *
+     * @return the endpoint's endpoint number
+     */
+    public int getEndpointNumber() {
+        return mAddress & UsbConstants.USB_ENDPOINT_NUMBER_MASK;
+    }
+
+    /**
+     * Returns the endpoint's direction.
+     * Returns {@link android.hardware.UsbConstants#USB_DIR_OUT}
+     * if the direction is host to device, and
+     * {@link android.hardware.UsbConstants#USB_DIR_IN} if the
+     * direction is device to host.
+     *
+     * @return the endpoint's direction
+     */
+    public int getDirection() {
+        return mAddress & UsbConstants.USB_ENDPOINT_DIR_MASK;
+    }
+
+    /**
+     * Returns the endpoint's attributes field.
+     *
+     * @return the endpoint's attributes
+     */
+    public int getAttributes() {
+        return mAttributes;
+    }
+
+    /**
+     * Returns the endpoint's type.
+     * Possible results are:
+     * <ul>
+     * <li>{@link android.hardware.UsbConstants#USB_ENDPOINT_XFER_CONTROL} (endpoint zero)
+     * <li>{@link android.hardware.UsbConstants#USB_ENDPOINT_XFER_ISOC} (isochronous endpoint)
+     * <li>{@link android.hardware.UsbConstants#USB_ENDPOINT_XFER_BULK} (bulk endpoint)
+     * <li>{@link android.hardware.UsbConstants#USB_ENDPOINT_XFER_INT} (interrupt endpoint)
+     * </ul>
+     *
+     * @return the endpoint's type
+     */
+    public int getType() {
+        return mAttributes & UsbConstants.USB_ENDPOINT_XFERTYPE_MASK;
+    }
+
+    /**
+     * Returns the endpoint's maximum packet size.
+     *
+     * @return the endpoint's maximum packet size
+     */
+    public int getMaxPacketSize() {
+        return mMaxPacketSize;
+    }
+
+    /**
+     * Returns the endpoint's interval field.
+     *
+     * @return the endpoint's interval
+     */
+    public int getInterval() {
+        return mInterval;
+    }
+
+    /**
+     * Returns the {@link android.hardware.UsbInterface} this endpoint belongs to.
+     *
+     * @return the endpoint's interface
+     */
+    public UsbInterface getInterface() {
+        return mInterface;
+    }
+
+    /**
+     * Returns the {@link android.hardware.UsbDevice} this endpoint belongs to.
+     *
+     * @return the endpoint's device
+     */
+    public UsbDevice getDevice() {
+        return mInterface.getDevice();
+    }
+
+    // only used for parcelling
+    /* package */ void setInterface(UsbInterface intf) {
+        mInterface = intf;
+    }
+
+    @Override
+    public String toString() {
+        return "UsbEndpoint[mAddress=" + mAddress + ",mAttributes=" + mAttributes +
+                ",mMaxPacketSize=" + mMaxPacketSize + ",mInterval=" + mInterval +"]";
+    }
+
+    public static final Parcelable.Creator<UsbEndpoint> CREATOR =
+        new Parcelable.Creator<UsbEndpoint>() {
+        public UsbEndpoint createFromParcel(Parcel in) {
+            int address = in.readInt();
+            int attributes = in.readInt();
+            int maxPacketSize = in.readInt();
+            int interval = in.readInt();
+            return new UsbEndpoint(address, attributes, maxPacketSize, interval);
+        }
+
+        public UsbEndpoint[] newArray(int size) {
+            return new UsbEndpoint[size];
+        }
+    };
+
+    public int describeContents() {
+        return 0;
+    }
+
+    public void writeToParcel(Parcel parcel, int flags) {
+        parcel.writeInt(mAddress);
+        parcel.writeInt(mAttributes);
+        parcel.writeInt(mMaxPacketSize);
+        parcel.writeInt(mInterval);
+   }
+}
diff --git a/core/java/android/hardware/UsbInterface.aidl b/core/java/android/hardware/UsbInterface.aidl
new file mode 100644
index 0000000..a715ccd
--- /dev/null
+++ b/core/java/android/hardware/UsbInterface.aidl
@@ -0,0 +1,19 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.hardware;
+
+parcelable UsbInterface;
diff --git a/core/java/android/hardware/UsbInterface.java b/core/java/android/hardware/UsbInterface.java
new file mode 100644
index 0000000..deef81f
--- /dev/null
+++ b/core/java/android/hardware/UsbInterface.java
@@ -0,0 +1,159 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.hardware;
+
+import android.os.Bundle;
+import android.os.Parcel;
+import android.os.Parcelable;
+
+/**
+ * A class representing an interface on a {@link android.hardware.UsbDevice}.
+ */
+public final class UsbInterface implements Parcelable {
+
+    private int mId;
+    private int mClass;
+    private int mSubclass;
+    private int mProtocol;
+    private UsbDevice mDevice;
+    private Parcelable[] mEndpoints;
+
+    private UsbInterface() {
+    }
+
+    /**
+     * UsbInterface should only be instantiated by UsbService implementation
+     * @hide
+     */
+    public UsbInterface(int id, int Class, int subClass, int protocol,
+            Parcelable[] endpoints) {
+        mId = id;
+        mClass = Class;
+        mSubclass = subClass;
+        mProtocol = protocol;
+        mEndpoints = endpoints;
+    }
+
+    /**
+     * Returns the interface's ID field.
+     *
+     * @return the interface's ID
+     */
+    public int getId() {
+        return mId;
+    }
+
+    /**
+     * Returns the interface's class field.
+     * Some useful constants for USB classes can be found in
+     * {@link android.hardware.UsbConstants}
+     *
+     * @return the interface's class
+     */
+    public int getInterfaceClass() {
+        return mClass;
+    }
+
+    /**
+     * Returns the interface's subclass field.
+     *
+     * @return the interface's subclass
+     */
+    public int getInterfaceSubclass() {
+        return mSubclass;
+    }
+
+    /**
+     * Returns the interface's protocol field.
+     *
+     * @return the interface's protocol
+     */
+    public int getInterfaceProtocol() {
+        return mProtocol;
+    }
+
+    /**
+     * Returns the number of {@link android.hardware.UsbEndpoint}s this interface contains.
+     *
+     * @return the number of endpoints
+     */
+    public int getEndpointCount() {
+        return mEndpoints.length;
+    }
+
+    /**
+     * Returns the {@link android.hardware.UsbEndpoint} at the given index.
+     *
+     * @return the endpoint
+     */
+    public UsbEndpoint getEndpoint(int index) {
+        return (UsbEndpoint)mEndpoints[index];
+    }
+
+    /**
+     * Returns the {@link android.hardware.UsbDevice} this interface belongs to.
+     *
+     * @return the interface's device
+     */
+    public UsbDevice getDevice() {
+        return mDevice;
+    }
+
+    // only used for parcelling
+    /* package */ void setDevice(UsbDevice device) {
+        mDevice = device;
+    }
+
+    @Override
+    public String toString() {
+        return "UsbInterface[mId=" + mId + ",mClass=" + mClass +
+                ",mSubclass=" + mSubclass + ",mProtocol=" + mProtocol +
+                ",mEndpoints=" + mEndpoints + "]";
+    }
+
+    public static final Parcelable.Creator<UsbInterface> CREATOR =
+        new Parcelable.Creator<UsbInterface>() {
+        public UsbInterface createFromParcel(Parcel in) {
+            int id = in.readInt();
+            int Class = in.readInt();
+            int subClass = in.readInt();
+            int protocol = in.readInt();
+            Parcelable[] endpoints = in.readParcelableArray(UsbEndpoint.class.getClassLoader());
+            UsbInterface result = new UsbInterface(id, Class, subClass, protocol, endpoints);
+            for (int i = 0; i < endpoints.length; i++) {
+                ((UsbEndpoint)endpoints[i]).setInterface(result);
+            }
+            return result;
+        }
+
+        public UsbInterface[] newArray(int size) {
+            return new UsbInterface[size];
+        }
+    };
+
+    public int describeContents() {
+        return 0;
+    }
+
+    public void writeToParcel(Parcel parcel, int flags) {
+        parcel.writeInt(mId);
+        parcel.writeInt(mClass);
+        parcel.writeInt(mSubclass);
+        parcel.writeInt(mProtocol);
+        parcel.writeParcelableArray(mEndpoints, 0);
+   }
+}
diff --git a/core/java/android/hardware/UsbManager.java b/core/java/android/hardware/UsbManager.java
index 18790d2..8fad210 100644
--- a/core/java/android/hardware/UsbManager.java
+++ b/core/java/android/hardware/UsbManager.java
@@ -17,17 +17,31 @@
 
 package android.hardware;
 
+import android.os.Bundle;
+import android.os.ParcelFileDescriptor;
+import android.os.RemoteException;
+import android.util.Log;
+
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
+import java.util.HashMap;
 
 /**
- * Class for accessing USB state information.
- * @hide
+ * This class allows you to access the state of USB, both in host and device mode.
+ *
+ * <p>You can obtain an instance of this class by calling
+ * {@link android.content.Context#getSystemService(java.lang.String) Context.getSystemService()}.
+ *
+ * {@samplecode
+ * UsbManager manager = (UsbManager) getSystemService(Context.USB_SERVICE);
+ * }
  */
 public class UsbManager {
+    private static final String TAG = "UsbManager";
+
    /**
-     * Broadcast Action:  A sticky broadcast for USB state change events.
+     * Broadcast Action:  A sticky broadcast for USB state change events when in device mode.
      *
      * This is a sticky broadcast for clients that includes USB connected/disconnected state,
      * the USB configuration that is currently set and a bundle containing name/value pairs
@@ -39,6 +53,22 @@ public class UsbManager {
     public static final String ACTION_USB_STATE =
             "android.hardware.action.USB_STATE";
 
+   /**
+     * Broadcast Action:  A broadcast for USB device attached event.
+     *
+     * This intent is sent when a USB device is attached to the USB bus when in host mode.
+     */
+    public static final String ACTION_USB_DEVICE_ATTACHED =
+            "android.hardware.action.USB_DEVICE_ATTACHED";
+
+   /**
+     * Broadcast Action:  A broadcast for USB device detached event.
+     *
+     * This intent is sent when a USB device is detached from the USB bus when in host mode.
+     */
+    public static final String ACTION_USB_DEVICE_DETACHED =
+            "android.hardware.action.USB_DEVICE_DETACHED";
+
     /**
      * Boolean extra indicating whether USB is connected or disconnected.
      * Used in extras for the {@link #ACTION_USB_STATE} broadcast.
@@ -87,6 +117,103 @@ public class UsbManager {
      */
     public static final String USB_FUNCTION_DISABLED = "disabled";
 
+    /**
+     * Name of extra for {@link #ACTION_USB_DEVICE_ATTACHED} and
+     * {@link #ACTION_USB_DEVICE_DETACHED} broadcasts
+     * containing the device's ID (String).
+     */
+    public static final String EXTRA_DEVICE_NAME = "device_name";
+
+    /**
+     * Name of extra for {@link #ACTION_USB_DEVICE_ATTACHED} broadcast
+     * containing the device's vendor ID (int).
+     */
+    public static final String EXTRA_VENDOR_ID = "vendor_id";
+
+    /**
+     * Name of extra for {@link #ACTION_USB_DEVICE_ATTACHED} broadcast
+     * containing the device's product ID (int).
+     */
+    public static final String EXTRA_PRODUCT_ID = "product_id";
+
+    /**
+     * Name of extra for {@link #ACTION_USB_DEVICE_ATTACHED} broadcast
+     * containing the device's class (int).
+     */
+    public static final String EXTRA_DEVICE_CLASS = "device_class";
+
+    /**
+     * Name of extra for {@link #ACTION_USB_DEVICE_ATTACHED} broadcast
+     * containing the device's class (int).
+     */
+    public static final String EXTRA_DEVICE_SUBCLASS = "device_subclass";
+
+    /**
+     * Name of extra for {@link #ACTION_USB_DEVICE_ATTACHED} broadcast
+     * containing the device's class (int).
+     */
+    public static final String EXTRA_DEVICE_PROTOCOL = "device_protocol";
+
+    /**
+     * Name of extra for {@link #ACTION_USB_DEVICE_ATTACHED} broadcast
+     * containing the UsbDevice object for the device.
+     */
+    public static final String EXTRA_DEVICE = "device";
+
+    private IUsbManager mService;
+
+    /**
+     * {@hide}
+     */
+    public UsbManager(IUsbManager service) {
+        mService = service;
+    }
+
+    /**
+     * Returns a HashMap containing all USB devices currently attached.
+     * USB device name is the key for the returned HashMap.
+     * The result will be empty if no devices are attached, or if
+     * USB host mode is inactive or unsupported.
+     *
+     * @return HashMap containing all connected USB devices.
+     */
+    public HashMap<String,UsbDevice> getDeviceList() {
+        Bundle bundle = new Bundle();
+        try {
+            mService.getDeviceList(bundle);
+            HashMap<String,UsbDevice> result = new HashMap<String,UsbDevice>();
+            for (String name : bundle.keySet()) {
+                result.put(name, (UsbDevice)bundle.get(name));
+            }
+            return result;
+        } catch (RemoteException e) {
+            Log.e(TAG, "RemoteException in getDeviceList", e);
+            return null;
+        }
+    }
+
+    /**
+     * Opens the device so it can be used to send and receive
+     * data using {@link android.hardware.UsbRequest}.
+     *
+     * @param device the device to open
+     * @return true if we successfully opened the device
+     */
+    public boolean openDevice(UsbDevice device) {
+        try {
+            ParcelFileDescriptor pfd = mService.openDevice(device.getDeviceName());
+            if (pfd == null) {
+                return false;
+            }
+            boolean result = device.open(pfd);
+            pfd.close();
+            return result;
+        } catch (Exception e) {
+            Log.e(TAG, "exception in UsbManager.openDevice", e);
+            return false;
+        }
+    }
+
     private static File getFunctionEnableFile(String function) {
         return new File("/sys/class/usb_composite/" + function + "/enable");
     }
@@ -94,6 +221,9 @@ public class UsbManager {
     /**
      * Returns true if the specified USB function is supported by the kernel.
      * Note that a USB function maybe supported but disabled.
+     *
+     * @param function name of the USB function
+     * @return true if the USB function is supported.
      */
     public static boolean isFunctionSupported(String function) {
         return getFunctionEnableFile(function).exists();
@@ -101,6 +231,9 @@ public class UsbManager {
 
     /**
      * Returns true if the specified USB function is currently enabled.
+     *
+     * @param function name of the USB function
+     * @return true if the USB function is enabled.
      */
     public static boolean isFunctionEnabled(String function) {
         try {
diff --git a/core/java/android/hardware/UsbRequest.java b/core/java/android/hardware/UsbRequest.java
new file mode 100644
index 0000000..ae3a289
--- /dev/null
+++ b/core/java/android/hardware/UsbRequest.java
@@ -0,0 +1,177 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.hardware;
+
+import android.util.Log;
+
+import java.nio.ByteBuffer;
+
+/**
+ * A class representing USB request packet.
+ * This can be used for both reading and writing data to or from a
+ * {@link android.hardware.UsbDevice}.
+ * UsbRequests are sent asynchronously via {@link #queue} and the results
+ * are read by {@link android.hardware.UsbDevice#requestWait}.
+ */
+public class UsbRequest {
+
+    private static final String TAG = "UsbRequest";
+
+    // used by the JNI code
+    private int mNativeContext;
+
+    private UsbEndpoint mEndpoint;
+
+    // for temporarily saving current buffer across queue and dequeue
+    private ByteBuffer mBuffer;
+    private int mLength;
+
+    // for client use
+    private Object mClientData;
+
+    public UsbRequest() {
+    }
+
+    /**
+     * Initializes the request so it can read or write data on the given endpoint.
+     * Whether the request allows reading or writing depends on the direction of the endpoint.
+     *
+     * @param endpoint the endpoint to be used for this request.
+     * @return true if the request was successfully opened.
+     */
+    public boolean initialize(UsbEndpoint endpoint) {
+        mEndpoint = endpoint;
+        return native_init(endpoint.getDevice(),
+                endpoint.getAddress(), endpoint.getAttributes(),
+                endpoint.getMaxPacketSize(), endpoint.getInterval());
+    }
+
+    /**
+     * Releases all resources related to this request.
+     */
+    public void close() {
+        mEndpoint = null;
+        native_close();
+    }
+
+    @Override
+    protected void finalize() throws Throwable {
+        try {
+            if (mEndpoint != null) {
+                Log.v(TAG, "endpoint still open in finalize(): " + this);
+                close();
+            }
+        } finally {
+            super.finalize();
+        }
+    }
+
+    /**
+     * Returns the endpoint for the request, or null if the request is not opened.
+     *
+     * @return the request's endpoint
+     */
+    public UsbEndpoint getEndpoint() {
+        return mEndpoint;
+    }
+
+    /**
+     * Returns the client data for the request.
+     * This can be used in conjunction with {@link #setClientData}
+     * to associate another object with this request, which can be useful for
+     * maintaining state between calls to {@link #queue} and
+     * {@link android.hardware.UsbDevice#requestWait}
+     *
+     * @return the client data for the request
+     */
+    public Object getClientData() {
+        return mClientData;
+    }
+
+    /**
+     * Sets the client data for the request.
+     * This can be used in conjunction with {@link #getClientData}
+     * to associate another object with this request, which can be useful for
+     * maintaining state between calls to {@link #queue} and
+     * {@link android.hardware.UsbDevice#requestWait}
+     *
+     * @param data the client data for the request
+     */
+    public void setClientData(Object data) {
+        mClientData = data;
+    }
+
+    /**
+     * Queues the request to send or receive data on its endpoint.
+     * For OUT endpoints, the given buffer data will be sent on the endpoint.
+     * For IN endpoints, the endpoint will attempt to read the given number of bytes
+     * into the specified buffer.
+     * If the queueing operation is successful, we return true and the result will be
+     * returned via {@link android.hardware.UsbDevice#requestWait}
+     *
+     * @param buffer the buffer containing the bytes to write, or location to store
+     * the results of a read
+     * @param length number of bytes to read or write
+     * @return true if the queueing operation succeeded
+     */
+    public boolean queue(ByteBuffer buffer, int length) {
+        boolean out = (mEndpoint.getDirection() == UsbConstants.USB_DIR_OUT);
+        boolean result;
+        if (buffer.isDirect()) {
+            result = native_queue_direct(buffer, length, out);
+        } else if (buffer.hasArray()) {
+            result = native_queue_array(buffer.array(), length, out);
+        } else {
+            throw new IllegalArgumentException("buffer is not direct and has no array");
+        }
+        if (result) {
+            // save our buffer for when the request has completed
+            mBuffer = buffer;
+            mLength = length;
+        }
+        return result;
+    }
+
+    /* package */ void dequeue() {
+        boolean out = (mEndpoint.getDirection() == UsbConstants.USB_DIR_OUT);
+        if (mBuffer.isDirect()) {
+            native_dequeue_direct();
+        } else {
+            native_dequeue_array(mBuffer.array(), mLength, out);
+        }
+        mBuffer = null;
+        mLength = 0;
+    }
+
+    /**
+     * Cancels a pending queue operation.
+     *
+     * @return true if cancelling succeeded
+     */
+    public boolean cancel() {
+        return native_cancel();
+    }
+
+    private native boolean native_init(UsbDevice device, int ep_address, int ep_attributes,
+            int ep_max_packet_size, int ep_interval);
+    private native void native_close();
+    private native boolean native_queue_array(byte[] buffer, int length, boolean out);
+    private native void native_dequeue_array(byte[] buffer, int length, boolean out);
+    private native boolean native_queue_direct(ByteBuffer buffer, int length, boolean out);
+    private native void native_dequeue_direct();
+    private native boolean native_cancel();
+}