如果你看遍了网上那些只是在C++里面输出一个 ‘ helloWorld ’ 的NDK教程的话，可以看看本系列的文章，本系列是通过NDK的运用的例子来学习NDK。

Android鬼点子-通过Google官方示例学NDK（2）——主要是说的不使用java代码，用c++写一个activity。

Android鬼点子-通过Google官方示例学NDK（3）——这是一个opengl的例子。

Android鬼点子-通过Google官方示例学NDK（4）——主要是说的视频解码相关的内容。

代码地址，建议先拉下来看看。

代码的功能就是一个简单的计时器。界面上的时间每秒增加1。

通过这个里可以了解到如何C++调用java代码。如何在C++起一个线程。

/*
 * Copyright (C) 2016 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.example.hellojnicallback;

import android.support.annotation.Keep;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.widget.TextView;

public class MainActivity extends AppCompatActivity {

    int hour = 0;
    int minute = 0;
    int second = 0;
    TextView tickView;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        tickView = (TextView) findViewById(R.id.tickView);
    }
    @Override
    public void onResume() {
        super.onResume();
        hour = minute = second = 0;
        ((TextView)findViewById(R.id.hellojniMsg)).setText(stringFromJNI());
        startTicks();
    }

    @Override
    public void onPause () {
        super.onPause();
        StopTicks();
    }

    /*
     * A function calling from JNI to update current timer
     */
    @Keep
    private void updateTimer() {
        ++second;
        if(second >= 60) {
            ++minute;
            second -= 60;
            if(minute >= 60) {
                ++hour;
                minute -= 60;
            }
        }
        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                String ticks = "" + MainActivity.this.hour + ":" +
                        MainActivity.this.minute + ":" +
                        MainActivity.this.second;
                MainActivity.this.tickView.setText(ticks);
            }
        });
    }
    static {
        System.loadLibrary("hello-jnicallback");
    }
    public native  String stringFromJNI();
    public native void startTicks();
    public native void StopTicks();
}

Activity中有3个jni方法。一个更新界面方法。这里主要了解这3个jni方法。

首先看stringFromJNI()方法，这只是一个简单的C++调用java获取数据。

JNIEXPORT jstring JNICALL
Java_com_example_hellojnicallback_MainActivity_stringFromJNI( JNIEnv* env, jobject thiz )
{
#if defined(__arm__)
    #if defined(__ARM_ARCH_7A__)
    #if defined(__ARM_NEON__)
      #if defined(__ARM_PCS_VFP)
        #define ABI "armeabi-v7a/NEON (hard-float)"
      #else
        #define ABI "armeabi-v7a/NEON"
      #endif
    #else
      #if defined(__ARM_PCS_VFP)
        #define ABI "armeabi-v7a (hard-float)"
      #else
        #define ABI "armeabi-v7a"
      #endif
    #endif
  #else
   #define ABI "armeabi"
  #endif
#elif defined(__i386__)
#define ABI "x86"
#elif defined(__x86_64__)
#define ABI "x86_64"
#elif defined(__mips64)  /* mips64el-* toolchain defines __mips__ too */
#define ABI "mips64"
#elif defined(__mips__)
#define ABI "mips"
#elif defined(__aarch64__)
#define ABI "arm64-v8a"
#else
#define ABI "unknown"
#endif
    return (*env)->NewStringUTF(env, "Hello from JNI !  Compiled with ABI " ABI ".");
}

这个方法有两个参数，JNIEnv* env 是jni的运行环境，不同线程的JNIEnv 彼此独立； jobject thiz是该方法的调用者（static方法的话就是clazz）。

第一个方法就这样，说另外两个方法之前，先看一下JniHandler.java：

/*
 * Copyright (C) 2016 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */
package com.example.hellojnicallback;

import android.os.Build;
import android.support.annotation.Keep;
import android.util.Log;

/*
 * A helper class to demo that JNI could call into:
 *     private non-static function
 *     public non-static function
 *     static public function
 * The calling code is inside hello-jnicallback.c
 */
public class JniHandler {
    /*
     * Print out status to logcat
     */
    @Keep
    private void updateStatus(String msg) {
        if (msg.toLowerCase().contains("error")) {
            Log.e("JniHandler", "Native Err: " + msg);
        } else {
            Log.i("JniHandler", "Native Msg: " + msg);
        }
    }

    /*
     * Return OS build version: a static function
     */
    @Keep
    static public String getBuildVersion() {
        return Build.VERSION.RELEASE;
    }

