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

1.cmake是什么？

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

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

 

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

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

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

  1. 创建新的原生源文件并将其添加到您的 Android Studio 项目中。

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

配置完项目后，您可以使用 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 文件的路径，将 Gradle 关联到您的原生库。

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

  1. 从 IDE 的左侧打开 Project 窗格并从下拉菜单中选择 Project 视图。
  2. 右键点击您的模块的根目录并选择 New > File。

    注：您可以在所需的任意位置创建构建脚本。不过，在配置构建脚本时，原生源文件和库的路径将与构建脚本的位置相关。
  3. 输入“CMakeLists.txt”作为文件名并点击 OK。

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

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

使用 add_library() 向您的 CMake 构建脚本添加源文件或库时，Android Studio 还会在您同步项目后在 Project 视图下显示关联的标头文件。不过，为了确保 CMake 可以在编译时定位您的标头文件，您需要将 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 库包含到项目的 CMakeLists.txt 脚本文件中，您可以使用这些 API 中的任意一种。

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

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

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

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

NDK 还以源代码的形式包含一些库，您在构建和关联到您的原生库时需要使用这些代码。您可以使用 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} )

添加其他预构建库

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

add_library( imported-lib
             SHARED
             IMPORTED )

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

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

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 )

为了确保 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 分析器验证 Gradle 将哪些库封装到您的 APK 中。如需了解有关 CMake 命令的详细信息，请参阅 CMake 文档。

导入.a静态库

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

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

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

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

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

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

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

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

第三步， 动态库与头文件拷贝进去时候，是需要告诉编译器做关联的。在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在哪个目录下，并指定链接库的名称

接着添加

  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)

然后修改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. #添加curl网络请求
  7. add_library(curl STATIC IMPORTED)
  8. set_target_properties(curl
  9. PROPERTIES IMPORTED_LOCATION
  10. ${CMAKE_SOURCE_DIR}/src/main/jniLibs/${ANDROID_ABI}/libcurl.a)
  11. #添加加密工具(md5, base64, des, aes , asa) part-1
  12. add_library(crypto STATIC IMPORTED)
  13. set_target_properties(crypto
  14. PROPERTIES IMPORTED_LOCATION
  15. ${CMAKE_SOURCE_DIR}/src/main/jniLibs/${ANDROID_ABI}/libcrypto.a)
  16. #添加加密工具(md5, base64, des, aes , asa) des加密 part-2
  17. add_library(ssl STATIC IMPORTED)
  18. set_target_properties(ssl
  19. PROPERTIES IMPORTED_LOCATION
  20. ${CMAKE_SOURCE_DIR}/src/main/jniLibs/${ANDROID_ABI}/libssl.a)



    

  1. target_link_libraries(native-lib
    2. 

  2. jsoncpp
    3. 

  3. curl
    4. 

  4. crypto
    5. 

  5. ssl
    6. 

  6. ${log-lib})
    7. 




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


将 Gradle 关联到您的原生库


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

  2. 右键点击您想要关联到原生库的模块（例如 app 模块），并从菜单中选择 Link C++ Project with Gradle。您应看到一个如图 4 所示的对话框。
    3. 

  3. 从下拉菜单中，选择 CMake 或 ndk-build。

      

    1. 如果您选择 CMake，请使用 Project Path 旁的字段为您的外部 CMake 项目指定 CMakeLists.txt 脚本文件。
      2. 

    2. 如果您选择 ndk-build，请使用 Project Path 旁的字段为您的外部 ndk-build 项目指定 Android.mk 脚本文件。如果 Application.mk 文件与您的 Android.mk 文件位于相同目录下，Android Studio 也会包含此文件。
      3. 

    

    

    图 4.使用 Android Studio 对话框关联外部 C++ 项目。
    4. 

  4. 点击 OK。
    5. 



手动配置 Gradle


要手动配置 Gradle 以关联到您的原生库，您需要将 externalNativeBuild {} 块添加到模块级 build.gradle 文件中，并使用 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"
    }
  }
}


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


指定可选配置


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


例如，如果您的 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 "-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 {...}
  }
}


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


指定 ABI


