Libro de cocina para compilación de Android Cree aplicaciones o bibliotecas utilizando el archivo Crear Autor: swetabh suman | Octubre de 2020

Android proporciona varios sistemas de compilación para compilar, implementar y convertir código fuente en código objeto. El que se usa en Android Studio es el sistema de compilación Gradle y el otro que se usa en AOSP para describir recursos y bibliotecas es el archivo Make (Android.mk).

El archivo Android.mk está escrito para describir los recursos del sistema de compilación y las bibliotecas compartidas. Puede definir varios módulos en un Android.mk o puede escribir varios archivos Android.mk, cada uno definiendo un módulo.

El módulo puede ser de uno de los siguientes tipos:

  1. Un programa para Android que se compila y empaqueta para generar un archivo APK.
  2. Programa de biblioteca JAVA, compilado y empaquetado para generar un archivo JAR.
  3. Un programa C / C ++ compilado para generar una aplicación C / C ++ ejecutable.
  4. Biblioteca estática C / C ++, compilando y generando una biblioteca estática C / C ++ y envolviéndola en un archivo .a
  5. Biblioteca compartida C / C ++, compilando y generando una biblioteca compartida C / C ++ y envolviéndola en un archivo .so.

Todo AndroireEl sistema de compilación analiza los archivos .mk antes de que se produzca la compilación. Estos archivos son pequeños Archivo de creación GNU fragmentos que serán analizados por el sistema de ensamblaje más de una vez.

Veamos un fragmento de código para ayudarlo a crear rápidamente tareas comunes, como compilar APK, crear una biblioteca estática o compartida o firmar un APK con una clave de plataforma.

LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)

# Build all java files in the java subdirectory
LOCAL_SRC_FILES := $(call all-subdir-java-files)
LOCAL_RESOURCE_DIR := $(LOCAL_PATH)/res

# Name of the APK to build
LOCAL_PACKAGE_NAME := LocalPackage

# Tell it to build an APK
include $(BUILD_PACKAGE)

Ahora explicaremos estas líneas:

LOCAL_PATH: = $ (llamar a mi directorio)

Android.mk debe comenzar con la definición de la variable LOCAL_PATH. Se utiliza para buscar archivos fuente en el árbol de desarrollo. En este ejemplo, la función de macro ‘my-dir’ proporcionada por el sistema de compilación se utiliza para devolver la ruta del directorio actual (es decir, el directorio que contiene el archivo Android.mk).

incluir $ (CLEAR_VARS)

La variable CLEAR_VARS es un script y se refiere a un Makefile GNU especial que borra todas las variables LOCAL_XXX por usted, como LOCAL_MODULE, LOCAL_SRC_FILES, LOCAL_STATIC_LIBRARIES, etc … No borra LOCAL_PATH. Esto se debe a que todos los archivos de control de ensamblaje se analizan en un solo GNU para ejecutar un contexto de ejecución donde todas las variables son globales.

LOCAL_SRC_FILES: = $ (llamar a todos los archivos subdir-java)

Esto incluye todos los archivos fuente de Java presentes en subdirectorios que el sistema de ensamblaje usa para generar el módulo.

DIRECCIÓN_DE_RECURSOS_LOCAL: = $ (RUTA_LOCAL) / res
Esto incluye archivos de recursos asociados con la aplicación.

LOCAL_PACKAGE_NAME: = LocalPackage

Esta variable le dice al sistema de compilación cuál sería el nombre del módulo que está creando.

incluir $ (BUILD_PACKAGE)

Como CLEAR_VAR, BUILD_PACKAGE también apunta a un script que recopila toda la información que ingresaste en LOCAL_XXX y le dice al sistema de compilación que cree a partir de él y un APK.

  LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)

# List of static libraries to include in the package
LOCAL_STATIC_JAVA_LIBRARIES := static-library

# Build all java files in the java subdirectory
LOCAL_SRC_FILES := $(call all-subdir-java-files)

# Name of the APK to build
LOCAL_PACKAGE_NAME := LocalPackage

