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