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