1 /*
2 * Copyright (c) 2024-2025 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 "AudioPolicyDump"
17 #endif
18
19 #include "audio_policy_dump.h"
20 #include <ability_manager_client.h>
21 #include "iservice_registry.h"
22 #include "parameter.h"
23 #include "parameters.h"
24 #include "data_share_observer_callback.h"
25
26 #include "audio_policy_log.h"
27
28 #include "iservice_registry.h"
29 #include "audio_manager_listener_stub.h"
30 #include "audio_inner_call.h"
31 #include "media_monitor_manager.h"
32 #include "audio_converter_parser.h"
33
34
35 namespace OHOS {
36 namespace AudioStandard {
37
GetEncryptAddr(const std::string & addr)38 static std::string GetEncryptAddr(const std::string &addr)
39 {
40 const int32_t START_POS = 6;
41 const int32_t END_POS = 13;
42 const int32_t ADDRESS_STR_LEN = 17;
43 if (addr.empty() || addr.length() != ADDRESS_STR_LEN) {
44 return std::string("");
45 }
46 std::string tmp = "**:**:**:**:**:**";
47 std::string out = addr;
48 for (int i = START_POS; i <= END_POS; i++) {
49 out[i] = tmp[i];
50 }
51 return out;
52 }
53
IsStreamSupported(AudioStreamType streamType)54 bool AudioPolicyDump::IsStreamSupported(AudioStreamType streamType)
55 {
56 switch (streamType) {
57 case STREAM_MUSIC:
58 case STREAM_RING:
59 case STREAM_VOICE_CALL:
60 case STREAM_VOICE_COMMUNICATION:
61 case STREAM_VOICE_ASSISTANT:
62 case STREAM_WAKEUP:
63 case STREAM_SYSTEM:
64 case STREAM_CAMCORDER:
65 return true;
66 default:
67 return false;
68 }
69 }
70
DevicesInfoDump(std::string & dumpString)71 void AudioPolicyDump::DevicesInfoDump(std::string &dumpString)
72 {
73 std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptors;
74
75 dumpString += "\nInput local Devices:\n";
76 audioDeviceDescriptors = GetDumpDeviceInfo(dumpString, INPUT_DEVICES_FLAG);
77 AppendFormat(dumpString, "- %zu Input Devices (s) available\n", audioDeviceDescriptors.size());
78
79 dumpString += "\nOutput local Devices:\n";
80 audioDeviceDescriptors = GetDumpDeviceInfo(dumpString, OUTPUT_DEVICES_FLAG);
81 AppendFormat(dumpString, "- %zu output Devices (s) available\n", audioDeviceDescriptors.size());
82
83 dumpString += "\nInput distributed Devices:\n";
84 audioDeviceDescriptors = GetDumpDeviceInfo(dumpString, DISTRIBUTED_INPUT_DEVICES_FLAG);
85 AppendFormat(dumpString, "- %zu output Devices (s) available\n", audioDeviceDescriptors.size());
86
87 dumpString += "\nOutput distributed Devices:\n";
88 audioDeviceDescriptors = GetDumpDeviceInfo(dumpString, DISTRIBUTED_OUTPUT_DEVICES_FLAG);
89 AppendFormat(dumpString, "- %zu output Devices (s) available\n", audioDeviceDescriptors.size());
90
91 priorityOutputDevice_ = audioActiveDevice_.GetCurrentOutputDeviceType();
92 priorityInputDevice_ = audioActiveDevice_.GetCurrentInputDeviceType();
93 AppendFormat(dumpString, "\nHighest priority output device: %s",
94 AudioInfoDumpUtils::GetDeviceTypeName(priorityOutputDevice_).c_str());
95 AppendFormat(dumpString, "\nHighest priority input device: %s \n",
96 AudioInfoDumpUtils::GetDeviceTypeName(priorityInputDevice_).c_str());
97
98 audioDeviceManager_.Dump(dumpString);
99 GetMicrophoneDescriptorsDump(dumpString);
100 GetOffloadStatusDump(dumpString);
101 }
102
GetDumpDeviceInfo(std::string & dumpString,DeviceFlag deviceFlag)103 std::vector<std::shared_ptr<AudioDeviceDescriptor>> AudioPolicyDump::GetDumpDeviceInfo(std::string &dumpString,
104 DeviceFlag deviceFlag)
105 {
106 std::vector<std::shared_ptr<AudioDeviceDescriptor>> deviceDescs = GetDumpDevices(deviceFlag);
107
108 for (const auto &desc : deviceDescs) {
109 std::shared_ptr<AudioDeviceDescriptor> devDesc = std::make_shared<AudioDeviceDescriptor>(*desc);
110 dumpString += "\n";
111 AppendFormat(dumpString, " - device name:%s\n",
112 AudioInfoDumpUtils::GetDeviceTypeName(devDesc->deviceType_).c_str());
113 AppendFormat(dumpString, " - device type:%d\n", devDesc->deviceType_);
114 AppendFormat(dumpString, " - device id:%d\n", devDesc->deviceId_);
115 AppendFormat(dumpString, " - device role:%d\n", devDesc->deviceRole_);
116 AppendFormat(dumpString, " - device name:%s\n", devDesc->deviceName_.c_str());
117 AppendFormat(dumpString, " - device mac:%s\n", GetEncryptAddr(devDesc->macAddress_).c_str());
118 AppendFormat(dumpString, " - device network:%s\n", devDesc->networkId_.c_str());
119 if (deviceFlag == DeviceFlag::INPUT_DEVICES_FLAG || deviceFlag == DeviceFlag::OUTPUT_DEVICES_FLAG) {
120 conneceType_ = CONNECT_TYPE_LOCAL;
121 } else if (deviceFlag == DeviceFlag::DISTRIBUTED_INPUT_DEVICES_FLAG ||
122 deviceFlag == DeviceFlag::DISTRIBUTED_OUTPUT_DEVICES_FLAG) {
123 conneceType_ = CONNECT_TYPE_DISTRIBUTED;
124 }
125 AppendFormat(dumpString, " - connect type:%s\n", AudioInfoDumpUtils::GetConnectTypeName(conneceType_).c_str());
126 for (auto &samplingRate : devDesc->audioStreamInfo_.samplingRate) {
127 AppendFormat(dumpString, " - device sampleRates:%d\n", samplingRate);
128 }
129 for (auto &channel : devDesc->audioStreamInfo_.channels) {
130 AppendFormat(dumpString, " - device channels:%d\n", channel);
131 }
132 AppendFormat(dumpString, " - device format:%d\n", devDesc->audioStreamInfo_.format);
133 }
134 return deviceDescs;
135 }
136
GetDumpDevices(DeviceFlag deviceFlag)137 std::vector<std::shared_ptr<AudioDeviceDescriptor>> AudioPolicyDump::GetDumpDevices(DeviceFlag deviceFlag)
138 {
139 bool hasSystemPermission = PermissionUtil::VerifySystemPermission();
140 switch (deviceFlag) {
141 case NONE_DEVICES_FLAG:
142 case DISTRIBUTED_OUTPUT_DEVICES_FLAG:
143 case DISTRIBUTED_INPUT_DEVICES_FLAG:
144 case ALL_DISTRIBUTED_DEVICES_FLAG:
145 case ALL_L_D_DEVICES_FLAG:
146 if (!hasSystemPermission) {
147 AUDIO_ERR_LOG("GetDevices: No system permission");
148 std::vector<std::shared_ptr<AudioDeviceDescriptor>> info = {};
149 return info;
150 }
151 break;
152 default:
153 break;
154 }
155
156 std::vector<std::shared_ptr<AudioDeviceDescriptor>> deviceDescs =
157 audioConnectedDevice_.GetDevicesInner(deviceFlag);
158 if (!hasSystemPermission) {
159 for (std::shared_ptr<AudioDeviceDescriptor> desc : deviceDescs) {
160 desc->networkId_ = "";
161 desc->interruptGroupId_ = GROUP_ID_NONE;
162 desc->volumeGroupId_ = GROUP_ID_NONE;
163 }
164 }
165 return deviceDescs;
166 }
167
GetMicrophoneDescriptorsDump(std::string & dumpString)168 void AudioPolicyDump::GetMicrophoneDescriptorsDump(std::string &dumpString)
169 {
170 dumpString += "\nAvailable MicrophoneDescriptors:\n";
171
172 std::vector<sptr<MicrophoneDescriptor>> micDescs = audioMicrophoneDescriptor_.GetAvailableMicrophones();
173 for (auto it = micDescs.begin();
174 it != micDescs.end(); ++it) {
175 AppendFormat(dumpString, " - id:%d \n", (*it)->micId_);
176 AppendFormat(dumpString, " - device type:%d \n", (*it)->deviceType_);
177 AppendFormat(dumpString, " - group id:%d \n", (*it)->groupId_);
178 AppendFormat(dumpString, " - sensitivity:%d \n", (*it)->sensitivity_);
179 AppendFormat(dumpString, " - position:%f %f %f (x, y, z)\n",
180 (*it)->position_.x, (*it)->position_.y, (*it)->position_.z);
181 AppendFormat(dumpString, " - orientation:%f %f %f (x, y, z)\n",
182 (*it)->orientation_.x, (*it)->orientation_.y, (*it)->orientation_.z);
183 }
184 }
185
GetOffloadStatusDump(std::string & dumpString)186 void AudioPolicyDump::GetOffloadStatusDump(std::string &dumpString)
187 {
188 dumpString += "\nOffload status:";
189 DeviceType dev = audioActiveDevice_.GetCurrentOutputDeviceType();
190 if (dev != DEVICE_TYPE_SPEAKER && dev != DEVICE_TYPE_USB_HEADSET && dev != DEVICE_TYPE_BLUETOOTH_A2DP) {
191 AppendFormat(dumpString, " - current device do not supportted offload: %d\n", dev);
192 }
193 dumpString += "\nPrimary Offload\n";
194 if (dev == DEVICE_TYPE_SPEAKER || dev == DEVICE_TYPE_USB_HEADSET) {
195 AppendFormat(dumpString, " - primary deviceType : %d\n", dev);
196 AppendFormat(dumpString, " - primary offloadEnable : %d\n", audioOffloadStream_.GetOffloadAvailableFromXml());
197 } else {
198 AppendFormat(dumpString, " - current device is not primary\n");
199 }
200 dumpString += "\nA2DP offload\n";
201 if (dev == DEVICE_TYPE_BLUETOOTH_A2DP) {
202 AppendFormat(dumpString, " - A2DP deviceType: %d\n", dev);
203 AppendFormat(dumpString, " - A2DP offloadstatus : %d\n", audioA2dpOffloadFlag_.GetA2dpOffloadFlag());
204 } else {
205 AppendFormat(dumpString, " - current device is not A2DP\n");
206 }
207 AppendFormat(dumpString, "\n");
208 }
209
210
AudioModeDump(std::string & dumpString)211 void AudioPolicyDump::AudioModeDump(std::string &dumpString)
212 {
213 GetCallStatusDump(dumpString);
214 GetRingerModeDump(dumpString);
215 }
216
GetCallStatusDump(std::string & dumpString)217 void AudioPolicyDump::GetCallStatusDump(std::string &dumpString)
218 {
219 dumpString += "\nAudio Scene:";
220 bool hasSystemPermission = PermissionUtil::VerifySystemPermission();
221 AudioScene callStatus = audioSceneManager_.GetAudioScene(hasSystemPermission);
222 switch (callStatus) {
223 case AUDIO_SCENE_DEFAULT:
224 dumpString += "DEFAULT";
225 break;
226 case AUDIO_SCENE_RINGING:
227 dumpString += "RINGING";
228 break;
229 case AUDIO_SCENE_PHONE_CALL:
230 dumpString += "PHONE_CALL";
231 break;
232 case AUDIO_SCENE_PHONE_CHAT:
233 dumpString += "PHONE_CHAT";
234 break;
235 default:
236 dumpString += "UNKNOWN";
237 }
238 dumpString += "\n";
239 }
240
GetRingerModeDump(std::string & dumpString)241 void AudioPolicyDump::GetRingerModeDump(std::string &dumpString)
242 {
243 dumpString += "Ringer Mode:";
244 AudioRingerMode ringerMode = audioPolicyManager_.GetRingerMode();
245 switch (ringerMode) {
246 case RINGER_MODE_NORMAL:
247 dumpString += "NORMAL";
248 break;
249 case RINGER_MODE_SILENT:
250 dumpString += "SILENT";
251 break;
252 case RINGER_MODE_VIBRATE:
253 dumpString += "VIBRATE";
254 break;
255 default:
256 dumpString += "UNKNOWN";
257 }
258 dumpString += "\n\n";
259 }
260
StreamVolumesDump(std::string & dumpString)261 void AudioPolicyDump::StreamVolumesDump(std::string &dumpString)
262 {
263 dumpString += "\nStream Volumes:\n";
264 // Get stream volumes
265 std::map<AudioStreamType, int32_t> streamVolumes_;
266 for (int stream = AudioStreamType::STREAM_VOICE_CALL; stream <= AudioStreamType::STREAM_TYPE_MAX; stream++) {
267 AudioStreamType streamType = (AudioStreamType)stream;
268
269 if (IsStreamSupported(streamType)) {
270 if (streamType == STREAM_ALL) {
271 streamType = STREAM_MUSIC;
272 AUDIO_DEBUG_LOG("GetVolume of STREAM_ALL for streamType = %{public}d ", streamType);
273 }
274 int32_t volume = audioVolumeManager_.GetSystemVolumeLevel(streamType);
275 streamVolumes_.insert({ streamType, volume });
276 }
277 }
278 AppendFormat(dumpString, " [StreamName]: [Volume]\n");
279 for (auto it = streamVolumes_.cbegin(); it != streamVolumes_.cend();
280 ++it) {
281 AppendFormat(dumpString, " - %s: %d\n", AudioInfoDumpUtils::GetStreamName(it->first).c_str(), it->second);
282 }
283 GetVolumeConfigDump(dumpString);
284 GetGroupInfoDump(dumpString);
285 audioPolicyManager_.SafeVolumeDump(dumpString);
286 }
287
GetVolumeConfigDump(std::string & dumpString)288 void AudioPolicyDump::GetVolumeConfigDump(std::string &dumpString)
289 {
290 dumpString += "\nVolume config of streams:\n";
291
292 StreamVolumeInfoMap streamVolumeInfos;
293 audioPolicyManager_.GetStreamVolumeInfoMap(streamVolumeInfos);
294 for (auto it = streamVolumeInfos.cbegin();
295 it != streamVolumeInfos.cend(); ++it) {
296 auto streamType = it->first;
297 AppendFormat(dumpString, " %s: ", AudioInfoDumpUtils::GetStreamName(streamType).c_str());
298 if (streamType == STREAM_ALL) {
299 streamType = STREAM_MUSIC;
300 AUDIO_INFO_LOG("GetStreamMute of STREAM_ALL for streamType = %{public}d ", streamType);
301 }
302 AppendFormat(dumpString, "mute = %d ", audioVolumeManager_.GetStreamMute(streamType));
303 auto streamVolumeInfo = it->second;
304 AppendFormat(dumpString, "minLevel = %d ", streamVolumeInfo->minLevel);
305 AppendFormat(dumpString, "maxLevel = %d ", streamVolumeInfo->maxLevel);
306 AppendFormat(dumpString, "defaultLevel = %d\n", streamVolumeInfo->defaultLevel);
307 DeviceVolumeInfosDump(dumpString, streamVolumeInfo->deviceVolumeInfos);
308 }
309 }
310
DeviceVolumeInfosDump(std::string & dumpString,DeviceVolumeInfoMap & deviceVolumeInfos)311 void AudioPolicyDump::DeviceVolumeInfosDump(std::string &dumpString, DeviceVolumeInfoMap &deviceVolumeInfos)
312 {
313 for (auto iter = deviceVolumeInfos.cbegin(); iter != deviceVolumeInfos.cend(); ++iter) {
314 AppendFormat(dumpString, " %s : {", AudioInfoDumpUtils::GetDeviceVolumeTypeName(iter->first).c_str());
315 auto volumePoints = iter->second->volumePoints;
316 for (auto volPoint = volumePoints.cbegin(); volPoint != volumePoints.cend(); ++volPoint) {
317 AppendFormat(dumpString, "[%u, %d]", volPoint->index, volPoint->dbValue);
318 if (volPoint + 1 != volumePoints.cend()) {
319 dumpString += ", ";
320 }
321 }
322 dumpString += "}\n";
323 }
324 }
325
GetGroupInfoDump(std::string & dumpString)326 void AudioPolicyDump::GetGroupInfoDump(std::string &dumpString)
327 {
328 dumpString += "\nVolume GroupInfo:\n";
329 // Get group info
330 std::vector<sptr<VolumeGroupInfo>> groupInfos;
331 audioVolumeManager_.GetVolumeGroupInfo(groupInfos);
332 AppendFormat(dumpString, "- %zu Group Infos (s) available :\n", groupInfos.size());
333
334 for (auto it = groupInfos.begin(); it != groupInfos.end(); it++) {
335 AppendFormat(dumpString, " Group Infos %d\n", it - groupInfos.begin() + 1);
336 AppendFormat(dumpString, " - ConnectType(0 for Local, 1 for Remote): %d\n", (*it)->connectType_);
337 AppendFormat(dumpString, " - Name: %s\n", (*it)->groupName_.c_str());
338 AppendFormat(dumpString, " - Id: %d\n", (*it)->volumeGroupId_);
339 }
340 dumpString += "\n";
341 }
342
AudioPolicyParserDumpInner(std::string & dumpString,const std::unordered_map<AdaptersType,AudioAdapterInfo> & adapterInfoMap,const std::unordered_map<std::string,std::string> & volumeGroupData,std::unordered_map<std::string,std::string> & interruptGroupData,GlobalConfigs globalConfigs)343 void AudioPolicyDump::AudioPolicyParserDumpInner(std::string &dumpString,
344 const std::unordered_map<AdaptersType, AudioAdapterInfo>& adapterInfoMap,
345 const std::unordered_map<std::string, std::string>& volumeGroupData,
346 std::unordered_map<std::string, std::string>& interruptGroupData,
347 GlobalConfigs globalConfigs)
348 {
349 for (auto &[adapterType, adapterInfo] : adapterInfoMap) {
350 AppendFormat(dumpString, " - adapter : %s -- adapterType:%u\n", adapterInfo.adapterName_.c_str(), adapterType);
351 for (auto &deviceInfo : adapterInfo.deviceInfos_) {
352 AppendFormat(dumpString, " - device -- name:%s, pin:%s, type:%s, role:%s\n", deviceInfo.name_.c_str(),
353 deviceInfo.pin_.c_str(), deviceInfo.type_.c_str(), deviceInfo.role_.c_str());
354 }
355 for (auto &pipeInfo : adapterInfo.pipeInfos_) {
356 AppendFormat(dumpString, " - module : -- name:%s, pipeRole:%s, pipeFlags:%s, lib:%s, paPropRole:%s, "
357 "fixedLatency:%s, renderInIdleState:%s\n", pipeInfo.name_.c_str(),
358 pipeInfo.pipeRole_.c_str(), pipeInfo.pipeFlags_.c_str(), pipeInfo.lib_.c_str(),
359 pipeInfo.paPropRole_.c_str(), pipeInfo.fixedLatency_.c_str(), pipeInfo.renderInIdleState_.c_str());
360
361 for (auto &configInfo : pipeInfo.configInfos_) {
362 AppendFormat(dumpString, " - config : -- name:%s, value:%s\n", configInfo.name_.c_str(),
363 configInfo.value_.c_str());
364 }
365 }
366 }
367 for (auto& volume : volumeGroupData) {
368 AppendFormat(dumpString, " - volumeGroupMap_ first:%s, second:%s\n\n", volume.first.c_str(),
369 volume.second.c_str());
370 }
371 for (auto& interrupt : interruptGroupData) {
372 AppendFormat(dumpString, " - interruptGroupMap_ first:%s, second:%s\n", interrupt.first.c_str(),
373 interrupt.second.c_str());
374 }
375 AppendFormat(dumpString, " - globalConfig adapter:%s, pipe:%s, device:%s, updateRouteSupport:%d, "
376 "audioLatency:%s, sinkLatency:%s\n", globalConfigs.adapter_.c_str(),
377 globalConfigs.pipe_.c_str(), globalConfigs.device_.c_str(),
378 globalConfigs.updateRouteSupport_,
379 globalConfigs.globalPaConfigs_.audioLatency_.c_str(),
380 globalConfigs.globalPaConfigs_.sinkLatency_.c_str());
381 for (auto &outputConfig : globalConfigs.outputConfigInfos_) {
382 AppendFormat(dumpString, " - output config name:%s, type:%s, value:%s\n", outputConfig.name_.c_str(),
383 outputConfig.type_.c_str(), outputConfig.value_.c_str());
384 }
385 for (auto &inputConfig : globalConfigs.inputConfigInfos_) {
386 AppendFormat(dumpString, " - input config name:%s, type_%s, value:%s\n\n", inputConfig.name_.c_str(),
387 inputConfig.type_.c_str(), inputConfig.value_.c_str());
388 }
389 AppendFormat(dumpString, " - module curActiveCount:%d\n\n", audioPolicyManager_.GetCurActivateCount());
390 }
391
AudioPolicyParserDump(std::string & dumpString)392 void AudioPolicyDump::AudioPolicyParserDump(std::string &dumpString)
393 {
394 dumpString += "\nAudioPolicyParser:\n";
395 std::unordered_map<AdaptersType, AudioAdapterInfo> adapterInfoMap;
396 std::unordered_map<std::string, std::string> volumeGroupData;
397 std::unordered_map<std::string, std::string> interruptGroupData;
398 GlobalConfigs globalConfigs;
399
400 audioConfigManager_.GetAudioAdapterInfos(adapterInfoMap);
401 audioConfigManager_.GetVolumeGroupData(volumeGroupData);
402 audioConfigManager_.GetInterruptGroupData(interruptGroupData);
403 audioConfigManager_.GetGlobalConfigs(globalConfigs);
404
405 AudioPolicyParserDumpInner(dumpString, adapterInfoMap, volumeGroupData, interruptGroupData, globalConfigs);
406 }
407
AudioStreamDump(std::string & dumpString)408 void AudioPolicyDump::AudioStreamDump(std::string &dumpString)
409 {
410 dumpString += "\nAudioRenderer stream:\n";
411 vector<shared_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
412 streamCollector_.GetCurrentRendererChangeInfos(audioRendererChangeInfos);
413
414 AppendFormat(dumpString, " - audiorenderer stream size : %zu\n", audioRendererChangeInfos.size());
415 for (auto it = audioRendererChangeInfos.begin(); it != audioRendererChangeInfos.end(); it++) {
416 if ((*it)->rendererInfo.rendererFlags == STREAM_FLAG_NORMAL) {
417 AppendFormat(dumpString, " - normal AudioCapturer stream:\n");
418 } else if ((*it)->rendererInfo.rendererFlags == STREAM_FLAG_FAST) {
419 AppendFormat(dumpString, " - fast AudioCapturer stream:\n");
420 }
421 AppendFormat(dumpString, " - rendererStatus : %d\n", (*it)->rendererState);
422 AppendFormat(dumpString, " - clientUID : %d\n", (*it)->clientUID);
423 AppendFormat(dumpString, " - streamId : %d\n", (*it)->sessionId);
424 AppendFormat(dumpString, " - deviceType : %d\n", (*it)->outputDeviceInfo.deviceType_);
425 AppendFormat(dumpString, " - contentType : %d\n", (*it)->rendererInfo.contentType);
426 AppendFormat(dumpString, " - streamUsage : %d\n", (*it)->rendererInfo.streamUsage);
427 AppendFormat(dumpString, " - samplingRate : %d\n", (*it)->rendererInfo.samplingRate);
428 AppendFormat(dumpString, " - pipeType : %d\n", (*it)->rendererInfo.pipeType);
429 AppendFormat(dumpString, " - rendererState : %d\n", (*it)->rendererState);
430 AppendFormat(dumpString, " - appVolume : %d\n", (*it)->appVolume);
431 }
432 GetCapturerStreamDump(dumpString);
433 }
434
GetCapturerStreamDump(std::string & dumpString)435 void AudioPolicyDump::GetCapturerStreamDump(std::string &dumpString)
436 {
437 dumpString += "\nAudioCapturer stream:\n";
438 vector<shared_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
439 streamCollector_.GetCurrentCapturerChangeInfos(audioCapturerChangeInfos);
440 AppendFormat(dumpString, " - audiocapturer stream size : %zu\n", audioCapturerChangeInfos.size());
441 for (auto it = audioCapturerChangeInfos.begin(); it != audioCapturerChangeInfos.end(); it++) {
442 if ((*it)->capturerInfo.capturerFlags == STREAM_FLAG_NORMAL) {
443 AppendFormat(dumpString, " - normal AudioCapturer stream:\n");
444 } else if ((*it)->capturerInfo.capturerFlags == STREAM_FLAG_FAST) {
445 AppendFormat(dumpString, " - fast AudioCapturer stream:\n");
446 }
447 AppendFormat(dumpString, " - clientUID : %d\n", (*it)->clientUID);
448 AppendFormat(dumpString, " - streamId : %d\n", (*it)->sessionId);
449 AppendFormat(dumpString, " - is muted : %s\n", (*it)->muted ? "true" : "false");
450 AppendFormat(dumpString, " - deviceType : %d\n", (*it)->inputDeviceInfo.deviceType_);
451 AppendFormat(dumpString, " - samplingRate : %d\n", (*it)->capturerInfo.samplingRate);
452 AppendFormat(dumpString, " - pipeType : %d\n", (*it)->capturerInfo.pipeType);
453 AppendFormat(dumpString, " - capturerState : %d\n", (*it)->capturerState);
454 }
455 }
456
XmlParsedDataMapDump(std::string & dumpString)457 void AudioPolicyDump::XmlParsedDataMapDump(std::string &dumpString)
458 {
459 dumpString += "\nXmlParsedDataParser:\n";
460
461 std::unordered_map<ClassType, std::list<AudioModuleInfo>> deviceClassInfo = {};
462 audioConfigManager_.GetDeviceClassInfo(deviceClassInfo);
463
464 for (auto &[adapterType, deviceClassInfos] : deviceClassInfo) {
465 AppendFormat(dumpString, " - DeviceClassInfo type %d\n", adapterType);
466 for (const auto &deviceClassInfoIter : deviceClassInfos) {
467 AppendFormat(dumpString, " - Data : className:%s, name:%s, adapter:%s, id:%s, lib:%s, role:%s, rate:%s\n",
468 deviceClassInfoIter.className.c_str(), deviceClassInfoIter.name.c_str(),
469 deviceClassInfoIter.adapterName.c_str(), deviceClassInfoIter.id.c_str(),
470 deviceClassInfoIter.lib.c_str(), deviceClassInfoIter.role.c_str(), deviceClassInfoIter.rate.c_str());
471
472 for (auto rate : deviceClassInfoIter.supportedRate_) {
473 AppendFormat(dumpString, " - rate:%u\n", rate);
474 }
475
476 for (auto supportedChannel : deviceClassInfoIter.supportedChannels_) {
477 AppendFormat(dumpString, " - supportedChannel:%u\n", supportedChannel);
478 }
479
480 AppendFormat(dumpString, " -DeviceClassInfo : format:%s, channels:%s, bufferSize:%s, fixedLatency:%s, "
481 " sinkLatency:%s, renderInIdleState:%s, OpenMicSpeaker:%s, fileName:%s, networkId:%s, "
482 "deviceType:%s, sceneName:%s, sourceType:%s, offloadEnable:%s\n",
483 deviceClassInfoIter.format.c_str(), deviceClassInfoIter.channels.c_str(),
484 deviceClassInfoIter.bufferSize.c_str(),
485 deviceClassInfoIter.fixedLatency.c_str(), deviceClassInfoIter.sinkLatency.c_str(),
486 deviceClassInfoIter.renderInIdleState.c_str(), deviceClassInfoIter.OpenMicSpeaker.c_str(),
487 deviceClassInfoIter.fileName.c_str(), deviceClassInfoIter.networkId.c_str(),
488 deviceClassInfoIter.deviceType.c_str(), deviceClassInfoIter.sceneName.c_str(),
489 deviceClassInfoIter.sourceType.c_str(), deviceClassInfoIter.offloadEnable.c_str());
490 }
491 AppendFormat(dumpString, "-----EndOfXmlParsedDataMap-----\n");
492 }
493 }
494
StreamEffectSceneInfoDump(string & dumpString,const ProcessNew & processNew,const string processType)495 static void StreamEffectSceneInfoDump(string &dumpString, const ProcessNew &processNew, const string processType)
496 {
497 AppendFormat(dumpString, "- %zu %s supported :\n", processNew.stream.size(), processType.c_str());
498
499 for (Stream x : processNew.stream) {
500 AppendFormat(dumpString, " %s stream scene = %s \n", processType.c_str(), x.scene.c_str());
501 int32_t count = 0;
502 for (StreamEffectMode mode : x.streamEffectMode) {
503 count++;
504 AppendFormat(dumpString, " - modeName%d = %s \n", count, mode.mode.c_str());
505 int32_t n = 0;
506 for (Device deviceInfo : mode.devicePort) {
507 n++;
508 AppendFormat(dumpString, " - device%d type = %s \n", n, deviceInfo.type.c_str());
509 AppendFormat(dumpString, " - device%d chain = %s \n", n, deviceInfo.chain.c_str());
510 }
511 }
512 dumpString += "\n";
513 }
514 }
515
GetEffectManagerInfo()516 void AudioPolicyDump::GetEffectManagerInfo()
517 {
518 AudioConverterParser &converterParser = AudioConverterParser::GetInstance();
519 converterConfig_ = converterParser.LoadConfig();
520 audioEffectService_.GetSupportedEffectConfig(supportedEffectConfig_);
521 }
522
EffectManagerInfoDump(string & dumpString)523 void AudioPolicyDump::EffectManagerInfoDump(string &dumpString)
524 {
525 int32_t count = 0;
526 GetEffectManagerInfo();
527
528 std::unordered_map<AdaptersType, AudioAdapterInfo> adapterInfoMap;
529 audioConfigManager_.GetAudioAdapterInfos(adapterInfoMap);
530
531 dumpString += "==== Audio Effect Manager INFO ====\n";
532
533 // effectChain info
534 count = 0;
535 AppendFormat(dumpString, "- system support %d effectChain(s):\n",
536 supportedEffectConfig_.effectChains.size());
537 for (EffectChain x : supportedEffectConfig_.effectChains) {
538 count++;
539 AppendFormat(dumpString, " effectChain%d :\n", count);
540 AppendFormat(dumpString, " - effectChain name = %s \n", x.name.c_str());
541 int32_t countEffect = 0;
542 for (string effectUnit : x.apply) {
543 countEffect++;
544 AppendFormat(dumpString, " - effectUnit%d = %s \n", countEffect, effectUnit.c_str());
545 }
546 dumpString += "\n";
547 }
548
549 // converter info
550 AppendFormat(dumpString, "- system support audio converter for special streams:\n");
551 AppendFormat(dumpString, " - converter name: %s\n", converterConfig_.library.name.c_str());
552 AppendFormat(dumpString, " - converter out channel layout: %" PRId64 "\n",
553 converterConfig_.outChannelLayout);
554 dumpString += "\n";
555
556 // preProcess info
557 StreamEffectSceneInfoDump(dumpString, supportedEffectConfig_.preProcessNew, "preProcess");
558 dumpString += "\n";
559 // postProcess info
560 StreamEffectSceneInfoDump(dumpString, supportedEffectConfig_.postProcessNew, "postProcess");
561
562 // postProcess scene maping
563 AppendFormat(dumpString, "- postProcess scene maping config:\n");
564 for (SceneMappingItem it: supportedEffectConfig_.postProcessSceneMap) {
565 AppendFormat(dumpString, " - streamUsage: %s = %s \n", it.name.c_str(), it.sceneType.c_str());
566 }
567 dumpString += "\n";
568 }
569
MicrophoneMuteInfoDump(string & dumpString)570 void AudioPolicyDump::MicrophoneMuteInfoDump(string &dumpString)
571 {
572 dumpString += "==== Microphone Mute INFO ====\n";
573 // non-persistent microphone mute info
574 AppendFormat(dumpString, " - non-persistent microphone isMuted: %d \n",
575 audioMicrophoneDescriptor_.GetMicrophoneMuteTemporary());
576 // persistent microphone mute info
577 AppendFormat(dumpString, " - persistent microphone isMuted: %d \n",
578 audioMicrophoneDescriptor_.GetMicrophoneMutePersistent());
579 dumpString += "\n";
580 }
581
582 }
583 }