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