Android. mk usage in Android

An android. mk file is used to describe your source code to the compilation system. Specifically, this file is a small part of GNU makefile and will be parsed once or multiple times by the compilation system. You can define one or more modules in each android. mk file. You can also use the same source code file in several modules. The compilation system handles many details for you. For example, you do not need to list header files and dependent files in your android. mk file. The ndk compilation system automatically handles these problems for you. This also means that after you upgrade the ndk, you should get the new toolchain/platform support and do not need to change your android. mk file. Let's take a look at a simple example: A simple "Hello World", such as the following file: sources/helloworld. c sources/helloworld/android. MK corresponding android. the MK file will look like the following: ---------- cut here ---------------- local_path :=$ (call my-DIR) include $ (clear_vars) local_module: = helloworldlocal_src_files: = helloworld. cinclude $ (build_shared_library) ---------- cut here ------------------ Let's explain these lines of code: local_path :=$ (call my-DIR) an android. MK file must first define L Ocal_path variable. It is used to search for source files in the Development tree. In this example, the macro function 'my-dir' is provided by the compilation system and used to return the current path (that is, the directory containing the Android. mk file ).
Include $ (clear_vars) clear_vars is provided by the compilation system, specifying that GNU makefile clears many local_xxx variables (such as local_module, local_src_files, local_static_libraries, etc. ..) for you, except local_path. This is necessary because all the compilation control files are in the same GNU make execution environment, and all the variables are global.
Local_module: = The helloworldlocal_module variable must be defined to identify each module you describe in the android. mk file. The name must be unique and contain no spaces. Note that the compilation system automatically generates the appropriate prefix and suffix. In other words, a shared library module named 'foo' will generate the 'libfoo. so' file.
Local_src_files: = helloworld. c local_src_files must contain the C or C ++ source code files to be compiled and packaged into the module. Note that you do not need to list header files and contained files here, because the compilation system will automatically find the dependent files for you; just list the source code files directly transmitted to the compiler. Add local programs or libraries in Android. These programs and libraries have nothing to do with their paths, but only with their android. mk files. Android. mk is different from a general makefile. It has a unified Writing Method and mainly contains some common macros of the system. Multiple executable programs, dynamic libraries, and static libraries can be generated in an android. mk file. 1. Compile the Application Template: # 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) (cainiao-level explanation: = indicates the value assignment, $ is the value of a variable.) Add the source file path to local_src_files, add the path of the header file to be included in local_c_des des, and add local_static_libraries to the static library to be linked (*. a) Name. Add the dynamic library (*. so) Name, local _ Module indicates the final name of the module, and build_executable indicates compiling in an executable program. 2. Compile the static library template: # 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) is similar to the above. build_static_library indicates compiling a static library. 3. Compile the dynamic library template: # 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: = # region: = include $ (build_shared_library) is generally similar to the above. build_shared_library indicates compiling a static library. The above three generation results are as follows, and the generic changes according to the specific target: out/target/product/generic/obj/executableout/target/product/generic/obj/static_libraryout/target/product/generic/obj/shared_library the target folders of each module are: executable program: xxx_intermediates static library: xxx_static_intermediates dynamic library: xxx_shared_intermediates in Android. in the MK file, you can also specify the final target installation path, which is specified using local_module_path and local_unstripped_path. Use the following macro to select different file system paths: target_root_out: indicates the root file system. Target_out: indicates the system file system. Target_out_data: indicates the data file system. Usage example: cal_module_path: = $ (target_root_out)