c37255d5d0
The native media scanner no longer filters files based on file extension. Audio, video, image and playlist files are handled as before, but non-media files are now inserted into the "files" table, which was originally added to support MTP. Change-Id: I9053218fb6d2671a3bb181405c34442b94678afc Signed-off-by: Mike Lockwood <lockwood@android.com>
323 lines
11 KiB
C++
323 lines
11 KiB
C++
/* //device/libs/media_jni/MediaScanner.cpp
|
|
**
|
|
** Copyright 2007, 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 "MediaScanner"
|
|
#include "utils/Log.h"
|
|
|
|
#include <media/mediascanner.h>
|
|
#include <stdio.h>
|
|
#include <assert.h>
|
|
#include <limits.h>
|
|
#include <unistd.h>
|
|
#include <fcntl.h>
|
|
#include <cutils/properties.h>
|
|
#include <utils/threads.h>
|
|
|
|
#include "jni.h"
|
|
#include "JNIHelp.h"
|
|
#include "android_runtime/AndroidRuntime.h"
|
|
|
|
#include <media/stagefright/StagefrightMediaScanner.h>
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
using namespace android;
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
struct fields_t {
|
|
jfieldID context;
|
|
};
|
|
static fields_t fields;
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
class MyMediaScannerClient : public MediaScannerClient
|
|
{
|
|
public:
|
|
MyMediaScannerClient(JNIEnv *env, jobject client)
|
|
: mEnv(env),
|
|
mClient(env->NewGlobalRef(client)),
|
|
mScanFileMethodID(0),
|
|
mHandleStringTagMethodID(0),
|
|
mSetMimeTypeMethodID(0)
|
|
{
|
|
jclass mediaScannerClientInterface = env->FindClass("android/media/MediaScannerClient");
|
|
if (mediaScannerClientInterface == NULL) {
|
|
fprintf(stderr, "android/media/MediaScannerClient not found\n");
|
|
}
|
|
else {
|
|
mScanFileMethodID = env->GetMethodID(mediaScannerClientInterface, "scanFile",
|
|
"(Ljava/lang/String;JJ)V");
|
|
mHandleStringTagMethodID = env->GetMethodID(mediaScannerClientInterface, "handleStringTag",
|
|
"(Ljava/lang/String;Ljava/lang/String;)V");
|
|
mSetMimeTypeMethodID = env->GetMethodID(mediaScannerClientInterface, "setMimeType",
|
|
"(Ljava/lang/String;)V");
|
|
mAddNoMediaFolderMethodID = env->GetMethodID(mediaScannerClientInterface, "addNoMediaFolder",
|
|
"(Ljava/lang/String;)V");
|
|
}
|
|
}
|
|
|
|
virtual ~MyMediaScannerClient()
|
|
{
|
|
mEnv->DeleteGlobalRef(mClient);
|
|
}
|
|
|
|
// returns true if it succeeded, false if an exception occured in the Java code
|
|
virtual bool scanFile(const char* path, long long lastModified, long long fileSize)
|
|
{
|
|
jstring pathStr;
|
|
if ((pathStr = mEnv->NewStringUTF(path)) == NULL) return false;
|
|
|
|
mEnv->CallVoidMethod(mClient, mScanFileMethodID, pathStr, lastModified, fileSize);
|
|
|
|
mEnv->DeleteLocalRef(pathStr);
|
|
return (!mEnv->ExceptionCheck());
|
|
}
|
|
|
|
// returns true if it succeeded, false if an exception occured in the Java code
|
|
virtual bool handleStringTag(const char* name, const char* value)
|
|
{
|
|
jstring nameStr, valueStr;
|
|
if ((nameStr = mEnv->NewStringUTF(name)) == NULL) return false;
|
|
if ((valueStr = mEnv->NewStringUTF(value)) == NULL) return false;
|
|
|
|
mEnv->CallVoidMethod(mClient, mHandleStringTagMethodID, nameStr, valueStr);
|
|
|
|
mEnv->DeleteLocalRef(nameStr);
|
|
mEnv->DeleteLocalRef(valueStr);
|
|
return (!mEnv->ExceptionCheck());
|
|
}
|
|
|
|
// returns true if it succeeded, false if an exception occured in the Java code
|
|
virtual bool setMimeType(const char* mimeType)
|
|
{
|
|
jstring mimeTypeStr;
|
|
if ((mimeTypeStr = mEnv->NewStringUTF(mimeType)) == NULL) return false;
|
|
|
|
mEnv->CallVoidMethod(mClient, mSetMimeTypeMethodID, mimeTypeStr);
|
|
|
|
mEnv->DeleteLocalRef(mimeTypeStr);
|
|
return (!mEnv->ExceptionCheck());
|
|
}
|
|
|
|
// returns true if it succeeded, false if an exception occured in the Java code
|
|
virtual bool addNoMediaFolder(const char* path)
|
|
{
|
|
jstring pathStr;
|
|
if ((pathStr = mEnv->NewStringUTF(path)) == NULL) return false;
|
|
|
|
mEnv->CallVoidMethod(mClient, mAddNoMediaFolderMethodID, pathStr);
|
|
|
|
mEnv->DeleteLocalRef(pathStr);
|
|
return (!mEnv->ExceptionCheck());
|
|
}
|
|
|
|
|
|
private:
|
|
JNIEnv *mEnv;
|
|
jobject mClient;
|
|
jmethodID mScanFileMethodID;
|
|
jmethodID mHandleStringTagMethodID;
|
|
jmethodID mSetMimeTypeMethodID;
|
|
jmethodID mAddNoMediaFolderMethodID;
|
|
};
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
static bool ExceptionCheck(void* env)
|
|
{
|
|
return ((JNIEnv *)env)->ExceptionCheck();
|
|
}
|
|
|
|
static void
|
|
android_media_MediaScanner_processDirectory(JNIEnv *env, jobject thiz, jstring path, jobject client)
|
|
{
|
|
MediaScanner *mp = (MediaScanner *)env->GetIntField(thiz, fields.context);
|
|
|
|
if (path == NULL) {
|
|
jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
|
|
return;
|
|
}
|
|
|
|
const char *pathStr = env->GetStringUTFChars(path, NULL);
|
|
if (pathStr == NULL) { // Out of memory
|
|
jniThrowException(env, "java/lang/RuntimeException", "Out of memory");
|
|
return;
|
|
}
|
|
|
|
MyMediaScannerClient myClient(env, client);
|
|
mp->processDirectory(pathStr, myClient, ExceptionCheck, env);
|
|
env->ReleaseStringUTFChars(path, pathStr);
|
|
}
|
|
|
|
static void
|
|
android_media_MediaScanner_processFile(JNIEnv *env, jobject thiz, jstring path, jstring mimeType, jobject client)
|
|
{
|
|
MediaScanner *mp = (MediaScanner *)env->GetIntField(thiz, fields.context);
|
|
|
|
if (path == NULL) {
|
|
jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
|
|
return;
|
|
}
|
|
|
|
const char *pathStr = env->GetStringUTFChars(path, NULL);
|
|
if (pathStr == NULL) { // Out of memory
|
|
jniThrowException(env, "java/lang/RuntimeException", "Out of memory");
|
|
return;
|
|
}
|
|
const char *mimeTypeStr = (mimeType ? env->GetStringUTFChars(mimeType, NULL) : NULL);
|
|
if (mimeType && mimeTypeStr == NULL) { // Out of memory
|
|
env->ReleaseStringUTFChars(path, pathStr);
|
|
jniThrowException(env, "java/lang/RuntimeException", "Out of memory");
|
|
return;
|
|
}
|
|
|
|
MyMediaScannerClient myClient(env, client);
|
|
mp->processFile(pathStr, mimeTypeStr, myClient);
|
|
env->ReleaseStringUTFChars(path, pathStr);
|
|
if (mimeType) {
|
|
env->ReleaseStringUTFChars(mimeType, mimeTypeStr);
|
|
}
|
|
}
|
|
|
|
static void
|
|
android_media_MediaScanner_setLocale(JNIEnv *env, jobject thiz, jstring locale)
|
|
{
|
|
MediaScanner *mp = (MediaScanner *)env->GetIntField(thiz, fields.context);
|
|
|
|
if (locale == NULL) {
|
|
jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
|
|
return;
|
|
}
|
|
const char *localeStr = env->GetStringUTFChars(locale, NULL);
|
|
if (localeStr == NULL) { // Out of memory
|
|
jniThrowException(env, "java/lang/RuntimeException", "Out of memory");
|
|
return;
|
|
}
|
|
mp->setLocale(localeStr);
|
|
|
|
env->ReleaseStringUTFChars(locale, localeStr);
|
|
}
|
|
|
|
static jbyteArray
|
|
android_media_MediaScanner_extractAlbumArt(JNIEnv *env, jobject thiz, jobject fileDescriptor)
|
|
{
|
|
MediaScanner *mp = (MediaScanner *)env->GetIntField(thiz, fields.context);
|
|
|
|
if (fileDescriptor == NULL) {
|
|
jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
|
|
return NULL;
|
|
}
|
|
|
|
int fd = getParcelFileDescriptorFD(env, fileDescriptor);
|
|
char* data = mp->extractAlbumArt(fd);
|
|
if (!data) {
|
|
return NULL;
|
|
}
|
|
long len = *((long*)data);
|
|
|
|
jbyteArray array = env->NewByteArray(len);
|
|
if (array != NULL) {
|
|
jbyte* bytes = env->GetByteArrayElements(array, NULL);
|
|
memcpy(bytes, data + 4, len);
|
|
env->ReleaseByteArrayElements(array, bytes, 0);
|
|
}
|
|
|
|
done:
|
|
free(data);
|
|
// if NewByteArray() returned NULL, an out-of-memory
|
|
// exception will have been raised. I just want to
|
|
// return null in that case.
|
|
env->ExceptionClear();
|
|
return array;
|
|
}
|
|
|
|
// This function gets a field ID, which in turn causes class initialization.
|
|
// It is called from a static block in MediaScanner, which won't run until the
|
|
// first time an instance of this class is used.
|
|
static void
|
|
android_media_MediaScanner_native_init(JNIEnv *env)
|
|
{
|
|
jclass clazz;
|
|
|
|
clazz = env->FindClass("android/media/MediaScanner");
|
|
if (clazz == NULL) {
|
|
jniThrowException(env, "java/lang/RuntimeException", "Can't find android/media/MediaScanner");
|
|
return;
|
|
}
|
|
|
|
fields.context = env->GetFieldID(clazz, "mNativeContext", "I");
|
|
if (fields.context == NULL) {
|
|
jniThrowException(env, "java/lang/RuntimeException", "Can't find MediaScanner.mNativeContext");
|
|
return;
|
|
}
|
|
}
|
|
|
|
static void
|
|
android_media_MediaScanner_native_setup(JNIEnv *env, jobject thiz)
|
|
{
|
|
MediaScanner *mp = new StagefrightMediaScanner;
|
|
|
|
if (mp == NULL) {
|
|
jniThrowException(env, "java/lang/RuntimeException", "Out of memory");
|
|
return;
|
|
}
|
|
|
|
env->SetIntField(thiz, fields.context, (int)mp);
|
|
}
|
|
|
|
static void
|
|
android_media_MediaScanner_native_finalize(JNIEnv *env, jobject thiz)
|
|
{
|
|
MediaScanner *mp = (MediaScanner *)env->GetIntField(thiz, fields.context);
|
|
|
|
//printf("##### android_media_MediaScanner_native_finalize: ctx=0x%p\n", ctx);
|
|
|
|
if (mp == 0)
|
|
return;
|
|
|
|
delete mp;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
static JNINativeMethod gMethods[] = {
|
|
{"processDirectory", "(Ljava/lang/String;Landroid/media/MediaScannerClient;)V",
|
|
(void *)android_media_MediaScanner_processDirectory},
|
|
{"processFile", "(Ljava/lang/String;Ljava/lang/String;Landroid/media/MediaScannerClient;)V",
|
|
(void *)android_media_MediaScanner_processFile},
|
|
{"setLocale", "(Ljava/lang/String;)V", (void *)android_media_MediaScanner_setLocale},
|
|
{"extractAlbumArt", "(Ljava/io/FileDescriptor;)[B", (void *)android_media_MediaScanner_extractAlbumArt},
|
|
{"native_init", "()V", (void *)android_media_MediaScanner_native_init},
|
|
{"native_setup", "()V", (void *)android_media_MediaScanner_native_setup},
|
|
{"native_finalize", "()V", (void *)android_media_MediaScanner_native_finalize},
|
|
};
|
|
|
|
static const char* const kClassPathName = "android/media/MediaScanner";
|
|
|
|
// This function only registers the native methods, and is called from
|
|
// JNI_OnLoad in android_media_MediaPlayer.cpp
|
|
int register_android_media_MediaScanner(JNIEnv *env)
|
|
{
|
|
return AndroidRuntime::registerNativeMethods(env,
|
|
"android/media/MediaScanner", gMethods, NELEM(gMethods));
|
|
}
|
|
|
|
|