Introduction: The Power of Custom Android Things Images

Android Things, Google’s embedded operating system built on Android, offers a robust platform for IoT devices. While pre-built images serve many use cases, true power lies in creating custom OS images from source. This advanced capability allows developers to tailor the OS for specific hardware, integrate proprietary applications, optimize performance, and fine-tune security settings, making it indispensable for specialized IoT, automotive, and smart TV projects. This guide will walk you through the comprehensive process of building a custom Android Things image from the ground up, providing expert-level insights and practical commands.

Prerequisites: Setting the Stage

Before diving into the source code, ensure you have the necessary environment and hardware:

Hardware Requirements:

• A powerful Linux machine (Ubuntu 18.04 LTS or 20.04 LTS recommended) with at least 16GB RAM (32GB+ preferred) and 200GB+ free disk space.
• An Android Things compatible development board, such as the NXP i.MX7D Pico or Raspberry Pi 3 (though Google has shifted focus from RPi3 for newer AT builds, NXP is a strong reference).
• USB cables for connecting your development board.

Software Requirements:

• JDK 8 (OpenJDK recommended).
• Essential build tools (Git, cURL, Python, etc.).
• `repo` tool for managing AOSP source.
• `adb` and `fastboot` tools.

Setting Up Your Build Environment

First, prepare your Linux environment:

1. Install Essential Packages:

sudo apt-get update
sudo apt-get install -y git-core gnupg flex bison gperf build-essential zip curl zlib1g-dev gcc-multilib g++-multilib libc6-dev-i386 libncurses5 lib32ncurses5-dev x11proto-core-dev libx11-dev libgl1-mesa-dev libxml2-utils xsltproc unzip mtools u-boot-tools python3

2. Install JDK 8:

sudo apt-get install -y openjdk-8-jdk

Verify installation:

java -version
javac -version

3. Install the `repo` Tool:

The `repo` tool simplifies managing the many Git repositories that make up the Android Open Source Project (AOSP).

mkdir ~/bin
PATH=~/bin:$PATH
curl https://storage.googleapis.com/git-repo-downloads/repo > ~/bin/repo
chmod a+x ~/bin/repo

Downloading the Android Things Source Code

Now, synchronize the vast Android Things source code to your local machine.

1. Initialize the `repo` Client:

Create a working directory and initialize `repo`. For Android Things, you need to specify the correct manifest branch. Google frequently updates these, so refer to the official Android Things documentation for the latest manifest URL and branch, but `iot-release` or a specific API level branch like `android-things-1.0.1` are common.

mkdir android-things-src
cd android-things-src
repo init -u https://android.googlesource.com/platform/manifest -b iot-release -m default.xml

Alternatively, for a specific tag or version:

repo init -u https://android.googlesource.com/platform/manifest -b android-things-1.0.1_r2 -m default.xml

2. Synchronize the Source Code:

This step will download all necessary repositories. It can take several hours depending on your internet connection.

repo sync -j$(nproc)

Understanding the Android Things Build System

The Android Things build system is an extension of AOSP. Key directories include:

• device/google/at/: Contains Android Things specific device configurations.
• device/google/imx7d_pico/: Example device configuration for the NXP i.MX7D Pico.
• vendor/nxp/: Contains NXP proprietary blobs and kernel sources.
• build/: Core build system scripts.

