前言

之前一直在用Eclipse 做开发，直到今年年初才将项目迁移到Google 推荐的AndroidStudio上面，毕竟这是一个趋势，可谁知道事情根本没有我想的那么简单，这期间遇到了N多坑，我想这些坑可能大家也有可能遇到，不在这里详细叙述。最终一个个问题的去解决，走完了这些坑，觉得还挺好用的，Eclipse 是一个吃内存的IDE，反正我每次打开，编写代码的时候就会卡，有时候还是死掉，已无力吐糟~~，AndroidStudio的界面更人性化，除此之外，还有更多的功能。所以决定把之前在正在eclipse上开发的一个使用NDK开发的android项目转移到AndroidStudio上，在2.2之前对C/C++ 支持不是很友好，没有语法提示，编译也不方便等问题，所以期待了的Android Studio 2.2 版本稳定版终于在前段发布，一直未来得及尝试，今天把整个过程记下来，希望能给你有所帮助。

原文链接请标明：
http://blog.csdn.net/u011974987/article/details/52888864
本文出自:【stromxu的博客】
欢迎访问我的博客，增加点儿人气~~Xuhao’s Blog
参考文献：https://developer.android.com/studio/projects/add-native-code.html#create-sources

---

正文

1. 下载开发工具和NDK（windows10 64位环境）

Android Studio 2.2 的NDK开发支持 CMake和ndk-build两种方式，默认的是CMake编译的，编译和调试需要下载安装以下组件：

• AndroidStudio 官网下载地址：

  Android Studio 2.2 （需要梯子）

  推荐一个国内的镜像网站：

  http://www.androiddevtools.cn （身为开发者都应该知道，O(∩_∩)O）

  下载最新版的 Android Studio 2.2 ：

  Download （点击下载）

• 下载NDK：android-ndk-r12b-windows-x86_64

• CMake： Android Studio 默认使用 CMake 编译原生库，如果你只打算用ndk-build来编译的话，你就不需要这个组件。

• LLDB： 使用它来调试本地代码。

注意：要在 Android Studio 中使用 CMake 或者 ndk-build，你需要使用 Android Studio 2.2 或更高的版本，同时需要配合使用 Android Plugin for Gradle 2.2.0 及以上的版本。

你可以使用 SDK Manager 来安装上述组件：

1. 已安装的软件包如有更新，其旁边的复选框中会显示短划线

2. 打开一个项目，从菜单栏中选择 Tools > Android > SDK Manager 。

3. 点击 SDK Tools 选项卡。

4. 勾选 LLDB，CMake 和 NDK 。如图一：

点击 Apply ，然后点击 OK 。

当安装完成后，点击 Finish ，然后点击 OK 。

---

创建支持Native Code新项目

创建一个支持 native code 的项目和创建普通的 Android studio 工程很像。但是有几点需要留意的地方：

1. 在 Configure your new project 选项中，勾选 Include C++ Support 选项。

2. 点击 Next，后面的流程和创建普通的 Android studio 工程一样。

3. 在 Customize C++ Support 选项卡中。你有下面几种方式来自定义你的项目：

   • C++ Standard ：点击下拉框，可以选择标准 C++，或者选择默认 CMake 设置的 Toolchain Default 选项。

   • Exceptions Support ：如果你想使用有关 C++ 异常处理的支持，就勾选它。勾选之后，Android Studio 会在 module 层的 build.gradle 文件中的 cppFlags 中添加 -fexcetions 标志。

   • Runtime Type Information Support ：如果你想支持 RTTI，那么就勾选它。勾选之后，Android Studio 会在 module 层的 build.gradle 文件中的 cppFlags 中添加 -frtti 标志。

4. 点击 “Finish”。

当 Android Studio 完成新项目创建后，打开 Project 面板，选择 Android 视图。Android Studio 会添加 cpp 和 External Build Files 文件夹。

1. cpp 文件夹存放你所有 native code 的地方，包括源码，头文件，预编译项目等。对于新项目，Android Studio 创建了一个 C++ 模板文件： native-lib.cpp ，并且将该文件放到了你的 app 模块的 src/main/cpp/ 目录下。这份模板代码提供了一个简答的 C++ 函数： stringFromJNI() ，该函数返回一个字符串：”Hello from C++”。

