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