Java Native Interface: Who When Where What Why How

关于Jni的5W+1H，以前没深入，今天总结一篇，做为最近几天的努力的见证。

       JNI是Java Native Interface的缩写，JNI是一种机制，有了它就可以在java程序中调用其他native代码，或者使native代码调用java层的代码。也就是说，有了JNI我们可以使Android项目中，java层与native层各自发挥所长并相互配合。

        JNI相对与native层来说是一个接口，java层的程序想访问native层，必须通过JNI，反过来也一样。下面我们来看几个问题。

1，如何告诉VM（虚拟机）java层需要调用native层的哪些libs？

        我们知道java程序是运行在VM上的，而Native层的libs则不然。所以为了让java层能访问native层的libs，必须得告诉VM要使用哪些native层的libs。下面看一段代码:

public class MediaPlayer  
 {  
     ...  
   
     static {  
         System.loadLibrary("media_jni");  
         native_init();  
     }  
   
      ...  
   
     private native final void native_setup(Object mediaplayer_this);  
        
      ...  
  }

可以看到上面的代码中，在MediaPlayer类中有一段static块包围起来的代码，其中System.loadLibrary("media_jni")就是告诉VM去加载libmedia_jni.so这个动态库，那么这个动态库什么时候被加载呢?因为static语句块的原因，所以在MediaPlayer第一次实例化的时候就会被加载了。这段代码中，我们还看到了一个函数native_init()，该函数被申明为native型，就是告诉VM该函数由native层来实现。

2，如何做到java层到native层的映射。

        事实上我想表达的意思是，如何完成java层的代码到native层代码的映射，例如上面的代码中有一个native函数native_init()，那么如何使这个函数映射到一个由C/C++（或者其他语言）实现的具体函数呢？PS：本菜鸟，表达能力欠缺，不知道大家有没有看明白。

             当VM执行到System.loadLibrary()的时候就会去执行native libs中的JNI_OnLoad(JavaVM* vm, void* reserved)函数，因为JNI_OnLoad函数是从java层进入native层第一个调用的方法，所以可以在JNI_OnLoad函数中完成一些native层组件的初始化工作，同时更加重要的是，通常在JNI_jint JNI_OnLoad(JavaVM* vm, void* reserved)函数中会注册java层的native方法。下面看一段代码：

jint JNI_OnLoad(JavaVM* vm, void* reserved)
{
    JNIEnv* env = NULL;
    jint result = -1;
    //判断一下JNI的版本 
    if (vm->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK) {
        LOGE("ERROR: GetEnv failedn");
        goto bail;
    }
    assert(env != NULL);

    if (register_android_media_MediaPlayer(env) < 0) {
        LOGE("ERROR: MediaPlayer native registration failedn");
        goto bail;
    }

    if (register_android_media_MediaRecorder(env) < 0) {
        LOGE("ERROR: MediaRecorder native registration failedn");
        goto bail;
    }

    if (register<span style="font-size:16px;">_android_media_MediaScanner(env) < 0) {
        LOGE("ERROR: MediaScanner native registration failedn");
        goto bail;
    }</span>

    if (register_android_media_MediaMetadataRetriever(env) < 0) {
        LOGE("ERROR: MediaMetadataRetriever native registration failedn");
        goto bail;
    }

    if (register_android_media_AmrInputStream(env) < 0) {
        LOGE("ERROR: AmrInputStream native registration failedn");
        goto bail;
    }

    if (register_android_media_ResampleInputStream(env) < 0) {
        LOGE("ERROR: ResampleInputStream native registration failedn");
        goto bail;
    }

    if (register_android_media_MediaProfiles(env) < 0) {
        LOGE("ERROR: MediaProfiles native registration failed");
        goto bail;
    }

    /* success -- return valid version number */
    result = JNI_VERSION_1_4;

bail:
    return result;
}

上面这段代码的JNI_OnLoad(JavaVM* vm, void* reserved)函数实现与libmedia_jni.so库中。上面的代码中调用了一些形如register_android_media_MediaPlayer(env)的函数，这些函数的作用是注册native method。我们来看看函数register_android_media_MediaPlayer(env)的实现。

