1. 首页
  2. 文章中心
  3. JNI

JNI使用及简单封装前言一、Java调用C++二、C++调用(回调)Java方法

57 阅读 0 评论
我是靠谱客的博主 帅气钢笔，最近开发中收集的这篇文章主要介绍JNI使用及简单封装前言一、Java调用C++二、C++调用(回调)Java方法，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

文章目录

  • 前言
  • 一、Java调用C++
  • 二、C++调用(回调)Java方法

前言

本文主要记录JNI实践中的使用场景，Java调用C++ ，C++回调Java的实现过程，带简单封装思路。
在这里插入图片描述

解释下文件用途：
MainActivity.java :调用native方法的类
AndroidJavaNativeApi.java：写native方法
CallbackJavaHandler.java：写C++回调Java的方法
JniNativeApi.cpp： native方法的JNI方法实现
JavaGlobalRef ：C++ 全局变量保存（jvm ,java 的CallbackJavaHandler回调对象）
NativeCallbackJavaHandler.cpp ：所有C++回调Java实现在这里面
TypeTest ： C++项目代码逻辑

一、Java调用C++

1，AndroidJavaNativeApi.java中定义native方法

public class AndroidJavaNativeApi {

    public native int init(CallbackJavaHandler javaHandler);

    public native void setBasicType(boolean is, byte b, char c, short st, int it, long lg, float ft, double db);

    public native void setObjectType(String str,ObjectType objectType);

}

2，JniNativeApi.cpp中定义native方法的JNI实现，此处不需要定义.h头文件（cpp是类的实现，.h相当于类的对外接口，jni方法实现是基于C语言， JNIEXPORT 表示对外暴露）

#include <jni.h>
#include <string>
#include <__locale>
#include "JavaGlobalRef.h"
#include "TypeTest.h"
#include "ALog.h"
#include "android/log.h"

extern JavaVM *g_jvm;
extern jobject g_objCallbackHandler;

jint JNI_OnLoad(JavaVM *vm, void *reserved) {
    alogd("JNI_OnLoad set jvm");
    if (g_jvm == nullptr) {
        g_jvm = vm;
        alogd("g_jvm :%p", g_jvm);
    }
    return JNI_VERSION_1_6;
}

extern "C"
JNIEXPORT jint JNICALL
Java_com_meeting_jnidemo_AndroidJavaNativeApi_init(
        JNIEnv *env,
        jobject /* this */,
        jobject callBackHandler) {
    alogd("init");
    // save jvm
    if (g_jvm == nullptr) {
        env->GetJavaVM(&g_jvm);
        alogd("init set g_jvm :%p", g_jvm);
    }

    // 保存c++回调Java 的类对象
    if (g_objCallbackHandler == nullptr) {
        alogd("set callback handler");
        g_objCallbackHandler = env->NewGlobalRef(callBackHandler);
        if (g_objCallbackHandler == nullptr) {
            alogd("g_objCallbackHandler is null");
        }
    }
    return 0;
}


extern "C"
JNIEXPORT void JNICALL
Java_com_meeting_jnidemo_AndroidJavaNativeApi_setBasicType(JNIEnv *env, jobject thiz,
                                                                    jboolean is, jbyte b, jchar c,
                                                                    jshort st, jint it, jlong lg,
                                                                    jfloat ft, jdouble db) {
    // TODO: implement setBasicType()
    unsigned char bl = is;
    char _byte = b;
    unsigned short _char = c;
    short _short = st;
    int _int = it;
    long long _long = lg;
    float _float = ft;
    double _double = db;
    alogd("setBasicType boolean:%d, byte:%x, char :%c, short:%hd, int:%d ,long:%lld, float:%f, double:%f",
          is, _byte, _char, _short, _int, _long, _float, _double);

    TypeTest test;
    test.setBasicType(bl, _byte, _char, _short, _int, _long, _float, _double);

}

