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 }
217
AudioDataDump(string & dumpString,std::queue<std::u16string> & argQue)218 void AudioServerDump::AudioDataDump(string &dumpString, std::queue<std::u16string>& argQue)
219 {
220 if (mainLoop == nullptr || context == nullptr) {
221 AUDIO_ERR_LOG("Audio Service Not running");
222 return;
223 }
224
225 PaLockGuard lock(mainLoop);
226 pa_operation *operation = nullptr;
227 operation = pa_context_get_sink_info_list(context,
228 AudioServerDump::PASinkInfoCallback, reinterpret_cast<void *>(this));
229
230 while (pa_operation_get_state(operation) == PA_OPERATION_RUNNING) {
231 pa_threaded_mainloop_wait(mainLoop);
232 }
233
234 pa_operation_unref(operation);
235 operation = pa_context_get_sink_input_info_list(context,
236 AudioServerDump::PASinkInputInfoCallback, reinterpret_cast<void *>(this));
237
238 while (pa_operation_get_state(operation) == PA_OPERATION_RUNNING) {
239 pa_threaded_mainloop_wait(mainLoop);
240 }
241
242 pa_operation_unref(operation);
243 operation = pa_context_get_source_info_list(context,
244 AudioServerDump::PASourceInfoCallback, reinterpret_cast<void *>(this));
245
246 while (pa_operation_get_state(operation) == PA_OPERATION_RUNNING) {
247 pa_threaded_mainloop_wait(mainLoop);
248 }
249
250 pa_operation_unref(operation);
251 operation = pa_context_get_source_output_info_list(context,
252 AudioServerDump::PASourceOutputInfoCallback, reinterpret_cast<void *>(this));
253
254 while (pa_operation_get_state(operation) == PA_OPERATION_RUNNING) {
255 pa_threaded_mainloop_wait(mainLoop);
256 }
257
258 pa_operation_unref(operation);
259
260 ArgDataDump(dumpString, argQue);
261
262 return;
263 }
264
PAContextStateCb(pa_context * context,void * userdata)265 void AudioServerDump::PAContextStateCb(pa_context *context, void *userdata)
266 {
267 pa_threaded_mainloop *mainLoop = reinterpret_cast<pa_threaded_mainloop *>(userdata);
268
269 switch (pa_context_get_state(context)) {
270 case PA_CONTEXT_READY:
271 case PA_CONTEXT_TERMINATED:
272 case PA_CONTEXT_FAILED:
273 pa_threaded_mainloop_signal(mainLoop, 0);
274 break;
275
276 case PA_CONTEXT_UNCONNECTED:
277 case PA_CONTEXT_CONNECTING:
278 case PA_CONTEXT_AUTHORIZING:
279 case PA_CONTEXT_SETTING_NAME:
280 default:
281 break;
282 }
283 return;
284 }
285
PASinkInfoCallback(pa_context * c,const pa_sink_info * i,int eol,void * userdata)286 void AudioServerDump::PASinkInfoCallback(pa_context *c, const pa_sink_info *i, int eol, void *userdata)
287 {
288 AudioServerDump *asDump = reinterpret_cast<AudioServerDump *>(userdata);
289 CHECK_AND_RETURN_LOG(asDump != nullptr, "Failed to get sink information");
290
291 pa_threaded_mainloop *mainLoop = reinterpret_cast<pa_threaded_mainloop *>(asDump->mainLoop);
292
293 CHECK_AND_RETURN_LOG(eol >= 0, "Failed to get sink information: %{public}s", pa_strerror(pa_context_errno(c)));
294
295 if (eol) {
296 pa_threaded_mainloop_signal(mainLoop, 0);
297 return;
298 }
299
300 SinkSourceInfo sinkInfo;
301
302 if (i->name != nullptr) {
303 string sinkName(i->name);
304 if (IsValidModule(sinkName)) {
305 (sinkInfo.name).assign(sinkName);
306 sinkInfo.sampleSpec = i->sample_spec;
307 asDump->streamData_.sinkDevices.push_back(sinkInfo);
308 }
309 }
310 }
311
PASinkInputInfoCallback(pa_context * c,const pa_sink_input_info * i,int eol,void * userdata)312 void AudioServerDump::PASinkInputInfoCallback(pa_context *c, const pa_sink_input_info *i, int eol, void *userdata)
313 {
314 AudioServerDump *asDump = reinterpret_cast<AudioServerDump *>(userdata);
315 CHECK_AND_RETURN_LOG(asDump != nullptr, "Failed to get sink input information");
316 pa_threaded_mainloop *mainLoop = reinterpret_cast<pa_threaded_mainloop *>(asDump->mainLoop);
317 CHECK_AND_RETURN_LOG(eol >= 0, "Failed to get sink input information: %{public}s",
318 pa_strerror(pa_context_errno(c)));
319 if (eol) {
320 pa_threaded_mainloop_signal(mainLoop, 0);
321 return;
322 }
323 InputOutputInfo sinkInputInfo;
324 sinkInputInfo.sampleSpec = i->sample_spec;
325 sinkInputInfo.corked = i->corked;
326 if (i->proplist != nullptr) {
327 const char *applicationname = pa_proplist_gets(i->proplist, "application.name");
328 const char *processid = pa_proplist_gets(i->proplist, "application.process.id");
329 const char *user = pa_proplist_gets(i->proplist, "application.process.user");
330 const char *sessionid = pa_proplist_gets(i->proplist, "stream.sessionID");
331 const char *sessionstarttime = pa_proplist_gets(i->proplist, "stream.startTime");
332 const char *privacytype = pa_proplist_gets(i->proplist, "stream.privacyType");
333 if (applicationname != nullptr) {
334 string applicationName(applicationname);
335 (sinkInputInfo.applicationName).assign(applicationName);
336 }
337 if (processid != nullptr) {
338 string processId(processid);
339 (sinkInputInfo.processId).assign(processId);
340 }
341 if (user != nullptr) {
342 struct passwd *p;
343 if ((p = getpwnam(user)) != nullptr) {
344 sinkInputInfo.userId = uint32_t(p->pw_uid);
345 }
346 }
347 if (sessionid != nullptr) {
348 string sessionId(sessionid);
349 (sinkInputInfo.sessionId).assign(sessionId);
350 }
351 if (sessionstarttime != nullptr) {
352 string sessionStartTime(sessionstarttime);
353 (sinkInputInfo.sessionStartTime).assign(sessionStartTime);
354 }
355 if (privacytype != nullptr) {
356 string privacyType(privacytype);
357 (sinkInputInfo.privacyType).assign(privacyType);
358 }
359 }
360 asDump->streamData_.sinkInputs.push_back(sinkInputInfo);
361 }
362
PASourceInfoCallback(pa_context * c,const pa_source_info * i,int eol,void * userdata)363 void AudioServerDump::PASourceInfoCallback(pa_context *c, const pa_source_info *i, int eol, void *userdata)
364 {
365 AudioServerDump *asDump = reinterpret_cast<AudioServerDump *>(userdata);
366 CHECK_AND_RETURN_LOG(asDump != nullptr, "Failed to get source information");
367
368 pa_threaded_mainloop *mainLoop = reinterpret_cast<pa_threaded_mainloop *>(asDump->mainLoop);
369 CHECK_AND_RETURN_LOG(eol >= 0, "Failed to get source information: %{public}s",
370 pa_strerror(pa_context_errno(c)));
371
372 if (eol) {
373 pa_threaded_mainloop_signal(mainLoop, 0);
374 return;
375 }
376
377 SinkSourceInfo sourceInfo;
378
379 if (i->name != nullptr) {
380 string sourceName(i->name);
381 if (IsValidModule(sourceName)) {
382 (sourceInfo.name).assign(sourceName);
383 sourceInfo.sampleSpec = i->sample_spec;
384 asDump->streamData_.sourceDevices.push_back(sourceInfo);
385 }
386 }
387 }
388
PASourceOutputInfoCallback(pa_context * c,const pa_source_output_info * i,int eol,void * userdata)389 void AudioServerDump::PASourceOutputInfoCallback(pa_context *c, const pa_source_output_info *i, int eol,
390 void *userdata)
391 {
392 AudioServerDump *asDump = reinterpret_cast<AudioServerDump *>(userdata);
393 CHECK_AND_RETURN_LOG(asDump != nullptr, "Failed to get source output information");
394 pa_threaded_mainloop *mainLoop = reinterpret_cast<pa_threaded_mainloop *>(asDump->mainLoop);
395 CHECK_AND_RETURN_LOG(eol >= 0, "Failed to get source output information: %{public}s",
396 pa_strerror(pa_context_errno(c)));
397 if (eol) {
398 pa_threaded_mainloop_signal(mainLoop, 0);
399 return;
400 }
401 InputOutputInfo sourceOutputInfo;
402 sourceOutputInfo.sampleSpec = i->sample_spec;
403 sourceOutputInfo.corked = i->corked;
404 if (i->proplist != nullptr) {
405 const char *applicationname = pa_proplist_gets(i->proplist, "application.name");
406 const char *processid = pa_proplist_gets(i->proplist, "application.process.id");
407 const char *user = pa_proplist_gets(i->proplist, "application.process.user");
408 const char *sessionid = pa_proplist_gets(i->proplist, "stream.sessionID");
409 const char *sessionstarttime = pa_proplist_gets(i->proplist, "stream.startTime");
410 const char *privacytype = pa_proplist_gets(i->proplist, "stream.privacyType");
411 if (applicationname != nullptr) {
412 string applicationName(applicationname);
413 (sourceOutputInfo.applicationName).assign(applicationName);
414 }
415 if (processid != nullptr) {
416 string processId(processid);
417 (sourceOutputInfo.processId).assign(processId);
418 }
419 if (user != nullptr) {
420 struct passwd *p;
421 if ((p = getpwnam(user)) != nullptr) {
422 sourceOutputInfo.userId = uint32_t(p->pw_uid);
423 }
424 }
425 if (sessionid != nullptr) {
426 string sessionId(sessionid);
427 (sourceOutputInfo.sessionId).assign(sessionId);
428 }
429 if (sessionstarttime != nullptr) {
430 string sessionStartTime(sessionstarttime);
431 (sourceOutputInfo.sessionStartTime).assign(sessionStartTime);
432 }
433 if (privacytype != nullptr) {
434 string privacyType(privacytype);
435 (sourceOutputInfo.privacyType).assign(privacyType);
436 }
437 }
438 asDump->streamData_.sourceOutputs.push_back(sourceOutputInfo);
439 }
440
PlaybackSinkDump(std::string & dumpString)441 void AudioServerDump::PlaybackSinkDump(std::string &dumpString)
442 {
443 AUDIO_INFO_LOG("PlaybackSinkDump enter");
444 char s[PA_SAMPLE_SPEC_SNPRINT_MAX];
445
446 dumpString += "Playback Streams\n";
447
448 AppendFormat(dumpString, "- %zu Playback stream (s) available:\n", streamData_.sinkInputs.size());
449
450 for (auto it = streamData_.sinkInputs.begin(); it != streamData_.sinkInputs.end(); it++) {
451 InputOutputInfo sinkInputInfo = *it;
452
453 AppendFormat(dumpString, " Stream %d\n", it - streamData_.sinkInputs.begin() + 1);
454 AppendFormat(dumpString, " - Stream Id: %s\n", (sinkInputInfo.sessionId).c_str());
455 AppendFormat(dumpString, " - Application Name: %s\n", ((sinkInputInfo.applicationName).c_str()));
456 AppendFormat(dumpString, " - Process Id: %s\n", (sinkInputInfo.processId).c_str());
457 AppendFormat(dumpString, " - User Id: %u\n", sinkInputInfo.userId);
458 AppendFormat(dumpString, " - stream can be captured: %s\n",
459 sinkInputInfo.privacyType == "0" ? "true" : "false");
460
461 char *inputSampleSpec = pa_sample_spec_snprint(s, sizeof(s), &(sinkInputInfo.sampleSpec));
462 AppendFormat(dumpString, " - Stream Configuration: %s\n", inputSampleSpec);
463 dumpString += " - Status:";
464 dumpString += (sinkInputInfo.corked) ? "STOPPED/PAUSED" : "RUNNING";
465 AppendFormat(dumpString, "\n - Stream Start Time: %s\n", (sinkInputInfo.sessionStartTime).c_str());
466 dumpString += "\n";
467 }
468 }
469
RecordSourceDump(std::string & dumpString)470 void AudioServerDump::RecordSourceDump(std::string &dumpString)
471 {
472 char s[PA_SAMPLE_SPEC_SNPRINT_MAX];
473 dumpString += "Record Streams \n";
474 AppendFormat(dumpString, "- %zu Record stream (s) available:\n", streamData_.sourceOutputs.size());
475
476 for (auto it = streamData_.sourceOutputs.begin(); it != streamData_.sourceOutputs.end(); it++) {
477 InputOutputInfo sourceOutputInfo = *it;
478 AppendFormat(dumpString, " Stream %d\n", it - streamData_.sourceOutputs.begin() + 1);
479 AppendFormat(dumpString, " - Stream Id: %s\n", (sourceOutputInfo.sessionId).c_str());
480 AppendFormat(dumpString, " - Application Name: %s\n", (sourceOutputInfo.applicationName).c_str());
481 AppendFormat(dumpString, " - Process Id: %s\n", sourceOutputInfo.processId.c_str());
482 AppendFormat(dumpString, " - User Id: %u\n", sourceOutputInfo.userId);
483
484 char *outputSampleSpec = pa_sample_spec_snprint(s, sizeof(s), &(sourceOutputInfo.sampleSpec));
485 AppendFormat(dumpString, " - Stream Configuration: %s\n", outputSampleSpec);
486 dumpString += " - Status:";
487 dumpString += (sourceOutputInfo.corked) ? "STOPPED/PAUSED" : "RUNNING";
488 AppendFormat(dumpString, "\n - Stream Start Time: %s\n", (sourceOutputInfo.sessionStartTime).c_str());
489 dumpString += "\n";
490 }
491 }
492
HDFModulesDump(std::string & dumpString)493 void AudioServerDump::HDFModulesDump(std::string &dumpString)
494 {
495 char s[PA_SAMPLE_SPEC_SNPRINT_MAX];
496
497 dumpString += "\nHDF Input Modules\n";
498 AppendFormat(dumpString, "- %zu HDF Input Modules (s) available:\n", streamData_.sourceDevices.size());
499
500 for (auto it = streamData_.sourceDevices.begin(); it != streamData_.sourceDevices.end(); it++) {
501 SinkSourceInfo sourceInfo = *it;
502
503 AppendFormat(dumpString, " Module %d\n", it - streamData_.sourceDevices.begin() + 1);
504 AppendFormat(dumpString, " - Module Name: %s\n", (sourceInfo.name).c_str());
505 char *hdfOutSampleSpec = pa_sample_spec_snprint(s, sizeof(s), &(sourceInfo.sampleSpec));
506 AppendFormat(dumpString, " - Module Configuration: %s\n\n", hdfOutSampleSpec);
507 }
508
509 dumpString += "HDF Output Modules\n";
510 AppendFormat(dumpString, "- %zu HDF Output Modules (s) available:\n", streamData_.sinkDevices.size());
511
512 for (auto it = streamData_.sinkDevices.begin(); it != streamData_.sinkDevices.end(); it++) {
513 SinkSourceInfo sinkInfo = *it;
514 AppendFormat(dumpString, " Module %d\n", it - streamData_.sinkDevices.begin() + 1);
515 AppendFormat(dumpString, " - Module Name: %s\n", (sinkInfo.name).c_str());
516 char *hdfInSampleSpec = pa_sample_spec_snprint(s, sizeof(s), &(sinkInfo.sampleSpec));
517 AppendFormat(dumpString, " - Module Configuration: %s\n\n", hdfInSampleSpec);
518 }
519 }
520
PolicyHandlerDump(std::string & dumpString)521 void AudioServerDump::PolicyHandlerDump(std::string &dumpString)
522 {
523 AUDIO_INFO_LOG("PolicyHandlerDump");
524 AudioService::GetInstance()->Dump(dumpString);
525 }
526
AudioCacheTimeDump(std::string & dumpString)527 void AudioServerDump::AudioCacheTimeDump(std::string &dumpString)
528 {
529 AUDIO_INFO_LOG("AudioCacheTimeDump");
530 dumpString += "\nAudioCached Time\n";
531
532 int64_t startTime = 0;
533 int64_t endTime = 0;
534 AudioCacheMgr::GetInstance().GetCachedDuration(startTime, endTime);
535 dumpString += "Call dump get time: [ " + ClockTime::NanoTimeToString(startTime) + " ~ " +
536 ClockTime::NanoTimeToString(endTime) + " ], cur: [ " +
537 ClockTime::NanoTimeToString(ClockTime::GetRealNano()) + " ] \n";
538 }
539
AudioCacheMemoryDump(std::string & dumpString)540 void AudioServerDump::AudioCacheMemoryDump(std::string &dumpString)
541 {
542 AUDIO_INFO_LOG("AudioCacheMemoryDump");
543 dumpString += "\nAudioCached Memory\n";
544
545 size_t dataLength = 0;
546 size_t bufferLength = 0;
547 size_t structLength = 0;
548 AudioCacheMgr::GetInstance().GetCurMemoryCondition(dataLength, bufferLength, structLength);
549 dumpString += "dataLength: " + std::to_string(dataLength / BYTE_TO_KB_SIZE) + " KB, " +
550 "bufferLength: " + std::to_string(bufferLength / BYTE_TO_KB_SIZE) + " KB, " +
551 "structLength: " + std::to_string(structLength / BYTE_TO_KB_SIZE) + " KB \n";
552 }
553
AudioPerformMonitorDump(std::string & dumpString)554 void AudioServerDump::AudioPerformMonitorDump(std::string &dumpString)
555 {
556 AUDIO_INFO_LOG("AudioPerformMonitorDump");
557 dumpString += "\n Dump Audio Performance Monitor Record Infos\n";
558 AudioPerformanceMonitor::GetInstance().DumpMonitorInfo(dumpString);
559 }
560
HdiAdapterDump(std::string & dumpString)561 void AudioServerDump::HdiAdapterDump(std::string &dumpString)
562 {
563 AUDIO_INFO_LOG("HdiAdapterDump");
564 dumpString += "\nHdiAdapter Info\n";
565 HdiAdapterManager::GetInstance().DumpInfo(dumpString);
566 }
567
568 } // namespace AudioStandard
569 } // namespace OHOS
570