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