// This function only registers the native methods
static int register_android_media_MediaPlayer(JNIEnv *env)
{
    return AndroidRuntime::registerNativeMethods(env,
                "android/media/MediaPlayer", gMethods, NELEM(gMethods));

/*
 * Register native methods using JNI.
 */
/*static*/ int AndroidRuntime::registerNativeMethods(JNIEnv* env,
    const char* className, const JNINativeMethod* gMethods, int numMethods)
{
    return jniRegisterNativeMethods(env, className, gMethods, numMethods);
}

最终jniRegisterNativeMethods函数完成java标准的native函数的映射工作。下面我们来具体的看看上面这个函数中各个参数的意义。

a，JNIEnv* env，关于JNIEnv我在google上找到了这些信息：

JNI defines two key data structures, "JavaVM" and "JNIEnv". Both of these are essentiallypointers to pointers to function tables. (In the C++ version, they're classes with apointer to a function table and a member function for each JNI function that indirects throughthe table.) The JavaVM provides the "invocation interface" functions,which allow you to create and destroy a JavaVM. In theory you can have multiple JavaVMs per process,but Android only allows one.

The JNIEnv provides most of the JNI functions. Your native functions all receive a JNIEnv asthe first argument.

The JNIEnv is used for thread-local storage. For this reason, you cannot share a JNIEnv between threads.If a piece of code has no other way to get its JNIEnv, you should sharethe JavaVM, and useGetEnv to discover the thread's JNIEnv. (Assuming it has one; see AttachCurrentThreadbelow.)

这里需要注意一点的是，JNIEnv是一个线程的局部变量，这以为这JNIEnv是存在与多线程环境下的，因为 VM 通常是多执行绪(Multi-threading)的执行环境。每一个执行绪在呼叫JNI_OnLoad()时,所传递进来的 JNIEnv 指标值都是不同的。为了配合这种多执行绪的环境,C/C++组件开发者在撰写本地函数时,可藉由 JNIEnv 指标值之不同而避免执行绪的资料冲突问题,才能确保所写的本地函数能安全地在 Android 的多执行绪 VM 里安全地执行。基于这个理由,当在
呼叫 C/C++ 组件的函数时,都会将 JNIEnv 指标值传递给它。

b，char* className，这个没什么好说的，java空间中类名，其中包含了包名。

c，JNINativeMethod* gMethods，传递进去的是一个JNINativeMethod类型的指针gMethods，gMethods指向一个JNINativeMethod数组，我们先看看JNINativeMethod这个结构体。

typedef struct {
 const char* name; /*Java 中函数的名字*/
 const char* signature; /*描述了函数的参数和返回值*/
 void* fnPtr; /*函数指针,指向 C 函数*/
 } JNINativeMethod;

再来看看gMethods数组

static JNINativeMethod gMethods[] = {

    {"setDataSource",       "(Ljava/lang/String;)V",            (void *)android_media_MediaPlayer_setDataSource},
    。。。
    {"setAuxEffectSendLevel", "(F)V",                           (void *)android_media_MediaPlayer_setAuxEffectSendLevel},
    {"attachAuxEffect",     "(I)V",                             (void *)android_media_MediaPlayer_attachAuxEffect},
    {"getOrganDBIndex",     "(II)I",                            (void *)android_media_MediaPlayer_getOrganDBIndex},
};

d，int numMethods，不解释。

这样一来就完成了java native函数到到JNI层函数的映射。当然具体功能实现还是由JNI层函数来调用C/C++相应的功能函数

1，registerNativeMethods()函数使得java空间中的Native函数更加容易的找到对应的本地函数。（通过gMethods[]中的函数指针）

2，可以在执行期间进行本地函数的替换。因为gMethods[]数组是一个<java中函数名字，本地函数指针>的对应表，所以可以在程序的执行过程中，多次呼叫registerNativeMethods()函数来更换本地函数的指针，提高程序的弹性。

函数签名：

       在JNINativeMethod的结构体中，有一个描述函数的参数和返回值的签名字段，它是java中对应函数的签名信息，由参数类型和返回值类型共同组成。这个函数签名信息的作用是什么呢？

       由于java支持函数重载，也就是说，可以定义同名但不同参数的函数。然而仅仅根据函数名是没法找到具体函数的。为了解决这个问题，JNI技术中就将参数类型和返回值类型的组合作为一个函数的签名信息，有了签名信息和函数名，就能顺利的找到java中的函数了。

        JNI规范定义的函数签名信息格式如下：

        (参数1类型标示参数2类型标示......参数n类型标示)返回值类型标示

“()V”
"(II)V"
“(Ljava/lang/String;Ljava/lang/String)V";

 实际上这些字符是与函数的参数类型一一对应的。
        “()” 中的字符表示参数,后面的则代表返回值。例如”()V” 就表示 void Func();
        “(II)V” 表示 void Func(int, int);

        值得注意的一点是，当参数类型是引用数据类型时，其格式是“L包名；”其中包名中的“.” 换成“/”，所以在上面的例子中(Ljava/lang/String;Ljava/lang/String;)V 表示 void Func(String,String)；

         如果 JAVA 函数位于一个嵌入类,则用$作为类名间的分隔符。

         例如 “(Ljava/lang/String;Landroid/os/FileUtils$FileStatus;)Z”

 具体的对应关系见下面两张图：

        数组则以”["开始,用两个字符表示

         以上都是基本数据类型，前面我们解决了JNI函数的注册问题，下面我们来考虑这样一个问题。在java中调用native函数传递的参数是java数据类型，那么这些参数类型到了JNI会变成什么呢? 下面我们引出了一个新的话题——数据类型转换。

数据类型转换：

       在java层调用native函数传递到JNI层的参数，JNI层会做一些特殊处理，我们知道java数据类型分为基本数据类型和引用数据类型两种，JNI层也是区别对待的。下表示出了java数据类型—>native类型的转换。

         其中在java数据类型中，除了java中基本数据类型和数组，Class，String，Throwable，其余所有的java对象的数据类型在JNI中用jobject表示。下面来看一段代码

    {"native_invoke",       "(Landroid/os/Parcel;Landroid/os/Parcel;)I",(void *)android_media_MediaPlayer_invoke},

//java层native_invoke函数有两个参数都是Parcel
private native final int native_invoke(Parcel request, Parcel reply);

//JNI层对应的函数android_media_MediaPlayer_invoke的最后两个参数与native_invoke的参数对应
android_media_MediaPlayer_invoke(JNIEnv *env, jobject thiz,
                                 jobject java_request, jobject java_reply)

       从上面的代码可以看出来，java中的数据类型Parcel在JNI层对应的数据类型为jobejct，在JNI层的对应函数中，我们看到相对java层的native函数来说，多了两个参数JNIEnv *env ，jobject thiz。其中JNIEnv的定义在前一篇blog我们已经介绍过了。第二个参数jobject代表了java层的MediaPlayer对象，它表示在哪个MediaPlayer对象上调用的native_invoke。如果java层是static函数，那么这个参数将是jclass，表示是在调用那个java Class的静态函数。

        还记得前面我们说过，java层和JNI层应该是可以互相交互，我们通过java层中的native函数可以进入到JNI层，那么JNI层的代码能不能操作java层中函数呢？当然可以，通过JNIEnv

JNIEnv再度解析

         先来看看两个函数原型

<span style="color:#000000;">jfieldID GetFieldID(jclass clazz,const char *name,const char *sig );
jmethodID GetMethodID(jclass clazz,const char *name,const char *sig)；</span>

        结合前面的知识来看，JNIEnv是一个与线程相关的代表JNI环境的结构体。JNIEnv实际上提供了一些JNI系统函数。通过这些系统函数可以调用java层中的函数或者操作jobect。下面我看一段函数

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 foundn");
        }
        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");
        }
    }
