NDK开发（九） ：Hello jniCallback

最新推荐文章于 2024-04-15 10:50:28 发布
最新推荐文章于 2024-04-15 10:50:28 发布
阅读量531 收藏 2
点赞数
分类专栏： NDK 文章标签： JNI NDK
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lxk_1993/article/details/100019976
版权

转载请以链接形式标明出处：
本文出自:103style的博客

本文操作以 Android Studio 3.5 版本为例

本文为参考官方示例 hello-jniCallback 动手写的 Demo.

功能介绍

  • 通过 JNI 获取并调用静态内部类 JniHandler 的 静态方法getBuildVersion() 和 公开方法getRuntimeMemorySize()获取 当前的系统版本 以及 当前可用内存。
  • 通过 JNI 线程 实现 开始和停止每秒打印距离开始计时的秒数。

编写测试代码

  • 编写测试代码 JniCallbackDemo.

    public class JniCallbackDemo {
    private static final String TAG = "JniCallbackDemo";
    static {
        System.loadLibrary("jni_callback");
    }
    private int timeCount;
    public native void startTiming();
    public native void stopTiming();

    private void printTime() {
        Log.e(TAG, "timeCount = " + timeCount);
        timeCount++;
    }
    public static class JniHandler {
        public static String getBuildVersion() {
            return Build.VERSION.RELEASE;
        }
        public long getRuntimeMemorySize() {
            return Runtime.getRuntime().freeMemory();
        }
        private void updateStatus(String msg) {
            if (msg.toLowerCase().contains("error")) {
                Log.e("JniHandler", "Native Err: " + msg);
            } else {
                Log.i("JniHandler", "Native Msg: " + msg);
            }
        }
    }
}

  • 创建 jni_callback.cpp.

  • 添加以下代码到CMakeLists.txt.

    add_library(
        jni_callback
        SHARED
        jni_callback.cpp)
target_link_libraries(
        jni_callback
        ${log-lib})

通过JNI实现功能逻辑

  • 获取当前的系统版本和可用内存。

    • 因为这个只需要执行一次就好了，我们可以放到JNI_OnLoad方法中去实现(在应用层调用.so库首先会执行 JNI_OnLoad 方法)。
    • 获取内部类用 $ 而不是 .，例如：
      env->FindClass("com/lxk/ndkdemo/JniCallbackDemo$JniHandler");.
    • 这里构建了一个结构体jniCallback保存获取的 类 和 实例。
    void queryRuntimeInfo(JNIEnv *env) {
    //获取getBuildVersion的方法id
    jmethodID staticMethodId = env->GetStaticMethodID(jniCallback.jniHandlerClz, "getBuildVersion",
                                                      "()Ljava/lang/String;");
    if (!staticMethodId) {
        LOGE("Failed to retrieve getBuildVersion() methodID");
        return;
    }
    //执行静态方法获取getBuildVersion的方法id
    jstring releaseVersion = static_cast<jstring>(env->CallStaticObjectMethod(
            jniCallback.jniHandlerClz, staticMethodId));
    //获取字符串的地址
    const char *version = env->GetStringUTFChars(releaseVersion, nullptr);
    if (!version) {
        LOGE("Unable to get version string");
        return;
    }
    LOGD("releaseVersion = %s", version);
    //释放字符串的内存
    env->ReleaseStringUTFChars(releaseVersion, version);
    //删除引用
    env->DeleteLocalRef(releaseVersion);

    //获取非静态方法 getRuntimeMemorySize 的id
    jmethodID methodId = env->GetMethodID(jniCallback.jniHandlerClz, "getRuntimeMemorySize", "()J");
    if (!methodId) {
        LOGE("Failed to retrieve getRuntimeMemorySize() methodID");
        return;
    }
    //调用 getRuntimeMemorySize
    jlong freeMemorySize = env->CallLongMethod(jniCallback.jniHandlerObj, methodId);

    //打印可用内存
    LOGD("Runtime free memory size: %"
                 PRId64, freeMemorySize);
}

JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *reserved) {
    LOGD("JNI_OnLoad");
    JNIEnv *env;
    //给jniCallback初始化地址
    memset(&jniCallback, 0, sizeof(jniCallback));

    jniCallback.javaVM = vm;

    if (vm->GetEnv(reinterpret_cast<void **>(&env), JNI_VERSION_1_6) != JNI_OK) {
        return JNI_ERR;
    }
    //获取JniCallbackDemo.JniHandler 类
    jclass clz = env->FindClass("com/lxk/ndkdemo/JniCallbackDemo$JniHandler");
    //赋值到结构体
    jniCallback.jniHandlerClz = static_cast<jclass>(env->NewGlobalRef(clz));
    if (!clz) {
        LOGE("FindClass JniCallbackDemo$JniHandler error");
        return JNI_ERR;
    }
    //获取构造函数
    jmethodID initMethodId = env->GetMethodID(jniCallback.jniHandlerClz, "<init>", "()V");
    //构建类
    jobject instance = env->NewObject(jniCallback.jniHandlerClz, initMethodId);
    if (!instance) {
        LOGE("NewObject jniHandler error")
        return JNI_ERR;
    }
    //赋值到结构体
    jniCallback.jniHandlerObj = env->NewGlobalRef(instance);

    //调用 JniHandler 的相关方法
    queryRuntimeInfo(env);

    jniCallback.done = 0;
    jniCallback.jniCallbackDemoObj = nullptr;
    return JNI_VERSION_1_6;
}

  • 创建线程执实现开始计时的逻辑：

    • 通过pthread_create创建线程的时候，第一个参数：线程id的指针；第二个参数：线程属性的指针；第一个参数：在线程中运行的函数；第四个参数：运行函数的参数
    extern "C"
JNIEXPORT void JNICALL
Java_com_lxk_ndkdemo_JniCallbackDemo_startTiming(JNIEnv *env, jobject instance) {
    LOGD("jni startTiming");

    //线程ID
    pthread_t threadInfo;
    //线程属性
    pthread_attr_t threadAttr;
    //初始化线程属性
    pthread_attr_init(&threadAttr);
    //设置脱离状态的属性
    pthread_attr_setdetachstate(&threadAttr, PTHREAD_CREATE_DETACHED);

    //互斥锁
    pthread_mutex_t lock;
    //初始化互斥锁
    pthread_mutex_init(&lock, nullptr);

    //获取当前类
    jclass clz = env->GetObjectClass(instance);
    //保存类和 实例 到 结构体中
    jniCallback.jniCallbackDemoClz = static_cast<jclass>(env->NewGlobalRef(clz));
    jniCallback.jniCallbackDemoObj = env->NewGlobalRef(instance);

    // StartTiming ：在线程中运行的函数  jniCallback 运行函数的参数
    int result = pthread_create(&threadInfo, &threadAttr, StartTiming, &jniCallback);
    assert(result == 0);
    //删除线程属性
    pthread_attr_destroy(&threadAttr);
}

  • 线程的执行函数：

    /**
 * 调用 类 instance 的 void方法 methodId
 */
void sendJavaMsg(JNIEnv *env, jobject instance, jmethodID methodId, const char *msg) {
    LOGD("jni sendJavaMsg");
    //获取字符串
    jstring javaMsg = env->NewStringUTF(msg);
    //调用对应方法
    env->CallVoidMethod(instance, methodId, javaMsg);
    //删除本地引用
    env->DeleteLocalRef(javaMsg);
}

