1 /*
2 * Copyright (c) 2022 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 "input_proxy.h"
17 #include <hdf_base.h>
18 #include <message_parcel.h>
19 #include "securec.h"
20
21 #define HDF_LOG_TAG InputProxy
22
23 namespace OHOS {
24 namespace Input {
SetPowerStatus(uint32_t devIndex,uint32_t status)25 int32_t InputProxy::SetPowerStatus(uint32_t devIndex, uint32_t status)
26 {
27 MessageParcel data = {};
28 MessageParcel reply = {};
29 MessageOption option = {};
30
31 if (!data.writeInterfaceToken(InputProxy::GetDescriptor()) || !data.WriteUint32(devIndex)) {
32 HDF_LOGE("%{public}s: write devIndex failed.", __func__);
33 return INPUT_INVALID_PARAM;
34 }
35 if (!data.writeInterfaceToken(InputProxy::GetDescriptor()) || !data.WriteUint32(status)) {
36 HDF_LOGE("InputProxy %{public}s: write status failed.", __func__);
37 return INPUT_INVALID_PARAM;
38 }
39 int32_t ret = Remote()->SendRequest(CMD_INPUT_SET_POWER_STATUS_PROXY, data, reply, option);
40 if (ret != HDF_SUCCESS) {
41 HDF_LOGE("InputProxy %{public}s: SendRequest failed, error code is %{public}d", __func__, ret);
42 return INPUT_INVALID_PARAM;
43 }
44 return INPUT_SUCCESS;
45 }
46
GetPowerStatus(uint32_t devIndex,uint32_t * status)47 int32_t InputProxy::GetPowerStatus(uint32_t devIndex, uint32_t *status)
48 {
49 MessageParcel data = {};
50 MessageParcel reply = {};
51 MessageOption option = {};
52
53 if (!data.writeInterfaceToken(InputProxy::GetDescriptor()) || !data.WriteUint32(devIndex)) {
54 HDF_LOGE("InputProxy %{public}s: write devIndex failed.", __func__);
55 return INPUT_FAILURE;
56 }
57
58 int32_t ret = Remote()->SendRequest(CMD_INPUT_GET_POWER_STATUS_PROXY, data, reply, option);
59 if (ret != HDF_SUCCESS) {
60 HDF_LOGE("InputProxy %{public}s: SendRequest failed, error code is %{public}d", __func__, ret);
61 return INPUT_INVALID_PARAM;
62 }
63 *status = reply.ReadUint32();
64 return INPUT_SUCCESS;
65 }
66
GetDeviceType(uint32_t devIndex,uint32_t * status)67 int32_t InputProxy::GetDeviceType(uint32_t devIndex, uint32_t *status)
68 {
69 MessageParcel data = {};
70 MessageParcel reply = {};
71 MessageOption option = {};
72
73 if (!data.writeInterfaceToken(InputProxy::GetDescriptor()) || !data.WriteUint32(devIndex)) {
74 HDF_LOGE("InputProxy %{public}s: write devIndex failed.", __func__);
75 return INPUT_FAILURE;
76 }
77 int32_t ret = Remote()->SendRequest(CMD_INPUT_GET_DEVICE_TYPE_PROXY, data, reply, option);
78 if (ret != HDF_SUCCESS) {
79 HDF_LOGE("InputProxy %{public}s: SendRequest failed, error code is %{public}d", __func__, ret);
80 return INPUT_INVALID_PARAM;
81 }
82 *status = reply.ReadUint32();
83 return INPUT_SUCCESS;
84 }
85
GetChipInfo(uint32_t devIndex,char * chipInfo,uint32_t length)86 int32_t InputProxy::GetChipInfo(uint32_t devIndex, char *chipInfo, uint32_t length)
87 {
88 MessageParcel data = {};
89 MessageParcel reply = {};
90 MessageOption option = {};
91
92 if (!data.writeInterfaceToken(InputProxy::GetDescriptor()) || !data.WriteUint32(devIndex)) {
93 HDF_LOGE("InputProxy %{public}s: write devIndex failed.", __func__);
94 return INPUT_INVALID_PARAM;
95 }
96 if (!data.writeInterfaceToken(InputProxy::GetDescriptor()) || !data.WriteUint32(length)) {
97 HDF_LOGE("InputProxy %{public}s: write length failed.", __func__);
98 return INPUT_INVALID_PARAM;
99 }
100 int32_t ret = Remote()->SendRequest(CMD_INPUT_GET_CHIP_INFO_PROXY, data, reply, option);
101 if (ret != HDF_SUCCESS) {
102 HDF_LOGE("InputProxy %{public}s: SendRequest failed, error code is %{public}d", __func__, ret);
103 return INPUT_INVALID_PARAM;
104 }
105 if (chipInfo == nullptr) {
106 HDF_LOGE("InputProxy %{public}s: write length failed.", __func__);
107 return INPUT_FAILURE;
108 }
109 uint32_t retValueLen = reply.ReadUint32();
110 HDF_LOGD("InputProxy %{public}s: called retValueLen:%{public}d", __func__, retValueLen);
111 ret = memcpy_s(chipInfo, retValueLen, reply.ReadBuffer(retValueLen), retValueLen);
112 if (ret != 0) {
113 HDF_LOGE("InputProxy %{public}s: memcpy_s failed.", __func__);
114 return INPUT_FAILURE;
115 }
116 HDF_LOGI("InputProxy %{public}s: called chipName:%{public}s", __func__, chipInfo);
117 return INPUT_SUCCESS;
118 }
119
GetVendorName(uint32_t devIndex,char * vendorName,uint32_t length)120 int32_t InputProxy::GetVendorName(uint32_t devIndex, char *vendorName, uint32_t length)
121 {
122 MessageParcel data = {};
123 MessageParcel reply = {};
124 MessageOption option = {};
125
126 if (!data.writeInterfaceToken(InputProxy::GetDescriptor()) || !data.WriteUint32(devIndex)) {
127 HDF_LOGE("InputProxy %{public}s: write devIndex failed.", __func__);
128 return INPUT_INVALID_PARAM;
129 }
130 if (!data.writeInterfaceToken(InputProxy::GetDescriptor()) || !data.WriteUint32(length)) {
131 HDF_LOGE("InputProxy %{public}s: write length failed.", __func__);
132 return INPUT_INVALID_PARAM;
133 }
134 int32_t ret = Remote()->SendRequest(CMD_INPUT_GET_VENDOR_NAME_PROXY, data, reply, option);
135 if (ret != HDF_SUCCESS) {
136 HDF_LOGE("InputProxy %{public}s: SendRequest failed, error code is %{public}d", __func__, ret);
137 return INPUT_FAILURE;
138 }
139 if (vendorName == nullptr) {
140 HDF_LOGE("InputProxy %{public}s: write length failed.", __func__);
141 return INPUT_FAILURE;
142 }
143 uint32_t retValueLen = reply.ReadUint32();
144 HDF_LOGI("InputProxy %{public}s: called retValueLen:%{public}d", __func__, retValueLen);
145 ret = memcpy_s(vendorName, retValueLen, reply.ReadBuffer(retValueLen), retValueLen);
146 if (ret != 0) {
147 HDF_LOGE("InputProxy %{public}s: memcpy_s failed.", __func__);
148 return INPUT_FAILURE;
149 }
150 HDF_LOGI("InputProxy %{public}s: called vendorName:%{public}s", __func__, vendorName);
151 return INPUT_SUCCESS;
152 }
153
GetChipName(uint32_t devIndex,char * chipName,uint32_t length)154 int32_t InputProxy::GetChipName(uint32_t devIndex, char *chipName, uint32_t length)
155 {
156 MessageParcel data = {};
157 MessageParcel reply = {};
158 MessageOption option = {};
159
160 if (!data.writeInterfaceToken(InputProxy::GetDescriptor()) || !data.WriteUint32(devIndex)) {
161 HDF_LOGE("InputProxy %{public}s: write devIndex failed.", __func__);
162 return INPUT_INVALID_PARAM;
163 }
164 if (!data.writeInterfaceToken(InputProxy::GetDescriptor()) || !data.WriteUint32(length)) {
165 HDF_LOGE("InputProxy %{public}s: write length failed.", __func__);
166 return INPUT_INVALID_PARAM;
167 }
168 int32_t ret = Remote()->SendRequest(CMD_INPUT_GET_CHIP_NAME_PROXY, data, reply, option);
169 if (ret != HDF_SUCCESS) {
170 HDF_LOGE("%{public}s: SendRequest failed, error code is %{public}d", __func__, ret);
171 return INPUT_INVALID_PARAM;
172 }
173 if (chipName == nullptr) {
174 HDF_LOGE("%{public}s: write length failed.", __func__);
175 return INPUT_FAILURE;
176 }
177 uint32_t retValueLen = reply.ReadUint32();
178 HDF_LOGI("InputProxy %{public}s: called retValueLen:%{public}d", __func__, retValueLen);
179 ret = memcpy_s(chipName, retValueLen, reply.ReadBuffer(retValueLen), retValueLen);
180 if (ret != 0) {
181 HDF_LOGE("%{public}s: memcpy_s failed.", __func__);
182 return INPUT_FAILURE;
183 }
184 HDF_LOGI("InputProxy %{public}s: called chipName:%{public}s", __func__, chipName);
185 return INPUT_SUCCESS;
186 }
187
SetGestureMode(uint32_t devIndex,uint32_t gestureMode)188 int32_t InputProxy::SetGestureMode(uint32_t devIndex, uint32_t gestureMode)
189 {
190 MessageParcel data = {};
191 MessageParcel reply = {};
192 MessageOption option = {};
193
194 if (!data.writeInterfaceToken(InputProxy::GetDescriptor()) || !data.WriteUint32(devIndex)) {
195 HDF_LOGE("InputProxy %{public}s: write devIndex failed.", __func__);
196 return INPUT_INVALID_PARAM;
197 }
198 if (!data.writeInterfaceToken(InputProxy::GetDescriptor()) || !data.WriteUint32(gestureMode)) {
199 HDF_LOGE("InputProxy %{public}s: write gestureMode failed.", __func__);
200 return INPUT_INVALID_PARAM;
201 }
202 int32_t ret = Remote()->SendRequest(CMD_INPUT_SET_GESTURE_MODE_PROXY, data, reply, option);
203 if (ret != HDF_SUCCESS) {
204 HDF_LOGE("%{public}s: SendRequest failed, error code is %{public}d", __func__, ret);
205 return INPUT_INVALID_PARAM;
206 }
207 return INPUT_SUCCESS;
208 }
209
RunCapacitanceTest(uint32_t devIndex,uint32_t testType,char * result,uint32_t length)210 int32_t InputProxy::RunCapacitanceTest(uint32_t devIndex, uint32_t testType, char *result, uint32_t length)
211 {
212 MessageParcel data = {};
213 MessageParcel reply = {};
214 MessageOption option = {};
215
216 if (!data.writeInterfaceToken(InputProxy::GetDescriptor()) || !data.WriteUint32(devIndex)) {
217 HDF_LOGE("%{public}s: write devIndex failed.", __func__);
218 return INPUT_INVALID_PARAM;
219 }
220 if (!data.writeInterfaceToken(InputProxy::GetDescriptor()) || !data.WriteUint32(testType)) {
221 HDF_LOGE("%{public}s: write testType failed.", __func__);
222 return INPUT_INVALID_PARAM;
223 }
224 if (!data.writeInterfaceToken(InputProxy::GetDescriptor()) || !data.WriteUint32(length)) {
225 HDF_LOGE("InputProxy %{public}s: write length failed.", __func__);
226 return INPUT_INVALID_PARAM;
227 }
228 int32_t ret = Remote()->SendRequest(CMD_INPUT_RUN_CAPACITANCE_TEST_PROXY, data, reply, option);
229 if (ret != HDF_SUCCESS) {
230 HDF_LOGE("InputProxy %{public}s: SendRequest failed, error code is %{public}d", __func__, ret);
231 return INPUT_INVALID_PARAM;
232 }
233 if (result == nullptr) {
234 HDF_LOGE("InputProxy %{public}s: write length failed.", __func__);
235 return INPUT_FAILURE;
236 }
237 ret = memcpy_s(result, reply.ReadString().length(), reply.ReadString().c_str(), reply.ReadString().length());
238 if (ret != 0) {
239 HDF_LOGE("InputProxy %{public}s: memcpy_s failed.", __func__);
240 return INPUT_FAILURE;
241 }
242 return INPUT_SUCCESS;
243 }
244
RunExtraCommand(uint32_t devIndex,InputExtraCmd * cmd)245 int32_t InputProxy::RunExtraCommand(uint32_t devIndex, InputExtraCmd *cmd)
246 {
247 MessageParcel data = {};
248 MessageParcel reply = {};
249 MessageOption option = {};
250
251 if (!data.writeInterfaceToken(InputProxy::GetDescriptor()) || !data.WriteUint32(devIndex)) {
252 HDF_LOGE("InputProxy %{public}s: write devIndex failed.", __func__);
253 return INPUT_INVALID_PARAM;
254 }
255 int32_t ret = Remote()->SendRequest(CMD_INPUT_RUN_EXTRA_COMMAND_PROXY, data, reply, option);
256 if (ret != HDF_SUCCESS) {
257 HDF_LOGE("InputProxy %{public}s: SendRequest failed, error code is %{public}d", __func__, ret);
258 return INPUT_INVALID_PARAM;
259 }
260 return INPUT_SUCCESS;
261 }
262
ScanInputDevice(DevDesc * staArr,uint32_t arrLen)263 int32_t InputProxy::ScanInputDevice(DevDesc *staArr, uint32_t arrLen)
264 {
265 MessageParcel data = {};
266 MessageParcel reply = {};
267 MessageOption option = {};
268
269 if (!data.writeInterfaceToken(InputProxy::GetDescriptor()) || !data.WriteUint32(arrLen)) {
270 HDF_LOGE("InputProxy %{public}s: write arrLen failed.", __func__);
271 return INPUT_INVALID_PARAM;
272 }
273 int32_t ret = Remote()->SendRequest(CMD_INPUT_SCAN_DEVICE_PROXY, data, reply, option);
274 if (ret != HDF_SUCCESS) {
275 HDF_LOGE("InputProxy %{public}s: SendRequest failed, error code is %{public}d", __func__, ret);
276 return INPUT_INVALID_PARAM;
277 }
278 uint32_t readValLen = reply.ReadUint32();
279 HDF_LOGD("InputProxy %{public}s: called line:%{public}d readValLen:%{public}d cnt:%{public}d",
280 __func__, __LINE__, readValLen, readValLen/sizeof(DevDesc));
281 DevDesc* tmpStaArr = (DevDesc*)reply.ReadBuffer(readValLen);
282 if (tmpStaArr != nullptr) {
283 memcpy_s(staArr, readValLen, tmpStaArr, readValLen);
284 }
285 for (uint32_t i = 0; i < arrLen; i++) {
286 HDF_LOGE("InputProxy %{public}s: called line:%{public}d index:%{public}d type:%{public}d",
287 __func__, __LINE__, (staArr+i)->devIndex, (staArr+i)->devType);
288 }
289 return INPUT_SUCCESS;
290 }
291
OpenInputDevice(uint32_t devIndex)292 int32_t InputProxy::OpenInputDevice(uint32_t devIndex)
293 {
294 MessageParcel data = {};
295 MessageParcel reply = {};
296 MessageOption option = {};
297
298 if (!data.writeInterfaceToken(InputProxy::GetDescriptor()) || !data.WriteUint32(devIndex)) {
299 HDF_LOGE("InputProxy %{public}s: write devIndex failed.", __func__);
300 return INPUT_INVALID_PARAM;
301 }
302 int32_t ret = Remote()->SendRequest(CMD_INPUT_OPNE_DEVICE_PROXY, data, reply, option);
303 if (ret != HDF_SUCCESS) {
304 HDF_LOGE("InputProxy %{public}s: SendRequest failed, error code is %{public}d", __func__, ret);
305 return INPUT_INVALID_PARAM;
306 }
307 return INPUT_SUCCESS;
308 }
309
CloseInputDevice(uint32_t devIndex)310 int32_t InputProxy::CloseInputDevice(uint32_t devIndex)
311 {
312 MessageParcel data = {};
313 MessageParcel reply = {};
314 MessageOption option = {};
315 if (!data.writeInterfaceToken(InputProxy::GetDescriptor()) || !data.WriteUint32(devIndex)) {
316 HDF_LOGE("InputProxy %{public}s: write devIndex failed.", __func__);
317 return INPUT_INVALID_PARAM;
318 }
319 int32_t ret = Remote()->SendRequest(CMD_INPUT_CLOSE_DEVICE_PROXY, data, reply, option);
320 if (ret != HDF_SUCCESS) {
321 HDF_LOGE("InputProxy %{public}s: SendRequest failed, error code is %{public}d", __func__, ret);
322 return INPUT_INVALID_PARAM;
323 }
324 return INPUT_SUCCESS;
325 }
326
GetInputDevice(uint32_t devIndex,DeviceInfo ** devInfo)327 int32_t InputProxy::GetInputDevice(uint32_t devIndex, DeviceInfo **devInfo)
328 {
329 MessageParcel data = {};
330 MessageParcel reply = {};
331 MessageOption option = {};
332
333 if (!data.writeInterfaceToken(InputProxy::GetDescriptor()) || !data.WriteUint32(devIndex)) {
334 HDF_LOGE("InputProxy %{public}s: write devIndex failed.", __func__);
335 return INPUT_FAILURE;
336 }
337 int32_t ret = Remote()->SendRequest(CMD_INPUT_GET_DEVICE_PROXY, data, reply, option);
338 if (ret != HDF_SUCCESS) {
339 HDF_LOGE("InputProxy %{public}s: SendRequest failed, error code is %{public}d", __func__, ret);
340 return INPUT_FAILURE;
341 }
342 uint32_t readLen = reply.ReadUint32();
343 DeviceInfo* tmpDevInfo = (DeviceInfo*) new DeviceInfo();
344 if (tmpDevInfo == nullptr) {
345 HDF_LOGE("InputProxy %{public}s: called line:%{public}d tmpDevInfo:%{public}p",
346 __func__, __LINE__, tmpDevInfo);
347 return INPUT_FAILURE;
348 } else {
349 *devInfo = tmpDevInfo;
350 }
351 (void)memcpy_s(tmpDevInfo, readLen, (DeviceInfo*)(reply.ReadBuffer(readLen)), readLen);
352 return INPUT_SUCCESS;
353 }
354
GetInputDeviceList(uint32_t * devNum,DeviceInfo ** devList,uint32_t size)355 int32_t InputProxy::GetInputDeviceList(uint32_t *devNum, DeviceInfo **devList, uint32_t size)
356 {
357 MessageParcel data = {};
358 MessageParcel reply = {};
359 MessageOption option = {};
360
361 if (!data.writeInterfaceToken(InputProxy::GetDescriptor()) || !data.WriteUint32(size)) {
362 HDF_LOGE("InputProxy %{public}s: write devIndex failed.", __func__);
363 return INPUT_FAILURE;
364 }
365 int32_t ret = Remote()->SendRequest(CMD_INPUT_GET_DEVICE_LIST_PROXY, data, reply, option);
366 if (ret != HDF_SUCCESS) {
367 HDF_LOGE("InputProxy %{public}s: SendRequest failed, error code is %{public}d", __func__, ret);
368 return INPUT_FAILURE;
369 }
370 *devNum = reply.ReadUint32();
371 if (*devList == nullptr) {
372 HDF_LOGE("InputProxy %{public}s: called line:%{public}d ", __func__, __LINE__);
373 return INPUT_FAILURE;
374 }
375 uint32_t readLen = reply.ReadUint32();
376 (void)memcpy_s(*devList, readLen, (DeviceInfo*)(reply.ReadBuffer(readLen)), readLen);
377 HDF_LOGI("devNum:%{public}d devList:%{public}p", *devNum, *devList);
378 return INPUT_SUCCESS;
379 }
380
RegisterReportCallback(uint32_t devIndex,OHOS::sptr<InputReportEventCb> callback)381 int32_t InputProxy::RegisterReportCallback(uint32_t devIndex, OHOS::sptr<InputReportEventCb> callback)
382 {
383 MessageParcel data = {};
384 MessageParcel reply = {};
385 MessageOption option = {};
386
387 if (!data.writeInterfaceToken(InputProxy::GetDescriptor()) || !data.WriteUint32(devIndex)) {
388 HDF_LOGE("InputProxy %{public}s: write devIndex failed.", __func__);
389 return INPUT_FAILURE;
390 }
391 if (callback == nullptr) {
392 HDF_LOGE("InputProxy %{public}s: called line:%{public}d", __func__, __LINE__);
393 return INPUT_FAILURE;
394 }
395 if (!data.WriteBool(true)) {
396 HDF_LOGE("%s: set callback flag failed!", __func__);
397 return INPUT_FAILURE;
398 }
399 if (!data.WriteRemoteObject(callback->AsObject())) {
400 HDF_LOGE("%s: set callback write remote obj failed!", __func__);
401 return INPUT_FAILURE;
402 }
403 int32_t ret = Remote()->SendRequest(CMD_INPUT_REGISTER_DEVICE_PROXY, data, reply, option);
404 if (ret != HDF_SUCCESS) {
405 HDF_LOGE("InputProxy%{public}s: SendRequest failed, error code is %{public}d line %{public}d",
406 __func__, ret, __LINE__);
407 return INPUT_FAILURE;
408 }
409 return INPUT_SUCCESS;
410 }
411
UnregisterReportCallback(uint32_t devIndex)412 int32_t InputProxy::UnregisterReportCallback(uint32_t devIndex)
413 {
414 MessageParcel data = {};
415 MessageParcel reply = {};
416 MessageOption option = {};
417
418 if (!data.writeInterfaceToken(InputProxy::GetDescriptor()) || !data.WriteUint32(devIndex)) {
419 HDF_LOGE("%{public}s: write devIndex failed.", __func__);
420 return INPUT_FAILURE;
421 }
422 int32_t ret = Remote()->SendRequest(CMD_INPUT_UNREGISTER_DEVICE_PROXY, data, reply, option);
423 if (ret != HDF_SUCCESS) {
424 HDF_LOGE("InputProxy%{public}s: SendRequest failed, error code is %{public}d line %{public}d",
425 __func__, ret, __LINE__);
426 return INPUT_FAILURE;
427 }
428 return INPUT_SUCCESS;
429 }
430
RegisterHotPlugCallback(OHOS::sptr<InputReportHostCb> callback)431 int32_t InputProxy::RegisterHotPlugCallback(OHOS::sptr<InputReportHostCb> callback)
432 {
433 MessageParcel data = {};
434 MessageParcel reply = {};
435 MessageOption option = {};
436
437 if (callback == nullptr) {
438 HDF_LOGE("InputProxy %{public}s: called line:%{public}d", __func__, __LINE__);
439 return INPUT_FAILURE;
440 }
441 HDF_LOGE("InputProxy %{public}s: hostSptr is %{public}p", __func__, callback.GetRefPtr());
442 if (!data.WriteBool(true)) {
443 HDF_LOGE("%s: set callback flag failed!", __func__);
444 return INPUT_FAILURE;
445 }
446 if (!data.WriteRemoteObject(callback->AsObject())) {
447 HDF_LOGE("%s: set callback write remote obj failed!", __func__);
448 return INPUT_FAILURE;
449 }
450 int32_t ret = Remote()->SendRequest(CMD_INPUT_REGISTER_HOT_PLAUS_DEVICE_PROXY, data, reply, option);
451 if (ret != HDF_SUCCESS) {
452 HDF_LOGE("InputProxy%{public}s: SendRequest failed, error code is %{public}d line %{public}d",
453 __func__, ret, __LINE__);
454 return INPUT_FAILURE;
455 }
456 return INPUT_SUCCESS;
457 }
458
UnregisterHotPlugCallback(void)459 int32_t InputProxy::UnregisterHotPlugCallback(void)
460 {
461 MessageParcel data = {};
462 MessageParcel reply = {};
463 MessageOption option = {};
464
465 int32_t ret = Remote()->SendRequest(CMD_INPUT_UNREGISTER_HOT_PLAUS_DEVICE_PROXY, data, reply, option);
466 if (ret != HDF_SUCCESS) {
467 HDF_LOGE("InputProxy%{public}s: SendRequest failed, error code is %{public}d line %{public}d",
468 __func__, ret, __LINE__);
469 return INPUT_FAILURE;
470 }
471 return INPUT_SUCCESS;
472 }
473 } // namespace Input
474 } // namespace OHOS
475