基于CMake的JNI开发探索

实际项目中用到了JNI，在此对碰到的坑做一些总结。android studio2.2支持android.mk和CMake编译配置工具两种方式，谷歌官方推荐使用CMake并且做了很好的支持。

首先，需要配置ndk环境：
File->Settings->Appearance&Behavior->System Setings->Android SDK，选中SDK Tools标签页，选择CMake，LLDB，NDK进行安装如下图：
CMake：编译配置工具。
LLDB：调试C代码。
NDK：开发工具包。

下载完成后查看 File->Project Structure，是否配置ndk：
（如果没有就配置一下）

好了NDK环境配置完成，接下来重启IDE，新建一个jni工程：

需要勾选include c++ support，项目就可以进行ndk开发

C++ Standard
指定编译库的环境，其中Toolchain Default使用的是默认的CMake环境。建议选择C++ 11，表示支持C++ 11库。

Exceptions Support
如果选中复选框，则表示当前项目支持C++异常处理，建议勾选。

Runtime Type Information Support
同理，选中复选框，项目支持RTTI，建议勾选。

（注：当然此处不勾选，也可以在项目中的gradle下添加支持）

好了，项目新建完成，查看项目的结构：
cpp目录：用于存放c/c++文件。
CMakeLists.txt：CMake的配置文件。

---

直入主题，首先删掉了android studio给我们的hellow示例。新建了一个JNIManager单例类，用于存放native接口；定义了一个头文件native-lib.h（cpp目录下）。

