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 "PrivacyPriorityRouter"
17 #endif
18
19 #include "privacy_priority_router.h"
20
21 using namespace std;
22
23 namespace OHOS {
24 namespace AudioStandard {
25
GetMediaRenderDevice(StreamUsage streamUsage,int32_t clientUID)26 shared_ptr<AudioDeviceDescriptor> PrivacyPriorityRouter::GetMediaRenderDevice(StreamUsage streamUsage,
27 int32_t clientUID)
28 {
29 vector<shared_ptr<AudioDeviceDescriptor>> descs =
30 AudioDeviceManager::GetAudioDeviceManager().GetMediaRenderPrivacyDevices();
31 shared_ptr<AudioDeviceDescriptor> desc = GetLatestNonExcludedConnectDevice(MEDIA_OUTPUT_DEVICES, descs);
32 AUDIO_DEBUG_LOG("streamUsage %{public}d clientUID %{public}d fetch device %{public}d", streamUsage,
33 clientUID, desc->deviceType_);
34 return desc;
35 }
36
RemoveArmUsb(vector<shared_ptr<AudioDeviceDescriptor>> & descs)37 void PrivacyPriorityRouter::RemoveArmUsb(vector<shared_ptr<AudioDeviceDescriptor>> &descs)
38 {
39 auto isPresent = [] (const shared_ptr<AudioDeviceDescriptor> &desc) {
40 CHECK_AND_RETURN_RET_LOG(desc != nullptr, false, "Invalid device descriptor");
41 return desc->deviceType_ == DEVICE_TYPE_USB_ARM_HEADSET;
42 };
43
44 auto removeBeginIt = std::remove_if(descs.begin(), descs.end(), isPresent);
45 size_t deleteNum = static_cast<uint32_t>(descs.end() - removeBeginIt);
46 descs.erase(removeBeginIt, descs.end());
47 AUDIO_INFO_LOG("Remove %{public}zu desc from privacy list", deleteNum);
48 }
49
GetCallRenderDevice(StreamUsage streamUsage,int32_t clientUID)50 shared_ptr<AudioDeviceDescriptor> PrivacyPriorityRouter::GetCallRenderDevice(StreamUsage streamUsage,
51 int32_t clientUID)
52 {
53 vector<shared_ptr<AudioDeviceDescriptor>> descs =
54 AudioDeviceManager::GetAudioDeviceManager().GetCommRenderPrivacyDevices();
55
56 if (streamUsage == STREAM_USAGE_VOICE_MODEM_COMMUNICATION) {
57 RemoveArmUsb(descs);
58 }
59
60 shared_ptr<AudioDeviceDescriptor> desc = GetLatestNonExcludedConnectDevice(CALL_OUTPUT_DEVICES, descs);
61 AUDIO_DEBUG_LOG("streamUsage %{public}d clientUID %{public}d fetch device %{public}d", streamUsage,
62 clientUID, desc->deviceType_);
63 return desc;
64 }
65
GetCallCaptureDevice(SourceType sourceType,int32_t clientUID)66 shared_ptr<AudioDeviceDescriptor> PrivacyPriorityRouter::GetCallCaptureDevice(SourceType sourceType,
67 int32_t clientUID)
68 {
69 vector<shared_ptr<AudioDeviceDescriptor>> descs =
70 AudioDeviceManager::GetAudioDeviceManager().GetCommCapturePrivacyDevices();
71 shared_ptr<AudioDeviceDescriptor> desc = GetLatestNonExcludedConnectDevice(CALL_INPUT_DEVICES, descs);
72 AUDIO_DEBUG_LOG("sourceType %{public}d clientUID %{public}d fetch device %{public}d", sourceType,
73 clientUID, desc->deviceType_);
74 return desc;
75 }
76
GetRingRenderDevices(StreamUsage streamUsage,int32_t clientUID)77 vector<std::shared_ptr<AudioDeviceDescriptor>> PrivacyPriorityRouter::GetRingRenderDevices(StreamUsage streamUsage,
78 int32_t clientUID)
79 {
80 AudioRingerMode curRingerMode = audioPolicyManager_.GetRingerMode();
81 vector<shared_ptr<AudioDeviceDescriptor>> descs;
82 vector<shared_ptr<AudioDeviceDescriptor>> curDescs;
83 AudioDeviceUsage audioDevUsage = CALL_OUTPUT_DEVICES;
84 if (streamUsage == STREAM_USAGE_VOICE_RINGTONE || streamUsage == STREAM_USAGE_RINGTONE) {
85 curDescs = AudioDeviceManager::GetAudioDeviceManager().GetCommRenderPrivacyDevices();
86 } else {
87 curDescs = AudioDeviceManager::GetAudioDeviceManager().GetMediaRenderPrivacyDevices();
88 audioDevUsage = MEDIA_OUTPUT_DEVICES;
89 }
90
91 shared_ptr<AudioDeviceDescriptor> latestConnDesc = GetLatestNonExcludedConnectDevice(audioDevUsage, curDescs);
92 if (!latestConnDesc.get()) {
93 AUDIO_INFO_LOG("Have no latest connecte desc, just only add default device.");
94 descs.push_back(make_shared<AudioDeviceDescriptor>());
95 return descs;
96 }
97 if (latestConnDesc->getType() == DEVICE_TYPE_NONE) {
98 AUDIO_INFO_LOG("Latest connecte desc type is none, just only add default device.");
99 descs.push_back(make_shared<AudioDeviceDescriptor>());
100 return descs;
101 }
102
103 if (NeedLatestConnectWithDefaultDevices(latestConnDesc->getType())) {
104 // Add the latest connected device.
105 descs.push_back(move(latestConnDesc));
106 switch (streamUsage) {
107 case STREAM_USAGE_ALARM:
108 // Add default device at same time for alarm.
109 descs.push_back(AudioDeviceManager::GetAudioDeviceManager().GetRenderDefaultDevice());
110 break;
111 case STREAM_USAGE_VOICE_RINGTONE:
112 case STREAM_USAGE_RINGTONE:
113 if (curRingerMode == RINGER_MODE_NORMAL) {
114 // Add default devices at same time only in ringer normal mode.
115 descs.push_back(AudioDeviceManager::GetAudioDeviceManager().GetRenderDefaultDevice());
116 }
117 break;
118 default:
119 AUDIO_DEBUG_LOG("Don't add default device at the same time.");
120 break;
121 }
122 } else if (latestConnDesc->getType() != DEVICE_TYPE_NONE) {
123 descs.push_back(move(latestConnDesc));
124 } else {
125 descs.push_back(make_shared<AudioDeviceDescriptor>());
126 }
127 return descs;
128 }
129
GetRecordCaptureDevice(SourceType sourceType,int32_t clientUID)130 shared_ptr<AudioDeviceDescriptor> PrivacyPriorityRouter::GetRecordCaptureDevice(SourceType sourceType,
131 int32_t clientUID)
132 {
133 if (Util::IsScoSupportSource(sourceType)) {
134 vector<shared_ptr<AudioDeviceDescriptor>> descs =
135 AudioDeviceManager::GetAudioDeviceManager().GetRecongnitionCapturePrivacyDevices();
136 shared_ptr<AudioDeviceDescriptor> desc = GetLatestNonExcludedConnectDevice(CALL_INPUT_DEVICES, descs);
137 if (desc->deviceType_ == DEVICE_TYPE_BLUETOOTH_SCO) {
138 AUDIO_DEBUG_LOG("Recognition sourceType %{public}d clientUID %{public}d fetch device %{public}d",
139 sourceType, clientUID, desc->deviceType_);
140 return desc;
141 }
142 }
143 vector<shared_ptr<AudioDeviceDescriptor>> descs =
144 AudioDeviceManager::GetAudioDeviceManager().GetMediaCapturePrivacyDevices();
145 shared_ptr<AudioDeviceDescriptor> desc = GetLatestNonExcludedConnectDevice(MEDIA_INPUT_DEVICES, descs);
146 AUDIO_DEBUG_LOG("sourceType %{public}d clientUID %{public}d fetch device %{public}d", sourceType,
147 clientUID, desc->deviceType_);
148
149 // bluetooth sco device, need skip
150 if (desc == nullptr) {
151 AUDIO_ERR_LOG("nullptr desc");
152 return make_shared<AudioDeviceDescriptor>();
153 }
154 if (desc->deviceType_ == DEVICE_TYPE_BLUETOOTH_SCO) {
155 AUDIO_INFO_LOG("record scene, skip bluetooth sco router");
156 return make_shared<AudioDeviceDescriptor>();
157 }
158
159 return desc;
160 }
161
GetToneRenderDevice(StreamUsage streamUsage,int32_t clientUID)162 shared_ptr<AudioDeviceDescriptor> PrivacyPriorityRouter::GetToneRenderDevice(StreamUsage streamUsage,
163 int32_t clientUID)
164 {
165 return make_shared<AudioDeviceDescriptor>();
166 }
167
168 } // namespace AudioStandard
169 } // namespace OHOS