1 /*
2 * Copyright (c) 2021 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 #include "input_reporter.h"
16 #include <stdio.h>
17 #include <unistd.h>
18 #include <malloc.h>
19 #include <sys/ioctl.h>
20 #include <securec.h>
21 #include "hdf_io_service_if.h"
22 #include "hdf_syscall_adapter.h"
23 #include "osal_time.h"
24 #include "input_common.h"
25
26 #define POLL_WAIT_MS 100
27 #define MOUSE_DATA_LEN 4
28 #define REL_X_BYTE 1
29 #define REL_Y_BYTE 2
30 #define MAX_EVENT_PKG_NUM 100
31
32 InputDevManager *GetDevManager(void);
33
EventListenerCallback(struct HdfDevEventlistener * listener,struct HdfIoService * service,uint32_t id,struct HdfSBuf * data)34 static int32_t EventListenerCallback(struct HdfDevEventlistener *listener, struct HdfIoService *service,
35 uint32_t id, struct HdfSBuf *data)
36 {
37 (void)listener;
38 (void)id;
39 int32_t count = 0;
40 uint32_t len = 0;
41 InputEventPackage *pkgs[MAX_EVENT_PKG_NUM] = {0};
42 DeviceInfoNode *pos = NULL;
43 DeviceInfoNode *next = NULL;
44 InputDevManager *manager = NULL;
45
46 if (service == NULL || data == NULL) {
47 HDF_LOGE("%s: invalid param", __func__);
48 return INPUT_INVALID_PARAM;
49 }
50
51 manager = GetDevManager();
52 if (manager == NULL) {
53 HDF_LOGE("%s: get manager failed", __func__);
54 return INPUT_NULL_PTR;
55 }
56
57 while (true) {
58 if (count >= MAX_EVENT_PKG_NUM) {
59 break;
60 }
61
62 if (!HdfSbufReadBuffer(data, (const void **)&pkgs[count], &len)) {
63 HDF_LOGE("%s: sbuf read finished", __func__);
64 break;
65 }
66
67 if (pkgs[count] == NULL) {
68 break;
69 }
70 count++;
71 }
72
73 DLIST_FOR_EACH_ENTRY_SAFE(pos, next, &manager->devList, DeviceInfoNode, node) {
74 if (pos->service == service) {
75 pos->eventCb->EventPkgCallback((const InputEventPackage **)pkgs, count, pos->payload.devIndex);
76 }
77 }
78 return INPUT_SUCCESS;
79 }
80
EventListenerInstance(void)81 static struct HdfDevEventlistener *EventListenerInstance(void)
82 {
83 struct HdfDevEventlistener *listener = (struct HdfDevEventlistener *)malloc(sizeof(struct HdfDevEventlistener));
84 if (listener == NULL) {
85 HDF_LOGE("%s: instance listener failed", __func__);
86 return NULL;
87 }
88
89 (void)memset_s(listener, sizeof(struct HdfDevEventlistener), 0, sizeof(struct HdfDevEventlistener));
90 listener->onReceive = EventListenerCallback;
91 return listener;
92 }
93
RegisterReportCallback(uint32_t devIndex,InputEventCb * callback)94 static int32_t RegisterReportCallback(uint32_t devIndex, InputEventCb *callback)
95 {
96 DeviceInfoNode *pos = NULL;
97 DeviceInfoNode *next = NULL;
98 InputDevManager *manager = NULL;
99
100 if ((devIndex >= MAX_INPUT_DEV_NUM) || (callback == NULL) || (callback->EventPkgCallback == NULL)) {
101 HDF_LOGE("%s: invalid param", __func__);
102 return INPUT_INVALID_PARAM;
103 }
104 GET_MANAGER_CHECK_RETURN(manager);
105
106 pthread_mutex_lock(&manager->mutex);
107 DLIST_FOR_EACH_ENTRY_SAFE(pos, next, &manager->devList, DeviceInfoNode, node) {
108 if (pos->payload.devIndex != devIndex) {
109 continue;
110 }
111 struct HdfDevEventlistener *listener = EventListenerInstance();
112 if (listener == NULL) {
113 pthread_mutex_unlock(&manager->mutex);
114 return INPUT_FAILURE;
115 }
116 if (HdfDeviceRegisterEventListener(pos->service, listener) != INPUT_SUCCESS) {
117 free(listener);
118 pthread_mutex_unlock(&manager->mutex);
119 HDF_LOGE("%s: fail to register listener", __func__);
120 return INPUT_FAILURE;
121 }
122 manager->evtCallbackNum++;
123 pos->eventCb = callback;
124 pos->listener = listener;
125 pthread_mutex_unlock(&manager->mutex);
126 HDF_LOGI("%s: device%u register callback succ, evtCallbackNum = %d", __func__,
127 devIndex, manager->evtCallbackNum);
128 return INPUT_SUCCESS;
129 }
130
131 pthread_mutex_unlock(&manager->mutex);
132 HDF_LOGE("%s: device%u doesn't exist, can't register callback", __func__, devIndex);
133 return INPUT_FAILURE;
134 }
135
UnregisterReportCallback(uint32_t devIndex)136 static int32_t UnregisterReportCallback(uint32_t devIndex)
137 {
138 DeviceInfoNode *pos = NULL;
139 DeviceInfoNode *next = NULL;
140 InputDevManager *manager = NULL;
141
142 if (devIndex >= MAX_INPUT_DEV_NUM) {
143 HDF_LOGE("%s: invalid param", __func__);
144 return INPUT_INVALID_PARAM;
145 }
146 GET_MANAGER_CHECK_RETURN(manager);
147
148 pthread_mutex_lock(&manager->mutex);
149 DLIST_FOR_EACH_ENTRY_SAFE(pos, next, &manager->devList, DeviceInfoNode, node) {
150 if (pos->payload.devIndex != devIndex) {
151 continue;
152 }
153 if (pos->eventCb != NULL) {
154 if (HdfDeviceUnregisterEventListener(pos->service, pos->listener) != INPUT_SUCCESS) {
155 pthread_mutex_unlock(&manager->mutex);
156 HDF_LOGE("%s: fail to unregister listener", __func__);
157 return INPUT_FAILURE;
158 }
159 free(pos->listener);
160 pos->listener = NULL;
161 pos->eventCb = NULL;
162 manager->evtCallbackNum--;
163 pthread_mutex_unlock(&manager->mutex);
164 HDF_LOGI("%s: device%u unregister callback succ", __func__, devIndex);
165 return INPUT_SUCCESS;
166 } else {
167 pthread_mutex_unlock(&manager->mutex);
168 HDF_LOGE("%s: device%u does not register callback", __func__, devIndex);
169 return INPUT_FAILURE;
170 }
171 }
172
173 pthread_mutex_unlock(&manager->mutex);
174 HDF_LOGE("%s: device%u doesn't exist, can't unregister callback", __func__, devIndex);
175 return INPUT_FAILURE;
176 }
177
HotPlugEventListenerCallback(struct HdfDevEventlistener * listener,struct HdfIoService * service,uint32_t id,struct HdfSBuf * data)178 static int32_t HotPlugEventListenerCallback(struct HdfDevEventlistener *listener,
179 struct HdfIoService *service, uint32_t id, struct HdfSBuf *data)
180 {
181 (void)listener;
182 (void)id;
183 uint32_t len = 0;
184 InputHotPlugEvent *event = NULL;
185 InputDevManager *manager = NULL;
186 bool ret = false;
187
188 if (service == NULL || data == NULL) {
189 HDF_LOGE("%s: invalid param", __func__);
190 return INPUT_INVALID_PARAM;
191 }
192
193 GET_MANAGER_CHECK_RETURN(manager);
194
195 ret = HdfSbufReadBuffer(data, (const void **)&event, &len);
196 if (!ret) {
197 HDF_LOGE("%s: read sbuf failed", __func__);
198 return INPUT_FAILURE;
199 }
200 manager->hostDev.hostCb->HotPlugCallback((const InputHotPlugEvent *)event);
201 return INPUT_SUCCESS;
202 }
203
HotPlugEventListenerInstance(void)204 static struct HdfDevEventlistener *HotPlugEventListenerInstance(void)
205 {
206 struct HdfDevEventlistener *listener = (struct HdfDevEventlistener *)malloc(sizeof(struct HdfDevEventlistener));
207 if (listener == NULL) {
208 HDF_LOGE("%s: instance listener failed", __func__);
209 return NULL;
210 }
211
212 (void)memset_s(listener, sizeof(struct HdfDevEventlistener), 0, sizeof(struct HdfDevEventlistener));
213 listener->onReceive = HotPlugEventListenerCallback;
214 return listener;
215 }
216
RegisterHotPlugCallback(InputHostCb * callback)217 static int32_t RegisterHotPlugCallback(InputHostCb *callback)
218 {
219 InputDevManager *manager = NULL;
220
221 if ((callback == NULL) || (callback->HotPlugCallback == NULL)) {
222 HDF_LOGE("%s: invalid param", __func__);
223 return INPUT_INVALID_PARAM;
224 }
225 GET_MANAGER_CHECK_RETURN(manager);
226
227 pthread_mutex_lock(&manager->mutex);
228 if (manager->hostDev.service == NULL) {
229 manager->hostDev.service = HdfIoServiceBind(DEV_MANAGER_SERVICE_NAME);
230 if (manager->hostDev.service == NULL) {
231 pthread_mutex_unlock(&manager->mutex);
232 return INPUT_FAILURE;
233 }
234 }
235
236 struct HdfDevEventlistener *listener = HotPlugEventListenerInstance();
237 if (listener == NULL) {
238 pthread_mutex_unlock(&manager->mutex);
239 HDF_LOGE("%s: fail to instance listener", __func__);
240 return INPUT_FAILURE;
241 }
242 if (HdfDeviceRegisterEventListener(manager->hostDev.service, listener) != INPUT_SUCCESS) {
243 pthread_mutex_unlock(&manager->mutex);
244 HDF_LOGE("%s: fail to register listener", __func__);
245 free(listener);
246 return INPUT_FAILURE;
247 }
248 manager->hostDev.hostCb = callback;
249 manager->hostDev.listener = listener;
250 pthread_mutex_unlock(&manager->mutex);
251 return INPUT_SUCCESS;
252 }
253
UnregisterHotPlugCallback(void)254 static int32_t UnregisterHotPlugCallback(void)
255 {
256 InputDevManager *manager = NULL;
257 GET_MANAGER_CHECK_RETURN(manager);
258
259 pthread_mutex_lock(&manager->mutex);
260 if (manager->hostDev.listener != NULL) {
261 free(manager->hostDev.listener);
262 manager->hostDev.listener = NULL;
263 }
264 manager->hostDev.hostCb = NULL;
265 pthread_mutex_unlock(&manager->mutex);
266 return INPUT_SUCCESS;
267 }
268
InstanceReporterHdi(InputReporter ** reporter)269 int32_t InstanceReporterHdi(InputReporter **reporter)
270 {
271 InputReporter *reporterHdi = (InputReporter *)malloc(sizeof(InputReporter));
272 if (reporterHdi == NULL) {
273 HDF_LOGE("%s: malloc fail", __func__);
274 return INPUT_NOMEM;
275 }
276
277 (void)memset_s(reporterHdi, sizeof(InputReporter), 0, sizeof(InputReporter));
278
279 reporterHdi->RegisterReportCallback = RegisterReportCallback;
280 reporterHdi->UnregisterReportCallback = UnregisterReportCallback;
281 reporterHdi->RegisterHotPlugCallback = RegisterHotPlugCallback;
282 reporterHdi->UnregisterHotPlugCallback = UnregisterHotPlugCallback;
283 *reporter = reporterHdi;
284
285 return INPUT_SUCCESS;
286 }
287