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 
WriteDeviceChange(std::shared_ptr<EventBean> & bean)112 void MediaEventBaseWriter::WriteDeviceChange(std::shared_ptr<EventBean> &bean)
113 {
114     MEDIA_LOG_D("Write device Change");
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, "DEVICE_CHANGE",
121         HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
122         "ISOUTPUT", bean->GetIntValue("ISOUTPUT"),
123         "STREAMID", bean->GetIntValue("STREAMID"),
124         "STREAMTYPE", bean->GetIntValue("STREAM_TYPE"),
125         "DEVICETYPE", bean->GetIntValue("DEVICETYPE"),
126         "NETWORKID", bean->GetStringValue("NETWORKID"),
127         "ADDRESS", bean->GetStringValue("ADDRESS"),
128         "DEVICE_DETAILED_CATEGORY", bean->GetStringValue("DEVICE_NAME"));
129     if (ret) {
130         MEDIA_LOG_E("write event fail: DEVICE_CHANGE, ret = %{public}d", ret);
131     }
132 #endif
133 }
134 
WriteLoadConfigError(std::shared_ptr<EventBean> & bean)135 void MediaEventBaseWriter::WriteLoadConfigError(std::shared_ptr<EventBean> &bean)
136 {
137     MEDIA_LOG_D("Write load config error");
138     if (bean == nullptr) {
139         MEDIA_LOG_E("eventBean is nullptr");
140         return;
141     }
142 #ifdef MONITOR_ENABLE_HISYSEVENT
143     HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "LOAD_CONFIG_ERROR",
144         HiviewDFX::HiSysEvent::EventType::FAULT,
145         "CATEGORY", static_cast<uint16_t>(bean->GetIntValue("CATEGORY")));
146 #endif
147 }
148 
WriteLoadEffectEngineError(std::shared_ptr<EventBean> & bean)149 void MediaEventBaseWriter::WriteLoadEffectEngineError(std::shared_ptr<EventBean> &bean)
150 {
151     MEDIA_LOG_D("Write load effect engine error");
152     if (bean == nullptr) {
153         MEDIA_LOG_E("eventBean is nullptr");
154         return;
155     }
156 #ifdef MONITOR_ENABLE_HISYSEVENT
157     HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "LOAD_EFFECT_ENGINE_ERROR",
158         HiviewDFX::HiSysEvent::EventType::FAULT,
159         "ENGINE_TYPE", static_cast<uint16_t>(bean->GetIntValue("ENGINE_TYPE")));
160 #endif
161 }
162 
WriteAudioStartupError(std::shared_ptr<EventBean> & bean)163 void MediaEventBaseWriter::WriteAudioStartupError(std::shared_ptr<EventBean> &bean)
164 {
165     MEDIA_LOG_D("Write audio startup error");
166     if (bean == nullptr) {
167         MEDIA_LOG_E("eventBean is nullptr");
168         return;
169     }
170 #ifdef MONITOR_ENABLE_HISYSEVENT
171     HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "AUDIO_SERVICE_STARTUP_ERROR",
172         HiviewDFX::HiSysEvent::EventType::FAULT,
173         "SERVICE_ID", static_cast<uint>(bean->GetIntValue("SERVICE_ID")),
174         "ERROR_CODE", static_cast<uint32_t>(bean->GetIntValue("ERROR_CODE")));
175 #endif
176 }
177 
WriteStreamExhastedError(std::shared_ptr<EventBean> & bean)178 void MediaEventBaseWriter::WriteStreamExhastedError(std::shared_ptr<EventBean> &bean)
179 {
180     MEDIA_LOG_D("Write stream exhasted error");
181     if (bean == nullptr) {
182         MEDIA_LOG_E("eventBean is nullptr");
183         return;
184     }
185 #ifdef MONITOR_ENABLE_HISYSEVENT
186     HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "AUDIO_STREAM_EXHAUSTED_STATS",
187         HiviewDFX::HiSysEvent::EventType::STATISTIC,
188         "DUBIOUS_APP", bean->GetStringValue("DUBIOUS_APP"),
189         "TIMES", static_cast<uint32_t>(bean->GetIntValue("TIMES")));
190 #endif
191 }
192 
WriteStreamCreateError(std::shared_ptr<EventBean> & bean)193 void MediaEventBaseWriter::WriteStreamCreateError(std::shared_ptr<EventBean> &bean)
194 {
195     MEDIA_LOG_D("Write stream create error");
196     if (bean == nullptr) {
197         MEDIA_LOG_E("eventBean is nullptr");
198         return;
199     }
200 #ifdef MONITOR_ENABLE_HISYSEVENT
201     HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "AUDIO_STREAM_CREATE_ERROR_STATS",
202         HiviewDFX::HiSysEvent::EventType::STATISTIC,
203         "APP_NAME", bean->GetStringValue("APP_NAME"),
204         "IS_PLAYBACK", static_cast<bool>(bean->GetIntValue("IS_PLAYBACK")),
205         "STREAM_TYPE", static_cast<uint>(bean->GetIntValue("STREAM_TYPE")),
206         "ERROR_CODE", bean->GetIntValue("ERROR_CODE"),
207         "TIMES", static_cast<uint32_t>(bean->GetIntValue("TIMES")));
208 #endif
209 }
210 
WriteBackgoundSilentPlayback(std::shared_ptr<EventBean> & bean)211 void MediaEventBaseWriter::WriteBackgoundSilentPlayback(std::shared_ptr<EventBean> &bean)
212 {
213     MEDIA_LOG_D("Write backgound silent playback");
214     if (bean == nullptr) {
215         MEDIA_LOG_E("eventBean is nullptr");
216         return;
217     }
218 #ifdef MONITOR_ENABLE_HISYSEVENT
219     HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "BACKGROUND_SILENT_PLAYBACK",
220         HiviewDFX::HiSysEvent::EventType::STATISTIC,
221         "APP_NAME", bean->GetStringValue("APP_NAME"),
222         "APP_VERSION_CODE", static_cast<uint32_t>(bean->GetIntValue("APP_VERSION_CODE")),
223         "TIMES", static_cast<uint32_t>(bean->GetIntValue("TIMES")));
224 #endif
225 }
226 
WriteBGSilentPlayback(std::shared_ptr<EventBean> & bean)227 void MediaEventBaseWriter::WriteBGSilentPlayback(std::shared_ptr<EventBean> &bean)
228 {
229     MEDIA_LOG_D("Write bg silent playback");
230     if (bean == nullptr) {
231         MEDIA_LOG_E("eventBean is nullptr");
232         return;
233     }
234 #ifdef MONITOR_ENABLE_HISYSEVENT
235     auto ret = HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "BG_SILENT_PLAYBACK",
236         HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
237         "APP_NAME", bean->GetStringValue("APP_NAME"),
238         "APP_VERSION_CODE", static_cast<uint32_t>(bean->GetIntValue("APP_VERSION_CODE")));
239     if (ret) {
240         MEDIA_LOG_E("write event fail: BG_SILENT_PLAYBACK, ret = %{public}d", ret);
241     }
242 #endif
243 }
244 
WriteSetForceDevice(std::shared_ptr<EventBean> & bean)245 void MediaEventBaseWriter::WriteSetForceDevice(std::shared_ptr<EventBean> &bean)
246 {
247     MEDIA_LOG_D("Write set force use device");
248     if (bean == nullptr) {
249         MEDIA_LOG_E("eventBean is nullptr");
250         return;
251     }
252 #ifdef MONITOR_ENABLE_HISYSEVENT
253     HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "SET_FORCE_USE_AUDIO_DEVICE",
254         HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
255         "APP_NAME", bean->GetStringValue("APP_NAME"),
256         "DEVICE_TYPE", static_cast<uint>(bean->GetIntValue("DEVICE_TYPE")),
257         "IS_PLAYBACK", static_cast<bool>(bean->GetIntValue("IS_PLAYBACK")),
258         "STREAM_TYPE", static_cast<uint>(bean->GetIntValue("STREAM_TYPE")));
259 #endif
260 }
261 
WriteDeviceStatistic(std::shared_ptr<EventBean> & bean)262 void MediaEventBaseWriter::WriteDeviceStatistic(std::shared_ptr<EventBean> &bean)
263 {
264     MEDIA_LOG_D("Write device statistic duration");
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, "AUDIO_DEVICE_UTILIZATION_STATS",
271         HiviewDFX::HiSysEvent::EventType::STATISTIC,
272         "IS_PLAYBACK", static_cast<bool>(bean->GetIntValue("IS_PLAYBACK")),
273         "DEVICE_TYPE", static_cast<uint>(bean->GetIntValue("DEVICE_TYPE")),
274         "STREAM_TYPE", static_cast<uint>(bean->GetIntValue("STREAM_TYPE")),
275         "DURATION", static_cast<uint32_t>(bean->GetUint64Value("DURATION")));
276 #endif
277 }
278 
WriteBtUsageStatistic(std::shared_ptr<EventBean> & bean)279 void MediaEventBaseWriter::WriteBtUsageStatistic(std::shared_ptr<EventBean> &bean)
280 {
281     MEDIA_LOG_D("Write bt usage statistic duration");
282     if (bean == nullptr) {
283         MEDIA_LOG_E("eventBean is nullptr");
284         return;
285     }
286 #ifdef MONITOR_ENABLE_HISYSEVENT
287     HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "BT_UTILIZATION_STATS",
288         HiviewDFX::HiSysEvent::EventType::STATISTIC,
289         "IS_PLAYBACK", static_cast<bool>(bean->GetIntValue("IS_PLAYBACK")),
290         "BT_TYPE", static_cast<uint>(bean->GetIntValue("BT_TYPE")),
291         "STREAM_TYPE", static_cast<uint>(bean->GetIntValue("STREAM_TYPE")),
292         "DURATION", static_cast<uint32_t>(bean->GetUint64Value("DURATION")));
293 #endif
294 }
295 
WriteStreamStatistic(std::shared_ptr<EventBean> & bean)296 void MediaEventBaseWriter::WriteStreamStatistic(std::shared_ptr<EventBean> &bean)
297 {
298     MEDIA_LOG_D("Write stream statistic duration");
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, "STREAM_UTILIZATION_STATS",
305         HiviewDFX::HiSysEvent::EventType::STATISTIC,
306         "IS_PLAYBACK", static_cast<bool>(bean->GetIntValue("IS_PLAYBACK")),
307         "PIPE_TYPE", static_cast<uint>(bean->GetIntValue("PIPE_TYPE")),
308         "STREAM_TYPE", static_cast<uint>(bean->GetIntValue("STREAM_TYPE")),
309         "SAMPLE_RATE", static_cast<uint>(bean->GetIntValue("SAMPLE_RATE")),
310         "APP_NAME", bean->GetStringValue("APP_NAME"),
311         "EFFECT_CHAIN", static_cast<uint>(bean->GetIntValue("EFFECT_CHAIN")),
312         "DURATION", static_cast<uint32_t>(bean->GetUint64Value("DURATION")));
313 #endif
314 }
315 
WriteStreamPropertyStatistic(std::shared_ptr<EventBean> & bean)316 void MediaEventBaseWriter::WriteStreamPropertyStatistic(std::shared_ptr<EventBean> &bean)
317 {
318     MEDIA_LOG_D("Write stream property statistic duration");
319     if (bean == nullptr) {
320         MEDIA_LOG_E("eventBean is nullptr");
321         return;
322     }
323 #ifdef MONITOR_ENABLE_HISYSEVENT
324     HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "STREAM_PROPERTY_STATS",
325         HiviewDFX::HiSysEvent::EventType::STATISTIC,
326         "IS_PLAYBACK", static_cast<bool>(bean->GetIntValue("IS_PLAYBACK")),
327         "STREAM_TYPE", static_cast<uint>(bean->GetIntValue("STREAM_TYPE")),
328         "APP_NAME", bean->GetStringValue("APP_NAME"),
329         "ENCODING_TYPE", static_cast<uint>(bean->GetIntValue("ENCODING_TYPE")),
330         "CHANNEL_LAYOUT", static_cast<uint64_t>(bean->GetUint64Value("CHANNEL_LAYOUT")),
331         "DURATION", static_cast<uint32_t>(bean->GetUint64Value("DURATION")));
332 #endif
333 }
334 
WriteUnderrunStatistic(std::shared_ptr<EventBean> & bean)335 void MediaEventBaseWriter::WriteUnderrunStatistic(std::shared_ptr<EventBean> &bean)
336 {
337     MEDIA_LOG_D("Write underrun statistic times");
338     if (bean == nullptr) {
339         MEDIA_LOG_E("eventBean is nullptr");
340         return;
341     }
342 #ifdef MONITOR_ENABLE_HISYSEVENT
343     HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "PERFORMANCE_UNDER_OVERRUN_STATS",
344         HiviewDFX::HiSysEvent::EventType::STATISTIC,
345         "IS_PLAYBACK", static_cast<bool>(bean->GetIntValue("IS_PLAYBACK")),
346         "STREAM_TYPE", static_cast<uint>(bean->GetIntValue("STREAM_TYPE")),
347         "PIPE_TYPE", static_cast<uint>(bean->GetIntValue("PIPE_TYPE")),
348         "APP_NAME", bean->GetStringValue("APP_NAME"),
349         "TIMES", static_cast<uint32_t>(bean->GetIntValue("TIMES")));
350 #endif
351 }
352 
WriteAudioPipeChange(std::shared_ptr<EventBean> & bean)353 void MediaEventBaseWriter::WriteAudioPipeChange(std::shared_ptr<EventBean> &bean)
354 {
355     MEDIA_LOG_D("Write audio pipe change");
356     if (bean == nullptr) {
357         MEDIA_LOG_E("eventBean is nullptr");
358         return;
359     }
360 #ifdef MONITOR_ENABLE_HISYSEVENT
361     HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "AUDIO_PIPE_CHANGE",
362         HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
363         "APP_NAME", bean->GetStringValue("APP_NAME"),
364         "STREAM_TYPE", static_cast<uint>(bean->GetIntValue("STREAM_TYPE")),
365         "IS_PLAYBACK", static_cast<bool>(bean->GetIntValue("IS_PLAYBACK")),
366         "PIPE_TYPE_BEFORE_CHANGE", static_cast<uint>(bean->GetIntValue("PIPE_TYPE_BEFORE_CHANGE")),
367         "PIPE_TYPE_AFTER_CHANGE", static_cast<uint>(bean->GetIntValue("PIPE_TYPE_AFTER_CHANGE")),
368         "REASON", static_cast<uint>(bean->GetIntValue("REASON")));
369 #endif
370 }
371 
WriteAudioRouteChange(std::shared_ptr<EventBean> & bean)372 void MediaEventBaseWriter::WriteAudioRouteChange(std::shared_ptr<EventBean> &bean)
373 {
374     MEDIA_LOG_D("Write audio route Change");
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_ROUTE_CHANGE",
381         HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
382         "TIMESTAMP", bean->GetUint64Value("TIMESTAMP"),
383         "DEVICE_TYPE_BEFORE_CHANGE", static_cast<uint>(bean->GetIntValue("DEVICE_TYPE_BEFORE_CHANGE")),
384         "DEVICE_TYPE_AFTER_CHANGE", static_cast<uint>(bean->GetIntValue("DEVICE_TYPE_AFTER_CHANGE")),
385         "REASON", static_cast<uint>(bean->GetIntValue("REASON")));
386 #endif
387 }
388 
WriteFocusMigrate(std::shared_ptr<EventBean> & bean)389 void MediaEventBaseWriter::WriteFocusMigrate(std::shared_ptr<EventBean> &bean)
390 {
391     MEDIA_LOG_D("Write focus migrate");
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, "AUDIO_FOCUS_MIGRATE",
398         HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
399         "DEVICE_DESC", bean->GetStringValue("DEVICE_DESC"),
400         "APP_NAME", bean->GetStringValue("APP_NAME"),
401         "MIGRATE_DIRECTION", static_cast<uint>(bean->GetIntValue("MIGRATE_DIRECTION")));
402 #endif
403 }
404 
WriteMutedCapture(std::shared_ptr<EventBean> & bean)405 void MediaEventBaseWriter::WriteMutedCapture(std::shared_ptr<EventBean> &bean)
406 {
407     MEDIA_LOG_D("Write muted capture duration");
408     if (bean == nullptr) {
409         MEDIA_LOG_E("eventBean is nullptr");
410         return;
411     }
412 #ifdef MONITOR_ENABLE_HISYSEVENT
413     HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::AUDIO, "MUTED_CAPTURE_STATS",
414         HiviewDFX::HiSysEvent::EventType::STATISTIC,
415         "STREAM_TYPE", static_cast<uint>(bean->GetIntValue("STREAM_TYPE")),
416         "DEVICE_TYPE", static_cast<uint>(bean->GetIntValue("DEVICE_TYPE")),
417         "DURATION", static_cast<uint32_t>(bean->GetUint64Value("DURATION")));
418 #endif
419 }
420 
WritePlaybackVolume(std::shared_ptr<EventBean> & bean)421 void MediaEventBaseWriter::WritePlaybackVolume(std::shared_ptr<EventBean> &bean)
422 {
423     MEDIA_LOG_D("Write playback volume duration");
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, "PLAYBACK_VOLUME_STATS",
430         HiviewDFX::HiSysEvent::EventType::STATISTIC,
431         "LEVEL", static_cast<uint>(bean->GetIntValue("LEVEL")),
432         "STREAM_TYPE", static_cast<uint>(bean->GetIntValue("STREAM_TYPE")),
433         "DEVICE_TYPE", static_cast<uint>(bean->GetIntValue("DEVICE_TYPE")),
434         "DURATION", static_cast<uint32_t>(bean->GetUint64Value("DURATION")));
435 #endif
436 }
437 } // namespace MediaMonitor
438 } // namespace Media
439 } // namespace OHOS