void *StartTiming(void *context) {
    //获取参数
    JniCallback *JniCallback = static_cast<jni_callback *>(context);
    JavaVM *javaVm = JniCallback->javaVM;
    JNIEnv *env;

    jint res = javaVm->GetEnv((void **) (&env), JNI_VERSION_1_6);
    LOGD("javaVm->GetEnv() res = %d", res);
    if (res != JNI_OK) {
        //链接到虚拟机
        res = javaVm->AttachCurrentThread(&env, nullptr);
        if (JNI_OK != res) {
            LOGE("Failed to AttachCurrentThread, ErrorCode = %d", res);
            return nullptr;
        }
    } else {
        LOGE("javaVm GetEnv JNI_OK");
    }

    //获取 JniHandler 的 updateStatus 函数
    jmethodID statusId = env->GetMethodID(JniCallback->jniHandlerClz, "updateStatus",
                                          "(Ljava/lang/String;)V");

    sendJavaMsg(env, JniCallback->jniHandlerObj, statusId, "TimeThread status: initializing...");
    //获取 JniCallbackDemo 的 printTime 函数
    jmethodID timerId = env->GetMethodID(JniCallback->jniCallbackDemoClz, "printTime", "()V");
    //声明时间变量
    struct timeval beginTime, curTime, usedTime, leftTime;
    const struct timeval kOneSecond = {
            (__kernel_time_t) 1,
            (__kernel_suseconds_t) 0
    };

    sendJavaMsg(env, JniCallback->jniHandlerObj, statusId,
                "TimeThread status: prepare startTiming ...");

    while (true) {
        //获取当前的时间 赋值给 beginTime
        gettimeofday(&beginTime, nullptr);
        //占有互斥锁
        pthread_mutex_lock(&JniCallback->lock);
        //获取当前的状态
        int done = JniCallback->done;
        if (JniCallback->done) {
            JniCallback->done = 0;
        }
        //释放互斥锁
        pthread_mutex_unlock(&JniCallback->lock);

        if (done) {
            LOGD("JniCallback done");
            break;
        }

        //调用 printTime 函数
        env->CallVoidMethod(JniCallback->jniCallbackDemoObj, timerId);

        //获取当前的时间 赋值给 curTime
        gettimeofday(&curTime, nullptr);

        //计算函数运行消耗的时间
        //usedTime = curTime - beginTime
        timersub(&curTime, &beginTime, &usedTime);

        //计算需要等待的时间
        //leftTime = kOneSecond - usedTime
        timersub(&kOneSecond, &usedTime, &leftTime);

        //构建等待的时间
        struct timespec sleepTime;
        sleepTime.tv_sec = leftTime.tv_sec;
        sleepTime.tv_nsec = leftTime.tv_usec * 1000;

        if (sleepTime.tv_sec <= 1) {
            //睡眠对应纳秒的时间
            nanosleep(&sleepTime, nullptr);
        } else {
            sendJavaMsg(env, JniCallback->jniHandlerObj, statusId,
                        "TimeThread error: processing too long!");
        }
    }
    sendJavaMsg(env, JniCallback->jniHandlerObj, statusId,
                "TimeThread status: ticking stopped");
    //释放线程
    javaVm->DetachCurrentThread();
    return context;
}

  • 停止计时的逻辑：

    extern "C"
JNIEXPORT void JNICALL
Java_com_lxk_ndkdemo_JniCallbackDemo_stopTiming(JNIEnv *env, jobject instance) {
    LOGD("jni stopTiming");

    //占用互斥锁
    pthread_mutex_lock(&jniCallback.lock);
    //修改线程运行的条件
    jniCallback.done = 1;
    //释放互斥锁
    pthread_mutex_unlock(&jniCallback.lock);

    //初始化等待时间
    struct timespec sleepTime;
    memset(&sleepTime, 0, sizeof(sleepTime));
    sleepTime.tv_nsec = 100000000;

    while (jniCallback.done) {
        nanosleep(&sleepTime, nullptr);
    }

    //删除引用
    env->DeleteGlobalRef(jniCallback.jniCallbackDemoClz);
    env->DeleteGlobalRef(jniCallback.jniCallbackDemoObj);
    jniCallback.jniCallbackDemoObj = nullptr;
    jniCallback.jniCallbackDemoClz = nullptr;

    //删除互斥锁
    pthread_mutex_destroy(&jniCallback.lock);
}

执行测试代码

private void testJniCallback() {
    jniCallbackRun(true);
}

private void jniCallbackRun(boolean run) {
    if (jniCallbackDemo == null) {
        jniCallbackDemo = new JniCallbackDemo();
    }
    if (run) {
        Toast.makeText(this, "开始计时，请查看控制台日志输出", Toast.LENGTH_SHORT).show();
        jniCallbackDemo.startTiming();
    } else {
        jniCallbackDemo.stopTiming();
    }
}

点击按钮jni callback test，在控制台即会输出以下信息。

