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