1 /*
2 * Copyright (c) 2021-2025 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.h"
17
18 #include "axis_event.h"
19 #include "event_log_helper.h"
20
21 #undef MMI_LOG_TAG
22 #define MMI_LOG_TAG "InputEvent"
23
24 namespace OHOS {
25 namespace MMI {
26 namespace {
27 int64_t g_nextEventId = 1;
28 constexpr uint32_t DATA_LENGTH_LIMIT { 1024 }; // 1024: max length
29 } // namespace
30
31 std::string EventLogHelper::userType_ = "";
32 std::once_flag EventLogHelper::betaFlag_;
33
InputEvent(int32_t eventType)34 InputEvent::InputEvent(int32_t eventType) : eventType_(eventType)
35 {
36 Reset();
37 }
38
InputEvent(const InputEvent & other)39 InputEvent::InputEvent(const InputEvent& other)
40 : eventType_(other.eventType_), id_(other.id_), actionTime_(other.actionTime_),
41 sensorInputTime_(other.sensorInputTime_), action_(other.action_), actionStartTime_(other.actionStartTime_),
42 deviceId_(other.deviceId_), sourceType_(other.sourceType_), targetDisplayId_(other.targetDisplayId_),
43 targetWindowId_(other.targetWindowId_), agentWindowId_(other.agentWindowId_),
44 bitwise_(other.bitwise_), markEnabled_(other.markEnabled_),
45 extraData_(other.extraData_), extraDataLength_(other.extraDataLength_) {}
46
~InputEvent()47 InputEvent::~InputEvent() {}
48
Reset()49 void InputEvent::Reset()
50 {
51 struct timespec ts = { 0, 0 };
52 if (clock_gettime(CLOCK_MONOTONIC, &ts) != 0) {
53 actionTime_ = 0;
54 }
55 id_ = -1;
56 if (!AddInt64(ts.tv_sec * 1000000, ts.tv_nsec / 1000, actionTime_)) {
57 MMI_HILOGE("The addition of actionTime_ overflows");
58 return;
59 }
60 action_ = ACTION_UNKNOWN;
61 actionStartTime_ = actionTime_;
62 deviceId_ = -1;
63 sourceType_ = SOURCE_TYPE_UNKNOWN;
64 targetDisplayId_ = -1;
65 targetWindowId_ = -1;
66 agentWindowId_ = -1;
67 bitwise_ = EVENT_FLAG_NONE;
68 markEnabled_ = true;
69 }
70
ToString()71 std::string InputEvent::ToString()
72 {
73 std::string eventStr = "eventType:" + std::to_string(eventType_);
74 eventStr += ",actionTime:" + std::to_string(actionTime_);
75 eventStr += ",deviceId:" + std::to_string(deviceId_);
76 eventStr += ",sourceType:" + std::to_string(sourceType_);
77 return eventStr;
78 }
79
Create()80 std::shared_ptr<InputEvent> InputEvent::Create()
81 {
82 auto event = std::shared_ptr<InputEvent>(new (std::nothrow) InputEvent(InputEvent::EVENT_TYPE_BASE));
83 CHKPP(event);
84 return event;
85 }
86
EventTypeToString(int32_t eventType)87 const char* InputEvent::EventTypeToString(int32_t eventType)
88 {
89 switch (eventType) {
90 case InputEvent::EVENT_TYPE_BASE: {
91 return "base";
92 }
93 case InputEvent::EVENT_TYPE_KEY: {
94 return "key";
95 }
96 case InputEvent::EVENT_TYPE_POINTER: {
97 return "pointer";
98 }
99 case InputEvent::EVENT_TYPE_AXIS: {
100 return "axis";
101 }
102 case InputEvent::EVENT_TYPE_FINGERPRINT: {
103 return "fingerprint";
104 }
105 default: {
106 MMI_HILOGW("Unknown EVENT_TYPE");
107 return "unknown";
108 }
109 }
110 }
111
GetId() const112 int32_t InputEvent::GetId() const
113 {
114 return id_;
115 }
116
SetId(int32_t id)117 void InputEvent::SetId(int32_t id)
118 {
119 id_ = id;
120 }
121
UpdateId()122 void InputEvent::UpdateId()
123 {
124 id_ = g_nextEventId++;
125 }
126
GetActionTime() const127 int64_t InputEvent::GetActionTime() const
128 {
129 return actionTime_;
130 }
131
SetActionTime(int64_t actionTime)132 void InputEvent::SetActionTime(int64_t actionTime)
133 {
134 actionTime_ = actionTime;
135 }
136
SetSensorInputTime(uint64_t sensorInputTime)137 void InputEvent::SetSensorInputTime(uint64_t sensorInputTime)
138 {
139 sensorInputTime_ = sensorInputTime;
140 }
141
GetSensorInputTime() const142 uint64_t InputEvent::GetSensorInputTime() const
143 {
144 return sensorInputTime_;
145 }
146
GetAction() const147 int32_t InputEvent::GetAction() const
148 {
149 return action_;
150 }
151
SetAction(int32_t action)152 void InputEvent::SetAction(int32_t action)
153 {
154 action_ = action;
155 }
156
GetActionStartTime() const157 int64_t InputEvent::GetActionStartTime() const
158 {
159 return actionStartTime_;
160 }
161
SetActionStartTime(int64_t actionStartTime)162 void InputEvent::SetActionStartTime(int64_t actionStartTime)
163 {
164 actionStartTime_ = actionStartTime;
165 }
166
GetDeviceId() const167 int32_t InputEvent::GetDeviceId() const
168 {
169 return deviceId_;
170 }
171
SetDeviceId(int32_t deviceId)172 void InputEvent::SetDeviceId(int32_t deviceId)
173 {
174 deviceId_ = deviceId;
175 }
176
GetSourceType() const177 int32_t InputEvent::GetSourceType() const
178 {
179 return sourceType_;
180 }
181
SetSourceType(int32_t sourceType)182 void InputEvent::SetSourceType(int32_t sourceType)
183 {
184 sourceType_ = sourceType;
185 }
186
DumpSourceType() const187 const char* InputEvent::DumpSourceType() const
188 {
189 switch (sourceType_) {
190 case InputEvent::SOURCE_TYPE_MOUSE: {
191 return "mouse";
192 }
193 case InputEvent::SOURCE_TYPE_TOUCHSCREEN: {
194 return "touch-screen";
195 }
196 case InputEvent::SOURCE_TYPE_TOUCHPAD: {
197 return "touch-pad";
198 }
199 case InputEvent::SOURCE_TYPE_JOYSTICK: {
200 return "joystick";
201 }
202 case InputEvent::SOURCE_TYPE_FINGERPRINT: {
203 return "fingerprint";
204 }
205 case InputEvent::SOURCE_TYPE_CROWN: {
206 return "crown";
207 }
208 default: {
209 break;
210 }
211 }
212 return "unknown";
213 }
214
GetTargetDisplayId() const215 int32_t InputEvent::GetTargetDisplayId() const
216 {
217 return targetDisplayId_;
218 }
219
SetTargetDisplayId(int32_t displayId)220 void InputEvent::SetTargetDisplayId(int32_t displayId)
221 {
222 targetDisplayId_ = displayId;
223 }
224
GetAgentWindowId() const225 int32_t InputEvent::GetAgentWindowId() const
226 {
227 return agentWindowId_;
228 }
229
SetAgentWindowId(int32_t windowId)230 void InputEvent::SetAgentWindowId(int32_t windowId)
231 {
232 agentWindowId_ = windowId;
233 }
234
GetTargetWindowId() const235 int32_t InputEvent::GetTargetWindowId() const
236 {
237 return targetWindowId_;
238 }
239
SetTargetWindowId(int32_t windowId)240 void InputEvent::SetTargetWindowId(int32_t windowId)
241 {
242 targetWindowId_ = windowId;
243 }
244
GetEventType() const245 int32_t InputEvent::GetEventType() const
246 {
247 return eventType_;
248 }
249
GetFlag() const250 uint32_t InputEvent::GetFlag() const
251 {
252 return bitwise_;
253 }
254
HasFlag(uint32_t flag)255 bool InputEvent::HasFlag(uint32_t flag)
256 {
257 return (bitwise_ & flag) != 0;
258 }
259
IsFlag(uint32_t flag)260 bool InputEvent::IsFlag(uint32_t flag)
261 {
262 return (bitwise_ & flag) == flag;
263 }
264
AddFlag(uint32_t flag)265 void InputEvent::AddFlag(uint32_t flag)
266 {
267 bitwise_ |= flag;
268 }
269
ClearFlag()270 void InputEvent::ClearFlag()
271 {
272 bitwise_ = EVENT_FLAG_NONE;
273 }
274
ClearFlag(uint32_t flag)275 void InputEvent::ClearFlag(uint32_t flag)
276 {
277 bitwise_ &= ~flag;
278 }
279
IsMarkEnabled() const280 bool InputEvent::IsMarkEnabled() const
281 {
282 return markEnabled_;
283 }
284
285
SetMarkEnabled(bool markEnabled)286 void InputEvent::SetMarkEnabled(bool markEnabled)
287 {
288 markEnabled_ = markEnabled;
289 }
290
291
SetProcessedCallback(std::function<void (int32_t,int64_t)> callback)292 void InputEvent::SetProcessedCallback(std::function<void(int32_t, int64_t)> callback)
293 {
294 processedCallback_ = callback;
295 }
296
MarkProcessed()297 void InputEvent::MarkProcessed()
298 {
299 if (!processedCallback_) {
300 return;
301 }
302 if (!markEnabled_) {
303 MMI_HILOGD("Skip MarkProcessed eventId:%{public}d, eventType:%{public}d", id_, eventType_);
304 return;
305 }
306 auto func = processedCallback_;
307 processedCallback_ = std::function<void(int32_t, int64_t)>();
308 func(id_, actionTime_);
309 }
310
SetExtraData(const std::shared_ptr<const uint8_t[]> data,uint32_t length)311 void InputEvent::SetExtraData(const std::shared_ptr<const uint8_t[]> data, uint32_t length)
312 {
313 if (data && (length > 0) && (length <= DATA_LENGTH_LIMIT)) {
314 extraData_ = data;
315 extraDataLength_ = length;
316 }
317 }
318
GetExtraData(std::shared_ptr<const uint8_t[]> & data,uint32_t & length) const319 void InputEvent::GetExtraData(std::shared_ptr<const uint8_t[]> &data, uint32_t &length) const
320 {
321 if (extraData_ && extraDataLength_ != 0) {
322 data = extraData_;
323 length = extraDataLength_;
324 } else {
325 length = 0;
326 }
327 }
328
WriteToParcel(Parcel & out) const329 bool InputEvent::WriteToParcel(Parcel &out) const
330 {
331 WRITEINT32(out, eventType_);
332 WRITEINT32(out, id_);
333 WRITEINT64(out, actionTime_);
334 WRITEUINT64(out, sensorInputTime_);
335 WRITEINT32(out, action_);
336 WRITEINT64(out, actionStartTime_);
337 WRITEINT32(out, deviceId_);
338 WRITEINT32(out, sourceType_);
339 WRITEINT32(out, targetDisplayId_);
340 WRITEINT32(out, targetWindowId_);
341 WRITEINT32(out, agentWindowId_);
342 WRITEUINT32(out, bitwise_);
343 WRITEBOOL(out, markEnabled_);
344 if (extraData_ && extraDataLength_ != 0) {
345 WRITEUINT32(out, extraDataLength_);
346 WRITEBUFFER(out, (void *)extraData_.get(), extraDataLength_);
347 } else {
348 WRITEUINT32(out, 0);
349 }
350 return true;
351 }
352
Marshalling(Parcel & out) const353 bool InputEvent::Marshalling(Parcel &out) const
354 {
355 return WriteToParcel(out);
356 }
357
ReadFromParcel(Parcel & in)358 bool InputEvent::ReadFromParcel(Parcel &in)
359 {
360 #if defined(ANDROID_PLATFORM) || defined(IOS_PLATFORM)
361 return false;
362 #else
363 READINT32(in, eventType_);
364 READINT32(in, id_);
365 READINT64(in, actionTime_);
366 READUINT64(in, sensorInputTime_);
367 READINT32(in, action_);
368 READINT64(in, actionStartTime_);
369 READINT32(in, deviceId_);
370 READINT32(in, sourceType_);
371 READINT32(in, targetDisplayId_);
372 READINT32(in, targetWindowId_);
373 READINT32(in, agentWindowId_);
374 READUINT32(in, bitwise_);
375 READBOOL(in, markEnabled_);
376 READUINT32(in, extraDataLength_);
377
378 if (extraDataLength_ == 0) {
379 return true;
380 }
381 if (extraDataLength_ > DATA_LENGTH_LIMIT) {
382 extraDataLength_ = 0;
383 return false;
384 }
385 const uint8_t *buffer = in.ReadBuffer(extraDataLength_);
386 std::shared_ptr<uint8_t[]> sp(new uint8_t[extraDataLength_], [](uint8_t* ptr) { delete[] ptr; });
387 if ((buffer == nullptr) || (sp == nullptr)) {
388 extraDataLength_ = 0;
389 return false;
390 }
391 std::copy(buffer, buffer + extraDataLength_, sp.get());
392 extraData_ = sp;
393 return true;
394 #endif // defined(ANDROID_PLATFORM) || defined(IOS_PLATFORM)
395 }
396
Unmarshalling(Parcel & parcel)397 InputEvent *InputEvent::Unmarshalling(Parcel &parcel)
398 {
399 InputEvent *data = new (std::nothrow) InputEvent(InputEvent::EVENT_TYPE_BASE);
400 if (data && !data->ReadFromParcel(parcel)) {
401 delete data;
402 data = nullptr;
403 }
404 return data;
405 }
406
ActionToShortStr(int32_t action)407 std::string_view InputEvent::ActionToShortStr(int32_t action)
408 {
409 switch (action) {
410 case InputEvent::ACTION_CANCEL:
411 return "B:C:";
412 case InputEvent::ACTION_UNKNOWN:
413 return "B:UK:";
414 default:
415 return "B:?:";
416 }
417 }
418
419 struct LogTraceKey {
420 int64_t traceId;
421 int32_t action;
422 int32_t evtType;
423 };
424
425 thread_local std::vector<LogTraceKey> g_traceIds;
426 thread_local std::unordered_map<int64_t, size_t> g_traceIdToIdx;
427 thread_local std::string g_traceStr;
428
Action2Str(int32_t eventType,int32_t action)429 std::string_view Action2Str(int32_t eventType, int32_t action)
430 {
431 switch (eventType) {
432 case InputEvent::EVENT_TYPE_KEY: {
433 return KeyEvent::ActionToShortStr(action);
434 }
435 case InputEvent::EVENT_TYPE_POINTER:
436 case InputEvent::EVENT_TYPE_FINGERPRINT: {
437 return PointerEvent::ActionToShortStr(action);
438 }
439 case InputEvent::EVENT_TYPE_AXIS: {
440 return AxisEvent::ActionToShortStr(action);
441 }
442 case InputEvent::EVENT_TYPE_BASE: {
443 return InputEvent::ActionToShortStr(action);
444 }
445 default: {
446 return "?:?:";
447 }
448 }
449 }
450
RefreshTraceStr()451 void RefreshTraceStr()
452 {
453 g_traceStr.clear();
454 for (auto item = g_traceIds.begin(); item < g_traceIds.end(); ++item) {
455 if (item->traceId == -1) {
456 continue;
457 }
458 if (item != g_traceIds.begin()) {
459 g_traceStr += "/";
460 }
461 g_traceStr += Action2Str(item->evtType, item->action);
462 g_traceStr += std::to_string(item->traceId);
463 }
464 }
465
StartLogTraceId(int64_t traceId,int32_t eventType,int32_t action)466 void StartLogTraceId(int64_t traceId, int32_t eventType, int32_t action)
467 {
468 if (traceId == -1) {
469 return;
470 }
471 auto iter = g_traceIdToIdx.find(traceId);
472 if (iter == g_traceIdToIdx.end()) {
473 g_traceIds.push_back({traceId, action, eventType});
474 g_traceIdToIdx.emplace(traceId, g_traceIds.size() - 1);
475 std::string currentTraceStr(Action2Str(eventType, action));
476 currentTraceStr += std::to_string(traceId);
477 if (g_traceIds.size() == 1) {
478 g_traceStr = currentTraceStr;
479 } else {
480 g_traceStr += "/" + currentTraceStr;
481 }
482 return;
483 }
484 if (g_traceIds.size() <= iter->second) {
485 return;
486 }
487 LogTraceKey &old = g_traceIds.at(iter->second);
488 if (old.evtType != eventType || old.action != action) {
489 old.evtType = eventType;
490 old.action = action;
491 RefreshTraceStr();
492 }
493 };
494
EndLogTraceId(int64_t id)495 void EndLogTraceId(int64_t id)
496 {
497 auto iter = g_traceIdToIdx.find(id);
498 if (iter == g_traceIdToIdx.end()) {
499 return;
500 }
501 size_t idx = iter->second;
502 g_traceIdToIdx.erase(iter);
503 size_t idCount = g_traceIds.size();
504 if (idCount <= idx) {
505 return;
506 }
507
508 if (idCount == idx + 1) {
509 g_traceIds.pop_back();
510 while (!g_traceIds.empty() && g_traceIds.back().traceId == -1) {
511 g_traceIds.pop_back();
512 }
513 } else {
514 // can't erase it, erase it will make the index of other elem changed.
515 LogTraceKey &toDelete = g_traceIds.at(idx);
516 toDelete.traceId = -1;
517 }
518 RefreshTraceStr();
519 }
520
FormatLogTrace()521 __attribute__((noinline)) const char *FormatLogTrace()
522 {
523 return g_traceStr.c_str();
524 }
525
526
ResetLogTrace()527 void ResetLogTrace()
528 {
529 g_traceIds.clear();
530 g_traceIdToIdx.clear();
531 g_traceStr.clear();
532 }
533
LogTracer(int64_t traceId,int32_t evtType,int32_t action)534 LogTracer::LogTracer(int64_t traceId, int32_t evtType, int32_t action)
535 {
536 traceId_ = traceId;
537 StartLogTraceId(traceId, evtType, action);
538 }
539
~LogTracer()540 LogTracer::~LogTracer()
541 {
542 EndLogTraceId(traceId_);
543 }
544
LogTracer()545 LogTracer::LogTracer()
546 {
547 traceId_ = -1;
548 }
549
LogTracer(LogTracer && other)550 LogTracer::LogTracer(LogTracer &&other) noexcept: traceId_(other.traceId_)
551 {
552 other.traceId_ = -1;
553 }
554
operator =(LogTracer && other)555 LogTracer &LogTracer::operator=(LogTracer &&other) noexcept
556 {
557 if (this != &other) {
558 traceId_ = other.traceId_;
559 other.traceId_ = -1;
560 }
561 return *this;
562 }
563
564 int32_t OHOS::MMI::EventLogHelper::infoDictCount_ = 0;
565 int32_t OHOS::MMI::EventLogHelper::debugDictCount_ = 0;
566
567 } // namespace MMI
568 } // namespace OHOS
569