Android Stduio下通过JNI接口调用C++库（二）

一、上一篇记录了Android如何调用JNI（Android Studio下通过JNI接口调用C++库（一）），这一篇记录Android如何通过JNI调用C++库

二、首先编写C++库（这里要确保你编写的C++库在本地是可以编译通过可以运行的），具体的代码可以看这里

1、根目录下面的CMakeLists.txt文件

cmake_minimum_required(VERSION 3.6.0)
project(verify_project)

include_directories(${PROJECT_SOURCE_DIR}/src)

set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)

set(CMAKE_POSITION_INDEPENDENT_CODE ON)
set(CMAKE_INSTALL_PREFIX ${CMAKE_SOURCE_DIR}/out)

if(WIN32)
    set(LOCAL_PLATFROM windows/${CMAKE_BUILD_TYPE})
    set(os_name windows)
elseif(UNIX AND NOT ANDROID AND NOT APPLE)
    set(LOCAL_PLATFROM linux)
    set(os_name linux)
elseif(APPLE AND NOT IOS)
    set(LOCAL_PLATFROM macos)
    set(os_name macos)
elseif(ANDROID)
    set(LOCAL_PLATFROM ${CMAKE_ANDROID_ARCH_ABI})
    set(os_name android)
endif()

add_subdirectory(${PROJECT_SOURCE_DIR}/src)
if(BUILD_EXAMPLE)
add_subdirectory(${PROJECT_SOURCE_DIR}/example)
endif()

2、新建 src文件夹和example文件夹，src/CMakeLists.txt文件

add_library(verify
        ./verify_callback.cpp
        ./verify_test.cpp
        ./verify_class.cpp
        )

# INSTALL(FILES ${HEADERS} DESTINATION ${os_name}/include)

INSTALL(TARGETS verify DESTINATION ${os_name}/lib/${LOCAL_PLATFROM})
INSTALL(FILES ${CMAKE_SOURCE_DIR}/src/verify_callback.h DESTINATION ${os_name}/include/verify)
INSTALL(FILES ${CMAKE_SOURCE_DIR}/src/verify_test.h DESTINATION ${os_name}/include/verify)
INSTALL(FILES ${CMAKE_SOURCE_DIR}/src/verify_class.h DESTINATION ${os_name}/include/verify)
if(MSVC)
    INSTALL(FILES ${PROJECT_BINARY_DIR}/src/Debug/verify.pdb
        DESTINATION ${os_name}/lib/${LOCAL_PLATFROM}
        CONFIGURATIONS Debug)
endif()

3、src/verify_callback.h

#pragma once

#include <cstdint>
#include <functional>

using Callback = std::function<void(int)>;

void RegisteCallback(Callback callback);

void Start();

void Stop();

4、src/verify_callback.cpp

#include "verify_callback.h"

#include <iostream>

#include <thread>

class ValueCallback {
public:
    static ValueCallback& GetInstance() {
        static ValueCallback instance;
        return instance;
    }

    void Start() {
        if (running_) { return; }
        running_ = true;
        work_thread_ = std::thread(&ValueCallback::WorkFunc, this);
    }

    void Stop() {
        if (!running_) { return; }
        running_ = false;
        work_thread_.join();
    }

    void RegisteCallback(Callback callback) { callback_ = callback; }

private:
    ValueCallback() {}
    ValueCallback(const ValueCallback&) = delete;
    ValueCallback& operator=(const ValueCallback&) = delete;
    ~ValueCallback() {}

    void WorkFunc() {
        while (running_) {
            int value = rand() % 9999;
            if (value > 5555 && value < 5600) {
                std::cout << "callback" << std::endl;
                callback_(value);
            }
            std::this_thread::sleep_for(std::chrono::milliseconds(10));
        }
    }

private:
    bool running_ = false;
    std::thread work_thread_;
    Callback callback_;
};

void RegisteCallback(Callback callback) {
    ValueCallback::GetInstance().RegisteCallback(callback);
}

