JNI开发（一）

一、宏

C++ 宏定义将一个标识符定义为一个字符串，源程序中的该标识符均以指定的字符串来代替,比如定义常量。
C++编译的四大过程：预处理，预编译，汇编，链接；
预处理：预处理阶段主要处理include和define等。它把#include包含进来的.h 文件插入到#include所在的位置，把源程序中使用到的用#define定义的宏用实际的字符串代替，宏定义的展开，宏定义的替换。
预处理器不是编译器，预处理器主要完成文本替换的操作，预处理器都是用 #xxx 的写法。
#include 导入头文件
#if if判断操作 【if的范畴 必须endif】
#elif else if
#else else
#endif 结束if
#define 定义一个宏
#ifdef 如果定义了这个宏 【if的范畴 必须endif】
#ifndef 如果没有定义这个宏 【if的范畴 必须endif】
#undef 取消宏定义
#pragma 设定编译器的状态

1、宏定义示例

//宏定义示例：
#ifndef CLIONCPPPROJECT_T2_H // 如果没有定义这个宏  解决循环拷贝的问题
#define CLIONCPPPROJECT_T2_H // 我就定义这个宏

// 100 行代码
// 第一次能够进来
// 第二次  第n此进不来    直接 解决循环拷贝的问题了

// ---------------
#ifndef isRelease // 如果没有isRelease这个宏
#define isRelease 1 // 是否是正式环境下 【我就定义isRelease这个宏】

#if isRelease == true
#define RELEASE // 正式环境下 定义RELEASE宏

#elif isRelease == false
#define DEBUG // 测试环境下  定义DEBUG宏

#endif // 结束里面的if
#endif // 结束里面的if

#endif //CLIONCPPPROJECT_T2_H // 结束外面的if

#include <iostream>
#include "T2.h"
using namespace std;

int main() {
    // if 条件判断
    // ifdef xxx 是否定义了xxx这个宏
#ifdef DEBUG // 是否定义了DEBUG这个宏
    cout << "在测试环境下，迭代功能" << endl;
#else RELEASE
    cout << "在正式环境下，功能上下中" << endl;
#endif // 结束IF
}

2、宏的取消

// 宏的取消 #undef 宏
#include <iostream>
using namespace std;
int main() {
    int i = 1
#ifndef DERRY // 如果没有定义这个宏
#define DERRY // 我就定义宏
#ifdef DERRY // 是否定义了这个宏
    for (int i = 0; i < 6; ++i) {
        cout << "Derry 1" << endl;
    }
#undef DERRY // 取消宏的定义，下面的代码，就没法用这个宏了，相当于：没有定义过DERRY宏

#ifdef DERRY
    cout << "你定义了Derry宏" << endl;
#else
    cout << "你没有定义了Derry宏" << endl;

#endif
#endif
#endif
#endif
    return 0;
}

3、宏函数

优点：文本替换，不会造成函数的调用开销(开辟栈空间，形参压栈，函数弹栈释放 ..)
缺点：会导致代码体积增大

// 宏函数 真实开发中：宏函数都是大写
#include <iostream>
using namespace std;
#define VALUE_I 9527
#define VALUE_S "AAA"
#define VALUE_F 545.3f

#define SHOW(V) cout << V << endl; // 参数列表 无需类型  返回值 看不到
#define ADD(n1, n2) n1 + n2
#define CHE(n1, n2) n1 * n2 // 故意制作问题 ，宏函数的注意事项

// 复杂的宏函数
#define LOGIN(V) if(V==1) {                         \
    cout << "满足 你个货输入的是:" << V << endl;        \
} else {                                             \
    cout << "不满足 你个货输入的是:" << V << endl;       \
} // 这个是结尾，不需要加 \

