Android JNI编程实战教程

本文还有配套的精品资源，点击获取

简介：Android JNI编程是一种允许Java代码与本地C/C++代码交互的技术，利用C/C++的高性能和低级控制优势。本文通过一个入门级demo，讲解了在Android Studio中进行JNI开发的步骤，包括创建项目、设置jni目录、编写Java和C/C++代码、生成JNI头文件、配置CMakeLists.txt文件以及构建和运行项目。通过实践，学习如何在Android应用中实现本地方法调用，以及如何封装和使用C/C++代码库。

1. JNI基本概念介绍

1.1 JNI是什么？

Java Native Interface（JNI）是Java提供的一种标准编程接口，允许Java代码和其他语言编写的本地应用程序或库进行交互。这种互操作性使得开发者可以在Java应用中嵌入其他语言编写的代码，例如C或C++，进而利用这些语言的强大性能或现有库。

1.2 JNI的作用和重要性

通过JNI，Java可以调用C/C++编写的库来访问操作系统级别的API，或者使用高性能计算、数据处理、图像处理等C/C++库。这在进行系统级开发、音视频处理、硬件通信等对性能要求极高的场景中非常重要。同时，它也让Java开发者能更好地复用旧有的本地代码，降低迁移成本。

1.3 JNI和Java的交互过程

JNI的交互涉及到两个主要过程：Java代码调用本地方法，以及本地方法调用Java代码。开发者首先需要在Java类中声明本地方法，然后通过JNI提供的接口来实现这些方法。在实际调用时，JVM会通过JNI动态加载和链接到相应的本地库，进行数据类型转换和方法调用，完成两层代码之间的交互。

2. Android Studio环境下的JNI开发流程

2.1 开发环境的搭建

2.1.1 安装Android Studio

在开始JNI开发之前，首先需要一个合适的集成开发环境（IDE）。Android Studio是开发Android应用的官方IDE，它提供了丰富的工具和插件支持。安装Android Studio的步骤如下：

1. 访问 Android Studio官方下载页面 。
2. 根据您的操作系统下载相应的安装包。
3. 安装下载的安装包，遵循安装向导的指示完成安装。

安装完成后，启动Android Studio并按照初次运行的引导完成初始设置，比如选择SDK版本和下载所需的组件。

2.1.2 配置JDK和NDK环境

为了在Android Studio中使用JNI，必须确保Java开发工具包（JDK）和原生开发工具包（NDK）已经被正确安装和配置。

1. 配置JDK环境 ：

   • 确保JDK已经被安装在您的机器上，可以通过运行 java -version 在命令行中检查JDK版本。
   • 在Android Studio中，进入 File > Project Structure > SDK Location 来设置JDK路径。

2. 安装和配置NDK ：

   • 在Android Studio的 Tools > SDK Manager 中，选择 SDK Tools 标签页。
   • 勾选 NDK (Side by side) 选项，然后点击 Apply 进行下载和安装。
   • 安装完成后，在 File > Project Structure > SDK Location 中设置NDK路径。

完成以上步骤之后，您的Android Studio环境就准备好了，可以开始进行JNI开发了。

2.2 开发流程概述

2.2.1 JNI开发的基本步骤

JNI开发通常涉及以下几个基本步骤：

1. 创建Android项目 ：启动Android Studio，创建一个新的Android项目。
2. 启用C++支持 ：在项目中启用C++支持，并配置CMake或ndk-build脚本来编译本地代码。
3. 编写Java代码中的本地方法 ：定义Java接口或类中的本地方法。
4. 生成JNI头文件 ：使用 javah 或在Android Studio中通过Java类名自动生成JNI头文件。
5. 编写C/C++本地实现 ：根据JNI头文件，编写本地方法的C/C++实现。
6. 配置CMakeLists.txt ：配置CMakeLists.txt来定义构建规则和链接选项。
7. 构建项目 ：构建包含JNI代码的Android项目。
8. 运行和调试 ：运行和调试应用以测试JNI代码的正确性和性能。

2.2.2 各步骤的详细说明

