AndroidO 平台JNI机制的学习

116struct _jfieldID;                       /* opaque structure */

117typedef struct _jfieldID* jfieldID;     /* field IDs */

119struct _jmethodID;                      /* opaque structure */

120typedef struct _jmethodID* jmethodID;   /* method IDs */

143typedef struct {

144    const char* name;       //对应Java层native函数的名，例如：processFile

145    const char* signature;  //函数的参数签名信息，使用JNI层定义的类型

146    void*       fnPtr;      // 函数指针，指向JNI层对应函数

147} JNINativeMethod;

149struct _JNIEnv;

150struct _JavaVM; 

151typedef const struct JNINativeInterface* C_JNIEnv;

153#if defined(__cplusplus)   // c++版本条件选择，决定JNIEnv和JavaVM结构体

154    typedef _JNIEnv JNIEnv;

155    typedef _JavaVM JavaVM;

156#else

157  typedef const struct JNINativeInterface* JNIEnv;  // 接口函数指针表

158  typedef const struct JNIInvokeInterface* JavaVM; // JNI调用接口，几个函数

159#endif

161/*

162 * Table of interface function pointers.

163 */

164struct JNINativeInterface {

212    jmethodID   (*GetMethodID)(JNIEnv*, jclass, const char*, const char*);

241    void        (*CallVoidMethod)(JNIEnv*, jobject, jmethodID, ...);

306    jfieldID    (*GetFieldID)(JNIEnv*, jclass, const char*, const char*);

314    jlong       (*GetLongField)(JNIEnv*, jobject, jfieldID);

324    void        (*SetLongField)(JNIEnv*, jobject, jfieldID, jlong);

390    jstring     (*NewStringUTF)(JNIEnv*, const char*);

392    /* JNI spec says this returns const jbyte*, but that's inconsistent */

393    const char* (*GetStringUTFChars)(JNIEnv*, jstring, jboolean*);

497}; // end 结构体

