Android Car Automotive Development - Learn Android Native Services

Master Android Native Services for Android Car Automotive Development.

Learn to create Android Native Services from scratch, starting with Stable AIDL creation, building, and enablement, native service creation based on the AIDL, native service configuration, native service building, native service security, client library and tests for the native service focusing on the newest versions of Android 14 and 15.

This book has a total of 13 main chapters and many subchapters designed to help you master the AOSP Automotive Native Services from the basics to the interesting and complex details.

Includes a step-by-step guide to setting up the AOSP Car Emulator environment for running the provided example code.

Includes example code that is ready to be run in the AOSP Car Emulator.

A Discord link is included so I can directly assist you with any issues you might encounter.

Chapter Overview

1. Stable AIDL interface creation for Native Services

Create Stable AIDL interfaces for Native Services (C++) in Android to guarantee backward compatible IPC between independently updated components. Define your interface methods and types using standard AIDL syntax within .aidl files, just as you would for Java services.

2. Stable AIDL interface building for Native Services

Within the Soong build system, use the aidl interface module type, crucially specifying backend to trigger C++ stub code generation. Your native C++ service implementation will then inherit from and implement the generated server-side class. Finally, ensure long-term API stability by managing explicit interface versioning within the aidl interface module definition.

3. Stable AIDL interface enablement for Native Services

Enable Stable AIDL for Native Services in Android to achieve reliable, backward-compatible C++ Inter-Process Communication (IPC). Although the interface contract is defined using standard AIDL syntax in .aidl files, the core enablement happens via build system configuration. Learn how the build system enables the Stable AIDL to be visible in the entire system to facilitate IPC.

4. Native Service Creation - The Header

Creating an Android Native Service requires a C++ header file that defines the service's class structure. This service class must typically inherit from the relevant Binder base class, such as the auto-generated interface from the previously created AIDL interface. Within this header, you will declare the service methods which correspond to the functions defined in your AIDL contract.

This guide uses code examples to teach native service header creation from scratch, ensuring you understand the required inheritance from AIDL-generated code.

5. Native Service Creation - The Source Files

The Native Service source file is where you write the core C++ implementation for the service defined in your header. You must include required header files, typically both your service's custom header and the relevant AIDL-generated header. Within this source file, you implement the inherited virtual methods corresponding to your AIDL interface, providing the actual service logic. This is also the place to implement other service-specific functionality and Binder logic. Also, this is where you register the native service to Android ServiceManager for discoverability across the system.

Follow the book's step-by-step examples and explanations to learn key aspects of native services: implementing core functions, receiving and processing IPC input, and registering the service with the Android system for discoverability, ensuring you understand each concept.

6. Native Service Creation - Manifest and Compatibility Matrix

For low-level Android Native Services, declaration typically occurs in a device-specific VINTF manifest file, not the standard AndroidManifest.xml. This manifest precisely details the interface versions and instance names the device component provides. Concurrently, the Android framework specifies its dependencies in a Framework Compatibility Matrix (FCM). A critical VINTF compatibility check validates the device manifest against the framework matrix before the system boots. This mechanism is fundamental to ensure stability and interoperability, particularly for devices supporting Project Treble, allowing independent framework and vendor updates.

Learn how to create these crucial manifests and compatibility matrices from scratch, using clear explanations and practical examples.

7. Native Service Creation - Service Startup

Android Native Services, such as system daemons, are typically launched by the core Android process during the boot sequence. Configuration and startup logic reside within script files. Within these scripts, each native executable is defined using a specific keyword stanza, specifying its binary path and properties. Various service options configure its execution context, including user/group IDs, process class, and SELinux labels. Services are then usually started automatically based on triggers defined in the script files.

Learn how to configure a native service to launch automatically at Android startup and be available system-wide, using step-by-step explanations and code examples.

8. Native Service Creation - Building the Service

To build an Android Native Service, you primarily interact with the Soong build system. Within an appropriate build script, define your service as a Soong module, usually as a library or as a binary, depending on whether it's a library or standalone executable. Inside the module definition, you must specify source files and link required dependencies. The compilation process for the module or entire system is initiated using build commands like the Android make from the AOSP root directory. Successful compilation produces the final build output, either a shared library or an executable binary, located in the android system image.

Master the process of building native services by learning how to write the necessary build scripts through clear examples and step-by-step instructions.

9. Native Service Creation - SELinux

Securing Android Native Services critically involves SELinux policy development to enforce Mandatory Access Control (MAC). You must define unique SELinux types and process contexts for your service within Type Enforcement policy files. Proper labeling is key, assigning the execution type and the binder context. Specific access permissions are explicitly granted by writing detailed SELinux allow rules within type enforcement files, specifying allowed operations between domains and types.

Find comprehensive coverage of the required SELinux configurations for Native Services within this book, presented with clear explanations and hands-on examples.

10. Creating a Client Library for the Native Service - The Header

The native client library header serves to define the public C++ API that applications will use to interact with your remote Android native service. This header typically needs to include the primary AIDL-generated interface definition header. To make this API usable, the library's build definition must export this client header for inclusion by consuming modules. The goal of this header and its library is to provide simplified client interaction, hiding complex Binder communication details.

Learn to understand and implement the essential client library header file, which enables client access to the native service, using clear explanations and practical code examples.

11. Creating a Client Library for the Native Service - The Source files

The native client library source file contains the C++ implementation of the public client API defined in the corresponding header. It must include the necessary headers, including its own API header and relevant AIDL-generated headers. A primary function within this source is to use the Binder proxy object to connect to the remote service and make the actual IPC calls. Developers implement the public API methods here, often wrapping the underlying Binder transactions with simplified interfaces and error handling.

Master the fundamentals of IPC client-service communication, starting from scratch, using clear step-by-step guidance and illustrative examples.

12. Creating a Client Library for the Native Service - Building

To build a native client library for accessing an Android service, utilize the Soong build system configured through script files. Define your client library module, often as a static or shared library, within an appropriate build script. Inside this definition, specify your client library source files and ensure you link all required dependencies, crucially including the generated AIDL library for the service being accessed. Remember to export the public client API headers using build properties so consuming applications can use them. Finally, compile the client library using standard AOSP build commands, which generates the library file in the build output directory.

Master the process of building client libraries by learning how to write the necessary build scripts through clear examples and step-by-step instructions.

13. Testing the Native Service and Client Library using Test Binaries

Test your Android Native Service and its client library effectively using dedicated native test binaries. Crucially, the test binary must link against the client library to accurately simulate client-side API usage. When executed, the test binary then interacts with the actual running service instance on the device using standard IPC mechanisms. This allows comprehensive validation, helping to verify the client library's API and confirm correct end-to-end client-service communication.

Discover how to properly test native service and client library implementations with the help of clear explanations and examples.