1 /*
2 * Copyright (C) 2006-2007 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #define LOG_TAG "AudioSystem"
18 //#define LOG_NDEBUG 0
19
20 #include <utils/Log.h>
21
22 #include <android/media/IAudioPolicyService.h>
23 #include <android/media/AudioMixUpdate.h>
24 #include <android/media/BnCaptureStateListener.h>
25 #include <android_media_audiopolicy.h>
26 #include <binder/IServiceManager.h>
27 #include <binder/ProcessState.h>
28 #include <binder/IPCThreadState.h>
29 #include <cutils/properties.h>
30 #include <media/AidlConversion.h>
31 #include <media/AudioResamplerPublic.h>
32 #include <media/AudioSystem.h>
33 #include <media/IAudioFlinger.h>
34 #include <media/PolicyAidlConversion.h>
35 #include <media/TypeConverter.h>
36 #include <mediautils/ServiceSingleton.h>
37 #include <math.h>
38 #include <private/android_filesystem_config.h>
39
40 #include <system/audio.h>
41 #include <android/media/GetInputForAttrResponse.h>
42 #include <android/media/AudioMixerAttributesInternal.h>
43
44 #define VALUE_OR_RETURN_BINDER_STATUS(x) \
45 ({ auto _tmp = (x); \
46 if (!_tmp.ok()) return aidl_utils::binderStatusFromStatusT(_tmp.error()); \
47 std::move(_tmp.value()); })
48
49 // ----------------------------------------------------------------------------
50
51 namespace audio_flags = android::media::audiopolicy;
52
53 namespace android {
54 using aidl_utils::statusTFromBinderStatus;
55 using binder::Status;
56 using content::AttributionSourceState;
57 using media::IAudioPolicyService;
58 using media::audio::common::AudioConfig;
59 using media::audio::common::AudioConfigBase;
60 using media::audio::common::AudioDevice;
61 using media::audio::common::AudioDeviceDescription;
62 using media::audio::common::AudioFormatDescription;
63 using media::audio::common::AudioMMapPolicyInfo;
64 using media::audio::common::AudioMMapPolicyType;
65 using media::audio::common::AudioOffloadInfo;
66 using media::audio::common::AudioSource;
67 using media::audio::common::AudioStreamType;
68 using media::audio::common::AudioUsage;
69 using media::audio::common::Int;
70
71 std::mutex AudioSystem::gMutex;
72 dynamic_policy_callback AudioSystem::gDynPolicyCallback = NULL;
73 record_config_callback AudioSystem::gRecordConfigCallback = NULL;
74 routing_callback AudioSystem::gRoutingCallback = NULL;
75 vol_range_init_req_callback AudioSystem::gVolRangeInitReqCallback = NULL;
76
77 std::mutex AudioSystem::gApsCallbackMutex;
78 std::mutex AudioSystem::gErrorCallbacksMutex;
79 std::set<audio_error_callback> AudioSystem::gAudioErrorCallbacks;
80
81 std::mutex AudioSystem::gSoundTriggerMutex;
82 sp<CaptureStateListenerImpl> AudioSystem::gSoundTriggerCaptureStateListener;
83
84 // ----------------------------
85
86 // AudioSystem is the client side interface to AudioFlinger (AF) and AudioPolicy (AP).
87 //
88 // For clients:
89 // We use the ServiceSingleton class in mediautils to fetch the AF/AP service.
90 // The ServiceSingleton offers service prefetch, automatic
91 // new service notification, automatic binder death notification.
92 //
93 // AudioFlingerServiceTraits and AudioPolicyServiceTraits are passed into
94 // ServiceSingleton to provide interaction with the service notifications and
95 // binder death notifications.
96 //
97 // If the AF/AP service is unavailable for kServiceClientWaitMs from ServiceManager,
98 // ServiceSingleton will return a nullptr service handle resulting in the same dead object error
99 // as if the service died (which it did, otherwise we'd be returning the cached handle).
100 //
101 // Potential deadlock sequence:
102 // 1) audioserver reboots.
103 // 2) App clients call into AudioService (system server) obtaining binder threads,
104 // these calls blocking for audioserver reboot completion (or waiting for a mutex
105 // held by those blocked threads).
106 // 3) AudioFlinger and AudioPolicyManager services need to call into system server
107 // during initialization. It can't because app clients hold all the binder threads
108 // in the threadpool.
109 // 4) We have a resource deadlock between (2) and (3) potentially causing an ANR and
110 // further reinitialization.
111 // 5) However, after the service wait timeout kServiceWaitNs, the calls for (2) will
112 // return an error and resolve itself, breaking the resource deadlock in (4).
113 //
114 // At this time, it is a matter of experimentation whether the service timeout is
115 // applied only for system server, and we let other clients block indefinitely.
116 //
117 // For audio services:
118 // AudioFlinger and AudioPolicy may call back into AudioSystem. When doing
119 // so it should not hold any mutexes. There is no service wait as AudioFlinger
120 // and AudioPolicy are in-process with each other, and the call proceeds without
121 // binder. The setLocalService() method is used to set the service interfaces
122 // within audioserver to bypass the ServiceManager lookup.
123 //
124
125 // Wait timeout for AudioFlinger or AudioPolicy service before returning with null.
126 // Such an audioserver failure is considered benign as the ground truth is stored in
127 // the Java AudioService and can be restored once audioserver has finished initialization.
128 //
129 // TODO(b/375691003) We use 5s as a conservative timeout value, and will tune closer to 3s.
130 // Too small a value (i.e. less than 1s would churn repeated calls to get the service).
131 // The value can be tuned by the property audio.service.client_wait_ms.
132 static constexpr int32_t kServiceClientWaitMs = 5'000;
133
134 static constexpr const char kServiceWaitProperty[] = "audio.service.client_wait_ms";
135
136 // AudioFlingerServiceTraits is a collection of methods that parameterize the
137 // ServiceSingleton handler for IAudioFlinger
138
139 class AudioFlingerServiceTraits {
140 public:
141 // ------- required by ServiceSingleton
142
getServiceName()143 static constexpr const char* getServiceName() { return "media.audio_flinger"; }
144
onNewService(const sp<media::IAudioFlingerService> & afs)145 static void onNewService(const sp<media::IAudioFlingerService>& afs) {
146 onNewServiceWithAdapter(createServiceAdapter(afs));
147 }
148
onServiceDied(const sp<media::IAudioFlingerService> & service)149 static void onServiceDied(const sp<media::IAudioFlingerService>& service) {
150 ALOGW("%s: %s service died %p", __func__, getServiceName(), service.get());
151 {
152 std::lock_guard l(mMutex);
153 if (!mValid) {
154 ALOGW("%s: %s service already invalidated, ignoring", __func__, getServiceName());
155 return;
156 }
157 if (!mService || mService->getDelegate() != service) {
158 ALOGW("%s: %s unmatched service death pointers, ignoring",
159 __func__, getServiceName());
160 return;
161 }
162 mValid = false;
163 if (mClient) {
164 mClient->clearIoCache();
165 } else {
166 ALOGW("%s: null client", __func__);
167 }
168 }
169 AudioSystem::reportError(DEAD_OBJECT);
170 }
171
options()172 static constexpr mediautils::ServiceOptions options() {
173 return mediautils::ServiceOptions::kNone;
174 }
175
176 // ------- required by AudioSystem
177
getService(std::chrono::milliseconds waitMs=std::chrono::milliseconds{-1})178 static sp<IAudioFlinger> getService(
179 std::chrono::milliseconds waitMs = std::chrono::milliseconds{-1}) {
180 static bool init = false;
181 audio_utils::unique_lock ul(mMutex);
182 if (!init) {
183 if (!mDisableThreadPoolStart) {
184 ProcessState::self()->startThreadPool();
185 }
186 if (multiuser_get_app_id(getuid()) == AID_AUDIOSERVER) {
187 mediautils::skipService<media::IAudioFlingerService>(mediautils::SkipMode::kWait);
188 mWaitMs = std::chrono::milliseconds(INT32_MAX);
189 } else {
190 mediautils::initService<media::IAudioFlingerService, AudioFlingerServiceTraits>();
191 mWaitMs = std::chrono::milliseconds(
192 property_get_int32(kServiceWaitProperty, kServiceClientWaitMs));
193 }
194 init = true;
195 }
196 if (mValid) return mService;
197 if (waitMs.count() < 0) waitMs = mWaitMs;
198 ul.unlock();
199
200 // mediautils::getService() installs a persistent new service notification.
201 auto service = mediautils::getService<
202 media::IAudioFlingerService>(waitMs);
203 ALOGD("%s: checking for service %s: %p", __func__, getServiceName(), service.get());
204
205 ul.lock();
206 // return the IAudioFlinger interface which is adapted
207 // from the media::IAudioFlingerService.
208 return mService;
209 }
210
getClient()211 static sp<AudioSystem::AudioFlingerClient> getClient() {
212 audio_utils::unique_lock ul(mMutex);
213 if (mValid) return mClient;
214 ul.unlock();
215
216 auto service = getService();
217 ALOGD("%s: checking for service: %p", __func__, service.get());
218
219 ul.lock();
220 return mClient;
221 }
222
setBinder(const sp<IBinder> & binder)223 static void setBinder(const sp<IBinder>& binder) {
224 setLocalService(createServiceAdapter(
225 mediautils::interfaceFromBinder<media::IAudioFlingerService>(binder)));
226 }
227
setLocalService(const sp<IAudioFlinger> & af)228 static status_t setLocalService(const sp<IAudioFlinger>& af) {
229 mediautils::skipService<media::IAudioFlingerService>();
230 sp<IAudioFlinger> old;
231
232 audio_utils::unique_lock ul(mMutex);
233 old = mService;
234 if (old) {
235 ul.unlock();
236 onServiceDied(old->getDelegate());
237 ul.lock();
238 ALOGW_IF(old != mService,
239 "%s: service changed during callback, continuing.", __func__);
240 }
241 mService = af;
242 ul.unlock();
243 if (af) onNewServiceWithAdapter(af);
244 return OK;
245 }
246
disableThreadPoolStart()247 static void disableThreadPoolStart() {
248 mDisableThreadPoolStart = true;
249 }
250
isValid()251 static bool isValid() {
252 audio_utils::unique_lock ul(mMutex);
253 if (mValid) return true;
254 ul.unlock();
255 (void)getService({});
256 ul.lock();
257 return mValid;
258 }
259
260 // called to determine error on nullptr service return.
getError()261 static constexpr status_t getError() {
262 return DEAD_OBJECT;
263 }
264
265 private:
266
onNewServiceWithAdapter(const sp<IAudioFlinger> & service)267 static void onNewServiceWithAdapter(const sp<IAudioFlinger>& service) {
268 ALOGD("%s: %s service obtained %p", __func__, getServiceName(), service.get());
269 sp<AudioSystem::AudioFlingerClient> client;
270 bool reportNoError = false;
271 {
272 std::lock_guard l(mMutex);
273 ALOGW_IF(mValid, "%s: %s service already valid, continuing with initialization",
274 __func__, getServiceName());
275 if (mClient == nullptr) {
276 mClient = sp<AudioSystem::AudioFlingerClient>::make();
277 } else {
278 mClient->clearIoCache();
279 reportNoError = true;
280 }
281 mService = service;
282 client = mClient;
283 mValid = true;
284 }
285 // TODO(b/375280520) consider registerClient() within mMutex lock.
286 const int64_t token = IPCThreadState::self()->clearCallingIdentity();
287 service->registerClient(client);
288 IPCThreadState::self()->restoreCallingIdentity(token);
289
290 if (reportNoError) AudioSystem::reportError(NO_ERROR);
291 }
292
createServiceAdapter(const sp<media::IAudioFlingerService> & af)293 static sp<IAudioFlinger> createServiceAdapter(
294 const sp<media::IAudioFlingerService>& af) {
295 return sp<AudioFlingerClientAdapter>::make(af);
296 }
297
298 static inline constinit std::mutex mMutex;
299 static inline constinit sp<AudioSystem::AudioFlingerClient> mClient GUARDED_BY(mMutex);
300 static inline constinit sp<IAudioFlinger> mService GUARDED_BY(mMutex);
301 static inline constinit std::chrono::milliseconds mWaitMs
GUARDED_BY(mMutex)302 GUARDED_BY(mMutex) {kServiceClientWaitMs};
303 static inline constinit bool mValid GUARDED_BY(mMutex) = false;
304 static inline constinit std::atomic_bool mDisableThreadPoolStart = false;
305 };
306
get_audio_flinger()307 sp<IAudioFlinger> AudioSystem::get_audio_flinger() {
308 return AudioFlingerServiceTraits::getService();
309 }
310
getAudioFlingerClient()311 sp<AudioSystem::AudioFlingerClient> AudioSystem::getAudioFlingerClient() {
312 return AudioFlingerServiceTraits::getClient();
313 }
314
setAudioFlingerBinder(const sp<IBinder> & audioFlinger)315 void AudioSystem::setAudioFlingerBinder(const sp<IBinder>& audioFlinger) {
316 AudioFlingerServiceTraits::setBinder(audioFlinger);
317 }
318
setLocalAudioFlinger(const sp<IAudioFlinger> & af)319 status_t AudioSystem::setLocalAudioFlinger(const sp<IAudioFlinger>& af) {
320 return AudioFlingerServiceTraits::setLocalService(af);
321 }
322
getIoDescriptor(audio_io_handle_t ioHandle)323 sp<AudioIoDescriptor> AudioSystem::getIoDescriptor(audio_io_handle_t ioHandle) {
324 sp<AudioIoDescriptor> desc;
325 const sp<AudioFlingerClient> afc = getAudioFlingerClient();
326 if (afc != 0) {
327 desc = afc->getIoDescriptor(ioHandle);
328 }
329 return desc;
330 }
331
checkAudioFlinger()332 /* static */ status_t AudioSystem::checkAudioFlinger() {
333 if (AudioFlingerServiceTraits::isValid()) return OK;
334 return DEAD_OBJECT;
335 }
336
337 // FIXME Declare in binder opcode order, similarly to IAudioFlinger.h and IAudioFlinger.cpp
338
muteMicrophone(bool state)339 status_t AudioSystem::muteMicrophone(bool state) {
340 const sp<IAudioFlinger> af = get_audio_flinger();
341 if (af == nullptr) return AudioFlingerServiceTraits::getError();
342 return af->setMicMute(state);
343 }
344
isMicrophoneMuted(bool * state)345 status_t AudioSystem::isMicrophoneMuted(bool* state) {
346 const sp<IAudioFlinger> af = get_audio_flinger();
347 if (af == nullptr) return AudioFlingerServiceTraits::getError();
348 *state = af->getMicMute();
349 return NO_ERROR;
350 }
351
setMasterVolume(float value)352 status_t AudioSystem::setMasterVolume(float value) {
353 const sp<IAudioFlinger> af = get_audio_flinger();
354 if (af == nullptr) return AudioFlingerServiceTraits::getError();
355 af->setMasterVolume(value);
356 return NO_ERROR;
357 }
358
setMasterMute(bool mute)359 status_t AudioSystem::setMasterMute(bool mute) {
360 const sp<IAudioFlinger> af = get_audio_flinger();
361 if (af == nullptr) return AudioFlingerServiceTraits::getError();
362 af->setMasterMute(mute);
363 return NO_ERROR;
364 }
365
getMasterVolume(float * volume)366 status_t AudioSystem::getMasterVolume(float* volume) {
367 const sp<IAudioFlinger> af = get_audio_flinger();
368 if (af == nullptr) return AudioFlingerServiceTraits::getError();
369 *volume = af->masterVolume();
370 return NO_ERROR;
371 }
372
getMasterMute(bool * mute)373 status_t AudioSystem::getMasterMute(bool* mute) {
374 const sp<IAudioFlinger> af = get_audio_flinger();
375 if (af == nullptr) return AudioFlingerServiceTraits::getError();
376 *mute = af->masterMute();
377 return NO_ERROR;
378 }
379
setStreamVolume(audio_stream_type_t stream,float value,bool muted,audio_io_handle_t output)380 status_t AudioSystem::setStreamVolume(audio_stream_type_t stream, float value,
381 bool muted, audio_io_handle_t output) {
382 if (uint32_t(stream) >= AUDIO_STREAM_CNT) return BAD_VALUE;
383 const sp<IAudioFlinger> af = get_audio_flinger();
384 if (af == nullptr) return AudioFlingerServiceTraits::getError();
385 af->setStreamVolume(stream, value, muted, output);
386 return NO_ERROR;
387 }
388
setStreamMute(audio_stream_type_t stream,bool mute)389 status_t AudioSystem::setStreamMute(audio_stream_type_t stream, bool mute) {
390 if (uint32_t(stream) >= AUDIO_STREAM_CNT) return BAD_VALUE;
391 const sp<IAudioFlinger> af = get_audio_flinger();
392 if (af == nullptr) return AudioFlingerServiceTraits::getError();
393 af->setStreamMute(stream, mute);
394 return NO_ERROR;
395 }
396
setPortsVolume(const std::vector<audio_port_handle_t> & portIds,float volume,bool muted,audio_io_handle_t output)397 status_t AudioSystem::setPortsVolume(
398 const std::vector<audio_port_handle_t>& portIds, float volume, bool muted,
399 audio_io_handle_t output) {
400 const sp<IAudioFlinger> af = get_audio_flinger();
401 if (af == nullptr) return AudioFlingerServiceTraits::getError();
402 std::vector<int32_t> portIdsAidl = VALUE_OR_RETURN_STATUS(
403 convertContainer<std::vector<int32_t>>(
404 portIds, legacy2aidl_audio_port_handle_t_int32_t));
405 int32_t outputAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(output));
406 af->setPortsVolume(portIdsAidl, volume, muted, outputAidl);
407 return NO_ERROR;
408 }
409
setMode(audio_mode_t mode)410 status_t AudioSystem::setMode(audio_mode_t mode) {
411 if (uint32_t(mode) >= AUDIO_MODE_CNT) return BAD_VALUE;
412 const sp<IAudioFlinger> af = get_audio_flinger();
413 if (af == nullptr) return AudioFlingerServiceTraits::getError();
414 return af->setMode(mode);
415 }
416
setSimulateDeviceConnections(bool enabled)417 status_t AudioSystem::setSimulateDeviceConnections(bool enabled) {
418 const sp<IAudioFlinger> af = get_audio_flinger();
419 if (af == nullptr) return AudioFlingerServiceTraits::getError();
420 return af->setSimulateDeviceConnections(enabled);
421 }
422
setParameters(audio_io_handle_t ioHandle,const String8 & keyValuePairs)423 status_t AudioSystem::setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs) {
424 const sp<IAudioFlinger> af = get_audio_flinger();
425 if (af == nullptr) return AudioFlingerServiceTraits::getError();
426 return af->setParameters(ioHandle, keyValuePairs);
427 }
428
getParameters(audio_io_handle_t ioHandle,const String8 & keys)429 String8 AudioSystem::getParameters(audio_io_handle_t ioHandle, const String8& keys) {
430 const sp<IAudioFlinger> af = get_audio_flinger();
431 String8 result = String8("");
432 if (af == nullptr) return result;
433
434 result = af->getParameters(ioHandle, keys);
435 return result;
436 }
437
setParameters(const String8 & keyValuePairs)438 status_t AudioSystem::setParameters(const String8& keyValuePairs) {
439 return setParameters(AUDIO_IO_HANDLE_NONE, keyValuePairs);
440 }
441
getParameters(const String8 & keys)442 String8 AudioSystem::getParameters(const String8& keys) {
443 return getParameters(AUDIO_IO_HANDLE_NONE, keys);
444 }
445
446 // convert volume steps to natural log scale
447
448 // change this value to change volume scaling
449 constexpr float kdbPerStep = 0.5f;
450 // shouldn't need to touch these
451 constexpr float kdBConvert = -kdbPerStep * 2.302585093f / 20.0f;
452 constexpr float kdBConvertInverse = 1.0f / kdBConvert;
453
linearToLog(int volume)454 float AudioSystem::linearToLog(int volume) {
455 // float v = volume ? exp(float(100 - volume) * kdBConvert) : 0;
456 // ALOGD("linearToLog(%d)=%f", volume, v);
457 // return v;
458 return volume ? exp(float(100 - volume) * kdBConvert) : 0;
459 }
460
logToLinear(float volume)461 int AudioSystem::logToLinear(float volume) {
462 // int v = volume ? 100 - int(kdBConvertInverse * log(volume) + 0.5) : 0;
463 // ALOGD("logTolinear(%d)=%f", v, volume);
464 // return v;
465 return volume ? 100 - int(kdBConvertInverse * log(volume) + 0.5) : 0;
466 }
467
calculateMinFrameCount(uint32_t afLatencyMs,uint32_t afFrameCount,uint32_t afSampleRate,uint32_t sampleRate,float speed)468 /* static */ size_t AudioSystem::calculateMinFrameCount(
469 uint32_t afLatencyMs, uint32_t afFrameCount, uint32_t afSampleRate,
470 uint32_t sampleRate, float speed /*, uint32_t notificationsPerBufferReq*/) {
471 // Ensure that buffer depth covers at least audio hardware latency
472 uint32_t minBufCount = afLatencyMs / ((1000 * afFrameCount) / afSampleRate);
473 if (minBufCount < 2) {
474 minBufCount = 2;
475 }
476 #if 0
477 // The notificationsPerBufferReq parameter is not yet used for non-fast tracks,
478 // but keeping the code here to make it easier to add later.
479 if (minBufCount < notificationsPerBufferReq) {
480 minBufCount = notificationsPerBufferReq;
481 }
482 #endif
483 ALOGV("calculateMinFrameCount afLatency %u afFrameCount %u afSampleRate %u "
484 "sampleRate %u speed %f minBufCount: %u" /*" notificationsPerBufferReq %u"*/,
485 afLatencyMs, afFrameCount, afSampleRate, sampleRate, speed, minBufCount
486 /*, notificationsPerBufferReq*/);
487 return minBufCount * sourceFramesNeededWithTimestretch(
488 sampleRate, afFrameCount, afSampleRate, speed);
489 }
490
491
492 status_t
getOutputSamplingRate(uint32_t * samplingRate,audio_stream_type_t streamType)493 AudioSystem::getOutputSamplingRate(uint32_t* samplingRate, audio_stream_type_t streamType) {
494 audio_io_handle_t output;
495
496 if (streamType == AUDIO_STREAM_DEFAULT) {
497 streamType = AUDIO_STREAM_MUSIC;
498 }
499
500 output = getOutput(streamType);
501 if (output == 0) {
502 return PERMISSION_DENIED;
503 }
504
505 return getSamplingRate(output, samplingRate);
506 }
507
getSamplingRate(audio_io_handle_t ioHandle,uint32_t * samplingRate)508 status_t AudioSystem::getSamplingRate(audio_io_handle_t ioHandle,
509 uint32_t* samplingRate) {
510 const sp<IAudioFlinger> af = get_audio_flinger();
511 if (af == nullptr) return AudioFlingerServiceTraits::getError();
512 sp<AudioIoDescriptor> desc = getIoDescriptor(ioHandle);
513 if (desc == 0) {
514 *samplingRate = af->sampleRate(ioHandle);
515 } else {
516 *samplingRate = desc->getSamplingRate();
517 }
518 if (*samplingRate == 0) {
519 ALOGE("AudioSystem::getSamplingRate failed for ioHandle %d", ioHandle);
520 return BAD_VALUE;
521 }
522
523 ALOGV("getSamplingRate() ioHandle %d, sampling rate %u", ioHandle, *samplingRate);
524
525 return NO_ERROR;
526 }
527
getOutputFrameCount(size_t * frameCount,audio_stream_type_t streamType)528 status_t AudioSystem::getOutputFrameCount(size_t* frameCount, audio_stream_type_t streamType) {
529 audio_io_handle_t output;
530
531 if (streamType == AUDIO_STREAM_DEFAULT) {
532 streamType = AUDIO_STREAM_MUSIC;
533 }
534
535 output = getOutput(streamType);
536 if (output == AUDIO_IO_HANDLE_NONE) {
537 return PERMISSION_DENIED;
538 }
539
540 return getFrameCount(output, frameCount);
541 }
542
getFrameCount(audio_io_handle_t ioHandle,size_t * frameCount)543 status_t AudioSystem::getFrameCount(audio_io_handle_t ioHandle,
544 size_t* frameCount) {
545 const sp<IAudioFlinger> af = get_audio_flinger();
546 if (af == nullptr) return AudioFlingerServiceTraits::getError();
547 sp<AudioIoDescriptor> desc = getIoDescriptor(ioHandle);
548 if (desc == 0) {
549 *frameCount = af->frameCount(ioHandle);
550 } else {
551 *frameCount = desc->getFrameCount();
552 }
553 if (*frameCount == 0) {
554 ALOGE("AudioSystem::getFrameCount failed for ioHandle %d", ioHandle);
555 return BAD_VALUE;
556 }
557
558 ALOGV("getFrameCount() ioHandle %d, frameCount %zu", ioHandle, *frameCount);
559
560 return NO_ERROR;
561 }
562
getOutputLatency(uint32_t * latency,audio_stream_type_t streamType)563 status_t AudioSystem::getOutputLatency(uint32_t* latency, audio_stream_type_t streamType) {
564 audio_io_handle_t output;
565
566 if (streamType == AUDIO_STREAM_DEFAULT) {
567 streamType = AUDIO_STREAM_MUSIC;
568 }
569
570 output = getOutput(streamType);
571 if (output == AUDIO_IO_HANDLE_NONE) {
572 return PERMISSION_DENIED;
573 }
574
575 return getLatency(output, latency);
576 }
577
getLatency(audio_io_handle_t output,uint32_t * latency)578 status_t AudioSystem::getLatency(audio_io_handle_t output,
579 uint32_t* latency) {
580 const sp<IAudioFlinger> af = get_audio_flinger();
581 if (af == nullptr) return AudioFlingerServiceTraits::getError();
582 sp<AudioIoDescriptor> outputDesc = getIoDescriptor(output);
583 if (outputDesc == 0) {
584 *latency = af->latency(output);
585 } else {
586 *latency = outputDesc->getLatency();
587 }
588
589 ALOGV("getLatency() output %d, latency %d", output, *latency);
590
591 return NO_ERROR;
592 }
593
getInputBufferSize(uint32_t sampleRate,audio_format_t format,audio_channel_mask_t channelMask,size_t * buffSize)594 status_t AudioSystem::getInputBufferSize(uint32_t sampleRate, audio_format_t format,
595 audio_channel_mask_t channelMask, size_t* buffSize) {
596 const sp<AudioFlingerClient> afc = getAudioFlingerClient();
597 if (afc == 0) {
598 return NO_INIT;
599 }
600 return afc->getInputBufferSize(sampleRate, format, channelMask, buffSize);
601 }
602
setVoiceVolume(float value)603 status_t AudioSystem::setVoiceVolume(float value) {
604 const sp<IAudioFlinger> af = get_audio_flinger();
605 if (af == nullptr) return AudioFlingerServiceTraits::getError();
606 return af->setVoiceVolume(value);
607 }
608
getRenderPosition(audio_io_handle_t output,uint32_t * halFrames,uint32_t * dspFrames)609 status_t AudioSystem::getRenderPosition(audio_io_handle_t output, uint32_t* halFrames,
610 uint32_t* dspFrames) {
611 const sp<IAudioFlinger> af = get_audio_flinger();
612 if (af == nullptr) return AudioFlingerServiceTraits::getError();
613
614 return af->getRenderPosition(halFrames, dspFrames, output);
615 }
616
getInputFramesLost(audio_io_handle_t ioHandle)617 uint32_t AudioSystem::getInputFramesLost(audio_io_handle_t ioHandle) {
618 const sp<IAudioFlinger> af = get_audio_flinger();
619 uint32_t result = 0;
620 if (af == nullptr) return result;
621 if (ioHandle == AUDIO_IO_HANDLE_NONE) return result;
622
623 result = af->getInputFramesLost(ioHandle);
624 return result;
625 }
626
newAudioUniqueId(audio_unique_id_use_t use)627 audio_unique_id_t AudioSystem::newAudioUniqueId(audio_unique_id_use_t use) {
628 // Must not use AF as IDs will re-roll on audioserver restart, b/130369529.
629 const sp<IAudioFlinger> af = get_audio_flinger();
630 if (af == nullptr) return AUDIO_UNIQUE_ID_ALLOCATE;
631 return af->newAudioUniqueId(use);
632 }
633
acquireAudioSessionId(audio_session_t audioSession,pid_t pid,uid_t uid)634 void AudioSystem::acquireAudioSessionId(audio_session_t audioSession, pid_t pid, uid_t uid) {
635 const sp<IAudioFlinger> af = get_audio_flinger();
636 if (af != 0) {
637 af->acquireAudioSessionId(audioSession, pid, uid);
638 }
639 }
640
releaseAudioSessionId(audio_session_t audioSession,pid_t pid)641 void AudioSystem::releaseAudioSessionId(audio_session_t audioSession, pid_t pid) {
642 const sp<IAudioFlinger> af = get_audio_flinger();
643 if (af != 0) {
644 af->releaseAudioSessionId(audioSession, pid);
645 }
646 }
647
getAudioHwSyncForSession(audio_session_t sessionId)648 audio_hw_sync_t AudioSystem::getAudioHwSyncForSession(audio_session_t sessionId) {
649 const sp<IAudioFlinger> af = get_audio_flinger();
650 if (af == nullptr) return AUDIO_HW_SYNC_INVALID;
651 return af->getAudioHwSyncForSession(sessionId);
652 }
653
systemReady()654 status_t AudioSystem::systemReady() {
655 const sp<IAudioFlinger> af = get_audio_flinger();
656 if (af == nullptr) return NO_INIT;
657 return af->systemReady();
658 }
659
audioPolicyReady()660 status_t AudioSystem::audioPolicyReady() {
661 const sp<IAudioFlinger> af = get_audio_flinger();
662 if (af == nullptr) return NO_INIT;
663 return af->audioPolicyReady();
664 }
665
getFrameCountHAL(audio_io_handle_t ioHandle,size_t * frameCount)666 status_t AudioSystem::getFrameCountHAL(audio_io_handle_t ioHandle,
667 size_t* frameCount) {
668 const sp<IAudioFlinger> af = get_audio_flinger();
669 if (af == nullptr) return AudioFlingerServiceTraits::getError();
670 sp<AudioIoDescriptor> desc = getIoDescriptor(ioHandle);
671 if (desc == 0) {
672 *frameCount = af->frameCountHAL(ioHandle);
673 } else {
674 *frameCount = desc->getFrameCountHAL();
675 }
676 if (*frameCount == 0) {
677 ALOGE("AudioSystem::getFrameCountHAL failed for ioHandle %d", ioHandle);
678 return BAD_VALUE;
679 }
680
681 ALOGV("getFrameCountHAL() ioHandle %d, frameCount %zu", ioHandle, *frameCount);
682
683 return NO_ERROR;
684 }
685
686 // ---------------------------------------------------------------------------
687
688
clearIoCache()689 void AudioSystem::AudioFlingerClient::clearIoCache() {
690 std::lock_guard _l(mMutex);
691 mIoDescriptors.clear();
692 mInBuffSize = 0;
693 mInSamplingRate = 0;
694 mInFormat = AUDIO_FORMAT_DEFAULT;
695 mInChannelMask = AUDIO_CHANNEL_NONE;
696 }
697
ioConfigChanged(media::AudioIoConfigEvent _event,const media::AudioIoDescriptor & _ioDesc)698 Status AudioSystem::AudioFlingerClient::ioConfigChanged(
699 media::AudioIoConfigEvent _event,
700 const media::AudioIoDescriptor& _ioDesc) {
701 audio_io_config_event_t event = VALUE_OR_RETURN_BINDER_STATUS(
702 aidl2legacy_AudioIoConfigEvent_audio_io_config_event_t(_event));
703 sp<AudioIoDescriptor> ioDesc(
704 VALUE_OR_RETURN_BINDER_STATUS(
705 aidl2legacy_AudioIoDescriptor_AudioIoDescriptor(_ioDesc)));
706
707 ALOGV("ioConfigChanged() event %d", event);
708
709 if (ioDesc->getIoHandle() == AUDIO_IO_HANDLE_NONE) return Status::ok();
710
711 DeviceIdVector deviceIds;
712 std::vector<sp<AudioDeviceCallback>> callbacksToCall;
713 {
714 std::lock_guard _l(mMutex);
715 auto callbacks = std::map<audio_port_handle_t, wp<AudioDeviceCallback>>();
716
717 switch (event) {
718 case AUDIO_OUTPUT_OPENED:
719 case AUDIO_OUTPUT_REGISTERED:
720 case AUDIO_INPUT_OPENED:
721 case AUDIO_INPUT_REGISTERED: {
722 if (sp<AudioIoDescriptor> oldDesc = getIoDescriptor_l(ioDesc->getIoHandle())) {
723 deviceIds = oldDesc->getDeviceIds();
724 }
725 mIoDescriptors[ioDesc->getIoHandle()] = ioDesc;
726
727 if (!ioDesc->getDeviceIds().empty()) {
728 deviceIds = ioDesc->getDeviceIds();
729 if (event == AUDIO_OUTPUT_OPENED || event == AUDIO_INPUT_OPENED) {
730 auto it = mAudioDeviceCallbacks.find(ioDesc->getIoHandle());
731 if (it != mAudioDeviceCallbacks.end()) {
732 callbacks = it->second;
733 }
734 }
735 }
736 ALOGV("ioConfigChanged() new %s %s %s",
737 event == AUDIO_OUTPUT_OPENED || event == AUDIO_OUTPUT_REGISTERED ?
738 "output" : "input",
739 event == AUDIO_OUTPUT_OPENED || event == AUDIO_INPUT_OPENED ?
740 "opened" : "registered",
741 ioDesc->toDebugString().c_str());
742 }
743 break;
744 case AUDIO_OUTPUT_CLOSED:
745 case AUDIO_INPUT_CLOSED: {
746 if (getIoDescriptor_l(ioDesc->getIoHandle()) == 0) {
747 ALOGW("ioConfigChanged() closing unknown %s %d",
748 event == AUDIO_OUTPUT_CLOSED ? "output" : "input", ioDesc->getIoHandle());
749 break;
750 }
751 ALOGV("ioConfigChanged() %s %d closed",
752 event == AUDIO_OUTPUT_CLOSED ? "output" : "input", ioDesc->getIoHandle());
753
754 mIoDescriptors.erase(ioDesc->getIoHandle());
755 mAudioDeviceCallbacks.erase(ioDesc->getIoHandle());
756 }
757 break;
758
759 case AUDIO_OUTPUT_CONFIG_CHANGED:
760 case AUDIO_INPUT_CONFIG_CHANGED: {
761 sp<AudioIoDescriptor> oldDesc = getIoDescriptor_l(ioDesc->getIoHandle());
762 if (oldDesc == 0) {
763 ALOGW("ioConfigChanged() modifying unknown %s! %d",
764 event == AUDIO_OUTPUT_CONFIG_CHANGED ? "output" : "input",
765 ioDesc->getIoHandle());
766 break;
767 }
768
769 deviceIds = oldDesc->getDeviceIds();
770 mIoDescriptors[ioDesc->getIoHandle()] = ioDesc;
771
772 DeviceIdVector ioDescDeviceIds = ioDesc->getDeviceIds();
773 if (!areDeviceIdsEqual(deviceIds, ioDescDeviceIds)) {
774 deviceIds = ioDescDeviceIds;
775 auto it = mAudioDeviceCallbacks.find(ioDesc->getIoHandle());
776 if (it != mAudioDeviceCallbacks.end()) {
777 callbacks = it->second;
778 }
779 }
780 ALOGV("ioConfigChanged() new config for %s %s",
781 event == AUDIO_OUTPUT_CONFIG_CHANGED ? "output" : "input",
782 ioDesc->toDebugString().c_str());
783
784 }
785 break;
786 case AUDIO_CLIENT_STARTED: {
787 sp<AudioIoDescriptor> oldDesc = getIoDescriptor_l(ioDesc->getIoHandle());
788 if (oldDesc == 0) {
789 ALOGW("ioConfigChanged() start client on unknown io! %d",
790 ioDesc->getIoHandle());
791 break;
792 }
793 ALOGV("ioConfigChanged() AUDIO_CLIENT_STARTED io %d port %d num callbacks %zu",
794 ioDesc->getIoHandle(), ioDesc->getPortId(), mAudioDeviceCallbacks.size());
795 oldDesc->setPatch(ioDesc->getPatch());
796 auto it = mAudioDeviceCallbacks.find(ioDesc->getIoHandle());
797 if (it != mAudioDeviceCallbacks.end()) {
798 auto cbks = it->second;
799 auto it2 = cbks.find(ioDesc->getPortId());
800 if (it2 != cbks.end()) {
801 callbacks.emplace(ioDesc->getPortId(), it2->second);
802 deviceIds = oldDesc->getDeviceIds();
803 }
804 }
805 }
806 break;
807 }
808
809 for (auto wpCbk : callbacks) {
810 sp<AudioDeviceCallback> spCbk = wpCbk.second.promote();
811 if (spCbk != nullptr) {
812 callbacksToCall.push_back(spCbk);
813 }
814 }
815 }
816
817 // Callbacks must be called without mMutex held. May lead to dead lock if calling for
818 // example getRoutedDevice that updates the device and tries to acquire mMutex.
819 for (auto cb : callbacksToCall) {
820 // If callbacksToCall is not empty, it implies ioDesc->getIoHandle() and deviceId are valid
821 cb->onAudioDeviceUpdate(ioDesc->getIoHandle(), deviceIds);
822 }
823
824 return Status::ok();
825 }
826
onSupportedLatencyModesChanged(int output,const std::vector<media::audio::common::AudioLatencyMode> & latencyModes)827 Status AudioSystem::AudioFlingerClient::onSupportedLatencyModesChanged(
828 int output, const std::vector<media::audio::common::AudioLatencyMode>& latencyModes) {
829 audio_io_handle_t outputLegacy = VALUE_OR_RETURN_BINDER_STATUS(
830 aidl2legacy_int32_t_audio_io_handle_t(output));
831 std::vector<audio_latency_mode_t> modesLegacy = VALUE_OR_RETURN_BINDER_STATUS(
832 convertContainer<std::vector<audio_latency_mode_t>>(
833 latencyModes, aidl2legacy_AudioLatencyMode_audio_latency_mode_t));
834
835 std::vector<sp<SupportedLatencyModesCallback>> callbacks;
836 {
837 std::lock_guard _l(mMutex);
838 for (auto callback : mSupportedLatencyModesCallbacks) {
839 if (auto ref = callback.promote(); ref != nullptr) {
840 callbacks.push_back(ref);
841 }
842 }
843 }
844 for (const auto& callback : callbacks) {
845 callback->onSupportedLatencyModesChanged(outputLegacy, modesLegacy);
846 }
847
848 return Status::ok();
849 }
850
getInputBufferSize(uint32_t sampleRate,audio_format_t format,audio_channel_mask_t channelMask,size_t * buffSize)851 status_t AudioSystem::AudioFlingerClient::getInputBufferSize(
852 uint32_t sampleRate, audio_format_t format,
853 audio_channel_mask_t channelMask, size_t* buffSize) {
854 const sp<IAudioFlinger> af = get_audio_flinger();
855 if (af == nullptr) return AudioFlingerServiceTraits::getError();
856 std::lock_guard _l(mMutex);
857 // Do we have a stale mInBuffSize or are we requesting the input buffer size for new values
858 if ((mInBuffSize == 0) || (sampleRate != mInSamplingRate) || (format != mInFormat)
859 || (channelMask != mInChannelMask)) {
860 size_t inBuffSize = af->getInputBufferSize(sampleRate, format, channelMask);
861 if (inBuffSize == 0) {
862 ALOGE("AudioSystem::getInputBufferSize failed sampleRate %d format %#x channelMask %#x",
863 sampleRate, format, channelMask);
864 return BAD_VALUE;
865 }
866 // A benign race is possible here: we could overwrite a fresher cache entry
867 // save the request params
868 mInSamplingRate = sampleRate;
869 mInFormat = format;
870 mInChannelMask = channelMask;
871
872 mInBuffSize = inBuffSize;
873 }
874
875 *buffSize = mInBuffSize;
876
877 return NO_ERROR;
878 }
879
880 sp<AudioIoDescriptor>
getIoDescriptor_l(audio_io_handle_t ioHandle)881 AudioSystem::AudioFlingerClient::getIoDescriptor_l(audio_io_handle_t ioHandle) {
882 if (const auto it = mIoDescriptors.find(ioHandle);
883 it != mIoDescriptors.end()) {
884 return it->second;
885 }
886 return {};
887 }
888
getIoDescriptor(audio_io_handle_t ioHandle)889 sp<AudioIoDescriptor> AudioSystem::AudioFlingerClient::getIoDescriptor(audio_io_handle_t ioHandle) {
890 std::lock_guard _l(mMutex);
891 return getIoDescriptor_l(ioHandle);
892 }
893
addAudioDeviceCallback(const wp<AudioDeviceCallback> & callback,audio_io_handle_t audioIo,audio_port_handle_t portId)894 status_t AudioSystem::AudioFlingerClient::addAudioDeviceCallback(
895 const wp<AudioDeviceCallback>& callback, audio_io_handle_t audioIo,
896 audio_port_handle_t portId) {
897 ALOGV("%s audioIo %d portId %d", __func__, audioIo, portId);
898 std::lock_guard _l(mMutex);
899 auto& callbacks = mAudioDeviceCallbacks.emplace(
900 audioIo,
901 std::map<audio_port_handle_t, wp<AudioDeviceCallback>>()).first->second;
902 auto result = callbacks.try_emplace(portId, callback);
903 if (!result.second) {
904 return INVALID_OPERATION;
905 }
906 return NO_ERROR;
907 }
908
removeAudioDeviceCallback(const wp<AudioDeviceCallback> & callback __unused,audio_io_handle_t audioIo,audio_port_handle_t portId)909 status_t AudioSystem::AudioFlingerClient::removeAudioDeviceCallback(
910 const wp<AudioDeviceCallback>& callback __unused, audio_io_handle_t audioIo,
911 audio_port_handle_t portId) {
912 ALOGV("%s audioIo %d portId %d", __func__, audioIo, portId);
913 std::lock_guard _l(mMutex);
914 auto it = mAudioDeviceCallbacks.find(audioIo);
915 if (it == mAudioDeviceCallbacks.end()) {
916 return INVALID_OPERATION;
917 }
918 if (it->second.erase(portId) == 0) {
919 return INVALID_OPERATION;
920 }
921 if (it->second.size() == 0) {
922 mAudioDeviceCallbacks.erase(audioIo);
923 }
924 return NO_ERROR;
925 }
926
addSupportedLatencyModesCallback(const sp<SupportedLatencyModesCallback> & callback)927 status_t AudioSystem::AudioFlingerClient::addSupportedLatencyModesCallback(
928 const sp<SupportedLatencyModesCallback>& callback) {
929 std::lock_guard _l(mMutex);
930 if (std::find(mSupportedLatencyModesCallbacks.begin(),
931 mSupportedLatencyModesCallbacks.end(),
932 callback) != mSupportedLatencyModesCallbacks.end()) {
933 return INVALID_OPERATION;
934 }
935 mSupportedLatencyModesCallbacks.push_back(callback);
936 return NO_ERROR;
937 }
938
removeSupportedLatencyModesCallback(const sp<SupportedLatencyModesCallback> & callback)939 status_t AudioSystem::AudioFlingerClient::removeSupportedLatencyModesCallback(
940 const sp<SupportedLatencyModesCallback>& callback) {
941 std::lock_guard _l(mMutex);
942 auto it = std::find(mSupportedLatencyModesCallbacks.begin(),
943 mSupportedLatencyModesCallbacks.end(),
944 callback);
945 if (it == mSupportedLatencyModesCallbacks.end()) {
946 return INVALID_OPERATION;
947 }
948 mSupportedLatencyModesCallbacks.erase(it);
949 return NO_ERROR;
950 }
951
addErrorCallback(audio_error_callback cb)952 /* static */ uintptr_t AudioSystem::addErrorCallback(audio_error_callback cb) {
953 std::lock_guard _l(gErrorCallbacksMutex);
954 gAudioErrorCallbacks.insert(cb);
955 return reinterpret_cast<uintptr_t>(cb);
956 }
957
removeErrorCallback(uintptr_t cb)958 /* static */ void AudioSystem::removeErrorCallback(uintptr_t cb) {
959 std::lock_guard _l(gErrorCallbacksMutex);
960 gAudioErrorCallbacks.erase(reinterpret_cast<audio_error_callback>(cb));
961 }
962
reportError(status_t err)963 /* static */ void AudioSystem::reportError(status_t err) {
964 std::lock_guard _l(gErrorCallbacksMutex);
965 for (auto callback : gAudioErrorCallbacks) {
966 callback(err);
967 }
968 }
969
setDynPolicyCallback(dynamic_policy_callback cb)970 /*static*/ void AudioSystem::setDynPolicyCallback(dynamic_policy_callback cb) {
971 std::lock_guard _l(gMutex);
972 gDynPolicyCallback = cb;
973 }
974
setRecordConfigCallback(record_config_callback cb)975 /*static*/ void AudioSystem::setRecordConfigCallback(record_config_callback cb) {
976 std::lock_guard _l(gMutex);
977 gRecordConfigCallback = cb;
978 }
979
setRoutingCallback(routing_callback cb)980 /*static*/ void AudioSystem::setRoutingCallback(routing_callback cb) {
981 std::lock_guard _l(gMutex);
982 gRoutingCallback = cb;
983 }
984
setVolInitReqCallback(vol_range_init_req_callback cb)985 /*static*/ void AudioSystem::setVolInitReqCallback(vol_range_init_req_callback cb) {
986 std::lock_guard _l(gMutex);
987 gVolRangeInitReqCallback = cb;
988 }
989
990
991 // AudioPolicyServiceTraits is a collection of methods that parameterize the
992 // ServiceSingleton class implementation of IAudioPolicyService.
993
994 class AudioPolicyServiceTraits {
995 public:
996 // ------- methods required by ServiceSingleton
997
getServiceName()998 static constexpr const char* getServiceName() { return "media.audio_policy"; }
999
onNewService(const sp<IAudioPolicyService> & aps)1000 static void onNewService(const sp<IAudioPolicyService>& aps) {
1001 ALOGD("%s: %s service obtained %p", __func__, getServiceName(), aps.get());
1002 sp<AudioSystem::AudioPolicyServiceClient> client;
1003 {
1004 std::lock_guard l(mMutex);
1005 ALOGW_IF(mValid, "%s: %s service already valid, continuing with initialization",
1006 __func__, getServiceName());
1007 if (mClient == nullptr) {
1008 mClient = sp<AudioSystem::AudioPolicyServiceClient>::make();
1009 }
1010 client = mClient;
1011 mService = aps;
1012 mValid = true;
1013 }
1014 // TODO(b/375280520) consider registerClient() within mMutex lock.
1015 const int64_t token = IPCThreadState::self()->clearCallingIdentity();
1016 aps->registerClient(client);
1017 aps->setAudioPortCallbacksEnabled(client->isAudioPortCbEnabled());
1018 aps->setAudioVolumeGroupCallbacksEnabled(client->isAudioVolumeGroupCbEnabled());
1019 IPCThreadState::self()->restoreCallingIdentity(token);
1020 }
1021
onServiceDied(const sp<IAudioPolicyService> & service)1022 static void onServiceDied(const sp<IAudioPolicyService>& service) {
1023 ALOGW("%s: %s service died %p", __func__, getServiceName(), service.get());
1024 sp<AudioSystem::AudioPolicyServiceClient> client;
1025 {
1026 std::lock_guard l(mMutex);
1027 if (!mValid) {
1028 ALOGW("%s: %s service already invalidated, ignoring", __func__, getServiceName());
1029 return;
1030 }
1031 if (mService != service) {
1032 ALOGW("%s: %s unmatched service death pointers, ignoring",
1033 __func__, getServiceName());
1034 return;
1035 }
1036 mValid = false;
1037 client = mClient;
1038 }
1039 if (client) {
1040 client->onServiceDied();
1041 } else {
1042 ALOGW("%s: null client", __func__);
1043 }
1044 }
1045
options()1046 static constexpr mediautils::ServiceOptions options() {
1047 return mediautils::ServiceOptions::kNone;
1048 }
1049
1050 // ------- methods required by AudioSystem
1051
getService(std::chrono::milliseconds waitMs=std::chrono::milliseconds{-1})1052 static sp<IAudioPolicyService> getService(
1053 std::chrono::milliseconds waitMs = std::chrono::milliseconds{-1}) {
1054 static bool init = false;
1055 audio_utils::unique_lock ul(mMutex);
1056 if (!init) {
1057 if (!mDisableThreadPoolStart) {
1058 ProcessState::self()->startThreadPool();
1059 }
1060 if (multiuser_get_app_id(getuid()) == AID_AUDIOSERVER) {
1061 mediautils::skipService<IAudioPolicyService>(mediautils::SkipMode::kWait);
1062 mWaitMs = std::chrono::milliseconds(INT32_MAX);
1063 } else {
1064 mediautils::initService<IAudioPolicyService, AudioPolicyServiceTraits>();
1065 mWaitMs = std::chrono::milliseconds(
1066 property_get_int32(kServiceWaitProperty, kServiceClientWaitMs));
1067 }
1068 init = true;
1069 }
1070 if (mValid) return mService;
1071 if (waitMs.count() < 0) waitMs = mWaitMs;
1072 ul.unlock();
1073
1074 auto service = mediautils::getService<
1075 media::IAudioPolicyService>(waitMs);
1076 ALOGD("%s: checking for service %s: %p", __func__, getServiceName(), service.get());
1077
1078 // mediautils::getService() will return early if setLocalService() is called
1079 // (whereupon mService contained the actual local service pointer to use).
1080 // we should always return mService.
1081 ul.lock();
1082 return mService;
1083 }
1084
getClient()1085 static sp<AudioSystem::AudioPolicyServiceClient> getClient() {
1086 audio_utils::unique_lock ul(mMutex);
1087 if (mValid) return mClient;
1088 ul.unlock();
1089
1090 auto service = getService();
1091 ALOGD("%s: checking for service: %p", __func__, service.get());
1092
1093 ul.lock();
1094 return mClient;
1095 }
1096
setLocalService(const sp<IAudioPolicyService> & aps)1097 static status_t setLocalService(const sp<IAudioPolicyService>& aps) {
1098 mediautils::skipService<IAudioPolicyService>();
1099 sp<IAudioPolicyService> old;
1100 audio_utils::unique_lock ul(mMutex);
1101 old = mService;
1102 if (old) {
1103 ul.unlock();
1104 onServiceDied(old);
1105 ul.lock();
1106 if (mService != old) {
1107 ALOGD("%s: service changed during callback, ignoring.", __func__);
1108 return OK;
1109 }
1110 }
1111 mService = aps;
1112 ul.unlock();
1113 if (aps) onNewService(aps);
1114 return OK;
1115 }
1116
disableThreadPoolStart()1117 static void disableThreadPoolStart() {
1118 mDisableThreadPoolStart = true;
1119 }
1120
1121 // called to determine error on nullptr service return.
getError()1122 static constexpr status_t getError() {
1123 return DEAD_OBJECT;
1124 }
1125 private:
1126
1127 static inline constinit std::mutex mMutex;
1128 static inline constinit sp<AudioSystem::AudioPolicyServiceClient> mClient GUARDED_BY(mMutex);
1129 static inline constinit sp<IAudioPolicyService> mService GUARDED_BY(mMutex);
1130 static inline constinit bool mValid GUARDED_BY(mMutex) = false;
1131 static inline constinit std::chrono::milliseconds mWaitMs
GUARDED_BY(mMutex)1132 GUARDED_BY(mMutex) {kServiceClientWaitMs};
1133 static inline constinit std::atomic_bool mDisableThreadPoolStart = false;
1134 };
1135
1136
get_audio_policy_service()1137 sp<IAudioPolicyService> AudioSystem::get_audio_policy_service() {
1138 return AudioPolicyServiceTraits::getService();
1139 }
1140
setLocalAudioPolicyService(const sp<IAudioPolicyService> & aps)1141 status_t AudioSystem::setLocalAudioPolicyService(const sp<IAudioPolicyService>& aps) {
1142 return AudioPolicyServiceTraits::setLocalService(aps);
1143 }
1144
getAudioPolicyClient()1145 sp<AudioSystem::AudioPolicyServiceClient> AudioSystem::getAudioPolicyClient() {
1146 return AudioPolicyServiceTraits::getClient();
1147 }
1148
disableThreadPool()1149 void AudioSystem::disableThreadPool() {
1150 AudioFlingerServiceTraits::disableThreadPoolStart();
1151 AudioPolicyServiceTraits::disableThreadPoolStart();
1152 }
1153
1154 // ---------------------------------------------------------------------------
1155
onNewAudioModulesAvailable()1156 void AudioSystem::onNewAudioModulesAvailable() {
1157 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1158 if (aps == nullptr) return;
1159 aps->onNewAudioModulesAvailable();
1160 }
1161
setDeviceConnectionState(audio_policy_dev_state_t state,const android::media::audio::common::AudioPort & port,audio_format_t encodedFormat)1162 status_t AudioSystem::setDeviceConnectionState(audio_policy_dev_state_t state,
1163 const android::media::audio::common::AudioPort& port,
1164 audio_format_t encodedFormat) {
1165 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1166
1167 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
1168
1169 return statusTFromBinderStatus(
1170 aps->setDeviceConnectionState(
1171 VALUE_OR_RETURN_STATUS(
1172 legacy2aidl_audio_policy_dev_state_t_AudioPolicyDeviceState(state)),
1173 port,
1174 VALUE_OR_RETURN_STATUS(
1175 legacy2aidl_audio_format_t_AudioFormatDescription(encodedFormat))));
1176 }
1177
getDeviceConnectionState(audio_devices_t device,const char * device_address)1178 audio_policy_dev_state_t AudioSystem::getDeviceConnectionState(audio_devices_t device,
1179 const char* device_address) {
1180 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1181 if (aps == nullptr) return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE;
1182
1183 auto result = [&]() -> ConversionResult<audio_policy_dev_state_t> {
1184 AudioDevice deviceAidl = VALUE_OR_RETURN(
1185 legacy2aidl_audio_device_AudioDevice(device, device_address));
1186
1187 media::AudioPolicyDeviceState result;
1188 RETURN_IF_ERROR(statusTFromBinderStatus(
1189 aps->getDeviceConnectionState(deviceAidl, &result)));
1190
1191 return aidl2legacy_AudioPolicyDeviceState_audio_policy_dev_state_t(result);
1192 }();
1193 return result.value_or(AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE);
1194 }
1195
handleDeviceConfigChange(audio_devices_t device,const char * device_address,const char * device_name,audio_format_t encodedFormat)1196 status_t AudioSystem::handleDeviceConfigChange(audio_devices_t device,
1197 const char* device_address,
1198 const char* device_name,
1199 audio_format_t encodedFormat) {
1200 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1201 const char* address = "";
1202 const char* name = "";
1203
1204 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
1205
1206 if (device_address != NULL) {
1207 address = device_address;
1208 }
1209 if (device_name != NULL) {
1210 name = device_name;
1211 }
1212
1213 AudioDevice deviceAidl = VALUE_OR_RETURN_STATUS(
1214 legacy2aidl_audio_device_AudioDevice(device, address));
1215
1216 return statusTFromBinderStatus(
1217 aps->handleDeviceConfigChange(deviceAidl, name, VALUE_OR_RETURN_STATUS(
1218 legacy2aidl_audio_format_t_AudioFormatDescription(encodedFormat))));
1219 }
1220
setPhoneState(audio_mode_t state,uid_t uid)1221 status_t AudioSystem::setPhoneState(audio_mode_t state, uid_t uid) {
1222 if (uint32_t(state) >= AUDIO_MODE_CNT) return BAD_VALUE;
1223 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1224 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
1225
1226 return statusTFromBinderStatus(aps->setPhoneState(
1227 VALUE_OR_RETURN_STATUS(legacy2aidl_audio_mode_t_AudioMode(state)),
1228 VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(uid))));
1229 }
1230
1231 status_t
setForceUse(audio_policy_force_use_t usage,audio_policy_forced_cfg_t config)1232 AudioSystem::setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config) {
1233 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1234 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
1235
1236 return statusTFromBinderStatus(
1237 aps->setForceUse(
1238 VALUE_OR_RETURN_STATUS(
1239 legacy2aidl_audio_policy_force_use_t_AudioPolicyForceUse(usage)),
1240 VALUE_OR_RETURN_STATUS(
1241 legacy2aidl_audio_policy_forced_cfg_t_AudioPolicyForcedConfig(
1242 config))));
1243 }
1244
getForceUse(audio_policy_force_use_t usage)1245 audio_policy_forced_cfg_t AudioSystem::getForceUse(audio_policy_force_use_t usage) {
1246 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1247 if (aps == nullptr) return AUDIO_POLICY_FORCE_NONE;
1248
1249 auto result = [&]() -> ConversionResult<audio_policy_forced_cfg_t> {
1250 media::AudioPolicyForceUse usageAidl = VALUE_OR_RETURN(
1251 legacy2aidl_audio_policy_force_use_t_AudioPolicyForceUse(usage));
1252 media::AudioPolicyForcedConfig configAidl;
1253 RETURN_IF_ERROR(statusTFromBinderStatus(
1254 aps->getForceUse(usageAidl, &configAidl)));
1255 return aidl2legacy_AudioPolicyForcedConfig_audio_policy_forced_cfg_t(configAidl);
1256 }();
1257
1258 return result.value_or(AUDIO_POLICY_FORCE_NONE);
1259 }
1260
1261
getOutput(audio_stream_type_t stream)1262 audio_io_handle_t AudioSystem::getOutput(audio_stream_type_t stream) {
1263 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1264 if (aps == nullptr) return AUDIO_IO_HANDLE_NONE;
1265
1266 auto result = [&]() -> ConversionResult<audio_io_handle_t> {
1267 AudioStreamType streamAidl = VALUE_OR_RETURN(
1268 legacy2aidl_audio_stream_type_t_AudioStreamType(stream));
1269 int32_t outputAidl;
1270 RETURN_IF_ERROR(
1271 statusTFromBinderStatus(aps->getOutput(streamAidl, &outputAidl)));
1272 return aidl2legacy_int32_t_audio_io_handle_t(outputAidl);
1273 }();
1274
1275 return result.value_or(AUDIO_IO_HANDLE_NONE);
1276 }
1277
getOutputForAttr(audio_attributes_t * attr,audio_io_handle_t * output,audio_session_t session,audio_stream_type_t * stream,const AttributionSourceState & attributionSource,audio_config_t * config,audio_output_flags_t flags,DeviceIdVector * selectedDeviceIds,audio_port_handle_t * portId,std::vector<audio_io_handle_t> * secondaryOutputs,bool * isSpatialized,bool * isBitPerfect,float * volume,bool * muted)1278 status_t AudioSystem::getOutputForAttr(audio_attributes_t* attr,
1279 audio_io_handle_t* output,
1280 audio_session_t session,
1281 audio_stream_type_t* stream,
1282 const AttributionSourceState& attributionSource,
1283 audio_config_t* config,
1284 audio_output_flags_t flags,
1285 DeviceIdVector* selectedDeviceIds,
1286 audio_port_handle_t* portId,
1287 std::vector<audio_io_handle_t>* secondaryOutputs,
1288 bool *isSpatialized,
1289 bool *isBitPerfect,
1290 float *volume,
1291 bool *muted) {
1292 if (attr == nullptr) {
1293 ALOGE("%s NULL audio attributes", __func__);
1294 return BAD_VALUE;
1295 }
1296 if (output == nullptr) {
1297 ALOGE("%s NULL output - shouldn't happen", __func__);
1298 return BAD_VALUE;
1299 }
1300 if (selectedDeviceIds == nullptr) {
1301 ALOGE("%s NULL selectedDeviceIds - shouldn't happen", __func__);
1302 return BAD_VALUE;
1303 }
1304 if (portId == nullptr) {
1305 ALOGE("%s NULL portId - shouldn't happen", __func__);
1306 return BAD_VALUE;
1307 }
1308 if (secondaryOutputs == nullptr) {
1309 ALOGE("%s NULL secondaryOutputs - shouldn't happen", __func__);
1310 return BAD_VALUE;
1311 }
1312
1313 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1314 if (aps == nullptr) return NO_INIT;
1315
1316 media::audio::common::AudioAttributes attrAidl = VALUE_OR_RETURN_STATUS(
1317 legacy2aidl_audio_attributes_t_AudioAttributes(*attr));
1318 int32_t sessionAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_session_t_int32_t(session));
1319 AudioConfig configAidl = VALUE_OR_RETURN_STATUS(
1320 legacy2aidl_audio_config_t_AudioConfig(*config, false /*isInput*/));
1321 int32_t flagsAidl = VALUE_OR_RETURN_STATUS(
1322 legacy2aidl_audio_output_flags_t_int32_t_mask(flags));
1323 auto selectedDeviceIdsAidl = VALUE_OR_RETURN_STATUS(convertContainer<std::vector<int32_t>>(
1324 *selectedDeviceIds, legacy2aidl_audio_port_handle_t_int32_t));
1325
1326 media::GetOutputForAttrResponse responseAidl;
1327
1328 status_t status = statusTFromBinderStatus(
1329 aps->getOutputForAttr(attrAidl, sessionAidl, attributionSource, configAidl, flagsAidl,
1330 selectedDeviceIdsAidl, &responseAidl));
1331 if (status != NO_ERROR) {
1332 config->format = VALUE_OR_RETURN_STATUS(
1333 aidl2legacy_AudioFormatDescription_audio_format_t(responseAidl.configBase.format));
1334 config->channel_mask = VALUE_OR_RETURN_STATUS(
1335 aidl2legacy_AudioChannelLayout_audio_channel_mask_t(
1336 responseAidl.configBase.channelMask, false /*isInput*/));
1337 config->sample_rate = responseAidl.configBase.sampleRate;
1338 return status;
1339 }
1340
1341 *output = VALUE_OR_RETURN_STATUS(
1342 aidl2legacy_int32_t_audio_io_handle_t(responseAidl.output));
1343
1344 if (stream != nullptr) {
1345 *stream = VALUE_OR_RETURN_STATUS(
1346 aidl2legacy_AudioStreamType_audio_stream_type_t(responseAidl.stream));
1347 }
1348 *selectedDeviceIds = VALUE_OR_RETURN_STATUS(convertContainer<DeviceIdVector>(
1349 responseAidl.selectedDeviceIds, aidl2legacy_int32_t_audio_port_handle_t));
1350 *portId = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_audio_port_handle_t(responseAidl.portId));
1351 *secondaryOutputs = VALUE_OR_RETURN_STATUS(convertContainer<std::vector<audio_io_handle_t>>(
1352 responseAidl.secondaryOutputs, aidl2legacy_int32_t_audio_io_handle_t));
1353 *isSpatialized = responseAidl.isSpatialized;
1354 *isBitPerfect = responseAidl.isBitPerfect;
1355 *attr = VALUE_OR_RETURN_STATUS(
1356 aidl2legacy_AudioAttributes_audio_attributes_t(responseAidl.attr));
1357 *volume = responseAidl.volume;
1358 *muted = responseAidl.muted;
1359
1360 return OK;
1361 }
1362
startOutput(audio_port_handle_t portId)1363 status_t AudioSystem::startOutput(audio_port_handle_t portId) {
1364 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1365 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
1366
1367 int32_t portIdAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_port_handle_t_int32_t(portId));
1368 return statusTFromBinderStatus(aps->startOutput(portIdAidl));
1369 }
1370
stopOutput(audio_port_handle_t portId)1371 status_t AudioSystem::stopOutput(audio_port_handle_t portId) {
1372 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1373 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
1374
1375 int32_t portIdAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_port_handle_t_int32_t(portId));
1376 return statusTFromBinderStatus(aps->stopOutput(portIdAidl));
1377 }
1378
releaseOutput(audio_port_handle_t portId)1379 void AudioSystem::releaseOutput(audio_port_handle_t portId) {
1380 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1381 if (aps == nullptr) return;
1382
1383 auto status = [&]() -> status_t {
1384 int32_t portIdAidl = VALUE_OR_RETURN_STATUS(
1385 legacy2aidl_audio_port_handle_t_int32_t(portId));
1386 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(aps->releaseOutput(portIdAidl)));
1387 return OK;
1388 }();
1389
1390 // Ignore status.
1391 (void) status;
1392 }
1393
getInputForAttr(const audio_attributes_t * attr,audio_io_handle_t * input,audio_unique_id_t riid,audio_session_t session,const AttributionSourceState & attributionSource,audio_config_base_t * config,audio_input_flags_t flags,audio_port_handle_t * selectedDeviceId,audio_port_handle_t * portId)1394 status_t AudioSystem::getInputForAttr(const audio_attributes_t* attr,
1395 audio_io_handle_t* input,
1396 audio_unique_id_t riid,
1397 audio_session_t session,
1398 const AttributionSourceState &attributionSource,
1399 audio_config_base_t* config,
1400 audio_input_flags_t flags,
1401 audio_port_handle_t* selectedDeviceId,
1402 audio_port_handle_t* portId) {
1403 if (attr == NULL) {
1404 ALOGE("getInputForAttr NULL attr - shouldn't happen");
1405 return BAD_VALUE;
1406 }
1407 if (input == NULL) {
1408 ALOGE("getInputForAttr NULL input - shouldn't happen");
1409 return BAD_VALUE;
1410 }
1411 if (selectedDeviceId == NULL) {
1412 ALOGE("getInputForAttr NULL selectedDeviceId - shouldn't happen");
1413 return BAD_VALUE;
1414 }
1415 if (portId == NULL) {
1416 ALOGE("getInputForAttr NULL portId - shouldn't happen");
1417 return BAD_VALUE;
1418 }
1419
1420 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1421 if (aps == nullptr) return NO_INIT;
1422
1423 media::audio::common::AudioAttributes attrAidl = VALUE_OR_RETURN_STATUS(
1424 legacy2aidl_audio_attributes_t_AudioAttributes(*attr));
1425 int32_t inputAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(*input));
1426 int32_t riidAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_unique_id_t_int32_t(riid));
1427 int32_t sessionAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_session_t_int32_t(session));
1428 AudioConfigBase configAidl = VALUE_OR_RETURN_STATUS(
1429 legacy2aidl_audio_config_base_t_AudioConfigBase(*config, true /*isInput*/));
1430 int32_t flagsAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_input_flags_t_int32_t_mask(flags));
1431 int32_t selectedDeviceIdAidl = VALUE_OR_RETURN_STATUS(
1432 legacy2aidl_audio_port_handle_t_int32_t(*selectedDeviceId));
1433
1434 media::GetInputForAttrResponse response;
1435
1436 const Status res = aps->getInputForAttr(attrAidl, inputAidl, riidAidl, sessionAidl,
1437 attributionSource, configAidl, flagsAidl,
1438 selectedDeviceIdAidl, &response);
1439 if (!res.isOk()) {
1440 ALOGE("getInputForAttr error: %s", res.toString8().c_str());
1441 *config = VALUE_OR_RETURN_STATUS(
1442 aidl2legacy_AudioConfigBase_audio_config_base_t(response.config, true /*isInput*/));
1443 return statusTFromBinderStatus(res);
1444 }
1445
1446 *input = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_audio_io_handle_t(response.input));
1447 *selectedDeviceId = VALUE_OR_RETURN_STATUS(
1448 aidl2legacy_int32_t_audio_port_handle_t(response.selectedDeviceId));
1449 *portId = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_audio_port_handle_t(response.portId));
1450
1451 return OK;
1452 }
1453
startInput(audio_port_handle_t portId)1454 status_t AudioSystem::startInput(audio_port_handle_t portId) {
1455 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1456 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
1457
1458 int32_t portIdAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_port_handle_t_int32_t(portId));
1459 return statusTFromBinderStatus(aps->startInput(portIdAidl));
1460 }
1461
stopInput(audio_port_handle_t portId)1462 status_t AudioSystem::stopInput(audio_port_handle_t portId) {
1463 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1464 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
1465
1466 int32_t portIdAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_port_handle_t_int32_t(portId));
1467 return statusTFromBinderStatus(aps->stopInput(portIdAidl));
1468 }
1469
releaseInput(audio_port_handle_t portId)1470 void AudioSystem::releaseInput(audio_port_handle_t portId) {
1471 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1472 if (aps == nullptr) return;
1473
1474 auto status = [&]() -> status_t {
1475 int32_t portIdAidl = VALUE_OR_RETURN_STATUS(
1476 legacy2aidl_audio_port_handle_t_int32_t(portId));
1477 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(aps->releaseInput(portIdAidl)));
1478 return OK;
1479 }();
1480
1481 // Ignore status.
1482 (void) status;
1483 }
1484
setDeviceAbsoluteVolumeEnabled(audio_devices_t deviceType,const char * address,bool enabled,audio_stream_type_t streamToDriveAbs)1485 status_t AudioSystem::setDeviceAbsoluteVolumeEnabled(audio_devices_t deviceType,
1486 const char *address,
1487 bool enabled,
1488 audio_stream_type_t streamToDriveAbs) {
1489 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1490 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
1491
1492 AudioDevice deviceAidl = VALUE_OR_RETURN_STATUS(
1493 legacy2aidl_audio_device_AudioDevice(deviceType, address));
1494 AudioStreamType streamToDriveAbsAidl = VALUE_OR_RETURN_STATUS(
1495 legacy2aidl_audio_stream_type_t_AudioStreamType(streamToDriveAbs));
1496 return statusTFromBinderStatus(
1497 aps->setDeviceAbsoluteVolumeEnabled(deviceAidl, enabled, streamToDriveAbsAidl));
1498 }
1499
initStreamVolume(audio_stream_type_t stream,int indexMin,int indexMax)1500 status_t AudioSystem::initStreamVolume(audio_stream_type_t stream,
1501 int indexMin,
1502 int indexMax) {
1503 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1504 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
1505
1506 AudioStreamType streamAidl = VALUE_OR_RETURN_STATUS(
1507 legacy2aidl_audio_stream_type_t_AudioStreamType(stream));
1508 int32_t indexMinAidl = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(indexMin));
1509 int32_t indexMaxAidl = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(indexMax));
1510 status_t status = statusTFromBinderStatus(
1511 aps->initStreamVolume(streamAidl, indexMinAidl, indexMaxAidl));
1512 return status;
1513 }
1514
setStreamVolumeIndex(audio_stream_type_t stream,int index,bool muted,audio_devices_t device)1515 status_t AudioSystem::setStreamVolumeIndex(audio_stream_type_t stream,
1516 int index,
1517 bool muted,
1518 audio_devices_t device) {
1519 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1520 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
1521
1522 AudioStreamType streamAidl = VALUE_OR_RETURN_STATUS(
1523 legacy2aidl_audio_stream_type_t_AudioStreamType(stream));
1524 int32_t indexAidl = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(index));
1525 AudioDeviceDescription deviceAidl = VALUE_OR_RETURN_STATUS(
1526 legacy2aidl_audio_devices_t_AudioDeviceDescription(device));
1527 return statusTFromBinderStatus(
1528 aps->setStreamVolumeIndex(streamAidl, deviceAidl, indexAidl, muted));
1529 }
1530
getStreamVolumeIndex(audio_stream_type_t stream,int * index,audio_devices_t device)1531 status_t AudioSystem::getStreamVolumeIndex(audio_stream_type_t stream,
1532 int* index,
1533 audio_devices_t device) {
1534 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1535 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
1536
1537 AudioStreamType streamAidl = VALUE_OR_RETURN_STATUS(
1538 legacy2aidl_audio_stream_type_t_AudioStreamType(stream));
1539 AudioDeviceDescription deviceAidl = VALUE_OR_RETURN_STATUS(
1540 legacy2aidl_audio_devices_t_AudioDeviceDescription(device));
1541 int32_t indexAidl;
1542 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
1543 aps->getStreamVolumeIndex(streamAidl, deviceAidl, &indexAidl)));
1544 if (index != nullptr) {
1545 *index = VALUE_OR_RETURN_STATUS(convertIntegral<int>(indexAidl));
1546 }
1547 return OK;
1548 }
1549
setVolumeIndexForAttributes(const audio_attributes_t & attr,int index,bool muted,audio_devices_t device)1550 status_t AudioSystem::setVolumeIndexForAttributes(const audio_attributes_t& attr,
1551 int index,
1552 bool muted,
1553 audio_devices_t device) {
1554 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1555 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
1556
1557 media::audio::common::AudioAttributes attrAidl = VALUE_OR_RETURN_STATUS(
1558 legacy2aidl_audio_attributes_t_AudioAttributes(attr));
1559 int32_t indexAidl = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(index));
1560 AudioDeviceDescription deviceAidl = VALUE_OR_RETURN_STATUS(
1561 legacy2aidl_audio_devices_t_AudioDeviceDescription(device));
1562 return statusTFromBinderStatus(
1563 aps->setVolumeIndexForAttributes(attrAidl, deviceAidl, indexAidl, muted));
1564 }
1565
getVolumeIndexForAttributes(const audio_attributes_t & attr,int & index,audio_devices_t device)1566 status_t AudioSystem::getVolumeIndexForAttributes(const audio_attributes_t& attr,
1567 int& index,
1568 audio_devices_t device) {
1569 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1570 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
1571
1572 media::audio::common::AudioAttributes attrAidl = VALUE_OR_RETURN_STATUS(
1573 legacy2aidl_audio_attributes_t_AudioAttributes(attr));
1574 AudioDeviceDescription deviceAidl = VALUE_OR_RETURN_STATUS(
1575 legacy2aidl_audio_devices_t_AudioDeviceDescription(device));
1576 int32_t indexAidl;
1577 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
1578 aps->getVolumeIndexForAttributes(attrAidl, deviceAidl, &indexAidl)));
1579 index = VALUE_OR_RETURN_STATUS(convertIntegral<int>(indexAidl));
1580 return OK;
1581 }
1582
getMaxVolumeIndexForAttributes(const audio_attributes_t & attr,int & index)1583 status_t AudioSystem::getMaxVolumeIndexForAttributes(const audio_attributes_t& attr, int& index) {
1584 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1585 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
1586
1587 media::audio::common::AudioAttributes attrAidl = VALUE_OR_RETURN_STATUS(
1588 legacy2aidl_audio_attributes_t_AudioAttributes(attr));
1589 int32_t indexAidl;
1590 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
1591 aps->getMaxVolumeIndexForAttributes(attrAidl, &indexAidl)));
1592 index = VALUE_OR_RETURN_STATUS(convertIntegral<int>(indexAidl));
1593 return OK;
1594 }
1595
getMinVolumeIndexForAttributes(const audio_attributes_t & attr,int & index)1596 status_t AudioSystem::getMinVolumeIndexForAttributes(const audio_attributes_t& attr, int& index) {
1597 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1598 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
1599
1600 media::audio::common::AudioAttributes attrAidl = VALUE_OR_RETURN_STATUS(
1601 legacy2aidl_audio_attributes_t_AudioAttributes(attr));
1602 int32_t indexAidl;
1603 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
1604 aps->getMinVolumeIndexForAttributes(attrAidl, &indexAidl)));
1605 index = VALUE_OR_RETURN_STATUS(convertIntegral<int>(indexAidl));
1606 return OK;
1607 }
1608
getStrategyForStream(audio_stream_type_t stream)1609 product_strategy_t AudioSystem::getStrategyForStream(audio_stream_type_t stream) {
1610 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1611 if (aps == nullptr) return PRODUCT_STRATEGY_NONE;
1612
1613 auto result = [&]() -> ConversionResult<product_strategy_t> {
1614 AudioStreamType streamAidl = VALUE_OR_RETURN(
1615 legacy2aidl_audio_stream_type_t_AudioStreamType(stream));
1616 int32_t resultAidl;
1617 RETURN_IF_ERROR(statusTFromBinderStatus(
1618 aps->getStrategyForStream(streamAidl, &resultAidl)));
1619 return aidl2legacy_int32_t_product_strategy_t(resultAidl);
1620 }();
1621 return result.value_or(PRODUCT_STRATEGY_NONE);
1622 }
1623
getDevicesForAttributes(const audio_attributes_t & aa,AudioDeviceTypeAddrVector * devices,bool forVolume)1624 status_t AudioSystem::getDevicesForAttributes(const audio_attributes_t& aa,
1625 AudioDeviceTypeAddrVector* devices,
1626 bool forVolume) {
1627 if (devices == nullptr) {
1628 return BAD_VALUE;
1629 }
1630 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1631 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
1632
1633 media::audio::common::AudioAttributes aaAidl = VALUE_OR_RETURN_STATUS(
1634 legacy2aidl_audio_attributes_t_AudioAttributes(aa));
1635 std::vector<AudioDevice> retAidl;
1636 RETURN_STATUS_IF_ERROR(
1637 statusTFromBinderStatus(aps->getDevicesForAttributes(aaAidl, forVolume, &retAidl)));
1638 *devices = VALUE_OR_RETURN_STATUS(
1639 convertContainer<AudioDeviceTypeAddrVector>(
1640 retAidl,
1641 aidl2legacy_AudioDeviceTypeAddress));
1642 return OK;
1643 }
1644
getOutputForEffect(const effect_descriptor_t * desc)1645 audio_io_handle_t AudioSystem::getOutputForEffect(const effect_descriptor_t* desc) {
1646 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1647 // FIXME change return type to status_t, and return PERMISSION_DENIED here
1648 if (aps == nullptr) return AUDIO_IO_HANDLE_NONE;
1649
1650 auto result = [&]() -> ConversionResult<audio_io_handle_t> {
1651 media::EffectDescriptor descAidl = VALUE_OR_RETURN(
1652 legacy2aidl_effect_descriptor_t_EffectDescriptor(*desc));
1653 int32_t retAidl;
1654 RETURN_IF_ERROR(
1655 statusTFromBinderStatus(aps->getOutputForEffect(descAidl, &retAidl)));
1656 return aidl2legacy_int32_t_audio_io_handle_t(retAidl);
1657 }();
1658
1659 return result.value_or(AUDIO_IO_HANDLE_NONE);
1660 }
1661
registerEffect(const effect_descriptor_t * desc,audio_io_handle_t io,product_strategy_t strategy,audio_session_t session,int id)1662 status_t AudioSystem::registerEffect(const effect_descriptor_t* desc,
1663 audio_io_handle_t io,
1664 product_strategy_t strategy,
1665 audio_session_t session,
1666 int id) {
1667 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1668 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
1669
1670 media::EffectDescriptor descAidl = VALUE_OR_RETURN_STATUS(
1671 legacy2aidl_effect_descriptor_t_EffectDescriptor(*desc));
1672 int32_t ioAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(io));
1673 int32_t strategyAidl = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_product_strategy_t(strategy));
1674 int32_t sessionAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_session_t_int32_t(session));
1675 int32_t idAidl = VALUE_OR_RETURN_STATUS(convertReinterpret<int32_t>(id));
1676 return statusTFromBinderStatus(
1677 aps->registerEffect(descAidl, ioAidl, strategyAidl, sessionAidl, idAidl));
1678 }
1679
unregisterEffect(int id)1680 status_t AudioSystem::unregisterEffect(int id) {
1681 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1682 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
1683
1684 int32_t idAidl = VALUE_OR_RETURN_STATUS(convertReinterpret<int32_t>(id));
1685 return statusTFromBinderStatus(
1686 aps->unregisterEffect(idAidl));
1687 }
1688
setEffectEnabled(int id,bool enabled)1689 status_t AudioSystem::setEffectEnabled(int id, bool enabled) {
1690 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1691 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
1692
1693 int32_t idAidl = VALUE_OR_RETURN_STATUS(convertReinterpret<int32_t>(id));
1694 return statusTFromBinderStatus(
1695 aps->setEffectEnabled(idAidl, enabled));
1696 }
1697
moveEffectsToIo(const std::vector<int> & ids,audio_io_handle_t io)1698 status_t AudioSystem::moveEffectsToIo(const std::vector<int>& ids, audio_io_handle_t io) {
1699 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1700 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
1701
1702 std::vector<int32_t> idsAidl = VALUE_OR_RETURN_STATUS(
1703 convertContainer<std::vector<int32_t>>(ids, convertReinterpret<int32_t, int>));
1704 int32_t ioAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(io));
1705 return statusTFromBinderStatus(aps->moveEffectsToIo(idsAidl, ioAidl));
1706 }
1707
isStreamActive(audio_stream_type_t stream,bool * state,uint32_t inPastMs)1708 status_t AudioSystem::isStreamActive(audio_stream_type_t stream, bool* state, uint32_t inPastMs) {
1709 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1710 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
1711 if (state == NULL) return BAD_VALUE;
1712
1713 AudioStreamType streamAidl = VALUE_OR_RETURN_STATUS(
1714 legacy2aidl_audio_stream_type_t_AudioStreamType(stream));
1715 int32_t inPastMsAidl = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(inPastMs));
1716 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
1717 aps->isStreamActive(streamAidl, inPastMsAidl, state)));
1718 return OK;
1719 }
1720
isStreamActiveRemotely(audio_stream_type_t stream,bool * state,uint32_t inPastMs)1721 status_t AudioSystem::isStreamActiveRemotely(audio_stream_type_t stream, bool* state,
1722 uint32_t inPastMs) {
1723 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1724 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
1725 if (state == NULL) return BAD_VALUE;
1726
1727 AudioStreamType streamAidl = VALUE_OR_RETURN_STATUS(
1728 legacy2aidl_audio_stream_type_t_AudioStreamType(stream));
1729 int32_t inPastMsAidl = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(inPastMs));
1730 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
1731 aps->isStreamActiveRemotely(streamAidl, inPastMsAidl, state)));
1732 return OK;
1733 }
1734
isSourceActive(audio_source_t stream,bool * state)1735 status_t AudioSystem::isSourceActive(audio_source_t stream, bool* state) {
1736 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1737 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
1738 if (state == NULL) return BAD_VALUE;
1739
1740 AudioSource streamAidl = VALUE_OR_RETURN_STATUS(
1741 legacy2aidl_audio_source_t_AudioSource(stream));
1742 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
1743 aps->isSourceActive(streamAidl, state)));
1744 return OK;
1745 }
1746
getPrimaryOutputSamplingRate()1747 uint32_t AudioSystem::getPrimaryOutputSamplingRate() {
1748 const sp<IAudioFlinger> af = get_audio_flinger();
1749 if (af == nullptr) return 0;
1750 return af->getPrimaryOutputSamplingRate();
1751 }
1752
getPrimaryOutputFrameCount()1753 size_t AudioSystem::getPrimaryOutputFrameCount() {
1754 const sp<IAudioFlinger> af = get_audio_flinger();
1755 if (af == nullptr) return 0;
1756 return af->getPrimaryOutputFrameCount();
1757 }
1758
setLowRamDevice(bool isLowRamDevice,int64_t totalMemory)1759 status_t AudioSystem::setLowRamDevice(bool isLowRamDevice, int64_t totalMemory) {
1760 const sp<IAudioFlinger> af = get_audio_flinger();
1761 if (af == nullptr) return AudioFlingerServiceTraits::getError();
1762 return af->setLowRamDevice(isLowRamDevice, totalMemory);
1763 }
1764
setSupportedSystemUsages(const std::vector<audio_usage_t> & systemUsages)1765 status_t AudioSystem::setSupportedSystemUsages(const std::vector<audio_usage_t>& systemUsages) {
1766 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1767 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
1768
1769 std::vector<AudioUsage> systemUsagesAidl = VALUE_OR_RETURN_STATUS(
1770 convertContainer<std::vector<AudioUsage>>(systemUsages,
1771 legacy2aidl_audio_usage_t_AudioUsage));
1772 return statusTFromBinderStatus(aps->setSupportedSystemUsages(systemUsagesAidl));
1773 }
1774
setAllowedCapturePolicy(uid_t uid,audio_flags_mask_t capturePolicy)1775 status_t AudioSystem::setAllowedCapturePolicy(uid_t uid, audio_flags_mask_t capturePolicy) {
1776 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1777 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
1778
1779 int32_t uidAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(uid));
1780 int32_t capturePolicyAidl = VALUE_OR_RETURN_STATUS(
1781 legacy2aidl_audio_flags_mask_t_int32_t_mask(capturePolicy));
1782 return statusTFromBinderStatus(aps->setAllowedCapturePolicy(uidAidl, capturePolicyAidl));
1783 }
1784
getOffloadSupport(const audio_offload_info_t & info)1785 audio_offload_mode_t AudioSystem::getOffloadSupport(const audio_offload_info_t& info) {
1786 ALOGV("%s", __func__);
1787 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1788 if (aps == nullptr) return AUDIO_OFFLOAD_NOT_SUPPORTED;
1789
1790 auto result = [&]() -> ConversionResult<audio_offload_mode_t> {
1791 AudioOffloadInfo infoAidl = VALUE_OR_RETURN(
1792 legacy2aidl_audio_offload_info_t_AudioOffloadInfo(info));
1793 media::AudioOffloadMode retAidl;
1794 RETURN_IF_ERROR(
1795 statusTFromBinderStatus(aps->getOffloadSupport(infoAidl, &retAidl)));
1796 return aidl2legacy_AudioOffloadMode_audio_offload_mode_t(retAidl);
1797 }();
1798
1799 return result.value_or(static_cast<audio_offload_mode_t>(0));
1800 }
1801
listAudioPorts(audio_port_role_t role,audio_port_type_t type,unsigned int * num_ports,struct audio_port_v7 * ports,unsigned int * generation)1802 status_t AudioSystem::listAudioPorts(audio_port_role_t role,
1803 audio_port_type_t type,
1804 unsigned int* num_ports,
1805 struct audio_port_v7* ports,
1806 unsigned int* generation) {
1807 if (num_ports == nullptr || (*num_ports != 0 && ports == nullptr) ||
1808 generation == nullptr) {
1809 return BAD_VALUE;
1810 }
1811
1812 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1813 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
1814
1815 media::AudioPortRole roleAidl = VALUE_OR_RETURN_STATUS(
1816 legacy2aidl_audio_port_role_t_AudioPortRole(role));
1817 media::AudioPortType typeAidl = VALUE_OR_RETURN_STATUS(
1818 legacy2aidl_audio_port_type_t_AudioPortType(type));
1819 Int numPortsAidl;
1820 numPortsAidl.value = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(*num_ports));
1821 std::vector<media::AudioPortFw> portsAidl;
1822 int32_t generationAidl;
1823
1824 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
1825 aps->listAudioPorts(roleAidl, typeAidl, &numPortsAidl, &portsAidl, &generationAidl)));
1826 *num_ports = VALUE_OR_RETURN_STATUS(convertIntegral<unsigned int>(numPortsAidl.value));
1827 *generation = VALUE_OR_RETURN_STATUS(convertIntegral<unsigned int>(generationAidl));
1828 RETURN_STATUS_IF_ERROR(convertRange(portsAidl.begin(), portsAidl.end(), ports,
1829 aidl2legacy_AudioPortFw_audio_port_v7));
1830 return OK;
1831 }
1832
listDeclaredDevicePorts(media::AudioPortRole role,std::vector<media::AudioPortFw> * result)1833 status_t AudioSystem::listDeclaredDevicePorts(media::AudioPortRole role,
1834 std::vector<media::AudioPortFw>* result) {
1835 if (result == nullptr) return BAD_VALUE;
1836 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1837 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
1838 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(aps->listDeclaredDevicePorts(role, result)));
1839 return OK;
1840 }
1841
getAudioPort(struct audio_port_v7 * port)1842 status_t AudioSystem::getAudioPort(struct audio_port_v7* port) {
1843 if (port == nullptr) {
1844 return BAD_VALUE;
1845 }
1846 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1847 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
1848
1849 media::AudioPortFw portAidl;
1850 RETURN_STATUS_IF_ERROR(
1851 statusTFromBinderStatus(aps->getAudioPort(port->id, &portAidl)));
1852 *port = VALUE_OR_RETURN_STATUS(aidl2legacy_AudioPortFw_audio_port_v7(portAidl));
1853 return OK;
1854 }
1855
createAudioPatch(const struct audio_patch * patch,audio_patch_handle_t * handle)1856 status_t AudioSystem::createAudioPatch(const struct audio_patch* patch,
1857 audio_patch_handle_t* handle) {
1858 if (patch == nullptr || handle == nullptr) {
1859 return BAD_VALUE;
1860 }
1861
1862 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1863 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
1864
1865 media::AudioPatchFw patchAidl = VALUE_OR_RETURN_STATUS(
1866 legacy2aidl_audio_patch_AudioPatchFw(*patch));
1867 int32_t handleAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_patch_handle_t_int32_t(*handle));
1868 RETURN_STATUS_IF_ERROR(
1869 statusTFromBinderStatus(aps->createAudioPatch(patchAidl, handleAidl, &handleAidl)));
1870 *handle = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_audio_patch_handle_t(handleAidl));
1871 return OK;
1872 }
1873
releaseAudioPatch(audio_patch_handle_t handle)1874 status_t AudioSystem::releaseAudioPatch(audio_patch_handle_t handle) {
1875 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1876 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
1877
1878 int32_t handleAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_patch_handle_t_int32_t(handle));
1879 return statusTFromBinderStatus(aps->releaseAudioPatch(handleAidl));
1880 }
1881
listAudioPatches(unsigned int * num_patches,struct audio_patch * patches,unsigned int * generation)1882 status_t AudioSystem::listAudioPatches(unsigned int* num_patches,
1883 struct audio_patch* patches,
1884 unsigned int* generation) {
1885 if (num_patches == nullptr || (*num_patches != 0 && patches == nullptr) ||
1886 generation == nullptr) {
1887 return BAD_VALUE;
1888 }
1889
1890 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1891 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
1892
1893
1894 Int numPatchesAidl;
1895 numPatchesAidl.value = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(*num_patches));
1896 std::vector<media::AudioPatchFw> patchesAidl;
1897 int32_t generationAidl;
1898
1899 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
1900 aps->listAudioPatches(&numPatchesAidl, &patchesAidl, &generationAidl)));
1901 *num_patches = VALUE_OR_RETURN_STATUS(convertIntegral<unsigned int>(numPatchesAidl.value));
1902 *generation = VALUE_OR_RETURN_STATUS(convertIntegral<unsigned int>(generationAidl));
1903 RETURN_STATUS_IF_ERROR(convertRange(patchesAidl.begin(), patchesAidl.end(), patches,
1904 aidl2legacy_AudioPatchFw_audio_patch));
1905 return OK;
1906 }
1907
setAudioPortConfig(const struct audio_port_config * config)1908 status_t AudioSystem::setAudioPortConfig(const struct audio_port_config* config) {
1909 if (config == nullptr) {
1910 return BAD_VALUE;
1911 }
1912
1913 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1914 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
1915
1916 media::AudioPortConfigFw configAidl = VALUE_OR_RETURN_STATUS(
1917 legacy2aidl_audio_port_config_AudioPortConfigFw(*config));
1918 return statusTFromBinderStatus(aps->setAudioPortConfig(configAidl));
1919 }
1920
addAudioPortCallback(const sp<AudioPortCallback> & callback)1921 status_t AudioSystem::addAudioPortCallback(const sp<AudioPortCallback>& callback) {
1922 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1923 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
1924 const auto apc = getAudioPolicyClient();
1925 if (apc == nullptr) return NO_INIT;
1926
1927 std::lock_guard _l(gApsCallbackMutex);
1928 const int ret = apc->addAudioPortCallback(callback);
1929 if (ret == 1) {
1930 aps->setAudioPortCallbacksEnabled(true);
1931 }
1932 return (ret < 0) ? INVALID_OPERATION : NO_ERROR;
1933 }
1934
1935 /*static*/
removeAudioPortCallback(const sp<AudioPortCallback> & callback)1936 status_t AudioSystem::removeAudioPortCallback(const sp<AudioPortCallback>& callback) {
1937 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1938 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
1939 const auto apc = AudioSystem::getAudioPolicyClient();
1940 if (apc == nullptr) return NO_INIT;
1941
1942 std::lock_guard _l(gApsCallbackMutex);
1943 const int ret = apc->removeAudioPortCallback(callback);
1944 if (ret == 0) {
1945 aps->setAudioPortCallbacksEnabled(false);
1946 }
1947 return (ret < 0) ? INVALID_OPERATION : NO_ERROR;
1948 }
1949
addAudioVolumeGroupCallback(const sp<AudioVolumeGroupCallback> & callback)1950 status_t AudioSystem::addAudioVolumeGroupCallback(const sp<AudioVolumeGroupCallback>& callback) {
1951 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1952 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
1953 const auto apc = AudioSystem::getAudioPolicyClient();
1954 if (apc == nullptr) return NO_INIT;
1955
1956 std::lock_guard _l(gApsCallbackMutex);
1957 const int ret = apc->addAudioVolumeGroupCallback(callback);
1958 if (ret == 1) {
1959 aps->setAudioVolumeGroupCallbacksEnabled(true);
1960 }
1961 return (ret < 0) ? INVALID_OPERATION : NO_ERROR;
1962 }
1963
removeAudioVolumeGroupCallback(const sp<AudioVolumeGroupCallback> & callback)1964 status_t AudioSystem::removeAudioVolumeGroupCallback(const sp<AudioVolumeGroupCallback>& callback) {
1965 const sp<IAudioPolicyService> aps = get_audio_policy_service();
1966 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
1967 const auto apc = AudioSystem::getAudioPolicyClient();
1968 if (apc == nullptr) return NO_INIT;
1969
1970 std::lock_guard _l(gApsCallbackMutex);
1971 const int ret = apc->removeAudioVolumeGroupCallback(callback);
1972 if (ret == 0) {
1973 aps->setAudioVolumeGroupCallbacksEnabled(false);
1974 }
1975 return (ret < 0) ? INVALID_OPERATION : NO_ERROR;
1976 }
1977
addAudioDeviceCallback(const wp<AudioDeviceCallback> & callback,audio_io_handle_t audioIo,audio_port_handle_t portId)1978 status_t AudioSystem::addAudioDeviceCallback(
1979 const wp<AudioDeviceCallback>& callback, audio_io_handle_t audioIo,
1980 audio_port_handle_t portId) {
1981 const sp<AudioFlingerClient> afc = getAudioFlingerClient();
1982 if (afc == 0) {
1983 return NO_INIT;
1984 }
1985 status_t status = afc->addAudioDeviceCallback(callback, audioIo, portId);
1986 if (status == NO_ERROR) {
1987 const sp<IAudioFlinger> af = get_audio_flinger();
1988 if (af != 0) {
1989 af->registerClient(afc);
1990 }
1991 }
1992 return status;
1993 }
1994
removeAudioDeviceCallback(const wp<AudioDeviceCallback> & callback,audio_io_handle_t audioIo,audio_port_handle_t portId)1995 status_t AudioSystem::removeAudioDeviceCallback(
1996 const wp<AudioDeviceCallback>& callback, audio_io_handle_t audioIo,
1997 audio_port_handle_t portId) {
1998 const sp<AudioFlingerClient> afc = getAudioFlingerClient();
1999 if (afc == 0) {
2000 return NO_INIT;
2001 }
2002 return afc->removeAudioDeviceCallback(callback, audioIo, portId);
2003 }
2004
addSupportedLatencyModesCallback(const sp<SupportedLatencyModesCallback> & callback)2005 status_t AudioSystem::addSupportedLatencyModesCallback(
2006 const sp<SupportedLatencyModesCallback>& callback) {
2007 const sp<AudioFlingerClient> afc = getAudioFlingerClient();
2008 if (afc == 0) {
2009 return NO_INIT;
2010 }
2011 return afc->addSupportedLatencyModesCallback(callback);
2012 }
2013
removeSupportedLatencyModesCallback(const sp<SupportedLatencyModesCallback> & callback)2014 status_t AudioSystem::removeSupportedLatencyModesCallback(
2015 const sp<SupportedLatencyModesCallback>& callback) {
2016 const sp<AudioFlingerClient> afc = getAudioFlingerClient();
2017 if (afc == 0) {
2018 return NO_INIT;
2019 }
2020 return afc->removeSupportedLatencyModesCallback(callback);
2021 }
2022
getDeviceIdsForIo(audio_io_handle_t audioIo,DeviceIdVector & deviceIds)2023 status_t AudioSystem::getDeviceIdsForIo(audio_io_handle_t audioIo, DeviceIdVector& deviceIds) {
2024 const sp<IAudioFlinger> af = get_audio_flinger();
2025 if (af == nullptr) return AudioFlingerServiceTraits::getError();
2026 const sp<AudioIoDescriptor> desc = getIoDescriptor(audioIo);
2027 if (desc == 0) {
2028 deviceIds.clear();
2029 } else {
2030 deviceIds = desc->getDeviceIds();
2031 }
2032 return OK;
2033 }
2034
acquireSoundTriggerSession(audio_session_t * session,audio_io_handle_t * ioHandle,audio_devices_t * device)2035 status_t AudioSystem::acquireSoundTriggerSession(audio_session_t* session,
2036 audio_io_handle_t* ioHandle,
2037 audio_devices_t* device) {
2038 if (session == nullptr || ioHandle == nullptr || device == nullptr) {
2039 return BAD_VALUE;
2040 }
2041 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2042 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
2043
2044 media::SoundTriggerSession retAidl;
2045 RETURN_STATUS_IF_ERROR(
2046 statusTFromBinderStatus(aps->acquireSoundTriggerSession(&retAidl)));
2047 *session = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_audio_session_t(retAidl.session));
2048 *ioHandle = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_audio_io_handle_t(retAidl.ioHandle));
2049 *device = VALUE_OR_RETURN_STATUS(
2050 aidl2legacy_AudioDeviceDescription_audio_devices_t(retAidl.device));
2051 return OK;
2052 }
2053
releaseSoundTriggerSession(audio_session_t session)2054 status_t AudioSystem::releaseSoundTriggerSession(audio_session_t session) {
2055 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2056 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
2057
2058 int32_t sessionAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_session_t_int32_t(session));
2059 return statusTFromBinderStatus(aps->releaseSoundTriggerSession(sessionAidl));
2060 }
2061
getPhoneState()2062 audio_mode_t AudioSystem::getPhoneState() {
2063 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2064 if (aps == nullptr) return AUDIO_MODE_INVALID;
2065
2066 auto result = [&]() -> ConversionResult<audio_mode_t> {
2067 media::audio::common::AudioMode retAidl;
2068 RETURN_IF_ERROR(statusTFromBinderStatus(aps->getPhoneState(&retAidl)));
2069 return aidl2legacy_AudioMode_audio_mode_t(retAidl);
2070 }();
2071
2072 return result.value_or(AUDIO_MODE_INVALID);
2073 }
2074
registerPolicyMixes(const Vector<AudioMix> & mixes,bool registration)2075 status_t AudioSystem::registerPolicyMixes(const Vector<AudioMix>& mixes, bool registration) {
2076 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2077 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
2078
2079 size_t mixesSize = std::min(mixes.size(), size_t{MAX_MIXES_PER_POLICY});
2080 std::vector<media::AudioMix> mixesAidl;
2081 RETURN_STATUS_IF_ERROR(
2082 convertRange(mixes.begin(), mixes.begin() + mixesSize, std::back_inserter(mixesAidl),
2083 legacy2aidl_AudioMix));
2084 return statusTFromBinderStatus(aps->registerPolicyMixes(mixesAidl, registration));
2085 }
2086
getRegisteredPolicyMixes(std::vector<AudioMix> & mixes)2087 status_t AudioSystem::getRegisteredPolicyMixes(std::vector<AudioMix>& mixes) {
2088 if (!audio_flags::audio_mix_test_api()) {
2089 return INVALID_OPERATION;
2090 }
2091
2092 const sp<IAudioPolicyService> aps = AudioSystem::get_audio_policy_service();
2093 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
2094
2095 std::vector<::android::media::AudioMix> aidlMixes;
2096 Status status = aps->getRegisteredPolicyMixes(&aidlMixes);
2097
2098 for (const auto& aidlMix : aidlMixes) {
2099 AudioMix mix = VALUE_OR_RETURN_STATUS(aidl2legacy_AudioMix(aidlMix));
2100 mixes.push_back(mix);
2101 }
2102
2103 return statusTFromBinderStatus(status);
2104 }
2105
updatePolicyMixes(const std::vector<std::pair<AudioMix,std::vector<AudioMixMatchCriterion>>> & mixesWithUpdates)2106 status_t AudioSystem::updatePolicyMixes(
2107 const std::vector<std::pair<AudioMix, std::vector<AudioMixMatchCriterion>>>&
2108 mixesWithUpdates) {
2109 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2110 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
2111
2112 std::vector<media::AudioMixUpdate> updatesAidl;
2113 updatesAidl.reserve(mixesWithUpdates.size());
2114
2115 for (const auto& update : mixesWithUpdates) {
2116 media::AudioMixUpdate updateAidl;
2117 updateAidl.audioMix = VALUE_OR_RETURN_STATUS(legacy2aidl_AudioMix(update.first));
2118 RETURN_STATUS_IF_ERROR(convertRange(update.second.begin(), update.second.end(),
2119 std::back_inserter(updateAidl.newCriteria),
2120 legacy2aidl_AudioMixMatchCriterion));
2121 updatesAidl.emplace_back(updateAidl);
2122 }
2123
2124 return statusTFromBinderStatus(aps->updatePolicyMixes(updatesAidl));
2125 }
2126
setUidDeviceAffinities(uid_t uid,const AudioDeviceTypeAddrVector & devices)2127 status_t AudioSystem::setUidDeviceAffinities(uid_t uid, const AudioDeviceTypeAddrVector& devices) {
2128 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2129 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
2130
2131 int32_t uidAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(uid));
2132 std::vector<AudioDevice> devicesAidl = VALUE_OR_RETURN_STATUS(
2133 convertContainer<std::vector<AudioDevice>>(devices,
2134 legacy2aidl_AudioDeviceTypeAddress));
2135 return statusTFromBinderStatus(aps->setUidDeviceAffinities(uidAidl, devicesAidl));
2136 }
2137
removeUidDeviceAffinities(uid_t uid)2138 status_t AudioSystem::removeUidDeviceAffinities(uid_t uid) {
2139 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2140 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
2141
2142 int32_t uidAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(uid));
2143 return statusTFromBinderStatus(aps->removeUidDeviceAffinities(uidAidl));
2144 }
2145
setUserIdDeviceAffinities(int userId,const AudioDeviceTypeAddrVector & devices)2146 status_t AudioSystem::setUserIdDeviceAffinities(int userId,
2147 const AudioDeviceTypeAddrVector& devices) {
2148 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2149 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
2150
2151 int32_t userIdAidl = VALUE_OR_RETURN_STATUS(convertReinterpret<int32_t>(userId));
2152 std::vector<AudioDevice> devicesAidl = VALUE_OR_RETURN_STATUS(
2153 convertContainer<std::vector<AudioDevice>>(devices,
2154 legacy2aidl_AudioDeviceTypeAddress));
2155 return statusTFromBinderStatus(
2156 aps->setUserIdDeviceAffinities(userIdAidl, devicesAidl));
2157 }
2158
removeUserIdDeviceAffinities(int userId)2159 status_t AudioSystem::removeUserIdDeviceAffinities(int userId) {
2160 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2161 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
2162 int32_t userIdAidl = VALUE_OR_RETURN_STATUS(convertReinterpret<int32_t>(userId));
2163 return statusTFromBinderStatus(aps->removeUserIdDeviceAffinities(userIdAidl));
2164 }
2165
startAudioSource(const struct audio_port_config * source,const audio_attributes_t * attributes,audio_port_handle_t * portId)2166 status_t AudioSystem::startAudioSource(const struct audio_port_config* source,
2167 const audio_attributes_t* attributes,
2168 audio_port_handle_t* portId) {
2169 if (source == nullptr || attributes == nullptr || portId == nullptr) {
2170 return BAD_VALUE;
2171 }
2172 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2173 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
2174
2175 media::AudioPortConfigFw sourceAidl = VALUE_OR_RETURN_STATUS(
2176 legacy2aidl_audio_port_config_AudioPortConfigFw(*source));
2177 media::audio::common::AudioAttributes attributesAidl = VALUE_OR_RETURN_STATUS(
2178 legacy2aidl_audio_attributes_t_AudioAttributes(*attributes));
2179 int32_t portIdAidl;
2180 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
2181 aps->startAudioSource(sourceAidl, attributesAidl, &portIdAidl)));
2182 *portId = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_audio_port_handle_t(portIdAidl));
2183 return OK;
2184 }
2185
stopAudioSource(audio_port_handle_t portId)2186 status_t AudioSystem::stopAudioSource(audio_port_handle_t portId) {
2187 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2188 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
2189
2190 int32_t portIdAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_port_handle_t_int32_t(portId));
2191 return statusTFromBinderStatus(aps->stopAudioSource(portIdAidl));
2192 }
2193
setMasterMono(bool mono)2194 status_t AudioSystem::setMasterMono(bool mono) {
2195 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2196 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
2197 return statusTFromBinderStatus(aps->setMasterMono(mono));
2198 }
2199
getMasterMono(bool * mono)2200 status_t AudioSystem::getMasterMono(bool* mono) {
2201 if (mono == nullptr) {
2202 return BAD_VALUE;
2203 }
2204 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2205 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
2206 return statusTFromBinderStatus(aps->getMasterMono(mono));
2207 }
2208
setMasterBalance(float balance)2209 status_t AudioSystem::setMasterBalance(float balance) {
2210 const sp<IAudioFlinger> af = get_audio_flinger();
2211 if (af == nullptr) return AudioFlingerServiceTraits::getError();
2212 return af->setMasterBalance(balance);
2213 }
2214
getMasterBalance(float * balance)2215 status_t AudioSystem::getMasterBalance(float* balance) {
2216 const sp<IAudioFlinger> af = get_audio_flinger();
2217 if (af == nullptr) return AudioFlingerServiceTraits::getError();
2218 return af->getMasterBalance(balance);
2219 }
2220
2221 float
getStreamVolumeDB(audio_stream_type_t stream,int index,audio_devices_t device)2222 AudioSystem::getStreamVolumeDB(audio_stream_type_t stream, int index, audio_devices_t device) {
2223 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2224 if (aps == nullptr) return NAN;
2225
2226 auto result = [&]() -> ConversionResult<float> {
2227 AudioStreamType streamAidl = VALUE_OR_RETURN(
2228 legacy2aidl_audio_stream_type_t_AudioStreamType(stream));
2229 int32_t indexAidl = VALUE_OR_RETURN(convertIntegral<int32_t>(index));
2230 AudioDeviceDescription deviceAidl = VALUE_OR_RETURN(
2231 legacy2aidl_audio_devices_t_AudioDeviceDescription(device));
2232 float retAidl;
2233 RETURN_IF_ERROR(statusTFromBinderStatus(
2234 aps->getStreamVolumeDB(streamAidl, indexAidl, deviceAidl, &retAidl)));
2235 return retAidl;
2236 }();
2237 return result.value_or(NAN);
2238 }
2239
getMicrophones(std::vector<media::MicrophoneInfoFw> * microphones)2240 status_t AudioSystem::getMicrophones(std::vector<media::MicrophoneInfoFw>* microphones) {
2241 const sp<IAudioFlinger> af = get_audio_flinger();
2242 if (af == nullptr) return AudioFlingerServiceTraits::getError();
2243 return af->getMicrophones(microphones);
2244 }
2245
setAudioHalPids(const std::vector<pid_t> & pids)2246 status_t AudioSystem::setAudioHalPids(const std::vector<pid_t>& pids) {
2247 const sp<IAudioFlinger> af = get_audio_flinger();
2248 if (af == nullptr) return AudioFlingerServiceTraits::getError();
2249 return af->setAudioHalPids(pids);
2250 }
2251
getSurroundFormats(unsigned int * numSurroundFormats,audio_format_t * surroundFormats,bool * surroundFormatsEnabled)2252 status_t AudioSystem::getSurroundFormats(unsigned int* numSurroundFormats,
2253 audio_format_t* surroundFormats,
2254 bool* surroundFormatsEnabled) {
2255 if (numSurroundFormats == nullptr || (*numSurroundFormats != 0 &&
2256 (surroundFormats == nullptr ||
2257 surroundFormatsEnabled == nullptr))) {
2258 return BAD_VALUE;
2259 }
2260
2261 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2262 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
2263 Int numSurroundFormatsAidl;
2264 numSurroundFormatsAidl.value =
2265 VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(*numSurroundFormats));
2266 std::vector<AudioFormatDescription> surroundFormatsAidl;
2267 std::vector<bool> surroundFormatsEnabledAidl;
2268 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
2269 aps->getSurroundFormats(&numSurroundFormatsAidl, &surroundFormatsAidl,
2270 &surroundFormatsEnabledAidl)));
2271
2272 *numSurroundFormats = VALUE_OR_RETURN_STATUS(
2273 convertIntegral<unsigned int>(numSurroundFormatsAidl.value));
2274 RETURN_STATUS_IF_ERROR(
2275 convertRange(surroundFormatsAidl.begin(), surroundFormatsAidl.end(), surroundFormats,
2276 aidl2legacy_AudioFormatDescription_audio_format_t));
2277 std::copy(surroundFormatsEnabledAidl.begin(), surroundFormatsEnabledAidl.end(),
2278 surroundFormatsEnabled);
2279 return OK;
2280 }
2281
getReportedSurroundFormats(unsigned int * numSurroundFormats,audio_format_t * surroundFormats)2282 status_t AudioSystem::getReportedSurroundFormats(unsigned int* numSurroundFormats,
2283 audio_format_t* surroundFormats) {
2284 if (numSurroundFormats == nullptr || (*numSurroundFormats != 0 && surroundFormats == nullptr)) {
2285 return BAD_VALUE;
2286 }
2287
2288 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2289 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
2290 Int numSurroundFormatsAidl;
2291 numSurroundFormatsAidl.value =
2292 VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(*numSurroundFormats));
2293 std::vector<AudioFormatDescription> surroundFormatsAidl;
2294 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
2295 aps->getReportedSurroundFormats(&numSurroundFormatsAidl, &surroundFormatsAidl)));
2296
2297 *numSurroundFormats = VALUE_OR_RETURN_STATUS(
2298 convertIntegral<unsigned int>(numSurroundFormatsAidl.value));
2299 RETURN_STATUS_IF_ERROR(
2300 convertRange(surroundFormatsAidl.begin(), surroundFormatsAidl.end(), surroundFormats,
2301 aidl2legacy_AudioFormatDescription_audio_format_t));
2302 return OK;
2303 }
2304
setSurroundFormatEnabled(audio_format_t audioFormat,bool enabled)2305 status_t AudioSystem::setSurroundFormatEnabled(audio_format_t audioFormat, bool enabled) {
2306 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2307 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
2308
2309 AudioFormatDescription audioFormatAidl = VALUE_OR_RETURN_STATUS(
2310 legacy2aidl_audio_format_t_AudioFormatDescription(audioFormat));
2311 return statusTFromBinderStatus(
2312 aps->setSurroundFormatEnabled(audioFormatAidl, enabled));
2313 }
2314
setAssistantServicesUids(const std::vector<uid_t> & uids)2315 status_t AudioSystem::setAssistantServicesUids(const std::vector<uid_t>& uids) {
2316 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2317 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
2318
2319 std::vector<int32_t> uidsAidl = VALUE_OR_RETURN_STATUS(
2320 convertContainer<std::vector<int32_t>>(uids, legacy2aidl_uid_t_int32_t));
2321 return statusTFromBinderStatus(aps->setAssistantServicesUids(uidsAidl));
2322 }
2323
setActiveAssistantServicesUids(const std::vector<uid_t> & activeUids)2324 status_t AudioSystem::setActiveAssistantServicesUids(const std::vector<uid_t>& activeUids) {
2325 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2326 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
2327
2328 std::vector<int32_t> activeUidsAidl = VALUE_OR_RETURN_STATUS(
2329 convertContainer<std::vector<int32_t>>(activeUids, legacy2aidl_uid_t_int32_t));
2330 return statusTFromBinderStatus(aps->setActiveAssistantServicesUids(activeUidsAidl));
2331 }
2332
setA11yServicesUids(const std::vector<uid_t> & uids)2333 status_t AudioSystem::setA11yServicesUids(const std::vector<uid_t>& uids) {
2334 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2335 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
2336
2337 std::vector<int32_t> uidsAidl = VALUE_OR_RETURN_STATUS(
2338 convertContainer<std::vector<int32_t>>(uids, legacy2aidl_uid_t_int32_t));
2339 return statusTFromBinderStatus(aps->setA11yServicesUids(uidsAidl));
2340 }
2341
setCurrentImeUid(uid_t uid)2342 status_t AudioSystem::setCurrentImeUid(uid_t uid) {
2343 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2344 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
2345
2346 int32_t uidAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(uid));
2347 return statusTFromBinderStatus(aps->setCurrentImeUid(uidAidl));
2348 }
2349
isHapticPlaybackSupported()2350 bool AudioSystem::isHapticPlaybackSupported() {
2351 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2352 if (aps == nullptr) return false;
2353
2354 auto result = [&]() -> ConversionResult<bool> {
2355 bool retVal;
2356 RETURN_IF_ERROR(
2357 statusTFromBinderStatus(aps->isHapticPlaybackSupported(&retVal)));
2358 return retVal;
2359 }();
2360 return result.value_or(false);
2361 }
2362
isUltrasoundSupported()2363 bool AudioSystem::isUltrasoundSupported() {
2364 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2365 if (aps == nullptr) return false;
2366
2367 auto result = [&]() -> ConversionResult<bool> {
2368 bool retVal;
2369 RETURN_IF_ERROR(
2370 statusTFromBinderStatus(aps->isUltrasoundSupported(&retVal)));
2371 return retVal;
2372 }();
2373 return result.value_or(false);
2374 }
2375
getHwOffloadFormatsSupportedForBluetoothMedia(audio_devices_t device,std::vector<audio_format_t> * formats)2376 status_t AudioSystem::getHwOffloadFormatsSupportedForBluetoothMedia(
2377 audio_devices_t device, std::vector<audio_format_t>* formats) {
2378 if (formats == nullptr) {
2379 return BAD_VALUE;
2380 }
2381
2382 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2383 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
2384
2385 std::vector<AudioFormatDescription> formatsAidl;
2386 AudioDeviceDescription deviceAidl = VALUE_OR_RETURN_STATUS(
2387 legacy2aidl_audio_devices_t_AudioDeviceDescription(device));
2388 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
2389 aps->getHwOffloadFormatsSupportedForBluetoothMedia(deviceAidl, &formatsAidl)));
2390 *formats = VALUE_OR_RETURN_STATUS(
2391 convertContainer<std::vector<audio_format_t>>(
2392 formatsAidl,
2393 aidl2legacy_AudioFormatDescription_audio_format_t));
2394 return OK;
2395 }
2396
listAudioProductStrategies(AudioProductStrategyVector & strategies)2397 status_t AudioSystem::listAudioProductStrategies(AudioProductStrategyVector& strategies) {
2398 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2399 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
2400
2401 std::vector<media::AudioProductStrategy> strategiesAidl;
2402 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
2403 aps->listAudioProductStrategies(&strategiesAidl)));
2404 strategies = VALUE_OR_RETURN_STATUS(
2405 convertContainer<AudioProductStrategyVector>(strategiesAidl,
2406 aidl2legacy_AudioProductStrategy));
2407 return OK;
2408 }
2409
streamTypeToAttributes(audio_stream_type_t stream)2410 audio_attributes_t AudioSystem::streamTypeToAttributes(audio_stream_type_t stream) {
2411 AudioProductStrategyVector strategies;
2412 listAudioProductStrategies(strategies);
2413 for (const auto& strategy : strategies) {
2414 auto attrVect = strategy.getVolumeGroupAttributes();
2415 auto iter = std::find_if(begin(attrVect), end(attrVect), [&stream](const auto& attributes) {
2416 return attributes.getStreamType() == stream;
2417 });
2418 if (iter != end(attrVect)) {
2419 return iter->getAttributes();
2420 }
2421 }
2422 ALOGE("invalid stream type %s when converting to attributes", toString(stream).c_str());
2423 return AUDIO_ATTRIBUTES_INITIALIZER;
2424 }
2425
attributesToStreamType(const audio_attributes_t & attr)2426 audio_stream_type_t AudioSystem::attributesToStreamType(const audio_attributes_t& attr) {
2427 product_strategy_t psId;
2428 status_t ret = AudioSystem::getProductStrategyFromAudioAttributes(attr, psId);
2429 if (ret != NO_ERROR) {
2430 ALOGE("no strategy found for attributes %s", toString(attr).c_str());
2431 return AUDIO_STREAM_MUSIC;
2432 }
2433 AudioProductStrategyVector strategies;
2434 listAudioProductStrategies(strategies);
2435 for (const auto& strategy : strategies) {
2436 if (strategy.getId() == psId) {
2437 auto attrVect = strategy.getVolumeGroupAttributes();
2438 auto iter = std::find_if(begin(attrVect), end(attrVect), [&attr](const auto& refAttr) {
2439 return refAttr.matchesScore(attr) > 0;
2440 });
2441 if (iter != end(attrVect)) {
2442 return iter->getStreamType();
2443 }
2444 }
2445 }
2446 switch (attr.usage) {
2447 case AUDIO_USAGE_VIRTUAL_SOURCE:
2448 // virtual source is not expected to have an associated product strategy
2449 break;
2450 default:
2451 ALOGE("invalid attributes %s when converting to stream", toString(attr).c_str());
2452 break;
2453 }
2454 return AUDIO_STREAM_MUSIC;
2455 }
2456
getProductStrategyFromAudioAttributes(const audio_attributes_t & aa,product_strategy_t & productStrategy,bool fallbackOnDefault)2457 status_t AudioSystem::getProductStrategyFromAudioAttributes(const audio_attributes_t& aa,
2458 product_strategy_t& productStrategy,
2459 bool fallbackOnDefault) {
2460 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2461 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
2462
2463 media::audio::common::AudioAttributes aaAidl = VALUE_OR_RETURN_STATUS(
2464 legacy2aidl_audio_attributes_t_AudioAttributes(aa));
2465 int32_t productStrategyAidl;
2466
2467 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
2468 aps->getProductStrategyFromAudioAttributes(aaAidl, fallbackOnDefault,
2469 &productStrategyAidl)));
2470 productStrategy = VALUE_OR_RETURN_STATUS(
2471 aidl2legacy_int32_t_product_strategy_t(productStrategyAidl));
2472 return OK;
2473 }
2474
listAudioVolumeGroups(AudioVolumeGroupVector & groups)2475 status_t AudioSystem::listAudioVolumeGroups(AudioVolumeGroupVector& groups) {
2476 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2477 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
2478
2479 std::vector<media::AudioVolumeGroup> groupsAidl;
2480 RETURN_STATUS_IF_ERROR(
2481 statusTFromBinderStatus(aps->listAudioVolumeGroups(&groupsAidl)));
2482 groups = VALUE_OR_RETURN_STATUS(
2483 convertContainer<AudioVolumeGroupVector>(groupsAidl, aidl2legacy_AudioVolumeGroup));
2484 return OK;
2485 }
2486
getVolumeGroupFromAudioAttributes(const audio_attributes_t & aa,volume_group_t & volumeGroup,bool fallbackOnDefault)2487 status_t AudioSystem::getVolumeGroupFromAudioAttributes(const audio_attributes_t &aa,
2488 volume_group_t& volumeGroup,
2489 bool fallbackOnDefault) {
2490 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2491 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
2492
2493 media::audio::common::AudioAttributes aaAidl = VALUE_OR_RETURN_STATUS(
2494 legacy2aidl_audio_attributes_t_AudioAttributes(aa));
2495 int32_t volumeGroupAidl;
2496 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
2497 aps->getVolumeGroupFromAudioAttributes(aaAidl, fallbackOnDefault, &volumeGroupAidl)));
2498 volumeGroup = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_volume_group_t(volumeGroupAidl));
2499 return OK;
2500 }
2501
setRttEnabled(bool enabled)2502 status_t AudioSystem::setRttEnabled(bool enabled) {
2503 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2504 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
2505 return statusTFromBinderStatus(aps->setRttEnabled(enabled));
2506 }
2507
isCallScreenModeSupported()2508 bool AudioSystem::isCallScreenModeSupported() {
2509 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2510 if (aps == nullptr) return false;
2511
2512 auto result = [&]() -> ConversionResult<bool> {
2513 bool retAidl;
2514 RETURN_IF_ERROR(
2515 statusTFromBinderStatus(aps->isCallScreenModeSupported(&retAidl)));
2516 return retAidl;
2517 }();
2518 return result.value_or(false);
2519 }
2520
setDevicesRoleForStrategy(product_strategy_t strategy,device_role_t role,const AudioDeviceTypeAddrVector & devices)2521 status_t AudioSystem::setDevicesRoleForStrategy(product_strategy_t strategy,
2522 device_role_t role,
2523 const AudioDeviceTypeAddrVector& devices) {
2524 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2525 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
2526
2527 int32_t strategyAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_product_strategy_t_int32_t(strategy));
2528 media::DeviceRole roleAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_device_role_t_DeviceRole(role));
2529 std::vector<AudioDevice> devicesAidl = VALUE_OR_RETURN_STATUS(
2530 convertContainer<std::vector<AudioDevice>>(devices,
2531 legacy2aidl_AudioDeviceTypeAddress));
2532 return statusTFromBinderStatus(
2533 aps->setDevicesRoleForStrategy(strategyAidl, roleAidl, devicesAidl));
2534 }
2535
removeDevicesRoleForStrategy(product_strategy_t strategy,device_role_t role,const AudioDeviceTypeAddrVector & devices)2536 status_t AudioSystem::removeDevicesRoleForStrategy(product_strategy_t strategy,
2537 device_role_t role,
2538 const AudioDeviceTypeAddrVector& devices) {
2539 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2540 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
2541
2542 int32_t strategyAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_product_strategy_t_int32_t(strategy));
2543 media::DeviceRole roleAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_device_role_t_DeviceRole(role));
2544 std::vector<AudioDevice> devicesAidl = VALUE_OR_RETURN_STATUS(
2545 convertContainer<std::vector<AudioDevice>>(devices,
2546 legacy2aidl_AudioDeviceTypeAddress));
2547 return statusTFromBinderStatus(
2548 aps->removeDevicesRoleForStrategy(strategyAidl, roleAidl, devicesAidl));
2549 }
2550
2551 status_t
clearDevicesRoleForStrategy(product_strategy_t strategy,device_role_t role)2552 AudioSystem::clearDevicesRoleForStrategy(product_strategy_t strategy, device_role_t role) {
2553 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2554 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
2555
2556 int32_t strategyAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_product_strategy_t_int32_t(strategy));
2557 media::DeviceRole roleAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_device_role_t_DeviceRole(role));
2558 return statusTFromBinderStatus(
2559 aps->clearDevicesRoleForStrategy(strategyAidl, roleAidl));
2560 }
2561
getDevicesForRoleAndStrategy(product_strategy_t strategy,device_role_t role,AudioDeviceTypeAddrVector & devices)2562 status_t AudioSystem::getDevicesForRoleAndStrategy(product_strategy_t strategy,
2563 device_role_t role,
2564 AudioDeviceTypeAddrVector& devices) {
2565 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2566 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
2567
2568 int32_t strategyAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_product_strategy_t_int32_t(strategy));
2569 media::DeviceRole roleAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_device_role_t_DeviceRole(role));
2570 std::vector<AudioDevice> devicesAidl;
2571 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
2572 aps->getDevicesForRoleAndStrategy(strategyAidl, roleAidl, &devicesAidl)));
2573 devices = VALUE_OR_RETURN_STATUS(
2574 convertContainer<AudioDeviceTypeAddrVector>(devicesAidl,
2575 aidl2legacy_AudioDeviceTypeAddress));
2576 return OK;
2577 }
2578
setDevicesRoleForCapturePreset(audio_source_t audioSource,device_role_t role,const AudioDeviceTypeAddrVector & devices)2579 status_t AudioSystem::setDevicesRoleForCapturePreset(audio_source_t audioSource,
2580 device_role_t role,
2581 const AudioDeviceTypeAddrVector& devices) {
2582 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2583 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
2584
2585 AudioSource audioSourceAidl = VALUE_OR_RETURN_STATUS(
2586 legacy2aidl_audio_source_t_AudioSource(audioSource));
2587 media::DeviceRole roleAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_device_role_t_DeviceRole(role));
2588 std::vector<AudioDevice> devicesAidl = VALUE_OR_RETURN_STATUS(
2589 convertContainer<std::vector<AudioDevice>>(devices,
2590 legacy2aidl_AudioDeviceTypeAddress));
2591 return statusTFromBinderStatus(
2592 aps->setDevicesRoleForCapturePreset(audioSourceAidl, roleAidl, devicesAidl));
2593 }
2594
addDevicesRoleForCapturePreset(audio_source_t audioSource,device_role_t role,const AudioDeviceTypeAddrVector & devices)2595 status_t AudioSystem::addDevicesRoleForCapturePreset(audio_source_t audioSource,
2596 device_role_t role,
2597 const AudioDeviceTypeAddrVector& devices) {
2598 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2599 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
2600
2601 AudioSource audioSourceAidl = VALUE_OR_RETURN_STATUS(
2602 legacy2aidl_audio_source_t_AudioSource(audioSource));
2603 media::DeviceRole roleAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_device_role_t_DeviceRole(role));
2604 std::vector<AudioDevice> devicesAidl = VALUE_OR_RETURN_STATUS(
2605 convertContainer<std::vector<AudioDevice>>(devices,
2606 legacy2aidl_AudioDeviceTypeAddress));
2607 return statusTFromBinderStatus(
2608 aps->addDevicesRoleForCapturePreset(audioSourceAidl, roleAidl, devicesAidl));
2609 }
2610
removeDevicesRoleForCapturePreset(audio_source_t audioSource,device_role_t role,const AudioDeviceTypeAddrVector & devices)2611 status_t AudioSystem::removeDevicesRoleForCapturePreset(
2612 audio_source_t audioSource, device_role_t role, const AudioDeviceTypeAddrVector& devices) {
2613 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2614 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
2615
2616 AudioSource audioSourceAidl = VALUE_OR_RETURN_STATUS(
2617 legacy2aidl_audio_source_t_AudioSource(audioSource));
2618 media::DeviceRole roleAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_device_role_t_DeviceRole(role));
2619 std::vector<AudioDevice> devicesAidl = VALUE_OR_RETURN_STATUS(
2620 convertContainer<std::vector<AudioDevice>>(devices,
2621 legacy2aidl_AudioDeviceTypeAddress));
2622 return statusTFromBinderStatus(
2623 aps->removeDevicesRoleForCapturePreset(audioSourceAidl, roleAidl, devicesAidl));
2624 }
2625
clearDevicesRoleForCapturePreset(audio_source_t audioSource,device_role_t role)2626 status_t AudioSystem::clearDevicesRoleForCapturePreset(audio_source_t audioSource,
2627 device_role_t role) {
2628 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2629 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
2630
2631 AudioSource audioSourceAidl = VALUE_OR_RETURN_STATUS(
2632 legacy2aidl_audio_source_t_AudioSource(audioSource));
2633 media::DeviceRole roleAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_device_role_t_DeviceRole(role));
2634 return statusTFromBinderStatus(
2635 aps->clearDevicesRoleForCapturePreset(audioSourceAidl, roleAidl));
2636 }
2637
getDevicesForRoleAndCapturePreset(audio_source_t audioSource,device_role_t role,AudioDeviceTypeAddrVector & devices)2638 status_t AudioSystem::getDevicesForRoleAndCapturePreset(audio_source_t audioSource,
2639 device_role_t role,
2640 AudioDeviceTypeAddrVector& devices) {
2641 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2642 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
2643 AudioSource audioSourceAidl = VALUE_OR_RETURN_STATUS(
2644 legacy2aidl_audio_source_t_AudioSource(audioSource));
2645 media::DeviceRole roleAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_device_role_t_DeviceRole(role));
2646 std::vector<AudioDevice> devicesAidl;
2647 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
2648 aps->getDevicesForRoleAndCapturePreset(audioSourceAidl, roleAidl, &devicesAidl)));
2649 devices = VALUE_OR_RETURN_STATUS(
2650 convertContainer<AudioDeviceTypeAddrVector>(devicesAidl,
2651 aidl2legacy_AudioDeviceTypeAddress));
2652 return OK;
2653 }
2654
getSpatializer(const sp<media::INativeSpatializerCallback> & callback,sp<media::ISpatializer> * spatializer)2655 status_t AudioSystem::getSpatializer(const sp<media::INativeSpatializerCallback>& callback,
2656 sp<media::ISpatializer>* spatializer) {
2657 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2658 if (spatializer == nullptr) {
2659 return BAD_VALUE;
2660 }
2661 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
2662 media::GetSpatializerResponse response;
2663 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
2664 aps->getSpatializer(callback, &response)));
2665
2666 *spatializer = response.spatializer;
2667 return OK;
2668 }
2669
canBeSpatialized(const audio_attributes_t * attr,const audio_config_t * config,const AudioDeviceTypeAddrVector & devices,bool * canBeSpatialized)2670 status_t AudioSystem::canBeSpatialized(const audio_attributes_t *attr,
2671 const audio_config_t *config,
2672 const AudioDeviceTypeAddrVector &devices,
2673 bool *canBeSpatialized) {
2674 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2675 if (canBeSpatialized == nullptr) {
2676 return BAD_VALUE;
2677 }
2678 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
2679 audio_attributes_t attributes = attr != nullptr ? *attr : AUDIO_ATTRIBUTES_INITIALIZER;
2680 audio_config_t configuration = config != nullptr ? *config : AUDIO_CONFIG_INITIALIZER;
2681
2682 std::optional<media::audio::common::AudioAttributes> attrAidl = VALUE_OR_RETURN_STATUS(
2683 legacy2aidl_audio_attributes_t_AudioAttributes(attributes));
2684 std::optional<AudioConfig> configAidl = VALUE_OR_RETURN_STATUS(
2685 legacy2aidl_audio_config_t_AudioConfig(configuration, false /*isInput*/));
2686 std::vector<AudioDevice> devicesAidl = VALUE_OR_RETURN_STATUS(
2687 convertContainer<std::vector<AudioDevice>>(devices,
2688 legacy2aidl_AudioDeviceTypeAddress));
2689 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
2690 aps->canBeSpatialized(attrAidl, configAidl, devicesAidl, canBeSpatialized)));
2691 return OK;
2692 }
2693
getSoundDoseInterface(const sp<media::ISoundDoseCallback> & callback,sp<media::ISoundDose> * soundDose)2694 status_t AudioSystem::getSoundDoseInterface(const sp<media::ISoundDoseCallback>& callback,
2695 sp<media::ISoundDose>* soundDose) {
2696 const sp<IAudioFlinger> af = get_audio_flinger();
2697 if (af == nullptr) return AudioFlingerServiceTraits::getError();
2698 if (soundDose == nullptr) {
2699 return BAD_VALUE;
2700 }
2701
2702 RETURN_STATUS_IF_ERROR(af->getSoundDoseInterface(callback, soundDose));
2703 return OK;
2704 }
2705
getDirectPlaybackSupport(const audio_attributes_t * attr,const audio_config_t * config,audio_direct_mode_t * directMode)2706 status_t AudioSystem::getDirectPlaybackSupport(const audio_attributes_t *attr,
2707 const audio_config_t *config,
2708 audio_direct_mode_t* directMode) {
2709 if (attr == nullptr || config == nullptr || directMode == nullptr) {
2710 return BAD_VALUE;
2711 }
2712
2713 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2714 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
2715
2716 media::audio::common::AudioAttributes attrAidl = VALUE_OR_RETURN_STATUS(
2717 legacy2aidl_audio_attributes_t_AudioAttributes(*attr));
2718 AudioConfig configAidl = VALUE_OR_RETURN_STATUS(
2719 legacy2aidl_audio_config_t_AudioConfig(*config, false /*isInput*/));
2720
2721 media::AudioDirectMode retAidl;
2722 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
2723 aps->getDirectPlaybackSupport(attrAidl, configAidl, &retAidl)));
2724 *directMode = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_audio_direct_mode_t_mask(
2725 static_cast<int32_t>(retAidl)));
2726 return NO_ERROR;
2727 }
2728
getDirectProfilesForAttributes(const audio_attributes_t * attr,std::vector<audio_profile> * audioProfiles)2729 status_t AudioSystem::getDirectProfilesForAttributes(const audio_attributes_t* attr,
2730 std::vector<audio_profile>* audioProfiles) {
2731 if (attr == nullptr || audioProfiles == nullptr) {
2732 return BAD_VALUE;
2733 }
2734
2735 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2736 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
2737
2738 media::audio::common::AudioAttributes attrAidl = VALUE_OR_RETURN_STATUS(
2739 legacy2aidl_audio_attributes_t_AudioAttributes(*attr));
2740
2741 std::vector<media::audio::common::AudioProfile> audioProfilesAidl;
2742 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
2743 aps->getDirectProfilesForAttributes(attrAidl, &audioProfilesAidl)));
2744 *audioProfiles = VALUE_OR_RETURN_STATUS(convertContainer<std::vector<audio_profile>>(
2745 audioProfilesAidl, aidl2legacy_AudioProfile_audio_profile, false /*isInput*/));
2746
2747 return NO_ERROR;
2748 }
2749
setRequestedLatencyMode(audio_io_handle_t output,audio_latency_mode_t mode)2750 status_t AudioSystem::setRequestedLatencyMode(
2751 audio_io_handle_t output, audio_latency_mode_t mode) {
2752 const sp<IAudioFlinger> af = get_audio_flinger();
2753 if (af == nullptr) return AudioFlingerServiceTraits::getError();
2754 return af->setRequestedLatencyMode(output, mode);
2755 }
2756
getSupportedLatencyModes(audio_io_handle_t output,std::vector<audio_latency_mode_t> * modes)2757 status_t AudioSystem::getSupportedLatencyModes(audio_io_handle_t output,
2758 std::vector<audio_latency_mode_t>* modes) {
2759 const sp<IAudioFlinger> af = get_audio_flinger();
2760 if (af == nullptr) return AudioFlingerServiceTraits::getError();
2761 return af->getSupportedLatencyModes(output, modes);
2762 }
2763
setBluetoothVariableLatencyEnabled(bool enabled)2764 status_t AudioSystem::setBluetoothVariableLatencyEnabled(bool enabled) {
2765 const sp<IAudioFlinger> af = get_audio_flinger();
2766 if (af == nullptr) return AudioFlingerServiceTraits::getError();
2767 return af->setBluetoothVariableLatencyEnabled(enabled);
2768 }
2769
isBluetoothVariableLatencyEnabled(bool * enabled)2770 status_t AudioSystem::isBluetoothVariableLatencyEnabled(
2771 bool *enabled) {
2772 const sp<IAudioFlinger> af = get_audio_flinger();
2773 if (af == nullptr) return AudioFlingerServiceTraits::getError();
2774 return af->isBluetoothVariableLatencyEnabled(enabled);
2775 }
2776
supportsBluetoothVariableLatency(bool * support)2777 status_t AudioSystem::supportsBluetoothVariableLatency(
2778 bool *support) {
2779 const sp<IAudioFlinger> af = get_audio_flinger();
2780 if (af == nullptr) return AudioFlingerServiceTraits::getError();
2781 return af->supportsBluetoothVariableLatency(support);
2782 }
2783
getAudioPolicyConfig(media::AudioPolicyConfig * config)2784 status_t AudioSystem::getAudioPolicyConfig(media::AudioPolicyConfig *config) {
2785 const sp<IAudioFlinger> af = get_audio_flinger();
2786 if (af == nullptr) return AudioFlingerServiceTraits::getError();
2787 return af->getAudioPolicyConfig(config);
2788 }
2789
2790 class CaptureStateListenerImpl : public media::BnCaptureStateListener,
2791 public IBinder::DeathRecipient {
2792 public:
CaptureStateListenerImpl(const sp<IAudioPolicyService> & aps,const sp<AudioSystem::CaptureStateListener> & listener)2793 CaptureStateListenerImpl(
2794 const sp<IAudioPolicyService>& aps,
2795 const sp<AudioSystem::CaptureStateListener>& listener)
2796 : mAps(aps), mListener(listener) {}
2797
init()2798 void init() {
2799 bool active;
2800 status_t status = statusTFromBinderStatus(
2801 mAps->registerSoundTriggerCaptureStateListener(this, &active));
2802 if (status != NO_ERROR) {
2803 mListener->onServiceDied();
2804 return;
2805 }
2806 mListener->onStateChanged(active);
2807 IInterface::asBinder(mAps)->linkToDeath(this);
2808 }
2809
setCaptureState(bool active)2810 binder::Status setCaptureState(bool active) override {
2811 std::lock_guard _l(AudioSystem::gSoundTriggerMutex);
2812 mListener->onStateChanged(active);
2813 return binder::Status::ok();
2814 }
2815
binderDied(const wp<IBinder> &)2816 void binderDied(const wp<IBinder>&) override {
2817 std::lock_guard _l(AudioSystem::gSoundTriggerMutex);
2818 mListener->onServiceDied();
2819 AudioSystem::gSoundTriggerCaptureStateListener = nullptr;
2820 }
2821
2822 private:
2823 // Need this in order to keep the death receipent alive.
2824 sp<IAudioPolicyService> mAps;
2825 sp<AudioSystem::CaptureStateListener> mListener;
2826 };
2827
registerSoundTriggerCaptureStateListener(const sp<CaptureStateListener> & listener)2828 status_t AudioSystem::registerSoundTriggerCaptureStateListener(
2829 const sp<CaptureStateListener>& listener) {
2830 LOG_ALWAYS_FATAL_IF(listener == nullptr);
2831
2832 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2833 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
2834
2835 std::lock_guard _l(AudioSystem::gSoundTriggerMutex);
2836 gSoundTriggerCaptureStateListener = new CaptureStateListenerImpl(aps, listener);
2837 gSoundTriggerCaptureStateListener->init();
2838
2839 return NO_ERROR;
2840 }
2841
setVibratorInfos(const std::vector<media::AudioVibratorInfo> & vibratorInfos)2842 status_t AudioSystem::setVibratorInfos(
2843 const std::vector<media::AudioVibratorInfo>& vibratorInfos) {
2844 const sp<IAudioFlinger> af = get_audio_flinger();
2845 if (af == nullptr) return AudioFlingerServiceTraits::getError();
2846 return af->setVibratorInfos(vibratorInfos);
2847 }
2848
getMmapPolicyInfos(AudioMMapPolicyType policyType,std::vector<AudioMMapPolicyInfo> * policyInfos)2849 status_t AudioSystem::getMmapPolicyInfos(
2850 AudioMMapPolicyType policyType, std::vector<AudioMMapPolicyInfo> *policyInfos) {
2851 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2852 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
2853 return statusTFromBinderStatus(aps->getMmapPolicyInfos(policyType, policyInfos));
2854 }
2855
getAAudioMixerBurstCount()2856 int32_t AudioSystem::getAAudioMixerBurstCount() {
2857 const sp<IAudioFlinger> af = get_audio_flinger();
2858 if (af == nullptr) return AudioFlingerServiceTraits::getError();
2859 return af->getAAudioMixerBurstCount();
2860 }
2861
getAAudioHardwareBurstMinUsec()2862 int32_t AudioSystem::getAAudioHardwareBurstMinUsec() {
2863 const sp<IAudioFlinger> af = get_audio_flinger();
2864 if (af == nullptr) return AudioFlingerServiceTraits::getError();
2865 return af->getAAudioHardwareBurstMinUsec();
2866 }
2867
getSupportedMixerAttributes(audio_port_handle_t portId,std::vector<audio_mixer_attributes_t> * mixerAttrs)2868 status_t AudioSystem::getSupportedMixerAttributes(
2869 audio_port_handle_t portId, std::vector<audio_mixer_attributes_t> *mixerAttrs) {
2870 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2871 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
2872
2873 int32_t portIdAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_port_handle_t_int32_t(portId));
2874 std::vector<media::AudioMixerAttributesInternal> _aidlReturn;
2875 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
2876 aps->getSupportedMixerAttributes(portIdAidl, &_aidlReturn)));
2877 *mixerAttrs = VALUE_OR_RETURN_STATUS(
2878 convertContainer<std::vector<audio_mixer_attributes_t>>(
2879 _aidlReturn,
2880 aidl2legacy_AudioMixerAttributesInternal_audio_mixer_attributes_t));
2881 return OK;
2882 }
2883
setPreferredMixerAttributes(const audio_attributes_t * attr,audio_port_handle_t portId,uid_t uid,const audio_mixer_attributes_t * mixerAttr)2884 status_t AudioSystem::setPreferredMixerAttributes(const audio_attributes_t *attr,
2885 audio_port_handle_t portId,
2886 uid_t uid,
2887 const audio_mixer_attributes_t *mixerAttr) {
2888 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2889 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
2890
2891 media::audio::common::AudioAttributes attrAidl = VALUE_OR_RETURN_STATUS(
2892 legacy2aidl_audio_attributes_t_AudioAttributes(*attr));
2893 media::AudioMixerAttributesInternal mixerAttrAidl = VALUE_OR_RETURN_STATUS(
2894 legacy2aidl_audio_mixer_attributes_t_AudioMixerAttributesInternal(*mixerAttr));
2895 int32_t uidAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(uid));
2896 int32_t portIdAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_port_handle_t_int32_t(portId));
2897
2898 return statusTFromBinderStatus(
2899 aps->setPreferredMixerAttributes(attrAidl, portIdAidl, uidAidl, mixerAttrAidl));
2900 }
2901
getPreferredMixerAttributes(const audio_attributes_t * attr,audio_port_handle_t portId,std::optional<audio_mixer_attributes_t> * mixerAttr)2902 status_t AudioSystem::getPreferredMixerAttributes(
2903 const audio_attributes_t *attr,
2904 audio_port_handle_t portId,
2905 std::optional<audio_mixer_attributes_t> *mixerAttr) {
2906 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2907 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
2908
2909 media::audio::common::AudioAttributes attrAidl = VALUE_OR_RETURN_STATUS(
2910 legacy2aidl_audio_attributes_t_AudioAttributes(*attr));
2911 int32_t portIdAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_port_handle_t_int32_t(portId));
2912 std::optional<media::AudioMixerAttributesInternal> _aidlReturn;
2913 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
2914 aps->getPreferredMixerAttributes(attrAidl, portIdAidl, &_aidlReturn)));
2915
2916 if (_aidlReturn.has_value()) {
2917 *mixerAttr = VALUE_OR_RETURN_STATUS(
2918 aidl2legacy_AudioMixerAttributesInternal_audio_mixer_attributes_t(
2919 _aidlReturn.value()));
2920 }
2921 return NO_ERROR;
2922 }
2923
clearPreferredMixerAttributes(const audio_attributes_t * attr,audio_port_handle_t portId,uid_t uid)2924 status_t AudioSystem::clearPreferredMixerAttributes(const audio_attributes_t *attr,
2925 audio_port_handle_t portId,
2926 uid_t uid) {
2927 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2928 if (aps == nullptr) return AudioPolicyServiceTraits::getError();
2929
2930 media::audio::common::AudioAttributes attrAidl = VALUE_OR_RETURN_STATUS(
2931 legacy2aidl_audio_attributes_t_AudioAttributes(*attr));
2932 int32_t uidAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(uid));
2933 int32_t portIdAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_port_handle_t_int32_t(portId));
2934 return statusTFromBinderStatus(
2935 aps->clearPreferredMixerAttributes(attrAidl, portIdAidl, uidAidl));
2936 }
2937
getMmapPolicyForDevice(AudioMMapPolicyType policyType,audio_devices_t device,AudioMMapPolicyInfo * policyInfo)2938 status_t AudioSystem::getMmapPolicyForDevice(AudioMMapPolicyType policyType,
2939 audio_devices_t device,
2940 AudioMMapPolicyInfo *policyInfo) {
2941 const sp<IAudioPolicyService> aps = get_audio_policy_service();
2942 if (aps == nullptr) {
2943 return PERMISSION_DENIED;
2944 }
2945 policyInfo->device.type = VALUE_OR_RETURN_STATUS(
2946 legacy2aidl_audio_devices_t_AudioDeviceDescription(device));
2947 return statusTFromBinderStatus(aps->getMmapPolicyForDevice(policyType, policyInfo));
2948 }
2949
2950 // ---------------------------------------------------------------------------
2951
addAudioPortCallback(const sp<AudioPortCallback> & callback)2952 int AudioSystem::AudioPolicyServiceClient::addAudioPortCallback(
2953 const sp<AudioPortCallback>& callback) {
2954 std::lock_guard _l(mMutex);
2955 return mAudioPortCallbacks.insert(callback).second ? mAudioPortCallbacks.size() : -1;
2956 }
2957
removeAudioPortCallback(const sp<AudioPortCallback> & callback)2958 int AudioSystem::AudioPolicyServiceClient::removeAudioPortCallback(
2959 const sp<AudioPortCallback>& callback) {
2960 std::lock_guard _l(mMutex);
2961 return mAudioPortCallbacks.erase(callback) > 0 ? mAudioPortCallbacks.size() : -1;
2962 }
2963
onAudioPortListUpdate()2964 Status AudioSystem::AudioPolicyServiceClient::onAudioPortListUpdate() {
2965 std::lock_guard _l(mMutex);
2966 for (const auto& callback : mAudioPortCallbacks) {
2967 callback->onAudioPortListUpdate();
2968 }
2969 return Status::ok();
2970 }
2971
onAudioPatchListUpdate()2972 Status AudioSystem::AudioPolicyServiceClient::onAudioPatchListUpdate() {
2973 std::lock_guard _l(mMutex);
2974 for (const auto& callback : mAudioPortCallbacks) {
2975 callback->onAudioPatchListUpdate();
2976 }
2977 return Status::ok();
2978 }
2979
2980 // ----------------------------------------------------------------------------
addAudioVolumeGroupCallback(const sp<AudioVolumeGroupCallback> & callback)2981 int AudioSystem::AudioPolicyServiceClient::addAudioVolumeGroupCallback(
2982 const sp<AudioVolumeGroupCallback>& callback) {
2983 std::lock_guard _l(mMutex);
2984 return mAudioVolumeGroupCallbacks.insert(callback).second
2985 ? mAudioVolumeGroupCallbacks.size() : -1;
2986 }
2987
removeAudioVolumeGroupCallback(const sp<AudioVolumeGroupCallback> & callback)2988 int AudioSystem::AudioPolicyServiceClient::removeAudioVolumeGroupCallback(
2989 const sp<AudioVolumeGroupCallback>& callback) {
2990 std::lock_guard _l(mMutex);
2991 return mAudioVolumeGroupCallbacks.erase(callback) > 0
2992 ? mAudioVolumeGroupCallbacks.size() : -1;
2993 }
2994
onAudioVolumeGroupChanged(int32_t group,int32_t flags)2995 Status AudioSystem::AudioPolicyServiceClient::onAudioVolumeGroupChanged(int32_t group,
2996 int32_t flags) {
2997 volume_group_t groupLegacy = VALUE_OR_RETURN_BINDER_STATUS(
2998 aidl2legacy_int32_t_volume_group_t(group));
2999 int flagsLegacy = VALUE_OR_RETURN_BINDER_STATUS(convertReinterpret<int>(flags));
3000
3001 std::lock_guard _l(mMutex);
3002 for (const auto& callback : mAudioVolumeGroupCallbacks) {
3003 callback->onAudioVolumeGroupChanged(groupLegacy, flagsLegacy);
3004 }
3005 return Status::ok();
3006 }
3007 // ----------------------------------------------------------------------------
3008
onDynamicPolicyMixStateUpdate(const::std::string & regId,int32_t state)3009 Status AudioSystem::AudioPolicyServiceClient::onDynamicPolicyMixStateUpdate(
3010 const ::std::string& regId, int32_t state) {
3011 ALOGV("AudioPolicyServiceClient::onDynamicPolicyMixStateUpdate(%s, %d)", regId.c_str(), state);
3012
3013 String8 regIdLegacy = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_string_view_String8(regId));
3014 int stateLegacy = VALUE_OR_RETURN_BINDER_STATUS(convertReinterpret<int>(state));
3015 dynamic_policy_callback cb = NULL;
3016 {
3017 std::lock_guard _l(AudioSystem::gMutex);
3018 cb = gDynPolicyCallback;
3019 }
3020
3021 if (cb != NULL) {
3022 cb(DYNAMIC_POLICY_EVENT_MIX_STATE_UPDATE, regIdLegacy, stateLegacy);
3023 }
3024 return Status::ok();
3025 }
3026
onRecordingConfigurationUpdate(int32_t event,const media::RecordClientInfo & clientInfo,const AudioConfigBase & clientConfig,const std::vector<media::EffectDescriptor> & clientEffects,const AudioConfigBase & deviceConfig,const std::vector<media::EffectDescriptor> & effects,int32_t patchHandle,AudioSource source)3027 Status AudioSystem::AudioPolicyServiceClient::onRecordingConfigurationUpdate(
3028 int32_t event,
3029 const media::RecordClientInfo& clientInfo,
3030 const AudioConfigBase& clientConfig,
3031 const std::vector<media::EffectDescriptor>& clientEffects,
3032 const AudioConfigBase& deviceConfig,
3033 const std::vector<media::EffectDescriptor>& effects,
3034 int32_t patchHandle,
3035 AudioSource source) {
3036 record_config_callback cb = NULL;
3037 {
3038 std::lock_guard _l(AudioSystem::gMutex);
3039 cb = gRecordConfigCallback;
3040 }
3041
3042 if (cb != NULL) {
3043 int eventLegacy = VALUE_OR_RETURN_BINDER_STATUS(convertReinterpret<int>(event));
3044 record_client_info_t clientInfoLegacy = VALUE_OR_RETURN_BINDER_STATUS(
3045 aidl2legacy_RecordClientInfo_record_client_info_t(clientInfo));
3046 audio_config_base_t clientConfigLegacy = VALUE_OR_RETURN_BINDER_STATUS(
3047 aidl2legacy_AudioConfigBase_audio_config_base_t(clientConfig, true /*isInput*/));
3048 std::vector<effect_descriptor_t> clientEffectsLegacy = VALUE_OR_RETURN_BINDER_STATUS(
3049 convertContainer<std::vector<effect_descriptor_t>>(
3050 clientEffects,
3051 aidl2legacy_EffectDescriptor_effect_descriptor_t));
3052 audio_config_base_t deviceConfigLegacy = VALUE_OR_RETURN_BINDER_STATUS(
3053 aidl2legacy_AudioConfigBase_audio_config_base_t(deviceConfig, true /*isInput*/));
3054 std::vector<effect_descriptor_t> effectsLegacy = VALUE_OR_RETURN_BINDER_STATUS(
3055 convertContainer<std::vector<effect_descriptor_t>>(
3056 effects,
3057 aidl2legacy_EffectDescriptor_effect_descriptor_t));
3058 audio_patch_handle_t patchHandleLegacy = VALUE_OR_RETURN_BINDER_STATUS(
3059 aidl2legacy_int32_t_audio_patch_handle_t(patchHandle));
3060 audio_source_t sourceLegacy = VALUE_OR_RETURN_BINDER_STATUS(
3061 aidl2legacy_AudioSource_audio_source_t(source));
3062 cb(eventLegacy, &clientInfoLegacy, &clientConfigLegacy, clientEffectsLegacy,
3063 &deviceConfigLegacy, effectsLegacy, patchHandleLegacy, sourceLegacy);
3064 }
3065 return Status::ok();
3066 }
3067
onRoutingUpdated()3068 Status AudioSystem::AudioPolicyServiceClient::onRoutingUpdated() {
3069 routing_callback cb = NULL;
3070 {
3071 std::lock_guard _l(AudioSystem::gMutex);
3072 cb = gRoutingCallback;
3073 }
3074
3075 if (cb != NULL) {
3076 cb();
3077 }
3078 return Status::ok();
3079 }
3080
onVolumeRangeInitRequest()3081 Status AudioSystem::AudioPolicyServiceClient::onVolumeRangeInitRequest() {
3082 vol_range_init_req_callback cb = NULL;
3083 {
3084 std::lock_guard _l(AudioSystem::gMutex);
3085 cb = gVolRangeInitReqCallback;
3086 }
3087
3088 if (cb != NULL) {
3089 cb();
3090 }
3091 return Status::ok();
3092 }
3093
onServiceDied()3094 void AudioSystem::AudioPolicyServiceClient::onServiceDied() {
3095 std::lock_guard _l(mMutex);
3096 for (const auto& callback : mAudioPortCallbacks) {
3097 callback->onServiceDied();
3098 }
3099 for (const auto& callback : mAudioVolumeGroupCallbacks) {
3100 callback->onServiceDied();
3101 }
3102 }
3103
3104 ConversionResult<record_client_info_t>
aidl2legacy_RecordClientInfo_record_client_info_t(const media::RecordClientInfo & aidl)3105 aidl2legacy_RecordClientInfo_record_client_info_t(const media::RecordClientInfo& aidl) {
3106 record_client_info_t legacy;
3107 legacy.riid = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_unique_id_t(aidl.riid));
3108 legacy.uid = VALUE_OR_RETURN(aidl2legacy_int32_t_uid_t(aidl.uid));
3109 legacy.session = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_session_t(aidl.session));
3110 legacy.source = VALUE_OR_RETURN(aidl2legacy_AudioSource_audio_source_t(aidl.source));
3111 legacy.port_id = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_port_handle_t(aidl.portId));
3112 legacy.silenced = aidl.silenced;
3113 return legacy;
3114 }
3115
3116 ConversionResult<media::RecordClientInfo>
legacy2aidl_record_client_info_t_RecordClientInfo(const record_client_info_t & legacy)3117 legacy2aidl_record_client_info_t_RecordClientInfo(const record_client_info_t& legacy) {
3118 media::RecordClientInfo aidl;
3119 aidl.riid = VALUE_OR_RETURN(legacy2aidl_audio_unique_id_t_int32_t(legacy.riid));
3120 aidl.uid = VALUE_OR_RETURN(legacy2aidl_uid_t_int32_t(legacy.uid));
3121 aidl.session = VALUE_OR_RETURN(legacy2aidl_audio_session_t_int32_t(legacy.session));
3122 aidl.source = VALUE_OR_RETURN(legacy2aidl_audio_source_t_AudioSource(legacy.source));
3123 aidl.portId = VALUE_OR_RETURN(legacy2aidl_audio_port_handle_t_int32_t(legacy.port_id));
3124 aidl.silenced = legacy.silenced;
3125 return aidl;
3126 }
3127
3128 } // namespace android
3129