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 "AudioPolicyService.h"
21
22 #include <utils/Log.h>
23
24 #include "BinderProxy.h"
25
26 namespace android {
27
28 /* implementation of the client interface from the policy manager */
29
loadHwModule(const char * name)30 audio_module_handle_t AudioPolicyService::AudioPolicyClient::loadHwModule(const char *name)
31 {
32 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
33 if (af == 0) {
34 ALOGW("%s: could not get AudioFlinger", __func__);
35 return AUDIO_MODULE_HANDLE_NONE;
36 }
37
38 return af->loadHwModule(name);
39 }
40
openOutput(audio_module_handle_t module,audio_io_handle_t * output,audio_config_t * halConfig,audio_config_base_t * mixerConfig,const sp<DeviceDescriptorBase> & device,uint32_t * latencyMs,audio_output_flags_t flags)41 status_t AudioPolicyService::AudioPolicyClient::openOutput(audio_module_handle_t module,
42 audio_io_handle_t *output,
43 audio_config_t *halConfig,
44 audio_config_base_t *mixerConfig,
45 const sp<DeviceDescriptorBase>& device,
46 uint32_t *latencyMs,
47 audio_output_flags_t flags)
48 {
49 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
50 if (af == 0) {
51 ALOGW("%s: could not get AudioFlinger", __func__);
52 return PERMISSION_DENIED;
53 }
54
55 media::OpenOutputRequest request;
56 media::OpenOutputResponse response;
57
58 request.module = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_module_handle_t_int32_t(module));
59 request.halConfig = VALUE_OR_RETURN_STATUS(
60 legacy2aidl_audio_config_t_AudioConfig(*halConfig, false /*isInput*/));
61 request.mixerConfig = VALUE_OR_RETURN_STATUS(
62 legacy2aidl_audio_config_base_t_AudioConfigBase(*mixerConfig, false /*isInput*/));
63 request.device = VALUE_OR_RETURN_STATUS(legacy2aidl_DeviceDescriptorBase(device));
64 request.flags = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_output_flags_t_int32_t_mask(flags));
65
66 status_t status = af->openOutput(request, &response);
67 if (status == OK) {
68 *output = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_audio_io_handle_t(response.output));
69 *halConfig = VALUE_OR_RETURN_STATUS(
70 aidl2legacy_AudioConfig_audio_config_t(response.config, false /*isInput*/));
71 *latencyMs = VALUE_OR_RETURN_STATUS(convertIntegral<uint32_t>(response.latencyMs));
72 }
73 return status;
74 }
75
openDuplicateOutput(audio_io_handle_t output1,audio_io_handle_t output2)76 audio_io_handle_t AudioPolicyService::AudioPolicyClient::openDuplicateOutput(
77 audio_io_handle_t output1,
78 audio_io_handle_t output2)
79 {
80 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
81 if (af == 0) {
82 ALOGW("%s: could not get AudioFlinger", __func__);
83 return 0;
84 }
85 return af->openDuplicateOutput(output1, output2);
86 }
87
closeOutput(audio_io_handle_t output)88 status_t AudioPolicyService::AudioPolicyClient::closeOutput(audio_io_handle_t output)
89 {
90 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
91 if (af == 0) {
92 return PERMISSION_DENIED;
93 }
94
95 return af->closeOutput(output);
96 }
97
suspendOutput(audio_io_handle_t output)98 status_t AudioPolicyService::AudioPolicyClient::suspendOutput(audio_io_handle_t output)
99 {
100 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
101 if (af == 0) {
102 ALOGW("%s: could not get AudioFlinger", __func__);
103 return PERMISSION_DENIED;
104 }
105
106 return af->suspendOutput(output);
107 }
108
restoreOutput(audio_io_handle_t output)109 status_t AudioPolicyService::AudioPolicyClient::restoreOutput(audio_io_handle_t output)
110 {
111 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
112 if (af == 0) {
113 ALOGW("%s: could not get AudioFlinger", __func__);
114 return PERMISSION_DENIED;
115 }
116
117 return af->restoreOutput(output);
118 }
119
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)120 status_t AudioPolicyService::AudioPolicyClient::openInput(audio_module_handle_t module,
121 audio_io_handle_t *input,
122 audio_config_t *config,
123 audio_devices_t *device,
124 const String8& address,
125 audio_source_t source,
126 audio_input_flags_t flags)
127 {
128 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
129 if (af == 0) {
130 ALOGW("%s: could not get AudioFlinger", __func__);
131 return PERMISSION_DENIED;
132 }
133
134 AudioDeviceTypeAddr deviceTypeAddr(*device, address.c_str());
135
136 media::OpenInputRequest request;
137 request.module = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_module_handle_t_int32_t(module));
138 request.input = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(*input));
139 request.config = VALUE_OR_RETURN_STATUS(
140 legacy2aidl_audio_config_t_AudioConfig(*config, true /*isInput*/));
141 request.device = VALUE_OR_RETURN_STATUS(legacy2aidl_AudioDeviceTypeAddress(deviceTypeAddr));
142 request.source = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_source_t_AudioSource(source));
143 request.flags = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_input_flags_t_int32_t_mask(flags));
144
145 media::OpenInputResponse response;
146 status_t status = af->openInput(request, &response);
147 if (status == OK) {
148 *input = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_audio_module_handle_t(response.input));
149 }
150 return status;
151 }
152
closeInput(audio_io_handle_t input)153 status_t AudioPolicyService::AudioPolicyClient::closeInput(audio_io_handle_t input)
154 {
155 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
156 if (af == 0) {
157 return PERMISSION_DENIED;
158 }
159
160 return af->closeInput(input);
161 }
162
setStreamVolume(audio_stream_type_t stream,float volume,audio_io_handle_t output,int delay_ms)163 status_t AudioPolicyService::AudioPolicyClient::setStreamVolume(audio_stream_type_t stream,
164 float volume, audio_io_handle_t output,
165 int delay_ms)
166 {
167 return mAudioPolicyService->setStreamVolume(stream, volume, output,
168 delay_ms);
169 }
170
invalidateStream(audio_stream_type_t stream)171 status_t AudioPolicyService::AudioPolicyClient::invalidateStream(audio_stream_type_t stream)
172 {
173 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
174 if (af == 0) {
175 return PERMISSION_DENIED;
176 }
177
178 return af->invalidateStream(stream);
179 }
180
setParameters(audio_io_handle_t io_handle,const String8 & keyValuePairs,int delay_ms)181 void AudioPolicyService::AudioPolicyClient::setParameters(audio_io_handle_t io_handle,
182 const String8& keyValuePairs,
183 int delay_ms)
184 {
185 mAudioPolicyService->setParameters(io_handle, keyValuePairs.string(), delay_ms);
186 }
187
getParameters(audio_io_handle_t io_handle,const String8 & keys)188 String8 AudioPolicyService::AudioPolicyClient::getParameters(audio_io_handle_t io_handle,
189 const String8& keys)
190 {
191 String8 result = AudioSystem::getParameters(io_handle, keys);
192 return result;
193 }
194
setVoiceVolume(float volume,int delay_ms)195 status_t AudioPolicyService::AudioPolicyClient::setVoiceVolume(float volume, int delay_ms)
196 {
197 return mAudioPolicyService->setVoiceVolume(volume, delay_ms);
198 }
199
moveEffects(audio_session_t session,audio_io_handle_t src_output,audio_io_handle_t dst_output)200 status_t AudioPolicyService::AudioPolicyClient::moveEffects(audio_session_t session,
201 audio_io_handle_t src_output,
202 audio_io_handle_t dst_output)
203 {
204 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
205 if (af == 0) {
206 return PERMISSION_DENIED;
207 }
208
209 return af->moveEffects(session, src_output, dst_output);
210 }
211
setEffectSuspended(int effectId,audio_session_t sessionId,bool suspended)212 void AudioPolicyService::AudioPolicyClient::setEffectSuspended(int effectId,
213 audio_session_t sessionId,
214 bool suspended)
215 {
216 mAudioPolicyService->setEffectSuspended(effectId, sessionId, suspended);
217 }
218
createAudioPatch(const struct audio_patch * patch,audio_patch_handle_t * handle,int delayMs)219 status_t AudioPolicyService::AudioPolicyClient::createAudioPatch(const struct audio_patch *patch,
220 audio_patch_handle_t *handle,
221 int delayMs)
222 {
223 return mAudioPolicyService->clientCreateAudioPatch(patch, handle, delayMs);
224 }
225
releaseAudioPatch(audio_patch_handle_t handle,int delayMs)226 status_t AudioPolicyService::AudioPolicyClient::releaseAudioPatch(audio_patch_handle_t handle,
227 int delayMs)
228 {
229 return mAudioPolicyService->clientReleaseAudioPatch(handle, delayMs);
230 }
231
setAudioPortConfig(const struct audio_port_config * config,int delayMs)232 status_t AudioPolicyService::AudioPolicyClient::setAudioPortConfig(
233 const struct audio_port_config *config,
234 int delayMs)
235 {
236 return mAudioPolicyService->clientSetAudioPortConfig(config, delayMs);
237 }
238
onAudioPortListUpdate()239 void AudioPolicyService::AudioPolicyClient::onAudioPortListUpdate()
240 {
241 mAudioPolicyService->onAudioPortListUpdate();
242 }
243
onAudioPatchListUpdate()244 void AudioPolicyService::AudioPolicyClient::onAudioPatchListUpdate()
245 {
246 mAudioPolicyService->onAudioPatchListUpdate();
247 }
248
onDynamicPolicyMixStateUpdate(String8 regId,int32_t state)249 void AudioPolicyService::AudioPolicyClient::onDynamicPolicyMixStateUpdate(
250 String8 regId, int32_t state)
251 {
252 mAudioPolicyService->onDynamicPolicyMixStateUpdate(regId, state);
253 }
254
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)255 void AudioPolicyService::AudioPolicyClient::onRecordingConfigurationUpdate(
256 int event,
257 const record_client_info_t *clientInfo,
258 const audio_config_base_t *clientConfig,
259 std::vector<effect_descriptor_t> clientEffects,
260 const audio_config_base_t *deviceConfig,
261 std::vector<effect_descriptor_t> effects,
262 audio_patch_handle_t patchHandle,
263 audio_source_t source)
264 {
265 mAudioPolicyService->onRecordingConfigurationUpdate(event, clientInfo,
266 clientConfig, clientEffects, deviceConfig, effects, patchHandle, source);
267 }
268
onAudioVolumeGroupChanged(volume_group_t group,int flags)269 void AudioPolicyService::AudioPolicyClient::onAudioVolumeGroupChanged(volume_group_t group,
270 int flags)
271 {
272 mAudioPolicyService->onAudioVolumeGroupChanged(group, flags);
273 }
274
onRoutingUpdated()275 void AudioPolicyService::AudioPolicyClient::onRoutingUpdated()
276 {
277 mAudioPolicyService->onRoutingUpdated();
278 }
279
onVolumeRangeInitRequest()280 void AudioPolicyService::AudioPolicyClient::onVolumeRangeInitRequest()
281 {
282 mAudioPolicyService->onVolumeRangeInitRequest();
283 }
284
newAudioUniqueId(audio_unique_id_use_t use)285 audio_unique_id_t AudioPolicyService::AudioPolicyClient::newAudioUniqueId(audio_unique_id_use_t use)
286 {
287 return AudioSystem::newAudioUniqueId(use);
288 }
289
setSoundTriggerCaptureState(bool active)290 void AudioPolicyService::AudioPolicyClient::setSoundTriggerCaptureState(bool active)
291 {
292 mAudioPolicyService->mCaptureStateNotifier.setCaptureState(active);
293 }
294
getAudioPort(struct audio_port_v7 * port)295 status_t AudioPolicyService::AudioPolicyClient::getAudioPort(struct audio_port_v7 *port)
296 {
297 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
298 if (af == 0) {
299 ALOGW("%s: could not get AudioFlinger", __func__);
300 return PERMISSION_DENIED;
301 }
302 return af->getAudioPort(port);
303 }
304
updateSecondaryOutputs(const TrackSecondaryOutputsMap & trackSecondaryOutputs)305 status_t AudioPolicyService::AudioPolicyClient::updateSecondaryOutputs(
306 const TrackSecondaryOutputsMap& trackSecondaryOutputs) {
307 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
308 if (af == nullptr) {
309 ALOGW("%s: could not get AudioFlinger", __func__);
310 return PERMISSION_DENIED;
311 }
312 return af->updateSecondaryOutputs(trackSecondaryOutputs);
313 }
314
setDeviceConnectedState(const struct audio_port_v7 * port,bool connected)315 status_t AudioPolicyService::AudioPolicyClient::setDeviceConnectedState(
316 const struct audio_port_v7 *port, bool connected) {
317 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
318 if (af == nullptr) {
319 ALOGW("%s: could not get AudioFlinger", __func__);
320 return PERMISSION_DENIED;
321 }
322 return af->setDeviceConnectedState(port, connected);
323 }
324
325
326 } // namespace android
327