1 /*
2 * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "input_event_data_transformation.h"
17
18 #include "extra_data.h"
19 #ifdef OHOS_BUILD_ENABLE_SECURITY_COMPONENT
20 #include "sec_comp_enhance_kit.h"
21 #endif // OHOS_BUILD_ENABLE_SECURITY_COMPONENT
22
23 #undef MMI_LOG_TAG
24 #define MMI_LOG_TAG "KeyEventDataTransformation"
25
26 namespace OHOS {
27 namespace MMI {
28 namespace {
29 constexpr size_t MAX_PRESSED_BUTTONS { 10 };
30 constexpr size_t MAX_POINTER_COUNT { 10 };
31 constexpr size_t MAX_PRESSED_KEY_NUM { 10 };
32 #ifdef OHOS_BUILD_ENABLE_SECURITY_COMPONENT
33 constexpr uint32_t MAX_ENHANCE_DATA_LEN { 1000 };
34 #endif // OHOS_BUILD_ENABLE_SECURITY_COMPONENT
35 } // namespace
36
KeyEventToNetPacket(const std::shared_ptr<KeyEvent> key,NetPacket & pkt)37 int32_t InputEventDataTransformation::KeyEventToNetPacket(
38 const std::shared_ptr<KeyEvent> key, NetPacket &pkt)
39 {
40 CHKPR(key, RET_ERR);
41 if (SerializeInputEvent(key, pkt) != RET_OK) {
42 MMI_HILOGE("Serialize input event failed");
43 return RET_ERR;
44 }
45 pkt << key->GetKeyCode() << key->GetKeyAction() << key->GetKeyIntention() << key->IsRepeatKey();
46 auto keys = key->GetKeyItems();
47 int32_t size = static_cast<int32_t>(keys.size());
48 if (size > MAX_KEY_SIZE) {
49 MMI_HILOGE("Key exceeds the max range");
50 return RET_ERR;
51 }
52 pkt << size;
53 for (const auto &item : keys) {
54 pkt << item.GetKeyCode() << item.GetDownTime()
55 << item.GetDeviceId() << item.IsPressed() << item.GetUnicode();
56 }
57 pkt << key->GetFunctionKey(KeyEvent::NUM_LOCK_FUNCTION_KEY)
58 << key->GetFunctionKey(KeyEvent::CAPS_LOCK_FUNCTION_KEY)
59 << key->GetFunctionKey(KeyEvent::SCROLL_LOCK_FUNCTION_KEY);
60 if (pkt.ChkRWError()) {
61 MMI_HILOGE("Packet write key event failed");
62 return RET_ERR;
63 }
64 return RET_OK;
65 }
66
NetPacketToKeyEvent(NetPacket & pkt,std::shared_ptr<KeyEvent> key)67 int32_t InputEventDataTransformation::NetPacketToKeyEvent(NetPacket &pkt, std::shared_ptr<KeyEvent> key)
68 {
69 if (DeserializeInputEvent(pkt, key) != RET_OK) {
70 MMI_HILOGE("Deserialize input event failed");
71 return RET_ERR;
72 }
73 int32_t data = 0;
74 pkt >> data;
75 key->SetKeyCode(data);
76 pkt >> data;
77 key->SetKeyAction(data);
78 pkt >> data;
79 key->SetKeyIntention(data);
80 bool isRepeatKey { false };
81 pkt >> isRepeatKey;
82 key->SetRepeatKey(isRepeatKey);
83 int32_t size = 0;
84 pkt >> size;
85 if (size > MAX_KEY_SIZE) {
86 MMI_HILOGE("Key exceeds the max range");
87 return RET_ERR;
88 }
89 if (pkt.ChkRWError()) {
90 MMI_HILOGE("Packet read size failed");
91 return RET_ERR;
92 }
93 bool isPressed = false;
94 for (int32_t i = 0; i < size; i++) {
95 KeyEvent::KeyItem keyItem;
96 pkt >> data;
97 keyItem.SetKeyCode(data);
98 int64_t datatime = 0;
99 pkt >> datatime;
100 keyItem.SetDownTime(datatime);
101 pkt >> data;
102 keyItem.SetDeviceId(data);
103 pkt >> isPressed;
104 if (pkt.ChkRWError()) {
105 MMI_HILOGE("Packet read item isPressed failed");
106 return RET_ERR;
107 }
108 keyItem.SetPressed(isPressed);
109 uint32_t unicode;
110 pkt >> unicode;
111 keyItem.SetUnicode(unicode);
112 key->AddKeyItem(keyItem);
113 }
114 ReadFunctionKeys(pkt, key);
115 return RET_OK;
116 }
117
ReadFunctionKeys(NetPacket & pkt,std::shared_ptr<KeyEvent> key)118 void InputEventDataTransformation::ReadFunctionKeys(NetPacket &pkt, std::shared_ptr<KeyEvent> key)
119 {
120 CHKPV(key);
121 bool state = false;
122 pkt >> state;
123 key->SetFunctionKey(KeyEvent::NUM_LOCK_FUNCTION_KEY, state);
124 pkt >> state;
125 key->SetFunctionKey(KeyEvent::CAPS_LOCK_FUNCTION_KEY, state);
126 pkt >> state;
127 key->SetFunctionKey(KeyEvent::SCROLL_LOCK_FUNCTION_KEY, state);
128 }
129
SwitchEventToNetPacket(const std::shared_ptr<SwitchEvent> swEvent,NetPacket & pkt)130 int32_t InputEventDataTransformation::SwitchEventToNetPacket(
131 const std::shared_ptr<SwitchEvent> swEvent, NetPacket &pkt)
132 {
133 if (SerializeInputEvent(swEvent, pkt) != RET_OK) {
134 MMI_HILOGE("Serialize input event failed");
135 return RET_ERR;
136 }
137 pkt << swEvent->GetSwitchType() << swEvent->GetSwitchValue() << swEvent->GetSwitchMask();
138 if (pkt.ChkRWError()) {
139 MMI_HILOGE("Packet write key event failed");
140 return RET_ERR;
141 }
142 return RET_OK;
143 }
144
NetPacketToSwitchEvent(NetPacket & pkt,std::shared_ptr<SwitchEvent> swEvent)145 int32_t InputEventDataTransformation::NetPacketToSwitchEvent(NetPacket &pkt, std::shared_ptr<SwitchEvent> swEvent)
146 {
147 if (DeserializeInputEvent(pkt, swEvent) != RET_OK) {
148 MMI_HILOGE("Deserialize input event failed");
149 return RET_ERR;
150 }
151 int32_t data = 0;
152 pkt >> data;
153 swEvent->SetSwitchType(data);
154 pkt >> data;
155 swEvent->SetSwitchValue(data);
156 pkt >> data;
157 swEvent->SetSwitchMask(data);
158 return RET_OK;
159 }
160
LongPressEventToNetPacket(const LongPressEvent & longPressEvent,NetPacket & pkt)161 int32_t InputEventDataTransformation::LongPressEventToNetPacket(const LongPressEvent &longPressEvent, NetPacket &pkt)
162 {
163 pkt << longPressEvent.fingerCount << longPressEvent.duration << longPressEvent.pid << longPressEvent.displayId
164 << longPressEvent.displayX << longPressEvent.displayY << longPressEvent.result << longPressEvent.windowId
165 << longPressEvent.pointerId << longPressEvent.downTime;
166 if (!pkt.Write(longPressEvent.bundleName)) {
167 MMI_HILOGE("Packet write long press event failed");
168 return RET_ERR;
169 }
170 if (pkt.ChkRWError()) {
171 MMI_HILOGE("Packet write key event failed");
172 return RET_ERR;
173 }
174 return RET_OK;
175 }
176
NetPacketToLongPressEvent(NetPacket & pkt,LongPressEvent & longPressEvent)177 int32_t InputEventDataTransformation::NetPacketToLongPressEvent(NetPacket &pkt, LongPressEvent &longPressEvent)
178 {
179 int32_t data = 0;
180 pkt >> data;
181 longPressEvent.fingerCount = data;
182 pkt >> data;
183 longPressEvent.duration = data;
184 pkt >> data;
185 longPressEvent.pid = data;
186 pkt >> data;
187 longPressEvent.displayId = data;
188 pkt >> data;
189 longPressEvent.displayX = data;
190 pkt >> data;
191 longPressEvent.displayY = data;
192 pkt >> data;
193 longPressEvent.result = data;
194 pkt >> data;
195 longPressEvent.windowId = data;
196 pkt >> data;
197 longPressEvent.pointerId = data;
198 int64_t downTime;
199 pkt >> downTime;
200 longPressEvent.downTime = downTime;
201 if (!pkt.Read(longPressEvent.bundleName)) {
202 MMI_HILOGE("Packet read long press event failed");
203 return RET_ERR;
204 }
205 return RET_OK;
206 }
207
SerializeInputEvent(std::shared_ptr<InputEvent> event,NetPacket & pkt)208 int32_t InputEventDataTransformation::SerializeInputEvent(std::shared_ptr<InputEvent> event, NetPacket &pkt)
209 {
210 CHKPR(event, ERROR_NULL_POINTER);
211 pkt << event->GetEventType() << event->GetId() << event->GetActionTime()
212 << event->GetAction() << event->GetActionStartTime() << event->GetSensorInputTime() << event->GetDeviceId()
213 << event->GetSourceType() << event->GetTargetDisplayId() << event->GetTargetWindowId()
214 << event->GetAgentWindowId() << event->GetFlag() << event->IsMarkEnabled();
215 if (pkt.ChkRWError()) {
216 MMI_HILOGE("Serialize packet is failed");
217 return RET_ERR;
218 }
219 return RET_OK;
220 }
221
DeserializeInputEvent(NetPacket & pkt,std::shared_ptr<InputEvent> event)222 int32_t InputEventDataTransformation::DeserializeInputEvent(NetPacket &pkt, std::shared_ptr<InputEvent> event)
223 {
224 CHKPR(event, ERROR_NULL_POINTER);
225 int32_t tField = 0;
226 pkt >> tField;
227 pkt >> tField;
228 event->SetId(tField);
229 int64_t rField = 0;
230 pkt >> rField;
231 event->SetActionTime(rField);
232 pkt >> tField;
233 event->SetAction(tField);
234 pkt >> rField;
235 event->SetActionStartTime(rField);
236 uint64_t sensorTime;
237 pkt >> sensorTime;
238 event->SetSensorInputTime(sensorTime);
239 pkt >> tField;
240 event->SetDeviceId(tField);
241 pkt >> tField;
242 event->SetSourceType(tField);
243 pkt >> tField;
244 event->SetTargetDisplayId(tField);
245 pkt >> tField;
246 event->SetTargetWindowId(tField);
247 pkt >> tField;
248 event->SetAgentWindowId(tField);
249 uint32_t tFlag = InputEvent::EVENT_FLAG_NONE;
250 pkt >> tFlag;
251 event->AddFlag(tFlag);
252 bool markEnabled = true;
253 pkt >> markEnabled;
254 event->SetMarkEnabled(markEnabled);
255 if (pkt.ChkRWError()) {
256 MMI_HILOGE("Deserialize packet is failed");
257 return RET_ERR;
258 }
259 return RET_OK;
260 }
261
Marshalling(std::shared_ptr<PointerEvent> event,NetPacket & pkt)262 int32_t InputEventDataTransformation::Marshalling(std::shared_ptr<PointerEvent> event, NetPacket &pkt)
263 {
264 CHKPR(event, ERROR_NULL_POINTER);
265 if (SerializeInputEvent(event, pkt) != RET_OK) {
266 MMI_HILOGE("Serialize input event failed");
267 return RET_ERR;
268 }
269 SerializeFingerprint(event, pkt);
270 SerializePointerEvent(event, pkt);
271 std::set<int32_t> pressedBtns { event->GetPressedButtons() };
272 pkt << pressedBtns.size();
273 for (int32_t btnId : pressedBtns) {
274 pkt << btnId;
275 }
276 std::vector<int32_t> pointerIds { event->GetPointerIds() };
277 pkt << pointerIds.size();
278 for (const auto &pointerId : pointerIds) {
279 PointerEvent::PointerItem item;
280 if (!event->GetPointerItem(pointerId, item)) {
281 MMI_HILOGE("Get pointer item failed");
282 return RET_ERR;
283 }
284 if (SerializePointerItem(pkt, item) != RET_OK) {
285 MMI_HILOGE("Serialize pointer item failed");
286 return RET_ERR;
287 }
288 }
289 std::vector<int32_t> pressedKeys = event->GetPressedKeys();
290 pkt << pressedKeys.size();
291 for (const auto &keyCode : pressedKeys) {
292 pkt << keyCode;
293 }
294 std::vector<uint8_t> buffer = event->GetBuffer();
295 if (buffer.size() > ExtraData::MAX_BUFFER_SIZE) {
296 MMI_HILOGE("The buffer is oversize:%{public}zu", buffer.size());
297 return RET_ERR;
298 }
299 pkt << buffer.size();
300 for (const auto &buf : buffer) {
301 pkt << buf;
302 }
303 pkt << event->GetPullId();
304 pkt << event->GetThrowAngle();
305 pkt << event->GetThrowSpeed();
306 if (pkt.ChkRWError()) {
307 MMI_HILOGE("Marshalling pointer event failed");
308 return RET_ERR;
309 }
310 if (!SerializeSettings(event, pkt)) {
311 MMI_HILOGE("SerializeSettings fail");
312 return RET_ERR;
313 }
314 return RET_OK;
315 }
316
SerializePointerEvent(const std::shared_ptr<PointerEvent> event,NetPacket & pkt)317 void InputEventDataTransformation::SerializePointerEvent(const std::shared_ptr<PointerEvent> event, NetPacket &pkt)
318 {
319 pkt << event->GetPointerAction() << event->GetOriginPointerAction() << event->GetPointerId()
320 << event->GetButtonId() << event->GetFingerCount()
321 << event->GetZOrder() << event->GetDispatchTimes() << event->GetHandlerEventType()
322 << event->GetAxes();
323 for (int32_t i = PointerEvent::AXIS_TYPE_UNKNOWN; i < PointerEvent::AXIS_TYPE_MAX; ++i) {
324 pkt << event->GetAxisValue(static_cast<PointerEvent::AxisType>(i));
325 }
326 pkt << event->GetVelocity();
327 pkt << event->GetAxisEventType();
328 pkt << event->GetHandOption();
329 PointerEvent::FixedMode fixedMode = event->GetFixedMode();
330 if (fixedMode > PointerEvent::FixedMode::SCREEN_MODE_UNKNOWN &&
331 fixedMode < PointerEvent::FixedMode::SCREEN_MODE_MAX) {
332 pkt << static_cast<int32_t>(fixedMode);
333 } else {
334 pkt << static_cast<int32_t>(PointerEvent::FixedMode::SCREEN_MODE_UNKNOWN);
335 }
336 pkt << event->GetAutoToVirtualScreen();
337 #ifdef OHOS_BUILD_ENABLE_ANCO
338 pkt << event->GetAncoDeal();
339 #endif // OHOS_BUILD_ENABLE_ANCO
340 }
341
SerializeFingerprint(const std::shared_ptr<PointerEvent> event,NetPacket & pkt)342 void InputEventDataTransformation::SerializeFingerprint(const std::shared_ptr<PointerEvent> event, NetPacket &pkt)
343 {
344 #ifdef OHOS_BUILD_ENABLE_FINGERPRINT
345 pkt << event->GetFingerprintDistanceX() << event->GetFingerprintDistanceY();
346 #endif // OHOS_BUILD_ENABLE_FINGERPRINT
347 }
348
DeserializePressedButtons(std::shared_ptr<PointerEvent> event,NetPacket & pkt)349 int32_t InputEventDataTransformation::DeserializePressedButtons(std::shared_ptr<PointerEvent> event, NetPacket &pkt)
350 {
351 CHKPR(event, ERROR_NULL_POINTER);
352 int32_t tField;
353 pkt >> tField;
354 event->SetPointerAction(tField);
355 pkt >> tField;
356 event->SetOriginPointerAction(tField);
357 pkt >> tField;
358 event->SetPointerId(tField);
359 pkt >> tField;
360 event->SetButtonId(tField);
361 pkt >> tField;
362 event->SetFingerCount(tField);
363 float zOrder;
364 pkt >> zOrder;
365 event->SetZOrder(zOrder);
366 pkt >> tField;
367 event->SetDispatchTimes(tField);
368 uint32_t type = 0u;
369 pkt >> type;
370 event->SetHandlerEventType(type);
371 SetAxisInfo(pkt, event);
372 pkt >> tField;
373 event->SetHandOption(tField);
374 pkt >> tField;
375 event->SetFixedMode(static_cast<PointerEvent::FixedMode>(tField));
376 bool bField;
377 pkt >> bField;
378 event->SetAutoToVirtualScreen(bField);
379 #ifdef OHOS_BUILD_ENABLE_ANCO
380 pkt >> bField;
381 event->SetAncoDeal(bField);
382 #endif // OHOS_BUILD_ENABLE_ANCO
383
384 std::set<int32_t>::size_type nPressed;
385 pkt >> nPressed;
386 if (nPressed > MAX_PRESSED_BUTTONS) {
387 MMI_HILOGE("Invalid nPressed:%{public}zu", nPressed);
388 return RET_ERR;
389 }
390 while (nPressed-- > 0) {
391 pkt >> tField;
392 event->SetButtonPressed(tField);
393 }
394 return RET_OK;
395 }
396
DeserializePointerIds(std::shared_ptr<PointerEvent> event,NetPacket & pkt)397 int32_t InputEventDataTransformation::DeserializePointerIds(std::shared_ptr<PointerEvent> event, NetPacket &pkt)
398 {
399 CHKPR(event, ERROR_NULL_POINTER);
400 std::vector<int32_t>::size_type pointerCnt;
401 pkt >> pointerCnt;
402 if (pointerCnt > MAX_POINTER_COUNT) {
403 MMI_HILOGE("Invalid pointerCnt:%{public}zu", pointerCnt);
404 return RET_ERR;
405 }
406 while (pointerCnt-- > 0) {
407 PointerEvent::PointerItem item;
408 if (DeserializePointerItem(pkt, item) != RET_OK) {
409 MMI_HILOGE("Deserialize pointer item failed");
410 return RET_ERR;
411 }
412 event->AddPointerItem(item);
413 }
414 return RET_OK;
415 }
416
Unmarshalling(NetPacket & pkt,std::shared_ptr<PointerEvent> event)417 int32_t InputEventDataTransformation::Unmarshalling(NetPacket &pkt, std::shared_ptr<PointerEvent> event)
418 {
419 if (DeserializeInputEvent(pkt, event) != RET_OK) {
420 MMI_HILOGE("Deserialize input event failed");
421 return RET_ERR;
422 }
423
424 #ifdef OHOS_BUILD_ENABLE_FINGERPRINT
425 double distanceX {0.0};
426 double distanceY {0.0};
427 pkt >> distanceX;
428 pkt >> distanceY;
429 event->SetFingerprintDistanceX(distanceX);
430 event->SetFingerprintDistanceY(distanceY);
431 #endif // OHOS_BUILD_ENABLE_FINGERPRINT
432
433 if (DeserializePressedButtons(event, pkt) != RET_OK) {
434 MMI_HILOGE("Deserialize pressed buttons failed");
435 return RET_ERR;
436 }
437
438 if (DeserializePointerIds(event, pkt) != RET_OK) {
439 MMI_HILOGE("Deserialize pressed ids failed");
440 return RET_ERR;
441 }
442
443 std::vector<int32_t> pressedKeys;
444 std::vector<int32_t>::size_type pressedKeySize;
445 int32_t tField;
446 pkt >> pressedKeySize;
447 if (pressedKeySize > MAX_PRESSED_KEY_NUM) {
448 MMI_HILOGE("Invalid pressedKeySize:%{public}zu", pressedKeySize);
449 return RET_ERR;
450 }
451 while (pressedKeySize-- > 0) {
452 pkt >> tField;
453 pressedKeys.push_back(tField);
454 }
455 if (pkt.ChkRWError()) {
456 MMI_HILOGE("Unmarshalling pointer event failed");
457 return RET_ERR;
458 }
459 event->SetPressedKeys(pressedKeys);
460
461 std::vector<uint8_t> buffer;
462 std::vector<uint8_t>::size_type bufferSize;
463 pkt >> bufferSize;
464 if (bufferSize > ExtraData::MAX_BUFFER_SIZE) {
465 MMI_HILOGE("Invalid bufferSize:%{public}zu", bufferSize);
466 return RET_ERR;
467 }
468 uint8_t buff = 0;
469 while (bufferSize-- > 0) {
470 pkt >> buff;
471 buffer.push_back(buff);
472 }
473 pkt >> tField;
474 if (pkt.ChkRWError()) {
475 MMI_HILOGE("Unmarshalling pointer event failed");
476 return RET_ERR;
477 }
478 event->SetBuffer(buffer);
479 event->SetPullId(tField);
480 double throwAngle {0.0};
481 double throwSpeed {0.0};
482 pkt >> throwAngle;
483 pkt >> throwSpeed;
484 event->SetThrowAngle(throwAngle);
485 event->SetThrowSpeed(throwSpeed);
486
487 if (!DeserializeSettings(pkt, event)) {
488 MMI_HILOGE("DeserializeSettings fail");
489 return RET_ERR;
490 }
491 return RET_OK;
492 }
493
SetAxisInfo(NetPacket & pkt,std::shared_ptr<PointerEvent> event)494 void InputEventDataTransformation::SetAxisInfo(NetPacket &pkt, std::shared_ptr<PointerEvent> event)
495 {
496 uint32_t tAxes;
497 pkt >> tAxes;
498 double axisValue;
499 for (int32_t i = PointerEvent::AXIS_TYPE_UNKNOWN; i < PointerEvent::AXIS_TYPE_MAX; ++i) {
500 const PointerEvent::AxisType axisType { static_cast<PointerEvent::AxisType>(i) };
501 pkt >> axisValue;
502 event->SetAxisValue(axisType, axisValue);
503 if (!PointerEvent::HasAxis(tAxes, axisType)) {
504 event->ClearAxisStatus(axisType);
505 }
506 }
507 double velocity;
508 pkt >> velocity;
509 event->SetVelocity(velocity);
510 int32_t axisEventType;
511 pkt >> axisEventType;
512 event->SetAxisEventType(axisEventType);
513 }
514
SerializePointerItem(NetPacket & pkt,PointerEvent::PointerItem & item)515 int32_t InputEventDataTransformation::SerializePointerItem(NetPacket &pkt, PointerEvent::PointerItem &item)
516 {
517 pkt << item;
518 if (pkt.ChkRWError()) {
519 MMI_HILOGE("Packet write pointer item failed");
520 return RET_ERR;
521 }
522 return RET_OK;
523 }
524
DeserializePointerItem(NetPacket & pkt,PointerEvent::PointerItem & item)525 int32_t InputEventDataTransformation::DeserializePointerItem(NetPacket &pkt, PointerEvent::PointerItem &item)
526 {
527 pkt >> item;
528 if (pkt.ChkRWError()) {
529 MMI_HILOGE("Packet read pointer item failed");
530 return RET_ERR;
531 }
532 return RET_OK;
533 }
534
535 #ifdef OHOS_BUILD_ENABLE_SECURITY_COMPONENT
MarshallingEnhanceData(std::shared_ptr<PointerEvent> event,NetPacket & pkt)536 int32_t InputEventDataTransformation::MarshallingEnhanceData(std::shared_ptr<PointerEvent> event, NetPacket &pkt)
537 {
538 CHKPR(event, ERROR_NULL_POINTER);
539 int32_t pointerId = event->GetPointerId();
540 PointerEvent::PointerItem pointerItem;
541 if (!event->GetPointerItem(pointerId, pointerItem)) {
542 MMI_HILOGE("Can't find pointer item, pointer:%{public}d", pointerId);
543 return RET_ERR;
544 }
545 SecCompPointEvent *secCompPointEvent = static_cast<SecCompPointEvent*>(malloc(sizeof(SecCompPointEvent)));
546 if (secCompPointEvent == NULL) {
547 MMI_HILOGE("Malloc failed");
548 return RET_ERR;
549 }
550 if (event->GetFixedMode() == PointerEvent::FixedMode::AUTO) {
551 secCompPointEvent->touchX = pointerItem.GetFixedDisplayX();
552 secCompPointEvent->touchY = pointerItem.GetFixedDisplayY();
553 } else {
554 secCompPointEvent->touchX = pointerItem.GetDisplayX();
555 secCompPointEvent->touchY = pointerItem.GetDisplayY();
556 }
557 secCompPointEvent->timeStamp = event->GetActionTime();
558 uint32_t dataLen = sizeof(*secCompPointEvent);
559 uint8_t outBuf[MAX_HMAC_SIZE] = { 0 };
560 uint8_t* enHanceData = reinterpret_cast<uint8_t *>(&outBuf[0]);
561 uint32_t enHanceDataLen = MAX_HMAC_SIZE;
562 int32_t result = Security::SecurityComponent::SecCompEnhanceKit::GetPointerEventEnhanceData(secCompPointEvent,
563 dataLen, enHanceData, enHanceDataLen);
564 if (result != 0 || enHanceDataLen > MAX_HMAC_SIZE) {
565 pkt << 0;
566 free(secCompPointEvent);
567 secCompPointEvent = nullptr;
568 return RET_ERR;
569 }
570 pkt << enHanceDataLen;
571 std::vector<uint8_t> realBuf;
572 for (size_t i = 0; i < enHanceDataLen; i++) {
573 realBuf.push_back(enHanceData[i]);
574 pkt << realBuf[i];
575 }
576 free(secCompPointEvent);
577 secCompPointEvent = nullptr;
578 if (pkt.ChkRWError()) {
579 MMI_HILOGE("Marshalling enhanceData failed");
580 return RET_ERR;
581 }
582 return RET_OK;
583 }
584
UnmarshallingEnhanceData(NetPacket & pkt,std::shared_ptr<PointerEvent> event)585 int32_t InputEventDataTransformation::UnmarshallingEnhanceData(NetPacket &pkt, std::shared_ptr<PointerEvent> event)
586 {
587 uint32_t enHanceDataLen;
588 pkt >> enHanceDataLen;
589 if (enHanceDataLen == 0) {
590 return RET_OK;
591 }
592 if (enHanceDataLen > MAX_ENHANCE_DATA_LEN) {
593 MMI_HILOGE("Invalid enHanceDataLen:%{public}u", enHanceDataLen);
594 return RET_ERR;
595 }
596 uint8_t enhanceDataBuf[enHanceDataLen];
597 std::vector<uint8_t> enhanceData;
598 for (size_t i = 0; i < enHanceDataLen; i++) {
599 pkt >> enhanceDataBuf[i];
600 enhanceData.push_back(enhanceDataBuf[i]);
601 }
602 if (pkt.ChkRWError()) {
603 MMI_HILOGE("UnmarshallingEnhanceData pointer event failed");
604 return RET_ERR;
605 }
606 event->SetEnhanceData(enhanceData);
607 return RET_OK;
608 }
609
610 struct keyEventEnhanceData {
611 int64_t timestamp;
612 int32_t keyCode;
613 };
614
MarshallingEnhanceData(std::shared_ptr<KeyEvent> event,NetPacket & pkt)615 int32_t InputEventDataTransformation::MarshallingEnhanceData(std::shared_ptr<KeyEvent> event, NetPacket &pkt)
616 {
617 CHKPR(event, ERROR_NULL_POINTER);
618 struct keyEventEnhanceData secCompKeyEvent;
619 secCompKeyEvent.timestamp = event->GetActionTime();
620 secCompKeyEvent.keyCode = event->GetKeyCode();
621 uint32_t dataLen = sizeof(secCompKeyEvent);
622 uint8_t outBuf[MAX_HMAC_SIZE] = { 0 };
623 uint8_t* enHanceData = reinterpret_cast<uint8_t *>(&outBuf[0]);
624 uint32_t enHanceDataLen = MAX_HMAC_SIZE;
625 int32_t result = Security::SecurityComponent::SecCompEnhanceKit::GetPointerEventEnhanceData(&secCompKeyEvent,
626 dataLen, enHanceData, enHanceDataLen);
627 if (result != 0 || enHanceDataLen > MAX_HMAC_SIZE) {
628 pkt << 0;
629 return RET_ERR;
630 }
631 pkt << enHanceDataLen;
632 std::vector<uint8_t> realBuf;
633 for (size_t i = 0; i < enHanceDataLen; i++) {
634 realBuf.push_back(enHanceData[i]);
635 pkt << realBuf[i];
636 }
637 if (pkt.ChkRWError()) {
638 MMI_HILOGE("Marshalling enhanceData failed");
639 return RET_ERR;
640 }
641 return RET_OK;
642 }
643
UnmarshallingEnhanceData(NetPacket & pkt,std::shared_ptr<KeyEvent> event)644 int32_t InputEventDataTransformation::UnmarshallingEnhanceData(NetPacket &pkt, std::shared_ptr<KeyEvent> event)
645 {
646 uint32_t enHanceDataLen;
647 pkt >> enHanceDataLen;
648 if (enHanceDataLen == 0 || enHanceDataLen > MAX_HMAC_SIZE) {
649 return RET_OK;
650 }
651 uint8_t enhanceDataBuf[enHanceDataLen];
652 std::vector<uint8_t> enhanceData;
653 for (size_t i = 0; i < enHanceDataLen; i++) {
654 pkt >> enhanceDataBuf[i];
655 enhanceData.push_back(enhanceDataBuf[i]);
656 }
657 if (pkt.ChkRWError()) {
658 MMI_HILOGE("UnmarshallingEnhanceData key event failed");
659 return RET_ERR;
660 }
661 event->SetEnhanceData(enhanceData);
662 return RET_OK;
663 }
664 #endif // OHOS_BUILD_ENABLE_SECURITY_COMPONENT
665
SerializeSettings(const std::shared_ptr<PointerEvent> event,NetPacket & pkt)666 bool InputEventDataTransformation::SerializeSettings(const std::shared_ptr<PointerEvent> event, NetPacket &pkt)
667 {
668 int32_t setting {};
669
670 setting = event->GetScrollRows();
671 pkt << setting;
672
673 return !pkt.ChkRWError();
674 }
675
DeserializeSettings(NetPacket & pkt,std::shared_ptr<PointerEvent> event)676 bool InputEventDataTransformation::DeserializeSettings(NetPacket &pkt, std::shared_ptr<PointerEvent> event)
677 {
678 int32_t setting {};
679
680 pkt >> setting;
681 event->SetScrollRows(setting);
682
683 return !pkt.ChkRWError();
684 }
685 } // namespace MMI
686 } // namespace OHOS
687