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