public class JNIManager {    static {        System.loadLibrary("native-lib");    }    private static JNIManager mJNIManger = null;    private JNIManager() {    }    public static JNIManager getInstance() {        if (mJNIManger == null) {            synchronized (JNIManager.class) {                if (mJNIManger == null) {                    mJNIManger = new JNIManager();                }            }        }        return mJNIManger;    }    public native int add(int x, int y);//java传入int值给C，C返回int值给java    public static native String passString(String str);//传入String值，返回String值    public static native int[] passIntArray(int[] intArray);//传入int数组，返回int数组    public native void passOthers(char m_char, boolean m_boolean, byte m_byte, short m_short, long m_long, float m_float, double m_double);//传入其他基本数据类型，无返回值}

其中，

static {        System.loadLibrary("native-lib");    }

表示导入native-lib的库文件，以便使用库中的api。其接口都用native声明（static修饰符可加可不加），在声明接口后，用快捷键可在cpp生成相应的函数，如下：

#include "native-lib.h"JNIEXPORT jint JNICALLJava_com_hecc_jnitest_JNIManager_add(JNIEnv *env, jobject instance, jint x, jint y) {    return x + y;//返回x，y的和}JNIEXPORT jstring JNICALLJava_com_hecc_jnitest_JNIManager_passString(JNIEnv *env, jclass type, jstring m_str) {    char *str = (char *) env->GetStringUTFChars(m_str, 0);//将java中的String类型的值转化成C识别的char*类型的值    // 对字符串进行（移位）处理    int length = strlen(str);    for (int i = 0; i < length; ++i) {        *(str + i) += 1;    }    env->ReleaseStringUTFChars(m_str, str);//释放内存    return env->NewStringUTF(str);//返回一个处理后的字符串}JNIEXPORT jintArray JNICALLJava_com_hecc_jnitest_JNIManager_passIntArray(JNIEnv *env, jclass type, jintArray m_intArray) {    jint *intArray = env->GetIntArrayElements(m_intArray, NULL);//获取数组的指针    jsize length = env->GetArrayLength(m_intArray);//获取数组长度    // 对数组进行（元素+10）处理    for (int i = 0; i < length; i++) {        *(intArray + i) += 10;    }    env->ReleaseIntArrayElements(m_intArray, intArray, 0);//释放内存    return m_intArray;//返回一个处理后的数组}JNIEXPORT void JNICALLJava_com_hecc_jnitest_JNIManager_passOthers(JNIEnv *env, jobject instance, jchar m_char,                                            jboolean m_boolean, jbyte m_byte, jshort m_short,                                            jlong m_long, jfloat m_float, jdouble m_double) {    LOGI("m_char=%c,m_boolean=%d,m_byte=%d,m_short=%hd,m_long=%ld,m_float=%f,m_double=%lf",         m_char, m_boolean, m_byte, m_short, m_long, m_float, m_double);    LOGE("打印：LOGE");}

简单说明下，ndk环境下的书写格式都是固定的。
C本地函数命名规则： Java_包名类名本地方法名
JNIEXPORT，JNICALL：是系统定义的宏，JNIEXPORT后面写函数的输出类型，JNICALL后面写函数名，实测这两个宏可写可不写。
JNIEnv *env： 是结构体JNINativeInterface的二级指针，重定义了大量的函数指针，这些函数指针在jni开发中很常用。可以理解为JNI的上下文环境，需要通过env调用各种接口。
jobject instance :调用本地函数的java对象，在此例中就是JNIManager的实例。

为了代码清晰，我把函数的声明放在头文件native-lib.h，如下：
（注：extern “C”里写函数声明，这一步也是必须的，否则将报错：cant find method）

#ifndef JNITEST_NATIVE_LIB_H#define JNITEST_NATIVE_LIB_H#include <jni.h>#include <string>#include <android/log.h>#define  LOG_TAG    "System.out.fromC"#define  LOGI(...)  __android_log_print(ANDROID_LOG_INFO,LOG_TAG,__VA_ARGS__)#define  LOGE(...)  __android_log_print(ANDROID_LOG_ERROR,LOG_TAG,__VA_ARGS__)extern "C" {JNIEXPORT jint JNICALL        Java_com_hecc_jnitest_JNIManager_add(JNIEnv *env, jobject instance, jint x, jint y);JNIEXPORT jstring JNICALL        Java_com_hecc_jnitest_JNIManager_passString(JNIEnv *env, jclass type, jstring str_);JNIEXPORT jintArray JNICALL        Java_com_hecc_jnitest_JNIManager_passIntArray(JNIEnv *env, jclass type, jintArray intArray_);JNIEXPORT void JNICALL              Java_com_hecc_jnitest_JNIManager_passOthers(JNIEnv *env, jobject instance,               jchar m_char, jboolean m_boolean, jbyte m_byte, jshort m_short, jlong m_long,               jfloat m_float, jdouble m_double);}#endif

然后在MainActivity写测试JNI的代码，如下：

public class MainActivity extends AppCompatActivity {    JNIManager manager = JNIManager.getInstance();    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_main);        testJNI();    }    private void testJNI() {        int sum = manager.add(3, 4);        Log.i("MainActivity", "3+4=" + sum);        String str = JNIManager.passString("abc");        Log.i("MainActivity", "abc from C:" + str);        int[] arr = {1, 2, 3};        int[] newArr = manager.passIntArray(arr);        printArr(arr);//打印原数组        printArr(newArr);//打印JNI处理后的新数组    }    void printArr(int[] arr) {        for (int i = 0; i < arr.length; i++) {            Log.i("MainActivity", "元素" + i + "=" + arr[i]);        }    }}

打印的结果如图：

查看结果正确，调用jni函数成功！值得注意的是，此处我打印了两次数组，发现原数组和新数组的结果一致。是不是很意外，其实不难理解，原数组传给C后（对照代码），获取原数组的指针和长度，然后是对其内存地址进行操作。然后返回值是操作后的原数组（所谓的新数组）。因此，两则结果一致就有理可据了，类似思想在JNI中会大量的用到。

可能大家会有疑问，如何在NDK环境中打印LOG？
答：需要调用系统库，在CMakeList.txt中配置相关log库（模板demo已配置好），然后在头文件中定义相关宏，如下：

上面C代码中是不是还有一个函数未测试，接下来在MainActivity中添加如下代码：

