AudioPolicyClientImpl.cpp revision ec40d284218466d8f0e832e7eb88e6ea6c479c88 
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 "AudioPolicyClientImpl"
18//#define LOG_NDEBUG 0
19
20#include <utils/Log.h>
21#include "AudioPolicyService.h"
22
23namespace android {
24
25/* implementation of the client interface from the policy manager */
26
27audio_module_handle_t AudioPolicyService::AudioPolicyClient::loadHwModule(const char *name)
28{
29    sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
30    if (af == 0) {
31        ALOGW("%s: could not get AudioFlinger", __func__);
32        return 0;
33    }
34
35    return af->loadHwModule(name);
36}
37
38audio_io_handle_t AudioPolicyService::AudioPolicyClient::openOutput(audio_module_handle_t module,
39                               audio_devices_t *pDevices,
40                               uint32_t *pSamplingRate,
41                               audio_format_t *pFormat,
42                               audio_channel_mask_t *pChannelMask,
43                               uint32_t *pLatencyMs,
44                               audio_output_flags_t flags,
45                               const audio_offload_info_t *offloadInfo)
46{
47    sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
48    if (af == 0) {
49        ALOGW("%s: could not get AudioFlinger", __func__);
50        return 0;
51    }
52    return af->openOutput(module, pDevices, pSamplingRate, pFormat, pChannelMask,
53                          pLatencyMs, flags, offloadInfo);
54}
55
56audio_io_handle_t AudioPolicyService::AudioPolicyClient::openDuplicateOutput(
57                                                                audio_io_handle_t output1,
58                                                                audio_io_handle_t output2)
59{
60    sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
61    if (af == 0) {
62        ALOGW("%s: could not get AudioFlinger", __func__);
63        return 0;
64    }
65    return af->openDuplicateOutput(output1, output2);
66}
67
68status_t AudioPolicyService::AudioPolicyClient::closeOutput(audio_io_handle_t output)
69{
70    sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
71    if (af == 0) {
72        return PERMISSION_DENIED;
73    }
74
75    return af->closeOutput(output);
76}
77
78status_t AudioPolicyService::AudioPolicyClient::suspendOutput(audio_io_handle_t output)
79{
80    sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
81    if (af == 0) {
82        ALOGW("%s: could not get AudioFlinger", __func__);
83        return PERMISSION_DENIED;
84    }
85
86    return af->suspendOutput(output);
87}
88
89status_t AudioPolicyService::AudioPolicyClient::restoreOutput(audio_io_handle_t output)
90{
91    sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
92    if (af == 0) {
93        ALOGW("%s: could not get AudioFlinger", __func__);
94        return PERMISSION_DENIED;
95    }
96
97    return af->restoreOutput(output);
98}
99
100audio_io_handle_t AudioPolicyService::AudioPolicyClient::openInput(audio_module_handle_t module,
101                              audio_devices_t *pDevices,
102                              uint32_t *pSamplingRate,
103                              audio_format_t *pFormat,
104                              audio_channel_mask_t *pChannelMask,
105                              audio_input_flags_t flags)
106{
107    sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
108    if (af == 0) {
109        ALOGW("%s: could not get AudioFlinger", __func__);
110        return 0;
111    }
112
113    return af->openInput(module, pDevices, pSamplingRate, pFormat, pChannelMask, flags);
114}
115
116status_t AudioPolicyService::AudioPolicyClient::closeInput(audio_io_handle_t input)
117{
118    sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
119    if (af == 0) {
120        return PERMISSION_DENIED;
121    }
122
123    return af->closeInput(input);
124}
125
126status_t AudioPolicyService::AudioPolicyClient::setStreamVolume(audio_stream_type_t stream,
127                     float volume, audio_io_handle_t output,
128                     int delay_ms)
129{
130    return mAudioPolicyService->setStreamVolume(stream, volume, output,
131                                               delay_ms);
132}
133
134status_t AudioPolicyService::AudioPolicyClient::invalidateStream(audio_stream_type_t stream)
135{
136    sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
137    if (af == 0) {
138        return PERMISSION_DENIED;
139    }
140
141    return af->invalidateStream(stream);
142}
143
144void AudioPolicyService::AudioPolicyClient::setParameters(audio_io_handle_t io_handle,
145                   const String8& keyValuePairs,
146                   int delay_ms)
147{
148    mAudioPolicyService->setParameters(io_handle, keyValuePairs.string(), delay_ms);
149}
150
151String8 AudioPolicyService::AudioPolicyClient::getParameters(audio_io_handle_t io_handle,
152                      const String8& keys)
153{
154    String8 result = AudioSystem::getParameters(io_handle, keys);
155    return result;
156}
157
158status_t AudioPolicyService::AudioPolicyClient::startTone(audio_policy_tone_t tone,
159              audio_stream_type_t stream)
160{
161    return mAudioPolicyService->startTone(tone, stream);
162}
163
164status_t AudioPolicyService::AudioPolicyClient::stopTone()
165{
166    return mAudioPolicyService->stopTone();
167}
168
169status_t AudioPolicyService::AudioPolicyClient::setVoiceVolume(float volume, int delay_ms)
170{
171    return mAudioPolicyService->setVoiceVolume(volume, delay_ms);
172}
173
174status_t AudioPolicyService::AudioPolicyClient::moveEffects(int session,
175                        audio_io_handle_t src_output,
176                        audio_io_handle_t dst_output)
177{
178    sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
179    if (af == 0) {
180        return PERMISSION_DENIED;
181    }
182
183    return af->moveEffects(session, src_output, dst_output);
184}
185
186status_t AudioPolicyService::AudioPolicyClient::createAudioPatch(const struct audio_patch *patch,
187                                                                  audio_patch_handle_t *handle,
188                                                                  int delayMs)
189{
190    return mAudioPolicyService->clientCreateAudioPatch(patch, handle, delayMs);
191}
192
193status_t AudioPolicyService::AudioPolicyClient::releaseAudioPatch(audio_patch_handle_t handle,
194                                                                  int delayMs)
195{
196    return mAudioPolicyService->clientReleaseAudioPatch(handle, delayMs);
197}
198
199status_t AudioPolicyService::AudioPolicyClient::setAudioPortConfig(
200                                                        const struct audio_port_config *config,
201                                                        int delayMs)
202{
203    return mAudioPolicyService->clientSetAudioPortConfig(config, delayMs);
204}
205
206void AudioPolicyService::AudioPolicyClient::onAudioPortListUpdate()
207{
208    mAudioPolicyService->onAudioPortListUpdate();
209}
210
211void AudioPolicyService::AudioPolicyClient::onAudioPatchListUpdate()
212{
213    mAudioPolicyService->onAudioPatchListUpdate();
214}
215
216}; // namespace android
217