1 /*
2 * Copyright (c) 2021-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 #ifndef LOG_TAG
16 #define LOG_TAG "AudioServerDump"
17 #endif
18
19 #include "audio_server_dump.h"
20 #include "audio_utils.h"
21 #include "audio_service.h"
22 #include "pa_adapter_tools.h"
23 #include "audio_dump_pcm.h"
24 #include "audio_performance_monitor.h"
25 #include "manager/hdi_adapter_manager.h"
26
27 using namespace std;
28
29 namespace OHOS {
30 namespace AudioStandard {
31
AudioServerDump()32 AudioServerDump::AudioServerDump() : mainLoop(nullptr),
33 api(nullptr),
34 context(nullptr),
35 isMainLoopStarted_(false),
36 isContextConnected_(false)
37 {
38 AUDIO_DEBUG_LOG("AudioServerDump construct");
39 InitDumpFuncMap();
40 }
41
~AudioServerDump()42 AudioServerDump::~AudioServerDump()
43 {
44 ResetPAAudioDump();
45 }
46
InitDumpFuncMap()47 void AudioServerDump::InitDumpFuncMap()
48 {
49 dumpFuncMap[u"-h"] = &AudioServerDump::HelpInfoDump;
50 dumpFuncMap[u"-p"] = &AudioServerDump::PlaybackSinkDump;
51 dumpFuncMap[u"-r"] = &AudioServerDump::RecordSourceDump;
52 dumpFuncMap[u"-m"] = &AudioServerDump::HDFModulesDump;
53 dumpFuncMap[u"-ep"] = &AudioServerDump::PolicyHandlerDump;
54 dumpFuncMap[u"-ct"] = &AudioServerDump::AudioCacheTimeDump;
55 dumpFuncMap[u"-cm"] = &AudioServerDump::AudioCacheMemoryDump;
56 dumpFuncMap[u"-pm"] = &AudioServerDump::AudioPerformMonitorDump;
57 dumpFuncMap[u"-ha"] = &AudioServerDump::HdiAdapterDump;
58 }
59
ResetPAAudioDump()60 void AudioServerDump::ResetPAAudioDump()
61 {
62 lock_guard<mutex> lock(ctrlMutex_);
63 if (mainLoop && (isMainLoopStarted_ == true)) {
64 pa_threaded_mainloop_stop(mainLoop);
65 }
66
67 if (context) {
68 pa_context_set_state_callback(context, nullptr, nullptr);
69 if (isContextConnected_ == true) {
70 AUDIO_INFO_LOG("[AudioServerDump] disconnect context!");
71 pa_context_disconnect(context);
72 }
73 pa_context_unref(context);
74 }
75
76 if (mainLoop) {
77 pa_threaded_mainloop_free(mainLoop);
78 }
79
80 isMainLoopStarted_ = false;
81 isContextConnected_ = false;
82 mainLoop = nullptr;
83 context = nullptr;
84 api = nullptr;
85 }
86
Initialize()87 int32_t AudioServerDump::Initialize()
88 {
89 mainLoop = pa_threaded_mainloop_new();
90 if (mainLoop == nullptr) {
91 return AUDIO_DUMP_INIT_ERR;
92 }
93
94 api = pa_threaded_mainloop_get_api(mainLoop);
95 if (api == nullptr) {
96 ResetPAAudioDump();
97 return AUDIO_DUMP_INIT_ERR;
98 }
99
100 context = pa_context_new(api, "AudioServerDump");
101 if (context == nullptr) {
102 ResetPAAudioDump();
103 return AUDIO_DUMP_INIT_ERR;
104 }
105
106 pa_context_set_state_callback(context, PAContextStateCb, mainLoop);
107
108 if (pa_context_connect(context, nullptr, PA_CONTEXT_NOFAIL, nullptr) < 0) {
109 int error = pa_context_errno(context);
110 AUDIO_ERR_LOG("context connect error: %{public}s", pa_strerror(error));
111 ResetPAAudioDump();
112 return AUDIO_DUMP_INIT_ERR;
113 }
114
115 isContextConnected_ = true;
116 PaLockGuard lock(mainLoop);
117
118 if (pa_threaded_mainloop_start(mainLoop) < 0) {
119 AUDIO_ERR_LOG("Audio Service not started!");
120 ResetPAAudioDump();
121 return AUDIO_DUMP_INIT_ERR;
122 }
123
124 isMainLoopStarted_ = true;
125 while (isMainLoopStarted_) {
126 pa_context_state_t state = pa_context_get_state(context);
127 if (state == PA_CONTEXT_READY) {
128 break;
129 }
130
131 if (!PA_CONTEXT_IS_GOOD(state)) {
132 int error = pa_context_errno(context);
133 AUDIO_ERR_LOG("context bad state error: %{public}s", pa_strerror(error));
134 ResetPAAudioDump();
135 return AUDIO_DUMP_INIT_ERR;
136 }
137
138 pa_threaded_mainloop_wait(mainLoop);
139 }
140
141 return AUDIO_DUMP_SUCCESS;
142 }
143
OnTimeOut()144 void AudioServerDump::OnTimeOut()
145 {
146 PaLockGuard lock(mainLoop);
147 pa_threaded_mainloop_signal(mainLoop, 0);
148 }
149
IsEndWith(const std::string & mainStr,const std::string & toMatch)150 bool AudioServerDump::IsEndWith(const std::string &mainStr, const std::string &toMatch)
151 {
152 if (mainStr.size() >= toMatch.size() &&
153 mainStr.compare(mainStr.size() - toMatch.size(), toMatch.size(), toMatch) == 0) {
154 return true;
155 }
156 return false;
157 }
158
IsValidModule(const std::string moduleName)159 bool AudioServerDump::IsValidModule(const std::string moduleName)
160 {
161 if (moduleName.rfind("fifo", 0) == SUCCESS) {
162 return false; // Module starts with fifo, Not valid module
163 }
164
165 if (IsEndWith(moduleName, "monitor")) {
166 return false; // Module ends with monitor, Not valid module
167 }
168 return true;
169 }
170
ServerDataDump(string & dumpString)171 void AudioServerDump::ServerDataDump(string &dumpString)
172 {
173 PlaybackSinkDump(dumpString);
174 RecordSourceDump(dumpString);
175 HDFModulesDump(dumpString);
176 PolicyHandlerDump(dumpString);
177 }
178
ArgDataDump(std::string & dumpString,std::queue<std::u16string> & argQue)179 void AudioServerDump::ArgDataDump(std::string &dumpString, std::queue<std::u16string>& argQue)
180 {
181 dumpString += "AudioServer Data Dump:\n\n";
182 if (argQue.empty()) {
183 ServerDataDump(dumpString);
184 return;
185 }
186 while (!argQue.empty()) {
187 std::u16string para = argQue.front();
188 if (para == u"-h") {
189 dumpString.clear();
190 (this->*dumpFuncMap[para])(dumpString);
191 return;
192 } else if (dumpFuncMap.count(para) == 0) {
193 dumpString.clear();
194 AppendFormat(dumpString, "Please input correct param:\n");
195 HelpInfoDump(dumpString);
196 return;
197 } else {
198 (this->*dumpFuncMap[para])(dumpString);
199 }
200 argQue.pop();
201 }
202 }
203
HelpInfoDump(string & dumpString)204 void AudioServerDump::HelpInfoDump(string &dumpString)
205 {
206 AppendFormat(dumpString, "usage:\n");
207 AppendFormat(dumpString, " -h\t\t\t|help text for hidumper audio\n");
208 AppendFormat(dumpString, " -p\t\t\t|dump pa playback streams\n");
209 AppendFormat(dumpString, " -r\t\t\t|dump pa record streams\n");
210 AppendFormat(dumpString, " -m\t\t\t|dump hdf input modules\n");
211 AppendFormat(dumpString, " -ep\t\t\t|dump policyhandler info\n");
212 AppendFormat(dumpString, " -ct\t\t\t|dump AudioCached time info\n");
213 AppendFormat(dumpString, " -cm\t\t\t|dump AudioCached memory info\n");
214 AppendFormat(dumpString, " -pm\t\t\t|dump AudioPerformMonitor info\n");
215 AppendFormat(dumpString, " -ha\t\t\t|dump HdiAdapter info\n");
216 AppendFormat(dumpString, " -ap\t\t\t|dump AudioPipeManager info\n");
217 }
218
AudioDataDump(string & dumpString,std::queue<std::u16string> & argQue)219 void AudioServerDump::AudioDataDump(string &dumpString, std::queue<std::u16string>& argQue)
220 {
221 if (mainLoop == nullptr || context == nullptr) {
222 AUDIO_ERR_LOG("Audio Service Not running");
223 return;
224 }
225
226 PaLockGuard lock(mainLoop);
227 pa_operation *operation = nullptr;
228 operation = pa_context_get_sink_info_list(context,
229 AudioServerDump::PASinkInfoCallback, reinterpret_cast<void *>(this));
230
231 while (pa_operation_get_state(operation) == PA_OPERATION_RUNNING) {
232 pa_threaded_mainloop_wait(mainLoop);
233 }
234
235 pa_operation_unref(operation);
236 operation = pa_context_get_sink_input_info_list(context,
237 AudioServerDump::PASinkInputInfoCallback, reinterpret_cast<void *>(this));
238
239 while (pa_operation_get_state(operation) == PA_OPERATION_RUNNING) {
240 pa_threaded_mainloop_wait(mainLoop);
241 }
242
243 pa_operation_unref(operation);
244 operation = pa_context_get_source_info_list(context,
245 AudioServerDump::PASourceInfoCallback, reinterpret_cast<void *>(this));
246
247 while (pa_operation_get_state(operation) == PA_OPERATION_RUNNING) {
248 pa_threaded_mainloop_wait(mainLoop);
249 }
250
251 pa_operation_unref(operation);
252 operation = pa_context_get_source_output_info_list(context,
253 AudioServerDump::PASourceOutputInfoCallback, reinterpret_cast<void *>(this));
254
255 while (pa_operation_get_state(operation) == PA_OPERATION_RUNNING) {
256 pa_threaded_mainloop_wait(mainLoop);
257 }
258
259 pa_operation_unref(operation);
260
261 ArgDataDump(dumpString, argQue);
262
263 return;
264 }
265
PAContextStateCb(pa_context * context,void * userdata)266 void AudioServerDump::PAContextStateCb(pa_context *context, void *userdata)
267 {
268 pa_threaded_mainloop *mainLoop = reinterpret_cast<pa_threaded_mainloop *>(userdata);
269
270 switch (pa_context_get_state(context)) {
271 case PA_CONTEXT_READY:
272 case PA_CONTEXT_TERMINATED:
273 case PA_CONTEXT_FAILED:
274 pa_threaded_mainloop_signal(mainLoop, 0);
275 break;
276
277 case PA_CONTEXT_UNCONNECTED:
278 case PA_CONTEXT_CONNECTING:
279 case PA_CONTEXT_AUTHORIZING:
280 case PA_CONTEXT_SETTING_NAME:
281 default:
282 break;
283 }
284 return;
285 }
286
PASinkInfoCallback(pa_context * c,const pa_sink_info * i,int eol,void * userdata)287 void AudioServerDump::PASinkInfoCallback(pa_context *c, const pa_sink_info *i, int eol, void *userdata)
288 {
289 AudioServerDump *asDump = reinterpret_cast<AudioServerDump *>(userdata);
290 CHECK_AND_RETURN_LOG(asDump != nullptr, "Failed to get sink information");
291
292 pa_threaded_mainloop *mainLoop = reinterpret_cast<pa_threaded_mainloop *>(asDump->mainLoop);
293
294 CHECK_AND_RETURN_LOG(eol >= 0, "Failed to get sink information: %{public}s", pa_strerror(pa_context_errno(c)));
295
296 if (eol) {
297 pa_threaded_mainloop_signal(mainLoop, 0);
298 return;
299 }
300
301 SinkSourceInfo sinkInfo;
302
303 if (i->name != nullptr) {
304 string sinkName(i->name);
305 if (IsValidModule(sinkName)) {
306 (sinkInfo.name).assign(sinkName);
307 sinkInfo.sampleSpec = i->sample_spec;
308 asDump->streamData_.sinkDevices.push_back(sinkInfo);
309 }
310 }
311 }
312
PASinkInputInfoCallback(pa_context * c,const pa_sink_input_info * i,int eol,void * userdata)313 void AudioServerDump::PASinkInputInfoCallback(pa_context *c, const pa_sink_input_info *i, int eol, void *userdata)
314 {
315 AudioServerDump *asDump = reinterpret_cast<AudioServerDump *>(userdata);
316 CHECK_AND_RETURN_LOG(asDump != nullptr, "Failed to get sink input information");
317 pa_threaded_mainloop *mainLoop = reinterpret_cast<pa_threaded_mainloop *>(asDump->mainLoop);
318 CHECK_AND_RETURN_LOG(eol >= 0, "Failed to get sink input information: %{public}s",
319 pa_strerror(pa_context_errno(c)));
320 if (eol) {
321 pa_threaded_mainloop_signal(mainLoop, 0);
322 return;
323 }
324 InputOutputInfo sinkInputInfo;
325 sinkInputInfo.sampleSpec = i->sample_spec;
326 sinkInputInfo.corked = i->corked;
327 if (i->proplist != nullptr) {
328 const char *applicationname = pa_proplist_gets(i->proplist, "application.name");
329 const char *processid = pa_proplist_gets(i->proplist, "application.process.id");
330 const char *user = pa_proplist_gets(i->proplist, "application.process.user");
331 const char *sessionid = pa_proplist_gets(i->proplist, "stream.sessionID");
332 const char *sessionstarttime = pa_proplist_gets(i->proplist, "stream.startTime");
333 const char *privacytype = pa_proplist_gets(i->proplist, "stream.privacyType");
334 if (applicationname != nullptr) {
335 string applicationName(applicationname);
336 (sinkInputInfo.applicationName).assign(applicationName);
337 }
338 if (processid != nullptr) {
339 string processId(processid);
340 (sinkInputInfo.processId).assign(processId);
341 }
342 if (user != nullptr) {
343 struct passwd *p;
344 if ((p = getpwnam(user)) != nullptr) {
345 sinkInputInfo.userId = uint32_t(p->pw_uid);
346 }
347 }
348 if (sessionid != nullptr) {
349 string sessionId(sessionid);
350 (sinkInputInfo.sessionId).assign(sessionId);
351 }
352 if (sessionstarttime != nullptr) {
353 string sessionStartTime(sessionstarttime);
354 (sinkInputInfo.sessionStartTime).assign(sessionStartTime);
355 }
356 if (privacytype != nullptr) {
357 string privacyType(privacytype);
358 (sinkInputInfo.privacyType).assign(privacyType);
359 }
360 }
361 asDump->streamData_.sinkInputs.push_back(sinkInputInfo);
362 }
363
PASourceInfoCallback(pa_context * c,const pa_source_info * i,int eol,void * userdata)364 void AudioServerDump::PASourceInfoCallback(pa_context *c, const pa_source_info *i, int eol, void *userdata)
365 {
366 AudioServerDump *asDump = reinterpret_cast<AudioServerDump *>(userdata);
367 CHECK_AND_RETURN_LOG(asDump != nullptr, "Failed to get source information");
368
369 pa_threaded_mainloop *mainLoop = reinterpret_cast<pa_threaded_mainloop *>(asDump->mainLoop);
370 CHECK_AND_RETURN_LOG(eol >= 0, "Failed to get source information: %{public}s",
371 pa_strerror(pa_context_errno(c)));
372
373 if (eol) {
374 pa_threaded_mainloop_signal(mainLoop, 0);
375 return;
376 }
377
378 SinkSourceInfo sourceInfo;
379
380 if (i->name != nullptr) {
381 string sourceName(i->name);
382 if (IsValidModule(sourceName)) {
383 (sourceInfo.name).assign(sourceName);
384 sourceInfo.sampleSpec = i->sample_spec;
385 asDump->streamData_.sourceDevices.push_back(sourceInfo);
386 }
387 }
388 }
389
PASourceOutputInfoCallback(pa_context * c,const pa_source_output_info * i,int eol,void * userdata)390 void AudioServerDump::PASourceOutputInfoCallback(pa_context *c, const pa_source_output_info *i, int eol,
391 void *userdata)
392 {
393 AudioServerDump *asDump = reinterpret_cast<AudioServerDump *>(userdata);
394 CHECK_AND_RETURN_LOG(asDump != nullptr, "Failed to get source output information");
395 pa_threaded_mainloop *mainLoop = reinterpret_cast<pa_threaded_mainloop *>(asDump->mainLoop);
396 CHECK_AND_RETURN_LOG(eol >= 0, "Failed to get source output information: %{public}s",
397 pa_strerror(pa_context_errno(c)));
398 if (eol) {
399 pa_threaded_mainloop_signal(mainLoop, 0);
400 return;
401 }
402 InputOutputInfo sourceOutputInfo;
403 sourceOutputInfo.sampleSpec = i->sample_spec;
404 sourceOutputInfo.corked = i->corked;
405 if (i->proplist != nullptr) {
406 const char *applicationname = pa_proplist_gets(i->proplist, "application.name");
407 const char *processid = pa_proplist_gets(i->proplist, "application.process.id");
408 const char *user = pa_proplist_gets(i->proplist, "application.process.user");
409 const char *sessionid = pa_proplist_gets(i->proplist, "stream.sessionID");
410 const char *sessionstarttime = pa_proplist_gets(i->proplist, "stream.startTime");
411 const char *privacytype = pa_proplist_gets(i->proplist, "stream.privacyType");
412 if (applicationname != nullptr) {
413 string applicationName(applicationname);
414 (sourceOutputInfo.applicationName).assign(applicationName);
415 }
416 if (processid != nullptr) {
417 string processId(processid);
418 (sourceOutputInfo.processId).assign(processId);
419 }
420 if (user != nullptr) {
421 struct passwd *p;
422 if ((p = getpwnam(user)) != nullptr) {
423 sourceOutputInfo.userId = uint32_t(p->pw_uid);
424 }
425 }
426 if (sessionid != nullptr) {
427 string sessionId(sessionid);
428 (sourceOutputInfo.sessionId).assign(sessionId);
429 }
430 if (sessionstarttime != nullptr) {
431 string sessionStartTime(sessionstarttime);
432 (sourceOutputInfo.sessionStartTime).assign(sessionStartTime);
433 }
434 if (privacytype != nullptr) {
435 string privacyType(privacytype);
436 (sourceOutputInfo.privacyType).assign(privacyType);
437 }
438 }
439 asDump->streamData_.sourceOutputs.push_back(sourceOutputInfo);
440 }
441
PlaybackSinkDump(std::string & dumpString)442 void AudioServerDump::PlaybackSinkDump(std::string &dumpString)
443 {
444 AUDIO_INFO_LOG("PlaybackSinkDump enter");
445 char s[PA_SAMPLE_SPEC_SNPRINT_MAX];
446
447 dumpString += "Playback Streams\n";
448
449 AppendFormat(dumpString, "- %zu Playback stream (s) available:\n", streamData_.sinkInputs.size());
450
451 for (auto it = streamData_.sinkInputs.begin(); it != streamData_.sinkInputs.end(); it++) {
452 InputOutputInfo sinkInputInfo = *it;
453
454 AppendFormat(dumpString, " Stream %d\n", it - streamData_.sinkInputs.begin() + 1);
455 AppendFormat(dumpString, " - Stream Id: %s\n", (sinkInputInfo.sessionId).c_str());
456 AppendFormat(dumpString, " - Application Name: %s\n", ((sinkInputInfo.applicationName).c_str()));
457 AppendFormat(dumpString, " - Process Id: %s\n", (sinkInputInfo.processId).c_str());
458 AppendFormat(dumpString, " - User Id: %u\n", sinkInputInfo.userId);
459 AppendFormat(dumpString, " - stream can be captured: %s\n",
460 sinkInputInfo.privacyType == "0" ? "true" : "false");
461
462 char *inputSampleSpec = pa_sample_spec_snprint(s, sizeof(s), &(sinkInputInfo.sampleSpec));
463 AppendFormat(dumpString, " - Stream Configuration: %s\n", inputSampleSpec);
464 dumpString += " - Status:";
465 dumpString += (sinkInputInfo.corked) ? "STOPPED/PAUSED" : "RUNNING";
466 AppendFormat(dumpString, "\n - Stream Start Time: %s\n", (sinkInputInfo.sessionStartTime).c_str());
467 dumpString += "\n";
468 }
469 }
470
RecordSourceDump(std::string & dumpString)471 void AudioServerDump::RecordSourceDump(std::string &dumpString)
472 {
473 char s[PA_SAMPLE_SPEC_SNPRINT_MAX];
474 dumpString += "Record Streams \n";
475 AppendFormat(dumpString, "- %zu Record stream (s) available:\n", streamData_.sourceOutputs.size());
476
477 for (auto it = streamData_.sourceOutputs.begin(); it != streamData_.sourceOutputs.end(); it++) {
478 InputOutputInfo sourceOutputInfo = *it;
479 AppendFormat(dumpString, " Stream %d\n", it - streamData_.sourceOutputs.begin() + 1);
480 AppendFormat(dumpString, " - Stream Id: %s\n", (sourceOutputInfo.sessionId).c_str());
481 AppendFormat(dumpString, " - Application Name: %s\n", (sourceOutputInfo.applicationName).c_str());
482 AppendFormat(dumpString, " - Process Id: %s\n", sourceOutputInfo.processId.c_str());
483 AppendFormat(dumpString, " - User Id: %u\n", sourceOutputInfo.userId);
484
485 char *outputSampleSpec = pa_sample_spec_snprint(s, sizeof(s), &(sourceOutputInfo.sampleSpec));
486 AppendFormat(dumpString, " - Stream Configuration: %s\n", outputSampleSpec);
487 dumpString += " - Status:";
488 dumpString += (sourceOutputInfo.corked) ? "STOPPED/PAUSED" : "RUNNING";
489 AppendFormat(dumpString, "\n - Stream Start Time: %s\n", (sourceOutputInfo.sessionStartTime).c_str());
490 dumpString += "\n";
491 }
492 }
493
HDFModulesDump(std::string & dumpString)494 void AudioServerDump::HDFModulesDump(std::string &dumpString)
495 {
496 char s[PA_SAMPLE_SPEC_SNPRINT_MAX];
497
498 dumpString += "\nHDF Input Modules\n";
499 AppendFormat(dumpString, "- %zu HDF Input Modules (s) available:\n", streamData_.sourceDevices.size());
500
501 for (auto it = streamData_.sourceDevices.begin(); it != streamData_.sourceDevices.end(); it++) {
502 SinkSourceInfo sourceInfo = *it;
503
504 AppendFormat(dumpString, " Module %d\n", it - streamData_.sourceDevices.begin() + 1);
505 AppendFormat(dumpString, " - Module Name: %s\n", (sourceInfo.name).c_str());
506 char *hdfOutSampleSpec = pa_sample_spec_snprint(s, sizeof(s), &(sourceInfo.sampleSpec));
507 AppendFormat(dumpString, " - Module Configuration: %s\n\n", hdfOutSampleSpec);
508 }
509
510 dumpString += "HDF Output Modules\n";
511 AppendFormat(dumpString, "- %zu HDF Output Modules (s) available:\n", streamData_.sinkDevices.size());
512
513 for (auto it = streamData_.sinkDevices.begin(); it != streamData_.sinkDevices.end(); it++) {
514 SinkSourceInfo sinkInfo = *it;
515 AppendFormat(dumpString, " Module %d\n", it - streamData_.sinkDevices.begin() + 1);
516 AppendFormat(dumpString, " - Module Name: %s\n", (sinkInfo.name).c_str());
517 char *hdfInSampleSpec = pa_sample_spec_snprint(s, sizeof(s), &(sinkInfo.sampleSpec));
518 AppendFormat(dumpString, " - Module Configuration: %s\n\n", hdfInSampleSpec);
519 }
520 }
521
PolicyHandlerDump(std::string & dumpString)522 void AudioServerDump::PolicyHandlerDump(std::string &dumpString)
523 {
524 AUDIO_INFO_LOG("PolicyHandlerDump");
525 AudioService::GetInstance()->Dump(dumpString);
526 }
527
AudioCacheTimeDump(std::string & dumpString)528 void AudioServerDump::AudioCacheTimeDump(std::string &dumpString)
529 {
530 AUDIO_INFO_LOG("AudioCacheTimeDump");
531 dumpString += "\nAudioCached Time\n";
532
533 int64_t startTime = 0;
534 int64_t endTime = 0;
535 AudioCacheMgr::GetInstance().GetCachedDuration(startTime, endTime);
536 dumpString += "Call dump get time: [ " + ClockTime::NanoTimeToString(startTime) + " ~ " +
537 ClockTime::NanoTimeToString(endTime) + " ], cur: [ " +
538 ClockTime::NanoTimeToString(ClockTime::GetRealNano()) + " ] \n";
539 }
540
AudioCacheMemoryDump(std::string & dumpString)541 void AudioServerDump::AudioCacheMemoryDump(std::string &dumpString)
542 {
543 AUDIO_INFO_LOG("AudioCacheMemoryDump");
544 dumpString += "\nAudioCached Memory\n";
545
546 size_t dataLength = 0;
547 size_t bufferLength = 0;
548 size_t structLength = 0;
549 AudioCacheMgr::GetInstance().GetCurMemoryCondition(dataLength, bufferLength, structLength);
550 dumpString += "dataLength: " + std::to_string(dataLength / BYTE_TO_KB_SIZE) + " KB, " +
551 "bufferLength: " + std::to_string(bufferLength / BYTE_TO_KB_SIZE) + " KB, " +
552 "structLength: " + std::to_string(structLength / BYTE_TO_KB_SIZE) + " KB \n";
553 }
554
AudioPerformMonitorDump(std::string & dumpString)555 void AudioServerDump::AudioPerformMonitorDump(std::string &dumpString)
556 {
557 AUDIO_INFO_LOG("AudioPerformMonitorDump");
558 dumpString += "\n Dump Audio Performance Monitor Record Infos\n";
559 AudioPerformanceMonitor::GetInstance().DumpMonitorInfo(dumpString);
560 }
561
HdiAdapterDump(std::string & dumpString)562 void AudioServerDump::HdiAdapterDump(std::string &dumpString)
563 {
564 AUDIO_INFO_LOG("HdiAdapterDump");
565 dumpString += "\nHdiAdapter Info\n";
566 HdiAdapterManager::GetInstance().DumpInfo(dumpString);
567 }
568
569 } // namespace AudioStandard
570 } // namespace OHOS
571