extern "C"
JNIEXPORT void JNICALL
Java_com_meeting_jnidemo_AndroidJavaNativeApi_setObjectType(JNIEnv *env, jobject thiz,
                                                                     jstring str,
                                                                     jobject object_type) {
    // TODO: implement setObjectType()
    // 1,生成jstring
    const char *c_str = "hello word";
    jstring js = env->NewStringUTF(c_str);

    // 2,jstring 转换成 char *
    const char *c_string = env->GetStringUTFChars(str, 0);
    // 3,释放 char *
    env->ReleaseStringUTFChars(str, c_string);

    // 释放局部变量引用
    env->DeleteLocalRef(js);


    // object 操作
    jclass c_obj = env->GetObjectClass(object_type);
    if (c_obj == nullptr) {
        return;
    }

    jfieldID id_strName = env->GetFieldID(c_obj, "name", "Ljava/lang/String;");
    // 取对象属性值
    jstring j_strName = (jstring) env->GetObjectField(object_type, id_strName);

    // 设置对象属性值
    env->SetObjectField(object_type, id_strName, env->NewStringUTF("张三"));

    // 内部类
    jfieldID id_innerClass = env->GetFieldID(c_obj, "innerClass",
                                             "Lcom/meeting/jnidemo/ObjectType/InnerClass;");
    jobject obj_innerClass = env->GetObjectField(object_type, id_innerClass);

    jclass cls_innerClass = env->GetObjectClass(obj_innerClass);
    // 重复上面步骤获取内部类属性

}

上面JNI方法中Java_com_meeting_jnidemo_AndroidJavaNativeApi_setBasicType
中

 TypeTest test;
 test.setBasicType(bl, _byte, _char, _short, _int, _long, _float, _double);

就是初始化C++类并调用其C++方法，以上就是Java调用C++流程，很简单。

二、C++调用(回调)Java方法

首先C++回调Java方法，必须持有一个Java回调类对象，如下Java类

public class CallbackJavaHandler {
    private String TAG = this.getClass().getSimpleName();
    public void onSetBasicTypeOk(String msg) {
        Log.i(TAG, "onSetBasicTypeOk: java rev");
    }
}

这个类通过JniNativeApi.cpp中自定义的init JNI方法传递到C++层

 // 保存c++回调Java 的类对象
    if (g_objCallbackHandler == nullptr) {
        alogd("set callback handler");
        g_objCallbackHandler = env->NewGlobalRef(callBackHandler);
        if (g_objCallbackHandler == nullptr) {
            alogd("g_objCallbackHandler is null");
        }
    }

C++ 层通过全局变量jobject g_objCallbackHandler 保存回调对象

其次是C++回调Java需要拿到JNI层Java环境参数env，env不能在JNI方法中做保存，需要通过JVM获取，以下是保存jvm的两种方法

JniNativeApi.cpp中JNI_OnLoad方法，是Java层调用

 static {
        System.loadLibrary("common");
    }

1，加载so时会执行方法（我这里是把JNI实现cpp，与C++源码都打到一个libcommon.so中），JNI_OnLoad中我们需要保存全局JavaVM *vm变量。

2，也可以自定义init JNI初始方法 通过env Java环境参数得到jvm并保存。

 // save jvm
    if (g_jvm == nullptr) {
        env->GetJavaVM(&g_jvm);
        alogd("init set g_jvm :%p", g_jvm);
    }

全局变量g_jvm，g_objCallbackHandler单独使用一个C++类做保存
JavaGlobalRef.cpp类

#include "JavaGlobalRef.h"
#include "ALog.h"

// 全局变量
JavaVM *g_jvm = nullptr;
jobject g_objCallbackHandler = nullptr;

JNIEnv *JavaGlobalRef::GetEnv() {
    int status;
    JNIEnv *_jniEnv = NULL;
    status = g_jvm->GetEnv((void **) &_jniEnv, JNI_VERSION_1_6);
    JavaVMAttachArgs args = {JNI_VERSION_1_6, __FUNCTION__, nullptr};

    if (status < 0) {
        status = g_jvm->AttachCurrentThread(&_jniEnv, &args);//获得了可以使用的env
        if (status < 0) {
            _jniEnv = NULL;
        }
    }
    return _jniEnv;
}

void JavaGlobalRef::releaseGlobalRef() {
    if (g_jvm != nullptr) {
        g_jvm->DetachCurrentThread();
        g_jvm->DestroyJavaVM();
        g_jvm = nullptr;
    }
}
JavaGlobalRef::JavaGlobalRef() = default;
JavaGlobalRef::~JavaGlobalRef() = default;