2. External Build Files 文件夹是存放 CMake 或 ndk-build 构建脚本的地方。有点类似于 build.gradle 文件告诉 Gradle 如何编译你的 APP 一样，CMake 和 ndk-build 也需要一个脚本来告知如何编译你的 native library。对于一个新的项目，Android Studio 创建了一个 CMake 脚本： CMakeLists.txt ，并且将其放到了你的 module 的根目录下。

---

编译运行示例 APP

当你点击 Run 按钮，Android Studio 会编译并启动一个 APP ，然后在 APP 中显示一段文字”Hello from C++”。

从编译到运行示例 APP 的流程简单归纳如下：

1. Gradle 调用外部构建脚本，也就是 CMakeLists.txt 。

2. CMake 会根据构建脚本的指令去编译一个 C++ 源文件，也就是 native-lib.cpp ，并将编译后的产物扔进共享对象库中，并将其命名为 libnative-lib.so ，然后 Gradle 将其打包到 APK 中。

3. 在运行期间，APP 的 MainActivity 会调用 System.loadLibrary() 方法，加载 native library。而这个库的原生函数， stringFromJNI() ，就可以为 APP 所用了。

4. MainActivity.onCreate() 方法会调用 stringFromJNI() ，然后返回 “Hello from C++”，并更新 TextView 的显示。

注意： Instant Run 并不兼容使用了 native code 的项目。Android Studio 会自动禁止 Instant
Run 功能。

如果你想验证一下 Gradle 是否将 native library 在APK中是否存在，你可以使用 APK Analyzer:

1. 选择 Build > Analyze APK 。
2. 从 app/build/outputs/apk/ 路径中选择 APK，并点击 OK 。
3. 如下图，在 APK Analyzer 窗口中，选择 lib/<ABI>/ ，你就可以看见 libnative-lib.so 。

---

将 C/C++ 代码添加到现有的项目中

如果你想将 native code 添加到一个现有的项目中，请按照下面的步骤：

1. 创建新的 native source 文件，并将其添加到你的 Android Studio 项目中。如果你已经有了 native code，也可以跳过这一步。

2. 创建一个 CMake 构建脚本。如果你已经有了一个 CMakeLists.txt 构建脚本，或者你想使用 ndk-build 然后有一个 Android.mk 构建脚本，也可以跳过这一步。

3. 将你的 native library 与 Gradle 关联起来。Gradle 使用构建脚本将源码导入到你的 Android Studio 项目中，并且将你的 native library （也就是 .so 文件）打包到 APK 中。

一旦你配置好了你的项目，你就可以在 Java 代码中，使用 JNI 框架开调用原生函数（native functions）。只需要点击 Run 按钮，就可以编译运行你的 APP 了。

---

创建新的 native source 文件

请按照下面的方法来创建一个 cpp/ 文件夹和源文件（native source files）：

1. 打开IDE左边的 Project 面板，选择 Project 视图。

2. 找到你项目的 module > src 目录，右键点击 main 文件夹，选择 New > Directory 。

3. 输入文件夹的名字（比如 cpp），然后点击 OK 。

4. 右键点击刚才创建好的文件夹，选择 New > C/C++ Source File 。

5. 输入文件名，比如 native-lib 。

6. 在 Type 菜单下拉选项中，选择源文件的扩展后缀名，比如 .cpp 。

7. 如果你也想创建一个头文件，点击 Create an associated header 选项框。

8. 点击 OK 。

---

创建 CMake 构建脚本

如果没有一个 CMake 构建脚本，你需要自己手动创建一个，并添加一些合适的 CMake 命令。CMake 构建脚本是一个空白的文本文档（后缀为 .txt 的文件），名字必须为 CMakeLists.txt 。

注意：如果你的项目使用了 ndk-build，你就不需要创建 CMake 构建脚本，只需要提供一个路径链，将你的 Android.mk
文件链接到 Gradle 中即可。

将一个空白的文本文档变成一个 CMake 构建脚本，你需要这么做：

1. 打开 IDE 左边的 Project 面板，选择 Project 视图。

2. 在你的 module 根目录下，右键，选择 New > File 。

