Introduction

Android Automotive OS (AAOS) represents a significant evolution in in-vehicle infotainment systems, providing a full Android experience tailored for the automotive environment. While AAOS offers a robust default user interface, many automotive OEMs and developers require deeply customized UI/UX to differentiate their brand and meet specific driver interaction models. At the heart of this user experience is the launcher – the primary entry point for users to access applications and vehicle functions. This expert-level guide will walk you through the process of integrating a custom launcher into an AAOS AOSP (Android Open Source Project) build, transforming the default interface into a bespoke automotive experience.

By understanding the AOSP build system and the specific mechanisms AAOS uses for launchers, you’ll gain the ability to replace the stock CarLauncher with your own, enabling unparalleled control over the in-car UI/UX.

Understanding the AAOS Launcher Ecosystem

The Default CarLauncher

In a standard AAOS AOSP build, the default launcher is typically found within the AOSP source tree under packages/apps/Car/Launcher. This application serves as the system’s home screen, displaying applications, media controls, and often integrating with car-specific functionalities like climate control or navigation. Like any Android launcher, it’s identified by specific intent filters in its AndroidManifest.xml:

    <activity android:name=".CarLauncher">        <intent-filter>            <action android:name="android.intent.action.MAIN" />            <category android:name="android.intent.category.HOME" />            <category android:name="android.intent.category.DEFAULT" />        </intent-filter>    </activity>

The CATEGORY_HOME and ACTION_MAIN intents are crucial for the Android system to identify an application as a potential home screen. When multiple apps declare these intents, the user is typically prompted to select a default. In the context of an AOSP build, we will explicitly configure the system to use our custom launcher.

Setting Up Your AAOS AOSP Build Environment

Before diving into launcher development, ensure you have a functional AAOS AOSP build environment. This typically involves a Linux-based workstation (Ubuntu is recommended) with sufficient disk space (200GB+) and RAM (16GB+).

Prerequisites:

• Ubuntu 18.04 LTS or newer (64-bit)
• Java Development Kit (OpenJDK 11 for Android 12+, OpenJDK 8 for older versions)
• Git and Repo tools

Syncing the AOSP Source Code:

First, initialize and synchronize the AOSP source code. Choose an appropriate branch for AAOS, often denoted by tags like android-13.0.0_rXX for Android 13.

mkdir aosp-automotivecd aosp-automotive# Install repo tool if not already presentcurl https://storage.googleapis.com/git-repo-downloads/repo > ~/bin/repochmod a+x ~/bin/repo# Initialize repo with the desired AAOS branchrepo init -u https://android.googlesource.com/platform/manifest -b android-13.0.0_rXX --depth=1# Sync the source coderepo sync -j$(nproc)

Creating Your Custom AAOS Launcher Module

Now, let’s create a new module for your custom launcher within the AOSP source tree. A good practice is to place it under packages/apps/.

1. Project Structure and Manifest

Create a new directory for your launcher, for example, packages/apps/MyCustomLauncher. Inside this directory, you’ll need an AndroidManifest.xml, a src folder for Java code, and a res folder for layouts and resources.

mkdir -p packages/apps/MyCustomLauncher/src/com/example/mycustomlaunchermkdir -p packages/apps/MyCustomLauncher/res/layoutpackages/apps/MyCustomLauncher/res/values

Create packages/apps/MyCustomLauncher/AndroidManifest.xml:

    <?xml version="1.0" encoding="utf-8"?>    <manifest xmlns:android="http://schemas.android.com/apk/res/android"        package="com.example.mycustomlauncher">        <application            android:label="My Custom AAOS Launcher"            android:supportsRtl="true"            android:persistent="true">            <activity android:name=".MyLauncherActivity"                android:launchMode="singleTask"                android:stateNotNeeded="true"                android:theme="@android:style/Theme.NoTitleBar.Fullscreen"                android:clearTaskOnLaunch="true">                <intent-filter>                    <action android:name="android.intent.action.MAIN" />                    <category android:name="android.intent.category.HOME" />                    <category android:name="android.intent.category.DEFAULT" />                </intent-filter>            </activity>        </application>    </manifest>

Note the android:persistent="true" which is often useful for system-level apps like launchers to keep them running in the background.

2. Implementing the Launcher Activity

