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