Android hid 数据传输（device 端 ）

最近一直在处理hid 数据需求，简而言之就是两台装备直接可以通过usb 线相互通报数据。
项目架构

为什么Device 端要采用HID（人机接口装备）的方式发送和接收数据呢？
主要是速率快，举个例子，就是鼠标移动，屏幕可以及时相应，用的也是这种协议。
因为Host端底层我们控制不了，不能保证都支持Hid 协议，以是Host 端采用跨平台方案，libusb 协议。
Liusb 网上介绍的很多啦，可以运行在各个平台，windows ,android.linux,是一种理想中的跨平台数据传输方案。

项目主要功能

1，sensor数据传输
2，TP 数据传输（按键传输同理）


项目主要技术点

1，TP数据监听
2，sensor数据监听
3，hid 数据传输丢失问题
4，HID 节点天生监听
5，开机启动native 服务处理数据
6，selinux 权限问题

技术实现

代码结构

TP数据监听

驱动全部的滑动 和 按键 上报都是通过节点的方式，不同平台节点有所差异，需要和驱动沟通。我试验的平台节点是：

1. #define INPUT_KEY_NODE "/dev/input/event1"
2. #define INPUT_TP_NODE "/dev/input/event3"

复制代码

以是监听这两个就行了，我们这里采用的是poll 的方式，有数据的时候会回调，没有的话会阻塞
主要代码

1. void HidReceiver::listenThread()
2. {
3.     struct pollfd fds[IN_FILES];
4.     fds[0].events = POLLIN;
5.     fds[1].events = POLLIN;
6.     fds[2].events = POLLIN;
7.     int result;
8.     char buff[512];
9. //    sleep(1);
10.     LOGD("hid open");
11.     hid_fd = open(DEVICE_NODE, O_RDWR | O_NONBLOCK);
12.     int key_fd =  open(INPUT_KEY_NODE, O_RDWR | O_NONBLOCK);
13.     int tp_fd =  open(INPUT_TP_NODE, O_RDWR | O_NONBLOCK);
14.     LOGD("nod %d,%d,%d",hid_fd,key_fd,tp_fd);
15.     fds[0].fd = hid_fd;
16.     fds[1].fd = key_fd;
17.     fds[2].fd = tp_fd;
20.     unsigned char data[sizeof(input_event)];
21.     input_event dev_data;
23.     while(1){
24.         result = poll(fds, IN_FILES, -1);
25.         if (result == 0) {
26.             LOGD("Poll timeout");
27.         } else if(result > 0){
28.             if ((fds[0].revents & POLLIN)){
29.                 int size = read(fds[0].fd, buff, sizeof(buff));
30.                 if(size > 0){
31.                     process_event(buff);
32.                 }
33.             }
35.             if ((fds[1].revents & POLLIN)){
36.                 int size = read (fds[1].fd, (unsigned char*)data, sizeof(input_event));
37.                 LOGD("size:%d", size);
38.                 memcpy(&dev_data, data, sizeof(input_event));
39.                 LOGD("Keyevent size:%d", dev_data.type);
40.                 // sensordata.sensorType = 0x104;
41.                 // sensordata.ievent = dev_data;
42.                 // process_event(sensordata);
43.             }
46.             if ((fds[2].revents & POLLIN)){
47.                 int size = read (fds[2].fd, (unsigned char*)data, sizeof(input_event));
48.                 memcpy(&dev_data, data, sizeof(input_event));
49.                 #if 0
50.                 LOGD("abs size:%d", dev_data.type);
51.                 if (dev_data.type == EV_ABS)
52.                 {
53.                     if (dev_data.code == ABS_MT_POSITION_X)
54.                     {
55.                             x = dev_data.value;
56.                             if (x < 0) x = 0;
57.                             LOGD("rel X:%d", dev_data.value);
58.                     }
59.                     else if(dev_data.code == ABS_MT_POSITION_Y)
60.                     {
61.                             LOGD("\nx=%d,y=%d,dev_data.code=%d\n", x, y,dev_data.code);
62.                             y = dev_data.value;
63.                             if (y < 0) y = 0;
64.                             sensordata.sensorType = 0x104;
65.                             sensordata.abs_x = x;
66.                             sensordata.abs_y = y;
67.                             process_event(sensordata);
68.                             x = 0;
69.                             y = 0;
70.                     }
71.                 }
72.                 #endif
73.                 if (dev_data.type == EV_KEY)
74.                 {
75.                     LOGD("EV_KEY %d",dev_data.code);
76.                     switch(dev_data.code){
77.                         case KEY_KP5://双击
78.                         case KEY_DASHBOARD://单机
79.                         case KEY_F17://左滑
80.                         case KEY_ISO://右滑
81.                         case KEY_F16://上滑
82.                         case KEY_CONFIG://下滑
83.                             sensordata.sensorType = 0x104;
84.                             sensordata.type = dev_data.type;
85.                             sensordata.code = dev_data.code;
86.                             sensordata.value = dev_data.value;
87.                             sensordata.priority = 3;
88.                             process_event(sensordata);
89.                             break;            
90.                     }
91.                 }
92.             }
93.         }   
94.     }
95. }

