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
24 namespace android {
25
26 /* implementation of the client interface from the policy manager */
27
loadHwModule(const char * name)28 audio_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 AUDIO_MODULE_HANDLE_NONE;
34 }
35
36 return af->loadHwModule(name);
37 }
38
openOutput(audio_module_handle_t module,audio_io_handle_t * output,audio_config_t * config,const sp<DeviceDescriptorBase> & device,uint32_t * latencyMs,audio_output_flags_t flags)39 status_t AudioPolicyService::AudioPolicyClient::openOutput(audio_module_handle_t module,
40 audio_io_handle_t *output,
41 audio_config_t *config,
42 const sp<DeviceDescriptorBase>& device,
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, device, latencyMs, flags);
52 }
53
openDuplicateOutput(audio_io_handle_t output1,audio_io_handle_t output2)54 audio_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
closeOutput(audio_io_handle_t output)66 status_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
suspendOutput(audio_io_handle_t output)76 status_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
restoreOutput(audio_io_handle_t output)87 status_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
openInput(audio_module_handle_t module,audio_io_handle_t * input,audio_config_t * config,audio_devices_t * device,const String8 & address,audio_source_t source,audio_input_flags_t flags)98 status_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
closeInput(audio_io_handle_t input)115 status_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
setStreamVolume(audio_stream_type_t stream,float volume,audio_io_handle_t output,int delay_ms)125 status_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
invalidateStream(audio_stream_type_t stream)133 status_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
setParameters(audio_io_handle_t io_handle,const String8 & keyValuePairs,int delay_ms)143 void 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
getParameters(audio_io_handle_t io_handle,const String8 & keys)150 String8 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
setVoiceVolume(float volume,int delay_ms)157 status_t AudioPolicyService::AudioPolicyClient::setVoiceVolume(float volume, int delay_ms)
158 {
159 return mAudioPolicyService->setVoiceVolume(volume, delay_ms);
160 }
161
moveEffects(audio_session_t session,audio_io_handle_t src_output,audio_io_handle_t dst_output)162 status_t AudioPolicyService::AudioPolicyClient::moveEffects(audio_session_t session,
163 audio_io_handle_t src_output,
164 audio_io_handle_t dst_output)
165 {
166 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
167 if (af == 0) {
168 return PERMISSION_DENIED;
169 }
170
171 return af->moveEffects(session, src_output, dst_output);
172 }
173
setEffectSuspended(int effectId,audio_session_t sessionId,bool suspended)174 void AudioPolicyService::AudioPolicyClient::setEffectSuspended(int effectId,
175 audio_session_t sessionId,
176 bool suspended)
177 {
178 mAudioPolicyService->setEffectSuspended(effectId, sessionId, suspended);
179 }
180
createAudioPatch(const struct audio_patch * patch,audio_patch_handle_t * handle,int delayMs)181 status_t AudioPolicyService::AudioPolicyClient::createAudioPatch(const struct audio_patch *patch,
182 audio_patch_handle_t *handle,
183 int delayMs)
184 {
185 return mAudioPolicyService->clientCreateAudioPatch(patch, handle, delayMs);
186 }
187
releaseAudioPatch(audio_patch_handle_t handle,int delayMs)188 status_t AudioPolicyService::AudioPolicyClient::releaseAudioPatch(audio_patch_handle_t handle,
189 int delayMs)
190 {
191 return mAudioPolicyService->clientReleaseAudioPatch(handle, delayMs);
192 }
193
setAudioPortConfig(const struct audio_port_config * config,int delayMs)194 status_t AudioPolicyService::AudioPolicyClient::setAudioPortConfig(
195 const struct audio_port_config *config,
196 int delayMs)
197 {
198 return mAudioPolicyService->clientSetAudioPortConfig(config, delayMs);
199 }
200
onAudioPortListUpdate()201 void AudioPolicyService::AudioPolicyClient::onAudioPortListUpdate()
202 {
203 mAudioPolicyService->onAudioPortListUpdate();
204 }
205
onAudioPatchListUpdate()206 void AudioPolicyService::AudioPolicyClient::onAudioPatchListUpdate()
207 {
208 mAudioPolicyService->onAudioPatchListUpdate();
209 }
210
onDynamicPolicyMixStateUpdate(String8 regId,int32_t state)211 void AudioPolicyService::AudioPolicyClient::onDynamicPolicyMixStateUpdate(
212 String8 regId, int32_t state)
213 {
214 mAudioPolicyService->onDynamicPolicyMixStateUpdate(regId, state);
215 }
216
onRecordingConfigurationUpdate(int event,const record_client_info_t * clientInfo,const audio_config_base_t * clientConfig,std::vector<effect_descriptor_t> clientEffects,const audio_config_base_t * deviceConfig,std::vector<effect_descriptor_t> effects,audio_patch_handle_t patchHandle,audio_source_t source)217 void AudioPolicyService::AudioPolicyClient::onRecordingConfigurationUpdate(
218 int event,
219 const record_client_info_t *clientInfo,
220 const audio_config_base_t *clientConfig,
221 std::vector<effect_descriptor_t> clientEffects,
222 const audio_config_base_t *deviceConfig,
223 std::vector<effect_descriptor_t> effects,
224 audio_patch_handle_t patchHandle,
225 audio_source_t source)
226 {
227 mAudioPolicyService->onRecordingConfigurationUpdate(event, clientInfo,
228 clientConfig, clientEffects, deviceConfig, effects, patchHandle, source);
229 }
230
onAudioVolumeGroupChanged(volume_group_t group,int flags)231 void AudioPolicyService::AudioPolicyClient::onAudioVolumeGroupChanged(volume_group_t group,
232 int flags)
233 {
234 mAudioPolicyService->onAudioVolumeGroupChanged(group, flags);
235 }
236
newAudioUniqueId(audio_unique_id_use_t use)237 audio_unique_id_t AudioPolicyService::AudioPolicyClient::newAudioUniqueId(audio_unique_id_use_t use)
238 {
239 return AudioSystem::newAudioUniqueId(use);
240 }
241
242 } // namespace android
243