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