Android Studio中JNI编程入门实践指南

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

简介：本教程详细介绍了如何在Android Studio集成开发环境中进行JNI（Java Native Interface）编程。JNI允许Java代码与其他语言如C/C++编写的应用程序交互，在性能优化和硬件接口使用上发挥重要作用。教程内容包括设置NDK环境、创建Android项目、创建JNI源代码、定义JNI函数、生成JNI头文件、实现JNI函数、配置build.gradle文件、构建和运行、以及测试验证。通过本教程，读者将掌握JNI编程的完整流程，并能够将其应用于实际开发中。

1. Android Studio简介与JNI介绍

Android Studio简介

Android Studio是谷歌官方开发的集成开发环境（IDE），为Android应用开发提供了丰富的工具和功能。它提供代码编辑、调试、性能分析和应用打包等一站式服务。自2013年推出以来，已经成为开发者首选的Android应用开发平台。

JNI的概念与重要性

JNI（Java Native Interface）是Java平台标准版的一部分，允许Java代码和其他语言编写的代码进行交互。这是Android应用中经常需要使用的功能，特别是当我们需要访问操作系统级别的功能或重用已有的C/C++库时。通过JNI，Java代码可以调用本地代码（如C/C++编写的库函数），反之亦然，从而在不同的编程语言和平台之间架起了一座桥梁。

JNI的应用场景

在Android应用开发中，JNI经常用于以下场景：
- 性能优化：在某些性能敏感的场景，如图像处理、游戏开发等，使用C/C++编写关键代码段可以提升性能。
- 代码复用：利用已有的C/C++库，如OpenCV图像处理库，可以快速集成到Android应用中。
- 系统功能访问：访问Android系统底层API，进行硬件控制、系统服务交互等。

通过学习JNI，开发者可以扩展Java的边界，打破语言障碍，将Java的强大功能与C/C++的高性能结合在一起，为用户提供更加丰富和高效的移动应用体验。在下一章节中，我们将开始介绍如何设置NDK环境，这是使用JNI进行开发的第一步。

2. NDK环境设置

2.1 NDK的安装与配置

2.1.1 下载NDK安装包

为了开发Android应用中的原生代码，首先需要安装NDK（Native Development Kit）。NDK的安装包可以从Android Studio的SDK Manager中获得，或者从Android官方网站直接下载。

在Android Studio中，可以打开 Preferences (或 Settings ), 导航至 Appearance & Behavior > System Settings > Android SDK > SDK Tools ，然后勾选 NDK (Side by side) 并下载。

用户也可以直接访问 Android NDK 官网 下载独立的NDK安装包，选择适合你开发平台的版本进行下载。

2.1.2 环境变量的配置方法

在NDK安装完成后，需要配置系统环境变量以方便在命令行中直接使用NDK工具。

在Linux或Mac系统中，通过编辑 ~/.bash_profile 或者 ~/.zshrc 文件，添加如下环境变量：

export ANDROID_NDK_HOME=/path/to/your/ndk
export PATH=$PATH:$ANDROID_NDK_HOME

在Windows系统中，可以通过 控制面板 > 系统 > 高级系统设置 > 环境变量 ，新建系统变量 ANDROID_NDK_HOME 并指向你的NDK安装路径，然后在 Path 环境变量中添加 %ANDROID_NDK_HOME% 。

完成环境变量配置后，通过命令行运行 ndk-build 测试是否配置成功。

2.1.3 检验NDK环境设置

为了确认NDK环境变量配置成功，可以在命令行输入以下命令：

ndk-build -v

如果系统成功显示了NDK的版本信息，那么说明环境变量配置无误，NDK已经可以使用。

2.2 Android NDK与JDK的关系

2.2.1 JDK在NDK开发中的作用

在Android NDK的开发过程中，JDK（Java Development Kit）是必不可少的，因为NDK主要用于将C/C++代码编译成可以在Android平台上运行的原生库，但大部分的Android应用仍然需要使用Java或Kotlin进行开发。

