Android HAL
HIDL & AIDL ile Donanım Soyutlama.

00 Android HAL nedir?

Hardware Abstraction Layer (HAL), Android framework'ünün donanıma doğrudan bağımlı olmasını engelleyen ara katmandır. SoC üreticileri ve OEM'ler, HAL arayüzlerini kendi donanımlarına göre implemente ederek Android framework katmanının değişmeden çalışmasını sağlar.

Treble mimarisi

Android 8.0 (Oreo) ile birlikte Google, Project Treble'ı duyurdu. Treble öncesinde Android güncellemeleri OEM'ler ve SoC üreticilerine bağımlıydı; her güncelleme için tüm vendor değişikliklerinin yeniden birleştirilmesi gerekiyordu. Treble, system ve vendor bölümlerini net bir arayüzle ayırdı.

  ┌──────────────────────────────────────────────────────────┐
  │                Android Framework (system)                 │
  │  Camera Service │ Audio Flinger │ Sensor Service │ ...    │
  ├──────────────────────────────────────────────────────────┤
  │              HAL Arayüzü (HIDL / AIDL)                   │  ← Treble sınırı
  ├──────────────────────────────────────────────────────────┤
  │                 Vendor HAL (vendor)                       │
  │  camera.so │ audio.so │ sensors.so │ ...                  │
  ├──────────────────────────────────────────────────────────┤
  │              Kernel Sürücüleri (Linux)                    │
  └──────────────────────────────────────────────────────────┘
    

HIDL'den AIDL'e geçiş

Android 11'de Google, HAL tanım dili olarak HIDL'in yerini AIDL'in alacağını duyurdu. Android 13 itibarıyla yeni HAL'lerin AIDL ile yazılması zorunlu hale getirildi. HIDL, AIDL'e kıyasla daha karmaşık bir araç zinciri gerektiriyordu; AIDL ise aynı arayüz tanım diilinin Java, C++, Rust ve NDK backend'leri için ortaklaşa kullanılmasına olanak tanıyor.

01 HIDL — HAL Interface Definition Language

HIDL, Android 8.0 ile birlikte HAL arayüzlerini tanımlamak için kullanılan IDL'dir. C++ ya da Java'ya benzer sözdizimiyle yazılır ve hidl-gen aracıyla otomatik olarak binder glue kodu üretilir.

.hal dosyası sözdizimi

// hardware/interfaces/sensors/1.0/ISensors.hal
package android.hardware.sensors@1.0;

import android.hardware.sensors@1.0::types;

interface ISensors {
    /**
     * getSensorsList: Sistemdeki sensör listesini döner.
     */
    getSensorsList() generates (vec<SensorInfo> list);

    /**
     * activate: Belirli sensörü aktif/pasif yapar.
     */
    activate(int32_t sensorHandle, bool enabled) generates (Result result);

    /**
     * poll: Yeni sensör verisi için bloke eder (callback tabanlı değil).
     */
    poll(int32_t maxCount)
        generates (Result result, vec<Event> data, vec<SensorInfo> dynamicSensorsAdded);
};

hidl-gen ile kod üretimi

# hidl-gen aracı AOSP build sisteminde mevcuttur
# C++ stub üretimi:
hidl-gen \
  -o hardware/interfaces/sensors/1.0/default \
  -L c++-impl \
  -r android.hardware:hardware/interfaces \
  android.hardware.sensors@1.0

# Android.bp dosyası üretimi:
hidl-gen \
  -o hardware/interfaces/sensors/1.0 \
  -L androidbp \
  -r android.hardware:hardware/interfaces \
  android.hardware.sensors@1.0

Passthrough vs Binderized mod

// types.hal — ortak veri tipleri
package android.hardware.sensors@1.0;

enum Result : int32_t {
    OK             = 0,
    PERMISSION_DENIED = -1,
    NO_MEMORY      = -12,
    BAD_VALUE      = -22,
    INVALID_OPERATION = -38,
};

struct SensorInfo {
    int32_t  sensorHandle;
    string   name;
    string   vendor;
    int32_t  version;
    SensorType type;
    float    maxRange;
    float    resolution;
    float    power;    // mA
    int32_t  minDelay; // us; 0 = one-shot, <0 = on-change
};

