1 /*
2 * Copyright (c) 2024 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 "log.h"
17 #include "media_event_base_writer.h"
18
19 #ifdef MONITOR_ENABLE_HISYSEVENT
20 #include "hisysevent.h"
21 #endif
22
23 namespace {
24 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN_FOUNDATION, "MediaEventBaseWriter"};
25 }
26
27 namespace OHOS {
28 namespace Media {
29 namespace MediaMonitor {
30
WriteHeasetChange(std::shared_ptr<EventBean> & bean)31 void MediaEventBaseWriter::WriteHeasetChange(std::shared_ptr<EventBean> &bean)
32 {
33 MEDIA_LOG_D("Write heaset change");
34 if (bean == nullptr) {
35 MEDIA_LOG_E("eventBean is nullptr");
36 return;
37 }
38 #ifdef MONITOR_ENABLE_HISYSEVENT
39 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "HEADSET_CHANGE",
40 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
41 "ISCONNECT", bean->GetIntValue("ISCONNECT"),
42 "HASMIC", bean->GetIntValue("HASMIC"),
43 "DEVICETYPE", bean->GetIntValue("DEVICETYPE"));
44 #endif
45 }
46
WriteVolumeChange(std::shared_ptr<EventBean> & bean)47 void MediaEventBaseWriter::WriteVolumeChange(std::shared_ptr<EventBean> &bean)
48 {
49 MEDIA_LOG_D("Write volume change");
50 if (bean == nullptr) {
51 MEDIA_LOG_E("eventBean is nullptr");
52 return;
53 }
54 #ifdef MONITOR_ENABLE_HISYSEVENT
55 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "VOLUME_CHANGE",
56 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
57 "ISOUTPUT", bean->GetIntValue("ISOUTPUT"),
58 "STREAMID", bean->GetIntValue("STREAMID"),
59 "APP_UID", bean->GetIntValue("APP_UID"),
60 "APP_PID", bean->GetIntValue("APP_PID"),
61 "STREAMTYPE", bean->GetIntValue("STREAM_TYPE"),
62 "VOLUME", bean->GetFloatValue("VOLUME"),
63 "SYSVOLUME", bean->GetIntValue("SYSVOLUME"),
64 "VOLUMEFACTOR", bean->GetFloatValue("VOLUMEFACTOR"),
65 "POWERVOLUMEFACTOR", bean->GetFloatValue("POWERVOLUMEFACTOR"));
66 #endif
67 }
68
WriteStreamChange(std::shared_ptr<EventBean> & bean)69 void MediaEventBaseWriter::WriteStreamChange(std::shared_ptr<EventBean> &bean)
70 {
71 MEDIA_LOG_D("Write stream change");
72 if (bean == nullptr) {
73 MEDIA_LOG_E("eventBean is nullptr");
74 return;
75 }
76 #ifdef MONITOR_ENABLE_HISYSEVENT
77 auto ret = HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "STREAM_CHANGE",
78 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
79 "ISOUTPUT", bean->GetIntValue("ISOUTPUT"),
80 "STREAMID", bean->GetIntValue("STREAMID"),
81 "UID", bean->GetIntValue("UID"),
82 "PID", bean->GetIntValue("PID"),
83 "TRANSACTIONID", bean->GetUint64Value("TRANSACTIONID"),
84 "STREAMTYPE", bean->GetIntValue("STREAM_TYPE"),
85 "STATE", bean->GetIntValue("STATE"),
86 "DEVICETYPE", bean->GetIntValue("DEVICETYPE"),
87 "NETWORKID", bean->GetStringValue("NETWORKID"));
88 if (ret) {
89 MEDIA_LOG_E("write event fail: STREAM_CHANGE, ret = %{public}d", ret);
90 }
91 #endif
92 }
93
WriteStreamStandby(std::shared_ptr<EventBean> & bean)94 void MediaEventBaseWriter::WriteStreamStandby(std::shared_ptr<EventBean> &bean)
95 {
96 MEDIA_LOG_D("Write stream standby");
97 if (bean == nullptr) {
98 MEDIA_LOG_E("eventBean is nullptr");
99 return;
100 }
101 #ifdef MONITOR_ENABLE_HISYSEVENT
102 auto ret = HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "STREAM_STANDBY",
103 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
104 "STREAMID", bean->GetIntValue("STREAMID"),
105 "STANDBY", bean->GetIntValue("STANDBY"));
106 if (ret) {
107 MEDIA_LOG_E("write event fail: STREAM_STANDBY, ret = %{public}d", ret);
108 }
109 #endif
110 }
111
WriteSmartPAStatus(std::shared_ptr<EventBean> & bean)112 void MediaEventBaseWriter::WriteSmartPAStatus(std::shared_ptr<EventBean> &bean)
113 {
114 MEDIA_LOG_D("Write smartPA status");
115 if (bean == nullptr) {
116 MEDIA_LOG_E("eventBean is nullptr");
117 return;
118 }
119 #ifdef MONITOR_ENABLE_HISYSEVENT
120 auto ret = HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "SMARTPA_STATUS",
121 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
122 "STATUS", bean->GetIntValue("STATUS"));
123 if (ret) {
124 MEDIA_LOG_E("write event fail: SMARTPA_STATUS, ret = %{public}d", ret);
125 }
126 #endif
127 }
128
WriteDeviceChange(std::shared_ptr<EventBean> & bean)129 void MediaEventBaseWriter::WriteDeviceChange(std::shared_ptr<EventBean> &bean)
130 {
131 MEDIA_LOG_D("Write device Change");
132 if (bean == nullptr) {
133 MEDIA_LOG_E("eventBean is nullptr");
134 return;
135 }
136 #ifdef MONITOR_ENABLE_HISYSEVENT
137 auto ret = HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "DEVICE_CHANGE",
138 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
139 "ISOUTPUT", bean->GetIntValue("ISOUTPUT"),
140 "STREAMID", bean->GetIntValue("STREAMID"),
141 "STREAMTYPE", bean->GetIntValue("STREAM_TYPE"),
142 "DEVICETYPE", bean->GetIntValue("DEVICETYPE"),
143 "NETWORKID", bean->GetStringValue("NETWORKID"),
144 "ADDRESS", bean->GetStringValue("ADDRESS"),
145 "DEVICE_DETAILED_CATEGORY", bean->GetStringValue("DEVICE_NAME"));
146 if (ret) {
147 MEDIA_LOG_E("write event fail: DEVICE_CHANGE, ret = %{public}d", ret);
148 }
149 #endif
150 }
151
WriteNoiseSuppression(std::shared_ptr<EventBean> & bean)152 void MediaEventBaseWriter::WriteNoiseSuppression(std::shared_ptr<EventBean> &bean)
153 {
154 MEDIA_LOG_D("Write noise suppression");
155 if (bean == nullptr) {
156 MEDIA_LOG_E("eventBean is nullptr");
157 return;
158 }
159 #ifdef MONITOR_ENABLE_HISYSEVENT
160 auto ret = HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "AI_VOICE_NOISE_SUPPRESSION",
161 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
162 "CURRENT_VALUE", bean->GetIntValue("CURRENT_VALUE"));
163 if (ret) {
164 MEDIA_LOG_E("write event fail: AI_VOICE_NOISE_SUPPRESSION, ret = %{public}d", ret);
165 }
166 #endif
167 }
168
WriteLoadConfigError(std::shared_ptr<EventBean> & bean)169 void MediaEventBaseWriter::WriteLoadConfigError(std::shared_ptr<EventBean> &bean)
170 {
171 MEDIA_LOG_D("Write load config error");
172 if (bean == nullptr) {
173 MEDIA_LOG_E("eventBean is nullptr");
174 return;
175 }
176 #ifdef MONITOR_ENABLE_HISYSEVENT
177 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "LOAD_CONFIG_ERROR",
178 HiviewDFX::HiSysEvent::EventType::FAULT,
179 "CATEGORY", static_cast<uint16_t>(bean->GetIntValue("CATEGORY")));
180 #endif
181 }
182
WriteLoadEffectEngineError(std::shared_ptr<EventBean> & bean)183 void MediaEventBaseWriter::WriteLoadEffectEngineError(std::shared_ptr<EventBean> &bean)
184 {
185 MEDIA_LOG_D("Write load effect engine error");
186 if (bean == nullptr) {
187 MEDIA_LOG_E("eventBean is nullptr");
188 return;
189 }
190 #ifdef MONITOR_ENABLE_HISYSEVENT
191 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "LOAD_EFFECT_ENGINE_ERROR",
192 HiviewDFX::HiSysEvent::EventType::FAULT,
193 "ENGINE_TYPE", static_cast<uint16_t>(bean->GetIntValue("ENGINE_TYPE")));
194 #endif
195 }
196
WriteAppWriteMute(std::shared_ptr<EventBean> & bean)197 void MediaEventBaseWriter::WriteAppWriteMute(std::shared_ptr<EventBean> &bean)
198 {
199 MEDIA_LOG_D("app write mute");
200 if (bean == nullptr) {
201 MEDIA_LOG_E("eventBean is nullptr");
202 return;
203 }
204 #ifdef MONITOR_ENABLE_HISYSEVENT
205 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "APP_WRITE_MUTE",
206 HiviewDFX::HiSysEvent::EventType::STATISTIC,
207 "APP_BUNDLE_NAME", bean->GetStringValue("APP_BUNDLE_NAME"),
208 "STREAM_TYPE", static_cast<uint8_t>(bean->GetIntValue("STREAM_TYPE")),
209 "SESSION_ID", static_cast<uint32_t>(bean->GetIntValue("SESSION_ID")),
210 "STREAM_VOLUME", bean->GetFloatValue("STREAM_VOLUME"),
211 "MUTE_STATE", static_cast<uint8_t>(bean->GetIntValue("MUTE_STATE")),
212 "APP_BACKGROUND_STATE", static_cast<uint8_t>(bean->GetIntValue("APP_BACKGROUND_STATE")),
213 "MUTE_PLAY_START_TIME", bean->GetUint64Value("MUTE_PLAY_START_TIME"),
214 "MUTE_PLAY_DURATION", static_cast<uint32_t>(bean->GetIntValue("MUTE_PLAY_DURATION")));
215 #endif
216 }
217
WriteHdiException(std::shared_ptr<EventBean> & bean)218 void MediaEventBaseWriter::WriteHdiException(std::shared_ptr<EventBean> &bean)
219 {
220 MEDIA_LOG_D("Write Hdi Exception error");
221 if (bean == nullptr) {
222 MEDIA_LOG_E("eventBean is nullptr");
223 return;
224 }
225 #ifdef MONITOR_ENABLE_HISYSEVENT
226 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "HDI_EXCEPTION",
227 HiviewDFX::HiSysEvent::EventType::FAULT,
228 "HDI_TYPE", static_cast<uint8_t>(bean->GetIntValue("HDI_TYPE")),
229 "ERROR_CASE", static_cast<uint32_t>(bean->GetIntValue("ERROR_CASE")),
230 "ERROR_MSG", bean->GetIntValue("ERROR_MSG"),
231 "ERROR_DESCRIPTION", bean->GetStringValue("ERROR_DESCRIPTION"));
232 #endif
233 }
234
WriteJankPlaybackError(std::shared_ptr<EventBean> & bean)235 void MediaEventBaseWriter::WriteJankPlaybackError(std::shared_ptr<EventBean> &bean)
236 {
237 MEDIA_LOG_D("Write jank playback error");
238 if (bean == nullptr) {
239 MEDIA_LOG_E("eventBean is nullptr");
240 return;
241 }
242 #ifdef MONITOR_ENABLE_HISYSEVENT
243 int32_t reason = bean->GetIntValue("REASON");
244 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "JANK_PLAYBACK",
245 HiviewDFX::HiSysEvent::EventType::FAULT,
246 "REASON", static_cast<uint8_t>(reason),
247 "PERIOD_MS", static_cast<uint32_t>(bean->GetIntValue("PERIOD_MS")),
248 "PIPE_TYPE", static_cast<uint8_t>(bean->GetIntValue("PIPE_TYPE")),
249 "HDI_ADAPTER", static_cast<uint8_t>(bean->GetIntValue("HDI_ADAPTER")),
250 "POSITION", static_cast<uint8_t>(bean->GetIntValue("POSITION")),
251 "APP_NAME", (reason == 0 ? bean->GetStringValue("APP_NAMES") : bean->GetStringValue("APP_NAME")),
252 "JANK_START_TIME", static_cast<int64_t>(bean->GetUint64Value("JANK_START_TIME")));
253 #endif
254 }
255
WriteAudioStartupError(std::shared_ptr<EventBean> & bean)256 void MediaEventBaseWriter::WriteAudioStartupError(std::shared_ptr<EventBean> &bean)
257 {
258 MEDIA_LOG_D("Write audio startup error");
259 if (bean == nullptr) {
260 MEDIA_LOG_E("eventBean is nullptr");
261 return;
262 }
263 #ifdef MONITOR_ENABLE_HISYSEVENT
264 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "AUDIO_SERVICE_STARTUP_ERROR",
265 HiviewDFX::HiSysEvent::EventType::FAULT,
266 "SERVICE_ID", static_cast<uint>(bean->GetIntValue("SERVICE_ID")),
267 "ERROR_CODE", static_cast<uint32_t>(bean->GetIntValue("ERROR_CODE")));
268 #endif
269 }
270
WriteStreamExhastedError(std::shared_ptr<EventBean> & bean)271 void MediaEventBaseWriter::WriteStreamExhastedError(std::shared_ptr<EventBean> &bean)
272 {
273 MEDIA_LOG_D("Write stream exhasted error");
274 if (bean == nullptr) {
275 MEDIA_LOG_E("eventBean is nullptr");
276 return;
277 }
278 #ifdef MONITOR_ENABLE_HISYSEVENT
279 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "AUDIO_STREAM_EXHAUSTED_STATS",
280 HiviewDFX::HiSysEvent::EventType::STATISTIC,
281 "DUBIOUS_APP", bean->GetStringValue("DUBIOUS_APP"),
282 "TIMES", static_cast<uint32_t>(bean->GetIntValue("TIMES")));
283 #endif
284 }
285
WriteStreamCreateError(std::shared_ptr<EventBean> & bean)286 void MediaEventBaseWriter::WriteStreamCreateError(std::shared_ptr<EventBean> &bean)
287 {
288 MEDIA_LOG_D("Write stream create error");
289 if (bean == nullptr) {
290 MEDIA_LOG_E("eventBean is nullptr");
291 return;
292 }
293 #ifdef MONITOR_ENABLE_HISYSEVENT
294 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "AUDIO_STREAM_CREATE_ERROR_STATS",
295 HiviewDFX::HiSysEvent::EventType::STATISTIC,
296 "APP_NAME", bean->GetStringValue("APP_NAME"),
297 "IS_PLAYBACK", static_cast<bool>(bean->GetIntValue("IS_PLAYBACK")),
298 "STREAM_TYPE", static_cast<uint>(bean->GetIntValue("STREAM_TYPE")),
299 "ERROR_CODE", bean->GetIntValue("ERROR_CODE"),
300 "TIMES", static_cast<uint32_t>(bean->GetIntValue("TIMES")));
301 #endif
302 }
303
WriteBackgoundSilentPlayback(std::shared_ptr<EventBean> & bean)304 void MediaEventBaseWriter::WriteBackgoundSilentPlayback(std::shared_ptr<EventBean> &bean)
305 {
306 MEDIA_LOG_D("Write backgound silent playback");
307 if (bean == nullptr) {
308 MEDIA_LOG_E("eventBean is nullptr");
309 return;
310 }
311 #ifdef MONITOR_ENABLE_HISYSEVENT
312 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "BACKGROUND_SILENT_PLAYBACK",
313 HiviewDFX::HiSysEvent::EventType::STATISTIC,
314 "APP_NAME", bean->GetStringValue("APP_NAME"),
315 "APP_VERSION_CODE", static_cast<uint32_t>(bean->GetIntValue("APP_VERSION_CODE")),
316 "TIMES", static_cast<uint32_t>(bean->GetIntValue("TIMES")));
317 #endif
318 }
319
WriteBGSilentPlayback(std::shared_ptr<EventBean> & bean)320 void MediaEventBaseWriter::WriteBGSilentPlayback(std::shared_ptr<EventBean> &bean)
321 {
322 MEDIA_LOG_D("Write bg silent playback");
323 if (bean == nullptr) {
324 MEDIA_LOG_E("eventBean is nullptr");
325 return;
326 }
327 #ifdef MONITOR_ENABLE_HISYSEVENT
328 auto ret = HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "BG_SILENT_PLAYBACK",
329 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
330 "APP_NAME", bean->GetStringValue("APP_NAME"),
331 "APP_VERSION_CODE", static_cast<uint32_t>(bean->GetIntValue("APP_VERSION_CODE")));
332 if (ret) {
333 MEDIA_LOG_E("write event fail: BG_SILENT_PLAYBACK, ret = %{public}d", ret);
334 }
335 #endif
336 }
337
WriteExcludeOutputDevice(std::shared_ptr<EventBean> & bean)338 void MediaEventBaseWriter::WriteExcludeOutputDevice(std::shared_ptr<EventBean> &bean)
339 {
340 MEDIA_LOG_D("Write exclude output device");
341 if (bean == nullptr) {
342 MEDIA_LOG_E("eventBean is nullptr");
343 return;
344 }
345 #ifdef MONITOR_ENABLE_HISYSEVENT
346 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "EXCLUDE_OUTPUT_DEVICE",
347 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
348 "APP_NAME", bean->GetStringValue("APP_NAME"),
349 "EXCLUSION_STATUS", static_cast<uint>(bean->GetIntValue("EXCLUSION_STATUS")),
350 "AUDIO_DEVICE_USAGE", static_cast<uint>(bean->GetIntValue("AUDIO_DEVICE_USAGE")),
351 "DEVICE_TYPE", bean->GetIntValue("DEVICE_TYPE"));
352 #endif
353 }
354
WriteSetForceDevice(std::shared_ptr<EventBean> & bean)355 void MediaEventBaseWriter::WriteSetForceDevice(std::shared_ptr<EventBean> &bean)
356 {
357 MEDIA_LOG_D("Write set force use device");
358 if (bean == nullptr) {
359 MEDIA_LOG_E("eventBean is nullptr");
360 return;
361 }
362 #ifdef MONITOR_ENABLE_HISYSEVENT
363 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "SET_FORCE_USE_AUDIO_DEVICE",
364 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
365 "APP_NAME", bean->GetStringValue("APP_NAME"),
366 "DEVICE_TYPE", static_cast<uint>(bean->GetIntValue("DEVICE_TYPE")),
367 "IS_PLAYBACK", static_cast<bool>(bean->GetIntValue("IS_PLAYBACK")),
368 "STREAM_TYPE", static_cast<uint>(bean->GetIntValue("STREAM_TYPE")));
369 #endif
370 }
371
WriteDeviceStatistic(std::shared_ptr<EventBean> & bean)372 void MediaEventBaseWriter::WriteDeviceStatistic(std::shared_ptr<EventBean> &bean)
373 {
374 MEDIA_LOG_D("Write device statistic duration");
375 if (bean == nullptr) {
376 MEDIA_LOG_E("eventBean is nullptr");
377 return;
378 }
379 #ifdef MONITOR_ENABLE_HISYSEVENT
380 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "AUDIO_DEVICE_UTILIZATION_STATS",
381 HiviewDFX::HiSysEvent::EventType::STATISTIC,
382 "IS_PLAYBACK", static_cast<bool>(bean->GetIntValue("IS_PLAYBACK")),
383 "DEVICE_TYPE", static_cast<uint>(bean->GetIntValue("DEVICE_TYPE")),
384 "STREAM_TYPE", static_cast<uint>(bean->GetIntValue("STREAM_TYPE")),
385 "DURATION", static_cast<uint32_t>(bean->GetUint64Value("DURATION")));
386 #endif
387 }
388
WriteBtUsageStatistic(std::shared_ptr<EventBean> & bean)389 void MediaEventBaseWriter::WriteBtUsageStatistic(std::shared_ptr<EventBean> &bean)
390 {
391 MEDIA_LOG_D("Write bt usage statistic duration");
392 if (bean == nullptr) {
393 MEDIA_LOG_E("eventBean is nullptr");
394 return;
395 }
396 #ifdef MONITOR_ENABLE_HISYSEVENT
397 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "BT_UTILIZATION_STATS",
398 HiviewDFX::HiSysEvent::EventType::STATISTIC,
399 "IS_PLAYBACK", static_cast<bool>(bean->GetIntValue("IS_PLAYBACK")),
400 "BT_TYPE", static_cast<uint>(bean->GetIntValue("BT_TYPE")),
401 "STREAM_TYPE", static_cast<uint>(bean->GetIntValue("STREAM_TYPE")),
402 "DURATION", static_cast<uint32_t>(bean->GetUint64Value("DURATION")));
403 #endif
404 }
405
WriteStreamStatistic(std::shared_ptr<EventBean> & bean)406 void MediaEventBaseWriter::WriteStreamStatistic(std::shared_ptr<EventBean> &bean)
407 {
408 MEDIA_LOG_D("Write stream statistic duration");
409 if (bean == nullptr) {
410 MEDIA_LOG_E("eventBean is nullptr");
411 return;
412 }
413 #ifdef MONITOR_ENABLE_HISYSEVENT
414 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "STREAM_UTILIZATION_STATS",
415 HiviewDFX::HiSysEvent::EventType::STATISTIC,
416 "IS_PLAYBACK", static_cast<bool>(bean->GetIntValue("IS_PLAYBACK")),
417 "PIPE_TYPE", static_cast<uint>(bean->GetIntValue("PIPE_TYPE")),
418 "STREAM_TYPE", static_cast<uint>(bean->GetIntValue("STREAM_TYPE")),
419 "SAMPLE_RATE", static_cast<uint>(bean->GetIntValue("SAMPLE_RATE")),
420 "APP_NAME", bean->GetStringValue("APP_NAME"),
421 "EFFECT_CHAIN", static_cast<uint>(bean->GetIntValue("EFFECT_CHAIN")),
422 "DURATION", static_cast<uint32_t>(bean->GetUint64Value("DURATION")));
423 #endif
424 }
425
WriteStreamPropertyStatistic(std::shared_ptr<EventBean> & bean)426 void MediaEventBaseWriter::WriteStreamPropertyStatistic(std::shared_ptr<EventBean> &bean)
427 {
428 MEDIA_LOG_D("Write stream property statistic duration");
429 if (bean == nullptr) {
430 MEDIA_LOG_E("eventBean is nullptr");
431 return;
432 }
433 #ifdef MONITOR_ENABLE_HISYSEVENT
434 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "STREAM_PROPERTY_STATS",
435 HiviewDFX::HiSysEvent::EventType::STATISTIC,
436 "IS_PLAYBACK", static_cast<bool>(bean->GetIntValue("IS_PLAYBACK")),
437 "STREAM_TYPE", static_cast<uint>(bean->GetIntValue("STREAM_TYPE")),
438 "APP_NAME", bean->GetStringValue("APP_NAME"),
439 "ENCODING_TYPE", static_cast<uint>(bean->GetIntValue("ENCODING_TYPE")),
440 "CHANNEL_LAYOUT", static_cast<uint64_t>(bean->GetUint64Value("CHANNEL_LAYOUT")),
441 "DURATION", static_cast<uint32_t>(bean->GetUint64Value("DURATION")));
442 #endif
443 }
444
WriteUnderrunStatistic(std::shared_ptr<EventBean> & bean)445 void MediaEventBaseWriter::WriteUnderrunStatistic(std::shared_ptr<EventBean> &bean)
446 {
447 MEDIA_LOG_D("Write underrun statistic times");
448 if (bean == nullptr) {
449 MEDIA_LOG_E("eventBean is nullptr");
450 return;
451 }
452 #ifdef MONITOR_ENABLE_HISYSEVENT
453 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "PERFORMANCE_UNDER_OVERRUN_STATS",
454 HiviewDFX::HiSysEvent::EventType::STATISTIC,
455 "IS_PLAYBACK", static_cast<bool>(bean->GetIntValue("IS_PLAYBACK")),
456 "STREAM_TYPE", static_cast<uint>(bean->GetIntValue("STREAM_TYPE")),
457 "PIPE_TYPE", static_cast<uint>(bean->GetIntValue("PIPE_TYPE")),
458 "APP_NAME", bean->GetStringValue("APP_NAME"),
459 "TIMES", static_cast<uint32_t>(bean->GetIntValue("TIMES")));
460 #endif
461 }
462
WriteAudioPipeChange(std::shared_ptr<EventBean> & bean)463 void MediaEventBaseWriter::WriteAudioPipeChange(std::shared_ptr<EventBean> &bean)
464 {
465 MEDIA_LOG_D("Write audio pipe change");
466 if (bean == nullptr) {
467 MEDIA_LOG_E("eventBean is nullptr");
468 return;
469 }
470 #ifdef MONITOR_ENABLE_HISYSEVENT
471 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "AUDIO_PIPE_CHANGE",
472 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
473 "APP_NAME", bean->GetStringValue("APP_NAME"),
474 "STREAM_TYPE", static_cast<uint>(bean->GetIntValue("STREAM_TYPE")),
475 "IS_PLAYBACK", static_cast<bool>(bean->GetIntValue("IS_PLAYBACK")),
476 "PIPE_TYPE_BEFORE_CHANGE", static_cast<uint>(bean->GetIntValue("PIPE_TYPE_BEFORE_CHANGE")),
477 "PIPE_TYPE_AFTER_CHANGE", static_cast<uint>(bean->GetIntValue("PIPE_TYPE_AFTER_CHANGE")),
478 "REASON", static_cast<uint>(bean->GetIntValue("REASON")));
479 #endif
480 }
481
WriteAudioRouteChange(std::shared_ptr<EventBean> & bean)482 void MediaEventBaseWriter::WriteAudioRouteChange(std::shared_ptr<EventBean> &bean)
483 {
484 MEDIA_LOG_D("Write audio route Change");
485 if (bean == nullptr) {
486 MEDIA_LOG_E("eventBean is nullptr");
487 return;
488 }
489 #ifdef MONITOR_ENABLE_HISYSEVENT
490 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "AUDIO_ROUTE_CHANGE",
491 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
492 "TIMESTAMP", bean->GetUint64Value("TIMESTAMP"),
493 "DEVICE_TYPE_BEFORE_CHANGE", static_cast<uint>(bean->GetIntValue("DEVICE_TYPE_BEFORE_CHANGE")),
494 "DEVICE_TYPE_AFTER_CHANGE", static_cast<uint>(bean->GetIntValue("DEVICE_TYPE_AFTER_CHANGE")),
495 "REASON", static_cast<uint>(bean->GetIntValue("REASON")),
496 "PRE_AUDIO_SCENE", static_cast<int8_t>(bean->GetIntValue("PRE_AUDIO_SCENE")),
497 "CUR_AUDIO_SCENE", static_cast<int8_t>(bean->GetIntValue("CUR_AUDIO_SCENE")),
498 "DEVICE_LIST", bean->GetStringValue("DEVICE_LIST"),
499 "ROUTER_TYPE", static_cast<uint8_t>(bean->GetIntValue("ROUTER_TYPE")));
500 #endif
501 }
502
WriteDbAccessException(std::shared_ptr<EventBean> & bean)503 void MediaEventBaseWriter::WriteDbAccessException(std::shared_ptr<EventBean> &bean)
504 {
505 MEDIA_LOG_D("Write db access exception");
506 if (bean == nullptr) {
507 MEDIA_LOG_E("eventBean is nullptr");
508 return;
509 }
510 #ifdef MONITOR_ENABLE_HISYSEVENT
511 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "DB_ACCESS_EXCEPTION",
512 HiviewDFX::HiSysEvent::EventType::FAULT,
513 "DB_TYPE", bean->GetStringValue("DB_TYPE"),
514 "ERROR_CASE", static_cast<uint32_t>(bean->GetIntValue("ERROR_CASE")),
515 "ERROR_MSG", bean->GetIntValue("ERROR_MSG"),
516 "ERROR_DESCRIPTION", bean->GetStringValue("ERROR_DESCRIPTION"));
517 #endif
518 }
519
WriteDeviceChangeException(std::shared_ptr<EventBean> & bean)520 void MediaEventBaseWriter::WriteDeviceChangeException(std::shared_ptr<EventBean> &bean)
521 {
522 MEDIA_LOG_D("Write device change exception");
523 if (bean == nullptr) {
524 MEDIA_LOG_E("eventBean is nullptr");
525 return;
526 }
527 #ifdef MONITOR_ENABLE_HISYSEVENT
528 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "DEVICE_CHANGE_EXCEPTION",
529 HiviewDFX::HiSysEvent::EventType::FAULT,
530 "CHANGE_REASON", static_cast<uint8_t>(bean->GetIntValue("CHANGE_REASON")),
531 "DEVICE_TYPE", bean->GetIntValue("DEVICE_TYPE"),
532 "ERROR_CASE", static_cast<uint32_t>(bean->GetIntValue("ERROR_CASE")),
533 "ERROR_MSG", bean->GetIntValue("ERROR_MSG"),
534 "ERROR_DESCRIPTION", bean->GetStringValue("ERROR_DESCRIPTION"));
535 #endif
536 }
537
WriteFocusMigrate(std::shared_ptr<EventBean> & bean)538 void MediaEventBaseWriter::WriteFocusMigrate(std::shared_ptr<EventBean> &bean)
539 {
540 MEDIA_LOG_D("Write focus migrate");
541 if (bean == nullptr) {
542 MEDIA_LOG_E("eventBean is nullptr");
543 return;
544 }
545 #ifdef MONITOR_ENABLE_HISYSEVENT
546 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "AUDIO_FOCUS_MIGRATE",
547 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
548 "DEVICE_DESC", bean->GetStringValue("DEVICE_DESC"),
549 "APP_NAME", bean->GetStringValue("APP_NAME"),
550 "MIGRATE_DIRECTION", static_cast<uint>(bean->GetIntValue("MIGRATE_DIRECTION")));
551 #endif
552 }
553
WriteMutedCapture(std::shared_ptr<EventBean> & bean)554 void MediaEventBaseWriter::WriteMutedCapture(std::shared_ptr<EventBean> &bean)
555 {
556 MEDIA_LOG_D("Write muted capture duration");
557 if (bean == nullptr) {
558 MEDIA_LOG_E("eventBean is nullptr");
559 return;
560 }
561 #ifdef MONITOR_ENABLE_HISYSEVENT
562 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "MUTED_CAPTURE_STATS",
563 HiviewDFX::HiSysEvent::EventType::STATISTIC,
564 "STREAM_TYPE", static_cast<uint>(bean->GetIntValue("STREAM_TYPE")),
565 "DEVICE_TYPE", static_cast<uint>(bean->GetIntValue("DEVICE_TYPE")),
566 "DURATION", static_cast<uint32_t>(bean->GetUint64Value("DURATION")));
567 #endif
568 }
569
WriteCustomizedToneChange(std::shared_ptr<EventBean> & bean)570 void MediaEventBaseWriter::WriteCustomizedToneChange(std::shared_ptr<EventBean> &bean)
571 {
572 MEDIA_LOG_I("Write customzed tone change subscription");
573 if (bean == nullptr) {
574 MEDIA_LOG_E("eventBean is nullptr");
575 return;
576 }
577 #ifdef MONITOR_ENABLE_HISYSEVENT
578 auto ret = HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "ADD_REMOVE_CUSTOMIZED_TONE",
579 HiviewDFX::HiSysEvent::EventType::STATISTIC,
580 "ADD_REMOVE_OPERATION", static_cast<bool>(bean->GetIntValue("ADD_REMOVE_OPERATION")),
581 "APP_NAME", bean->GetStringValue("APP_NAME"),
582 "FILE_SIZE", static_cast<uint32_t>(bean->GetUint64Value("FILE_SIZE")),
583 "RINGTONE_CATEGORY", bean->GetIntValue("RINGTONE_CATEGORY"),
584 "MEDIA_TYPE", static_cast<int8_t>(bean->GetIntValue("MEDIA_TYPE")),
585 "MIME_TYPE", bean->GetStringValue("MIME_TYPE"),
586 "TIMESTAMP", bean->GetUint64Value("TIMESTAMP"),
587 "RESULT", static_cast<int8_t>(bean->GetIntValue("RESULT")));
588 if (ret) {
589 MEDIA_LOG_E("write event fail: ADD_REMOVE_CUSTOMIZED_TONE, ret = %{public}d", ret);
590 }
591 #endif
592 }
593
WritePlaybackVolume(std::shared_ptr<EventBean> & bean)594 void MediaEventBaseWriter::WritePlaybackVolume(std::shared_ptr<EventBean> &bean)
595 {
596 MEDIA_LOG_D("Write playback volume duration");
597 if (bean == nullptr) {
598 MEDIA_LOG_E("eventBean is nullptr");
599 return;
600 }
601 #ifdef MONITOR_ENABLE_HISYSEVENT
602 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "PLAYBACK_VOLUME_STATS",
603 HiviewDFX::HiSysEvent::EventType::STATISTIC,
604 "LEVEL", static_cast<uint>(bean->GetIntValue("LEVEL")),
605 "STREAM_TYPE", static_cast<uint>(bean->GetIntValue("STREAM_TYPE")),
606 "DEVICE_TYPE", static_cast<uint>(bean->GetIntValue("DEVICE_TYPE")),
607 "DURATION", static_cast<uint32_t>(bean->GetUint64Value("DURATION")));
608 #endif
609 }
610
WriteVolumeSubscribe(std::shared_ptr<EventBean> & bean)611 void MediaEventBaseWriter::WriteVolumeSubscribe(std::shared_ptr<EventBean> &bean)
612 {
613 MEDIA_LOG_D("Write volume subscription");
614 if (bean == nullptr) {
615 MEDIA_LOG_E("eventBean is nullptr");
616 return;
617 }
618 #ifdef MONITOR_ENABLE_HISYSEVENT
619 auto ret = HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "VOLUME_SUBSCRIBE",
620 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
621 "SUBSCRIBE_KEY", bean->GetStringValue("SUBSCRIBE_KEY"),
622 "SUBSCRIBE_RESULT", static_cast<uint32_t>(bean->GetIntValue("SUBSCRIBE_RESULT")));
623 if (ret) {
624 MEDIA_LOG_E("write event fail: VOLUME_SUBSCRIBE, ret = %{public}d", ret);
625 }
626 #endif
627 }
628
WriteSystemTonePlayback(const std::unique_ptr<DfxSystemTonePlaybackResult> & result)629 void MediaEventBaseWriter::WriteSystemTonePlayback(const std::unique_ptr<DfxSystemTonePlaybackResult> &result)
630 {
631 #ifdef MONITOR_ENABLE_HISYSEVENT
632 MEDIA_LOG_I("Write system tone playback MONITOR_ENABLE_HISYSEVENT");
633 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "SYSTEM_TONE_PLAYBACK",
634 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
635 "TIME_STAMP", result->timeStamp,
636 "SYSTEM_SOUND_TYPE", result->systemSoundType,
637 "CLIENT_UID", result->clientUid,
638 "DEVICE_TYPE", result->deviceType,
639 "ERROR_CODE", result->errorCode,
640 "ERROR_REASON", result->errorReason,
641 "MUTE_STATE", result->muteState,
642 "MUTE_HAPTICS", result->muteHaptics,
643 "RING_MODE", result->ringMode,
644 "STREAM_TYPE", result->streamType,
645 "VIBRATION_STATE", result->vibrationState,
646 "VOLUME_LEVEL", result->volumeLevel);
647 MEDIA_LOG_I("Write system tone playback end");
648 #endif
649 }
650
WriteStreamOccupancy(std::shared_ptr<EventBean> & bean)651 void MediaEventBaseWriter::WriteStreamOccupancy(std::shared_ptr<EventBean> &bean)
652 {
653 MEDIA_LOG_D("Write stream occupancy");
654 if (bean == nullptr) {
655 MEDIA_LOG_E("eventBean is nullptr");
656 return;
657 }
658 #ifdef MONITOR_ENABLE_HISYSEVENT
659 auto ret = HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "STREAM_OCCUPANCY",
660 HiviewDFX::HiSysEvent::EventType::STATISTIC,
661 "IS_PLAYBACK", static_cast<bool>(bean->GetIntValue("IS_PLAYBACK")),
662 "SESSIONID", bean->GetIntValue("SESSIONID"),
663 "UID", bean->GetIntValue("UID"),
664 "PKGNAME", bean->GetStringValue("PKGNAME"),
665 "STREAM_OR_SOURCE_TYPE", bean->GetIntValue("STREAM_OR_SOURCE_TYPE"),
666 "START_TIME", static_cast<int64_t>(bean->GetUint64Value("START_TIME")),
667 "UPLOAD_TIME", static_cast<int64_t>(bean->GetUint64Value("UPLOAD_TIME")));
668 if (ret) {
669 MEDIA_LOG_E("write event fail: STREAM_OCCUPANCY, ret = %{public}d", ret);
670 }
671 #endif
672 }
673
WriteAudioRecordError(std::shared_ptr<EventBean> & bean)674 void MediaEventBaseWriter::WriteAudioRecordError(std::shared_ptr<EventBean> &bean)
675 {
676 MEDIA_LOG_D("Write audio record error");
677 if (bean == nullptr) {
678 MEDIA_LOG_E("eventBean is nullptr");
679 return;
680 }
681 #ifdef MONITOR_ENABLE_HISYSEVENT
682 auto ret = HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "RECORD_ERROR",
683 HiviewDFX::HiSysEvent::EventType::FAULT,
684 "INCOMING_SOURCE", static_cast<uint8_t>(bean->GetIntValue("INCOMING_SOURCE")),
685 "INCOMING_PID", bean->GetIntValue("INCOMING_PID"),
686 "INCOMING_PKG", bean->GetStringValue("INCOMING_PKG"),
687 "ACTIVE_SOURCE", static_cast<uint8_t>(bean->GetIntValue("ACTIVE_SOURCE")),
688 "ACTIVE_PID", bean->GetIntValue("ACTIVE_PID"),
689 "ACTIVE_PKG", bean->GetStringValue("ACTIVE_PKG"),
690 "REASON", bean->GetIntValue("REASON"));
691 if (ret) {
692 MEDIA_LOG_E("write event fail: RECORD_ERROR, ret = %{public}d", ret);
693 }
694 #endif
695 }
696 } // namespace MediaMonitor
697 } // namespace Media
698 } // namespace OHOS