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