在下面的小节中，我们将会详细解释这些步骤，包括每个步骤中的关键操作和注意事项。

1. 创建Android项目 ：

   • 新建项目时，选择 Native C++ 模板可以快速启动包含C++支持的项目。
   • 为项目命名并设置好路径后，Android Studio会生成一个基本的应用结构，其中包含了 app/src/main/cpp 目录用于存放C/C++代码。

2. 启用C++支持 ：

   • 在 app 模块的 build.gradle 文件中，确保 externalNativeBuild 配置已经启用，并且指定了CMakeLists.txt或Android.mk的位置。
   • 进入 File > Project Structure > Project ，确保 Language level 设置符合NDK的要求。

通过以上步骤，您的开发环境就设置完毕，并且您已经了解了JNI开发的基本流程。在后续章节中，我们将详细探讨如何在Android Studio中启用C++支持以及如何在项目中设置JNI目录。

3. 创建项目并启用C++支持

3.1 新建Android项目

3.1.1 选择项目模板

创建一个Android项目是开始任何Android开发工作的第一步。在Android Studio中，开发者可以选择一个模板来快速搭建项目的骨架。通常情况下，可供选择的模板分为两类：一类是基于Java的活动（Activity）模板，另一类是包含C++支持的模板。对于需要使用JNI的项目，选择包含C++支持的项目模板是明智的决策，因为它会自动配置好C++开发所需的环境和相关文件。

在新建项目时，开发者需要通过Android Studio的启动窗口进行操作。启动窗口提供了多种选项，其中“Native C++”模板特别为使用C++和JNI的开发者设计。选择“Native C++”模板将确保项目创建时自动添加CMakeLists.txt文件以及构建脚本，这些是后续配置和构建C++代码的基础。

3.1.2 配置项目名称和保存路径

接下来是配置项目的名称和保存路径，这是项目创建过程中的关键步骤之一。项目名称应简洁明了，能够反映出应用的主要功能或者特性。名称设置完成后，需要选择一个合适的目录用于保存项目文件。保存路径的选择应考虑到项目的存储需求、备份的便捷性以及团队协作的需要。

路径选择完成后，Android Studio将开始项目创建过程。它将根据所选模板创建一个包含多个默认文件和文件夹的项目结构。这时，可以开始进行一些基本的项目设置，比如设置MinSdkVersion（最低支持的SDK版本）和TargetSdkVersion（目标SDK版本），以及配置其他相关的构建变量。

3.2 启用C++支持

3.2.1 进入项目设置

在Android Studio中为项目启用C++支持并不是创建项目时的必选项。因此，在已有的项目中添加C++支持就成了需要掌握的技能。开始之前，进入项目的设置是首要步骤。在Android Studio的菜单栏中，选择 File > Project Structure ，打开项目结构对话框。

在此对话框中，可以调整项目的模块设置。对于想要添加C++支持的项目，应当在模块设置中寻找“Sources”标签。在这个界面中，Android Studio允许开发者添加新的源代码文件夹，这通常包括添加一个名为 cpp 的文件夹，以便于管理C++源代码和相关文件。

3.2.2 启用C++支持的步骤

在模块设置窗口中找到 C++ 部分，点击 + 按钮来启用C++支持。通常情况下，这将需要开发者选择CMake或ndk-build的构建脚本，或者是生成一个默认的CMakeLists.txt文件。接着，Android Studio会自动在项目的app模块中创建一个cpp文件夹，并在该文件夹下创建一个CMakeLists.txt文件。

随后，开发者需要在 build.gradle 文件中进行相应的配置，以确保Gradle脚本可以找到并处理C++源代码。这通常涉及修改 sourceSets 配置块，并指定C++源代码所在的文件夹和CMakeLists.txt文件的位置。

现在，Android Studio已经为项目启用了C++支持。开发者可以在这个基础上开始编写C++代码，创建本地方法，并使用JNI将它们与Java代码桥接起来。通过这样的步骤，开发者能够充分利用C++的强大性能优势，实现更复杂、更高效的Android应用开发。