void show() {}
int main() {
    int i = VALUE_I; // 预处理阶段 宏会直接完成文本替换工作，替换后的样子：int i = 9527;
    string s = VALUE_S; // string s = "AAA";
    float f = VALUE_F; // float f = 545.3f;s

    SHOW(8);
    SHOW(8.8f);
    SHOW(8.99);

    int r = ADD(1, 2);
    cout << r << endl;

    r = ADD(1+1, 2+2);
    cout << r << endl;

    // r = CHE(1+1, 2+2);
    r = 1+1 * 2+2; // 文本替换：1+1 * 2+2  先算乘法  最终等于 5
    cout << r << endl; // 我们认为的是8，   但是打印5

    LOGIN(0);
    LOGIN(0);
    LOGIN(0);
    // 会导致代码体积增大

    show();
    show();
    // 普通函数，每次都会进栈 弹栈 ，不会导致代码体积增大

    return 0;
}

二、JNI交互

1、JNI概述

定义：Java Native Interface，即 Java 本地接口
作用： 使得 Java 与 本地其他类型语言（如 C、C++）交互，JNI 是 Java 调用 Native 语言的一种特性，JNI 是属于 Java 的，与 Android 无直接关系，实际中的驱动都是 C/C++开发的,通过 JNI,Java 可以调用 C/c++实现的驱动，从而扩展 Java 虚拟机的能力。另外，在高效率的数学运算、游戏的实时渲染、音视频的编码和解码等方面，一般都是用 C 开发的（Java 代码 里调用 C/C++等语言代码 或 C/C++代码调用 Java 代码）；
实际使用中，Java 需要与 本地代码 进行交互，因为 Java 具备跨平台的特点，所以 Java 与 本地代码交互的能力非常弱，采用 JNI 特性 增强 Java 与 本地代码交互的能力。

NDK 与 JNI 关系？
JNI： Java 平台 JDK 提供的一套非常强大的框架 Java Native Interface
相互调用交互通信：C C++ Native < > Java / Kotlin
NDK： Android 平台提供的 Native 开发工具集开发包 Native Development Kit,后面把开始的 JNI，拿到 NDK 里面来并进行封装 （JNI，gcc，g++， ）

2、JNI交互实例

