NDK开发（三）——C/C++代码如何调用java层代码

通过前面两节简单学习，我们知道在进行NDK开发的时候，想要实现Java代码调用C/C++的代码，只要完成下面简单的几步就可以实现：

1.新建Java类，并在其中声明native方法

JNIUtils.java

```
public class JNIUtils {
    //声明一个native方法
    public static native String sayHelloFromJNI();
}

```

2.利用javah命令生成上面Java类所对应的头文件xxx_JNIUtils.h（通过CMake构建的话不需要此步）

3.编写native方法所对应的C/C++代码

JNIHello.cpp

```
#include "com_example_zhangxudong_jnidemo_JNIUtils.h"

JNIEXPORT jstring JNICALL Java_com_example_zhangxudong_jnidemo_JNIUtils_sayHelloFromJNI
        (JNIEnv *env, jclass jclass){
    env->NewStringUTF("Hello World From JNI!!!!!");
}
```

4.在app层下的build.gradle中写好配置代码，编译工程，生成C/C++对应的动态库JNIHello.so，并在Java类中加载此动态库

```
public class JNIUtils {
    //加载动态库
    static {
        System.loadLibrary("JNIHello");
    }
    //声明一个native方法
    public static native String sayHelloFromJNI();
}
```

经过上面简单的几步，我们就可以实现Java代码对C/C++代码的调用。那么反过来，如果我们想要利用 C/C++代码来调用Java的代码，比如访问Java类中的成员变量，方法等，这个时候该怎么办呢？今天我们就来简单的介绍一下如何通过C/C++代码来访问Java层代码。

我们需要知道JNI也是有其对应的数据类型的，也可以大体的分为基本类型和引用类型。如下，Java的数据类型和JNI数据类型的映射关系：

扫描二维码关注公众号，回复： 3878774 查看本文章

接下来我们正式的讲解C/C++调用Java代码的各个模块。

1.如何通过C/C++代码调用Java类中的属性、方法和构造方法

首先，C/C++不会主动的去调用Java代码，需要在Java代码中去触发C/C++去调用。

1.1 访问属性

我们依旧采用CMake构建的方式来完成各个知识点对应的Demo。在AS下新建一个NDKDemo的Project，记得勾选上Include C++ support.

项目建好以后我们需要适当的修改一下IDE为我们自动生成的代码，删减不必要的代码片段。先看MainActivity。

```
public class MainActivity extends AppCompatActivity {
    //加载动态库
    static {
        System.loadLibrary("native-lib");
    }
    public  static String TAG = "MainActivity";
    //这个就是我们要修改的属性，一会儿我们通过C代码把它修改为super
    public String s = "shadow";
    //这个方法就是触发点，告诉C/C++层代码去修改上面的成员属性s
    public native String accessFiled();
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //通过打印log我们看一下修改是否成功
        Log.e(TAG + "修改前s是：" ,s);
        //调用native方法，让C代码修改成员变量s
        accessFiled();
        Log.e(TAG + "修改后s是：" ,s);
    }
}

```

MainActivity的布局文件activity_mian.xml也尽量修改的简单一些

```
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">
    <TextView
        android:id="@+id/sample_text"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello World!" />
</LinearLayout>

```

下面就是重头戏C代码的编写了，到文件夹cpp下找到系统自动为我们生成的native-lib.cpp文件。我们这里选择用C语言来编写native层的代码（我C++不熟啊，哎，水的一批），所以把native-lib.cpp的扩展名改为c(native-lib.c)。当然这里修改了，我们必须到CMakeLists.txt文件中同步一下，把原来的native-lib.cpp改为native-lib.c,否则编译的时候找不到这个文件：

下面看native层代码的编写