4. jni目录的作用及设置

4.1 jni目录的创建和作用

4.1.1 jni目录的重要性

JNI（Java Native Interface）是Java和非Java代码（通常是C/C++代码）之间的接口。在Android Studio中开发JNI时，jni目录是存放本地源代码和头文件的专用文件夹。正确设置jni目录对于让系统识别和编译本地代码至关重要。此外，它还用于存放生成的JNI头文件和预编译的库文件。

4.1.2 如何创建jni目录

创建jni目录的步骤如下：

1. 在Android项目中，右键点击 app/src/main 目录。
2. 选择 New -> Directory 。
3. 命名新文件夹为 jni 。

完成以上步骤后，你将看到一个新创建的 jni 文件夹出现在项目目录结构中，这时你就可以在这个目录下存放你的本地代码了。

4.2 jni目录的配置

4.2.1 添加源文件和头文件

在 jni 目录下创建源文件（ .cpp 或 .c 文件）和头文件（ .h 文件）是存放本地方法实现的地方。例如，你可以创建一个名为 native-lib.cpp 的源文件和一个对应的 native-lib.h 头文件，这两个文件将包含本地方法的实现和声明。将这些文件放置在 jni 目录下，可以确保Android构建系统能够找到并编译它们。

4.2.2 配置Gradle以识别jni目录

为让Gradle构建脚本能够识别 jni 目录，并包含目录下的源文件和头文件，需要进行如下配置：

1. 打开 build.gradle （模块级别）文件。
2. 在 android 部分中找到 sourceSets 块。
3. 在 main 部分中添加 jni.srcDirs 属性，指定 jni 目录。

示例配置如下：

android {
    ...
    sourceSets {
        main {
            jni.srcDirs = ['src/main/jni']
        }
    }
}

以上步骤能够确保Android Studio在构建项目时识别并包含 jni 目录中的文件。

现在，我们已经建立了jni目录，并且将其配置到了Android项目中。这为接下来在C/C++中编写本地方法的实现打下了坚实的基础。下面的章节将介绍如何在Java中定义本地方法，以及如何加载和使用这些方法。在了解了这些概念之后，我们将会深入探讨如何编写本地代码，并最终在Android应用中运行和调试它们。

5. Java代码中本地方法的定义和加载

5.1 本地方法的定义

5.1.1 编写本地方法的语法

在Java中，本地方法是指用Java语言声明而用非Java语言实现的方法。在Java代码中定义本地方法时，必须在方法声明前添加 native 关键字，表明这是一个本地方法。例如：

public class MyClass {
    // 声明本地方法
    public native void myNativeMethod();

    static {
        // 加载包含本地方法实现的库
        System.loadLibrary("myNativeLibrary");
    }
}

在上述示例中， myNativeMethod 是一个本地方法，该方法的实现将由C或C++代码提供。注意，静态初始化块用于加载包含本地方法实现的动态链接库（DLL），在这个例子中，库的名称是 myNativeLibrary 。通常，这个名字会与Java代码中定义的本地方法的名称相关联，但实际加载的库名可能会有所不同，这取决于操作系统和平台。

5.1.2 本地方法的命名约定

在JNI中，本地方法的名称在被JNI方法调用时会被“修饰”或“转换”，以形成一个能与C/C++函数名相匹配的名称。这个过程遵循一定的命名规则。例如，Java方法 myNativeMethod 在C/C++中的对应实现将有一个类似于以下的名字：

JNIEXPORT void JNICALL Java_MyClass_myNativeMethod(JNIEnv *env, jobject obj);

这里的命名规则是 Java_完整类名_方法名 ，并包含了JNI函数签名。使用这种命名约定，JNI能够确保在C/C++代码中找到正确的函数以匹配Java中声明的本地方法。

5.2 本地方法的加载机制

5.2.1 Java Native Interface的加载过程

Java Native Interface的加载过程涉及Java虚拟机（JVM）与本地代码之间的相互作用。当Java代码调用一个本地方法时，JVM首先会尝试查找对应平台的本地库。如果找到了，JVM会加载这个库，并定位到对应的本地方法实现函数，然后跳转到该函数执行。