默认情况下，Gradle 会针对 NDK 支持的 ABI 将您的原生库构建到单独的 .so 文件中，并将其全部封装到您的 APK 中。如果您希望 Gradle 仅构建和封装原生库的特定 ABI 配置，您可以在模块级 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 的大小，请考虑配置 ABI APK 拆分，而不是创建一个包含原生库所有版本的大型 APK，Gradle 会为您想要支持的每个 ABI 创建单独的 APK，并且仅封装每个 ABI 需要的文件。如果您配置 ABI 拆分，但没有像上面的代码示例一样指定 abiFilters 标志，Gradle 会构建原生库的所有受支持 ABI 版本，不过仅会封装您在 ABI 拆分配置中指定的版本。为了避免构建您不想要的原生库版本，请为 abiFilters 标志和 ABI 拆分配置提供相同的 ABI 列表。


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


				
时间： 2024-11-05 07:59:31 

		


		


	

	
	

		


		
AndroidStudio用Cmake方式编译NDK代码（cmake配置.a库）的相关文章


								

		

			

                linux下cmake方式编译安装MySQL数据库
			

		

		

									

				前言:MySQL数据库自5.5版本以后,就开始使用CMake编译工具进行安装. 安装环境: [[email protected] ~]# cat /etc/redhat-release Red Hat Enterprise Linux Server release 6.5 (Santiago)[[email protected] ~]# mysqladmin --versionmysqladmin  Ver 8.42 Distrib 5.6.14, for Linux on x86_64 1.安			

		

	

				

		

			

                CMAKE方式编译安装Mysql5.5
			

		

		

									

				1.源码cmake方式编译安装MySQL5.5.32 安装前先安装: yum install ncurses-devel -y 1.1 下载Mysql和cmake安装包: wgethttp://wwwNaNake.org/files/v2.8/cmake-2.8.8.tar.gz 1.2 查看系统环境 cat/etc/redhat-release uname-r uname-m 1.3 安装cmake包 tarzxf cmake-2.8.8.tar.gz cdcmake-2.8.8 ./conf			

		

	

				

		

			

                CMake方式编译
			

		

		

									

				[1]CMake基础 CMake是一种跨平台编译工具 CMake主要是编写CMakeLists.txt文件 通过CMake命令将CMakeLists.txt文件转化为make所需的Makefile文件 再用make命令编译源代码生成可执行程序或库文件 [2]示例工程 (1)项目结构 build目录用来构建项目 include目录放置头文件,myprint.h头文件,内容如下: src目录下myprint.cpp文件,内容如下: hello.cpp文件,内容如下: (2)CMake方式编译生成库文			

		

	

				

		

			

                CMake方式编译grpc
			

		

		

									

				首先,下载 grpc 源代码到本地: git clone https://github.com/grpc/grpc.git 如果只想下载指定版本的,如以版本"1.27.3"为例,可改成如下语句: git clone -b v1.27.3 https://github.com/grpc/grpc.git 上列操作成功完成后,grpc 源码的第三方依赖目录 third_party 实际是空的,需通过下列步骤拉取依赖的第三方.切换到 grpc 目录,下载 grpc 第三方依赖到本地: git			

		

	

				

		

			

                cmake安装mysql及多实例配置方法
			

		

		

									

				一.安装mysql 1. 生产环境如何选择MySQL版本 1. 选择社区版的稳定GA版本2. 可以选择5.1或5.5.互联网公司主流5.5, 其次是5.1和5.63. 选择发布后6个月以上的GA版4. 要选择前后几个月没有打的BUG修复的版本,而不是大量修复BUG的几种版本5. 最好选择向后较长时间没有更新发布的版本6. 考虑开发人员开发程序使用的版本是否兼容你选的版本7. 企业非核心业务采用新版本的数据库GA版本软件8. 作为内部开发测试数据库环境,跑大概3-6个月时间9. 向DBA高手请教,			

		

	

				

		

			

                NDK开发使用cMake方式 - 添加其他的预编译库
			

		

		

									

				NDK 开发使用cMake方式,网上能找到不少的教程,这里推荐一篇博文: http://blog.csdn.net/wl9739/article/details/52607010 关于添加其他的预编译库,网上很多文章写得不太准确,这里说下步骤: 1,将预编译库加入项目 2,编辑CMakeLists.txt,动态链接库是SHARED,静态是STATIC. 关键是IMPORTED_LOCATION.CMAKE_SOURCE_DIR不用手动定义,指向CMakeLists.txt所在的目录. add_l			

		

	

				

		

			

                AS2.2使用CMake方式进行JNI/NDK开发
			

		

		

									

				之前写过一篇比较水的文章Android手机控制电脑撸出HelloWorld 里面用到了JNI/NDK技术. 这篇文章给大家介绍下JNI/NDK开发.采用的是Android Studio2.2开发环境,使用CMake方式进行开发. JNI(Java Native Interface)是java与C/C++进行通信的一种技术,使用JNI技术,可以java调用C/C++的函数对象等等,Android中的Framework层与Native层就是采用的JNI技术. 我们知道,Android系统是基于lin			

		

	

				

		

			

                使用AndroidStudio编译NDK的方法及错误解决方式
			

		

		

									

				參考资料: [android ndk]macos环境下Android Studio中利用gradle编译jni模块及配置:http://demo.netfoucs.com/ashqal/article/details/21869151 ANDROID STUDIO, GRADLE AND NDK INTEGRATION:http://ph0b.com/android-studio-gradle-and-ndk-integration/ Gradle Plugin User Guide:http:			

		

	

				

		

			

                使用AndroidStudio编译NDK的方法及错误解决方案
			

		

		

									

				参考资料: [android ndk]macos环境下Android Studio中利用gradle编译jni模块及配置:http://demo.netfoucs.com/ashqal/article/details/21869151 ANDROID STUDIO, GRADLE AND NDK INTEGRATION:http://ph0b.com/android-studio-gradle-and-ndk-integration/ Gradle Plugin User Guide:http: