1 /*
2 * Copyright (c) 2023-2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "hid_ddk_service.h"
17 #include <hdf_base.h>
18 #include "emit_event_manager.h"
19 #include "hid_ddk_permission.h"
20 #include "input_uhdf_log.h"
21 #include <unistd.h>
22 #include <fcntl.h>
23 #include <iostream>
24 #include <sys/ioctl.h>
25 #include <linux/hiddev.h>
26 #include <linux/hidraw.h>
27 #include <poll.h>
28 #include <memory.h>
29 #include <securec.h>
30 #include "ddk_sysfs_dev_node.h"
31 #ifdef __LITEOS__
32 #include "hid_liteos_adapter.h"
33 #else
34 #include "hid_linux_adapter.h"
35 #endif
36
37 #define HDF_LOG_TAG hid_ddk_service
38
39 namespace OHOS {
40 namespace HDI {
41 namespace Input {
42 namespace Ddk {
43 namespace V1_1 {
44 const uint8_t THIRTY_TWO_BIT = 32;
45 const uint32_t MAX_REPORT_BUFFER_SIZE = 16 * 1024 - 1;
46
GetBusNum(uint64_t devHandle)47 inline uint32_t GetBusNum(uint64_t devHandle)
48 {
49 return static_cast<uint32_t>(devHandle >> THIRTY_TWO_BIT);
50 }
51
GetDevNum(uint64_t devHandle)52 inline uint32_t GetDevNum(uint64_t devHandle)
53 {
54 return static_cast<uint32_t>(devHandle & 0xFFFFFFFF);
55 }
56
57 static const std::string PERMISSION_NAME = "ohos.permission.ACCESS_DDK_HID";
58
HidDdkImplGetInstance(void)59 extern "C" IHidDdk *HidDdkImplGetInstance(void)
60 {
61 std::shared_ptr<HidOsAdapter> osAdapter;
62 #ifdef __LITEOS__
63 osAdapter = std::make_shared<LiteosHidOsAdapter>();
64 #else
65 osAdapter = std::make_shared<LinuxHidOsAdapter>();
66 #endif
67 return new (std::nothrow) HidDdkService(osAdapter);
68 }
69
CreateDevice(const Hid_Device & hidDevice,const Hid_EventProperties & hidEventProperties,uint32_t & deviceId)70 int32_t HidDdkService::CreateDevice(const Hid_Device &hidDevice,
71 const Hid_EventProperties &hidEventProperties, uint32_t &deviceId)
72 {
73 HDF_LOGI("%{public}s create device enter", __func__);
74 if (!DdkPermissionManager::VerifyPermission(PERMISSION_NAME)) {
75 HDF_LOGE("%{public}s: no permission", __func__);
76 return HDF_ERR_NOPERM;
77 }
78
79 int32_t ret = OHOS::ExternalDeviceManager::EmitEventManager::GetInstance()
80 .CreateDevice(hidDevice, hidEventProperties);
81 if (ret < 0) {
82 HDF_LOGE("%{public}s create device faild, ret=%{public}d", __func__, ret);
83 return ret;
84 }
85
86 deviceId = static_cast<uint32_t>(ret);
87 return Hid_DdkErrCode::HID_DDK_SUCCESS;
88 }
89
EmitEvent(uint32_t deviceId,const std::vector<Hid_EmitItem> & items)90 int32_t HidDdkService::EmitEvent(uint32_t deviceId, const std::vector<Hid_EmitItem> &items)
91 {
92 HDF_LOGI("%{public}s emit event enter, the id of device = %{public}d", __func__, deviceId);
93 if (!DdkPermissionManager::VerifyPermission(PERMISSION_NAME)) {
94 HDF_LOGE("%{public}s: no permission", __func__);
95 return HDF_ERR_NOPERM;
96 }
97
98 return OHOS::ExternalDeviceManager::EmitEventManager::GetInstance().EmitEvent(deviceId, items);
99 }
100
DestroyDevice(uint32_t deviceId)101 int32_t HidDdkService::DestroyDevice(uint32_t deviceId)
102 {
103 HDF_LOGI("%{public}s destroy device enter, the id of device = %{public}d", __func__, deviceId);
104 if (!DdkPermissionManager::VerifyPermission(PERMISSION_NAME)) {
105 HDF_LOGE("%{public}s: no permission", __func__);
106 return HDF_ERR_NOPERM;
107 }
108
109 return OHOS::ExternalDeviceManager::EmitEventManager::GetInstance().DestroyDevice(deviceId);
110 }
111
Init()112 int32_t HidDdkService::Init()
113 {
114 HDF_LOGD("%{public}s init enter", __func__);
115 if (!DdkPermissionManager::VerifyPermission(PERMISSION_NAME)) {
116 HDF_LOGE("%{public}s: no permission", __func__);
117 return HID_DDK_NO_PERM;
118 }
119
120 return HID_DDK_SUCCESS;
121 }
122
Release()123 int32_t HidDdkService::Release()
124 {
125 HDF_LOGD("%{public}s release enter", __func__);
126 if (!DdkPermissionManager::VerifyPermission(PERMISSION_NAME)) {
127 HDF_LOGE("%{public}s: no permission", __func__);
128 return HID_DDK_NO_PERM;
129 }
130
131 return HID_DDK_SUCCESS;
132 }
133
Open(uint64_t deviceId,uint8_t interfaceIndex,HidDeviceHandle & dev)134 int32_t HidDdkService::Open(uint64_t deviceId, uint8_t interfaceIndex, HidDeviceHandle& dev)
135 {
136 HDF_LOGD("%{public}s open enter", __func__);
137 if (!DdkPermissionManager::VerifyPermission(PERMISSION_NAME)) {
138 HDF_LOGE("%{public}s: no permission", __func__);
139 return HID_DDK_NO_PERM;
140 }
141
142 uint32_t busNum = GetBusNum(deviceId);
143 uint32_t devNum = GetDevNum(deviceId);
144 SysfsDevNode devNode(busNum, devNum, interfaceIndex, "hidraw");
145 std::string path;
146 int32_t ret = devNode.FindPath(path);
147 if (ret != HID_DDK_SUCCESS) {
148 HDF_LOGE("%{public}s device not found, path=%{public}s", __func__, path.c_str());
149 return HID_DDK_DEVICE_NOT_FOUND;
150 }
151
152 char realpathStr[PATH_MAX] = {'\0'};
153 if (realpath(path.c_str(), realpathStr) == nullptr) {
154 HDF_LOGE("%{public}s:realpath failed.ret = %{public}s", __func__, strerror(errno));
155 return HID_DDK_IO_ERROR;
156 }
157
158 FILE* file = fopen(realpathStr, "r+");
159 if (file == nullptr) {
160 HDF_LOGE("%{public}s fopen failed, path=%{public}s, errno=%{public}d", __func__, path.c_str(), errno);
161 return HID_DDK_IO_ERROR;
162 }
163 dev.fd = fileno(file);
164 {
165 std::lock_guard<std::mutex> lock(fileDescriptorLock_);
166 fileDescriptorMap_[dev.fd] = file;
167 }
168
169 return HID_DDK_SUCCESS;
170 }
171
Close(const HidDeviceHandle & dev)172 int32_t HidDdkService::Close(const HidDeviceHandle& dev)
173 {
174 HDF_LOGD("%{public}s close enter", __func__);
175 if (!DdkPermissionManager::VerifyPermission(PERMISSION_NAME)) {
176 HDF_LOGE("%{public}s: no permission", __func__);
177 return HID_DDK_NO_PERM;
178 }
179
180 {
181 std::lock_guard<std::mutex> lock(fileDescriptorLock_);
182 if (fileDescriptorMap_.find(dev.fd) == fileDescriptorMap_.end()) {
183 HDF_LOGE("%{public}s file not found, fd=%{public}d", __func__, dev.fd);
184 return HID_DDK_IO_ERROR;
185 }
186 int32_t ret = fclose(fileDescriptorMap_[dev.fd]);
187 if (ret == EOF) {
188 HDF_LOGE("%{public}s fclose failed, errno=%{public}d", __func__, errno);
189 return HID_DDK_IO_ERROR;
190 }
191 fileDescriptorMap_.erase(dev.fd);
192 }
193
194 return HID_DDK_SUCCESS;
195 }
196
Write(const HidDeviceHandle & dev,const std::vector<uint8_t> & data,uint32_t & bytesWritten)197 int32_t HidDdkService::Write(const HidDeviceHandle& dev, const std::vector<uint8_t>& data, uint32_t& bytesWritten)
198 {
199 HDF_LOGD("%{public}s write enter", __func__);
200 if (!DdkPermissionManager::VerifyPermission(PERMISSION_NAME)) {
201 HDF_LOGE("%{public}s: no permission", __func__);
202 return HID_DDK_NO_PERM;
203 }
204
205 int32_t ret = write(dev.fd, data.data(), data.size());
206 if (ret < 0) {
207 HDF_LOGE("%{public}s write failed, errno=%{public}d", __func__, errno);
208 bytesWritten = 0;
209 return HID_DDK_IO_ERROR;
210 }
211
212 bytesWritten = static_cast<uint32_t>(ret);
213 return HID_DDK_SUCCESS;
214 }
215
ReadTimeout(const HidDeviceHandle & dev,std::vector<uint8_t> & data,uint32_t buffSize,int32_t timeout,uint32_t & bytesRead)216 int32_t HidDdkService::ReadTimeout(const HidDeviceHandle& dev, std::vector<uint8_t>& data, uint32_t buffSize,
217 int32_t timeout, uint32_t& bytesRead)
218 {
219 HDF_LOGD("%{public}s read timeout enter", __func__);
220 if (!DdkPermissionManager::VerifyPermission(PERMISSION_NAME)) {
221 HDF_LOGE("%{public}s: no permission", __func__);
222 return HID_DDK_NO_PERM;
223 }
224
225 if (buffSize > MAX_REPORT_BUFFER_SIZE) {
226 HDF_LOGE("%{public}s: invalid parameter", __func__);
227 return HID_DDK_INVALID_PARAMETER;
228 }
229
230 if (timeout >= 0) {
231 int32_t ret;
232 struct pollfd fds;
233
234 fds.fd = dev.fd;
235 fds.events = POLLIN;
236 fds.revents = 0;
237 ret = poll(&fds, 1, timeout);
238 if (ret == 0) {
239 return HID_DDK_TIMEOUT;
240 } else if (ret == -1) {
241 HDF_LOGE("%{public}s poll failed, errno=%{public}d", __func__, errno);
242 return HID_DDK_IO_ERROR;
243 }
244 if ((unsigned int)fds.revents & (POLLERR | POLLHUP | POLLNVAL)) {
245 HDF_LOGE("%{public}s poll failed, revents=%{public}u", __func__, (unsigned int)fds.revents);
246 return HID_DDK_IO_ERROR;
247 }
248 }
249
250 data.resize(buffSize);
251 int32_t readRet = read(dev.fd, data.data(), data.size());
252 if (readRet < 0) {
253 HDF_LOGE("%{public}s read failed, errno=%{public}d", __func__, errno);
254 bytesRead = 0;
255 return HID_DDK_IO_ERROR;
256 }
257
258 bytesRead = static_cast<uint32_t>(readRet);
259 return HID_DDK_SUCCESS;
260 }
261
SetNonBlocking(const HidDeviceHandle & dev,int32_t nonBlock)262 int32_t HidDdkService::SetNonBlocking(const HidDeviceHandle& dev, int32_t nonBlock)
263 {
264 HDF_LOGD("%{public}s enter", __func__);
265 if (!DdkPermissionManager::VerifyPermission(PERMISSION_NAME)) {
266 HDF_LOGE("%{public}s: no permission", __func__);
267 return HID_DDK_NO_PERM;
268 }
269
270 return HID_DDK_SUCCESS;
271 }
272
GetRawInfo(const HidDeviceHandle & dev,HidRawDevInfo & rawDevInfo)273 int32_t HidDdkService::GetRawInfo(const HidDeviceHandle& dev, HidRawDevInfo& rawDevInfo)
274 {
275 HDF_LOGD("%{public}s enter", __func__);
276 if (!DdkPermissionManager::VerifyPermission(PERMISSION_NAME)) {
277 HDF_LOGE("%{public}s: no permission", __func__);
278 return HID_DDK_NO_PERM;
279 }
280
281 return osAdapter_->GetRawInfo(dev.fd, rawDevInfo);
282 }
283
GetRawName(const HidDeviceHandle & dev,std::vector<uint8_t> & data,uint32_t buffSize)284 int32_t HidDdkService::GetRawName(const HidDeviceHandle& dev, std::vector<uint8_t>& data, uint32_t buffSize)
285 {
286 HDF_LOGD("%{public}s enter", __func__);
287 if (!DdkPermissionManager::VerifyPermission(PERMISSION_NAME)) {
288 HDF_LOGE("%{public}s: no permission", __func__);
289 return HID_DDK_NO_PERM;
290 }
291
292 if (buffSize > MAX_REPORT_BUFFER_SIZE) {
293 HDF_LOGE("%{public}s: invalid parameter", __func__);
294 return HID_DDK_INVALID_PARAMETER;
295 }
296
297 data.resize(buffSize);
298
299 return osAdapter_->GetRawName(dev.fd, data);
300 }
301
GetPhysicalAddress(const HidDeviceHandle & dev,std::vector<uint8_t> & data,uint32_t buffSize)302 int32_t HidDdkService::GetPhysicalAddress(const HidDeviceHandle& dev, std::vector<uint8_t>& data, uint32_t buffSize)
303 {
304 HDF_LOGD("%{public}s enter", __func__);
305 if (!DdkPermissionManager::VerifyPermission(PERMISSION_NAME)) {
306 HDF_LOGE("%{public}s: no permission", __func__);
307 return HID_DDK_NO_PERM;
308 }
309
310 if (buffSize > MAX_REPORT_BUFFER_SIZE) {
311 HDF_LOGE("%{public}s: invalid parameter", __func__);
312 return HID_DDK_INVALID_PARAMETER;
313 }
314
315 data.resize(buffSize);
316
317 return osAdapter_->GetPhysicalAddress(dev.fd, data);
318 }
319
GetRawUniqueId(const HidDeviceHandle & dev,std::vector<uint8_t> & data,uint32_t buffSize)320 int32_t HidDdkService::GetRawUniqueId(const HidDeviceHandle& dev, std::vector<uint8_t>& data, uint32_t buffSize)
321 {
322 HDF_LOGD("%{public}s enter", __func__);
323 if (!DdkPermissionManager::VerifyPermission(PERMISSION_NAME)) {
324 HDF_LOGE("%{public}s: no permission", __func__);
325 return HID_DDK_NO_PERM;
326 }
327
328 if (buffSize > MAX_REPORT_BUFFER_SIZE) {
329 HDF_LOGE("%{public}s: invalid parameter", __func__);
330 return HID_DDK_INVALID_PARAMETER;
331 }
332
333 data.resize(buffSize);
334
335 return osAdapter_->GetRawUniqueId(dev.fd, data);
336 }
337
SendReport(const HidDeviceHandle & dev,HidReportType reportType,const std::vector<uint8_t> & data)338 int32_t HidDdkService::SendReport(const HidDeviceHandle& dev, HidReportType reportType,
339 const std::vector<uint8_t>& data)
340 {
341 HDF_LOGD("%{public}s enter", __func__);
342 if (!DdkPermissionManager::VerifyPermission(PERMISSION_NAME)) {
343 HDF_LOGE("%{public}s: no permission", __func__);
344 return HID_DDK_NO_PERM;
345 }
346
347 return osAdapter_->SendReport(dev.fd, reportType, data);
348 }
349
GetReport(const HidDeviceHandle & dev,HidReportType reportType,uint8_t reportNumber,std::vector<uint8_t> & data,uint32_t buffSize)350 int32_t HidDdkService::GetReport(const HidDeviceHandle& dev, HidReportType reportType, uint8_t reportNumber,
351 std::vector<uint8_t>& data, uint32_t buffSize)
352 {
353 HDF_LOGD("%{public}s enter", __func__);
354 if (!DdkPermissionManager::VerifyPermission(PERMISSION_NAME)) {
355 HDF_LOGE("%{public}s: no permission", __func__);
356 return HID_DDK_NO_PERM;
357 }
358
359 if (buffSize > MAX_REPORT_BUFFER_SIZE) {
360 HDF_LOGE("%{public}s: invalid parameter", __func__);
361 return HID_DDK_INVALID_PARAMETER;
362 }
363
364 data.resize(buffSize);
365 data[0] = reportNumber;
366
367 return osAdapter_->GetReport(dev.fd, reportType, data);
368 }
369
GetReportDescriptor(const HidDeviceHandle & dev,std::vector<uint8_t> & buf,uint32_t buffSize,uint32_t & bytesRead)370 int32_t HidDdkService::GetReportDescriptor(const HidDeviceHandle& dev, std::vector<uint8_t>& buf, uint32_t buffSize,
371 uint32_t& bytesRead)
372 {
373 HDF_LOGD("%{public}s enter", __func__);
374 if (!DdkPermissionManager::VerifyPermission(PERMISSION_NAME)) {
375 HDF_LOGE("%{public}s: no permission", __func__);
376 return HID_DDK_NO_PERM;
377 }
378
379 if (buffSize > MAX_REPORT_BUFFER_SIZE) {
380 HDF_LOGE("%{public}s: invalid parameter", __func__);
381 return HID_DDK_INVALID_PARAMETER;
382 }
383
384 buf.resize(buffSize);
385
386 return osAdapter_->GetReportDescriptor(dev.fd, buf, bytesRead);
387 }
388
389 } // V1_1
390 } // Ddk
391 } // Input
392 } // HDI
393 } // OHOS
394