From 752c7bba057c37d4fac528eabeeefd6d7848675a Mon Sep 17 00:00:00 2001 From: liyuhang Date: Thu, 25 Apr 2024 08:07:10 +0000 Subject: [PATCH] New audio policy config xml Signed-off-by: liyuhang Change-Id: I044ff398ea31598c615ae1f546818dccce5c25a2 --- .../server/include/audio_service_dump.h | 3 + .../include/service/audio_policy_service.h | 15 +- .../service/common/audio_adapter_info.h | 118 +++- .../service/common/audio_module_info.h | 2 + .../service/config/audio_policy_parser.h | 58 +- .../include/service/config/parser_factory.h | 44 -- .../include/service/config/xml_parser.h | 96 --- .../service/interface/iport_observer.h | 1 + .../server/src/audio_policy_server.cpp | 2 + .../src/service/audio_policy_service.cpp | 105 +-- .../service/config/audio_policy_parser.cpp | 667 +++++++++++------- .../server/src/service/config/xml_parser.cpp | 376 ---------- .../src/service/dump/audio_service_dump.cpp | 86 ++- 13 files changed, 708 insertions(+), 865 deletions(-) delete mode 100644 services/audio_policy/server/include/service/config/parser_factory.h delete mode 100644 services/audio_policy/server/include/service/config/xml_parser.h delete mode 100644 services/audio_policy/server/src/service/config/xml_parser.cpp diff --git a/services/audio_policy/server/include/audio_service_dump.h b/services/audio_policy/server/include/audio_service_dump.h index 7cc760f5d8..38f0534057 100644 --- a/services/audio_policy/server/include/audio_service_dump.h +++ b/services/audio_policy/server/include/audio_service_dump.h @@ -103,6 +103,8 @@ typedef struct { std::map adapterInfoMap; std::unordered_map volumeGroupData; std::unordered_map interruptGroupData; + std::unordered_map> deviceClassInfo; + GlobalConfigs globalConfigs; } PolicyData; typedef struct { @@ -145,6 +147,7 @@ private: void AudioFocusInfoDump(std::string &dumpString); void AudioInterruptZoneDump(std::string &dumpString); void AudioPolicyParserDump(std::string &dumpString); + void DumpXmlParsedDataMap(std::string &dumpString); void GroupInfoDump(std::string& dumpString); void EffectManagerInfoDump(std::string& dumpString); void DataDump(std::string &dumpString); diff --git a/services/audio_policy/server/include/service/audio_policy_service.h b/services/audio_policy/server/include/service/audio_policy_service.h index 6d4780b5ca..9c499de82c 100644 --- a/services/audio_policy/server/include/service/audio_policy_service.h +++ b/services/audio_policy/server/include/service/audio_policy_service.h @@ -172,6 +172,10 @@ public: void GetInterruptGroupData(std::unordered_map& interruptGroupData); + void GetDeviceClassInfo(std::unordered_map> &deviceClassInfo); + + void GetGlobalConfigs(GlobalConfigs &globalConfigs); + // Audio Policy Parser callbacks void OnAudioPolicyXmlParsingCompleted(const std::map adapterInfoMap); @@ -182,6 +186,8 @@ public: void OnInterruptGroupParsed(std::unordered_map& interruptGroupData); + void OnGlobalConfigsParsed(GlobalConfigs &globalConfigs); + void OnUpdateRouteSupport(bool isSupported); int32_t GetDeviceNameFromDataShareHelper(std::string &deviceName); @@ -326,8 +332,6 @@ public: float GetMaxStreamVolume(void); - void MaxRenderInstanceInit(); - int32_t GetMaxRendererInstances(); void RegisterDataObserver(); @@ -706,7 +710,8 @@ private: void MuteSinkPort(unique_ptr &desc); - void RectifyModuleInfo(AudioModuleInfo &moduleInfo, AudioAdapterInfo audioAdapterInfo, SourceInfo targetInfo); + void RectifyModuleInfo(AudioModuleInfo &moduleInfo, std::list &moduleInfoList, + SourceInfo &targetInfo); void ClearScoDeviceSuspendState(string macAddress = ""); @@ -816,6 +821,7 @@ private: std::vector> interruptGroups_; std::unordered_map volumeGroupData_; std::unordered_map interruptGroupData_; + GlobalConfigs globalConfigs_; AudioEffectManager& audioEffectManager_; bool isMicrophoneMute_ = false; @@ -858,6 +864,9 @@ private: SOURCE_TYPE_REMOTE_CAST }; + static std::map formatStrToEnum; + static std::map classStrToEnum; + std::unordered_set sessionIdisRemovedSet_; SourceType currentSourceType = SOURCE_TYPE_MIC; diff --git a/services/audio_policy/server/include/service/common/audio_adapter_info.h b/services/audio_policy/server/include/service/common/audio_adapter_info.h index 1c53758d21..b0dd13fc85 100644 --- a/services/audio_policy/server/include/service/common/audio_adapter_info.h +++ b/services/audio_policy/server/include/service/common/audio_adapter_info.h @@ -69,57 +69,73 @@ static const std::string MODULE_FILE_SOURCE_FILE = "/data/data/.pulse_dir/file_s static const std::string CONFIG_TYPE_PRELOAD = "preload"; static const std::string CONFIG_TYPE_MAXINSTANCES = "maxinstances"; +static const uint32_t DEFAULT_PERIOD_IN_MS = 20; // 20ms + enum class XmlNodeType { ADAPTERS, VOLUME_GROUPS, INTERRUPT_GROUPS, - EXTENDS, + GLOBAL_CONFIGS, XML_UNKNOWN }; enum class AdaptersType { TYPE_PRIMARY, TYPE_A2DP, - TYPE_REMOTE, - TYPE_FILE, TYPE_USB, + TYPE_FILE_IO, + TYPE_REMOTE_AUDIO, TYPE_DP, TYPE_INVALID }; enum class AdapterType { + PIPES, DEVICES, - MODULES, UNKNOWN }; -enum class ModulesType { - SINK, - SOURCE, +enum class PipeType { + PA_PROP, + STREAM_PROP, + CONFIGS, UNKNOWN }; -enum class ModuleType { - CONFIGS, - PROFILES, - DEVICES, +enum class GlobalConfigType { + DEFAULT_OUTPUT, + COMMON_CONFIGS, + PA_CONFIGS, + DEFAULT_MAX_CON_CURRENT_INSTANCE, UNKNOWN }; -enum class ExtendType { - UPDATE_ROUTE_SUPPORT, +enum class PAConfigType { AUDIO_LATENCY, SINK_LATENCY, UNKNOWN }; +enum class DefaultMaxInstanceType { + OUTPUT, + INPUT, + UNKNOWN +}; + +enum class StreamType { + NORMAL, + FAST, + UNKNOWN +}; + class ConfigInfo { public: ConfigInfo() = default; virtual ~ConfigInfo() = default; std::string name_ = STR_INIT; - std::string valu_ = STR_INIT; + std::string value_ = STR_INIT; + std::string type_ = STR_INIT; }; class ProfileInfo { @@ -143,6 +159,51 @@ public: std::string role_ = STR_INIT; }; +class StreamPropInfo { +public: + StreamPropInfo() = default; + virtual ~StreamPropInfo() = default; + + std::string format_ = STR_INIT; + uint32_t sampleRate_ = 0; + uint32_t periodInMs_ = DEFAULT_PERIOD_IN_MS; + uint32_t channelLayout_ = 0; + uint32_t bufferSize_ = 0; +}; + +class PipeInfo { +public: + PipeInfo() = default; + virtual ~PipeInfo() = default; + + std::string name_ = STR_INIT; + std::string pipeRole_ = STR_INIT; + std::string pipeFlags_ = STR_INIT; + std::string moduleName_ = STR_INIT; + + std::string lib_ = STR_INIT; + std::string paPropRole_ = STR_INIT; + std::string fixedLatency_ = STR_INIT; + std::string renderInIdleState_ = STR_INIT; + + std::list streamPropInfos_ {}; + std::list sampleRates_ {}; + std::list channelLayouts_ {}; + std::list configInfos_ {}; +}; + +class AudioPipeDeviceInfo { +public: + AudioPipeDeviceInfo() = default; + virtual ~AudioPipeDeviceInfo() = default; + + std::string name_ = STR_INIT; + std::string type_ = STR_INIT; + std::string pin_ = STR_INIT; + std::string role_ = STR_INIT; + std::list supportPipes_ {}; +}; + class ModuleInfo { public: ModuleInfo() = default; @@ -169,8 +230,33 @@ public: virtual ~AudioAdapterInfo() = default; std::string adapterName_ = STR_INIT; - std::list deviceInfos_ {}; - std::list moduleInfos_ {}; + std::string adaptersupportScene_ = STR_INIT; + std::list deviceInfos_ {}; + std::list pipeInfos_ {}; +}; + +class GlobalPaConfigs { +public: + GlobalPaConfigs() = default; + virtual ~GlobalPaConfigs() = default; + + std::string audioLatency_ = STR_INIT; + std::string sinkLatency_ = STR_INIT; +}; + +class GlobalConfigs { +public: + GlobalConfigs() = default; + virtual ~GlobalConfigs() = default; + + std::string adapter_ = STR_INIT; + std::string pipe_ = STR_INIT; + std::string device_ = STR_INIT; + std::list commonConfigs_ {}; + bool updateRouteSupport_ = false; + GlobalPaConfigs globalPaConfigs_; + std::list outputConfigInfos_ {}; + std::list inputConfigInfos_ {}; }; } // namespace AudioStandard } // namespace OHOS diff --git a/services/audio_policy/server/include/service/common/audio_module_info.h b/services/audio_policy/server/include/service/common/audio_module_info.h index 88e20bc43c..a26a779aaa 100644 --- a/services/audio_policy/server/include/service/common/audio_module_info.h +++ b/services/audio_policy/server/include/service/common/audio_module_info.h @@ -30,6 +30,8 @@ static const std::string A2DP_CLASS = "a2dp"; static const std::string USB_CLASS = "usb"; static const std::string DP_CLASS = "dp"; static const std::string FILE_CLASS = "file_io"; +static const std::string REMOTE_CLASS = "remote"; +static const std::string INVALID_CLASS = "invalid"; static const std::string BLUETOOTH_SPEAKER = "Bt_Speaker"; static const std::string PRIMARY_SPEAKER = "Speaker"; static const std::string USB_SPEAKER = "Usb_arm_speaker"; diff --git a/services/audio_policy/server/include/service/config/audio_policy_parser.h b/services/audio_policy/server/include/service/config/audio_policy_parser.h index 09b85aa24c..4778850198 100644 --- a/services/audio_policy/server/include/service/config/audio_policy_parser.h +++ b/services/audio_policy/server/include/service/config/audio_policy_parser.h @@ -25,16 +25,16 @@ #include "audio_adapter_info.h" #include "audio_device_info.h" +#include "audio_stream_info.h" #include "iport_observer.h" #include "parser.h" namespace OHOS { namespace AudioStandard { - class AudioPolicyParser : public Parser { public: - static constexpr char CHIP_PROD_CONFIG_FILE[] = "/chip_prod/etc/audio/audio_policy_config.xml"; - static constexpr char CONFIG_FILE[] = "/vendor/etc/audio/audio_policy_config_new.xml"; + static constexpr char CHIP_PROD_CONFIG_FILE[] = "/chip_prod/etc/audio/audio_policy_config_new.xml"; + static constexpr char CONFIG_FILE[] = "vendor/etc/audio/audio_policy_config.xml"; bool LoadConfiguration() final; bool Parse() final; @@ -52,37 +52,48 @@ public: } private: - XmlNodeType GetNodeTypeAsInt(xmlNode &node); - AdaptersType GetAdaptersType(const std::string &adapterClass); AdapterType GetAdapterTypeAsInt(xmlNode &node); - ModulesType GetModulesTypeAsInt(xmlNode &node); - ModuleType GetModuleTypeAsInt(xmlNode &node); - ExtendType GetExtendTypeAsInt(xmlNode &node); + PipeType GetPipeInfoTypeAsInt(xmlNode &node); + GlobalConfigType GetGlobalConfigTypeAsInt(xmlNode &node); + XmlNodeType GetXmlNodeTypeAsInt(xmlNode &node); + DefaultMaxInstanceType GetDefaultMaxInstanceTypeAsInt(xmlNode &node); + StreamType GetStreamTypeAsInt(xmlNode &node); bool ParseInternal(xmlNode &node); void ParseAdapters(xmlNode &node); void ParseAdapter(xmlNode &node); - void ParseModule(xmlNode &node, ModuleInfo &moduleInfo); - void ParseModuleProperty(xmlNode &node, ModuleInfo &moduleInfo, std::string adapterName); - void ParseModules(xmlNode &node, AudioAdapterInfo &adapterInfo); - void ParseAudioAdapterDevices(xmlNode &node, AudioAdapterInfo &adapterInfo); - void ParseConfigs(xmlNode &node, ModuleInfo &moduleInfo); - void ParseProfiles(xmlNode &node, ModuleInfo &moduleInfo); - void ParseModuleDevices(xmlNode &node, ModuleInfo &moduleInfo); + void ParsePipes(xmlNode &node, AudioAdapterInfo &adapterInfo); + void ParsePipeInfos(xmlNode &node, PipeInfo &pipeInfo); + void ParseStreamProps(xmlNode &node, PipeInfo &pipeInfo); + void ParseConfigs(xmlNode &node, PipeInfo &pipeInfo); + void ParseDevices(xmlNode &node, AudioAdapterInfo &adapterInfo); void ParseGroups(xmlNode& node, XmlNodeType type); void ParseGroup(xmlNode& node, XmlNodeType type); - void ParseGroupSink(xmlNode& node, XmlNodeType type, std::string groupName); - void ParseExtends(xmlNode& node); - void ParseUpdateRouteSupport(xmlNode &node); + void ParseGroupSink(xmlNode &node, XmlNodeType type, std::string &groupName); + void ParseGlobalConfigs(xmlNode& node); + void ParsePAConfigs(xmlNode& node); + void ParseDefaultMaxInstances(xmlNode& node); + void ParseOutputMaxInstances(xmlNode& node); + void ParseInputMaxInstances(xmlNode& node); + void ParseCommonConfigs(xmlNode& node); + + void HandleUpdateRouteSupportParsed(std::string &value); + PAConfigType GetPaConfigType(std::string &name); + + void SplitStringToSet(std::string &str, std::set &result); + void SplitStringToList(std::string &str, std::list &result); + void SplitChannelStringToSet(std::string &str, std::set &result); + + std::string ExtractPropertyValue(const std::string &propName, xmlNode &node); + AdaptersType GetAdaptersType(const std::string &adapterClass); + + std::string GetAudioModuleInfoName(std::string &pipeInfoName, std::list &deviceInfos); void ConvertAdapterInfoToAudioModuleInfo(); - void ConvertAdapterInfoToAudioModuleInfo(std::unordered_map &volumeGroupMap, - std::unordered_map &interruptGroupMap); void ConvertAdapterInfoToGroupInfo(std::unordered_map &volumeGroupMap, - std::unordered_map &interruptGroupMap, ModuleInfo &moduleInfo); - void GetCommontAudioModuleInfo(ModuleInfo &moduleInfo, AudioModuleInfo &audioModuleInfo); + std::unordered_map &interruptGroupMap); + void GetCommontAudioModuleInfo(PipeInfo &pipeInfo, AudioModuleInfo &audioModuleInfo); ClassType GetClassTypeByAdapterType(AdaptersType adapterType); void GetOffloadAndOpenMicState(AudioAdapterInfo &adapterInfo, bool &shouldEnableOffload); - std::string ExtractPropertyValue(const std::string &propName, xmlNode &node); IPortObserver &portObserver_; xmlDoc *doc_; @@ -90,6 +101,7 @@ private: std::unordered_map> xmlParsedDataMap_ {}; std::unordered_map volumeGroupMap_; std::unordered_map interruptGroupMap_; + GlobalConfigs globalConfigs_; bool shouldOpenMicSpeaker_; }; } // namespace AudioStandard diff --git a/services/audio_policy/server/include/service/config/parser_factory.h b/services/audio_policy/server/include/service/config/parser_factory.h deleted file mode 100644 index 70134c56b3..0000000000 --- a/services/audio_policy/server/include/service/config/parser_factory.h +++ /dev/null @@ -1,44 +0,0 @@ -/* - * Copyright (c) 2021-2022 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef ST_PARSER_FACTORY_H -#define ST_PARSER_FACTORY_H - -#include "xml_parser.h" - -namespace OHOS { -namespace AudioStandard { -class ParserFactory { -public: - static ParserFactory& GetInstance() - { - static ParserFactory instance; - return instance; - } - - Parser& CreateParser(IPortObserver& observer) - { - static XMLParser parser(observer); - return parser; - } -private: - ParserFactory(ParserFactory&) = delete; - ParserFactory() {} - ~ParserFactory() {} -}; -} // namespace AudioStandard -} // namespace OHOS - -#endif // ST_PARSER_FACTORY_H diff --git a/services/audio_policy/server/include/service/config/xml_parser.h b/services/audio_policy/server/include/service/config/xml_parser.h deleted file mode 100644 index eb032e43c5..0000000000 --- a/services/audio_policy/server/include/service/config/xml_parser.h +++ /dev/null @@ -1,96 +0,0 @@ -/* - * Copyright (c) 2021-2022 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef ST_XML_PARSER_H -#define ST_XML_PARSER_H - -#include -#include -#include -#include -#include -#include - -#include "audio_module_info.h" -#include "iport_observer.h" -#include "parser.h" - -namespace OHOS { -namespace AudioStandard { -class XMLParser : public Parser { -public: - static constexpr char CONFIG_FILE[] = "vendor/etc/audio/audio_policy_config.xml"; - - bool LoadConfiguration() final; - bool Parse() final; - void Destroy() final; - - explicit XMLParser(IPortObserver &observer) - : mPortObserver(observer), - mDoc(nullptr) - { - } - - virtual ~XMLParser() - { - Destroy(); - } -private: - NodeName GetNodeNameAsInt(xmlNode &node); - bool ParseInternal(xmlNode &node); - void ParseDeviceClass(xmlNode &node); - void ParseModules(xmlNode &node, std::string &className); - void ParsePorts(xmlNode &node, AudioModuleInfo &moduleInfo); - void ParsePort(xmlNode &node, AudioModuleInfo &moduleInfo); - void ParseAudioInterrupt(xmlNode &node); - void ParseUpdateRouteSupport(xmlNode &node); - void ParseAudioLatency(xmlNode &node); - void ParseSinkLatency(xmlNode &node); - void ParseGroups(xmlNode& node, NodeName type); - void ParseGroup(xmlNode& node, NodeName type); - void ParseGroupModule(xmlNode& node, NodeName type, std::string groupName); - std::string ExtractPropertyValue(const std::string &propName, xmlNode &node); - ClassType GetDeviceClassType(const std::string &deviceClass); - - template std::set SeparatedListParser(const std::string &separatedList) - { - std::set res; - std::regex regexDelimiter(","); - const std::sregex_token_iterator itEnd; - for (std::sregex_token_iterator it(separatedList.begin(), separatedList.end(), regexDelimiter, -1); - it != itEnd; ++it) { - res.insert(atoi(it->str().c_str())); - } - return res; - } - - template void SeparatedListParserAndFetchMaxValue(const std::string &separatedList, - std::set &supportedSet, std::string &value) - { - supportedSet = SeparatedListParser(separatedList); - value = std::to_string(*(supportedSet.rbegin())); - } - - IPortObserver &mPortObserver; - xmlDoc *mDoc; - ClassType deviceClassType_; - std::unordered_map> xmlParsedDataMap_; - std::unordered_map volumeGroupMap_; - std::unordered_map interruptGroupMap_; -}; -} // namespace AudioStandard -} // namespace OHOS - -#endif // ST_XML_PARSER_H diff --git a/services/audio_policy/server/include/service/interface/iport_observer.h b/services/audio_policy/server/include/service/interface/iport_observer.h index 2a40233d46..0dc0678a6c 100644 --- a/services/audio_policy/server/include/service/interface/iport_observer.h +++ b/services/audio_policy/server/include/service/interface/iport_observer.h @@ -31,6 +31,7 @@ public: virtual void OnSinkLatencyParsed(uint32_t latency) = 0; virtual void OnVolumeGroupParsed(std::unordered_map& volumeGroupData) = 0; virtual void OnInterruptGroupParsed(std::unordered_map& interruptGroupData) = 0; + virtual void OnGlobalConfigsParsed(GlobalConfigs &globalConfig) = 0; }; } // namespace AudioStandard } // namespace OHOS diff --git a/services/audio_policy/server/src/audio_policy_server.cpp b/services/audio_policy/server/src/audio_policy_server.cpp index d5c34f191f..ebe9c5398f 100644 --- a/services/audio_policy/server/src/audio_policy_server.cpp +++ b/services/audio_policy/server/src/audio_policy_server.cpp @@ -1325,6 +1325,8 @@ void AudioPolicyServer::GetPolicyData(PolicyData &policyData) audioPolicyService_.GetAudioAdapterInfos(policyData.adapterInfoMap); audioPolicyService_.GetVolumeGroupData(policyData.volumeGroupData); audioPolicyService_.GetInterruptGroupData(policyData.interruptGroupData); + audioPolicyService_.GetDeviceClassInfo(policyData.deviceClassInfo); + audioPolicyService_.GetGlobalConfigs(policyData.globalConfigs); } void AudioPolicyServer::GetStreamVolumeInfoMap(StreamVolumeInfoMap& streamVolumeInfos) diff --git a/services/audio_policy/server/src/service/audio_policy_service.cpp b/services/audio_policy/server/src/service/audio_policy_service.cpp index 2aae1a017b..9ff1ff6480 100644 --- a/services/audio_policy/server/src/service/audio_policy_service.cpp +++ b/services/audio_policy/server/src/service/audio_policy_service.cpp @@ -49,6 +49,7 @@ using namespace std; static const std::string INNER_CAPTURER_SINK_NAME = "InnerCapturer"; static const std::string RECEIVER_SINK_NAME = "Receiver"; static const std::string SINK_NAME_FOR_CAPTURE_SUFFIX = "_CAP"; +static const std::string EARPIECE_TYPE_NAME = "DEVICE_TYPE_EARPIECE"; static const std::vector VOLUME_TYPE_LIST = { STREAM_VOICE_CALL, @@ -61,6 +62,24 @@ static const std::vector VOLUME_TYPE_LIST = { STREAM_ALL }; +std::map AudioPolicyService::formatStrToEnum = { + {"SAMPLE_U8", SAMPLE_U8}, + {"SAMPLE_S16E", SAMPLE_S16LE}, + {"SAMPLE_S24LE", SAMPLE_S24LE}, + {"SAMPLE_S32LE", SAMPLE_S32LE}, + {"SAMPLE_F32LE", SAMPLE_F32LE}, + {"INVALID_WIDTH", INVALID_WIDTH}, +}; + +std::map AudioPolicyService::classStrToEnum = { + {PRIMARY_CLASS, TYPE_PRIMARY}, + {A2DP_CLASS, TYPE_A2DP}, + {USB_CLASS, TYPE_USB}, + {FILE_CLASS, TYPE_FILE_IO}, + {REMOTE_CLASS, TYPE_REMOTE_AUDIO}, + {INVALID_CLASS, TYPE_INVALID}, +}; + static const std::string SETTINGS_DATA_BASE_URI = "datashare:///com.ohos.settingsdata/entry/settingsdata/SETTINGSDATA?Proxy=true"; static const std::string SETTINGS_DATA_EXT_URI = "datashare:///com.ohos.settingsdata.DataAbility"; @@ -71,6 +90,7 @@ const uint32_t PCM_8_BIT = 8; const uint32_t PCM_16_BIT = 16; const uint32_t PCM_24_BIT = 24; const uint32_t PCM_32_BIT = 32; +const int32_t DEFAULT_MAX_OUTPUT_NORMAL_INSTANCES = 128; const uint32_t BT_BUFFER_ADJUSTMENT_FACTOR = 50; const uint32_t ABS_VOLUME_SUPPORT_RETRY_INTERVAL_IN_MICROSECONDS = 10000; const float RENDER_FRAME_INTERVAL_IN_SECONDS = 0.02; @@ -3768,11 +3788,10 @@ void AudioPolicyService::OnAudioPolicyXmlParsingCompleted( AUDIO_INFO_LOG("adapterInfo num [%{public}zu]", adapterInfoMap.size()); CHECK_AND_RETURN_LOG(!adapterInfoMap.empty(), "failed to parse audiopolicy xml file. Received data is empty"); adapterInfoMap_ = adapterInfoMap; - MaxRenderInstanceInit(); for (auto &adapterInfo : adapterInfoMap_) { for (auto &deviceInfos : (adapterInfo.second).deviceInfos_) { - if (deviceInfos.name_ == ADAPTER_DEVICE_PRIMARY_EARPIECE) { + if (deviceInfos.type_ == EARPIECE_TYPE_NAME) { hasEarpiece_ = true; break; } @@ -3810,6 +3829,11 @@ void AudioPolicyService::OnInterruptGroupParsed(std::unordered_map &adapterInfoMap) { adapterInfoMap = adapterInfoMap_; @@ -3825,6 +3849,16 @@ void AudioPolicyService::GetInterruptGroupData(std::unordered_map> &deviceClassInfo) +{ + deviceClassInfo = deviceClassInfo_; +} + +void AudioPolicyService::GetGlobalConfigs(GlobalConfigs &globalConfigs) +{ + globalConfigs = globalConfigs_; +} + void AudioPolicyService::AddAudioPolicyClientProxyMap(int32_t clientPid, const sptr& cb) { if (audioPolicyServerHandler_ != nullptr) { @@ -4927,36 +4961,15 @@ void AudioPolicyService::SetParameterCallback(const std::shared_ptr &moduleInfoList, + SourceInfo &targetInfo) { auto [targetSourceType, targetRate, targetChannels] = targetInfo; - for (auto &adapterModuleInfo : audioAdapterInfo.moduleInfos_) { - if (moduleInfo.role == adapterModuleInfo.moduleType_ && - adapterModuleInfo.name_.find(MODULE_SINK_OFFLOAD) == std::string::npos) { - for (const auto&[rate, channels, format, bufferSize] : adapterModuleInfo.profileInfos_) { - CHECK_AND_CONTINUE_LOG(rate == std::to_string(targetRate), "audio rate unmatch."); - CHECK_AND_CONTINUE_LOG(channels == std::to_string(targetChannels), "audio channels unmatch."); - moduleInfo.rate = std::to_string(targetRate); - moduleInfo.channels = std::to_string(targetChannels); - moduleInfo.bufferSize = bufferSize; - AUDIO_INFO_LOG("match success. rate:%{public}s, channels:%{public}s, bufferSize:%{public}s", - moduleInfo.rate.c_str(), moduleInfo.channels.c_str(), moduleInfo.bufferSize.c_str()); - } + for (auto &adapterModuleInfo : moduleInfoList) { + if (moduleInfo.role == adapterModuleInfo.role && + adapterModuleInfo.name.find(MODULE_SINK_OFFLOAD) == std::string::npos) { + CHECK_AND_CONTINUE_LOG(adapterModuleInfo.rate == std::to_string(targetRate), "rate unmatch."); + CHECK_AND_CONTINUE_LOG(adapterModuleInfo.channels == std::to_string(targetChannels), "channels unmatch."); + moduleInfo.rate = std::to_string(targetRate); + moduleInfo.channels = std::to_string(targetChannels); + moduleInfo.bufferSize = adapterModuleInfo.bufferSize; + AUDIO_INFO_LOG("match success. rate:%{public}s, channels:%{public}s, bufferSize:%{public}s", + moduleInfo.rate.c_str(), moduleInfo.channels.c_str(), moduleInfo.bufferSize.c_str()); } } moduleInfo.sourceType = std::to_string(targetSourceType); diff --git a/services/audio_policy/server/src/service/config/audio_policy_parser.cpp b/services/audio_policy/server/src/service/config/audio_policy_parser.cpp index 85e1fffbf1..51d89beda0 100644 --- a/services/audio_policy/server/src/service/config/audio_policy_parser.cpp +++ b/services/audio_policy/server/src/service/config/audio_policy_parser.cpp @@ -19,10 +19,32 @@ #include "audio_policy_parser.h" #include +#include +#include #include "audio_log.h" namespace OHOS { namespace AudioStandard { +constexpr int32_t AUDIO_MS_PER_S = 1000; +constexpr uint32_t LAYOUT_STEREO_CHANNEL_ENUM = 2; +constexpr uint32_t LAYOUT_5POINT1_CHANNEL_ENUM = 6; +constexpr uint32_t LAYOUT_7POINT1_CHANNEL_ENUM = 8; +constexpr uint32_t S16LE_TO_BYTE = 2; +constexpr uint32_t S24LE_TO_BYTE = 3; +constexpr uint32_t S32LE_TO_BYTE = 4; + +static std::map layoutStrToChannels = { + {"CH_LAYOUT_STEREO", LAYOUT_STEREO_CHANNEL_ENUM}, + {"CH_LAYOUT_5POINT1", LAYOUT_5POINT1_CHANNEL_ENUM}, + {"CH_LAYOUT_7POINT1", LAYOUT_7POINT1_CHANNEL_ENUM}, +}; + +static std::map formatStrToEnum = { + {"s16le", S16LE_TO_BYTE}, + {"s24le", S24LE_TO_BYTE}, + {"s32le", S32LE_TO_BYTE}, +}; + bool AudioPolicyParser::LoadConfiguration() { doc_ = xmlReadFile(CHIP_PROD_CONFIG_FILE, nullptr, 0); @@ -51,7 +73,8 @@ bool AudioPolicyParser::Parse() std::unordered_map volumeGroupMap {}; std::unordered_map interruptGroupMap {}; - ConvertAdapterInfoToAudioModuleInfo(volumeGroupMap, interruptGroupMap); + ConvertAdapterInfoToGroupInfo(volumeGroupMap, interruptGroupMap); + ConvertAdapterInfoToAudioModuleInfo(); volumeGroupMap_ = volumeGroupMap; interruptGroupMap_ = interruptGroupMap; @@ -60,6 +83,7 @@ bool AudioPolicyParser::Parse() portObserver_.OnXmlParsingCompleted(xmlParsedDataMap_); portObserver_.OnVolumeGroupParsed(volumeGroupMap_); portObserver_.OnInterruptGroupParsed(interruptGroupMap_); + portObserver_.OnGlobalConfigsParsed(globalConfigs_); return true; } @@ -75,7 +99,7 @@ bool AudioPolicyParser::ParseInternal(xmlNode &node) xmlNode *currNode = &node; for (; currNode; currNode = currNode->next) { if (XML_ELEMENT_NODE == currNode->type) { - switch (GetNodeTypeAsInt(*currNode)) { + switch (GetXmlNodeTypeAsInt(*currNode)) { case XmlNodeType::ADAPTERS: ParseAdapters(*currNode); break; @@ -85,8 +109,8 @@ bool AudioPolicyParser::ParseInternal(xmlNode &node) case XmlNodeType::INTERRUPT_GROUPS: ParseGroups(*currNode, XmlNodeType::INTERRUPT_GROUPS); break; - case XmlNodeType::EXTENDS: - ParseExtends(*currNode); + case XmlNodeType::GLOBAL_CONFIGS: + ParseGlobalConfigs(*currNode); break; default: ParseInternal(*(currNode->children)); @@ -97,64 +121,59 @@ bool AudioPolicyParser::ParseInternal(xmlNode &node) return true; } +void AudioPolicyParser::ParseAdapters(xmlNode &node) +{ + xmlNode *currNode = nullptr; + currNode = node.xmlChildrenNode; + + while (currNode != nullptr) { + if (currNode->type == XML_ELEMENT_NODE) { + ParseAdapter(*currNode); + } + currNode = currNode->next; + } +} + void AudioPolicyParser::ConvertAdapterInfoToGroupInfo(std::unordered_map &volumeGroupMap, - std::unordered_map &interruptGroupMap, ModuleInfo &moduleInfo) + std::unordered_map &interruptGroupMap) { for (auto &[sinkName, groupName] : volumeGroupMap_) { - if (sinkName == moduleInfo.name_) { - volumeGroupMap[moduleInfo.devices_.front()] = groupName; - } + volumeGroupMap["Speaker"] = groupName; } for (auto &[sinkName, groupName] : interruptGroupMap_) { - if (sinkName == moduleInfo.name_) { - interruptGroupMap[moduleInfo.devices_.front()] = groupName; - } + interruptGroupMap["Speaker"] = groupName; } } -void AudioPolicyParser::GetCommontAudioModuleInfo(ModuleInfo &moduleInfo, AudioModuleInfo &audioModuleInfo) +void AudioPolicyParser::GetCommontAudioModuleInfo(PipeInfo &pipeInfo, AudioModuleInfo &audioModuleInfo) { - for (auto profileInfo : moduleInfo.profileInfos_) { - audioModuleInfo.supportedRate_.insert(atoi(profileInfo.rate_.c_str())); - audioModuleInfo.supportedChannels_.insert(atoi(profileInfo.channels_.c_str())); + audioModuleInfo.role = pipeInfo.paPropRole_; + + for (auto sampleRate : pipeInfo.sampleRates_) { + audioModuleInfo.supportedRate_.insert(sampleRate); } - audioModuleInfo.role = moduleInfo.moduleType_; - audioModuleInfo.name = moduleInfo.devices_.front(); + for (auto channelLayout : pipeInfo.channelLayouts_) { + audioModuleInfo.supportedChannels_.insert(channelLayout); + } + + audioModuleInfo.lib = pipeInfo.lib_; - if (audioModuleInfo.name == ADAPTER_DEVICE_PRIMARY_MIC) { - audioModuleInfo.name = PRIMARY_MIC; - } else if (audioModuleInfo.name == ADAPTER_DEVICE_A2DP_BT_A2DP) { - audioModuleInfo.name = BLUETOOTH_SPEAKER; - } else if (audioModuleInfo.name == ADAPTER_DEVICE_USB_SPEAKER || - (audioModuleInfo.role == MODULE_TYPE_SINK && audioModuleInfo.name == ADAPTER_DEVICE_USB_HEADSET_ARM)) { - audioModuleInfo.name = USB_SPEAKER; - } else if (audioModuleInfo.name == ADAPTER_DEVICE_USB_MIC || - (audioModuleInfo.role == MODULE_TYPE_SOURCE && audioModuleInfo.name == ADAPTER_DEVICE_USB_HEADSET_ARM)) { - audioModuleInfo.name = USB_MIC; - } else if (audioModuleInfo.name == ADAPTER_DEVICE_FILE_SINK) { - audioModuleInfo.name = FILE_SINK; - } else if (audioModuleInfo.name == ADAPTER_DEVICE_FILE_SOURCE) { - audioModuleInfo.name = FILE_SOURCE; - } else if (audioModuleInfo.name == ADAPTER_DEVICE_PIPE_SINK) { - audioModuleInfo.name = PIPE_SINK; - } else if (audioModuleInfo.name == ADAPTER_DEVICE_PIPE_SOURCE) { - audioModuleInfo.name = PIPE_SOURCE; - } else if (audioModuleInfo.name == ADAPTER_DEVICE_DP) { - audioModuleInfo.name = DP_SINK; + if (pipeInfo.streamPropInfos_.size() != 0) { + audioModuleInfo.rate = std::to_string((*pipeInfo.streamPropInfos_.begin()).sampleRate_); + audioModuleInfo.format = (*pipeInfo.streamPropInfos_.begin()).format_; + audioModuleInfo.channels = std::to_string((*pipeInfo.streamPropInfos_.begin()).channelLayout_); + audioModuleInfo.bufferSize = std::to_string((*pipeInfo.streamPropInfos_.begin()).bufferSize_); } - audioModuleInfo.lib = moduleInfo.lib_; - if (moduleInfo.profileInfos_.begin() != moduleInfo.profileInfos_.end()) { - audioModuleInfo.rate = moduleInfo.profileInfos_.begin()->rate_; - audioModuleInfo.format = moduleInfo.profileInfos_.begin()->format_; - audioModuleInfo.channels = moduleInfo.profileInfos_.begin()->channels_; - audioModuleInfo.bufferSize = moduleInfo.profileInfos_.begin()->bufferSize_; + for (auto &config : pipeInfo.configInfos_) { + if (config.name_ == "filePath") { + audioModuleInfo.fileName = config.value_; + } } - audioModuleInfo.fileName = moduleInfo.file_; - audioModuleInfo.fixedLatency = moduleInfo.fixedLatency_; - audioModuleInfo.renderInIdleState = moduleInfo.renderInIdleState_; + audioModuleInfo.fixedLatency = pipeInfo.fixedLatency_; + audioModuleInfo.renderInIdleState = pipeInfo.renderInIdleState_; } ClassType AudioPolicyParser::GetClassTypeByAdapterType(AdaptersType adapterType) @@ -163,9 +182,9 @@ ClassType AudioPolicyParser::GetClassTypeByAdapterType(AdaptersType adapterType) return ClassType::TYPE_PRIMARY; } else if (adapterType == AdaptersType::TYPE_A2DP) { return ClassType::TYPE_A2DP; - } else if (adapterType == AdaptersType::TYPE_REMOTE) { + } else if (adapterType == AdaptersType::TYPE_REMOTE_AUDIO) { return ClassType::TYPE_REMOTE_AUDIO; - } else if (adapterType == AdaptersType::TYPE_FILE) { + } else if (adapterType == AdaptersType::TYPE_FILE_IO) { return ClassType::TYPE_FILE_IO; } else if (adapterType == AdaptersType::TYPE_USB) { return ClassType::TYPE_USB; @@ -179,17 +198,27 @@ ClassType AudioPolicyParser::GetClassTypeByAdapterType(AdaptersType adapterType) void AudioPolicyParser::GetOffloadAndOpenMicState(AudioAdapterInfo &adapterInfo, bool &shouldEnableOffload) { - for (auto &moduleInfo : adapterInfo.moduleInfos_) { - if (moduleInfo.moduleType_ == MODULE_TYPE_SINK && - moduleInfo.name_.find(MODULE_SINK_OFFLOAD) != std::string::npos) { + for (auto &pipeInfo : adapterInfo.pipeInfos_) { + if (pipeInfo.paPropRole_ == MODULE_TYPE_SINK && + pipeInfo.name_.find(MODULE_SINK_OFFLOAD) != std::string::npos) { shouldEnableOffload = true; } } } -void AudioPolicyParser::ConvertAdapterInfoToAudioModuleInfo( - std::unordered_map &volumeGroupMap, - std::unordered_map &interruptGroupMap) +std::string AudioPolicyParser::GetAudioModuleInfoName(std::string &pipeInfoName, + std::list &deviceInfos) +{ + for (auto &deviceInfo : deviceInfos) { + if (std::find(deviceInfo.supportPipes_.begin(), deviceInfo.supportPipes_.end(), pipeInfoName) != + deviceInfo.supportPipes_.end()) { + return deviceInfo.name_; + } + } + return ""; +} + +void AudioPolicyParser::ConvertAdapterInfoToAudioModuleInfo() { for (auto &[adapterType, adapterInfo] : adapterInfoMap_) { std::list audioModuleList = {}; @@ -198,24 +227,36 @@ void AudioPolicyParser::ConvertAdapterInfoToAudioModuleInfo( GetOffloadAndOpenMicState(adapterInfo, shouldEnableOffload); } - for (auto &moduleInfo : adapterInfo.moduleInfos_) { - ConvertAdapterInfoToGroupInfo(volumeGroupMap, interruptGroupMap, moduleInfo); - CHECK_AND_CONTINUE_LOG(moduleInfo.name_.find(MODULE_SINK_OFFLOAD) == std::string::npos, + std::string currentRole = ""; + for (auto &pipeInfo : adapterInfo.pipeInfos_) { + if (currentRole == pipeInfo.pipeRole_) { + continue; + } + currentRole = pipeInfo.pipeRole_; + CHECK_AND_CONTINUE_LOG(pipeInfo.name_.find(MODULE_SINK_OFFLOAD) == std::string::npos, "skip offload out sink."); AudioModuleInfo audioModuleInfo = {}; - GetCommontAudioModuleInfo(moduleInfo, audioModuleInfo); + GetCommontAudioModuleInfo(pipeInfo, audioModuleInfo); audioModuleInfo.className = adapterInfo.adapterName_; + // The logic here strongly depends on the moduleName in the XML + if (pipeInfo.moduleName_ != "") { + audioModuleInfo.name = pipeInfo.moduleName_; + } else { + audioModuleInfo.name = GetAudioModuleInfoName(pipeInfo.name_, adapterInfo.deviceInfos_); + } + audioModuleInfo.adapterName = adapterInfo.adapterName_; - if (adapterType == AdaptersType::TYPE_FILE) { + if (adapterType == AdaptersType::TYPE_FILE_IO) { audioModuleInfo.adapterName = STR_INIT; audioModuleInfo.format = STR_INIT; audioModuleInfo.className = FILE_CLASS; } + audioModuleInfo.sinkLatency = globalConfigs_.globalPaConfigs_.sinkLatency_; shouldOpenMicSpeaker_ ? audioModuleInfo.OpenMicSpeaker = "1" : audioModuleInfo.OpenMicSpeaker = "0"; if (adapterType == AdaptersType::TYPE_PRIMARY && - shouldEnableOffload && moduleInfo.moduleType_ == MODULE_TYPE_SINK) { + shouldEnableOffload && pipeInfo.paPropRole_ == MODULE_TYPE_SINK) { audioModuleInfo.offloadEnable = "1"; } audioModuleList.push_back(audioModuleInfo); @@ -231,19 +272,6 @@ void AudioPolicyParser::ConvertAdapterInfoToAudioModuleInfo( } } -void AudioPolicyParser::ParseAdapters(xmlNode &node) -{ - xmlNode *adapterNode = nullptr; - adapterNode = node.xmlChildrenNode; - - while (adapterNode != nullptr) { - if (adapterNode->type == XML_ELEMENT_NODE) { - ParseAdapter(*adapterNode); - } - adapterNode = adapterNode->next; - } -} - void AudioPolicyParser::ParseAdapter(xmlNode &node) { std::string adapterName = ExtractPropertyValue("name", node); @@ -255,114 +283,162 @@ void AudioPolicyParser::ParseAdapter(xmlNode &node) AdaptersType adaptersType = GetAdaptersType(adapterName); adapterInfoMap_[adaptersType] = {}; - xmlNode *currNode = node.xmlChildrenNode; AudioAdapterInfo adapterInfo = {}; adapterInfo.adapterName_ = adapterName; - for (; currNode; currNode = currNode->next) { - if (XML_ELEMENT_NODE == currNode->type) { + adapterInfo.adaptersupportScene_ = ExtractPropertyValue("supportScene", node); + + xmlNode *currNode = node.xmlChildrenNode; + while (currNode != nullptr) { + if (currNode->type == XML_ELEMENT_NODE) { switch (GetAdapterTypeAsInt(*currNode)) { - case AdapterType::DEVICES: - ParseAudioAdapterDevices(*currNode, adapterInfo); + case AdapterType::PIPES: + ParsePipes(*currNode, adapterInfo); break; - case AdapterType::MODULES: - ParseModules(*currNode, adapterInfo); + case AdapterType::DEVICES: + ParseDevices(*currNode, adapterInfo); break; default: ParseAdapter(*(currNode->children)); break; } } + currNode = currNode->next; } adapterInfoMap_[adaptersType] = adapterInfo; } -void AudioPolicyParser::ParseAudioAdapterDevices(xmlNode &node, AudioAdapterInfo &adapterInfo) +void AudioPolicyParser::ParsePipes(xmlNode &node, AudioAdapterInfo &adapterInfo) { - xmlNode *deviceNode = nullptr; - deviceNode = node.xmlChildrenNode; - std::list deviceInfos; + xmlNode *currNode = node.xmlChildrenNode; + std::list pipeInfos; - while (deviceNode != nullptr) { - if (deviceNode->type == XML_ELEMENT_NODE) { - AudioAdapterDeviceInfo deviceInfo {}; - deviceInfo.name_ = ExtractPropertyValue("name", *deviceNode); - deviceInfo.type_ = ExtractPropertyValue("type", *deviceNode); - deviceInfo.role_ = ExtractPropertyValue("role", *deviceNode); - deviceInfos.push_back(deviceInfo); + while (currNode != nullptr) { + if (currNode->type == XML_ELEMENT_NODE) { + PipeInfo pipeInfo {}; + pipeInfo.name_ = ExtractPropertyValue("name", *currNode); + pipeInfo.pipeRole_ = ExtractPropertyValue("role", *currNode); + pipeInfo.pipeFlags_ = ExtractPropertyValue("flags", *currNode); + ParsePipeInfos(*currNode, pipeInfo); + pipeInfos.push_back(pipeInfo); } - deviceNode = deviceNode->next; + currNode = currNode->next; } - adapterInfo.deviceInfos_ = deviceInfos; + adapterInfo.pipeInfos_ = pipeInfos; } -void AudioPolicyParser::ParseModules(xmlNode &node, AudioAdapterInfo &adapterInfo) +void AudioPolicyParser::SplitStringToSet(std::string &str, std::set &result) { - xmlNode *moduleNode = nullptr; - moduleNode = node.xmlChildrenNode; - - std::list moduleInfos; + std::stringstream ss(str); + std::string token; - for (; moduleNode; moduleNode = moduleNode->next) { - if (XML_ELEMENT_NODE == moduleNode->type) { - ModuleInfo moduleInfo {}; - ParseModuleProperty(*moduleNode, moduleInfo, adapterInfo.adapterName_); - ParseModule(*moduleNode, moduleInfo); - moduleInfos.push_back(moduleInfo); - } + while (std::getline(ss, token, ',')) { + uint32_t num = std::stoi(token); + result.insert(num); } - - adapterInfo.moduleInfos_ = moduleInfos; } -void AudioPolicyParser::ParseModuleProperty(xmlNode &node, ModuleInfo &moduleInfo, std::string adapterName) +void AudioPolicyParser::SplitChannelStringToSet(std::string &str, std::set &result) { - moduleInfo.moduleType_ = reinterpret_cast(node.name); - if (moduleInfo.moduleType_ == MODULE_TYPE_SINK) { - moduleInfo.lib_ = MODULE_SINK_LIB; - if (adapterName == ADAPTER_FILE_TYPE) { - moduleInfo.file_ = MODULE_FILE_SINK_FILE; - } - } - if (moduleInfo.moduleType_ == MODULE_TYPE_SOURCE) { - moduleInfo.lib_ = MODULE_SOURCE_LIB; - if (adapterName == ADAPTER_FILE_TYPE) { - moduleInfo.file_ = MODULE_FILE_SOURCE_FILE; - } - } + std::stringstream ss(str); + std::string token; - moduleInfo.name_ = ExtractPropertyValue("name", node); - moduleInfo.role_ = ExtractPropertyValue("role", node); - moduleInfo.fixedLatency_ = ExtractPropertyValue("fixed_latency", node); - moduleInfo.renderInIdleState_ = ExtractPropertyValue("render_in_idle_state", node); - moduleInfo.profile_ = ExtractPropertyValue("profile", node); + while (std::getline(ss, token, ',')) { + result.insert(layoutStrToChannels[token]); + } } -void AudioPolicyParser::ParseModule(xmlNode &node, ModuleInfo &moduleInfo) +void AudioPolicyParser::ParsePipeInfos(xmlNode &node, PipeInfo &pipeInfo) { - xmlNode *currNode = nullptr; - currNode = node.xmlChildrenNode; - - for (; currNode; currNode = currNode->next) { + xmlNode *currNode = node.xmlChildrenNode; + while (currNode != nullptr) { if (currNode->type == XML_ELEMENT_NODE) { - switch (GetModuleTypeAsInt(*currNode)) { - case ModuleType::CONFIGS: - ParseConfigs(*currNode, moduleInfo); + switch (GetPipeInfoTypeAsInt(*currNode)) { + case PipeType::PA_PROP: + pipeInfo.lib_ = ExtractPropertyValue("lib", *currNode); + pipeInfo.paPropRole_ = ExtractPropertyValue("role", *currNode); + pipeInfo.fixedLatency_ = ExtractPropertyValue("fixed_latency", *currNode); + pipeInfo.renderInIdleState_ = ExtractPropertyValue("render_in_idle_state", *currNode); + pipeInfo.moduleName_ = ExtractPropertyValue("moduleName", *currNode); break; - case ModuleType::PROFILES: - ParseProfiles(*currNode, moduleInfo); + case PipeType::STREAM_PROP: + ParseStreamProps(*currNode, pipeInfo); break; - case ModuleType::DEVICES: - ParseModuleDevices(*currNode, moduleInfo); + case PipeType::CONFIGS: + ParseConfigs(*currNode, pipeInfo); break; default: - ParseModule(*(currNode->children), moduleInfo); + ParsePipeInfos(*(currNode->children), pipeInfo); break; } } + currNode = currNode->next; + } +} + +AdapterType AudioPolicyParser::GetAdapterTypeAsInt(xmlNode &node) +{ + if (!xmlStrcmp(node.name, reinterpret_cast("pipes"))) { + return AdapterType::PIPES; + } else if (!xmlStrcmp(node.name, reinterpret_cast("devices"))) { + return AdapterType::DEVICES; + } else { + return AdapterType::UNKNOWN; + } +} + +PipeType AudioPolicyParser::GetPipeInfoTypeAsInt(xmlNode &node) +{ + if (!xmlStrcmp(node.name, reinterpret_cast("paProp"))) { + return PipeType::PA_PROP; + } else if (!xmlStrcmp(node.name, reinterpret_cast("streamProps"))) { + return PipeType::STREAM_PROP; + } else if (!xmlStrcmp(node.name, reinterpret_cast("attributes"))) { + return PipeType::CONFIGS; + } else { + return PipeType::UNKNOWN; + } +} + +void AudioPolicyParser::ParseStreamProps(xmlNode &node, PipeInfo &pipeInfo) +{ + xmlNode *currNode = node.xmlChildrenNode; + std::list streamPropInfos; + + while (currNode != nullptr) { + if (currNode->type == XML_ELEMENT_NODE) { + StreamPropInfo streamPropInfo = {}; + streamPropInfo.format_ = ExtractPropertyValue("format", *currNode); + std::string sampleRateStr = ExtractPropertyValue("sampleRates", *currNode); + if (sampleRateStr != "") { + streamPropInfo.sampleRate_ = (uint32_t)std::stoi(sampleRateStr); + pipeInfo.sampleRates_.push_back(streamPropInfo.sampleRate_); + } + std::string periodInMsStr = ExtractPropertyValue("periodInMs", *currNode); + if (periodInMsStr != "") { + streamPropInfo.periodInMs_ = (uint32_t)std::stoi(periodInMsStr); + } + std::string channelLayoutStr = ExtractPropertyValue("channelLayout", *currNode); + if (channelLayoutStr != "") { + streamPropInfo.channelLayout_ = layoutStrToChannels[channelLayoutStr]; + pipeInfo.channelLayouts_.push_back(streamPropInfo.channelLayout_); + } + + std::string bufferSizeStr = ExtractPropertyValue("bufferSize", *currNode); + if (bufferSizeStr != "") { + streamPropInfo.bufferSize_ = (uint32_t)std::stoi(bufferSizeStr); + } else { + streamPropInfo.bufferSize_ = formatStrToEnum[streamPropInfo.format_] * streamPropInfo.sampleRate_ * + streamPropInfo.periodInMs_ * streamPropInfo.channelLayout_ / AUDIO_MS_PER_S; + } + + streamPropInfos.push_back(streamPropInfo); + } + currNode = currNode->next; } + pipeInfo.streamPropInfos_ = streamPropInfos; } -void AudioPolicyParser::ParseConfigs(xmlNode &node, ModuleInfo &moduleInfo) +void AudioPolicyParser::ParseConfigs(xmlNode &node, PipeInfo &pipeInfo) { xmlNode *configNode = nullptr; configNode = node.xmlChildrenNode; @@ -372,136 +448,257 @@ void AudioPolicyParser::ParseConfigs(xmlNode &node, ModuleInfo &moduleInfo) if (configNode->type == XML_ELEMENT_NODE) { ConfigInfo configInfo = {}; configInfo.name_ = ExtractPropertyValue("name", *configNode); - configInfo.valu_ = ExtractPropertyValue("valu", *configNode); + configInfo.value_ = ExtractPropertyValue("value", *configNode); configInfos.push_back(configInfo); } configNode = configNode->next; } - moduleInfo.configInfos_ = configInfos; + pipeInfo.configInfos_ = configInfos; } -void AudioPolicyParser::ParseProfiles(xmlNode &node, ModuleInfo &moduleInfo) +void AudioPolicyParser::ParseDevices(xmlNode &node, AudioAdapterInfo &adapterInfo) { - xmlNode *profileNode = nullptr; - profileNode = node.xmlChildrenNode; - std::list profileInfoList = {}; - - while (profileNode != nullptr) { - if (profileNode->type == XML_ELEMENT_NODE) { - ProfileInfo profileInfo = {}; - profileInfo.rate_ = ExtractPropertyValue("rate", *profileNode); - profileInfo.channels_ = ExtractPropertyValue("channels", *profileNode); - profileInfo.format_ = ExtractPropertyValue("format", *profileNode); - profileInfo.bufferSize_ = ExtractPropertyValue("buffer_size", *profileNode); + xmlNode *currNode = nullptr; + currNode = node.xmlChildrenNode; + std::list deviceInfos = {}; - profileInfoList.push_back(profileInfo); + while (currNode != nullptr) { + if (currNode->type == XML_ELEMENT_NODE) { + AudioPipeDeviceInfo deviceInfo = {}; + deviceInfo.name_ = ExtractPropertyValue("name", *currNode); + deviceInfo.type_ = ExtractPropertyValue("type", *currNode); + deviceInfo.pin_ = ExtractPropertyValue("pin", *currNode); + deviceInfo.role_ = ExtractPropertyValue("role", *currNode); + std::string supportPipeInStr = ExtractPropertyValue("supportPipes", *currNode); + SplitStringToList(supportPipeInStr, deviceInfo.supportPipes_); + deviceInfos.push_back(deviceInfo); } - profileNode = profileNode->next; + currNode = currNode->next; } - moduleInfo.profileInfos_ = profileInfoList; + adapterInfo.deviceInfos_ = deviceInfos; } -void AudioPolicyParser::ParseModuleDevices(xmlNode &node, ModuleInfo &moduleInfo) +void AudioPolicyParser::SplitStringToList(std::string &str, std::list &result) { - xmlNode *deviceNode = nullptr; - deviceNode = node.xmlChildrenNode; - - std::list devices {}; - - while (deviceNode != nullptr) { - if (deviceNode->type == XML_ELEMENT_NODE) { - std::string device = ExtractPropertyValue("name", *deviceNode); - devices.push_back(device); - } - deviceNode = deviceNode->next; + char *token = std::strtok(&str[0], ","); + while (token != nullptr) { + result.push_back(token); + token = std::strtok(nullptr, ","); } - moduleInfo.devices_ = devices; } -void AudioPolicyParser::ParseGroups(xmlNode& node, XmlNodeType type) +void AudioPolicyParser::ParseGroups(xmlNode &node, XmlNodeType type) { - xmlNode* groupsNode = nullptr; - groupsNode = node.xmlChildrenNode; - while (groupsNode != nullptr) { - if (groupsNode->type == XML_ELEMENT_NODE) { - ParseGroup(*groupsNode, type); + xmlNode *currNode = nullptr; + currNode = node.xmlChildrenNode; + + while (currNode != nullptr) { + if (currNode->type == XML_ELEMENT_NODE) { + ParseGroup(*currNode, type); } - groupsNode = groupsNode->next; + currNode = currNode->next; } } -void AudioPolicyParser::ParseGroup(xmlNode& node, XmlNodeType type) +void AudioPolicyParser::ParseGroup(xmlNode &node, XmlNodeType type) { - xmlNode* groupNode = nullptr; - groupNode = node.xmlChildrenNode; + xmlNode *currNode = nullptr; + currNode = node.xmlChildrenNode; - while (groupNode != nullptr) { - if (groupNode->type == XML_ELEMENT_NODE) { - std::string groupName = ExtractPropertyValue("name", *groupNode); - ParseGroupSink(*groupNode, type, groupName); + while (currNode != nullptr) { + if (currNode->type == XML_ELEMENT_NODE) { + std::string groupName = ExtractPropertyValue("name", *currNode); + ParseGroupSink(*currNode, type, groupName); } - groupNode = groupNode->next; + currNode = currNode->next; } } -void AudioPolicyParser::ParseGroupSink(xmlNode& node, XmlNodeType type, std::string groupName) +void AudioPolicyParser::ParseGroupSink(xmlNode &node, XmlNodeType type, std::string &groupName) { - xmlNode* sinkNode = nullptr; - sinkNode = node.xmlChildrenNode; - while (sinkNode != nullptr) { - if (sinkNode->type == XML_ELEMENT_NODE) { - std::string sinkName = ExtractPropertyValue("name", *sinkNode); + xmlNode *currNode = nullptr; + currNode = node.xmlChildrenNode; + + while (currNode != nullptr) { + if (currNode->type == XML_ELEMENT_NODE) { + std::string sinkName = ExtractPropertyValue("name", *currNode); if (type == XmlNodeType::VOLUME_GROUPS) { volumeGroupMap_[sinkName] = groupName; } else if (type == XmlNodeType::INTERRUPT_GROUPS) { interruptGroupMap_[sinkName] = groupName; } } - sinkNode = sinkNode->next; + currNode = currNode->next; } } -void AudioPolicyParser::ParseExtends(xmlNode& node) +void AudioPolicyParser::ParseGlobalConfigs(xmlNode &node) { xmlNode *currNode = node.xmlChildrenNode; - for (; currNode; currNode = currNode->next) { - if (XML_ELEMENT_NODE == currNode->type) { + while (currNode != nullptr) { + if (currNode->type == XML_ELEMENT_NODE) { + switch (GetGlobalConfigTypeAsInt(*currNode)) { + case GlobalConfigType::DEFAULT_OUTPUT: + globalConfigs_.adapter_ = ExtractPropertyValue("adapter", *currNode); + globalConfigs_.pipe_ = ExtractPropertyValue("pipe", *currNode); + globalConfigs_.device_ = ExtractPropertyValue("device", *currNode); + break; + case GlobalConfigType::COMMON_CONFIGS: + ParseCommonConfigs(*currNode); + break; + case GlobalConfigType::PA_CONFIGS: + ParsePAConfigs(*currNode); + break; + case GlobalConfigType::DEFAULT_MAX_CON_CURRENT_INSTANCE: + ParseDefaultMaxInstances(*currNode); + break; + default: + ParseGlobalConfigs(*(currNode->children)); + break; + } + } + currNode = currNode->next; + } +} + +GlobalConfigType AudioPolicyParser::GetGlobalConfigTypeAsInt(xmlNode &node) +{ + if (!xmlStrcmp(node.name, reinterpret_cast("defaultOutput"))) { + return GlobalConfigType::DEFAULT_OUTPUT; + } else if (!xmlStrcmp(node.name, reinterpret_cast("commonConfigs"))) { + return GlobalConfigType::COMMON_CONFIGS; + } else if (!xmlStrcmp(node.name, reinterpret_cast("paConfigs"))) { + return GlobalConfigType::PA_CONFIGS; + } else if (!xmlStrcmp(node.name, reinterpret_cast("maxConcurrentInstances"))) { + return GlobalConfigType::DEFAULT_MAX_CON_CURRENT_INSTANCE; + } else { + return GlobalConfigType::UNKNOWN; + } +} + +void AudioPolicyParser::ParsePAConfigs(xmlNode &node) +{ + xmlNode *currNode = nullptr; + currNode = node.xmlChildrenNode; + + while (currNode != nullptr) { + if (currNode->type == XML_ELEMENT_NODE) { + std::string name = ExtractPropertyValue("name", *currNode); + std::string value = ExtractPropertyValue("value", *currNode); + + switch (GetPaConfigType(name)) { + case PAConfigType::AUDIO_LATENCY: + portObserver_.OnAudioLatencyParsed((uint64_t)std::stoi(value)); + globalConfigs_.globalPaConfigs_.audioLatency_ = value; + break; + case PAConfigType::SINK_LATENCY: + portObserver_.OnSinkLatencyParsed((uint64_t)std::stoi(value)); + globalConfigs_.globalPaConfigs_.sinkLatency_ = value; + break; + default: + ParsePAConfigs(*(currNode->children)); + break; + } + } + currNode = currNode->next; + } +} + +void AudioPolicyParser::ParseDefaultMaxInstances(xmlNode &node) +{ + xmlNode *currNode = node.xmlChildrenNode; + while (currNode != nullptr) { + if (currNode->type == XML_ELEMENT_NODE) { xmlChar *extendInfo = xmlNodeGetContent(currNode); std::string sExtendInfo(reinterpret_cast(extendInfo)); - switch (GetExtendTypeAsInt(*currNode)) { - case ExtendType::UPDATE_ROUTE_SUPPORT: - ParseUpdateRouteSupport(*currNode); - break; - case ExtendType::AUDIO_LATENCY: - portObserver_.OnAudioLatencyParsed((uint64_t)std::stoi(sExtendInfo)); + switch (GetDefaultMaxInstanceTypeAsInt(*currNode)) { + case DefaultMaxInstanceType::OUTPUT: + ParseOutputMaxInstances(*currNode); break; - case ExtendType::SINK_LATENCY: - portObserver_.OnSinkLatencyParsed((uint64_t)std::stoi(sExtendInfo)); + case DefaultMaxInstanceType::INPUT: + ParseInputMaxInstances(*currNode); break; default: - ParseExtends(*(currNode->children)); + ParseDefaultMaxInstances(*(currNode->children)); break; } } + currNode = currNode->next; + } +} + +void AudioPolicyParser::ParseOutputMaxInstances(xmlNode &node) +{ + xmlNode *currNode = nullptr; + currNode = node.xmlChildrenNode; + std::list configInfos; + + while (currNode != nullptr) { + if (currNode->type == XML_ELEMENT_NODE) { + ConfigInfo configInfo = {}; + configInfo.name_ = ExtractPropertyValue("name", *currNode); + configInfo.type_ = ExtractPropertyValue("flag", *currNode); + configInfo.value_ = ExtractPropertyValue("value", *currNode); + configInfos.push_back(configInfo); + } + currNode = currNode->next; + } + globalConfigs_.outputConfigInfos_ = configInfos; +} + +void AudioPolicyParser::ParseInputMaxInstances(xmlNode &node) +{ + xmlNode *currNode = nullptr; + currNode = node.xmlChildrenNode; + std::list configInfos; + + while (currNode != nullptr) { + if (currNode->type == XML_ELEMENT_NODE) { + ConfigInfo configInfo = {}; + configInfo.name_ = ExtractPropertyValue("name", *currNode); + configInfo.type_ = ExtractPropertyValue("flag", *currNode); + configInfo.value_ = ExtractPropertyValue("value", *currNode); + configInfos.push_back(configInfo); + } + currNode = currNode->next; } + globalConfigs_.inputConfigInfos_ = configInfos; } -void AudioPolicyParser::ParseUpdateRouteSupport(xmlNode &node) +void AudioPolicyParser::ParseCommonConfigs(xmlNode &node) { - xmlNode *child = node.children; - xmlChar *supportFlag = xmlNodeGetContent(child); + xmlNode *currNode = nullptr; + currNode = node.xmlChildrenNode; + std::list configInfos; - if (!xmlStrcmp(supportFlag, reinterpret_cast("true"))) { + while (currNode != nullptr) { + if (currNode->type == XML_ELEMENT_NODE) { + ConfigInfo configInfo = {}; + configInfo.name_ = ExtractPropertyValue("name", *currNode); + configInfo.value_ = ExtractPropertyValue("value", *currNode); + configInfos.push_back(configInfo); + if (configInfo.name_ == "updateRouteSupport") { + AUDIO_INFO_LOG("update route support: %{public}s", configInfo.value_.c_str()); + HandleUpdateRouteSupportParsed(configInfo.value_); + } + } + currNode = currNode->next; + } + globalConfigs_.commonConfigs_ = configInfos; +} + +void AudioPolicyParser::HandleUpdateRouteSupportParsed(std::string &value) +{ + if (value == "true") { portObserver_.OnUpdateRouteSupport(true); shouldOpenMicSpeaker_ = true; } else { portObserver_.OnUpdateRouteSupport(false); shouldOpenMicSpeaker_ = false; } - xmlFree(supportFlag); } -XmlNodeType AudioPolicyParser::GetNodeTypeAsInt(xmlNode &node) +XmlNodeType AudioPolicyParser::GetXmlNodeTypeAsInt(xmlNode &node) { if (!xmlStrcmp(node.name, reinterpret_cast("adapters"))) { return XmlNodeType::ADAPTERS; @@ -509,8 +706,8 @@ XmlNodeType AudioPolicyParser::GetNodeTypeAsInt(xmlNode &node) return XmlNodeType::VOLUME_GROUPS; } else if (!xmlStrcmp(node.name, reinterpret_cast("interruptGroups"))) { return XmlNodeType::INTERRUPT_GROUPS; - } else if (!xmlStrcmp(node.name, reinterpret_cast("extends"))) { - return XmlNodeType::EXTENDS; + } else if (!xmlStrcmp(node.name, reinterpret_cast("globalConfigs"))) { + return XmlNodeType::GLOBAL_CONFIGS; } else { return XmlNodeType::XML_UNKNOWN; } @@ -540,9 +737,9 @@ AdaptersType AudioPolicyParser::GetAdaptersType(const std::string &adapterName) else if (adapterName == ADAPTER_A2DP_TYPE) return AdaptersType::TYPE_A2DP; else if (adapterName == ADAPTER_REMOTE_TYPE) - return AdaptersType::TYPE_REMOTE; + return AdaptersType::TYPE_REMOTE_AUDIO; else if (adapterName == ADAPTER_FILE_TYPE) - return AdaptersType::TYPE_FILE; + return AdaptersType::TYPE_FILE_IO; else if (adapterName == ADAPTER_USB_TYPE) return AdaptersType::TYPE_USB; else if (adapterName == ADAPTER_DP_TYPE) @@ -551,41 +748,37 @@ AdaptersType AudioPolicyParser::GetAdaptersType(const std::string &adapterName) return AdaptersType::TYPE_INVALID; } -AdapterType AudioPolicyParser::GetAdapterTypeAsInt(xmlNode &node) +PAConfigType AudioPolicyParser::GetPaConfigType(std::string &name) { - if (!xmlStrcmp(node.name, reinterpret_cast("devices"))) { - return AdapterType::DEVICES; - } else if (!xmlStrcmp(node.name, reinterpret_cast("modules"))) { - return AdapterType::MODULES; + if (name =="audioLatency") { + return PAConfigType::AUDIO_LATENCY; + } else if (name =="sinkLatency") { + return PAConfigType::SINK_LATENCY; } else { - return AdapterType::UNKNOWN; + return PAConfigType::UNKNOWN; } } -ModuleType AudioPolicyParser::GetModuleTypeAsInt(xmlNode &node) +DefaultMaxInstanceType AudioPolicyParser::GetDefaultMaxInstanceTypeAsInt(xmlNode &node) { - if (!xmlStrcmp(node.name, reinterpret_cast("configs"))) { - return ModuleType::CONFIGS; - } else if (!xmlStrcmp(node.name, reinterpret_cast("profiles"))) { - return ModuleType::PROFILES; - } else if (!xmlStrcmp(node.name, reinterpret_cast("devices"))) { - return ModuleType::DEVICES; + if (!xmlStrcmp(node.name, reinterpret_cast("output"))) { + return DefaultMaxInstanceType::OUTPUT; + } else if (!xmlStrcmp(node.name, reinterpret_cast("input"))) { + return DefaultMaxInstanceType::INPUT; } else { - return ModuleType::UNKNOWN; + return DefaultMaxInstanceType::UNKNOWN; } } -ExtendType AudioPolicyParser::GetExtendTypeAsInt(xmlNode &node) +StreamType AudioPolicyParser::GetStreamTypeAsInt(xmlNode &node) { - if (!xmlStrcmp(node.name, reinterpret_cast("updateRouteSupport"))) { - return ExtendType::UPDATE_ROUTE_SUPPORT; - } else if (!xmlStrcmp(node.name, reinterpret_cast("audioLatency"))) { - return ExtendType::AUDIO_LATENCY; - } else if (!xmlStrcmp(node.name, reinterpret_cast("sinkLatency"))) { - return ExtendType::SINK_LATENCY; + if (!xmlStrcmp(node.name, reinterpret_cast("normal"))) { + return StreamType::NORMAL; + } else if (!xmlStrcmp(node.name, reinterpret_cast("fast"))) { + return StreamType::FAST; } else { - return ExtendType::UNKNOWN; + return StreamType::UNKNOWN; } } } // namespace AudioStandard -} // namespace OHOS \ No newline at end of file +} // namespace OHOS diff --git a/services/audio_policy/server/src/service/config/xml_parser.cpp b/services/audio_policy/server/src/service/config/xml_parser.cpp deleted file mode 100644 index 5759606ffa..0000000000 --- a/services/audio_policy/server/src/service/config/xml_parser.cpp +++ /dev/null @@ -1,376 +0,0 @@ -/* - * Copyright (c) 2021-2022 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -#undef LOG_TAG -#define LOG_TAG "XMLParser" - -#include "audio_log.h" - -#include "xml_parser.h" - -#include - -namespace OHOS { -namespace AudioStandard { -bool XMLParser::LoadConfiguration() -{ - AUDIO_INFO_LOG("start LoadConfiguration"); - mDoc = xmlReadFile(CONFIG_FILE, nullptr, 0); - CHECK_AND_RETURN_RET_LOG(mDoc != nullptr, false, "xmlReadFile Failed"); - - return true; -} - -bool XMLParser::Parse() -{ - xmlNode *root = xmlDocGetRootElement(mDoc); - CHECK_AND_RETURN_RET_LOG(root != nullptr, false, "xmlDocGetRootElement Failed"); - - if (!ParseInternal(*root)) { - return false; - } - - return true; -} - -void XMLParser::Destroy() -{ - if (mDoc != nullptr) { - xmlFreeDoc(mDoc); - } -} - -bool XMLParser::ParseInternal(xmlNode &node) -{ - xmlNode *currNode = &node; - for (; currNode; currNode = currNode->next) { - if (XML_ELEMENT_NODE == currNode->type) { - switch (GetNodeNameAsInt(*currNode)) { - case DEVICE_CLASS: - ParseDeviceClass(*currNode); - break; - case AUDIO_INTERRUPT_ENABLE: - ParseAudioInterrupt(*currNode); - break; - case UPDATE_ROUTE_SUPPORT: - ParseUpdateRouteSupport(*currNode); - break; - case AUDIO_LATENCY: - ParseAudioLatency(*currNode); - break; - case SINK_LATENCY: - ParseSinkLatency(*currNode); - break; - case VOLUME_GROUP_CONFIG: - ParseGroups(*currNode, VOLUME_GROUP_CONFIG); - break; - case INTERRUPT_GROUP_CONFIG: - ParseGroups(*currNode, INTERRUPT_GROUP_CONFIG); - break; - default: - ParseInternal(*(currNode->children)); - break; - } - } - } - - mPortObserver.OnXmlParsingCompleted(xmlParsedDataMap_); - mPortObserver.OnVolumeGroupParsed(volumeGroupMap_); - mPortObserver.OnInterruptGroupParsed(interruptGroupMap_); - return true; -} - -void XMLParser::ParseDeviceClass(xmlNode &node) -{ - xmlNode *modulesNode = nullptr; - modulesNode = node.xmlChildrenNode; - - std::string className = ExtractPropertyValue("name", node); - CHECK_AND_RETURN_LOG(!className.empty(), "No name provided for the device class %{public}s", node.name); - - deviceClassType_ = GetDeviceClassType(className); - xmlParsedDataMap_[deviceClassType_] = {}; - - while (modulesNode != nullptr) { - if (modulesNode->type == XML_ELEMENT_NODE) { - ParseModules(*modulesNode, className); - } - modulesNode = modulesNode->next; - } -} - -void XMLParser::ParseModules(xmlNode &node, std::string &className) -{ - xmlNode *moduleNode = nullptr; - std::list moduleList = {}; - moduleNode = node.xmlChildrenNode; - - while (moduleNode != nullptr) { - if (moduleNode->type == XML_ELEMENT_NODE) { - AudioModuleInfo moduleInfo = {}; - moduleInfo.className = className; - moduleInfo.name = ExtractPropertyValue("name", *moduleNode); - moduleInfo.lib = ExtractPropertyValue("lib", *moduleNode); - moduleInfo.role = ExtractPropertyValue("role", *moduleNode); - - std::regex regexDelimiter(","); - std::string rates = ExtractPropertyValue("rate", *moduleNode); - const std::sregex_token_iterator itEnd; - for (std::sregex_token_iterator it(rates.begin(), rates.end(), regexDelimiter, -1); it != itEnd; ++it) { - moduleInfo.supportedRate_.insert(atoi(it->str().c_str())); - } - moduleInfo.rate = std::to_string(*(moduleInfo.supportedRate_.rbegin())); - - moduleInfo.format = ExtractPropertyValue("format", *moduleNode); - - std::string channels = ExtractPropertyValue("channels", *moduleNode); - for (std::sregex_token_iterator it(channels.begin(), channels.end(), regexDelimiter, -1); - it != itEnd; ++it) { - moduleInfo.supportedChannels_.insert(atoi(it->str().c_str())); - } - moduleInfo.channels = std::to_string(*(moduleInfo.supportedChannels_.rbegin())); - - moduleInfo.bufferSize = ExtractPropertyValue("buffer_size", *moduleNode); - moduleInfo.fileName = ExtractPropertyValue("file", *moduleNode); - moduleInfo.ports = {}; - - ParsePorts(*moduleNode, moduleInfo); - moduleList.push_back(moduleInfo); - } - moduleNode = moduleNode->next; - } - - xmlParsedDataMap_[deviceClassType_] = moduleList; -} - -void XMLParser::ParsePorts(xmlNode &node, AudioModuleInfo &moduleInfo) -{ - xmlNode *portsNode = nullptr; - portsNode = node.xmlChildrenNode; - - while (portsNode != nullptr) { - if (portsNode->type == XML_ELEMENT_NODE) { - ParsePort(*portsNode, moduleInfo); - } - portsNode = portsNode->next; - } -} - -void XMLParser::ParsePort(xmlNode &node, AudioModuleInfo &moduleInfo) -{ - xmlNode *portNode = nullptr; - std::list portInfoList = {}; - portNode = node.xmlChildrenNode; - - while (portNode != nullptr) { - if (portNode->type == XML_ELEMENT_NODE) { - moduleInfo.adapterName = ExtractPropertyValue("adapter_name", *portNode); - moduleInfo.id = ExtractPropertyValue("id", *portNode); - - // if some parameter is not configured inside , take data from moduleinfo - std::string value = ExtractPropertyValue("rate", *portNode); - if (!value.empty()) { - SeparatedListParserAndFetchMaxValue(value, moduleInfo.supportedRate_, moduleInfo.rate); - } - - value = ExtractPropertyValue("format", *portNode); - if (!value.empty()) { - moduleInfo.format = value; - } - - value = ExtractPropertyValue("channels", *portNode); - if (!value.empty()) { - SeparatedListParserAndFetchMaxValue(value, moduleInfo.supportedChannels_, moduleInfo.channels); - } - - value = ExtractPropertyValue("buffer_size", *portNode); - if (!value.empty()) { - moduleInfo.bufferSize = value; - } - - value = ExtractPropertyValue("fixed_latency", *portNode); - if (!value.empty()) { - moduleInfo.fixedLatency = value; - } - - value = ExtractPropertyValue("render_in_idle_state", *portNode); - if (!value.empty()) { - moduleInfo.renderInIdleState = value; - } - - if (!((value = ExtractPropertyValue("open_mic_speaker", *portNode)).empty())) { - moduleInfo.OpenMicSpeaker = value; - } - - if (!((value = ExtractPropertyValue("source_type", *portNode)).empty())) { - moduleInfo.sourceType = value; - } - - if (!((value = ExtractPropertyValue("file", *portNode)).empty())) { - moduleInfo.fileName = value; - } - - if (!((value = ExtractPropertyValue("offload_enable", *portNode)).empty())) { - moduleInfo.offloadEnable = value; - } - - portInfoList.push_back(moduleInfo); - } - portNode = portNode->next; - } - - moduleInfo.ports.assign(portInfoList.begin(), portInfoList.end()); -} - -NodeName XMLParser::GetNodeNameAsInt(xmlNode &node) -{ - if (!xmlStrcmp(node.name, reinterpret_cast("deviceclass"))) { - return DEVICE_CLASS; - } else if (!xmlStrcmp(node.name, reinterpret_cast("AudioInterruptEnable"))) { - return AUDIO_INTERRUPT_ENABLE; - } else if (!xmlStrcmp(node.name, reinterpret_cast("UpdateRouteSupport"))) { - return UPDATE_ROUTE_SUPPORT; - } else if (!xmlStrcmp(node.name, reinterpret_cast("AudioLatency"))) { - return AUDIO_LATENCY; - } else if (!xmlStrcmp(node.name, reinterpret_cast("SinkLatency"))) { - return SINK_LATENCY; - } else if (!xmlStrcmp(node.name, reinterpret_cast("VolumeGroupConfig"))) { - return VOLUME_GROUP_CONFIG; - } else if (!xmlStrcmp(node.name, reinterpret_cast("InterruptGroupConfig"))) { - return INTERRUPT_GROUP_CONFIG; - } else { - return UNKNOWN; - } -} - -void XMLParser::ParseUpdateRouteSupport(xmlNode &node) -{ - xmlNode *child = node.children; - xmlChar *supportFlag = xmlNodeGetContent(child); - - if (!xmlStrcmp(supportFlag, reinterpret_cast("true"))) { - mPortObserver.OnUpdateRouteSupport(true); - } else { - mPortObserver.OnUpdateRouteSupport(false); - } - - xmlFree(supportFlag); -} - -void XMLParser::ParseAudioInterrupt(xmlNode &node) -{ - xmlNode *child = node.children; - xmlChar *enableFlag = xmlNodeGetContent(child); - - xmlStrcmp(enableFlag, reinterpret_cast("true")); - xmlFree(enableFlag); -} - -ClassType XMLParser::GetDeviceClassType(const std::string &deviceClass) -{ - if (deviceClass == PRIMARY_CLASS) - return ClassType::TYPE_PRIMARY; - else if (deviceClass == A2DP_CLASS) - return ClassType::TYPE_A2DP; - else if (deviceClass == USB_CLASS) - return ClassType::TYPE_USB; - else if (deviceClass == DP_CLASS) - return ClassType::TYPE_DP; - else if (deviceClass == FILE_CLASS) - return ClassType::TYPE_FILE_IO; - else - return ClassType::TYPE_INVALID; -} - -std::string XMLParser::ExtractPropertyValue(const std::string &propName, xmlNode &node) -{ - std::string propValue = ""; - xmlChar *tempValue = nullptr; - - if (xmlHasProp(&node, reinterpret_cast(propName.c_str()))) { - tempValue = xmlGetProp(&node, reinterpret_cast(propName.c_str())); - } - - if (tempValue != nullptr) { - propValue = reinterpret_cast(tempValue); - xmlFree(tempValue); - } - - return propValue; -} - -void XMLParser::ParseAudioLatency(xmlNode &node) -{ - xmlNode *child = node.children; - xmlChar *audioLatency = xmlNodeGetContent(child); - std::string sAudioLatency(reinterpret_cast(audioLatency)); - mPortObserver.OnAudioLatencyParsed((uint64_t)std::stoi(sAudioLatency)); - - xmlFree(audioLatency); -} - -void XMLParser::ParseSinkLatency(xmlNode &node) -{ - xmlNode *child = node.children; - xmlChar *latency = xmlNodeGetContent(child); - std::string sLatency(reinterpret_cast(latency)); - mPortObserver.OnSinkLatencyParsed((uint64_t)std::stoi(sLatency)); - - xmlFree(latency); -} - -void XMLParser::ParseGroups(xmlNode& node, NodeName type) -{ - xmlNode* groupsNode = nullptr; - groupsNode = node.xmlChildrenNode; // get - while (groupsNode != nullptr) { - if (groupsNode->type == XML_ELEMENT_NODE) { - ParseGroup(*groupsNode, type); - } - groupsNode = groupsNode->next; - } -} - -void XMLParser::ParseGroup(xmlNode& node, NodeName type) -{ - xmlNode* groupNode = nullptr; - groupNode = node.xmlChildrenNode; - - while (groupNode != nullptr) { - if (groupNode->type == XML_ELEMENT_NODE) { - std::string groupName = ExtractPropertyValue("name", *groupNode); - ParseGroupModule(*groupNode, type, groupName); - } - groupNode = groupNode->next; - } -} - -void XMLParser::ParseGroupModule(xmlNode& node, NodeName type, std::string groupName) -{ - xmlNode* moduleNode = nullptr; - moduleNode = node.xmlChildrenNode; - while (moduleNode != nullptr) { - if (moduleNode->type == XML_ELEMENT_NODE) { - std::string moduleName = ExtractPropertyValue("name", *moduleNode); - if (type == VOLUME_GROUP_CONFIG) { - volumeGroupMap_[moduleName] = groupName; - } else if (type == INTERRUPT_GROUP_CONFIG) { - interruptGroupMap_[moduleName] = groupName; - } - } - moduleNode = moduleNode->next; - } -} -} // namespace AudioStandard -} // namespace OHOS diff --git a/services/audio_policy/server/src/service/dump/audio_service_dump.cpp b/services/audio_policy/server/src/service/dump/audio_service_dump.cpp index 6da852b0a8..117220b728 100644 --- a/services/audio_policy/server/src/service/dump/audio_service_dump.cpp +++ b/services/audio_policy/server/src/service/dump/audio_service_dump.cpp @@ -569,36 +569,25 @@ void AudioServiceDump::AudioFocusInfoDump(string &dumpString) return; } -void AudioServiceDump::AudioPolicyParserDump(string &dumpString) +void AudioServiceDump::AudioPolicyParserDump(std::string &dumpString) { dumpString += "\nAudioPolicyParser:\n"; for (auto &[adapterType, adapterInfo] : audioData_.policyData.adapterInfoMap) { AppendFormat(dumpString, " - adapter : %s -- adapterType:%u\n", adapterInfo.adapterName_.c_str(), adapterType); for (auto &deviceInfo : adapterInfo.deviceInfos_) { - AppendFormat(dumpString, " - device -- name:%s, type:%s, role:%s\n", deviceInfo.name_.c_str(), - deviceInfo.type_.c_str(), deviceInfo.role_.c_str()); + AppendFormat(dumpString, " - device -- name:%s, pin:%s, type:%s, role:%s\n", deviceInfo.name_.c_str(), + deviceInfo.pin_.c_str(), deviceInfo.type_.c_str(), deviceInfo.role_.c_str()); } - for (auto &moduleInfo : adapterInfo.moduleInfos_) { - AppendFormat(dumpString, " - module : -- name:%s, moduleType_:%s, lib:%s, role:%s, fixedLatency:%s, " - "renderInIdleState:%s, profile:%s, file:%s\n", moduleInfo.name_.c_str(), - moduleInfo.moduleType_.c_str(), moduleInfo.lib_.c_str(), moduleInfo.role_.c_str(), - moduleInfo.fixedLatency_.c_str(), moduleInfo.renderInIdleState_.c_str(), - moduleInfo.profile_.c_str(), moduleInfo.file_.c_str()); - - for (auto &configInfo : moduleInfo.configInfos_) { - AppendFormat(dumpString, " - config : -- name:%s, valu:%s\n", configInfo.name_.c_str(), - configInfo.valu_.c_str()); - } - - for (auto profileInfo : moduleInfo.profileInfos_) { - AppendFormat(dumpString, " - profile -- rate:%s, channels:%s, format:%s, bufferSize:%s\n", - profileInfo.rate_.c_str(), profileInfo.channels_.c_str(), profileInfo.format_.c_str(), - profileInfo.bufferSize_.c_str()); - } - - for (auto device : moduleInfo.devices_) { - AppendFormat(dumpString, " - device : %s\n", device.c_str()); + for (auto &pipeInfo : adapterInfo.pipeInfos_) { + AppendFormat(dumpString, " - module : -- name:%s, pipeRole:%s, pipeFlags:%s, lib:%s, paPropRole:%s, " + "fixedLatency:%s, renderInIdleState:%s\n", pipeInfo.name_.c_str(), + pipeInfo.pipeRole_.c_str(), pipeInfo.pipeFlags_.c_str(), pipeInfo.lib_.c_str(), + pipeInfo.paPropRole_.c_str(), pipeInfo.fixedLatency_.c_str(), pipeInfo.renderInIdleState_.c_str()); + + for (auto &configInfo : pipeInfo.configInfos_) { + AppendFormat(dumpString, " - config : -- name:%s, value:%s\n", configInfo.name_.c_str(), + configInfo.value_.c_str()); } } } @@ -612,9 +601,59 @@ void AudioServiceDump::AudioPolicyParserDump(string &dumpString) AppendFormat(dumpString, " - interruptGroupMap_ first:%s, second:%s\n", interrupt.first.c_str(), interrupt.second.c_str()); } + + AppendFormat(dumpString, " - globalConfig adapter:%s, pipe:%s, device:%s, updateRouteSupport:%d, " + "audioLatency:%s, sinkLatency:%s\n", audioData_.policyData.globalConfigs.adapter_.c_str(), + audioData_.policyData.globalConfigs.pipe_.c_str(), audioData_.policyData.globalConfigs.device_.c_str(), + audioData_.policyData.globalConfigs.updateRouteSupport_, + audioData_.policyData.globalConfigs.globalPaConfigs_.audioLatency_.c_str(), + audioData_.policyData.globalConfigs.globalPaConfigs_.sinkLatency_.c_str()); + for (auto &outputConfig : audioData_.policyData.globalConfigs.outputConfigInfos_) { + AppendFormat(dumpString, " - output config name:%s, type:%s, value:%s\n", outputConfig.name_.c_str(), + outputConfig.type_.c_str(), outputConfig.value_.c_str()); + } + for (auto &inputConfig : audioData_.policyData.globalConfigs.inputConfigInfos_) { + AppendFormat(dumpString, " - input config name:%s, type_%s, value:%s\n", inputConfig.name_.c_str(), + inputConfig.type_.c_str(), inputConfig.value_.c_str()); + } dumpString += "\n"; } +void AudioServiceDump::DumpXmlParsedDataMap(string &dumpString) +{ + dumpString += "\nXmlParsedDataParser:\n"; + + for (auto &[adapterType, deviceClassInfos] : audioData_.policyData.deviceClassInfo) { + AppendFormat(dumpString, " - DeviceClassInfo type %d\n", adapterType); + for (auto &deviceClassInfo : deviceClassInfos) { + AppendFormat(dumpString, " - Data : className:%s, name:%s, adapter:%s, id:%s, lib:%s, role:%s, rate:%s\n", + deviceClassInfo.className.c_str(), deviceClassInfo.name.c_str(), + deviceClassInfo.adapterName.c_str(), deviceClassInfo.id.c_str(), + deviceClassInfo.lib.c_str(), deviceClassInfo.role.c_str(), deviceClassInfo.rate.c_str()); + + for (auto rate : deviceClassInfo.supportedRate_) { + AppendFormat(dumpString, " - rate:%u\n", rate); + } + + for (auto supportedChannel : deviceClassInfo.supportedChannels_) { + AppendFormat(dumpString, " - supportedChannel:%u\n", supportedChannel); + } + + AppendFormat(dumpString, " -DeviceClassInfo : format:%s, channels:%s, bufferSize:%s, fixedLatency:%s, " + " sinkLatency:%s, renderInIdleState:%s, OpenMicSpeaker:%s, fileName:%s, networkId:%s, " + "deviceType:%s, sceneName:%s, sourceType:%s, offloadEnable:%s\n", + deviceClassInfo.format.c_str(), deviceClassInfo.channels.c_str(), deviceClassInfo.bufferSize.c_str(), + deviceClassInfo.fixedLatency.c_str(), deviceClassInfo.sinkLatency.c_str(), + deviceClassInfo.renderInIdleState.c_str(), deviceClassInfo.OpenMicSpeaker.c_str(), + deviceClassInfo.fileName.c_str(), deviceClassInfo.networkId.c_str(), deviceClassInfo.deviceType.c_str(), + deviceClassInfo.sceneName.c_str(), deviceClassInfo.sourceType.c_str(), + deviceClassInfo.offloadEnable.c_str()); + } + AppendFormat(dumpString, "-----EndOfXmlParsedDataMap-----\n"); + } +} + + void AudioServiceDump::AudioInterruptZoneDump(string &dumpString) { dumpString += "\nAudioInterrupt Zone:\n"; @@ -815,6 +854,7 @@ void AudioServiceDump::DataDump(string &dumpString) AudioFocusInfoDump(dumpString); AudioInterruptZoneDump(dumpString); AudioPolicyParserDump(dumpString); + DumpXmlParsedDataMap(dumpString); GroupInfoDump(dumpString); EffectManagerInfoDump(dumpString); StreamVolumeInfosDump(dumpString); -- Gitee