void Start() { ValueCallback::GetInstance().Start(); }

void Stop() { ValueCallback::GetInstance().Stop(); }

5、src/verify_class.h

#pragma once

#include <cstdint>
#include <string>
#include <unordered_map>

class VerifyClass {
public:
    VerifyClass();

    ~VerifyClass();

    void SetValue(uint32_t id, const std::string& value);

    std::string GetValue(uint32_t id);

private:
    std::unordered_map<uint32_t, std::string> value_map_;
};

6、src/verify_class.cpp

#include "verify_class.h"
// std::unordered_map<uint32_t, std::string> value_map_;
VerifyClass::VerifyClass() {}

VerifyClass::~VerifyClass() {}

void VerifyClass::SetValue(uint32_t id, const std::string& value) {
    value_map_[id] = value;
}

std::string VerifyClass::GetValue(uint32_t id) {
    if (value_map_.find(id) == value_map_.end()) { return ""; }
    return value_map_[id];
}

7、src/verify_test.h

#pragma once

#include <cstdint>
#include <string>

uint32_t GetRandValue();

std::string GetStringValue();

8、src/verify_test.cpp

#include "verify_test.h"

#include <iostream>

uint32_t GetRandValue() { return rand() % 100; }

std::string GetStringValue() { return "hello jni"; }

9、example/main.cpp

#include <iostream>
#include <string>

#include "../src/verify_callback.h"
#include "../src/verify_class.h"
#include "../src/verify_test.h"

int main(void) {
    RegisteCallback([](int val) { std::cout << "val:" << val << std::endl; });
    Start();

    VerifyClass verify_class;

    verify_class.SetValue(1,"hello");
    verify_class.SetValue(2,"world");

    std::cout << verify_class.GetValue(1) << std::endl;
    std::cout << verify_class.GetValue(2) << std::endl;

    std::cout << GetRandValue() << std::endl;
    std::cout << GetStringValue() << std::endl;

    getchar();
    Stop();
    return 0;
}

10、example/CMakeLists.txt

add_executable(verify_test ./main.cpp)
target_link_libraries(verify_test verify)

上面包含了回调，类，基本方法的使用

三、配置ANDROID_HOME和ANDROID_NDK_HOME，因为我是用的zsh，所以我就放在了.zshrc里面

export ANDROID_HOME=/Users/yangpan4485/Library/Android/sdk
export ANDROID_NDK_HOME=/Users/yangpan4485/Library/Android/sdk/ndk

四、编译Android构建脚本android_build.sh，这里的构建脚本表示会编译arm64-v8a和armeabi-v7a这两个平台下面的so库

#!/bin/bash

if [ -z "${ANDROID_HOME}" ]; then
    echo "ANDROID_HOME is not set" && exit -1
fi

if [ -z "${ANDROID_NDK_HOME}" ]; then
    echo "ANDROID_NDK_HOME is not set" && exit -1
fi

CMAKE=`find $ANDROID_HOME -name cmake | grep bin`
TOOLCHAIN_FILE=$ANDROID_NDK_HOME/build/cmake/android.toolchain.cmake
BUILD_DIR=./build/android

echo "build android with ${CMAKE}"

ABI="arm64-v8a armeabi-v7a"

for abi in $ABI
do
    echo "**********************"
    echo "  ${abi} shared  "
    echo "**********************"

    if [ ! -d ${BUILD_DIR}/${abi} ]; then
        mkdir -p $BUILD_DIR/${abi} || exit -1
    fi
    cd $BUILD_DIR/${abi}

    ${CMAKE} \
        -DBUILD_SHARED_LIBS=ON                                      \
        -DCMAKE_TOOLCHAIN_FILE=${TOOLCHAIN_FILE}                    \
        -DANDROID_ABI="$abi"                                        \
        -DANDROID_NATIVE_API_LEVEL="android-19"                     \
        -DANDROID_STL="c++_shared"                                  \
        -DANDROID_CPP_FEATURES="rtti exceptions"                    \
        -DCMAKE_BUILD_TYPE=Release                                  \
        ../../..

    if [ $? -ne 0 ]; then
        exit -1
    fi

    make -j4 && make install/strip  || exit -1
    cd -

