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