androidmk变量

Ⅰ android.mk是在什么情况下生成的

当你需要使用JNI的时候，你需要创建一个native工程。Android.mk就是一个makefile配置文件，帮你把C/C++的代码编译成动态库so的。

创建的方式有两种：

在工程根目录里手动创建一个目录叫jni，在里面新建一个Android.mk，然后创建c,cpp文件，把他们配置到Android.mk里。

右键工程，选择Android Tools->Add Native Support自动生成。

(1)androidmk变量扩展阅读：

创建Android库

Android 库在结构上与 Android 应用模块相同。可以提供构建应用所需的一切内容，包括源代码、资源文件和 Android 清单。

不过，Android 库将编译到可以用作 Android 应用模块依赖项的 Android 归档 (AAR：Android Archive Resource) 文件，而不是在设备上运行的 APK。

与 JAR 文件不同，AAR 文件可以包含 Android 资源和一个清单文件，这样，除了 java 类与方法外，还可以捆绑布局和可绘制对象等共享资源。

库模块在以下情况下非常有用：

构建使用某些相同组件（例如 Activity、服务或 UI 布局）的多个应用。

构建存在多个 APK 变体（例如免费版本和付费版本）的应用并且需要在两种版本中使用相同的核心组件。

Ⅱ 如何输出 android.mk 及 Application.mk 中个变量的值

