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 #include <binder/IServiceManager.h>
22 #include <media/AudioSystem.h>
23 #include <media/IAudioFlinger.h>
24 #include <media/IAudioPolicyService.h>
25 #include <math.h>
26
27 #include <system/audio.h>
28
29 // ----------------------------------------------------------------------------
30
31 namespace android {
32
33 // client singleton for AudioFlinger binder interface
34 Mutex AudioSystem::gLock;
35 Mutex AudioSystem::gLockAPS;
36 sp<IAudioFlinger> AudioSystem::gAudioFlinger;
37 sp<AudioSystem::AudioFlingerClient> AudioSystem::gAudioFlingerClient;
38 audio_error_callback AudioSystem::gAudioErrorCallback = NULL;
39 dynamic_policy_callback AudioSystem::gDynPolicyCallback = NULL;
40
41
42 // establish binder interface to AudioFlinger service
get_audio_flinger()43 const sp<IAudioFlinger> AudioSystem::get_audio_flinger()
44 {
45 sp<IAudioFlinger> af;
46 sp<AudioFlingerClient> afc;
47 {
48 Mutex::Autolock _l(gLock);
49 if (gAudioFlinger == 0) {
50 sp<IServiceManager> sm = defaultServiceManager();
51 sp<IBinder> binder;
52 do {
53 binder = sm->getService(String16("media.audio_flinger"));
54 if (binder != 0)
55 break;
56 ALOGW("AudioFlinger not published, waiting...");
57 usleep(500000); // 0.5 s
58 } while (true);
59 if (gAudioFlingerClient == NULL) {
60 gAudioFlingerClient = new AudioFlingerClient();
61 } else {
62 if (gAudioErrorCallback) {
63 gAudioErrorCallback(NO_ERROR);
64 }
65 }
66 binder->linkToDeath(gAudioFlingerClient);
67 gAudioFlinger = interface_cast<IAudioFlinger>(binder);
68 LOG_ALWAYS_FATAL_IF(gAudioFlinger == 0);
69 afc = gAudioFlingerClient;
70 }
71 af = gAudioFlinger;
72 }
73 if (afc != 0) {
74 af->registerClient(afc);
75 }
76 return af;
77 }
78
getAudioFlingerClient()79 const sp<AudioSystem::AudioFlingerClient> AudioSystem::getAudioFlingerClient()
80 {
81 // calling get_audio_flinger() will initialize gAudioFlingerClient if needed
82 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
83 if (af == 0) return 0;
84 Mutex::Autolock _l(gLock);
85 return gAudioFlingerClient;
86 }
87
getIoDescriptor(audio_io_handle_t ioHandle)88 sp<AudioIoDescriptor> AudioSystem::getIoDescriptor(audio_io_handle_t ioHandle)
89 {
90 sp<AudioIoDescriptor> desc;
91 const sp<AudioFlingerClient> afc = getAudioFlingerClient();
92 if (afc != 0) {
93 desc = afc->getIoDescriptor(ioHandle);
94 }
95 return desc;
96 }
97
checkAudioFlinger()98 /* static */ status_t AudioSystem::checkAudioFlinger()
99 {
100 if (defaultServiceManager()->checkService(String16("media.audio_flinger")) != 0) {
101 return NO_ERROR;
102 }
103 return DEAD_OBJECT;
104 }
105
muteMicrophone(bool state)106 status_t AudioSystem::muteMicrophone(bool state)
107 {
108 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
109 if (af == 0) return PERMISSION_DENIED;
110 return af->setMicMute(state);
111 }
112
isMicrophoneMuted(bool * state)113 status_t AudioSystem::isMicrophoneMuted(bool* state)
114 {
115 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
116 if (af == 0) return PERMISSION_DENIED;
117 *state = af->getMicMute();
118 return NO_ERROR;
119 }
120
setMasterVolume(float value)121 status_t AudioSystem::setMasterVolume(float value)
122 {
123 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
124 if (af == 0) return PERMISSION_DENIED;
125 af->setMasterVolume(value);
126 return NO_ERROR;
127 }
128
setMasterMute(bool mute)129 status_t AudioSystem::setMasterMute(bool mute)
130 {
131 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
132 if (af == 0) return PERMISSION_DENIED;
133 af->setMasterMute(mute);
134 return NO_ERROR;
135 }
136
getMasterVolume(float * volume)137 status_t AudioSystem::getMasterVolume(float* volume)
138 {
139 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
140 if (af == 0) return PERMISSION_DENIED;
141 *volume = af->masterVolume();
142 return NO_ERROR;
143 }
144
getMasterMute(bool * mute)145 status_t AudioSystem::getMasterMute(bool* mute)
146 {
147 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
148 if (af == 0) return PERMISSION_DENIED;
149 *mute = af->masterMute();
150 return NO_ERROR;
151 }
152
setStreamVolume(audio_stream_type_t stream,float value,audio_io_handle_t output)153 status_t AudioSystem::setStreamVolume(audio_stream_type_t stream, float value,
154 audio_io_handle_t output)
155 {
156 if (uint32_t(stream) >= AUDIO_STREAM_CNT) return BAD_VALUE;
157 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
158 if (af == 0) return PERMISSION_DENIED;
159 af->setStreamVolume(stream, value, output);
160 return NO_ERROR;
161 }
162
setStreamMute(audio_stream_type_t stream,bool mute)163 status_t AudioSystem::setStreamMute(audio_stream_type_t stream, bool mute)
164 {
165 if (uint32_t(stream) >= AUDIO_STREAM_CNT) return BAD_VALUE;
166 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
167 if (af == 0) return PERMISSION_DENIED;
168 af->setStreamMute(stream, mute);
169 return NO_ERROR;
170 }
171
getStreamVolume(audio_stream_type_t stream,float * volume,audio_io_handle_t output)172 status_t AudioSystem::getStreamVolume(audio_stream_type_t stream, float* volume,
173 audio_io_handle_t output)
174 {
175 if (uint32_t(stream) >= AUDIO_STREAM_CNT) return BAD_VALUE;
176 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
177 if (af == 0) return PERMISSION_DENIED;
178 *volume = af->streamVolume(stream, output);
179 return NO_ERROR;
180 }
181
getStreamMute(audio_stream_type_t stream,bool * mute)182 status_t AudioSystem::getStreamMute(audio_stream_type_t stream, bool* mute)
183 {
184 if (uint32_t(stream) >= AUDIO_STREAM_CNT) return BAD_VALUE;
185 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
186 if (af == 0) return PERMISSION_DENIED;
187 *mute = af->streamMute(stream);
188 return NO_ERROR;
189 }
190
setMode(audio_mode_t mode)191 status_t AudioSystem::setMode(audio_mode_t mode)
192 {
193 if (uint32_t(mode) >= AUDIO_MODE_CNT) return BAD_VALUE;
194 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
195 if (af == 0) return PERMISSION_DENIED;
196 return af->setMode(mode);
197 }
198
setParameters(audio_io_handle_t ioHandle,const String8 & keyValuePairs)199 status_t AudioSystem::setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs)
200 {
201 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
202 if (af == 0) return PERMISSION_DENIED;
203 return af->setParameters(ioHandle, keyValuePairs);
204 }
205
getParameters(audio_io_handle_t ioHandle,const String8 & keys)206 String8 AudioSystem::getParameters(audio_io_handle_t ioHandle, const String8& keys)
207 {
208 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
209 String8 result = String8("");
210 if (af == 0) return result;
211
212 result = af->getParameters(ioHandle, keys);
213 return result;
214 }
215
setParameters(const String8 & keyValuePairs)216 status_t AudioSystem::setParameters(const String8& keyValuePairs)
217 {
218 return setParameters(AUDIO_IO_HANDLE_NONE, keyValuePairs);
219 }
220
getParameters(const String8 & keys)221 String8 AudioSystem::getParameters(const String8& keys)
222 {
223 return getParameters(AUDIO_IO_HANDLE_NONE, keys);
224 }
225
226 // convert volume steps to natural log scale
227
228 // change this value to change volume scaling
229 static const float dBPerStep = 0.5f;
230 // shouldn't need to touch these
231 static const float dBConvert = -dBPerStep * 2.302585093f / 20.0f;
232 static const float dBConvertInverse = 1.0f / dBConvert;
233
linearToLog(int volume)234 float AudioSystem::linearToLog(int volume)
235 {
236 // float v = volume ? exp(float(100 - volume) * dBConvert) : 0;
237 // ALOGD("linearToLog(%d)=%f", volume, v);
238 // return v;
239 return volume ? exp(float(100 - volume) * dBConvert) : 0;
240 }
241
logToLinear(float volume)242 int AudioSystem::logToLinear(float volume)
243 {
244 // int v = volume ? 100 - int(dBConvertInverse * log(volume) + 0.5) : 0;
245 // ALOGD("logTolinear(%d)=%f", v, volume);
246 // return v;
247 return volume ? 100 - int(dBConvertInverse * log(volume) + 0.5) : 0;
248 }
249
getOutputSamplingRate(uint32_t * samplingRate,audio_stream_type_t streamType)250 status_t AudioSystem::getOutputSamplingRate(uint32_t* samplingRate, audio_stream_type_t streamType)
251 {
252 audio_io_handle_t output;
253
254 if (streamType == AUDIO_STREAM_DEFAULT) {
255 streamType = AUDIO_STREAM_MUSIC;
256 }
257
258 output = getOutput(streamType);
259 if (output == 0) {
260 return PERMISSION_DENIED;
261 }
262
263 return getSamplingRate(output, samplingRate);
264 }
265
getSamplingRate(audio_io_handle_t output,uint32_t * samplingRate)266 status_t AudioSystem::getSamplingRate(audio_io_handle_t output,
267 uint32_t* samplingRate)
268 {
269 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
270 if (af == 0) return PERMISSION_DENIED;
271 sp<AudioIoDescriptor> outputDesc = getIoDescriptor(output);
272 if (outputDesc == 0) {
273 ALOGV("getOutputSamplingRate() no output descriptor for output %d in gOutputs", output);
274 *samplingRate = af->sampleRate(output);
275 } else {
276 ALOGV("getOutputSamplingRate() reading from output desc");
277 *samplingRate = outputDesc->mSamplingRate;
278 }
279 if (*samplingRate == 0) {
280 ALOGE("AudioSystem::getSamplingRate failed for output %d", output);
281 return BAD_VALUE;
282 }
283
284 ALOGV("getSamplingRate() output %d, sampling rate %u", output, *samplingRate);
285
286 return NO_ERROR;
287 }
288
getOutputFrameCount(size_t * frameCount,audio_stream_type_t streamType)289 status_t AudioSystem::getOutputFrameCount(size_t* frameCount, audio_stream_type_t streamType)
290 {
291 audio_io_handle_t output;
292
293 if (streamType == AUDIO_STREAM_DEFAULT) {
294 streamType = AUDIO_STREAM_MUSIC;
295 }
296
297 output = getOutput(streamType);
298 if (output == AUDIO_IO_HANDLE_NONE) {
299 return PERMISSION_DENIED;
300 }
301
302 return getFrameCount(output, frameCount);
303 }
304
getFrameCount(audio_io_handle_t output,size_t * frameCount)305 status_t AudioSystem::getFrameCount(audio_io_handle_t output,
306 size_t* frameCount)
307 {
308 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
309 if (af == 0) return PERMISSION_DENIED;
310 sp<AudioIoDescriptor> outputDesc = getIoDescriptor(output);
311 if (outputDesc == 0) {
312 *frameCount = af->frameCount(output);
313 } else {
314 *frameCount = outputDesc->mFrameCount;
315 }
316 if (*frameCount == 0) {
317 ALOGE("AudioSystem::getFrameCount failed for output %d", output);
318 return BAD_VALUE;
319 }
320
321 ALOGV("getFrameCount() output %d, frameCount %zu", output, *frameCount);
322
323 return NO_ERROR;
324 }
325
getOutputLatency(uint32_t * latency,audio_stream_type_t streamType)326 status_t AudioSystem::getOutputLatency(uint32_t* latency, audio_stream_type_t streamType)
327 {
328 audio_io_handle_t output;
329
330 if (streamType == AUDIO_STREAM_DEFAULT) {
331 streamType = AUDIO_STREAM_MUSIC;
332 }
333
334 output = getOutput(streamType);
335 if (output == AUDIO_IO_HANDLE_NONE) {
336 return PERMISSION_DENIED;
337 }
338
339 return getLatency(output, latency);
340 }
341
getLatency(audio_io_handle_t output,uint32_t * latency)342 status_t AudioSystem::getLatency(audio_io_handle_t output,
343 uint32_t* latency)
344 {
345 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
346 if (af == 0) return PERMISSION_DENIED;
347 sp<AudioIoDescriptor> outputDesc = getIoDescriptor(output);
348 if (outputDesc == 0) {
349 *latency = af->latency(output);
350 } else {
351 *latency = outputDesc->mLatency;
352 }
353
354 ALOGV("getLatency() output %d, latency %d", output, *latency);
355
356 return NO_ERROR;
357 }
358
getInputBufferSize(uint32_t sampleRate,audio_format_t format,audio_channel_mask_t channelMask,size_t * buffSize)359 status_t AudioSystem::getInputBufferSize(uint32_t sampleRate, audio_format_t format,
360 audio_channel_mask_t channelMask, size_t* buffSize)
361 {
362 const sp<AudioFlingerClient> afc = getAudioFlingerClient();
363 if (afc == 0) {
364 return NO_INIT;
365 }
366 return afc->getInputBufferSize(sampleRate, format, channelMask, buffSize);
367 }
368
setVoiceVolume(float value)369 status_t AudioSystem::setVoiceVolume(float value)
370 {
371 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
372 if (af == 0) return PERMISSION_DENIED;
373 return af->setVoiceVolume(value);
374 }
375
getRenderPosition(audio_io_handle_t output,uint32_t * halFrames,uint32_t * dspFrames)376 status_t AudioSystem::getRenderPosition(audio_io_handle_t output, uint32_t *halFrames,
377 uint32_t *dspFrames)
378 {
379 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
380 if (af == 0) return PERMISSION_DENIED;
381
382 return af->getRenderPosition(halFrames, dspFrames, output);
383 }
384
getInputFramesLost(audio_io_handle_t ioHandle)385 uint32_t AudioSystem::getInputFramesLost(audio_io_handle_t ioHandle)
386 {
387 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
388 uint32_t result = 0;
389 if (af == 0) return result;
390 if (ioHandle == AUDIO_IO_HANDLE_NONE) return result;
391
392 result = af->getInputFramesLost(ioHandle);
393 return result;
394 }
395
newAudioUniqueId()396 audio_unique_id_t AudioSystem::newAudioUniqueId()
397 {
398 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
399 if (af == 0) return AUDIO_UNIQUE_ID_ALLOCATE;
400 return af->newAudioUniqueId();
401 }
402
acquireAudioSessionId(int audioSession,pid_t pid)403 void AudioSystem::acquireAudioSessionId(int audioSession, pid_t pid)
404 {
405 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
406 if (af != 0) {
407 af->acquireAudioSessionId(audioSession, pid);
408 }
409 }
410
releaseAudioSessionId(int audioSession,pid_t pid)411 void AudioSystem::releaseAudioSessionId(int audioSession, pid_t pid)
412 {
413 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
414 if (af != 0) {
415 af->releaseAudioSessionId(audioSession, pid);
416 }
417 }
418
getAudioHwSyncForSession(audio_session_t sessionId)419 audio_hw_sync_t AudioSystem::getAudioHwSyncForSession(audio_session_t sessionId)
420 {
421 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
422 if (af == 0) return AUDIO_HW_SYNC_INVALID;
423 return af->getAudioHwSyncForSession(sessionId);
424 }
425
systemReady()426 status_t AudioSystem::systemReady()
427 {
428 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
429 if (af == 0) return NO_INIT;
430 return af->systemReady();
431 }
432
433 // ---------------------------------------------------------------------------
434
435
clearIoCache()436 void AudioSystem::AudioFlingerClient::clearIoCache()
437 {
438 Mutex::Autolock _l(mLock);
439 mIoDescriptors.clear();
440 mInBuffSize = 0;
441 mInSamplingRate = 0;
442 mInFormat = AUDIO_FORMAT_DEFAULT;
443 mInChannelMask = AUDIO_CHANNEL_NONE;
444 }
445
binderDied(const wp<IBinder> & who __unused)446 void AudioSystem::AudioFlingerClient::binderDied(const wp<IBinder>& who __unused)
447 {
448 audio_error_callback cb = NULL;
449 {
450 Mutex::Autolock _l(AudioSystem::gLock);
451 AudioSystem::gAudioFlinger.clear();
452 cb = gAudioErrorCallback;
453 }
454
455 // clear output handles and stream to output map caches
456 clearIoCache();
457
458 if (cb) {
459 cb(DEAD_OBJECT);
460 }
461 ALOGW("AudioFlinger server died!");
462 }
463
ioConfigChanged(audio_io_config_event event,const sp<AudioIoDescriptor> & ioDesc)464 void AudioSystem::AudioFlingerClient::ioConfigChanged(audio_io_config_event event,
465 const sp<AudioIoDescriptor>& ioDesc) {
466 ALOGV("ioConfigChanged() event %d", event);
467
468 if (ioDesc == 0 || ioDesc->mIoHandle == AUDIO_IO_HANDLE_NONE) return;
469
470 audio_port_handle_t deviceId = AUDIO_PORT_HANDLE_NONE;
471 Vector < sp<AudioDeviceCallback> > callbacks;
472
473 {
474 Mutex::Autolock _l(mLock);
475
476 switch (event) {
477 case AUDIO_OUTPUT_OPENED:
478 case AUDIO_INPUT_OPENED: {
479 sp<AudioIoDescriptor> oldDesc = getIoDescriptor(ioDesc->mIoHandle);
480 if (oldDesc == 0) {
481 mIoDescriptors.add(ioDesc->mIoHandle, ioDesc);
482 } else {
483 deviceId = oldDesc->getDeviceId();
484 mIoDescriptors.replaceValueFor(ioDesc->mIoHandle, ioDesc);
485 }
486
487 if (ioDesc->getDeviceId() != AUDIO_PORT_HANDLE_NONE) {
488 deviceId = ioDesc->getDeviceId();
489 ssize_t ioIndex = mAudioDeviceCallbacks.indexOfKey(ioDesc->mIoHandle);
490 if (ioIndex >= 0) {
491 callbacks = mAudioDeviceCallbacks.valueAt(ioIndex);
492 }
493 }
494 ALOGV("ioConfigChanged() new %s opened %d samplingRate %u, format %#x channel mask %#x "
495 "frameCount %zu deviceId %d", event == AUDIO_OUTPUT_OPENED ? "output" : "input",
496 ioDesc->mIoHandle, ioDesc->mSamplingRate, ioDesc->mFormat, ioDesc->mChannelMask,
497 ioDesc->mFrameCount, ioDesc->getDeviceId());
498 } break;
499 case AUDIO_OUTPUT_CLOSED:
500 case AUDIO_INPUT_CLOSED: {
501 if (getIoDescriptor(ioDesc->mIoHandle) == 0) {
502 ALOGW("ioConfigChanged() closing unknown %s %d",
503 event == AUDIO_OUTPUT_CLOSED ? "output" : "input", ioDesc->mIoHandle);
504 break;
505 }
506 ALOGV("ioConfigChanged() %s %d closed",
507 event == AUDIO_OUTPUT_CLOSED ? "output" : "input", ioDesc->mIoHandle);
508
509 mIoDescriptors.removeItem(ioDesc->mIoHandle);
510 mAudioDeviceCallbacks.removeItem(ioDesc->mIoHandle);
511 } break;
512
513 case AUDIO_OUTPUT_CONFIG_CHANGED:
514 case AUDIO_INPUT_CONFIG_CHANGED: {
515 sp<AudioIoDescriptor> oldDesc = getIoDescriptor(ioDesc->mIoHandle);
516 if (oldDesc == 0) {
517 ALOGW("ioConfigChanged() modifying unknown output! %d", ioDesc->mIoHandle);
518 break;
519 }
520
521 deviceId = oldDesc->getDeviceId();
522 mIoDescriptors.replaceValueFor(ioDesc->mIoHandle, ioDesc);
523
524 if (deviceId != ioDesc->getDeviceId()) {
525 deviceId = ioDesc->getDeviceId();
526 ssize_t ioIndex = mAudioDeviceCallbacks.indexOfKey(ioDesc->mIoHandle);
527 if (ioIndex >= 0) {
528 callbacks = mAudioDeviceCallbacks.valueAt(ioIndex);
529 }
530 }
531 ALOGV("ioConfigChanged() new config for %s %d samplingRate %u, format %#x "
532 "channel mask %#x frameCount %zu deviceId %d",
533 event == AUDIO_OUTPUT_CONFIG_CHANGED ? "output" : "input",
534 ioDesc->mIoHandle, ioDesc->mSamplingRate, ioDesc->mFormat,
535 ioDesc->mChannelMask, ioDesc->mFrameCount, ioDesc->getDeviceId());
536
537 } break;
538 }
539 }
540 // callbacks.size() != 0 => ioDesc->mIoHandle and deviceId are valid
541 for (size_t i = 0; i < callbacks.size(); i++) {
542 callbacks[i]->onAudioDeviceUpdate(ioDesc->mIoHandle, deviceId);
543 }
544 }
545
getInputBufferSize(uint32_t sampleRate,audio_format_t format,audio_channel_mask_t channelMask,size_t * buffSize)546 status_t AudioSystem::AudioFlingerClient::getInputBufferSize(
547 uint32_t sampleRate, audio_format_t format,
548 audio_channel_mask_t channelMask, size_t* buffSize)
549 {
550 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
551 if (af == 0) {
552 return PERMISSION_DENIED;
553 }
554 Mutex::Autolock _l(mLock);
555 // Do we have a stale mInBuffSize or are we requesting the input buffer size for new values
556 if ((mInBuffSize == 0) || (sampleRate != mInSamplingRate) || (format != mInFormat)
557 || (channelMask != mInChannelMask)) {
558 size_t inBuffSize = af->getInputBufferSize(sampleRate, format, channelMask);
559 if (inBuffSize == 0) {
560 ALOGE("AudioSystem::getInputBufferSize failed sampleRate %d format %#x channelMask %x",
561 sampleRate, format, channelMask);
562 return BAD_VALUE;
563 }
564 // A benign race is possible here: we could overwrite a fresher cache entry
565 // save the request params
566 mInSamplingRate = sampleRate;
567 mInFormat = format;
568 mInChannelMask = channelMask;
569
570 mInBuffSize = inBuffSize;
571 }
572
573 *buffSize = mInBuffSize;
574
575 return NO_ERROR;
576 }
577
getIoDescriptor(audio_io_handle_t ioHandle)578 sp<AudioIoDescriptor> AudioSystem::AudioFlingerClient::getIoDescriptor(audio_io_handle_t ioHandle)
579 {
580 sp<AudioIoDescriptor> desc;
581 ssize_t index = mIoDescriptors.indexOfKey(ioHandle);
582 if (index >= 0) {
583 desc = mIoDescriptors.valueAt(index);
584 }
585 return desc;
586 }
587
addAudioDeviceCallback(const sp<AudioDeviceCallback> & callback,audio_io_handle_t audioIo)588 status_t AudioSystem::AudioFlingerClient::addAudioDeviceCallback(
589 const sp<AudioDeviceCallback>& callback, audio_io_handle_t audioIo)
590 {
591 Mutex::Autolock _l(mLock);
592 Vector < sp<AudioDeviceCallback> > callbacks;
593 ssize_t ioIndex = mAudioDeviceCallbacks.indexOfKey(audioIo);
594 if (ioIndex >= 0) {
595 callbacks = mAudioDeviceCallbacks.valueAt(ioIndex);
596 }
597
598 for (size_t cbIndex = 0; cbIndex < callbacks.size(); cbIndex++) {
599 if (callbacks[cbIndex] == callback) {
600 return INVALID_OPERATION;
601 }
602 }
603 callbacks.add(callback);
604
605 mAudioDeviceCallbacks.replaceValueFor(audioIo, callbacks);
606 return NO_ERROR;
607 }
608
removeAudioDeviceCallback(const sp<AudioDeviceCallback> & callback,audio_io_handle_t audioIo)609 status_t AudioSystem::AudioFlingerClient::removeAudioDeviceCallback(
610 const sp<AudioDeviceCallback>& callback, audio_io_handle_t audioIo)
611 {
612 Mutex::Autolock _l(mLock);
613 ssize_t ioIndex = mAudioDeviceCallbacks.indexOfKey(audioIo);
614 if (ioIndex < 0) {
615 return INVALID_OPERATION;
616 }
617 Vector < sp<AudioDeviceCallback> > callbacks = mAudioDeviceCallbacks.valueAt(ioIndex);
618
619 size_t cbIndex;
620 for (cbIndex = 0; cbIndex < callbacks.size(); cbIndex++) {
621 if (callbacks[cbIndex] == callback) {
622 break;
623 }
624 }
625 if (cbIndex == callbacks.size()) {
626 return INVALID_OPERATION;
627 }
628 callbacks.removeAt(cbIndex);
629 if (callbacks.size() != 0) {
630 mAudioDeviceCallbacks.replaceValueFor(audioIo, callbacks);
631 } else {
632 mAudioDeviceCallbacks.removeItem(audioIo);
633 }
634 return NO_ERROR;
635 }
636
setErrorCallback(audio_error_callback cb)637 /* static */ void AudioSystem::setErrorCallback(audio_error_callback cb)
638 {
639 Mutex::Autolock _l(gLock);
640 gAudioErrorCallback = cb;
641 }
642
setDynPolicyCallback(dynamic_policy_callback cb)643 /*static*/ void AudioSystem::setDynPolicyCallback(dynamic_policy_callback cb)
644 {
645 Mutex::Autolock _l(gLock);
646 gDynPolicyCallback = cb;
647 }
648
649 // client singleton for AudioPolicyService binder interface
650 // protected by gLockAPS
651 sp<IAudioPolicyService> AudioSystem::gAudioPolicyService;
652 sp<AudioSystem::AudioPolicyServiceClient> AudioSystem::gAudioPolicyServiceClient;
653
654
655 // establish binder interface to AudioPolicy service
get_audio_policy_service()656 const sp<IAudioPolicyService> AudioSystem::get_audio_policy_service()
657 {
658 sp<IAudioPolicyService> ap;
659 sp<AudioPolicyServiceClient> apc;
660 {
661 Mutex::Autolock _l(gLockAPS);
662 if (gAudioPolicyService == 0) {
663 sp<IServiceManager> sm = defaultServiceManager();
664 sp<IBinder> binder;
665 do {
666 binder = sm->getService(String16("media.audio_policy"));
667 if (binder != 0)
668 break;
669 ALOGW("AudioPolicyService not published, waiting...");
670 usleep(500000); // 0.5 s
671 } while (true);
672 if (gAudioPolicyServiceClient == NULL) {
673 gAudioPolicyServiceClient = new AudioPolicyServiceClient();
674 }
675 binder->linkToDeath(gAudioPolicyServiceClient);
676 gAudioPolicyService = interface_cast<IAudioPolicyService>(binder);
677 LOG_ALWAYS_FATAL_IF(gAudioPolicyService == 0);
678 apc = gAudioPolicyServiceClient;
679 }
680 ap = gAudioPolicyService;
681 }
682 if (apc != 0) {
683 ap->registerClient(apc);
684 }
685
686 return ap;
687 }
688
689 // ---------------------------------------------------------------------------
690
setDeviceConnectionState(audio_devices_t device,audio_policy_dev_state_t state,const char * device_address,const char * device_name)691 status_t AudioSystem::setDeviceConnectionState(audio_devices_t device,
692 audio_policy_dev_state_t state,
693 const char *device_address,
694 const char *device_name)
695 {
696 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
697 const char *address = "";
698 const char *name = "";
699
700 if (aps == 0) return PERMISSION_DENIED;
701
702 if (device_address != NULL) {
703 address = device_address;
704 }
705 if (device_name != NULL) {
706 name = device_name;
707 }
708 return aps->setDeviceConnectionState(device, state, address, name);
709 }
710
getDeviceConnectionState(audio_devices_t device,const char * device_address)711 audio_policy_dev_state_t AudioSystem::getDeviceConnectionState(audio_devices_t device,
712 const char *device_address)
713 {
714 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
715 if (aps == 0) return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE;
716
717 return aps->getDeviceConnectionState(device, device_address);
718 }
719
setPhoneState(audio_mode_t state)720 status_t AudioSystem::setPhoneState(audio_mode_t state)
721 {
722 if (uint32_t(state) >= AUDIO_MODE_CNT) return BAD_VALUE;
723 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
724 if (aps == 0) return PERMISSION_DENIED;
725
726 return aps->setPhoneState(state);
727 }
728
setForceUse(audio_policy_force_use_t usage,audio_policy_forced_cfg_t config)729 status_t AudioSystem::setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config)
730 {
731 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
732 if (aps == 0) return PERMISSION_DENIED;
733 return aps->setForceUse(usage, config);
734 }
735
getForceUse(audio_policy_force_use_t usage)736 audio_policy_forced_cfg_t AudioSystem::getForceUse(audio_policy_force_use_t usage)
737 {
738 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
739 if (aps == 0) return AUDIO_POLICY_FORCE_NONE;
740 return aps->getForceUse(usage);
741 }
742
743
getOutput(audio_stream_type_t stream,uint32_t samplingRate,audio_format_t format,audio_channel_mask_t channelMask,audio_output_flags_t flags,const audio_offload_info_t * offloadInfo)744 audio_io_handle_t AudioSystem::getOutput(audio_stream_type_t stream,
745 uint32_t samplingRate,
746 audio_format_t format,
747 audio_channel_mask_t channelMask,
748 audio_output_flags_t flags,
749 const audio_offload_info_t *offloadInfo)
750 {
751 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
752 if (aps == 0) return 0;
753 return aps->getOutput(stream, samplingRate, format, channelMask, flags, offloadInfo);
754 }
755
getOutputForAttr(const audio_attributes_t * attr,audio_io_handle_t * output,audio_session_t session,audio_stream_type_t * stream,uid_t uid,uint32_t samplingRate,audio_format_t format,audio_channel_mask_t channelMask,audio_output_flags_t flags,audio_port_handle_t selectedDeviceId,const audio_offload_info_t * offloadInfo)756 status_t AudioSystem::getOutputForAttr(const audio_attributes_t *attr,
757 audio_io_handle_t *output,
758 audio_session_t session,
759 audio_stream_type_t *stream,
760 uid_t uid,
761 uint32_t samplingRate,
762 audio_format_t format,
763 audio_channel_mask_t channelMask,
764 audio_output_flags_t flags,
765 audio_port_handle_t selectedDeviceId,
766 const audio_offload_info_t *offloadInfo)
767 {
768 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
769 if (aps == 0) return NO_INIT;
770 return aps->getOutputForAttr(attr, output, session, stream, uid,
771 samplingRate, format, channelMask,
772 flags, selectedDeviceId, offloadInfo);
773 }
774
startOutput(audio_io_handle_t output,audio_stream_type_t stream,audio_session_t session)775 status_t AudioSystem::startOutput(audio_io_handle_t output,
776 audio_stream_type_t stream,
777 audio_session_t session)
778 {
779 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
780 if (aps == 0) return PERMISSION_DENIED;
781 return aps->startOutput(output, stream, session);
782 }
783
stopOutput(audio_io_handle_t output,audio_stream_type_t stream,audio_session_t session)784 status_t AudioSystem::stopOutput(audio_io_handle_t output,
785 audio_stream_type_t stream,
786 audio_session_t session)
787 {
788 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
789 if (aps == 0) return PERMISSION_DENIED;
790 return aps->stopOutput(output, stream, session);
791 }
792
releaseOutput(audio_io_handle_t output,audio_stream_type_t stream,audio_session_t session)793 void AudioSystem::releaseOutput(audio_io_handle_t output,
794 audio_stream_type_t stream,
795 audio_session_t session)
796 {
797 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
798 if (aps == 0) return;
799 aps->releaseOutput(output, stream, session);
800 }
801
getInputForAttr(const audio_attributes_t * attr,audio_io_handle_t * input,audio_session_t session,uid_t uid,uint32_t samplingRate,audio_format_t format,audio_channel_mask_t channelMask,audio_input_flags_t flags,audio_port_handle_t selectedDeviceId)802 status_t AudioSystem::getInputForAttr(const audio_attributes_t *attr,
803 audio_io_handle_t *input,
804 audio_session_t session,
805 uid_t uid,
806 uint32_t samplingRate,
807 audio_format_t format,
808 audio_channel_mask_t channelMask,
809 audio_input_flags_t flags,
810 audio_port_handle_t selectedDeviceId)
811 {
812 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
813 if (aps == 0) return NO_INIT;
814 return aps->getInputForAttr(
815 attr, input, session, uid, samplingRate, format, channelMask, flags, selectedDeviceId);
816 }
817
startInput(audio_io_handle_t input,audio_session_t session)818 status_t AudioSystem::startInput(audio_io_handle_t input,
819 audio_session_t session)
820 {
821 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
822 if (aps == 0) return PERMISSION_DENIED;
823 return aps->startInput(input, session);
824 }
825
stopInput(audio_io_handle_t input,audio_session_t session)826 status_t AudioSystem::stopInput(audio_io_handle_t input,
827 audio_session_t session)
828 {
829 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
830 if (aps == 0) return PERMISSION_DENIED;
831 return aps->stopInput(input, session);
832 }
833
releaseInput(audio_io_handle_t input,audio_session_t session)834 void AudioSystem::releaseInput(audio_io_handle_t input,
835 audio_session_t session)
836 {
837 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
838 if (aps == 0) return;
839 aps->releaseInput(input, session);
840 }
841
initStreamVolume(audio_stream_type_t stream,int indexMin,int indexMax)842 status_t AudioSystem::initStreamVolume(audio_stream_type_t stream,
843 int indexMin,
844 int indexMax)
845 {
846 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
847 if (aps == 0) return PERMISSION_DENIED;
848 return aps->initStreamVolume(stream, indexMin, indexMax);
849 }
850
setStreamVolumeIndex(audio_stream_type_t stream,int index,audio_devices_t device)851 status_t AudioSystem::setStreamVolumeIndex(audio_stream_type_t stream,
852 int index,
853 audio_devices_t device)
854 {
855 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
856 if (aps == 0) return PERMISSION_DENIED;
857 return aps->setStreamVolumeIndex(stream, index, device);
858 }
859
getStreamVolumeIndex(audio_stream_type_t stream,int * index,audio_devices_t device)860 status_t AudioSystem::getStreamVolumeIndex(audio_stream_type_t stream,
861 int *index,
862 audio_devices_t device)
863 {
864 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
865 if (aps == 0) return PERMISSION_DENIED;
866 return aps->getStreamVolumeIndex(stream, index, device);
867 }
868
getStrategyForStream(audio_stream_type_t stream)869 uint32_t AudioSystem::getStrategyForStream(audio_stream_type_t stream)
870 {
871 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
872 if (aps == 0) return 0;
873 return aps->getStrategyForStream(stream);
874 }
875
getDevicesForStream(audio_stream_type_t stream)876 audio_devices_t AudioSystem::getDevicesForStream(audio_stream_type_t stream)
877 {
878 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
879 if (aps == 0) return AUDIO_DEVICE_NONE;
880 return aps->getDevicesForStream(stream);
881 }
882
getOutputForEffect(const effect_descriptor_t * desc)883 audio_io_handle_t AudioSystem::getOutputForEffect(const effect_descriptor_t *desc)
884 {
885 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
886 // FIXME change return type to status_t, and return PERMISSION_DENIED here
887 if (aps == 0) return AUDIO_IO_HANDLE_NONE;
888 return aps->getOutputForEffect(desc);
889 }
890
registerEffect(const effect_descriptor_t * desc,audio_io_handle_t io,uint32_t strategy,int session,int id)891 status_t AudioSystem::registerEffect(const effect_descriptor_t *desc,
892 audio_io_handle_t io,
893 uint32_t strategy,
894 int session,
895 int id)
896 {
897 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
898 if (aps == 0) return PERMISSION_DENIED;
899 return aps->registerEffect(desc, io, strategy, session, id);
900 }
901
unregisterEffect(int id)902 status_t AudioSystem::unregisterEffect(int id)
903 {
904 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
905 if (aps == 0) return PERMISSION_DENIED;
906 return aps->unregisterEffect(id);
907 }
908
setEffectEnabled(int id,bool enabled)909 status_t AudioSystem::setEffectEnabled(int id, bool enabled)
910 {
911 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
912 if (aps == 0) return PERMISSION_DENIED;
913 return aps->setEffectEnabled(id, enabled);
914 }
915
isStreamActive(audio_stream_type_t stream,bool * state,uint32_t inPastMs)916 status_t AudioSystem::isStreamActive(audio_stream_type_t stream, bool* state, uint32_t inPastMs)
917 {
918 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
919 if (aps == 0) return PERMISSION_DENIED;
920 if (state == NULL) return BAD_VALUE;
921 *state = aps->isStreamActive(stream, inPastMs);
922 return NO_ERROR;
923 }
924
isStreamActiveRemotely(audio_stream_type_t stream,bool * state,uint32_t inPastMs)925 status_t AudioSystem::isStreamActiveRemotely(audio_stream_type_t stream, bool* state,
926 uint32_t inPastMs)
927 {
928 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
929 if (aps == 0) return PERMISSION_DENIED;
930 if (state == NULL) return BAD_VALUE;
931 *state = aps->isStreamActiveRemotely(stream, inPastMs);
932 return NO_ERROR;
933 }
934
isSourceActive(audio_source_t stream,bool * state)935 status_t AudioSystem::isSourceActive(audio_source_t stream, bool* state)
936 {
937 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
938 if (aps == 0) return PERMISSION_DENIED;
939 if (state == NULL) return BAD_VALUE;
940 *state = aps->isSourceActive(stream);
941 return NO_ERROR;
942 }
943
getPrimaryOutputSamplingRate()944 uint32_t AudioSystem::getPrimaryOutputSamplingRate()
945 {
946 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
947 if (af == 0) return 0;
948 return af->getPrimaryOutputSamplingRate();
949 }
950
getPrimaryOutputFrameCount()951 size_t AudioSystem::getPrimaryOutputFrameCount()
952 {
953 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
954 if (af == 0) return 0;
955 return af->getPrimaryOutputFrameCount();
956 }
957
setLowRamDevice(bool isLowRamDevice)958 status_t AudioSystem::setLowRamDevice(bool isLowRamDevice)
959 {
960 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
961 if (af == 0) return PERMISSION_DENIED;
962 return af->setLowRamDevice(isLowRamDevice);
963 }
964
clearAudioConfigCache()965 void AudioSystem::clearAudioConfigCache()
966 {
967 // called by restoreTrack_l(), which needs new IAudioFlinger and IAudioPolicyService instances
968 ALOGV("clearAudioConfigCache()");
969 {
970 Mutex::Autolock _l(gLock);
971 if (gAudioFlingerClient != 0) {
972 gAudioFlingerClient->clearIoCache();
973 }
974 gAudioFlinger.clear();
975 }
976 {
977 Mutex::Autolock _l(gLockAPS);
978 gAudioPolicyService.clear();
979 }
980 }
981
isOffloadSupported(const audio_offload_info_t & info)982 bool AudioSystem::isOffloadSupported(const audio_offload_info_t& info)
983 {
984 ALOGV("isOffloadSupported()");
985 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
986 if (aps == 0) return false;
987 return aps->isOffloadSupported(info);
988 }
989
listAudioPorts(audio_port_role_t role,audio_port_type_t type,unsigned int * num_ports,struct audio_port * ports,unsigned int * generation)990 status_t AudioSystem::listAudioPorts(audio_port_role_t role,
991 audio_port_type_t type,
992 unsigned int *num_ports,
993 struct audio_port *ports,
994 unsigned int *generation)
995 {
996 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
997 if (aps == 0) return PERMISSION_DENIED;
998 return aps->listAudioPorts(role, type, num_ports, ports, generation);
999 }
1000
getAudioPort(struct audio_port * port)1001 status_t AudioSystem::getAudioPort(struct audio_port *port)
1002 {
1003 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
1004 if (aps == 0) return PERMISSION_DENIED;
1005 return aps->getAudioPort(port);
1006 }
1007
createAudioPatch(const struct audio_patch * patch,audio_patch_handle_t * handle)1008 status_t AudioSystem::createAudioPatch(const struct audio_patch *patch,
1009 audio_patch_handle_t *handle)
1010 {
1011 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
1012 if (aps == 0) return PERMISSION_DENIED;
1013 return aps->createAudioPatch(patch, handle);
1014 }
1015
releaseAudioPatch(audio_patch_handle_t handle)1016 status_t AudioSystem::releaseAudioPatch(audio_patch_handle_t handle)
1017 {
1018 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
1019 if (aps == 0) return PERMISSION_DENIED;
1020 return aps->releaseAudioPatch(handle);
1021 }
1022
listAudioPatches(unsigned int * num_patches,struct audio_patch * patches,unsigned int * generation)1023 status_t AudioSystem::listAudioPatches(unsigned int *num_patches,
1024 struct audio_patch *patches,
1025 unsigned int *generation)
1026 {
1027 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
1028 if (aps == 0) return PERMISSION_DENIED;
1029 return aps->listAudioPatches(num_patches, patches, generation);
1030 }
1031
setAudioPortConfig(const struct audio_port_config * config)1032 status_t AudioSystem::setAudioPortConfig(const struct audio_port_config *config)
1033 {
1034 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
1035 if (aps == 0) return PERMISSION_DENIED;
1036 return aps->setAudioPortConfig(config);
1037 }
1038
addAudioPortCallback(const sp<AudioPortCallback> & callback)1039 status_t AudioSystem::addAudioPortCallback(const sp<AudioPortCallback>& callback)
1040 {
1041 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
1042 if (aps == 0) return PERMISSION_DENIED;
1043
1044 Mutex::Autolock _l(gLockAPS);
1045 if (gAudioPolicyServiceClient == 0) {
1046 return NO_INIT;
1047 }
1048 int ret = gAudioPolicyServiceClient->addAudioPortCallback(callback);
1049 if (ret == 1) {
1050 aps->setAudioPortCallbacksEnabled(true);
1051 }
1052 return (ret < 0) ? INVALID_OPERATION : NO_ERROR;
1053 }
1054
1055 /*static*/
removeAudioPortCallback(const sp<AudioPortCallback> & callback)1056 status_t AudioSystem::removeAudioPortCallback(const sp<AudioPortCallback>& callback)
1057 {
1058 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
1059 if (aps == 0) return PERMISSION_DENIED;
1060
1061 Mutex::Autolock _l(gLockAPS);
1062 if (gAudioPolicyServiceClient == 0) {
1063 return NO_INIT;
1064 }
1065 int ret = gAudioPolicyServiceClient->removeAudioPortCallback(callback);
1066 if (ret == 0) {
1067 aps->setAudioPortCallbacksEnabled(false);
1068 }
1069 return (ret < 0) ? INVALID_OPERATION : NO_ERROR;
1070 }
1071
addAudioDeviceCallback(const sp<AudioDeviceCallback> & callback,audio_io_handle_t audioIo)1072 status_t AudioSystem::addAudioDeviceCallback(
1073 const sp<AudioDeviceCallback>& callback, audio_io_handle_t audioIo)
1074 {
1075 const sp<AudioFlingerClient> afc = getAudioFlingerClient();
1076 if (afc == 0) {
1077 return NO_INIT;
1078 }
1079 status_t status = afc->addAudioDeviceCallback(callback, audioIo);
1080 if (status == NO_ERROR) {
1081 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
1082 if (af != 0) {
1083 af->registerClient(afc);
1084 }
1085 }
1086 return status;
1087 }
1088
removeAudioDeviceCallback(const sp<AudioDeviceCallback> & callback,audio_io_handle_t audioIo)1089 status_t AudioSystem::removeAudioDeviceCallback(
1090 const sp<AudioDeviceCallback>& callback, audio_io_handle_t audioIo)
1091 {
1092 const sp<AudioFlingerClient> afc = getAudioFlingerClient();
1093 if (afc == 0) {
1094 return NO_INIT;
1095 }
1096 return afc->removeAudioDeviceCallback(callback, audioIo);
1097 }
1098
getDeviceIdForIo(audio_io_handle_t audioIo)1099 audio_port_handle_t AudioSystem::getDeviceIdForIo(audio_io_handle_t audioIo)
1100 {
1101 const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
1102 if (af == 0) return PERMISSION_DENIED;
1103 const sp<AudioIoDescriptor> desc = getIoDescriptor(audioIo);
1104 if (desc == 0) {
1105 return AUDIO_PORT_HANDLE_NONE;
1106 }
1107 return desc->getDeviceId();
1108 }
1109
acquireSoundTriggerSession(audio_session_t * session,audio_io_handle_t * ioHandle,audio_devices_t * device)1110 status_t AudioSystem::acquireSoundTriggerSession(audio_session_t *session,
1111 audio_io_handle_t *ioHandle,
1112 audio_devices_t *device)
1113 {
1114 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
1115 if (aps == 0) return PERMISSION_DENIED;
1116 return aps->acquireSoundTriggerSession(session, ioHandle, device);
1117 }
1118
releaseSoundTriggerSession(audio_session_t session)1119 status_t AudioSystem::releaseSoundTriggerSession(audio_session_t session)
1120 {
1121 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
1122 if (aps == 0) return PERMISSION_DENIED;
1123 return aps->releaseSoundTriggerSession(session);
1124 }
1125
getPhoneState()1126 audio_mode_t AudioSystem::getPhoneState()
1127 {
1128 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
1129 if (aps == 0) return AUDIO_MODE_INVALID;
1130 return aps->getPhoneState();
1131 }
1132
registerPolicyMixes(Vector<AudioMix> mixes,bool registration)1133 status_t AudioSystem::registerPolicyMixes(Vector<AudioMix> mixes, bool registration)
1134 {
1135 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
1136 if (aps == 0) return PERMISSION_DENIED;
1137 return aps->registerPolicyMixes(mixes, registration);
1138 }
1139
startAudioSource(const struct audio_port_config * source,const audio_attributes_t * attributes,audio_io_handle_t * handle)1140 status_t AudioSystem::startAudioSource(const struct audio_port_config *source,
1141 const audio_attributes_t *attributes,
1142 audio_io_handle_t *handle)
1143 {
1144 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
1145 if (aps == 0) return PERMISSION_DENIED;
1146 return aps->startAudioSource(source, attributes, handle);
1147 }
1148
stopAudioSource(audio_io_handle_t handle)1149 status_t AudioSystem::stopAudioSource(audio_io_handle_t handle)
1150 {
1151 const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
1152 if (aps == 0) return PERMISSION_DENIED;
1153 return aps->stopAudioSource(handle);
1154 }
1155
1156 // ---------------------------------------------------------------------------
1157
addAudioPortCallback(const sp<AudioPortCallback> & callback)1158 int AudioSystem::AudioPolicyServiceClient::addAudioPortCallback(
1159 const sp<AudioPortCallback>& callback)
1160 {
1161 Mutex::Autolock _l(mLock);
1162 for (size_t i = 0; i < mAudioPortCallbacks.size(); i++) {
1163 if (mAudioPortCallbacks[i] == callback) {
1164 return -1;
1165 }
1166 }
1167 mAudioPortCallbacks.add(callback);
1168 return mAudioPortCallbacks.size();
1169 }
1170
removeAudioPortCallback(const sp<AudioPortCallback> & callback)1171 int AudioSystem::AudioPolicyServiceClient::removeAudioPortCallback(
1172 const sp<AudioPortCallback>& callback)
1173 {
1174 Mutex::Autolock _l(mLock);
1175 size_t i;
1176 for (i = 0; i < mAudioPortCallbacks.size(); i++) {
1177 if (mAudioPortCallbacks[i] == callback) {
1178 break;
1179 }
1180 }
1181 if (i == mAudioPortCallbacks.size()) {
1182 return -1;
1183 }
1184 mAudioPortCallbacks.removeAt(i);
1185 return mAudioPortCallbacks.size();
1186 }
1187
1188
onAudioPortListUpdate()1189 void AudioSystem::AudioPolicyServiceClient::onAudioPortListUpdate()
1190 {
1191 Mutex::Autolock _l(mLock);
1192 for (size_t i = 0; i < mAudioPortCallbacks.size(); i++) {
1193 mAudioPortCallbacks[i]->onAudioPortListUpdate();
1194 }
1195 }
1196
onAudioPatchListUpdate()1197 void AudioSystem::AudioPolicyServiceClient::onAudioPatchListUpdate()
1198 {
1199 Mutex::Autolock _l(mLock);
1200 for (size_t i = 0; i < mAudioPortCallbacks.size(); i++) {
1201 mAudioPortCallbacks[i]->onAudioPatchListUpdate();
1202 }
1203 }
1204
onDynamicPolicyMixStateUpdate(String8 regId,int32_t state)1205 void AudioSystem::AudioPolicyServiceClient::onDynamicPolicyMixStateUpdate(
1206 String8 regId, int32_t state)
1207 {
1208 ALOGV("AudioPolicyServiceClient::onDynamicPolicyMixStateUpdate(%s, %d)", regId.string(), state);
1209 dynamic_policy_callback cb = NULL;
1210 {
1211 Mutex::Autolock _l(AudioSystem::gLock);
1212 cb = gDynPolicyCallback;
1213 }
1214
1215 if (cb != NULL) {
1216 cb(DYNAMIC_POLICY_EVENT_MIX_STATE_UPDATE, regId, state);
1217 }
1218 }
1219
binderDied(const wp<IBinder> & who __unused)1220 void AudioSystem::AudioPolicyServiceClient::binderDied(const wp<IBinder>& who __unused)
1221 {
1222 {
1223 Mutex::Autolock _l(mLock);
1224 for (size_t i = 0; i < mAudioPortCallbacks.size(); i++) {
1225 mAudioPortCallbacks[i]->onServiceDied();
1226 }
1227 }
1228 {
1229 Mutex::Autolock _l(gLockAPS);
1230 AudioSystem::gAudioPolicyService.clear();
1231 }
1232
1233 ALOGW("AudioPolicyService server died!");
1234 }
1235
1236 } // namespace android
1237