blob: c766a15a4367c20388516613b36913e8c29994d5 [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
Eric Laurentdce54a12014-03-10 12:19:46 -070030audio_module_handle_t AudioPolicyService::AudioPolicyClient::loadHwModule(const char *name)
Eric Laurent2d388ec2014-03-07 13:25:54 -080031{
32 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
33 if (af == 0) {
34 ALOGW("%s: could not get AudioFlinger", __func__);
Glenn Kastena13cde92016-03-28 15:26:02 -070035 return AUDIO_MODULE_HANDLE_NONE;
Eric Laurent2d388ec2014-03-07 13:25:54 -080036 }
37
38 return af->loadHwModule(name);
39}
40
Eric Laurentcf2c0212014-07-25 16:20:43 -070041status_t AudioPolicyService::AudioPolicyClient::openOutput(audio_module_handle_t module,
42 audio_io_handle_t *output,
Eric Laurentf1f22e72021-07-13 14:04:14 +020043 audio_config_t *halConfig,
44 audio_config_base_t *mixerConfig,
jiabin43810402019-10-24 14:58:31 -070045 const sp<DeviceDescriptorBase>& device,
Eric Laurentcf2c0212014-07-25 16:20:43 -070046 uint32_t *latencyMs,
47 audio_output_flags_t flags)
Eric Laurent2d388ec2014-03-07 13:25:54 -080048{
49 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
50 if (af == 0) {
51 ALOGW("%s: could not get AudioFlinger", __func__);
Eric Laurentcf2c0212014-07-25 16:20:43 -070052 return PERMISSION_DENIED;
Eric Laurent2d388ec2014-03-07 13:25:54 -080053 }
Ytai Ben-Tsvi50e016a2020-11-12 14:26:12 -080054
55 media::OpenOutputRequest request;
56 media::OpenOutputResponse response;
57
58 request.module = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_module_handle_t_int32_t(module));
Mikhail Naganovde3fa182021-07-30 15:06:42 -070059 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*/));
Ytai Ben-Tsvi50e016a2020-11-12 14:26:12 -080063 request.device = VALUE_OR_RETURN_STATUS(legacy2aidl_DeviceDescriptorBase(device));
Andy Hung973638a2020-12-08 20:47:45 -080064 request.flags = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_output_flags_t_int32_t_mask(flags));
Ytai Ben-Tsvi50e016a2020-11-12 14:26:12 -080065
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));
Mikhail Naganovde3fa182021-07-30 15:06:42 -070069 *halConfig = VALUE_OR_RETURN_STATUS(
70 aidl2legacy_AudioConfig_audio_config_t(response.config, false /*isInput*/));
Ytai Ben-Tsvi50e016a2020-11-12 14:26:12 -080071 *latencyMs = VALUE_OR_RETURN_STATUS(convertIntegral<uint32_t>(response.latencyMs));
72 }
73 return status;
Eric Laurent2d388ec2014-03-07 13:25:54 -080074}
75
Eric Laurentdce54a12014-03-10 12:19:46 -070076audio_io_handle_t AudioPolicyService::AudioPolicyClient::openDuplicateOutput(
77 audio_io_handle_t output1,
78 audio_io_handle_t output2)
Eric Laurent2d388ec2014-03-07 13:25:54 -080079{
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
Eric Laurentdce54a12014-03-10 12:19:46 -070088status_t AudioPolicyService::AudioPolicyClient::closeOutput(audio_io_handle_t output)
Eric Laurent2d388ec2014-03-07 13:25:54 -080089{
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
Eric Laurentdce54a12014-03-10 12:19:46 -070098status_t AudioPolicyService::AudioPolicyClient::suspendOutput(audio_io_handle_t output)
Eric Laurent2d388ec2014-03-07 13:25:54 -080099{
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
Eric Laurentdce54a12014-03-10 12:19:46 -0700109status_t AudioPolicyService::AudioPolicyClient::restoreOutput(audio_io_handle_t output)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800110{
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
Eric Laurentcf2c0212014-07-25 16:20:43 -0700120status_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)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800127{
128 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
129 if (af == 0) {
130 ALOGW("%s: could not get AudioFlinger", __func__);
Eric Laurentcf2c0212014-07-25 16:20:43 -0700131 return PERMISSION_DENIED;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800132 }
133
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -0800134 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));
Mikhail Naganovde3fa182021-07-30 15:06:42 -0700139 request.config = VALUE_OR_RETURN_STATUS(
140 legacy2aidl_audio_config_t_AudioConfig(*config, true /*isInput*/));
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -0800141 request.device = VALUE_OR_RETURN_STATUS(legacy2aidl_AudioDeviceTypeAddress(deviceTypeAddr));
Mikhail Naganovddceecc2021-09-03 13:58:56 -0700142 request.source = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_source_t_AudioSource(source));
Andy Hung973638a2020-12-08 20:47:45 -0800143 request.flags = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_input_flags_t_int32_t_mask(flags));
Ytai Ben-Tsvi12a0b842020-11-05 13:47:32 -0800144
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;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800151}
152
Eric Laurentdce54a12014-03-10 12:19:46 -0700153status_t AudioPolicyService::AudioPolicyClient::closeInput(audio_io_handle_t input)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800154{
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
Eric Laurentdce54a12014-03-10 12:19:46 -0700163status_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
171status_t AudioPolicyService::AudioPolicyClient::invalidateStream(audio_stream_type_t stream)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800172{
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
Eric Laurentdce54a12014-03-10 12:19:46 -0700181void 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
188String8 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
Eric Laurentdce54a12014-03-10 12:19:46 -0700195status_t AudioPolicyService::AudioPolicyClient::setVoiceVolume(float volume, int delay_ms)
196{
197 return mAudioPolicyService->setVoiceVolume(volume, delay_ms);
198}
199
Glenn Kastend848eb42016-03-08 13:42:11 -0800200status_t AudioPolicyService::AudioPolicyClient::moveEffects(audio_session_t session,
Eric Laurentdce54a12014-03-10 12:19:46 -0700201 audio_io_handle_t src_output,
202 audio_io_handle_t dst_output)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800203{
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
Eric Laurentb20cf7d2019-04-05 19:37:34 -0700212void AudioPolicyService::AudioPolicyClient::setEffectSuspended(int effectId,
213 audio_session_t sessionId,
214 bool suspended)
215{
216 mAudioPolicyService->setEffectSuspended(effectId, sessionId, suspended);
217}
218
Eric Laurent951f4552014-05-20 10:48:17 -0700219status_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}
Eric Laurent2d388ec2014-03-07 13:25:54 -0800225
Eric Laurent951f4552014-05-20 10:48:17 -0700226status_t AudioPolicyService::AudioPolicyClient::releaseAudioPatch(audio_patch_handle_t handle,
227 int delayMs)
228{
229 return mAudioPolicyService->clientReleaseAudioPatch(handle, delayMs);
230}
Eric Laurent2d388ec2014-03-07 13:25:54 -0800231
Eric Laurente1715a42014-05-20 11:30:42 -0700232status_t AudioPolicyService::AudioPolicyClient::setAudioPortConfig(
233 const struct audio_port_config *config,
234 int delayMs)
235{
236 return mAudioPolicyService->clientSetAudioPortConfig(config, delayMs);
237}
238
Eric Laurentb52c1522014-05-20 11:27:36 -0700239void AudioPolicyService::AudioPolicyClient::onAudioPortListUpdate()
240{
241 mAudioPolicyService->onAudioPortListUpdate();
242}
243
244void AudioPolicyService::AudioPolicyClient::onAudioPatchListUpdate()
245{
246 mAudioPolicyService->onAudioPatchListUpdate();
247}
248
Jean-Michel Trivide801052015-04-14 19:10:14 -0700249void AudioPolicyService::AudioPolicyClient::onDynamicPolicyMixStateUpdate(
250 String8 regId, int32_t state)
251{
252 mAudioPolicyService->onDynamicPolicyMixStateUpdate(regId, state);
253}
254
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800255void AudioPolicyService::AudioPolicyClient::onRecordingConfigurationUpdate(
Eric Laurenta9f86652018-11-28 17:23:11 -0800256 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)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800264{
Jean-Michel Triviac4e4292016-12-22 11:39:31 -0800265 mAudioPolicyService->onRecordingConfigurationUpdate(event, clientInfo,
Eric Laurenta9f86652018-11-28 17:23:11 -0800266 clientConfig, clientEffects, deviceConfig, effects, patchHandle, source);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800267}
268
François Gaffiecfe17322018-11-07 13:41:29 +0100269void AudioPolicyService::AudioPolicyClient::onAudioVolumeGroupChanged(volume_group_t group,
270 int flags)
271{
272 mAudioPolicyService->onAudioVolumeGroupChanged(group, flags);
273}
274
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -0700275void AudioPolicyService::AudioPolicyClient::onRoutingUpdated()
276{
277 mAudioPolicyService->onRoutingUpdated();
278}
279
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +0000280void AudioPolicyService::AudioPolicyClient::onVolumeRangeInitRequest()
281{
282 mAudioPolicyService->onVolumeRangeInitRequest();
283}
284
Glenn Kasteneeecb982016-02-26 10:44:04 -0800285audio_unique_id_t AudioPolicyService::AudioPolicyClient::newAudioUniqueId(audio_unique_id_use_t use)
Eric Laurentde3f8392014-07-27 18:38:22 -0700286{
Glenn Kasteneeecb982016-02-26 10:44:04 -0800287 return AudioSystem::newAudioUniqueId(use);
Eric Laurentde3f8392014-07-27 18:38:22 -0700288}
289
Ytai Ben-Tsvi1ef846b2020-03-26 09:41:15 -0700290void AudioPolicyService::AudioPolicyClient::setSoundTriggerCaptureState(bool active)
291{
292 mAudioPolicyService->mCaptureStateNotifier.setCaptureState(active);
Ytai Ben-Tsvi74cd6b02019-10-25 10:06:40 -0700293}
294
jiabinb4fed192020-09-22 14:45:40 -0700295status_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
jiabinf042b9b2021-05-07 23:46:28 +0000305status_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
Mikhail Naganov516d3982022-02-01 23:53:59 +0000315status_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
Mikhail Naganov1b2a7942017-12-08 10:18:09 -0800326} // namespace android