jni-01、宏、jni函数详解、数据获取、类型转换、签名规则

宏语法

// TODO 预处理器不是编译器，预处理器主要完成文本替换的操作（文本替换，以后专门在Linux中去讲），预处理器都是用 #xxx 的写法，并不是注释哦

/*
                                #include  导入头文件
                                #if       if判断操作  【if的范畴 必须endif】
                                #elif     else if
                                #else     else
                                #endif    结束if
          #define   定义一个宏
          #ifdef    如果定义了这个宏 【if的范畴 必须endif】
          #ifndef   如果没有定义这个宏 【if的范畴 必须endif】
          #undef    取消宏定义
          #pragma   设定编译器的状态
 */

#include 
using namespace std;

int main() {
    // std::cout << "宏" << std::endl;

#if 1 // if
    cout <<  "真" << endl;

#elif 0 // else if
    cout <<  "假" << endl;

#else
    cout << "都不满足" << endl;

#endif // 结束if
    cout << "结束if" << endl;

    return 0;
}

宏定义 解决循环拷贝的问题

• T2.h

#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 
#include "T2.h"
using namespace std;

int main() {

    // if 条件判断
    // ifdef xxx 是否定义了xxx这个宏

#ifdef DEBUG // 是否定义了DEBUG这个宏
    cout << "在测试环境下，迭代功能" << endl;
    // 省略 500行 ...

#else RELEASE
    cout << "在正式环境下，功能上下中" << endl;
    // 省略 500行 ...

#endif // 结束IF
}

宏的取消 #undef 宏

// 宏的取消 #undef 宏

#include 
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;
    }
    // 省略 500行 ...

#ifdef DERRY // 是否定义了这个宏
    for (int i = 0; i < 6; ++i) {
        cout << "Derry 2" << endl;
    }
    // 省略 500行 ...

#undef DERRY // 取消宏的定义，下面的代码，就没法用这个宏了，相当于：没有定义过DERRY宏

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

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

宏变量 真实开发中：宏都是大写

#include 
using namespace std;

#define VALUE_I 9527
#define VALUE_S "AAA"
#define VALUE_F 545.3f

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

宏函数 优缺点

#include 
using namespace std;

#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() {
    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);
    LOGIN(0);
    LOGIN(0);
    LOGIN(0);
    // 会导致代码体积增大

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

    return 0;
}

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

jni函数详解

• native-lib.cpp

#include "com_derry_as_jni_project_MainActivity.h"

// NDK工具链里面的 log 库 引入过来
#include 

#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(env->GetObjectField(thiz ,j_fid));

   // 打印字符串  目标
   char * c_str = const_cast(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);

   // printf()  C
   // cout << << endl; // C++
}

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);

}

• MainActivity

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();
    }

}

签名规则 大写

/*
   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 忽略私有公开的所有属性方法全部输出
 */