AudioPolicyInterfaceImpl.cpp revision 2d388eccc9dc085337c7a03a68467cbee6b809e1 
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 "AudioPolicyService"
18//#define LOG_NDEBUG 0
19
20#include <utils/Log.h>
21#include "AudioPolicyService.h"
22#include "ServiceUtilities.h"
23
24#include <system/audio.h>
25#include <system/audio_policy.h>
26#include <hardware/audio_policy.h>
27
28namespace android {
29
30
31// ----------------------------------------------------------------------------
32
33status_t AudioPolicyService::setDeviceConnectionState(audio_devices_t device,
34                                                  audio_policy_dev_state_t state,
35                                                  const char *device_address)
36{
37    if (mpAudioPolicy == NULL) {
38        return NO_INIT;
39    }
40    if (!settingsAllowed()) {
41        return PERMISSION_DENIED;
42    }
43    if (!audio_is_output_device(device) && !audio_is_input_device(device)) {
44        return BAD_VALUE;
45    }
46    if (state != AUDIO_POLICY_DEVICE_STATE_AVAILABLE &&
47            state != AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE) {
48        return BAD_VALUE;
49    }
50
51    ALOGV("setDeviceConnectionState()");
52    Mutex::Autolock _l(mLock);
53    return mpAudioPolicy->set_device_connection_state(mpAudioPolicy, device,
54                                                      state, device_address);
55}
56
57audio_policy_dev_state_t AudioPolicyService::getDeviceConnectionState(
58                                                              audio_devices_t device,
59                                                              const char *device_address)
60{
61    if (mpAudioPolicy == NULL) {
62        return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE;
63    }
64    return mpAudioPolicy->get_device_connection_state(mpAudioPolicy, device,
65                                                      device_address);
66}
67
68status_t AudioPolicyService::setPhoneState(audio_mode_t state)
69{
70    if (mpAudioPolicy == NULL) {
71        return NO_INIT;
72    }
73    if (!settingsAllowed()) {
74        return PERMISSION_DENIED;
75    }
76    if (uint32_t(state) >= AUDIO_MODE_CNT) {
77        return BAD_VALUE;
78    }
79
80    ALOGV("setPhoneState()");
81
82    // TODO: check if it is more appropriate to do it in platform specific policy manager
83    AudioSystem::setMode(state);
84
85    Mutex::Autolock _l(mLock);
86    mpAudioPolicy->set_phone_state(mpAudioPolicy, state);
87    return NO_ERROR;
88}
89
90status_t AudioPolicyService::setForceUse(audio_policy_force_use_t usage,
91                                         audio_policy_forced_cfg_t config)
92{
93    if (mpAudioPolicy == NULL) {
94        return NO_INIT;
95    }
96    if (!settingsAllowed()) {
97        return PERMISSION_DENIED;
98    }
99    if (usage < 0 || usage >= AUDIO_POLICY_FORCE_USE_CNT) {
100        return BAD_VALUE;
101    }
102    if (config < 0 || config >= AUDIO_POLICY_FORCE_CFG_CNT) {
103        return BAD_VALUE;
104    }
105    ALOGV("setForceUse()");
106    Mutex::Autolock _l(mLock);
107    mpAudioPolicy->set_force_use(mpAudioPolicy, usage, config);
108    return NO_ERROR;
109}
110
111audio_policy_forced_cfg_t AudioPolicyService::getForceUse(audio_policy_force_use_t usage)
112{
113    if (mpAudioPolicy == NULL) {
114        return AUDIO_POLICY_FORCE_NONE;
115    }
116    if (usage < 0 || usage >= AUDIO_POLICY_FORCE_USE_CNT) {
117        return AUDIO_POLICY_FORCE_NONE;
118    }
119    return mpAudioPolicy->get_force_use(mpAudioPolicy, usage);
120}
121
122audio_io_handle_t AudioPolicyService::getOutput(audio_stream_type_t stream,
123                                    uint32_t samplingRate,
124                                    audio_format_t format,
125                                    audio_channel_mask_t channelMask,
126                                    audio_output_flags_t flags,
127                                    const audio_offload_info_t *offloadInfo)
128{
129    if (mpAudioPolicy == NULL) {
130        return 0;
131    }
132    ALOGV("getOutput()");
133    Mutex::Autolock _l(mLock);
134    return mpAudioPolicy->get_output(mpAudioPolicy, stream, samplingRate,
135                                    format, channelMask, flags, offloadInfo);
136}
137
138status_t AudioPolicyService::startOutput(audio_io_handle_t output,
139                                         audio_stream_type_t stream,
140                                         int session)
141{
142    if (mpAudioPolicy == NULL) {
143        return NO_INIT;
144    }
145    ALOGV("startOutput()");
146    Mutex::Autolock _l(mLock);
147    return mpAudioPolicy->start_output(mpAudioPolicy, output, stream, session);
148}
149
150status_t AudioPolicyService::stopOutput(audio_io_handle_t output,
151                                        audio_stream_type_t stream,
152                                        int session)
153{
154    if (mpAudioPolicy == NULL) {
155        return NO_INIT;
156    }
157    ALOGV("stopOutput()");
158    mOutputCommandThread->stopOutputCommand(output, stream, session);
159    return NO_ERROR;
160}
161
162status_t  AudioPolicyService::doStopOutput(audio_io_handle_t output,
163                                      audio_stream_type_t stream,
164                                      int session)
165{
166    ALOGV("doStopOutput from tid %d", gettid());
167    Mutex::Autolock _l(mLock);
168    return mpAudioPolicy->stop_output(mpAudioPolicy, output, stream, session);
169}
170
171void AudioPolicyService::releaseOutput(audio_io_handle_t output)
172{
173    if (mpAudioPolicy == NULL) {
174        return;
175    }
176    ALOGV("releaseOutput()");
177    mOutputCommandThread->releaseOutputCommand(output);
178}
179
180void AudioPolicyService::doReleaseOutput(audio_io_handle_t output)
181{
182    ALOGV("doReleaseOutput from tid %d", gettid());
183    Mutex::Autolock _l(mLock);
184    mpAudioPolicy->release_output(mpAudioPolicy, output);
185}
186
187audio_io_handle_t AudioPolicyService::getInput(audio_source_t inputSource,
188                                    uint32_t samplingRate,
189                                    audio_format_t format,
190                                    audio_channel_mask_t channelMask,
191                                    int audioSession)
192{
193    if (mpAudioPolicy == NULL) {
194        return 0;
195    }
196    // already checked by client, but double-check in case the client wrapper is bypassed
197    if (inputSource >= AUDIO_SOURCE_CNT && inputSource != AUDIO_SOURCE_HOTWORD) {
198        return 0;
199    }
200
201    if ((inputSource == AUDIO_SOURCE_HOTWORD) && !captureHotwordAllowed()) {
202        return 0;
203    }
204
205    Mutex::Autolock _l(mLock);
206    // the audio_in_acoustics_t parameter is ignored by get_input()
207    audio_io_handle_t input = mpAudioPolicy->get_input(mpAudioPolicy, inputSource, samplingRate,
208                                                   format, channelMask, (audio_in_acoustics_t) 0);
209
210    if (input == 0) {
211        return input;
212    }
213    // create audio pre processors according to input source
214    audio_source_t aliasSource = (inputSource == AUDIO_SOURCE_HOTWORD) ?
215                                    AUDIO_SOURCE_VOICE_RECOGNITION : inputSource;
216
217    ssize_t index = mInputSources.indexOfKey(aliasSource);
218    if (index < 0) {
219        return input;
220    }
221    ssize_t idx = mInputs.indexOfKey(input);
222    InputDesc *inputDesc;
223    if (idx < 0) {
224        inputDesc = new InputDesc(audioSession);
225        mInputs.add(input, inputDesc);
226    } else {
227        inputDesc = mInputs.valueAt(idx);
228    }
229
230    Vector <EffectDesc *> effects = mInputSources.valueAt(index)->mEffects;
231    for (size_t i = 0; i < effects.size(); i++) {
232        EffectDesc *effect = effects[i];
233        sp<AudioEffect> fx = new AudioEffect(NULL, &effect->mUuid, -1, 0, 0, audioSession, input);
234        status_t status = fx->initCheck();
235        if (status != NO_ERROR && status != ALREADY_EXISTS) {
236            ALOGW("Failed to create Fx %s on input %d", effect->mName, input);
237            // fx goes out of scope and strong ref on AudioEffect is released
238            continue;
239        }
240        for (size_t j = 0; j < effect->mParams.size(); j++) {
241            fx->setParameter(effect->mParams[j]);
242        }
243        inputDesc->mEffects.add(fx);
244    }
245    setPreProcessorEnabled(inputDesc, true);
246    return input;
247}
248
249status_t AudioPolicyService::startInput(audio_io_handle_t input)
250{
251    if (mpAudioPolicy == NULL) {
252        return NO_INIT;
253    }
254    Mutex::Autolock _l(mLock);
255
256    return mpAudioPolicy->start_input(mpAudioPolicy, input);
257}
258
259status_t AudioPolicyService::stopInput(audio_io_handle_t input)
260{
261    if (mpAudioPolicy == NULL) {
262        return NO_INIT;
263    }
264    Mutex::Autolock _l(mLock);
265
266    return mpAudioPolicy->stop_input(mpAudioPolicy, input);
267}
268
269void AudioPolicyService::releaseInput(audio_io_handle_t input)
270{
271    if (mpAudioPolicy == NULL) {
272        return;
273    }
274    Mutex::Autolock _l(mLock);
275    mpAudioPolicy->release_input(mpAudioPolicy, input);
276
277    ssize_t index = mInputs.indexOfKey(input);
278    if (index < 0) {
279        return;
280    }
281    InputDesc *inputDesc = mInputs.valueAt(index);
282    setPreProcessorEnabled(inputDesc, false);
283    delete inputDesc;
284    mInputs.removeItemsAt(index);
285}
286
287status_t AudioPolicyService::initStreamVolume(audio_stream_type_t stream,
288                                            int indexMin,
289                                            int indexMax)
290{
291    if (mpAudioPolicy == NULL) {
292        return NO_INIT;
293    }
294    if (!settingsAllowed()) {
295        return PERMISSION_DENIED;
296    }
297    if (uint32_t(stream) >= AUDIO_STREAM_CNT) {
298        return BAD_VALUE;
299    }
300    Mutex::Autolock _l(mLock);
301    mpAudioPolicy->init_stream_volume(mpAudioPolicy, stream, indexMin, indexMax);
302    return NO_ERROR;
303}
304
305status_t AudioPolicyService::setStreamVolumeIndex(audio_stream_type_t stream,
306                                                  int index,
307                                                  audio_devices_t device)
308{
309    if (mpAudioPolicy == NULL) {
310        return NO_INIT;
311    }
312    if (!settingsAllowed()) {
313        return PERMISSION_DENIED;
314    }
315    if (uint32_t(stream) >= AUDIO_STREAM_CNT) {
316        return BAD_VALUE;
317    }
318    Mutex::Autolock _l(mLock);
319    if (mpAudioPolicy->set_stream_volume_index_for_device) {
320        return mpAudioPolicy->set_stream_volume_index_for_device(mpAudioPolicy,
321                                                                stream,
322                                                                index,
323                                                                device);
324    } else {
325        return mpAudioPolicy->set_stream_volume_index(mpAudioPolicy, stream, index);
326    }
327}
328
329status_t AudioPolicyService::getStreamVolumeIndex(audio_stream_type_t stream,
330                                                  int *index,
331                                                  audio_devices_t device)
332{
333    if (mpAudioPolicy == NULL) {
334        return NO_INIT;
335    }
336    if (uint32_t(stream) >= AUDIO_STREAM_CNT) {
337        return BAD_VALUE;
338    }
339    Mutex::Autolock _l(mLock);
340    if (mpAudioPolicy->get_stream_volume_index_for_device) {
341        return mpAudioPolicy->get_stream_volume_index_for_device(mpAudioPolicy,
342                                                                stream,
343                                                                index,
344                                                                device);
345    } else {
346        return mpAudioPolicy->get_stream_volume_index(mpAudioPolicy, stream, index);
347    }
348}
349
350uint32_t AudioPolicyService::getStrategyForStream(audio_stream_type_t stream)
351{
352    if (mpAudioPolicy == NULL) {
353        return 0;
354    }
355    return mpAudioPolicy->get_strategy_for_stream(mpAudioPolicy, stream);
356}
357
358//audio policy: use audio_device_t appropriately
359
360audio_devices_t AudioPolicyService::getDevicesForStream(audio_stream_type_t stream)
361{
362    if (mpAudioPolicy == NULL) {
363        return (audio_devices_t)0;
364    }
365    return mpAudioPolicy->get_devices_for_stream(mpAudioPolicy, stream);
366}
367
368audio_io_handle_t AudioPolicyService::getOutputForEffect(const effect_descriptor_t *desc)
369{
370    // FIXME change return type to status_t, and return NO_INIT here
371    if (mpAudioPolicy == NULL) {
372        return 0;
373    }
374    Mutex::Autolock _l(mLock);
375    return mpAudioPolicy->get_output_for_effect(mpAudioPolicy, desc);
376}
377
378status_t AudioPolicyService::registerEffect(const effect_descriptor_t *desc,
379                                audio_io_handle_t io,
380                                uint32_t strategy,
381                                int session,
382                                int id)
383{
384    if (mpAudioPolicy == NULL) {
385        return NO_INIT;
386    }
387    return mpAudioPolicy->register_effect(mpAudioPolicy, desc, io, strategy, session, id);
388}
389
390status_t AudioPolicyService::unregisterEffect(int id)
391{
392    if (mpAudioPolicy == NULL) {
393        return NO_INIT;
394    }
395    return mpAudioPolicy->unregister_effect(mpAudioPolicy, id);
396}
397
398status_t AudioPolicyService::setEffectEnabled(int id, bool enabled)
399{
400    if (mpAudioPolicy == NULL) {
401        return NO_INIT;
402    }
403    return mpAudioPolicy->set_effect_enabled(mpAudioPolicy, id, enabled);
404}
405
406bool AudioPolicyService::isStreamActive(audio_stream_type_t stream, uint32_t inPastMs) const
407{
408    if (mpAudioPolicy == NULL) {
409        return 0;
410    }
411    Mutex::Autolock _l(mLock);
412    return mpAudioPolicy->is_stream_active(mpAudioPolicy, stream, inPastMs);
413}
414
415bool AudioPolicyService::isStreamActiveRemotely(audio_stream_type_t stream, uint32_t inPastMs) const
416{
417    if (mpAudioPolicy == NULL) {
418        return 0;
419    }
420    Mutex::Autolock _l(mLock);
421    return mpAudioPolicy->is_stream_active_remotely(mpAudioPolicy, stream, inPastMs);
422}
423
424bool AudioPolicyService::isSourceActive(audio_source_t source) const
425{
426    if (mpAudioPolicy == NULL) {
427        return false;
428    }
429    if (mpAudioPolicy->is_source_active == 0) {
430        return false;
431    }
432    Mutex::Autolock _l(mLock);
433    return mpAudioPolicy->is_source_active(mpAudioPolicy, source);
434}
435
436status_t AudioPolicyService::queryDefaultPreProcessing(int audioSession,
437                                                       effect_descriptor_t *descriptors,
438                                                       uint32_t *count)
439{
440
441    if (mpAudioPolicy == NULL) {
442        *count = 0;
443        return NO_INIT;
444    }
445    Mutex::Autolock _l(mLock);
446    status_t status = NO_ERROR;
447
448    size_t index;
449    for (index = 0; index < mInputs.size(); index++) {
450        if (mInputs.valueAt(index)->mSessionId == audioSession) {
451            break;
452        }
453    }
454    if (index == mInputs.size()) {
455        *count = 0;
456        return BAD_VALUE;
457    }
458    Vector< sp<AudioEffect> > effects = mInputs.valueAt(index)->mEffects;
459
460    for (size_t i = 0; i < effects.size(); i++) {
461        effect_descriptor_t desc = effects[i]->descriptor();
462        if (i < *count) {
463            descriptors[i] = desc;
464        }
465    }
466    if (effects.size() > *count) {
467        status = NO_MEMORY;
468    }
469    *count = effects.size();
470    return status;
471}
472
473bool AudioPolicyService::isOffloadSupported(const audio_offload_info_t& info)
474{
475    if (mpAudioPolicy == NULL) {
476        ALOGV("mpAudioPolicy == NULL");
477        return false;
478    }
479
480    if (mpAudioPolicy->is_offload_supported == NULL) {
481        ALOGV("HAL does not implement is_offload_supported");
482        return false;
483    }
484
485    return mpAudioPolicy->is_offload_supported(mpAudioPolicy, &info);
486}
487
488
489}; // namespace android
490