JNI是Java Native Interface的缩写，译为Java本地接口。它允许Java代码和其他语言编写的代码进行交互。在android中提供JNI的方式，让Java程 序可以调用C语言程序。android中很多Java类都具有native接口，这些接口由本地实现，然后注册到系统中。
 
       主要的JNI代码放在以下的路径中：frameworks/base/core/jni/，这个路径中的内容被编译成库 libandroid_runtime.so，这是个普通的动态库，被放置在目标系统的/system/lib目录下。此外，android还有其他的 JNI库。JNI中的各个文件，实际上就是普通的C++源文件；在android中实现的JNI库，需要连接动态库 libnativehelper.so。
 
 1，JNI的实现方式
 
      实现JNI需要在Java源代码中声明，在C++代码中实现JNI的各种方法，并把这些方法注册到系统中。实现JNI的核心是 JNINativeMethod结构体。
 
 typedef struct {
        const char* name;
        const char* signature;
        void* fnPtr;
 } JNINativeMethod;
 
 第一个变量name是Java中JNI函数的名字，第二个变量signature用字符串描述函数参数和返回值，第三个变量fnPtr是JNI函 数C指针。  
 
       在Java代码中，定义的函数由JNI实现时，需要指定函数为native。
 
 2，在应用程 序中使用JNI，可以通过代码中/development/samples/SimpleJNI来分析：
 
 A，分析顶层 Android.mk文件
 
     LOCAL_PACKAGE_NAME := SimpleJNI    //生成PACKAGE的名字，在out/target/product/smdk6410/obj/APPS
 
     LOCAL_JNI_SHARED_LIBRARIES := libsimplejni //生成JNI共享库的名字，在....smdk6410/obj/SHARED_LIBRARIES
 
     include $(BUILD_PACKAGE)                   //以生成APK的方式编译
 
     include $(call all-makefiles-under,$(LOCAL_PATH))   //调用下层makefile
 
 B，分析 JNI目录下Android.mk文件
 
     LOCAL_SRC_FILES:= /                           //JNI的C++源文件
           native.cpp
 
     include $(BUILD_SHARED_LIBRARY)       //以共享库方式编译
 
 3，JNI的代码实现和调用
 
 A，native.cpp内容
 
 static jint
 
 add(JNIEnv *env, jobject thiz, jint a, jint b) { //定义JAVA方法add
 int result = a + b;
     LOGI("%d + %d = %d", a, b, result);
     return result;
 }
 
 
 static const char *classPathName = "com/example/android/simplejni/Native"; //目标JAVA类路径，此处即Native类的路径
 
 
 static JNINativeMethod methods[] = {//本地实现方法列表
   {"add", "(II)I", (void*)add },
 };
 
 
 /*
  * Register several native methods for one class.
  */
 static int registerNativeMethods(JNIEnv* env, const char* className,
     JNINativeMethod* gMethods, int numMethods)
 {
     jclass clazz;
 
 
     clazz = env->FindClass(className);
     if (clazz == NULL) {
         LOGE("Native registration unable to find class '%s'", className);
         return JNI_FALSE;
     }
     if (env->RegisterNatives(clazz, gMethods, numMethods) < 0) {//最后调用jni.c中得方法
         LOGE("RegisterNatives failed for '%s'", className);
         return JNI_FALSE;
     }
 
 
     return JNI_TRUE;
 }
 
 
 /*
  * Register native methods for all classes we know about.
  *
  * returns JNI_TRUE on success.
  */
 static int registerNatives(JNIEnv* env)
 {
   if (!registerNativeMethods(env, classPathName,
                  methods, sizeof(methods) / sizeof(methods[0]))) {
     return JNI_FALSE;
   }
 
 
   return JNI_TRUE;
 }
 // ----------------------------------------------------------------------------
 /*
  * This is called by the VM when the shared library is first loaded.
  */
  
 typedef union {
     JNIEnv* env;
     void* venv;
 } UnionJNIEnvToVoid;
 
 
 jint JNI_OnLoad(JavaVM* vm, void* reserved)//为当前虚拟机平台注册本地JNI
 {
     UnionJNIEnvToVoid uenv;
     uenv.venv = NULL;
     jint result = -1;
     JNIEnv* env = NULL;
     
     LOGI("JNI_OnLoad");
 
 
     if (vm->GetEnv(&uenv.venv, JNI_VERSION_1_4) != JNI_OK) {
         LOGE("ERROR: GetEnv failed");
         goto bail;
     }
     env = uenv.env;
 
 
     if (registerNatives(env) != JNI_TRUE) {//跳到为所有类注册native方法
         LOGE("ERROR: registerNatives failed");
         goto bail;
     }
     
     result = JNI_VERSION_1_4;//告诉VM JINI的版本
     
 bail:
     return result;
 }
 
 当VM执行到C组件（即*.so文件）的System.loadLibrary()函数时，首先去执行.cpp文件中的JNI_Onload()函数，JNI_Onload函数的作用：
 
 1：告诉VM此C组件使用哪个JNI版本，如果没有提供JNI_OnLoad函数，VM默认JNI为1.1版本，如果使用新的JNI版本就必须由JNI_OnLoad来告诉VM
 
 2：可以由JNI_OnLoad做初始化工作
 
 
 
 
 B，SimpleJNI.java 内容
 
     package com.example.android.simplejni;  //JAVA包，跟文件路径对应
 
     import android.app.Activity;
     import android.os.Bundle;
     import android.widget.TextView;            //需要包含的类，以便调用函数
 
 public class SimpleJNI extends Activity {
     /** Called when the activity is first created. */
     @Override
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         TextView tv = new TextView(this);
         int sum = Native.add(2, 3);                     //调用Native类的函数add，该add就是JNI函数，由CPP实现
         tv.setText("2 + 3 = " + Integer.toString(sum));
         setContentView(tv);                                //在屏幕上显示
     }
 }
 
  class Native {
     static {
      // The runtime will add "lib" on the front and ".o" on the end of
      // the name supplied to loadLibrary.
         System.loadLibrary("simplejni");              //载入由native.cpp生成的动态库，全名是lib+simplejni+.o
     }
 
     static native int add(int a, int b);                  //声明动态库中实现的JNI函数add，供JAVA调用
 }
 
     编译生成PACKAGE后，安装到MID上，运行即是2+3=5。
 
  
 
  
 
 Android JNI 使用的数据结构JNINativeMethod详解
 
 
 
