JNI 实战全面解析

标签：des   android   style   blog   http   io   color   os   ar   

简介

项目决定移植一款C++开源项目到Android平台，开始对JNI深入研究。

JNI是什么？

JNI(Java Native Interface)意为JAVA本地调用，它允许Java代码和其他语言写的代码进行交互，简单的说，一种在Java虚拟机控制下执行代码的标准机制。

NDK是什么？

Android NDK（Native Development Kit ）是一套工具集合，允许你用像C/C++语言那样实现应用程序的一部分。

为什么要用NDK？

1、安全性，java是半解释型语言，很容易被反汇编后拿到源代码文件，我们可以在重要的交互功能使用C语言代替。
2、效率，C语言比起java来说效率要高出很多。

JNI和NDK的区别？

从工具上说，NDK其实多了一个把.so和.apk打包的工具，而JNI开发并没有打包，只是把.so文件放到文件系统的特定位置。
从编译库说，NDK开发C/C++只能能使用NDK自带的有限的头文件，而使用JNI则可以使用文件系统中带的头文件。
从编写方式说，它们一样。

详解

1、JNI 元素

1、JNI组织结构

JNI函数表的组成就像C++的虚函数表，虚拟机可以运行多张函数表。
JNI接口指针仅在当前线程中起作用，指针不能从一个线程进入另一个线程，但可以在不同的线程中调用本地方法。

2、原始数据

Jobject  对象 引用类型

函数操作

域描述符

引用类型则为 L + 该类型类描述符 + 。