JDK主要负责处理应用的Java代码部分，而NDK则处理Java和C/C++代码间的交互以及优化性能热点问题。因此，Java虚拟机（JVM）和原生代码的交互十分关键。JNI（Java Native Interface）就是负责这种交互的机制。

2.2.2 如何解决JDK版本冲突问题

由于Android应用通常需要与Java代码交互，不同的开发环境可能会要求不同版本的JDK，这可能会导致版本冲突。例如，Android Studio默认可能需要较新的JDK版本，而某些旧的项目或库可能依赖于较旧的JDK。

解决这一问题的常用方法包括：

1. 多JDK管理工具 ：使用工具如 jEnv 或 SDKMAN! 来管理多个JDK版本，能够方便地在不同项目间切换使用的JDK版本。
2. 环境变量配置 ：为不同的项目配置不同的环境变量，确保编译和运行时使用正确的JDK版本。
3. 统一JDK版本 ：尽可能统一项目依赖的JDK版本，从而避免版本冲突。

为了配置 jEnv ，安装好 jEnv 后，你需要执行以下步骤：

# 安装jEnv
$ brew install jenv

# 添加jEnv到你的shell配置中
$ echo 'export PATH="$HOME/.jenv/bin:$PATH"' >> ~/.bash_profile
$ echo 'eval "$(jenv init -)"' >> ~/.bash_profile

# 重启终端或执行source ~/.bash_profile

# 安装特定版本的JDK
$ jenv add /Library/Java/JavaVirtualMachines/jdk1.8.0_201.jdk/Contents/Home

# 列出安装的JDK版本
$ jenv versions

# 设置当前shell使用的JDK版本
$ jenv global 1.8

jEnv 的配置允许你为每个项目设置特定的JDK版本，并在不同的项目间进行切换。

3. Android项目创建与结构介绍

3.1 创建一个新的Android项目

3.1.1 使用Android Studio创建项目

使用Android Studio创建项目是开发Android应用的第一步，它提供了项目模板、项目依赖配置、API级别选择等便利功能。具体操作如下：

1. 打开Android Studio，选择”Start a new Android Studio project”。
2. 在创建向导中，选择一个适合你的项目模板，如”Empty Activity”。
3. 输入项目名称、包名、保存位置等基本信息，并选择目标设备和最小的API级别。
4. 选择你想要使用的语言（Java或Kotlin）以及测试框架（JUnit或Espresso）。
5. 点击”Finish”，Android Studio将自动创建项目并打开IDE。

创建后的项目结构清晰，包含以下基本元素：
- app/ ：包含应用代码的主要模块目录。
- build.gradle ：配置项目的构建脚本文件。
- settings.gradle ：设置项目名称的配置文件。
- MainActivity.java/.kt ：应用程序的主入口，通常是活动（Activity）类。

3.1.2 Android项目的基本结构

一个典型的Android项目基本结构如下所示，它遵循MVC（Model-View-Controller）模式：

• app/ ：这是应用的主要目录，包含了所有源代码、资源文件以及包结构。
• src/ ：存放源代码和资源文件。
  • main/ ：存放主要代码和资源。
  • java/ ：存放Java源代码文件。
  • res/ ：存放资源文件，如布局、字符串、图标等。
  • androidTest/ ：存放Android UI测试用的代码。
  • test/ ：存放单元测试代码。
• build.gradle ：模块级别的构建配置文件，用于配置依赖和构建任务。
• build/ ：存放编译过程中生成的文件。
• gradle.properties ：定义项目级别的全局属性，如版本号。
• build.gradle ：项目级别的构建配置文件，配置了项目的构建版本和依赖。
• settings.gradle ：定义项目中哪些模块需要被构建。

此外，Android Studio还为项目的构建和运行提供了大量的配置选项和工具支持，使得开发者可以轻松管理项目。

3.2 Android项目中JNI的位置

3.2.1 JNI在Android项目中的角色

JNI（Java Native Interface）是Java提供的一种标准编程接口，它允许Java代码与使用其他编程语言编写的本地应用程序和库进行交互。在Android项目中，JNI的主要作用是：

