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
WriteJankPlaybackError(std::shared_ptr<EventBean> & bean)197 void MediaEventBaseWriter::WriteJankPlaybackError(std::shared_ptr<EventBean> &bean)
198 {
199 MEDIA_LOG_D("Write jank playback error");
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, "JANK_PLAYBACK",
206 HiviewDFX::HiSysEvent::EventType::FAULT,
207 "REASON", static_cast<uint8_t>(bean->GetIntValue("REASON")),
208 "PERIOD_MS", static_cast<uint32_t>(bean->GetIntValue("PERIOD_MS")),
209 "PIPE_TYPE", static_cast<uint8_t>(bean->GetIntValue("PIPE_TYPE")),
210 "HDI_ADAPTER", static_cast<uint8_t>(bean->GetIntValue("HDI_ADAPTER")));
211 #endif
212 }
213
WriteAudioStartupError(std::shared_ptr<EventBean> & bean)214 void MediaEventBaseWriter::WriteAudioStartupError(std::shared_ptr<EventBean> &bean)
215 {
216 MEDIA_LOG_D("Write audio startup error");
217 if (bean == nullptr) {
218 MEDIA_LOG_E("eventBean is nullptr");
219 return;
220 }
221 #ifdef MONITOR_ENABLE_HISYSEVENT
222 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "AUDIO_SERVICE_STARTUP_ERROR",
223 HiviewDFX::HiSysEvent::EventType::FAULT,
224 "SERVICE_ID", static_cast<uint>(bean->GetIntValue("SERVICE_ID")),
225 "ERROR_CODE", static_cast<uint32_t>(bean->GetIntValue("ERROR_CODE")));
226 #endif
227 }
228
WriteStreamExhastedError(std::shared_ptr<EventBean> & bean)229 void MediaEventBaseWriter::WriteStreamExhastedError(std::shared_ptr<EventBean> &bean)
230 {
231 MEDIA_LOG_D("Write stream exhasted error");
232 if (bean == nullptr) {
233 MEDIA_LOG_E("eventBean is nullptr");
234 return;
235 }
236 #ifdef MONITOR_ENABLE_HISYSEVENT
237 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "AUDIO_STREAM_EXHAUSTED_STATS",
238 HiviewDFX::HiSysEvent::EventType::STATISTIC,
239 "DUBIOUS_APP", bean->GetStringValue("DUBIOUS_APP"),
240 "TIMES", static_cast<uint32_t>(bean->GetIntValue("TIMES")));
241 #endif
242 }
243
WriteStreamCreateError(std::shared_ptr<EventBean> & bean)244 void MediaEventBaseWriter::WriteStreamCreateError(std::shared_ptr<EventBean> &bean)
245 {
246 MEDIA_LOG_D("Write stream create error");
247 if (bean == nullptr) {
248 MEDIA_LOG_E("eventBean is nullptr");
249 return;
250 }
251 #ifdef MONITOR_ENABLE_HISYSEVENT
252 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "AUDIO_STREAM_CREATE_ERROR_STATS",
253 HiviewDFX::HiSysEvent::EventType::STATISTIC,
254 "APP_NAME", bean->GetStringValue("APP_NAME"),
255 "IS_PLAYBACK", static_cast<bool>(bean->GetIntValue("IS_PLAYBACK")),
256 "STREAM_TYPE", static_cast<uint>(bean->GetIntValue("STREAM_TYPE")),
257 "ERROR_CODE", bean->GetIntValue("ERROR_CODE"),
258 "TIMES", static_cast<uint32_t>(bean->GetIntValue("TIMES")));
259 #endif
260 }
261
WriteBackgoundSilentPlayback(std::shared_ptr<EventBean> & bean)262 void MediaEventBaseWriter::WriteBackgoundSilentPlayback(std::shared_ptr<EventBean> &bean)
263 {
264 MEDIA_LOG_D("Write backgound silent playback");
265 if (bean == nullptr) {
266 MEDIA_LOG_E("eventBean is nullptr");
267 return;
268 }
269 #ifdef MONITOR_ENABLE_HISYSEVENT
270 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "BACKGROUND_SILENT_PLAYBACK",
271 HiviewDFX::HiSysEvent::EventType::STATISTIC,
272 "APP_NAME", bean->GetStringValue("APP_NAME"),
273 "APP_VERSION_CODE", static_cast<uint32_t>(bean->GetIntValue("APP_VERSION_CODE")),
274 "TIMES", static_cast<uint32_t>(bean->GetIntValue("TIMES")));
275 #endif
276 }
277
WriteBGSilentPlayback(std::shared_ptr<EventBean> & bean)278 void MediaEventBaseWriter::WriteBGSilentPlayback(std::shared_ptr<EventBean> &bean)
279 {
280 MEDIA_LOG_D("Write bg silent playback");
281 if (bean == nullptr) {
282 MEDIA_LOG_E("eventBean is nullptr");
283 return;
284 }
285 #ifdef MONITOR_ENABLE_HISYSEVENT
286 auto ret = HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "BG_SILENT_PLAYBACK",
287 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
288 "APP_NAME", bean->GetStringValue("APP_NAME"),
289 "APP_VERSION_CODE", static_cast<uint32_t>(bean->GetIntValue("APP_VERSION_CODE")));
290 if (ret) {
291 MEDIA_LOG_E("write event fail: BG_SILENT_PLAYBACK, ret = %{public}d", ret);
292 }
293 #endif
294 }
295
WriteExcludeOutputDevice(std::shared_ptr<EventBean> & bean)296 void MediaEventBaseWriter::WriteExcludeOutputDevice(std::shared_ptr<EventBean> &bean)
297 {
298 MEDIA_LOG_D("Write exclude output device");
299 if (bean == nullptr) {
300 MEDIA_LOG_E("eventBean is nullptr");
301 return;
302 }
303 #ifdef MONITOR_ENABLE_HISYSEVENT
304 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "EXCLUDE_OUTPUT_DEVICE",
305 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
306 "APP_NAME", bean->GetStringValue("APP_NAME"),
307 "EXCLUSION_STATUS", static_cast<uint>(bean->GetIntValue("EXCLUSION_STATUS")),
308 "AUDIO_DEVICE_USAGE", static_cast<uint>(bean->GetIntValue("AUDIO_DEVICE_USAGE")),
309 "DEVICE_TYPE", bean->GetIntValue("DEVICE_TYPE"));
310 #endif
311 }
312
WriteSetForceDevice(std::shared_ptr<EventBean> & bean)313 void MediaEventBaseWriter::WriteSetForceDevice(std::shared_ptr<EventBean> &bean)
314 {
315 MEDIA_LOG_D("Write set force use device");
316 if (bean == nullptr) {
317 MEDIA_LOG_E("eventBean is nullptr");
318 return;
319 }
320 #ifdef MONITOR_ENABLE_HISYSEVENT
321 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "SET_FORCE_USE_AUDIO_DEVICE",
322 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
323 "APP_NAME", bean->GetStringValue("APP_NAME"),
324 "DEVICE_TYPE", static_cast<uint>(bean->GetIntValue("DEVICE_TYPE")),
325 "IS_PLAYBACK", static_cast<bool>(bean->GetIntValue("IS_PLAYBACK")),
326 "STREAM_TYPE", static_cast<uint>(bean->GetIntValue("STREAM_TYPE")));
327 #endif
328 }
329
WriteDeviceStatistic(std::shared_ptr<EventBean> & bean)330 void MediaEventBaseWriter::WriteDeviceStatistic(std::shared_ptr<EventBean> &bean)
331 {
332 MEDIA_LOG_D("Write device statistic duration");
333 if (bean == nullptr) {
334 MEDIA_LOG_E("eventBean is nullptr");
335 return;
336 }
337 #ifdef MONITOR_ENABLE_HISYSEVENT
338 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "AUDIO_DEVICE_UTILIZATION_STATS",
339 HiviewDFX::HiSysEvent::EventType::STATISTIC,
340 "IS_PLAYBACK", static_cast<bool>(bean->GetIntValue("IS_PLAYBACK")),
341 "DEVICE_TYPE", static_cast<uint>(bean->GetIntValue("DEVICE_TYPE")),
342 "STREAM_TYPE", static_cast<uint>(bean->GetIntValue("STREAM_TYPE")),
343 "DURATION", static_cast<uint32_t>(bean->GetUint64Value("DURATION")));
344 #endif
345 }
346
WriteBtUsageStatistic(std::shared_ptr<EventBean> & bean)347 void MediaEventBaseWriter::WriteBtUsageStatistic(std::shared_ptr<EventBean> &bean)
348 {
349 MEDIA_LOG_D("Write bt usage statistic duration");
350 if (bean == nullptr) {
351 MEDIA_LOG_E("eventBean is nullptr");
352 return;
353 }
354 #ifdef MONITOR_ENABLE_HISYSEVENT
355 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "BT_UTILIZATION_STATS",
356 HiviewDFX::HiSysEvent::EventType::STATISTIC,
357 "IS_PLAYBACK", static_cast<bool>(bean->GetIntValue("IS_PLAYBACK")),
358 "BT_TYPE", static_cast<uint>(bean->GetIntValue("BT_TYPE")),
359 "STREAM_TYPE", static_cast<uint>(bean->GetIntValue("STREAM_TYPE")),
360 "DURATION", static_cast<uint32_t>(bean->GetUint64Value("DURATION")));
361 #endif
362 }
363
WriteStreamStatistic(std::shared_ptr<EventBean> & bean)364 void MediaEventBaseWriter::WriteStreamStatistic(std::shared_ptr<EventBean> &bean)
365 {
366 MEDIA_LOG_D("Write stream statistic duration");
367 if (bean == nullptr) {
368 MEDIA_LOG_E("eventBean is nullptr");
369 return;
370 }
371 #ifdef MONITOR_ENABLE_HISYSEVENT
372 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "STREAM_UTILIZATION_STATS",
373 HiviewDFX::HiSysEvent::EventType::STATISTIC,
374 "IS_PLAYBACK", static_cast<bool>(bean->GetIntValue("IS_PLAYBACK")),
375 "PIPE_TYPE", static_cast<uint>(bean->GetIntValue("PIPE_TYPE")),
376 "STREAM_TYPE", static_cast<uint>(bean->GetIntValue("STREAM_TYPE")),
377 "SAMPLE_RATE", static_cast<uint>(bean->GetIntValue("SAMPLE_RATE")),
378 "APP_NAME", bean->GetStringValue("APP_NAME"),
379 "EFFECT_CHAIN", static_cast<uint>(bean->GetIntValue("EFFECT_CHAIN")),
380 "DURATION", static_cast<uint32_t>(bean->GetUint64Value("DURATION")));
381 #endif
382 }
383
WriteStreamPropertyStatistic(std::shared_ptr<EventBean> & bean)384 void MediaEventBaseWriter::WriteStreamPropertyStatistic(std::shared_ptr<EventBean> &bean)
385 {
386 MEDIA_LOG_D("Write stream property statistic duration");
387 if (bean == nullptr) {
388 MEDIA_LOG_E("eventBean is nullptr");
389 return;
390 }
391 #ifdef MONITOR_ENABLE_HISYSEVENT
392 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "STREAM_PROPERTY_STATS",
393 HiviewDFX::HiSysEvent::EventType::STATISTIC,
394 "IS_PLAYBACK", static_cast<bool>(bean->GetIntValue("IS_PLAYBACK")),
395 "STREAM_TYPE", static_cast<uint>(bean->GetIntValue("STREAM_TYPE")),
396 "APP_NAME", bean->GetStringValue("APP_NAME"),
397 "ENCODING_TYPE", static_cast<uint>(bean->GetIntValue("ENCODING_TYPE")),
398 "CHANNEL_LAYOUT", static_cast<uint64_t>(bean->GetUint64Value("CHANNEL_LAYOUT")),
399 "DURATION", static_cast<uint32_t>(bean->GetUint64Value("DURATION")));
400 #endif
401 }
402
WriteUnderrunStatistic(std::shared_ptr<EventBean> & bean)403 void MediaEventBaseWriter::WriteUnderrunStatistic(std::shared_ptr<EventBean> &bean)
404 {
405 MEDIA_LOG_D("Write underrun statistic times");
406 if (bean == nullptr) {
407 MEDIA_LOG_E("eventBean is nullptr");
408 return;
409 }
410 #ifdef MONITOR_ENABLE_HISYSEVENT
411 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "PERFORMANCE_UNDER_OVERRUN_STATS",
412 HiviewDFX::HiSysEvent::EventType::STATISTIC,
413 "IS_PLAYBACK", static_cast<bool>(bean->GetIntValue("IS_PLAYBACK")),
414 "STREAM_TYPE", static_cast<uint>(bean->GetIntValue("STREAM_TYPE")),
415 "PIPE_TYPE", static_cast<uint>(bean->GetIntValue("PIPE_TYPE")),
416 "APP_NAME", bean->GetStringValue("APP_NAME"),
417 "TIMES", static_cast<uint32_t>(bean->GetIntValue("TIMES")));
418 #endif
419 }
420
WriteAudioPipeChange(std::shared_ptr<EventBean> & bean)421 void MediaEventBaseWriter::WriteAudioPipeChange(std::shared_ptr<EventBean> &bean)
422 {
423 MEDIA_LOG_D("Write audio pipe change");
424 if (bean == nullptr) {
425 MEDIA_LOG_E("eventBean is nullptr");
426 return;
427 }
428 #ifdef MONITOR_ENABLE_HISYSEVENT
429 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "AUDIO_PIPE_CHANGE",
430 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
431 "APP_NAME", bean->GetStringValue("APP_NAME"),
432 "STREAM_TYPE", static_cast<uint>(bean->GetIntValue("STREAM_TYPE")),
433 "IS_PLAYBACK", static_cast<bool>(bean->GetIntValue("IS_PLAYBACK")),
434 "PIPE_TYPE_BEFORE_CHANGE", static_cast<uint>(bean->GetIntValue("PIPE_TYPE_BEFORE_CHANGE")),
435 "PIPE_TYPE_AFTER_CHANGE", static_cast<uint>(bean->GetIntValue("PIPE_TYPE_AFTER_CHANGE")),
436 "REASON", static_cast<uint>(bean->GetIntValue("REASON")));
437 #endif
438 }
439
WriteAudioRouteChange(std::shared_ptr<EventBean> & bean)440 void MediaEventBaseWriter::WriteAudioRouteChange(std::shared_ptr<EventBean> &bean)
441 {
442 MEDIA_LOG_D("Write audio route Change");
443 if (bean == nullptr) {
444 MEDIA_LOG_E("eventBean is nullptr");
445 return;
446 }
447 #ifdef MONITOR_ENABLE_HISYSEVENT
448 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "AUDIO_ROUTE_CHANGE",
449 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
450 "TIMESTAMP", bean->GetUint64Value("TIMESTAMP"),
451 "DEVICE_TYPE_BEFORE_CHANGE", static_cast<uint>(bean->GetIntValue("DEVICE_TYPE_BEFORE_CHANGE")),
452 "DEVICE_TYPE_AFTER_CHANGE", static_cast<uint>(bean->GetIntValue("DEVICE_TYPE_AFTER_CHANGE")),
453 "REASON", static_cast<uint>(bean->GetIntValue("REASON")));
454 #endif
455 }
456
WriteFocusMigrate(std::shared_ptr<EventBean> & bean)457 void MediaEventBaseWriter::WriteFocusMigrate(std::shared_ptr<EventBean> &bean)
458 {
459 MEDIA_LOG_D("Write focus migrate");
460 if (bean == nullptr) {
461 MEDIA_LOG_E("eventBean is nullptr");
462 return;
463 }
464 #ifdef MONITOR_ENABLE_HISYSEVENT
465 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "AUDIO_FOCUS_MIGRATE",
466 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
467 "DEVICE_DESC", bean->GetStringValue("DEVICE_DESC"),
468 "APP_NAME", bean->GetStringValue("APP_NAME"),
469 "MIGRATE_DIRECTION", static_cast<uint>(bean->GetIntValue("MIGRATE_DIRECTION")));
470 #endif
471 }
472
WriteMutedCapture(std::shared_ptr<EventBean> & bean)473 void MediaEventBaseWriter::WriteMutedCapture(std::shared_ptr<EventBean> &bean)
474 {
475 MEDIA_LOG_D("Write muted capture duration");
476 if (bean == nullptr) {
477 MEDIA_LOG_E("eventBean is nullptr");
478 return;
479 }
480 #ifdef MONITOR_ENABLE_HISYSEVENT
481 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "MUTED_CAPTURE_STATS",
482 HiviewDFX::HiSysEvent::EventType::STATISTIC,
483 "STREAM_TYPE", static_cast<uint>(bean->GetIntValue("STREAM_TYPE")),
484 "DEVICE_TYPE", static_cast<uint>(bean->GetIntValue("DEVICE_TYPE")),
485 "DURATION", static_cast<uint32_t>(bean->GetUint64Value("DURATION")));
486 #endif
487 }
488
WritePlaybackVolume(std::shared_ptr<EventBean> & bean)489 void MediaEventBaseWriter::WritePlaybackVolume(std::shared_ptr<EventBean> &bean)
490 {
491 MEDIA_LOG_D("Write playback volume duration");
492 if (bean == nullptr) {
493 MEDIA_LOG_E("eventBean is nullptr");
494 return;
495 }
496 #ifdef MONITOR_ENABLE_HISYSEVENT
497 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "PLAYBACK_VOLUME_STATS",
498 HiviewDFX::HiSysEvent::EventType::STATISTIC,
499 "LEVEL", static_cast<uint>(bean->GetIntValue("LEVEL")),
500 "STREAM_TYPE", static_cast<uint>(bean->GetIntValue("STREAM_TYPE")),
501 "DEVICE_TYPE", static_cast<uint>(bean->GetIntValue("DEVICE_TYPE")),
502 "DURATION", static_cast<uint32_t>(bean->GetUint64Value("DURATION")));
503 #endif
504 }
505
WriteVolumeSubscribe(std::shared_ptr<EventBean> & bean)506 void MediaEventBaseWriter::WriteVolumeSubscribe(std::shared_ptr<EventBean> &bean)
507 {
508 MEDIA_LOG_D("Write volume subscription");
509 if (bean == nullptr) {
510 MEDIA_LOG_E("eventBean is nullptr");
511 return;
512 }
513 #ifdef MONITOR_ENABLE_HISYSEVENT
514 auto ret = HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "VOLUME_SUBSCRIBE",
515 HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
516 "SUBSCRIBE_KEY", bean->GetStringValue("SUBSCRIBE_KEY"),
517 "SUBSCRIBE_RESULT", static_cast<uint32_t>(bean->GetIntValue("SUBSCRIBE_RESULT")));
518 if (ret) {
519 MEDIA_LOG_E("write event fail: VOLUME_SUBSCRIBE, ret = %{public}d", ret);
520 }
521 #endif
522 }
523 } // namespace MediaMonitor
524 } // namespace Media
525 } // namespace OHOS