签名规则：javap -s -p MainActivity 必须是.class
Java的boolean --- Z 注意点
Java的byte --- B
Java的char --- C
Java的short --- S
Java的int --- I
Java的long --- J 注意点
Java的float --- F
Java的double --- D
Java的void --- V
Java的引用类型 --- Lxxx/xxx/xx/类名;
Java的String --- Ljava/lang/String;
Java的array int[] --- [I double[][][][] --- [[[D
int add(char c1, char c2) ---- (CC)I
void a() === ()V
javap -s -p xxx.class -s 输出xxxx.class的所有属性和方法的签名， -p 忽略私有公开的所有属性方法全部输出

//MainActivity.java
package com.derry.as_jni_project;

import androidx.appcompat.app.AppCompatActivity;

import android.os.Bundle;
import android.widget.TextView;

// 生成头文件：javah com.derry.as_jni_project.MainActivity
public class MainActivity extends AppCompatActivity {

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

    public static final int A = 100;

    public String name = "Derry"; // 签名：Ljava/lang/String;

    public static int age = 29; // 签名：I

    // Java 本地方法  实现：native层
    public native String getStringPwd();
    public static native String getStringPwd2();

    // -------------  交互操作 JNI
    public native void changeName();
    public static native void changeAge();
    public native void callAddMethod();

    // 专门写一个函数，给native成调用
    public int add(int number1, int number2) {
        return number1 + number2 + 8;
    }

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

         // Example of a call to a native method
         TextView tv = findViewById(R.id.sample_text);
        changeName();
        tv.setText(name);

        changeAge();
        tv.setText("" + age);
        callAddMethod();
    }
}

//头文件，解释相关细节
#include <jni.h>
#include <string>
// 解决循环Copy的问题 第二次就进不来了
#ifndef _Included_com_derry_as_jni_project_MainActivity // 如果没有定义这个宏
#define _Included_com_derry_as_jni_project_MainActivity // 我就定义这个宏
#ifdef __cplusplus // 如果是C++环境
extern "C" { // 全部采用C的方式 不准你函数重载，函数名一样的问题
#endif
#undef com_derry_as_jni_project_MainActivity_A
#define com_derry_as_jni_project_MainActivity_A 100L
// 函数的声明
JNIEXPORT jstring JNICALL Java_com_derry_as_1jni_1project_MainActivity_getStringPwd
  (JNIEnv *, jobject);
#ifdef __cplusplus 
}
#endif
#endif

//native-lib.cpp
#include "com_derry_as_jni_project_MainActivity.h"

// NDK工具链里面的 log 库 引入过来
#include <android/log.h>

#define TAG "Derry"
// ... 我都不知道传入什么  借助JNI里面的宏来自动帮我填充
#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, TAG, __VA_ARGS__)
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, TAG, __VA_ARGS__)
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, TAG, __VA_ARGS__)


// extern "C"： 必须采用C的编译方式，为什么，请看JNIEnv内部源码
// // 无论是C还是C++ 最终是调用到 C的JNINativeInterface，所以必须采用C的方式 extern "C"
// 函数的实现
extern "C"

JNIEXPORT  // 标记该方法可以被外部调用（VS上不加入 运行会报错， AS上不加入运行没有问题）
// Linux运行不加入，不报错,  Win 你必须加入 否则运行报错,   MacOS 还不知道

jstring // Java <---> native 转换用的

JNICALL // 代表是 JNI标记，可以少

// Java_包名_类名_方法名  ，注意：我们的包名 _     native _1

// JNIEnv * env  JNI：的桥梁环境    300多个函数，所以的JNI操作，必须靠他

// jobject jobj  谁调用，就是谁的实例  MainActivity this
// jclass clazz 谁调用，就是谁的class MainActivity.class

Java_com_derry_as_1jni_1project_MainActivity_getStringPwd
        (JNIEnv * env, jobject jobj) {
}

// 静态函数
extern "C"
JNIEXPORT jstring JNICALL
Java_com_derry_as_1jni_1project_MainActivity_getStringPwd2(JNIEnv *env, jclass clazz) {
    // TODO: implement getStringPwd2()
}

extern "C"
JNIEXPORT void JNICALL
Java_com_derry_as_1jni_1project_MainActivity_changeName(JNIEnv *env, jobject thiz) {
   // 获取class
   jclass j_cls = env->GetObjectClass(thiz);

   // 获取属性  L对象类型 都需要L
   // jfieldID GetFieldID(MainActivity.class, 属性名, 属性的签名)
   jfieldID j_fid = env->GetFieldID(j_cls, "name", "Ljava/lang/String;");

   // 转换工作
   jstring j_str = static_cast<jstring>(env->GetObjectField(thiz ,j_fid));

   // 打印字符串  目标
   char * c_str = const_cast<char *>(env->GetStringUTFChars(j_str, NULL));
    LOGD("native : %s\n", c_str);
    LOGE("native : %s\n", c_str);
    LOGI("native : %s\n", c_str);

    // 修改成 Beyond
    jstring jName = env->NewStringUTF("Beyond");
    env->SetObjectField(thiz, j_fid, jName);
}

extern "C"
JNIEXPORT void JNICALL
Java_com_derry_as_1jni_1project_MainActivity_changeAge(JNIEnv *env, jclass jcls) {
    const char * sig = "I";
   jfieldID j_fid = env->GetStaticFieldID(jcls, "age", sig);
   jint age = env->GetStaticIntField(jcls, j_fid);
   age += 10;
   env->SetStaticIntField(jcls, j_fid, age);
}

extern "C"
JNIEXPORT void JNICALL
Java_com_derry_as_1jni_1project_MainActivity_callAddMethod(JNIEnv *env, jobject job) {
    // 自己得到 MainActivity.class
    jclass  mainActivityClass = env->GetObjectClass(job);

    // GetMethodID(MainActivity.class, 方法名, 方法的签名)
   jmethodID j_mid = env->GetMethodID(mainActivityClass, "add", "(II)I");

   // 调用 Java的方法
   jint sum = env->CallIntMethod(job, j_mid, 3, 3);
   LOGE("sum result:%d", sum);
}