Andoird 中使用了一种不同传统Java JNI的方式来定义其native的函数。其中很重要的区别是Andorid使用了一种Java 和 C 函数的映射表数组，并在其中描述了函数的参数和返回值。这个数组的类型是JNINativeMethod，定义如下：此数据结构定义在jni.h中在\dalvik\libnativehelper\include\nativehelper文件夹中
 
typedef struct {
 const char* name;
 const char* signature;
 void* fnPtr;
 } JNINativeMethod;
 
第一个变量name是Java中函数的名字。
 
第二个变量signature，用字符串是描述了函数的参数和返回值
 
第三个变量fnPtr是函数指针，指向C函数。
 
 
 
其中比较难以理解的是第二个参数，例如
 
"()V"
 
"(II)V"
 
"(Ljava/lang/String;Ljava/lang/String;)V"
 
 
 
实际上这些字符是与函数的参数类型一一对应的。
 
"()" 中的字符表示参数，后面的则代表返回值。例如"()V" 就表示void Func();
 
"(II)V" 表示 void Func(int, int);
 
 
 
具体的每一个字符的对应关系如下
 
 
 
字符 Java类型 C类型
 
V      void            void
 Z       jboolean     boolean
 I        jint              int
 J       jlong            long
 D      jdouble       double
 F      jfloat            float
 B      jbyte            byte
 C      jchar           char
 S      jshort          short
 
 
 
数组则以"["开始，用两个字符表示
 
 
 