1. 性能优化 ：对那些性能要求极高的操作，可以利用C或C++进行优化，提高执行效率。
2. 系统资源访问 ：直接访问操作系统或硬件资源，如相机、传感器、底层系统API等。
3. 代码复用 ：利用现有的本地代码库或第三方库，无需重写即可在Android平台上使用。

3.2.2 如何管理JNI相关的文件

管理JNI相关的文件是项目维护的一个重要方面，主要步骤包括：

1. 创建JNI源代码文件夹 ：通常命名为 native-lib 或 jni ，并将其放在 app/src/main/ 目录下。
2. 编写JNI接口声明 ：在Java代码中声明本地方法，并使用 System.loadLibrary() 加载对应的库文件。
3. 编写和编译本地代码 ：使用C或C++编写本地代码，并编译成 .so 共享库文件。
4. 配置Gradle脚本 ：在 build.gradle 中配置NDK路径、ABI过滤、编译指令等，以便Gradle可以正确处理本地库。

这些文件和配置通常在Android Studio中进行统一管理，便于项目的版本控制和协作开发。其中， app/build.gradle 文件是配置本地库编译和链接的关键位置。

android {
    ...
    defaultConfig {
        ...
        externalNativeBuild {
            ndkBuild {
                // NDK编译配置
                abiFilters 'armeabi-v7a', 'arm64-v8a'
            }
        }
        externalNativeBuild {
            cmake {
                // CMake编译配置
                cppFlags ""
            }
        }
    }
    externalNativeBuild {
        ndkBuild {
            // 指定NDK构建脚本路径
            path 'src/main/jni/Android.mk'
        }
        cmake {
            // 指定CMakeLists.txt文件路径
            path 'src/main/jni/CMakeLists.txt'
        }
    }
}

通过上述配置，开发者可以确保在构建过程中自动编译和链接JNI本地代码，确保应用的完整性和可移植性。

接下来，让我们深入了解如何创建JNI源代码，以及如何编译和生成所需的库文件。

4. JNI源代码创建方法

4.1 JNI源文件的编写

4.1.1 JNI源代码的基本结构

在开始编写JNI（Java Native Interface）源文件之前，了解其基本结构是至关重要的。JNI源代码通常包括以下几个关键部分：

• 头文件包含 ：每个JNI源文件开头都需要包含 jni.h 头文件，它定义了与Java交互所需的函数、宏和类型。
• 本地方法声明 ：需要在Java类中声明哪些方法是本地的，并在JNI源文件中以特定格式实现它们。
• 方法实现 ：实际的本地方法实现，通常涉及到调用C/C++库函数或者执行特定的算法。
• 异常处理 ：在本地方法执行过程中可能需要抛出异常到Java层。

#include <jni.h>
#include "com_example_myapp_MainActivity.h" // Java类头文件，根据实际情况替换路径

// 声明本地方法
JNIEXPORT void JNICALL
Java_com_example_myapp_MainActivity_nativeMethod(JNIEnv *env, jobject obj) {
    // 方法实现
}

在上述代码中， Java_com_example_myapp_MainActivity_nativeMethod 是JNI函数的标准命名格式，它遵循”Java_[完整类名]_[方法名]”的规则。 JNIEnv 指针提供了一系列函数用于操作Java对象和调用Java方法， jobject 参数代表了调用本地方法的Java对象。

4.1.2 Java本地方法声明

在Java代码中声明本地方法是使用 native 关键字。比如，如果你要声明一个本地方法 nativeMethod ，你会在Java类中这样写：

public class MainActivity extends AppCompatActivity {
    static {
        System.loadLibrary("native-lib"); // 加载本地库时使用
    }

    // 声明本地方法
    public native void nativeMethod();
    // 其他Java代码...
}

在上述代码中， nativeMethod 方法被标记为 native ，这意味着它将在C/C++层面上实现。注意 System.loadLibrary 方法用于加载名为”native-lib”的本地库，该库名称需要与实际编译出的库文件名匹配。

4.2 JNI源代码的编译与生成

4.2.1 使用NDK编译器编译JNI源文件

