audio policy: remove dependency from AudioSystemLegacy
Remove all dependencies on AudioSystemLegacy from AudioPolicyManagerBase.
Only use types and definitions from audio.h and audio_policy.h.
Also move code back into android name space.
Change-Id: I0c2582cf854027fb1e599981865a6cbe7b5a9490
diff --git a/services/audiopolicy/AudioPolicyInterface.h b/services/audiopolicy/AudioPolicyInterface.h
index da03ee3..768b13e 100644
--- a/services/audiopolicy/AudioPolicyInterface.h
+++ b/services/audiopolicy/AudioPolicyInterface.h
@@ -18,16 +18,11 @@
#define ANDROID_AUDIOPOLICYINTERFACE_H
#include <media/AudioSystem.h>
-#include <media/ToneGenerator.h>
#include <utils/String8.h>
-#include <hardware_legacy/AudioSystemLegacy.h>
#include <hardware/audio_policy.h>
-namespace android_audio_legacy {
- using android::Vector;
- using android::String8;
- using android::ToneGenerator;
+namespace android {
// ----------------------------------------------------------------------------
@@ -68,17 +63,17 @@
// indicate a change in device connection status
virtual status_t setDeviceConnectionState(audio_devices_t device,
- AudioSystem::device_connection_state state,
+ audio_policy_dev_state_t state,
const char *device_address) = 0;
// retrieve a device connection status
- virtual AudioSystem::device_connection_state getDeviceConnectionState(audio_devices_t device,
+ virtual audio_policy_dev_state_t getDeviceConnectionState(audio_devices_t device,
const char *device_address) = 0;
- // indicate a change in phone state. Valid phones states are defined by AudioSystem::audio_mode
- virtual void setPhoneState(int state) = 0;
+ // indicate a change in phone state. Valid phones states are defined by audio_mode_t
+ virtual void setPhoneState(audio_mode_t state) = 0;
// force using a specific device category for the specified usage
- virtual void setForceUse(AudioSystem::force_use usage, AudioSystem::forced_config config) = 0;
+ virtual void setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config) = 0;
// retrieve current device category forced for a given usage
- virtual AudioSystem::forced_config getForceUse(AudioSystem::force_use usage) = 0;
+ virtual audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage) = 0;
// set a system property (e.g. camera sound always audible)
virtual void setSystemProperty(const char* property, const char* value) = 0;
// check proper initialization
@@ -89,29 +84,29 @@
//
// request an output appropriate for playback of the supplied stream type and parameters
- virtual audio_io_handle_t getOutput(AudioSystem::stream_type stream,
+ virtual audio_io_handle_t getOutput(audio_stream_type_t stream,
uint32_t samplingRate,
audio_format_t format,
audio_channel_mask_t channelMask,
- AudioSystem::output_flags flags,
+ audio_output_flags_t flags,
const audio_offload_info_t *offloadInfo) = 0;
// indicates to the audio policy manager that the output starts being used by corresponding stream.
virtual status_t startOutput(audio_io_handle_t output,
- AudioSystem::stream_type stream,
+ audio_stream_type_t stream,
int session = 0) = 0;
// indicates to the audio policy manager that the output stops being used by corresponding stream.
virtual status_t stopOutput(audio_io_handle_t output,
- AudioSystem::stream_type stream,
+ audio_stream_type_t stream,
int session = 0) = 0;
// releases the output.
virtual void releaseOutput(audio_io_handle_t output) = 0;
// request an input appropriate for record from the supplied device with supplied parameters.
- virtual audio_io_handle_t getInput(int inputSource,
+ virtual audio_io_handle_t getInput(audio_source_t inputSource,
uint32_t samplingRate,
audio_format_t format,
audio_channel_mask_t channelMask,
- AudioSystem::audio_in_acoustics acoustics) = 0;
+ audio_in_acoustics_t acoustics) = 0;
// indicates to the audio policy manager that the input starts being used.
virtual status_t startInput(audio_io_handle_t input) = 0;
// indicates to the audio policy manager that the input stops being used.
@@ -124,29 +119,29 @@
//
// initialises stream volume conversion parameters by specifying volume index range.
- virtual void initStreamVolume(AudioSystem::stream_type stream,
+ virtual void initStreamVolume(audio_stream_type_t stream,
int indexMin,
int indexMax) = 0;
// sets the new stream volume at a level corresponding to the supplied index for the
// supplied device. By convention, specifying AUDIO_DEVICE_OUT_DEFAULT means
// setting volume for all devices
- virtual status_t setStreamVolumeIndex(AudioSystem::stream_type stream,
+ virtual status_t setStreamVolumeIndex(audio_stream_type_t stream,
int index,
audio_devices_t device) = 0;
// retrieve current volume index for the specified stream and the
// specified device. By convention, specifying AUDIO_DEVICE_OUT_DEFAULT means
// querying the volume of the active device.
- virtual status_t getStreamVolumeIndex(AudioSystem::stream_type stream,
+ virtual status_t getStreamVolumeIndex(audio_stream_type_t stream,
int *index,
audio_devices_t device) = 0;
// return the strategy corresponding to a given stream type
- virtual uint32_t getStrategyForStream(AudioSystem::stream_type stream) = 0;
+ virtual uint32_t getStrategyForStream(audio_stream_type_t stream) = 0;
// return the enabled output devices for the given stream type
- virtual audio_devices_t getDevicesForStream(AudioSystem::stream_type stream) = 0;
+ virtual audio_devices_t getDevicesForStream(audio_stream_type_t stream) = 0;
// Audio effect management
virtual audio_io_handle_t getOutputForEffect(const effect_descriptor_t *desc) = 0;
@@ -158,8 +153,9 @@
virtual status_t unregisterEffect(int id) = 0;
virtual status_t setEffectEnabled(int id, bool enabled) = 0;
- virtual bool isStreamActive(int stream, uint32_t inPastMs = 0) const = 0;
- virtual bool isStreamActiveRemotely(int stream, uint32_t inPastMs = 0) const = 0;
+ virtual bool isStreamActive(audio_stream_type_t stream, uint32_t inPastMs = 0) const = 0;
+ virtual bool isStreamActiveRemotely(audio_stream_type_t stream,
+ uint32_t inPastMs = 0) const = 0;
virtual bool isSourceActive(audio_source_t source) const = 0;
//dump state
@@ -227,10 +223,10 @@
// set a stream volume for a particular output. For the same user setting, a given stream type can have different volumes
// for each output (destination device) it is attached to.
- virtual status_t setStreamVolume(AudioSystem::stream_type stream, float volume, audio_io_handle_t output, int delayMs = 0) = 0;
+ virtual status_t setStreamVolume(audio_stream_type_t stream, float volume, audio_io_handle_t output, int delayMs = 0) = 0;
// invalidate a stream type, causing a reroute to an unspecified new output
- virtual status_t invalidateStream(AudioSystem::stream_type stream) = 0;
+ virtual status_t invalidateStream(audio_stream_type_t stream) = 0;
// function enabling to send proprietary informations directly from audio policy manager to audio hardware interface.
virtual void setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs, int delayMs = 0) = 0;
@@ -239,7 +235,7 @@
// request the playback of a tone on the specified stream: used for instance to replace notification sounds when playing
// over a telephony device during a phone call.
- virtual status_t startTone(ToneGenerator::tone_type tone, AudioSystem::stream_type stream) = 0;
+ virtual status_t startTone(audio_policy_tone_t tone, audio_stream_type_t stream) = 0;
virtual status_t stopTone() = 0;
// set down link audio volume.
diff --git a/services/audiopolicy/AudioPolicyManagerBase.cpp b/services/audiopolicy/AudioPolicyManagerBase.cpp
index 6f58cf7..3a4ccf9 100644
--- a/services/audiopolicy/AudioPolicyManagerBase.cpp
+++ b/services/audiopolicy/AudioPolicyManagerBase.cpp
@@ -32,14 +32,15 @@
#define APM_AUDIO_OUT_DEVICE_REMOTE_ALL AUDIO_DEVICE_OUT_REMOTE_SUBMIX
#include <utils/Log.h>
-#include <hardware_legacy/AudioPolicyManagerBase.h>
+#include "AudioPolicyManagerBase.h"
#include <hardware/audio_effect.h>
#include <hardware/audio.h>
#include <math.h>
#include <hardware_legacy/audio_policy_conf.h>
#include <cutils/properties.h>
+#include <media/AudioParameter.h>
-namespace android_audio_legacy {
+namespace android {
// ----------------------------------------------------------------------------
// AudioPolicyInterface implementation
@@ -47,7 +48,7 @@
status_t AudioPolicyManagerBase::setDeviceConnectionState(audio_devices_t device,
- AudioSystem::device_connection_state state,
+ audio_policy_dev_state_t state,
const char *device_address)
{
SortedVector <audio_io_handle_t> outputs;
@@ -85,7 +86,7 @@
switch (state)
{
// handle output device connection
- case AudioSystem::DEVICE_STATE_AVAILABLE:
+ case AUDIO_POLICY_DEVICE_STATE_AVAILABLE:
if (mAvailableOutputDevices & device) {
ALOGW("setDeviceConnectionState() device already connected: %x", device);
return INVALID_OPERATION;
@@ -124,7 +125,7 @@
break;
// handle output device disconnection
- case AudioSystem::DEVICE_STATE_UNAVAILABLE: {
+ case AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE: {
if (!(mAvailableOutputDevices & device)) {
ALOGW("setDeviceConnectionState() device not connected: %x", device);
return INVALID_OPERATION;
@@ -163,7 +164,7 @@
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) ||
+ if ((state == AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE) ||
(((desc->mFlags & AUDIO_OUTPUT_FLAG_DIRECT) != 0) &&
(desc->mDirectOpenCount == 0))) {
closeOutput(outputs[i]);
@@ -198,7 +199,7 @@
switch (state)
{
// handle input device connection
- case AudioSystem::DEVICE_STATE_AVAILABLE: {
+ case AUDIO_POLICY_DEVICE_STATE_AVAILABLE: {
if (mAvailableInputDevices & device) {
ALOGW("setDeviceConnectionState() device already connected: %d", device);
return INVALID_OPERATION;
@@ -208,7 +209,7 @@
break;
// handle input device disconnection
- case AudioSystem::DEVICE_STATE_UNAVAILABLE: {
+ case AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE: {
if (!(mAvailableInputDevices & device)) {
ALOGW("setDeviceConnectionState() device not connected: %d", device);
return INVALID_OPERATION;
@@ -242,10 +243,10 @@
return BAD_VALUE;
}
-AudioSystem::device_connection_state AudioPolicyManagerBase::getDeviceConnectionState(audio_devices_t device,
+audio_policy_dev_state_t AudioPolicyManagerBase::getDeviceConnectionState(audio_devices_t device,
const char *device_address)
{
- AudioSystem::device_connection_state state = AudioSystem::DEVICE_STATE_UNAVAILABLE;
+ audio_policy_dev_state_t state = AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE;
String8 address = String8(device_address);
if (audio_is_output_device(device)) {
if (device & mAvailableOutputDevices) {
@@ -265,22 +266,22 @@
if (audio_is_remote_submix_device((audio_devices_t)device) && !mHasRemoteSubmix) {
return state;
}
- state = AudioSystem::DEVICE_STATE_AVAILABLE;
+ state = AUDIO_POLICY_DEVICE_STATE_AVAILABLE;
}
} else if (audio_is_input_device(device)) {
if (device & mAvailableInputDevices) {
- state = AudioSystem::DEVICE_STATE_AVAILABLE;
+ state = AUDIO_POLICY_DEVICE_STATE_AVAILABLE;
}
}
return state;
}
-void AudioPolicyManagerBase::setPhoneState(int state)
+void AudioPolicyManagerBase::setPhoneState(audio_mode_t state)
{
ALOGV("setPhoneState() state %d", state);
audio_devices_t newDevice = AUDIO_DEVICE_NONE;
- if (state < 0 || state >= AudioSystem::NUM_MODES) {
+ if (state < 0 || state >= AUDIO_MODE_CNT) {
ALOGW("setPhoneState() invalid state %d", state);
return;
}
@@ -294,8 +295,8 @@
// pertaining to sonification strategy see handleIncallSonification()
if (isInCall()) {
ALOGV("setPhoneState() in call state management: new state is %d", state);
- for (int stream = 0; stream < AudioSystem::NUM_STREAM_TYPES; stream++) {
- handleIncallSonification(stream, false, true);
+ for (int stream = 0; stream < AUDIO_STREAM_CNT; stream++) {
+ handleIncallSonification((audio_stream_type_t)stream, false, true);
}
}
@@ -377,68 +378,69 @@
// pertaining to sonification strategy see handleIncallSonification()
if (isStateInCall(state)) {
ALOGV("setPhoneState() in call state management: new state is %d", state);
- for (int stream = 0; stream < AudioSystem::NUM_STREAM_TYPES; stream++) {
- handleIncallSonification(stream, true, true);
+ for (int stream = 0; stream < AUDIO_STREAM_CNT; stream++) {
+ handleIncallSonification((audio_stream_type_t)stream, true, true);
}
}
// Flag that ringtone volume must be limited to music volume until we exit MODE_RINGTONE
- if (state == AudioSystem::MODE_RINGTONE &&
- isStreamActive(AudioSystem::MUSIC, SONIFICATION_HEADSET_MUSIC_DELAY)) {
+ if (state == AUDIO_MODE_RINGTONE &&
+ isStreamActive(AUDIO_STREAM_MUSIC, SONIFICATION_HEADSET_MUSIC_DELAY)) {
mLimitRingtoneVolume = true;
} else {
mLimitRingtoneVolume = false;
}
}
-void AudioPolicyManagerBase::setForceUse(AudioSystem::force_use usage, AudioSystem::forced_config config)
+void AudioPolicyManagerBase::setForceUse(audio_policy_force_use_t usage,
+ audio_policy_forced_cfg_t 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) {
+ case AUDIO_POLICY_FORCE_FOR_COMMUNICATION:
+ if (config != AUDIO_POLICY_FORCE_SPEAKER && config != AUDIO_POLICY_FORCE_BT_SCO &&
+ config != AUDIO_POLICY_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 &&
- 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) {
+ case AUDIO_POLICY_FORCE_FOR_MEDIA:
+ if (config != AUDIO_POLICY_FORCE_HEADPHONES && config != AUDIO_POLICY_FORCE_BT_A2DP &&
+ config != AUDIO_POLICY_FORCE_WIRED_ACCESSORY &&
+ config != AUDIO_POLICY_FORCE_ANALOG_DOCK &&
+ config != AUDIO_POLICY_FORCE_DIGITAL_DOCK && config != AUDIO_POLICY_FORCE_NONE &&
+ config != AUDIO_POLICY_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) {
+ case AUDIO_POLICY_FORCE_FOR_RECORD:
+ if (config != AUDIO_POLICY_FORCE_BT_SCO && config != AUDIO_POLICY_FORCE_WIRED_ACCESSORY &&
+ config != AUDIO_POLICY_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) {
+ case AUDIO_POLICY_FORCE_FOR_DOCK:
+ if (config != AUDIO_POLICY_FORCE_NONE && config != AUDIO_POLICY_FORCE_BT_CAR_DOCK &&
+ config != AUDIO_POLICY_FORCE_BT_DESK_DOCK &&
+ config != AUDIO_POLICY_FORCE_WIRED_ACCESSORY &&
+ config != AUDIO_POLICY_FORCE_ANALOG_DOCK &&
+ config != AUDIO_POLICY_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) {
+ case AUDIO_POLICY_FORCE_FOR_SYSTEM:
+ if (config != AUDIO_POLICY_FORCE_NONE &&
+ config != AUDIO_POLICY_FORCE_SYSTEM_ENFORCED) {
ALOGW("setForceUse() invalid config %d for FOR_SYSTEM", config);
}
forceVolumeReeval = true;
@@ -478,7 +480,7 @@
}
-AudioSystem::forced_config AudioPolicyManagerBase::getForceUse(AudioSystem::force_use usage)
+audio_policy_forced_cfg_t AudioPolicyManagerBase::getForceUse(audio_policy_force_use_t usage)
{
return mForceUse[usage];
}
@@ -525,16 +527,16 @@
return 0;
}
-audio_io_handle_t AudioPolicyManagerBase::getOutput(AudioSystem::stream_type stream,
+audio_io_handle_t AudioPolicyManagerBase::getOutput(audio_stream_type_t stream,
uint32_t samplingRate,
audio_format_t format,
audio_channel_mask_t channelMask,
- AudioSystem::output_flags flags,
+ audio_output_flags_t flags,
const audio_offload_info_t *offloadInfo)
{
audio_io_handle_t output = 0;
uint32_t latency = 0;
- routing_strategy strategy = getStrategy((AudioSystem::stream_type)stream);
+ routing_strategy strategy = getStrategy(stream);
audio_devices_t device = getDeviceForStrategy(strategy, false /*fromCache*/);
ALOGV("getOutput() device %d, stream %d, samplingRate %d, format %x, channelMask %x, flags %x",
device, stream, samplingRate, format, channelMask, flags);
@@ -552,7 +554,8 @@
outputDesc->mFormat = mTestFormat;
outputDesc->mChannelMask = mTestChannels;
outputDesc->mLatency = mTestLatencyMs;
- outputDesc->mFlags = (audio_output_flags_t)(mDirectOutput ? AudioSystem::OUTPUT_FLAG_DIRECT : 0);
+ outputDesc->mFlags =
+ (audio_output_flags_t)(mDirectOutput ? AUDIO_OUTPUT_FLAG_DIRECT : 0);
outputDesc->mRefCount[stream] = 0;
mTestOutputs[mCurOutput] = mpClientInterface->openOutput(0, &outputDesc->mDevice,
&outputDesc->mSamplingRate,
@@ -577,7 +580,7 @@
// and all common behaviors are driven by checking only the direct flag
// this should normally be set appropriately in the policy configuration file
if ((flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0) {
- flags = (AudioSystem::output_flags)(flags | AUDIO_OUTPUT_FLAG_DIRECT);
+ flags = (audio_output_flags_t)(flags | AUDIO_OUTPUT_FLAG_DIRECT);
}
// Do not allow offloading if one non offloadable effect is enabled. This prevents from
@@ -683,7 +686,7 @@
}
audio_io_handle_t AudioPolicyManagerBase::selectOutput(const SortedVector<audio_io_handle_t>& outputs,
- AudioSystem::output_flags flags)
+ audio_output_flags_t flags)
{
// select one output among several that provide a path to a particular device or set of
// devices (the list was previously build by getOutputsForDevice()).
@@ -706,7 +709,7 @@
for (size_t i = 0; i < outputs.size(); i++) {
AudioOutputDescriptor *outputDesc = mOutputs.valueFor(outputs[i]);
if (!outputDesc->isDuplicated()) {
- int commonFlags = (int)AudioSystem::popCount(outputDesc->mProfile->mFlags & flags);
+ int commonFlags = popcount(outputDesc->mProfile->mFlags & flags);
if (commonFlags > maxCommonFlags) {
outputFlags = outputs[i];
maxCommonFlags = commonFlags;
@@ -729,7 +732,7 @@
}
status_t AudioPolicyManagerBase::startOutput(audio_io_handle_t output,
- AudioSystem::stream_type stream,
+ audio_stream_type_t stream,
int session)
{
ALOGV("startOutput() output %d, stream %d, session %d", output, stream, session);
@@ -797,7 +800,7 @@
status_t AudioPolicyManagerBase::stopOutput(audio_io_handle_t output,
- AudioSystem::stream_type stream,
+ audio_stream_type_t stream,
int session)
{
ALOGV("stopOutput() output %d, stream %d, session %d", output, stream, session);
@@ -877,7 +880,7 @@
#endif //AUDIO_POLICY_TEST
AudioOutputDescriptor *desc = mOutputs.valueAt(index);
- if (desc->mFlags & AudioSystem::OUTPUT_FLAG_DIRECT) {
+ if (desc->mFlags & AUDIO_OUTPUT_FLAG_DIRECT) {
if (desc->mDirectOpenCount <= 0) {
ALOGW("releaseOutput() invalid open count %d for output %d",
desc->mDirectOpenCount, output);
@@ -896,11 +899,11 @@
}
-audio_io_handle_t AudioPolicyManagerBase::getInput(int inputSource,
+audio_io_handle_t AudioPolicyManagerBase::getInput(audio_source_t inputSource,
uint32_t samplingRate,
audio_format_t format,
audio_channel_mask_t channelMask,
- AudioSystem::audio_in_acoustics acoustics)
+ audio_in_acoustics_t acoustics)
{
audio_io_handle_t input = 0;
audio_devices_t device = getDeviceForInputSource(inputSource);
@@ -1013,7 +1016,7 @@
// automatically enable the remote submix output when input is started
if (audio_is_remote_submix_device(inputDesc->mDevice)) {
setDeviceConnectionState(AUDIO_DEVICE_OUT_REMOTE_SUBMIX,
- AudioSystem::DEVICE_STATE_AVAILABLE, AUDIO_REMOTE_SUBMIX_DEVICE_ADDRESS);
+ AUDIO_POLICY_DEVICE_STATE_AVAILABLE, AUDIO_REMOTE_SUBMIX_DEVICE_ADDRESS);
}
AudioParameter param = AudioParameter();
@@ -1048,7 +1051,7 @@
// automatically disable the remote submix output when input is stopped
if (audio_is_remote_submix_device(inputDesc->mDevice)) {
setDeviceConnectionState(AUDIO_DEVICE_OUT_REMOTE_SUBMIX,
- AudioSystem::DEVICE_STATE_UNAVAILABLE, AUDIO_REMOTE_SUBMIX_DEVICE_ADDRESS);
+ AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE, AUDIO_REMOTE_SUBMIX_DEVICE_ADDRESS);
}
AudioParameter param = AudioParameter();
@@ -1073,7 +1076,7 @@
ALOGV("releaseInput() exit");
}
-void AudioPolicyManagerBase::initStreamVolume(AudioSystem::stream_type stream,
+void AudioPolicyManagerBase::initStreamVolume(audio_stream_type_t stream,
int indexMin,
int indexMax)
{
@@ -1086,7 +1089,7 @@
mStreams[stream].mIndexMax = indexMax;
}
-status_t AudioPolicyManagerBase::setStreamVolumeIndex(AudioSystem::stream_type stream,
+status_t AudioPolicyManagerBase::setStreamVolumeIndex(audio_stream_type_t stream,
int index,
audio_devices_t device)
{
@@ -1126,7 +1129,7 @@
return status;
}
-status_t AudioPolicyManagerBase::getStreamVolumeIndex(AudioSystem::stream_type stream,
+status_t AudioPolicyManagerBase::getStreamVolumeIndex(audio_stream_type_t stream,
int *index,
audio_devices_t device)
{
@@ -1193,7 +1196,7 @@
{
// apply simple rule where global effects are attached to the same output as MUSIC streams
- routing_strategy strategy = getStrategy(AudioSystem::MUSIC);
+ routing_strategy strategy = getStrategy(AUDIO_STREAM_MUSIC);
audio_devices_t device = getDeviceForStrategy(strategy, false /*fromCache*/);
SortedVector<audio_io_handle_t> dstOutputs = getOutputsForDevice(device, mOutputs);
@@ -1322,25 +1325,26 @@
return false;
}
-bool AudioPolicyManagerBase::isStreamActive(int stream, uint32_t inPastMs) const
+bool AudioPolicyManagerBase::isStreamActive(audio_stream_type_t stream, uint32_t inPastMs) const
{
nsecs_t sysTime = systemTime();
for (size_t i = 0; i < mOutputs.size(); i++) {
const AudioOutputDescriptor *outputDesc = mOutputs.valueAt(i);
- if (outputDesc->isStreamActive((AudioSystem::stream_type)stream, inPastMs, sysTime)) {
+ if (outputDesc->isStreamActive(stream, inPastMs, sysTime)) {
return true;
}
}
return false;
}
-bool AudioPolicyManagerBase::isStreamActiveRemotely(int stream, uint32_t inPastMs) const
+bool AudioPolicyManagerBase::isStreamActiveRemotely(audio_stream_type_t stream,
+ uint32_t inPastMs) const
{
nsecs_t sysTime = systemTime();
for (size_t i = 0; i < mOutputs.size(); i++) {
const AudioOutputDescriptor *outputDesc = mOutputs.valueAt(i);
if (((outputDesc->device() & APM_AUDIO_OUT_DEVICE_REMOTE_ALL) != 0) &&
- outputDesc->isStreamActive((AudioSystem::stream_type)stream, inPastMs, sysTime)) {
+ outputDesc->isStreamActive(stream, inPastMs, sysTime)) {
return true;
}
}
@@ -1352,7 +1356,7 @@
for (size_t i = 0; i < mInputs.size(); i++) {
const AudioInputDescriptor * inputDescriptor = mInputs.valueAt(i);
if ((inputDescriptor->mInputSource == (int)source ||
- (source == (audio_source_t)AUDIO_SOURCE_VOICE_RECOGNITION &&
+ (source == AUDIO_SOURCE_VOICE_RECOGNITION &&
inputDescriptor->mInputSource == AUDIO_SOURCE_HOTWORD))
&& (inputDescriptor->mRefCount > 0)) {
return true;
@@ -1385,15 +1389,16 @@
result.append(buffer);
snprintf(buffer, SIZE, " Phone state: %d\n", mPhoneState);
result.append(buffer);
- snprintf(buffer, SIZE, " Force use for communications %d\n", mForceUse[AudioSystem::FOR_COMMUNICATION]);
+ snprintf(buffer, SIZE, " Force use for communications %d\n",
+ mForceUse[AUDIO_POLICY_FORCE_FOR_COMMUNICATION]);
result.append(buffer);
- snprintf(buffer, SIZE, " Force use for media %d\n", mForceUse[AudioSystem::FOR_MEDIA]);
+ snprintf(buffer, SIZE, " Force use for media %d\n", mForceUse[AUDIO_POLICY_FORCE_FOR_MEDIA]);
result.append(buffer);
- snprintf(buffer, SIZE, " Force use for record %d\n", mForceUse[AudioSystem::FOR_RECORD]);
+ snprintf(buffer, SIZE, " Force use for record %d\n", mForceUse[AUDIO_POLICY_FORCE_FOR_RECORD]);
result.append(buffer);
- snprintf(buffer, SIZE, " Force use for dock %d\n", mForceUse[AudioSystem::FOR_DOCK]);
+ snprintf(buffer, SIZE, " Force use for dock %d\n", mForceUse[AUDIO_POLICY_FORCE_FOR_DOCK]);
result.append(buffer);
- snprintf(buffer, SIZE, " Force use for system %d\n", mForceUse[AudioSystem::FOR_SYSTEM]);
+ snprintf(buffer, SIZE, " Force use for system %d\n", mForceUse[AUDIO_POLICY_FORCE_FOR_SYSTEM]);
result.append(buffer);
write(fd, result.string(), result.size());
@@ -1427,7 +1432,7 @@
snprintf(buffer, SIZE,
" Stream Can be muted Index Min Index Max Index Cur [device : index]...\n");
write(fd, buffer, strlen(buffer));
- for (size_t i = 0; i < AudioSystem::NUM_STREAM_TYPES; i++) {
+ for (int i = 0; i < AUDIO_STREAM_CNT; i++) {
snprintf(buffer, SIZE, " %02d ", i);
write(fd, buffer, strlen(buffer));
mStreams[i].dump(fd);
@@ -1527,7 +1532,7 @@
#endif //AUDIO_POLICY_TEST
mPrimaryOutput((audio_io_handle_t)0),
mAvailableOutputDevices(AUDIO_DEVICE_NONE),
- mPhoneState(AudioSystem::MODE_NORMAL),
+ mPhoneState(AUDIO_MODE_NORMAL),
mLimitRingtoneVolume(false), mLastVoiceVolume(-1.0f),
mTotalEffectsCpuLoad(0), mTotalEffectsMemory(0),
mA2dpSuspended(false), mHasA2dp(false), mHasUsb(false), mHasRemoteSubmix(false),
@@ -1535,8 +1540,8 @@
{
mpClientInterface = clientInterface;
- for (int i = 0; i < AudioSystem::NUM_FORCE_USE; i++) {
- mForceUse[i] = AudioSystem::FORCE_NONE;
+ for (int i = 0; i < AUDIO_POLICY_FORCE_USE_CNT; i++) {
+ mForceUse[i] = AUDIO_POLICY_FORCE_NONE;
}
mA2dpDeviceAddress = String8("");
@@ -1615,8 +1620,8 @@
mTestDevice = AUDIO_DEVICE_OUT_SPEAKER;
mTestSamplingRate = 44100;
- mTestFormat = AudioSystem::PCM_16_BIT;
- mTestChannels = AudioSystem::CHANNEL_OUT_STEREO;
+ mTestFormat = AUDIO_FORMAT_PCM_16_BIT;
+ mTestChannels = AUDIO_CHANNEL_OUT_STEREO;
mTestLatencyMs = 0;
mCurOutput = 0;
mDirectOutput = false;
@@ -1697,15 +1702,15 @@
if (param.get(String8("test_cmd_policy_format"), value) == NO_ERROR) {
param.remove(String8("test_cmd_policy_format"));
- int format = AudioSystem::INVALID_FORMAT;
+ int format = AUDIO_FORMAT_INVALID;
if (value == "PCM 16 bits") {
- format = AudioSystem::PCM_16_BIT;
+ format = AUDIO_FORMAT_PCM_16_BIT;
} else if (value == "PCM 8 bits") {
- format = AudioSystem::PCM_8_BIT;
+ format = AUDIO_FORMAT_PCM_8_BIT;
} else if (value == "Compressed MP3") {
- format = AudioSystem::MP3;
+ format = AUDIO_FORMAT_MP3;
}
- if (format != AudioSystem::INVALID_FORMAT) {
+ if (format != AUDIO_FORMAT_INVALID) {
if (target == "Manager") {
mTestFormat = format;
} else if (mTestOutputs[mCurOutput] != 0) {
@@ -1720,9 +1725,9 @@
int channels = 0;
if (value == "Channels Stereo") {
- channels = AudioSystem::CHANNEL_OUT_STEREO;
+ channels = AUDIO_CHANNEL_OUT_STEREO;
} else if (value == "Channels Mono") {
- channels = AudioSystem::CHANNEL_OUT_MONO;
+ channels = AUDIO_CHANNEL_OUT_MONO;
}
if (channels != 0) {
if (target == "Manager") {
@@ -1815,13 +1820,13 @@
status_t AudioPolicyManagerBase::checkOutputsForDevice(audio_devices_t device,
- AudioSystem::device_connection_state state,
+ audio_policy_dev_state_t state,
SortedVector<audio_io_handle_t>& outputs,
const String8 paramStr)
{
AudioOutputDescriptor *desc;
- if (state == AudioSystem::DEVICE_STATE_AVAILABLE) {
+ if (state == AUDIO_POLICY_DEVICE_STATE_AVAILABLE) {
// first list already open outputs that can be routed to this device
for (size_t i = 0; i < mOutputs.size(); i++) {
desc = mOutputs.valueAt(i);
@@ -2048,9 +2053,9 @@
// and as they were also referenced on the other output, the reference
// count for their stream type must be adjusted accordingly on
// the other output.
- for (int j = 0; j < (int)AudioSystem::NUM_STREAM_TYPES; j++) {
+ for (int j = 0; j < AUDIO_STREAM_CNT; j++) {
int refCount = dupOutputDesc->mRefCount[j];
- outputDesc2->changeRefCount((AudioSystem::stream_type)j,-refCount);
+ outputDesc2->changeRefCount((audio_stream_type_t)j,-refCount);
}
audio_io_handle_t duplicatedOutput = mOutputs.keyAt(i);
ALOGV("closeOutput() closing also duplicated output %d", duplicatedOutput);
@@ -2141,9 +2146,9 @@
}
}
// Move tracks associated to this strategy from previous output to new output
- for (int i = 0; i < (int)AudioSystem::NUM_STREAM_TYPES; i++) {
- if (getStrategy((AudioSystem::stream_type)i) == strategy) {
- mpClientInterface->invalidateStream((AudioSystem::stream_type)i);
+ for (int i = 0; i < AUDIO_STREAM_CNT; i++) {
+ if (getStrategy((audio_stream_type_t)i) == strategy) {
+ mpClientInterface->invalidateStream((audio_stream_type_t)i);
}
}
}
@@ -2199,20 +2204,20 @@
//
if (mA2dpSuspended) {
if (((mScoDeviceAddress == "") ||
- ((mForceUse[AudioSystem::FOR_COMMUNICATION] != AudioSystem::FORCE_BT_SCO) &&
- (mForceUse[AudioSystem::FOR_RECORD] != AudioSystem::FORCE_BT_SCO))) &&
- ((mPhoneState != AudioSystem::MODE_IN_CALL) &&
- (mPhoneState != AudioSystem::MODE_RINGTONE))) {
+ ((mForceUse[AUDIO_POLICY_FORCE_FOR_COMMUNICATION] != AUDIO_POLICY_FORCE_BT_SCO) &&
+ (mForceUse[AUDIO_POLICY_FORCE_FOR_RECORD] != AUDIO_POLICY_FORCE_BT_SCO))) &&
+ ((mPhoneState != AUDIO_MODE_IN_CALL) &&
+ (mPhoneState != AUDIO_MODE_RINGTONE))) {
mpClientInterface->restoreOutput(a2dpOutput);
mA2dpSuspended = false;
}
} else {
if (((mScoDeviceAddress != "") &&
- ((mForceUse[AudioSystem::FOR_COMMUNICATION] == AudioSystem::FORCE_BT_SCO) ||
- (mForceUse[AudioSystem::FOR_RECORD] == AudioSystem::FORCE_BT_SCO))) ||
- ((mPhoneState == AudioSystem::MODE_IN_CALL) ||
- (mPhoneState == AudioSystem::MODE_RINGTONE))) {
+ ((mForceUse[AUDIO_POLICY_FORCE_FOR_COMMUNICATION] == AUDIO_POLICY_FORCE_BT_SCO) ||
+ (mForceUse[AUDIO_POLICY_FORCE_FOR_RECORD] == AUDIO_POLICY_FORCE_BT_SCO))) ||
+ ((mPhoneState == AUDIO_MODE_IN_CALL) ||
+ (mPhoneState == AUDIO_MODE_RINGTONE))) {
mpClientInterface->suspendOutput(a2dpOutput);
mA2dpSuspended = true;
@@ -2257,16 +2262,16 @@
return device;
}
-uint32_t AudioPolicyManagerBase::getStrategyForStream(AudioSystem::stream_type stream) {
+uint32_t AudioPolicyManagerBase::getStrategyForStream(audio_stream_type_t stream) {
return (uint32_t)getStrategy(stream);
}
-audio_devices_t AudioPolicyManagerBase::getDevicesForStream(AudioSystem::stream_type stream) {
+audio_devices_t AudioPolicyManagerBase::getDevicesForStream(audio_stream_type_t stream) {
audio_devices_t devices;
// By checking the range of stream before calling getStrategy, we avoid
// getStrategy's behavior for invalid streams. getStrategy would do a ALOGE
// and then return STRATEGY_MEDIA, but we want to return the empty set.
- if (stream < (AudioSystem::stream_type) 0 || stream >= AudioSystem::NUM_STREAM_TYPES) {
+ if (stream < (audio_stream_type_t) 0 || stream >= AUDIO_STREAM_CNT) {
devices = AUDIO_DEVICE_NONE;
} else {
AudioPolicyManagerBase::routing_strategy strategy = getStrategy(stream);
@@ -2276,35 +2281,35 @@
}
AudioPolicyManagerBase::routing_strategy AudioPolicyManagerBase::getStrategy(
- AudioSystem::stream_type stream) {
+ audio_stream_type_t stream) {
// stream to strategy mapping
switch (stream) {
- case AudioSystem::VOICE_CALL:
- case AudioSystem::BLUETOOTH_SCO:
+ case AUDIO_STREAM_VOICE_CALL:
+ case AUDIO_STREAM_BLUETOOTH_SCO:
return STRATEGY_PHONE;
- case AudioSystem::RING:
- case AudioSystem::ALARM:
+ case AUDIO_STREAM_RING:
+ case AUDIO_STREAM_ALARM:
return STRATEGY_SONIFICATION;
- case AudioSystem::NOTIFICATION:
+ case AUDIO_STREAM_NOTIFICATION:
return STRATEGY_SONIFICATION_RESPECTFUL;
- case AudioSystem::DTMF:
+ case AUDIO_STREAM_DTMF:
return STRATEGY_DTMF;
default:
ALOGE("unknown stream type");
- case AudioSystem::SYSTEM:
+ case AUDIO_STREAM_SYSTEM:
// NOTE: SYSTEM stream uses MEDIA strategy because muting music and switching outputs
// while key clicks are played produces a poor result
- case AudioSystem::TTS:
- case AudioSystem::MUSIC:
+ case AUDIO_STREAM_TTS:
+ case AUDIO_STREAM_MUSIC:
return STRATEGY_MEDIA;
- case AudioSystem::ENFORCED_AUDIBLE:
+ case AUDIO_STREAM_ENFORCED_AUDIBLE:
return STRATEGY_ENFORCED_AUDIBLE;
}
}
-void AudioPolicyManagerBase::handleNotificationRoutingForStream(AudioSystem::stream_type stream) {
+void AudioPolicyManagerBase::handleNotificationRoutingForStream(audio_stream_type_t stream) {
switch(stream) {
- case AudioSystem::MUSIC:
+ case AUDIO_STREAM_MUSIC:
checkOutputForStrategy(STRATEGY_SONIFICATION_RESPECTFUL);
updateDevicesAndOutputs();
break;
@@ -2329,14 +2334,14 @@
case STRATEGY_SONIFICATION_RESPECTFUL:
if (isInCall()) {
device = getDeviceForStrategy(STRATEGY_SONIFICATION, false /*fromCache*/);
- } else if (isStreamActiveRemotely(AudioSystem::MUSIC,
+ } else if (isStreamActiveRemotely(AUDIO_STREAM_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)) {
+ } else if (isStreamActive(AUDIO_STREAM_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 {
@@ -2358,8 +2363,8 @@
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:
+ switch (mForceUse[AUDIO_POLICY_FORCE_FOR_COMMUNICATION]) {
+ case AUDIO_POLICY_FORCE_BT_SCO:
if (!isInCall() || strategy != STRATEGY_DTMF) {
device = mAvailableOutputDevices & AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT;
if (device) break;
@@ -2374,7 +2379,7 @@
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) &&
+ (mForceUse[AUDIO_POLICY_FORCE_FOR_MEDIA] != AUDIO_POLICY_FORCE_NO_BT_A2DP) &&
(getA2dpOutput() != 0) && !mA2dpSuspended) {
device = mAvailableOutputDevices & AUDIO_DEVICE_OUT_BLUETOOTH_A2DP;
if (device) break;
@@ -2385,7 +2390,7 @@
if (device) break;
device = mAvailableOutputDevices & AUDIO_DEVICE_OUT_WIRED_HEADSET;
if (device) break;
- if (mPhoneState != AudioSystem::MODE_IN_CALL) {
+ if (mPhoneState != AUDIO_MODE_IN_CALL) {
device = mAvailableOutputDevices & AUDIO_DEVICE_OUT_USB_ACCESSORY;
if (device) break;
device = mAvailableOutputDevices & AUDIO_DEVICE_OUT_USB_DEVICE;
@@ -2405,16 +2410,16 @@
}
break;
- case AudioSystem::FORCE_SPEAKER:
+ case AUDIO_POLICY_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) &&
+ (mForceUse[AUDIO_POLICY_FORCE_FOR_MEDIA] != AUDIO_POLICY_FORCE_NO_BT_A2DP) &&
(getA2dpOutput() != 0) && !mA2dpSuspended) {
device = mAvailableOutputDevices & AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER;
if (device) break;
}
- if (mPhoneState != AudioSystem::MODE_IN_CALL) {
+ if (mPhoneState != AUDIO_MODE_IN_CALL) {
device = mAvailableOutputDevices & AUDIO_DEVICE_OUT_USB_ACCESSORY;
if (device) break;
device = mAvailableOutputDevices & AUDIO_DEVICE_OUT_USB_DEVICE;
@@ -2453,7 +2458,7 @@
// - in countries where not enforced in which case it follows STRATEGY_MEDIA
if ((strategy == STRATEGY_SONIFICATION) ||
- (mForceUse[AudioSystem::FOR_SYSTEM] == AudioSystem::FORCE_SYSTEM_ENFORCED)) {
+ (mForceUse[AUDIO_POLICY_FORCE_FOR_SYSTEM] == AUDIO_POLICY_FORCE_SYSTEM_ENFORCED)) {
device = mAvailableOutputDevices & AUDIO_DEVICE_OUT_SPEAKER;
if (device == AUDIO_DEVICE_NONE) {
ALOGE("getDeviceForStrategy() speaker device not found for STRATEGY_SONIFICATION");
@@ -2469,7 +2474,8 @@
device2 = mAvailableOutputDevices & AUDIO_DEVICE_OUT_REMOTE_SUBMIX;
}
if ((device2 == AUDIO_DEVICE_NONE) &&
- mHasA2dp && (mForceUse[AudioSystem::FOR_MEDIA] != AudioSystem::FORCE_NO_BT_A2DP) &&
+ mHasA2dp &&
+ (mForceUse[AUDIO_POLICY_FORCE_FOR_MEDIA] != AUDIO_POLICY_FORCE_NO_BT_A2DP) &&
(getA2dpOutput() != 0) && !mA2dpSuspended) {
device2 = mAvailableOutputDevices & AUDIO_DEVICE_OUT_BLUETOOTH_A2DP;
if (device2 == AUDIO_DEVICE_NONE) {
@@ -2499,7 +2505,7 @@
device2 = mAvailableOutputDevices & AUDIO_DEVICE_OUT_AUX_DIGITAL;
}
if ((device2 == AUDIO_DEVICE_NONE) &&
- (mForceUse[AudioSystem::FOR_DOCK] == AudioSystem::FORCE_ANALOG_DOCK)) {
+ (mForceUse[AUDIO_POLICY_FORCE_FOR_DOCK] == AUDIO_POLICY_FORCE_ANALOG_DOCK)) {
device2 = mAvailableOutputDevices & AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET;
}
if (device2 == AUDIO_DEVICE_NONE) {
@@ -2546,7 +2552,7 @@
uint32_t muteWaitMs = 0;
audio_devices_t device = outputDesc->device();
- bool shouldMute = outputDesc->isActive() && (AudioSystem::popCount(device) >= 2);
+ bool shouldMute = outputDesc->isActive() && (popcount(device) >= 2);
// temporary mute output if device selection changes to avoid volume bursts due to
// different per device volumes
bool tempMute = outputDesc->isActive() && (device != prevDevice);
@@ -2685,7 +2691,7 @@
return NULL;
}
-audio_devices_t AudioPolicyManagerBase::getDeviceForInputSource(int inputSource)
+audio_devices_t AudioPolicyManagerBase::getDeviceForInputSource(audio_source_t inputSource)
{
uint32_t device = AUDIO_DEVICE_NONE;
@@ -2702,7 +2708,7 @@
case AUDIO_SOURCE_VOICE_RECOGNITION:
case AUDIO_SOURCE_HOTWORD:
case AUDIO_SOURCE_VOICE_COMMUNICATION:
- if (mForceUse[AudioSystem::FOR_RECORD] == AudioSystem::FORCE_BT_SCO &&
+ if (mForceUse[AUDIO_POLICY_FORCE_FOR_RECORD] == AUDIO_POLICY_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) {
@@ -2766,7 +2772,7 @@
// this happens when forcing a route update and no track is active on an output.
// In this case the returned category is not important.
device = AUDIO_DEVICE_OUT_SPEAKER;
- } else if (AudioSystem::popCount(device) > 1) {
+ } else if (popcount(device) > 1) {
// Multiple device selection is either:
// - speaker + one other device: give priority to speaker in this case.
// - one A2DP device + another device: happens with duplicated output. In this case
@@ -2779,7 +2785,7 @@
}
}
- ALOGW_IF(AudioSystem::popCount(device) != 1,
+ ALOGW_IF(popcount(device) != 1,
"getDeviceForVolume() invalid device combination: %08x",
device);
@@ -2989,7 +2995,7 @@
}
}
-float AudioPolicyManagerBase::computeVolume(int stream,
+float AudioPolicyManagerBase::computeVolume(audio_stream_type_t stream,
int index,
audio_io_handle_t output,
audio_devices_t device)
@@ -3003,7 +3009,7 @@
}
// if volume is not 0 (not muted), force media volume to max on digital output
- if (stream == AudioSystem::MUSIC &&
+ if (stream == AUDIO_STREAM_MUSIC &&
index != mStreams[stream].mIndexMin &&
(device == AUDIO_DEVICE_OUT_AUX_DIGITAL ||
device == AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET ||
@@ -3019,26 +3025,26 @@
// - always attenuate ring tones and notifications volume by 6dB
// - if music is playing, always limit the volume to current music volume,
// with a minimum threshold at -36dB so that notification is always perceived.
- const routing_strategy stream_strategy = getStrategy((AudioSystem::stream_type)stream);
+ const routing_strategy stream_strategy = getStrategy(stream);
if ((device & (AUDIO_DEVICE_OUT_BLUETOOTH_A2DP |
AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES |
AUDIO_DEVICE_OUT_WIRED_HEADSET |
AUDIO_DEVICE_OUT_WIRED_HEADPHONE)) &&
((stream_strategy == STRATEGY_SONIFICATION)
|| (stream_strategy == STRATEGY_SONIFICATION_RESPECTFUL)
- || (stream == AudioSystem::SYSTEM)
+ || (stream == AUDIO_STREAM_SYSTEM)
|| ((stream_strategy == STRATEGY_ENFORCED_AUDIBLE) &&
- (mForceUse[AudioSystem::FOR_SYSTEM] == AudioSystem::FORCE_NONE))) &&
+ (mForceUse[AUDIO_POLICY_FORCE_FOR_SYSTEM] == AUDIO_POLICY_FORCE_NONE))) &&
streamDesc.mCanBeMuted) {
volume *= SONIFICATION_HEADSET_VOLUME_FACTOR;
// when the phone is ringing we must consider that music could have been paused just before
// by the music application and behave as if music was active if the last music track was
// just stopped
- if (isStreamActive(AudioSystem::MUSIC, SONIFICATION_HEADSET_MUSIC_DELAY) ||
+ if (isStreamActive(AUDIO_STREAM_MUSIC, SONIFICATION_HEADSET_MUSIC_DELAY) ||
mLimitRingtoneVolume) {
audio_devices_t musicDevice = getDeviceForStrategy(STRATEGY_MEDIA, true /*fromCache*/);
- float musicVol = computeVolume(AudioSystem::MUSIC,
- mStreams[AudioSystem::MUSIC].getVolumeIndex(musicDevice),
+ float musicVol = computeVolume(AUDIO_STREAM_MUSIC,
+ mStreams[AUDIO_STREAM_MUSIC].getVolumeIndex(musicDevice),
output,
musicDevice);
float minVol = (musicVol > SONIFICATION_HEADSET_VOLUME_MIN) ?
@@ -3053,7 +3059,7 @@
return volume;
}
-status_t AudioPolicyManagerBase::checkAndSetVolume(int stream,
+status_t AudioPolicyManagerBase::checkAndSetVolume(audio_stream_type_t stream,
int index,
audio_io_handle_t output,
audio_devices_t device,
@@ -3069,10 +3075,12 @@
}
// 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)) {
+ if ((stream == AUDIO_STREAM_VOICE_CALL &&
+ mForceUse[AUDIO_POLICY_FORCE_FOR_COMMUNICATION] == AUDIO_POLICY_FORCE_BT_SCO) ||
+ (stream == AUDIO_STREAM_BLUETOOTH_SCO &&
+ mForceUse[AUDIO_POLICY_FORCE_FOR_COMMUNICATION] != AUDIO_POLICY_FORCE_BT_SCO)) {
ALOGV("checkAndSetVolume() cannot set stream %d volume with force use = %d for comm",
- stream, mForceUse[AudioSystem::FOR_COMMUNICATION]);
+ stream, mForceUse[AUDIO_POLICY_FORCE_FOR_COMMUNICATION]);
return INVALID_OPERATION;
}
@@ -3086,17 +3094,17 @@
ALOGVV("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);
+ if (stream == AUDIO_STREAM_BLUETOOTH_SCO) {
+ mpClientInterface->setStreamVolume(AUDIO_STREAM_VOICE_CALL, volume, output, delayMs);
}
- mpClientInterface->setStreamVolume((AudioSystem::stream_type)stream, volume, output, delayMs);
+ mpClientInterface->setStreamVolume(stream, volume, output, delayMs);
}
- if (stream == AudioSystem::VOICE_CALL ||
- stream == AudioSystem::BLUETOOTH_SCO) {
+ if (stream == AUDIO_STREAM_VOICE_CALL ||
+ stream == AUDIO_STREAM_BLUETOOTH_SCO) {
float voiceVolume;
// Force voice volume to max for bluetooth SCO as volume is managed by the headset
- if (stream == AudioSystem::VOICE_CALL) {
+ if (stream == AUDIO_STREAM_VOICE_CALL) {
voiceVolume = (float)index/(float)mStreams[stream].mIndexMax;
} else {
voiceVolume = 1.0;
@@ -3118,8 +3126,8 @@
{
ALOGVV("applyStreamVolumes() for output %d and device %x", output, device);
- for (int stream = 0; stream < AudioSystem::NUM_STREAM_TYPES; stream++) {
- checkAndSetVolume(stream,
+ for (int stream = 0; stream < AUDIO_STREAM_CNT; stream++) {
+ checkAndSetVolume((audio_stream_type_t)stream,
mStreams[stream].getVolumeIndex(device),
output,
device,
@@ -3135,14 +3143,14 @@
audio_devices_t device)
{
ALOGVV("setStrategyMute() strategy %d, mute %d, output %d", strategy, on, output);
- for (int stream = 0; stream < AudioSystem::NUM_STREAM_TYPES; stream++) {
- if (getStrategy((AudioSystem::stream_type)stream) == strategy) {
- setStreamMute(stream, on, output, delayMs, device);
+ for (int stream = 0; stream < AUDIO_STREAM_CNT; stream++) {
+ if (getStrategy((audio_stream_type_t)stream) == strategy) {
+ setStreamMute((audio_stream_type_t)stream, on, output, delayMs, device);
}
}
}
-void AudioPolicyManagerBase::setStreamMute(int stream,
+void AudioPolicyManagerBase::setStreamMute(audio_stream_type_t stream,
bool on,
audio_io_handle_t output,
int delayMs,
@@ -3160,8 +3168,8 @@
if (on) {
if (outputDesc->mMuteCount[stream] == 0) {
if (streamDesc.mCanBeMuted &&
- ((stream != AudioSystem::ENFORCED_AUDIBLE) ||
- (mForceUse[AudioSystem::FOR_SYSTEM] == AudioSystem::FORCE_NONE))) {
+ ((stream != AUDIO_STREAM_ENFORCED_AUDIBLE) ||
+ (mForceUse[AUDIO_POLICY_FORCE_FOR_SYSTEM] == AUDIO_POLICY_FORCE_NONE))) {
checkAndSetVolume(stream, 0, output, device, delayMs);
}
}
@@ -3182,7 +3190,8 @@
}
}
-void AudioPolicyManagerBase::handleIncallSonification(int stream, bool starting, bool stateChange)
+void AudioPolicyManagerBase::handleIncallSonification(audio_stream_type_t stream,
+ bool starting, bool stateChange)
{
// if the stream pertains to sonification strategy and we are in call we must
// mute the stream if it is low visibility. If it is high visibility, we must play a tone
@@ -3190,7 +3199,7 @@
// interfere with the device used for phone strategy
// if stateChange is true, we are called from setPhoneState() and we must mute or unmute as
// many times as there are active tracks on the output
- const routing_strategy stream_strategy = getStrategy((AudioSystem::stream_type)stream);
+ const routing_strategy stream_strategy = getStrategy(stream);
if ((stream_strategy == STRATEGY_SONIFICATION) ||
((stream_strategy == STRATEGY_SONIFICATION_RESPECTFUL))) {
AudioOutputDescriptor *outputDesc = mOutputs.valueFor(mPrimaryOutput);
@@ -3201,7 +3210,7 @@
if (stateChange) {
muteCount = outputDesc->mRefCount[stream];
}
- if (AudioSystem::isLowVisibility((AudioSystem::stream_type)stream)) {
+ if (audio_is_low_visibility(stream)) {
ALOGV("handleIncallSonification() low visibility, muteCount %d", muteCount);
for (int i = 0; i < muteCount; i++) {
setStreamMute(stream, starting, mPrimaryOutput);
@@ -3216,7 +3225,8 @@
}
}
if (starting) {
- mpClientInterface->startTone(ToneGenerator::TONE_SUP_CALL_WAITING, AudioSystem::VOICE_CALL);
+ mpClientInterface->startTone(AUDIO_POLICY_TONE_IN_CALL_NOTIFICATION,
+ AUDIO_STREAM_VOICE_CALL);
} else {
mpClientInterface->stopTone();
}
@@ -3231,8 +3241,8 @@
}
bool AudioPolicyManagerBase::isStateInCall(int state) {
- return ((state == AudioSystem::MODE_IN_CALL) ||
- (state == AudioSystem::MODE_IN_COMMUNICATION));
+ return ((state == AUDIO_MODE_IN_CALL) ||
+ (state == AUDIO_MODE_IN_COMMUNICATION));
}
uint32_t AudioPolicyManagerBase::getMaxEffectsCpuLoad()
@@ -3255,7 +3265,7 @@
mOutput1(0), mOutput2(0), mProfile(profile), mDirectOpenCount(0)
{
// clear usage count for all stream types
- for (int i = 0; i < AudioSystem::NUM_STREAM_TYPES; i++) {
+ for (int i = 0; i < AUDIO_STREAM_CNT; i++) {
mRefCount[i] = 0;
mCurVolume[i] = -1.0;
mMuteCount[i] = 0;
@@ -3302,7 +3312,8 @@
}
}
-void AudioPolicyManagerBase::AudioOutputDescriptor::changeRefCount(AudioSystem::stream_type stream, int delta)
+void AudioPolicyManagerBase::AudioOutputDescriptor::changeRefCount(audio_stream_type_t stream,
+ int delta)
{
// forward usage count change to attached outputs
if (isDuplicated()) {
@@ -3310,7 +3321,8 @@
mOutput2->changeRefCount(stream, delta);
}
if ((delta + (int)mRefCount[stream]) < 0) {
- ALOGW("changeRefCount() invalid delta %d for stream %d, refCount %d", delta, stream, mRefCount[stream]);
+ ALOGW("changeRefCount() invalid delta %d for stream %d, refCount %d",
+ delta, stream, mRefCount[stream]);
mRefCount[stream] = 0;
return;
}
@@ -3339,17 +3351,17 @@
if ((sysTime == 0) && (inPastMs != 0)) {
sysTime = systemTime();
}
- for (int i = 0; i < AudioSystem::NUM_STREAM_TYPES; i++) {
- if (((getStrategy((AudioSystem::stream_type)i) == strategy) ||
+ for (int i = 0; i < (int)AUDIO_STREAM_CNT; i++) {
+ if (((getStrategy((audio_stream_type_t)i) == strategy) ||
(NUM_STRATEGIES == strategy)) &&
- isStreamActive((AudioSystem::stream_type)i, inPastMs, sysTime)) {
+ isStreamActive((audio_stream_type_t)i, inPastMs, sysTime)) {
return true;
}
}
return false;
}
-bool AudioPolicyManagerBase::AudioOutputDescriptor::isStreamActive(AudioSystem::stream_type stream,
+bool AudioPolicyManagerBase::AudioOutputDescriptor::isStreamActive(audio_stream_type_t stream,
uint32_t inPastMs,
nsecs_t sysTime) const
{
@@ -3389,8 +3401,9 @@
result.append(buffer);
snprintf(buffer, SIZE, " Stream volume refCount muteCount\n");
result.append(buffer);
- for (int i = 0; i < AudioSystem::NUM_STREAM_TYPES; i++) {
- snprintf(buffer, SIZE, " %02d %.03f %02d %02d\n", i, mCurVolume[i], mRefCount[i], mMuteCount[i]);
+ for (int i = 0; i < (int)AUDIO_STREAM_CNT; i++) {
+ snprintf(buffer, SIZE, " %02d %.03f %02d %02d\n",
+ i, mCurVolume[i], mRefCount[i], mMuteCount[i]);
result.append(buffer);
}
write(fd, result.string(), result.size());
@@ -3403,7 +3416,7 @@
AudioPolicyManagerBase::AudioInputDescriptor::AudioInputDescriptor(const IOProfile *profile)
: mSamplingRate(0), mFormat(AUDIO_FORMAT_DEFAULT), mChannelMask(0),
mDevice(AUDIO_DEVICE_NONE), mRefCount(0),
- mInputSource(0), mProfile(profile)
+ mInputSource(AUDIO_SOURCE_DEFAULT), mProfile(profile)
{
}
diff --git a/services/audiopolicy/AudioPolicyManagerBase.h b/services/audiopolicy/AudioPolicyManagerBase.h
index 1ff409e..210ba66 100644
--- a/services/audiopolicy/AudioPolicyManagerBase.h
+++ b/services/audiopolicy/AudioPolicyManagerBase.h
@@ -23,13 +23,10 @@
#include <utils/Errors.h>
#include <utils/KeyedVector.h>
#include <utils/SortedVector.h>
-#include <hardware_legacy/AudioPolicyInterface.h>
+#include "AudioPolicyInterface.h"
-namespace android_audio_legacy {
- using android::KeyedVector;
- using android::DefaultKeyedVector;
- using android::SortedVector;
+namespace android {
// ----------------------------------------------------------------------------
@@ -77,33 +74,34 @@
// AudioPolicyInterface
virtual status_t setDeviceConnectionState(audio_devices_t device,
- AudioSystem::device_connection_state state,
+ audio_policy_dev_state_t state,
const char *device_address);
- virtual AudioSystem::device_connection_state getDeviceConnectionState(audio_devices_t device,
+ virtual audio_policy_dev_state_t getDeviceConnectionState(audio_devices_t device,
const char *device_address);
- virtual void setPhoneState(int state);
- virtual void setForceUse(AudioSystem::force_use usage, AudioSystem::forced_config config);
- virtual AudioSystem::forced_config getForceUse(AudioSystem::force_use usage);
+ virtual void setPhoneState(audio_mode_t state);
+ virtual void setForceUse(audio_policy_force_use_t usage,
+ audio_policy_forced_cfg_t config);
+ virtual audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage);
virtual void setSystemProperty(const char* property, const char* value);
virtual status_t initCheck();
- virtual audio_io_handle_t getOutput(AudioSystem::stream_type stream,
+ virtual audio_io_handle_t getOutput(audio_stream_type_t stream,
uint32_t samplingRate,
audio_format_t format,
audio_channel_mask_t channelMask,
- AudioSystem::output_flags flags,
+ audio_output_flags_t flags,
const audio_offload_info_t *offloadInfo);
virtual status_t startOutput(audio_io_handle_t output,
- AudioSystem::stream_type stream,
+ audio_stream_type_t stream,
int session = 0);
virtual status_t stopOutput(audio_io_handle_t output,
- AudioSystem::stream_type stream,
+ audio_stream_type_t stream,
int session = 0);
virtual void releaseOutput(audio_io_handle_t output);
- virtual audio_io_handle_t getInput(int inputSource,
+ virtual audio_io_handle_t getInput(audio_source_t inputSource,
uint32_t samplingRate,
audio_format_t format,
audio_channel_mask_t channelMask,
- AudioSystem::audio_in_acoustics acoustics);
+ audio_in_acoustics_t acoustics);
// indicates to the audio policy manager that the input starts being used.
virtual status_t startInput(audio_io_handle_t input);
@@ -111,21 +109,21 @@
// indicates to the audio policy manager that the input stops being used.
virtual status_t stopInput(audio_io_handle_t input);
virtual void releaseInput(audio_io_handle_t input);
- virtual void initStreamVolume(AudioSystem::stream_type stream,
+ virtual void initStreamVolume(audio_stream_type_t stream,
int indexMin,
int indexMax);
- virtual status_t setStreamVolumeIndex(AudioSystem::stream_type stream,
+ virtual status_t setStreamVolumeIndex(audio_stream_type_t stream,
int index,
audio_devices_t device);
- virtual status_t getStreamVolumeIndex(AudioSystem::stream_type stream,
+ virtual status_t getStreamVolumeIndex(audio_stream_type_t stream,
int *index,
audio_devices_t device);
// return the strategy corresponding to a given stream type
- virtual uint32_t getStrategyForStream(AudioSystem::stream_type stream);
+ virtual uint32_t getStrategyForStream(audio_stream_type_t stream);
// return the enabled output devices for the given stream type
- virtual audio_devices_t getDevicesForStream(AudioSystem::stream_type stream);
+ virtual audio_devices_t getDevicesForStream(audio_stream_type_t stream);
virtual audio_io_handle_t getOutputForEffect(const effect_descriptor_t *desc = NULL);
virtual status_t registerEffect(const effect_descriptor_t *desc,
@@ -136,11 +134,11 @@
virtual status_t unregisterEffect(int id);
virtual status_t setEffectEnabled(int id, bool enabled);
- virtual bool isStreamActive(int stream, uint32_t inPastMs = 0) const;
+ virtual bool isStreamActive(audio_stream_type_t stream, uint32_t inPastMs = 0) const;
// return whether a stream is playing remotely, override to change the definition of
// local/remote playback, used for instance by notification manager to not make
// media players lose audio focus when not playing locally
- virtual bool isStreamActiveRemotely(int stream, uint32_t inPastMs = 0) const;
+ virtual bool isStreamActiveRemotely(audio_stream_type_t stream, uint32_t inPastMs = 0) const;
virtual bool isSourceActive(audio_source_t source) const;
virtual status_t dump(int fd);
@@ -254,14 +252,14 @@
status_t dump(int fd);
audio_devices_t device() const;
- void changeRefCount(AudioSystem::stream_type stream, int delta);
+ void changeRefCount(audio_stream_type_t stream, int delta);
bool isDuplicated() const { return (mOutput1 != NULL && mOutput2 != NULL); }
audio_devices_t supportedDevices();
uint32_t latency();
bool sharesHwModuleWith(const AudioOutputDescriptor *outputDesc);
bool isActive(uint32_t inPastMs = 0) const;
- bool isStreamActive(AudioSystem::stream_type stream,
+ bool isStreamActive(audio_stream_type_t stream,
uint32_t inPastMs = 0,
nsecs_t sysTime = 0) const;
bool isStrategyActive(routing_strategy strategy,
@@ -275,12 +273,12 @@
uint32_t mLatency; //
audio_output_flags_t mFlags; //
audio_devices_t mDevice; // current device this output is routed to
- uint32_t mRefCount[AudioSystem::NUM_STREAM_TYPES]; // number of streams of each type using this output
- nsecs_t mStopTime[AudioSystem::NUM_STREAM_TYPES];
+ uint32_t mRefCount[AUDIO_STREAM_CNT]; // number of streams of each type using this output
+ nsecs_t mStopTime[AUDIO_STREAM_CNT];
AudioOutputDescriptor *mOutput1; // used by duplicated outputs: first output
AudioOutputDescriptor *mOutput2; // used by duplicated outputs: second output
- float mCurVolume[AudioSystem::NUM_STREAM_TYPES]; // current stream volume
- int mMuteCount[AudioSystem::NUM_STREAM_TYPES]; // mute request counter
+ float mCurVolume[AUDIO_STREAM_CNT]; // current stream volume
+ int mMuteCount[AUDIO_STREAM_CNT]; // mute request counter
const IOProfile *mProfile; // I/O profile this output derives from
bool mStrategyMutedByDevice[NUM_STRATEGIES]; // strategies muted because of incompatible
// device selection. See checkDeviceMuteStrategies()
@@ -301,7 +299,7 @@
audio_channel_mask_t mChannelMask; //
audio_devices_t mDevice; // current device this input is routed to
uint32_t mRefCount; // number of AudioRecord clients using this output
- int mInputSource; // input source selected by application (mediarecorder.h)
+ audio_source_t mInputSource; // input source selected by application (mediarecorder.h)
const IOProfile *mProfile; // I/O profile this output derives from
};
@@ -339,7 +337,7 @@
void addOutput(audio_io_handle_t id, AudioOutputDescriptor *outputDesc);
// return the strategy corresponding to a given stream type
- static routing_strategy getStrategy(AudioSystem::stream_type stream);
+ static routing_strategy getStrategy(audio_stream_type_t stream);
// return appropriate device for streams handled by the specified strategy according to current
// phone state, connected devices...
@@ -363,7 +361,7 @@
int delayMs = 0);
// select input device corresponding to requested audio source
- virtual audio_devices_t getDeviceForInputSource(int inputSource);
+ virtual audio_devices_t getDeviceForInputSource(audio_source_t inputSource);
// return io handle of active input or 0 if no input is active
// Only considers inputs from physical devices (e.g. main mic, headset mic) when
@@ -375,10 +373,12 @@
// compute the actual volume for a given stream according to the requested index and a particular
// device
- virtual float computeVolume(int stream, int index, audio_io_handle_t output, audio_devices_t device);
+ virtual float computeVolume(audio_stream_type_t stream, int index,
+ audio_io_handle_t output, audio_devices_t device);
// check that volume change is permitted, compute and send new volume to audio hardware
- status_t checkAndSetVolume(int stream, int index, audio_io_handle_t output, audio_devices_t device, int delayMs = 0, bool force = false);
+ status_t checkAndSetVolume(audio_stream_type_t stream, int index, audio_io_handle_t output,
+ audio_devices_t device, int delayMs = 0, bool force = false);
// apply all stream volumes to the specified output and device
void applyStreamVolumes(audio_io_handle_t output, audio_devices_t device, int delayMs = 0, bool force = false);
@@ -391,7 +391,7 @@
audio_devices_t device = (audio_devices_t)0);
// Mute or unmute the stream on the specified output
- void setStreamMute(int stream,
+ void setStreamMute(audio_stream_type_t stream,
bool on,
audio_io_handle_t output,
int delayMs = 0,
@@ -399,7 +399,7 @@
// handle special cases for sonification strategy while in call: mute streams or replace by
// a special tone in the device used for communication
- void handleIncallSonification(int stream, bool starting, bool stateChange);
+ void handleIncallSonification(audio_stream_type_t stream, bool starting, bool stateChange);
// true if device is in a telephony or VoIP call
virtual bool isInCall();
@@ -414,7 +414,7 @@
// returns its handle if any.
// transfers the audio tracks and effects from one output thread to another accordingly.
status_t checkOutputsForDevice(audio_devices_t device,
- AudioSystem::device_connection_state state,
+ audio_policy_dev_state_t state,
SortedVector<audio_io_handle_t>& outputs,
const String8 paramStr);
@@ -480,7 +480,7 @@
uint32_t delayMs);
audio_io_handle_t selectOutput(const SortedVector<audio_io_handle_t>& outputs,
- AudioSystem::output_flags flags);
+ audio_output_flags_t flags);
IOProfile *getInputProfile(audio_devices_t device,
uint32_t samplingRate,
audio_format_t format,
@@ -530,9 +530,9 @@
// without AUDIO_DEVICE_BIT_IN to allow direct bit
// field comparisons
int mPhoneState; // current phone state
- AudioSystem::forced_config mForceUse[AudioSystem::NUM_FORCE_USE]; // current forced use configuration
+ audio_policy_forced_cfg_t mForceUse[AUDIO_POLICY_FORCE_USE_CNT]; // current forced use configuration
- StreamDescriptor mStreams[AudioSystem::NUM_STREAM_TYPES]; // stream descriptors for volume control
+ StreamDescriptor mStreams[AUDIO_STREAM_CNT]; // stream descriptors for volume control
String8 mA2dpDeviceAddress; // A2DP device MAC address
String8 mScoDeviceAddress; // SCO device MAC address
String8 mUsbCardAndDevice; // USB audio ALSA card and device numbers:
@@ -580,7 +580,7 @@
int indexInUi);
// updates device caching and output for streams that can influence the
// routing of notifications
- void handleNotificationRoutingForStream(AudioSystem::stream_type stream);
+ void handleNotificationRoutingForStream(audio_stream_type_t stream);
static bool isVirtualInputDevice(audio_devices_t device);
};