#2020征文-开发板#【AI Camera连载】HDF驱动和应用编译框架梳理

    root {
        device_info {
            match_attr = "hdf_manager";
            template host {
                hostName = "";
                priority = 100;
                template device {
                    template deviceNode {
                        policy = 0;
                        priority = 100;
                        preload = 0;
                        permission = 0664;
                        moduleName = "";
                        serviceName = "";
                        deviceMatchAttr = "";
                    }
                }
            }
            ++++
            sample_host :: host {
                hostName = "sample_host"; // host名称，host节点是用来存放某一类驱动的容器
                sample_device :: device { // sample设备节点
                    device0 :: deviceNode { // sample驱动的DeviceNode节点
                        policy = 2; // 驱动服务发布的策略：驱动对内核态和用户态都发布服务
                        priority = 100; // host启动优先级（0-200），值越大优先级越低，建议默认配100，优先级相同则不保证host的加载顺序
                        preload = 0; // 0=DEVICE_PRELOAD_ENABLE，系统启动过程中默认加载驱动。
                                     // 1=DEVICE_PRELOAD_DISABLE，系统启动过程中默认不加载驱动。
                        permission = 0664; // 驱动创建设备节点权限
                        moduleName = "sample_driver"; // 驱动和设备提供的服务相关联
                        serviceName = "sample_service"; // 用户空间通过服务名即可找到对应设备的驱动进行操作
                        //deviceMatchAttr = "sample_config"; // 驱动私有数据匹配的关键字，必须和驱动私有数据配置表中的match_attr值相等
                    }
                }
            }
            ++++
        }
    }

    #if 0
    // 补充：
    // 驱动有私有配置：
    root {
        SampLEDriverConfig {
            sample_version = 1;
            sample_bus = "I2C_0";
            match_attr = "sample_config";   //该字段的值必须和device_info.hcs中的deviceMatchAttr值一致
        }
    }
    #endif
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.

    typedef enum {
        /* 驱动不提供服务 */
        SERVICE_POLICY_NONE = 0,
        /* 驱动对内核态发布服务 */
        SERVICE_POLICY_PUBLIC = 1,
        /* 驱动对内核态和用户态都发布服务 */
        SERVICE_POLICY_CAPACITY = 2,
        /* 驱动服务不对外发布服务，但可以被订阅 */
        SERVICE_POLICY_FRIENDLY = 3,
        /* 驱动私有服务不对外发布服务，也不能被订阅 */
        SERVICE_POLICY_PRIVATE = 4,
        /* 错误的服务策略 */
        SERVICE_POLICY_INVALID
    } ServicePolicy;
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.

    #include <fcntl.h>
    #include <sys/stat.h>
    #include <sys/ioctl.h>
    #include "hdf_log.h"
    #include "hdf_base.h"
    #include "hdf_device_desc.h"

    #define HDF_LOG_TAG sample_driver

    // 设置cmd编号，类似于Linux的ioctl命令码。
    #define SAMPLE_WRITE_READ 123
    #define SELECT_DEFAULT 0

    // Dispatch是驱动中用来处理用户态发下来的消息的函数。
    //int32_t HdfSampleDriverDispatch( struct HdfDeviceObject *deviceObject, int id, struct HdfSBuf *data, struct HdfSBuf *reply)
    int32_t HdfSampleDriverDispatch(struct HdfDeviceIoClient *deviceIoClient, int id, struct HdfSBuf *data, struct HdfSBuf *reply)
    {
        HDF_LOGE("%s: received cmd %d", __func__, id);
        if (id == SAMPLE_WRITE_READ) { // 通常会采用switch case的方式来写。
            const char *readData = HdfSbufReadString(data); // 内核从用户空间获取数据，类似Linux的copy_from_user。
            if (readData != NULL) {
                HDF_LOGE("%s: read data is: %s", __func__, readData); // 内核打印从用户空间独到的数据。
            }

            #if SELECT_DEFAULT
            // do nothing
            #else
            // 修改用户空发过来的数据缓冲区指针data的内容,实际上修改无效
            char *readDataChange = "come from kernel sapce: change default event info";
            if (!HdfSbufWriteString(data, readDataChange)) {
                HDF_LOGE("%s: fail to write sbuf", __func__);
            }
            #endif

            #if SELECT_DEFAULT
            // 默认向用户空间返回的是INT32_MAX=2147483647
            if (!HdfSbufWriteInt32(reply, INT32_MAX)) { // 内核向用户空间返回数据，类似Linux的copy_to_user。
                HDF_LOGE("%s: reply int32 fail", __func__);
            }
            #else
            // 将向用户空间返回内容修改为字符串
            char *sendData = "come from kernel sapce: default event info";
            if (!HdfSbufWriteString(reply, sendData)) {
                HDF_LOGE("%s: fail to write sbuf", __func__);
            }
            #endif

            // 通HdfDeviceSendEvent函数触发用户空间获取驱动上报数据。
                // return HdfDeviceSendEvent(deviceObject, id, data);
            return HdfDeviceSendEvent(deviceIoClient->device, id, data);
        }
        return HDF_FAILURE;
    }

    // 驱动资源释放的接口，本例未分配需要回收的资源，因此为空。
    void HdfSampleDriverRelease(struct HdfDeviceObject *deviceObject)
    {
        // release resources here
        return;
    }

    // 用户态获取驱动的服务，获取该服务之后通过服务中的Dispatch方法向驱动发送消息。
    int HdfSampleDriverBind(struct HdfDeviceObject *deviceObject)
    {
        if (deviceObject == NULL) {
            return HDF_FAILURE;
        }
        static struct IDeviceIoService testService = {
            // Dispatch是用来处理用户态发下来的消息。
            .Dispatch = HdfSampleDriverDispatch,
        };
        deviceObject->service = &testService;
        return HDF_SUCCESS;
    }

    #if 0
    // 补充：
    // HdfSampleDriverBind中除了常用的IDeviceIoService，这里还可以扩展其他服务。
    struct ISampleDriverService {
        struct IDeviceIoService ioService;       // 服务结构的首个成员必须是IDeviceIoService类型的成员
        int32_t (*ServiceA)(void);               // 驱动的第一个服务接口
        int32_t (*ServiceB)(uint32_t inputCode); // 驱动的第二个服务接口，有多个可以依次往下累加
    };

    驱动服务接口的实现
    int32_t SampleDriverServiceA(void)
    {
        // 驱动开发者实现业务逻辑
        return 0;
    }

    int32_t SampleDriverServiceB(uint32_t inputCode)
    {
        // 驱动开发者实现业务逻辑
        return 0;
    }

    int HdfSampleDriverBind(struct HdfDeviceObject *deviceObject)
    {
        if (deviceObject == NULL) {
            return HDF_FAILURE;
        }
        static struct ISampleDriverService testService = {
            .ServiceA = SampleDriverServiceA,
            .ServiceB = SampleDriverServiceB,
        };
        deviceObject->service = &testService.ioService;
        return HDF_SUCCESS;
    }
    #endif

    // 驱动自身业务初始的接口。
    int HdfSampleDriverInit(struct HdfDeviceObject *deviceObject)
    {
        if (deviceObject == NULL) {
            HDF_LOGE("%s::ptr is null!", __func__);
            return HDF_FAILURE;
        }
        HDF_LOGE("Sample driver Init success");
        return HDF_SUCCESS;
    }

    // 定义驱动入口的对象，必须为HdfDriverEntry（在hdf_device_desc.h中定义）类型的全局变量。
    struct HdfDriverEntry g_sampleDriverEntry = {
        .moduleVersion = 1,
        .moduleName = "sample_driver", // 驱动的关键名称。
        .Bind = HdfSampleDriverBind,
        .Init = HdfSampleDriverInit,
        .Release = HdfSampleDriverRelease,
    };

    // 调用HDF_INIT将驱动入口注册到HDF框架中，在加载驱动时HDF框架会先调用Bind函数,
    // 再调用Init函数加载该驱动，当Init调用异常时，HDF框架会调用Release释放驱动资源并退出。
    HDF_INIT(g_sampleDriverEntry);
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.
95.
96.
97.
98.
99.
100.
101.
102.
103.
104.
105.
106.
107.
108.
109.
110.
111.
112.
113.
114.
115.
116.
117.
118.
119.
120.
121.
122.
123.
124.
125.
126.
127.
128.
129.
130.
131.
132.
133.
134.

    # Copyright (c) 2020 Huawei Device Co., Ltd.
    # Licensed under the Apache License, Version 2.0 (the "License");
    # you may not use this file except in compliance with the License.
    # You may obtain a copy of the License at
    #
    #     http://www.apache.org/licenses/LICENSE-2.0
    #
    # Unless required by applicable law or agreed to in writing, software
    # distributed under the License is distributed on an "AS IS" BASIS,
    # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    # See the License for the specific language governing permissions and
    # limitations under the License.

    config DRIVERS_HDF_PLATFORM_HDF_SAMPLE
        bool "Enable HDF platform HDF sample driver"
        default n
        depends on DRIVERS_HDF_PLATFORM
        help
          Answer Y to enable HDF platform HDF sample driver.
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.

    source "../../vendor/huawei/hdf/display/driver/Kconfig"
    +source "../../vendor/huawei/hdf/sample/platform/hdf-sample/Kconfig"
