1 /*
2 **
3 ** Copyright 2007, The Android Open Source Project
4 **
5 ** Licensed under the Apache License, Version 2.0 (the "License");
6 ** you may not use this file except in compliance with the License.
7 ** You may obtain a copy of the License at
8 **
9 ** http://www.apache.org/licenses/LICENSE-2.0
10 **
11 ** Unless required by applicable law or agreed to in writing, software
12 ** distributed under the License is distributed on an "AS IS" BASIS,
13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 ** See the License for the specific language governing permissions and
15 ** limitations under the License.
16 */
17
18 #define LOG_TAG "IAudioFlinger"
19 //#define LOG_NDEBUG 0
20
21 #include <utils/Log.h>
22
23 #include <stdint.h>
24 #include <sys/types.h>
25 #include "IAudioFlinger.h"
26 #include <binder/IPCThreadState.h>
27 #include <binder/Parcel.h>
28 #include <system/thread_defs.h>
29
30 namespace android {
31
32 using aidl_utils::statusTFromBinderStatus;
33 using binder::Status;
34 using media::audio::common::AudioChannelLayout;
35 using media::audio::common::AudioFormatDescription;
36 using media::audio::common::AudioMMapPolicyInfo;
37 using media::audio::common::AudioMMapPolicyType;
38 using media::audio::common::AudioMode;
39 using media::audio::common::AudioStreamType;
40 using media::audio::common::AudioUuid;
41
42 #define MAX_ITEMS_PER_LIST 1024
43
44 #define VALUE_OR_RETURN_BINDER(x) \
45 ({ \
46 auto _tmp = (x); \
47 if (!_tmp.ok()) return Status::fromStatusT(_tmp.error()); \
48 std::move(_tmp.value()); \
49 })
50
51 #define RETURN_BINDER_IF_ERROR(x) \
52 { \
53 auto _tmp = (x); \
54 if (_tmp != OK) return Status::fromStatusT(_tmp); \
55 }
56
toAidl() const57 ConversionResult<media::CreateTrackRequest> IAudioFlinger::CreateTrackInput::toAidl() const {
58 media::CreateTrackRequest aidl;
59 aidl.attr = VALUE_OR_RETURN(legacy2aidl_audio_attributes_t_AudioAttributes(attr));
60 // Do not be mislead by 'Input'--this is an input to 'createTrack', which creates output tracks.
61 aidl.config = VALUE_OR_RETURN(legacy2aidl_audio_config_t_AudioConfig(
62 config, false /*isInput*/));
63 aidl.clientInfo = VALUE_OR_RETURN(legacy2aidl_AudioClient_AudioClient(clientInfo));
64 aidl.sharedBuffer = VALUE_OR_RETURN(legacy2aidl_NullableIMemory_SharedFileRegion(sharedBuffer));
65 aidl.notificationsPerBuffer = VALUE_OR_RETURN(convertIntegral<int32_t>(notificationsPerBuffer));
66 aidl.speed = speed;
67 aidl.audioTrackCallback = audioTrackCallback;
68 aidl.flags = VALUE_OR_RETURN(legacy2aidl_audio_output_flags_t_int32_t_mask(flags));
69 aidl.frameCount = VALUE_OR_RETURN(convertIntegral<int64_t>(frameCount));
70 aidl.notificationFrameCount = VALUE_OR_RETURN(convertIntegral<int64_t>(notificationFrameCount));
71 aidl.selectedDeviceId = VALUE_OR_RETURN(
72 legacy2aidl_audio_port_handle_t_int32_t(selectedDeviceId));
73 aidl.sessionId = VALUE_OR_RETURN(legacy2aidl_audio_session_t_int32_t(sessionId));
74 return aidl;
75 }
76
77 ConversionResult<IAudioFlinger::CreateTrackInput>
fromAidl(const media::CreateTrackRequest & aidl)78 IAudioFlinger::CreateTrackInput::fromAidl(const media::CreateTrackRequest& aidl) {
79 IAudioFlinger::CreateTrackInput legacy;
80 legacy.attr = VALUE_OR_RETURN(aidl2legacy_AudioAttributes_audio_attributes_t(aidl.attr));
81 // Do not be mislead by 'Input'--this is an input to 'createTrack', which creates output tracks.
82 legacy.config = VALUE_OR_RETURN(
83 aidl2legacy_AudioConfig_audio_config_t(aidl.config, false /*isInput*/));
84 legacy.clientInfo = VALUE_OR_RETURN(aidl2legacy_AudioClient_AudioClient(aidl.clientInfo));
85 legacy.sharedBuffer = VALUE_OR_RETURN(aidl2legacy_NullableSharedFileRegion_IMemory(aidl.sharedBuffer));
86 legacy.notificationsPerBuffer = VALUE_OR_RETURN(
87 convertIntegral<uint32_t>(aidl.notificationsPerBuffer));
88 legacy.speed = aidl.speed;
89 legacy.audioTrackCallback = aidl.audioTrackCallback;
90 legacy.flags = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_output_flags_t_mask(aidl.flags));
91 legacy.frameCount = VALUE_OR_RETURN(convertIntegral<size_t>(aidl.frameCount));
92 legacy.notificationFrameCount = VALUE_OR_RETURN(
93 convertIntegral<size_t>(aidl.notificationFrameCount));
94 legacy.selectedDeviceId = VALUE_OR_RETURN(
95 aidl2legacy_int32_t_audio_port_handle_t(aidl.selectedDeviceId));
96 legacy.sessionId = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_session_t(aidl.sessionId));
97 return legacy;
98 }
99
100 ConversionResult<media::CreateTrackResponse>
toAidl() const101 IAudioFlinger::CreateTrackOutput::toAidl() const {
102 media::CreateTrackResponse aidl;
103 aidl.flags = VALUE_OR_RETURN(legacy2aidl_audio_output_flags_t_int32_t_mask(flags));
104 aidl.frameCount = VALUE_OR_RETURN(convertIntegral<int64_t>(frameCount));
105 aidl.notificationFrameCount = VALUE_OR_RETURN(convertIntegral<int64_t>(notificationFrameCount));
106 aidl.selectedDeviceId = VALUE_OR_RETURN(
107 legacy2aidl_audio_port_handle_t_int32_t(selectedDeviceId));
108 aidl.sessionId = VALUE_OR_RETURN(legacy2aidl_audio_session_t_int32_t(sessionId));
109 aidl.sampleRate = VALUE_OR_RETURN(convertIntegral<int32_t>(sampleRate));
110 aidl.streamType = VALUE_OR_RETURN(
111 legacy2aidl_audio_stream_type_t_AudioStreamType(streamType));
112 aidl.afFrameCount = VALUE_OR_RETURN(convertIntegral<int64_t>(afFrameCount));
113 aidl.afSampleRate = VALUE_OR_RETURN(convertIntegral<int32_t>(afSampleRate));
114 aidl.afLatencyMs = VALUE_OR_RETURN(convertIntegral<int32_t>(afLatencyMs));
115 aidl.afChannelMask = VALUE_OR_RETURN(
116 legacy2aidl_audio_channel_mask_t_AudioChannelLayout(afChannelMask, false /*isInput*/));
117 aidl.afFormat = VALUE_OR_RETURN(
118 legacy2aidl_audio_format_t_AudioFormatDescription(afFormat));
119 aidl.outputId = VALUE_OR_RETURN(legacy2aidl_audio_io_handle_t_int32_t(outputId));
120 aidl.portId = VALUE_OR_RETURN(legacy2aidl_audio_port_handle_t_int32_t(portId));
121 aidl.audioTrack = audioTrack;
122 return aidl;
123 }
124
125 ConversionResult<IAudioFlinger::CreateTrackOutput>
fromAidl(const media::CreateTrackResponse & aidl)126 IAudioFlinger::CreateTrackOutput::fromAidl(
127 const media::CreateTrackResponse& aidl) {
128 IAudioFlinger::CreateTrackOutput legacy;
129 legacy.flags = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_output_flags_t_mask(aidl.flags));
130 legacy.frameCount = VALUE_OR_RETURN(convertIntegral<size_t>(aidl.frameCount));
131 legacy.notificationFrameCount = VALUE_OR_RETURN(
132 convertIntegral<size_t>(aidl.notificationFrameCount));
133 legacy.selectedDeviceId = VALUE_OR_RETURN(
134 aidl2legacy_int32_t_audio_port_handle_t(aidl.selectedDeviceId));
135 legacy.sessionId = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_session_t(aidl.sessionId));
136 legacy.sampleRate = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.sampleRate));
137 legacy.streamType = VALUE_OR_RETURN(
138 aidl2legacy_AudioStreamType_audio_stream_type_t(aidl.streamType));
139 legacy.afFrameCount = VALUE_OR_RETURN(convertIntegral<size_t>(aidl.afFrameCount));
140 legacy.afSampleRate = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.afSampleRate));
141 legacy.afLatencyMs = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.afLatencyMs));
142 legacy.afChannelMask = VALUE_OR_RETURN(
143 aidl2legacy_AudioChannelLayout_audio_channel_mask_t(aidl.afChannelMask,
144 false /*isInput*/));
145 legacy.afFormat = VALUE_OR_RETURN(
146 aidl2legacy_AudioFormatDescription_audio_format_t(aidl.afFormat));
147 legacy.outputId = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_io_handle_t(aidl.outputId));
148 legacy.portId = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_port_handle_t(aidl.portId));
149 legacy.audioTrack = aidl.audioTrack;
150 return legacy;
151 }
152
153 ConversionResult<media::CreateRecordRequest>
toAidl() const154 IAudioFlinger::CreateRecordInput::toAidl() const {
155 media::CreateRecordRequest aidl;
156 aidl.attr = VALUE_OR_RETURN(legacy2aidl_audio_attributes_t_AudioAttributes(attr));
157 aidl.config = VALUE_OR_RETURN(
158 legacy2aidl_audio_config_base_t_AudioConfigBase(config, true /*isInput*/));
159 aidl.clientInfo = VALUE_OR_RETURN(legacy2aidl_AudioClient_AudioClient(clientInfo));
160 aidl.riid = VALUE_OR_RETURN(legacy2aidl_audio_unique_id_t_int32_t(riid));
161 aidl.maxSharedAudioHistoryMs = VALUE_OR_RETURN(
162 convertIntegral<int32_t>(maxSharedAudioHistoryMs));
163 aidl.flags = VALUE_OR_RETURN(legacy2aidl_audio_input_flags_t_int32_t_mask(flags));
164 aidl.frameCount = VALUE_OR_RETURN(convertIntegral<int64_t>(frameCount));
165 aidl.notificationFrameCount = VALUE_OR_RETURN(convertIntegral<int64_t>(notificationFrameCount));
166 aidl.selectedDeviceId = VALUE_OR_RETURN(
167 legacy2aidl_audio_port_handle_t_int32_t(selectedDeviceId));
168 aidl.sessionId = VALUE_OR_RETURN(legacy2aidl_audio_session_t_int32_t(sessionId));
169 return aidl;
170 }
171
172 ConversionResult<IAudioFlinger::CreateRecordInput>
fromAidl(const media::CreateRecordRequest & aidl)173 IAudioFlinger::CreateRecordInput::fromAidl(
174 const media::CreateRecordRequest& aidl) {
175 IAudioFlinger::CreateRecordInput legacy;
176 legacy.attr = VALUE_OR_RETURN(
177 aidl2legacy_AudioAttributes_audio_attributes_t(aidl.attr));
178 legacy.config = VALUE_OR_RETURN(
179 aidl2legacy_AudioConfigBase_audio_config_base_t(aidl.config, true /*isInput*/));
180 legacy.clientInfo = VALUE_OR_RETURN(aidl2legacy_AudioClient_AudioClient(aidl.clientInfo));
181 legacy.riid = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_unique_id_t(aidl.riid));
182 legacy.maxSharedAudioHistoryMs = VALUE_OR_RETURN(
183 convertIntegral<int32_t>(aidl.maxSharedAudioHistoryMs));
184 legacy.flags = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_input_flags_t_mask(aidl.flags));
185 legacy.frameCount = VALUE_OR_RETURN(convertIntegral<size_t>(aidl.frameCount));
186 legacy.notificationFrameCount = VALUE_OR_RETURN(
187 convertIntegral<size_t>(aidl.notificationFrameCount));
188 legacy.selectedDeviceId = VALUE_OR_RETURN(
189 aidl2legacy_int32_t_audio_port_handle_t(aidl.selectedDeviceId));
190 legacy.sessionId = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_session_t(aidl.sessionId));
191 return legacy;
192 }
193
194 ConversionResult<media::CreateRecordResponse>
toAidl() const195 IAudioFlinger::CreateRecordOutput::toAidl() const {
196 media::CreateRecordResponse aidl;
197 aidl.flags = VALUE_OR_RETURN(legacy2aidl_audio_input_flags_t_int32_t_mask(flags));
198 aidl.frameCount = VALUE_OR_RETURN(convertIntegral<int64_t>(frameCount));
199 aidl.notificationFrameCount = VALUE_OR_RETURN(convertIntegral<int64_t>(notificationFrameCount));
200 aidl.selectedDeviceId = VALUE_OR_RETURN(
201 legacy2aidl_audio_port_handle_t_int32_t(selectedDeviceId));
202 aidl.sessionId = VALUE_OR_RETURN(legacy2aidl_audio_session_t_int32_t(sessionId));
203 aidl.sampleRate = VALUE_OR_RETURN(convertIntegral<int32_t>(sampleRate));
204 aidl.inputId = VALUE_OR_RETURN(legacy2aidl_audio_io_handle_t_int32_t(inputId));
205 aidl.cblk = VALUE_OR_RETURN(legacy2aidl_NullableIMemory_SharedFileRegion(cblk));
206 aidl.buffers = VALUE_OR_RETURN(legacy2aidl_NullableIMemory_SharedFileRegion(buffers));
207 aidl.portId = VALUE_OR_RETURN(legacy2aidl_audio_port_handle_t_int32_t(portId));
208 aidl.audioRecord = audioRecord;
209 aidl.serverConfig = VALUE_OR_RETURN(
210 legacy2aidl_audio_config_base_t_AudioConfigBase(serverConfig, true /*isInput*/));
211 aidl.halConfig = VALUE_OR_RETURN(
212 legacy2aidl_audio_config_base_t_AudioConfigBase(halConfig, true /*isInput*/));
213 return aidl;
214 }
215
216 ConversionResult<IAudioFlinger::CreateRecordOutput>
fromAidl(const media::CreateRecordResponse & aidl)217 IAudioFlinger::CreateRecordOutput::fromAidl(
218 const media::CreateRecordResponse& aidl) {
219 IAudioFlinger::CreateRecordOutput legacy;
220 legacy.flags = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_input_flags_t_mask(aidl.flags));
221 legacy.frameCount = VALUE_OR_RETURN(convertIntegral<size_t>(aidl.frameCount));
222 legacy.notificationFrameCount = VALUE_OR_RETURN(
223 convertIntegral<size_t>(aidl.notificationFrameCount));
224 legacy.selectedDeviceId = VALUE_OR_RETURN(
225 aidl2legacy_int32_t_audio_port_handle_t(aidl.selectedDeviceId));
226 legacy.sessionId = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_session_t(aidl.sessionId));
227 legacy.sampleRate = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.sampleRate));
228 legacy.inputId = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_io_handle_t(aidl.inputId));
229 legacy.cblk = VALUE_OR_RETURN(aidl2legacy_NullableSharedFileRegion_IMemory(aidl.cblk));
230 legacy.buffers = VALUE_OR_RETURN(aidl2legacy_NullableSharedFileRegion_IMemory(aidl.buffers));
231 legacy.portId = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_port_handle_t(aidl.portId));
232 legacy.audioRecord = aidl.audioRecord;
233 legacy.serverConfig = VALUE_OR_RETURN(
234 aidl2legacy_AudioConfigBase_audio_config_base_t(aidl.serverConfig, true /*isInput*/));
235 legacy.halConfig = VALUE_OR_RETURN(
236 aidl2legacy_AudioConfigBase_audio_config_base_t(aidl.halConfig, true /*isInput*/));
237 return legacy;
238 }
239
240 ////////////////////////////////////////////////////////////////////////////////////////////////////
241 // AudioFlingerClientAdapter
242
AudioFlingerClientAdapter(const sp<media::IAudioFlingerService> delegate)243 AudioFlingerClientAdapter::AudioFlingerClientAdapter(
244 const sp<media::IAudioFlingerService> delegate) : mDelegate(delegate) {}
245
createTrack(const media::CreateTrackRequest & input,media::CreateTrackResponse & output)246 status_t AudioFlingerClientAdapter::createTrack(const media::CreateTrackRequest& input,
247 media::CreateTrackResponse& output) {
248 return statusTFromBinderStatus(mDelegate->createTrack(input, &output));
249 }
250
createRecord(const media::CreateRecordRequest & input,media::CreateRecordResponse & output)251 status_t AudioFlingerClientAdapter::createRecord(const media::CreateRecordRequest& input,
252 media::CreateRecordResponse& output) {
253 return statusTFromBinderStatus(mDelegate->createRecord(input, &output));
254 }
255
sampleRate(audio_io_handle_t ioHandle) const256 uint32_t AudioFlingerClientAdapter::sampleRate(audio_io_handle_t ioHandle) const {
257 auto result = [&]() -> ConversionResult<uint32_t> {
258 int32_t ioHandleAidl = VALUE_OR_RETURN(legacy2aidl_audio_io_handle_t_int32_t(ioHandle));
259 int32_t aidlRet;
260 RETURN_IF_ERROR(statusTFromBinderStatus(mDelegate->sampleRate(ioHandleAidl, &aidlRet)));
261 return convertIntegral<uint32_t>(aidlRet);
262 }();
263 // Failure is ignored.
264 return result.value_or(0);
265 }
266
format(audio_io_handle_t output) const267 audio_format_t AudioFlingerClientAdapter::format(audio_io_handle_t output) const {
268 auto result = [&]() -> ConversionResult<audio_format_t> {
269 int32_t outputAidl = VALUE_OR_RETURN(legacy2aidl_audio_io_handle_t_int32_t(output));
270 AudioFormatDescription aidlRet;
271 RETURN_IF_ERROR(statusTFromBinderStatus(mDelegate->format(outputAidl, &aidlRet)));
272 return aidl2legacy_AudioFormatDescription_audio_format_t(aidlRet);
273 }();
274 return result.value_or(AUDIO_FORMAT_INVALID);
275 }
276
frameCount(audio_io_handle_t ioHandle) const277 size_t AudioFlingerClientAdapter::frameCount(audio_io_handle_t ioHandle) const {
278 auto result = [&]() -> ConversionResult<size_t> {
279 int32_t ioHandleAidl = VALUE_OR_RETURN(legacy2aidl_audio_io_handle_t_int32_t(ioHandle));
280 int64_t aidlRet;
281 RETURN_IF_ERROR(statusTFromBinderStatus(mDelegate->frameCount(ioHandleAidl, &aidlRet)));
282 return convertIntegral<size_t>(aidlRet);
283 }();
284 // Failure is ignored.
285 return result.value_or(0);
286 }
287
latency(audio_io_handle_t output) const288 uint32_t AudioFlingerClientAdapter::latency(audio_io_handle_t output) const {
289 auto result = [&]() -> ConversionResult<uint32_t> {
290 int32_t outputAidl = VALUE_OR_RETURN(legacy2aidl_audio_io_handle_t_int32_t(output));
291 int32_t aidlRet;
292 RETURN_IF_ERROR(statusTFromBinderStatus(mDelegate->latency(outputAidl, &aidlRet)));
293 return convertIntegral<uint32_t>(aidlRet);
294 }();
295 // Failure is ignored.
296 return result.value_or(0);
297 }
298
setMasterVolume(float value)299 status_t AudioFlingerClientAdapter::setMasterVolume(float value) {
300 return statusTFromBinderStatus(mDelegate->setMasterVolume(value));
301 }
302
setMasterMute(bool muted)303 status_t AudioFlingerClientAdapter::setMasterMute(bool muted) {
304 return statusTFromBinderStatus(mDelegate->setMasterMute(muted));
305 }
306
masterVolume() const307 float AudioFlingerClientAdapter::masterVolume() const {
308 auto result = [&]() -> ConversionResult<float> {
309 float aidlRet;
310 RETURN_IF_ERROR(statusTFromBinderStatus(mDelegate->masterVolume(&aidlRet)));
311 return aidlRet;
312 }();
313 // Failure is ignored.
314 return result.value_or(0.f);
315 }
316
masterMute() const317 bool AudioFlingerClientAdapter::masterMute() const {
318 auto result = [&]() -> ConversionResult<bool> {
319 bool aidlRet;
320 RETURN_IF_ERROR(statusTFromBinderStatus(mDelegate->masterMute(&aidlRet)));
321 return aidlRet;
322 }();
323 // Failure is ignored.
324 return result.value_or(false);
325 }
326
setMasterBalance(float balance)327 status_t AudioFlingerClientAdapter::setMasterBalance(float balance) {
328 return statusTFromBinderStatus(mDelegate->setMasterBalance(balance));
329 }
330
getMasterBalance(float * balance) const331 status_t AudioFlingerClientAdapter::getMasterBalance(float* balance) const{
332 return statusTFromBinderStatus(mDelegate->getMasterBalance(balance));
333 }
334
setStreamVolume(audio_stream_type_t stream,float value,audio_io_handle_t output)335 status_t AudioFlingerClientAdapter::setStreamVolume(audio_stream_type_t stream, float value,
336 audio_io_handle_t output) {
337 AudioStreamType streamAidl = VALUE_OR_RETURN_STATUS(
338 legacy2aidl_audio_stream_type_t_AudioStreamType(stream));
339 int32_t outputAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(output));
340 return statusTFromBinderStatus(mDelegate->setStreamVolume(streamAidl, value, outputAidl));
341 }
342
setStreamMute(audio_stream_type_t stream,bool muted)343 status_t AudioFlingerClientAdapter::setStreamMute(audio_stream_type_t stream, bool muted) {
344 AudioStreamType streamAidl = VALUE_OR_RETURN_STATUS(
345 legacy2aidl_audio_stream_type_t_AudioStreamType(stream));
346 return statusTFromBinderStatus(mDelegate->setStreamMute(streamAidl, muted));
347 }
348
streamVolume(audio_stream_type_t stream,audio_io_handle_t output) const349 float AudioFlingerClientAdapter::streamVolume(audio_stream_type_t stream,
350 audio_io_handle_t output) const {
351 auto result = [&]() -> ConversionResult<float> {
352 AudioStreamType streamAidl = VALUE_OR_RETURN_STATUS(
353 legacy2aidl_audio_stream_type_t_AudioStreamType(stream));
354 int32_t outputAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(output));
355 float aidlRet;
356 RETURN_IF_ERROR(statusTFromBinderStatus(
357 mDelegate->streamVolume(streamAidl, outputAidl, &aidlRet)));
358 return aidlRet;
359 }();
360 // Failure is ignored.
361 return result.value_or(0.f);
362 }
363
streamMute(audio_stream_type_t stream) const364 bool AudioFlingerClientAdapter::streamMute(audio_stream_type_t stream) const {
365 auto result = [&]() -> ConversionResult<bool> {
366 AudioStreamType streamAidl = VALUE_OR_RETURN_STATUS(
367 legacy2aidl_audio_stream_type_t_AudioStreamType(stream));
368 bool aidlRet;
369 RETURN_IF_ERROR(statusTFromBinderStatus(
370 mDelegate->streamMute(streamAidl, &aidlRet)));
371 return aidlRet;
372 }();
373 // Failure is ignored.
374 return result.value_or(false);
375 }
376
setMode(audio_mode_t mode)377 status_t AudioFlingerClientAdapter::setMode(audio_mode_t mode) {
378 AudioMode modeAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_mode_t_AudioMode(mode));
379 return statusTFromBinderStatus(mDelegate->setMode(modeAidl));
380 }
381
setMicMute(bool state)382 status_t AudioFlingerClientAdapter::setMicMute(bool state) {
383 return statusTFromBinderStatus(mDelegate->setMicMute(state));
384 }
385
getMicMute() const386 bool AudioFlingerClientAdapter::getMicMute() const {
387 auto result = [&]() -> ConversionResult<bool> {
388 bool aidlRet;
389 RETURN_IF_ERROR(statusTFromBinderStatus(
390 mDelegate->getMicMute(&aidlRet)));
391 return aidlRet;
392 }();
393 // Failure is ignored.
394 return result.value_or(false);
395 }
396
setRecordSilenced(audio_port_handle_t portId,bool silenced)397 void AudioFlingerClientAdapter::setRecordSilenced(audio_port_handle_t portId, bool silenced) {
398 auto result = [&]() -> status_t {
399 int32_t portIdAidl = VALUE_OR_RETURN_STATUS(
400 legacy2aidl_audio_port_handle_t_int32_t(portId));
401 return statusTFromBinderStatus(mDelegate->setRecordSilenced(portIdAidl, silenced));
402 }();
403 // Failure is ignored.
404 (void) result;
405 }
406
setParameters(audio_io_handle_t ioHandle,const String8 & keyValuePairs)407 status_t AudioFlingerClientAdapter::setParameters(audio_io_handle_t ioHandle,
408 const String8& keyValuePairs) {
409 int32_t ioHandleAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(ioHandle));
410 std::string keyValuePairsAidl = VALUE_OR_RETURN_STATUS(
411 legacy2aidl_String8_string(keyValuePairs));
412 return statusTFromBinderStatus(mDelegate->setParameters(ioHandleAidl, keyValuePairsAidl));
413 }
414
getParameters(audio_io_handle_t ioHandle,const String8 & keys) const415 String8 AudioFlingerClientAdapter::getParameters(audio_io_handle_t ioHandle, const String8& keys)
416 const {
417 auto result = [&]() -> ConversionResult<String8> {
418 int32_t ioHandleAidl = VALUE_OR_RETURN(legacy2aidl_audio_io_handle_t_int32_t(ioHandle));
419 std::string keysAidl = VALUE_OR_RETURN(legacy2aidl_String8_string(keys));
420 std::string aidlRet;
421 RETURN_IF_ERROR(statusTFromBinderStatus(
422 mDelegate->getParameters(ioHandleAidl, keysAidl, &aidlRet)));
423 return aidl2legacy_string_view_String8(aidlRet);
424 }();
425 // Failure is ignored.
426 return result.value_or(String8());
427 }
428
registerClient(const sp<media::IAudioFlingerClient> & client)429 void AudioFlingerClientAdapter::registerClient(const sp<media::IAudioFlingerClient>& client) {
430 mDelegate->registerClient(client);
431 // Failure is ignored.
432 }
433
getInputBufferSize(uint32_t sampleRate,audio_format_t format,audio_channel_mask_t channelMask) const434 size_t AudioFlingerClientAdapter::getInputBufferSize(uint32_t sampleRate, audio_format_t format,
435 audio_channel_mask_t channelMask) const {
436 auto result = [&]() -> ConversionResult<size_t> {
437 int32_t sampleRateAidl = VALUE_OR_RETURN(convertIntegral<int32_t>(sampleRate));
438 AudioFormatDescription formatAidl = VALUE_OR_RETURN(
439 legacy2aidl_audio_format_t_AudioFormatDescription(format));
440 AudioChannelLayout channelMaskAidl = VALUE_OR_RETURN(
441 legacy2aidl_audio_channel_mask_t_AudioChannelLayout(channelMask, true /*isInput*/));
442 int64_t aidlRet;
443 RETURN_IF_ERROR(statusTFromBinderStatus(
444 mDelegate->getInputBufferSize(sampleRateAidl, formatAidl, channelMaskAidl,
445 &aidlRet)));
446 return convertIntegral<size_t>(aidlRet);
447 }();
448 // Failure is ignored.
449 return result.value_or(0);
450 }
451
openOutput(const media::OpenOutputRequest & request,media::OpenOutputResponse * response)452 status_t AudioFlingerClientAdapter::openOutput(const media::OpenOutputRequest& request,
453 media::OpenOutputResponse* response) {
454 return statusTFromBinderStatus(mDelegate->openOutput(request, response));
455 }
456
openDuplicateOutput(audio_io_handle_t output1,audio_io_handle_t output2)457 audio_io_handle_t AudioFlingerClientAdapter::openDuplicateOutput(audio_io_handle_t output1,
458 audio_io_handle_t output2) {
459 auto result = [&]() -> ConversionResult<audio_io_handle_t> {
460 int32_t output1Aidl = VALUE_OR_RETURN(legacy2aidl_audio_io_handle_t_int32_t(output1));
461 int32_t output2Aidl = VALUE_OR_RETURN(legacy2aidl_audio_io_handle_t_int32_t(output2));
462 int32_t aidlRet;
463 RETURN_IF_ERROR(statusTFromBinderStatus(
464 mDelegate->openDuplicateOutput(output1Aidl, output2Aidl, &aidlRet)));
465 return aidl2legacy_int32_t_audio_io_handle_t(aidlRet);
466 }();
467 // Failure is ignored.
468 return result.value_or(0);
469 }
470
closeOutput(audio_io_handle_t output)471 status_t AudioFlingerClientAdapter::closeOutput(audio_io_handle_t output) {
472 int32_t outputAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(output));
473 return statusTFromBinderStatus(mDelegate->closeOutput(outputAidl));
474 }
475
suspendOutput(audio_io_handle_t output)476 status_t AudioFlingerClientAdapter::suspendOutput(audio_io_handle_t output) {
477 int32_t outputAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(output));
478 return statusTFromBinderStatus(mDelegate->suspendOutput(outputAidl));
479 }
480
restoreOutput(audio_io_handle_t output)481 status_t AudioFlingerClientAdapter::restoreOutput(audio_io_handle_t output) {
482 int32_t outputAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(output));
483 return statusTFromBinderStatus(mDelegate->restoreOutput(outputAidl));
484 }
485
openInput(const media::OpenInputRequest & request,media::OpenInputResponse * response)486 status_t AudioFlingerClientAdapter::openInput(const media::OpenInputRequest& request,
487 media::OpenInputResponse* response) {
488 return statusTFromBinderStatus(mDelegate->openInput(request, response));
489 }
490
closeInput(audio_io_handle_t input)491 status_t AudioFlingerClientAdapter::closeInput(audio_io_handle_t input) {
492 int32_t inputAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(input));
493 return statusTFromBinderStatus(mDelegate->closeInput(inputAidl));
494 }
495
setVoiceVolume(float volume)496 status_t AudioFlingerClientAdapter::setVoiceVolume(float volume) {
497 return statusTFromBinderStatus(mDelegate->setVoiceVolume(volume));
498 }
499
getRenderPosition(uint32_t * halFrames,uint32_t * dspFrames,audio_io_handle_t output) const500 status_t AudioFlingerClientAdapter::getRenderPosition(uint32_t* halFrames, uint32_t* dspFrames,
501 audio_io_handle_t output) const {
502 int32_t outputAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(output));
503 media::RenderPosition aidlRet;
504 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
505 mDelegate->getRenderPosition(outputAidl, &aidlRet)));
506 if (halFrames != nullptr) {
507 *halFrames = VALUE_OR_RETURN_STATUS(convertIntegral<uint32_t>(aidlRet.halFrames));
508 }
509 if (dspFrames != nullptr) {
510 *dspFrames = VALUE_OR_RETURN_STATUS(convertIntegral<uint32_t>(aidlRet.dspFrames));
511 }
512 return OK;
513 }
514
getInputFramesLost(audio_io_handle_t ioHandle) const515 uint32_t AudioFlingerClientAdapter::getInputFramesLost(audio_io_handle_t ioHandle) const {
516 auto result = [&]() -> ConversionResult<uint32_t> {
517 int32_t ioHandleAidl = VALUE_OR_RETURN(legacy2aidl_audio_io_handle_t_int32_t(ioHandle));
518 int32_t aidlRet;
519 RETURN_IF_ERROR(statusTFromBinderStatus(
520 mDelegate->getInputFramesLost(ioHandleAidl, &aidlRet)));
521 return convertIntegral<uint32_t>(aidlRet);
522 }();
523 // Failure is ignored.
524 return result.value_or(0);
525 }
526
newAudioUniqueId(audio_unique_id_use_t use)527 audio_unique_id_t AudioFlingerClientAdapter::newAudioUniqueId(audio_unique_id_use_t use) {
528 auto result = [&]() -> ConversionResult<audio_unique_id_t> {
529 media::AudioUniqueIdUse useAidl = VALUE_OR_RETURN(
530 legacy2aidl_audio_unique_id_use_t_AudioUniqueIdUse(use));
531 int32_t aidlRet;
532 RETURN_IF_ERROR(statusTFromBinderStatus(
533 mDelegate->newAudioUniqueId(useAidl, &aidlRet)));
534 return aidl2legacy_int32_t_audio_unique_id_t(aidlRet);
535 }();
536 return result.value_or(AUDIO_UNIQUE_ID_ALLOCATE);
537 }
538
acquireAudioSessionId(audio_session_t audioSession,pid_t pid,uid_t uid)539 void AudioFlingerClientAdapter::acquireAudioSessionId(audio_session_t audioSession, pid_t pid,
540 uid_t uid) {
541 [&]() -> status_t {
542 int32_t audioSessionAidl = VALUE_OR_RETURN_STATUS(
543 legacy2aidl_audio_session_t_int32_t(audioSession));
544 int32_t pidAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_pid_t_int32_t(pid));
545 int32_t uidAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_pid_t_int32_t(uid));
546 return statusTFromBinderStatus(
547 mDelegate->acquireAudioSessionId(audioSessionAidl, pidAidl, uidAidl));
548 }();
549 // Failure is ignored.
550 }
551
releaseAudioSessionId(audio_session_t audioSession,pid_t pid)552 void AudioFlingerClientAdapter::releaseAudioSessionId(audio_session_t audioSession, pid_t pid) {
553 [&]() -> status_t {
554 int32_t audioSessionAidl = VALUE_OR_RETURN_STATUS(
555 legacy2aidl_audio_session_t_int32_t(audioSession));
556 int32_t pidAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_pid_t_int32_t(pid));
557 return statusTFromBinderStatus(
558 mDelegate->releaseAudioSessionId(audioSessionAidl, pidAidl));
559 }();
560 // Failure is ignored.
561 }
562
queryNumberEffects(uint32_t * numEffects) const563 status_t AudioFlingerClientAdapter::queryNumberEffects(uint32_t* numEffects) const {
564 int32_t aidlRet;
565 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
566 mDelegate->queryNumberEffects(&aidlRet)));
567 if (numEffects != nullptr) {
568 *numEffects = VALUE_OR_RETURN_STATUS(convertIntegral<uint32_t>(aidlRet));
569 }
570 return OK;
571 }
572
573 status_t
queryEffect(uint32_t index,effect_descriptor_t * pDescriptor) const574 AudioFlingerClientAdapter::queryEffect(uint32_t index, effect_descriptor_t* pDescriptor) const {
575 int32_t indexAidl = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(index));
576 media::EffectDescriptor aidlRet;
577 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
578 mDelegate->queryEffect(indexAidl, &aidlRet)));
579 if (pDescriptor != nullptr) {
580 *pDescriptor = VALUE_OR_RETURN_STATUS(
581 aidl2legacy_EffectDescriptor_effect_descriptor_t(aidlRet));
582 }
583 return OK;
584 }
585
getEffectDescriptor(const effect_uuid_t * pEffectUUID,const effect_uuid_t * pTypeUUID,uint32_t preferredTypeFlag,effect_descriptor_t * pDescriptor) const586 status_t AudioFlingerClientAdapter::getEffectDescriptor(const effect_uuid_t* pEffectUUID,
587 const effect_uuid_t* pTypeUUID,
588 uint32_t preferredTypeFlag,
589 effect_descriptor_t* pDescriptor) const {
590 AudioUuid effectUuidAidl = VALUE_OR_RETURN_STATUS(
591 legacy2aidl_audio_uuid_t_AudioUuid(*pEffectUUID));
592 AudioUuid typeUuidAidl = VALUE_OR_RETURN_STATUS(
593 legacy2aidl_audio_uuid_t_AudioUuid(*pTypeUUID));
594 int32_t preferredTypeFlagAidl = VALUE_OR_RETURN_STATUS(
595 convertReinterpret<int32_t>(preferredTypeFlag));
596 media::EffectDescriptor aidlRet;
597 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
598 mDelegate->getEffectDescriptor(effectUuidAidl, typeUuidAidl, preferredTypeFlagAidl,
599 &aidlRet)));
600 if (pDescriptor != nullptr) {
601 *pDescriptor = VALUE_OR_RETURN_STATUS(
602 aidl2legacy_EffectDescriptor_effect_descriptor_t(aidlRet));
603 }
604 return OK;
605 }
606
createEffect(const media::CreateEffectRequest & request,media::CreateEffectResponse * response)607 status_t AudioFlingerClientAdapter::createEffect(const media::CreateEffectRequest& request,
608 media::CreateEffectResponse* response) {
609 return statusTFromBinderStatus(mDelegate->createEffect(request, response));
610 }
611
612 status_t
moveEffects(audio_session_t session,audio_io_handle_t srcOutput,audio_io_handle_t dstOutput)613 AudioFlingerClientAdapter::moveEffects(audio_session_t session, audio_io_handle_t srcOutput,
614 audio_io_handle_t dstOutput) {
615 int32_t sessionAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_session_t_int32_t(session));
616 int32_t srcOutputAidl = VALUE_OR_RETURN_STATUS(
617 legacy2aidl_audio_io_handle_t_int32_t(srcOutput));
618 int32_t dstOutputAidl = VALUE_OR_RETURN_STATUS(
619 legacy2aidl_audio_io_handle_t_int32_t(dstOutput));
620 return statusTFromBinderStatus(
621 mDelegate->moveEffects(sessionAidl, srcOutputAidl, dstOutputAidl));
622 }
623
setEffectSuspended(int effectId,audio_session_t sessionId,bool suspended)624 void AudioFlingerClientAdapter::setEffectSuspended(int effectId,
625 audio_session_t sessionId,
626 bool suspended) {
627 [&]() -> status_t {
628 int32_t effectIdAidl = VALUE_OR_RETURN_STATUS(convertReinterpret<int32_t>(effectId));
629 int32_t sessionIdAidl = VALUE_OR_RETURN_STATUS(
630 legacy2aidl_audio_session_t_int32_t(sessionId));
631 return statusTFromBinderStatus(
632 mDelegate->setEffectSuspended(effectIdAidl, sessionIdAidl, suspended));
633 }();
634 // Failure is ignored.
635 }
636
loadHwModule(const char * name)637 audio_module_handle_t AudioFlingerClientAdapter::loadHwModule(const char* name) {
638 auto result = [&]() -> ConversionResult<audio_module_handle_t> {
639 std::string nameAidl(name);
640 int32_t aidlRet;
641 RETURN_IF_ERROR(statusTFromBinderStatus(
642 mDelegate->loadHwModule(nameAidl, &aidlRet)));
643 return aidl2legacy_int32_t_audio_module_handle_t(aidlRet);
644 }();
645 // Failure is ignored.
646 return result.value_or(0);
647 }
648
getPrimaryOutputSamplingRate()649 uint32_t AudioFlingerClientAdapter::getPrimaryOutputSamplingRate() {
650 auto result = [&]() -> ConversionResult<uint32_t> {
651 int32_t aidlRet;
652 RETURN_IF_ERROR(statusTFromBinderStatus(
653 mDelegate->getPrimaryOutputSamplingRate(&aidlRet)));
654 return convertIntegral<uint32_t>(aidlRet);
655 }();
656 // Failure is ignored.
657 return result.value_or(0);
658 }
659
getPrimaryOutputFrameCount()660 size_t AudioFlingerClientAdapter::getPrimaryOutputFrameCount() {
661 auto result = [&]() -> ConversionResult<size_t> {
662 int64_t aidlRet;
663 RETURN_IF_ERROR(statusTFromBinderStatus(
664 mDelegate->getPrimaryOutputFrameCount(&aidlRet)));
665 return convertIntegral<size_t>(aidlRet);
666 }();
667 // Failure is ignored.
668 return result.value_or(0);
669 }
670
setLowRamDevice(bool isLowRamDevice,int64_t totalMemory)671 status_t AudioFlingerClientAdapter::setLowRamDevice(bool isLowRamDevice, int64_t totalMemory) {
672 return statusTFromBinderStatus(mDelegate->setLowRamDevice(isLowRamDevice, totalMemory));
673 }
674
getAudioPort(struct audio_port_v7 * port)675 status_t AudioFlingerClientAdapter::getAudioPort(struct audio_port_v7* port) {
676 media::AudioPortFw portAidl = VALUE_OR_RETURN_STATUS(
677 legacy2aidl_audio_port_v7_AudioPortFw(*port));
678 media::AudioPortFw aidlRet;
679 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
680 mDelegate->getAudioPort(portAidl, &aidlRet)));
681 *port = VALUE_OR_RETURN_STATUS(aidl2legacy_AudioPortFw_audio_port_v7(aidlRet));
682 return OK;
683 }
684
createAudioPatch(const struct audio_patch * patch,audio_patch_handle_t * handle)685 status_t AudioFlingerClientAdapter::createAudioPatch(const struct audio_patch* patch,
686 audio_patch_handle_t* handle) {
687 media::AudioPatchFw patchAidl = VALUE_OR_RETURN_STATUS(
688 legacy2aidl_audio_patch_AudioPatchFw(*patch));
689 int32_t aidlRet = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_patch_handle_t_int32_t(
690 AUDIO_PATCH_HANDLE_NONE));
691 if (handle != nullptr) {
692 aidlRet = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_patch_handle_t_int32_t(*handle));
693 }
694 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
695 mDelegate->createAudioPatch(patchAidl, &aidlRet)));
696 if (handle != nullptr) {
697 *handle = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_audio_patch_handle_t(aidlRet));
698 }
699 return OK;
700 }
701
releaseAudioPatch(audio_patch_handle_t handle)702 status_t AudioFlingerClientAdapter::releaseAudioPatch(audio_patch_handle_t handle) {
703 int32_t handleAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_patch_handle_t_int32_t(handle));
704 return statusTFromBinderStatus(mDelegate->releaseAudioPatch(handleAidl));
705 }
706
listAudioPatches(unsigned int * num_patches,struct audio_patch * patches)707 status_t AudioFlingerClientAdapter::listAudioPatches(unsigned int* num_patches,
708 struct audio_patch* patches) {
709 std::vector<media::AudioPatchFw> aidlRet;
710 int32_t maxPatches = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(*num_patches));
711 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
712 mDelegate->listAudioPatches(maxPatches, &aidlRet)));
713 *num_patches = VALUE_OR_RETURN_STATUS(convertIntegral<unsigned int>(aidlRet.size()));
714 return convertRange(aidlRet.begin(), aidlRet.end(), patches,
715 aidl2legacy_AudioPatchFw_audio_patch);
716 }
717
setAudioPortConfig(const struct audio_port_config * config)718 status_t AudioFlingerClientAdapter::setAudioPortConfig(const struct audio_port_config* config) {
719 media::AudioPortConfigFw configAidl = VALUE_OR_RETURN_STATUS(
720 legacy2aidl_audio_port_config_AudioPortConfigFw(*config));
721 return statusTFromBinderStatus(mDelegate->setAudioPortConfig(configAidl));
722 }
723
getAudioHwSyncForSession(audio_session_t sessionId)724 audio_hw_sync_t AudioFlingerClientAdapter::getAudioHwSyncForSession(audio_session_t sessionId) {
725 auto result = [&]() -> ConversionResult<audio_hw_sync_t> {
726 int32_t sessionIdAidl = VALUE_OR_RETURN(legacy2aidl_audio_session_t_int32_t(sessionId));
727 int32_t aidlRet;
728 RETURN_IF_ERROR(statusTFromBinderStatus(
729 mDelegate->getAudioHwSyncForSession(sessionIdAidl, &aidlRet)));
730 return aidl2legacy_int32_t_audio_hw_sync_t(aidlRet);
731 }();
732 return result.value_or(AUDIO_HW_SYNC_INVALID);
733 }
734
systemReady()735 status_t AudioFlingerClientAdapter::systemReady() {
736 return statusTFromBinderStatus(mDelegate->systemReady());
737 }
738
audioPolicyReady()739 status_t AudioFlingerClientAdapter::audioPolicyReady() {
740 return statusTFromBinderStatus(mDelegate->audioPolicyReady());
741 }
742
frameCountHAL(audio_io_handle_t ioHandle) const743 size_t AudioFlingerClientAdapter::frameCountHAL(audio_io_handle_t ioHandle) const {
744 auto result = [&]() -> ConversionResult<size_t> {
745 int32_t ioHandleAidl = VALUE_OR_RETURN(legacy2aidl_audio_io_handle_t_int32_t(ioHandle));
746 int64_t aidlRet;
747 RETURN_IF_ERROR(statusTFromBinderStatus(
748 mDelegate->frameCountHAL(ioHandleAidl, &aidlRet)));
749 return convertIntegral<size_t>(aidlRet);
750 }();
751 // Failure is ignored.
752 return result.value_or(0);
753 }
754
755 status_t
getMicrophones(std::vector<media::MicrophoneInfoFw> * microphones)756 AudioFlingerClientAdapter::getMicrophones(std::vector<media::MicrophoneInfoFw>* microphones) {
757 std::vector<media::MicrophoneInfoFw> aidlRet;
758 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(mDelegate->getMicrophones(&aidlRet)));
759 if (microphones != nullptr) {
760 *microphones = std::move(aidlRet);
761 }
762 return OK;
763 }
764
setAudioHalPids(const std::vector<pid_t> & pids)765 status_t AudioFlingerClientAdapter::setAudioHalPids(const std::vector<pid_t>& pids) {
766 std::vector<int32_t> pidsAidl = VALUE_OR_RETURN_STATUS(
767 convertContainer<std::vector<int32_t>>(pids, legacy2aidl_pid_t_int32_t));
768 return statusTFromBinderStatus(mDelegate->setAudioHalPids(pidsAidl));
769 }
770
setVibratorInfos(const std::vector<media::AudioVibratorInfo> & vibratorInfos)771 status_t AudioFlingerClientAdapter::setVibratorInfos(
772 const std::vector<media::AudioVibratorInfo>& vibratorInfos) {
773 return statusTFromBinderStatus(mDelegate->setVibratorInfos(vibratorInfos));
774 }
775
updateSecondaryOutputs(const TrackSecondaryOutputsMap & trackSecondaryOutputs)776 status_t AudioFlingerClientAdapter::updateSecondaryOutputs(
777 const TrackSecondaryOutputsMap& trackSecondaryOutputs) {
778 std::vector<media::TrackSecondaryOutputInfo> trackSecondaryOutputInfos =
779 VALUE_OR_RETURN_STATUS(
780 convertContainer<std::vector<media::TrackSecondaryOutputInfo>>(
781 trackSecondaryOutputs,
782 legacy2aidl_TrackSecondaryOutputInfoPair_TrackSecondaryOutputInfo));
783 return statusTFromBinderStatus(mDelegate->updateSecondaryOutputs(trackSecondaryOutputInfos));
784 }
785
getMmapPolicyInfos(AudioMMapPolicyType policyType,std::vector<AudioMMapPolicyInfo> * policyInfos)786 status_t AudioFlingerClientAdapter::getMmapPolicyInfos(
787 AudioMMapPolicyType policyType, std::vector<AudioMMapPolicyInfo> *policyInfos) {
788 return statusTFromBinderStatus(mDelegate->getMmapPolicyInfos(policyType, policyInfos));
789 }
790
getAAudioMixerBurstCount()791 int32_t AudioFlingerClientAdapter::getAAudioMixerBurstCount() {
792 auto result = [&]() -> ConversionResult<int32_t> {
793 int32_t aidlRet;
794 RETURN_IF_ERROR(statusTFromBinderStatus(mDelegate->getAAudioMixerBurstCount(&aidlRet)));
795 return convertIntegral<int32_t>(aidlRet);
796 }();
797 // Failure is ignored.
798 return result.value_or(0);
799 }
800
getAAudioHardwareBurstMinUsec()801 int32_t AudioFlingerClientAdapter::getAAudioHardwareBurstMinUsec() {
802 auto result = [&]() -> ConversionResult<int32_t> {
803 int32_t aidlRet;
804 RETURN_IF_ERROR(statusTFromBinderStatus(
805 mDelegate->getAAudioHardwareBurstMinUsec(&aidlRet)));
806 return convertIntegral<int32_t>(aidlRet);
807 }();
808 // Failure is ignored.
809 return result.value_or(0);
810 }
811
setDeviceConnectedState(const struct audio_port_v7 * port,media::DeviceConnectedState state)812 status_t AudioFlingerClientAdapter::setDeviceConnectedState(
813 const struct audio_port_v7 *port, media::DeviceConnectedState state) {
814 media::AudioPortFw aidlPort = VALUE_OR_RETURN_STATUS(
815 legacy2aidl_audio_port_v7_AudioPortFw(*port));
816 return statusTFromBinderStatus(mDelegate->setDeviceConnectedState(aidlPort, state));
817 }
818
setSimulateDeviceConnections(bool enabled)819 status_t AudioFlingerClientAdapter::setSimulateDeviceConnections(bool enabled) {
820 return statusTFromBinderStatus(mDelegate->setSimulateDeviceConnections(enabled));
821 }
822
setRequestedLatencyMode(audio_io_handle_t output,audio_latency_mode_t mode)823 status_t AudioFlingerClientAdapter::setRequestedLatencyMode(
824 audio_io_handle_t output, audio_latency_mode_t mode) {
825 int32_t outputAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(output));
826 media::audio::common::AudioLatencyMode modeAidl = VALUE_OR_RETURN_STATUS(
827 legacy2aidl_audio_latency_mode_t_AudioLatencyMode(mode));
828 return statusTFromBinderStatus(mDelegate->setRequestedLatencyMode(outputAidl, modeAidl));
829 }
830
getSupportedLatencyModes(audio_io_handle_t output,std::vector<audio_latency_mode_t> * modes)831 status_t AudioFlingerClientAdapter::getSupportedLatencyModes(
832 audio_io_handle_t output, std::vector<audio_latency_mode_t>* modes) {
833 if (modes == nullptr) {
834 return BAD_VALUE;
835 }
836
837 int32_t outputAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(output));
838 std::vector<media::audio::common::AudioLatencyMode> modesAidl;
839
840 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
841 mDelegate->getSupportedLatencyModes(outputAidl, &modesAidl)));
842
843 *modes = VALUE_OR_RETURN_STATUS(
844 convertContainer<std::vector<audio_latency_mode_t>>(modesAidl,
845 aidl2legacy_AudioLatencyMode_audio_latency_mode_t));
846
847 return NO_ERROR;
848 }
849
setBluetoothVariableLatencyEnabled(bool enabled)850 status_t AudioFlingerClientAdapter::setBluetoothVariableLatencyEnabled(bool enabled) {
851 return statusTFromBinderStatus(mDelegate->setBluetoothVariableLatencyEnabled(enabled));
852 }
853
isBluetoothVariableLatencyEnabled(bool * enabled)854 status_t AudioFlingerClientAdapter::isBluetoothVariableLatencyEnabled(bool* enabled) {
855 if (enabled == nullptr) {
856 return BAD_VALUE;
857 }
858
859 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
860 mDelegate->isBluetoothVariableLatencyEnabled(enabled)));
861
862 return NO_ERROR;
863 }
864
supportsBluetoothVariableLatency(bool * support)865 status_t AudioFlingerClientAdapter::supportsBluetoothVariableLatency(bool* support) {
866 if (support == nullptr) {
867 return BAD_VALUE;
868 }
869
870 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
871 mDelegate->supportsBluetoothVariableLatency(support)));
872
873 return NO_ERROR;
874 }
875
getSoundDoseInterface(const sp<media::ISoundDoseCallback> & callback,sp<media::ISoundDose> * soundDose)876 status_t AudioFlingerClientAdapter::getSoundDoseInterface(
877 const sp<media::ISoundDoseCallback> &callback,
878 sp<media::ISoundDose>* soundDose) {
879 return statusTFromBinderStatus(mDelegate->getSoundDoseInterface(callback, soundDose));
880 }
881
invalidateTracks(const std::vector<audio_port_handle_t> & portIds)882 status_t AudioFlingerClientAdapter::invalidateTracks(
883 const std::vector<audio_port_handle_t>& portIds) {
884 std::vector<int32_t> portIdsAidl = VALUE_OR_RETURN_STATUS(
885 convertContainer<std::vector<int32_t>>(
886 portIds, legacy2aidl_audio_port_handle_t_int32_t));
887 return statusTFromBinderStatus(mDelegate->invalidateTracks(portIdsAidl));
888 }
889
getAudioPolicyConfig(media::AudioPolicyConfig * config)890 status_t AudioFlingerClientAdapter::getAudioPolicyConfig(media::AudioPolicyConfig *config) {
891 if (config == nullptr) {
892 return BAD_VALUE;
893 }
894
895 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(mDelegate->getAudioPolicyConfig(config)));
896
897 return NO_ERROR;
898 }
899
900 ////////////////////////////////////////////////////////////////////////////////////////////////////
901 // AudioFlingerServerAdapter
AudioFlingerServerAdapter(const sp<AudioFlingerServerAdapter::Delegate> & delegate)902 AudioFlingerServerAdapter::AudioFlingerServerAdapter(
903 const sp<AudioFlingerServerAdapter::Delegate>& delegate) : mDelegate(delegate) {
904 setMinSchedulerPolicy(SCHED_NORMAL, ANDROID_PRIORITY_AUDIO);
905 }
906
onTransact(uint32_t code,const Parcel & data,Parcel * reply,uint32_t flags)907 status_t AudioFlingerServerAdapter::onTransact(uint32_t code,
908 const Parcel& data,
909 Parcel* reply,
910 uint32_t flags) {
911 return mDelegate->onTransactWrapper(static_cast<Delegate::TransactionCode>(code),
912 data,
913 flags,
914 [&] {
915 return BnAudioFlingerService::onTransact(
916 code,
917 data,
918 reply,
919 flags);
920 });
921 }
922
dump(int fd,const Vector<String16> & args)923 status_t AudioFlingerServerAdapter::dump(int fd, const Vector<String16>& args) {
924 return mDelegate->dump(fd, args);
925 }
926
createTrack(const media::CreateTrackRequest & request,media::CreateTrackResponse * _aidl_return)927 Status AudioFlingerServerAdapter::createTrack(const media::CreateTrackRequest& request,
928 media::CreateTrackResponse* _aidl_return) {
929 return Status::fromStatusT(mDelegate->createTrack(request, *_aidl_return));
930 }
931
createRecord(const media::CreateRecordRequest & request,media::CreateRecordResponse * _aidl_return)932 Status AudioFlingerServerAdapter::createRecord(const media::CreateRecordRequest& request,
933 media::CreateRecordResponse* _aidl_return) {
934 return Status::fromStatusT(mDelegate->createRecord(request, *_aidl_return));
935 }
936
sampleRate(int32_t ioHandle,int32_t * _aidl_return)937 Status AudioFlingerServerAdapter::sampleRate(int32_t ioHandle, int32_t* _aidl_return) {
938 audio_io_handle_t ioHandleLegacy = VALUE_OR_RETURN_BINDER(
939 aidl2legacy_int32_t_audio_io_handle_t(ioHandle));
940 *_aidl_return = VALUE_OR_RETURN_BINDER(
941 convertIntegral<int32_t>(mDelegate->sampleRate(ioHandleLegacy)));
942 return Status::ok();
943 }
944
format(int32_t output,AudioFormatDescription * _aidl_return)945 Status AudioFlingerServerAdapter::format(int32_t output,
946 AudioFormatDescription* _aidl_return) {
947 audio_io_handle_t outputLegacy = VALUE_OR_RETURN_BINDER(
948 aidl2legacy_int32_t_audio_io_handle_t(output));
949 *_aidl_return = VALUE_OR_RETURN_BINDER(
950 legacy2aidl_audio_format_t_AudioFormatDescription(mDelegate->format(outputLegacy)));
951 return Status::ok();
952 }
953
frameCount(int32_t ioHandle,int64_t * _aidl_return)954 Status AudioFlingerServerAdapter::frameCount(int32_t ioHandle, int64_t* _aidl_return) {
955 audio_io_handle_t ioHandleLegacy = VALUE_OR_RETURN_BINDER(
956 aidl2legacy_int32_t_audio_io_handle_t(ioHandle));
957 *_aidl_return = VALUE_OR_RETURN_BINDER(
958 convertIntegral<int64_t>(mDelegate->frameCount(ioHandleLegacy)));
959 return Status::ok();
960 }
961
latency(int32_t output,int32_t * _aidl_return)962 Status AudioFlingerServerAdapter::latency(int32_t output, int32_t* _aidl_return) {
963 audio_io_handle_t outputLegacy = VALUE_OR_RETURN_BINDER(
964 aidl2legacy_int32_t_audio_io_handle_t(output));
965 *_aidl_return = VALUE_OR_RETURN_BINDER(
966 convertIntegral<int32_t>(mDelegate->latency(outputLegacy)));
967 return Status::ok();
968 }
969
setMasterVolume(float value)970 Status AudioFlingerServerAdapter::setMasterVolume(float value) {
971 return Status::fromStatusT(mDelegate->setMasterVolume(value));
972 }
973
setMasterMute(bool muted)974 Status AudioFlingerServerAdapter::setMasterMute(bool muted) {
975 return Status::fromStatusT(mDelegate->setMasterMute(muted));
976 }
977
masterVolume(float * _aidl_return)978 Status AudioFlingerServerAdapter::masterVolume(float* _aidl_return) {
979 *_aidl_return = mDelegate->masterVolume();
980 return Status::ok();
981 }
982
masterMute(bool * _aidl_return)983 Status AudioFlingerServerAdapter::masterMute(bool* _aidl_return) {
984 *_aidl_return = mDelegate->masterMute();
985 return Status::ok();
986 }
987
setMasterBalance(float balance)988 Status AudioFlingerServerAdapter::setMasterBalance(float balance) {
989 return Status::fromStatusT(mDelegate->setMasterBalance(balance));
990 }
991
getMasterBalance(float * _aidl_return)992 Status AudioFlingerServerAdapter::getMasterBalance(float* _aidl_return) {
993 return Status::fromStatusT(mDelegate->getMasterBalance(_aidl_return));
994 }
995
setStreamVolume(AudioStreamType stream,float value,int32_t output)996 Status AudioFlingerServerAdapter::setStreamVolume(AudioStreamType stream, float value,
997 int32_t output) {
998 audio_stream_type_t streamLegacy = VALUE_OR_RETURN_BINDER(
999 aidl2legacy_AudioStreamType_audio_stream_type_t(stream));
1000 audio_io_handle_t outputLegacy = VALUE_OR_RETURN_BINDER(
1001 aidl2legacy_int32_t_audio_io_handle_t(output));
1002 return Status::fromStatusT(mDelegate->setStreamVolume(streamLegacy, value, outputLegacy));
1003 }
1004
setStreamMute(AudioStreamType stream,bool muted)1005 Status AudioFlingerServerAdapter::setStreamMute(AudioStreamType stream, bool muted) {
1006 audio_stream_type_t streamLegacy = VALUE_OR_RETURN_BINDER(
1007 aidl2legacy_AudioStreamType_audio_stream_type_t(stream));
1008 return Status::fromStatusT(mDelegate->setStreamMute(streamLegacy, muted));
1009 }
1010
streamVolume(AudioStreamType stream,int32_t output,float * _aidl_return)1011 Status AudioFlingerServerAdapter::streamVolume(AudioStreamType stream, int32_t output,
1012 float* _aidl_return) {
1013 audio_stream_type_t streamLegacy = VALUE_OR_RETURN_BINDER(
1014 aidl2legacy_AudioStreamType_audio_stream_type_t(stream));
1015 audio_io_handle_t outputLegacy = VALUE_OR_RETURN_BINDER(
1016 aidl2legacy_int32_t_audio_io_handle_t(output));
1017 *_aidl_return = mDelegate->streamVolume(streamLegacy, outputLegacy);
1018 return Status::ok();
1019 }
1020
streamMute(AudioStreamType stream,bool * _aidl_return)1021 Status AudioFlingerServerAdapter::streamMute(AudioStreamType stream, bool* _aidl_return) {
1022 audio_stream_type_t streamLegacy = VALUE_OR_RETURN_BINDER(
1023 aidl2legacy_AudioStreamType_audio_stream_type_t(stream));
1024 *_aidl_return = mDelegate->streamMute(streamLegacy);
1025 return Status::ok();
1026 }
1027
setMode(AudioMode mode)1028 Status AudioFlingerServerAdapter::setMode(AudioMode mode) {
1029 audio_mode_t modeLegacy = VALUE_OR_RETURN_BINDER(aidl2legacy_AudioMode_audio_mode_t(mode));
1030 return Status::fromStatusT(mDelegate->setMode(modeLegacy));
1031 }
1032
setMicMute(bool state)1033 Status AudioFlingerServerAdapter::setMicMute(bool state) {
1034 return Status::fromStatusT(mDelegate->setMicMute(state));
1035 }
1036
getMicMute(bool * _aidl_return)1037 Status AudioFlingerServerAdapter::getMicMute(bool* _aidl_return) {
1038 *_aidl_return = mDelegate->getMicMute();
1039 return Status::ok();
1040 }
1041
setRecordSilenced(int32_t portId,bool silenced)1042 Status AudioFlingerServerAdapter::setRecordSilenced(int32_t portId, bool silenced) {
1043 audio_port_handle_t portIdLegacy = VALUE_OR_RETURN_BINDER(
1044 aidl2legacy_int32_t_audio_port_handle_t(portId));
1045 mDelegate->setRecordSilenced(portIdLegacy, silenced);
1046 return Status::ok();
1047 }
1048
1049 Status
setParameters(int32_t ioHandle,const std::string & keyValuePairs)1050 AudioFlingerServerAdapter::setParameters(int32_t ioHandle, const std::string& keyValuePairs) {
1051 audio_io_handle_t ioHandleLegacy = VALUE_OR_RETURN_BINDER(
1052 aidl2legacy_int32_t_audio_io_handle_t(ioHandle));
1053 String8 keyValuePairsLegacy = VALUE_OR_RETURN_BINDER(
1054 aidl2legacy_string_view_String8(keyValuePairs));
1055 return Status::fromStatusT(mDelegate->setParameters(ioHandleLegacy, keyValuePairsLegacy));
1056 }
1057
getParameters(int32_t ioHandle,const std::string & keys,std::string * _aidl_return)1058 Status AudioFlingerServerAdapter::getParameters(int32_t ioHandle, const std::string& keys,
1059 std::string* _aidl_return) {
1060 audio_io_handle_t ioHandleLegacy = VALUE_OR_RETURN_BINDER(
1061 aidl2legacy_int32_t_audio_io_handle_t(ioHandle));
1062 String8 keysLegacy = VALUE_OR_RETURN_BINDER(aidl2legacy_string_view_String8(keys));
1063 *_aidl_return = VALUE_OR_RETURN_BINDER(
1064 legacy2aidl_String8_string(mDelegate->getParameters(ioHandleLegacy, keysLegacy)));
1065 return Status::ok();
1066 }
1067
registerClient(const sp<media::IAudioFlingerClient> & client)1068 Status AudioFlingerServerAdapter::registerClient(const sp<media::IAudioFlingerClient>& client) {
1069 mDelegate->registerClient(client);
1070 return Status::ok();
1071 }
1072
getInputBufferSize(int32_t sampleRate,const AudioFormatDescription & format,const AudioChannelLayout & channelMask,int64_t * _aidl_return)1073 Status AudioFlingerServerAdapter::getInputBufferSize(int32_t sampleRate,
1074 const AudioFormatDescription& format,
1075 const AudioChannelLayout& channelMask,
1076 int64_t* _aidl_return) {
1077 uint32_t sampleRateLegacy = VALUE_OR_RETURN_BINDER(convertIntegral<uint32_t>(sampleRate));
1078 audio_format_t formatLegacy = VALUE_OR_RETURN_BINDER(
1079 aidl2legacy_AudioFormatDescription_audio_format_t(format));
1080 audio_channel_mask_t channelMaskLegacy = VALUE_OR_RETURN_BINDER(
1081 aidl2legacy_AudioChannelLayout_audio_channel_mask_t(channelMask, true /*isInput*/));
1082 size_t size = mDelegate->getInputBufferSize(sampleRateLegacy, formatLegacy, channelMaskLegacy);
1083 *_aidl_return = VALUE_OR_RETURN_BINDER(convertIntegral<int64_t>(size));
1084 return Status::ok();
1085 }
1086
openOutput(const media::OpenOutputRequest & request,media::OpenOutputResponse * _aidl_return)1087 Status AudioFlingerServerAdapter::openOutput(const media::OpenOutputRequest& request,
1088 media::OpenOutputResponse* _aidl_return) {
1089 return Status::fromStatusT(mDelegate->openOutput(request, _aidl_return));
1090 }
1091
openDuplicateOutput(int32_t output1,int32_t output2,int32_t * _aidl_return)1092 Status AudioFlingerServerAdapter::openDuplicateOutput(int32_t output1, int32_t output2,
1093 int32_t* _aidl_return) {
1094 audio_io_handle_t output1Legacy = VALUE_OR_RETURN_BINDER(
1095 aidl2legacy_int32_t_audio_io_handle_t(output1));
1096 audio_io_handle_t output2Legacy = VALUE_OR_RETURN_BINDER(
1097 aidl2legacy_int32_t_audio_io_handle_t(output2));
1098 audio_io_handle_t result = mDelegate->openDuplicateOutput(output1Legacy, output2Legacy);
1099 *_aidl_return = VALUE_OR_RETURN_BINDER(legacy2aidl_audio_io_handle_t_int32_t(result));
1100 return Status::ok();
1101 }
1102
closeOutput(int32_t output)1103 Status AudioFlingerServerAdapter::closeOutput(int32_t output) {
1104 audio_io_handle_t outputLegacy = VALUE_OR_RETURN_BINDER(
1105 aidl2legacy_int32_t_audio_io_handle_t(output));
1106 return Status::fromStatusT(mDelegate->closeOutput(outputLegacy));
1107 }
1108
suspendOutput(int32_t output)1109 Status AudioFlingerServerAdapter::suspendOutput(int32_t output) {
1110 audio_io_handle_t outputLegacy = VALUE_OR_RETURN_BINDER(
1111 aidl2legacy_int32_t_audio_io_handle_t(output));
1112 return Status::fromStatusT(mDelegate->suspendOutput(outputLegacy));
1113 }
1114
restoreOutput(int32_t output)1115 Status AudioFlingerServerAdapter::restoreOutput(int32_t output) {
1116 audio_io_handle_t outputLegacy = VALUE_OR_RETURN_BINDER(
1117 aidl2legacy_int32_t_audio_io_handle_t(output));
1118 return Status::fromStatusT(mDelegate->restoreOutput(outputLegacy));
1119 }
1120
openInput(const media::OpenInputRequest & request,media::OpenInputResponse * _aidl_return)1121 Status AudioFlingerServerAdapter::openInput(const media::OpenInputRequest& request,
1122 media::OpenInputResponse* _aidl_return) {
1123 return Status::fromStatusT(mDelegate->openInput(request, _aidl_return));
1124 }
1125
closeInput(int32_t input)1126 Status AudioFlingerServerAdapter::closeInput(int32_t input) {
1127 audio_io_handle_t inputLegacy = VALUE_OR_RETURN_BINDER(
1128 aidl2legacy_int32_t_audio_io_handle_t(input));
1129 return Status::fromStatusT(mDelegate->closeInput(inputLegacy));
1130 }
1131
setVoiceVolume(float volume)1132 Status AudioFlingerServerAdapter::setVoiceVolume(float volume) {
1133 return Status::fromStatusT(mDelegate->setVoiceVolume(volume));
1134 }
1135
1136 Status
getRenderPosition(int32_t output,media::RenderPosition * _aidl_return)1137 AudioFlingerServerAdapter::getRenderPosition(int32_t output, media::RenderPosition* _aidl_return) {
1138 audio_io_handle_t outputLegacy = VALUE_OR_RETURN_BINDER(
1139 aidl2legacy_int32_t_audio_io_handle_t(output));
1140 uint32_t halFramesLegacy;
1141 uint32_t dspFramesLegacy;
1142 RETURN_BINDER_IF_ERROR(
1143 mDelegate->getRenderPosition(&halFramesLegacy, &dspFramesLegacy, outputLegacy));
1144 _aidl_return->halFrames = VALUE_OR_RETURN_BINDER(convertIntegral<int32_t>(halFramesLegacy));
1145 _aidl_return->dspFrames = VALUE_OR_RETURN_BINDER(convertIntegral<int32_t>(dspFramesLegacy));
1146 return Status::ok();
1147 }
1148
getInputFramesLost(int32_t ioHandle,int32_t * _aidl_return)1149 Status AudioFlingerServerAdapter::getInputFramesLost(int32_t ioHandle, int32_t* _aidl_return) {
1150 audio_io_handle_t ioHandleLegacy = VALUE_OR_RETURN_BINDER(
1151 aidl2legacy_int32_t_audio_io_handle_t(ioHandle));
1152 uint32_t result = mDelegate->getInputFramesLost(ioHandleLegacy);
1153 *_aidl_return = VALUE_OR_RETURN_BINDER(convertIntegral<int32_t>(result));
1154 return Status::ok();
1155 }
1156
1157 Status
newAudioUniqueId(media::AudioUniqueIdUse use,int32_t * _aidl_return)1158 AudioFlingerServerAdapter::newAudioUniqueId(media::AudioUniqueIdUse use, int32_t* _aidl_return) {
1159 audio_unique_id_use_t useLegacy = VALUE_OR_RETURN_BINDER(
1160 aidl2legacy_AudioUniqueIdUse_audio_unique_id_use_t(use));
1161 audio_unique_id_t result = mDelegate->newAudioUniqueId(useLegacy);
1162 *_aidl_return = VALUE_OR_RETURN_BINDER(legacy2aidl_audio_unique_id_t_int32_t(result));
1163 return Status::ok();
1164 }
1165
1166 Status
acquireAudioSessionId(int32_t audioSession,int32_t pid,int32_t uid)1167 AudioFlingerServerAdapter::acquireAudioSessionId(int32_t audioSession, int32_t pid, int32_t uid) {
1168 audio_session_t audioSessionLegacy = VALUE_OR_RETURN_BINDER(
1169 aidl2legacy_int32_t_audio_session_t(audioSession));
1170 pid_t pidLegacy = VALUE_OR_RETURN_BINDER(aidl2legacy_int32_t_pid_t(pid));
1171 uid_t uidLegacy = VALUE_OR_RETURN_BINDER(aidl2legacy_int32_t_uid_t(uid));
1172 mDelegate->acquireAudioSessionId(audioSessionLegacy, pidLegacy, uidLegacy);
1173 return Status::ok();
1174 }
1175
releaseAudioSessionId(int32_t audioSession,int32_t pid)1176 Status AudioFlingerServerAdapter::releaseAudioSessionId(int32_t audioSession, int32_t pid) {
1177 audio_session_t audioSessionLegacy = VALUE_OR_RETURN_BINDER(
1178 aidl2legacy_int32_t_audio_session_t(audioSession));
1179 pid_t pidLegacy = VALUE_OR_RETURN_BINDER(aidl2legacy_int32_t_pid_t(pid));
1180 mDelegate->releaseAudioSessionId(audioSessionLegacy, pidLegacy);
1181 return Status::ok();
1182 }
1183
queryNumberEffects(int32_t * _aidl_return)1184 Status AudioFlingerServerAdapter::queryNumberEffects(int32_t* _aidl_return) {
1185 uint32_t result;
1186 RETURN_BINDER_IF_ERROR(mDelegate->queryNumberEffects(&result));
1187 *_aidl_return = VALUE_OR_RETURN_BINDER(convertIntegral<uint32_t>(result));
1188 return Status::ok();
1189 }
1190
1191 Status
queryEffect(int32_t index,media::EffectDescriptor * _aidl_return)1192 AudioFlingerServerAdapter::queryEffect(int32_t index, media::EffectDescriptor* _aidl_return) {
1193 uint32_t indexLegacy = VALUE_OR_RETURN_BINDER(convertIntegral<uint32_t>(index));
1194 effect_descriptor_t result;
1195 RETURN_BINDER_IF_ERROR(mDelegate->queryEffect(indexLegacy, &result));
1196 *_aidl_return = VALUE_OR_RETURN_BINDER(
1197 legacy2aidl_effect_descriptor_t_EffectDescriptor(result));
1198 return Status::ok();
1199 }
1200
getEffectDescriptor(const AudioUuid & effectUUID,const AudioUuid & typeUUID,int32_t preferredTypeFlag,media::EffectDescriptor * _aidl_return)1201 Status AudioFlingerServerAdapter::getEffectDescriptor(const AudioUuid& effectUUID,
1202 const AudioUuid& typeUUID,
1203 int32_t preferredTypeFlag,
1204 media::EffectDescriptor* _aidl_return) {
1205 effect_uuid_t effectUuidLegacy = VALUE_OR_RETURN_BINDER(
1206 aidl2legacy_AudioUuid_audio_uuid_t(effectUUID));
1207 effect_uuid_t typeUuidLegacy = VALUE_OR_RETURN_BINDER(
1208 aidl2legacy_AudioUuid_audio_uuid_t(typeUUID));
1209 uint32_t preferredTypeFlagLegacy = VALUE_OR_RETURN_BINDER(
1210 convertReinterpret<uint32_t>(preferredTypeFlag));
1211 effect_descriptor_t result;
1212 RETURN_BINDER_IF_ERROR(mDelegate->getEffectDescriptor(&effectUuidLegacy, &typeUuidLegacy,
1213 preferredTypeFlagLegacy, &result));
1214 *_aidl_return = VALUE_OR_RETURN_BINDER(
1215 legacy2aidl_effect_descriptor_t_EffectDescriptor(result));
1216 return Status::ok();
1217 }
1218
createEffect(const media::CreateEffectRequest & request,media::CreateEffectResponse * _aidl_return)1219 Status AudioFlingerServerAdapter::createEffect(const media::CreateEffectRequest& request,
1220 media::CreateEffectResponse* _aidl_return) {
1221 return Status::fromStatusT(mDelegate->createEffect(request, _aidl_return));
1222 }
1223
1224 Status
moveEffects(int32_t session,int32_t srcOutput,int32_t dstOutput)1225 AudioFlingerServerAdapter::moveEffects(int32_t session, int32_t srcOutput, int32_t dstOutput) {
1226 audio_session_t sessionLegacy = VALUE_OR_RETURN_BINDER(
1227 aidl2legacy_int32_t_audio_session_t(session));
1228 audio_io_handle_t srcOutputLegacy = VALUE_OR_RETURN_BINDER(
1229 aidl2legacy_int32_t_audio_io_handle_t(srcOutput));
1230 audio_io_handle_t dstOutputLegacy = VALUE_OR_RETURN_BINDER(
1231 aidl2legacy_int32_t_audio_io_handle_t(dstOutput));
1232 return Status::fromStatusT(
1233 mDelegate->moveEffects(sessionLegacy, srcOutputLegacy, dstOutputLegacy));
1234 }
1235
setEffectSuspended(int32_t effectId,int32_t sessionId,bool suspended)1236 Status AudioFlingerServerAdapter::setEffectSuspended(int32_t effectId, int32_t sessionId,
1237 bool suspended) {
1238 int effectIdLegacy = VALUE_OR_RETURN_BINDER(convertReinterpret<int>(effectId));
1239 audio_session_t sessionIdLegacy = VALUE_OR_RETURN_BINDER(
1240 aidl2legacy_int32_t_audio_session_t(sessionId));
1241 mDelegate->setEffectSuspended(effectIdLegacy, sessionIdLegacy, suspended);
1242 return Status::ok();
1243 }
1244
loadHwModule(const std::string & name,int32_t * _aidl_return)1245 Status AudioFlingerServerAdapter::loadHwModule(const std::string& name, int32_t* _aidl_return) {
1246 audio_module_handle_t result = mDelegate->loadHwModule(name.c_str());
1247 *_aidl_return = VALUE_OR_RETURN_BINDER(legacy2aidl_audio_module_handle_t_int32_t(result));
1248 return Status::ok();
1249 }
1250
getPrimaryOutputSamplingRate(int32_t * _aidl_return)1251 Status AudioFlingerServerAdapter::getPrimaryOutputSamplingRate(int32_t* _aidl_return) {
1252 *_aidl_return = VALUE_OR_RETURN_BINDER(
1253 convertIntegral<int32_t>(mDelegate->getPrimaryOutputSamplingRate()));
1254 return Status::ok();
1255 }
1256
getPrimaryOutputFrameCount(int64_t * _aidl_return)1257 Status AudioFlingerServerAdapter::getPrimaryOutputFrameCount(int64_t* _aidl_return) {
1258 *_aidl_return = VALUE_OR_RETURN_BINDER(
1259 convertIntegral<int64_t>(mDelegate->getPrimaryOutputFrameCount()));
1260 return Status::ok();
1261
1262 }
1263
setLowRamDevice(bool isLowRamDevice,int64_t totalMemory)1264 Status AudioFlingerServerAdapter::setLowRamDevice(bool isLowRamDevice, int64_t totalMemory) {
1265 return Status::fromStatusT(mDelegate->setLowRamDevice(isLowRamDevice, totalMemory));
1266 }
1267
getAudioPort(const media::AudioPortFw & port,media::AudioPortFw * _aidl_return)1268 Status AudioFlingerServerAdapter::getAudioPort(const media::AudioPortFw& port,
1269 media::AudioPortFw* _aidl_return) {
1270 audio_port_v7 portLegacy = VALUE_OR_RETURN_BINDER(aidl2legacy_AudioPortFw_audio_port_v7(port));
1271 RETURN_BINDER_IF_ERROR(mDelegate->getAudioPort(&portLegacy));
1272 *_aidl_return = VALUE_OR_RETURN_BINDER(legacy2aidl_audio_port_v7_AudioPortFw(portLegacy));
1273 return Status::ok();
1274 }
1275
createAudioPatch(const media::AudioPatchFw & patch,int32_t * _aidl_return)1276 Status AudioFlingerServerAdapter::createAudioPatch(const media::AudioPatchFw& patch,
1277 int32_t* _aidl_return) {
1278 audio_patch patchLegacy = VALUE_OR_RETURN_BINDER(aidl2legacy_AudioPatchFw_audio_patch(patch));
1279 audio_patch_handle_t handleLegacy = VALUE_OR_RETURN_BINDER(
1280 aidl2legacy_int32_t_audio_patch_handle_t(*_aidl_return));
1281 RETURN_BINDER_IF_ERROR(mDelegate->createAudioPatch(&patchLegacy, &handleLegacy));
1282 *_aidl_return = VALUE_OR_RETURN_BINDER(legacy2aidl_audio_patch_handle_t_int32_t(handleLegacy));
1283 return Status::ok();
1284 }
1285
releaseAudioPatch(int32_t handle)1286 Status AudioFlingerServerAdapter::releaseAudioPatch(int32_t handle) {
1287 audio_patch_handle_t handleLegacy = VALUE_OR_RETURN_BINDER(
1288 aidl2legacy_int32_t_audio_patch_handle_t(handle));
1289 return Status::fromStatusT(mDelegate->releaseAudioPatch(handleLegacy));
1290 }
1291
listAudioPatches(int32_t maxCount,std::vector<media::AudioPatchFw> * _aidl_return)1292 Status AudioFlingerServerAdapter::listAudioPatches(int32_t maxCount,
1293 std::vector<media::AudioPatchFw>* _aidl_return) {
1294 unsigned int count = VALUE_OR_RETURN_BINDER(convertIntegral<unsigned int>(maxCount));
1295 count = std::min(count, static_cast<unsigned int>(MAX_ITEMS_PER_LIST));
1296 std::unique_ptr<audio_patch[]> patchesLegacy(new audio_patch[count]);
1297 RETURN_BINDER_IF_ERROR(mDelegate->listAudioPatches(&count, patchesLegacy.get()));
1298 RETURN_BINDER_IF_ERROR(convertRange(&patchesLegacy[0],
1299 &patchesLegacy[count],
1300 std::back_inserter(*_aidl_return),
1301 legacy2aidl_audio_patch_AudioPatchFw));
1302 return Status::ok();
1303 }
1304
setAudioPortConfig(const media::AudioPortConfigFw & config)1305 Status AudioFlingerServerAdapter::setAudioPortConfig(const media::AudioPortConfigFw& config) {
1306 audio_port_config configLegacy = VALUE_OR_RETURN_BINDER(
1307 aidl2legacy_AudioPortConfigFw_audio_port_config(config));
1308 return Status::fromStatusT(mDelegate->setAudioPortConfig(&configLegacy));
1309 }
1310
getAudioHwSyncForSession(int32_t sessionId,int32_t * _aidl_return)1311 Status AudioFlingerServerAdapter::getAudioHwSyncForSession(int32_t sessionId,
1312 int32_t* _aidl_return) {
1313 audio_session_t sessionIdLegacy = VALUE_OR_RETURN_BINDER(
1314 aidl2legacy_int32_t_audio_session_t(sessionId));
1315 audio_hw_sync_t result = mDelegate->getAudioHwSyncForSession(sessionIdLegacy);
1316 *_aidl_return = VALUE_OR_RETURN_BINDER(legacy2aidl_audio_hw_sync_t_int32_t(result));
1317 return Status::ok();
1318 }
1319
systemReady()1320 Status AudioFlingerServerAdapter::systemReady() {
1321 return Status::fromStatusT(mDelegate->systemReady());
1322 }
1323
audioPolicyReady()1324 Status AudioFlingerServerAdapter::audioPolicyReady() {
1325 mDelegate->audioPolicyReady();
1326 return Status::ok();
1327 }
1328
frameCountHAL(int32_t ioHandle,int64_t * _aidl_return)1329 Status AudioFlingerServerAdapter::frameCountHAL(int32_t ioHandle, int64_t* _aidl_return) {
1330 audio_io_handle_t ioHandleLegacy = VALUE_OR_RETURN_BINDER(
1331 aidl2legacy_int32_t_audio_io_handle_t(ioHandle));
1332 size_t result = mDelegate->frameCountHAL(ioHandleLegacy);
1333 *_aidl_return = VALUE_OR_RETURN_BINDER(convertIntegral<int64_t>(result));
1334 return Status::ok();
1335 }
1336
getMicrophones(std::vector<media::MicrophoneInfoFw> * _aidl_return)1337 Status AudioFlingerServerAdapter::getMicrophones(
1338 std::vector<media::MicrophoneInfoFw>* _aidl_return) {
1339 RETURN_BINDER_IF_ERROR(mDelegate->getMicrophones(_aidl_return));
1340 return Status::ok();
1341 }
1342
setAudioHalPids(const std::vector<int32_t> & pids)1343 Status AudioFlingerServerAdapter::setAudioHalPids(const std::vector<int32_t>& pids) {
1344 std::vector<pid_t> pidsLegacy = VALUE_OR_RETURN_BINDER(
1345 convertContainer<std::vector<pid_t>>(pids, aidl2legacy_int32_t_pid_t));
1346 RETURN_BINDER_IF_ERROR(mDelegate->setAudioHalPids(pidsLegacy));
1347 return Status::ok();
1348 }
1349
setVibratorInfos(const std::vector<media::AudioVibratorInfo> & vibratorInfos)1350 Status AudioFlingerServerAdapter::setVibratorInfos(
1351 const std::vector<media::AudioVibratorInfo>& vibratorInfos) {
1352 return Status::fromStatusT(mDelegate->setVibratorInfos(vibratorInfos));
1353 }
1354
updateSecondaryOutputs(const std::vector<media::TrackSecondaryOutputInfo> & trackSecondaryOutputInfos)1355 Status AudioFlingerServerAdapter::updateSecondaryOutputs(
1356 const std::vector<media::TrackSecondaryOutputInfo>& trackSecondaryOutputInfos) {
1357 TrackSecondaryOutputsMap trackSecondaryOutputs =
1358 VALUE_OR_RETURN_BINDER(convertContainer<TrackSecondaryOutputsMap>(
1359 trackSecondaryOutputInfos,
1360 aidl2legacy_TrackSecondaryOutputInfo_TrackSecondaryOutputInfoPair));
1361 return Status::fromStatusT(mDelegate->updateSecondaryOutputs(trackSecondaryOutputs));
1362 }
1363
getMmapPolicyInfos(AudioMMapPolicyType policyType,std::vector<AudioMMapPolicyInfo> * _aidl_return)1364 Status AudioFlingerServerAdapter::getMmapPolicyInfos(
1365 AudioMMapPolicyType policyType, std::vector<AudioMMapPolicyInfo> *_aidl_return) {
1366 return Status::fromStatusT(mDelegate->getMmapPolicyInfos(policyType, _aidl_return));
1367 }
1368
getAAudioMixerBurstCount(int32_t * _aidl_return)1369 Status AudioFlingerServerAdapter::getAAudioMixerBurstCount(int32_t* _aidl_return) {
1370 *_aidl_return = VALUE_OR_RETURN_BINDER(
1371 convertIntegral<int32_t>(mDelegate->getAAudioMixerBurstCount()));
1372 return Status::ok();
1373 }
1374
getAAudioHardwareBurstMinUsec(int32_t * _aidl_return)1375 Status AudioFlingerServerAdapter::getAAudioHardwareBurstMinUsec(int32_t* _aidl_return) {
1376 *_aidl_return = VALUE_OR_RETURN_BINDER(
1377 convertIntegral<int32_t>(mDelegate->getAAudioHardwareBurstMinUsec()));
1378 return Status::ok();
1379 }
1380
setDeviceConnectedState(const media::AudioPortFw & port,media::DeviceConnectedState state)1381 Status AudioFlingerServerAdapter::setDeviceConnectedState(
1382 const media::AudioPortFw& port, media::DeviceConnectedState state) {
1383 audio_port_v7 portLegacy = VALUE_OR_RETURN_BINDER(aidl2legacy_AudioPortFw_audio_port_v7(port));
1384 return Status::fromStatusT(mDelegate->setDeviceConnectedState(&portLegacy, state));
1385 }
1386
setSimulateDeviceConnections(bool enabled)1387 Status AudioFlingerServerAdapter::setSimulateDeviceConnections(bool enabled) {
1388 return Status::fromStatusT(mDelegate->setSimulateDeviceConnections(enabled));
1389 }
1390
setRequestedLatencyMode(int32_t output,media::audio::common::AudioLatencyMode modeAidl)1391 Status AudioFlingerServerAdapter::setRequestedLatencyMode(
1392 int32_t output, media::audio::common::AudioLatencyMode modeAidl) {
1393 audio_io_handle_t outputLegacy = VALUE_OR_RETURN_BINDER(
1394 aidl2legacy_int32_t_audio_io_handle_t(output));
1395 audio_latency_mode_t modeLegacy = VALUE_OR_RETURN_BINDER(
1396 aidl2legacy_AudioLatencyMode_audio_latency_mode_t(modeAidl));
1397 return Status::fromStatusT(mDelegate->setRequestedLatencyMode(
1398 outputLegacy, modeLegacy));
1399 }
1400
getSupportedLatencyModes(int output,std::vector<media::audio::common::AudioLatencyMode> * _aidl_return)1401 Status AudioFlingerServerAdapter::getSupportedLatencyModes(
1402 int output, std::vector<media::audio::common::AudioLatencyMode>* _aidl_return) {
1403 audio_io_handle_t outputLegacy = VALUE_OR_RETURN_BINDER(
1404 aidl2legacy_int32_t_audio_io_handle_t(output));
1405 std::vector<audio_latency_mode_t> modesLegacy;
1406
1407 RETURN_BINDER_IF_ERROR(mDelegate->getSupportedLatencyModes(outputLegacy, &modesLegacy));
1408
1409 *_aidl_return = VALUE_OR_RETURN_BINDER(
1410 convertContainer<std::vector<media::audio::common::AudioLatencyMode>>(
1411 modesLegacy, legacy2aidl_audio_latency_mode_t_AudioLatencyMode));
1412 return Status::ok();
1413 }
1414
setBluetoothVariableLatencyEnabled(bool enabled)1415 Status AudioFlingerServerAdapter::setBluetoothVariableLatencyEnabled(bool enabled) {
1416 return Status::fromStatusT(mDelegate->setBluetoothVariableLatencyEnabled(enabled));
1417 }
1418
isBluetoothVariableLatencyEnabled(bool * enabled)1419 Status AudioFlingerServerAdapter::isBluetoothVariableLatencyEnabled(bool *enabled) {
1420 return Status::fromStatusT(mDelegate->isBluetoothVariableLatencyEnabled(enabled));
1421 }
1422
supportsBluetoothVariableLatency(bool * support)1423 Status AudioFlingerServerAdapter::supportsBluetoothVariableLatency(bool *support) {
1424 return Status::fromStatusT(mDelegate->supportsBluetoothVariableLatency(support));
1425 }
1426
getSoundDoseInterface(const sp<media::ISoundDoseCallback> & callback,sp<media::ISoundDose> * soundDose)1427 Status AudioFlingerServerAdapter::getSoundDoseInterface(
1428 const sp<media::ISoundDoseCallback>& callback,
1429 sp<media::ISoundDose>* soundDose)
1430 {
1431 return Status::fromStatusT(mDelegate->getSoundDoseInterface(callback, soundDose));
1432 }
1433
invalidateTracks(const std::vector<int32_t> & portIds)1434 Status AudioFlingerServerAdapter::invalidateTracks(const std::vector<int32_t>& portIds) {
1435 std::vector<audio_port_handle_t> portIdsLegacy = VALUE_OR_RETURN_BINDER(
1436 convertContainer<std::vector<audio_port_handle_t>>(
1437 portIds, aidl2legacy_int32_t_audio_port_handle_t));
1438 RETURN_BINDER_IF_ERROR(mDelegate->invalidateTracks(portIdsLegacy));
1439 return Status::ok();
1440 }
1441
getAudioPolicyConfig(media::AudioPolicyConfig * _aidl_return)1442 Status AudioFlingerServerAdapter::getAudioPolicyConfig(media::AudioPolicyConfig* _aidl_return) {
1443 return Status::fromStatusT(mDelegate->getAudioPolicyConfig(_aidl_return));
1444 }
1445
1446 } // namespace android
1447