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