1.
2.

    # Copyright (c) 2020 Huawei Device Co., Ltd.
    # Licensed under the Apache License, Version 2.0 (the "License");
    # you may not use this file except in compliance with the License.
    # You may obtain a copy of the License at
    #
    #     http://www.apache.org/licenses/LICENSE-2.0
    #
    # Unless required by applicable law or agreed to in writing, software
    # distributed under the License is distributed on an "AS IS" BASIS,
    # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    # See the License for the specific language governing permissions and
    # limitations under the License.

    include $(LITEOSTOPDIR)/config.mk
    include $(LITEOSTOPDIR)/../../drivers/hdf/lite/lite.mk

    MODULE_NAME := hdf_sample

    LOCAL_CFLAGS += $(HDF_INCLUDE)

    LOCAL_SRCS += hdf_sample.c

    # 警告需要关掉，不然unused的变量都会报错！
    #LOCAL_CFLAGS += -fstack-protector-strong -Wextra -Wall -Werror
    LOCAL_CFLAGS += -fstack-protector-strong

    include $(HDF_DRIVER)
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.

    LITEOS_BASELIB += -lhdf_uart_sample
    LIB_SUBDIRS    += $(VENDOR_HDF_DRIVERS_ROOT)/sample/platform/uart

    +LITEOS_BASELIB += -lhdf_sample
    +LIB_SUBDIRS    += $(VENDOR_HDF_DRIVERS_ROOT)/sample/platform/hdf-sample