复制代码

代码中DEVICE_NODE  用于监听hid 数据的，这个后面说。
sensor数据监听

1. void SensorTransfer::listenThread()
2. {
3.     int64_t stamp;
4.     LOGD("listenThread");
5.     while (m_bListening)
6.     {
7.         ASensorEvent event;
8.         while (ASensorEventQueue_getEvents(m_pEvtQue, &event, 1) > 0)
9.         {
10.             stamp = event.timestamp;
11.             switch (event.type)
12.             {
13.             // case ASENSOR_TYPE_GYROSCOPE:
14.             //     printf("GYROSCOPE:(%llu, %f,%f,%f)\n", (unsigned long long)stamp, event.data[0], event.data[1], event.data[2]);
15.             //     break;
16.             case ASENSOR_TYPE_ACCELEROMETER:
17.                 // printf("ACCELEROMETER: (%llu, %f,%f,%f)\n", (unsigned long long)stamp, event.data[0], event.data[1], event.data[2]);
18.                 sensordata.stamp = stamp;
19.                 sensordata.sensorType = 0x100;
20.                 sensordata.xvalue = event.data[0];
21.                 sensordata.yvalue = event.data[1];
22.                 sensordata.zvalue = event.data[2];
23.                 saveSensorData(sensordata);
24.                 sensordata.priority = 1;
25.                 break;
26.             case ASENSOR_TYPE_GRAVITY:
27.                 // printf("GRAVITY: (%llu, %f,%f,%f)\n", (unsigned long long)stamp, event.data[0], event.data[1], event.data[2]);
28.                 sensordata.stamp = stamp;
29.                 sensordata.sensorType = 0x101;
30.                 sensordata.xvalue = event.data[0];
31.                 sensordata.yvalue = event.data[1];
32.                 sensordata.zvalue = event.data[2];
33.                 sensordata.priority = 1;
34.                 saveSensorData(sensordata);
36.                 break;
37.             case ASENSOR_TYPE_PROXIMITY:
38.                 sensordata.stamp = stamp;
39.                 sensordata.sensorType = 0x102;
40.                 sensordata.lightvalue = event.data[0];
41.                 sensordata.priority = 1;
42.                 saveSensorData(sensordata);
43.                 break;
44.             default:
45.                 break;
46.             }
47.         }
48.         usleep(1000);
49.     }
50. }

复制代码

这个参考的一个博主的方案，主要是通过循环读取native sensor 数据。
监听HID节点删除添加

1. void HidReceiver::nodWatch(){
2.     int length, i = 0;
3.     int fd;
4.     int wd;
5.     char buffer[BUF_LEN];
7.     fd = inotify_init();
8.     if (fd < 0) {
9.         LOGD("inotify_init");
10.     }
12.     wd = inotify_add_watch(fd, DEV_NODE,
13.                            IN_CREATE );
14.     if (wd < 0) {
15.         LOGD("inotify_add_watch");
16.     }
18.     LOGD("Monitoring directory: %s", DEV_NODE);
19.     bool monitor = true;
20.     while (monitor) {
21.         LOGD("start monitor");
22.         length = read(fd, buffer, BUF_LEN);  
23.         if (length < 0) {
24.             LOGD("read");
25.         }  
26.         i = 0;
27.         LOGD("read %d",length);
28.         while (i < length) {
29.             struct inotify_event *event = (struct inotify_event *) &buffer[i];
30.             LOGD("inotify_event %d",event->len);
31.             if (event->len) {
32.                 LOGD("ievent->mask %d",event->mask);
33.                 if (event->mask & IN_CREATE) {
34.                     LOGD("Created: %s", event->name);
35.                     if(strcmp(event->name,"hidg0") == 0){
36.                         LOGD("Created: hidg0");
37.                         monitor = false;
38.                         startListen();
39.                         inotify_rm_watch(fd, wd);
40.                         return;
41.                     }
42.                 } else if (event->mask & IN_DELETE) {
43.                     LOGD("Deleted: %s", event->name);
44.                 } else if (event->mask & IN_MODIFY) {
45.                     LOGD("Modified: %s", event->name);
46.                 } else if (event->mask & IN_MOVED_FROM) {
47.                     LOGD("Moved from: %s", event->name);
48.                 } else if (event->mask & IN_MOVED_TO) {
49.                     LOGD("Moved to: %s", event->name);
50.                 }
51.             }
52.             i += EVENT_SIZE + event->len;
53.         }
54.     }
55. }

