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