892 lines
37 KiB
C++
892 lines
37 KiB
C++
/*
|
|
* Copyright (c) 2013-2014, The Linux Foundation. All rights reserved.
|
|
* Not a contribution.
|
|
*
|
|
* Copyright (C) 2009 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#define LOG_TAG "AudioPolicyManager"
|
|
//#define LOG_NDEBUG 0
|
|
|
|
//#define VERY_VERBOSE_LOGGING
|
|
#ifdef VERY_VERBOSE_LOGGING
|
|
#define ALOGVV ALOGV
|
|
#else
|
|
#define ALOGVV(a...) do { } while(0)
|
|
#endif
|
|
|
|
// A device mask for all audio output devices that are considered "remote" when evaluating
|
|
// active output devices in isStreamActiveRemotely()
|
|
#define APM_AUDIO_OUT_DEVICE_REMOTE_ALL AUDIO_DEVICE_OUT_REMOTE_SUBMIX
|
|
|
|
#include <utils/Log.h>
|
|
#include "AudioPolicyManager.h"
|
|
#include <hardware/audio_effect.h>
|
|
#include <hardware/audio.h>
|
|
#include <math.h>
|
|
#include <hardware_legacy/audio_policy_conf.h>
|
|
#include <cutils/properties.h>
|
|
|
|
namespace android_audio_legacy {
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// AudioPolicyInterface implementation
|
|
// ----------------------------------------------------------------------------
|
|
|
|
status_t AudioPolicyManager::setDeviceConnectionState(audio_devices_t device,
|
|
AudioSystem::device_connection_state state,
|
|
const char *device_address)
|
|
{
|
|
SortedVector <audio_io_handle_t> outputs;
|
|
|
|
ALOGV("setDeviceConnectionState() device: %x, state %d, address %s", device, state, device_address);
|
|
|
|
// connect/disconnect only 1 device at a time
|
|
if (!audio_is_output_device(device) && !audio_is_input_device(device)) return BAD_VALUE;
|
|
|
|
if (strlen(device_address) >= MAX_DEVICE_ADDRESS_LEN) {
|
|
ALOGE("setDeviceConnectionState() invalid address: %s", device_address);
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
// handle output devices
|
|
if (audio_is_output_device(device)) {
|
|
|
|
if (!mHasA2dp && audio_is_a2dp_device(device)) {
|
|
ALOGE("setDeviceConnectionState() invalid A2DP device: %x", device);
|
|
return BAD_VALUE;
|
|
}
|
|
if (!mHasUsb && audio_is_usb_device(device)) {
|
|
ALOGE("setDeviceConnectionState() invalid USB audio device: %x", device);
|
|
return BAD_VALUE;
|
|
}
|
|
if (!mHasRemoteSubmix && audio_is_remote_submix_device((audio_devices_t)device)) {
|
|
ALOGE("setDeviceConnectionState() invalid remote submix audio device: %x", device);
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
// save a copy of the opened output descriptors before any output is opened or closed
|
|
// by checkOutputsForDevice(). This will be needed by checkOutputForAllStrategies()
|
|
mPreviousOutputs = mOutputs;
|
|
switch (state)
|
|
{
|
|
// handle output device connection
|
|
case AudioSystem::DEVICE_STATE_AVAILABLE:
|
|
if (mAvailableOutputDevices & device) {
|
|
ALOGW("setDeviceConnectionState() device already connected: %x", device);
|
|
return INVALID_OPERATION;
|
|
}
|
|
ALOGV("setDeviceConnectionState() connecting device %x", device);
|
|
|
|
if (checkOutputsForDevice(device, state, outputs) != NO_ERROR) {
|
|
return INVALID_OPERATION;
|
|
}
|
|
ALOGV("setDeviceConnectionState() checkOutputsForDevice() returned %d outputs",
|
|
outputs.size());
|
|
// register new device as available
|
|
mAvailableOutputDevices = (audio_devices_t)(mAvailableOutputDevices | device);
|
|
|
|
if (!outputs.isEmpty()) {
|
|
String8 paramStr;
|
|
if (mHasA2dp && audio_is_a2dp_device(device)) {
|
|
// handle A2DP device connection
|
|
AudioParameter param;
|
|
param.add(String8(AUDIO_PARAMETER_A2DP_SINK_ADDRESS), String8(device_address));
|
|
paramStr = param.toString();
|
|
mA2dpDeviceAddress = String8(device_address, MAX_DEVICE_ADDRESS_LEN);
|
|
mA2dpSuspended = false;
|
|
} else if (audio_is_bluetooth_sco_device(device)) {
|
|
// handle SCO device connection
|
|
mScoDeviceAddress = String8(device_address, MAX_DEVICE_ADDRESS_LEN);
|
|
} else if (mHasUsb && audio_is_usb_device(device)) {
|
|
// handle USB device connection
|
|
mUsbCardAndDevice = String8(device_address, MAX_DEVICE_ADDRESS_LEN);
|
|
paramStr = mUsbCardAndDevice;
|
|
}
|
|
// not currently handling multiple simultaneous submixes: ignoring remote submix
|
|
// case and address
|
|
if (!paramStr.isEmpty()) {
|
|
for (size_t i = 0; i < outputs.size(); i++) {
|
|
mpClientInterface->setParameters(outputs[i], paramStr);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
// handle output device disconnection
|
|
case AudioSystem::DEVICE_STATE_UNAVAILABLE: {
|
|
if (!(mAvailableOutputDevices & device)) {
|
|
ALOGW("setDeviceConnectionState() device not connected: %x", device);
|
|
return INVALID_OPERATION;
|
|
}
|
|
|
|
ALOGV("setDeviceConnectionState() disconnecting device %x", device);
|
|
// remove device from available output devices
|
|
mAvailableOutputDevices = (audio_devices_t)(mAvailableOutputDevices & ~device);
|
|
|
|
checkOutputsForDevice(device, state, outputs);
|
|
if (mHasA2dp && audio_is_a2dp_device(device)) {
|
|
// handle A2DP device disconnection
|
|
mA2dpDeviceAddress = "";
|
|
mA2dpSuspended = false;
|
|
} else if (audio_is_bluetooth_sco_device(device)) {
|
|
// handle SCO device disconnection
|
|
mScoDeviceAddress = "";
|
|
} else if (mHasUsb && audio_is_usb_device(device)) {
|
|
// handle USB device disconnection
|
|
mUsbCardAndDevice = "";
|
|
}
|
|
// not currently handling multiple simultaneous submixes: ignoring remote submix
|
|
// case and address
|
|
} break;
|
|
|
|
default:
|
|
ALOGE("setDeviceConnectionState() invalid state: %x", state);
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
checkA2dpSuspend();
|
|
checkOutputForAllStrategies();
|
|
// outputs must be closed after checkOutputForAllStrategies() is executed
|
|
if (!outputs.isEmpty()) {
|
|
for (size_t i = 0; i < outputs.size(); i++) {
|
|
AudioOutputDescriptor *desc = mOutputs.valueFor(outputs[i]);
|
|
// close unused outputs after device disconnection or direct outputs that have been
|
|
// opened by checkOutputsForDevice() to query dynamic parameters
|
|
if ((state == AudioSystem::DEVICE_STATE_UNAVAILABLE) ||
|
|
(((desc->mFlags & AUDIO_OUTPUT_FLAG_DIRECT) != 0) &&
|
|
(desc->mDirectOpenCount == 0))) {
|
|
closeOutput(outputs[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
updateDevicesAndOutputs();
|
|
audio_devices_t newDevice = getNewDevice(mPrimaryOutput, false /*fromCache*/);
|
|
#ifdef AUDIO_EXTN_FM_ENABLED
|
|
if(device == AUDIO_DEVICE_OUT_FM) {
|
|
if (state == AudioSystem::DEVICE_STATE_AVAILABLE) {
|
|
mOutputs.valueFor(mPrimaryOutput)->changeRefCount(AudioSystem::MUSIC, 1);
|
|
newDevice = (audio_devices_t)(getNewDevice(mPrimaryOutput, false) | AUDIO_DEVICE_OUT_FM);
|
|
} else {
|
|
mOutputs.valueFor(mPrimaryOutput)->changeRefCount(AudioSystem::MUSIC, -1);
|
|
}
|
|
|
|
AudioParameter param = AudioParameter();
|
|
param.addInt(String8("handle_fm"), (int)newDevice);
|
|
ALOGV("setDeviceConnectionState() setParameters handle_fm");
|
|
mpClientInterface->setParameters(mPrimaryOutput, param.toString());
|
|
}
|
|
#endif
|
|
for (size_t i = 0; i < mOutputs.size(); i++) {
|
|
// do not force device change on duplicated output because if device is 0, it will
|
|
// also force a device 0 for the two outputs it is duplicated to which may override
|
|
// a valid device selection on those outputs.
|
|
setOutputDevice(mOutputs.keyAt(i),
|
|
getNewDevice(mOutputs.keyAt(i), true /*fromCache*/),
|
|
!mOutputs.valueAt(i)->isDuplicated(),
|
|
0);
|
|
}
|
|
|
|
if (device == AUDIO_DEVICE_OUT_WIRED_HEADSET) {
|
|
device = AUDIO_DEVICE_IN_WIRED_HEADSET;
|
|
} else if (device == AUDIO_DEVICE_OUT_BLUETOOTH_SCO ||
|
|
device == AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET ||
|
|
device == AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT) {
|
|
device = AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET;
|
|
} else if(device == AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET){
|
|
device = AUDIO_DEVICE_IN_ANLG_DOCK_HEADSET;
|
|
} else {
|
|
return NO_ERROR;
|
|
}
|
|
}
|
|
// handle input devices
|
|
if (audio_is_input_device(device)) {
|
|
|
|
switch (state)
|
|
{
|
|
// handle input device connection
|
|
case AudioSystem::DEVICE_STATE_AVAILABLE: {
|
|
if (mAvailableInputDevices & device) {
|
|
ALOGW("setDeviceConnectionState() device already connected: %d", device);
|
|
return INVALID_OPERATION;
|
|
}
|
|
mAvailableInputDevices = mAvailableInputDevices | (device & ~AUDIO_DEVICE_BIT_IN);
|
|
}
|
|
break;
|
|
|
|
// handle input device disconnection
|
|
case AudioSystem::DEVICE_STATE_UNAVAILABLE: {
|
|
if (!(mAvailableInputDevices & device)) {
|
|
ALOGW("setDeviceConnectionState() device not connected: %d", device);
|
|
return INVALID_OPERATION;
|
|
}
|
|
mAvailableInputDevices = (audio_devices_t) (mAvailableInputDevices & ~device);
|
|
} break;
|
|
|
|
default:
|
|
ALOGE("setDeviceConnectionState() invalid state: %x", state);
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
audio_io_handle_t activeInput = getActiveInput();
|
|
if (activeInput != 0) {
|
|
AudioInputDescriptor *inputDesc = mInputs.valueFor(activeInput);
|
|
audio_devices_t newDevice = getDeviceForInputSource(inputDesc->mInputSource);
|
|
if ((newDevice != AUDIO_DEVICE_NONE) && (newDevice != inputDesc->mDevice)) {
|
|
ALOGV("setDeviceConnectionState() changing device from %x to %x for input %d",
|
|
inputDesc->mDevice, newDevice, activeInput);
|
|
inputDesc->mDevice = newDevice;
|
|
AudioParameter param = AudioParameter();
|
|
param.addInt(String8(AudioParameter::keyRouting), (int)newDevice);
|
|
mpClientInterface->setParameters(activeInput, param.toString());
|
|
}
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
ALOGW("setDeviceConnectionState() invalid device: %x", device);
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
void AudioPolicyManager::setForceUse(AudioSystem::force_use usage, AudioSystem::forced_config config)
|
|
{
|
|
ALOGV("setForceUse() usage %d, config %d, mPhoneState %d", usage, config, mPhoneState);
|
|
|
|
bool forceVolumeReeval = false;
|
|
switch(usage) {
|
|
case AudioSystem::FOR_COMMUNICATION:
|
|
if (config != AudioSystem::FORCE_SPEAKER && config != AudioSystem::FORCE_BT_SCO &&
|
|
config != AudioSystem::FORCE_NONE) {
|
|
ALOGW("setForceUse() invalid config %d for FOR_COMMUNICATION", config);
|
|
return;
|
|
}
|
|
forceVolumeReeval = true;
|
|
mForceUse[usage] = config;
|
|
break;
|
|
case AudioSystem::FOR_MEDIA:
|
|
if (config != AudioSystem::FORCE_HEADPHONES && config != AudioSystem::FORCE_BT_A2DP &&
|
|
#ifdef AUDIO_EXTN_FM_ENABLED
|
|
config != AudioSystem::FORCE_SPEAKER &&
|
|
#endif
|
|
config != AudioSystem::FORCE_WIRED_ACCESSORY &&
|
|
config != AudioSystem::FORCE_ANALOG_DOCK &&
|
|
config != AudioSystem::FORCE_DIGITAL_DOCK && config != AudioSystem::FORCE_NONE &&
|
|
config != AudioSystem::FORCE_NO_BT_A2DP) {
|
|
ALOGW("setForceUse() invalid config %d for FOR_MEDIA", config);
|
|
return;
|
|
}
|
|
mForceUse[usage] = config;
|
|
break;
|
|
case AudioSystem::FOR_RECORD:
|
|
if (config != AudioSystem::FORCE_BT_SCO && config != AudioSystem::FORCE_WIRED_ACCESSORY &&
|
|
config != AudioSystem::FORCE_NONE) {
|
|
ALOGW("setForceUse() invalid config %d for FOR_RECORD", config);
|
|
return;
|
|
}
|
|
mForceUse[usage] = config;
|
|
break;
|
|
case AudioSystem::FOR_DOCK:
|
|
if (config != AudioSystem::FORCE_NONE && config != AudioSystem::FORCE_BT_CAR_DOCK &&
|
|
config != AudioSystem::FORCE_BT_DESK_DOCK &&
|
|
config != AudioSystem::FORCE_WIRED_ACCESSORY &&
|
|
config != AudioSystem::FORCE_ANALOG_DOCK &&
|
|
config != AudioSystem::FORCE_DIGITAL_DOCK) {
|
|
ALOGW("setForceUse() invalid config %d for FOR_DOCK", config);
|
|
}
|
|
forceVolumeReeval = true;
|
|
mForceUse[usage] = config;
|
|
break;
|
|
case AudioSystem::FOR_SYSTEM:
|
|
if (config != AudioSystem::FORCE_NONE &&
|
|
config != AudioSystem::FORCE_SYSTEM_ENFORCED) {
|
|
ALOGW("setForceUse() invalid config %d for FOR_SYSTEM", config);
|
|
}
|
|
forceVolumeReeval = true;
|
|
mForceUse[usage] = config;
|
|
break;
|
|
default:
|
|
ALOGW("setForceUse() invalid usage %d", usage);
|
|
break;
|
|
}
|
|
|
|
// check for device and output changes triggered by new force usage
|
|
checkA2dpSuspend();
|
|
checkOutputForAllStrategies();
|
|
updateDevicesAndOutputs();
|
|
for (int i = mOutputs.size() -1; i >= 0; i--) {
|
|
audio_io_handle_t output = mOutputs.keyAt(i);
|
|
audio_devices_t newDevice = getNewDevice(output, true /*fromCache*/);
|
|
setOutputDevice(output, newDevice, (newDevice != AUDIO_DEVICE_NONE));
|
|
if (forceVolumeReeval && (newDevice != AUDIO_DEVICE_NONE)) {
|
|
applyStreamVolumes(output, newDevice, 0, true);
|
|
}
|
|
}
|
|
|
|
audio_io_handle_t activeInput = getActiveInput();
|
|
if (activeInput != 0) {
|
|
AudioInputDescriptor *inputDesc = mInputs.valueFor(activeInput);
|
|
audio_devices_t newDevice = getDeviceForInputSource(inputDesc->mInputSource);
|
|
if ((newDevice != AUDIO_DEVICE_NONE) && (newDevice != inputDesc->mDevice)) {
|
|
ALOGV("setForceUse() changing device from %x to %x for input %d",
|
|
inputDesc->mDevice, newDevice, activeInput);
|
|
inputDesc->mDevice = newDevice;
|
|
AudioParameter param = AudioParameter();
|
|
param.addInt(String8(AudioParameter::keyRouting), (int)newDevice);
|
|
mpClientInterface->setParameters(activeInput, param.toString());
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
audio_io_handle_t AudioPolicyManager::getInput(int inputSource,
|
|
uint32_t samplingRate,
|
|
uint32_t format,
|
|
uint32_t channelMask,
|
|
AudioSystem::audio_in_acoustics acoustics)
|
|
{
|
|
audio_io_handle_t input = 0;
|
|
audio_devices_t device = getDeviceForInputSource(inputSource);
|
|
|
|
ALOGV("getInput() inputSource %d, samplingRate %d, format %d, channelMask %x, acoustics %x",
|
|
inputSource, samplingRate, format, channelMask, acoustics);
|
|
|
|
if (device == AUDIO_DEVICE_NONE) {
|
|
ALOGW("getInput() could not find device for inputSource %d", inputSource);
|
|
return 0;
|
|
}
|
|
|
|
|
|
IOProfile *profile = getInputProfile(device,
|
|
samplingRate,
|
|
format,
|
|
channelMask);
|
|
if (profile == NULL) {
|
|
ALOGW("getInput() could not find profile for device %04x, samplingRate %d, format %d,"
|
|
"channelMask %04x",
|
|
device, samplingRate, format, channelMask);
|
|
return 0;
|
|
}
|
|
|
|
if (profile->mModule->mHandle == 0) {
|
|
ALOGE("getInput(): HW module %s not opened", profile->mModule->mName);
|
|
return 0;
|
|
}
|
|
|
|
AudioInputDescriptor *inputDesc = new AudioInputDescriptor(profile);
|
|
|
|
inputDesc->mInputSource = inputSource;
|
|
inputDesc->mDevice = device;
|
|
inputDesc->mSamplingRate = samplingRate;
|
|
inputDesc->mFormat = (audio_format_t)format;
|
|
inputDesc->mChannelMask = (audio_channel_mask_t)channelMask;
|
|
inputDesc->mRefCount = 0;
|
|
input = mpClientInterface->openInput(profile->mModule->mHandle,
|
|
&inputDesc->mDevice,
|
|
&inputDesc->mSamplingRate,
|
|
&inputDesc->mFormat,
|
|
&inputDesc->mChannelMask);
|
|
|
|
// only accept input with the exact requested set of parameters
|
|
if (input == 0 ||
|
|
(samplingRate != inputDesc->mSamplingRate) ||
|
|
(format != inputDesc->mFormat) ||
|
|
(channelMask != inputDesc->mChannelMask)) {
|
|
ALOGV("getInput() failed opening input: samplingRate %d, format %d, channelMask %d",
|
|
samplingRate, format, channelMask);
|
|
if (input != 0) {
|
|
mpClientInterface->closeInput(input);
|
|
}
|
|
delete inputDesc;
|
|
return 0;
|
|
}
|
|
mInputs.add(input, inputDesc);
|
|
return input;
|
|
}
|
|
|
|
AudioPolicyManager::routing_strategy AudioPolicyManager::getStrategy(AudioSystem::stream_type stream)
|
|
{
|
|
#ifdef QCOM_INCALL_MUSIC_ENABLED
|
|
if (stream == AudioSystem::INCALL_MUSIC)
|
|
return STRATEGY_MEDIA;
|
|
#endif
|
|
|
|
return getStrategy(stream);
|
|
}
|
|
|
|
audio_devices_t AudioPolicyManager::getDeviceForStrategy(routing_strategy strategy,
|
|
bool fromCache)
|
|
{
|
|
uint32_t device = AUDIO_DEVICE_NONE;
|
|
|
|
if (fromCache) {
|
|
ALOGVV("getDeviceForStrategy() from cache strategy %d, device %x",
|
|
strategy, mDeviceForStrategy[strategy]);
|
|
return mDeviceForStrategy[strategy];
|
|
}
|
|
|
|
switch (strategy) {
|
|
|
|
case STRATEGY_SONIFICATION_RESPECTFUL:
|
|
if (isInCall()) {
|
|
device = getDeviceForStrategy(STRATEGY_SONIFICATION, false /*fromCache*/);
|
|
} else if (isStreamActiveRemotely(AudioSystem::MUSIC,
|
|
SONIFICATION_RESPECTFUL_AFTER_MUSIC_DELAY)) {
|
|
// while media is playing on a remote device, use the the sonification behavior.
|
|
// Note that we test this usecase before testing if media is playing because
|
|
// the isStreamActive() method only informs about the activity of a stream, not
|
|
// if it's for local playback. Note also that we use the same delay between both tests
|
|
device = getDeviceForStrategy(STRATEGY_SONIFICATION, false /*fromCache*/);
|
|
} else if (isStreamActive(AudioSystem::MUSIC, SONIFICATION_RESPECTFUL_AFTER_MUSIC_DELAY)) {
|
|
// while media is playing (or has recently played), use the same device
|
|
device = getDeviceForStrategy(STRATEGY_MEDIA, false /*fromCache*/);
|
|
} else {
|
|
// when media is not playing anymore, fall back on the sonification behavior
|
|
device = getDeviceForStrategy(STRATEGY_SONIFICATION, false /*fromCache*/);
|
|
}
|
|
|
|
break;
|
|
|
|
case STRATEGY_DTMF:
|
|
if (!isInCall()) {
|
|
// when off call, DTMF strategy follows the same rules as MEDIA strategy
|
|
device = getDeviceForStrategy(STRATEGY_MEDIA, false /*fromCache*/);
|
|
break;
|
|
}
|
|
// when in call, DTMF and PHONE strategies follow the same rules
|
|
// FALL THROUGH
|
|
|
|
case STRATEGY_PHONE:
|
|
// for phone strategy, we first consider the forced use and then the available devices by order
|
|
// of priority
|
|
switch (mForceUse[AudioSystem::FOR_COMMUNICATION]) {
|
|
case AudioSystem::FORCE_BT_SCO:
|
|
if (!isInCall() || strategy != STRATEGY_DTMF) {
|
|
device = mAvailableOutputDevices & AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT;
|
|
if (device) break;
|
|
}
|
|
device = mAvailableOutputDevices & AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET;
|
|
if (device) break;
|
|
device = mAvailableOutputDevices & AUDIO_DEVICE_OUT_BLUETOOTH_SCO;
|
|
if (device) break;
|
|
// if SCO device is requested but no SCO device is available, fall back to default case
|
|
// FALL THROUGH
|
|
|
|
default: // FORCE_NONE
|
|
// when not in a phone call, phone strategy should route STREAM_VOICE_CALL to A2DP
|
|
if (mHasA2dp && !isInCall() &&
|
|
(mForceUse[AudioSystem::FOR_MEDIA] != AudioSystem::FORCE_NO_BT_A2DP) &&
|
|
(getA2dpOutput() != 0) && !mA2dpSuspended) {
|
|
device = mAvailableOutputDevices & AUDIO_DEVICE_OUT_BLUETOOTH_A2DP;
|
|
if (device) break;
|
|
device = mAvailableOutputDevices & AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES;
|
|
if (device) break;
|
|
}
|
|
device = mAvailableOutputDevices & AUDIO_DEVICE_OUT_WIRED_HEADPHONE;
|
|
if (device) break;
|
|
device = mAvailableOutputDevices & AUDIO_DEVICE_OUT_WIRED_HEADSET;
|
|
if (device) break;
|
|
if (mPhoneState != AudioSystem::MODE_IN_CALL) {
|
|
device = mAvailableOutputDevices & AUDIO_DEVICE_OUT_USB_ACCESSORY;
|
|
if (device) break;
|
|
device = mAvailableOutputDevices & AUDIO_DEVICE_OUT_USB_DEVICE;
|
|
if (device) break;
|
|
device = mAvailableOutputDevices & AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET;
|
|
if (device) break;
|
|
device = mAvailableOutputDevices & AUDIO_DEVICE_OUT_AUX_DIGITAL;
|
|
if (device) break;
|
|
}
|
|
|
|
// Allow voice call on USB ANLG DOCK headset
|
|
device = mAvailableOutputDevices & AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET;
|
|
if (device) break;
|
|
|
|
device = mAvailableOutputDevices & AUDIO_DEVICE_OUT_EARPIECE;
|
|
if (device) break;
|
|
device = mDefaultOutputDevice;
|
|
if (device == AUDIO_DEVICE_NONE) {
|
|
ALOGE("getDeviceForStrategy() no device found for STRATEGY_PHONE");
|
|
}
|
|
break;
|
|
|
|
case AudioSystem::FORCE_SPEAKER:
|
|
// when not in a phone call, phone strategy should route STREAM_VOICE_CALL to
|
|
// A2DP speaker when forcing to speaker output
|
|
if (mHasA2dp && !isInCall() &&
|
|
(mForceUse[AudioSystem::FOR_MEDIA] != AudioSystem::FORCE_NO_BT_A2DP) &&
|
|
(getA2dpOutput() != 0) && !mA2dpSuspended) {
|
|
device = mAvailableOutputDevices & AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER;
|
|
if (device) break;
|
|
}
|
|
if (mPhoneState != AudioSystem::MODE_IN_CALL) {
|
|
device = mAvailableOutputDevices & AUDIO_DEVICE_OUT_USB_ACCESSORY;
|
|
if (device) break;
|
|
device = mAvailableOutputDevices & AUDIO_DEVICE_OUT_USB_DEVICE;
|
|
if (device) break;
|
|
device = mAvailableOutputDevices & AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET;
|
|
if (device) break;
|
|
device = mAvailableOutputDevices & AUDIO_DEVICE_OUT_AUX_DIGITAL;
|
|
if (device) break;
|
|
device = mAvailableOutputDevices & AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET;
|
|
if (device) break;
|
|
}
|
|
device = mAvailableOutputDevices & AUDIO_DEVICE_OUT_SPEAKER;
|
|
if (device) break;
|
|
device = mDefaultOutputDevice;
|
|
if (device == AUDIO_DEVICE_NONE) {
|
|
ALOGE("getDeviceForStrategy() no device found for STRATEGY_PHONE, FORCE_SPEAKER");
|
|
}
|
|
break;
|
|
}
|
|
// FIXME: Why do need to replace with speaker? If voice call is active
|
|
// We should use device from STRATEGY_PHONE
|
|
#ifdef AUDIO_EXTN_FM_ENABLED
|
|
if (mAvailableOutputDevices & AUDIO_DEVICE_OUT_FM) {
|
|
if (mForceUse[AudioSystem::FOR_MEDIA] == AudioSystem::FORCE_SPEAKER) {
|
|
device = AUDIO_DEVICE_OUT_SPEAKER;
|
|
}
|
|
}
|
|
#endif
|
|
break;
|
|
|
|
case STRATEGY_SONIFICATION:
|
|
|
|
// If incall, just select the STRATEGY_PHONE device: The rest of the behavior is handled by
|
|
// handleIncallSonification().
|
|
if (isInCall()) {
|
|
device = getDeviceForStrategy(STRATEGY_PHONE, false /*fromCache*/);
|
|
break;
|
|
}
|
|
// FALL THROUGH
|
|
|
|
case STRATEGY_ENFORCED_AUDIBLE:
|
|
// strategy STRATEGY_ENFORCED_AUDIBLE uses same routing policy as STRATEGY_SONIFICATION
|
|
// except:
|
|
// - when in call where it doesn't default to STRATEGY_PHONE behavior
|
|
// - in countries where not enforced in which case it follows STRATEGY_MEDIA
|
|
|
|
if ((strategy == STRATEGY_SONIFICATION) ||
|
|
(mForceUse[AudioSystem::FOR_SYSTEM] == AudioSystem::FORCE_SYSTEM_ENFORCED)) {
|
|
device = mAvailableOutputDevices & AUDIO_DEVICE_OUT_SPEAKER;
|
|
if (device == AUDIO_DEVICE_NONE) {
|
|
ALOGE("getDeviceForStrategy() speaker device not found for STRATEGY_SONIFICATION");
|
|
}
|
|
}
|
|
// The second device used for sonification is the same as the device used by media strategy
|
|
// FALL THROUGH
|
|
|
|
case STRATEGY_MEDIA: {
|
|
uint32_t device2 = AUDIO_DEVICE_NONE;
|
|
|
|
if (isInCall() && (device == AUDIO_DEVICE_NONE)) {
|
|
// when in call, get the device for Phone strategy
|
|
device = getDeviceForStrategy(STRATEGY_PHONE, false /*fromCache*/);
|
|
break;
|
|
}
|
|
#ifdef AUDIO_EXTN_FM_ENABLED
|
|
if (mForceUse[AudioSystem::FOR_MEDIA] == AudioSystem::FORCE_SPEAKER) {
|
|
device = AUDIO_DEVICE_OUT_SPEAKER;
|
|
break;
|
|
}
|
|
#endif
|
|
|
|
if (strategy != STRATEGY_SONIFICATION) {
|
|
// no sonification on remote submix (e.g. WFD)
|
|
device2 = mAvailableOutputDevices & AUDIO_DEVICE_OUT_REMOTE_SUBMIX;
|
|
}
|
|
if ((device2 == AUDIO_DEVICE_NONE) &&
|
|
mHasA2dp && (mForceUse[AudioSystem::FOR_MEDIA] != AudioSystem::FORCE_NO_BT_A2DP) &&
|
|
(getA2dpOutput() != 0) && !mA2dpSuspended) {
|
|
device2 = mAvailableOutputDevices & AUDIO_DEVICE_OUT_BLUETOOTH_A2DP;
|
|
if (device2 == AUDIO_DEVICE_NONE) {
|
|
device2 = mAvailableOutputDevices & AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES;
|
|
}
|
|
if (device2 == AUDIO_DEVICE_NONE) {
|
|
device2 = mAvailableOutputDevices & AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER;
|
|
}
|
|
}
|
|
if (device2 == AUDIO_DEVICE_NONE) {
|
|
device2 = mAvailableOutputDevices & AUDIO_DEVICE_OUT_WIRED_HEADPHONE;
|
|
}
|
|
if (device2 == AUDIO_DEVICE_NONE) {
|
|
device2 = mAvailableOutputDevices & AUDIO_DEVICE_OUT_WIRED_HEADSET;
|
|
}
|
|
if (device2 == AUDIO_DEVICE_NONE) {
|
|
device2 = mAvailableOutputDevices & AUDIO_DEVICE_OUT_USB_ACCESSORY;
|
|
}
|
|
if (device2 == AUDIO_DEVICE_NONE) {
|
|
device2 = mAvailableOutputDevices & AUDIO_DEVICE_OUT_USB_DEVICE;
|
|
}
|
|
if (device2 == AUDIO_DEVICE_NONE) {
|
|
device2 = mAvailableOutputDevices & AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET;
|
|
}
|
|
if ((device2 == AUDIO_DEVICE_NONE) && (strategy != STRATEGY_SONIFICATION)) {
|
|
// no sonification on aux digital (e.g. HDMI)
|
|
device2 = mAvailableOutputDevices & AUDIO_DEVICE_OUT_AUX_DIGITAL;
|
|
}
|
|
if ((device2 == AUDIO_DEVICE_NONE) &&
|
|
(mForceUse[AudioSystem::FOR_DOCK] == AudioSystem::FORCE_ANALOG_DOCK)
|
|
&& (strategy != STRATEGY_SONIFICATION)) {
|
|
device2 = mAvailableOutputDevices & AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET;
|
|
}
|
|
#ifdef AUDIO_EXTN_FM_ENABLED
|
|
if ((strategy != STRATEGY_SONIFICATION) && (device2 == AUDIO_DEVICE_NONE)) {
|
|
device2 = mAvailableOutputDevices & AUDIO_DEVICE_OUT_FM_TX;
|
|
}
|
|
#endif
|
|
#ifdef AUDIO_EXTN_AFE_PROXY_ENABLED
|
|
if ((strategy != STRATEGY_SONIFICATION) && (device2 == AUDIO_DEVICE_NONE)) {
|
|
// no sonification on WFD sink
|
|
device2 = mAvailableOutputDevices & AUDIO_DEVICE_OUT_PROXY;
|
|
}
|
|
#endif
|
|
if (device2 == AUDIO_DEVICE_NONE) {
|
|
device2 = mAvailableOutputDevices & AUDIO_DEVICE_OUT_SPEAKER;
|
|
}
|
|
|
|
// device is DEVICE_OUT_SPEAKER if we come from case STRATEGY_SONIFICATION or
|
|
// STRATEGY_ENFORCED_AUDIBLE, AUDIO_DEVICE_NONE otherwise
|
|
device |= device2;
|
|
if (device) break;
|
|
device = mDefaultOutputDevice;
|
|
if (device == AUDIO_DEVICE_NONE) {
|
|
ALOGE("getDeviceForStrategy() no device found for STRATEGY_MEDIA");
|
|
}
|
|
} break;
|
|
|
|
default:
|
|
ALOGW("getDeviceForStrategy() unknown strategy: %d", strategy);
|
|
break;
|
|
}
|
|
|
|
ALOGVV("getDeviceForStrategy() strategy %d, device %x", strategy, device);
|
|
return device;
|
|
}
|
|
|
|
audio_devices_t AudioPolicyManager::getDeviceForInputSource(int inputSource)
|
|
{
|
|
uint32_t device = AUDIO_DEVICE_NONE;
|
|
|
|
switch (inputSource) {
|
|
case AUDIO_SOURCE_VOICE_UPLINK:
|
|
if (mAvailableInputDevices & AUDIO_DEVICE_IN_VOICE_CALL) {
|
|
device = AUDIO_DEVICE_IN_VOICE_CALL;
|
|
break;
|
|
}
|
|
// FALL THROUGH
|
|
|
|
case AUDIO_SOURCE_DEFAULT:
|
|
case AUDIO_SOURCE_MIC:
|
|
case AUDIO_SOURCE_VOICE_RECOGNITION:
|
|
case AUDIO_SOURCE_HOTWORD:
|
|
case AUDIO_SOURCE_VOICE_COMMUNICATION:
|
|
if (mForceUse[AudioSystem::FOR_RECORD] == AudioSystem::FORCE_BT_SCO &&
|
|
mAvailableInputDevices & AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET) {
|
|
device = AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET;
|
|
} else if (mAvailableInputDevices & AUDIO_DEVICE_IN_WIRED_HEADSET) {
|
|
device = AUDIO_DEVICE_IN_WIRED_HEADSET;
|
|
} else if (mAvailableInputDevices & AUDIO_DEVICE_IN_ANLG_DOCK_HEADSET) {
|
|
device = AUDIO_DEVICE_IN_ANLG_DOCK_HEADSET;
|
|
} else if (mAvailableInputDevices & AUDIO_DEVICE_IN_BUILTIN_MIC) {
|
|
device = AUDIO_DEVICE_IN_BUILTIN_MIC;
|
|
}
|
|
break;
|
|
case AUDIO_SOURCE_CAMCORDER:
|
|
if (mAvailableInputDevices & AUDIO_DEVICE_IN_BACK_MIC) {
|
|
device = AUDIO_DEVICE_IN_BACK_MIC;
|
|
} else if (mAvailableInputDevices & AUDIO_DEVICE_IN_BUILTIN_MIC) {
|
|
device = AUDIO_DEVICE_IN_BUILTIN_MIC;
|
|
}
|
|
break;
|
|
case AUDIO_SOURCE_VOICE_DOWNLINK:
|
|
case AUDIO_SOURCE_VOICE_CALL:
|
|
if (mAvailableInputDevices & AUDIO_DEVICE_IN_VOICE_CALL) {
|
|
device = AUDIO_DEVICE_IN_VOICE_CALL;
|
|
}
|
|
break;
|
|
case AUDIO_SOURCE_REMOTE_SUBMIX:
|
|
if (mAvailableInputDevices & AUDIO_DEVICE_IN_REMOTE_SUBMIX) {
|
|
device = AUDIO_DEVICE_IN_REMOTE_SUBMIX;
|
|
}
|
|
break;
|
|
#ifdef AUDIO_EXTN_FM_ENABLED
|
|
case AUDIO_SOURCE_FM_RX:
|
|
device = AUDIO_DEVICE_IN_FM_RX;
|
|
break;
|
|
case AUDIO_SOURCE_FM_RX_A2DP:
|
|
device = AUDIO_DEVICE_IN_FM_RX_A2DP;
|
|
break;
|
|
#endif
|
|
default:
|
|
ALOGW("getDeviceForInputSource() invalid input source %d", inputSource);
|
|
break;
|
|
}
|
|
ALOGV("getDeviceForInputSource()input source %d, device %08x", inputSource, device);
|
|
return device;
|
|
}
|
|
|
|
AudioPolicyManager::device_category AudioPolicyManager::getDeviceCategory(audio_devices_t device)
|
|
{
|
|
switch(getDeviceForVolume(device)) {
|
|
case AUDIO_DEVICE_OUT_EARPIECE:
|
|
return DEVICE_CATEGORY_EARPIECE;
|
|
case AUDIO_DEVICE_OUT_WIRED_HEADSET:
|
|
case AUDIO_DEVICE_OUT_WIRED_HEADPHONE:
|
|
case AUDIO_DEVICE_OUT_BLUETOOTH_SCO:
|
|
case AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET:
|
|
case AUDIO_DEVICE_OUT_BLUETOOTH_A2DP:
|
|
case AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES:
|
|
#ifdef AUDIO_EXTN_FM_ENABLED
|
|
case AUDIO_DEVICE_OUT_FM:
|
|
#endif
|
|
return DEVICE_CATEGORY_HEADSET;
|
|
case AUDIO_DEVICE_OUT_SPEAKER:
|
|
case AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT:
|
|
case AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER:
|
|
case AUDIO_DEVICE_OUT_AUX_DIGITAL:
|
|
case AUDIO_DEVICE_OUT_USB_ACCESSORY:
|
|
case AUDIO_DEVICE_OUT_USB_DEVICE:
|
|
case AUDIO_DEVICE_OUT_REMOTE_SUBMIX:
|
|
#ifdef AUDIO_EXTN_AFE_PROXY_ENABLED
|
|
case AUDIO_DEVICE_OUT_PROXY:
|
|
#endif
|
|
default:
|
|
return DEVICE_CATEGORY_SPEAKER;
|
|
}
|
|
}
|
|
|
|
status_t AudioPolicyManager::checkAndSetVolume(int stream,
|
|
int index,
|
|
audio_io_handle_t output,
|
|
audio_devices_t device,
|
|
int delayMs,
|
|
bool force)
|
|
{
|
|
ALOGV("checkAndSetVolume: index %d output %d device %x", index, output, device);
|
|
// do not change actual stream volume if the stream is muted
|
|
if (mOutputs.valueFor(output)->mMuteCount[stream] != 0) {
|
|
ALOGVV("checkAndSetVolume() stream %d muted count %d",
|
|
stream, mOutputs.valueFor(output)->mMuteCount[stream]);
|
|
return NO_ERROR;
|
|
}
|
|
|
|
// do not change in call volume if bluetooth is connected and vice versa
|
|
if ((stream == AudioSystem::VOICE_CALL && mForceUse[AudioSystem::FOR_COMMUNICATION] == AudioSystem::FORCE_BT_SCO) ||
|
|
(stream == AudioSystem::BLUETOOTH_SCO && mForceUse[AudioSystem::FOR_COMMUNICATION] != AudioSystem::FORCE_BT_SCO)) {
|
|
ALOGV("checkAndSetVolume() cannot set stream %d volume with force use = %d for comm",
|
|
stream, mForceUse[AudioSystem::FOR_COMMUNICATION]);
|
|
return INVALID_OPERATION;
|
|
}
|
|
|
|
float volume = computeVolume(stream, index, output, device);
|
|
// We actually change the volume if:
|
|
// - the float value returned by computeVolume() changed
|
|
// - the force flag is set
|
|
if (volume != mOutputs.valueFor(output)->mCurVolume[stream] ||
|
|
force) {
|
|
mOutputs.valueFor(output)->mCurVolume[stream] = volume;
|
|
ALOGV("checkAndSetVolume() for output %d stream %d, volume %f, delay %d", output, stream, volume, delayMs);
|
|
// Force VOICE_CALL to track BLUETOOTH_SCO stream volume when bluetooth audio is
|
|
// enabled
|
|
if (stream == AudioSystem::BLUETOOTH_SCO) {
|
|
mpClientInterface->setStreamVolume(AudioSystem::VOICE_CALL, volume, output, delayMs);
|
|
#ifdef AUDIO_EXTN_FM_ENABLED
|
|
} else if (stream == AudioSystem::MUSIC &&
|
|
output == mPrimaryOutput) {
|
|
float fmVolume = -1.0;
|
|
fmVolume = computeVolume(stream, index, output, device);
|
|
if (fmVolume >= 0) {
|
|
AudioParameter param = AudioParameter();
|
|
param.addFloat(String8("fm_volume"), fmVolume);
|
|
ALOGV("checkAndSetVolume setParameters fm_volume, volume=:%f delay=:%d",fmVolume,delayMs*2);
|
|
//Double delayMs to avoid sound burst while device switch.
|
|
mpClientInterface->setParameters(mPrimaryOutput, param.toString(), delayMs*2);
|
|
}
|
|
#endif
|
|
}
|
|
mpClientInterface->setStreamVolume((AudioSystem::stream_type)stream, volume, output, delayMs);
|
|
}
|
|
|
|
if (stream == AudioSystem::VOICE_CALL ||
|
|
stream == AudioSystem::BLUETOOTH_SCO) {
|
|
float voiceVolume;
|
|
|
|
voiceVolume = (float)index/(float)mStreams[stream].mIndexMax;
|
|
|
|
// Force voice volume to max when Vgs is set for bluetooth SCO as volume is managed by the headset
|
|
if (stream == AudioSystem::BLUETOOTH_SCO) {
|
|
String8 key ("bt_headset_vgs");
|
|
mpClientInterface->getParameters(output,key);
|
|
AudioParameter result(mpClientInterface->getParameters(0,key));
|
|
int value;
|
|
if (result.getInt(String8("isVGS"),value) == NO_ERROR) {
|
|
ALOGV("Use BT-SCO Voice Volume");
|
|
voiceVolume = 1.0;
|
|
}
|
|
}
|
|
|
|
if (voiceVolume != mLastVoiceVolume && output == mPrimaryOutput) {
|
|
mpClientInterface->setVoiceVolume(voiceVolume, delayMs);
|
|
mLastVoiceVolume = voiceVolume;
|
|
}
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
|
|
float AudioPolicyManager::computeVolume(int stream,
|
|
int index,
|
|
audio_io_handle_t output,
|
|
audio_devices_t device)
|
|
{
|
|
float volume = 1.0;
|
|
AudioOutputDescriptor *outputDesc = mOutputs.valueFor(output);
|
|
|
|
if (device == AUDIO_DEVICE_NONE) {
|
|
device = outputDesc->device();
|
|
}
|
|
|
|
// if volume is not 0 (not muted), force media volume to max on digital output
|
|
if (stream == AudioSystem::MUSIC &&
|
|
index != mStreams[stream].mIndexMin &&
|
|
(device == AUDIO_DEVICE_OUT_AUX_DIGITAL ||
|
|
device == AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET ||
|
|
device == AUDIO_DEVICE_OUT_USB_ACCESSORY ||
|
|
#ifdef AUDIO_EXTN_AFE_PROXY_ENABLED
|
|
device == AUDIO_DEVICE_OUT_PROXY ||
|
|
#endif
|
|
device == AUDIO_DEVICE_OUT_USB_DEVICE )) {
|
|
return 1.0;
|
|
}
|
|
#ifdef AUDIO_EXTN_INCALL_MUSIC_ENABLED
|
|
if (stream == AudioSystem::INCALL_MUSIC) {
|
|
return 1.0;
|
|
}
|
|
#endif
|
|
return AudioPolicyManagerBase::computeVolume(stream, index, output, device);
|
|
}
|
|
extern "C" AudioPolicyInterface* createAudioPolicyManager(AudioPolicyClientInterface *clientInterface)
|
|
{
|
|
return new AudioPolicyManager(clientInterface);
|
|
}
|
|
|
|
extern "C" void destroyAudioPolicyManager(AudioPolicyInterface *interface)
|
|
{
|
|
delete interface;
|
|
}
|
|
|
|
}; // namespace android
|