想知道
android.mk
及
Application.mk
中各变量的值可以通过新建如下两个.mk文件:
PRINT_ANDROID_VARIABLE.mk
PRINT_APPLICATION_VARIABLE.mk
包含到android.mk文件中某位置:
1
include
$(LOCAL_PATH)PRINT_ANDROID_VARIABLE.mk
2
include
$(LOCAL_PATH)PRINT_APPLICATION_VARIABLE.mk
View
Code
文件PRINT_ANDROID_VARIABLE.mk内容如下：
1
$(warning
CLEAR_VARS
=
$(CLEAR_VARS))
2
$(warning
BUILD_SHARED_LIBRARY
=
$(BUILD_SHARED_LIBRARY))
3
$(warning
BUILD_STATIC_LIBRARY
=
$(BUILD_STATIC_LIBRARY))
4
$(warning
PREBUILT_SHARED_LIBRARY
=
$(PREBUILT_SHARED_LIBRARY))
5
$(warning
TARGET_ARCH
=
$(TARGET_ARCH))
6
$(warning
TARGET_PLATFORM
=
$(TARGET_PLATFORM))
7
$(warning
TARGET_ARCH_ABI
=
$(TARGET_ARCH_ABI))
8
$(warning
TARGET_ABI
=
$(TARGET_ABI))
9
$(warning
LOCAL_PATH
=
$(LOCAL_PATH))
10
$(warning
LOCAL_MODULE
=
$(LOCAL_MODULE))
11
$(warning
LOCAL_MODULE_FILENAME
=
$(LOCAL_MODULE_FILENAME))
12
$(warning
LOCAL_SRC_FILES
=
$(LOCAL_SRC_FILES))
13
$(warning
LOCAL_CPP_EXTENSION
=
$(LOCAL_CPP_EXTENSION))
14
$(warning
LOCAL_C_INCLUDES
=
$(LOCAL_C_INCLUDES))
15
$(warning
LOCAL_CFLAGS
=
$(LOCAL_CFLAGS))
16
$(warning
LOCAL_CXXFLAGS
=
$(LOCAL_CXXFLAGS))
17
$(warning
LOCAL_CPPFLAGS
=
$(LOCAL_CPPFLAGS))
18
$(warning
LOCAL_STATIC_LIBRARIES
=
$(LOCAL_STATIC_LIBRARIES))
19
$(warning
LOCAL_SHARED_LIBRARIES
=
$(LOCAL_SHARED_LIBRARIES))
20
$(warning
LOCAL_WHOLE_STATIC_LIBRARIES
=
$(LOCAL_WHOLE_STATIC_LIBRARIES))
21
$(warning
LOCAL_LDLIBS
=
$(LOCAL_LDLIBS))
22
$(warning
LOCAL_LDFLAGS
=
$(LOCAL_LDFLAGS))
23
$(warning
LOCAL_ALLOW_UNDEFINED_SYMBOLS
=
$(LOCAL_ALLOW_UNDEFINED_SYMBOLS))
24
$(warning
LOCAL_ARM_MODE
=
$(LOCAL_ARM_MODE))
25
$(warning
LOCAL_ARM_NEON
=
$(LOCAL_ARM_NEON))
26
$(warning
LOCAL_DISABLE_NO_EXECUTE
=
$(LOCAL_DISABLE_NO_EXECUTE))
27
$(warning
LOCAL_DISABLE_RELRO
=
$(LOCAL_DISABLE_RELRO))
28
$(warning
LOCAL_DISABLE_FORMAT_STRING_CHECKS
=
$(LOCAL_DISABLE_FORMAT_STRING_CHECKS))
29
$(warning
LOCAL_EXPORT_CFLAGS
=
$(LOCAL_EXPORT_CFLAGS))
30
$(warning
LOCAL_EXPORT_CPPFLAGS
=
$(LOCAL_EXPORT_CPPFLAGS))
31
$(warning
LOCAL_EXPORT_C_INCLUDES
=
$(LOCAL_EXPORT_C_INCLUDES))
32
$(warning
LOCAL_EXPORT_LDFLAGS
=
$(LOCAL_EXPORT_LDFLAGS))
33
$(warning
LOCAL_EXPORT_LDLIBS
=
$(LOCAL_EXPORT_LDLIBS))
34
$(warning
LOCAL_SHORT_COMMANDS
=
$(LOCAL_SHORT_COMMANDS))
35
$(warning
LOCAL_THIN_ARCHIVE
=
$(LOCAL_THIN_ARCHIVE))
36
$(warning
LOCAL_FILTER_ASM
=
$(LOCAL_FILTER_ASM))
View
Code
文件PRINT_APPLICATION_VARIABLE.mk内容如下：
1
$(warning
APP_PROJECT_PATH
=
$(APP_PROJECT_PATH))
2
$(warning
APP_MODULES
=
$(APP_MODULES))
3
$(warning
APP_OPTIM
=
$(APP_OPTIM))
4
$(warning
APP_CFLAGS
=
$(APP_CFLAGS))
5
$(warning
APP_CXXFLAGS
=
$(APP_CXXFLAGS))
6
$(warning
APP_CPPFLAGS
=
$(APP_CPPFLAGS))
7
$(warning
APP_LDFLAGS
=
$(APP_LDFLAGS))
8
$(warning
APP_BUILD_SCRIPT
=
$(APP_BUILD_SCRIPT))
9
$(warning
APP_ABI
=
$(APP_ABI))
10
$(warning
APP_PLATFORM
=
$(APP_PLATFORM))
11
$(warning
APP_STL
=
$(APP_STL))
12
$(warning
APP_GNUSTL_FORCE_CPP_FEATURES
=
$(APP_GNUSTL_FORCE_CPP_FEATURES))
13
$(warning
APP_SHORT_COMMANDS
=
$(APP_SHORT_COMMANDS))
14
$(warning
NDK_TOOLCHAIN_VERSION
=
$(NDK_TOOLCHAIN_VERSION))
15
$(warning
APP_PIE
=
$(APP_PIE))
16
$(warning
APP_THIN_ARCHIVE
=
$(APP_THIN_ARCHIVE))
View
Code

Ⅲ android mk文件怎么加混淆

针对android 选择user版本进行编译的时候，会出现proguard错误，我们需要知道的事情

1.proguard是做什么的，他的作用是将java代码进行混淆的工具

2.因为proguard是混淆工具，所以android的mk文件也对其支持为两种方式：

1.指定不需要混淆的native方法与变量的proguard.flags文件
如：LOCAL_PROGUARD_FLAG_FILES := proguard.flags

2.制定编译的工程，不要使用代码混淆的工具进行代码混淆
如：LOCAL_PROGUARD_ENABLED := disabled
3.不设置，默认使用LOCAL_PROGUARD_ENABLED := full.即将该工程代码全部混淆

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
在Android项目中用到JNI，当用了proguard后，发现native方法找不到很多变量，原来是被proard优化掉了。所以，在JNI应用中该慎用progurad啊。

