Android-HAL与HIDL分析使用总结_hal hidl

Android-HAL与HIDL分析使用总结

HAL接口定义语言（简称HIDL）适用于指定HAL和其用户之间的接口的一种接口描述语言（IDL）,HIDL允许指定类型和方法调用。
HIDL旨在用于进程间通信（IPC）。进程之间的通信经过Binder化。对于必须与进程相关联的代码库，还可以使用直通模式。
HIDL可指定数据结构和方法签名，这些内容会整理归类到接口中，而接口会汇集到软件包中。
尽管HIDL具有一系列不同的关键字，C++和JAVA程序员对HIDL的语法并不陌生。此外，HIDL还是用JAVA样式和注释。

Android 8.0引入hidl，目的是为了将hal从system.img移除出去，方便android版本升级。
Google每次更新Android大版本，基本上都是framework的升级，与vendor改的代码理论上是可以独立开来的，
所以Google尝试通过Treble来独立更新system.img来帮助vendor更快的移植新的Android版本。

以前HAL是以so的形式存在的，作为一系列标准接口，供Android framework调用，无论是通过jni还是别的途径，
如果要被framework调用，那这些so就一定要存在于system分区，但是我们现在要把system分区独立开来，
这样vendor修改的代码全部要在vendor分区，所以引入HIDL来解决这个问题，vendor设计的HAL都以独立的service存在，
每一个HAL模块都是一个独立的binder server进程，Android framework想要调用HAL的接口就必须作为binder的client来调用.

AOSP有哪些HAL：
Camera
Audio
Sensor
等等

Google理论上只关心Android的框架层和上层软件，但是上层软件依赖于底层的硬件实现，每家手机厂商，
或者说是CPU厂商底层硬件的实现都是不一样的，所以这个HAL层基本都是手机厂商或者CPU厂商去实现的，
Google只是作为一个框架的指导，和Framework层API的接口定义，这些接口的实现都得由HAL去完成。

底层硬件都是由Linux kernel驱动控制的，提供文件读写就可以简单控制驱动，在此以虚拟驱动为例，省略kernel driver的实现;

HIDL 接口文件定义
进入代码，我们假设 DemoHal 作为标准AOSP的HAL，进入代码目录创建HIDL目录
mkdir -p hardware/interfaces/demohal/1.0/default 
进入该目录
接着创建接口描述文件 IDemoHal.hal
package android.hardware.demohal@1.0;
interface IDemoHal {
    helloWorld(string name) generates (string result);
};

这里我们定义了一个 IDemoHal 接口文件，简单的添加了一个 helloWorld 接口，入参 string name，返回string，后面再来实现这个接口。

生成HAL 相关文件
Google提供了一些工具来生成HAL层相关的代码框架和代码实例，我们只需关心接口实现部分。

使用hidl-gen工具
# PACKAGE=android.hardware.demohal@1.0
# LOC=hardware/interfaces/demohal/1.0/default/
# make hidl-gen -j64
# hidl-gen -o $LOC -Lc++-impl -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport ${PACKAGE}
# hidl-gen -o $LOC -Landroidbp-impl -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport ${PACKAGE}

然后使用脚本来更新Makefile，自动生成Android.mk, Android.bp
# ./hardware/interfaces/update-makefiles.sh

现在，我们来添加两个空文件,后面再实现;
touch hardware/interfaces/demohal/1.0/default/android.hardware.demohal@1.0-service.rc
touch hardware/interfaces/demohal/1.0/default/service.cpp

现在我们的代码目录: hardware/interface/demohal:
├── 1.0
│   ├── Android.bp
│   ├── Android.mk
│   ├── default
│   │   ├── Android.bp
│   │   ├── android.hardware.demohal@1.0-service.rc
│   │   ├── DemoHal.cpp
│   │   ├── DemoHal.h
│   │   └── service.cpp
│   └── IDemoHal.hal
└── Android.bp

我们写代码就写了一个IDemoHal.hal，其余代码都是自动生成的，特别是 DemoHal.cpp 和 DemoHal.h 这两个文件是实现接口的关键文件。

实现HAL实现端的共享库
打开 DemoHal.h 和 DemoHal.cpp 文件，开始写代码
打开 DemoHal.h 文件
struct DemoHal : public IDemoHal {
    // Methods from IDemoHal follow.
    Return<void> helloWorld(const hidl_string& name, helloWorld_cb _hidl_cb) override;
    // Methods from ::android::hidl::base::V1_0::IBase follow.
};