NDK（Native Development Kit）提供了一套工具，用于编译C和C++源代码为Android平台上的机器代码。编译器会生成对应CPU架构的库文件。这些库文件需要与Android应用程序一起打包，以便在运行时被加载。

编译过程通常涉及到编写 Android.mk 或者 CMakeLists.txt 文件来定义编译规则。然后使用 ndk-build 命令或者CMake来编译源代码，生成库文件。

# Android.mk示例文件
LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)
LOCAL_MODULE    := native-lib
LOCAL_SRC_FILES := native-lib.cpp
include $(BUILD_SHARED_LIBRARY)

在上述 Android.mk 文件中，定义了模块名称（ LOCAL_MODULE ），源文件名称（ LOCAL_SRC_FILES ），并包含 BUILD_SHARED_LIBRARY 宏来构建共享库。

4.2.2 生成可被Android系统调用的库文件

编译完成后，会生成一个或多个 .so 文件，这些文件是不同CPU架构的共享库。在Android应用打包时，这些库文件会被包含到APK中。当应用程序运行时，Java层的方法加载并调用这些本地方法。

库文件的名称和位置很重要，因为在Java代码中加载这些库时，需要指定和库文件名匹配的字符串。通常，这个过程由Gradle脚本自动处理，它根据配置的 sourceSets 指令将库文件放到正确的目录。

android {
    ...
    sourceSets {
        main {
            jniLibs.srcDirs 'libs'
        }
    }
    ...
}

上述Gradle配置段确保了所有 jniLibs 目录下的库文件被正确地包含到最终APK中。

在下一章节，我们将深入探讨JNI函数声明的具体要求以及如何实现这些函数，并涉及到如何调试这些与Java层交互的本地方法。

5. JNI函数声明与实现

5.1 JNI函数声明的要求

5.1.1 遵循的命名规则

在Java代码中声明的本地方法，会通过JNI与C/C++函数进行桥接。这种桥接要求开发者在声明本地方法时遵循特定的命名规则。例如，一个Java类中的本地方法声明如下：

public native int add(int a, int b);

为了在C/C++代码中找到对应的函数实现，JNI使用了特定的命名规范，将Java方法名转换为如下形式的C/C++函数名：

jint Java_YourClass_add(JNIEnv* env, jobject obj, jint a, jint b);

这里的函数名由三部分组成： Java_ 前缀、完整包名+类名（用下划线替换包中的点）、以及原Java方法名。参数列表则从第一个参数开始，包含一个指向 JNIEnv 结构的指针和一个 jobject 引用，指向声明该方法的Java类的实例，随后是Java方法的参数列表。

5.1.2 参数和返回值的处理

JNI函数需要特别注意参数和返回值的处理。在Java中，所有类型都对应着JNI的某种引用类型或基本类型。因此，JNI函数的参数不仅包括Java方法的参数，还包括 JNIEnv* 和 jobject 。返回值类型通常由 j 前缀的类型表示，比如 jint 表示 int 类型。

开发者在实现JNI函数时，需要将Java中的引用类型和基本类型与JNI中的类型进行转换，这包括数据类型的转换以及对对象引用的处理。例如，Java中的 String 对象在JNI中处理时需要使用 GetStringUTFChars 和 ReleaseStringUTFChars 函数来获取和释放UTF-8编码的C字符串。

5.2 JNI函数的实现步骤

5.2.1 编写本地方法的实现代码

在了解了JNI命名规则和参数处理后，我们就可以开始编写本地方法的实现代码了。以 add 方法为例，其C/C++实现可能如下：

#include <jni.h>
#include <stdio.h>

JNIEXPORT jint JNICALL Java_YourClass_add(JNIEnv* env, jobject obj, jint a, jint b) {
    return a + b;
}

在实现代码中，开发者可以利用JNI提供的各种函数和宏来访问Java对象、调用Java方法以及管理Java对象引用。例如，使用 NewObject 、 GetMethodID 、 CallStaticObjectMethod 等JNI函数来创建和操作Java对象。

5.2.2 调试本地方法与Java层交互

