blob: 8c71336926cabf53bbc9033dc5426ee184450cc7 [file] [log] [blame]
François Gaffie2110e042015-03-24 08:41:51 +01001/*
2 * Copyright (C) 2015 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#define LOG_TAG "APM::AudioPolicyEngine"
18//#define LOG_NDEBUG 0
19
20//#define VERY_VERBOSE_LOGGING
21#ifdef VERY_VERBOSE_LOGGING
22#define ALOGVV ALOGV
23#else
24#define ALOGVV(a...) do { } while(0)
25#endif
26
27#include "Engine.h"
Chih-Hung Hsieh2b487032018-09-13 14:16:02 -070028#include <android-base/macros.h>
François Gaffie2110e042015-03-24 08:41:51 +010029#include <AudioPolicyManagerObserver.h>
jiabine1284852019-09-11 10:15:46 -070030#include <PolicyAudioPort.h>
François Gaffie2110e042015-03-24 08:41:51 +010031#include <IOProfile.h>
François Gaffiec005e562018-11-06 15:04:49 +010032#include <AudioIODescriptorInterface.h>
François Gaffie2110e042015-03-24 08:41:51 +010033#include <policy.h>
jiabin9a3361e2019-10-01 09:38:30 -070034#include <media/AudioContainers.h>
François Gaffie2110e042015-03-24 08:41:51 +010035#include <utils/String8.h>
36#include <utils/Log.h>
37
38namespace android
39{
40namespace audio_policy
41{
42
François Gaffiedc7553f2018-11-02 10:39:57 +010043struct legacy_strategy_map { const char *name; legacy_strategy id; };
Mikhail Naganovf9003622020-03-10 13:15:08 -070044static const std::vector<legacy_strategy_map>& getLegacyStrategy() {
45 static const std::vector<legacy_strategy_map> legacyStrategy = {
46 { "STRATEGY_NONE", STRATEGY_NONE },
47 { "STRATEGY_MEDIA", STRATEGY_MEDIA },
48 { "STRATEGY_PHONE", STRATEGY_PHONE },
49 { "STRATEGY_SONIFICATION", STRATEGY_SONIFICATION },
50 { "STRATEGY_SONIFICATION_RESPECTFUL", STRATEGY_SONIFICATION_RESPECTFUL },
51 { "STRATEGY_DTMF", STRATEGY_DTMF },
52 { "STRATEGY_ENFORCED_AUDIBLE", STRATEGY_ENFORCED_AUDIBLE },
53 { "STRATEGY_TRANSMITTED_THROUGH_SPEAKER", STRATEGY_TRANSMITTED_THROUGH_SPEAKER },
54 { "STRATEGY_ACCESSIBILITY", STRATEGY_ACCESSIBILITY },
55 { "STRATEGY_REROUTING", STRATEGY_REROUTING },
56 { "STRATEGY_PATCH", STRATEGY_REROUTING }, // boiler to manage stream patch volume
57 { "STRATEGY_CALL_ASSISTANT", STRATEGY_CALL_ASSISTANT },
58 };
59 return legacyStrategy;
60}
François Gaffiedc7553f2018-11-02 10:39:57 +010061
François Gaffie2110e042015-03-24 08:41:51 +010062Engine::Engine()
François Gaffie2110e042015-03-24 08:41:51 +010063{
François Gaffiedc7553f2018-11-02 10:39:57 +010064 auto result = EngineBase::loadAudioPolicyEngineConfig();
65 ALOGE_IF(result.nbSkippedElement != 0,
66 "Policy Engine configuration is partially invalid, skipped %zu elements",
67 result.nbSkippedElement);
68
Mikhail Naganovf9003622020-03-10 13:15:08 -070069 auto legacyStrategy = getLegacyStrategy();
70 for (const auto &strategy : legacyStrategy) {
François Gaffiedc7553f2018-11-02 10:39:57 +010071 mLegacyStrategyMap[getProductStrategyByName(strategy.name)] = strategy.id;
François Gaffie2110e042015-03-24 08:41:51 +010072 }
73}
74
François Gaffie2110e042015-03-24 08:41:51 +010075status_t Engine::setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config)
76{
77 switch(usage) {
78 case AUDIO_POLICY_FORCE_FOR_COMMUNICATION:
79 if (config != AUDIO_POLICY_FORCE_SPEAKER && config != AUDIO_POLICY_FORCE_BT_SCO &&
80 config != AUDIO_POLICY_FORCE_NONE) {
81 ALOGW("setForceUse() invalid config %d for FOR_COMMUNICATION", config);
82 return BAD_VALUE;
83 }
François Gaffie2110e042015-03-24 08:41:51 +010084 break;
85 case AUDIO_POLICY_FORCE_FOR_MEDIA:
86 if (config != AUDIO_POLICY_FORCE_HEADPHONES && config != AUDIO_POLICY_FORCE_BT_A2DP &&
87 config != AUDIO_POLICY_FORCE_WIRED_ACCESSORY &&
88 config != AUDIO_POLICY_FORCE_ANALOG_DOCK &&
89 config != AUDIO_POLICY_FORCE_DIGITAL_DOCK && config != AUDIO_POLICY_FORCE_NONE &&
90 config != AUDIO_POLICY_FORCE_NO_BT_A2DP && config != AUDIO_POLICY_FORCE_SPEAKER ) {
91 ALOGW("setForceUse() invalid config %d for FOR_MEDIA", config);
92 return BAD_VALUE;
93 }
François Gaffie2110e042015-03-24 08:41:51 +010094 break;
95 case AUDIO_POLICY_FORCE_FOR_RECORD:
96 if (config != AUDIO_POLICY_FORCE_BT_SCO && config != AUDIO_POLICY_FORCE_WIRED_ACCESSORY &&
97 config != AUDIO_POLICY_FORCE_NONE) {
98 ALOGW("setForceUse() invalid config %d for FOR_RECORD", config);
99 return BAD_VALUE;
100 }
François Gaffie2110e042015-03-24 08:41:51 +0100101 break;
102 case AUDIO_POLICY_FORCE_FOR_DOCK:
103 if (config != AUDIO_POLICY_FORCE_NONE && config != AUDIO_POLICY_FORCE_BT_CAR_DOCK &&
104 config != AUDIO_POLICY_FORCE_BT_DESK_DOCK &&
105 config != AUDIO_POLICY_FORCE_WIRED_ACCESSORY &&
106 config != AUDIO_POLICY_FORCE_ANALOG_DOCK &&
107 config != AUDIO_POLICY_FORCE_DIGITAL_DOCK) {
108 ALOGW("setForceUse() invalid config %d for FOR_DOCK", config);
109 }
François Gaffie2110e042015-03-24 08:41:51 +0100110 break;
111 case AUDIO_POLICY_FORCE_FOR_SYSTEM:
112 if (config != AUDIO_POLICY_FORCE_NONE &&
113 config != AUDIO_POLICY_FORCE_SYSTEM_ENFORCED) {
114 ALOGW("setForceUse() invalid config %d for FOR_SYSTEM", config);
115 }
François Gaffie2110e042015-03-24 08:41:51 +0100116 break;
117 case AUDIO_POLICY_FORCE_FOR_HDMI_SYSTEM_AUDIO:
118 if (config != AUDIO_POLICY_FORCE_NONE &&
119 config != AUDIO_POLICY_FORCE_HDMI_SYSTEM_AUDIO_ENFORCED) {
Phil Burk09bc4612016-02-24 15:58:15 -0800120 ALOGW("setForceUse() invalid config %d for HDMI_SYSTEM_AUDIO", config);
121 }
Phil Burk09bc4612016-02-24 15:58:15 -0800122 break;
123 case AUDIO_POLICY_FORCE_FOR_ENCODED_SURROUND:
124 if (config != AUDIO_POLICY_FORCE_NONE &&
125 config != AUDIO_POLICY_FORCE_ENCODED_SURROUND_NEVER &&
jiabin81772902018-04-02 17:52:27 -0700126 config != AUDIO_POLICY_FORCE_ENCODED_SURROUND_ALWAYS &&
127 config != AUDIO_POLICY_FORCE_ENCODED_SURROUND_MANUAL) {
Phil Burk09bc4612016-02-24 15:58:15 -0800128 ALOGW("setForceUse() invalid config %d for ENCODED_SURROUND", config);
129 return BAD_VALUE;
François Gaffie2110e042015-03-24 08:41:51 +0100130 }
François Gaffie2110e042015-03-24 08:41:51 +0100131 break;
Jack He96117ae2018-02-12 20:52:53 -0800132 case AUDIO_POLICY_FORCE_FOR_VIBRATE_RINGING:
133 if (config != AUDIO_POLICY_FORCE_BT_SCO && config != AUDIO_POLICY_FORCE_NONE) {
134 ALOGW("setForceUse() invalid config %d for FOR_VIBRATE_RINGING", config);
135 return BAD_VALUE;
136 }
Jack He96117ae2018-02-12 20:52:53 -0800137 break;
François Gaffie2110e042015-03-24 08:41:51 +0100138 default:
139 ALOGW("setForceUse() invalid usage %d", usage);
Phil Burk09bc4612016-02-24 15:58:15 -0800140 break; // TODO return BAD_VALUE?
François Gaffie2110e042015-03-24 08:41:51 +0100141 }
François Gaffiedc7553f2018-11-02 10:39:57 +0100142 return EngineBase::setForceUse(usage, config);
François Gaffie2110e042015-03-24 08:41:51 +0100143}
144
Eric Laurent2802b862021-03-01 09:36:16 +0100145void Engine::filterOutputDevicesForStrategy(legacy_strategy strategy,
146 DeviceVector& availableOutputDevices,
Eric Laurent2802b862021-03-01 09:36:16 +0100147 const SwAudioOutputCollection &outputs) const
Eric Laurent28d09f02016-03-08 10:43:05 -0800148{
Eric Laurent6cd5f902021-03-23 18:29:58 +0100149 DeviceVector availableInputDevices = getApmObserver()->getAvailableInputDevices();
150
François Gaffie2110e042015-03-24 08:41:51 +0100151 switch (strategy) {
Eric Laurent2802b862021-03-01 09:36:16 +0100152 case STRATEGY_SONIFICATION_RESPECTFUL: {
153 if (!(isInCall() || outputs.isActiveLocally(toVolumeSource(AUDIO_STREAM_VOICE_CALL)))) {
Jean-Michel Trivi61309522018-01-23 09:58:17 -0800154 // routing is same as media without the "remote" device
jiabin9a3361e2019-10-01 09:38:30 -0700155 availableOutputDevices.remove(availableOutputDevices.getDevicesFromType(
jiabinf502d152019-08-07 14:43:33 -0700156 AUDIO_DEVICE_OUT_REMOTE_SUBMIX));
François Gaffie2110e042015-03-24 08:41:51 +0100157 }
Eric Laurent2802b862021-03-01 09:36:16 +0100158 } break;
François Gaffie2110e042015-03-24 08:41:51 +0100159 case STRATEGY_DTMF:
Eric Laurent2517af32020-11-25 15:31:27 +0100160 case STRATEGY_PHONE: {
François Gaffie2110e042015-03-24 08:41:51 +0100161 // Force use of only devices on primary output if:
162 // - in call AND
163 // - cannot route from voice call RX OR
164 // - audio HAL version is < 3.0 and TX device is on the primary HW module
165 if (getPhoneState() == AUDIO_MODE_IN_CALL) {
jiabinf502d152019-08-07 14:43:33 -0700166 audio_devices_t txDevice = getDeviceForInputSource(
167 AUDIO_SOURCE_VOICE_COMMUNICATION)->type();
François Gaffie2110e042015-03-24 08:41:51 +0100168 sp<AudioOutputDescriptor> primaryOutput = outputs.getPrimaryOutput();
jiabinb6b07482019-09-26 18:05:18 -0700169 LOG_ALWAYS_FATAL_IF(primaryOutput == nullptr, "Primary output not found");
jiabinf502d152019-08-07 14:43:33 -0700170 DeviceVector availPrimaryInputDevices =
171 availableInputDevices.getDevicesFromHwModule(primaryOutput->getModuleHandle());
Eric Laurent58a73fc2018-02-21 18:46:13 -0800172
173 // TODO: getPrimaryOutput return only devices from first module in
174 // audio_policy_configuration.xml, hearing aid is not there, but it's
175 // a primary device
176 // FIXME: this is not the right way of solving this problem
jiabin9a3361e2019-10-01 09:38:30 -0700177 DeviceVector availPrimaryOutputDevices = availableOutputDevices.getDevicesFromTypes(
jiabinf502d152019-08-07 14:43:33 -0700178 primaryOutput->supportedDevices().types());
179 availPrimaryOutputDevices.add(
jiabin9a3361e2019-10-01 09:38:30 -0700180 availableOutputDevices.getDevicesFromType(AUDIO_DEVICE_OUT_HEARING_AID));
François Gaffie2110e042015-03-24 08:41:51 +0100181
jiabinf502d152019-08-07 14:43:33 -0700182 if ((availableInputDevices.getDevice(AUDIO_DEVICE_IN_TELEPHONY_RX,
Eric Laurent2517af32020-11-25 15:31:27 +0100183 String8(""), AUDIO_FORMAT_DEFAULT) == nullptr) ||
184 ((availPrimaryInputDevices.getDevice(
185 txDevice, String8(""), AUDIO_FORMAT_DEFAULT) != nullptr) &&
186 (primaryOutput->getPolicyAudioPort()->getModuleVersionMajor() < 3))) {
jiabinf502d152019-08-07 14:43:33 -0700187 availableOutputDevices = availPrimaryOutputDevices;
François Gaffie2110e042015-03-24 08:41:51 +0100188 }
Eric Laurent8f2f4e92021-05-17 14:42:27 +0200189
Eric Laurent97cec6f2021-05-20 13:52:47 +0200190 }
191 // Do not use A2DP devices when in call but use them when not in call
192 // (e.g for voice mail playback)
193 if (isInCall()) {
Eric Laurent8f2f4e92021-05-17 14:42:27 +0200194 availableOutputDevices.remove(availableOutputDevices.getDevicesFromTypes({
195 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP, AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES,
196 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER, }));
François Gaffie2110e042015-03-24 08:41:51 +0100197 }
Eric Laurent802ad1d2022-07-01 16:54:43 +0200198 // If connected to a dock, never use the device speaker for calls
199 if (!availableOutputDevices.getDevicesFromTypes({AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET})
200 .isEmpty()) {
201 availableOutputDevices.remove(
202 availableOutputDevices.getDevicesFromTypes({AUDIO_DEVICE_OUT_SPEAKER}));
203 }
Eric Laurent2802b862021-03-01 09:36:16 +0100204 } break;
205 case STRATEGY_ACCESSIBILITY: {
206 // do not route accessibility prompts to a digital output currently configured with a
207 // compressed format as they would likely not be mixed and dropped.
208 for (size_t i = 0; i < outputs.size(); i++) {
209 sp<AudioOutputDescriptor> desc = outputs.valueAt(i);
210 if (desc->isActive() && !audio_is_linear_pcm(desc->getFormat())) {
211 availableOutputDevices.remove(desc->devices().getDevicesFromTypes({
212 AUDIO_DEVICE_OUT_HDMI, AUDIO_DEVICE_OUT_SPDIF,
Kuowei Li01a686b2020-10-27 16:54:39 +0800213 AUDIO_DEVICE_OUT_HDMI_ARC, AUDIO_DEVICE_OUT_HDMI_EARC}));
Eric Laurent2802b862021-03-01 09:36:16 +0100214 }
215 }
216 } break;
217 default:
218 break;
219 }
220}
221
Eric Laurent6cd5f902021-03-23 18:29:58 +0100222product_strategy_t Engine::remapStrategyFromContext(product_strategy_t strategy,
223 const SwAudioOutputCollection &outputs) const {
224 auto legacyStrategy = mLegacyStrategyMap.find(strategy) != end(mLegacyStrategyMap) ?
225 mLegacyStrategyMap.at(strategy) : STRATEGY_NONE;
226
227 if (isInCall()) {
228 switch (legacyStrategy) {
229 case STRATEGY_ACCESSIBILITY:
230 case STRATEGY_DTMF:
231 case STRATEGY_MEDIA:
232 case STRATEGY_SONIFICATION:
233 case STRATEGY_SONIFICATION_RESPECTFUL:
234 legacyStrategy = STRATEGY_PHONE;
235 break;
236
237 default:
238 return strategy;
239 }
240 } else {
241 switch (legacyStrategy) {
242 case STRATEGY_SONIFICATION_RESPECTFUL:
243 case STRATEGY_SONIFICATION:
244 if (outputs.isActiveLocally(toVolumeSource(AUDIO_STREAM_VOICE_CALL))) {
245 legacyStrategy = STRATEGY_PHONE;
246 }
247 break;
248
249 case STRATEGY_ACCESSIBILITY:
250 if (outputs.isActive(toVolumeSource(AUDIO_STREAM_RING)) ||
251 outputs.isActive(toVolumeSource(AUDIO_STREAM_ALARM))) {
252 legacyStrategy = STRATEGY_SONIFICATION;
253 }
254 break;
255
256 default:
257 return strategy;
258 }
259 }
260 return getProductStrategyFromLegacy(legacyStrategy);
261}
262
Eric Laurent2802b862021-03-01 09:36:16 +0100263DeviceVector Engine::getDevicesForStrategyInt(legacy_strategy strategy,
264 DeviceVector availableOutputDevices,
Eric Laurent2802b862021-03-01 09:36:16 +0100265 const SwAudioOutputCollection &outputs) const
266{
267 DeviceVector devices;
268
269 switch (strategy) {
270
271 case STRATEGY_TRANSMITTED_THROUGH_SPEAKER:
272 devices = availableOutputDevices.getDevicesFromType(AUDIO_DEVICE_OUT_SPEAKER);
273 break;
274
Eric Laurent2802b862021-03-01 09:36:16 +0100275 case STRATEGY_PHONE: {
Lorena Torres-Huerta208cfff2022-08-24 19:18:53 +0000276 // TODO(b/243670205): remove this logic that gives preference to last removable devices
277 // once a UX decision has been made
Eric Laurentc0697592021-05-10 11:45:22 +0200278 devices = availableOutputDevices.getFirstDevicesFromTypes(
Lorena Torres-Huerta208cfff2022-08-24 19:18:53 +0000279 getLastRemovableMediaDevices(GROUP_NONE, {
280 // excluding HEARING_AID and BLE_HEADSET because Dialer uses
281 // setCommunicationDevice to select them explicitly
282 AUDIO_DEVICE_OUT_HEARING_AID,
283 AUDIO_DEVICE_OUT_BLE_HEADSET
284 }));
Eric Laurent2517af32020-11-25 15:31:27 +0100285 if (!devices.isEmpty()) break;
Eric Laurent454a2cc2022-01-26 11:56:13 +0100286 devices = availableOutputDevices.getFirstDevicesFromTypes({
287 AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET, AUDIO_DEVICE_OUT_EARPIECE});
Eric Laurent2517af32020-11-25 15:31:27 +0100288 } break;
François Gaffie2110e042015-03-24 08:41:51 +0100289
290 case STRATEGY_SONIFICATION:
François Gaffie2110e042015-03-24 08:41:51 +0100291 case STRATEGY_ENFORCED_AUDIBLE:
292 // strategy STRATEGY_ENFORCED_AUDIBLE uses same routing policy as STRATEGY_SONIFICATION
293 // except:
294 // - when in call where it doesn't default to STRATEGY_PHONE behavior
295 // - in countries where not enforced in which case it follows STRATEGY_MEDIA
296
297 if ((strategy == STRATEGY_SONIFICATION) ||
François Gaffiedc7553f2018-11-02 10:39:57 +0100298 (getForceUse(AUDIO_POLICY_FORCE_FOR_SYSTEM) == AUDIO_POLICY_FORCE_SYSTEM_ENFORCED)) {
jiabin9a3361e2019-10-01 09:38:30 -0700299 devices = availableOutputDevices.getDevicesFromType(AUDIO_DEVICE_OUT_SPEAKER);
François Gaffie2110e042015-03-24 08:41:51 +0100300 }
Eric Laurenta8e0f022017-01-27 17:41:53 -0800301
302 // if SCO headset is connected and we are told to use it, play ringtone over
303 // speaker and BT SCO
jiabin9a3361e2019-10-01 09:38:30 -0700304 if (!availableOutputDevices.getDevicesFromTypes(getAudioDeviceOutAllScoSet()).isEmpty()) {
jiabinf502d152019-08-07 14:43:33 -0700305 DeviceVector devices2;
306 devices2 = availableOutputDevices.getFirstDevicesFromTypes({
307 AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT, AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET,
308 AUDIO_DEVICE_OUT_BLUETOOTH_SCO});
Jack He96117ae2018-02-12 20:52:53 -0800309 // Use ONLY Bluetooth SCO output when ringing in vibration mode
François Gaffiedc7553f2018-11-02 10:39:57 +0100310 if (!((getForceUse(AUDIO_POLICY_FORCE_FOR_SYSTEM) == AUDIO_POLICY_FORCE_SYSTEM_ENFORCED)
Jack He96117ae2018-02-12 20:52:53 -0800311 && (strategy == STRATEGY_ENFORCED_AUDIBLE))) {
François Gaffiedc7553f2018-11-02 10:39:57 +0100312 if (getForceUse(AUDIO_POLICY_FORCE_FOR_VIBRATE_RINGING)
Jack He96117ae2018-02-12 20:52:53 -0800313 == AUDIO_POLICY_FORCE_BT_SCO) {
jiabinf502d152019-08-07 14:43:33 -0700314 if (!devices2.isEmpty()) {
315 devices = devices2;
Jack He96117ae2018-02-12 20:52:53 -0800316 break;
317 }
318 }
319 }
320 // Use both Bluetooth SCO and phone default output when ringing in normal mode
Eric Laurent2517af32020-11-25 15:31:27 +0100321 if (audio_is_bluetooth_out_sco_device(getPreferredDeviceTypeForLegacyStrategy(
322 availableOutputDevices, STRATEGY_PHONE))) {
jiabinf502d152019-08-07 14:43:33 -0700323 if (strategy == STRATEGY_SONIFICATION) {
324 devices.replaceDevicesByType(
325 AUDIO_DEVICE_OUT_SPEAKER,
jiabin9a3361e2019-10-01 09:38:30 -0700326 availableOutputDevices.getDevicesFromType(
jiabinf502d152019-08-07 14:43:33 -0700327 AUDIO_DEVICE_OUT_SPEAKER_SAFE));
juyuchen5fa0aed2018-05-16 10:58:37 +0800328 }
jiabinf502d152019-08-07 14:43:33 -0700329 if (!devices2.isEmpty()) {
330 devices.add(devices2);
Jack He96117ae2018-02-12 20:52:53 -0800331 break;
332 }
Eric Laurenta8e0f022017-01-27 17:41:53 -0800333 }
334 }
François Gaffie2110e042015-03-24 08:41:51 +0100335 // The second device used for sonification is the same as the device used by media strategy
Chih-Hung Hsieh2b487032018-09-13 14:16:02 -0700336 FALLTHROUGH_INTENDED;
François Gaffie2110e042015-03-24 08:41:51 +0100337
Eric Laurent6cd5f902021-03-23 18:29:58 +0100338 case STRATEGY_DTMF:
François Gaffie2110e042015-03-24 08:41:51 +0100339 case STRATEGY_ACCESSIBILITY:
Eric Laurent6cd5f902021-03-23 18:29:58 +0100340 case STRATEGY_SONIFICATION_RESPECTFUL:
François Gaffie2110e042015-03-24 08:41:51 +0100341 case STRATEGY_REROUTING:
342 case STRATEGY_MEDIA: {
jiabinf502d152019-08-07 14:43:33 -0700343 DeviceVector devices2;
François Gaffie2110e042015-03-24 08:41:51 +0100344 if (strategy != STRATEGY_SONIFICATION) {
345 // no sonification on remote submix (e.g. WFD)
jiabinf502d152019-08-07 14:43:33 -0700346 sp<DeviceDescriptor> remoteSubmix;
347 if ((remoteSubmix = availableOutputDevices.getDevice(
348 AUDIO_DEVICE_OUT_REMOTE_SUBMIX, String8("0"),
349 AUDIO_FORMAT_DEFAULT)) != nullptr) {
350 devices2.add(remoteSubmix);
François Gaffie2110e042015-03-24 08:41:51 +0100351 }
352 }
Eric Laurenta9986862020-10-07 08:42:28 -0700353
jiabinf502d152019-08-07 14:43:33 -0700354 if ((devices2.isEmpty()) &&
François Gaffiedc7553f2018-11-02 10:39:57 +0100355 (getForceUse(AUDIO_POLICY_FORCE_FOR_MEDIA) == AUDIO_POLICY_FORCE_SPEAKER)) {
jiabin9a3361e2019-10-01 09:38:30 -0700356 devices2 = availableOutputDevices.getDevicesFromType(AUDIO_DEVICE_OUT_SPEAKER);
François Gaffie2110e042015-03-24 08:41:51 +0100357 }
Eric Laurent96d1dda2022-03-14 17:14:19 +0100358
359 // LE audio broadcast device is only used if:
360 // - No call is active
361 // - either MEDIA or SONIFICATION_RESPECTFUL is the highest priority active strategy
362 // OR the LE audio unicast device is not active
363 if (devices2.isEmpty() && !isInCall()
364 && (strategy == STRATEGY_MEDIA || strategy == STRATEGY_SONIFICATION_RESPECTFUL)) {
365 legacy_strategy topActiveStrategy = STRATEGY_NONE;
366 for (const auto &ps : getOrderedProductStrategies()) {
367 if (outputs.isStrategyActive(ps)) {
368 topActiveStrategy = mLegacyStrategyMap.find(ps) != end(mLegacyStrategyMap) ?
369 mLegacyStrategyMap.at(ps) : STRATEGY_NONE;
370 break;
371 }
372 }
373
374 if (topActiveStrategy == STRATEGY_NONE || topActiveStrategy == STRATEGY_MEDIA
375 || topActiveStrategy == STRATEGY_SONIFICATION_RESPECTFUL
376 || !outputs.isAnyDeviceTypeActive(getAudioDeviceOutLeAudioUnicastSet())) {
377 devices2 =
378 availableOutputDevices.getDevicesFromType(AUDIO_DEVICE_OUT_BLE_BROADCAST);
379 }
380 }
381
Baekgyeong Kim08451522019-11-01 20:40:02 +0900382 if (devices2.isEmpty() && (getLastRemovableMediaDevices().size() > 0)) {
Eric Laurenta9986862020-10-07 08:42:28 -0700383 if ((getForceUse(AUDIO_POLICY_FORCE_FOR_MEDIA) != AUDIO_POLICY_FORCE_NO_BT_A2DP)) {
Baekgyeong Kim08451522019-11-01 20:40:02 +0900384 // Get the last connected device of wired and bluetooth a2dp
385 devices2 = availableOutputDevices.getFirstDevicesFromTypes(
386 getLastRemovableMediaDevices());
387 } else {
388 // Get the last connected device of wired except bluetooth a2dp
389 devices2 = availableOutputDevices.getFirstDevicesFromTypes(
390 getLastRemovableMediaDevices(GROUP_WIRED));
391 }
François Gaffie2110e042015-03-24 08:41:51 +0100392 }
jiabinf502d152019-08-07 14:43:33 -0700393 if ((devices2.isEmpty()) && (strategy != STRATEGY_SONIFICATION)) {
François Gaffie2110e042015-03-24 08:41:51 +0100394 // no sonification on aux digital (e.g. HDMI)
jiabin9a3361e2019-10-01 09:38:30 -0700395 devices2 = availableOutputDevices.getDevicesFromType(AUDIO_DEVICE_OUT_AUX_DIGITAL);
François Gaffie2110e042015-03-24 08:41:51 +0100396 }
jiabinf502d152019-08-07 14:43:33 -0700397 if ((devices2.isEmpty()) &&
François Gaffiedc7553f2018-11-02 10:39:57 +0100398 (getForceUse(AUDIO_POLICY_FORCE_FOR_DOCK) == AUDIO_POLICY_FORCE_ANALOG_DOCK)) {
jiabin9a3361e2019-10-01 09:38:30 -0700399 devices2 = availableOutputDevices.getDevicesFromType(
jiabinf502d152019-08-07 14:43:33 -0700400 AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET);
François Gaffie2110e042015-03-24 08:41:51 +0100401 }
jiabinf502d152019-08-07 14:43:33 -0700402 if (devices2.isEmpty()) {
Eric Laurent454a2cc2022-01-26 11:56:13 +0100403 devices2 = availableOutputDevices.getFirstDevicesFromTypes({
404 AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET, AUDIO_DEVICE_OUT_SPEAKER});
François Gaffie2110e042015-03-24 08:41:51 +0100405 }
jiabinf502d152019-08-07 14:43:33 -0700406 DeviceVector devices3;
François Gaffie2110e042015-03-24 08:41:51 +0100407 if (strategy == STRATEGY_MEDIA) {
408 // ARC, SPDIF and AUX_LINE can co-exist with others.
jiabin9a3361e2019-10-01 09:38:30 -0700409 devices3 = availableOutputDevices.getDevicesFromTypes({
Kuowei Li01a686b2020-10-27 16:54:39 +0800410 AUDIO_DEVICE_OUT_HDMI_ARC, AUDIO_DEVICE_OUT_HDMI_EARC,
411 AUDIO_DEVICE_OUT_SPDIF, AUDIO_DEVICE_OUT_AUX_LINE,
412 });
François Gaffie2110e042015-03-24 08:41:51 +0100413 }
414
jiabinf502d152019-08-07 14:43:33 -0700415 devices2.add(devices3);
François Gaffie2110e042015-03-24 08:41:51 +0100416 // device is DEVICE_OUT_SPEAKER if we come from case STRATEGY_SONIFICATION or
417 // STRATEGY_ENFORCED_AUDIBLE, AUDIO_DEVICE_NONE otherwise
jiabinf502d152019-08-07 14:43:33 -0700418 devices.add(devices2);
François Gaffie2110e042015-03-24 08:41:51 +0100419
420 // If hdmi system audio mode is on, remove speaker out of output list.
421 if ((strategy == STRATEGY_MEDIA) &&
François Gaffiedc7553f2018-11-02 10:39:57 +0100422 (getForceUse(AUDIO_POLICY_FORCE_FOR_HDMI_SYSTEM_AUDIO) ==
François Gaffie2110e042015-03-24 08:41:51 +0100423 AUDIO_POLICY_FORCE_HDMI_SYSTEM_AUDIO_ENFORCED)) {
jiabin9a3361e2019-10-01 09:38:30 -0700424 devices.remove(devices.getDevicesFromType(AUDIO_DEVICE_OUT_SPEAKER));
François Gaffie2110e042015-03-24 08:41:51 +0100425 }
Jean-Michel Trivi654afa02017-05-11 14:12:33 -0700426
Eric Laurent6cd5f902021-03-23 18:29:58 +0100427 bool mediaActiveLocally =
428 outputs.isActiveLocally(toVolumeSource(AUDIO_STREAM_MUSIC),
429 SONIFICATION_RESPECTFUL_AFTER_MUSIC_DELAY)
430 || outputs.isActiveLocally(
431 toVolumeSource(AUDIO_STREAM_ACCESSIBILITY),
432 SONIFICATION_RESPECTFUL_AFTER_MUSIC_DELAY);
Carter Hsu524ee462021-07-20 08:47:31 +0800433
434 bool ringActiveLocally = outputs.isActiveLocally(toVolumeSource(AUDIO_STREAM_RING), 0);
435 // - for STRATEGY_SONIFICATION and ringtone active:
Jean-Michel Trivi654afa02017-05-11 14:12:33 -0700436 // if SPEAKER was selected, and SPEAKER_SAFE is available, use SPEAKER_SAFE instead
Eric Laurent6cd5f902021-03-23 18:29:58 +0100437 // - for STRATEGY_SONIFICATION_RESPECTFUL:
438 // if no media is playing on the device, check for mandatory use of "safe" speaker
439 // when media would have played on speaker, and the safe speaker path is available
Carter Hsu524ee462021-07-20 08:47:31 +0800440 if (strategy == STRATEGY_SONIFICATION || ringActiveLocally
Eric Laurent6cd5f902021-03-23 18:29:58 +0100441 || (strategy == STRATEGY_SONIFICATION_RESPECTFUL && !mediaActiveLocally)) {
jiabinf502d152019-08-07 14:43:33 -0700442 devices.replaceDevicesByType(
443 AUDIO_DEVICE_OUT_SPEAKER,
jiabin9a3361e2019-10-01 09:38:30 -0700444 availableOutputDevices.getDevicesFromType(
jiabinf502d152019-08-07 14:43:33 -0700445 AUDIO_DEVICE_OUT_SPEAKER_SAFE));
Jean-Michel Trivi654afa02017-05-11 14:12:33 -0700446 }
François Gaffie2110e042015-03-24 08:41:51 +0100447 } break;
448
Eric Laurent21777f82019-12-06 18:12:06 -0800449 case STRATEGY_CALL_ASSISTANT:
450 devices = availableOutputDevices.getDevicesFromType(AUDIO_DEVICE_OUT_TELEPHONY_TX);
451 break;
452
Eric Laurentd9766932020-08-07 14:01:22 -0700453 case STRATEGY_NONE:
454 // Happens when internal strategies are processed ("rerouting", "patch"...)
455 break;
456
François Gaffie2110e042015-03-24 08:41:51 +0100457 default:
Eric Laurentd9766932020-08-07 14:01:22 -0700458 ALOGW("%s unknown strategy: %d", __func__, strategy);
François Gaffie2110e042015-03-24 08:41:51 +0100459 break;
460 }
461
jiabinf502d152019-08-07 14:43:33 -0700462 if (devices.isEmpty()) {
Eric Laurentd9766932020-08-07 14:01:22 -0700463 ALOGV("%s no device found for strategy %d", __func__, strategy);
jiabinf502d152019-08-07 14:43:33 -0700464 sp<DeviceDescriptor> defaultOutputDevice = getApmObserver()->getDefaultOutputDevice();
465 if (defaultOutputDevice != nullptr) {
466 devices.add(defaultOutputDevice);
467 }
468 ALOGE_IF(devices.isEmpty(),
Eric Laurentd9766932020-08-07 14:01:22 -0700469 "%s no default device defined", __func__);
Eric Laurent5a2b6292016-04-14 18:05:57 -0700470 }
jiabinf502d152019-08-07 14:43:33 -0700471
Eric Laurentd9766932020-08-07 14:01:22 -0700472 ALOGVV("%s strategy %d, device %s", __func__,
jiabincd510522020-01-22 09:40:55 -0800473 strategy, dumpDeviceTypes(devices.types()).c_str());
jiabinf502d152019-08-07 14:43:33 -0700474 return devices;
François Gaffie2110e042015-03-24 08:41:51 +0100475}
476
477
jiabinf502d152019-08-07 14:43:33 -0700478sp<DeviceDescriptor> Engine::getDeviceForInputSource(audio_source_t inputSource) const
François Gaffie2110e042015-03-24 08:41:51 +0100479{
Eric Laurentaf377772019-03-29 14:50:21 -0700480 const DeviceVector availableOutputDevices = getApmObserver()->getAvailableOutputDevices();
481 const DeviceVector availableInputDevices = getApmObserver()->getAvailableInputDevices();
François Gaffiedc7553f2018-11-02 10:39:57 +0100482 const SwAudioOutputCollection &outputs = getApmObserver()->getOutputs();
jiabinf502d152019-08-07 14:43:33 -0700483 DeviceVector availableDevices = availableInputDevices;
Eric Laurent5ee8d122019-04-19 15:41:52 -0700484 sp<AudioOutputDescriptor> primaryOutput = outputs.getPrimaryOutput();
jiabinb6b07482019-09-26 18:05:18 -0700485 DeviceVector availablePrimaryDevices = primaryOutput == nullptr ? DeviceVector()
486 : availableInputDevices.getDevicesFromHwModule(primaryOutput->getModuleHandle());
jiabinf502d152019-08-07 14:43:33 -0700487 sp<DeviceDescriptor> device;
François Gaffie2110e042015-03-24 08:41:51 +0100488
Eric Laurentdc95a252018-04-12 12:46:56 -0700489 // when a call is active, force device selection to match source VOICE_COMMUNICATION
490 // for most other input sources to avoid rerouting call TX audio
491 if (isInCall()) {
492 switch (inputSource) {
493 case AUDIO_SOURCE_DEFAULT:
494 case AUDIO_SOURCE_MIC:
495 case AUDIO_SOURCE_VOICE_RECOGNITION:
496 case AUDIO_SOURCE_UNPROCESSED:
497 case AUDIO_SOURCE_HOTWORD:
498 case AUDIO_SOURCE_CAMCORDER:
Eric Laurentae4b6ec2019-01-15 18:34:38 -0800499 case AUDIO_SOURCE_VOICE_PERFORMANCE:
Carter Hsua3abb402021-10-26 11:11:20 +0800500 case AUDIO_SOURCE_ULTRASOUND:
Eric Laurentdc95a252018-04-12 12:46:56 -0700501 inputSource = AUDIO_SOURCE_VOICE_COMMUNICATION;
502 break;
503 default:
504 break;
505 }
506 }
507
Eric Laurent2517af32020-11-25 15:31:27 +0100508 audio_devices_t commDeviceType =
509 getPreferredDeviceTypeForLegacyStrategy(availableOutputDevices, STRATEGY_PHONE);
510
François Gaffie2110e042015-03-24 08:41:51 +0100511 switch (inputSource) {
François Gaffie2110e042015-03-24 08:41:51 +0100512 case AUDIO_SOURCE_DEFAULT:
513 case AUDIO_SOURCE_MIC:
jiabinf502d152019-08-07 14:43:33 -0700514 device = availableDevices.getDevice(
515 AUDIO_DEVICE_IN_BLUETOOTH_A2DP, String8(""), AUDIO_FORMAT_DEFAULT);
516 if (device != nullptr) break;
Eric Laurent2517af32020-11-25 15:31:27 +0100517 if (audio_is_bluetooth_out_sco_device(commDeviceType)) {
jiabinf502d152019-08-07 14:43:33 -0700518 device = availableDevices.getDevice(
519 AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET, String8(""), AUDIO_FORMAT_DEFAULT);
520 if (device != nullptr) break;
521 }
522 device = availableDevices.getFirstExistingDevice({
Eric Laurent93666b22022-05-13 14:42:13 +0200523 AUDIO_DEVICE_IN_WIRED_HEADSET,
Eric Laurenta9986862020-10-07 08:42:28 -0700524 AUDIO_DEVICE_IN_USB_HEADSET, AUDIO_DEVICE_IN_USB_DEVICE,
wei wanga7020522020-12-10 21:36:11 -0500525 AUDIO_DEVICE_IN_BLUETOOTH_BLE, AUDIO_DEVICE_IN_BUILTIN_MIC});
jiabinf502d152019-08-07 14:43:33 -0700526 break;
François Gaffie2110e042015-03-24 08:41:51 +0100527
528 case AUDIO_SOURCE_VOICE_COMMUNICATION:
529 // Allow only use of devices on primary input if in call and HAL does not support routing
530 // to voice call path.
531 if ((getPhoneState() == AUDIO_MODE_IN_CALL) &&
jiabinf502d152019-08-07 14:43:33 -0700532 (availableOutputDevices.getDevice(AUDIO_DEVICE_OUT_TELEPHONY_TX,
533 String8(""), AUDIO_FORMAT_DEFAULT)) == nullptr) {
jiabinb6b07482019-09-26 18:05:18 -0700534 LOG_ALWAYS_FATAL_IF(availablePrimaryDevices.isEmpty(), "Primary devices not found");
jiabinf502d152019-08-07 14:43:33 -0700535 availableDevices = availablePrimaryDevices;
François Gaffie2110e042015-03-24 08:41:51 +0100536 }
537
Eric Laurent2517af32020-11-25 15:31:27 +0100538 if (audio_is_bluetooth_out_sco_device(commDeviceType)) {
François Gaffie2110e042015-03-24 08:41:51 +0100539 // if SCO device is requested but no SCO device is available, fall back to default case
jiabinf502d152019-08-07 14:43:33 -0700540 device = availableDevices.getDevice(
541 AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET, String8(""), AUDIO_FORMAT_DEFAULT);
542 if (device != nullptr) {
François Gaffie2110e042015-03-24 08:41:51 +0100543 break;
544 }
Eric Laurent2517af32020-11-25 15:31:27 +0100545 }
546 switch (commDeviceType) {
547 case AUDIO_DEVICE_OUT_BLE_HEADSET:
548 device = availableDevices.getDevice(
Grzegorz Kołodziejczyk2e4e3e62021-07-21 15:35:03 +0200549 AUDIO_DEVICE_IN_BLE_HEADSET, String8(""), AUDIO_FORMAT_DEFAULT);
François Gaffie2110e042015-03-24 08:41:51 +0100550 break;
Eric Laurent2517af32020-11-25 15:31:27 +0100551 case AUDIO_DEVICE_OUT_SPEAKER:
jiabinf502d152019-08-07 14:43:33 -0700552 device = availableDevices.getFirstExistingDevice({
Eric Laurent6435dd72020-12-02 14:42:42 +0100553 AUDIO_DEVICE_IN_BACK_MIC, AUDIO_DEVICE_IN_BUILTIN_MIC,
554 AUDIO_DEVICE_IN_USB_DEVICE, AUDIO_DEVICE_IN_USB_HEADSET});
François Gaffie2110e042015-03-24 08:41:51 +0100555 break;
Eric Laurent2517af32020-11-25 15:31:27 +0100556 default: // FORCE_NONE
557 device = availableDevices.getFirstExistingDevice({
558 AUDIO_DEVICE_IN_WIRED_HEADSET, AUDIO_DEVICE_IN_USB_HEADSET,
wei wanga7020522020-12-10 21:36:11 -0500559 AUDIO_DEVICE_IN_USB_DEVICE, AUDIO_DEVICE_IN_BLUETOOTH_BLE,
560 AUDIO_DEVICE_IN_BUILTIN_MIC});
Eric Laurent2517af32020-11-25 15:31:27 +0100561 break;
562
François Gaffie2110e042015-03-24 08:41:51 +0100563 }
564 break;
565
566 case AUDIO_SOURCE_VOICE_RECOGNITION:
rago8a397d52015-12-02 11:27:57 -0800567 case AUDIO_SOURCE_UNPROCESSED:
wei wanga7020522020-12-10 21:36:11 -0500568 if (audio_is_bluetooth_out_sco_device(commDeviceType)) {
569 device = availableDevices.getDevice(
570 AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET, String8(""), AUDIO_FORMAT_DEFAULT);
571 if (device != nullptr) break;
Eric Laurent5ee8d122019-04-19 15:41:52 -0700572 }
wei wanga7020522020-12-10 21:36:11 -0500573 // we need to make BLUETOOTH_BLE has higher priority than BUILTIN_MIC,
574 // because sometimes user want to do voice search by bt remote
575 // even if BUILDIN_MIC is available.
576 device = availableDevices.getFirstExistingDevice({
Eric Laurent93666b22022-05-13 14:42:13 +0200577 AUDIO_DEVICE_IN_WIRED_HEADSET,
wei wanga7020522020-12-10 21:36:11 -0500578 AUDIO_DEVICE_IN_USB_HEADSET, AUDIO_DEVICE_IN_USB_DEVICE,
579 AUDIO_DEVICE_IN_BLUETOOTH_BLE, AUDIO_DEVICE_IN_BUILTIN_MIC});
580
581 break;
582 case AUDIO_SOURCE_HOTWORD:
583 // We should not use primary output criteria for Hotword but rather limit
584 // to devices attached to the same HW module as the build in mic
585 LOG_ALWAYS_FATAL_IF(availablePrimaryDevices.isEmpty(), "Primary devices not found");
586 availableDevices = availablePrimaryDevices;
Eric Laurent2517af32020-11-25 15:31:27 +0100587 if (audio_is_bluetooth_out_sco_device(commDeviceType)) {
jiabinf502d152019-08-07 14:43:33 -0700588 device = availableDevices.getDevice(
589 AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET, String8(""), AUDIO_FORMAT_DEFAULT);
590 if (device != nullptr) break;
François Gaffie2110e042015-03-24 08:41:51 +0100591 }
jiabinf502d152019-08-07 14:43:33 -0700592 device = availableDevices.getFirstExistingDevice({
Eric Laurent93666b22022-05-13 14:42:13 +0200593 AUDIO_DEVICE_IN_WIRED_HEADSET,
Eric Laurenta9986862020-10-07 08:42:28 -0700594 AUDIO_DEVICE_IN_USB_HEADSET, AUDIO_DEVICE_IN_USB_DEVICE,
595 AUDIO_DEVICE_IN_BUILTIN_MIC});
François Gaffie2110e042015-03-24 08:41:51 +0100596 break;
597 case AUDIO_SOURCE_CAMCORDER:
jiabinf502d152019-08-07 14:43:33 -0700598 // For a device without built-in mic, adding usb device
599 device = availableDevices.getFirstExistingDevice({
600 AUDIO_DEVICE_IN_BACK_MIC, AUDIO_DEVICE_IN_BUILTIN_MIC,
601 AUDIO_DEVICE_IN_USB_DEVICE});
François Gaffie2110e042015-03-24 08:41:51 +0100602 break;
603 case AUDIO_SOURCE_VOICE_DOWNLINK:
604 case AUDIO_SOURCE_VOICE_CALL:
Eric Laurent5ee8d122019-04-19 15:41:52 -0700605 case AUDIO_SOURCE_VOICE_UPLINK:
jiabinf502d152019-08-07 14:43:33 -0700606 device = availableDevices.getDevice(
607 AUDIO_DEVICE_IN_VOICE_CALL, String8(""), AUDIO_FORMAT_DEFAULT);
François Gaffie2110e042015-03-24 08:41:51 +0100608 break;
Eric Laurentae4b6ec2019-01-15 18:34:38 -0800609 case AUDIO_SOURCE_VOICE_PERFORMANCE:
jiabinf502d152019-08-07 14:43:33 -0700610 device = availableDevices.getFirstExistingDevice({
611 AUDIO_DEVICE_IN_WIRED_HEADSET, AUDIO_DEVICE_IN_USB_HEADSET,
wei wanga7020522020-12-10 21:36:11 -0500612 AUDIO_DEVICE_IN_USB_DEVICE, AUDIO_DEVICE_IN_BLUETOOTH_BLE,
613 AUDIO_DEVICE_IN_BUILTIN_MIC});
Eric Laurentae4b6ec2019-01-15 18:34:38 -0800614 break;
François Gaffie2110e042015-03-24 08:41:51 +0100615 case AUDIO_SOURCE_REMOTE_SUBMIX:
jiabinf502d152019-08-07 14:43:33 -0700616 device = availableDevices.getDevice(
617 AUDIO_DEVICE_IN_REMOTE_SUBMIX, String8(""), AUDIO_FORMAT_DEFAULT);
François Gaffie2110e042015-03-24 08:41:51 +0100618 break;
Eric Laurentae4b6ec2019-01-15 18:34:38 -0800619 case AUDIO_SOURCE_FM_TUNER:
jiabinf502d152019-08-07 14:43:33 -0700620 device = availableDevices.getDevice(
621 AUDIO_DEVICE_IN_FM_TUNER, String8(""), AUDIO_FORMAT_DEFAULT);
François Gaffie2110e042015-03-24 08:41:51 +0100622 break;
Eric Laurentae4b6ec2019-01-15 18:34:38 -0800623 case AUDIO_SOURCE_ECHO_REFERENCE:
jiabinf502d152019-08-07 14:43:33 -0700624 device = availableDevices.getDevice(
625 AUDIO_DEVICE_IN_ECHO_REFERENCE, String8(""), AUDIO_FORMAT_DEFAULT);
Eric Laurentae4b6ec2019-01-15 18:34:38 -0800626 break;
Carter Hsua3abb402021-10-26 11:11:20 +0800627 case AUDIO_SOURCE_ULTRASOUND:
628 device = availableDevices.getFirstExistingDevice({
629 AUDIO_DEVICE_IN_BUILTIN_MIC, AUDIO_DEVICE_IN_BACK_MIC});
630 break;
François Gaffie2110e042015-03-24 08:41:51 +0100631 default:
632 ALOGW("getDeviceForInputSource() invalid input source %d", inputSource);
633 break;
634 }
jiabinf502d152019-08-07 14:43:33 -0700635 if (device == nullptr) {
Eric Laurent5a2b6292016-04-14 18:05:57 -0700636 ALOGV("getDeviceForInputSource() no device found for source %d", inputSource);
jiabinf502d152019-08-07 14:43:33 -0700637 device = availableDevices.getDevice(
638 AUDIO_DEVICE_IN_STUB, String8(""), AUDIO_FORMAT_DEFAULT);
639 ALOGE_IF(device == nullptr,
Eric Laurent5a2b6292016-04-14 18:05:57 -0700640 "getDeviceForInputSource() no default device defined");
641 }
Eric Laurent2517af32020-11-25 15:31:27 +0100642
jiabinf502d152019-08-07 14:43:33 -0700643 ALOGV_IF(device != nullptr,
644 "getDeviceForInputSource()input source %d, device %08x",
645 inputSource, device->type());
François Gaffie2110e042015-03-24 08:41:51 +0100646 return device;
647}
648
François Gaffiedc7553f2018-11-02 10:39:57 +0100649void Engine::updateDeviceSelectionCache()
650{
651 for (const auto &iter : getProductStrategies()) {
Jean-Michel Trivi30857152019-11-01 11:04:15 -0700652 const auto& strategy = iter.second;
François Gaffiedc7553f2018-11-02 10:39:57 +0100653 auto devices = getDevicesForProductStrategy(strategy->getId());
654 mDevicesForStrategies[strategy->getId()] = devices;
655 strategy->setDeviceTypes(devices.types());
656 strategy->setDeviceAddress(devices.getFirstValidAddress().c_str());
657 }
658}
659
Eric Laurent2517af32020-11-25 15:31:27 +0100660product_strategy_t Engine::getProductStrategyFromLegacy(legacy_strategy legacyStrategy) const {
661 for (const auto& strategyMap : mLegacyStrategyMap) {
662 if (strategyMap.second == legacyStrategy) {
663 return strategyMap.first;
664 }
665 }
666 return PRODUCT_STRATEGY_NONE;
667}
François Gaffiedc7553f2018-11-02 10:39:57 +0100668
Eric Laurent2517af32020-11-25 15:31:27 +0100669audio_devices_t Engine::getPreferredDeviceTypeForLegacyStrategy(
670 const DeviceVector& availableOutputDevices, legacy_strategy legacyStrategy) const {
671 product_strategy_t strategy = getProductStrategyFromLegacy(legacyStrategy);
672 DeviceVector devices = getPreferredAvailableDevicesForProductStrategy(
673 availableOutputDevices, strategy);
674 if (devices.size() > 0) {
675 return devices[0]->type();
676 }
677 return AUDIO_DEVICE_NONE;
678}
679
680DeviceVector Engine::getPreferredAvailableDevicesForProductStrategy(
681 const DeviceVector& availableOutputDevices, product_strategy_t strategy) const {
682 DeviceVector preferredAvailableDevVec = {};
jiabin0a488932020-08-07 17:32:40 -0700683 AudioDeviceTypeAddrVector preferredStrategyDevices;
684 const status_t status = getDevicesForRoleAndStrategy(
685 strategy, DEVICE_ROLE_PREFERRED, preferredStrategyDevices);
Jean-Michel Trivi30857152019-11-01 11:04:15 -0700686 if (status == NO_ERROR) {
687 // there is a preferred device, is it available?
Eric Laurent2517af32020-11-25 15:31:27 +0100688 preferredAvailableDevVec =
jiabin0a488932020-08-07 17:32:40 -0700689 availableOutputDevices.getDevicesFromDeviceTypeAddrVec(preferredStrategyDevices);
jiabin61591b12022-01-21 17:06:06 +0000690 if (preferredAvailableDevVec.size() == preferredStrategyDevices.size()) {
jiabin0a488932020-08-07 17:32:40 -0700691 ALOGVV("%s using pref device %s for strategy %u",
692 __func__, preferredAvailableDevVec.toString().c_str(), strategy);
693 return preferredAvailableDevVec;
Jean-Michel Trivi30857152019-11-01 11:04:15 -0700694 }
695 }
Eric Laurent2517af32020-11-25 15:31:27 +0100696 return preferredAvailableDevVec;
697}
698
Eric Laurent6cd5f902021-03-23 18:29:58 +0100699
Eric Laurent2517af32020-11-25 15:31:27 +0100700DeviceVector Engine::getDevicesForProductStrategy(product_strategy_t strategy) const {
Eric Laurent6cd5f902021-03-23 18:29:58 +0100701 const SwAudioOutputCollection& outputs = getApmObserver()->getOutputs();
702
703 // Take context into account to remap product strategy before
704 // checking preferred device for strategy and applying default routing rules
705 strategy = remapStrategyFromContext(strategy, outputs);
706
Eric Laurent2517af32020-11-25 15:31:27 +0100707 auto legacyStrategy = mLegacyStrategyMap.find(strategy) != end(mLegacyStrategyMap) ?
708 mLegacyStrategyMap.at(strategy) : STRATEGY_NONE;
709
Eric Laurent6cd5f902021-03-23 18:29:58 +0100710 DeviceVector availableOutputDevices = getApmObserver()->getAvailableOutputDevices();
Eric Laurent2802b862021-03-01 09:36:16 +0100711
Eric Laurent6cd5f902021-03-23 18:29:58 +0100712 filterOutputDevicesForStrategy(legacyStrategy, availableOutputDevices, outputs);
Eric Laurent2802b862021-03-01 09:36:16 +0100713
Eric Laurent2517af32020-11-25 15:31:27 +0100714 // check if this strategy has a preferred device that is available,
715 // if yes, give priority to it.
716 DeviceVector preferredAvailableDevVec =
717 getPreferredAvailableDevicesForProductStrategy(availableOutputDevices, strategy);
718 if (!preferredAvailableDevVec.isEmpty()) {
719 return preferredAvailableDevVec;
720 }
Jean-Michel Trivi30857152019-11-01 11:04:15 -0700721
jiabinf502d152019-08-07 14:43:33 -0700722 return getDevicesForStrategyInt(legacyStrategy,
723 availableOutputDevices,
Eric Laurent6cd5f902021-03-23 18:29:58 +0100724 outputs);
François Gaffiedc7553f2018-11-02 10:39:57 +0100725}
726
727DeviceVector Engine::getOutputDevicesForAttributes(const audio_attributes_t &attributes,
728 const sp<DeviceDescriptor> &preferredDevice,
729 bool fromCache) const
730{
731 // First check for explict routing device
732 if (preferredDevice != nullptr) {
733 ALOGV("%s explicit Routing on device %s", __func__, preferredDevice->toString().c_str());
734 return DeviceVector(preferredDevice);
735 }
François Gaffiec005e562018-11-06 15:04:49 +0100736 product_strategy_t strategy = getProductStrategyForAttributes(attributes);
Eric Laurentaf377772019-03-29 14:50:21 -0700737 const DeviceVector availableOutputDevices = getApmObserver()->getAvailableOutputDevices();
François Gaffiec005e562018-11-06 15:04:49 +0100738 const SwAudioOutputCollection &outputs = getApmObserver()->getOutputs();
François Gaffiedc7553f2018-11-02 10:39:57 +0100739 //
740 // @TODO: what is the priority of explicit routing? Shall it be considered first as it used to
741 // be by APM?
742 //
François Gaffiec005e562018-11-06 15:04:49 +0100743 // Honor explicit routing requests only if all active clients have a preferred route in which
744 // case the last active client route is used
745 sp<DeviceDescriptor> device = findPreferredDevice(outputs, strategy, availableOutputDevices);
746 if (device != nullptr) {
747 return DeviceVector(device);
748 }
François Gaffiedc7553f2018-11-02 10:39:57 +0100749
750 return fromCache? mDevicesForStrategies.at(strategy) : getDevicesForProductStrategy(strategy);
751}
752
753DeviceVector Engine::getOutputDevicesForStream(audio_stream_type_t stream, bool fromCache) const
754{
755 auto attributes = getAttributesForStreamType(stream);
756 return getOutputDevicesForAttributes(attributes, nullptr, fromCache);
757}
758
759sp<DeviceDescriptor> Engine::getInputDeviceForAttributes(const audio_attributes_t &attr,
yuanjiahsu0735bf32021-03-18 08:12:54 +0800760 uid_t uid,
Mikhail Naganovbfac5832019-03-05 16:55:28 -0800761 sp<AudioPolicyMix> *mix) const
François Gaffiedc7553f2018-11-02 10:39:57 +0100762{
François Gaffiec005e562018-11-06 15:04:49 +0100763 const auto &policyMixes = getApmObserver()->getAudioPolicyMixCollection();
Eric Laurentaf377772019-03-29 14:50:21 -0700764 const auto availableInputDevices = getApmObserver()->getAvailableInputDevices();
François Gaffiec005e562018-11-06 15:04:49 +0100765 const auto &inputs = getApmObserver()->getInputs();
François Gaffiedc7553f2018-11-02 10:39:57 +0100766 std::string address;
François Gaffiec005e562018-11-06 15:04:49 +0100767
François Gaffiedc7553f2018-11-02 10:39:57 +0100768 //
François Gaffiec005e562018-11-06 15:04:49 +0100769 // Explicit Routing ??? what is the priority of explicit routing? Shall it be considered
770 // first as it used to be by APM?
François Gaffiedc7553f2018-11-02 10:39:57 +0100771 //
François Gaffiec005e562018-11-06 15:04:49 +0100772 // Honor explicit routing requests only if all active clients have a preferred route in which
773 // case the last active client route is used
774 sp<DeviceDescriptor> device =
775 findPreferredDevice(inputs, attr.source, availableInputDevices);
776 if (device != nullptr) {
777 return device;
778 }
779
yuanjiahsu0735bf32021-03-18 08:12:54 +0800780 device = policyMixes.getDeviceAndMixForInputSource(attr.source,
781 availableInputDevices,
782 uid,
783 mix);
François Gaffiec005e562018-11-06 15:04:49 +0100784 if (device != nullptr) {
785 return device;
786 }
François Gaffiedc7553f2018-11-02 10:39:57 +0100787
jiabinf502d152019-08-07 14:43:33 -0700788 device = getDeviceForInputSource(attr.source);
789 if (device == nullptr || !audio_is_remote_submix_device(device->type())) {
790 // Return immediately if the device is null or it is not a remote submix device.
791 return device;
François Gaffiedc7553f2018-11-02 10:39:57 +0100792 }
jiabinf502d152019-08-07 14:43:33 -0700793
794 // For remote submix device, try to find the device by address.
795 address = "0";
796 std::size_t pos;
797 std::string tags { attr.tags };
798 if ((pos = tags.find("addr=")) != std::string::npos) {
799 address = tags.substr(pos + std::strlen("addr="));
800 }
801 return availableInputDevices.getDevice(device->type(),
François Gaffiedc7553f2018-11-02 10:39:57 +0100802 String8(address.c_str()),
803 AUDIO_FORMAT_DEFAULT);
804}
805
François Gaffie2110e042015-03-24 08:41:51 +0100806} // namespace audio_policy
807} // namespace android
808
809