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