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 "StreamFilterRouter"
17 #endif
18 
19 #include "stream_filter_router.h"
20 
21 #include "audio_policy_service.h"
22 
23 using namespace std;
24 
25 namespace OHOS {
26 namespace AudioStandard {
27 
GetMediaRenderDevice(StreamUsage streamUsage,int32_t clientUID)28 unique_ptr<AudioDeviceDescriptor> StreamFilterRouter::GetMediaRenderDevice(StreamUsage streamUsage,
29     int32_t clientUID)
30 {
31     DistributedRoutingInfo routingInfo = AudioPolicyService::GetAudioPolicyService().GetDistributedRoutingRoleInfo();
32     if (routingInfo.descriptor != nullptr) {
33         sptr<AudioDeviceDescriptor> deviceDescriptor = routingInfo.descriptor;
34         CastType type = routingInfo.type;
35         bool hasDescriptor = false;
36         AUDIO_INFO_LOG("StreamfilterRouter GetMediaRenderDevice streamUsage %{public}d clientUid %{public}d",
37             streamUsage, clientUID);
38 
39         switch (type) {
40             case CAST_TYPE_NULL: {
41                 break;
42             }
43             case CAST_TYPE_ALL: {
44                 vector<unique_ptr<AudioDeviceDescriptor>> descriptors =
45                     AudioDeviceManager::GetAudioDeviceManager().GetRemoteRenderDevices();
46                 hasDescriptor = IsIncomingDeviceInRemoteDevice(descriptors, deviceDescriptor);
47                 break;
48             }
49             case CAST_TYPE_PROJECTION: {
50                 if (streamUsage == STREAM_USAGE_MUSIC) {
51                     vector<unique_ptr<AudioDeviceDescriptor>> descriptors =
52                         AudioDeviceManager::GetAudioDeviceManager().GetRemoteRenderDevices();
53                     hasDescriptor = IsIncomingDeviceInRemoteDevice(descriptors, deviceDescriptor);
54                 }
55                 break;
56             }
57             case CAST_TYPE_COOPERATION: {
58                 break;
59             }
60             default: {
61                 AUDIO_ERR_LOG("GetMediaRenderDevice unhandled cast type: %{public}d", type);
62                 break;
63             }
64         }
65         if (hasDescriptor) {
66             AUDIO_INFO_LOG("Incoming device is in remote devices");
67             unique_ptr<AudioDeviceDescriptor> incomingDevice = make_unique<AudioDeviceDescriptor>(deviceDescriptor);
68             return incomingDevice;
69         }
70     }
71     return make_unique<AudioDeviceDescriptor>();
72 }
73 
GetCallRenderDevice(StreamUsage streamUsage,int32_t clientUID)74 unique_ptr<AudioDeviceDescriptor> StreamFilterRouter::GetCallRenderDevice(StreamUsage streamUsage,
75     int32_t clientUID)
76 {
77     DistributedRoutingInfo routingInfo = AudioPolicyService::GetAudioPolicyService().GetDistributedRoutingRoleInfo();
78     if (routingInfo.descriptor != nullptr) {
79         sptr<AudioDeviceDescriptor> deviceDescriptor = routingInfo.descriptor;
80         CastType type = routingInfo.type;
81         bool hasDescriptor = false;
82         AUDIO_INFO_LOG("StreamfilterRouter GetCallRenderDevice streamUsage %{public}d clientUid %{public}d",
83             streamUsage, clientUID);
84 
85         switch (type) {
86             case CAST_TYPE_NULL: {
87                 break;
88             }
89             case CAST_TYPE_ALL: {
90                 vector<unique_ptr<AudioDeviceDescriptor>> descriptors =
91                     AudioDeviceManager::GetAudioDeviceManager().GetRemoteRenderDevices();
92                 hasDescriptor = IsIncomingDeviceInRemoteDevice(descriptors, deviceDescriptor);
93                 break;
94             }
95             case CAST_TYPE_PROJECTION: {
96                 break;
97             }
98             case CAST_TYPE_COOPERATION: {
99                 break;
100             }
101             default: {
102                 AUDIO_ERR_LOG("GetCallRenderDevice unhandled cast type: %{public}d", type);
103                 break;
104             }
105         }
106         if (hasDescriptor) {
107             AUDIO_INFO_LOG("Incoming device is in remote devices");
108             unique_ptr<AudioDeviceDescriptor> incomingDevice = make_unique<AudioDeviceDescriptor>(deviceDescriptor);
109             return incomingDevice;
110         }
111     }
112     return make_unique<AudioDeviceDescriptor>();
113 }
114 
GetCallCaptureDevice(SourceType sourceType,int32_t clientUID)115 unique_ptr<AudioDeviceDescriptor> StreamFilterRouter::GetCallCaptureDevice(SourceType sourceType,
116     int32_t clientUID)
117 {
118     DistributedRoutingInfo routingInfo = AudioPolicyService::GetAudioPolicyService().GetDistributedRoutingRoleInfo();
119     if (routingInfo.descriptor != nullptr) {
120         sptr<AudioDeviceDescriptor> deviceDescriptor = routingInfo.descriptor;
121         CastType type = routingInfo.type;
122         bool hasDescriptor = false;
123         AUDIO_INFO_LOG("StreamfilterRouter GetCallCaptureDevice sourceType %{public}d clientUid %{public}d",
124             sourceType, clientUID);
125         switch (type) {
126             case CAST_TYPE_NULL: {
127                 break;
128             }
129             case CAST_TYPE_ALL: {
130                 vector<unique_ptr<AudioDeviceDescriptor>> descriptors =
131                     AudioDeviceManager::GetAudioDeviceManager().GetRemoteCaptureDevices();
132                 hasDescriptor = IsIncomingDeviceInRemoteDevice(descriptors, deviceDescriptor);
133                 break;
134             }
135             case CAST_TYPE_PROJECTION: {
136                 break;
137             }
138             case CAST_TYPE_COOPERATION: {
139                 break;
140             }
141             default: {
142                 AUDIO_ERR_LOG("GetCallCaptureDevice unhandled cast type: %{public}d", type);
143                 break;
144             }
145         }
146         if (hasDescriptor) {
147             AUDIO_INFO_LOG("Incoming device is in remote devices");
148             unique_ptr<AudioDeviceDescriptor> incomingDevice = make_unique<AudioDeviceDescriptor>(deviceDescriptor);
149             return incomingDevice;
150         }
151     }
152     return make_unique<AudioDeviceDescriptor>();
153 }
154 
GetRingRenderDevices(StreamUsage streamUsage,int32_t clientUID)155 vector<std::unique_ptr<AudioDeviceDescriptor>> StreamFilterRouter::GetRingRenderDevices(StreamUsage streamUsage,
156     int32_t clientUID)
157 {
158     vector<unique_ptr<AudioDeviceDescriptor>> descs;
159     return descs;
160 }
161 
GetRecordCaptureDevice(SourceType sourceType,int32_t clientUID)162 unique_ptr<AudioDeviceDescriptor> StreamFilterRouter::GetRecordCaptureDevice(SourceType sourceType,
163     int32_t clientUID)
164 {
165     DistributedRoutingInfo routingInfo = AudioPolicyService::GetAudioPolicyService().GetDistributedRoutingRoleInfo();
166     if (routingInfo.descriptor != nullptr) {
167         sptr<AudioDeviceDescriptor> deviceDescriptor = routingInfo.descriptor;
168         CastType type = routingInfo.type;
169         bool hasDescriptor = false;
170         unique_ptr<AudioDeviceDescriptor> captureDevice;
171         AUDIO_INFO_LOG("StreamfilterRouter GetRecordCaptureDevice sourceType %{public}d clientUid %{public}d",
172             sourceType, clientUID);
173         switch (type) {
174             case CAST_TYPE_NULL: {
175                 break;
176             }
177             case CAST_TYPE_ALL: {
178                 vector<unique_ptr<AudioDeviceDescriptor>> descriptors =
179                     AudioDeviceManager::GetAudioDeviceManager().GetRemoteCaptureDevices();
180                 captureDevice = SelectRemoteCaptureDevice(descriptors, deviceDescriptor, hasDescriptor);
181                 break;
182             }
183             case CAST_TYPE_PROJECTION: {
184                 if (sourceType == SOURCE_TYPE_MIC) {
185                     vector<unique_ptr<AudioDeviceDescriptor>> descriptors =
186                         AudioDeviceManager::GetAudioDeviceManager().GetRemoteCaptureDevices();
187                     captureDevice = SelectRemoteCaptureDevice(descriptors, deviceDescriptor, hasDescriptor);
188                 }
189                 break;
190             }
191             case CAST_TYPE_COOPERATION: {
192                 break;
193             }
194             default: {
195                 AUDIO_ERR_LOG("GetRecordCaptureDevice unhandled cast type: %{public}d", type);
196                 break;
197             }
198         }
199         if (hasDescriptor) {
200             AUDIO_INFO_LOG("Incoming device is in remote devices");
201             return captureDevice;
202         }
203     }
204     return make_unique<AudioDeviceDescriptor>();
205 }
206 
GetToneRenderDevice(StreamUsage streamUsage,int32_t clientUID)207 unique_ptr<AudioDeviceDescriptor> StreamFilterRouter::GetToneRenderDevice(StreamUsage streamUsage,
208     int32_t clientUID)
209 {
210     return make_unique<AudioDeviceDescriptor>();
211 }
212 
IsIncomingDeviceInRemoteDevice(vector<unique_ptr<AudioDeviceDescriptor>> & descriptors,sptr<AudioDeviceDescriptor> incomingDevice)213 bool StreamFilterRouter::IsIncomingDeviceInRemoteDevice(vector<unique_ptr<AudioDeviceDescriptor>> &descriptors,
214     sptr<AudioDeviceDescriptor> incomingDevice)
215 {
216     for (const auto &desc : descriptors) {
217         if (desc != nullptr) {
218             if (desc->deviceRole_ == incomingDevice->deviceRole_ &&
219                 desc->deviceType_ == incomingDevice->deviceType_ &&
220                 desc->interruptGroupId_ == incomingDevice->interruptGroupId_ &&
221                 desc->volumeGroupId_ == incomingDevice->volumeGroupId_ &&
222                 desc->networkId_ == incomingDevice->networkId_ &&
223                 desc->macAddress_ == incomingDevice->macAddress_) {
224                 return true;
225             }
226         }
227     }
228     return false;
229 }
230 
SelectRemoteCaptureDevice(vector<unique_ptr<AudioDeviceDescriptor>> & descriptors,sptr<AudioDeviceDescriptor> incomingDevice,bool & hasDescriptor)231 std::unique_ptr<AudioDeviceDescriptor> StreamFilterRouter::SelectRemoteCaptureDevice(
232     vector<unique_ptr<AudioDeviceDescriptor>> &descriptors, sptr<AudioDeviceDescriptor> incomingDevice,
233     bool &hasDescriptor)
234 {
235     for (auto &descriptor : descriptors) {
236         if (descriptor != nullptr &&
237             descriptor->networkId_ == incomingDevice->networkId_ &&
238             descriptor->deviceRole_ == INPUT_DEVICE &&
239             descriptor->deviceType_ == DEVICE_TYPE_MIC) {
240             hasDescriptor = true;
241             return make_unique<AudioDeviceDescriptor>(*descriptor);
242         }
243     }
244     return make_unique<AudioDeviceDescriptor>();
245 }
246 } // namespace AudioStandard
247 } // namespace OHOS