Product definitions in device/*/ define what goes into a specific build, including kernel, bootloader, system images, and pre-installed apps.

Customizing Your Android Things Image

This is where you make the OS truly your own.

1. Adding Custom Applications:

To include your own APKs, place them in the appropriate directory within your device’s product definition. For example, for the i.MX7D Pico:

cd device/google/imx7d_pico/

Edit the imx7d_pico.mk or a related `product.mk` file to include your APK. You’ll typically create a new directory, e.g., apps/, place your APKs there, and then reference them.

# device/google/imx7d_pico/imx7d_pico.mk (example snippet)

PRODUCT_PACKAGES += 
    YourCustomApp.apk 
    AnotherService.apk

PRODUCT_COPY_FILES += 
    device/google/imx7d_pico/apps/YourCustomApp.apk:system/app/YourCustomApp/YourCustomApp.apk 
    device/google/imx7d_pico/apps/AnotherService.apk:system/priv-app/AnotherService/AnotherService.apk

Make sure to sign your APKs or disable signature verification for system apps during development (not recommended for production).

2. Modifying System Properties and Services:

You can adjust system properties via build.prop files or add custom init.rc scripts. These allow you to change boot behavior, set default locales, or enable/disable services.

For example, to add a custom init service:

• Create device/google/imx7d_pico/init.custom.rc
• Add a service entry:

# init.custom.rc
service my_custom_service /system/bin/my_executable
    class main
    user root
    group root
    disabled
    oneshot

• Reference this in your product’s .mk file:

PRODUCT_COPY_FILES += 
    device/google/imx7d_pico/init.custom.rc:system/etc/init/init.custom.rc

3. Kernel Customization (Advanced):

For deep hardware integration, you might need to modify the kernel. This involves:

• Applying patches to the kernel source (usually found in kernel/google/imx7d or similar).
• Modifying device tree overlays (`.dtbo` files) to enable specific peripherals.
• Building custom kernel modules.

This is a complex topic beyond a basic guide but involves navigating to the kernel directory and using standard kernel build procedures after configuring with `make menuconfig`.

Building the Custom Android Things Image

With customizations in place, it’s time to build.

1. Set Up the Build Environment:

source build/envsetup.sh

2. Choose a Target Product:

Use the `lunch` command to select your target. For the NXP i.MX7D Pico, typical targets are:

• aosp_imx7d_pico-userdebug (debugging enabled, suitable for development)
• aosp_imx7d_pico-user (production build)

lunch aosp_imx7d_pico-userdebug

3. Compile the Source Code:

Start the build process. The -j flag specifies the number of parallel jobs; use a value roughly equal to `$(nproc)` for optimal speed.

make -j$(nproc)

This step can take several hours on the first run. Upon successful completion, your generated images will be located in out/target/product/imx7d_pico/.

Flashing the Custom Image to Your Device

Finally, transfer your custom OS to the development board.

1. Enter Bootloader Mode:

Ensure your device is connected via USB. Reboot into bootloader (fastboot) mode:

adb reboot bootloader

2. Flash the Images:

Navigate to your output directory and use `fastboot` to flash each partition. The exact commands might vary slightly based on your board and Android Things version.

cd out/target/product/imx7d_pico/

fastboot flash bootloader bootloader.img
fastboot flash boot boot.img
fastboot flash system system.img
fastboot flash vendor vendor.img
fastboot flash userdata userdata.img
fastboot flash recovery recovery.img
fastboot flash dtbo dtbo.img
fastboot flash vbmeta vbmeta.img
fastboot flash super_empty.img
fastboot flash super super.img # For devices using A/B partitions with dynamic partitions

Note: Some devices might require additional flashing steps, such as updating U-Boot or flashing an entirely new partition table. Always consult your board’s specific flashing instructions.

3. Reboot the Device:

fastboot reboot

Verification

After rebooting, your device should boot into your custom Android Things OS. You can verify your changes:

• Use adb shell to explore the file system and check for your custom apps or modified system files.
• Check system properties with adb shell getprop.
• Observe the boot log for any custom service startup messages.

Conclusion: Empowering Your IoT Vision

Mastering the creation of custom Android Things OS images from source opens up a world of possibilities for IoT, automotive, and smart TV developers. This capability empowers you to precisely control every aspect of your device’s software stack, from embedded applications to core system services and kernel behaviors. While challenging, the ability to build a bespoke Android Things experience is crucial for performance optimization, enhanced security, and seamless hardware integration, enabling you to bring highly specialized and robust embedded solutions to life.