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 class AudioRouterCenter { 35 public: GetAudioRouterCenter()36 static AudioRouterCenter& GetAudioRouterCenter() 37 { 38 static AudioRouterCenter audioRouterCenter; 39 return audioRouterCenter; 40 } 41 std::vector<std::unique_ptr<AudioDeviceDescriptor>> FetchOutputDevices(StreamUsage streamUsage, int32_t clientUID); 42 std::unique_ptr<AudioDeviceDescriptor> FetchInputDevice(SourceType sourceType, int32_t clientUID); 43 44 bool isCallRenderRouter(StreamUsage streamUsage); 45 46 int32_t SetAudioDeviceRefinerCallback(const sptr<IRemoteObject> &object); 47 48 int32_t UnsetAudioDeviceRefinerCallback(); 49 50 private: AudioRouterCenter()51 AudioRouterCenter() 52 { 53 unique_ptr<AudioStrategyRouterParser> audioStrategyRouterParser = make_unique<AudioStrategyRouterParser>(); 54 if (audioStrategyRouterParser->LoadConfiguration()) { 55 AUDIO_INFO_LOG("audioStrategyRouterParser load configuration successfully."); 56 audioStrategyRouterParser->Parse(); 57 for (auto &mediaRounter : audioStrategyRouterParser->mediaRenderRouters_) { 58 AUDIO_INFO_LOG("mediaRenderRouters_, class %{public}s", mediaRounter->GetClassName().c_str()); 59 mediaRenderRouters_.push_back(std::move(mediaRounter)); 60 } 61 for (auto &callRenderRouter : audioStrategyRouterParser->callRenderRouters_) { 62 AUDIO_INFO_LOG("callRenderRouters_, class %{public}s", callRenderRouter->GetClassName().c_str()); 63 callRenderRouters_.push_back(std::move(callRenderRouter)); 64 } 65 for (auto &callCaptureRouter : audioStrategyRouterParser->callCaptureRouters_) { 66 AUDIO_INFO_LOG("callCaptureRouters_, class %{public}s", callCaptureRouter->GetClassName().c_str()); 67 callCaptureRouters_.push_back(std::move(callCaptureRouter)); 68 } 69 for (auto &ringRenderRouter : audioStrategyRouterParser->ringRenderRouters_) { 70 AUDIO_INFO_LOG("ringRenderRouters_, class %{public}s", ringRenderRouter->GetClassName().c_str()); 71 ringRenderRouters_.push_back(std::move(ringRenderRouter)); 72 } 73 for (auto &toneRenderRouter : audioStrategyRouterParser->toneRenderRouters_) { 74 AUDIO_INFO_LOG("toneRenderRouters_, class %{public}s", toneRenderRouter->GetClassName().c_str()); 75 toneRenderRouters_.push_back(std::move(toneRenderRouter)); 76 } 77 for (auto &recordCaptureRouter : audioStrategyRouterParser->recordCaptureRouters_) { 78 AUDIO_INFO_LOG("recordCaptureRouters_, class %{public}s", recordCaptureRouter->GetClassName().c_str()); 79 recordCaptureRouters_.push_back(std::move(recordCaptureRouter)); 80 } 81 for (auto &voiceMessageRouter : audioStrategyRouterParser->voiceMessageRouters_) { 82 AUDIO_INFO_LOG("voiceMessageRouters_, class %{public}s", voiceMessageRouter->GetClassName().c_str()); 83 voiceMessageRouters_.push_back(std::move(voiceMessageRouter)); 84 } 85 } 86 87 unique_ptr<AudioUsageStrategyParser> audioUsageStrategyParser = make_unique<AudioUsageStrategyParser>(); 88 if (audioUsageStrategyParser->LoadConfiguration()) { 89 AUDIO_INFO_LOG("AudioUsageStrategyParser load configuration successfully."); 90 audioUsageStrategyParser->Parse(); 91 renderConfigMap_ = audioUsageStrategyParser->renderConfigMap_; 92 capturerConfigMap_ = audioUsageStrategyParser->capturerConfigMap_; 93 for (auto &renderConfig : renderConfigMap_) { 94 AUDIO_INFO_LOG("streamusage:%{public}d, routername:%{public}s", 95 renderConfig.first, renderConfig.second.c_str()); 96 } 97 for (auto &capturerConfig : capturerConfigMap_) { 98 AUDIO_INFO_LOG("sourceType:%{public}d, sourceTypeName:%{public}s", 99 capturerConfig.first, capturerConfig.second.c_str()); 100 } 101 } 102 } 103 ~AudioRouterCenter()104 ~AudioRouterCenter() {} 105 106 unique_ptr<AudioDeviceDescriptor> FetchMediaRenderDevice(StreamUsage streamUsage, int32_t clientUID, 107 RouterType &routerType); 108 unique_ptr<AudioDeviceDescriptor> FetchCallRenderDevice(StreamUsage streamUsage, int32_t clientUID, 109 RouterType &routerType); 110 bool HasScoDevice(); 111 vector<unique_ptr<AudioDeviceDescriptor>> FetchRingRenderDevices(StreamUsage streamUsage, int32_t clientUID, 112 RouterType &routerType); 113 void DealRingRenderRouters(std::vector<std::unique_ptr<AudioDeviceDescriptor>> &descs, 114 StreamUsage streamUsage, int32_t clientUID, RouterType &routerType); 115 116 std::vector<std::unique_ptr<RouterBase>> mediaRenderRouters_; 117 std::vector<std::unique_ptr<RouterBase>> callRenderRouters_; 118 std::vector<std::unique_ptr<RouterBase>> callCaptureRouters_; 119 std::vector<std::unique_ptr<RouterBase>> ringRenderRouters_; 120 std::vector<std::unique_ptr<RouterBase>> toneRenderRouters_; 121 std::vector<std::unique_ptr<RouterBase>> recordCaptureRouters_; 122 std::vector<std::unique_ptr<RouterBase>> voiceMessageRouters_; 123 124 unordered_map<StreamUsage, string> renderConfigMap_; 125 unordered_map<SourceType, string> capturerConfigMap_; 126 127 sptr<IStandardAudioRoutingManagerListener> audioDeviceRefinerCb_; 128 }; 129 } // namespace AudioStandard 130 } // namespace OHOS 131 #endif // ST_AUDIO_ROUTER_CENTER_H 132