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 <soundtrigger/SoundTrigger.h>
21#include <utils/Log.h>
22#include "AudioPolicyService.h"
23
24namespace android {
25
26/* implementation of the client interface from the policy manager */
27
28audio_module_handle_t AudioPolicyService::AudioPolicyClient::loadHwModule(const char *name)
29{
30    sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
31    if (af == 0) {
32        ALOGW("%s: could not get AudioFlinger", __func__);
33        return 0;
34    }
35
36    return af->loadHwModule(name);
37}
38
39status_t AudioPolicyService::AudioPolicyClient::openOutput(audio_module_handle_t module,
40                                                           audio_io_handle_t *output,
41                                                           audio_config_t *config,
42                                                           audio_devices_t *devices,
43                                                           const String8& address,
44                                                           uint32_t *latencyMs,
45                                                           audio_output_flags_t flags)
46{
47    sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
48    if (af == 0) {
49        ALOGW("%s: could not get AudioFlinger", __func__);
50        return PERMISSION_DENIED;
51    }
52    return af->openOutput(module, output, config, devices, address, latencyMs, flags);
53}
54
55audio_io_handle_t AudioPolicyService::AudioPolicyClient::openDuplicateOutput(
56                                                                audio_io_handle_t output1,
57                                                                audio_io_handle_t output2)
58{
59    sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
60    if (af == 0) {
61        ALOGW("%s: could not get AudioFlinger", __func__);
62        return 0;
63    }
64    return af->openDuplicateOutput(output1, output2);
65}
66
67status_t AudioPolicyService::AudioPolicyClient::closeOutput(audio_io_handle_t output)
68{
69    sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
70    if (af == 0) {
71        return PERMISSION_DENIED;
72    }
73
74    return af->closeOutput(output);
75}
76
77status_t AudioPolicyService::AudioPolicyClient::suspendOutput(audio_io_handle_t output)
78{
79    sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
80    if (af == 0) {
81        ALOGW("%s: could not get AudioFlinger", __func__);
82        return PERMISSION_DENIED;
83    }
84
85    return af->suspendOutput(output);
86}
87
88status_t AudioPolicyService::AudioPolicyClient::restoreOutput(audio_io_handle_t output)
89{
90    sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
91    if (af == 0) {
92        ALOGW("%s: could not get AudioFlinger", __func__);
93        return PERMISSION_DENIED;
94    }
95
96    return af->restoreOutput(output);
97}
98
99status_t AudioPolicyService::AudioPolicyClient::openInput(audio_module_handle_t module,
100                                                          audio_io_handle_t *input,
101                                                          audio_config_t *config,
102                                                          audio_devices_t *device,
103                                                          const String8& address,
104                                                          audio_source_t source,
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 PERMISSION_DENIED;
111    }
112
113    return af->openInput(module, input, config, device, address, source, 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
216audio_unique_id_t AudioPolicyService::AudioPolicyClient::newAudioUniqueId()
217{
218    return AudioSystem::newAudioUniqueId();
219}
220
221}; // namespace android
222