...

// 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());
    }

可以看到上面的代码中，先找到java层中MediaScannerClinet类在JNI层中对应的jclass实例(通过FindClass)。然后拿到MediaScannerclient类中所需要用到函数的函数函数id(通过GetMethodID)。接着通过JNIEnv调用CallXXXMethod函数并且把对应的jobject，jMethodID还有对应的参数传递进去，这样的通过CallXXXMethod就完成了JNI层向java层的调用。这里要注意一点的是这里JNI层中调用的方法实际上是java中对象的成员函数，如果要调用static函数可以使用CallStaticXXXMethod。这种机制有利于native层回调java代码完成相应操作。

               上面讲述了如下在JNI层中去调用java层的代码，那么理所当然的应该可以在JNI层中访问或者修改java层中某对象的成员变量的值。我们通过JNIEnv中的GetFieldID()函数来得到java中对象的某个域的id。看下面的具体代码

int register_android_backup_BackupHelperDispatcher(JNIEnv* env)
{
    jclass clazz;

    clazz = env->FindClass("java/io/FileDescriptor");
    LOG_FATAL_IF(clazz == NULL, "Unable to find class java.io.FileDescriptor");
    s_descriptorField = env->GetFieldID(clazz, "descriptor", "I");
    LOG_FATAL_IF(s_descriptorField == NULL,
            "Unable to find descriptor field in java.io.FileDescriptor");
    
    clazz = env->FindClass("android/app/backup/BackupHelperDispatcher$Header");
    LOG_FATAL_IF(clazz == NULL,
            "Unable to find class android.app.backup.BackupHelperDispatcher.Header");
    s_chunkSizeField = env->GetFieldID(clazz, "chunkSize", "I");
    LOG_FATAL_IF(s_chunkSizeField == NULL,
            "Unable to find chunkSize field in android.app.backup.BackupHelperDispatcher.Header");
    s_keyPrefixField = env->GetFieldID(clazz, "keyPrefix", "Ljava/lang/String;");
    LOG_FATAL_IF(s_keyPrefixField == NULL,
            "Unable to find keyPrefix field in android.app.backup.BackupHelperDispatcher.Header");
    
    return AndroidRuntime::registerNativeMethods(env, "android/app/backup/BackupHelperDispatcher",
            g_methods, NELEM(g_methods));
}

