Android 中的 NDK 到底是什么？（详细解析+案例实战）

Posted 2023-04-03 Android每日一讲

NDK 提供了一系列的工具，帮助开发者快速开发 C (或 C++ )的动态库，并能自动将 so 和 java 应用一起打包成 apk；这些工具对开发者的帮助是巨大的

什么是 NDK ？

Android 原生开发包 NDK(Native Delopment kits )将用于 Android 平台上的 C++ 开发

Android NDK 是 Android 软件开发包（SDK）的相关工具集，用来扩展 android SDK 的功能，从而是开发人员能够使用机器代码生成的编程语言（如 C、C++ 和汇编语言）实现一些对代码行要求较高的模块并将这些模块嵌入到 Android 应用程序中

众所周知，Android 程序运行在 Dalvik 虚拟机中，NDK 允许用户使用类似 C / C++ 之类的原生代码语言执行部分程序

NDK 的定义

• Android NDK 不是一个单独的工具： 它是一个包含API、交叉编译器、链接程序、调试器、构建工具、文档和实例应用程序的综合工具集
• 在 Android 的官方文档上是这么解释 NDK 的：“原生开发套件 (NDK) 是一套工具，使您能够在 Android 应用中使用 C 和 C++ 代码，并提供众多平台库，您可使用这些平台库管理原生 Activity 和访问物理设备组件；例如传感器和轻触输入”
• NDK 是一个 Android 官方提供的一个开发套件与 Android SDK 相对应，NDK 是原生开发套件，而 SDK 是 JAVA 开发套件。NDK 使得 Android 应用可以利用 C++ 语言高效的计算性能，进一步提升App的性能，降低延迟。

说道这里，大家肯定要问 NDK 有那些应用场景，我为什么要用 NDK 呢，用 JAV 不行吗？

下面列举一些NDK 的应用场景

重用一些现成的库，例如已经用 C/C++ 编写好的 openCV 库
前面提到的高性能计算，例如很多 Bitmap 的处理到放在 NDK 进行处理
一些敏感信息的保护，例如密钥等信息（密钥等信息还是要经过加盐才能放到 NDK 中，不然还是
会有别反编译的风险）
知道了应用场景，大家肯定已经摩拳擦掌准备试一试了，先别着急。欲善其事，先利其器；以下给出了开发 NDK 的三大利器；

NDK 的三大开发组件

• NDK　　Android 原生开发套件

• CMAKE　外部编译工具

• LLDB　　原生代码调试工具

NDK 开发优点

• 利用 NDK 开发的库，不容易被反编译，保密性，安全性都提高了
• 很多开源工程和大工程都是 C/C++ 代码写的
• C/C++ 的代码运行速度和效率都比 Java 快很多

Android NDK 开发步骤

（1）JNI 接口设计；
（2）使用 C/C++ 本地实现方法；
（3）生成动态链接库；
（4）将动态链接库复制到 Java 工程，运行 Java 程序

NDK 基础实践

CMake

推荐使用 CMake 而不是传统 NDK-build 的方式，既然都用新的，自然有它的道理，简单方便
有很多人在配置 CMakeLists.txt 时编译不通过，是自己的问题吗？当然，难不成还是它的问题吗？

首先我们想要打出一个.so文件来，我们肯定是要先写Java代码

第一步：

解释一下这里代码的意思： native 这个就是我们提供出去的方法，这个方法到时候要和 .c 文件里面或者 .cc 文件里面的方法名一致，我们再静态中去加载我们打出来的 .so 文件， 这里的参数名字不是 .so 文件的名字，而是我们在打包的时候配置的名字，这个配置下面介绍

public class JniKit 
    //这里的方法名如果报错那是正常的，不影响
    public static native int calculate(int num);

    static 
        System.loadLibrary("JniDemo");
    

第二步：

我们需要根据这个写好的 Java 文件来生成一个 .h 文件，生成 .h 文件是通过 javah 来执行的，这里我之前尝试了各种办法，但是网上说的办法都没办法成功，都是报错说找不到类文件，我觉得这里可能和我的文件的方法有点问题，等会我把我现在成功的文件目录贴出来，执行的代码