done

五、执行./android_build.sh，这个时候如果当前ndk的版本过高的话，那么构建会出现问题，需要重新下载ndk

六、重新下载ndk，我这里下载的是16b版本，然后解压更换原来的ndk

下载地址：https://developer.android.google.cn/ndk/downloads/

七、重新执行./android_build.sh，这个时候会生成对应Android平台的so库，应该是在out目录下

八、新建Android工程（具体可参考上一篇文章），将生成的so库和头文件拷贝到对应目录下面，然后在jni层使用C++库里面的方法

我这里将头文件放在了verify/src/main/cpp/include目录下面

将so文件放在了verify/src/main/jniLibs目录下面

九、编写jni程序

1、这里我仍然是新建了一个Android Library命名为verify，然后新建3个class(VerifyCallback,VerifyClass,VerifyTest)和1个interface(TransmitterVerifyListener)，这四个文件的内容如下

（1）VerifyCallback.java

package com.example.verify;

public class VerifyCallback {
    static{
        System.loadLibrary("verify_android");
    }

    private TransmitterVerifyListener mTransmitterVerifyListener;

    public void registeVerifyListener(TransmitterVerifyListener transmitterVerifyListener){
        mTransmitterVerifyListener = transmitterVerifyListener;
    }

    public native void start();

    public native void stop();

    public native void startListenTransmitter();
}

（2）VerifyClass.java

package com.example.verify;

public class VerifyClass {
    static {
        System.loadLibrary("verify_android");
    }

    public native long createObject();

    public native void setValue(long verify , int id,String value);

    public native String getValue(long verify , int id);
}

（3）VerifyTest.java

package com.example.verify;

public class VerifyTest {
    static{
        System.loadLibrary("verify_android");
    }

    public native int getRandValue();

    public native String getStringValue();
}

（4）TransmitterVerifyListener.java

package com.example.verify;

public interface TransmitterVerifyListener {
    public void onTransmitterVerifyValue(int value);
}

然后将3个class使用javah生成jni文件，目录结构如下所示

2、将这3个jni文件拷贝的cpp目录下面，然后新建这3个.h文件对应的.cpp文件（这里我重新命名了），然后再新建一个jni_helper.h和jni_helper.cpp文件，目录结构如下所示

其中jni_helper.h,jni_helper.cpp和其它几个cpp文件的内容如下

（1）jni_helper.h

//
// Created by yangpan4485 on 2020-02-24.
//

#ifndef VERIFYTEST_JNI_HELPER_H
#define VERIFYTEST_JNI_HELPER_H

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

struct VerifyFields {
    struct {
        jfieldID verify_instance;
    } native_object;

    struct {
        jmethodID onTransmitter;
    }verify_callback;
};

/// 获取缓存的 Fields
VerifyFields &GetVerifyFields();

/// 获取当前线程的 Env
JNIEnv *GetJNIEnv();

void DetachCurrentThread();

/// 把 jstring 转换为 std::string
std::string JstringToString(JNIEnv* env,jstring val);

#endif //VERIFYTEST_JNI_HELPER_H

（2）jni_helper.cpp

#include "jni_helper.h"

#include <stdexcept>

#include <jni.h>
#include <pthread.h>
#include <sys/types.h>
#include <string>
#include <iostream>

#include <android/log.h>

#define TAG    "verify-jni" // 这个是自定义的LOG的标识
#define LOGD(...)  __android_log_print(ANDROID_LOG_DEBUG,TAG,__VA_ARGS__) // 定义LOGD类型

JavaVM *myVm = nullptr;

/// 获取缓存的 Fields
VerifyFields &GetVerifyFields(){
    static VerifyFields fields;
    return fields;
}

/// 获取当前线程的 Env
JNIEnv *GetJNIEnv(){
    JNIEnv *env = NULL;
    if ((myVm)->GetEnv((void **)&env, JNI_VERSION_1_6) != JNI_OK) {
        int status = (myVm)->AttachCurrentThread(&env, 0);
        if (status < 0) {
            LOGD("###failed to attach current thread");
            return NULL;
        }
    }
    return env;
}

void DetachCurrentThread(){
    myVm->DetachCurrentThread();
}

/// 把 jstring 转换为 std::string
std::string JstringToString(JNIEnv* env,jstring val){
    jboolean isCopy;
    const char* char_val = env->GetStringUTFChars(val, &isCopy);
    std::string str_val(char_val);
    if (isCopy == JNI_TRUE){
        env->ReleaseStringUTFChars(val, char_val);
    }
    return str_val;
}

jint JNI_OnLoad(JavaVM *vm, void *reserved) {
    myVm = vm;

    if (myVm) {
        LOGD("###m_vm init success");
    } else {
        LOGD("###m_vm init failed");
    }

    JNIEnv *env = NULL;
    if ((vm)->GetEnv((void **)&env, JNI_VERSION_1_4) != JNI_OK) { return -1; }

    VerifyFields &fields = GetVerifyFields();
    // com.example.verify;
    jclass clazz = env->FindClass("com/example/verify/VerifyCallback");
    fields.native_object.verify_instance = env->GetFieldID(
            clazz, "mTransmitterVerifyListener",
            "Lcom/example/verify/TransmitterVerifyListener;");

    clazz = env->FindClass("com/example/verify/TransmitterVerifyListener");
    fields.verify_callback.onTransmitter = env->GetMethodID(clazz,"onTransmitterVerifyValue","(I)V");

    LOGD("###m_vm init finish");
    return JNI_VERSION_1_6;
}

#undef GET_CLASS
#undef GET_ID

void JNI_OnUnload(JavaVM *vm, void *reserved) {
    JNIEnv *env = NULL;
    if ((vm)->GetEnv((void **)&env, JNI_VERSION_1_6) != JNI_OK) {
        LOGD("###get env error");
    }
    myVm = nullptr;
}

（3）verify_callback_jni.cpp

#include "verify_callback_jni.h"

#include <android/log.h>
#include <pthread.h>
#include <stdlib.h>
#include <future>
#include <iostream>

#include "jni_helper.h"
#include "verify_callback.h"

#define TAG "verify-callback-jni"  // 这个是自定义的LOG的标识
#define LOGD(...) \
    __android_log_print(ANDROID_LOG_DEBUG, TAG, __VA_ARGS__)  // 定义LOGD类型


jobject verify_obj;

JNIEXPORT void JNICALL Java_com_example_verify_VerifyCallback_start
  (JNIEnv *env, jobject obj){
    Start();
}


JNIEXPORT void JNICALL Java_com_example_verify_VerifyCallback_stop
  (JNIEnv *env, jobject obj){
    Stop();
}

void HandlerCallback(int val){
    auto jni_env = GetJNIEnv();
    auto verify_id = GetVerifyFields().verify_callback.onTransmitter;
    jni_env->CallVoidMethod(verify_obj, verify_id, val);
    DetachCurrentThread();

}

JNIEXPORT void JNICALL Java_com_example_verify_VerifyCallback_startListenTransmitter
  (JNIEnv *env, jobject obj){
    jobject mobj = env->GetObjectField(
            obj, GetVerifyFields().native_object.verify_instance);
    verify_obj = env->NewGlobalRef(mobj);

    LOGD("###Start");

        RegisteCallback([](int val) {
            LOGD("###kCallback");
            HandlerCallback(val);
         });
  }

（4）verify_class_jni.cpp

#include "verify_class_jni.h"

#include <android/log.h>
#include <pthread.h>
#include <stdlib.h>
#include <future>
#include <iostream>

