android_mtp_MtpDevice.cpp revision 5a15d0d31b877ef512b3379eac033c6bb041c86a 
1/*
2 * Copyright (C) 2010 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17// #define LOG_NDEBUG 0
18
19#define LOG_TAG "MtpDeviceJNI"
20#include "utils/Log.h"
21
22#include <stdio.h>
23#include <assert.h>
24#include <limits.h>
25#include <unistd.h>
26#include <fcntl.h>
27
28#include "jni.h"
29#include "JNIHelp.h"
30#include "android_runtime/AndroidRuntime.h"
31#include "android_runtime/Log.h"
32#include "private/android_filesystem_config.h"
33
34#include "MtpTypes.h"
35#include "MtpDevice.h"
36#include "MtpDeviceInfo.h"
37#include "MtpStorageInfo.h"
38#include "MtpObjectInfo.h"
39
40using namespace android;
41
42// ----------------------------------------------------------------------------
43
44static jfieldID field_context;
45
46jclass clazz_deviceInfo;
47jclass clazz_storageInfo;
48jclass clazz_objectInfo;
49
50jmethodID constructor_deviceInfo;
51jmethodID constructor_storageInfo;
52jmethodID constructor_objectInfo;
53
54// MtpDeviceInfo fields
55static jfieldID field_deviceInfo_manufacturer;
56static jfieldID field_deviceInfo_model;
57static jfieldID field_deviceInfo_version;
58static jfieldID field_deviceInfo_serialNumber;
59
60// MtpStorageInfo fields
61static jfieldID field_storageInfo_storageId;
62static jfieldID field_storageInfo_maxCapacity;
63static jfieldID field_storageInfo_freeSpace;
64static jfieldID field_storageInfo_description;
65static jfieldID field_storageInfo_volumeIdentifier;
66
67// MtpObjectInfo fields
68static jfieldID field_objectInfo_handle;
69static jfieldID field_objectInfo_storageId;
70static jfieldID field_objectInfo_format;
71static jfieldID field_objectInfo_protectionStatus;
72static jfieldID field_objectInfo_compressedSize;
73static jfieldID field_objectInfo_thumbFormat;
74static jfieldID field_objectInfo_thumbCompressedSize;
75static jfieldID field_objectInfo_thumbPixWidth;
76static jfieldID field_objectInfo_thumbPixHeight;
77static jfieldID field_objectInfo_imagePixWidth;
78static jfieldID field_objectInfo_imagePixHeight;
79static jfieldID field_objectInfo_imagePixDepth;
80static jfieldID field_objectInfo_parent;
81static jfieldID field_objectInfo_associationType;
82static jfieldID field_objectInfo_associationDesc;
83static jfieldID field_objectInfo_sequenceNumber;
84static jfieldID field_objectInfo_name;
85static jfieldID field_objectInfo_dateCreated;
86static jfieldID field_objectInfo_dateModified;
87static jfieldID field_objectInfo_keywords;
88
89MtpDevice* get_device_from_object(JNIEnv* env, jobject javaDevice)
90{
91    return (MtpDevice*)env->GetLongField(javaDevice, field_context);
92}
93
94// ----------------------------------------------------------------------------
95
96static jboolean
97android_mtp_MtpDevice_open(JNIEnv *env, jobject thiz, jstring deviceName, jint fd)
98{
99    const char *deviceNameStr = env->GetStringUTFChars(deviceName, NULL);
100    if (deviceNameStr == NULL) {
101        return JNI_FALSE;
102    }
103
104    MtpDevice* device = MtpDevice::open(deviceNameStr, fd);
105    env->ReleaseStringUTFChars(deviceName, deviceNameStr);
106
107    if (device)
108        env->SetLongField(thiz, field_context,  (jlong)device);
109    return (jboolean)(device != NULL);
110}
111
112static void
113android_mtp_MtpDevice_close(JNIEnv *env, jobject thiz)
114{
115    MtpDevice* device = get_device_from_object(env, thiz);
116    if (device) {
117        device->close();
118        delete device;
119        env->SetLongField(thiz, field_context, 0);
120    }
121}
122
123static jobject
124android_mtp_MtpDevice_get_device_info(JNIEnv *env, jobject thiz)
125{
126    MtpDevice* device = get_device_from_object(env, thiz);
127    if (!device) {
128        ALOGD("android_mtp_MtpDevice_get_device_info device is null");
129        return NULL;
130    }
131    MtpDeviceInfo* deviceInfo = device->getDeviceInfo();
132    if (!deviceInfo) {
133        ALOGD("android_mtp_MtpDevice_get_device_info deviceInfo is null");
134        return NULL;
135    }
136    jobject info = env->NewObject(clazz_deviceInfo, constructor_deviceInfo);
137    if (info == NULL) {
138        ALOGE("Could not create a MtpDeviceInfo object");
139        delete deviceInfo;
140        return NULL;
141    }
142
143    if (deviceInfo->mManufacturer)
144        env->SetObjectField(info, field_deviceInfo_manufacturer,
145            env->NewStringUTF(deviceInfo->mManufacturer));
146    if (deviceInfo->mModel)
147        env->SetObjectField(info, field_deviceInfo_model,
148            env->NewStringUTF(deviceInfo->mModel));
149    if (deviceInfo->mVersion)
150        env->SetObjectField(info, field_deviceInfo_version,
151            env->NewStringUTF(deviceInfo->mVersion));
152    if (deviceInfo->mSerial)
153        env->SetObjectField(info, field_deviceInfo_serialNumber,
154            env->NewStringUTF(deviceInfo->mSerial));
155
156    delete deviceInfo;
157    return info;
158}
159
160static jintArray
161android_mtp_MtpDevice_get_storage_ids(JNIEnv *env, jobject thiz)
162{
163    MtpDevice* device = get_device_from_object(env, thiz);
164    if (!device)
165        return NULL;
166    MtpStorageIDList* storageIDs = device->getStorageIDs();
167    if (!storageIDs)
168        return NULL;
169
170    int length = storageIDs->size();
171    jintArray array = env->NewIntArray(length);
172    // FIXME is this cast safe?
173    env->SetIntArrayRegion(array, 0, length, (const jint *)storageIDs->array());
174
175    delete storageIDs;
176    return array;
177}
178
179static jobject
180android_mtp_MtpDevice_get_storage_info(JNIEnv *env, jobject thiz, jint storageID)
181{
182    MtpDevice* device = get_device_from_object(env, thiz);
183    if (!device)
184        return NULL;
185    MtpStorageInfo* storageInfo = device->getStorageInfo(storageID);
186    if (!storageInfo)
187        return NULL;
188
189    jobject info = env->NewObject(clazz_storageInfo, constructor_storageInfo);
190    if (info == NULL) {
191        ALOGE("Could not create a MtpStorageInfo object");
192        delete storageInfo;
193        return NULL;
194    }
195
196    if (storageInfo->mStorageID)
197        env->SetIntField(info, field_storageInfo_storageId, storageInfo->mStorageID);
198    if (storageInfo->mMaxCapacity)
199        env->SetLongField(info, field_storageInfo_maxCapacity, storageInfo->mMaxCapacity);
200    if (storageInfo->mFreeSpaceBytes)
201        env->SetLongField(info, field_storageInfo_freeSpace, storageInfo->mFreeSpaceBytes);
202    if (storageInfo->mStorageDescription)
203        env->SetObjectField(info, field_storageInfo_description,
204            env->NewStringUTF(storageInfo->mStorageDescription));
205    if (storageInfo->mVolumeIdentifier)
206        env->SetObjectField(info, field_storageInfo_volumeIdentifier,
207            env->NewStringUTF(storageInfo->mVolumeIdentifier));
208
209    delete storageInfo;
210    return info;
211}
212
213static jintArray
214android_mtp_MtpDevice_get_object_handles(JNIEnv *env, jobject thiz,
215        jint storageID, jint format, jint objectID)
216{
217    MtpDevice* device = get_device_from_object(env, thiz);
218    if (!device)
219        return NULL;
220    MtpObjectHandleList* handles = device->getObjectHandles(storageID, format, objectID);
221    if (!handles)
222        return NULL;
223
224    int length = handles->size();
225    jintArray array = env->NewIntArray(length);
226    // FIXME is this cast safe?
227    env->SetIntArrayRegion(array, 0, length, (const jint *)handles->array());
228
229    delete handles;
230    return array;
231}
232
233static jobject
234android_mtp_MtpDevice_get_object_info(JNIEnv *env, jobject thiz, jint objectID)
235{
236    MtpDevice* device = get_device_from_object(env, thiz);
237    if (!device)
238        return NULL;
239    MtpObjectInfo* objectInfo = device->getObjectInfo(objectID);
240    if (!objectInfo)
241        return NULL;
242    jobject info = env->NewObject(clazz_objectInfo, constructor_objectInfo);
243    if (info == NULL) {
244        ALOGE("Could not create a MtpObjectInfo object");
245        delete objectInfo;
246        return NULL;
247    }
248
249    if (objectInfo->mHandle)
250        env->SetIntField(info, field_objectInfo_handle, objectInfo->mHandle);
251    if (objectInfo->mStorageID)
252        env->SetIntField(info, field_objectInfo_storageId, objectInfo->mStorageID);
253    if (objectInfo->mFormat)
254        env->SetIntField(info, field_objectInfo_format, objectInfo->mFormat);
255    if (objectInfo->mProtectionStatus)
256        env->SetIntField(info, field_objectInfo_protectionStatus, objectInfo->mProtectionStatus);
257    if (objectInfo->mCompressedSize)
258        env->SetIntField(info, field_objectInfo_compressedSize, objectInfo->mCompressedSize);
259    if (objectInfo->mThumbFormat)
260        env->SetIntField(info, field_objectInfo_thumbFormat, objectInfo->mThumbFormat);
261    if (objectInfo->mThumbCompressedSize)
262        env->SetIntField(info, field_objectInfo_thumbCompressedSize, objectInfo->mThumbCompressedSize);
263    if (objectInfo->mThumbPixWidth)
264        env->SetIntField(info, field_objectInfo_thumbPixWidth, objectInfo->mThumbPixWidth);
265    if (objectInfo->mThumbPixHeight)
266        env->SetIntField(info, field_objectInfo_thumbPixHeight, objectInfo->mThumbPixHeight);
267    if (objectInfo->mImagePixWidth)
268        env->SetIntField(info, field_objectInfo_imagePixWidth, objectInfo->mImagePixWidth);
269    if (objectInfo->mImagePixHeight)
270        env->SetIntField(info, field_objectInfo_imagePixHeight, objectInfo->mImagePixHeight);
271    if (objectInfo->mImagePixDepth)
272        env->SetIntField(info, field_objectInfo_imagePixDepth, objectInfo->mImagePixDepth);
273    if (objectInfo->mParent)
274        env->SetIntField(info, field_objectInfo_parent, objectInfo->mParent);
275    if (objectInfo->mAssociationType)
276        env->SetIntField(info, field_objectInfo_associationType, objectInfo->mAssociationType);
277    if (objectInfo->mAssociationDesc)
278        env->SetIntField(info, field_objectInfo_associationDesc, objectInfo->mAssociationDesc);
279    if (objectInfo->mSequenceNumber)
280        env->SetIntField(info, field_objectInfo_sequenceNumber, objectInfo->mSequenceNumber);
281    if (objectInfo->mName)
282        env->SetObjectField(info, field_objectInfo_name, env->NewStringUTF(objectInfo->mName));
283    if (objectInfo->mDateCreated)
284        env->SetLongField(info, field_objectInfo_dateCreated, objectInfo->mDateCreated * 1000LL);
285    if (objectInfo->mDateModified)
286        env->SetLongField(info, field_objectInfo_dateModified, objectInfo->mDateModified * 1000LL);
287    if (objectInfo->mKeywords)
288        env->SetObjectField(info, field_objectInfo_keywords,
289            env->NewStringUTF(objectInfo->mKeywords));
290
291    delete objectInfo;
292    return info;
293}
294
295struct get_object_callback_data {
296    JNIEnv *env;
297    jbyteArray array;
298};
299
300static bool get_object_callback(void* data, int offset, int length, void* clientData)
301{
302    get_object_callback_data* cbData = (get_object_callback_data *)clientData;
303    cbData->env->SetByteArrayRegion(cbData->array, offset, length, (jbyte *)data);
304    return true;
305}
306
307static jbyteArray
308android_mtp_MtpDevice_get_object(JNIEnv *env, jobject thiz, jint objectID, jint objectSize)
309{
310    MtpDevice* device = get_device_from_object(env, thiz);
311    if (!device)
312        return NULL;
313
314    jbyteArray array = env->NewByteArray(objectSize);
315    if (!array) {
316        jniThrowException(env, "java/lang/OutOfMemoryError", NULL);
317        return NULL;
318    }
319
320    get_object_callback_data data;
321    data.env = env;
322    data.array = array;
323
324    if (device->readObject(objectID, get_object_callback, objectSize, &data))
325        return array;
326    return NULL;
327}
328
329static jbyteArray
330android_mtp_MtpDevice_get_thumbnail(JNIEnv *env, jobject thiz, jint objectID)
331{
332    MtpDevice* device = get_device_from_object(env, thiz);
333    if (!device)
334        return NULL;
335
336    int length;
337    void* thumbnail = device->getThumbnail(objectID, length);
338    if (! thumbnail)
339        return NULL;
340    jbyteArray array = env->NewByteArray(length);
341    env->SetByteArrayRegion(array, 0, length, (const jbyte *)thumbnail);
342
343    free(thumbnail);
344    return array;
345}
346
347static jboolean
348android_mtp_MtpDevice_delete_object(JNIEnv *env, jobject thiz, jint object_id)
349{
350    MtpDevice* device = get_device_from_object(env, thiz);
351    if (device && device->deleteObject(object_id)) {
352        return JNI_TRUE;
353    } else {
354        return JNI_FALSE;
355    }
356}
357
358static jlong
359android_mtp_MtpDevice_get_parent(JNIEnv *env, jobject thiz, jint object_id)
360{
361    MtpDevice* device = get_device_from_object(env, thiz);
362    if (device)
363        return (jlong)device->getParent(object_id);
364    else
365        return -1;
366}
367
368static jlong
369android_mtp_MtpDevice_get_storage_id(JNIEnv *env, jobject thiz, jint object_id)
370{
371    MtpDevice* device = get_device_from_object(env, thiz);
372    if (device)
373        return (jlong)device->getStorageID(object_id);
374    else
375        return -1;
376}
377
378static jboolean
379android_mtp_MtpDevice_import_file(JNIEnv *env, jobject thiz, jint object_id, jstring dest_path)
380{
381    MtpDevice* device = get_device_from_object(env, thiz);
382    if (device) {
383        const char *destPathStr = env->GetStringUTFChars(dest_path, NULL);
384        if (destPathStr == NULL) {
385            return JNI_FALSE;
386        }
387
388        jboolean result = device->readObject(object_id, destPathStr, AID_SDCARD_RW, 0664);
389        env->ReleaseStringUTFChars(dest_path, destPathStr);
390        return result;
391    }
392
393    return JNI_FALSE;
394}
395
396// ----------------------------------------------------------------------------
397
398static JNINativeMethod gMethods[] = {
399    {"native_open",             "(Ljava/lang/String;I)Z",
400                                        (void *)android_mtp_MtpDevice_open},
401    {"native_close",            "()V",  (void *)android_mtp_MtpDevice_close},
402    {"native_get_device_info",  "()Landroid/mtp/MtpDeviceInfo;",
403                                        (void *)android_mtp_MtpDevice_get_device_info},
404    {"native_get_storage_ids",  "()[I", (void *)android_mtp_MtpDevice_get_storage_ids},
405    {"native_get_storage_info", "(I)Landroid/mtp/MtpStorageInfo;",
406                                        (void *)android_mtp_MtpDevice_get_storage_info},
407    {"native_get_object_handles","(III)[I",
408                                        (void *)android_mtp_MtpDevice_get_object_handles},
409    {"native_get_object_info",  "(I)Landroid/mtp/MtpObjectInfo;",
410                                        (void *)android_mtp_MtpDevice_get_object_info},
411    {"native_get_object",       "(II)[B",(void *)android_mtp_MtpDevice_get_object},
412    {"native_get_thumbnail",    "(I)[B",(void *)android_mtp_MtpDevice_get_thumbnail},
413    {"native_delete_object",    "(I)Z", (void *)android_mtp_MtpDevice_delete_object},
414    {"native_get_parent",       "(I)J", (void *)android_mtp_MtpDevice_get_parent},
415    {"native_get_storage_id",   "(I)J", (void *)android_mtp_MtpDevice_get_storage_id},
416    {"native_import_file",     "(ILjava/lang/String;)Z",
417                                        (void *)android_mtp_MtpDevice_import_file},
418};
419
420static const char* const kClassPathName = "android/mtp/MtpDevice";
421
422int register_android_mtp_MtpDevice(JNIEnv *env)
423{
424    jclass clazz;
425
426    ALOGD("register_android_mtp_MtpDevice\n");
427
428    clazz = env->FindClass("android/mtp/MtpDeviceInfo");
429    if (clazz == NULL) {
430        ALOGE("Can't find android/mtp/MtpDeviceInfo");
431        return -1;
432    }
433    constructor_deviceInfo = env->GetMethodID(clazz, "<init>", "()V");
434    if (constructor_deviceInfo == NULL) {
435        ALOGE("Can't find android/mtp/MtpDeviceInfo constructor");
436        return -1;
437    }
438    field_deviceInfo_manufacturer = env->GetFieldID(clazz, "mManufacturer", "Ljava/lang/String;");
439    if (field_deviceInfo_manufacturer == NULL) {
440        ALOGE("Can't find MtpDeviceInfo.mManufacturer");
441        return -1;
442    }
443    field_deviceInfo_model = env->GetFieldID(clazz, "mModel", "Ljava/lang/String;");
444    if (field_deviceInfo_model == NULL) {
445        ALOGE("Can't find MtpDeviceInfo.mModel");
446        return -1;
447    }
448    field_deviceInfo_version = env->GetFieldID(clazz, "mVersion", "Ljava/lang/String;");
449    if (field_deviceInfo_version == NULL) {
450        ALOGE("Can't find MtpDeviceInfo.mVersion");
451        return -1;
452    }
453    field_deviceInfo_serialNumber = env->GetFieldID(clazz, "mSerialNumber", "Ljava/lang/String;");
454    if (field_deviceInfo_serialNumber == NULL) {
455        ALOGE("Can't find MtpDeviceInfo.mSerialNumber");
456        return -1;
457    }
458    clazz_deviceInfo = (jclass)env->NewGlobalRef(clazz);
459
460    clazz = env->FindClass("android/mtp/MtpStorageInfo");
461    if (clazz == NULL) {
462        ALOGE("Can't find android/mtp/MtpStorageInfo");
463        return -1;
464    }
465    constructor_storageInfo = env->GetMethodID(clazz, "<init>", "()V");
466    if (constructor_storageInfo == NULL) {
467        ALOGE("Can't find android/mtp/MtpStorageInfo constructor");
468        return -1;
469    }
470    field_storageInfo_storageId = env->GetFieldID(clazz, "mStorageId", "I");
471    if (field_storageInfo_storageId == NULL) {
472        ALOGE("Can't find MtpStorageInfo.mStorageId");
473        return -1;
474    }
475    field_storageInfo_maxCapacity = env->GetFieldID(clazz, "mMaxCapacity", "J");
476    if (field_storageInfo_maxCapacity == NULL) {
477        ALOGE("Can't find MtpStorageInfo.mMaxCapacity");
478        return -1;
479    }
480    field_storageInfo_freeSpace = env->GetFieldID(clazz, "mFreeSpace", "J");
481    if (field_storageInfo_freeSpace == NULL) {
482        ALOGE("Can't find MtpStorageInfo.mFreeSpace");
483        return -1;
484    }
485    field_storageInfo_description = env->GetFieldID(clazz, "mDescription", "Ljava/lang/String;");
486    if (field_storageInfo_description == NULL) {
487        ALOGE("Can't find MtpStorageInfo.mDescription");
488        return -1;
489    }
490    field_storageInfo_volumeIdentifier = env->GetFieldID(clazz, "mVolumeIdentifier", "Ljava/lang/String;");
491    if (field_storageInfo_volumeIdentifier == NULL) {
492        ALOGE("Can't find MtpStorageInfo.mVolumeIdentifier");
493        return -1;
494    }
495    clazz_storageInfo = (jclass)env->NewGlobalRef(clazz);
496
497    clazz = env->FindClass("android/mtp/MtpObjectInfo");
498    if (clazz == NULL) {
499        ALOGE("Can't find android/mtp/MtpObjectInfo");
500        return -1;
501    }
502    constructor_objectInfo = env->GetMethodID(clazz, "<init>", "()V");
503    if (constructor_objectInfo == NULL) {
504        ALOGE("Can't find android/mtp/MtpObjectInfo constructor");
505        return -1;
506    }
507    field_objectInfo_handle = env->GetFieldID(clazz, "mHandle", "I");
508    if (field_objectInfo_handle == NULL) {
509        ALOGE("Can't find MtpObjectInfo.mHandle");
510        return -1;
511    }
512    field_objectInfo_storageId = env->GetFieldID(clazz, "mStorageId", "I");
513    if (field_objectInfo_storageId == NULL) {
514        ALOGE("Can't find MtpObjectInfo.mStorageId");
515        return -1;
516    }
517    field_objectInfo_format = env->GetFieldID(clazz, "mFormat", "I");
518    if (field_objectInfo_format == NULL) {
519        ALOGE("Can't find MtpObjectInfo.mFormat");
520        return -1;
521    }
522    field_objectInfo_protectionStatus = env->GetFieldID(clazz, "mProtectionStatus", "I");
523    if (field_objectInfo_protectionStatus == NULL) {
524        ALOGE("Can't find MtpObjectInfo.mProtectionStatus");
525        return -1;
526    }
527    field_objectInfo_compressedSize = env->GetFieldID(clazz, "mCompressedSize", "I");
528    if (field_objectInfo_compressedSize == NULL) {
529        ALOGE("Can't find MtpObjectInfo.mCompressedSize");
530        return -1;
531    }
532    field_objectInfo_thumbFormat = env->GetFieldID(clazz, "mThumbFormat", "I");
533    if (field_objectInfo_thumbFormat == NULL) {
534        ALOGE("Can't find MtpObjectInfo.mThumbFormat");
535        return -1;
536    }
537    field_objectInfo_thumbCompressedSize = env->GetFieldID(clazz, "mThumbCompressedSize", "I");
538    if (field_objectInfo_thumbCompressedSize == NULL) {
539        ALOGE("Can't find MtpObjectInfo.mThumbCompressedSize");
540        return -1;
541    }
542    field_objectInfo_thumbPixWidth = env->GetFieldID(clazz, "mThumbPixWidth", "I");
543    if (field_objectInfo_thumbPixWidth == NULL) {
544        ALOGE("Can't find MtpObjectInfo.mThumbPixWidth");
545        return -1;
546    }
547    field_objectInfo_thumbPixHeight = env->GetFieldID(clazz, "mThumbPixHeight", "I");
548    if (field_objectInfo_thumbPixHeight == NULL) {
549        ALOGE("Can't find MtpObjectInfo.mThumbPixHeight");
550        return -1;
551    }
552    field_objectInfo_imagePixWidth = env->GetFieldID(clazz, "mImagePixWidth", "I");
553    if (field_objectInfo_imagePixWidth == NULL) {
554        ALOGE("Can't find MtpObjectInfo.mImagePixWidth");
555        return -1;
556    }
557    field_objectInfo_imagePixHeight = env->GetFieldID(clazz, "mImagePixHeight", "I");
558    if (field_objectInfo_imagePixHeight == NULL) {
559        ALOGE("Can't find MtpObjectInfo.mImagePixHeight");
560        return -1;
561    }
562    field_objectInfo_imagePixDepth = env->GetFieldID(clazz, "mImagePixDepth", "I");
563    if (field_objectInfo_imagePixDepth == NULL) {
564        ALOGE("Can't find MtpObjectInfo.mImagePixDepth");
565        return -1;
566    }
567    field_objectInfo_parent = env->GetFieldID(clazz, "mParent", "I");
568    if (field_objectInfo_parent == NULL) {
569        ALOGE("Can't find MtpObjectInfo.mParent");
570        return -1;
571    }
572    field_objectInfo_associationType = env->GetFieldID(clazz, "mAssociationType", "I");
573    if (field_objectInfo_associationType == NULL) {
574        ALOGE("Can't find MtpObjectInfo.mAssociationType");
575        return -1;
576    }
577    field_objectInfo_associationDesc = env->GetFieldID(clazz, "mAssociationDesc", "I");
578    if (field_objectInfo_associationDesc == NULL) {
579        ALOGE("Can't find MtpObjectInfo.mAssociationDesc");
580        return -1;
581    }
582    field_objectInfo_sequenceNumber = env->GetFieldID(clazz, "mSequenceNumber", "I");
583    if (field_objectInfo_sequenceNumber == NULL) {
584        ALOGE("Can't find MtpObjectInfo.mSequenceNumber");
585        return -1;
586    }
587    field_objectInfo_name = env->GetFieldID(clazz, "mName", "Ljava/lang/String;");
588    if (field_objectInfo_name == NULL) {
589        ALOGE("Can't find MtpObjectInfo.mName");
590        return -1;
591    }
592    field_objectInfo_dateCreated = env->GetFieldID(clazz, "mDateCreated", "J");
593    if (field_objectInfo_dateCreated == NULL) {
594        ALOGE("Can't find MtpObjectInfo.mDateCreated");
595        return -1;
596    }
597    field_objectInfo_dateModified = env->GetFieldID(clazz, "mDateModified", "J");
598    if (field_objectInfo_dateModified == NULL) {
599        ALOGE("Can't find MtpObjectInfo.mDateModified");
600        return -1;
601    }
602    field_objectInfo_keywords = env->GetFieldID(clazz, "mKeywords", "Ljava/lang/String;");
603    if (field_objectInfo_keywords == NULL) {
604        ALOGE("Can't find MtpObjectInfo.mKeywords");
605        return -1;
606    }
607    clazz_objectInfo = (jclass)env->NewGlobalRef(clazz);
608
609    clazz = env->FindClass("android/mtp/MtpDevice");
610    if (clazz == NULL) {
611        ALOGE("Can't find android/mtp/MtpDevice");
612        return -1;
613    }
614    field_context = env->GetFieldID(clazz, "mNativeContext", "J");
615    if (field_context == NULL) {
616        ALOGE("Can't find MtpDevice.mNativeContext");
617        return -1;
618    }
619
620    return AndroidRuntime::registerNativeMethods(env,
621                "android/mtp/MtpDevice", gMethods, NELEM(gMethods));
622}
623