1 /*
2 * Copyright (c) 2021-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 "multimodal_input_connect_stub.h"
17
18
19 #include "string_ex.h"
20
21 #include "bytrace_adapter.h"
22 #include "multimodal_input_connect_def_parcel.h"
23 #include "permission_helper.h"
24 #include "pixel_map.h"
25 #include "time_cost_chk.h"
26 #ifdef PLAYER_FRAMEWORK_EXISTS
27 #include "input_screen_capture_agent.h"
28 #endif // PLAYER_FRAMEWORK_EXISTS
29
30 #undef MMI_LOG_DOMAIN
31 #define MMI_LOG_DOMAIN MMI_LOG_SERVER
32 #undef MMI_LOG_TAG
33 #define MMI_LOG_TAG "MultimodalInputConnectStub"
34
35 namespace OHOS {
36 namespace MMI {
37 namespace {
38 constexpr int32_t MAX_AXIS_INFO { 64 };
39 constexpr int32_t MIN_ROWS { 1 };
40 constexpr int32_t MAX_ROWS { 100 };
41 constexpr int32_t TOUCHPAD_SCROLL_ROWS { 3 };
42 constexpr int32_t UID_TRANSFORM_DIVISOR { 200000 };
43 constexpr int32_t MAX_SPEED { 20 };
44 constexpr int32_t MIN_SPEED { 1 };
45 constexpr int32_t KEY_MAX_LIST_SIZE { 5 };
46
g_parseInputDevice(MessageParcel & data,std::shared_ptr<InputDevice> & inputDevice)47 int32_t g_parseInputDevice(MessageParcel &data, std::shared_ptr<InputDevice> &inputDevice)
48 {
49 CHKPR(inputDevice, RET_ERR);
50 int32_t value = 0;
51 READINT32(data, value, IPC_PROXY_DEAD_OBJECT_ERR);
52 inputDevice->SetId(value);
53 READINT32(data, value, IPC_PROXY_DEAD_OBJECT_ERR);
54 inputDevice->SetType(value);
55 std::string element;
56 READSTRING(data, element, IPC_PROXY_DEAD_OBJECT_ERR);
57 inputDevice->SetName(element);
58 READINT32(data, value, IPC_PROXY_DEAD_OBJECT_ERR);
59 inputDevice->SetBus(value);
60 READINT32(data, value, IPC_PROXY_DEAD_OBJECT_ERR);
61 inputDevice->SetVersion(value);
62 READINT32(data, value, IPC_PROXY_DEAD_OBJECT_ERR);
63 inputDevice->SetProduct(value);
64 READINT32(data, value, IPC_PROXY_DEAD_OBJECT_ERR);
65 inputDevice->SetVendor(value);
66 READSTRING(data, element, IPC_PROXY_DEAD_OBJECT_ERR);
67 inputDevice->SetPhys(element);
68 READSTRING(data, element, IPC_PROXY_DEAD_OBJECT_ERR);
69 inputDevice->SetUniq(element);
70 uint64_t caps;
71 READUINT64(data, caps, IPC_PROXY_DEAD_OBJECT_ERR);
72 inputDevice->SetCapabilities(static_cast<unsigned long>(caps));
73 uint32_t size = 0;
74 READUINT32(data, size, IPC_PROXY_DEAD_OBJECT_ERR);
75 if (size > MAX_AXIS_INFO) {
76 return RET_ERR;
77 }
78 InputDevice::AxisInfo axis;
79 for (uint32_t i = 0; i < size; ++i) {
80 int32_t val = 0;
81 READINT32(data, val, IPC_PROXY_DEAD_OBJECT_ERR);
82 axis.SetMinimum(val);
83 READINT32(data, val, IPC_PROXY_DEAD_OBJECT_ERR);
84 axis.SetMaximum(val);
85 READINT32(data, val, IPC_PROXY_DEAD_OBJECT_ERR);
86 axis.SetAxisType(val);
87 READINT32(data, val, IPC_PROXY_DEAD_OBJECT_ERR);
88 axis.SetFuzz(val);
89 READINT32(data, val, IPC_PROXY_DEAD_OBJECT_ERR);
90 axis.SetFlat(val);
91 READINT32(data, val, IPC_PROXY_DEAD_OBJECT_ERR);
92 axis.SetResolution(val);
93 inputDevice->AddAxisInfo(axis);
94 }
95 return RET_OK;
96 }
97 } // namespace
98 const int32_t TUPLE_PID { 0 };
99 const int32_t TUPLE_UID { 1 };
100 const int32_t TUPLE_NAME { 2 };
101 const int32_t DEFAULT_POINTER_COLOR { 0x000000 };
102 constexpr int32_t MAX_N_TRANSMIT_INFRARED_PATTERN { 1024 };
103
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)104 int32_t MultimodalInputConnectStub::OnRemoteRequest(uint32_t code, MessageParcel& data,
105 MessageParcel& reply, MessageOption& option)
106 {
107 int32_t pid = GetCallingPid();
108 TimeCostChk chk("IPC-OnRemoteRequest", "overtime 300(us)", MAX_OVER_TIME, pid,
109 static_cast<int64_t>(code));
110 MMI_HILOGD("RemoteRequest code:%{public}d, tid:%{public}" PRIu64 ", pid:%{public}d", code, GetThisThreadId(), pid);
111
112 std::u16string descriptor = data.ReadInterfaceToken();
113 if (descriptor != IMultimodalInputConnect::GetDescriptor()) {
114 MMI_HILOGE("Get unexpect descriptor:%{public}s", Str16ToStr8(descriptor).c_str());
115 return ERR_INVALID_STATE;
116 }
117 ResetLogTrace();
118 BytraceAdapter::StartIpcServer(code);
119 int32_t ret = RET_ERR;
120 switch (code) {
121 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::ALLOC_SOCKET_FD):
122 ret = StubHandleAllocSocketFd(data, reply);
123 break;
124 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::ADD_INPUT_EVENT_FILTER):
125 ret = StubAddInputEventFilter(data, reply);
126 break;
127 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::RMV_INPUT_EVENT_FILTER):
128 ret = StubRemoveInputEventFilter(data, reply);
129 break;
130 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SET_MOUSE_SCROLL_ROWS):
131 ret = StubSetMouseScrollRows(data, reply);
132 break;
133 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::GET_MOUSE_SCROLL_ROWS):
134 ret = StubGetMouseScrollRows(data, reply);
135 break;
136 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SET_POINTER_SIZE):
137 ret = StubSetPointerSize(data, reply);
138 break;
139 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::GET_POINTER_SIZE):
140 ret = StubGetPointerSize(data, reply);
141 break;
142 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SET_CUSTOM_CURSOR):
143 ret = StubSetCustomCursor(data, reply);
144 break;
145 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SET_MOUSE_ICON):
146 ret = StubSetMouseIcon(data, reply);
147 break;
148 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SET_MOUSE_PRIMARY_BUTTON):
149 ret = StubSetMousePrimaryButton(data, reply);
150 break;
151 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::GET_MOUSE_PRIMARY_BUTTON):
152 ret = StubGetMousePrimaryButton(data, reply);
153 break;
154 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SET_HOVER_SCROLL_STATE):
155 ret = StubSetHoverScrollState(data, reply);
156 break;
157 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::GET_HOVER_SCROLL_STATE):
158 ret = StubGetHoverScrollState(data, reply);
159 break;
160 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SET_POINTER_VISIBLE):
161 ret = StubSetPointerVisible(data, reply);
162 break;
163 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SET_POINTER_STYLE):
164 ret = StubSetPointerStyle(data, reply);
165 break;
166 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::NOTIFY_NAP_ONLINE):
167 ret = StubNotifyNapOnline(data, reply);
168 break;
169 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::RMV_INPUT_EVENT_OBSERVER):
170 ret = StubRemoveInputEventObserver(data, reply);
171 break;
172 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SET_NAP_STATUS):
173 ret = StubSetNapStatus(data, reply);
174 break;
175 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::CLEAN_WIDNOW_STYLE):
176 ret = StubClearWindowPointerStyle(data, reply);
177 break;
178 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::GET_POINTER_STYLE):
179 ret = StubGetPointerStyle(data, reply);
180 break;
181 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::IS_POINTER_VISIBLE):
182 ret = StubIsPointerVisible(data, reply);
183 break;
184 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::REGISTER_DEV_MONITOR):
185 ret = StubRegisterInputDeviceMonitor(data, reply);
186 break;
187 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::UNREGISTER_DEV_MONITOR):
188 ret = StubUnregisterInputDeviceMonitor(data, reply);
189 break;
190 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::GET_DEVICE_IDS):
191 ret = StubGetDeviceIds(data, reply);
192 break;
193 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::GET_DEVICE):
194 ret = StubGetDevice(data, reply);
195 break;
196 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SUPPORT_KEYS):
197 ret = StubSupportKeys(data, reply);
198 break;
199 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::GET_KEYBOARD_TYPE):
200 ret = StubGetKeyboardType(data, reply);
201 break;
202 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SET_POINTER_COLOR):
203 ret = StubSetPointerColor(data, reply);
204 break;
205 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::GET_POINTER_COLOR):
206 ret = StubGetPointerColor(data, reply);
207 break;
208 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SET_POINTER_SPEED):
209 ret = StubSetPointerSpeed(data, reply);
210 break;
211 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::GET_POINTER_SPEED):
212 ret = StubGetPointerSpeed(data, reply);
213 break;
214 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SUBSCRIBE_KEY_EVENT):
215 ret = StubSubscribeKeyEvent(data, reply);
216 break;
217 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::UNSUBSCRIBE_KEY_EVENT):
218 ret = StubUnsubscribeKeyEvent(data, reply);
219 break;
220 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SUBSCRIBE_HOT_KEY):
221 ret = StubSubscribeHotkey(data, reply);
222 break;
223 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::UNSUBSCRIBE_HOT_KEY):
224 ret = StubUnsubscribeHotkey(data, reply);
225 break;
226 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SUBSCRIBE_SWITCH_EVENT):
227 ret = StubSubscribeSwitchEvent(data, reply);
228 break;
229 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::UNSUBSCRIBE_SWITCH_EVENT):
230 ret = StubUnsubscribeSwitchEvent(data, reply);
231 break;
232 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SUBSCRIBE_TABLET_EVENT):
233 ret = StubSubscribeTabletProximity(data, reply);
234 break;
235 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::UNSUBSCRIBE_TABLET_EVENT):
236 ret = StubUnSubscribetabletProximity(data, reply);
237 break;
238 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::MARK_PROCESSED):
239 ret = StubMarkProcessed(data, reply);
240 break;
241 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::ADD_INPUT_HANDLER):
242 ret = StubAddInputHandler(data, reply);
243 break;
244 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::REMOVE_INPUT_HANDLER):
245 ret = StubRemoveInputHandler(data, reply);
246 break;
247 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::ADD_PRE_INPUT_HANDLER):
248 ret = StubAddPreInputHandler(data, reply);
249 break;
250 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::REMOVE_PRE_INPUT_HANDLER):
251 ret = StubRemovePreInputHandler(data, reply);
252 break;
253 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::ADD_GESTURE_MONITOR):
254 ret = StubAddGestureMonitor(data, reply);
255 break;
256 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::REMOVE_GESTURE_MONITOR):
257 ret = StubRemoveGestureMonitor(data, reply);
258 break;
259 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::MARK_EVENT_CONSUMED):
260 ret = StubMarkEventConsumed(data, reply);
261 break;
262 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::MOVE_MOUSE):
263 ret = StubMoveMouseEvent(data, reply);
264 break;
265 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SHIFT_APP_POINTER_EVENT):
266 ret = StubShiftAppPointerEvent(data, reply);
267 break;
268 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::INJECT_KEY_EVENT):
269 ret = StubInjectKeyEvent(data, reply);
270 break;
271 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::INJECT_POINTER_EVENT):
272 ret = StubInjectPointerEvent(data, reply);
273 break;
274 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::INJECT_TOUCHPAD_EVENT):
275 ret = StubInjectTouchPadEvent(data, reply);
276 break;
277 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SET_ANR_OBSERVER):
278 ret = StubSetAnrListener(data, reply);
279 break;
280 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::GET_DISPLAY_BIND_INFO):
281 ret = StubGetDisplayBindInfo(data, reply);
282 break;
283 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::GET_ALL_NAPSTATUS_DATA):
284 ret = StubGetAllMmiSubscribedEvents(data, reply);
285 break;
286 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SET_DISPLAY_BIND):
287 ret = StubSetDisplayBind(data, reply);
288 break;
289 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::GET_FUNCTION_KEY_STATE):
290 ret = StubGetFunctionKeyState(data, reply);
291 break;
292 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SET_FUNCTION_KEY_STATE):
293 ret = StubSetFunctionKeyState(data, reply);
294 break;
295 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SET_POINTER_LOCATION):
296 ret = StubSetPointerLocation(data, reply);
297 break;
298 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SET_CAPTURE_MODE):
299 ret = StubSetMouseCaptureMode(data, reply);
300 break;
301 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::GET_WINDOW_PID):
302 ret = StubGetWindowPid(data, reply);
303 break;
304 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::APPEND_EXTRA_DATA):
305 ret = StubAppendExtraData(data, reply);
306 break;
307 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::ENABLE_INPUT_DEVICE):
308 ret = StubEnableInputDevice(data, reply);
309 break;
310 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::ENABLE_COMBINE_KEY):
311 ret = StubEnableCombineKey(data, reply);
312 break;
313 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SET_KEY_DOWN_DURATION):
314 ret = StubSetKeyDownDuration(data, reply);
315 break;
316 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SET_TP_SCROLL_SWITCH):
317 ret = StubSetTouchpadScrollSwitch(data, reply);
318 break;
319 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::GET_TP_SCROLL_SWITCH):
320 ret = StubGetTouchpadScrollSwitch(data, reply);
321 break;
322 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SET_TP_SCROLL_DIRECT_SWITCH):
323 ret = StubSetTouchpadScrollDirection(data, reply);
324 break;
325 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::GET_TP_SCROLL_DIRECT_SWITCH):
326 ret = StubGetTouchpadScrollDirection(data, reply);
327 break;
328 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SET_TP_TAP_SWITCH):
329 ret = StubSetTouchpadTapSwitch(data, reply);
330 break;
331 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::GET_TP_TAP_SWITCH):
332 ret = StubGetTouchpadTapSwitch(data, reply);
333 break;
334 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SET_TP_POINTER_SPEED):
335 ret = StubSetTouchpadPointerSpeed(data, reply);
336 break;
337 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::GET_TP_POINTER_SPEED):
338 ret = StubGetTouchpadPointerSpeed(data, reply);
339 break;
340 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::GET_TOUCHPAD_OPTION):
341 ret = StubGetTouchpadCDG(data, reply);
342 break;
343 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SET_KEYBOARD_REPEAT_DELAY):
344 ret = StubSetKeyboardRepeatDelay(data, reply);
345 break;
346 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SET_KEYBOARD_REPEAT_RATE):
347 ret = StubSetKeyboardRepeatRate(data, reply);
348 break;
349 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SET_TP_PINCH_SWITCH):
350 ret = StubSetTouchpadPinchSwitch(data, reply);
351 break;
352 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::GET_TP_PINCH_SWITCH):
353 ret = StubGetTouchpadPinchSwitch(data, reply);
354 break;
355 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SET_TP_SWIPE_SWITCH):
356 ret = StubSetTouchpadSwipeSwitch(data, reply);
357 break;
358 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::GET_TP_SWIPE_SWITCH):
359 ret = StubGetTouchpadSwipeSwitch(data, reply);
360 break;
361 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SET_TP_RIGHT_CLICK_TYPE):
362 ret = StubSetTouchpadRightClickType(data, reply);
363 break;
364 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::GET_TP_RIGHT_CLICK_TYPE):
365 ret = StubGetTouchpadRightClickType(data, reply);
366 break;
367 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SET_TP_ROTATE_SWITCH):
368 ret = StubSetTouchpadRotateSwitch(data, reply);
369 break;
370 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::GET_TP_ROTATE_SWITCH):
371 ret = StubGetTouchpadRotateSwitch(data, reply);
372 break;
373 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SET_DOUBLE_TAP_DRAG_STATE):
374 ret = StubSetTouchpadDoubleTapAndDragState(data, reply);
375 break;
376 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::GET_DOUBLE_TAP_DRAG_STATE):
377 ret = StubGetTouchpadDoubleTapAndDragState(data, reply);
378 break;
379 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::GET_KEYBOARD_REPEAT_DELAY):
380 ret = StubGetKeyboardRepeatDelay(data, reply);
381 break;
382 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::GET_KEYBOARD_REPEAT_RATE):
383 ret = StubGetKeyboardRepeatRate(data, reply);
384 break;
385 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SET_MOUSE_HOT_SPOT):
386 ret = StubSetMouseHotSpot(data, reply);
387 break;
388 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SET_SHIELD_STATUS):
389 ret = StubSetShieldStatus(data, reply);
390 break;
391 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::GET_SHIELD_STATUS):
392 ret = StubGetShieldStatus(data, reply);
393 break;
394 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::GET_KEY_STATE):
395 ret = StubGetKeyState(data, reply);
396 break;
397 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::NATIVE_AUTHORIZE):
398 ret = StubAuthorize(data, reply);
399 break;
400 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::NATIVE_CANCEL_INJECTION):
401 ret = StubCancelInjection(data, reply);
402 break;
403 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::NATIVE_INFRARED_OWN):
404 ret = StubHasIrEmitter(data, reply);
405 break;
406 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::NATIVE_INFRARED_FREQUENCY):
407 ret = StubGetInfraredFrequencies(data, reply);
408 break;
409 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::NATIVE_CANCEL_TRANSMIT):
410 ret = StubTransmitInfrared(data, reply);
411 break;
412 #ifdef OHOS_BUILD_ENABLE_VKEYBOARD
413 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::CREATE_VKEYBOARD_DEVICE):
414 ret = StubCreateVKeyboardDevice(data, reply);
415 break;
416 #endif // OHOS_BUILD_ENABLE_VKEYBOARD
417 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SET_PIXEL_MAP_DATA):
418 ret = StubSetPixelMapData(data, reply);
419 break;
420 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SET_MOVE_EVENT_FILTERS):
421 ret = StubSetMoveEventFilters(data, reply);
422 break;
423 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SET_CURRENT_USERID):
424 ret = StubSetCurrentUser(data, reply);
425 break;
426 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::ENABLE_HARDWARE_CURSOR_STATS):
427 ret = StubEnableHardwareCursorStats(data, reply);
428 break;
429 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::GET_HARDWARE_CURSOR_STATS):
430 ret = StubGetHardwareCursorStats(data, reply);
431 break;
432 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SET_TOUCHPAD_SCROLL_ROWS):
433 ret = StubSetTouchpadScrollRows(data, reply);
434 break;
435 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::GET_TOUCHPAD_SCROLL_ROWS):
436 ret = StubGetTouchpadScrollRows(data, reply);
437 break;
438 #ifdef OHOS_BUILD_ENABLE_MAGICCURSOR
439 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::GET_POINTER_SNAPSHOT):
440 ret = StubGetPointerSnapshot(data, reply);
441 break;
442 #endif // OHOS_BUILD_ENABLE_MAGICCURSOR
443 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::ADD_VIRTUAL_INPUT_DEVICE):
444 ret = StubAddVirtualInputDevice(data, reply);
445 break;
446 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::REMOVE_VIRTUAL_INPUT_DEVICE):
447 ret = StubRemoveVirtualInputDevice(data, reply);
448 break;
449 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SET_THREE_GINGERS_TAPSWITCH):
450 ret = StubSetTouchpadThreeFingersTapSwitch(data, reply);
451 break;
452 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::GET_THREE_GINGERS_TAPSWITCH):
453 ret = StubGetTouchpadThreeFingersTapSwitch(data, reply);
454 break;
455 #ifdef OHOS_BUILD_ENABLE_ANCO
456 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::ADD_ANCO_CHANNEL):
457 ret = StubAncoAddChannel(data, reply);
458 break;
459 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::REMOVE_ANCO_CHANNEL):
460 ret = StubAncoRemoveChannel(data, reply);
461 break;
462 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::CHECK_KNUCKLE_EVENT):
463 ret = StubCheckKnuckleEvent(data, reply);
464 break;
465 #endif // OHOS_BUILD_ENABLE_ANCO
466 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::TRANSFER_BINDER_CLIENT_SERVICE):
467 ret = StubTransferBinderClientService(data, reply);
468 break;
469 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SET_CLIENT_INFO):
470 ret = StubSetClientInfo(data, reply);
471 break;
472 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::GET_SYSTEM_EVENT_TIME_INTERVAL):
473 ret = StubGetIntervalSinceLastInput(data, reply);
474 break;
475 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::GET_ALL_SYSTEM_HOT_KEY):
476 ret = StubGetAllSystemHotkeys(data, reply);
477 break;
478 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::GET_CURSOR_SURFACE_ID):
479 ret = StubGetCursorSurfaceId(data, reply);
480 break;
481 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SUBSCRIBE_LONG_PRESS):
482 ret = StubSubscribeLongPressEvent(data, reply);
483 break;
484 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::UNSUBSCRIBE_LONG_PRESS):
485 ret = StubUnsubscribeLongPressEvent(data, reply);
486 break;
487 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SET_INPUT_DEVICE_ENABLE):
488 ret = StubSetInputDeviceInputEnable(data, reply);
489 break;
490 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SET_CUSTOM_MOUSE_CURSOR):
491 ret = StubSetCustomMouseCursor(data, reply);
492 break;
493 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SET_MUILT_WINDOW_SCREEN_ID):
494 ret = StubSetMultiWindowScreenId(data, reply);
495 break;
496 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::SUBSCRIBE_KEY_MONITOR):
497 ret = StubSubscribeKeyMonitor(data, reply);
498 break;
499 case static_cast<uint32_t>(MultimodalinputConnectInterfaceCode::UNSUBSCRIBE_KEY_MONITOR):
500 ret = StubUnsubscribeKeyMonitor(data, reply);
501 break;
502 default: {
503 MMI_HILOGE("Unknown code:%{public}u, go switch default", code);
504 ret = IPCObjectStub::OnRemoteRequest(code, data, reply, option);
505 }
506 }
507 BytraceAdapter::StopIpcServer();
508 return ret;
509 }
510
StubHandleAllocSocketFd(MessageParcel & data,MessageParcel & reply)511 int32_t MultimodalInputConnectStub::StubHandleAllocSocketFd(MessageParcel& data, MessageParcel& reply)
512 {
513 int32_t pid = GetCallingPid();
514 if (!IsRunning()) {
515 MMI_HILOGE("Service is not running. pid:%{public}d, go switch default", pid);
516 return MMISERVICE_NOT_RUNNING;
517 }
518 sptr<ConnectReqParcel> req = data.ReadParcelable<ConnectReqParcel>();
519 CHKPR(req, ERROR_NULL_POINTER);
520 MMI_HILOGD("clientName:%{public}s, moduleId:%{public}d", req->data.clientName.c_str(), req->data.moduleId);
521 if (req->data.clientName.empty()) {
522 MMI_HILOGE("Invalid clientName:empty");
523 return RET_ERR;
524 }
525
526 int32_t clientFd = INVALID_SOCKET_FD;
527 int32_t tokenType = PER_HELPER->GetTokenType();
528 int32_t ret = AllocSocketFd(req->data.clientName, req->data.moduleId, clientFd, tokenType);
529 if (ret != RET_OK) {
530 MMI_HILOGE("AllocSocketFd failed pid:%{public}d, go switch default", pid);
531 if (clientFd >= 0) {
532 close(clientFd);
533 }
534 return ret;
535 }
536
537 if (!reply.WriteFileDescriptor(clientFd)) {
538 MMI_HILOGE("Write file descriptor failed");
539 close(clientFd);
540 return IPC_STUB_WRITE_PARCEL_ERR;
541 }
542
543 WRITEINT32(reply, tokenType, IPC_STUB_WRITE_PARCEL_ERR);
544 MMI_HILOGI("Send clientFd to client, clientFd:%{public}d, tokenType:%{public}d", clientFd, tokenType);
545 close(clientFd);
546 return RET_OK;
547 }
548
StubAddInputEventFilter(MessageParcel & data,MessageParcel & reply)549 int32_t MultimodalInputConnectStub::StubAddInputEventFilter(MessageParcel& data, MessageParcel& reply)
550 {
551 CALL_DEBUG_ENTER;
552 if (!PER_HELPER->VerifySystemApp()) {
553 MMI_HILOGE("Verify system APP failed");
554 return ERROR_NOT_SYSAPI;
555 }
556 if (!PER_HELPER->CheckInputEventFilter()) {
557 MMI_HILOGE("Filter permission check failed");
558 return ERROR_NO_PERMISSION;
559 }
560 sptr<IRemoteObject> client = data.ReadRemoteObject();
561 CHKPR(client, ERR_INVALID_VALUE);
562 sptr<IEventFilter> filter = iface_cast<IEventFilter>(client);
563 CHKPR(filter, ERROR_NULL_POINTER);
564 int32_t filterId = -1;
565 READINT32(data, filterId, IPC_PROXY_DEAD_OBJECT_ERR);
566 int32_t priority = 0;
567 READINT32(data, priority, IPC_PROXY_DEAD_OBJECT_ERR);
568 uint32_t deviceTags = 0;
569 READUINT32(data, deviceTags, IPC_PROXY_DEAD_OBJECT_ERR);
570 int32_t ret = AddInputEventFilter(filter, filterId, priority, deviceTags);
571 if (ret != RET_OK) {
572 MMI_HILOGE("Call AddInputEventFilter failed:%{public}d", ret);
573 return ret;
574 }
575 MMI_HILOGD("Success pid:%{public}d", GetCallingPid());
576 return RET_OK;
577 }
578
StubRemoveInputEventFilter(MessageParcel & data,MessageParcel & reply)579 int32_t MultimodalInputConnectStub::StubRemoveInputEventFilter(MessageParcel& data, MessageParcel& reply)
580 {
581 CALL_DEBUG_ENTER;
582 if (!PER_HELPER->VerifySystemApp()) {
583 MMI_HILOGE("Verify system APP failed");
584 return ERROR_NOT_SYSAPI;
585 }
586 if (!PER_HELPER->CheckInputEventFilter()) {
587 MMI_HILOGE("Filter permission check failed");
588 return ERROR_NO_PERMISSION;
589 }
590 int32_t filterId = -1;
591 READINT32(data, filterId, IPC_PROXY_DEAD_OBJECT_ERR);
592 int32_t ret = RemoveInputEventFilter(filterId);
593 if (ret != RET_OK) {
594 MMI_HILOGE("Call RemoveInputEventFilter failed:%{public}d", ret);
595 return ret;
596 }
597 MMI_HILOGD("Success pid:%{public}d", GetCallingPid());
598 return RET_OK;
599 }
600
StubSetMouseScrollRows(MessageParcel & data,MessageParcel & reply)601 int32_t MultimodalInputConnectStub::StubSetMouseScrollRows(MessageParcel& data, MessageParcel& reply)
602 {
603 CALL_DEBUG_ENTER;
604 if (!IsRunning()) {
605 MMI_HILOGE("Service is not running");
606 return MMISERVICE_NOT_RUNNING;
607 }
608
609 if (!PER_HELPER->VerifySystemApp()) {
610 MMI_HILOGE("Verify system APP failed");
611 return ERROR_NOT_SYSAPI;
612 }
613
614 int32_t rows = 3; // the initial number of scrolling rows is 3.
615 READINT32(data, rows, IPC_PROXY_DEAD_OBJECT_ERR);
616 int32_t ret = SetMouseScrollRows(rows);
617 if (ret != RET_OK) {
618 MMI_HILOGE("Call SetMouseScrollRows failed:%{public}d", ret);
619 return ret;
620 }
621 MMI_HILOGD("Success rows:%{public}d, pid:%{public}d", rows, GetCallingPid());
622 return RET_OK;
623 }
624
StubSetCustomCursor(MessageParcel & data,MessageParcel & reply)625 int32_t MultimodalInputConnectStub::StubSetCustomCursor(MessageParcel& data, MessageParcel& reply)
626 {
627 CALL_DEBUG_ENTER;
628 if (!IsRunning()) {
629 MMI_HILOGE("Service is not running");
630 return MMISERVICE_NOT_RUNNING;
631 }
632 int32_t windowId = 0;
633 int32_t focusX = 0;
634 int32_t focusY = 0;
635 READINT32(data, windowId, IPC_PROXY_DEAD_OBJECT_ERR);
636 READINT32(data, focusX, IPC_PROXY_DEAD_OBJECT_ERR);
637 READINT32(data, focusY, IPC_PROXY_DEAD_OBJECT_ERR);
638 if (windowId <= 0) {
639 MMI_HILOGE("Invalid windowId:%{public}d", windowId);
640 return RET_ERR;
641 }
642 OHOS::Media::PixelMap* pixelMap = Media::PixelMap::Unmarshalling(data);
643 CHKPR(pixelMap, RET_ERR);
644 focusX = focusX < 0 ? 0 : focusX;
645 focusY = focusY < 0 ? 0 : focusY;
646 focusX = focusX > pixelMap->GetWidth() ? pixelMap->GetWidth() : focusX;
647 focusY = focusY > pixelMap->GetHeight() ? pixelMap->GetHeight() : focusY;
648 int32_t ret = SetCustomCursor(windowId, focusX, focusY, (void*)pixelMap);
649 if (ret != RET_OK) {
650 MMI_HILOGE("Call SetCustomCursor failed:%{public}d", ret);
651 return ret;
652 }
653 return RET_OK;
654 }
655
StubSetMouseIcon(MessageParcel & data,MessageParcel & reply)656 int32_t MultimodalInputConnectStub::StubSetMouseIcon(MessageParcel& data, MessageParcel& reply)
657 {
658 CALL_DEBUG_ENTER;
659 if (!PER_HELPER->VerifySystemApp()) {
660 MMI_HILOGE("Verify system APP failed");
661 return ERROR_NOT_SYSAPI;
662 }
663 if (!IsRunning()) {
664 MMI_HILOGE("Service is not running");
665 return MMISERVICE_NOT_RUNNING;
666 }
667 int32_t windowId = 0;
668 OHOS::Media::PixelMap *pixelMap = OHOS::Media::PixelMap::Unmarshalling(data);
669 CHKPR(pixelMap, RET_ERR);
670 READINT32(data, windowId, IPC_PROXY_DEAD_OBJECT_ERR);
671 MMI_HILOGD("Reading windowid the tlv count:%{public}d", windowId);
672 if (windowId <= 0) {
673 MMI_HILOGE("Invalid windowId:%{public}d", windowId);
674 return RET_ERR;
675 }
676
677 int32_t ret = SetMouseIcon(windowId, (void*)pixelMap);
678 if (ret != RET_OK) {
679 MMI_HILOGE("Call SetMouseIcon failed:%{public}d", ret);
680 return ret;
681 }
682 return RET_OK;
683 }
684
StubSetMouseHotSpot(MessageParcel & data,MessageParcel & reply)685 int32_t MultimodalInputConnectStub::StubSetMouseHotSpot(MessageParcel& data, MessageParcel& reply)
686 {
687 CALL_DEBUG_ENTER;
688 if (!PER_HELPER->VerifySystemApp()) {
689 MMI_HILOGE("Verify system APP failed");
690 return ERROR_NOT_SYSAPI;
691 }
692 if (!IsRunning()) {
693 MMI_HILOGE("Service is not running");
694 return MMISERVICE_NOT_RUNNING;
695 }
696 int32_t windowId = 0;
697 int32_t winPid = -1;
698 READINT32(data, winPid, IPC_PROXY_DEAD_OBJECT_ERR);
699 READINT32(data, windowId, IPC_PROXY_DEAD_OBJECT_ERR);
700 if (windowId <= 0) {
701 MMI_HILOGE("Invalid windowId:%{public}d", windowId);
702 return RET_ERR;
703 }
704 int32_t hotSpotX = 0;
705 READINT32(data, hotSpotX, IPC_PROXY_DEAD_OBJECT_ERR);
706 int32_t hotSpotY = 0;
707 READINT32(data, hotSpotY, IPC_PROXY_DEAD_OBJECT_ERR);
708 int32_t ret = SetMouseHotSpot(winPid, windowId, hotSpotX, hotSpotY);
709 if (ret != RET_OK) {
710 MMI_HILOGE("Call SetMouseHotSpot failed:%{public}d", ret);
711 return ret;
712 }
713 return RET_OK;
714 }
715
StubGetMouseScrollRows(MessageParcel & data,MessageParcel & reply)716 int32_t MultimodalInputConnectStub::StubGetMouseScrollRows(MessageParcel& data, MessageParcel& reply)
717 {
718 CALL_DEBUG_ENTER;
719 if (!IsRunning()) {
720 MMI_HILOGE("Service is not running");
721 return MMISERVICE_NOT_RUNNING;
722 }
723
724 if (!PER_HELPER->VerifySystemApp()) {
725 MMI_HILOGE("Verify system APP failed");
726 return ERROR_NOT_SYSAPI;
727 }
728
729 int32_t rows = 3; // the initial number of scrolling rows is 3.
730 int32_t ret = GetMouseScrollRows(rows);
731 if (ret != RET_OK) {
732 MMI_HILOGE("Call GetMouseScrollRows failed ret:%{public}d", ret);
733 return ret;
734 }
735 WRITEINT32(reply, rows, IPC_STUB_WRITE_PARCEL_ERR);
736 MMI_HILOGD("Mouse scroll rows:%{public}d, ret:%{public}d", rows, ret);
737 return RET_OK;
738 }
739
StubSetPointerSize(MessageParcel & data,MessageParcel & reply)740 int32_t MultimodalInputConnectStub::StubSetPointerSize(MessageParcel& data, MessageParcel& reply)
741 {
742 CALL_DEBUG_ENTER;
743 if (!IsRunning()) {
744 MMI_HILOGE("Service is not running");
745 return MMISERVICE_NOT_RUNNING;
746 }
747
748 if (!PER_HELPER->VerifySystemApp()) {
749 MMI_HILOGE("Verify system APP failed");
750 return ERROR_NOT_SYSAPI;
751 }
752
753 int32_t size = 1; // the initial pointer size is 1.
754 READINT32(data, size, IPC_PROXY_DEAD_OBJECT_ERR);
755 int32_t ret = SetPointerSize(size);
756 if (ret != RET_OK) {
757 MMI_HILOGE("Call SetPointerSize failed ret:%{public}d", ret);
758 return ret;
759 }
760 MMI_HILOGD("Success size:%{public}d, pid:%{public}d", size, GetCallingPid());
761 return RET_OK;
762 }
763
StubSetNapStatus(MessageParcel & data,MessageParcel & reply)764 int32_t MultimodalInputConnectStub::StubSetNapStatus(MessageParcel& data, MessageParcel& reply)
765 {
766 CALL_DEBUG_ENTER;
767 if (!PER_HELPER->VerifySystemApp()) {
768 MMI_HILOGE("Verify system APP failed");
769 return ERROR_NOT_SYSAPI;
770 }
771 if (!IsRunning()) {
772 MMI_HILOGE("Service is not running");
773 return MMISERVICE_NOT_RUNNING;
774 }
775 int32_t napPid = -1;
776 int32_t napUid = -1;
777 std::string napBundleName;
778 int32_t napStatus = 0;
779 READINT32(data, napPid, IPC_PROXY_DEAD_OBJECT_ERR);
780 READINT32(data, napUid, IPC_PROXY_DEAD_OBJECT_ERR);
781 READSTRING(data, napBundleName, IPC_PROXY_DEAD_OBJECT_ERR);
782 READINT32(data, napStatus, IPC_PROXY_DEAD_OBJECT_ERR);
783
784 int32_t ret = SetNapStatus(napPid, napUid, napBundleName, napStatus);
785 if (ret != RET_OK) {
786 MMI_HILOGE("Call StubSetNapStatus failed ret:%{public}d", ret);
787 return ret;
788 }
789 MMI_HILOGD("Success set napStatus:%{public}d, pid:%{public}d", napStatus, GetCallingPid());
790 return RET_OK;
791 }
792
StubGetPointerSize(MessageParcel & data,MessageParcel & reply)793 int32_t MultimodalInputConnectStub::StubGetPointerSize(MessageParcel& data, MessageParcel& reply)
794 {
795 CALL_DEBUG_ENTER;
796 if (!IsRunning()) {
797 MMI_HILOGE("Service is not running");
798 return MMISERVICE_NOT_RUNNING;
799 }
800
801 if (!PER_HELPER->VerifySystemApp()) {
802 MMI_HILOGE("Verify system APP failed");
803 return ERROR_NOT_SYSAPI;
804 }
805
806 int32_t size = 1; // the initial pointer size is 1.
807 int32_t ret = GetPointerSize(size);
808 if (ret != RET_OK) {
809 MMI_HILOGE("Call GetPoinerSize failed ret:%{public}d", ret);
810 return ret;
811 }
812 WRITEINT32(reply, size, IPC_STUB_WRITE_PARCEL_ERR);
813 MMI_HILOGD("Pointer size:%{public}d, ret:%{public}d", size, ret);
814 return RET_OK;
815 }
816
StubGetCursorSurfaceId(MessageParcel & data,MessageParcel & reply)817 int32_t MultimodalInputConnectStub::StubGetCursorSurfaceId(MessageParcel& data, MessageParcel& reply)
818 {
819 if (!IsRunning()) {
820 MMI_HILOGE("Service is not running");
821 return MMISERVICE_NOT_RUNNING;
822 }
823 if (!PER_HELPER->VerifySystemApp()) {
824 MMI_HILOGE("Verify system APP failed");
825 return ERROR_NOT_SYSAPI;
826 }
827 uint64_t surfaceId {};
828 auto ret = GetCursorSurfaceId(surfaceId);
829 if (ret != RET_OK) {
830 MMI_HILOGE("GetCursorSurfaceId fail, ret:%{public}d", ret);
831 return ret;
832 }
833 WRITEUINT64(reply, surfaceId, IPC_STUB_WRITE_PARCEL_ERR);
834 return RET_OK;
835 }
836
StubSetMousePrimaryButton(MessageParcel & data,MessageParcel & reply)837 int32_t MultimodalInputConnectStub::StubSetMousePrimaryButton(MessageParcel& data, MessageParcel& reply)
838 {
839 CALL_DEBUG_ENTER;
840 if (!PER_HELPER->VerifySystemApp()) {
841 MMI_HILOGE("Verify system APP failed");
842 return ERROR_NOT_SYSAPI;
843 }
844
845 int32_t primaryButton = -1;
846 READINT32(data, primaryButton, IPC_PROXY_DEAD_OBJECT_ERR);
847 int32_t ret = SetMousePrimaryButton(primaryButton);
848 if (ret != RET_OK) {
849 MMI_HILOGE("Call SetMousePrimaryButton failed ret:%{public}d", ret);
850 return ret;
851 }
852 MMI_HILOGD("Success primaryButton:%{public}d, pid:%{public}d", primaryButton, GetCallingPid());
853 return RET_OK;
854 }
855
StubGetMousePrimaryButton(MessageParcel & data,MessageParcel & reply)856 int32_t MultimodalInputConnectStub::StubGetMousePrimaryButton(MessageParcel& data, MessageParcel& reply)
857 {
858 CALL_DEBUG_ENTER;
859 if (!PER_HELPER->VerifySystemApp()) {
860 MMI_HILOGE("Verify system APP failed");
861 return ERROR_NOT_SYSAPI;
862 }
863
864 int32_t primaryButton = -1;
865 int32_t ret = GetMousePrimaryButton(primaryButton);
866 if (ret != RET_OK) {
867 MMI_HILOGE("Call GetMousePrimaryButton failed ret:%{public}d", ret);
868 return ret;
869 }
870 WRITEINT32(reply, primaryButton, IPC_STUB_WRITE_PARCEL_ERR);
871 MMI_HILOGD("Mouse primaryButton:%{public}d, ret:%{public}d", primaryButton, ret);
872 return RET_OK;
873 }
874
StubSetHoverScrollState(MessageParcel & data,MessageParcel & reply)875 int32_t MultimodalInputConnectStub::StubSetHoverScrollState(MessageParcel& data, MessageParcel& reply)
876 {
877 CALL_DEBUG_ENTER;
878 if (!PER_HELPER->VerifySystemApp()) {
879 MMI_HILOGE("Verify system APP failed");
880 return ERROR_NOT_SYSAPI;
881 }
882
883 bool state = true;
884 READBOOL(data, state, IPC_PROXY_DEAD_OBJECT_ERR);
885 int32_t ret = SetHoverScrollState(state);
886 if (ret != RET_OK) {
887 MMI_HILOGE("Call SetHoverScrollState failed, ret:%{public}d", ret);
888 return ret;
889 }
890 MMI_HILOGD("Success state:%{public}d, pid:%{public}d", state, GetCallingPid());
891 return RET_OK;
892 }
893
StubGetHoverScrollState(MessageParcel & data,MessageParcel & reply)894 int32_t MultimodalInputConnectStub::StubGetHoverScrollState(MessageParcel& data, MessageParcel& reply)
895 {
896 CALL_DEBUG_ENTER;
897 if (!PER_HELPER->VerifySystemApp()) {
898 MMI_HILOGE("Verify system APP failed");
899 return ERROR_NOT_SYSAPI;
900 }
901
902 bool state = true;
903 int32_t ret = GetHoverScrollState(state);
904 if (ret != RET_OK) {
905 MMI_HILOGE("Call GetHoverScrollState failed, ret:%{public}d", ret);
906 return ret;
907 }
908 WRITEBOOL(reply, state, IPC_STUB_WRITE_PARCEL_ERR);
909 MMI_HILOGD("Mouse hover scroll state:%{public}d, ret:%{public}d", state, ret);
910 return RET_OK;
911 }
912
StubSetPointerVisible(MessageParcel & data,MessageParcel & reply)913 int32_t MultimodalInputConnectStub::StubSetPointerVisible(MessageParcel& data, MessageParcel& reply)
914 {
915 CALL_DEBUG_ENTER;
916 bool visible = false;
917 READBOOL(data, visible, IPC_PROXY_DEAD_OBJECT_ERR);
918 int32_t priority = 0;
919 READINT32(data, priority, IPC_PROXY_DEAD_OBJECT_ERR);
920 if (priority < 0) {
921 MMI_HILOGE("Invalid priority:%{public}d", priority);
922 return RET_ERR;
923 }
924 int32_t ret = SetPointerVisible(visible, priority);
925 if (ret != RET_OK) {
926 MMI_HILOGE("Call SetPointerVisible failed ret:%{public}d", ret);
927 return ret;
928 }
929 MMI_HILOGD("Success visible:%{public}d,pid:%{public}d", visible, GetCallingPid());
930 return RET_OK;
931 }
932
StubIsPointerVisible(MessageParcel & data,MessageParcel & reply)933 int32_t MultimodalInputConnectStub::StubIsPointerVisible(MessageParcel& data, MessageParcel& reply)
934 {
935 CALL_DEBUG_ENTER;
936 bool visible = false;
937 int32_t ret = IsPointerVisible(visible);
938 if (ret != RET_OK) {
939 MMI_HILOGE("Call IsPointerVisible failed ret:%{public}d", ret);
940 return ret;
941 }
942 WRITEBOOL(reply, visible, IPC_STUB_WRITE_PARCEL_ERR);
943 MMI_HILOGD("visible:%{public}d, ret:%{public}d, pid:%{public}d", visible, ret, GetCallingPid());
944 return RET_OK;
945 }
946
StubMarkProcessed(MessageParcel & data,MessageParcel & reply)947 int32_t MultimodalInputConnectStub::StubMarkProcessed(MessageParcel& data, MessageParcel& reply)
948 {
949 CALL_DEBUG_ENTER;
950 if (!IsRunning()) {
951 MMI_HILOGE("Service is not running");
952 return MMISERVICE_NOT_RUNNING;
953 }
954 int32_t eventType;
955 READINT32(data, eventType, IPC_PROXY_DEAD_OBJECT_ERR);
956 int32_t eventId;
957 READINT32(data, eventId, IPC_PROXY_DEAD_OBJECT_ERR);
958 int32_t ret = MarkProcessed(eventType, eventId);
959 if (ret != RET_OK) {
960 MMI_HILOGD("MarkProcessed failed, ret:%{public}d", ret);
961 return ret;
962 }
963 return RET_OK;
964 }
965
StubSetPointerColor(MessageParcel & data,MessageParcel & reply)966 int32_t MultimodalInputConnectStub::StubSetPointerColor(MessageParcel& data, MessageParcel& reply)
967 {
968 CALL_DEBUG_ENTER;
969 if (!IsRunning()) {
970 MMI_HILOGE("Service is not running");
971 return MMISERVICE_NOT_RUNNING;
972 }
973
974 if (!PER_HELPER->VerifySystemApp()) {
975 MMI_HILOGE("Verify system APP failed");
976 return ERROR_NOT_SYSAPI;
977 }
978
979 int32_t color = DEFAULT_POINTER_COLOR;
980 READINT32(data, color, IPC_PROXY_DEAD_OBJECT_ERR);
981 int32_t ret = SetPointerColor(color);
982 if (ret != RET_OK) {
983 MMI_HILOGE("Call SetPointerColor failed ret:%{public}d", ret);
984 return ret;
985 }
986 MMI_HILOGD("Success color:%{public}d, pid:%{public}d", color, GetCallingPid());
987 return RET_OK;
988 }
989
StubGetPointerColor(MessageParcel & data,MessageParcel & reply)990 int32_t MultimodalInputConnectStub::StubGetPointerColor(MessageParcel& data, MessageParcel& reply)
991 {
992 CALL_DEBUG_ENTER;
993 if (!IsRunning()) {
994 MMI_HILOGE("Service is not running");
995 return MMISERVICE_NOT_RUNNING;
996 }
997
998 if (!PER_HELPER->VerifySystemApp()) {
999 MMI_HILOGE("Verify system APP failed");
1000 return ERROR_NOT_SYSAPI;
1001 }
1002
1003 int32_t color = DEFAULT_POINTER_COLOR;
1004 int32_t ret = GetPointerColor(color);
1005 if (ret != RET_OK) {
1006 MMI_HILOGE("Call GetPointerColor failed ret:%{public}d", ret);
1007 return ret;
1008 }
1009 WRITEINT32(reply, color, IPC_STUB_WRITE_PARCEL_ERR);
1010 MMI_HILOGD("Pointer color:%{public}d, ret:%{public}d", color, ret);
1011 return RET_OK;
1012 }
1013
StubSetPointerSpeed(MessageParcel & data,MessageParcel & reply)1014 int32_t MultimodalInputConnectStub::StubSetPointerSpeed(MessageParcel& data, MessageParcel& reply)
1015 {
1016 CALL_DEBUG_ENTER;
1017 if (!PER_HELPER->VerifySystemApp()) {
1018 MMI_HILOGE("Verify system APP failed");
1019 return ERROR_NOT_SYSAPI;
1020 }
1021
1022 int32_t speed = 0;
1023 READINT32(data, speed, IPC_PROXY_DEAD_OBJECT_ERR);
1024 int32_t ret = SetPointerSpeed(speed);
1025 if (ret != RET_OK) {
1026 MMI_HILOGE("Set pointer speed failed ret:%{public}d", ret);
1027 return RET_ERR;
1028 }
1029 return RET_OK;
1030 }
1031
StubGetPointerSpeed(MessageParcel & data,MessageParcel & reply)1032 int32_t MultimodalInputConnectStub::StubGetPointerSpeed(MessageParcel& data, MessageParcel& reply)
1033 {
1034 CALL_DEBUG_ENTER;
1035 if (!PER_HELPER->VerifySystemApp()) {
1036 MMI_HILOGE("Verify system APP failed");
1037 return ERROR_NOT_SYSAPI;
1038 }
1039
1040 int32_t speed = 0;
1041 int32_t ret = GetPointerSpeed(speed);
1042 if (ret != RET_OK) {
1043 MMI_HILOGE("Call get pointer speed failed ret:%{public}d", ret);
1044 return RET_ERR;
1045 }
1046 WRITEINT32(reply, speed, IPC_STUB_WRITE_PARCEL_ERR);
1047 MMI_HILOGD("Pointer speed:%{public}d, ret:%{public}d", speed, ret);
1048 return RET_OK;
1049 }
1050
StubNotifyNapOnline(MessageParcel & data,MessageParcel & reply)1051 int32_t MultimodalInputConnectStub::StubNotifyNapOnline(MessageParcel& data, MessageParcel& reply)
1052 {
1053 CALL_DEBUG_ENTER;
1054 int32_t ret = NotifyNapOnline();
1055 return ret;
1056 }
1057
StubRemoveInputEventObserver(MessageParcel & data,MessageParcel & reply)1058 int32_t MultimodalInputConnectStub::StubRemoveInputEventObserver(MessageParcel& data, MessageParcel& reply)
1059 {
1060 CALL_DEBUG_ENTER;
1061 if (!PER_HELPER->VerifySystemApp()) {
1062 MMI_HILOGE("Verify system APP failed");
1063 return ERROR_NOT_SYSAPI;
1064 }
1065 int32_t ret = RemoveInputEventObserver();
1066 return ret;
1067 }
1068
StubSetPointerStyle(MessageParcel & data,MessageParcel & reply)1069 int32_t MultimodalInputConnectStub::StubSetPointerStyle(MessageParcel& data, MessageParcel& reply)
1070 {
1071 CALL_DEBUG_ENTER;
1072 int32_t windowId = 0;
1073 READINT32(data, windowId, RET_ERR);
1074 if (!PER_HELPER->VerifySystemApp()) {
1075 if (windowId < 0) {
1076 MMI_HILOGE("windowId is negative number and not system hap, set pointerStyle failed");
1077 return ERROR_NOT_SYSAPI;
1078 }
1079 }
1080 PointerStyle pointerStyle;
1081 READINT32(data, pointerStyle.size, RET_ERR);
1082 READINT32(data, pointerStyle.color, RET_ERR);
1083 READINT32(data, pointerStyle.id, RET_ERR);
1084 bool isUiExtension;
1085 READBOOL(data, isUiExtension, RET_ERR);
1086 if (windowId == -1 && !PER_HELPER->VerifySystemApp()) {
1087 MMI_HILOGE("Can not set global winid, because this is not sys app");
1088 return ERROR_NOT_SYSAPI;
1089 }
1090 int32_t ret = SetPointerStyle(windowId, pointerStyle, isUiExtension);
1091 if (ret != RET_OK) {
1092 MMI_HILOGE("Call SetPointerStyle failed ret:%{public}d", ret);
1093 return ret;
1094 }
1095 MMI_HILOGD("Successfully set windowId:%{public}d, icon:%{public}d", windowId, pointerStyle.id);
1096 return RET_OK;
1097 }
1098
StubClearWindowPointerStyle(MessageParcel & data,MessageParcel & reply)1099 int32_t MultimodalInputConnectStub::StubClearWindowPointerStyle(MessageParcel& data, MessageParcel& reply)
1100 {
1101 CALL_DEBUG_ENTER;
1102 if (!PER_HELPER->VerifySystemApp()) {
1103 MMI_HILOGE("Verify system APP failed");
1104 return ERROR_NOT_SYSAPI;
1105 }
1106 int32_t pid = GetCallingPid();
1107 int32_t windowId = 0;
1108 READINT32(data, windowId, RET_ERR);
1109 if (windowId <= 0) {
1110 MMI_HILOGE("Invalid windowId:%{public}d", windowId);
1111 return RET_ERR;
1112 }
1113
1114 int32_t ret = ClearWindowPointerStyle(pid, windowId);
1115 if (ret != RET_OK) {
1116 MMI_HILOGE("Call SetPointerStyle failed ret:%{public}d", ret);
1117 return ret;
1118 }
1119 MMI_HILOGD("Successfully clean pointerStyle for windowId:%{public}d, pid:%{public}d", windowId, pid);
1120 return RET_OK;
1121 }
1122
StubGetPointerStyle(MessageParcel & data,MessageParcel & reply)1123 int32_t MultimodalInputConnectStub::StubGetPointerStyle(MessageParcel& data, MessageParcel& reply)
1124 {
1125 CALL_DEBUG_ENTER;
1126 int32_t windowId = 0;
1127 READINT32(data, windowId, RET_ERR);
1128 bool isUiExtension;
1129 READBOOL(data, isUiExtension, RET_ERR);
1130 PointerStyle pointerStyle;
1131 int32_t ret = GetPointerStyle(windowId, pointerStyle, isUiExtension);
1132 if (ret != RET_OK) {
1133 MMI_HILOGE("Call GetPointerStyle failed ret:%{public}d", ret);
1134 return ret;
1135 }
1136 WRITEINT32(reply, pointerStyle.size, RET_ERR);
1137 WRITEINT32(reply, pointerStyle.color, RET_ERR);
1138 WRITEINT32(reply, pointerStyle.id, RET_ERR);
1139 WRITEINT32(reply, pointerStyle.options, RET_ERR);
1140 MMI_HILOGD("Successfully get windowId:%{public}d, icon:%{public}d", windowId, pointerStyle.id);
1141 return RET_OK;
1142 }
1143
StubSupportKeys(MessageParcel & data,MessageParcel & reply)1144 int32_t MultimodalInputConnectStub::StubSupportKeys(MessageParcel& data, MessageParcel& reply)
1145 {
1146 CALL_DEBUG_ENTER;
1147 int32_t deviceId = -1;
1148 READINT32(data, deviceId, IPC_PROXY_DEAD_OBJECT_ERR);
1149 if (deviceId < 0) {
1150 MMI_HILOGE("invalid deviceId :%{public}d", deviceId);
1151 return RET_ERR;
1152 }
1153 int32_t size = 0;
1154 READINT32(data, size, IPC_PROXY_DEAD_OBJECT_ERR);
1155 if (size < 0 || size > ExtraData::MAX_BUFFER_SIZE) {
1156 MMI_HILOGE("Invalid size:%{public}d", size);
1157 return RET_ERR;
1158 }
1159 std::vector<int32_t> keys;
1160 int32_t key = 0;
1161 for (int32_t i = 0; i < size; ++i) {
1162 READINT32(data, key, IPC_PROXY_DEAD_OBJECT_ERR);
1163 keys.push_back(key);
1164 }
1165 std::vector<bool> keystroke;
1166 int32_t ret = SupportKeys(deviceId, keys, keystroke);
1167 if (ret != RET_OK) {
1168 MMI_HILOGE("Call SupportKeys failed ret:%{public}d", ret);
1169 return RET_ERR;
1170 }
1171 if (!reply.WriteBoolVector(keystroke)) {
1172 MMI_HILOGE("Write keyStroke failed");
1173 return RET_ERR;
1174 }
1175 return ret;
1176 }
1177
StubGetDeviceIds(MessageParcel & data,MessageParcel & reply)1178 int32_t MultimodalInputConnectStub::StubGetDeviceIds(MessageParcel& data, MessageParcel& reply)
1179 {
1180 CALL_DEBUG_ENTER;
1181 std::vector<int32_t> ids;
1182 int32_t ret = GetDeviceIds(ids);
1183 if (ret != RET_OK) {
1184 MMI_HILOGE("Call GetDeviceIds failed ret:%{public}d", ret);
1185 return RET_ERR;
1186 }
1187 if (!reply.WriteInt32Vector(ids)) {
1188 MMI_HILOGE("Write ids failed");
1189 return RET_ERR;
1190 }
1191 return ret;
1192 }
1193
StubGetDevice(MessageParcel & data,MessageParcel & reply)1194 int32_t MultimodalInputConnectStub::StubGetDevice(MessageParcel& data, MessageParcel& reply)
1195 {
1196 CALL_DEBUG_ENTER;
1197 int32_t deviceId = -1;
1198 READINT32(data, deviceId, IPC_PROXY_DEAD_OBJECT_ERR);
1199 std::shared_ptr<InputDevice> inputDevice = std::make_shared<InputDevice>();
1200 int32_t ret = GetDevice(deviceId, inputDevice);
1201 if (ret != RET_OK) {
1202 MMI_HILOGE("Call GetDevice failed ret:%{public}d", ret);
1203 return RET_ERR;
1204 }
1205 WRITEINT32(reply, inputDevice->GetId(), IPC_STUB_WRITE_PARCEL_ERR);
1206 WRITEINT32(reply, inputDevice->GetType(), IPC_STUB_WRITE_PARCEL_ERR);
1207 WRITESTRING(reply, inputDevice->GetName(), IPC_STUB_WRITE_PARCEL_ERR);
1208 WRITEINT32(reply, inputDevice->GetBus(), IPC_STUB_WRITE_PARCEL_ERR);
1209 WRITEINT32(reply, inputDevice->GetVersion(), IPC_STUB_WRITE_PARCEL_ERR);
1210 WRITEINT32(reply, inputDevice->GetProduct(), IPC_STUB_WRITE_PARCEL_ERR);
1211 WRITEINT32(reply, inputDevice->GetVendor(), IPC_STUB_WRITE_PARCEL_ERR);
1212 WRITESTRING(reply, inputDevice->GetPhys(), IPC_STUB_WRITE_PARCEL_ERR);
1213 WRITESTRING(reply, inputDevice->GetUniq(), IPC_STUB_WRITE_PARCEL_ERR);
1214 WRITEUINT64(reply, static_cast<uint64_t>(inputDevice->GetCapabilities()), IPC_STUB_WRITE_PARCEL_ERR);
1215 WRITEUINT32(reply, static_cast<uint32_t>(inputDevice->GetAxisInfo().size()), IPC_STUB_WRITE_PARCEL_ERR);
1216 for (const auto &item : inputDevice->GetAxisInfo()) {
1217 WRITEINT32(reply, item.GetMinimum(), IPC_STUB_WRITE_PARCEL_ERR);
1218 WRITEINT32(reply, item.GetMaximum(), IPC_STUB_WRITE_PARCEL_ERR);
1219 WRITEINT32(reply, item.GetAxisType(), IPC_STUB_WRITE_PARCEL_ERR);
1220 WRITEINT32(reply, item.GetFuzz(), IPC_STUB_WRITE_PARCEL_ERR);
1221 WRITEINT32(reply, item.GetFlat(), IPC_STUB_WRITE_PARCEL_ERR);
1222 WRITEINT32(reply, item.GetResolution(), IPC_STUB_WRITE_PARCEL_ERR);
1223 }
1224 return RET_OK;
1225 }
1226
StubRegisterInputDeviceMonitor(MessageParcel & data,MessageParcel & reply)1227 int32_t MultimodalInputConnectStub::StubRegisterInputDeviceMonitor(MessageParcel& data, MessageParcel& reply)
1228 {
1229 CALL_DEBUG_ENTER;
1230 int32_t ret = RegisterDevListener();
1231 if (ret != RET_OK) {
1232 MMI_HILOGE("Call RegisterInputDeviceMonitor failed ret:%{public}d", ret);
1233 }
1234 return ret;
1235 }
1236
StubUnregisterInputDeviceMonitor(MessageParcel & data,MessageParcel & reply)1237 int32_t MultimodalInputConnectStub::StubUnregisterInputDeviceMonitor(MessageParcel& data, MessageParcel& reply)
1238 {
1239 CALL_DEBUG_ENTER;
1240 int32_t ret = UnregisterDevListener();
1241 if (ret != RET_OK) {
1242 MMI_HILOGE("Call UnregisterInputDeviceMonitor failed ret:%{public}d", ret);
1243 }
1244 return ret;
1245 }
1246
StubGetKeyboardType(MessageParcel & data,MessageParcel & reply)1247 int32_t MultimodalInputConnectStub::StubGetKeyboardType(MessageParcel& data, MessageParcel& reply)
1248 {
1249 CALL_DEBUG_ENTER;
1250 int32_t deviceId = -1;
1251 READINT32(data, deviceId, IPC_PROXY_DEAD_OBJECT_ERR);
1252 if (deviceId < 0) {
1253 MMI_HILOGE("invalid deviceId :%{public}d", deviceId);
1254 return RET_ERR;
1255 }
1256 int32_t keyboardType = 0;
1257 int32_t ret = GetKeyboardType(deviceId, keyboardType);
1258 if (ret != RET_OK) {
1259 MMI_HILOGE("Call GetKeyboardType failed ret:%{public}d", ret);
1260 return RET_ERR;
1261 }
1262 WRITEINT32(reply, keyboardType, IPC_STUB_WRITE_PARCEL_ERR);
1263 return ret;
1264 }
1265
ParseAddInputHandlerData(MessageParcel & data,ParseData & parseData)1266 int32_t MultimodalInputConnectStub::ParseAddInputHandlerData(MessageParcel& data, ParseData& parseData)
1267 {
1268 READINT32(data, parseData.actionsTypeSize, IPC_PROXY_DEAD_OBJECT_ERR);
1269 std::vector<int32_t> actionsType;
1270 if (parseData.actionsTypeSize == 0) {
1271 READUINT32(data, parseData.eventType, IPC_PROXY_DEAD_OBJECT_ERR);
1272 READINT32(data, parseData.priority, IPC_PROXY_DEAD_OBJECT_ERR);
1273 READINT32(data, parseData.deviceTags, IPC_PROXY_DEAD_OBJECT_ERR);
1274 } else {
1275 if (parseData.actionsTypeSize < 0 || parseData.actionsTypeSize > ExtraData::MAX_BUFFER_SIZE) {
1276 MMI_HILOGE("Invalid actionsTypeSize:%{public}d", parseData.actionsTypeSize);
1277 return RET_ERR;
1278 }
1279 int32_t key = 0;
1280 for (int32_t i = 0; i < parseData.actionsTypeSize; ++i) {
1281 READINT32(data, key, IPC_PROXY_DEAD_OBJECT_ERR);
1282 parseData.actionsType.push_back(key);
1283 }
1284 }
1285 return RET_OK;
1286 }
1287
StubAddInputHandler(MessageParcel & data,MessageParcel & reply)1288 int32_t MultimodalInputConnectStub::StubAddInputHandler(MessageParcel& data, MessageParcel& reply)
1289 {
1290 CALL_DEBUG_ENTER;
1291 int32_t handlerType = 0;
1292 READINT32(data, handlerType, IPC_PROXY_DEAD_OBJECT_ERR);
1293 if (!PER_HELPER->VerifySystemApp()) {
1294 if (handlerType == InputHandlerType::MONITOR) {
1295 #ifdef PLAYER_FRAMEWORK_EXISTS
1296 int32_t pid = GetCallingPid();
1297 bool ret = InputScreenCaptureAgent::GetInstance().IsScreenCaptureWorking(pid);
1298 if (!ret) {
1299 MMI_HILOGE("Calling pid is:%{public}d", pid);
1300 return ERROR_NO_PERMISSION;
1301 }
1302 #else
1303 return ERROR_NOT_SYSAPI;
1304 #endif
1305 } else if (handlerType != InputHandlerType::INTERCEPTOR) {
1306 MMI_HILOGE("Verify system APP failed");
1307 return ERROR_NOT_SYSAPI;
1308 }
1309 }
1310
1311 if (!IsRunning()) {
1312 MMI_HILOGE("Service is not running");
1313 return MMISERVICE_NOT_RUNNING;
1314 }
1315 if ((handlerType == InputHandlerType::INTERCEPTOR) && (!PER_HELPER->CheckInterceptor())) {
1316 MMI_HILOGE("Interceptor permission check failed");
1317 return ERROR_NO_PERMISSION;
1318 }
1319 if ((handlerType == InputHandlerType::MONITOR) && (!PER_HELPER->CheckMonitor())) {
1320 MMI_HILOGE("Monitor permission check failed");
1321 return ERROR_NO_PERMISSION;
1322 }
1323 ParseData parseData;
1324 if (RET_ERR == ParseAddInputHandlerData(data, parseData)) {
1325 return RET_ERR;
1326 }
1327 int32_t ret = AddInputHandler(static_cast<InputHandlerType>(handlerType), parseData.eventType, parseData.priority,
1328 parseData.deviceTags, parseData.actionsType);
1329 if (ret != RET_OK) {
1330 MMI_HILOGE("Call AddInputHandler failed ret:%{public}d", ret);
1331 return ret;
1332 }
1333 return RET_OK;
1334 }
1335
StubAddPreInputHandler(MessageParcel & data,MessageParcel & reply)1336 int32_t MultimodalInputConnectStub::StubAddPreInputHandler(MessageParcel& data, MessageParcel& reply)
1337 {
1338 CALL_DEBUG_ENTER;
1339 if (!PER_HELPER->VerifySystemApp()) {
1340 return ERROR_NOT_SYSAPI;
1341 }
1342
1343 if (!IsRunning()) {
1344 MMI_HILOGE("Service is not running");
1345 return MMISERVICE_NOT_RUNNING;
1346 }
1347
1348 if (!PER_HELPER->CheckMonitor()) {
1349 MMI_HILOGE("Monitor permission check failed");
1350 return ERROR_NO_PERMISSION;
1351 }
1352 int32_t handlerId = -1;
1353 READINT32(data, handlerId, IPC_PROXY_DEAD_OBJECT_ERR);
1354 int32_t eventType = 0;
1355 READINT32(data, eventType, IPC_PROXY_DEAD_OBJECT_ERR);
1356 std::vector<int32_t> keys;
1357 int32_t keysLen = 0;
1358 int32_t key = 0;
1359 READINT32(data, keysLen, IPC_PROXY_DEAD_OBJECT_ERR);
1360 if (keysLen <= 0 || keysLen > KEY_MAX_LIST_SIZE) {
1361 MMI_HILOGE("Invalid keysLen:%{public}d", keysLen);
1362 return RET_ERR;
1363 }
1364 for (int32_t i = 0; i < keysLen; ++i) {
1365 READINT32(data, key, IPC_PROXY_DEAD_OBJECT_ERR);
1366 keys.push_back(key);
1367 }
1368
1369 int32_t ret = AddPreInputHandler(handlerId, eventType, keys);
1370 if (ret != RET_OK) {
1371 MMI_HILOGE("Call AddPreInputHandler failed ret:%{public}d", ret);
1372 return ret;
1373 }
1374 return RET_OK;
1375 }
1376
StubRemovePreInputHandler(MessageParcel & data,MessageParcel & reply)1377 int32_t MultimodalInputConnectStub::StubRemovePreInputHandler(MessageParcel& data, MessageParcel& reply)
1378 {
1379 CALL_DEBUG_ENTER;
1380 if (!PER_HELPER->VerifySystemApp()) {
1381 return ERROR_NOT_SYSAPI;
1382 }
1383
1384 if (!IsRunning()) {
1385 MMI_HILOGE("Service is not running");
1386 return MMISERVICE_NOT_RUNNING;
1387 }
1388 if (!PER_HELPER->CheckMonitor()) {
1389 MMI_HILOGE("Monitor permission check failed");
1390 return ERROR_NO_PERMISSION;
1391 }
1392 int32_t handlerId = -1;
1393 READINT32(data, handlerId, IPC_PROXY_DEAD_OBJECT_ERR);
1394 int32_t ret = RemovePreInputHandler(handlerId);
1395 if (ret != RET_OK) {
1396 MMI_HILOGE("Call RemovePreInputHandler failed ret:%{public}d", ret);
1397 return ret;
1398 }
1399 return RET_OK;
1400 }
1401
StubRemoveInputHandler(MessageParcel & data,MessageParcel & reply)1402 int32_t MultimodalInputConnectStub::StubRemoveInputHandler(MessageParcel& data, MessageParcel& reply)
1403 {
1404 CALL_DEBUG_ENTER;
1405 int32_t handlerType = 0;
1406 READINT32(data, handlerType, IPC_PROXY_DEAD_OBJECT_ERR);
1407 if (!PER_HELPER->VerifySystemApp()) {
1408 if (handlerType != InputHandlerType::MONITOR && handlerType != InputHandlerType::INTERCEPTOR) {
1409 MMI_HILOGE("Verify system APP failed");
1410 return ERROR_NOT_SYSAPI;
1411 }
1412 }
1413
1414 if (!IsRunning()) {
1415 MMI_HILOGE("Service is not running");
1416 return MMISERVICE_NOT_RUNNING;
1417 }
1418 if ((handlerType == InputHandlerType::INTERCEPTOR) && (!PER_HELPER->CheckInterceptor())) {
1419 MMI_HILOGE("Interceptor permission check failed");
1420 return ERROR_NO_PERMISSION;
1421 }
1422 if ((handlerType == InputHandlerType::MONITOR) && (!PER_HELPER->CheckMonitor())) {
1423 MMI_HILOGE("Monitor permission check failed");
1424 return ERROR_NO_PERMISSION;
1425 }
1426 ParseData parseData;
1427 if (RET_ERR == ParseAddInputHandlerData(data, parseData)) {
1428 return RET_ERR;
1429 }
1430 int32_t ret = RemoveInputHandler(static_cast<InputHandlerType>(handlerType), parseData.eventType,
1431 parseData.priority, parseData.deviceTags, parseData.actionsType);
1432 if (ret != RET_OK) {
1433 MMI_HILOGE("Call RemoveInputHandler failed ret:%{public}d", ret);
1434 return ret;
1435 }
1436 return RET_OK;
1437 }
1438
StubRemoveGestureMonitor(MessageParcel & data,MessageParcel & reply)1439 int32_t MultimodalInputConnectStub::StubRemoveGestureMonitor(MessageParcel& data, MessageParcel& reply)
1440 {
1441 return HandleGestureMonitor(MultimodalinputConnectInterfaceCode::REMOVE_GESTURE_MONITOR, data, reply);
1442 }
1443
StubAddGestureMonitor(MessageParcel & data,MessageParcel & reply)1444 int32_t MultimodalInputConnectStub::StubAddGestureMonitor(MessageParcel& data, MessageParcel& reply)
1445 {
1446 return HandleGestureMonitor(MultimodalinputConnectInterfaceCode::ADD_GESTURE_MONITOR, data, reply);
1447 }
1448
HandleGestureMonitor(MultimodalinputConnectInterfaceCode code,MessageParcel & data,MessageParcel & reply)1449 int32_t MultimodalInputConnectStub::HandleGestureMonitor(
1450 MultimodalinputConnectInterfaceCode code, MessageParcel& data, MessageParcel& reply)
1451 {
1452 if (!PER_HELPER->VerifySystemApp()) {
1453 MMI_HILOGE("Verify system APP failed");
1454 return ERROR_NOT_SYSAPI;
1455 }
1456 if (!IsRunning()) {
1457 MMI_HILOGE("Service is not running");
1458 return MMISERVICE_NOT_RUNNING;
1459 }
1460 if (!PER_HELPER->CheckMonitor()) {
1461 MMI_HILOGE("Monitor permission check failed");
1462 return ERROR_NO_PERMISSION;
1463 }
1464 int32_t handlerType = 0;
1465 READINT32(data, handlerType, IPC_PROXY_DEAD_OBJECT_ERR);
1466 if (handlerType != InputHandlerType::MONITOR) {
1467 MMI_HILOGE("Illegal type:%{public}d", handlerType);
1468 return RET_ERR;
1469 }
1470 uint32_t eventType = 0;
1471 READUINT32(data, eventType, IPC_PROXY_DEAD_OBJECT_ERR);
1472 uint32_t gestureType = 0u;
1473 READUINT32(data, gestureType, IPC_PROXY_DEAD_OBJECT_ERR);
1474 int32_t fingers = 0;
1475 READINT32(data, fingers, IPC_PROXY_DEAD_OBJECT_ERR);
1476 int32_t ret = RET_OK;
1477 if (MultimodalinputConnectInterfaceCode::ADD_GESTURE_MONITOR == code) {
1478 ret = AddGestureMonitor(static_cast<InputHandlerType>(handlerType),
1479 eventType, static_cast<TouchGestureType>(gestureType), fingers);
1480 } else {
1481 ret = RemoveGestureMonitor(static_cast<InputHandlerType>(handlerType),
1482 eventType, static_cast<TouchGestureType>(gestureType), fingers);
1483 }
1484 if (ret != RET_OK) {
1485 MMI_HILOGE("Call AddGestureMonitor/RemoveGestureMonitor failed ret:%{public}d", ret);
1486 }
1487 return ret;
1488 }
1489
StubMarkEventConsumed(MessageParcel & data,MessageParcel & reply)1490 int32_t MultimodalInputConnectStub::StubMarkEventConsumed(MessageParcel& data, MessageParcel& reply)
1491 {
1492 CALL_DEBUG_ENTER;
1493 if (!PER_HELPER->CheckMonitor()) {
1494 MMI_HILOGE("Permission check failed");
1495 return ERROR_NO_PERMISSION;
1496 }
1497
1498 if (!IsRunning()) {
1499 MMI_HILOGE("Service is not running");
1500 return MMISERVICE_NOT_RUNNING;
1501 }
1502 int32_t eventId = 0;
1503 READINT32(data, eventId, IPC_PROXY_DEAD_OBJECT_ERR);
1504 int32_t ret = MarkEventConsumed(eventId);
1505 if (ret != RET_OK) {
1506 MMI_HILOGE("Call MarkEventConsumed failed ret:%{public}d", ret);
1507 return ret;
1508 }
1509 return RET_OK;
1510 }
1511
StubSubscribeKeyEvent(MessageParcel & data,MessageParcel & reply)1512 int32_t MultimodalInputConnectStub::StubSubscribeKeyEvent(MessageParcel& data, MessageParcel& reply)
1513 {
1514 CALL_DEBUG_ENTER;
1515 if (!IsRunning()) {
1516 MMI_HILOGE("Service is not running");
1517 return MMISERVICE_NOT_RUNNING;
1518 }
1519 if (!PER_HELPER->VerifySystemApp()) {
1520 MMI_HILOGE("Verify system APP failed");
1521 return ERROR_NOT_SYSAPI;
1522 }
1523 int32_t subscribeId = 0;
1524 READINT32(data, subscribeId, IPC_PROXY_DEAD_OBJECT_ERR);
1525
1526 auto keyOption = std::make_shared<KeyOption>();
1527 if (!keyOption->ReadFromParcel(data)) {
1528 MMI_HILOGE("Read keyOption failed");
1529 return IPC_PROXY_DEAD_OBJECT_ERR;
1530 }
1531 int32_t ret = SubscribeKeyEvent(subscribeId, keyOption);
1532 if (ret != RET_OK) {
1533 MMI_HILOGE("SubscribeKeyEvent failed, ret:%{public}d", ret);
1534 return ret;
1535 }
1536 return RET_OK;
1537 }
1538
StubUnsubscribeKeyEvent(MessageParcel & data,MessageParcel & reply)1539 int32_t MultimodalInputConnectStub::StubUnsubscribeKeyEvent(MessageParcel& data, MessageParcel& reply)
1540 {
1541 CALL_DEBUG_ENTER;
1542 if (!IsRunning()) {
1543 MMI_HILOGE("Service is not running");
1544 return MMISERVICE_NOT_RUNNING;
1545 }
1546 if (!PER_HELPER->VerifySystemApp()) {
1547 MMI_HILOGE("Verify system APP failed");
1548 return ERROR_NOT_SYSAPI;
1549 }
1550
1551 int32_t subscribeId = 0;
1552 READINT32(data, subscribeId, IPC_PROXY_DEAD_OBJECT_ERR);
1553 if (subscribeId < 0) {
1554 MMI_HILOGE("Invalid subscribe");
1555 return RET_ERR;
1556 }
1557 int32_t ret = UnsubscribeKeyEvent(subscribeId);
1558 if (ret != RET_OK) {
1559 MMI_HILOGE("UnsubscribeKeyEvent failed, ret:%{public}d", ret);
1560 return ret;
1561 }
1562 return RET_OK;
1563 }
1564
StubSubscribeHotkey(MessageParcel & data,MessageParcel & reply)1565 int32_t MultimodalInputConnectStub::StubSubscribeHotkey(MessageParcel& data, MessageParcel& reply)
1566 {
1567 CALL_DEBUG_ENTER;
1568 if (!IsRunning()) {
1569 MMI_HILOGE("Service is not running");
1570 return MMISERVICE_NOT_RUNNING;
1571 }
1572
1573 int32_t subscribeId = 0;
1574 READINT32(data, subscribeId, IPC_PROXY_DEAD_OBJECT_ERR);
1575 if (subscribeId < 0) {
1576 MMI_HILOGE("Invalid subscribe");
1577 return RET_ERR;
1578 }
1579 auto keyOption = std::make_shared<KeyOption>();
1580 if (!keyOption->ReadFromParcel(data)) {
1581 MMI_HILOGE("Read keyOption failed");
1582 return IPC_PROXY_DEAD_OBJECT_ERR;
1583 }
1584 int32_t ret = SubscribeHotkey(subscribeId, keyOption);
1585 if (ret != RET_OK) {
1586 MMI_HILOGE("SubscribeHotkey failed, ret:%{public}d", ret);
1587 }
1588 return ret;
1589 }
1590
StubUnsubscribeHotkey(MessageParcel & data,MessageParcel & reply)1591 int32_t MultimodalInputConnectStub::StubUnsubscribeHotkey(MessageParcel& data, MessageParcel& reply)
1592 {
1593 CALL_DEBUG_ENTER;
1594 if (!IsRunning()) {
1595 MMI_HILOGE("Service is not running");
1596 return MMISERVICE_NOT_RUNNING;
1597 }
1598
1599 int32_t subscribeId = 0;
1600 READINT32(data, subscribeId, IPC_PROXY_DEAD_OBJECT_ERR);
1601 if (subscribeId < 0) {
1602 MMI_HILOGE("Invalid subscribe");
1603 return RET_ERR;
1604 }
1605 int32_t ret = UnsubscribeHotkey(subscribeId);
1606 if (ret != RET_OK) {
1607 MMI_HILOGE("UnsubscribeHotkey failed, ret:%{public}d", ret);
1608 }
1609 return ret;
1610 }
1611
StubSubscribeKeyMonitor(MessageParcel & data,MessageParcel & reply)1612 int32_t MultimodalInputConnectStub::StubSubscribeKeyMonitor(MessageParcel& data, MessageParcel& reply)
1613 {
1614 CALL_DEBUG_ENTER;
1615 if (!IsRunning()) {
1616 MMI_HILOGE("Service is not running");
1617 return MMISERVICE_NOT_RUNNING;
1618 }
1619 KeyMonitorOption keyOption {};
1620
1621 if (!keyOption.Unmarshalling(data)) {
1622 MMI_HILOGE("Read KeyMonitorOption failed");
1623 return IPC_PROXY_DEAD_OBJECT_ERR;
1624 }
1625 auto ret = SubscribeKeyMonitor(keyOption);
1626 if (ret != RET_OK) {
1627 MMI_HILOGE("SubscribeKeyMonitor failed, ret:%{public}d", ret);
1628 }
1629 return ret;
1630 }
1631
StubUnsubscribeKeyMonitor(MessageParcel & data,MessageParcel & reply)1632 int32_t MultimodalInputConnectStub::StubUnsubscribeKeyMonitor(MessageParcel& data, MessageParcel& reply)
1633 {
1634 CALL_DEBUG_ENTER;
1635 if (!IsRunning()) {
1636 MMI_HILOGE("Service is not running");
1637 return MMISERVICE_NOT_RUNNING;
1638 }
1639 KeyMonitorOption keyOption {};
1640
1641 if (!keyOption.Unmarshalling(data)) {
1642 MMI_HILOGE("Read KeyMonitorOption failed");
1643 return IPC_PROXY_DEAD_OBJECT_ERR;
1644 }
1645 auto ret = UnsubscribeKeyMonitor(keyOption);
1646 if (ret != RET_OK) {
1647 MMI_HILOGE("UnsubscribeKeyMonitor failed, ret:%{public}d", ret);
1648 }
1649 return ret;
1650 }
1651
StubSubscribeSwitchEvent(MessageParcel & data,MessageParcel & reply)1652 int32_t MultimodalInputConnectStub::StubSubscribeSwitchEvent(MessageParcel& data, MessageParcel& reply)
1653 {
1654 CALL_DEBUG_ENTER;
1655 if (!PER_HELPER->VerifySystemApp()) {
1656 MMI_HILOGE("Verify system APP failed");
1657 return ERROR_NOT_SYSAPI;
1658 }
1659
1660 if (!IsRunning()) {
1661 MMI_HILOGE("Service is not running");
1662 return MMISERVICE_NOT_RUNNING;
1663 }
1664
1665 int32_t subscribeId = 0;
1666 int32_t switchType = 0;
1667 READINT32(data, subscribeId, IPC_PROXY_DEAD_OBJECT_ERR);
1668 READINT32(data, switchType, IPC_PROXY_DEAD_OBJECT_ERR);
1669
1670 int32_t ret = SubscribeSwitchEvent(subscribeId, switchType);
1671 if (ret != RET_OK) {
1672 MMI_HILOGE("SubscribeSwitchEvent failed, ret:%{public}d", ret);
1673 }
1674 return ret;
1675 }
1676
StubUnsubscribeSwitchEvent(MessageParcel & data,MessageParcel & reply)1677 int32_t MultimodalInputConnectStub::StubUnsubscribeSwitchEvent(MessageParcel& data, MessageParcel& reply)
1678 {
1679 CALL_DEBUG_ENTER;
1680 if (!PER_HELPER->VerifySystemApp()) {
1681 MMI_HILOGE("Verify system APP failed");
1682 return ERROR_NOT_SYSAPI;
1683 }
1684
1685 if (!IsRunning()) {
1686 MMI_HILOGE("Service is not running");
1687 return MMISERVICE_NOT_RUNNING;
1688 }
1689
1690 int32_t subscribeId = 0;
1691 READINT32(data, subscribeId, IPC_PROXY_DEAD_OBJECT_ERR);
1692 if (subscribeId < 0) {
1693 MMI_HILOGE("Invalid subscribeId");
1694 return RET_ERR;
1695 }
1696 int32_t ret = UnsubscribeSwitchEvent(subscribeId);
1697 if (ret != RET_OK) {
1698 MMI_HILOGE("UnsubscribeSwitchEvent failed, ret:%{public}d", ret);
1699 }
1700 return ret;
1701 }
1702
1703
StubSubscribeTabletProximity(MessageParcel & data,MessageParcel & reply)1704 int32_t MultimodalInputConnectStub::StubSubscribeTabletProximity(MessageParcel& data, MessageParcel& reply)
1705 {
1706 CALL_DEBUG_ENTER;
1707 if (!PER_HELPER->VerifySystemApp()) {
1708 MMI_HILOGE("Verify system APP failed");
1709 return ERROR_NOT_SYSAPI;
1710 }
1711
1712 if (!IsRunning()) {
1713 MMI_HILOGE("Service is not running");
1714 return MMISERVICE_NOT_RUNNING;
1715 }
1716
1717 int32_t subscribeId = 0;
1718 READINT32(data, subscribeId, IPC_PROXY_DEAD_OBJECT_ERR);
1719
1720 int32_t ret = SubscribeTabletProximity(subscribeId);
1721 if (ret != RET_OK) {
1722 MMI_HILOGE("SubscribeTabletProximity failed, ret:%{public}d", ret);
1723 }
1724 return ret;
1725 }
1726
StubUnSubscribetabletProximity(MessageParcel & data,MessageParcel & reply)1727 int32_t MultimodalInputConnectStub::StubUnSubscribetabletProximity(MessageParcel& data, MessageParcel& reply)
1728 {
1729 CALL_DEBUG_ENTER;
1730 if (!PER_HELPER->VerifySystemApp()) {
1731 MMI_HILOGE("Verify system APP failed");
1732 return ERROR_NOT_SYSAPI;
1733 }
1734
1735 if (!IsRunning()) {
1736 MMI_HILOGE("Service is not running");
1737 return MMISERVICE_NOT_RUNNING;
1738 }
1739
1740 int32_t subscribeId = 0;
1741 READINT32(data, subscribeId, IPC_PROXY_DEAD_OBJECT_ERR);
1742 if (subscribeId < 0) {
1743 MMI_HILOGE("Invalid subscribeId");
1744 return RET_ERR;
1745 }
1746 int32_t ret = UnsubscribetabletProximity(subscribeId);
1747 if (ret != RET_OK) {
1748 MMI_HILOGE("UnsubscribeTabletProximity failed, ret:%{public}d", ret);
1749 }
1750 return ret;
1751 }
1752
StubSubscribeLongPressEvent(MessageParcel & data,MessageParcel & reply)1753 int32_t MultimodalInputConnectStub::StubSubscribeLongPressEvent(MessageParcel& data, MessageParcel& reply)
1754 {
1755 CALL_DEBUG_ENTER;
1756 if (!PER_HELPER->VerifySystemApp()) {
1757 MMI_HILOGE("Verify system APP failed");
1758 return ERROR_NOT_SYSAPI;
1759 }
1760
1761 if (!IsRunning()) {
1762 MMI_HILOGE("Service is not running");
1763 return MMISERVICE_NOT_RUNNING;
1764 }
1765
1766 int32_t subscribeId = 0;
1767 int32_t fingerCount = 0;
1768 int32_t duration = 0;
1769 READINT32(data, subscribeId, IPC_PROXY_DEAD_OBJECT_ERR);
1770 READINT32(data, fingerCount, IPC_PROXY_DEAD_OBJECT_ERR);
1771 READINT32(data, duration, IPC_PROXY_DEAD_OBJECT_ERR);
1772 LongPressRequest longPressRequest = {
1773 .fingerCount = fingerCount,
1774 .duration = duration,
1775 };
1776 int32_t ret = SubscribeLongPressEvent(subscribeId, longPressRequest);
1777 if (ret != RET_OK) {
1778 MMI_HILOGE("SubscribeLongPressEvent failed, ret:%{public}d", ret);
1779 }
1780 return ret;
1781 }
1782
StubUnsubscribeLongPressEvent(MessageParcel & data,MessageParcel & reply)1783 int32_t MultimodalInputConnectStub::StubUnsubscribeLongPressEvent(MessageParcel& data, MessageParcel& reply)
1784 {
1785 CALL_DEBUG_ENTER;
1786 if (!PER_HELPER->VerifySystemApp()) {
1787 MMI_HILOGE("Verify system APP failed");
1788 return ERROR_NOT_SYSAPI;
1789 }
1790
1791 if (!IsRunning()) {
1792 MMI_HILOGE("Service is not running");
1793 return MMISERVICE_NOT_RUNNING;
1794 }
1795
1796 int32_t subscribeId = 0;
1797 READINT32(data, subscribeId, IPC_PROXY_DEAD_OBJECT_ERR);
1798
1799 int32_t ret = UnsubscribeLongPressEvent(subscribeId);
1800 if (ret != RET_OK) {
1801 MMI_HILOGE("UnsubscribeLongPressEvent failed, ret:%{public}d", ret);
1802 }
1803 return ret;
1804 }
1805
StubMoveMouseEvent(MessageParcel & data,MessageParcel & reply)1806 int32_t MultimodalInputConnectStub::StubMoveMouseEvent(MessageParcel& data, MessageParcel& reply)
1807 {
1808 CALL_DEBUG_ENTER;
1809 if (!PER_HELPER->VerifySystemApp()) {
1810 MMI_HILOGE("Verify system APP failed");
1811 return ERROR_NOT_SYSAPI;
1812 }
1813 if (!PER_HELPER->CheckMouseCursor()) {
1814 MMI_HILOGE("Mouse cursor permission check failed");
1815 return ERROR_NO_PERMISSION;
1816 }
1817 if (!IsRunning()) {
1818 MMI_HILOGE("Service is not running");
1819 return MMISERVICE_NOT_RUNNING;
1820 }
1821 int32_t offsetX = 0;
1822 READINT32(data, offsetX, IPC_PROXY_DEAD_OBJECT_ERR);
1823 int32_t offsetY = 0;
1824 READINT32(data, offsetY, IPC_PROXY_DEAD_OBJECT_ERR);
1825
1826 int32_t ret = MoveMouseEvent(offsetX, offsetY);
1827 if (ret != RET_OK) {
1828 MMI_HILOGE("MoveMouseEvent failed, ret:%{public}d", ret);
1829 }
1830 return ret;
1831 }
1832
StubInjectKeyEvent(MessageParcel & data,MessageParcel & reply)1833 int32_t MultimodalInputConnectStub::StubInjectKeyEvent(MessageParcel& data, MessageParcel& reply)
1834 {
1835 CALL_DEBUG_ENTER;
1836 if (!IsRunning()) {
1837 MMI_HILOGE("Service is not running");
1838 return MMISERVICE_NOT_RUNNING;
1839 }
1840 auto event = KeyEvent::Create();
1841 CHKPR(event, ERROR_NULL_POINTER);
1842 if (!event->ReadFromParcel(data)) {
1843 MMI_HILOGE("Read Key Event failed");
1844 return IPC_PROXY_DEAD_OBJECT_ERR;
1845 }
1846 LogTracer lt(event->GetId(), event->GetEventType(), event->GetKeyAction());
1847 bool isNativeInject { false };
1848 READBOOL(data, isNativeInject, IPC_PROXY_DEAD_OBJECT_ERR);
1849 if (!isNativeInject && !PER_HELPER->VerifySystemApp()) {
1850 MMI_HILOGE("Verify system APP failed");
1851 return ERROR_NOT_SYSAPI;
1852 }
1853 EndLogTraceId(event->GetId());
1854 event->UpdateId();
1855 LogTracer lt1(event->GetId(), event->GetEventType(), event->GetKeyAction());
1856 int32_t ret = InjectKeyEvent(event, isNativeInject);
1857 if (ret != RET_OK) {
1858 MMI_HILOGE("InjectKeyEvent failed, ret:%{public}d", ret);
1859 }
1860 return ret;
1861 }
1862
StubInjectPointerEvent(MessageParcel & data,MessageParcel & reply)1863 int32_t MultimodalInputConnectStub::StubInjectPointerEvent(MessageParcel& data, MessageParcel& reply)
1864 {
1865 CALL_DEBUG_ENTER;
1866 if (!IsRunning()) {
1867 MMI_HILOGE("Service is not running");
1868 return MMISERVICE_NOT_RUNNING;
1869 }
1870 auto pointerEvent = PointerEvent::Create();
1871 CHKPR(pointerEvent, ERROR_NULL_POINTER);
1872 if (!pointerEvent->ReadFromParcel(data)) {
1873 MMI_HILOGE("Read Pointer Event failed");
1874 return IPC_PROXY_DEAD_OBJECT_ERR;
1875 }
1876 bool isNativeInject { false };
1877 READBOOL(data, isNativeInject, IPC_PROXY_DEAD_OBJECT_ERR);
1878 if (!isNativeInject && !PER_HELPER->VerifySystemApp()) {
1879 MMI_HILOGE("Verify system APP failed");
1880 return ERROR_NOT_SYSAPI;
1881 }
1882 int32_t ret = InjectPointerEvent(pointerEvent, isNativeInject);
1883 if (ret != RET_OK) {
1884 MMI_HILOGE("Call InjectPointerEvent failed ret:%{public}d", ret);
1885 }
1886 return ret;
1887 }
1888
StubInjectTouchPadEvent(MessageParcel & data,MessageParcel & reply)1889 int32_t MultimodalInputConnectStub::StubInjectTouchPadEvent(MessageParcel& data, MessageParcel& reply)
1890 {
1891 CALL_DEBUG_ENTER;
1892 if (!IsRunning()) {
1893 MMI_HILOGE("Service is not running");
1894 return MMISERVICE_NOT_RUNNING;
1895 }
1896 auto pointerEvent = PointerEvent::Create();
1897 CHKPR(pointerEvent, ERROR_NULL_POINTER);
1898 if (!pointerEvent->ReadFromParcel(data)) {
1899 MMI_HILOGE("Read Pointer Event failed");
1900 return IPC_PROXY_DEAD_OBJECT_ERR;
1901 }
1902 double ppi = 0.0;
1903 double size = 0.0;
1904 int32_t speed = 0;
1905 bool isNativeInject { false };
1906 READDOUBLE(data, ppi, IPC_PROXY_DEAD_OBJECT_ERR);
1907 READDOUBLE(data, size, IPC_PROXY_DEAD_OBJECT_ERR);
1908 READINT32(data, speed, IPC_PROXY_DEAD_OBJECT_ERR);
1909 READBOOL(data, isNativeInject, IPC_PROXY_DEAD_OBJECT_ERR);
1910 TouchpadCDG touchpadCDG = {
1911 .ppi = ppi,
1912 .size = size,
1913 .speed = speed,
1914 };
1915 if (!PER_HELPER->VerifySystemApp()) {
1916 MMI_HILOGE("Verify system APP failed");
1917 return ERROR_NOT_SYSAPI;
1918 }
1919 int32_t ret = InjectTouchPadEvent(pointerEvent, touchpadCDG, isNativeInject);
1920 if (ret != RET_OK) {
1921 MMI_HILOGE("Call InjectTouchPadEvent failed ret:%{public}d", ret);
1922 }
1923 return ret;
1924 }
1925
StubSetAnrListener(MessageParcel & data,MessageParcel & reply)1926 int32_t MultimodalInputConnectStub::StubSetAnrListener(MessageParcel& data, MessageParcel& reply)
1927 {
1928 CALL_DEBUG_ENTER;
1929 if (!PER_HELPER->VerifySystemApp()) {
1930 MMI_HILOGE("Verify system APP failed");
1931 return ERROR_NOT_SYSAPI;
1932 }
1933 if (!IsRunning()) {
1934 MMI_HILOGE("Service is not running");
1935 return MMISERVICE_NOT_RUNNING;
1936 }
1937 int32_t ret = SetAnrObserver();
1938 if (ret != RET_OK) {
1939 MMI_HILOGE("Call SetAnrObserver failed, ret:%{public}d", ret);
1940 }
1941 return ret;
1942 }
1943
1944
StubGetDisplayBindInfo(MessageParcel & data,MessageParcel & reply)1945 int32_t MultimodalInputConnectStub::StubGetDisplayBindInfo(MessageParcel& data, MessageParcel& reply)
1946 {
1947 CALL_DEBUG_ENTER;
1948 if (!PER_HELPER->VerifySystemApp()) {
1949 MMI_HILOGE("Verify system APP failed");
1950 return ERROR_NOT_SYSAPI;
1951 }
1952 if (!IsRunning()) {
1953 MMI_HILOGE("Service is not running");
1954 return MMISERVICE_NOT_RUNNING;
1955 }
1956 DisplayBindInfos infos;
1957 int32_t ret = GetDisplayBindInfo(infos);
1958 if (ret != RET_OK) {
1959 MMI_HILOGE("Call GetDisplayBindInfo failed, ret:%{public}d", ret);
1960 return ret;
1961 }
1962 int32_t size = static_cast<int32_t>(infos.size());
1963 WRITEINT32(reply, size, ERR_INVALID_VALUE);
1964 infos.reserve(size);
1965 for (const auto &info : infos) {
1966 WRITEINT32(reply, info.inputDeviceId, ERR_INVALID_VALUE);
1967 WRITESTRING(reply, info.inputDeviceName, ERR_INVALID_VALUE);
1968 WRITEINT32(reply, info.displayId, ERR_INVALID_VALUE);
1969 WRITESTRING(reply, info.displayName, ERR_INVALID_VALUE);
1970 }
1971 return RET_OK;
1972 }
1973
StubGetAllMmiSubscribedEvents(MessageParcel & data,MessageParcel & reply)1974 int32_t MultimodalInputConnectStub::StubGetAllMmiSubscribedEvents(MessageParcel& data, MessageParcel& reply)
1975 {
1976 CALL_DEBUG_ENTER;
1977 if (!PER_HELPER->VerifySystemApp()) {
1978 MMI_HILOGE("Verify system APP failed");
1979 return ERROR_NOT_SYSAPI;
1980 }
1981 if (!IsRunning()) {
1982 MMI_HILOGE("Service is not running");
1983 return MMISERVICE_NOT_RUNNING;
1984 }
1985 std::map<std::tuple<int32_t, int32_t, std::string>, int32_t> datas;
1986 int32_t ret = GetAllMmiSubscribedEvents(datas);
1987 if (ret != RET_OK) {
1988 MMI_HILOGE("Call GetDisplayBindInfo failed, ret:%{public}d", ret);
1989 return ret;
1990 }
1991 int32_t size = static_cast<int32_t>(datas.size());
1992 WRITEINT32(reply, size, ERR_INVALID_VALUE);
1993 for (const auto &data : datas) {
1994 WRITEINT32(reply, std::get<TUPLE_PID>(data.first), ERR_INVALID_VALUE);
1995 WRITEINT32(reply, std::get<TUPLE_UID>(data.first), ERR_INVALID_VALUE);
1996 WRITESTRING(reply, std::get<TUPLE_NAME>(data.first), ERR_INVALID_VALUE);
1997 WRITEINT32(reply, data.second, ERR_INVALID_VALUE);
1998 }
1999 return RET_OK;
2000 }
2001
StubSetDisplayBind(MessageParcel & data,MessageParcel & reply)2002 int32_t MultimodalInputConnectStub::StubSetDisplayBind(MessageParcel& data, MessageParcel& reply)
2003 {
2004 CALL_DEBUG_ENTER;
2005 if (!PER_HELPER->VerifySystemApp()) {
2006 MMI_HILOGE("Verify system APP failed");
2007 return ERROR_NOT_SYSAPI;
2008 }
2009 if (!IsRunning()) {
2010 MMI_HILOGE("Service is not running");
2011 return MMISERVICE_NOT_RUNNING;
2012 }
2013 int32_t inputDeviceId = -1;
2014 READINT32(data, inputDeviceId, ERR_INVALID_VALUE);
2015 int32_t displayId = -1;
2016 READINT32(data, displayId, ERR_INVALID_VALUE);
2017 std::string msg;
2018 int32_t ret = SetDisplayBind(inputDeviceId, displayId, msg);
2019 if (ret != RET_OK) {
2020 MMI_HILOGE("Call SetDisplayBind failed, ret:%{public}d", ret);
2021 }
2022 WRITESTRING(reply, msg, ERR_INVALID_VALUE);
2023 return ret;
2024 }
2025
StubGetFunctionKeyState(MessageParcel & data,MessageParcel & reply)2026 int32_t MultimodalInputConnectStub::StubGetFunctionKeyState(MessageParcel &data, MessageParcel &reply)
2027 {
2028 CALL_DEBUG_ENTER;
2029 if (!IsRunning()) {
2030 MMI_HILOGE("Service is not running");
2031 return MMISERVICE_NOT_RUNNING;
2032 }
2033
2034 int32_t funcKey { 0 };
2035 bool state { false };
2036 READINT32(data, funcKey, IPC_PROXY_DEAD_OBJECT_ERR);
2037 int32_t ret = GetFunctionKeyState(funcKey, state);
2038 if (ret != RET_OK) {
2039 MMI_HILOGE("Call GetKeyboardEnableState failed ret:%{public}d", ret);
2040 return ret;
2041 }
2042
2043 WRITEBOOL(reply, state, IPC_PROXY_DEAD_OBJECT_ERR);
2044 return RET_OK;
2045 }
2046
StubSetFunctionKeyState(MessageParcel & data,MessageParcel & reply)2047 int32_t MultimodalInputConnectStub::StubSetFunctionKeyState(MessageParcel &data, MessageParcel &reply)
2048 {
2049 CALL_DEBUG_ENTER;
2050 if (!PER_HELPER->CheckFunctionKeyEnabled()) {
2051 MMI_HILOGE("Set function key state permission check failed");
2052 return ERROR_KEYBOARD_NO_PERMISSION;
2053 }
2054 if (!IsRunning()) {
2055 MMI_HILOGE("Service is not running");
2056 return MMISERVICE_NOT_RUNNING;
2057 }
2058
2059 int32_t funcKey { 0 };
2060 bool enable { false };
2061 READINT32(data, funcKey, IPC_PROXY_DEAD_OBJECT_ERR);
2062 READBOOL(data, enable, IPC_PROXY_DEAD_OBJECT_ERR);
2063 if (funcKey != KeyEvent::NUM_LOCK_FUNCTION_KEY && funcKey != KeyEvent::CAPS_LOCK_FUNCTION_KEY &&
2064 funcKey != KeyEvent::SCROLL_LOCK_FUNCTION_KEY) {
2065 MMI_HILOGE("Invalid funcKey:%{public}d", funcKey);
2066 return RET_ERR;
2067 }
2068
2069 int32_t ret = SetFunctionKeyState(funcKey, enable);
2070 if (ret != RET_OK) {
2071 MMI_HILOGE("Call SetFunctionKeyState failed ret:%{public}d", ret);
2072 }
2073 return ret;
2074 }
2075
StubSetPointerLocation(MessageParcel & data,MessageParcel & reply)2076 int32_t MultimodalInputConnectStub::StubSetPointerLocation(MessageParcel &data, MessageParcel &reply)
2077 {
2078 CALL_DEBUG_ENTER;
2079 if (!PER_HELPER->VerifySystemApp()) {
2080 MMI_HILOGE("StubSetPointerLocation Verify system APP failed");
2081 return ERROR_NOT_SYSAPI;
2082 }
2083 if (!PER_HELPER->CheckMouseCursor()) {
2084 MMI_HILOGE("Mouse cursor permission check failed");
2085 return ERROR_NO_PERMISSION;
2086 }
2087 if (!IsRunning()) {
2088 MMI_HILOGE("Service is not running");
2089 return MMISERVICE_NOT_RUNNING;
2090 }
2091
2092 int32_t x = 0;
2093 int32_t y = 0;
2094 int32_t displayId = 0;
2095 READINT32(data, x, IPC_PROXY_DEAD_OBJECT_ERR);
2096 READINT32(data, y, IPC_PROXY_DEAD_OBJECT_ERR);
2097 READINT32(data, displayId, IPC_PROXY_DEAD_OBJECT_ERR);
2098 int32_t ret = SetPointerLocation(x, y, displayId);
2099 if (ret != RET_OK) {
2100 MMI_HILOGE("Call SetFunctionKeyState failed ret:%{public}d", ret);
2101 }
2102 return ret;
2103 }
2104
StubSetMouseCaptureMode(MessageParcel & data,MessageParcel & reply)2105 int32_t MultimodalInputConnectStub::StubSetMouseCaptureMode(MessageParcel& data, MessageParcel& reply)
2106 {
2107 CALL_DEBUG_ENTER;
2108 if (!PER_HELPER->VerifySystemApp()) {
2109 MMI_HILOGE("Verify system APP failed");
2110 return ERROR_NOT_SYSAPI;
2111 }
2112 int32_t windowId = -1;
2113 bool isCaptureMode = false;
2114 READINT32(data, windowId, IPC_PROXY_DEAD_OBJECT_ERR);
2115 READBOOL(data, isCaptureMode, IPC_PROXY_DEAD_OBJECT_ERR);
2116 if (windowId <= 0) {
2117 MMI_HILOGE("Invalid windowId:%{public}d", windowId);
2118 return RET_ERR;
2119 }
2120 int32_t ret = SetMouseCaptureMode(windowId, isCaptureMode);
2121 if (ret != RET_OK) {
2122 MMI_HILOGE("Fail to call SetMouseCaptureMode, ret:%{public}d", ret);
2123 }
2124 return ret;
2125 }
2126
StubGetWindowPid(MessageParcel & data,MessageParcel & reply)2127 int32_t MultimodalInputConnectStub::StubGetWindowPid(MessageParcel& data, MessageParcel& reply)
2128 {
2129 CALL_DEBUG_ENTER;
2130 if (!IsRunning()) {
2131 MMI_HILOGE("Service is not running");
2132 return MMISERVICE_NOT_RUNNING;
2133 }
2134
2135 int32_t windowId = 0;
2136 READINT32(data, windowId, IPC_PROXY_DEAD_OBJECT_ERR);
2137 int32_t ret = GetWindowPid(windowId);
2138 if (ret == RET_ERR) {
2139 MMI_HILOGE("Get window pid failed");
2140 }
2141 WRITEINT32(reply, ret, ERR_INVALID_VALUE);
2142 return RET_OK;
2143 }
2144
StubAppendExtraData(MessageParcel & data,MessageParcel & reply)2145 int32_t MultimodalInputConnectStub::StubAppendExtraData(MessageParcel& data, MessageParcel& reply)
2146 {
2147 CALL_DEBUG_ENTER;
2148 if (!PER_HELPER->VerifySystemApp()) {
2149 MMI_HILOGE("Verify system APP failed");
2150 return ERROR_NOT_SYSAPI;
2151 }
2152 if (!IsRunning()) {
2153 MMI_HILOGE("Service is not running");
2154 return MMISERVICE_NOT_RUNNING;
2155 }
2156 ExtraData extraData;
2157 READBOOL(data, extraData.appended, IPC_PROXY_DEAD_OBJECT_ERR);
2158 int32_t size = 0;
2159 READINT32(data, size, IPC_PROXY_DEAD_OBJECT_ERR);
2160 if (size > ExtraData::MAX_BUFFER_SIZE) {
2161 MMI_HILOGE("Append extra data failed, buffer is oversize:%{public}d", size);
2162 return ERROR_OVER_SIZE_BUFFER;
2163 }
2164 uint8_t buffer = 0;
2165 for (int32_t i = 0; i < size; ++i) {
2166 READUINT8(data, buffer, IPC_PROXY_DEAD_OBJECT_ERR);
2167 extraData.buffer.push_back(buffer);
2168 }
2169 READINT32(data, extraData.toolType, IPC_PROXY_DEAD_OBJECT_ERR);
2170 READINT32(data, extraData.sourceType, IPC_PROXY_DEAD_OBJECT_ERR);
2171 READINT32(data, extraData.pointerId, IPC_PROXY_DEAD_OBJECT_ERR);
2172 READINT32(data, extraData.pullId, IPC_PROXY_DEAD_OBJECT_ERR);
2173 READINT32(data, extraData.eventId, IPC_PROXY_DEAD_OBJECT_ERR);
2174 READBOOL(data, extraData.drawCursor, IPC_PROXY_DEAD_OBJECT_ERR);
2175 if (extraData.sourceType != InputEvent::SOURCE_TYPE_TOUCHSCREEN &&
2176 extraData.sourceType != InputEvent::SOURCE_TYPE_MOUSE) {
2177 MMI_HILOGE("Invalid extraData.sourceType:%{public}d", extraData.sourceType);
2178 return RET_ERR;
2179 }
2180 if (extraData.pointerId < 0 || extraData.pullId < 0) {
2181 MMI_HILOGE("Invalid extraData.pointerId or extraData.pullId or extraData.eventId, pointerId:%{public}d,"
2182 "pullId:%{public}d, eventId:%{public}d", extraData.pointerId, extraData.pullId, extraData.eventId);
2183 return RET_ERR;
2184 }
2185
2186 int32_t ret = AppendExtraData(extraData);
2187 if (ret != RET_OK) {
2188 MMI_HILOGE("Fail to call AppendExtraData, ret:%{public}d", ret);
2189 }
2190 return ret;
2191 }
2192
StubEnableCombineKey(MessageParcel & data,MessageParcel & reply)2193 int32_t MultimodalInputConnectStub::StubEnableCombineKey(MessageParcel& data, MessageParcel& reply)
2194 {
2195 CALL_DEBUG_ENTER;
2196 if (!PER_HELPER->VerifySystemApp()) {
2197 MMI_HILOGE("Verify system APP failed");
2198 return ERROR_NOT_SYSAPI;
2199 }
2200 if (!IsRunning()) {
2201 MMI_HILOGE("Service is not running");
2202 return MMISERVICE_NOT_RUNNING;
2203 }
2204 bool enable;
2205 READBOOL(data, enable, IPC_PROXY_DEAD_OBJECT_ERR);
2206 int32_t ret = EnableCombineKey(enable);
2207 if (ret != RET_OK) {
2208 MMI_HILOGE("Call EnableCombineKey failed, ret:%{public}d", ret);
2209 }
2210 return ret;
2211 }
2212
StubEnableInputDevice(MessageParcel & data,MessageParcel & reply)2213 int32_t MultimodalInputConnectStub::StubEnableInputDevice(MessageParcel& data, MessageParcel& reply)
2214 {
2215 CALL_DEBUG_ENTER;
2216 MMI_HILOGW("EnableInputDevice is not supported yet");
2217 return RET_OK;
2218 }
2219
StubSetKeyDownDuration(MessageParcel & data,MessageParcel & reply)2220 int32_t MultimodalInputConnectStub::StubSetKeyDownDuration(MessageParcel& data, MessageParcel& reply)
2221 {
2222 CALL_DEBUG_ENTER;
2223 if (!PER_HELPER->VerifySystemApp()) {
2224 MMI_HILOGE("Verify system APP failed");
2225 return ERROR_NOT_SYSAPI;
2226 }
2227 if (!IsRunning()) {
2228 MMI_HILOGE("Service is not running");
2229 return MMISERVICE_NOT_RUNNING;
2230 }
2231 std::string businessId;
2232 READSTRING(data, businessId, IPC_PROXY_DEAD_OBJECT_ERR);
2233 int32_t delay = 0;
2234 READINT32(data, delay, IPC_PROXY_DEAD_OBJECT_ERR);
2235 int32_t ret = SetKeyDownDuration(businessId, delay);
2236 if (ret != RET_OK) {
2237 MMI_HILOGE("Set key down duration failed ret:%{public}d", ret);
2238 return ret;
2239 }
2240 return RET_OK;
2241 }
2242
VerifyTouchPadSetting(void)2243 int32_t MultimodalInputConnectStub::VerifyTouchPadSetting(void)
2244 {
2245 if (!IsRunning()) {
2246 MMI_HILOGE("Service is not running");
2247 return MMISERVICE_NOT_RUNNING;
2248 }
2249
2250 if (!PER_HELPER->VerifySystemApp()) {
2251 MMI_HILOGE("Verify system APP failed");
2252 return ERROR_NOT_SYSAPI;
2253 }
2254
2255 return RET_OK;
2256 }
2257
StubSetTouchpadScrollSwitch(MessageParcel & data,MessageParcel & reply)2258 int32_t MultimodalInputConnectStub::StubSetTouchpadScrollSwitch(MessageParcel& data, MessageParcel& reply)
2259 {
2260 CALL_DEBUG_ENTER;
2261 int32_t ret = VerifyTouchPadSetting();
2262 if (ret != RET_OK) {
2263 MMI_HILOGE("Verify touchpad setting failed");
2264 return ret;
2265 }
2266
2267 bool switchFlag = true;
2268 READBOOL(data, switchFlag, IPC_PROXY_DEAD_OBJECT_ERR);
2269 ret = SetTouchpadScrollSwitch(switchFlag);
2270 if (ret != RET_OK) {
2271 MMI_HILOGE("Set touchpad scroll switch failed ret:%{public}d", ret);
2272 return ret;
2273 }
2274 return RET_OK;
2275 }
2276
StubGetTouchpadScrollSwitch(MessageParcel & data,MessageParcel & reply)2277 int32_t MultimodalInputConnectStub::StubGetTouchpadScrollSwitch(MessageParcel& data, MessageParcel& reply)
2278 {
2279 CALL_DEBUG_ENTER;
2280 int32_t ret = VerifyTouchPadSetting();
2281 if (ret != RET_OK) {
2282 MMI_HILOGE("Verify touchpad setting failed");
2283 return ret;
2284 }
2285
2286 bool switchFlag = true;
2287 ret = GetTouchpadScrollSwitch(switchFlag);
2288 if (ret != RET_OK) {
2289 MMI_HILOGE("Call GetTouchpadScrollSwitch failed ret:%{public}d", ret);
2290 return ret;
2291 }
2292 WRITEBOOL(reply, switchFlag, IPC_STUB_WRITE_PARCEL_ERR);
2293 MMI_HILOGD("Touchpad scroll switch :%{public}d, ret:%{public}d", switchFlag, ret);
2294 return RET_OK;
2295 }
2296
StubSetTouchpadScrollDirection(MessageParcel & data,MessageParcel & reply)2297 int32_t MultimodalInputConnectStub::StubSetTouchpadScrollDirection(MessageParcel& data, MessageParcel& reply)
2298 {
2299 CALL_DEBUG_ENTER;
2300 int32_t ret = VerifyTouchPadSetting();
2301 if (ret != RET_OK) {
2302 MMI_HILOGE("Verify touchpad setting failed");
2303 return ret;
2304 }
2305
2306 bool state = true;
2307 READBOOL(data, state, IPC_PROXY_DEAD_OBJECT_ERR);
2308 ret = SetTouchpadScrollDirection(state);
2309 if (ret != RET_OK) {
2310 MMI_HILOGE("Set touchpad scroll direction switch failed ret:%{public}d", ret);
2311 return ret;
2312 }
2313 return RET_OK;
2314 }
2315
StubGetTouchpadScrollDirection(MessageParcel & data,MessageParcel & reply)2316 int32_t MultimodalInputConnectStub::StubGetTouchpadScrollDirection(MessageParcel& data, MessageParcel& reply)
2317 {
2318 CALL_DEBUG_ENTER;
2319 int32_t ret = VerifyTouchPadSetting();
2320 if (ret != RET_OK) {
2321 MMI_HILOGE("Verify touchpad setting failed");
2322 return ret;
2323 }
2324
2325 bool state = true;
2326 ret = GetTouchpadScrollDirection(state);
2327 if (ret != RET_OK) {
2328 MMI_HILOGE("Call GetTouchpadScrollDirection failed ret:%{public}d", ret);
2329 return ret;
2330 }
2331 WRITEBOOL(reply, state, IPC_STUB_WRITE_PARCEL_ERR);
2332 MMI_HILOGD("Touchpad scroll direction switch state:%{public}d, ret:%{public}d", state, ret);
2333 return RET_OK;
2334 }
2335
StubSetTouchpadTapSwitch(MessageParcel & data,MessageParcel & reply)2336 int32_t MultimodalInputConnectStub::StubSetTouchpadTapSwitch(MessageParcel& data, MessageParcel& reply)
2337 {
2338 CALL_DEBUG_ENTER;
2339 int32_t ret = VerifyTouchPadSetting();
2340 if (ret != RET_OK) {
2341 MMI_HILOGE("Verify touchpad setting failed");
2342 return ret;
2343 }
2344
2345 bool switchFlag = true;
2346 READBOOL(data, switchFlag, IPC_PROXY_DEAD_OBJECT_ERR);
2347 ret = SetTouchpadTapSwitch(switchFlag);
2348 if (ret != RET_OK) {
2349 MMI_HILOGE("Set touchpad tap switch failed ret:%{public}d", ret);
2350 return ret;
2351 }
2352 return RET_OK;
2353 }
2354
StubGetTouchpadTapSwitch(MessageParcel & data,MessageParcel & reply)2355 int32_t MultimodalInputConnectStub::StubGetTouchpadTapSwitch(MessageParcel& data, MessageParcel& reply)
2356 {
2357 CALL_DEBUG_ENTER;
2358 int32_t ret = VerifyTouchPadSetting();
2359 if (ret != RET_OK) {
2360 MMI_HILOGE("Verify touchpad setting failed");
2361 return ret;
2362 }
2363
2364 bool switchFlag = true;
2365 ret = GetTouchpadTapSwitch(switchFlag);
2366 if (ret != RET_OK) {
2367 MMI_HILOGE("Call GetTouchpadTapSwitch failed ret:%{public}d", ret);
2368 return ret;
2369 }
2370 WRITEBOOL(reply, switchFlag, IPC_STUB_WRITE_PARCEL_ERR);
2371 MMI_HILOGD("Touchpad tap switchFlag:%{public}d, ret:%{public}d", switchFlag, ret);
2372 return RET_OK;
2373 }
2374
StubSetTouchpadPointerSpeed(MessageParcel & data,MessageParcel & reply)2375 int32_t MultimodalInputConnectStub::StubSetTouchpadPointerSpeed(MessageParcel& data, MessageParcel& reply)
2376 {
2377 CALL_DEBUG_ENTER;
2378 int32_t ret = VerifyTouchPadSetting();
2379 if (ret != RET_OK) {
2380 MMI_HILOGE("Verify touchpad setting failed");
2381 return ret;
2382 }
2383
2384 int32_t speed = 1;
2385 READINT32(data, speed, IPC_PROXY_DEAD_OBJECT_ERR);
2386 if (speed < MIN_SPEED) {
2387 speed = MIN_SPEED;
2388 } else if (speed > MAX_SPEED) {
2389 speed = MAX_SPEED;
2390 }
2391 ret = SetTouchpadPointerSpeed(speed);
2392 if (ret != RET_OK) {
2393 MMI_HILOGE("Set touchpad pointer speed failed ret:%{public}d", ret);
2394 return ret;
2395 }
2396 return RET_OK;
2397 }
2398
StubGetTouchpadPointerSpeed(MessageParcel & data,MessageParcel & reply)2399 int32_t MultimodalInputConnectStub::StubGetTouchpadPointerSpeed(MessageParcel& data, MessageParcel& reply)
2400 {
2401 CALL_DEBUG_ENTER;
2402 int32_t ret = VerifyTouchPadSetting();
2403 if (ret != RET_OK) {
2404 MMI_HILOGE("Verify touchpad setting failed");
2405 return ret;
2406 }
2407
2408 int32_t speed = 1;
2409 ret = GetTouchpadPointerSpeed(speed);
2410 if (ret != RET_OK) {
2411 MMI_HILOGE("Call GetTouchpadPointerSpeed failed ret:%{public}d", ret);
2412 return ret;
2413 }
2414 WRITEINT32(reply, speed, IPC_STUB_WRITE_PARCEL_ERR);
2415 MMI_HILOGD("Touchpad pointer speed:%{public}d, ret:%{public}d", speed, ret);
2416 return RET_OK;
2417 }
2418
StubGetTouchpadCDG(MessageParcel & data,MessageParcel & reply)2419 int32_t MultimodalInputConnectStub::StubGetTouchpadCDG(MessageParcel& data, MessageParcel& reply)
2420 {
2421 CALL_DEBUG_ENTER;
2422 int32_t ret = VerifyTouchPadSetting();
2423 if (ret != RET_OK) {
2424 MMI_HILOGE("Verify touchpad setting failed");
2425 return ret;
2426 }
2427
2428 TouchpadCDG touchpadCDG;
2429 touchpadCDG.ppi = 0.0;
2430 touchpadCDG.size = 0.0;
2431 touchpadCDG.speed = 0;
2432 ret = GetTouchpadCDG(touchpadCDG);
2433 if (ret != RET_OK) {
2434 MMI_HILOGE("Call GetTouchpadCDG failed ret:%{public}d", ret);
2435 return ret;
2436 }
2437 WRITEDOUBLE(reply, touchpadCDG.ppi, IPC_STUB_WRITE_PARCEL_ERR);
2438 WRITEDOUBLE(reply, touchpadCDG.size, IPC_STUB_WRITE_PARCEL_ERR);
2439 WRITEINT32(reply, touchpadCDG.speed, IPC_STUB_WRITE_PARCEL_ERR);
2440 MMI_HILOGD("Touchpad option ppi:%{public}lf size:%{public}lf speed:%{public}d, ret:%{public}d",
2441 touchpadCDG.ppi, touchpadCDG.size, touchpadCDG.speed, ret);
2442 return RET_OK;
2443 }
2444
StubSetKeyboardRepeatDelay(MessageParcel & data,MessageParcel & reply)2445 int32_t MultimodalInputConnectStub::StubSetKeyboardRepeatDelay(MessageParcel& data, MessageParcel& reply)
2446 {
2447 CALL_DEBUG_ENTER;
2448 if (!IsRunning()) {
2449 MMI_HILOGE("Service is not running");
2450 return MMISERVICE_NOT_RUNNING;
2451 }
2452 if (!PER_HELPER->VerifySystemApp()) {
2453 MMI_HILOGE("Verify system APP failed");
2454 return ERROR_NOT_SYSAPI;
2455 }
2456 int32_t delay = 0;
2457 READINT32(data, delay, IPC_PROXY_DEAD_OBJECT_ERR);
2458 int32_t ret = SetKeyboardRepeatDelay(delay);
2459 if (ret != RET_OK) {
2460 MMI_HILOGE("Set keyboard repeat delay failed ret:%{public}d", ret);
2461 return RET_ERR;
2462 }
2463 return RET_OK;
2464 }
2465
StubSetKeyboardRepeatRate(MessageParcel & data,MessageParcel & reply)2466 int32_t MultimodalInputConnectStub::StubSetKeyboardRepeatRate(MessageParcel& data, MessageParcel& reply)
2467 {
2468 CALL_DEBUG_ENTER;
2469 if (!IsRunning()) {
2470 MMI_HILOGE("Service is not running");
2471 return MMISERVICE_NOT_RUNNING;
2472 }
2473 if (!PER_HELPER->VerifySystemApp()) {
2474 MMI_HILOGE("Verify system APP failed");
2475 return ERROR_NOT_SYSAPI;
2476 }
2477 int32_t rate = 0;
2478 READINT32(data, rate, IPC_PROXY_DEAD_OBJECT_ERR);
2479 int32_t ret = SetKeyboardRepeatRate(rate);
2480 if (ret != RET_OK) {
2481 MMI_HILOGE("Set keyboard repeat rate failed ret:%{public}d", ret);
2482 return RET_ERR;
2483 }
2484 return RET_OK;
2485 }
2486
StubGetKeyboardRepeatDelay(MessageParcel & data,MessageParcel & reply)2487 int32_t MultimodalInputConnectStub::StubGetKeyboardRepeatDelay(MessageParcel& data, MessageParcel& reply)
2488 {
2489 CALL_DEBUG_ENTER;
2490 if (!IsRunning()) {
2491 MMI_HILOGE("Service is not running");
2492 return MMISERVICE_NOT_RUNNING;
2493 }
2494 if (!PER_HELPER->VerifySystemApp()) {
2495 MMI_HILOGE("Verify system APP failed");
2496 return ERROR_NOT_SYSAPI;
2497 }
2498 int32_t delay = 0;
2499 int32_t ret = GetKeyboardRepeatDelay(delay);
2500 if (ret != RET_OK) {
2501 MMI_HILOGE("Get keyboard repeat delay failed ret:%{public}d", ret);
2502 return RET_ERR;
2503 }
2504 WRITEINT32(reply, delay, IPC_STUB_WRITE_PARCEL_ERR);
2505 return RET_OK;
2506 }
2507
StubGetKeyboardRepeatRate(MessageParcel & data,MessageParcel & reply)2508 int32_t MultimodalInputConnectStub::StubGetKeyboardRepeatRate(MessageParcel& data, MessageParcel& reply)
2509 {
2510 CALL_DEBUG_ENTER;
2511 if (!IsRunning()) {
2512 MMI_HILOGE("Service is not running");
2513 return MMISERVICE_NOT_RUNNING;
2514 }
2515 if (!PER_HELPER->VerifySystemApp()) {
2516 MMI_HILOGE("Verify system APP failed");
2517 return ERROR_NOT_SYSAPI;
2518 }
2519 int32_t rate = 0;
2520 int32_t ret = GetKeyboardRepeatRate(rate);
2521 if (ret != RET_OK) {
2522 MMI_HILOGE("Get keyboard repeat rate failed ret:%{public}d", ret);
2523 return RET_ERR;
2524 }
2525 WRITEINT32(reply, rate, IPC_STUB_WRITE_PARCEL_ERR);
2526 return RET_OK;
2527 }
2528
StubSetTouchpadPinchSwitch(MessageParcel & data,MessageParcel & reply)2529 int32_t MultimodalInputConnectStub::StubSetTouchpadPinchSwitch(MessageParcel& data, MessageParcel& reply)
2530 {
2531 CALL_DEBUG_ENTER;
2532 int32_t ret = VerifyTouchPadSetting();
2533 if (ret != RET_OK) {
2534 MMI_HILOGE("Verify touchpad setting failed");
2535 return ret;
2536 }
2537
2538 bool switchFlag = true;
2539 READBOOL(data, switchFlag, IPC_PROXY_DEAD_OBJECT_ERR);
2540 ret = SetTouchpadPinchSwitch(switchFlag);
2541 if (ret != RET_OK) {
2542 MMI_HILOGE("Set touchpad pinch switch failed ret:%{public}d", ret);
2543 return ret;
2544 }
2545 return RET_OK;
2546 }
2547
StubGetTouchpadPinchSwitch(MessageParcel & data,MessageParcel & reply)2548 int32_t MultimodalInputConnectStub::StubGetTouchpadPinchSwitch(MessageParcel& data, MessageParcel& reply)
2549 {
2550 CALL_DEBUG_ENTER;
2551 int32_t ret = VerifyTouchPadSetting();
2552 if (ret != RET_OK) {
2553 MMI_HILOGE("Verify touchpad setting failed");
2554 return ret;
2555 }
2556
2557 bool switchFlag = true;
2558 ret = GetTouchpadPinchSwitch(switchFlag);
2559 if (ret != RET_OK) {
2560 MMI_HILOGE("Call GetTouchpadPinchSwitch failed ret:%{public}d", ret);
2561 return ret;
2562 }
2563 WRITEBOOL(reply, switchFlag, IPC_STUB_WRITE_PARCEL_ERR);
2564 MMI_HILOGD("Touchpad pinch switchFlag:%{public}d, ret:%{public}d", switchFlag, ret);
2565 return RET_OK;
2566 }
2567
StubSetTouchpadSwipeSwitch(MessageParcel & data,MessageParcel & reply)2568 int32_t MultimodalInputConnectStub::StubSetTouchpadSwipeSwitch(MessageParcel& data, MessageParcel& reply)
2569 {
2570 CALL_DEBUG_ENTER;
2571 int32_t ret = VerifyTouchPadSetting();
2572 if (ret != RET_OK) {
2573 MMI_HILOGE("Verify touchpad setting failed");
2574 return ret;
2575 }
2576
2577 bool switchFlag = true;
2578 READBOOL(data, switchFlag, IPC_PROXY_DEAD_OBJECT_ERR);
2579 ret = SetTouchpadSwipeSwitch(switchFlag);
2580 if (ret != RET_OK) {
2581 MMI_HILOGE("Set touchpad swipe switch failed ret:%{public}d", ret);
2582 return ret;
2583 }
2584 return RET_OK;
2585 }
2586
StubGetTouchpadSwipeSwitch(MessageParcel & data,MessageParcel & reply)2587 int32_t MultimodalInputConnectStub::StubGetTouchpadSwipeSwitch(MessageParcel& data, MessageParcel& reply)
2588 {
2589 CALL_DEBUG_ENTER;
2590 int32_t ret = VerifyTouchPadSetting();
2591 if (ret != RET_OK) {
2592 MMI_HILOGE("Verify touchpad setting failed");
2593 return ret;
2594 }
2595
2596 bool switchFlag = true;
2597 ret = GetTouchpadSwipeSwitch(switchFlag);
2598 if (ret != RET_OK) {
2599 MMI_HILOGE("Call GetTouchpadSwipeSwitch failed ret:%{public}d", ret);
2600 return ret;
2601 }
2602 WRITEBOOL(reply, switchFlag, IPC_STUB_WRITE_PARCEL_ERR);
2603 MMI_HILOGD("Touchpad swipe switchFlag:%{public}d, ret:%{public}d", switchFlag, ret);
2604 return RET_OK;
2605 }
2606
StubSetTouchpadRightClickType(MessageParcel & data,MessageParcel & reply)2607 int32_t MultimodalInputConnectStub::StubSetTouchpadRightClickType(MessageParcel& data, MessageParcel& reply)
2608 {
2609 CALL_DEBUG_ENTER;
2610 int32_t ret = VerifyTouchPadSetting();
2611 if (ret != RET_OK) {
2612 MMI_HILOGE("Verify touchpad setting failed");
2613 return ret;
2614 }
2615
2616 int32_t type = 1;
2617 READINT32(data, type, IPC_PROXY_DEAD_OBJECT_ERR);
2618 if (type != RightClickType::TOUCHPAD_RIGHT_BUTTON && type != RightClickType::TOUCHPAD_LEFT_BUTTON &&
2619 type != RightClickType::TOUCHPAD_TWO_FINGER_TAP) {
2620 MMI_HILOGE("Invalid type:%{public}d", type);
2621 return RET_ERR;
2622 }
2623 ret = SetTouchpadRightClickType(type);
2624 if (ret != RET_OK) {
2625 MMI_HILOGE("Set touchpad right button menu type failed ret:%{public}d", ret);
2626 return ret;
2627 }
2628 return RET_OK;
2629 }
2630
StubGetTouchpadRightClickType(MessageParcel & data,MessageParcel & reply)2631 int32_t MultimodalInputConnectStub::StubGetTouchpadRightClickType(MessageParcel& data, MessageParcel& reply)
2632 {
2633 CALL_DEBUG_ENTER;
2634 int32_t ret = VerifyTouchPadSetting();
2635 if (ret != RET_OK) {
2636 MMI_HILOGE("Verify touchpad setting failed");
2637 return ret;
2638 }
2639
2640 int32_t type = 1;
2641 ret = GetTouchpadRightClickType(type);
2642 if (ret != RET_OK) {
2643 MMI_HILOGE("Call GetTouchpadRightClickType failed ret:%{public}d", ret);
2644 return ret;
2645 }
2646 WRITEINT32(reply, type, IPC_STUB_WRITE_PARCEL_ERR);
2647 MMI_HILOGD("Touchpad right button menu type:%{public}d, ret:%{public}d", type, ret);
2648 return RET_OK;
2649 }
2650
StubSetTouchpadRotateSwitch(MessageParcel & data,MessageParcel & reply)2651 int32_t MultimodalInputConnectStub::StubSetTouchpadRotateSwitch(MessageParcel& data, MessageParcel& reply)
2652 {
2653 CALL_DEBUG_ENTER;
2654 int32_t ret = VerifyTouchPadSetting();
2655 if (ret != RET_OK) {
2656 MMI_HILOGE("Verify touchpad setting failed");
2657 return ret;
2658 }
2659
2660 bool rotateSwitch = true;
2661 READBOOL(data, rotateSwitch, IPC_PROXY_DEAD_OBJECT_ERR);
2662 ret = SetTouchpadRotateSwitch(rotateSwitch);
2663 if (ret != RET_OK) {
2664 MMI_HILOGE("Set touchpad rotate switch failed ret:%{public}d", ret);
2665 return ret;
2666 }
2667 return RET_OK;
2668 }
2669
StubGetTouchpadRotateSwitch(MessageParcel & data,MessageParcel & reply)2670 int32_t MultimodalInputConnectStub::StubGetTouchpadRotateSwitch(MessageParcel& data, MessageParcel& reply)
2671 {
2672 CALL_DEBUG_ENTER;
2673 int32_t ret = VerifyTouchPadSetting();
2674 if (ret != RET_OK) {
2675 MMI_HILOGE("Verify touchpad setting failed");
2676 return ret;
2677 }
2678
2679 bool rotateSwitch = true;
2680 ret = GetTouchpadRotateSwitch(rotateSwitch);
2681 if (ret != RET_OK) {
2682 MMI_HILOGE("GetTouchpadRotateSwitch failed ret:%{public}d", ret);
2683 return ret;
2684 }
2685 WRITEBOOL(reply, rotateSwitch, IPC_STUB_WRITE_PARCEL_ERR);
2686 MMI_HILOGD("Touchpad rotate switch:%{public}d, ret:%{public}d", rotateSwitch, ret);
2687 return RET_OK;
2688 }
2689
StubSetTouchpadDoubleTapAndDragState(MessageParcel & data,MessageParcel & reply)2690 int32_t MultimodalInputConnectStub::StubSetTouchpadDoubleTapAndDragState(MessageParcel& data, MessageParcel& reply)
2691 {
2692 CALL_DEBUG_ENTER;
2693 int32_t ret = VerifyTouchPadSetting();
2694 if (ret != RET_OK) {
2695 MMI_HILOGE("Verify touchpad setting failed");
2696 return ret;
2697 }
2698
2699 bool switchFlag = true;
2700 READBOOL(data, switchFlag, IPC_PROXY_DEAD_OBJECT_ERR);
2701 ret = SetTouchpadDoubleTapAndDragState(switchFlag);
2702 if (ret != RET_OK) {
2703 MMI_HILOGE("Set touchpad double tap and drag switch failed ret:%{public}d", ret);
2704 return ret;
2705 }
2706 return RET_OK;
2707 }
2708
StubGetTouchpadDoubleTapAndDragState(MessageParcel & data,MessageParcel & reply)2709 int32_t MultimodalInputConnectStub::StubGetTouchpadDoubleTapAndDragState(MessageParcel& data, MessageParcel& reply)
2710 {
2711 CALL_DEBUG_ENTER;
2712 int32_t ret = VerifyTouchPadSetting();
2713 if (ret != RET_OK) {
2714 MMI_HILOGE("Verify touchpad setting failed");
2715 return ret;
2716 }
2717
2718 bool switchFlag = true;
2719 ret = GetTouchpadDoubleTapAndDragState(switchFlag);
2720 if (ret != RET_OK) {
2721 MMI_HILOGE("GetTouchpadDoubleTapAndDragState failed ret:%{public}d", ret);
2722 return ret;
2723 }
2724 WRITEBOOL(reply, switchFlag, IPC_STUB_WRITE_PARCEL_ERR);
2725 return RET_OK;
2726 }
2727
StubSetShieldStatus(MessageParcel & data,MessageParcel & reply)2728 int32_t MultimodalInputConnectStub::StubSetShieldStatus(MessageParcel& data, MessageParcel& reply)
2729 {
2730 CALL_DEBUG_ENTER;
2731 if (!PER_HELPER->VerifySystemApp()) {
2732 MMI_HILOGE("Verify system APP failed");
2733 return ERROR_NOT_SYSAPI;
2734 }
2735 if (!PER_HELPER->CheckDispatchControl()) {
2736 MMI_HILOGE("Input dispatch control permission check failed");
2737 return ERROR_NO_PERMISSION;
2738 }
2739 if (!IsRunning()) {
2740 MMI_HILOGE("Service is not running");
2741 return MMISERVICE_NOT_RUNNING;
2742 }
2743
2744 int32_t shieldMode { 0 };
2745 bool isShield { false };
2746 READINT32(data, shieldMode, IPC_PROXY_DEAD_OBJECT_ERR);
2747 READBOOL(data, isShield, IPC_PROXY_DEAD_OBJECT_ERR);
2748 int32_t ret = SetShieldStatus(shieldMode, isShield);
2749 if (ret != RET_OK) {
2750 MMI_HILOGE("Call SetShieldStatus failed, ret:%{public}d", ret);
2751 return ret;
2752 }
2753 MMI_HILOGD("Success shieldMode:%{public}d, isShield:%{public}d", shieldMode, isShield);
2754 return RET_OK;
2755 }
2756
StubGetShieldStatus(MessageParcel & data,MessageParcel & reply)2757 int32_t MultimodalInputConnectStub::StubGetShieldStatus(MessageParcel& data, MessageParcel& reply)
2758 {
2759 CALL_DEBUG_ENTER;
2760 if (!PER_HELPER->VerifySystemApp()) {
2761 MMI_HILOGE("Verify system APP failed");
2762 return ERROR_NOT_SYSAPI;
2763 }
2764 if (!PER_HELPER->CheckDispatchControl()) {
2765 MMI_HILOGE("Input dispatch control permission check failed");
2766 return ERROR_NO_PERMISSION;
2767 }
2768 if (!IsRunning()) {
2769 MMI_HILOGE("Service is not running");
2770 return MMISERVICE_NOT_RUNNING;
2771 }
2772
2773 int32_t shieldMode { 0 };
2774 bool state { false };
2775 READINT32(data, shieldMode, IPC_PROXY_DEAD_OBJECT_ERR);
2776 int32_t ret = GetShieldStatus(shieldMode, state);
2777 if (ret != RET_OK) {
2778 MMI_HILOGE("Call GetShieldStatus failed ret:%{public}d", ret);
2779 return ret;
2780 }
2781 WRITEBOOL(reply, state, IPC_PROXY_DEAD_OBJECT_ERR);
2782 return RET_OK;
2783 }
2784
StubGetKeyState(MessageParcel & data,MessageParcel & reply)2785 int32_t MultimodalInputConnectStub::StubGetKeyState(MessageParcel& data, MessageParcel& reply)
2786 {
2787 CALL_DEBUG_ENTER;
2788 std::vector<int32_t> pressedKeys;
2789 std::map<int32_t, int32_t> specialKeysState;
2790 int32_t ret = GetKeyState(pressedKeys, specialKeysState);
2791 if (ret != RET_OK) {
2792 MMI_HILOGE("Call GetKeyState failed ret:%{public}d", ret);
2793 return RET_ERR;
2794 }
2795 if (!reply.WriteInt32Vector(pressedKeys)) {
2796 MMI_HILOGE("Write pressedKeys failed");
2797 return RET_ERR;
2798 }
2799 std::vector<int32_t> specialKeysStateTmp;
2800 for (const auto &item : specialKeysState) {
2801 specialKeysStateTmp.push_back(item.second);
2802 }
2803 if (!reply.WriteInt32Vector(specialKeysStateTmp)) {
2804 MMI_HILOGE("Write specialKeysStateTmp failed");
2805 return RET_ERR;
2806 }
2807 return ret;
2808 }
2809
StubAuthorize(MessageParcel & data,MessageParcel & reply)2810 int32_t MultimodalInputConnectStub::StubAuthorize(MessageParcel& data, MessageParcel& reply)
2811 {
2812 CALL_DEBUG_ENTER;
2813 if (!PER_HELPER->VerifySystemApp()) {
2814 MMI_HILOGE("Verify system APP failed");
2815 return ERROR_NOT_SYSAPI;
2816 }
2817 if (!PER_HELPER->CheckAuthorize()) {
2818 MMI_HILOGE("Input authorize permission check failed");
2819 return ERROR_NO_PERMISSION;
2820 }
2821 bool isAuthorize { false };
2822 READBOOL(data, isAuthorize, IPC_PROXY_DEAD_OBJECT_ERR);
2823 int32_t ret = Authorize(isAuthorize);
2824 if (ret != RET_OK) {
2825 MMI_HILOGE("Call Authorize failed ret:%{public}d", ret);
2826 return ret;
2827 }
2828 return RET_OK;
2829 }
2830
StubCancelInjection(MessageParcel & data,MessageParcel & reply)2831 int32_t MultimodalInputConnectStub::StubCancelInjection(MessageParcel& data, MessageParcel& reply)
2832 {
2833 CALL_DEBUG_ENTER;
2834 int32_t ret = CancelInjection();
2835 if (ret != RET_OK) {
2836 MMI_HILOGE("Call CancelInjection failed ret:%{public}d", ret);
2837 return ret;
2838 }
2839 return RET_OK;
2840 }
2841
StubHasIrEmitter(MessageParcel & data,MessageParcel & reply)2842 int32_t MultimodalInputConnectStub::StubHasIrEmitter(MessageParcel& data, MessageParcel& reply)
2843 {
2844 CALL_DEBUG_ENTER;
2845 if (!PER_HELPER->VerifySystemApp()) {
2846 MMI_HILOGE("Verify system APP failed");
2847 return ERROR_NOT_SYSAPI;
2848 }
2849 bool hasIrEmitter = false;
2850 int32_t ret = HasIrEmitter(hasIrEmitter);
2851 if (ret != RET_OK) {
2852 MMI_HILOGE("Call StubHasIrEmitter failed ret:%{public}d", ret);
2853 return ret;
2854 }
2855 WRITEBOOL(reply, hasIrEmitter, IPC_STUB_WRITE_PARCEL_ERR);
2856 return RET_OK;
2857 }
2858
StubGetInfraredFrequencies(MessageParcel & data,MessageParcel & reply)2859 int32_t MultimodalInputConnectStub::StubGetInfraredFrequencies(MessageParcel& data, MessageParcel& reply)
2860 {
2861 CALL_DEBUG_ENTER;
2862 if (!PER_HELPER->CheckInfraredEmmit()) {
2863 MMI_HILOGE("Infrared permission check failed");
2864 return ERROR_NO_PERMISSION;
2865 }
2866 std::vector<InfraredFrequency> requencys;
2867 int32_t ret = GetInfraredFrequencies(requencys);
2868 if (ret != RET_OK) {
2869 MMI_HILOGE("Call StubGetInfraredFrequencies failed returnCode:%{public}d", ret);
2870 return ret;
2871 }
2872 WRITEINT64(reply, requencys.size());
2873 for (const auto &item : requencys) {
2874 WRITEINT64(reply, item.max_);
2875 WRITEINT64(reply, item.min_);
2876 }
2877 return RET_OK;
2878 }
2879
StubTransmitInfrared(MessageParcel & data,MessageParcel & reply)2880 int32_t MultimodalInputConnectStub::StubTransmitInfrared(MessageParcel& data, MessageParcel& reply)
2881 {
2882 CALL_DEBUG_ENTER;
2883 if (!PER_HELPER->CheckInfraredEmmit()) {
2884 MMI_HILOGE("StubTransmitInfrared permission check failed. returnCode:%{public}d", ERROR_NO_PERMISSION);
2885 return ERROR_NO_PERMISSION;
2886 }
2887 int64_t number = 0;
2888 READINT64(data, number, IPC_PROXY_DEAD_OBJECT_ERR);
2889 int32_t patternLen = 0;
2890 std::vector<int64_t> pattern;
2891 READINT32(data, patternLen, IPC_PROXY_DEAD_OBJECT_ERR);
2892 if (patternLen > MAX_N_TRANSMIT_INFRARED_PATTERN || patternLen <= 0) {
2893 MMI_HILOGE("Transmit infrared pattern len is invalid");
2894 return false;
2895 }
2896 for (int32_t i = 0; i < patternLen; i++) {
2897 int64_t value = 0;
2898 READINT64(data, value);
2899 pattern.push_back(value);
2900 }
2901 if (number < 0) {
2902 MMI_HILOGE("Transmit infrared number is invalid");
2903 return false;
2904 }
2905 int32_t ret = TransmitInfrared(number, pattern);
2906 if (ret != RET_OK) {
2907 MMI_HILOGE("Call StubTransmitInfrared failed returnCode:%{public}d", ret);
2908 return ret;
2909 }
2910 WRITEINT32(reply, ret);
2911 return RET_OK;
2912 }
2913
2914 #ifdef OHOS_BUILD_ENABLE_VKEYBOARD
StubCreateVKeyboardDevice(MessageParcel & data,MessageParcel & reply)2915 int32_t MultimodalInputConnectStub::StubCreateVKeyboardDevice(MessageParcel& data, MessageParcel& reply)
2916 {
2917 CALL_DEBUG_ENTER;
2918 if (!PER_HELPER->VerifySystemApp()) {
2919 MMI_HILOGE("StubCreateVKeyboardDevice Verify system APP failed");
2920 return ERROR_NOT_SYSAPI;
2921 }
2922 sptr<IRemoteObject> vkeyboardDevice = nullptr;
2923 int32_t ret = CreateVKeyboardDevice(vkeyboardDevice);
2924 if (ret != RET_OK) {
2925 MMI_HILOGE("Call StubCreateVKeyboardDevice failed ret:%{public}d", ret);
2926 }
2927 WRITEREMOTEOBJECT(reply, vkeyboardDevice, ERR_INVALID_VALUE);
2928 return ret;
2929 }
2930 #endif // OHOS_BUILD_ENABLE_VKEYBOARD
2931
StubSetPixelMapData(MessageParcel & data,MessageParcel & reply)2932 int32_t MultimodalInputConnectStub::StubSetPixelMapData(MessageParcel& data, MessageParcel& reply)
2933 {
2934 CALL_DEBUG_ENTER;
2935 if (!PER_HELPER->VerifySystemApp()) {
2936 MMI_HILOGE("Verify system APP failed");
2937 return ERROR_NOT_SYSAPI;
2938 }
2939 if (!IsRunning()) {
2940 MMI_HILOGE("Service is not running");
2941 return MMISERVICE_NOT_RUNNING;
2942 }
2943 int32_t infoId = -1;
2944 READINT32(data, infoId, IPC_PROXY_DEAD_OBJECT_ERR);
2945 if (infoId <= 0) {
2946 MMI_HILOGE("Invalid infoId:%{public}d", infoId);
2947 return RET_ERR;
2948 }
2949 OHOS::Media::PixelMap* pixelMap = Media::PixelMap::Unmarshalling(data);
2950 CHKPR(pixelMap, RET_ERR);
2951 int32_t ret = SetPixelMapData(infoId, static_cast<void*>(pixelMap));
2952 if (ret != RET_OK) {
2953 MMI_HILOGE("Failed to call SetPixelMapData, ret:%{public}d", ret);
2954 }
2955 return ret;
2956 }
2957
StubSetMoveEventFilters(MessageParcel & data,MessageParcel & reply)2958 int32_t MultimodalInputConnectStub::StubSetMoveEventFilters(MessageParcel& data, MessageParcel& reply)
2959 {
2960 CALL_DEBUG_ENTER;
2961 if (!PER_HELPER->VerifySystemApp()) {
2962 MMI_HILOGE("StubSetMoveEventFilters Verify system APP failed");
2963 return ERROR_NOT_SYSAPI;
2964 }
2965 if (!IsRunning()) {
2966 MMI_HILOGE("Service is not running");
2967 return MMISERVICE_NOT_RUNNING;
2968 }
2969 bool flag = false;
2970 READBOOL(data, flag, IPC_PROXY_DEAD_OBJECT_ERR);
2971 int32_t ret = SetMoveEventFilters(flag);
2972 if (ret != RET_OK) {
2973 MMI_HILOGE("Call SetMoveEventFilters failed, ret:%{public}d", ret);
2974 }
2975 return ret;
2976 }
2977
StubSetCurrentUser(MessageParcel & data,MessageParcel & reply)2978 int32_t MultimodalInputConnectStub::StubSetCurrentUser(MessageParcel& data, MessageParcel& reply)
2979 {
2980 CALL_DEBUG_ENTER;
2981 if (!PER_HELPER->VerifySystemApp()) {
2982 MMI_HILOGE("StubSetCurrentUser Verify system APP failed");
2983 return ERROR_NOT_SYSAPI;
2984 }
2985 int32_t userId = 0;
2986 READINT32(data, userId, IPC_PROXY_DEAD_OBJECT_ERR);
2987 int32_t callingUid = GetCallingUid();
2988 if (callingUid < UID_TRANSFORM_DIVISOR) {
2989 MMI_HILOGE("CallingUid is not within the range:%{public}d", callingUid);
2990 return RET_ERR;
2991 }
2992 if (callingUid / UID_TRANSFORM_DIVISOR != userId) {
2993 MMI_HILOGE("Invalid CallingUid:%{public}d", callingUid);
2994 return RET_ERR;
2995 }
2996 int32_t ret = SetCurrentUser(userId);
2997 if (ret != RET_OK) {
2998 MMI_HILOGE("Failed to call SetCurrentUser ret:%{public}d", ret);
2999 return ret;
3000 }
3001 WRITEINT32(reply, ret);
3002 return RET_OK;
3003 }
3004
StubSetTouchpadThreeFingersTapSwitch(MessageParcel & data,MessageParcel & reply)3005 int32_t MultimodalInputConnectStub::StubSetTouchpadThreeFingersTapSwitch(MessageParcel& data, MessageParcel& reply)
3006 {
3007 CALL_DEBUG_ENTER;
3008 if (!PER_HELPER->VerifySystemApp()) {
3009 MMI_HILOGE("StubSetTouchpadThreeFingersTapSwitch Verify system APP failed");
3010 return ERROR_NOT_SYSAPI;
3011 }
3012 bool threeFingersTapSwitch = true;
3013 READBOOL(data, threeFingersTapSwitch, IPC_PROXY_DEAD_OBJECT_ERR);
3014 int32_t ret = SetTouchpadThreeFingersTapSwitch(threeFingersTapSwitch);
3015 if (ret != RET_OK) {
3016 MMI_HILOGE("Failed to call StubSetTouchpadThreeFingersTapSwitch ret:%{public}d", ret);
3017 return ret;
3018 }
3019 return RET_OK;
3020 }
3021
StubGetTouchpadThreeFingersTapSwitch(MessageParcel & data,MessageParcel & reply)3022 int32_t MultimodalInputConnectStub::StubGetTouchpadThreeFingersTapSwitch(MessageParcel& data, MessageParcel& reply)
3023 {
3024 CALL_DEBUG_ENTER;
3025 if (!PER_HELPER->VerifySystemApp()) {
3026 MMI_HILOGE("StubGetTouchpadThreeFingersTapSwitch Verify system APP failed");
3027 return ERROR_NOT_SYSAPI;
3028 }
3029 bool switchFlag = true;
3030 int32_t ret = GetTouchpadThreeFingersTapSwitch(switchFlag);
3031 if (ret != RET_OK) {
3032 MMI_HILOGE("Failed to call StubGetTouchpadThreeFingersTapSwitch ret:%{public}d", ret);
3033 } else {
3034 WRITEBOOL(reply, switchFlag);
3035 }
3036 return ret;
3037 }
3038
StubEnableHardwareCursorStats(MessageParcel & data,MessageParcel & reply)3039 int32_t MultimodalInputConnectStub::StubEnableHardwareCursorStats(MessageParcel& data, MessageParcel& reply)
3040 {
3041 CALL_DEBUG_ENTER;
3042 if (!PER_HELPER->VerifySystemApp()) {
3043 MMI_HILOGE("Verify system APP failed");
3044 return ERROR_NOT_SYSAPI;
3045 }
3046 bool enable = false;
3047 READBOOL(data, enable, IPC_PROXY_DEAD_OBJECT_ERR);
3048 int32_t ret = EnableHardwareCursorStats(enable);
3049 if (ret != RET_OK) {
3050 MMI_HILOGE("Call EnableHardwareCursorStats failed ret:%{public}d", ret);
3051 return ret;
3052 }
3053 return RET_OK;
3054 }
3055
StubGetHardwareCursorStats(MessageParcel & data,MessageParcel & reply)3056 int32_t MultimodalInputConnectStub::StubGetHardwareCursorStats(MessageParcel& data, MessageParcel& reply)
3057 {
3058 CALL_DEBUG_ENTER;
3059 if (!PER_HELPER->VerifySystemApp()) {
3060 MMI_HILOGE("Verify system APP failed");
3061 return ERROR_NOT_SYSAPI;
3062 }
3063 uint32_t frameCount = 0;
3064 uint32_t vsyncCount = 0;
3065 int32_t ret = GetHardwareCursorStats(frameCount, vsyncCount);
3066 if (ret != RET_OK) {
3067 MMI_HILOGE("Call GetHardwareCursorStats failed ret:%{public}d", ret);
3068 return ret;
3069 }
3070 WRITEUINT32(reply, frameCount, IPC_PROXY_DEAD_OBJECT_ERR);
3071 WRITEUINT32(reply, vsyncCount, IPC_PROXY_DEAD_OBJECT_ERR);
3072 return RET_OK;
3073 }
3074
StubSetTouchpadScrollRows(MessageParcel & data,MessageParcel & reply)3075 int32_t MultimodalInputConnectStub::StubSetTouchpadScrollRows(MessageParcel& data, MessageParcel& reply)
3076 {
3077 CALL_DEBUG_ENTER;
3078 if (!IsRunning()) {
3079 MMI_HILOGE("Service is not running");
3080 return MMISERVICE_NOT_RUNNING;
3081 }
3082 if (!PER_HELPER->VerifySystemApp()) {
3083 MMI_HILOGE("Verify system APP failed");
3084 return ERROR_NOT_SYSAPI;
3085 }
3086 int32_t rows = TOUCHPAD_SCROLL_ROWS;
3087 READINT32(data, rows, IPC_PROXY_DEAD_OBJECT_ERR);
3088 int32_t newRows = std::clamp(rows, MIN_ROWS, MAX_ROWS);
3089 int32_t ret = SetTouchpadScrollRows(newRows);
3090 if (ret != RET_OK) {
3091 MMI_HILOGE("Call SetTouchpadScrollRows failed ret:%{public}d, pid:%{public}d", ret, GetCallingPid());
3092 }
3093 MMI_HILOGD("Success rows:%{public}d, pid:%{public}d", newRows, GetCallingPid());
3094 return ret;
3095 }
3096
StubGetTouchpadScrollRows(MessageParcel & data,MessageParcel & reply)3097 int32_t MultimodalInputConnectStub::StubGetTouchpadScrollRows(MessageParcel& data, MessageParcel& reply)
3098 {
3099 CALL_DEBUG_ENTER;
3100 if (!IsRunning()) {
3101 MMI_HILOGE("Service is not running");
3102 return MMISERVICE_NOT_RUNNING;
3103 }
3104 if (!PER_HELPER->VerifySystemApp()) {
3105 MMI_HILOGE("Verify system APP failed");
3106 return ERROR_NOT_SYSAPI;
3107 }
3108 int32_t rows = TOUCHPAD_SCROLL_ROWS;
3109 int32_t ret = GetTouchpadScrollRows(rows);
3110 if (rows < MIN_ROWS || rows > MAX_ROWS) {
3111 MMI_HILOGD("Invalid touchpad scroll rows:%{public}d, ret:%{public}d", rows, ret);
3112 return ret;
3113 }
3114 if (ret != RET_OK) {
3115 MMI_HILOGE("Call GetTouchpadScrollRows failed, ret:%{public}d", ret);
3116 return ret;
3117 }
3118 WRITEINT32(reply, rows, IPC_STUB_WRITE_PARCEL_ERR);
3119 MMI_HILOGD("Touchpad scroll rows:%{public}d, ret:%{public}d", rows, ret);
3120 return RET_OK;
3121 }
3122
3123 #ifdef OHOS_BUILD_ENABLE_MAGICCURSOR
StubGetPointerSnapshot(MessageParcel & data,MessageParcel & reply)3124 int32_t MultimodalInputConnectStub::StubGetPointerSnapshot(MessageParcel &data, MessageParcel &reply)
3125 {
3126 CALL_DEBUG_ENTER;
3127 if (!IsRunning()) {
3128 MMI_HILOGE("Service is not running");
3129 return MMISERVICE_NOT_RUNNING;
3130 }
3131 if (!PER_HELPER->VerifySystemApp()) {
3132 MMI_HILOGE("Verify system APP failed");
3133 return ERROR_NOT_SYSAPI;
3134 }
3135 std::shared_ptr<Media::PixelMap> pixelMap;
3136 int32_t ret = GetPointerSnapshot(&pixelMap);
3137 if (ret != RET_OK) {
3138 MMI_HILOGE("Call GetPointerSnapshot failed ret:%{public}d", ret);
3139 return ret;
3140 }
3141 CHKPR(pixelMap, ERR_INVALID_VALUE);
3142 if (pixelMap->GetCapacity() == 0) {
3143 MMI_HILOGE("pixelMap is empty, we dont have to pass it to the server");
3144 return ERR_INVALID_VALUE;
3145 }
3146 pixelMap->Marshalling(reply);
3147 return RET_OK;
3148 }
3149 #endif // OHOS_BUILD_ENABLE_MAGICCURSOR
3150
StubAddVirtualInputDevice(MessageParcel & data,MessageParcel & reply)3151 int32_t MultimodalInputConnectStub::StubAddVirtualInputDevice(MessageParcel& data, MessageParcel& reply)
3152 {
3153 CALL_DEBUG_ENTER;
3154 if (!PER_HELPER->VerifySystemApp()) {
3155 MMI_HILOGE("Verify system APP failed");
3156 return ERROR_NOT_SYSAPI;
3157 }
3158 auto device = std::make_shared<InputDevice>();
3159 if (g_parseInputDevice(data, device) != RET_OK) {
3160 MMI_HILOGE("ParseInputDevice failed");
3161 return RET_ERR;
3162 }
3163 int32_t deviceId { -1 };
3164 int32_t ret = AddVirtualInputDevice(device, deviceId);
3165 if (ret != RET_OK) {
3166 MMI_HILOGE("AddVirtualInputDevice failed");
3167 return ret;
3168 }
3169 WRITEINT32(reply, deviceId);
3170 return RET_OK;
3171 }
3172
StubRemoveVirtualInputDevice(MessageParcel & data,MessageParcel & reply)3173 int32_t MultimodalInputConnectStub::StubRemoveVirtualInputDevice(MessageParcel& data, MessageParcel& reply)
3174 {
3175 CALL_DEBUG_ENTER;
3176 if (!PER_HELPER->VerifySystemApp()) {
3177 MMI_HILOGE("Verify system APP failed");
3178 return ERROR_NOT_SYSAPI;
3179 }
3180 int32_t deviceId { -1 };
3181 READINT32(data, deviceId, IPC_PROXY_DEAD_OBJECT_ERR);
3182 if (deviceId < 0) {
3183 MMI_HILOGE("invalid deviceId :%{public}d", deviceId);
3184 return RET_ERR;
3185 }
3186 int32_t ret = RemoveVirtualInputDevice(deviceId);
3187 if (ret != RET_OK) {
3188 MMI_HILOGE("RemoveVirtualInputDevice failed");
3189 return ret;
3190 }
3191 WRITEINT32(reply, ret);
3192 return RET_OK;
3193 }
3194
3195 #ifdef OHOS_BUILD_ENABLE_ANCO
StubAncoAddChannel(MessageParcel & data,MessageParcel & reply)3196 int32_t MultimodalInputConnectStub::StubAncoAddChannel(MessageParcel& data, MessageParcel& reply)
3197 {
3198 CALL_DEBUG_ENTER;
3199 if (!PER_HELPER->VerifySystemApp()) {
3200 MMI_HILOGE("Verify system APP failed");
3201 return ERROR_NOT_SYSAPI;
3202 }
3203 sptr<IRemoteObject> remoteObj = data.ReadRemoteObject();
3204 CHKPR(remoteObj, ERR_INVALID_VALUE);
3205 sptr<IAncoChannel> channel = iface_cast<IAncoChannel>(remoteObj);
3206 CHKPR(channel, ERROR_NULL_POINTER);
3207 int32_t ret = AncoAddChannel(channel);
3208 if (ret != RET_OK) {
3209 MMI_HILOGE("AncoAddChannel fail, error:%{public}d", ret);
3210 }
3211 WRITEINT32(reply, ret);
3212 return ret;
3213 }
3214
StubAncoRemoveChannel(MessageParcel & data,MessageParcel & reply)3215 int32_t MultimodalInputConnectStub::StubAncoRemoveChannel(MessageParcel& data, MessageParcel& reply)
3216 {
3217 CALL_DEBUG_ENTER;
3218 if (!PER_HELPER->VerifySystemApp()) {
3219 MMI_HILOGE("Verify system APP failed");
3220 return ERROR_NOT_SYSAPI;
3221 }
3222 sptr<IRemoteObject> remoteObj = data.ReadRemoteObject();
3223 CHKPR(remoteObj, ERR_INVALID_VALUE);
3224 sptr<IAncoChannel> channel = iface_cast<IAncoChannel>(remoteObj);
3225 CHKPR(channel, ERROR_NULL_POINTER);
3226 int32_t ret = AncoRemoveChannel(channel);
3227 if (ret != RET_OK) {
3228 MMI_HILOGE("AncoRemoveChannel fail, error:%{public}d", ret);
3229 }
3230 WRITEINT32(reply, ret);
3231 return ret;
3232 }
3233
StubCheckKnuckleEvent(MessageParcel & data,MessageParcel & reply)3234 int32_t MultimodalInputConnectStub::StubCheckKnuckleEvent(MessageParcel &data, MessageParcel &reply)
3235 {
3236 CALL_DEBUG_ENTER;
3237 if (!PER_HELPER->VerifySystemApp()) {
3238 MMI_HILOGE("Verify system APP failed");
3239 return ERROR_NOT_SYSAPI;
3240 }
3241 float pointX = 0;
3242 float pointY = 0;
3243 bool touchType = false;
3244 READFLOAT(data, pointX, RET_ERR);
3245 READFLOAT(data, pointY, RET_ERR);
3246 int32_t ret = CheckKnuckleEvent(pointX, pointY, touchType);
3247 if (ret != RET_OK) {
3248 MMI_HILOGE("Call CheckKnuckleEvent failed:%{public}d", ret);
3249 return ret;
3250 }
3251
3252 WRITEBOOL(reply, touchType, RET_ERR);
3253 return RET_OK;
3254 }
3255 #endif // OHOS_BUILD_ENABLE_ANCO
3256
StubTransferBinderClientService(MessageParcel & data,MessageParcel & reply)3257 int32_t MultimodalInputConnectStub::StubTransferBinderClientService(MessageParcel& data, MessageParcel& reply)
3258 {
3259 CALL_DEBUG_ENTER;
3260 sptr<IRemoteObject> remoteObj = data.ReadRemoteObject();
3261 CHKPR(remoteObj, ERROR_NULL_POINTER);
3262 int32_t ret = TransferBinderClientSrv(remoteObj);
3263 if (ret != RET_OK) {
3264 MMI_HILOGE("TransferBinderClientSrv failed");
3265 return ret;
3266 }
3267 WRITEINT32(reply, ret);
3268 return RET_OK;
3269 }
3270
StubSkipPointerLayer(MessageParcel & data,MessageParcel & reply)3271 int32_t MultimodalInputConnectStub::StubSkipPointerLayer(MessageParcel& data, MessageParcel& reply)
3272 {
3273 CALL_DEBUG_ENTER;
3274 if (!PER_HELPER->VerifySystemApp()) {
3275 MMI_HILOGE("Verify system APP failed");
3276 return ERROR_NOT_SYSAPI;
3277 }
3278 bool isSkip = true;
3279 READBOOL(data, isSkip, IPC_PROXY_DEAD_OBJECT_ERR);
3280 int32_t ret = SkipPointerLayer(isSkip);
3281 if (ret != RET_OK) {
3282 MMI_HILOGE("Call SkipPointerLayer failed, ret:%{public}d", ret);
3283 return ret;
3284 }
3285 MMI_HILOGD("Success isSkip:%{public}d, pid:%{public}d", isSkip, GetCallingPid());
3286 return RET_OK;
3287 }
3288
StubSetClientInfo(MessageParcel & data,MessageParcel & reply)3289 int32_t MultimodalInputConnectStub::StubSetClientInfo(MessageParcel &data, MessageParcel &reply)
3290 {
3291 CALL_DEBUG_ENTER;
3292 if (!IsRunning()) {
3293 MMI_HILOGE("Service is not running");
3294 return MMISERVICE_NOT_RUNNING;
3295 }
3296 int32_t pid = GetCallingPid();
3297 uint64_t readThreadId = 0;
3298 READUINT64(data, readThreadId, IPC_PROXY_DEAD_OBJECT_ERR);
3299 if (readThreadId < 0) {
3300 MMI_HILOGE("invalid readThreadId :%{public}" PRIu64, readThreadId);
3301 return RET_ERR;
3302 }
3303 int32_t ret = SetClientInfo(pid, readThreadId);
3304 if (ret != RET_OK) {
3305 MMI_HILOGE("Failed to call SetClientInfo, ret:%{public}d", ret);
3306 }
3307 return ret;
3308 }
3309
StubGetIntervalSinceLastInput(MessageParcel & data,MessageParcel & reply)3310 int32_t MultimodalInputConnectStub::StubGetIntervalSinceLastInput(MessageParcel& data, MessageParcel& reply)
3311 {
3312 CALL_DEBUG_ENTER;
3313 int64_t timeInterval = 0;
3314 int32_t ret = GetIntervalSinceLastInput(timeInterval);
3315 if (ret != RET_OK) {
3316 MMI_HILOGE("Failed to call StubGetIntervalSinceLastInput ret:%{public}d", ret);
3317 } else {
3318 WRITEINT64(reply, timeInterval);
3319 }
3320 return ret;
3321 }
3322
StubGetAllSystemHotkeys(MessageParcel & data,MessageParcel & reply)3323 int32_t MultimodalInputConnectStub::StubGetAllSystemHotkeys(MessageParcel& data, MessageParcel& reply)
3324 {
3325 CALL_DEBUG_ENTER;
3326 std::vector<std::unique_ptr<KeyOption>> keyOptions;
3327 int32_t ret = GetAllSystemHotkeys(keyOptions);
3328 if (ret != RET_OK) {
3329 MMI_HILOGD("Call GetAllSystemHotkeys failed ret:%{public}d", ret);
3330 return RET_ERR;
3331 }
3332 WRITEINT32(reply, static_cast<int32_t>(keyOptions.size()), IPC_STUB_WRITE_PARCEL_ERR);
3333 MMI_HILOGD("keyOptionsCount size:%{public}d", static_cast<int32_t>(keyOptions.size()));
3334 for (const auto &item : keyOptions) {
3335 if (!item->WriteToParcel(reply)) {
3336 MMI_HILOGE("Write keyOption failed");
3337 return IPC_STUB_WRITE_PARCEL_ERR;
3338 }
3339 }
3340 return ret;
3341 }
3342
StubSetInputDeviceInputEnable(MessageParcel & data,MessageParcel & reply)3343 int32_t MultimodalInputConnectStub::StubSetInputDeviceInputEnable(MessageParcel& data, MessageParcel& reply)
3344 {
3345 CALL_DEBUG_ENTER;
3346 if (!IsRunning()) {
3347 MMI_HILOGE("Service is not running");
3348 return MMISERVICE_NOT_RUNNING;
3349 }
3350 if (!PER_HELPER->VerifySystemApp()) {
3351 MMI_HILOGE("Verify system APP failed");
3352 return ERROR_NOT_SYSAPI;
3353 }
3354 if (!PER_HELPER->CheckInputDeviceController()) {
3355 MMI_HILOGE("Controller permission check failed");
3356 return ERROR_NO_PERMISSION;
3357 }
3358 int32_t deviceId = 0;
3359 bool enable = true;
3360 int32_t index = 0;
3361 READINT32(data, deviceId, IPC_PROXY_DEAD_OBJECT_ERR);
3362 READBOOL(data, enable, IPC_PROXY_DEAD_OBJECT_ERR);
3363 READINT32(data, index, IPC_PROXY_DEAD_OBJECT_ERR);
3364 if (deviceId < 0) {
3365 MMI_HILOGE("invalid deviceId :%{public}d", deviceId);
3366 return RET_ERR;
3367 }
3368 int32_t ret = SetInputDeviceEnabled(deviceId, enable, index);
3369 if (ret != RET_OK) {
3370 MMI_HILOGE("Set inputdevice device input failed ret:%{public}d", ret);
3371 return ERROR_DEVICE_NOT_EXIST;
3372 }
3373 return RET_OK;
3374 }
3375
StubShiftAppPointerEvent(MessageParcel & data,MessageParcel & reply)3376 int32_t MultimodalInputConnectStub::StubShiftAppPointerEvent(MessageParcel& data, MessageParcel& reply)
3377 {
3378 CALL_DEBUG_ENTER;
3379 if (!PER_HELPER->VerifySystemApp()) {
3380 MMI_HILOGE("Verify system APP failed");
3381 return ERROR_NOT_SYSAPI;
3382 }
3383 if (!IsRunning()) {
3384 MMI_HILOGE("Service is not running");
3385 return MMISERVICE_NOT_RUNNING;
3386 }
3387 ShiftWindowParam param;
3388 READINT32(data, param.sourceWindowId, ERR_INVALID_VALUE);
3389 READINT32(data, param.targetWindowId, ERR_INVALID_VALUE);
3390 READINT32(data, param.x, ERR_INVALID_VALUE);
3391 READINT32(data, param.y, ERR_INVALID_VALUE);
3392 bool autoGenDown = true;
3393 READBOOL(data, autoGenDown, IPC_PROXY_DEAD_OBJECT_ERR);
3394 int32_t ret = ShiftAppPointerEvent(param, autoGenDown);
3395 if (ret != RET_OK) {
3396 MMI_HILOGE("shift AppPointerEvent failed, ret:%{public}d", ret);
3397 }
3398 return ret;
3399 }
3400
StubSetCustomMouseCursor(MessageParcel & data,MessageParcel & reply)3401 int32_t MultimodalInputConnectStub::StubSetCustomMouseCursor(MessageParcel& data, MessageParcel& reply)
3402 {
3403 CALL_DEBUG_ENTER;
3404 if (!IsRunning()) {
3405 MMI_HILOGE("Service is not running");
3406 return MMISERVICE_NOT_RUNNING;
3407 }
3408 int32_t windowId = 0;
3409 CustomCursor cursor;
3410 CursorOptions options;
3411 READINT32(data, windowId, IPC_PROXY_DEAD_OBJECT_ERR);
3412 OHOS::Media::PixelMap* pixelMapPtr = Media::PixelMap::Unmarshalling(data);
3413 CHKPR(pixelMapPtr, RET_ERR);
3414 cursor.pixelMap = (void*)pixelMapPtr;
3415 READINT32(data, cursor.focusX, IPC_PROXY_DEAD_OBJECT_ERR);
3416 READINT32(data, cursor.focusY, IPC_PROXY_DEAD_OBJECT_ERR);
3417 READBOOL(data, options.followSystem, IPC_PROXY_DEAD_OBJECT_ERR);
3418
3419 int32_t ret = SetCustomCursor(windowId, cursor, options);
3420 if (ret != RET_OK) {
3421 MMI_HILOGE("Call SetCustomCursor failed:%{public}d", ret);
3422 return ret;
3423 }
3424 return RET_OK;
3425 }
3426
StubSetMultiWindowScreenId(MessageParcel & data,MessageParcel & reply)3427 int32_t MultimodalInputConnectStub::StubSetMultiWindowScreenId(MessageParcel &data, MessageParcel &reply)
3428 {
3429 CALL_DEBUG_ENTER;
3430 if (!PER_HELPER->VerifySystemApp()) {
3431 MMI_HILOGE("Verify system APP failed");
3432 return ERROR_NOT_SYSAPI;
3433 }
3434 uint64_t screenId = 0;
3435 uint64_t displayNodeScreenId = 0;
3436 READUINT64(data, screenId, IPC_PROXY_DEAD_OBJECT_ERR);
3437 READUINT64(data, displayNodeScreenId, IPC_PROXY_DEAD_OBJECT_ERR);
3438 int32_t ret = SetMultiWindowScreenId(screenId, displayNodeScreenId);
3439 if (ret != RET_OK) {
3440 MMI_HILOGE("Call SkipPointerLayer failed, ret:%{public}d", ret);
3441 return ret;
3442 }
3443 return RET_OK;
3444 }
3445 } // namespace MMI
3446 } // namespace OHOS
3447