Create packages/apps/MyCustomLauncher/src/com/example/mycustomlauncher/MyLauncherActivity.java:

    package com.example.mycustomlauncher;    import android.app.Activity;    import android.os.Bundle;    import android.widget.TextView;    public class MyLauncherActivity extends Activity {        @Override        protected void onCreate(Bundle savedInstanceState) {            super.onCreate(savedInstanceState);            // Set the content view from our custom layout            setContentView(R.layout.activity_my_launcher);            // Optional: Add some basic logic or UI updates            TextView welcomeText = findViewById(R.id.welcome_text);            if (welcomeText != null) {                welcomeText.setText("Welcome to Your Custom AAOS!");            }        }    }

3. Basic Layout XML

Create packages/apps/MyCustomLauncher/res/layout/activity_my_launcher.xml:

    <?xml version="1.0" encoding="utf-8"?>    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"        android:orientation="vertical"        android:layout_width="match_parent"        android:layout_height="match_parent"        android:gravity="center"        android:background="#1A237E"> <!-- Deep blue background -->        <TextView            android:id="@+id/welcome_text"            android:layout_width="wrap_content"            android:layout_height="wrap_content"            android:text="My Custom AAOS Launcher"            android:textColor="#FFFFFF"            android:textSize="32sp"            android:textStyle="bold"            android:padding="20dp"/>        <Button            android:layout_width="wrap_content"            android:layout_height="wrap_content"            android:text="Launch Apps (Placeholder)"            android:layout_marginTop="30dp"            android:backgroundTint="#64B5F6"            android:textColor="#FFFFFF"            android:paddingStart="40dp"            android:paddingEnd="40dp"            android:paddingTop="15dp"            android:paddingBottom="15dp"/>    </LinearLayout>

Integrating into the AOSP Build System

For your custom launcher to be built and included in the AAOS image, you need to create an Android.bp file and modify the product’s build configuration.

1. Creating the Android.bp File

Create packages/apps/MyCustomLauncher/Android.bp:

    android_app {        name: "MyCustomLauncher",        srcs: ["src/**/*.java"],        resource_dirs: ["res"],        manifest: "AndroidManifest.xml",        sdk_version: "current",        platform_apis: true, // Required for system apps to use internal APIs        privileged: true,    // Often needed for launchers to interact with system services        system_ext_specific: true, // For apps specific to system_ext partition, common in AAOS        required: ["privapp_whitelist_com.example.mycustomlauncher"], // If using privileged permissions    }    // Optional: Add a privapp-whitelist if your launcher uses privileged permissions    // Create packages/apps/MyCustomLauncher/privapp_whitelist_com.example.mycustomlauncher.xml    // <?xml version="1.0" encoding="utf-8"?>    // <permissions>    //     <privapp-permission android:name="android.permission.BIND_REMOTEVIEWS"/>    // </permissions>

2. Modifying Product Configuration

To ensure your launcher is included in the build and set as the default, you need to edit the relevant .mk files for your AAOS product. For the emulator, this is typically in device/generic/car/common/car.mk or a similar product definition file. You might also need to look at specific device/generic/car/emulator/car_x86_64.mk if building for the emulator.

Locate the section defining PRODUCT_PACKAGES and the default home activity. You’ll want to remove the default CarLauncher and add your MyCustomLauncher. More importantly, you must set the ro.car.default_home_activity property.

In device/generic/car/common/car.mk (or equivalent):

    # Remove the default CarLauncher or ensure it's not the default    # PRODUCT_PACKAGES +=     #     CarLauncher     # Add your custom launcher    PRODUCT_PACKAGES +=         MyCustomLauncher         # Ensure other necessary system packages are here...    # Override the default home activity for the car    PRODUCT_PROPERTY_OVERRIDES +=         ro.car.default_home_activity=com.example.mycustomlauncher/.MyLauncherActivity

It’s also a good idea to ensure that com.example.mycustomlauncher has the necessary permissions. If it’s a privileged app, you might need to add it to PRODUCT_SYSTEM_SERVER_JARS or similar lists depending on its functionality and the AAOS version.

Building and Flashing Your Custom AAOS Image

With your custom launcher integrated into the AOSP build system, it’s time to build the new image and flash it.

1. Build Commands:

Navigate back to the root of your AOSP directory:

source build/envsetup.sh # Set up the build environmentlunch car_x86_64-userdebug # Choose your target (e.g., car_x86_64 for emulator)make -j$(nproc) # Start the build, using all available processor cores

This build process can take a considerable amount of time, from 30 minutes to several hours, depending on your system’s specifications.

2. Flashing to Emulator or Hardware:

For Emulator:

After a successful build, you can launch the emulator directly:

emulator

The emulator should boot, and you should see your custom launcher as the primary interface.

For Physical Device:

Flashing a full AAOS image to a physical head unit requires specific hardware knowledge and usually involves fastboot. The exact steps vary by device, but generally follow this pattern:

# Reboot device into bootloadermodeadb reboot bootloader# Flash the entire image (this will wipe user data)fastboot flashall -w# Reboot devicefastboot reboot

Caution: Flashing a full AOSP image will erase all data on your device. Ensure you have backups if needed.

Testing and Verification

Once your AAOS system boots, verify the following:

• Your custom launcher appears as the home screen.
• Any text or UI elements you added are visible.
• Try pressing the home button; it should return to your launcher.
• Ensure other core system functionalities (e.g., Bluetooth, Wi-Fi, basic apps) are still accessible, either through your launcher or other means (e.g., Settings app).

Advanced Customization and Next Steps

This tutorial provides a foundational understanding. Real-world AAOS launchers often require deeper integration:

Interacting with Car Service APIs:

AAOS provides the Car Service, offering APIs to interact with vehicle-specific hardware and sensors (e.g., climate, radio, gear position, vehicle speed). Your launcher can utilize these APIs to display real-time vehicle data or control functions. You’ll need to declare appropriate permissions (e.g., android.car.permission.CAR_CONTROL_AUDIO_VOLUME) in your manifest.

Theming and UI Integration:

Leverage the Car UI Library (car-ui-lib) provided by AAOS to ensure consistency with Google’s automotive design guidelines, or entirely customize your themes to match brand requirements. This involves using custom layouts, styles, and potentially integrating with other UI frameworks.

Handling Automotive Input:

Consider integrating support for rotary controllers, steering wheel controls, and voice commands. This involves implementing appropriate listeners and handling input events in your launcher’s activities.

Conclusion

Building a custom launcher for Android Automotive OS allows for complete control over the in-car user experience, a critical aspect for brand identity and specific functional requirements. By following this guide, you have successfully set up your AOSP environment, created a basic custom launcher, integrated it into the AAOS build system, and prepared an image for deployment. This hands-on process empowers you to move beyond the default and craft truly unique and tailored automotive infotainment systems, opening doors to sophisticated and specialized UI/UX designs within the AAOS ecosystem.