Android.mk入门到精通（003）——Android.mk用法详解

缺乏、安全感 2022-06-05 01:51 1120阅读 0赞

https://www.cnblogs.com/reality-soul/p/6893248.html

**一、[Android][].mk介绍**

Android.mk是Android提供的一种makefile文件，用来指定诸如编译生成so库名、引用的头文件目录、需要编译的.c/.cpp文件和.a静态库文件等。要掌握jni，就必须熟练掌握Android.mk的语法规范。

它的基本格式如下：

**\[cpp\]** [ view plain][view plain] [ copy][view plain] [ print][view plain] [?][view plain]

1.  LOCAL\_PATH := $(call my-dir)  
2.  include $(CLEAR\_VARS)  
3.  ................  
4.  LOCAL\_xxx       := xxx  
5.  LOCAL\_MODULE    := hello-jni  
6.  LOCAL\_SRC\_FILES := hello-jni.c  
7.  LOCAL\_xxx       := xxx  
8.  ................  
9.  include $(BUILD\_SHARED\_LIBRARY)

LOCAL\_PATH变量制定了该.mk的路径，$(call my-dir)调用NDK内部的函数获得当前.mk文件的路径

include $(CLEAR\_VARS)清空了除了LOCAL\_PATH之外的所有LOCAL\_xxx变量的值

省略号中间就是对于模块参数的设置，主要包括：模块名字、模块源文件、模块类型、编译好的模块存放位置、以及编译的平台等

include $(BUILD\_xxx\_xxx)执行NDK的默认脚本，它会收集include $(CLEAR\_VARS)脚本后所有定义的LOCAL\_xxx变量，然后根据它们来生成模块。

**二、Android.mk语法详解**

LOCAL\_PATH := $(call my-dir)   
每个Android.mk文件必须以定义LOCAL\_PATH为开始。它用于在开发tree中查找源文件。宏my-dir 则由Build System提供。返回包含Android.mk的目录路径。

include $(CLEAR\_VARS)   
CLEAR\_VARS 变量由Build System提供。并指向一个指定的GNU Makefile，由它负责清理很多LOCAL\_xxx.  
例如：LOCAL\_MODULE, LOCAL\_SRC\_FILES, LOCAL\_STATIC\_LIBRARIES等等。但不清理LOCAL\_PATH.  
这个清理动作是必须的，因为所有的编译控制文件由同一个GNU Make解析和执行，其变量是全局的。所以清理后才能避免相互影响。

LOCAL\_MODULE    := hello-jni

LOCAL\_MODULE模块必须定义，以表示Android.mk中的每一个模块。名字必须唯一且不包含空格。Build System会自动添加适当的前缀和后缀。例如，foo，要产生动态库，则生成libfoo.so. 但请注意：如果模块名被定为：libfoo.则生成libfoo.so. 不再加前缀

LOCAL\_MODULE\_PATH :=$(TARGET\_ROOT\_OUT) 指定最后生成的模块的目标地址

TARGET\_ROOT\_OUT:根文件系统，路径为out/target/product/generic/root

TARGET\_OUT:system文件系统，路径为out/target/product/generic/system

TARGET\_OUT\_DATA:data文件系统，路径为out/target/product/generic/data

除了上面的这些，NDK还提供了很多其他的TARGET\_XXX\_XXX变量，用于将生成的模块拷贝到输出目录的不同路径

默认是TARGET\_OUT

LOCAL\_SRC\_FILES := hello-jni.c

LOCAL\_SRC\_FILES变量必须包含将要打包如模块的C/C++ 源码。不必列出头文件，build System 会自动帮我们找出依赖文件。缺省的C++源码的扩展名为.cpp. 也可以修改，通过LOCAL\_CPP\_EXTENSION

include $(BUILD\_SHARED\_LIBRARY)   
BUILD\_SHARED\_LIBRARY：是Build System提供的一个变量，指向一个GNU Makefile Script。  
它负责收集自从上次调用 include $(CLEAR\_VARS)  后的所有LOCAL\_XXX信息。并决定编译为什么。

BUILD\_STATIC\_LIBRARY    ：编译为静态库。   
BUILD\_SHARED\_LIBRARY ：编译为动态库   
BUILD\_EXECUTABLE           ：编译为Native C可执行程序

BUILD\_PREBUILT                 ：该模块已经预先编译

NDK还定义了很多其他的BUILD\_XXX\_XXX变量，它们用来指定模块的生成方式。

**三、使用示例**

**\[cpp\]** [ view plain][view plain] [ copy][view plain] [ print][view plain] [?][view plain]