// FIXME: most likely delete, this is only for passthrough implementations
// extern "C" IDemoHal* HIDL_FETCH_IDemoHal(const char* name);

HIDL的实现有两种方式，一种是Binderized模式，另一种是Passthrough模式，
我们看到上面有两行注释掉的代码，看来这个代码是关键，来选择实现方式是Binderized还是Passthrough。

我们这里使用Passthrough模式来演示，这两种方式本质是一样的，目前大部分厂商使用的是Passthrough来延续以前的很多代码，但是慢慢的都会被改掉的。

DemoHal.h
# ifndef ANDROID_HARDWARE_NARUTO_V1_0_NARUTO_H
# define ANDROID_HARDWARE_NARUTO_V1_0_NARUTO_H
# include <android/hardware/demohal/1.0/IDemoHal.h>
# include <hidl/MQDescriptor.h>
# include <hidl/Status.h>

namespace android {
namespace hardware {
namespace demohal {
namespace V1_0 {
namespace implementation {

using ::android::hardware::hidl_array;
using ::android::hardware::hidl_memory;
using ::android::hardware::hidl_string;
using ::android::hardware::hidl_vec;
using ::android::hardware::Return;
using ::android::hardware::Void;
using ::android::sp;

struct DemoHal : public IDemoHal {
    // Methods from IDemoHal follow.
    Return<void> helloWorld(const hidl_string& name, helloWorld_cb _hidl_cb) override;
    // Methods from ::android::hidl::base::V1_0::IBase follow.
};

// FIXME: most likely delete, this is only for passthrough implementations
extern "C" IDemoHal* HIDL_FETCH_IDemoHal(const char* name);

}  // namespace implementation
}  // namespace V1_0
}  // namespace demohal
}  // namespace hardware
}  // namespace android

# endif  // ANDROID_HARDWARE_NARUTO_V1_0_NARUTO_H

DemoHal.cpp 实现 DemoHal::helloWorld() 接口;
# include "DemoHal.h"

namespace android {
namespace hardware {
namespace demohal {
namespace V1_0 {
namespace implementation {

// Methods from IDemoHal follow.
Return<void> DemoHal::helloWorld(const hidl_string& name, helloWorld_cb _hidl_cb) {
    // TODO implement
    char buf[100];
    ::memset(buf, 0x00, 100);
    ::snprintf(buf, 100, "Hello World, %s", name.c_str());
    hidl_string result(buf);

    _hidl_cb(result);
    return Void();
}

// Methods from ::android::hidl::base::V1_0::IBase follow.

IDemoHal* HIDL_FETCH_IDemoHal(const char* /* name */) {
    return new DemoHal();
}

}  // namespace implementation
}  // namespace V1_0
}  // namespace demohal
}  // namespace hardware
}  // namespace android

1. 我们打开了 HIDL_FETCH 的注释，让我们的 HIDL 使用 Passthrough 方式实现;
2. 添加helloWorld函数的实现(返回拼接后的字符串);

查看一下Android.bp文件
cc_library_shared {
    name: "android.hardware.demohal@1.0-impl",
    relative_install_path: "hw",
    proprietary: true,
    srcs: [
        "DemoHal.cpp",
    ],
    shared_libs: [
        "libhidlbase",
        "libhidltransport",
        "libutils",
        "android.hardware.demohal@1.0",
    ],
}

用mmm编译最终会在/vendor/lib64/hw/下生成一个 android.hardware.demohal@1.0-impl.so
$ mmm hardware/interfaces/demohal/1.0/default/

PLATFORM_VERSION_CODENAME=REL
PLATFORM_VERSION=8.1.0
TARGET_PRODUCT=hon660
TARGET_BUILD_VARIANT=userdebug
TARGET_BUILD_TYPE=release
TARGET_ARCH=arm64
TARGET_ARCH_VARIANT=armv8-a
TARGET_CPU_VARIANT=generic
TARGET_2ND_ARCH=arm
TARGET_2ND_ARCH_VARIANT=armv7-a-neon
TARGET_2ND_CPU_VARIANT=cortex-a53
HOST_ARCH=x86_64
HOST_2ND_ARCH=x86
HOST_OS=linux
HOST_OS_EXTRA=Linux-3.16.0-48-generic-x86_64-with-Ubuntu-14.04-trusty
HOST_CROSS_OS=windows
HOST_CROSS_ARCH=x86
HOST_CROSS_2ND_ARCH=x86_64
HOST_BUILD_TYPE=release
BUILD_ID=OPM1.171019.011

