AndroidStudio用Cmake方式编译NDK代码（cmake配置.a库）

男娘i 2022-01-13 09:29 635阅读 0赞

[2019独角兽企业重金招聘Python工程师标准>>> ][2019_Python_] ![hot3.png][]

# [AndroidStudio用Cmake方式编译NDK代码（cmake配置.a库）][AndroidStudio_Cmake_NDK_cmake_.a] #

**1.cmake是什么？**

CMake是一个跨平台的安装（[编译][Link 1]）工具，可以用简单的语句来描述所有平台的安装(编译过程)。他能够输出各种各样的makefile或者project文件，能测试[编译器][Link 2]所支持的C++特性,类似UNIX下的automake。

谷歌从AndroidStudio2.2以上就添加了Cmake方式来编译NDK代码，并从NDK例子看出，默认编译的方式就是cmake方式。

** **

**2.谷歌官方的用cmake方式编译NDK的教程**

谷歌从AndroidStudio2.2以上就添加了Cmake方式来编译NDK代码，并从NDK例子看出，默认编译的方式就是cmake方式。

如果您希望向现有项目添加原生代码，请执行以下步骤：

1.  [创建新的原生源文件][Link 3]并将其添加到您的 Android Studio 项目中。
    
     *  如果您已经拥有原生代码或想要导入预构建的原生库，则可以跳过此步骤。
2.  [创建 CMake 构建脚本][CMake]，将您的原生源代码构建到库中。如果导入和关联预构建库或平台库，您也需要此构建脚本。
    
     *  如果您的现有原生库已经拥有 `CMakeLists.txt` 构建脚本或者使用 ndk-build 并包含 [`Android.mk`][Android.mk] 构建脚本，则可以跳过此步骤。
3.  提供一个指向您的 CMake 或 ndk-build 脚本文件的路径，[将 Gradle 关联到您的原生库][Gradle]。Gradle 使用构建脚本将源代码导入您的 Android Studio 项目并将原生库（SO 文件）封装到 APK 中。

配置完项目后，您可以使用 [JNI 框架][JNI]从 Java 代码中访问您的原生函数。要构建和运行应用，只需点击 **Run** 。Gradle 会以依赖项的形式添加您的外部原生构建流程，用于编译、构建原生库并将其随 APK 一起封装。

### 创建新的原生源文件 ###

要在应用模块的主源代码集中创建一个包含新建原生源文件的 `cpp/` 目录，请按以下步骤操作：

1.  从 IDE 的左侧打开 **Project** 窗格并从下拉菜单中选择 **Project** 视图。
2.  导航到**您的模块 > src**，右键点击 **main** 目录，然后选择 **New > Directory**。
3.  为目录输入一个名称（例如 `cpp`）并点击 **OK**。
4.  右键点击您刚刚创建的目录，然后选择 **New > C/C++ Source File**。
5.  为您的源文件输入一个名称，例如 `native-lib`。
6.  从 **Type** 下拉菜单中，为您的源文件选择文件扩展名，例如 `.cpp`。
    
     *  点击 **Edit File Types** ，您可以向下拉菜单中添加其他文件类型，例如 `.cxx` 或 `.hxx`。在弹出的 **C/C++** 对话框中，从 **Source Extension** 和 **Header Extension** 下拉菜单中选择另一个文件扩展名，然后点击 **OK**。
7.  如果您还希望创建一个标头文件，请选中 **Create an associated header** 复选框。
8.  点击 **OK**。

### 创建 CMake 构建脚本 ###

如果您的原生源文件还没有 CMake 构建脚本，则您需要自行创建一个并包含适当的 CMake 命令。CMake 构建脚本是一个纯文本文件，您必须将其命名为 `CMakeLists.txt`。本部分介绍了您应包含到构建脚本中的一些基本命令，用于在创建原生库时指示 CMake 应使用哪些源文件。

**注**：如果您的项目使用 ndk-build，则不需要创建 CMake 构建脚本。提供一个指向您的 [`Android.mk`][Android.mk] 文件的路径，[将 Gradle 关联到您的原生库][Gradle]。

要创建一个可以用作 CMake 构建脚本的纯文本文件，请按以下步骤操作：

1.  从 IDE 的左侧打开 **Project** 窗格并从下拉菜单中选择 **Project** 视图。
2.  右键点击**您的模块**的根目录并选择 **New > File**。
    
    **注**：您可以在所需的任意位置创建构建脚本。不过，在配置构建脚本时，原生源文件和库的路径将与构建脚本的位置相关。