02 AIDL — Android Interface Definition Language

AIDL, Android'in genel amaçlı IPC arayüz tanım dilidir. Android 11 itibarıyla HAL tanımları için de Stable AIDL kullanılmaya başlandı. Tek bir .aidl dosyasından Java, C++, NDK ve Rust backend'leri için kod üretilebilir.

.aidl dosyası — HAL arayüzü

// hardware/interfaces/sensors/aidl/android/hardware/sensors/ISensors.aidl
package android.hardware.sensors;

import android.hardware.sensors.Event;
import android.hardware.sensors.ISensorsCallback;
import android.hardware.sensors.SensorInfo;

@VintfStability  // Stable AIDL için zorunlu annotation
interface ISensors {
    const int32_t RESULT_OK = 0;

    SensorInfo[] getSensorsList();

    void activate(int sensorHandle, boolean enabled);

    void initialize(
        in ISensorsCallback sensorsCallback
    );

    Event[] poll(int maxCount);

    void setOperationMode(OperationMode mode);
}

aidl aracı ile kod üretimi

# C++ backend
aidl \
  --lang=cpp \
  --structured \
  --stability=vintf \
  --include hardware/interfaces/sensors/aidl \
  -o out/sensors-cpp \
  hardware/interfaces/sensors/aidl/android/hardware/sensors/ISensors.aidl

# Rust backend (Android 12+)
aidl \
  --lang=rust \
  --structured \
  --stability=vintf \
  -o out/sensors-rust \
  hardware/interfaces/sensors/aidl/android/hardware/sensors/ISensors.aidl

Stable AIDL versiyonlama

Stable AIDL, arayüz değişikliklerini versiyonlar halinde yönetir. Her release edilmiş versiyon dondurulur (freeze); geriye dönük uyumluluğu kıran değişiklikler yasaktır.

# Android.bp — AIDL HAL tanımı
aidl_interface {
    name: "android.hardware.sensors",
    vendor_available: true,
    srcs: ["android/hardware/sensors/*.aidl"],
    stability: "vintf",
    backend: {
        cpp: { enabled: true },
        java: { sdk_version: "module_current" },
        rust: { enabled: true },
        ndk: { enabled: true },
    },
    versions_with_info: [
        {
            version: "1",
            imports: [],
        },
        {
            version: "2",     // dondurulmuş versiyon
            imports: [],
        },
    ],
    frozen: true,             // son versiyon değiştirilemez
}

AIDL backend karşılaştırması

03 HAL implementasyonu

HAL arayüzü tanımlandıktan sonra asıl iş: donanıma özel implementasyonun yazılması. Bu bölümde C++ AIDL HAL servisi, thread pool yapılandırması ve servisin başlatılması ele alınıyor.

HAL implementasyon sınıfı

// Sensors.h
#pragma once
#include <aidl/android/hardware/sensors/BnSensors.h>
#include <thread>
#include <atomic>

namespace aidl::android::hardware::sensors {

class Sensors : public BnSensors {
public:
    Sensors();
    ~Sensors() override;

    ndk::ScopedAStatus getSensorsList(
        std::vector<SensorInfo>* _aidl_return) override;

    ndk::ScopedAStatus activate(
        int32_t sensorHandle, bool enabled) override;

    ndk::ScopedAStatus initialize(
        const std::shared_ptr<ISensorsCallback>& sensorsCallback) override;

    ndk::ScopedAStatus poll(
        int32_t maxCount,
        std::vector<Event>* _aidl_return) override;

private:
    std::shared_ptr<ISensorsCallback> mCallback;
    std::atomic<bool> mRunning{false};
    std::thread mPollThread;
    int mDriverFd{-1};  // /dev/my_sensor dosyası

    void pollLoop();
};

}  // namespace

// Sensors.cpp — implementasyon
#include "Sensors.h"
#include <android-base/logging.h>
#include <fcntl.h>
#include <unistd.h>