1.  \#编译静态库    
2.  LOCAL\_PATH := $(call my-dir)    
3.  include $(CLEAR\_VARS)    
4.  LOCAL\_MODULE = libhellos    
5.  LOCAL\_CFLAGS = $(L\_CFLAGS)    
6.  LOCAL\_SRC\_FILES = hellos.c    
7.  LOCAL\_C\_INCLUDES = $(INCLUDES)    
8.  LOCAL\_SHARED\_LIBRARIES := libcutils    
9.  LOCAL\_COPY\_HEADERS\_TO := libhellos    
10. LOCAL\_COPY\_HEADERS := hellos.h    
11. include $(BUILD\_STATIC\_LIBRARY)    
12.     
13. \#编译动态库    
14. LOCAL\_PATH := $(call my-dir)    
15. include $(CLEAR\_VARS)    
16. LOCAL\_MODULE = libhellod    
17. LOCAL\_CFLAGS = $(L\_CFLAGS)    
18. LOCAL\_SRC\_FILES = hellod.c    
19. LOCAL\_C\_INCLUDES = $(INCLUDES)    
20. LOCAL\_SHARED\_LIBRARIES := libcutils    
21. LOCAL\_COPY\_HEADERS\_TO := libhellod    
22. LOCAL\_COPY\_HEADERS := hellod.h    
23. include $(BUILD\_SHARED\_LIBRARY)    
24.     
25. \#使用静态库    
26. LOCAL\_PATH := $(call my-dir)    
27. include $(CLEAR\_VARS)    
28. LOCAL\_MODULE := hellos    
29. LOCAL\_STATIC\_LIBRARIES := libhellos    
30. LOCAL\_SHARED\_LIBRARIES :=    
31. LOCAL\_LDLIBS += -ldl    
32. LOCAL\_CFLAGS := $(L\_CFLAGS)    
33. LOCAL\_SRC\_FILES := mains.c    
34. LOCAL\_C\_INCLUDES := $(INCLUDES)    
35. include $(BUILD\_EXECUTABLE)    
36.     
37. \#使用动态库    
38. LOCAL\_PATH := $(call my-dir)    
39. include $(CLEAR\_VARS)    
40. LOCAL\_MODULE := hellod    
41. LOCAL\_MODULE\_TAGS := debug    
42. LOCAL\_SHARED\_LIBRARIES := libc libcutils libhellod    
43. LOCAL\_LDLIBS += -ldl    
44. LOCAL\_CFLAGS := $(L\_CFLAGS)    
45. LOCAL\_SRC\_FILES := maind.c    
46. LOCAL\_C\_INCLUDES := $(INCLUDES)    
47. include $(BUILD\_EXECUTABLE)    
48.   
49.   
50. \#拷贝文件到指定目录  
51. LOCAL\_PATH := $(call my-dir)  
52. include $(CLEAR\_VARS)  
53. LOCAL\_MODULE := bt\_vendor.conf  
54. LOCAL\_MODULE\_CLASS := ETC  
55. LOCAL\_MODULE\_PATH := $(TARGET\_OUT)/etc/bluetooth  
56. LOCAL\_MODULE\_TAGS := eng  
57. LOCAL\_SRC\_FILES := $(LOCAL\_MODULE)  
58. include $(BUILD\_PREBUILT)  
59.   
60.   
61. \#拷贝动态库到指定目录  
62. LOCAL\_PATH := $(call my-dir)  
63. include $(CLEAR\_VARS)  
64. \#the data or lib you want to copy  
65. LOCAL\_MODULE := libxxx.so  
66. LOCAL\_MODULE\_CLASS := SHARED\_LIBRARIES  
67. LOCAL\_MODULE\_PATH := $(ANDROID\_OUT\_SHARED\_LIBRARIES)  
68. LOCAL\_SRC\_FILES := lib/$(LOCAL\_MODULE )  
69. OVERRIDE\_BUILD\_MODULE\_PATH := $(TARGET\_OUT\_INTERMEDIATE\_LIBRARIES)  
70. include $(BUILD\_PREBUILT)

参考文章：

