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 namespace OHOS {
24 namespace MMI {
25 namespace {
26 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = { LOG_CORE, MMI_LOG_DOMAIN, "BytraceAdapter" };
27 const std::string onKeyEvent { "OnKeyEvent" };
28 const std::string onTouchEvent { "OnTouchEvent" };
29 const std::string onPointerEvent { "OnPointerEvent" };
30 const std::string keyEventDispatch { "KeyEventDispatch" };
31 const std::string touchEventDispatch { "touchEventDispatch" };
32 const std::string pointerEventDispatch { "PointerEventDispatch" };
33 const std::string keyEventSubscribe { "KeyEventSubscribe" };
34 const std::string pointerEventIntercept { "PointerEventIntercept" };
35 const std::string touchEventIntercept { "TouchEventIntercept" };
36 const std::string keyEventIntercept { "KeyEventIntercept" };
37 const std::string startEvent { "StartEvent" };
38 const std::string launchEvent { "LaunchEvent" };
39 const std::string stopEvent { "StopEvent" };
40 constexpr int32_t START_ID = 1;
41 constexpr int32_t LAUNCH_ID = 2;
42 constexpr int32_t STOP_ID = 3;
43 } // namespace
44
StartBytrace(std::shared_ptr<KeyEvent> keyEvent)45 void BytraceAdapter::StartBytrace(std::shared_ptr<KeyEvent> keyEvent)
46 {
47 CHKPV(keyEvent);
48 int32_t keyId = keyEvent->GetId();
49 StartAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, onKeyEvent, keyId);
50 HITRACE_METER_NAME(HITRACE_TAG_MULTIMODALINPUT, "service report keyId=" + std::to_string(keyId));
51 }
52
StartBytrace(std::shared_ptr<PointerEvent> pointerEvent,TraceBtn traceBtn)53 void BytraceAdapter::StartBytrace(std::shared_ptr<PointerEvent> pointerEvent, TraceBtn traceBtn)
54 {
55 CHKPV(pointerEvent);
56 int32_t eventId = pointerEvent->GetId();
57 if (traceBtn == TRACE_START) {
58 if (pointerEvent->GetSourceType() == PointerEvent::SOURCE_TYPE_MOUSE) {
59 StartAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, onPointerEvent, eventId);
60 HITRACE_METER_NAME(HITRACE_TAG_MULTIMODALINPUT, "service report pointerId:" + std::to_string(eventId));
61 } else {
62 StartAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, onTouchEvent, eventId);
63 HITRACE_METER_NAME(HITRACE_TAG_MULTIMODALINPUT, "service report touchId:" + std::to_string(eventId));
64 }
65 } else {
66 if (pointerEvent->GetSourceType() == PointerEvent::SOURCE_TYPE_MOUSE) {
67 FinishAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, onPointerEvent, eventId);
68 } else {
69 FinishAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, onTouchEvent, eventId);
70 }
71 }
72 }
73
StartBytrace(std::shared_ptr<KeyEvent> key,HandlerType handlerType)74 void BytraceAdapter::StartBytrace(std::shared_ptr<KeyEvent> key, HandlerType handlerType)
75 {
76 CHKPV(key);
77 int32_t keyCode = key->GetKeyCode();
78 std::string checkKeyCode;
79 switch (handlerType) {
80 case KEY_INTERCEPT_EVENT: {
81 checkKeyCode = "Intercept keycode:" + std::to_string(keyCode);
82 break;
83 }
84 case KEY_LAUNCH_EVENT: {
85 checkKeyCode = "Launch keycode:" + std::to_string(keyCode);
86 break;
87 }
88 case KEY_SUBSCRIBE_EVENT: {
89 checkKeyCode = "Subscribe keycode:" + std::to_string(keyCode);
90 break;
91 }
92 case KEY_DISPATCH_EVENT: {
93 checkKeyCode = "Dispatch keycode:" + std::to_string(keyCode);
94 break;
95 }
96 default: {
97 checkKeyCode = "Unknown keycode:" + std::to_string(keyCode);
98 break;
99 }
100 }
101 HITRACE_METER_NAME(HITRACE_TAG_MULTIMODALINPUT, checkKeyCode);
102 int32_t keyId = key->GetId();
103 FinishAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, onKeyEvent, keyId);
104 }
105
StartBytrace(std::shared_ptr<KeyEvent> keyEvent,TraceBtn traceBtn,HandlerType handlerType)106 void BytraceAdapter::StartBytrace(std::shared_ptr<KeyEvent> keyEvent, TraceBtn traceBtn, HandlerType handlerType)
107 {
108 CHKPV(keyEvent);
109 int32_t keyId = keyEvent->GetId();
110 int32_t keyCode = keyEvent->GetKeyCode();
111 if (traceBtn == TRACE_START) {
112 switch (handlerType) {
113 case KEY_INTERCEPT_EVENT: {
114 StartAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, keyEventIntercept, keyId);
115 HITRACE_METER_NAME(HITRACE_TAG_MULTIMODALINPUT, "client Intercept keyCode:" + std::to_string(keyCode));
116 break;
117 }
118 case KEY_SUBSCRIBE_EVENT: {
119 StartAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, keyEventSubscribe, keyId);
120 HITRACE_METER_NAME(HITRACE_TAG_MULTIMODALINPUT, "client subscribe keyCode:" + std::to_string(keyCode));
121 break;
122 }
123 case KEY_DISPATCH_EVENT: {
124 StartAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, keyEventDispatch, keyId);
125 HITRACE_METER_NAME(HITRACE_TAG_MULTIMODALINPUT, "client dispatch keyCode:" + std::to_string(keyCode));
126 break;
127 }
128 default: {
129 HITRACE_METER_NAME(HITRACE_TAG_MULTIMODALINPUT, "Unknown keycode:" + std::to_string(keyCode));
130 break;
131 }
132 }
133 } else {
134 switch (handlerType) {
135 case KEY_INTERCEPT_EVENT: {
136 FinishAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, keyEventIntercept, keyId);
137 break;
138 }
139 case KEY_SUBSCRIBE_EVENT: {
140 FinishAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, keyEventSubscribe, keyId);
141 break;
142 }
143 case KEY_DISPATCH_EVENT: {
144 FinishAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, keyEventDispatch, keyId);
145 break;
146 }
147 default: {
148 HITRACE_METER_NAME(HITRACE_TAG_MULTIMODALINPUT, "Unknown keycode:" + std::to_string(keyCode));
149 break;
150 }
151 }
152 }
153 }
154
StartBytrace(std::shared_ptr<PointerEvent> pointerEvent,TraceBtn traceBtn,HandlerType handlerType)155 void BytraceAdapter::StartBytrace(
156 std::shared_ptr<PointerEvent> pointerEvent, TraceBtn traceBtn, HandlerType handlerType)
157 {
158 CHKPV(pointerEvent);
159 int32_t eventId = pointerEvent->GetId();
160 if (traceBtn == TRACE_START) {
161 if (handlerType == POINT_DISPATCH_EVENT) {
162 if (pointerEvent->GetSourceType() == PointerEvent::SOURCE_TYPE_MOUSE) {
163 StartAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, pointerEventDispatch, eventId);
164 HITRACE_METER_NAME(HITRACE_TAG_MULTIMODALINPUT, "client dispatch pointerId:" + std::to_string(eventId));
165 } else {
166 StartAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, touchEventDispatch, eventId);
167 HITRACE_METER_NAME(HITRACE_TAG_MULTIMODALINPUT, "client dispatch touchId:" + std::to_string(eventId));
168 }
169 } else {
170 if (pointerEvent->GetSourceType() == PointerEvent::SOURCE_TYPE_MOUSE) {
171 StartAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, pointerEventIntercept, eventId);
172 HITRACE_METER_NAME(HITRACE_TAG_MULTIMODALINPUT,
173 "client Intercept pointerId:" + std::to_string(eventId));
174 } else {
175 StartAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, touchEventIntercept, eventId);
176 HITRACE_METER_NAME(HITRACE_TAG_MULTIMODALINPUT, "client Intercept touchId:" + std::to_string(eventId));
177 }
178 }
179 } else {
180 if (handlerType == POINT_DISPATCH_EVENT) {
181 if (pointerEvent->GetSourceType() == PointerEvent::SOURCE_TYPE_MOUSE) {
182 FinishAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, pointerEventDispatch, eventId);
183 } else {
184 FinishAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, touchEventDispatch, eventId);
185 }
186 }
187 if (handlerType == POINT_INTERCEPT_EVENT) {
188 if (pointerEvent->GetSourceType() == PointerEvent::SOURCE_TYPE_MOUSE) {
189 FinishAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, pointerEventIntercept, eventId);
190 } else {
191 FinishAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, touchEventIntercept, eventId);
192 }
193 }
194 }
195 }
196
StartBytrace(TraceBtn traceBtn,EventType eventType)197 void BytraceAdapter::StartBytrace(TraceBtn traceBtn, EventType eventType)
198 {
199 std::string checkKeyCode;
200 if (traceBtn == TRACE_START) {
201 switch (eventType) {
202 case START_EVENT: {
203 StartAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, startEvent, START_ID);
204 checkKeyCode = "crossing startId:" + std::to_string(START_ID);
205 HITRACE_METER_NAME(HITRACE_TAG_MULTIMODALINPUT, checkKeyCode);
206 break;
207 }
208 case LAUNCH_EVENT: {
209 StartAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, launchEvent, LAUNCH_ID);
210 checkKeyCode = "crossing launchId:" + std::to_string(LAUNCH_ID);
211 HITRACE_METER_NAME(HITRACE_TAG_MULTIMODALINPUT, checkKeyCode);
212 break;
213 }
214 case STOP_EVENT: {
215 StartAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, stopEvent, STOP_ID);
216 checkKeyCode = "crossing stopId:" + std::to_string(STOP_ID);
217 HITRACE_METER_NAME(HITRACE_TAG_MULTIMODALINPUT, checkKeyCode);
218 break;
219 }
220 }
221 } else {
222 switch (eventType) {
223 case START_EVENT: {
224 FinishAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, keyEventIntercept, START_ID);
225 break;
226 }
227 case LAUNCH_EVENT: {
228 FinishAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, keyEventIntercept, LAUNCH_ID);
229 break;
230 }
231 case STOP_EVENT: {
232 FinishAsyncTrace(HITRACE_TAG_MULTIMODALINPUT, keyEventIntercept, STOP_ID);
233 break;
234 }
235 }
236 }
237 }
238 } // namespace MMI
239 } // namespace OHOS