4f1a6d6f7d
Android Host is not capable to deal with the long processing time for runtime thumbnail generation. Skip runtime thumbnail generation for Android Host but keep no impact to other Host Bug: 188752500 Test: atest MtpTests Test: atest MtpServerTest Test: atest MtpServiceTests Test: manual test on Windows 10 File Explorer Test: manual test on Android Host Files App Change-Id: I24ed3bb29c5a6912398a9e00e7748fd406cf6a64
1386 lines
54 KiB
C++
1386 lines
54 KiB
C++
/*
|
|
* Copyright (C) 2010 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#define LOG_TAG "MtpDatabaseJNI"
|
|
#include "utils/Log.h"
|
|
#include "utils/String8.h"
|
|
|
|
#include "android_media_Streams.h"
|
|
#include "mtp.h"
|
|
#include "IMtpDatabase.h"
|
|
#include "MtpDataPacket.h"
|
|
#include "MtpObjectInfo.h"
|
|
#include "MtpProperty.h"
|
|
#include "MtpStringBuffer.h"
|
|
#include "MtpUtils.h"
|
|
|
|
#include "src/piex_types.h"
|
|
#include "src/piex.h"
|
|
|
|
#include <android_runtime/AndroidRuntime.h>
|
|
#include <android_runtime/Log.h>
|
|
#include "core_jni_helpers.h"
|
|
#include <jni.h>
|
|
#include <media/stagefright/NuMediaExtractor.h>
|
|
#include <nativehelper/JNIHelp.h>
|
|
#include <nativehelper/ScopedLocalRef.h>
|
|
|
|
#include <assert.h>
|
|
#include <fcntl.h>
|
|
#include <inttypes.h>
|
|
#include <limits.h>
|
|
#include <stdio.h>
|
|
#include <unistd.h>
|
|
|
|
using namespace android;
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// MtpDatabase methods
|
|
static jmethodID method_beginSendObject;
|
|
static jmethodID method_endSendObject;
|
|
static jmethodID method_rescanFile;
|
|
static jmethodID method_getObjectList;
|
|
static jmethodID method_getNumObjects;
|
|
static jmethodID method_getSupportedPlaybackFormats;
|
|
static jmethodID method_getSupportedCaptureFormats;
|
|
static jmethodID method_getSupportedObjectProperties;
|
|
static jmethodID method_getSupportedDeviceProperties;
|
|
static jmethodID method_setObjectProperty;
|
|
static jmethodID method_getDeviceProperty;
|
|
static jmethodID method_setDeviceProperty;
|
|
static jmethodID method_getObjectPropertyList;
|
|
static jmethodID method_getObjectInfo;
|
|
static jmethodID method_getObjectFilePath;
|
|
static jmethodID method_openFilePath;
|
|
static jmethodID method_getThumbnailInfo;
|
|
static jmethodID method_getThumbnailData;
|
|
static jmethodID method_beginDeleteObject;
|
|
static jmethodID method_endDeleteObject;
|
|
static jmethodID method_beginMoveObject;
|
|
static jmethodID method_endMoveObject;
|
|
static jmethodID method_beginCopyObject;
|
|
static jmethodID method_endCopyObject;
|
|
static jmethodID method_getObjectReferences;
|
|
static jmethodID method_setObjectReferences;
|
|
|
|
// MtpDatabase fields.
|
|
static jfieldID field_context;
|
|
|
|
// MtpPropertyList methods
|
|
static jmethodID method_getCode;
|
|
static jmethodID method_getCount;
|
|
static jmethodID method_getObjectHandles;
|
|
static jmethodID method_getPropertyCodes;
|
|
static jmethodID method_getDataTypes;
|
|
static jmethodID method_getLongValues;
|
|
static jmethodID method_getStringValues;
|
|
|
|
// Initializer for the jfieldIDs and jmethodIDs above. This method must be invoked
|
|
// before using these static fields and methods for JNI accesses.
|
|
static void initializeJavaIDs(JNIEnv* env) {
|
|
static std::once_flag sJniInitialized;
|
|
|
|
#define GET_METHOD_ID(name, jclass, signature) \
|
|
method_##name = GetMethodIDOrDie(env, jclass, #name, signature);
|
|
|
|
std::call_once(sJniInitialized, [](JNIEnv* env) {
|
|
const jclass mdb_class = FindClassOrDie(env, "android/mtp/MtpDatabase");
|
|
GET_METHOD_ID(beginSendObject, mdb_class, "(Ljava/lang/String;III)I");
|
|
GET_METHOD_ID(endSendObject, mdb_class, "(IZ)V");
|
|
GET_METHOD_ID(rescanFile, mdb_class, "(Ljava/lang/String;II)V");
|
|
GET_METHOD_ID(getObjectList, mdb_class, "(III)[I");
|
|
GET_METHOD_ID(getNumObjects, mdb_class, "(III)I");
|
|
GET_METHOD_ID(getSupportedPlaybackFormats, mdb_class, "()[I");
|
|
GET_METHOD_ID(getSupportedCaptureFormats, mdb_class, "()[I");
|
|
GET_METHOD_ID(getSupportedObjectProperties, mdb_class, "(I)[I");
|
|
GET_METHOD_ID(getSupportedDeviceProperties, mdb_class, "()[I");
|
|
GET_METHOD_ID(setObjectProperty, mdb_class, "(IIJLjava/lang/String;)I");
|
|
GET_METHOD_ID(getDeviceProperty, mdb_class, "(I[J[C)I");
|
|
GET_METHOD_ID(setDeviceProperty, mdb_class, "(IJLjava/lang/String;)I");
|
|
GET_METHOD_ID(getObjectPropertyList, mdb_class, "(IIIII)Landroid/mtp/MtpPropertyList;");
|
|
GET_METHOD_ID(getObjectInfo, mdb_class, "(I[I[C[J)Z");
|
|
GET_METHOD_ID(getObjectFilePath, mdb_class, "(I[C[J)I");
|
|
GET_METHOD_ID(openFilePath, mdb_class, "(Ljava/lang/String;Z)I");
|
|
GET_METHOD_ID(getThumbnailInfo, mdb_class, "(I[J)Z");
|
|
GET_METHOD_ID(getThumbnailData, mdb_class, "(I)[B");
|
|
GET_METHOD_ID(beginDeleteObject, mdb_class, "(I)I");
|
|
GET_METHOD_ID(endDeleteObject, mdb_class, "(IZ)V");
|
|
GET_METHOD_ID(beginMoveObject, mdb_class, "(III)I");
|
|
GET_METHOD_ID(endMoveObject, mdb_class, "(IIIIIZ)V");
|
|
GET_METHOD_ID(beginCopyObject, mdb_class, "(III)I");
|
|
GET_METHOD_ID(endCopyObject, mdb_class, "(IZ)V");
|
|
GET_METHOD_ID(getObjectReferences, mdb_class, "(I)[I");
|
|
GET_METHOD_ID(setObjectReferences, mdb_class, "(I[I)I");
|
|
field_context = GetFieldIDOrDie(env, mdb_class, "mNativeContext", "J");
|
|
|
|
const jclass mpl_class = FindClassOrDie(env, "android/mtp/MtpPropertyList");
|
|
GET_METHOD_ID(getCode, mpl_class, "()I");
|
|
GET_METHOD_ID(getCount, mpl_class, "()I");
|
|
GET_METHOD_ID(getObjectHandles, mpl_class, "()[I");
|
|
GET_METHOD_ID(getPropertyCodes, mpl_class, "()[I");
|
|
GET_METHOD_ID(getDataTypes, mpl_class, "()[I");
|
|
GET_METHOD_ID(getLongValues, mpl_class, "()[J");
|
|
GET_METHOD_ID(getStringValues, mpl_class, "()[Ljava/lang/String;");
|
|
|
|
return 0;
|
|
}, env);
|
|
|
|
#undef GET_METHOD_ID
|
|
}
|
|
|
|
|
|
IMtpDatabase* getMtpDatabase(JNIEnv *env, jobject database) {
|
|
return (IMtpDatabase *)env->GetLongField(database, field_context);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
class MtpDatabase : public IMtpDatabase {
|
|
private:
|
|
jobject mDatabase;
|
|
jintArray mIntBuffer;
|
|
jlongArray mLongBuffer;
|
|
jcharArray mStringBuffer;
|
|
|
|
public:
|
|
MtpDatabase(JNIEnv *env, jobject client);
|
|
virtual ~MtpDatabase();
|
|
void cleanup(JNIEnv *env);
|
|
|
|
virtual MtpObjectHandle beginSendObject(const char* path,
|
|
MtpObjectFormat format,
|
|
MtpObjectHandle parent,
|
|
MtpStorageID storage);
|
|
|
|
virtual void endSendObject(MtpObjectHandle handle, bool succeeded);
|
|
|
|
virtual void rescanFile(const char* path,
|
|
MtpObjectHandle handle,
|
|
MtpObjectFormat format);
|
|
|
|
virtual MtpObjectHandleList* getObjectList(MtpStorageID storageID,
|
|
MtpObjectFormat format,
|
|
MtpObjectHandle parent);
|
|
|
|
virtual int getNumObjects(MtpStorageID storageID,
|
|
MtpObjectFormat format,
|
|
MtpObjectHandle parent);
|
|
|
|
// callee should delete[] the results from these
|
|
// results can be NULL
|
|
virtual MtpObjectFormatList* getSupportedPlaybackFormats();
|
|
virtual MtpObjectFormatList* getSupportedCaptureFormats();
|
|
virtual MtpObjectPropertyList* getSupportedObjectProperties(MtpObjectFormat format);
|
|
virtual MtpDevicePropertyList* getSupportedDeviceProperties();
|
|
|
|
virtual MtpResponseCode getObjectPropertyValue(MtpObjectHandle handle,
|
|
MtpObjectProperty property,
|
|
MtpDataPacket& packet);
|
|
|
|
virtual MtpResponseCode setObjectPropertyValue(MtpObjectHandle handle,
|
|
MtpObjectProperty property,
|
|
MtpDataPacket& packet);
|
|
|
|
virtual MtpResponseCode getDevicePropertyValue(MtpDeviceProperty property,
|
|
MtpDataPacket& packet);
|
|
|
|
virtual MtpResponseCode setDevicePropertyValue(MtpDeviceProperty property,
|
|
MtpDataPacket& packet);
|
|
|
|
virtual MtpResponseCode resetDeviceProperty(MtpDeviceProperty property);
|
|
|
|
virtual MtpResponseCode getObjectPropertyList(MtpObjectHandle handle,
|
|
uint32_t format, uint32_t property,
|
|
int groupCode, int depth,
|
|
MtpDataPacket& packet);
|
|
|
|
virtual MtpResponseCode getObjectInfo(MtpObjectHandle handle,
|
|
MtpObjectInfo& info);
|
|
|
|
virtual void* getThumbnail(MtpObjectHandle handle, size_t& outThumbSize);
|
|
|
|
virtual MtpResponseCode getObjectFilePath(MtpObjectHandle handle,
|
|
MtpStringBuffer& outFilePath,
|
|
int64_t& outFileLength,
|
|
MtpObjectFormat& outFormat);
|
|
virtual int openFilePath(const char* path, bool transcode);
|
|
virtual MtpResponseCode beginDeleteObject(MtpObjectHandle handle);
|
|
virtual void endDeleteObject(MtpObjectHandle handle, bool succeeded);
|
|
|
|
bool getObjectPropertyInfo(MtpObjectProperty property, int& type);
|
|
bool getDevicePropertyInfo(MtpDeviceProperty property, int& type);
|
|
|
|
virtual MtpObjectHandleList* getObjectReferences(MtpObjectHandle handle);
|
|
|
|
virtual MtpResponseCode setObjectReferences(MtpObjectHandle handle,
|
|
MtpObjectHandleList* references);
|
|
|
|
virtual MtpProperty* getObjectPropertyDesc(MtpObjectProperty property,
|
|
MtpObjectFormat format);
|
|
|
|
virtual MtpProperty* getDevicePropertyDesc(MtpDeviceProperty property);
|
|
|
|
virtual MtpResponseCode beginMoveObject(MtpObjectHandle handle, MtpObjectHandle newParent,
|
|
MtpStorageID newStorage);
|
|
|
|
virtual void endMoveObject(MtpObjectHandle oldParent, MtpObjectHandle newParent,
|
|
MtpStorageID oldStorage, MtpStorageID newStorage,
|
|
MtpObjectHandle handle, bool succeeded);
|
|
|
|
virtual MtpResponseCode beginCopyObject(MtpObjectHandle handle, MtpObjectHandle newParent,
|
|
MtpStorageID newStorage);
|
|
virtual void endCopyObject(MtpObjectHandle handle, bool succeeded);
|
|
|
|
};
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
static void checkAndClearExceptionFromCallback(JNIEnv* env, const char* methodName) {
|
|
if (env->ExceptionCheck()) {
|
|
ALOGE("An exception was thrown by callback '%s'.", methodName);
|
|
LOGE_EX(env);
|
|
env->ExceptionClear();
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
MtpDatabase::MtpDatabase(JNIEnv *env, jobject client)
|
|
: mDatabase(env->NewGlobalRef(client)),
|
|
mIntBuffer(NULL),
|
|
mLongBuffer(NULL),
|
|
mStringBuffer(NULL)
|
|
{
|
|
// create buffers for out arguments
|
|
// we don't need to be thread-safe so this is OK
|
|
jintArray intArray = env->NewIntArray(3);
|
|
if (!intArray) {
|
|
return; // Already threw.
|
|
}
|
|
mIntBuffer = (jintArray)env->NewGlobalRef(intArray);
|
|
jlongArray longArray = env->NewLongArray(3);
|
|
if (!longArray) {
|
|
return; // Already threw.
|
|
}
|
|
mLongBuffer = (jlongArray)env->NewGlobalRef(longArray);
|
|
// Needs to be long enough to hold a file path for getObjectFilePath()
|
|
jcharArray charArray = env->NewCharArray(PATH_MAX + 1);
|
|
if (!charArray) {
|
|
return; // Already threw.
|
|
}
|
|
mStringBuffer = (jcharArray)env->NewGlobalRef(charArray);
|
|
}
|
|
|
|
void MtpDatabase::cleanup(JNIEnv *env) {
|
|
env->DeleteGlobalRef(mDatabase);
|
|
env->DeleteGlobalRef(mIntBuffer);
|
|
env->DeleteGlobalRef(mLongBuffer);
|
|
env->DeleteGlobalRef(mStringBuffer);
|
|
}
|
|
|
|
MtpDatabase::~MtpDatabase() {
|
|
}
|
|
|
|
MtpObjectHandle MtpDatabase::beginSendObject(const char* path,
|
|
MtpObjectFormat format,
|
|
MtpObjectHandle parent,
|
|
MtpStorageID storage) {
|
|
JNIEnv* env = AndroidRuntime::getJNIEnv();
|
|
jstring pathStr = env->NewStringUTF(path);
|
|
MtpObjectHandle result = env->CallIntMethod(mDatabase, method_beginSendObject,
|
|
pathStr, (jint)format, (jint)parent, (jint)storage);
|
|
|
|
if (pathStr)
|
|
env->DeleteLocalRef(pathStr);
|
|
checkAndClearExceptionFromCallback(env, __FUNCTION__);
|
|
return result;
|
|
}
|
|
|
|
void MtpDatabase::endSendObject(MtpObjectHandle handle, bool succeeded) {
|
|
JNIEnv* env = AndroidRuntime::getJNIEnv();
|
|
env->CallVoidMethod(mDatabase, method_endSendObject, (jint)handle, (jboolean)succeeded);
|
|
|
|
checkAndClearExceptionFromCallback(env, __FUNCTION__);
|
|
}
|
|
|
|
void MtpDatabase::rescanFile(const char* path, MtpObjectHandle handle,
|
|
MtpObjectFormat format) {
|
|
JNIEnv* env = AndroidRuntime::getJNIEnv();
|
|
jstring pathStr = env->NewStringUTF(path);
|
|
env->CallVoidMethod(mDatabase, method_rescanFile, pathStr,
|
|
(jint)handle, (jint)format);
|
|
|
|
if (pathStr)
|
|
env->DeleteLocalRef(pathStr);
|
|
checkAndClearExceptionFromCallback(env, __FUNCTION__);
|
|
}
|
|
|
|
MtpObjectHandleList* MtpDatabase::getObjectList(MtpStorageID storageID,
|
|
MtpObjectFormat format,
|
|
MtpObjectHandle parent) {
|
|
JNIEnv* env = AndroidRuntime::getJNIEnv();
|
|
jintArray array = (jintArray)env->CallObjectMethod(mDatabase, method_getObjectList,
|
|
(jint)storageID, (jint)format, (jint)parent);
|
|
if (!array)
|
|
return NULL;
|
|
MtpObjectHandleList* list = new MtpObjectHandleList();
|
|
jint* handles = env->GetIntArrayElements(array, 0);
|
|
jsize length = env->GetArrayLength(array);
|
|
for (int i = 0; i < length; i++)
|
|
list->push_back(handles[i]);
|
|
env->ReleaseIntArrayElements(array, handles, 0);
|
|
env->DeleteLocalRef(array);
|
|
|
|
checkAndClearExceptionFromCallback(env, __FUNCTION__);
|
|
return list;
|
|
}
|
|
|
|
int MtpDatabase::getNumObjects(MtpStorageID storageID,
|
|
MtpObjectFormat format,
|
|
MtpObjectHandle parent) {
|
|
JNIEnv* env = AndroidRuntime::getJNIEnv();
|
|
int result = env->CallIntMethod(mDatabase, method_getNumObjects,
|
|
(jint)storageID, (jint)format, (jint)parent);
|
|
|
|
checkAndClearExceptionFromCallback(env, __FUNCTION__);
|
|
return result;
|
|
}
|
|
|
|
MtpObjectFormatList* MtpDatabase::getSupportedPlaybackFormats() {
|
|
JNIEnv* env = AndroidRuntime::getJNIEnv();
|
|
jintArray array = (jintArray)env->CallObjectMethod(mDatabase,
|
|
method_getSupportedPlaybackFormats);
|
|
if (!array)
|
|
return NULL;
|
|
MtpObjectFormatList* list = new MtpObjectFormatList();
|
|
jint* formats = env->GetIntArrayElements(array, 0);
|
|
jsize length = env->GetArrayLength(array);
|
|
for (int i = 0; i < length; i++)
|
|
list->push_back(formats[i]);
|
|
env->ReleaseIntArrayElements(array, formats, 0);
|
|
env->DeleteLocalRef(array);
|
|
|
|
checkAndClearExceptionFromCallback(env, __FUNCTION__);
|
|
return list;
|
|
}
|
|
|
|
MtpObjectFormatList* MtpDatabase::getSupportedCaptureFormats() {
|
|
JNIEnv* env = AndroidRuntime::getJNIEnv();
|
|
jintArray array = (jintArray)env->CallObjectMethod(mDatabase,
|
|
method_getSupportedCaptureFormats);
|
|
if (!array)
|
|
return NULL;
|
|
MtpObjectFormatList* list = new MtpObjectFormatList();
|
|
jint* formats = env->GetIntArrayElements(array, 0);
|
|
jsize length = env->GetArrayLength(array);
|
|
for (int i = 0; i < length; i++)
|
|
list->push_back(formats[i]);
|
|
env->ReleaseIntArrayElements(array, formats, 0);
|
|
env->DeleteLocalRef(array);
|
|
|
|
checkAndClearExceptionFromCallback(env, __FUNCTION__);
|
|
return list;
|
|
}
|
|
|
|
MtpObjectPropertyList* MtpDatabase::getSupportedObjectProperties(MtpObjectFormat format) {
|
|
JNIEnv* env = AndroidRuntime::getJNIEnv();
|
|
jintArray array = (jintArray)env->CallObjectMethod(mDatabase,
|
|
method_getSupportedObjectProperties, (jint)format);
|
|
if (!array)
|
|
return NULL;
|
|
MtpObjectPropertyList* list = new MtpObjectPropertyList();
|
|
jint* properties = env->GetIntArrayElements(array, 0);
|
|
jsize length = env->GetArrayLength(array);
|
|
for (int i = 0; i < length; i++)
|
|
list->push_back(properties[i]);
|
|
env->ReleaseIntArrayElements(array, properties, 0);
|
|
env->DeleteLocalRef(array);
|
|
|
|
checkAndClearExceptionFromCallback(env, __FUNCTION__);
|
|
return list;
|
|
}
|
|
|
|
MtpDevicePropertyList* MtpDatabase::getSupportedDeviceProperties() {
|
|
JNIEnv* env = AndroidRuntime::getJNIEnv();
|
|
jintArray array = (jintArray)env->CallObjectMethod(mDatabase,
|
|
method_getSupportedDeviceProperties);
|
|
if (!array)
|
|
return NULL;
|
|
MtpDevicePropertyList* list = new MtpDevicePropertyList();
|
|
jint* properties = env->GetIntArrayElements(array, 0);
|
|
jsize length = env->GetArrayLength(array);
|
|
for (int i = 0; i < length; i++)
|
|
list->push_back(properties[i]);
|
|
env->ReleaseIntArrayElements(array, properties, 0);
|
|
env->DeleteLocalRef(array);
|
|
|
|
checkAndClearExceptionFromCallback(env, __FUNCTION__);
|
|
return list;
|
|
}
|
|
|
|
MtpResponseCode MtpDatabase::getObjectPropertyValue(MtpObjectHandle handle,
|
|
MtpObjectProperty property,
|
|
MtpDataPacket& packet) {
|
|
static_assert(sizeof(jint) >= sizeof(MtpObjectHandle),
|
|
"Casting MtpObjectHandle to jint loses a value");
|
|
static_assert(sizeof(jint) >= sizeof(MtpObjectProperty),
|
|
"Casting MtpObjectProperty to jint loses a value");
|
|
JNIEnv* env = AndroidRuntime::getJNIEnv();
|
|
jobject list = env->CallObjectMethod(
|
|
mDatabase,
|
|
method_getObjectPropertyList,
|
|
static_cast<jint>(handle),
|
|
0,
|
|
static_cast<jint>(property),
|
|
0,
|
|
0);
|
|
MtpResponseCode result = env->CallIntMethod(list, method_getCode);
|
|
jint count = env->CallIntMethod(list, method_getCount);
|
|
if (count != 1)
|
|
result = MTP_RESPONSE_GENERAL_ERROR;
|
|
|
|
if (result == MTP_RESPONSE_OK) {
|
|
jintArray objectHandlesArray = (jintArray)env->CallObjectMethod(list, method_getObjectHandles);
|
|
jintArray propertyCodesArray = (jintArray)env->CallObjectMethod(list, method_getPropertyCodes);
|
|
jintArray dataTypesArray = (jintArray)env->CallObjectMethod(list, method_getDataTypes);
|
|
jlongArray longValuesArray = (jlongArray)env->CallObjectMethod(list, method_getLongValues);
|
|
jobjectArray stringValuesArray = (jobjectArray)env->CallObjectMethod(list, method_getStringValues);
|
|
|
|
jint* objectHandles = env->GetIntArrayElements(objectHandlesArray, 0);
|
|
jint* propertyCodes = env->GetIntArrayElements(propertyCodesArray, 0);
|
|
jint* dataTypes = env->GetIntArrayElements(dataTypesArray, 0);
|
|
jlong* longValues = env->GetLongArrayElements(longValuesArray, 0);
|
|
|
|
int type = dataTypes[0];
|
|
jlong longValue = (longValues ? longValues[0] : 0);
|
|
|
|
switch (type) {
|
|
case MTP_TYPE_INT8:
|
|
packet.putInt8(longValue);
|
|
break;
|
|
case MTP_TYPE_UINT8:
|
|
packet.putUInt8(longValue);
|
|
break;
|
|
case MTP_TYPE_INT16:
|
|
packet.putInt16(longValue);
|
|
break;
|
|
case MTP_TYPE_UINT16:
|
|
packet.putUInt16(longValue);
|
|
break;
|
|
case MTP_TYPE_INT32:
|
|
packet.putInt32(longValue);
|
|
break;
|
|
case MTP_TYPE_UINT32:
|
|
packet.putUInt32(longValue);
|
|
break;
|
|
case MTP_TYPE_INT64:
|
|
packet.putInt64(longValue);
|
|
break;
|
|
case MTP_TYPE_UINT64:
|
|
packet.putUInt64(longValue);
|
|
break;
|
|
case MTP_TYPE_INT128:
|
|
packet.putInt128(longValue);
|
|
break;
|
|
case MTP_TYPE_UINT128:
|
|
packet.putUInt128(longValue);
|
|
break;
|
|
case MTP_TYPE_STR:
|
|
{
|
|
jstring stringValue = (jstring)env->GetObjectArrayElement(stringValuesArray, 0);
|
|
const char* str = (stringValue ? env->GetStringUTFChars(stringValue, NULL) : NULL);
|
|
if (stringValue) {
|
|
packet.putString(str);
|
|
env->ReleaseStringUTFChars(stringValue, str);
|
|
} else {
|
|
packet.putEmptyString();
|
|
}
|
|
env->DeleteLocalRef(stringValue);
|
|
break;
|
|
}
|
|
default:
|
|
ALOGE("unsupported type in getObjectPropertyValue\n");
|
|
result = MTP_RESPONSE_INVALID_OBJECT_PROP_FORMAT;
|
|
}
|
|
env->ReleaseIntArrayElements(objectHandlesArray, objectHandles, 0);
|
|
env->ReleaseIntArrayElements(propertyCodesArray, propertyCodes, 0);
|
|
env->ReleaseIntArrayElements(dataTypesArray, dataTypes, 0);
|
|
env->ReleaseLongArrayElements(longValuesArray, longValues, 0);
|
|
|
|
env->DeleteLocalRef(objectHandlesArray);
|
|
env->DeleteLocalRef(propertyCodesArray);
|
|
env->DeleteLocalRef(dataTypesArray);
|
|
env->DeleteLocalRef(longValuesArray);
|
|
env->DeleteLocalRef(stringValuesArray);
|
|
}
|
|
|
|
env->DeleteLocalRef(list);
|
|
checkAndClearExceptionFromCallback(env, __FUNCTION__);
|
|
return result;
|
|
}
|
|
|
|
static bool readLongValue(int type, MtpDataPacket& packet, jlong& longValue) {
|
|
switch (type) {
|
|
case MTP_TYPE_INT8: {
|
|
int8_t temp;
|
|
if (!packet.getInt8(temp)) return false;
|
|
longValue = temp;
|
|
break;
|
|
}
|
|
case MTP_TYPE_UINT8: {
|
|
uint8_t temp;
|
|
if (!packet.getUInt8(temp)) return false;
|
|
longValue = temp;
|
|
break;
|
|
}
|
|
case MTP_TYPE_INT16: {
|
|
int16_t temp;
|
|
if (!packet.getInt16(temp)) return false;
|
|
longValue = temp;
|
|
break;
|
|
}
|
|
case MTP_TYPE_UINT16: {
|
|
uint16_t temp;
|
|
if (!packet.getUInt16(temp)) return false;
|
|
longValue = temp;
|
|
break;
|
|
}
|
|
case MTP_TYPE_INT32: {
|
|
int32_t temp;
|
|
if (!packet.getInt32(temp)) return false;
|
|
longValue = temp;
|
|
break;
|
|
}
|
|
case MTP_TYPE_UINT32: {
|
|
uint32_t temp;
|
|
if (!packet.getUInt32(temp)) return false;
|
|
longValue = temp;
|
|
break;
|
|
}
|
|
case MTP_TYPE_INT64: {
|
|
int64_t temp;
|
|
if (!packet.getInt64(temp)) return false;
|
|
longValue = temp;
|
|
break;
|
|
}
|
|
case MTP_TYPE_UINT64: {
|
|
uint64_t temp;
|
|
if (!packet.getUInt64(temp)) return false;
|
|
longValue = temp;
|
|
break;
|
|
}
|
|
default:
|
|
ALOGE("unsupported type in readLongValue");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
MtpResponseCode MtpDatabase::setObjectPropertyValue(MtpObjectHandle handle,
|
|
MtpObjectProperty property,
|
|
MtpDataPacket& packet) {
|
|
int type;
|
|
|
|
if (!getObjectPropertyInfo(property, type))
|
|
return MTP_RESPONSE_OBJECT_PROP_NOT_SUPPORTED;
|
|
|
|
JNIEnv* env = AndroidRuntime::getJNIEnv();
|
|
jlong longValue = 0;
|
|
jstring stringValue = NULL;
|
|
MtpResponseCode result = MTP_RESPONSE_INVALID_OBJECT_PROP_FORMAT;
|
|
|
|
if (type == MTP_TYPE_STR) {
|
|
MtpStringBuffer buffer;
|
|
if (!packet.getString(buffer)) goto fail;
|
|
stringValue = env->NewStringUTF((const char *)buffer);
|
|
} else {
|
|
if (!readLongValue(type, packet, longValue)) goto fail;
|
|
}
|
|
|
|
result = env->CallIntMethod(mDatabase, method_setObjectProperty,
|
|
(jint)handle, (jint)property, longValue, stringValue);
|
|
if (stringValue)
|
|
env->DeleteLocalRef(stringValue);
|
|
|
|
fail:
|
|
checkAndClearExceptionFromCallback(env, __FUNCTION__);
|
|
return result;
|
|
}
|
|
|
|
MtpResponseCode MtpDatabase::getDevicePropertyValue(MtpDeviceProperty property,
|
|
MtpDataPacket& packet) {
|
|
JNIEnv* env = AndroidRuntime::getJNIEnv();
|
|
int type;
|
|
|
|
if (!getDevicePropertyInfo(property, type))
|
|
return MTP_RESPONSE_DEVICE_PROP_NOT_SUPPORTED;
|
|
|
|
jint result = env->CallIntMethod(mDatabase, method_getDeviceProperty,
|
|
(jint)property, mLongBuffer, mStringBuffer);
|
|
if (result != MTP_RESPONSE_OK) {
|
|
checkAndClearExceptionFromCallback(env, __FUNCTION__);
|
|
return result;
|
|
}
|
|
|
|
jlong* longValues = env->GetLongArrayElements(mLongBuffer, 0);
|
|
jlong longValue = longValues[0];
|
|
env->ReleaseLongArrayElements(mLongBuffer, longValues, 0);
|
|
|
|
switch (type) {
|
|
case MTP_TYPE_INT8:
|
|
packet.putInt8(longValue);
|
|
break;
|
|
case MTP_TYPE_UINT8:
|
|
packet.putUInt8(longValue);
|
|
break;
|
|
case MTP_TYPE_INT16:
|
|
packet.putInt16(longValue);
|
|
break;
|
|
case MTP_TYPE_UINT16:
|
|
packet.putUInt16(longValue);
|
|
break;
|
|
case MTP_TYPE_INT32:
|
|
packet.putInt32(longValue);
|
|
break;
|
|
case MTP_TYPE_UINT32:
|
|
packet.putUInt32(longValue);
|
|
break;
|
|
case MTP_TYPE_INT64:
|
|
packet.putInt64(longValue);
|
|
break;
|
|
case MTP_TYPE_UINT64:
|
|
packet.putUInt64(longValue);
|
|
break;
|
|
case MTP_TYPE_INT128:
|
|
packet.putInt128(longValue);
|
|
break;
|
|
case MTP_TYPE_UINT128:
|
|
packet.putInt128(longValue);
|
|
break;
|
|
case MTP_TYPE_STR:
|
|
{
|
|
jchar* str = env->GetCharArrayElements(mStringBuffer, 0);
|
|
packet.putString(str);
|
|
env->ReleaseCharArrayElements(mStringBuffer, str, 0);
|
|
break;
|
|
}
|
|
default:
|
|
ALOGE("unsupported type in getDevicePropertyValue\n");
|
|
return MTP_RESPONSE_INVALID_DEVICE_PROP_FORMAT;
|
|
}
|
|
|
|
checkAndClearExceptionFromCallback(env, __FUNCTION__);
|
|
return MTP_RESPONSE_OK;
|
|
}
|
|
|
|
MtpResponseCode MtpDatabase::setDevicePropertyValue(MtpDeviceProperty property,
|
|
MtpDataPacket& packet) {
|
|
int type;
|
|
|
|
if (!getDevicePropertyInfo(property, type))
|
|
return MTP_RESPONSE_DEVICE_PROP_NOT_SUPPORTED;
|
|
|
|
JNIEnv* env = AndroidRuntime::getJNIEnv();
|
|
jlong longValue = 0;
|
|
jstring stringValue = NULL;
|
|
MtpResponseCode result = MTP_RESPONSE_INVALID_DEVICE_PROP_FORMAT;
|
|
|
|
if (type == MTP_TYPE_STR) {
|
|
MtpStringBuffer buffer;
|
|
if (!packet.getString(buffer)) goto fail;
|
|
stringValue = env->NewStringUTF((const char *)buffer);
|
|
} else {
|
|
if (!readLongValue(type, packet, longValue)) goto fail;
|
|
}
|
|
|
|
result = env->CallIntMethod(mDatabase, method_setDeviceProperty,
|
|
(jint)property, longValue, stringValue);
|
|
if (stringValue)
|
|
env->DeleteLocalRef(stringValue);
|
|
|
|
fail:
|
|
checkAndClearExceptionFromCallback(env, __FUNCTION__);
|
|
return result;
|
|
}
|
|
|
|
MtpResponseCode MtpDatabase::resetDeviceProperty(MtpDeviceProperty /*property*/) {
|
|
return -1;
|
|
}
|
|
|
|
MtpResponseCode MtpDatabase::getObjectPropertyList(MtpObjectHandle handle,
|
|
uint32_t format, uint32_t property,
|
|
int groupCode, int depth,
|
|
MtpDataPacket& packet) {
|
|
static_assert(sizeof(jint) >= sizeof(MtpObjectHandle),
|
|
"Casting MtpObjectHandle to jint loses a value");
|
|
JNIEnv* env = AndroidRuntime::getJNIEnv();
|
|
jobject list = env->CallObjectMethod(
|
|
mDatabase,
|
|
method_getObjectPropertyList,
|
|
static_cast<jint>(handle),
|
|
static_cast<jint>(format),
|
|
static_cast<jint>(property),
|
|
static_cast<jint>(groupCode),
|
|
static_cast<jint>(depth));
|
|
checkAndClearExceptionFromCallback(env, __FUNCTION__);
|
|
if (!list)
|
|
return MTP_RESPONSE_GENERAL_ERROR;
|
|
int count = env->CallIntMethod(list, method_getCount);
|
|
MtpResponseCode result = env->CallIntMethod(list, method_getCode);
|
|
|
|
packet.putUInt32(count);
|
|
if (count > 0) {
|
|
jintArray objectHandlesArray = (jintArray)env->CallObjectMethod(list, method_getObjectHandles);
|
|
jintArray propertyCodesArray = (jintArray)env->CallObjectMethod(list, method_getPropertyCodes);
|
|
jintArray dataTypesArray = (jintArray)env->CallObjectMethod(list, method_getDataTypes);
|
|
jlongArray longValuesArray = (jlongArray)env->CallObjectMethod(list, method_getLongValues);
|
|
jobjectArray stringValuesArray = (jobjectArray)env->CallObjectMethod(list, method_getStringValues);
|
|
|
|
jint* objectHandles = env->GetIntArrayElements(objectHandlesArray, 0);
|
|
jint* propertyCodes = env->GetIntArrayElements(propertyCodesArray, 0);
|
|
jint* dataTypes = env->GetIntArrayElements(dataTypesArray, 0);
|
|
jlong* longValues = (longValuesArray ? env->GetLongArrayElements(longValuesArray, 0) : NULL);
|
|
|
|
for (int i = 0; i < count; i++) {
|
|
packet.putUInt32(objectHandles[i]);
|
|
packet.putUInt16(propertyCodes[i]);
|
|
int type = dataTypes[i];
|
|
packet.putUInt16(type);
|
|
|
|
if (type == MTP_TYPE_STR) {
|
|
jstring value = (jstring)env->GetObjectArrayElement(stringValuesArray, i);
|
|
const char *valueStr = (value ? env->GetStringUTFChars(value, NULL) : NULL);
|
|
if (valueStr) {
|
|
packet.putString(valueStr);
|
|
env->ReleaseStringUTFChars(value, valueStr);
|
|
} else {
|
|
packet.putEmptyString();
|
|
}
|
|
env->DeleteLocalRef(value);
|
|
continue;
|
|
}
|
|
|
|
if (!longValues) {
|
|
ALOGE("bad longValuesArray value in MyMtpDatabase::getObjectPropertyList");
|
|
continue;
|
|
}
|
|
|
|
switch (type) {
|
|
case MTP_TYPE_INT8:
|
|
packet.putInt8(longValues[i]);
|
|
break;
|
|
case MTP_TYPE_UINT8:
|
|
packet.putUInt8(longValues[i]);
|
|
break;
|
|
case MTP_TYPE_INT16:
|
|
packet.putInt16(longValues[i]);
|
|
break;
|
|
case MTP_TYPE_UINT16:
|
|
packet.putUInt16(longValues[i]);
|
|
break;
|
|
case MTP_TYPE_INT32:
|
|
packet.putInt32(longValues[i]);
|
|
break;
|
|
case MTP_TYPE_UINT32:
|
|
packet.putUInt32(longValues[i]);
|
|
break;
|
|
case MTP_TYPE_INT64:
|
|
packet.putInt64(longValues[i]);
|
|
break;
|
|
case MTP_TYPE_UINT64:
|
|
packet.putUInt64(longValues[i]);
|
|
break;
|
|
case MTP_TYPE_INT128:
|
|
packet.putInt128(longValues[i]);
|
|
break;
|
|
case MTP_TYPE_UINT128:
|
|
packet.putUInt128(longValues[i]);
|
|
break;
|
|
default:
|
|
ALOGE("bad or unsupported data type in MtpDatabase::getObjectPropertyList");
|
|
break;
|
|
}
|
|
}
|
|
|
|
env->ReleaseIntArrayElements(objectHandlesArray, objectHandles, 0);
|
|
env->ReleaseIntArrayElements(propertyCodesArray, propertyCodes, 0);
|
|
env->ReleaseIntArrayElements(dataTypesArray, dataTypes, 0);
|
|
env->ReleaseLongArrayElements(longValuesArray, longValues, 0);
|
|
|
|
env->DeleteLocalRef(objectHandlesArray);
|
|
env->DeleteLocalRef(propertyCodesArray);
|
|
env->DeleteLocalRef(dataTypesArray);
|
|
env->DeleteLocalRef(longValuesArray);
|
|
env->DeleteLocalRef(stringValuesArray);
|
|
}
|
|
|
|
env->DeleteLocalRef(list);
|
|
checkAndClearExceptionFromCallback(env, __FUNCTION__);
|
|
return result;
|
|
}
|
|
|
|
MtpResponseCode MtpDatabase::getObjectInfo(MtpObjectHandle handle,
|
|
MtpObjectInfo& info) {
|
|
MtpStringBuffer path;
|
|
int64_t length;
|
|
MtpObjectFormat format;
|
|
|
|
MtpResponseCode result = getObjectFilePath(handle, path, length, format);
|
|
if (result != MTP_RESPONSE_OK) {
|
|
return result;
|
|
}
|
|
info.mCompressedSize = (length > 0xFFFFFFFFLL ? 0xFFFFFFFF : (uint32_t)length);
|
|
|
|
JNIEnv* env = AndroidRuntime::getJNIEnv();
|
|
if (!env->CallBooleanMethod(mDatabase, method_getObjectInfo,
|
|
(jint)handle, mIntBuffer, mStringBuffer, mLongBuffer)) {
|
|
return MTP_RESPONSE_INVALID_OBJECT_HANDLE;
|
|
}
|
|
|
|
jint* intValues = env->GetIntArrayElements(mIntBuffer, 0);
|
|
info.mStorageID = intValues[0];
|
|
info.mFormat = intValues[1];
|
|
info.mParent = intValues[2];
|
|
env->ReleaseIntArrayElements(mIntBuffer, intValues, 0);
|
|
|
|
jlong* longValues = env->GetLongArrayElements(mLongBuffer, 0);
|
|
info.mDateCreated = longValues[0];
|
|
info.mDateModified = longValues[1];
|
|
env->ReleaseLongArrayElements(mLongBuffer, longValues, 0);
|
|
|
|
if ((false)) {
|
|
info.mAssociationType = (format == MTP_FORMAT_ASSOCIATION ?
|
|
MTP_ASSOCIATION_TYPE_GENERIC_FOLDER :
|
|
MTP_ASSOCIATION_TYPE_UNDEFINED);
|
|
}
|
|
info.mAssociationType = MTP_ASSOCIATION_TYPE_UNDEFINED;
|
|
|
|
jchar* str = env->GetCharArrayElements(mStringBuffer, 0);
|
|
MtpStringBuffer temp(str);
|
|
info.mName = strdup(temp);
|
|
env->ReleaseCharArrayElements(mStringBuffer, str, 0);
|
|
|
|
// read EXIF data for thumbnail information
|
|
switch (info.mFormat) {
|
|
case MTP_FORMAT_EXIF_JPEG:
|
|
case MTP_FORMAT_HEIF:
|
|
case MTP_FORMAT_JFIF:
|
|
case MTP_FORMAT_PNG:
|
|
case MTP_FORMAT_BMP:
|
|
case MTP_FORMAT_GIF: {
|
|
env = AndroidRuntime::getJNIEnv();
|
|
if (env->CallBooleanMethod(
|
|
mDatabase, method_getThumbnailInfo, (jint)handle, mLongBuffer)) {
|
|
|
|
jlong* longValues = env->GetLongArrayElements(mLongBuffer, 0);
|
|
jlong size = longValues[0];
|
|
jlong w = longValues[1];
|
|
jlong h = longValues[2];
|
|
if (size > 0 && size <= UINT32_MAX &&
|
|
w > 0 && w <= UINT32_MAX &&
|
|
h > 0 && h <= UINT32_MAX) {
|
|
info.mThumbCompressedSize = size;
|
|
info.mThumbFormat = MTP_FORMAT_EXIF_JPEG;
|
|
info.mImagePixWidth = w;
|
|
info.mImagePixHeight = h;
|
|
}
|
|
env->ReleaseLongArrayElements(mLongBuffer, longValues, 0);
|
|
}
|
|
break;
|
|
}
|
|
|
|
// Except DNG, all supported RAW image formats are not defined in PTP 1.2 specification.
|
|
// Most of RAW image formats are based on TIFF or TIFF/EP. To render Fuji's RAF format,
|
|
// it checks MTP_FORMAT_DEFINED case since it's designed as a custom format.
|
|
case MTP_FORMAT_DNG:
|
|
case MTP_FORMAT_TIFF:
|
|
case MTP_FORMAT_TIFF_EP:
|
|
case MTP_FORMAT_DEFINED: {
|
|
String8 temp(path);
|
|
std::unique_ptr<FileStream> stream(new FileStream(temp));
|
|
piex::PreviewImageData image_data;
|
|
if (!GetExifFromRawImage(stream.get(), temp, image_data)) {
|
|
// Couldn't parse EXIF data from a image file via piex.
|
|
break;
|
|
}
|
|
|
|
info.mThumbCompressedSize = image_data.thumbnail.length;
|
|
info.mThumbFormat = MTP_FORMAT_EXIF_JPEG;
|
|
info.mImagePixWidth = image_data.full_width;
|
|
info.mImagePixHeight = image_data.full_height;
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
checkAndClearExceptionFromCallback(env, __FUNCTION__);
|
|
return MTP_RESPONSE_OK;
|
|
}
|
|
|
|
void* MtpDatabase::getThumbnail(MtpObjectHandle handle, size_t& outThumbSize) {
|
|
MtpStringBuffer path;
|
|
int64_t length;
|
|
MtpObjectFormat format;
|
|
void* result = NULL;
|
|
outThumbSize = 0;
|
|
|
|
if (getObjectFilePath(handle, path, length, format) == MTP_RESPONSE_OK) {
|
|
switch (format) {
|
|
case MTP_FORMAT_EXIF_JPEG:
|
|
case MTP_FORMAT_HEIF:
|
|
case MTP_FORMAT_JFIF:
|
|
case MTP_FORMAT_PNG:
|
|
case MTP_FORMAT_BMP:
|
|
case MTP_FORMAT_GIF: {
|
|
JNIEnv* env = AndroidRuntime::getJNIEnv();
|
|
jbyteArray thumbData = (jbyteArray) env->CallObjectMethod(
|
|
mDatabase, method_getThumbnailData, (jint)handle);
|
|
if (thumbData == NULL) {
|
|
return nullptr;
|
|
}
|
|
jsize thumbSize = env->GetArrayLength(thumbData);
|
|
result = malloc(thumbSize);
|
|
if (result) {
|
|
env->GetByteArrayRegion(thumbData, 0, thumbSize, (jbyte*)result);
|
|
outThumbSize = thumbSize;
|
|
}
|
|
env->DeleteLocalRef(thumbData);
|
|
break;
|
|
}
|
|
|
|
// See the above comment on getObjectInfo() method.
|
|
case MTP_FORMAT_DNG:
|
|
case MTP_FORMAT_TIFF:
|
|
case MTP_FORMAT_TIFF_EP:
|
|
case MTP_FORMAT_DEFINED: {
|
|
String8 temp(path);
|
|
std::unique_ptr<FileStream> stream(new FileStream(temp));
|
|
piex::PreviewImageData image_data;
|
|
if (!GetExifFromRawImage(stream.get(), temp, image_data)) {
|
|
// Couldn't parse EXIF data from a image file via piex.
|
|
break;
|
|
}
|
|
|
|
if (image_data.thumbnail.length == 0
|
|
|| image_data.thumbnail.format != ::piex::Image::kJpegCompressed) {
|
|
// No thumbnail or non jpeg thumbnail.
|
|
break;
|
|
}
|
|
|
|
result = malloc(image_data.thumbnail.length);
|
|
if (result) {
|
|
piex::Error err = stream.get()->GetData(
|
|
image_data.thumbnail.offset,
|
|
image_data.thumbnail.length,
|
|
(std::uint8_t *)result);
|
|
if (err == piex::Error::kOk) {
|
|
outThumbSize = image_data.thumbnail.length;
|
|
} else {
|
|
free(result);
|
|
result = NULL;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
MtpResponseCode MtpDatabase::getObjectFilePath(MtpObjectHandle handle,
|
|
MtpStringBuffer& outFilePath,
|
|
int64_t& outFileLength,
|
|
MtpObjectFormat& outFormat) {
|
|
JNIEnv* env = AndroidRuntime::getJNIEnv();
|
|
jint result = env->CallIntMethod(mDatabase, method_getObjectFilePath,
|
|
(jint)handle, mStringBuffer, mLongBuffer);
|
|
if (result != MTP_RESPONSE_OK) {
|
|
checkAndClearExceptionFromCallback(env, __FUNCTION__);
|
|
return result;
|
|
}
|
|
|
|
jchar* str = env->GetCharArrayElements(mStringBuffer, 0);
|
|
outFilePath.set(str);
|
|
env->ReleaseCharArrayElements(mStringBuffer, str, 0);
|
|
|
|
jlong* longValues = env->GetLongArrayElements(mLongBuffer, 0);
|
|
outFileLength = longValues[0];
|
|
outFormat = longValues[1];
|
|
env->ReleaseLongArrayElements(mLongBuffer, longValues, 0);
|
|
|
|
checkAndClearExceptionFromCallback(env, __FUNCTION__);
|
|
return result;
|
|
}
|
|
|
|
int MtpDatabase::openFilePath(const char* path, bool transcode) {
|
|
JNIEnv* env = AndroidRuntime::getJNIEnv();
|
|
jstring pathStr = env->NewStringUTF(path);
|
|
jint result = env->CallIntMethod(mDatabase, method_openFilePath, pathStr, transcode);
|
|
|
|
if (result < 0) {
|
|
checkAndClearExceptionFromCallback(env, __FUNCTION__);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
MtpResponseCode MtpDatabase::beginDeleteObject(MtpObjectHandle handle) {
|
|
JNIEnv* env = AndroidRuntime::getJNIEnv();
|
|
MtpResponseCode result = env->CallIntMethod(mDatabase, method_beginDeleteObject, (jint)handle);
|
|
|
|
checkAndClearExceptionFromCallback(env, __FUNCTION__);
|
|
return result;
|
|
}
|
|
|
|
void MtpDatabase::endDeleteObject(MtpObjectHandle handle, bool succeeded) {
|
|
JNIEnv* env = AndroidRuntime::getJNIEnv();
|
|
env->CallVoidMethod(mDatabase, method_endDeleteObject, (jint)handle, (jboolean) succeeded);
|
|
|
|
checkAndClearExceptionFromCallback(env, __FUNCTION__);
|
|
}
|
|
|
|
MtpResponseCode MtpDatabase::beginMoveObject(MtpObjectHandle handle, MtpObjectHandle newParent,
|
|
MtpStorageID newStorage) {
|
|
JNIEnv* env = AndroidRuntime::getJNIEnv();
|
|
MtpResponseCode result = env->CallIntMethod(mDatabase, method_beginMoveObject,
|
|
(jint)handle, (jint)newParent, (jint) newStorage);
|
|
|
|
checkAndClearExceptionFromCallback(env, __FUNCTION__);
|
|
return result;
|
|
}
|
|
|
|
void MtpDatabase::endMoveObject(MtpObjectHandle oldParent, MtpObjectHandle newParent,
|
|
MtpStorageID oldStorage, MtpStorageID newStorage,
|
|
MtpObjectHandle handle, bool succeeded) {
|
|
JNIEnv* env = AndroidRuntime::getJNIEnv();
|
|
env->CallVoidMethod(mDatabase, method_endMoveObject,
|
|
(jint)oldParent, (jint) newParent, (jint) oldStorage, (jint) newStorage,
|
|
(jint) handle, (jboolean) succeeded);
|
|
|
|
checkAndClearExceptionFromCallback(env, __FUNCTION__);
|
|
}
|
|
|
|
MtpResponseCode MtpDatabase::beginCopyObject(MtpObjectHandle handle, MtpObjectHandle newParent,
|
|
MtpStorageID newStorage) {
|
|
JNIEnv* env = AndroidRuntime::getJNIEnv();
|
|
MtpResponseCode result = env->CallIntMethod(mDatabase, method_beginCopyObject,
|
|
(jint)handle, (jint)newParent, (jint) newStorage);
|
|
|
|
checkAndClearExceptionFromCallback(env, __FUNCTION__);
|
|
return result;
|
|
}
|
|
|
|
void MtpDatabase::endCopyObject(MtpObjectHandle handle, bool succeeded) {
|
|
JNIEnv* env = AndroidRuntime::getJNIEnv();
|
|
env->CallVoidMethod(mDatabase, method_endCopyObject, (jint)handle, (jboolean)succeeded);
|
|
|
|
checkAndClearExceptionFromCallback(env, __FUNCTION__);
|
|
}
|
|
|
|
|
|
struct PropertyTableEntry {
|
|
MtpObjectProperty property;
|
|
int type;
|
|
};
|
|
|
|
static const PropertyTableEntry kObjectPropertyTable[] = {
|
|
{ MTP_PROPERTY_STORAGE_ID, MTP_TYPE_UINT32 },
|
|
{ MTP_PROPERTY_OBJECT_FORMAT, MTP_TYPE_UINT16 },
|
|
{ MTP_PROPERTY_PROTECTION_STATUS, MTP_TYPE_UINT16 },
|
|
{ MTP_PROPERTY_OBJECT_SIZE, MTP_TYPE_UINT64 },
|
|
{ MTP_PROPERTY_OBJECT_FILE_NAME, MTP_TYPE_STR },
|
|
{ MTP_PROPERTY_DATE_MODIFIED, MTP_TYPE_STR },
|
|
{ MTP_PROPERTY_PARENT_OBJECT, MTP_TYPE_UINT32 },
|
|
{ MTP_PROPERTY_PERSISTENT_UID, MTP_TYPE_UINT128 },
|
|
{ MTP_PROPERTY_NAME, MTP_TYPE_STR },
|
|
{ MTP_PROPERTY_DISPLAY_NAME, MTP_TYPE_STR },
|
|
{ MTP_PROPERTY_DATE_ADDED, MTP_TYPE_STR },
|
|
{ MTP_PROPERTY_ARTIST, MTP_TYPE_STR },
|
|
{ MTP_PROPERTY_ALBUM_NAME, MTP_TYPE_STR },
|
|
{ MTP_PROPERTY_ALBUM_ARTIST, MTP_TYPE_STR },
|
|
{ MTP_PROPERTY_TRACK, MTP_TYPE_UINT16 },
|
|
{ MTP_PROPERTY_ORIGINAL_RELEASE_DATE, MTP_TYPE_STR },
|
|
{ MTP_PROPERTY_GENRE, MTP_TYPE_STR },
|
|
{ MTP_PROPERTY_COMPOSER, MTP_TYPE_STR },
|
|
{ MTP_PROPERTY_DURATION, MTP_TYPE_UINT32 },
|
|
{ MTP_PROPERTY_DESCRIPTION, MTP_TYPE_STR },
|
|
{ MTP_PROPERTY_AUDIO_WAVE_CODEC, MTP_TYPE_UINT32 },
|
|
{ MTP_PROPERTY_BITRATE_TYPE, MTP_TYPE_UINT16 },
|
|
{ MTP_PROPERTY_AUDIO_BITRATE, MTP_TYPE_UINT32 },
|
|
{ MTP_PROPERTY_NUMBER_OF_CHANNELS,MTP_TYPE_UINT16 },
|
|
{ MTP_PROPERTY_SAMPLE_RATE, MTP_TYPE_UINT32 },
|
|
};
|
|
|
|
static const PropertyTableEntry kDevicePropertyTable[] = {
|
|
{ MTP_DEVICE_PROPERTY_SYNCHRONIZATION_PARTNER, MTP_TYPE_STR },
|
|
{ MTP_DEVICE_PROPERTY_DEVICE_FRIENDLY_NAME, MTP_TYPE_STR },
|
|
{ MTP_DEVICE_PROPERTY_IMAGE_SIZE, MTP_TYPE_STR },
|
|
{ MTP_DEVICE_PROPERTY_BATTERY_LEVEL, MTP_TYPE_UINT8 },
|
|
{ MTP_DEVICE_PROPERTY_PERCEIVED_DEVICE_TYPE, MTP_TYPE_UINT32 },
|
|
{ MTP_DEVICE_PROPERTY_SESSION_INITIATOR_VERSION_INFO, MTP_TYPE_STR },
|
|
};
|
|
|
|
bool MtpDatabase::getObjectPropertyInfo(MtpObjectProperty property, int& type) {
|
|
int count = sizeof(kObjectPropertyTable) / sizeof(kObjectPropertyTable[0]);
|
|
const PropertyTableEntry* entry = kObjectPropertyTable;
|
|
for (int i = 0; i < count; i++, entry++) {
|
|
if (entry->property == property) {
|
|
type = entry->type;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool MtpDatabase::getDevicePropertyInfo(MtpDeviceProperty property, int& type) {
|
|
int count = sizeof(kDevicePropertyTable) / sizeof(kDevicePropertyTable[0]);
|
|
const PropertyTableEntry* entry = kDevicePropertyTable;
|
|
for (int i = 0; i < count; i++, entry++) {
|
|
if (entry->property == property) {
|
|
type = entry->type;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
MtpObjectHandleList* MtpDatabase::getObjectReferences(MtpObjectHandle handle) {
|
|
JNIEnv* env = AndroidRuntime::getJNIEnv();
|
|
jintArray array = (jintArray)env->CallObjectMethod(mDatabase, method_getObjectReferences,
|
|
(jint)handle);
|
|
if (!array)
|
|
return NULL;
|
|
MtpObjectHandleList* list = new MtpObjectHandleList();
|
|
jint* handles = env->GetIntArrayElements(array, 0);
|
|
jsize length = env->GetArrayLength(array);
|
|
for (int i = 0; i < length; i++)
|
|
list->push_back(handles[i]);
|
|
env->ReleaseIntArrayElements(array, handles, 0);
|
|
env->DeleteLocalRef(array);
|
|
|
|
checkAndClearExceptionFromCallback(env, __FUNCTION__);
|
|
return list;
|
|
}
|
|
|
|
MtpResponseCode MtpDatabase::setObjectReferences(MtpObjectHandle handle,
|
|
MtpObjectHandleList* references) {
|
|
JNIEnv* env = AndroidRuntime::getJNIEnv();
|
|
int count = references->size();
|
|
jintArray array = env->NewIntArray(count);
|
|
if (!array) {
|
|
ALOGE("out of memory in setObjectReferences");
|
|
return false;
|
|
}
|
|
jint* handles = env->GetIntArrayElements(array, 0);
|
|
for (int i = 0; i < count; i++)
|
|
handles[i] = (*references)[i];
|
|
env->ReleaseIntArrayElements(array, handles, 0);
|
|
MtpResponseCode result = env->CallIntMethod(mDatabase, method_setObjectReferences,
|
|
(jint)handle, array);
|
|
env->DeleteLocalRef(array);
|
|
|
|
checkAndClearExceptionFromCallback(env, __FUNCTION__);
|
|
return result;
|
|
}
|
|
|
|
MtpProperty* MtpDatabase::getObjectPropertyDesc(MtpObjectProperty property,
|
|
MtpObjectFormat format) {
|
|
static const int channelEnum[] = {
|
|
1, // mono
|
|
2, // stereo
|
|
3, // 2.1
|
|
4, // 3
|
|
5, // 3.1
|
|
6, // 4
|
|
7, // 4.1
|
|
8, // 5
|
|
9, // 5.1
|
|
};
|
|
static const int bitrateEnum[] = {
|
|
1, // fixed rate
|
|
2, // variable rate
|
|
};
|
|
|
|
MtpProperty* result = NULL;
|
|
switch (property) {
|
|
case MTP_PROPERTY_OBJECT_FORMAT:
|
|
// use format as default value
|
|
result = new MtpProperty(property, MTP_TYPE_UINT16, false, format);
|
|
break;
|
|
case MTP_PROPERTY_PROTECTION_STATUS:
|
|
case MTP_PROPERTY_TRACK:
|
|
result = new MtpProperty(property, MTP_TYPE_UINT16);
|
|
break;
|
|
case MTP_PROPERTY_STORAGE_ID:
|
|
case MTP_PROPERTY_PARENT_OBJECT:
|
|
case MTP_PROPERTY_DURATION:
|
|
case MTP_PROPERTY_AUDIO_WAVE_CODEC:
|
|
result = new MtpProperty(property, MTP_TYPE_UINT32);
|
|
break;
|
|
case MTP_PROPERTY_OBJECT_SIZE:
|
|
result = new MtpProperty(property, MTP_TYPE_UINT64);
|
|
break;
|
|
case MTP_PROPERTY_PERSISTENT_UID:
|
|
result = new MtpProperty(property, MTP_TYPE_UINT128);
|
|
break;
|
|
case MTP_PROPERTY_NAME:
|
|
case MTP_PROPERTY_DISPLAY_NAME:
|
|
case MTP_PROPERTY_ARTIST:
|
|
case MTP_PROPERTY_ALBUM_NAME:
|
|
case MTP_PROPERTY_ALBUM_ARTIST:
|
|
case MTP_PROPERTY_GENRE:
|
|
case MTP_PROPERTY_COMPOSER:
|
|
case MTP_PROPERTY_DESCRIPTION:
|
|
result = new MtpProperty(property, MTP_TYPE_STR);
|
|
break;
|
|
case MTP_PROPERTY_DATE_MODIFIED:
|
|
case MTP_PROPERTY_DATE_ADDED:
|
|
case MTP_PROPERTY_ORIGINAL_RELEASE_DATE:
|
|
result = new MtpProperty(property, MTP_TYPE_STR);
|
|
result->setFormDateTime();
|
|
break;
|
|
case MTP_PROPERTY_OBJECT_FILE_NAME:
|
|
// We allow renaming files and folders
|
|
result = new MtpProperty(property, MTP_TYPE_STR, true);
|
|
break;
|
|
case MTP_PROPERTY_BITRATE_TYPE:
|
|
result = new MtpProperty(property, MTP_TYPE_UINT16);
|
|
result->setFormEnum(bitrateEnum, sizeof(bitrateEnum)/sizeof(bitrateEnum[0]));
|
|
break;
|
|
case MTP_PROPERTY_AUDIO_BITRATE:
|
|
result = new MtpProperty(property, MTP_TYPE_UINT32);
|
|
result->setFormRange(1, 1536000, 1);
|
|
break;
|
|
case MTP_PROPERTY_NUMBER_OF_CHANNELS:
|
|
result = new MtpProperty(property, MTP_TYPE_UINT16);
|
|
result->setFormEnum(channelEnum, sizeof(channelEnum)/sizeof(channelEnum[0]));
|
|
break;
|
|
case MTP_PROPERTY_SAMPLE_RATE:
|
|
result = new MtpProperty(property, MTP_TYPE_UINT32);
|
|
result->setFormRange(8000, 48000, 1);
|
|
break;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
MtpProperty* MtpDatabase::getDevicePropertyDesc(MtpDeviceProperty property) {
|
|
JNIEnv* env = AndroidRuntime::getJNIEnv();
|
|
MtpProperty* result = NULL;
|
|
bool writable = false;
|
|
|
|
// get current value
|
|
jint ret = env->CallIntMethod(mDatabase, method_getDeviceProperty,
|
|
(jint)property, mLongBuffer, mStringBuffer);
|
|
if (ret == MTP_RESPONSE_OK) {
|
|
switch (property) {
|
|
case MTP_DEVICE_PROPERTY_SYNCHRONIZATION_PARTNER:
|
|
case MTP_DEVICE_PROPERTY_DEVICE_FRIENDLY_NAME:
|
|
case MTP_DEVICE_PROPERTY_SESSION_INITIATOR_VERSION_INFO:
|
|
writable = true;
|
|
// fall through
|
|
FALLTHROUGH_INTENDED;
|
|
case MTP_DEVICE_PROPERTY_IMAGE_SIZE:
|
|
{
|
|
result = new MtpProperty(property, MTP_TYPE_STR, writable);
|
|
jchar* str = env->GetCharArrayElements(mStringBuffer, 0);
|
|
result->setCurrentValue(str);
|
|
// for read-only properties it is safe to assume current value is default value
|
|
if (!writable)
|
|
result->setDefaultValue(str);
|
|
env->ReleaseCharArrayElements(mStringBuffer, str, 0);
|
|
break;
|
|
}
|
|
case MTP_DEVICE_PROPERTY_BATTERY_LEVEL:
|
|
{
|
|
result = new MtpProperty(property, MTP_TYPE_UINT8);
|
|
jlong* arr = env->GetLongArrayElements(mLongBuffer, 0);
|
|
result->setFormRange(0, arr[1], 1);
|
|
result->mCurrentValue.u.u8 = (uint8_t) arr[0];
|
|
env->ReleaseLongArrayElements(mLongBuffer, arr, 0);
|
|
break;
|
|
}
|
|
case MTP_DEVICE_PROPERTY_PERCEIVED_DEVICE_TYPE:
|
|
{
|
|
jlong* arr = env->GetLongArrayElements(mLongBuffer, 0);
|
|
result = new MtpProperty(property, MTP_TYPE_UINT32);
|
|
result->mCurrentValue.u.u32 = (uint32_t) arr[0];
|
|
env->ReleaseLongArrayElements(mLongBuffer, arr, 0);
|
|
break;
|
|
}
|
|
default:
|
|
ALOGE("Unrecognized property %x", property);
|
|
}
|
|
} else {
|
|
ALOGE("unable to read device property, response: %04X", ret);
|
|
}
|
|
|
|
checkAndClearExceptionFromCallback(env, __FUNCTION__);
|
|
return result;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
static void
|
|
android_mtp_MtpDatabase_setup(JNIEnv *env, jobject thiz)
|
|
{
|
|
initializeJavaIDs(env);
|
|
MtpDatabase* database = new MtpDatabase(env, thiz);
|
|
env->SetLongField(thiz, field_context, (jlong)database);
|
|
checkAndClearExceptionFromCallback(env, __FUNCTION__);
|
|
}
|
|
|
|
static void
|
|
android_mtp_MtpDatabase_finalize(JNIEnv *env, jobject thiz)
|
|
{
|
|
MtpDatabase* database = (MtpDatabase *)env->GetLongField(thiz, field_context);
|
|
database->cleanup(env);
|
|
delete database;
|
|
env->SetLongField(thiz, field_context, 0);
|
|
checkAndClearExceptionFromCallback(env, __FUNCTION__);
|
|
}
|
|
|
|
static jstring
|
|
android_mtp_MtpPropertyGroup_format_date_time(JNIEnv *env, jobject /*thiz*/, jlong seconds)
|
|
{
|
|
char date[20];
|
|
formatDateTime(seconds, date, sizeof(date));
|
|
return env->NewStringUTF(date);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
static const JNINativeMethod gMtpDatabaseMethods[] = {
|
|
{"native_setup", "()V", (void *)android_mtp_MtpDatabase_setup},
|
|
{"native_finalize", "()V", (void *)android_mtp_MtpDatabase_finalize},
|
|
};
|
|
|
|
static const JNINativeMethod gMtpPropertyGroupMethods[] = {
|
|
{"format_date_time", "(J)Ljava/lang/String;",
|
|
(void *)android_mtp_MtpPropertyGroup_format_date_time},
|
|
};
|
|
\
|
|
int register_android_mtp_MtpDatabase(JNIEnv *env)
|
|
{
|
|
if (AndroidRuntime::registerNativeMethods(env,
|
|
"android/mtp/MtpDatabase", gMtpDatabaseMethods, NELEM(gMtpDatabaseMethods)))
|
|
return -1;
|
|
|
|
return AndroidRuntime::registerNativeMethods(env,
|
|
"android/mtp/MtpPropertyGroup", gMtpPropertyGroupMethods, NELEM(gMtpPropertyGroupMethods));
|
|
}
|