1.
2.
3.
4.
5.

    include $(LITEOSTOPDIR)/../../drivers/hdf/lite/lite.mk #导入hdf预定义内容，必需
    MODULE_NAME :=    #生成的结果文件
    LOCAL_INCLUDE :=  #本驱动的头文件目录
    LOCAL_SRCS :=     #本驱动的源代码文件
    LOCAL_CFLAGS ：=  #自定义的编译选项
    include $(HDF_DRIVER) #导入模板makefile完成编译
1.
2.
3.
4.
5.
6.

    LITEOS_BASELIB +=  -lxxx  #链接生成的静态库
    LIB_SUBDIRS    +=         #驱动代码Makefile的目录
1.
2.

    ...
    clean hi3516dv300 finish
    make[1]: Entering directory '/home/ubuntu/harmony/sdk/kernel/liteos_a'
    /home/ubuntu/harmony/sdk/kernel/liteos_a/tools/menuconfig/conf --silentoldconfig /home/ubuntu/harmony/sdk/kernel/liteos_a/Kconfig
    *
    * Restart config...
    *
    *
    * Driver
    *
    Enable Driver (DRIVERS) [Y/n/?] y
      Enable USB (DRIVERS_USB) [Y/n/?] y
        Enable USB HCD (DRIVERS_USB_HOST_DRIVER) [Y/n/?] y
          USB HCD
            1. Enable EHCI HCD (USB 2.0) (DRIVERS_USB_HOST_EHCI)
          > 2. Enable XHCI HCD (USB 3.0) (DRIVERS_USB_HOST_XHCI)
          choice[1-2?]: 2
    Enable USB Device Class Drivers (DRIVERS_USB_DEVICE_CLASS_DRIVERS) [Y/n/?] y
    Enable HDF manager (DRIVERS_HDF) [Y/n/?] y
      Enable HDF platform driver (DRIVERS_HDF_PLATFORM) [Y/n/?] y
        Enable HDF platform i2c driver (DRIVERS_HDF_PLATFORM_I2C) [Y/n/?] y
        Enable HDF platform spi driver (DRIVERS_HDF_PLATFORM_SPI) [Y/n/?] y
        Enable HDF platform gpio driver (DRIVERS_HDF_PLATFORM_GPIO) [Y/n/?] y
        Enable HDF platform watchdog driver (DRIVERS_HDF_PLATFORM_WATCHDOG) [Y/n/?] y
        Enable HDF platform sdio driver (DRIVERS_HDF_PLATFORM_SDIO) [Y/n/?] y
        Enable HDF platform rtc driver (DRIVERS_HDF_PLATFORM_RTC) [Y/n/?] y
        Enable HDF hisi sdk driver (DRIVERS_HDF_PLATFORM_HISI_SDK) [Y/n/?] y
      Enable HDF WiFi Host driver (DRIVERS_HDF_WIFI) [Y/n/?] y
        Enable Hi3881 Host driver (DRIVERS_HI3881) [Y/n/?] y
      Enable HDF input driver (DRIVERS_HDF_INPUT) [Y/n/?] y
        Enable HDF tp 5P5 gt911 driver (DRIVERS_HDF_TP_5P5_GT911) [Y/n/?] y
      Enable HDF Lcd driver (DRIVERS_HDF_LCD) [Y/n/?] y
        Enable HDF Lcd Icn9700 driver (DRIVERS_HDF_LCD_ICN9700) [Y/n/?] y
    Enable HDF platform HDF sample driver (DRIVERS_HDF_PLATFORM_HDF_SAMPLE) [N/y/?] (NEW) aborted!

    Console input/output is redirected. Run 'make oldconfig' to update configuration.

    make[1]: *** [Makefile:129: genconfig] Error 1
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.

    ./kernel/liteos_a/.config:159:LOSCFG_DRIVERS_HDF_LCD_ICN9700=y
    ./vendor/huawei/hdf/display/driver/Kconfig:8:config DRIVERS_HDF_LCD_ICN9700
