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