1 /*
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"
28 #include <android-base/macros.h>
29 #include <AudioPolicyManagerObserver.h>
30 #include <PolicyAudioPort.h>
31 #include <IOProfile.h>
32 #include <AudioIODescriptorInterface.h>
33 #include <com_android_media_audioserver.h>
34 #include <policy.h>
35 #include <media/AudioContainers.h>
36 #include <utils/String8.h>
37 #include <utils/Log.h>
38 
39 namespace android::audio_policy {
40 
41 struct legacy_strategy_map { const char *name; legacy_strategy id; };
getLegacyStrategy()42 static const std::vector<legacy_strategy_map>& getLegacyStrategy() {
43     static const std::vector<legacy_strategy_map> legacyStrategy = {
44         { "STRATEGY_NONE", STRATEGY_NONE },
45         { "STRATEGY_MEDIA", STRATEGY_MEDIA },
46         { "STRATEGY_PHONE", STRATEGY_PHONE },
47         { "STRATEGY_SONIFICATION", STRATEGY_SONIFICATION },
48         { "STRATEGY_SONIFICATION_RESPECTFUL", STRATEGY_SONIFICATION_RESPECTFUL },
49         { "STRATEGY_DTMF", STRATEGY_DTMF },
50         { "STRATEGY_ENFORCED_AUDIBLE", STRATEGY_ENFORCED_AUDIBLE },
51         { "STRATEGY_TRANSMITTED_THROUGH_SPEAKER", STRATEGY_TRANSMITTED_THROUGH_SPEAKER },
52         { "STRATEGY_ACCESSIBILITY", STRATEGY_ACCESSIBILITY },
53         { "STRATEGY_REROUTING", STRATEGY_REROUTING },
54         { "STRATEGY_PATCH", STRATEGY_REROUTING }, // boiler to manage stream patch volume
55         { "STRATEGY_CALL_ASSISTANT", STRATEGY_CALL_ASSISTANT },
56     };
57     return legacyStrategy;
58 }
59 
loadFromHalConfigWithFallback(const media::audio::common::AudioHalEngineConfig & aidlConfig)60 status_t Engine::loadFromHalConfigWithFallback(
61         const media::audio::common::AudioHalEngineConfig& aidlConfig) {
62     return loadWithFallback(aidlConfig);
63 }
64 
loadFromXmlConfigWithFallback(const std::string & xmlFilePath)65 status_t Engine::loadFromXmlConfigWithFallback(const std::string& xmlFilePath) {
66     return loadWithFallback(xmlFilePath);
67 }
68 
69 template<typename T>
loadWithFallback(const T & configSource)70 status_t Engine::loadWithFallback(const T& configSource) {
71     auto result = EngineBase::loadAudioPolicyEngineConfig(configSource);
72     ALOGE_IF(result.nbSkippedElement != 0,
73              "Policy Engine configuration is partially invalid, skipped %zu elements",
74              result.nbSkippedElement);
75 
76     auto legacyStrategy = getLegacyStrategy();
77     for (const auto &strategy : legacyStrategy) {
78         mLegacyStrategyMap[getProductStrategyByName(strategy.name)] = strategy.id;
79     }
80 
81     return OK;
82 }
83 
84 
setForceUse(audio_policy_force_use_t usage,audio_policy_forced_cfg_t config)85 status_t Engine::setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config)
86 {
87     switch(usage) {
88     case AUDIO_POLICY_FORCE_FOR_COMMUNICATION:
89         if (config != AUDIO_POLICY_FORCE_SPEAKER && config != AUDIO_POLICY_FORCE_BT_SCO &&
90             config != AUDIO_POLICY_FORCE_NONE) {
91             ALOGW("setForceUse() invalid config %d for COMMUNICATION", config);
92             return BAD_VALUE;
93         }
94         break;
95     case AUDIO_POLICY_FORCE_FOR_MEDIA:
96         if (config != AUDIO_POLICY_FORCE_HEADPHONES && config != AUDIO_POLICY_FORCE_BT_A2DP &&
97             config != AUDIO_POLICY_FORCE_WIRED_ACCESSORY &&
98             config != AUDIO_POLICY_FORCE_ANALOG_DOCK &&
99             config != AUDIO_POLICY_FORCE_DIGITAL_DOCK && config != AUDIO_POLICY_FORCE_NONE &&
100             config != AUDIO_POLICY_FORCE_NO_BT_A2DP && config != AUDIO_POLICY_FORCE_SPEAKER ) {
101             ALOGW("setForceUse() invalid config %d for MEDIA", config);
102             return BAD_VALUE;
103         }
104         break;
105     case AUDIO_POLICY_FORCE_FOR_RECORD:
106         if (config != AUDIO_POLICY_FORCE_BT_SCO && config != AUDIO_POLICY_FORCE_WIRED_ACCESSORY &&
107             config != AUDIO_POLICY_FORCE_NONE) {
108             ALOGW("setForceUse() invalid config %d for RECORD", config);
109             return BAD_VALUE;
110         }
111         break;
112     case AUDIO_POLICY_FORCE_FOR_DOCK:
113         if (config != AUDIO_POLICY_FORCE_NONE && config != AUDIO_POLICY_FORCE_BT_CAR_DOCK &&
114             config != AUDIO_POLICY_FORCE_BT_DESK_DOCK &&
115             config != AUDIO_POLICY_FORCE_WIRED_ACCESSORY &&
116             config != AUDIO_POLICY_FORCE_ANALOG_DOCK &&
117             config != AUDIO_POLICY_FORCE_DIGITAL_DOCK) {
118             ALOGW("setForceUse() invalid config %d for DOCK", config);
119             return BAD_VALUE;
120         }
121         break;
122     case AUDIO_POLICY_FORCE_FOR_SYSTEM:
123         if (config != AUDIO_POLICY_FORCE_NONE &&
124             config != AUDIO_POLICY_FORCE_SYSTEM_ENFORCED) {
125             ALOGW("setForceUse() invalid config %d for SYSTEM", config);
126             return BAD_VALUE;
127         }
128         break;
129     case AUDIO_POLICY_FORCE_FOR_HDMI_SYSTEM_AUDIO:
130         if (config != AUDIO_POLICY_FORCE_NONE &&
131             config != AUDIO_POLICY_FORCE_HDMI_SYSTEM_AUDIO_ENFORCED) {
132             ALOGW("setForceUse() invalid config %d for HDMI_SYSTEM_AUDIO", config);
133             return BAD_VALUE;
134         }
135         break;
136     case AUDIO_POLICY_FORCE_FOR_ENCODED_SURROUND:
137         if (config != AUDIO_POLICY_FORCE_NONE &&
138                 config != AUDIO_POLICY_FORCE_ENCODED_SURROUND_NEVER &&
139                 config != AUDIO_POLICY_FORCE_ENCODED_SURROUND_ALWAYS &&
140                 config != AUDIO_POLICY_FORCE_ENCODED_SURROUND_MANUAL) {
141             ALOGW("setForceUse() invalid config %d for ENCODED_SURROUND", config);
142             return BAD_VALUE;
143         }
144         break;
145     case AUDIO_POLICY_FORCE_FOR_VIBRATE_RINGING:
146         if (config != AUDIO_POLICY_FORCE_BT_SCO && config != AUDIO_POLICY_FORCE_NONE) {
147             ALOGW("setForceUse() invalid config %d for VIBRATE_RINGING", config);
148             return BAD_VALUE;
149         }
150         break;
151     default:
152         ALOGW("setForceUse() invalid usage %d", usage);
153         return BAD_VALUE;
154     }
155     return EngineBase::setForceUse(usage, config);
156 }
157 
isBtScoActive(DeviceVector & availableOutputDevices,const SwAudioOutputCollection & outputs) const158 bool Engine::isBtScoActive(DeviceVector& availableOutputDevices,
159                            const SwAudioOutputCollection &outputs) const {
160     if (availableOutputDevices.getDevicesFromTypes(getAudioDeviceOutAllScoSet()).isEmpty()) {
161         return false;
162     }
163     // SCO is active if:
164     // 1) we are in a call and SCO is the preferred device for PHONE strategy
165     if (isInCall() && audio_is_bluetooth_out_sco_device(
166             getPreferredDeviceTypeForLegacyStrategy(availableOutputDevices, STRATEGY_PHONE))) {
167         return true;
168     }
169 
170     // 2) A strategy for which the preferred device is SCO is active
171     for (const auto &ps : getOrderedProductStrategies()) {
172         if (outputs.isStrategyActive(ps) &&
173             !getPreferredAvailableDevicesForProductStrategy(availableOutputDevices, ps)
174                 .getDevicesFromTypes(getAudioDeviceOutAllScoSet()).isEmpty()) {
175             return true;
176         }
177     }
178     // 3) a ringtone is active and SCO is used for ringing
179     if (outputs.isActiveLocally(toVolumeSource(AUDIO_STREAM_RING))
180           && (getForceUse(AUDIO_POLICY_FORCE_FOR_VIBRATE_RINGING)
181                     == AUDIO_POLICY_FORCE_BT_SCO)) {
182         return true;
183     }
184     // 4) an active input is routed from SCO
185     DeviceVector availableInputDevices = getApmObserver()->getAvailableInputDevices();
186     const auto &inputs = getApmObserver()->getInputs();
187     if (inputs.activeInputsCountOnDevices(availableInputDevices.getDevicesFromType(
188             AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET)) > 0) {
189         return true;
190     }
191     return false;
192 }
193 
filterOutputDevicesForStrategy(legacy_strategy strategy,DeviceVector & availableOutputDevices,const SwAudioOutputCollection & outputs) const194 void Engine::filterOutputDevicesForStrategy(legacy_strategy strategy,
195                                             DeviceVector& availableOutputDevices,
196                                             const SwAudioOutputCollection &outputs) const
197 {
198     DeviceVector availableInputDevices = getApmObserver()->getAvailableInputDevices();
199 
200     if (com::android::media::audioserver::use_bt_sco_for_media()) {
201         // remove A2DP and LE Audio devices whenever BT SCO is in use
202         if (isBtScoActive(availableOutputDevices, outputs)) {
203             availableOutputDevices.remove(
204                 availableOutputDevices.getDevicesFromTypes(getAudioDeviceOutAllA2dpSet()));
205             availableOutputDevices.remove(
206                 availableOutputDevices.getDevicesFromTypes(getAudioDeviceOutAllBleSet()));
207         }
208     }
209 
210     switch (strategy) {
211     case STRATEGY_SONIFICATION_RESPECTFUL: {
212         if (!(isInCall() || outputs.isActiveLocally(toVolumeSource(AUDIO_STREAM_VOICE_CALL)))) {
213             // routing is same as media without the "remote" device
214             availableOutputDevices.remove(availableOutputDevices.getDevicesFromType(
215                     AUDIO_DEVICE_OUT_REMOTE_SUBMIX));
216         }
217         } break;
218     case STRATEGY_DTMF:
219     case STRATEGY_PHONE: {
220         // Force use of only devices on primary output if:
221         // - in call AND
222         //   - cannot route from voice call RX OR
223         //   - audio HAL version is < 3.0 and TX device is on the primary HW module
224         if (getPhoneState() == AUDIO_MODE_IN_CALL) {
225             sp<AudioOutputDescriptor> primaryOutput = outputs.getPrimaryOutput();
226             if (primaryOutput != nullptr) {
227                 audio_devices_t txDevice = AUDIO_DEVICE_NONE;
228                 sp<DeviceDescriptor> txDeviceDesc =
229                         getDeviceForInputSource(AUDIO_SOURCE_VOICE_COMMUNICATION);
230                 if (txDeviceDesc != nullptr) {
231                     txDevice = txDeviceDesc->type();
232                 }
233                 DeviceVector availPrimaryInputDevices =
234                         availableInputDevices.getDevicesFromHwModule(
235                             primaryOutput->getModuleHandle());
236 
237                 // TODO: getPrimaryOutput return only devices from first module in
238                 // audio_policy_configuration.xml, hearing aid is not there, but it's
239                 // a primary device
240                 // FIXME: this is not the right way of solving this problem
241                 DeviceVector availPrimaryOutputDevices = availableOutputDevices.getDevicesFromTypes(
242                         primaryOutput->supportedDevices().types());
243                 availPrimaryOutputDevices.add(
244                         availableOutputDevices.getDevicesFromType(AUDIO_DEVICE_OUT_HEARING_AID));
245 
246                 if ((availableInputDevices.getDevice(AUDIO_DEVICE_IN_TELEPHONY_RX,
247                                                      String8(""), AUDIO_FORMAT_DEFAULT) == nullptr)
248                     || ((availPrimaryInputDevices.getDevice(
249                             txDevice, String8(""), AUDIO_FORMAT_DEFAULT) != nullptr) &&
250                      (primaryOutput->getPolicyAudioPort()->getModuleVersionMajor() < 3))) {
251                     availableOutputDevices = availPrimaryOutputDevices;
252                 }
253             } else {
254                 ALOGE("%s, STRATEGY_PHONE: Primary output not found", __func__);
255             }
256         }
257         // Do not use A2DP devices when in call but use them when not in call
258         // (e.g for voice mail playback)
259         if (isInCall()) {
260             availableOutputDevices.remove(availableOutputDevices.getDevicesFromTypes({
261                     AUDIO_DEVICE_OUT_BLUETOOTH_A2DP, AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES,
262                     AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER, }));
263         }
264         // If connected to a dock, never use the device speaker for calls
265         if (!availableOutputDevices.getDevicesFromTypes({AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET})
266                 .isEmpty()) {
267             availableOutputDevices.remove(
268                     availableOutputDevices.getDevicesFromTypes({AUDIO_DEVICE_OUT_SPEAKER}));
269         }
270         } break;
271     case STRATEGY_ACCESSIBILITY: {
272         // do not route accessibility prompts to a digital output currently configured with a
273         // compressed format as they would likely not be mixed and dropped.
274         for (size_t i = 0; i < outputs.size(); i++) {
275             sp<AudioOutputDescriptor> desc = outputs.valueAt(i);
276             if (desc->isActive() && !audio_is_linear_pcm(desc->getFormat())) {
277                 availableOutputDevices.remove(desc->devices().getDevicesFromTypes({
278                         AUDIO_DEVICE_OUT_HDMI, AUDIO_DEVICE_OUT_SPDIF,
279                         AUDIO_DEVICE_OUT_HDMI_ARC, AUDIO_DEVICE_OUT_HDMI_EARC}));
280             }
281         }
282         } break;
283     default:
284         break;
285     }
286 }
287 
remapStrategyFromContext(product_strategy_t strategy,const SwAudioOutputCollection & outputs) const288 product_strategy_t Engine::remapStrategyFromContext(product_strategy_t strategy,
289                                                  const SwAudioOutputCollection &outputs) const {
290     auto legacyStrategy = mLegacyStrategyMap.find(strategy) != end(mLegacyStrategyMap) ?
291                           mLegacyStrategyMap.at(strategy) : STRATEGY_NONE;
292 
293     if (isInCall()) {
294         switch (legacyStrategy) {
295         case STRATEGY_ACCESSIBILITY:
296         case STRATEGY_DTMF:
297         case STRATEGY_MEDIA:
298         case STRATEGY_SONIFICATION:
299         case STRATEGY_SONIFICATION_RESPECTFUL:
300             legacyStrategy = STRATEGY_PHONE;
301             break;
302 
303         default:
304             return strategy;
305         }
306     } else {
307         switch (legacyStrategy) {
308         case STRATEGY_SONIFICATION_RESPECTFUL:
309         case STRATEGY_SONIFICATION:
310             if (outputs.isActiveLocally(toVolumeSource(AUDIO_STREAM_VOICE_CALL))) {
311                 legacyStrategy = STRATEGY_PHONE;
312             }
313             break;
314 
315         case STRATEGY_ACCESSIBILITY:
316             if (outputs.isActive(toVolumeSource(AUDIO_STREAM_RING)) ||
317                     outputs.isActive(toVolumeSource(AUDIO_STREAM_ALARM))) {
318                 legacyStrategy = STRATEGY_SONIFICATION;
319             }
320             break;
321 
322         default:
323             return strategy;
324         }
325     }
326     return getProductStrategyFromLegacy(legacyStrategy);
327 }
328 
getDevicesForStrategyInt(legacy_strategy strategy,DeviceVector availableOutputDevices,const SwAudioOutputCollection & outputs) const329 DeviceVector Engine::getDevicesForStrategyInt(legacy_strategy strategy,
330                                               DeviceVector availableOutputDevices,
331                                               const SwAudioOutputCollection &outputs) const
332 {
333     DeviceVector devices;
334 
335     switch (strategy) {
336 
337     case STRATEGY_TRANSMITTED_THROUGH_SPEAKER:
338         devices = availableOutputDevices.getDevicesFromType(AUDIO_DEVICE_OUT_SPEAKER);
339         break;
340 
341     case STRATEGY_PHONE: {
342         // TODO(b/243670205): remove this logic that gives preference to last removable devices
343         // once a UX decision has been made
344         devices = availableOutputDevices.getFirstDevicesFromTypes(
345                         getLastRemovableMediaDevices(GROUP_NONE, {
346                             // excluding HEARING_AID and BLE_HEADSET because Dialer uses
347                             // setCommunicationDevice to select them explicitly
348                             AUDIO_DEVICE_OUT_HEARING_AID,
349                             AUDIO_DEVICE_OUT_BLE_HEADSET,
350                             AUDIO_DEVICE_OUT_AUX_DIGITAL
351                             }));
352         if (!devices.isEmpty()) break;
353         devices = availableOutputDevices.getFirstDevicesFromTypes({
354                 AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET, AUDIO_DEVICE_OUT_EARPIECE,
355                 AUDIO_DEVICE_OUT_SPEAKER});
356     } break;
357 
358     case STRATEGY_SONIFICATION:
359     case STRATEGY_ENFORCED_AUDIBLE:
360         // strategy STRATEGY_ENFORCED_AUDIBLE uses same routing policy as STRATEGY_SONIFICATION
361         // except:
362         //   - when in call where it doesn't default to STRATEGY_PHONE behavior
363         //   - in countries where not enforced in which case it follows STRATEGY_MEDIA
364 
365         if ((strategy == STRATEGY_SONIFICATION) ||
366                 (getForceUse(AUDIO_POLICY_FORCE_FOR_SYSTEM) == AUDIO_POLICY_FORCE_SYSTEM_ENFORCED)) {
367             // favor dock over speaker when available
368             devices = availableOutputDevices.getFirstDevicesFromTypes({
369                     AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET, AUDIO_DEVICE_OUT_SPEAKER});
370         }
371 
372         // if SCO headset is connected and we are told to use it, play ringtone over
373         // speaker and BT SCO
374         if (!availableOutputDevices.getDevicesFromTypes(getAudioDeviceOutAllScoSet()).isEmpty()) {
375             DeviceVector devices2;
376             devices2 = availableOutputDevices.getFirstDevicesFromTypes({
377                     AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT, AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET,
378                     AUDIO_DEVICE_OUT_BLUETOOTH_SCO});
379             // Use ONLY Bluetooth SCO output when ringing in vibration mode
380             if (!((getForceUse(AUDIO_POLICY_FORCE_FOR_SYSTEM) == AUDIO_POLICY_FORCE_SYSTEM_ENFORCED)
381                     && (strategy == STRATEGY_ENFORCED_AUDIBLE))) {
382                 if (getForceUse(AUDIO_POLICY_FORCE_FOR_VIBRATE_RINGING)
383                         == AUDIO_POLICY_FORCE_BT_SCO) {
384                     if (!devices2.isEmpty()) {
385                         devices = devices2;
386                         break;
387                     }
388                 }
389             }
390             // Use both Bluetooth SCO and phone default output when ringing in normal mode
391             if (audio_is_bluetooth_out_sco_device(getPreferredDeviceTypeForLegacyStrategy(
392                     availableOutputDevices, STRATEGY_PHONE))) {
393                 if (strategy == STRATEGY_SONIFICATION) {
394                     devices.replaceDevicesByType(
395                             AUDIO_DEVICE_OUT_SPEAKER,
396                             availableOutputDevices.getDevicesFromType(
397                                     AUDIO_DEVICE_OUT_SPEAKER_SAFE));
398                 }
399                 if (!devices2.isEmpty()) {
400                     devices.add(devices2);
401                     break;
402                 }
403             }
404         }
405         // The second device used for sonification is the same as the device used by media strategy
406         FALLTHROUGH_INTENDED;
407 
408     case STRATEGY_DTMF:
409     case STRATEGY_ACCESSIBILITY:
410     case STRATEGY_SONIFICATION_RESPECTFUL:
411     case STRATEGY_REROUTING:
412     case STRATEGY_MEDIA: {
413         DeviceVector devices2;
414         if (strategy != STRATEGY_SONIFICATION) {
415             // no sonification on remote submix (e.g. WFD)
416             sp<DeviceDescriptor> remoteSubmix;
417             if ((remoteSubmix = availableOutputDevices.getDevice(
418                     AUDIO_DEVICE_OUT_REMOTE_SUBMIX, String8("0"),
419                     AUDIO_FORMAT_DEFAULT)) != nullptr) {
420                 devices2.add(remoteSubmix);
421             }
422         }
423 
424         if ((devices2.isEmpty()) &&
425             (getForceUse(AUDIO_POLICY_FORCE_FOR_MEDIA) == AUDIO_POLICY_FORCE_SPEAKER)) {
426             devices2 = availableOutputDevices.getDevicesFromType(AUDIO_DEVICE_OUT_SPEAKER);
427         }
428 
429         // LE audio broadcast device is only used if:
430         // - No call is active
431         // - either MEDIA or SONIFICATION_RESPECTFUL is the highest priority active strategy
432         //   OR the LE audio unicast device is not active
433         if (devices2.isEmpty() && !isInCall()
434                 && (strategy == STRATEGY_MEDIA || strategy == STRATEGY_SONIFICATION_RESPECTFUL)) {
435             legacy_strategy topActiveStrategy = STRATEGY_NONE;
436             for (const auto &ps : getOrderedProductStrategies()) {
437                 if (outputs.isStrategyActive(ps)) {
438                     topActiveStrategy =  mLegacyStrategyMap.find(ps) != end(mLegacyStrategyMap) ?
439                             mLegacyStrategyMap.at(ps) : STRATEGY_NONE;
440                     break;
441                 }
442             }
443 
444             if (topActiveStrategy == STRATEGY_NONE || topActiveStrategy == STRATEGY_MEDIA
445                     || topActiveStrategy == STRATEGY_SONIFICATION_RESPECTFUL
446                     || !outputs.isAnyDeviceTypeActive(getAudioDeviceOutLeAudioUnicastSet())) {
447                 devices2 =
448                         availableOutputDevices.getDevicesFromType(AUDIO_DEVICE_OUT_BLE_BROADCAST);
449             }
450         }
451 
452         if (devices2.isEmpty() && (getLastRemovableMediaDevices().size() > 0)) {
453             std::vector<audio_devices_t> excludedDevices;
454             // no sonification on aux digital (e.g. HDMI)
455             if (strategy == STRATEGY_SONIFICATION) {
456                 excludedDevices.push_back(AUDIO_DEVICE_OUT_AUX_DIGITAL);
457             }
458             if ((getForceUse(AUDIO_POLICY_FORCE_FOR_MEDIA) != AUDIO_POLICY_FORCE_NO_BT_A2DP)) {
459                 // Get the last connected device of wired and bluetooth a2dp
460                 devices2 = availableOutputDevices.getFirstDevicesFromTypes(
461                         getLastRemovableMediaDevices(GROUP_NONE, excludedDevices));
462             } else {
463                 // Get the last connected device of wired except bluetooth a2dp
464                 devices2 = availableOutputDevices.getFirstDevicesFromTypes(
465                         getLastRemovableMediaDevices(GROUP_WIRED, excludedDevices));
466             }
467         }
468 
469         if (com::android::media::audioserver::use_bt_sco_for_media()) {
470             if (devices2.isEmpty() && isBtScoActive(availableOutputDevices, outputs)) {
471                 devices2 = availableOutputDevices.getFirstDevicesFromTypes(
472                         { AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT,
473                           AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET,
474                           AUDIO_DEVICE_OUT_BLUETOOTH_SCO});
475             }
476         }
477 
478         if ((devices2.isEmpty()) &&
479                 (getForceUse(AUDIO_POLICY_FORCE_FOR_DOCK) == AUDIO_POLICY_FORCE_ANALOG_DOCK)) {
480             devices2 = availableOutputDevices.getDevicesFromType(
481                     AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET);
482         }
483 
484         if (devices2.isEmpty()) {
485             devices2 = availableOutputDevices.getFirstDevicesFromTypes({
486                         AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET, AUDIO_DEVICE_OUT_SPEAKER});
487         }
488 
489         DeviceVector devices3;
490         if (strategy == STRATEGY_MEDIA) {
491             // ARC, SPDIF and AUX_LINE can co-exist with others.
492             devices3 = availableOutputDevices.getDevicesFromTypes({
493                     AUDIO_DEVICE_OUT_HDMI_ARC, AUDIO_DEVICE_OUT_HDMI_EARC,
494                     AUDIO_DEVICE_OUT_SPDIF, AUDIO_DEVICE_OUT_AUX_LINE,
495                     });
496         }
497 
498         devices2.add(devices3);
499         // device is DEVICE_OUT_SPEAKER if we come from case STRATEGY_SONIFICATION or
500         // STRATEGY_ENFORCED_AUDIBLE, AUDIO_DEVICE_NONE otherwise
501         devices.add(devices2);
502 
503         // If hdmi system audio mode is on, remove speaker out of output list.
504         if ((strategy == STRATEGY_MEDIA) &&
505             (getForceUse(AUDIO_POLICY_FORCE_FOR_HDMI_SYSTEM_AUDIO) ==
506                 AUDIO_POLICY_FORCE_HDMI_SYSTEM_AUDIO_ENFORCED)) {
507             devices.remove(devices.getDevicesFromType(AUDIO_DEVICE_OUT_SPEAKER));
508         }
509 
510         bool mediaActiveLocally =
511                 outputs.isActiveLocally(toVolumeSource(AUDIO_STREAM_MUSIC),
512                                         SONIFICATION_RESPECTFUL_AFTER_MUSIC_DELAY)
513                 || outputs.isActiveLocally(
514                     toVolumeSource(AUDIO_STREAM_ACCESSIBILITY),
515                     SONIFICATION_RESPECTFUL_AFTER_MUSIC_DELAY);
516 
517         bool ringActiveLocally = outputs.isActiveLocally(toVolumeSource(AUDIO_STREAM_RING), 0);
518         // - for STRATEGY_SONIFICATION and ringtone active:
519         // if SPEAKER was selected, and SPEAKER_SAFE is available, use SPEAKER_SAFE instead
520         // - for STRATEGY_SONIFICATION_RESPECTFUL:
521         // if no media is playing on the device, check for mandatory use of "safe" speaker
522         // when media would have played on speaker, and the safe speaker path is available
523         if (strategy == STRATEGY_SONIFICATION || ringActiveLocally
524             || (strategy == STRATEGY_SONIFICATION_RESPECTFUL && !mediaActiveLocally)) {
525             devices.replaceDevicesByType(
526                     AUDIO_DEVICE_OUT_SPEAKER,
527                     availableOutputDevices.getDevicesFromType(
528                             AUDIO_DEVICE_OUT_SPEAKER_SAFE));
529         }
530         } break;
531 
532     case STRATEGY_CALL_ASSISTANT:
533         devices = availableOutputDevices.getDevicesFromType(AUDIO_DEVICE_OUT_TELEPHONY_TX);
534         break;
535 
536     case STRATEGY_NONE:
537         // Happens when internal strategies are processed ("rerouting", "patch"...)
538         break;
539 
540     default:
541         ALOGW("%s unknown strategy: %d", __func__, strategy);
542         break;
543     }
544 
545     if (devices.isEmpty()) {
546         ALOGI("%s no device found for strategy %d", __func__, strategy);
547         sp<DeviceDescriptor> defaultOutputDevice = getApmObserver()->getDefaultOutputDevice();
548         if (defaultOutputDevice != nullptr) {
549             devices.add(defaultOutputDevice);
550         }
551         ALOGE_IF(devices.isEmpty(),
552                  "%s no default device defined", __func__);
553     }
554 
555     ALOGVV("%s strategy %d, device %s", __func__,
556            strategy, dumpDeviceTypes(devices.types()).c_str());
557     return devices;
558 }
559 
getPreferredAvailableDevicesForInputSource(const DeviceVector & availableInputDevices,audio_source_t inputSource) const560 DeviceVector Engine::getPreferredAvailableDevicesForInputSource(
561             const DeviceVector& availableInputDevices, audio_source_t inputSource) const {
562     DeviceVector preferredAvailableDevVec = {};
563     AudioDeviceTypeAddrVector preferredDevices;
564     const status_t status = getDevicesForRoleAndCapturePreset(
565             inputSource, DEVICE_ROLE_PREFERRED, preferredDevices);
566     if (status == NO_ERROR) {
567         // Only use preferred devices when they are all available.
568         preferredAvailableDevVec =
569                 availableInputDevices.getDevicesFromDeviceTypeAddrVec(preferredDevices);
570         if (preferredAvailableDevVec.size() == preferredDevices.size()) {
571             ALOGVV("%s using pref device %s for source %u",
572                    __func__, preferredAvailableDevVec.toString().c_str(), inputSource);
573             return preferredAvailableDevVec;
574         }
575     }
576     return preferredAvailableDevVec;
577 }
578 
getDisabledDevicesForInputSource(const DeviceVector & availableInputDevices,audio_source_t inputSource) const579 DeviceVector Engine::getDisabledDevicesForInputSource(
580             const DeviceVector& availableInputDevices, audio_source_t inputSource) const {
581     DeviceVector disabledDevices = {};
582     AudioDeviceTypeAddrVector disabledDevicesTypeAddr;
583     const status_t status = getDevicesForRoleAndCapturePreset(
584             inputSource, DEVICE_ROLE_DISABLED, disabledDevicesTypeAddr);
585     if (status == NO_ERROR) {
586         disabledDevices =
587                 availableInputDevices.getDevicesFromDeviceTypeAddrVec(disabledDevicesTypeAddr);
588     }
589     return disabledDevices;
590 }
591 
getDeviceForInputSource(audio_source_t inputSource) const592 sp<DeviceDescriptor> Engine::getDeviceForInputSource(audio_source_t inputSource) const
593 {
594     const DeviceVector availableOutputDevices = getApmObserver()->getAvailableOutputDevices();
595     const DeviceVector availableInputDevices = getApmObserver()->getAvailableInputDevices();
596     const SwAudioOutputCollection &outputs = getApmObserver()->getOutputs();
597     DeviceVector availableDevices = availableInputDevices;
598     sp<AudioOutputDescriptor> primaryOutput = outputs.getPrimaryOutput();
599     DeviceVector availablePrimaryDevices = primaryOutput == nullptr ? DeviceVector()
600             : availableInputDevices.getDevicesFromHwModule(primaryOutput->getModuleHandle());
601     sp<DeviceDescriptor> device;
602 
603     // when a call is active, force device selection to match source VOICE_COMMUNICATION
604     // for most other input sources to avoid rerouting call TX audio
605     if (isInCall()) {
606         switch (inputSource) {
607         case AUDIO_SOURCE_DEFAULT:
608         case AUDIO_SOURCE_MIC:
609         case AUDIO_SOURCE_VOICE_RECOGNITION:
610         case AUDIO_SOURCE_UNPROCESSED:
611         case AUDIO_SOURCE_HOTWORD:
612         case AUDIO_SOURCE_CAMCORDER:
613         case AUDIO_SOURCE_VOICE_PERFORMANCE:
614         case AUDIO_SOURCE_ULTRASOUND:
615             inputSource = AUDIO_SOURCE_VOICE_COMMUNICATION;
616             break;
617         default:
618             break;
619         }
620     }
621 
622     // Use the preferred device for the input source if it is available.
623     DeviceVector preferredInputDevices = getPreferredAvailableDevicesForInputSource(
624             availableDevices, inputSource);
625     if (!preferredInputDevices.isEmpty()) {
626         // Currently, only support single device for input. The public JAVA API also only
627         // support setting single device as preferred device. In that case, returning the
628         // first device is OK here.
629         return preferredInputDevices[0];
630     }
631     // Remove the disabled device for the input source from the available input device list.
632     DeviceVector disabledInputDevices = getDisabledDevicesForInputSource(
633             availableDevices, inputSource);
634     availableDevices.remove(disabledInputDevices);
635 
636     audio_devices_t commDeviceType =
637         getPreferredDeviceTypeForLegacyStrategy(availableOutputDevices, STRATEGY_PHONE);
638 
639     switch (inputSource) {
640     case AUDIO_SOURCE_DEFAULT:
641     case AUDIO_SOURCE_MIC:
642         device = availableDevices.getDevice(
643                 AUDIO_DEVICE_IN_BLUETOOTH_A2DP, String8(""), AUDIO_FORMAT_DEFAULT);
644         if (device != nullptr) break;
645         if (audio_is_bluetooth_out_sco_device(commDeviceType)) {
646             device = availableDevices.getDevice(
647                     AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET, String8(""), AUDIO_FORMAT_DEFAULT);
648             if (device != nullptr) break;
649         }
650         device = availableDevices.getFirstExistingDevice({
651                 AUDIO_DEVICE_IN_WIRED_HEADSET,
652                 AUDIO_DEVICE_IN_USB_HEADSET, AUDIO_DEVICE_IN_USB_DEVICE,
653                 AUDIO_DEVICE_IN_BLUETOOTH_BLE, AUDIO_DEVICE_IN_BUILTIN_MIC});
654         break;
655 
656     case AUDIO_SOURCE_VOICE_COMMUNICATION:
657         // Allow only use of devices on primary input if in call and HAL does not support routing
658         // to voice call path.
659         if ((getPhoneState() == AUDIO_MODE_IN_CALL) &&
660                 (availableOutputDevices.getDevice(AUDIO_DEVICE_OUT_TELEPHONY_TX,
661                         String8(""), AUDIO_FORMAT_DEFAULT)) == nullptr) {
662             if (!availablePrimaryDevices.isEmpty()) {
663                 availableDevices = availablePrimaryDevices;
664             } else {
665                 ALOGE("%s, AUDIO_SOURCE_VOICE_COMMUNICATION: Primary devices not found", __func__);
666             }
667         }
668 
669         if (audio_is_bluetooth_out_sco_device(commDeviceType)) {
670             // if SCO device is requested but no SCO device is available, fall back to default case
671             device = availableDevices.getDevice(
672                     AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET, String8(""), AUDIO_FORMAT_DEFAULT);
673             if (device != nullptr) {
674                 break;
675             }
676         }
677         switch (commDeviceType) {
678         case AUDIO_DEVICE_OUT_SPEAKER:
679             device = availableDevices.getFirstExistingDevice({
680                     AUDIO_DEVICE_IN_BACK_MIC, AUDIO_DEVICE_IN_BUILTIN_MIC,
681                     AUDIO_DEVICE_IN_USB_DEVICE, AUDIO_DEVICE_IN_USB_HEADSET});
682             break;
683         case AUDIO_DEVICE_OUT_BLE_HEADSET:
684             device = availableDevices.getDevice(
685                     AUDIO_DEVICE_IN_BLE_HEADSET, String8(""), AUDIO_FORMAT_DEFAULT);
686             if (device != nullptr) {
687                 break;
688             }
689             ALOGE("%s LE Audio selected for communication but input device not available",
690                     __func__);
691             FALLTHROUGH_INTENDED;
692         default:    // FORCE_NONE
693             device = availableDevices.getFirstExistingDevice({
694                     AUDIO_DEVICE_IN_WIRED_HEADSET, AUDIO_DEVICE_IN_USB_HEADSET,
695                     AUDIO_DEVICE_IN_USB_DEVICE, AUDIO_DEVICE_IN_BLUETOOTH_BLE,
696                     AUDIO_DEVICE_IN_BUILTIN_MIC});
697             break;
698         }
699         break;
700 
701     case AUDIO_SOURCE_VOICE_RECOGNITION:
702     case AUDIO_SOURCE_UNPROCESSED:
703         if (audio_is_bluetooth_out_sco_device(commDeviceType)) {
704             device = availableDevices.getDevice(
705                     AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET, String8(""), AUDIO_FORMAT_DEFAULT);
706             if (device != nullptr) break;
707         }
708         // we need to make BLUETOOTH_BLE has higher priority than BUILTIN_MIC,
709         // because sometimes user want to do voice search by bt remote
710         // even if BUILDIN_MIC is available.
711         device = availableDevices.getFirstExistingDevice({
712                 AUDIO_DEVICE_IN_WIRED_HEADSET,
713                 AUDIO_DEVICE_IN_USB_HEADSET, AUDIO_DEVICE_IN_USB_DEVICE,
714                 AUDIO_DEVICE_IN_BLUETOOTH_BLE, AUDIO_DEVICE_IN_BUILTIN_MIC});
715 
716         break;
717     case AUDIO_SOURCE_HOTWORD:
718         // We should not use primary output criteria for Hotword but rather limit
719         // to devices attached to the same HW module as the build in mic
720         if (!availablePrimaryDevices.isEmpty()) {
721             availableDevices = availablePrimaryDevices;
722         } else {
723             ALOGE("%s, AUDIO_SOURCE_HOTWORD: Primary devices not found", __func__);
724         }
725         if (audio_is_bluetooth_out_sco_device(commDeviceType)) {
726             device = availableDevices.getDevice(
727                     AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET, String8(""), AUDIO_FORMAT_DEFAULT);
728             if (device != nullptr) break;
729         }
730         device = availableDevices.getFirstExistingDevice({
731                 AUDIO_DEVICE_IN_WIRED_HEADSET,
732                 AUDIO_DEVICE_IN_USB_HEADSET, AUDIO_DEVICE_IN_USB_DEVICE,
733                 AUDIO_DEVICE_IN_BUILTIN_MIC});
734         break;
735     case AUDIO_SOURCE_CAMCORDER:
736         // For a device without built-in mic, adding usb device
737         device = availableDevices.getFirstExistingDevice({
738                 AUDIO_DEVICE_IN_BACK_MIC, AUDIO_DEVICE_IN_BUILTIN_MIC,
739                 AUDIO_DEVICE_IN_USB_DEVICE});
740         break;
741     case AUDIO_SOURCE_VOICE_DOWNLINK:
742     case AUDIO_SOURCE_VOICE_CALL:
743     case AUDIO_SOURCE_VOICE_UPLINK:
744         device = availableDevices.getDevice(
745                 AUDIO_DEVICE_IN_VOICE_CALL, String8(""), AUDIO_FORMAT_DEFAULT);
746         break;
747     case AUDIO_SOURCE_VOICE_PERFORMANCE:
748         device = availableDevices.getFirstExistingDevice({
749                 AUDIO_DEVICE_IN_WIRED_HEADSET, AUDIO_DEVICE_IN_USB_HEADSET,
750                 AUDIO_DEVICE_IN_USB_DEVICE, AUDIO_DEVICE_IN_BLUETOOTH_BLE,
751                 AUDIO_DEVICE_IN_BUILTIN_MIC});
752         break;
753     case AUDIO_SOURCE_REMOTE_SUBMIX:
754         device = availableDevices.getDevice(
755                 AUDIO_DEVICE_IN_REMOTE_SUBMIX, String8(""), AUDIO_FORMAT_DEFAULT);
756         break;
757     case AUDIO_SOURCE_FM_TUNER:
758         device = availableDevices.getDevice(
759                 AUDIO_DEVICE_IN_FM_TUNER, String8(""), AUDIO_FORMAT_DEFAULT);
760         break;
761     case AUDIO_SOURCE_ECHO_REFERENCE:
762         device = availableDevices.getDevice(
763                 AUDIO_DEVICE_IN_ECHO_REFERENCE, String8(""), AUDIO_FORMAT_DEFAULT);
764         break;
765     case AUDIO_SOURCE_ULTRASOUND:
766         device = availableDevices.getFirstExistingDevice({
767                 AUDIO_DEVICE_IN_BUILTIN_MIC, AUDIO_DEVICE_IN_BACK_MIC});
768         break;
769     default:
770         ALOGW("getDeviceForInputSource() invalid input source %d", inputSource);
771         break;
772     }
773     if (device == nullptr) {
774         ALOGV("getDeviceForInputSource() no device found for source %d", inputSource);
775         device = availableDevices.getDevice(
776                 AUDIO_DEVICE_IN_STUB, String8(""), AUDIO_FORMAT_DEFAULT);
777         ALOGE_IF(device == nullptr,
778                  "getDeviceForInputSource() no default device defined");
779     }
780 
781     ALOGV_IF(device != nullptr,
782              "getDeviceForInputSource()input source %d, device %08x",
783              inputSource, device->type());
784     return device;
785 }
786 
setStrategyDevices(const sp<ProductStrategy> & strategy,const DeviceVector & devices)787 void Engine::setStrategyDevices(const sp<ProductStrategy>& strategy, const DeviceVector &devices) {
788     strategy->setDeviceTypes(devices.types());
789     strategy->setDeviceAddress(devices.getFirstValidAddress().c_str());
790 }
791 
getProductStrategyFromLegacy(legacy_strategy legacyStrategy) const792 product_strategy_t Engine::getProductStrategyFromLegacy(legacy_strategy legacyStrategy) const {
793     for (const auto& strategyMap : mLegacyStrategyMap) {
794         if (strategyMap.second == legacyStrategy) {
795             return strategyMap.first;
796         }
797     }
798     return PRODUCT_STRATEGY_NONE;
799 }
800 
getPreferredDeviceTypeForLegacyStrategy(const DeviceVector & availableOutputDevices,legacy_strategy legacyStrategy) const801 audio_devices_t Engine::getPreferredDeviceTypeForLegacyStrategy(
802         const DeviceVector& availableOutputDevices, legacy_strategy legacyStrategy) const {
803     product_strategy_t strategy = getProductStrategyFromLegacy(legacyStrategy);
804     DeviceVector devices = getPreferredAvailableDevicesForProductStrategy(
805             availableOutputDevices, strategy);
806     if (devices.size() > 0) {
807         return devices[0]->type();
808     }
809     return AUDIO_DEVICE_NONE;
810 }
811 
getDevicesForProductStrategy(product_strategy_t strategy) const812 DeviceVector Engine::getDevicesForProductStrategy(product_strategy_t strategy) const {
813     const SwAudioOutputCollection& outputs = getApmObserver()->getOutputs();
814 
815     // Take context into account to remap product strategy before
816     // checking preferred device for strategy and applying default routing rules
817     strategy = remapStrategyFromContext(strategy, outputs);
818 
819     auto legacyStrategy = mLegacyStrategyMap.find(strategy) != end(mLegacyStrategyMap) ?
820                           mLegacyStrategyMap.at(strategy) : STRATEGY_NONE;
821 
822     DeviceVector availableOutputDevices = getApmObserver()->getAvailableOutputDevices();
823 
824     filterOutputDevicesForStrategy(legacyStrategy, availableOutputDevices, outputs);
825 
826     // check if this strategy has a preferred device that is available,
827     // if yes, give priority to it.
828     DeviceVector preferredAvailableDevVec =
829             getPreferredAvailableDevicesForProductStrategy(availableOutputDevices, strategy);
830     if (!preferredAvailableDevVec.isEmpty()) {
831         return preferredAvailableDevVec;
832     }
833 
834     // Remove all disabled devices from the available device list.
835     DeviceVector disabledDevVec =
836             getDisabledDevicesForProductStrategy(availableOutputDevices, strategy);
837     availableOutputDevices.remove(disabledDevVec);
838 
839     return getDevicesForStrategyInt(legacyStrategy,
840                                     availableOutputDevices,
841                                     outputs);
842 }
843 
getOutputDevicesForAttributes(const audio_attributes_t & attributes,const sp<DeviceDescriptor> & preferredDevice,bool fromCache) const844 DeviceVector Engine::getOutputDevicesForAttributes(const audio_attributes_t &attributes,
845                                                    const sp<DeviceDescriptor> &preferredDevice,
846                                                    bool fromCache) const
847 {
848     // First check for explict routing device
849     if (preferredDevice != nullptr) {
850         ALOGV("%s explicit Routing on device %s", __func__, preferredDevice->toString().c_str());
851         return DeviceVector(preferredDevice);
852     }
853     product_strategy_t strategy = getProductStrategyForAttributes(attributes);
854     const DeviceVector availableOutputDevices = getApmObserver()->getAvailableOutputDevices();
855     const SwAudioOutputCollection &outputs = getApmObserver()->getOutputs();
856     //
857     // @TODO: what is the priority of explicit routing? Shall it be considered first as it used to
858     // be by APM?
859     //
860     // Honor explicit routing requests only if all active clients have a preferred route in which
861     // case the last active client route is used
862     sp<DeviceDescriptor> device = findPreferredDevice(outputs, strategy, availableOutputDevices);
863     if (device != nullptr) {
864         return DeviceVector(device);
865     }
866 
867     return fromCache? mDevicesForStrategies.at(strategy) : getDevicesForProductStrategy(strategy);
868 }
869 
getOutputDevicesForStream(audio_stream_type_t stream,bool fromCache) const870 DeviceVector Engine::getOutputDevicesForStream(audio_stream_type_t stream, bool fromCache) const
871 {
872     auto attributes = getAttributesForStreamType(stream);
873     return getOutputDevicesForAttributes(attributes, nullptr, fromCache);
874 }
875 
getInputDeviceForAttributes(const audio_attributes_t & attr,uid_t uid,audio_session_t session,sp<AudioPolicyMix> * mix) const876 sp<DeviceDescriptor> Engine::getInputDeviceForAttributes(const audio_attributes_t &attr,
877                                                          uid_t uid,
878                                                          audio_session_t session,
879                                                          sp<AudioPolicyMix> *mix) const
880 {
881     const auto &policyMixes = getApmObserver()->getAudioPolicyMixCollection();
882     const auto availableInputDevices = getApmObserver()->getAvailableInputDevices();
883     const auto &inputs = getApmObserver()->getInputs();
884     std::string address;
885 
886     //
887     // Explicit Routing ??? what is the priority of explicit routing? Shall it be considered
888     // first as it used to be by APM?
889     //
890     // Honor explicit routing requests only if all active clients have a preferred route in which
891     // case the last active client route is used
892     sp<DeviceDescriptor> device =
893             findPreferredDevice(inputs, attr.source, availableInputDevices);
894     if (device != nullptr) {
895         return device;
896     }
897 
898     device = policyMixes.getDeviceAndMixForInputSource(attr,
899                                                        availableInputDevices,
900                                                        uid,
901                                                        session,
902                                                        mix);
903     if (device != nullptr) {
904         return device;
905     }
906 
907     device = getDeviceForInputSource(attr.source);
908     if (device == nullptr || !audio_is_remote_submix_device(device->type())) {
909         // Return immediately if the device is null or it is not a remote submix device.
910         return device;
911     }
912 
913     // For remote submix device, try to find the device by address.
914     address = "0";
915     std::size_t pos;
916     std::string tags { attr.tags };
917     if ((pos = tags.find("addr=")) != std::string::npos) {
918         address = tags.substr(pos + std::strlen("addr="));
919     }
920     return availableInputDevices.getDevice(device->type(),
921                                            String8(address.c_str()),
922                                            AUDIO_FORMAT_DEFAULT);
923 }
924 
925 } // namespace android::audio_policy
926