获得jfieldID之后呢，我们就可以在JNI层之间来访问和操作java层的field的值了，方法如下

NativeType Get<type>Field（JNIEnv *env，jobject object，jfieldID fieldID）

void Set<type>Field(JNIEnv *env,jobject object ,jfieldID fieldID,NativeType value)

注意这里的NativeType值得是jobject，jboolean等等。

        现在我们看到有了JNIEnv，我们可以很轻松的操作jobject所代表的java层中的实际的对象了。

jstring介绍

         之所以要把jstring单独拿出来说正是由于它的特殊性。java中String类型也是一个引用类型，但是JNI中并没有用jobject来与之对应，JNI中单独创建了一个jstring类型来表示java中的String类型。显然java中的String不能和C++中的String等同起来，那么怎么操作jstring呢？方法很多下面看几个简单的方法

1，调用JNIEnv的NewStringUTF将根据Native的一个UTF-8字符串得到一个jstring对象。只有这样才能让一个C++中String在JNI中使用。

2，调用JNIEnv的GetStringChars函数（将得到一个Unicode字符串）和GetStringUTFChars函数（将得到一个UTF-8字符串），他们可以将java String对象转换诚本地字符串。下面我们来看段事例代码。

virtual bool scanFile(const char* path, long long lastModified, long long fileSize)
    {
        jstring pathStr;
        //将char*数组字符串转换诚jstring类型
        if ((pathStr = mEnv->NewStringUTF(path)) == NULL) return false;

        mEnv->CallVoidMethod(mClient, mScanFileMethodID, pathStr, lastModified, fileSize);

        mEnv->DeleteLocalRef(pathStr);
        return (!mEnv->ExceptionCheck());
    }

      ....
      ....