```
#include <jni.h>
#include <string.h>

JNIEXPORT jstring

JNICALL
Java_com_example_zhangxudong_ndkdemo_MainActivity_accessFiled(
        JNIEnv *env,
        jobject obj) {
    //1.obj就代表MainActivity的实体对象，但我们这里需要的是MainActiviyt.class字节码文件，
    // 通过以下方法可得到MainActiviy对应的字节码文件。
    jclass cls = (*env)->GetObjectClass(env,obj);
    //2.找到属性对应的id-->jfieldID,函数的四个参数：
    // env不必多说，cls就是上面得到的MainActiviyt.class字节码文件。
    // s就是属性名称，这个是我们在MainActivity中自己定义的。最后一个是属性签名，一会儿在下面讲解
    jfieldID fid = (*env)->GetFieldID(env, cls, "s", "Ljava/lang/String;");
    //3.获取属性的值,修改原来的属性shadow为super shadow.。
    // 一般获取某个属性的值，用到的方法都是这种模式：Get<Type>Field
    jstring jstr = (*env)->GetObjectField(env, obj, fid);
    //4.将jn数据类型转为对应的C数据类型，jstring -> c字符串，至于为什要转为类型的字符串，
    //当然是为了方便我们下一步的字符串拼接操作，所以这一步也是必要的。
    //关于第三个参数，isCopy 是否复制（true代表赋值，false不复制），一般写为NULL或JNI_FALSE就可以
    char *c_str = (*env)->GetStringUTFChars(env,jstr,JNI_FALSE);
    //拼接得到新的字符串，下面这两句都是c语言的语法，首先定义了一个字符数组（也即字符串）
    //然后把它和上面得到的字符串c_str拼接到一起
    char text[20] = "super  ";
    strcat(text,c_str);
    //5.再把C数据类型转回到jni对应的数据类型，c字符串 ->jstring
    jstring new_jstr = (*env)->NewStringUTF(env, text);
    //6.修改属性，模式：Set<Type>Field.这个和上面的GetObjectField方法类似，只是多了一个参数
    //这个参数就是我们修改后的属性的值。
    (*env)->SetObjectField(env, obj, fid, new_jstr);
    //只要使用了GetStringUTFChars或GetStringUTF函数，记得一定要去释放。
    //释放GetStringUTFChars函数或GetStringUTF函数
    (*env)->ReleaseStringUTFChars(env,jstr,c_str);
    //7.返回修改后的属性值
    return new_jstr;
}
```

经过以上，我们编译并运行一下项目，观察log可以看到，确实修改成功了

04-05 00:49:21.312 6060-6060/com.example.zhangxudong.ndkdemo E/MainActivity修改前s是：: shadow
04-05 00:49:21.312 6060-6060/com.example.zhangxudong.ndkdemo E/MainActivity修改后s是：: super  shadow

接下来我们解释一下上面代码中的一些东西，首先env这个东西我们放在最后讲。关于“->”这个运算符，在这里你可以简单的和Java中的“.”类比一下。在Java中我们通过一个类的实例对象可以点出来这个类中的成员变量，成员方法什么的，比如student.age,student.getAge()等，这个“->”在C语言中其实是一样的道理，只不过C语言中没有类的概念，但是有结构体。关于它的具体用法大家可以百度一下，篇幅所限，这里就不展开讲了。

再一个就是关于“签名”的问题了。我们在native层想要拿到一个属性或则方法对应的id就必须要用到其对应的签名。而且这个签名是必要的。就拿方法签名来说吧，有时候我们会在Java层中写很多同名的重载方法，但在native层我们想要调用这其中的某个方法时该怎么区分呢？这个时候方法签名就可以发挥作用了，通过某个函数的方法签名native层就能很好的识别出要调用的是那个重载方法。那么我怎么知道某个属性或者方法具体的签名是什么呢？java为我们提供了一个javap的命令用来查看签名，在AS中，打开Terminal,进入到如下目录E:\你的项目名称\app\build\intermediates\classes\debug>，然后输入如下命令javap -s -p com.example.zhangxudong.ndkdemo.MainActivity，这样你MainActivity中所有的属性和方法的签名都会显示出来，如下：

这里再填一张网友们总结的签名表：

1.2 访问静态属性

修改MainActivity中的代码如下,主要变化就是就是把原来的s属性变为了现在的静态属性count，native方法由原来的String accessFiled()变为现在的void accessStaticField().

```
public class MainActivity extends AppCompatActivity {
    //加载动态库
    static {
        System.loadLibrary("native-lib");
    }
    public  static String TAG = "MainActivity";
    //静态属性
    public static int county  = 3;
    public native void accessStaticFiled();
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        Log.e(TAG + "修改前county是：" ,county + "");
        //调用native方法，让C代码修改成员变量county
        accessStaticFiled();
        Log.e(TAG + "修改后county是：" ,county + "");
    }
}

```

修改native-cpp中的代码如下：

```
#include <jni.h>


JNIEXPORT void
JNICALL
Java_com_example_zhangxudong_ndkdemo_MainActivity_accessStaticFiled(
        JNIEnv *env,
        jobject obj) {
    jclass cls = (*env)->GetObjectClass(env, obj);
    jfieldID fid = (*env)->GetStaticFieldID(env, cls, "count", "I");
    jint count = (*env)->GetStaticIntField(env, cls, fid);
    //修改静态属性值
    count++;
    //SetStatic<Type>Field
    (*env)->SetStaticIntField(env,cls,fid,count);
}
```

理清了1.1中修改属性的套路，其实修改静态属性相对来说要简单很多，套路是一个套路，在这里就不赘述了。我们看一下log，确实修改成功了：