解决办法：
1、在Android.mk中加入一行：
LOCAL_PROGUARD_FLAGS := -include $(LOCAL_PATH)/proguard.flags
2、创建proguard.flag文件，里面写入不需要proguard优化的类和方法。例如：

-keep class oms.miracle.mobiletv.broadcast.ServiceContext {
*;
}

我的这个类是和JNI相关的，不想让proguard去优化而引起错误，向上面写就能实现。

----------下面是网上找到的一些proguard的资料，贴出来分享：
ProGuard是一个免费的java类文件压缩,优化,混淆器.它探测并删除没有使用的类,字段,方法和属性.它删除没有用的说明并使用字节码得到最大优化.它使用无意义的名字来重命名类,字段和方法.

ProGuard的使用是为了:

1.创建紧凑的代码文档是为了更快的网络传输,快速装载和更小的内存占用.
2.创建的程序和程序库很难使用反向工程.
3.所以它能删除来自源文件中的没有调用的代码
4.充分利用java6的快速加载的优点来提前检测和返回java6中存在的类文件.

参数：

-include {filename} 从给定的文件中读取配置参数

-basedirectory {directoryname} 指定基础目录为以后相对的档案名称

-injars {class_path} 指定要处理的应用程序jar,war,ear和目录

-outjars {class_path} 指定处理完后要输出的jar,war,ear和目录的名称

-libraryjars {classpath} 指定要处理的应用程序jar,war,ear和目录所需要的程序库文件

- 指定不去忽略非公共的库类。

- 指定不去忽略包可见的库类的成员。

保留选项
-keep {Modifier} {class_specification} 保护指定的类文件和类的成员

-keepclassmembers {modifier} {class_specification} 保护指定类的成员，如果此类受到保护他们会保护的更好

-keepclasseswithmembers {class_specification} 保护指定的类和类的成员，但条件是所有指定的类和类成员是要存在。

-keepnames {class_specification} 保护指定的类和类的成员的名称（如果他们不会压缩步骤中删除）

-keepclassmembernames {class_specification} 保护指定的类的成员的名称（如果他们不会压缩步骤中删除）

-keepclasseswithmembernames {class_specification} 保护指定的类和类的成员的名称，如果所有指定的类成员出席（在压缩步骤之后）

-printseeds {filename} 列出类和类的成员-keep选项的清单，标准输出到给定的文件

Ⅳ Android.mk 的一个问题

如果common.mk在之前有被调用到的话，直接把MY_DEBUG_OPEN抛出来。或者你为什么不定义在这个makefile里面。

include $(LOCAL_PATH)/../common.mk
makefile文件里面应该不支持这种写法。

Ⅳ android.mk文件怎么写

一个Android.mk file用来向编译系统描述你的源代码。具体来说：该文件是GNU Makefile的一小部分，会被编译系统解析一次或多次。你可以在每一个Android.mk file中定义一个或多个模块，你也可以在几个模块中使用同一个源代码文件。编译系统为你处理许多细节问题。例如，你不需要在你的Android.mk中列出头文件和依赖文件。NDK编译系统将会为你自动处理这些问题。这也意味着，在升级NDK后，你应该得到新的toolchain/platform支持，而且不需要改变你的Android.mk文件。
先看一个简单的例子：一个简单的"hello world"，比如下面的文件：
sources/helloworld/helloworld.c
sources/helloworld/Android.mk
相应的Android.mk文件会象下面这样：
---------- cut here ------------------
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE
:= helloworld
LOCAL_SRC_FILES := helloworld.c
include $(BUILD_SHARED_LIBRARY)
---------- cut here ------------------
我们来解释一下这几行代码：
LOCAL_PATH := $(call my-dir)
一个Android.mk file首先必须定义好LOCAL_PATH变量。它用于在开发树中查找源文件。在这个例子中，宏函数’my-dir’, 由编译系统提供，用于返回当前路径（即包含Android.mk file文件的目录）。
include $( CLEAR_VARS)
CLEAR_VARS由编译系统提供，指定让GNU MAKEFILE为你清除许多LOCAL_XXX变量（例如 LOCAL_MODULE, LOCAL_SRC_FILES, LOCAL_STATIC_LIBRARIES, 等等...),除LOCAL_PATH 。这是必要的，因为所有的编译控制文件都在同一个GNU MAKE执行环境中，所有的变量都是全局的。
LOCAL_MODULE := helloworld
LOCAL_MODULE变量必须定义，以标识你在Android.mk文件中描述的每个模块。名称必须是唯一的，而且不包含任何空格。注意编译系统会自动产生合适的前缀和后缀，换句话说，一个被命名为'foo'的共享库模块，将会生成'libfoo.so'文件。
LOCAL_SRC_FILES := helloworld.c
LOCAL_SRC_FILES变量必须包含将要编译打包进模块中的C或C++源代码文件。注意，你不用在这里列出头文件和包含文件，因为编译系统将会自动为你找出依赖型的文件；仅仅列出直接传递给编译器的源代码文件就好。