namespace aidl::android::hardware::sensors {

Sensors::Sensors() {
    mDriverFd = ::open("/dev/my_sensor", O_RDONLY | O_NONBLOCK);
    if (mDriverFd < 0) {
        LOG(ERROR) << "Failed to open sensor device: " << strerror(errno);
    }
}

ndk::ScopedAStatus Sensors::getSensorsList(
        std::vector<SensorInfo>* _aidl_return) {
    SensorInfo info;
    info.sensorHandle = 1;
    info.name         = "MyAccelerometer";
    info.vendor       = "MyVendor";
    info.version      = 1;
    info.type         = SensorType::ACCELEROMETER;
    info.maxRange     = 16.0f;   // ±16g
    info.resolution   = 0.001f;
    info.power        = 0.18f;   // mA
    info.minDelay     = 10000;   // 100 Hz
    _aidl_return->push_back(info);
    return ndk::ScopedAStatus::ok();
}

ndk::ScopedAStatus Sensors::initialize(
        const std::shared_ptr<ISensorsCallback>& sensorsCallback) {
    mCallback = sensorsCallback;
    mRunning = true;
    mPollThread = std::thread([this]() { pollLoop(); });
    return ndk::ScopedAStatus::ok();
}

}  // namespace

service.cpp — HAL servisinin başlatılması

// service.cpp
#include "Sensors.h"
#include <android/binder_manager.h>
#include <android/binder_process.h>
#include <android-base/logging.h>

int main() {
    android::base::InitLogging(nullptr, android::base::LogdLogger());
    LOG(INFO) << "Sensors HAL service starting";

    // Thread pool oluştur — binder IPC için
    ABinderProcess_setThreadPoolMaxThreadCount(4);
    ABinderProcess_startThreadPool();

    // HAL implementasyonunu oluştur ve kaydet
    std::shared_ptr<aidl::android::hardware::sensors::Sensors> sensors =
        ndk::SharedRefBase::make<aidl::android::hardware::sensors::Sensors>();

    const std::string instance =
        std::string() + ISensors::descriptor + "/default";

    binder_status_t status =
        AServiceManager_addService(sensors->asBinder().get(), instance.c_str());

    if (status != STATUS_OK) {
        LOG(ERROR) << "Failed to register HAL service: " << status;
        return -1;
    }

    LOG(INFO) << "Sensors HAL registered: " << instance;
    ABinderProcess_joinThreadPool();  // bloke et, IPC bekle
    return 0;
}

Android.bp — build kuralları

cc_binary {
    name: "android.hardware.sensors-service.myvendor",
    relative_install_path: "hw",
    vendor: true,
    init_rc: ["sensors-myvendor.rc"],
    vintf_fragments: ["sensors-myvendor.xml"],
    srcs: [
        "Sensors.cpp",
        "service.cpp",
    ],
    shared_libs: [
        "libbinder_ndk",
        "liblog",
        "libbase",
        "android.hardware.sensors-V2-ndk",
    ],
}

04 HAL manifest ve compatibility matrix

Android VINTF (Vendor Interface) sistemi, hangi HAL'lerin mevcut olduğunu ve framework'ün hangileri gerektirdiğini manifest ve compatibility matrix dosyaları üzerinden yönetir.

manifest.xml — vendor partition

<!-- /vendor/etc/vintf/manifest.xml -->
<manifest version="2.0" type="device">
    <hal format="aidl">
        <name>android.hardware.sensors</name>
        <version>2</version>
        <fqname>ISensors/default</fqname>
    </hal>

    <hal format="aidl">
        <name>android.hardware.camera.provider</name>
        <version>1</version>
        <fqname>ICameraProvider/internal/0</fqname>
    </hal>

    <!-- HIDL HAL örneği (eski format) -->
    <hal format="hidl">
        <name>android.hardware.audio</name>
        <transport>hwbinder</transport>
        <version>7.0</version>
        <interface>
            <name>IDevicesFactory</name>
            <instance>default</instance>
        </interface>
    </hal>

    <sepolicy>
        <version>33.0</version>
    </sepolicy>
</manifest>

compatibility_matrix.xml — framework gereksinimleri