头文件 JavaGlobalRef.h

#ifndef JNIDEMO_JAVAGLOBALREF_H
#define JNIDEMO_JAVAGLOBALREF_H

#include <jni.h>

class JavaGlobalRef {
public:
    JavaGlobalRef();

private:
    ~JavaGlobalRef();

public:
    static JNIEnv *GetEnv();
    static void releaseGlobalRef();

};
#endif //JNIDEMO_JAVAGLOBALREF_H

全局变量在其他类中使用，cpp中得如下引用，方可访问。

extern JavaVM *g_jvm;
extern jobject g_objCallbackHandler;

jvm和Java 回调类jobject准备好了，就可以回调到Java方法了，这里定义一个专门处理回调Java方法得NativeCallbackJavaHandler.cpp类

#include "NativeCallbackJavaHandler.h"
#include "JavaGlobalRef.h"
#include "ALog.h"

extern jobject g_objCallbackHandler;
const char *name_onSetBasicTypeOk = "onSetBasicTypeOk";

void NativeCallbackJavaHandler::onSetBasicTypeOk() {
    alogd("onSetBasicTypeOk");
    JNIEnv *env = JavaGlobalRef::GetEnv(); // 获取Java环境参数 env
    if (g_objCallbackHandler == nullptr) {
        alogd("g_objCallbackHandler is null");
        return;
    }
    // java 方法public void onSetBasicTypeOk(String msg) {}
    jclass cls_handler = env->GetObjectClass(g_objCallbackHandler); // 通过g_objCallbackHandler获取jclass对象
    jmethodID id_onSetBasicTypeOk = env->GetMethodID(cls_handler, name_onSetBasicTypeOk,
                                                     "(Ljava/lang/String;)V"); // "(Ljava/lang/String;)V" Java方法签名

    jstring msg = env->NewStringUTF("hello"); // java 方法传参
    if (id_onSetBasicTypeOk != 0) {
        env->CallVoidMethod(g_objCallbackHandler, id_onSetBasicTypeOk, msg);
    }
    env->DeleteLocalRef(msg);
}

NativeCallbackJavaHandler.h

#ifndef JNIDEMO_NATIVECALLBACKJAVAHANDLER_H
#define JNIDEMO_NATIVECALLBACKJAVAHANDLER_H

class NativeCallbackJavaHandler {
public:
    void onSetBasicTypeOk();
};
#endif //JNIDEMO_NATIVECALLBACKJAVAHANDLER_H

JNIEnv *env = JavaGlobalRef::GetEnv(); // 获取Java环境参数 env
必须通过jvm绑定Java线程后获取得env才能正常调用Java方法

JNIEnv *JavaGlobalRef::GetEnv() {
    int status;
    JNIEnv *_jniEnv = NULL;
    status = g_jvm->GetEnv((void **) &_jniEnv, JNI_VERSION_1_6);
    JavaVMAttachArgs args = {JNI_VERSION_1_6, __FUNCTION__, nullptr};
    if (status < 0) {
        status = g_jvm->AttachCurrentThread(&_jniEnv, &args);//获得了可以使用的env
        if (status < 0) {
            _jniEnv = NULL;
        }
    }
    return _jniEnv;
}

补充下NativeCallbackJavaHandler.cpp的调用类TypeTest.cpp

#include "TypeTest.h"
#include "ALog.h"

TypeTest::TypeTest() : callbackJavaHandler(nullptr) {
    // 构造函数初始化C++层专门回调Java的类
    callbackJavaHandler = new NativeCallbackJavaHandler;
}

TypeTest::~TypeTest() {
    callbackJavaHandler = nullptr;
}

void TypeTest::setBasicType(bool bl, char byte, unsigned short _char, short _short, int _int,
                            long long int _long, float _float, double _double) {
    alogd("setBasicType");
    if (callbackJavaHandler != nullptr) {
        // JNI 里面调用java方法成功后，C++回调Java
        callbackJavaHandler->onSetBasicTypeOk();
    }
}

ALog.h logcat输出C++层日志（）

#ifndef JNIDEMO_ALOG_H
#define JNIDEMO_ALOG_H

#include <android/log.h>