1.
2.

    LOSCFG_DRIVERS_HDF_LCD_ICN9700=y
    +LOSCFG_DRIVERS_HDF_PLATFORM_HDF_SAMPLE=y
    LOSCFG_DRIVERS_HDF_USB=y
1.
2.
3.

    sh param:hi3516dv300,clang,debug
1.

    hdf_sample.c:53:21:
    error: incompatible pointer types initializing
    'int32_t (*)(struct HdfDeviceIoClient *, int, struct HdfSBuf *, struct HdfSBuf *)'
    (aka 'int (*)(struct HdfDeviceIoClient *, int, struct HdfSBuf *, struct HdfSBuf *)')
    with an expression of type
    'int (struct HdfDeviceObject *, int, struct HdfSBuf *, struct HdfSBuf *)'
    [-Werror,-Wincompatible-pointer-types]

            .Dispatch = HdfSampleDriverDispatch,
1.
2.
3.
4.
5.
6.
7.
8.
9.

    // Dispatch是驱动中用来处理用户态发下来的消息的函数。
    -int32_t HdfSampleDriverDispatch( struct HdfDeviceObject *deviceObject, int id, struct HdfSBuf *data, struct HdfSBuf *reply)
    +int32_t HdfSampleDriverDispatch(struct HdfDeviceIoClient *deviceIoClient, int id, struct HdfSBuf *data, struct HdfSBuf *reply)
    {
        HDF_LOGE("%s: received cmd %d", __func__, id);

            // 通HdfDeviceSendEvent函数触发用户空间获取驱动上报数据。
    -        return HdfDeviceSendEvent(deviceObject, id, data);
    +        return HdfDeviceSendEvent(deviceIoClient->device, id, data);
        }
        return HDF_FAILURE;
    }
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.