在Android中增加本地程序或者库，这些程序和库与其所载路径没有任何关系，只和它们的Android.mk文件有关系。Android.mk和普通的Makefile有所不同，它具有统一的写法，主要包含一些系统公共的宏。
在一个Android.mk中可以生成多个可执行程序、动态库和静态库。
1，编译应用程序的模板：
#Test Exe
LOCAL_PATH := $(call my-dir)
#include $(CLEAR_VARS)
LOCAL_SRC_FILES:= main.c
LOCAL_MODULE:= test_exe
#LOCAL_C_INCLUDES :=
#LOCAL_STATIC_LIBRARIES :=
#LOCAL_SHARED_LIBRARIES :=
include $(BUILD_EXECUTABLE)
（菜鸟级别解释：:=是赋值的意思，$是引用某变量的值）LOCAL_SRC_FILES中加入源文件路径，LOCAL_C_INCLUDES 中加入所需要包含的头文件路径，LOCAL_STATIC_LIBRARIES加入所需要链接的静态库（*.a）的名称，LOCAL_SHARED_LIBRARIES中加入所需要链接的动态库（*.so）的名称，LOCAL_MODULE表示模块最终的名称，BUILD_EXECUTABLE表示以一个可执行程序的方式进行编译。
2，编译静态库的模板：
#Test Static Lib
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_SRC_FILES:= /
helloworld.c
LOCAL_MODULE:= libtest_static
#LOCAL_C_INCLUDES :=
#LOCAL_STATIC_LIBRARIES :=
#LOCAL_SHARED_LIBRARIES :=
include $(BUILD_STATIC_LIBRARY)
一般的和上面相似，BUILD_STATIC_LIBRARY表示编译一个静态库。
3，编译动态库的模板：
#Test Shared Lib
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_SRC_FILES:= /
helloworld.c
LOCAL_MODULE:= libtest_shared
TARGET_PRELINK_MODULES := false
#LOCAL_C_INCLUDES :=
#LOCAL_STATIC_LIBRARIES :=
#LOCAL_SHARED_LIBRARIES :=
include $(BUILD_SHARED_LIBRARY)
一般的和上面相似，BUILD_SHARED_LIBRARY表示编译一个静态库。
以上三者的生成结果分别在如下，generic依具体target会变：
out/target/proct/generic/obj/EXECUTABLE
out/target/proct/generic/obj/STATIC_LIBRARY
out/target/proct/generic/obj/SHARED_LIBRARY
每个模块的目标文件夹分别为：
可执行程序：XXX_intermediates
静态库： XXX_static_intermediates
动态库： XXX_shared_intermediates
另外，在Android.mk文件中，还可以指定最后的目标安装路径，用LOCAL_MODULE_PATH和LOCAL_UNSTRIPPED_PATH来指定。不同的文件系统路径用以下的宏进行选择：
TARGET_ROOT_OUT：表示根文件系统。
TARGET_OUT：表示system文件系统。
TARGET_OUT_DATA：表示data文件系统。
用法如：
CAL_MODULE_PATH:=$(TARGET_ROOT_OUT)

Ⅵ 如何自动设好 Android.mk 的 LOCAL

