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 "input_event_data_transformation.h"
17
18 #include "define_multimodal.h"
19
20 namespace OHOS {
21 namespace MMI {
22 namespace {
23 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = { LOG_CORE, MMI_LOG_DOMAIN, "KeyEventDataTransformation" };
24 } // namespace
25
KeyEventToNetPacket(const std::shared_ptr<KeyEvent> key,NetPacket & pkt)26 int32_t InputEventDataTransformation::KeyEventToNetPacket(
27 const std::shared_ptr<KeyEvent> key, NetPacket &pkt)
28 {
29 if (SerializeInputEvent(key, pkt) != RET_OK) {
30 MMI_HILOGE("Serialize input event failed");
31 return RET_ERR;
32 }
33 pkt << key->GetKeyCode() << key->GetKeyAction();
34 auto keys = key->GetKeyItems();
35 int32_t size = static_cast<int32_t>(keys.size());
36 if (size > MAX_KEY_SIZE) {
37 MMI_HILOGE("Key exceeds the max range");
38 return RET_ERR;
39 }
40 pkt << size;
41 for (const auto &item : keys) {
42 pkt << item.GetKeyCode() << item.GetDownTime()
43 << item.GetDeviceId() << item.IsPressed() << item.GetUnicode();
44 }
45 pkt << key->GetFunctionKey(KeyEvent::NUM_LOCK_FUNCTION_KEY)
46 << key->GetFunctionKey(KeyEvent::CAPS_LOCK_FUNCTION_KEY)
47 << key->GetFunctionKey(KeyEvent::SCROLL_LOCK_FUNCTION_KEY);
48 if (pkt.ChkRWError()) {
49 MMI_HILOGE("Packet write key event failed");
50 return RET_ERR;
51 }
52 return RET_OK;
53 }
54
NetPacketToKeyEvent(NetPacket & pkt,std::shared_ptr<KeyEvent> key)55 int32_t InputEventDataTransformation::NetPacketToKeyEvent(NetPacket &pkt, std::shared_ptr<KeyEvent> key)
56 {
57 if (DeserializeInputEvent(pkt, key) != RET_OK) {
58 MMI_HILOGE("Deserialize input event failed");
59 return RET_ERR;
60 }
61 int32_t data = 0;
62 pkt >> data;
63 key->SetKeyCode(data);
64 pkt >> data;
65 key->SetKeyAction(data);
66 int32_t size = 0;
67 pkt >> size;
68 if (size > MAX_KEY_SIZE) {
69 MMI_HILOGE("Key exceeds the max range");
70 return RET_ERR;
71 }
72 if (pkt.ChkRWError()) {
73 MMI_HILOGE("Packet read size failed");
74 return RET_ERR;
75 }
76 bool isPressed = false;
77 for (int32_t i = 0; i < size; i++) {
78 KeyEvent::KeyItem keyItem;
79 pkt >> data;
80 keyItem.SetKeyCode(data);
81 int64_t datatime = 0;
82 pkt >> datatime;
83 keyItem.SetDownTime(datatime);
84 pkt >> data;
85 keyItem.SetDeviceId(data);
86 pkt >> isPressed;
87 if (pkt.ChkRWError()) {
88 MMI_HILOGE("Packet read item isPressed failed");
89 return RET_ERR;
90 }
91 keyItem.SetPressed(isPressed);
92 uint32_t unicode;
93 pkt >> unicode;
94 keyItem.SetUnicode(unicode);
95 key->AddKeyItem(keyItem);
96 }
97 bool state = false;
98 pkt >> state;
99 key->SetFunctionKey(KeyEvent::NUM_LOCK_FUNCTION_KEY, state);
100 pkt >> state;
101 key->SetFunctionKey(KeyEvent::CAPS_LOCK_FUNCTION_KEY, state);
102 pkt >> state;
103 key->SetFunctionKey(KeyEvent::SCROLL_LOCK_FUNCTION_KEY, state);
104 return RET_OK;
105 }
106
SerializeInputEvent(std::shared_ptr<InputEvent> event,NetPacket & pkt)107 int32_t InputEventDataTransformation::SerializeInputEvent(std::shared_ptr<InputEvent> event, NetPacket &pkt)
108 {
109 CHKPR(event, ERROR_NULL_POINTER);
110 pkt << event->GetEventType() << event->GetId() << event->GetActionTime()
111 << event->GetAction() << event->GetActionStartTime() << event->GetDeviceId()
112 << event->GetTargetDisplayId() << event->GetTargetWindowId()
113 << event->GetAgentWindowId() << event->GetFlag();
114 if (pkt.ChkRWError()) {
115 MMI_HILOGE("Serialize packet is failed");
116 return RET_ERR;
117 }
118 return RET_OK;
119 }
120
DeserializeInputEvent(NetPacket & pkt,std::shared_ptr<InputEvent> event)121 int32_t InputEventDataTransformation::DeserializeInputEvent(NetPacket &pkt, std::shared_ptr<InputEvent> event)
122 {
123 CHKPR(event, ERROR_NULL_POINTER);
124 int32_t tField = 0;
125 pkt >> tField;
126 pkt >> tField;
127 event->SetId(tField);
128 int64_t rField = 0;
129 pkt >> rField;
130 event->SetActionTime(rField);
131 pkt >> tField;
132 event->SetAction(tField);
133 pkt >> rField;
134 event->SetActionStartTime(rField);
135 pkt >> tField;
136 event->SetDeviceId(tField);
137 pkt >> tField;
138 event->SetTargetDisplayId(tField);
139 pkt >> tField;
140 event->SetTargetWindowId(tField);
141 pkt >> tField;
142 event->SetAgentWindowId(tField);
143 uint32_t tFlag = InputEvent::EVENT_FLAG_NONE;
144 pkt >> tFlag;
145 if (pkt.ChkRWError()) {
146 MMI_HILOGE("Deserialize packet is failed");
147 return RET_ERR;
148 }
149 event->AddFlag(tFlag);
150 return RET_OK;
151 }
152
Marshalling(std::shared_ptr<PointerEvent> event,NetPacket & pkt)153 int32_t InputEventDataTransformation::Marshalling(std::shared_ptr<PointerEvent> event, NetPacket &pkt)
154 {
155 CHKPR(event, ERROR_NULL_POINTER);
156 if (SerializeInputEvent(event, pkt) != RET_OK) {
157 MMI_HILOGE("Serialize input event failed");
158 return RET_ERR;
159 }
160
161 pkt << event->GetPointerAction() << event->GetPointerId() << event->GetSourceType() << event->GetButtonId()
162 << event->GetAxes();
163
164 if (event->HasAxis(PointerEvent::AXIS_TYPE_SCROLL_VERTICAL)) {
165 pkt << event->GetAxisValue(PointerEvent::AXIS_TYPE_SCROLL_VERTICAL);
166 }
167 if (event->HasAxis(PointerEvent::AXIS_TYPE_SCROLL_HORIZONTAL)) {
168 pkt << event->GetAxisValue(PointerEvent::AXIS_TYPE_SCROLL_HORIZONTAL);
169 }
170 if (event->HasAxis(PointerEvent::AXIS_TYPE_PINCH)) {
171 pkt << event->GetAxisValue(PointerEvent::AXIS_TYPE_PINCH);
172 }
173
174 std::set<int32_t> pressedBtns { event->GetPressedButtons() };
175 pkt << pressedBtns.size();
176 for (int32_t btnId : pressedBtns) {
177 pkt << btnId;
178 }
179
180 std::vector<int32_t> pointerIds { event->GetPointerIds() };
181 pkt << pointerIds.size();
182 for (const auto &pointerId : pointerIds) {
183 PointerEvent::PointerItem item;
184 if (!event->GetPointerItem(pointerId, item)) {
185 MMI_HILOGE("Get pointer item failed");
186 return RET_ERR;
187 }
188 if (SerializePointerItem(pkt, item) != RET_OK) {
189 MMI_HILOGE("Serialize pointer item failed");
190 return RET_ERR;
191 }
192 }
193
194 std::vector<int32_t> pressedKeys = event->GetPressedKeys();
195 pkt << pressedKeys.size();
196 for (const auto &keyCode : pressedKeys) {
197 pkt << keyCode;
198 }
199 if (pkt.ChkRWError()) {
200 MMI_HILOGE("Marshalling pointer event failed");
201 return RET_ERR;
202 }
203 return RET_OK;
204 }
205
Unmarshalling(NetPacket & pkt,std::shared_ptr<PointerEvent> event)206 int32_t InputEventDataTransformation::Unmarshalling(NetPacket &pkt, std::shared_ptr<PointerEvent> event)
207 {
208 if (DeserializeInputEvent(pkt, event) != RET_OK) {
209 MMI_HILOGE("Deserialize input event failed");
210 return RET_ERR;
211 }
212 int32_t tField;
213 pkt >> tField;
214 event->SetPointerAction(tField);
215 pkt >> tField;
216 event->SetPointerId(tField);
217 pkt >> tField;
218 event->SetSourceType(tField);
219 pkt >> tField;
220 event->SetButtonId(tField);
221 uint32_t tAxes;
222 pkt >> tAxes;
223 double axisValue;
224 if (PointerEvent::HasAxis(tAxes, PointerEvent::AXIS_TYPE_SCROLL_VERTICAL)) {
225 pkt >> axisValue;
226 event->SetAxisValue(PointerEvent::AXIS_TYPE_SCROLL_VERTICAL, axisValue);
227 }
228 if (PointerEvent::HasAxis(tAxes, PointerEvent::AXIS_TYPE_SCROLL_HORIZONTAL)) {
229 pkt >> axisValue;
230 event->SetAxisValue(PointerEvent::AXIS_TYPE_SCROLL_HORIZONTAL, axisValue);
231 }
232 if (PointerEvent::HasAxis(tAxes, PointerEvent::AXIS_TYPE_PINCH)) {
233 pkt >> axisValue;
234 event->SetAxisValue(PointerEvent::AXIS_TYPE_PINCH, axisValue);
235 }
236
237 std::set<int32_t>::size_type nPressed;
238 pkt >> nPressed;
239 while (nPressed-- > 0) {
240 pkt >> tField;
241 event->SetButtonPressed(tField);
242 }
243
244 std::vector<int32_t>::size_type pointerCnt;
245 pkt >> pointerCnt;
246 while (pointerCnt-- > 0) {
247 PointerEvent::PointerItem item;
248 if (DeserializePointerItem(pkt, item) != RET_OK) {
249 MMI_HILOGE("Deserialize pointer item failed");
250 return RET_ERR;
251 }
252 event->AddPointerItem(item);
253 }
254
255 std::vector<int32_t> pressedKeys;
256 std::vector<int32_t>::size_type pressedKeySize;
257 pkt >> pressedKeySize;
258 while (pressedKeySize-- > 0) {
259 pkt >> tField;
260 pressedKeys.push_back(tField);
261 }
262 if (pkt.ChkRWError()) {
263 MMI_HILOGE("Unmarshalling pointer event failed");
264 return RET_ERR;
265 }
266 event->SetPressedKeys(pressedKeys);
267 return RET_OK;
268 }
269
SerializePointerItem(NetPacket & pkt,PointerEvent::PointerItem & item)270 int32_t InputEventDataTransformation::SerializePointerItem(NetPacket &pkt, PointerEvent::PointerItem &item)
271 {
272 pkt << item;
273 if (pkt.ChkRWError()) {
274 MMI_HILOGE("Packet write pointer item failed");
275 return RET_ERR;
276 }
277 return RET_OK;
278 }
279
DeserializePointerItem(NetPacket & pkt,PointerEvent::PointerItem & item)280 int32_t InputEventDataTransformation::DeserializePointerItem(NetPacket &pkt, PointerEvent::PointerItem &item)
281 {
282 pkt >> item;
283 if (pkt.ChkRWError()) {
284 MMI_HILOGE("Packet read pointer item failed");
285 return RET_ERR;
286 }
287 return RET_OK;
288 }
289 } // namespace MMI
290 } // namespace OHOS