javah -classpath D:\\360PhoneInfo\\small-video-record-master\\SmallVideoRecord2\\testndk\\build\\intermediates\\classes\\debug -d jni
 com.example.testndk.JniKit

根据这个代码我得到了.h文件，包括这个jni文件夹也是通过-d jni这个生成出来的，不是自己创建的

第三步：

现在我们有了 .h 文件了，接下来就是写 .c 文件了，当然了我不会 c 语言，所以这里拿了一个测试的来用, c 这部分的不用关注太多 include中指向你创建的 .h 头文件 Java_com_example_testndk_JniKit_calculate；Java 包名类名方法名（参数）

#include "com_example_testndk_JniKit.h"

JNIEXPORT jint JNICALL Java_com_example_testndk_JniKit_calculate(JNIEnv *env, jclass cls, jint num) 
    return num * num;

第四步：

现在 .h.c 文件我们都有了，接下来就是最关键的一步了，生成 .so 文件了，这一步，我查阅了很多资料，折磨了两个小时，才弄出来，这里我不知道是不是我的配置有问题，还是什么问题，反正我在 build.gradle 配置，然后去 Make Project 生成了很久没有生成出来，这里我是用命令行中的 ndk-build 来解决的

解决方式如下：

1、建立一个 Android.mk 文件

LOCAL_MODULE 表示模块名称 LOCAL_SRC_FILES 表示需要参与编译的源文件，就是我们的 c 除了这两个，其他照搬即可

LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)

LOCAL_MODULE := JniDemo
LOCAL_SRC_FILES := jni_test.c
LOCAL_LDLIBS +=-L$(SYSROOT)/usr/lib -lm -llog
include $(BUILD_SHARED_LIBRARY)

2、建立一个Application.mk文件

需要注意的东西都写在里面了，以逗号分割cpu指令

APP_STL := gnustl_static  
APP_CPPFLAGS := -frtti -fexceptions  
APP_ABI := armeabi-v7a       #这句是设置生成的cpu指令类型，提示，目前绝大部分安卓手机支持armeabi，libs下太多类型，编译进去 apk 包会过大  
APP_PLATFORM := android-8    #这句是设置最低安卓平台，可以不弄 

3、因为我的这两个文件是和 .h.c 放在同一个文件夹中 -jni，所以我们要执行 ndk-build 命令需要进入到 jni 文件夹下再去执行

这里给一个范例,传入字符串调用 so 库中的方法

public class JniUtil 
    static 
        System.loadLibrary("JniUtil");
    

    public static native void initialize(String string, String logPath);

extern "C"
JNIEXPORT void JNICALL Java_com_kxqin_livingrecognitiondemo_JniUtil_initialize
        (JNIEnv* env, jclass jclazz ,jstring jstring1, jstring logPath)
    //获取字符串指针，必须使用指针，不能使用char strContent[],因为GetStringUTFChars()返回值为const char *;
    const char *str = env->GetStringUTFChars(jstring1, JNI_FALSE);
    const char *path = env->GetStringUTFChars(logPath, JNI_FALSE);
    std::string log = path;
    std::string string = str;
    //头文件中的方法
    defence_native_initialize(string, log);
    //LOGD("initialize is success");

然后直接 JniUtil.initialize (String1,String2) 就可以调用到 cpp 中的方法了

试试在 Terminal 中输入

adb logcat | ndk-stack -sym app\\build\\intermediates\\cmake\\debug\\obj$ABI

将 $ABI 换为你的 ABI，正常情况下在模拟器上使用就是 x86，真机就是 armabi-v7a 或 arm64-v8a，
或许能帮你解决不少麻烦

总结

通过前面详细的讲解，我想各位读者应该对 NDK 有一个清晰的认识了下面让我在最后用一句话总结那就是NDK 则是 Android 妈咪谷歌提供的一种开发工具套件

如果想学习更多 Android 进阶知识或者获取音视频相关技术文档，请私信发送 “进阶” 即可直达；里面包含了面试资源系统整理分享，Java 语言进阶和 Kotlin 语言与 Android 相关技术内核， APP 开发框架知识、 Android 前沿技术，高级 UI、Gradle 等技术文档