最简单的方式就是调用shell外部命令。首先咱们指定要搜索的源文件根目录，设为SRC_ROOT这个变量。LOCAL_C_INCLUDES变量直接就是用find <path> -type d命令去搜索根目录下的目录。LOCAL_SRC_FILES稍微复杂一些，首先咱们先用find <path> -type f得到所有的普通文件路径，再指定源代码文件名的匹配模式（例如咱用的是c++，所以咱指定了变量SRC_SUFFIX存放一般c++源代码文件的后缀名），用filter命令筛选出所有的源代码文件路径。

完整的代码如下：

# WARNING: Shell command is used, it is only works on a UNIX-like OS.
# Replace it with Makefile rules if you want to run on Windows.
SRC_SUFFIX := *.cpp *.c
SRC_ROOT := $(LOCAL_PATH)/../../Classes
ALL_FILES := $(shell find $(SRC_ROOT) -type f)
SRC_FILES := $(filter $(subst *,%,$(SRC\_SUFFIX)),$(ALL_FILES))
LOCAL_SRC_FILES := hellocpp/main.cpp
LOCAL_SRC_FILES += $(SRC\_FILES:$(LOCAL_PATH)/%=%)

SRC_DIRS := $(shell find $(SRC_ROOT) -type d)
LOCAL_C_INCLUDES := $(SRC_DIRS)

Ⅶ android studio怎么创建ndkclass.c和android.mk文件

Android.mk文件首先需要指定LOCAL_PATH变量，用于查找源文件,宏函数’my-dir’, 由编译系统提供。由于一般情况下Android.mk和需要编译的源文件在同一目录下，所以定义成如下形式：
LOCAL_PATH:=$(call my-dir)
上面的语句的意思是 将LOCAL_PATH变量定义成 本文件所在 目录路径。
一个 Android.mk中 可以 定义 多个编译模块，每个编译模块 都是 以include $(CLEAR_VARS)开始
以include $(BUILD_XXX)结束

相关链接：http://blog.csdn.net/wh_19910525/article/details/7518190

Ⅷ 如何让编译器架构Android.mk动态

Android.mk文件用来告知NDK Build 系统关于Source的信息。 Android.mk将是GNU Makefile的一部分，且将被Build System解析一次或多次。
所以，请尽量少的在Android.mk中声明变量，也不要假定任何东西不会在解析过程中定义。

Android.mk文件语法允许我们将Source打包成一个"moles". moles可以是：
静态库
动态库。

只有动态库可以被 install/到应用程序包(APK). 静态库则可以被链接入动态库。
可以在一个Android.mk中定义一个或多个moles. 也可以将同一份source 加进多个moles.

Build System帮我们处理了很多细节而不需要我们再关心。例如：你不需要在Android.mk中列出头文件和外部依赖文件。
NDK Build System自动帮我们提供这些信息。这也意味着，当用户升级NDK后，你将可以受益于新的toolchain/platform而不必再去修改Android.mk.

1. Android.mk语法：
首先看一个最简单的Android.mk的例子：
LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)

LOCAL_MODULE := hello-jni
LOCAL_SRC_FILES := hello-jni.c

include $(BUILD_SHARED_LIBRARY)
讲解如下：
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_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可执行程序

2. NDK Build System变量：
NDK Build System 保留以下变量名：
以LOCAL_ 为开头的
以PRIVATE_ ,NDK_ 或者APP_ 开头的名字。
小写字母名字：如my-dir

如果想要定义自己在Android.mk中使用的变量名，建议添加 MY＿前缀。

2.1: NDK提供的变量：
此类GNU Make变量是NDK Build System在解析Android.mk之前就定义好了的。
2.1.1：CLEAR_VARS：

指向一个编译脚本。必须在新模块前包含之。
include $(CLEAR_VARS)
2.1.2：BUILD_SHARED_LIBRARY：
指向一个编译脚本，它收集自从上次调用 include $(CLEAR_VARS) 后的所有LOCAL_XXX信息。
并决定如何将你列出的Source编译成一个动态库。 注意，在包含此文件前，至少应该包含：LOCAL_MODULE and LOCAL_SRC_FILES 例如：
include $(BUILD_SHARED_LIBRARY)