复制代码

Hid 数据传输和数据丢失问题

hid 数据怎么传，其实很简单，写节点就可以了，但是数据量太大的时候，会出现写节点失败，同时，按键或者TP 等数据，也会丢失，sensor 数据丢失感知倒不是很大，但是按键和触摸这些传输失败，Host端就无法相应，体验会很差。

目前采用的方案是
Bufferqueue + 延时 办理HID 数据丢失的问题(生产者斲丧者模式)
priority_queue  办理用户自动利用的数据优先级问题，主要是TP 和 按键，保证优先相应
主要代码：
斲丧者

1. // 消费者线程，读取队列中的数据并发送
2. void SensorTransfer::consumer() {
3.     while (true) {
4.         std::unique_lock<std::mutex> lock(queueMutex);
5.         dataCondition.wait(lock, [this] { return !bufferQueue.empty(); });
6.         // if (!bufferQueue.empty())
7.         //     break; // 程序结束
8.         if(!bufferQueue.empty()){
9.             sensor_data data = bufferQueue.top();
10.             // 发送数据到 HID 设备
11.             int written = write(hid_fd,&data,sizeof(struct sensor_data));
12.             if(written >=0){
13.                 bufferQueue.pop();
14.             }else{
15.                 //LOGD("rewrite data result fail");
16.                 std::this_thread::sleep_for(std::chrono::milliseconds(1)); // 控制发送速率
17.             }
18.             if(data.sensorType == 259){
19.                 LOGD("consumer sn");
20.                 std::this_thread::sleep_for(std::chrono::milliseconds(5));
21.             }
22.             if(data.sensorType == 260){
23.                 LOGD("consumer KEY");
24.                 std::this_thread::sleep_for(std::chrono::milliseconds(5));
25.             }
26.         }else{
27.             LOGD("consumer 等待");
28.         }
29.     }
30. }

复制代码

生产者

1. int SensorTransfer::saveSensorData(sensor_data data) {
2.     //std::lock_guard<std::mutex> lock(queueMutex);
3.     if (bufferQueue.size() < MAX_QUEUE) { // 限制队列最大长度
4.         bufferQueue.push(data);
5.         sensor_data topdata = bufferQueue.top();
6.         if(topdata.sensorType != 259&&topdata.sensorType != 260){
7.             dataCondition.notify_one(); // 通知消费者线程
8.         }
9.     }else{
10.         LOGD("buffer is full");
11.     }
12.     return 0;
13. }

复制代码

selinux 添加
这个是老一套了，之前也写过文章，可以参考这里直接贴上主要权限
新增hidtransfer.te

1. type hidtransfer, domain,mlstrustedsubject;
2. typeattribute hidtransfer coredomain;
3. type hidtransfer_exec, system_file_type, exec_type, file_type;
4. binder_use(hidtransfer)
5. init_daemon_domain(hidtransfer)
7. allow hidtransfer system_server:unix_stream_socket {read write};
8. allow hidtransfer tty_device:chr_file {write read getattr};
9. allow hidtransfer hid_device:chr_file { read getattr open ioctl write};
10. allow hidtransfer device:dir read;
11. allow hidtransfer system_server:binder call;
12. allow hidtransfer tty_device:chr_file ioctl;
13. allow hidtransfer serialno_prop:file { map getattr open read};
14. allow hidtransfer permission_service:service_manager find;
15. allow hidtransfer sensorservice_service:service_manager find;
16. allow hidtransfer input_device:chr_file { read write open };
17. allow hidtransfer input_device:dir { search };
18. allow hidtransfer device:dir watch;
19. allow hidtransfer system_server:fd use;

复制代码

file_contexts

1. /system/bin/hidtransfer u:object_r:hidtransfer_exec:s0
2. /dev/hidg0 u:object_r:hid_device:s0

复制代码

device.te

1. type hid_device,dev_type;

复制代码

参考：
1.Android Native Sensor(C++)实例_sensor hal 陀螺仪读取数据实当代码-CSDN博客


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。