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.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
AddFlag(uint32_t flag)260 void InputEvent::AddFlag(uint32_t flag)
261 {
262 bitwise_ |= flag;
263 }
264
ClearFlag()265 void InputEvent::ClearFlag()
266 {
267 bitwise_ = EVENT_FLAG_NONE;
268 }
269
ClearFlag(uint32_t flag)270 void InputEvent::ClearFlag(uint32_t flag)
271 {
272 bitwise_ &= ~flag;
273 }
274
IsMarkEnabled() const275 bool InputEvent::IsMarkEnabled() const
276 {
277 return markEnabled_;
278 }
279
280
SetMarkEnabled(bool markEnabled)281 void InputEvent::SetMarkEnabled(bool markEnabled)
282 {
283 markEnabled_ = markEnabled;
284 }
285
286
SetProcessedCallback(std::function<void (int32_t,int64_t)> callback)287 void InputEvent::SetProcessedCallback(std::function<void(int32_t, int64_t)> callback)
288 {
289 processedCallback_ = callback;
290 }
291
MarkProcessed()292 void InputEvent::MarkProcessed()
293 {
294 if (!processedCallback_) {
295 return;
296 }
297 if (!markEnabled_) {
298 MMI_HILOGD("Skip MarkProcessed eventId:%{public}d, eventType:%{public}d", id_, eventType_);
299 return;
300 }
301 auto func = processedCallback_;
302 processedCallback_ = std::function<void(int32_t, int64_t)>();
303 func(id_, actionTime_);
304 }
305
SetExtraData(const std::shared_ptr<const uint8_t[]> data,uint32_t length)306 void InputEvent::SetExtraData(const std::shared_ptr<const uint8_t[]> data, uint32_t length)
307 {
308 if (data && (length > 0) && (length <= DATA_LENGTH_LIMIT)) {
309 extraData_ = data;
310 extraDataLength_ = length;
311 }
312 }
313
GetExtraData(std::shared_ptr<const uint8_t[]> & data,uint32_t & length) const314 void InputEvent::GetExtraData(std::shared_ptr<const uint8_t[]> &data, uint32_t &length) const
315 {
316 if (extraData_ && extraDataLength_ != 0) {
317 data = extraData_;
318 length = extraDataLength_;
319 } else {
320 length = 0;
321 }
322 }
323
WriteToParcel(Parcel & out) const324 bool InputEvent::WriteToParcel(Parcel &out) const
325 {
326 WRITEINT32(out, eventType_);
327 WRITEINT32(out, id_);
328 WRITEINT64(out, actionTime_);
329 WRITEUINT64(out, sensorInputTime_);
330 WRITEINT32(out, action_);
331 WRITEINT64(out, actionStartTime_);
332 WRITEINT32(out, deviceId_);
333 WRITEINT32(out, sourceType_);
334 WRITEINT32(out, targetDisplayId_);
335 WRITEINT32(out, targetWindowId_);
336 WRITEINT32(out, agentWindowId_);
337 WRITEUINT32(out, bitwise_);
338 WRITEBOOL(out, markEnabled_);
339 if (extraData_ && extraDataLength_ != 0) {
340 WRITEUINT32(out, extraDataLength_);
341 WRITEBUFFER(out, (void *)extraData_.get(), extraDataLength_);
342 } else {
343 WRITEUINT32(out, 0);
344 }
345 return true;
346 }
347
ReadFromParcel(Parcel & in)348 bool InputEvent::ReadFromParcel(Parcel &in)
349 {
350 #if defined(ANDROID_PLATFORM) || defined(IOS_PLATFORM)
351 return false;
352 #else
353 READINT32(in, eventType_);
354 READINT32(in, id_);
355 READINT64(in, actionTime_);
356 READUINT64(in, sensorInputTime_);
357 READINT32(in, action_);
358 READINT64(in, actionStartTime_);
359 READINT32(in, deviceId_);
360 READINT32(in, sourceType_);
361 READINT32(in, targetDisplayId_);
362 READINT32(in, targetWindowId_);
363 READINT32(in, agentWindowId_);
364 READUINT32(in, bitwise_);
365 READBOOL(in, markEnabled_);
366 READUINT32(in, extraDataLength_);
367
368 if (extraDataLength_ == 0) {
369 return true;
370 }
371 if (extraDataLength_ > DATA_LENGTH_LIMIT) {
372 extraDataLength_ = 0;
373 return false;
374 }
375 const uint8_t *buffer = in.ReadBuffer(extraDataLength_);
376 std::shared_ptr<uint8_t[]> sp(new uint8_t[extraDataLength_], [](uint8_t* ptr) { delete[] ptr; });
377 if ((buffer == nullptr) || (sp == nullptr)) {
378 extraDataLength_ = 0;
379 return false;
380 }
381 std::copy(buffer, buffer + extraDataLength_, sp.get());
382 extraData_ = sp;
383 return true;
384 #endif // defined(ANDROID_PLATFORM) || defined(IOS_PLATFORM)
385 }
386
ActionToShortStr(int32_t action)387 std::string_view InputEvent::ActionToShortStr(int32_t action)
388 {
389 switch (action) {
390 case InputEvent::ACTION_CANCEL:
391 return "B:C:";
392 case InputEvent::ACTION_UNKNOWN:
393 return "B:UK:";
394 default:
395 return "B:?:";
396 }
397 }
398
399 struct LogTraceKey {
400 int64_t traceId;
401 int32_t action;
402 int32_t evtType;
403 };
404
405 thread_local std::vector<LogTraceKey> g_traceIds;
406 thread_local std::unordered_map<int64_t, size_t> g_traceIdToIdx;
407 thread_local std::string g_traceStr;
408
Action2Str(int32_t eventType,int32_t action)409 std::string_view Action2Str(int32_t eventType, int32_t action)
410 {
411 switch (eventType) {
412 case InputEvent::EVENT_TYPE_KEY: {
413 return KeyEvent::ActionToShortStr(action);
414 }
415 case InputEvent::EVENT_TYPE_POINTER:
416 case InputEvent::EVENT_TYPE_FINGERPRINT: {
417 return PointerEvent::ActionToShortStr(action);
418 }
419 case InputEvent::EVENT_TYPE_AXIS: {
420 return AxisEvent::ActionToShortStr(action);
421 }
422 case InputEvent::EVENT_TYPE_BASE: {
423 return InputEvent::ActionToShortStr(action);
424 }
425 default: {
426 return "?:?:";
427 }
428 }
429 }
430
RefreshTraceStr()431 void RefreshTraceStr()
432 {
433 g_traceStr.clear();
434 for (auto item = g_traceIds.begin(); item < g_traceIds.end(); ++item) {
435 if (item->traceId == -1) {
436 continue;
437 }
438 if (item != g_traceIds.begin()) {
439 g_traceStr += "/";
440 }
441 g_traceStr += Action2Str(item->evtType, item->action);
442 g_traceStr += std::to_string(item->traceId);
443 }
444 }
445
StartLogTraceId(int64_t traceId,int32_t eventType,int32_t action)446 void StartLogTraceId(int64_t traceId, int32_t eventType, int32_t action)
447 {
448 if (traceId == -1) {
449 return;
450 }
451 auto iter = g_traceIdToIdx.find(traceId);
452 if (iter == g_traceIdToIdx.end()) {
453 g_traceIds.push_back({traceId, action, eventType});
454 g_traceIdToIdx.emplace(traceId, g_traceIds.size() - 1);
455 std::string currentTraceStr(Action2Str(eventType, action));
456 currentTraceStr += std::to_string(traceId);
457 if (g_traceIds.size() == 1) {
458 g_traceStr = currentTraceStr;
459 } else {
460 g_traceStr += "/" + currentTraceStr;
461 }
462 return;
463 }
464 if (g_traceIds.size() <= iter->second) {
465 return;
466 }
467 LogTraceKey &old = g_traceIds.at(iter->second);
468 if (old.evtType != eventType || old.action != action) {
469 old.evtType = eventType;
470 old.action = action;
471 RefreshTraceStr();
472 }
473 };
474
EndLogTraceId(int64_t id)475 void EndLogTraceId(int64_t id)
476 {
477 auto iter = g_traceIdToIdx.find(id);
478 if (iter == g_traceIdToIdx.end()) {
479 return;
480 }
481 size_t idx = iter->second;
482 g_traceIdToIdx.erase(iter);
483 size_t idCount = g_traceIds.size();
484 if (idCount <= idx) {
485 return;
486 }
487
488 if (idCount == idx + 1) {
489 g_traceIds.pop_back();
490 while (!g_traceIds.empty() && g_traceIds.back().traceId == -1) {
491 g_traceIds.pop_back();
492 }
493 } else {
494 // can't erase it, erase it will make the index of other elem changed.
495 LogTraceKey &toDelete = g_traceIds.at(idx);
496 toDelete.traceId = -1;
497 }
498 RefreshTraceStr();
499 }
500
FormatLogTrace()501 const char *FormatLogTrace()
502 {
503 return g_traceStr.c_str();
504 }
505
506
ResetLogTrace()507 void ResetLogTrace()
508 {
509 g_traceIds.clear();
510 g_traceIdToIdx.clear();
511 g_traceStr.clear();
512 }
513
LogTracer(int64_t traceId,int32_t evtType,int32_t action)514 LogTracer::LogTracer(int64_t traceId, int32_t evtType, int32_t action)
515 {
516 traceId_ = traceId;
517 StartLogTraceId(traceId, evtType, action);
518 }
519
~LogTracer()520 LogTracer::~LogTracer()
521 {
522 EndLogTraceId(traceId_);
523 }
524
LogTracer()525 LogTracer::LogTracer()
526 {
527 traceId_ = -1;
528 }
529
LogTracer(LogTracer && other)530 LogTracer::LogTracer(LogTracer &&other) noexcept: traceId_(other.traceId_)
531 {
532 other.traceId_ = -1;
533 }
534
operator =(LogTracer && other)535 LogTracer &LogTracer::operator=(LogTracer &&other) noexcept
536 {
537 if (this != &other) {
538 traceId_ = other.traceId_;
539 other.traceId_ = -1;
540 }
541 return *this;
542 }
543
544 int32_t OHOS::MMI::EventLogHelper::infoDictCount_ = 0;
545 int32_t OHOS::MMI::EventLogHelper::debugDictCount_ = 0;
546
547 } // namespace MMI
548 } // namespace OHOS
549