2.1.3：BUILD_STATIC_LIBRARY：
与前面类似，它也指向一个编译脚本，
收集自从上次调用 include $(CLEAR_VARS) 后的所有LOCAL_XXX信息。
并决定如何将你列出的Source编译成一个静态库。 静态库不能够加入到Project 或者APK中。但它可以用来生成动态库。
LOCAL_STATIC_LIBRARIES and LOCAL_WHOLE_STATIC_LIBRARIES将描述之。
include $(BUILD_STATIC_LIBRARY)

2.1.4: BUILD_EXECUTABLE:
与前面类似，它也指向一个编译脚本，收集自从上次调用 include $(CLEAR_VARS) 后的所有LOCAL_XXX信息。
并决定如何将你列出的Source编译成一个可执行Native程序。 include $(BUILD_EXECUTABLE)

2.1.5：PREBUILT_SHARED_LIBRARY：
把这个共享库声明为 “一个” 独立的模块。
指向一个build 脚本，用来指定一个预先编译好多动态库。 与BUILD_SHARED_LIBRARY and BUILD_STATIC_LIBRARY不同，
此时模块的LOCAL_SRC_FILES应该被指定为一个预先编译好的动态库，而非source file. LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)
LOCAL_MODULE := foo-prebuilt # 模块名
LOCAL_SRC_FILES := libfoo.so # 模块的文件路径（相对于 LOCAL_PATH）

include $(PREBUILT_SHARED_LIBRARY) # 注意这里不是 BUILD_SHARED_LIBRARY

这个共享库将被拷贝到 $PROJECT/obj/local 和 $PROJECT/libs/<abi> (stripped) 主要是用在将已经编译好的第三方库
使用在本Android Project中。为什么不直接将其COPY到libs/armabi目录呢？因为这样做缺陷很多。下一节再详细说明。

2.1.6: PREBUILT_STATIC_LIBRARY:预先编译的静态库。 同上。

2.1.7: TARGET_ARCH: 目标CPU架构名。如果为“arm” 则声称ARM兼容的指令。与CPU架构版本无关。

2.1.8: TARGET_PLATFORM: 目标的名字。

2.1.9：TARGET_ARCH_ABI
Name of the target CPU+ABI
armeabi For ARMv5TE armeabi-v7a
2.1.10：TARGET_ABI

2.2: NDK提供的功能宏：
GNUMake 提供的功能宏，只有通过类似： $(call function) 的方式来得到其值，它将返回文本化的信息。

2.2.1: my-dir: $(call my-dir):
返回最近一次include的Makefile的路径。通常返回Android.mk所在的路径。它用来作为Android.mk的开头来定义LOCAL_PATH. LOCAL_PATH := $(call my-dir)
请注意：返回的是最近一次include的Makefile的路径。所以在Include其它Makefile后，再调用$(call my-dir)会返回其它Android.mk 所在路径。 例如：
LOCAL_PATH := $(call my-dir) declare one mole include $(LOCAL_PATH)/foo/Android.mk LOCAL_PATH := $(call my-dir) declare another mole
则第二次返回的LOCAL_PATH为：$PATH/foo。 而非$PATH.

2.2.2: all-subdir-makefiles:
返回一个列表，包含'my-dir'中所有子目录中的Android.mk。
例如： 结构如下： sources/foo/Android.mk sources/foo/lib1/Android.mk sources/foo/lib2/Android.mk
在If sources/foo/Android.mk 中， include $(call all-subdir-makefiles) 那则自动include 了sources/foo/lib1/Android.mk and sources/foo/lib2/Android.mk。

2.2.3：this-makefile：
当前Makefile的路径。

2.2.4：parent-makefile：
返回include tree中父Makefile 路径。 也就是include 当前Makefile的Makefile Path。

2.2.5：import-mole：
允许寻找并inport其它moles到本Android.mk中来。 它会从NDK_MODULE_PATH寻找指定的模块名。 $(call import-mole,<name>)
2.3: 模块描述变量：
此类变量用来给Build System描述模块信息。在'include $(CLEAR_VARS)' 和 'include $(BUILD_XXXXX)'之间。必须定义此类变量。 include $(CLEAR_VARS) script用来清空这些变量。

include $(BUILD_XXXXX)收集和使用这些变量。

