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
|
/*
* 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.mtp;
import android.hardware.usb.UsbDevice;
import android.hardware.usb.UsbDeviceConnection;
import android.os.ParcelFileDescriptor;
import android.util.Log;
/**
* This class represents an MTP or PTP device connected on the USB host bus.
*/
public final class MtpDevice {
private static final String TAG = "MtpDevice";
private final UsbDevice mDevice;
static {
System.loadLibrary("media_jni");
}
/**
* MtpClient constructor
*
* @param device the {@link android.hardware.usb.UsbDevice} for the MTP or PTP device
*/
public MtpDevice(UsbDevice device) {
mDevice = device;
}
/**
* Opens the MTP device. Once the device is open it takes ownership of the
* {@link android.hardware.usb.UsbDeviceConnection}.
* The connection will be closed when you call {@link #close()}
* The connection will also be closed if this method fails.
*
* @param connection an open {@link android.hardware.usb.UsbDeviceConnection} for the device
* @return true if the device was successfully opened.
*/
public boolean open(UsbDeviceConnection connection) {
boolean result = native_open(mDevice.getDeviceName(), connection.getFileDescriptor());
if (!result) {
connection.close();
}
return result;
}
/**
* Closes all resources related to the MtpDevice object
*/
public void close() {
native_close();
}
@Override
protected void finalize() throws Throwable {
try {
native_close();
} finally {
super.finalize();
}
}
/**
* Returns the name of the USB device
*
* @return the device name
*/
public String getDeviceName() {
return mDevice.getDeviceName();
}
/**
* Returns the ID of the USB device
*
* @return the device ID
*/
public int getDeviceId() {
return mDevice.getDeviceId();
}
@Override
public String toString() {
return mDevice.getDeviceName();
}
/**
* Returns the {@link android.mtp.MtpDeviceInfo} for this device
*
* @return the device info
*/
public MtpDeviceInfo getDeviceInfo() {
return native_get_device_info();
}
/**
* Returns the list of IDs for all storage units on this device
*
* @return the storage IDs
*/
public int[] getStorageIds() {
return native_get_storage_ids();
}
/**
* Returns the list of object handles for all objects on the given storage unit,
* with the given format and parent.
*
* @param storageId the storage unit to query
* @param format the format of the object to return, or zero for all formats
* @param objectHandle the parent object to query, or zero for the storage root
* @return the object handles
*/
public int[] getObjectHandles(int storageId, int format, int objectHandle) {
return native_get_object_handles(storageId, format, objectHandle);
}
/**
* Returns the data for an object as a byte array.
*
* @param objectHandle handle of the object to read
* @param objectSize the size of the object (this should match
* {@link android.mtp.MtpObjectInfo#getCompressedSize}
* @return the object's data, or null if reading fails
*/
public byte[] getObject(int objectHandle, int objectSize) {
return native_get_object(objectHandle, objectSize);
}
/**
* Returns the thumbnail data for an object as a byte array.
*
* @param objectHandle handle of the object to read
* @return the object's thumbnail, or null if reading fails
*/
public byte[] getThumbnail(int objectHandle) {
return native_get_thumbnail(objectHandle);
}
/**
* Retrieves the {@link android.mtp.MtpStorageInfo} for a storage unit.
*
* @param storageId the ID of the storage unit
* @return the MtpStorageInfo
*/
public MtpStorageInfo getStorageInfo(int storageId) {
return native_get_storage_info(storageId);
}
/**
* Retrieves the {@link android.mtp.MtpObjectInfo} for an object.
*
* @param objectHandle the handle of the object
* @return the MtpObjectInfo
*/
public MtpObjectInfo getObjectInfo(int objectHandle) {
return native_get_object_info(objectHandle);
}
/**
* Deletes an object on the device.
*
* @param objectHandle handle of the object to delete
* @return true if the deletion succeeds
*/
public boolean deleteObject(int objectHandle) {
return native_delete_object(objectHandle);
}
/**
* Retrieves the object handle for the parent of an object on the device.
*
* @param objectHandle handle of the object to query
* @return the parent's handle, or zero if it is in the root of the storage
*/
public long getParent(int objectHandle) {
return native_get_parent(objectHandle);
}
/**
* Retrieves the ID of the storage unit containing the given object on the device.
*
* @param objectHandle handle of the object to query
* @return the object's storage unit ID
*/
public long getStorageID(int objectHandle) {
return native_get_storage_id(objectHandle);
}
/**
* Copies the data for an object to a file in external storage.
*
* @param objectHandle handle of the object to read
* @param destPath path to destination for the file transfer.
* This path should be in the external storage as defined by
* {@link android.os.Environment#getExternalStorageDirectory}
* @return true if the file transfer succeeds
*/
public boolean importFile(int objectHandle, String destPath) {
return native_import_file(objectHandle, destPath);
}
// used by the JNI code
private int mNativeContext;
private native boolean native_open(String deviceName, int fd);
private native void native_close();
private native MtpDeviceInfo native_get_device_info();
private native int[] native_get_storage_ids();
private native MtpStorageInfo native_get_storage_info(int storageId);
private native int[] native_get_object_handles(int storageId, int format, int objectHandle);
private native MtpObjectInfo native_get_object_info(int objectHandle);
private native byte[] native_get_object(int objectHandle, int objectSize);
private native byte[] native_get_thumbnail(int objectHandle);
private native boolean native_delete_object(int objectHandle);
private native long native_get_parent(int objectHandle);
private native long native_get_storage_id(int objectHandle);
private native boolean native_import_file(int objectHandle, String destPath);
}
|