# OUT_DIR=out

[2/2] bootstrap out/soong/.minibootstrap/build.ninja.in
[1/1] out/soong/.bootstrap/bin/minibp out/soong/.bootstrap/build.ninja
[2/3] glob hardware/interfaces/*/Android.bp
[1/1] out/soong/.bootstrap/bin/soong_build out/soong/build.ninja
No need to regenerate ninja file
[100% 3/3] out/soong/.bootstrap/bin/soong_build out/soong/build.ninja
[100% 18/18] build 'out/target/product/hon660/obj/SHARED_LIBRARIES/android.hardware.demohal@1.0-impl_intermediates/android.hardware.demohal@1.0-impl.so.toc'

#### build completed successfully (02:35 (mm:ss))

调用流程
上面完成了实现端的代码和编译，接下来看一下整个HIDL的调用流程。
HIDL软件包中自动生成的文件会链接到与软件包同名的单个共享库。
该共享库还会导出单个头文件 IDemoHal.h,用于在binder客户端和服务端声明的接口文件；

我们这个实例会用到以下几个模块：
android.hardware.demohal@1.0-impl.so: DemoHal模块实现端的代码编译生成，binder server端
android.hardware.demohal@1.0.so: DemoHal模块调用端的代码，binder client端
demohal_hal_service: 通过直通式注册binder service，暴露接口给client调用
android.hardware.demohal@1.0-service.rc: Android native 进程入口

启动binder server端进程
回到之前创建的两个文件，先来看一下rc文件
hardware/interfaces/demohal/1.0/default/android.hardware.demohal@1.0-service.rc

service demohal_hal_service /vendor/bin/hw/android.hardware.demohal@1.0-service
    class hal
    user system
    group system
在设备启动的时候执行 /vendor/bin/hw/android.hardware.demohal@1.0-service 程序

hardware/interfaces/demohal/1.0/default/service.cpp
# define LOG_TAG "android.hardware.demohal@1.0-service"
# include <android/hardware/demohal/1.0/IDemoHal.h>
# include <hidl/LegacySupport.h>

using android::hardware::demohal::V1_0::IDemoHal;
using android::hardware::defaultPassthroughServiceImplementation;

int main() {
    return defaultPassthroughServiceImplementation<IDemoHal>();
}
这个service注册了IDemoHal接口文件中定义的接口作为binder server端，就一条return语句;
因为我们使用了passthrough的模式，Android帮我们封装了这个函数，不需要我们自己去addService啦。
编译后可以在, vendor/bin/hw/下找到对应的文件。

OK，我们server端的进程和实现端共享库已经完成了。

但是这个时候你如果烧录镜像，会发现这个进程会启动失败，原因是因为没有给这个进程配sepolicy，
所以正确的做法是要给他加上selinux的权限,可先略过，暂时可以用root权限去手动起这个service；
手动运行service
# vendor/bin/hw/android.hardware.demohal@1.0-service

HIDL Client测试代码 client.cpp
首先要注意包含HIDL接口实现端的头文件 android/hardware/demohal/1.0/IDemoHal.h
# include <android/hardware/demohal/1.0/IDemoHal.h>
# include <hidl/Status.h>
# include <hidl/LegacySupport.h>
# include <utils/misc.h>
# include <hidl/HidlSupport.h>
# include <stdio.h>

using android::hardware::demohal::V1_0::IDemoHal;
using android::sp;
using android::hardware::hidl_string;

int main()
{
    int ret;

    android::sp<IDemoHal> service = IDemoHal::getService();
    if(service == nullptr) {
        printf("Failed to get service\n");
        return -1;
    }

    service->helloWorld("JayZhang", [&](hidl_string result) {
                                        printf("%s\n", result.c_str());
                                    }
                       );
    return 0;
}
客户端通过 IDemoHal::getService() 获取binder server端代理服务对象，
然后就可以调用他的方法了，我们这里调用 helloWorld 接口，然后通过callback获取结果。

Android.mk
LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)
LOCAL_PROPRIETARY_MODULE := true
LOCAL_MODULE := demohal_test
LOCAL_SRC_FILES := \
    client.cpp \

LOCAL_SHARED_LIBRARIES := \
   liblog \
   libhidlbase \
   libutils \
   android.hardware.demohal@1.0 \

include $(BUILD_EXECUTABLE)

在manifest文件里添加vendor接口的定义，不然在client端是没法拿到service的，在相应的manifest.xml里面加入：
<hal format="hidl">
    <name>android.hardware.demohal</name>
    <transport>hwbinder</transport>
    <version>1.0</version>
    <interface>
        <name>IDemoHal</name>
        <instance>default</instance>
    </interface>
</hal>

运行测试代码：
# demohal_test

创建HIDL的server端和client端到此结束。
以上实现了 client 端到 server 端的接口调用过程;
如果需要在 server 端调用 client 端的接口来传递和处理数据,需要注册回调函数给 server 端;

注册回调
我们把HAL独立为一个单独的进程，client也是一个单独的进程，那么对于一般的模块而言，都是需要从底层（HAL以及以下）获取数据，
比如sensor，需要获取sensor数据，Camera，需要获取camera的raw、yuv等数据流，
对于软件设计而言，如果是同步的话，通过getXXX()函数来获取即可，
但是如果是异步的，比如底层的实现是中断的机制，不知道什么时候会来数据，那么这个时候通常会通过 callback 来实现异步的回调。

client                   server
regCallBack    ----->    saveCallBack
funcCallBack   <-----    onCallBack

实战演练
写一个简单的HAL模块，然后在.hal文件里面加入一个 setCallback 函数，传入一个 callback 指针，
当HAL的server端起来的时候会起一个线程，每隔5秒钟时间调用一下传入的这个回调函数，实现回调的机制。

看一下 HIDL 接口 IHello.hal
package vendor.sample.hello@1.0;
import IHelloCallback;

interface IHello {
    init();
    release();
    setCallback(IHelloCallback callback);
};

定义了三个接口
init：做一些初始化的动作
release：做一些释放的动作
setCallback：让client端设置一个callback方法到server端

下面来看看这个callback里面都定义了些啥，我们要为这个callback定义一个接口 IHelloCallback.hal
package vendor.sample.hello@1.0;
interface IHelloCallback {
 oneway onNotify(HalEvent event);
};

回调函数里面有一个回调方法，可以让server传一个 HalEvent 的结构体到client端，这个结构体也是自定义的，在types.hal，
可以定义自己喜欢的类型，这里是一个简单的int成员变量。
types.hal 文件
package vendor.sample.hello@1.0;
struct HalEvent {
 int32_t value;
};

OK，HIDL的接口定义好之后，使用hidl-gen工具生成代码框架
$ hidl-gen -o vendor/xxx/common/sample/hidl-impl/sample/ \
    -Lc++-impl -rvendor.sample:vendor/xxx/common/sample/interfaces \
    -randroid.hidl:system/libhidl/transport vendor.sample.hello@1.0

生成了代码：

├── Android.mk
├── hidl-impl
│ ├── Android.mk
│ └── sample │
├── Android.bp ***
│ ├── HelloCallback.cpp*** ***
│ ├── HelloCallback.h*** ***
│ ├── Hello.cpp*** ***
│ └── Hello.h***
└── interfaces
​ ├── Android.bp
​ └── hello
​ └── 1.0
​ ├── Android.bp
​ ├── IHelloCallback.hal
​ ├── IHello.hal
​ └── types.hal

其中有一个代码是用不到的，HelloCallback.h和HelloCallback.cpp，删掉他们。
注意，要把hidl-impl/sample/Android.bp里面的HelloCallback.cpp也要删掉
cc_library_shared {
 proprietary: true,
 srcs: [
 "Hello.cpp",
 ],
 shared_libs: [
 "libhidlbase",
 "libhidltransport",
 "libutils",
 "vendor.sample.hello@1.0",
 ],
}

接下来就是写代码了
在vendor分区，要起一个service来handle这个 HIDL 接口
service.cpp
#include <vendor/sample/hello/1.0/IHello.h>
​#include <hidl/LegacySupport.h>
​
using vendor::sample::hello::V1_0::IHello;
using android::hardware::defaultPassthroughServiceImplementation;
​
int main()
{
 return defaultPassthroughServiceImplementation<IHello>();
}

然后是makefile
cc_binary {
 name: "vendor.sample.hello@1.0-service",
 relative_install_path: "hw",
 defaults: ["hidl_defaults"],
 vendor: true,
 init_rc: ["vendor.sample.hello@1.0-service.rc"],
 srcs: [
 "service.cpp",
 ],
 shared_libs: [
 "liblog",
 "libutils",
 "libhidlbase",
 "libhidltransport",
 "libutils",
 "vendor.sample.hello@1.0",
 ],
}

然后编译，应该就能看到生产impl的库和一个可执行程序用来起server的。

下面的代码，是主体实现端的代码
#define LOG_TAG     "Sample"
​
#include "Hello.h"
#include <log/log.h>
​
namespace vendor {
namespace sample {
namespace hello {
namespace V1_0 {
namespace implementation {
​
sp<IHelloCallback> Hello::mCallback = nullptr;
​
// Methods from ::vendor::sample::hello::V1_0::IHello follow.
Return<void> Hello::init() {
 mExit = false;
 run("sample");
 return Void();
}
​
Return<void> Hello::release() {
 mExit = true;
 return Void();
}
​
Return<void> Hello::setCallback(const sp<::vendor::sample::hello::V1_0::IHelloCallback>& callback) {
 mCallback = callback;
 if(mCallback != nullptr) {
  ALOGD("setCallback: done");
 }
​
return Void();
​
}
​
bool Hello::threadLoop()
{
 static int32_t count = 0;
 HalEvent event;
 while(!mExit) {
  ::sleep(1);
  event.value = count ++;
  if(mCallback != nullptr) {
   mCallback->onNotify(event);
  }
 }
 ALOGD("threadLoop: exit");
 return false;
}
​
// Methods from ::android::hidl::base::V1_0::IBase follow.
​
IHello* HIDL_FETCH_IHello(const char* /* name */) {
 return new Hello();
}
//
}  // namespace implementation
}  // namespace V1_0
}  // namespace hello
}  // namespace sample
}  // namespace vendor
run函数就相当于是启动了一个线程，sample是线程的名字，具体可以看一下继承的父类 android::Thread
在init函数里面调用run方法启动线程，线程的主体是threadLoop函数，可以看到在线程里面，会每隔1秒钟循环去callback一次方法;

