1 /* 2 * Copyright (c) 2023 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #ifndef ST_AUDIO_ROUTER_CENTER_H 17 #define ST_AUDIO_ROUTER_CENTER_H 18 19 #include "router_base.h" 20 #include "user_select_router.h" 21 #include "privacy_priority_router.h" 22 #include "public_priority_router.h" 23 #include "package_filter_router.h" 24 #include "stream_filter_router.h" 25 #include "cockpit_phone_router.h" 26 #include "pair_device_router.h" 27 #include "default_router.h" 28 #include "audio_stream_collector.h" 29 #include "audio_strategy_router_parser.h" 30 #include "audio_usage_strategy_parser.h" 31 32 namespace OHOS { 33 namespace AudioStandard { 34 struct FetchDeviceInfo { 35 StreamUsage streamUsage; 36 int32_t clientUID; 37 std::string caller; 38 }; 39 40 class AudioRouterCenter { 41 public: GetAudioRouterCenter()42 static AudioRouterCenter& GetAudioRouterCenter() 43 { 44 static AudioRouterCenter audioRouterCenter; 45 return audioRouterCenter; 46 } 47 std::vector<std::shared_ptr<AudioDeviceDescriptor>> FetchOutputDevices(StreamUsage streamUsage, 48 int32_t clientUID, std::string caller, const RouterType &bypassType = RouterType::ROUTER_TYPE_NONE); 49 std::shared_ptr<AudioDeviceDescriptor> FetchInputDevice(SourceType sourceType, int32_t clientUID, 50 const uint32_t sessionID = 0); 51 int32_t SetAudioDeviceRefinerCallback(const sptr<IRemoteObject> &object); 52 int32_t UnsetAudioDeviceRefinerCallback(); 53 bool isCallRenderRouter(StreamUsage streamUsage); 54 void SetAlarmFollowRingRouter(const bool flag); 55 56 int32_t GetSplitInfo(std::string &splitInfo); 57 58 int32_t NotifyDistributedOutputChange(bool isRemote); 59 60 bool IsConfigRouterStrategy(SourceType sourceType); 61 private: AudioRouterCenter()62 AudioRouterCenter() 63 { 64 unique_ptr<AudioStrategyRouterParser> audioStrategyRouterParser = make_unique<AudioStrategyRouterParser>(); 65 if (audioStrategyRouterParser->LoadConfiguration()) { 66 AUDIO_INFO_LOG("audioStrategyRouterParser load configuration successfully."); 67 for (auto &mediaRounter : audioStrategyRouterParser->mediaRenderRouters_) { 68 AUDIO_INFO_LOG("mediaRenderRouters_, class %{public}s", mediaRounter->GetClassName().c_str()); 69 mediaRenderRouters_.push_back(std::move(mediaRounter)); 70 } 71 for (auto &callRenderRouter : audioStrategyRouterParser->callRenderRouters_) { 72 AUDIO_INFO_LOG("callRenderRouters_, class %{public}s", callRenderRouter->GetClassName().c_str()); 73 callRenderRouters_.push_back(std::move(callRenderRouter)); 74 } 75 for (auto &callCaptureRouter : audioStrategyRouterParser->callCaptureRouters_) { 76 AUDIO_INFO_LOG("callCaptureRouters_, class %{public}s", callCaptureRouter->GetClassName().c_str()); 77 callCaptureRouters_.push_back(std::move(callCaptureRouter)); 78 } 79 for (auto &ringRenderRouter : audioStrategyRouterParser->ringRenderRouters_) { 80 AUDIO_INFO_LOG("ringRenderRouters_, class %{public}s", ringRenderRouter->GetClassName().c_str()); 81 ringRenderRouters_.push_back(std::move(ringRenderRouter)); 82 } 83 for (auto &toneRenderRouter : audioStrategyRouterParser->toneRenderRouters_) { 84 AUDIO_INFO_LOG("toneRenderRouters_, class %{public}s", toneRenderRouter->GetClassName().c_str()); 85 toneRenderRouters_.push_back(std::move(toneRenderRouter)); 86 } 87 for (auto &recordCaptureRouter : audioStrategyRouterParser->recordCaptureRouters_) { 88 AUDIO_INFO_LOG("recordCaptureRouters_, class %{public}s", recordCaptureRouter->GetClassName().c_str()); 89 recordCaptureRouters_.push_back(std::move(recordCaptureRouter)); 90 } 91 for (auto &voiceMessageRouter : audioStrategyRouterParser->voiceMessageRouters_) { 92 AUDIO_INFO_LOG("voiceMessageRouters_, class %{public}s", voiceMessageRouter->GetClassName().c_str()); 93 voiceMessageRouters_.push_back(std::move(voiceMessageRouter)); 94 } 95 } 96 97 unique_ptr<AudioUsageStrategyParser> audioUsageStrategyParser = make_unique<AudioUsageStrategyParser>(); 98 if (audioUsageStrategyParser->LoadConfiguration()) { 99 AUDIO_INFO_LOG("AudioUsageStrategyParser load configuration successfully."); 100 renderConfigMap_ = audioUsageStrategyParser->renderConfigMap_; 101 capturerConfigMap_ = audioUsageStrategyParser->capturerConfigMap_; 102 for (auto &renderConfig : renderConfigMap_) { 103 AUDIO_INFO_LOG("streamusage:%{public}d, routername:%{public}s", 104 renderConfig.first, renderConfig.second.c_str()); 105 } 106 for (auto &capturerConfig : capturerConfigMap_) { 107 AUDIO_INFO_LOG("sourceType:%{public}d, sourceTypeName:%{public}s", 108 capturerConfig.first, capturerConfig.second.c_str()); 109 } 110 } 111 } 112 ~AudioRouterCenter()113 ~AudioRouterCenter() {} 114 115 shared_ptr<AudioDeviceDescriptor> FetchMediaRenderDevice(StreamUsage streamUsage, int32_t clientUID, 116 RouterType &routerType, const RouterType &bypassType = RouterType::ROUTER_TYPE_NONE); 117 shared_ptr<AudioDeviceDescriptor> FetchCallRenderDevice(StreamUsage streamUsage, int32_t clientUID, 118 RouterType &routerType, const RouterType &bypassType = RouterType::ROUTER_TYPE_NONE, 119 const RouterType &bypassWithSco = RouterType::ROUTER_TYPE_NONE); 120 bool HasScoDevice(); 121 vector<shared_ptr<AudioDeviceDescriptor>> FetchRingRenderDevices(StreamUsage streamUsage, int32_t clientUID, 122 RouterType &routerType); 123 void DealRingRenderRouters(std::vector<std::shared_ptr<AudioDeviceDescriptor>> &descs, 124 StreamUsage streamUsage, int32_t clientUID, RouterType &routerType); 125 shared_ptr<AudioDeviceDescriptor> FetchCallCaptureDevice(SourceType sourceType, int32_t clientUID, 126 RouterType &routerType, const uint32_t sessionID = 0); 127 shared_ptr<AudioDeviceDescriptor> FetchRecordCaptureDevice(SourceType sourceType, int32_t clientUID, 128 RouterType &routerType, const uint32_t sessionID = 0); 129 shared_ptr<AudioDeviceDescriptor> FetchVoiceMessageCaptureDevice(SourceType sourceType, int32_t clientUID, 130 RouterType &routerType, const uint32_t sessionID = 0); 131 bool NeedSkipSelectAudioOutputDeviceRefined(StreamUsage streamUsage, 132 std::vector<std::shared_ptr<AudioDeviceDescriptor>> &descs); 133 RouterType GetBypassWithSco(AudioScene audioScene); 134 bool IsMediaFollowCallStrategy(AudioScene audioScene); 135 shared_ptr<AudioDeviceDescriptor> FetchCapturerInputDevice(SourceType sourceType, 136 int32_t clientUID, RouterType &routerType, const uint32_t sessionID); 137 std::vector<std::shared_ptr<AudioDeviceDescriptor>> FetchOutputDevicesInner(FetchDeviceInfo info, 138 RouterType &routerType, const RouterType &bypassType, 139 std::vector<std::shared_ptr<AudioDeviceDescriptor>> &descs); 140 141 std::vector<std::unique_ptr<RouterBase>> mediaRenderRouters_; 142 std::vector<std::unique_ptr<RouterBase>> callRenderRouters_; 143 std::vector<std::unique_ptr<RouterBase>> callCaptureRouters_; 144 std::vector<std::unique_ptr<RouterBase>> ringRenderRouters_; 145 std::vector<std::unique_ptr<RouterBase>> toneRenderRouters_; 146 std::vector<std::unique_ptr<RouterBase>> recordCaptureRouters_; 147 std::vector<std::unique_ptr<RouterBase>> voiceMessageRouters_; 148 149 unordered_map<StreamUsage, string> renderConfigMap_; 150 unordered_map<SourceType, string> capturerConfigMap_; 151 152 sptr<IStandardAudioRoutingManagerListener> audioDeviceRefinerCb_; 153 }; 154 } // namespace AudioStandard 155 } // namespace OHOS 156 #endif // ST_AUDIO_ROUTER_CENTER_H 157