android_mtp_MtpDatabase.cpp revision 56c85244b9be0fc6f6c2baf5f9a53f2364d5ec5e
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_TAG "MtpDatabaseJNI" 18#include "utils/Log.h" 19 20#include <stdio.h> 21#include <assert.h> 22#include <limits.h> 23#include <unistd.h> 24#include <fcntl.h> 25 26#include "jni.h" 27#include "JNIHelp.h" 28#include "android_runtime/AndroidRuntime.h" 29#include "android_runtime/Log.h" 30 31#include "MtpDatabase.h" 32#include "MtpDataPacket.h" 33#include "MtpObjectInfo.h" 34#include "MtpProperty.h" 35#include "MtpStringBuffer.h" 36#include "MtpUtils.h" 37#include "mtp.h" 38 39extern "C" { 40#include "libexif/exif-content.h" 41#include "libexif/exif-data.h" 42#include "libexif/exif-tag.h" 43#include "libexif/exif-utils.h" 44} 45 46using namespace android; 47 48// ---------------------------------------------------------------------------- 49 50static jmethodID method_beginSendObject; 51static jmethodID method_endSendObject; 52static jmethodID method_getObjectList; 53static jmethodID method_getNumObjects; 54static jmethodID method_getSupportedPlaybackFormats; 55static jmethodID method_getSupportedCaptureFormats; 56static jmethodID method_getSupportedObjectProperties; 57static jmethodID method_getSupportedDeviceProperties; 58static jmethodID method_setObjectProperty; 59static jmethodID method_getDeviceProperty; 60static jmethodID method_setDeviceProperty; 61static jmethodID method_getObjectPropertyList; 62static jmethodID method_getObjectInfo; 63static jmethodID method_getObjectFilePath; 64static jmethodID method_deleteFile; 65static jmethodID method_getObjectReferences; 66static jmethodID method_setObjectReferences; 67static jmethodID method_sessionStarted; 68static jmethodID method_sessionEnded; 69 70static jfieldID field_context; 71static jfieldID field_batteryLevel; 72static jfieldID field_batteryScale; 73 74// MtpPropertyList fields 75static jfieldID field_mCount; 76static jfieldID field_mResult; 77static jfieldID field_mObjectHandles; 78static jfieldID field_mPropertyCodes; 79static jfieldID field_mDataTypes; 80static jfieldID field_mLongValues; 81static jfieldID field_mStringValues; 82 83 84MtpDatabase* getMtpDatabase(JNIEnv *env, jobject database) { 85 return (MtpDatabase *)env->GetLongField(database, field_context); 86} 87 88// ---------------------------------------------------------------------------- 89 90class MyMtpDatabase : public MtpDatabase { 91private: 92 jobject mDatabase; 93 jintArray mIntBuffer; 94 jlongArray mLongBuffer; 95 jcharArray mStringBuffer; 96 97public: 98 MyMtpDatabase(JNIEnv *env, jobject client); 99 virtual ~MyMtpDatabase(); 100 void cleanup(JNIEnv *env); 101 102 virtual MtpObjectHandle beginSendObject(const char* path, 103 MtpObjectFormat format, 104 MtpObjectHandle parent, 105 MtpStorageID storage, 106 uint64_t size, 107 time_t modified); 108 109 virtual void endSendObject(const char* path, 110 MtpObjectHandle handle, 111 MtpObjectFormat format, 112 bool succeeded); 113 114 virtual MtpObjectHandleList* getObjectList(MtpStorageID storageID, 115 MtpObjectFormat format, 116 MtpObjectHandle parent); 117 118 virtual int getNumObjects(MtpStorageID storageID, 119 MtpObjectFormat format, 120 MtpObjectHandle parent); 121 122 // callee should delete[] the results from these 123 // results can be NULL 124 virtual MtpObjectFormatList* getSupportedPlaybackFormats(); 125 virtual MtpObjectFormatList* getSupportedCaptureFormats(); 126 virtual MtpObjectPropertyList* getSupportedObjectProperties(MtpObjectFormat format); 127 virtual MtpDevicePropertyList* getSupportedDeviceProperties(); 128 129 virtual MtpResponseCode getObjectPropertyValue(MtpObjectHandle handle, 130 MtpObjectProperty property, 131 MtpDataPacket& packet); 132 133 virtual MtpResponseCode setObjectPropertyValue(MtpObjectHandle handle, 134 MtpObjectProperty property, 135 MtpDataPacket& packet); 136 137 virtual MtpResponseCode getDevicePropertyValue(MtpDeviceProperty property, 138 MtpDataPacket& packet); 139 140 virtual MtpResponseCode setDevicePropertyValue(MtpDeviceProperty property, 141 MtpDataPacket& packet); 142 143 virtual MtpResponseCode resetDeviceProperty(MtpDeviceProperty property); 144 145 virtual MtpResponseCode getObjectPropertyList(MtpObjectHandle handle, 146 uint32_t format, uint32_t property, 147 int groupCode, int depth, 148 MtpDataPacket& packet); 149 150 virtual MtpResponseCode getObjectInfo(MtpObjectHandle handle, 151 MtpObjectInfo& info); 152 153 virtual void* getThumbnail(MtpObjectHandle handle, size_t& outThumbSize); 154 155 virtual MtpResponseCode getObjectFilePath(MtpObjectHandle handle, 156 MtpString& outFilePath, 157 int64_t& outFileLength, 158 MtpObjectFormat& outFormat); 159 virtual MtpResponseCode deleteFile(MtpObjectHandle handle); 160 161 bool getObjectPropertyInfo(MtpObjectProperty property, int& type); 162 bool getDevicePropertyInfo(MtpDeviceProperty property, int& type); 163 164 virtual MtpObjectHandleList* getObjectReferences(MtpObjectHandle handle); 165 166 virtual MtpResponseCode setObjectReferences(MtpObjectHandle handle, 167 MtpObjectHandleList* references); 168 169 virtual MtpProperty* getObjectPropertyDesc(MtpObjectProperty property, 170 MtpObjectFormat format); 171 172 virtual MtpProperty* getDevicePropertyDesc(MtpDeviceProperty property); 173 174 virtual void sessionStarted(); 175 176 virtual void sessionEnded(); 177}; 178 179// ---------------------------------------------------------------------------- 180 181static void checkAndClearExceptionFromCallback(JNIEnv* env, const char* methodName) { 182 if (env->ExceptionCheck()) { 183 ALOGE("An exception was thrown by callback '%s'.", methodName); 184 LOGE_EX(env); 185 env->ExceptionClear(); 186 } 187} 188 189// ---------------------------------------------------------------------------- 190 191MyMtpDatabase::MyMtpDatabase(JNIEnv *env, jobject client) 192 : mDatabase(env->NewGlobalRef(client)), 193 mIntBuffer(NULL), 194 mLongBuffer(NULL), 195 mStringBuffer(NULL) 196{ 197 // create buffers for out arguments 198 // we don't need to be thread-safe so this is OK 199 jintArray intArray = env->NewIntArray(3); 200 if (!intArray) { 201 return; // Already threw. 202 } 203 mIntBuffer = (jintArray)env->NewGlobalRef(intArray); 204 jlongArray longArray = env->NewLongArray(2); 205 if (!longArray) { 206 return; // Already threw. 207 } 208 mLongBuffer = (jlongArray)env->NewGlobalRef(longArray); 209 jcharArray charArray = env->NewCharArray(256); 210 if (!charArray) { 211 return; // Already threw. 212 } 213 mStringBuffer = (jcharArray)env->NewGlobalRef(charArray); 214} 215 216void MyMtpDatabase::cleanup(JNIEnv *env) { 217 env->DeleteGlobalRef(mDatabase); 218 env->DeleteGlobalRef(mIntBuffer); 219 env->DeleteGlobalRef(mLongBuffer); 220 env->DeleteGlobalRef(mStringBuffer); 221} 222 223MyMtpDatabase::~MyMtpDatabase() { 224} 225 226MtpObjectHandle MyMtpDatabase::beginSendObject(const char* path, 227 MtpObjectFormat format, 228 MtpObjectHandle parent, 229 MtpStorageID storage, 230 uint64_t size, 231 time_t modified) { 232 JNIEnv* env = AndroidRuntime::getJNIEnv(); 233 jstring pathStr = env->NewStringUTF(path); 234 MtpObjectHandle result = env->CallIntMethod(mDatabase, method_beginSendObject, 235 pathStr, (jint)format, (jint)parent, (jint)storage, 236 (jlong)size, (jlong)modified); 237 238 if (pathStr) 239 env->DeleteLocalRef(pathStr); 240 checkAndClearExceptionFromCallback(env, __FUNCTION__); 241 return result; 242} 243 244void MyMtpDatabase::endSendObject(const char* path, MtpObjectHandle handle, 245 MtpObjectFormat format, bool succeeded) { 246 JNIEnv* env = AndroidRuntime::getJNIEnv(); 247 jstring pathStr = env->NewStringUTF(path); 248 env->CallVoidMethod(mDatabase, method_endSendObject, pathStr, 249 (jint)handle, (jint)format, (jboolean)succeeded); 250 251 if (pathStr) 252 env->DeleteLocalRef(pathStr); 253 checkAndClearExceptionFromCallback(env, __FUNCTION__); 254} 255 256MtpObjectHandleList* MyMtpDatabase::getObjectList(MtpStorageID storageID, 257 MtpObjectFormat format, 258 MtpObjectHandle parent) { 259 JNIEnv* env = AndroidRuntime::getJNIEnv(); 260 jintArray array = (jintArray)env->CallObjectMethod(mDatabase, method_getObjectList, 261 (jint)storageID, (jint)format, (jint)parent); 262 if (!array) 263 return NULL; 264 MtpObjectHandleList* list = new MtpObjectHandleList(); 265 jint* handles = env->GetIntArrayElements(array, 0); 266 jsize length = env->GetArrayLength(array); 267 for (int i = 0; i < length; i++) 268 list->push(handles[i]); 269 env->ReleaseIntArrayElements(array, handles, 0); 270 env->DeleteLocalRef(array); 271 272 checkAndClearExceptionFromCallback(env, __FUNCTION__); 273 return list; 274} 275 276int MyMtpDatabase::getNumObjects(MtpStorageID storageID, 277 MtpObjectFormat format, 278 MtpObjectHandle parent) { 279 JNIEnv* env = AndroidRuntime::getJNIEnv(); 280 int result = env->CallIntMethod(mDatabase, method_getNumObjects, 281 (jint)storageID, (jint)format, (jint)parent); 282 283 checkAndClearExceptionFromCallback(env, __FUNCTION__); 284 return result; 285} 286 287MtpObjectFormatList* MyMtpDatabase::getSupportedPlaybackFormats() { 288 JNIEnv* env = AndroidRuntime::getJNIEnv(); 289 jintArray array = (jintArray)env->CallObjectMethod(mDatabase, 290 method_getSupportedPlaybackFormats); 291 if (!array) 292 return NULL; 293 MtpObjectFormatList* list = new MtpObjectFormatList(); 294 jint* formats = env->GetIntArrayElements(array, 0); 295 jsize length = env->GetArrayLength(array); 296 for (int i = 0; i < length; i++) 297 list->push(formats[i]); 298 env->ReleaseIntArrayElements(array, formats, 0); 299 env->DeleteLocalRef(array); 300 301 checkAndClearExceptionFromCallback(env, __FUNCTION__); 302 return list; 303} 304 305MtpObjectFormatList* MyMtpDatabase::getSupportedCaptureFormats() { 306 JNIEnv* env = AndroidRuntime::getJNIEnv(); 307 jintArray array = (jintArray)env->CallObjectMethod(mDatabase, 308 method_getSupportedCaptureFormats); 309 if (!array) 310 return NULL; 311 MtpObjectFormatList* list = new MtpObjectFormatList(); 312 jint* formats = env->GetIntArrayElements(array, 0); 313 jsize length = env->GetArrayLength(array); 314 for (int i = 0; i < length; i++) 315 list->push(formats[i]); 316 env->ReleaseIntArrayElements(array, formats, 0); 317 env->DeleteLocalRef(array); 318 319 checkAndClearExceptionFromCallback(env, __FUNCTION__); 320 return list; 321} 322 323MtpObjectPropertyList* MyMtpDatabase::getSupportedObjectProperties(MtpObjectFormat format) { 324 JNIEnv* env = AndroidRuntime::getJNIEnv(); 325 jintArray array = (jintArray)env->CallObjectMethod(mDatabase, 326 method_getSupportedObjectProperties, (jint)format); 327 if (!array) 328 return NULL; 329 MtpObjectPropertyList* list = new MtpObjectPropertyList(); 330 jint* properties = env->GetIntArrayElements(array, 0); 331 jsize length = env->GetArrayLength(array); 332 for (int i = 0; i < length; i++) 333 list->push(properties[i]); 334 env->ReleaseIntArrayElements(array, properties, 0); 335 env->DeleteLocalRef(array); 336 337 checkAndClearExceptionFromCallback(env, __FUNCTION__); 338 return list; 339} 340 341MtpDevicePropertyList* MyMtpDatabase::getSupportedDeviceProperties() { 342 JNIEnv* env = AndroidRuntime::getJNIEnv(); 343 jintArray array = (jintArray)env->CallObjectMethod(mDatabase, 344 method_getSupportedDeviceProperties); 345 if (!array) 346 return NULL; 347 MtpDevicePropertyList* list = new MtpDevicePropertyList(); 348 jint* properties = env->GetIntArrayElements(array, 0); 349 jsize length = env->GetArrayLength(array); 350 for (int i = 0; i < length; i++) 351 list->push(properties[i]); 352 env->ReleaseIntArrayElements(array, properties, 0); 353 env->DeleteLocalRef(array); 354 355 checkAndClearExceptionFromCallback(env, __FUNCTION__); 356 return list; 357} 358 359MtpResponseCode MyMtpDatabase::getObjectPropertyValue(MtpObjectHandle handle, 360 MtpObjectProperty property, 361 MtpDataPacket& packet) { 362 JNIEnv* env = AndroidRuntime::getJNIEnv(); 363 jobject list = env->CallObjectMethod(mDatabase, method_getObjectPropertyList, 364 (jlong)handle, 0, (jlong)property, 0, 0); 365 MtpResponseCode result = env->GetIntField(list, field_mResult); 366 int count = env->GetIntField(list, field_mCount); 367 if (result == MTP_RESPONSE_OK && count != 1) 368 result = MTP_RESPONSE_GENERAL_ERROR; 369 370 if (result == MTP_RESPONSE_OK) { 371 jintArray objectHandlesArray = (jintArray)env->GetObjectField(list, field_mObjectHandles); 372 jintArray propertyCodesArray = (jintArray)env->GetObjectField(list, field_mPropertyCodes); 373 jintArray dataTypesArray = (jintArray)env->GetObjectField(list, field_mDataTypes); 374 jlongArray longValuesArray = (jlongArray)env->GetObjectField(list, field_mLongValues); 375 jobjectArray stringValuesArray = (jobjectArray)env->GetObjectField(list, field_mStringValues); 376 377 jint* objectHandles = env->GetIntArrayElements(objectHandlesArray, 0); 378 jint* propertyCodes = env->GetIntArrayElements(propertyCodesArray, 0); 379 jint* dataTypes = env->GetIntArrayElements(dataTypesArray, 0); 380 jlong* longValues = (longValuesArray ? env->GetLongArrayElements(longValuesArray, 0) : NULL); 381 382 int type = dataTypes[0]; 383 jlong longValue = (longValues ? longValues[0] : 0); 384 385 // special case date properties, which are strings to MTP 386 // but stored internally as a uint64 387 if (property == MTP_PROPERTY_DATE_MODIFIED || property == MTP_PROPERTY_DATE_ADDED) { 388 char date[20]; 389 formatDateTime(longValue, date, sizeof(date)); 390 packet.putString(date); 391 goto out; 392 } 393 // release date is stored internally as just the year 394 if (property == MTP_PROPERTY_ORIGINAL_RELEASE_DATE) { 395 char date[20]; 396 snprintf(date, sizeof(date), "%04lld0101T000000", longValue); 397 packet.putString(date); 398 goto out; 399 } 400 401 switch (type) { 402 case MTP_TYPE_INT8: 403 packet.putInt8(longValue); 404 break; 405 case MTP_TYPE_UINT8: 406 packet.putUInt8(longValue); 407 break; 408 case MTP_TYPE_INT16: 409 packet.putInt16(longValue); 410 break; 411 case MTP_TYPE_UINT16: 412 packet.putUInt16(longValue); 413 break; 414 case MTP_TYPE_INT32: 415 packet.putInt32(longValue); 416 break; 417 case MTP_TYPE_UINT32: 418 packet.putUInt32(longValue); 419 break; 420 case MTP_TYPE_INT64: 421 packet.putInt64(longValue); 422 break; 423 case MTP_TYPE_UINT64: 424 packet.putUInt64(longValue); 425 break; 426 case MTP_TYPE_INT128: 427 packet.putInt128(longValue); 428 break; 429 case MTP_TYPE_UINT128: 430 packet.putInt128(longValue); 431 break; 432 case MTP_TYPE_STR: 433 { 434 jstring stringValue = (jstring)env->GetObjectArrayElement(stringValuesArray, 0); 435 if (stringValue) { 436 const char* str = env->GetStringUTFChars(stringValue, NULL); 437 if (str == NULL) { 438 return MTP_RESPONSE_GENERAL_ERROR; 439 } 440 packet.putString(str); 441 env->ReleaseStringUTFChars(stringValue, str); 442 } else { 443 packet.putEmptyString(); 444 } 445 break; 446 } 447 default: 448 ALOGE("unsupported type in getObjectPropertyValue\n"); 449 result = MTP_RESPONSE_INVALID_OBJECT_PROP_FORMAT; 450 } 451out: 452 env->ReleaseIntArrayElements(objectHandlesArray, objectHandles, 0); 453 env->ReleaseIntArrayElements(propertyCodesArray, propertyCodes, 0); 454 env->ReleaseIntArrayElements(dataTypesArray, dataTypes, 0); 455 if (longValues) 456 env->ReleaseLongArrayElements(longValuesArray, longValues, 0); 457 458 env->DeleteLocalRef(objectHandlesArray); 459 env->DeleteLocalRef(propertyCodesArray); 460 env->DeleteLocalRef(dataTypesArray); 461 if (longValuesArray) 462 env->DeleteLocalRef(longValuesArray); 463 if (stringValuesArray) 464 env->DeleteLocalRef(stringValuesArray); 465 } 466 467 env->DeleteLocalRef(list); 468 checkAndClearExceptionFromCallback(env, __FUNCTION__); 469 return result; 470} 471 472MtpResponseCode MyMtpDatabase::setObjectPropertyValue(MtpObjectHandle handle, 473 MtpObjectProperty property, 474 MtpDataPacket& packet) { 475 int type; 476 477 if (!getObjectPropertyInfo(property, type)) 478 return MTP_RESPONSE_OBJECT_PROP_NOT_SUPPORTED; 479 480 JNIEnv* env = AndroidRuntime::getJNIEnv(); 481 jlong longValue = 0; 482 jstring stringValue = NULL; 483 484 switch (type) { 485 case MTP_TYPE_INT8: 486 longValue = packet.getInt8(); 487 break; 488 case MTP_TYPE_UINT8: 489 longValue = packet.getUInt8(); 490 break; 491 case MTP_TYPE_INT16: 492 longValue = packet.getInt16(); 493 break; 494 case MTP_TYPE_UINT16: 495 longValue = packet.getUInt16(); 496 break; 497 case MTP_TYPE_INT32: 498 longValue = packet.getInt32(); 499 break; 500 case MTP_TYPE_UINT32: 501 longValue = packet.getUInt32(); 502 break; 503 case MTP_TYPE_INT64: 504 longValue = packet.getInt64(); 505 break; 506 case MTP_TYPE_UINT64: 507 longValue = packet.getUInt64(); 508 break; 509 case MTP_TYPE_STR: 510 { 511 MtpStringBuffer buffer; 512 packet.getString(buffer); 513 stringValue = env->NewStringUTF((const char *)buffer); 514 break; 515 } 516 default: 517 ALOGE("unsupported type in getObjectPropertyValue\n"); 518 return MTP_RESPONSE_INVALID_OBJECT_PROP_FORMAT; 519 } 520 521 jint result = env->CallIntMethod(mDatabase, method_setObjectProperty, 522 (jint)handle, (jint)property, longValue, stringValue); 523 if (stringValue) 524 env->DeleteLocalRef(stringValue); 525 526 checkAndClearExceptionFromCallback(env, __FUNCTION__); 527 return result; 528} 529 530MtpResponseCode MyMtpDatabase::getDevicePropertyValue(MtpDeviceProperty property, 531 MtpDataPacket& packet) { 532 JNIEnv* env = AndroidRuntime::getJNIEnv(); 533 534 if (property == MTP_DEVICE_PROPERTY_BATTERY_LEVEL) { 535 // special case - implemented here instead of Java 536 packet.putUInt8((uint8_t)env->GetIntField(mDatabase, field_batteryLevel)); 537 return MTP_RESPONSE_OK; 538 } else { 539 int type; 540 541 if (!getDevicePropertyInfo(property, type)) 542 return MTP_RESPONSE_DEVICE_PROP_NOT_SUPPORTED; 543 544 jint result = env->CallIntMethod(mDatabase, method_getDeviceProperty, 545 (jint)property, mLongBuffer, mStringBuffer); 546 if (result != MTP_RESPONSE_OK) { 547 checkAndClearExceptionFromCallback(env, __FUNCTION__); 548 return result; 549 } 550 551 jlong* longValues = env->GetLongArrayElements(mLongBuffer, 0); 552 jlong longValue = longValues[0]; 553 env->ReleaseLongArrayElements(mLongBuffer, longValues, 0); 554 555 switch (type) { 556 case MTP_TYPE_INT8: 557 packet.putInt8(longValue); 558 break; 559 case MTP_TYPE_UINT8: 560 packet.putUInt8(longValue); 561 break; 562 case MTP_TYPE_INT16: 563 packet.putInt16(longValue); 564 break; 565 case MTP_TYPE_UINT16: 566 packet.putUInt16(longValue); 567 break; 568 case MTP_TYPE_INT32: 569 packet.putInt32(longValue); 570 break; 571 case MTP_TYPE_UINT32: 572 packet.putUInt32(longValue); 573 break; 574 case MTP_TYPE_INT64: 575 packet.putInt64(longValue); 576 break; 577 case MTP_TYPE_UINT64: 578 packet.putUInt64(longValue); 579 break; 580 case MTP_TYPE_INT128: 581 packet.putInt128(longValue); 582 break; 583 case MTP_TYPE_UINT128: 584 packet.putInt128(longValue); 585 break; 586 case MTP_TYPE_STR: 587 { 588 jchar* str = env->GetCharArrayElements(mStringBuffer, 0); 589 packet.putString(str); 590 env->ReleaseCharArrayElements(mStringBuffer, str, 0); 591 break; 592 } 593 default: 594 ALOGE("unsupported type in getDevicePropertyValue\n"); 595 return MTP_RESPONSE_INVALID_DEVICE_PROP_FORMAT; 596 } 597 598 checkAndClearExceptionFromCallback(env, __FUNCTION__); 599 return MTP_RESPONSE_OK; 600 } 601} 602 603MtpResponseCode MyMtpDatabase::setDevicePropertyValue(MtpDeviceProperty property, 604 MtpDataPacket& packet) { 605 int type; 606 607 if (!getDevicePropertyInfo(property, type)) 608 return MTP_RESPONSE_DEVICE_PROP_NOT_SUPPORTED; 609 610 JNIEnv* env = AndroidRuntime::getJNIEnv(); 611 jlong longValue = 0; 612 jstring stringValue = NULL; 613 614 switch (type) { 615 case MTP_TYPE_INT8: 616 longValue = packet.getInt8(); 617 break; 618 case MTP_TYPE_UINT8: 619 longValue = packet.getUInt8(); 620 break; 621 case MTP_TYPE_INT16: 622 longValue = packet.getInt16(); 623 break; 624 case MTP_TYPE_UINT16: 625 longValue = packet.getUInt16(); 626 break; 627 case MTP_TYPE_INT32: 628 longValue = packet.getInt32(); 629 break; 630 case MTP_TYPE_UINT32: 631 longValue = packet.getUInt32(); 632 break; 633 case MTP_TYPE_INT64: 634 longValue = packet.getInt64(); 635 break; 636 case MTP_TYPE_UINT64: 637 longValue = packet.getUInt64(); 638 break; 639 case MTP_TYPE_STR: 640 { 641 MtpStringBuffer buffer; 642 packet.getString(buffer); 643 stringValue = env->NewStringUTF((const char *)buffer); 644 break; 645 } 646 default: 647 ALOGE("unsupported type in setDevicePropertyValue\n"); 648 return MTP_RESPONSE_INVALID_OBJECT_PROP_FORMAT; 649 } 650 651 jint result = env->CallIntMethod(mDatabase, method_setDeviceProperty, 652 (jint)property, longValue, stringValue); 653 if (stringValue) 654 env->DeleteLocalRef(stringValue); 655 656 checkAndClearExceptionFromCallback(env, __FUNCTION__); 657 return result; 658} 659 660MtpResponseCode MyMtpDatabase::resetDeviceProperty(MtpDeviceProperty property) { 661 return -1; 662} 663 664MtpResponseCode MyMtpDatabase::getObjectPropertyList(MtpObjectHandle handle, 665 uint32_t format, uint32_t property, 666 int groupCode, int depth, 667 MtpDataPacket& packet) { 668 JNIEnv* env = AndroidRuntime::getJNIEnv(); 669 jobject list = env->CallObjectMethod(mDatabase, method_getObjectPropertyList, 670 (jlong)handle, (jint)format, (jlong)property, (jint)groupCode, (jint)depth); 671 checkAndClearExceptionFromCallback(env, __FUNCTION__); 672 if (!list) 673 return MTP_RESPONSE_GENERAL_ERROR; 674 int count = env->GetIntField(list, field_mCount); 675 MtpResponseCode result = env->GetIntField(list, field_mResult); 676 677 packet.putUInt32(count); 678 if (count > 0) { 679 jintArray objectHandlesArray = (jintArray)env->GetObjectField(list, field_mObjectHandles); 680 jintArray propertyCodesArray = (jintArray)env->GetObjectField(list, field_mPropertyCodes); 681 jintArray dataTypesArray = (jintArray)env->GetObjectField(list, field_mDataTypes); 682 jlongArray longValuesArray = (jlongArray)env->GetObjectField(list, field_mLongValues); 683 jobjectArray stringValuesArray = (jobjectArray)env->GetObjectField(list, field_mStringValues); 684 685 jint* objectHandles = env->GetIntArrayElements(objectHandlesArray, 0); 686 jint* propertyCodes = env->GetIntArrayElements(propertyCodesArray, 0); 687 jint* dataTypes = env->GetIntArrayElements(dataTypesArray, 0); 688 jlong* longValues = (longValuesArray ? env->GetLongArrayElements(longValuesArray, 0) : NULL); 689 690 for (int i = 0; i < count; i++) { 691 packet.putUInt32(objectHandles[i]); 692 packet.putUInt16(propertyCodes[i]); 693 int type = dataTypes[i]; 694 packet.putUInt16(type); 695 696 switch (type) { 697 case MTP_TYPE_INT8: 698 packet.putInt8(longValues[i]); 699 break; 700 case MTP_TYPE_UINT8: 701 packet.putUInt8(longValues[i]); 702 break; 703 case MTP_TYPE_INT16: 704 packet.putInt16(longValues[i]); 705 break; 706 case MTP_TYPE_UINT16: 707 packet.putUInt16(longValues[i]); 708 break; 709 case MTP_TYPE_INT32: 710 packet.putInt32(longValues[i]); 711 break; 712 case MTP_TYPE_UINT32: 713 packet.putUInt32(longValues[i]); 714 break; 715 case MTP_TYPE_INT64: 716 packet.putInt64(longValues[i]); 717 break; 718 case MTP_TYPE_UINT64: 719 packet.putUInt64(longValues[i]); 720 break; 721 case MTP_TYPE_INT128: 722 packet.putInt128(longValues[i]); 723 break; 724 case MTP_TYPE_UINT128: 725 packet.putUInt128(longValues[i]); 726 break; 727 case MTP_TYPE_STR: { 728 jstring value = (jstring)env->GetObjectArrayElement(stringValuesArray, i); 729 const char *valueStr = (value ? env->GetStringUTFChars(value, NULL) : NULL); 730 if (valueStr) { 731 packet.putString(valueStr); 732 env->ReleaseStringUTFChars(value, valueStr); 733 } else { 734 packet.putEmptyString(); 735 } 736 env->DeleteLocalRef(value); 737 break; 738 } 739 default: 740 ALOGE("bad or unsupported data type in MyMtpDatabase::getObjectPropertyList"); 741 break; 742 } 743 } 744 745 env->ReleaseIntArrayElements(objectHandlesArray, objectHandles, 0); 746 env->ReleaseIntArrayElements(propertyCodesArray, propertyCodes, 0); 747 env->ReleaseIntArrayElements(dataTypesArray, dataTypes, 0); 748 if (longValues) 749 env->ReleaseLongArrayElements(longValuesArray, longValues, 0); 750 751 env->DeleteLocalRef(objectHandlesArray); 752 env->DeleteLocalRef(propertyCodesArray); 753 env->DeleteLocalRef(dataTypesArray); 754 if (longValuesArray) 755 env->DeleteLocalRef(longValuesArray); 756 if (stringValuesArray) 757 env->DeleteLocalRef(stringValuesArray); 758 } 759 760 env->DeleteLocalRef(list); 761 checkAndClearExceptionFromCallback(env, __FUNCTION__); 762 return result; 763} 764 765static void foreachentry(ExifEntry *entry, void *user) { 766 char buf[1024]; 767 ALOGI("entry %x, format %d, size %d: %s", 768 entry->tag, entry->format, entry->size, exif_entry_get_value(entry, buf, sizeof(buf))); 769} 770 771static void foreachcontent(ExifContent *content, void *user) { 772 ALOGI("content %d", exif_content_get_ifd(content)); 773 exif_content_foreach_entry(content, foreachentry, user); 774} 775 776static long getLongFromExifEntry(ExifEntry *e) { 777 ExifByteOrder o = exif_data_get_byte_order(e->parent->parent); 778 return exif_get_long(e->data, o); 779} 780 781MtpResponseCode MyMtpDatabase::getObjectInfo(MtpObjectHandle handle, 782 MtpObjectInfo& info) { 783 char date[20]; 784 MtpString path; 785 int64_t length; 786 MtpObjectFormat format; 787 788 MtpResponseCode result = getObjectFilePath(handle, path, length, format); 789 if (result != MTP_RESPONSE_OK) { 790 return result; 791 } 792 info.mCompressedSize = (length > 0xFFFFFFFFLL ? 0xFFFFFFFF : (uint32_t)length); 793 794 JNIEnv* env = AndroidRuntime::getJNIEnv(); 795 if (!env->CallBooleanMethod(mDatabase, method_getObjectInfo, 796 (jint)handle, mIntBuffer, mStringBuffer, mLongBuffer)) { 797 return MTP_RESPONSE_INVALID_OBJECT_HANDLE; 798 } 799 800 jint* intValues = env->GetIntArrayElements(mIntBuffer, 0); 801 info.mStorageID = intValues[0]; 802 info.mFormat = intValues[1]; 803 info.mParent = intValues[2]; 804 env->ReleaseIntArrayElements(mIntBuffer, intValues, 0); 805 806 jlong* longValues = env->GetLongArrayElements(mLongBuffer, 0); 807 info.mDateCreated = longValues[0]; 808 info.mDateModified = longValues[1]; 809 env->ReleaseLongArrayElements(mLongBuffer, longValues, 0); 810 811// info.mAssociationType = (format == MTP_FORMAT_ASSOCIATION ? 812// MTP_ASSOCIATION_TYPE_GENERIC_FOLDER : 813// MTP_ASSOCIATION_TYPE_UNDEFINED); 814 info.mAssociationType = MTP_ASSOCIATION_TYPE_UNDEFINED; 815 816 jchar* str = env->GetCharArrayElements(mStringBuffer, 0); 817 MtpString temp(str); 818 info.mName = strdup((const char *)temp); 819 env->ReleaseCharArrayElements(mStringBuffer, str, 0); 820 821 // read EXIF data for thumbnail information 822 if (info.mFormat == MTP_FORMAT_EXIF_JPEG || info.mFormat == MTP_FORMAT_JFIF) { 823 824 ExifData *exifdata = exif_data_new_from_file(path); 825 if (exifdata) { 826 //exif_data_foreach_content(exifdata, foreachcontent, NULL); 827 828 // XXX get this from exif, or parse jpeg header instead? 829 ExifEntry *w = exif_content_get_entry( 830 exifdata->ifd[EXIF_IFD_EXIF], EXIF_TAG_PIXEL_X_DIMENSION); 831 ExifEntry *h = exif_content_get_entry( 832 exifdata->ifd[EXIF_IFD_EXIF], EXIF_TAG_PIXEL_Y_DIMENSION); 833 info.mThumbCompressedSize = exifdata->data ? exifdata->size : 0; 834 info.mThumbFormat = MTP_FORMAT_EXIF_JPEG; 835 info.mImagePixWidth = w ? getLongFromExifEntry(w) : 0; 836 info.mImagePixHeight = h ? getLongFromExifEntry(h) : 0; 837 exif_data_unref(exifdata); 838 } 839 } 840 841 checkAndClearExceptionFromCallback(env, __FUNCTION__); 842 return MTP_RESPONSE_OK; 843} 844 845void* MyMtpDatabase::getThumbnail(MtpObjectHandle handle, size_t& outThumbSize) { 846 MtpString path; 847 int64_t length; 848 MtpObjectFormat format; 849 void* result = NULL; 850 outThumbSize = 0; 851 852 if (getObjectFilePath(handle, path, length, format) == MTP_RESPONSE_OK 853 && (format == MTP_FORMAT_EXIF_JPEG || format == MTP_FORMAT_JFIF)) { 854 855 ExifData *exifdata = exif_data_new_from_file(path); 856 if (exifdata) { 857 if (exifdata->data) { 858 result = malloc(exifdata->size); 859 if (result) { 860 memcpy(result, exifdata->data, exifdata->size); 861 } 862 } 863 exif_data_unref(exifdata); 864 } 865 } 866 867 return result; 868} 869 870MtpResponseCode MyMtpDatabase::getObjectFilePath(MtpObjectHandle handle, 871 MtpString& outFilePath, 872 int64_t& outFileLength, 873 MtpObjectFormat& outFormat) { 874 JNIEnv* env = AndroidRuntime::getJNIEnv(); 875 jint result = env->CallIntMethod(mDatabase, method_getObjectFilePath, 876 (jint)handle, mStringBuffer, mLongBuffer); 877 if (result != MTP_RESPONSE_OK) { 878 checkAndClearExceptionFromCallback(env, __FUNCTION__); 879 return result; 880 } 881 882 jchar* str = env->GetCharArrayElements(mStringBuffer, 0); 883 outFilePath.setTo(str, strlen16(str)); 884 env->ReleaseCharArrayElements(mStringBuffer, str, 0); 885 886 jlong* longValues = env->GetLongArrayElements(mLongBuffer, 0); 887 outFileLength = longValues[0]; 888 outFormat = longValues[1]; 889 env->ReleaseLongArrayElements(mLongBuffer, longValues, 0); 890 891 checkAndClearExceptionFromCallback(env, __FUNCTION__); 892 return result; 893} 894 895MtpResponseCode MyMtpDatabase::deleteFile(MtpObjectHandle handle) { 896 JNIEnv* env = AndroidRuntime::getJNIEnv(); 897 MtpResponseCode result = env->CallIntMethod(mDatabase, method_deleteFile, (jint)handle); 898 899 checkAndClearExceptionFromCallback(env, __FUNCTION__); 900 return result; 901} 902 903struct PropertyTableEntry { 904 MtpObjectProperty property; 905 int type; 906}; 907 908static const PropertyTableEntry kObjectPropertyTable[] = { 909 { MTP_PROPERTY_STORAGE_ID, MTP_TYPE_UINT32 }, 910 { MTP_PROPERTY_OBJECT_FORMAT, MTP_TYPE_UINT16 }, 911 { MTP_PROPERTY_PROTECTION_STATUS, MTP_TYPE_UINT16 }, 912 { MTP_PROPERTY_OBJECT_SIZE, MTP_TYPE_UINT64 }, 913 { MTP_PROPERTY_OBJECT_FILE_NAME, MTP_TYPE_STR }, 914 { MTP_PROPERTY_DATE_MODIFIED, MTP_TYPE_STR }, 915 { MTP_PROPERTY_PARENT_OBJECT, MTP_TYPE_UINT32 }, 916 { MTP_PROPERTY_PERSISTENT_UID, MTP_TYPE_UINT128 }, 917 { MTP_PROPERTY_NAME, MTP_TYPE_STR }, 918 { MTP_PROPERTY_DISPLAY_NAME, MTP_TYPE_STR }, 919 { MTP_PROPERTY_DATE_ADDED, MTP_TYPE_STR }, 920 { MTP_PROPERTY_ARTIST, MTP_TYPE_STR }, 921 { MTP_PROPERTY_ALBUM_NAME, MTP_TYPE_STR }, 922 { MTP_PROPERTY_ALBUM_ARTIST, MTP_TYPE_STR }, 923 { MTP_PROPERTY_TRACK, MTP_TYPE_UINT16 }, 924 { MTP_PROPERTY_ORIGINAL_RELEASE_DATE, MTP_TYPE_STR }, 925 { MTP_PROPERTY_GENRE, MTP_TYPE_STR }, 926 { MTP_PROPERTY_COMPOSER, MTP_TYPE_STR }, 927 { MTP_PROPERTY_DURATION, MTP_TYPE_UINT32 }, 928 { MTP_PROPERTY_DESCRIPTION, MTP_TYPE_STR }, 929}; 930 931static const PropertyTableEntry kDevicePropertyTable[] = { 932 { MTP_DEVICE_PROPERTY_SYNCHRONIZATION_PARTNER, MTP_TYPE_STR }, 933 { MTP_DEVICE_PROPERTY_DEVICE_FRIENDLY_NAME, MTP_TYPE_STR }, 934 { MTP_DEVICE_PROPERTY_IMAGE_SIZE, MTP_TYPE_STR }, 935 { MTP_DEVICE_PROPERTY_BATTERY_LEVEL, MTP_TYPE_UINT8 }, 936}; 937 938bool MyMtpDatabase::getObjectPropertyInfo(MtpObjectProperty property, int& type) { 939 int count = sizeof(kObjectPropertyTable) / sizeof(kObjectPropertyTable[0]); 940 const PropertyTableEntry* entry = kObjectPropertyTable; 941 for (int i = 0; i < count; i++, entry++) { 942 if (entry->property == property) { 943 type = entry->type; 944 return true; 945 } 946 } 947 return false; 948} 949 950bool MyMtpDatabase::getDevicePropertyInfo(MtpDeviceProperty property, int& type) { 951 int count = sizeof(kDevicePropertyTable) / sizeof(kDevicePropertyTable[0]); 952 const PropertyTableEntry* entry = kDevicePropertyTable; 953 for (int i = 0; i < count; i++, entry++) { 954 if (entry->property == property) { 955 type = entry->type; 956 return true; 957 } 958 } 959 return false; 960} 961 962MtpObjectHandleList* MyMtpDatabase::getObjectReferences(MtpObjectHandle handle) { 963 JNIEnv* env = AndroidRuntime::getJNIEnv(); 964 jintArray array = (jintArray)env->CallObjectMethod(mDatabase, method_getObjectReferences, 965 (jint)handle); 966 if (!array) 967 return NULL; 968 MtpObjectHandleList* list = new MtpObjectHandleList(); 969 jint* handles = env->GetIntArrayElements(array, 0); 970 jsize length = env->GetArrayLength(array); 971 for (int i = 0; i < length; i++) 972 list->push(handles[i]); 973 env->ReleaseIntArrayElements(array, handles, 0); 974 env->DeleteLocalRef(array); 975 976 checkAndClearExceptionFromCallback(env, __FUNCTION__); 977 return list; 978} 979 980MtpResponseCode MyMtpDatabase::setObjectReferences(MtpObjectHandle handle, 981 MtpObjectHandleList* references) { 982 JNIEnv* env = AndroidRuntime::getJNIEnv(); 983 int count = references->size(); 984 jintArray array = env->NewIntArray(count); 985 if (!array) { 986 ALOGE("out of memory in setObjectReferences"); 987 return false; 988 } 989 jint* handles = env->GetIntArrayElements(array, 0); 990 for (int i = 0; i < count; i++) 991 handles[i] = (*references)[i]; 992 env->ReleaseIntArrayElements(array, handles, 0); 993 MtpResponseCode result = env->CallIntMethod(mDatabase, method_setObjectReferences, 994 (jint)handle, array); 995 env->DeleteLocalRef(array); 996 997 checkAndClearExceptionFromCallback(env, __FUNCTION__); 998 return result; 999} 1000 1001MtpProperty* MyMtpDatabase::getObjectPropertyDesc(MtpObjectProperty property, 1002 MtpObjectFormat format) { 1003 MtpProperty* result = NULL; 1004 switch (property) { 1005 case MTP_PROPERTY_OBJECT_FORMAT: 1006 // use format as default value 1007 result = new MtpProperty(property, MTP_TYPE_UINT16, false, format); 1008 break; 1009 case MTP_PROPERTY_PROTECTION_STATUS: 1010 case MTP_PROPERTY_TRACK: 1011 result = new MtpProperty(property, MTP_TYPE_UINT16); 1012 break; 1013 case MTP_PROPERTY_STORAGE_ID: 1014 case MTP_PROPERTY_PARENT_OBJECT: 1015 case MTP_PROPERTY_DURATION: 1016 result = new MtpProperty(property, MTP_TYPE_UINT32); 1017 break; 1018 case MTP_PROPERTY_OBJECT_SIZE: 1019 result = new MtpProperty(property, MTP_TYPE_UINT64); 1020 break; 1021 case MTP_PROPERTY_PERSISTENT_UID: 1022 result = new MtpProperty(property, MTP_TYPE_UINT128); 1023 break; 1024 case MTP_PROPERTY_NAME: 1025 case MTP_PROPERTY_DISPLAY_NAME: 1026 case MTP_PROPERTY_ARTIST: 1027 case MTP_PROPERTY_ALBUM_NAME: 1028 case MTP_PROPERTY_ALBUM_ARTIST: 1029 case MTP_PROPERTY_GENRE: 1030 case MTP_PROPERTY_COMPOSER: 1031 case MTP_PROPERTY_DESCRIPTION: 1032 result = new MtpProperty(property, MTP_TYPE_STR); 1033 break; 1034 case MTP_PROPERTY_DATE_MODIFIED: 1035 case MTP_PROPERTY_DATE_ADDED: 1036 case MTP_PROPERTY_ORIGINAL_RELEASE_DATE: 1037 result = new MtpProperty(property, MTP_TYPE_STR); 1038 result->setFormDateTime(); 1039 break; 1040 case MTP_PROPERTY_OBJECT_FILE_NAME: 1041 // We allow renaming files and folders 1042 result = new MtpProperty(property, MTP_TYPE_STR, true); 1043 break; 1044 } 1045 1046 return result; 1047} 1048 1049MtpProperty* MyMtpDatabase::getDevicePropertyDesc(MtpDeviceProperty property) { 1050 JNIEnv* env = AndroidRuntime::getJNIEnv(); 1051 MtpProperty* result = NULL; 1052 bool writable = false; 1053 1054 switch (property) { 1055 case MTP_DEVICE_PROPERTY_SYNCHRONIZATION_PARTNER: 1056 case MTP_DEVICE_PROPERTY_DEVICE_FRIENDLY_NAME: 1057 writable = true; 1058 // fall through 1059 case MTP_DEVICE_PROPERTY_IMAGE_SIZE: { 1060 result = new MtpProperty(property, MTP_TYPE_STR, writable); 1061 1062 // get current value 1063 jint ret = env->CallIntMethod(mDatabase, method_getDeviceProperty, 1064 (jint)property, mLongBuffer, mStringBuffer); 1065 if (ret == MTP_RESPONSE_OK) { 1066 jchar* str = env->GetCharArrayElements(mStringBuffer, 0); 1067 result->setCurrentValue(str); 1068 // for read-only properties it is safe to assume current value is default value 1069 if (!writable) 1070 result->setDefaultValue(str); 1071 env->ReleaseCharArrayElements(mStringBuffer, str, 0); 1072 } else { 1073 ALOGE("unable to read device property, response: %04X", ret); 1074 } 1075 break; 1076 } 1077 case MTP_DEVICE_PROPERTY_BATTERY_LEVEL: 1078 result = new MtpProperty(property, MTP_TYPE_UINT8); 1079 result->setFormRange(0, env->GetIntField(mDatabase, field_batteryScale), 1); 1080 result->mCurrentValue.u.u8 = (uint8_t)env->GetIntField(mDatabase, field_batteryLevel); 1081 break; 1082 } 1083 1084 checkAndClearExceptionFromCallback(env, __FUNCTION__); 1085 return result; 1086} 1087 1088void MyMtpDatabase::sessionStarted() { 1089 JNIEnv* env = AndroidRuntime::getJNIEnv(); 1090 env->CallVoidMethod(mDatabase, method_sessionStarted); 1091 checkAndClearExceptionFromCallback(env, __FUNCTION__); 1092} 1093 1094void MyMtpDatabase::sessionEnded() { 1095 JNIEnv* env = AndroidRuntime::getJNIEnv(); 1096 env->CallVoidMethod(mDatabase, method_sessionEnded); 1097 checkAndClearExceptionFromCallback(env, __FUNCTION__); 1098} 1099 1100// ---------------------------------------------------------------------------- 1101 1102static void 1103android_mtp_MtpDatabase_setup(JNIEnv *env, jobject thiz) 1104{ 1105 MyMtpDatabase* database = new MyMtpDatabase(env, thiz); 1106 env->SetLongField(thiz, field_context, (jlong)database); 1107 checkAndClearExceptionFromCallback(env, __FUNCTION__); 1108} 1109 1110static void 1111android_mtp_MtpDatabase_finalize(JNIEnv *env, jobject thiz) 1112{ 1113 MyMtpDatabase* database = (MyMtpDatabase *)env->GetLongField(thiz, field_context); 1114 database->cleanup(env); 1115 delete database; 1116 env->SetLongField(thiz, field_context, 0); 1117 checkAndClearExceptionFromCallback(env, __FUNCTION__); 1118} 1119 1120static jstring 1121android_mtp_MtpPropertyGroup_format_date_time(JNIEnv *env, jobject thiz, jlong seconds) 1122{ 1123 char date[20]; 1124 formatDateTime(seconds, date, sizeof(date)); 1125 return env->NewStringUTF(date); 1126} 1127 1128// ---------------------------------------------------------------------------- 1129 1130static JNINativeMethod gMtpDatabaseMethods[] = { 1131 {"native_setup", "()V", (void *)android_mtp_MtpDatabase_setup}, 1132 {"native_finalize", "()V", (void *)android_mtp_MtpDatabase_finalize}, 1133}; 1134 1135static JNINativeMethod gMtpPropertyGroupMethods[] = { 1136 {"format_date_time", "(J)Ljava/lang/String;", 1137 (void *)android_mtp_MtpPropertyGroup_format_date_time}, 1138}; 1139 1140static const char* const kClassPathName = "android/mtp/MtpDatabase"; 1141 1142int register_android_mtp_MtpDatabase(JNIEnv *env) 1143{ 1144 jclass clazz; 1145 1146 clazz = env->FindClass("android/mtp/MtpDatabase"); 1147 if (clazz == NULL) { 1148 ALOGE("Can't find android/mtp/MtpDatabase"); 1149 return -1; 1150 } 1151 method_beginSendObject = env->GetMethodID(clazz, "beginSendObject", "(Ljava/lang/String;IIIJJ)I"); 1152 if (method_beginSendObject == NULL) { 1153 ALOGE("Can't find beginSendObject"); 1154 return -1; 1155 } 1156 method_endSendObject = env->GetMethodID(clazz, "endSendObject", "(Ljava/lang/String;IIZ)V"); 1157 if (method_endSendObject == NULL) { 1158 ALOGE("Can't find endSendObject"); 1159 return -1; 1160 } 1161 method_getObjectList = env->GetMethodID(clazz, "getObjectList", "(III)[I"); 1162 if (method_getObjectList == NULL) { 1163 ALOGE("Can't find getObjectList"); 1164 return -1; 1165 } 1166 method_getNumObjects = env->GetMethodID(clazz, "getNumObjects", "(III)I"); 1167 if (method_getNumObjects == NULL) { 1168 ALOGE("Can't find getNumObjects"); 1169 return -1; 1170 } 1171 method_getSupportedPlaybackFormats = env->GetMethodID(clazz, "getSupportedPlaybackFormats", "()[I"); 1172 if (method_getSupportedPlaybackFormats == NULL) { 1173 ALOGE("Can't find getSupportedPlaybackFormats"); 1174 return -1; 1175 } 1176 method_getSupportedCaptureFormats = env->GetMethodID(clazz, "getSupportedCaptureFormats", "()[I"); 1177 if (method_getSupportedCaptureFormats == NULL) { 1178 ALOGE("Can't find getSupportedCaptureFormats"); 1179 return -1; 1180 } 1181 method_getSupportedObjectProperties = env->GetMethodID(clazz, "getSupportedObjectProperties", "(I)[I"); 1182 if (method_getSupportedObjectProperties == NULL) { 1183 ALOGE("Can't find getSupportedObjectProperties"); 1184 return -1; 1185 } 1186 method_getSupportedDeviceProperties = env->GetMethodID(clazz, "getSupportedDeviceProperties", "()[I"); 1187 if (method_getSupportedDeviceProperties == NULL) { 1188 ALOGE("Can't find getSupportedDeviceProperties"); 1189 return -1; 1190 } 1191 method_setObjectProperty = env->GetMethodID(clazz, "setObjectProperty", "(IIJLjava/lang/String;)I"); 1192 if (method_setObjectProperty == NULL) { 1193 ALOGE("Can't find setObjectProperty"); 1194 return -1; 1195 } 1196 method_getDeviceProperty = env->GetMethodID(clazz, "getDeviceProperty", "(I[J[C)I"); 1197 if (method_getDeviceProperty == NULL) { 1198 ALOGE("Can't find getDeviceProperty"); 1199 return -1; 1200 } 1201 method_setDeviceProperty = env->GetMethodID(clazz, "setDeviceProperty", "(IJLjava/lang/String;)I"); 1202 if (method_setDeviceProperty == NULL) { 1203 ALOGE("Can't find setDeviceProperty"); 1204 return -1; 1205 } 1206 method_getObjectPropertyList = env->GetMethodID(clazz, "getObjectPropertyList", 1207 "(JIJII)Landroid/mtp/MtpPropertyList;"); 1208 if (method_getObjectPropertyList == NULL) { 1209 ALOGE("Can't find getObjectPropertyList"); 1210 return -1; 1211 } 1212 method_getObjectInfo = env->GetMethodID(clazz, "getObjectInfo", "(I[I[C[J)Z"); 1213 if (method_getObjectInfo == NULL) { 1214 ALOGE("Can't find getObjectInfo"); 1215 return -1; 1216 } 1217 method_getObjectFilePath = env->GetMethodID(clazz, "getObjectFilePath", "(I[C[J)I"); 1218 if (method_getObjectFilePath == NULL) { 1219 ALOGE("Can't find getObjectFilePath"); 1220 return -1; 1221 } 1222 method_deleteFile = env->GetMethodID(clazz, "deleteFile", "(I)I"); 1223 if (method_deleteFile == NULL) { 1224 ALOGE("Can't find deleteFile"); 1225 return -1; 1226 } 1227 method_getObjectReferences = env->GetMethodID(clazz, "getObjectReferences", "(I)[I"); 1228 if (method_getObjectReferences == NULL) { 1229 ALOGE("Can't find getObjectReferences"); 1230 return -1; 1231 } 1232 method_setObjectReferences = env->GetMethodID(clazz, "setObjectReferences", "(I[I)I"); 1233 if (method_setObjectReferences == NULL) { 1234 ALOGE("Can't find setObjectReferences"); 1235 return -1; 1236 } 1237 method_sessionStarted = env->GetMethodID(clazz, "sessionStarted", "()V"); 1238 if (method_sessionStarted == NULL) { 1239 ALOGE("Can't find sessionStarted"); 1240 return -1; 1241 } 1242 method_sessionEnded = env->GetMethodID(clazz, "sessionEnded", "()V"); 1243 if (method_sessionEnded == NULL) { 1244 ALOGE("Can't find sessionEnded"); 1245 return -1; 1246 } 1247 1248 field_context = env->GetFieldID(clazz, "mNativeContext", "J"); 1249 if (field_context == NULL) { 1250 ALOGE("Can't find MtpDatabase.mNativeContext"); 1251 return -1; 1252 } 1253 field_batteryLevel = env->GetFieldID(clazz, "mBatteryLevel", "I"); 1254 if (field_batteryLevel == NULL) { 1255 ALOGE("Can't find MtpDatabase.mBatteryLevel"); 1256 return -1; 1257 } 1258 field_batteryScale = env->GetFieldID(clazz, "mBatteryScale", "I"); 1259 if (field_batteryScale == NULL) { 1260 ALOGE("Can't find MtpDatabase.mBatteryScale"); 1261 return -1; 1262 } 1263 1264 // now set up fields for MtpPropertyList class 1265 clazz = env->FindClass("android/mtp/MtpPropertyList"); 1266 if (clazz == NULL) { 1267 ALOGE("Can't find android/mtp/MtpPropertyList"); 1268 return -1; 1269 } 1270 field_mCount = env->GetFieldID(clazz, "mCount", "I"); 1271 if (field_mCount == NULL) { 1272 ALOGE("Can't find MtpPropertyList.mCount"); 1273 return -1; 1274 } 1275 field_mResult = env->GetFieldID(clazz, "mResult", "I"); 1276 if (field_mResult == NULL) { 1277 ALOGE("Can't find MtpPropertyList.mResult"); 1278 return -1; 1279 } 1280 field_mObjectHandles = env->GetFieldID(clazz, "mObjectHandles", "[I"); 1281 if (field_mObjectHandles == NULL) { 1282 ALOGE("Can't find MtpPropertyList.mObjectHandles"); 1283 return -1; 1284 } 1285 field_mPropertyCodes = env->GetFieldID(clazz, "mPropertyCodes", "[I"); 1286 if (field_mPropertyCodes == NULL) { 1287 ALOGE("Can't find MtpPropertyList.mPropertyCodes"); 1288 return -1; 1289 } 1290 field_mDataTypes = env->GetFieldID(clazz, "mDataTypes", "[I"); 1291 if (field_mDataTypes == NULL) { 1292 ALOGE("Can't find MtpPropertyList.mDataTypes"); 1293 return -1; 1294 } 1295 field_mLongValues = env->GetFieldID(clazz, "mLongValues", "[J"); 1296 if (field_mLongValues == NULL) { 1297 ALOGE("Can't find MtpPropertyList.mLongValues"); 1298 return -1; 1299 } 1300 field_mStringValues = env->GetFieldID(clazz, "mStringValues", "[Ljava/lang/String;"); 1301 if (field_mStringValues == NULL) { 1302 ALOGE("Can't find MtpPropertyList.mStringValues"); 1303 return -1; 1304 } 1305 1306 if (AndroidRuntime::registerNativeMethods(env, 1307 "android/mtp/MtpDatabase", gMtpDatabaseMethods, NELEM(gMtpDatabaseMethods))) 1308 return -1; 1309 1310 return AndroidRuntime::registerNativeMethods(env, 1311 "android/mtp/MtpPropertyGroup", gMtpPropertyGroupMethods, NELEM(gMtpPropertyGroupMethods)); 1312} 1313