下面是client的实现
#define LOG_TAG     "TestHello"
​
#include <log/log.h>
#include <vendor/sample/hello/1.0/types.h>
#include <vendor/sample/hello/1.0/IHello.h>
#include <vendor/sample/hello/1.0/IHelloCallback.h>
#include <hidl/Status.h>
#include <hidl/HidlSupport.h>
​
using android::sp;
using android::hardware::Return;
using android::hardware::Void;
​
using vendor::sample::hello::V1_0::HalEvent;
using vendor::sample::hello::V1_0::IHello;
using vendor::sample::hello::V1_0::IHelloCallback;
​
class HelloCallback: public IHelloCallback {
public:
 HelloCallback() {

}
​
~HelloCallback() {

}
​
Return<void> onNotify(const HalEvent& event) {
​
 ALOGD("onNotify: value = %d", event.value);
​
 return Void();
}
​
};
​
int main(void)
{
 sp<IHello> service = IHello::getService();
 if(service == nullptr) {
  ALOGE("main: failed to get hello service");
  return -1;
 }
​
sp<HelloCallback> callback = new HelloCallback();
service->setCallback(callback);
service->init();
​
::sleep(10);
service->release();
​
return 0;
​
}
在client端就是简单的打印了callback回来的event里面的数据

下面是makefile的代码
cc_binary {
 name: "test_hello",
 srcs: [
 "test_hello.cpp",
 ],
 shared_libs: [
 "liblog",
 "libutils",
 "libhidlbase",
 "libhidltransport",
 "libutils",
 "vendor.sample.hello@1.0",
 ],
}

编译后手动运行测试程序
并通过logcat来获取log输出并观察；

实例总结
未完待续...

参考资料
https://www.jianshu.com/p/b3a2c7117ccc
https://www.jianshu.com/p/b80865c61d8e