505struct _JNIEnv {

506    /* do not rename this; it does not seem to be entirely opaque */

507    const struct JNINativeInterface* functions;

// …

605    jmethodID GetMethodID(jclass clazz, const char* name, const char* sig)

606        { return functions->GetMethodID(this, clazz, name, sig); }

646    void CallVoidMethod(jobject obj, jmethodID methodID, ...)

647    {

648        va_list args;

649        va_start(args, methodID);

650        functions->CallVoidMethodV(this, obj, methodID, args);

651        va_end(args);

652    }

714    jfieldID GetFieldID(jclass clazz, const char* name, const char* sig)

715         { return functions->GetFieldID(this, clazz, name, sig); }

729    jlong GetLongField(jobject obj, jfieldID fieldID)

730         { return functions->GetLongField(this, obj, fieldID); }

750    void SetLongField(jobject obj, jfieldID fieldID, jlong value)

751         { functions->SetLongField(this, obj, fieldID, value); }

872    jstring NewStringUTF(const char* bytes)

873        { return functions->NewStringUTF(this, bytes); }

878    const char* GetStringUTFChars(jstring string, jboolean* isCopy)

879        { return functions->GetStringUTFChars(this, string, isCopy); }

1067 /* JNI invocation interface.JNI调用接口

1068 */

1069struct JNIInvokeInterface {

1070    void*       reserved0;

1071    void*       reserved1;

1072    void*       reserved2;

1074    jint        (*DestroyJavaVM)(JavaVM*);

1075    jint        (*AttachCurrentThread)(JavaVM*, JNIEnv**, void*);

1076    jint        (*DetachCurrentThread)(JavaVM*);

1077    jint        (*GetEnv)(JavaVM*, void**, jint);

1078    jint        (*AttachCurrentThreadAsDaemon)(JavaVM*, JNIEnv**, void*);

1079};

1081/*

1082 * C++ version.

1083 */

1084struct _JavaVM {

1085    const struct JNIInvokeInterface* functions;

1087#if defined(__cplusplus)

1088    jint DestroyJavaVM()

1089    { return functions->DestroyJavaVM(this); }

1090    jint AttachCurrentThread(JNIEnv** p_env, void* thr_args)

1091    { return functions->AttachCurrentThread(this, p_env, thr_args); }

1092    jint DetachCurrentThread()

1093    { return functions->DetachCurrentThread(this); }

1094    jint GetEnv(void** env, jint version)

1095    { return functions->GetEnv(this, env, version); }

1096    jint AttachCurrentThreadAsDaemon(JNIEnv** p_env, void* thr_args)

1097    { return functions->AttachCurrentThreadAsDaemon(this, p_env, thr_args); }

1098#endif /*__cplusplus*/

1099};

124public class MediaScanner implements AutoCloseable {

125    static {

126        System.loadLibrary("media_jni");

127        native_init();

128    }

2078    private native void processDirectory(String path, MediaScannerClient client);

2079    private native void processFile(String path, String mimeType, MediaScannerClient client);

2080    private native void setLocale(String locale);

2081

2082    public native byte[] extractAlbumArt(FileDescriptor fd);

2083

2084    private static native final void native_init();

2085    private native final void native_setup();

2086    private native final void native_finalize();

1438// This function only registers the native methods

1439static int register_android_media_MediaPlayer(JNIEnv *env)

1440{

1441    return AndroidRuntime::registerNativeMethods(env,

1442                "android/media/MediaPlayer", gMethods, NELEM(gMethods));

1443}

1444extern int register_android_media_ImageReader(JNIEnv *env);

1453extern int register_android_media_MediaMetadataRetriever(JNIEnv *env);

1455extern int register_android_media_MediaRecorder(JNIEnv *env);

1456extern int register_android_media_MediaScanner(JNIEnv *env);

1462extern int register_android_mtp_MtpServer(JNIEnv *env);

459// This function only registers the native methods, and is called from

460// JNI_OnLoad in android_media_MediaPlayer.cpp

461int register_android_media_MediaScanner(JNIEnv *env)

462{

463    return AndroidRuntime::registerNativeMethods(env,

464                kClassMediaScanner, gMethods, NELEM(gMethods));

465}

19#define LOG_TAG "MediaScannerJNI"

20#include <utils/Log.h>

21#include <utils/threads.h>

22#include <media/mediascanner.h>

23#include <media/stagefright/StagefrightMediaScanner.h>

24#include <private/media/VideoFrame.h>

25

26#include "jni.h"

27#include <nativehelper/JNIHelp.h>

28#include "android_runtime/AndroidRuntime.h"

29#include "android_runtime/Log.h"

30

31using namespace android;

32

33

34static const char* const kClassMediaScannerClient =

35        "android/media/MediaScannerClient";

36

37static const char* const kClassMediaScanner =

38        "android/media/MediaScanner";

415static const JNINativeMethod gMethods[] = {

416    {

417        "processDirectory",

418        "(Ljava/lang/String;Landroid/media/MediaScannerClient;)V",

419        (void *)android_media_MediaScanner_processDirectory

420    },

421

422    {

423        "processFile",

424        "(Ljava/lang/String;Ljava/lang/String;Landroid/media/MediaScannerClient;)V",

425        (void *)android_media_MediaScanner_processFile

426    },

427

428    {

429        "setLocale",

430        "(Ljava/lang/String;)V",

431        (void *)android_media_MediaScanner_setLocale

432    },

433

434    {

435        "extractAlbumArt",

436        "(Ljava/io/FileDescriptor;)[B",

437        (void *)android_media_MediaScanner_extractAlbumArt

438    },

439

440    {

441        "native_init",

442        "()V",

443        (void *)android_media_MediaScanner_native_init

444    },

445

446    {

447        "native_setup",

448        "()V",

449        (void *)android_media_MediaScanner_native_setup

450    },

451

452    {

453        "native_finalize",

454        "()V",

455        (void *)android_media_MediaScanner_native_finalize

456    },

457};

282/*

283 * Register native methods using JNI.

284 */

285/*static*/ int AndroidRuntime::registerNativeMethods(JNIEnv* env,

286    const char* className, const JNINativeMethod* gMethods, int numMethods)

287{

288    return jniRegisterNativeMethods(env, className, gMethods, numMethods);

289}

75extern "C" int jniRegisterNativeMethods(C_JNIEnv* env, const char* className,

76    const JNINativeMethod* gMethods, int numMethods)

77{

78    JNIEnv* e = reinterpret_cast<JNIEnv*>(env);

80    ALOGV("Registering %s's %d native methods...", className, numMethods);

82    scoped_local_ref<jclass> c(env, findClass(env, className));

83    if (c.get() == NULL) {

         // 处理打印一些错误的信息

95    }

96

97    if ((*env)->RegisterNatives(e, c.get(), gMethods, numMethods) < 0) {

         // 处理打印一些错误的信息

107    }

109    return 0;

110}

607        public void scanFile(String path, long lastModified, long fileSize,

608                boolean isDirectory, boolean noMedia) {

611            doScanFile(path, null, lastModified, fileSize, isDirectory, false, noMedia);

612        }

private native void processFile(String path, String mimeType, MediaScannerClient client);

267static void android_media_MediaScanner_processFile(

269        JNIEnv *env, jobject thiz, jstring path,

270        jstring mimeType, jobject client)

271{   // env便是运行当前线程的JNI环境JNIEnv， thiz 表示Java层MediaScanner对象

273    // 获取java层MediaScanner对象所对应Native层的MediaScanner.cpp类对象

274    // Lock already hold by processDirectory

275    MediaScanner *mp = getNativeScanner_l(env, thiz);

276    if (mp == NULL) {

277        jniThrowException(env, kRunTimeException, "No scanner available");

278        return;

279    }

281    if (path == NULL) {

282        jniThrowException(env, kIllegalArgumentException, NULL);

283        return;

284    }

285    // 将 JNI类型jstring对象转化为char* 字符串指针类型

286    const char *pathStr = env->GetStringUTFChars(path, NULL);

287    if (pathStr == NULL) {  // Out of memory

288        return;

289    }

291    const char *mimeTypeStr =

292        (mimeType ? env->GetStringUTFChars(mimeType, NULL) : NULL);

293    if (mimeType && mimeTypeStr == NULL) {  // Out of memory

294        // ReleaseStringUTFChars can be called with an exception pending.

295        env->ReleaseStringUTFChars(path, pathStr);

296        return;

297    }

298    // 创建 MediaScannerClient.cpp的子类对象，涉及到 JNIEnv操jobject

299    MyMediaScannerClient myClient(env, client);

300    MediaScanResult result = mp->processFile(pathStr, mimeTypeStr, myClient);

301    if (result == MEDIA_SCAN_RESULT_ERROR) {

302        ALOGE("An error occurred while scanning file '%s'.", pathStr);

303    }

304    env->ReleaseStringUTFChars(path, pathStr);

305    if (mimeType) {

306        env->ReleaseStringUTFChars(mimeType, mimeTypeStr);

307    }

308}

228static MediaScanner *getNativeScanner_l(JNIEnv* env, jobject thiz){

230    return (MediaScanner *) env->GetLongField(thiz, fields.context);

231}

   // 看来native_setup调用，就会创建Native层的MediaScanner.cpp子类对象，并将该对象mp

   // 通过绑定thiz、fields.context设置进去，以便通过相同参数获取。

389static void

390android_media_MediaScanner_native_setup(JNIEnv *env, jobject thiz){

393    MediaScanner *mp = new StagefrightMediaScanner;

       // 设置长整数域，即设置一个对象实例（非静态）域的值

400    env->SetLongField(thiz, fields.context, (jlong)mp);

401}

111    MyMediaScannerClient(JNIEnv *env, jobject client)

112        :   mEnv(env),

113            mClient(env->NewGlobalRef(client))

117    {

118        ALOGV("MyMediaScannerClient constructor");

119        jclass mediaScannerClientInterface =

120                env->FindClass(kClassMediaScannerClient);

125            mScanFileMethodID = env->GetMethodID(

126                                    mediaScannerClientInterface,

127                                    "scanFile",

128                                    "(Ljava/lang/String;JJZZ)V");

135            mSetMimeTypeMethodID = env->GetMethodID(

136                                    mediaScannerClientInterface,

137                                    "setMimeType",

138                                    "(Ljava/lang/String;)V");

140    }

148    virtual status_t scanFile(const char* path, long long lastModified,

149            long long fileSize, bool isDirectory, bool noMedia)

150    {

151        ALOGV("scanFile: path(%s), time(%lld), size(%lld) and isDir(%d)",

152            path, lastModified, fileSize, isDirectory);

154        jstring pathStr;

155        if ((pathStr = mEnv->NewStringUTF(path)) == NULL) {

156            mEnv->ExceptionClear();

157            return NO_MEMORY;

158        }

159      // JNI层调用，反向调用到java层MediaScannerClient类的 scanFile()方法

160        mEnv->CallVoidMethod(mClient, mScanFileMethodID, pathStr, lastModified,

161                fileSize, isDirectory, noMedia);

163        mEnv->DeleteLocalRef(pathStr);

164        return checkAndClearExceptionFromCallback(mEnv, "scanFile");

165    }

204    virtual status_t setMimeType(const char* mimeType)

205    {

206        ALOGV("setMimeType: %s", mimeType);

207        jstring mimeTypeStr;

208        if ((mimeTypeStr = mEnv->NewStringUTF(mimeType)) == NULL) {

209            mEnv->ExceptionClear();

210            return NO_MEMORY;

211        }

212     // JNI层调用，实现调用Java层MediaScannerClient类的 setMimeType()方法

213        mEnv->CallVoidMethod(mClient, mSetMimeTypeMethodID, mimeTypeStr);

214

215        mEnv->DeleteLocalRef(mimeTypeStr);

216        return checkAndClearExceptionFromCallback(mEnv, "setMimeType");

217    }

500    protected class MyMediaScannerClient implements MediaScannerClient

889        public void setMimeType(String mimeType) {

890            if ("audio/mp4".equals(mMimeType) &&

891                    mimeType.startsWith("video")) {

892                // for feature parity with Donut, we force m4a files to keep the

893                // audio/mp4 mimetype, even if they are really "enhanced podcasts"

894                // with a video track

895                return;

896            }

897            mMimeType = mimeType;

898            mFileType = MediaFile.getFileTypeForMimeType(mimeType);

899        }