while (env->CallBooleanMethod(iter, hasNext)) {
            jobject entry = env->CallObjectMethod(iter, next);
            jstring key = (jstring) env->CallObjectMethod(entry, getKey);
            jstring value = (jstring) env->CallObjectMethod(entry, getValue);

            const char* keyStr = env->GetStringUTFChars(key, NULL);
            ...
            ...

GetStringUTFChars()函数将jstring类型转换成一个UTF-8本地字符串，另外如果代码中调用了上面的几个函数，则在做完相关工作后，要调用ReleaseStringChars函数或者ReleaseStringUTFChars函数来释放资源。看下面的代码

            ...
            ...
            jstring key = (jstring) env->CallObjectMethod(entry, getKey);
            jstring value = (jstring) env->CallObjectMethod(entry, getValue);

            const char* keyStr = env->GetStringUTFChars(key, NULL);
            if (!keyStr) {  // Out of memory
                jniThrowException(
                        env, "java/lang/RuntimeException", "Out of memory");
                return;
            }

            const char* valueStr = env->GetStringUTFChars(value, NULL);
            if (!valueStr) {  // Out of memory
                jniThrowException(
                        env, "java/lang/RuntimeException", "Out of memory");
                return;
            }

            headersVector.add(String8(keyStr), String8(valueStr));

            env->DeleteLocalRef(entry);
            env->ReleaseStringUTFChars(key, keyStr);
            env->DeleteLocalRef(key);
            ...
            ...

可以看到GetStringUTFChars与下面的ReleaseStringUTFChars对应。

###################################################################################################################
进入bin目录执行：   javah -classpath . -jni package_name.class_name

所有的 JNI 调用都使用了 JNIEnv * 类型的指针，习惯上在 CPP 文件中将这个变量定义为 evn，它是任意一个本地方法的第一个参数。env 指针指向一个函数指针表，在 VC 中可以直接用"->"操作符访问其中的函数。

jobject 指向在此 Java 代码中实例化的 Java 对象 LocalFunction 的一个句柄，相当于 this 指针。

后续的参数就是本地调用中有 Java 程序传进的参数，本例中只有一个 String 型参数。 对于字符串型参数，因为在本地代码中不能直接读取 Java 字符串，而必须将其转换为 C /C++ 字符串或 Unicode。以下是三个我们经常会用到的字符串类型处理的函数：

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

返回指向字符串 UTF 编码的指针，如果不能创建这个字符数组，返回 null。这个指针在调用 ReleaseStringUTFChar() 函数之前一直有效。

参数：string 		 Java 字符串对象
 isCopy 		如果进行拷贝，指向以 JNI_TRUE 填充的 jboolean, 否则指向以 JNI_FALSE 填充的 jboolean。
 void ReleaseStringUTFChars(jstring str, const char* chars) 
通知虚拟机本地代码不再需要通过 chars 访问 Java 字符串。

参数：string 		 Java 字符串对象
 chars 		由 GetStringChars 返回的指针
 jstring NewStringUTF(const char *utf) 
返回一个新的 Java 字符串并将 utf 内容拷贝入新串，如果不能创建字符串对象，
返回 null。通常在反值类型为 string 型时用到。

Android.mk是Android提供的一种makefile文件，用来指定诸如编译生成so库名、引用的头文件目录、需要编译的.c/.cpp文件和.a静态库文件等。要掌握jni，就必须熟练掌握Android.mk的语法规范。

一、Android.mk文件的用途
一个android子项目中会存在一个或多个Android.mk文件
1、单一的Android.mk文件
直接参考NDK的sample目录下的hello-jni项目，在这个项目中只有一个Android.mk文件
2、多个Android.mk文件
如果需要编译的模块比较多，我们可能会将对应的模块放置在相应的目录中，
这样，我们可以在每个目录中定义对应的Android.mk文件（类似于上面的写法），
最后，在根目录放置一个Android.mk文件，内容如下：
include $(call all-subdir-makefiles)
只需要这一行就可以了，它的作用就是包含所有子目录中的Android.mk文件
3、多个模块共用一个Android.mk
这个文件允许你将源文件组织成模块，这个模块中含有：
  -静态库(.a文件)
  -动态库(.so文件)
只有共享库才能被安装/复制到您的应用软件（APK）包中
include $(BUILD_STATIC_LIBRARY)，编译出的是静态库
include $(BUILD_SHARED_LIBRARY)，编译出的是动态库

 

二、自定义变量
 以下是在 Android.mk中依赖或定义的变量列表，可以定义其他变量为自己使用，但是NDK编译系统保留下列变量名：
 -以 LOCAL_开头的名字（例如 LOCAL_MODULE）
 -以 PRIVATE_, NDK_ 或 APP_开头的名字（内部使用）
 -小写名字（内部使用，例如‘my-dir’）
  如果为了方便在 Android.mk 中定义自己的变量，建议使用 MY_前缀，一个小例子：
MY_SOURCES := foo.c
ifneq ($(MY_CONFIG_BAR),)
 MY_SOURCES += bar.c
endif
LOCAL_SRC_FILES += $(MY_SOURCES)
注意：‘:=’是赋值的意思；'+='是追加的意思；‘$’表示引用某变量的值。

 

三、GNU Make系统变量
  这些 GNU Make变量在你的 Android.mk 文件解析之前，就由编译系统定义好了。注意在某些情况下，NDK可能分析 Android.mk 几次，每一次某些变量的定义会有不同。
  （1）CLEAR_VARS:  指向一个编译脚本，几乎所有未定义的 LOCAL_XXX 变量都在"Module-description"节中列出。必须在开始一个新模块之前包含这个脚本：include$(CLEAR_VARS)，用于重置除LOCAL_PATH变量外的，所有LOCAL_XXX系列变量。
  （2）BUILD_SHARED_LIBRARY:  指向编译脚本，根据所有的在 LOCAL_XXX 变量把列出的源代码文件编译成一个共享库。
       注意，必须至少在包含这个文件之前定义 LOCAL_MODULE 和 LOCAL_SRC_FILES。
  （3）BUILD_STATIC_LIBRARY:  一个 BUILD_SHARED_LIBRARY 变量用于编译一个静态库。静态库不会复制到的APK包中，但是能够用于编译共享库。
       示例：include $(BUILD_STATIC_LIBRARY)
       注意，这将会生成一个名为 lib$(LOCAL_MODULE).a 的文件
  （4）TARGET_ARCH: 目标 CPU平台的名字
  （5）TARGET_PLATFORM: Android.mk 解析的时候，目标 Android 平台的名字.详情可考/development/ndk/docs/stable- apis.txt.
       android-3 -> Official Android 1.5 system images
       android-4 -> Official Android 1.6 system images
       android-5 -> Official Android 2.0 system images
  （6）TARGET_ARCH_ABI:  暂时只支持两个 value，armeabi 和 armeabi-v7a。。
  （7）TARGET_ABI: 目标平台和 ABI 的组合，

                               
四、模块描述变量
  下面的变量用于向编译系统描述你的模块。应该定义在'include  $(CLEAR_VARS)'和'include $(BUILD_XXXXX)'之间。$(CLEAR_VARS)是一个脚本，清除所有这些变量。
  （1）LOCAL_PATH:  这个变量用于给出当前文件的路径。
       必须在 Android.mk 的开头定义，可以这样使用：LOCAL_PATH := $(call my-dir)
       如当前目录下有个文件夹名称 src，则可以这样写 $(call src)，那么就会得到 src 目录的完整路径
       这个变量不会被$(CLEAR_VARS)清除，因此每个 Android.mk 只需要定义一次(即使在一个文件中定义了几个模块的情况下)。
  （2）LOCAL_MODULE: 这是模块的名字，它必须是唯一的，而且不能包含空格。
       必须在包含任一的$(BUILD_XXXX)脚本之前定义它。模块的名字决定了生成文件的名字。
  （3）LOCAL_SRC_FILES:  这是要编译的源代码文件列表。
       只要列出要传递给编译器的文件，因为编译系统自动计算依赖。注意源代码文件名称都是相对于 LOCAL_PATH的，你可以使用路径部分，例如：
        LOCAL_SRC_FILES := foo.c toto/bar.c
        Hello.c
       文件之间可以用空格或Tab键进行分割,换行请用""
       如果是追加源代码文件的话，请用LOCAL_SRC_FILES +=
       注意：可以LOCAL_SRC_FILES := $(call all-subdir-java-files)这种形式来包含local_path目录下的所有java文件。
  （4）LOCAL_C_INCLUDES:  可选变量，表示头文件的搜索路径。
        默认的头文件的搜索路径是LOCAL_PATH目录。
  （5）LOCAL_STATIC_LIBRARIES: 表示该模块需要使用哪些静态库，以便在编译时进行链接。
  （6）LOCAL_SHARED_LIBRARIES:  表示模块在运行时要依赖的共享库（动态库），在链接时就需要，以便在生成文件时嵌入其相应的信息。
       注意：它不会附加列出的模块到编译图，也就是仍然需要在Application.mk 中把它们添加到程序要求的模块中。
  （7）LOCAL_LDLIBS:  编译模块时要使用的附加的链接器选项。这对于使用‘-l’前缀传递指定库的名字是有用的。
       例如，LOCAL_LDLIBS := -lz表示告诉链接器生成的模块要在加载时刻链接到/system/lib/libz.so
       可查看 docs/STABLE-APIS.TXT 获取使用 NDK发行版能链接到的开放的系统库列表。
   (8)LOCAL_MODULE_PATH 和 LOCAL_UNSTRIPPED_PATH
       在 Android.mk 文件中， 还可以用LOCAL_MODULE_PATH 和LOCAL_UNSTRIPPED_PATH指定最后的目标安装路径.
       不同的文件系统路径用以下的宏进行选择：
       TARGET_ROOT_OUT：表示根文件系统。
       TARGET_OUT：表示 system文件系统。
       TARGET_OUT_DATA：表示 data文件系统。
       用法如：LOCAL_MODULE_PATH :=$(TARGET_ROOT_OUT)
       至于LOCAL_MODULE_PATH 和LOCAL_UNSTRIPPED_PATH的区别，暂时还不清楚。
   （9）LOCAL_JNI_SHARED_LIBRARIES：定义了要包含的so库文件的名字，如果程序没有采用jni，不需要
        LOCAL_JNI_SHARED_LIBRARIES := libxxx 这样在编译的时候，NDK自动会把这个libxxx打包进apk； 放在youapk/lib/目录下

 

五、NDK提供的函数宏
GNU Make函数宏，必须通过使用'$(call  )'来调用，返回值是文本化的信息。
   （1）my-dir:返回当前 Android.mk 所在的目录的路径，相对于 NDK 编译系统的顶层。这是有用的，在 Android.mk 文件的开头如此定义：
        LOCAL_PATH := $(call my-dir)
   （2）all-subdir-makefiles: 返回一个位于当前'my-dir'路径的子目录中的所有Android.mk的列表。
       例如，某一子项目的目录层次如下：
            src/foo/Android.mk
            src/foo/lib1/Android.mk
            src/foo/lib2/Android.mk
      如果 src/foo/Android.mk 包含一行：
           include $(call all-subdir-makefiles)
      那么它就会自动包含 src/foo/lib1/Android.mk 和 src/foo/lib2/Android.mk。
      这项功能用于向编译系统提供深层次嵌套的代码目录层次。
      注意，在默认情况下，NDK 将会只搜索在 src/*/Android.mk 中的文件。
   （3）this-makefile:  返回当前Makefile 的路径(即这个函数调用的地方)
   （4）parent-makefile:  返回调用树中父 Makefile 路径。即包含当前Makefile的Makefile 路径。
   （5）grand-parent-makefile：返回调用树中父Makefile的父Makefile的路径

 

六、 Android.mk示例
#编译静态库
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE = libhellos
LOCAL_CFLAGS = $(L_CFLAGS)
LOCAL_SRC_FILES = hellos.c
LOCAL_C_INCLUDES = $(INCLUDES)
LOCAL_SHARED_LIBRARIES := libcutils
LOCAL_COPY_HEADERS_TO := libhellos
LOCAL_COPY_HEADERS := hellos.h
include $(BUILD_STATIC_LIBRARY)

#编译动态库
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE = libhellod
LOCAL_CFLAGS = $(L_CFLAGS)
LOCAL_SRC_FILES = hellod.c
LOCAL_C_INCLUDES = $(INCLUDES)
LOCAL_SHARED_LIBRARIES := libcutils
LOCAL_COPY_HEADERS_TO := libhellod
LOCAL_COPY_HEADERS := hellod.h
include $(BUILD_SHARED_LIBRARY)

#使用静态库
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE := hellos
LOCAL_STATIC_LIBRARIES := libhellos
LOCAL_SHARED_LIBRARIES :=
LOCAL_LDLIBS += -ldl
LOCAL_CFLAGS := $(L_CFLAGS)
LOCAL_SRC_FILES := mains.c
LOCAL_C_INCLUDES := $(INCLUDES)
include $(BUILD_EXECUTABLE)

#使用动态库
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE := hellod
LOCAL_MODULE_TAGS := debug
LOCAL_SHARED_LIBRARIES := libc libcutils libhellod
LOCAL_LDLIBS += -ldl
LOCAL_CFLAGS := $(L_CFLAGS)
LOCAL_SRC_FILES := maind.c
LOCAL_C_INCLUDES := $(INCLUDES)
include $(BUILD_EXECUTABLE)

Android.mk给变量赋值，同时用的“:=”和“=”，他们分别代表什么意思呢？

“:=” 的意思是，它右边赋得值如果是变量，只能使用在这条语句之前定义好的，而不能使用本条语句之后定义的变量；

“=”，当它的右边赋值是变量时，这个变量的定义在本条语句之前或之后都可以；

最后

以上就是害怕白云为你收集整理的Java Native Interface: Who When Where What Why How的全部内容，希望文章能够帮你解决Java Native Interface: Who When Where What Why How所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。