好了，以上就是今天要分享的内容，大家觉得有用的话，可以点赞分享一下；如果文章中有什么问题欢迎大家指正；欢迎在评论区或后台讨论哈～

Android NDK pthreads详细使用

这个pthread.h文件可以在NDK环境里创建子线程，并对线程能够做出互斥所、等待、销毁等控制。

写这个博客的原因是我要写如何使用FFmpeg播放视频，因为同时需要播放音频和视频所以需要开启线程，并设置生产者和消费者的关系。

好了直接上整体

1.开启和销毁线程

pthread_create函数能够创建线程，第一个参数是线程的引用，第二个是线程的属性，一般为NULL，第三个为线程运行的函数，第四个是给线程运行函数的参数

pthread_create又是开启线程，只要运行了这个函数线程就会运行起来，也就是运行第三个参数所代表的函数

pthread_t pthreads;
pthread_create(&pthreads, NULL, threadFunc, (void *) "zzw");

等待线程完成和返回参数，这个如果开启线程只有一个可以不写，但是如果有多个线程这个就必须要写，不写的话只会运行第一个线程

int retvalue;
pthread_join(pthreads,(void**)&retvalue);
if(retvalue!=0){
    __android_log_print(ANDROID_LOG_ERROR,"hello","thread error occurred");
}

我们再来看看线程运行函数，这个他可以获取参数，并且能能够提前结束线程

void threadFunc(void arg){

char* str=(char*)arg;

for(int i=0;i<3;i++){
    __android_log_print(ANDROID_LOG_VERBOSE,"hello","i = %d arg = %s",i,str);
    //线程自杀，需要返回参数
    //pthread_exit((void*)2);
    //线程他杀
    //pthread_cancel()
}
return (void *) 0;

}

完整例子代码

#include <jni.h>
#include <string>
#include <android/log.h>
#define LOGE(FORMAT,...) android_log_print(ANDROID_LOG_ERROR,"LC XXX",FORMAT,##VA_ARGS__);

extern "C"
JNIEXPORT jstring
JNICALL
Java_com_example_zth_ndkthread_MainActivity_stringFromJNI(
JNIEnv env,
jobject / this */) {
std::string hello = "Hello from C++";
return env->NewStringUTF(hello.c_str());
}

void threadFunc(void arg){

char* str=(char*)arg;

for(int i=0;i<3;i++){
    __android_log_print(ANDROID_LOG_VERBOSE,"hello","i = %d arg = %s",i,str);
    //线程自杀，需要返回参数
    //pthread_exit((void*)2);
    //线程他杀
    //pthread_cancel()
}
return (void *) 0;

}

extern "C"
JNIEXPORT void JNICALL
Java_com_example_zth_ndkthread_MainActivity_startNativeThread(JNIEnv* env, jobject thiz,jint count) {

pthread_t pthreads;
pthread_create(&pthreads, NULL, threadFunc, (void *) "zzw");

int retvalue;
pthread_join(pthreads,(void**)&retvalue);
if(retvalue!=0){
    __android_log_print(ANDROID_LOG_ERROR,"hello","thread error occurred");
}

}

2.互斥锁

互斥锁指的是它能够锁住一段代码，使得这段代码在解锁之前不能再被执行一次，

初始化

pthread_mutex_t pthread_mutex;
if(pthread_mutex_init(&pthread_mutex,NULL)!=0)
    return;

开启线程时把互斥锁传给线程运行函数

for(int i=0;i<count;i++){
    pthread_create(&pthreads[i],NULL,threadFunc,&pthread_mutex);
}

我们再来看看线程运行函数
取出互斥锁并上锁

pthread_mutex_t* pthread_mutex=(pthread_mutex_t*)arg;
pthread_mutex_lock(pthread_mutex);

然后一段代码

for(int i=0;i<3;i++){
    __android_log_print(ANDROID_LOG_VERBOSE,"hello","i = %d",i);
}
__android_log_print(ANDROID_LOG_VERBOSE,"hello","————————————");

解锁

pthread_mutex_unlock(pthread_mutex);

最后销毁互斥锁