#include "jni_helper.h"
#include "include/verify/verify_class.h"

#define TAG "verify-class-jni"  // 这个是自定义的LOG的标识
#define LOGD(...) \
    __android_log_print(ANDROID_LOG_DEBUG, TAG, __VA_ARGS__)  // 定义LOGD类型


JNIEXPORT jlong JNICALL Java_com_example_verify_VerifyClass_createObject
  (JNIEnv *env, jobject obj){
  VerifyClass* verify_clz = new VerifyClass();
  return (jlong)verify_clz;
}

JNIEXPORT void JNICALL Java_com_example_verify_VerifyClass_setValue
  (JNIEnv *env, jobject obj, jlong verify, jint key, jstring value){
  VerifyClass* verify_clz = (VerifyClass*)verify;
  int i_key = key;
  std::string str_value = JstringToString(env,value);
  verify_clz->SetValue(key,str_value);
}

JNIEXPORT jstring JNICALL Java_com_example_verify_VerifyClass_getValue
  (JNIEnv *env, jobject obj, jlong verify, jint key){
  int i_key = key;
  VerifyClass* verify_clz = (VerifyClass*)verify;
  std::string str_value = verify_clz->GetValue(i_key);
  return env->NewStringUTF(str_value.c_str());
}

（5）verify_test_jni.cpp

#include "verify_test_jni.h"

#include <android/log.h>
#include <pthread.h>
#include <stdlib.h>
#include <future>
#include <iostream>

#include "jni_helper.h"
#include "include/verify/verify_test.h"

#define TAG "verify-class-jni"  // 这个是自定义的LOG的标识
#define LOGD(...) \
    __android_log_print(ANDROID_LOG_DEBUG, TAG, __VA_ARGS__)  // 定义LOGD类型

JNIEXPORT jint JNICALL Java_com_example_verify_VerifyTest_getRandValue
  (JNIEnv *env, jobject obj){
  uint32_t val = GetRandValue();
  return val;
}


JNIEXPORT jstring JNICALL Java_com_example_verify_VerifyTest_getStringValue
  (JNIEnv *env, jobject obj){
  std::string str = GetStringValue();
  return env->NewStringUTF(str.c_str());
}

3、修改verify目录下面的CMakeLists.txt文件

# For more information about using CMake with Android Studio, read the
# documentation: https://d.android.com/studio/projects/add-native-code.html

# Sets the minimum version of CMake required to build the native library.

cmake_minimum_required(VERSION 3.4.1)

# Creates and names a library, sets it as either STATIC
# or SHARED, and provides the relative paths to its source code.
# You can define multiple libraries, and CMake builds them for you.
# Gradle automatically packages shared libraries with your APK.

include_directories(
        ${CMAKE_SOURCE_DIR}/src/main/cpp
        ${CMAKE_SOURCE_DIR}/src/main/cpp/include/verify
)

add_library( # Sets the name of the library.
        verify_android

        # Sets the library as a shared library.
        SHARED

        # Provides a relative path to your source file(s).
        src/main/cpp/jni_helper.cpp
        src/main/cpp/verify_callback_jni.cpp
        src/main/cpp/verify_class_jni.cpp
        src/main/cpp/verify_test_jni.cpp
        )

# Searches for a specified prebuilt library and stores the path as a
# variable. Because CMake includes system libraries in the search path by
# default, you only need to specify the name of the public NDK library
# you want to add. CMake verifies that the library exists before
# completing its build.

find_library( # Sets the name of the path variable.
        log-lib

        # Specifies the name of the NDK library that
        # you want CMake to locate.
        log)

# Specifies libraries CMake should link to your target library. You
# can link multiple libraries, such as libraries you define in this
# build script, prebuilt third-party libraries, or system libraries.

add_library(
        verify
        SHARED
        IMPORTED
)

set_target_properties( verify
        PROPERTIES IMPORTED_LOCATION
        ${CMAKE_SOURCE_DIR}/src/main/jniLibs/${ANDROID_ABI}/libverify.so)



