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