How to add a custom service for Android

This article explains how to create your own Android service to manage a dedicated hardware resource. It is intended for distribution package users.


1 Prerequisites[edit]

The environment used must be installed using the right Distribution Package for your selected microprocessor device. See Distribution_Package.

To be able to execute following instructions you need to work from your distribution root directory and initialize your environment:

 source build/
 lunch aosp_<BoardId>-userdebug

2 Hardware service[edit]

First of all you need to create your HIDL files to be able to interact with your hardware. They act as the interface between your hardware and Android. You can refer to the HIDL manual [1]. For more information on HAL definition you can refer to the official AOSP documentation[2].

2.1 Creation[edit]

To create your interface you need to create a folder myinterface in source tree path hardware/interfaces. Inside the interfaces folder, create a version folder for your interface like hardware/interfaces/myinterface/1.0/.

2.2 Hardware Interface (HIDL)[edit]

Define as many classes and types you need to be able to interact with your hardware. Those functions must be implemented in your device HAL folder. (See Implement the vendor HAL)


package android.hardware.myinterface@1.0;

interface IMyClass {
    myFunct1() generates (bool ret);
    myFunct2(string name) generates (bool ret, MyType val);


package android.hardware.myinterface@1.0;

struct MyType {
    uint32_t id;
    bool state;

2.3 Generation[edit]


hidl_interface {
    name: "android.hardware.myinterface@1.0",
    root: "android.hardware",
    vndk: {
        enabled: true,
    srcs: [
    interfaces: [
    types: [
    gen_java: true,

2.4 Hash creation[edit]

This step is not required to make it work but it must be done at least once when the interfaces are finalized nearing the end of development. When your interface is done you must execute

hidl-gen -L hash android.hardware.myinterface@1.0 >> hardware/interfaces/current.txt

This adds a specific hash matching your hardware interface. This ensures the use of the appropriate interface by the framework. Do not forget to update the hash if you make changes to the interface.

3 Service (AIDL)[edit]

In order to interact with your hardware from an application you need to add your API on top of the already existing Android API.

3.1 Creation[edit]

To create your API you need to create a "myinterface" subfolder at frameworks/base/core/java/android/.

3.2 Interface (AIDL)[edit]

Create as many classes you need to define your API. All files need to have the .aidl extension. For more information on how to create AIDL files, see[4].


package android.myinterface;

interface IMyClass {
    void myAidlFunct1();

You need then to generate Java classes matching your AIDL files. Those functions will be the ones exposed to the application developer.


package android.myinterface;

import android.util.AndroidException;
import android.util.Log;
import android.util.Slog;
import android.content.Context;
import android.os.RemoteException;

public class MyClassManager {
    private final Context mContext;
    private final IMyClass mService;

    public MyClassManager(Context ctx, IMyClass service) {
        mContext = ctx;
        mService = service;

    public void myAidlFunct1() {
        } catch (RemoteException ex){
            Slog.e("MyClassManager", "Unable to contact the remote MyClassManager");

3.3 Generation[edit]

To integrate your changes you need to adapt the Android.bp file in framework/base. Include all the AIDL files you have created beforehand.

java_library {

3.4 Update API[edit]

Add the following line in build/make/target/product/vndk/<current api version>.txt (ex: 28.txt for API 28) and in build/make/target/product/vndk/current.txt


When your interface is well defined you need to execute the command:

 make update-api

This command updates all the necessary files to integrate your API in the distribution.

4 Implement the vendor HAL[edit]

To implement the HAL you have just created please refer to the AOSP documentation[5].

5 Custom Service[edit]

To be able to connect everything together you need to create an independent service that will run in background and reply to API calls.

5.1 Package services[edit]

Create a folder in packages/services with the name of your service (MyInterfaceService)

prepare the folder structure as follows:

  • AndroidManifest.xml
  • src
    • com
      • android
        • myinterfaceservice

5.2 Implement service[edit]


import android.util.Log;
import android.util.Slog;
import android.os.IBinder;

import android.os.ServiceManager;

import android.myinterface.IMyClass;

public class MyInterfaceServiceApp extends Application { 
    private static final String REMOTE_SERVICE_NAME = IMyClass.class.getName();
    private static final String TAG = "MyInterfaceServiceApp";
    private IBinder mMyClassManager = null; 

    public void onCreate() {
        Slog.d(TAG, "Build service");
        mMyClassManager = new IMyClassImpl();
        ServiceManager.addService(REMOTE_SERVICE_NAME, mMyClassManager);

    public void onTerminate() {


import android.util.Log;
import android.util.Slog;

import java.util.ArrayList;
import android.os.RemoteException;

import android.myinterface.IMyClass;

import android.hardware.myinterface.V1_0.IMyClass;

class IMyClassImpl extends IMyClass.Stub {
    private static final String TAG = "IMyClassImpl";
    private IMyClass mIMyClassHal = null;

    public IMyClassImpl() {
        Slog.d(TAG, "Build service");
        try {
            mIMyClassHal = IMyClass.getService();
        } catch (Exception e)
            mIMyClassHal = null;

    public void myAidlFunct1() throws RemoteException {
        if (mIMyClassHal != null) {
            mIMyClassHal.myFunct1(new IMyClass.myFunct1Callback() {

                public void onValues(bool ret) {
                    //Function that you have to treat the HAL "IMyClass myFunct1() generates (bool ret)" returned value.

5.3 Makefile and manifest[edit]

 LOCAL_PATH:= $(call my-dir)
 include $(CLEAR_VARS)
 LOCAL_MODULE_TAGS := optional
 LOCAL_SRC_FILES := $(call all-java-files-under,src)
 LOCAL_REQUIRED_MODULES := android.hardware.myinterface
 LOCAL_STATIC_JAVA_LIBRARIES := android.hardware.myinterface-V1.0-java
 LOCAL_PACKAGE_NAME := MyInterfaceService
 include $(BUILD_PACKAGE)


<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android=""
<application android:name=".MyInterfaceServiceApp"

6 Add SEpolicy[edit]

To be able to execute your service, even if your system is permissive you need to declare dedicated SEpolicy.

Because the new service is embedded like any other AOSP service you need to adapt official AOSP SEpolicy.

For more details please refer to the official AOSP documentation[6].

6.1 Change AOSP SEpolicy[edit]

In system/sepolicy/public/attributes, you need to declare a new HAL name.


This creates all necessary rules for the HAL.

In system/sepolicy/public/service.te

type myservice_service, app_api_service, service_manager_type;

This creates the new SEpolicy name with appropriate rights.

In system/sepolicy/private/service_contexts

 android.myinterface.IMyClass               u:object_r:myservice_service:s0

This gives the correct rights to the service.

In system/sepolicy/private/seapp_contexts add the new packages/apps rules.

 user=system seinfo=myservice domain=myservice_app type=app_data_file

This gives the correct rights to the packages/apps service.

In system/sepolicy/private/compat/27.0/27.0.ignore.cil and system/sepolicy/private/compat/26.0/26.0.ignore.cil add the service at the end of the list.


Because of the base AOSP SEpolicy change you need to copy those files in the prebuilt location (path depends on API version used)

 cp system/sepolicy/public/attributes system/sepolicy/prebuilts/api/28.0/public/attributes
 cp system/sepolicy/public/service.te system/sepolicy/prebuilts/api/28.0/public/service.te
 cp system/sepolicy/private/service_contexts system/sepolicy/prebuilts/api/28.0/private/service_contexts
 cp system/sepolicy/private/seapp_contexts system/sepolicy/prebuilts/api/28.0/private/seapp_contexts
 cp system/sepolicy/private/compat/27.0/27.0.ignore.cil system/sepolicy/prebuilts/api/28.0/private/compat/27.0/27.0.ignore.cil
 cp system/sepolicy/private/compat/26.0/26.0.ignore.cil system/sepolicy/prebuilts/api/28.0/private/compat/26.0/26.0.ignore.cil

6.2 Add custom SEpolicy to distribution[edit]

Create device/stm/<STM32Series>/sepolicy/hal_myinterface_default.te

type hal_myservice_default, domain;
hal_server_domain(hal_myservice_default, hal_myservice)

type hal_myservice_default_exec, exec_type, vendor_file_type, file_type;

binder_call(hal_myservice_client, hal_myservice_server)
binder_call(hal_myservice_server, hal_myservice_client)

add_hwservice(hal_myservice_server, hal_myservice_hwservice)

If your HAL needs to access some specific system files you need to add the definition here.

In 'device/stm/<STM32Series>/sepolicy/myservice_app.te

#packages app MyInterfaceService
type myservice_app, domain;

7 Add to the board[edit]

To include your new service in the board-specific Android image you need to customize your

        MyInterfaceService # The packages apps service

You need to rebuild your distribution to integrate the changes.

 make -j

8 SDK integration[edit]

To allow using the created service in your applications, you have to re-generate the SDK and install it within Android Studio (refer to How to build and install an SDK for Android).

9 References[edit]