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