<!-- /system/etc/vintf/compatibility_matrix.5.xml (API level 31) -->
<compatibility-matrix version="2.0" type="framework">
    <hal format="aidl" optional="false">
        <name>android.hardware.sensors</name>
        <version>1-2</version>  <!-- versiyon aralığı -->
        <interface>
            <name>ISensors</name>
            <instance>default</instance>
        </interface>
    </hal>

    <sepolicy>
        <kernel-sepolicy-version>30</kernel-sepolicy-version>
        <sepolicy-version>33.0-34.0</sepolicy-version>
    </sepolicy>

    <kernel version="5.10.0">
        <conditions>
            <config>
                <key>CONFIG_SMP</key>
                <value type="tristate">y</value>
            </config>
        </conditions>
    </kernel>
</compatibility-matrix>

vintf araçları ile doğrulama

# Cihazda manifest kontrolü
adb shell vintf
adb shell vintf --check-compat

# hidl-check (HIDL için)
hidl-check android.hardware.sensors@1.0

# AIDL manifest doğrulama
adb shell dumpsys android.hardware.sensors.ISensors/default

# Kayıtlı tüm HAL servislerini listele
adb shell service list | grep android.hardware

# VINTF uyumluluk kontrolü (build zamanı)
check_vintf --manifest vendor/etc/vintf/manifest.xml \
            --matrix frameworks/compatibility_matrix.5.xml

05 Kernel sürücüsü ile HAL bağlantısı

HAL implementasyonu, donanıma genellikle bir Linux kernel sürücüsü üzerinden erişir. Bu katman genelde bir karakter cihaz (/dev/xxx) veya sysfs arayüzü üzerinden ioctl çağrılarıyla yönetilir.

ioctl köprüsü mimarisi

  Android Framework
       │ Binder IPC
  HAL Service (vendor process)
       │ open("/dev/my_sensor", ...)
       │ ioctl(fd, SENSOR_IOCTL_GET_DATA, &data)
  Kernel Driver (my_sensor.ko)
       │ platform_driver / i2c_driver
  Fiziksel Sensör (I2C / SPI)
    

HAL tarafında ioctl kullanımı

#include <sys/ioctl.h>
#include <linux/my_sensor.h>  // kernel header (UAPI)

// UAPI ioctl tanımları (kernel/include/uapi/linux/my_sensor.h)
#define SENSOR_IOC_MAGIC   's'
#define SENSOR_IOCTL_ACTIVATE   _IOW(SENSOR_IOC_MAGIC, 1, int)
#define SENSOR_IOCTL_GET_DATA   _IOR(SENSOR_IOC_MAGIC, 2, struct sensor_data)

struct sensor_data {
    int32_t x, y, z;
    int64_t timestamp_ns;
};

// HAL içinde kullanım:
ndk::ScopedAStatus Sensors::activate(int32_t handle, bool enabled) {
    int val = enabled ? 1 : 0;
    if (::ioctl(mDriverFd, SENSOR_IOCTL_ACTIVATE, &val) < 0) {
        LOG(ERROR) << "ioctl ACTIVATE failed: " << strerror(errno);
        return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE);
    }
    return ndk::ScopedAStatus::ok();
}

void Sensors::pollLoop() {
    while (mRunning) {
        struct sensor_data raw{};
        if (::ioctl(mDriverFd, SENSOR_IOCTL_GET_DATA, &raw) < 0) {
            if (errno == EAGAIN) { usleep(10000); continue; }
            break;
        }
        Event ev;
        ev.sensorHandle = 1;
        ev.sensorType   = SensorType::ACCELEROMETER;
        ev.timestamp    = raw.timestamp_ns;
        ev.payload.set<EventPayload::Tag::vec3>({
            (float)raw.x / 1000.0f,
            (float)raw.y / 1000.0f,
            (float)raw.z / 1000.0f,
        });
        if (mCallback) mCallback->onDynamicSensorsConnected({});
    }
}

SELinux HAL context

# vendor/sepolicy/my_sensor_hal.te

# HAL process tipi tanımla
type my_sensor_hal, domain;
type my_sensor_hal_exec, exec_type, vendor_file_type, file_type;
hal_server_domain(my_sensor_hal, hal_sensors)

# /dev/my_sensor cihazına erişim
type my_sensor_device, dev_type;

# vendor/sepolicy/file_contexts:
# /dev/my_sensor    u:object_r:my_sensor_device:s0

allow my_sensor_hal my_sensor_device:chr_file rw_file_perms;
allow my_sensor_hal self:capability { sys_nice };

