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