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 #ifndef LOG_TAG
16 #define LOG_TAG "AudioRouterCenter"
17 #endif
18 
19 #include "audio_router_center.h"
20 #include "audio_policy_service.h"
21 
22 using namespace std;
23 
24 namespace OHOS {
25 namespace AudioStandard {
26 
27 const string MEDIA_RENDER_ROUTERS = "MediaRenderRouters";
28 const string CALL_RENDER_ROUTERS = "CallRenderRouters";
29 const string RECORD_CAPTURE_ROUTERS = "RecordCaptureRouters";
30 const string CALL_CAPTURE_ROUTERS = "CallCaptureRouters";
31 const string RING_RENDER_ROUTERS = "RingRenderRouters";
32 const string TONE_RENDER_ROUTERS = "ToneRenderRouters";
33 
FetchMediaRenderDevice(StreamUsage streamUsage,int32_t clientUID,RouterType & routerType,const RouterType & bypassType)34 unique_ptr<AudioDeviceDescriptor> AudioRouterCenter::FetchMediaRenderDevice(
35     StreamUsage streamUsage, int32_t clientUID, RouterType &routerType, const RouterType &bypassType)
36 {
37     for (auto &router : mediaRenderRouters_) {
38         if (router->GetRouterType() == bypassType) {
39             AUDIO_INFO_LOG("Fetch media render device bypass %{public}d", bypassType);
40             continue;
41         }
42         unique_ptr<AudioDeviceDescriptor> desc = router->GetMediaRenderDevice(streamUsage, clientUID);
43         if (desc->deviceType_ != DEVICE_TYPE_NONE) {
44             routerType = router->GetRouterType();
45             return desc;
46         }
47     }
48     return make_unique<AudioDeviceDescriptor>();
49 }
50 
FetchCallRenderDevice(StreamUsage streamUsage,int32_t clientUID,RouterType & routerType,const RouterType & bypassType)51 unique_ptr<AudioDeviceDescriptor> AudioRouterCenter::FetchCallRenderDevice(
52     StreamUsage streamUsage, int32_t clientUID, RouterType &routerType, const RouterType &bypassType)
53 {
54     for (auto &router : callRenderRouters_) {
55         if (router->GetRouterType() == bypassType) {
56             AUDIO_INFO_LOG("Fetch call render device bypass %{public}d", bypassType);
57             continue;
58         }
59         unique_ptr<AudioDeviceDescriptor> desc = router->GetCallRenderDevice(streamUsage, clientUID);
60         if (desc->deviceType_ != DEVICE_TYPE_NONE) {
61             routerType = router->GetRouterType();
62             return desc;
63         }
64     }
65     return make_unique<AudioDeviceDescriptor>();
66 }
67 
FetchRingRenderDevices(StreamUsage streamUsage,int32_t clientUID,RouterType & routerType)68 vector<unique_ptr<AudioDeviceDescriptor>> AudioRouterCenter::FetchRingRenderDevices(StreamUsage streamUsage,
69     int32_t clientUID, RouterType &routerType)
70 {
71     for (auto &router : ringRenderRouters_) {
72         CHECK_AND_CONTINUE_LOG(router != nullptr, "Invalid router.");
73         vector<unique_ptr<AudioDeviceDescriptor>> descs = router->GetRingRenderDevices(streamUsage, clientUID);
74         CHECK_AND_CONTINUE_LOG(!descs.empty(), "FetchRingRenderDevices is empty.");
75         if (descs.front() != nullptr && descs.front()->deviceType_ != DEVICE_TYPE_NONE) {
76             AUDIO_INFO_LOG("RingRender streamUsage %{public}d clientUID %{public}d"
77                 " fetch descs front:%{public}d", streamUsage, clientUID, descs.front()->deviceType_);
78             routerType = router->GetRouterType();
79             return descs;
80         }
81     }
82     vector<unique_ptr<AudioDeviceDescriptor>> descs;
83     if (streamUsage == STREAM_USAGE_RINGTONE || streamUsage == STREAM_USAGE_VOICE_RINGTONE) {
84         AudioRingerMode curRingerMode = AudioPolicyService::GetAudioPolicyService().GetRingerMode();
85         if (curRingerMode == RINGER_MODE_NORMAL) {
86             descs.push_back(AudioDeviceManager::GetAudioDeviceManager().GetRenderDefaultDevice());
87         } else {
88             descs.push_back(make_unique<AudioDeviceDescriptor>());
89         }
90     } else {
91         descs.push_back(AudioDeviceManager::GetAudioDeviceManager().GetRenderDefaultDevice());
92     }
93     return descs;
94 }
95 
HasScoDevice()96 bool AudioRouterCenter::HasScoDevice()
97 {
98     vector<unique_ptr<AudioDeviceDescriptor>> descs =
99         AudioDeviceManager::GetAudioDeviceManager().GetCommRenderPrivacyDevices();
100     for (auto &desc : descs) {
101         if (desc->deviceType_ == DEVICE_TYPE_BLUETOOTH_SCO) {
102             return true;
103         }
104     }
105 
106     vector<unique_ptr<AudioDeviceDescriptor>> publicDescs =
107         AudioDeviceManager::GetAudioDeviceManager().GetCommRenderPublicDevices();
108     for (auto &desc : publicDescs) {
109         if (desc->deviceType_ == DEVICE_TYPE_BLUETOOTH_SCO && desc->deviceCategory_ == BT_CAR) {
110             return true;
111         }
112     }
113     return false;
114 }
115 
FetchOutputDevices(StreamUsage streamUsage,int32_t clientUID,const RouterType & bypassType)116 std::vector<std::unique_ptr<AudioDeviceDescriptor>> AudioRouterCenter::FetchOutputDevices(StreamUsage streamUsage,
117     int32_t clientUID, const RouterType &bypassType)
118 {
119     vector<unique_ptr<AudioDeviceDescriptor>> descs;
120     RouterType routerType = ROUTER_TYPE_NONE;
121     if (streamUsage == STREAM_USAGE_ULTRASONIC &&
122         AudioStreamCollector::GetAudioStreamCollector().GetRunningStreamUsageNoUltrasonic() == STREAM_USAGE_INVALID) {
123         AUDIO_INFO_LOG("Stream ULTRASONIC always choose spk");
124         descs.push_back(AudioDeviceManager::GetAudioDeviceManager().GetRenderDefaultDevice());
125         return descs;
126     }
127     if (renderConfigMap_[streamUsage] == MEDIA_RENDER_ROUTERS ||
128         renderConfigMap_[streamUsage] == TONE_RENDER_ROUTERS) {
129         AudioScene audioScene = AudioPolicyService::GetAudioPolicyService().GetAudioScene();
130         unique_ptr<AudioDeviceDescriptor> desc = make_unique<AudioDeviceDescriptor>();
131         if (audioScene == AUDIO_SCENE_PHONE_CALL || audioScene == AUDIO_SCENE_PHONE_CHAT ||
132             ((audioScene == AUDIO_SCENE_RINGING || audioScene == AUDIO_SCENE_VOICE_RINGING) && HasScoDevice())) {
133             if (desc->deviceType_ == DEVICE_TYPE_NONE) {
134                 StreamUsage callStreamUsage =
135                     AudioStreamCollector::GetAudioStreamCollector().GetLastestRunningCallStreamUsage();
136                 AUDIO_INFO_LOG("Media follow call strategy, replace usage %{public}d to %{public}d", streamUsage,
137                     callStreamUsage);
138                 desc = FetchCallRenderDevice(callStreamUsage, clientUID, routerType, bypassType);
139             }
140         } else {
141             desc = FetchMediaRenderDevice(streamUsage, clientUID, routerType, bypassType);
142         }
143         descs.push_back(move(desc));
144     } else if (renderConfigMap_[streamUsage] == RING_RENDER_ROUTERS) {
145         DealRingRenderRouters(descs, streamUsage, clientUID, routerType);
146     } else if (renderConfigMap_[streamUsage] == CALL_RENDER_ROUTERS) {
147         descs.push_back(FetchCallRenderDevice(streamUsage, clientUID, routerType, bypassType));
148     } else {
149         AUDIO_INFO_LOG("streamUsage %{public}d didn't config router strategy, skipped", streamUsage);
150         descs.push_back(make_unique<AudioDeviceDescriptor>());
151         return descs;
152     }
153     if (audioDeviceRefinerCb_ != nullptr) {
154         audioDeviceRefinerCb_->OnAudioOutputDeviceRefined(descs, routerType,
155             streamUsage, clientUID, PIPE_TYPE_NORMAL_OUT);
156     }
157     int32_t audioId_ = descs[0]->deviceId_;
158     DeviceType type = descs[0]->deviceType_;
159     AUDIO_PRERELEASE_LOGI("usage:%{public}d uid:%{public}d size:[%{public}zu], 1st type:[%{public}d], id:[%{public}d],"
160         " router:%{public}d ", streamUsage, clientUID, descs.size(), type, audioId_, routerType);
161     return descs;
162 }
163 
DealRingRenderRouters(std::vector<std::unique_ptr<AudioDeviceDescriptor>> & descs,StreamUsage streamUsage,int32_t clientUID,RouterType & routerType)164 void AudioRouterCenter::DealRingRenderRouters(std::vector<std::unique_ptr<AudioDeviceDescriptor>> &descs,
165     StreamUsage streamUsage, int32_t clientUID, RouterType &routerType)
166 {
167     AudioScene audioScene = AudioPolicyService::GetAudioPolicyService().GetAudioScene();
168     StreamUsage callStreamUsage =
169                 AudioStreamCollector::GetAudioStreamCollector().GetLastestRunningCallStreamUsage();
170     bool isVoipStream = AudioStreamCollector::GetAudioStreamCollector().IsCallStreamUsage(callStreamUsage);
171     AUDIO_INFO_LOG("ring render router streamUsage:%{public}d, audioScene:%{public}d, isVoipStream:%{public}d.",
172         streamUsage, audioScene, isVoipStream);
173     if (audioScene == AUDIO_SCENE_PHONE_CALL || audioScene == AUDIO_SCENE_PHONE_CHAT ||
174         (audioScene == AUDIO_SCENE_VOICE_RINGING && isVoipStream)) {
175         unique_ptr<AudioDeviceDescriptor> desc = make_unique<AudioDeviceDescriptor>();
176         if (desc->deviceType_ == DEVICE_TYPE_NONE) {
177             AUDIO_INFO_LOG("Ring follow call strategy, replace usage %{public}d to %{public}d", streamUsage,
178                 callStreamUsage);
179             desc = FetchCallRenderDevice(callStreamUsage, clientUID, routerType);
180         }
181         descs.push_back(move(desc));
182     } else {
183         descs = FetchRingRenderDevices(streamUsage, clientUID, routerType);
184     }
185 }
186 
FetchInputDevice(SourceType sourceType,int32_t clientUID)187 unique_ptr<AudioDeviceDescriptor> AudioRouterCenter::FetchInputDevice(SourceType sourceType, int32_t clientUID)
188 {
189     unique_ptr<AudioDeviceDescriptor> desc = make_unique<AudioDeviceDescriptor>();
190     RouterType routerType = ROUTER_TYPE_NONE;
191     if (sourceType == SOURCE_TYPE_ULTRASONIC &&
192         AudioStreamCollector::GetAudioStreamCollector().GetRunningSourceTypeNoUltrasonic() == SOURCE_TYPE_INVALID) {
193         AUDIO_INFO_LOG("Source ULTRASONIC always choose mic");
194         return AudioDeviceManager::GetAudioDeviceManager().GetCaptureDefaultDevice();
195     }
196     if (capturerConfigMap_[sourceType] == "RecordCaptureRouters") {
197         for (auto &router : recordCaptureRouters_) {
198             desc = router->GetRecordCaptureDevice(sourceType, clientUID);
199             if (desc->deviceType_ != DEVICE_TYPE_NONE) {
200                 routerType = router->GetRouterType();
201                 break;
202             }
203         }
204     } else if (capturerConfigMap_[sourceType] == "CallCaptureRouters") {
205         for (auto &router : callCaptureRouters_) {
206             desc = router->GetCallCaptureDevice(sourceType, clientUID);
207             if (desc->deviceType_ != DEVICE_TYPE_NONE) {
208                 routerType = router->GetRouterType();
209                 break;
210             }
211         }
212     } else if (capturerConfigMap_[sourceType] == "VoiceMessages") {
213         for (auto &router : voiceMessageRouters_) {
214             desc = router->GetRecordCaptureDevice(sourceType, clientUID);
215             if (desc->deviceType_ != DEVICE_TYPE_NONE) {
216                 routerType = router->GetRouterType();
217                 break;
218             }
219         }
220     } else {
221         AUDIO_INFO_LOG("sourceType %{public}d didn't config router strategy, skipped", sourceType);
222         return desc;
223     }
224     vector<unique_ptr<AudioDeviceDescriptor>> descs;
225     descs.push_back(make_unique<AudioDeviceDescriptor>(*desc));
226     if (audioDeviceRefinerCb_ != nullptr) {
227         audioDeviceRefinerCb_->OnAudioInputDeviceRefined(descs, routerType, sourceType, clientUID, PIPE_TYPE_NORMAL_IN);
228     }
229     int32_t audioId_ = descs[0]->deviceId_;
230     DeviceType type = descs[0]->deviceType_;
231     AUDIO_PRERELEASE_LOGI("source:%{public}d uid:%{public}d fetch type:%{public}d id:%{public}d router:%{public}d",
232         sourceType, clientUID, type, audioId_, routerType);
233     return move(descs[0]);
234 }
235 
SetAudioDeviceRefinerCallback(const sptr<IRemoteObject> & object)236 int32_t AudioRouterCenter::SetAudioDeviceRefinerCallback(const sptr<IRemoteObject> &object)
237 {
238     sptr<IStandardAudioRoutingManagerListener> listener = iface_cast<IStandardAudioRoutingManagerListener>(object);
239     if (listener != nullptr) {
240         audioDeviceRefinerCb_ = listener;
241         return SUCCESS;
242     } else {
243         return ERROR;
244     }
245 }
246 
UnsetAudioDeviceRefinerCallback()247 int32_t AudioRouterCenter::UnsetAudioDeviceRefinerCallback()
248 {
249     audioDeviceRefinerCb_ = nullptr;
250     return SUCCESS;
251 }
252 
isCallRenderRouter(StreamUsage streamUsage)253 bool AudioRouterCenter::isCallRenderRouter(StreamUsage streamUsage)
254 {
255     return renderConfigMap_[streamUsage] == CALL_RENDER_ROUTERS;
256 }
257 } // namespace AudioStandard
258 } // namespace OHOS
259