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