```
04-05 02:26:38.017 4987-4987/com.example.zhangxudong.ndkdemo E/MainActivity_count修改前count是：: 3
04-05 02:26:38.017 4987-4987/com.example.zhangxudong.ndkdemo E/MainActivity_count修改后count是：: 4
```

1.3 访问静态方法

MainActivity

```
public class MainActivity extends AppCompatActivity {
    //加载动态库
    static {
        System.loadLibrary("native-lib");
    }
    public  static String TAG = "MainActivity";
    private TextView tv;
    private Button bt;

    //触发点，触发native层调用静态方法
    public native String accessStaticMethod();
    //静态方法，用来产生一个随机的UUID字符串
    public static String getUUID(){
        return UUID.randomUUID().toString();
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        tv = findViewById(R.id.sample_text);
        bt = findViewById(R.id.bt);
        bt.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                //触发native层调用静态方法
                tv.setText(accessStaticMethod());
            }
        });
    }
}
```

MainActivity对应的布局文件就不展示了，比较简单，只是多加了一个Button按钮。

native-lib.c

```
#include <jni.h>
#include <string.h>

JNIEXPORT jstring
JNICALL
Java_com_example_zhangxudong_ndkdemo_MainActivity_accessStaticMethod(
        JNIEnv *env,
        jobject obj) {
    //jclass
    jclass cls = (*env)->GetObjectClass(env, obj);
    //获取方法对应的id
    jmethodID mid = (*env)->GetStaticMethodID(env, cls, "getUUID", "()Ljava/lang/String;");
    //调用java中的静态方法getUUID()，模式：CallStatic<Type>Method
    jstring uuid = (*env)->CallStaticObjectMethod(env, cls, mid);
    return uuid;
}
```

看效果：

1.4 访问非静态方法

MainActivity

```
public class MainActivity extends AppCompatActivity {
    //加载动态库
    static {
        System.loadLibrary("native-lib");
    }
    public  static String TAG = "MainActivity";
    private TextView tv;
    private Button bt;

    public native int accessMethod();
    ////产生指定范围的随机数
    public int genRandomInt(int max){
        return new Random().nextInt(max);
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        tv = findViewById(R.id.sample_text);
        bt = findViewById(R.id.bt);
        bt.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                tv.setText(accessMethod() + "");
            }
        });
    }
}
```

native-lib.c

```
#include <jni.h>

JNIEXPORT jint
JNICALL
Java_com_example_zhangxudong_ndkdemo_MainActivity_accessMethod(
        JNIEnv *env,
        jobject obj) {
    jclass cls = (*env)->GetObjectClass(env, obj);
    jmethodID mid = (*env)->GetMethodID(env, cls, "genRandomInt", "(I)I");
    //第四个参数就是我们在Java层定义的genRandomInt(int max)中的max，即产生的随机数最大不能超过200
    jint random = (*env)->CallIntMethod(env, obj, mid, 200);
    return random;

```

效果图：

通过上面的学习，我们发现其实套路都是一样样的，就是在native层针对不同的属性和方法，调用的函数稍微有些差异，其他的都大同小异。接下来我们再看最后一个，对构造方法的调用。

1.5 访问Java的构造方法

MainActivity

```
public class MainActivity extends AppCompatActivity {
    //加载动态库
    static {
        System.loadLibrary("native-lib");
    }
    private TextView tv;
    private Button bt;
    private Date date;
    //访问Date类的构造函数
    public native long accessConstructor();
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        tv = findViewById(R.id.sample_text);
        bt = findViewById(R.id.bt);
        bt.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                tv.setText(accessConstructor() + "");
            }
        });
    }
}
```

native-lib.c

```
#include <jni.h>

JNIEXPORT jlong
JNICALL
Java_com_example_zhangxudong_ndkdemo_MainActivity_accessConstructor(
        JNIEnv *env,
        jobject obj) {
    //一般的，当我们可以通过一个类的对象拿到对应的jclass时，就用getObjectClass()方法
    //当没有一个类的对象，我们就需要通过这个类来拿到其对应的jclass,这个时候就用findClass()
    jclass cls = (*env)->FindClass(env, "java/util/Date");
    //jmethodID,<init>就代表的是构造方法
    jmethodID constructor_mid = (*env)->GetMethodID(env, cls, "<init>", "()V");
    //实例化一个Date对象
    jobject date_obj = (*env)->NewObject(env, cls, constructor_mid);
    //通过得到的Date对象其调用getTime方法
    jmethodID mid = (*env)->GetMethodID(env, cls, "getTime", "()J");
    jlong time = (*env)->CallLongMethod(env, date_obj, mid);
    return time;
}
```

效果图：

NDK开发（三）——C/C++代码如何调用java层代码

猜你喜欢