3.  输入“CMakeLists.txt”作为文件名并点击 **OK**。

现在，您可以添加 CMake 命令，对您的构建脚本进行配置。要指示 CMake 从原生源代码创建一个原生库，请将 [`cmake_minimum_required()`][cmake_minimum_required] 和 [`add_library()`][add_library] 命令添加到您的构建脚本中：

![复制代码][copycode.gif]

# Sets the minimum version of CMake required to build your native library.
    # This ensures that a certain set of CMake features is available to
    # your build.
    
    cmake_minimum_required(VERSION 3.4.1)
    
    # Specifies a library name, specifies whether the library is STATIC or
    # SHARED, and provides relative paths to the source code. You can
    # define multiple libraries by adding multiple add.library() commands,
    # and CMake builds them for you. When you build your app, Gradle
    # automatically packages shared libraries with your APK.
    
    add_library( # Specifies the name of the library.
                 native-lib
    
                 # Sets the library as a shared library.
                 SHARED
    
                 # Provides a relative path to your source file(s).
                 src/main/cpp/native-lib.cpp )

![复制代码][copycode.gif]

使用 `add_library()` 向您的 CMake 构建脚本添加源文件或库时，Android Studio 还会在您同步项目后在 **Project** 视图下显示关联的标头文件。不过，为了确保 CMake 可以在编译时定位您的标头文件，您需要将 [`include_directories()`][include_directories] 命令添加到 CMake 构建脚本中并指定标头的路径：

add_library(...)
    
    # Specifies a path to native header files.
    include_directories(src/main/cpp/include/)

CMake 使用以下规范来为库文件命名：

> `lib库名称.so`

例如，如果您在构建脚本中指定“native-lib”作为共享库的名称，CMake 将创建一个名称为 `libnative-lib.so` 的文件。不过，在 Java 代码中加载此库时，请使用您在 CMake 构建脚本中指定的名称：

static {
        System.loadLibrary(“native-lib”);
    }

**注**：如果您在 CMake 构建脚本中重命名或移除某个库，您需要先清理项目，Gradle 随后才会应用更改或者从 APK 中移除旧版本的库。要清理项目，请从菜单栏中选择 **Build > Clean Project**。

Android Studio 会自动将源文件和标头添加到 **Project** 窗格的 **cpp** 组中。使用多个 `add_library()` 命令，您可以为 CMake 定义要从其他源文件构建的更多库。

#### 添加 NDK API ####

Android NDK 提供了一套实用的原生 API 和库。通过将 [NDK 库][NDK]包含到项目的 `CMakeLists.txt` 脚本文件中，您可以使用这些 API 中的任意一种。

预构建的 NDK 库已经存在于 Android 平台上，因此，您无需再构建或将其封装到 APK 中。由于 NDK 库已经是 CMake 搜索路径的一部分，您甚至不需要在您的本地 NDK 安装中指定库的位置 - 只需要向 CMake 提供您希望使用的库的名称，并将其关联到您自己的原生库。

将 [`find_library()`][find_library] 命令添加到您的 CMake 构建脚本中以定位 NDK 库，并将其路径存储为一个变量。您可以使用此变量在构建脚本的其他部分引用 NDK 库。以下示例可以定位 [Android 特定的日志支持库][Android]并将其路径存储在 `log-lib` 中：

![复制代码][copycode.gif]

find_library( # Defines the name of the path variable that stores the
                  # location of the NDK library.
                  log-lib
    
                  # Specifies the name of the NDK library that
                  # CMake needs to locate.
                  log )

![复制代码][copycode.gif]

为了确保您的原生库可以在 `log` 库中调用函数，您需要使用 CMake 构建脚本中的 [`target_link_libraries()`][target_link_libraries] 命令关联库：

![复制代码][copycode.gif]

find_library(...)
    
    # Links your native library against one or more other native libraries.
    target_link_libraries( # Specifies the target library.
                           native-lib
    
                           # Links the log library to the target library.
                           ${log-lib} )

![复制代码][copycode.gif]

NDK 还以源代码的形式包含一些库，您在构建和关联到您的原生库时需要使用这些代码。您可以使用 CMake 构建脚本中的 `add_library()` 命令，将源代码编译到原生库中。要提供本地 NDK 库的路径，您可以使用 `ANDROID_NDK` 路径变量，Android Studio 会自动为您定义此变量。

