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

3 files changed, 252 insertions, 243 deletions

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 @@ public:
 
     // 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 @@ public:
     //
 
     // 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 @@ public:
     //
 
     // 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 @@ public:
     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 @@ public:
 
     // 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 @@ public:
 
     // 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 @@ namespace android_audio_legacy {
 
 
 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 @@ status_t AudioPolicyManagerBase::setDeviceConnectionState(audio_devices_t device
         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 @@ status_t AudioPolicyManagerBase::setDeviceConnectionState(audio_devices_t device
 
             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 @@ status_t AudioPolicyManagerBase::setDeviceConnectionState(audio_devices_t device
                 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 @@ status_t AudioPolicyManagerBase::setDeviceConnectionState(audio_devices_t device
         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 @@ status_t AudioPolicyManagerBase::setDeviceConnectionState(audio_devices_t device
             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 @@ status_t AudioPolicyManagerBase::setDeviceConnectionState(audio_devices_t device
     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 @@ AudioSystem::device_connection_state AudioPolicyManagerBase::getDeviceConnection
             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 @@ void AudioPolicyManagerBase::setPhoneState(int state)
     // 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 @@ void AudioPolicyManagerBase::setPhoneState(int state)
     // 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 @@ void AudioPolicyManagerBase::setForceUse(AudioSystem::force_use usage, AudioSyst
 
 }
 
-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 @@ AudioPolicyManagerBase::IOProfile *AudioPolicyManagerBase::getProfileForDirectOu
     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 @@ audio_io_handle_t AudioPolicyManagerBase::getOutput(AudioSystem::stream_type str
             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 @@ audio_io_handle_t AudioPolicyManagerBase::getOutput(AudioSystem::stream_type str
     // 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::getOutput(AudioSystem::stream_type str
 }
 
 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 @@ audio_io_handle_t AudioPolicyManagerBase::selectOutput(const SortedVector<audio_
     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 @@ audio_io_handle_t AudioPolicyManagerBase::selectOutput(const SortedVector<audio_
 }
 
 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::startOutput(audio_io_handle_t output,
 
 
 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 @@ void AudioPolicyManagerBase::releaseOutput(audio_io_handle_t output)
 #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 @@ void AudioPolicyManagerBase::releaseOutput(audio_io_handle_t output)
 }
 
 
-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 @@ status_t AudioPolicyManagerBase::startInput(audio_io_handle_t input)
     // 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 @@ status_t AudioPolicyManagerBase::stopInput(audio_io_handle_t input)
         // 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 @@ void AudioPolicyManagerBase::releaseInput(audio_io_handle_t input)
     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 @@ void AudioPolicyManagerBase::initStreamVolume(AudioSystem::stream_type stream,
     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 @@ status_t AudioPolicyManagerBase::setStreamVolumeIndex(AudioSystem::stream_type s
     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 @@ audio_io_handle_t AudioPolicyManagerBase::getOutputForEffect(const effect_descri
 {
     // 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 @@ bool AudioPolicyManagerBase::isNonOffloadableEffectEnabled()
     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 @@ bool AudioPolicyManagerBase::isSourceActive(audio_source_t source) const
     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 @@ status_t AudioPolicyManagerBase::dump(int fd)
     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 @@ status_t AudioPolicyManagerBase::dump(int fd)
     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 @@ AudioPolicyManagerBase::AudioPolicyManagerBase(AudioPolicyClientInterface *clien
 #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 @@ AudioPolicyManagerBase::AudioPolicyManagerBase(AudioPolicyClientInterface *clien
 {
     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 @@ AudioPolicyManagerBase::AudioPolicyManagerBase(AudioPolicyClientInterface *clien
 
         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 @@ bool AudioPolicyManagerBase::threadLoop()
 
             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 @@ bool AudioPolicyManagerBase::threadLoop()
                 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 @@ void AudioPolicyManagerBase::addOutput(audio_io_handle_t id, AudioOutputDescript
 
 
 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 @@ void AudioPolicyManagerBase::closeOutput(audio_io_handle_t output)
             // 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 @@ void AudioPolicyManagerBase::checkOutputForStrategy(routing_strategy strategy)
             }
         }
         // 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 @@ void AudioPolicyManagerBase::checkA2dpSuspend()
     //
     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 @@ audio_devices_t AudioPolicyManagerBase::getNewDevice(audio_io_handle_t output, b
     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 @@ audio_devices_t AudioPolicyManagerBase::getDevicesForStream(AudioSystem::stream_
 }
 
 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 @@ audio_devices_t AudioPolicyManagerBase::getDeviceForStrategy(routing_strategy st
     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 @@ audio_devices_t AudioPolicyManagerBase::getDeviceForStrategy(routing_strategy st
     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 @@ audio_devices_t AudioPolicyManagerBase::getDeviceForStrategy(routing_strategy st
         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 @@ audio_devices_t AudioPolicyManagerBase::getDeviceForStrategy(routing_strategy st
             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 @@ audio_devices_t AudioPolicyManagerBase::getDeviceForStrategy(routing_strategy st
             }
             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 @@ audio_devices_t AudioPolicyManagerBase::getDeviceForStrategy(routing_strategy st
         //   - 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 @@ audio_devices_t AudioPolicyManagerBase::getDeviceForStrategy(routing_strategy st
             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 @@ audio_devices_t AudioPolicyManagerBase::getDeviceForStrategy(routing_strategy st
             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 AudioPolicyManagerBase::checkDeviceMuteStrategies(AudioOutputDescriptor
 
     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 @@ AudioPolicyManagerBase::IOProfile *AudioPolicyManagerBase::getInputProfile(audio
     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 @@ audio_devices_t AudioPolicyManagerBase::getDeviceForInputSource(int inputSource)
     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 @@ audio_devices_t AudioPolicyManagerBase::getDeviceForVolume(audio_devices_t devic
         // 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 @@ audio_devices_t AudioPolicyManagerBase::getDeviceForVolume(audio_devices_t devic
         }
     }
 
-    ALOGW_IF(AudioSystem::popCount(device) != 1,
+    ALOGW_IF(popcount(device) != 1,
             "getDeviceForVolume() invalid device combination: %08x",
             device);
 
@@ -2989,7 +2995,7 @@ void AudioPolicyManagerBase::initializeVolumeCurves()
     }
 }
 
-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 @@ float AudioPolicyManagerBase::computeVolume(int stream,
     }
 
     // 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 @@ float AudioPolicyManagerBase::computeVolume(int stream,
     // - 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 @@ float AudioPolicyManagerBase::computeVolume(int stream,
     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 @@ status_t AudioPolicyManagerBase::checkAndSetVolume(int stream,
     }
 
     // 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 @@ status_t AudioPolicyManagerBase::checkAndSetVolume(int stream,
         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 @@ void AudioPolicyManagerBase::applyStreamVolumes(audio_io_handle_t output,
 {
     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 @@ void AudioPolicyManagerBase::setStrategyMute(routing_strategy strategy,
                                              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 @@ void AudioPolicyManagerBase::setStreamMute(int stream,
     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::setStreamMute(int stream,
     }
 }
 
-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 @@ void AudioPolicyManagerBase::handleIncallSonification(int stream, bool starting,
     // 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 @@ void AudioPolicyManagerBase::handleIncallSonification(int stream, bool starting,
             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 @@ void AudioPolicyManagerBase::handleIncallSonification(int stream, bool starting,
                     }
                 }
                 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::isInCall()
 }
 
 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 @@ AudioPolicyManagerBase::AudioOutputDescriptor::AudioOutputDescriptor(
     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 @@ bool AudioPolicyManagerBase::AudioOutputDescriptor::sharesHwModuleWith(
     }
 }
 
-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 @@ void AudioPolicyManagerBase::AudioOutputDescriptor::changeRefCount(AudioSystem::
         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 @@ bool AudioPolicyManagerBase::AudioOutputDescriptor::isStrategyActive(routing_str
     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 @@ status_t AudioPolicyManagerBase::AudioOutputDescriptor::dump(int fd)
     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 @@ status_t AudioPolicyManagerBase::AudioOutputDescriptor::dump(int fd)
 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 @@ public:
 
         // 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 @@ public:
         // 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 @@ public:
         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 @@ protected:
             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 @@ protected:
             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 @@ protected:
             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 @@ protected:
         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 @@ protected:
                              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 @@ protected:
 
         // 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 @@ protected:
                              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 @@ protected:
 
         // 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 @@ protected:
         // 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 @@ protected:
                                             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 @@ protected:
                                                 // 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 @@ private:
                 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);
 };