013 《Android NDK 编程权威指南》
🌟🌟🌟本文案由Gemini 2.0 Flash Thinking Experimental 01-21创作，用来辅助学习知识。🌟🌟🌟
书籍大纲
▮▮▮▮ 1. chapter 1： 初识 Android NDK：开启 Native 开发之旅
▮▮▮▮▮▮▮ 1.1 Android 平台架构与 NDK 定位：为何选择 NDK
▮▮▮▮▮▮▮ 1.2 NDK 开发环境搭建：工具链、SDK、CMake 与 ndk-build
▮▮▮▮▮▮▮ 1.3 第一个 NDK 程序：Java 与 Native 层的互通初体验 (JNI)
▮▮▮▮▮▮▮ 1.4 NDK 开发流程详解：编译、链接、打包与调试
▮▮▮▮▮▮▮▮▮▮▮ 1.4.1 使用 CMake 构建 NDK 项目
▮▮▮▮▮▮▮▮▮▮▮ 1.4.2 使用 ndk-build 构建 NDK 项目
▮▮▮▮▮▮▮▮▮▮▮ 1.4.3 Android Studio 中 NDK 集成与调试
▮▮▮▮ 2. chapter 2： 深入 JNI：Java 与 Native 层的桥梁
▮▮▮▮▮▮▮ 2.1 JNI 基础：数据类型映射、方法签名与字段描述符
▮▮▮▮▮▮▮ 2.2 JNI 方法调用：静态方法、实例方法与构造方法
▮▮▮▮▮▮▮ 2.3 JNI 字段访问：静态字段与实例字段
▮▮▮▮▮▮▮ 2.4 JNI 引用类型：局部引用、全局引用与弱全局引用
▮▮▮▮▮▮▮ 2.5 JNI 异常处理：Java 异常与 Native 异常的交互
▮▮▮▮▮▮▮ 2.6 JNI 线程管理：在 Native 层创建和管理 Java 线程
▮▮▮▮ 3. chapter 3： NDK 核心 API：构建高性能 Native 应用
▮▮▮▮▮▮▮ 3.1 C/C++ 标准库与 NDK 支持：常用库函数详解
▮▮▮▮▮▮▮ 3.2 Android Log 系统：native 日志输出与调试技巧
▮▮▮▮▮▮▮ 3.3 文件 I/O 操作：native 层的安全高效文件访问
▮▮▮▮▮▮▮ 3.4 网络编程：Socket 通信在 NDK 中的应用
▮▮▮▮▮▮▮ 3.5 多线程与并发：native 线程同步与异步处理
▮▮▮▮▮▮▮ 3.6 内存管理：native 内存分配、释放与优化策略
▮▮▮▮ 4. chapter 4： NDK 图形图像开发：OpenGL ES 与 Vulkan
▮▮▮▮▮▮▮ 4.1 OpenGL ES 基础：渲染管线、着色器与纹理
▮▮▮▮▮▮▮ 4.2 OpenGL ES 在 NDK 中的应用：EGL 环境配置与渲染流程
▮▮▮▮▮▮▮ 4.3 Vulkan 初探：现代图形 API 及其在 Android NDK 的应用
▮▮▮▮▮▮▮ 4.4 图像处理库：OpenCV 与 NDK 的集成应用
▮▮▮▮▮▮▮ 4.5 实战案例：基于 OpenGL ES 的 3D 游戏开发基础
▮▮▮▮ 5. chapter 5： NDK 音频开发：OpenSL ES 与 AAudio
▮▮▮▮▮▮▮ 5.1 OpenSL ES 基础：音频引擎、音频播放器与录音器
▮▮▮▮▮▮▮ 5.2 OpenSL ES 在 NDK 中的应用：音频播放与录制流程
▮▮▮▮▮▮▮ 5.3 AAudio 介绍：Android 高性能音频 API
▮▮▮▮▮▮▮ 5.4 音频处理库：FFmpeg 与 NDK 的集成应用
▮▮▮▮▮▮▮ 5.5 实战案例：基于 OpenSL ES 的音频播放器开发
▮▮▮▮ 6. chapter 6： NDK 传感器与输入：与硬件交互
▮▮▮▮▮▮▮ 6.1 Android 传感器框架：传感器类型与数据获取
▮▮▮▮▮▮▮ 6.2 传感器在 NDK 中的应用：SensorManager 与 SensorEventListener
▮▮▮▮▮▮▮ 6.3 输入事件处理：触摸事件与按键事件的 native 层处理
▮▮▮▮▮▮▮ 6.4 实战案例：基于传感器的体感游戏开发
▮▮▮▮ 7. chapter 7： NDK 性能优化：打造高效 Native 代码
▮▮▮▮▮▮▮ 7.1 性能分析工具：Profiler 与 Systrace 的使用
▮▮▮▮▮▮▮ 7.2 代码优化技巧：算法优化、数据结构选择与编译器优化
▮▮▮▮▮▮▮ 7.3 内存优化策略：内存泄漏检测与内存池技术
▮▮▮▮▮▮▮ 7.4 多线程优化：线程池与异步任务管理
▮▮▮▮▮▮▮ 7.5 CPU 架构与指令集优化：ARM Neon 技术
▮▮▮▮ 8. chapter 8： NDK 高级主题：架构、安全与跨平台
▮▮▮▮▮▮▮ 8.1 NDK 模块化设计：构建可维护的 Native 代码
▮▮▮▮▮▮▮ 8.2 NDK 代码安全：防止逆向工程与安全漏洞
▮▮▮▮▮▮▮ 8.3 NDK 跨平台开发：C/C++ 代码的平台适配策略
▮▮▮▮▮▮▮ 8.4 NDK 与 Kotlin Native：Kotlin Native 与 NDK 的互操作
▮▮▮▮▮▮▮ 8.5 NDK 未来展望：Android Native 开发的趋势与新技术
▮▮▮▮ 9. chapter 9： NDK 实战案例：综合项目开发
▮▮▮▮▮▮▮ 9.1 案例一：高性能图像处理应用
▮▮▮▮▮▮▮ 9.2 案例二：跨平台音视频播放器
▮▮▮▮▮▮▮ 9.3 案例三：基于物理引擎的 2D 游戏
▮▮▮▮▮▮▮ 9.4 案例四：机器学习模型 NDK 部署与加速
▮▮▮▮ 10. chapter 10： NDK API 参考与最佳实践
▮▮▮▮▮▮▮ 10.1 常用 JNI 函数 API 详解与示例
▮▮▮▮▮▮▮ 10.2 NDK 核心库 API 索引与速查
▮▮▮▮▮▮▮ 10.3 NDK 开发最佳实践总结与建议
▮▮▮▮▮▮▮ 10.4 NDK 常见问题与解决方案 (FAQ)
1. chapter 1： 初识 Android NDK：开启 Native 开发之旅
1.1 Android 平台架构与 NDK 定位：为何选择 NDK
Android 作为一个开放且流行的移动操作系统，其平台架构设计精巧而复杂。理解 Android 的平台架构，对于我们深入学习 Android NDK（Native Development Kit，原生开发工具包）至关重要。本节将从 Android 平台架构的宏观视角出发，阐述 NDK 在其中的定位，并探讨为何开发者会选择 NDK 进行 Android 应用开发。
Android 平台架构通常被划分为五个主要层次，从底层到高层依次为：
① Linux 内核层（Linux Kernel）：Android 系统的基石，基于 Linux 内核构建。内核层负责设备硬件驱动、进程管理、内存管理、电源管理、网络堆栈以及安全机制等核心功能。对于 NDK 开发而言，Linux 内核层提供了 Native 代码运行的基础环境，Native 代码可以直接调用 Linux 内核提供的系统调用，从而实现对底层硬件和系统资源的直接访问。
② 硬件抽象层（HAL，Hardware Abstraction Layer）：HAL 作为硬件接口的抽象层，向上层框架屏蔽了底层硬件的差异性。它定义了一组标准的接口，使得 Android 系统可以在不同的硬件平台上保持一致性。NDK 开发中，虽然我们不直接与 HAL 交互，但 HAL 的存在保证了 Native 代码在不同 Android 设备上的兼容性。
③ Native 库层（Native Libraries）：这一层包含了 Android 系统运行所需的各种 C/C++ 库，例如 libc（C 标准库）、libm（数学库）、libz（压缩库）、OpenGL ES（图形库）、WebKit（浏览器引擎库）等。这些 Native 库为上层应用框架和应用开发者提供了丰富的功能支持。NDK 开发的核心价值之一，就是允许开发者使用 C/C++ 语言编写 Native 代码，并直接调用和扩展这些底层的 Native 库，从而实现高性能和底层特性的访问。
④ Android 运行时环境层（Android Runtime）：Android 运行时环境主要由核心库（Core Libraries）和虚拟机（Virtual Machine）组成。在早期的 Android 版本中，虚拟机是 Dalvik 虚拟机，而在 Android 5.0 (API Level 21) 之后，ART（Android Runtime）虚拟机取代了 Dalvik。运行时环境负责应用的生命周期管理、内存管理、线程管理等，并为应用提供 Java API 框架。NDK 开发涉及到 Java 代码和 Native 代码的交互，这种交互主要通过 JNI（Java Native Interface，Java 本地接口）技术来实现，JNI 桥接了 Java 虚拟机和 Native 代码，使得两者可以互相调用和数据交换。
⑤ 应用框架层（Application Framework）：应用框架层是构建 Android 应用的基础，它提供了一系列 Java API，例如 Activity 管理器、窗口管理器、内容提供器、视图系统、资源管理器、位置管理器、通知管理器等。开发者可以使用这些 API 构建各种类型的 Android 应用。虽然应用框架层主要使用 Java 语言编写，但 NDK 允许开发者绕过部分 Java 框架，直接使用 Native 代码实现某些功能，从而在性能敏感的场景下获得更好的表现。
NDK 的定位：连接 Java 世界与 Native 世界的桥梁
NDK 的核心作用在于提供了一种机制，允许开发者使用 C、C++ 等 Native 语言编写 Android 应用的部分模块。这些 Native 模块可以直接编译为机器码，运行效率更高，并且可以直接访问底层的系统资源和硬件能力。NDK 充当了 Java 世界和 Native 世界的桥梁，通过 JNI 技术，实现了 Java 代码和 Native 代码的互操作。
为何选择 NDK？NDK 的应用场景与优势
在 Android 应用开发中，并非所有场景都适合使用 NDK。Java 语言在 Android 平台上拥有成熟的生态和便捷的开发体验，对于大多数应用需求而言，纯 Java 开发已经足够。然而，在某些特定场景下，NDK 的引入能够带来显著的优势：
① 性能敏感型应用：对于计算密集型或者对性能要求极高的应用，例如游戏、音视频处理、图像处理、科学计算等，使用 C/C++ 编写 Native 代码可以获得比 Java 代码更高的执行效率。C/C++ 编译为机器码直接在 CPU 上运行，避免了虚拟机解释执行的开销，性能更接近硬件极限。
② 复用现有的 C/C++ 代码库：许多成熟的、高性能的库和框架都是使用 C/C++ 编写的，例如 FFmpeg（音视频处理库）、OpenCV（计算机视觉库）、OpenGL ES/Vulkan（图形库）、物理引擎、加密库等。通过 NDK，开发者可以将这些现有的 C/C++ 代码库无缝集成到 Android 应用中，避免重复造轮子，并充分利用已有的技术积累。
③ 访问底层硬件和系统特性：NDK 允许 Native 代码直接调用 Linux 系统调用，访问底层的硬件资源和系统特性，例如传感器、摄像头、OpenGL ES/Vulkan 图形 API 等。这为开发需要深度硬件交互的应用提供了可能，例如高性能游戏、AR/VR 应用、硬件加速的图像处理应用等。
④ 代码保护与安全性：相对于 Java 代码，Native 代码编译为机器码后，反编译和逆向工程的难度更高，一定程度上可以提高应用的代码安全性和知识产权保护。对于一些核心算法或者敏感逻辑，使用 Native 代码实现可以增加破解的门槛。
⑤ 跨平台开发：使用 C/C++ 编写的 Native 代码具有良好的跨平台性。通过合理的架构设计和平台适配，同一份 C/C++ 代码可以编译为不同平台（例如 Android、iOS、桌面操作系统）的 Native 库，从而实现跨平台代码复用，降低多平台开发的成本。
总结
NDK 是 Android 平台架构中一个重要的组成部分，它为开发者提供了使用 Native 语言进行 Android 应用开发的能力。选择 NDK 的主要原因在于其在性能、代码复用、底层访问、安全性和跨平台性方面的优势。然而，NDK 开发也引入了更高的复杂性和学习曲线，开发者需要权衡利弊，根据具体的应用场景和需求，合理选择是否使用 NDK 以及如何使用 NDK。在接下来的章节中，我们将深入探讨 NDK 开发的各个方面，帮助读者掌握 NDK 技术，开启 Android Native 开发之旅。
1.2 NDK 开发环境搭建：工具链、SDK、CMake 与 ndk-build
工欲善其事，必先利其器。在开始 Android NDK 开发之前，搭建好完善的开发环境至关重要。本节将详细介绍 NDK 开发环境的搭建步骤，包括必要的工具链、Android SDK（Software Development Kit，软件开发工具包）、构建工具 CMake 和 ndk-build 的配置与使用。
1. 安装 Android SDK
Android SDK 是 Android 开发的基础，包含了编译、调试和运行 Android 应用所需的各种工具和库。要进行 NDK 开发，首先需要安装 Android SDK。
① 下载 Android Studio：推荐使用 Android Studio 作为 Android 开发的集成开发环境（IDE）。Android Studio 包含了 Android SDK 管理器，可以方便地下载和管理 SDK 组件。访问 Android Studio 官网 下载并安装最新版本的 Android Studio。
② 使用 SDK 管理器安装 SDK 组件：启动 Android Studio，打开 SDK 管理器（可以通过 "Tools" -> "SDK Manager" 菜单打开）。在 SDK 管理器中，需要安装以下必要的组件：
⚝ Android SDK Platform：选择你想要开发的 Android 版本对应的 SDK Platform。建议选择最新的稳定版本，并根据需要选择其他版本。
⚝ SDK Tools：
▮▮▮▮ⓐ Android SDK Build-Tools：用于编译 Android 应用的构建工具，建议安装最新版本。
▮▮▮▮ⓑ NDK (Side by side)：这是 NDK 开发的核心组件，必须安装。SDK 管理器会自动下载并安装 NDK 工具链。
▮▮▮▮ⓒ CMake：CMake 是一个跨平台的构建系统，NDK 开发推荐使用 CMake 进行项目构建。SDK 管理器会安装 CMake 工具。
▮▮▮▮ⓓ LLDB：LLDB 是 Android Studio 默认的 Native 代码调试器，用于调试 NDK 代码。通常 Android Studio 会自动安装 LLDB。
安装完成后，Android SDK 的路径（SDK Path）会被记录在 Android Studio 的设置中。后续配置环境变量或者构建项目时需要用到 SDK 路径。
2. 配置环境变量 (可选)
为了在命令行中方便地使用 Android SDK 和 NDK 工具，可以将 SDK 和 NDK 的路径添加到系统的环境变量 PATH 中。
① 查找 SDK 路径和 NDK 路径：在 Android Studio 中，打开 SDK 管理器 ("Tools" -> "SDK Manager")，在 "Android SDK Location" 中可以看到 SDK 路径。NDK 路径通常位于 SDK 路径下的 ndk 目录中，例如 <SDK 路径>/ndk/<NDK 版本号>。
② 配置 PATH 环境变量：
⚝ Windows 系统：
▮▮▮▮ⓐ 打开 "控制面板" -> "系统与安全" -> "系统" -> "高级系统设置"。
▮▮▮▮ⓑ 点击 "环境变量" 按钮。
▮▮▮▮ⓒ 在 "系统变量" 中找到 "Path" 变量，点击 "编辑"。
▮▮▮▮ⓓ 在 "编辑环境变量" 窗口中，点击 "新建"，分别添加 SDK 的 platform-tools 目录、tools 目录，以及 NDK 工具链的路径。例如：
▮▮▮▮▮▮▮▮❺ <SDK 路径>\platform-tools
▮▮▮▮▮▮▮▮❻ <SDK 路径>\tools
▮▮▮▮▮▮▮▮❼ <NDK 路径>
▮▮▮▮ⓗ 点击 "确定" 保存修改。
⚝ macOS / Linux 系统：
▮▮▮▮ⓐ 打开终端，编辑 shell 配置文件（例如 ~/.bash_profile、~/.zshrc）。
▮▮▮▮ⓑ 在配置文件中添加以下行，将 <SDK 路径> 和 <NDK 路径> 替换为实际路径：
1
export ANDROID_SDK_ROOT=<SDK 路径>
2
export ANDROID_NDK_ROOT=<NDK 路径>
3
export PATH=$PATH:$ANDROID_SDK_ROOT/platform-tools:$ANDROID_SDK_ROOT/tools:$ANDROID_NDK_ROOT
▮▮▮▮ⓒ 保存配置文件，并执行 source ~/.bash_profile 或 source ~/.zshrc 使配置生效。
配置环境变量后，就可以在命令行中直接使用 adb、sdkmanager、ndk-build、cmake 等命令。
3. 选择构建工具：CMake 或 ndk-build
NDK 提供了两种主要的构建工具：CMake 和 ndk-build。
① CMake：CMake 是一个跨平台的开源构建系统，它使用简单的配置文件（CMakeLists.txt）来描述构建过程，可以生成各种构建工具（例如 Make、Ninja、Visual Studio、Xcode）的工程文件。CMake 具有良好的跨平台性、灵活性和可扩展性，是 Google 推荐的 NDK 项目构建工具。Android Studio 默认使用 CMake 构建 NDK 项目。
② ndk-build：ndk-build 是 Android NDK 自带的构建脚本，基于 GNU Make 构建。它使用 Android.mk 和 Application.mk 文件来描述构建过程。ndk-build 配置相对简单，对于简单的 NDK 项目比较方便。但在大型项目和跨平台构建方面，CMake 更具优势。
本书主要推荐使用 CMake 作为 NDK 项目的构建工具。后续章节将重点介绍 CMake 的使用方法。
4. 验证 NDK 环境
完成上述步骤后，可以验证 NDK 环境是否搭建成功。
① 检查 NDK 版本：在命令行中输入 ndk-build --version，如果能正确显示 NDK 版本信息，则说明 NDK 工具链安装成功。
② 创建 NDK 项目：在 Android Studio 中创建一个新的 Android 项目，在创建向导中选择 "Native C++" 项目模板。如果项目能够成功创建和编译，并且没有 NDK 相关的错误提示，则说明 NDK 环境配置正确。
③ 运行示例程序：运行创建的 "Native C++" 项目，如果应用能够正常运行，并且在 Logcat 中看到 Native 代码输出的日志信息，则进一步验证了 NDK 环境的可用性。
总结
搭建 NDK 开发环境是 NDK 开发的第一步，也是至关重要的一步。本节介绍了 Android SDK 的安装、NDK 组件的安装、环境变量的配置，以及 CMake 和 ndk-build 构建工具的选择。通过本节的学习，读者应该能够成功搭建起 NDK 开发环境，为后续的 NDK 开发学习打下坚实的基础。在下一节，我们将开始编写第一个 NDK 程序，体验 Java 层与 Native 层的互通。
1.3 第一个 NDK 程序：Java 与 Native 层的互通初体验 (JNI)
理论学习固然重要，但实践才是检验真理的唯一标准。本节我们将通过一个简单的 "Hello NDK" 程序，带领读者亲身体验 NDK 开发的流程，并初步了解 JNI（Java Native Interface，Java 本地接口）技术，感受 Java 层与 Native 层互通的魅力。
1. 创建 Android Studio 项目
① 启动 Android Studio，点击 "Create New Project"。
② 选择项目模板：在项目模板选择界面，选择 "Native C++" 模板，然后点击 "Next"。
③ 配置项目信息：
▮▮▮▮⚝ Name：输入项目名称，例如 "HelloNDK"。
▮▮▮▮⚝ Package name：设置包名，例如 "com.example.hellondk"。
▮▮▮▮⚝ Save location：选择项目保存路径。
▮▮▮▮⚝ Language：选择 "Java" 或 "Kotlin" 作为 Java/Kotlin 代码的语言。
▮▮▮▮⚝ Minimum SDK：选择最低兼容的 Android 版本。
▮▮▮▮⚝ 点击 "Next"。
④ 配置 C++ 标准：
▮▮▮▮⚝ C++ Standard：选择 C++ 标准，例如 "Toolchain Default" 或 "C++11"。
▮▮▮▮⚝ 点击 "Finish"。
Android Studio 会自动创建一个包含 NDK 支持的 Android 项目。项目结构中会包含 cpp 目录，用于存放 Native 代码。
2. 查看和修改 Native 代码
① 打开 native-lib.cpp 文件：在 Android Studio 的 "Project" 视图中，展开 "app" -> "cpp" 目录，找到 native-lib.cpp 文件并打开。
② 分析默认代码：native-lib.cpp 文件中默认包含以下代码：
1
#include <jni.h>
2
#include <string>
3
4
extern "C" JNIEXPORT jstring JNICALL
5
Java_com_example_hellondk_MainActivity_stringFromJNI(
6
JNIEnv* env,
7
jobject /* this */) {
8
std::string hello = "Hello from C++";
9
return env->NewStringUTF(hello.c_str());
10
}
这段代码定义了一个 JNI 函数 stringFromJNI。让我们逐行分析：
⚝ #include <jni.h>： 包含了 JNI 相关的头文件，提供了 JNI 函数和数据类型的定义。
⚝ #include <string>：包含了 C++ 标准库的 string 头文件。
⚝ extern "C" JNIEXPORT jstring JNICALL：
▮▮▮▮ⓐ extern "C"： 确保 C++ 编译器按照 C 语言的规则编译该函数，避免 C++ 的名字修饰导致 Java 层无法找到该函数。
▮▮▮▮ⓑ JNIEXPORT 和 JNICALL： JNI 关键字，用于声明该函数为 JNI 函数，可以被 Java 层调用。
▮▮▮▮ⓒ jstring： JNI 数据类型，对应 Java 的 String 类型。表示该 JNI 函数的返回值类型为 JNI 字符串。
⚝ Java_com_example_hellondk_MainActivity_stringFromJNI(...)： JNI 函数的函数名，遵循特定的命名规则。
▮▮▮▮ⓐ Java_： JNI 函数名的固定前缀。
▮▮▮▮ⓑ com_example_hellondk_MainActivity： Java 类名的全路径，将包名中的 . 替换为 _，类名 MainActivity 直接拼接。
▮▮▮▮ⓒ stringFromJNI： Java 方法名。
▮▮▮▮这个函数名表示该 JNI 函数对应 Java 类 com.example.hellondk.MainActivity 中的 stringFromJNI 方法。
⚝ JNIEnv* env： JNI 环境指针，通过该指针可以调用 JNI 提供的各种函数，例如创建 Java 字符串、访问 Java 类和对象等。
⚝ jobject /* this */： Java 对象的引用，对应 Java 方法的 this 指针。对于静态 JNI 方法，该参数为 jclass 类型，表示 Java 类的引用。
⚝ std::string hello = "Hello from C++";： 创建一个 C++ 字符串 "Hello from C++"。
⚝ return env->NewStringUTF(hello.c_str());： 使用 JNI 函数 NewStringUTF 将 C++ 字符串转换为 JNI 字符串 (jstring)，并返回给 Java 层。
③ 修改字符串内容：将 std::string hello = "Hello from C++"; 修改为 std::string hello = "Hello NDK from C++";，让 Native 代码返回 "Hello NDK from C++" 字符串。
3. 调用 JNI 函数
① 打开 MainActivity.java (或 MainActivity.kt) 文件：在 "Project" 视图中，打开 java -> com.example.hellondk -> MainActivity.java (或 MainActivity.kt) 文件。
② 查看和修改 Java 代码：MainActivity 文件中默认包含以下代码 (Java 代码示例)：
1
package com.example.hellondk;
2
3
import androidx.appcompat.app.AppCompatActivity;
4
import android.os.Bundle;
5
import android.widget.TextView;
6
import com.example.hellondk.databinding.ActivityMainBinding;
7
8
public class MainActivity extends AppCompatActivity {
9
10
// Used to load the 'native-lib' library on application startup.
11
static {
12
System.loadLibrary("native-lib");
13
}
14
15
private ActivityMainBinding binding;
16
17
@Override
18
protected void onCreate(Bundle savedInstanceState) {
19
super.onCreate(savedInstanceState);
20
21
binding = ActivityMainBinding.inflate(getLayoutInflater());
22
setContentView(binding.getRoot());
23
24
// Example of a call to a native method
25
TextView tv = binding.sampleText;
26
tv.setText(stringFromJNI());
27
}
28
29
/**
30
* A native method that is implemented by the 'native-lib' native library,
31
* which is packaged with this application.
32
*/
33
public native String stringFromJNI();
34
}
让我们分析 Java 代码中与 NDK 相关的部分：
⚝ static { System.loadLibrary("native-lib"); }： 静态代码块，在类加载时执行。System.loadLibrary("native-lib") 用于加载 Native 库 "native-lib"。native-lib 对应于 CMakeLists.txt 中 add_library(native-lib ...) 定义的库名。Android 系统会在应用启动时加载该 Native 库。
⚝ public native String stringFromJNI();： Native 方法声明。native 关键字表示该方法的实现位于 Native 代码中。String stringFromJNI() 方法的签名与 native-lib.cpp 中的 Java_com_example_hellondk_MainActivity_stringFromJNI 函数对应。
⚝ TextView tv = binding.sampleText; tv.setText(stringFromJNI());： 在 onCreate 方法中，获取 TextView 组件，并调用 stringFromJNI() Native 方法获取字符串，然后设置给 TextView 显示。
③ 运行应用：点击 Android Studio 工具栏中的 "Run" 按钮，选择设备或模拟器运行应用。
如果一切配置正确，应用启动后，在界面上应该看到 "Hello NDK from C++" 字符串，而不是之前的 "Hello from C++"。这表明我们成功地调用了 Native 代码，并获取了 Native 代码返回的数据。
4. 深入理解 JNI
通过这个简单的 "Hello NDK" 程序，我们初步体验了 JNI 的基本流程：
① 编写 Native 代码：使用 C/C++ 编写 Native 函数，并遵循 JNI 规范命名函数名和参数。
② 编译 Native 代码：使用 CMake 或 ndk-build 将 Native 代码编译为动态链接库 (.so 文件)。
③ 加载 Native 库：在 Java 代码中使用 System.loadLibrary() 加载 Native 库。
④ 声明 Native 方法：在 Java 代码中使用 native 关键字声明 Native 方法，方法签名需要与 Native 函数对应。
⑤ 调用 Native 方法：在 Java 代码中像调用普通 Java 方法一样调用 Native 方法。
JNI 是 Java 与 Native 代码交互的桥梁，它定义了一套规范，使得 Java 代码可以调用 Native 代码，Native 代码也可以回调 Java 代码。在后续章节中，我们将深入学习 JNI 的各种细节，包括数据类型映射、方法调用、字段访问、引用管理、异常处理、线程管理等。
总结
本节通过一个简单的 "Hello NDK" 程序，带领读者完成了第一个 NDK 应用的开发，体验了 Java 层与 Native 层的互通。我们学习了如何创建 NDK 项目、查看和修改 Native 代码、调用 JNI 函数，并初步了解了 JNI 的基本概念和流程。这为后续深入学习 NDK 开发奠定了基础。在下一节，我们将详细介绍 NDK 开发的完整流程，包括编译、链接、打包与调试。
1.4 NDK 开发流程详解：编译、链接、打包与调试
掌握 NDK 开发流程是进行高效 NDK 开发的关键。本节将详细解析 NDK 开发的完整流程，包括 Native 代码的编译、链接，Native 库的打包，以及 NDK 代码的调试方法。我们将分别介绍使用 CMake 和 ndk-build 两种构建工具的开发流程，并重点讲解如何在 Android Studio 中集成和调试 NDK 代码。
1.4.1 使用 CMake 构建 NDK 项目
CMake 是 Google 推荐的 NDK 项目构建工具，Android Studio 默认使用 CMake 构建 NDK 项目。使用 CMake 构建 NDK 项目的流程主要包括以下几个步骤：
① 编写 CMakeLists.txt 文件：在 NDK 项目的 cpp 目录下，需要创建一个 CMakeLists.txt 文件，用于描述项目的构建规则。CMakeLists.txt 文件使用 CMake 语言编写，语法简洁而强大。一个基本的 CMakeLists.txt 文件通常包含以下内容：
1
cmake_minimum_required(VERSION 3.18.1) # 指定 CMake 最低版本
2
3
project("hello-ndk") # 定义项目名称
4
5
add_library( # 添加一个库
6
native-lib # 库的名称，对应 System.loadLibrary("native-lib")
7
SHARED # 库的类型，SHARED 表示动态链接库 (.so)
8
native-lib.cpp) # 源文件列表
9
10
find_library( # 查找 Android 系统库
11
log-lib # 变量名，用于存储找到的库的路径
12
log ) # 要查找的库的名称，这里是 log 库 (liblog.so)
13
14
target_link_libraries( # 链接库
15
native-lib # 目标库，即 add_library 中定义的库
16
${log-lib} ) # 要链接的库，这里链接 log 库
CMakeLists.txt 文件常用指令解释：
⚝ cmake_minimum_required(VERSION version)：指定 CMake 的最低版本要求。
⚝ project(projectName)：定义项目名称。
⚝ add_library(libName libraryType sourceFiles)：添加一个库。
▮▮▮▮ⓐ libName：库的名称，在 Java 代码中通过 System.loadLibrary(libName) 加载。
▮▮▮▮ⓑ libraryType：库的类型，可以是 SHARED (动态链接库 .so)、STATIC (静态库 .a) 或 MODULE (模块库 .so)。
▮▮▮▮ⓒ sourceFiles：源文件列表，可以是多个源文件。
⚝ find_library(outputVariable libraryName)：查找系统库。
▮▮▮▮ⓐ outputVariable：变量名，用于存储找到的库的路径。
▮▮▮▮ⓑ libraryName：要查找的库的名称。
⚝ target_link_libraries(targetName libraries)：链接库。
▮▮▮▮ⓐ targetName：目标库，通常是 add_library 中定义的库。
▮▮▮▮ⓑ libraries：要链接的库列表，可以是系统库、第三方库或其他自定义库。
② 配置 build.gradle 文件：在 app 模块的 build.gradle 文件中，需要配置 CMake 构建相关的选项。在 android 闭包中，找到 externalNativeBuild 闭包，进行如下配置：
1
android {
2
// ...
3
externalNativeBuild {
4
cmake {
5
path 'src/main/cpp/CMakeLists.txt' // CMakeLists.txt 文件路径
6
version '3.18.1' // CMake 版本
7
abiFilters 'armeabi-v7a', 'arm64-v8a', 'x86', 'x86_64' // 指定支持的 CPU 架构
8
arguments "-DANDROID_STL=lldb_shared" // CMake 参数，例如指定 STL 类型
9
cppFlags "-std=c++11" // C++ 编译选项，例如指定 C++ 标准
10
}
11
}
12
// ...
13
}
build.gradle 文件 CMake 配置项解释：
⚝ path 'src/main/cpp/CMakeLists.txt'：指定 CMakeLists.txt 文件的路径。
⚝ version '3.18.1'：指定 CMake 版本。
⚝ abiFilters 'armeabi-v7a', 'arm64-v8a', 'x86', 'x86_64'：指定要构建的 CPU 架构 ABI (Application Binary Interface)。常用的 ABI 包括 armeabi-v7a、arm64-v8a、x86、x86_64。可以根据应用的需求选择支持的 ABI，减少 APK 大小。
⚝ arguments "-DANDROID_STL=lldb_shared"：传递给 CMake 的参数。-DANDROID_STL=lldb_shared 指定使用 lldb_shared 共享库版本的 C++ 标准库。常用的 STL 类型包括 system (系统默认 STL)、c++_static (静态链接 STL)、c++_shared (动态链接 STL)、lldb_shared (LLDB 调试器使用的共享 STL)。
⚝ cppFlags "-std=c++11"：C++ 编译选项。-std=c++11 指定使用 C++11 标准编译。
③ 构建 NDK 项目：在 Android Studio 中，点击 "Build" -> "Make Project" 或 "Build" -> "Rebuild Project" 菜单，Android Studio 会自动调用 CMake 构建工具，根据 CMakeLists.txt 和 build.gradle 中的配置，编译 Native 代码，生成对应 CPU 架构的动态链接库 .so 文件。
④ 查看构建产物：构建成功后，可以在 app/build/intermediates/cmake/debug/ (或 release) 目录下找到 CMake 构建的中间产物和最终的 .so 文件。.so 文件会被打包到 APK 文件中。
1.4.2 使用 ndk-build 构建 NDK 项目
ndk-build 是 Android NDK 自带的构建脚本，基于 GNU Make 构建。使用 ndk-build 构建 NDK 项目需要编写 Android.mk 和 Application.mk 两个 Makefile 文件。
① 编写 Android.mk 文件：在 NDK 项目的 jni 目录下（如果没有 jni 目录，需要手动创建），创建 Android.mk 文件，用于描述 Native 模块的构建规则。一个基本的 Android.mk 文件如下：
1
LOCAL_PATH := $(call my-dir) # 获取当前目录
2
3
include $(CLEAR_VARS) # 清除全局变量
4
5
LOCAL_MODULE := native-lib # 模块名称，对应 System.loadLibrary("native-lib")
6
LOCAL_SRC_FILES := native-lib.cpp # 源文件列表
7
8
LOCAL_LDLIBS := -llog # 需要链接的系统库，这里链接 log 库
9
10
include $(BUILD_SHARED_LIBRARY) # 构建动态链接库
Android.mk 文件常用变量和指令解释：
⚝ LOCAL_PATH := $(call my-dir)：获取当前 Android.mk 文件所在的目录，赋值给 LOCAL_PATH 变量。
⚝ include $(CLEAR_VARS)：清除全局变量，为构建新的模块做准备。
⚝ LOCAL_MODULE := moduleName：定义模块名称，在 Java 代码中通过 System.loadLibrary(moduleName) 加载。
⚝ LOCAL_SRC_FILES := sourceFiles：指定源文件列表，可以是多个源文件。
⚝ LOCAL_LDLIBS := libraryFlags：指定需要链接的系统库，例如 -llog 链接 liblog.so，-lz 链接 libz.so。
⚝ include $(BUILD_SHARED_LIBRARY)：构建动态链接库 .so。
⚝ include $(BUILD_STATIC_LIBRARY)：构建静态库 .a。
⚝ include $(BUILD_EXECUTABLE)：构建可执行文件。
② 编写 Application.mk 文件 (可选)：在 jni 目录下，可以创建 Application.mk 文件，用于配置应用级别的构建选项，例如指定支持的 CPU 架构 ABI、C++ 标准库类型等。一个简单的 Application.mk 文件如下：
1
APP_ABI := armeabi-v7a arm64-v8a x86 x86_64 # 指定支持的 CPU 架构
2
APP_STL := lldb_shared # 指定 STL 类型
3
APP_CPPFLAGS := -std=c++11 # C++ 编译选项
Application.mk 文件常用变量解释：
⚝ APP_ABI := abis：指定要构建的 CPU 架构 ABI，多个 ABI 之间用空格分隔。
⚝ APP_STL := stlType：指定 C++ 标准库类型，常用的 STL 类型与 CMake 相同。
⚝ APP_CPPFLAGS := cppFlags：C++ 编译选项。
③ 配置 build.gradle 文件：在 app 模块的 build.gradle 文件中，需要配置使用 ndk-build 构建。在 android 闭包中，找到 externalNativeBuild 闭包，进行如下配置：
1
android {
2
// ...
3
externalNativeBuild {
4
ndkBuild {
5
path 'src/main/jni/Android.mk' // Android.mk 文件路径
6
abiFilters 'armeabi-v7a', 'arm64-v8a', 'x86', 'x86_64' // 指定支持的 CPU 架构
7
}
8
}
9
// ...
10
sourceSets {
11
main {
12
jniLibs.srcDirs = ['src/main/jniLibs'] // 指定 jniLibs 目录，用于存放预编译的 .so 文件
13
jni.srcDirs = [] // 禁用默认的 jni 目录，避免与 ndk-build 冲突
14
}
15
}
16
}
build.gradle 文件 ndk-build 配置项解释：
⚝ path 'src/main/jni/Android.mk'：指定 Android.mk 文件的路径。
⚝ abiFilters 'armeabi-v7a', 'arm64-v8a', 'x86', 'x86_64'：指定要构建的 CPU 架构 ABI。
⚝ sourceSets { main { jniLibs.srcDirs = ['src/main/jniLibs']; jni.srcDirs = []; } }：配置 sourceSets，指定 jniLibs 目录用于存放预编译的 .so 文件，并禁用默认的 jni 目录，避免与 ndk-build 构建过程冲突。
④ 构建 NDK 项目：在 Android Studio 中，点击 "Build" -> "Make Project" 或 "Build" -> "Rebuild Project" 菜单，Android Studio 会自动调用 ndk-build 脚本，根据 Android.mk 和 Application.mk 中的配置，编译 Native 代码，生成对应 CPU 架构的动态链接库 .so 文件。
⑤ 查看构建产物：构建成功后，可以在 app/build/intermediates/ndkBuild/debug/ (或 release) 目录下找到 ndk-build 构建的中间产物和最终的 .so 文件。.so 文件会被打包到 APK 文件中。
1.4.3 Android Studio 中 NDK 集成与调试
Android Studio 提供了强大的 NDK 集成和调试功能，可以方便地进行 NDK 代码的开发和调试。
① 代码编辑与智能提示：Android Studio 对 C/C++ 代码提供代码高亮、代码补全、语法检查、重构等功能，可以提高 Native 代码的编写效率和代码质量。
② 编译和构建：Android Studio 集成了 CMake 和 ndk-build 构建工具，可以一键编译和构建 NDK 项目。通过 "Build" 菜单可以触发构建过程，并在 "Build Output" 窗口查看构建日志和错误信息。
③ 设备部署和运行：Android Studio 可以将编译好的 APK 文件部署到连接的 Android 设备或模拟器上运行。点击 "Run" 按钮即可运行应用。
④ Native 代码调试：Android Studio 提供了强大的 Native 代码调试功能，支持断点调试、单步执行、查看变量值、查看调用堆栈等。
⚝ 设置断点：在 C/C++ 代码编辑器中，在需要调试的代码行左侧点击，即可设置断点。
⚝ 启动调试：点击 "Debug" 按钮，选择设备或模拟器启动调试会话。Android Studio 会将应用部署到设备并启动调试器。
⚝ 调试界面：当程序运行到断点时，程序会暂停执行，Android Studio 会显示调试界面。调试界面包括：
▮▮▮▮ⓐ Debug 工具栏：提供单步执行 (Step Over, Step Into, Step Out)、继续执行 (Resume Program)、停止调试 (Stop) 等调试操作按钮。
▮▮▮▮ⓑ Variables 窗口：显示当前作用域内的变量值，可以查看和修改变量值。
▮▮▮▮ⓒ Watches 窗口：可以添加需要监视的变量或表达式，实时查看其值。
▮▮▮▮ⓓ Call Stack 窗口：显示当前线程的调用堆栈，可以查看函数调用关系。
▮▮▮▮ⓔ Breakpoints 窗口：管理断点，可以启用、禁用、删除断点，设置断点条件等。
▮▮▮▮ⓕ Debugger Console 窗口：显示调试器输出的日志信息。
⚝ LLDB 调试器：Android Studio 默认使用 LLDB (LLVM Debugger) 作为 Native 代码调试器。LLDB 是一款功能强大的开源调试器，支持 C、C++、Objective-C 等语言的调试。
⑤ Logcat 日志查看：Android Studio 的 Logcat 窗口可以查看 Android 设备的系统日志和应用日志。Native 代码可以使用 <android/log.h> 头文件提供的 __android_log_print 函数输出日志信息，并在 Logcat 窗口中查看。
1
#include <android/log.h>
2
3
#define TAG "HelloNDK"
4
5
extern "C" JNIEXPORT jstring JNICALL
6
Java_com_example_hellondk_MainActivity_stringFromJNI(
7
JNIEnv* env,
8
jobject /* this */) {
9
std::string hello = "Hello NDK from C++";
10
__android_log_print(ANDROID_LOG_DEBUG, TAG, "Native method stringFromJNI called"); // 输出日志
11
return env->NewStringUTF(hello.c_str());
12
}
在 Logcat 窗口中，选择 "Debug" 级别，并过滤 "HelloNDK" 标签，即可看到 Native 代码输出的日志信息。
总结
本节详细介绍了 NDK 开发的完整流程，包括使用 CMake 和 ndk-build 两种构建工具进行 Native 代码的编译和链接，以及 Native 库的打包。重点讲解了如何在 Android Studio 中集成和调试 NDK 代码，包括代码编辑、编译构建、设备部署、Native 代码调试和 Logcat 日志查看。掌握 NDK 开发流程和调试技巧，是高效进行 NDK 开发的基础。在接下来的章节中，我们将深入学习 JNI 的各种高级特性和 NDK 核心 API，进一步提升 NDK 开发技能。
ENDOF_CHAPTER_
2. chapter 2： 深入 JNI：Java 与 Native 层的桥梁
2.1 JNI 基础：数据类型映射、方法签名与字段描述符
Java Native Interface（JNI）是 Android NDK 开发的基石，它充当了 Java 世界与 Native（本地）世界沟通的桥梁。理解 JNI 的基础概念对于进行高效且稳定的 NDK 开发至关重要。本节将深入探讨 JNI 的核心基础，包括数据类型映射（Data Type Mapping）、方法签名（Method Signature）以及字段描述符（Field Descriptor）。
2.1.1 数据类型映射（Data Type Mapping）
Java 虚拟机（JVM）与 Native 代码运行环境在数据类型表示上存在差异。为了实现 Java 层与 Native 层之间的数据交换，JNI 定义了一套标准的数据类型映射规则，将 Java 数据类型转换为 Native 代码可以识别和操作的类型。
① 基本数据类型映射：JNI 提供了一组 j 开头的类型名，用于映射 Java 的基本数据类型。下表列出了 Java 基本数据类型与 JNI 类型的对应关系：
| Java 类型（Java Type） | JNI 类型（JNI Type） | C/C++ 类型（C/C++ Type） | 描述（Description） |
|---|---|---|---|
boolean | jboolean | unsigned char | Java 布尔型 |
byte | jbyte | signed char | Java 字节型 |
char | jchar | unsigned short | Java 字符型 (UTF-16 编码) |
short | jshort | short | Java 短整型 |
int | jint | int | Java 整型 |
long | jlong | long long | Java 长整型 |
float | jfloat | float | Java 单精度浮点型 |
double | jdouble | double | Java 双精度浮点型 |
void | void | void | void 类型 |
② 引用类型映射：Java 中的对象（Objects）和数组（Arrays）属于引用类型。JNI 使用 jobject 类型作为所有 Java 对象的基类，并为特定的引用类型提供了专门的 JNI 类型：
| Java 类型（Java Type） | JNI 类型（JNI Type） | 描述（Description） |
|---|---|---|
java.lang.Object | jobject | 所有 Java 对象的基类 |
java.lang.String | jstring | Java 字符串对象 |
java.lang.Class | jclass | Java 类对象 |
java.lang.Throwable | jthrowable | Java 异常对象 |
java.lang.reflect.Method | jmethodID | Java 方法 ID (非类型，但常与引用类型一起讨论) |
java.lang.reflect.Field | jfieldID | Java 字段 ID (非类型，但常与引用类型一起讨论) |
boolean[] | jbooleanArray | Java 布尔型数组 |
byte[] | jbyteArray | Java 字节型数组 |
char[] | jcharArray | Java 字符型数组 |
short[] | jshortArray | Java 短整型数组 |
int[] | jintArray | Java 整型数组 |
long[] | jlongArray | Java 长整型数组 |
float[] | jfloatArray | Java 单精度浮点型数组 |
double[] | jdoubleArray | Java 双精度浮点型数组 |
Object[] | jobjectArray | Java 对象数组 |
理解这些数据类型映射是编写 JNI 代码的基础，确保在 Java 层和 Native 层之间正确地传递和处理数据。
2.1.2 方法签名（Method Signature）
在 JNI 中，当需要在 Native 代码中调用 Java 方法时，或者在 Java 代码中调用 Native 方法时，都需要使用方法签名来唯一标识一个 Java 方法。方法签名是一个字符串，它描述了方法的参数类型和返回类型。
① 方法签名格式：方法签名的基本格式如下：
1
(参数类型签名)返回类型签名
② 类型签名字符：下表列出了常用的类型签名字符：
| 类型签名字符（Type Signature Character） | Java 类型（Java Type） | JNI 类型（JNI Type） |
|---|---|---|
Z | boolean | jboolean |
B | byte | jbyte |
C | char | jchar |
S | short | jshort |
I | int | jint |
J | long | jlong |
F | float | jfloat |
D | double | jdouble |
V | void | void |
L<className>; | className | jobject (或其子类，如 jstring, jclass 等) |
[ | arrayType[] | jarray (或其子类，如 jintArray, jobjectArray 等) |
注意：
⚝ 类名 className 使用完全限定名，例如 java/lang/String 而不是 java.lang.String，并且使用 / 代替 . 分隔包名。
⚝ 方法签名中，参数类型签名按照参数顺序排列。
⚝ 如果方法没有参数，则参数类型签名部分为空，即 ()。
⚝ 构造方法的方法名为 <init>，静态初始化方法名为 <clinit>。
③ 获取方法签名：可以使用 JDK 提供的 javap 工具来获取 Java 方法的签名。在命令行中，进入包含 .class 文件的目录，然后执行以下命令：
1
javap -s -classpath .
其中 <ClassName> 是 Java 类的名称。-s 选项表示输出方法签名，-classpath . 表示类路径为当前目录。
示例：
假设有以下 Java 方法：
1
package com.example;
2
3
public class MyClass {
4
public static int add(int a, int b) {
5
return a + b;
6
}
7
8
public String getString(String input) {
9
return "Hello, " + input;
10
}
11
12
public MyClass() {
13
// Constructor
14
}
15
}
使用 javap -s -classpath . com.example.MyClass 命令，可以得到如下方法签名：
1
Compiled from "MyClass.java"
2
package com.example;
3
public class MyClass {
4
public com.example.MyClass();
5
descriptor: ()V
6
public static int add(int, int);
7
descriptor: (II)I
8
public java.lang.String getString(java.lang.String);
9
descriptor: (Ljava/lang/String;)Ljava/lang/String;
10
}
⚝ 构造方法 MyClass() 的签名是 ()V，表示没有参数，返回 void。
⚝ 静态方法 add(int, int) 的签名是 (II)I，表示接受两个 int 参数，返回 int。
⚝ 实例方法 getString(String) 的签名是 (Ljava/lang/String;)Ljava/lang/String;，表示接受一个 String 对象参数，返回 String 对象。
2.1.3 字段描述符（Field Descriptor）
字段描述符与方法签名类似，用于描述 Java 类的字段类型。在 JNI 中访问 Java 字段时，需要使用字段描述符来指定要访问的字段类型。
① 字段描述符格式：字段描述符的格式与方法签名中的返回类型签名格式相同，直接使用类型签名字符表示字段类型。
② 类型签名字符：字段描述符使用的类型签名字符与方法签名中的类型签名字符相同，请参考 2.1.2 节中的表格。
③ 获取字段描述符：同样可以使用 javap -s -classpath . <ClassName> 命令来获取 Java 字段的描述符。
示例：
假设 com.example.MyClass 类中包含以下字段：
1
package com.example;
2
3
public class MyClass {
4
public static int staticCount = 0;
5
public String name = "Default Name";
6
}
使用 javap -s -classpath . com.example.MyClass 命令，可以得到如下字段描述符：
1
Compiled from "MyClass.java"
2
package com.example;
3
public class MyClass {
4
public static int staticCount;
5
descriptor: I
6
public java.lang.String name;
7
descriptor: Ljava/lang/String;
8
public com.example.MyClass();
9
descriptor: ()V
10
public static int add(int, int);
11
descriptor: (II)I
12
public java.lang.String getString(java.lang.String);
13
descriptor: (Ljava/lang/String;)Ljava/lang/String;
14
}
⚝ 静态字段 staticCount 的描述符是 I，表示 int 类型。
⚝ 实例字段 name 的描述符是 Ljava/lang/String;，表示 String 对象类型。
掌握数据类型映射、方法签名和字段描述符是 JNI 开发的基础。在后续章节中，我们将看到如何使用这些基础知识进行 Java 层与 Native 层之间的互操作。
2.2 JNI 方法调用：静态方法、实例方法与构造方法
JNI 的核心功能之一是在 Native 代码中调用 Java 方法。根据 Java 方法的类型，JNI 提供了不同的函数来调用静态方法、实例方法和构造方法。本节将详细介绍如何在 Native 代码中调用这三种类型的 Java 方法。
2.2.1 调用静态方法（Calling Static Methods）
静态方法属于类本身，不依赖于类的实例。在 JNI 中调用静态方法需要以下步骤：
① 获取类引用（Get Class Reference）：首先需要获取要调用静态方法所属的 Java 类的 jclass 引用。可以使用 FindClass 函数根据类的完全限定名来查找类。
1
jclass clazz = env->FindClass("com/example/MyClass");
2
if (clazz == nullptr) {
3
// 异常处理：类未找到
4
return;
5
}
② 获取方法 ID（Get Method ID）：使用 GetStaticMethodID 函数获取静态方法的 ID (jmethodID)。该函数需要类引用、方法名和方法签名作为参数。
1
jmethodID methodId = env->GetStaticMethodID(clazz, "add", "(II)I");
2
if (methodId == nullptr) {
3
// 异常处理：方法未找到
4
env->DeleteLocalRef(clazz); // 释放类引用
5
return;
6
}
③ 调用静态方法（Call Static Method）：根据静态方法的返回类型，选择合适的 CallStatic<Type>Method 函数来调用方法。例如，如果方法返回 int 类型，则使用 CallStaticIntMethod。函数需要类引用、方法 ID 以及方法参数。
1
jint result = env->CallStaticIntMethod(clazz, methodId, 10, 20);
2
// 使用 result
④ 释放类引用（Release Class Reference）：如果类引用是局部引用，在不再需要时应该释放它，避免内存泄漏。
1
env->DeleteLocalRef(clazz);
完整示例代码：
1
#include <jni.h>
2
3
extern "C" JNIEXPORT jint JNICALL
4
Java_com_example_ndkbook_MainActivity_callStaticMethod(JNIEnv *env, jobject /* this */) {
5
jclass clazz = env->FindClass("com/example/ndkbook/MyCalculator");
6
if (clazz == nullptr) {
7
return -1; // 类未找到
8
}
9
10
jmethodID methodId = env->GetStaticMethodID(clazz, "add", "(II)I");
11
if (methodId == nullptr) {
12
env->DeleteLocalRef(clazz);
13
return -2; // 方法未找到
14
}
15
16
jint result = env->CallStaticIntMethod(clazz, methodId, 10, 20);
17
18
env->DeleteLocalRef(clazz);
19
return result;
20
}
Java 代码 (MyCalculator.java):
1
package com.example.ndkbook;
2
3
public class MyCalculator {
4
public static int add(int a, int b) {
5
return a + b;
6
}
7
}
2.2.2 调用实例方法（Calling Instance Methods）
实例方法属于类的实例，需要通过对象来调用。在 JNI 中调用实例方法需要以下步骤：
① 获取类引用（Get Class Reference）：与调用静态方法类似，首先需要获取要调用实例方法所属的 Java 类的 jclass 引用。
② 获取方法 ID（Get Method ID）：使用 GetMethodID 函数获取实例方法的 ID (jmethodID)。该函数需要类引用、方法名和方法签名作为参数。
1
jmethodID methodId = env->GetMethodID(clazz, "getString", "(Ljava/lang/String;)Ljava/lang/String;");
2
if (methodId == nullptr) {
3
// 异常处理：方法未找到
4
env->DeleteLocalRef(clazz);
5
return;
6
}
③ 获取对象实例（Get Object Instance）：需要获取要调用方法的 Java 对象实例 (jobject)。这通常是通过 JNI 函数参数传递进来的，或者通过其他 JNI 调用获取。
④ 调用实例方法（Call Instance Method）：根据实例方法的返回类型，选择合适的 Call<Type>Method 函数来调用方法。例如，如果方法返回 String 对象，则使用 CallObjectMethod。函数需要对象实例、方法 ID 以及方法参数。
1
jstring inputString = env->NewStringUTF("World");
2
jstring resultString = (jstring)env->CallObjectMethod(objectInstance, methodId, inputString);
3
// 使用 resultString
4
env->DeleteLocalRef(inputString); // 释放局部引用
⑤ 释放局部引用（Release Local References）：释放不再需要的局部引用，包括类引用和方法参数等。
完整示例代码：
1
#include <jni.h>
2
3
extern "C" JNIEXPORT jstring JNICALL
4
Java_com_example_ndkbook_MainActivity_callInstanceMethod(JNIEnv *env, jobject /* this */, jobject javaObject) {
5
jclass clazz = env->GetObjectClass(javaObject); // 从对象实例获取类引用
6
if (clazz == nullptr) {
7
return env->NewStringUTF("获取类失败");
8
}
9
10
jmethodID methodId = env->GetMethodID(clazz, "getName", "()Ljava/lang/String;");
11
if (methodId == nullptr) {
12
env->DeleteLocalRef(clazz);
13
return env->NewStringUTF("获取方法失败");
14
}
15
16
jstring resultString = (jstring)env->CallObjectMethod(javaObject, methodId);
17
18
env->DeleteLocalRef(clazz);
19
return resultString;
20
}
Java 代码 (MyObject.java):
1
package com.example.ndkbook;
2
3
public class MyObject {
4
private String name;
5
6
public MyObject(String name) {
7
this.name = name;
8
}
9
10
public String getName() {
11
return name;
12
}
13
}
MainActivity.java (调用 Native 方法):
1
// ...
2
MyObject myObject = new MyObject("JNI Object");
3
String name = callInstanceMethod(myObject);
4
// ...
5
private native String callInstanceMethod(MyObject javaObject);
2.2.3 调用构造方法（Calling Constructors）
构造方法用于创建 Java 对象实例。在 JNI 中调用构造方法的过程略有不同，需要先创建对象实例，然后再调用构造方法进行初始化。
① 获取类引用（Get Class Reference）：与前述方法类似，获取要创建对象的 Java 类的 jclass 引用。
② 获取构造方法 ID（Get Constructor Method ID）：使用 GetMethodID 函数获取构造方法的 ID (jmethodID)。构造方法的方法名固定为 <init>。
1
jmethodID constructorId = env->GetMethodID(clazz, "<init>", "(Ljava/lang/String;)V");
2
if (constructorId == nullptr) {
3
// 异常处理：构造方法未找到
4
env->DeleteLocalRef(clazz);
5
return nullptr;
6
}
③ 创建对象实例（Create Object Instance）：使用 NewObject 函数创建 Java 对象实例。该函数需要类引用、构造方法 ID 以及构造方法参数。
1
jstring nameString = env->NewStringUTF("New Object from JNI");
2
jobject newObject = env->NewObject(clazz, constructorId, nameString);
3
// 使用 newObject
4
env->DeleteLocalRef(nameString);
④ 释放局部引用（Release Local References）：释放不再需要的局部引用。
完整示例代码：
1
#include <jni.h>
2
3
extern "C" JNIEXPORT jobject JNICALL
4
Java_com_example_ndkbook_MainActivity_createObject(JNIEnv *env, jobject /* this */) {
5
jclass clazz = env->FindClass("com/example/ndkbook/MyObject");
6
if (clazz == nullptr) {
7
return nullptr; // 类未找到
8
}
9
10
jmethodID constructorId = env->GetMethodID(clazz, "<init>", "(Ljava/lang/String;)V");
11
if (constructorId == nullptr) {
12
env->DeleteLocalRef(clazz);
13
return nullptr; // 构造方法未找到
14
}
15
16
jstring nameString = env->NewStringUTF("Created by JNI");
17
jobject newObject = env->NewObject(clazz, constructorId, nameString);
18
19
env->DeleteLocalRef(clazz);
20
env->DeleteLocalRef(nameString);
21
return newObject;
22
}
Java 代码 (MyObject.java):
1
package com.example.ndkbook;
2
3
public class MyObject {
4
private String name;
5
6
public MyObject(String name) {
7
this.name = name;
8
}
9
10
public String getName() {
11
return name;
12
}
13
}
MainActivity.java (调用 Native 方法):
1
// ...
2
MyObject createdObject = createObject();
3
String objectName = createdObject.getName();
4
// ...
5
private native MyObject createObject();
通过以上介绍，我们了解了如何在 Native 代码中调用 Java 的静态方法、实例方法和构造方法。这些是 JNI 方法调用的基本操作，为实现 Java 层与 Native 层的交互提供了强大的工具。
2.3 JNI 字段访问：静态字段与实例字段
除了方法调用，JNI 还允许 Native 代码访问和修改 Java 对象的字段（成员变量）。与方法调用类似，字段也分为静态字段和实例字段，JNI 提供了不同的函数来访问这两种类型的字段。本节将详细介绍如何在 Native 代码中访问和修改 Java 字段。
2.3.1 访问静态字段（Accessing Static Fields）
静态字段属于类本身，不依赖于类的实例。在 JNI 中访问静态字段需要以下步骤：
① 获取类引用（Get Class Reference）：首先需要获取要访问静态字段所属的 Java 类的 jclass 引用。
1
jclass clazz = env->FindClass("com/example/MyClass");
2
if (clazz == nullptr) {
3
// 异常处理：类未找到
4
return;
5
}
② 获取字段 ID（Get Field ID）：使用 GetStaticFieldID 函数获取静态字段的 ID (jfieldID)。该函数需要类引用、字段名和字段描述符作为参数。
1
jfieldID fieldId = env->GetStaticFieldID(clazz, "staticCount", "I");
2
if (fieldId == nullptr) {
3
// 异常处理：字段未找到
4
env->DeleteLocalRef(clazz);
5
return;
6
}
③ 获取静态字段值（Get Static Field Value）：根据静态字段的类型，选择合适的 GetStatic<Type>Field 函数来获取字段值。例如，如果字段类型是 int，则使用 GetStaticIntField。函数需要类引用和字段 ID。
1
jint staticValue = env->GetStaticIntField(clazz, fieldId);
2
// 使用 staticValue
④ 设置静态字段值（Set Static Field Value）：如果需要修改静态字段的值，可以使用 SetStatic<Type>Field 函数。例如，如果字段类型是 int，则使用 SetStaticIntField。函数需要类引用、字段 ID 和新的字段值。
1
env->SetStaticIntField(clazz, fieldId, staticValue + 1);
⑤ 释放类引用（Release Class Reference）：如果类引用是局部引用，在不再需要时应该释放它。
1
env->DeleteLocalRef(clazz);
完整示例代码：
1
#include <jni.h>
2
3
extern "C" JNIEXPORT jint JNICALL
4
Java_com_example_ndkbook_MainActivity_accessStaticField(JNIEnv *env, jobject /* this */) {
5
jclass clazz = env->FindClass("com/example/ndkbook/MyCounter");
6
if (clazz == nullptr) {
7
return -1; // 类未找到
8
}
9
10
jfieldID fieldId = env->GetStaticFieldID(clazz, "staticCount", "I");
11
if (fieldId == nullptr) {
12
env->DeleteLocalRef(clazz);
13
return -2; // 字段未找到
14
}
15
16
jint staticValue = env->GetStaticIntField(clazz, fieldId);
17
env->SetStaticIntField(clazz, fieldId, staticValue + 1);
18
19
env->DeleteLocalRef(clazz);
20
return staticValue; // 返回修改前的值
21
}
Java 代码 (MyCounter.java):
1
package com.example.ndkbook;
2
3
public class MyCounter {
4
public static int staticCount = 0;
5
}
2.3.2 访问实例字段（Accessing Instance Fields）
实例字段属于类的实例，需要通过对象来访问。在 JNI 中访问实例字段需要以下步骤：
① 获取类引用（Get Class Reference）：与访问静态字段类似，首先需要获取要访问实例字段所属的 Java 类的 jclass 引用。
② 获取字段 ID（Get Field ID）：使用 GetFieldID 函数获取实例字段的 ID (jfieldID)。该函数需要类引用、字段名和字段描述符作为参数。
1
jfieldID fieldId = env->GetFieldID(clazz, "name", "Ljava/lang/String;");
2
if (fieldId == nullptr) {
3
// 异常处理：字段未找到
4
env->DeleteLocalRef(clazz);
5
return;
6
}
③ 获取对象实例（Get Object Instance）：需要获取要访问字段的 Java 对象实例 (jobject)。
④ 获取实例字段值（Get Instance Field Value）：根据实例字段的类型，选择合适的 Get<Type>Field 函数来获取字段值。例如，如果字段类型是 String 对象，则使用 GetObjectField。函数需要对象实例和字段 ID。
1
jstring nameValue = (jstring)env->GetObjectField(objectInstance, fieldId);
2
// 使用 nameValue
⑤ 设置实例字段值（Set Instance Field Value）：如果需要修改实例字段的值，可以使用 Set<Type>Field 函数。例如，如果字段类型是 String 对象，则使用 SetObjectField。函数需要对象实例、字段 ID 和新的字段值。
1
jstring newNameString = env->NewStringUTF("Updated Name from JNI");
2
env->SetObjectField(objectInstance, fieldId, newNameString);
3
env->DeleteLocalRef(newNameString); // 释放局部引用
⑥ 释放局部引用（Release Local References）：释放不再需要的局部引用。
完整示例代码：
1
#include <jni.h>
2
3
extern "C" JNIEXPORT jstring JNICALL
4
Java_com_example_ndkbook_MainActivity_accessInstanceField(JNIEnv *env, jobject /* this */, jobject javaObject) {
5
jclass clazz = env->GetObjectClass(javaObject);
6
if (clazz == nullptr) {
7
return env->NewStringUTF("获取类失败");
8
}
9
10
jfieldID fieldId = env->GetFieldID(clazz, "name", "Ljava/lang/String;");
11
if (fieldId == nullptr) {
12
env->DeleteLocalRef(clazz);
13
return env->NewStringUTF("获取字段失败");
14
}
15
16
jstring nameValue = (jstring)env->GetObjectField(javaObject, fieldId);
17
jstring newNameString = env->NewStringUTF("Modified by JNI");
18
env->SetObjectField(javaObject, fieldId, newNameString);
19
env->DeleteLocalRef(newNameString);
20
21
env->DeleteLocalRef(clazz);
22
return nameValue; // 返回修改前的值
23
}
Java 代码 (MyObject.java):
1
package com.example.ndkbook;
2
3
public class MyObject {
4
public String name = "Default Name";
5
6
public String getName() {
7
return name;
8
}
9
}
MainActivity.java (调用 Native 方法):
1
// ...
2
MyObject myObject = new MyObject();
3
String originalName = accessInstanceField(myObject);
4
String currentName = myObject.getName(); // 获取修改后的值
5
// ...
6
private native String accessInstanceField(MyObject javaObject);
通过本节的学习，我们掌握了如何在 Native 代码中访问和修改 Java 类的静态字段和实例字段。字段访问是 JNI 中数据交互的重要组成部分，与方法调用一起，构成了 Java 层与 Native 层之间双向通信的基础。
2.4 JNI 引用类型：局部引用、全局引用与弱全局引用
在 JNI 中，Native 代码通过 jobject 及其子类型（如 jstring, jclass 等）来操作 Java 对象。这些 jobject 实际上是对 JVM 中 Java 对象的引用。JNI 引用对于内存管理至关重要，不当的引用管理可能导致内存泄漏或程序崩溃。JNI 提供了三种类型的引用：局部引用（Local Reference）、全局引用（Global Reference）和弱全局引用（Weak Global Reference），每种引用类型都有不同的生命周期和适用场景。
2.4.1 局部引用（Local Reference）
局部引用是最常见的 JNI 引用类型。大多数通过 JNI 函数返回的 jobject 都是局部引用，例如 FindClass, NewObject, CallObjectMethod 等返回的引用。
① 生命周期：局部引用的生命周期非常短暂，仅在 Native 方法的当前线程的当前 Native 方法的执行期间有效。当 Native 方法返回 Java 层，或者 Native 方法调用了 DeleteLocalRef 函数显式释放局部引用时，局部引用就会失效。JVM 会自动回收局部引用指向的 Java 对象（如果不再有其他引用指向该对象）。
② 特点：
⚝ 自动释放：JVM 会在 Native 方法返回时自动释放所有局部引用，无需手动管理。
⚝ 线程安全：局部引用只在创建它的线程中有效，不能跨线程使用。
⚝ 性能优化：由于生命周期短，JVM 可以更高效地管理局部引用，减少内存压力。
⚝ 限制数量：每个 Native 方法可以创建的局部引用数量有限制（通常为 16 到 512 个），超出限制可能导致程序崩溃。
③ 适用场景：局部引用适用于大多数 JNI 操作，例如：
⚝ 在 Native 方法中临时使用 Java 对象。
⚝ 作为 JNI 函数的参数或返回值。
⚝ 在循环或频繁调用的代码块中创建的临时对象。
④ 显式释放：虽然 JVM 会自动释放局部引用，但在某些情况下，为了避免局部引用表溢出，或者为了尽早释放不再需要的对象，可以显式调用 DeleteLocalRef 函数释放局部引用。
1
jstring localString = env->NewStringUTF("Temporary String");
2
// ... 使用 localString ...
3
env->DeleteLocalRef(localString); // 显式释放局部引用
注意： 错误地释放局部引用（例如，释放了非局部引用，或者释放了已经被释放的引用）会导致程序崩溃。
2.4.2 全局引用（Global Reference）
全局引用可以跨越多个 Native 方法调用，甚至跨越多个线程使用。全局引用需要手动创建和显式释放。
① 生命周期：全局引用的生命周期由程序员手动控制。全局引用在被显式调用 DeleteGlobalRef 函数释放之前一直有效，即使创建它的 Native 方法已经返回，甚至创建它的线程已经结束。
② 特点：
⚝ 手动管理：全局引用必须手动创建和释放，否则会导致内存泄漏。
⚝ 跨线程：全局引用可以在多个线程之间共享和使用。
⚝ 持久性：全局引用指向的对象在全局引用被释放之前不会被 JVM 回收（除非没有其他引用指向该对象）。
⚝ 资源消耗：全局引用会增加 JVM 的内存管理负担，应谨慎使用。
③ 创建全局引用：使用 NewGlobalRef 函数从局部引用或全局引用创建全局引用。
1
jstring localString = env->NewStringUTF("Persistent String");
2
jstring globalString = (jstring)env->NewGlobalRef(localString); // 创建全局引用
3
env->DeleteLocalRef(localString); // 局部引用可以释放
4
// ... 在后续的 Native 方法或线程中使用 globalString ...
④ 释放全局引用：使用 DeleteGlobalRef 函数显式释放全局引用。
1
env->DeleteGlobalRef(globalString); // 释放全局引用
2
globalString = nullptr; // 建议将全局引用变量置为 nullptr，防止悬空指针
⑤ 适用场景：全局引用适用于以下场景：
⚝ 需要在多个 Native 方法调用之间保持 Java 对象存活。
⚝ 需要在多个线程之间共享 Java 对象。
⚝ 需要缓存 Java 对象，例如，缓存 jclass 或 jmethodID 等。
注意： 全局引用必须成对创建和释放，避免内存泄漏。全局引用的创建和释放应该在明确的生命周期管理下进行。
2.4.3 弱全局引用（Weak Global Reference）
弱全局引用是全局引用的一种特殊形式。与全局引用类似，弱全局引用也可以跨越多个 Native 方法调用和线程使用，但弱全局引用不会阻止 JVM 回收其指向的 Java 对象。
① 生命周期：弱全局引用的生命周期也由程序员手动控制创建和释放。但是，即使弱全局引用仍然存在，其指向的 Java 对象也可能被 JVM 回收（如果只有弱全局引用指向该对象）。
② 特点：
⚝ 手动管理：弱全局引用也需要手动创建和释放。
⚝ 跨线程：弱全局引用也可以跨线程使用。
⚝ 不阻止回收：弱全局引用不会阻止 JVM 回收其指向的对象。
⚝ 可能失效：弱全局引用指向的对象可能在任何时候被回收，使用前需要检查其是否仍然有效。
③ 创建弱全局引用：使用 NewWeakGlobalRef 函数从局部引用或全局引用创建弱全局引用。
1
jstring localString = env->NewStringUTF("Weak Reference String");
2
jweak weakString = env->NewWeakGlobalRef(localString); // 创建弱全局引用
3
env->DeleteLocalRef(localString);
④ 检查弱全局引用是否有效：在使用弱全局引用之前，需要使用 IsSameObject 函数检查其指向的对象是否已经被回收。如果对象已被回收，IsSameObject(weakRef, nullptr) 将返回 JNI_TRUE。
1
if (env->IsSameObject(weakString, nullptr)) {
2
// 弱全局引用指向的对象已被回收
3
// ... 处理对象已被回收的情况 ...
4
} else {
5
// 弱全局引用仍然有效，可以使用
6
jstring resolvedString = (jstring)env->NewLocalRef(weakString); // 将弱全局引用转换为局部引用使用
7
// ... 使用 resolvedString ...
8
env->DeleteLocalRef(resolvedString); // 使用完后释放局部引用
9
}
⑤ 释放弱全局引用：使用 DeleteWeakGlobalRef 函数显式释放弱全局引用。
1
env->DeleteWeakGlobalRef(weakString);
2
weakString = nullptr;
⑥ 适用场景：弱全局引用适用于以下场景：
⚝ 需要缓存 Java 对象，但允许 JVM 在内存紧张时回收这些对象。
⚝ 实现类似观察者模式，当被观察对象被回收时，观察者可以自动感知。
⚝ 避免循环引用导致的内存泄漏。
注意： 弱全局引用使用起来比全局引用更复杂，需要在使用前检查其有效性，并妥善处理对象被回收的情况。
2.4.4 引用类型选择与最佳实践
选择合适的 JNI 引用类型对于编写高效且稳定的 NDK 代码至关重要。以下是一些引用类型选择和使用的最佳实践：
⚝ 优先使用局部引用：在大多数情况下，局部引用已经足够满足需求。局部引用由 JVM 自动管理，性能高，资源消耗小。
⚝ 谨慎使用全局引用：全局引用应仅在必要时使用，例如，缓存 jclass 或 jmethodID，或者需要在多个 Native 方法或线程之间共享对象。全局引用必须手动管理，避免内存泄漏。
⚝ 合理使用弱全局引用：弱全局引用适用于需要缓存对象，但允许 JVM 回收的场景。弱全局引用使用前需要检查有效性，并处理对象被回收的情况。
⚝ 及时释放引用：对于局部引用，虽然 JVM 会自动释放，但在循环或大量创建局部引用的场景下，应考虑显式释放，避免局部引用表溢出。对于全局引用和弱全局引用，必须显式释放，避免内存泄漏。
⚝ 避免引用泄漏：确保 JNI 引用与 Java 对象的生命周期管理一致，避免引用泄漏。例如，不要将局部引用存储在静态变量或全局变量中，导致局部引用超出其生命周期。
⚝ 使用工具检测内存泄漏：使用内存分析工具（例如，Android Studio Profiler, Valgrind 等）检测 JNI 代码中的内存泄漏问题，及时修复。
理解和正确使用 JNI 引用类型是高级 NDK 开发的关键技能。合理的引用管理可以提高程序的性能和稳定性，避免潜在的内存问题。
2.5 JNI 异常处理：Java 异常与 Native 异常的交互
在 JNI 开发中，Java 异常和 Native 异常的交互处理至关重要。当 Java 代码调用 Native 方法时，Native 代码中可能发生错误，需要能够将错误信息传递回 Java 层，以便 Java 层进行异常处理。同样，Native 代码在调用 Java 方法时，Java 方法也可能抛出异常，Native 代码需要能够捕获和处理这些 Java 异常。本节将详细介绍 JNI 中 Java 异常与 Native 异常的交互处理机制。
2.5.1 Java 异常传递到 Native 层
当 Java 代码调用 Native 方法时，如果 Java 层在调用之前已经存在未处理的异常，或者在 Native 方法执行过程中，Java 代码通过 JNI 函数调用抛出了异常，这些 Java 异常会被传递到 Native 层。
① 检查 Java 异常：在 Native 代码中，可以使用以下 JNI 函数来检查是否发生了 Java 异常：
⚝ jboolean ExceptionCheck(JNIEnv *env)：检查当前线程是否发生了 Java 异常。如果发生了异常，返回 JNI_TRUE，否则返回 JNI_FALSE。
⚝ jthrowable ExceptionOccurred(JNIEnv *env)：检查当前线程是否发生了 Java 异常，并返回异常对象 (jthrowable)。如果没有异常发生，返回 nullptr。
② 处理 Java 异常：如果检测到 Java 异常，Native 代码可以选择以下处理方式：
⚝ 清除异常并继续执行：使用 void ExceptionClear(JNIEnv *env) 函数清除当前线程的 Java 异常状态。清除异常后，Native 代码可以继续执行，但 Java 异常信息会丢失。通常在 Native 代码能够妥善处理异常并恢复执行的情况下使用。
1
if (env->ExceptionCheck()) {
2
env->ExceptionClear(); // 清除异常
3
// ... 继续执行 ...
4
}
⚝ 返回到 Java 层处理：如果 Native 代码无法处理 Java 异常，或者希望将异常传递回 Java 层处理，则 Native 代码不应该清除异常，而是直接返回。当 Native 方法返回时，JVM 会检查是否有未处理的 Java 异常，如果有，则会将异常抛给 Java 层的调用者。
1
if (env->ExceptionCheck()) {
2
return; // 直接返回，将异常传递回 Java 层
3
}
⚝ 抛出新的 Java 异常：Native 代码可以捕获已发生的 Java 异常，并根据需要抛出新的 Java 异常。可以使用 jint ThrowNew(JNIEnv *env, jclass clazz, const char *message) 函数抛出指定类型的 Java 异常。
1
if (env->ExceptionCheck()) {
2
jthrowable originalException = env->ExceptionOccurred();
3
env->ExceptionClear(); // 清除原始异常
4
5
jclass newExceptionClass = env->FindClass("java/lang/RuntimeException");
6
if (newExceptionClass != nullptr) {
7
env->ThrowNew(newExceptionClass, "Native code caught and re-threw an exception");
8
}
9
env->DeleteLocalRef(newExceptionClass);
10
env->DeleteLocalRef(originalException);
11
return; // 返回，抛出新的异常
12
}
示例：Native 代码捕获并处理 Java 异常
假设 Java 代码调用 Native 方法时，可能会抛出 IOException 异常。Native 代码可以捕获这个异常，并进行处理：
Java 代码：
1
public class MyClass {
2
public native void nativeMethod() throws IOException;
3
4
public void callNativeMethod() {
5
try {
6
nativeMethod();
7
} catch (IOException e) {
8
Log.e("JNI_ERROR", "Java caught IOException: " + e.getMessage());
9
}
10
}
11
}
Native 代码：
1
#include <jni.h>
2
#include <android/log.h>
3
4
#define LOG_TAG "JNI_EXAMPLE"
5
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
6
7
extern "C" JNIEXPORT void JNICALL
8
Java_com_example_ndkbook_MyClass_nativeMethod(JNIEnv *env, jobject /* this */) {
9
// 模拟 Java 代码抛出 IOException
10
jclass ioExceptionClass = env->FindClass("java/io/IOException");
11
if (ioExceptionClass != nullptr) {
12
env->ThrowNew(ioExceptionClass, "Simulated IOException from Native");
13
env->DeleteLocalRef(ioExceptionClass);
14
}
15
16
if (env->ExceptionCheck()) {
17
jthrowable exception = env->ExceptionOccurred();
18
env->ExceptionClear(); // 清除异常
19
20
// 获取异常类名和错误信息
21
jclass exceptionClass = env->GetObjectClass(exception);
22
jmethodID getMessageMethod = env->GetMethodID(exceptionClass, "getMessage", "()Ljava/lang/String;");
23
jstring messageString = (jstring)env->CallObjectMethod(exception, getMessageMethod);
24
const char *message = env->GetStringUTFChars(messageString, nullptr);
25
26
LOGE("Native code caught Java exception: %s", message);
27
28
env->ReleaseStringUTFChars(messageString, message);
29
env->DeleteLocalRef(messageString);
30
env->DeleteLocalRef(exceptionClass);
31
env->DeleteLocalRef(exception);
32
33
// Native 代码可以选择继续执行，或者返回到 Java 层
34
// 这里选择继续执行
35
LOGE("Native code continues execution after handling exception.");
36
} else {
37
LOGE("No Java exception occurred.");
38
}
39
}
2.5.2 Native 代码抛出 Java 异常
Native 代码可以使用 ThrowNew 函数主动抛出 Java 异常，将错误信息传递回 Java 层。
① 获取异常类引用：首先需要获取要抛出的 Java 异常类的 jclass 引用。常用的异常类包括 java.lang.Exception, java.lang.RuntimeException, java.lang.IllegalArgumentException 等。可以使用 FindClass 函数查找异常类。
1
jclass exceptionClass = env->FindClass("java/lang/IllegalArgumentException");
2
if (exceptionClass == nullptr) {
3
// 异常处理：异常类未找到
4
return;
5
}
② 抛出异常：使用 ThrowNew 函数抛出指定类型的 Java 异常。函数需要异常类引用、异常消息字符串作为参数。
1
env->ThrowNew(exceptionClass, "Invalid argument value");
2
env->DeleteLocalRef(exceptionClass);
3
return; // 抛出异常后，Native 方法通常应该立即返回
示例：Native 代码抛出 Java 异常
Java 代码：
1
public class MyClass {
2
public native int divide(int a, int b) throws ArithmeticException;
3
4
public void callDivide(int a, int b) {
5
try {
6
int result = divide(a, b);
7
Log.d("JNI_RESULT", "Result of division: " + result);
8
} catch (ArithmeticException e) {
9
Log.e("JNI_ERROR", "Java caught ArithmeticException: " + e.getMessage());
10
}
11
}
12
}
Native 代码：
1
#include <jni.h>
2
3
extern "C" JNIEXPORT jint JNICALL
4
Java_com_example_ndkbook_MyClass_divide(JNIEnv *env, jobject /* this */, jint a, jint b) {
5
if (b == 0) {
6
jclass arithmeticExceptionClass = env->FindClass("java/lang/ArithmeticException");
7
if (arithmeticExceptionClass != nullptr) {
8
env->ThrowNew(arithmeticExceptionClass, "Division by zero");
9
env->DeleteLocalRef(arithmeticExceptionClass);
10
}
11
return -1; // 返回一个错误值，但 Java 层会收到异常
12
}
13
return a / b;
14
}
2.5.3 Native 异常处理
虽然 JNI 主要关注 Java 异常的处理，但在 Native 代码中也可能发生 C/C++ 异常（例如，std::exception）。JNI 本身不直接处理 Native 异常，Native 代码需要使用 C++ 的异常处理机制（try-catch 块）来捕获和处理 Native 异常。
如果 Native 异常发生后，Native 代码希望将错误信息传递回 Java 层，可以将 Native 异常转换为 Java 异常抛出。
示例：Native 代码处理 C++ 异常并转换为 Java 异常
1
#include <jni.h>
2
#include <stdexcept>
3
4
extern "C" JNIEXPORT jint JNICALL
5
Java_com_example_ndkbook_MyClass_nativeMethodWithCppException(JNIEnv *env, jobject /* this */) {
6
try {
7
// 模拟 C++ 异常
8
throw std::runtime_error("C++ runtime error occurred");
9
} catch (const std::exception& e) {
10
jclass runtimeExceptionClass = env->FindClass("java/lang/RuntimeException");
11
if (runtimeExceptionClass != nullptr) {
12
env->ThrowNew(runtimeExceptionClass, e.what()); // 将 C++ 异常信息转换为 Java 异常
13
env->DeleteLocalRef(runtimeExceptionClass);
14
}
15
return -1; // 返回错误值，Java 层会收到异常
16
}
17
return 0; // 正常返回
18
}
Java 代码：
1
public class MyClass {
2
public native int nativeMethodWithCppException() throws RuntimeException;
3
4
public void callNativeMethodWithCppException() {
5
try {
6
nativeMethodWithCppException();
7
} catch (RuntimeException e) {
8
Log.e("JNI_ERROR", "Java caught RuntimeException from C++: " + e.getMessage());
9
}
10
}
11
}
2.5.4 JNI 异常处理最佳实践
⚝ 及时检查异常：在 JNI 函数调用后，应及时使用 ExceptionCheck 或 ExceptionOccurred 检查是否发生了 Java 异常。
⚝ 选择合适的异常处理方式：根据 Native 代码的逻辑和异常处理能力，选择清除异常、传递异常或抛出新异常等合适的处理方式。
⚝ 避免忽略异常：不要忽略 Java 异常，否则可能导致程序状态不一致或崩溃。
⚝ 使用 try-catch 处理 Native 异常：在 Native 代码中使用 try-catch 块捕获和处理 C++ 异常，并根据需要转换为 Java 异常抛出。
⚝ 提供清晰的异常信息：在抛出 Java 异常时，提供清晰的异常消息，方便 Java 层进行错误诊断和处理。
⚝ 文档化异常：在 JNI 接口文档中，明确 Native 方法可能抛出的 Java 异常类型，方便 Java 开发者正确处理异常。
通过合理的 JNI 异常处理机制，可以确保 Java 层和 Native 层之间的错误信息能够有效传递和处理，提高程序的健壮性和可靠性。
2.6 JNI 线程管理：在 Native 层创建和管理 Java 线程
在 Android 应用开发中，多线程编程是常见的需求。在 NDK 开发中，有时需要在 Native 代码中创建和管理 Java 线程，以便利用 Java 线程的特性，例如，方便地访问 Android Framework API，或者与现有的 Java 线程池集成。JNI 提供了 API，允许 Native 代码创建、管理和操作 Java 线程。本节将详细介绍如何在 Native 层创建和管理 Java 线程。
2.6.1 附加线程到 JVM（Attaching Thread to JVM）
当 Native 代码需要在新的线程中调用 Java 代码时，必须首先将该 Native 线程附加到 JVM。只有附加到 JVM 的 Native 线程才能获取 JNIEnv 指针，并使用 JNI 函数调用 Java 代码。
① 获取 JavaVM 指针：在 JNI 初始化时，JVM 会将 JavaVM 指针传递给 JNI_OnLoad 函数。需要将 JavaVM 指针保存起来，以便在后续的 Native 线程中使用。
1
JavaVM *g_jvm = nullptr;
2
3
JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *reserved) {
4
g_jvm = vm; // 保存 JavaVM 指针
5
return JNI_VERSION_1_6;
6
}
② 附加当前线程：在 Native 线程的入口函数中，使用 AttachCurrentThread 函数将当前 Native 线程附加到 JVM。AttachCurrentThread 函数需要 JavaVM 指针和 JNIEnv 指针的指针作为参数，并将返回 JNIEnv 指针。
1
#include <pthread.h>
2
3
void* nativeThreadEntry(void* arg) {
4
JNIEnv *env;
5
JavaVMAttachArgs attachArgs;
6
attachArgs.version = JNI_VERSION_1_6;
7
attachArgs.name = "NativeThread"; // 线程名称，可选
8
attachArgs.group = nullptr; // 线程组，可选
9
10
jint result = g_jvm->AttachCurrentThread(&env, &attachArgs);
11
if (result != JNI_OK) {
12
// 附加线程失败，处理错误
13
return nullptr;
14
}
15
16
// 现在可以使用 env 指针调用 JNI 函数
17
jclass stringClass = env->FindClass("java/lang/String");
18
// ... 其他 JNI 操作 ...
19
20
// 执行完 JNI 操作后，需要分离线程
21
g_jvm->DetachCurrentThread();
22
return nullptr;
23
}
24
25
// 创建 Native 线程
26
pthread_t thread;
27
pthread_create(&thread, nullptr, nativeThreadEntry, nullptr);
注意：
⚝ AttachCurrentThread 函数的第二个参数是 JavaVMAttachArgs 结构体，用于设置线程附加参数，例如线程名称和线程组。可以设置为 nullptr 使用默认参数。
⚝ AttachCurrentThread 函数可能会失败，需要检查返回值，并进行错误处理。
⚝ 每个 Native 线程只需要附加一次。如果线程需要多次调用 Java 代码，只需要在线程入口函数中附加一次即可。
2.6.2 分离线程与资源释放（Detaching Thread and Resource Release）
当 Native 线程不再需要调用 Java 代码时，应该将线程从 JVM 分离。分离线程可以释放 JVM 资源，避免资源泄漏。
① 分离当前线程：在 Native 线程的出口函数中，使用 DetachCurrentThread 函数将当前 Native 线程从 JVM 分离。
1
g_jvm->DetachCurrentThread(); // 分离当前线程
注意：
⚝ DetachCurrentThread 函数必须与 AttachCurrentThread 成对调用。每个附加的线程都必须在线程结束前分离。
⚝ 通常在 Native 线程的出口函数（例如，pthread_exit 或线程函数返回前）调用 DetachCurrentThread。
⚝ 分离线程后，该线程就不能再使用之前获取的 JNIEnv 指针调用 JNI 函数。
② 资源释放：在线程分离之前，应该释放线程中使用的 JNI 资源，例如，局部引用、全局引用等。虽然局部引用会在线程分离时自动释放，但显式释放可以更早地回收资源，并有助于避免资源泄漏。全局引用和弱全局引用必须手动释放。
2.6.3 获取 JNIEnv 指针
对于已经附加到 JVM 的 Native 线程，可以使用 GetEnv 函数获取该线程的 JNIEnv 指针。GetEnv 函数需要 JavaVM 指针和 JNI 版本号作为参数，并将返回 JNIEnv 指针。
1
JNIEnv *env;
2
jint result = g_jvm->GetEnv((void**)&env, JNI_VERSION_1_6);
3
if (result == JNI_EDETACHED) {
4
// 线程未附加到 JVM，需要先附加线程
5
// ... 调用 AttachCurrentThread ...
6
} else if (result == JNI_OK) {
7
// 获取 JNIEnv 指针成功，可以使用 env 指针调用 JNI 函数
8
// ... 使用 env 指针 ...
9
} else if (result == JNI_EVERSION) {
10
// JNI 版本不支持
11
// ... 处理版本错误 ...
12
}
注意：
⚝ GetEnv 函数可以用于检查当前线程是否已经附加到 JVM。如果线程未附加，GetEnv 函数会返回 JNI_EDETACHED。
⚝ 如果线程已经附加，GetEnv 函数会返回该线程的 JNIEnv 指针。
⚝ GetEnv 函数不会创建新的 JNIEnv 指针，也不会附加线程。
2.6.4 线程安全与同步
在多线程 JNI 编程中，线程安全是一个重要的考虑因素。JNIEnv 指针是线程相关的，每个线程都有自己的 JNIEnv 指针，不能在多个线程之间共享 JNIEnv 指针。
如果多个 Native 线程需要访问和修改共享的 Java 对象，需要进行线程同步，避免数据竞争和并发问题。可以使用 Java 提供的线程同步机制（例如，synchronized 关键字，java.util.concurrent 包中的类），或者使用 Native 线程同步机制（例如，互斥锁、条件变量等）。
示例：使用 Java 线程同步机制
假设多个 Native 线程需要递增同一个 Java 对象的计数器字段。可以使用 Java 的 synchronized 关键字来保证线程安全。
Java 代码：
1
public class Counter {
2
private int count = 0;
3
4
public synchronized void increment() {
5
count++;
6
}
7
8
public int getCount() {
9
return count;
10
}
11
}
Native 代码：
1
#include <jni.h>
2
3
extern "C" JNIEXPORT void JNICALL
4
Java_com_example_ndkbook_Counter_incrementFromNative(JNIEnv *env, jobject /* this */) {
5
jclass counterClass = env->GetObjectClass(thiz);
6
jmethodID incrementMethod = env->GetMethodID(counterClass, "increment", "()V");
7
if (incrementMethod != nullptr) {
8
env->CallVoidMethod(thiz, incrementMethod); // 调用 Java 的 synchronized 方法
9
}
10
env->DeleteLocalRef(counterClass);
11
}
由于 increment 方法是 synchronized 的，多个 Native 线程同时调用 incrementFromNative 方法时，对 count 字段的递增操作会是线程安全的。
2.6.5 JNI 线程管理最佳实践
⚝ 按需附加和分离线程：只在 Native 线程需要调用 Java 代码时才附加线程，并在线程结束前及时分离线程，避免资源浪费。
⚝ 避免长时间附加线程：如果 Native 线程只需要短暂地调用 Java 代码，可以在调用前后立即附加和分离线程，避免长时间占用 JVM 资源。
⚝ 使用线程池管理 Native 线程：如果需要频繁创建和销毁 Native 线程，可以使用线程池来管理 Native 线程，提高线程复用率和性能。
⚝ 注意线程安全：在多线程 JNI 编程中，务必考虑线程安全问题，并采取合适的线程同步措施，保证数据一致性和程序稳定性。
⚝ 避免死锁：在 Native 线程和 Java 线程之间进行同步时，注意避免死锁问题。例如，避免 Native 线程持有锁等待 Java 线程释放锁，同时 Java 线程又持有锁等待 Native 线程释放锁的情况。
通过合理的 JNI 线程管理，可以在 Native 代码中灵活地使用 Java 线程，实现更复杂的多线程应用场景，并充分利用 Java 和 Native 平台的优势。
ENDOF_CHAPTER_
3. chapter 3： NDK 核心 API：构建高性能 Native 应用
3.1 C/C++ 标准库与 NDK 支持：常用库函数详解
Android NDK (Native Development Kit) 旨在让你在 Android 应用中使用 C 和 C++ 等原生语言编写高性能代码。为了方便开发者，NDK 提供了对 C/C++ 标准库的大力支持，使得开发者能够复用已有的 C/C++ 代码和开发经验，降低学习成本，提高开发效率。然而，需要注意的是，NDK 提供的标准库支持并非完整意义上的 POSIX 标准兼容，而是针对移动平台特性进行了裁剪和优化。
本节将详细介绍 NDK 中对 C/C++ 标准库的支持情况，并重点讲解一些常用的库函数，帮助读者了解如何在 NDK 开发中有效地利用这些工具。
3.1.1 NDK 标准库支持概览
NDK 主要通过以下几种方式提供 C/C++ 标准库支持：
① Bionic Libc：Bionic 是 Google 为 Android 专门开发的 C 标准库，它是 BSD libc 的一个变种，针对嵌入式系统和移动设备进行了优化，例如体积更小、性能更高。NDK 默认使用 Bionic Libc 作为 C 标准库的实现。Bionic 实现了大部分 ANSI C 和 POSIX 标准，包括：
▮▮▮▮ⓐ 标准 C 库函数：如 stdio.h (输入输出)、stdlib.h (通用工具函数)、string.h (字符串操作)、math.h (数学函数)、time.h (时间函数) 等。
▮▮▮▮ⓑ POSIX 线程库 (pthread)：用于多线程编程，提供了线程创建、同步、互斥锁、条件变量等功能。
▮▮▮▮ⓒ Socket 网络库：支持 TCP/IP 和 UDP 网络通信，提供了 socket 编程相关的函数。
▮▮▮▮ⓓ 其他 POSIX 兼容的函数：例如文件 I/O 操作、进程管理、信号处理等。
② C++ 标准库 (libc++)：NDK 提供了 libc++ 作为 C++ 标准库的实现，它是一个高性能、开源的 C++ 标准库，源自 LLVM 项目。libc++ 提供了完整的 C++ 标准库功能，包括：
▮▮▮▮ⓐ STL (Standard Template Library)：包括容器（如 vector, list, map）、算法（如 sort, find, transform）、迭代器等。
▮▮▮▮ⓑ iostream：用于输入输出流操作，如 cin, cout, cerr, fstream 等。
▮▮▮▮ⓒ string：C++ 字符串类，提供了更安全、更方便的字符串操作方式。
▮▮▮▮ⓓ 其他 C++ 标准库组件：如异常处理、智能指针、时间库、正则表达式等。
③ 其他常用库：除了标准库之外，NDK 还提供了一些常用的第三方库，例如：
▮▮▮▮ⓐ zlib：用于数据压缩和解压缩。
▮▮▮▮ⓑ libpng 和 libjpeg：用于图像处理，支持 PNG 和 JPEG 格式。
▮▮▮▮ⓒ OpenSSL：用于安全加密和网络通信。
3.1.2 常用 C 标准库函数详解
在 NDK 开发中，C 标准库函数是使用频率最高的工具之一。下面我们选取一些常用的类别，并详细介绍其中的一些典型函数。
① 字符串操作 (string.h)
string.h 头文件提供了一系列用于处理 C 风格字符串（char 数组）的函数。
⚝ strcpy(char *dest, const char *src)：将 src 指向的字符串复制到 dest 指向的字符数组中，包括空字符 \0。注意： strcpy 不进行边界检查，容易导致缓冲区溢出，应尽量使用更安全的 strncpy 或 strcpy_s (如果可用)。
1
#include <string.h>
2
#include <android/log.h>
3
4
void stringCopyExample() {
5
char src[] = "Hello NDK";
6
char dest[20]; // 确保 dest 足够大
7
8
strcpy(dest, src);
9
__android_log_print(ANDROID_LOG_INFO, "NDK_TAG", "Copied string: %s", dest);
10
}
⚝ strncpy(char *dest, const char *src, size_t n)：与 strcpy 类似，但最多复制 n 个字符到 dest。如果 src 的长度小于 n，则 dest 会用空字符填充到长度 n。如果 src 的长度大于等于 n，则 dest 不会以空字符结尾，需要手动添加。
1
#include <string.h>
2
#include <android/log.h>
3
4
void stringNCopyExample() {
5
char src[] = "Hello NDK World";
6
char dest[10];
7
8
strncpy(dest, src, sizeof(dest) - 1); // 留一个位置给 '\0'
9
dest[sizeof(dest) - 1] = '\0'; // 手动添加空字符
10
__android_log_print(ANDROID_LOG_INFO, "NDK_TAG", "Copied string (strncpy): %s", dest);
11
}
⚝ strcat(char *dest, const char *src)：将 src 指向的字符串追加到 dest 指向的字符串末尾。同样存在缓冲区溢出风险，应使用 strncat 或 strcat_s。
⚝ strncat(char *dest, const char *src, size_t n)：与 strcat 类似，但最多从 src 追加 n 个字符到 dest。
⚝ strcmp(const char *s1, const char *s2)：比较字符串 s1 和 s2，返回 0 如果相等，负数如果 s1 小于 s2，正数如果 s1 大于 s2。
⚝ strncmp(const char *s1, const char *s2, size_t n)：与 strcmp 类似，但只比较前 n 个字符。
⚝ strlen(const char *s)：返回字符串 s 的长度，不包括空字符 \0。
② 标准输入输出 (stdio.h)
stdio.h 头文件提供了标准的输入输出函数，但在 Android NDK 环境下，与传统的桌面应用有所不同。
⚝ printf 系列函数 (printf, fprintf, sprintf, snprintf 等)：用于格式化输出。在 NDK 中，printf 及其变体默认输出到 logcat，可以通过 adb logcat 命令查看。fprintf 可以将输出重定向到文件，但需要注意 Android 的文件系统权限。
1
#include <stdio.h>
2
#include <android/log.h>
3
4
void printfExample() {
5
int value = 123;
6
printf("Value: %d\n", value); // 输出到 logcat
7
__android_log_print(ANDROID_LOG_INFO, "NDK_TAG", "Value from log: %d", value); // 使用 android log 输出
8
}
⚝ scanf 系列函数 (scanf, fscanf, sscanf 等)：用于格式化输入。在 NDK 中，从标准输入读取数据通常不常见，更常见的做法是从文件或网络接收数据。
⚝ 文件 I/O 函数 (fopen, fclose, fread, fwrite, fseek, fflush 等)：用于文件操作。NDK 支持标准的文件 I/O 操作，但需要注意 Android 的文件系统权限和路径问题。后续章节会详细介绍文件 I/O 操作。
③ 内存管理 (stdlib.h)
stdlib.h 头文件提供了一些通用的工具函数，包括内存管理、随机数生成、进程控制等。
⚝ malloc(size_t size)：动态分配 size 字节的内存，返回指向分配内存的指针。如果分配失败，返回 NULL。
⚝ calloc(size_t num, size_t size)：动态分配 num * size 字节的内存，并将分配的内存初始化为 0，返回指向分配内存的指针。如果分配失败，返回 NULL。
⚝ realloc(void *ptr, size_t size)：重新分配 ptr 指向的内存块的大小为 size 字节。如果 ptr 为 NULL，则相当于 malloc(size)。如果 size 为 0 且 ptr 不为 NULL，则相当于 free(ptr)。返回指向重新分配内存的指针，如果分配失败，返回 NULL，原内存块的数据可能会被复制到新的内存块。
⚝ free(void *ptr)：释放 malloc, calloc, 或 realloc 分配的内存。ptr 必须是指向由这些函数分配的内存块的指针，否则行为未定义。释放 NULL 指针是安全的，不会有任何操作。务必成对使用 malloc/calloc/realloc 和 free，避免内存泄漏。
1
#include <stdlib.h>
2
#include <android/log.h>
3
4
void memoryAllocationExample() {
5
int *ptr = (int*)malloc(sizeof(int) * 10); // 分配 10 个 int 的空间
6
if (ptr == NULL) {
7
__android_log_print(ANDROID_LOG_ERROR, "NDK_TAG", "Memory allocation failed!");
8
return;
9
}
10
11
for (int i = 0; i < 10; ++i) {
12
ptr[i] = i * 2;
13
}
14
15
for (int i = 0; i < 10; ++i) {
16
__android_log_print(ANDROID_LOG_INFO, "NDK_TAG", "Value at index %d: %d", i, ptr[i]);
17
}
18
19
free(ptr); // 释放内存
20
ptr = NULL; // 避免悬 dangling 指针
21
}
⚝ atoi, atol, atoll, atof: 将字符串转换为整数 (int, long, long long) 和浮点数 (double)。
⚝ rand, srand: 生成伪随机数。rand 生成一个 0 到 RAND_MAX 之间的伪随机整数。srand 用于设置随机数生成器的种子，通常使用当前时间作为种子，以获得不同的随机数序列。
④ 数学函数 (math.h)
math.h 头文件提供了各种数学函数，例如三角函数、指数函数、对数函数、幂函数等。
⚝ 三角函数：sin, cos, tan, asin, acos, atan, atan2 等。
⚝ 指数和对数函数：exp, log, log10, pow, sqrt 等。
⚝ 取整函数：ceil (向上取整), floor (向下取整), round (四舍五入), trunc (截断取整)。
⚝ 其他函数：fabs (绝对值), fmod (浮点数取余), modf (将浮点数分解为整数和小数部分) 等。
1
#include <math.h>
2
#include <android/log.h>
3
4
void mathFunctionExample() {
5
double angle = M_PI / 4.0; // 45 度角 (弧度)
6
double sinValue = sin(angle);
7
double cosValue = cos(angle);
8
double powerValue = pow(2.0, 3.0); // 2 的 3 次方
9
10
__android_log_print(ANDROID_LOG_INFO, "NDK_TAG", "sin(45 degrees): %f", sinValue);
11
__android_log_print(ANDROID_LOG_INFO, "NDK_TAG", "cos(45 degrees): %f", cosValue);
12
__android_log_print(ANDROID_LOG_INFO, "NDK_TAG", "2^3: %f", powerValue);
13
}
⑤ 时间函数 (time.h)
time.h 头文件提供了时间相关的函数。
⚝ time(time_t *timer)：获取当前日历时间，通常是从 Epoch (1970-01-01 00:00:00 UTC) 至今的秒数。如果 timer 不为 NULL，则时间值也会存储在 timer 指向的位置。
⚝ clock()：获取程序启动以来 CPU 消耗的时间，精度可能较低，且不同平台和编译器实现可能有所不同。
⚝ difftime(time_t time1, time_t time0)：计算两个 time_t 值之间的时间差，以秒为单位。
⚝ localtime(const time_t *timer), gmtime(const time_t *timer): 将 time_t 值转换为本地时间或 GMT/UTC 时间的结构体 tm。
⚝ mktime(struct tm *timeptr): 将 tm 结构体转换为 time_t 值。
⚝ strftime(char *s, size_t maxsize, const char *format, const struct tm *timeptr): 将 tm 结构体格式化为字符串。
1
#include <time.h>
2
#include <stdio.h>
3
#include <android/log.h>
4
5
void timeFunctionExample() {
6
time_t currentTime;
7
time(¤tTime); // 获取当前时间
8
9
struct tm *localTime = localtime(¤tTime); // 转换为本地时间
10
11
char buffer[80];
12
strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", localTime); // 格式化时间字符串
13
14
__android_log_print(ANDROID_LOG_INFO, "NDK_TAG", "Current local time: %s", buffer);
15
}
3.1.3 C++ 标准库的使用
在 NDK 项目中使用 C++ 标准库非常简单。只需要在 C++ 源文件中包含相应的头文件，并使用 std 命名空间即可。例如，使用 std::vector 和 std::string：
1
#include <vector>
2
#include <string>
3
#include <android/log.h>
4
5
void cppStdLibExample() {
6
std::vector<int> numbers;
7
numbers.push_back(10);
8
numbers.push_back(20);
9
numbers.push_back(30);
10
11
std::string message = "Numbers: ";
12
for (int number : numbers) {
13
message += std::to_string(number) + " ";
14
}
15
16
__android_log_print(ANDROID_LOG_INFO, "NDK_TAG", "%s", message.c_str());
17
}
在 CMakeLists.txt 或 Android.mk 文件中，确保你的项目配置为使用 C++ 编译器，并链接 C++ 标准库。对于 CMake，通常会自动处理。对于 ndk-build，可能需要在 Application.mk 中指定 APP_STL := c++_shared 或其他 C++ STL 实现。
3.1.4 注意事项与最佳实践
⚝ 选择合适的标准库实现：NDK 提供了多种 C++ 标准库实现 (libc++_shared, libc++_static, stlport_static, gnustl_static)。libc++_shared 是推荐的默认选项，它以动态链接库的形式提供，可以减小 APK 大小，并与其他使用 libc++_shared 的应用共享库。libc++_static 和其他静态库会将标准库代码静态链接到你的 native 库中，可能增大 APK 大小，但可以避免运行时库版本兼容性问题。
⚝ 了解 NDK 的标准库限制：虽然 NDK 提供了广泛的标准库支持，但并非完全 POSIX 兼容。某些高级或特定于操作系统的功能可能不可用或行为有所不同。在移植现有 C/C++ 代码时，需要进行适当的适配和测试。
⚝ 安全性和性能：在使用 C 标准库函数时，要注意安全问题，例如缓冲区溢出。尽量使用更安全的函数变体（如 strncpy, strncat, snprintf）或 C++ 的 std::string 等更安全的工具。同时，也要关注性能，避免不必要的内存分配和拷贝操作。
⚝ 查阅 NDK 文档：Android NDK 官方文档是了解 NDK 标准库支持情况的最权威来源。遇到问题时，应查阅官方文档，了解特定函数在 NDK 环境下的行为和限制。
本节介绍了 Android NDK 对 C/C++ 标准库的支持，并详细讲解了一些常用的 C 标准库函数。掌握这些基础知识是进行 NDK 开发的重要一步，能够帮助开发者更高效地构建高性能的 Android native 应用。在后续章节中，我们将继续深入探讨 NDK 的其他核心 API 和开发技术。
3.2 Android Log 系统：native 日志输出与调试技巧
在 Android 应用开发中，日志 (Log) 系统是不可或缺的调试和监控工具。通过输出日志，开发者可以了解程序的运行状态、追踪错误、分析性能瓶颈。Android 系统提供了完善的日志机制，允许 Java 层和 Native 层代码输出日志信息。本节将深入介绍 Android Log 系统在 NDK 开发中的应用，包括 native 日志输出方法、日志级别、过滤技巧以及调试实践。
3.2.1 Android Log 系统简介
Android Log 系统是一个集中式的日志管理框架，它收集来自系统组件、应用进程以及内核的日志信息，并提供统一的接口供开发者查看和分析。Android Log 系统主要由以下几个组件构成：
⚝ Log Buffer (日志缓冲区)：Android 系统维护了多个日志缓冲区，例如 main (主缓冲区，用于应用日志)、system (系统缓冲区，用于系统组件日志)、radio (无线缓冲区，用于无线通信日志)、events (事件缓冲区，用于系统事件日志)、crash (崩溃缓冲区，用于崩溃日志)。每个缓冲区以环形队列的方式存储日志记录，当缓冲区满时，新的日志会覆盖旧的日志。
⚝ logd (Log Daemon, 日志守护进程)：logd 是一个系统进程，负责从各个组件和进程收集日志信息，并将它们写入到相应的日志缓冲区。logd 进程运行在后台，持续监听来自不同来源的日志请求。
⚝ liblog (Log 库)：liblog 是一个共享库，提供了 C/C++ 接口用于向 Android Log 系统写入日志。NDK 开发中，我们主要使用 liblog 库提供的函数来输出 native 日志。
⚝ logcat (Log Cat, 日志查看工具)：logcat 是一个命令行工具，用于从 Android Log 系统读取和显示日志信息。开发者可以使用 adb logcat 命令在终端查看设备或模拟器上的日志。logcat 提供了丰富的过滤和格式化选项，方便开发者查找和分析日志。
3.2.2 Native 日志输出：__android_log_print
在 NDK 开发中，最常用的 native 日志输出函数是 __android_log_print，它定义在 <android/log.h> 头文件中。使用 __android_log_print 可以将格式化的日志信息写入到 Android Log 系统。
__android_log_print 函数的原型如下：
1
int __android_log_print(int prio, const char *tag, const char *fmt, ...);
⚝ prio (Priority, 优先级/日志级别)：指定日志的优先级，即日志级别。Android Log 系统定义了多个日志级别，用于区分日志的重要性。常用的日志级别包括：
▮▮▮▮⚝ ANDROID_LOG_VERBOSE (Verbose, 详细)：最低优先级，用于输出最详细的调试信息，通常在开发阶段使用。
▮▮▮▮⚝ ANDROID_LOG_DEBUG (Debug, 调试)：用于输出调试信息，比 Verbose 级别稍高，也常用于开发阶段。
▮▮▮▮⚝ ANDROID_LOG_INFO (Info, 信息)：用于输出一般性的信息，例如程序运行状态、重要事件等。
▮▮▮▮⚝ ANDROID_LOG_WARN (Warn, 警告)：用于输出警告信息，表示可能存在潜在问题，但不影响程序正常运行。
▮▮▮▮⚝ ANDROID_LOG_ERROR (Error, 错误)：用于输出错误信息，表示程序发生了错误，可能影响部分功能或导致程序崩溃。
▮▮▮▮⚝ ANDROID_LOG_FATAL (Fatal, 致命)：最高优先级，用于输出致命错误信息，通常表示程序即将崩溃或无法继续运行。
▮▮▮▮⚝ ANDROID_LOG_SILENT (Silent, 静默)：最高优先级，用于屏蔽所有日志输出。
▮▮▮▮日志级别从低到高依次为：VERBOSE < DEBUG < INFO < WARN < ERROR < FATAL < SILENT。在 logcat 中，日志级别通常用首字母缩写表示：V, D, I, W, E, F, S。
⚝ tag (Tag, 标签)：指定日志的标签，用于标识日志的来源模块或组件。标签通常是一个简短的字符串，方便在 logcat 中过滤和查找特定模块的日志。建议为每个模块或类定义一个唯一的标签。
⚝ fmt (Format, 格式化字符串)：类似于 printf 函数的格式化字符串，用于指定日志信息的格式。可以使用 %d, %f, %s, %p 等格式化占位符，并传递相应的参数。
⚝ ... (Variable arguments, 可变参数)：与格式化字符串 fmt 对应的可变参数列表，用于填充格式化占位符。
使用示例：
1
#include <android/log.h>
2
3
#define TAG "MyNDKApp" // 定义日志标签
4
5
void logExample() {
6
int value = 123;
7
float floatValue = 3.14f;
8
const char* message = "Hello from NDK!";
9
10
__android_log_print(ANDROID_LOG_VERBOSE, TAG, "Verbose log: value=%d, floatValue=%.2f, message=%s", value, floatValue, message);
11
__android_log_print(ANDROID_LOG_DEBUG, TAG, "Debug log: value=%d", value);
12
__android_log_print(ANDROID_LOG_INFO, TAG, "Info log: message=%s", message);
13
__android_log_print(ANDROID_LOG_WARN, TAG, "Warning log: floatValue=%.2f", floatValue);
14
__android_log_print(ANDROID_LOG_ERROR, TAG, "Error log: value=%d, message=%s", value, message);
15
__android_log_print(ANDROID_LOG_FATAL, TAG, "Fatal log: Program is about to crash!");
16
}
编译和链接 liblog 库：
在使用 __android_log_print 函数之前，需要在 NDK 项目中链接 liblog 库。
⚝ CMake: 在 CMakeLists.txt 文件中，使用 target_link_libraries 命令链接 log 库：
1
target_link_libraries(your-native-lib log)
⚝ ndk-build: 在 Android.mk 文件中，使用 LOCAL_LDLIBS 变量链接 log 库：
1
LOCAL_LDLIBS := -llog
3.2.3 logcat 日志查看与过滤
使用 adb logcat 命令可以查看 Android 设备的日志信息。在终端中执行 adb logcat 命令后，logcat 会持续输出实时的日志信息。
基本用法：
⚝ adb logcat: 显示所有日志缓冲区 (main, system, radio, events, crash) 的日志信息。
⚝ adb logcat -b <buffer>: 指定要查看的日志缓冲区，例如 adb logcat -b main 只显示主缓冲区的日志。常用的缓冲区包括 main, system, radio, events, crash。
⚝ adb logcat -c: 清空所有日志缓冲区。
⚝ adb logcat -d: 将当前日志缓冲区的内容转储到终端并退出，不会持续监听新的日志。
⚝ adb logcat -f <filename>: 将日志输出到文件，例如 adb logcat -f log.txt 将日志保存到 log.txt 文件。
日志过滤：
logcat 提供了强大的日志过滤功能，可以根据日志级别、标签、进程 ID (PID)、应用包名等条件过滤日志，只显示关心的日志信息。
⚝ 按日志级别过滤: 使用 级别:标签 的格式指定要显示的最低日志级别和标签。例如，adb logcat *:W 显示所有标签的 Warning 及以上级别的日志。adb logcat MyNDKApp:D *:S 显示标签为 MyNDKApp 的 Debug 及以上级别的日志，以及其他所有标签的 Silent 级别日志（即屏蔽其他标签的日志）。
▮▮▮▮常用的日志级别过滤器：
▮▮▮▮⚝ V: Verbose
▮▮▮▮⚝ D: Debug
▮▮▮▮⚝ I: Info
▮▮▮▮⚝ W: Warn
▮▮▮▮⚝ E: Error
▮▮▮▮⚝ F: Fatal
▮▮▮▮⚝ S: Silent (屏蔽所有日志)
▮▮▮▮例如：
▮▮▮▮⚝ adb logcat *:V: 显示所有级别的日志 (Verbose 及以上)。
▮▮▮▮⚝ adb logcat *:D: 显示 Debug 及以上级别的日志。
▮▮▮▮⚝ adb logcat *:I: 显示 Info 及以上级别的日志 (常用)。
▮▮▮▮⚝ adb logcat *:W: 显示 Warning 及以上级别的日志。
▮▮▮▮⚝ adb logcat *:E: 显示 Error 及以上级别的日志。
▮▮▮▮⚝ adb logcat *:F: 显示 Fatal 及以上级别的日志。
⚝ 按标签过滤: 使用 标签:级别 的格式指定要过滤的标签和最低日志级别。例如，adb logcat MyNDKApp:V 只显示标签为 MyNDKApp 的 Verbose 及以上级别的日志。
▮▮▮▮例如：
▮▮▮▮⚝ adb logcat MyNDKApp:V *:S: 只显示标签为 MyNDKApp 的所有日志。
▮▮▮▮⚝ adb logcat MyNDKApp:D *:S: 只显示标签为 MyNDKApp 的 Debug 及以上级别的日志。
▮▮▮▮⚝ adb logcat MyNDKApp:I *:S: 只显示标签为 MyNDKApp 的 Info 及以上级别的日志 (常用)。
⚝ 组合过滤: 可以组合多个过滤条件，例如 adb logcat MyNDKApp:D System.err:W *:S 显示标签为 MyNDKApp 的 Debug 及以上级别的日志，以及标签为 System.err 的 Warning 及以上级别的日志，并屏蔽其他所有标签的日志。
⚝ 使用正则表达式过滤: logcat 支持使用正则表达式进行更复杂的过滤。可以使用 grep 命令结合 logcat 进行正则表达式过滤，例如 adb logcat | grep "error\|exception" 查找包含 "error" 或 "exception" 关键词的日志。
日志格式化：
logcat 允许自定义日志输出格式，使用 -v <format> 选项指定格式。常用的格式选项包括：
⚝ brief: 默认格式，显示优先级/标签(PID:TID)/消息。
⚝ process: 显示进程/优先级/标签/消息。
⚝ tag: 只显示优先级/标签: 消息。
⚝ raw: 只显示原始日志消息，没有其他元数据。
⚝ time: 显示日期/时间/优先级/标签(PID:TID)/消息。
⚝ threadtime: 显示日期/时间/线程ID/优先级/标签/消息 (常用)。
⚝ long: 显示所有元数据字段和消息，格式最详细。
例如，adb logcat -v threadtime 使用 threadtime 格式显示日志。
3.2.4 NDK 日志调试技巧与最佳实践
⚝ 选择合适的日志级别: 根据日志的重要性选择合适的日志级别。Verbose 和 Debug 级别用于开发调试阶段，Info 级别用于记录程序运行状态，Warn 和 Error 级别用于报告潜在问题和错误，Fatal 级别用于记录致命错误。在发布版本中，通常应关闭 Verbose 和 Debug 级别的日志，只保留 Info, Warn, Error, Fatal 级别的日志，以减少性能开销和日志输出量。可以通过条件编译或宏定义来控制不同日志级别的输出。
⚝ 使用清晰的日志标签: 为每个模块或类定义一个唯一的日志标签，方便在 logcat 中过滤和查找日志。标签应具有描述性，能够清晰地标识日志的来源。
⚝ 格式化日志信息: 使用格式化字符串输出结构化的日志信息，方便阅读和分析。例如，输出关键变量的值、函数参数、错误码等。
⚝ 避免在性能敏感代码中输出大量日志: 日志输出会带来一定的性能开销，尤其是在高频率调用的代码路径中。在性能敏感的代码中，应尽量减少日志输出，或者只输出必要的关键日志。可以使用条件编译或宏定义来控制日志输出，在调试版本中启用详细日志，在发布版本中关闭或减少日志输出。
⚝ 使用 logcat 过滤和分析日志: 熟练掌握 logcat 的过滤和格式化选项，可以高效地查找和分析日志信息。根据日志级别、标签、关键词等条件过滤日志，快速定位问题。
⚝ 结合 Android Studio Logcat 工具: Android Studio 集成了 Logcat 工具，提供了图形化的日志查看界面，支持日志过滤、格式化、搜索等功能，更加方便易用。可以在 Android Studio 中直接查看和分析设备或模拟器的日志。
⚝ 使用日志进行错误追踪和性能分析: 在程序出现错误或异常时，通过查看日志信息，可以追踪错误发生的上下文和原因。在性能分析时，可以在关键代码段添加日志输出，记录执行时间、资源消耗等信息，帮助分析性能瓶颈。
⚝ 注意日志安全性: 避免在日志中输出敏感信息，例如用户密码、密钥、个人身份信息等，防止信息泄露。
Android Log 系统是 NDK 开发中重要的调试和监控工具。熟练掌握 native 日志输出方法和 logcat 日志查看技巧，可以有效地提高开发效率，快速定位和解决问题，构建高质量的 Android native 应用。
3.3 文件 I/O 操作：native 层的安全高效文件访问
在 Android 应用开发中，文件 I/O (Input/Output) 操作是常见的需求，例如读取配置文件、保存用户数据、加载资源文件等。在 NDK 开发中，native 层代码同样需要进行文件 I/O 操作。然而，Android 平台的文件系统具有一定的特殊性，例如权限管理、存储位置限制等。本节将深入探讨 NDK native 层的文件 I/O 操作，重点关注安全性和效率，并介绍如何在 native 层安全高效地访问文件。
3.3.1 Android 文件系统概述
Android 基于 Linux 内核，其文件系统结构也继承了 Linux 的特点。然而，为了安全性和资源管理，Android 对应用的文件访问权限和存储位置做了一些限制。
⚝ 应用沙箱 (Application Sandbox)：每个 Android 应用都运行在独立的沙箱环境中，拥有独立的用户 ID 和进程 ID。应用只能访问自身沙箱目录下的文件，以及被明确授予权限的外部存储空间。应用无法直接访问其他应用的沙箱目录，保证了应用之间的隔离性和安全性。
⚝ 内部存储 (Internal Storage)：每个应用在内部存储中都有一个私有目录，位于 /data/data/<package_name>/ 目录下。应用可以自由读写内部存储目录下的文件，无需申请任何权限。内部存储的文件对其他应用是不可见的，除非通过 Content Provider 等机制共享。内部存储空间有限，通常用于存储应用的私有数据、配置文件等。
⚝ 外部存储 (External Storage)：外部存储通常指 SD 卡或模拟的外部存储空间，例如 /sdcard/ 或 /storage/emulated/0/ 目录。外部存储空间较大，可以存储大量的媒体文件、下载文件等。从 Android 4.4 (API Level 19) 开始，外部存储分为公共外部存储 (Public External Storage) 和私有外部存储 (Private External Storage)。
▮▮▮▮⚝ 公共外部存储: 指外部存储中不属于任何特定应用的目录，例如 Download, Pictures, Music, Movies 等目录。应用可以访问公共外部存储中的文件，但需要申请相应的存储权限 (例如 READ_EXTERNAL_STORAGE, WRITE_EXTERNAL_STORAGE)。从 Android 10 (API Level 29) 开始，默认启用分区存储 (Scoped Storage)，应用只能访问自身创建的公共外部存储文件，以及用户通过 Storage Access Framework 选择的文件。
▮▮▮▮⚝ 私有外部存储: 指位于外部存储中，应用包名目录下的私有目录，例如 /sdcard/Android/data/<package_name>/files/ 和 /sdcard/Android/data/<package_name>/cache/ 目录。应用可以自由读写私有外部存储目录下的文件，无需申请存储权限。私有外部存储的文件在应用卸载时会被删除。
⚝ 文件访问权限: Android 使用 Linux 的文件权限机制 (User, Group, Others) 管理文件访问权限。应用进程通常以应用的用户 ID 运行，只能访问自身用户 ID 或组 ID 拥有的文件，以及 Others 可访问的文件。对于外部存储，Android 通过权限系统和 MediaStore API 进行更细粒度的访问控制。
3.3.2 Native 文件 I/O API
在 NDK native 层，可以使用标准的 C/C++ 文件 I/O API 进行文件操作，例如 fopen, fclose, fread, fwrite, fprintf, fscanf, fseek, fflush 等，这些函数定义在 <stdio.h> 头文件中。
常用文件 I/O 函数：
⚝ fopen(const char *pathname, const char *mode): 打开文件，返回文件指针 FILE*。pathname 是文件路径，mode 是打开模式，例如 "r" (只读), "w" (只写，覆盖), "a" (追加), "rb" (二进制只读), "wb" (二进制只写) 等。如果打开失败，返回 NULL。
⚝ fclose(FILE *stream): 关闭文件，释放文件资源。stream 是 fopen 返回的文件指针。
⚝ fread(void *ptr, size_t size, size_t count, FILE *stream): 从文件中读取数据。ptr 是数据缓冲区指针，size 是每个数据项的大小，count 是要读取的数据项数量，stream 是文件指针。返回实际读取的数据项数量。
⚝ fwrite(const void *ptr, size_t size, size_t count, FILE *stream): 向文件中写入数据。参数含义与 fread 类似。返回实际写入的数据项数量。
⚝ fprintf(FILE *stream, const char *format, ...): 格式化输出到文件，类似于 printf，但输出到指定的文件流 stream。
⚝ fscanf(FILE *stream, const char *format, ...): 从文件中格式化读取数据，类似于 scanf，但从指定的文件流 stream 读取。
⚝ fseek(FILE *stream, long offset, int whence): 移动文件指针到指定位置。offset 是偏移量，whence 是起始位置，可以是 SEEK_SET (文件开头), SEEK_CUR (当前位置), SEEK_END (文件末尾)。
⚝ fflush(FILE *stream): 刷新文件缓冲区，将缓冲区中的数据写入到磁盘。
文件路径获取：
在 native 层进行文件 I/O 操作，首先需要获取正确的文件路径。对于内部存储和私有外部存储，可以使用 Java 层 Context 对象的方法获取文件路径，并通过 JNI 传递给 native 层。
⚝ 内部存储路径: 可以使用 Context.getFilesDir() 或 Context.getCacheDir() 获取内部存储的文件目录和缓存目录路径。
⚝ 私有外部存储路径: 可以使用 Context.getExternalFilesDir(String type) 或 Context.getExternalCacheDir() 获取私有外部存储的文件目录和缓存目录路径。type 参数可以指定文件类型，例如 Environment.DIRECTORY_PICTURES, Environment.DIRECTORY_MUSIC 等，也可以为 null 表示根目录。
示例代码 (Java 层获取文件路径并传递给 Native 层):
1
// Java 代码
2
public class MyJNIClass {
3
static {
4
System.loadLibrary("my-native-lib");
5
}
6
7
public native void nativeFileIO(String internalFilePath, String externalFilePath);
8
9
public void performFileIO(Context context) {
10
String internalDir = context.getFilesDir().getAbsolutePath();
11
String externalDir = context.getExternalFilesDir(null).getAbsolutePath();
12
nativeFileIO(internalDir, externalDir);
13
}
14
}
1
// Native 代码 (C++)
2
#include <stdio.h>
3
#include <string>
4
#include <android/log.h>
5
6
#define TAG "NativeFileIO"
7
8
extern "C" JNIEXPORT void JNICALL
9
Java_com_example_myapp_MyJNIClass_nativeFileIO(JNIEnv *env, jobject /* this */, jstring internalFilePath, jstring externalFilePath) {
10
const char *internalPath = env->GetStringUTFChars(internalFilePath, nullptr);
11
const char *externalPath = env->GetStringUTFChars(externalFilePath, nullptr);
12
13
// 内部存储文件操作
14
std::string internalFileName = std::string(internalPath) + "/my_internal_file.txt";
15
FILE *internalFile = fopen(internalFileName.c_str(), "w");
16
if (internalFile) {
17
fprintf(internalFile, "Hello from internal storage!\n");
18
fclose(internalFile);
19
__android_log_print(ANDROID_LOG_INFO, TAG, "Successfully wrote to internal file: %s", internalFileName.c_str());
20
} else {
21
__android_log_print(ANDROID_LOG_ERROR, TAG, "Failed to open internal file: %s", internalFileName.c_str());
22
}
23
24
// 私有外部存储文件操作
25
std::string externalFileName = std::string(externalPath) + "/my_external_file.txt";
26
FILE *externalFile = fopen(externalFileName.c_str(), "w");
27
if (externalFile) {
28
fprintf(externalFile, "Hello from external storage!\n");
29
fclose(externalFile);
30
__android_log_print(ANDROID_LOG_INFO, TAG, "Successfully wrote to external file: %s", externalFileName.c_str());
31
} else {
32
__android_log_print(ANDROID_LOG_ERROR, TAG, "Failed to open external file: %s", externalFileName.c_str());
33
}
34
35
env->ReleaseStringUTFChars(internalFilePath, internalPath);
36
env->ReleaseStringUTFChars(externalFilePath, externalPath);
37
}
3.3.3 文件 I/O 安全性与最佳实践
⚝ 文件路径安全: 避免硬编码文件路径，应使用 Context API 获取应用的文件目录路径。防止路径遍历漏洞，不要接受用户输入的文件路径直接进行文件操作。
⚝ 权限管理: 对于公共外部存储，需要在 AndroidManifest.xml 文件中声明存储权限 (READ_EXTERNAL_STORAGE, WRITE_EXTERNAL_STORAGE)，并在运行时动态申请权限 (Android 6.0 及以上)。对于内部存储和私有外部存储，无需申请权限。
⚝ 文件访问模式: 根据文件操作的需求选择合适的文件打开模式 ("r", "w", "a", "rb", "wb" 等)。只读操作使用 "r" 或 "rb" 模式，避免误写入。写入操作根据需求选择 "w" (覆盖) 或 "a" (追加) 模式。
⚝ 错误处理: 检查文件操作的返回值，例如 fopen 的返回值是否为 NULL，fread 和 fwrite 的返回值是否与预期的数据项数量一致。及时处理文件操作错误，例如文件不存在、权限不足、磁盘空间不足等。
⚝ 资源释放: 在文件操作完成后，务必使用 fclose 关闭文件，释放文件资源。可以使用 RAII (Resource Acquisition Is Initialization) 机制，例如 C++ 的 std::fstream 或自定义的文件操作类，在对象析构时自动关闭文件，避免资源泄漏。
⚝ 缓冲区管理: 文件 I/O 操作通常涉及缓冲区。fflush 函数可以刷新文件缓冲区，确保数据及时写入磁盘。在写入重要数据后，应调用 fflush 确保数据持久化。
⚝ 性能优化: 文件 I/O 操作通常是耗时操作。应尽量减少文件 I/O 操作的次数和数据量。可以使用缓冲 I/O、内存映射文件等技术提高文件 I/O 性能。对于小文件，可以考虑一次性读取到内存中处理。对于大文件，可以分块读取和处理。
⚝ 异步 I/O: 对于耗时的文件 I/O 操作，应避免在主线程 (UI 线程) 中执行，防止阻塞 UI 线程，导致应用卡顿。可以使用异步任务、线程池等机制，在后台线程中执行文件 I/O 操作。
⚝ 数据格式: 选择合适的数据格式存储文件数据，例如文本文件、JSON、Protocol Buffers 等。根据数据结构和访问模式选择高效的数据格式。对于二进制数据，使用二进制文件读写，效率更高。
⚝ 文件加密: 对于敏感数据，可以考虑对文件进行加密存储，例如使用 OpenSSL 等加密库对文件内容进行加密，提高数据安全性。
3.3.4 Android Storage Access Framework (SAF)
对于公共外部存储的文件访问，Android 推荐使用 Storage Access Framework (SAF)。SAF 提供了一种统一的方式，让用户选择文件或目录，并授予应用访问权限。使用 SAF 可以提高用户体验和数据安全性，并更好地适应 Android 分区存储的限制。
SAF 主要涉及以下组件：
⚝ ACTION_OPEN_DOCUMENT 和 ACTION_CREATE_DOCUMENT Intent: 用于启动文件选择器，让用户选择已有的文件或创建新的文件。
⚝ DocumentFile 类: 用于表示 SAF 返回的文件或目录，提供了文件操作的抽象接口。
⚝ ContentResolver 类: 用于通过 Content Provider 访问 SAF 返回的文件内容。
在 NDK native 层，可以通过 JNI 调用 Java 层的 SAF API，获取 SAF 返回的文件 URI，并通过 ContentResolver 读取文件内容。SAF 的使用相对复杂，但对于公共外部存储的文件访问，是更加安全和推荐的方式。
本节介绍了 NDK native 层的文件 I/O 操作，重点关注了 Android 文件系统的特性、native 文件 I/O API 的使用、文件 I/O 的安全性和最佳实践。掌握这些知识，可以帮助开发者在 NDK 开发中安全高效地进行文件操作，构建功能完善的 Android native 应用。
3.4 网络编程：Socket 通信在 NDK 中的应用
网络编程是现代应用开发的重要组成部分。Android 应用经常需要与服务器进行网络通信，获取数据、上传文件、进行实时交互等。在 NDK 开发中，native 层代码同样可以进行网络编程，实现高性能的网络通信功能。本节将介绍如何在 NDK native 层使用 Socket API 进行网络编程，实现 TCP 和 UDP 通信。
3.4.1 Socket 编程基础
Socket (套接字) 是网络编程的基本概念，它是网络通信的端点，用于在不同主机之间或同一主机不同进程之间进行数据交换。Socket 提供了一组 API，允许应用程序创建网络连接、发送和接收数据。
Socket 通信通常基于客户端-服务器 (Client-Server) 模式。服务器端监听指定的端口，等待客户端连接请求。客户端发起连接请求，与服务器建立连接后，双方可以进行数据交换。
Socket 通信协议主要有两种：
⚝ TCP (Transmission Control Protocol, 传输控制协议)：面向连接的、可靠的、基于字节流的协议。TCP 提供可靠的数据传输，保证数据按序到达，并且具有拥塞控制和流量控制机制。TCP 适用于需要可靠数据传输的应用，例如文件传输、网页浏览、邮件传输等。
⚝ UDP (User Datagram Protocol, 用户数据报协议)：无连接的、不可靠的、基于数据报的协议。UDP 不保证数据可靠传输，不保证数据按序到达，但具有较低的延迟和较高的传输效率。UDP 适用于对实时性要求较高，但对数据可靠性要求相对较低的应用，例如音视频流传输、在线游戏、DNS 查询等。
3.4.2 NDK Socket API
NDK 提供了标准的 BSD Socket API，定义在 <sys/socket.h> 和 <netinet/in.h> 等头文件中。NDK Socket API 与 Linux 系统上的 Socket API 基本一致，开发者可以使用熟悉的 Socket 函数进行网络编程。
常用 Socket API 函数：
⚝ socket(int domain, int type, int protocol): 创建一个 Socket。
▮▮▮▮⚝ domain (域)：指定协议族，常用的有 AF_INET (IPv4), AF_INET6 (IPv6), AF_UNIX (本地 Socket)。
▮▮▮▮⚝ type (类型)：指定 Socket 类型，常用的有 SOCK_STREAM (TCP), SOCK_DGRAM (UDP), SOCK_RAW (原始 Socket)。
▮▮▮▮⚝ protocol (协议)：指定协议，通常设置为 0，由系统根据 domain 和 type 自动选择协议。
▮▮▮▮返回 Socket 文件描述符 (file descriptor)，如果创建失败，返回 -1。
⚝ bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen): 将 Socket 绑定到指定的地址和端口。
▮▮▮▮⚝ sockfd (Socket 文件描述符)：socket 函数返回的 Socket 文件描述符。
▮▮▮▮⚝ addr (地址结构体指针)：指向地址结构体 sockaddr 的指针，需要根据 domain 类型转换为 sockaddr_in (IPv4) 或 sockaddr_in6 (IPv6)。
▮▮▮▮⚝ addrlen (地址结构体长度)：地址结构体的长度，通常为 sizeof(struct sockaddr_in) 或 sizeof(struct sockaddr_in6)。
▮▮▮▮返回 0 表示成功，返回 -1 表示失败。
⚝ listen(int sockfd, int backlog): 将 Socket 设置为监听状态，等待客户端连接。
▮▮▮▮⚝ sockfd (Socket 文件描述符)：监听 Socket 的文件描述符。
▮▮▮▮⚝ backlog (backlog 队列长度)：指定等待连接队列的最大长度。当有多个客户端同时发起连接请求时，超过 backlog 队列长度的连接请求会被拒绝。
▮▮▮▮返回 0 表示成功，返回 -1 表示失败。
⚝ accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen): 接受客户端连接请求，创建一个新的 Socket 用于与客户端通信。
▮▮▮▮⚝ sockfd (Socket 文件描述符)：监听 Socket 的文件描述符。
▮▮▮▮⚝ addr (地址结构体指针)：用于接收客户端地址信息的地址结构体指针。可以为 NULL。
▮▮▮▮⚝ addrlen (地址结构体长度指针)：指向地址结构体长度的指针。可以为 NULL。
▮▮▮▮返回新的 Socket 文件描述符，用于与客户端通信。如果接受连接失败，返回 -1。
⚝ connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen): 客户端发起连接请求，连接到服务器。
▮▮▮▮⚝ sockfd (Socket 文件描述符)：客户端 Socket 的文件描述符。
▮▮▮▮⚝ addr (地址结构体指针)：服务器地址结构体指针。
▮▮▮▮⚝ addrlen (地址结构体长度)：服务器地址结构体长度。
▮▮▮▮返回 0 表示连接成功，返回 -1 表示连接失败。
⚝ send(int sockfd, const void *buf, size_t len, int flags): 通过 Socket 发送数据。
▮▮▮▮⚝ sockfd (Socket 文件描述符)：已连接的 Socket 文件描述符。
▮▮▮▮⚝ buf (数据缓冲区指针)：指向要发送数据的缓冲区指针。
▮▮▮▮⚝ len (数据长度)：要发送的数据长度。
▮▮▮▮⚝ flags (标志)：控制发送行为的标志，通常设置为 0。
▮▮▮▮返回实际发送的字节数，如果发送失败，返回 -1。
⚝ recv(int sockfd, void *buf, size_t len, int flags): 通过 Socket 接收数据。
▮▮▮▮⚝ sockfd (Socket 文件描述符)：已连接的 Socket 文件描述符。
▮▮▮▮⚝ buf (数据缓冲区指针)：用于接收数据的缓冲区指针。
▮▮▮▮⚝ len (缓冲区长度)：缓冲区的大小。
▮▮▮▮⚝ flags (标志)：控制接收行为的标志，通常设置为 0。
▮▮▮▮返回实际接收的字节数，如果接收失败或连接关闭，返回 -1 或 0。
⚝ close(int fd): 关闭 Socket 文件描述符，释放 Socket 资源。
⚝ getaddrinfo(const char *hostname, const char *servname, const struct addrinfo *hints, struct addrinfo **res): 将主机名或域名转换为 IP 地址。
▮▮▮▮⚝ hostname (主机名或域名)：例如 "www.example.com" 或 "192.168.1.100"。
▮▮▮▮⚝ servname (服务名或端口号)：例如 "http" 或 "80"。
▮▮▮▮⚝ hints (地址信息提示结构体指针)：用于提供地址信息提示，可以为 NULL。
▮▮▮▮⚝ res (地址信息结构体指针的指针)：用于接收转换结果的地址信息结构体链表。
▮▮▮▮返回 0 表示成功，返回非 0 值表示失败。
⚝ freeaddrinfo(struct addrinfo *res): 释放 getaddrinfo 返回的地址信息结构体链表。
地址结构体：
⚝ struct sockaddr: 通用的地址结构体，用于表示 Socket 地址。
⚝ struct sockaddr_in: IPv4 地址结构体，定义在 <netinet/in.h> 中。
1
struct sockaddr_in {
2
sa_family_t sin_family; /* address family: AF_INET */
3
in_port_t sin_port; /* port in network byte order */
4
struct in_addr sin_addr; /* internet address */
5
char sin_zero[8]; /* padding to make size of sockaddr_in same as sockaddr */
6
};
⚝ struct in_addr: IPv4 地址结构体，定义在 <netinet/in.h> 中。
1
struct in_addr {
2
in_addr_t s_addr; /* address in network byte order */
3
};
⚝ struct sockaddr_in6: IPv6 地址结构体，定义在 <netinet/in.h> 中。
3.4.3 TCP Socket 通信示例 (客户端)
1
#include <sys/socket.h>
2
#include <netinet/in.h>
3
#include <arpa/inet.h>
4
#include <unistd.h>
5
#include <string.h>
6
#include <android/log.h>
7
8
#define TAG "TCPSocketClient"
9
#define SERVER_IP "127.0.0.1" // 服务器 IP 地址
10
#define SERVER_PORT 8888 // 服务器端口号
11
12
void tcpClientExample() {
13
int clientSocket = socket(AF_INET, SOCK_STREAM, 0);
14
if (clientSocket == -1) {
15
__android_log_print(ANDROID_LOG_ERROR, TAG, "Failed to create socket: %s", strerror(errno));
16
return;
17
}
18
19
struct sockaddr_in serverAddr;
20
memset(&serverAddr, 0, sizeof(serverAddr));
21
serverAddr.sin_family = AF_INET;
22
serverAddr.sin_port = htons(SERVER_PORT); // 端口号需要转换为网络字节序
23
if (inet_pton(AF_INET, SERVER_IP, &serverAddr.sin_addr) <= 0) { // IP 地址字符串转换为网络字节序
24
__android_log_print(ANDROID_LOG_ERROR, TAG, "Invalid server IP address: %s", SERVER_IP);
25
close(clientSocket);
26
return;
27
}
28
29
if (connect(clientSocket, (struct sockaddr *)&serverAddr, sizeof(serverAddr)) == -1) {
30
__android_log_print(ANDROID_LOG_ERROR, TAG, "Failed to connect to server: %s", strerror(errno));
31
close(clientSocket);
32
return;
33
}
34
35
const char *message = "Hello from TCP client!";
36
ssize_t bytesSent = send(clientSocket, message, strlen(message), 0);
37
if (bytesSent == -1) {
38
__android_log_print(ANDROID_LOG_ERROR, TAG, "Failed to send data: %s", strerror(errno));
39
} else {
40
__android_log_print(ANDROID_LOG_INFO, TAG, "Sent data to server: %s, bytes=%zd", message, bytesSent);
41
}
42
43
char buffer[1024];
44
ssize_t bytesReceived = recv(clientSocket, buffer, sizeof(buffer) - 1, 0);
45
if (bytesReceived == -1) {
46
__android_log_print(ANDROID_LOG_ERROR, TAG, "Failed to receive data: %s", strerror(errno));
47
} else if (bytesReceived == 0) {
48
__android_log_print(ANDROID_LOG_INFO, TAG, "Server closed connection.");
49
} else {
50
buffer[bytesReceived] = '\0'; // 添加字符串结束符
51
__android_log_print(ANDROID_LOG_INFO, TAG, "Received data from server: %s, bytes=%zd", buffer, bytesReceived);
52
}
53
54
close(clientSocket);
55
}
编译和链接 Socket 库：
在使用 Socket API 之前，需要在 NDK 项目中链接 Socket 库。
⚝ CMake: 在 CMakeLists.txt 文件中，使用 target_link_libraries 命令链接 android 库 (其中包含了 Socket 库)：
1
target_link_libraries(your-native-lib android)
⚝ ndk-build: 在 Android.mk 文件中，使用 LOCAL_LDLIBS 变量链接 android 库：
1
LOCAL_LDLIBS := -landroid
3.4.4 UDP Socket 通信示例 (客户端)
1
#include <sys/socket.h>
2
#include <netinet/in.h>
3
#include <arpa/inet.h>
4
#include <unistd.h>
5
#include <string.h>
6
#include <android/log.h>
7
8
#define TAG "UDPSocketClient"
9
#define SERVER_IP "127.0.0.1" // 服务器 IP 地址
10
#define SERVER_PORT 8888 // 服务器端口号
11
12
void udpClientExample() {
13
int clientSocket = socket(AF_INET, SOCK_DGRAM, 0);
14
if (clientSocket == -1) {
15
__android_log_print(ANDROID_LOG_ERROR, TAG, "Failed to create socket: %s", strerror(errno));
16
return;
17
}
18
19
struct sockaddr_in serverAddr;
20
memset(&serverAddr, 0, sizeof(serverAddr));
21
serverAddr.sin_family = AF_INET;
22
serverAddr.sin_port = htons(SERVER_PORT);
23
if (inet_pton(AF_INET, SERVER_IP, &serverAddr.sin_addr) <= 0) {
24
__android_log_print(ANDROID_LOG_ERROR, TAG, "Invalid server IP address: %s", SERVER_IP);
25
close(clientSocket);
26
return;
27
}
28
29
const char *message = "Hello from UDP client!";
30
ssize_t bytesSent = sendto(clientSocket, message, strlen(message), 0, (struct sockaddr *)&serverAddr, sizeof(serverAddr));
31
if (bytesSent == -1) {
32
__android_log_print(ANDROID_LOG_ERROR, TAG, "Failed to send data: %s", strerror(errno));
33
} else {
34
__android_log_print(ANDROID_LOG_INFO, TAG, "Sent data to server: %s, bytes=%zd", message, bytesSent);
35
}
36
37
char buffer[1024];
38
struct sockaddr_in senderAddr;
39
socklen_t senderAddrLen = sizeof(senderAddr);
40
ssize_t bytesReceived = recvfrom(clientSocket, buffer, sizeof(buffer) - 1, 0, (struct sockaddr *)&senderAddr, &senderAddrLen);
41
if (bytesReceived == -1) {
42
__android_log_print(ANDROID_LOG_ERROR, TAG, "Failed to receive data: %s", strerror(errno));
43
} else {
44
buffer[bytesReceived] = '\0';
45
__android_log_print(ANDROID_LOG_INFO, TAG, "Received data from server: %s, bytes=%zd, from IP: %s, port: %d",
46
buffer, bytesReceived, inet_ntoa(senderAddr.sin_addr), ntohs(senderAddr.sin_port));
47
}
48
49
close(clientSocket);
50
}
3.4.5 网络编程注意事项与最佳实践
⚝ 权限声明: Android 应用需要声明 INTERNET 权限才能进行网络通信。在 AndroidManifest.xml 文件中添加 <uses-permission android:name="android.permission.INTERNET" /> 声明。
⚝ 网络操作在后台线程: 网络操作通常是耗时操作，应避免在主线程 (UI 线程) 中执行，防止阻塞 UI 线程，导致应用卡顿。可以使用异步任务、线程池等机制，在后台线程中执行网络操作。
⚝ 错误处理: 网络编程中可能出现各种错误，例如连接失败、数据发送失败、数据接收失败、网络超时等。需要完善的错误处理机制，捕获并处理 Socket API 返回的错误码，例如使用 strerror(errno) 获取错误描述信息。
⚝ 字节序转换: 网络传输中，多字节数据 (例如端口号、IP 地址) 需要转换为网络字节序 (大端字节序)。使用 htons (host to network short), htonl (host to network long), ntohs (network to host short), ntohl (network to host long) 等函数进行字节序转换。
⚝ 地址转换: IP 地址通常以点分十进制字符串形式表示 (例如 "192.168.1.100")。需要使用 inet_pton 函数将 IP 地址字符串转换为网络字节序的二进制形式，使用 inet_ntoa 函数将网络字节序的二进制 IP 地址转换为点分十进制字符串形式。
⚝ Socket 超时设置: 可以设置 Socket 的接收和发送超时时间，防止程序长时间阻塞在网络操作上。使用 setsockopt 函数设置 SO_RCVTIMEO 和 SO_SNDTIMEO 选项。
⚝ 非阻塞 Socket: 对于需要高并发和高性能的网络应用，可以使用非阻塞 Socket 和多路复用技术 (例如 select, poll, epoll)。非阻塞 Socket 在没有数据可读或缓冲区满时，不会阻塞程序执行，可以提高程序的响应速度和并发能力。
⚝ 安全通信: 对于敏感数据的网络传输，应使用安全加密协议，例如 HTTPS, TLS/SSL 等。可以使用 OpenSSL 等加密库在 native 层实现安全通信。
⚝ 资源释放: 在网络通信完成后，务必关闭 Socket 文件描述符，释放 Socket 资源。可以使用 RAII 机制，例如 C++ 的智能指针或自定义的 Socket 类，在对象析构时自动关闭 Socket，避免资源泄漏。
本节介绍了 NDK native 层的 Socket 网络编程，包括 TCP 和 UDP Socket 的创建、连接、发送、接收和关闭等操作。掌握这些知识，可以帮助开发者在 NDK 开发中实现高性能的网络通信功能，构建功能丰富的 Android native 应用。
3.5 多线程与并发：native 线程同步与异步处理
多线程和并发是现代软件开发中提高程序性能和响应能力的重要手段。在 Android NDK 开发中，native 层代码同样可以使用多线程技术，充分利用多核 CPU 的并行处理能力，提高应用的性能和用户体验。本节将介绍 NDK native 层多线程编程的基本概念、线程创建与管理、线程同步机制以及异步处理技术。
3.5.1 多线程编程基础
⚝ 进程 (Process)：进程是操作系统资源分配的基本单位，每个进程拥有独立的内存空间、代码段、数据段等资源。Android 应用通常运行在独立的进程中。
⚝ 线程 (Thread)：线程是进程中执行的实体，是 CPU 调度的基本单位。一个进程可以包含多个线程，这些线程共享进程的内存空间和资源。多线程可以实现并发执行，提高程序的并行处理能力。
⚝ 并发 (Concurrency)：指多个任务在同一时间段内看似同时执行。在单核 CPU 系统中，并发通过时间片轮转实现，CPU 在不同线程之间快速切换，造成并行执行的假象。在多核 CPU 系统中，并发可以实现真正的并行执行，多个线程可以在不同的 CPU 核心上同时运行。
⚝ 并行 (Parallelism)：指多个任务在同一时刻真正同时执行。并行需要多核 CPU 硬件支持，每个核心可以独立执行一个线程。
⚝ 线程的优点:
▮▮▮▮⚝ 提高程序性能: 通过并发执行，可以充分利用多核 CPU 的并行处理能力，缩短程序的执行时间。
▮▮▮▮⚝ 提高程序响应能力: 对于 I/O 密集型应用，可以将 I/O 操作放在后台线程执行，避免阻塞主线程，提高 UI 响应速度。
▮▮▮▮⚝ 简化程序设计: 对于某些复杂的任务，可以使用多线程将任务分解为多个子任务并行执行，简化程序设计和代码结构。
⚝ 线程的缺点:
▮▮▮▮⚝ 线程安全问题: 多线程共享进程的内存空间，可能存在数据竞争和线程安全问题。需要使用线程同步机制保证数据的一致性和正确性。
▮▮▮▮⚝ 线程管理开销: 线程的创建、销毁和切换需要一定的系统开销。过多的线程会增加系统负担，降低程序性能。
▮▮▮▮⚝ 调试复杂性: 多线程程序的调试比单线程程序更复杂，需要考虑线程同步、死锁、竞态条件等问题。
3.5.2 NDK 线程 API：pthread
NDK 提供了 POSIX 线程库 (pthread) 用于 native 层多线程编程。pthread 是一套跨平台的线程 API 标准，在 Linux, Android, macOS, iOS 等操作系统上都得到广泛支持。
常用 pthread API 函数：
⚝ pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg): 创建一个新的线程。
▮▮▮▮⚝ thread (线程 ID 指针)：用于接收新创建线程的线程 ID。
▮▮▮▮⚝ attr (线程属性指针)：指向线程属性结构体 pthread_attr_t 的指针，可以为 NULL 使用默认属性。
▮▮▮▮⚝ start_routine (线程入口函数指针)：指向线程入口函数的函数指针。线程启动后，会执行该函数。函数原型为 void* function_name(void* arg)，参数和返回值都是 void* 类型。
▮▮▮▮⚝ arg (线程入口函数参数)：传递给线程入口函数的参数，类型为 void*。
▮▮▮▮返回 0 表示成功，返回非 0 值表示失败。
⚝ pthread_join(pthread_t thread, void **retval): 等待指定的线程结束。
▮▮▮▮⚝ thread (线程 ID)：要等待的线程的线程 ID。
▮▮▮▮⚝ retval (线程返回值指针的指针)：用于接收线程返回值的指针。如果不需要接收返回值，可以为 NULL。
▮▮▮▮调用 pthread_join 的线程会阻塞，直到指定的线程结束。
⚝ pthread_detach(pthread_t thread): 将指定的线程设置为 detached 状态。Detached 状态的线程在结束后会自动释放资源，无需其他线程调用 pthread_join 等待其结束。
⚝ pthread_exit(void *retval): 线程主动退出，并可以返回一个返回值。
⚝ pthread_self(): 获取当前线程的线程 ID。
⚝ pthread_cancel(pthread_t thread): 取消指定的线程。被取消的线程需要检查取消状态并进行清理操作。
⚝ pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr): 初始化互斥锁 (mutex)。
⚝ pthread_mutex_destroy(pthread_mutex_t *mutex): 销毁互斥锁。
⚝ pthread_mutex_lock(pthread_mutex_t *mutex): 获取互斥锁。如果互斥锁已被其他线程持有，则当前线程会阻塞，直到获取到互斥锁。
⚝ pthread_mutex_unlock(pthread_mutex_t *mutex): 释放互斥锁。
⚝ pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr): 初始化条件变量 (condition variable)。
⚝ pthread_cond_destroy(pthread_cond_t *cond): 销毁条件变量。
⚝ pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex): 等待条件变量。调用 pthread_cond_wait 的线程会释放互斥锁，并进入休眠状态，直到条件变量被唤醒。
⚝ pthread_cond_signal(pthread_cond_t *cond): 唤醒等待条件变量的一个线程。
⚝ pthread_cond_broadcast(pthread_cond_t *cond): 唤醒等待条件变量的所有线程。
⚝ pthread_barrier_init(pthread_barrier_t *barrier, const pthread_barrierattr_t *attr, unsigned count): 初始化屏障 (barrier)。
⚝ pthread_barrier_destroy(pthread_barrier_t *barrier): 销毁屏障.
⚝ pthread_barrier_wait(pthread_barrier_t *barrier): 等待所有线程到达屏障。当指定数量的线程都调用 pthread_barrier_wait 时，所有线程才会被唤醒，继续执行。
3.5.3 线程创建与管理示例
1
#include <pthread.h>
2
#include <unistd.h>
3
#include <android/log.h>
4
5
#define TAG "NativeThreadExample"
6
7
void* threadFunction(void* arg) {
8
int threadId = *(int*)arg;
9
__android_log_print(ANDROID_LOG_INFO, TAG, "Thread %d started", threadId);
10
11
for (int i = 0; i < 5; ++i) {
12
__android_log_print(ANDROID_LOG_INFO, TAG, "Thread %d: count = %d", threadId, i);
13
sleep(1); // 模拟耗时操作
14
}
15
16
__android_log_print(ANDROID_LOG_INFO, TAG, "Thread %d finished", threadId);
17
pthread_exit((void*)threadId); // 返回线程 ID 作为返回值
18
return nullptr; // 为了兼容某些编译器，显式返回 nullptr
19
}
20
21
void createThreadsExample() {
22
pthread_t threads[3];
23
int threadIds[3] = {1, 2, 3};
24
25
for (int i = 0; i < 3; ++i) {
26
int result = pthread_create(&threads[i], nullptr, threadFunction, &threadIds[i]);
27
if (result != 0) {
28
__android_log_print(ANDROID_LOG_ERROR, TAG, "Failed to create thread %d: %s", threadIds[i], strerror(result));
29
} else {
30
__android_log_print(ANDROID_LOG_INFO, TAG, "Created thread %d", threadIds[i]);
31
}
32
}
33
34
for (int i = 0; i < 3; ++i) {
35
void* returnValue;
36
pthread_join(threads[i], &returnValue); // 等待线程结束，并获取返回值
37
int returnedThreadId = (int)(intptr_t)returnValue; // void* 转换为 int
38
__android_log_print(ANDROID_LOG_INFO, TAG, "Thread %d joined, returned value: %d", i + 1, returnedThreadId);
39
}
40
41
__android_log_print(ANDROID_LOG_INFO, TAG, "All threads finished");
42
}
编译和链接 pthread 库：
在使用 pthread API 之前，需要在 NDK 项目中链接 pthread 库。
⚝ CMake: 在 CMakeLists.txt 文件中，使用 target_link_libraries 命令链接 pthread 库：
1
target_link_libraries(your-native-lib pthread)
⚝ ndk-build: 在 Android.mk 文件中，使用 LOCAL_LDLIBS 变量链接 pthread 库：
1
LOCAL_LDLIBS := -lpthread
3.5.4 线程同步机制
多线程共享数据时，需要使用线程同步机制保证数据的一致性和正确性，避免数据竞争和竞态条件。常用的线程同步机制包括：
⚝ 互斥锁 (Mutex)：互斥锁用于保护临界区 (critical section)，保证在同一时刻只有一个线程可以访问临界区资源。线程在访问临界区之前需要获取互斥锁，访问完成后释放互斥锁。
⚝ 条件变量 (Condition Variable)：条件变量通常与互斥锁一起使用，用于线程间的同步和通信。线程可以等待某个条件成立，当条件成立时，其他线程可以唤醒等待线程。
⚝ 信号量 (Semaphore)：信号量用于控制对共享资源的访问数量。信号量维护一个计数器，线程在访问资源之前需要获取信号量 (计数器减 1)，访问完成后释放信号量 (计数器加 1)。当计数器为 0 时，线程需要等待，直到有其他线程释放信号量。
⚝ 屏障 (Barrier)：屏障用于同步多个线程的执行进度。当所有线程都到达屏障时，所有线程才会被唤醒，继续执行。
⚝ 原子操作 (Atomic Operations)：原子操作是指不可中断的操作，可以保证操作的原子性。C++11 提供了原子操作库 <atomic>，可以用于实现无锁编程，提高并发性能。
3.5.5 异步处理技术
异步处理是指将耗时操作放在后台线程执行，避免阻塞主线程，提高 UI 响应速度。Android 提供了多种异步处理技术，例如：
⚝ AsyncTask (Java)：Android 提供的异步任务类，用于在后台线程执行耗时操作，并在主线程更新 UI。AsyncTask 适用于简单的异步任务，但容易导致回调地狱和内存泄漏。
⚝ HandlerThread (Java)：Android 提供的带有消息循环的线程类，可以与 Handler 结合使用，实现线程间通信和异步处理。
⚝ 线程池 (Thread Pool)：线程池维护一组线程，可以复用线程，减少线程创建和销毁的开销，提高线程管理效率。可以使用 java.util.concurrent.ExecutorService 等线程池 API。
⚝ C++ Futures and Promises (C++11)：C++11 提供的异步编程工具，可以方便地实现异步任务的启动、等待和结果获取。
⚝ libuv (C/C++): libuv 是一个高性能的跨平台异步 I/O 库，可以用于实现事件驱动的异步编程模型。
在 NDK native 层，可以使用 pthread 创建和管理线程，使用互斥锁、条件变量等线程同步机制保证线程安全，使用异步处理技术提高程序性能和响应能力。选择合适的线程同步和异步处理技术，可以构建高效、稳定、流畅的 Android native 应用。
3.6 内存管理：native 内存分配、释放与优化策略
内存管理是软件开发中至关重要的一环。在 Android NDK 开发中，native 层代码的内存管理直接影响应用的性能、稳定性和资源消耗。不合理的内存管理可能导致内存泄漏、内存溢出、性能下降等问题。本节将深入探讨 NDK native 层的内存管理，包括内存分配与释放、内存泄漏检测与预防、内存优化策略以及内存池技术。
3.6.1 Native 内存分配与释放
在 NDK native 层，主要使用 C/C++ 的动态内存分配 API 进行内存管理。常用的内存分配和释放函数包括：
⚝ malloc(size_t size): 分配 size 字节的内存块，返回指向分配内存的指针。如果分配失败，返回 NULL。
⚝ calloc(size_t num, size_t size): 分配 num * size 字节的内存块，并将分配的内存初始化为 0，返回指向分配内存的指针。如果分配失败，返回 NULL。
⚝ realloc(void *ptr, size_t size): 重新分配 ptr 指向的内存块的大小为 size 字节。如果 ptr 为 NULL，则相当于 malloc(size)。如果 size 为 0 且 ptr 不为 NULL，则相当于 free(ptr)。返回指向重新分配内存的指针，如果分配失败，返回 NULL，原内存块的数据可能会被复制到新的内存块。
⚝ free(void *ptr): 释放 malloc, calloc, 或 realloc 分配的内存块。ptr 必须是指向由这些函数分配的内存块的指针，否则行为未定义。释放 NULL 指针是安全的，不会有任何操作。
⚝ new 和 delete (C++): C++ 提供的内存分配和释放运算符。new 用于分配单个对象或对象数组，delete 和 delete[] 用于释放 new 分配的内存。new 和 delete 会调用对象的构造函数和析构函数，适用于 C++ 对象的内存管理。
▮▮▮▮⚝ T* ptr = new T; // 分配单个 T 类型对象
▮▮▮▮⚝ delete ptr; // 释放单个对象内存
▮▮▮▮⚝ T* arrayPtr = new T[n]; // 分配 n 个 T 类型对象数组
▮▮▮▮⚝ delete[] arrayPtr; // 释放对象数组内存
内存分配示例：
1
#include <stdlib.h>
2
#include <new> // C++ new/delete
3
4
void memoryAllocationExample() {
5
// C 风格内存分配
6
int *cIntPtr = (int*)malloc(sizeof(int));
7
if (cIntPtr == NULL) {
8
// 内存分配失败处理
9
}
10
*cIntPtr = 100;
11
free(cIntPtr); // 释放 C 风格分配的内存
12
13
int *cIntArrayPtr = (int*)calloc(10, sizeof(int)); // 分配 10 个 int，并初始化为 0
14
if (cIntArrayPtr == NULL) {
15
// 内存分配失败处理
16
}
17
free(cIntArrayPtr);
18
19
// C++ 风格内存分配
20
int *cppIntPtr = new int;
21
*cppIntPtr = 200;
22
delete cppIntPtr; // 释放 C++ 风格分配的内存
23
24
int *cppIntArrayPtr = new int[5];
25
delete[] cppIntArrayPtr;
26
}
内存释放原则：
⚝ 配对使用: malloc/calloc/realloc 和 free 必须配对使用，new 和 delete (或 delete[]) 必须配对使用。分配了内存就必须释放，避免内存泄漏。
⚝ 只释放一次: 同一块内存只能释放一次，多次释放会导致程序崩溃或内存损坏。
⚝ 释放正确的内存: 释放的指针必须是指向由 malloc/calloc/realloc/new 分配的内存块的起始地址。不要释放野指针、空指针或已释放的指针。
⚝ 及时释放: 在内存不再使用时，应及时释放，避免长时间占用内存资源。
3.6.2 内存泄漏检测与预防
内存泄漏 (Memory Leak) 指的是程序在运行过程中，动态分配的内存没有被及时释放，导致可用内存逐渐减少，最终可能导致内存耗尽，程序崩溃或系统性能下降。在 NDK 开发中，内存泄漏是一个常见且严重的问题。
内存泄漏检测工具：
⚝ AddressSanitizer (ASan)：ASan 是一个强大的内存错误检测工具，可以检测内存泄漏、缓冲区溢出、使用已释放内存等错误。ASan 可以通过编译器和链接器选项启用，例如 -fsanitize=address。ASan 会在运行时对内存操作进行监控，检测内存错误并报告错误信息。
⚝ Valgrind (Memcheck)：Valgrind 是一套强大的程序分析工具，其中的 Memcheck 工具可以检测内存泄漏、非法内存访问等错误。Valgrind 运行在虚拟机中，对程序进行动态分析，检测内存错误并报告详细的错误信息。Valgrind 性能开销较大，通常用于开发和调试阶段。
⚝ Android Studio Memory Profiler: Android Studio 提供的内存分析工具，可以实时监控应用的内存使用情况，包括 Java 堆内存和 Native 堆内存。Memory Profiler 可以检测内存泄漏、内存抖动等问题，并提供内存快照和堆转储分析功能。
内存泄漏预防策略：
⚝ 养成良好的内存管理习惯: 始终牢记内存分配和释放的配对原则，分配了内存就必须释放。在代码编写过程中，仔细检查内存分配和释放逻辑，确保没有遗漏或错误。
⚝ 使用 RAII (Resource Acquisition Is Initialization)：RAII 是一种 C++ 编程技术，将资源 (例如内存、文件句柄、锁) 的生命周期与对象的生命周期绑定。通过 RAII，可以确保资源在对象创建时分配，在对象销毁时自动释放，避免资源泄漏。C++ 的智能指针 (例如 std::unique_ptr, std::shared_ptr) 就是 RAII 的典型应用。
⚝ 避免手动管理内存: 尽量使用 C++ 的智能指针、容器 (例如 std::vector, std::string, std::map) 等 RAII 机制，减少手动内存管理的场景。对于需要手动管理内存的情况，要格外小心，确保内存分配和释放的正确性。
⚝ 代码审查和测试: 定期进行代码审查，检查代码中的内存管理问题。进行充分的测试，包括单元测试、集成测试、压力测试等，尽早发现和修复内存泄漏问题。
⚝ 使用内存泄漏检测工具: 在开发和测试阶段，使用 ASan, Valgrind, Android Studio Memory Profiler 等内存泄漏检测工具，及时发现和定位内存泄漏问题。
3.6.3 内存优化策略
内存优化旨在减少应用的内存占用，提高内存使用效率，降低内存分配和释放的开销，从而提升应用的性能和用户体验。
内存优化策略：
⚝ 减少内存分配次数: 频繁的内存分配和释放会增加系统开销，降低程序性能。尽量减少内存分配次数，例如：
▮▮▮▮⚝ 对象池 (Object Pool)：对于频繁创建和销毁的对象，可以使用对象池技术，预先创建一批对象，放入对象池中。需要使用对象时，从对象池中获取，使用完后放回对象池，避免频繁的内存分配和释放。
▮▮▮▮⚝ 内存池 (Memory Pool)：类似于对象池，但管理的是内存块。内存池预先分配一大块内存，然后将内存块分割成小块，按需分配小块内存。内存池可以减少内存碎片，提高内存分配效率。
▮▮▮▮⚝ 复用内存: 对于可以复用的内存，尽量复用，避免重复分配和释放。
⚝ 减小内存块大小: 尽量减小内存块的大小，只分配需要的内存，避免浪费内存空间。
⚝ 选择合适的数据结构: 选择合适的数据结构可以减少内存占用和提高数据访问效率。例如，使用 std::vector 代替动态数组，使用 std::unordered_map 代替 std::map (在不需要有序遍历时)。
⚝ 延迟加载 (Lazy Loading)：对于不常用的资源或数据，可以延迟加载，在需要使用时才加载，减少应用启动时的内存占用。
⚝ 内存缓存 (Memory Cache)：对于经常访问的数据，可以使用内存缓存，将数据缓存在内存中，提高数据访问速度，减少重复加载。
⚝ 图片压缩和缩放: 对于图片资源，进行适当的压缩和缩放，减小图片文件大小和内存占用。
⚝ 避免内存抖动 (Memory Churn)：内存抖动指的是短时间内频繁地分配和释放大量内存，导致内存碎片增多，GC 频繁触发，降低程序性能。应尽量避免内存抖动，例如减少临时对象的创建，使用对象池和内存池等技术。
⚝ 使用更高效的内存分配器: Android 系统默认的内存分配器是 dlmalloc。可以考虑使用更高效的内存分配器，例如 jemalloc, tcmalloc 等。这些内存分配器在某些场景下可以提高内存分配效率，减少内存碎片。
3.6.4 内存池技术
内存池 (Memory Pool) 是一种内存管理技术，预先分配一大块连续的内存，然后将这块内存分割成大小相等或大小不同的内存块，按需分配和释放内存块。内存池可以减少内存碎片，提高内存分配和释放效率，尤其适用于频繁分配和释放小块内存的场景。
内存池的优点：
⚝ 提高内存分配和释放效率: 内存池预先分配内存，后续的内存分配和释放操作只需要在预分配的内存块中进行，避免了频繁的系统调用，提高了内存操作效率。
⚝ 减少内存碎片: 内存池通常分配一大块连续的内存，可以减少内存碎片，提高内存利用率。
⚝ 内存分配可预测性: 内存池的内存分配是可预测的，可以避免内存分配失败的风险。
内存池的缺点：
⚝ 内存浪费: 内存池预先分配的内存可能没有完全使用，造成内存浪费。
⚝ 实现复杂性: 内存池的实现相对复杂，需要考虑内存块的分配、释放、管理等问题。
内存池适用场景：
⚝ 频繁分配和释放小块内存的场景: 例如游戏开发、网络编程、实时系统等。
⚝ 对内存分配性能要求较高的场景: 例如高性能服务器、嵌入式系统等。
简单的内存池实现示例 (C++)：
1
#include <cstdlib>
2
#include <vector>
3
4
class MemoryPool {
5
public:
6
MemoryPool(size_t blockSize, size_t blockCount) : blockSize_(blockSize), blockCount_(blockCount), pool_(nullptr), freeBlocks_(blockCount) {
7
pool_ = malloc(blockSize * blockCount); // 预分配内存池
8
if (pool_ == nullptr) {
9
// 内存分配失败处理
10
return;
11
}
12
char* blockPtr = static_cast<char*>(pool_);
13
for (size_t i = 0; i < blockCount; ++i) {
14
freeBlocks_[i] = blockPtr + i * blockSize; // 初始化空闲块列表
15
}
16
}
17
18
~MemoryPool() {
19
free(pool_); // 释放内存池
20
}
21
22
void* allocate() {
23
if (freeBlocks_.empty()) {
24
return nullptr; // 内存池已满
25
}
26
void* block = freeBlocks_.back();
27
freeBlocks_.pop_back();
28
return block;
29
}
30
31
void deallocate(void* block) {
32
if (block == nullptr) {
33
return;
34
}
35
freeBlocks_.push_back(block); // 将内存块放回空闲块列表
36
}
37
38
private:
39
size_t blockSize_; // 内存块大小
40
size_t blockCount_; // 内存块数量
41
void* pool_; // 内存池起始地址
42
std::vector<void*> freeBlocks_; // 空闲内存块列表
43
};
本节介绍了 NDK native 层的内存管理，包括内存分配与释放、内存泄漏检测与预防、内存优化策略以及内存池技术。合理的内存管理是 NDK 开发的关键，可以提高应用的性能、稳定性和资源利用率。开发者应深入理解内存管理原理，掌握内存管理工具和技术，编写高质量的 Android native 代码。
ENDOF_CHAPTER_
4. chapter 4： NDK 图形图像开发：OpenGL ES 与 Vulkan
4.1 OpenGL ES 基础：渲染管线、着色器与纹理
OpenGL ES (OpenGL for Embedded Systems) 是一种针对嵌入式系统，例如移动设备、游戏机和汽车信息娱乐系统等，优化的跨语言、跨平台的应用程序编程接口 (API)。它是桌面 OpenGL 规范的一个子集，专为在资源受限的环境中实现高性能 2D 和 3D 图形渲染而设计。在 Android NDK 开发中，OpenGL ES 是进行图形图像开发的重要工具，尤其是在游戏开发、视觉效果和高性能 UI 渲染等领域。
本节将深入探讨 OpenGL ES 的基础概念，包括渲染管线 (Rendering Pipeline)、着色器 (Shader) 和纹理 (Texture)，为后续章节深入 NDK 中的 OpenGL ES 应用打下坚实的基础。
4.1.1 渲染管线 (Rendering Pipeline)
渲染管线是 OpenGL ES 的核心概念，它描述了将 3D 模型数据转换为屏幕上 2D 像素的完整流程。理解渲染管线对于优化图形性能至关重要。OpenGL ES 的渲染管线主要包括以下几个阶段：
① 顶点着色器 (Vertex Shader)：
⚝ 顶点着色器是渲染管线的第一个阶段，它处理输入的顶点数据。顶点数据通常包括顶点的位置、颜色、法线、纹理坐标等信息。
⚝ 顶点着色器的主要任务是对每个顶点进行变换，例如模型视图变换 (Model-View Transformation) 和投影变换 (Projection Transformation)，将顶点坐标从模型空间转换到裁剪空间。
⚝ 顶点着色器还可以进行其他顶点属性的计算，例如光照计算、动画效果等。
⚝ 顶点着色器是可编程的，开发者可以使用 GLSL (OpenGL Shading Language) 语言编写顶点着色器程序。
② 图元装配 (Primitive Assembly)：
⚝ 图元装配阶段将顶点着色器输出的顶点数据组织成图元 (Primitive)，例如点、线、三角形等。
⚝ 图元是 OpenGL ES 渲染的基本单元。常见的图元类型包括 GL_POINTS（点）、GL_LINES（线段）、GL_TRIANGLES（三角形）等。
⚝ 图元装配阶段还会进行裁剪 (Clipping) 和背面剔除 (Back-face Culling) 等操作，以提高渲染效率。裁剪操作会剔除位于视口之外的图元，背面剔除操作会剔除朝向观察者背面的三角形。
③ 光栅化 (Rasterization)：
⚝ 光栅化阶段将图元转换为片段 (Fragment)。片段可以理解为潜在的像素，它包含了像素的位置、颜色、深度等信息。
⚝ 光栅化过程会根据图元的形状和位置，计算出覆盖了哪些像素，并为每个像素生成对应的片段。
⚝ 光栅化阶段还会进行插值 (Interpolation) 操作，例如对顶点颜色、纹理坐标等属性进行插值，得到每个片段的属性值。
④ 片段着色器 (Fragment Shader)：
⚝ 片段着色器是渲染管线的核心阶段，它处理光栅化阶段生成的每个片段。
⚝ 片段着色器的主要任务是计算每个片段的最终颜色。这通常涉及到纹理采样、光照计算、雾化效果、后期处理等操作。
⚝ 片段着色器也是可编程的，开发者可以使用 GLSL 语言编写片段着色器程序。
⚝ 片段着色器的输出是片段的颜色值，以及可选的深度值。
⑤ 测试与混合 (Tests and Blending)：
⚝ 测试与混合阶段对片段着色器输出的片段进行一系列测试，例如深度测试 (Depth Test)、模板测试 (Stencil Test) 等。
⚝ 深度测试用于判断片段是否被遮挡，只有深度值较小的片段才能通过深度测试并被绘制到帧缓冲区 (Framebuffer) 中。
⚝ 模板测试用于实现一些特殊的渲染效果，例如遮罩、轮廓线等。
⚝ 混合 (Blending) 操作用于将当前片段的颜色与帧缓冲区中已有的颜色进行混合，实现透明效果、叠加效果等。
⑥ 帧缓冲区 (Framebuffer)：
⚝ 帧缓冲区是存储最终渲染结果的缓冲区。它通常包括颜色缓冲区 (Color Buffer)、深度缓冲区 (Depth Buffer) 和模板缓冲区 (Stencil Buffer)。
⚝ 颜色缓冲区存储每个像素的颜色值，深度缓冲区存储每个像素的深度值，模板缓冲区存储每个像素的模板值。
⚝ 渲染管线的最终输出结果会被写入到帧缓冲区中，然后显示到屏幕上。
理解 OpenGL ES 渲染管线的各个阶段，有助于开发者更好地控制图形渲染过程，优化渲染性能，并实现各种复杂的图形效果。
4.1.2 着色器 (Shader)
着色器是 OpenGL ES 中可编程渲染管线的核心组成部分。它们是用 GLSL (OpenGL Shading Language) 编写的小程序，运行在 GPU (Graphics Processing Unit) 上，负责处理顶点和片段数据，控制图形渲染的各个方面。OpenGL ES 主要使用两种类型的着色器：顶点着色器 (Vertex Shader) 和片段着色器 (Fragment Shader)。
① 顶点着色器 (Vertex Shader)：
⚝ 顶点着色器处理输入的顶点数据，例如顶点的位置、颜色、法线、纹理坐标等。
⚝ 顶点着色器的主要任务是对每个顶点进行变换，将顶点坐标从模型空间转换到裁剪空间。
⚝ 顶点着色器可以访问顶点属性、uniform 变量 (Uniform Variable) 和纹理 (Texture)。
⚝ 顶点着色器的输出是变换后的顶点位置，以及其他需要传递给片段着色器的顶点属性。
② 片段着色器 (Fragment Shader)：
⚝ 片段着色器处理光栅化阶段生成的每个片段。
⚝ 片段着色器的主要任务是计算每个片段的最终颜色。
⚝ 片段着色器可以访问片段属性（由顶点着色器插值得到）、uniform 变量和纹理。
⚝ 片段着色器的输出是片段的颜色值，以及可选的深度值。
GLSL (OpenGL Shading Language)：
⚝ GLSL 是 OpenGL ES 的着色语言，它是一种类 C 的高级编程语言，专门用于编写着色器程序。
⚝ GLSL 提供了丰富的内置函数和数据类型，用于进行向量、矩阵运算、纹理采样、光照计算等图形操作。
⚝ GLSL 着色器程序需要在运行时编译和链接，然后才能被 OpenGL ES 使用。
着色器程序示例 (GLSL)：
顶点着色器示例：
1
#version 300 es
2
in vec4 a_position; // 顶点位置属性
3
uniform mat4 u_mvpMatrix; // MVP 矩阵
4
5
void main() {
6
gl_Position = u_mvpMatrix * a_position; // 顶点变换
7
}
片段着色器示例：
1
#version 300 es
2
precision mediump float; // 设置浮点精度
3
out vec4 fragColor; // 输出颜色
4
5
void main() {
6
fragColor = vec4(1.0, 0.0, 0.0, 1.0); // 红色
7
}
上述示例展示了最简单的顶点着色器和片段着色器。顶点着色器接收顶点位置属性 a_position 和 MVP 矩阵 u_mvpMatrix，将顶点位置进行 MVP 变换后输出。片段着色器直接输出红色。
通过编写着色器程序，开发者可以灵活地控制图形渲染的各个方面，实现各种自定义的视觉效果。掌握着色器编程是 OpenGL ES 开发的关键技能。
4.1.3 纹理 (Texture)
纹理是 OpenGL ES 中非常重要的概念，它可以将图像数据应用到 3D 模型表面，增加模型的细节和真实感。纹理可以理解为覆盖在模型表面的“皮肤”，它可以是颜色图像、灰度图像、法线贴图、高度图等等。
① 纹理类型：
⚝ 2D 纹理 (2D Texture)：最常用的纹理类型，用于存储 2D 图像数据。
⚝ 立方体纹理 (Cube Texture)：由六个 2D 纹理组成，用于环境贴图 (Environment Mapping) 和天空盒 (Skybox) 等效果。
⚝ 3D 纹理 (3D Texture)：用于存储 3D 体积数据，例如医学图像、烟雾效果等。
⚝ 纹理数组 (Texture Array)：用于存储多个 2D 纹理，可以高效地切换纹理。
② 纹理坐标 (Texture Coordinates)：
⚝ 纹理坐标用于指定模型表面上的每个点对应纹理图像上的哪个位置。
⚝ 纹理坐标通常是二维的，范围在 [0, 1] 之间，通常用 (s, t) 或 (u, v) 表示。
⚝ 顶点数据中可以包含纹理坐标属性，顶点着色器会将纹理坐标传递给片段着色器，并在光栅化阶段进行插值。
③ 纹理采样 (Texture Sampling)：
⚝ 纹理采样是指在片段着色器中，根据纹理坐标从纹理图像中获取颜色值的过程。
⚝ OpenGL ES 提供了多种纹理采样函数，例如 texture2D()、textureCube() 等。
⚝ 纹理采样可以设置纹理过滤 (Texture Filtering) 和纹理环绕 (Texture Wrapping) 方式，控制纹理的显示效果。
④ 纹理过滤 (Texture Filtering)：
⚝ 纹理过滤用于控制纹理在放大或缩小时的显示效果。
⚝ 最近邻过滤 (Nearest Neighbor Filtering)：也称为点过滤，速度快，但纹理放大时会出现明显的像素块状感。
⚝ 线性过滤 (Linear Filtering)：也称为双线性过滤，纹理放大和缩小时效果更平滑，但性能稍慢。
⚝ mipmap 过滤 (Mipmap Filtering)：用于优化纹理缩小时的性能和质量，生成一系列不同分辨率的纹理图像，根据物体距离选择合适的 mipmap 层级进行采样。
⑤ 纹理环绕 (Texture Wrapping)：
⚝ 纹理环绕用于控制纹理坐标超出 [0, 1] 范围时的显示方式。
⚝ 重复环绕 (Repeat Wrapping)：纹理在水平和垂直方向上重复平铺。
⚝ 镜像环绕 (Mirrored Repeat Wrapping)：纹理在水平和垂直方向上镜像重复平铺。
⚝ 边缘钳制环绕 (Clamp to Edge Wrapping)：纹理坐标超出 [0, 1] 范围时，采样纹理边缘的像素颜色。
纹理应用示例 (片段着色器 GLSL)：
1
#version 300 es
2
precision mediump float;
3
in vec2 v_texCoord; // 纹理坐标属性 (由顶点着色器传递)
4
uniform sampler2D u_texture; // 2D 纹理 uniform 变量
5
out vec4 fragColor;
6
7
void main() {
8
fragColor = texture(u_texture, v_texCoord); // 纹理采样
9
}
上述示例展示了如何在片段着色器中使用纹理。片段着色器接收纹理坐标属性 v_texCoord 和 2D 纹理 uniform 变量 u_texture，使用 texture() 函数进行纹理采样，将采样得到的颜色值作为片段的最终颜色输出。
纹理是 OpenGL ES 图形渲染中不可或缺的组成部分，它可以为 3D 模型增加丰富的细节和视觉效果。理解纹理的概念和使用方法，对于进行高质量的图形图像开发至关重要。
4.2 OpenGL ES 在 NDK 中的应用：EGL 环境配置与渲染流程
在 Android NDK 中使用 OpenGL ES 进行图形开发，需要进行一系列的配置和初始化工作。其中，EGL (Embedded Graphics Library) 环境配置是关键步骤。EGL 是 OpenGL ES 和底层原生平台窗口系统之间的接口，它负责创建 OpenGL ES 上下文 (Context)、配置渲染表面 (Surface) 和管理缓冲区交换 (Buffer Swap) 等操作。
本节将详细介绍如何在 NDK 中配置 EGL 环境，并构建一个基本的 OpenGL ES 渲染流程。
4.2.1 EGL 环境配置 (EGL Environment Configuration)
EGL 环境配置主要包括以下几个步骤：
① 获取 EGLDisplay：
⚝ EGLDisplay 是 EGL 的核心对象，它代表了原生平台的显示设备。
⚝ 可以通过 eglGetDisplay(EGL_DEFAULT_DISPLAY) 函数获取默认的 EGLDisplay。
⚝ 如果获取失败，需要进行错误处理。
② 初始化 EGL：
⚝ 使用 eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor) 函数初始化 EGL。
⚝ 该函数会返回 EGL 的主版本号和次版本号。
⚝ 如果初始化失败，需要进行错误处理。
③ 配置 EGLConfig：
⚝ EGLConfig 描述了可用的渲染配置，例如颜色缓冲区格式、深度缓冲区大小、模板缓冲区大小、渲染 API 版本等。
⚝ 可以使用 eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config) 函数选择合适的 EGLConfig。
⚝ attrib_list 参数是一个属性列表，用于指定所需的配置属性。例如，可以指定使用 OpenGL ES 3.0 版本、RGBA8888 颜色格式、深度缓冲区等。
⚝ 如果找不到合适的 EGLConfig，需要进行错误处理。
④ 创建 EGLContext：
⚝ EGLContext 代表 OpenGL ES 渲染上下文，它存储了 OpenGL ES 的状态信息，例如当前使用的着色器程序、纹理对象、缓冲区对象等。
⚝ 可以使用 eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *attrib_list) 函数创建 EGLContext。
⚝ share_context 参数可以指定与其他 EGLContext 共享资源，例如纹理对象、缓冲区对象等。
⚝ 如果创建失败，需要进行错误处理。
⑤ 创建 EGLSurface：
⚝ EGLSurface 代表渲染表面，它是 OpenGL ES 渲染的目标。在 Android 平台上，EGLSurface 通常与 ANativeWindow 关联，用于将渲染结果显示到屏幕上。
⚝ 可以使用 eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint *attrib_list) 函数创建窗口表面 EGLSurface。
⚝ win 参数是 ANativeWindow 对象，代表 Android 窗口。
⚝ 如果创建失败，需要进行错误处理。
⑥ 绑定 EGLContext 和 EGLSurface：
⚝ 使用 eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx) 函数将 EGLContext 和 EGLSurface 绑定到当前线程。
⚝ 绑定之后，当前线程的 OpenGL ES 操作将会在指定的 EGLContext 和 EGLSurface 上执行。
⚝ 如果绑定失败，需要进行错误处理。
EGL 环境配置代码示例 (C++)：
1
#include <EGL/egl.h>
2
#include <android/native_window.h>
3
#include <android/log.h>
4
5
#define LOG_TAG "EGLHelper"
6
#define ALOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
7
8
EGLDisplay display = EGL_NO_DISPLAY;
9
EGLContext context = EGL_NO_CONTEXT;
10
EGLSurface surface = EGL_NO_SURFACE;
11
12
bool setupEGL(ANativeWindow* window) {
13
// 1. 获取 EGLDisplay
14
display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
15
if (display == EGL_NO_DISPLAY) {
16
ALOGE("eglGetDisplay() returned error %d", eglGetError());
17
return false;
18
}
19
20
// 2. 初始化 EGL
21
EGLint majorVersion;
22
EGLint minorVersion;
23
if (!eglInitialize(display, &majorVersion, &minorVersion)) {
24
ALOGE("eglInitialize() returned error %d", eglGetError());
25
return false;
26
}
27
28
// 3. 配置 EGLConfig
29
EGLint configAttribList[] = {
30
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES3_BIT, // 使用 OpenGL ES 3.0
31
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
32
EGL_BLUE_SIZE, 8,
33
EGL_GREEN_SIZE, 8,
34
EGL_RED_SIZE, 8,
35
EGL_DEPTH_SIZE, 24,
36
EGL_NONE
37
};
38
EGLConfig config = nullptr;
39
EGLint numConfigs;
40
if (!eglChooseConfig(display, configAttribList, &config, 1, &numConfigs)) {
41
ALOGE("eglChooseConfig() returned error %d", eglGetError());
42
return false;
43
}
44
45
// 4. 创建 EGLContext
46
EGLint contextAttribList[] = {
47
EGL_CONTEXT_CLIENT_VERSION, 3, // 使用 OpenGL ES 3.0 上下文
48
EGL_NONE
49
};
50
context = eglCreateContext(display, config, EGL_NO_CONTEXT, contextAttribList);
51
if (context == EGL_NO_CONTEXT) {
52
ALOGE("eglCreateContext() returned error %d", eglGetError());
53
return false;
54
}
55
56
// 5. 创建 EGLSurface
57
surface = eglCreateWindowSurface(display, config, window, nullptr);
58
if (surface == EGL_NO_SURFACE) {
59
ALOGE("eglCreateWindowSurface() returned error %d", eglGetError());
60
return false;
61
}
62
63
// 6. 绑定 EGLContext 和 EGLSurface
64
if (!eglMakeCurrent(display, surface, surface, context)) {
65
ALOGE("eglMakeCurrent() returned error %d", eglGetError());
66
return false;
67
}
68
69
return true;
70
}
71
72
void releaseEGL() {
73
if (display != EGL_NO_DISPLAY) {
74
eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
75
if (surface != EGL_NO_SURFACE) {
76
eglDestroySurface(display, surface);
77
surface = EGL_NO_SURFACE;
78
}
79
if (context != EGL_NO_CONTEXT) {
80
eglDestroyContext(display, context);
81
context = EGL_NO_CONTEXT;
82
}
83
eglTerminate(display);
84
display = EGL_NO_DISPLAY;
85
}
86
}
上述代码示例展示了 EGL 环境配置的基本流程。setupEGL() 函数负责初始化 EGL 环境，releaseEGL() 函数负责释放 EGL 资源。在 Android NDK OpenGL ES 开发中，通常需要在 NativeActivity 的 onSurfaceCreated() 或 onSurfaceChanged() 回调函数中调用 setupEGL() 进行 EGL 环境配置，并在 onSurfaceDestroyed() 回调函数中调用 releaseEGL() 释放 EGL 资源。
4.2.2 OpenGL ES 渲染流程 (OpenGL ES Rendering Process)
完成 EGL 环境配置后，就可以开始进行 OpenGL ES 渲染了。一个基本的 OpenGL ES 渲染流程通常包括以下几个步骤：
① 设置视口 (Viewport)：
⚝ 使用 glViewport(GLint x, GLint y, GLsizei width, GLsizei height) 函数设置视口大小。
⚝ 视口定义了 OpenGL ES 渲染输出的目标窗口区域。通常需要将视口大小设置为窗口的宽度和高度。
② 清除缓冲区 (Clear Buffers)：
⚝ 使用 glClear(GLbitfield mask) 函数清除缓冲区。
⚝ mask 参数指定要清除的缓冲区，例如 GL_COLOR_BUFFER_BIT（颜色缓冲区）、GL_DEPTH_BUFFER_BIT（深度缓冲区）、GL_STENCIL_BUFFER_BIT（模板缓冲区）。
⚝ 通常需要在每一帧渲染开始前清除颜色缓冲区和深度缓冲区。
③ 加载和编译着色器 (Load and Compile Shaders)：
⚝ 从资源文件或字符串中加载顶点着色器和片段着色器源代码。
⚝ 使用 glCreateShader(GLenum type) 函数创建着色器对象，glShaderSource(GLuint shader, GLsizei count, const char *const* string, const GLint *length) 函数加载着色器源代码，glCompileShader(GLuint shader) 函数编译着色器。
⚝ 需要检查着色器编译是否成功，如果失败需要获取编译错误信息并进行处理。
④ 创建和链接着色器程序 (Create and Link Shader Program)：
⚝ 使用 glCreateProgram() 函数创建着色器程序对象。
⚝ 使用 glAttachShader(GLuint program, GLuint shader) 函数将顶点着色器和片段着色器对象附加到程序对象。
⚝ 使用 glLinkProgram(GLuint program) 函数链接着色器程序。
⚝ 需要检查程序链接是否成功，如果失败需要获取链接错误信息并进行处理。
⚝ 使用 glUseProgram(GLuint program) 函数激活着色器程序。
⑤ 准备顶点数据 (Prepare Vertex Data)：
⚝ 定义顶点数据，包括顶点位置、颜色、法线、纹理坐标等。
⚝ 将顶点数据上传到 GPU 缓冲区对象 (Buffer Object)。
⚝ 使用 glGenBuffers(GLsizei n, GLuint *buffers) 函数创建缓冲区对象，glBindBuffer(GLenum target, GLuint buffer) 函数绑定缓冲区对象，glBufferData(GLenum target, GLsizeiptr size, const void *data, GLenum usage) 函数上传顶点数据。
⑥ 设置顶点属性 (Set Vertex Attributes)：
⚝ 使用 glGetAttribLocation(GLuint program, const char *name) 函数获取顶点着色器中顶点属性变量的位置。
⚝ 使用 glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer) 函数设置顶点属性指针，指定顶点属性数据的格式和位置。
⚝ 使用 glEnableVertexAttribArray(GLuint index) 函数启用顶点属性数组。
⑦ 设置 Uniform 变量 (Set Uniform Variables)：
⚝ 使用 glGetUniformLocation(GLuint program, const char *name) 函数获取着色器程序中 uniform 变量的位置。
⚝ 使用 glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)、glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) 等函数设置 uniform 变量的值。
⚝ Uniform 变量通常用于传递 MVP 矩阵、纹理单元索引、颜色值等全局参数。
⑧ 绘制图元 (Draw Primitives)：
⚝ 使用 glDrawArrays(GLenum mode, GLint first, GLsizei count) 或 glDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices) 函数绘制图元。
⚝ mode 参数指定图元类型，例如 GL_TRIANGLES、GL_LINES、GL_POINTS 等。
⚝ first 和 count 参数指定绘制的顶点范围。
⚝ indices 参数用于索引绘制，可以减少顶点数据的重复。
⑨ 交换缓冲区 (Swap Buffers)：
⚝ 使用 eglSwapBuffers(EGLDisplay dpy, EGLSurface surface) 函数交换前后缓冲区，将渲染结果显示到屏幕上。
⚝ 交换缓冲区操作通常在每一帧渲染结束后执行。
OpenGL ES 渲染流程代码框架 (C++)：
1
void renderFrame() {
2
// 1. 设置视口
3
glViewport(0, 0, windowWidth, windowHeight);
4
5
// 2. 清除缓冲区
6
glClearColor(0.0f, 0.0f, 0.0f, 1.0f); // 黑色背景
7
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
8
9
// 3. 加载和编译着色器 (省略)
10
// 4. 创建和链接着色器程序 (省略)
11
glUseProgram(program);
12
13
// 5. 准备顶点数据 (省略)
14
// 6. 设置顶点属性 (省略)
15
16
// 7. 设置 Uniform 变量 (例如 MVP 矩阵) (省略)
17
18
// 8. 绘制图元
19
glDrawArrays(GL_TRIANGLES, 0, vertexCount); // 绘制三角形
20
21
// 9. 交换缓冲区
22
eglSwapBuffers(display, surface);
23
}
上述代码框架展示了一个基本的 OpenGL ES 渲染流程。实际的渲染过程会更加复杂，需要根据具体的渲染需求进行着色器编程、顶点数据准备、纹理加载等操作。理解 OpenGL ES 渲染流程，有助于开发者构建高效的图形渲染应用。
4.3 Vulkan 初探：现代图形 API 及其在 Android NDK 的应用
Vulkan 是一种现代、跨平台的 2D 和 3D 图形和计算 API。与 OpenGL ES 相比，Vulkan 提供了更低的 CPU 开销、更好的多线程支持和更强的硬件控制能力，可以显著提升图形渲染性能，尤其是在移动设备等资源受限的平台上。Android 平台从 Android 7.0 (API Level 24) 开始支持 Vulkan。
本节将对 Vulkan 进行初步介绍，探讨 Vulkan 的优势和特点，以及如何在 Android NDK 中应用 Vulkan 进行图形开发。
4.3.1 Vulkan 的优势与特点 (Advantages and Features of Vulkan)
Vulkan 相对于 OpenGL ES 等传统图形 API，具有以下显著的优势和特点：
① 降低 CPU 开销 (Lower CPU Overhead)：
⚝ Vulkan 采用了更底层的 API 设计，减少了驱动程序的 CPU 开销。
⚝ Vulkan 允许应用程序进行更多的显式控制，例如内存管理、命令缓冲区管理等，减少了驱动程序的隐式操作，从而降低了 CPU 负载。
⚝ Vulkan 的命令缓冲区预先录制和多线程提交机制，可以进一步降低 CPU 开销，提高渲染效率。
② 更好的多线程支持 (Better Multi-threading Support)：
⚝ Vulkan 从设计之初就考虑了多线程并行处理。
⚝ Vulkan 允许应用程序在多个线程中并行录制命令缓冲区，然后将多个命令缓冲区同时提交到 GPU 执行。
⚝ Vulkan 的多线程支持可以充分利用多核 CPU 的性能，提高渲染效率，尤其是在复杂的场景中。
③ 更强的硬件控制能力 (Stronger Hardware Control)：
⚝ Vulkan 提供了更底层的硬件访问接口，允许应用程序更精细地控制 GPU 的行为。
⚝ Vulkan 允许应用程序进行显式的内存管理，例如分配和释放 GPU 内存、控制内存的布局和访问方式等。
⚝ Vulkan 允许应用程序直接访问 GPU 的队列 (Queue) 和命令池 (Command Pool)，进行更底层的命令提交和同步控制。
④ 显式同步 (Explicit Synchronization)：
⚝ Vulkan 强调显式同步，应用程序需要显式地管理 GPU 操作之间的同步关系。
⚝ Vulkan 提供了栅栏 (Fence)、信号量 (Semaphore)、事件 (Event) 等同步原语，用于控制 GPU 操作的执行顺序和依赖关系。
⚝ 显式同步虽然增加了开发的复杂度，但也提供了更高的灵活性和性能优化空间。
⑤ 统一的计算和图形 API (Unified Compute and Graphics API)：
⚝ Vulkan 不仅是一个图形 API，也是一个通用的计算 API。
⚝ Vulkan 可以用于进行图形渲染，也可以用于进行 GPU 计算，例如物理模拟、图像处理、机器学习等。
⚝ Vulkan 的统一 API 设计，使得开发者可以使用同一套 API 进行图形和计算任务，提高了开发效率和代码复用性。
⑥ 跨平台支持 (Cross-platform Support)：
⚝ Vulkan 是一个跨平台的 API，可以在 Android、Windows、Linux 等多个平台上使用。
⚝ Vulkan 的跨平台特性，使得开发者可以使用同一套代码库开发跨平台图形应用程序。
尽管 Vulkan 具有诸多优势，但其学习曲线也相对陡峭，开发复杂度较高。对于简单的 2D 或 3D 图形应用，OpenGL ES 可能仍然是一个更简单易用的选择。然而，对于需要极致性能和硬件控制的高性能图形应用，例如 AAA 级游戏、VR/AR 应用等，Vulkan 是更合适的选择。
4.3.2 Vulkan 在 Android NDK 中的应用 (Vulkan Application in Android NDK)
在 Android NDK 中使用 Vulkan 进行图形开发，需要进行一系列的初始化和配置工作。Vulkan 的初始化流程相对复杂，主要包括以下几个步骤：
① 创建 Vulkan 实例 (Instance)：
⚝ VkInstance 是 Vulkan 的核心对象，代表 Vulkan 库的实例。
⚝ 创建 VkInstance 需要指定应用程序信息、扩展 (Extension) 和层 (Layer) 等。
⚝ 扩展用于启用 Vulkan 的可选功能，例如交换链 (Swapchain)、调试工具等。
⚝ 层用于启用 Vulkan 的验证和调试功能，例如验证层、性能分析层等。
② 选择物理设备 (PhysicalDevice)：
⚝ VkPhysicalDevice 代表 Vulkan 的物理设备，通常对应于 GPU。
⚝ 可以枚举系统中可用的物理设备，并选择一个合适的物理设备进行后续操作。
⚝ 选择物理设备需要考虑设备的特性和功能，例如队列族 (Queue Family)、内存类型、设备扩展支持等。
③ 创建逻辑设备 (Device)：
⚝ VkDevice 代表 Vulkan 的逻辑设备，它是对物理设备的抽象和控制接口。
⚝ 创建 VkDevice 需要指定要使用的队列族、设备特性、设备扩展等。
⚝ 逻辑设备是应用程序与 Vulkan 物理设备交互的主要接口。
④ 创建队列 (Queue)：
⚝ VkQueue 代表 Vulkan 的队列，用于提交命令缓冲区到 GPU 执行。
⚝ Vulkan 物理设备通常支持多种队列族，例如图形队列、计算队列、传输队列等。
⚝ 创建逻辑设备时需要指定要创建的队列族和队列数量。
⑤ 创建交换链 (Swapchain)：
⚝ VkSwapchainKHR 是 Vulkan 的交换链，用于管理渲染表面的帧缓冲区。
⚝ 交换链负责创建和管理渲染目标图像 (Image)、呈现队列 (Present Queue) 和表面格式 (Surface Format) 等。
⚝ 在 Android 平台上，交换链通常与 ANativeWindow 关联，用于将渲染结果显示到屏幕上。
⑥ 创建图像视图 (ImageView)：
⚝ VkImageView 是 Vulkan 的图像视图，用于描述如何访问图像数据。
⚝ 图像视图可以指定图像的格式、维度、子资源范围等。
⚝ 交换链中的每个渲染目标图像都需要创建一个对应的图像视图。
⑦ 创建渲染通道 (RenderPass)：
⚝ VkRenderPass 是 Vulkan 的渲染通道，用于描述渲染过程的配置，例如附件 (Attachment)、子通道 (Subpass)、依赖关系 (Dependency) 等。
⚝ 渲染通道定义了渲染操作的流程和格式，例如颜色附件、深度附件、加载操作、存储操作等。
⑧ 创建帧缓冲区 (Framebuffer)：
⚝ VkFramebuffer 是 Vulkan 的帧缓冲区，用于绑定渲染通道的附件和图像视图。
⚝ 帧缓冲区是渲染操作的目标，它指定了渲染结果要写入到哪些图像视图中。
⚝ 交换链中的每个渲染目标图像都需要创建一个对应的帧缓冲区。
⑨ 创建命令池 (CommandPool)：
⚝ VkCommandPool 是 Vulkan 的命令池，用于分配命令缓冲区。
⚝ 命令池管理命令缓冲区的内存分配和释放。
⑩ 创建命令缓冲区 (CommandBuffer)：
⚝ VkCommandBuffer 是 Vulkan 的命令缓冲区，用于记录 GPU 命令。
⚝ 命令缓冲区记录了渲染操作的指令序列，例如绑定管线状态、设置顶点缓冲区、绘制图元等。
⚝ 命令缓冲区需要从命令池中分配。
⑪ 录制命令缓冲区 (Record CommandBuffer)：
⚝ 使用 Vulkan 命令录制函数，例如 vkCmdBeginRenderPass()、vkCmdBindPipeline()、vkCmdBindVertexBuffers()、vkCmdDraw()、vkCmdEndRenderPass() 等，将渲染命令记录到命令缓冲区中。
⑫ 提交命令缓冲区 (Submit CommandBuffer)：
⚝ 使用 vkQueueSubmit() 函数将命令缓冲区提交到队列执行。
⚝ 提交命令缓冲区后，GPU 会按照命令缓冲区中记录的指令序列执行渲染操作。
⑬ 呈现图像 (Present Image)：
⚝ 使用 vkQueuePresentKHR() 函数将渲染结果呈现到屏幕上。
⚝ 呈现图像操作通常在每一帧渲染结束后执行。
Vulkan 渲染流程代码框架 (C++)：
1
void renderFrame() {
2
// 1. 获取下一个交换链图像索引 (省略)
3
uint32_t imageIndex;
4
5
// 2. 等待帧栅栏 (省略)
6
// vkWaitForFences(...)
7
8
// 3. 重置命令缓冲区 (省略)
9
// vkResetCommandBuffer(...)
10
11
// 4. 开始命令缓冲区录制 (省略)
12
// VkCommandBufferBeginInfo beginInfo = {};
13
// vkBeginCommandBuffer(commandBuffer, &beginInfo);
14
15
// 5. 开始渲染通道 (省略)
16
// VkRenderPassBeginInfo renderPassInfo = {};
17
// vkCmdBeginRenderPass(commandBuffer, &renderPassInfo, VK_SUBPASS_CONTENTS_INLINE);
18
19
// 6. 绑定管线状态 (省略)
20
// vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, graphicsPipeline);
21
22
// 7. 绑定顶点缓冲区 (省略)
23
// VkBuffer vertexBuffers[] = {vertexBuffer};
24
// VkDeviceSize offsets[] = {0};
25
// vkCmdBindVertexBuffers(commandBuffer, 0, 1, vertexBuffers, offsets);
26
27
// 8. 绘制图元 (省略)
28
// vkCmdDraw(commandBuffer, vertexCount, 1, 0, 0);
29
30
// 9. 结束渲染通道 (省略)
31
// vkCmdEndRenderPass(commandBuffer);
32
33
// 10. 结束命令缓冲区录制 (省略)
34
// vkEndCommandBuffer(commandBuffer);
35
36
// 11. 提交命令缓冲区 (省略)
37
// VkSubmitInfo submitInfo = {};
38
// vkQueueSubmit(graphicsQueue, 1, &submitInfo, inFlightFence);
39
40
// 12. 呈现图像 (省略)
41
// VkPresentInfoKHR presentInfo = {};
42
// vkQueuePresentKHR(presentQueue, &presentInfo);
43
}
上述代码框架展示了一个基本的 Vulkan 渲染流程。Vulkan 的初始化和渲染流程比 OpenGL ES 复杂得多，需要开发者深入理解 Vulkan 的 API 和概念。Android NDK 提供了 Vulkan 的头文件和库，开发者可以使用 C/C++ 语言进行 Vulkan 开发。
4.4 图像处理库：OpenCV 与 NDK 的集成应用
OpenCV (Open Source Computer Vision Library) 是一个开源的计算机视觉和机器学习软件库。它包含了大量的图像处理和计算机视觉算法，例如图像滤波、边缘检测、特征提取、目标检测、图像分割、视频分析等。OpenCV 广泛应用于图像处理、计算机视觉、机器人、人工智能等领域。
在 Android NDK 开发中，OpenCV 可以与 NDK 集成，利用 Native 代码的高性能优势，实现高效的图像处理和计算机视觉功能。本节将介绍如何在 NDK 中集成 OpenCV，并展示一些 OpenCV 在 NDK 中的应用示例。
4.4.1 OpenCV Android SDK 集成 (OpenCV Android SDK Integration)
OpenCV 官方提供了 Android SDK，可以方便地将 OpenCV 集成到 Android 项目中。OpenCV Android SDK 包含了 Java 库和 Native 库，Java 库用于在 Java 层调用 OpenCV 功能，Native 库用于在 Native 层调用 OpenCV 功能。
在 NDK 项目中集成 OpenCV，主要需要以下步骤：
① 下载 OpenCV Android SDK：
⚝ 从 OpenCV 官网 (opencv.org) 下载 OpenCV Android SDK。
⚝ 下载完成后，解压 SDK 压缩包。
② 导入 OpenCV Native 库：
⚝ 在 NDK 项目的 CMakeLists.txt 文件中，使用 find_package(OpenCV REQUIRED) 命令查找 OpenCV 库。
⚝ 如果 CMake 无法自动找到 OpenCV 库，需要手动指定 OpenCV 的安装路径。可以使用 set(OpenCV_DIR <OpenCV SDK 路径>/sdk/native/jni) 命令设置 OpenCV_DIR 变量。
⚝ 使用 target_link_libraries(<目标库> opencv_core opencv_imgproc opencv_imgcodecs ...) 命令链接需要的 OpenCV 模块库。例如，opencv_core 是 OpenCV 核心模块库，opencv_imgproc 是图像处理模块库，opencv_imgcodecs 是图像编解码模块库。
③ 配置 AndroidManifest.xml：
⚝ 在 AndroidManifest.xml 文件中，添加 OpenCV 库的 native 库加载声明。
⚝ 可以使用 <uses-library> 标签声明使用 OpenCV 库，例如 <uses-library android:name="org.opencv.lib_v4"/>。
④ 在 Native 代码中使用 OpenCV API：
⚝ 在 Native 代码中，包含 OpenCV 的头文件，例如 #include <opencv2/core.hpp>、#include <opencv2/imgproc.hpp>、#include <opencv2/imgcodecs.hpp> 等。
⚝ 使用 OpenCV 的 C++ API 进行图像处理和计算机视觉操作。例如，可以使用 cv::Mat 类表示图像，使用 cv::cvtColor() 函数进行颜色空间转换，使用 cv::GaussianBlur() 函数进行高斯模糊，使用 cv::Canny() 函数进行边缘检测等。
CMakeLists.txt 配置示例：
1
cmake_minimum_required(VERSION 3.4.1)
2
3
find_package(OpenCV REQUIRED)
4
5
include_directories(${OpenCV_INCLUDE_DIRS})
6
7
add_library(native-lib
8
SHARED
9
src/main/cpp/native-lib.cpp)
10
11
target_link_libraries(native-lib
12
${OpenCV_LIBS}
13
log)
Native 代码示例 (C++)：
1
#include <jni.h>
2
#include <string>
3
#include <android/bitmap.h>
4
#include <opencv2/core.hpp>
5
#include <opencv2/imgproc.hpp>
6
#include <opencv2/android.h>
7
8
extern "C" JNIEXPORT void JNICALL
9
Java_com_example_ndkopencv_MainActivity_grayScale(JNIEnv *env, jobject /* this */, jobject bitmap) {
10
AndroidBitmapInfo bitmapInfo;
11
void* pixels;
12
13
AndroidBitmap_getInfo(env, bitmap, &bitmapInfo);
14
AndroidBitmap_lockPixels(env, bitmap, &pixels);
15
16
cv::Mat rgbaMat(bitmapInfo.height, bitmapInfo.width, CV_8UC4, pixels);
17
cv::Mat grayMat;
18
cv::cvtColor(rgbaMat, grayMat, cv::COLOR_RGBA2GRAY);
19
cv::cvtColor(grayMat, rgbaMat, cv::COLOR_GRAY2RGBA); // 转换回 RGBA，以便显示在 Bitmap 上
20
21
AndroidBitmap_unlockPixels(env, bitmap);
22
}
上述代码示例展示了如何在 NDK 项目中集成 OpenCV，并实现一个简单的灰度化图像处理功能。Java 层将 Bitmap 对象传递给 Native 层，Native 层使用 OpenCV 将 Bitmap 图像转换为灰度图像，并将结果写回 Bitmap 对象。
4.4.2 OpenCV 在 NDK 中的应用示例 (OpenCV Application Examples in NDK)
OpenCV 在 NDK 中可以应用于各种图像处理和计算机视觉任务，例如：
① 图像滤波与增强 (Image Filtering and Enhancement)：
⚝ 使用 OpenCV 的滤波函数，例如 cv::GaussianBlur()、cv::medianBlur()、cv::bilateralFilter() 等，对图像进行平滑、去噪、锐化等处理。
⚝ 使用 OpenCV 的直方图均衡化函数 cv::equalizeHist()，增强图像的对比度。
② 边缘检测与特征提取 (Edge Detection and Feature Extraction)：
⚝ 使用 OpenCV 的边缘检测函数，例如 cv::Canny()、cv::Sobel()、cv::Laplacian() 等，检测图像的边缘信息。
⚝ 使用 OpenCV 的特征提取算法，例如 SIFT、SURF、ORB 等，提取图像的特征点和描述符，用于图像匹配、目标识别等任务。
③ 目标检测与识别 (Object Detection and Recognition)：
⚝ 使用 OpenCV 的 Haar 特征级联分类器或深度学习模型 (例如 YOLO、SSD) 进行目标检测，识别图像中的物体。
⚝ 使用 OpenCV 的图像匹配算法，例如 BFMatcher、FlannBasedMatcher 等，进行图像匹配和目标识别。
④ 图像分割与语义理解 (Image Segmentation and Semantic Understanding)：
⚝ 使用 OpenCV 的图像分割算法，例如 Watershed 算法、GrabCut 算法等，将图像分割成不同的区域。
⚝ 结合深度学习模型，进行图像语义分割，理解图像场景的内容。
⑤ 视频分析与运动跟踪 (Video Analysis and Motion Tracking)：
⚝ 使用 OpenCV 的视频处理模块，读取和处理视频帧。
⚝ 使用 OpenCV 的运动跟踪算法，例如 MeanShift、CamShift、Optical Flow 等，跟踪视频中的运动物体。
⑥ 图像几何变换与图像配准 (Image Geometric Transformation and Image Registration)：
⚝ 使用 OpenCV 的几何变换函数，例如 cv::warpAffine()、cv::warpPerspective() 等，对图像进行旋转、缩放、平移、透视变换等操作。
⚝ 使用 OpenCV 的图像配准算法，将多张图像对齐到同一坐标系下。
通过将 OpenCV 集成到 NDK 项目中，开发者可以利用 Native 代码的高性能优势，实现各种复杂的图像处理和计算机视觉功能，为 Android 应用增加强大的视觉能力。
4.5 实战案例：基于 OpenGL ES 的 3D 游戏开发基础
OpenGL ES 在 Android 游戏开发中扮演着至关重要的角色，尤其是在 3D 游戏开发中，OpenGL ES 是实现高性能 3D 图形渲染的核心技术。本节将通过一个简单的实战案例，介绍基于 OpenGL ES 的 3D 游戏开发基础，包括 3D 模型加载、场景渲染、用户交互等。
4.5.1 3D 模型加载与渲染 (3D Model Loading and Rendering)
在 3D 游戏开发中，首先需要加载 3D 模型数据。3D 模型数据通常存储在模型文件中，例如 OBJ、FBX、glTF 等格式。模型文件包含了模型的顶点数据、法线数据、纹理坐标数据、材质信息等。
① 模型文件格式 (Model File Formats)：
⚝ OBJ (Wavefront OBJ)：一种简单的文本格式，易于解析，但功能相对简单，不支持动画和复杂材质。
⚝ FBX (Filmbox)：一种二进制格式，功能强大，支持动画、骨骼、复杂材质等，但解析较为复杂。
⚝ glTF (GL Transmission Format)：一种开放标准的 JSON 格式，专为 WebGL 和 OpenGL ES 设计，高效、轻量级，支持动画、PBR 材质等，是现代 3D 模型格式的趋势。
② 模型加载库 (Model Loading Libraries)：
⚝ Assimp (Open Asset Import Library)：一个开源的模型加载库，支持多种模型文件格式，例如 OBJ、FBX、glTF、DAE 等。Assimp 可以将模型数据加载到内存中，并提供统一的数据结构访问接口。
⚝ tinygltf：一个轻量级的 glTF 模型加载库，专注于 glTF 格式的加载，性能高效，代码简洁。
③ OpenGL ES 模型渲染流程：
⚝ 加载模型数据：使用模型加载库 (例如 Assimp 或 tinygltf) 加载模型文件，获取模型的顶点数据、索引数据、法线数据、纹理坐标数据等。
⚝ 创建顶点缓冲区对象 (VBO)：将模型的顶点数据、法线数据、纹理坐标数据上传到 GPU 缓冲区对象。
⚝ 创建索引缓冲区对象 (IBO)：如果模型使用了索引绘制，将模型的索引数据上传到 GPU 缓冲区对象。
⚝ 加载纹理：加载模型的纹理图像，创建 OpenGL ES 纹理对象，并将纹理图像数据上传到纹理对象。
⚝ 编写顶点着色器和片段着色器：编写顶点着色器和片段着色器程序，实现模型渲染的视觉效果。顶点着色器负责顶点变换，片段着色器负责像素着色。
⚝ 设置顶点属性：设置顶点属性指针，指定顶点位置、法线、纹理坐标等属性数据的格式和位置。
⚝ 设置 Uniform 变量：设置 MVP 矩阵、材质属性、光照参数、纹理单元索引等 uniform 变量。
⚝ 绘制模型：使用 glDrawArrays() 或 glDrawElements() 函数绘制模型。
简易 3D 模型渲染代码框架 (C++)：
1
void renderModel(Model* model, glm::mat4 modelMatrix, glm::mat4 viewMatrix, glm::mat4 projectionMatrix) {
2
// 1. 激活着色器程序
3
glUseProgram(modelShader->programId);
4
5
// 2. 设置 MVP 矩阵 uniform 变量
6
glm::mat4 mvpMatrix = projectionMatrix * viewMatrix * modelMatrix;
7
GLuint mvpMatrixLoc = glGetUniformLocation(modelShader->programId, "u_mvpMatrix");
8
glUniformMatrix4fv(mvpMatrixLoc, 1, GL_FALSE, glm::value_ptr(mvpMatrix));
9
10
// 3. 绑定顶点缓冲区对象
11
glBindBuffer(GL_ARRAY_BUFFER, model->vertexBuffer);
12
13
// 4. 设置顶点位置属性
14
GLuint positionLoc = glGetAttribLocation(modelShader->programId, "a_position");
15
glVertexAttribPointer(positionLoc, 3, GL_FLOAT, GL_FALSE, model->vertexStride, (void*)model->positionOffset);
16
glEnableVertexAttribArray(positionLoc);
17
18
// 5. 绑定纹理
19
glActiveTexture(GL_TEXTURE0);
20
glBindTexture(GL_TEXTURE_2D, model->textureId);
21
22
// 6. 设置纹理 uniform 变量
23
GLuint textureLoc = glGetUniformLocation(modelShader->programId, "u_texture");
24
glUniform1i(textureLoc, 0); // 使用纹理单元 0
25
26
// 7. 绘制模型 (假设使用三角形图元)
27
glDrawArrays(GL_TRIANGLES, 0, model->vertexCount);
28
}
上述代码框架展示了一个简易的 3D 模型渲染流程。实际的 3D 游戏渲染会更加复杂，需要处理材质、光照、阴影、动画、特效等。
4.5.2 场景管理与摄像机控制 (Scene Management and Camera Control)
在 3D 游戏开发中，需要管理游戏场景中的所有 3D 模型、灯光、摄像机等对象。场景管理负责组织和更新场景中的对象，摄像机控制负责控制玩家的视角。
① 场景图 (Scene Graph)：
⚝ 场景图是一种树状数据结构，用于组织和管理游戏场景中的对象。
⚝ 场景图的每个节点代表一个场景对象，例如模型、灯光、摄像机、空节点等。
⚝ 场景图的节点可以包含子节点，形成层次结构。
⚝ 场景图可以方便地进行场景对象的遍历、更新、渲染等操作。
② 摄像机 (Camera)：
⚝ 摄像机定义了玩家在游戏世界中的视角。
⚝ 摄像机通常包括位置 (Position)、目标点 (Target)、向上方向 (Up Direction)、视场角 (Field of View)、宽高比 (Aspect Ratio)、近裁剪面 (Near Plane)、远裁剪面 (Far Plane) 等参数。
⚝ 摄像机可以进行平移、旋转、缩放等操作，控制玩家的视角。
③ 摄像机控制方式：
⚝ 第一人称视角 (First-Person View)：摄像机跟随玩家的头部运动，玩家直接控制摄像机的方向和位置。
⚝ 第三人称视角 (Third-Person View)：摄像机位于玩家角色的后方或侧方，玩家控制角色移动和摄像机旋转。
⚝ 固定视角 (Fixed View)：摄像机位置和方向固定不变，例如 RTS 游戏、塔防游戏等。
④ 用户输入处理 (User Input Handling)：
⚝ 游戏需要处理用户的输入，例如触摸事件、按键事件、传感器事件等。
⚝ 用户输入可以用于控制角色移动、摄像机旋转、UI 交互等。
⚝ Android NDK 提供了 ANativeWindow_injectInputEvent() 函数，用于将输入事件注入到 NativeActivity 中。
简易摄像机控制代码框架 (C++)：
1
class Camera {
2
public:
3
glm::vec3 position;
4
glm::vec3 target;
5
glm::vec3 up;
6
float fov;
7
float aspectRatio;
8
float nearPlane;
9
float farPlane;
10
11
glm::mat4 getViewMatrix() {
12
return glm::lookAt(position, target, up);
13
}
14
15
glm::mat4 getProjectionMatrix() {
16
return glm::perspective(glm::radians(fov), aspectRatio, nearPlane, farPlane);
17
}
18
19
void update(float deltaTime) {
20
// 根据用户输入更新摄像机位置和方向
21
}
22
};
23
24
void handleTouchEvent(float x, float y) {
25
// 根据触摸事件更新摄像机控制
26
}
上述代码框架展示了一个简易的摄像机类和触摸事件处理函数。实际的游戏摄像机控制会更加复杂，需要考虑玩家的运动速度、加速度、碰撞检测、视角限制等因素。
4.5.3 简单的游戏循环 (Simple Game Loop)
游戏循环是游戏程序的核心，它负责不断地更新游戏状态、渲染游戏画面、处理用户输入等。一个简单的游戏循环通常包括以下几个步骤：
① 输入处理 (Input Handling)：
⚝ 处理用户输入事件，例如触摸事件、按键事件、传感器事件等。
⚝ 根据用户输入更新游戏状态，例如角色移动、摄像机旋转、UI 交互等。
② 游戏逻辑更新 (Game Logic Update)：
⚝ 更新游戏世界中的对象状态，例如角色位置、动画状态、物理模拟、AI 行为等。
⚝ 计算游戏逻辑，例如碰撞检测、游戏规则判断、得分计算等。
③ 渲染 (Rendering)：
⚝ 清除缓冲区。
⚝ 设置摄像机视口。
⚝ 遍历场景图，渲染场景中的所有对象。
⚝ 交换缓冲区，显示渲染结果。
④ 帧率控制 (Frame Rate Control)：
⚝ 控制游戏循环的帧率，保证游戏运行的流畅性。
⚝ 可以使用时间函数计算帧时间，并根据目标帧率进行延迟等待。
简易游戏循环代码框架 (C++)：
1
void gameLoop() {
2
long lastFrameTime = getCurrentTimeMillis();
3
4
while (isRunning) {
5
long currentFrameTime = getCurrentTimeMillis();
6
float deltaTime = (currentFrameTime - lastFrameTime) / 1000.0f; // 计算帧时间 (秒)
7
lastFrameTime = currentFrameTime;
8
9
// 1. 输入处理
10
handleInput();
11
12
// 2. 游戏逻辑更新
13
updateGameLogic(deltaTime);
14
15
// 3. 渲染
16
renderFrame();
17
18
// 4. 帧率控制 (例如目标帧率 60 FPS)
19
long frameDuration = getCurrentTimeMillis() - currentFrameTime;
20
long targetFrameDuration = 1000 / 60; // 16.67 毫秒
21
if (frameDuration < targetFrameDuration) {
22
sleep(targetFrameDuration - frameDuration); // 延迟等待
23
}
24
}
25
}
上述代码框架展示了一个简易的游戏循环。实际的游戏循环会更加复杂，需要处理游戏状态管理、资源加载、音频播放、网络通信等。
通过本节的实战案例，我们初步了解了基于 OpenGL ES 的 3D 游戏开发基础。3D 游戏开发是一个复杂而庞大的领域，需要开发者掌握图形学、游戏引擎、编程语言、数学等多种知识和技能。OpenGL ES 作为 Android 平台主要的图形 API，是进行高性能 3D 游戏开发的关键技术。
ENDOF_CHAPTER_
5. chapter 5： NDK 音频开发：OpenSL ES 与 AAudio
5.1 OpenSL ES 基础：音频引擎、音频播放器与录音器
OpenSL ES（Open Sound Library for Embedded Systems）是一个 Khronos Group 定义的跨平台音频 API，旨在为嵌入式系统提供高性能、低延迟的音频功能。在 Android NDK 开发中，OpenSL ES 允许开发者直接使用 C/C++ 代码来处理音频，从而绕过 Java 层，实现更精细的音频控制和更低的延迟，这对于对音频实时性要求高的应用，如游戏、实时音频处理、乐器应用等至关重要。
OpenSL ES 的核心概念围绕着对象（Object）和接口（Interface）。对象代表了音频系统的各种组件，例如音频引擎、播放器、录音器等，而接口则定义了如何操作这些对象。通过获取对象的接口，开发者可以控制音频的播放、录制、音量调节等功能。
OpenSL ES 中最核心的几个组件包括：
⚝ 音频引擎（Audio Engine）：
⚝ 音频引擎是 OpenSL ES 的入口点，也是所有其他对象的工厂。
⚝ 它负责初始化和管理底层的音频系统资源。
⚝ 在开始使用 OpenSL ES 的任何功能之前，都必须首先创建并初始化音频引擎。
⚝ 一个应用通常只需要创建一个音频引擎实例。
⚝ 音频播放器（Audio Player）：
⚝ 音频播放器用于播放音频数据。
⚝ 它可以从多种数据源读取音频数据，例如：
① URI 数据源：从文件路径或网络 URL 读取音频文件。
② 缓冲区队列数据源（Buffer Queue Data Source）：从内存缓冲区中读取音频数据，适用于实时生成或处理的音频数据。
③ MIME 数据源： 用于播放特定的 MIME 类型的音频数据。
⚝ 音频播放器提供了诸如播放、暂停、停止、循环播放、音量控制等接口，允许开发者灵活控制音频播放行为。
⚝ 音频录音器（Audio Recorder）：
⚝ 音频录音器用于录制音频数据。
⚝ 它可以将录制到的音频数据写入到：
① URI 数据接收器：将录音数据保存到文件中。
② 缓冲区队列数据接收器（Buffer Queue Data Sink）：将录音数据写入到内存缓冲区中，适用于实时音频处理或传输。
⚝ 音频录音器提供了开始录音、停止录音、暂停录音等接口，以及获取录音数据的回调机制。
⚝ 混音器（Mixer）：
⚝ 混音器用于将多个音频源混合成一个输出。
⚝ 在复杂的音频应用中，可能需要同时播放背景音乐、特效音效等多个音频源，这时就需要使用混音器将它们混合在一起。
⚝ OpenSL ES 允许创建多个混音器，并可以配置混音器的输出路由。
⚝ 效果器（Effect）：
⚝ OpenSL ES 支持音频效果器，例如混响（Reverb）、均衡器（Equalizer）、音调控制（Preset Reverb）等。
⚝ 通过添加和配置效果器，可以为音频播放和录制添加各种音频效果，提升用户体验。
理解这些核心组件及其相互关系是掌握 OpenSL ES 的基础。在实际开发中，通常会先创建音频引擎，然后根据需求创建播放器、录音器、混音器等对象，并获取相应的接口进行操作，从而实现各种复杂的音频功能。OpenSL ES 的对象和接口设计模式，使得音频处理流程模块化且易于扩展，为 NDK 音频开发提供了强大的工具。
5.2 OpenSL ES 在 NDK 中的应用：音频播放与录制流程
在 Android NDK 中使用 OpenSL ES 进行音频开发，主要涉及音频播放和录制两个核心场景。下面分别详细介绍其流程：
音频播放流程：
- 创建音频引擎 (Audio Engine)：
▮▮▮▮⚝ 首先，需要创建 OpenSL ES 的音频引擎对象，这是所有后续操作的基础。
▮▮▮▮⚝ 通过slCreateEngine()函数创建引擎对象，并使用(*slEngineEngine)->Realize()函数实现引擎对象。
▮▮▮▮⚝ 获取引擎对象的SL_IID_ENGINE接口，用于创建其他对象。
1
SLObjectItf engineObject;
2
SLEngineItf engineEngine;
3
SLresult result;
4
5
// 创建引擎对象
6
result = slCreateEngine(&engineObject, 0, NULL, 0, NULL, NULL);
7
assert(SL_RESULT_SUCCESS == result);
8
9
// 实现引擎对象
10
result = (*engineObject)->Realize(engineObject, SL_BOOLEAN_FALSE);
11
assert(SL_RESULT_SUCCESS == result);
12
13
// 获取引擎接口
14
result = (*engineObject)->GetInterface(engineObject, SL_IID_ENGINE, &engineEngine);
15
assert(SL_RESULT_SUCCESS == result);
- 创建混音器 (Output Mixer)：
▮▮▮▮⚝ 创建一个混音器对象，作为音频播放器的最终输出目标。
▮▮▮▮⚝ 通过引擎接口(*engineEngine)->CreateOutputMix()创建混音器对象，并实现它。
▮▮▮▮⚝ 获取混音器对象的SL_IID_OUTPUTMIX接口（虽然通常不直接使用，但对象本身是需要的）。
1
SLObjectItf outputMixObject;
2
SLOutputMixItf outputMix;
3
4
// 创建混音器对象
5
result = (*engineEngine)->CreateOutputMix(engineEngine, &outputMixObject, 0, 0, 0);
6
assert(SL_RESULT_SUCCESS == result);
7
8
// 实现混音器对象
9
result = (*outputMixObject)->Realize(outputMixObject, SL_BOOLEAN_FALSE);
10
assert(SL_RESULT_SUCCESS == result);
- 配置音频数据源 (Audio Source)：
▮▮▮▮⚝ 根据音频数据的来源选择合适的数据源配置。
▮▮▮▮⚝ 例如，从 assets 目录或文件系统中读取音频文件，通常使用 URI 数据源。
▮▮▮▮⚝ 对于实时生成的音频数据，可以使用缓冲区队列数据源。
▮▮▮▮URI 数据源配置示例：
1
SLDataLocator_URI loc_uri = {SL_DATALOCATOR_URI, (SLchar *) uri}; // uri 为音频文件路径
2
SLDataFormat_MIME format_mime = {SL_DATAFORMAT_MIME, NULL, SL_CONTAINERTYPE_UNSPECIFIED};
3
SLDataSource audioSrc = {&loc_uri, &format_mime};
▮▮▮▮缓冲区队列数据源配置示例：
1
SLDataLocator_BufferQueue loc_bq = {SL_DATALOCATOR_BUFFERQUEUE, 2}; // 缓冲区数量
2
SLDataFormat_PCM format_pcm = { // PCM 数据格式
3
SL_DATAFORMAT_PCM,
4
2, // 声道数
5
SL_SAMPLINGRATE_44_1, // 采样率
6
SL_PCMSAMPLEFORMAT_FIXED_16, // 采样格式
7
SL_PCMSAMPLEFORMAT_FIXED_16,
8
SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT, // 声道布局
9
SL_BYTEORDER_LITTLEENDIAN
10
};
11
SLDataSource audioSrc = {&loc_bq, &format_pcm};
- 配置音频接收器 (Audio Sink)：
▮▮▮▮⚝ 音频接收器指定音频数据输出的目标，通常是混音器。
▮▮▮▮⚝ 使用SLDataLocator_OutputMix配置音频接收器，指向之前创建的混音器对象。
1
SLDataLocator_OutputMix loc_outmix = {SL_DATALOCATOR_OUTPUTMIX, outputMixObject};
2
SLDataSink audioSnk = {&loc_outmix, NULL};
- 创建音频播放器 (Audio Player)：
▮▮▮▮⚝ 使用引擎接口(*engineEngine)->CreateAudioPlayer()创建音频播放器对象。
▮▮▮▮⚝ 传入配置好的音频数据源和接收器，以及需要的接口 ID 列表。
▮▮▮▮⚝ 实现播放器对象，并获取SL_IID_PLAY接口，用于控制播放。
▮▮▮▮⚝ 如果使用缓冲区队列数据源，还需要获取SL_IID_BUFFERQUEUE接口，用于管理缓冲区队列。
1
SLObjectItf playerObject = NULL;
2
SLPlayItf playerPlay;
3
SLBufferQueueItf playerBufferQueue;
4
const SLInterfaceID playerIIDs[] = {SL_IID_PLAY, SL_IID_BUFFERQUEUE}; // 需要的接口
5
const SLboolean playerReqs[] = {SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE};
6
7
// 创建播放器对象
8
result = (*engineEngine)->CreateAudioPlayer(engineEngine, &playerObject, &audioSrc, &audioSnk,
9
2, playerIIDs, playerReqs);
10
assert(SL_RESULT_SUCCESS == result);
11
12
// 实现播放器对象
13
result = (*playerObject)->Realize(playerObject, SL_BOOLEAN_FALSE);
14
assert(SL_RESULT_SUCCESS == result);
15
16
// 获取播放接口
17
result = (*playerObject)->GetInterface(playerObject, SL_IID_PLAY, &playerPlay);
18
assert(SL_RESULT_SUCCESS == result);
19
20
// 获取缓冲区队列接口 (如果使用缓冲区队列数据源)
21
result = (*playerObject)->GetInterface(playerObject, SL_IID_BUFFERQUEUE, &playerBufferQueue);
22
assert(SL_RESULT_SUCCESS == result);
- 设置播放状态并播放 (Set Play State)：
▮▮▮▮⚝ 通过播放接口(*playerPlay)->SetPlayState()设置播放器的状态，开始、暂停或停止播放。
▮▮▮▮⚝SL_PLAYSTATE_PLAYING开始播放，SL_PLAYSTATE_PAUSED暂停，SL_PLAYSTATE_STOPPED停止。
1
// 开始播放
2
result = (*playerPlay)->SetPlayState(playerPlay, SL_PLAYSTATE_PLAYING);
3
assert(SL_RESULT_SUCCESS == result);
- 缓冲区队列管理 (Buffer Queue Management，针对缓冲区队列数据源)：
▮▮▮▮⚝ 如果使用缓冲区队列数据源，需要注册回调函数，当缓冲区播放完成时，OpenSL ES 会回调该函数，开发者需要在回调函数中填充新的音频数据到缓冲区队列中，实现连续播放。
▮▮▮▮⚝ 使用(*playerBufferQueue)->RegisterCallback()注册回调函数，并使用(*playerBufferQueue)->Enqueue()将音频数据放入缓冲区队列。
1
// 缓冲区队列回调函数
2
void bqPlayerCallback(SLBufferQueueItf bq, void *context) {
3
// ... 填充新的音频数据到缓冲区 ...
4
SLresult result;
5
result = (*bq)->Enqueue(bq, newData, newDataSize); // newData 为新的音频数据，newDataSize 为数据大小
6
assert(SL_RESULT_SUCCESS == result);
7
}
8
9
// 注册缓冲区队列回调函数
10
result = (*playerBufferQueue)->RegisterCallback(playerBufferQueue, bqPlayerCallback, NULL);
11
assert(SL_RESULT_SUCCESS == result);
12
13
// 首次入队音频数据
14
result = (*playerBufferQueue)->Enqueue(playerBufferQueue, initialData, initialDataSize);
15
assert(SL_RESULT_SUCCESS == result);
- 资源释放 (Resource Release)：
▮▮▮▮⚝ 在不再需要音频播放器时，需要释放相关资源，防止内存泄漏。
▮▮▮▮⚝ 依次销毁播放器对象、混音器对象和引擎对象。
1
if (playerObject != NULL) {
2
(*playerObject)->Destroy(playerObject);
3
playerObject = NULL;
4
playerPlay = NULL;
5
playerBufferQueue = NULL;
6
}
7
if (outputMixObject != NULL) {
8
(*outputMixObject)->Destroy(outputMixObject);
9
outputMixObject = NULL;
10
outputMix = NULL;
11
}
12
if (engineObject != NULL) {
13
(*engineObject)->Destroy(engineObject);
14
engineObject = NULL;
15
engineEngine = NULL;
16
}
音频录制流程：
音频录制流程与播放流程类似，主要步骤如下：
- 创建音频引擎 (Audio Engine)：与播放流程相同。
- 创建混音器 (Output Mixer)：与播放流程相同（虽然录制流程中混音器不是直接必需的，但在某些复杂的录制场景中可能会用到，为了代码结构一致性，可以先创建）。
- 配置音频数据源 (Audio Source)：
▮▮▮▮⚝ 对于录音，数据源是麦克风。
▮▮▮▮⚝ 使用SLDataLocator_IODevice配置 I/O 设备数据定位器，指定输入设备为麦克风。
▮▮▮▮⚝ 配置 PCM 数据格式，与播放流程中的缓冲区队列数据源配置类似。
1
SLDataLocator_IODevice loc_dev = {SL_DATALOCATOR_IODEVICE, SL_IODEVICE_AUDIOINPUT, SL_IODEVICE_DEFAULT};
2
SLDataSource audioSrc = {&loc_dev, &format_pcm}; // format_pcm 为 PCM 数据格式配置
- 配置音频接收器 (Audio Sink)：
▮▮▮▮⚝ 音频接收器指定录音数据输出的目标。
▮▮▮▮⚝ 通常使用缓冲区队列数据接收器，将录音数据写入到内存缓冲区中，以便后续处理。
1
SLDataLocator_BufferQueue loc_bq_sink = {SL_DATALOCATOR_BUFFERQUEUE, 2}; // 缓冲区数量
2
SLDataSink audioSnk = {&loc_bq_sink, &format_pcm}; // format_pcm 与数据源的 PCM 格式一致
- 创建音频录音器 (Audio Recorder)：
▮▮▮▮⚝ 使用引擎接口(*engineEngine)->CreateAudioRecorder()创建音频录音器对象。
▮▮▮▮⚝ 传入配置好的音频数据源和接收器，以及需要的接口 ID 列表。
▮▮▮▮⚝ 实现录音器对象，并获取SL_IID_RECORD接口，用于控制录音。
▮▮▮▮⚝ 获取SL_IID_BUFFERQUEUE接口，用于管理缓冲区队列，接收录音数据。
1
SLObjectItf recorderObject = NULL;
2
SLRecordItf recorderRecord;
3
SLBufferQueueItf recorderBufferQueue;
4
const SLInterfaceID recorderIIDs[] = {SL_IID_RECORD, SL_IID_BUFFERQUEUE};
5
const SLboolean recorderReqs[] = {SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE};
6
7
// 创建录音器对象
8
result = (*engineEngine)->CreateAudioRecorder(engineEngine, &recorderObject, &audioSrc, &audioSnk,
9
2, recorderIIDs, recorderReqs);
10
assert(SL_RESULT_SUCCESS == result);
11
12
// 实现录音器对象
13
result = (*recorderObject)->Realize(recorderObject, SL_BOOLEAN_FALSE);
14
assert(SL_RESULT_SUCCESS == result);
15
16
// 获取录音接口
17
result = (*recorderObject)->GetInterface(recorderObject, SL_IID_RECORD, &recorderRecord);
18
assert(SL_RESULT_SUCCESS == result);
19
20
// 获取缓冲区队列接口
21
result = (*recorderObject)->GetInterface(recorderObject, SL_IID_BUFFERQUEUE, &recorderBufferQueue);
22
assert(SL_RESULT_SUCCESS == result);
- 设置录音状态并开始录音 (Set Record State)：
▮▮▮▮⚝ 通过录音接口(*recorderRecord)->SetRecordState()设置录音器的状态，开始、暂停或停止录音。
▮▮▮▮⚝SL_RECORDSTATE_RECORDING开始录音，SL_RECORDSTATE_PAUSED暂停，SL_RECORDSTATE_STOPPED停止。
1
// 开始录音
2
result = (*recorderRecord)->SetRecordState(recorderRecord, SL_RECORDSTATE_RECORDING);
3
assert(SL_RESULT_SUCCESS == result);
- 缓冲区队列管理 (Buffer Queue Management)：
▮▮▮▮⚝ 注册缓冲区队列回调函数，当缓冲区被填满录音数据时，OpenSL ES 会回调该函数，开发者需要在回调函数中处理录音数据，并清空缓冲区，以便接收新的录音数据。
▮▮▮▮⚝ 使用(*recorderBufferQueue)->RegisterCallback()注册回调函数，并在回调函数中使用(*recorderBufferQueue)->Dequeue()获取录音数据。
1
// 缓冲区队列回调函数
2
void bqRecorderCallback(SLBufferQueueItf bq, void *context) {
3
SLAndroidBufferQueueItf abq = (SLAndroidBufferQueueItf)bq;
4
void *data;
5
SLuint32 dataSize;
6
SLuint32 itemsEnqueued;
7
SLresult result;
8
9
// 出队缓冲区，获取录音数据
10
result = (*abq)->GetBuffer(abq, &itemsEnqueued, &data, &dataSize, NULL, NULL);
11
assert(SL_RESULT_SUCCESS == result);
12
13
// ... 处理录音数据 data，数据大小为 dataSize ...
14
15
// 清空缓冲区，准备接收新的数据
16
result = (*bq)->Clear(bq);
17
assert(SL_RESULT_SUCCESS == result);
18
19
// 重新入队一个空缓冲区，以便继续录音
20
result = (*bq)->Enqueue(bq, emptyBuffer, bufferSize); // emptyBuffer 为预先分配的空缓冲区，bufferSize 为缓冲区大小
21
assert(SL_RESULT_SUCCESS == result);
22
}
23
24
// 注册缓冲区队列回调函数
25
result = (*recorderBufferQueue)->RegisterCallback(recorderBufferQueue, bqRecorderCallback, NULL);
26
assert(SL_RESULT_SUCCESS == result);
27
28
// 首次入队一个空缓冲区，用于接收录音数据
29
result = (*recorderBufferQueue)->Enqueue(recorderBufferQueue, emptyBuffer, bufferSize);
30
assert(SL_RESULT_SUCCESS == result);
- 资源释放 (Resource Release)：与播放流程相同，释放录音器对象、混音器对象和引擎对象。
以上流程概述了 OpenSL ES 在 NDK 中进行音频播放和录制的基本步骤。实际应用中，可能还需要处理错误、进行更精细的参数配置、添加音频效果等。理解这些基本流程是进行更复杂音频开发的基础。
5.3 AAudio 介绍：Android 高性能音频 API
AAudio（Android Audio）是 Android 8.0 (API Level 26) 引入的高性能音频 API，旨在解决 OpenSL ES 在某些方面存在的不足，并提供更低延迟、更易用的音频开发体验。AAudio 被设计为替代 OpenSL ES 的现代音频解决方案，尤其适用于对延迟敏感的应用，如实时乐器、高性能游戏、专业音频应用等。
AAudio 的主要特点和优势：
⚝ 更低的延迟 (Lower Latency)：
⚝ AAudio 从架构上进行了优化，减少了音频数据在 Android 音频系统中的处理环节，从而实现了更低的音频延迟。
⚝ 它采用了独占模式（Exclusive Mode），允许应用直接访问音频硬件资源，绕过混音器等中间层，进一步降低延迟。
⚝ AAudio 还支持回调模式（Callback Mode），应用可以注册回调函数，由系统在需要音频数据时主动调用，避免了轮询等待，提高了效率并降低了延迟。
⚝ 更简洁易用的 API (Simpler API)：
⚝ 相比 OpenSL ES 复杂的对象和接口体系，AAudio 提供了更简洁、更现代的 C++ API。
⚝ AAudio 的 API 设计更符合现代 C++ 编程风格，例如使用了 Builder 模式来配置音频流，使得代码更易读、易维护。
⚝ AAudio 的错误处理机制也更加清晰，使用 aaudio_result_t 枚举类型返回错误码，方便开发者进行错误检查和处理。
⚝ 更好的性能 (Better Performance)：
⚝ AAudio 针对高性能音频应用进行了优化，在 CPU 占用、内存使用等方面都表现更佳。
⚝ 独占模式的使用减少了系统混音的开销，降低了 CPU 负载。
⚝ 回调模式避免了不必要的线程切换和同步开销，提高了音频处理效率。
⚝ 现代音频特性支持 (Modern Audio Features)：
⚝ AAudio 更好地支持了现代音频特性，例如高采样率、多声道音频、浮点数音频格式等。
⚝ 它对音频格式的兼容性更好，可以处理更广泛的音频数据。
AAudio 的核心概念：
⚝ 音频流 (Audio Stream)：
⚝ AAudio 的核心是音频流（AAudioStream），代表了音频数据的输入或输出通道。
⚝ 一个 AAudio 应用通常会创建一个或多个音频流，用于播放音频或录制音频。
⚝ 音频流可以是输出流（Output Stream），用于播放音频到扬声器或耳机；也可以是输入流（Input Stream），用于从麦克风录制音频。
⚝ 流构建器 (Stream Builder)：
⚝ AAudio 使用流构建器（AAudioStreamBuilder）来配置和创建音频流。
⚝ 通过流构建器，可以设置音频流的各种参数，例如：
① 方向 (Direction)：输入流或输出流。
② 格式 (Format)：采样格式（例如 AAUDIO_FORMAT_PCM_FLOAT, AAUDIO_FORMAT_PCM_I16）、声道数、采样率等。
③ 性能模式 (Performance Mode)：低延迟模式（AAUDIO_PERFORMANCE_MODE_LOW_LATENCY）或功率节省模式（AAUDIO_PERFORMANCE_MODE_NONE）。
④ 共享模式 (Sharing Mode)：独占模式（AAUDIO_SHARING_MODE_EXCLUSIVE）或共享模式（AAUDIO_SHARING_MODE_SHARED）。
⑤ 回调 (Callback)：注册回调函数，用于音频数据处理。
⚝ 回调函数 (Callback Function)：
⚝ 在回调模式下，AAudio 使用回调函数来处理音频数据。
⚝ 对于输出流，系统会定期调用数据请求回调函数（Data Callback），应用需要在回调函数中填充音频数据到缓冲区中。
⚝ 对于输入流，系统会定期调用数据可用回调函数（Error Callback），应用需要在回调函数中从缓冲区读取录音数据。
⚝ AAudio 还支持错误回调函数（Error Callback），用于处理音频流的错误事件。
AAudio 的基本使用流程：
- 创建流构建器 (Create Stream Builder)：
▮▮▮▮⚝ 使用AAudioStreamBuilder_openStream()函数创建一个流构建器对象。
1
AAudioStreamBuilder *builder;
2
aaudio_result_t result = AAudioStreamBuilder_allocate(&builder);
3
if (result != AAUDIO_OK) {
4
// 处理错误
5
}
- 配置流参数 (Configure Stream Parameters)：
▮▮▮▮⚝ 使用流构建器 API 设置音频流的各种参数，例如方向、格式、性能模式、共享模式、回调函数等。
1
// 设置输出流
2
AAudioStreamBuilder_setDirection(builder, AAUDIO_DIRECTION_OUTPUT);
3
// 设置格式
4
AAudioStreamBuilder_setFormat(builder, AAUDIO_FORMAT_PCM_FLOAT);
5
AAudioStreamBuilder_setChannelCount(builder, 2);
6
AAudioStreamBuilder_setSampleRate(builder, 48000);
7
// 设置性能模式为低延迟
8
AAudioStreamBuilder_setPerformanceMode(builder, AAUDIO_PERFORMANCE_MODE_LOW_LATENCY);
9
// 设置共享模式为独占
10
AAudioStreamBuilder_setSharingMode(builder, AAUDIO_SHARING_MODE_EXCLUSIVE);
11
// 设置数据回调函数
12
AAudioStreamBuilder_setDataCallback(builder, dataCallback, userData);
13
// 设置错误回调函数
14
AAudioStreamBuilder_setErrorCallback(builder, errorCallback, userData);
- 打开音频流 (Open Audio Stream)：
▮▮▮▮⚝ 使用AAudioStreamBuilder_openStream()函数打开音频流，创建AAudioStream对象。
1
AAudioStream *stream;
2
result = AAudioStreamBuilder_openStream(builder, &stream);
3
if (result != AAUDIO_OK) {
4
// 处理错误
5
}
- 启动音频流 (Start Audio Stream)：
▮▮▮▮⚝ 使用AAudioStream_requestStart()函数启动音频流，开始音频数据传输。
1
result = AAudioStream_requestStart(stream);
2
if (result != AAUDIO_OK) {
3
// 处理错误
4
}
- 数据回调处理 (Data Callback Handling)：
▮▮▮▮⚝ 对于输出流，在数据回调函数dataCallback中，填充音频数据到AAudioStream_getData()提供的缓冲区中。
▮▮▮▮⚝ 对于输入流，在数据回调函数dataCallback中，从AAudioStream_getData()提供的缓冲区中读取录音数据。
1
aaudio_data_callback_result_t dataCallback(AAudioStream *stream, void *userData,
2
void *audioData, int32_t numFrames) {
3
// ... 生成或读取音频数据 ...
4
// 将音频数据写入到 audioData 缓冲区 (输出流) 或从 audioData 缓冲区读取数据 (输入流)
5
return AAUDIO_CALLBACK_RESULT_CONTINUE; // 返回继续，表示需要更多数据
6
}
- 停止和关闭音频流 (Stop and Close Audio Stream)：
▮▮▮▮⚝ 在不再需要音频流时，使用AAudioStream_requestStop()停止音频流，并使用AAudioStream_close()关闭音频流，释放资源。
1
AAudioStream_requestStop(stream);
2
AAudioStream_close(stream);
3
AAudioStreamBuilder_delete(builder); // 释放构建器
AAudio 与 OpenSL ES 的对比：
| 特性 | AAudio | OpenSL ES |
|---|---|---|
| API 设计 | 现代 C++ API，更简洁易用 | C 风格 API，对象和接口体系，较为复杂 |
| 延迟 | 更低，尤其在独占模式下 | 相对较高，受系统混音影响 |
| 性能 | 更优，CPU 占用和内存使用更低 | 相对较高 |
| 易用性 | 更容易上手，文档更清晰 | 学习曲线较陡峭，文档相对分散 |
| 平台兼容性 | Android 8.0+ (API Level 26+) | Android 2.3+ (API Level 9+) |
| 功能特性 | 专注于低延迟高性能音频，特性相对精简 | 功能更全面，支持更多音频效果和特性 |
| 适用场景 | 对延迟敏感的应用，高性能音频应用 | 兼容性要求高，功能需求全面的音频应用 |
总结：
AAudio 是 Android 平台上更现代、更高效的音频 API，特别适合对音频延迟有严格要求的应用。如果你的应用目标平台是 Android 8.0 及以上，并且追求最低的音频延迟和最佳的性能，那么 AAudio 是更优的选择。如果需要兼容更老的 Android 版本，或者需要使用 OpenSL ES 提供的更丰富的功能特性（例如更全面的音频效果器），则可以考虑使用 OpenSL ES。在实际开发中，可以根据应用的具体需求和目标平台，选择合适的音频 API。
5.4 音频处理库：FFmpeg 与 NDK 的集成应用
FFmpeg 是一个开源的多媒体框架，功能强大且应用广泛，几乎可以处理所有主流的音频和视频格式。在 Android NDK 开发中，FFmpeg 可以被集成进来，用于实现各种复杂的音频处理任务，例如：
⚝ 音频解码与编码 (Audio Decoding and Encoding)：
⚝ FFmpeg 支持解码几乎所有常见的音频格式，例如 MP3, AAC, FLAC, Vorbis, Opus 等。
⚝ 它也支持将音频编码成各种格式，方便进行音频格式转换和压缩。
⚝ 音频格式转换 (Audio Format Conversion)：
⚝ 利用 FFmpeg 可以轻松实现音频格式之间的转换，例如将 MP3 转换为 AAC，将 WAV 转换为 FLAC 等。
⚝ 可以转换音频的采样率、声道数、采样格式等参数。
⚝ 音频混音与合成 (Audio Mixing and Synthesis)：
⚝ FFmpeg 提供了强大的混音功能，可以将多个音频流混合成一个音频流。
⚝ 可以合成音频，例如将背景音乐和人声合成在一起。
⚝ 音频滤镜与效果处理 (Audio Filtering and Effects)：
⚝ FFmpeg 提供了丰富的音频滤镜，可以实现各种音频效果处理，例如均衡器、混响、降噪、音调调整、速度调整等。
⚝ 可以对音频进行各种增强和优化处理。
⚝ 音频流处理 (Audio Streaming)：
⚝ FFmpeg 可以处理音频流数据，例如从网络流中解码音频，或者将音频编码后推送到网络流。
⚝ 适用于音频直播、在线音乐播放等场景。
将 FFmpeg 集成到 Android NDK 项目的步骤：
下载 FFmpeg 源码 (Download FFmpeg Source Code)：
▮▮▮▮⚝ 访问 FFmpeg 官网 https://ffmpeg.org/download.html 下载 FFmpeg 源码包。
▮▮▮▮⚝ 选择合适的版本下载，通常选择稳定版本 (Stable release)。配置编译选项 (Configure Build Options)：
▮▮▮▮⚝ FFmpeg 提供了 configure 脚本用于配置编译选项。
▮▮▮▮⚝ 需要根据 Android NDK 的环境和目标架构，配置交叉编译选项。
▮▮▮▮⚝ 常用的配置选项包括：
①--prefix=安装目录：指定 FFmpeg 安装目录，例如--prefix=./ffmpeg_build。
②--enable-cross-compile：启用交叉编译。
③--target-os=android：指定目标操作系统为 Android。
④--arch=架构：指定目标架构，例如--arch=armv7-a,--arch=arm64,--arch=x86,--arch=x86_64。
⑤--cc=编译器：指定 C 编译器，例如--cc=clang。
⑥--cxx=C++编译器：指定 C++ 编译器，例如--cxx=clang++。
⑦--sysroot=NDK sysroot 路径：指定 NDK sysroot 路径，例如--sysroot=$NDK_PATH/sysroot。
⑧--extra-cflags=C 编译 flags：添加额外的 C 编译 flags，例如--extra-cflags="-I$NDK_PATH/sysroot/usr/include -D__ANDROID_API__=$API_LEVEL"。
⑨--extra-ldflags=链接 flags：添加额外的链接 flags，例如--extra-ldflags="-L$NDK_PATH/sysroot/usr/lib"。
⑩--disable-programs：禁用编译 FFmpeg 工具程序（例如 ffmpeg, ffprobe 等，通常 NDK 开发不需要这些工具）。
⑪--disable-doc：禁用生成文档。
⑫--disable-static：禁用编译静态库（通常 NDK 开发使用动态库）。
⑬--enable-shared：启用编译共享库。
⑭--enable-jni(可选)：如果需要编译 FFmpeg 的 JNI 接口，可以启用此选项。
▮▮▮▮⚝ 示例配置脚本 (build_ffmpeg.sh)：
1
#!/bin/bash
2
3
NDK_PATH=/path/to/your/ndk # 替换为你的 NDK 路径
4
API_LEVEL=26 # 目标 API Level
5
ARCH=arm64-v8a # 目标架构，例如 arm64-v8a, armeabi-v7a, x86_64, x86
6
OUTPUT_DIR=./ffmpeg_build_${ARCH} # 输出目录
7
8
mkdir -p ${OUTPUT_DIR}
9
10
./configure --prefix=${OUTPUT_DIR} --enable-cross-compile --target-os=android --arch=aarch64 --cc=${NDK_PATH}/toolchains/llvm/prebuilt/linux-x86_64/bin/clang --cxx=${NDK_PATH}/toolchains/llvm/prebuilt/linux-x86_64/bin/clang++ --sysroot=${NDK_PATH}/sysroot --extra-cflags="-I${NDK_PATH}/sysroot/usr/include -D__ANDROID_API__=${API_LEVEL}" --extra-ldflags="-L${NDK_PATH}/sysroot/usr/lib" --disable-programs --disable-doc --disable-static --enable-shared --enable-jni # 可选，如果需要 JNI 接口
11
12
make -j$(nproc)
13
make install
▮▮▮▮⚝ 注意：需要根据实际 NDK 路径、API Level 和目标架构修改脚本中的变量。
编译 FFmpeg (Compile FFmpeg)：
▮▮▮▮⚝ 在 FFmpeg 源码目录下，运行make -j$(nproc)命令进行编译。-j$(nproc)可以利用多核 CPU 加速编译。安装 FFmpeg (Install FFmpeg)：
▮▮▮▮⚝ 编译完成后，运行make install命令将编译好的 FFmpeg 库和头文件安装到配置的安装目录 (--prefix指定的目录)。在 Android NDK 项目中集成 FFmpeg：
▮▮▮▮⚝ 将编译好的 FFmpeg 库文件 (通常在安装目录的lib目录下，例如libavcodec.so,libavformat.so,libavutil.so等) 复制到 Android NDK 项目的jniLibs目录下，根据不同的 CPU 架构放置到对应的子目录 (例如jniLibs/arm64-v8a,jniLibs/armeabi-v7a等)。
▮▮▮▮⚝ 将 FFmpeg 头文件 (通常在安装目录的include目录下) 复制到 NDK 项目的cpp或jni目录下，或者配置 CMake 或 ndk-build 的头文件搜索路径，指向 FFmpeg 头文件目录。
▮▮▮▮⚝ 在 CMakeLists.txt 或 Android.mk 文件中，链接 FFmpeg 库。
▮▮▮▮CMakeLists.txt 示例：
1
cmake_minimum_required(VERSION 3.4.1)
2
3
add_library(native-lib
4
SHARED
5
src/main/cpp/native-lib.cpp )
6
7
# 指定 FFmpeg 头文件目录
8
include_directories(src/main/cpp/ffmpeg_include)
9
10
# 链接 FFmpeg 库
11
target_link_libraries(native-lib
12
${CMAKE_SOURCE_DIR}/src/main/jniLibs/${ANDROID_ABI}/libavcodec.so
13
${CMAKE_SOURCE_DIR}/src/main/jniLibs/${ANDROID_ABI}/libavformat.so
14
${CMAKE_SOURCE_DIR}/src/main/jniLibs/${ANDROID_ABI}/libavutil.so
15
# ... 其他需要的 FFmpeg 库 ...
16
)
▮▮▮▮Android.mk 示例：
1
LOCAL_PATH := $(call my-dir)
2
3
include $(CLEAR_VARS)
4
5
LOCAL_MODULE := native-lib
6
LOCAL_SRC_FILES := native-lib.cpp
7
LOCAL_LDLIBS := -llog -lz -lm
8
9
# 指定 FFmpeg 头文件目录
10
LOCAL_C_INCLUDES := $(LOCAL_PATH)/ffmpeg_include
11
12
# 链接 FFmpeg 库
13
LOCAL_SHARED_LIBRARIES := libavcodec libavformat libavutil # ... 其他需要的 FFmpeg 库 ...
14
15
# 预编译 FFmpeg 库
16
PREBUILT_SHARED_LIBRARY := libavcodec.so
17
LOCAL_SRC_FILES := ffmpeg_libs/$(TARGET_ARCH_ABI)/libavcodec.so
18
LOCAL_MODULE := libavcodec
19
include $(PREBUILT_SHARED_LIBRARY)
20
21
PREBUILT_SHARED_LIBRARY := libavformat.so
22
LOCAL_SRC_FILES := ffmpeg_libs/$(TARGET_ARCH_ABI)/libavformat.so
23
LOCAL_MODULE := libavformat
24
include $(PREBUILT_SHARED_LIBRARY)
25
26
PREBUILT_SHARED_LIBRARY := libavutil.so
27
LOCAL_SRC_FILES := ffmpeg_libs/$(TARGET_ARCH_ABI)/libavutil.so
28
LOCAL_MODULE := libavutil
29
include $(PREBUILT_SHARED_LIBRARY)
30
31
# ... 其他预编译库 ...
32
33
include $(BUILD_SHARED_LIBRARY)
- 使用 FFmpeg API 进行音频处理：
▮▮▮▮⚝ 在 NDK 代码中，包含 FFmpeg 的头文件，例如#include <libavcodec/avcodec.h>,#include <libavformat/avformat.h>,#include <libavutil/avutil.h>。
▮▮▮▮⚝ 调用 FFmpeg 的 API 进行音频解码、编码、格式转换、混音、滤镜等操作。
▮▮▮▮⚝ 参考 FFmpeg 的官方文档和示例代码，学习如何使用 FFmpeg API。
FFmpeg 在 NDK 音频开发中的应用示例：
⚝ 音频解码播放器：使用 FFmpeg 解码各种音频格式 (例如 MP3, AAC, FLAC)，然后使用 OpenSL ES 或 AAudio 播放解码后的 PCM 数据。
⚝ 音频格式转换工具：使用 FFmpeg 将一种音频格式转换为另一种格式，例如 MP3 转 AAC, WAV 转 FLAC。
⚝ 音频编辑器：使用 FFmpeg 进行音频剪辑、混音、添加效果等操作。
⚝ 音频直播推流：使用 FFmpeg 编码音频数据，并通过网络推送到流媒体服务器。
总结：
FFmpeg 是一个强大的音频处理库，集成到 Android NDK 项目中可以极大地扩展音频处理能力。通过 FFmpeg，可以轻松实现各种复杂的音频解码、编码、格式转换、混音、滤镜等功能，为 Android 音频应用开发提供强大的支持。但需要注意的是，FFmpeg 库体积较大，集成到 APK 中会增加 APK 大小，需要根据实际需求权衡使用。
5.5 实战案例：基于 OpenSL ES 的音频播放器开发
本节将介绍一个基于 OpenSL ES 的简易音频播放器实战案例，帮助读者将前面学习的 OpenSL ES 知识应用到实际项目中。这个播放器将实现以下基本功能：
⚝ 播放本地音频文件：支持播放存储在 Android 设备本地文件系统中的音频文件。
⚝ 播放/暂停控制：提供播放和暂停功能，允许用户控制音频播放状态。
⚝ 简单的用户界面：提供简单的 UI 界面，例如播放按钮、暂停按钮等。
项目结构：
1
AudioPlayerNDK/
2
├── app/
3
│ ├── build.gradle
4
│ └── src/
5
│ └── main/
6
│ ├── java/
7
│ │ └── com/example/audioplayerndk/MainActivity.java
8
│ └── cpp/
9
│ ├── CMakeLists.txt
10
│ └── native-lib.cpp
11
├── build.gradle
12
├── gradle.properties
13
├── gradlew
14
└── gradlew.bat
核心代码实现：
- MainActivity.java (Java 层)：
1
package com.example.audioplayerndk;
2
3
import androidx.appcompat.app.AppCompatActivity;
4
import android.os.Bundle;
5
import android.widget.Button;
6
import android.widget.TextView;
7
import android.os.Environment;
8
import android.util.Log;
9
10
import java.io.File;
11
12
public class MainActivity extends AppCompatActivity {
13
14
private Button playButton;
15
private Button pauseButton;
16
private TextView sampleText;
17
private String audioFilePath;
18
private boolean isPlaying = false;
19
20
// Used to load the 'native-lib' library on application startup.
21
static {
22
System.loadLibrary("native-lib");
23
}
24
25
@Override
26
protected void onCreate(Bundle savedInstanceState) {
27
super.onCreate(savedInstanceState);
28
setContentView(R.layout.activity_main);
29
30
playButton = findViewById(R.id.play_button);
31
pauseButton = findViewById(R.id.pause_button);
32
sampleText = findViewById(R.id.sample_text);
33
34
// 获取外部存储音频文件路径 (需要 READ_EXTERNAL_STORAGE 权限)
35
File musicDir = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_MUSIC);
36
if (musicDir.exists()) {
37
File[] files = musicDir.listFiles();
38
if (files != null && files.length > 0) {
39
audioFilePath = files[0].getAbsolutePath(); // 假设使用第一个音频文件
40
sampleText.setText("Audio File: " + audioFilePath);
41
} else {
42
sampleText.setText("No audio file found in Music directory.");
43
audioFilePath = "";
44
}
45
} else {
46
sampleText.setText("Music directory not found.");
47
audioFilePath = "";
48
}
49
50
playButton.setOnClickListener(v -> {
51
if (!isPlaying && !audioFilePath.isEmpty()) {
52
startPlay(audioFilePath);
53
isPlaying = true;
54
Log.d("MainActivity", "Play button clicked, starting playback.");
55
}
56
});
57
58
pauseButton.setOnClickListener(v -> {
59
if (isPlaying) {
60
pausePlay();
61
isPlaying = false;
62
Log.d("MainActivity", "Pause button clicked, pausing playback.");
63
}
64
});
65
}
66
67
/**
68
* A native method that is implemented by the 'native-lib' native library,
69
* which is packaged with this application.
70
*/
71
public native String stringFromJNI();
72
public native void startPlay(String filePath);
73
public native void pausePlay();
74
}
- native-lib.cpp (C++ 层，OpenSL ES 实现)：
1
#include <jni.h>
2
#include <string>
3
#include <android/log.h>
4
#include <SLES/OpenSLES.h>
5
#include <SLES/OpenSLES_Android.h>
6
7
#define LOG_TAG "AudioPlayerNDK"
8
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
9
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
10
11
// OpenSL ES 对象
12
static SLObjectItf engineObject = NULL;
13
static SLEngineItf engineEngine;
14
static SLObjectItf outputMixObject = NULL;
15
static SLObjectItf playerObject = NULL;
16
static SLPlayItf playerPlay;
17
18
extern "C" JNIEXPORT jstring JNICALL
19
Java_com_example_audioplayerndk_MainActivity_stringFromJNI(
20
JNIEnv* env,
21
jobject /* this */) {
22
std::string hello = "Hello from C++";
23
return env->NewStringUTF(hello.c_str());
24
}
25
26
extern "C" JNIEXPORT void JNICALL
27
Java_com_example_audioplayerndk_MainActivity_startPlay(JNIEnv *env, jobject /* this */, jstring filePath_) {
28
const char *filePath = env->GetStringUTFChars(filePath_, 0);
29
SLresult result;
30
31
// 1. 创建引擎
32
if (engineObject == NULL) {
33
result = slCreateEngine(&engineObject, 0, NULL, 0, NULL, NULL);
34
if (result != SL_RESULT_SUCCESS) {
35
LOGE("slCreateEngine failed: %d", result);
36
return;
37
}
38
result = (*engineObject)->Realize(engineObject, SL_BOOLEAN_FALSE);
39
if (result != SL_RESULT_SUCCESS) {
40
LOGE("engineObject->Realize failed: %d", result);
41
return;
42
}
43
result = (*engineObject)->GetInterface(engineObject, SL_IID_ENGINE, &engineEngine);
44
if (result != SL_RESULT_SUCCESS) {
45
LOGE("engineObject->GetInterface(SL_IID_ENGINE) failed: %d", result);
46
return;
47
}
48
}
49
50
// 2. 创建混音器
51
if (outputMixObject == NULL) {
52
result = (*engineEngine)->CreateOutputMix(engineEngine, &outputMixObject, 0, 0, 0);
53
if (result != SL_RESULT_SUCCESS) {
54
LOGE("engineEngine->CreateOutputMix failed: %d", result);
55
return;
56
}
57
result = (*outputMixObject)->Realize(outputMixObject, SL_BOOLEAN_FALSE);
58
if (result != SL_RESULT_SUCCESS) {
59
LOGE("outputMixObject->Realize failed: %d", result);
60
return;
61
}
62
}
63
64
// 3. 配置数据源 (URI)
65
SLDataLocator_URI loc_uri = {SL_DATALOCATOR_URI, (SLchar *) filePath};
66
SLDataFormat_MIME format_mime = {SL_DATAFORMAT_MIME, NULL, SL_CONTAINERTYPE_UNSPECIFIED};
67
SLDataSource audioSrc = {&loc_uri, &format_mime};
68
69
// 4. 配置数据接收器 (OutputMix)
70
SLDataLocator_OutputMix loc_outmix = {SL_DATALOCATOR_OUTPUTMIX, outputMixObject};
71
SLDataSink audioSnk = {&loc_outmix, NULL};
72
73
// 5. 创建播放器
74
const SLInterfaceID playerIIDs[] = {SL_IID_PLAY};
75
const SLboolean playerReqs[] = {SL_BOOLEAN_TRUE};
76
result = (*engineEngine)->CreateAudioPlayer(engineEngine, &playerObject, &audioSrc, &audioSnk,
77
1, playerIIDs, playerReqs);
78
if (result != SL_RESULT_SUCCESS) {
79
LOGE("engineEngine->CreateAudioPlayer failed: %d", result);
80
env->ReleaseStringUTFChars(filePath_, filePath);
81
return;
82
}
83
result = (*playerObject)->Realize(playerObject, SL_BOOLEAN_FALSE);
84
if (result != SL_RESULT_SUCCESS) {
85
LOGE("playerObject->Realize failed: %d", result);
86
env->ReleaseStringUTFChars(filePath_, filePath);
87
return;
88
}
89
result = (*playerObject)->GetInterface(playerObject, SL_IID_PLAY, &playerPlay);
90
if (result != SL_RESULT_SUCCESS) {
91
LOGE("playerObject->GetInterface(SL_IID_PLAY) failed: %d", result);
92
env->ReleaseStringUTFChars(filePath_, filePath);
93
return;
94
}
95
96
// 6. 设置播放状态为播放
97
result = (*playerPlay)->SetPlayState(playerPlay, SL_PLAYSTATE_PLAYING);
98
if (result != SL_RESULT_SUCCESS) {
99
LOGE("playerPlay->SetPlayState(PLAYING) failed: %d", result);
100
} else {
101
LOGI("Start playing audio: %s", filePath);
102
}
103
104
env->ReleaseStringUTFChars(filePath_, filePath);
105
}
106
107
extern "C" JNIEXPORT void JNICALL
108
Java_com_example_audioplayerndk_MainActivity_pausePlay(JNIEnv *env, jobject /* this */) {
109
if (playerPlay != NULL) {
110
SLresult result = (*playerPlay)->SetPlayState(playerPlay, SL_PLAYSTATE_PAUSED);
111
if (result == SL_RESULT_SUCCESS) {
112
LOGI("Pause playing audio.");
113
} else {
114
LOGE("playerPlay->SetPlayState(PAUSED) failed: %d", result);
115
}
116
}
117
}
- CMakeLists.txt (CMake 构建配置)：
1
cmake_minimum_required(VERSION 3.4.1)
2
3
add_library( native-lib
4
SHARED
5
src/main/cpp/native-lib.cpp )
6
7
find_library( log-lib
8
log )
9
find_library( opensles-lib
10
OpenSLES )
11
12
target_link_libraries( native-lib
13
${log-lib}
14
${opensles-lib} )
- activity_main.xml (UI 布局)：
1
<?xml version="1.0" encoding="utf-8"?>
2
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
3
android:layout_width="match_parent"
4
android:layout_height="match_parent"
5
android:orientation="vertical"
6
android:gravity="center">
7
8
<TextView
9
android:id="@+id/sample_text"
10
android:layout_width="wrap_content"
11
android:layout_height="wrap_content"
12
android:text="Audio File Path"
13
android:layout_marginBottom="20dp"/>
14
15
<Button
16
android:id="@+id/play_button"
17
android:layout_width="wrap_content"
18
android:layout_height="wrap_content"
19
android:text="Play"/>
20
21
<Button
22
android:id="@+id/pause_button"
23
android:layout_width="wrap_content"
24
android:layout_height="wrap_content"
25
android:text="Pause"
26
android:layout_marginTop="10dp"/>
27
28
</LinearLayout>
使用步骤：
- 创建 Android Studio 工程：创建一个新的 Android Studio 工程，选择 Native C++ 项目模板。
- 添加布局文件：将
activity_main.xml文件添加到res/layout目录下。 - 修改 MainActivity.java：将
MainActivity.java代码复制到项目中，并确保包名一致。 - 修改 native-lib.cpp：将
native-lib.cpp代码复制到cpp目录下，并确保函数签名与 Java 代码中的 native 方法声明一致。 - 修改 CMakeLists.txt：将
CMakeLists.txt代码复制到cpp目录下。 - 添加音频文件：将音频文件 (例如 MP3 文件) 复制到设备的
Music目录下 (需要授予应用外部存储读写权限)。 - 运行应用：编译并运行应用，点击 "Play" 按钮开始播放音频，点击 "Pause" 按钮暂停播放。
代码说明：
⚝ Java 层 (MainActivity.java)：
▮▮▮▮⚝ 负责 UI 交互，获取音频文件路径，调用 NDK 层的 startPlay 和 pausePlay 方法。
▮▮▮▮⚝ 需要申请 READ_EXTERNAL_STORAGE 权限才能读取外部存储的音频文件。
⚝ C++ 层 (native-lib.cpp)：
▮▮▮▮⚝ 使用 OpenSL ES API 实现音频播放功能。
▮▮▮▮⚝ startPlay 函数：
① 创建 OpenSL ES 引擎和混音器。
② 配置 URI 数据源，指向音频文件路径。
③ 配置 OutputMix 数据接收器。
④ 创建音频播放器，获取 Play 接口。
⑤ 设置播放状态为 SL_PLAYSTATE_PLAYING，开始播放。
▮▮▮▮⚝ pausePlay 函数：
① 获取 Play 接口。
② 设置播放状态为 SL_PLAYSTATE_PAUSED，暂停播放。
⚝ CMakeLists.txt：
▮▮▮▮⚝ 配置 CMake 构建，链接 log 和 OpenSLES 库。
扩展功能：
⚝ 停止播放：添加停止播放功能，并在停止播放时释放 OpenSL ES 资源。
⚝ 进度条：添加进度条显示播放进度，并允许拖动进度条控制播放位置 (需要更复杂的 OpenSL ES API 使用)。
⚝ 音量控制：添加音量控制功能，使用 OpenSL ES 的 Volume 接口调节音量。
⚝ 播放列表：支持播放多个音频文件，实现播放列表功能。
⚝ 错误处理：完善错误处理，例如处理音频文件不存在、OpenSL ES 初始化失败等情况。
这个实战案例提供了一个简单的 OpenSL ES 音频播放器框架，读者可以基于此框架进行扩展和完善，学习更高级的 OpenSL ES 音频开发技术。通过实践，可以更深入地理解 OpenSL ES 的 API 使用和音频播放流程。
ENDOF_CHAPTER_
6. chapter 6： NDK 传感器与输入：与硬件交互
6.1 Android 传感器框架：传感器类型与数据获取
Android 传感器框架（Sensor Framework）是 Android 系统中用于访问各种硬件传感器的核心组件。它为应用程序提供了一个统一的接口，使得开发者能够方便地获取设备内置的多种传感器数据，例如加速度计（Accelerometer）、陀螺仪（Gyroscope）、光线传感器（Light Sensor）、距离传感器（Proximity Sensor）等等。通过利用这些传感器数据，应用程序可以实现各种丰富的功能，例如运动感应、环境感知、位置定位等，从而极大地提升用户体验和应用场景。
Android 传感器框架主要由以下几个关键组件构成：
① SensorManager（传感器管理器）：SensorManager 是访问 Android 传感器框架的核心类，它负责管理设备上的所有传感器。开发者通过 SensorManager 可以获取传感器列表、注册和注销传感器监听器、设置传感器数据采样频率等。在 Java 层，可以通过 Context.getSystemService(Context.SENSOR_SERVICE) 获取 SensorManager 实例。
② Sensor（传感器）：Sensor 类代表一个具体的硬件传感器，例如加速度计、陀螺仪等。每个 Sensor 对象都包含了传感器的类型、厂商、功耗、精度等信息。可以通过 SensorManager.getSensorList(int type) 或 SensorManager.getDefaultSensor(int type) 获取 Sensor 对象。
③ SensorEventListener（传感器事件监听器）：SensorEventListener 是一个接口，用于接收传感器数据变化的通知。开发者需要实现 SensorEventListener 接口中的 onSensorChanged(SensorEvent event) 和 onAccuracyChanged(Sensor sensor, int accuracy) 方法，分别处理传感器数据更新和精度变化事件。通过 SensorManager.registerListener() 方法注册监听器，即可开始接收传感器数据。
Android 系统支持多种类型的传感器，根据功能和用途，大致可以分为以下几类：
① 运动传感器（Motion Sensors）：用于测量设备运动状态的传感器，例如：
⚝ 加速度计（Accelerometer）：测量设备在三个物理轴（X、Y、Z）上的加速度，单位通常为 m/s²。加速度计可以用于检测设备的晃动、倾斜、自由落体等运动状态。
⚝ 陀螺仪（Gyroscope）：测量设备绕三个物理轴（X、Y、Z）旋转的角速度，单位通常为 rad/s。陀螺仪可以用于检测设备的旋转、角速度等运动状态，常用于姿态识别和运动跟踪。
⚝ 重力传感器（Gravity Sensor）：测量设备受到的重力加速度，不受设备自身运动加速度的影响。重力传感器可以用于判断设备的水平方向和垂直方向。
⚝ 线性加速度传感器（Linear Acceleration Sensor）：测量设备自身运动产生的加速度，去除重力加速度的影响。线性加速度传感器可以更准确地反映设备的运动状态。
⚝ 旋转矢量传感器（Rotation Vector Sensor）：以矢量的形式表示设备在三维空间中的姿态，提供更精确的设备方向信息，常用于增强现实（AR）和虚拟现实（VR）应用。
⚝ 计步器（Step Counter） 和 步测器（Step Detector）：用于检测用户的步数和步频，常用于运动健康类应用。
② 环境传感器（Environmental Sensors）：用于测量设备周围环境参数的传感器，例如：
⚝ 光线传感器（Light Sensor）：测量环境光照强度，单位通常为 lux。光线传感器可以用于自动调节屏幕亮度。
⚝ 压力传感器（Pressure Sensor）：测量大气压强，单位通常为 hPa 或 kPa。压力传感器可以用于海拔高度测量和天气预报。
⚝ 温度传感器（Temperature Sensor）：测量设备周围环境温度，单位通常为摄氏度 (°C)。
⚝ 湿度传感器（Humidity Sensor）：测量环境相对湿度，单位通常为百分比 (%)。
③ 位置传感器（Position Sensors）：用于确定设备地理位置的传感器，例如：
⚝ 磁场传感器（Magnetic Field Sensor）：测量设备周围的磁场强度，单位通常为 μT（微特斯拉）。磁场传感器可以用于指南针应用和金属探测。
⚝ 方向传感器（Orientation Sensor）：测量设备在水平面上的方向，通常以角度表示。方向传感器常用于导航和地图应用。
在 Java 层获取传感器数据 的基本步骤如下：
- 获取 SensorManager 实例：
1
SensorManager sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
- 获取 Sensor 对象：
1
Sensor accelerometerSensor = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
2
if (accelerometerSensor != null) {
3
// 加速度计传感器存在
4
} else {
5
// 加速度计传感器不存在
6
}
- 注册 SensorEventListener：
1
SensorEventListener sensorEventListener = new SensorEventListener() {
2
@Override
3
public void onSensorChanged(SensorEvent event) {
4
if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
5
float x = event.values[0]; // X 轴加速度
6
float y = event.values[1]; // Y 轴加速度
7
float z = event.values[2]; // Z 轴加速度
8
// 处理加速度数据
9
}
10
}
11
12
@Override
13
public void onAccuracyChanged(Sensor sensor, int accuracy) {
14
// 处理传感器精度变化
15
}
16
};
17
18
sensorManager.registerListener(sensorEventListener, accelerometerSensor, SensorManager.SENSOR_DELAY_NORMAL);
其中，SENSOR_DELAY_NORMAL 表示传感器数据采样频率，还可以选择 SENSOR_DELAY_UI、SENSOR_DELAY_GAME、SENSOR_DELAY_FASTEST 等不同的频率。
- 注销 SensorEventListener：在不需要使用传感器数据时，应该及时注销监听器，以节省电量和系统资源。
1
sensorManager.unregisterListener(sensorEventListener);
了解了 Android 传感器框架的基本概念和 Java 层的使用方法后，接下来我们将深入探讨如何在 NDK 中使用传感器，实现更高效、更底层的硬件交互。
6.2 传感器在 NDK 中的应用：SensorManager 与 SensorEventListener
在 NDK 中使用传感器，与 Java 层类似，也需要通过 SensorManager 和 SensorEventListener 来实现。但是，NDK 中使用的是 C/C++ 接口，需要通过 JNI 技术桥接 Java 层的 SensorManager 服务，并使用 Native 的 ASensorManager、ASensorEventQueue 等 API 来进行传感器数据的获取和处理。
NDK 传感器 API 概览
NDK 提供了以下关键的 API 用于传感器开发：
① ASensorManager（Native 传感器管理器）：ASensorManager 是 NDK 中用于管理传感器的核心 API，类似于 Java 层的 SensorManager。通过 ASensorManager_getInstance() 可以获取 ASensorManager 实例。
② ASensorList（传感器列表）：ASensorList 是一个 ASensor* 类型的数组，用于存储设备上的传感器列表。可以通过 ASensorManager_getSensorList() 获取传感器列表。
③ ASensor（Native 传感器）：ASensor 结构体代表一个具体的硬件传感器，类似于 Java 层的 Sensor 类。可以通过 ASensor_getType(), ASensor_getName(), ASensor_getVendor() 等函数获取传感器的信息。
④ ASensorEventQueue（传感器事件队列）：ASensorEventQueue 用于接收传感器事件。每个 ASensor 可以关联一个或多个 ASensorEventQueue。通过 ASensorManager_createEventQueue() 创建事件队列，通过 ASensorEventQueue_enableSensor() 启用传感器，并通过 ASensorEventQueue_getEvents() 获取传感器事件。
⑤ ASensorEvent（Native 传感器事件）：ASensorEvent 结构体包含了传感器数据和事件信息，例如时间戳、传感器类型、传感器精度以及传感器数值（values 数组）。
NDK 传感器开发步骤
在 NDK 中使用传感器的基本步骤如下：
- 获取 ASensorManager 实例：
1
#include <android/sensor.h>
2
3
ASensorManager* sensorManager = ASensorManager_getInstance();
4
if (sensorManager == nullptr) {
5
// 获取 SensorManager 失败
6
return;
7
}
- 获取传感器列表：
1
ASensorList sensorList;
2
int sensorCount = ASensorManager_getSensorList(sensorManager, &sensorList);
3
if (sensorCount < 0) {
4
// 获取传感器列表失败
5
return;
6
}
7
8
for (int i = 0; i < sensorCount; ++i) {
9
ASensor* sensor = sensorList[i];
10
int sensorType = ASensor_getType(sensor);
11
const char* sensorName = ASensor_getName(sensor);
12
const char* sensorVendor = ASensor_getVendor(sensor);
13
// 处理传感器信息
14
}
- 获取指定类型的传感器：例如获取加速度计传感器：
1
const ASensor* accelerometerSensor = ASensorManager_getDefaultSensor(sensorManager, ASENSOR_TYPE_ACCELEROMETER);
2
if (accelerometerSensor == nullptr) {
3
// 加速度计传感器不存在
4
return;
5
}
- 创建 ASensorEventQueue：
1
ALooper* looper = ALooper_prepare(ALOOPER_PREPARE_ALLOW_WAKEUPS); // 获取 Looper
2
ASensorEventQueue* sensorEventQueue = ASensorManager_createEventQueue(sensorManager, looper, 0, nullptr, nullptr);
3
if (sensorEventQueue == nullptr) {
4
// 创建事件队列失败
5
return;
6
}
这里需要注意，ASensorManager_createEventQueue() 需要一个 ALooper 对象。ALooper 是 Android 系统中用于消息循环的组件，类似于 Java 层的 Looper。可以使用 ALooper_prepare() 获取当前线程的 ALooper，或者创建一个新的 ALooper。
- 启用传感器并设置采样频率：
1
int enableResult = ASensorEventQueue_enableSensor(sensorEventQueue, accelerometerSensor);
2
if (enableResult < 0) {
3
// 启用传感器失败
4
ASensorManager_destroyEventQueue(sensorManager, sensorEventQueue);
5
return;
6
}
7
8
int setRateResult = ASensorEventQueue_setEventRate(sensorEventQueue, accelerometerSensor, SENSOR_DELAY_NORMAL);
9
if (setRateResult < 0) {
10
// 设置采样频率失败
11
ASensorEventQueue_disableSensor(sensorEventQueue, accelerometerSensor);
12
ASensorManager_destroyEventQueue(sensorManager, sensorEventQueue);
13
return;
14
}
SENSOR_DELAY_NORMAL 等常量定义在 <android/sensor.h> 头文件中，与 Java 层 SensorManager 中的常量对应。
- 循环获取传感器事件：
1
while (true) {
2
int sensorEventCount = 0;
3
ASensorEvent sensorEvents[16]; // 一次最多获取 16 个事件
4
int pollResult = ALooper_pollAll(-1, nullptr, &sensorEventCount, nullptr); // 阻塞等待事件
5
if (pollResult == ALOOPER_POLL_WAKE || pollResult == ALOOPER_POLL_CALLBACK) {
6
// Looper 唤醒或回调，继续处理
7
} else if (pollResult == ALOOPER_POLL_TIMEOUT) {
8
// 超时，继续循环
9
continue;
10
} else if (pollResult < 0) {
11
// 错误发生，退出循环
12
break;
13
}
14
15
if (sensorEventCount > 0) {
16
int eventsRead = ASensorEventQueue_getEvents(sensorEventQueue, sensorEvents, 16);
17
if (eventsRead > 0) {
18
for (int i = 0; i < eventsRead; ++i) {
19
ASensorEvent* event = &sensorEvents[i];
20
if (event->type == ASENSOR_TYPE_ACCELEROMETER) {
21
float x = event->values[0]; // X 轴加速度
22
float y = event->values[1]; // Y 轴加速度
23
float z = event->values[2]; // Z 轴加速度
24
// 处理加速度数据
25
}
26
}
27
}
28
}
29
}
ALooper_pollAll() 用于等待事件发生，-1 表示无限期等待。ASensorEventQueue_getEvents() 用于从事件队列中获取传感器事件。
- 禁用传感器并销毁事件队列：在不需要使用传感器数据时，应该及时禁用传感器并销毁事件队列，释放资源。
1
ASensorEventQueue_disableSensor(sensorEventQueue, accelerometerSensor);
2
ASensorManager_destroyEventQueue(sensorManager, sensorEventQueue);
JNI 桥接
为了在 Java 层调用 Native 层的传感器代码，需要使用 JNI 技术。可以将上述 NDK 传感器代码封装在一个 C/C++ 函数中，并通过 JNI 暴露给 Java 层调用。例如，可以创建一个名为 startSensorListening() 的 JNI 函数，在 Java 层调用该函数即可启动传感器监听。
代码示例 (JNI 函数)
1
#include <jni.h>
2
#include <android/sensor.h>
3
#include <android/looper.h>
4
5
extern "C" JNIEXPORT void JNICALL
6
Java_com_example_ndksensorapp_MainActivity_startSensorListening(JNIEnv* env, jobject /* this */) {
7
ASensorManager* sensorManager = ASensorManager_getInstance();
8
if (sensorManager == nullptr) return;
9
10
const ASensor* accelerometerSensor = ASensorManager_getDefaultSensor(sensorManager, ASENSOR_TYPE_ACCELEROMETER);
11
if (accelerometerSensor == nullptr) return;
12
13
ALooper* looper = ALooper_prepare(ALOOPER_PREPARE_ALLOW_WAKEUPS);
14
ASensorEventQueue* sensorEventQueue = ASensorManager_createEventQueue(sensorManager, looper, 0, nullptr, nullptr);
15
if (sensorEventQueue == nullptr) return;
16
17
ASensorEventQueue_enableSensor(sensorEventQueue, accelerometerSensor);
18
ASensorEventQueue_setEventRate(sensorEventQueue, accelerometerSensor, SENSOR_DELAY_NORMAL);
19
20
while (true) {
21
int sensorEventCount = 0;
22
ASensorEvent sensorEvents[16];
23
int pollResult = ALooper_pollAll(-1, nullptr, &sensorEventCount, nullptr);
24
if (pollResult == ALOOPER_POLL_WAKE || pollResult == ALOOPER_POLL_CALLBACK) {
25
// Looper 唤醒或回调，继续处理
26
} else if (pollResult == ALOOPER_POLL_TIMEOUT) {
27
continue;
28
} else if (pollResult < 0) {
29
break;
30
}
31
32
if (sensorEventCount > 0) {
33
int eventsRead = ASensorEventQueue_getEvents(sensorEventQueue, sensorEvents, 16);
34
if (eventsRead > 0) {
35
for (int i = 0; i < eventsRead; ++i) {
36
ASensorEvent* event = &sensorEvents[i];
37
if (event->type == ASENSOR_TYPE_ACCELEROMETER) {
38
float x = event->values[0];
39
float y = event->values[1];
40
float z = event->values[2];
41
// 在这里处理加速度数据，例如通过 JNI 回调 Java 层
42
}
43
}
44
}
45
}
46
}
47
48
ASensorEventQueue_disableSensor(sensorEventQueue, accelerometerSensor);
49
ASensorManager_destroyEventQueue(sensorManager, sensorEventQueue);
50
}
Java 层调用
在 Java 代码中，声明 native 方法 startSensorListening()，并在需要的时候调用该方法：
1
public class MainActivity extends AppCompatActivity {
2
3
// ...
4
5
private native void startSensorListening();
6
7
@Override
8
protected void onCreate(Bundle savedInstanceState) {
9
super.onCreate(savedInstanceState);
10
setContentView(R.layout.activity_main);
11
12
// ...
13
startSensorListening(); // 启动传感器监听
14
}
15
16
// ...
17
18
static {
19
System.loadLibrary("native-lib"); // 加载 Native 库
20
}
21
}
通过以上步骤，就可以在 NDK 中使用传感器 API 获取传感器数据，并利用 JNI 技术将数据传递给 Java 层进行进一步处理和应用。
6.3 输入事件处理：触摸事件与按键事件的 native 层处理
Android 系统中的输入事件，例如触摸事件（Touch Events）和按键事件（Key Events），也可以在 Native 层进行处理。在 NDK 中，可以使用 AInputQueue 和 AInputEvent API 来接收和处理输入事件，从而实现更底层的输入控制和交互逻辑。
NDK 输入事件 API 概览
NDK 提供了以下关键的 API 用于输入事件处理：
① AInputQueue（输入事件队列）：AInputQueue 用于接收输入事件。每个 Android 窗口（Window）可以关联一个 AInputQueue。通过 ANativeWindow_getInputQueue() 可以获取与 Native Window 关联的 AInputQueue。
② AInputEvent（Native 输入事件）：AInputEvent 是所有输入事件的基类，包含了事件的通用信息，例如事件类型、事件时间等。AInputEvent 有两个主要的子类：
⚝ AMotionEvent（MotionEvent）：代表触摸事件，例如手指按下、移动、抬起等。
⚝ AKeyEvent（KeyEvent）：代表按键事件，例如按键按下、抬起等。
触摸事件处理
处理触摸事件的基本步骤如下：
- 获取 AInputQueue：首先需要获取与 Native Window 关联的
AInputQueue。通常在 Native Window 创建或就绪的回调函数中获取AInputQueue。
1
#include <android/native_window.h>
2
#include <android/input.h>
3
4
ANativeWindow* nativeWindow = ...; // 获取 ANativeWindow
5
AInputQueue* inputQueue = nullptr;
6
7
void handleNativeWindowCreated(ANativeWindow* window) {
8
nativeWindow = window;
9
inputQueue = ANativeWindow_getInputQueue(nativeWindow);
10
if (inputQueue != nullptr) {
11
AInputQueue_attachLooper(inputQueue, ALooper_getForThread(), 0, nullptr, nullptr); // 关联 Looper
12
}
13
}
14
15
void handleNativeWindowDestroyed(ANativeWindow* window) {
16
if (inputQueue != nullptr) {
17
AInputQueue_detachLooper(inputQueue); // 解除 Looper 关联
18
inputQueue = nullptr;
19
}
20
nativeWindow = nullptr;
21
}
ANativeWindow_getInputQueue() 用于获取 AInputQueue。AInputQueue_attachLooper() 将 AInputQueue 与当前线程的 Looper 关联，使得输入事件可以被当前线程处理。AInputQueue_detachLooper() 用于解除关联。
- 循环获取输入事件：在消息循环中，调用
AInputQueue_getEvent()获取输入事件。
1
while (true) {
2
AInputEvent* event = nullptr;
3
if (AInputQueue_getEvent(inputQueue, &event) >= 0) {
4
if (AInputQueue_preDispatchEvent(inputQueue, event)) {
5
// 事件被预先分发，忽略
6
continue;
7
} else {
8
// 处理输入事件
9
int eventType = AInputEvent_getType(event);
10
if (eventType == AINPUT_EVENT_TYPE_MOTION) {
11
// 处理触摸事件
12
int action = AMotionEvent_getAction(event);
13
float x = AMotionEvent_getX(event, 0); // 获取第一个触点的 X 坐标
14
float y = AMotionEvent_getY(event, 0); // 获取第一个触点的 Y 坐标
15
// 根据 action 和坐标处理触摸事件
16
switch (action & AMOTION_EVENT_ACTION_MASK) {
17
case AMOTION_EVENT_ACTION_DOWN:
18
// 手指按下
19
break;
20
case AMOTION_EVENT_ACTION_MOVE:
21
// 手指移动
22
break;
23
case AMOTION_EVENT_ACTION_UP:
24
// 手指抬起
25
break;
26
// ... 其他触摸事件类型
27
}
28
} else if (eventType == AINPUT_EVENT_TYPE_KEY) {
29
// 处理按键事件
30
// ...
31
}
32
AInputQueue_finishEvent(inputQueue, event, 1); // 完成事件处理
33
}
34
} else {
35
// 输入队列发生错误或被销毁，退出循环
36
break;
37
}
38
}
AInputQueue_getEvent() 用于获取输入事件，如果队列为空则阻塞等待。AInputQueue_preDispatchEvent() 用于预先分发事件，通常返回 false，表示事件需要被当前线程处理。AInputEvent_getType() 获取事件类型。AMotionEvent_getAction() 获取触摸事件的动作类型，例如 AMOTION_EVENT_ACTION_DOWN、AMOTION_EVENT_ACTION_MOVE、AMOTION_EVENT_ACTION_UP 等。AMotionEvent_getX() 和 AMotionEvent_getY() 获取触点的坐标。AInputQueue_finishEvent() 用于完成事件处理，并告知系统事件已被处理。
按键事件处理
处理按键事件的步骤与触摸事件类似，只是事件类型和事件信息的获取方式有所不同。
在上述代码的 else if (eventType == AINPUT_EVENT_TYPE_KEY) 分支中，可以处理按键事件：
1
} else if (eventType == AINPUT_EVENT_TYPE_KEY) {
2
// 处理按键事件
3
int action = AKeyEvent_getAction(event);
4
int keyCode = AKeyEvent_getKeyCode(event);
5
// 根据 action 和 keyCode 处理按键事件
6
switch (action) {
7
case AKEY_EVENT_ACTION_DOWN:
8
// 按键按下
9
if (keyCode == AKEYCODE_BACK) {
10
// 返回键按下
11
} else if (keyCode == AKEYCODE_VOLUME_UP) {
12
// 音量加键按下
13
}
14
break;
15
case AKEY_EVENT_ACTION_UP:
16
// 按键抬起
17
break;
18
// ... 其他按键事件类型
19
}
20
}
AKeyEvent_getAction() 获取按键事件的动作类型，例如 AKEY_EVENT_ACTION_DOWN、AKEY_EVENT_ACTION_UP 等。AKeyEvent_getKeyCode() 获取按键的键码，例如 AKEYCODE_BACK、AKEYCODE_VOLUME_UP 等。键码常量定义在 <android/keycodes.h> 头文件中。
NativeActivity
在 Android NDK 开发中，通常使用 NativeActivity 作为 Native 应用的入口。NativeActivity 已经封装了 Native Window 的创建、销毁以及输入事件的处理流程，开发者只需要在 android_main() 函数中实现自己的 Native 逻辑即可。
在 NativeActivity 中，可以通过 android_app->inputQueue 获取 AInputQueue，并使用 ALooper 进行事件循环，从而方便地处理输入事件。
代码示例 (NativeActivity 输入事件处理)
1
#include <jni.h>
2
#include <android_native_app_glue.h>
3
#include <android/input.h>
4
#include <android/log.h>
5
6
void handle_input(android_app* app, AInputEvent* event) {
7
int eventType = AInputEvent_getType(event);
8
if (eventType == AINPUT_EVENT_TYPE_MOTION) {
9
int action = AMotionEvent_getAction(event);
10
float x = AMotionEvent_getX(event, 0);
11
float y = AMotionEvent_getY(event, 0);
12
__android_log_print(ANDROID_LOG_INFO, "NDKInput", "Touch Event: Action=%d, X=%f, Y=%f", action, x, y);
13
// 处理触摸事件
14
} else if (eventType == AINPUT_EVENT_TYPE_KEY) {
15
int action = AKeyEvent_getAction(event);
16
int keyCode = AKeyEvent_getKeyCode(event);
17
__android_log_print(ANDROID_LOG_INFO, "NDKInput", "Key Event: Action=%d, KeyCode=%d", action, keyCode);
18
// 处理按键事件
19
}
20
}
21
22
void android_main(android_app* app) {
23
app_dummy(); // 确保 android_native_app_glue 静态库被链接
24
25
app->onInputEvent = handle_input; // 设置输入事件回调函数
26
app->onAppCmd = handle_cmd; // 设置应用命令回调函数 (例如窗口创建、销毁等)
27
28
while (true) {
29
int events;
30
android_poll_source* source;
31
while ((ALooper_pollAll(-1, nullptr, &events, (void**)&source)) >= 0) {
32
if (source != nullptr) {
33
source->process(app, source);
34
}
35
if (app->destroyRequested != 0) {
36
return;
37
}
38
}
39
// 渲染帧或其他逻辑
40
}
41
}
在 android_main() 函数中，通过 app->onInputEvent = handle_input; 设置输入事件回调函数 handle_input()。当有输入事件发生时，handle_input() 函数会被调用，可以在该函数中处理触摸事件和按键事件。
通过 NDK 输入事件 API，开发者可以在 Native 层实现精细的输入控制和交互逻辑，例如自定义手势识别、游戏控制等。
6.4 实战案例：基于传感器的体感游戏开发
本节将介绍一个基于传感器的体感游戏开发实战案例，以帮助读者更好地理解和应用 NDK 传感器与输入 API。我们将设计一个简单的体感游戏，通过加速度计传感器检测设备的运动，并结合触摸输入实现游戏交互。
游戏概念：重力迷宫
游戏名称为 "重力迷宫"（Gravity Maze）。游戏的核心玩法是控制一个小球在一个迷宫中滚动，目标是将小球滚动到迷宫的终点。玩家通过倾斜设备来改变迷宫的倾斜角度，从而利用重力控制小球的滚动方向和速度。同时，玩家可以通过触摸屏幕来触发一些特殊操作，例如加速、跳跃等（可选功能）。
技术方案
① 传感器数据获取：使用加速度计传感器获取设备的倾斜角度。通过分析加速度计在 X 轴和 Y 轴上的分量，可以计算出设备在水平面上的倾斜角度。
② 游戏场景渲染：使用 OpenGL ES 渲染 2D 迷宫场景和小球。迷宫可以使用简单的线条或纹理绘制，小球可以使用圆形或球形模型绘制。
③ 物理模拟：使用简单的物理引擎模拟小球在迷宫中的滚动运动。根据加速度计数据计算小球的加速度，并更新小球的位置和速度。
④ 触摸输入处理：监听触摸事件，实现触摸加速或跳跃等功能（可选）。
⑤ 碰撞检测：检测小球是否与迷宫墙壁或终点发生碰撞。
开发步骤
创建 NDK 项目：使用 Android Studio 创建一个新的 NDK 项目，选择 Native C++ 项目模板。
集成 OpenGL ES：在
build.gradle文件中配置 OpenGL ES 依赖，并在 Native 代码中初始化 OpenGL ES 环境。传感器代码实现：
▮▮▮▮⚝ 在 Native 代码中获取ASensorManager实例和加速度计传感器。
▮▮▮▮⚝ 创建ASensorEventQueue并启用加速度计传感器。
▮▮▮▮⚝ 在消息循环中获取加速度计数据，并计算设备倾斜角度。游戏场景渲染实现：
▮▮▮▮⚝ 定义迷宫数据结构，例如使用二维数组表示迷宫墙壁和路径。
▮▮▮▮⚝ 使用 OpenGL ES 绘制迷宫场景和小球。物理模拟实现：
▮▮▮▮⚝ 定义小球的位置、速度、加速度等物理属性。
▮▮▮▮⚝ 在每一帧更新时，根据加速度计数据计算小球的加速度。
▮▮▮▮⚝ 使用简单的积分算法（例如欧拉积分）更新小球的位置和速度。
▮▮▮▮⚝ 实现边界碰撞检测，防止小球穿墙。触摸输入处理实现（可选）：
▮▮▮▮⚝ 在 Native 代码中获取AInputQueue并监听触摸事件。
▮▮▮▮⚝ 在触摸事件处理函数中，根据触摸动作触发小球加速或跳跃等操作。游戏逻辑实现：
▮▮▮▮⚝ 实现游戏开始、暂停、结束等状态管理。
▮▮▮▮⚝ 实现游戏胜利条件判断（小球到达终点）。
▮▮▮▮⚝ 添加游戏 UI，例如显示得分、时间等信息。测试与优化：在 Android 设备上运行游戏，测试传感器灵敏度、游戏流畅度、碰撞检测准确性等。根据测试结果进行优化，例如调整传感器采样频率、优化物理引擎参数、改进渲染效率等。
关键代码片段 (加速度计数据处理)
1
// ... 传感器事件循环中 ...
2
if (event->type == ASENSOR_TYPE_ACCELEROMETER) {
3
float x = event->values[0]; // X 轴加速度
4
float y = event->values[1]; // Y 轴加速度
5
float z = event->values[2]; // Z 轴加速度
6
7
// 计算倾斜角度 (简化计算，实际应用中可能需要更精确的算法)
8
float angleX = atan2(y, z) * 180 / M_PI; // X 轴倾斜角度
9
float angleY = atan2(x, z) * 180 / M_PI; // Y 轴倾斜角度
10
11
// 根据倾斜角度更新小球的加速度
12
float accelerationX = angleY * SENSOR_SENSITIVITY; // SENSOR_SENSITIVITY 为灵敏度系数
13
float accelerationY = -angleX * SENSOR_SENSITIVITY;
14
15
// 更新小球物理状态 (位置、速度)
16
updateBallPhysics(accelerationX, accelerationY, deltaTime);
17
}
扩展功能
⚝ 更复杂的迷宫设计：设计更复杂、更有挑战性的迷宫关卡。
⚝ 多种游戏模式：例如计时模式、步数限制模式等。
⚝ 道具系统：添加道具，例如加速道具、减速道具、无敌道具等。
⚝ 多人游戏：实现本地或在线多人对战模式。
⚝ 精美的游戏画面和音效：提升游戏的视觉和听觉体验。
通过 "重力迷宫" 这个实战案例，读者可以学习到如何将 NDK 传感器 API 和输入 API 应用于实际的游戏开发中，并掌握体感游戏开发的基本流程和技术要点。这个案例也展示了 NDK 在高性能游戏开发方面的优势，以及如何利用 Native 代码实现更流畅、更底层的硬件交互。
ENDOF_CHAPTER_
7. chapter 7： NDK 性能优化：打造高效 Native 代码
7.1 性能分析工具：Profiler 与 Systrace 的使用
在 Android NDK 开发中，性能优化是至关重要的环节。Native 代码的执行效率直接影响应用的整体性能和用户体验。为了有效地进行性能优化，我们需要借助强大的性能分析工具来定位性能瓶颈。Android 平台提供了多种性能分析工具，其中 Profiler（性能分析器） 和 Systrace（系统跟踪） 是两种最常用且功能强大的工具。
Profiler 通常指的是 Android Studio 内置的 Profiler 工具集，它能够实时监控应用的 CPU、内存、网络和电量使用情况。对于 Native 代码的性能分析，CPU Profiler 是我们关注的重点。它可以帮助我们了解 Native 代码的 CPU 占用率、方法调用耗时等信息，从而找出性能热点。
Systrace 则是一个更底层的系统级性能分析工具。它可以收集 Android 系统内核、SurfaceFlinger、Binder、Webview 等多个组件的运行信息，并将这些信息以可视化的方式呈现出来。Systrace 可以帮助我们从系统全局的角度分析应用的性能问题，例如线程调度、锁竞争、I/O 瓶颈等。
7.1.1 Android Studio Profiler 的使用
Android Studio Profiler 集成在 IDE 中，使用起来非常方便。以下是使用 CPU Profiler 分析 Native 代码性能的基本步骤：
① 启动 Profiler：在 Android Studio 中运行你的应用，然后点击底部的 "Profiler" 标签页，即可打开 Profiler 窗口。
② 选择 CPU Profiler：在 Profiler 窗口中，选择 "CPU" 分页。
③ 开始录制：点击 CPU Profiler 面板中的 "Record" 按钮，开始录制 CPU 性能数据。在录制过程中，执行你需要分析的应用操作，例如运行某个 Native 函数。
④ 停止录制：完成操作后，点击 "Stop" 按钮停止录制。Profiler 会自动分析录制的数据，并以多种视图展示出来，例如：
⚝ 火焰图（Flame Chart）：以火焰状图形展示方法调用栈和耗时，宽度代表方法的执行时间，颜色深浅代表调用深度。火焰图能够直观地展示 CPU 时间都消耗在了哪些方法上，帮助快速定位性能瓶颈函数。
⚝ 调用图（Call Chart）：以树状结构展示方法调用关系和耗时，可以清晰地看到方法的调用路径和各自的耗时占比。
⚝ 方法表（Top Down/Bottom Up）：以列表形式展示方法的耗时统计信息，包括 Self Time（方法自身耗时）、Total Time（方法及其子方法总耗时）、调用次数等。可以根据耗时排序，快速找到耗时最多的方法。
⑤ 分析结果：根据 Profiler 提供的各种视图，分析 Native 代码的性能瓶颈。重点关注火焰图和方法表，找出耗时较长的 Native 函数，并进一步分析其实现逻辑，寻找优化空间。
7.1.2 Systrace 的使用
Systrace 是一个命令行工具，需要通过 adb 命令来运行。使用 Systrace 分析 Native 代码性能的步骤如下：
① 准备 Systrace：确保你的 Android SDK Platform-Tools 目录已添加到系统环境变量 PATH 中，以便可以直接在命令行中运行 systrace 命令。
② 收集 Trace 数据：打开终端，使用 systrace 命令收集 Trace 数据。常用的命令格式如下：
1
systrace [options] [categories] [app_name]
▮▮▮▮⚝ options：Systrace 的选项，例如 -t <seconds> 指定录制时长，-o <filename> 指定输出文件名等。
▮▮▮▮⚝ categories：需要收集的系统事件类别，例如 sched（调度）、gfx（图形）、input（输入）、binder_driver（Binder 驱动）等。对于 Native 代码性能分析，通常需要包含 sched 和 binder_driver 类别。可以使用 -l 选项查看所有可用的类别。
▮▮▮▮⚝ app_name：要分析的应用包名，可选参数。如果指定了应用包名，Systrace 会自动标记该应用的进程。
▮▮▮▮例如，要录制 10 秒的应用 com.example.myapp 的 Trace 数据，并包含调度和 Binder 驱动事件，可以使用以下命令：
1
systrace -t 10 sched binder_driver -o mytrace.html com.example.myapp
③ 分析 Trace 结果：Systrace 会生成一个 HTML 文件（例如 mytrace.html），用浏览器打开该文件即可查看 Trace 结果。Systrace 界面主要分为以下几个部分：
⚝ 时间轴（Timeline）：横轴表示时间，纵轴表示不同的进程和线程。时间轴上会显示各个线程的运行状态、事件发生时间等信息。
⚝ 事件（Events）：时间轴上的彩色条块表示不同的事件，例如 CPU 调度、函数调用、Binder 事务等。鼠标悬停在事件上可以查看事件的详细信息。
⚝ 分析面板（Analysis Panel）：Systrace 会自动分析 Trace 数据，并在分析面板中展示一些性能指标和建议，例如 CPU 占用率、帧率、卡顿信息等。
④ 定位 Native 代码性能问题：在 Systrace 界面中，找到你的应用进程，查看其 Native 线程的运行状态和事件。重点关注以下信息：
⚝ CPU 调度延迟：如果 Native 线程频繁被抢占或等待 CPU 调度，可能说明 CPU 资源紧张或线程优先级设置不合理。
⚝ 锁竞争：如果 Native 线程在等待锁的时间过长，可能说明存在锁竞争问题，需要优化锁的使用方式或减少锁的持有时间。
⚝ Binder 调用耗时：如果 Native 代码通过 JNI 调用 Java 层方法，或者与系统服务进行 Binder 通信，需要关注 Binder 调用的耗时，避免频繁的跨进程调用。
7.1.3 选择合适的性能分析工具
Profiler 和 Systrace 各有优缺点，在实际应用中需要根据具体情况选择合适的工具：
⚝ Profiler：
▮▮▮▮⚝ 优点：集成在 Android Studio 中，使用方便；实时监控应用性能；提供多种视图，方便分析 CPU、内存等性能指标。
▮▮▮▮⚝ 缺点：只能分析单个应用的性能；系统级信息较少，难以定位系统层面的性能问题；对 Native 代码的分析粒度相对较粗。
▮▮▮▮⚝ 适用场景：快速定位应用内部的性能瓶颈，例如某个 Native 函数的耗时过长、内存泄漏等。
⚝ Systrace：
▮▮▮▮⚝ 优点：系统级性能分析工具，可以收集系统内核、SurfaceFlinger 等多个组件的运行信息；可以从系统全局的角度分析应用的性能问题；对 Native 代码的分析粒度更细，可以跟踪函数调用、锁竞争等事件。
▮▮▮▮⚝ 缺点：使用命令行操作，配置相对复杂；Trace 结果数据量大，分析难度较高；实时性较差，需要先录制 Trace 数据再进行分析。
▮▮▮▮⚝ 适用场景：定位系统层面的性能问题，例如线程调度延迟、锁竞争、Binder 调用瓶颈等；深入分析 Native 代码的执行细节。
在实际开发中，通常可以结合使用 Profiler 和 Systrace。先使用 Profiler 快速定位应用内部的性能瓶颈，再使用 Systrace 深入分析系统层面的性能问题。
7.2 代码优化技巧：算法优化、数据结构选择与编译器优化
定位到性能瓶颈后，就需要针对性地进行代码优化。代码优化是一个涉及多个层面的复杂过程，可以从算法、数据结构、编译器等多个角度入手。
7.2.1 算法优化
算法是程序的灵魂，选择合适的算法是提高程序性能的关键。对于 Native 代码来说，算法优化尤为重要，因为 Native 代码通常承担着计算密集型任务。
① 时间复杂度分析：在选择算法时，首先要分析算法的时间复杂度。时间复杂度描述了算法执行时间随输入规模增长的趋势。通常情况下，时间复杂度越低的算法，性能越高。例如，对于排序操作，快速排序（平均时间复杂度 O(n log n)）通常比冒泡排序（时间复杂度 O(n^2)）效率更高。
② 避免冗余计算：仔细检查代码逻辑，避免进行不必要的重复计算。例如，可以将循环不变的计算移到循环外部，减少循环内部的计算量。
③ 空间换时间：在某些情况下，可以通过增加内存消耗来换取时间性能的提升。例如，可以使用缓存（Cache）技术，将计算结果缓存起来，避免重复计算。
④ 并行化算法：对于可以并行执行的任务，可以考虑使用并行算法，充分利用多核处理器的计算能力。例如，可以使用多线程或 SIMD（Single Instruction Multiple Data，单指令多数据流）指令来并行处理数据。
⑤ 针对特定硬件优化：了解目标设备的硬件特性，例如 CPU 架构、指令集等，可以针对性地选择更高效的算法。例如，在 ARM 架构的设备上，可以使用 NEON 指令集进行 SIMD 优化。
7.2.2 数据结构选择
数据结构是数据的组织方式，选择合适的数据结构可以提高数据的访问和操作效率。
① 数组（Array）：数组是最基本的数据结构，适用于存储固定大小的同类型数据。数组的优点是访问速度快，缺点是大小固定，插入和删除元素效率较低。
② 链表（Linked List）：链表适用于存储大小不确定的数据，插入和删除元素效率较高，但访问速度较慢。
③ 哈希表（Hash Table）：哈希表（也称为散列表）可以实现快速的查找、插入和删除操作，平均时间复杂度为 O(1)。哈希表适用于需要频繁查找的场景。
④ 树（Tree）：树是一种层次结构的数据结构，例如二叉树、平衡树、B 树等。树适用于存储有序数据，可以实现高效的查找、插入和删除操作。
⑤ 图（Graph）：图是一种用于表示对象之间关系的数据结构，例如邻接矩阵、邻接表等。图适用于表示复杂的关系网络，例如社交网络、地图等。
在选择数据结构时，需要根据具体的应用场景和需求，权衡各种数据结构的优缺点，选择最合适的数据结构。
7.2.3 编译器优化
编译器可以将高级语言代码（例如 C/C++）转换为机器码，编译器的优化能力直接影响程序的执行效率。现代编译器通常提供了多种优化选项，可以帮助开发者提高代码性能。
① 优化级别：编译器通常提供了不同的优化级别，例如 -O0（无优化）、-O1（基本优化）、-O2（常用优化）、-O3（激进优化）等。优化级别越高，编译器进行的优化越多，但编译时间也会相应增加。通常情况下，建议使用 -O2 或 -O3 优化级别。
② 链接时优化（Link-Time Optimization，LTO）：LTO 是一种跨模块的优化技术，可以在链接时对整个程序进行优化。LTO 可以消除跨模块的函数调用开销，提高代码的整体性能。在 CMake 中，可以通过设置 CMAKE_INTERPROCEDURAL_OPTIMIZATION 属性启用 LTO。
③ Profile-Guided Optimization（PGO）：PGO 是一种基于性能剖析的优化技术。它首先通过运行程序的 Profile 版本收集性能数据，然后根据性能数据指导编译器进行优化。PGO 可以使编译器更好地了解程序的运行时行为，从而进行更有效的优化。
④ 指令集优化：编译器可以根据目标 CPU 架构的指令集进行优化，例如使用 SIMD 指令（例如 ARM NEON）来加速向量运算。可以通过编译器选项指定目标 CPU 架构和指令集。
⑤ 手动内联（Inline）：对于一些频繁调用的短小函数，可以手动使用 inline 关键字将其声明为内联函数。内联函数可以减少函数调用开销，提高代码执行效率。但过度使用内联函数可能会导致代码膨胀，反而降低性能。
需要注意的是，编译器优化并非万能的。过度依赖编译器优化可能会导致代码可读性降低，调试难度增加。在进行编译器优化时，需要权衡优化效果和代码维护性。
7.3 内存优化策略：内存泄漏检测与内存池技术
内存管理是 Native 开发中一个重要的方面。不合理的内存管理容易导致内存泄漏、内存碎片等问题，影响应用的性能和稳定性。
7.3.1 内存泄漏检测
内存泄漏（Memory Leak）是指程序在申请内存后，无法释放已申请的内存空间，一次小的内存泄漏可能不会立即造成危害，但如果持续发生，就会导致可用内存逐渐减少，最终导致程序崩溃或系统卡顿。
① 手动代码审查：最基本的内存泄漏检测方法是手动代码审查。仔细检查代码中内存分配和释放的逻辑，确保每一块分配的内存都有对应的释放操作。重点关注以下场景：
⚝ 动态内存分配：使用 malloc、calloc、new 等函数分配的内存，必须使用 free、delete、delete[] 等函数释放。
⚝ 资源句柄：例如文件句柄、Socket 句柄、OpenGL ES 上下文等，使用完毕后必须及时关闭或释放。
⚝ 循环和条件分支：在循环和条件分支中分配的内存，要确保在所有情况下都能正确释放。
⚝ 异常处理：在异常处理代码中，要确保即使发生异常，已分配的内存也能被正确释放。
② 静态分析工具：可以使用静态分析工具（例如 Clang Static Analyzer、Cppcheck）来自动检测代码中的潜在内存泄漏问题。静态分析工具可以在不运行程序的情况下，分析代码的语法和语义，找出可能的内存泄漏点。
③ 动态分析工具：可以使用动态分析工具（例如 Valgrind、AddressSanitizer）在程序运行时检测内存泄漏。动态分析工具会在程序运行时监控内存分配和释放操作，如果发现内存泄漏，会报告泄漏的位置和大小。
⚝ Valgrind：Valgrind 是一套强大的程序调试和性能分析工具，其中的 Memcheck 工具可以检测内存泄漏、内存越界、使用未初始化内存等问题。Valgrind 的优点是功能强大，检测准确率高，缺点是运行速度较慢，会显著降低程序性能。
⚝ AddressSanitizer (ASan)：ASan 是一种轻量级的内存错误检测工具，由 LLVM 项目提供。ASan 的优点是性能开销小，检测速度快，缺点是功能相对 Valgrind 较弱。ASan 可以检测内存泄漏、堆栈溢出、使用释放后内存等问题。在 Android NDK 开发中，可以使用 ASan 进行内存泄漏检测。
④ Android Studio Memory Profiler：Android Studio Memory Profiler 可以实时监控应用的内存使用情况，包括 Java 堆内存和 Native 堆内存。Memory Profiler 可以帮助我们观察内存的增长趋势，如果发现内存持续增长，可能存在内存泄漏。Memory Profiler 还提供了 Heap Dump 功能，可以dump 内存快照，分析内存中的对象分布，进一步定位内存泄漏的根源。
7.3.2 内存池技术
内存池（Memory Pool）是一种内存管理技术，它预先分配一块大的内存块，作为内存池，然后程序从内存池中分配和释放内存，而不是直接向系统申请和释放内存。内存池可以有效地减少内存分配和释放的开销，提高内存管理的效率，并减少内存碎片。
① 内存池的原理：内存池的核心思想是“预分配”和“复用”。程序启动时，内存池会预先分配一块大的内存块，并将这块内存块划分为若干个大小相等的内存块（称为内存单元）。当程序需要分配内存时，内存池会从空闲的内存单元中分配一个，当程序释放内存时，内存单元会被返回到内存池中，供后续分配使用。
② 内存池的优点：
⚝ 提高内存分配和释放效率：内存池的内存分配和释放操作都是在预先分配的内存块内部进行的，避免了频繁的系统调用，减少了内存分配和释放的开销。
⚝ 减少内存碎片：内存池通常采用固定大小的内存单元，可以有效地减少内存碎片。
⚝ 提高内存分配的可预测性：内存池的内存分配时间是可预测的，可以避免因内存分配导致的性能抖动。
③ 内存池的适用场景：内存池适用于以下场景：
⚝ 频繁分配和释放小块内存：例如游戏开发、网络编程等场景，需要频繁地分配和释放小块内存，使用内存池可以显著提高性能。
⚝ 对内存分配性能要求高的场景：例如实时系统、高性能计算等场景，对内存分配的延迟和抖动非常敏感，使用内存池可以提高内存分配的可预测性。
④ 内存池的实现：内存池的实现方式有很多种，常见的实现方式包括：
⚝ 固定大小内存池：内存池中的内存单元大小固定，适用于分配固定大小内存块的场景。
⚝ 可变大小内存池：内存池中的内存单元大小可变，可以分配不同大小的内存块，但实现相对复杂。
⚝ 对象池：对象池是一种特殊的内存池，用于管理对象的生命周期。对象池预先创建一批对象，当程序需要使用对象时，从对象池中获取一个，使用完毕后返回对象池，而不是频繁地创建和销毁对象。
在 Android NDK 开发中，可以根据具体的应用场景选择合适的内存池实现方式。例如，对于需要频繁分配和释放小块内存的游戏引擎，可以使用固定大小内存池或对象池来提高性能。
7.4 多线程优化：线程池与异步任务管理
多线程是提高程序并发性和响应速度的重要手段。在 Native 代码中，合理地使用多线程可以充分利用多核处理器的计算能力，提高程序的整体性能。
7.4.1 线程池
线程池（Thread Pool）是一种线程管理技术，它预先创建一组线程，放入线程池中，当有任务需要执行时，从线程池中获取一个空闲线程来执行任务，任务执行完毕后，线程返回线程池，等待执行下一个任务。线程池可以有效地管理线程的生命周期，减少线程创建和销毁的开销，提高线程的复用率。
① 线程池的优点：
⚝ 减少线程创建和销毁开销：线程的创建和销毁是一个比较耗时的操作，线程池通过线程复用，避免了频繁的线程创建和销毁，提高了程序的性能。
⚝ 提高系统资源利用率：线程池可以控制并发线程的数量，避免过多的线程竞争系统资源，提高系统资源利用率。
⚝ 提高程序响应速度：当有任务到达时，可以立即从线程池中获取线程来执行，提高了程序的响应速度。
⚝ 简化线程管理：线程池封装了线程的创建、销毁和调度等细节，简化了线程管理的代码。
② 线程池的组成：一个典型的线程池通常包含以下几个组成部分：
⚝ 线程池管理器（Thread Pool Manager）：负责创建和管理线程池，包括创建线程、销毁线程、维护线程池状态等。
⚝ 工作队列（Work Queue）：用于存放待执行的任务。
⚝ 工作线程（Worker Thread）：线程池中的线程，负责从工作队列中取出任务并执行。
⚝ 任务接口（Task Interface）：定义任务的接口，通常是一个抽象类或接口，需要执行的任务需要实现该接口。
③ 线程池的工作流程：
⚝ 当有新的任务提交到线程池时，线程池管理器首先将任务放入工作队列。
⚝ 线程池中的工作线程不断地从工作队列中取出任务。
⚝ 工作线程执行任务，任务执行完毕后，线程返回线程池，等待执行下一个任务。
⚝ 如果工作队列为空，工作线程会进入等待状态，直到有新的任务到达。
④ Android NDK 中的线程池实现：在 Android NDK 开发中，可以使用 C++ 标准库提供的 std::thread 和 std::future 等工具来实现线程池。也可以使用一些开源的线程池库，例如 Boost.Asio、libdispatch 等。
7.4.2 异步任务管理
异步任务（Asynchronous Task）是指在后台线程中执行的任务，执行结果可以通过回调函数或 Future 对象返回给主线程。异步任务可以避免耗时操作阻塞主线程，提高应用的响应速度。
① 异步任务的优点：
⚝ 避免主线程阻塞：将耗时操作放在后台线程中执行，避免阻塞主线程，保证主线程的流畅运行。
⚝ 提高应用响应速度：用户操作可以立即得到响应，即使后台任务还在执行，用户也不会感到卡顿。
⚝ 提高并发性：可以同时执行多个异步任务，提高应用的并发性。
② 异步任务的实现方式：在 Android NDK 开发中，可以使用多种方式实现异步任务：
⚝ 使用 std::thread：可以使用 std::thread 创建后台线程，在后台线程中执行耗时操作，然后通过 JNI 回调 Java 层方法，将结果返回给主线程。
⚝ 使用 AsyncTask (Java 层)：可以在 Java 层使用 AsyncTask 类创建异步任务，然后在 doInBackground() 方法中调用 Native 方法执行耗时操作，在 onPostExecute() 方法中处理结果。
⚝ 使用 Handler (Java 层)：可以使用 Handler 将任务 post 到后台线程的 Looper 中执行，然后通过 Handler 将结果 post 回主线程。
⚝ 使用协程 (Coroutine)：可以使用协程（例如 Kotlin Coroutines）来实现异步任务，协程可以简化异步编程的代码，提高代码的可读性和可维护性。
③ 异步任务的注意事项：
⚝ 线程同步：在多线程环境下，需要注意线程同步问题，避免数据竞争和死锁。可以使用互斥锁、条件变量、信号量等同步机制来保护共享资源。
⚝ 线程间通信：异步任务需要在后台线程和主线程之间进行通信，可以使用 JNI 回调、Handler、Future 等方式进行线程间通信。
⚝ 异常处理：在异步任务中，需要处理可能发生的异常，避免异常导致程序崩溃。
⚝ 任务取消：对于长时间运行的异步任务，需要提供取消任务的机制，避免任务长时间占用系统资源。
在实际开发中，需要根据具体的应用场景和需求，选择合适的线程池和异步任务管理方式，并注意线程同步、线程间通信、异常处理和任务取消等问题，才能有效地提高程序的性能和稳定性。
7.5 CPU 架构与指令集优化：ARM Neon 技术
不同的 CPU 架构具有不同的指令集，针对特定的 CPU 架构和指令集进行优化，可以充分发挥硬件的性能优势，提高程序的执行效率。Android 设备主要采用 ARM 架构的 CPU，ARM 架构的 CPU 提供了多种指令集扩展，例如 NEON、VFP、Thumb-2 等。其中，NEON（Advanced SIMD） 是一种强大的 SIMD 指令集扩展，可以显著提高多媒体和信号处理应用的性能。
7.5.1 ARM 架构与指令集
ARM 架构是一种 RISC（Reduced Instruction Set Computing，精简指令集计算）架构，具有低功耗、高性能的特点，广泛应用于移动设备、嵌入式系统等领域。ARM 架构的 CPU 提供了多种指令集，包括：
⚝ ARM 指令集：ARM 架构的基本指令集，32 位定长指令，功能强大，但代码密度相对较低。
⚝ Thumb 指令集：16 位定长指令，代码密度高，但指令功能相对较弱。
⚝ Thumb-2 指令集：混合了 16 位和 32 位指令，兼顾了代码密度和指令功能，是目前 ARM 架构的主流指令集。
⚝ NEON 指令集：Advanced SIMD 指令集，用于加速向量运算，例如图像处理、音频处理、视频处理等。
⚝ VFP 指令集：Vector Floating Point 指令集，用于加速浮点运算。
7.5.2 NEON 技术
NEON 是一种 128 位 SIMD 指令集，可以同时处理多个数据，例如可以同时对 4 个 32 位浮点数或 8 个 16 位整数进行运算。NEON 指令集提供了丰富的向量运算指令，包括加法、减法、乘法、除法、比较、逻辑运算等。使用 NEON 指令集可以显著提高向量运算的性能，尤其是在图像处理、音频处理、视频处理等领域。
① NEON 的优点：
⚝ 提高向量运算性能：NEON 指令集可以并行处理多个数据，显著提高向量运算的性能。
⚝ 降低功耗：使用 NEON 指令集可以减少指令执行次数，降低 CPU 功耗。
⚝ 提高代码效率：使用 NEON 指令集可以用更少的代码实现相同的功能，提高代码效率。
② NEON 的适用场景：NEON 指令集适用于以下场景：
⚝ 图像处理：例如图像滤波、图像变换、图像缩放、图像颜色空间转换等。
⚝ 音频处理：例如音频编解码、音频滤波、音频混音、音频特效等。
⚝ 视频处理：例如视频编解码、视频滤波、视频特效、视频分析等。
⚝ 科学计算：例如矩阵运算、向量运算、数值计算等。
⚝ 机器学习：例如神经网络推理、特征提取、模型训练等。
③ NEON 编程：NEON 编程可以使用以下几种方式：
⚝ NEON Intrinsics：NEON Intrinsics 是 ARM 提供的一组 C/C++ 内联函数，可以直接调用 NEON 指令。NEON Intrinsics 提供了对 NEON 指令的底层访问，可以实现精细的性能控制。
⚝ NEON Assembly：可以直接编写 NEON 汇编代码，可以实现最高的性能，但编程难度较高。
⚝ 编译器自动向量化：现代编译器（例如 GCC、Clang）可以自动将部分 C/C++ 代码向量化，生成 NEON 指令。编译器自动向量化可以简化 NEON 编程，但优化效果可能不如手动使用 NEON Intrinsics 或 NEON Assembly。
④ NEON 优化技巧：
⚝ 数据对齐：NEON 指令要求数据地址对齐到 16 字节边界，未对齐的数据访问会导致性能下降。可以使用 __attribute__((aligned(16))) 属性或 posix_memalign() 函数来分配对齐的内存。
⚝ 数据重排：为了充分利用 NEON 的并行处理能力，可能需要对数据进行重排，例如将 RGB 图像数据转换为 Planar 格式（R、G、B 分量分别存储在不同的数组中）。
⚝ 循环展开：循环展开可以减少循环开销，提高 NEON 代码的执行效率。
⚝ 混合精度计算：在某些情况下，可以使用低精度浮点数（例如半精度浮点数）进行计算，以提高 NEON 的吞吐量。
在 Android NDK 开发中，如果应用涉及到大量的向量运算，可以考虑使用 NEON 技术进行优化，以提高应用的性能。需要注意的是，NEON 优化需要一定的学习成本和开发成本，需要根据具体的性能瓶颈和优化收益来权衡是否使用 NEON 技术。
ENDOF_CHAPTER_
8. chapter 8： NDK 高级主题：架构、安全与跨平台
8.1 NDK 模块化设计：构建可维护的 Native 代码
在大型 Android NDK 项目中，随着代码库的增长和功能的复杂化，模块化设计变得至关重要。模块化能够将一个庞大的系统分解为更小、更易于管理和理解的独立单元（模块），从而显著提高代码的可维护性、可重用性和可测试性。本节将深入探讨 NDK 模块化设计的必要性、原则、方法以及实践策略，旨在帮助开发者构建结构清晰、易于维护和扩展的高质量 Native 代码。
8.1.1 模块化设计的必要性与优势
随着项目规模的扩大，代码复杂性呈指数级增长。如果没有合理的模块化设计，代码将变得难以理解、修改和维护，最终导致开发效率降低和错误率升高。NDK 模块化设计旨在解决这些问题，其必要性与优势体现在以下几个方面：
① 提高代码可维护性（Maintainability）：
▮▮▮▮ⓑ 模块化将代码划分为独立的、功能单一的模块，每个模块职责清晰，降低了代码的理解难度。
▮▮▮▮ⓒ 当需要修改或修复 Bug 时，可以快速定位到相关的模块，减少了对整个系统的影响，降低了维护成本。
② 增强代码可重用性（Reusability）：
▮▮▮▮ⓑ 模块化鼓励开发独立的、通用的模块，这些模块可以在不同的项目或系统的不同部分中重复使用。
▮▮▮▮ⓒ 避免了代码冗余，提高了开发效率，并保证了代码的一致性和质量。
③ 提升团队协作效率（Collaboration Efficiency）：
▮▮▮▮ⓑ 模块化允许团队成员并行开发不同的模块，降低了代码冲突的风险。
▮▮▮▮ⓒ 每个团队成员可以专注于自己负责的模块，提高了开发效率和专业性。
④ 简化单元测试（Unit Testing）：
▮▮▮▮ⓑ 模块化的模块通常具有明确的接口和功能，易于进行独立的单元测试。
▮▮▮▮ⓒ 保证了模块的质量，也为整个系统的稳定性奠定了基础。
⑤ 促进系统扩展性（Extensibility）：
▮▮▮▮ⓑ 模块化设计使得系统更容易扩展新功能。
▮▮▮▮ⓒ 新功能可以以模块的形式添加到系统中，而不会对现有模块造成过大的影响。
8.1.2 NDK 模块化设计原则
在 NDK 项目中进行模块化设计时，应遵循以下关键原则，以确保模块化能够真正发挥其优势：
① 单一职责原则（Single Responsibility Principle, SRP）：
▮▮▮▮ⓑ 每个模块应只负责完成一个明确的功能或任务。
▮▮▮▮ⓒ 避免模块功能过于复杂，导致模块内部耦合度过高。
② 高内聚低耦合原则（High Cohesion, Low Coupling）：
▮▮▮▮ⓑ 高内聚（High Cohesion）：模块内部的各个组成部分应紧密相关，共同完成模块的功能。
▮▮▮▮ⓒ 低耦合（Low Coupling）：模块之间应尽可能独立，减少模块间的依赖关系。模块之间通过定义良好的接口进行通信。
③ 接口隔离原则（Interface Segregation Principle, ISP）：
▮▮▮▮ⓑ 模块应提供简洁、明确的接口，只暴露必要的功能给外部使用。
▮▮▮▮ⓒ 避免模块接口过于臃肿，包含不必要的功能，导致客户端被迫依赖不需要的接口。
④ 依赖倒置原则（Dependency Inversion Principle, DIP）：
▮▮▮▮ⓑ 高层模块不应依赖于低层模块，两者都应依赖于抽象。
▮▮▮▮ⓒ 抽象不应依赖于细节，细节应依赖于抽象。
▮▮▮▮ⓓ 通过接口或抽象类来定义模块间的交互，降低模块间的直接依赖。
8.1.3 NDK 模块化设计方法与实践
在 NDK 项目中，可以采用多种方法来实现模块化设计。以下是一些常用的方法和实践策略：
① 静态库与动态库（Static Library & Shared Library）：
▮▮▮▮ⓑ 将不同的功能模块编译成独立的静态库（.a）或动态库（.so）。
▮▮▮▮ⓒ 主程序或模块之间通过链接这些库来使用模块的功能。
▮▮▮▮ⓓ 静态库：在编译时链接到可执行文件中，运行时不再需要库文件，但会增加可执行文件的大小。
▮▮▮▮ⓔ 动态库：在运行时加载，可以减小可执行文件的大小，并且多个程序可以共享同一个动态库，节省内存。
▮▮▮▮ⓕ 使用 CMake 可以方便地创建和管理静态库和动态库目标。
1
# CMakeLists.txt 示例：创建静态库和动态库
2
3
# 创建静态库 my_module_static
4
add_library(my_module_static STATIC
5
my_module.cpp
6
my_module.h
7
)
8
9
# 创建动态库 my_module_shared
10
add_library(my_module_shared SHARED
11
my_module.cpp
12
my_module.h
13
)
14
15
# 主程序链接静态库
16
add_executable(main_app main.cpp)
17
target_link_libraries(main_app my_module_static)
18
19
# 另一个程序链接动态库
20
add_executable(another_app another.cpp)
21
target_link_libraries(another_app my_module_shared)
② 命名空间（Namespace）：
▮▮▮▮ⓑ 使用 C++ 命名空间将不同的模块的代码隔离在不同的命名空间中。
▮▮▮▮ⓒ 避免全局命名冲突，提高代码的可读性和可维护性。
1
// my_module.h
2
namespace MyModule {
3
4
void moduleFunction();
5
6
class ModuleClass {
7
public:
8
void doSomething();
9
};
10
11
} // namespace MyModule
12
13
// my_module.cpp
14
#include "my_module.h"
15
#include <android/log.h>
16
17
namespace MyModule {
18
19
void moduleFunction() {
20
__android_log_print(ANDROID_LOG_INFO, "MyModule", "moduleFunction called");
21
}
22
23
void ModuleClass::doSomething() {
24
__android_log_print(ANDROID_LOG_INFO, "MyModule", "ModuleClass::doSomething called");
25
}
26
27
} // namespace MyModule
28
29
// main.cpp
30
#include "my_module.h"
31
32
int main() {
33
MyModule::moduleFunction();
34
MyModule::ModuleClass moduleObj;
35
moduleObj.doSomething();
36
return 0;
37
}
③ 组件化架构（Component-Based Architecture）：
▮▮▮▮ⓑ 将系统分解为多个独立的、可复用的组件（Components）。
▮▮▮▮ⓒ 每个组件封装特定的功能，组件之间通过接口进行交互。
▮▮▮▮ⓓ 组件可以独立开发、测试和部署，提高了系统的灵活性和可扩展性。
▮▮▮▮ⓔ 在 NDK 中，可以将功能模块设计为组件，例如：音频组件、视频组件、图像处理组件等。
④ 服务化架构（Service-Oriented Architecture, SOA）：
▮▮▮▮ⓑ 将系统功能抽象为一系列独立的服务（Services）。
▮▮▮▮ⓒ 服务之间通过网络或进程间通信（IPC）进行交互。
▮▮▮▮ⓓ 服务化架构适用于构建分布式系统，可以提高系统的可伸缩性和可靠性。
▮▮▮▮ⓔ 在 Android NDK 中，可以使用 Binder 或 Socket 等技术实现服务间的通信。
8.1.4 模块间通信与依赖管理
模块化设计的一个关键方面是模块间的通信和依赖管理。合理的模块间通信机制和清晰的依赖关系是保证模块化系统正常运行的基础。
① 接口定义与抽象：
▮▮▮▮ⓑ 模块间应通过定义良好的接口进行通信，而不是直接依赖于彼此的实现细节。
▮▮▮▮ⓒ 使用抽象类或纯虚函数来定义接口，可以降低模块间的耦合度，提高系统的灵活性。
② 依赖注入（Dependency Injection, DI）：
▮▮▮▮ⓑ 将模块的依赖关系从模块内部转移到外部进行管理。
▮▮▮▮ⓒ 通过构造函数注入、Setter 方法注入或接口注入等方式，将依赖对象传递给模块。
▮▮▮▮ⓓ 提高了模块的独立性和可测试性。
③ 事件总线（Event Bus）：
▮▮▮▮ⓑ 使用事件总线作为模块间通信的中心枢纽。
▮▮▮▮ⓒ 模块可以发布事件到事件总线，其他模块可以订阅感兴趣的事件。
▮▮▮▮ⓓ 实现模块间的解耦，适用于异步事件处理和模块间消息传递。
④ 消息队列（Message Queue）：
▮▮▮▮ⓑ 使用消息队列进行模块间的异步通信。
▮▮▮▮ⓒ 模块可以将消息发送到消息队列，其他模块从消息队列中接收消息进行处理。
▮▮▮▮ⓓ 适用于处理大量异步任务和模块间数据交换。
8.1.5 模块化设计的实践建议
在 NDK 项目中实践模块化设计时，可以参考以下建议：
① 尽早规划模块化架构：在项目初期就应该考虑模块化设计，避免后期重构的成本。
② 明确模块边界与职责：清晰地定义每个模块的功能和边界，避免模块职责不清或重叠。
③ 保持模块的独立性：尽量减少模块间的依赖，提高模块的独立性和可重用性。
④ 使用版本控制管理模块：对模块进行版本控制，方便模块的升级和维护。
⑤ 持续重构与优化：随着项目的发展，不断审视和优化模块化架构，保持系统的健康和可维护性。
通过合理的模块化设计，NDK 项目可以变得更加结构清晰、易于维护、高效开发和灵活扩展，从而更好地应对复杂性和变化，提升软件质量和开发效率。
8.2 NDK 代码安全：防止逆向工程与安全漏洞
Android NDK 代码由于其 Native 特性，直接运行在底层，拥有更高的执行效率和系统权限，但也因此成为安全防护的重要阵地。NDK 代码的安全问题不仅关系到应用的稳定运行，更关乎用户数据的安全和隐私。本节将深入探讨 NDK 代码安全的重要性，分析常见的安全威胁，并提供一系列防止逆向工程和安全漏洞的实用技术和最佳实践。
8.2.1 NDK 代码安全的重要性
NDK 代码安全在 Android 应用安全体系中占据着至关重要的地位，其重要性体现在以下几个方面：
① 保护核心算法与商业逻辑：
▮▮▮▮ⓑ 许多应用的核心算法和商业逻辑都放在 NDK 层实现，例如：加密算法、图像处理算法、音视频编解码算法等。
▮▮▮▮ⓒ NDK 代码一旦被逆向工程破解，核心算法和商业逻辑将暴露无遗，导致知识产权被侵犯，商业利益受损。
② 防止恶意代码注入与篡改：
▮▮▮▮ⓑ NDK 代码如果存在安全漏洞，容易被恶意攻击者利用，注入恶意代码或篡改程序逻辑。
▮▮▮▮ⓒ 导致应用行为异常，甚至危害用户设备和数据安全。
③ 保障用户数据安全与隐私：
▮▮▮▮ⓑ NDK 代码常常处理敏感用户数据，例如：用户身份信息、支付信息、地理位置信息等。
▮▮▮▮ⓒ 如果 NDK 代码存在安全漏洞，或者被逆向工程破解，敏感用户数据可能被泄露或滥用，侵犯用户隐私。
④ 提升应用安全性与可信度：
▮▮▮▮ⓑ 安全的 NDK 代码是构建安全可靠 Android 应用的基础。
▮▮▮▮ⓒ 提升应用的安全性，可以增强用户对应用的信任度，提高用户满意度和忠诚度。
8.2.2 NDK 代码安全威胁分析
NDK 代码面临着多种安全威胁，主要包括以下几种类型：
① 逆向工程（Reverse Engineering）：
▮▮▮▮ⓑ 攻击者通过反编译、反汇编、动态调试等技术手段，分析 NDK 代码的内部结构、算法逻辑和实现细节。
▮▮▮▮ⓒ 逆向工程是所有 NDK 代码安全威胁的基础，一旦代码被成功逆向，后续的安全防护措施将形同虚设。
② 代码注入（Code Injection）：
▮▮▮▮ⓑ 攻击者利用 NDK 代码中的漏洞，例如：缓冲区溢出、格式化字符串漏洞等，向程序注入恶意代码。
▮▮▮▮ⓒ 注入的恶意代码可以在程序运行时执行，篡改程序行为，窃取用户数据，甚至控制用户设备。
③ 数据篡改（Data Tampering）：
▮▮▮▮ⓑ 攻击者通过修改 NDK 代码或运行时内存数据，篡改程序的运行逻辑或数据内容。
▮▮▮▮ⓒ 例如：修改游戏中的金币数量、修改支付金额等，破坏程序的正常功能和数据完整性。
④ 拒绝服务攻击（Denial of Service, DoS）：
▮▮▮▮ⓑ 攻击者利用 NDK 代码中的漏洞，或者通过大量恶意请求，消耗系统资源，导致程序崩溃或无法正常提供服务。
▮▮▮▮ⓒ 例如：内存耗尽攻击、CPU 资源耗尽攻击等。
⑤ 侧信道攻击（Side-Channel Attack）：
▮▮▮▮ⓑ 攻击者通过分析程序的运行时间、功耗、电磁辐射等侧信道信息，推断程序的内部状态或敏感数据。
▮▮▮▮ⓒ 例如：时序攻击、功耗分析攻击等。
8.2.3 防止 NDK 代码逆向工程的技术
为了防止 NDK 代码被逆向工程破解，可以采用以下技术手段：
① 代码混淆（Code Obfuscation）：
▮▮▮▮ⓑ 符号混淆（Symbol Obfuscation）：将函数名、变量名、类名等符号替换为无意义的字符串，增加代码的可读性难度。
▮▮▮▮ⓒ 控制流混淆（Control Flow Obfuscation）：打乱程序的控制流程，例如：插入无用代码、修改条件判断、增加跳转等，使代码逻辑更加复杂。
▮▮▮▮ⓓ 数据混淆（Data Obfuscation）：对字符串、常量、数据结构等进行加密或编码，增加数据分析的难度。
▮▮▮▮ⓔ 指令替换（Instruction Substitution）：将常用的指令替换为等价但更复杂的指令序列，增加反汇编分析的难度。
▮▮▮▮ⓕ 商业混淆工具：可以使用商业级的 NDK 代码混淆工具，例如：ProGuard（虽然 ProGuard 主要用于 Java 代码混淆，但也可以通过配置对 Native 代码进行一定程度的混淆）、DexGuard、Armadillo 等。
② Native 代码保护工具：
▮▮▮▮ⓑ 使用专业的 Native 代码保护工具，例如：梆梆加固、爱加密、360 加固等。
▮▮▮▮ⓒ 这些工具通常提供代码加密、反调试、反 Hook、完整性校验等多种保护功能，可以有效提高 NDK 代码的安全性。
③ 反调试技术（Anti-Debugging）：
▮▮▮▮ⓑ 检测调试器：在程序运行时检测是否存在调试器附加，如果检测到调试器，则采取反调试措施，例如：退出程序、修改程序行为、增加调试难度等。
▮▮▮▮ⓒ 阻止调试器附加：通过技术手段阻止调试器附加到程序进程，例如：使用 ptrace 系统调用阻止其他进程附加到当前进程。
▮▮▮▮ⓓ 对抗动态分析：增加动态分析的难度，例如：使用花指令、不透明谓词、虚假控制流等技术，干扰调试器的分析。
④ 代码虚拟化（Code Virtualization）：
▮▮▮▮ⓑ 将 NDK 代码编译成自定义的虚拟机指令，然后在自定义的虚拟机中解释执行。
▮▮▮▮ⓒ 虚拟机指令与目标平台的指令集不同，逆向工程人员需要先逆向虚拟机，才能理解程序的真实逻辑，大大增加了逆向难度。
▮▮▮▮ⓓ 代码虚拟化是一种高级的代码保护技术，安全性较高，但性能开销也较大。
⑤ 完整性校验（Integrity Check）：
▮▮▮▮ⓑ 在程序启动或运行时，对 NDK 代码进行完整性校验，例如：计算代码的 Hash 值，与预先存储的 Hash 值进行比较。
▮▮▮▮ⓒ 如果代码被篡改，校验将失败，程序可以采取相应的措施，例如：退出程序、重新加载代码等。
▮▮▮▮ⓓ 可以防止代码被运行时篡改。
8.2.4 防止 NDK 代码安全漏洞的最佳实践
除了防止逆向工程，还需要关注 NDK 代码本身的安全漏洞，以下是一些最佳实践：
① 输入验证（Input Validation）：
▮▮▮▮ⓑ 对所有来自外部的输入数据进行严格的验证，包括：JNI 传递的参数、文件读取的数据、网络接收的数据等。
▮▮▮▮ⓒ 验证输入数据的类型、格式、范围等，防止恶意输入导致缓冲区溢出、格式化字符串漏洞等安全问题。
② 内存安全（Memory Safety）：
▮▮▮▮ⓑ 避免缓冲区溢出：使用安全的字符串处理函数，例如：strncpy、strncat、snprintf 等，限制字符串操作的长度。
▮▮▮▮ⓒ 防止内存泄漏：及时释放不再使用的内存，避免内存泄漏导致程序崩溃或性能下降。
▮▮▮▮ⓓ 使用智能指针：在 C++ 中使用智能指针（std::unique_ptr、std::shared_ptr）管理内存，自动释放内存，减少内存管理错误。
③ 安全编码规范（Secure Coding Practices）：
▮▮▮▮ⓑ 遵循安全编码规范，例如：CERT C/C++ Secure Coding Standard、MISRA C/C++ 等。
▮▮▮▮ⓒ 避免使用不安全的函数，例如：strcpy、sprintf 等，使用更安全的替代函数。
▮▮▮▮ⓓ 编写清晰、简洁、易于理解的代码，减少代码错误的可能性。
④ 最小权限原则（Principle of Least Privilege）：
▮▮▮▮ⓑ NDK 代码只申请必要的权限，避免过度授权。
▮▮▮▮ⓒ 降低安全风险，即使代码存在漏洞，攻击者也无法利用过多的权限进行恶意操作。
⑤ 代码审查与安全测试（Code Review & Security Testing）：
▮▮▮▮ⓑ 进行定期的代码审查，检查代码中是否存在潜在的安全漏洞。
▮▮▮▮ⓒ 进行安全测试，例如：静态代码分析、动态漏洞扫描、渗透测试等，发现并修复安全漏洞。
⑥ 及时更新依赖库（Dependency Updates）：
▮▮▮▮ⓑ NDK 代码常常依赖于第三方库，例如：OpenSSL、zlib、libpng 等。
▮▮▮▮ⓒ 及时更新这些依赖库到最新版本，修复已知的安全漏洞。
⑦ 错误处理与日志记录（Error Handling & Logging）：
▮▮▮▮ⓑ 完善的错误处理机制可以防止程序在遇到错误时崩溃或泄露敏感信息。
▮▮▮▮ⓒ 详细的日志记录可以帮助开发者快速定位和修复安全问题。
▮▮▮▮ⓓ 但需要注意，日志记录不应包含敏感信息，避免日志泄露敏感数据。
NDK 代码安全是一个持续改进的过程，需要开发者不断学习新的安全技术，关注最新的安全威胁，并将其应用到实际的开发工作中，才能有效地保护 NDK 代码的安全，保障 Android 应用的安全可靠运行。
8.3 NDK 跨平台开发：C/C++ 代码的平台适配策略
跨平台开发是现代软件开发的重要趋势，它可以减少开发成本，提高代码复用率，并快速覆盖多个平台。Android NDK 允许开发者使用 C/C++ 编写 Native 代码，而 C/C++ 本身就具有良好的跨平台特性。然而，Android 平台与其他平台（如 iOS、Windows、Linux 等）在系统 API、硬件架构、库支持等方面存在差异。因此，在进行 NDK 跨平台开发时，需要采取相应的平台适配策略，以确保 C/C++ 代码能够在不同平台上正确、高效地运行。本节将深入探讨 NDK 跨平台开发的挑战，并提供一系列实用的平台适配策略和技术。
8.3.1 NDK 跨平台开发的挑战
NDK 跨平台开发面临着诸多挑战，主要包括以下几个方面：
① 操作系统 API 差异：
▮▮▮▮ⓑ 不同操作系统提供不同的系统 API，例如：文件 I/O、网络编程、线程管理、图形图像处理等。
▮▮▮▮ⓒ Android 使用 Linux 内核，但其系统 API 与标准的 Linux API 存在差异，例如：Android Log 系统、Binder IPC 机制、OpenGL ES 等。
▮▮▮▮ⓓ iOS、Windows 等平台则有各自独特的系统 API。
② 硬件架构差异：
▮▮▮▮ⓑ 不同平台可能使用不同的 CPU 架构，例如：ARM、x86、MIPS 等。
▮▮▮▮ⓒ 同一架构下，不同平台的指令集和硬件特性也可能存在差异。
▮▮▮▮ⓓ 需要针对不同的硬件架构进行编译和优化，以获得最佳性能。
③ 库支持差异：
▮▮▮▮ⓑ 不同平台支持的 C/C++ 标准库和第三方库可能存在差异。
▮▮▮▮ⓒ 例如：Android NDK 提供的 C++ 标准库支持程度可能与桌面 Linux 不同。
▮▮▮▮ⓓ 某些第三方库可能只在特定平台上可用，或者在不同平台上的版本和功能存在差异。
④ 编译工具链差异：
▮▮▮▮ⓑ 不同平台使用不同的编译工具链，例如：GCC、Clang、Visual C++ 等。
▮▮▮▮ⓒ 编译选项、链接方式、ABI 兼容性等方面可能存在差异。
▮▮▮▮ⓓ 需要使用平台特定的编译工具链进行编译。
⑤ 调试与测试差异：
▮▮▮▮ⓑ 不同平台的调试工具和测试环境可能存在差异。
▮▮▮▮ⓒ 例如：Android 使用 ADB 和 Android Studio 进行调试，iOS 使用 Xcode 进行调试。
▮▮▮▮ⓓ 需要针对不同平台进行调试和测试，确保代码在各个平台上运行正常。
8.3.2 NDK 跨平台开发策略
为了应对 NDK 跨平台开发的挑战，可以采用以下策略：
① 条件编译（Conditional Compilation）：
▮▮▮▮ⓑ 使用 C/C++ 预处理器指令（#ifdef、#ifndef、#elif、#define 等）根据不同的平台选择性地编译代码。
▮▮▮▮ⓒ 通过预定义的宏来识别不同的平台，例如：__ANDROID__、__linux__、__APPLE__、_WIN32 等。
▮▮▮▮ⓓ 可以针对不同平台编写平台特定的代码，同时保持代码的整体结构和逻辑一致。
1
#include <stdio.h>
2
3
void platform_specific_function() {
4
#ifdef __ANDROID__
5
// Android 平台特定代码
6
printf("Running on Android\n");
7
// 使用 Android 特定的 API，例如：__android_log_print
8
__android_log_print(ANDROID_LOG_INFO, "CrossPlatform", "This is Android log");
9
#elif __APPLE__
10
// iOS 平台特定代码
11
printf("Running on iOS\n");
12
// 使用 iOS 特定的 API，例如：NSLog
13
NSLog(@"This is iOS log");
14
#elif _WIN32
15
// Windows 平台特定代码
16
printf("Running on Windows\n");
17
// 使用 Windows 特定的 API，例如：OutputDebugString
18
OutputDebugStringW(L"This is Windows debug output\n");
19
#else
20
// 其他平台通用代码
21
printf("Running on an unknown platform\n");
22
#endif
23
}
24
25
int main() {
26
platform_specific_function();
27
return 0;
28
}
② 抽象层（Abstraction Layer）：
▮▮▮▮ⓑ 将平台相关的代码封装在抽象层中，提供统一的接口给上层使用。
▮▮▮▮ⓒ 上层代码只需要调用抽象层的接口，无需关心底层平台的具体实现。
▮▮▮▮ⓓ 降低了平台依赖性，提高了代码的可移植性和可维护性。
▮▮▮▮ⓔ 可以为不同的平台实现不同的抽象层实现，实现平台适配。
1
// cross_platform_api.h - 抽象层头文件
2
#ifndef CROSS_PLATFORM_API_H
3
#define CROSS_PLATFORM_API_H
4
5
#include <string>
6
7
// 抽象日志接口
8
class Logger {
9
public:
10
virtual ~Logger() = default;
11
virtual void logInfo(const std::string& message) = 0;
12
virtual void logError(const std::string& message) = 0;
13
};
14
15
// 创建 Logger 实例的工厂函数
16
Logger* createLogger();
17
18
#endif // CROSS_PLATFORM_API_H
19
20
// android_logger.h - Android 平台 Logger 实现
21
#ifndef ANDROID_LOGGER_H
22
#define ANDROID_LOGGER_H
23
24
#include "cross_platform_api.h"
25
#include <android/log.h>
26
27
class AndroidLogger : public Logger {
28
public:
29
void logInfo(const std::string& message) override;
30
void logError(const std::string& message) override;
31
};
32
33
#endif // ANDROID_LOGGER_H
34
35
// android_logger.cpp - Android 平台 Logger 实现
36
#include "android_logger.h"
37
38
void AndroidLogger::logInfo(const std::string& message) {
39
__android_log_print(ANDROID_LOG_INFO, "AppLog", "%s", message.c_str());
40
}
41
42
void AndroidLogger::logError(const std::string& message) {
43
__android_log_print(ANDROID_LOG_ERROR, "AppLog", "%s", message.c_str());
44
}
45
46
// ios_logger.h - iOS 平台 Logger 实现 (示例，实际需要 iOS 实现)
47
#ifndef IOS_LOGGER_H
48
#define IOS_LOGGER_H
49
50
#include "cross_platform_api.h"
51
// 假设 iOS 使用 NSLog
52
53
class IOSLogger : public Logger {
54
public:
55
void logInfo(const std::string& message) override;
56
void logError(const std::string& message) override;
57
};
58
59
#endif // IOS_LOGGER_H
60
61
// ios_logger.cpp - iOS 平台 Logger 实现 (示例，实际需要 iOS 实现)
62
#include "ios_logger.h"
63
#include <Foundation/Foundation.h> // 假设需要 Foundation 框架
64
65
void IOSLogger::logInfo(const std::string& message) {
66
NSLog(@"[INFO] %@", message.c_str());
67
}
68
69
void IOSLogger::logError(const std::string& message) {
70
NSLog(@"[ERROR] %@", message.c_str());
71
}
72
73
74
// logger_factory.cpp - Logger 工厂函数
75
#include "cross_platform_api.h"
76
77
#ifdef __ANDROID__
78
#include "android_logger.h"
79
#elif __APPLE__
80
#include "ios_logger.h"
81
#else
82
// 默认 Logger 实现，例如：控制台输出
83
class DefaultLogger : public Logger {
84
public:
85
void logInfo(const std::string& message) override {
86
printf("[INFO] %s\n", message.c_str());
87
}
88
void logError(const std::string& message) override {
89
fprintf(stderr, "[ERROR] %s\n", message.c_str());
90
}
91
};
92
#endif
93
94
95
Logger* createLogger() {
96
#ifdef __ANDROID__
97
return new AndroidLogger();
98
#elif __APPLE__
99
return new IOSLogger();
100
#else
101
return new DefaultLogger();
102
#endif
103
}
104
105
// main.cpp - 使用抽象层
106
#include "cross_platform_api.h"
107
108
int main() {
109
Logger* logger = createLogger();
110
logger->logInfo("Application started");
111
// ... 应用程序逻辑 ...
112
logger->logError("An error occurred");
113
delete logger;
114
return 0;
115
}
③ 跨平台构建工具（Cross-Platform Build Tools）：
▮▮▮▮ⓑ 使用跨平台构建工具，例如：CMake、Gradle、Bazel 等，管理项目的构建过程。
▮▮▮▮ⓒ 这些工具可以生成不同平台下的构建文件（例如：Makefile、Xcode 工程、Visual Studio 工程等）。
▮▮▮▮ⓓ 简化了跨平台构建的配置和管理，提高了构建效率。
▮▮▮▮ⓔ CMake 是 NDK 开发中常用的构建工具，可以方便地配置不同平台的编译选项和依赖库。
④ 跨平台库（Cross-Platform Libraries）：
▮▮▮▮ⓑ 尽可能使用跨平台库，例如：SDL（Simple DirectMedia Layer）、Qt、Boost、C++ 标准库等。
▮▮▮▮ⓒ 这些库在多个平台上提供了统一的 API，减少了平台差异带来的开发工作量。
▮▮▮▮ⓓ 但需要注意，某些跨平台库在不同平台上的性能和功能可能存在差异，需要进行评估和测试。
⑤ 平台特性检测（Platform Feature Detection）：
▮▮▮▮ⓑ 在运行时检测当前平台是否支持某些特性或 API。
▮▮▮▮ⓒ 例如：检测是否支持 Vulkan 图形 API、是否支持特定的硬件加速功能等。
▮▮▮▮ⓓ 根据检测结果选择不同的实现路径，以充分利用平台特性，同时保证在不支持特性的平台上也能正常运行。
1
#include <iostream>
2
3
bool isVulkanSupported() {
4
// 平台特性检测代码，例如：尝试加载 Vulkan 库或查询系统信息
5
#ifdef __ANDROID__
6
// Android 平台 Vulkan 支持检测 (示例，实际需要更严谨的检测)
7
void* vulkanLib = dlopen("libvulkan.so", RTLD_NOW);
8
if (vulkanLib != nullptr) {
9
dlclose(vulkanLib);
10
return true;
11
} else {
12
return false;
13
}
14
#elif _WIN32
15
// Windows 平台 Vulkan 支持检测 (示例，实际需要更严谨的检测)
16
HMODULE vulkanLib = LoadLibraryW(L"vulkan-1.dll");
17
if (vulkanLib != nullptr) {
18
FreeLibrary(vulkanLib);
19
return true;
20
} else {
21
return false;
22
}
23
#else
24
// 其他平台 Vulkan 支持检测 (示例，可能需要更通用的方法)
25
// ...
26
return false; // 默认不支持
27
#endif
28
}
29
30
int main() {
31
if (isVulkanSupported()) {
32
std::cout << "Vulkan is supported on this platform." << std::endl;
33
// 使用 Vulkan API 进行图形渲染
34
} else {
35
std::cout << "Vulkan is not supported. Falling back to OpenGL ES." << std::endl;
36
// 使用 OpenGL ES API 进行图形渲染
37
}
38
return 0;
39
}
8.3.3 NDK 跨平台开发的实践建议
在 NDK 跨平台开发实践中，可以参考以下建议：
① 优先考虑跨平台库：在选择库时，优先考虑成熟的跨平台库，例如：SDL、Qt、Boost 等，减少平台适配的工作量。
② 合理使用条件编译：条件编译适用于处理少量的平台差异，但过度使用条件编译会使代码难以维护，应尽量使用抽象层来隔离平台差异。
③ 充分测试不同平台：在所有目标平台上进行充分的测试，包括功能测试、性能测试、兼容性测试等，确保代码在各个平台上运行正常。
④ 持续关注平台更新：不同平台的系统和库都在不断更新，需要持续关注平台更新，及时调整和优化跨平台代码。
⑤ 模块化平台适配代码：将平台适配代码模块化，方便管理和维护，例如：将不同平台的抽象层实现放在不同的目录或库中。
通过合理的跨平台开发策略和实践，可以有效地降低 NDK 跨平台开发的难度，提高代码复用率，并快速将 Android 应用扩展到其他平台，实现更大的商业价值。
8.4 NDK 与 Kotlin Native：Kotlin Native 与 NDK 的互操作
Kotlin Native 是一种将 Kotlin 代码编译成 Native 可执行文件的技术，它允许开发者使用 Kotlin 语言进行跨平台 Native 开发。Kotlin Native 可以与 C/C++ 代码进行互操作，包括调用 C/C++ 库和被 C/C++ 代码调用。这为 Android NDK 开发带来了新的可能性，开发者可以使用 Kotlin Native 编写跨平台的 Native 代码，并与现有的 NDK 代码进行集成。本节将介绍 Kotlin Native 的基本概念，探讨 Kotlin Native 与 NDK 的互操作机制，并展示如何在 NDK 项目中使用 Kotlin Native。
8.4.1 Kotlin Native 简介
Kotlin Native 是 Kotlin 编程语言的一个编译目标，它使用 LLVM 编译器将 Kotlin 代码编译成独立的可执行文件，无需 Java 虚拟机（JVM）或 Android Runtime（ART）。Kotlin Native 支持多种平台，包括 iOS、macOS、Windows、Linux、Android 等。
Kotlin Native 的主要特点包括：
① 跨平台 Native 开发：使用 Kotlin 编写的 Native 代码可以编译成多个平台的可执行文件，实现代码复用。
② 无需 JVM/ART：Kotlin Native 代码直接运行在操作系统之上，没有 JVM/ART 的开销，性能接近原生 C/C++ 代码。
③ 与 C/C++ 互操作：Kotlin Native 可以方便地调用 C/C++ 库，也可以被 C/C++ 代码调用，实现混合编程。
④ 内存安全与并发安全：Kotlin Native 具有内存安全和并发安全的特性，可以减少内存泄漏和数据竞争等问题。
⑤ 现代语言特性：Kotlin 语言本身具有简洁、安全、表达力强等优点，提高了开发效率和代码质量。
8.4.2 Kotlin Native 与 NDK 互操作机制
Kotlin Native 与 NDK 的互操作主要通过以下机制实现：
① C 互操作（C Interop）：
▮▮▮▮ⓑ Kotlin Native 提供了 C 互操作功能，允许 Kotlin 代码直接调用 C 语言编写的库和函数。
▮▮▮▮ⓒ 通过 Kotlin Native 的 cinterop 工具，可以根据 C 头文件生成 Kotlin 代码，用于访问 C 库。
▮▮▮▮ⓓ 可以将 NDK 编译生成的 C/C++ 库封装成 C 接口，然后在 Kotlin Native 代码中调用这些 C 接口。
② JNI 桥接（JNI Bridge）：
▮▮▮▮ⓑ Kotlin Native 可以通过 JNI 桥接与 Android Java 代码进行互操作。
▮▮▮▮ⓒ Kotlin Native 代码可以编译成动态库（.so 文件），然后在 Java 代码中通过 JNI 加载和调用。
▮▮▮▮ⓓ 也可以在 Kotlin Native 代码中调用 Java 代码，实现双向互操作。
③ Kotlin/Native Objective-C 互操作（Objective-C Interop）：
▮▮▮▮ⓑ 对于 iOS 平台，Kotlin Native 提供了 Objective-C 互操作功能，可以与 Objective-C/Swift 代码进行互操作。
▮▮▮▮ⓒ 可以调用 iOS 系统 API 和 Objective-C 库。
▮▮▮▮ⓓ 虽然与 NDK 无直接关系，但在跨平台开发中，Objective-C 互操作也是重要的组成部分。
8.4.3 在 NDK 项目中使用 Kotlin Native
在 NDK 项目中，可以将 Kotlin Native 用于以下方面：
① 编写跨平台 Native 模块：
▮▮▮▮ⓑ 使用 Kotlin Native 编写跨平台的 Native 模块，例如：数据处理模块、网络通信模块、算法模块等。
▮▮▮▮ⓒ 这些模块可以编译成多个平台（包括 Android）的动态库，提高代码复用率。
▮▮▮▮ⓓ Android 应用可以通过 JNI 调用 Kotlin Native 编译的动态库。
② 替代部分 C/C++ 代码：
▮▮▮▮ⓑ 对于一些性能要求不高，但逻辑复杂的 Native 代码，可以使用 Kotlin Native 替代 C/C++ 编写。
▮▮▮▮ⓒ Kotlin 语言的现代特性和安全性可以提高开发效率和代码质量。
▮▮▮▮ⓓ 例如：配置文件解析、数据序列化、业务逻辑处理等。
③ 构建跨平台应用框架：
▮▮▮▮ⓑ 使用 Kotlin Native 构建跨平台应用框架，例如：游戏引擎、UI 框架、多媒体框架等。
▮▮▮▮ⓒ 基于 Kotlin Native 框架开发的应用可以更容易地移植到多个平台。
▮▮▮▮ⓓ Android 平台可以使用 NDK 集成 Kotlin Native 框架。
8.4.4 Kotlin Native 与 NDK 互操作示例
以下是一个简单的示例，演示如何在 Kotlin Native 代码中调用 NDK 编译的 C++ 库：
C++ 库 (NDK 编译)
1
// my_cpp_lib.h
2
#ifndef MY_CPP_LIB_H
3
#define MY_CPP_LIB_H
4
5
extern "C" { // 使用 extern "C" 保证 C 兼容性
6
7
int add(int a, int b);
8
9
} // extern "C"
10
11
#endif // MY_CPP_LIB_H
12
13
// my_cpp_lib.cpp
14
#include "my_cpp_lib.h"
15
16
int add(int a, int b) {
17
return a + b;
18
}
使用 NDK 编译生成动态库 libmycpplib.so。
Kotlin Native 代码
1
// 项目 build.gradle.kts (Kotlin Native Gradle 插件配置)
2
plugins {
3
kotlin("multiplatform") version "1.9.20"
4
}
5
6
kotlin {
7
androidNativeArm64("android") { // 配置 Android ARM64 目标
8
binaries {
9
sharedLib {
10
baseName = "mylibrary" // 输出动态库名称 libmylibrary.so
11
}
12
}
13
}
14
sourceSets {
15
val androidMain by getting {
16
dependencies {
17
implementation(project(":my-cpp-lib")) // 依赖 NDK 编译的 C++ 库
18
}
19
}
20
val androidInterop by creating { // 创建 interop 源集
21
dependencies {
22
implementation(project(":my-cpp-lib")) // 再次依赖 C++ 库，用于 cinterop
23
}
24
}
25
}
26
}
27
28
// src/androidInterop/kotlin/interop.def (cinterop 定义文件)
29
language = C
30
headers = my_cpp_lib.h // C++ 库头文件
31
package = interop // Kotlin 包名
32
33
// src/androidMain/kotlin/main.kt (Kotlin Native 代码)
34
package com.example.myapplication
35
36
import interop.* // 导入 interop 包
37
38
fun main() {
39
val result = add(5, 3) // 调用 C++ 库的 add 函数
40
println("Result from C++ library: $result")
41
}
在 Android 应用中，将 Kotlin Native 编译生成的 libmylibrary.so 和 NDK 编译生成的 libmycpplib.so 打包到 APK 中，然后在 Java 代码中加载 libmylibrary.so，即可运行 Kotlin Native 代码，并间接调用 C++ 库。
8.4.5 Kotlin Native 的优势与局限性
优势：
① 跨平台性：Kotlin Native 提供了真正的跨平台 Native 开发能力，可以减少平台适配工作。
② 现代语言：Kotlin 语言的现代特性提高了开发效率和代码质量。
③ 互操作性：与 C/C++ 和 Java 的良好互操作性，方便与现有 NDK 代码集成。
④ 性能：接近原生 C/C++ 的性能，适用于性能敏感的应用场景。
局限性：
① 生态系统：Kotlin Native 的生态系统相对 C/C++ 尚不完善，第三方库和工具较少。
② 学习曲线：Kotlin Native 的开发模式和工具链与传统的 Android NDK 开发有所不同，需要一定的学习成本。
③ 调试难度：Kotlin Native 的 Native 代码调试可能比 Java 代码调试更复杂。
④ 内存管理：Kotlin Native 使用自动内存管理（垃圾回收），但与 C/C++ 的手动内存管理有所不同，需要注意内存管理策略。
Kotlin Native 为 Android NDK 开发带来了新的选择，尤其是在跨平台 Native 开发方面具有独特的优势。开发者可以根据项目需求和团队技术栈，选择合适的 Native 开发技术，充分利用 Kotlin Native 和 NDK 的优点，构建更高效、更安全、更可靠的 Android 应用。
8.5 NDK 未来展望：Android Native 开发的趋势与新技术
Android NDK 自发布以来，一直是 Android 开发生态系统中不可或缺的一部分。随着 Android 平台的不断发展和技术的进步，NDK 的未来也充满了新的机遇和挑战。本节将展望 Android Native 开发的未来趋势，探讨 NDK 的发展方向，并介绍一些值得关注的新技术。
8.5.1 Android Native 开发的未来趋势
① 性能优化与效率提升：
▮▮▮▮ⓑ 性能始终是 Android 开发的重要考量因素，尤其是在高性能计算、游戏、音视频处理等领域。
▮▮▮▮ⓒ NDK 将继续在性能优化方面发挥关键作用，提供更高效的 Native 代码执行环境和工具。
▮▮▮▮ⓓ 随着移动设备硬件性能的提升，NDK 将在更多高性能应用场景中得到应用。
② 跨平台 Native 开发需求增长：
▮▮▮▮ⓑ 跨平台开发是降低开发成本、提高代码复用率的重要手段。
▮▮▮▮ⓒ NDK 的跨平台特性将越来越受到重视，开发者将更加关注如何使用 NDK 构建跨平台 Native 模块。
▮▮▮▮ⓓ Kotlin Native 等跨平台 Native 技术将进一步发展，与 NDK 协同工作，提供更完善的跨平台解决方案。
③ 安全防护与代码保护：
▮▮▮▮ⓑ Android 应用安全问题日益突出，NDK 代码安全也变得越来越重要。
▮▮▮▮ⓒ 防止逆向工程、代码注入、安全漏洞等安全威胁将是 NDK 开发的重点关注方向。
▮▮▮▮ⓓ 代码混淆、代码虚拟化、反调试等安全技术将得到更广泛的应用。
④ 与新兴技术的融合：
▮▮▮▮ⓑ 人工智能（AI）、机器学习（ML）、增强现实（AR）、虚拟现实（VR）等新兴技术在 Android 平台上的应用越来越广泛。
▮▮▮▮ⓒ NDK 将在这些新兴技术领域发挥重要作用，例如：使用 NDK 加速机器学习模型的推理计算、开发高性能的 AR/VR 应用等。
▮▮▮▮ⓓ NDK 将与 TensorFlow Lite、OpenGL ES、Vulkan 等技术更紧密地结合。
⑤ 开发工具与生态系统的完善：
▮▮▮▮ⓑ Android 开发工具链将持续完善，提供更强大的 NDK 开发支持，例如：更智能的代码编辑器、更高效的调试器、更便捷的性能分析工具等。
▮▮▮▮ⓒ NDK 的生态系统将更加繁荣，涌现出更多优秀的 NDK 库、框架和工具，降低 NDK 开发门槛，提高开发效率。
8.5.2 NDK 值得关注的新技术
① Android Game Development Kit (AGDK)：
▮▮▮▮ⓑ AGDK 是 Google 推出的 Android 游戏开发套件，旨在简化 Android 游戏开发，提高游戏性能。
▮▮▮▮ⓒ AGDK 包含 C/C++ 游戏库、调试工具、性能分析工具等，可以帮助开发者更高效地开发高质量的 Android 游戏。
▮▮▮▮ⓓ AGDK 基于 NDK 构建，充分利用 NDK 的性能优势。
② Vulkan API 的普及与应用：
▮▮▮▮ⓑ Vulkan 是新一代跨平台图形 API，相比 OpenGL ES 具有更高的性能和更低的 CPU 开销。
▮▮▮▮ⓒ Android 平台对 Vulkan 的支持越来越完善，Vulkan 将逐渐取代 OpenGL ES 成为 Android 图形开发的主流 API。
▮▮▮▮ⓓ NDK 开发者应积极学习和应用 Vulkan API，开发更高效、更精美的图形应用和游戏。
③ Rust 语言在 NDK 开发中的应用：
▮▮▮▮ⓑ Rust 是一种内存安全、并发安全的系统编程语言，具有高性能和高可靠性。
▮▮▮▮ⓒ Rust 语言在 NDK 开发中逐渐受到关注，可以用于替代 C/C++ 编写更安全、更高效的 Native 代码。
▮▮▮▮ⓓ Google 也在积极探索 Rust 在 Android 系统开发中的应用。
④ Jetpack Compose 与 Native 组件的集成：
▮▮▮▮ⓑ Jetpack Compose 是 Android 官方推出的现代 UI 工具包，用于构建声明式 UI。
▮▮▮▮ⓒ 未来 Jetpack Compose 可能会与 NDK 更紧密地集成，允许开发者使用 Native 代码构建高性能的 UI 组件。
▮▮▮▮ⓓ 例如：使用 NDK 渲染自定义 UI 控件、实现高性能的动画效果等。
⑤ 机器学习模型 NDK 部署与加速：
▮▮▮▮ⓑ 机器学习模型在移动设备上的部署和加速是重要的研究方向。
▮▮▮▮ⓒ NDK 可以用于将机器学习模型部署到 Android 设备上，并利用 CPU、GPU、NPU 等硬件加速器进行推理计算。
▮▮▮▮ⓓ TensorFlow Lite、NNAPI 等技术提供了 NDK 接口，方便开发者在 NDK 代码中集成机器学习模型。
8.5.3 NDK 开发者的应对策略
面对 Android Native 开发的未来趋势和新技术，NDK 开发者应采取以下应对策略：
① 持续学习新技术：
▮▮▮▮ⓑ 关注 Android 平台和 NDK 的最新发展动态，学习新的 API、工具和技术，例如：AGDK、Vulkan、Rust、Jetpack Compose 等。
▮▮▮▮ⓒ 保持技术敏感性，不断提升自身的技术能力。
② 加强安全意识：
▮▮▮▮ⓑ 重视 NDK 代码安全，学习和应用代码混淆、反调试、安全编码等安全技术。
▮▮▮▮ⓒ 提高安全编码水平，避免常见的安全漏洞。
③ 拥抱跨平台开发：
▮▮▮▮ⓑ 学习跨平台开发技术，例如：Kotlin Native、CMake 跨平台构建、跨平台库等。
▮▮▮▮ⓒ 掌握跨平台开发方法，提高代码复用率，降低开发成本。
④ 关注性能优化：
▮▮▮▮ⓑ 深入理解 Android 平台的性能优化原理和技术，例如：CPU 架构优化、内存优化、多线程优化等。
▮▮▮▮ⓒ 掌握性能分析工具的使用，例如：Profiler、Systrace 等，持续优化 NDK 代码性能。
⑤ 积极参与社区交流：
▮▮▮▮ⓑ 参与 Android NDK 开发者社区的交流和讨论，分享经验，学习他人的实践，共同进步。
▮▮▮▮ⓒ 关注 Google 官方的 NDK 博客、文档和示例代码，及时获取最新的 NDK 信息。
Android NDK 在 Android 开发中仍然扮演着重要的角色，并且在未来将继续发挥关键作用。NDK 开发者需要紧跟技术发展趋势，不断学习和进步，才能在未来的 Android 开发领域保持竞争力，并创造出更优秀的应用和产品。
ENDOF_CHAPTER_
9. chapter 9： NDK 实战案例：综合项目开发
9.1 案例一：高性能图像处理应用
在移动应用开发领域，图像处理一直占据着举足轻重的地位。从美颜相机 📸 到图像编辑器 🖼️，再到各种视觉特效应用，高性能的图像处理能力是支撑用户体验的关键。Android 平台上的原生开发工具包 NDK（Native Development Kit）为开发者提供了直接使用 C/C++ 等原生代码进行图像处理的途径，从而释放设备的硬件潜能，实现卓越的性能表现。本节将深入探讨如何利用 NDK 构建高性能的图像处理应用。
9.1.1 需求分析与技术选型
① 需求分析：
⚝ 实时性要求：许多图像处理应用，如相机滤镜、实时美颜等，对处理速度有极高的要求，必须保证实时性，避免出现卡顿现象，影响用户体验。
⚝ 计算密集型：图像处理算法，尤其是复杂的算法，通常是计算密集型的，需要大量的 CPU 运算。
⚝ 跨平台需求：为了提高代码复用率和开发效率，开发者可能希望图像处理核心算法能够跨平台运行，而 C/C++ 代码具有良好的跨平台性。
② 技术选型：
⚝ NDK 的优势：
▮▮▮▮ⓐ 性能优势：C/C++ 代码在执行效率上通常优于 Java 代码，尤其是在 CPU 密集型任务中，NDK 可以充分利用底层硬件资源，提供更高的性能。
▮▮▮▮ⓑ 库支持：C/C++ 社区拥有丰富的成熟图像处理库，如 OpenCV（Open Source Computer Vision Library）、libyuv 等，NDK 可以方便地集成这些库，加速开发进程。
▮▮▮▮ⓒ 跨平台能力：使用 C/C++ 编写的图像处理核心代码，可以更容易地移植到其他平台，例如 iOS、桌面平台等。
⚝ 常用图像处理库：
▮▮▮▮ⓐ OpenCV：一个强大的开源计算机视觉库，提供了丰富的图像处理和计算机视觉算法，包括图像滤波、特征检测、目标识别等。OpenCV 拥有 C++、Python 和 Java 等多种接口，NDK 可以方便地集成 OpenCV 的 C++ 接口。
▮▮▮▮ⓑ libyuv：Google 开源的 YUV 图像格式转换和处理库，专注于视频编解码和图像格式转换，性能卓越，尤其在 Android 平台上进行了深度优化。
▮▮▮▮ⓒ Skia：Google 开源的 2D 图形库，广泛应用于 Chrome 浏览器和 Android 系统，提供了高性能的 2D 渲染能力，也包含一些图像处理功能。
9.1.2 基于 OpenCV 的图像滤波实战
① OpenCV 库的集成：
⚝ CMake 集成：在 CMakeLists.txt 文件中，可以使用 find_package(OpenCV REQUIRED) 命令查找 OpenCV 库，并使用 target_link_libraries 将 OpenCV 库链接到 NDK 模块。
⚝ 预编译库：也可以下载 OpenCV 的 Android 预编译库，将其添加到项目中，并在 CMakeLists.txt 中指定库的路径。
② JNI 接口设计：
⚝ Java 层接口：在 Java 层定义 JNI 接口，用于调用 Native 层的图像处理函数，例如：
1
public class ImageProcessor {
2
static {
3
System.loadLibrary("image-processor"); // 加载 NDK 库
4
}
5
6
public native void nativeApplyGaussianBlur(Bitmap bitmap, int radius);
7
}
⚝ Native 层接口：在 C++ 代码中实现 JNI 接口函数，例如：
1
#include <jni.h>
2
#include <opencv2/core.hpp>
3
#include <opencv2/imgproc.hpp>
4
#include <android/bitmap.h>
5
6
extern "C" JNIEXPORT void JNICALL
7
Java_com_example_imageprocessor_ImageProcessor_nativeApplyGaussianBlur(
8
JNIEnv* env,
9
jobject /* this */,
10
jobject bitmap,
11
jint radius) {
12
// ... (图像处理逻辑) ...
13
}
③ 图像数据传递与处理：
⚝ Bitmap 数据获取：使用 AndroidBitmap_lockPixels 和 AndroidBitmap_unlockPixels 函数锁定和解锁 Bitmap 的像素数据，获取像素数据的指针。
⚝ OpenCV Mat 转换：将 Bitmap 的像素数据转换为 OpenCV 的 cv::Mat 格式，方便使用 OpenCV 的图像处理函数。
⚝ 高斯模糊算法：使用 OpenCV 的 cv::GaussianBlur 函数实现高斯模糊效果。
⚝ 处理结果回写：将处理后的 cv::Mat 数据写回 Bitmap 的像素数据。
1
extern "C" JNIEXPORT void JNICALL
2
Java_com_example_imageprocessor_ImageProcessor_nativeApplyGaussianBlur(
3
JNIEnv* env,
4
jobject /* this */,
5
jobject bitmap,
6
jint radius) {
7
AndroidBitmapInfo bitmapInfo;
8
void* pixels;
9
AndroidBitmap_getInfo(env, bitmap, &bitmapInfo);
10
AndroidBitmap_lockPixels(env, bitmap, &pixels);
11
12
cv::Mat src(bitmapInfo.height, bitmapInfo.width, CV_8UC4, pixels); // RGBA 格式
13
cv::Mat dst;
14
cv::GaussianBlur(src, dst, cv::Size(radius, radius), 0);
15
dst.copyTo(src); // 将处理结果复制回 src Mat，即 Bitmap 的像素数据
16
17
AndroidBitmap_unlockPixels(env, bitmap);
18
}
④ 性能优化：
⚝ 内存优化：避免在 JNI 层频繁创建和销毁 cv::Mat 对象，可以考虑复用 cv::Mat 对象，减少内存分配和释放的开销。
⚝ 算法优化：选择更高效的图像处理算法，例如使用 Separable Gaussian Blur 优化高斯模糊算法。
⚝ 多线程并行：对于大型图像，可以将图像分割成小块，使用多线程并行处理，提高处理速度。
⚝ NEON 指令集：利用 ARM NEON 指令集加速图像处理运算，OpenCV 默认情况下会启用 NEON 优化。
9.1.3 案例总结与展望
通过 NDK 和 OpenCV，我们可以构建高性能的 Android 图像处理应用。本案例演示了如何使用 NDK 集成 OpenCV 库，并实现高斯模糊滤镜。在实际开发中，可以根据具体需求选择合适的图像处理算法和库，并进行性能优化，以满足应用的性能要求。未来，随着移动设备硬件性能的不断提升和图像处理算法的不断发展，NDK 在高性能图像处理领域将发挥更加重要的作用。
9.2 案例二：跨平台音视频播放器
音视频播放是移动应用中常见的核心功能之一。为了支持丰富的音视频格式、提供流畅的播放体验，并实现跨平台兼容性，使用 NDK 开发音视频播放器成为一种流行的选择。本节将探讨如何利用 NDK 构建一个跨平台的音视频播放器。
9.2.1 需求分析与技术选型
① 需求分析：
⚝ 格式兼容性：需要支持多种常见的音视频格式，例如 MP4、MKV、AVI、MP3、AAC 等。
⚝ 解码性能：需要高效的音视频解码能力，保证高清视频的流畅播放，尤其是在低端设备上。
⚝ 跨平台性：为了减少重复开发工作，希望播放器核心代码能够跨平台运行，支持 Android、iOS、甚至桌面平台。
⚝ 功能扩展性：需要支持常见的播放器功能，例如播放、暂停、快进、快退、音量调节、字幕显示等，并具备良好的扩展性，方便后续添加新功能。
② 技术选型：
⚝ NDK 的优势：
▮▮▮▮ⓐ 性能优势：音视频解码和渲染是计算密集型任务，NDK 可以提供更高的性能，保证流畅的播放体验。
▮▮▮▮ⓑ 库支持：C/C++ 社区拥有成熟的音视频处理库，例如 FFmpeg、libVLC 等，NDK 可以方便地集成这些库，快速构建功能强大的播放器。
▮▮▮▮ⓒ 跨平台能力：使用 C/C++ 编写的播放器核心代码，可以轻松实现跨平台。
⚝ 常用音视频库：
▮▮▮▮ⓐ FFmpeg：一个开源的音视频处理工具库，几乎支持所有的音视频格式，提供了音视频解码、编码、转码、封装、解封装等功能，是构建跨平台播放器的首选库。
▮▮▮▮ⓑ libVLC：VLC 播放器的核心库，基于 FFmpeg 开发，提供了更高级的 API 和更完善的功能，例如网络流媒体播放、字幕支持等。
▮▮▮▮ⓒ ExoPlayer：Google 官方推荐的 Android 平台音视频播放库，基于 Java 开发，但也可以通过 NDK 扩展其功能，例如集成自定义解码器。
9.2.2 基于 FFmpeg 的简易播放器实现
① FFmpeg 库的集成：
⚝ 编译 FFmpeg：需要交叉编译 FFmpeg 库，生成 Android 平台可用的动态库或静态库。可以使用 ffmpeg-android-maker 等工具简化编译过程。
⚝ CMake 集成：将编译好的 FFmpeg 库添加到项目中，并在 CMakeLists.txt 文件中指定库的路径和链接选项。
② JNI 接口设计：
⚝ Java 层接口：定义 Java 层接口，用于控制播放器的行为，例如：
1
public class VideoPlayer {
2
static {
3
System.loadLibrary("video-player");
4
}
5
6
public native void nativeInit();
7
public native void nativeSetDataSource(String path);
8
public native void nativePlay();
9
public native void nativePause();
10
public native void nativeStop();
11
public native void nativeRelease();
12
public native void nativeSetSurface(Surface surface); // 用于视频渲染
13
}
⚝ Native 层接口：在 C++ 代码中实现 JNI 接口函数，例如：
1
#include <jni.h>
2
#include <string>
3
#include <android/native_window.h>
4
#include <android/native_window_jni.h>
5
// 引入 FFmpeg 头文件 (需要根据实际 FFmpeg 编译结果调整路径)
6
extern "C" {
7
#include <libavformat/avformat.h>
8
#include <libavcodec/avcodec.h>
9
#include <libavutil/imgutils.h>
10
#include <libswscale/swscale.h>
11
}
12
13
// ... (播放器核心逻辑) ...
14
15
extern "C" JNIEXPORT void JNICALL
16
Java_com_example_videoplayer_VideoPlayer_nativeInit(JNIEnv* env, jobject /* this */) {
17
// 初始化 FFmpeg
18
av_register_all();
19
avformat_network_init();
20
}
21
22
extern "C" JNIEXPORT void JNICALL
23
Java_com_example_videoplayer_VideoPlayer_nativeSetDataSource(JNIEnv* env, jobject /* this */, jstring path) {
24
// 设置视频文件路径
25
const char *file_path = env->GetStringUTFChars(path, 0);
26
// ... (打开视频文件) ...
27
env->ReleaseStringUTFChars(path, file_path);
28
}
29
30
// ... (其他 JNI 接口实现) ...
31
32
extern "C" JNIEXPORT void JNICALL
33
Java_com_example_videoplayer_VideoPlayer_nativeSetSurface(JNIEnv* env, jobject /* this */, jobject surface) {
34
// 设置 Surface 用于视频渲染
35
ANativeWindow* nativeWindow = ANativeWindow_fromSurface(env, surface);
36
// ... (设置渲染目标) ...
37
}
③ 播放器核心逻辑：
⚝ 解封装：使用 FFmpeg 的 avformat_open_input 函数打开音视频文件，avformat_find_stream_info 函数获取流信息。
⚝ 解码：找到视频流和音频流，使用 avcodec_find_decoder 函数找到对应的解码器，avcodec_open2 函数打开解码器。
⚝ 解码循环：循环读取音视频帧，使用 av_read_frame 函数读取一帧数据，avcodec_decode_video2 和 avcodec_decode_audio4 函数解码视频帧和音频帧。
⚝ 视频渲染：将解码后的视频帧转换为 RGB 或 YUV 格式，使用 ANativeWindow_lock 和 ANativeWindow_unlockAndPost 函数将视频帧数据渲染到 Surface 上。可以使用 sws_scale 函数进行图像格式转换。
⚝ 音频播放：将解码后的音频帧数据通过 AudioTrack 或 OpenSL ES 等 Android 音频 API 进行播放。
⚝ 同步：实现音视频同步，保证音视频播放同步。
④ 性能优化：
⚝ 解码器选择：优先使用硬件解码器，例如 MediaCodec，可以显著提高解码性能，降低 CPU 占用。FFmpeg 可以配置支持硬件解码。
⚝ 零拷贝：尽量减少数据拷贝，例如使用 DirectBuffer 或 DMA 等技术，提高数据传输效率。
⚝ 多线程：将解码、渲染、音频播放等任务放在不同的线程中并行执行，提高播放器的响应速度和流畅性。
⚝ 指令集优化：利用 ARM NEON 指令集加速音视频解码和渲染运算。
9.2.3 案例总结与展望
通过 NDK 和 FFmpeg，我们可以构建跨平台的音视频播放器。本案例简要介绍了基于 FFmpeg 的简易播放器的实现思路，包括 FFmpeg 集成、JNI 接口设计、播放器核心逻辑和性能优化等方面。在实际开发中，需要根据具体需求完善播放器的功能，例如添加字幕支持、网络流媒体播放、手势控制等，并进行充分的测试和优化，以提供稳定、流畅、功能丰富的音视频播放体验。未来，随着 5G 技术的普及和移动设备性能的提升，对高性能、低延迟的音视频播放需求将越来越高，NDK 在音视频领域将继续发挥重要作用。
9.3 案例三：基于物理引擎的 2D 游戏
2D 游戏在移动平台拥有广泛的用户群体，而物理引擎是 2D 游戏开发中不可或缺的核心组件，它负责模拟游戏世界中物体的运动和碰撞效果，为游戏带来真实的物理交互体验。NDK 提供了在 Android 平台上使用 C/C++ 物理引擎的机会，可以构建高性能、流畅的 2D 游戏。本节将探讨如何利用 NDK 和物理引擎开发 2D 游戏。
9.3.1 需求分析与技术选型
① 需求分析：
⚝ 物理模拟：需要精确、稳定的物理模拟能力，模拟重力、碰撞、摩擦力等物理效果，使游戏世界中的物体运动符合物理规律。
⚝ 性能要求：游戏通常需要高帧率运行，物理引擎的计算不能成为性能瓶颈，尤其是在复杂的游戏场景中。
⚝ 易用性：物理引擎需要提供易于使用的 API，方便游戏开发者集成和使用。
⚝ 跨平台性：如果游戏需要跨平台发布，物理引擎最好也具备跨平台能力。
② 技术选型：
⚝ NDK 的优势：
▮▮▮▮ⓐ 性能优势：物理引擎的计算通常是 CPU 密集型的，NDK 可以提供更高的性能，保证游戏的流畅运行。
▮▮▮▮ⓑ 库支持：C/C++ 社区拥有成熟的 2D 物理引擎库，例如 Box2D、Chipmunk2D 等，NDK 可以方便地集成这些库。
▮▮▮▮ⓒ 跨平台能力：C/C++ 物理引擎通常具有良好的跨平台性。
⚝ 常用 2D 物理引擎：
▮▮▮▮ⓐ Box2D：一个流行的开源 2D 物理引擎，广泛应用于游戏开发领域，提供了刚体动力学、碰撞检测、关节等功能，性能优秀，易于使用，并且具有良好的跨平台性。
▮▮▮▮ⓑ Chipmunk2D：另一个流行的开源 2D 物理引擎，与 Box2D 类似，也提供了丰富的物理模拟功能，性能和易用性都很好。
▮▮▮▮ⓒ Unity 2D Physics：Unity 游戏引擎内置的 2D 物理引擎，如果使用 Unity 引擎开发 Android 游戏，可以直接使用 Unity 2D Physics。
9.3.2 基于 Box2D 的简易 2D 游戏示例
① Box2D 库的集成：
⚝ CMake 集成：下载 Box2D 源代码，将其添加到项目中，并在 CMakeLists.txt 文件中使用 add_subdirectory 将 Box2D 添加为子项目，然后使用 target_link_libraries 将 Box2D 库链接到 NDK 模块。
⚝ 预编译库：也可以编译 Box2D 库，生成 Android 平台可用的静态库或动态库，并将其添加到项目中。
② JNI 接口设计：
⚝ Java 层接口：定义 Java 层接口，用于创建和控制游戏世界、创建物理物体、处理用户输入等，例如：
1
public class GameWorld {
2
static {
3
System.loadLibrary("game-world");
4
}
5
6
public native void nativeInit();
7
public native void nativeCreateWorld();
8
public native void nativeCreateBox(float x, float y, float width, float height);
9
public native void nativeStep(float timeStep);
10
public native float[] nativeGetBoxPosition(int index); // 获取 Box 位置
11
}
⚝ Native 层接口：在 C++ 代码中实现 JNI 接口函数，例如：
1
#include <jni.h>
2
#include <Box2D/Box2D.h>
3
#include <vector>
4
5
std::vector<b2Body*> boxes; // 存储 Box2D 刚体
6
7
extern "C" JNIEXPORT void JNICALL
8
Java_com_example_gameworld_GameWorld_nativeInit(JNIEnv* env, jobject /* this */) {
9
// 初始化游戏世界
10
}
11
12
extern "C" JNIEXPORT void JNICALL
13
Java_com_example_gameworld_GameWorld_nativeCreateWorld(JNIEnv* env, jobject /* this */) {
14
// 创建 Box2D 世界
15
b2Vec2 gravity(0.0f, 9.8f); // 重力
16
b2World* world = new b2World(gravity);
17
// ... (存储 world 指针，例如使用全局变量或单例模式) ...
18
}
19
20
extern "C" JNIEXPORT void JNICALL
21
Java_com_example_gameworld_GameWorld_nativeCreateBox(JNIEnv* env, jobject /* this */, jfloat x, jfloat y, jfloat width, jfloat height) {
22
// 创建 Box2D 刚体
23
b2BodyDef bodyDef;
24
bodyDef.type = b2_dynamicBody; // 动态刚体
25
bodyDef.position.Set(x, y);
26
b2Body* body = world->CreateBody(&bodyDef);
27
28
b2PolygonShape dynamicBox;
29
dynamicBox.SetAsBox(width/2.0f, height/2.0f);
30
31
b2FixtureDef fixtureDef;
32
fixtureDef.shape = &dynamicBox;
33
fixtureDef.density = 1.0f;
34
fixtureDef.friction = 0.3f;
35
body->CreateFixture(&fixtureDef);
36
37
boxes.push_back(body); // 存储刚体
38
}
39
40
extern "C" JNIEXPORT void JNICALL
41
Java_com_example_gameworld_GameWorld_nativeStep(JNIEnv* env, jobject /* this */, jfloat timeStep) {
42
// 物理世界步进
43
world->Step(timeStep, 6, 2); // 速度迭代次数和位置迭代次数
44
}
45
46
extern "C" JNIEXPORT jfloatArray JNICALL
47
Java_com_example_gameworld_GameWorld_nativeGetBoxPosition(JNIEnv* env, jobject /* this */, jint index) {
48
// 获取 Box 位置
49
if (index >= 0 && index < boxes.size()) {
50
b2Vec2 position = boxes[index]->GetPosition();
51
jfloatArray positionArray = env->NewFloatArray(2);
52
if (positionArray != nullptr) {
53
jfloat temp[2];
54
temp[0] = position.x;
55
temp[1] = position.y;
56
env->SetFloatArrayRegion(positionArray, 0, 2, temp);
57
}
58
return positionArray;
59
}
60
return nullptr;
61
}
③ 游戏循环与渲染：
⚝ 游戏循环：在 Java 层创建一个游戏循环线程，定时调用 nativeStep 函数更新物理世界，并调用 nativeGetBoxPosition 等函数获取物体位置，用于渲染。
⚝ 渲染：可以使用 Canvas 2D API 或 OpenGL ES 进行 2D 游戏渲染。将从 NDK 获取的物体位置信息转换为屏幕坐标，绘制游戏元素。
④ 性能优化：
⚝ 物理世界优化：合理设置物理世界的参数，例如时间步长、迭代次数等，避免过度精确的物理模拟，降低计算量。
⚝ 碰撞检测优化：Box2D 等物理引擎内部已经进行了碰撞检测优化，开发者可以关注物体形状的简化、碰撞过滤等技巧，进一步提高性能。
⚝ 对象池：对于游戏中频繁创建和销毁的物体，可以使用对象池技术，减少内存分配和释放的开销。
9.3.3 案例总结与展望
通过 NDK 和 Box2D 等物理引擎，我们可以构建高性能的 2D 游戏。本案例演示了如何使用 NDK 集成 Box2D 库，并实现简单的物理世界模拟。在实际游戏开发中，需要根据游戏类型和需求，选择合适的物理引擎，并进行游戏逻辑开发、场景设计、美术资源制作等工作。NDK 为 2D 游戏开发提供了强大的性能支持，可以开发出更流畅、更精美的 2D 游戏作品。未来，随着移动设备性能的提升和游戏引擎技术的进步，NDK 在游戏开发领域将继续发挥重要作用。
9.4 案例四：机器学习模型 NDK 部署与加速
机器学习（Machine Learning, ML）在移动应用中的应用越来越广泛，例如图像识别、自然语言处理、推荐系统等。为了在移动设备上高效运行机器学习模型，并充分利用设备的硬件加速能力，使用 NDK 部署和加速机器学习模型成为一种重要的技术手段。本节将探讨如何利用 NDK 部署和加速机器学习模型。
9.4.1 需求分析与技术选型
① 需求分析：
⚝ 推理性能：机器学习模型的推理（Inference）过程通常是计算密集型的，需要在移动设备上实现快速、低延迟的推理，保证用户体验。
⚝ 模型大小：移动设备的存储空间和内存资源有限，需要尽量减小模型的大小，并优化模型的内存占用。
⚝ 硬件加速：充分利用移动设备的硬件加速能力，例如 GPU、DSP、NPU 等，提高推理性能。
⚝ 跨平台性：如果需要跨平台部署机器学习模型，需要选择支持跨平台的模型框架和部署方案。
② 技术选型：
⚝ NDK 的优势：
▮▮▮▮ⓐ 性能优势：NDK 可以直接使用 C/C++ 代码进行机器学习模型的推理计算，充分利用底层硬件资源，提供更高的性能。
▮▮▮▮ⓑ 库支持：C/C++ 社区拥有成熟的机器学习推理框架，例如 TensorFlow Lite C++ API、ONNX Runtime C++ API 等，NDK 可以方便地集成这些库。
▮▮▮▮ⓒ 硬件加速：NDK 可以更方便地利用底层硬件加速 API，例如 OpenGL ES、Vulkan、NNAPI 等，实现硬件加速推理。
⚝ 常用 ML 模型部署框架：
▮▮▮▮ⓐ TensorFlow Lite：Google 官方推出的轻量级机器学习模型部署框架，专注于移动和嵌入式设备，提供了 TensorFlow Lite C++ API 和 Java API，支持模型转换、量化、硬件加速等功能。
▮▮▮▮ⓑ ONNX Runtime：微软开源的跨平台机器学习推理引擎，支持多种模型格式（包括 ONNX、TensorFlow、PyTorch 等），提供了 C++ API 和多种语言的 API，支持多种硬件加速后端。
▮▮▮▮ⓒ MediaPipe：Google 开源的跨平台多媒体处理框架，包含了一系列预训练的机器学习模型和处理模块，例如人脸检测、手势识别、姿态估计等，可以使用 NDK 集成 MediaPipe，并利用其提供的模型和功能。
9.4.2 基于 TensorFlow Lite 的图像分类模型部署
① TensorFlow Lite 库的集成：
⚝ CMake 集成：下载 TensorFlow Lite C++ 库，将其添加到项目中，并在 CMakeLists.txt 文件中指定库的路径和链接选项。可以使用 TensorFlow Lite 官方提供的 CMake 构建脚本。
⚝ 预编译库：也可以下载 TensorFlow Lite 的 Android 预编译库，将其添加到项目中。
② JNI 接口设计：
⚝ Java 层接口：定义 Java 层接口，用于加载模型、进行推理、获取结果等，例如：
1
public class ImageClassifier {
2
static {
3
System.loadLibrary("image-classifier");
4
}
5
6
public native void nativeLoadModel(String modelPath);
7
public native String nativeClassifyImage(Bitmap bitmap);
8
public native void nativeReleaseModel();
9
}
⚝ Native 层接口：在 C++ 代码中实现 JNI 接口函数，例如：
1
#include <jni.h>
2
#include <string>
3
#include <android/bitmap.h>
4
#include <tensorflow/lite/interpreter.h>
5
#include <tensorflow/lite/kernels/register.h>
6
#include <tensorflow/lite/model.h>
7
8
std::unique_ptr<tflite::Interpreter> interpreter; // TensorFlow Lite Interpreter
9
10
extern "C" JNIEXPORT void JNICALL
11
Java_com_example_imageclassifier_ImageClassifier_nativeLoadModel(JNIEnv* env, jobject /* this */, jstring modelPath) {
12
// 加载 TensorFlow Lite 模型
13
const char *path = env->GetStringUTFChars(modelPath, 0);
14
std::unique_ptr<tflite::FlatBufferModel> model = tflite::FlatBufferModel::BuildFromFile(path);
15
tflite::ops::builtin::BuiltinOpResolver resolver;
16
tflite::InterpreterBuilder builder(*model, resolver);
17
builder(&interpreter);
18
interpreter->AllocateTensors();
19
env->ReleaseStringUTFChars(modelPath, path);
20
}
21
22
extern "C" JNIEXPORT jstring JNICALL
23
Java_com_example_imageclassifier_ImageClassifier_nativeClassifyImage(JNIEnv* env, jobject /* this */, jobject bitmap) {
24
// 图像分类
25
AndroidBitmapInfo bitmapInfo;
26
void* pixels;
27
AndroidBitmap_getInfo(env, bitmap, &bitmapInfo);
28
AndroidBitmap_lockPixels(env, bitmap, &pixels);
29
30
// ... (图像预处理，例如缩放、归一化) ...
31
// 将 Bitmap 像素数据复制到 TensorFlow Lite 模型输入 Tensor
32
float* input_tensor = interpreter->typed_input_tensor<float>(0);
33
// ... (数据复制逻辑) ...
34
35
interpreter->Invoke(); // 执行推理
36
37
// 获取输出 Tensor 数据
38
float* output_tensor = interpreter->typed_output_tensor<float>(0);
39
// ... (后处理输出结果，例如找到概率最高的类别) ...
40
41
AndroidBitmap_unlockPixels(env, bitmap);
42
// ... (返回分类结果字符串) ...
43
return env->NewStringUTF("Classification Result"); // 示例
44
}
45
46
extern "C" JNIEXPORT void JNICALL
47
Java_com_example_imageclassifier_ImageClassifier_nativeReleaseModel(JNIEnv* env, jobject /* this */) {
48
// 释放模型资源
49
interpreter.reset();
50
}
③ 模型推理流程：
⚝ 模型加载：在 nativeLoadModel 函数中，使用 tflite::FlatBufferModel::BuildFromFile 加载 TensorFlow Lite 模型文件，使用 tflite::InterpreterBuilder 构建 tflite::Interpreter 对象，并调用 interpreter->AllocateTensors() 分配 Tensor 内存。
⚝ 图像预处理：将 Java Bitmap 图像数据转换为模型输入所需的格式，例如缩放、归一化、数据类型转换等。
⚝ 数据输入：将预处理后的图像数据复制到 TensorFlow Lite 模型的输入 Tensor 中。
⚝ 模型推理：调用 interpreter->Invoke() 执行模型推理计算。
⚝ 结果后处理：从 TensorFlow Lite 模型的输出 Tensor 中获取推理结果，并进行后处理，例如找到概率最高的类别，转换为可读的文本结果。
⚝ 模型释放：在 nativeReleaseModel 函数中，释放 tflite::Interpreter 对象，释放模型资源。
④ 性能优化：
⚝ 模型量化：使用 TensorFlow Lite 的模型量化技术，将模型权重从 float32 转换为 int8 或 float16，减小模型大小，提高推理速度，降低内存占用。
⚝ 硬件加速：利用 TensorFlow Lite 的硬件加速功能，例如 NNAPI Delegate、GPU Delegate 等，将模型推理计算委托给硬件加速器执行，提高推理性能。
⚝ 模型剪枝：对模型进行剪枝，去除模型中不重要的连接和参数，减小模型大小，提高推理速度。
⚝ 算子融合：TensorFlow Lite 编译器会自动进行算子融合优化，将多个算子合并成一个算子，减少算子执行的开销。
⚝ 多线程：配置 TensorFlow Lite Interpreter 使用多线程进行推理计算，提高并行度，加速推理过程。
9.4.3 案例总结与展望
通过 NDK 和 TensorFlow Lite 等机器学习框架，我们可以高效地在 Android 设备上部署和加速机器学习模型。本案例演示了如何使用 NDK 集成 TensorFlow Lite C++ 库，并实现简单的图像分类功能。在实际应用中，可以根据具体需求选择合适的机器学习框架和模型，并进行模型优化和硬件加速，以满足应用的性能和精度要求。随着移动设备 AI 芯片的普及和机器学习技术的不断发展，NDK 在移动端机器学习部署领域将发挥越来越重要的作用，为移动应用带来更智能、更强大的功能。
ENDOF_CHAPTER_
10. chapter 10： NDK API 参考与最佳实践
10.1 常用 JNI 函数 API 详解与示例
JNI（Java Native Interface，Java 本地接口）是 Android NDK 开发的核心，它允许 Java 代码和 Native 代码（通常是 C/C++）进行交互。理解并熟练运用 JNI 函数 API 是 NDK 开发的基础。本节将详细介绍常用的 JNI 函数 API，并提供示例代码帮助读者快速掌握。
10.1.1 类操作 (Class Operations)
JNI 提供了丰富的函数来操作 Java 类，包括查找类、获取类信息等。
① jclass FindClass(JNIEnv *env, const char *name)
⚝ 功能：根据类名查找 Java 类。
⚝ 参数：
▮▮▮▮⚝ env：JNI 接口指针。
▮▮▮▮⚝ name：Java 类的全限定名，例如 "java/lang/String"。
⚝ 返回值：
▮▮▮▮⚝ 成功：返回 jclass 对象，代表找到的 Java 类。
▮▮▮▮⚝ 失败：返回 NULL，并抛出 ClassNotFoundException 异常。
⚝ 示例：
1
JNIEXPORT jclass JNICALL
2
Java_com_example_ndkbook_MainActivity_findJavaClass(JNIEnv *env, jobject /* this */) {
3
jclass stringClass = env->FindClass("java/lang/String");
4
if (stringClass == nullptr) {
5
// 异常处理
6
return nullptr;
7
}
8
return stringClass;
9
}
② jclass GetObjectClass(JNIEnv *env, jobject obj)
⚝ 功能：获取 Java 对象的类。
⚝ 参数：
▮▮▮▮⚝ env：JNI 接口指针。
▮▮▮▮⚝ obj：Java 对象。
⚝ 返回值：
▮▮▮▮⚝ 返回 jclass 对象，代表 obj 的 Java 类。
⚝ 示例：
1
JNIEXPORT jclass JNICALL
2
Java_com_example_ndkbook_MainActivity_getObjectClass(JNIEnv *env, jobject /* this */, jobject javaObject) {
3
jclass objClass = env->GetObjectClass(javaObject);
4
return objClass;
5
}
③ jmethodID GetMethodID(JNIEnv *env, jclass clazz, const char *name, const char *sig)
⚝ 功能：获取 Java 类中实例方法的 ID。
⚝ 参数：
▮▮▮▮⚝ env：JNI 接口指针。
▮▮▮▮⚝ clazz：Java 类对象 (jclass)。
▮▮▮▮⚝ name：方法名，例如 "toString"。
▮▮▮▮⚝ sig：方法签名，描述方法的参数和返回值类型，例如 "()Ljava/lang/String;"。
⚝ 返回值：
▮▮▮▮⚝ 成功：返回 jmethodID，代表方法的 ID。
▮▮▮▮⚝ 失败：返回 NULL，并可能抛出 NoSuchMethodError 异常。
⚝ 示例：
1
JNIEXPORT jmethodID JNICALL
2
Java_com_example_ndkbook_MainActivity_getMethodID(JNIEnv *env, jobject /* this */, jclass javaClass) {
3
jmethodID toStringMethod = env->GetMethodID(javaClass, "toString", "()Ljava/lang/String;");
4
if (toStringMethod == nullptr) {
5
// 异常处理
6
return nullptr;
7
}
8
return toStringMethod;
9
}
④ jmethodID GetStaticMethodID(JNIEnv *env, jclass clazz, const char *name, const char *sig)
⚝ 功能：获取 Java 类中静态方法的 ID。
⚝ 参数：
▮▮▮▮⚝ env：JNI 接口指针。
▮▮▮▮⚝ clazz：Java 类对象 (jclass)。
▮▮▮▮⚝ name：静态方法名。
▮▮▮▮⚝ sig：静态方法签名。
⚝ 返回值：
▮▮▮▮⚝ 成功：返回 jmethodID，代表静态方法的 ID。
▮▮▮▮⚝ 失败：返回 NULL，并可能抛出 NoSuchMethodError 异常。
⑤ jfieldID GetFieldID(JNIEnv *env, jclass clazz, const char *name, const char *sig)
⚝ 功能：获取 Java 类中实例字段的 ID。
⚝ 参数：
▮▮▮▮⚝ env：JNI 接口指针。
▮▮▮▮⚝ clazz：Java 类对象 (jclass)。
▮▮▮▮⚝ name：字段名。
▮▮▮▮⚝ sig：字段签名，描述字段类型，例如 "I" (int), "Ljava/lang/String;" (String)。
⚝ 返回值：
▮▮▮▮⚝ 成功：返回 jfieldID，代表实例字段的 ID。
▮▮▮▮⚝ 失败：返回 NULL，并可能抛出 NoSuchFieldError 异常。
⑥ jfieldID GetStaticFieldID(JNIEnv *env, jclass clazz, const char *name, const char *sig)
⚝ 功能：获取 Java 类中静态字段的 ID。
⚝ 参数：
▮▮▮▮⚝ env：JNI 接口指针。
▮▮▮▮⚝ clazz：Java 类对象 (jclass)。
▮▮▮▮⚝ name：静态字段名。
▮▮▮▮⚝ sig：静态字段签名。
⚝ 返回值：
▮▮▮▮⚝ 成功：返回 jfieldID，代表静态字段的 ID。
▮▮▮▮⚝ 失败：返回 NULL，并可能抛出 NoSuchFieldError 异常。
10.1.2 对象操作 (Object Operations)
JNI 允许在 Native 层创建、访问和操作 Java 对象。
① jobject NewObject(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
⚝ 功能：创建 Java 对象。调用类的构造方法。
⚝ 参数：
▮▮▮▮⚝ env：JNI 接口指针。
▮▮▮▮⚝ clazz：要创建对象的类 (jclass)。
▮▮▮▮⚝ methodID：构造方法的 ID (jmethodID)，通常是 <init> 方法。
▮▮▮▮⚝ ...：构造方法的参数。
⚝ 返回值：
▮▮▮▮⚝ 成功：返回新创建的 Java 对象 (jobject)。
▮▮▮▮⚝ 失败：返回 NULL，并可能抛出异常。
⚝ 示例：
1
JNIEXPORT jobject JNICALL
2
Java_com_example_ndkbook_MainActivity_createStringObject(JNIEnv *env, jobject /* this */) {
3
jclass stringClass = env->FindClass("java/lang/String");
4
if (stringClass == nullptr) {
5
return nullptr;
6
}
7
jmethodID constructorID = env->GetMethodID(stringClass, "<init>", "()V"); // 默认构造方法
8
if (constructorID == nullptr) {
9
return nullptr;
10
}
11
jobject stringObj = env->NewObject(stringClass, constructorID);
12
return stringObj;
13
}
② jobject CallObjectMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
⚝ 功能：调用 Java 对象的实例方法，方法返回值为对象类型。
⚝ 参数：
▮▮▮▮⚝ env：JNI 接口指针。
▮▮▮▮⚝ obj：Java 对象。
▮▮▮▮⚝ methodID：方法 ID (jmethodID)。
▮▮▮▮⚝ ...：方法的参数。
⚝ 返回值：
▮▮▮▮⚝ 成功：返回方法调用的结果对象 (jobject)。
▮▮▮▮⚝ 失败：返回 NULL，并可能抛出异常。
③ jboolean CallBooleanMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...), jint CallIntMethod(...), jlong CallLongMethod(...), jfloat CallFloatMethod(...), jdouble CallDoubleMethod(...), void CallVoidMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
⚝ 功能：调用 Java 对象的实例方法，根据返回值类型选择不同的函数。
⚝ 参数：与 CallObjectMethod 类似。
⚝ 返回值：
▮▮▮▮⚝ 返回对应 Java 方法的返回值。CallVoidMethod 没有返回值。
④ jobject GetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID)
⚝ 功能：获取 Java 对象的实例字段的值，字段类型为对象类型。
⚝ 参数：
▮▮▮▮⚝ env：JNI 接口指针。
▮▮▮▮⚝ obj：Java 对象。
▮▮▮▮⚝ fieldID：字段 ID (jfieldID)。
⚝ 返回值：
▮▮▮▮⚝ 返回字段的值 (jobject)。
⑤ jboolean GetBooleanField(JNIEnv *env, jobject obj, jfieldID fieldID), jint GetIntField(...), jlong GetLongField(...), jfloat GetFloatField(...), jdouble GetDoubleField(...)
⚝ 功能：获取 Java 对象的实例字段的值，根据字段类型选择不同的函数。
⚝ 参数：与 GetObjectField 类似。
⚝ 返回值：
▮▮▮▮⚝ 返回对应 Java 字段的值。
⑥ void SetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID, jobject value)
⚝ 功能：设置 Java 对象的实例字段的值，字段类型为对象类型。
⚝ 参数：
▮▮▮▮⚝ env：JNI 接口指针。
▮▮▮▮⚝ obj：Java 对象。
▮▮▮▮⚝ fieldID：字段 ID (jfieldID)。
▮▮▮▮⚝ value：要设置的字段值 (jobject)。
⑦ void SetBooleanField(JNIEnv *env, jobject obj, jfieldID fieldID, jboolean value), void SetIntField(...), void SetLongField(...), void SetFloatField(...), void SetDoubleField(...)
⚝ 功能：设置 Java 对象的实例字段的值，根据字段类型选择不同的函数。
⚝ 参数：与 SetObjectField 类似。
10.1.3 静态方法和字段操作 (Static Method and Field Operations)
JNI 也支持调用 Java 类的静态方法和访问静态字段。
① jobject CallStaticObjectMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
⚝ 功能：调用 Java 类的静态方法，方法返回值为对象类型。
⚝ 参数：
▮▮▮▮⚝ env：JNI 接口指针。
▮▮▮▮⚝ clazz：Java 类对象 (jclass)。
▮▮▮▮⚝ methodID：静态方法 ID (jmethodID)。
▮▮▮▮⚝ ...：方法的参数。
⚝ 返回值：
▮▮▮▮⚝ 成功：返回方法调用的结果对象 (jobject)。
▮▮▮▮⚝ 失败：返回 NULL，并可能抛出异常。
② jboolean CallStaticBooleanMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...), jint CallStaticIntMethod(...), jlong CallStaticLongMethod(...), jfloat CallStaticFloatMethod(...), jdouble CallStaticDoubleMethod(...), void CallStaticVoidMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
⚝ 功能：调用 Java 类的静态方法，根据返回值类型选择不同的函数。
⚝ 参数：与 CallStaticObjectMethod 类似。
⚝ 返回值：
▮▮▮▮⚝ 返回对应 Java 静态方法的返回值。CallStaticVoidMethod 没有返回值。
③ jobject GetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID)
⚝ 功能：获取 Java 类的静态字段的值，字段类型为对象类型。
⚝ 参数：
▮▮▮▮⚝ env：JNI 接口指针。
▮▮▮▮⚝ clazz：Java 类对象 (jclass)。
▮▮▮▮⚝ fieldID：静态字段 ID (jfieldID)。
⚝ 返回值：
▮▮▮▮⚝ 返回字段的值 (jobject)。
④ jboolean GetStaticBooleanField(JNIEnv *env, jclass clazz, jfieldID fieldID), jint GetStaticIntField(...), jlong GetStaticLongField(...), jfloat GetStaticFloatField(...), jdouble GetStaticDoubleField(...)
⚝ 功能：获取 Java 类的静态字段的值，根据字段类型选择不同的函数。
⚝ 参数：与 GetStaticObjectField 类似。
⚝ 返回值：
▮▮▮▮⚝ 返回对应 Java 静态字段的值。
⑤ void SetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value)
⚝ 功能：设置 Java 类的静态字段的值，字段类型为对象类型。
⚝ 参数：
▮▮▮▮⚝ env：JNI 接口指针。
▮▮▮▮⚝ clazz：Java 类对象 (jclass)。
▮▮▮▮⚝ fieldID：静态字段 ID (jfieldID)。
▮▮▮▮⚝ value：要设置的字段值 (jobject)。
⑥ void SetStaticBooleanField(JNIEnv *env, jclass clazz, jfieldID fieldID, jboolean value), void SetStaticIntField(...), void SetStaticLongField(...), void SetStaticFloatField(...), void SetStaticDoubleField(...)
⚝ 功能：设置 Java 类的静态字段的值，根据字段类型选择不同的函数。
⚝ 参数：与 SetStaticObjectField 类似。
10.1.4 字符串操作 (String Operations)
JNI 提供了专门的函数来处理 Java String 对象和 Native 字符串之间的转换。
① jstring NewStringUTF(JNIEnv *env, const char *bytes)
⚝ 功能：根据 UTF-8 编码的 Native 字符串创建 Java String 对象。
⚝ 参数：
▮▮▮▮⚝ env：JNI 接口指针。
▮▮▮▮⚝ bytes：UTF-8 编码的 Native 字符串。
⚝ 返回值：
▮▮▮▮⚝ 成功：返回新创建的 Java String 对象 (jstring)。
▮▮▮▮⚝ 失败：返回 NULL，并可能抛出 OutOfMemoryError 异常。
⚝ 示例：
1
JNIEXPORT jstring JNICALL
2
Java_com_example_ndkbook_MainActivity_getJavaStringFromNative(JNIEnv *env, jobject /* this */) {
3
const char *nativeString = "Hello from Native!";
4
jstring javaString = env->NewStringUTF(nativeString);
5
return javaString;
6
}
② const char *GetStringUTFChars(JNIEnv *env, jstring string, jboolean *isCopy)
⚝ 功能：将 Java String 对象转换为 UTF-8 编码的 Native 字符串。
⚝ 参数：
▮▮▮▮⚝ env：JNI 接口指针。
▮▮▮▮⚝ string：Java String 对象 (jstring)。
▮▮▮▮⚝ isCopy：指向 jboolean 的指针，用于指示返回的字符串是原始字符串的副本还是直接指针。可以设置为 NULL。
⚝ 返回值：
▮▮▮▮⚝ 成功：返回 UTF-8 编码的 Native 字符串指针 (const char *)。
▮▮▮▮⚝ 失败：返回 NULL，并可能抛出 OutOfMemoryError 异常。
⚝ 注意：使用完返回的字符串后，必须调用 ReleaseStringUTFChars 释放资源。
⚝ 示例：
1
JNIEXPORT jstring JNICALL
2
Java_com_example_ndkbook_MainActivity_processJavaString(JNIEnv *env, jobject /* this */, jstring javaString) {
3
const char *nativeString = env->GetStringUTFChars(javaString, nullptr);
4
if (nativeString == nullptr) {
5
return nullptr;
6
}
7
// 在这里处理 nativeString
8
// ...
9
env->ReleaseStringUTFChars(javaString, nativeString); // 释放资源
10
return javaString; // 示例中简单返回原字符串
11
}
③ void ReleaseStringUTFChars(JNIEnv *env, jstring string, const char *utf)
⚝ 功能：释放 GetStringUTFChars 获取的 Native 字符串资源。
⚝ 参数：
▮▮▮▮⚝ env：JNI 接口指针。
▮▮▮▮⚝ string：原始的 Java String 对象 (jstring)。
▮▮▮▮⚝ utf：GetStringUTFChars 返回的 Native 字符串指针。
⚝ 重要：必须成对使用 GetStringUTFChars 和 ReleaseStringUTFChars，避免内存泄漏。
10.1.5 数组操作 (Array Operations)
JNI 提供了函数来处理 Java 数组，包括基本类型数组和对象数组。
① jintArray NewIntArray(JNIEnv *env, jsize len), jlongArray NewLongArray(...), jfloatArray NewFloatArray(...), jdoubleArray NewDoubleArray(...), jbooleanArray NewBooleanArray(...), jcharArray NewCharArray(...), jshortArray NewShortArray(...), jbyteArray NewByteArray(...)
⚝ 功能：创建新的 Java 基本类型数组。
⚝ 参数：
▮▮▮▮⚝ env：JNI 接口指针。
▮▮▮▮⚝ len：数组长度。
⚝ 返回值：
▮▮▮▮⚝ 成功：返回新创建的 Java 数组对象。
▮▮▮▮⚝ 失败：返回 NULL，并可能抛出 OutOfMemoryError 异常。
② jobjectArray NewObjectArray(JNIEnv *env, jsize len, jclass clazz, jobject init)
⚝ 功能：创建新的 Java 对象数组。
⚝ 参数：
▮▮▮▮⚝ env：JNI 接口指针。
▮▮▮▮⚝ len：数组长度。
▮▮▮▮⚝ clazz：数组元素的类 (jclass)。
▮▮▮▮⚝ init：数组元素的初始值，可以为 NULL。
⚝ 返回值：
▮▮▮▮⚝ 成功：返回新创建的 Java 对象数组对象。
▮▮▮▮⚝ 失败：返回 NULL，并可能抛出 OutOfMemoryError 异常。
③ jint *GetIntArrayElements(JNIEnv *env, jintArray array, jboolean *isCopy), jlong *GetLongArrayElements(...), jfloat *GetFloatArrayElements(...), jdouble *GetDoubleArrayElements(...), jboolean *GetBooleanArrayElements(...), jchar *GetCharArrayElements(...), jshort *GetShortArrayElements(...), jbyte *GetByteArrayElements(...)
⚝ 功能：获取 Java 基本类型数组的指针，允许 Native 代码直接访问数组元素。
⚝ 参数：
▮▮▮▮⚝ env：JNI 接口指针。
▮▮▮▮⚝ array：Java 数组对象。
▮▮▮▮⚝ isCopy：指向 jboolean 的指针，指示返回的指针是原始数组的副本还是直接指针。可以设置为 NULL。
⚝ 返回值：
▮▮▮▮⚝ 成功：返回指向数组元素的 Native 指针。
▮▮▮▮⚝ 失败：返回 NULL，并可能抛出 OutOfMemoryError 异常。
⚝ 注意：使用完数组后，必须调用对应的 Release<Type>ArrayElements 函数释放资源。
④ void ReleaseIntArrayElements(JNIEnv *env, jintArray array, jint *elems, jint mode), void ReleaseLongArrayElements(...), void ReleaseFloatArrayElements(...), void ReleaseDoubleArrayElements(...), void ReleaseBooleanArrayElements(...), void ReleaseCharArrayElements(...), void ReleaseShortArrayElements(...), void ReleaseByteArrayElements(JNIEnv *env, jbyteArray array, jbyte *elems, jint mode)
⚝ 功能：释放 Get<Type>ArrayElements 获取的数组资源。
⚝ 参数：
▮▮▮▮⚝ env：JNI 接口指针。
▮▮▮▮⚝ array：原始的 Java 数组对象。
▮▮▮▮⚝ elems：Get<Type>ArrayElements 返回的 Native 数组指针。
▮▮▮▮⚝ mode：释放模式，通常使用 0 (刷新并释放副本), JNI_COMMIT (刷新但不释放副本), JNI_ABORT (不刷新直接释放副本)。
⚝ 重要：必须成对使用 Get<Type>ArrayElements 和 Release<Type>ArrayElements，避免资源泄漏。
⑤ jobject GetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index)
⚝ 功能：获取 Java 对象数组中指定索引位置的元素。
⚝ 参数：
▮▮▮▮⚝ env：JNI 接口指针。
▮▮▮▮⚝ array：Java 对象数组对象。
▮▮▮▮⚝ index：索引位置。
⚝ 返回值：
▮▮▮▮⚝ 返回指定索引位置的 Java 对象 (jobject)。
⑥ void SetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index, jobject value)
⚝ 功能：设置 Java 对象数组中指定索引位置的元素。
⚝ 参数：
▮▮▮▮⚝ env：JNI 接口指针。
▮▮▮▮⚝ array：Java 对象数组对象。
▮▮▮▮⚝ index：索引位置。
▮▮▮▮⚝ value：要设置的 Java 对象 (jobject)。
10.1.6 异常处理 (Exception Handling)
JNI 提供了函数来检查和处理 Java 异常。
① jthrowable ExceptionOccurred(JNIEnv *env)
⚝ 功能：检查是否发生了 Java 异常。
⚝ 参数：
▮▮▮▮⚝ env：JNI 接口指针。
⚝ 返回值：
▮▮▮▮⚝ 如果发生了异常，返回异常对象 (jthrowable)。
▮▮▮▮⚝ 如果没有异常发生，返回 NULL。
② void ExceptionDescribe(JNIEnv *env)
⚝ 功能：打印异常的堆栈信息到标准错误输出。
⚝ 参数：
▮▮▮▮⚝ env：JNI 接口指针。
③ void ExceptionClear(JNIEnv *env)
⚝ 功能：清除当前线程的异常。清除后，ExceptionOccurred 将返回 NULL。
⚝ 参数：
▮▮▮▮⚝ env：JNI 接口指针。
⚝ 重要：在 Native 代码中捕获并处理 Java 异常后，应该调用 ExceptionClear 清除异常状态，避免异常传递回 Java 层导致程序崩溃。
④ void ThrowNew(JNIEnv *env, jclass clazz, const char *message)
⚝ 功能：在 Native 代码中抛出一个新的 Java 异常。
⚝ 参数：
▮▮▮▮⚝ env：JNI 接口指针。
▮▮▮▮⚝ clazz：异常类 (jclass)，例如 java/lang/IllegalArgumentException。
▮▮▮▮⚝ message：异常消息。
⚝ 示例：
1
JNIEXPORT void JNICALL
2
Java_com_example_ndkbook_MainActivity_throwExceptionFromNative(JNIEnv *env, jobject /* this */) {
3
jclass exceptionClass = env->FindClass("java/lang/IllegalArgumentException");
4
if (exceptionClass == nullptr) {
5
return; // 找不到异常类，无法抛出
6
}
7
env->ThrowNew(exceptionClass, "Exception thrown from Native code!");
8
}
10.1.7 引用管理 (Reference Management)
JNI 引用分为局部引用、全局引用和弱全局引用，合理的引用管理对于避免内存泄漏至关重要。
① 局部引用 (Local References)
⚝ 大部分 JNI 函数返回的引用都是局部引用。
⚝ 局部引用只在 Native 方法的执行期间有效，方法返回后会被自动释放。
⚝ 局部引用数量有限制，过度创建局部引用可能导致 JNI local reference table overflow 错误。
② jobject NewGlobalRef(JNIEnv *env, jobject obj)
⚝ 功能：创建一个全局引用。
⚝ 参数：
▮▮▮▮⚝ env：JNI 接口指针。
▮▮▮▮⚝ obj：要创建全局引用的 Java 对象。
⚝ 返回值：
▮▮▮▮⚝ 成功：返回全局引用 (jobject)。
▮▮▮▮⚝ 失败：返回 NULL，并可能抛出 OutOfMemoryError 异常。
⚝ 全局引用：全局引用在被显式释放之前一直有效，即使 Native 方法已经返回。全局引用必须手动释放，否则会导致内存泄漏。
③ void DeleteGlobalRef(JNIEnv *env, jglobalRef ref)
⚝ 功能：释放全局引用。
⚝ 参数：
▮▮▮▮⚝ env：JNI 接口指针。
▮▮▮▮⚝ ref：要释放的全局引用 (jglobalRef)。
⚝ 重要：必须成对使用 NewGlobalRef 和 DeleteGlobalRef，避免内存泄漏。
④ jweak NewWeakGlobalRef(JNIEnv *env, jobject obj)
⚝ 功能：创建一个弱全局引用。
⚝ 参数：
▮▮▮▮⚝ env：JNI 接口指针。
▮▮▮▮⚝ obj：要创建弱全局引用的 Java 对象。
⚝ 返回值：
▮▮▮▮⚝ 成功：返回弱全局引用 (jweak)。
▮▮▮▮⚝ 失败：返回 NULL，并可能抛出 OutOfMemoryError 异常。
⚝ 弱全局引用：弱全局引用不会阻止垃圾回收器回收引用的对象。当对象被回收后，弱全局引用会自动变为 NULL。弱全局引用通常用于缓存，当对象不再需要时可以被回收，节省内存。
⑤ void DeleteWeakGlobalRef(JNIEnv *env, jweak ref)
⚝ 功能：释放弱全局引用。
⚝ 参数：
▮▮▮▮⚝ env：JNI 接口指针。
▮▮▮▮⚝ ref：要释放的弱全局引用 (jweak)。
⚝ 重要：虽然弱全局引用不会导致内存泄漏，但不再使用时也应该及时释放，以便资源管理。
⑥ void DeleteLocalRef(JNIEnv *env, jobject localRef)
⚝ 功能：手动删除局部引用。
⚝ 参数：
▮▮▮▮⚝ env：JNI 接口指针。
▮▮▮▮⚝ localRef：要删除的局部引用 (jobject)。
⚝ 使用场景：在 Native 方法中创建了大量的局部引用，可能导致局部引用表溢出时，可以手动删除不再需要的局部引用，提前释放资源。通常情况下，局部引用会自动释放，不需要手动删除。
10.1.8 其他常用 JNI 函数
① jint GetVersion(JNIEnv *env)
⚝ 功能：获取 JNI 版本号。
⚝ 参数：
▮▮▮▮⚝ env：JNI 接口指针。
⚝ 返回值：
▮▮▮▮⚝ 返回 JNI 版本号，例如 JNI_VERSION_1_6。
② jint RegisterNatives(JNIEnv *env, jclass clazz, const JNINativeMethod *methods, jint nMethods)
⚝ 功能：动态注册 Native 方法。
⚝ 参数：
▮▮▮▮⚝ env：JNI 接口指针。
▮▮▮▮⚝ clazz：要注册 Native 方法的 Java 类 (jclass)。
▮▮▮▮⚝ methods：JNINativeMethod 结构体数组，描述要注册的 Native 方法信息。
▮▮▮▮⚝ nMethods：要注册的 Native 方法数量。
⚝ 返回值：
▮▮▮▮⚝ 成功：返回 0。
▮▮▮▮⚝ 失败：返回负数错误码。
⚝ 应用场景：动态注册 Native 方法可以提高灵活性，避免 Java 方法名和 Native 函数名之间的硬编码依赖。
③ jint UnregisterNatives(JNIEnv *env, jclass clazz)
⚝ 功能：取消注册 Native 方法。
⚝ 参数：
▮▮▮▮⚝ env：JNI 接口指针。
▮▮▮▮⚝ clazz：要取消注册 Native 方法的 Java 类 (jclass)。
⚝ 返回值：
▮▮▮▮⚝ 成功：返回 0。
▮▮▮▮⚝ 失败：返回负数错误码。
⚝ 应用场景：与 RegisterNatives 配对使用，在不再需要 Native 方法时取消注册。
④ void FatalError(JNIEnv *env, const char *msg)
⚝ 功能：抛出一个致命错误并终止虚拟机。
⚝ 参数：
▮▮▮▮⚝ env：JNI 接口指针。
▮▮▮▮⚝ msg：错误消息。
⚝ 慎用：FatalError 会直接终止虚拟机，通常只在遇到无法恢复的严重错误时使用。
本节介绍了常用的 JNI 函数 API，涵盖了类操作、对象操作、静态方法和字段操作、字符串操作、数组操作、异常处理和引用管理等方面。熟练掌握这些 API 是进行 Android NDK 开发的基础。在实际开发中，应根据具体需求选择合适的 JNI 函数，并注意资源管理，避免内存泄漏和程序崩溃。
10.2 NDK 核心库 API 索引与速查
Android NDK 提供了丰富的 C/C++ 库，用于支持各种系统功能和开发需求。本节将对 NDK 核心库 API 进行索引和速查，方便开发者快速查找和使用。
10.2.1 C 标准库 (C Standard Library)
NDK 提供了对 C 标准库的良好支持，包括常用的函数和头文件。
① <stdio.h>: 标准输入输出库
⚝ 文件 I/O 操作：fopen, fclose, fread, fwrite, fprintf, printf, scanf 等。
⚝ 格式化输入输出。
② <stdlib.h>: 通用工具库
⚝ 内存管理：malloc, free, calloc, realloc, aligned_alloc, aligned_free。
⚝ 进程控制：abort, exit, getenv, system。
⚝ 随机数生成：rand, srand。
⚝ 字符串转换：atoi, atol, atof, strtol, strtod。
⚝ 搜索和排序：qsort, bsearch。
③ <string.h>: 字符串操作库
⚝ 字符串复制：strcpy, strncpy, memcpy, memmove。
⚝ 字符串连接：strcat, strncat。
⚝ 字符串比较：strcmp, strncmp, memcmp。
⚝ 字符串查找：strstr, strchr, memchr。
⚝ 字符串长度：strlen。
⚝ 字符串填充和设置：memset, bzero。
④ <math.h>: 数学库
⚝ 三角函数：sin, cos, tan, asin, acos, atan, atan2。
⚝ 指数和对数函数：exp, log, log10, pow, sqrt。
⚝ 双曲函数：sinh, cosh, tanh。
⚝ 其他数学函数：ceil, floor, fabs, fmod, round。
⑤ <time.h>: 时间库
⚝ 时间获取：time, clock, gettimeofday。
⚝ 时间转换：localtime, gmtime, mktime, strftime, strptime。
⑥ <ctype.h>: 字符处理库
⚝ 字符类型判断：isalnum, isalpha, isdigit, isspace, islower, isupper, ispunct。
⚝ 字符转换：tolower, toupper。
⑦ <errno.h>: 错误处理库
⚝ 错误码定义：errno, perror。
⑧ <assert.h>: 断言库
⚝ 断言宏：assert。
10.2.2 C++ 标准库 (C++ Standard Library)
NDK 也支持 C++ 标准库，包括 STL (Standard Template Library) 和其他常用组件。
① <iostream>: 输入输出流
⚝ 标准输入输出对象：cin, cout, cerr, clog。
⚝ 文件流：ifstream, ofstream, fstream。
⚝ 字符串流：stringstream, istringstream, ostringstream。
② <string>: 字符串类
⚝ std::string 类：字符串操作，查找，替换，比较等。
③ <vector>: 动态数组
⚝ std::vector 容器：动态数组，自动内存管理。
④ <list>: 双向链表
⚝ std::list 容器：双向链表。
⑤ <deque>: 双端队列
⚝ std::deque 容器：双端队列。
⑥ <stack>: 栈
⚝ std::stack 容器：栈数据结构。
⑦ <queue>: 队列
⚝ std::queue 容器：队列数据结构。
⚝ std::priority_queue 容器：优先级队列。
⑧ <set>: 集合
⚝ std::set 容器：有序集合。
⚝ std::multiset 容器：多重集合。
⑨ <map>: 映射
⚝ std::map 容器：键值对映射，有序。
⚝ std::multimap 容器：多重映射。
⑩ <algorithm>: 算法库
⚝ 常用算法：sort, find, binary_search, copy, move, transform, accumulate, for_each 等。
⑪ <cmath>: C++ 数学库
⚝ C++ 版本的数学函数，与 <math.h> 类似。
⑫ <ctime>: C++ 时间库
⚝ C++ 版本的时间函数，与 <time.h> 类似。
⑬ <thread>: 线程库 (C++11)
⚝ std::thread 类：线程管理。
⚝ std::mutex, std::condition_variable, std::future, std::promise：线程同步和异步。
⑭ <atomic>: 原子操作库 (C++11)
⚝ 原子类型和操作：std::atomic, std::atomic_flag。
⑮ <memory>: 内存管理库
⚝ 智能指针：std::shared_ptr, std::unique_ptr, std::weak_ptr。
⑯ <exception>: 异常处理库
⚝ 异常类：std::exception, std::runtime_error, std::logic_error。
10.2.3 Android 特有库 (Android-Specific Libraries)
NDK 提供了一些 Android 特有的库，用于访问 Android 系统功能。
① <android/log.h>: Log 系统
⚝ 日志输出函数：__android_log_print, __android_log_write, __android_log_vprint。
⚝ 日志级别宏：ANDROID_LOG_VERBOSE, ANDROID_LOG_DEBUG, ANDROID_LOG_INFO, ANDROID_LOG_WARN, ANDROID_LOG_ERROR, ANDROID_LOG_FATAL, ANDROID_LOG_SILENT。
② <android/asset_manager.h>: Asset 管理器
⚝ Asset 管理器类型：AAssetManager, AAssetDir, AAsset。
⚝ Asset 管理器函数：AAssetManager_OpenDir, AAssetManager_open, AAsset_read, AAsset_close。
⚝ 用于访问 APK 包中的 assets 目录下的资源文件。
③ <android/bitmap.h>: Bitmap 操作
⚝ Bitmap 信息结构体：AndroidBitmapInfo。
⚝ Bitmap 操作函数：AndroidBitmap_getInfo, AndroidBitmap_lockPixels, AndroidBitmap_unlockPixels。
⚝ 用于 Native 层直接操作 Bitmap 像素数据。
④ <android/configuration.h>: Configuration 配置
⚝ Configuration 信息结构体：AConfiguration。
⚝ Configuration 函数：AConfiguration_new, AConfiguration_fromEvent, AConfiguration_delete, AConfiguration_getLanguage。
⚝ 用于获取设备配置信息，如语言、屏幕方向等。
⑤ <android/input.h>: 输入事件
⚝ 输入事件类型：AInputEvent, AKeyEvent, AMotionEvent。
⚝ 输入事件函数：AInputEvent_getType, AKeyEvent_getKeyCode, AMotionEvent_getX。
⚝ 用于 Native 层处理输入事件。
⑥ <android/looper.h>: Looper
⚝ Looper 类型：ALooper, ALooper_callbackFunc, ALooper_pollSource。
⚝ Looper 函数：ALooper_prepare, ALooper_pollAll, ALooper_addFd, ALooper_removeFd。
⚝ 用于 Native 层实现消息循环机制。
⑦ <android/native_window.h>: Native Window
⚝ Native Window 类型：ANativeWindow, ANativeWindow_Buffer。
⚝ Native Window 函数：ANativeWindow_fromSurface, ANativeWindow_lock, ANativeWindow_unlockAndPost。
⚝ 用于 Native 层直接渲染到 Surface。
⑧ <android/sensor.h>: 传感器
⚝ 传感器类型：ASensorManager, ASensorList, ASensorEventQueue, ASensorEvent。
⚝ 传感器函数：ASensorManager_getDefaultSensor, ASensorManager_createEventQueue, ASensorEventQueue_enableSensor, ASensorEventQueue_getEvents。
⚝ 用于访问设备传感器数据。
⑨ <android/surface_texture.h>: SurfaceTexture
⚝ SurfaceTexture 类型：ASurfaceTexture。
⚝ SurfaceTexture 函数：ASurfaceTexture_fromSurface, ASurfaceTexture_acquireBuffer, ASurfaceTexture_releaseBuffer。
⚝ 用于 Native 层处理 SurfaceTexture。
⑩ <android/keycodes.h>: Keycodes
⚝ 键盘按键码常量定义，例如 AKEYCODE_BACK, AKEYCODE_HOME, AKEYCODE_VOLUME_UP。
⑪ <android/obb.h>: OBB (Opaque Binary Blob)
⚝ OBB 函数：obb_verify, obb_get_package_info, obb_get_file_descriptor。
⚝ 用于访问 OBB 扩展文件。
⑫ <android/binder.h>: Binder (AIDL)
⚝ Binder 相关类型和函数，用于实现跨进程通信 (IPC)。
10.2.4 多媒体库 (Multimedia Libraries)
NDK 提供了多媒体相关的库，用于音视频处理和图形渲染。
① OpenGL ES (Open Graphics Library for Embedded Systems)
⚝ 头文件：<GLES2/gl2.h>, <GLES3/gl3.h>, <EGL/egl.h>, <EGL/eglext.h>。
⚝ 用于 2D 和 3D 图形渲染。
⚝ 版本：OpenGL ES 2.0, 3.0, 3.1, 3.2。
② Vulkan
⚝ 头文件：<vulkan/vulkan.h>, <vulkan/vulkan_android.h>。
⚝ 新一代图形 API，提供更高的性能和更低的 CPU 开销。
③ OpenSL ES (Open Sound Library for Embedded Systems)
⚝ 头文件：<SLES/OpenSLES.h>, <SLES/OpenSLES_Android.h>, <SLES/OpenSLES_AndroidConfiguration.h>。
⚝ 用于音频播放和录制。
④ AAudio (Android Audio)
⚝ 头文件：<aaudio/AAudio.h>。
⚝ Android 高性能音频 API，提供低延迟音频。
⑤ MediaCodec
⚝ 头文件：<media/NdkMediaCodec.h>, <media/NdkMediaFormat.h>。
⚝ 用于音视频编解码。
⑥ MediaExtractor/MediaMuxer
⚝ 头文件：<media/NdkMediaExtractor.h>, <media/NdkMediaMuxer.h>。
⚝ 用于音视频文件解封装和封装。
⑦ Camera2 NDK
⚝ 头文件：<camera/NdkCameraDevice.h>, <camera/NdkCameraCaptureSession.h>, <camera/NdkCameraMetadata.h>。
⚝ 用于访问 Camera2 API，进行相机控制和图像采集。
10.2.5 其他库 (Other Libraries)
① zlib: 压缩库
⚝ 头文件：<zlib.h>。
⚝ 用于数据压缩和解压缩。
② libpng: PNG 图像库
⚝ 头文件：<png.h>。
⚝ 用于 PNG 图像编码和解码。
③ libjpeg: JPEG 图像库
⚝ 头文件：<jpeglib.h>。
⚝ 用于 JPEG 图像编码和解码。
④ freetype: 字体库
⚝ 头文件：<ft2build.h>, <freetype/freetype.h>。
⚝ 用于字体渲染。
⑤ curl: 网络库
⚝ 头文件：<curl/curl.h>。
⚝ 用于网络请求，支持 HTTP, FTP 等协议。
⑥ OpenCV: 计算机视觉库
⚝ 头文件：<opencv2/opencv.hpp>。
⚝ 强大的计算机视觉和图像处理库。
⑦ FFmpeg: 多媒体处理库
⚝ 头文件：根据具体模块而定，例如 <libavcodec/avcodec.h>, <libavformat/avformat.h>。
⚝ 强大的多媒体处理框架，支持音视频编解码、格式转换、流媒体处理等。
本节提供了 NDK 核心库 API 的索引和速查，涵盖了 C/C++ 标准库、Android 特有库、多媒体库和其他常用库。开发者可以根据需求查阅本节内容，快速找到所需的库和 API，并参考官方文档获取更详细的信息和使用方法。
10.3 NDK 开发最佳实践总结与建议
在 Android NDK 开发中，遵循最佳实践可以提高代码质量、性能、可维护性和安全性。本节总结 NDK 开发中的一些最佳实践和建议。
10.3.1 JNI 交互优化
① 减少 JNI 跨越次数
⚝ JNI 跨越 Java 层和 Native 层有性能开销。应尽量减少 JNI 调用的次数，批量传递数据，例如使用数组或 ByteBuffer 传递大量数据。
⚝ 避免在循环中频繁调用 JNI 方法。
② 使用基本类型参数和返回值
⚝ 基本类型（int, float, boolean 等）的 JNI 传递效率比对象类型更高。
⚝ 尽量使用基本类型进行 JNI 方法的参数和返回值传递。
③ 合理使用引用类型
⚝ 局部引用：在 Native 方法中使用局部引用，方法返回后自动释放，避免内存泄漏。
⚝ 全局引用：仅在必要时使用全局引用，例如需要在多个 Native 方法或长时间持有 Java 对象时。使用后及时释放全局引用。
⚝ 弱全局引用：用于缓存对象，不阻止垃圾回收。
④ 避免在 Native 层创建大量 Java 对象
⚝ Java 对象的创建和垃圾回收由 JVM 管理，在 Native 层频繁创建 Java 对象会增加 JVM 的负担，影响性能。
⚝ 尽量在 Java 层创建对象，然后传递到 Native 层进行处理。
⑤ 使用 Direct ByteBuffer 进行数据传输
⚝ Direct ByteBuffer 可以直接在 Native 内存中分配，避免了 Java 堆内存和 Native 内存之间的数据拷贝，提高了数据传输效率，尤其适用于大块数据的传输，例如图像、音频数据。
10.3.2 内存管理优化
① 手动管理 Native 内存
⚝ Native 代码中的内存需要手动管理，使用 malloc, calloc, realloc, free 等函数进行内存分配和释放。
⚝ 避免内存泄漏：确保每次 malloc 或 calloc 分配的内存最终都被 free 释放。
⚝ 使用智能指针 (C++11)：std::shared_ptr, std::unique_ptr 等智能指针可以自动管理内存，减少内存泄漏的风险。
② 内存池技术
⚝ 对于频繁分配和释放小块内存的场景，可以使用内存池技术，预先分配一块大的内存，然后从中分配和回收小块内存，减少 malloc 和 free 的调用次数，提高内存分配效率。
③ 内存对齐
⚝ 确保内存对齐可以提高内存访问效率，尤其是在 ARM 架构上。
⚝ 使用 aligned_alloc (C11) 或平台相关的对齐分配函数进行内存分配。
④ 避免内存碎片
⚝ 频繁分配和释放不同大小的内存块可能导致内存碎片，降低内存利用率。
⚝ 尽量使用内存池或对象池技术，减少内存碎片。
⑤ 内存泄漏检测工具
⚝ 使用内存泄漏检测工具，例如 Valgrind, AddressSanitizer (ASan) 等，检测 Native 代码中的内存泄漏问题。
10.3.3 性能优化
① 性能分析工具
⚝ 使用性能分析工具，例如 Profiler, Systrace, Simpleperf 等，分析 NDK 代码的性能瓶颈，找出需要优化的热点代码。
② 算法和数据结构优化
⚝ 选择合适的算法和数据结构，提高代码执行效率。
⚝ 避免使用低效的算法和数据结构。
③ 编译器优化
⚝ 开启编译器优化选项，例如 -O2, -O3，让编译器进行代码优化。
⚝ 使用 LTO (Link-Time Optimization) 链接时优化，可以进行全局代码优化。
④ 指令集优化
⚝ 针对不同的 CPU 架构（ARM, x86）进行指令集优化，例如使用 ARM Neon 指令集进行 SIMD (Single Instruction, Multiple Data) 优化，提高数据并行处理能力。
⚝ 使用 CPU 特性检测，根据 CPU 支持的指令集选择最优的代码路径。
⑤ 多线程和并发
⚝ 合理使用多线程和并发技术，提高程序的并行处理能力，充分利用多核 CPU 的性能。
⚝ 注意线程同步和互斥，避免竞态条件和死锁问题。
⚝ 使用线程池管理线程，减少线程创建和销毁的开销。
⑥ 缓存优化
⚝ 合理利用 CPU 缓存，提高数据访问速度。
⚝ 优化数据布局，提高缓存命中率。
10.3.4 代码质量与可维护性
① 代码风格统一
⚝ 遵循统一的代码风格，提高代码可读性和可维护性。
⚝ 使用代码格式化工具，例如 ClangFormat，自动格式化代码。
② 模块化设计
⚝ 将 NDK 代码模块化，按照功能划分为不同的模块，提高代码的组织性和可维护性。
⚝ 使用 C++ 命名空间，避免命名冲突。
③ 清晰的注释
⚝ 编写清晰的注释，解释代码的功能和实现思路，方便他人理解和维护代码。
⚝ 尤其对于复杂的算法和逻辑，需要详细注释。
④ 错误处理
⚝ 完善的错误处理机制，处理 JNI 调用和 Native 代码中可能出现的错误。
⚝ 及时检查 JNI 函数的返回值，处理异常情况。
⚝ 使用异常处理机制 (C++ exceptions) 或错误码处理 Native 代码中的错误。
⑤ 单元测试
⚝ 编写单元测试，测试 NDK 代码的各个模块和功能，保证代码质量。
⚝ 使用 C++ 单元测试框架，例如 Google Test。
10.3.5 安全与跨平台
① 代码安全
⚝ 防止逆向工程：对 Native 代码进行混淆和加密，增加逆向分析的难度。
⚝ 安全漏洞防范：注意代码安全，避免缓冲区溢出、格式化字符串漏洞等安全漏洞。
⚝ 输入验证：对 JNI 传递的数据进行输入验证，防止恶意输入。
② 跨平台开发
⚝ 编写跨平台的 C/C++ 代码，提高代码的可移植性。
⚝ 使用条件编译，针对不同的平台进行适配。
⚝ 使用 CMake 构建系统，方便跨平台编译。
⚝ 避免使用平台相关的 API，尽量使用标准 C/C++ 库或跨平台库。
10.3.6 构建与调试
① 使用 CMake 构建系统
⚝ 使用 CMake 构建 NDK 项目，CMake 是官方推荐的构建系统，配置灵活，易于管理依赖，支持多种构建工具和平台。
⚝ 避免使用过时的 ndk-build 构建系统。
② 配置合理的构建选项
⚝ 根据项目需求配置 CMake 构建选项，例如 C++ 标准版本、ABI 架构、优化级别、调试信息等。
③ 使用 Android Studio 集成 NDK 开发
⚝ Android Studio 提供了良好的 NDK 开发集成环境，支持代码编辑、编译、调试、运行等功能。
⚝ 熟练使用 Android Studio 的 NDK 开发工具。
④ Native 调试技巧
⚝ 使用 GDB 或 LLDB 进行 Native 代码调试，设置断点、单步调试、查看变量值等。
⚝ 使用 Android Studio 的 Native 调试功能，方便调试 NDK 代码。
⚝ 使用日志输出进行调试，__android_log_print 输出日志信息。
遵循以上最佳实践和建议，可以帮助开发者编写高质量、高性能、可维护和安全的 Android NDK 代码，提升 NDK 开发效率和应用质量。
10.4 NDK 常见问题与解决方案 (FAQ)
在 Android NDK 开发过程中，开发者可能会遇到各种问题。本节总结一些常见的 NDK 问题，并提供相应的解决方案 (FAQ)。
10.4.1 编译构建问题
① 问题：CMake 构建失败，提示找不到 NDK 或 CMake 工具链。
⚝ 解决方案：
▮▮▮▮⚝ 检查 Android SDK 和 NDK 是否已正确安装，并在 Android Studio 中配置 NDK 路径。
▮▮▮▮⚝ 检查 local.properties 文件中 ndk.dir 属性是否指向正确的 NDK 路径。
▮▮▮▮⚝ 检查 build.gradle 文件中 ndkVersion 和 cmake 配置是否正确。
▮▮▮▮⚝ 清理项目 (Clean Project) 并重新构建 (Rebuild Project)。
▮▮▮▮⚝ 重启 Android Studio。
② 问题：编译错误，提示头文件找不到。
⚝ 解决方案：
▮▮▮▮⚝ 检查 CMakeLists.txt 文件中 include_directories 命令是否包含了所需的头文件路径。
▮▮▮▮⚝ 检查头文件路径是否正确。
▮▮▮▮⚝ 确认 NDK 版本是否支持所需的头文件。
③ 问题：链接错误，提示 undefined reference to symbol。
⚝ 解决方案：
▮▮▮▮⚝ 检查 CMakeLists.txt 文件中 target_link_libraries 命令是否链接了所需的库。
▮▮▮▮⚝ 检查库文件路径是否正确。
▮▮▮▮⚝ 确认库文件是否已正确编译和生成。
▮▮▮▮⚝ 检查 ABI 架构是否匹配，例如 64 位设备使用 64 位库，32 位设备使用 32 位库。
④ 问题：编译速度慢。
⚝ 解决方案：
▮▮▮▮⚝ 使用 Ninja 构建工具，Ninja 构建工具比 Make 构建工具更快。
▮▮▮▮⚝ 开启 CMake 并行编译，使用 -j 参数指定并行编译的线程数。
▮▮▮▮⚝ 使用 ccache 或 sccache 等编译缓存工具，缓存编译结果，加速增量编译。
▮▮▮▮⚝ 优化代码结构，减少编译依赖。
10.4.2 JNI 相关问题
① 问题：java.lang.UnsatisfiedLinkError: dlopen failed: library "xxx.so" not found。
⚝ 解决方案：
▮▮▮▮⚝ 检查 .so 库文件是否已正确打包到 APK 文件中。
▮▮▮▮⚝ 检查 .so 库文件是否位于正确的 ABI 目录下，例如 lib/armeabi-v7a/xxx.so。
▮▮▮▮⚝ 检查 Java 代码中 System.loadLibrary("xxx") 加载的库名是否与 .so 文件名一致（不包含 lib 前缀和 .so 后缀）。
▮▮▮▮⚝ 确认设备 ABI 架构是否与 APK 包中包含的 .so 库 ABI 架构匹配。
② 问题：java.lang.NoSuchMethodError: No static method <method_signature> 或 java.lang.NoSuchFieldError: No field <field_signature>。
⚝ 解决方案：
▮▮▮▮⚝ 检查 Java 方法签名或字段签名是否与 Native 代码中 GetMethodID 或 GetFieldID 使用的签名一致。
▮▮▮▮⚝ 检查 Java 方法或字段名是否拼写错误。
▮▮▮▮⚝ 确认 Java 类中确实存在该方法或字段。
▮▮▮▮⚝ 清理项目并重新构建。
③ 问题：java.lang.IllegalArgumentException: JNI DETECTED ERROR IN APPLICATION: input 'java.lang.String' is not valid UTF-8: illegal start byte 0xXX。
⚝ 解决方案：
▮▮▮▮⚝ 检查 Native 代码中传递给 NewStringUTF 函数的 Native 字符串是否是有效的 UTF-8 编码。
▮▮▮▮⚝ 确保 Native 字符串以 null 结尾。
▮▮▮▮⚝ 如果 Native 字符串不是 UTF-8 编码，考虑使用其他字符串转换函数，例如 NewString (UTF-16)。
④ 问题：JNI local reference table overflow (max=512) 或 JNI ERROR (app bug): local reference table overflow。
⚝ 解决方案：
▮▮▮▮⚝ 检查 Native 代码中是否创建了过多的局部引用而没有及时释放。
▮▮▮▮⚝ 在循环中创建局部引用时，及时使用 DeleteLocalRef 手动删除不再需要的局部引用。
▮▮▮▮⚝ 减少 JNI 跨越次数，批量处理数据。
⑤ 问题：JNI 内存泄漏。
⚝ 解决方案：
▮▮▮▮⚝ 检查 Native 代码中是否正确释放了 malloc, calloc, realloc 分配的内存。
▮▮▮▮⚝ 检查是否成对使用了 Get<Type>ArrayElements 和 Release<Type>ArrayElements，GetStringUTFChars 和 ReleaseStringUTFChars，NewGlobalRef 和 DeleteGlobalRef 等 JNI 函数。
▮▮▮▮⚝ 使用内存泄漏检测工具，例如 Valgrind, AddressSanitizer (ASan) 等，检测内存泄漏问题。
10.4.3 性能问题
① 问题：NDK 代码性能不佳，运行缓慢。
⚝ 解决方案：
▮▮▮▮⚝ 使用性能分析工具，例如 Profiler, Systrace, Simpleperf 等，分析性能瓶颈。
▮▮▮▮⚝ 优化算法和数据结构。
▮▮▮▮⚝ 开启编译器优化选项。
▮▮▮▮⚝ 进行指令集优化，使用 ARM Neon 等 SIMD 指令集。
▮▮▮▮⚝ 合理使用多线程和并发。
▮▮▮▮⚝ 减少 JNI 跨越次数。
▮▮▮▮⚝ 优化内存管理，减少内存分配和释放开销。
② 问题：ANR (Application Not Responding) 错误。
⚝ 解决方案：
▮▮▮▮⚝ 避免在主线程 (UI 线程) 中执行耗时操作，将耗时操作放在 Native 线程或 Java 线程中异步执行。
▮▮▮▮⚝ 检查 Native 代码中是否存在死循环或长时间阻塞的操作。
▮▮▮▮⚝ 使用 Traceview 或 Systrace 分析 ANR 原因。
10.4.4 调试问题
① 问题：Native 代码无法断点调试。
⚝ 解决方案：
▮▮▮▮⚝ 确保 CMake 构建类型为 Debug (Debuggable)。
▮▮▮▮⚝ 在 Android Studio 中配置 Native 调试器 (LLDB)。
▮▮▮▮⚝ 在 Native 代码中设置断点。
▮▮▮▮⚝ 使用 Debug 模式运行应用。
▮▮▮▮⚝ 检查 build.gradle 文件中 jniDebuggable 是否设置为 true。
② 问题：Native 代码崩溃，但没有明确的错误信息。
⚝ 解决方案：
▮▮▮▮⚝ 使用 __android_log_print 输出日志信息，方便定位问题。
▮▮▮▮⚝ 使用 Crashlytics 或其他崩溃收集工具，收集 Native 代码崩溃信息。
▮▮▮▮⚝ 使用 AddressSanitizer (ASan) 或 MemorySanitizer (MSan) 等内存错误检测工具，检测内存错误导致的崩溃。
▮▮▮▮⚝ 使用 GDB 或 LLDB 进行崩溃现场调试，分析崩溃原因。
③ 问题：日志输出不显示。
⚝ 解决方案：
▮▮▮▮⚝ 检查日志级别是否设置正确，例如使用 ANDROID_LOG_DEBUG 或更高级别的日志。
▮▮▮▮⚝ 使用 adb logcat 命令查看日志输出，过滤应用进程的日志。
▮▮▮▮⚝ 确保日志输出代码已执行到。
本节 FAQ 总结了 NDK 开发中常见的编译构建、JNI 相关、性能和调试问题，并提供了相应的解决方案。开发者在遇到问题时，可以参考本节内容进行排查和解决。同时，建议开发者多查阅官方文档、社区论坛和技术博客，积累 NDK 开发经验，提高问题解决能力。
ENDOF_CHAPTER_