Home | History | Annotate | Download | only in managerdefault
      1 /*
      2  * Copyright (C) 2009 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #define LOG_TAG "APM_AudioPolicyManager"
     18 //#define LOG_NDEBUG 0
     19 
     20 //#define VERY_VERBOSE_LOGGING
     21 #ifdef VERY_VERBOSE_LOGGING
     22 #define ALOGVV ALOGV
     23 #else
     24 #define ALOGVV(a...) do { } while(0)
     25 #endif
     26 
     27 #define AUDIO_POLICY_XML_CONFIG_FILE_PATH_MAX_LENGTH 128
     28 #define AUDIO_POLICY_XML_CONFIG_FILE_NAME "audio_policy_configuration.xml"
     29 
     30 #include <inttypes.h>
     31 #include <math.h>
     32 
     33 #include <AudioPolicyManagerInterface.h>
     34 #include <AudioPolicyEngineInstance.h>
     35 #include <cutils/atomic.h>
     36 #include <cutils/properties.h>
     37 #include <utils/Log.h>
     38 #include <media/AudioParameter.h>
     39 #include <media/AudioPolicyHelper.h>
     40 #include <soundtrigger/SoundTrigger.h>
     41 #include <system/audio.h>
     42 #include <audio_policy_conf.h>
     43 #include "AudioPolicyManager.h"
     44 #ifndef USE_XML_AUDIO_POLICY_CONF
     45 #include <ConfigParsingUtils.h>
     46 #include <StreamDescriptor.h>
     47 #endif
     48 #include <Serializer.h>
     49 #include "TypeConverter.h"
     50 #include <policy.h>
     51 
     52 namespace android {
     53 
     54 //FIXME: workaround for truncated touch sounds
     55 // to be removed when the problem is handled by system UI
     56 #define TOUCH_SOUND_FIXED_DELAY_MS 100
     57 // ----------------------------------------------------------------------------
     58 // AudioPolicyInterface implementation
     59 // ----------------------------------------------------------------------------
     60 
     61 status_t AudioPolicyManager::setDeviceConnectionState(audio_devices_t device,
     62                                                       audio_policy_dev_state_t state,
     63                                                       const char *device_address,
     64                                                       const char *device_name)
     65 {
     66     return setDeviceConnectionStateInt(device, state, device_address, device_name);
     67 }
     68 
     69 void AudioPolicyManager::broadcastDeviceConnectionState(audio_devices_t device,
     70                                                         audio_policy_dev_state_t state,
     71                                                         const String8 &device_address)
     72 {
     73     AudioParameter param(device_address);
     74     const String8 key(state == AUDIO_POLICY_DEVICE_STATE_AVAILABLE ?
     75                 AudioParameter::keyStreamConnect : AudioParameter::keyStreamDisconnect);
     76     param.addInt(key, device);
     77     mpClientInterface->setParameters(AUDIO_IO_HANDLE_NONE, param.toString());
     78 }
     79 
     80 status_t AudioPolicyManager::setDeviceConnectionStateInt(audio_devices_t device,
     81                                                          audio_policy_dev_state_t state,
     82                                                          const char *device_address,
     83                                                          const char *device_name)
     84 {
     85     ALOGV("setDeviceConnectionStateInt() device: 0x%X, state %d, address %s name %s",
     86 -            device, state, device_address, device_name);
     87 
     88     // connect/disconnect only 1 device at a time
     89     if (!audio_is_output_device(device) && !audio_is_input_device(device)) return BAD_VALUE;
     90 
     91     sp<DeviceDescriptor> devDesc =
     92             mHwModules.getDeviceDescriptor(device, device_address, device_name);
     93 
     94     // handle output devices
     95     if (audio_is_output_device(device)) {
     96         SortedVector <audio_io_handle_t> outputs;
     97 
     98         ssize_t index = mAvailableOutputDevices.indexOf(devDesc);
     99 
    100         // save a copy of the opened output descriptors before any output is opened or closed
    101         // by checkOutputsForDevice(). This will be needed by checkOutputForAllStrategies()
    102         mPreviousOutputs = mOutputs;
    103         switch (state)
    104         {
    105         // handle output device connection
    106         case AUDIO_POLICY_DEVICE_STATE_AVAILABLE: {
    107             if (index >= 0) {
    108                 ALOGW("setDeviceConnectionState() device already connected: %x", device);
    109                 return INVALID_OPERATION;
    110             }
    111             ALOGV("setDeviceConnectionState() connecting device %x", device);
    112 
    113             // register new device as available
    114             index = mAvailableOutputDevices.add(devDesc);
    115             if (index >= 0) {
    116                 sp<HwModule> module = mHwModules.getModuleForDevice(device);
    117                 if (module == 0) {
    118                     ALOGD("setDeviceConnectionState() could not find HW module for device %08x",
    119                           device);
    120                     mAvailableOutputDevices.remove(devDesc);
    121                     return INVALID_OPERATION;
    122                 }
    123                 mAvailableOutputDevices[index]->attach(module);
    124             } else {
    125                 return NO_MEMORY;
    126             }
    127 
    128             // Before checking outputs, broadcast connect event to allow HAL to retrieve dynamic
    129             // parameters on newly connected devices (instead of opening the outputs...)
    130             broadcastDeviceConnectionState(device, state, devDesc->mAddress);
    131 
    132             if (checkOutputsForDevice(devDesc, state, outputs, devDesc->mAddress) != NO_ERROR) {
    133                 mAvailableOutputDevices.remove(devDesc);
    134 
    135                 broadcastDeviceConnectionState(device, AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
    136                                                devDesc->mAddress);
    137                 return INVALID_OPERATION;
    138             }
    139             // Propagate device availability to Engine
    140             mEngine->setDeviceConnectionState(devDesc, state);
    141 
    142             // outputs should never be empty here
    143             ALOG_ASSERT(outputs.size() != 0, "setDeviceConnectionState():"
    144                     "checkOutputsForDevice() returned no outputs but status OK");
    145             ALOGV("setDeviceConnectionState() checkOutputsForDevice() returned %zu outputs",
    146                   outputs.size());
    147 
    148             } break;
    149         // handle output device disconnection
    150         case AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE: {
    151             if (index < 0) {
    152                 ALOGW("setDeviceConnectionState() device not connected: %x", device);
    153                 return INVALID_OPERATION;
    154             }
    155 
    156             ALOGV("setDeviceConnectionState() disconnecting output device %x", device);
    157 
    158             // Send Disconnect to HALs
    159             broadcastDeviceConnectionState(device, state, devDesc->mAddress);
    160 
    161             // remove device from available output devices
    162             mAvailableOutputDevices.remove(devDesc);
    163 
    164             checkOutputsForDevice(devDesc, state, outputs, devDesc->mAddress);
    165 
    166             // Propagate device availability to Engine
    167             mEngine->setDeviceConnectionState(devDesc, state);
    168             } break;
    169 
    170         default:
    171             ALOGE("setDeviceConnectionState() invalid state: %x", state);
    172             return BAD_VALUE;
    173         }
    174 
    175         // checkA2dpSuspend must run before checkOutputForAllStrategies so that A2DP
    176         // output is suspended before any tracks are moved to it
    177         checkA2dpSuspend();
    178         checkOutputForAllStrategies();
    179         // outputs must be closed after checkOutputForAllStrategies() is executed
    180         if (!outputs.isEmpty()) {
    181             for (size_t i = 0; i < outputs.size(); i++) {
    182                 sp<SwAudioOutputDescriptor> desc = mOutputs.valueFor(outputs[i]);
    183                 // close unused outputs after device disconnection or direct outputs that have been
    184                 // opened by checkOutputsForDevice() to query dynamic parameters
    185                 if ((state == AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE) ||
    186                         (((desc->mFlags & AUDIO_OUTPUT_FLAG_DIRECT) != 0) &&
    187                          (desc->mDirectOpenCount == 0))) {
    188                     closeOutput(outputs[i]);
    189                 }
    190             }
    191             // check again after closing A2DP output to reset mA2dpSuspended if needed
    192             checkA2dpSuspend();
    193         }
    194 
    195         updateDevicesAndOutputs();
    196         if (mEngine->getPhoneState() == AUDIO_MODE_IN_CALL && hasPrimaryOutput()) {
    197             audio_devices_t newDevice = getNewOutputDevice(mPrimaryOutput, false /*fromCache*/);
    198             updateCallRouting(newDevice);
    199         }
    200         for (size_t i = 0; i < mOutputs.size(); i++) {
    201             sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
    202             if ((mEngine->getPhoneState() != AUDIO_MODE_IN_CALL) || (desc != mPrimaryOutput)) {
    203                 audio_devices_t newDevice = getNewOutputDevice(desc, true /*fromCache*/);
    204                 // do not force device change on duplicated output because if device is 0, it will
    205                 // also force a device 0 for the two outputs it is duplicated to which may override
    206                 // a valid device selection on those outputs.
    207                 bool force = !desc->isDuplicated()
    208                         && (!device_distinguishes_on_address(device)
    209                                 // always force when disconnecting (a non-duplicated device)
    210                                 || (state == AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE));
    211                 setOutputDevice(desc, newDevice, force, 0);
    212             }
    213         }
    214 
    215         if (state == AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE) {
    216             cleanUpForDevice(devDesc);
    217         }
    218 
    219         mpClientInterface->onAudioPortListUpdate();
    220         return NO_ERROR;
    221     }  // end if is output device
    222 
    223     // handle input devices
    224     if (audio_is_input_device(device)) {
    225         SortedVector <audio_io_handle_t> inputs;
    226 
    227         ssize_t index = mAvailableInputDevices.indexOf(devDesc);
    228         switch (state)
    229         {
    230         // handle input device connection
    231         case AUDIO_POLICY_DEVICE_STATE_AVAILABLE: {
    232             if (index >= 0) {
    233                 ALOGW("setDeviceConnectionState() device already connected: %d", device);
    234                 return INVALID_OPERATION;
    235             }
    236             sp<HwModule> module = mHwModules.getModuleForDevice(device);
    237             if (module == NULL) {
    238                 ALOGW("setDeviceConnectionState(): could not find HW module for device %08x",
    239                       device);
    240                 return INVALID_OPERATION;
    241             }
    242 
    243             // Before checking intputs, broadcast connect event to allow HAL to retrieve dynamic
    244             // parameters on newly connected devices (instead of opening the inputs...)
    245             broadcastDeviceConnectionState(device, state, devDesc->mAddress);
    246 
    247             if (checkInputsForDevice(devDesc, state, inputs, devDesc->mAddress) != NO_ERROR) {
    248                 broadcastDeviceConnectionState(device, AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
    249                                                devDesc->mAddress);
    250                 return INVALID_OPERATION;
    251             }
    252 
    253             index = mAvailableInputDevices.add(devDesc);
    254             if (index >= 0) {
    255                 mAvailableInputDevices[index]->attach(module);
    256             } else {
    257                 return NO_MEMORY;
    258             }
    259 
    260             // Propagate device availability to Engine
    261             mEngine->setDeviceConnectionState(devDesc, state);
    262         } break;
    263 
    264         // handle input device disconnection
    265         case AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE: {
    266             if (index < 0) {
    267                 ALOGW("setDeviceConnectionState() device not connected: %d", device);
    268                 return INVALID_OPERATION;
    269             }
    270 
    271             ALOGV("setDeviceConnectionState() disconnecting input device %x", device);
    272 
    273             // Set Disconnect to HALs
    274             broadcastDeviceConnectionState(device, state, devDesc->mAddress);
    275 
    276             checkInputsForDevice(devDesc, state, inputs, devDesc->mAddress);
    277             mAvailableInputDevices.remove(devDesc);
    278 
    279             // Propagate device availability to Engine
    280             mEngine->setDeviceConnectionState(devDesc, state);
    281         } break;
    282 
    283         default:
    284             ALOGE("setDeviceConnectionState() invalid state: %x", state);
    285             return BAD_VALUE;
    286         }
    287 
    288         closeAllInputs();
    289         // As the input device list can impact the output device selection, update
    290         // getDeviceForStrategy() cache
    291         updateDevicesAndOutputs();
    292 
    293         if (mEngine->getPhoneState() == AUDIO_MODE_IN_CALL && hasPrimaryOutput()) {
    294             audio_devices_t newDevice = getNewOutputDevice(mPrimaryOutput, false /*fromCache*/);
    295             updateCallRouting(newDevice);
    296         }
    297 
    298         if (state == AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE) {
    299             cleanUpForDevice(devDesc);
    300         }
    301 
    302         mpClientInterface->onAudioPortListUpdate();
    303         return NO_ERROR;
    304     } // end if is input device
    305 
    306     ALOGW("setDeviceConnectionState() invalid device: %x", device);
    307     return BAD_VALUE;
    308 }
    309 
    310 audio_policy_dev_state_t AudioPolicyManager::getDeviceConnectionState(audio_devices_t device,
    311                                                                       const char *device_address)
    312 {
    313     sp<DeviceDescriptor> devDesc =
    314             mHwModules.getDeviceDescriptor(device, device_address, "",
    315                                            (strlen(device_address) != 0)/*matchAddress*/);
    316 
    317     if (devDesc == 0) {
    318         ALOGW("getDeviceConnectionState() undeclared device, type %08x, address: %s",
    319               device, device_address);
    320         return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE;
    321     }
    322 
    323     DeviceVector *deviceVector;
    324 
    325     if (audio_is_output_device(device)) {
    326         deviceVector = &mAvailableOutputDevices;
    327     } else if (audio_is_input_device(device)) {
    328         deviceVector = &mAvailableInputDevices;
    329     } else {
    330         ALOGW("getDeviceConnectionState() invalid device type %08x", device);
    331         return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE;
    332     }
    333 
    334     return (deviceVector->getDevice(device, String8(device_address)) != 0) ?
    335             AUDIO_POLICY_DEVICE_STATE_AVAILABLE : AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE;
    336 }
    337 
    338 status_t AudioPolicyManager::handleDeviceConfigChange(audio_devices_t device,
    339                                                       const char *device_address,
    340                                                       const char *device_name)
    341 {
    342     status_t status;
    343 
    344     ALOGV("handleDeviceConfigChange(() device: 0x%X, address %s name %s",
    345           device, device_address, device_name);
    346 
    347     // connect/disconnect only 1 device at a time
    348     if (!audio_is_output_device(device) && !audio_is_input_device(device)) return BAD_VALUE;
    349 
    350     // Check if the device is currently connected
    351     sp<DeviceDescriptor> devDesc =
    352             mHwModules.getDeviceDescriptor(device, device_address, device_name);
    353     ssize_t index = mAvailableOutputDevices.indexOf(devDesc);
    354     if (index < 0) {
    355         // Nothing to do: device is not connected
    356         return NO_ERROR;
    357     }
    358 
    359     // Toggle the device state: UNAVAILABLE -> AVAILABLE
    360     // This will force reading again the device configuration
    361     status = setDeviceConnectionState(device,
    362                                       AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
    363                                       device_address, device_name);
    364     if (status != NO_ERROR) {
    365         ALOGW("handleDeviceConfigChange() error disabling connection state: %d",
    366               status);
    367         return status;
    368     }
    369 
    370     status = setDeviceConnectionState(device,
    371                                       AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
    372                                       device_address, device_name);
    373     if (status != NO_ERROR) {
    374         ALOGW("handleDeviceConfigChange() error enabling connection state: %d",
    375               status);
    376         return status;
    377     }
    378 
    379     return NO_ERROR;
    380 }
    381 
    382 uint32_t AudioPolicyManager::updateCallRouting(audio_devices_t rxDevice, uint32_t delayMs)
    383 {
    384     bool createTxPatch = false;
    385     status_t status;
    386     audio_patch_handle_t afPatchHandle;
    387     DeviceVector deviceList;
    388     uint32_t muteWaitMs = 0;
    389 
    390     if(!hasPrimaryOutput() || mPrimaryOutput->device() == AUDIO_DEVICE_OUT_STUB) {
    391         return muteWaitMs;
    392     }
    393     audio_devices_t txDevice = getDeviceAndMixForInputSource(AUDIO_SOURCE_VOICE_COMMUNICATION);
    394     ALOGV("updateCallRouting device rxDevice %08x txDevice %08x", rxDevice, txDevice);
    395 
    396     // release existing RX patch if any
    397     if (mCallRxPatch != 0) {
    398         mpClientInterface->releaseAudioPatch(mCallRxPatch->mAfPatchHandle, 0);
    399         mCallRxPatch.clear();
    400     }
    401     // release TX patch if any
    402     if (mCallTxPatch != 0) {
    403         mpClientInterface->releaseAudioPatch(mCallTxPatch->mAfPatchHandle, 0);
    404         mCallTxPatch.clear();
    405     }
    406 
    407     // If the RX device is on the primary HW module, then use legacy routing method for voice calls
    408     // via setOutputDevice() on primary output.
    409     // Otherwise, create two audio patches for TX and RX path.
    410     if (availablePrimaryOutputDevices() & rxDevice) {
    411         muteWaitMs = setOutputDevice(mPrimaryOutput, rxDevice, true, delayMs);
    412         // If the TX device is also on the primary HW module, setOutputDevice() will take care
    413         // of it due to legacy implementation. If not, create a patch.
    414         if ((availablePrimaryInputDevices() & txDevice & ~AUDIO_DEVICE_BIT_IN)
    415                 == AUDIO_DEVICE_NONE) {
    416             createTxPatch = true;
    417         }
    418     } else { // create RX path audio patch
    419         struct audio_patch patch;
    420 
    421         patch.num_sources = 1;
    422         patch.num_sinks = 1;
    423         deviceList = mAvailableOutputDevices.getDevicesFromType(rxDevice);
    424         ALOG_ASSERT(!deviceList.isEmpty(),
    425                     "updateCallRouting() selected device not in output device list");
    426         sp<DeviceDescriptor> rxSinkDeviceDesc = deviceList.itemAt(0);
    427         deviceList = mAvailableInputDevices.getDevicesFromType(AUDIO_DEVICE_IN_TELEPHONY_RX);
    428         ALOG_ASSERT(!deviceList.isEmpty(),
    429                     "updateCallRouting() no telephony RX device");
    430         sp<DeviceDescriptor> rxSourceDeviceDesc = deviceList.itemAt(0);
    431 
    432         rxSourceDeviceDesc->toAudioPortConfig(&patch.sources[0]);
    433         rxSinkDeviceDesc->toAudioPortConfig(&patch.sinks[0]);
    434 
    435         // request to reuse existing output stream if one is already opened to reach the RX device
    436         SortedVector<audio_io_handle_t> outputs =
    437                                 getOutputsForDevice(rxDevice, mOutputs);
    438         audio_io_handle_t output = selectOutput(outputs,
    439                                                 AUDIO_OUTPUT_FLAG_NONE,
    440                                                 AUDIO_FORMAT_INVALID);
    441         if (output != AUDIO_IO_HANDLE_NONE) {
    442             sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueFor(output);
    443             ALOG_ASSERT(!outputDesc->isDuplicated(),
    444                         "updateCallRouting() RX device output is duplicated");
    445             outputDesc->toAudioPortConfig(&patch.sources[1]);
    446             patch.sources[1].ext.mix.usecase.stream = AUDIO_STREAM_PATCH;
    447             patch.num_sources = 2;
    448         }
    449 
    450         afPatchHandle = AUDIO_PATCH_HANDLE_NONE;
    451         status = mpClientInterface->createAudioPatch(&patch, &afPatchHandle, delayMs);
    452         ALOGW_IF(status != NO_ERROR, "updateCallRouting() error %d creating RX audio patch",
    453                                                status);
    454         if (status == NO_ERROR) {
    455             mCallRxPatch = new AudioPatch(&patch, mUidCached);
    456             mCallRxPatch->mAfPatchHandle = afPatchHandle;
    457             mCallRxPatch->mUid = mUidCached;
    458         }
    459         createTxPatch = true;
    460     }
    461     if (createTxPatch) { // create TX path audio patch
    462         struct audio_patch patch;
    463 
    464         patch.num_sources = 1;
    465         patch.num_sinks = 1;
    466         deviceList = mAvailableInputDevices.getDevicesFromType(txDevice);
    467         ALOG_ASSERT(!deviceList.isEmpty(),
    468                     "updateCallRouting() selected device not in input device list");
    469         sp<DeviceDescriptor> txSourceDeviceDesc = deviceList.itemAt(0);
    470         txSourceDeviceDesc->toAudioPortConfig(&patch.sources[0]);
    471         deviceList = mAvailableOutputDevices.getDevicesFromType(AUDIO_DEVICE_OUT_TELEPHONY_TX);
    472         ALOG_ASSERT(!deviceList.isEmpty(),
    473                     "updateCallRouting() no telephony TX device");
    474         sp<DeviceDescriptor> txSinkDeviceDesc = deviceList.itemAt(0);
    475         txSinkDeviceDesc->toAudioPortConfig(&patch.sinks[0]);
    476 
    477         SortedVector<audio_io_handle_t> outputs =
    478                                 getOutputsForDevice(AUDIO_DEVICE_OUT_TELEPHONY_TX, mOutputs);
    479         audio_io_handle_t output = selectOutput(outputs,
    480                                                 AUDIO_OUTPUT_FLAG_NONE,
    481                                                 AUDIO_FORMAT_INVALID);
    482         // request to reuse existing output stream if one is already opened to reach the TX
    483         // path output device
    484         if (output != AUDIO_IO_HANDLE_NONE) {
    485             sp<AudioOutputDescriptor> outputDesc = mOutputs.valueFor(output);
    486             ALOG_ASSERT(!outputDesc->isDuplicated(),
    487                         "updateCallRouting() RX device output is duplicated");
    488             outputDesc->toAudioPortConfig(&patch.sources[1]);
    489             patch.sources[1].ext.mix.usecase.stream = AUDIO_STREAM_PATCH;
    490             patch.num_sources = 2;
    491         }
    492 
    493         // terminate active capture if on the same HW module as the call TX source device
    494         // FIXME: would be better to refine to only inputs whose profile connects to the
    495         // call TX device but this information is not in the audio patch and logic here must be
    496         // symmetric to the one in startInput()
    497         Vector<sp <AudioInputDescriptor> > activeInputs = mInputs.getActiveInputs();
    498         for (size_t i = 0; i < activeInputs.size(); i++) {
    499             sp<AudioInputDescriptor> activeDesc = activeInputs[i];
    500             if (activeDesc->hasSameHwModuleAs(txSourceDeviceDesc)) {
    501                 AudioSessionCollection activeSessions =
    502                         activeDesc->getAudioSessions(true /*activeOnly*/);
    503                 for (size_t j = 0; j < activeSessions.size(); j++) {
    504                     audio_session_t activeSession = activeSessions.keyAt(j);
    505                     stopInput(activeDesc->mIoHandle, activeSession);
    506                     releaseInput(activeDesc->mIoHandle, activeSession);
    507                 }
    508             }
    509         }
    510 
    511         afPatchHandle = AUDIO_PATCH_HANDLE_NONE;
    512         status = mpClientInterface->createAudioPatch(&patch, &afPatchHandle, delayMs);
    513         ALOGW_IF(status != NO_ERROR, "setPhoneState() error %d creating TX audio patch",
    514                                                status);
    515         if (status == NO_ERROR) {
    516             mCallTxPatch = new AudioPatch(&patch, mUidCached);
    517             mCallTxPatch->mAfPatchHandle = afPatchHandle;
    518             mCallTxPatch->mUid = mUidCached;
    519         }
    520     }
    521 
    522     return muteWaitMs;
    523 }
    524 
    525 void AudioPolicyManager::setPhoneState(audio_mode_t state)
    526 {
    527     ALOGV("setPhoneState() state %d", state);
    528     // store previous phone state for management of sonification strategy below
    529     int oldState = mEngine->getPhoneState();
    530 
    531     if (mEngine->setPhoneState(state) != NO_ERROR) {
    532         ALOGW("setPhoneState() invalid or same state %d", state);
    533         return;
    534     }
    535     /// Opens: can these line be executed after the switch of volume curves???
    536     // if leaving call state, handle special case of active streams
    537     // pertaining to sonification strategy see handleIncallSonification()
    538     if (isStateInCall(oldState)) {
    539         ALOGV("setPhoneState() in call state management: new state is %d", state);
    540         for (int stream = 0; stream < AUDIO_STREAM_FOR_POLICY_CNT; stream++) {
    541             handleIncallSonification((audio_stream_type_t)stream, false, true);
    542         }
    543 
    544         // force reevaluating accessibility routing when call stops
    545         mpClientInterface->invalidateStream(AUDIO_STREAM_ACCESSIBILITY);
    546     }
    547 
    548     /**
    549      * Switching to or from incall state or switching between telephony and VoIP lead to force
    550      * routing command.
    551      */
    552     bool force = ((is_state_in_call(oldState) != is_state_in_call(state))
    553                   || (is_state_in_call(state) && (state != oldState)));
    554 
    555     // check for device and output changes triggered by new phone state
    556     checkA2dpSuspend();
    557     checkOutputForAllStrategies();
    558     updateDevicesAndOutputs();
    559 
    560     int delayMs = 0;
    561     if (isStateInCall(state)) {
    562         nsecs_t sysTime = systemTime();
    563         for (size_t i = 0; i < mOutputs.size(); i++) {
    564             sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
    565             // mute media and sonification strategies and delay device switch by the largest
    566             // latency of any output where either strategy is active.
    567             // This avoid sending the ring tone or music tail into the earpiece or headset.
    568             if ((isStrategyActive(desc, STRATEGY_MEDIA,
    569                                   SONIFICATION_HEADSET_MUSIC_DELAY,
    570                                   sysTime) ||
    571                  isStrategyActive(desc, STRATEGY_SONIFICATION,
    572                                   SONIFICATION_HEADSET_MUSIC_DELAY,
    573                                   sysTime)) &&
    574                     (delayMs < (int)desc->latency()*2)) {
    575                 delayMs = desc->latency()*2;
    576             }
    577             setStrategyMute(STRATEGY_MEDIA, true, desc);
    578             setStrategyMute(STRATEGY_MEDIA, false, desc, MUTE_TIME_MS,
    579                 getDeviceForStrategy(STRATEGY_MEDIA, true /*fromCache*/));
    580             setStrategyMute(STRATEGY_SONIFICATION, true, desc);
    581             setStrategyMute(STRATEGY_SONIFICATION, false, desc, MUTE_TIME_MS,
    582                 getDeviceForStrategy(STRATEGY_SONIFICATION, true /*fromCache*/));
    583         }
    584     }
    585 
    586     if (hasPrimaryOutput()) {
    587         // Note that despite the fact that getNewOutputDevice() is called on the primary output,
    588         // the device returned is not necessarily reachable via this output
    589         audio_devices_t rxDevice = getNewOutputDevice(mPrimaryOutput, false /*fromCache*/);
    590         // force routing command to audio hardware when ending call
    591         // even if no device change is needed
    592         if (isStateInCall(oldState) && rxDevice == AUDIO_DEVICE_NONE) {
    593             rxDevice = mPrimaryOutput->device();
    594         }
    595 
    596         if (state == AUDIO_MODE_IN_CALL) {
    597             updateCallRouting(rxDevice, delayMs);
    598         } else if (oldState == AUDIO_MODE_IN_CALL) {
    599             if (mCallRxPatch != 0) {
    600                 mpClientInterface->releaseAudioPatch(mCallRxPatch->mAfPatchHandle, 0);
    601                 mCallRxPatch.clear();
    602             }
    603             if (mCallTxPatch != 0) {
    604                 mpClientInterface->releaseAudioPatch(mCallTxPatch->mAfPatchHandle, 0);
    605                 mCallTxPatch.clear();
    606             }
    607             setOutputDevice(mPrimaryOutput, rxDevice, force, 0);
    608         } else {
    609             setOutputDevice(mPrimaryOutput, rxDevice, force, 0);
    610         }
    611     }
    612     // if entering in call state, handle special case of active streams
    613     // pertaining to sonification strategy see handleIncallSonification()
    614     if (isStateInCall(state)) {
    615         ALOGV("setPhoneState() in call state management: new state is %d", state);
    616         for (int stream = 0; stream < AUDIO_STREAM_FOR_POLICY_CNT; stream++) {
    617             handleIncallSonification((audio_stream_type_t)stream, true, true);
    618         }
    619 
    620         // force reevaluating accessibility routing when call starts
    621         mpClientInterface->invalidateStream(AUDIO_STREAM_ACCESSIBILITY);
    622     }
    623 
    624     // Flag that ringtone volume must be limited to music volume until we exit MODE_RINGTONE
    625     if (state == AUDIO_MODE_RINGTONE &&
    626         isStreamActive(AUDIO_STREAM_MUSIC, SONIFICATION_HEADSET_MUSIC_DELAY)) {
    627         mLimitRingtoneVolume = true;
    628     } else {
    629         mLimitRingtoneVolume = false;
    630     }
    631 }
    632 
    633 audio_mode_t AudioPolicyManager::getPhoneState() {
    634     return mEngine->getPhoneState();
    635 }
    636 
    637 void AudioPolicyManager::setForceUse(audio_policy_force_use_t usage,
    638                                          audio_policy_forced_cfg_t config)
    639 {
    640     ALOGV("setForceUse() usage %d, config %d, mPhoneState %d", usage, config, mEngine->getPhoneState());
    641     if (config == mEngine->getForceUse(usage)) {
    642         return;
    643     }
    644 
    645     if (mEngine->setForceUse(usage, config) != NO_ERROR) {
    646         ALOGW("setForceUse() could not set force cfg %d for usage %d", config, usage);
    647         return;
    648     }
    649     bool forceVolumeReeval = (usage == AUDIO_POLICY_FORCE_FOR_COMMUNICATION) ||
    650             (usage == AUDIO_POLICY_FORCE_FOR_DOCK) ||
    651             (usage == AUDIO_POLICY_FORCE_FOR_SYSTEM);
    652 
    653     // check for device and output changes triggered by new force usage
    654     checkA2dpSuspend();
    655     checkOutputForAllStrategies();
    656     updateDevicesAndOutputs();
    657 
    658     //FIXME: workaround for truncated touch sounds
    659     // to be removed when the problem is handled by system UI
    660     uint32_t delayMs = 0;
    661     uint32_t waitMs = 0;
    662     if (usage == AUDIO_POLICY_FORCE_FOR_COMMUNICATION) {
    663         delayMs = TOUCH_SOUND_FIXED_DELAY_MS;
    664     }
    665     if (mEngine->getPhoneState() == AUDIO_MODE_IN_CALL && hasPrimaryOutput()) {
    666         audio_devices_t newDevice = getNewOutputDevice(mPrimaryOutput, true /*fromCache*/);
    667         waitMs = updateCallRouting(newDevice, delayMs);
    668     }
    669     for (size_t i = 0; i < mOutputs.size(); i++) {
    670         sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueAt(i);
    671         audio_devices_t newDevice = getNewOutputDevice(outputDesc, true /*fromCache*/);
    672         if ((mEngine->getPhoneState() != AUDIO_MODE_IN_CALL) || (outputDesc != mPrimaryOutput)) {
    673             waitMs = setOutputDevice(outputDesc, newDevice, (newDevice != AUDIO_DEVICE_NONE),
    674                                      delayMs);
    675         }
    676         if (forceVolumeReeval && (newDevice != AUDIO_DEVICE_NONE)) {
    677             applyStreamVolumes(outputDesc, newDevice, waitMs, true);
    678         }
    679     }
    680 
    681     Vector<sp <AudioInputDescriptor> > activeInputs = mInputs.getActiveInputs();
    682     for (size_t i = 0; i < activeInputs.size(); i++) {
    683         sp<AudioInputDescriptor> activeDesc = activeInputs[i];
    684         audio_devices_t newDevice = getNewInputDevice(activeDesc);
    685         // Force new input selection if the new device can not be reached via current input
    686         if (activeDesc->mProfile->getSupportedDevices().types() &
    687                 (newDevice & ~AUDIO_DEVICE_BIT_IN)) {
    688             setInputDevice(activeDesc->mIoHandle, newDevice);
    689         } else {
    690             closeInput(activeDesc->mIoHandle);
    691         }
    692     }
    693 }
    694 
    695 void AudioPolicyManager::setSystemProperty(const char* property, const char* value)
    696 {
    697     ALOGV("setSystemProperty() property %s, value %s", property, value);
    698 }
    699 
    700 // Find a direct output profile compatible with the parameters passed, even if the input flags do
    701 // not explicitly request a direct output
    702 sp<IOProfile> AudioPolicyManager::getProfileForDirectOutput(
    703                                                                audio_devices_t device,
    704                                                                uint32_t samplingRate,
    705                                                                audio_format_t format,
    706                                                                audio_channel_mask_t channelMask,
    707                                                                audio_output_flags_t flags)
    708 {
    709     // only retain flags that will drive the direct output profile selection
    710     // if explicitly requested
    711     static const uint32_t kRelevantFlags =
    712             (AUDIO_OUTPUT_FLAG_HW_AV_SYNC | AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD);
    713     flags =
    714         (audio_output_flags_t)((flags & kRelevantFlags) | AUDIO_OUTPUT_FLAG_DIRECT);
    715 
    716     sp<IOProfile> profile;
    717 
    718     for (size_t i = 0; i < mHwModules.size(); i++) {
    719         if (mHwModules[i]->mHandle == 0) {
    720             continue;
    721         }
    722         for (size_t j = 0; j < mHwModules[i]->mOutputProfiles.size(); j++) {
    723             sp<IOProfile> curProfile = mHwModules[i]->mOutputProfiles[j];
    724             if (!curProfile->isCompatibleProfile(device, String8(""),
    725                     samplingRate, NULL /*updatedSamplingRate*/,
    726                     format, NULL /*updatedFormat*/,
    727                     channelMask, NULL /*updatedChannelMask*/,
    728                     flags)) {
    729                 continue;
    730             }
    731             // reject profiles not corresponding to a device currently available
    732             if ((mAvailableOutputDevices.types() & curProfile->getSupportedDevicesType()) == 0) {
    733                 continue;
    734             }
    735             // if several profiles are compatible, give priority to one with offload capability
    736             if (profile != 0 && ((curProfile->getFlags() & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) == 0)) {
    737                 continue;
    738             }
    739             profile = curProfile;
    740             if ((profile->getFlags() & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0) {
    741                 break;
    742             }
    743         }
    744     }
    745     return profile;
    746 }
    747 
    748 audio_io_handle_t AudioPolicyManager::getOutput(audio_stream_type_t stream,
    749                                                 uint32_t samplingRate,
    750                                                 audio_format_t format,
    751                                                 audio_channel_mask_t channelMask,
    752                                                 audio_output_flags_t flags,
    753                                                 const audio_offload_info_t *offloadInfo)
    754 {
    755     routing_strategy strategy = getStrategy(stream);
    756     audio_devices_t device = getDeviceForStrategy(strategy, false /*fromCache*/);
    757     ALOGV("getOutput() device %d, stream %d, samplingRate %d, format %x, channelMask %x, flags %x",
    758           device, stream, samplingRate, format, channelMask, flags);
    759 
    760     return getOutputForDevice(device, AUDIO_SESSION_ALLOCATE, stream, samplingRate, format,
    761                               channelMask, flags, offloadInfo);
    762 }
    763 
    764 status_t AudioPolicyManager::getOutputForAttr(const audio_attributes_t *attr,
    765                                               audio_io_handle_t *output,
    766                                               audio_session_t session,
    767                                               audio_stream_type_t *stream,
    768                                               uid_t uid,
    769                                               const audio_config_t *config,
    770                                               audio_output_flags_t flags,
    771                                               audio_port_handle_t selectedDeviceId,
    772                                               audio_port_handle_t *portId)
    773 {
    774     audio_attributes_t attributes;
    775     if (attr != NULL) {
    776         if (!isValidAttributes(attr)) {
    777             ALOGE("getOutputForAttr() invalid attributes: usage=%d content=%d flags=0x%x tags=[%s]",
    778                   attr->usage, attr->content_type, attr->flags,
    779                   attr->tags);
    780             return BAD_VALUE;
    781         }
    782         attributes = *attr;
    783     } else {
    784         if (*stream < AUDIO_STREAM_MIN || *stream >= AUDIO_STREAM_PUBLIC_CNT) {
    785             ALOGE("getOutputForAttr():  invalid stream type");
    786             return BAD_VALUE;
    787         }
    788         stream_type_to_audio_attributes(*stream, &attributes);
    789     }
    790 
    791     // TODO: check for existing client for this port ID
    792     if (*portId == AUDIO_PORT_HANDLE_NONE) {
    793         *portId = AudioPort::getNextUniqueId();
    794     }
    795 
    796     sp<SwAudioOutputDescriptor> desc;
    797     if (mPolicyMixes.getOutputForAttr(attributes, uid, desc) == NO_ERROR) {
    798         ALOG_ASSERT(desc != 0, "Invalid desc returned by getOutputForAttr");
    799         if (!audio_has_proportional_frames(config->format)) {
    800             return BAD_VALUE;
    801         }
    802         *stream = streamTypefromAttributesInt(&attributes);
    803         *output = desc->mIoHandle;
    804         ALOGV("getOutputForAttr() returns output %d", *output);
    805         return NO_ERROR;
    806     }
    807     if (attributes.usage == AUDIO_USAGE_VIRTUAL_SOURCE) {
    808         ALOGW("getOutputForAttr() no policy mix found for usage AUDIO_USAGE_VIRTUAL_SOURCE");
    809         return BAD_VALUE;
    810     }
    811 
    812     ALOGV("getOutputForAttr() usage=%d, content=%d, tag=%s flags=%08x"
    813             " session %d selectedDeviceId %d",
    814             attributes.usage, attributes.content_type, attributes.tags, attributes.flags,
    815             session, selectedDeviceId);
    816 
    817     *stream = streamTypefromAttributesInt(&attributes);
    818 
    819     // Explicit routing?
    820     sp<DeviceDescriptor> deviceDesc;
    821     for (size_t i = 0; i < mAvailableOutputDevices.size(); i++) {
    822         if (mAvailableOutputDevices[i]->getId() == selectedDeviceId) {
    823             deviceDesc = mAvailableOutputDevices[i];
    824             break;
    825         }
    826     }
    827     mOutputRoutes.addRoute(session, *stream, SessionRoute::SOURCE_TYPE_NA, deviceDesc, uid);
    828 
    829     routing_strategy strategy = (routing_strategy) getStrategyForAttr(&attributes);
    830     audio_devices_t device = getDeviceForStrategy(strategy, false /*fromCache*/);
    831 
    832     if ((attributes.flags & AUDIO_FLAG_HW_AV_SYNC) != 0) {
    833         flags = (audio_output_flags_t)(flags | AUDIO_OUTPUT_FLAG_HW_AV_SYNC);
    834     }
    835 
    836     ALOGV("getOutputForAttr() device 0x%x, samplingRate %d, format %x, channelMask %x, flags %x",
    837           device, config->sample_rate, config->format, config->channel_mask, flags);
    838 
    839     *output = getOutputForDevice(device, session, *stream,
    840                                  config->sample_rate, config->format, config->channel_mask,
    841                                  flags, &config->offload_info);
    842     if (*output == AUDIO_IO_HANDLE_NONE) {
    843         mOutputRoutes.removeRoute(session);
    844         return INVALID_OPERATION;
    845     }
    846 
    847     return NO_ERROR;
    848 }
    849 
    850 audio_io_handle_t AudioPolicyManager::getOutputForDevice(
    851         audio_devices_t device,
    852         audio_session_t session,
    853         audio_stream_type_t stream,
    854         uint32_t samplingRate,
    855         audio_format_t format,
    856         audio_channel_mask_t channelMask,
    857         audio_output_flags_t flags,
    858         const audio_offload_info_t *offloadInfo)
    859 {
    860     audio_io_handle_t output = AUDIO_IO_HANDLE_NONE;
    861     status_t status;
    862 
    863 #ifdef AUDIO_POLICY_TEST
    864     if (mCurOutput != 0) {
    865         ALOGV("getOutput() test output mCurOutput %d, samplingRate %d, format %d, channelMask %x, mDirectOutput %d",
    866                 mCurOutput, mTestSamplingRate, mTestFormat, mTestChannels, mDirectOutput);
    867 
    868         if (mTestOutputs[mCurOutput] == 0) {
    869             ALOGV("getOutput() opening test output");
    870             sp<AudioOutputDescriptor> outputDesc = new SwAudioOutputDescriptor(NULL,
    871                                                                                mpClientInterface);
    872             outputDesc->mDevice = mTestDevice;
    873             outputDesc->mLatency = mTestLatencyMs;
    874             outputDesc->mFlags =
    875                     (audio_output_flags_t)(mDirectOutput ? AUDIO_OUTPUT_FLAG_DIRECT : 0);
    876             outputDesc->mRefCount[stream] = 0;
    877             audio_config_t config = AUDIO_CONFIG_INITIALIZER;
    878             config.sample_rate = mTestSamplingRate;
    879             config.channel_mask = mTestChannels;
    880             config.format = mTestFormat;
    881             if (offloadInfo != NULL) {
    882                 config.offload_info = *offloadInfo;
    883             }
    884             status = mpClientInterface->openOutput(0,
    885                                                   &mTestOutputs[mCurOutput],
    886                                                   &config,
    887                                                   &outputDesc->mDevice,
    888                                                   String8(""),
    889                                                   &outputDesc->mLatency,
    890                                                   outputDesc->mFlags);
    891             if (status == NO_ERROR) {
    892                 outputDesc->mSamplingRate = config.sample_rate;
    893                 outputDesc->mFormat = config.format;
    894                 outputDesc->mChannelMask = config.channel_mask;
    895                 AudioParameter outputCmd = AudioParameter();
    896                 outputCmd.addInt(String8("set_id"),mCurOutput);
    897                 mpClientInterface->setParameters(mTestOutputs[mCurOutput],outputCmd.toString());
    898                 addOutput(mTestOutputs[mCurOutput], outputDesc);
    899             }
    900         }
    901         return mTestOutputs[mCurOutput];
    902     }
    903 #endif //AUDIO_POLICY_TEST
    904 
    905     // open a direct output if required by specified parameters
    906     //force direct flag if offload flag is set: offloading implies a direct output stream
    907     // and all common behaviors are driven by checking only the direct flag
    908     // this should normally be set appropriately in the policy configuration file
    909     if ((flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0) {
    910         flags = (audio_output_flags_t)(flags | AUDIO_OUTPUT_FLAG_DIRECT);
    911     }
    912     if ((flags & AUDIO_OUTPUT_FLAG_HW_AV_SYNC) != 0) {
    913         flags = (audio_output_flags_t)(flags | AUDIO_OUTPUT_FLAG_DIRECT);
    914     }
    915     // only allow deep buffering for music stream type
    916     if (stream != AUDIO_STREAM_MUSIC) {
    917         flags = (audio_output_flags_t)(flags &~AUDIO_OUTPUT_FLAG_DEEP_BUFFER);
    918     } else if (/* stream == AUDIO_STREAM_MUSIC && */
    919             flags == AUDIO_OUTPUT_FLAG_NONE &&
    920             property_get_bool("audio.deep_buffer.media", false /* default_value */)) {
    921         // use DEEP_BUFFER as default output for music stream type
    922         flags = (audio_output_flags_t)AUDIO_OUTPUT_FLAG_DEEP_BUFFER;
    923     }
    924     if (stream == AUDIO_STREAM_TTS) {
    925         flags = AUDIO_OUTPUT_FLAG_TTS;
    926     }
    927 
    928     sp<IOProfile> profile;
    929 
    930     // skip direct output selection if the request can obviously be attached to a mixed output
    931     // and not explicitly requested
    932     if (((flags & AUDIO_OUTPUT_FLAG_DIRECT) == 0) &&
    933             audio_is_linear_pcm(format) && samplingRate <= SAMPLE_RATE_HZ_MAX &&
    934             audio_channel_count_from_out_mask(channelMask) <= 2) {
    935         goto non_direct_output;
    936     }
    937 
    938     // Do not allow offloading if one non offloadable effect is enabled or MasterMono is enabled.
    939     // This prevents creating an offloaded track and tearing it down immediately after start
    940     // when audioflinger detects there is an active non offloadable effect.
    941     // FIXME: We should check the audio session here but we do not have it in this context.
    942     // This may prevent offloading in rare situations where effects are left active by apps
    943     // in the background.
    944 
    945     if (((flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) == 0) ||
    946             !(mEffects.isNonOffloadableEffectEnabled() || mMasterMono)) {
    947         profile = getProfileForDirectOutput(device,
    948                                            samplingRate,
    949                                            format,
    950                                            channelMask,
    951                                            (audio_output_flags_t)flags);
    952     }
    953 
    954     if (profile != 0) {
    955         sp<SwAudioOutputDescriptor> outputDesc = NULL;
    956 
    957         for (size_t i = 0; i < mOutputs.size(); i++) {
    958             sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
    959             if (!desc->isDuplicated() && (profile == desc->mProfile)) {
    960                 outputDesc = desc;
    961                 // reuse direct output if currently open by the same client
    962                 // and configured with same parameters
    963                 if ((samplingRate == outputDesc->mSamplingRate) &&
    964                     audio_formats_match(format, outputDesc->mFormat) &&
    965                     (channelMask == outputDesc->mChannelMask)) {
    966                   if (session == outputDesc->mDirectClientSession) {
    967                       outputDesc->mDirectOpenCount++;
    968                       ALOGV("getOutput() reusing direct output %d for session %d",
    969                             mOutputs.keyAt(i), session);
    970                       return mOutputs.keyAt(i);
    971                   } else {
    972                       ALOGV("getOutput() do not reuse direct output because current client (%d) "
    973                             "is not the same as requesting client (%d)",
    974                             outputDesc->mDirectClientSession, session);
    975                       goto non_direct_output;
    976                   }
    977                 }
    978             }
    979         }
    980         // close direct output if currently open and configured with different parameters
    981         if (outputDesc != NULL) {
    982             closeOutput(outputDesc->mIoHandle);
    983         }
    984 
    985         // if the selected profile is offloaded and no offload info was specified,
    986         // create a default one
    987         audio_offload_info_t defaultOffloadInfo = AUDIO_INFO_INITIALIZER;
    988         if ((profile->getFlags() & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) && !offloadInfo) {
    989             flags = (audio_output_flags_t)(flags | AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD);
    990             defaultOffloadInfo.sample_rate = samplingRate;
    991             defaultOffloadInfo.channel_mask = channelMask;
    992             defaultOffloadInfo.format = format;
    993             defaultOffloadInfo.stream_type = stream;
    994             defaultOffloadInfo.bit_rate = 0;
    995             defaultOffloadInfo.duration_us = -1;
    996             defaultOffloadInfo.has_video = true; // conservative
    997             defaultOffloadInfo.is_streaming = true; // likely
    998             offloadInfo = &defaultOffloadInfo;
    999         }
   1000 
   1001         outputDesc = new SwAudioOutputDescriptor(profile, mpClientInterface);
   1002         outputDesc->mDevice = device;
   1003         outputDesc->mLatency = 0;
   1004         outputDesc->mFlags = (audio_output_flags_t)(outputDesc->mFlags | flags);
   1005         audio_config_t config = AUDIO_CONFIG_INITIALIZER;
   1006         config.sample_rate = samplingRate;
   1007         config.channel_mask = channelMask;
   1008         config.format = format;
   1009         if (offloadInfo != NULL) {
   1010             config.offload_info = *offloadInfo;
   1011         }
   1012         DeviceVector outputDevices = mAvailableOutputDevices.getDevicesFromType(device);
   1013         String8 address = outputDevices.size() > 0 ? outputDevices.itemAt(0)->mAddress
   1014                 : String8("");
   1015         status = mpClientInterface->openOutput(profile->getModuleHandle(),
   1016                                                &output,
   1017                                                &config,
   1018                                                &outputDesc->mDevice,
   1019                                                address,
   1020                                                &outputDesc->mLatency,
   1021                                                outputDesc->mFlags);
   1022 
   1023         // only accept an output with the requested parameters
   1024         if (status != NO_ERROR ||
   1025             (samplingRate != 0 && samplingRate != config.sample_rate) ||
   1026             (format != AUDIO_FORMAT_DEFAULT && !audio_formats_match(format, config.format)) ||
   1027             (channelMask != 0 && channelMask != config.channel_mask)) {
   1028             ALOGV("getOutput() failed opening direct output: output %d samplingRate %d %d,"
   1029                     "format %d %d, channelMask %04x %04x", output, samplingRate,
   1030                     outputDesc->mSamplingRate, format, outputDesc->mFormat, channelMask,
   1031                     outputDesc->mChannelMask);
   1032             if (output != AUDIO_IO_HANDLE_NONE) {
   1033                 mpClientInterface->closeOutput(output);
   1034             }
   1035             // fall back to mixer output if possible when the direct output could not be open
   1036             if (audio_is_linear_pcm(format) && samplingRate <= SAMPLE_RATE_HZ_MAX) {
   1037                 goto non_direct_output;
   1038             }
   1039             return AUDIO_IO_HANDLE_NONE;
   1040         }
   1041         outputDesc->mSamplingRate = config.sample_rate;
   1042         outputDesc->mChannelMask = config.channel_mask;
   1043         outputDesc->mFormat = config.format;
   1044         outputDesc->mRefCount[stream] = 0;
   1045         outputDesc->mStopTime[stream] = 0;
   1046         outputDesc->mDirectOpenCount = 1;
   1047         outputDesc->mDirectClientSession = session;
   1048 
   1049         addOutput(output, outputDesc);
   1050         mPreviousOutputs = mOutputs;
   1051         ALOGV("getOutput() returns new direct output %d", output);
   1052         mpClientInterface->onAudioPortListUpdate();
   1053         return output;
   1054     }
   1055 
   1056 non_direct_output:
   1057 
   1058     // A request for HW A/V sync cannot fallback to a mixed output because time
   1059     // stamps are embedded in audio data
   1060     if ((flags & AUDIO_OUTPUT_FLAG_HW_AV_SYNC) != 0) {
   1061         return AUDIO_IO_HANDLE_NONE;
   1062     }
   1063 
   1064     // ignoring channel mask due to downmix capability in mixer
   1065 
   1066     // open a non direct output
   1067 
   1068     // for non direct outputs, only PCM is supported
   1069     if (audio_is_linear_pcm(format)) {
   1070         // get which output is suitable for the specified stream. The actual
   1071         // routing change will happen when startOutput() will be called
   1072         SortedVector<audio_io_handle_t> outputs = getOutputsForDevice(device, mOutputs);
   1073 
   1074         // at this stage we should ignore the DIRECT flag as no direct output could be found earlier
   1075         flags = (audio_output_flags_t)(flags & ~AUDIO_OUTPUT_FLAG_DIRECT);
   1076         output = selectOutput(outputs, flags, format);
   1077     }
   1078     ALOGW_IF((output == 0), "getOutput() could not find output for stream %d, samplingRate %d,"
   1079             "format %d, channels %x, flags %x", stream, samplingRate, format, channelMask, flags);
   1080 
   1081     ALOGV("  getOutputForDevice() returns output %d", output);
   1082 
   1083     return output;
   1084 }
   1085 
   1086 audio_io_handle_t AudioPolicyManager::selectOutput(const SortedVector<audio_io_handle_t>& outputs,
   1087                                                        audio_output_flags_t flags,
   1088                                                        audio_format_t format)
   1089 {
   1090     // select one output among several that provide a path to a particular device or set of
   1091     // devices (the list was previously build by getOutputsForDevice()).
   1092     // The priority is as follows:
   1093     // 1: the output with the highest number of requested policy flags
   1094     // 2: the output with the bit depth the closest to the requested one
   1095     // 3: the primary output
   1096     // 4: the first output in the list
   1097 
   1098     if (outputs.size() == 0) {
   1099         return 0;
   1100     }
   1101     if (outputs.size() == 1) {
   1102         return outputs[0];
   1103     }
   1104 
   1105     int maxCommonFlags = 0;
   1106     audio_io_handle_t outputForFlags = 0;
   1107     audio_io_handle_t outputForPrimary = 0;
   1108     audio_io_handle_t outputForFormat = 0;
   1109     audio_format_t bestFormat = AUDIO_FORMAT_INVALID;
   1110     audio_format_t bestFormatForFlags = AUDIO_FORMAT_INVALID;
   1111 
   1112     for (size_t i = 0; i < outputs.size(); i++) {
   1113         sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueFor(outputs[i]);
   1114         if (!outputDesc->isDuplicated()) {
   1115             // if a valid format is specified, skip output if not compatible
   1116             if (format != AUDIO_FORMAT_INVALID) {
   1117                 if (outputDesc->mFlags & AUDIO_OUTPUT_FLAG_DIRECT) {
   1118                     if (!audio_formats_match(format, outputDesc->mFormat)) {
   1119                         continue;
   1120                     }
   1121                 } else if (!audio_is_linear_pcm(format)) {
   1122                     continue;
   1123                 }
   1124                 if (AudioPort::isBetterFormatMatch(
   1125                         outputDesc->mFormat, bestFormat, format)) {
   1126                     outputForFormat = outputs[i];
   1127                     bestFormat = outputDesc->mFormat;
   1128                 }
   1129             }
   1130 
   1131             int commonFlags = popcount(outputDesc->mProfile->getFlags() & flags);
   1132             if (commonFlags >= maxCommonFlags) {
   1133                 if (commonFlags == maxCommonFlags) {
   1134                     if (AudioPort::isBetterFormatMatch(
   1135                             outputDesc->mFormat, bestFormatForFlags, format)) {
   1136                         outputForFlags = outputs[i];
   1137                         bestFormatForFlags = outputDesc->mFormat;
   1138                     }
   1139                 } else {
   1140                     outputForFlags = outputs[i];
   1141                     maxCommonFlags = commonFlags;
   1142                     bestFormatForFlags = outputDesc->mFormat;
   1143                 }
   1144                 ALOGV("selectOutput() commonFlags for output %d, %04x", outputs[i], commonFlags);
   1145             }
   1146             if (outputDesc->mProfile->getFlags() & AUDIO_OUTPUT_FLAG_PRIMARY) {
   1147                 outputForPrimary = outputs[i];
   1148             }
   1149         }
   1150     }
   1151 
   1152     if (outputForFlags != 0) {
   1153         return outputForFlags;
   1154     }
   1155     if (outputForFormat != 0) {
   1156         return outputForFormat;
   1157     }
   1158     if (outputForPrimary != 0) {
   1159         return outputForPrimary;
   1160     }
   1161 
   1162     return outputs[0];
   1163 }
   1164 
   1165 status_t AudioPolicyManager::startOutput(audio_io_handle_t output,
   1166                                              audio_stream_type_t stream,
   1167                                              audio_session_t session)
   1168 {
   1169     ALOGV("startOutput() output %d, stream %d, session %d",
   1170           output, stream, session);
   1171     ssize_t index = mOutputs.indexOfKey(output);
   1172     if (index < 0) {
   1173         ALOGW("startOutput() unknown output %d", output);
   1174         return BAD_VALUE;
   1175     }
   1176 
   1177     sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueAt(index);
   1178 
   1179     // Routing?
   1180     mOutputRoutes.incRouteActivity(session);
   1181 
   1182     audio_devices_t newDevice;
   1183     AudioMix *policyMix = NULL;
   1184     const char *address = NULL;
   1185     if (outputDesc->mPolicyMix != NULL) {
   1186         policyMix = outputDesc->mPolicyMix;
   1187         address = policyMix->mDeviceAddress.string();
   1188         if ((policyMix->mRouteFlags & MIX_ROUTE_FLAG_RENDER) == MIX_ROUTE_FLAG_RENDER) {
   1189             newDevice = policyMix->mDeviceType;
   1190         } else {
   1191             newDevice = AUDIO_DEVICE_OUT_REMOTE_SUBMIX;
   1192         }
   1193     } else if (mOutputRoutes.hasRouteChanged(session)) {
   1194         newDevice = getNewOutputDevice(outputDesc, false /*fromCache*/);
   1195         checkStrategyRoute(getStrategy(stream), output);
   1196     } else {
   1197         newDevice = AUDIO_DEVICE_NONE;
   1198     }
   1199 
   1200     uint32_t delayMs = 0;
   1201 
   1202     status_t status = startSource(outputDesc, stream, newDevice, address, &delayMs);
   1203 
   1204     if (status != NO_ERROR) {
   1205         mOutputRoutes.decRouteActivity(session);
   1206         return status;
   1207     }
   1208     // Automatically enable the remote submix input when output is started on a re routing mix
   1209     // of type MIX_TYPE_RECORDERS
   1210     if (audio_is_remote_submix_device(newDevice) && policyMix != NULL &&
   1211             policyMix->mMixType == MIX_TYPE_RECORDERS) {
   1212             setDeviceConnectionStateInt(AUDIO_DEVICE_IN_REMOTE_SUBMIX,
   1213                     AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
   1214                     address,
   1215                     "remote-submix");
   1216     }
   1217 
   1218     if (delayMs != 0) {
   1219         usleep(delayMs * 1000);
   1220     }
   1221 
   1222     return status;
   1223 }
   1224 
   1225 status_t AudioPolicyManager::startSource(const sp<AudioOutputDescriptor>& outputDesc,
   1226                                              audio_stream_type_t stream,
   1227                                              audio_devices_t device,
   1228                                              const char *address,
   1229                                              uint32_t *delayMs)
   1230 {
   1231     // cannot start playback of STREAM_TTS if any other output is being used
   1232     uint32_t beaconMuteLatency = 0;
   1233 
   1234     *delayMs = 0;
   1235     if (stream == AUDIO_STREAM_TTS) {
   1236         ALOGV("\t found BEACON stream");
   1237         if (!mTtsOutputAvailable && mOutputs.isAnyOutputActive(AUDIO_STREAM_TTS /*streamToIgnore*/)) {
   1238             return INVALID_OPERATION;
   1239         } else {
   1240             beaconMuteLatency = handleEventForBeacon(STARTING_BEACON);
   1241         }
   1242     } else {
   1243         // some playback other than beacon starts
   1244         beaconMuteLatency = handleEventForBeacon(STARTING_OUTPUT);
   1245     }
   1246 
   1247     // force device change if the output is inactive and no audio patch is already present.
   1248     // check active before incrementing usage count
   1249     bool force = !outputDesc->isActive() &&
   1250             (outputDesc->getPatchHandle() == AUDIO_PATCH_HANDLE_NONE);
   1251 
   1252     // increment usage count for this stream on the requested output:
   1253     // NOTE that the usage count is the same for duplicated output and hardware output which is
   1254     // necessary for a correct control of hardware output routing by startOutput() and stopOutput()
   1255     outputDesc->changeRefCount(stream, 1);
   1256 
   1257     if (stream == AUDIO_STREAM_MUSIC) {
   1258         selectOutputForMusicEffects();
   1259     }
   1260 
   1261     if (outputDesc->mRefCount[stream] == 1 || device != AUDIO_DEVICE_NONE) {
   1262         // starting an output being rerouted?
   1263         if (device == AUDIO_DEVICE_NONE) {
   1264             device = getNewOutputDevice(outputDesc, false /*fromCache*/);
   1265         }
   1266 
   1267         routing_strategy strategy = getStrategy(stream);
   1268         bool shouldWait = (strategy == STRATEGY_SONIFICATION) ||
   1269                             (strategy == STRATEGY_SONIFICATION_RESPECTFUL) ||
   1270                             (beaconMuteLatency > 0);
   1271         uint32_t waitMs = beaconMuteLatency;
   1272         for (size_t i = 0; i < mOutputs.size(); i++) {
   1273             sp<AudioOutputDescriptor> desc = mOutputs.valueAt(i);
   1274             if (desc != outputDesc) {
   1275                 // force a device change if any other output is:
   1276                 // - managed by the same hw module
   1277                 // - has a current device selection that differs from selected device.
   1278                 // - supports currently selected device
   1279                 // - has an active audio patch
   1280                 // In this case, the audio HAL must receive the new device selection so that it can
   1281                 // change the device currently selected by the other active output.
   1282                 if (outputDesc->sharesHwModuleWith(desc) &&
   1283                         desc->device() != device &&
   1284                         desc->supportedDevices() & device &&
   1285                         desc->getPatchHandle() != AUDIO_PATCH_HANDLE_NONE) {
   1286                     force = true;
   1287                 }
   1288                 // wait for audio on other active outputs to be presented when starting
   1289                 // a notification so that audio focus effect can propagate, or that a mute/unmute
   1290                 // event occurred for beacon
   1291                 uint32_t latency = desc->latency();
   1292                 if (shouldWait && desc->isActive(latency * 2) && (waitMs < latency)) {
   1293                     waitMs = latency;
   1294                 }
   1295             }
   1296         }
   1297         uint32_t muteWaitMs = setOutputDevice(outputDesc, device, force, 0, NULL, address);
   1298 
   1299         // handle special case for sonification while in call
   1300         if (isInCall()) {
   1301             handleIncallSonification(stream, true, false);
   1302         }
   1303 
   1304         // apply volume rules for current stream and device if necessary
   1305         checkAndSetVolume(stream,
   1306                           mVolumeCurves->getVolumeIndex(stream, device),
   1307                           outputDesc,
   1308                           device);
   1309 
   1310         // update the outputs if starting an output with a stream that can affect notification
   1311         // routing
   1312         handleNotificationRoutingForStream(stream);
   1313 
   1314         // force reevaluating accessibility routing when ringtone or alarm starts
   1315         if (strategy == STRATEGY_SONIFICATION) {
   1316             mpClientInterface->invalidateStream(AUDIO_STREAM_ACCESSIBILITY);
   1317         }
   1318 
   1319         if (waitMs > muteWaitMs) {
   1320             *delayMs = waitMs - muteWaitMs;
   1321         }
   1322     }
   1323 
   1324     return NO_ERROR;
   1325 }
   1326 
   1327 
   1328 status_t AudioPolicyManager::stopOutput(audio_io_handle_t output,
   1329                                             audio_stream_type_t stream,
   1330                                             audio_session_t session)
   1331 {
   1332     ALOGV("stopOutput() output %d, stream %d, session %d", output, stream, session);
   1333     ssize_t index = mOutputs.indexOfKey(output);
   1334     if (index < 0) {
   1335         ALOGW("stopOutput() unknown output %d", output);
   1336         return BAD_VALUE;
   1337     }
   1338 
   1339     sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueAt(index);
   1340 
   1341     if (outputDesc->mRefCount[stream] == 1) {
   1342         // Automatically disable the remote submix input when output is stopped on a
   1343         // re routing mix of type MIX_TYPE_RECORDERS
   1344         if (audio_is_remote_submix_device(outputDesc->mDevice) &&
   1345                 outputDesc->mPolicyMix != NULL &&
   1346                 outputDesc->mPolicyMix->mMixType == MIX_TYPE_RECORDERS) {
   1347             setDeviceConnectionStateInt(AUDIO_DEVICE_IN_REMOTE_SUBMIX,
   1348                     AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
   1349                     outputDesc->mPolicyMix->mDeviceAddress,
   1350                     "remote-submix");
   1351         }
   1352     }
   1353 
   1354     // Routing?
   1355     bool forceDeviceUpdate = false;
   1356     if (outputDesc->mRefCount[stream] > 0) {
   1357         int activityCount = mOutputRoutes.decRouteActivity(session);
   1358         forceDeviceUpdate = (mOutputRoutes.hasRoute(session) && (activityCount == 0));
   1359 
   1360         if (forceDeviceUpdate) {
   1361             checkStrategyRoute(getStrategy(stream), AUDIO_IO_HANDLE_NONE);
   1362         }
   1363     }
   1364 
   1365     return stopSource(outputDesc, stream, forceDeviceUpdate);
   1366 }
   1367 
   1368 status_t AudioPolicyManager::stopSource(const sp<AudioOutputDescriptor>& outputDesc,
   1369                                             audio_stream_type_t stream,
   1370                                             bool forceDeviceUpdate)
   1371 {
   1372     // always handle stream stop, check which stream type is stopping
   1373     handleEventForBeacon(stream == AUDIO_STREAM_TTS ? STOPPING_BEACON : STOPPING_OUTPUT);
   1374 
   1375     // handle special case for sonification while in call
   1376     if (isInCall()) {
   1377         handleIncallSonification(stream, false, false);
   1378     }
   1379 
   1380     if (outputDesc->mRefCount[stream] > 0) {
   1381         // decrement usage count of this stream on the output
   1382         outputDesc->changeRefCount(stream, -1);
   1383 
   1384         // store time at which the stream was stopped - see isStreamActive()
   1385         if (outputDesc->mRefCount[stream] == 0 || forceDeviceUpdate) {
   1386             outputDesc->mStopTime[stream] = systemTime();
   1387             audio_devices_t newDevice = getNewOutputDevice(outputDesc, false /*fromCache*/);
   1388             // delay the device switch by twice the latency because stopOutput() is executed when
   1389             // the track stop() command is received and at that time the audio track buffer can
   1390             // still contain data that needs to be drained. The latency only covers the audio HAL
   1391             // and kernel buffers. Also the latency does not always include additional delay in the
   1392             // audio path (audio DSP, CODEC ...)
   1393             setOutputDevice(outputDesc, newDevice, false, outputDesc->latency()*2);
   1394 
   1395             // force restoring the device selection on other active outputs if it differs from the
   1396             // one being selected for this output
   1397             uint32_t delayMs = outputDesc->latency()*2;
   1398             for (size_t i = 0; i < mOutputs.size(); i++) {
   1399                 sp<AudioOutputDescriptor> desc = mOutputs.valueAt(i);
   1400                 if (desc != outputDesc &&
   1401                         desc->isActive() &&
   1402                         outputDesc->sharesHwModuleWith(desc) &&
   1403                         (newDevice != desc->device())) {
   1404                     audio_devices_t newDevice2 = getNewOutputDevice(desc, false /*fromCache*/);
   1405                     bool force = desc->device() != newDevice2;
   1406                     setOutputDevice(desc,
   1407                                     newDevice2,
   1408                                     force,
   1409                                     delayMs);
   1410                     // re-apply device specific volume if not done by setOutputDevice()
   1411                     if (!force) {
   1412                         applyStreamVolumes(desc, newDevice2, delayMs);
   1413                     }
   1414                 }
   1415             }
   1416             // update the outputs if stopping one with a stream that can affect notification routing
   1417             handleNotificationRoutingForStream(stream);
   1418         }
   1419         if (stream == AUDIO_STREAM_MUSIC) {
   1420             selectOutputForMusicEffects();
   1421         }
   1422         return NO_ERROR;
   1423     } else {
   1424         ALOGW("stopOutput() refcount is already 0");
   1425         return INVALID_OPERATION;
   1426     }
   1427 }
   1428 
   1429 void AudioPolicyManager::releaseOutput(audio_io_handle_t output,
   1430                                        audio_stream_type_t stream __unused,
   1431                                        audio_session_t session __unused)
   1432 {
   1433     ALOGV("releaseOutput() %d", output);
   1434     ssize_t index = mOutputs.indexOfKey(output);
   1435     if (index < 0) {
   1436         ALOGW("releaseOutput() releasing unknown output %d", output);
   1437         return;
   1438     }
   1439 
   1440 #ifdef AUDIO_POLICY_TEST
   1441     int testIndex = testOutputIndex(output);
   1442     if (testIndex != 0) {
   1443         sp<AudioOutputDescriptor> outputDesc = mOutputs.valueAt(index);
   1444         if (outputDesc->isActive()) {
   1445             mpClientInterface->closeOutput(output);
   1446             removeOutput(output);
   1447             mTestOutputs[testIndex] = 0;
   1448         }
   1449         return;
   1450     }
   1451 #endif //AUDIO_POLICY_TEST
   1452 
   1453     // Routing
   1454     mOutputRoutes.removeRoute(session);
   1455 
   1456     sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(index);
   1457     if (desc->mFlags & AUDIO_OUTPUT_FLAG_DIRECT) {
   1458         if (desc->mDirectOpenCount <= 0) {
   1459             ALOGW("releaseOutput() invalid open count %d for output %d",
   1460                                                               desc->mDirectOpenCount, output);
   1461             return;
   1462         }
   1463         if (--desc->mDirectOpenCount == 0) {
   1464             closeOutput(output);
   1465             mpClientInterface->onAudioPortListUpdate();
   1466         }
   1467     }
   1468 }
   1469 
   1470 
   1471 status_t AudioPolicyManager::getInputForAttr(const audio_attributes_t *attr,
   1472                                              audio_io_handle_t *input,
   1473                                              audio_session_t session,
   1474                                              uid_t uid,
   1475                                              const audio_config_base_t *config,
   1476                                              audio_input_flags_t flags,
   1477                                              audio_port_handle_t selectedDeviceId,
   1478                                              input_type_t *inputType,
   1479                                              audio_port_handle_t *portId)
   1480 {
   1481     ALOGV("getInputForAttr() source %d, samplingRate %d, format %d, channelMask %x,"
   1482             "session %d, flags %#x",
   1483           attr->source, config->sample_rate, config->format, config->channel_mask, session, flags);
   1484 
   1485     *input = AUDIO_IO_HANDLE_NONE;
   1486     *inputType = API_INPUT_INVALID;
   1487 
   1488     audio_devices_t device;
   1489     // handle legacy remote submix case where the address was not always specified
   1490     String8 address = String8("");
   1491     audio_source_t inputSource = attr->source;
   1492     audio_source_t halInputSource;
   1493     AudioMix *policyMix = NULL;
   1494 
   1495     if (inputSource == AUDIO_SOURCE_DEFAULT) {
   1496         inputSource = AUDIO_SOURCE_MIC;
   1497     }
   1498     halInputSource = inputSource;
   1499 
   1500     // TODO: check for existing client for this port ID
   1501     if (*portId == AUDIO_PORT_HANDLE_NONE) {
   1502         *portId = AudioPort::getNextUniqueId();
   1503     }
   1504 
   1505     // Explicit routing?
   1506     sp<DeviceDescriptor> deviceDesc;
   1507     for (size_t i = 0; i < mAvailableInputDevices.size(); i++) {
   1508         if (mAvailableInputDevices[i]->getId() == selectedDeviceId) {
   1509             deviceDesc = mAvailableInputDevices[i];
   1510             break;
   1511         }
   1512     }
   1513     mInputRoutes.addRoute(session, SessionRoute::STREAM_TYPE_NA, inputSource, deviceDesc, uid);
   1514 
   1515     if (inputSource == AUDIO_SOURCE_REMOTE_SUBMIX &&
   1516             strncmp(attr->tags, "addr=", strlen("addr=")) == 0) {
   1517         status_t ret = mPolicyMixes.getInputMixForAttr(*attr, &policyMix);
   1518         if (ret != NO_ERROR) {
   1519             return ret;
   1520         }
   1521         *inputType = API_INPUT_MIX_EXT_POLICY_REROUTE;
   1522         device = AUDIO_DEVICE_IN_REMOTE_SUBMIX;
   1523         address = String8(attr->tags + strlen("addr="));
   1524     } else {
   1525         device = getDeviceAndMixForInputSource(inputSource, &policyMix);
   1526         if (device == AUDIO_DEVICE_NONE) {
   1527             ALOGW("getInputForAttr() could not find device for source %d", inputSource);
   1528             return BAD_VALUE;
   1529         }
   1530         if (policyMix != NULL) {
   1531             address = policyMix->mDeviceAddress;
   1532             if (policyMix->mMixType == MIX_TYPE_RECORDERS) {
   1533                 // there is an external policy, but this input is attached to a mix of recorders,
   1534                 // meaning it receives audio injected into the framework, so the recorder doesn't
   1535                 // know about it and is therefore considered "legacy"
   1536                 *inputType = API_INPUT_LEGACY;
   1537             } else {
   1538                 // recording a mix of players defined by an external policy, we're rerouting for
   1539                 // an external policy
   1540                 *inputType = API_INPUT_MIX_EXT_POLICY_REROUTE;
   1541             }
   1542         } else if (audio_is_remote_submix_device(device)) {
   1543             address = String8("0");
   1544             *inputType = API_INPUT_MIX_CAPTURE;
   1545         } else if (device == AUDIO_DEVICE_IN_TELEPHONY_RX) {
   1546             *inputType = API_INPUT_TELEPHONY_RX;
   1547         } else {
   1548             *inputType = API_INPUT_LEGACY;
   1549         }
   1550 
   1551     }
   1552 
   1553     *input = getInputForDevice(device, address, session, uid, inputSource,
   1554                                config->sample_rate, config->format, config->channel_mask, flags,
   1555                                policyMix);
   1556     if (*input == AUDIO_IO_HANDLE_NONE) {
   1557         mInputRoutes.removeRoute(session);
   1558         return INVALID_OPERATION;
   1559     }
   1560 
   1561     ALOGV("getInputForAttr() returns input type = %d", *inputType);
   1562     return NO_ERROR;
   1563 }
   1564 
   1565 
   1566 audio_io_handle_t AudioPolicyManager::getInputForDevice(audio_devices_t device,
   1567                                                         String8 address,
   1568                                                         audio_session_t session,
   1569                                                         uid_t uid,
   1570                                                         audio_source_t inputSource,
   1571                                                         uint32_t samplingRate,
   1572                                                         audio_format_t format,
   1573                                                         audio_channel_mask_t channelMask,
   1574                                                         audio_input_flags_t flags,
   1575                                                         AudioMix *policyMix)
   1576 {
   1577     audio_io_handle_t input = AUDIO_IO_HANDLE_NONE;
   1578     audio_source_t halInputSource = inputSource;
   1579     bool isSoundTrigger = false;
   1580 
   1581     if (inputSource == AUDIO_SOURCE_HOTWORD) {
   1582         ssize_t index = mSoundTriggerSessions.indexOfKey(session);
   1583         if (index >= 0) {
   1584             input = mSoundTriggerSessions.valueFor(session);
   1585             isSoundTrigger = true;
   1586             flags = (audio_input_flags_t)(flags | AUDIO_INPUT_FLAG_HW_HOTWORD);
   1587             ALOGV("SoundTrigger capture on session %d input %d", session, input);
   1588         } else {
   1589             halInputSource = AUDIO_SOURCE_VOICE_RECOGNITION;
   1590         }
   1591     }
   1592 
   1593     // find a compatible input profile (not necessarily identical in parameters)
   1594     sp<IOProfile> profile;
   1595     // samplingRate and flags may be updated by getInputProfile
   1596     uint32_t profileSamplingRate = (samplingRate == 0) ? SAMPLE_RATE_HZ_DEFAULT : samplingRate;
   1597     audio_format_t profileFormat = format;
   1598     audio_channel_mask_t profileChannelMask = channelMask;
   1599     audio_input_flags_t profileFlags = flags;
   1600     for (;;) {
   1601         profile = getInputProfile(device, address,
   1602                                   profileSamplingRate, profileFormat, profileChannelMask,
   1603                                   profileFlags);
   1604         if (profile != 0) {
   1605             break; // success
   1606         } else if (profileFlags & AUDIO_INPUT_FLAG_RAW) {
   1607             profileFlags = (audio_input_flags_t) (profileFlags & ~AUDIO_INPUT_FLAG_RAW); // retry
   1608         } else if (profileFlags != AUDIO_INPUT_FLAG_NONE) {
   1609             profileFlags = AUDIO_INPUT_FLAG_NONE; // retry
   1610         } else { // fail
   1611             ALOGW("getInputForDevice() could not find profile for device 0x%X,"
   1612                   "samplingRate %u, format %#x, channelMask 0x%X, flags %#x",
   1613                     device, samplingRate, format, channelMask, flags);
   1614             return input;
   1615         }
   1616     }
   1617     // Pick input sampling rate if not specified by client
   1618     if (samplingRate == 0) {
   1619         samplingRate = profileSamplingRate;
   1620     }
   1621 
   1622     if (profile->getModuleHandle() == 0) {
   1623         ALOGE("getInputForAttr(): HW module %s not opened", profile->getModuleName());
   1624         return input;
   1625     }
   1626 
   1627     sp<AudioSession> audioSession = new AudioSession(session,
   1628                                                               inputSource,
   1629                                                               format,
   1630                                                               samplingRate,
   1631                                                               channelMask,
   1632                                                               flags,
   1633                                                               uid,
   1634                                                               isSoundTrigger,
   1635                                                               policyMix, mpClientInterface);
   1636 
   1637 // FIXME: disable concurrent capture until UI is ready
   1638 #if 0
   1639     // reuse an open input if possible
   1640     sp<AudioInputDescriptor> reusedInputDesc;
   1641     for (size_t i = 0; i < mInputs.size(); i++) {
   1642         sp<AudioInputDescriptor> desc = mInputs.valueAt(i);
   1643         // reuse input if:
   1644         // - it shares the same profile
   1645         //      AND
   1646         // - it is not a reroute submix input
   1647         //      AND
   1648         // - it is: not used for sound trigger
   1649         //                OR
   1650         //          used for sound trigger and all clients use the same session ID
   1651         //
   1652         if ((profile == desc->mProfile) &&
   1653             (isSoundTrigger == desc->isSoundTrigger()) &&
   1654             !is_virtual_input_device(device)) {
   1655 
   1656             sp<AudioSession> as = desc->getAudioSession(session);
   1657             if (as != 0) {
   1658                 // do not allow unmatching properties on same session
   1659                 if (as->matches(audioSession)) {
   1660                     as->changeOpenCount(1);
   1661                 } else {
   1662                     ALOGW("getInputForDevice() record with different attributes"
   1663                           " exists for session %d", session);
   1664                     continue;
   1665                 }
   1666             } else if (isSoundTrigger) {
   1667                 continue;
   1668             }
   1669 
   1670             // Reuse the already opened input stream on this profile if:
   1671             // - the new capture source is background OR
   1672             // - the path requested configurations match OR
   1673             // - the new source priority is less than the highest source priority on this input
   1674             // If the input stream cannot be reused, close it before opening a new stream
   1675             // on the same profile for the new client so that the requested path configuration
   1676             // can be selected.
   1677             if (!isConcurrentSource(inputSource) &&
   1678                     ((desc->mSamplingRate != samplingRate ||
   1679                     desc->mChannelMask != channelMask ||
   1680                     !audio_formats_match(desc->mFormat, format)) &&
   1681                     (source_priority(desc->getHighestPrioritySource(false /*activeOnly*/)) <
   1682                      source_priority(inputSource)))) {
   1683                 reusedInputDesc = desc;
   1684                 continue;
   1685             } else {
   1686                 desc->addAudioSession(session, audioSession);
   1687                 ALOGV("%s: reusing input %d", __FUNCTION__, mInputs.keyAt(i));
   1688                 return mInputs.keyAt(i);
   1689             }
   1690         }
   1691     }
   1692 
   1693     if (reusedInputDesc != 0) {
   1694         AudioSessionCollection sessions = reusedInputDesc->getAudioSessions(false /*activeOnly*/);
   1695         for (size_t j = 0; j < sessions.size(); j++) {
   1696             audio_session_t currentSession = sessions.keyAt(j);
   1697             stopInput(reusedInputDesc->mIoHandle, currentSession);
   1698             releaseInput(reusedInputDesc->mIoHandle, currentSession);
   1699         }
   1700     }
   1701 #endif
   1702 
   1703     audio_config_t config = AUDIO_CONFIG_INITIALIZER;
   1704     config.sample_rate = profileSamplingRate;
   1705     config.channel_mask = profileChannelMask;
   1706     config.format = profileFormat;
   1707 
   1708     if (address == "") {
   1709         DeviceVector inputDevices = mAvailableInputDevices.getDevicesFromType(device);
   1710         //   the inputs vector must be of size 1, but we don't want to crash here
   1711         address = inputDevices.size() > 0 ? inputDevices.itemAt(0)->mAddress : String8("");
   1712     }
   1713 
   1714     status_t status = mpClientInterface->openInput(profile->getModuleHandle(),
   1715                                                    &input,
   1716                                                    &config,
   1717                                                    &device,
   1718                                                    address,
   1719                                                    halInputSource,
   1720                                                    profileFlags);
   1721 
   1722     // only accept input with the exact requested set of parameters
   1723     if (status != NO_ERROR || input == AUDIO_IO_HANDLE_NONE ||
   1724         (profileSamplingRate != config.sample_rate) ||
   1725         !audio_formats_match(profileFormat, config.format) ||
   1726         (profileChannelMask != config.channel_mask)) {
   1727         ALOGW("getInputForAttr() failed opening input: samplingRate %d"
   1728               ", format %d, channelMask %x",
   1729                 samplingRate, format, channelMask);
   1730         if (input != AUDIO_IO_HANDLE_NONE) {
   1731             mpClientInterface->closeInput(input);
   1732         }
   1733         return AUDIO_IO_HANDLE_NONE;
   1734     }
   1735 
   1736     sp<AudioInputDescriptor> inputDesc = new AudioInputDescriptor(profile);
   1737     inputDesc->mSamplingRate = profileSamplingRate;
   1738     inputDesc->mFormat = profileFormat;
   1739     inputDesc->mChannelMask = profileChannelMask;
   1740     inputDesc->mDevice = device;
   1741     inputDesc->mPolicyMix = policyMix;
   1742     inputDesc->addAudioSession(session, audioSession);
   1743 
   1744     addInput(input, inputDesc);
   1745     mpClientInterface->onAudioPortListUpdate();
   1746 
   1747     return input;
   1748 }
   1749 
   1750 //static
   1751 bool AudioPolicyManager::isConcurrentSource(audio_source_t source)
   1752 {
   1753     return (source == AUDIO_SOURCE_HOTWORD) ||
   1754             (source == AUDIO_SOURCE_VOICE_RECOGNITION) ||
   1755             (source == AUDIO_SOURCE_FM_TUNER);
   1756 }
   1757 
   1758 bool AudioPolicyManager::isConcurentCaptureAllowed(const sp<AudioInputDescriptor>& inputDesc,
   1759         const sp<AudioSession>& audioSession)
   1760 {
   1761     // Do not allow capture if an active voice call is using a software patch and
   1762     // the call TX source device is on the same HW module.
   1763     // FIXME: would be better to refine to only inputs whose profile connects to the
   1764     // call TX device but this information is not in the audio patch
   1765     if (mCallTxPatch != 0 &&
   1766         inputDesc->getModuleHandle() == mCallTxPatch->mPatch.sources[0].ext.device.hw_module) {
   1767         return false;
   1768     }
   1769 
   1770     // starting concurrent capture is enabled if:
   1771     // 1) capturing for re-routing
   1772     // 2) capturing for HOTWORD source
   1773     // 3) capturing for FM TUNER source
   1774     // 3) All other active captures are either for re-routing or HOTWORD
   1775 
   1776     if (is_virtual_input_device(inputDesc->mDevice) ||
   1777             isConcurrentSource(audioSession->inputSource())) {
   1778         return true;
   1779     }
   1780 
   1781     Vector< sp<AudioInputDescriptor> > activeInputs = mInputs.getActiveInputs();
   1782     for (size_t i = 0; i <  activeInputs.size(); i++) {
   1783         sp<AudioInputDescriptor> activeInput = activeInputs[i];
   1784         if (!isConcurrentSource(activeInput->inputSource(true)) &&
   1785                 !is_virtual_input_device(activeInput->mDevice)) {
   1786             return false;
   1787         }
   1788     }
   1789 
   1790     return true;
   1791 }
   1792 
   1793 
   1794 status_t AudioPolicyManager::startInput(audio_io_handle_t input,
   1795                                         audio_session_t session,
   1796                                         concurrency_type__mask_t *concurrency)
   1797 {
   1798     ALOGV("startInput() input %d", input);
   1799     *concurrency = API_INPUT_CONCURRENCY_NONE;
   1800     ssize_t index = mInputs.indexOfKey(input);
   1801     if (index < 0) {
   1802         ALOGW("startInput() unknown input %d", input);
   1803         return BAD_VALUE;
   1804     }
   1805     sp<AudioInputDescriptor> inputDesc = mInputs.valueAt(index);
   1806 
   1807     sp<AudioSession> audioSession = inputDesc->getAudioSession(session);
   1808     if (audioSession == 0) {
   1809         ALOGW("startInput() unknown session %d on input %d", session, input);
   1810         return BAD_VALUE;
   1811     }
   1812 
   1813 // FIXME: disable concurrent capture until UI is ready
   1814 #if 0
   1815     if (!isConcurentCaptureAllowed(inputDesc, audioSession)) {
   1816         ALOGW("startInput(%d) failed: other input already started", input);
   1817         return INVALID_OPERATION;
   1818     }
   1819 
   1820     if (isInCall()) {
   1821         *concurrency |= API_INPUT_CONCURRENCY_CALL;
   1822     }
   1823     if (mInputs.activeInputsCountOnDevices() != 0) {
   1824         *concurrency |= API_INPUT_CONCURRENCY_CAPTURE;
   1825     }
   1826 #else
   1827     if (!is_virtual_input_device(inputDesc->mDevice)) {
   1828         if (mCallTxPatch != 0 &&
   1829             inputDesc->getModuleHandle() == mCallTxPatch->mPatch.sources[0].ext.device.hw_module) {
   1830             ALOGW("startInput(%d) failed: call in progress", input);
   1831             return INVALID_OPERATION;
   1832         }
   1833 
   1834         Vector< sp<AudioInputDescriptor> > activeInputs = mInputs.getActiveInputs();
   1835         for (size_t i = 0; i < activeInputs.size(); i++) {
   1836             sp<AudioInputDescriptor> activeDesc = activeInputs[i];
   1837 
   1838             if (is_virtual_input_device(activeDesc->mDevice)) {
   1839                 continue;
   1840             }
   1841 
   1842             audio_source_t activeSource = activeDesc->inputSource(true);
   1843             if (audioSession->inputSource() == AUDIO_SOURCE_HOTWORD) {
   1844                 if (activeSource == AUDIO_SOURCE_HOTWORD) {
   1845                     if (activeDesc->hasPreemptedSession(session)) {
   1846                         ALOGW("startInput(%d) failed for HOTWORD: "
   1847                                 "other input %d already started for HOTWORD",
   1848                               input, activeDesc->mIoHandle);
   1849                         return INVALID_OPERATION;
   1850                     }
   1851                 } else {
   1852                     ALOGV("startInput(%d) failed for HOTWORD: other input %d already started",
   1853                           input, activeDesc->mIoHandle);
   1854                     return INVALID_OPERATION;
   1855                 }
   1856             } else {
   1857                 if (activeSource != AUDIO_SOURCE_HOTWORD) {
   1858                     ALOGW("startInput(%d) failed: other input %d already started",
   1859                           input, activeDesc->mIoHandle);
   1860                     return INVALID_OPERATION;
   1861                 }
   1862             }
   1863         }
   1864 
   1865         // if capture is allowed, preempt currently active HOTWORD captures
   1866         for (size_t i = 0; i < activeInputs.size(); i++) {
   1867             sp<AudioInputDescriptor> activeDesc = activeInputs[i];
   1868 
   1869             if (is_virtual_input_device(activeDesc->mDevice)) {
   1870                 continue;
   1871             }
   1872 
   1873             audio_source_t activeSource = activeDesc->inputSource(true);
   1874             if (activeSource == AUDIO_SOURCE_HOTWORD) {
   1875                 AudioSessionCollection activeSessions =
   1876                         activeDesc->getAudioSessions(true /*activeOnly*/);
   1877                 audio_session_t activeSession = activeSessions.keyAt(0);
   1878                 audio_io_handle_t activeHandle = activeDesc->mIoHandle;
   1879                 SortedVector<audio_session_t> sessions = activeDesc->getPreemptedSessions();
   1880                 sessions.add(activeSession);
   1881                 inputDesc->setPreemptedSessions(sessions);
   1882                 stopInput(activeHandle, activeSession);
   1883                 releaseInput(activeHandle, activeSession);
   1884                 ALOGV("startInput(%d) for HOTWORD preempting HOTWORD input %d",
   1885                       input, activeDesc->mIoHandle);
   1886             }
   1887         }
   1888     }
   1889 #endif
   1890 
   1891     // increment activity count before calling getNewInputDevice() below as only active sessions
   1892     // are considered for device selection
   1893     audioSession->changeActiveCount(1);
   1894 
   1895     // Routing?
   1896     mInputRoutes.incRouteActivity(session);
   1897 
   1898     if (audioSession->activeCount() == 1 || mInputRoutes.hasRouteChanged(session)) {
   1899         // indicate active capture to sound trigger service if starting capture from a mic on
   1900         // primary HW module
   1901         audio_devices_t device = getNewInputDevice(inputDesc);
   1902         setInputDevice(input, device, true /* force */);
   1903 
   1904         if (inputDesc->getAudioSessionCount(true/*activeOnly*/) == 1) {
   1905             // if input maps to a dynamic policy with an activity listener, notify of state change
   1906             if ((inputDesc->mPolicyMix != NULL)
   1907                     && ((inputDesc->mPolicyMix->mCbFlags & AudioMix::kCbFlagNotifyActivity) != 0)) {
   1908                 mpClientInterface->onDynamicPolicyMixStateUpdate(inputDesc->mPolicyMix->mDeviceAddress,
   1909                         MIX_STATE_MIXING);
   1910             }
   1911 
   1912             audio_devices_t primaryInputDevices = availablePrimaryInputDevices();
   1913             if (((device & primaryInputDevices & ~AUDIO_DEVICE_BIT_IN) != 0) &&
   1914                     mInputs.activeInputsCountOnDevices(primaryInputDevices) == 1) {
   1915                 SoundTrigger::setCaptureState(true);
   1916             }
   1917 
   1918             // automatically enable the remote submix output when input is started if not
   1919             // used by a policy mix of type MIX_TYPE_RECORDERS
   1920             // For remote submix (a virtual device), we open only one input per capture request.
   1921             if (audio_is_remote_submix_device(inputDesc->mDevice)) {
   1922                 String8 address = String8("");
   1923                 if (inputDesc->mPolicyMix == NULL) {
   1924                     address = String8("0");
   1925                 } else if (inputDesc->mPolicyMix->mMixType == MIX_TYPE_PLAYERS) {
   1926                     address = inputDesc->mPolicyMix->mDeviceAddress;
   1927                 }
   1928                 if (address != "") {
   1929                     setDeviceConnectionStateInt(AUDIO_DEVICE_OUT_REMOTE_SUBMIX,
   1930                             AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
   1931                             address, "remote-submix");
   1932                 }
   1933             }
   1934         }
   1935     }
   1936 
   1937     ALOGV("AudioPolicyManager::startInput() input source = %d", audioSession->inputSource());
   1938 
   1939     return NO_ERROR;
   1940 }
   1941 
   1942 status_t AudioPolicyManager::stopInput(audio_io_handle_t input,
   1943                                        audio_session_t session)
   1944 {
   1945     ALOGV("stopInput() input %d", input);
   1946     ssize_t index = mInputs.indexOfKey(input);
   1947     if (index < 0) {
   1948         ALOGW("stopInput() unknown input %d", input);
   1949         return BAD_VALUE;
   1950     }
   1951     sp<AudioInputDescriptor> inputDesc = mInputs.valueAt(index);
   1952 
   1953     sp<AudioSession> audioSession = inputDesc->getAudioSession(session);
   1954     if (index < 0) {
   1955         ALOGW("stopInput() unknown session %d on input %d", session, input);
   1956         return BAD_VALUE;
   1957     }
   1958 
   1959     if (audioSession->activeCount() == 0) {
   1960         ALOGW("stopInput() input %d already stopped", input);
   1961         return INVALID_OPERATION;
   1962     }
   1963 
   1964     audioSession->changeActiveCount(-1);
   1965 
   1966     // Routing?
   1967     mInputRoutes.decRouteActivity(session);
   1968 
   1969     if (audioSession->activeCount() == 0) {
   1970 
   1971         if (inputDesc->isActive()) {
   1972             setInputDevice(input, getNewInputDevice(inputDesc), false /* force */);
   1973         } else {
   1974             // if input maps to a dynamic policy with an activity listener, notify of state change
   1975             if ((inputDesc->mPolicyMix != NULL)
   1976                     && ((inputDesc->mPolicyMix->mCbFlags & AudioMix::kCbFlagNotifyActivity) != 0)) {
   1977                 mpClientInterface->onDynamicPolicyMixStateUpdate(inputDesc->mPolicyMix->mDeviceAddress,
   1978                         MIX_STATE_IDLE);
   1979             }
   1980 
   1981             // automatically disable the remote submix output when input is stopped if not
   1982             // used by a policy mix of type MIX_TYPE_RECORDERS
   1983             if (audio_is_remote_submix_device(inputDesc->mDevice)) {
   1984                 String8 address = String8("");
   1985                 if (inputDesc->mPolicyMix == NULL) {
   1986                     address = String8("0");
   1987                 } else if (inputDesc->mPolicyMix->mMixType == MIX_TYPE_PLAYERS) {
   1988                     address = inputDesc->mPolicyMix->mDeviceAddress;
   1989                 }
   1990                 if (address != "") {
   1991                     setDeviceConnectionStateInt(AUDIO_DEVICE_OUT_REMOTE_SUBMIX,
   1992                                              AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
   1993                                              address, "remote-submix");
   1994                 }
   1995             }
   1996 
   1997             audio_devices_t device = inputDesc->mDevice;
   1998             resetInputDevice(input);
   1999 
   2000             // indicate inactive capture to sound trigger service if stopping capture from a mic on
   2001             // primary HW module
   2002             audio_devices_t primaryInputDevices = availablePrimaryInputDevices();
   2003             if (((device & primaryInputDevices & ~AUDIO_DEVICE_BIT_IN) != 0) &&
   2004                     mInputs.activeInputsCountOnDevices(primaryInputDevices) == 0) {
   2005                 SoundTrigger::setCaptureState(false);
   2006             }
   2007             inputDesc->clearPreemptedSessions();
   2008         }
   2009     }
   2010     return NO_ERROR;
   2011 }
   2012 
   2013 void AudioPolicyManager::releaseInput(audio_io_handle_t input,
   2014                                       audio_session_t session)
   2015 {
   2016 
   2017     ALOGV("releaseInput() %d", input);
   2018     ssize_t index = mInputs.indexOfKey(input);
   2019     if (index < 0) {
   2020         ALOGW("releaseInput() releasing unknown input %d", input);
   2021         return;
   2022     }
   2023 
   2024     // Routing
   2025     mInputRoutes.removeRoute(session);
   2026 
   2027     sp<AudioInputDescriptor> inputDesc = mInputs.valueAt(index);
   2028     ALOG_ASSERT(inputDesc != 0);
   2029 
   2030     sp<AudioSession> audioSession = inputDesc->getAudioSession(session);
   2031     if (audioSession == 0) {
   2032         ALOGW("releaseInput() unknown session %d on input %d", session, input);
   2033         return;
   2034     }
   2035 
   2036     if (audioSession->openCount() == 0) {
   2037         ALOGW("releaseInput() invalid open count %d on session %d",
   2038               audioSession->openCount(), session);
   2039         return;
   2040     }
   2041 
   2042     if (audioSession->changeOpenCount(-1) == 0) {
   2043         inputDesc->removeAudioSession(session);
   2044     }
   2045 
   2046     if (inputDesc->getOpenRefCount() > 0) {
   2047         ALOGV("releaseInput() exit > 0");
   2048         return;
   2049     }
   2050 
   2051     closeInput(input);
   2052     mpClientInterface->onAudioPortListUpdate();
   2053     ALOGV("releaseInput() exit");
   2054 }
   2055 
   2056 void AudioPolicyManager::closeAllInputs() {
   2057     bool patchRemoved = false;
   2058 
   2059     for(size_t input_index = 0; input_index < mInputs.size(); input_index++) {
   2060         sp<AudioInputDescriptor> inputDesc = mInputs.valueAt(input_index);
   2061         ssize_t patch_index = mAudioPatches.indexOfKey(inputDesc->getPatchHandle());
   2062         if (patch_index >= 0) {
   2063             sp<AudioPatch> patchDesc = mAudioPatches.valueAt(patch_index);
   2064             (void) /*status_t status*/ mpClientInterface->releaseAudioPatch(patchDesc->mAfPatchHandle, 0);
   2065             mAudioPatches.removeItemsAt(patch_index);
   2066             patchRemoved = true;
   2067         }
   2068         mpClientInterface->closeInput(mInputs.keyAt(input_index));
   2069     }
   2070     mInputs.clear();
   2071     SoundTrigger::setCaptureState(false);
   2072     nextAudioPortGeneration();
   2073 
   2074     if (patchRemoved) {
   2075         mpClientInterface->onAudioPatchListUpdate();
   2076     }
   2077 }
   2078 
   2079 void AudioPolicyManager::initStreamVolume(audio_stream_type_t stream,
   2080                                             int indexMin,
   2081                                             int indexMax)
   2082 {
   2083     ALOGV("initStreamVolume() stream %d, min %d, max %d", stream , indexMin, indexMax);
   2084     mVolumeCurves->initStreamVolume(stream, indexMin, indexMax);
   2085 
   2086     // initialize other private stream volumes which follow this one
   2087     for (int curStream = 0; curStream < AUDIO_STREAM_FOR_POLICY_CNT; curStream++) {
   2088         if (!streamsMatchForvolume(stream, (audio_stream_type_t)curStream)) {
   2089             continue;
   2090         }
   2091         mVolumeCurves->initStreamVolume((audio_stream_type_t)curStream, indexMin, indexMax);
   2092     }
   2093 }
   2094 
   2095 status_t AudioPolicyManager::setStreamVolumeIndex(audio_stream_type_t stream,
   2096                                                   int index,
   2097                                                   audio_devices_t device)
   2098 {
   2099 
   2100     if ((index < mVolumeCurves->getVolumeIndexMin(stream)) ||
   2101             (index > mVolumeCurves->getVolumeIndexMax(stream))) {
   2102         return BAD_VALUE;
   2103     }
   2104     if (!audio_is_output_device(device)) {
   2105         return BAD_VALUE;
   2106     }
   2107 
   2108     // Force max volume if stream cannot be muted
   2109     if (!mVolumeCurves->canBeMuted(stream)) index = mVolumeCurves->getVolumeIndexMax(stream);
   2110 
   2111     ALOGV("setStreamVolumeIndex() stream %d, device %08x, index %d",
   2112           stream, device, index);
   2113 
   2114     // update other private stream volumes which follow this one
   2115     for (int curStream = 0; curStream < AUDIO_STREAM_FOR_POLICY_CNT; curStream++) {
   2116         if (!streamsMatchForvolume(stream, (audio_stream_type_t)curStream)) {
   2117             continue;
   2118         }
   2119         mVolumeCurves->addCurrentVolumeIndex((audio_stream_type_t)curStream, device, index);
   2120     }
   2121 
   2122     // update volume on all outputs and streams matching the following:
   2123     // - The requested stream (or a stream matching for volume control) is active on the output
   2124     // - The device (or devices) selected by the strategy corresponding to this stream includes
   2125     // the requested device
   2126     // - For non default requested device, currently selected device on the output is either the
   2127     // requested device or one of the devices selected by the strategy
   2128     // - For default requested device (AUDIO_DEVICE_OUT_DEFAULT_FOR_VOLUME), apply volume only if
   2129     // no specific device volume value exists for currently selected device.
   2130     status_t status = NO_ERROR;
   2131     for (size_t i = 0; i < mOutputs.size(); i++) {
   2132         sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
   2133         audio_devices_t curDevice = Volume::getDeviceForVolume(desc->device());
   2134         for (int curStream = 0; curStream < AUDIO_STREAM_FOR_POLICY_CNT; curStream++) {
   2135             if (!streamsMatchForvolume(stream, (audio_stream_type_t)curStream)) {
   2136                 continue;
   2137             }
   2138             if (!(desc->isStreamActive((audio_stream_type_t)curStream) ||
   2139                     (isInCall() && (curStream == AUDIO_STREAM_VOICE_CALL)))) {
   2140                 continue;
   2141             }
   2142             routing_strategy curStrategy = getStrategy((audio_stream_type_t)curStream);
   2143             audio_devices_t curStreamDevice = getDeviceForStrategy(curStrategy, false /*fromCache*/);
   2144             if ((device != AUDIO_DEVICE_OUT_DEFAULT_FOR_VOLUME) &&
   2145                     ((curStreamDevice & device) == 0)) {
   2146                 continue;
   2147             }
   2148             bool applyVolume;
   2149             if (device != AUDIO_DEVICE_OUT_DEFAULT_FOR_VOLUME) {
   2150                 curStreamDevice |= device;
   2151                 applyVolume = (curDevice & curStreamDevice) != 0;
   2152             } else {
   2153                 applyVolume = !mVolumeCurves->hasVolumeIndexForDevice(
   2154                         stream, Volume::getDeviceForVolume(curStreamDevice));
   2155             }
   2156 
   2157             if (applyVolume) {
   2158                 //FIXME: workaround for truncated touch sounds
   2159                 // delayed volume change for system stream to be removed when the problem is
   2160                 // handled by system UI
   2161                 status_t volStatus =
   2162                         checkAndSetVolume((audio_stream_type_t)curStream, index, desc, curDevice,
   2163                             (stream == AUDIO_STREAM_SYSTEM) ? TOUCH_SOUND_FIXED_DELAY_MS : 0);
   2164                 if (volStatus != NO_ERROR) {
   2165                     status = volStatus;
   2166                 }
   2167             }
   2168         }
   2169     }
   2170     return status;
   2171 }
   2172 
   2173 status_t AudioPolicyManager::getStreamVolumeIndex(audio_stream_type_t stream,
   2174                                                       int *index,
   2175                                                       audio_devices_t device)
   2176 {
   2177     if (index == NULL) {
   2178         return BAD_VALUE;
   2179     }
   2180     if (!audio_is_output_device(device)) {
   2181         return BAD_VALUE;
   2182     }
   2183     // if device is AUDIO_DEVICE_OUT_DEFAULT_FOR_VOLUME, return volume for device corresponding to
   2184     // the strategy the stream belongs to.
   2185     if (device == AUDIO_DEVICE_OUT_DEFAULT_FOR_VOLUME) {
   2186         device = getDeviceForStrategy(getStrategy(stream), true /*fromCache*/);
   2187     }
   2188     device = Volume::getDeviceForVolume(device);
   2189 
   2190     *index =  mVolumeCurves->getVolumeIndex(stream, device);
   2191     ALOGV("getStreamVolumeIndex() stream %d device %08x index %d", stream, device, *index);
   2192     return NO_ERROR;
   2193 }
   2194 
   2195 audio_io_handle_t AudioPolicyManager::selectOutputForMusicEffects()
   2196 {
   2197     // select one output among several suitable for global effects.
   2198     // The priority is as follows:
   2199     // 1: An offloaded output. If the effect ends up not being offloadable,
   2200     //    AudioFlinger will invalidate the track and the offloaded output
   2201     //    will be closed causing the effect to be moved to a PCM output.
   2202     // 2: A deep buffer output
   2203     // 3: The primary output
   2204     // 4: the first output in the list
   2205 
   2206     routing_strategy strategy = getStrategy(AUDIO_STREAM_MUSIC);
   2207     audio_devices_t device = getDeviceForStrategy(strategy, false /*fromCache*/);
   2208     SortedVector<audio_io_handle_t> outputs = getOutputsForDevice(device, mOutputs);
   2209 
   2210     if (outputs.size() == 0) {
   2211         return AUDIO_IO_HANDLE_NONE;
   2212     }
   2213 
   2214     audio_io_handle_t output = AUDIO_IO_HANDLE_NONE;
   2215     bool activeOnly = true;
   2216 
   2217     while (output == AUDIO_IO_HANDLE_NONE) {
   2218         audio_io_handle_t outputOffloaded = AUDIO_IO_HANDLE_NONE;
   2219         audio_io_handle_t outputDeepBuffer = AUDIO_IO_HANDLE_NONE;
   2220         audio_io_handle_t outputPrimary = AUDIO_IO_HANDLE_NONE;
   2221 
   2222         for (size_t i = 0; i < outputs.size(); i++) {
   2223             sp<SwAudioOutputDescriptor> desc = mOutputs.valueFor(outputs[i]);
   2224             if (activeOnly && !desc->isStreamActive(AUDIO_STREAM_MUSIC)) {
   2225                 continue;
   2226             }
   2227             ALOGV("selectOutputForMusicEffects activeOnly %d outputs[%zu] flags 0x%08x",
   2228                   activeOnly, i, desc->mFlags);
   2229             if ((desc->mFlags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0) {
   2230                 outputOffloaded = outputs[i];
   2231             }
   2232             if ((desc->mFlags & AUDIO_OUTPUT_FLAG_DEEP_BUFFER) != 0) {
   2233                 outputDeepBuffer = outputs[i];
   2234             }
   2235             if ((desc->mFlags & AUDIO_OUTPUT_FLAG_PRIMARY) != 0) {
   2236                 outputPrimary = outputs[i];
   2237             }
   2238         }
   2239         if (outputOffloaded != AUDIO_IO_HANDLE_NONE) {
   2240             output = outputOffloaded;
   2241         } else if (outputDeepBuffer != AUDIO_IO_HANDLE_NONE) {
   2242             output = outputDeepBuffer;
   2243         } else if (outputPrimary != AUDIO_IO_HANDLE_NONE) {
   2244             output = outputPrimary;
   2245         } else {
   2246             output = outputs[0];
   2247         }
   2248         activeOnly = false;
   2249     }
   2250 
   2251     if (output != mMusicEffectOutput) {
   2252         mpClientInterface->moveEffects(AUDIO_SESSION_OUTPUT_MIX, mMusicEffectOutput, output);
   2253         mMusicEffectOutput = output;
   2254     }
   2255 
   2256     ALOGV("selectOutputForMusicEffects selected output %d", output);
   2257     return output;
   2258 }
   2259 
   2260 audio_io_handle_t AudioPolicyManager::getOutputForEffect(const effect_descriptor_t *desc __unused)
   2261 {
   2262     return selectOutputForMusicEffects();
   2263 }
   2264 
   2265 status_t AudioPolicyManager::registerEffect(const effect_descriptor_t *desc,
   2266                                 audio_io_handle_t io,
   2267                                 uint32_t strategy,
   2268                                 int session,
   2269                                 int id)
   2270 {
   2271     ssize_t index = mOutputs.indexOfKey(io);
   2272     if (index < 0) {
   2273         index = mInputs.indexOfKey(io);
   2274         if (index < 0) {
   2275             ALOGW("registerEffect() unknown io %d", io);
   2276             return INVALID_OPERATION;
   2277         }
   2278     }
   2279     return mEffects.registerEffect(desc, io, strategy, session, id);
   2280 }
   2281 
   2282 bool AudioPolicyManager::isStreamActive(audio_stream_type_t stream, uint32_t inPastMs) const
   2283 {
   2284     bool active = false;
   2285     for (int curStream = 0; curStream < AUDIO_STREAM_FOR_POLICY_CNT && !active; curStream++) {
   2286         if (!streamsMatchForvolume(stream, (audio_stream_type_t)curStream)) {
   2287             continue;
   2288         }
   2289         active = mOutputs.isStreamActive((audio_stream_type_t)curStream, inPastMs);
   2290     }
   2291     return active;
   2292 }
   2293 
   2294 bool AudioPolicyManager::isStreamActiveRemotely(audio_stream_type_t stream, uint32_t inPastMs) const
   2295 {
   2296     return mOutputs.isStreamActiveRemotely(stream, inPastMs);
   2297 }
   2298 
   2299 bool AudioPolicyManager::isSourceActive(audio_source_t source) const
   2300 {
   2301     for (size_t i = 0; i < mInputs.size(); i++) {
   2302         const sp<AudioInputDescriptor>  inputDescriptor = mInputs.valueAt(i);
   2303         if (inputDescriptor->isSourceActive(source)) {
   2304             return true;
   2305         }
   2306     }
   2307     return false;
   2308 }
   2309 
   2310 // Register a list of custom mixes with their attributes and format.
   2311 // When a mix is registered, corresponding input and output profiles are
   2312 // added to the remote submix hw module. The profile contains only the
   2313 // parameters (sampling rate, format...) specified by the mix.
   2314 // The corresponding input remote submix device is also connected.
   2315 //
   2316 // When a remote submix device is connected, the address is checked to select the
   2317 // appropriate profile and the corresponding input or output stream is opened.
   2318 //
   2319 // When capture starts, getInputForAttr() will:
   2320 //  - 1 look for a mix matching the address passed in attribtutes tags if any
   2321 //  - 2 if none found, getDeviceForInputSource() will:
   2322 //     - 2.1 look for a mix matching the attributes source
   2323 //     - 2.2 if none found, default to device selection by policy rules
   2324 // At this time, the corresponding output remote submix device is also connected
   2325 // and active playback use cases can be transferred to this mix if needed when reconnecting
   2326 // after AudioTracks are invalidated
   2327 //
   2328 // When playback starts, getOutputForAttr() will:
   2329 //  - 1 look for a mix matching the address passed in attribtutes tags if any
   2330 //  - 2 if none found, look for a mix matching the attributes usage
   2331 //  - 3 if none found, default to device and output selection by policy rules.
   2332 
   2333 status_t AudioPolicyManager::registerPolicyMixes(const Vector<AudioMix>& mixes)
   2334 {
   2335     ALOGV("registerPolicyMixes() %zu mix(es)", mixes.size());
   2336     status_t res = NO_ERROR;
   2337 
   2338     sp<HwModule> rSubmixModule;
   2339     // examine each mix's route type
   2340     for (size_t i = 0; i < mixes.size(); i++) {
   2341         // we only support MIX_ROUTE_FLAG_LOOP_BACK or MIX_ROUTE_FLAG_RENDER, not the combination
   2342         if ((mixes[i].mRouteFlags & MIX_ROUTE_FLAG_ALL) == MIX_ROUTE_FLAG_ALL) {
   2343             res = INVALID_OPERATION;
   2344             break;
   2345         }
   2346         if ((mixes[i].mRouteFlags & MIX_ROUTE_FLAG_LOOP_BACK) == MIX_ROUTE_FLAG_LOOP_BACK) {
   2347             // Loop back through "remote submix"
   2348             if (rSubmixModule == 0) {
   2349                 for (size_t j = 0; i < mHwModules.size(); j++) {
   2350                     if (strcmp(AUDIO_HARDWARE_MODULE_ID_REMOTE_SUBMIX, mHwModules[j]->mName) == 0
   2351                             && mHwModules[j]->mHandle != 0) {
   2352                         rSubmixModule = mHwModules[j];
   2353                         break;
   2354                     }
   2355                 }
   2356             }
   2357 
   2358             ALOGV("registerPolicyMixes() mix %zu of %zu is LOOP_BACK", i, mixes.size());
   2359 
   2360             if (rSubmixModule == 0) {
   2361                 ALOGE(" Unable to find audio module for submix, aborting mix %zu registration", i);
   2362                 res = INVALID_OPERATION;
   2363                 break;
   2364             }
   2365 
   2366             String8 address = mixes[i].mDeviceAddress;
   2367 
   2368             if (mPolicyMixes.registerMix(address, mixes[i], 0 /*output desc*/) != NO_ERROR) {
   2369                 ALOGE(" Error registering mix %zu for address %s", i, address.string());
   2370                 res = INVALID_OPERATION;
   2371                 break;
   2372             }
   2373             audio_config_t outputConfig = mixes[i].mFormat;
   2374             audio_config_t inputConfig = mixes[i].mFormat;
   2375             // NOTE: audio flinger mixer does not support mono output: configure remote submix HAL in
   2376             // stereo and let audio flinger do the channel conversion if needed.
   2377             outputConfig.channel_mask = AUDIO_CHANNEL_OUT_STEREO;
   2378             inputConfig.channel_mask = AUDIO_CHANNEL_IN_STEREO;
   2379             rSubmixModule->addOutputProfile(address, &outputConfig,
   2380                     AUDIO_DEVICE_OUT_REMOTE_SUBMIX, address);
   2381             rSubmixModule->addInputProfile(address, &inputConfig,
   2382                     AUDIO_DEVICE_IN_REMOTE_SUBMIX, address);
   2383 
   2384             if (mixes[i].mMixType == MIX_TYPE_PLAYERS) {
   2385                 setDeviceConnectionStateInt(AUDIO_DEVICE_IN_REMOTE_SUBMIX,
   2386                         AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
   2387                         address.string(), "remote-submix");
   2388             } else {
   2389                 setDeviceConnectionStateInt(AUDIO_DEVICE_OUT_REMOTE_SUBMIX,
   2390                         AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
   2391                         address.string(), "remote-submix");
   2392             }
   2393         } else if ((mixes[i].mRouteFlags & MIX_ROUTE_FLAG_RENDER) == MIX_ROUTE_FLAG_RENDER) {
   2394             String8 address = mixes[i].mDeviceAddress;
   2395             audio_devices_t device = mixes[i].mDeviceType;
   2396             ALOGV(" registerPolicyMixes() mix %zu of %zu is RENDER, dev=0x%X addr=%s",
   2397                     i, mixes.size(), device, address.string());
   2398 
   2399             bool foundOutput = false;
   2400             for (size_t j = 0 ; j < mOutputs.size() ; j++) {
   2401                 sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(j);
   2402                 sp<AudioPatch> patch = mAudioPatches.valueFor(desc->getPatchHandle());
   2403                 if ((patch != 0) && (patch->mPatch.num_sinks != 0)
   2404                         && (patch->mPatch.sinks[0].type == AUDIO_PORT_TYPE_DEVICE)
   2405                         && (patch->mPatch.sinks[0].ext.device.type == device)
   2406                         && (strncmp(patch->mPatch.sinks[0].ext.device.address, address.string(),
   2407                                 AUDIO_DEVICE_MAX_ADDRESS_LEN) == 0)) {
   2408                     if (mPolicyMixes.registerMix(address, mixes[i], desc) != NO_ERROR) {
   2409                         res = INVALID_OPERATION;
   2410                     } else {
   2411                         foundOutput = true;
   2412                     }
   2413                     break;
   2414                 }
   2415             }
   2416 
   2417             if (res != NO_ERROR) {
   2418                 ALOGE(" Error registering mix %zu for device 0x%X addr %s",
   2419                         i, device, address.string());
   2420                 res = INVALID_OPERATION;
   2421                 break;
   2422             } else if (!foundOutput) {
   2423                 ALOGE(" Output not found for mix %zu for device 0x%X addr %s",
   2424                         i, device, address.string());
   2425                 res = INVALID_OPERATION;
   2426                 break;
   2427             }
   2428         }
   2429     }
   2430     if (res != NO_ERROR) {
   2431         unregisterPolicyMixes(mixes);
   2432     }
   2433     return res;
   2434 }
   2435 
   2436 status_t AudioPolicyManager::unregisterPolicyMixes(Vector<AudioMix> mixes)
   2437 {
   2438     ALOGV("unregisterPolicyMixes() num mixes %zu", mixes.size());
   2439     status_t res = NO_ERROR;
   2440     sp<HwModule> rSubmixModule;
   2441     // examine each mix's route type
   2442     for (size_t i = 0; i < mixes.size(); i++) {
   2443         if ((mixes[i].mRouteFlags & MIX_ROUTE_FLAG_LOOP_BACK) == MIX_ROUTE_FLAG_LOOP_BACK) {
   2444 
   2445             if (rSubmixModule == 0) {
   2446                 for (size_t j = 0; i < mHwModules.size(); j++) {
   2447                     if (strcmp(AUDIO_HARDWARE_MODULE_ID_REMOTE_SUBMIX, mHwModules[j]->mName) == 0
   2448                             && mHwModules[j]->mHandle != 0) {
   2449                         rSubmixModule = mHwModules[j];
   2450                         break;
   2451                     }
   2452                 }
   2453             }
   2454             if (rSubmixModule == 0) {
   2455                 res = INVALID_OPERATION;
   2456                 continue;
   2457             }
   2458 
   2459             String8 address = mixes[i].mDeviceAddress;
   2460 
   2461             if (mPolicyMixes.unregisterMix(address) != NO_ERROR) {
   2462                 res = INVALID_OPERATION;
   2463                 continue;
   2464             }
   2465 
   2466             if (getDeviceConnectionState(AUDIO_DEVICE_IN_REMOTE_SUBMIX, address.string()) ==
   2467                     AUDIO_POLICY_DEVICE_STATE_AVAILABLE)  {
   2468                 setDeviceConnectionStateInt(AUDIO_DEVICE_IN_REMOTE_SUBMIX,
   2469                         AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
   2470                         address.string(), "remote-submix");
   2471             }
   2472             if (getDeviceConnectionState(AUDIO_DEVICE_OUT_REMOTE_SUBMIX, address.string()) ==
   2473                     AUDIO_POLICY_DEVICE_STATE_AVAILABLE)  {
   2474                 setDeviceConnectionStateInt(AUDIO_DEVICE_OUT_REMOTE_SUBMIX,
   2475                         AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
   2476                         address.string(), "remote-submix");
   2477             }
   2478             rSubmixModule->removeOutputProfile(address);
   2479             rSubmixModule->removeInputProfile(address);
   2480 
   2481         } if ((mixes[i].mRouteFlags & MIX_ROUTE_FLAG_RENDER) == MIX_ROUTE_FLAG_RENDER) {
   2482             if (mPolicyMixes.unregisterMix(mixes[i].mDeviceAddress) != NO_ERROR) {
   2483                 res = INVALID_OPERATION;
   2484                 continue;
   2485             }
   2486         }
   2487     }
   2488     return res;
   2489 }
   2490 
   2491 
   2492 status_t AudioPolicyManager::dump(int fd)
   2493 {
   2494     const size_t SIZE = 256;
   2495     char buffer[SIZE];
   2496     String8 result;
   2497 
   2498     snprintf(buffer, SIZE, "\nAudioPolicyManager Dump: %p\n", this);
   2499     result.append(buffer);
   2500 
   2501     snprintf(buffer, SIZE, " Primary Output: %d\n",
   2502              hasPrimaryOutput() ? mPrimaryOutput->mIoHandle : AUDIO_IO_HANDLE_NONE);
   2503     result.append(buffer);
   2504     std::string stateLiteral;
   2505     AudioModeConverter::toString(mEngine->getPhoneState(), stateLiteral);
   2506     snprintf(buffer, SIZE, " Phone state: %s\n", stateLiteral.c_str());
   2507     result.append(buffer);
   2508     snprintf(buffer, SIZE, " Force use for communications %d\n",
   2509              mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_COMMUNICATION));
   2510     result.append(buffer);
   2511     snprintf(buffer, SIZE, " Force use for media %d\n", mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_MEDIA));
   2512     result.append(buffer);
   2513     snprintf(buffer, SIZE, " Force use for record %d\n", mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_RECORD));
   2514     result.append(buffer);
   2515     snprintf(buffer, SIZE, " Force use for dock %d\n", mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_DOCK));
   2516     result.append(buffer);
   2517     snprintf(buffer, SIZE, " Force use for system %d\n", mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_SYSTEM));
   2518     result.append(buffer);
   2519     snprintf(buffer, SIZE, " Force use for hdmi system audio %d\n",
   2520             mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_HDMI_SYSTEM_AUDIO));
   2521     result.append(buffer);
   2522     snprintf(buffer, SIZE, " Force use for encoded surround output %d\n",
   2523             mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_ENCODED_SURROUND));
   2524     result.append(buffer);
   2525     snprintf(buffer, SIZE, " TTS output %s\n", mTtsOutputAvailable ? "available" : "not available");
   2526     result.append(buffer);
   2527     snprintf(buffer, SIZE, " Master mono: %s\n", mMasterMono ? "on" : "off");
   2528     result.append(buffer);
   2529 
   2530     write(fd, result.string(), result.size());
   2531 
   2532     mAvailableOutputDevices.dump(fd, String8("Available output"));
   2533     mAvailableInputDevices.dump(fd, String8("Available input"));
   2534     mHwModules.dump(fd);
   2535     mOutputs.dump(fd);
   2536     mInputs.dump(fd);
   2537     mVolumeCurves->dump(fd);
   2538     mEffects.dump(fd);
   2539     mAudioPatches.dump(fd);
   2540     mPolicyMixes.dump(fd);
   2541 
   2542     return NO_ERROR;
   2543 }
   2544 
   2545 // This function checks for the parameters which can be offloaded.
   2546 // This can be enhanced depending on the capability of the DSP and policy
   2547 // of the system.
   2548 bool AudioPolicyManager::isOffloadSupported(const audio_offload_info_t& offloadInfo)
   2549 {
   2550     ALOGV("isOffloadSupported: SR=%u, CM=0x%x, Format=0x%x, StreamType=%d,"
   2551      " BitRate=%u, duration=%" PRId64 " us, has_video=%d",
   2552      offloadInfo.sample_rate, offloadInfo.channel_mask,
   2553      offloadInfo.format,
   2554      offloadInfo.stream_type, offloadInfo.bit_rate, offloadInfo.duration_us,
   2555      offloadInfo.has_video);
   2556 
   2557     if (mMasterMono) {
   2558         return false; // no offloading if mono is set.
   2559     }
   2560 
   2561     // Check if offload has been disabled
   2562     char propValue[PROPERTY_VALUE_MAX];
   2563     if (property_get("audio.offload.disable", propValue, "0")) {
   2564         if (atoi(propValue) != 0) {
   2565             ALOGV("offload disabled by audio.offload.disable=%s", propValue );
   2566             return false;
   2567         }
   2568     }
   2569 
   2570     // Check if stream type is music, then only allow offload as of now.
   2571     if (offloadInfo.stream_type != AUDIO_STREAM_MUSIC)
   2572     {
   2573         ALOGV("isOffloadSupported: stream_type != MUSIC, returning false");
   2574         return false;
   2575     }
   2576 
   2577     //TODO: enable audio offloading with video when ready
   2578     const bool allowOffloadWithVideo =
   2579             property_get_bool("audio.offload.video", false /* default_value */);
   2580     if (offloadInfo.has_video && !allowOffloadWithVideo) {
   2581         ALOGV("isOffloadSupported: has_video == true, returning false");
   2582         return false;
   2583     }
   2584 
   2585     //If duration is less than minimum value defined in property, return false
   2586     if (property_get("audio.offload.min.duration.secs", propValue, NULL)) {
   2587         if (offloadInfo.duration_us < (atoi(propValue) * 1000000 )) {
   2588             ALOGV("Offload denied by duration < audio.offload.min.duration.secs(=%s)", propValue);
   2589             return false;
   2590         }
   2591     } else if (offloadInfo.duration_us < OFFLOAD_DEFAULT_MIN_DURATION_SECS * 1000000) {
   2592         ALOGV("Offload denied by duration < default min(=%u)", OFFLOAD_DEFAULT_MIN_DURATION_SECS);
   2593         return false;
   2594     }
   2595 
   2596     // Do not allow offloading if one non offloadable effect is enabled. This prevents from
   2597     // creating an offloaded track and tearing it down immediately after start when audioflinger
   2598     // detects there is an active non offloadable effect.
   2599     // FIXME: We should check the audio session here but we do not have it in this context.
   2600     // This may prevent offloading in rare situations where effects are left active by apps
   2601     // in the background.
   2602     if (mEffects.isNonOffloadableEffectEnabled()) {
   2603         return false;
   2604     }
   2605 
   2606     // See if there is a profile to support this.
   2607     // AUDIO_DEVICE_NONE
   2608     sp<IOProfile> profile = getProfileForDirectOutput(AUDIO_DEVICE_NONE /*ignore device */,
   2609                                             offloadInfo.sample_rate,
   2610                                             offloadInfo.format,
   2611                                             offloadInfo.channel_mask,
   2612                                             AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD);
   2613     ALOGV("isOffloadSupported() profile %sfound", profile != 0 ? "" : "NOT ");
   2614     return (profile != 0);
   2615 }
   2616 
   2617 status_t AudioPolicyManager::listAudioPorts(audio_port_role_t role,
   2618                                             audio_port_type_t type,
   2619                                             unsigned int *num_ports,
   2620                                             struct audio_port *ports,
   2621                                             unsigned int *generation)
   2622 {
   2623     if (num_ports == NULL || (*num_ports != 0 && ports == NULL) ||
   2624             generation == NULL) {
   2625         return BAD_VALUE;
   2626     }
   2627     ALOGV("listAudioPorts() role %d type %d num_ports %d ports %p", role, type, *num_ports, ports);
   2628     if (ports == NULL) {
   2629         *num_ports = 0;
   2630     }
   2631 
   2632     size_t portsWritten = 0;
   2633     size_t portsMax = *num_ports;
   2634     *num_ports = 0;
   2635     if (type == AUDIO_PORT_TYPE_NONE || type == AUDIO_PORT_TYPE_DEVICE) {
   2636         // do not report devices with type AUDIO_DEVICE_IN_STUB or AUDIO_DEVICE_OUT_STUB
   2637         // as they are used by stub HALs by convention
   2638         if (role == AUDIO_PORT_ROLE_SINK || role == AUDIO_PORT_ROLE_NONE) {
   2639             for (size_t i = 0; i < mAvailableOutputDevices.size(); i++) {
   2640                 if (mAvailableOutputDevices[i]->type() == AUDIO_DEVICE_OUT_STUB) {
   2641                     continue;
   2642                 }
   2643                 if (portsWritten < portsMax) {
   2644                     mAvailableOutputDevices[i]->toAudioPort(&ports[portsWritten++]);
   2645                 }
   2646                 (*num_ports)++;
   2647             }
   2648         }
   2649         if (role == AUDIO_PORT_ROLE_SOURCE || role == AUDIO_PORT_ROLE_NONE) {
   2650             for (size_t i = 0; i < mAvailableInputDevices.size(); i++) {
   2651                 if (mAvailableInputDevices[i]->type() == AUDIO_DEVICE_IN_STUB) {
   2652                     continue;
   2653                 }
   2654                 if (portsWritten < portsMax) {
   2655                     mAvailableInputDevices[i]->toAudioPort(&ports[portsWritten++]);
   2656                 }
   2657                 (*num_ports)++;
   2658             }
   2659         }
   2660     }
   2661     if (type == AUDIO_PORT_TYPE_NONE || type == AUDIO_PORT_TYPE_MIX) {
   2662         if (role == AUDIO_PORT_ROLE_SINK || role == AUDIO_PORT_ROLE_NONE) {
   2663             for (size_t i = 0; i < mInputs.size() && portsWritten < portsMax; i++) {
   2664                 mInputs[i]->toAudioPort(&ports[portsWritten++]);
   2665             }
   2666             *num_ports += mInputs.size();
   2667         }
   2668         if (role == AUDIO_PORT_ROLE_SOURCE || role == AUDIO_PORT_ROLE_NONE) {
   2669             size_t numOutputs = 0;
   2670             for (size_t i = 0; i < mOutputs.size(); i++) {
   2671                 if (!mOutputs[i]->isDuplicated()) {
   2672                     numOutputs++;
   2673                     if (portsWritten < portsMax) {
   2674                         mOutputs[i]->toAudioPort(&ports[portsWritten++]);
   2675                     }
   2676                 }
   2677             }
   2678             *num_ports += numOutputs;
   2679         }
   2680     }
   2681     *generation = curAudioPortGeneration();
   2682     ALOGV("listAudioPorts() got %zu ports needed %d", portsWritten, *num_ports);
   2683     return NO_ERROR;
   2684 }
   2685 
   2686 status_t AudioPolicyManager::getAudioPort(struct audio_port *port __unused)
   2687 {
   2688     return NO_ERROR;
   2689 }
   2690 
   2691 status_t AudioPolicyManager::createAudioPatch(const struct audio_patch *patch,
   2692                                                audio_patch_handle_t *handle,
   2693                                                uid_t uid)
   2694 {
   2695     ALOGV("createAudioPatch()");
   2696 
   2697     if (handle == NULL || patch == NULL) {
   2698         return BAD_VALUE;
   2699     }
   2700     ALOGV("createAudioPatch() num sources %d num sinks %d", patch->num_sources, patch->num_sinks);
   2701 
   2702     if (patch->num_sources == 0 || patch->num_sources > AUDIO_PATCH_PORTS_MAX ||
   2703             patch->num_sinks == 0 || patch->num_sinks > AUDIO_PATCH_PORTS_MAX) {
   2704         return BAD_VALUE;
   2705     }
   2706     // only one source per audio patch supported for now
   2707     if (patch->num_sources > 1) {
   2708         return INVALID_OPERATION;
   2709     }
   2710 
   2711     if (patch->sources[0].role != AUDIO_PORT_ROLE_SOURCE) {
   2712         return INVALID_OPERATION;
   2713     }
   2714     for (size_t i = 0; i < patch->num_sinks; i++) {
   2715         if (patch->sinks[i].role != AUDIO_PORT_ROLE_SINK) {
   2716             return INVALID_OPERATION;
   2717         }
   2718     }
   2719 
   2720     sp<AudioPatch> patchDesc;
   2721     ssize_t index = mAudioPatches.indexOfKey(*handle);
   2722 
   2723     ALOGV("createAudioPatch source id %d role %d type %d", patch->sources[0].id,
   2724                                                            patch->sources[0].role,
   2725                                                            patch->sources[0].type);
   2726 #if LOG_NDEBUG == 0
   2727     for (size_t i = 0; i < patch->num_sinks; i++) {
   2728         ALOGV("createAudioPatch sink %zu: id %d role %d type %d", i, patch->sinks[i].id,
   2729                                                              patch->sinks[i].role,
   2730                                                              patch->sinks[i].type);
   2731     }
   2732 #endif
   2733 
   2734     if (index >= 0) {
   2735         patchDesc = mAudioPatches.valueAt(index);
   2736         ALOGV("createAudioPatch() mUidCached %d patchDesc->mUid %d uid %d",
   2737                                                                   mUidCached, patchDesc->mUid, uid);
   2738         if (patchDesc->mUid != mUidCached && uid != patchDesc->mUid) {
   2739             return INVALID_OPERATION;
   2740         }
   2741     } else {
   2742         *handle = AUDIO_PATCH_HANDLE_NONE;
   2743     }
   2744 
   2745     if (patch->sources[0].type == AUDIO_PORT_TYPE_MIX) {
   2746         sp<SwAudioOutputDescriptor> outputDesc = mOutputs.getOutputFromId(patch->sources[0].id);
   2747         if (outputDesc == NULL) {
   2748             ALOGV("createAudioPatch() output not found for id %d", patch->sources[0].id);
   2749             return BAD_VALUE;
   2750         }
   2751         ALOG_ASSERT(!outputDesc->isDuplicated(),"duplicated output %d in source in ports",
   2752                                                 outputDesc->mIoHandle);
   2753         if (patchDesc != 0) {
   2754             if (patchDesc->mPatch.sources[0].id != patch->sources[0].id) {
   2755                 ALOGV("createAudioPatch() source id differs for patch current id %d new id %d",
   2756                                           patchDesc->mPatch.sources[0].id, patch->sources[0].id);
   2757                 return BAD_VALUE;
   2758             }
   2759         }
   2760         DeviceVector devices;
   2761         for (size_t i = 0; i < patch->num_sinks; i++) {
   2762             // Only support mix to devices connection
   2763             // TODO add support for mix to mix connection
   2764             if (patch->sinks[i].type != AUDIO_PORT_TYPE_DEVICE) {
   2765                 ALOGV("createAudioPatch() source mix but sink is not a device");
   2766                 return INVALID_OPERATION;
   2767             }
   2768             sp<DeviceDescriptor> devDesc =
   2769                     mAvailableOutputDevices.getDeviceFromId(patch->sinks[i].id);
   2770             if (devDesc == 0) {
   2771                 ALOGV("createAudioPatch() out device not found for id %d", patch->sinks[i].id);
   2772                 return BAD_VALUE;
   2773             }
   2774 
   2775             if (!outputDesc->mProfile->isCompatibleProfile(devDesc->type(),
   2776                                                            devDesc->mAddress,
   2777                                                            patch->sources[0].sample_rate,
   2778                                                            NULL,  // updatedSamplingRate
   2779                                                            patch->sources[0].format,
   2780                                                            NULL,  // updatedFormat
   2781                                                            patch->sources[0].channel_mask,
   2782                                                            NULL,  // updatedChannelMask
   2783                                                            AUDIO_OUTPUT_FLAG_NONE /*FIXME*/)) {
   2784                 ALOGV("createAudioPatch() profile not supported for device %08x",
   2785                         devDesc->type());
   2786                 return INVALID_OPERATION;
   2787             }
   2788             devices.add(devDesc);
   2789         }
   2790         if (devices.size() == 0) {
   2791             return INVALID_OPERATION;
   2792         }
   2793 
   2794         // TODO: reconfigure output format and channels here
   2795         ALOGV("createAudioPatch() setting device %08x on output %d",
   2796               devices.types(), outputDesc->mIoHandle);
   2797         setOutputDevice(outputDesc, devices.types(), true, 0, handle);
   2798         index = mAudioPatches.indexOfKey(*handle);
   2799         if (index >= 0) {
   2800             if (patchDesc != 0 && patchDesc != mAudioPatches.valueAt(index)) {
   2801                 ALOGW("createAudioPatch() setOutputDevice() did not reuse the patch provided");
   2802             }
   2803             patchDesc = mAudioPatches.valueAt(index);
   2804             patchDesc->mUid = uid;
   2805             ALOGV("createAudioPatch() success");
   2806         } else {
   2807             ALOGW("createAudioPatch() setOutputDevice() failed to create a patch");
   2808             return INVALID_OPERATION;
   2809         }
   2810     } else if (patch->sources[0].type == AUDIO_PORT_TYPE_DEVICE) {
   2811         if (patch->sinks[0].type == AUDIO_PORT_TYPE_MIX) {
   2812             // input device to input mix connection
   2813             // only one sink supported when connecting an input device to a mix
   2814             if (patch->num_sinks > 1) {
   2815                 return INVALID_OPERATION;
   2816             }
   2817             sp<AudioInputDescriptor> inputDesc = mInputs.getInputFromId(patch->sinks[0].id);
   2818             if (inputDesc == NULL) {
   2819                 return BAD_VALUE;
   2820             }
   2821             if (patchDesc != 0) {
   2822                 if (patchDesc->mPatch.sinks[0].id != patch->sinks[0].id) {
   2823                     return BAD_VALUE;
   2824                 }
   2825             }
   2826             sp<DeviceDescriptor> devDesc =
   2827                     mAvailableInputDevices.getDeviceFromId(patch->sources[0].id);
   2828             if (devDesc == 0) {
   2829                 return BAD_VALUE;
   2830             }
   2831 
   2832             if (!inputDesc->mProfile->isCompatibleProfile(devDesc->type(),
   2833                                                           devDesc->mAddress,
   2834                                                           patch->sinks[0].sample_rate,
   2835                                                           NULL, /*updatedSampleRate*/
   2836                                                           patch->sinks[0].format,
   2837                                                           NULL, /*updatedFormat*/
   2838                                                           patch->sinks[0].channel_mask,
   2839                                                           NULL, /*updatedChannelMask*/
   2840                                                           // FIXME for the parameter type,
   2841                                                           // and the NONE
   2842                                                           (audio_output_flags_t)
   2843                                                             AUDIO_INPUT_FLAG_NONE)) {
   2844                 return INVALID_OPERATION;
   2845             }
   2846             // TODO: reconfigure output format and channels here
   2847             ALOGV("createAudioPatch() setting device %08x on output %d",
   2848                                                   devDesc->type(), inputDesc->mIoHandle);
   2849             setInputDevice(inputDesc->mIoHandle, devDesc->type(), true, handle);
   2850             index = mAudioPatches.indexOfKey(*handle);
   2851             if (index >= 0) {
   2852                 if (patchDesc != 0 && patchDesc != mAudioPatches.valueAt(index)) {
   2853                     ALOGW("createAudioPatch() setInputDevice() did not reuse the patch provided");
   2854                 }
   2855                 patchDesc = mAudioPatches.valueAt(index);
   2856                 patchDesc->mUid = uid;
   2857                 ALOGV("createAudioPatch() success");
   2858             } else {
   2859                 ALOGW("createAudioPatch() setInputDevice() failed to create a patch");
   2860                 return INVALID_OPERATION;
   2861             }
   2862         } else if (patch->sinks[0].type == AUDIO_PORT_TYPE_DEVICE) {
   2863             // device to device connection
   2864             if (patchDesc != 0) {
   2865                 if (patchDesc->mPatch.sources[0].id != patch->sources[0].id) {
   2866                     return BAD_VALUE;
   2867                 }
   2868             }
   2869             sp<DeviceDescriptor> srcDeviceDesc =
   2870                     mAvailableInputDevices.getDeviceFromId(patch->sources[0].id);
   2871             if (srcDeviceDesc == 0) {
   2872                 return BAD_VALUE;
   2873             }
   2874 
   2875             //update source and sink with our own data as the data passed in the patch may
   2876             // be incomplete.
   2877             struct audio_patch newPatch = *patch;
   2878             srcDeviceDesc->toAudioPortConfig(&newPatch.sources[0], &patch->sources[0]);
   2879 
   2880             for (size_t i = 0; i < patch->num_sinks; i++) {
   2881                 if (patch->sinks[i].type != AUDIO_PORT_TYPE_DEVICE) {
   2882                     ALOGV("createAudioPatch() source device but one sink is not a device");
   2883                     return INVALID_OPERATION;
   2884                 }
   2885 
   2886                 sp<DeviceDescriptor> sinkDeviceDesc =
   2887                         mAvailableOutputDevices.getDeviceFromId(patch->sinks[i].id);
   2888                 if (sinkDeviceDesc == 0) {
   2889                     return BAD_VALUE;
   2890                 }
   2891                 sinkDeviceDesc->toAudioPortConfig(&newPatch.sinks[i], &patch->sinks[i]);
   2892 
   2893                 // create a software bridge in PatchPanel if:
   2894                 // - source and sink devices are on differnt HW modules OR
   2895                 // - audio HAL version is < 3.0
   2896                 if (!srcDeviceDesc->hasSameHwModuleAs(sinkDeviceDesc) ||
   2897                         (srcDeviceDesc->mModule->getHalVersionMajor() < 3)) {
   2898                     // support only one sink device for now to simplify output selection logic
   2899                     if (patch->num_sinks > 1) {
   2900                         return INVALID_OPERATION;
   2901                     }
   2902                     SortedVector<audio_io_handle_t> outputs =
   2903                                             getOutputsForDevice(sinkDeviceDesc->type(), mOutputs);
   2904                     // if the sink device is reachable via an opened output stream, request to go via
   2905                     // this output stream by adding a second source to the patch description
   2906                     audio_io_handle_t output = selectOutput(outputs,
   2907                                                             AUDIO_OUTPUT_FLAG_NONE,
   2908                                                             AUDIO_FORMAT_INVALID);
   2909                     if (output != AUDIO_IO_HANDLE_NONE) {
   2910                         sp<AudioOutputDescriptor> outputDesc = mOutputs.valueFor(output);
   2911                         if (outputDesc->isDuplicated()) {
   2912                             return INVALID_OPERATION;
   2913                         }
   2914                         outputDesc->toAudioPortConfig(&newPatch.sources[1], &patch->sources[0]);
   2915                         newPatch.sources[1].ext.mix.usecase.stream = AUDIO_STREAM_PATCH;
   2916                         newPatch.num_sources = 2;
   2917                     }
   2918                 }
   2919             }
   2920             // TODO: check from routing capabilities in config file and other conflicting patches
   2921 
   2922             audio_patch_handle_t afPatchHandle = AUDIO_PATCH_HANDLE_NONE;
   2923             if (index >= 0) {
   2924                 afPatchHandle = patchDesc->mAfPatchHandle;
   2925             }
   2926 
   2927             status_t status = mpClientInterface->createAudioPatch(&newPatch,
   2928                                                                   &afPatchHandle,
   2929                                                                   0);
   2930             ALOGV("createAudioPatch() patch panel returned %d patchHandle %d",
   2931                                                                   status, afPatchHandle);
   2932             if (status == NO_ERROR) {
   2933                 if (index < 0) {
   2934                     patchDesc = new AudioPatch(&newPatch, uid);
   2935                     addAudioPatch(patchDesc->mHandle, patchDesc);
   2936                 } else {
   2937                     patchDesc->mPatch = newPatch;
   2938                 }
   2939                 patchDesc->mAfPatchHandle = afPatchHandle;
   2940                 *handle = patchDesc->mHandle;
   2941                 nextAudioPortGeneration();
   2942                 mpClientInterface->onAudioPatchListUpdate();
   2943             } else {
   2944                 ALOGW("createAudioPatch() patch panel could not connect device patch, error %d",
   2945                 status);
   2946                 return INVALID_OPERATION;
   2947             }
   2948         } else {
   2949             return BAD_VALUE;
   2950         }
   2951     } else {
   2952         return BAD_VALUE;
   2953     }
   2954     return NO_ERROR;
   2955 }
   2956 
   2957 status_t AudioPolicyManager::releaseAudioPatch(audio_patch_handle_t handle,
   2958                                                   uid_t uid)
   2959 {
   2960     ALOGV("releaseAudioPatch() patch %d", handle);
   2961 
   2962     ssize_t index = mAudioPatches.indexOfKey(handle);
   2963 
   2964     if (index < 0) {
   2965         return BAD_VALUE;
   2966     }
   2967     sp<AudioPatch> patchDesc = mAudioPatches.valueAt(index);
   2968     ALOGV("releaseAudioPatch() mUidCached %d patchDesc->mUid %d uid %d",
   2969           mUidCached, patchDesc->mUid, uid);
   2970     if (patchDesc->mUid != mUidCached && uid != patchDesc->mUid) {
   2971         return INVALID_OPERATION;
   2972     }
   2973 
   2974     struct audio_patch *patch = &patchDesc->mPatch;
   2975     patchDesc->mUid = mUidCached;
   2976     if (patch->sources[0].type == AUDIO_PORT_TYPE_MIX) {
   2977         sp<SwAudioOutputDescriptor> outputDesc = mOutputs.getOutputFromId(patch->sources[0].id);
   2978         if (outputDesc == NULL) {
   2979             ALOGV("releaseAudioPatch() output not found for id %d", patch->sources[0].id);
   2980             return BAD_VALUE;
   2981         }
   2982 
   2983         setOutputDevice(outputDesc,
   2984                         getNewOutputDevice(outputDesc, true /*fromCache*/),
   2985                        true,
   2986                        0,
   2987                        NULL);
   2988     } else if (patch->sources[0].type == AUDIO_PORT_TYPE_DEVICE) {
   2989         if (patch->sinks[0].type == AUDIO_PORT_TYPE_MIX) {
   2990             sp<AudioInputDescriptor> inputDesc = mInputs.getInputFromId(patch->sinks[0].id);
   2991             if (inputDesc == NULL) {
   2992                 ALOGV("releaseAudioPatch() input not found for id %d", patch->sinks[0].id);
   2993                 return BAD_VALUE;
   2994             }
   2995             setInputDevice(inputDesc->mIoHandle,
   2996                            getNewInputDevice(inputDesc),
   2997                            true,
   2998                            NULL);
   2999         } else if (patch->sinks[0].type == AUDIO_PORT_TYPE_DEVICE) {
   3000             status_t status = mpClientInterface->releaseAudioPatch(patchDesc->mAfPatchHandle, 0);
   3001             ALOGV("releaseAudioPatch() patch panel returned %d patchHandle %d",
   3002                                                               status, patchDesc->mAfPatchHandle);
   3003             removeAudioPatch(patchDesc->mHandle);
   3004             nextAudioPortGeneration();
   3005             mpClientInterface->onAudioPatchListUpdate();
   3006         } else {
   3007             return BAD_VALUE;
   3008         }
   3009     } else {
   3010         return BAD_VALUE;
   3011     }
   3012     return NO_ERROR;
   3013 }
   3014 
   3015 status_t AudioPolicyManager::listAudioPatches(unsigned int *num_patches,
   3016                                               struct audio_patch *patches,
   3017                                               unsigned int *generation)
   3018 {
   3019     if (generation == NULL) {
   3020         return BAD_VALUE;
   3021     }
   3022     *generation = curAudioPortGeneration();
   3023     return mAudioPatches.listAudioPatches(num_patches, patches);
   3024 }
   3025 
   3026 status_t AudioPolicyManager::setAudioPortConfig(const struct audio_port_config *config)
   3027 {
   3028     ALOGV("setAudioPortConfig()");
   3029 
   3030     if (config == NULL) {
   3031         return BAD_VALUE;
   3032     }
   3033     ALOGV("setAudioPortConfig() on port handle %d", config->id);
   3034     // Only support gain configuration for now
   3035     if (config->config_mask != AUDIO_PORT_CONFIG_GAIN) {
   3036         return INVALID_OPERATION;
   3037     }
   3038 
   3039     sp<AudioPortConfig> audioPortConfig;
   3040     if (config->type == AUDIO_PORT_TYPE_MIX) {
   3041         if (config->role == AUDIO_PORT_ROLE_SOURCE) {
   3042             sp<SwAudioOutputDescriptor> outputDesc = mOutputs.getOutputFromId(config->id);
   3043             if (outputDesc == NULL) {
   3044                 return BAD_VALUE;
   3045             }
   3046             ALOG_ASSERT(!outputDesc->isDuplicated(),
   3047                         "setAudioPortConfig() called on duplicated output %d",
   3048                         outputDesc->mIoHandle);
   3049             audioPortConfig = outputDesc;
   3050         } else if (config->role == AUDIO_PORT_ROLE_SINK) {
   3051             sp<AudioInputDescriptor> inputDesc = mInputs.getInputFromId(config->id);
   3052             if (inputDesc == NULL) {
   3053                 return BAD_VALUE;
   3054             }
   3055             audioPortConfig = inputDesc;
   3056         } else {
   3057             return BAD_VALUE;
   3058         }
   3059     } else if (config->type == AUDIO_PORT_TYPE_DEVICE) {
   3060         sp<DeviceDescriptor> deviceDesc;
   3061         if (config->role == AUDIO_PORT_ROLE_SOURCE) {
   3062             deviceDesc = mAvailableInputDevices.getDeviceFromId(config->id);
   3063         } else if (config->role == AUDIO_PORT_ROLE_SINK) {
   3064             deviceDesc = mAvailableOutputDevices.getDeviceFromId(config->id);
   3065         } else {
   3066             return BAD_VALUE;
   3067         }
   3068         if (deviceDesc == NULL) {
   3069             return BAD_VALUE;
   3070         }
   3071         audioPortConfig = deviceDesc;
   3072     } else {
   3073         return BAD_VALUE;
   3074     }
   3075 
   3076     struct audio_port_config backupConfig;
   3077     status_t status = audioPortConfig->applyAudioPortConfig(config, &backupConfig);
   3078     if (status == NO_ERROR) {
   3079         struct audio_port_config newConfig;
   3080         audioPortConfig->toAudioPortConfig(&newConfig, config);
   3081         status = mpClientInterface->setAudioPortConfig(&newConfig, 0);
   3082     }
   3083     if (status != NO_ERROR) {
   3084         audioPortConfig->applyAudioPortConfig(&backupConfig);
   3085     }
   3086 
   3087     return status;
   3088 }
   3089 
   3090 void AudioPolicyManager::releaseResourcesForUid(uid_t uid)
   3091 {
   3092     clearAudioSources(uid);
   3093     clearAudioPatches(uid);
   3094     clearSessionRoutes(uid);
   3095 }
   3096 
   3097 void AudioPolicyManager::clearAudioPatches(uid_t uid)
   3098 {
   3099     for (ssize_t i = (ssize_t)mAudioPatches.size() - 1; i >= 0; i--)  {
   3100         sp<AudioPatch> patchDesc = mAudioPatches.valueAt(i);
   3101         if (patchDesc->mUid == uid) {
   3102             releaseAudioPatch(mAudioPatches.keyAt(i), uid);
   3103         }
   3104     }
   3105 }
   3106 
   3107 void AudioPolicyManager::checkStrategyRoute(routing_strategy strategy,
   3108                                             audio_io_handle_t ouptutToSkip)
   3109 {
   3110     audio_devices_t device = getDeviceForStrategy(strategy, false /*fromCache*/);
   3111     SortedVector<audio_io_handle_t> outputs = getOutputsForDevice(device, mOutputs);
   3112     for (size_t j = 0; j < mOutputs.size(); j++) {
   3113         if (mOutputs.keyAt(j) == ouptutToSkip) {
   3114             continue;
   3115         }
   3116         sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueAt(j);
   3117         if (!isStrategyActive(outputDesc, (routing_strategy)strategy)) {
   3118             continue;
   3119         }
   3120         // If the default device for this strategy is on another output mix,
   3121         // invalidate all tracks in this strategy to force re connection.
   3122         // Otherwise select new device on the output mix.
   3123         if (outputs.indexOf(mOutputs.keyAt(j)) < 0) {
   3124             for (int stream = 0; stream < AUDIO_STREAM_FOR_POLICY_CNT; stream++) {
   3125                 if (getStrategy((audio_stream_type_t)stream) == strategy) {
   3126                     mpClientInterface->invalidateStream((audio_stream_type_t)stream);
   3127                 }
   3128             }
   3129         } else {
   3130             audio_devices_t newDevice = getNewOutputDevice(outputDesc, false /*fromCache*/);
   3131             setOutputDevice(outputDesc, newDevice, false);
   3132         }
   3133     }
   3134 }
   3135 
   3136 void AudioPolicyManager::clearSessionRoutes(uid_t uid)
   3137 {
   3138     // remove output routes associated with this uid
   3139     SortedVector<routing_strategy> affectedStrategies;
   3140     for (ssize_t i = (ssize_t)mOutputRoutes.size() - 1; i >= 0; i--)  {
   3141         sp<SessionRoute> route = mOutputRoutes.valueAt(i);
   3142         if (route->mUid == uid) {
   3143             mOutputRoutes.removeItemsAt(i);
   3144             if (route->mDeviceDescriptor != 0) {
   3145                 affectedStrategies.add(getStrategy(route->mStreamType));
   3146             }
   3147         }
   3148     }
   3149     // reroute outputs if necessary
   3150     for (size_t i = 0; i < affectedStrategies.size(); i++) {
   3151         checkStrategyRoute(affectedStrategies[i], AUDIO_IO_HANDLE_NONE);
   3152     }
   3153 
   3154     // remove input routes associated with this uid
   3155     SortedVector<audio_source_t> affectedSources;
   3156     for (ssize_t i = (ssize_t)mInputRoutes.size() - 1; i >= 0; i--)  {
   3157         sp<SessionRoute> route = mInputRoutes.valueAt(i);
   3158         if (route->mUid == uid) {
   3159             mInputRoutes.removeItemsAt(i);
   3160             if (route->mDeviceDescriptor != 0) {
   3161                 affectedSources.add(route->mSource);
   3162             }
   3163         }
   3164     }
   3165     // reroute inputs if necessary
   3166     SortedVector<audio_io_handle_t> inputsToClose;
   3167     for (size_t i = 0; i < mInputs.size(); i++) {
   3168         sp<AudioInputDescriptor> inputDesc = mInputs.valueAt(i);
   3169         if (affectedSources.indexOf(inputDesc->inputSource()) >= 0) {
   3170             inputsToClose.add(inputDesc->mIoHandle);
   3171         }
   3172     }
   3173     for (size_t i = 0; i < inputsToClose.size(); i++) {
   3174         closeInput(inputsToClose[i]);
   3175     }
   3176 }
   3177 
   3178 void AudioPolicyManager::clearAudioSources(uid_t uid)
   3179 {
   3180     for (ssize_t i = (ssize_t)mAudioSources.size() - 1; i >= 0; i--)  {
   3181         sp<AudioSourceDescriptor> sourceDesc = mAudioSources.valueAt(i);
   3182         if (sourceDesc->mUid == uid) {
   3183             stopAudioSource(mAudioSources.keyAt(i));
   3184         }
   3185     }
   3186 }
   3187 
   3188 status_t AudioPolicyManager::acquireSoundTriggerSession(audio_session_t *session,
   3189                                        audio_io_handle_t *ioHandle,
   3190                                        audio_devices_t *device)
   3191 {
   3192     *session = (audio_session_t)mpClientInterface->newAudioUniqueId(AUDIO_UNIQUE_ID_USE_SESSION);
   3193     *ioHandle = (audio_io_handle_t)mpClientInterface->newAudioUniqueId(AUDIO_UNIQUE_ID_USE_INPUT);
   3194     *device = getDeviceAndMixForInputSource(AUDIO_SOURCE_HOTWORD);
   3195 
   3196     return mSoundTriggerSessions.acquireSession(*session, *ioHandle);
   3197 }
   3198 
   3199 status_t AudioPolicyManager::startAudioSource(const struct audio_port_config *source,
   3200                                   const audio_attributes_t *attributes,
   3201                                   audio_patch_handle_t *handle,
   3202                                   uid_t uid)
   3203 {
   3204     ALOGV("%s source %p attributes %p handle %p", __FUNCTION__, source, attributes, handle);
   3205     if (source == NULL || attributes == NULL || handle == NULL) {
   3206         return BAD_VALUE;
   3207     }
   3208 
   3209     *handle = AUDIO_PATCH_HANDLE_NONE;
   3210 
   3211     if (source->role != AUDIO_PORT_ROLE_SOURCE ||
   3212             source->type != AUDIO_PORT_TYPE_DEVICE) {
   3213         ALOGV("%s INVALID_OPERATION source->role %d source->type %d", __FUNCTION__, source->role, source->type);
   3214         return INVALID_OPERATION;
   3215     }
   3216 
   3217     sp<DeviceDescriptor> srcDeviceDesc =
   3218             mAvailableInputDevices.getDevice(source->ext.device.type,
   3219                                               String8(source->ext.device.address));
   3220     if (srcDeviceDesc == 0) {
   3221         ALOGV("%s source->ext.device.type %08x not found", __FUNCTION__, source->ext.device.type);
   3222         return BAD_VALUE;
   3223     }
   3224     sp<AudioSourceDescriptor> sourceDesc =
   3225             new AudioSourceDescriptor(srcDeviceDesc, attributes, uid);
   3226 
   3227     struct audio_patch dummyPatch;
   3228     sp<AudioPatch> patchDesc = new AudioPatch(&dummyPatch, uid);
   3229     sourceDesc->mPatchDesc = patchDesc;
   3230 
   3231     status_t status = connectAudioSource(sourceDesc);
   3232     if (status == NO_ERROR) {
   3233         mAudioSources.add(sourceDesc->getHandle(), sourceDesc);
   3234         *handle = sourceDesc->getHandle();
   3235     }
   3236     return status;
   3237 }
   3238 
   3239 status_t AudioPolicyManager::connectAudioSource(const sp<AudioSourceDescriptor>& sourceDesc)
   3240 {
   3241     ALOGV("%s handle %d", __FUNCTION__, sourceDesc->getHandle());
   3242 
   3243     // make sure we only have one patch per source.
   3244     disconnectAudioSource(sourceDesc);
   3245 
   3246     routing_strategy strategy = (routing_strategy) getStrategyForAttr(&sourceDesc->mAttributes);
   3247     audio_stream_type_t stream = streamTypefromAttributesInt(&sourceDesc->mAttributes);
   3248     sp<DeviceDescriptor> srcDeviceDesc = sourceDesc->mDevice;
   3249 
   3250     audio_devices_t sinkDevice = getDeviceForStrategy(strategy, true);
   3251     sp<DeviceDescriptor> sinkDeviceDesc =
   3252             mAvailableOutputDevices.getDevice(sinkDevice, String8(""));
   3253 
   3254     audio_patch_handle_t afPatchHandle = AUDIO_PATCH_HANDLE_NONE;
   3255     struct audio_patch *patch = &sourceDesc->mPatchDesc->mPatch;
   3256 
   3257     if (srcDeviceDesc->getAudioPort()->mModule->getHandle() ==
   3258             sinkDeviceDesc->getAudioPort()->mModule->getHandle() &&
   3259             srcDeviceDesc->getAudioPort()->mModule->getHalVersionMajor() >= 3 &&
   3260             srcDeviceDesc->getAudioPort()->mGains.size() > 0) {
   3261         ALOGV("%s AUDIO_DEVICE_API_VERSION_3_0", __FUNCTION__);
   3262         //   create patch between src device and output device
   3263         //   create Hwoutput and add to mHwOutputs
   3264     } else {
   3265         SortedVector<audio_io_handle_t> outputs = getOutputsForDevice(sinkDevice, mOutputs);
   3266         audio_io_handle_t output =
   3267                 selectOutput(outputs, AUDIO_OUTPUT_FLAG_NONE, AUDIO_FORMAT_INVALID);
   3268         if (output == AUDIO_IO_HANDLE_NONE) {
   3269             ALOGV("%s no output for device %08x", __FUNCTION__, sinkDevice);
   3270             return INVALID_OPERATION;
   3271         }
   3272         sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueFor(output);
   3273         if (outputDesc->isDuplicated()) {
   3274             ALOGV("%s output for device %08x is duplicated", __FUNCTION__, sinkDevice);
   3275             return INVALID_OPERATION;
   3276         }
   3277         // create a special patch with no sink and two sources:
   3278         // - the second source indicates to PatchPanel through which output mix this patch should
   3279         // be connected as well as the stream type for volume control
   3280         // - the sink is defined by whatever output device is currently selected for the output
   3281         // though which this patch is routed.
   3282         patch->num_sinks = 0;
   3283         patch->num_sources = 2;
   3284         srcDeviceDesc->toAudioPortConfig(&patch->sources[0], NULL);
   3285         outputDesc->toAudioPortConfig(&patch->sources[1], NULL);
   3286         patch->sources[1].ext.mix.usecase.stream = stream;
   3287         status_t status = mpClientInterface->createAudioPatch(patch,
   3288                                                               &afPatchHandle,
   3289                                                               0);
   3290         ALOGV("%s patch panel returned %d patchHandle %d", __FUNCTION__,
   3291                                                               status, afPatchHandle);
   3292         if (status != NO_ERROR) {
   3293             ALOGW("%s patch panel could not connect device patch, error %d",
   3294                   __FUNCTION__, status);
   3295             return INVALID_OPERATION;
   3296         }
   3297         uint32_t delayMs = 0;
   3298         status = startSource(outputDesc, stream, sinkDevice, NULL, &delayMs);
   3299 
   3300         if (status != NO_ERROR) {
   3301             mpClientInterface->releaseAudioPatch(sourceDesc->mPatchDesc->mAfPatchHandle, 0);
   3302             return status;
   3303         }
   3304         sourceDesc->mSwOutput = outputDesc;
   3305         if (delayMs != 0) {
   3306             usleep(delayMs * 1000);
   3307         }
   3308     }
   3309 
   3310     sourceDesc->mPatchDesc->mAfPatchHandle = afPatchHandle;
   3311     addAudioPatch(sourceDesc->mPatchDesc->mHandle, sourceDesc->mPatchDesc);
   3312 
   3313     return NO_ERROR;
   3314 }
   3315 
   3316 status_t AudioPolicyManager::stopAudioSource(audio_patch_handle_t handle __unused)
   3317 {
   3318     sp<AudioSourceDescriptor> sourceDesc = mAudioSources.valueFor(handle);
   3319     ALOGV("%s handle %d", __FUNCTION__, handle);
   3320     if (sourceDesc == 0) {
   3321         ALOGW("%s unknown source for handle %d", __FUNCTION__, handle);
   3322         return BAD_VALUE;
   3323     }
   3324     status_t status = disconnectAudioSource(sourceDesc);
   3325 
   3326     mAudioSources.removeItem(handle);
   3327     return status;
   3328 }
   3329 
   3330 status_t AudioPolicyManager::setMasterMono(bool mono)
   3331 {
   3332     if (mMasterMono == mono) {
   3333         return NO_ERROR;
   3334     }
   3335     mMasterMono = mono;
   3336     // if enabling mono we close all offloaded devices, which will invalidate the
   3337     // corresponding AudioTrack. The AudioTrack client/MediaPlayer is responsible
   3338     // for recreating the new AudioTrack as non-offloaded PCM.
   3339     //
   3340     // If disabling mono, we leave all tracks as is: we don't know which clients
   3341     // and tracks are able to be recreated as offloaded. The next "song" should
   3342     // play back offloaded.
   3343     if (mMasterMono) {
   3344         Vector<audio_io_handle_t> offloaded;
   3345         for (size_t i = 0; i < mOutputs.size(); ++i) {
   3346             sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
   3347             if (desc->mFlags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) {
   3348                 offloaded.push(desc->mIoHandle);
   3349             }
   3350         }
   3351         for (size_t i = 0; i < offloaded.size(); ++i) {
   3352             closeOutput(offloaded[i]);
   3353         }
   3354     }
   3355     // update master mono for all remaining outputs
   3356     for (size_t i = 0; i < mOutputs.size(); ++i) {
   3357         updateMono(mOutputs.keyAt(i));
   3358     }
   3359     return NO_ERROR;
   3360 }
   3361 
   3362 status_t AudioPolicyManager::getMasterMono(bool *mono)
   3363 {
   3364     *mono = mMasterMono;
   3365     return NO_ERROR;
   3366 }
   3367 
   3368 status_t AudioPolicyManager::disconnectAudioSource(const sp<AudioSourceDescriptor>& sourceDesc)
   3369 {
   3370     ALOGV("%s handle %d", __FUNCTION__, sourceDesc->getHandle());
   3371 
   3372     sp<AudioPatch> patchDesc = mAudioPatches.valueFor(sourceDesc->mPatchDesc->mHandle);
   3373     if (patchDesc == 0) {
   3374         ALOGW("%s source has no patch with handle %d", __FUNCTION__,
   3375               sourceDesc->mPatchDesc->mHandle);
   3376         return BAD_VALUE;
   3377     }
   3378     removeAudioPatch(sourceDesc->mPatchDesc->mHandle);
   3379 
   3380     audio_stream_type_t stream = streamTypefromAttributesInt(&sourceDesc->mAttributes);
   3381     sp<SwAudioOutputDescriptor> swOutputDesc = sourceDesc->mSwOutput.promote();
   3382     if (swOutputDesc != 0) {
   3383         stopSource(swOutputDesc, stream, false);
   3384         mpClientInterface->releaseAudioPatch(patchDesc->mAfPatchHandle, 0);
   3385     } else {
   3386         sp<HwAudioOutputDescriptor> hwOutputDesc = sourceDesc->mHwOutput.promote();
   3387         if (hwOutputDesc != 0) {
   3388           //   release patch between src device and output device
   3389           //   close Hwoutput and remove from mHwOutputs
   3390         } else {
   3391             ALOGW("%s source has neither SW nor HW output", __FUNCTION__);
   3392         }
   3393     }
   3394     return NO_ERROR;
   3395 }
   3396 
   3397 sp<AudioSourceDescriptor> AudioPolicyManager::getSourceForStrategyOnOutput(
   3398         audio_io_handle_t output, routing_strategy strategy)
   3399 {
   3400     sp<AudioSourceDescriptor> source;
   3401     for (size_t i = 0; i < mAudioSources.size(); i++)  {
   3402         sp<AudioSourceDescriptor> sourceDesc = mAudioSources.valueAt(i);
   3403         routing_strategy sourceStrategy =
   3404                 (routing_strategy) getStrategyForAttr(&sourceDesc->mAttributes);
   3405         sp<SwAudioOutputDescriptor> outputDesc = sourceDesc->mSwOutput.promote();
   3406         if (sourceStrategy == strategy && outputDesc != 0 && outputDesc->mIoHandle == output) {
   3407             source = sourceDesc;
   3408             break;
   3409         }
   3410     }
   3411     return source;
   3412 }
   3413 
   3414 // ----------------------------------------------------------------------------
   3415 // AudioPolicyManager
   3416 // ----------------------------------------------------------------------------
   3417 uint32_t AudioPolicyManager::nextAudioPortGeneration()
   3418 {
   3419     return android_atomic_inc(&mAudioPortGeneration);
   3420 }
   3421 
   3422 #ifdef USE_XML_AUDIO_POLICY_CONF
   3423 // Treblized audio policy xml config will be located in /odm/etc or /vendor/etc.
   3424 static const char *kConfigLocationList[] =
   3425         {"/odm/etc", "/vendor/etc", "/system/etc"};
   3426 static const int kConfigLocationListSize =
   3427         (sizeof(kConfigLocationList) / sizeof(kConfigLocationList[0]));
   3428 
   3429 static status_t deserializeAudioPolicyXmlConfig(AudioPolicyConfig &config) {
   3430     char audioPolicyXmlConfigFile[AUDIO_POLICY_XML_CONFIG_FILE_PATH_MAX_LENGTH];
   3431     status_t ret;
   3432 
   3433     for (int i = 0; i < kConfigLocationListSize; i++) {
   3434         PolicySerializer serializer;
   3435         snprintf(audioPolicyXmlConfigFile,
   3436                  sizeof(audioPolicyXmlConfigFile),
   3437                  "%s/%s",
   3438                  kConfigLocationList[i],
   3439                  AUDIO_POLICY_XML_CONFIG_FILE_NAME);
   3440         ret = serializer.deserialize(audioPolicyXmlConfigFile, config);
   3441         if (ret == NO_ERROR) {
   3442             break;
   3443         }
   3444     }
   3445     return ret;
   3446 }
   3447 #endif
   3448 
   3449 AudioPolicyManager::AudioPolicyManager(AudioPolicyClientInterface *clientInterface)
   3450     :
   3451 #ifdef AUDIO_POLICY_TEST
   3452     Thread(false),
   3453 #endif //AUDIO_POLICY_TEST
   3454     mLimitRingtoneVolume(false), mLastVoiceVolume(-1.0f),
   3455     mA2dpSuspended(false),
   3456     mAudioPortGeneration(1),
   3457     mBeaconMuteRefCount(0),
   3458     mBeaconPlayingRefCount(0),
   3459     mBeaconMuted(false),
   3460     mTtsOutputAvailable(false),
   3461     mMasterMono(false),
   3462     mMusicEffectOutput(AUDIO_IO_HANDLE_NONE)
   3463 {
   3464     mUidCached = getuid();
   3465     mpClientInterface = clientInterface;
   3466 
   3467     // TODO: remove when legacy conf file is removed. true on devices that use DRC on the
   3468     // DEVICE_CATEGORY_SPEAKER path to boost soft sounds, used to adjust volume curves accordingly.
   3469     // Note: remove also speaker_drc_enabled from global configuration of XML config file.
   3470     bool speakerDrcEnabled = false;
   3471 
   3472 #ifdef USE_XML_AUDIO_POLICY_CONF
   3473     mVolumeCurves = new VolumeCurvesCollection();
   3474     AudioPolicyConfig config(mHwModules, mAvailableOutputDevices, mAvailableInputDevices,
   3475                              mDefaultOutputDevice, speakerDrcEnabled,
   3476                              static_cast<VolumeCurvesCollection *>(mVolumeCurves));
   3477     if (deserializeAudioPolicyXmlConfig(config) != NO_ERROR) {
   3478 #else
   3479     mVolumeCurves = new StreamDescriptorCollection();
   3480     AudioPolicyConfig config(mHwModules, mAvailableOutputDevices, mAvailableInputDevices,
   3481                              mDefaultOutputDevice, speakerDrcEnabled);
   3482     if ((ConfigParsingUtils::loadConfig(AUDIO_POLICY_VENDOR_CONFIG_FILE, config) != NO_ERROR) &&
   3483             (ConfigParsingUtils::loadConfig(AUDIO_POLICY_CONFIG_FILE, config) != NO_ERROR)) {
   3484 #endif
   3485         ALOGE("could not load audio policy configuration file, setting defaults");
   3486         config.setDefault();
   3487     }
   3488     // must be done after reading the policy (since conditionned by Speaker Drc Enabling)
   3489     mVolumeCurves->initializeVolumeCurves(speakerDrcEnabled);
   3490 
   3491     // Once policy config has been parsed, retrieve an instance of the engine and initialize it.
   3492     audio_policy::EngineInstance *engineInstance = audio_policy::EngineInstance::getInstance();
   3493     if (!engineInstance) {
   3494         ALOGE("%s:  Could not get an instance of policy engine", __FUNCTION__);
   3495         return;
   3496     }
   3497     // Retrieve the Policy Manager Interface
   3498     mEngine = engineInstance->queryInterface<AudioPolicyManagerInterface>();
   3499     if (mEngine == NULL) {
   3500         ALOGE("%s: Failed to get Policy Engine Interface", __FUNCTION__);
   3501         return;
   3502     }
   3503     mEngine->setObserver(this);
   3504     status_t status = mEngine->initCheck();
   3505     (void) status;
   3506     ALOG_ASSERT(status == NO_ERROR, "Policy engine not initialized(err=%d)", status);
   3507 
   3508     // mAvailableOutputDevices and mAvailableInputDevices now contain all attached devices
   3509     // open all output streams needed to access attached devices
   3510     audio_devices_t outputDeviceTypes = mAvailableOutputDevices.types();
   3511     audio_devices_t inputDeviceTypes = mAvailableInputDevices.types() & ~AUDIO_DEVICE_BIT_IN;
   3512     for (size_t i = 0; i < mHwModules.size(); i++) {
   3513         mHwModules[i]->mHandle = mpClientInterface->loadHwModule(mHwModules[i]->getName());
   3514         if (mHwModules[i]->mHandle == 0) {
   3515             ALOGW("could not open HW module %s", mHwModules[i]->getName());
   3516             continue;
   3517         }
   3518         // open all output streams needed to access attached devices
   3519         // except for direct output streams that are only opened when they are actually
   3520         // required by an app.
   3521         // This also validates mAvailableOutputDevices list
   3522         for (size_t j = 0; j < mHwModules[i]->mOutputProfiles.size(); j++)
   3523         {
   3524             const sp<IOProfile> outProfile = mHwModules[i]->mOutputProfiles[j];
   3525 
   3526             if (!outProfile->hasSupportedDevices()) {
   3527                 ALOGW("Output profile contains no device on module %s", mHwModules[i]->getName());
   3528                 continue;
   3529             }
   3530             if ((outProfile->getFlags() & AUDIO_OUTPUT_FLAG_TTS) != 0) {
   3531                 mTtsOutputAvailable = true;
   3532             }
   3533 
   3534             if ((outProfile->getFlags() & AUDIO_OUTPUT_FLAG_DIRECT) != 0) {
   3535                 continue;
   3536             }
   3537             audio_devices_t profileType = outProfile->getSupportedDevicesType();
   3538             if ((profileType & mDefaultOutputDevice->type()) != AUDIO_DEVICE_NONE) {
   3539                 profileType = mDefaultOutputDevice->type();
   3540             } else {
   3541                 // chose first device present in profile's SupportedDevices also part of
   3542                 // outputDeviceTypes
   3543                 profileType = outProfile->getSupportedDeviceForType(outputDeviceTypes);
   3544             }
   3545             if ((profileType & outputDeviceTypes) == 0) {
   3546                 continue;
   3547             }
   3548             sp<SwAudioOutputDescriptor> outputDesc = new SwAudioOutputDescriptor(outProfile,
   3549                                                                                  mpClientInterface);
   3550             const DeviceVector &supportedDevices = outProfile->getSupportedDevices();
   3551             const DeviceVector &devicesForType = supportedDevices.getDevicesFromType(profileType);
   3552             String8 address = devicesForType.size() > 0 ? devicesForType.itemAt(0)->mAddress
   3553                     : String8("");
   3554 
   3555             outputDesc->mDevice = profileType;
   3556             audio_config_t config = AUDIO_CONFIG_INITIALIZER;
   3557             config.sample_rate = outputDesc->mSamplingRate;
   3558             config.channel_mask = outputDesc->mChannelMask;
   3559             config.format = outputDesc->mFormat;
   3560             audio_io_handle_t output = AUDIO_IO_HANDLE_NONE;
   3561             status_t status = mpClientInterface->openOutput(outProfile->getModuleHandle(),
   3562                                                             &output,
   3563                                                             &config,
   3564                                                             &outputDesc->mDevice,
   3565                                                             address,
   3566                                                             &outputDesc->mLatency,
   3567                                                             outputDesc->mFlags);
   3568 
   3569             if (status != NO_ERROR) {
   3570                 ALOGW("Cannot open output stream for device %08x on hw module %s",
   3571                       outputDesc->mDevice,
   3572                       mHwModules[i]->getName());
   3573             } else {
   3574                 outputDesc->mSamplingRate = config.sample_rate;
   3575                 outputDesc->mChannelMask = config.channel_mask;
   3576                 outputDesc->mFormat = config.format;
   3577 
   3578                 for (size_t k = 0; k  < supportedDevices.size(); k++) {
   3579                     ssize_t index = mAvailableOutputDevices.indexOf(supportedDevices[k]);
   3580                     // give a valid ID to an attached device once confirmed it is reachable
   3581                     if (index >= 0 && !mAvailableOutputDevices[index]->isAttached()) {
   3582                         mAvailableOutputDevices[index]->attach(mHwModules[i]);
   3583                     }
   3584                 }
   3585                 if (mPrimaryOutput == 0 &&
   3586                         outProfile->getFlags() & AUDIO_OUTPUT_FLAG_PRIMARY) {
   3587                     mPrimaryOutput = outputDesc;
   3588                 }
   3589                 addOutput(output, outputDesc);
   3590                 setOutputDevice(outputDesc,
   3591                                 outputDesc->mDevice,
   3592                                 true,
   3593                                 0,
   3594                                 NULL,
   3595                                 address.string());
   3596             }
   3597         }
   3598         // open input streams needed to access attached devices to validate
   3599         // mAvailableInputDevices list
   3600         for (size_t j = 0; j < mHwModules[i]->mInputProfiles.size(); j++)
   3601         {
   3602             const sp<IOProfile> inProfile = mHwModules[i]->mInputProfiles[j];
   3603 
   3604             if (!inProfile->hasSupportedDevices()) {
   3605                 ALOGW("Input profile contains no device on module %s", mHwModules[i]->getName());
   3606                 continue;
   3607             }
   3608             // chose first device present in profile's SupportedDevices also part of
   3609             // inputDeviceTypes
   3610             audio_devices_t profileType = inProfile->getSupportedDeviceForType(inputDeviceTypes);
   3611 
   3612             if ((profileType & inputDeviceTypes) == 0) {
   3613                 continue;
   3614             }
   3615             sp<AudioInputDescriptor> inputDesc =
   3616                     new AudioInputDescriptor(inProfile);
   3617 
   3618             inputDesc->mDevice = profileType;
   3619 
   3620             // find the address
   3621             DeviceVector inputDevices = mAvailableInputDevices.getDevicesFromType(profileType);
   3622             //   the inputs vector must be of size 1, but we don't want to crash here
   3623             String8 address = inputDevices.size() > 0 ? inputDevices.itemAt(0)->mAddress
   3624                     : String8("");
   3625             ALOGV("  for input device 0x%x using address %s", profileType, address.string());
   3626             ALOGE_IF(inputDevices.size() == 0, "Input device list is empty!");
   3627 
   3628             audio_config_t config = AUDIO_CONFIG_INITIALIZER;
   3629             config.sample_rate = inputDesc->mSamplingRate;
   3630             config.channel_mask = inputDesc->mChannelMask;
   3631             config.format = inputDesc->mFormat;
   3632             audio_io_handle_t input = AUDIO_IO_HANDLE_NONE;
   3633             status_t status = mpClientInterface->openInput(inProfile->getModuleHandle(),
   3634                                                            &input,
   3635                                                            &config,
   3636                                                            &inputDesc->mDevice,
   3637                                                            address,
   3638                                                            AUDIO_SOURCE_MIC,
   3639                                                            AUDIO_INPUT_FLAG_NONE);
   3640 
   3641             if (status == NO_ERROR) {
   3642                 const DeviceVector &supportedDevices = inProfile->getSupportedDevices();
   3643                 for (size_t k = 0; k  < supportedDevices.size(); k++) {
   3644                     ssize_t index =  mAvailableInputDevices.indexOf(supportedDevices[k]);
   3645                     // give a valid ID to an attached device once confirmed it is reachable
   3646                     if (index >= 0) {
   3647                         sp<DeviceDescriptor> devDesc = mAvailableInputDevices[index];
   3648                         if (!devDesc->isAttached()) {
   3649                             devDesc->attach(mHwModules[i]);
   3650                             devDesc->importAudioPort(inProfile);
   3651                         }
   3652                     }
   3653                 }
   3654                 mpClientInterface->closeInput(input);
   3655             } else {
   3656                 ALOGW("Cannot open input stream for device %08x on hw module %s",
   3657                       inputDesc->mDevice,
   3658                       mHwModules[i]->getName());
   3659             }
   3660         }
   3661     }
   3662     // make sure all attached devices have been allocated a unique ID
   3663     for (size_t i = 0; i  < mAvailableOutputDevices.size();) {
   3664         if (!mAvailableOutputDevices[i]->isAttached()) {
   3665             ALOGW("Output device %08x unreachable", mAvailableOutputDevices[i]->type());
   3666             mAvailableOutputDevices.remove(mAvailableOutputDevices[i]);
   3667             continue;
   3668         }
   3669         // The device is now validated and can be appended to the available devices of the engine
   3670         mEngine->setDeviceConnectionState(mAvailableOutputDevices[i],
   3671                                           AUDIO_POLICY_DEVICE_STATE_AVAILABLE);
   3672         i++;
   3673     }
   3674     for (size_t i = 0; i  < mAvailableInputDevices.size();) {
   3675         if (!mAvailableInputDevices[i]->isAttached()) {
   3676             ALOGW("Input device %08x unreachable", mAvailableInputDevices[i]->type());
   3677             mAvailableInputDevices.remove(mAvailableInputDevices[i]);
   3678             continue;
   3679         }
   3680         // The device is now validated and can be appended to the available devices of the engine
   3681         mEngine->setDeviceConnectionState(mAvailableInputDevices[i],
   3682                                           AUDIO_POLICY_DEVICE_STATE_AVAILABLE);
   3683         i++;
   3684     }
   3685     // make sure default device is reachable
   3686     if (mDefaultOutputDevice == 0 || mAvailableOutputDevices.indexOf(mDefaultOutputDevice) < 0) {
   3687         ALOGE("Default device %08x is unreachable", mDefaultOutputDevice->type());
   3688     }
   3689 
   3690     ALOGE_IF((mPrimaryOutput == 0), "Failed to open primary output");
   3691 
   3692     updateDevicesAndOutputs();
   3693 
   3694 #ifdef AUDIO_POLICY_TEST
   3695     if (mPrimaryOutput != 0) {
   3696         AudioParameter outputCmd = AudioParameter();
   3697         outputCmd.addInt(String8("set_id"), 0);
   3698         mpClientInterface->setParameters(mPrimaryOutput->mIoHandle, outputCmd.toString());
   3699 
   3700         mTestDevice = AUDIO_DEVICE_OUT_SPEAKER;
   3701         mTestSamplingRate = 44100;
   3702         mTestFormat = AUDIO_FORMAT_PCM_16_BIT;
   3703         mTestChannels =  AUDIO_CHANNEL_OUT_STEREO;
   3704         mTestLatencyMs = 0;
   3705         mCurOutput = 0;
   3706         mDirectOutput = false;
   3707         for (int i = 0; i < NUM_TEST_OUTPUTS; i++) {
   3708             mTestOutputs[i] = 0;
   3709         }
   3710 
   3711         const size_t SIZE = 256;
   3712         char buffer[SIZE];
   3713         snprintf(buffer, SIZE, "AudioPolicyManagerTest");
   3714         run(buffer, ANDROID_PRIORITY_AUDIO);
   3715     }
   3716 #endif //AUDIO_POLICY_TEST
   3717 }
   3718 
   3719 AudioPolicyManager::~AudioPolicyManager()
   3720 {
   3721 #ifdef AUDIO_POLICY_TEST
   3722     exit();
   3723 #endif //AUDIO_POLICY_TEST
   3724    for (size_t i = 0; i < mOutputs.size(); i++) {
   3725         mpClientInterface->closeOutput(mOutputs.keyAt(i));
   3726    }
   3727    for (size_t i = 0; i < mInputs.size(); i++) {
   3728         mpClientInterface->closeInput(mInputs.keyAt(i));
   3729    }
   3730    mAvailableOutputDevices.clear();
   3731    mAvailableInputDevices.clear();
   3732    mOutputs.clear();
   3733    mInputs.clear();
   3734    mHwModules.clear();
   3735 }
   3736 
   3737 status_t AudioPolicyManager::initCheck()
   3738 {
   3739     return hasPrimaryOutput() ? NO_ERROR : NO_INIT;
   3740 }
   3741 
   3742 #ifdef AUDIO_POLICY_TEST
   3743 bool AudioPolicyManager::threadLoop()
   3744 {
   3745     ALOGV("entering threadLoop()");
   3746     while (!exitPending())
   3747     {
   3748         String8 command;
   3749         int valueInt;
   3750         String8 value;
   3751 
   3752         Mutex::Autolock _l(mLock);
   3753         mWaitWorkCV.waitRelative(mLock, milliseconds(50));
   3754 
   3755         command = mpClientInterface->getParameters(0, String8("test_cmd_policy"));
   3756         AudioParameter param = AudioParameter(command);
   3757 
   3758         if (param.getInt(String8("test_cmd_policy"), valueInt) == NO_ERROR &&
   3759             valueInt != 0) {
   3760             ALOGV("Test command %s received", command.string());
   3761             String8 target;
   3762             if (param.get(String8("target"), target) != NO_ERROR) {
   3763                 target = "Manager";
   3764             }
   3765             if (param.getInt(String8("test_cmd_policy_output"), valueInt) == NO_ERROR) {
   3766                 param.remove(String8("test_cmd_policy_output"));
   3767                 mCurOutput = valueInt;
   3768             }
   3769             if (param.get(String8("test_cmd_policy_direct"), value) == NO_ERROR) {
   3770                 param.remove(String8("test_cmd_policy_direct"));
   3771                 if (value == "false") {
   3772                     mDirectOutput = false;
   3773                 } else if (value == "true") {
   3774                     mDirectOutput = true;
   3775                 }
   3776             }
   3777             if (param.getInt(String8("test_cmd_policy_input"), valueInt) == NO_ERROR) {
   3778                 param.remove(String8("test_cmd_policy_input"));
   3779                 mTestInput = valueInt;
   3780             }
   3781 
   3782             if (param.get(String8("test_cmd_policy_format"), value) == NO_ERROR) {
   3783                 param.remove(String8("test_cmd_policy_format"));
   3784                 int format = AUDIO_FORMAT_INVALID;
   3785                 if (value == "PCM 16 bits") {
   3786                     format = AUDIO_FORMAT_PCM_16_BIT;
   3787                 } else if (value == "PCM 8 bits") {
   3788                     format = AUDIO_FORMAT_PCM_8_BIT;
   3789                 } else if (value == "Compressed MP3") {
   3790                     format = AUDIO_FORMAT_MP3;
   3791                 }
   3792                 if (format != AUDIO_FORMAT_INVALID) {
   3793                     if (target == "Manager") {
   3794                         mTestFormat = format;
   3795                     } else if (mTestOutputs[mCurOutput] != 0) {
   3796                         AudioParameter outputParam = AudioParameter();
   3797                         outputParam.addInt(String8(AudioParameter::keyStreamSupportedFormats), format);
   3798                         mpClientInterface->setParameters(mTestOutputs[mCurOutput], outputParam.toString());
   3799                     }
   3800                 }
   3801             }
   3802             if (param.get(String8("test_cmd_policy_channels"), value) == NO_ERROR) {
   3803                 param.remove(String8("test_cmd_policy_channels"));
   3804                 int channels = 0;
   3805 
   3806                 if (value == "Channels Stereo") {
   3807                     channels =  AUDIO_CHANNEL_OUT_STEREO;
   3808                 } else if (value == "Channels Mono") {
   3809                     channels =  AUDIO_CHANNEL_OUT_MONO;
   3810                 }
   3811                 if (channels != 0) {
   3812                     if (target == "Manager") {
   3813                         mTestChannels = channels;
   3814                     } else if (mTestOutputs[mCurOutput] != 0) {
   3815                         AudioParameter outputParam = AudioParameter();
   3816                         outputParam.addInt(String8(AudioParameter::keyStreamSupportedChannels), channels);
   3817                         mpClientInterface->setParameters(mTestOutputs[mCurOutput], outputParam.toString());
   3818                     }
   3819                 }
   3820             }
   3821             if (param.getInt(String8("test_cmd_policy_sampleRate"), valueInt) == NO_ERROR) {
   3822                 param.remove(String8("test_cmd_policy_sampleRate"));
   3823                 if (valueInt >= 0 && valueInt <= 96000) {
   3824                     int samplingRate = valueInt;
   3825                     if (target == "Manager") {
   3826                         mTestSamplingRate = samplingRate;
   3827                     } else if (mTestOutputs[mCurOutput] != 0) {
   3828                         AudioParameter outputParam = AudioParameter();
   3829                         outputParam.addInt(String8(AudioParameter::keyStreamSupportedSamplingRates), samplingRate);
   3830                         mpClientInterface->setParameters(mTestOutputs[mCurOutput], outputParam.toString());
   3831                     }
   3832                 }
   3833             }
   3834 
   3835             if (param.get(String8("test_cmd_policy_reopen"), value) == NO_ERROR) {
   3836                 param.remove(String8("test_cmd_policy_reopen"));
   3837 
   3838                 mpClientInterface->closeOutput(mpClientInterface->closeOutput(mPrimaryOutput););
   3839 
   3840                 audio_module_handle_t moduleHandle = mPrimaryOutput->getModuleHandle();
   3841 
   3842                 removeOutput(mPrimaryOutput->mIoHandle);
   3843                 sp<SwAudioOutputDescriptor> outputDesc = new AudioOutputDescriptor(NULL,
   3844                                                                                mpClientInterface);
   3845                 outputDesc->mDevice = AUDIO_DEVICE_OUT_SPEAKER;
   3846                 audio_config_t config = AUDIO_CONFIG_INITIALIZER;
   3847                 config.sample_rate = outputDesc->mSamplingRate;
   3848                 config.channel_mask = outputDesc->mChannelMask;
   3849                 config.format = outputDesc->mFormat;
   3850                 audio_io_handle_t handle;
   3851                 status_t status = mpClientInterface->openOutput(moduleHandle,
   3852                                                                 &handle,
   3853                                                                 &config,
   3854                                                                 &outputDesc->mDevice,
   3855                                                                 String8(""),
   3856                                                                 &outputDesc->mLatency,
   3857                                                                 outputDesc->mFlags);
   3858                 if (status != NO_ERROR) {
   3859                     ALOGE("Failed to reopen hardware output stream, "
   3860                         "samplingRate: %d, format %d, channels %d",
   3861                         outputDesc->mSamplingRate, outputDesc->mFormat, outputDesc->mChannelMask);
   3862                 } else {
   3863                     outputDesc->mSamplingRate = config.sample_rate;
   3864                     outputDesc->mChannelMask = config.channel_mask;
   3865                     outputDesc->mFormat = config.format;
   3866                     mPrimaryOutput = outputDesc;
   3867                     AudioParameter outputCmd = AudioParameter();
   3868                     outputCmd.addInt(String8("set_id"), 0);
   3869                     mpClientInterface->setParameters(handle, outputCmd.toString());
   3870                     addOutput(handle, outputDesc);
   3871                 }
   3872             }
   3873 
   3874 
   3875             mpClientInterface->setParameters(0, String8("test_cmd_policy="));
   3876         }
   3877     }
   3878     return false;
   3879 }
   3880 
   3881 void AudioPolicyManager::exit()
   3882 {
   3883     {
   3884         AutoMutex _l(mLock);
   3885         requestExit();
   3886         mWaitWorkCV.signal();
   3887     }
   3888     requestExitAndWait();
   3889 }
   3890 
   3891 int AudioPolicyManager::testOutputIndex(audio_io_handle_t output)
   3892 {
   3893     for (int i = 0; i < NUM_TEST_OUTPUTS; i++) {
   3894         if (output == mTestOutputs[i]) return i;
   3895     }
   3896     return 0;
   3897 }
   3898 #endif //AUDIO_POLICY_TEST
   3899 
   3900 // ---
   3901 
   3902 void AudioPolicyManager::addOutput(audio_io_handle_t output, const sp<SwAudioOutputDescriptor>& outputDesc)
   3903 {
   3904     outputDesc->setIoHandle(output);
   3905     mOutputs.add(output, outputDesc);
   3906     updateMono(output); // update mono status when adding to output list
   3907     selectOutputForMusicEffects();
   3908     nextAudioPortGeneration();
   3909 }
   3910 
   3911 void AudioPolicyManager::removeOutput(audio_io_handle_t output)
   3912 {
   3913     mOutputs.removeItem(output);
   3914     selectOutputForMusicEffects();
   3915 }
   3916 
   3917 void AudioPolicyManager::addInput(audio_io_handle_t input, const sp<AudioInputDescriptor>& inputDesc)
   3918 {
   3919     inputDesc->setIoHandle(input);
   3920     mInputs.add(input, inputDesc);
   3921     nextAudioPortGeneration();
   3922 }
   3923 
   3924 void AudioPolicyManager::findIoHandlesByAddress(const sp<SwAudioOutputDescriptor>& desc /*in*/,
   3925         const audio_devices_t device /*in*/,
   3926         const String8& address /*in*/,
   3927         SortedVector<audio_io_handle_t>& outputs /*out*/) {
   3928     sp<DeviceDescriptor> devDesc =
   3929         desc->mProfile->getSupportedDeviceByAddress(device, address);
   3930     if (devDesc != 0) {
   3931         ALOGV("findIoHandlesByAddress(): adding opened output %d on same address %s",
   3932               desc->mIoHandle, address.string());
   3933         outputs.add(desc->mIoHandle);
   3934     }
   3935 }
   3936 
   3937 status_t AudioPolicyManager::checkOutputsForDevice(const sp<DeviceDescriptor>& devDesc,
   3938                                                    audio_policy_dev_state_t state,
   3939                                                    SortedVector<audio_io_handle_t>& outputs,
   3940                                                    const String8& address)
   3941 {
   3942     audio_devices_t device = devDesc->type();
   3943     sp<SwAudioOutputDescriptor> desc;
   3944 
   3945     if (audio_device_is_digital(device)) {
   3946         // erase all current sample rates, formats and channel masks
   3947         devDesc->clearAudioProfiles();
   3948     }
   3949 
   3950     if (state == AUDIO_POLICY_DEVICE_STATE_AVAILABLE) {
   3951         // first list already open outputs that can be routed to this device
   3952         for (size_t i = 0; i < mOutputs.size(); i++) {
   3953             desc = mOutputs.valueAt(i);
   3954             if (!desc->isDuplicated() && (desc->supportedDevices() & device)) {
   3955                 if (!device_distinguishes_on_address(device)) {
   3956                     ALOGV("checkOutputsForDevice(): adding opened output %d", mOutputs.keyAt(i));
   3957                     outputs.add(mOutputs.keyAt(i));
   3958                 } else {
   3959                     ALOGV("  checking address match due to device 0x%x", device);
   3960                     findIoHandlesByAddress(desc, device, address, outputs);
   3961                 }
   3962             }
   3963         }
   3964         // then look for output profiles that can be routed to this device
   3965         SortedVector< sp<IOProfile> > profiles;
   3966         for (size_t i = 0; i < mHwModules.size(); i++)
   3967         {
   3968             if (mHwModules[i]->mHandle == 0) {
   3969                 continue;
   3970             }
   3971             for (size_t j = 0; j < mHwModules[i]->mOutputProfiles.size(); j++)
   3972             {
   3973                 sp<IOProfile> profile = mHwModules[i]->mOutputProfiles[j];
   3974                 if (profile->supportDevice(device)) {
   3975                     if (!device_distinguishes_on_address(device) ||
   3976                             profile->supportDeviceAddress(address)) {
   3977                         profiles.add(profile);
   3978                         ALOGV("checkOutputsForDevice(): adding profile %zu from module %zu", j, i);
   3979                     }
   3980                 }
   3981             }
   3982         }
   3983 
   3984         ALOGV("  found %zu profiles, %zu outputs", profiles.size(), outputs.size());
   3985 
   3986         if (profiles.isEmpty() && outputs.isEmpty()) {
   3987             ALOGW("checkOutputsForDevice(): No output available for device %04x", device);
   3988             return BAD_VALUE;
   3989         }
   3990 
   3991         // open outputs for matching profiles if needed. Direct outputs are also opened to
   3992         // query for dynamic parameters and will be closed later by setDeviceConnectionState()
   3993         for (ssize_t profile_index = 0; profile_index < (ssize_t)profiles.size(); profile_index++) {
   3994             sp<IOProfile> profile = profiles[profile_index];
   3995 
   3996             // nothing to do if one output is already opened for this profile
   3997             size_t j;
   3998             for (j = 0; j < outputs.size(); j++) {
   3999                 desc = mOutputs.valueFor(outputs.itemAt(j));
   4000                 if (!desc->isDuplicated() && desc->mProfile == profile) {
   4001                     // matching profile: save the sample rates, format and channel masks supported
   4002                     // by the profile in our device descriptor
   4003                     if (audio_device_is_digital(device)) {
   4004                         devDesc->importAudioPort(profile);
   4005                     }
   4006                     break;
   4007                 }
   4008             }
   4009             if (j != outputs.size()) {
   4010                 continue;
   4011             }
   4012 
   4013             ALOGV("opening output for device %08x with params %s profile %p",
   4014                                                       device, address.string(), profile.get());
   4015             desc = new SwAudioOutputDescriptor(profile, mpClientInterface);
   4016             desc->mDevice = device;
   4017             audio_config_t config = AUDIO_CONFIG_INITIALIZER;
   4018             config.sample_rate = desc->mSamplingRate;
   4019             config.channel_mask = desc->mChannelMask;
   4020             config.format = desc->mFormat;
   4021             config.offload_info.sample_rate = desc->mSamplingRate;
   4022             config.offload_info.channel_mask = desc->mChannelMask;
   4023             config.offload_info.format = desc->mFormat;
   4024             audio_io_handle_t output = AUDIO_IO_HANDLE_NONE;
   4025             status_t status = mpClientInterface->openOutput(profile->getModuleHandle(),
   4026                                                             &output,
   4027                                                             &config,
   4028                                                             &desc->mDevice,
   4029                                                             address,
   4030                                                             &desc->mLatency,
   4031                                                             desc->mFlags);
   4032             if (status == NO_ERROR) {
   4033                 desc->mSamplingRate = config.sample_rate;
   4034                 desc->mChannelMask = config.channel_mask;
   4035                 desc->mFormat = config.format;
   4036 
   4037                 // Here is where the out_set_parameters() for card & device gets called
   4038                 if (!address.isEmpty()) {
   4039                     char *param = audio_device_address_to_parameter(device, address);
   4040                     mpClientInterface->setParameters(output, String8(param));
   4041                     free(param);
   4042                 }
   4043                 updateAudioProfiles(device, output, profile->getAudioProfiles());
   4044                 if (!profile->hasValidAudioProfile()) {
   4045                     ALOGW("checkOutputsForDevice() missing param");
   4046                     mpClientInterface->closeOutput(output);
   4047                     output = AUDIO_IO_HANDLE_NONE;
   4048                 } else if (profile->hasDynamicAudioProfile()) {
   4049                     mpClientInterface->closeOutput(output);
   4050                     output = AUDIO_IO_HANDLE_NONE;
   4051                     profile->pickAudioProfile(config.sample_rate, config.channel_mask, config.format);
   4052                     config.offload_info.sample_rate = config.sample_rate;
   4053                     config.offload_info.channel_mask = config.channel_mask;
   4054                     config.offload_info.format = config.format;
   4055                     status = mpClientInterface->openOutput(profile->getModuleHandle(),
   4056                                                            &output,
   4057                                                            &config,
   4058                                                            &desc->mDevice,
   4059                                                            address,
   4060                                                            &desc->mLatency,
   4061                                                            desc->mFlags);
   4062                     if (status == NO_ERROR) {
   4063                         desc->mSamplingRate = config.sample_rate;
   4064                         desc->mChannelMask = config.channel_mask;
   4065                         desc->mFormat = config.format;
   4066                     } else {
   4067                         output = AUDIO_IO_HANDLE_NONE;
   4068                     }
   4069                 }
   4070 
   4071                 if (output != AUDIO_IO_HANDLE_NONE) {
   4072                     addOutput(output, desc);
   4073                     if (device_distinguishes_on_address(device) && address != "0") {
   4074                         sp<AudioPolicyMix> policyMix;
   4075                         if (mPolicyMixes.getAudioPolicyMix(address, policyMix) != NO_ERROR) {
   4076                             ALOGE("checkOutputsForDevice() cannot find policy for address %s",
   4077                                   address.string());
   4078                         }
   4079                         policyMix->setOutput(desc);
   4080                         desc->mPolicyMix = policyMix->getMix();
   4081 
   4082                     } else if (((desc->mFlags & AUDIO_OUTPUT_FLAG_DIRECT) == 0) &&
   4083                                     hasPrimaryOutput()) {
   4084                         // no duplicated output for direct outputs and
   4085                         // outputs used by dynamic policy mixes
   4086                         audio_io_handle_t duplicatedOutput = AUDIO_IO_HANDLE_NONE;
   4087 
   4088                         // set initial stream volume for device
   4089                         applyStreamVolumes(desc, device, 0, true);
   4090 
   4091                         //TODO: configure audio effect output stage here
   4092 
   4093                         // open a duplicating output thread for the new output and the primary output
   4094                         duplicatedOutput =
   4095                                 mpClientInterface->openDuplicateOutput(output,
   4096                                                                        mPrimaryOutput->mIoHandle);
   4097                         if (duplicatedOutput != AUDIO_IO_HANDLE_NONE) {
   4098                             // add duplicated output descriptor
   4099                             sp<SwAudioOutputDescriptor> dupOutputDesc =
   4100                                     new SwAudioOutputDescriptor(NULL, mpClientInterface);
   4101                             dupOutputDesc->mOutput1 = mPrimaryOutput;
   4102                             dupOutputDesc->mOutput2 = desc;
   4103                             dupOutputDesc->mSamplingRate = desc->mSamplingRate;
   4104                             dupOutputDesc->mFormat = desc->mFormat;
   4105                             dupOutputDesc->mChannelMask = desc->mChannelMask;
   4106                             dupOutputDesc->mLatency = desc->mLatency;
   4107                             addOutput(duplicatedOutput, dupOutputDesc);
   4108                             applyStreamVolumes(dupOutputDesc, device, 0, true);
   4109                         } else {
   4110                             ALOGW("checkOutputsForDevice() could not open dup output for %d and %d",
   4111                                     mPrimaryOutput->mIoHandle, output);
   4112                             mpClientInterface->closeOutput(output);
   4113                             removeOutput(output);
   4114                             nextAudioPortGeneration();
   4115                             output = AUDIO_IO_HANDLE_NONE;
   4116                         }
   4117                     }
   4118                 }
   4119             } else {
   4120                 output = AUDIO_IO_HANDLE_NONE;
   4121             }
   4122             if (output == AUDIO_IO_HANDLE_NONE) {
   4123                 ALOGW("checkOutputsForDevice() could not open output for device %x", device);
   4124                 profiles.removeAt(profile_index);
   4125                 profile_index--;
   4126             } else {
   4127                 outputs.add(output);
   4128                 // Load digital format info only for digital devices
   4129                 if (audio_device_is_digital(device)) {
   4130                     devDesc->importAudioPort(profile);
   4131                 }
   4132 
   4133                 if (device_distinguishes_on_address(device)) {
   4134                     ALOGV("checkOutputsForDevice(): setOutputDevice(dev=0x%x, addr=%s)",
   4135                             device, address.string());
   4136                     setOutputDevice(desc, device, true/*force*/, 0/*delay*/,
   4137                             NULL/*patch handle*/, address.string());
   4138                 }
   4139                 ALOGV("checkOutputsForDevice(): adding output %d", output);
   4140             }
   4141         }
   4142 
   4143         if (profiles.isEmpty()) {
   4144             ALOGW("checkOutputsForDevice(): No output available for device %04x", device);
   4145             return BAD_VALUE;
   4146         }
   4147     } else { // Disconnect
   4148         // check if one opened output is not needed any more after disconnecting one device
   4149         for (size_t i = 0; i < mOutputs.size(); i++) {
   4150             desc = mOutputs.valueAt(i);
   4151             if (!desc->isDuplicated()) {
   4152                 // exact match on device
   4153                 if (device_distinguishes_on_address(device) &&
   4154                         (desc->supportedDevices() == device)) {
   4155                     findIoHandlesByAddress(desc, device, address, outputs);
   4156                 } else if (!(desc->supportedDevices() & mAvailableOutputDevices.types())) {
   4157                     ALOGV("checkOutputsForDevice(): disconnecting adding output %d",
   4158                             mOutputs.keyAt(i));
   4159                     outputs.add(mOutputs.keyAt(i));
   4160                 }
   4161             }
   4162         }
   4163         // Clear any profiles associated with the disconnected device.
   4164         for (size_t i = 0; i < mHwModules.size(); i++)
   4165         {
   4166             if (mHwModules[i]->mHandle == 0) {
   4167                 continue;
   4168             }
   4169             for (size_t j = 0; j < mHwModules[i]->mOutputProfiles.size(); j++)
   4170             {
   4171                 sp<IOProfile> profile = mHwModules[i]->mOutputProfiles[j];
   4172                 if (profile->supportDevice(device)) {
   4173                     ALOGV("checkOutputsForDevice(): "
   4174                             "clearing direct output profile %zu on module %zu", j, i);
   4175                     profile->clearAudioProfiles();
   4176                 }
   4177             }
   4178         }
   4179     }
   4180     return NO_ERROR;
   4181 }
   4182 
   4183 status_t AudioPolicyManager::checkInputsForDevice(const sp<DeviceDescriptor>& devDesc,
   4184                                                   audio_policy_dev_state_t state,
   4185                                                   SortedVector<audio_io_handle_t>& inputs,
   4186                                                   const String8& address)
   4187 {
   4188     audio_devices_t device = devDesc->type();
   4189     sp<AudioInputDescriptor> desc;
   4190 
   4191     if (audio_device_is_digital(device)) {
   4192         // erase all current sample rates, formats and channel masks
   4193         devDesc->clearAudioProfiles();
   4194     }
   4195 
   4196     if (state == AUDIO_POLICY_DEVICE_STATE_AVAILABLE) {
   4197         // first list already open inputs that can be routed to this device
   4198         for (size_t input_index = 0; input_index < mInputs.size(); input_index++) {
   4199             desc = mInputs.valueAt(input_index);
   4200             if (desc->mProfile->supportDevice(device)) {
   4201                 ALOGV("checkInputsForDevice(): adding opened input %d", mInputs.keyAt(input_index));
   4202                inputs.add(mInputs.keyAt(input_index));
   4203             }
   4204         }
   4205 
   4206         // then look for input profiles that can be routed to this device
   4207         SortedVector< sp<IOProfile> > profiles;
   4208         for (size_t module_idx = 0; module_idx < mHwModules.size(); module_idx++)
   4209         {
   4210             if (mHwModules[module_idx]->mHandle == 0) {
   4211                 continue;
   4212             }
   4213             for (size_t profile_index = 0;
   4214                  profile_index < mHwModules[module_idx]->mInputProfiles.size();
   4215                  profile_index++)
   4216             {
   4217                 sp<IOProfile> profile = mHwModules[module_idx]->mInputProfiles[profile_index];
   4218 
   4219                 if (profile->supportDevice(device)) {
   4220                     if (!device_distinguishes_on_address(device) ||
   4221                             profile->supportDeviceAddress(address)) {
   4222                         profiles.add(profile);
   4223                         ALOGV("checkInputsForDevice(): adding profile %zu from module %zu",
   4224                               profile_index, module_idx);
   4225                     }
   4226                 }
   4227             }
   4228         }
   4229 
   4230         if (profiles.isEmpty() && inputs.isEmpty()) {
   4231             ALOGW("checkInputsForDevice(): No input available for device 0x%X", device);
   4232             return BAD_VALUE;
   4233         }
   4234 
   4235         // open inputs for matching profiles if needed. Direct inputs are also opened to
   4236         // query for dynamic parameters and will be closed later by setDeviceConnectionState()
   4237         for (ssize_t profile_index = 0; profile_index < (ssize_t)profiles.size(); profile_index++) {
   4238 
   4239             sp<IOProfile> profile = profiles[profile_index];
   4240             // nothing to do if one input is already opened for this profile
   4241             size_t input_index;
   4242             for (input_index = 0; input_index < mInputs.size(); input_index++) {
   4243                 desc = mInputs.valueAt(input_index);
   4244                 if (desc->mProfile == profile) {
   4245                     if (audio_device_is_digital(device)) {
   4246                         devDesc->importAudioPort(profile);
   4247                     }
   4248                     break;
   4249                 }
   4250             }
   4251             if (input_index != mInputs.size()) {
   4252                 continue;
   4253             }
   4254 
   4255             ALOGV("opening input for device 0x%X with params %s", device, address.string());
   4256             desc = new AudioInputDescriptor(profile);
   4257             desc->mDevice = device;
   4258             audio_config_t config = AUDIO_CONFIG_INITIALIZER;
   4259             config.sample_rate = desc->mSamplingRate;
   4260             config.channel_mask = desc->mChannelMask;
   4261             config.format = desc->mFormat;
   4262             audio_io_handle_t input = AUDIO_IO_HANDLE_NONE;
   4263             status_t status = mpClientInterface->openInput(profile->getModuleHandle(),
   4264                                                            &input,
   4265                                                            &config,
   4266                                                            &desc->mDevice,
   4267                                                            address,
   4268                                                            AUDIO_SOURCE_MIC,
   4269                                                            AUDIO_INPUT_FLAG_NONE /*FIXME*/);
   4270 
   4271             if (status == NO_ERROR) {
   4272                 desc->mSamplingRate = config.sample_rate;
   4273                 desc->mChannelMask = config.channel_mask;
   4274                 desc->mFormat = config.format;
   4275 
   4276                 if (!address.isEmpty()) {
   4277                     char *param = audio_device_address_to_parameter(device, address);
   4278                     mpClientInterface->setParameters(input, String8(param));
   4279                     free(param);
   4280                 }
   4281                 updateAudioProfiles(device, input, profile->getAudioProfiles());
   4282                 if (!profile->hasValidAudioProfile()) {
   4283                     ALOGW("checkInputsForDevice() direct input missing param");
   4284                     mpClientInterface->closeInput(input);
   4285                     input = AUDIO_IO_HANDLE_NONE;
   4286                 }
   4287 
   4288                 if (input != 0) {
   4289                     addInput(input, desc);
   4290                 }
   4291             } // endif input != 0
   4292 
   4293             if (input == AUDIO_IO_HANDLE_NONE) {
   4294                 ALOGW("checkInputsForDevice() could not open input for device 0x%X", device);
   4295                 profiles.removeAt(profile_index);
   4296                 profile_index--;
   4297             } else {
   4298                 inputs.add(input);
   4299                 if (audio_device_is_digital(device)) {
   4300                     devDesc->importAudioPort(profile);
   4301                 }
   4302                 ALOGV("checkInputsForDevice(): adding input %d", input);
   4303             }
   4304         } // end scan profiles
   4305 
   4306         if (profiles.isEmpty()) {
   4307             ALOGW("checkInputsForDevice(): No input available for device 0x%X", device);
   4308             return BAD_VALUE;
   4309         }
   4310     } else {
   4311         // Disconnect
   4312         // check if one opened input is not needed any more after disconnecting one device
   4313         for (size_t input_index = 0; input_index < mInputs.size(); input_index++) {
   4314             desc = mInputs.valueAt(input_index);
   4315             if (!(desc->mProfile->supportDevice(mAvailableInputDevices.types()))) {
   4316                 ALOGV("checkInputsForDevice(): disconnecting adding input %d",
   4317                       mInputs.keyAt(input_index));
   4318                 inputs.add(mInputs.keyAt(input_index));
   4319             }
   4320         }
   4321         // Clear any profiles associated with the disconnected device.
   4322         for (size_t module_index = 0; module_index < mHwModules.size(); module_index++) {
   4323             if (mHwModules[module_index]->mHandle == 0) {
   4324                 continue;
   4325             }
   4326             for (size_t profile_index = 0;
   4327                  profile_index < mHwModules[module_index]->mInputProfiles.size();
   4328                  profile_index++) {
   4329                 sp<IOProfile> profile = mHwModules[module_index]->mInputProfiles[profile_index];
   4330                 if (profile->supportDevice(device)) {
   4331                     ALOGV("checkInputsForDevice(): clearing direct input profile %zu on module %zu",
   4332                           profile_index, module_index);
   4333                     profile->clearAudioProfiles();
   4334                 }
   4335             }
   4336         }
   4337     } // end disconnect
   4338 
   4339     return NO_ERROR;
   4340 }
   4341 
   4342 
   4343 void AudioPolicyManager::closeOutput(audio_io_handle_t output)
   4344 {
   4345     ALOGV("closeOutput(%d)", output);
   4346 
   4347     sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueFor(output);
   4348     if (outputDesc == NULL) {
   4349         ALOGW("closeOutput() unknown output %d", output);
   4350         return;
   4351     }
   4352     mPolicyMixes.closeOutput(outputDesc);
   4353 
   4354     // look for duplicated outputs connected to the output being removed.
   4355     for (size_t i = 0; i < mOutputs.size(); i++) {
   4356         sp<SwAudioOutputDescriptor> dupOutputDesc = mOutputs.valueAt(i);
   4357         if (dupOutputDesc->isDuplicated() &&
   4358                 (dupOutputDesc->mOutput1 == outputDesc ||
   4359                 dupOutputDesc->mOutput2 == outputDesc)) {
   4360             sp<AudioOutputDescriptor> outputDesc2;
   4361             if (dupOutputDesc->mOutput1 == outputDesc) {
   4362                 outputDesc2 = dupOutputDesc->mOutput2;
   4363             } else {
   4364                 outputDesc2 = dupOutputDesc->mOutput1;
   4365             }
   4366             // As all active tracks on duplicated output will be deleted,
   4367             // and as they were also referenced on the other output, the reference
   4368             // count for their stream type must be adjusted accordingly on
   4369             // the other output.
   4370             for (int j = 0; j < AUDIO_STREAM_CNT; j++) {
   4371                 int refCount = dupOutputDesc->mRefCount[j];
   4372                 outputDesc2->changeRefCount((audio_stream_type_t)j,-refCount);
   4373             }
   4374             audio_io_handle_t duplicatedOutput = mOutputs.keyAt(i);
   4375             ALOGV("closeOutput() closing also duplicated output %d", duplicatedOutput);
   4376 
   4377             mpClientInterface->closeOutput(duplicatedOutput);
   4378             removeOutput(duplicatedOutput);
   4379         }
   4380     }
   4381 
   4382     nextAudioPortGeneration();
   4383 
   4384     ssize_t index = mAudioPatches.indexOfKey(outputDesc->getPatchHandle());
   4385     if (index >= 0) {
   4386         sp<AudioPatch> patchDesc = mAudioPatches.valueAt(index);
   4387         (void) /*status_t status*/ mpClientInterface->releaseAudioPatch(patchDesc->mAfPatchHandle, 0);
   4388         mAudioPatches.removeItemsAt(index);
   4389         mpClientInterface->onAudioPatchListUpdate();
   4390     }
   4391 
   4392     AudioParameter param;
   4393     param.add(String8("closing"), String8("true"));
   4394     mpClientInterface->setParameters(output, param.toString());
   4395 
   4396     mpClientInterface->closeOutput(output);
   4397     removeOutput(output);
   4398     mPreviousOutputs = mOutputs;
   4399 }
   4400 
   4401 void AudioPolicyManager::closeInput(audio_io_handle_t input)
   4402 {
   4403     ALOGV("closeInput(%d)", input);
   4404 
   4405     sp<AudioInputDescriptor> inputDesc = mInputs.valueFor(input);
   4406     if (inputDesc == NULL) {
   4407         ALOGW("closeInput() unknown input %d", input);
   4408         return;
   4409     }
   4410 
   4411     nextAudioPortGeneration();
   4412 
   4413     ssize_t index = mAudioPatches.indexOfKey(inputDesc->getPatchHandle());
   4414     if (index >= 0) {
   4415         sp<AudioPatch> patchDesc = mAudioPatches.valueAt(index);
   4416         (void) /*status_t status*/ mpClientInterface->releaseAudioPatch(patchDesc->mAfPatchHandle, 0);
   4417         mAudioPatches.removeItemsAt(index);
   4418         mpClientInterface->onAudioPatchListUpdate();
   4419     }
   4420 
   4421     mpClientInterface->closeInput(input);
   4422     mInputs.removeItem(input);
   4423 }
   4424 
   4425 SortedVector<audio_io_handle_t> AudioPolicyManager::getOutputsForDevice(
   4426                                                                 audio_devices_t device,
   4427                                                                 const SwAudioOutputCollection& openOutputs)
   4428 {
   4429     SortedVector<audio_io_handle_t> outputs;
   4430 
   4431     ALOGVV("getOutputsForDevice() device %04x", device);
   4432     for (size_t i = 0; i < openOutputs.size(); i++) {
   4433         ALOGVV("output %zu isDuplicated=%d device=%04x",
   4434                 i, openOutputs.valueAt(i)->isDuplicated(),
   4435                 openOutputs.valueAt(i)->supportedDevices());
   4436         if ((device & openOutputs.valueAt(i)->supportedDevices()) == device) {
   4437             ALOGVV("getOutputsForDevice() found output %d", openOutputs.keyAt(i));
   4438             outputs.add(openOutputs.keyAt(i));
   4439         }
   4440     }
   4441     return outputs;
   4442 }
   4443 
   4444 bool AudioPolicyManager::vectorsEqual(SortedVector<audio_io_handle_t>& outputs1,
   4445                                       SortedVector<audio_io_handle_t>& outputs2)
   4446 {
   4447     if (outputs1.size() != outputs2.size()) {
   4448         return false;
   4449     }
   4450     for (size_t i = 0; i < outputs1.size(); i++) {
   4451         if (outputs1[i] != outputs2[i]) {
   4452             return false;
   4453         }
   4454     }
   4455     return true;
   4456 }
   4457 
   4458 void AudioPolicyManager::checkOutputForStrategy(routing_strategy strategy)
   4459 {
   4460     audio_devices_t oldDevice = getDeviceForStrategy(strategy, true /*fromCache*/);
   4461     audio_devices_t newDevice = getDeviceForStrategy(strategy, false /*fromCache*/);
   4462     SortedVector<audio_io_handle_t> srcOutputs = getOutputsForDevice(oldDevice, mPreviousOutputs);
   4463     SortedVector<audio_io_handle_t> dstOutputs = getOutputsForDevice(newDevice, mOutputs);
   4464 
   4465     // also take into account external policy-related changes: add all outputs which are
   4466     // associated with policies in the "before" and "after" output vectors
   4467     ALOGVV("checkOutputForStrategy(): policy related outputs");
   4468     for (size_t i = 0 ; i < mPreviousOutputs.size() ; i++) {
   4469         const sp<SwAudioOutputDescriptor> desc = mPreviousOutputs.valueAt(i);
   4470         if (desc != 0 && desc->mPolicyMix != NULL) {
   4471             srcOutputs.add(desc->mIoHandle);
   4472             ALOGVV(" previous outputs: adding %d", desc->mIoHandle);
   4473         }
   4474     }
   4475     for (size_t i = 0 ; i < mOutputs.size() ; i++) {
   4476         const sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
   4477         if (desc != 0 && desc->mPolicyMix != NULL) {
   4478             dstOutputs.add(desc->mIoHandle);
   4479             ALOGVV(" new outputs: adding %d", desc->mIoHandle);
   4480         }
   4481     }
   4482 
   4483     if (!vectorsEqual(srcOutputs,dstOutputs)) {
   4484         ALOGV("checkOutputForStrategy() strategy %d, moving from output %d to output %d",
   4485               strategy, srcOutputs[0], dstOutputs[0]);
   4486         // mute strategy while moving tracks from one output to another
   4487         for (size_t i = 0; i < srcOutputs.size(); i++) {
   4488             sp<SwAudioOutputDescriptor> desc = mOutputs.valueFor(srcOutputs[i]);
   4489             if (isStrategyActive(desc, strategy)) {
   4490                 setStrategyMute(strategy, true, desc);
   4491                 setStrategyMute(strategy, false, desc, MUTE_TIME_MS, newDevice);
   4492             }
   4493             sp<AudioSourceDescriptor> source =
   4494                     getSourceForStrategyOnOutput(srcOutputs[i], strategy);
   4495             if (source != 0){
   4496                 connectAudioSource(source);
   4497             }
   4498         }
   4499 
   4500         // Move effects associated to this strategy from previous output to new output
   4501         if (strategy == STRATEGY_MEDIA) {
   4502             selectOutputForMusicEffects();
   4503         }
   4504         // Move tracks associated to this strategy from previous output to new output
   4505         for (int i = 0; i < AUDIO_STREAM_FOR_POLICY_CNT; i++) {
   4506             if (getStrategy((audio_stream_type_t)i) == strategy) {
   4507                 mpClientInterface->invalidateStream((audio_stream_type_t)i);
   4508             }
   4509         }
   4510     }
   4511 }
   4512 
   4513 void AudioPolicyManager::checkOutputForAllStrategies()
   4514 {
   4515     if (mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_SYSTEM) == AUDIO_POLICY_FORCE_SYSTEM_ENFORCED)
   4516         checkOutputForStrategy(STRATEGY_ENFORCED_AUDIBLE);
   4517     checkOutputForStrategy(STRATEGY_PHONE);
   4518     if (mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_SYSTEM) != AUDIO_POLICY_FORCE_SYSTEM_ENFORCED)
   4519         checkOutputForStrategy(STRATEGY_ENFORCED_AUDIBLE);
   4520     checkOutputForStrategy(STRATEGY_SONIFICATION);
   4521     checkOutputForStrategy(STRATEGY_SONIFICATION_RESPECTFUL);
   4522     checkOutputForStrategy(STRATEGY_ACCESSIBILITY);
   4523     checkOutputForStrategy(STRATEGY_MEDIA);
   4524     checkOutputForStrategy(STRATEGY_DTMF);
   4525     checkOutputForStrategy(STRATEGY_REROUTING);
   4526 }
   4527 
   4528 void AudioPolicyManager::checkA2dpSuspend()
   4529 {
   4530     audio_io_handle_t a2dpOutput = mOutputs.getA2dpOutput();
   4531     if (a2dpOutput == 0) {
   4532         mA2dpSuspended = false;
   4533         return;
   4534     }
   4535 
   4536     bool isScoConnected =
   4537             ((mAvailableInputDevices.types() & AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET &
   4538                     ~AUDIO_DEVICE_BIT_IN) != 0) ||
   4539             ((mAvailableOutputDevices.types() & AUDIO_DEVICE_OUT_ALL_SCO) != 0);
   4540 
   4541     // if suspended, restore A2DP output if:
   4542     //      ((SCO device is NOT connected) ||
   4543     //       ((forced usage communication is NOT SCO) && (forced usage for record is NOT SCO) &&
   4544     //        (phone state is NOT in call) && (phone state is NOT ringing)))
   4545     //
   4546     // if not suspended, suspend A2DP output if:
   4547     //      (SCO device is connected) &&
   4548     //       ((forced usage for communication is SCO) || (forced usage for record is SCO) ||
   4549     //       ((phone state is in call) || (phone state is ringing)))
   4550     //
   4551     if (mA2dpSuspended) {
   4552         if (!isScoConnected ||
   4553              ((mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_COMMUNICATION) !=
   4554                      AUDIO_POLICY_FORCE_BT_SCO) &&
   4555               (mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_RECORD) !=
   4556                       AUDIO_POLICY_FORCE_BT_SCO) &&
   4557               (mEngine->getPhoneState() != AUDIO_MODE_IN_CALL) &&
   4558               (mEngine->getPhoneState() != AUDIO_MODE_RINGTONE))) {
   4559 
   4560             mpClientInterface->restoreOutput(a2dpOutput);
   4561             mA2dpSuspended = false;
   4562         }
   4563     } else {
   4564         if (isScoConnected &&
   4565              ((mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_COMMUNICATION) ==
   4566                      AUDIO_POLICY_FORCE_BT_SCO) ||
   4567               (mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_RECORD) ==
   4568                       AUDIO_POLICY_FORCE_BT_SCO) ||
   4569               (mEngine->getPhoneState() == AUDIO_MODE_IN_CALL) ||
   4570               (mEngine->getPhoneState() == AUDIO_MODE_RINGTONE))) {
   4571 
   4572             mpClientInterface->suspendOutput(a2dpOutput);
   4573             mA2dpSuspended = true;
   4574         }
   4575     }
   4576 }
   4577 
   4578 audio_devices_t AudioPolicyManager::getNewOutputDevice(const sp<AudioOutputDescriptor>& outputDesc,
   4579                                                        bool fromCache)
   4580 {
   4581     audio_devices_t device = AUDIO_DEVICE_NONE;
   4582 
   4583     ssize_t index = mAudioPatches.indexOfKey(outputDesc->getPatchHandle());
   4584     if (index >= 0) {
   4585         sp<AudioPatch> patchDesc = mAudioPatches.valueAt(index);
   4586         if (patchDesc->mUid != mUidCached) {
   4587             ALOGV("getNewOutputDevice() device %08x forced by patch %d",
   4588                   outputDesc->device(), outputDesc->getPatchHandle());
   4589             return outputDesc->device();
   4590         }
   4591     }
   4592 
   4593     // check the following by order of priority to request a routing change if necessary:
   4594     // 1: the strategy enforced audible is active and enforced on the output:
   4595     //      use device for strategy enforced audible
   4596     // 2: we are in call or the strategy phone is active on the output:
   4597     //      use device for strategy phone
   4598     // 3: the strategy for enforced audible is active but not enforced on the output:
   4599     //      use the device for strategy enforced audible
   4600     // 4: the strategy sonification is active on the output:
   4601     //      use device for strategy sonification
   4602     // 5: the strategy accessibility is active on the output:
   4603     //      use device for strategy accessibility
   4604     // 6: the strategy "respectful" sonification is active on the output:
   4605     //      use device for strategy "respectful" sonification
   4606     // 7: the strategy media is active on the output:
   4607     //      use device for strategy media
   4608     // 8: the strategy DTMF is active on the output:
   4609     //      use device for strategy DTMF
   4610     // 9: the strategy for beacon, a.k.a. "transmitted through speaker" is active on the output:
   4611     //      use device for strategy t-t-s
   4612     if (isStrategyActive(outputDesc, STRATEGY_ENFORCED_AUDIBLE) &&
   4613         mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_SYSTEM) == AUDIO_POLICY_FORCE_SYSTEM_ENFORCED) {
   4614         device = getDeviceForStrategy(STRATEGY_ENFORCED_AUDIBLE, fromCache);
   4615     } else if (isInCall() ||
   4616                     isStrategyActive(outputDesc, STRATEGY_PHONE)) {
   4617         device = getDeviceForStrategy(STRATEGY_PHONE, fromCache);
   4618     } else if (isStrategyActive(outputDesc, STRATEGY_ENFORCED_AUDIBLE)) {
   4619         device = getDeviceForStrategy(STRATEGY_ENFORCED_AUDIBLE, fromCache);
   4620     } else if (isStrategyActive(outputDesc, STRATEGY_SONIFICATION)) {
   4621         device = getDeviceForStrategy(STRATEGY_SONIFICATION, fromCache);
   4622     } else if (isStrategyActive(outputDesc, STRATEGY_ACCESSIBILITY)) {
   4623         device = getDeviceForStrategy(STRATEGY_ACCESSIBILITY, fromCache);
   4624     } else if (isStrategyActive(outputDesc, STRATEGY_SONIFICATION_RESPECTFUL)) {
   4625         device = getDeviceForStrategy(STRATEGY_SONIFICATION_RESPECTFUL, fromCache);
   4626     } else if (isStrategyActive(outputDesc, STRATEGY_MEDIA)) {
   4627         device = getDeviceForStrategy(STRATEGY_MEDIA, fromCache);
   4628     } else if (isStrategyActive(outputDesc, STRATEGY_DTMF)) {
   4629         device = getDeviceForStrategy(STRATEGY_DTMF, fromCache);
   4630     } else if (isStrategyActive(outputDesc, STRATEGY_TRANSMITTED_THROUGH_SPEAKER)) {
   4631         device = getDeviceForStrategy(STRATEGY_TRANSMITTED_THROUGH_SPEAKER, fromCache);
   4632     } else if (isStrategyActive(outputDesc, STRATEGY_REROUTING)) {
   4633         device = getDeviceForStrategy(STRATEGY_REROUTING, fromCache);
   4634     }
   4635 
   4636     ALOGV("getNewOutputDevice() selected device %x", device);
   4637     return device;
   4638 }
   4639 
   4640 audio_devices_t AudioPolicyManager::getNewInputDevice(const sp<AudioInputDescriptor>& inputDesc)
   4641 {
   4642     audio_devices_t device = AUDIO_DEVICE_NONE;
   4643 
   4644     ssize_t index = mAudioPatches.indexOfKey(inputDesc->getPatchHandle());
   4645     if (index >= 0) {
   4646         sp<AudioPatch> patchDesc = mAudioPatches.valueAt(index);
   4647         if (patchDesc->mUid != mUidCached) {
   4648             ALOGV("getNewInputDevice() device %08x forced by patch %d",
   4649                   inputDesc->mDevice, inputDesc->getPatchHandle());
   4650             return inputDesc->mDevice;
   4651         }
   4652     }
   4653 
   4654     audio_source_t source = inputDesc->getHighestPrioritySource(true /*activeOnly*/);
   4655     if (isInCall()) {
   4656         device = getDeviceAndMixForInputSource(AUDIO_SOURCE_VOICE_COMMUNICATION);
   4657     } else if (source != AUDIO_SOURCE_DEFAULT) {
   4658         device = getDeviceAndMixForInputSource(source);
   4659     }
   4660 
   4661     return device;
   4662 }
   4663 
   4664 bool AudioPolicyManager::streamsMatchForvolume(audio_stream_type_t stream1,
   4665                                                audio_stream_type_t stream2) {
   4666     return (stream1 == stream2);
   4667 }
   4668 
   4669 uint32_t AudioPolicyManager::getStrategyForStream(audio_stream_type_t stream) {
   4670     return (uint32_t)getStrategy(stream);
   4671 }
   4672 
   4673 audio_devices_t AudioPolicyManager::getDevicesForStream(audio_stream_type_t stream) {
   4674     // By checking the range of stream before calling getStrategy, we avoid
   4675     // getStrategy's behavior for invalid streams.  getStrategy would do a ALOGE
   4676     // and then return STRATEGY_MEDIA, but we want to return the empty set.
   4677     if (stream < (audio_stream_type_t) 0 || stream >= AUDIO_STREAM_PUBLIC_CNT) {
   4678         return AUDIO_DEVICE_NONE;
   4679     }
   4680     audio_devices_t devices = AUDIO_DEVICE_NONE;
   4681     for (int curStream = 0; curStream < AUDIO_STREAM_FOR_POLICY_CNT; curStream++) {
   4682         if (!streamsMatchForvolume(stream, (audio_stream_type_t)curStream)) {
   4683             continue;
   4684         }
   4685         routing_strategy curStrategy = getStrategy((audio_stream_type_t)curStream);
   4686         audio_devices_t curDevices =
   4687                 getDeviceForStrategy((routing_strategy)curStrategy, false /*fromCache*/);
   4688         SortedVector<audio_io_handle_t> outputs = getOutputsForDevice(curDevices, mOutputs);
   4689         for (size_t i = 0; i < outputs.size(); i++) {
   4690             sp<AudioOutputDescriptor> outputDesc = mOutputs.valueFor(outputs[i]);
   4691             if (outputDesc->isStreamActive((audio_stream_type_t)curStream)) {
   4692                 curDevices |= outputDesc->device();
   4693             }
   4694         }
   4695         devices |= curDevices;
   4696     }
   4697 
   4698     /*Filter SPEAKER_SAFE out of results, as AudioService doesn't know about it
   4699       and doesn't really need to.*/
   4700     if (devices & AUDIO_DEVICE_OUT_SPEAKER_SAFE) {
   4701         devices |= AUDIO_DEVICE_OUT_SPEAKER;
   4702         devices &= ~AUDIO_DEVICE_OUT_SPEAKER_SAFE;
   4703     }
   4704     return devices;
   4705 }
   4706 
   4707 routing_strategy AudioPolicyManager::getStrategy(audio_stream_type_t stream) const
   4708 {
   4709     ALOG_ASSERT(stream != AUDIO_STREAM_PATCH,"getStrategy() called for AUDIO_STREAM_PATCH");
   4710     return mEngine->getStrategyForStream(stream);
   4711 }
   4712 
   4713 uint32_t AudioPolicyManager::getStrategyForAttr(const audio_attributes_t *attr) {
   4714     // flags to strategy mapping
   4715     if ((attr->flags & AUDIO_FLAG_BEACON) == AUDIO_FLAG_BEACON) {
   4716         return (uint32_t) STRATEGY_TRANSMITTED_THROUGH_SPEAKER;
   4717     }
   4718     if ((attr->flags & AUDIO_FLAG_AUDIBILITY_ENFORCED) == AUDIO_FLAG_AUDIBILITY_ENFORCED) {
   4719         return (uint32_t) STRATEGY_ENFORCED_AUDIBLE;
   4720     }
   4721     // usage to strategy mapping
   4722     return static_cast<uint32_t>(mEngine->getStrategyForUsage(attr->usage));
   4723 }
   4724 
   4725 void AudioPolicyManager::handleNotificationRoutingForStream(audio_stream_type_t stream) {
   4726     switch(stream) {
   4727     case AUDIO_STREAM_MUSIC:
   4728         checkOutputForStrategy(STRATEGY_SONIFICATION_RESPECTFUL);
   4729         updateDevicesAndOutputs();
   4730         break;
   4731     default:
   4732         break;
   4733     }
   4734 }
   4735 
   4736 uint32_t AudioPolicyManager::handleEventForBeacon(int event) {
   4737 
   4738     // skip beacon mute management if a dedicated TTS output is available
   4739     if (mTtsOutputAvailable) {
   4740         return 0;
   4741     }
   4742 
   4743     switch(event) {
   4744     case STARTING_OUTPUT:
   4745         mBeaconMuteRefCount++;
   4746         break;
   4747     case STOPPING_OUTPUT:
   4748         if (mBeaconMuteRefCount > 0) {
   4749             mBeaconMuteRefCount--;
   4750         }
   4751         break;
   4752     case STARTING_BEACON:
   4753         mBeaconPlayingRefCount++;
   4754         break;
   4755     case STOPPING_BEACON:
   4756         if (mBeaconPlayingRefCount > 0) {
   4757             mBeaconPlayingRefCount--;
   4758         }
   4759         break;
   4760     }
   4761 
   4762     if (mBeaconMuteRefCount > 0) {
   4763         // any playback causes beacon to be muted
   4764         return setBeaconMute(true);
   4765     } else {
   4766         // no other playback: unmute when beacon starts playing, mute when it stops
   4767         return setBeaconMute(mBeaconPlayingRefCount == 0);
   4768     }
   4769 }
   4770 
   4771 uint32_t AudioPolicyManager::setBeaconMute(bool mute) {
   4772     ALOGV("setBeaconMute(%d) mBeaconMuteRefCount=%d mBeaconPlayingRefCount=%d",
   4773             mute, mBeaconMuteRefCount, mBeaconPlayingRefCount);
   4774     // keep track of muted state to avoid repeating mute/unmute operations
   4775     if (mBeaconMuted != mute) {
   4776         // mute/unmute AUDIO_STREAM_TTS on all outputs
   4777         ALOGV("\t muting %d", mute);
   4778         uint32_t maxLatency = 0;
   4779         for (size_t i = 0; i < mOutputs.size(); i++) {
   4780             sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
   4781             setStreamMute(AUDIO_STREAM_TTS, mute/*on*/,
   4782                     desc,
   4783                     0 /*delay*/, AUDIO_DEVICE_NONE);
   4784             const uint32_t latency = desc->latency() * 2;
   4785             if (latency > maxLatency) {
   4786                 maxLatency = latency;
   4787             }
   4788         }
   4789         mBeaconMuted = mute;
   4790         return maxLatency;
   4791     }
   4792     return 0;
   4793 }
   4794 
   4795 audio_devices_t AudioPolicyManager::getDeviceForStrategy(routing_strategy strategy,
   4796                                                          bool fromCache)
   4797 {
   4798     // Routing
   4799     // see if we have an explicit route
   4800     // scan the whole RouteMap, for each entry, convert the stream type to a strategy
   4801     // (getStrategy(stream)).
   4802     // if the strategy from the stream type in the RouteMap is the same as the argument above,
   4803     // and activity count is non-zero
   4804     // the device = the device from the descriptor in the RouteMap, and exit.
   4805     for (size_t routeIndex = 0; routeIndex < mOutputRoutes.size(); routeIndex++) {
   4806         sp<SessionRoute> route = mOutputRoutes.valueAt(routeIndex);
   4807         routing_strategy routeStrategy = getStrategy(route->mStreamType);
   4808         if ((routeStrategy == strategy) && route->isActive()) {
   4809             return route->mDeviceDescriptor->type();
   4810         }
   4811     }
   4812 
   4813     if (fromCache) {
   4814         ALOGVV("getDeviceForStrategy() from cache strategy %d, device %x",
   4815               strategy, mDeviceForStrategy[strategy]);
   4816         return mDeviceForStrategy[strategy];
   4817     }
   4818     return mEngine->getDeviceForStrategy(strategy);
   4819 }
   4820 
   4821 void AudioPolicyManager::updateDevicesAndOutputs()
   4822 {
   4823     for (int i = 0; i < NUM_STRATEGIES; i++) {
   4824         mDeviceForStrategy[i] = getDeviceForStrategy((routing_strategy)i, false /*fromCache*/);
   4825     }
   4826     mPreviousOutputs = mOutputs;
   4827 }
   4828 
   4829 uint32_t AudioPolicyManager::checkDeviceMuteStrategies(const sp<AudioOutputDescriptor>& outputDesc,
   4830                                                        audio_devices_t prevDevice,
   4831                                                        uint32_t delayMs)
   4832 {
   4833     // mute/unmute strategies using an incompatible device combination
   4834     // if muting, wait for the audio in pcm buffer to be drained before proceeding
   4835     // if unmuting, unmute only after the specified delay
   4836     if (outputDesc->isDuplicated()) {
   4837         return 0;
   4838     }
   4839 
   4840     uint32_t muteWaitMs = 0;
   4841     audio_devices_t device = outputDesc->device();
   4842     bool shouldMute = outputDesc->isActive() && (popcount(device) >= 2);
   4843 
   4844     for (size_t i = 0; i < NUM_STRATEGIES; i++) {
   4845         audio_devices_t curDevice = getDeviceForStrategy((routing_strategy)i, false /*fromCache*/);
   4846         curDevice = curDevice & outputDesc->supportedDevices();
   4847         bool mute = shouldMute && (curDevice & device) && (curDevice != device);
   4848         bool doMute = false;
   4849 
   4850         if (mute && !outputDesc->mStrategyMutedByDevice[i]) {
   4851             doMute = true;
   4852             outputDesc->mStrategyMutedByDevice[i] = true;
   4853         } else if (!mute && outputDesc->mStrategyMutedByDevice[i]){
   4854             doMute = true;
   4855             outputDesc->mStrategyMutedByDevice[i] = false;
   4856         }
   4857         if (doMute) {
   4858             for (size_t j = 0; j < mOutputs.size(); j++) {
   4859                 sp<AudioOutputDescriptor> desc = mOutputs.valueAt(j);
   4860                 // skip output if it does not share any device with current output
   4861                 if ((desc->supportedDevices() & outputDesc->supportedDevices())
   4862                         == AUDIO_DEVICE_NONE) {
   4863                     continue;
   4864                 }
   4865                 ALOGVV("checkDeviceMuteStrategies() %s strategy %zu (curDevice %04x)",
   4866                       mute ? "muting" : "unmuting", i, curDevice);
   4867                 setStrategyMute((routing_strategy)i, mute, desc, mute ? 0 : delayMs);
   4868                 if (isStrategyActive(desc, (routing_strategy)i)) {
   4869                     if (mute) {
   4870                         // FIXME: should not need to double latency if volume could be applied
   4871                         // immediately by the audioflinger mixer. We must account for the delay
   4872                         // between now and the next time the audioflinger thread for this output
   4873                         // will process a buffer (which corresponds to one buffer size,
   4874                         // usually 1/2 or 1/4 of the latency).
   4875                         if (muteWaitMs < desc->latency() * 2) {
   4876                             muteWaitMs = desc->latency() * 2;
   4877                         }
   4878                     }
   4879                 }
   4880             }
   4881         }
   4882     }
   4883 
   4884     // temporary mute output if device selection changes to avoid volume bursts due to
   4885     // different per device volumes
   4886     if (outputDesc->isActive() && (device != prevDevice)) {
   4887         uint32_t tempMuteWaitMs = outputDesc->latency() * 2;
   4888         // temporary mute duration is conservatively set to 4 times the reported latency
   4889         uint32_t tempMuteDurationMs = outputDesc->latency() * 4;
   4890         if (muteWaitMs < tempMuteWaitMs) {
   4891             muteWaitMs = tempMuteWaitMs;
   4892         }
   4893 
   4894         for (size_t i = 0; i < NUM_STRATEGIES; i++) {
   4895             if (isStrategyActive(outputDesc, (routing_strategy)i)) {
   4896                 // make sure that we do not start the temporary mute period too early in case of
   4897                 // delayed device change
   4898                 setStrategyMute((routing_strategy)i, true, outputDesc, delayMs);
   4899                 setStrategyMute((routing_strategy)i, false, outputDesc,
   4900                                 delayMs + tempMuteDurationMs, device);
   4901             }
   4902         }
   4903     }
   4904 
   4905     // wait for the PCM output buffers to empty before proceeding with the rest of the command
   4906     if (muteWaitMs > delayMs) {
   4907         muteWaitMs -= delayMs;
   4908         usleep(muteWaitMs * 1000);
   4909         return muteWaitMs;
   4910     }
   4911     return 0;
   4912 }
   4913 
   4914 uint32_t AudioPolicyManager::setOutputDevice(const sp<AudioOutputDescriptor>& outputDesc,
   4915                                              audio_devices_t device,
   4916                                              bool force,
   4917                                              int delayMs,
   4918                                              audio_patch_handle_t *patchHandle,
   4919                                              const char* address)
   4920 {
   4921     ALOGV("setOutputDevice() device %04x delayMs %d", device, delayMs);
   4922     AudioParameter param;
   4923     uint32_t muteWaitMs;
   4924 
   4925     if (outputDesc->isDuplicated()) {
   4926         muteWaitMs = setOutputDevice(outputDesc->subOutput1(), device, force, delayMs);
   4927         muteWaitMs += setOutputDevice(outputDesc->subOutput2(), device, force, delayMs);
   4928         return muteWaitMs;
   4929     }
   4930     // no need to proceed if new device is not AUDIO_DEVICE_NONE and not supported by current
   4931     // output profile
   4932     if ((device != AUDIO_DEVICE_NONE) &&
   4933             ((device & outputDesc->supportedDevices()) == 0)) {
   4934         return 0;
   4935     }
   4936 
   4937     // filter devices according to output selected
   4938     device = (audio_devices_t)(device & outputDesc->supportedDevices());
   4939 
   4940     audio_devices_t prevDevice = outputDesc->mDevice;
   4941 
   4942     ALOGV("setOutputDevice() prevDevice 0x%04x", prevDevice);
   4943 
   4944     if (device != AUDIO_DEVICE_NONE) {
   4945         outputDesc->mDevice = device;
   4946     }
   4947     muteWaitMs = checkDeviceMuteStrategies(outputDesc, prevDevice, delayMs);
   4948 
   4949     // Do not change the routing if:
   4950     //      the requested device is AUDIO_DEVICE_NONE
   4951     //      OR the requested device is the same as current device
   4952     //  AND force is not specified
   4953     //  AND the output is connected by a valid audio patch.
   4954     // Doing this check here allows the caller to call setOutputDevice() without conditions
   4955     if ((device == AUDIO_DEVICE_NONE || device == prevDevice) &&
   4956         !force &&
   4957         outputDesc->getPatchHandle() != 0) {
   4958         ALOGV("setOutputDevice() setting same device 0x%04x or null device", device);
   4959         return muteWaitMs;
   4960     }
   4961 
   4962     ALOGV("setOutputDevice() changing device");
   4963 
   4964     // do the routing
   4965     if (device == AUDIO_DEVICE_NONE) {
   4966         resetOutputDevice(outputDesc, delayMs, NULL);
   4967     } else {
   4968         DeviceVector deviceList;
   4969         if ((address == NULL) || (strlen(address) == 0)) {
   4970             deviceList = mAvailableOutputDevices.getDevicesFromType(device);
   4971         } else {
   4972             deviceList = mAvailableOutputDevices.getDevicesFromTypeAddr(device, String8(address));
   4973         }
   4974 
   4975         if (!deviceList.isEmpty()) {
   4976             struct audio_patch patch;
   4977             outputDesc->toAudioPortConfig(&patch.sources[0]);
   4978             patch.num_sources = 1;
   4979             patch.num_sinks = 0;
   4980             for (size_t i = 0; i < deviceList.size() && i < AUDIO_PATCH_PORTS_MAX; i++) {
   4981                 deviceList.itemAt(i)->toAudioPortConfig(&patch.sinks[i]);
   4982                 patch.num_sinks++;
   4983             }
   4984             ssize_t index;
   4985             if (patchHandle && *patchHandle != AUDIO_PATCH_HANDLE_NONE) {
   4986                 index = mAudioPatches.indexOfKey(*patchHandle);
   4987             } else {
   4988                 index = mAudioPatches.indexOfKey(outputDesc->getPatchHandle());
   4989             }
   4990             sp< AudioPatch> patchDesc;
   4991             audio_patch_handle_t afPatchHandle = AUDIO_PATCH_HANDLE_NONE;
   4992             if (index >= 0) {
   4993                 patchDesc = mAudioPatches.valueAt(index);
   4994                 afPatchHandle = patchDesc->mAfPatchHandle;
   4995             }
   4996 
   4997             status_t status = mpClientInterface->createAudioPatch(&patch,
   4998                                                                    &afPatchHandle,
   4999                                                                    delayMs);
   5000             ALOGV("setOutputDevice() createAudioPatch returned %d patchHandle %d"
   5001                     "num_sources %d num_sinks %d",
   5002                                        status, afPatchHandle, patch.num_sources, patch.num_sinks);
   5003             if (status == NO_ERROR) {
   5004                 if (index < 0) {
   5005                     patchDesc = new AudioPatch(&patch, mUidCached);
   5006                     addAudioPatch(patchDesc->mHandle, patchDesc);
   5007                 } else {
   5008                     patchDesc->mPatch = patch;
   5009                 }
   5010                 patchDesc->mAfPatchHandle = afPatchHandle;
   5011                 if (patchHandle) {
   5012                     *patchHandle = patchDesc->mHandle;
   5013                 }
   5014                 outputDesc->setPatchHandle(patchDesc->mHandle);
   5015                 nextAudioPortGeneration();
   5016                 mpClientInterface->onAudioPatchListUpdate();
   5017             }
   5018         }
   5019 
   5020         // inform all input as well
   5021         for (size_t i = 0; i < mInputs.size(); i++) {
   5022             const sp<AudioInputDescriptor>  inputDescriptor = mInputs.valueAt(i);
   5023             if (!is_virtual_input_device(inputDescriptor->mDevice)) {
   5024                 AudioParameter inputCmd = AudioParameter();
   5025                 ALOGV("%s: inform input %d of device:%d", __func__,
   5026                       inputDescriptor->mIoHandle, device);
   5027                 inputCmd.addInt(String8(AudioParameter::keyRouting),device);
   5028                 mpClientInterface->setParameters(inputDescriptor->mIoHandle,
   5029                                                  inputCmd.toString(),
   5030                                                  delayMs);
   5031             }
   5032         }
   5033     }
   5034 
   5035     // update stream volumes according to new device
   5036     applyStreamVolumes(outputDesc, device, delayMs);
   5037 
   5038     return muteWaitMs;
   5039 }
   5040 
   5041 status_t AudioPolicyManager::resetOutputDevice(const sp<AudioOutputDescriptor>& outputDesc,
   5042                                                int delayMs,
   5043                                                audio_patch_handle_t *patchHandle)
   5044 {
   5045     ssize_t index;
   5046     if (patchHandle) {
   5047         index = mAudioPatches.indexOfKey(*patchHandle);
   5048     } else {
   5049         index = mAudioPatches.indexOfKey(outputDesc->getPatchHandle());
   5050     }
   5051     if (index < 0) {
   5052         return INVALID_OPERATION;
   5053     }
   5054     sp< AudioPatch> patchDesc = mAudioPatches.valueAt(index);
   5055     status_t status = mpClientInterface->releaseAudioPatch(patchDesc->mAfPatchHandle, delayMs);
   5056     ALOGV("resetOutputDevice() releaseAudioPatch returned %d", status);
   5057     outputDesc->setPatchHandle(AUDIO_PATCH_HANDLE_NONE);
   5058     removeAudioPatch(patchDesc->mHandle);
   5059     nextAudioPortGeneration();
   5060     mpClientInterface->onAudioPatchListUpdate();
   5061     return status;
   5062 }
   5063 
   5064 status_t AudioPolicyManager::setInputDevice(audio_io_handle_t input,
   5065                                             audio_devices_t device,
   5066                                             bool force,
   5067                                             audio_patch_handle_t *patchHandle)
   5068 {
   5069     status_t status = NO_ERROR;
   5070 
   5071     sp<AudioInputDescriptor> inputDesc = mInputs.valueFor(input);
   5072     if ((device != AUDIO_DEVICE_NONE) && ((device != inputDesc->mDevice) || force)) {
   5073         inputDesc->mDevice = device;
   5074 
   5075         DeviceVector deviceList = mAvailableInputDevices.getDevicesFromType(device);
   5076         if (!deviceList.isEmpty()) {
   5077             struct audio_patch patch;
   5078             inputDesc->toAudioPortConfig(&patch.sinks[0]);
   5079             // AUDIO_SOURCE_HOTWORD is for internal use only:
   5080             // handled as AUDIO_SOURCE_VOICE_RECOGNITION by the audio HAL
   5081             if (patch.sinks[0].ext.mix.usecase.source == AUDIO_SOURCE_HOTWORD &&
   5082                     !inputDesc->isSoundTrigger()) {
   5083                 patch.sinks[0].ext.mix.usecase.source = AUDIO_SOURCE_VOICE_RECOGNITION;
   5084             }
   5085             patch.num_sinks = 1;
   5086             //only one input device for now
   5087             deviceList.itemAt(0)->toAudioPortConfig(&patch.sources[0]);
   5088             patch.num_sources = 1;
   5089             ssize_t index;
   5090             if (patchHandle && *patchHandle != AUDIO_PATCH_HANDLE_NONE) {
   5091                 index = mAudioPatches.indexOfKey(*patchHandle);
   5092             } else {
   5093                 index = mAudioPatches.indexOfKey(inputDesc->getPatchHandle());
   5094             }
   5095             sp< AudioPatch> patchDesc;
   5096             audio_patch_handle_t afPatchHandle = AUDIO_PATCH_HANDLE_NONE;
   5097             if (index >= 0) {
   5098                 patchDesc = mAudioPatches.valueAt(index);
   5099                 afPatchHandle = patchDesc->mAfPatchHandle;
   5100             }
   5101 
   5102             status_t status = mpClientInterface->createAudioPatch(&patch,
   5103                                                                   &afPatchHandle,
   5104                                                                   0);
   5105             ALOGV("setInputDevice() createAudioPatch returned %d patchHandle %d",
   5106                                                                           status, afPatchHandle);
   5107             if (status == NO_ERROR) {
   5108                 if (index < 0) {
   5109                     patchDesc = new AudioPatch(&patch, mUidCached);
   5110                     addAudioPatch(patchDesc->mHandle, patchDesc);
   5111                 } else {
   5112                     patchDesc->mPatch = patch;
   5113                 }
   5114                 patchDesc->mAfPatchHandle = afPatchHandle;
   5115                 if (patchHandle) {
   5116                     *patchHandle = patchDesc->mHandle;
   5117                 }
   5118                 inputDesc->setPatchHandle(patchDesc->mHandle);
   5119                 nextAudioPortGeneration();
   5120                 mpClientInterface->onAudioPatchListUpdate();
   5121             }
   5122         }
   5123     }
   5124     return status;
   5125 }
   5126 
   5127 status_t AudioPolicyManager::resetInputDevice(audio_io_handle_t input,
   5128                                               audio_patch_handle_t *patchHandle)
   5129 {
   5130     sp<AudioInputDescriptor> inputDesc = mInputs.valueFor(input);
   5131     ssize_t index;
   5132     if (patchHandle) {
   5133         index = mAudioPatches.indexOfKey(*patchHandle);
   5134     } else {
   5135         index = mAudioPatches.indexOfKey(inputDesc->getPatchHandle());
   5136     }
   5137     if (index < 0) {
   5138         return INVALID_OPERATION;
   5139     }
   5140     sp< AudioPatch> patchDesc = mAudioPatches.valueAt(index);
   5141     status_t status = mpClientInterface->releaseAudioPatch(patchDesc->mAfPatchHandle, 0);
   5142     ALOGV("resetInputDevice() releaseAudioPatch returned %d", status);
   5143     inputDesc->setPatchHandle(AUDIO_PATCH_HANDLE_NONE);
   5144     removeAudioPatch(patchDesc->mHandle);
   5145     nextAudioPortGeneration();
   5146     mpClientInterface->onAudioPatchListUpdate();
   5147     return status;
   5148 }
   5149 
   5150 sp<IOProfile> AudioPolicyManager::getInputProfile(audio_devices_t device,
   5151                                                   const String8& address,
   5152                                                   uint32_t& samplingRate,
   5153                                                   audio_format_t& format,
   5154                                                   audio_channel_mask_t& channelMask,
   5155                                                   audio_input_flags_t flags)
   5156 {
   5157     // Choose an input profile based on the requested capture parameters: select the first available
   5158     // profile supporting all requested parameters.
   5159     //
   5160     // TODO: perhaps isCompatibleProfile should return a "matching" score so we can return
   5161     // the best matching profile, not the first one.
   5162 
   5163     for (size_t i = 0; i < mHwModules.size(); i++)
   5164     {
   5165         if (mHwModules[i]->mHandle == 0) {
   5166             continue;
   5167         }
   5168         for (size_t j = 0; j < mHwModules[i]->mInputProfiles.size(); j++)
   5169         {
   5170             sp<IOProfile> profile = mHwModules[i]->mInputProfiles[j];
   5171             // profile->log();
   5172             if (profile->isCompatibleProfile(device, address, samplingRate,
   5173                                              &samplingRate /*updatedSamplingRate*/,
   5174                                              format,
   5175                                              &format /*updatedFormat*/,
   5176                                              channelMask,
   5177                                              &channelMask /*updatedChannelMask*/,
   5178                                              (audio_output_flags_t) flags)) {
   5179 
   5180                 return profile;
   5181             }
   5182         }
   5183     }
   5184     return NULL;
   5185 }
   5186 
   5187 
   5188 audio_devices_t AudioPolicyManager::getDeviceAndMixForInputSource(audio_source_t inputSource,
   5189                                                                   AudioMix **policyMix)
   5190 {
   5191     audio_devices_t availableDeviceTypes = mAvailableInputDevices.types() & ~AUDIO_DEVICE_BIT_IN;
   5192     audio_devices_t selectedDeviceFromMix =
   5193            mPolicyMixes.getDeviceAndMixForInputSource(inputSource, availableDeviceTypes, policyMix);
   5194 
   5195     if (selectedDeviceFromMix != AUDIO_DEVICE_NONE) {
   5196         return selectedDeviceFromMix;
   5197     }
   5198     return getDeviceForInputSource(inputSource);
   5199 }
   5200 
   5201 audio_devices_t AudioPolicyManager::getDeviceForInputSource(audio_source_t inputSource)
   5202 {
   5203     for (size_t routeIndex = 0; routeIndex < mInputRoutes.size(); routeIndex++) {
   5204          sp<SessionRoute> route = mInputRoutes.valueAt(routeIndex);
   5205          if (inputSource == route->mSource && route->isActive()) {
   5206              return route->mDeviceDescriptor->type();
   5207          }
   5208      }
   5209 
   5210      return mEngine->getDeviceForInputSource(inputSource);
   5211 }
   5212 
   5213 float AudioPolicyManager::computeVolume(audio_stream_type_t stream,
   5214                                         int index,
   5215                                         audio_devices_t device)
   5216 {
   5217     float volumeDB = mVolumeCurves->volIndexToDb(stream, Volume::getDeviceCategory(device), index);
   5218 
   5219     // handle the case of accessibility active while a ringtone is playing: if the ringtone is much
   5220     // louder than the accessibility prompt, the prompt cannot be heard, thus masking the touch
   5221     // exploration of the dialer UI. In this situation, bring the accessibility volume closer to
   5222     // the ringtone volume
   5223     if ((stream == AUDIO_STREAM_ACCESSIBILITY)
   5224             && (AUDIO_MODE_RINGTONE == mEngine->getPhoneState())
   5225             && isStreamActive(AUDIO_STREAM_RING, 0)) {
   5226         const float ringVolumeDB = computeVolume(AUDIO_STREAM_RING, index, device);
   5227         return ringVolumeDB - 4 > volumeDB ? ringVolumeDB - 4 : volumeDB;
   5228     }
   5229 
   5230     // if a headset is connected, apply the following rules to ring tones and notifications
   5231     // to avoid sound level bursts in user's ears:
   5232     // - always attenuate notifications volume by 6dB
   5233     // - attenuate ring tones volume by 6dB unless music is not playing and
   5234     // speaker is part of the select devices
   5235     // - if music is playing, always limit the volume to current music volume,
   5236     // with a minimum threshold at -36dB so that notification is always perceived.
   5237     const routing_strategy stream_strategy = getStrategy(stream);
   5238     if ((device & (AUDIO_DEVICE_OUT_BLUETOOTH_A2DP |
   5239             AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES |
   5240             AUDIO_DEVICE_OUT_WIRED_HEADSET |
   5241             AUDIO_DEVICE_OUT_WIRED_HEADPHONE |
   5242             AUDIO_DEVICE_OUT_USB_HEADSET)) &&
   5243         ((stream_strategy == STRATEGY_SONIFICATION)
   5244                 || (stream_strategy == STRATEGY_SONIFICATION_RESPECTFUL)
   5245                 || (stream == AUDIO_STREAM_SYSTEM)
   5246                 || ((stream_strategy == STRATEGY_ENFORCED_AUDIBLE) &&
   5247                     (mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_SYSTEM) == AUDIO_POLICY_FORCE_NONE))) &&
   5248             mVolumeCurves->canBeMuted(stream)) {
   5249         // when the phone is ringing we must consider that music could have been paused just before
   5250         // by the music application and behave as if music was active if the last music track was
   5251         // just stopped
   5252         if (isStreamActive(AUDIO_STREAM_MUSIC, SONIFICATION_HEADSET_MUSIC_DELAY) ||
   5253                 mLimitRingtoneVolume) {
   5254             volumeDB += SONIFICATION_HEADSET_VOLUME_FACTOR_DB;
   5255             audio_devices_t musicDevice = getDeviceForStrategy(STRATEGY_MEDIA, true /*fromCache*/);
   5256             float musicVolDB = computeVolume(AUDIO_STREAM_MUSIC,
   5257                                              mVolumeCurves->getVolumeIndex(AUDIO_STREAM_MUSIC,
   5258                                                                               musicDevice),
   5259                                              musicDevice);
   5260             float minVolDB = (musicVolDB > SONIFICATION_HEADSET_VOLUME_MIN_DB) ?
   5261                     musicVolDB : SONIFICATION_HEADSET_VOLUME_MIN_DB;
   5262             if (volumeDB > minVolDB) {
   5263                 volumeDB = minVolDB;
   5264                 ALOGV("computeVolume limiting volume to %f musicVol %f", minVolDB, musicVolDB);
   5265             }
   5266             if (device & (AUDIO_DEVICE_OUT_BLUETOOTH_A2DP |
   5267                     AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES)) {
   5268                 // on A2DP, also ensure notification volume is not too low compared to media when
   5269                 // intended to be played
   5270                 if ((volumeDB > -96.0f) &&
   5271                         (musicVolDB - SONIFICATION_A2DP_MAX_MEDIA_DIFF_DB > volumeDB)) {
   5272                     ALOGV("computeVolume increasing volume for stream=%d device=0x%X from %f to %f",
   5273                             stream, device,
   5274                             volumeDB, musicVolDB - SONIFICATION_A2DP_MAX_MEDIA_DIFF_DB);
   5275                     volumeDB = musicVolDB - SONIFICATION_A2DP_MAX_MEDIA_DIFF_DB;
   5276                 }
   5277             }
   5278         } else if ((Volume::getDeviceForVolume(device) != AUDIO_DEVICE_OUT_SPEAKER) ||
   5279                 stream_strategy != STRATEGY_SONIFICATION) {
   5280             volumeDB += SONIFICATION_HEADSET_VOLUME_FACTOR_DB;
   5281         }
   5282     }
   5283 
   5284     return volumeDB;
   5285 }
   5286 
   5287 status_t AudioPolicyManager::checkAndSetVolume(audio_stream_type_t stream,
   5288                                                    int index,
   5289                                                    const sp<AudioOutputDescriptor>& outputDesc,
   5290                                                    audio_devices_t device,
   5291                                                    int delayMs,
   5292                                                    bool force)
   5293 {
   5294     // do not change actual stream volume if the stream is muted
   5295     if (outputDesc->mMuteCount[stream] != 0) {
   5296         ALOGVV("checkAndSetVolume() stream %d muted count %d",
   5297               stream, outputDesc->mMuteCount[stream]);
   5298         return NO_ERROR;
   5299     }
   5300     audio_policy_forced_cfg_t forceUseForComm =
   5301             mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_COMMUNICATION);
   5302     // do not change in call volume if bluetooth is connected and vice versa
   5303     if ((stream == AUDIO_STREAM_VOICE_CALL && forceUseForComm == AUDIO_POLICY_FORCE_BT_SCO) ||
   5304         (stream == AUDIO_STREAM_BLUETOOTH_SCO && forceUseForComm != AUDIO_POLICY_FORCE_BT_SCO)) {
   5305         ALOGV("checkAndSetVolume() cannot set stream %d volume with force use = %d for comm",
   5306              stream, forceUseForComm);
   5307         return INVALID_OPERATION;
   5308     }
   5309 
   5310     if (device == AUDIO_DEVICE_NONE) {
   5311         device = outputDesc->device();
   5312     }
   5313 
   5314     float volumeDb = computeVolume(stream, index, device);
   5315     if (outputDesc->isFixedVolume(device)) {
   5316         volumeDb = 0.0f;
   5317     }
   5318 
   5319     outputDesc->setVolume(volumeDb, stream, device, delayMs, force);
   5320 
   5321     if (stream == AUDIO_STREAM_VOICE_CALL ||
   5322         stream == AUDIO_STREAM_BLUETOOTH_SCO) {
   5323         float voiceVolume;
   5324         // Force voice volume to max for bluetooth SCO as volume is managed by the headset
   5325         if (stream == AUDIO_STREAM_VOICE_CALL) {
   5326             voiceVolume = (float)index/(float)mVolumeCurves->getVolumeIndexMax(stream);
   5327         } else {
   5328             voiceVolume = 1.0;
   5329         }
   5330 
   5331         if (voiceVolume != mLastVoiceVolume) {
   5332             mpClientInterface->setVoiceVolume(voiceVolume, delayMs);
   5333             mLastVoiceVolume = voiceVolume;
   5334         }
   5335     }
   5336 
   5337     return NO_ERROR;
   5338 }
   5339 
   5340 void AudioPolicyManager::applyStreamVolumes(const sp<AudioOutputDescriptor>& outputDesc,
   5341                                                 audio_devices_t device,
   5342                                                 int delayMs,
   5343                                                 bool force)
   5344 {
   5345     ALOGVV("applyStreamVolumes() for device %08x", device);
   5346 
   5347     for (int stream = 0; stream < AUDIO_STREAM_FOR_POLICY_CNT; stream++) {
   5348         checkAndSetVolume((audio_stream_type_t)stream,
   5349                           mVolumeCurves->getVolumeIndex((audio_stream_type_t)stream, device),
   5350                           outputDesc,
   5351                           device,
   5352                           delayMs,
   5353                           force);
   5354     }
   5355 }
   5356 
   5357 void AudioPolicyManager::setStrategyMute(routing_strategy strategy,
   5358                                              bool on,
   5359                                              const sp<AudioOutputDescriptor>& outputDesc,
   5360                                              int delayMs,
   5361                                              audio_devices_t device)
   5362 {
   5363     ALOGVV("setStrategyMute() strategy %d, mute %d, output ID %d",
   5364            strategy, on, outputDesc->getId());
   5365     for (int stream = 0; stream < AUDIO_STREAM_FOR_POLICY_CNT; stream++) {
   5366         if (getStrategy((audio_stream_type_t)stream) == strategy) {
   5367             setStreamMute((audio_stream_type_t)stream, on, outputDesc, delayMs, device);
   5368         }
   5369     }
   5370 }
   5371 
   5372 void AudioPolicyManager::setStreamMute(audio_stream_type_t stream,
   5373                                            bool on,
   5374                                            const sp<AudioOutputDescriptor>& outputDesc,
   5375                                            int delayMs,
   5376                                            audio_devices_t device)
   5377 {
   5378     if (device == AUDIO_DEVICE_NONE) {
   5379         device = outputDesc->device();
   5380     }
   5381 
   5382     ALOGVV("setStreamMute() stream %d, mute %d, mMuteCount %d device %04x",
   5383           stream, on, outputDesc->mMuteCount[stream], device);
   5384 
   5385     if (on) {
   5386         if (outputDesc->mMuteCount[stream] == 0) {
   5387             if (mVolumeCurves->canBeMuted(stream) &&
   5388                     ((stream != AUDIO_STREAM_ENFORCED_AUDIBLE) ||
   5389                      (mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_SYSTEM) == AUDIO_POLICY_FORCE_NONE))) {
   5390                 checkAndSetVolume(stream, 0, outputDesc, device, delayMs);
   5391             }
   5392         }
   5393         // increment mMuteCount after calling checkAndSetVolume() so that volume change is not ignored
   5394         outputDesc->mMuteCount[stream]++;
   5395     } else {
   5396         if (outputDesc->mMuteCount[stream] == 0) {
   5397             ALOGV("setStreamMute() unmuting non muted stream!");
   5398             return;
   5399         }
   5400         if (--outputDesc->mMuteCount[stream] == 0) {
   5401             checkAndSetVolume(stream,
   5402                               mVolumeCurves->getVolumeIndex(stream, device),
   5403                               outputDesc,
   5404                               device,
   5405                               delayMs);
   5406         }
   5407     }
   5408 }
   5409 
   5410 void AudioPolicyManager::handleIncallSonification(audio_stream_type_t stream,
   5411                                                       bool starting, bool stateChange)
   5412 {
   5413     if(!hasPrimaryOutput()) {
   5414         return;
   5415     }
   5416 
   5417     // if the stream pertains to sonification strategy and we are in call we must
   5418     // mute the stream if it is low visibility. If it is high visibility, we must play a tone
   5419     // in the device used for phone strategy and play the tone if the selected device does not
   5420     // interfere with the device used for phone strategy
   5421     // if stateChange is true, we are called from setPhoneState() and we must mute or unmute as
   5422     // many times as there are active tracks on the output
   5423     const routing_strategy stream_strategy = getStrategy(stream);
   5424     if ((stream_strategy == STRATEGY_SONIFICATION) ||
   5425             ((stream_strategy == STRATEGY_SONIFICATION_RESPECTFUL))) {
   5426         sp<SwAudioOutputDescriptor> outputDesc = mPrimaryOutput;
   5427         ALOGV("handleIncallSonification() stream %d starting %d device %x stateChange %d",
   5428                 stream, starting, outputDesc->mDevice, stateChange);
   5429         if (outputDesc->mRefCount[stream]) {
   5430             int muteCount = 1;
   5431             if (stateChange) {
   5432                 muteCount = outputDesc->mRefCount[stream];
   5433             }
   5434             if (audio_is_low_visibility(stream)) {
   5435                 ALOGV("handleIncallSonification() low visibility, muteCount %d", muteCount);
   5436                 for (int i = 0; i < muteCount; i++) {
   5437                     setStreamMute(stream, starting, mPrimaryOutput);
   5438                 }
   5439             } else {
   5440                 ALOGV("handleIncallSonification() high visibility");
   5441                 if (outputDesc->device() &
   5442                         getDeviceForStrategy(STRATEGY_PHONE, true /*fromCache*/)) {
   5443                     ALOGV("handleIncallSonification() high visibility muted, muteCount %d", muteCount);
   5444                     for (int i = 0; i < muteCount; i++) {
   5445                         setStreamMute(stream, starting, mPrimaryOutput);
   5446                     }
   5447                 }
   5448                 if (starting) {
   5449                     mpClientInterface->startTone(AUDIO_POLICY_TONE_IN_CALL_NOTIFICATION,
   5450                                                  AUDIO_STREAM_VOICE_CALL);
   5451                 } else {
   5452                     mpClientInterface->stopTone();
   5453                 }
   5454             }
   5455         }
   5456     }
   5457 }
   5458 
   5459 audio_stream_type_t AudioPolicyManager::streamTypefromAttributesInt(const audio_attributes_t *attr)
   5460 {
   5461     // flags to stream type mapping
   5462     if ((attr->flags & AUDIO_FLAG_AUDIBILITY_ENFORCED) == AUDIO_FLAG_AUDIBILITY_ENFORCED) {
   5463         return AUDIO_STREAM_ENFORCED_AUDIBLE;
   5464     }
   5465     if ((attr->flags & AUDIO_FLAG_SCO) == AUDIO_FLAG_SCO) {
   5466         return AUDIO_STREAM_BLUETOOTH_SCO;
   5467     }
   5468     if ((attr->flags & AUDIO_FLAG_BEACON) == AUDIO_FLAG_BEACON) {
   5469         return AUDIO_STREAM_TTS;
   5470     }
   5471 
   5472     // usage to stream type mapping
   5473     switch (attr->usage) {
   5474     case AUDIO_USAGE_MEDIA:
   5475     case AUDIO_USAGE_GAME:
   5476     case AUDIO_USAGE_ASSISTANT:
   5477     case AUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE:
   5478         return AUDIO_STREAM_MUSIC;
   5479     case AUDIO_USAGE_ASSISTANCE_ACCESSIBILITY:
   5480         return AUDIO_STREAM_ACCESSIBILITY;
   5481     case AUDIO_USAGE_ASSISTANCE_SONIFICATION:
   5482         return AUDIO_STREAM_SYSTEM;
   5483     case AUDIO_USAGE_VOICE_COMMUNICATION:
   5484         return AUDIO_STREAM_VOICE_CALL;
   5485 
   5486     case AUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING:
   5487         return AUDIO_STREAM_DTMF;
   5488 
   5489     case AUDIO_USAGE_ALARM:
   5490         return AUDIO_STREAM_ALARM;
   5491     case AUDIO_USAGE_NOTIFICATION_TELEPHONY_RINGTONE:
   5492         return AUDIO_STREAM_RING;
   5493 
   5494     case AUDIO_USAGE_NOTIFICATION:
   5495     case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_REQUEST:
   5496     case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_INSTANT:
   5497     case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_DELAYED:
   5498     case AUDIO_USAGE_NOTIFICATION_EVENT:
   5499         return AUDIO_STREAM_NOTIFICATION;
   5500 
   5501     case AUDIO_USAGE_UNKNOWN:
   5502     default:
   5503         return AUDIO_STREAM_MUSIC;
   5504     }
   5505 }
   5506 
   5507 bool AudioPolicyManager::isValidAttributes(const audio_attributes_t *paa)
   5508 {
   5509     // has flags that map to a strategy?
   5510     if ((paa->flags & (AUDIO_FLAG_AUDIBILITY_ENFORCED | AUDIO_FLAG_SCO | AUDIO_FLAG_BEACON)) != 0) {
   5511         return true;
   5512     }
   5513 
   5514     // has known usage?
   5515     switch (paa->usage) {
   5516     case AUDIO_USAGE_UNKNOWN:
   5517     case AUDIO_USAGE_MEDIA:
   5518     case AUDIO_USAGE_VOICE_COMMUNICATION:
   5519     case AUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING:
   5520     case AUDIO_USAGE_ALARM:
   5521     case AUDIO_USAGE_NOTIFICATION:
   5522     case AUDIO_USAGE_NOTIFICATION_TELEPHONY_RINGTONE:
   5523     case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_REQUEST:
   5524     case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_INSTANT:
   5525     case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_DELAYED:
   5526     case AUDIO_USAGE_NOTIFICATION_EVENT:
   5527     case AUDIO_USAGE_ASSISTANCE_ACCESSIBILITY:
   5528     case AUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE:
   5529     case AUDIO_USAGE_ASSISTANCE_SONIFICATION:
   5530     case AUDIO_USAGE_GAME:
   5531     case AUDIO_USAGE_VIRTUAL_SOURCE:
   5532     case AUDIO_USAGE_ASSISTANT:
   5533         break;
   5534     default:
   5535         return false;
   5536     }
   5537     return true;
   5538 }
   5539 
   5540 bool AudioPolicyManager::isStrategyActive(const sp<AudioOutputDescriptor>& outputDesc,
   5541                                           routing_strategy strategy, uint32_t inPastMs,
   5542                                           nsecs_t sysTime) const
   5543 {
   5544     if ((sysTime == 0) && (inPastMs != 0)) {
   5545         sysTime = systemTime();
   5546     }
   5547     for (int i = 0; i < (int)AUDIO_STREAM_FOR_POLICY_CNT; i++) {
   5548         if (((getStrategy((audio_stream_type_t)i) == strategy) ||
   5549                 (NUM_STRATEGIES == strategy)) &&
   5550                 outputDesc->isStreamActive((audio_stream_type_t)i, inPastMs, sysTime)) {
   5551             return true;
   5552         }
   5553     }
   5554     return false;
   5555 }
   5556 
   5557 audio_policy_forced_cfg_t AudioPolicyManager::getForceUse(audio_policy_force_use_t usage)
   5558 {
   5559     return mEngine->getForceUse(usage);
   5560 }
   5561 
   5562 bool AudioPolicyManager::isInCall()
   5563 {
   5564     return isStateInCall(mEngine->getPhoneState());
   5565 }
   5566 
   5567 bool AudioPolicyManager::isStateInCall(int state)
   5568 {
   5569     return is_state_in_call(state);
   5570 }
   5571 
   5572 void AudioPolicyManager::cleanUpForDevice(const sp<DeviceDescriptor>& deviceDesc)
   5573 {
   5574     for (ssize_t i = (ssize_t)mAudioSources.size() - 1; i >= 0; i--)  {
   5575         sp<AudioSourceDescriptor> sourceDesc = mAudioSources.valueAt(i);
   5576         if (sourceDesc->mDevice->equals(deviceDesc)) {
   5577             ALOGV("%s releasing audio source %d", __FUNCTION__, sourceDesc->getHandle());
   5578             stopAudioSource(sourceDesc->getHandle());
   5579         }
   5580     }
   5581 
   5582     for (ssize_t i = (ssize_t)mAudioPatches.size() - 1; i >= 0; i--)  {
   5583         sp<AudioPatch> patchDesc = mAudioPatches.valueAt(i);
   5584         bool release = false;
   5585         for (size_t j = 0; j < patchDesc->mPatch.num_sources && !release; j++)  {
   5586             const struct audio_port_config *source = &patchDesc->mPatch.sources[j];
   5587             if (source->type == AUDIO_PORT_TYPE_DEVICE &&
   5588                     source->ext.device.type == deviceDesc->type()) {
   5589                 release = true;
   5590             }
   5591         }
   5592         for (size_t j = 0; j < patchDesc->mPatch.num_sinks && !release; j++)  {
   5593             const struct audio_port_config *sink = &patchDesc->mPatch.sinks[j];
   5594             if (sink->type == AUDIO_PORT_TYPE_DEVICE &&
   5595                     sink->ext.device.type == deviceDesc->type()) {
   5596                 release = true;
   5597             }
   5598         }
   5599         if (release) {
   5600             ALOGV("%s releasing patch %u", __FUNCTION__, patchDesc->mHandle);
   5601             releaseAudioPatch(patchDesc->mHandle, patchDesc->mUid);
   5602         }
   5603     }
   5604 }
   5605 
   5606 // Modify the list of surround sound formats supported.
   5607 void AudioPolicyManager::filterSurroundFormats(FormatVector *formatsPtr) {
   5608     FormatVector &formats = *formatsPtr;
   5609     // TODO Set this based on Config properties.
   5610     const bool alwaysForceAC3 = true;
   5611 
   5612     audio_policy_forced_cfg_t forceUse = mEngine->getForceUse(
   5613             AUDIO_POLICY_FORCE_FOR_ENCODED_SURROUND);
   5614     ALOGD("%s: forced use = %d", __FUNCTION__, forceUse);
   5615 
   5616     // Analyze original support for various formats.
   5617     bool supportsAC3 = false;
   5618     bool supportsOtherSurround = false;
   5619     bool supportsIEC61937 = false;
   5620     for (size_t formatIndex = 0; formatIndex < formats.size(); formatIndex++) {
   5621         audio_format_t format = formats[formatIndex];
   5622         switch (format) {
   5623             case AUDIO_FORMAT_AC3:
   5624                 supportsAC3 = true;
   5625                 break;
   5626             case AUDIO_FORMAT_E_AC3:
   5627             case AUDIO_FORMAT_DTS:
   5628             case AUDIO_FORMAT_DTS_HD:
   5629                 supportsOtherSurround = true;
   5630                 break;
   5631             case AUDIO_FORMAT_IEC61937:
   5632                 supportsIEC61937 = true;
   5633                 break;
   5634             default:
   5635                 break;
   5636         }
   5637     }
   5638 
   5639     // Modify formats based on surround preferences.
   5640     // If NEVER, remove support for surround formats.
   5641     if (forceUse == AUDIO_POLICY_FORCE_ENCODED_SURROUND_NEVER) {
   5642         if (supportsAC3 || supportsOtherSurround || supportsIEC61937) {
   5643             // Remove surround sound related formats.
   5644             for (size_t formatIndex = 0; formatIndex < formats.size(); ) {
   5645                 audio_format_t format = formats[formatIndex];
   5646                 switch(format) {
   5647                     case AUDIO_FORMAT_AC3:
   5648                     case AUDIO_FORMAT_E_AC3:
   5649                     case AUDIO_FORMAT_DTS:
   5650                     case AUDIO_FORMAT_DTS_HD:
   5651                     case AUDIO_FORMAT_IEC61937:
   5652                         formats.removeAt(formatIndex);
   5653                         break;
   5654                     default:
   5655                         formatIndex++; // keep it
   5656                         break;
   5657                 }
   5658             }
   5659             supportsAC3 = false;
   5660             supportsOtherSurround = false;
   5661             supportsIEC61937 = false;
   5662         }
   5663     } else { // AUTO or ALWAYS
   5664         // Most TVs support AC3 even if they do not report it in the EDID.
   5665         if ((alwaysForceAC3 || (forceUse == AUDIO_POLICY_FORCE_ENCODED_SURROUND_ALWAYS))
   5666                 && !supportsAC3) {
   5667             formats.add(AUDIO_FORMAT_AC3);
   5668             supportsAC3 = true;
   5669         }
   5670 
   5671         // If ALWAYS, add support for raw surround formats if all are missing.
   5672         // This assumes that if any of these formats are reported by the HAL
   5673         // then the report is valid and should not be modified.
   5674         if ((forceUse == AUDIO_POLICY_FORCE_ENCODED_SURROUND_ALWAYS)
   5675                 && !supportsOtherSurround) {
   5676             formats.add(AUDIO_FORMAT_E_AC3);
   5677             formats.add(AUDIO_FORMAT_DTS);
   5678             formats.add(AUDIO_FORMAT_DTS_HD);
   5679             supportsOtherSurround = true;
   5680         }
   5681 
   5682         // Add support for IEC61937 if any raw surround supported.
   5683         // The HAL could do this but add it here, just in case.
   5684         if ((supportsAC3 || supportsOtherSurround) && !supportsIEC61937) {
   5685             formats.add(AUDIO_FORMAT_IEC61937);
   5686             supportsIEC61937 = true;
   5687         }
   5688     }
   5689 }
   5690 
   5691 // Modify the list of channel masks supported.
   5692 void AudioPolicyManager::filterSurroundChannelMasks(ChannelsVector *channelMasksPtr) {
   5693     ChannelsVector &channelMasks = *channelMasksPtr;
   5694     audio_policy_forced_cfg_t forceUse = mEngine->getForceUse(
   5695             AUDIO_POLICY_FORCE_FOR_ENCODED_SURROUND);
   5696 
   5697     // If NEVER, then remove support for channelMasks > stereo.
   5698     if (forceUse == AUDIO_POLICY_FORCE_ENCODED_SURROUND_NEVER) {
   5699         for (size_t maskIndex = 0; maskIndex < channelMasks.size(); ) {
   5700             audio_channel_mask_t channelMask = channelMasks[maskIndex];
   5701             if (channelMask & ~AUDIO_CHANNEL_OUT_STEREO) {
   5702                 ALOGI("%s: force NEVER, so remove channelMask 0x%08x", __FUNCTION__, channelMask);
   5703                 channelMasks.removeAt(maskIndex);
   5704             } else {
   5705                 maskIndex++;
   5706             }
   5707         }
   5708     // If ALWAYS, then make sure we at least support 5.1
   5709     } else if (forceUse == AUDIO_POLICY_FORCE_ENCODED_SURROUND_ALWAYS) {
   5710         bool supports5dot1 = false;
   5711         // Are there any channel masks that can be considered "surround"?
   5712         for (size_t maskIndex = 0; maskIndex < channelMasks.size(); maskIndex++) {
   5713             audio_channel_mask_t channelMask = channelMasks[maskIndex];
   5714             if ((channelMask & AUDIO_CHANNEL_OUT_5POINT1) == AUDIO_CHANNEL_OUT_5POINT1) {
   5715                 supports5dot1 = true;
   5716                 break;
   5717             }
   5718         }
   5719         // If not then add 5.1 support.
   5720         if (!supports5dot1) {
   5721             channelMasks.add(AUDIO_CHANNEL_OUT_5POINT1);
   5722             ALOGI("%s: force ALWAYS, so adding channelMask for 5.1 surround", __FUNCTION__);
   5723         }
   5724     }
   5725 }
   5726 
   5727 void AudioPolicyManager::updateAudioProfiles(audio_devices_t device,
   5728                                              audio_io_handle_t ioHandle,
   5729                                              AudioProfileVector &profiles)
   5730 {
   5731     String8 reply;
   5732 
   5733     // Format MUST be checked first to update the list of AudioProfile
   5734     if (profiles.hasDynamicFormat()) {
   5735         reply = mpClientInterface->getParameters(
   5736                 ioHandle, String8(AudioParameter::keyStreamSupportedFormats));
   5737         ALOGV("%s: supported formats %s", __FUNCTION__, reply.string());
   5738         AudioParameter repliedParameters(reply);
   5739         if (repliedParameters.get(
   5740                 String8(AudioParameter::keyStreamSupportedFormats), reply) != NO_ERROR) {
   5741             ALOGE("%s: failed to retrieve format, bailing out", __FUNCTION__);
   5742             return;
   5743         }
   5744         FormatVector formats = formatsFromString(reply.string());
   5745         if (device == AUDIO_DEVICE_OUT_HDMI) {
   5746             filterSurroundFormats(&formats);
   5747         }
   5748         profiles.setFormats(formats);
   5749     }
   5750     const FormatVector &supportedFormats = profiles.getSupportedFormats();
   5751 
   5752     for (size_t formatIndex = 0; formatIndex < supportedFormats.size(); formatIndex++) {
   5753         audio_format_t format = supportedFormats[formatIndex];
   5754         ChannelsVector channelMasks;
   5755         SampleRateVector samplingRates;
   5756         AudioParameter requestedParameters;
   5757         requestedParameters.addInt(String8(AudioParameter::keyFormat), format);
   5758 
   5759         if (profiles.hasDynamicRateFor(format)) {
   5760             reply = mpClientInterface->getParameters(
   5761                     ioHandle,
   5762                     requestedParameters.toString() + ";" +
   5763                     AudioParameter::keyStreamSupportedSamplingRates);
   5764             ALOGV("%s: supported sampling rates %s", __FUNCTION__, reply.string());
   5765             AudioParameter repliedParameters(reply);
   5766             if (repliedParameters.get(
   5767                     String8(AudioParameter::keyStreamSupportedSamplingRates), reply) == NO_ERROR) {
   5768                 samplingRates = samplingRatesFromString(reply.string());
   5769             }
   5770         }
   5771         if (profiles.hasDynamicChannelsFor(format)) {
   5772             reply = mpClientInterface->getParameters(ioHandle,
   5773                                                      requestedParameters.toString() + ";" +
   5774                                                      AudioParameter::keyStreamSupportedChannels);
   5775             ALOGV("%s: supported channel masks %s", __FUNCTION__, reply.string());
   5776             AudioParameter repliedParameters(reply);
   5777             if (repliedParameters.get(
   5778                     String8(AudioParameter::keyStreamSupportedChannels), reply) == NO_ERROR) {
   5779                 channelMasks = channelMasksFromString(reply.string());
   5780                 if (device == AUDIO_DEVICE_OUT_HDMI) {
   5781                     filterSurroundChannelMasks(&channelMasks);
   5782                 }
   5783             }
   5784         }
   5785         profiles.addProfileFromHal(new AudioProfile(format, channelMasks, samplingRates));
   5786     }
   5787 }
   5788 
   5789 }; // namespace android
   5790