1 /*
2  * Copyright (c) 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 #include "bytrace_adapter.h"
16 
17 #include <string>
18 
19 #include "define_multimodal.h"
20 #ifdef HITRACE_ENABLED
21 #include "hitrace_meter.h"
22 #endif // HITRACE_ENABLED
23 #include "mmi_log.h"
24 
25 #undef MMI_LOG_TAG
26 #define MMI_LOG_TAG "BytraceAdapter"
27 
28 namespace OHOS {
29 namespace MMI {
30 namespace {
31 const std::string ON_KEY_EVENT { "OnKeyEvent" };
32 const std::string ON_TOUCH_EVENT { "OnTouchEvent" };
33 const std::string ON_POINTER_EVENT { "OnPointerEvent" };
34 const std::string KEY_EVENT_DISPATCH { "KeyEventDispatch" };
35 const std::string TOUCH_EVENT_DISPATCH { "touchEventDispatch" };
36 const std::string POINTER_EVENT_DISPATCH { "PointerEventDispatch" };
37 const std::string KEY_EVENT_SUBSCRIBE { "KeyEventSubscribe" };
38 const std::string POINTER_EVENT_INTERCEPT { "PointerEventIntercept" };
39 const std::string TOUCH_EVENT_INTERCEPT { "TouchEventIntercept" };
40 const std::string KEY_EVENT_INTERCEPT { "KeyEventIntercept" };
41 const std::string ON_START_EVENT { "StartEvent" };
42 const std::string ON_LAUNCH_EVENT { "LaunchEvent" };
43 const std::string ON_STOP_EVENT { "StopEvent" };
44 constexpr int32_t START_ID { 1 };
45 constexpr int32_t LAUNCH_ID { 2 };
46 constexpr int32_t STOP_ID { 3 };
47 } // namespace
48 
StartBytrace(std::shared_ptr<KeyEvent> keyEvent)49 void BytraceAdapter::StartBytrace(std::shared_ptr<KeyEvent> keyEvent)
50 {
51 #ifdef HITRACE_ENABLED
52     CHKPV(keyEvent);
53     int32_t keyId = keyEvent->GetId();
54     StartAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, ON_KEY_EVENT, keyId);
55     HITRACE_METER_NAME(HITRACE_TAG_MULTIMODALINPUT, "service report keyId=" + std::to_string(keyId));
56 #endif // HITRACE_ENABLED
57 }
58 
GetKeyTraceString(std::shared_ptr<KeyEvent> keyEvent)59 std::string BytraceAdapter::GetKeyTraceString(std::shared_ptr<KeyEvent> keyEvent)
60 {
61     CHKPS(keyEvent);
62     return KeyEvent::ActionToString(keyEvent->GetKeyAction());
63 }
64 
GetPointerTraceString(std::shared_ptr<PointerEvent> pointerEvent)65 std::string BytraceAdapter::GetPointerTraceString(std::shared_ptr<PointerEvent> pointerEvent)
66 {
67 #ifdef HITRACE_ENABLED
68     CHKPS(pointerEvent);
69     std::vector<PointerEvent::PointerItem> pointerItems;
70     std::vector<int32_t> pointerIds{ pointerEvent->GetPointerIds() };
71     for (const auto &pointerId : pointerIds) {
72         PointerEvent::PointerItem item;
73         if (!pointerEvent->GetPointerItem(pointerId, item)) {
74             MMI_HILOGE("Invalid pointer:%{public}d", pointerId);
75             return "";
76         }
77         pointerItems.emplace_back(item);
78     }
79     std::string traceStr;
80     for (const auto &item : pointerItems) {
81         auto id = item.GetPointerId();
82         auto displayX = item.GetDisplayX();
83         auto displayY = item.GetDisplayY();
84         traceStr += " [";
85         traceStr += "id: " + std::to_string(id);
86         traceStr += ", x:" + std::to_string(displayX);
87         traceStr += ", y:" + std::to_string(displayY);
88         traceStr += "]";
89     }
90     return traceStr;
91 #else
92     return "";
93 #endif // HITRACE_ENABLED
94 }
95 
StartBytrace(std::shared_ptr<PointerEvent> pointerEvent, TraceBtn traceBtn)96 void BytraceAdapter::StartBytrace(std::shared_ptr<PointerEvent> pointerEvent, TraceBtn traceBtn)
97 {
98 #ifdef HITRACE_ENABLED
99     CHKPV(pointerEvent);
100     int32_t eventId = pointerEvent->GetId();
101     if (traceBtn == TRACE_START) {
102         if (pointerEvent->GetSourceType() == PointerEvent::SOURCE_TYPE_MOUSE) {
103             StartAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, ON_POINTER_EVENT, eventId);
104             HITRACE_METER_NAME(HITRACE_TAG_MULTIMODALINPUT, "service report pointerId:" + std::to_string(eventId) +
105                 + ", type: " + pointerEvent->DumpPointerAction());
106         } else {
107             StartAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, ON_TOUCH_EVENT, eventId);
108             HITRACE_METER_NAME(HITRACE_TAG_MULTIMODALINPUT, "service report touchId:" + std::to_string(eventId) +
109                 + ", type: " + pointerEvent->DumpPointerAction());
110         }
111     } else {
112         if (pointerEvent->GetSourceType() == PointerEvent::SOURCE_TYPE_MOUSE) {
113             FinishAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, ON_POINTER_EVENT, eventId);
114         } else {
115             FinishAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, ON_TOUCH_EVENT, eventId);
116         }
117     }
118 #endif // HITRACE_ENABLED
119 }
120 
StartBytrace(std::shared_ptr<KeyEvent> key, HandlerType handlerType)121 void BytraceAdapter::StartBytrace(std::shared_ptr<KeyEvent> key, HandlerType handlerType)
122 {
123 #ifdef HITRACE_ENABLED
124     CHKPV(key);
125     [[ maybe_unused ]] int32_t keyCode = key->GetKeyCode();
126     std::string checkKeyCode;
127     switch (handlerType) {
128         case KEY_INTERCEPT_EVENT: {
129             checkKeyCode = "Intercept keyCode";
130             break;
131         }
132         case KEY_LAUNCH_EVENT: {
133             checkKeyCode = "Launch keyCode";
134             break;
135         }
136         case KEY_SUBSCRIBE_EVENT: {
137             checkKeyCode = "Subscribe keyCode";
138             break;
139         }
140         case KEY_DISPATCH_EVENT: {
141             checkKeyCode = "Dispatch keyCode";
142             break;
143         }
144         default: {
145             checkKeyCode = "Unknown keyCode";
146             break;
147         }
148     }
149     HITRACE_METER_NAME(HITRACE_TAG_MULTIMODALINPUT, checkKeyCode);
150     int32_t keyId = key->GetId();
151     FinishAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, ON_KEY_EVENT, keyId);
152 #endif // HITRACE_ENABLED
153 }
154 
StartBytrace(std::shared_ptr<KeyEvent> keyEvent, TraceBtn traceBtn, HandlerType handlerType)155 void BytraceAdapter::StartBytrace(std::shared_ptr<KeyEvent> keyEvent, TraceBtn traceBtn, HandlerType handlerType)
156 {
157 #ifdef HITRACE_ENABLED
158     CHKPV(keyEvent);
159     int32_t keyId = keyEvent->GetId();
160     [[ maybe_unused ]] int32_t keyCode = keyEvent->GetKeyCode();
161     if (traceBtn == TRACE_START) {
162         switch (handlerType) {
163             case KEY_INTERCEPT_EVENT: {
164                 StartAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, KEY_EVENT_INTERCEPT, keyId);
165                 HITRACE_METER_NAME(HITRACE_TAG_MULTIMODALINPUT, "client Intercept keyCode");
166                 break;
167             }
168             case KEY_SUBSCRIBE_EVENT: {
169                 StartAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, KEY_EVENT_SUBSCRIBE, keyId);
170                 HITRACE_METER_NAME(HITRACE_TAG_MULTIMODALINPUT, "client subscribe keyCode");
171                 break;
172             }
173             case KEY_DISPATCH_EVENT: {
174                 StartAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, KEY_EVENT_DISPATCH, keyId);
175                 HITRACE_METER_NAME(HITRACE_TAG_MULTIMODALINPUT, "client dispatch keyCode");
176                 break;
177             }
178             default: {
179                 HITRACE_METER_NAME(HITRACE_TAG_MULTIMODALINPUT, "Unknown keyCode");
180                 break;
181             }
182         }
183     } else {
184         switch (handlerType) {
185             case KEY_INTERCEPT_EVENT: {
186                 FinishAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, KEY_EVENT_INTERCEPT, keyId);
187                 break;
188             }
189             case KEY_SUBSCRIBE_EVENT: {
190                 FinishAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, KEY_EVENT_SUBSCRIBE, keyId);
191                 break;
192             }
193             case KEY_DISPATCH_EVENT: {
194                 FinishAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, KEY_EVENT_DISPATCH, keyId);
195                 break;
196             }
197             default: {
198                 HITRACE_METER_NAME(HITRACE_TAG_MULTIMODALINPUT, "Unknown keyCode");
199                 break;
200             }
201         }
202     }
203 #endif // HITRACE_ENABLED
204 }
205 
StartBytrace( std::shared_ptr<PointerEvent> pointerEvent, TraceBtn traceBtn, HandlerType handlerType)206 void BytraceAdapter::StartBytrace(
207     std::shared_ptr<PointerEvent> pointerEvent, TraceBtn traceBtn, HandlerType handlerType)
208 {
209 #ifdef HITRACE_ENABLED
210     CHKPV(pointerEvent);
211     int32_t eventId = pointerEvent->GetId();
212     if (traceBtn == TRACE_START) {
213         if (handlerType == POINT_DISPATCH_EVENT) {
214             if (pointerEvent->GetSourceType() == PointerEvent::SOURCE_TYPE_MOUSE) {
215                 StartAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, POINTER_EVENT_DISPATCH, eventId);
216                 HITRACE_METER_NAME(HITRACE_TAG_MULTIMODALINPUT, "client dispatch pointerId:" + std::to_string(eventId));
217             } else {
218                 StartAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, TOUCH_EVENT_DISPATCH, eventId);
219                 HITRACE_METER_NAME(HITRACE_TAG_MULTIMODALINPUT, "client dispatch touchId:" + std::to_string(eventId));
220             }
221         } else {
222             if (pointerEvent->GetSourceType() == PointerEvent::SOURCE_TYPE_MOUSE) {
223                 StartAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, POINTER_EVENT_INTERCEPT, eventId);
224                 HITRACE_METER_NAME(HITRACE_TAG_MULTIMODALINPUT,
225                     "client Intercept pointerId:" + std::to_string(eventId));
226             } else {
227                 StartAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, TOUCH_EVENT_INTERCEPT, eventId);
228                 HITRACE_METER_NAME(HITRACE_TAG_MULTIMODALINPUT, "client Intercept touchId:" + std::to_string(eventId));
229             }
230         }
231     } else {
232         if (handlerType == POINT_DISPATCH_EVENT) {
233             if (pointerEvent->GetSourceType() == PointerEvent::SOURCE_TYPE_MOUSE) {
234                 FinishAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, POINTER_EVENT_DISPATCH, eventId);
235             } else {
236                 FinishAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, TOUCH_EVENT_DISPATCH, eventId);
237             }
238         }
239         if (handlerType == POINT_INTERCEPT_EVENT) {
240             if (pointerEvent->GetSourceType() == PointerEvent::SOURCE_TYPE_MOUSE) {
241                 FinishAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, POINTER_EVENT_INTERCEPT, eventId);
242             } else {
243                 FinishAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, TOUCH_EVENT_INTERCEPT, eventId);
244             }
245         }
246     }
247 #endif // HITRACE_ENABLED
248 }
249 
StartBytrace(TraceBtn traceBtn, EventType eventType)250 void BytraceAdapter::StartBytrace(TraceBtn traceBtn, EventType eventType)
251 {
252 #ifdef HITRACE_ENABLED
253     std::string checkKeyCode;
254     if (traceBtn == TRACE_START) {
255         switch (eventType) {
256             case START_EVENT: {
257                 StartAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, ON_START_EVENT, START_ID);
258                 checkKeyCode = "crossing startId:" + std::to_string(START_ID);
259                 HITRACE_METER_NAME(HITRACE_TAG_MULTIMODALINPUT, checkKeyCode);
260                 break;
261             }
262             case LAUNCH_EVENT: {
263                 StartAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, ON_LAUNCH_EVENT, LAUNCH_ID);
264                 checkKeyCode = "crossing launchId:" + std::to_string(LAUNCH_ID);
265                 HITRACE_METER_NAME(HITRACE_TAG_MULTIMODALINPUT, checkKeyCode);
266                 break;
267             }
268             case STOP_EVENT: {
269                 StartAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, ON_STOP_EVENT, STOP_ID);
270                 checkKeyCode = "crossing stopId:" + std::to_string(STOP_ID);
271                 HITRACE_METER_NAME(HITRACE_TAG_MULTIMODALINPUT, checkKeyCode);
272                 break;
273             }
274         }
275     } else {
276         switch (eventType) {
277             case START_EVENT: {
278                 FinishAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, KEY_EVENT_INTERCEPT, START_ID);
279                 break;
280             }
281             case LAUNCH_EVENT: {
282                 FinishAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, KEY_EVENT_INTERCEPT, LAUNCH_ID);
283                 break;
284             }
285             case STOP_EVENT: {
286                 FinishAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, KEY_EVENT_INTERCEPT, STOP_ID);
287                 break;
288             }
289         }
290     }
291 #endif // HITRACE_ENABLED
292 }
293 
StartIpcServer(uint32_t code)294 void BytraceAdapter::StartIpcServer(uint32_t code)
295 {
296 #ifdef HITRACE_ENABLED
297     StartTrace(HITRACE_TAG_MULTIMODALINPUT, "ipcServerHandle code:" + std::to_string(code));
298 #endif // HITRACE_ENABLED
299 }
300 
StopIpcServer()301 void BytraceAdapter::StopIpcServer()
302 {
303 #ifdef HITRACE_ENABLED
304     FinishTrace(HITRACE_TAG_MULTIMODALINPUT);
305 #endif // HITRACE_ENABLED
306 }
307 
StartPackageEvent(const std::string& msg)308 void BytraceAdapter::StartPackageEvent(const std::string& msg)
309 {
310 #ifdef HITRACE_ENABLED
311     StartTrace(HITRACE_TAG_MULTIMODALINPUT, msg);
312 #endif // HITRACE_ENABLED
313 }
314 
StopPackageEvent()315 void BytraceAdapter::StopPackageEvent()
316 {
317 #ifdef HITRACE_ENABLED
318     FinishTrace(HITRACE_TAG_MULTIMODALINPUT);
319 #endif // HITRACE_ENABLED
320 }
321 
StartHandleInput(int32_t code)322 void BytraceAdapter::StartHandleInput(int32_t code)
323 {
324 #ifdef HITRACE_ENABLED
325     StartTrace(HITRACE_TAG_MULTIMODALINPUT, "originEventHandle code:" + std::to_string(code));
326 #endif // HITRACE_ENABLED
327 }
328 
StopHandleInput()329 void BytraceAdapter::StopHandleInput()
330 {
331 #ifdef HITRACE_ENABLED
332     FinishTrace(HITRACE_TAG_MULTIMODALINPUT);
333 #endif // HITRACE_ENABLED
334 }
335 
StartHandleTracker(int32_t pointerId)336 void BytraceAdapter::StartHandleTracker(int32_t pointerId)
337 {
338 #ifdef HITRACE_ENABLED
339     StartTrace(HITRACE_TAG_MULTIMODALINPUT, "pointerId:" + std::to_string(pointerId));
340 #endif // HITRACE_ENABLED
341 }
342 
StopHandleTracker()343 void BytraceAdapter::StopHandleTracker()
344 {
345 #ifdef HITRACE_ENABLED
346     FinishTrace(HITRACE_TAG_MULTIMODALINPUT);
347 #endif // HITRACE_ENABLED
348 }
349 
StartConsumer(std::shared_ptr<PointerEvent> pointerEvent)350 void BytraceAdapter::StartConsumer(std::shared_ptr<PointerEvent> pointerEvent)
351 {
352 #ifdef HITRACE_ENABLED
353     CHKPV(pointerEvent);
354     StartTrace(HITRACE_TAG_MULTIMODALINPUT, "eventConsume pointerEventId:" + std::to_string(pointerEvent->GetId()));
355 #endif // HITRACE_ENABLED
356 }
357 
StopConsumer()358 void BytraceAdapter::StopConsumer()
359 {
360 #ifdef HITRACE_ENABLED
361     FinishTrace(HITRACE_TAG_MULTIMODALINPUT);
362 #endif // HITRACE_ENABLED
363 }
364 
StartConsumer(std::shared_ptr<KeyEvent> keyEvent)365 void BytraceAdapter::StartConsumer(std::shared_ptr<KeyEvent> keyEvent)
366 {
367 #ifdef HITRACE_ENABLED
368     CHKPV(keyEvent);
369     StartTrace(HITRACE_TAG_MULTIMODALINPUT, "eventConsume keyEventId:" + std::to_string(keyEvent->GetId()));
370 #endif // HITRACE_ENABLED
371 }
372 
StartPostTaskEvent(std::shared_ptr<PointerEvent> pointerEvent)373 void BytraceAdapter::StartPostTaskEvent(std::shared_ptr<PointerEvent> pointerEvent)
374 {
375 #ifdef HITRACE_ENABLED
376     CHKPV(pointerEvent);
377     StartTrace(HITRACE_TAG_MULTIMODALINPUT, "startpostEvent pointerEventId:" +
378         std::to_string(pointerEvent->GetId()));
379 #endif // HITRACE_ENABLED
380 }
381 
StartPostTaskEvent(std::shared_ptr<KeyEvent> keyEvent)382 void BytraceAdapter::StartPostTaskEvent(std::shared_ptr<KeyEvent> keyEvent)
383 {
384 #ifdef HITRACE_ENABLED
385     CHKPV(keyEvent);
386     StartTrace(HITRACE_TAG_MULTIMODALINPUT, "startpostEvent keyEventId:" +
387         std::to_string(keyEvent->GetId()));
388 #endif // HITRACE_ENABLED
389 }
390 
StopPostTaskEvent()391 void BytraceAdapter::StopPostTaskEvent()
392 {
393 #ifdef HITRACE_ENABLED
394     FinishTrace(HITRACE_TAG_MULTIMODALINPUT);
395 #endif // HITRACE_ENABLED
396 }
397 
StartSocketHandle(int32_t msgId)398 void BytraceAdapter::StartSocketHandle(int32_t msgId)
399 {
400 #ifdef HITRACE_ENABLED
401     StartTrace(HITRACE_TAG_MULTIMODALINPUT, "socketMsgHandle msgId:" + std::to_string(msgId));
402 #endif // HITRACE_ENABLED
403 }
404 
StopSocketHandle()405 void BytraceAdapter::StopSocketHandle()
406 {
407 #ifdef HITRACE_ENABLED
408     FinishTrace(HITRACE_TAG_MULTIMODALINPUT);
409 #endif // HITRACE_ENABLED
410 }
411 
StartDevListener(const std::string& type, int32_t deviceId)412 void BytraceAdapter::StartDevListener(const std::string& type, int32_t deviceId)
413 {
414 #ifdef HITRACE_ENABLED
415     StartTrace(HITRACE_TAG_MULTIMODALINPUT,
416         "device listener type:" + type + ", deviceid:" + std::to_string(deviceId));
417 #endif // HITRACE_ENABLED
418 }
419 
StopDevListener()420 void BytraceAdapter::StopDevListener()
421 {
422 #ifdef HITRACE_ENABLED
423     FinishTrace(HITRACE_TAG_MULTIMODALINPUT);
424 #endif // HITRACE_ENABLED
425 }
426 
StartLaunchAbility(int32_t type, const std::string& bundleName)427 void BytraceAdapter::StartLaunchAbility(int32_t type, const std::string& bundleName)
428 {
429 #ifdef HITRACE_ENABLED
430     StartTrace(HITRACE_TAG_MULTIMODALINPUT,
431         "launchAbility type:" + std::to_string(type) + ", bundleName:" + bundleName);
432 #endif // HITRACE_ENABLED
433 }
434 
StopLaunchAbility()435 void BytraceAdapter::StopLaunchAbility()
436 {
437 #ifdef HITRACE_ENABLED
438     FinishTrace(HITRACE_TAG_MULTIMODALINPUT);
439 #endif // HITRACE_ENABLED
440 }
441 
StartMarkedTracker(int32_t eventId)442 void BytraceAdapter::StartMarkedTracker(int32_t eventId)
443 {
444 #ifdef HITRACE_ENABLED
445     StartTrace(HITRACE_TAG_MULTIMODALINPUT, "markProcessed eventId:" + std::to_string(eventId));
446 #endif // HITRACE_ENABLED
447 }
448 
StopMarkedTracker()449 void BytraceAdapter::StopMarkedTracker()
450 {
451 #ifdef HITRACE_ENABLED
452     FinishTrace(HITRACE_TAG_MULTIMODALINPUT);
453 #endif // HITRACE_ENABLED
454 }
455 
StartTouchEvent(int32_t pointerId)456 void BytraceAdapter::StartTouchEvent(int32_t pointerId)
457 {
458 #ifdef HITRACE_ENABLED
459     StartTrace(HITRACE_TAG_MULTIMODALINPUT, "startTouchEvent pointerId:" + std::to_string(pointerId));
460 #endif // HITRACE_ENABLED
461 }
462 
StopTouchEvent()463 void BytraceAdapter::StopTouchEvent()
464 {
465 #ifdef HITRACE_ENABLED
466     FinishTrace(HITRACE_TAG_MULTIMODALINPUT);
467 #endif // HITRACE_ENABLED
468 }
469 } // namespace MMI
470 } // namespace OHOS