[I       jintArray      int[]
 [F     jfloatArray    float[]
 [B     jbyteArray    byte[]
 [C    jcharArray    char[]
 [S    jshortArray   short[]
 [D    jdoubleArray double[]
 [J     jlongArray     long[]
 [Z    jbooleanArray boolean[]
 
 
 
上面的都是基本类型。如果Java函数的参数是class，则以"L"开头，以";"结尾中间是用"/" 隔开的包及类名。而其对应的C函数名的参数则为jobject. 一个例外是String类，其对应的类为jstring
 
 
 
Ljava/lang/String; String jstring
 Ljava/net/Socket; Socket jobject
 
 
 
如果JAVA函数位于一个嵌入类，则用$作为类名间的分隔符。
 
例如 "(Ljava/lang/String;Landroid/os/FileUtils$FileStatus;)Z"
 
JNI调用原理：
 
 
JNI：
 
http://blog.csdn.net/droidpioneer/article/details/6787571
 
其中的目录：
 
internal目录：\frameworks\base\core\java\com\android\internal\os
 RegFNIRec gRegJNI[]数组对应的函数在：\frameworks\base\core\jni
 jniRegisterNativeMethods函数在：\dalvik\libnativehelper\JNIHelp.c中调用RegisterNatives 在\dalvik\vm\Jni.c中
 

一、前言
 
注册JNI函数有两种方式：
 
静态注册
 这种方法比较常见，用的是javah -jni xxxx命令生成一组签名函数，并去实现这些函数。
 静态注册方式的弊端：
 （a）需要编译所有声明了native函数的Java类，每个所生成的class文件都得用javah命令生成一个头文件。
 （b）javah生成的JNI层函数名特别长，书写起来很不方便。
 （c）初次调用native函数时要根据函数名字搜索对应的JNI层函数来建立关联关系，这样会影响运行效率。
 静态注册在前面已经提到过，详情请见:Android – JNI开发(静态注册)
动态注册
 Java的Native方法和JNI函数是一一对应的，JNI中有一个JNINativeMethod结构体来保存这个对应关系。我们可以通过重写JNI_OnLoad函数来实现动态注册。
 下面通过一个演示Demo来分析一下动态注册的步骤。
 演示Demo下载：Gitee
 
二、方法解析
 
Android Studio目录结构图如下：
 
 
 
实现如下布局文件，Activity界面有两个按键，分别用来演示Java调用C层和C调用Java层过程，同时有两个TextView显示调用结果。activity_main.xml如下：
 
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="@color/colorAntiqueWhite"
    tools:context=".MainActivity">

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_marginTop="10dp"
        android:layout_marginLeft="10dp"
        android:layout_marginRight="10dp"
        android:layout_marginBottom="10dp"
        android:orientation="vertical"
        android:background="@color/colorHoneydew3">

        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:background="@color/colorPlum1"
            android:orientation="vertical"
            android:layout_weight="1">

            <RelativeLayout
                android:layout_width="match_parent"
                android:layout_height="match_parent"
                android:layout_weight="1">

                <TextView
                    android:id="@+id/textview_java_to_c"
                    android:layout_width="match_parent"
                    android:layout_height="wrap_content"
                    android:layout_centerInParent="true"
                    android:gravity="center"
                    android:text="@string/java_to_c"
                    android:textSize="24sp"
                    android:textStyle="bold" />

            </RelativeLayout>

            <RelativeLayout
                android:layout_width="match_parent"
                android:layout_height="match_parent"
                android:layout_weight="1">

                <TextView
                    android:id="@+id/textview_c_to_java"
                    android:layout_width="match_parent"
                    android:layout_height="wrap_content"
                    android:layout_centerInParent="true"
                    android:gravity="center"
                    android:text="@string/c_to_java"
                    android:textSize="24sp"
                    android:textStyle="bold" />

            </RelativeLayout>




        </LinearLayout>

        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:layout_marginTop="10dp"
            android:background="@color/colorLightSkyBlue"
            android:layout_weight="9">

            <LinearLayout
                android:layout_width="match_parent"
                android:layout_height="match_parent"
                android:layout_marginTop="5dp"
                android:layout_marginLeft="5dp"
                android:layout_marginRight="5dp"
                android:layout_marginBottom="5dp"
                android:background="@color/colorMediumPurple1"
                android:orientation="horizontal">

                <LinearLayout
                    android:layout_width="match_parent"
                    android:layout_height="match_parent"
                    android:layout_weight="1">

                    <Button
                        android:id="@+id/button_java_to_c"
                        android:layout_width="match_parent"
                        android:layout_height="match_parent"
                        android:background="@color/colorPaleGreen"
                        android:text="@string/java_to_c"
                        android:textAllCaps="false"
                        android:onClick="onClick"/>
                </LinearLayout>

                <LinearLayout
                    android:layout_width="match_parent"
                    android:layout_height="match_parent"
                    android:layout_weight="1">

                    <Button
                        android:id="@+id/button_c_to_java"
                        android:layout_width="match_parent"
                        android:layout_height="match_parent"
                        android:background="@color/colorMediumPurple1"
                        android:text="@string/c_to_java"
                        android:textAllCaps="false"
                        android:onClick="onClick"/>
                </LinearLayout>

            </LinearLayout>
        </LinearLayout>

    </LinearLayout>

</androidx.constraintlayout.widget.ConstraintLayout>
 
 
文件定义
 我们将C层文件定义为jni_test.c，编译出来的库文件命名为jni_test，app目录下的build.gradle做如下配置，
 
在android{}路径下添加一下配置：
 
    sourceSets.main{
        jniLibs.srcDir 'src/main/libs' // 库文件输出目录 
        jni.srcDirs = []
    }

    externalNativeBuild {
        ndkBuild {
            path file('src/main/jni/Android.mk') // Android.mk编译目录
        }
    }
 
建立src/main/jni/Android.mk文件，主要是为了引入.c文件编译对应的库，里面内容为：
 
LOCAL_PATH := $(call my-dir)

LOCAL_MODULE := jni_test
LOCAL_SRC_FILES := jni_test.c

include $(BUILD_SHARED_LIBRARY)
 
建立src/main/jni/Application.mk文件，主要是为了生成所有架构的库文件：
 
APP_ABI := all
 
编写JNITest.java文件，主要用于加载jni_test库，编写native方法及C层回调方法，里面有详细的注释：
 
package com.example.jnitestdemo;

import android.util.Log;

public class JNITest {

    // Log tag
    private static final String LOG_TAG = "JNITest";

    private static MainView mView = null;

    static {
        System.loadLibrary("jni_test"); // 加载jni_test库
    }

    public JNITest(MainView mainView) {
        this.mView = mainView;
    }

    /* C层调用Java层 */
    public int CtoJavaReturn(int type) {
        debug("CtoJavaReturn: " + type);
        MainView view = JNITest.mView;
        mView.updateTextViewCtoJava(type);

        return 0;
    }

    /* Java调用C层 */
    public native String javaToC();
    public native String CtoJava();


    /* debug */
    private void debug(String info) {
        Log.d(LOG_TAG, info);
    }
}

 
编写jni_test.c文件，重写JNI_OnLoad函数，并结合registerNatives函数实现动态注册关联各个方法与函数，代码详情见注释：
 
//
// Created by jerry on 2021/3/31.
//
#include <jni.h>
#include <string.h>
#include <sys/system_properties.h>
#include <android/log.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <assert.h>
#include <time.h>

#ifdef __cplusplus
extern "C" {
#endif

/* 生成字符串 */
char* getString(int length) {
    int flag, i;
    char *string;
    srand((unsigned) time(NULL));
    if ((string = (char *) malloc(length)) == NULL) {
        return NULL;
    }

    for (i = 0; i < length - 1; i++) {
        flag = rand() % 3;
        switch (flag) {
            case 0:
                string[i] = 'A' + rand() % 26;
                break;
            case 1:
                string[i] = 'a' + rand() % 26;
                break;
            case 2:
                string[i] = '0' + rand() % 10;
                break;
            default:
                string[i] = 'x';
                break;
        }
    }
    string[length - 1] = '\0';
    return string;
}


// #define JNIREG_CLASS "com.example.jnitestdemo.JNITest" // 指定要注册的类 Android 5.0之前用这种方式(.)隔开
#define JNIREG_CLASS "com/example/jnitestdemo/JNITest"    // 指定要注册的类 Android 5.0之后用这种方式(/)隔开

void c_to_java_test(JNIEnv * env)
{
    srand(time(0));
    int type = rand() % 1000;

    jclass jClass = (*env)->FindClass(env, JNIREG_CLASS);
    if (jClass == 0) {
        return;
    }

    jobject jObject = (*env)->AllocObject(env,jClass);
    if (jObject == NULL) {
        return;
    }

    jmethodID jMethodId = (*env)->GetMethodID(env,jClass,"CtoJavaReturn", "(I)I");
    if (jMethodId == NULL) {
        return;
    }

    (**env).CallIntMethod(env,jObject,jMethodId,type);
}

JNIEXPORT jstring JNICALL jni_call_java_to_c(JNIEnv *env, jclass clazz)
{
    return (*env)->NewStringUTF(env, getString(5));
}

JNIEXPORT jstring JNICALL jni_call_c_to_java(JNIEnv *env, jclass clazz)
{
    c_to_java_test(env);
    return (*env)->NewStringUTF(env, "JNI Call C To Java.");;
}


/**
* Table of methods associated with a single class.
*/
static JNINativeMethod gMethods[] = {
        { "javaToC", "()Ljava/lang/String;", (void*)jni_call_java_to_c },
        { "CtoJava", "()Ljava/lang/String;", (void*)jni_call_c_to_java },
};

/*
* Register several native methods for one class.
*/
static int registerNativeMethods(JNIEnv* env, const char* className,
                                 JNINativeMethod* gMethods, int numMethods)
{
    jclass clazz;
    clazz = (*env)->FindClass(env, className);
    if (clazz == NULL) {
        return JNI_FALSE;
    }
    if ((*env)->RegisterNatives(env, clazz, gMethods, numMethods) < 0) {
        return JNI_FALSE;
    }

    return JNI_TRUE;
}


/*
* Register native methods for all classes we know about.
*/
static int registerNatives(JNIEnv* env)
{
    if (!registerNativeMethods(env, JNIREG_CLASS, gMethods,
                               sizeof(gMethods) / sizeof(gMethods[0])))
        return JNI_FALSE;

    return JNI_TRUE;
}

/*
* Set some test stuff up.
*
* Returns the JNI version on success, -1 on failure.
*/
JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved)
{
    JNIEnv* env = NULL;
    jint result = -1;

    if ((*vm)->GetEnv(vm, (void**) &env, JNI_VERSION_1_4) != JNI_OK) {
        return -1;
    }
    assert(env != NULL);

    if (!registerNatives(env)) {//注册
        return -1;
    }
    /* success -- return valid version number */
    result = JNI_VERSION_1_4;

    return result;
}

#ifdef __cplusplus
}
#endif

 
建立一个接口文件，用于回调MainActivity，代码如下：
 
package com.example.jnitestdemo;

public interface MainView {

    void updateTextViewCtoJava(int info);
}

 
最后完善MainActivity.java文件：
 
package com.example.jnitestdemo;

import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;

import android.annotation.SuppressLint;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.util.Log;
import android.view.View;
import android.widget.TextView;

public class MainActivity extends AppCompatActivity implements MainView{

    // Log tag
    private static final String LOG_TAG = "JNITestDemo";

    // TextView
    private TextView mTextViewJavatoC = null;
    private TextView mTextViewCtoJava = null;

    // msg.what
    private static final int UPDATE_UI_JAVA_TO_C = 0x01;
    private static final int UPDATE_UI_C_TO_JAVA = 0x02;

    // UIHandler
    private UIHandler mUIHandler = null;

    // JNITest
    private static JNITest mJniTest = null;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        debug("onCreate");

        initView();
        initDataSource();
    }

    /* initView */
    private void initView() {
        mTextViewJavatoC = findViewById(R.id.textview_java_to_c);
        mTextViewCtoJava = findViewById(R.id.textview_c_to_java);
    }

    /* initDataSource */
    private void initDataSource() {
        mUIHandler = new UIHandler();
        mJniTest = new JNITest(this);
    }

    /* jniCallJavaToC */
    private void jniCallJavaToC() {
        String text = mJniTest.javaToC();
        debug("jniCallJavaToC: " + text);

        Message message = new Message();
        message.what = UPDATE_UI_JAVA_TO_C;
        message.obj = text;
        mUIHandler.sendMessage(message);
    }

    /* jniCallCToJava */
    private void jniCallCToJava() {
        mJniTest.CtoJava();
    }

    /* Button onClick */
    public void onClick(View view) {
        switch (view.getId()) {
            case R.id.button_java_to_c:
                debug("click java to c");
                jniCallJavaToC();
                break;
            case R.id.button_c_to_java:
                debug("click c to java");
                jniCallCToJava();
                break;
                default:
                    break;
        }
    }

    @Override
    public void updateTextViewCtoJava(int info) {
        Message message = new Message();
        message.what = UPDATE_UI_C_TO_JAVA;
        message.arg1 = info;
        mUIHandler.sendMessage(message);
    }

    /* UIHandler */
    @SuppressLint("HandlerLeak")
    private class UIHandler extends Handler {
        @Override
        public void handleMessage(@NonNull Message msg) {
            super.handleMessage(msg);
            switch (msg.what) {
                case UPDATE_UI_JAVA_TO_C:
                    mTextViewJavatoC.setText(String.valueOf(msg.obj));
                    break;
                case UPDATE_UI_C_TO_JAVA:
                    mTextViewCtoJava.setText(String.valueOf(msg.arg1));
                    break;
                    default:
                        break;
            }
        }
    }

    /* debug */
    private void debug(String info) {
        Log.d(LOG_TAG, info);
    }
}

 
三、注意事项
 
  
 
指定要注册的类在不同Android版本下的区别
 
#define JNIREG_CLASS "com.example.jnitestdemo.JNITest" // 指定要注册的类 Android 5.0之前用这种方式(.)隔开
#define JNIREG_CLASS "com/example/jnitestdemo/JNITest"    // 指定要注册的类 Android 5.0之后用这种方式(/)隔开
 
 
数值类型要一一对应，否则编译会报错。
 
 
我们上面虽然给库命名的为jni_test，但实际编译出来的库名称为libjni_test.so。这个我们不用去理会，AS会自动将库安装到对应目录下。
 
 

前言
 
在Android开发中，使用 NDK开发的需求正逐渐增大
但很多人却搞不懂 JNI 与 NDK 到底是怎么回事
今天，我将先介绍JNI 与 NDK & 之间的区别，手把手进行 NDK的使用教学，希望你们会喜欢

目录
 
 

1. JNI介绍
 
1.1 简介
 
定义：Java Native Interface，即 Java本地接口
作用： 使得Java 与 本地其他类型语言（如C、C++）交互
 
 
即在 Java代码 里调用 C、C++等语言的代码 或 C、C++代码调用 Java 代码
 
 
特别注意： 
  
JNI是 Java 调用 Native 语言的一种特性
JNI 是属于 Java 的，与 Android 无直接关系

1.2 为什么要有 JNI
 
背景：实际使用中，Java 需要与 本地代码 进行交互
问题：因为 Java 具备跨平台的特点，所以Java 与 本地代码交互的能力非常弱
解决方案： 采用 JNI特性 增强 Java 与 本地代码交互的能力
1.3 实现步骤
 
在Java中声明Native方法（即需要调用的本地方法）
编译上述 Java源文件javac（得到 .class文件）
通过 javah 命令导出JNI的头文件（.h文件）
使用 Java需要交互的本地代码 实现在 Java中声明的Native方法
 
 
如 Java 需要与 C++ 交互，那么就用C++实现 Java的Native方法
 
 
编译.so库文件
通过Java命令执行 Java程序，最终实现Java调用本地代码
更加详细过程请参考本文第4节：具体使用
 

2. NDK介绍
 
2.1 简介
 
定义：Native Development Kit，是 Android的一个工具开发包
 
 
NDK是属于 Android 的，与Java并无直接关系
 
 
作用：快速开发C、 C++的动态库，并自动将so和应用一起打包成 APK
 
 
即可通过 NDK在 Android中 使用 JNI与本地代码（如C、C++）交互
 
 
应用场景：在Android的场景下 使用JNI
 
 
即 Android开发的功能需要本地代码（C/C++）实现
 
 
特点
 
额外注意
 
2.2 使用步骤
 
配置 Android NDK环境
创建 Android 项目，并与 NDK进行关联
在 Android 项目中声明所需要调用的 Native方法
使用 Android需要交互的本地代码 实现在Android中声明的Native方法
 
 
比如 Android 需要与 C++ 交互，那么就用C++ 实现 Java的Native方法
 
 
通过 ndk - bulid 命令编译产生.so库文件
编译 Android Studio 工程，从而实现 Android 调用本地代码
更加详细过程请参考本文第4节：具体使用
 

3. NDK与JNI关系
 
 

4. 具体使用
 
本文根据版本的不同介绍了两种在Android Studio中实现 NDK的方法：Android Studio2.2 以下 & 2.2以上
 
4.1 Android Studio2.2 以下实现NDK
 
 
步骤如下
 
  
配置 Android NDK环境
关联 Andorid Studio项目 与 NDK
创建本地代码文件（即需要在 Android项目中调用的本地代码文件）
创建 Android.mk文件 & Application.mk文件
编译上述文件，生成.so库文件，并放入到工程文件中
在 Andoird Studio项目中使用 NDK实现 JNI 功能
 
步骤详解
 
步骤1：配置 Android NDK环境
 
具体请看文章手把手教你配置Android NDK环境
 
步骤2： 关联Andorid Studio项目 与 NDK
 
当你的项目每次需要使用 NDK 时，都需要将该项目关联到 NDK
 
 
此处使用的是Andorid Studio，与Eclipse不同
还在使用Eclipse的同学请自行查找资料配置
 
具体配置如下
a. 在Gradle的 local.properties中添加配置
 
ndk.dir=/Users/Carson_Ho/Library/Android/sdk/ndk-bundle
 
 
 
若ndk目录存放在SDK的目录中，并命名为ndk-bundle，则该配置自动添加
 
 
 
b. 在Gradle的 gradle.properties中添加配置
 
android.useDeprecatedNdk=true 
// 对旧版本的NDK支持
 
 
c. 在Gradle的build.gradle添加ndk节点
 
 
至此，将Andorid Studio的项目 与 NDK 关联完毕
下面，将真正开始讲解如何在项目中使用NDK

步骤3：创建本地代码文件
 
即需要在Android项目中调用的本地代码文件
 
 
此处采用 C++作为展示
 
 
test.cpp
 
# include <jni.h>
# include <stdio.h>

extern "C"
{
   
    JNIEXPORT jstring JNICALL Java_scut_carson_1ho_ndk_1demo_MainActivity_getFromJNI(JNIEnv *env, jobject obj ){
       // 参数说明
       // 1. JNIEnv：代表了VM里面的环境，本地的代码可以通过该参数与Java代码进行操作
       // 2. obj：定义JNI方法的类的一个本地引用（this）
    return env -> NewStringUTF("Hello i am from JNI!");
    // 上述代码是返回一个String类型的"Hello i am from JNI!"字符串
	}
}
 
此处需要注意：
 
如果本地代码是C++（.cpp或者.cc），要使用extern "C" { }把本地方法括进去
JNIEXPORT jstring JNICALL中的JNIEXPORT 和 JNICALL不能省
关于方法名Java_scut_carson_1ho_ndk_1demo_MainActivity_getFromJNI 
  
格式 = Java _包名 _ 类名_Java需要调用的方法名
Java必须大写
对于包名，包名里的.要改成_，_要改成_1
  
 
   
如我的包名是：scut.carson_ho.ndk_demo，则需要改成scut_carson_1ho_ndk_1demo
 
  
 
最后，将创建好的test.cpp文件放入到工程文件目录中的src/main/jni文件夹
 
 
 
若无jni文件夹，则手动创建。
 
 
下面我讲解一下JNI类型与Java类型对应的关系介绍
 
步骤4：创建Android.mk文件
 
作用：指定源码编译的配置信息
 
 
如工作目录，编译模块的名称，参与编译的文件等
 
 
具体使用
Android.mk
 
LOCAL_PATH       :=  $(call my-dir)
// 设置工作目录，而my-dir则会返回Android.mk文件所在的目录

include              $(CLEAR_VARS)
// 清除几乎所有以LOCAL——PATH开头的变量（不包括LOCAL_PATH）

LOCAL_MODULE     :=  hello_jni
// 设置模块的名称，即编译出来.so文件名
// 注，要和上述步骤中build.gradle中NDK节点设置的名字相同

LOCAL_SRC_FILES  :=  test.cpp
// 指定参与模块编译的C/C++源文件名

include              $(BUILD_SHARED_LIBRARY)
// 指定生成的静态库或者共享库在运行时依赖的共享库模块列表。
 
最后，将上述文件同样放在src/main/jni文件夹中。
 
步骤5：创建Application.mk文件
 
作用：配置编译平台相关内容
具体使用
Application.mk
 
APP_ABI := armeabi
// 最常用的APP_ABI字段：指定需要基于哪些CPU平台的.so文件
// 常见的平台有armeabi x86 mips，其中移动设备主要是armeabi平台
// 默认情况下，Android平台会生成所有平台的.so文件，即同APP_ABI := armeabi x86 mips
// 指定CPU平台类型后，就只会生成该平台的.so文件，即上述语句只会生成armeabi平台的.so文件
 
最后，将上述文件同样放在src/main/jni文件夹中
 
步骤6：编译上述文件，生成.so库文件
 
经过上述步骤，在src/main/jni文件夹中已经有3个文件
 
打开终端，输入以下命令
// 步骤1：进入该文件夹
cd /Users/Carson_Ho/AndroidStudioProjects/NDK_Demo/app/src/main/jni 
// 步骤2：运行NDK编译命令
ndk-build
 
 
编译成功后，在src/main/会多了两个文件夹libs & obj，其中libs下存放的是.so库文件
 
步骤7：在src/main/中创建一个名为jniLibs的文件夹，并将上述生成的so文件夹放到该目录下
 
要把名为 CPU平台的文件夹放进去，而不是把.so文件放进去
如果本来就有.so文件，那么就直接创建名为jniLibs的文件夹并放进去就可以
 
步骤8：在Andoird Studio项目中使用NDK实现JNI功能
 
此时，我们已经将本地代码文件编译成.so库文件并放入到工程文件中
在Java代码中调用本地代码中的方法，具体代码如下：
MainActivity.java
 
public class MainActivity extends AppCompatActivity  {

    // 步骤1:加载生成的so库文件
    // 注意要跟.so库文件名相同
    static {

        System.loadLibrary("hello_jni");
    }
    
    // 步骤2:定义在JNI中实现的方法
    public native String getFromJNI();
    
    // 此处设置了一个按钮用于触发JNI方法
    private Button Button;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // 通过Button调用JNI中的方法
        Button = (Button) findViewById(R.id.button);
        Button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Button.setText(getFromJNI());
                
            }
        });
    }
 
主布局文件：activity_main.xml
 
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    tools:context="scut.carson_ho.ndk_demo.MainActivity">

    // 此处设置了一个按钮用于触发JNI方法
    <Button
        android:id="@+id/button"
        android:layout_centerInParent="true"
        android:layout_width="300dp"
        android:layout_height="50dp"
        android:text="调用JNI代码" />

</RelativeLayout>
 

结果展示
 
 

源码地址
 
Carson-Ho的Github地址：NDK_Demo
 

4.2 Android Studio2.2 以上实现NDK
 
如果你的Android Studio是2.2以上的，那么请采用下述方法
 
 
因为Android Studio2.2以上已经内部集成 NDK，所以只需要在Android Studio内部进行配置就可以
 
 
步骤讲解
步骤1：按提示创建工程
 
在创建工程时，需要配置 NDK，根据提示一步步安装即可。
 
 
步骤2：根据需求使用NDK
 
配置好NDK后，Android Studio会自动生成C++文件并设置好调用的代码
你只需要根据需求修改C++文件 & Android就可以使用了。
 

5. 总结
 
本文主要讲解 Java的 JNI与 Android的NDK相关知识
下面我将继续对 Android中的NDK进行深入讲解 ，有兴趣可以继续关注Carson_Ho的安卓开发笔记

请帮顶或评论点赞！因为你的鼓励是我写作的最大动力！
 

欢迎关注carson_ho的微信公众号
 
 

近来研究了一下Android Studio JNI开发，写过几个JAVA调用C层的例子，网上百度了很多，发现好多例子现在都不适用，因此在这儿做一个简单的总结，分享给大家。
 
特别说明：由于AS 和 Gradle更新过快，导致网上以前一些JNI开发的教程不适用。在这儿，此教程采用的是AS3.1，Gradle4.4。理论上，Gradle3.0以上的版本采用此教程即可。
 
下面的步骤仅供参考，详细代码请见：链接：https://pan.baidu.com/s/1fABPPC-uAf0fFAJrsmBkcA 密码：1l8b
 可以参考着代码来看这篇文章。
 AS正确的配置/安装了sdk，并且安装了CMake、LLDB、NDK，如下图所示。
 
 
新建一个工程，MainActivty.java写好相应的TextView显示代码。如下图：
 
 
在MainActivty.java同级目录下建立JNIUtils.java的文件，此文件为JNI接口，并填充相应方法，JNI接口需要用native关键字修饰，,如下图：
 
 注意 “System.loadLibrary(“hellojni”);”名字注意，需要和你的build.gradle ndk节点下的名字一样。
 
这个时候再Build -> Rebuild Project一下，生成相应的class文件。不报错继续往下走，报错请自行查找原因。
 
用AS自带的终端进入你的工程java文件夹下，我这里进入的是app\src\main\java，然后使用javah+包名+文件路径来生成头文件。我这儿运行的命令是：javah com.jnidemo.JNIUtils
 
 
操作正确的话会在这个同级目录下生成一个.h文件，我这里生成的是com_jnidemo_JNIUtils.h 如下图：
 
 
然后再main目录下创建jni文件夹，并将刚才生成的文件拷贝进去，并且新建一个cpp文件，将.h里面的代码拷贝近cpp文件里，并稍加修改，如下图：
 
 
在build.gradle的defaultConfig节点下加入：
 
        // 使用Cmake工具
        externalNativeBuild {
            cmake {
                cppFlags ""
                //生成多个版本的so文件
                abiFilters 'arm64-v8a','armeabi-v7a','x86','x86_64'
            }
        }
 
在build.gradle的android节点下加入：
 
    // 配置CMakeLists.txt路径
    externalNativeBuild {
        cmake {
            path "CMakeLists.txt"  // 设置所要编写的c源码位置，以及编译后so文件的名字
        }
 
在app目录下添加CMakeLists.txt文件，里面代码如下（注意汉字注释的地方）：
 
    # For more information about using CMake with Android Studio, read the  
    # documentation: https://d.android.com/studio/projects/add-native-code.html  
     
    # Sets the minimum version of CMake required to build the native library.  
    #CMakeLists.txt  
    cmake_minimum_required(VERSION 3.4.1)  
     
    # Creates and names a library, sets it as either STATIC  
    # or SHARED, and provides the relative paths to its source code.  
    # You can define multiple libraries, and CMake builds them for you.  
    # Gradle automatically packages shared libraries with your APK.  
      
    add_library( # Sets the name of the library.  
          # 设置so文件名称.  
           hellojni
     
           # Sets the library as a shared library.  
           SHARED  
           # 设置这个so文件为共享.  
     
           # Provides a relative path to your source file(s).  
           # 设置JNI源文件路径.
           src/main/jni/main.cpp)
     
    # Searches for a specified prebuilt library and stores the path as a  
    # variable. Because CMake includes system libraries in the search path by  
    # default, you only need to specify the name of the public NDK library  
    # you want to add. CMake verifies that the library exists before  
    # completing its build.  
      
    find_library( # Sets the name of the path variable.  
           log-lib  
     
           # Specifies the name of the NDK library that  
           # you want CMake to locate.  
           log )  
     
    # Specifies libraries CMake should link to your target library. You  
    # can link multiple libraries, such as libraries you define in this  
    # build script, prebuilt third-party libraries, or system libraries.  
      
    target_link_libraries( # Specifies the target library.  
                # 制定目标库.  
                hellojni
     
                # Links the target library to the log library  
                # included in the NDK.  
                ${log-lib} )  
 
最后我们去完善MainActivity.java文件，如下图：
 
 
最后连上你的手机，运行一下：
 
 
至此，实现了JAVA到C层的调用。