pthread_mutex_destroy(&pthread_mutex);

运行效果如下

03-02 14:25:58.346 10022-10077/com.example.zth.ndkthread V/hello: i = 0
03-02 14:25:58.346 10022-10077/com.example.zth.ndkthread V/hello: i = 1
03-02 14:25:58.346 10022-10077/com.example.zth.ndkthread V/hello: i = 2
03-02 14:25:58.346 10022-10077/com.example.zth.ndkthread V/hello: ------------------------
03-02 14:25:58.346 10022-10078/com.example.zth.ndkthread V/hello: i = 0
03-02 14:25:58.346 10022-10078/com.example.zth.ndkthread V/hello: i = 1
03-02 14:25:58.346 10022-10078/com.example.zth.ndkthread V/hello: i = 2
03-02 14:25:58.346 10022-10078/com.example.zth.ndkthread V/hello: ------------------------
03-02 14:25:58.347 10022-10079/com.example.zth.ndkthread V/hello: i = 0
03-02 14:25:58.347 10022-10079/com.example.zth.ndkthread V/hello: i = 1
03-02 14:25:58.347 10022-10079/com.example.zth.ndkthread V/hello: i = 2
03-02 14:25:58.347 10022-10079/com.example.zth.ndkthread V/hello: ————————————

如果我们没有加锁呢

pthread_mutex_t* pthread_mutex=(pthread_mutex_t*)arg;

// pthread_mutex_lock(pthread_mutex);
for(int i=0;i<3;i++){
android_log_print(ANDROID_LOG_VERBOSE,"hello","i = %d",i);
}
android_log_print(ANDROID_LOG_VERBOSE,"hello","------------------------");
// pthread_mutex_unlock(pthread_mutex);

结果如下

03-02 14:36:50.035 13815-13993/com.example.zth.ndkthread V/hello: i = 0
03-02 14:36:50.035 13815-13993/com.example.zth.ndkthread V/hello: i = 1
03-02 14:36:50.035 13815-13993/com.example.zth.ndkthread V/hello: i = 2
03-02 14:36:50.035 13815-13993/com.example.zth.ndkthread V/hello: ------------------------
03-02 14:36:50.035 13815-13994/com.example.zth.ndkthread V/hello: i = 0
03-02 14:36:50.035 13815-13994/com.example.zth.ndkthread V/hello: i = 1
03-02 14:36:50.035 13815-13994/com.example.zth.ndkthread V/hello: i = 2
03-02 14:36:50.035 13815-13995/com.example.zth.ndkthread V/hello: i = 0
03-02 14:36:50.035 13815-13994/com.example.zth.ndkthread V/hello: ------------------------
03-02 14:36:50.035 13815-13995/com.example.zth.ndkthread V/hello: i = 1
03-02 14:36:50.035 13815-13995/com.example.zth.ndkthread V/hello: i = 2
03-02 14:36:50.035 13815-13995/com.example.zth.ndkthread V/hello: ------------------------

所以互斥锁是先让一个线程做完，然后另外一个线程做。

例子代码：

#include <jni.h>
#include <string>
#include <android/log.h>
#include "pthread.h"
#define LOGE(FORMAT,...) android_log_print(ANDROID_LOG_ERROR,"LC XXX",FORMAT,##VA_ARGS__);

extern "C"
JNIEXPORT jstring
JNICALL
Java_com_example_zth_ndkthread_MainActivity_stringFromJNI(
JNIEnv env,
jobject / this */) {
std::string hello = "Hello from C++";
return env->NewStringUTF(hello.c_str());
}

void threadFunc(void arg){

pthread_mutex_t* pthread_mutex=(pthread_mutex_t*)arg;
pthread_mutex_lock(pthread_mutex);
for(int i=0;i<3;i++){
    __android_log_print(ANDROID_LOG_VERBOSE,"hello","i = %d",i);
}
__android_log_print(ANDROID_LOG_VERBOSE,"hello","------------------------");
pthread_mutex_unlock(pthread_mutex);
return (void *) 0;

}