这个过程隐藏了许多复杂性，如：

1. 确定本地方法的签名。
2. 确保本地代码与Java代码的数据类型兼容。
3. 处理参数传递和返回值。

5.2.2 如何正确加载本地方法

要正确加载本地方法，以下是一些关键步骤：

1. 确保本地库存在 ：需要确保编译好的本地库被放置在正确的位置，比如在Android中是 /libs 文件夹下，或者通过系统属性 java.library.path 指定的路径下。

2. 正确加载库 ：在Java代码中，确保使用 System.loadLibrary 加载了包含本地方法实现的库。

3. 确保方法签名匹配 ：在C/C++代码中实现的本地方法必须与Java声明的方法签名完全匹配，包括方法名和参数类型。

4. 调试和测试 ：使用合适的工具进行调试，确保本地方法能够被正确加载和调用。

下面是一个示例，展示如何在Java中加载和调用本地方法：

public class HelloJNI {
    // 声明本地方法
    public native void sayHello();

    // 加载包含本地方法实现的库
    static {
        System.loadLibrary("hello");
    }

    public static void main(String[] args) {
        new HelloJNI().sayHello();  // 调用本地方法
    }
}

在C/C++代码中，本地方法 sayHello 的实现可能看起来如下：

#include <jni.h>
#include "HelloJNI.h"

JNIEXPORT void JNICALL Java_HelloJNI_sayHello(JNIEnv *env, jobject obj) {
    // 实现细节
    printf("Hello from C++!\n");
}

在这段C代码中，我们定义了与Java中声明的本地方法签名相对应的函数。当 HelloJNI 实例调用 sayHello 方法时，JVM会调用这个C函数。

6. JNI头文件的生成和作用

6.1 生成JNI头文件

6.1.1 使用javah工具生成

在使用Java Native Interface（JNI）进行本地方法的开发时，通常需要生成对应的JNI头文件。这个文件包含了本地方法的签名，它将Java方法名映射为C/C++函数名，使得开发者可以在C/C++代码中正确地引用和实现这些方法。在过去，javah工具是生成JNI头文件的常用方法，尽管在最新的JDK版本中，javah已经被更先进的javac编译器所取代，后者可以自动生成所需的头文件。

以下是使用javah工具生成头文件的基本步骤：

1. 编写Java代码，声明本地方法。
2. 编译Java代码，确保本地方法声明无误。
3. 使用命令行运行 javah 工具，并指定包含本地方法声明的Java类的全限定名。

javah -jni com.example.MyClass

上述命令会生成一个名为 com_example_MyClass.h 的头文件，其中包含了本地方法对应的C/C++函数签名。

6.1.2 生成头文件的原理和作用

JNI头文件的生成原理基于Java类的元数据信息，其中包含了方法名、参数类型和返回类型等信息。javah工具解析这些信息，并生成具有标准命名规则的C/C++函数原型，允许开发者在本地代码中实现这些函数。

这些头文件的作用是简化本地代码的编写过程，开发者无需手动编写方法的C/C++签名。一旦头文件生成，它们会被包含在相应的C/C++源文件中，开发者可以直接从头文件中获取方法签名的详细信息。

6.2 头文件的使用方法

6.2.1 头文件在C/C++中的引用

在C/C++代码中，本地方法需要被正确地声明和定义才能被Java代码调用。JNI头文件包含了这些必要的声明，因此它们必须被包含在本地方法的源文件中。

#include "com_example_MyClass.h"