08-22 17:00:34.726 18711-18711/com.lxk.ndkdemo D/JNI: [jni_callback.cpp][63]: JNI_OnLoad
08-22 17:00:34.726 18711-18711/com.lxk.ndkdemo D/JNI: [jni_callback.cpp][42]: releaseVersion = 6.0.1
08-22 17:00:34.726 18711-18711/com.lxk.ndkdemo D/JNI: [jni_callback.cpp][59]: Runtime free memory size: 2439224
08-22 17:00:34.726 18711-18711/com.lxk.ndkdemo D/JNI: [jni_callback.cpp][207]: jni startTiming
08-22 17:00:34.726 18711-18758/com.lxk.ndkdemo D/JNI: [jni_callback.cpp][120]: javaVm->GetEnv() res = -2
08-22 17:00:34.726 18711-18758/com.lxk.ndkdemo D/JNI: [jni_callback.cpp][104]: jni sendJavaMsg
08-22 17:00:34.736 18711-18758/com.lxk.ndkdemo I/JniHandler: Native Msg: TimeThread status: initializing...
08-22 17:00:34.736 18711-18758/com.lxk.ndkdemo D/JNI: [jni_callback.cpp][104]: jni sendJavaMsg
08-22 17:00:34.736 18711-18758/com.lxk.ndkdemo I/JniHandler: Native Msg: TimeThread status: prepare startTiming ...
08-22 17:00:34.736 18711-18758/com.lxk.ndkdemo E/JniCallbackDemo: timeCount = 0
08-22 17:00:35.736 18711-18758/com.lxk.ndkdemo E/JniCallbackDemo: timeCount = 1
08-22 17:00:36.736 18711-18758/com.lxk.ndkdemo E/JniCallbackDemo: timeCount = 2
08-22 17:00:37.736 18711-18758/com.lxk.ndkdemo E/JniCallbackDemo: timeCount = 3
08-22 17:00:38.736 18711-18758/com.lxk.ndkdemo E/JniCallbackDemo: timeCount = 4
08-22 17:00:39.736 18711-18758/com.lxk.ndkdemo E/JniCallbackDemo: timeCount = 5
08-22 17:00:40.736 18711-18758/com.lxk.ndkdemo E/JniCallbackDemo: timeCount = 6
08-22 17:00:41.736 18711-18758/com.lxk.ndkdemo E/JniCallbackDemo: timeCount = 7
...

相关文档

源码

以上

103style
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JNI C/C++ Callback from JAVA
跨链技术践行者
12-23 995
JNI是JAVA世界和底层世界沟通的重要桥梁，在Android的底层开发中用到的较多。相关知识在网络上也容易搜索到，这里也不再累述。 本篇文章，要介绍的是，在Java通过JNI传递一个callback函数到C/C++中。 JAVA层 首先你需要有个callback 的类： public interface BLDeviceInfoCallback { String deviceInfo(String did, String name, boolean state); } 然呢在你提供生..
JNI全局回调java方法
Muggle的博客
02-20 1380
一、实现思路： 1、jni里面调用java方法的大致步骤是：根据jobject获取jclass（静态方法就不用这一步了）--&gt; 获取jmethodid --&gt; 调用方法。 2、jni里面调用java方法的环境分为2种。 第一种：在env所在线程调用java方法，这种情况不需要做特殊处理，直接按照步骤执行即可。 第二种：在pthread子线程调用ja...
Android JNI 在C++多线程调用Java的回调函数
最新发布
dengfuma的专栏
04-15 586
【代码】Android JNI 在C++多线程调用Java的回调函数。
JNI 回调函数 Callback
05-01
JNI callback Android
JNI 函数以及复杂对象传递
小码农大梦想
10-31 1186
转载请注明出处：http://blog.csdn.net/qinjuning          在掌握了JNI函数的使用和相关类型的映射后，以及知晓何利用javah工具生成对应的jni函数以及如何生成动态     链接库 (windos下就是.dll库，Linux就是.so库了，不懂在Window下生成dll动态库的，具体流程可看我的这篇博客：
Android JNI 篇 - JNI回调的三种方法（精华篇 ndk）
T的专栏
12-10 3515
1、一般在JNI_OnLoad方法中保存JavaVM 2、之后新建一个初始化方法保存调用者jjobject，注意保存时要使用方法把局部变量“升级”为全局变量 g_obj = (*env)->NewGlobalRef(env, thiz); 自己的例子是：MyWebrtc ---------------------------------------------------------...
hello-jniCallback.zip
08-31
总的来说，这个"hello-jniCallback.zip"项目提供了一个学习和实践JNI回调功能的实例，涵盖了Android应用开发中的原生代码集成、JNI接口定义、CMake构建过程以及跨语言回调机制等重要知识点。对于想要深入理解Android...
hello-jniCallback_jni_android_
10-02
"hello-jniCallback"是一个常见的示例项目，用于演示如何在Android应用中使用JNI来调用C/C++代码，并实现回调机制。这个项目可以帮助开发者理解JNI的基本用法以及如何在Java和原生代码之间传递数据。 1. **JNI基础...
Android NDK开发之:配置环境的详解
01-21
一、Windows：Windows下的开发环境需要安装以下软件：Java JDK Apache ANT Build SystemAndroid SDKCygwinAndroid NDKEclipse IDE1、安装Java JDK...打开PATH键，在末尾增加 ;%JAVA_HOME%\bin检测：javac -version2、...
eclipse ndk Hello-jni
11-02
eclipse ndk Hello-jnieclipse ndk Hello-jnieclipse ndk Hello-jnieclipse ndk Hello-jni
Android-NDK-hello-jniCallback
CodeMyDream的专栏
05-05 357
项目目录
Android-Jni线程（三）— JNI全局回调java方法
ywl5320的专栏
12-07 5625
我的视频课程（基础）：《（NDK）FFmpeg打造Android万能音频播放器》 我的视频课程（进阶）：《（NDK）FFmpeg打造Android视频播放器》 我的视频课程（编码直播推流）：《Android视频编码和直播推流》 我的视频课程（C++ OpenGL）：《Android C++ OpenGL教程》 目录： Android-Jni线程（一...
11.JNI：本地线程进入Java层（很好的理解call back的原理）
qq_26553393的博客
02-15 97
0. 总览 1. 如何创建Native层的子线程？ 1.1 在C函数里创建子线程 2. Native线程进入Java层 3. Native多线程的安全 0. 总览 1. 如何创建Native层的子线程？ 1.1 在C函数里创建子线程 2. Native线程进入Java层 3. Native多线程的安全 ...
Android NDK开发(五)——C代码回调Java代码
Vincent的专栏
01-05 9644
在上篇博客里了解了Java层是怎样传递数据到C层代码，并且熟悉了大部分的实际开发知识，基本上掌握这些就可以做一个基本的NDK开发了，但是光是了解Java回调C层的数据是不是还不够啊，考虑问题要考虑可逆性，Java能回调C，那么C能否反过来回调Java呢？答案是肯定可以的，这篇博客就介绍一个C语言如何调用Java层的代码。以下是一些问题场景，我们带着这个问题场景来分析一下实现的过程。
jni 调用java接口_深入浅析jni中的java接口使用
weixin_42100129的博客
02-13 351
JNI中的java接口使用项目需求，需要在c++函数中监听相应的状态，并在java端进行一些列的处理。这个需要在JNI中写一个subscriber，注册后在需要的地方进行引入使用。目录结构初始化是AS上的c++工程文件，这边先暂时实现简单的demo，CdemoActivity是NativeActivity的实现，我们暂时别管，因为实现是c++层控制的，有兴趣可以去百度下主要涉及jnicallbac...
ANDROID jni 中的事件回调机制JNIenv的使用
Nio96的专栏
10-28 1351
android framework 里java调用native，使用JNI机制，java如何调用native，在framework里面的例子很多，有很多参考，可以方便的使用。 但是在一些native中如果涉及到了事件回调，需要在native里调用java对象，在framework 框架里也有这样的例子。 在项目里用到了这一机制。 在native 注册的时候首先保存java的调用方法：
Android Studio下JNI编程2（接上篇，详细讲解java与c层互传参数）
huangximin1990的专栏
03-09 1642
Android Studio下JNI环境搭建、编译、运行等可以参考： http://blog.csdn.net/huangximin1990/article/details/50441400 上篇文章讲述的JNI示例编程主要涉及两个文件： NativeKit.java cn_com_losy_jnitest_jni_NativeKit.cpp NativeKit.
jni c调用java_JNI初步(二)c调用java方法
weixin_36070797的博客
02-26 122
1.写Jni类 并且在下面写好需要被c调用的方法方法体也写好public class Jni {{System.loadLibrary("cCallJava");}public native int addCallBack();public int add(int a, int b) {Log.i("godv", "a+b = " + a + b);return a + b;}}2.利用 jav...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值