AudioPolicyInterfaceImpl.cpp revision f53eaf49df1e1e1c01708919e9e0a046543de9b6 
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{
33    if (mAudioPolicyManager == NULL) {
34        return NO_INIT;
35    }
36    if (!settingsAllowed()) {
37        return PERMISSION_DENIED;
38    }
39    if (!audio_is_output_device(device) && !audio_is_input_device(device)) {
40        return BAD_VALUE;
41    }
42    if (state != AUDIO_POLICY_DEVICE_STATE_AVAILABLE &&
43            state != AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE) {
44        return BAD_VALUE;
45    }
46
47    ALOGV("setDeviceConnectionState()");
48    Mutex::Autolock _l(mLock);
49    return mAudioPolicyManager->setDeviceConnectionState(device,
50                                                      state, device_address);
51}
52
53audio_policy_dev_state_t AudioPolicyService::getDeviceConnectionState(
54                                                              audio_devices_t device,
55                                                              const char *device_address)
56{
57    if (mAudioPolicyManager == NULL) {
58        return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE;
59    }
60    return mAudioPolicyManager->getDeviceConnectionState(device,
61                                                      device_address);
62}
63
64status_t AudioPolicyService::setPhoneState(audio_mode_t state)
65{
66    if (mAudioPolicyManager == NULL) {
67        return NO_INIT;
68    }
69    if (!settingsAllowed()) {
70        return PERMISSION_DENIED;
71    }
72    if (uint32_t(state) >= AUDIO_MODE_CNT) {
73        return BAD_VALUE;
74    }
75
76    ALOGV("setPhoneState()");
77
78    // TODO: check if it is more appropriate to do it in platform specific policy manager
79    AudioSystem::setMode(state);
80
81    Mutex::Autolock _l(mLock);
82    mAudioPolicyManager->setPhoneState(state);
83    mPhoneState = state;
84    return NO_ERROR;
85}
86
87audio_mode_t AudioPolicyService::getPhoneState()
88{
89    Mutex::Autolock _l(mLock);
90    return mPhoneState;
91}
92
93status_t AudioPolicyService::setForceUse(audio_policy_force_use_t usage,
94                                         audio_policy_forced_cfg_t config)
95{
96    if (mAudioPolicyManager == NULL) {
97        return NO_INIT;
98    }
99    if (!settingsAllowed()) {
100        return PERMISSION_DENIED;
101    }
102    if (usage < 0 || usage >= AUDIO_POLICY_FORCE_USE_CNT) {
103        return BAD_VALUE;
104    }
105    if (config < 0 || config >= AUDIO_POLICY_FORCE_CFG_CNT) {
106        return BAD_VALUE;
107    }
108    ALOGV("setForceUse()");
109    Mutex::Autolock _l(mLock);
110    mAudioPolicyManager->setForceUse(usage, config);
111    return NO_ERROR;
112}
113
114audio_policy_forced_cfg_t AudioPolicyService::getForceUse(audio_policy_force_use_t usage)
115{
116    if (mAudioPolicyManager == NULL) {
117        return AUDIO_POLICY_FORCE_NONE;
118    }
119    if (usage < 0 || usage >= AUDIO_POLICY_FORCE_USE_CNT) {
120        return AUDIO_POLICY_FORCE_NONE;
121    }
122    return mAudioPolicyManager->getForceUse(usage);
123}
124
125audio_io_handle_t AudioPolicyService::getOutput(audio_stream_type_t stream,
126                                    uint32_t samplingRate,
127                                    audio_format_t format,
128                                    audio_channel_mask_t channelMask,
129                                    audio_output_flags_t flags,
130                                    const audio_offload_info_t *offloadInfo)
131{
132    if (mAudioPolicyManager == NULL) {
133        return 0;
134    }
135    ALOGV("getOutput()");
136    Mutex::Autolock _l(mLock);
137    return mAudioPolicyManager->getOutput(stream, samplingRate,
138                                    format, channelMask, flags, offloadInfo);
139}
140
141audio_io_handle_t AudioPolicyService::getOutputForAttr(const audio_attributes_t *attr,
142                                    uint32_t samplingRate,
143                                    audio_format_t format,
144                                    audio_channel_mask_t channelMask,
145                                    audio_output_flags_t flags,
146                                    const audio_offload_info_t *offloadInfo)
147{
148    if (mAudioPolicyManager == NULL) {
149        return 0;
150    }
151    ALOGV("getOutput()");
152    Mutex::Autolock _l(mLock);
153    return mAudioPolicyManager->getOutputForAttr(attr, samplingRate,
154                                    format, channelMask, flags, offloadInfo);
155}
156
157status_t AudioPolicyService::startOutput(audio_io_handle_t output,
158                                         audio_stream_type_t stream,
159                                         int session)
160{
161    if (mAudioPolicyManager == NULL) {
162        return NO_INIT;
163    }
164    ALOGV("startOutput()");
165    sp<AudioPolicyEffects>audioPolicyEffects;
166    {
167        Mutex::Autolock _l(mLock);
168        audioPolicyEffects = mAudioPolicyEffects;
169    }
170    if (audioPolicyEffects != 0) {
171        // create audio processors according to stream
172        status_t status = audioPolicyEffects->addOutputSessionEffects(output, stream, session);
173        if (status != NO_ERROR && status != ALREADY_EXISTS) {
174            ALOGW("Failed to add effects on session %d", session);
175        }
176    }
177    Mutex::Autolock _l(mLock);
178    return mAudioPolicyManager->startOutput(output, stream, session);
179}
180
181status_t AudioPolicyService::stopOutput(audio_io_handle_t output,
182                                        audio_stream_type_t stream,
183                                        int session)
184{
185    if (mAudioPolicyManager == NULL) {
186        return NO_INIT;
187    }
188    ALOGV("stopOutput()");
189    mOutputCommandThread->stopOutputCommand(output, stream, session);
190    return NO_ERROR;
191}
192
193status_t  AudioPolicyService::doStopOutput(audio_io_handle_t output,
194                                      audio_stream_type_t stream,
195                                      int session)
196{
197    ALOGV("doStopOutput from tid %d", gettid());
198    sp<AudioPolicyEffects>audioPolicyEffects;
199    {
200        Mutex::Autolock _l(mLock);
201        audioPolicyEffects = mAudioPolicyEffects;
202    }
203    if (audioPolicyEffects != 0) {
204        // release audio processors from the stream
205        status_t status = audioPolicyEffects->releaseOutputSessionEffects(output, stream, session);
206        if (status != NO_ERROR && status != ALREADY_EXISTS) {
207            ALOGW("Failed to release effects on session %d", session);
208        }
209    }
210    Mutex::Autolock _l(mLock);
211    return mAudioPolicyManager->stopOutput(output, stream, session);
212}
213
214void AudioPolicyService::releaseOutput(audio_io_handle_t output)
215{
216    if (mAudioPolicyManager == NULL) {
217        return;
218    }
219    ALOGV("releaseOutput()");
220    mOutputCommandThread->releaseOutputCommand(output);
221}
222
223void AudioPolicyService::doReleaseOutput(audio_io_handle_t output)
224{
225    ALOGV("doReleaseOutput from tid %d", gettid());
226    Mutex::Autolock _l(mLock);
227    mAudioPolicyManager->releaseOutput(output);
228}
229
230audio_io_handle_t AudioPolicyService::getInput(audio_source_t inputSource,
231                                    uint32_t samplingRate,
232                                    audio_format_t format,
233                                    audio_channel_mask_t channelMask,
234                                    int audioSession,
235                                    audio_input_flags_t flags)
236{
237    if (mAudioPolicyManager == NULL) {
238        return 0;
239    }
240    // already checked by client, but double-check in case the client wrapper is bypassed
241    if (inputSource >= AUDIO_SOURCE_CNT && inputSource != AUDIO_SOURCE_HOTWORD &&
242        inputSource != AUDIO_SOURCE_FM_TUNER) {
243        return 0;
244    }
245
246    if (((inputSource == AUDIO_SOURCE_HOTWORD) && !captureHotwordAllowed()) ||
247        ((inputSource == AUDIO_SOURCE_FM_TUNER) && !captureFmTunerAllowed())) {
248        return 0;
249    }
250    audio_io_handle_t input;
251    sp<AudioPolicyEffects>audioPolicyEffects;
252    {
253        Mutex::Autolock _l(mLock);
254        // the audio_in_acoustics_t parameter is ignored by get_input()
255        input = mAudioPolicyManager->getInput(inputSource, samplingRate,
256                                                       format, channelMask,
257                                                       (audio_session_t)audioSession, flags);
258        audioPolicyEffects = mAudioPolicyEffects;
259    }
260    if (input == 0) {
261        return input;
262    }
263    if (audioPolicyEffects != 0) {
264        // create audio pre processors according to input source
265        status_t status = audioPolicyEffects->addInputEffects(input, inputSource, audioSession);
266        if (status != NO_ERROR && status != ALREADY_EXISTS) {
267            ALOGW("Failed to add effects on input %d", input);
268        }
269    }
270    return input;
271}
272
273status_t AudioPolicyService::startInput(audio_io_handle_t input,
274                                        audio_session_t session)
275{
276    if (mAudioPolicyManager == NULL) {
277        return NO_INIT;
278    }
279    Mutex::Autolock _l(mLock);
280
281    return mAudioPolicyManager->startInput(input, session);
282}
283
284status_t AudioPolicyService::stopInput(audio_io_handle_t input,
285                                       audio_session_t session)
286{
287    if (mAudioPolicyManager == NULL) {
288        return NO_INIT;
289    }
290    Mutex::Autolock _l(mLock);
291
292    return mAudioPolicyManager->stopInput(input, session);
293}
294
295void AudioPolicyService::releaseInput(audio_io_handle_t input,
296                                      audio_session_t session)
297{
298    if (mAudioPolicyManager == NULL) {
299        return;
300    }
301    sp<AudioPolicyEffects>audioPolicyEffects;
302    {
303        Mutex::Autolock _l(mLock);
304        mAudioPolicyManager->releaseInput(input, session);
305        audioPolicyEffects = mAudioPolicyEffects;
306    }
307    if (audioPolicyEffects != 0) {
308        // release audio processors from the input
309        status_t status = audioPolicyEffects->releaseInputEffects(input);
310        if(status != NO_ERROR) {
311            ALOGW("Failed to release effects on input %d", input);
312        }
313    }
314}
315
316status_t AudioPolicyService::initStreamVolume(audio_stream_type_t stream,
317                                            int indexMin,
318                                            int indexMax)
319{
320    if (mAudioPolicyManager == NULL) {
321        return NO_INIT;
322    }
323    if (!settingsAllowed()) {
324        return PERMISSION_DENIED;
325    }
326    if (uint32_t(stream) >= AUDIO_STREAM_CNT) {
327        return BAD_VALUE;
328    }
329    Mutex::Autolock _l(mLock);
330    mAudioPolicyManager->initStreamVolume(stream, indexMin, indexMax);
331    return NO_ERROR;
332}
333
334status_t AudioPolicyService::setStreamVolumeIndex(audio_stream_type_t stream,
335                                                  int index,
336                                                  audio_devices_t device)
337{
338    if (mAudioPolicyManager == NULL) {
339        return NO_INIT;
340    }
341    if (!settingsAllowed()) {
342        return PERMISSION_DENIED;
343    }
344    if (uint32_t(stream) >= AUDIO_STREAM_CNT) {
345        return BAD_VALUE;
346    }
347    Mutex::Autolock _l(mLock);
348    return mAudioPolicyManager->setStreamVolumeIndex(stream,
349                                                    index,
350                                                    device);
351}
352
353status_t AudioPolicyService::getStreamVolumeIndex(audio_stream_type_t stream,
354                                                  int *index,
355                                                  audio_devices_t device)
356{
357    if (mAudioPolicyManager == NULL) {
358        return NO_INIT;
359    }
360    if (uint32_t(stream) >= AUDIO_STREAM_CNT) {
361        return BAD_VALUE;
362    }
363    Mutex::Autolock _l(mLock);
364    return mAudioPolicyManager->getStreamVolumeIndex(stream,
365                                                    index,
366                                                    device);
367}
368
369uint32_t AudioPolicyService::getStrategyForStream(audio_stream_type_t stream)
370{
371    if (mAudioPolicyManager == NULL) {
372        return 0;
373    }
374    return mAudioPolicyManager->getStrategyForStream(stream);
375}
376
377//audio policy: use audio_device_t appropriately
378
379audio_devices_t AudioPolicyService::getDevicesForStream(audio_stream_type_t stream)
380{
381    if (mAudioPolicyManager == NULL) {
382        return (audio_devices_t)0;
383    }
384    return mAudioPolicyManager->getDevicesForStream(stream);
385}
386
387audio_io_handle_t AudioPolicyService::getOutputForEffect(const effect_descriptor_t *desc)
388{
389    // FIXME change return type to status_t, and return NO_INIT here
390    if (mAudioPolicyManager == NULL) {
391        return 0;
392    }
393    Mutex::Autolock _l(mLock);
394    return mAudioPolicyManager->getOutputForEffect(desc);
395}
396
397status_t AudioPolicyService::registerEffect(const effect_descriptor_t *desc,
398                                audio_io_handle_t io,
399                                uint32_t strategy,
400                                int session,
401                                int id)
402{
403    if (mAudioPolicyManager == NULL) {
404        return NO_INIT;
405    }
406    return mAudioPolicyManager->registerEffect(desc, io, strategy, session, id);
407}
408
409status_t AudioPolicyService::unregisterEffect(int id)
410{
411    if (mAudioPolicyManager == NULL) {
412        return NO_INIT;
413    }
414    return mAudioPolicyManager->unregisterEffect(id);
415}
416
417status_t AudioPolicyService::setEffectEnabled(int id, bool enabled)
418{
419    if (mAudioPolicyManager == NULL) {
420        return NO_INIT;
421    }
422    return mAudioPolicyManager->setEffectEnabled(id, enabled);
423}
424
425bool AudioPolicyService::isStreamActive(audio_stream_type_t stream, uint32_t inPastMs) const
426{
427    if (mAudioPolicyManager == NULL) {
428        return 0;
429    }
430    Mutex::Autolock _l(mLock);
431    return mAudioPolicyManager->isStreamActive(stream, inPastMs);
432}
433
434bool AudioPolicyService::isStreamActiveRemotely(audio_stream_type_t stream, uint32_t inPastMs) const
435{
436    if (mAudioPolicyManager == NULL) {
437        return 0;
438    }
439    Mutex::Autolock _l(mLock);
440    return mAudioPolicyManager->isStreamActiveRemotely(stream, inPastMs);
441}
442
443bool AudioPolicyService::isSourceActive(audio_source_t source) const
444{
445    if (mAudioPolicyManager == NULL) {
446        return false;
447    }
448    Mutex::Autolock _l(mLock);
449    return mAudioPolicyManager->isSourceActive(source);
450}
451
452status_t AudioPolicyService::queryDefaultPreProcessing(int audioSession,
453                                                       effect_descriptor_t *descriptors,
454                                                       uint32_t *count)
455{
456    if (mAudioPolicyManager == NULL) {
457        *count = 0;
458        return NO_INIT;
459    }
460    sp<AudioPolicyEffects>audioPolicyEffects;
461    {
462        Mutex::Autolock _l(mLock);
463        audioPolicyEffects = mAudioPolicyEffects;
464    }
465    if (audioPolicyEffects == 0) {
466        *count = 0;
467        return NO_INIT;
468    }
469    return audioPolicyEffects->queryDefaultInputEffects(audioSession, descriptors, count);
470}
471
472bool AudioPolicyService::isOffloadSupported(const audio_offload_info_t& info)
473{
474    if (mAudioPolicyManager == NULL) {
475        ALOGV("mAudioPolicyManager == NULL");
476        return false;
477    }
478
479    return mAudioPolicyManager->isOffloadSupported(info);
480}
481
482status_t AudioPolicyService::listAudioPorts(audio_port_role_t role,
483                                            audio_port_type_t type,
484                                            unsigned int *num_ports,
485                                            struct audio_port *ports,
486                                            unsigned int *generation)
487{
488    Mutex::Autolock _l(mLock);
489    if(!modifyAudioRoutingAllowed()) {
490        return PERMISSION_DENIED;
491    }
492    if (mAudioPolicyManager == NULL) {
493        return NO_INIT;
494    }
495
496    return mAudioPolicyManager->listAudioPorts(role, type, num_ports, ports, generation);
497}
498
499status_t AudioPolicyService::getAudioPort(struct audio_port *port)
500{
501    Mutex::Autolock _l(mLock);
502    if(!modifyAudioRoutingAllowed()) {
503        return PERMISSION_DENIED;
504    }
505    if (mAudioPolicyManager == NULL) {
506        return NO_INIT;
507    }
508
509    return mAudioPolicyManager->getAudioPort(port);
510}
511
512status_t AudioPolicyService::createAudioPatch(const struct audio_patch *patch,
513        audio_patch_handle_t *handle)
514{
515    Mutex::Autolock _l(mLock);
516    if(!modifyAudioRoutingAllowed()) {
517        return PERMISSION_DENIED;
518    }
519    if (mAudioPolicyManager == NULL) {
520        return NO_INIT;
521    }
522    return mAudioPolicyManager->createAudioPatch(patch, handle,
523                                                  IPCThreadState::self()->getCallingUid());
524}
525
526status_t AudioPolicyService::releaseAudioPatch(audio_patch_handle_t handle)
527{
528    Mutex::Autolock _l(mLock);
529    if(!modifyAudioRoutingAllowed()) {
530        return PERMISSION_DENIED;
531    }
532    if (mAudioPolicyManager == NULL) {
533        return NO_INIT;
534    }
535
536    return mAudioPolicyManager->releaseAudioPatch(handle,
537                                                     IPCThreadState::self()->getCallingUid());
538}
539
540status_t AudioPolicyService::listAudioPatches(unsigned int *num_patches,
541        struct audio_patch *patches,
542        unsigned int *generation)
543{
544    Mutex::Autolock _l(mLock);
545    if(!modifyAudioRoutingAllowed()) {
546        return PERMISSION_DENIED;
547    }
548    if (mAudioPolicyManager == NULL) {
549        return NO_INIT;
550    }
551
552    return mAudioPolicyManager->listAudioPatches(num_patches, patches, generation);
553}
554
555status_t AudioPolicyService::setAudioPortConfig(const struct audio_port_config *config)
556{
557    Mutex::Autolock _l(mLock);
558    if(!modifyAudioRoutingAllowed()) {
559        return PERMISSION_DENIED;
560    }
561    if (mAudioPolicyManager == NULL) {
562        return NO_INIT;
563    }
564
565    return mAudioPolicyManager->setAudioPortConfig(config);
566}
567
568status_t AudioPolicyService::acquireSoundTriggerSession(audio_session_t *session,
569                                       audio_io_handle_t *ioHandle,
570                                       audio_devices_t *device)
571{
572    if (mAudioPolicyManager == NULL) {
573        return NO_INIT;
574    }
575
576    return mAudioPolicyManager->acquireSoundTriggerSession(session, ioHandle, device);
577}
578
579status_t AudioPolicyService::releaseSoundTriggerSession(audio_session_t session)
580{
581    if (mAudioPolicyManager == NULL) {
582        return NO_INIT;
583    }
584
585    return mAudioPolicyManager->releaseSoundTriggerSession(session);
586}
587
588}; // namespace android
589