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 "AudioPolicyIntefaceImpl"
18//#define LOG_NDEBUG 0
19
20#include <utils/Log.h>
21#include "AudioPolicyService.h"
22#include "ServiceUtilities.h"
23
24namespace android {
25
26
27// ----------------------------------------------------------------------------
28
29status_t AudioPolicyService::setDeviceConnectionState(audio_devices_t device,
30                                                  audio_policy_dev_state_t state,
31                                                  const char *device_address,
32                                                  const char *device_name)
33{
34    if (mAudioPolicyManager == NULL) {
35        return NO_INIT;
36    }
37    if (!settingsAllowed()) {
38        return PERMISSION_DENIED;
39    }
40    if (state != AUDIO_POLICY_DEVICE_STATE_AVAILABLE &&
41            state != AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE) {
42        return BAD_VALUE;
43    }
44
45    ALOGV("setDeviceConnectionState()");
46    Mutex::Autolock _l(mLock);
47    return mAudioPolicyManager->setDeviceConnectionState(device, state,
48                                                         device_address, device_name);
49}
50
51audio_policy_dev_state_t AudioPolicyService::getDeviceConnectionState(
52                                                              audio_devices_t device,
53                                                              const char *device_address)
54{
55    if (mAudioPolicyManager == NULL) {
56        return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE;
57    }
58    return mAudioPolicyManager->getDeviceConnectionState(device,
59                                                      device_address);
60}
61
62status_t AudioPolicyService::handleDeviceConfigChange(audio_devices_t device,
63                                                  const char *device_address,
64                                                  const char *device_name)
65{
66    if (mAudioPolicyManager == NULL) {
67        return NO_INIT;
68    }
69    if (!settingsAllowed()) {
70        return PERMISSION_DENIED;
71    }
72
73    ALOGV("handleDeviceConfigChange()");
74    Mutex::Autolock _l(mLock);
75    return mAudioPolicyManager->handleDeviceConfigChange(device, device_address,
76                                                         device_name);
77}
78
79status_t AudioPolicyService::setPhoneState(audio_mode_t state)
80{
81    if (mAudioPolicyManager == NULL) {
82        return NO_INIT;
83    }
84    if (!settingsAllowed()) {
85        return PERMISSION_DENIED;
86    }
87    if (uint32_t(state) >= AUDIO_MODE_CNT) {
88        return BAD_VALUE;
89    }
90
91    ALOGV("setPhoneState()");
92
93    // acquire lock before calling setMode() so that setMode() + setPhoneState() are an atomic
94    // operation from policy manager standpoint (no other operation (e.g track start or stop)
95    // can be interleaved).
96    Mutex::Autolock _l(mLock);
97
98    // TODO: check if it is more appropriate to do it in platform specific policy manager
99    AudioSystem::setMode(state);
100
101    mAudioPolicyManager->setPhoneState(state);
102    mPhoneState = state;
103    return NO_ERROR;
104}
105
106audio_mode_t AudioPolicyService::getPhoneState()
107{
108    Mutex::Autolock _l(mLock);
109    return mPhoneState;
110}
111
112status_t AudioPolicyService::setForceUse(audio_policy_force_use_t usage,
113                                         audio_policy_forced_cfg_t config)
114{
115    if (mAudioPolicyManager == NULL) {
116        return NO_INIT;
117    }
118    if (!settingsAllowed()) {
119        return PERMISSION_DENIED;
120    }
121    if (usage < 0 || usage >= AUDIO_POLICY_FORCE_USE_CNT) {
122        return BAD_VALUE;
123    }
124    if (config < 0 || config >= AUDIO_POLICY_FORCE_CFG_CNT) {
125        return BAD_VALUE;
126    }
127    ALOGV("setForceUse()");
128    Mutex::Autolock _l(mLock);
129    mAudioPolicyManager->setForceUse(usage, config);
130    return NO_ERROR;
131}
132
133audio_policy_forced_cfg_t AudioPolicyService::getForceUse(audio_policy_force_use_t usage)
134{
135    if (mAudioPolicyManager == NULL) {
136        return AUDIO_POLICY_FORCE_NONE;
137    }
138    if (usage < 0 || usage >= AUDIO_POLICY_FORCE_USE_CNT) {
139        return AUDIO_POLICY_FORCE_NONE;
140    }
141    return mAudioPolicyManager->getForceUse(usage);
142}
143
144audio_io_handle_t AudioPolicyService::getOutput(audio_stream_type_t stream,
145                                    uint32_t samplingRate,
146                                    audio_format_t format,
147                                    audio_channel_mask_t channelMask,
148                                    audio_output_flags_t flags,
149                                    const audio_offload_info_t *offloadInfo)
150{
151    if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
152        return AUDIO_IO_HANDLE_NONE;
153    }
154    if (mAudioPolicyManager == NULL) {
155        return AUDIO_IO_HANDLE_NONE;
156    }
157    ALOGV("getOutput()");
158    Mutex::Autolock _l(mLock);
159    return mAudioPolicyManager->getOutput(stream, samplingRate,
160                                    format, channelMask, flags, offloadInfo);
161}
162
163status_t AudioPolicyService::getOutputForAttr(const audio_attributes_t *attr,
164                                              audio_io_handle_t *output,
165                                              audio_session_t session,
166                                              audio_stream_type_t *stream,
167                                              uid_t uid,
168                                              const audio_config_t *config,
169                                              audio_output_flags_t flags,
170                                              audio_port_handle_t selectedDeviceId,
171                                              audio_port_handle_t *portId)
172{
173    if (mAudioPolicyManager == NULL) {
174        return NO_INIT;
175    }
176    ALOGV("getOutput()");
177    Mutex::Autolock _l(mLock);
178
179    const uid_t callingUid = IPCThreadState::self()->getCallingUid();
180    if (!isTrustedCallingUid(callingUid) || uid == (uid_t)-1) {
181        ALOGW_IF(uid != (uid_t)-1 && uid != callingUid,
182                "%s uid %d tried to pass itself off as %d", __FUNCTION__, callingUid, uid);
183        uid = callingUid;
184    }
185    return mAudioPolicyManager->getOutputForAttr(attr, output, session, stream, uid,
186                                                 config,
187                                                 flags, selectedDeviceId, portId);
188}
189
190status_t AudioPolicyService::startOutput(audio_io_handle_t output,
191                                         audio_stream_type_t stream,
192                                         audio_session_t session)
193{
194    if (uint32_t(stream) >= AUDIO_STREAM_CNT) {
195        return BAD_VALUE;
196    }
197    if (mAudioPolicyManager == NULL) {
198        return NO_INIT;
199    }
200    ALOGV("startOutput()");
201    sp<AudioPolicyEffects>audioPolicyEffects;
202    {
203        Mutex::Autolock _l(mLock);
204        audioPolicyEffects = mAudioPolicyEffects;
205    }
206    if (audioPolicyEffects != 0) {
207        // create audio processors according to stream
208        status_t status = audioPolicyEffects->addOutputSessionEffects(output, stream, session);
209        if (status != NO_ERROR && status != ALREADY_EXISTS) {
210            ALOGW("Failed to add effects on session %d", session);
211        }
212    }
213    Mutex::Autolock _l(mLock);
214    return mAudioPolicyManager->startOutput(output, stream, session);
215}
216
217status_t AudioPolicyService::stopOutput(audio_io_handle_t output,
218                                        audio_stream_type_t stream,
219                                        audio_session_t session)
220{
221    if (uint32_t(stream) >= AUDIO_STREAM_CNT) {
222        return BAD_VALUE;
223    }
224    if (mAudioPolicyManager == NULL) {
225        return NO_INIT;
226    }
227    ALOGV("stopOutput()");
228    mOutputCommandThread->stopOutputCommand(output, stream, session);
229    return NO_ERROR;
230}
231
232status_t  AudioPolicyService::doStopOutput(audio_io_handle_t output,
233                                      audio_stream_type_t stream,
234                                      audio_session_t session)
235{
236    ALOGV("doStopOutput from tid %d", gettid());
237    sp<AudioPolicyEffects>audioPolicyEffects;
238    {
239        Mutex::Autolock _l(mLock);
240        audioPolicyEffects = mAudioPolicyEffects;
241    }
242    if (audioPolicyEffects != 0) {
243        // release audio processors from the stream
244        status_t status = audioPolicyEffects->releaseOutputSessionEffects(output, stream, session);
245        if (status != NO_ERROR && status != ALREADY_EXISTS) {
246            ALOGW("Failed to release effects on session %d", session);
247        }
248    }
249    Mutex::Autolock _l(mLock);
250    return mAudioPolicyManager->stopOutput(output, stream, session);
251}
252
253void AudioPolicyService::releaseOutput(audio_io_handle_t output,
254                                       audio_stream_type_t stream,
255                                       audio_session_t session)
256{
257    if (mAudioPolicyManager == NULL) {
258        return;
259    }
260    ALOGV("releaseOutput()");
261    mOutputCommandThread->releaseOutputCommand(output, stream, session);
262}
263
264void AudioPolicyService::doReleaseOutput(audio_io_handle_t output,
265                                         audio_stream_type_t stream,
266                                         audio_session_t session)
267{
268    ALOGV("doReleaseOutput from tid %d", gettid());
269    Mutex::Autolock _l(mLock);
270    mAudioPolicyManager->releaseOutput(output, stream, session);
271}
272
273status_t AudioPolicyService::getInputForAttr(const audio_attributes_t *attr,
274                                             audio_io_handle_t *input,
275                                             audio_session_t session,
276                                             pid_t pid,
277                                             uid_t uid,
278                                             const audio_config_base_t *config,
279                                             audio_input_flags_t flags,
280                                             audio_port_handle_t selectedDeviceId,
281                                             audio_port_handle_t *portId)
282{
283    if (mAudioPolicyManager == NULL) {
284        return NO_INIT;
285    }
286    // already checked by client, but double-check in case the client wrapper is bypassed
287    if (attr->source >= AUDIO_SOURCE_CNT && attr->source != AUDIO_SOURCE_HOTWORD &&
288        attr->source != AUDIO_SOURCE_FM_TUNER) {
289        return BAD_VALUE;
290    }
291
292    if ((attr->source == AUDIO_SOURCE_HOTWORD) && !captureHotwordAllowed()) {
293        return BAD_VALUE;
294    }
295    sp<AudioPolicyEffects>audioPolicyEffects;
296    status_t status;
297    AudioPolicyInterface::input_type_t inputType;
298
299    bool updatePid = (pid == -1);
300    const uid_t callingUid = IPCThreadState::self()->getCallingUid();
301    if (!isTrustedCallingUid(callingUid)) {
302        ALOGW_IF(uid != (uid_t)-1 && uid != callingUid,
303                "%s uid %d tried to pass itself off as %d", __FUNCTION__, callingUid, uid);
304        uid = callingUid;
305        updatePid = true;
306    }
307
308    if (updatePid) {
309        const pid_t callingPid = IPCThreadState::self()->getCallingPid();
310        ALOGW_IF(pid != (pid_t)-1 && pid != callingPid,
311                 "%s uid %d pid %d tried to pass itself off as pid %d",
312                 __func__, callingUid, callingPid, pid);
313        pid = callingPid;
314    }
315
316    {
317        Mutex::Autolock _l(mLock);
318        // the audio_in_acoustics_t parameter is ignored by get_input()
319        status = mAudioPolicyManager->getInputForAttr(attr, input, session, uid,
320                                                     config,
321                                                     flags, selectedDeviceId,
322                                                     &inputType, portId);
323        audioPolicyEffects = mAudioPolicyEffects;
324
325        if (status == NO_ERROR) {
326            // enforce permission (if any) required for each type of input
327            switch (inputType) {
328            case AudioPolicyInterface::API_INPUT_LEGACY:
329                break;
330            case AudioPolicyInterface::API_INPUT_TELEPHONY_RX:
331                // FIXME: use the same permission as for remote submix for now.
332            case AudioPolicyInterface::API_INPUT_MIX_CAPTURE:
333                if (!captureAudioOutputAllowed(pid, uid)) {
334                    ALOGE("getInputForAttr() permission denied: capture not allowed");
335                    status = PERMISSION_DENIED;
336                }
337                break;
338            case AudioPolicyInterface::API_INPUT_MIX_EXT_POLICY_REROUTE:
339                if (!modifyAudioRoutingAllowed()) {
340                    ALOGE("getInputForAttr() permission denied: modify audio routing not allowed");
341                    status = PERMISSION_DENIED;
342                }
343                break;
344            case AudioPolicyInterface::API_INPUT_INVALID:
345            default:
346                LOG_ALWAYS_FATAL("getInputForAttr() encountered an invalid input type %d",
347                        (int)inputType);
348            }
349        }
350
351        if (status != NO_ERROR) {
352            if (status == PERMISSION_DENIED) {
353                mAudioPolicyManager->releaseInput(*input, session);
354            }
355            return status;
356        }
357    }
358
359    if (audioPolicyEffects != 0) {
360        // create audio pre processors according to input source
361        status_t status = audioPolicyEffects->addInputEffects(*input, attr->source, session);
362        if (status != NO_ERROR && status != ALREADY_EXISTS) {
363            ALOGW("Failed to add effects on input %d", *input);
364        }
365    }
366    return NO_ERROR;
367}
368
369status_t AudioPolicyService::startInput(audio_io_handle_t input,
370                                        audio_session_t session)
371{
372    if (mAudioPolicyManager == NULL) {
373        return NO_INIT;
374    }
375    Mutex::Autolock _l(mLock);
376    AudioPolicyInterface::concurrency_type__mask_t concurrency;
377    status_t status = mAudioPolicyManager->startInput(input, session, &concurrency);
378
379    if (status == NO_ERROR) {
380        LOG_ALWAYS_FATAL_IF(concurrency & ~AudioPolicyInterface::API_INPUT_CONCURRENCY_ALL,
381                            "startInput(): invalid concurrency type %d", (int)concurrency);
382
383        // enforce permission (if any) required for each type of concurrency
384        if (concurrency & AudioPolicyInterface::API_INPUT_CONCURRENCY_CALL) {
385            //TODO: check incall capture permission
386        }
387        if (concurrency & AudioPolicyInterface::API_INPUT_CONCURRENCY_CAPTURE) {
388            //TODO: check concurrent capture permission
389        }
390    }
391
392    return status;
393}
394
395status_t AudioPolicyService::stopInput(audio_io_handle_t input,
396                                       audio_session_t session)
397{
398    if (mAudioPolicyManager == NULL) {
399        return NO_INIT;
400    }
401    Mutex::Autolock _l(mLock);
402
403    return mAudioPolicyManager->stopInput(input, session);
404}
405
406void AudioPolicyService::releaseInput(audio_io_handle_t input,
407                                      audio_session_t session)
408{
409    if (mAudioPolicyManager == NULL) {
410        return;
411    }
412    sp<AudioPolicyEffects>audioPolicyEffects;
413    {
414        Mutex::Autolock _l(mLock);
415        audioPolicyEffects = mAudioPolicyEffects;
416    }
417    if (audioPolicyEffects != 0) {
418        // release audio processors from the input
419        status_t status = audioPolicyEffects->releaseInputEffects(input, session);
420        if(status != NO_ERROR) {
421            ALOGW("Failed to release effects on input %d", input);
422        }
423    }
424    {
425        Mutex::Autolock _l(mLock);
426        mAudioPolicyManager->releaseInput(input, session);
427    }
428}
429
430status_t AudioPolicyService::initStreamVolume(audio_stream_type_t stream,
431                                            int indexMin,
432                                            int indexMax)
433{
434    if (mAudioPolicyManager == NULL) {
435        return NO_INIT;
436    }
437    if (!settingsAllowed()) {
438        return PERMISSION_DENIED;
439    }
440    if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
441        return BAD_VALUE;
442    }
443    Mutex::Autolock _l(mLock);
444    mAudioPolicyManager->initStreamVolume(stream, indexMin, indexMax);
445    return NO_ERROR;
446}
447
448status_t AudioPolicyService::setStreamVolumeIndex(audio_stream_type_t stream,
449                                                  int index,
450                                                  audio_devices_t device)
451{
452    if (mAudioPolicyManager == NULL) {
453        return NO_INIT;
454    }
455    if (!settingsAllowed()) {
456        return PERMISSION_DENIED;
457    }
458    if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
459        return BAD_VALUE;
460    }
461    Mutex::Autolock _l(mLock);
462    return mAudioPolicyManager->setStreamVolumeIndex(stream,
463                                                    index,
464                                                    device);
465}
466
467status_t AudioPolicyService::getStreamVolumeIndex(audio_stream_type_t stream,
468                                                  int *index,
469                                                  audio_devices_t device)
470{
471    if (mAudioPolicyManager == NULL) {
472        return NO_INIT;
473    }
474    if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
475        return BAD_VALUE;
476    }
477    Mutex::Autolock _l(mLock);
478    return mAudioPolicyManager->getStreamVolumeIndex(stream,
479                                                    index,
480                                                    device);
481}
482
483uint32_t AudioPolicyService::getStrategyForStream(audio_stream_type_t stream)
484{
485    if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
486        return 0;
487    }
488    if (mAudioPolicyManager == NULL) {
489        return 0;
490    }
491    return mAudioPolicyManager->getStrategyForStream(stream);
492}
493
494//audio policy: use audio_device_t appropriately
495
496audio_devices_t AudioPolicyService::getDevicesForStream(audio_stream_type_t stream)
497{
498    if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
499        return AUDIO_DEVICE_NONE;
500    }
501    if (mAudioPolicyManager == NULL) {
502        return AUDIO_DEVICE_NONE;
503    }
504    Mutex::Autolock _l(mLock);
505    return mAudioPolicyManager->getDevicesForStream(stream);
506}
507
508audio_io_handle_t AudioPolicyService::getOutputForEffect(const effect_descriptor_t *desc)
509{
510    // FIXME change return type to status_t, and return NO_INIT here
511    if (mAudioPolicyManager == NULL) {
512        return 0;
513    }
514    Mutex::Autolock _l(mLock);
515    return mAudioPolicyManager->getOutputForEffect(desc);
516}
517
518status_t AudioPolicyService::registerEffect(const effect_descriptor_t *desc,
519                                audio_io_handle_t io,
520                                uint32_t strategy,
521                                audio_session_t session,
522                                int id)
523{
524    if (mAudioPolicyManager == NULL) {
525        return NO_INIT;
526    }
527    Mutex::Autolock _l(mEffectsLock);
528    return mAudioPolicyManager->registerEffect(desc, io, strategy, session, id);
529}
530
531status_t AudioPolicyService::unregisterEffect(int id)
532{
533    if (mAudioPolicyManager == NULL) {
534        return NO_INIT;
535    }
536    Mutex::Autolock _l(mEffectsLock);
537    return mAudioPolicyManager->unregisterEffect(id);
538}
539
540status_t AudioPolicyService::setEffectEnabled(int id, bool enabled)
541{
542    if (mAudioPolicyManager == NULL) {
543        return NO_INIT;
544    }
545    Mutex::Autolock _l(mEffectsLock);
546    return mAudioPolicyManager->setEffectEnabled(id, enabled);
547}
548
549bool AudioPolicyService::isStreamActive(audio_stream_type_t stream, uint32_t inPastMs) const
550{
551    if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
552        return false;
553    }
554    if (mAudioPolicyManager == NULL) {
555        return false;
556    }
557    Mutex::Autolock _l(mLock);
558    return mAudioPolicyManager->isStreamActive(stream, inPastMs);
559}
560
561bool AudioPolicyService::isStreamActiveRemotely(audio_stream_type_t stream, uint32_t inPastMs) const
562{
563    if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
564        return false;
565    }
566    if (mAudioPolicyManager == NULL) {
567        return false;
568    }
569    Mutex::Autolock _l(mLock);
570    return mAudioPolicyManager->isStreamActiveRemotely(stream, inPastMs);
571}
572
573bool AudioPolicyService::isSourceActive(audio_source_t source) const
574{
575    if (mAudioPolicyManager == NULL) {
576        return false;
577    }
578    Mutex::Autolock _l(mLock);
579    return mAudioPolicyManager->isSourceActive(source);
580}
581
582status_t AudioPolicyService::queryDefaultPreProcessing(audio_session_t audioSession,
583                                                       effect_descriptor_t *descriptors,
584                                                       uint32_t *count)
585{
586    if (mAudioPolicyManager == NULL) {
587        *count = 0;
588        return NO_INIT;
589    }
590    sp<AudioPolicyEffects>audioPolicyEffects;
591    {
592        Mutex::Autolock _l(mLock);
593        audioPolicyEffects = mAudioPolicyEffects;
594    }
595    if (audioPolicyEffects == 0) {
596        *count = 0;
597        return NO_INIT;
598    }
599    return audioPolicyEffects->queryDefaultInputEffects(
600            (audio_session_t)audioSession, descriptors, count);
601}
602
603bool AudioPolicyService::isOffloadSupported(const audio_offload_info_t& info)
604{
605    if (mAudioPolicyManager == NULL) {
606        ALOGV("mAudioPolicyManager == NULL");
607        return false;
608    }
609    Mutex::Autolock _l(mLock);
610    Mutex::Autolock _le(mEffectsLock); // isOffloadSupported queries for
611                                      // non-offloadable effects
612    return mAudioPolicyManager->isOffloadSupported(info);
613}
614
615status_t AudioPolicyService::listAudioPorts(audio_port_role_t role,
616                                            audio_port_type_t type,
617                                            unsigned int *num_ports,
618                                            struct audio_port *ports,
619                                            unsigned int *generation)
620{
621    Mutex::Autolock _l(mLock);
622    if (mAudioPolicyManager == NULL) {
623        return NO_INIT;
624    }
625
626    return mAudioPolicyManager->listAudioPorts(role, type, num_ports, ports, generation);
627}
628
629status_t AudioPolicyService::getAudioPort(struct audio_port *port)
630{
631    Mutex::Autolock _l(mLock);
632    if (mAudioPolicyManager == NULL) {
633        return NO_INIT;
634    }
635
636    return mAudioPolicyManager->getAudioPort(port);
637}
638
639status_t AudioPolicyService::createAudioPatch(const struct audio_patch *patch,
640        audio_patch_handle_t *handle)
641{
642    Mutex::Autolock _l(mLock);
643    if(!modifyAudioRoutingAllowed()) {
644        return PERMISSION_DENIED;
645    }
646    if (mAudioPolicyManager == NULL) {
647        return NO_INIT;
648    }
649    return mAudioPolicyManager->createAudioPatch(patch, handle,
650                                                  IPCThreadState::self()->getCallingUid());
651}
652
653status_t AudioPolicyService::releaseAudioPatch(audio_patch_handle_t handle)
654{
655    Mutex::Autolock _l(mLock);
656    if(!modifyAudioRoutingAllowed()) {
657        return PERMISSION_DENIED;
658    }
659    if (mAudioPolicyManager == NULL) {
660        return NO_INIT;
661    }
662
663    return mAudioPolicyManager->releaseAudioPatch(handle,
664                                                     IPCThreadState::self()->getCallingUid());
665}
666
667status_t AudioPolicyService::listAudioPatches(unsigned int *num_patches,
668        struct audio_patch *patches,
669        unsigned int *generation)
670{
671    Mutex::Autolock _l(mLock);
672    if (mAudioPolicyManager == NULL) {
673        return NO_INIT;
674    }
675
676    return mAudioPolicyManager->listAudioPatches(num_patches, patches, generation);
677}
678
679status_t AudioPolicyService::setAudioPortConfig(const struct audio_port_config *config)
680{
681    Mutex::Autolock _l(mLock);
682    if(!modifyAudioRoutingAllowed()) {
683        return PERMISSION_DENIED;
684    }
685    if (mAudioPolicyManager == NULL) {
686        return NO_INIT;
687    }
688
689    return mAudioPolicyManager->setAudioPortConfig(config);
690}
691
692status_t AudioPolicyService::acquireSoundTriggerSession(audio_session_t *session,
693                                       audio_io_handle_t *ioHandle,
694                                       audio_devices_t *device)
695{
696    if (mAudioPolicyManager == NULL) {
697        return NO_INIT;
698    }
699
700    return mAudioPolicyManager->acquireSoundTriggerSession(session, ioHandle, device);
701}
702
703status_t AudioPolicyService::releaseSoundTriggerSession(audio_session_t session)
704{
705    if (mAudioPolicyManager == NULL) {
706        return NO_INIT;
707    }
708
709    return mAudioPolicyManager->releaseSoundTriggerSession(session);
710}
711
712status_t AudioPolicyService::registerPolicyMixes(const Vector<AudioMix>& mixes, bool registration)
713{
714    Mutex::Autolock _l(mLock);
715    if(!modifyAudioRoutingAllowed()) {
716        return PERMISSION_DENIED;
717    }
718    if (mAudioPolicyManager == NULL) {
719        return NO_INIT;
720    }
721    if (registration) {
722        return mAudioPolicyManager->registerPolicyMixes(mixes);
723    } else {
724        return mAudioPolicyManager->unregisterPolicyMixes(mixes);
725    }
726}
727
728status_t AudioPolicyService::startAudioSource(const struct audio_port_config *source,
729                                  const audio_attributes_t *attributes,
730                                  audio_patch_handle_t *handle)
731{
732    Mutex::Autolock _l(mLock);
733    if (mAudioPolicyManager == NULL) {
734        return NO_INIT;
735    }
736
737    return mAudioPolicyManager->startAudioSource(source, attributes, handle,
738                                                 IPCThreadState::self()->getCallingUid());
739}
740
741status_t AudioPolicyService::stopAudioSource(audio_patch_handle_t handle)
742{
743    Mutex::Autolock _l(mLock);
744    if (mAudioPolicyManager == NULL) {
745        return NO_INIT;
746    }
747
748    return mAudioPolicyManager->stopAudioSource(handle);
749}
750
751status_t AudioPolicyService::setMasterMono(bool mono)
752{
753    if (mAudioPolicyManager == NULL) {
754        return NO_INIT;
755    }
756    if (!settingsAllowed()) {
757        return PERMISSION_DENIED;
758    }
759    Mutex::Autolock _l(mLock);
760    return mAudioPolicyManager->setMasterMono(mono);
761}
762
763status_t AudioPolicyService::getMasterMono(bool *mono)
764{
765    if (mAudioPolicyManager == NULL) {
766        return NO_INIT;
767    }
768    Mutex::Autolock _l(mLock);
769    return mAudioPolicyManager->getMasterMono(mono);
770}
771
772}; // namespace android
773