# udev kuralı (vendor/etc/udev/rules.d/99-my-sensor.rules):
# KERNEL=="my_sensor", MODE="0660", GROUP="system"

06 VTS — Vendor Test Suite

VTS (Vendor Test Suite), HAL implementasyonlarının AOSP sözleşmesine uygun çalışıp çalışmadığını doğrulayan resmi test çerçevesidir. CTS'nin vendor katmanına karşılık gelen testidir.

VTS test yapısı

// hardware/interfaces/sensors/aidl/vts/VtsAidlHalSensorsTest.cpp
#include <aidl/android/hardware/sensors/ISensors.h>
#include <android/binder_manager.h>
#include <gtest/gtest.h>

using namespace aidl::android::hardware::sensors;

class SensorsAidlTest : public ::testing::TestWithParam<std::string> {
protected:
    void SetUp() override {
        const std::string instance = GetParam();
        mSensors = ISensors::fromBinder(
            ndk::SpAIBinder(AServiceManager_waitForService(instance.c_str())));
        ASSERT_NE(mSensors, nullptr) << "HAL servisi bulunamadı: " << instance;
    }

    std::shared_ptr<ISensors> mSensors;
};

// Test 1: getSensorsList boş olmamalı
TEST_P(SensorsAidlTest, GetSensorsList) {
    std::vector<SensorInfo> sensorList;
    ASSERT_TRUE(mSensors->getSensorsList(&sensorList).isOk());
    EXPECT_GT(sensorList.size(), 0U) << "Sensör listesi boş!";
}

// Test 2: activate çağrısı başarılı olmalı
TEST_P(SensorsAidlTest, ActivateSensor) {
    std::vector<SensorInfo> sensorList;
    ASSERT_TRUE(mSensors->getSensorsList(&sensorList).isOk());
    ASSERT_GT(sensorList.size(), 0U);

    EXPECT_TRUE(mSensors->activate(sensorList[0].sensorHandle, true).isOk());
    EXPECT_TRUE(mSensors->activate(sensorList[0].sensorHandle, false).isOk());
}

GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(SensorsAidlTest);
INSTANTIATE_TEST_SUITE_P(
    PerInstance, SensorsAidlTest,
    testing::ValuesIn(android::getAidlHalInstanceNames(ISensors::descriptor)),
    android::PrintInstanceNameToString);

VTS çalıştırma

# VTS runner ile test çalıştırma (host tarafında)
python3 test/vts/tools/vts-tradefed/run-vts-tradefed.sh run \
    commandAndExit vts \
    --module VtsAidlHalSensorsTargetTest \
    -s <device-serial>

# Doğrudan cihazda çalıştırma (adb push + exec)
adb push out/target/product/<board>/data/nativetest64/VtsAidlHalSensorsTargetTest/VtsAidlHalSensorsTargetTest /data/local/tmp/
adb shell /data/local/tmp/VtsAidlHalSensorsTargetTest \
    --gtest_filter="SensorsAidlTest*"

07 Android Automotive HAL (VHAL)

Android Automotive OS (AAOS), araç içi sistemler (infotainment, HVAC, güç yönetimi) için özel bir HAL sunar: Vehicle HAL (VHAL). IVehicle arayüzü üzerinden araç property'lerine erişilir.

IVehicle arayüzü

// hardware/interfaces/automotive/vehicle/aidl/.../IVehicle.aidl
@VintfStability
interface IVehicle {
    /** Araç property'sini oku */
    VehiclePropValue[] getValues(VehiclePropValueRequest[] requests);

    /** Araç property'sini yaz (HVAC sıcaklığı, camlar vb.) */
    void setValues(VehiclePropValueRequest[] requests);

    /** Property listesini al */
    VehiclePropConfig[] getAllPropConfigs();

    /** Değişiklik callback'i kaydet */
    void subscribe(IVehicleCallback callback, SubscribeOptions[] options);
}

VehiclePropValue yapısı

// VehiclePropValue kullanım örneği (C++)
using namespace aidl::android::hardware::automotive::vehicle;

// Araç hızını oku (PERF_VEHICLE_SPEED = 291504644)
VehiclePropValueRequest req;
req.requestId = 1;
req.value.prop  = toInt(VehicleProperty::PERF_VEHICLE_SPEED);
req.value.areaId = 0;  // global property