# Tell it to build an APK
include $(BUILD_PACKAGE)

LOCAL_STATIC_JAVA_LIBRARIES: = biblioteca estática

Esta variable debe incluir todas las bibliotecas JAVA estáticas en su módulo. Por ejemplo, suponga que desea usar la biblioteca support-v7-appcompact y luego usarla así:
LOCAL_STATIC_JAVA_LIBRARIES + = android-support-v7-appcompat
O, si desea utilizar cualquier biblioteca local que haya creado, siga estos pasos:
LOCAL_STATIC_JAVA_LIBRARIES + = myLib

  LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)

# Build all java files in the java subdirectory
LOCAL_SRC_FILES := $(call all-subdir-java-files)

# Name of the APK to build
LOCAL_PACKAGE_NAME := LocalPackage

LOCAL_CERTIFICATE := platform

# Tell it to build an APK
include $(BUILD_PACKAGE)

LOCAL_CERTIFICATE: = plataforma

Esta variable le dice al sistema de compilación que firme el módulo o APK usando las claves de la plataforma.

LOCAL_CERTIFICATE := vendor/example/certs/app

Aquí todo será igual que arriba, solo LOCAL_CERTIFICATE apuntará al lugar donde están presentes los certificados.

Ahora tiene un APK preparado previamente y desea incluirlo en el árbol de compilación. Veremos cómo hacerlo.

  LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)

# Module name should match apk name to be installed.
LOCAL_MODULE := LocalModuleName
LOCAL_SRC_FILES := $(LOCAL_MODULE).apk
LOCAL_MODULE_CLASS := APPS
LOCAL_MODULE_SUFFIX := $(COMMON_ANDROID_PACKAGE_SUFFIX)

include $(BUILD_PREBUILT)

Aquí, LOCAL_SRC_FILE apuntará a tu APK. LOCAL_MODULE_CLASS ayudará al sistema a determinar la ubicación intermedia del almacén de archivos, como la salida compilada final, ya que APPS será la ubicación intermedia obj / APPS. Necesitamos especificar el tipo de archivo, por ejemplo APPS para archivos apk, SHARED_LIBRARIES para bibliotecas dinámicas, EJECUTABLES para archivos bin, ETC para otros archivos.
Las opciones de LOCAL_MODULE_CLASS son:
LOCAL_MODULE_CLASS: = ETC
LOCAL_MODULE_CLASS: = STATIC_LIBRARIES
LOCAL_MODULE_CLASS: = RENDIMIENTO
LOCAL_MODULE_CLASS: = FAKE
LOCAL_MODULE_CLASS: = JAVA_LIBRARIES
LOCAL_MODULE_CLASS: = SHARED_LIBRARIES
LOCAL_MODULE_CLASS: = APLICACIONES

LOCAL_MODULE_SUFFIX: = $ (COMMON_ANDROID_PACKAGE_SUFFIX)
Esta variable indica la extensión del paquete de destino después de que se compila el enlace. Para archivos .so será .so y para APK será COMMON_ANDROID_PACKAGE_SUFFIX

Incluir $ (BUILD_PREBUILT)
Este es un script que le dice al sistema de compilación que este módulo está precompilado y preprocesado.

LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)

# Build all java files in the java subdirectory
LOCAL_SRC_FILES := $(call all-subdir-java-files)

# Any libraries that this library depends on
LOCAL_JAVA_LIBRARIES := android.test.runner

# The name of the jar file to create
LOCAL_MODULE := sample

# Build a static jar file.
include $(BUILD_STATIC_JAVA_LIBRARY)

LOCAL_JAVA_LIBRARIES: = android.test.runner
Esta variable define cualquier biblioteca de la que depende la biblioteca del edificio actual. En este ejemplo, nuestra biblioteca de muestra depende de la biblioteca JAVA android.test.runner.

incluir $ (BUILD_STATIC_JAVA_LIBRARY)
Este es un script que crea uno estático. Biblioteca JAVA.