3. 输入 “CMakeLists.txt” 作为文件名，并点击 OK 。

现在，你可以添加 CMake 命令来配置你的构建脚本了。为了让 CMake 将源代码（native source code）编译成 native library。需要在编译文件中添加 cmake_minimum_required() 和 add_library() 命令：

# 设置建立你的本地库所需的CMake的最低版本。
# 这为了确保某些功能在你构建的时候是可用的。

cmake_minimum_required(VERSION 3.4.1)

# 指定库名
# 并提供源代码的相对路径. 
# 你可以通过add.library()命令定义多个库,CMake会去构建他们，
# 当你构建App 的时候，Gradle 会自动把库打包到你的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 )

当你使用 add_library() ，将一个源文件（source file）或库添加到你的 CMake 构建脚本，同步你的项目，然后你会发现 Android studio 将关联的头文件也显示了处理。然而，为了让 CMake 在编译时期能定位到你的头文件，你需要在 CMake 构建脚本中添加 include_directories() 命令，并指定头文件路径：

add_library(...)

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

CMake的使用命名库的文件的约定下面的形式：

lib*library-name*.so

例如 ，如果你在构建脚本中，将 library 命名为 “native-lib”，那么 CMake 会创建叫 libnative-lib.so 的文件。但是，当你将 library 加载到 Java 代码中的时候， 你需要使用在 CMake 中指定的名称：

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

注意：如果你将 CMake 脚本里面的 library 重命名了，或者移除了。你需要清理一下你的工程。在 IDE 的菜单栏中选择 Build > Clean Project 。

Android Studio 会在 Project 面板中的 cpp 文件夹中自动添加源文件和头文件。你可以多次使用 add_library() 命令，来添加额外的 library。

添加 NDK APIs

Android NDK 提供了一些有用的 native APIs。将 NDK librarys 添加到 CMakeLists.txt 脚本文件中，就可以使用这些 API 了。

预编译的 NDK librarys 已经存在在 Android 平台中了，所以你不需要编译它们，或者是将其打包到你的 APK 中。因为这些 NDK librarys 已经是 CMake 搜索路径的一部分，你甚至不需要提供你本地安装的 NDK 路径。你只需要向 CMake 提供你想使用的 library 名字。

将 find_library() 命令添加到你的 CMake 构建脚本中，这样就可以定位 NDK library 的位置，并将其位置存储在一个变量之中。你可以在构建脚本的其他地方使用这个变量，来代指 NDK library。下面的示例代码将 Android-specific log support library 的位置存储到变量 log-lib 中：

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 )

NDK 同样也包含一些只包含源码的 library，这些就需要你去编译，然后链接到你的本地库（native library）。你可以在 CMake 构建脚本中使用 add_library() 命令将源码编译进本地库。这时就需要提供你的本地 NDK 安装路径，通常将该路径保存在 ANDROID_NDK 变量中，这样 Android Studio 可以自动为你定义。

下面的命令告诉 CMake 去构建 android_native_app_glue.c ，这个命令可以管理 NativeActivity 的生命周期以及点击输入，并将其导入静态库中，然后将其链接至 native-lib ：

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} )

添加其他的预编译库

添加预编译库和添加本地库（native library）类似。由于预编译库是已经构建好的，你想就要使用 IMPORTED 标志去告诉 CMake ，你只需要将其导入到你的项目中即可：

add_library( imported-lib
SHARED
IMPORTED )
然后你需要使用 set_target_properties() 命令去指定库的路径，就像下面的代码那样。

一些库会根据不同的 CPU 使用不同的包，或者是 Application Binary Interfaces(ABI) ，并且将他们归类到不同的目录中。这样做的好处是，可以充分发挥特定的 CPU 架构。你可以使用 ANDROID_ABI 路径变量，将多个 ABI 版本的库添加到你的 CMake 构建脚本中。这个变量使用了一些 NDK 默认支持的 ABI，以及一些需要手动配置到 Gradle 的 ABI，比如：

add_library(...)
set_target_properties( ＃指定目标库。
                       imported-lib

                       ＃指定要定义的参数。
                       PROPERTIES IMPORTED_LOCATION

                       ＃提供的路径，你要导入的库。
                       imported-lib/src/${ANDROID_ABI}/libimported-lib.so )