./out/ipcamera_hi3516dv300/obj/kernel/liteos_a/obj/vendor/huawei/hdf/sample/platform/hdf_sample
1.

    #include <fcntl.h>
    #include <unistd.h>
    #include "hdf_log.h"
    #include "hdf_sbuf.h"
    #include "hdf_io_service_if.h"

    #define HDF_LOG_TAG "sample_test"
    #define SAMPLE_SERVICE_NAME "sample_service"  // 服务的关键名称。

    #define SAMPLE_WRITE_READ 123
    #define SELECT_DEFAULT 0

    int g_replyFlag = 0;

    // 用户空间回调函数，驱动通过HdfDeviceSendEvent发送事件后，该函数将处理返回数据。
    static int OnDevEventReceived(void *priv,  uint32_t id, struct HdfSBuf *data)
    {
        const char *string = HdfSbufReadString(data);
        if (string == NULL) {
            HDF_LOGE("fail to read string in event data");
            g_replyFlag = 1;
            return HDF_FAILURE;
        }
        HDF_LOGE("user space received:");
        HDF_LOGE("%s: dev event received: %u %s",  (char *)priv, id, string);
        g_replyFlag = 1;
        return HDF_SUCCESS;
    }

    // 用户空间给内核驱动发送数据
    static int SendEvent(struct HdfIoService *serv, char *eventData)
    {
        int ret = 0;

        // 获取系统分配的data sbuf。
        struct HdfSBuf *data = HdfSBufObtainDefaultSize();
        if (data == NULL) {
            HDF_LOGE("fail to obtain sbuf data");
            return 1;
        }

        // 获取系统分配的reply sbuf。
        struct HdfSBuf *reply = HdfSBufObtainDefaultSize();
        if (reply == NULL) {
            HDF_LOGE("fail to obtain sbuf reply");
            ret = HDF_DEV_ERR_NO_MEMORY;
            goto out;
        }

        // 将用户空间目标数据放到sbuf。
        if (!HdfSbufWriteString(data, eventData)) {
            HDF_LOGE("fail to write sbuf");
            ret = HDF_FAILURE;
            goto out;
        }

        // 通过驱动服务提供的Dispatch实现用户态应用和内核态驱动的信息交互。
        ret = serv->dispatcher->Dispatch(&serv->object, SAMPLE_WRITE_READ, data, reply);
        if (ret != HDF_SUCCESS) {
            HDF_LOGE("fail to send service call");
            goto out;
        }

        #if SELECT_DEFAULT
        // 默认将sbuf中获取到的int数据放到用户空间变量中。
        int replyData = 0;
        if (!HdfSbufReadInt32(reply, &replyData)) {
            HDF_LOGE("fail to get service call reply");
            ret = HDF_ERR_INVALID_OBJECT;
            goto out;
        }
        HDF_LOGE("Get reply is: %d", replyData);
        #else
        // 将sbuf中获取到的字符串数据放到用户空间变量中。
        const char *replyData = HdfSbufReadString(reply);
        if (replyData == NULL) {
            HDF_LOGE("fail to get service call reply");
            ret = HDF_ERR_INVALID_OBJECT;
            goto out;
        }
        HDF_LOGE("Get reply is: %s", replyData);
        #endif
    out:
        HdfSBufRecycle(data); // 释放用于数据中转的sbuf
        HdfSBufRecycle(reply); // 释放用于数据中转的sbuf
        return ret;
    }

    int main()
    {
        char *sendData = "come from user sapce: default event info";

        // 用户态获取驱动的服务，获取该服务之后通过服务中的Dispatch方法向驱动发送消息。
        struct HdfIoService *serv = HdfIoServiceBind(SAMPLE_SERVICE_NAME, 0);
        if (serv == NULL) {
            HDF_LOGE("fail to get service %s", SAMPLE_SERVICE_NAME);
            return HDF_FAILURE;
        }

        // 注册订阅驱动服务的回调函数。
        static struct HdfDevEventlistener listener = {
            .callBack = OnDevEventReceived,
            .priv ="Service0"
        };

    #if 0
        // 补充：
        // 驱动服务的获取有两种方式，HDF框架提供接口直接获取和HDF框架提供订阅机制获取。
        // 1. 当明确驱动已经加载完成时，获取该驱动的服务可以通过HDF框架提供的能力接口直接获取，如下所示：
            const struct ISampleDriverService *sampleService =
                    (const struct ISampleDriverService *)DevSvcManagerClntGetService("sample_driver");
            if (sampleService == NULL) {
                return -1;
            }
            sampleService->ServiceA();
            sampleService->ServiceB(5);
        // 2. 当对驱动（同一个host）加载的时机不感知时，可以通过HDF框架提供的订阅机制来订阅该驱动。
    #endif

        // 通过HDF提供的订阅机制获取驱动服务。
        if (HdfDeviceRegisterEventListener(serv, &listener) != HDF_SUCCESS) {
            HDF_LOGE("fail to register event listener");
            return HDF_FAILURE;
        }

        // 用户空间给内核驱动发送数据
        HDF_LOGE("user space send:");
        HDF_LOGE("cmd: %u, send data is: %s", SAMPLE_WRITE_READ, sendData);
        if (SendEvent(serv, sendData)) {
            HDF_LOGE("fail to send event");
            return HDF_FAILURE;
        }

        /* wait for event receive event finishing */
        while (g_replyFlag == 0) {
            sleep(1);
        }

        // 用户态程序注册接收驱动上报事件的操作方法。
        if (HdfDeviceUnregisterEventListener(serv, &listener)) {
            HDF_LOGE("fail to  unregister listener");
            return HDF_FAILURE;
        }

        // 释放驱动服务。
        HdfIoServiceRecycle(serv);
        return HDF_SUCCESS;
    }
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.
95.
96.
97.
98.
99.
100.
101.
102.
103.
104.
105.
106.
107.
108.
109.
110.
111.
112.
113.
114.
115.
116.
117.
118.
119.
120.
121.
122.
123.
124.
125.
126.
127.
128.
129.
130.
131.
132.
133.
134.
135.
136.
137.
138.
139.
140.
141.
142.
143.
144.
145.
146.
147.
148.