 char m_char = 'a'; boolean m_boolean = true; byte m_byte = 1; short m_short = 2; long m_long = 30000000000L; float m_float = 1.2F; double m_double = 3.333D; manager.passOthers(m_char, m_boolean, m_byte, m_short, m_long, m_float, m_double);

发现效果还可以，以后就方便在C中打log了。（注：C的基本数据没有boolean类型，所以java中true对应C中是1，false对应C中是0）

现在，我打算在java中写JNIBean类，存放各种数据类型；在C++中写一个CppBean.cpp和CppBean.h，用于和java数据进行交互。将java的实体类创建对象并赋值，传递给本地，再赋值给c++的映射的单例对象，大致的流程就是java–>ndk–>c/c++。
在cpp目录添加C/C++文件时，需要CMakeList.txt中进行配置，如下：

你可能会觉得上图和自己的文件不一致，CMake语法中#是注释，所以我将原注释删除，写了中文注释。然后添加一行代码：src/main/cpp/CppBean.cpp。（对CMake语法不做说明）接着，点击按钮 Tools->Android->Sync Project with Gradle Files 进行同步。

JNIBean的代码，如下：

public class JNIBean {    public static int jb_int;//静态变量    public boolean   jb_boolean;    public byte      jb_byte;    public short     jb_short;    public long      jb_long;    public float     jb_float;    public double    jb_double;    public String    jb_str;    public int[]     jb_intArr;}

CppBean.h的代码，如下：

#ifndef JNITEST_CPPBEAN_H#define JNITEST_CPPBEAN_H#include <string>using namespace std;#define MCppBean  (CppBean::GetInstance())typedef signed char Bool;#define MPTrue          1#define MPFalse         0typedef unsigned char Byte;class CppBean {public:    int getcpp_int() const;    void setcpp_int(int jb_int);    Bool getcpp_Bool() const;    void setcpp_Bool(Bool jb_boolean);    Byte getcpp_byte() const;    void setcpp_byte(Byte jb_byte);    short getcpp_short() const;    void setcpp_short(short jb_short);    long getcpp_long() const;    void setcpp_long(long jb_long);    float getcpp_float() const;    void setcpp_float(float jb_float);    double getcpp_double() const;    void setcpp_double(double jb_double);    string getcpp_str() const;    void setcpp_str(char *str);    int *getcpp_intArr();    void setcpp_intArr(int *intArr, int length);public:    static CppBean &GetInstance() {        static CppBean instance;        return instance;    }    virtual ~CppBean();private:    CppBean();    CppBean(const CppBean &);    CppBean &operator=(const CppBean &);private:    int cpp_int;    Bool cpp_boolean;    Byte cpp_byte;    short cpp_short;    long cpp_long;    float cpp_float;    double cpp_double;    string cpp_str;    int cpp_intArr[];};#endif

CppBean.cpp的代码，如下：

#include "cppbean.h"CppBean::CppBean() {}CppBean::~CppBean() {}int CppBean::getcpp_int() const {    return cpp_int;}void CppBean::setcpp_int(int jb_int) {    cpp_int = jb_int;}Bool CppBean::getcpp_Bool() const {    return cpp_boolean;}void CppBean::setcpp_Bool(Bool jb_boolean) {    cpp_boolean = jb_boolean;}Byte CppBean::getcpp_byte() const {    return cpp_byte;}void CppBean::setcpp_byte(Byte jb_byte) {    cpp_byte = jb_byte;}short CppBean::getcpp_short() const {    return cpp_short;}void CppBean::setcpp_short(short jb_short) {    cpp_short = jb_short;}long CppBean::getcpp_long() const {    return cpp_long;}void CppBean::setcpp_long(long jb_long) {    cpp_long = jb_long;}float CppBean::getcpp_float() const {    return cpp_float;}void CppBean::setcpp_float(float jb_float) {    cpp_float = jb_float;}double CppBean::getcpp_double() const {    return cpp_double;}void CppBean::setcpp_double(double jb_double) {    cpp_double = jb_double;}string CppBean::getcpp_str() const {    return cpp_str;}void CppBean::setcpp_str(char *str) {    cpp_str.assign(str);}int *CppBean::getcpp_intArr() {    return cpp_intArr;}void CppBean::setcpp_intArr(int *intArr, int length) {    memcpy(cpp_intArr, intArr, length * 4);}

然后我们需要在JNI中添加接口：

public native void passData(JNIBean bean);

然后在native-lib.h中声明，并在native-lib.cpp中实现：

extern "C" {        ...JNIEXPORT void JNICALL        Java_com_hecc_jnitest_JNIManager_passData(JNIEnv *env, jobject instance, jobject bean);}

#include "native-lib.h"#include "cppbean.h"//包含cppbean.h头文件        ...JNIEXPORT void JNICALLJava_com_hecc_jnitest_JNIManager_passData(JNIEnv *env, jobject instance, jobject bean) {    jclass cls_bean = env->GetObjectClass(bean);//获取字节码对象    jfieldID ids_int = env->GetStaticFieldID(cls_bean, "jb_int", "I");//获取静态字段ID对象    jint jb_int = env->GetStaticIntField(cls_bean, ids_int);//获取相应静态字段的int值    MCppBean.setcpp_int(jb_int);//将int值赋给CppBean中的映射值    jfieldID id_boolean = env->GetFieldID(cls_bean, "jb_boolean", "Z");//获取非静态字段ID对象    jboolean jb_boolean = env->GetBooleanField(bean, id_boolean);//获取相应非静态字段的boolean值    MCppBean.setcpp_Bool(jb_boolean);//将boolean值赋给CppBean中的映射值    jbyte jb_byte = env->GetByteField(bean, env->GetFieldID(cls_bean, "jb_byte", "B"));    MCppBean.setcpp_byte(jb_byte);    MCppBean.setcpp_short(env->GetShortField(bean, env->GetFieldID(cls_bean, "jb_short", "S")));    MCppBean.setcpp_long(env->GetLongField(bean, env->GetFieldID(cls_bean, "jb_long", "J")));    MCppBean.setcpp_float(env->GetFloatField(bean, env->GetFieldID(cls_bean, "jb_float", "F")));    MCppBean.setcpp_double(env->GetDoubleField(bean, env->GetFieldID(cls_bean, "jb_double", "D")));    LOGI("MCppBean中：int字段值=%d,Bool字段值=%d,Byte字段值=%d,short字段值=%hd,long字段值=%ld,float字段值=%f,double字段值=%lf",         MCppBean.getcpp_int(), MCppBean.getcpp_Bool(), MCppBean.getcpp_byte(),         MCppBean.getcpp_short(), MCppBean.getcpp_long(),         MCppBean.getcpp_float(), MCppBean.getcpp_double());    //字符串    jfieldID ids_str = env->GetFieldID(cls_bean, "jb_str", "Ljava/lang/String;");    jstring jb_str = (jstring) env->GetObjectField(bean, ids_str);    char *str = (char *) env->GetStringUTFChars(jb_str, 0);    MCppBean.setcpp_str(str);    env->ReleaseStringUTFChars(jb_str, str);    LOGI("MCppBean中：string字段值=%s", MCppBean.getcpp_str().c_str());    //数组    jfieldID ids_intArr = env->GetFieldID(cls_bean, "jb_intArr", "[I");    jintArray jb_intArr = (jintArray) env->GetObjectField(bean, ids_intArr);    jint *intArray = env->GetIntArrayElements(jb_intArr, NULL);    jsize length = env->GetArrayLength(jb_intArr);    MCppBean.setcpp_intArr(intArray, length);    env->ReleaseIntArrayElements(jb_intArr, intArray, 0);    for (int i = 0; i < length; i++) {        LOGI("数组元素%d：%d", i, *(MCppBean.getcpp_intArr() + i));    }}

在NDK中基本数据类型转换的写法是固定的：
1.获取javabean的字节码对象
除了通过env->GetObjectClass(object对象)方法，还可通过env->FindClass(“com/hecc/jnitest/JNIManager”)获取，形参填写javabean的全类名。

2.获取字段ID对象
java中字段分为静态和非静态两种，对应的api也有两种：
jfieldID GetStaticFieldID(jclass clazz, const char* name, const char* sig)；
jfieldID GetFieldID(jclass clazz, const char* name, const char* sig)；
形参1：正是步骤一的字节码对象。形参2：方法名。形参3：字段描述符，简单说每个基本数据类型都有一个固定的标记作识别（参考下表）。

（注：另外数组类型的简写,则用”[“加上如表所示的对应类型的简写形式进行表示就可以了，
比如：[I 表示 int []。[L全类名; 表示类类型数组。另外，引用类型（除基本类型的数组外）的标示最后都有个”;”）

3.获取字段值

获取字段值的api也分静态和非静态（本地类型和java类型查上表）：
本地基本数据类型 GetStatic（java类型）Field(jclass clazz, jfieldID fieldID)；
本地基本数据类型 Get（java类型）Field(jobject obj, jfieldID fieldID)；
形参1：若是静态，为字节码对象；非静态，为实例对象。形参2：正是步骤二的字段ID对象。

对于字符串和数组的获取稍微复杂点，所以单独列出。
字符串：jstring其实是_jobject的子类，所以用GetObjectField()获取jstring,而c/c++并不识别jstring类型，别担心，ndk提供了相关api—-GetStringUTFChars(jstring string, jboolean* isCopy)来转换成char *类型。
数组（int数组为例）：jintArray也是_jobject的子类，同时ndk提供了相关api来获取数组首地—- GetIntArrayElements(jintArray array, jboolean* isCopy)和数组个数—-GetArrayLength(jarray array)。

在MainActivity添加如下代码，进行测试：

  ...private void testJNI() {     ...        JNIBean bean = new JNIBean();        JNIBean.jb_int = 11;        bean.jb_boolean = false;        bean.jb_byte = 22;        bean.jb_short = 33;        bean.jb_long = 30000000000L;        bean.jb_float = 12.34f;        bean.jb_double = 56.789d;        bean.jb_str = "我是测试代码";        bean.jb_intArr = new int[]{1, 23, 456, 78, 9};        manager.passData(bean);    }

运行，打印结果如图：

---

有人可能会有这样的需求：如何将内部类，类类型数组的数据传递给本地？
ndk中数据的转换方式是相当固定的，如果理解了上述的实例，对于类似的需要并不难实现。
首先，在JNIBean 中添加内部类和类类型数组。

public class JNIBean {    ...    public JNIChildBean jb_ChildBean;    public JNIChildBean[] jb_arr_ChildBean;    public class JNIChildBean {        public int jcb_int;    }}

在native-lib中添加如下代码：

JNIEXPORT void JNICALLJava_com_hecc_jnitest_JNIManager_passData(JNIEnv *env, jobject instance, jobject bean) {    ...    //内部类    jfieldID ids_child = env->GetFieldID(cls_bean, "jb_ChildBean", "Lcom/hecc/jnitest/JNIBean$JNIChildBean;");//内部类用$符号，而不是/符号。    jobject jb_child = env->GetObjectField(bean, ids_child);    jclass cls_child = env->GetObjectClass(jb_child);    jint jcb_int = env->GetIntField(jb_child, env->GetFieldID(cls_child, "jcb_int", "I"));    LOGI("jcb_int=%d", jcb_int);    //类类型数组    jfieldID ids_arr_child = env->GetFieldID(cls_bean, "jb_arr_ChildBean",                                     "[Lcom/hecc/jnitest/JNIBean$JNIChildBean;");    jobjectArray jb_arr_child = (jobjectArray) env->GetObjectField(bean, ids_arr_child);    jsize size = env->GetArrayLength(jb_arr_child);    for (int i = 0; i < size; ++i) {        jobject jab_child = env->GetObjectArrayElement(jb_arr_child, i);//获取每个数组的元素        jint jacb_int = env->GetIntField(jab_child,                                 env->GetFieldID(env->GetObjectClass(jab_child), "jcb_int", "I"));        LOGI("jacb_int=%d",jacb_int);    }}

然后在MainActivity在添加如下代码，进行测试：

public class MainActivity extends AppCompatActivity {  ...    private void testJNI() {     ...        bean.jb_ChildBean = bean.new JNIChildBean();        bean.jb_ChildBean.jcb_int = 1010;        bean.jb_arr_ChildBean = new JNIBean.JNIChildBean[5];        for (int i = 0; i < 5; i++) {            JNIBean.JNIChildBean childBean = bean.new JNIChildBean();            childBean.jcb_int = i + 2000;            bean.jb_arr_ChildBean[i] = childBean;        }        manager.passData(bean);    }}

打印结果如图：

---

以上示例，都是以java–>c/c++的形式，实际需求中可能需要c/c++–>java或则java–>c/c++–>java的形式传递。那么现在就以java–>c/c++–>java，我打算在界面上写个按钮，点击按钮开启一个线程调用本地方法，ndk再调用c++的函数处理逻辑（这里让线程睡了3秒，模拟耗时操作），然后c++通过ndk回调java的函数，并打印日志。事件逻辑可能有点复杂，下面按照先后流程贴代码：

在MainActivity在添加如下代码：

public class MainActivity extends AppCompatActivity {    ...    //按钮点击事件    public void test(View v) {        new Thread(new Runnable() {            @Override            public void run() {                manager.test();            }        }).start();    }}

在JNIManager在添加如下代码：

public class JNIManager {   ...    public native void test();    //c++调用java的函数    public void printFromC(int sec) {        Log.i("JNIManager", "hello from c after " + sec + "s");    }}

我打算先创建c++的类，并在CMakeLists.txt中配置
text.h文件：

#ifndef JNITEST_TEST_H#define JNITEST_TEST_Hextern void runTest();#endif

text.cpp文件：

#include "test.h"#include <unistd.h>#include "native-lib.h"//包含native-lib.h头文件void runTest() {    int sec = 3;    ::sleep(sec); // 睡3秒    call_printFromC(sec);//需要在native-lib.h中声明}

配置完成后点击同步按钮。

此时在native-lib.h中声明函数：

...extern "C" {    ...JNIEXPORT void JNICALL        Java_com_hecc_jnitest_JNIManager_test(JNIEnv *env, jobject instance);}extern void call_printFromC(int sec);//回调函数

最后是native-lib.cpp的代码：

#include "native-lib.h"#include "cppbean.h"#include "test.h"//包含test.h头文件static JavaVM *m_JavaVM;//java虚拟机static jclass m_jcls_JNI;JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *java_vm, void *reserved) {    m_JavaVM = java_vm;    JNIEnv *jni_env = 0;    //获取JavaVM的JNIEnv     if (m_JavaVM->GetEnv((void **) (&jni_env), JNI_VERSION_1_4) != JNI_OK) {        return -1;    }    jclass jcls_JNI = jni_env->FindClass("com/hecc/jnitest/JNIManager");    m_jcls_JNI = (jclass) jni_env->NewGlobalRef((jobject) jcls_JNI);//全局变量，方便调用    return JNI_VERSION_1_4;}...JNIEXPORT void JNICALLJava_com_hecc_jnitest_JNIManager_test(JNIEnv *env, jobject instance) {    runTest();//调用test.h的方法}void call_printFromC(int sec) {    JNIEnv *env;    m_JavaVM->AttachCurrentThread(&env, NULL);//获取当前线程的JNIEnv     jmethodID methodID = env->GetMethodID(m_jcls_JNI, "printFromC", "(I)V");    jobject obj_manager = env->AllocObject(m_jcls_JNI);//获取实例对象    env->CallVoidMethod(obj_manager,methodID,sec);}

众所周知，ndk环境下调用api离不开JNIEnv指针，但是如何在c/c++函数中获取JNIEnv呢？
答：要获取JNIEnv之前，先了解JavaVM ，它代表java的虚拟机，所有的工作都是从获取虚拟机的接口开始的。在加载动态链接库的时候，JVM会调用JNI_OnLoad(JavaVM* jvm, void* reserved)（如果定义了该函数），第一个参数会传入JavaVM指针。然后，通过JVM的AttachCurrentThread(JNIEnv** p_env, void* thr_args)的函数获取JNIEnv。
获取到JNIEnv后，想要调用其他api就方便了。对于ndk回调java函数的格式也是相当固定的：

1.获取函数ID对象
java中函数分为静态和非静态，对应的api：
jmethodID GetStaticMethodID(jclass clazz, const char* name, const char* sig)；
jmethodID GetMethodID(jclass clazz, const char* name, const char* sig)；
形参1：字节码对象。形参2：方法名。形参3：函数描述符，具体格式是（形参类型）返回值类型，另外形参可以写任意个数，没有返回值用V(表示void型)表示。

2.执行回调函数
也分静态和非静态：
本地基本数据类型 CallStatic（返回值类型）Method(jclass clazz, jmethodID methodID, …)
本地基本数据类型 Call（返回值类型）Method(jobject obj, jmethodID methodID, …)
形参1：若是静态，为字节码对象；非静态，为实例对象。形参2：正是步骤一的函数ID对象。其他形参：这里填写的就是java函数对应的参数值，可以写任意个，没有就不用写。

回调java函数完成，点击test按钮，运行查看结果（等待3秒）：

---

这个时候，来了一个变态需求，JeanBean里有一个静态的int型二维数组，通过JNI给其赋值。

public class JNIBean {...    public static int[][] jb_intArr2;}

来看看具体的实现过程：

... void call_printFromC(int sec) {    int pInt[2][3] = {{1, 2, 3}, {4, 5, 6}};//模拟数据    JNIEnv *env;    m_JavaVM->AttachCurrentThread(&env, NULL);    processJNIBean(env, pInt);//处理数据    jmethodID methodID = env->GetMethodID(m_jcls_JNI, "printFromC", "(I)V");    jobject newManager = env->AllocObject(m_jcls_JNI);    env->CallVoidMethod(newManager, methodID, sec);}void processJNIBean(JNIEnv *env, int pInt[2][3]) {    jclass cls_JB = env->FindClass("com/hecc/jnitest/JNIBean");    jobjectArray _infoArr2 = env->NewObjectArray(2, env->FindClass("[I"), NULL);//创建一个长度为2，元素为int[]的jobjectArray     for (int i = 0; i < 2; ++i) {        jintArray _infoArr = env->NewIntArray(3);//创建长度为3的jintArray 数组        env->SetIntArrayRegion(_infoArr, 0, 3, pInt[i]);//给jintArray赋值         env->SetObjectArrayElement(_infoArr2, i, _infoArr);//给jobjectArray赋值    }    jfieldID id_infoArr2 = env->GetStaticFieldID(cls_JB, "jb_intArr2", "[[I"); //静态二维数组ID对象    env->SetStaticObjectField(cls_JB, id_infoArr2, _infoArr2);//设置java端数组数据}

千万不要忘了在native-lib.h声明函数：

static void processJNIBean(JNIEnv *env,int pInt[2][3]);

然后打印数组元素：

public class JNIManager {   ...    //c++调用java的函数    public void printFromC(int sec) {        for (int i = 0; i < 2; i++) {            for (int j = 0; j < 3; j++) {                Log.i("JNIManager","元素["+i+"]["+j+"]="+JNIBean.jb_intArr2[i][j]);            }        }    }}

赋值成功，和模拟的数据一样。

---

如果对ndk 的api不熟悉，可以查看官方文档：

http://docs.oracle.com/javase/7/docs/technotes/guides/jni/spec/jniTOC.html

吾日三省吾身：
代码写完了，功能实现了，稳定性够不够？网络是不是有优化的空间？线程是否安全？内存耗费是否可以更小一些，释放干净没有？各种平台的适配做得够不够好？