以下命令可以指示 CMake 构建 `android_native_app_glue.c`，后者会将 [`NativeActivity`][NativeActivity] 生命周期事件和触摸输入置于静态库中并将静态库关联到 `native-lib`：

![复制代码][copycode.gif]

add_library( app-glue
                 STATIC
                 ${ANDROID_NDK}/sources/android/native_app_glue/android_native_app_glue.c )
    
    # You need to link static libraries against your shared native library.
    target_link_libraries( native-lib app-glue ${log-lib} )

![复制代码][copycode.gif]

#### 添加其他预构建库 ####

添加预构建库与为 CMake 指定要构建的另一个原生库类似。不过，由于库已经预先构建，您需要使用 [`IMPORTED`][IMPORTED] 标志告知 CMake 您只希望将库导入到项目中：

add_library( imported-lib
                 SHARED
                 IMPORTED )

然后，您需要使用 [`set_target_properties()`][set_target_properties] 命令指定库的路径，如下所示。

某些库为特定的 CPU 架构（或[应用二进制接口 (ABI)][_ABI]）提供了单独的软件包，并将其组织到单独的目录中。此方法既有助于库充分利用特定的 CPU 架构，又能让您仅使用所需的库版本。要向 CMake 构建脚本中添加库的多个 ABI 版本，而不必为库的每个版本编写多个命令，您可以使用 `ANDROID_ABI` 路径变量。此变量使用 [NDK 支持的一组默认 ABI][NDK _ ABI]，或者[您手动配置 Gradle][Gradle 1] 而让其使用的一组经过筛选的 ABI。例如：

![复制代码][copycode.gif]

add_library(...)
    set_target_properties( # Specifies the target library.
                           imported-lib
    
                           # Specifies the parameter you want to define.
                           PROPERTIES IMPORTED_LOCATION
    
                           # Provides the path to the library you want to import.
                           imported-lib/src/${ANDROID_ABI}/libimported-lib.so )

![复制代码][copycode.gif]

为了确保 CMake 可以在编译时定位您的标头文件，您需要使用 `include_directories()` 命令，并包含标头文件的路径：

include_directories( imported-lib/include/ )

**注**：如果您希望封装一个并不是构建时依赖项的预构建库（例如在添加属于 `imported-lib` 依赖项的预构建库时），则不需要执行以下说明来关联库。

要将预构建库关联到您自己的原生库，请将其添加到 CMake 构建脚本的 `target_link_libraries()` 命令中：

target_link_libraries( native-lib imported-lib app-glue ${log-lib} )

在您构建应用时，Gradle 会自动将导入的库封装到 APK 中。您可以使用 [APK 分析器][APK]验证 Gradle 将哪些库封装到您的 APK 中。如需了解有关 CMake 命令的详细信息，请参阅 [CMake 文档][CMake 1]。

**导入.a静态库**

自 android studio 2.2 +后就集成了ndk开发， 自带cmake 编译器.  编写ndk时候，配置很简单。再也不需要用android.mk配置文件。

新建一个带ndk开发项目的结构是这样的，

![20170705141836235][]

言归正传，那么要添加第三方的xx.a链接库呢？

通常我们把第三方提供的h文件夹，放在cpp的include里面。这是规范，不是必须。而xxx.a库放在**src/main/jniLibs/armeabi**目录下。

本文章以添加libjsoncpp.a连接库做例子