deps = [ "//drivers/hdf/lite/manager:hdf_core", "//drivers/hdf/lite/adapter/osal/posix:hdf_posix_osal", ]
1.

    # Copyright (c) 2020 Huawei Device Co., Ltd.
    # Licensed under the Apache License, Version 2.0 (the "License");
    # you may not use this file except in compliance with the License.
    # You may obtain a copy of the License at
    #
    #     http://www.apache.org/licenses/LICENSE-2.0
    #
    # Unless required by applicable law or agreed to in writing, software
    # distributed under the License is distributed on an "AS IS" BASIS,
    # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    # See the License for the specific language governing permissions and
    # limitations under the License.

    import("//build/lite/config/component/lite_component.gni")
    import("//build/lite/ndk/ndk.gni")

    HDF_FRAMEWORKS = "//drivers/hdf/frameworks"

    executable("hdf_sample_app") {
        sources = [
            "hdf_sample_app.c"
        ]

        include_dirs = [
            "$HDF_FRAMEWORKS/ability/sbuf/include",
            "$HDF_FRAMEWORKS/core/shared/include",
            "$HDF_FRAMEWORKS/core/host/include",
            "$HDF_FRAMEWORKS/core/master/include",
            "$HDF_FRAMEWORKS/include/core",
            "$HDF_FRAMEWORKS/include/utils",
            "$HDF_FRAMEWORKS/utils/include",
            "$HDF_FRAMEWORKS/include/osal",
            "//third_party/bounds_checking_function/include",
        ]

        deps = [
            "//drivers/hdf/lite/manager:hdf_core",
            "//drivers/hdf/lite/adapter/osal/posix:hdf_posix_osal",
        ]

        public_deps = [
            "//third_party/bounds_checking_function:libsec_shared",
        ]
        defines = [
            "__USER__",
        ]

        cflags = [
            "-Wall",
            "-Wextra",
        ]
    }
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.

    {
      "subsystem": [
        {
          "name": "hdf",
          "component": [
            { "name": "posix", "dir": "//drivers/hdf/lite/posix:hdf_posix", "features":[] },
            { "name": "manager", "dir": "//drivers/hdf/lite/manager:hdf_manager", "features":[] },
            { "name": "wifi", "dir": "//vendor/huawei/hdf/wifi:wifi_firmware", "features":[] },
            { "name": "display", "dir": "//vendor/huawei/hdf/display/hdi:hdi_display", "features":[] },
            { "name": "input", "dir": "//vendor/huawei/hdf/input/hdi:hdi_input", "features":[] },
            { "name": "hdf_sample", "dir": "//vendor/huawei/hdf/sample/platform/uart:hello_uart_sample", "features":[] },
    +        { "name": "hdf_sample_app", "dir": "//vendor/huawei/hdf/sample/platform/hdf-sample/app:hdf_sample_app", "features":[] }
          ]
        },
      ]
    }
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.

    Done. Made 251 targets from 160 files in 907ms
    ninja: Entering directory `/home/ubuntu/harmony/sdk/out/ipcamera_hi3516dv300'
    [1/1346] STAMP obj/applications/sample/camera/communication/sample.stamp
    ...
    // 新增的hdf_sample_app
    [1163/1346] clang obj/vendor/huawei/hdf/sample/platform/hdf-sample/app/hdf_sample_app.o
    [1167/1346] LLVM LINK ./bin/hdf_sample_app
    // 可供参考的hello_uart
    [1160/1346] clang obj/vendor/huawei/hdf/sample/platform/uart/dev/hello_uart_dev.o
    [1161/1346] LLVM LINK ./bin/hello_uart
    [1169/1346] clang obj/vendor/huawei/hdf/sample/platform/uart/dispatch/uart_if.o
    [1170/1346] clang obj/vendor/huawei/hdf/sample/platform/uart/dispatch/hello_uart_dispatch.o
    [1171/1346] LLVM LINK ./bin/hello_uart_dispatch
    [1172/1346] STAMP obj/vendor/huawei/hdf/sample/platform/uart/hello_uart_sample.stamp
    ...
    [1344/1346] STAMP obj/build/lite/ohos.stamp
    [1345/1346] ACTION //build/lite:gen_rootfs(//build/lite/toolchain:linux_x86_64_clang)
    [1346/1346] STAMP obj/build/lite/gen_rootfs.stamp
    ohos ipcamera_hi3516dv300 build success!
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.

    ./bin/hdf_sample_app
1.

    OHOS # ./bin/hdf_sample_app
    // 用户空间给内核驱动发送数据
    [HDF:E/"sample_test"]user space send:
    [HDF:E/"sample_test"]cmd: 123, send data is: come from user sapce: default event info

    // 被驱动中用来处理用户态发下来的消息的函数HdfSampleDriverDispatch接收到
    [ERR][HDF:E/sample_driver]HdfSampleDriverDispatch: received cmd 123
    [ERR][HDF:E/sample_driver]HdfSampleDriverDispatch: read data is: come from user sapce: default event info

    // 默认：用户空间回调函数OnDevEventReceived的打印信息
    [HDF:E/"sample_test"]user space received:
    [HDF:E/"sample_test"]Service0: dev event received: 123 come from user sapce: default event info
    [HDF:E/"sample_test"]Get reply is: 2147483647
    [HDF:E/hdf_syscall_adapter]event listener task exit
    // 修改后：
    [HDF:E/"sample_test"]user space received:
    [HDF:E/"sample_test"]Service0: dev event received: 123 come from user sapce: default event info // 这了尝试打印出“change default event info”，但修改无效
    [HDF:E/"sample_test"]Get reply is: come from kernel sapce: default event info
    [HDF:E/hdf_syscall_adapter]event listener task exit
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.