android_media_MediaScanner.cpp revision 1a8b6c29aaa5a1591097daca0876808cc029cbda 
1/*
2**
3** Copyright 2007, The Android Open Source Project
4**
5** Licensed under the Apache License, Version 2.0 (the "License");
6** you may not use this file except in compliance with the License.
7** You may obtain a copy of the License at
8**
9**     http://www.apache.org/licenses/LICENSE-2.0
10**
11** Unless required by applicable law or agreed to in writing, software
12** distributed under the License is distributed on an "AS IS" BASIS,
13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14** See the License for the specific language governing permissions and
15** limitations under the License.
16*/
17
18//#define LOG_NDEBUG 0
19#define LOG_TAG "MediaScannerJNI"
20#include <utils/Log.h>
21#include <utils/threads.h>
22#include <utils/Unicode.h>
23#include <media/mediascanner.h>
24#include <media/stagefright/StagefrightMediaScanner.h>
25
26#include "jni.h"
27#include "JNIHelp.h"
28#include "android_runtime/AndroidRuntime.h"
29
30using namespace android;
31
32
33static const char* const kClassMediaScannerClient =
34        "android/media/MediaScannerClient";
35
36static const char* const kClassMediaScanner =
37        "android/media/MediaScanner";
38
39static const char* const kRunTimeException =
40        "java/lang/RuntimeException";
41
42static const char* const kIllegalArgumentException =
43        "java/lang/IllegalArgumentException";
44
45struct fields_t {
46    jfieldID    context;
47};
48static fields_t fields;
49
50static status_t checkAndClearExceptionFromCallback(JNIEnv* env, const char* methodName) {
51    if (env->ExceptionCheck()) {
52        ALOGE("An exception was thrown by callback '%s'.", methodName);
53        LOGE_EX(env);
54        env->ExceptionClear();
55        return UNKNOWN_ERROR;
56    }
57    return OK;
58}
59
60class MyMediaScannerClient : public MediaScannerClient
61{
62public:
63    MyMediaScannerClient(JNIEnv *env, jobject client)
64        :   mEnv(env),
65            mClient(env->NewGlobalRef(client)),
66            mScanFileMethodID(0),
67            mHandleStringTagMethodID(0),
68            mSetMimeTypeMethodID(0)
69    {
70        ALOGV("MyMediaScannerClient constructor");
71        jclass mediaScannerClientInterface =
72                env->FindClass(kClassMediaScannerClient);
73
74        if (mediaScannerClientInterface == NULL) {
75            ALOGE("Class %s not found", kClassMediaScannerClient);
76        } else {
77            mScanFileMethodID = env->GetMethodID(
78                                    mediaScannerClientInterface,
79                                    "scanFile",
80                                    "(Ljava/lang/String;JJZZ)V");
81
82            mHandleStringTagMethodID = env->GetMethodID(
83                                    mediaScannerClientInterface,
84                                    "handleStringTag",
85                                    "(Ljava/lang/String;Ljava/lang/String;)V");
86
87            mSetMimeTypeMethodID = env->GetMethodID(
88                                    mediaScannerClientInterface,
89                                    "setMimeType",
90                                    "(Ljava/lang/String;)V");
91        }
92    }
93
94    virtual ~MyMediaScannerClient()
95    {
96        ALOGV("MyMediaScannerClient destructor");
97        mEnv->DeleteGlobalRef(mClient);
98    }
99
100    virtual status_t scanFile(const char* path, long long lastModified,
101            long long fileSize, bool isDirectory, bool noMedia)
102    {
103        ALOGV("scanFile: path(%s), time(%lld), size(%lld) and isDir(%d)",
104            path, lastModified, fileSize, isDirectory);
105
106        jstring pathStr;
107        if ((pathStr = mEnv->NewStringUTF(path)) == NULL) {
108            mEnv->ExceptionClear();
109            return NO_MEMORY;
110        }
111
112        mEnv->CallVoidMethod(mClient, mScanFileMethodID, pathStr, lastModified,
113                fileSize, isDirectory, noMedia);
114
115        mEnv->DeleteLocalRef(pathStr);
116        return checkAndClearExceptionFromCallback(mEnv, "scanFile");
117    }
118
119    virtual status_t handleStringTag(const char* name, const char* value)
120    {
121        ALOGV("handleStringTag: name(%s) and value(%s)", name, value);
122        jstring nameStr, valueStr;
123        if ((nameStr = mEnv->NewStringUTF(name)) == NULL) {
124            mEnv->ExceptionClear();
125            return NO_MEMORY;
126        }
127
128        // Check if the value is valid UTF-8 string and replace
129        // any un-printable characters with '?' when it's not.
130        char *cleaned = NULL;
131        if (utf8_length(value) == -1) {
132            cleaned = strdup(value);
133            char *chp = cleaned;
134            char ch;
135            while ((ch = *chp)) {
136                if (ch & 0x80) {
137                    *chp = '?';
138                }
139                chp++;
140            }
141            value = cleaned;
142        }
143        valueStr = mEnv->NewStringUTF(value);
144        free(cleaned);
145        if (valueStr == NULL) {
146            mEnv->DeleteLocalRef(nameStr);
147            mEnv->ExceptionClear();
148            return NO_MEMORY;
149        }
150
151        mEnv->CallVoidMethod(
152            mClient, mHandleStringTagMethodID, nameStr, valueStr);
153
154        mEnv->DeleteLocalRef(nameStr);
155        mEnv->DeleteLocalRef(valueStr);
156        return checkAndClearExceptionFromCallback(mEnv, "handleStringTag");
157    }
158
159    virtual status_t setMimeType(const char* mimeType)
160    {
161        ALOGV("setMimeType: %s", mimeType);
162        jstring mimeTypeStr;
163        if ((mimeTypeStr = mEnv->NewStringUTF(mimeType)) == NULL) {
164            mEnv->ExceptionClear();
165            return NO_MEMORY;
166        }
167
168        mEnv->CallVoidMethod(mClient, mSetMimeTypeMethodID, mimeTypeStr);
169
170        mEnv->DeleteLocalRef(mimeTypeStr);
171        return checkAndClearExceptionFromCallback(mEnv, "setMimeType");
172    }
173
174private:
175    JNIEnv *mEnv;
176    jobject mClient;
177    jmethodID mScanFileMethodID;
178    jmethodID mHandleStringTagMethodID;
179    jmethodID mSetMimeTypeMethodID;
180};
181
182
183static MediaScanner *getNativeScanner_l(JNIEnv* env, jobject thiz)
184{
185    return (MediaScanner *) env->GetIntField(thiz, fields.context);
186}
187
188static void setNativeScanner_l(JNIEnv* env, jobject thiz, MediaScanner *s)
189{
190    env->SetIntField(thiz, fields.context, (int)s);
191}
192
193static void
194android_media_MediaScanner_processDirectory(
195        JNIEnv *env, jobject thiz, jstring path, jobject client)
196{
197    ALOGV("processDirectory");
198    MediaScanner *mp = getNativeScanner_l(env, thiz);
199    if (mp == NULL) {
200        jniThrowException(env, kRunTimeException, "No scanner available");
201        return;
202    }
203
204    if (path == NULL) {
205        jniThrowException(env, kIllegalArgumentException, NULL);
206        return;
207    }
208
209    const char *pathStr = env->GetStringUTFChars(path, NULL);
210    if (pathStr == NULL) {  // Out of memory
211        return;
212    }
213
214    MyMediaScannerClient myClient(env, client);
215    MediaScanResult result = mp->processDirectory(pathStr, myClient);
216    if (result == MEDIA_SCAN_RESULT_ERROR) {
217        ALOGE("An error occurred while scanning directory '%s'.", pathStr);
218    }
219    env->ReleaseStringUTFChars(path, pathStr);
220}
221
222static void
223android_media_MediaScanner_processFile(
224        JNIEnv *env, jobject thiz, jstring path,
225        jstring mimeType, jobject client)
226{
227    ALOGV("processFile");
228
229    // Lock already hold by processDirectory
230    MediaScanner *mp = getNativeScanner_l(env, thiz);
231    if (mp == NULL) {
232        jniThrowException(env, kRunTimeException, "No scanner available");
233        return;
234    }
235
236    if (path == NULL) {
237        jniThrowException(env, kIllegalArgumentException, NULL);
238        return;
239    }
240
241    const char *pathStr = env->GetStringUTFChars(path, NULL);
242    if (pathStr == NULL) {  // Out of memory
243        return;
244    }
245
246    const char *mimeTypeStr =
247        (mimeType ? env->GetStringUTFChars(mimeType, NULL) : NULL);
248    if (mimeType && mimeTypeStr == NULL) {  // Out of memory
249        // ReleaseStringUTFChars can be called with an exception pending.
250        env->ReleaseStringUTFChars(path, pathStr);
251        return;
252    }
253
254    MyMediaScannerClient myClient(env, client);
255    MediaScanResult result = mp->processFile(pathStr, mimeTypeStr, myClient);
256    if (result == MEDIA_SCAN_RESULT_ERROR) {
257        ALOGE("An error occurred while scanning file '%s'.", pathStr);
258    }
259    env->ReleaseStringUTFChars(path, pathStr);
260    if (mimeType) {
261        env->ReleaseStringUTFChars(mimeType, mimeTypeStr);
262    }
263}
264
265static void
266android_media_MediaScanner_setLocale(
267        JNIEnv *env, jobject thiz, jstring locale)
268{
269    ALOGV("setLocale");
270    MediaScanner *mp = getNativeScanner_l(env, thiz);
271    if (mp == NULL) {
272        jniThrowException(env, kRunTimeException, "No scanner available");
273        return;
274    }
275
276    if (locale == NULL) {
277        jniThrowException(env, kIllegalArgumentException, NULL);
278        return;
279    }
280    const char *localeStr = env->GetStringUTFChars(locale, NULL);
281    if (localeStr == NULL) {  // Out of memory
282        return;
283    }
284    mp->setLocale(localeStr);
285
286    env->ReleaseStringUTFChars(locale, localeStr);
287}
288
289static jbyteArray
290android_media_MediaScanner_extractAlbumArt(
291        JNIEnv *env, jobject thiz, jobject fileDescriptor)
292{
293    ALOGV("extractAlbumArt");
294    MediaScanner *mp = getNativeScanner_l(env, thiz);
295    if (mp == NULL) {
296        jniThrowException(env, kRunTimeException, "No scanner available");
297        return NULL;
298    }
299
300    if (fileDescriptor == NULL) {
301        jniThrowException(env, kIllegalArgumentException, NULL);
302        return NULL;
303    }
304
305    int fd = jniGetFDFromFileDescriptor(env, fileDescriptor);
306    char* data = mp->extractAlbumArt(fd);
307    if (!data) {
308        return NULL;
309    }
310    long len = *((long*)data);
311
312    jbyteArray array = env->NewByteArray(len);
313    if (array != NULL) {
314        jbyte* bytes = env->GetByteArrayElements(array, NULL);
315        memcpy(bytes, data + 4, len);
316        env->ReleaseByteArrayElements(array, bytes, 0);
317    }
318
319done:
320    free(data);
321    // if NewByteArray() returned NULL, an out-of-memory
322    // exception will have been raised. I just want to
323    // return null in that case.
324    env->ExceptionClear();
325    return array;
326}
327
328// This function gets a field ID, which in turn causes class initialization.
329// It is called from a static block in MediaScanner, which won't run until the
330// first time an instance of this class is used.
331static void
332android_media_MediaScanner_native_init(JNIEnv *env)
333{
334    ALOGV("native_init");
335    jclass clazz = env->FindClass(kClassMediaScanner);
336    if (clazz == NULL) {
337        return;
338    }
339
340    fields.context = env->GetFieldID(clazz, "mNativeContext", "I");
341    if (fields.context == NULL) {
342        return;
343    }
344}
345
346static void
347android_media_MediaScanner_native_setup(JNIEnv *env, jobject thiz)
348{
349    ALOGV("native_setup");
350    MediaScanner *mp = new StagefrightMediaScanner;
351
352    if (mp == NULL) {
353        jniThrowException(env, kRunTimeException, "Out of memory");
354        return;
355    }
356
357    env->SetIntField(thiz, fields.context, (int)mp);
358}
359
360static void
361android_media_MediaScanner_native_finalize(JNIEnv *env, jobject thiz)
362{
363    ALOGV("native_finalize");
364    MediaScanner *mp = getNativeScanner_l(env, thiz);
365    if (mp == 0) {
366        return;
367    }
368    delete mp;
369    setNativeScanner_l(env, thiz, 0);
370}
371
372static JNINativeMethod gMethods[] = {
373    {
374        "processDirectory",
375        "(Ljava/lang/String;Landroid/media/MediaScannerClient;)V",
376        (void *)android_media_MediaScanner_processDirectory
377    },
378
379    {
380        "processFile",
381        "(Ljava/lang/String;Ljava/lang/String;Landroid/media/MediaScannerClient;)V",
382        (void *)android_media_MediaScanner_processFile
383    },
384
385    {
386        "setLocale",
387        "(Ljava/lang/String;)V",
388        (void *)android_media_MediaScanner_setLocale
389    },
390
391    {
392        "extractAlbumArt",
393        "(Ljava/io/FileDescriptor;)[B",
394        (void *)android_media_MediaScanner_extractAlbumArt
395    },
396
397    {
398        "native_init",
399        "()V",
400        (void *)android_media_MediaScanner_native_init
401    },
402
403    {
404        "native_setup",
405        "()V",
406        (void *)android_media_MediaScanner_native_setup
407    },
408
409    {
410        "native_finalize",
411        "()V",
412        (void *)android_media_MediaScanner_native_finalize
413    },
414};
415
416// This function only registers the native methods, and is called from
417// JNI_OnLoad in android_media_MediaPlayer.cpp
418int register_android_media_MediaScanner(JNIEnv *env)
419{
420    return AndroidRuntime::registerNativeMethods(env,
421                kClassMediaScanner, gMethods, NELEM(gMethods));
422}
423