1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
|
/*
* 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.usb;
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.usb.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.usb.UsbInterface}s this device contains.
*
* @return the number of interfaces
*/
public int getInterfaceCount() {
return mInterfaces.length;
}
/**
* Returns the {@link android.hardware.usb.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.usb.UsbInterface}.
* This must be done before sending or receiving data on any
* {@link android.hardware.usb.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.usb.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.
* The direction of the transfer is determined by the request type.
* If requestType & {@link UsbConstants#USB_ENDPOINT_DIR_MASK} is
* {@link UsbConstants#USB_DIR_OUT}, then the transfer is a write,
* and if it is {@link UsbConstants#USB_DIR_IN}, then the transfer
* is a read.
*
* @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
* @param timeout in milliseconds
* @return length of data transferred (or zero) for success,
* or negative value for failure
*/
public int controlTransfer(int requestType, int request, int value,
int index, byte[] buffer, int length, int timeout) {
return native_control_request(requestType, request, value, index, buffer, length, timeout);
}
/**
* Performs a bulk transaction on the given endpoint.
* The direction of the transfer is determined by the direction of the endpoint
*
* @param endpoint the endpoint for this transaction
* @param buffer buffer for data to send or receive,
* @param length the length of the data to send or receive
* @param timeout in milliseconds
* @return length of data transferred (or zero) for success,
* or negative value for failure
*/
public int bulkTransfer(UsbEndpoint endpoint, byte[] buffer, int length, int timeout) {
return native_bulk_request(endpoint.getAddress(), buffer, length, timeout);
}
/**
* Waits for the result of a {@link android.hardware.usb.UsbRequest#queue} operation
* Note that this may return requests queued on multiple
* {@link android.hardware.usb.UsbEndpoint}s.
* When multiple endpoints are in use, {@link android.hardware.usb.UsbRequest#getEndpoint} and
* {@link android.hardware.usb.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 int hashCode() {
return mName.hashCode();
}
@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, int timeout);
private native int native_bulk_request(int endpoint, byte[] buffer, int length, int timeout);
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);
}
|