[http://www.cnblogs.com/wainiwann/p/3837936.html][http_www.cnblogs.com_wainiwann_p_3837936.html]

[http://blog.csdn.net/ly131420/article/details/9619269][http_blog.csdn.net_ly131420_article_details_9619269]

[http://blog.csdn.net/mawl2002/article/details/6118522][http_blog.csdn.net_mawl2002_article_details_6118522]

**（一）概要**

在android系统源码中，还是需要在系统环境下编译的应用程序，都可以见到android.mk的文件，该文件就是编译源代码所需要的编译文件。

下面就来分析下android.mk文件

该文件其实是GNU Makefile的一小部分，它用来对Android程序进行编译。Android.mk把源码组织成不同的模块，每个模块可以是一个静态库也可以是一个动态库。动态库才会被拷贝到安装包中，静态库只能用于编译生成动态库。同一个Android.mk文件可以定义多个模块，不同的模块可以共用同一个Android.mk文件。

一个Android.mk文件可以编译多个模块，每个模块属下列类型之一 ：

1）APK程序

一般的Android程序，编译打包生成apk文件

2）JAVA库

java类库，编译打包生成jar文件

3)C\\C++应用程序

可执行的C\\C++应用程序

4）C\\C++静态库

编译生成C\\C++静态库，并打包成.a文件

5）C\\C++共享库

编译生成共享库（动态链接库），并打包成.so文， 有且只有共享库才能被安装/复制到您的应用软件（APK）包中。

编译打包的5中方式：  
（1）APK程序  
  一般的Android程序，编译打包生成apk文件  
（out/target/product/generic/obj/APPS/XXX\_intermediates）  
（2）JAVA库  
  java类库，编译打包生成jar文件  
(out/target/product/generic/obj/JAVA\_LIBRARIES/XXX\_intermediates)  
（3)C\\C++应用程序  
 可执行的C\\C++应用程序  
(out/target/product/generic/obj/EXECUTABLE/XXX\_intermediates)  
（4）C\\C++静态库   
编译生成C\\C++静态库，并打包成.a文件  
(out/target/product/generic/obj/STATIC\_LIBRARY/XXX\_static\_intermediates)  
 (5）C\\C++共享库  
编译生成共享库（动态链接库），并打包成.so文， 有且只有共享库才能被安装/复制到您的应用软件（APK）包中。  
(out/target/product/generic/obj/SHARED\_LIBRARY/XXX\_shared\_intermediates)  
  
代码：  
include $(BUILD\_PACKAGE)  
编译打包成APK文件  
  
include $(BUILD\_STATIC\_JAVA\_LIBRARY)  
用它来编译生成JAVA库（打包成.jar文件）  
  
include $(BUILD\_EXECUTABLE)  
编译C/C++应用程序  
  
include $(BUILD\_STATIC\_LIBRARY)  
用它来编译生成C\\C++静态库（打包成.a文件）  
  
include $(BUILD\_SHARED\_LIBRARY)  
指向一个 GNU Makefile 脚本(应该就是在 build/core目录下的 shared\_library.mk),用它来编译生成共享库（动态链接库.so）

注意，NDK所使用的Android.mk文件的语法与Android操作系统的开放源码中的Android.mk的语法非常接近，但是编译系统实现他们的方式却是不同的，这是为了方便应用程序开发人员复用以前的代码。

**（二）简单示例**

jni/Android.mk 文件是这个模块的编译脚本，内容如下：

**\[plain\]**  [view plain][view plain 1] [copy][view plain 1]

1.  LOCAL\_PATH := $(call my-dir)  
2.    
3.  include $(CLEAR\_VARS)  
4.    
5.  LOCAL\_MODULE    := hello-jni  
6.  LOCAL\_SRC\_FILES := hello-jni.c  
7.    
8.  include $(BUILD\_SHARED\_LIBRARY)

以上内容解释如下：

LOCAL\_PATH := $(call my-dir)

每个Android.mk文件都必须在开头定义 LOCAL\_PATH 变量。这个变量被用来寻找C/C++源文件。在该例中，my-dir 是一个由编译系统提供的**宏函数**，用于返回Android.mk所在目录的路径。

include $(CLEAR\_VARS)

CLEAR\_VARS是编译系统预定义的一个变量，它指向一个特殊的Makefile，这个Makefile负责清除 LOCAL\_xxx 的变量（例如 LOCAL\_MODULE, LOCAL\_SRC\_FILES, LOCAL\_STATIC\_LIBRARIES 等）但不会清除 LOCAL\_PATH。之所以需要清理这些变量是因为所有的编译控制文件是在一趟make执行过程中完成的，而所有的变量都是全局的，会对其他Android.mk文件产生影响。

LOCAL\_MODULE := hello-jni

LOCAL\_MODULE 用来给每个模块定义一个名字，不同模块的名字不能相同，不能有空格。这里的名字会传给NDK编译系统，然后加上lib前缀和.so后缀 （例如，变成libhello-jni.so）。注意，如果你在LOCAL\_MODULE定义中自己加上了lib前缀，则ndk在处理的时候就不会再加上lib前缀了（为了兼容Android系统的一些源码）。

LOCAL\_SRC\_FILES := hello-jni.c

在LOCAL\_SRC\_FILES 变量里面列举出对应于同一个模块的、要编译的那些文件，这里不要把头文件加进来，编译系统可以自动检测头文件依赖关系。默认情况下，C++源码文件的扩展名应该是cpp，如果想修改的话，将变量LOCAL\_CPP\_EXTENSION修改为你想要的扩展名，注意句点。例如：LOCAL\_CPP\_EXTENSION := .cxx

include $(BUILD\_SHARED\_LIBRARY)

这个 BUILD\_SHARED\_LIBRARY也是预定义的变量，也是指向一个Makefile，负责将你在 LOCAL\_XXX 等变量中定义信息收集起来，确定要编译的文件，如何编译。如果要编译的是静态库而不是动态库，则可以用 BUILD\_STATIC\_LIBRARY。

**（三）自定义变量**

以下是在 Android.mk中依赖或定义的变量列表， 可以定义其他变量为自己使用，但是NDK编译系统保留下列变量名：

-以 LOCAL\_开头的名字（例如 LOCAL\_MODULE）

-以 PRIVATE\_, NDK\_ 或 APP\_开头的名字（内部使用）

-小写名字（内部使用，例如‘my-dir’）

如果为了方便在 Android.mk 中定义自己的变量，建议使用 MY\_前缀，一个小例子：

MY\_SOURCES := foo.c

ifneq ($(MY\_CONFIG\_BAR))

MY\_SOURCES += bar.c

endif

LOCAL\_SRC\_FILES += $(MY\_SOURCES)

注意：‘:=’是赋值的意思；'+='是追加的意思；‘$’表示引用某变量的值。

**（四）GNU Make系统变量**

这些 GNU Make变量在你的 Android.mk 文件解析之前，就由编译系统定义好了。

注意在某些情况下，NDK可能分析 Android.mk 几次，每一次某些变量的定义会有不同。

（1）CLEAR\_VARS:   指向一个编译脚本，几乎所有未定义的 LOCAL\_XXX 变量都在"Module-description"节中列出。必须在开始一个新模块之前包含这个脚本：

include $( CLEAR\_VARS )，用于重置除LOCAL\_PATH变量外的，所有LOCAL\_XXX系列变量。

（2）BUILD\_SHARED\_LIBRARY:   指向编译脚本，根据所有的在 LOCAL\_XXX 变量把列出的源代码文件编译成一个共享库。

注意，必须至少在包含这个文件之前定义 LOCAL\_MODULE 和 LOCAL\_SRC\_FILES。

include $( BUILD\_SHARED\_LIBRARY )

（3） BUILD\_STATIC\_LIBRARY:   一个BUILD\_STATIC\_LIBRARY变量用于编译一个静态库。静态库不会复制到的APK包中，但是能够用于编译共享库。

示例：include $( BUILD\_STATIC\_LIBRARY)

注意，这将会生成一个名为  lib$(LOCAL\_MODULE).a 的文件

（4）TARGET\_ARCH:  目标 CPU平台的名字,  和 android 开放源码中指定的那样。如果是 arm，表示要生成 ARM 兼容的指令，与 CPU架构的修订版无关。

（5）TARGET\_PLATFORM:  Android.mk 解析的时候，目标 Android 平台的名字. 详情可参考/development/ndk/docs/stable- apis.txt.

android-3 -> Official Android 1.5 system images

android-4 -> Official Android 1.6 system images

android-5 -> Official Android 2.0 system images

（6）TARGET\_ARCH\_ABI:   暂时只支持两个 value，armeabi 和 armeabi-v7a。在现在的版本中一般把这两个值简单的定义为 arm， 通过 android  平台内部对它重定义来获得更好的匹配。其他的 ABI 将在以后的 NDK 版本中介绍，它们会有不同的名字。注意虽然所有基于 ARM的ABI都会把 'TARGET\_ARCH'定义成‘arm’， 但是会有不同的‘TARGET\_ARCH\_ABI’。

（ 7 ） TARGET\_ABI:   目标平台和 ABI 的组合，它事实上被定义成$(TARGET\_PLATFORM)-$(TARGET\_ARCH\_ABI)  ，在想要在真实的设备中针对一个特别的目标系统进行测试时，会有用。在默认的情况下，它会是'android-3-arm'。

**（五）模块描述变量**

下面这些变量用于对模块进行描述，这些变量应该在 include $(CLEAR\_VARS) 和 include $(BUILD\_XXXX) 之间定义好。

#### LOCAL\_PATH （必须）    ####

这个变量表示当前文件（一般是Android.mk）所在的路径，**该变量很重要，必须定义**（在Android.mk文件的开头处定义）。常见写法如下：

LOCAL\_PATH := $(call my-dir)

宏函数‘my-dir’,  由编译系统提供， 用于返回当前路径(即包含Android.mk file文件的目录)。（第7部分会详细介绍）

该变量不会被 include $(CLEAR\_VARS) 清空，所以不论Android.mk定义了几个模块，一个Android.mk只需要在开头定义一次即可。

**include $(CLEAR\_VARS)**  
**CLEAR\_VARS是一个GNU Make系统变量****，指向一个编译脚本。**该脚本功能为你清除许多 LOCAL\_XXX 变量 ( 例如 LOCAL\_MODULE ， LOCAL\_SRC\_FILES ，LOCAL\_STATIC\_LIBRARIES，等等…)，除 LOCAL\_PATH外。  
( android 安装目录下的/build/core/config.mk 文件看到其定义)

#### LOCAL\_MODULE （必须）    ####

该变量定义当前模块的名字，名字必须唯一，不能有空格。这个变量必须在 include $(BUILD\_XXX) 之前定义好。默认情况下，这里的名字会用来得到输出文件的名字。例如模块名为foo，则得到的输出文件为libfoo.so。但是，如果你要在其他模块的Android.mk文件或Application.mk中引用这个模块，应该用foo这个模块名，而不要用libfoo.so这个文件名。

#### **LOCAL\_MODULE\_FILENAME （可选）**    ####

该变量可以用来重定义输出文件的名字。默认情况下，foo模块得到的静态库的名字为 libfoo.a，动态库的名字为libfoo.so（UNIX规范）。当定义了LOCAL\_MODULE\_FILENAME之后，输出文件名就是这个变量指定的名字，例如：

**\[plain\]**  [view plain][view plain 1] [copy][view plain 1]

1.  LOCAL\_MODULE := foo-version-1  
2.  LOCAL\_MODULE\_FILENAME := libfoo

注意： LOCAL\_MODULE\_FILENAME不支持文件路径（所以不能有斜杠），不要写扩展名（文件路径和文件扩展名是由编译工具自动加上的）

#### LOCAL\_SRC\_FILES （必须）    ####

该变量用来指定该模块对应的源文件，只把需要传给编译器的源文件名加进LOCAL\_SRC\_FILES，编译系统会自动处理头文件依赖。这里的文件名都是以 LOCAL\_PATH 作为当前目录的（即相对于LOCAL\_PATH目录），例如：

LOCAL\_SRC\_FILES := foo.c  \\       \#如果要换行，用反斜杠

bar.c

LOCAL\_SRC\_FILES := $(call all-subdir-java-files)

LOCAL\_SRC\_FILES := $(call all-java-files-under, src)

## [LOCAL\_MODULE\_TAGS][LOCAL_MODULE_TAGS] ##

LOCAL\_MODULE\_TAGS ：=user eng tests optional  samples  shell\_ash  shell\_mksh

user: 指该模块只在user版本下才编译

eng: 指该模块只在eng版本下才编译

tests: 指该模块只在tests版本下才编译

optional:指该模块在所有版本下都编译

LOCAL\_MODULE\_PATH := $(TARGET\_ROOT\_OUT)  编译打包后，指定模块最后的目标存放路径  
TARGET\_ROOT\_OUT：表示根文件系统。  
TARGET\_OUT：表示system文件系统。  
TARGET\_OUT\_DATA：表示data文件系统。

#### LOCAL\_CPP\_EXTENSION （可选） ####

用来定义C++代码文件的扩展名。必须以句点开头（即 “.”），默认值是“.cpp”，可以修改，例如：

LOCAL\_CPP\_EXTENSION := .cxx

从 NDK r7 这个版本开始，该变量可以支持多个扩展名了，例如：

LOCAL\_CPP\_EXTENSION := .cxx .cpp .cc

#### LOCAL\_CPP\_FEATURES （可选） ####

该变量用来指定C++代码所依赖的特殊C++特性。例如，如果要告诉编译器你的C++代码使用了RTTI（RunTime Type Information）：

LOCAL\_CPP\_FEATURES := rtti

如果要指定你的C++代码使用了C++异常，则：

LOCAL\_CPP\_FEATURES := exceptions

该变量可以同时指定多个特性。例如：    LOCAL\_CPP\_FEATURES := rtti features

这个变量的作用就是在编译模块的时候，开启相应的编译器/链接器标志。对于预编译的文件，该变量表明该预编译的库依赖了这些特性，从而确保最后的链接工作正确进行。与该变量等价的做法是在LOCAL\_CPPFLAGS中写上 -frtti -fexceptions 等标志选项。但是，推荐用这里的方法。

#### LOCAL\_C\_INCLUDES ####

加入需要的头文件搜索路径

一个路径的列表，是**NDK根目录**的相对路径（LOCAL\_SRC\_FILES中的文件相对于LOCAL\_PATH）。当编译C/C++、汇编文件时，这些路径将被追加到头文件搜索路径列表中。例如：

LOCAL\_C\_INCLUDES := sources/foo

或者， LOCAL\_C\_INCLUDES := $(LOCAL\_PATH)/../foo

这里的搜索路径会放在LOCAL\_CFLAGS/LOCAL\_CPPFALGS等标志的前面。 当使用ndk-gdb的时候，LOCAL\_C\_INCLUDES中的路径也会被用到。

#### LOCAL\_CFLAGS ####

指定当编译C/C++源码的时候，传给编译器的标志。它一般用来指定其他的编译选项和宏定义。

注意：尽量不要在Android.mk中修改优化/调试等级，因为在Application.mk中定义了相关信息之后编译系统会自动处理这些问题。

#### LOCAL\_CXXFLAGS （废除， LOCAL\_CPPFLAGS的别名） ####

#### LOCAL\_CPPFLAGS （可选）    ####

编译C++代码的时候传递给编译器的选项（编译C代码不会用这里的选项）。最后得到的命令行选项中，这里指定的选项在 LOCAL\_CFLAGS 指定的选项的后面。

#### LOCAL\_STATIC\_LIBRARIES ####

指定应该链接到当前模块的静态库（可指定多个）。当前模块是动态库时，该选项才有意义。

#### LOCAL\_SHARED\_LIBRARIES ####

指定的是运行时该模块所依赖共享库（可指定多个）。这些信息是链接阶段必须的。

#### LOCAL\_WHOLE\_STATIC\_LIBRARIES ####

它是LOCAL\_STATIC\_LIBRARIES的变体，用来表示它对应的模块对于linker来说应该是一个“whole archive”（见GNU linker 文档，关于 --whole-archive的资料）。当静态库之间有循环依赖时，会用到这个选项。注意，当编译动态库时，这个选项会强行把所有的对象文件组装到一起；不过，在编译可执行文件的时候情况不是这样的。

#### LOCAL\_LDLIBS ####

用来指定模块编译时的其余连接器标志。例如：

LOCAL\_LDLIBS := -lz

告诉链接器在加载该共享库的时候必须链接 /system/lib/libz.so 这个共享库。

如果想知道Android系统中有哪些共享库可以链接，参考 [Stable APIs][]。

#### LOCAL\_ALLOW\_UNDEFINED\_SYMBOLS ####

默认情况下，当编译一个共享库的时候，遇到未定义符号引用就会报告一个“undefined symbol”错误。这有助于修复你的代码中存在的bug。

如果因为某种原因，必须禁止该检测，可以把这个变量设置为true。注意，编译出的共享库有可能在加载的时候就报错导致程序退出。

LOCAL\_ARM\_MODE

LOCAL\_ARM\_NEON

#### LOCAL\_DISABLE\_NO\_EXECUTE ####

Android NDK r4增加了对“NX bit“安全特性的支持。它是默认开启的，如果你确定自己不需要该特性，你可以将它关闭，即：

LOCAL\_DISABLE\_NO\_EXECUTE := true

该变量不会修改ABI，只会在 ARMv6以上的CPU的内核上启用。开启该特性编译出的代码无需修改可运行在老的CPU上（也就是说所有ARM的CPU都能运行）。

参考信息：

[http://en.wikipedia.org/wiki/NX\_bit][http_en.wikipedia.org_wiki_NX_bit]  
[http://www.gentoo.org/proj/en/hardened/gnu-stack.xml][http_www.gentoo.org_proj_en_hardened_gnu-stack.xml]

#### **LOCAL\_EXPORT\_CFLAGS** ####

这个变量定义一些C/C++编译器flags。这些flags（标志）会被追加到使用了这个模块（利用LOCAL\_STATIC\_LIBRARIES和LOCAL\_SHARED\_LIBRARIES）的模块的LOCAL\_CFLAGS 定义中去。

假如foo模块的声明如下：

**\[plain\]**  [view plain][view plain 1] [copy][view plain 1]

1.  include $(CLEAR\_VARS)  
2.  LOCAL\_MODULE := foo  
3.  LOCAL\_SRC\_FILES := foo/foo.c  
4.  LOCAL\_EXPORT\_CFLAGS := -DFOO=1  
5.  include $(BUILD\_STATIC\_LIBRARY)

bar模块依赖foo模块，声明如下：

**\[plain\]**  [view plain][view plain 1] [copy][view plain 1]

1.  include $(CLEAR\_VARS)  
2.  LOCAL\_MODULE := bar  
3.  LOCAL\_SRC\_FILES := bar.c  
4.  LOCAL\_CFLAGS := -DBAR=2  
5.  LOCAL\_STATIC\_LIBRARIES := foo  
6.  include $(BUILD\_SHARED\_LIBRARY)

因此在编译bar模块的时候，它的编译器标志就是 “-DFOO=1 -DBAR=2”。 导出的flags 加上本模块的 LOCAL\_CFLAGS，成为最后传给编译器的flags。这样修改起来就很容易。这种依赖关系是可传递的，例如，如果zoo依赖bar，bar依赖foo，那么zoo就会同时有bar和foo的导出flags。

注意，编译模块自身时，不会使用它所导出的flags。例如在编译上面的foo模块时， -DFOO=1 不会传递给编译器。

#### **LOCAL\_EXPORT\_CPPFLAGS** ####

与 LOCAL\_EXPORT\_CFLAGS 相同，是跟C++相关的标志。

#### **LOCAL\_EXPORT\_C\_INCLUDES** ####

与 LOCAL\_EXPORT\_CFLAGS 相同，但是只用于头文件搜索路径。当你的共享库有多个模块，而且互相之间有头文件依赖时有用。用法详见 Import Module。

#### **LOCAL\_EXPORT\_LDLIBS** ####

与 LOCAL\_EXPORT\_CFLAGS 相同，但是只用于连接器的flag。注意这里被导人的链接器标志将追加到模块的 LOCAL\_LDLIBS。

例如当foo模块是一个静态库并且代码依赖于系统库时，该变量非常有用。 LOCAL\_EXPORT\_LDLIBS 可以用于导出该依赖：

**\[plain\]**  [view plain][view plain 1] [copy][view plain 1]

1.  include $(CLEAR\_VARS)  
2.  LOCAL\_MODULE := foo  
3.  LOCAL\_SRC\_FILES := foo/foo.c  
4.  LOCAL\_EXPORT\_LDLIBS := -llog  
5.  include $(BUILD\_STATIC\_LIBRARY)  
6.    
7.  include $(CLEAR\_VARS)  
8.  LOCAL\_MODULE := bar  
9.  LOCAL\_SRC\_FILES := bar.c  
10. LOCAL\_STATIC\_LIBRARIES := foo  
11. include $(BUILD\_SHARED\_LIBRARY)

此处在编译bar模块的时候，它的链接器标志将加上一个 -llog，表示它依赖于系统提供的 liblog.so，因为它依赖 foo 模块。

#### **LOCAL\_FILTER\_ASM** ####

这个变量指定一个shell命令，用于过滤LOCAL\_SRC\_FILES 中列出的汇编文件或者LOCAL\_SRC\_FILES列出的文件所编译出的汇编文件。定义该变量后，将导致以下行为：

1）所有的C/C++源码首先翻译为临时汇编文件（如果不定义LOCAL\_FILTER\_ASM，则C/C++源码直接编译为 obj 文件）

2）这些汇编文件被传给 LOCAL\_FILTER\_ASM 所指定的shell命令处理，得到一批新的汇编文件。

3）这些新的汇编文件再被编译成obj文件。

换句话说，如果你定义：

**\[plain\]**  [view plain][view plain 1] [copy][view plain 1]

1.  LOCAL\_SRC\_FILES  := foo.c bar.S  
2.  LOCAL\_FILTER\_ASM := myasmfilter

则foo.c首先传给编译器（gcc），得到 foo.S.orignal，然后这个 foo.S.original 被传给你指定的过滤器(LOCAL\_ASM\_FILTER)，得到 foo.S，然后再传给汇编器（例如as），得到 foo.o。 bar.S 直接传给过滤器得到 bar.S.new，然后再传给汇编器，得到 bar.o。即在从\*.S到\*.o的编译流程中增加了一个过滤的环节。

过滤器必须是独立的shell命令，输入文件作为它的第一个命令行参数，输出文件作为第二个命令行参数，例如：

**\[plain\]**  [view plain][view plain 1] [copy][view plain 1]

1.      myasmfilter $OBJS\_DIR/foo.S.original $OBJS\_DIR/foo.S  
2.      myasmfilter bar.S $OBJS\_DIR/bar.S

**（六）GNU Make‘功能’宏**

GNU Make‘功能’宏，必须通过使用'$(call  )'来调用 ，调用他们将返回文本化的信息。

（1）my-dir: 返回当前 Android.mk 所在的目录的路径，相对于 NDK 编译系统的顶层。这是有用的，在 Android.mk 文件的开头如此定义：

LOCAL\_PATH := $(call my-dir)

（2）all-subdir-makefiles:  返回一个位于当前'my-dir'路径的子目录中的所有Android.mk的列表。

例如，看下面的目录层次：

sources/foo/Android.mk

sources/foo/lib1/Android.mk

sources/foo/lib2/Android.mk

如果 sources/foo/Android.mk 包含一行：

include $(call all-subdir-makefiles)

那么它就会自动包含 sources/foo/lib1/Android.mk 和 sources/foo/lib2/Android.mk。

这项功 能用于向编译系统提供深层次嵌套的代码目录层次。

注意， 在默认情况下，NDK 将会只搜索在 sources/\*/Android.mk 中的文件。

（3）this-makefile:   返回当前Makefile 的路径(即这个函数调用的地方)

（4）parent-makefile:   返回调用树中父 Makefile 路径。即包含当前Makefile的Makefile 路径。

（5）grand-parent-makefile： 返回调用树中父Makefile的父Makefile的路径

**（七）参考模板**

（1）在android里在编译一个java应用时，如果这个应用需要引入一个第三方的jar包，那么就需要将这个三方的jar包通过mk文件将其编译到apk里，下面是将一个三方的jar包编译到apk包里的方法.

**\[html\]** [ view plain][view plain 2] [ copy][view plain 2]

1.  LOCAL\_PATH := $(call my-dir)  
2.  include $(CLEAR\_VARS)  
3.    
4.  LOCAL\_MODULE\_TAGS := eng  
5.    
6.  LOCAL\_SRC\_FILES := $(call all-subdir-java-files)  
7.    
8.  \#在该模块中使用预编译好的静态jar包  
9.  LOCAL\_STATIC\_JAVA\_LIBRARIES := android\-support-v4  hiconfigserviceapi  hitv  
10.   
11. LOCAL\_PACKAGE\_NAME := HiConfigService  
12.   
13. LOCAL\_PROGUARD\_ENABLED := disabled  
14.   
15. LOCAL\_CERTIFICATE := platform  
16. \#指定编译该模块为apk  
17. include $(BUILD\_PACKAGE)  
18.   
19.   
20. include $(CLEAR\_VARS)  
21. \#预编译静态jar包。形式为：随便取的名字 ：jar包的真实路径  
22. LOCAL\_PREBUILT\_STATIC\_JAVA\_LIBRARIES :=android\-support-v4:libs/android-support-v4.jar\\  
23. hiconfigserviceapi:libs/hiconfigserviceapi.jar\\  
24. hitv:libs/hitv.jar  
25.   
26. include $(BUILD\_MULTI\_PREBUILT)

重要的语句

LOCAL\_STATIC\_JAVA\_LIBRARIES := googlemap（别名）

LOCAL\_PREBUILT\_STATIC\_JAVA\_LIBRARIES := googlemap:libs/armeabi/maps.jar （格式是：别名：JAR路径）

BUILD\_MULTI\_PREBUILT

Android提供了Prebuilt编译方法，两个文件prebuilt.mk和multi\_prebuilt.mk，对应的方法宏是BUILD\_PREBUILT和 BUILD\_MULTI\_PREBUILT。

prebuilt.mk就是prebuilt的具体实现，它是针对独立一个文件的操作，multi\_prebuilt.mk是针对多个文件的，它对多个文件进行判断，然后调用prebuilt对独立一个文件进行处理。

如果直接用prebuilt.mk的话还是比较麻烦的，得仔细看好需要的宏，如果使用multi\_prebuilt.mk会更方便些，很多它都帮忙处理了。

（2）

做JNI开发，需要把jni编译生成的so文件一起打包成apk

**\[html\]** [ view plain][view plain 2] [ copy][view plain 2]

1.  LOCAL\_PATH := $(call my-dir)  
2.  include $(CLEAR\_VARS)  
3.  LOCAL\_MODULE\_TAGS := optional  
4.    
5.  LOCAL\_SRC\_FILES := $(call all-java-files-under, src)  
6.    
7.  LOCAL\_PACKAGE\_NAME := TestJNI  
8.    
9.  \#就是把so文件放到apk文件里的libs/armeabi里  
10. LOCAL\_JNI\_SHARED\_LIBRARIES := libHimediaAnimation  
11.   
12. LOCAL\_CERTIFICATE := platform  
13.   
14.   
15. include $(BUILD\_PACKAGE)  
16. \#为了编译so文件  
17. include $(LOCAL\_PATH)/jni/Android.mk

重点：

include $(LOCAL\_PATH)/jni/Android.mk    编译生成so文件在out/target/product/\*\*\*/system/lib目录下

然后，LOCAL\_JNI\_SHARED\_LIBRARIES := libHimediaAnimation  引用该目录下的libHimediaAnimation.so共享文件

自动拷贝到libs/armeabi里，随apk一起打包

在源码下，只需要在工程目录mm，就可以编译整个JNI工程了。

（3）编译一个需要platform key签名的APK   
  
LOCAL\_PACKAGE\_NAME := LocalPackage  （apk名）  
LOCAL\_CERTIFICATE := platform  （后面是签名文件的文件名）

关于NDK开发时也使用到了android.mk。基本也一样。

请参考[**NDK官方开发指南翻译之 Android.mk**][NDK_ Android.mk]

在android系统源码中，根目录下有个Makefile 文件，内容为include build/core/main.mk。这是android系统编译的开始，由此也就开始分析android源码的编译。

请参考 **[android makefile 编译分析及 android.mk分析][android makefile _ android.mk]**

上面只是涉及了简单的android.mk，开发者要怎么看懂系统中的android.mk，就需要对makefile文件的语法和规则有个了解。

请参考（学习中。。。）

[Android]: http://lib.csdn.net/base/android
[view plain]: http://blog.csdn.net/qq_695538007/article/details/44339643#
[http_www.cnblogs.com_wainiwann_p_3837936.html]: http://www.cnblogs.com/wainiwann/p/3837936.html
[http_blog.csdn.net_ly131420_article_details_9619269]: http://blog.csdn.net/ly131420/article/details/9619269
[http_blog.csdn.net_mawl2002_article_details_6118522]: http://blog.csdn.net/mawl2002/article/details/6118522
[view plain 1]: http://blog.csdn.net/smfwuxiao/article/details/8530742#
[LOCAL_MODULE_TAGS]: http://www.cnblogs.com/eustoma/archive/2012/05/25/2518418.html
[Stable APIs]: http://blog.csdn.net/smfwuxiao/article/details/6590723
[http_en.wikipedia.org_wiki_NX_bit]: http://en.wikipedia.org/wiki/NX_bit
[http_www.gentoo.org_proj_en_hardened_gnu-stack.xml]: http://www.gentoo.org/proj/en/hardened/gnu-stack.xml
[view plain 2]: http://blog.csdn.net/huangxiaominglipeng/article/details/17839239#
[NDK_ Android.mk]: http://ikinglai.blog.51cto.com/6220785/1215819
[android makefile _ android.mk]: http://my.oschina.net/kangchunhui/blog/77517