    /*
     * Return Java memory info
     */
    @Keep
    public long getRuntimeMemorySize() {
        return Runtime.getRuntime().freeMemory();
    }
}

JniHandler中的3个方法会在jni中被调用。

再看一下hello-jnicallback.c中的JNI_OnLoad方法。这个方法，会在System.loadLibrary("hello-jnicallback");的时候被调用。

JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved) {
    JNIEnv* env;
    memset(&g_ctx, 0, sizeof(g_ctx)); //全部初始化未0

    g_ctx.javaVM = vm; //javaVM
    if ((*vm)->GetEnv(vm, (void**)&env, JNI_VERSION_1_6) != JNI_OK) { //env
        return JNI_ERR; // JNI version not supported.
    }

    jclass  clz = (*env)->FindClass(env,
                                    "com/example/hellojnicallback/JniHandler");//找到clz
    g_ctx.jniHelperClz = (*env)->NewGlobalRef(env, clz);//生成引用

    jmethodID  jniHelperCtor = (*env)->GetMethodID(env, g_ctx.jniHelperClz,
                                                   "<init>", "()V"); //获取clz的构造函数并生成一个对象
    jobject    handler = (*env)->NewObject(env, g_ctx.jniHelperClz,
                                           jniHelperCtor);
    g_ctx.jniHelperObj = (*env)->NewGlobalRef(env, handler);//生成并保持引用
    queryRuntimeInfo(env, g_ctx.jniHelperObj);

    g_ctx.done = 0;
    g_ctx.mainActivityObj = NULL;
    return  JNI_VERSION_1_6;
}

这个方法主要是初始化了下面的结构体

typedef struct tick_context {
    JavaVM  *javaVM;
    jclass   jniHelperClz;
    jobject  jniHelperObj;
    jclass   mainActivityClz;
    jobject  mainActivityObj;
    pthread_mutex_t  lock;
    int      done;
} TickContext;
TickContext g_ctx;

这个结构里面保存了JniHandler对象和activity对象，还有一个线程锁。

queryRuntimeInfo(env, g_ctx.jniHelperObj)方法是在拿到了JniHandler对象后，调用JniHandler对象的方法。这里就是C++调用Java的例子。因为之前已经保存了JniHandler对象和JniHandler的clazz,所以queryRuntimeInfo方法中只是找方法，然后调用方法。

jmethodID versionFunc = (*env)->GetStaticMethodID(
            env, g_ctx.jniHelperClz,
            "getBuildVersion", "()Ljava/lang/String;");
jstring buildVersion = (*env)->CallStaticObjectMethod(env,g_ctx.jniHelperClz, versionFunc);

如果你看不懂“()Ljava/lang/String;”，这里就是表示方法的返回值类型和参数类型。具体的可以参考。

上面是静态方法的调用，如果是普通方法，就需要对象作为参数。

jmethodID memFunc = (*env)->GetMethodID(env, g_ctx.jniHelperClz,
                                            "getRuntimeMemorySize", "()J");
jlong result = (*env)->CallLongMethod(env, instance, memFunc);

instance就是g_ctx.jniHelperObj。

那么，接下来看开始计时的实现：

JNIEXPORT void JNICALL
Java_com_example_hellojnicallback_MainActivity_startTicks(JNIEnv *env, jobject instance) {
    pthread_t       threadInfo_; //用于声明线程ID
    pthread_attr_t  threadAttr_; //用于保存线程属性

    pthread_attr_init(&threadAttr_);

    //表示新线程是否与进程中其他线程脱离同步,新线程不能用pthread_join()来同步，且在退出时自行释放所占用的资源
    pthread_attr_setdetachstate(&threadAttr_, PTHREAD_CREATE_DETACHED);

    //使用互斥锁，NULL使用默认的互斥锁属性，默认属性为快速互斥锁
    pthread_mutex_init(&g_ctx.lock, NULL);

    jclass clz = (*env)->GetObjectClass(env, instance);//这个方法依赖的类对象的class对象
    g_ctx.mainActivityClz = (*env)->NewGlobalRef(env, clz);
    g_ctx.mainActivityObj = (*env)->NewGlobalRef(env, instance);////这个方法依赖的类对象

    //线程创建,第三个参数是方法，该方法的参数是通过第四个参数传入的（void*类型）
    int result  = pthread_create( &threadInfo_, &threadAttr_, UpdateTicks, &g_ctx);//把第二个参数设置为NULL的话，将采用默认的属性配置
    assert(result == 0);

    pthread_attr_destroy(&threadAttr_);

    (void)result;
}

主要是起了一个线程，然后让UpdateTicks方法运行在上面。接下来看看UpdateTicks方法。

void*  UpdateTicks(void* context) {
    TickContext *pctx = (TickContext*) context;
    JavaVM *javaVM = pctx->javaVM;
    JNIEnv *env;//不同线程的JNIEnv相互独立
    jint res = (*javaVM)->GetEnv(javaVM, (void**)&env, JNI_VERSION_1_6);
    if (res != JNI_OK) {
        res = (*javaVM)->AttachCurrentThread(javaVM, &env, NULL);
        if (JNI_OK != res) {
            LOGE("Failed to AttachCurrentThread, ErrorCode = %d", res);
            return NULL;
        }
    }

    jmethodID statusId = (*env)->GetMethodID(env, pctx->jniHelperClz,
                                             "updateStatus",
                                             "(Ljava/lang/String;)V");//找到方法JniHandler.updateStatus
    sendJavaMsg(env, pctx->jniHelperObj, statusId,
                "TickerThread status: initializing...");

    // get mainActivity updateTimer function
    jmethodID timerId = (*env)->GetMethodID(env, pctx->mainActivityClz,
                                            "updateTimer", "()V");

    struct timeval beginTime, curTime, usedTime, leftTime;
    const struct timeval kOneSecond = {
            (__kernel_time_t)1,//秒
            (__kernel_suseconds_t) 0//零头：微秒
    };

    sendJavaMsg(env, pctx->jniHelperObj, statusId,
                "TickerThread status: start ticking ...");
    while(1) {
        gettimeofday(&beginTime, NULL);//获得当前精确时间(1970年1月1日到现在的时间),时区是null
        pthread_mutex_lock(&pctx->lock);//加锁
        int done = pctx->done;
        if (pctx->done) {
            pctx->done = 0;
        }
        pthread_mutex_unlock(&pctx->lock);//解锁
        if (done) {
            break;
        }
        (*env)->CallVoidMethod(env, pctx->mainActivityObj, timerId);

        gettimeofday(&curTime, NULL);//当前时间
        timersub(&curTime, &beginTime, &usedTime); //usedTime = curTime - beginTime,使用了的时间
        timersub(&kOneSecond, &usedTime, &leftTime); //leftTime = kOneSecond（1s） - usedTime,剩余的时间
        struct timespec sleepTime; //计算需要睡眠的时间
        sleepTime.tv_sec = leftTime.tv_sec;
        sleepTime.tv_nsec = leftTime.tv_usec * 1000; //微妙转毫秒

        if (sleepTime.tv_sec <= 1) {
            nanosleep(&sleepTime, NULL);//线程暂停
        } else {
            sendJavaMsg(env, pctx->jniHelperObj, statusId,
                        "TickerThread error: processing too long!");
        }
    }

    sendJavaMsg(env, pctx->jniHelperObj, statusId,
                "TickerThread status: ticking stopped");
    (*javaVM)->DetachCurrentThread(javaVM);//white结束后，收回线程
    return context;
}

这个有个while循环，并且通过pctx->done来作为终止条件。然后看1秒钟还剩多少时间，然后剩余的时间进行睡眠。

这里有个if (pctx->done) { pctx->done = 0;}的操作，我看到这里也比较迷惑，但是我们接下来往后看。

JNIEXPORT void JNICALL
Java_com_example_hellojnicallback_MainActivity_StopTicks(JNIEnv *env, jobject instance) {
    pthread_mutex_lock(&g_ctx.lock);
    g_ctx.done = 1;
    pthread_mutex_unlock(&g_ctx.lock);

    // waiting for ticking thread to flip the done flag
    // 等待UpdateTicks中执行break后，才可以继续收回资源
    struct timespec sleepTime;
    memset(&sleepTime, 0, sizeof(sleepTime));
    sleepTime.tv_nsec = 100000000;//100s
    while (g_ctx.done) {
        nanosleep(&sleepTime, NULL);
    }

    // release object we allocated from StartTicks() function
    (*env)->DeleteGlobalRef(env, g_ctx.mainActivityClz);
    (*env)->DeleteGlobalRef(env, g_ctx.mainActivityObj);
    g_ctx.mainActivityObj = NULL;
    g_ctx.mainActivityClz = NULL;

    pthread_mutex_destroy(&g_ctx.lock);
}

原注释waiting for ticking thread to flip the done flag的意思是等待计数线程翻转done的标志。我的理解是要等待计数线程退出之后，这里的方法才可以继续往下走，收回资源。

代码中我觉得有必要的地方我都加了中文注解，如果有理解错误的地方欢迎交流。