blob: 6d2c77279c2ee94c623ec9dca4a1610a31a3212c [file] [log] [blame]
Eric Laurent2d388ec2014-03-07 13:25:54 -08001/*
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
Eric Laurentdce54a12014-03-10 12:19:46 -070017#define LOG_TAG "AudioPolicyClientImpl"
Eric Laurent2d388ec2014-03-07 13:25:54 -080018//#define LOG_NDEBUG 0
19
Eric Laurent2d388ec2014-03-07 13:25:54 -080020#include "AudioPolicyService.h"
Eric Laurent2d388ec2014-03-07 13:25:54 -080021
Ytai Ben-Tsvi74cd6b02019-10-25 10:06:40 -070022#include <utils/Log.h>
23
24#include "BinderProxy.h"
25
Eric Laurent2d388ec2014-03-07 13:25:54 -080026namespace android {
27
Eric Laurentdce54a12014-03-10 12:19:46 -070028/* implementation of the client interface from the policy manager */
Eric Laurent2d388ec2014-03-07 13:25:54 -080029
Mikhail Naganov1fba38c2023-05-03 17:45:36 -070030status_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
Eric Laurentdce54a12014-03-10 12:19:46 -070042audio_module_handle_t AudioPolicyService::AudioPolicyClient::loadHwModule(const char *name)
Eric Laurent2d388ec2014-03-07 13:25:54 -080043{
44 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
45 if (af == 0) {
46 ALOGW("%s: could not get AudioFlinger", __func__);
Glenn Kastena13cde92016-03-28 15:26:02 -070047 return AUDIO_MODULE_HANDLE_NONE;
Eric Laurent2d388ec2014-03-07 13:25:54 -080048 }
49
50 return af->loadHwModule(name);
51}
52
Eric Laurentcf2c0212014-07-25 16:20:43 -070053status_t AudioPolicyService::AudioPolicyClient::openOutput(audio_module_handle_t module,
54 audio_io_handle_t *output,
Eric Laurentf1f22e72021-07-13 14:04:14 +020055 audio_config_t *halConfig,
56 audio_config_base_t *mixerConfig,
jiabin43810402019-10-24 14:58:31 -070057 const sp<DeviceDescriptorBase>& device,
Eric Laurentcf2c0212014-07-25 16:20:43 -070058 uint32_t *latencyMs,
Dean Wheatleydfb67b82024-01-23 09:36:29 +110059 audio_output_flags_t *flags,
Haofan Wangb75aa6a2024-07-09 23:06:58 -070060 audio_attributes_t attributes)
Eric Laurent2d388ec2014-03-07 13:25:54 -080061{
62 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
63 if (af == 0) {
64 ALOGW("%s: could not get AudioFlinger", __func__);
Eric Laurentcf2c0212014-07-25 16:20:43 -070065 return PERMISSION_DENIED;
Eric Laurent2d388ec2014-03-07 13:25:54 -080066 }
Ytai Ben-Tsvi50e016a2020-11-12 14:26:12 -080067
68 media::OpenOutputRequest request;
69 media::OpenOutputResponse response;
70
71 request.module = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_module_handle_t_int32_t(module));
Mikhail Naganovde3fa182021-07-30 15:06:42 -070072 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*/));
Ytai Ben-Tsvi50e016a2020-11-12 14:26:12 -080076 request.device = VALUE_OR_RETURN_STATUS(legacy2aidl_DeviceDescriptorBase(device));
Dean Wheatleydfb67b82024-01-23 09:36:29 +110077 request.flags = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_output_flags_t_int32_t_mask(*flags));
Haofan Wangb75aa6a2024-07-09 23:06:58 -070078 request.attributes = VALUE_OR_RETURN_STATUS(
79 legacy2aidl_audio_attributes_t_AudioAttributes(attributes));
Ytai Ben-Tsvi50e016a2020-11-12 14:26:12 -080080
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));
Mikhail Naganovde3fa182021-07-30 15:06:42 -070084 *halConfig = VALUE_OR_RETURN_STATUS(
85 aidl2legacy_AudioConfig_audio_config_t(response.config, false /*isInput*/));
Ytai Ben-Tsvi50e016a2020-11-12 14:26:12 -080086 *latencyMs = VALUE_OR_RETURN_STATUS(convertIntegral<uint32_t>(response.latencyMs));
Eric Laurent0d13fea2022-11-04 17:12:08 +010087
88 audio_config_base_t config = {.sample_rate = halConfig->sample_rate,
89 .channel_mask = halConfig->channel_mask,
90 .format = halConfig->format,
91 };
Dean Wheatleydfb67b82024-01-23 09:36:29 +110092 *flags = VALUE_OR_RETURN_STATUS(
93 aidl2legacy_int32_t_audio_output_flags_t_mask(response.flags));
94 mAudioPolicyService->registerOutput(*output, config, *flags);
Ytai Ben-Tsvi50e016a2020-11-12 14:26:12 -080095 }
96 return status;
Eric Laurent2d388ec2014-03-07 13:25:54 -080097}
98
Eric Laurentdce54a12014-03-10 12:19:46 -070099audio_io_handle_t AudioPolicyService::AudioPolicyClient::openDuplicateOutput(
100 audio_io_handle_t output1,
101 audio_io_handle_t output2)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800102{
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
Eric Laurentdce54a12014-03-10 12:19:46 -0700111status_t AudioPolicyService::AudioPolicyClient::closeOutput(audio_io_handle_t output)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800112{
113 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
114 if (af == 0) {
115 return PERMISSION_DENIED;
116 }
Eric Laurent0d13fea2022-11-04 17:12:08 +0100117 mAudioPolicyService->unregisterOutput(output);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800118 return af->closeOutput(output);
119}
120
Eric Laurentdce54a12014-03-10 12:19:46 -0700121status_t AudioPolicyService::AudioPolicyClient::suspendOutput(audio_io_handle_t output)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800122{
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
Eric Laurentdce54a12014-03-10 12:19:46 -0700132status_t AudioPolicyService::AudioPolicyClient::restoreOutput(audio_io_handle_t output)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800133{
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
Eric Laurentcf2c0212014-07-25 16:20:43 -0700143status_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)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800150{
151 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
152 if (af == 0) {
153 ALOGW("%s: could not get AudioFlinger", __func__);
Eric Laurentcf2c0212014-07-25 16:20:43 -0700154 return PERMISSION_DENIED;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800155 }
156
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -0800157 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));
Mikhail Naganovde3fa182021-07-30 15:06:42 -0700162 request.config = VALUE_OR_RETURN_STATUS(
163 legacy2aidl_audio_config_t_AudioConfig(*config, true /*isInput*/));
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -0800164 request.device = VALUE_OR_RETURN_STATUS(legacy2aidl_AudioDeviceTypeAddress(deviceTypeAddr));
Mikhail Naganovddceecc2021-09-03 13:58:56 -0700165 request.source = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_source_t_AudioSource(source));
Andy Hung973638a2020-12-08 20:47:45 -0800166 request.flags = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_input_flags_t_int32_t_mask(flags));
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -0800167
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));
Dean Wheatley6c009512023-10-23 09:34:14 +1100172 *config = VALUE_OR_RETURN_STATUS(
173 aidl2legacy_AudioConfig_audio_config_t(response.config, true /*isInput*/));
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -0800174 }
175 return status;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800176}
177
Eric Laurentdce54a12014-03-10 12:19:46 -0700178status_t AudioPolicyService::AudioPolicyClient::closeInput(audio_io_handle_t input)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800179{
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
Eric Laurentdce54a12014-03-10 12:19:46 -0700188status_t AudioPolicyService::AudioPolicyClient::setStreamVolume(audio_stream_type_t stream,
189 float volume, audio_io_handle_t output,
190 int delay_ms)
191{
192 return mAudioPolicyService->setStreamVolume(stream, volume, output,
193 delay_ms);
194}
195
Eric Laurentdce54a12014-03-10 12:19:46 -0700196void AudioPolicyService::AudioPolicyClient::setParameters(audio_io_handle_t io_handle,
197 const String8& keyValuePairs,
198 int delay_ms)
199{
Tomasz Wasilczyk8f36f6e2023-08-15 20:59:35 +0000200 mAudioPolicyService->setParameters(io_handle, keyValuePairs.c_str(), delay_ms);
Eric Laurentdce54a12014-03-10 12:19:46 -0700201}
202
203String8 AudioPolicyService::AudioPolicyClient::getParameters(audio_io_handle_t io_handle,
204 const String8& keys)
205{
206 String8 result = AudioSystem::getParameters(io_handle, keys);
207 return result;
208}
209
Eric Laurentdce54a12014-03-10 12:19:46 -0700210status_t AudioPolicyService::AudioPolicyClient::setVoiceVolume(float volume, int delay_ms)
211{
212 return mAudioPolicyService->setVoiceVolume(volume, delay_ms);
213}
214
Glenn Kastend848eb42016-03-08 13:42:11 -0800215status_t AudioPolicyService::AudioPolicyClient::moveEffects(audio_session_t session,
Eric Laurentdce54a12014-03-10 12:19:46 -0700216 audio_io_handle_t src_output,
217 audio_io_handle_t dst_output)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800218{
219 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
220 if (af == 0) {
221 return PERMISSION_DENIED;
222 }
223
224 return af->moveEffects(session, src_output, dst_output);
225}
226
Eric Laurentb20cf7d2019-04-05 19:37:34 -0700227void AudioPolicyService::AudioPolicyClient::setEffectSuspended(int effectId,
228 audio_session_t sessionId,
229 bool suspended)
230{
231 mAudioPolicyService->setEffectSuspended(effectId, sessionId, suspended);
232}
233
Eric Laurent951f4552014-05-20 10:48:17 -0700234status_t AudioPolicyService::AudioPolicyClient::createAudioPatch(const struct audio_patch *patch,
235 audio_patch_handle_t *handle,
236 int delayMs)
237{
238 return mAudioPolicyService->clientCreateAudioPatch(patch, handle, delayMs);
239}
Eric Laurent2d388ec2014-03-07 13:25:54 -0800240
Eric Laurent951f4552014-05-20 10:48:17 -0700241status_t AudioPolicyService::AudioPolicyClient::releaseAudioPatch(audio_patch_handle_t handle,
242 int delayMs)
243{
244 return mAudioPolicyService->clientReleaseAudioPatch(handle, delayMs);
245}
Eric Laurent2d388ec2014-03-07 13:25:54 -0800246
Eric Laurente1715a42014-05-20 11:30:42 -0700247status_t AudioPolicyService::AudioPolicyClient::setAudioPortConfig(
248 const struct audio_port_config *config,
249 int delayMs)
250{
251 return mAudioPolicyService->clientSetAudioPortConfig(config, delayMs);
252}
253
Eric Laurentb52c1522014-05-20 11:27:36 -0700254void AudioPolicyService::AudioPolicyClient::onAudioPortListUpdate()
255{
256 mAudioPolicyService->onAudioPortListUpdate();
257}
258
259void AudioPolicyService::AudioPolicyClient::onAudioPatchListUpdate()
260{
261 mAudioPolicyService->onAudioPatchListUpdate();
262}
263
Jean-Michel Trivide801052015-04-14 19:10:14 -0700264void AudioPolicyService::AudioPolicyClient::onDynamicPolicyMixStateUpdate(
265 String8 regId, int32_t state)
266{
267 mAudioPolicyService->onDynamicPolicyMixStateUpdate(regId, state);
268}
269
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800270void AudioPolicyService::AudioPolicyClient::onRecordingConfigurationUpdate(
Eric Laurenta9f86652018-11-28 17:23:11 -0800271 int event,
272 const record_client_info_t *clientInfo,
273 const audio_config_base_t *clientConfig,
274 std::vector<effect_descriptor_t> clientEffects,
275 const audio_config_base_t *deviceConfig,
276 std::vector<effect_descriptor_t> effects,
277 audio_patch_handle_t patchHandle,
278 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800279{
Jean-Michel Triviac4e4292016-12-22 11:39:31 -0800280 mAudioPolicyService->onRecordingConfigurationUpdate(event, clientInfo,
Eric Laurenta9f86652018-11-28 17:23:11 -0800281 clientConfig, clientEffects, deviceConfig, effects, patchHandle, source);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800282}
283
François Gaffiecfe17322018-11-07 13:41:29 +0100284void AudioPolicyService::AudioPolicyClient::onAudioVolumeGroupChanged(volume_group_t group,
285 int flags)
286{
287 mAudioPolicyService->onAudioVolumeGroupChanged(group, flags);
288}
289
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -0700290void AudioPolicyService::AudioPolicyClient::onRoutingUpdated()
291{
292 mAudioPolicyService->onRoutingUpdated();
293}
294
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +0000295void AudioPolicyService::AudioPolicyClient::onVolumeRangeInitRequest()
296{
297 mAudioPolicyService->onVolumeRangeInitRequest();
298}
299
Glenn Kasteneeecb982016-02-26 10:44:04 -0800300audio_unique_id_t AudioPolicyService::AudioPolicyClient::newAudioUniqueId(audio_unique_id_use_t use)
Eric Laurentde3f8392014-07-27 18:38:22 -0700301{
Glenn Kasteneeecb982016-02-26 10:44:04 -0800302 return AudioSystem::newAudioUniqueId(use);
Eric Laurentde3f8392014-07-27 18:38:22 -0700303}
304
Ytai Ben-Tsvi1ef846b2020-03-26 09:41:15 -0700305void AudioPolicyService::AudioPolicyClient::setSoundTriggerCaptureState(bool active)
306{
307 mAudioPolicyService->mCaptureStateNotifier.setCaptureState(active);
Ytai Ben-Tsvi74cd6b02019-10-25 10:06:40 -0700308}
309
jiabinb4fed192020-09-22 14:45:40 -0700310status_t AudioPolicyService::AudioPolicyClient::getAudioPort(struct audio_port_v7 *port)
311{
312 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
313 if (af == 0) {
314 ALOGW("%s: could not get AudioFlinger", __func__);
315 return PERMISSION_DENIED;
316 }
317 return af->getAudioPort(port);
318}
319
jiabinf042b9b2021-05-07 23:46:28 +0000320status_t AudioPolicyService::AudioPolicyClient::updateSecondaryOutputs(
321 const TrackSecondaryOutputsMap& trackSecondaryOutputs) {
322 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
323 if (af == nullptr) {
324 ALOGW("%s: could not get AudioFlinger", __func__);
325 return PERMISSION_DENIED;
326 }
327 return af->updateSecondaryOutputs(trackSecondaryOutputs);
328}
329
Mikhail Naganov516d3982022-02-01 23:53:59 +0000330status_t AudioPolicyService::AudioPolicyClient::setDeviceConnectedState(
jiabin872de702023-04-27 22:04:31 +0000331 const struct audio_port_v7 *port, media::DeviceConnectedState state) {
Mikhail Naganov516d3982022-02-01 23:53:59 +0000332 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
333 if (af == nullptr) {
334 ALOGW("%s: could not get AudioFlinger", __func__);
335 return PERMISSION_DENIED;
336 }
jiabin872de702023-04-27 22:04:31 +0000337 return af->setDeviceConnectedState(port, state);
Mikhail Naganov516d3982022-02-01 23:53:59 +0000338}
339
jiabinc44b3462022-12-08 12:52:31 -0800340status_t AudioPolicyService::AudioPolicyClient::invalidateTracks(
341 const std::vector<audio_port_handle_t>& portIds) {
342 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
343 if (af == 0) {
344 return PERMISSION_DENIED;
345 }
346
347 return af->invalidateTracks(portIds);
348}
349
jiabin12537fc2023-10-12 17:56:08 +0000350status_t AudioPolicyService::AudioPolicyClient::getAudioMixPort(
351 const struct audio_port_v7 *devicePort,
352 struct audio_port_v7 *port) {
353 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
354 if (af == 0) {
355 return PERMISSION_DENIED;
356 }
357 return af->getAudioMixPort(devicePort, port);
358}
359
jiabin220eea12024-05-17 17:55:20 +0000360status_t AudioPolicyService::AudioPolicyClient::setTracksInternalMute(
361 const std::vector<media::TrackInternalMuteInfo>& tracksInternalMute) {
362 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
363 if (af == nullptr) {
364 return PERMISSION_DENIED;
365 }
366 return af->setTracksInternalMute(tracksInternalMute);
367}
368
Mikhail Naganov1b2a7942017-12-08 10:18:09 -0800369} // namespace android