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