#define LOG_TAG "logtest"
#define alogd(...)  __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG,__VA_ARGS__);
// 输出文件名，方法名，行号 +（msg format待实现，需通过va_list拼接format）
//#define alogv(...)  __android_log_print(ANDROID_LOG_VERBOSE, LOG_TAG,"[%s]:[%s]:(%d):%s",__FILE_NAME__,__FUNCTION__ ,__LINE__,__VA_ARGS__);
//#define alogd(...)  __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG,"[%s]:[%s]:(%d) :%s",__FILE_NAME__,__FUNCTION__ ,__LINE__,##__VA_ARGS__);
//#define alogi(...)  __android_log_print(ANDROID_LOG_INFO, LOG_TAG,"[%s]:[%s]:(%d):%s",__FILE_NAME__,__FUNCTION__ ,__LINE__,__VA_ARGS__);
//#define alogw(...)  __android_log_print(ANDROID_LOG_WARN, LOG_TAG,"[%s]:[%s]:(%d):%s",__FILE_NAME__,__FUNCTION__ ,__LINE__,__VA_ARGS__);
//#define aloge(...)  __android_log_print(ANDROID_LOG_ERROR, LOG_TAG,"[%s]:[%s]:(%d):%s",__FILE_NAME__,__FUNCTION__ ,__LINE__,__VA_ARGS__);
#endif //JNIDEMO_ALOG_H

补充下Java-jni-C++类型对比

java类型Jni类型C++类型C++字符串格式符（日志打印）
booleanjbooleanunsigned char%d
bytejbytechar%x(16进制)
charjcharunsigned short%c
shortjshortshort%hd (十进制显示)
intjintint%d %u(无符号整型)
longjlonglong long%lld
floatjfloatfloat%f
doublejdoubledouble%f
%p 指针

基本类型签名：

JavaNativeSignature
bytejbyteB
charjcharC
doublejdoubleD
floatjfloatF
intjintI
shortjshortS
longjlongJ
booleanjbooleanZ
voidvoidV

引用数据类型的签名（对象以L开头“;”分号结尾，不同参数签名间没有符号）

JavaNativeSignature
所有对象jobjectL+classname +;
ClassjclassLjava/lang/Class;
StringjstringLjava/lang/String;
Object[]jobjectArray[L+classname +;
byte[]jbyteArray[B
 jmethodID id_onSetBasicTypeOk = env->GetMethodID(cls_handler, name_onSetBasicTypeOk,
                                                     "(Ljava/lang/String;)V");

“(Ljava/lang/String;)V” 即为java方法的签名 （括号内为参数签名，V表示无返回值）
“(Ljava/lang/String;)I” ,表示返回int 类型参数，以此类推

最后

以上就是帅气钢笔为你收集整理的JNI使用及简单封装前言一、Java调用C++二、C++调用(回调)Java方法的全部内容，希望文章能够帮你解决JNI使用及简单封装前言一、Java调用C++二、C++调用(回调)Java方法所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
点赞(38)

相关文章

JNI问题<转>
JNI问题<转>
Android之jni解决JNIEnv跨线程问题
Android之jni解决JNIEnv跨线程问题
android jni 方法定义,Android JNI与NDK编程
android jni 方法定义,Android JNI与NDK编程
JVM启动过程的重要数据结构
JVM启动过程的重要数据结构
JNI使用及简单封装前言一、Java调用C++二、C++调用(回调)Java方法
JNI使用及简单封装前言一、Java调用C++二、C++调用(回调)Java方法
JNI 学习笔记
JNI 学习笔记
Android调用JNI的实现方法概述调用JNI接口的方法后记
Android调用JNI的实现方法概述调用JNI接口的方法后记
【Android NDK 开发】JNI 线程 ( JNI 线程创建 | 线程执行函数 | 非 JNI 方法获取 JNIEnv 与 Java 对象 | 线程获取 JNIEnv | 全局变量设置 )
【Android NDK 开发】JNI 线程 ( JNI 线程创建 | 线程执行函数 | 非 JNI 方法获取 JNIEnv 与 Java 对象 | 线程获取 JNIEnv | 全局变量设置 )

评论列表共有 0 条评论

立即
投稿
返回
顶部