数组，其为 :  [ + 其类型的域描述符 + 。

多维数组则是 n个[ +该类型的域描述符 , N代表的是几维数组。

String类型的域描述符为 Ljava/lang/String;  

[ + 其类型的域描述符 + ;
int[ ]     其描述符为[I
float[ ]   其描述符为[F
String[ ]  其描述符为[Ljava/lang/String;
Object[ ]类型的域描述符为[Ljava/lang/Object;
int  [ ][ ] 其描述符为[[I
float[ ][ ] 其描述符为[[F

 将参数类型的域描述符按照申明顺序放入一对括号中后跟返回值类型的域描述符，规则如下： (参数的域描述符的叠加)返回类型描述符。对于，没有返回值的，用V(表示void型)表示。
举例如下：

Java层方法                                               JNI函数签名
                String test ( )                                              Ljava/lang/String;
                int f (int i, Object object)                            (ILjava/lang/Object;)I
                void set (byte[ ] bytes)                                ([B)V

JNIEnv与JavaVM 

JNIEnv 概念 : 是一个线程相关的结构体, 该结构体代表了 Java 在本线程的运行环境 ; 

JNIEnv 与 JavaVM : 注意区分这两个概念; 
-- JavaVM : JavaVM 是 Java虚拟机在 JNI 层的代表, JNI 全局只有一个;
-- JNIEnv : JavaVM 在线程中的代表, 每个线程都有一个, JNI 中可能有很多个 JNIEnv;

JNIEnv 作用 : 
-- 调用 Java 函数 : JNIEnv 代表 Java 运行环境, 可以使用 JNIEnv 调用 Java 中的代码;
-- 操作 Java 对象 : Java 对象传入 JNI 层就是 Jobject 对象, 需要使用 JNIEnv 来操作这个 Java 对象;

JNIEnv 体系结构 

线程相关 : JNIEnv 是线程相关的, 即 在 每个线程中 都有一个 JNIEnv 指针, 每个JNIEnv 都是线程专有的, 其它线程不能使用本线程中的 JNIEnv, 线程 A 不能调用 线程 B 的 JNIEnv;

JNIEnv 不能跨线程 : 
-- 当前线程有效 : JNIEnv 只在当前线程有效, JNIEnv 不能在 线程之间进行传递, 在同一个线程中, 多次调用 JNI层方法, 传入的 JNIEnv 是相同的;
-- 本地方法匹配多JNIEnv : 在 Java 层定义的本地方法, 可以在不同的线程调用, 因此 可以接受不同的 JNIEnv;

JNIEnv 结构 : 由上面的代码可以得出, JNIEnv 是一个指针,  指向一个线程相关的结构, 线程相关结构指向 JNI 函数指针 数组, 这个数组中存放了大量的 JNI 函数指针, 这些指针指向了具体的 JNI 函数; 

注意：JNIEnv只在当前线程中有效。本地方法不能将JNIEnv从一个线程传递到另一个线程中。相同的 Java 线程中对本地方法多次调用时，传递给该本地方法的JNIEnv是相同的。但是，一个本地方法可被不同的 Java 线程所调用，因此可以接受不同的 JNIEnv。

UTF-8编码

JNI使用改进的UTF-8字符串来表示不同的字符类型。Java使用UTF-16编码。UTF-8编码主要使用于C语言，因为它的编码用\u000表示为0xc0，而不是通常的0×00。非空ASCII字符改进后的字符串编码中可以用一个字节表示。

错误

JNI不会检查NullPointerException、IllegalArgumentException这样的错误，原因是：导致性能下降。

jthrowable ExceptionOccurred(JNIEnv *env);
例如：一些操作数组的JNI函数不会报错，因此可以调用ArrayIndexOutofBoundsException或ArrayStoreExpection方法报告异常。

3、JNI函数实战

1、*.so的入口函数

JNI_OnLoad()与JNI_OnUnload()
当Android的VM(Virtual Machine)执行到System.loadLibrary()函数时，首先会去执行C组件里的JNI_OnLoad()函数。它的用途有二：
(1)告诉VM此C组件使用那一个JNI版本。如果你的*.so档没有提供JNI_OnLoad()函数，VM会默认该*.so档是使用最老的JNI 1.1版本。由于新版的JNI做了许多扩充，如果需要使用JNI的新版功能，例如JNI 1.4的java.nio.ByteBuffer,就必须藉由JNI_OnLoad()函数来告知VM。
(2)由于VM执行到System.loadLibrary()函数时，就会立即先呼叫JNI_OnLoad()，所以C组件的开发者可以藉由JNI_OnLoad()来进行C组件内的初期值之设定(Initialization) 。

2、返回值

jstring str = env->newStringUTF("HelloJNI");  //直接使用该JNI构造一个jstring对象返回  
    return str ;  

jobjectArray ret = 0;
jsize len = 5;
jstring str;
string value("hello");
 
ret = (jobjectArray)(env->NewObjectArray(len, env->FindClass("java/lang/String"), 0));
for(int i = 0; i < len; i++)
{
    str = env->NewStringUTF(value..c_str());
    env->SetObjectArrayElement(ret, i, str);
}
return ret; 返回数组

 jclass    m_cls   = env->FindClass("com/ldq/ScanResult");  
  
    jmethodID m_mid   = env->GetMethodID(m_cls,"<init>","()V");  
      
    jfieldID  m_fid_1 = env->GetFieldID(m_cls,"ssid","Ljava/lang/String;");  
    jfieldID  m_fid_2 = env->GetFieldID(m_cls,"mac","Ljava/lang/String;");  
    jfieldID  m_fid_3 = env->GetFieldID(m_cls,"level","I");  
  
    jobject   m_obj   = env->NewObject(m_cls,m_mid);  
  
                        env->SetObjectField(m_obj,m_fid_1,env->NewStringUTF("AP1"));  
                        env->SetObjectField(m_obj,m_fid_2,env->NewStringUTF("00-11-22-33-44-55"));  
                        env->SetIntField(m_obj,m_fid_3,-50);  
    return m_obj;  返回自定义对象

jclass list_cls = env->FindClass("Ljava/util/ArrayList;");//获得ArrayList类引用  
  
    if(listcls == NULL)  
    {  
        cout << "listcls is null \n" ;  
    }  
    jmethodID list_costruct = env->GetMethodID(list_cls , "<init>","()V"); //获得得构造函数Id  
  
    jobject list_obj = env->NewObject(list_cls , list_costruct); //创建一个Arraylist集合对象  
    //或得Arraylist类中的 add()方法ID，其方法原型为： boolean add(Object object) ;  
    jmethodID list_add  = env->GetMethodID(list_cls,"add","(Ljava/lang/Object;)Z");   
    
    jclass stu_cls = env->FindClass("Lcom/feixun/jni/Student;");//获得Student类引用  
    //获得该类型的构造函数  函数名为 <init> 返回类型必须为 void 即 V  
    jmethodID stu_costruct = env->GetMethodID(stu_cls , "<init>", "(ILjava/lang/String;)V");  
  
    for(int i = 0 ; i < 3 ; i++)  
    {  
        jstring str = env->NewStringUTF("Native");  
        //通过调用该对象的构造函数来new 一个 Student实例  
        jobject stu_obj = env->NewObject(stucls , stu_costruct , 10,str);  //构造一个对象  
          
        env->CallBooleanMethod(list_obj , list_add , stu_obj); //执行Arraylist类实例的add方法，添加一个stu对象  
    }  
  
    return list_obj ;   返回对象集合

//获得jfieldID 以及 该字段的初始值  
   jfieldID  nameFieldId ;  
  
   jclass cls = env->GetObjectClass(obj);  //获得Java层该对象实例的类引用，即HelloJNI类引用  
  
   nameFieldId = env->GetFieldID(cls , "name" , "Ljava/lang/String;"); //获得属性句柄  
  
   if(nameFieldId == NULL)  
   {  
       cout << " 没有得到name 的句柄Id \n;" ;  
   }  
   jstring javaNameStr = (jstring)env->GetObjectField(obj ,nameFieldId);  // 获得该属性的值  
   const char * c_javaName = env->GetStringUTFChars(javaNameStr , NULL);  //转换为 char *类型  
   string str_name = c_javaName ;    
   cout << "the name from java is " << str_name << endl ; //输出显示  
   env->ReleaseStringUTFChars(javaNameStr , c_javaName);  //释放局部引用  
  
   //构造一个jString对象  
   char * c_ptr_name = "I come from Native" ;  
     
   jstring cName = env->NewStringUTF(c_ptr_name); //构造一个jstring对象  
  
   env->SetObjectField(obj , nameFieldId , cName); // 设置该字段的值 

  jstring str = NULL;  
      
    jclass clz = env->FindClass("cc/androidos/jni/JniTest");  
    //获取clz的构造函数并生成一个对象  
    jmethodID ctor = env->GetMethodID(clz, "<init>", "()V");  
    jobject obj = env->NewObject(clz, ctor);  
  
    // 如果是数组类型，则在类型前加[,如整形数组int[] intArray,则对应类型为[I,整形数组String[] strArray对应为[Ljava/lang/String;  
    jmethodID mid = env->GetMethodID(clz, "sayHelloFromJava", "(Ljava/lang/String;II[I)I");  
    if (mid)  
    {  
        LOGI("mid is get");  
        jstring str1 = env->NewStringUTF("I am Native");  
        jint index1 = 10;  
        jint index2 = 12;  
        //env->CallVoidMethod(obj, mid, str1, index1, index2);  
  
        // 数组类型转换 testIntArray能不能不申请内存空间  
        jintArray testIntArray = env->NewIntArray(10);  
        jint *test = new jint[10];  
        for(int i = 0; i < 10; ++i)  
        {  
            *(test+i) = i + 100;  
        }  
        env->SetIntArrayRegion(testIntArray, 0, 10, test);  
  
  
        jint javaIndex = env->CallIntMethod(obj, mid, str1, index1, index2, testIntArray);  
        LOGI("javaIndex = %d", javaIndex);  
        delete[] test;  
        test = NULL;  
    }  

static void event_callback(int eventId,const char* description) {  //主进程回调可以，线程中回调失败。
	if (gEventHandle == NULL)
		return;
	
	JNIEnv *env;
	bool isAttached = false;

	if (myVm->GetEnv((void**) &env, JNI_VERSION_1_2) < 0) { //获取当前的JNIEnv
		if (myVm->AttachCurrentThread(&env, NULL) < 0)
			return;
		isAttached = true;
	}

	jclass cls = env->GetObjectClass(gEventHandle); //获取类对象
	if (!cls) {
		LOGE("EventHandler: failed to get class reference");
		return;
	}

	jmethodID methodID = env->GetStaticMethodID(cls, "callbackStatic",
		"(ILjava/lang/String;)V");  //静态方法或成员方法
	if (methodID) {
		jstring content = env->NewStringUTF(description);
		env->CallVoidMethod(gEventHandle, methodID,eventId,
			content);
		env->ReleaseStringUTFChars(content,description);
	} else {
		LOGE("EventHandler: failed to get the callback method");
	}

	if (isAttached)
		myVm->DetachCurrentThread();
}

static pthread_t create_thread_callback(const char* name, void (*start)(void *), void* arg)  
{  
    return (pthread_t)AndroidRuntime::createJavaThread(name, start, arg);  
} 


static void checkAndClearExceptionFromCallback(JNIEnv* env, const char* methodName) {  //异常检测和排除
    if (env->ExceptionCheck()) {  
        LOGE("An exception was thrown by callback ‘%s‘.", methodName);  
        LOGE_EX(env);  
        env->ExceptionClear();  
    }  
}  
  
static void receive_callback(unsigned char *buf, int len)  //回调
{  
    int i;  
    JNIEnv* env = AndroidRuntime::getJNIEnv();  
    jcharArray array = env->NewCharArray(len);  
    jchar *pArray ;  
      
    if(array == NULL){  
        LOGE("receive_callback: NewCharArray error.");  
        return;   
    }  
  
    pArray = (jchar*)calloc(len, sizeof(jchar));  
    if(pArray == NULL){  
        LOGE("receive_callback: calloc error.");  
        return;   
    }  
  
    //copy buffer to jchar array  
    for(i = 0; i < len; i++)  
    {  
        *(pArray + i) = *(buf + i);  
    }  
    //copy buffer to jcharArray  
    env->SetCharArrayRegion(array,0,len,pArray);  
    //invoke java callback method  
    env->CallVoidMethod(mCallbacksObj, method_receive,array,len);  
    //release resource  
    env->DeleteLocalRef(array);  
    free(pArray);  
    pArray = NULL;  
      
    checkAndClearExceptionFromCallback(env, __FUNCTION__);  
}


public void Receive(char buffer[],int length){  //java层函数
        String msg = new String(buffer);  
        msg = "received from jni callback" + msg;  
        Log.d("Test", msg);  
    }

  
    jclass cls = env->GetObjectClass(obj);//获得Java类实例  
    jmethodID callbackID = env->GetMethodID(cls , "callback" , "(Ljava/lang/String;)V") ;//或得该回调方法句柄  
  
    if(callbackID == NULL)  
    {  
         cout << "getMethodId is failed \n" << endl ;  
    }  
    
    jstring native_desc = env->NewStringUTF(" I am Native");  
  
    env->CallVoidMethod(obj , callbackID , native_desc); //回调该方法，并且

5、传对象到JNI调用

  jclass stu_cls = env->GetObjectClass(obj_stu); //或得Student类引用  
  
    if(stu_cls == NULL)  
    {  
        cout << "GetObjectClass failed \n" ;  
    }  
    //下面这些函数操作，我们都见过的。O(∩_∩)O~  
    jfieldID ageFieldID = env->GetFieldID(stucls,"age","I"); //获得得Student类的属性id   
    jfieldID nameFieldID = env->GetFieldID(stucls,"name","Ljava/lang/String;"); // 获得属性ID  
  
    jint age = env->GetIntField(objstu , ageFieldID);  //获得属性值  
    jstring name = (jstring)env->GetObjectField(objstu , nameFieldID);//获得属性值  
  
    const char * c_name = env->GetStringUTFChars(name ,NULL);//转换成 char *  
   
    string str_name = c_name ;   
    env->ReleaseStringUTFChars(name,c_name); //释放引用  
      
    cout << " at Native age is :" << age << " # name is " << str_name << endl ;   

jbytearray转c++byte数组

jbyte * arrayBody = env->GetByteArrayElements(data,0);   
jsize theArrayLengthJ = env->GetArrayLength(data);   
BYTE * starter = (BYTE *)arrayBody;   

jbyte * olddata = (jbyte*)env->GetByteArrayElements(strIn, 0);  
jsize  oldsize = env->GetArrayLength(strIn);  
BYTE* bytearr = (BYTE*)olddata;  
int len = (int)oldsize;  

jbyte *by = (jbyte*)pData;  
jbyteArray jarray = env->NewByteArray(nOutSize);  
env->SetByteArrayRegin(jarray, 0, nOutSize, by);  

char* data = (char*)env->GetByteArrayElements(strIn, 0);  

jstring WindowsTojstring(JNIEnv* env, char* str_tmp)  
{  
 jstring rtn=0;  
 int slen = (int)strlen(str_tmp);  
 unsigned short* buffer=0;  
 if(slen == 0)  
 {  
  rtn = env->NewStringUTF(str_tmp);  
 }  
 else  
 {  
  int length = MultiByteToWideChar(CP_ACP, 0, (LPCSTR)str_tmp, slen, NULL, 0);  
  buffer = (unsigned short*)malloc(length*2+1);  
  if(MultiByteToWideChar(CP_ACP, 0, (LPCSTR)str_tmp, slen, (LPWSTR)buffer, length) > 0)  
  {  
   rtn = env->NewString((jchar*)buffer, length);  
  }  
 }  
 if(buffer)  
 {  
  free(buffer);  
 }  
 return rtn;  
}  

JNIEXPORT jstring JNICALL Java_com_explorer_jni_SambaTreeNative_getDetailsBy  
  (JNIEnv *env, jobject jobj, jstring pc_server, jstring server_user, jstring server_passwd)  
{  
    const char *pc = env->GetStringUTFChars(pc_server, NULL);  
    const char *user = env->GetStringUTFChars(server_user, NULL);  
    const char *passwd = env->GetStringUTFChars(server_passwd, NULL);  
    const char *details = smbtree::getPara(pc, user, passwd);  
    jstring jDetails = env->NewStringUTF(details);  
    return jDetails;  
}  

4、Android.mk、Application.mk

1、Android.mk

Android.mk文件是GNU Makefile的一小部分，它用来对Android程序进行编译,Android.mk中的变量都是全局的，解析过程会被定义。

一个Android.mk文件可以编译多个模块，模块包括：APK程序、JAVA库、C\C++应用程序、C\C++静态库、C\C++共享库。

简单实例如下：

LOCAL_PATH := $(call my-dir)  #表示是当前文件的路径
include $(CLEAR_VARS)		#指定让GNU MAKEFILE该脚本为你清除许多 LOCAL_XXX 变量
LOCAL_MODULE:= helloworld	#标识你在 Android.mk 文件中描述的每个模块
MY_SOURCES := foo.c			#自定义变量
ifneq ($(MY_CONFIG_BAR),)
 MY_SOURCES += bar.c
endif
LOCAL_SRC_FILES += $(MY_SOURCES)	#包含将要编译打包进模块中的 C 或 C++源代码文件
include $(BUILD_SHARED_LIBRARY)	#根据LOCAL_XXX系列变量中的值，来编译生成共享库（动态链接库）

GNU Make 功能宏

范例：

2、

编译一个简单的APK

  LOCAL_PATH := $(call my-dir)
  include $(CLEAR_VARS)
  # Build all java files in the java subdirectory
  LOCAL_SRC_FILES := $(call all-subdir-java-files)
  # Name of the APK to build
  LOCAL_PACKAGE_NAME := LocalPackage
  # Tell it to build an APK
  include $(BUILD_PACKAGE)

LOCAL_PATH := $(call my-dir)
  include $(CLEAR_VARS)
  # List of static libraries to include in the package
  LOCAL_STATIC_JAVA_LIBRARIES := static-library
  # Build all java files in the java subdirectory
  LOCAL_SRC_FILES := $(call all-subdir-java-files)
  # Name of the APK to build
  LOCAL_PACKAGE_NAME := LocalPackage
  # Tell it to build an APK
  include $(BUILD_PACKAGE)
 注：LOCAL_STATIC_JAVA_LIBRARIES 后面应是你的APK程序所需要的JAVA库的JAR文件名。

LOCAL_PATH := $(call my-dir)
  include $(CLEAR_VARS)
  # Build all java files in the java subdirectory
  LOCAL_SRC_FILES := $(call all-subdir-java-files)
  # Name of the APK to build
  LOCAL_PACKAGE_NAME := LocalPackage
  LOCAL_CERTIFICATE := platform
  # Tell it to build an APK
  include $(BUILD_PACKAGE)
 注：LOCAL_CERTIFICATE 后面应该是签名文件的文件名

 LOCAL_PATH := $(call my-dir)
  include $(CLEAR_VARS)
  # Build all java files in the java subdirectory
  LOCAL_SRC_FILES := $(call all-subdir-java-files)
  # Name of the APK to build
  LOCAL_PACKAGE_NAME := LocalPackage
  LOCAL_CERTIFICATE := vendor/example/certs/app
  # Tell it to build an APK
  include $(BUILD_PACKAGE)

 LOCAL_PATH := $(call my-dir)
  include $(CLEAR_VARS)
  # Module name should match apk name to be installed.
  LOCAL_MODULE := LocalModuleName
  LOCAL_SRC_FILES := $(LOCAL_MODULE).apk
  LOCAL_MODULE_CLASS := APPS
  LOCAL_MODULE_SUFFIX := $(COMMON_ANDROID_PACKAGE_SUFFIX)
  LOCAL_CERTIFICATE := platform
  include $(BUILD_PREBUILT) 

LOCAL_PATH := $(my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE := baiduinput_android_v1.1_1000e
LOCAL_SRC_FILES := $(LOCAL_MODULE).apk
LOCAL_MODULE_CLASS := APPS
LOCAL_MODULE_SUFFIX := $(COMMON_ANDROID_PACKAGE_SUFFIX)
LOCAL_CERTIFICATE := platform
include $(BUILD_PREBUILT)
 
#################################################################
####### copy the library to /system/lib #########################
#################################################################
include $(CLEAR_VARS)
LOCAL_MODULE := libinputcore.so
LOCAL_MODULE_CLASS := SHARED_LIBRARIES
LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)
LOCAL_SRC_FILES := lib/$(LOCAL_MODULE)
OVERRIDE_BUILD_MODULE_PATH := $(TARGET_OUT_INTERMEDIATE_LIBRARIES)
include $(BUILD_PREBUILT)

  LOCAL_PATH := $(call my-dir)
  include $(CLEAR_VARS)
  # Build all java files in the java subdirectory
  LOCAL_SRC_FILES := $(call all-subdir-java-files)
  # Any libraries that this library depends on
  LOCAL_JAVA_LIBRARIES := android.test.runner
  # The name of the jar file to create
  LOCAL_MODULE := sample
  # Build a static jar file.
  include $(BUILD_STATIC_JAVA_LIBRARY)
注：LOCAL_JAVA_LIBRARIES表示生成的java库的jar文件名。

LOCAL_PATH := $(call my-dir)
#include $(CLEAR_VARS)
LOCAL_SRC_FILES := main.c
LOCAL_MODULE := test_exe
#LOCAL_C_INCLUDES :=
#LOCAL_STATIC_LIBRARIES :=
#LOCAL_SHARED_LIBRARIES :=
include $(BUILD_EXECUTABLE)
注：‘:=’是赋值的意思，‘+=‘是追加的意思，‘$’表示引用某变量的值
LOCAL_SRC_FILES中加入源文件路径，LOCAL_C_INCLUDES中加入需要的头文件搜索路径
LOCAL_STATIC_LIBRARIES 加入所需要链接的静态库(*.a)的名称，
LOCAL_SHARED_LIBRARIES 中加入所需要链接的动态库(*.so)的名称，
LOCAL_MODULE表示模块最终的名称，BUILD_EXECUTABLE 表示以一个可执行程序的方式进行编译。
（4）编译C\C++静态库
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_SRC_FILES :=  helloworld.c
LOCAL_MODULE:= libtest_static
 #LOCAL_C_INCLUDES :=
#LOCAL_STATIC_LIBRARIES :=
#LOCAL_SHARED_LIBRARIES :=
include $(BUILD_STATIC_LIBRARY)
和上面相似，BUILD_STATIC_LIBRARY 表示编译一个静态库。

LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_SRC_FILES := helloworld.c
LOCAL_MODULE := libtest_shared
TARGET_PRELINK_MODULES := false
#LOCAL_C_INCLUDES :=
#LOCAL_STATIC_LIBRARIES :=
#LOCAL_SHARED_LIBRARIES :=
include $(BUILD_SHARED_LIBRARY)
和上面相似，BUILD_SHARED_LIBRARY 表示编译一个共享库。
以上三者的生成结果分别在如下目录中，generic 依具体 target 会变：
out/target/product/generic/obj/APPS
out/target/product/generic/obj/JAVA_LIBRARIES
out/target/product/generic/obj/EXECUTABLE
out/target/product/generic/obj/STATIC_LIBRARY
out/target/product/generic/obj/SHARED_LIBRARY
每个模块的目标文件夹分别为：
1）APK程序：XXX_intermediates
2）JAVA库程序：XXX_intermediates
这里的XXX
 3）C\C++可执行程序：XXX_intermediates
 4）C\C++静态库： XXX_static_intermediates
 5）C\C++动态库： XXX_shared_intermediates

实例：

LOCAL_PATH := $(call my-dir)  #项目地址
include $(CLEAR_VARS)		#清除变量

LOCAL_MODULE    := libvlcjni	#库

#源文件
LOCAL_SRC_FILES := libvlcjni.c libvlcjni-util.c libvlcjni-track.c libvlcjni-medialist.c aout.c vout.c libvlcjni-equalizer.c native_crash_handler.c
LOCAL_SRC_FILES += thumbnailer.c pthread-condattr.c pthread-rwlocks.c pthread-once.c eventfd.c sem.c
LOCAL_SRC_FILES += pipe2.c
LOCAL_SRC_FILES += wchar/wcpcpy.c
LOCAL_SRC_FILES += wchar/wcpncpy.c
LOCAL_SRC_FILES += wchar/wcscasecmp.c
LOCAL_SRC_FILES += wchar/wcscat.c
LOCAL_SRC_FILES += wchar/wcschr.c
LOCAL_SRC_FILES += wchar/wcscmp.c
LOCAL_SRC_FILES += wchar/wcscoll.c
LOCAL_SRC_FILES += wchar/wcscpy.c
LOCAL_SRC_FILES += wchar/wcscspn.c
LOCAL_SRC_FILES += wchar/wcsdup.c
LOCAL_SRC_FILES += wchar/wcslcat.c
LOCAL_SRC_FILES += wchar/wcslcpy.c
LOCAL_SRC_FILES += wchar/wcslen.c
LOCAL_SRC_FILES += wchar/wcsncasecmp.c
LOCAL_SRC_FILES += wchar/wcsncat.c
LOCAL_SRC_FILES += wchar/wcsncmp.c
LOCAL_SRC_FILES += wchar/wcsncpy.c
LOCAL_SRC_FILES += wchar/wcsnlen.c
LOCAL_SRC_FILES += wchar/wcspbrk.c
LOCAL_SRC_FILES += wchar/wcsrchr.c
LOCAL_SRC_FILES += wchar/wcsspn.c
LOCAL_SRC_FILES += wchar/wcsstr.c
LOCAL_SRC_FILES += wchar/wcstok.c
LOCAL_SRC_FILES += wchar/wcswidth.c
LOCAL_SRC_FILES += wchar/wcsxfrm.c
LOCAL_SRC_FILES += wchar/wmemchr.c
LOCAL_SRC_FILES += wchar/wmemcmp.c
LOCAL_SRC_FILES += wchar/wmemcpy.c
LOCAL_SRC_FILES += wchar/wmemmove.c
LOCAL_SRC_FILES += wchar/wmemset.c


LOCAL_C_INCLUDES := $(VLC_SRC_DIR)/include	#包含头

ARCH=$(ANDROID_ABI) #变量 平台

CPP_STATIC=$(ANDROID_NDK)/sources/cxx-stl/gnu-libstdc++$(CXXSTL)/libs/$(ARCH)/libgnustl_static.a #应用静态库

LOCAL_CFLAGS := -std=gnu99  #编译器标识
ifeq ($(ARCH), armeabi)
	LOCAL_CFLAGS += -DHAVE_ARMEABI
	# Needed by ARMv6 Thumb1 (the System Control coprocessor/CP15 is mandatory on ARMv6)
	# On newer ARM architectures we can use Thumb2
	LOCAL_ARM_MODE := arm
endif
ifeq ($(ARCH), armeabi-v7a)
	LOCAL_CFLAGS += -DHAVE_ARMEABI_V7A
endif
LOCAL_LDLIBS := -L$(VLC_CONTRIB)/lib \	#使用本地库
	$(VLC_MODULES) 	$(VLC_BUILD_DIR)/lib/.libs/libvlc.a 	$(VLC_BUILD_DIR)/src/.libs/libvlccore.a 	$(VLC_BUILD_DIR)/compat/.libs/libcompat.a 	-ldl -lz -lm -llog 	-ldvbpsi -lebml -lmatroska -ltag 	-logg -lFLAC -ltheora -lvorbis 	-lmpeg2 -la52 	-lavformat -lavcodec -lswscale -lavutil -lpostproc -lgsm -lopenjpeg 	-lliveMedia -lUsageEnvironment -lBasicUsageEnvironment -lgroupsock 	-lspeex -lspeexdsp 	-lxml2 -lpng -lgnutls -lgcrypt -lgpg-error 	-lnettle -lhogweed -lgmp 	-lfreetype -liconv -lass -lfribidi -lopus 	-lEGL -lGLESv2 -ljpeg 	-ldvdnav -ldvdread -ldvdcss 	$(CPP_STATIC)

include $(BUILD_SHARED_LIBRARY) #编译成动态库


include $(CLEAR_VARS)	#清除变量

LOCAL_MODULE     := libiomx-gingerbread  
LOCAL_SRC_FILES  := ../$(VLC_SRC_DIR)/modules/codec/omxil/iomx.cpp
LOCAL_C_INCLUDES := $(VLC_SRC_DIR)/modules/codec/omxil $(ANDROID_SYS_HEADERS_GINGERBREAD)/frameworks/base/include $(ANDROID_SYS_HEADERS_GINGERBREAD)/system/core/include
LOCAL_CFLAGS     := -Wno-psabi
LOCAL_LDLIBS     := -L$(ANDROID_LIBS) -lgcc -lstagefright -lmedia -lutils -lbinder

include $(BUILD_SHARED_LIBRARY)

include $(CLEAR_VARS)

LOCAL_MODULE     := libiomx-hc
LOCAL_SRC_FILES  := ../$(VLC_SRC_DIR)/modules/codec/omxil/iomx.cpp
LOCAL_C_INCLUDES := $(VLC_SRC_DIR)/modules/codec/omxil $(ANDROID_SYS_HEADERS_HC)/frameworks/base/include $(ANDROID_SYS_HEADERS_HC)/frameworks/base/native/include $(ANDROID_SYS_HEADERS_HC)/system/core/include $(ANDROID_SYS_HEADERS_HC)/hardware/libhardware/include
LOCAL_CFLAGS     := -Wno-psabi
LOCAL_LDLIBS     := -L$(ANDROID_LIBS) -lgcc -lstagefright -lmedia -lutils -lbinder

include $(BUILD_SHARED_LIBRARY)

include $(CLEAR_VARS)

LOCAL_MODULE     := libiomx-ics
LOCAL_SRC_FILES  := ../$(VLC_SRC_DIR)/modules/codec/omxil/iomx.cpp
LOCAL_C_INCLUDES := $(VLC_SRC_DIR)/modules/codec/omxil $(ANDROID_SYS_HEADERS_ICS)/frameworks/base/include $(ANDROID_SYS_HEADERS_ICS)/frameworks/base/native/include $(ANDROID_SYS_HEADERS_ICS)/system/core/include $(ANDROID_SYS_HEADERS_ICS)/hardware/libhardware/include
LOCAL_CFLAGS     := -Wno-psabi
LOCAL_LDLIBS     := -L$(ANDROID_LIBS) -lgcc -lstagefright -lmedia -lutils -lbinder

include $(BUILD_SHARED_LIBRARY)

2、Application.mk

Application.mk目的是描述在你的应用程序中所需要的模块(即静态库或动态库)。

实例：

APP_OPTIM := release   //调试版还是发行版
APP_PLATFORM := android-8  //平台
APP_STL := gnustl_static  //C++运行时库
APP_CPPFLAGS += -frtti		//编译标识
APP_CPPFLAGS += -fexceptions  //编译标识 异常
APP_CPPFLAGS += -DANDROID	//编译标识
APP_MODULES := test		//静态模块

JNI内存泄漏

JAVA 编程中的内存泄漏，从泄漏的内存位置角度可以分为两种：JVM 中 Java Heap 的内存泄漏；JVM 内存中 native memory 的内存泄漏。

Java Heap 的内存泄漏：

JVM 中 native memory 的内存泄漏

Native Code 本身的内存泄漏

Global Reference 引入的内存泄漏

LocalReference 的深入理解

Java 代码部分
 class TestLocalReference { 
 private native void nativeMethod(int i); 
 public static void main(String args[]) { 
         TestLocalReference c = new TestLocalReference(); 
         //call the jni native method 
         c.nativeMethod(1000000); 
 }  
 static { 
 //load the jni library 
 System.loadLibrary("StaticMethodCall"); 
 } 
 } 


 JNI 代码，nativeMethod(int i) 的 C 语言实现
 #include<stdio.h> 
 #include<jni.h> 
 #include"TestLocalReference.h"
 JNIEXPORT void JNICALL Java_TestLocalReference_nativeMethod 
 (JNIEnv * env, jobject obj, jint count) 
 { 
 jint i = 0; 
 jstring str; 


 for(; i<count; i++) 
         str = (*env)->NewStringUTF(env, "0"); 
 } 
运行结果
 JVMCI161: FATAL ERROR in native method: Out of memory when expanding 
 local ref table beyond capacity 
 at TestLocalReference.nativeMethod(Native Method) 
 at TestLocalReference.main(TestLocalReference.java:9)

JNI 代码，nativeMethod(int i) 的 C 语言实现
 #include<stdio.h> 
 #include<jni.h> 
 #include"TestLocalReference.h"
 jstring CreateStringUTF(JNIEnv * env) 
 { 
 return (*env)->NewStringUTF(env, "0"); 
 } 
 JNIEXPORT void JNICALL Java_TestLocalReference_nativeMethod 
 (JNIEnv * env, jobject obj, jint count) 
 { 
 jint i = 0; 
 for(; i<count; i++) 
 { 
         str = CreateStringUTF(env); 
 } 
 } 
运行结果
 JVMCI161: FATAL ERROR in native method: Out of memory when expanding local ref 
 table beyond  capacity 
 at TestLocalReference.nativeMethod(Native Method) 
 at TestLocalReference.main(TestLocalReference.java:9)

编译问题：SLES/OpenSLES.h: No such file or directory
解决方法：ndk-build TARGET_PLATFORM=android-9

编译断点问题：有没有好用的断点工具

解决方法：visualGDB 神器

JNI 实战全面解析

标签：des   android   style   blog   http   io   color   os   ar   

原文地址：http://blog.csdn.net/banketree/article/details/40535325