实现本地方法后，调试就成为了一项重要的任务。开发者需要确保本地方法被正确调用，并且与Java层的交互没有问题。调试通常涉及到几个方面：

• 使用 printf 或日志库输出中间变量值进行基本逻辑检查。
• 通过断点来调试本地方法的执行流程。
• 在Android Studio中使用JDWP（Java Debug Wire Protocol）进行远程调试。

此外，JNI调用可能会引发异常，因此需要检查错误代码，并利用 ExceptionCheck 、 ExceptionDescribe 等JNI函数来处理异常情况。调试时，开发者还可以采用模拟器或真实设备，并结合Android的日志系统（Logcat）来捕获和分析输出信息。

6. JNI头文件生成方式

6.1 利用javah命令生成头文件

6.1.1 javah命令使用方法

javah 是一个用于从 Java 本地接口（JNI）声明生成 C 头文件的工具，这些头文件在 Java 代码和本地代码之间的接口被定义。生成的头文件包含必要的信息，如函数签名，这些信息对于将 Java 类型转换为 C/C++ 类型是必需的。在使用 javah 之前，你需要确保你的 Java 类中声明了一些本地方法，这些方法通过 native 关键字标识。

使用 javah 的基本命令格式如下：

javah -classpath <your_classpath> -d <output_directory> <fully_qualified_class_name>

这里， <your_classpath> 是编译 Java 类的类路径， <output_directory> 是生成头文件的输出目录，而 <fully_qualified_class_name> 是包含本地方法的 Java 类的完全限定名。

例如，如果你有一个名为 com.example.MyClass 的 Java 类，其中包含本地方法，你可以这样生成头文件：

javah -classpath bin -d headers com.example.MyClass

这条命令会在 headers 目录下生成一个 com_example_MyClass.h 文件。

6.1.2 头文件的作用和结构

头文件的作用是提供 Java 类中本地方法的签名到 C/C++ 代码。这是本地方法实现的关键，因为它允许本地代码知道如何正确地与 Java 方法通信。

一个典型的头文件包含了宏定义以及 extern "C" 块来防止 C++ 名字修饰（name mangling）。例如：

/* Header for class com_example_MyClass */

#ifndef _Included_com_example_MyClass
#define _Included_com_example_MyClass

#ifdef __cplusplus
extern "C" {
#endif

/*
 * Class:     com_example_MyClass
 * Method:    nativeMethod
 * Signature: (I)J
 */
JNIEXPORT jlong JNICALL Java_com_example_MyClass_nativeMethod
  (JNIEnv *, jobject, jint);

#ifdef __cplusplus
}
#endif

#endif

在这个例子中， nativeMethod 是一个本地方法，它接受一个整型参数并返回一个长整型值。

6.2 头文件与源文件的关联

6.2.1 如何正确包含和使用头文件

在你的 C/C++ 源文件中，你需要包含由 javah 生成的头文件，以便能够实现本地方法。例如，如果你有一个名为 nativeMethod 的本地方法，你需要在你的源文件中这样包含头文件：

#include "com_example_MyClass.h"

JNIEXPORT jlong JNICALL Java_com_example_MyClass_nativeMethod(JNIEnv *env, jobject obj, jint param) {
    // 方法实现
}

6.2.2 头文件更新后的处理方法

如果 Java 类中的本地方法签名发生了变化，比如增加了新的本地方法或参数类型被修改，你需要重新运行 javah 来更新头文件。当头文件被更新后，你需要仔细检查源文件中对应的实现代码是否符合新的签名要求。

请注意，在 Java 8 引入的 JDK 8u20 版本之后，Oracle 移除了 javah 命令，推荐使用 javac -h 来生成头文件，因为 javac 现在能够直接生成包含正确路径的头文件。

javac -h <output_directory> com/example/MyClass.java

这样， javac 会根据 Java 源文件生成所需的头文件。

在后续的开发过程中，保持对头文件和源文件的一致性是至关重要的，以确保 Java 和本地代码之间的无缝交互。任何对头文件的更改都应立即反映在对应的源文件中，以避免编译错误或运行时错误。

