Detailed Instructions

The steps below describe how to configure makefiles for new mobile devices and products running Android.

1. Create a company directory in //vendor/.
   

     mkdir vendor/<company_name>

2. Create a products directory beneath the company directory you created in step 1.
   

     mkdir vendor/<company_name>/products/

3. Create a product-specific makefile, called vendor/<company_name>/products/<first_product_name>.mk, that includes at least the following code:
   

     $(call inherit-product, $(SRC_TARGET_DIR)/product/generic.mk)
     #
     # Overrides
     PRODUCT_NAME := <first_product_name>
     PRODUCT_DEVICE := <board_name>

4. Additional product-specific variables can be added to this Product Definition file.
5. In the products directory, create an AndroidProducts.mk file that point to (and is responsible for finding) the individual product make files.
   

     #
     # This file should set PRODUCT_MAKEFILES to a list of product makefiles
     # to expose to the build system.  LOCAL_DIR will already be set to
     # the directory containing this file. 
     #
     # This file may not rely on the value of any variable other than
     # LOCAL_DIR; do not use any conditionals, and do not look up the
     # value of any variable that isn't set in this file or in a file that
     # it includes.
     #
     
     PRODUCT_MAKEFILES := \
       $(LOCAL_DIR)/first_product_name.mk \

6. Create a board-specific directory beneath your company directory that matches the PRODUCT_DEVICE variable <board_name> referenced in the product-specific make file above. This will include a make file that gets accessed by any product using this board.
   

     mkdir vendor/<company_name>/<board_name>

7. Create a BoardConfig.mk file in the directory created in the previous step (vendor/<company_name>/<board_name>). 
   

     # These definitions override the defaults in config/config.make for <board_name>
     #
     # TARGET_NO_BOOTLOADER := false
     # TARGET_HARDWARE_3D := false 
     #
     TARGET_USE_GENERIC_AUDIO := true

8. If you wish to modify system properties, create a system.prop file in your <board_name> directory(vendor/<company_name>/<board_name>).
   

     # system.prop for 
     # This overrides settings in the products/generic/system.prop file
     #
     # rild.libpath=/system/lib/libreference-ril.so
     # rild.libargs=-d /dev/ttyS0

9. Add a pointer to <second_product_name>.mk within products/AndroidProducts.mk.
   

     PRODUCT_MAKEFILES := \
       $(LOCAL_DIR)/first_product_name.mk \
       $(LOCAL_DIR)/second_product_name.mk

10. An Android.mk file must be included in vendor/<company_name>/<board_name> with at least the following code:
    

      # make file for new hardware  from 
      #
      LOCAL_PATH := $(call my-dir)
      #
      # this is here to use the pre-built kernel
      ifeq ($(TARGET_PREBUILT_KERNEL),)
      TARGET_PREBUILT_KERNEL := $(LOCAL_PATH)/kernel
      endif
      #
      file := $(INSTALLED_KERNEL_TARGET)
      ALL_PREBUILT += $(file)
      $(file): $(TARGET_PREBUILT_KERNEL) | $(ACP)
    		$(transform-prebuilt-to-target)
      #
      # no boot loader, so we don't need any of that stuff..  
      #
      LOCAL_PATH := vendor/<company_name>/<board_name>
      #
      include $(CLEAR_VARS)
      #
      # include more board specific stuff here? Such as Audio parameters.      
      #

11. To create a second product for the same board, create a second product-specific make file called vendor/company_name/products/<second_product_name>.mkthat includes:
    

      $(call inherit-product, $(SRC_TARGET_DIR)/product/generic.mk)
      #
      # Overrides
      PRODUCT_NAME := <second_product_name>
      PRODUCT_DEVICE := <board_name>

By now, you should have two new products, called <first_product_name> and <second_product_name> associated with <company_name>. To verify that a product is properly configured (<first_product_name>, for example), execute the following:

  . build/envsetup.sh
  make PRODUCT-<first_product_name>-user

You should find new build binaries located in /out/target/product/<board_name>.

New Product File Tree

The file tree below illustrates what your own system should look like after completing the steps above.

• <company_name>
  • <board_name>
    • Android.mk
    • product_config.mk
    • system.prop
  • products
    • AndroidProducts.mk
    • <first_product_name>.mk
    • <second_product_name>.mk

Product Definition Files

Product-specific variables are defined in product definition files. A product definition file can inherit from other product definition files, thus reducing the need to copy and simplifying maintenance.

Variables maintained in a product definition files include:

The snippet below illustrates a typical product definition file.

$(call inherit-product, build/target/product/generic.mk)

#Overrides
PRODUCT_NAME := MyDevice
PRODUCT_MANUFACTURER := acme
PRODUCT_BRAND := acme_us
PRODUCT_LOCALES := en_GB es_ES fr_FR
PRODUCT_PACKAGE_OVERLAYS := vendor/acme/overlay

The Android Build Cookbook offers code snippets to help you quickly implement some common build tasks. For additional instruction, please see the other build documents in this section.

Building a simple APK

  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
   
  # Tell it to build an APK
  include $(BUILD_PACKAGE)

Building a APK that depends on a static .jar file

  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)

Building a APK that should be signed with the platform key

  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)

Building a APK that should be signed with a specific vendor key

  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 := vendor/example/certs/app
   
  # Tell it to build an APK
  include $(BUILD_PACKAGE)

Adding a prebuilt APK

  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)

Adding a Static Java Library

  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)

Android.mk Variables

These are the variables that you'll commonly see in Android.mk files, listed alphabetically. First, a note on the variable naming:

• LOCAL_ - These variables are set per-module. They are cleared by the include $(CLEAR_VARS) line, so you can rely on them being empty after including that file. Most of the variables you'll use in most modules are LOCAL_ variables.
• PRIVATE_ - These variables are make-target-specific variables. That means they're only usable within the commands for that module. It also means that they're unlikely to change behind your back from modules that are included after yours. This link to the make documentation describes more about target-specific variables.
• HOST_ and TARGET_ - These contain the directories and definitions that are specific to either the host or the target builds. Do not set variables that start with HOST_ or TARGET_ in your makefiles.
• BUILD_ and CLEAR_VARS - These contain the names of well-defined template makefiles to include. Some examples are CLEAR_VARS and BUILD_HOST_PACKAGE.
• Any other name is fair-game for you to use in your Android.mk. However, remember that this is a non-recursive build system, so it is possible that your variable will be changed by another Android.mk included later, and be different when the commands for your rule / module are executed.