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