2.3.1: LOCAL_PATH:
这个值用来给定当前目录。必须在Android.mk的开是位置定义之。
例如： LOCAL_PATH := $(call my-dir) LOCAL_PATH不会被include $(CLEAR_VARS) 清理。

2.3.2: LOCAL_MODULE:
moles名。在include $(BUILD_XXXXX)之前，必须定义这个变量。此变量必须唯一且不能有空格。
通常，由此变量名决定最终生成的目标文件名。

2.3.3: LOCAL_MODULE_FILENAME:
可选。用来override LOCAL_MODULE. 即允许用户重新定义最终生成的目标文件名。 LOCAL_MODULE := foo-version-1 LOCAL_MODULE_FILENAME := libfoo
2.3.4：LOCAL_SRC_FILES：
为Build Moles而提供的Source 文件列表。不需要列出依赖文件。 注意：文件相对于LOCAL_PATH存放，
且可以提供相对路径。 例如： LOCAL_SRC_FILES := foo.c \ toto/bar.c
2.3.5: LOCAL_CPP_EXTENSION:
指出C++ 扩展名。(可选) LOCAL_CPP_EXTENSION := .cxx 从NDK R7后，可以写多个：
LOCAL_CPP_EXTENSION := .cxx .cpp .cc

2.3.6：LOCAL_CPP_FEATURES：
可选。用来指定C++ features。 LOCAL_CPP_FEATURES := rtti
LOCAL_CPP_FEATURES := exceptions

2.3.7：LOCAL_C_INCLUDES：
一个可选的path列表。相对于NDK ROOT 目录。编译时，将会把这些目录附上。 LOCAL_C_INCLUDES := sources/foo LOCAL_C_INCLUDES := $(LOCAL_PATH)/../foo
2.3.8: LOCAL_CFLAGS:
一个可选的设置，在编译C/C++ source 时添加如Flags。
用来附加编译选项。 注意：不要尝试在此处修改编译的优化选项和Debug等级。它会通过您Application.mk中的信息自动指定。
也可以指定include 目录通过：LOCAL_CFLAGS += -I<path>。 这个方法比使用LOCAL_C_INCLUDES要好。因为这样也可以被ndk-debug使用。

2.3.9: LOCAL_CXXFLAGS: LOCAL_CPPFLAGS的别名。
2.3.10: LOCAL_CPPFLAGS:
C++ Source 编译时添加的C Flags。这些Flags将出现在LOCAL_CFLAGS flags 的后面。

2.3.11: LOCAL_STATIC_LIBRARIES:
要链接到本模块的静态库list。(built with BUILD_STATIC_LIBRARY)

2.3.12: LOCAL_SHARED_LIBRARIES:
要链接到本模块的动态库。

2.3.13：LOCAL_WHOLE_STATIC_LIBRARIES：

静态库全链接。 不同于LOCAL_STATIC_LIBRARIES，类似于使用--whole-archive

2.3.14：LOCAL_LDLIBS：

linker flags。 可以用它来添加系统库。 如 -lz: LOCAL_LDLIBS := -lz

2.3.15: LOCAL_ALLOW_UNDEFINED_SYMBOLS:

2.3.16: LOCAL_ARM_MODE:
缺省模式下，ARM目标代码被编译为thumb模式。每个指令16位。如果指定此变量为：arm。 则指令为32位。 LOCAL_ARM_MODE := arm 其实也可以指定某一个或者某几个文件的ARM指令模式。
2.3.17: LOCAL_ARM_NEON:
设置为true时，会讲浮点编译成neon指令。这会极大地加快浮点运算(前提是硬件支持)
只有targeting 为 'armeabi-v7a'时才可以。

2.3.18：LOCAL_DISABLE_NO_EXECUTE：

2.3.19: LOCAL_EXPORT_CFLAGS:
定义这个变量用来记录C/C++编译器标志集合，
并且会被添加到其他任何以LOCAL_STATIC_LIBRARIES和LOCAL_SHARED_LIBRARIES的模块的LOCAL_CFLAGS定义中 LOCAL_SRC_FILES := foo.c bar.c.arm
注意：此处NDK版本为NDK R7C.（不同NDK版本，ndk-build所产生的Makefile并不完全相同）