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