7. build.gradle文件配置

在现代Android项目中，Gradle作为一种自动化构建工具，扮演着非常重要的角色。它不仅管理项目的构建过程，还能自动化执行各种任务，比如打包、依赖管理等。而 build.gradle 文件则是控制这些自动化任务的主要配置文件。接下来，我们将深入学习如何在 build.gradle 中配置NDK选项。

7.1 Gradle的基本介绍

7.1.1 Gradle在Android项目中的作用

Gradle是一个基于Apache Ant和Apache Maven概念的项目自动化构建工具，它使用基于Groovy的特定领域语言（DSL）来声明项目设置，比传统的XML更加简洁和灵活。在Android开发中，Gradle用于定义项目的结构、依赖关系、构建类型等。它还允许开发者根据不同的需求配置多个构建变体，如debug和release版本。

7.1.2 如何编写build.gradle文件

一个基础的 build.gradle 文件包含多个部分，如 plugins 、 android 、 dependencies 等。 android 部分用于配置项目特定的构建设置，如应用的最小SDK版本、目标SDK版本、编译SDK版本、签名配置等。 dependencies 部分则用于声明项目所依赖的库。

示例代码块展示了一个简单的 build.gradle 配置：

// 声明使用Android插件
plugins {
    id 'com.android.application'
}

// Android配置块
android {
    compileSdkVersion 30
    defaultConfig {
        applicationId "com.example.myapp"
        minSdkVersion 16
        targetSdkVersion 30
        versionCode 1
        versionName "1.0"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }
}

// 依赖配置块
dependencies {
    implementation 'androidx.appcompat:appcompat:1.2.0'
    implementation 'com.google.android.material:material:1.3.0'
    implementation 'androidx.constraintlayout:constraintlayout:2.0.4'
}

7.2 在build.gradle中配置NDK选项

7.2.1 添加NDK配置项

要在 build.gradle 中添加NDK配置项，开发者需要在 android 部分下的 defaultConfig 块中指定 externalNativeBuild 配置。这里可以通过NDK构建系统来编译本地代码，并将生成的库文件链接到应用程序。

示例代码块展示了如何添加NDK配置项：

android {
    compileSdkVersion 30
    defaultConfig {
        // 其他默认配置...

        // 指定NDK版本
        ndkVersion "21.4.7075529"

        // 配置外部原生构建系统，这里以ndk-build为例
        externalNativeBuild {
            ndkBuild {
                // ndk-build的路径或参数，通常配置为项目中ndk-build脚本的路径
                path "src/main/jni/Android.mk"
            }
        }
    }
    // 配置外部原生构建选项
    externalNativeBuild {
        ndkBuild {
            // 添加编译选项
            arguments "-j4"
        }
    }
}

7.2.2 配置ndkBuild或CMakeLists.txt

开发者可以选择使用 ndk-build 或 CMakeLists.txt 来编译本地代码。 ndkBuild 是较早的构建系统，而 CMake 提供了更多的灵活性和扩展性。

对于 CMake 配置的示例：

android {
    // 其他配置...

    externalNativeBuild {
        cmake {
            // CMakeLists.txt的路径
            path "src/main/cpp/CMakeLists.txt"
        }
    }
}

配置完成后，开发者可以在Android Studio中使用Gradle任务同步项目，确保所有的配置项被正确识别和应用。之后，就可以按照正常流程构建项目，并在需要时使用NDK提供的工具链来编译和链接本地代码。

在下一章节，我们将深入了解 CMakeLists.txt 的配置方法以及如何与JNI集成。

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

简介：本教程详细介绍了如何在Android Studio集成开发环境中进行JNI（Java Native Interface）编程。JNI允许Java代码与其他语言如C/C++编写的应用程序交互，在性能优化和硬件接口使用上发挥重要作用。教程内容包括设置NDK环境、创建Android项目、创建JNI源代码、定义JNI函数、生成JNI头文件、实现JNI函数、配置build.gradle文件、构建和运行、以及测试验证。通过本教程，读者将掌握JNI编程的完整流程，并能够将其应用于实际开发中。

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