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