std::vector<VehiclePropValue> results;
auto status = mVehicle->getValues({req}, &results);
if (status.isOk() && !results.empty()) {
    float speed = results[0].value.floatValues[0];
    LOG(INFO) << "Araç hızı: " << speed << " m/s";
}

// HVAC sıcaklığını ayarla (HVAC_TEMPERATURE_SET)
VehiclePropValueRequest setReq;
setReq.requestId = 2;
setReq.value.prop   = toInt(VehicleProperty::HVAC_TEMPERATURE_SET);
setReq.value.areaId = toInt(VehicleAreaSeat::ROW_1_LEFT);
setReq.value.value.floatValues = {22.0f};  // 22°C
mVehicle->setValues({setReq});

AAOS VHAL property kategorileri

08 Pratik: Basit sensör HAL — HIDL + kernel char device + VTS test

Bu bölümde sıfırdan küçük bir akselerometre HAL'i oluşturuyoruz: kernel karakter sürücüsü, AIDL HAL implementasyonu ve temel VTS testi — tam dosya yapısıyla.

Proje dosya yapısı

  vendor/myvendor/
  ├── hardware/
  │   └── sensors/
  │       ├── Android.bp
  │       ├── Sensors.h
  │       ├── Sensors.cpp
  │       ├── service.cpp
  │       ├── sensors-myvendor.rc         ← init script
  │       ├── sensors-myvendor.xml        ← vintf fragment
  │       └── sepolicy/
  │           ├── my_sensor_hal.te
  │           └── file_contexts
  └── kernel/
      └── drivers/
          └── my_sensor/
              ├── Makefile
              └── my_sensor.c
    

Kernel sürücüsü (my_sensor.c)

#include <linux/module.h>
#include <linux/miscdevice.h>
#include <linux/uaccess.h>
#include <linux/random.h>
#include <uapi/linux/my_sensor.h>

static long my_sensor_ioctl(struct file *f, unsigned int cmd,
                            unsigned long arg) {
    switch (cmd) {
    case SENSOR_IOCTL_ACTIVATE:
        pr_info("my_sensor: activate = %lu\n", arg);
        return 0;

    case SENSOR_IOCTL_GET_DATA: {
        struct sensor_data d = {
            .x = 0, .y = 0, .z = 9810,  /* 9.81 m/s^2 × 1000 */
            .timestamp_ns = ktime_get_ns(),
        };
        if (copy_to_user((void __user *)arg, &d, sizeof(d)))
            return -EFAULT;
        return 0;
    }
    default:
        return -ENOTTY;
    }
}

static const struct file_operations my_sensor_fops = {
    .owner          = THIS_MODULE,
    .unlocked_ioctl = my_sensor_ioctl,
};

static struct miscdevice my_sensor_misc = {
    .minor = MISC_DYNAMIC_MINOR,
    .name  = "my_sensor",
    .fops  = &my_sensor_fops,
};

module_misc_device(my_sensor_misc);
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("MyVendor Accelerometer Driver");

Init RC dosyası

# sensors-myvendor.rc
service vendor.sensors-myvendor /vendor/bin/hw/android.hardware.sensors-service.myvendor
    class hal
    user system
    group system input
    capabilities SYS_NICE
    ioprio rt 4
    task_profiles ServiceCapacityLow

VINTF fragment

<!-- sensors-myvendor.xml -->
<manifest version="2.0" type="device">
    <hal format="aidl">
        <name>android.hardware.sensors</name>
        <version>2</version>
        <fqname>ISensors/default</fqname>
    </hal>
</manifest>

Hızlı kontrol komutları

# Kernel modülü yükle
insmod /vendor/lib/modules/my_sensor.ko
ls /dev/my_sensor  # cihaz göründü mü?

# HAL servisini başlat (test)
adb shell start vendor.sensors-myvendor
adb shell service list | grep sensors

# Logcat ile HAL loglarını izle
adb logcat -s "Sensors_HAL"

# VTS hızlı koşusu
adb shell /data/local/tmp/VtsAidlHalSensorsTargetTest \
    --gtest_filter="SensorsAidlTest/0.GetSensorsList"