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