LOCAL_PATH:= $(call my-dir)include $(CLEAR_VARS)
LOCAL_MODULE := SampleModule
LOCAL_SRC_FILES := helloworld.cpp CalculateVolume.cpp
LOCAL_MODULE_TAGS := optional
LOCAL_STATIC_LIBRARIES := libutils libcutils liblog libc
include $(BUILD_EXECUTABLE)

LOCAL_STATIC_LIBRARIES: = libutils libcutils liblog libc
Esta variable contiene una lista de bibliotecas estáticas que el módulo requiere para compilar.

incluir $ (BUILD_EXECUTABLE)
Esto le dice al sistema de ensamblaje que cree un objeto ejecutable.

Se refiere al script de ensamblaje, borre todas las variables LOCAL_XXX excepto LOCAL_PATH

BUILD_SHARED_LIBRARY

Se refiere a un script de ensamblaje para compilar el recurso especificado en una biblioteca compartida basada en las variables LOCAL_XXX descritas en el archivo make.

BUILD_STATIC_LIBRARY

Se refiere a un script de ensamblaje para compilar el recurso especificado en una biblioteca estática basada en las variables LOCAL_XXX descritas en el archivo make. incluir $ (BUILD_STATIC_LIBRARY) genera un archivo llamado lib $ (LOCAL_MODULE) .a

BUILD_PREBUILT

Se refiere al script de ensamblaje para incluir módulos precompilados y preprocesados ​​en el sistema de ensamblaje

Una variable opcional que hace referencia a un archivo de código C ++. El valor predeterminado es .cpp, pero puede cambiarlo, por ejemplo:
LOCAL_CPP_EXTENSION: = .cxx

LOCAL_ASSET_FILES

En los archivos Android.mk include $(BUILD_PACKAGE) configúrelo en el conjunto de archivos que desea integrar en su aplicación. Generalmente:

LOCAL_ASSET_FILES += $(call find-subdir-assets)

LOCAL_C_INCLUDES

Directorios adicionales que indican a los compiladores de C / C ++ que incluyan archivos de encabezado. La ruta predeterminada para buscar el archivo de encabezado es el directorio LOCAL_PATH.

Por ejemplo: LOCAL_C_INCLUDES: =
$ (RUTA_LOCAL) / ..
$ (LOCAL_PATH) / include
$ (LOCAL_PATH) /../ btcore / include
$ (RUTA_LOCAL) /../ hci / include
$ (LOCAL_PATH) /../ include
$ (LOCAL_PATH) /../ stack / include
$ (bluetooth_C_INCLUDES)

LOCAL_C_INCLUDES debe establecerse antes de cualquier indicador que contenga LOCAL_CFLAGS / LOCAL_CPPFLAGS.

LOCAL_CFLAGS

Esta es una opción de compilador opcional para usar al compilar archivos de código C. Esto puede ser útil al especificar definiciones de macros, otras opciones de inclusión de ruta o compilación.

Por ejemplo: LOCAL_CFLAGS + = -DANDROID
-Pared
-DLIBUTILS_NATIVE = 1

LOCAL_CPPFLAGS

Igual que LOCAL_CFLAGS, pero aplicable a ambos archivos C / C ++

LOCAL_SHARED_LIBRARIES

Igual que LOCAL_STATIC_LIBRARIES, pero solo incluye bibliotecas compartidas de las que depende el módulo en tiempo de ejecución.

Por ejemplo:
LIBRERÍAS_COMPARTIDAS_LOCALES: =
libutils
libui
libaudio
libexpat
libsgl

LOCAL_CC

Esto se usa si desea configurar un compilador de C diferente al predeterminado.

LOCAL_FORCE_STATIC_EXECUTABLE

Establezca esto en verdadero si desea vincular estáticamente el archivo ejecutable. Esto solo se aplica a los archivos ejecutables que se ejecutan en / sbin en el directorio raíz de su sistema de archivos.

Por ejemplo: LOCAL_FORCE_STATIC_EXECUTABLE: = true

LOCAL_MODULE_TAG