target_link_libraries( # Specifies the target library.
        verify_android

        verify

        # Links the target library to the log library
        # included in the NDK.
        ${log-lib})

4、编写测试程序

（1）MainActivity.java

package com.example.verifytest;

import androidx.appcompat.app.AppCompatActivity;

import android.os.Bundle;

public class MainActivity extends AppCompatActivity {

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

        mVerify = new Verify();
        mVerify.startVerify();
    }
}

（2） Verify.java

package com.example.verifytest;

import android.util.Log;

import com.example.verify.VerifyTest;
import com.example.verify.TransmitterVerifyListener;
import com.example.verify.VerifyCallback;
import com.example.verify.VerifyClass;

public class Verify {

    private TransmitterVerifyListener mTransmitterVerifyListener;
    private VerifyTest mVerifyTest;
    private VerifyCallback mVerifyCallback;
    private VerifyClass mVerifyClass;
    public Verify(){

    }

    public void startVerify(){
        mTransmitterVerifyListener = new TransmitterVerifyListener() {
            @Override
            public void onTransmitterVerifyValue(int value) {
                Log.d("####", "value:"+value);
            }
        };

        mVerifyTest = new VerifyTest();
        mVerifyCallback = new VerifyCallback();
        mVerifyClass = new VerifyClass();

        Log.d("###","rand value:" + mVerifyTest.getRandValue());
        Log.d("###","string value:" + mVerifyTest.getStringValue());

        mVerifyCallback.registeVerifyListener(mTransmitterVerifyListener);
        mVerifyCallback.startListenTransmitter();
        mVerifyCallback.start();

        long clz_obj = mVerifyClass.createObject();
        mVerifyClass.setValue(clz_obj,1,"hello");
        Log.d("###","get value:"+mVerifyClass.getValue(clz_obj,1));

        int value = 0;
        while(true){
            value++;
            if(value > 100){
                break;
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        mVerifyCallback.stop();
    }
}

十、运行程序，观察结果

十一、项目对应的github地址

github：https://github.com/yangpan4485/AndroidJnitest

oracle报错7001,Oracle 10g expdp导出报错ORA-4031的解决方法

数据库是10.2.0.4 操作系统是aix,在执行expdp导出多个方案对象时报ORA-39014,ORA-39029,ORA-31671,ORA-39079,ORA-06512,ORA-0403 数据库是10.2.0.4 操作系统是aix,在执行expdp导出多个

【超多代码、超多图解】Node.js一文全解析

安装指定版本的nodejs

node有一个模块n，是专门用来管理node.js的版本的。 1、安装n模块 npm install -g n 报错则改用另一条命令：npm install -

unity中的Network Identity

介绍 unity中的Network Identity

Apache Kafka：开启单机版的RestApi

当前版本：kafka_2.12-2.8.0、CentOS7 1. 声明当前内容主要为本人学习和测试开启Kafka的RestApi的方式，当前

java中集合怎么定义_java集合框架中List的定义以及一些注意事项

大家知道,集合框架是为了表示和操作集合而规定的一种统一的标准的体系结构,学习集合知识有利于我们解决一系列例如保存数据与对象的问题。常用的集合在系统中定义了两大接口，List和Set 这里我们就来讨论一下List 的定义以及一些常见的问题

Redis入门(六)应用问题

如何打造易用的DevOps工具链

内容来源：2017年6月10日，易维科技联合创始人在任发科“DevOps&SRE 超越传统运维之道”进行《如何打造易用的DevOps工具链》演讲分享。IT 大咖说作为独家视频合作方，经主办方和讲者审

CSS动画-Animation

一、动画介绍动画( animation)是CSS3中具有颠覆性的特征之ー,可通过设置多个节点来精确控制一个或一组动画常用来实现复杂的动画效果。相比较过渡，动画可以实现更多变化，更多控制

LeetCode算法题整理(200题左右)

目录前言