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 the Loc Al_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 Program Or the library. 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 exelocal_path :=$ (call my-DIR) # include $ (clear_vars) local_src_files: = Main. clocal_module: = test_exe # local_c_includes: = # local_static_libraries: = # local_shared_libraries: = include $ (build_executable, $ 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 to be linked in local_shared_libraries (*. so) Name, local_module table The final name of the display module, build_executable, indicates compilation in an executable program.
2. Compile the static library template: # test static liblocal_path :=$ (call my-DIR) include $ (clear_vars) local_src_files: = \ helloworld. clocal_module: = libtest_static # local_c_includes: = # local_static_libraries: = # local_shared_libraries: = include $ (build_static_library)
In general, it is similar to the above. build_static_library indicates compiling a static library.
3. Compile the dynamic library template: # test shared liblocal_path :=$ (call my-DIR) include $ (clear_vars) local_src_files: = \ helloworld. clocal_module: = libraries: = false # local_c_includes: = # local_static_libraries: = # local_shared_libraries: = include $ (build_shared_library) is 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 addition, in the Android. mk file, you can 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)