JNIEXPORT jstring JNICALL Java_com_example_MyClass_myNativeMethod(JNIEnv *env, jobject obj) {
    // C/C++代码实现
    return (*env)->NewStringUTF(env, "Hello from C++);
}

6.2.2 头文件中函数声明的处理

在使用头文件中的函数声明时，开发者需要了解如何正确处理这些声明。这通常包括确保参数类型匹配和处理返回值。JNI为Java和C/C++之间提供了一套调用规范，例如，所有Java基本类型和字符串都有对应的JNI类型。

在头文件中，你会看到函数声明类似于：

JNIEXPORT jstring JNICALL Java_com_example_MyClass_myNativeMethod(JNIEnv *env, jobject obj);

上述代码中， JNIEXPORT 和 JNICALL 是JNI定义的宏， jstring 是返回类型， Java_com_example_MyClass_myNativeMethod 是JNI函数名， JNIEnv * 是为调用JNI函数而提供的环境指针， jobject 代表调用该本地方法的对象。

开发者需要确保C/C++代码中的函数定义与头文件中的声明完全一致。此外，处理JNI函数调用时，可能需要使用JNI API函数来访问Java对象和调用Java方法。这包括使用 env->FindClass 获取类对象， env->GetMethodID 获取方法ID等。

总而言之，JNI头文件是本地代码开发中的关键，它们使得在Java代码和本地代码之间建立桥梁变得简单和直接。通过合理地生成、引用和处理头文件中的函数声明，开发者可以高效地实现本地方法，构建起功能强大的Android应用。

7. C/C++代码的编写与实现

7.1 编写本地方法实现

7.1.1 C/C++中方法的声明和定义

在C/C++中实现JNI方法时，我们需要遵循特定的命名约定以确保Java能够识别对应的本地函数。例如，假设我们有以下Java方法：

public native String stringFromJNI();

我们需要在C/C++代码中这样声明和定义它：

#include <jni.h>

JNIEXPORT jstring JNICALL
Java_com_example_myapp_MainActivity_stringFromJNI(JNIEnv *env, jobject obj) {
    return (*env)->NewStringUTF(env, "Hello from C++");
}

这里使用了 JNIEXPORT 和 JNICALL 宏，它们依赖于平台，由jni.h提供，确保函数名称在编译时会被适当地修改以适应不同的平台。

7.1.2 本地方法参数和返回值的处理

在JNI中，所有的Java对象和基本数据类型都有对应的本地表示。例如，Java的 String 类型在JNI中对应 jstring 类型。返回值也类似，我们可以从Java返回字符串到C/C++中，然后返回一个 jstring 对象。

7.2 实现本地方法的具体操作

7.2.1 Java类型与C/C++类型的映射

JNI为Java类型和C/C++类型之间提供了一系列的映射规则。例如，Java的 boolean 类型对应C/C++的 jboolean ， byte 对应 jbyte ， short 对应 jshort ，以此类推。Java中的 Object 类型对应 jobject ，类和接口对应 jclass 和 jobject 。

7.2.2 数据类型的转换和操作

当我们在C/C++中处理Java传递过来的对象时，可能需要将它们转换为适合在C/C++中操作的类型。例如，Java传递过来的字符串可以通过 env->GetStringUTFChars() 方法转换为C字符串，并在处理完毕后使用 env->ReleaseStringUTFChars() 释放资源。

const char* jstr = env->GetStringUTFChars(jstr, 0);
// 在此处对jstr进行操作
env->ReleaseStringUTFChars(jstr, native_str);

JNI提供了许多这样的转换函数，以处理不同的数据类型转换和操作。开发者必须熟悉这些函数，以便在本地代码中有效地处理Java类型。

在编写C/C++代码时，开发者需要对内存管理和类型安全特别注意。JNI环境中内存泄漏和类型不匹配是常见的问题来源，因此需要仔细设计代码，合理管理资源。

本文还有配套的精品资源，点击获取

简介：Android JNI编程是一种允许Java代码与本地C/C++代码交互的技术，利用C/C++的高性能和低级控制优势。本文通过一个入门级demo，讲解了在Android Studio中进行JNI开发的步骤，包括创建项目、设置jni目录、编写Java和C/C++代码、生成JNI头文件、配置CMakeLists.txt文件以及构建和运行项目。通过实践，学习如何在Android应用中实现本地方法调用，以及如何封装和使用C/C++代码库。

本文还有配套的精品资源，点击获取