Esta bandera se usa para determinar bajo qué circunstancias se compilará su módulo. Puede ser una prueba / eng / opcional

Por ejemplo:
LOCAL_MODULE_TAGS: = opcional
Medios Compilar este módulo en todas las versiones.
LOCAL_MODULE_TAGS: = Inglés
Esto significa compilar este módulo solo en un entorno técnico / de desarrollo.
Lo mismo va
LOCAL_MODULE_TAGS: = depurar
Medio. compilar solo en un entorno de depuración
LOCAL_MODULE_TAGS: = usuario
Si se requiere una biblioteca o módulo solo en el producto de software final.

LOCAL_PROGUARD_ENABLED

Esto establece el tipo de protección que desea habilitar en su módulo (confusión, optimización o ambos).

Por ejemplo:
LOCAL_PROGUARD_ENABLED: = confusión
o
LOCAL_PROGUARD_ENABLED: = Optimización de desenfoque

LOCAL_PROGUARD_FLAG_FILES

Esto incluye un archivo proguard.

Por ejemplo:
LOCAL_PROGUARD_FLAG_FILES: = proguard.flags

LOCAL_PRIVILEGED_MODULE

Esto es para colocar el apk en la carpeta de ensamblado de la aplicación priv. Puede ser /system / priv-applications / ovendedor / priv-app /

Por ejemplo:
LOCAL_PRIVILEGED_MODULE: = verdadero

LOCAL_VENDOR_MODULE

Esto es para colocar el apk en /proveedor / directorio

Por ejemplo:
LOCAL_VENDOR_MODULE: = verdadero

LOCAL_MULTILIB

Es decir, el sistema de montaje es que el módulo esté limitado a 32 bits o 64 bits, o sea compatible con ambos.

Por ejemplo:
LOCAL_MULTILIB: = 32/64 / OBA

LOCAL_REQUIRED_MODULES

Quiere decirle al sistema de construcción que su módulo necesita construir estas bibliotecas primero.

Por ejemplo:
LOCAL_REQUIRED_MODULES: = SoundRecorder, AndroidLib

LOCAL_OVERRIDES_PACKAGES

Esta variable sobrescribirá el paquete proporcionado con su paquete / módulo actual. Debe ingresar el nombre del módulo que desea sobrescribir. Por ejemplo, está creando su propia aplicación y desea sobrescribir la aplicación launcher3 que ya está presente en el sistema.
Agregue esta marca al archivo Android.mk para asegurarse de que estos paquetes no se agreguen a ninguna versión donde se agregue este paquete.

Úselo así:
LOCAL_OVERRIDES_PACKAGES: = Inicio Launcher2 Launcher3

Las siguientes convocatorias: make installclean al crear un feed para Android. Esto eliminará su directorio de todos los módulos / imágenes antiguos.

Puedes verlo desde eso enlace cómo DeskClock sobrescribe AlarmClock en AOSP.

  1. todos-subdirectorios-makefiles: Esto devuelve una lista de todos los archivos Android.mk en LOCAL_PATH o en el directorio actual.
    Por ejemplo: incluir $ (llamar a all-subdir-makefiles)
  2. todos-makefiles-under: Esto es para incluir todos los archivos make de una ruta determinada en una macro.
    Por ejemplo: incluya $ (llame a all-makefiles-under, $ (LOCAL_PATH))
  3. todos-archivos-java-pod: Esto incluye todos los archivos JAVA presentes en la ubicación dada.
    Por ejemplo: LOCAL_SRC_FILES: = $ (llamar a all-java-files-under, src)
    Donde src es el directorio donde están presentes los archivos Java.
  4. todos-los-archivos-Iaidl-bajo: Esto incluye todos los archivos AIDL presentes en la ubicación indicada.
    Por ejemplo: LOCAL_SRC_FILES: = $ (llamar a todos los archivos de Java-under, src) $ (llamar a todos los archivos de Iaidl-under, src)

El artículo original se publicó en GizmoMind.com. Tú puedes ver enlace.

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *