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