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