为了让 CMake 在编译时期能找到你的头文件，你需要使用 include_directories() 命令，并且将你的头文件地址传进去：

include_directories( imported-lib/include/ )

在 CMake 构建脚本中使用 target_link_libraries() 命令，将预构建库与你本地库相关联：

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

当你构建你的 APP 的时候，Gradle 会自动将导入的库打包到你的 APK 中。你可以使用 APK Analyzer 来检查。有关CMake的命令的详细信息，请参阅CMake的文档。

---

关联本地库与 Gradle

为了将本地库与 Gradle 相关联，你需要在 CMake 或 ndk-build 构建脚本中提供一个路径地址。当你构建你的 APP 时，Gradle 会将 CMake 或 ndk-build 作为一个依赖运行，然后将共享库（.so 文件）打包到你的 APK 中。Gradle 同样使用构建脚本来识别哪些文件需要导入到 Android Studio 项目，你可以从 Project 窗口面板中看到相应的文件。如果你还没有一个为 native sources 准备的构建脚本，你需要先创建一个CMake脚本，然后在继续。

一旦你使用Gradle关联了本地项目，AndroidStudio会在窗口更新项目的C/C++源文件和本地库，和你外部构建的脚本文件。

注意： 当你改变Gradle配置的时候，请确保在工具栏中点击Sync Project

使用 Android Studio 图形化界面

你可以使用 Android Studio 的图形化界面来将 Gradle 与外部 CMake 或者 ndk-build 项目关联起来。

1. 打开 IDE 左边的 Project 面板，选择 Android 。

2. 右键点击你想链接本地库的 module，比如 app module，然后从菜单中选择 Link C++ Project with Gradle 。你应该能看见一个和下面图片中的对话框。

3. 在下拉菜单中，选择 CMake 或者 ndk-build 。
   a. 如果你选择 CMake ，需要在 Project Path 中指定 CMakeLists.txt 脚本文件的路径。
   b. 如果你选择 ndk-build ，你需要在 Project Path 中指定 Android.mk 脚本文件的路径。

4. 点击 OK。

配置 Gradle

如果要手动将 Gradle 与你的本地库相关联，你需要在 module 层级的 build.gradle 文件中添加 externalNativeBuild {} 代码块，并且在该代码块中配置 cmake {} 或 ndkBuild {} ：

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"
    }
  }
}

可选配置

你可以在你的 module 层级的 build.gradle 文件中的 defaultConfig {} 代码块中，添加 externalNativeBuild {} 代码块，为 CMake 或 ndk-build 配置一些额外参数。当然，你也可以在你的构建配置中的其他每一个生产渠道重写这些属性。

比如，如果你的 CMake 或者 ndk-build 项目中定义了多个本地库，你想在某个生产渠道使用这些本地库中的几个，你就可以使用 targets 属性来构建和打包。下面的代码展示了一些你可能会用到的属性：

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 "-DCMAKE_VERBOSE_MAKEFILE=TRUE"

        // 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" } } } } // You use this block to link Gradle to your CMake or ndk-build script. externalNativeBuild { cmake {...} // or ndkBuild {...} } } ----------

指定 ABI

默认的情况下，Gradle 会将你的本地库构建成 .so 文件，然后将其打包到你的 APK 中。如果你想 Gradle 构建并打包某个特定的 ABI 。你可以在你的 module 层级的 build.gradle 文件中使用 ndk.abiFilters 标签来指定他们：

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 {...}
  //
}

大多数情况，你只需要在 ndk {} 代码块中指定 abiFilters 就可以了；如上代码。它会告诉Gradle来构建编译不同的平台，但是，如果你想控制 Gradle 构建什么，独立打包到你的apk中，那就在defaultConfig.externalNativeBuild.cmake {} 代码块或 defaultConfig.externalNativeBuild.ndkBuild {} 代码块中，配置其他的 abiFilters 标签。Gradle 会构建那些 ABI 配置，但是只会将 defaultConfig.ndk {} 代码块中指定的配置打包到 apk 中。

ndk {
    moduleName "libHelloJni"
}