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 <memory> 29#include <string> 30 31#include "jni.h" 32#include "JNIHelp.h" 33#include "ScopedPrimitiveArray.h" 34 35#include "android_runtime/AndroidRuntime.h" 36#include "android_runtime/Log.h" 37#include "nativehelper/ScopedLocalRef.h" 38#include "private/android_filesystem_config.h" 39 40#include "MtpTypes.h" 41#include "MtpDevice.h" 42#include "MtpDeviceInfo.h" 43#include "MtpStorageInfo.h" 44#include "MtpObjectInfo.h" 45#include "MtpProperty.h" 46 47using namespace android; 48 49// ---------------------------------------------------------------------------- 50 51namespace { 52 53static jfieldID field_context; 54 55jclass clazz_deviceInfo; 56jclass clazz_storageInfo; 57jclass clazz_objectInfo; 58jclass clazz_event; 59jclass clazz_io_exception; 60jclass clazz_operation_canceled_exception; 61 62jmethodID constructor_deviceInfo; 63jmethodID constructor_storageInfo; 64jmethodID constructor_objectInfo; 65jmethodID constructor_event; 66 67// MtpDeviceInfo fields 68static jfieldID field_deviceInfo_manufacturer; 69static jfieldID field_deviceInfo_model; 70static jfieldID field_deviceInfo_version; 71static jfieldID field_deviceInfo_serialNumber; 72static jfieldID field_deviceInfo_operationsSupported; 73static jfieldID field_deviceInfo_eventsSupported; 74 75// MtpStorageInfo fields 76static jfieldID field_storageInfo_storageId; 77static jfieldID field_storageInfo_maxCapacity; 78static jfieldID field_storageInfo_freeSpace; 79static jfieldID field_storageInfo_description; 80static jfieldID field_storageInfo_volumeIdentifier; 81 82// MtpObjectInfo fields 83static jfieldID field_objectInfo_handle; 84static jfieldID field_objectInfo_storageId; 85static jfieldID field_objectInfo_format; 86static jfieldID field_objectInfo_protectionStatus; 87static jfieldID field_objectInfo_compressedSize; 88static jfieldID field_objectInfo_thumbFormat; 89static jfieldID field_objectInfo_thumbCompressedSize; 90static jfieldID field_objectInfo_thumbPixWidth; 91static jfieldID field_objectInfo_thumbPixHeight; 92static jfieldID field_objectInfo_imagePixWidth; 93static jfieldID field_objectInfo_imagePixHeight; 94static jfieldID field_objectInfo_imagePixDepth; 95static jfieldID field_objectInfo_parent; 96static jfieldID field_objectInfo_associationType; 97static jfieldID field_objectInfo_associationDesc; 98static jfieldID field_objectInfo_sequenceNumber; 99static jfieldID field_objectInfo_name; 100static jfieldID field_objectInfo_dateCreated; 101static jfieldID field_objectInfo_dateModified; 102static jfieldID field_objectInfo_keywords; 103 104// MtpEvent fields 105static jfieldID field_event_eventCode; 106static jfieldID field_event_parameter1; 107static jfieldID field_event_parameter2; 108static jfieldID field_event_parameter3; 109 110class JavaArrayWriter { 111public: 112 JavaArrayWriter(JNIEnv* env, jbyteArray array) : 113 mEnv(env), mArray(array), mSize(mEnv->GetArrayLength(mArray)) {} 114 bool write(void* data, uint32_t offset, uint32_t length) { 115 if (static_cast<uint32_t>(mSize) < offset + length) { 116 return false; 117 } 118 mEnv->SetByteArrayRegion(mArray, offset, length, static_cast<jbyte*>(data)); 119 return true; 120 } 121 static bool writeTo(void* data, uint32_t offset, uint32_t length, void* clientData) { 122 return static_cast<JavaArrayWriter*>(clientData)->write(data, offset, length); 123 } 124 125private: 126 JNIEnv* mEnv; 127 jbyteArray mArray; 128 jsize mSize; 129}; 130 131} 132 133MtpDevice* get_device_from_object(JNIEnv* env, jobject javaDevice) 134{ 135 return (MtpDevice*)env->GetLongField(javaDevice, field_context); 136} 137 138void fill_jobject_from_object_info(JNIEnv* env, jobject object, MtpObjectInfo* objectInfo) { 139 if (objectInfo->mHandle) 140 env->SetIntField(object, field_objectInfo_handle, objectInfo->mHandle); 141 if (objectInfo->mStorageID) 142 env->SetIntField(object, field_objectInfo_storageId, objectInfo->mStorageID); 143 if (objectInfo->mFormat) 144 env->SetIntField(object, field_objectInfo_format, objectInfo->mFormat); 145 if (objectInfo->mProtectionStatus) 146 env->SetIntField(object, field_objectInfo_protectionStatus, objectInfo->mProtectionStatus); 147 if (objectInfo->mCompressedSize) 148 env->SetIntField(object, field_objectInfo_compressedSize, objectInfo->mCompressedSize); 149 if (objectInfo->mThumbFormat) 150 env->SetIntField(object, field_objectInfo_thumbFormat, objectInfo->mThumbFormat); 151 if (objectInfo->mThumbCompressedSize) { 152 env->SetIntField(object, field_objectInfo_thumbCompressedSize, 153 objectInfo->mThumbCompressedSize); 154 } 155 if (objectInfo->mThumbPixWidth) 156 env->SetIntField(object, field_objectInfo_thumbPixWidth, objectInfo->mThumbPixWidth); 157 if (objectInfo->mThumbPixHeight) 158 env->SetIntField(object, field_objectInfo_thumbPixHeight, objectInfo->mThumbPixHeight); 159 if (objectInfo->mImagePixWidth) 160 env->SetIntField(object, field_objectInfo_imagePixWidth, objectInfo->mImagePixWidth); 161 if (objectInfo->mImagePixHeight) 162 env->SetIntField(object, field_objectInfo_imagePixHeight, objectInfo->mImagePixHeight); 163 if (objectInfo->mImagePixDepth) 164 env->SetIntField(object, field_objectInfo_imagePixDepth, objectInfo->mImagePixDepth); 165 if (objectInfo->mParent) 166 env->SetIntField(object, field_objectInfo_parent, objectInfo->mParent); 167 if (objectInfo->mAssociationType) 168 env->SetIntField(object, field_objectInfo_associationType, objectInfo->mAssociationType); 169 if (objectInfo->mAssociationDesc) 170 env->SetIntField(object, field_objectInfo_associationDesc, objectInfo->mAssociationDesc); 171 if (objectInfo->mSequenceNumber) 172 env->SetIntField(object, field_objectInfo_sequenceNumber, objectInfo->mSequenceNumber); 173 if (objectInfo->mName) 174 env->SetObjectField(object, field_objectInfo_name, env->NewStringUTF(objectInfo->mName)); 175 if (objectInfo->mDateCreated) 176 env->SetLongField(object, field_objectInfo_dateCreated, objectInfo->mDateCreated * 1000LL); 177 if (objectInfo->mDateModified) { 178 env->SetLongField(object, field_objectInfo_dateModified, 179 objectInfo->mDateModified * 1000LL); 180 } 181 if (objectInfo->mKeywords) { 182 env->SetObjectField(object, field_objectInfo_keywords, 183 env->NewStringUTF(objectInfo->mKeywords)); 184 } 185} 186 187// ---------------------------------------------------------------------------- 188 189static jboolean 190android_mtp_MtpDevice_open(JNIEnv *env, jobject thiz, jstring deviceName, jint fd) 191{ 192 const char *deviceNameStr = env->GetStringUTFChars(deviceName, NULL); 193 if (deviceNameStr == NULL) { 194 return JNI_FALSE; 195 } 196 197 // The passed in fd is maintained by the UsbDeviceConnection 198 fd = dup(fd); 199 200 MtpDevice* device = MtpDevice::open(deviceNameStr, fd); 201 env->ReleaseStringUTFChars(deviceName, deviceNameStr); 202 203 if (device) 204 env->SetLongField(thiz, field_context, (jlong)device); 205 return (jboolean)(device != NULL); 206} 207 208static void 209android_mtp_MtpDevice_close(JNIEnv *env, jobject thiz) 210{ 211 MtpDevice* device = get_device_from_object(env, thiz); 212 if (device) { 213 device->close(); 214 delete device; 215 env->SetLongField(thiz, field_context, 0); 216 } 217} 218 219static jobject 220android_mtp_MtpDevice_get_device_info(JNIEnv *env, jobject thiz) 221{ 222 MtpDevice* device = get_device_from_object(env, thiz); 223 if (!device) { 224 ALOGD("android_mtp_MtpDevice_get_device_info device is null"); 225 return NULL; 226 } 227 std::unique_ptr<MtpDeviceInfo> deviceInfo(device->getDeviceInfo()); 228 if (!deviceInfo) { 229 ALOGD("android_mtp_MtpDevice_get_device_info deviceInfo is null"); 230 return NULL; 231 } 232 jobject info = env->NewObject(clazz_deviceInfo, constructor_deviceInfo); 233 if (info == NULL) { 234 ALOGE("Could not create a MtpDeviceInfo object"); 235 return NULL; 236 } 237 238 if (deviceInfo->mManufacturer) 239 env->SetObjectField(info, field_deviceInfo_manufacturer, 240 env->NewStringUTF(deviceInfo->mManufacturer)); 241 if (deviceInfo->mModel) 242 env->SetObjectField(info, field_deviceInfo_model, 243 env->NewStringUTF(deviceInfo->mModel)); 244 if (deviceInfo->mVersion) 245 env->SetObjectField(info, field_deviceInfo_version, 246 env->NewStringUTF(deviceInfo->mVersion)); 247 if (deviceInfo->mSerial) 248 env->SetObjectField(info, field_deviceInfo_serialNumber, 249 env->NewStringUTF(deviceInfo->mSerial)); 250 assert(deviceInfo->mOperations); 251 { 252 const size_t size = deviceInfo->mOperations->size(); 253 ScopedLocalRef<jintArray> operations(env, static_cast<jintArray>(env->NewIntArray(size))); 254 { 255 ScopedIntArrayRW elements(env, operations.get()); 256 if (elements.get() == NULL) { 257 ALOGE("Could not create operationsSupported element."); 258 return NULL; 259 } 260 for (size_t i = 0; i < size; ++i) { 261 elements[i] = deviceInfo->mOperations->itemAt(i); 262 } 263 env->SetObjectField(info, field_deviceInfo_operationsSupported, operations.get()); 264 } 265 } 266 assert(deviceInfo->mEvents); 267 { 268 const size_t size = deviceInfo->mEvents->size(); 269 ScopedLocalRef<jintArray> events(env, static_cast<jintArray>(env->NewIntArray(size))); 270 { 271 ScopedIntArrayRW elements(env, events.get()); 272 if (elements.get() == NULL) { 273 ALOGE("Could not create eventsSupported element."); 274 return NULL; 275 } 276 for (size_t i = 0; i < size; ++i) { 277 elements[i] = deviceInfo->mEvents->itemAt(i); 278 } 279 env->SetObjectField(info, field_deviceInfo_eventsSupported, events.get()); 280 } 281 } 282 283 return info; 284} 285 286static jintArray 287android_mtp_MtpDevice_get_storage_ids(JNIEnv *env, jobject thiz) 288{ 289 MtpDevice* device = get_device_from_object(env, thiz); 290 if (!device) 291 return NULL; 292 MtpStorageIDList* storageIDs = device->getStorageIDs(); 293 if (!storageIDs) 294 return NULL; 295 296 int length = storageIDs->size(); 297 jintArray array = env->NewIntArray(length); 298 // FIXME is this cast safe? 299 env->SetIntArrayRegion(array, 0, length, (const jint *)storageIDs->array()); 300 301 delete storageIDs; 302 return array; 303} 304 305static jobject 306android_mtp_MtpDevice_get_storage_info(JNIEnv *env, jobject thiz, jint storageID) 307{ 308 MtpDevice* device = get_device_from_object(env, thiz); 309 if (!device) 310 return NULL; 311 MtpStorageInfo* storageInfo = device->getStorageInfo(storageID); 312 if (!storageInfo) 313 return NULL; 314 315 jobject info = env->NewObject(clazz_storageInfo, constructor_storageInfo); 316 if (info == NULL) { 317 ALOGE("Could not create a MtpStorageInfo object"); 318 delete storageInfo; 319 return NULL; 320 } 321 322 if (storageInfo->mStorageID) 323 env->SetIntField(info, field_storageInfo_storageId, storageInfo->mStorageID); 324 if (storageInfo->mMaxCapacity) 325 env->SetLongField(info, field_storageInfo_maxCapacity, storageInfo->mMaxCapacity); 326 if (storageInfo->mFreeSpaceBytes) 327 env->SetLongField(info, field_storageInfo_freeSpace, storageInfo->mFreeSpaceBytes); 328 if (storageInfo->mStorageDescription) 329 env->SetObjectField(info, field_storageInfo_description, 330 env->NewStringUTF(storageInfo->mStorageDescription)); 331 if (storageInfo->mVolumeIdentifier) 332 env->SetObjectField(info, field_storageInfo_volumeIdentifier, 333 env->NewStringUTF(storageInfo->mVolumeIdentifier)); 334 335 delete storageInfo; 336 return info; 337} 338 339static jintArray 340android_mtp_MtpDevice_get_object_handles(JNIEnv *env, jobject thiz, 341 jint storageID, jint format, jint objectID) 342{ 343 MtpDevice* device = get_device_from_object(env, thiz); 344 if (!device) 345 return NULL; 346 MtpObjectHandleList* handles = device->getObjectHandles(storageID, format, objectID); 347 if (!handles) 348 return NULL; 349 350 int length = handles->size(); 351 jintArray array = env->NewIntArray(length); 352 // FIXME is this cast safe? 353 env->SetIntArrayRegion(array, 0, length, (const jint *)handles->array()); 354 355 delete handles; 356 return array; 357} 358 359static jobject 360android_mtp_MtpDevice_get_object_info(JNIEnv *env, jobject thiz, jint objectID) 361{ 362 MtpDevice* device = get_device_from_object(env, thiz); 363 if (!device) 364 return NULL; 365 MtpObjectInfo* objectInfo = device->getObjectInfo(objectID); 366 if (!objectInfo) 367 return NULL; 368 jobject info = env->NewObject(clazz_objectInfo, constructor_objectInfo); 369 if (info == NULL) { 370 ALOGE("Could not create a MtpObjectInfo object"); 371 delete objectInfo; 372 return NULL; 373 } 374 375 fill_jobject_from_object_info(env, info, objectInfo); 376 delete objectInfo; 377 return info; 378} 379 380bool check_uint32_arg(JNIEnv *env, const char* name, jlong value, uint32_t* out) { 381 if (value < 0 || 0xffffffff < value) { 382 jniThrowException( 383 env, 384 "java/lang/IllegalArgumentException", 385 (std::string("argument must be a 32-bit unsigned integer: ") + name).c_str()); 386 return false; 387 } 388 *out = static_cast<uint32_t>(value); 389 return true; 390} 391 392static jbyteArray 393android_mtp_MtpDevice_get_object(JNIEnv *env, jobject thiz, jint objectID, jlong objectSizeLong) 394{ 395 uint32_t objectSize; 396 if (!check_uint32_arg(env, "objectSize", objectSizeLong, &objectSize)) { 397 return nullptr; 398 } 399 400 MtpDevice* device = get_device_from_object(env, thiz); 401 if (!device) { 402 return nullptr; 403 } 404 405 ScopedLocalRef<jbyteArray> array(env, env->NewByteArray(objectSize)); 406 if (!array.get()) { 407 jniThrowException(env, "java/lang/OutOfMemoryError", NULL); 408 return nullptr; 409 } 410 411 JavaArrayWriter writer(env, array.get()); 412 413 if (device->readObject(objectID, JavaArrayWriter::writeTo, objectSize, &writer)) { 414 return array.release(); 415 } 416 return nullptr; 417} 418 419static jlong 420android_mtp_MtpDevice_get_partial_object(JNIEnv *env, 421 jobject thiz, 422 jint objectID, 423 jlong offsetLong, 424 jlong sizeLong, 425 jbyteArray array) 426{ 427 if (!array) { 428 jniThrowException(env, "java/lang/IllegalArgumentException", "Array must not be null."); 429 return -1; 430 } 431 432 uint32_t offset; 433 uint32_t size; 434 if (!check_uint32_arg(env, "offset", offsetLong, &offset) || 435 !check_uint32_arg(env, "size", sizeLong, &size)) { 436 return -1; 437 } 438 439 MtpDevice* const device = get_device_from_object(env, thiz); 440 if (!device) { 441 jniThrowException(env, "java/io/IOException", "Failed to obtain MtpDevice."); 442 return -1; 443 } 444 445 JavaArrayWriter writer(env, array); 446 uint32_t written_size; 447 const bool success = device->readPartialObject( 448 objectID, offset, size, &written_size, JavaArrayWriter::writeTo, &writer); 449 if (!success) { 450 jniThrowException(env, "java/io/IOException", "Failed to read data."); 451 return -1; 452 } 453 return static_cast<jlong>(written_size); 454} 455 456static jint 457android_mtp_MtpDevice_get_partial_object_64(JNIEnv *env, 458 jobject thiz, 459 jint objectID, 460 jlong offset, 461 jlong size, 462 jbyteArray array) { 463 if (!array) { 464 jniThrowException(env, "java/lang/IllegalArgumentException", "Array must not be null."); 465 return -1; 466 } 467 468 if (offset < 0) { 469 jniThrowException( 470 env, 471 "java/lang/IllegalArgumentException", 472 "Offset argument must not be a negative value."); 473 return -1; 474 } 475 476 if (size < 0 || 0xffffffffL < size) { 477 jniThrowException( 478 env, 479 "java/lang/IllegalArgumentException", 480 "Size argument must be a 32-bit unsigned integer."); 481 return -1; 482 } 483 484 MtpDevice* const device = get_device_from_object(env, thiz); 485 if (!device) { 486 jniThrowException(env, "java/io/IOException", "Failed to obtain MtpDevice."); 487 return -1; 488 } 489 490 const uint32_t native_object_handle = static_cast<uint32_t>(objectID); 491 const uint64_t native_offset = static_cast<uint64_t>(offset); 492 const uint32_t native_size = static_cast<uint32_t>(size); 493 494 JavaArrayWriter writer(env, array); 495 uint32_t written_size; 496 const bool success = device->readPartialObject64( 497 native_object_handle, 498 native_offset, 499 native_size, 500 &written_size, 501 JavaArrayWriter::writeTo, 502 &writer); 503 if (!success) { 504 jniThrowException(env, "java/io/IOException", "Failed to read data."); 505 return -1; 506 } 507 return static_cast<jint>(written_size); 508} 509 510static jbyteArray 511android_mtp_MtpDevice_get_thumbnail(JNIEnv *env, jobject thiz, jint objectID) 512{ 513 MtpDevice* device = get_device_from_object(env, thiz); 514 if (!device) 515 return NULL; 516 517 int length; 518 void* thumbnail = device->getThumbnail(objectID, length); 519 if (! thumbnail) 520 return NULL; 521 jbyteArray array = env->NewByteArray(length); 522 env->SetByteArrayRegion(array, 0, length, (const jbyte *)thumbnail); 523 524 free(thumbnail); 525 return array; 526} 527 528static jboolean 529android_mtp_MtpDevice_delete_object(JNIEnv *env, jobject thiz, jint object_id) 530{ 531 MtpDevice* device = get_device_from_object(env, thiz); 532 if (device && device->deleteObject(object_id)) { 533 return JNI_TRUE; 534 } else { 535 return JNI_FALSE; 536 } 537} 538 539static jint 540android_mtp_MtpDevice_get_parent(JNIEnv *env, jobject thiz, jint object_id) 541{ 542 MtpDevice* device = get_device_from_object(env, thiz); 543 if (device) 544 return static_cast<jint>(device->getParent(object_id)); 545 else 546 return -1; 547} 548 549static jint 550android_mtp_MtpDevice_get_storage_id(JNIEnv *env, jobject thiz, jint object_id) 551{ 552 MtpDevice* device = get_device_from_object(env, thiz); 553 if (device) 554 return static_cast<jint>(device->getStorageID(object_id)); 555 else 556 return -1; 557} 558 559static jboolean 560android_mtp_MtpDevice_import_file(JNIEnv *env, jobject thiz, jint object_id, jstring dest_path) 561{ 562 MtpDevice* device = get_device_from_object(env, thiz); 563 if (device) { 564 const char *destPathStr = env->GetStringUTFChars(dest_path, NULL); 565 if (destPathStr == NULL) { 566 return JNI_FALSE; 567 } 568 569 jboolean result = device->readObject(object_id, destPathStr, AID_SDCARD_RW, 0664); 570 env->ReleaseStringUTFChars(dest_path, destPathStr); 571 return result; 572 } 573 574 return JNI_FALSE; 575} 576 577static jboolean 578android_mtp_MtpDevice_import_file_to_fd(JNIEnv *env, jobject thiz, jint object_id, jint fd) 579{ 580 MtpDevice* device = get_device_from_object(env, thiz); 581 if (device) 582 return device->readObject(object_id, fd); 583 else 584 return JNI_FALSE; 585} 586 587static jboolean 588android_mtp_MtpDevice_send_object( 589 JNIEnv *env, jobject thiz, jint object_id, jlong sizeLong, jint fd) 590{ 591 uint32_t size; 592 if (!check_uint32_arg(env, "size", sizeLong, &size)) 593 return JNI_FALSE; 594 595 MtpDevice* device = get_device_from_object(env, thiz); 596 if (!device) 597 return JNI_FALSE; 598 599 return device->sendObject(object_id, size, fd); 600} 601 602static jobject 603android_mtp_MtpDevice_send_object_info(JNIEnv *env, jobject thiz, jobject info) 604{ 605 MtpDevice* device = get_device_from_object(env, thiz); 606 if (!device) { 607 return NULL; 608 } 609 610 // Updating existing objects is not supported. 611 if (env->GetIntField(info, field_objectInfo_handle) != -1) { 612 return NULL; 613 } 614 615 MtpObjectInfo* object_info = new MtpObjectInfo(-1); 616 object_info->mStorageID = env->GetIntField(info, field_objectInfo_storageId); 617 object_info->mFormat = env->GetIntField(info, field_objectInfo_format); 618 object_info->mProtectionStatus = env->GetIntField(info, field_objectInfo_protectionStatus); 619 object_info->mCompressedSize = env->GetIntField(info, field_objectInfo_compressedSize); 620 object_info->mThumbFormat = env->GetIntField(info, field_objectInfo_thumbFormat); 621 object_info->mThumbCompressedSize = 622 env->GetIntField(info, field_objectInfo_thumbCompressedSize); 623 object_info->mThumbPixWidth = env->GetIntField(info, field_objectInfo_thumbPixWidth); 624 object_info->mThumbPixHeight = env->GetIntField(info, field_objectInfo_thumbPixHeight); 625 object_info->mImagePixWidth = env->GetIntField(info, field_objectInfo_imagePixWidth); 626 object_info->mImagePixHeight = env->GetIntField(info, field_objectInfo_imagePixHeight); 627 object_info->mImagePixDepth = env->GetIntField(info, field_objectInfo_imagePixDepth); 628 object_info->mParent = env->GetIntField(info, field_objectInfo_parent); 629 object_info->mAssociationType = env->GetIntField(info, field_objectInfo_associationType); 630 object_info->mAssociationDesc = env->GetIntField(info, field_objectInfo_associationDesc); 631 object_info->mSequenceNumber = env->GetIntField(info, field_objectInfo_sequenceNumber); 632 633 jstring name_jstring = (jstring) env->GetObjectField(info, field_objectInfo_name); 634 if (name_jstring != NULL) { 635 const char* name_string = env->GetStringUTFChars(name_jstring, NULL); 636 object_info->mName = strdup(name_string); 637 env->ReleaseStringUTFChars(name_jstring, name_string); 638 } 639 640 object_info->mDateCreated = env->GetLongField(info, field_objectInfo_dateCreated) / 1000LL; 641 object_info->mDateModified = env->GetLongField(info, field_objectInfo_dateModified) / 1000LL; 642 643 jstring keywords_jstring = (jstring) env->GetObjectField(info, field_objectInfo_keywords); 644 if (keywords_jstring != NULL) { 645 const char* keywords_string = env->GetStringUTFChars(keywords_jstring, NULL); 646 object_info->mKeywords = strdup(keywords_string); 647 env->ReleaseStringUTFChars(keywords_jstring, keywords_string); 648 } 649 650 int object_handle = device->sendObjectInfo(object_info); 651 if (object_handle == -1) { 652 delete object_info; 653 return NULL; 654 } 655 656 object_info->mHandle = object_handle; 657 jobject result = env->NewObject(clazz_objectInfo, constructor_objectInfo); 658 if (result == NULL) { 659 ALOGE("Could not create a MtpObjectInfo object"); 660 delete object_info; 661 return NULL; 662 } 663 664 fill_jobject_from_object_info(env, result, object_info); 665 delete object_info; 666 return result; 667} 668 669static jint android_mtp_MtpDevice_submit_event_request(JNIEnv *env, jobject thiz) 670{ 671 MtpDevice* const device = get_device_from_object(env, thiz); 672 if (!device) { 673 env->ThrowNew(clazz_io_exception, ""); 674 return -1; 675 } 676 return device->submitEventRequest(); 677} 678 679static jobject android_mtp_MtpDevice_reap_event_request(JNIEnv *env, jobject thiz, jint seq) 680{ 681 MtpDevice* const device = get_device_from_object(env, thiz); 682 if (!device) { 683 env->ThrowNew(clazz_io_exception, ""); 684 return NULL; 685 } 686 uint32_t parameters[3]; 687 const int eventCode = device->reapEventRequest(seq, ¶meters); 688 if (eventCode <= 0) { 689 env->ThrowNew(clazz_operation_canceled_exception, ""); 690 return NULL; 691 } 692 jobject result = env->NewObject(clazz_event, constructor_event); 693 env->SetIntField(result, field_event_eventCode, eventCode); 694 env->SetIntField(result, field_event_parameter1, static_cast<jint>(parameters[0])); 695 env->SetIntField(result, field_event_parameter2, static_cast<jint>(parameters[1])); 696 env->SetIntField(result, field_event_parameter3, static_cast<jint>(parameters[2])); 697 return result; 698} 699 700static void android_mtp_MtpDevice_discard_event_request(JNIEnv *env, jobject thiz, jint seq) 701{ 702 MtpDevice* const device = get_device_from_object(env, thiz); 703 if (!device) { 704 return; 705 } 706 device->discardEventRequest(seq); 707} 708 709// Returns object size in 64-bit integer. If the MTP device does not support the property, it 710// throws IOException. 711static jlong android_mtp_MtpDevice_get_object_size_long( 712 JNIEnv *env, jobject thiz, jint handle, jint format) { 713 MtpDevice* const device = get_device_from_object(env, thiz); 714 if (!device) { 715 env->ThrowNew(clazz_io_exception, "Failed to obtain MtpDevice."); 716 return 0; 717 } 718 719 std::unique_ptr<MtpProperty> property( 720 device->getObjectPropDesc(MTP_PROPERTY_OBJECT_SIZE, format)); 721 if (!property) { 722 env->ThrowNew(clazz_io_exception, "Failed to obtain property desc."); 723 return 0; 724 } 725 726 if (property->getDataType() != MTP_TYPE_UINT64) { 727 env->ThrowNew(clazz_io_exception, "Unexpected property data type."); 728 return 0; 729 } 730 731 if (!device->getObjectPropValue(handle, property.get())) { 732 env->ThrowNew(clazz_io_exception, "Failed to obtain property value."); 733 return 0; 734 } 735 736 const jlong object_size = static_cast<jlong>(property->getCurrentValue().u.u64); 737 if (object_size < 0) { 738 env->ThrowNew(clazz_io_exception, "Object size is too large to express as jlong."); 739 return 0; 740 } 741 742 return object_size; 743} 744 745// ---------------------------------------------------------------------------- 746 747static const JNINativeMethod gMethods[] = { 748 {"native_open", "(Ljava/lang/String;I)Z", 749 (void *)android_mtp_MtpDevice_open}, 750 {"native_close", "()V", (void *)android_mtp_MtpDevice_close}, 751 {"native_get_device_info", "()Landroid/mtp/MtpDeviceInfo;", 752 (void *)android_mtp_MtpDevice_get_device_info}, 753 {"native_get_storage_ids", "()[I", (void *)android_mtp_MtpDevice_get_storage_ids}, 754 {"native_get_storage_info", "(I)Landroid/mtp/MtpStorageInfo;", 755 (void *)android_mtp_MtpDevice_get_storage_info}, 756 {"native_get_object_handles","(III)[I", 757 (void *)android_mtp_MtpDevice_get_object_handles}, 758 {"native_get_object_info", "(I)Landroid/mtp/MtpObjectInfo;", 759 (void *)android_mtp_MtpDevice_get_object_info}, 760 {"native_get_object", "(IJ)[B",(void *)android_mtp_MtpDevice_get_object}, 761 {"native_get_partial_object", "(IJJ[B)J", (void *)android_mtp_MtpDevice_get_partial_object}, 762 {"native_get_partial_object_64", "(IJJ[B)I", 763 (void *)android_mtp_MtpDevice_get_partial_object_64}, 764 {"native_get_thumbnail", "(I)[B",(void *)android_mtp_MtpDevice_get_thumbnail}, 765 {"native_delete_object", "(I)Z", (void *)android_mtp_MtpDevice_delete_object}, 766 {"native_get_parent", "(I)I", (void *)android_mtp_MtpDevice_get_parent}, 767 {"native_get_storage_id", "(I)I", (void *)android_mtp_MtpDevice_get_storage_id}, 768 {"native_import_file", "(ILjava/lang/String;)Z", 769 (void *)android_mtp_MtpDevice_import_file}, 770 {"native_import_file", "(II)Z",(void *)android_mtp_MtpDevice_import_file_to_fd}, 771 {"native_send_object", "(IJI)Z",(void *)android_mtp_MtpDevice_send_object}, 772 {"native_send_object_info", "(Landroid/mtp/MtpObjectInfo;)Landroid/mtp/MtpObjectInfo;", 773 (void *)android_mtp_MtpDevice_send_object_info}, 774 {"native_submit_event_request", "()I", (void *)android_mtp_MtpDevice_submit_event_request}, 775 {"native_reap_event_request", "(I)Landroid/mtp/MtpEvent;", 776 (void *)android_mtp_MtpDevice_reap_event_request}, 777 {"native_discard_event_request", "(I)V", (void *)android_mtp_MtpDevice_discard_event_request}, 778 779 {"native_get_object_size_long", "(II)J", (void *)android_mtp_MtpDevice_get_object_size_long}, 780}; 781 782int register_android_mtp_MtpDevice(JNIEnv *env) 783{ 784 jclass clazz; 785 786 ALOGD("register_android_mtp_MtpDevice\n"); 787 788 clazz = env->FindClass("android/mtp/MtpDeviceInfo"); 789 if (clazz == NULL) { 790 ALOGE("Can't find android/mtp/MtpDeviceInfo"); 791 return -1; 792 } 793 constructor_deviceInfo = env->GetMethodID(clazz, "<init>", "()V"); 794 if (constructor_deviceInfo == NULL) { 795 ALOGE("Can't find android/mtp/MtpDeviceInfo constructor"); 796 return -1; 797 } 798 field_deviceInfo_manufacturer = env->GetFieldID(clazz, "mManufacturer", "Ljava/lang/String;"); 799 if (field_deviceInfo_manufacturer == NULL) { 800 ALOGE("Can't find MtpDeviceInfo.mManufacturer"); 801 return -1; 802 } 803 field_deviceInfo_model = env->GetFieldID(clazz, "mModel", "Ljava/lang/String;"); 804 if (field_deviceInfo_model == NULL) { 805 ALOGE("Can't find MtpDeviceInfo.mModel"); 806 return -1; 807 } 808 field_deviceInfo_version = env->GetFieldID(clazz, "mVersion", "Ljava/lang/String;"); 809 if (field_deviceInfo_version == NULL) { 810 ALOGE("Can't find MtpDeviceInfo.mVersion"); 811 return -1; 812 } 813 field_deviceInfo_serialNumber = env->GetFieldID(clazz, "mSerialNumber", "Ljava/lang/String;"); 814 if (field_deviceInfo_serialNumber == NULL) { 815 ALOGE("Can't find MtpDeviceInfo.mSerialNumber"); 816 return -1; 817 } 818 field_deviceInfo_operationsSupported = env->GetFieldID(clazz, "mOperationsSupported", "[I"); 819 if (field_deviceInfo_operationsSupported == NULL) { 820 ALOGE("Can't find MtpDeviceInfo.mOperationsSupported"); 821 return -1; 822 } 823 field_deviceInfo_eventsSupported = env->GetFieldID(clazz, "mEventsSupported", "[I"); 824 if (field_deviceInfo_eventsSupported == NULL) { 825 ALOGE("Can't find MtpDeviceInfo.mEventsSupported"); 826 return -1; 827 } 828 clazz_deviceInfo = (jclass)env->NewGlobalRef(clazz); 829 830 clazz = env->FindClass("android/mtp/MtpStorageInfo"); 831 if (clazz == NULL) { 832 ALOGE("Can't find android/mtp/MtpStorageInfo"); 833 return -1; 834 } 835 constructor_storageInfo = env->GetMethodID(clazz, "<init>", "()V"); 836 if (constructor_storageInfo == NULL) { 837 ALOGE("Can't find android/mtp/MtpStorageInfo constructor"); 838 return -1; 839 } 840 field_storageInfo_storageId = env->GetFieldID(clazz, "mStorageId", "I"); 841 if (field_storageInfo_storageId == NULL) { 842 ALOGE("Can't find MtpStorageInfo.mStorageId"); 843 return -1; 844 } 845 field_storageInfo_maxCapacity = env->GetFieldID(clazz, "mMaxCapacity", "J"); 846 if (field_storageInfo_maxCapacity == NULL) { 847 ALOGE("Can't find MtpStorageInfo.mMaxCapacity"); 848 return -1; 849 } 850 field_storageInfo_freeSpace = env->GetFieldID(clazz, "mFreeSpace", "J"); 851 if (field_storageInfo_freeSpace == NULL) { 852 ALOGE("Can't find MtpStorageInfo.mFreeSpace"); 853 return -1; 854 } 855 field_storageInfo_description = env->GetFieldID(clazz, "mDescription", "Ljava/lang/String;"); 856 if (field_storageInfo_description == NULL) { 857 ALOGE("Can't find MtpStorageInfo.mDescription"); 858 return -1; 859 } 860 field_storageInfo_volumeIdentifier = env->GetFieldID(clazz, "mVolumeIdentifier", "Ljava/lang/String;"); 861 if (field_storageInfo_volumeIdentifier == NULL) { 862 ALOGE("Can't find MtpStorageInfo.mVolumeIdentifier"); 863 return -1; 864 } 865 clazz_storageInfo = (jclass)env->NewGlobalRef(clazz); 866 867 clazz = env->FindClass("android/mtp/MtpObjectInfo"); 868 if (clazz == NULL) { 869 ALOGE("Can't find android/mtp/MtpObjectInfo"); 870 return -1; 871 } 872 constructor_objectInfo = env->GetMethodID(clazz, "<init>", "()V"); 873 if (constructor_objectInfo == NULL) { 874 ALOGE("Can't find android/mtp/MtpObjectInfo constructor"); 875 return -1; 876 } 877 field_objectInfo_handle = env->GetFieldID(clazz, "mHandle", "I"); 878 if (field_objectInfo_handle == NULL) { 879 ALOGE("Can't find MtpObjectInfo.mHandle"); 880 return -1; 881 } 882 field_objectInfo_storageId = env->GetFieldID(clazz, "mStorageId", "I"); 883 if (field_objectInfo_storageId == NULL) { 884 ALOGE("Can't find MtpObjectInfo.mStorageId"); 885 return -1; 886 } 887 field_objectInfo_format = env->GetFieldID(clazz, "mFormat", "I"); 888 if (field_objectInfo_format == NULL) { 889 ALOGE("Can't find MtpObjectInfo.mFormat"); 890 return -1; 891 } 892 field_objectInfo_protectionStatus = env->GetFieldID(clazz, "mProtectionStatus", "I"); 893 if (field_objectInfo_protectionStatus == NULL) { 894 ALOGE("Can't find MtpObjectInfo.mProtectionStatus"); 895 return -1; 896 } 897 field_objectInfo_compressedSize = env->GetFieldID(clazz, "mCompressedSize", "I"); 898 if (field_objectInfo_compressedSize == NULL) { 899 ALOGE("Can't find MtpObjectInfo.mCompressedSize"); 900 return -1; 901 } 902 field_objectInfo_thumbFormat = env->GetFieldID(clazz, "mThumbFormat", "I"); 903 if (field_objectInfo_thumbFormat == NULL) { 904 ALOGE("Can't find MtpObjectInfo.mThumbFormat"); 905 return -1; 906 } 907 field_objectInfo_thumbCompressedSize = env->GetFieldID(clazz, "mThumbCompressedSize", "I"); 908 if (field_objectInfo_thumbCompressedSize == NULL) { 909 ALOGE("Can't find MtpObjectInfo.mThumbCompressedSize"); 910 return -1; 911 } 912 field_objectInfo_thumbPixWidth = env->GetFieldID(clazz, "mThumbPixWidth", "I"); 913 if (field_objectInfo_thumbPixWidth == NULL) { 914 ALOGE("Can't find MtpObjectInfo.mThumbPixWidth"); 915 return -1; 916 } 917 field_objectInfo_thumbPixHeight = env->GetFieldID(clazz, "mThumbPixHeight", "I"); 918 if (field_objectInfo_thumbPixHeight == NULL) { 919 ALOGE("Can't find MtpObjectInfo.mThumbPixHeight"); 920 return -1; 921 } 922 field_objectInfo_imagePixWidth = env->GetFieldID(clazz, "mImagePixWidth", "I"); 923 if (field_objectInfo_imagePixWidth == NULL) { 924 ALOGE("Can't find MtpObjectInfo.mImagePixWidth"); 925 return -1; 926 } 927 field_objectInfo_imagePixHeight = env->GetFieldID(clazz, "mImagePixHeight", "I"); 928 if (field_objectInfo_imagePixHeight == NULL) { 929 ALOGE("Can't find MtpObjectInfo.mImagePixHeight"); 930 return -1; 931 } 932 field_objectInfo_imagePixDepth = env->GetFieldID(clazz, "mImagePixDepth", "I"); 933 if (field_objectInfo_imagePixDepth == NULL) { 934 ALOGE("Can't find MtpObjectInfo.mImagePixDepth"); 935 return -1; 936 } 937 field_objectInfo_parent = env->GetFieldID(clazz, "mParent", "I"); 938 if (field_objectInfo_parent == NULL) { 939 ALOGE("Can't find MtpObjectInfo.mParent"); 940 return -1; 941 } 942 field_objectInfo_associationType = env->GetFieldID(clazz, "mAssociationType", "I"); 943 if (field_objectInfo_associationType == NULL) { 944 ALOGE("Can't find MtpObjectInfo.mAssociationType"); 945 return -1; 946 } 947 field_objectInfo_associationDesc = env->GetFieldID(clazz, "mAssociationDesc", "I"); 948 if (field_objectInfo_associationDesc == NULL) { 949 ALOGE("Can't find MtpObjectInfo.mAssociationDesc"); 950 return -1; 951 } 952 field_objectInfo_sequenceNumber = env->GetFieldID(clazz, "mSequenceNumber", "I"); 953 if (field_objectInfo_sequenceNumber == NULL) { 954 ALOGE("Can't find MtpObjectInfo.mSequenceNumber"); 955 return -1; 956 } 957 field_objectInfo_name = env->GetFieldID(clazz, "mName", "Ljava/lang/String;"); 958 if (field_objectInfo_name == NULL) { 959 ALOGE("Can't find MtpObjectInfo.mName"); 960 return -1; 961 } 962 field_objectInfo_dateCreated = env->GetFieldID(clazz, "mDateCreated", "J"); 963 if (field_objectInfo_dateCreated == NULL) { 964 ALOGE("Can't find MtpObjectInfo.mDateCreated"); 965 return -1; 966 } 967 field_objectInfo_dateModified = env->GetFieldID(clazz, "mDateModified", "J"); 968 if (field_objectInfo_dateModified == NULL) { 969 ALOGE("Can't find MtpObjectInfo.mDateModified"); 970 return -1; 971 } 972 field_objectInfo_keywords = env->GetFieldID(clazz, "mKeywords", "Ljava/lang/String;"); 973 if (field_objectInfo_keywords == NULL) { 974 ALOGE("Can't find MtpObjectInfo.mKeywords"); 975 return -1; 976 } 977 clazz_objectInfo = (jclass)env->NewGlobalRef(clazz); 978 979 clazz = env->FindClass("android/mtp/MtpEvent"); 980 if (clazz == NULL) { 981 ALOGE("Can't find android/mtp/MtpEvent"); 982 return -1; 983 } 984 constructor_event = env->GetMethodID(clazz, "<init>", "()V"); 985 if (constructor_event == NULL) { 986 ALOGE("Can't find android/mtp/MtpEvent constructor"); 987 return -1; 988 } 989 field_event_eventCode = env->GetFieldID(clazz, "mEventCode", "I"); 990 if (field_event_eventCode == NULL) { 991 ALOGE("Can't find MtpObjectInfo.mEventCode"); 992 return -1; 993 } 994 field_event_parameter1 = env->GetFieldID(clazz, "mParameter1", "I"); 995 if (field_event_parameter1 == NULL) { 996 ALOGE("Can't find MtpObjectInfo.mParameter1"); 997 return -1; 998 } 999 field_event_parameter2 = env->GetFieldID(clazz, "mParameter2", "I"); 1000 if (field_event_parameter2 == NULL) { 1001 ALOGE("Can't find MtpObjectInfo.mParameter2"); 1002 return -1; 1003 } 1004 field_event_parameter3 = env->GetFieldID(clazz, "mParameter3", "I"); 1005 if (field_event_parameter3 == NULL) { 1006 ALOGE("Can't find MtpObjectInfo.mParameter3"); 1007 return -1; 1008 } 1009 clazz_event = (jclass)env->NewGlobalRef(clazz); 1010 1011 clazz = env->FindClass("android/mtp/MtpDevice"); 1012 if (clazz == NULL) { 1013 ALOGE("Can't find android/mtp/MtpDevice"); 1014 return -1; 1015 } 1016 field_context = env->GetFieldID(clazz, "mNativeContext", "J"); 1017 if (field_context == NULL) { 1018 ALOGE("Can't find MtpDevice.mNativeContext"); 1019 return -1; 1020 } 1021 clazz = env->FindClass("java/io/IOException"); 1022 if (clazz == NULL) { 1023 ALOGE("Can't find java.io.IOException"); 1024 return -1; 1025 } 1026 clazz_io_exception = (jclass)env->NewGlobalRef(clazz); 1027 clazz = env->FindClass("android/os/OperationCanceledException"); 1028 if (clazz == NULL) { 1029 ALOGE("Can't find android.os.OperationCanceledException"); 1030 return -1; 1031 } 1032 clazz_operation_canceled_exception = (jclass)env->NewGlobalRef(clazz); 1033 1034 return AndroidRuntime::registerNativeMethods(env, 1035 "android/mtp/MtpDevice", gMethods, NELEM(gMethods)); 1036} 1037