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