首先在cpp目录下建立一个include文件夹，把jsoncpp官方提供的头文件文件夹拷贝到include里面(我这个项目有3个链接库，jsoncpp, curl , openssl，另外2个仅做参考作用，与其无关）

![20170705142718194][]

![20170705143307606][]

第二步， 在app的src目录的main下，建立一个文件夹，jniLibs,然后在jniLibs里面再建立一个armeabi文件夹。

然后把libjsoncpp.a链接库拷贝进去。

![20170705152912036][]

第三步， 动态库与头文件拷贝进去时候，是需要告诉编译器做关联的。在app目录的src文件夹下有个CMakeLists.txt文件，我们通过它编写配置信息。

将**jsoncpp头文件所在目录**告诉编译，在里面添加

1.  include\_directories( src/main/cpp/include/jsoncpp)

如果有多个链接库，那么可以这样  
例如有三个链接库，jsoncpp， currl ， openssl.

1.  include\_directories( src/main/cpp/include/jsoncpp  
2.                       src/main/cpp/include/curl  
3.                       src/main/cpp/include/openssl  
4.                       )

** **

然后告诉编译器，libjsoncppp.a在哪个目录下，并指定链接库的名称

接着添加

然后修改target\_link\_libraries,加多一行jsoncpp

1.  target\_link\_libraries(native-lib  
2.                        jsoncpp  
3.                        $\{log-lib\})

**如果有多个，那么可以多次添加。如**

1.  \#添加json库  
2.  add\_library(jsoncpp STATIC IMPORTED)  
3.  set\_target\_properties(jsoncpp  
4.    PROPERTIES IMPORTED\_LOCATION  
5.    $\{CMAKE\_SOURCE\_DIR\}/src/main/jniLibs/$\{ANDROID\_ABI\}/libjsoncpp.a)  
6.    
7.  \#添加curl网络请求  
8.  add\_library(curl STATIC IMPORTED)  
9.  set\_target\_properties(curl  
10.   PROPERTIES IMPORTED\_LOCATION  
11.   $\{CMAKE\_SOURCE\_DIR\}/src/main/jniLibs/$\{ANDROID\_ABI\}/libcurl.a)  
12.   
13. \#添加加密工具(md5, base64, des, aes , asa) part-1  
14. add\_library(crypto STATIC IMPORTED)  
15. set\_target\_properties(crypto  
16.   PROPERTIES IMPORTED\_LOCATION  
17.   $\{CMAKE\_SOURCE\_DIR\}/src/main/jniLibs/$\{ANDROID\_ABI\}/libcrypto.a)  
18.   
19. \#添加加密工具(md5, base64, des, aes , asa) des加密 part-2  
20. add\_library(ssl STATIC IMPORTED)  
21. set\_target\_properties(ssl  
22.   PROPERTIES IMPORTED\_LOCATION  
23.   $\{CMAKE\_SOURCE\_DIR\}/src/main/jniLibs/$\{ANDROID\_ABI\}/libssl.a)

1.  target\_link\_libraries(native-lib  
2.                        jsoncpp  
3.                        curl  
4.                        crypto  
5.                        ssl  
6.                        $\{log-lib\})

然后gradle编译就可以使用了。是不是很简单？

### 将 Gradle 关联到您的原生库 ###

要将 Gradle 关联到您的原生库，您需要提供一个指向 CMake 或 ndk-build 脚本文件的路径。在您构建应用时，Gradle 会以依赖项的形式运行 CMake 或 ndk-build，并将共享的库封装到您的 APK 中。Gradle 还使用构建脚本来了解要将哪些文件添加到您的 Android Studio 项目中，以便您可以从 **Project** 窗口访问这些文件。如果您的原生源文件没有构建脚本，则需要先[创建 CMake 构建脚本][CMake]，然后再继续。

将 Gradle 关联到原生项目后，Android Studio 会更新 **Project** 窗格以在 **cpp** 组中显示您的源文件和原生库，在 **External Build Files** 组中显示您的外部构建脚本。

**注**：更改 Gradle 配置时，请确保通过点击工具栏中的 **Sync Project**  应用更改。此外，如果在将 CMake 或 ndk-build 脚本文件关联到 Gradle 后再对其进行更改，您应当从菜单栏中选择 **Build > Refresh Linked C++ Projects**，将 Android Studio 与您的更改同步。

#### 使用 Android Studio UI ####

您可以使用 Android Studio UI 将 Gradle 关联到外部 CMake 或 ndk-build 项目：

1.  从 IDE 左侧打开 **Project** 窗格并选择 **Android** 视图。
2.  右键点击您想要关联到原生库的模块（例如 **app** 模块），并从菜单中选择 **Link C++ Project with Gradle**。您应看到一个如图 4 所示的对话框。
3.  从下拉菜单中，选择 **CMake** 或 **ndk-build**。
    
    1.  如果您选择 **CMake**，请使用 **Project Path** 旁的字段为您的外部 CMake 项目指定 `CMakeLists.txt` 脚本文件。
    2.  如果您选择 **ndk-build**，请使用 **Project Path** 旁的字段为您的外部 ndk-build 项目指定 [`Android.mk`][Android.mk] 脚本文件。如果 [`Application.mk`][Application.mk] 文件与您的 `Android.mk` 文件位于相同目录下，Android Studio 也会包含此文件。
    
    **图 4.**使用 Android Studio 对话框关联外部 C++ 项目。
4.  点击 **OK**。

#### 手动配置 Gradle ####

要手动配置 Gradle 以关联到您的原生库，您需要将 `externalNativeBuild {}` 块添加到模块级 `build.gradle` 文件中，并使用 `cmake {}` 或 `ndkBuild {}`对其进行配置：

![复制代码][copycode.gif]

android {
      ...
      defaultConfig {...}
      buildTypes {...}
    
      // Encapsulates your external native build configurations.
      externalNativeBuild {
    
        // Encapsulates your CMake build configurations.
        cmake {
    
          // Provides a relative path to your CMake build script.
          path "CMakeLists.txt"
        }
      }
    }

![复制代码][copycode.gif]

**注**：如果您想要将 Gradle 关联到现有 ndk-build 项目，请使用 `ndkBuild {}` 块而不是 `cmake {}`，并提供 [`Android.mk`][Android.mk] 文件的相对路径。如果 [`Application.mk`][Application.mk] 文件与您的 [`Android.mk`][Android.mk] 文件位于相同目录下，Gradle 也会包含此文件。

指定可选配置

您可以在模块级 `build.gradle` 文件的 `defaultConfig {}` 块中配置另一个 `externalNativeBuild {}` 块，为 CMake 或 ndk-build 指定可选参数和标志。与 `defaultConfig {}` 块中的其他属性类似，您也可以在构建配置中为每个产品风味重写这些属性。

例如，如果您的 CMake 或 ndk-build 项目定义多个原生库，您可以使用 `targets` 属性仅为给定产品风味构建和封装这些库中的一部分。以下代码示例说明了您可以配置的部分属性：

![复制代码][copycode.gif]

android {
      ...
      defaultConfig {
        ...
        // This block is different from the one you use to link Gradle
        // to your CMake or ndk-build script.
        externalNativeBuild {
    
          // For ndk-build, instead use ndkBuild {}
          cmake {
    
            // Passes optional arguments to CMake.
            arguments "-DANDROID_ARM_NEON=TRUE", "-DANDROID_TOOLCHAIN=clang"
    
            // Sets optional flags for the C compiler.
            cFlags "-D_EXAMPLE_C_FLAG1", "-D_EXAMPLE_C_FLAG2"
    
            // Sets a flag to enable format macro constants for the C++ compiler.
            cppFlags "-D__STDC_FORMAT_MACROS"
          }
        }
      }
    
      buildTypes {...}
    
      productFlavors {
        ...
        demo {
          ...
          externalNativeBuild {
            cmake {
              ...
              // Specifies which native libraries to build and package for this
              // product flavor. If you don't configure this property, Gradle
              // builds and packages all shared object libraries that you define
              // in your CMake or ndk-build project.
              targets "native-lib-demo"
            }
          }
        }
    
        paid {
          ...
          externalNativeBuild {
            cmake {
              ...
              targets "native-lib-paid"
            }
          }
        }
      }
    
      // Use this block to link Gradle to your CMake or ndk-build script.
      externalNativeBuild {
        cmake {...}
        // or ndkBuild {...}
      }
    }

![复制代码][copycode.gif]

要详细了解配置产品风味和构建变体，请参阅[配置构建变体][Link 4]。如需了解您可以使用 `arguments` 属性为 CMake 配置的变量列表，请参阅[使用 CMake 变量][CMake 2]。

指定 ABI

默认情况下，Gradle 会针对 [NDK 支持的 ABI][NDK _ ABI] 将您的原生库构建到单独的 `.so` 文件中，并将其全部封装到您的 APK 中。如果您希望 Gradle 仅构建和封装原生库的特定 ABI 配置，您可以在模块级 `build.gradle` 文件中使用 `ndk.abiFilters` 标志指定这些配置，如下所示：

![复制代码][copycode.gif]

android {
      ...
      defaultConfig {
        ...
        externalNativeBuild {
          cmake {...}
          // or ndkBuild {...}
        }
    
        ndk {
          // Specifies the ABI configurations of your native
          // libraries Gradle should build and package with your APK.
          abiFilters 'x86', 'x86_64', 'armeabi', 'armeabi-v7a',
                       'arm64-v8a'
        }
      }
      buildTypes {...}
      externalNativeBuild {...}
    }

![复制代码][copycode.gif]

在大多数情况下，您只需要在 `ndk {}` 块中指定 `abiFilters`（如上所示），因为它会指示 Gradle 构建和封装原生库的这些版本。不过，如果您希望控制 Gradle 应当构建的配置，并独立于您希望其封装到 APK 中的配置，请在 `defaultConfig.externalNativeBuild.cmake {}` 块（或 `defaultConfig.externalNativeBuild.ndkBuild {}` 块中）配置另一个 `abiFilters` 标志。Gradle 会构建这些 ABI 配置，不过仅会封装您在 `defaultConfig.ndk{}` 块中指定的配置。

为了进一步降低 APK 的大小，请考虑[配置 ABI APK 拆分][ABI APK]，而不是创建一个包含原生库所有版本的大型 APK，Gradle 会为您想要支持的每个 ABI 创建单独的 APK，并且仅封装每个 ABI 需要的文件。如果您配置 ABI 拆分，但没有像上面的代码示例一样指定 `abiFilters` 标志，Gradle 会构建原生库的所有受支持 ABI 版本，不过仅会封装您在 ABI 拆分配置中指定的版本。为了避免构建您不想要的原生库版本，请为 `abiFilters` 标志和 ABI 拆分配置提供相同的 ABI 列表。

谷歌从AndroidStudio2.2以上就添加了Cmake方式来编译NDK代码，并从NDK例子看出，默认编译的方式就是cmake方式。

转载于:https://my.oschina.net/u/4000302/blog/3058592

[2019_Python_]: https://my.oschina.net/u/2663968/blog/3061697
[hot3.png]: /images/20220113/02b823e362be47278666553213b3e835.png
[AndroidStudio_Cmake_NDK_cmake_.a]: https://www.cnblogs.com/fnlingnzb-learner/p/7593488.html
[Link 1]: http://baike.baidu.com/view/69568.htm
[Link 2]: http://baike.baidu.com/view/487018.htm
[Link 3]: https://developer.android.google.cn/studio/projects/add-native-code.html#create-sources
[CMake]: https://developer.android.google.cn/studio/projects/add-native-code.html#create-cmake-script
[Android.mk]: https://developer.android.google.cn/ndk/guides/android_mk.html
[Gradle]: https://developer.android.google.cn/studio/projects/add-native-code.html#link-gradle
[JNI]: http://docs.oracle.com/javase/7/docs/technotes/guides/jni/spec/jniTOC.html
[cmake_minimum_required]: https://cmake.org/cmake/help/latest/command/cmake_minimum_required.html
[add_library]: https://cmake.org/cmake/help/latest/command/add_library.html
[copycode.gif]: /images/20220113/c5360ec2638146f28d9d554ff0672d11.png
[include_directories]: https://cmake.org/cmake/help/latest/command/include_directories.html
[NDK]: https://developer.android.google.cn/ndk/guides/stable_apis.html
[find_library]: https://cmake.org/cmake/help/latest/command/find_library.html
[Android]: https://developer.android.google.cn/ndk/guides/stable_apis.html#a3
[target_link_libraries]: https://cmake.org/cmake/help/latest/command/target_link_libraries.html
[NativeActivity]: https://developer.android.google.cn/reference/android/app/NativeActivity.html
[IMPORTED]: https://cmake.org/cmake/help/latest/prop_tgt/IMPORTED.html#prop_tgt:IMPORTED
[set_target_properties]: https://cmake.org/cmake/help/latest/command/set_target_properties.html
[_ABI]: https://developer.android.google.cn/ndk/guides/abis.html
[NDK _ ABI]: https://developer.android.google.cn/ndk/guides/abis.html#sa
[Gradle 1]: https://developer.android.google.cn/studio/projects/add-native-code.html#specify-abi
[APK]: https://developer.android.google.cn/studio/build/apk-analyzer.html
[CMake 1]: https://cmake.org/cmake/help/latest/manual/cmake-commands.7.html
[20170705141836235]: /images/20220113/9a5f3cdad5fb4271851d85b5d2a0dca8.png
[20170705142718194]: /images/20220113/5740850a5ac04b1688dd882a07b90617.png
[20170705143307606]: /images/20220113/2e7cce2d193e4e5a88d2f7d451bf3304.png
[20170705152912036]: /images/20220113/ece3d407df154e2181c74be16eadf1eb.png
[Application.mk]: https://developer.android.google.cn/ndk/guides/application_mk.html
[Link 4]: https://developer.android.google.cn/studio/build/build-variants.html
[CMake 2]: https://developer.android.google.cn/ndk/guides/cmake.html#variables
[ABI APK]: https://developer.android.google.cn/studio/build/configure-apk-splits.html#configure-abi-split