extern "C"
JNIEXPORT void JNICALL
Java_com_example_zth_ndkthread_MainActivity_startNativeThread(JNIEnv* env, jobject thiz,jint count) {

pthread_mutex_t pthread_mutex;
if(pthread_mutex_init(&pthread_mutex,NULL)!=0)
    return;

pthread_t pthreads[count];
for(int i=0;i<count;i++){
    pthread_create(&pthreads[i],NULL,threadFunc,&pthread_mutex);
}

for(int i=0;i<count;i++){
    int retvalue=0;
    pthread_join(pthreads[i],(void**)&retvalue);
    if(retvalue!=0){
        __android_log_print(ANDROID_LOG_ERROR,"hello","thread error occurred");
    }
}

pthread_mutex_destroy(&pthread_mutex);

}

3.条件变量

视频解码的绘制使用的就是生产者—消费者的模式。比如说我们生产者生成的产品，放到一个队列里面，当生产者生产出产品的时候就会发送信号通知消费者去消费

这个条件变量能够唤醒线程运行

初始化

pthread_cond_init(&c,NULL);

开启生成者线程和消费者线程

pthread_create(&thread_producer, NULL, produce, (void *) "producer");
pthread_create(&thread_comsumer, NULL, comsume, (void *) "comsumer");

循环生产产品，然后提醒消费者

for(;;){
    pthread_mutex_lock(&m);
    productNum++;
    __android_log_print(ANDROID_LOG_VERBOSE,"hello","i = %d",productNum);
    pthread_cond_signal(&c);
    pthread_mutex_unlock(&m);

}

消费者线程如果发现没有产品就等待条件变量提醒，，如果有产品就消费掉

    pthread_mutex_lock(&m);
    while(productNum == 0){
        pthread_cond_wait(&c,&m);

    }
    productNum--;
    __android_log_print(ANDROID_LOG_VERBOSE,"hello","i = %d",productNum);
    pthread_mutex_unlock(&m);

注意生成者与消费者线程运行的全过程都在互斥锁下，都是按顺序一一执行的，这样对于全局变量productNum的计算就不会错误，并且通过一个线程执行pthread_cond_signal来触发另一个线程执行

例子代码

#include <jni.h>
#include <string>
#include <android/log.h>
#include "pthread.h"
#define LOGE(FORMAT,...) android_log_print(ANDROID_LOG_ERROR,"LC XXX",FORMAT,##VA_ARGS__);

extern "C"
JNIEXPORT jstring
JNICALL
Java_com_example_zth_ndkthread_MainActivity_stringFromJNI(
JNIEnv env,
jobject / this */) {
std::string hello = "Hello from C++";
return env->NewStringUTF(hello.c_str());
}

int productNum = 0;
pthread_mutex_t m;
pthread_cond_t c;

void produce(void arg){
char no = (char)arg;
for(;;){
pthread_mutex_lock(&m);
productNum++;
__android_log_print(ANDROID_LOG_VERBOSE,"hello","i = %d",productNum);
pthread_cond_signal(&c);
pthread_mutex_unlock(&m);

}

}

void comsume(void arg){
char no = (char)arg;
for(;;){
pthread_mutex_lock(&m);
while(productNum == 0){
pthread_cond_wait(&c,&m);

    }
    productNum--;
    __android_log_print(ANDROID_LOG_VERBOSE,"hello","i = %d",productNum);
    pthread_mutex_unlock(&m);

}

}

extern "C"
JNIEXPORT void JNICALL
Java_com_example_zth_ndkthread_MainActivity_startNativeThread(JNIEnv* env, jobject thiz,jint count) {

pthread_mutex_init(&m,NULL);
pthread_cond_init(&c,NULL);

pthread_t thread_producer;
pthread_t thread_comsumer;

pthread_create(&thread_producer, NULL, produce, (void *) "producer");
pthread_create(&thread_comsumer, NULL, comsume, (void *) "comsumer");

pthread_join(thread_producer,NULL);
pthread_join(thread_comsumer,NULL);

pthread_mutex_destroy(&m);
pthread_cond_destroy(&c);

}

参考文章

https://www.jianshu.com/p/453d12c16885

http://blog.csdn.net/lxmhuendan/article/details/11967593