Home | History | Annotate | Download | only in service
      1 /*
      2  * Copyright (C) 2009 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 "AudioPolicyClientImpl"
     18 //#define LOG_NDEBUG 0
     19 
     20 #include <soundtrigger/SoundTrigger.h>
     21 #include <utils/Log.h>
     22 #include "AudioPolicyService.h"
     23 
     24 namespace android {
     25 
     26 /* implementation of the client interface from the policy manager */
     27 
     28 audio_module_handle_t AudioPolicyService::AudioPolicyClient::loadHwModule(const char *name)
     29 {
     30     sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
     31     if (af == 0) {
     32         ALOGW("%s: could not get AudioFlinger", __func__);
     33         return AUDIO_MODULE_HANDLE_NONE;
     34     }
     35 
     36     return af->loadHwModule(name);
     37 }
     38 
     39 status_t AudioPolicyService::AudioPolicyClient::openOutput(audio_module_handle_t module,
     40                                                            audio_io_handle_t *output,
     41                                                            audio_config_t *config,
     42                                                            audio_devices_t *devices,
     43                                                            const String8& address,
     44                                                            uint32_t *latencyMs,
     45                                                            audio_output_flags_t flags)
     46 {
     47     sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
     48     if (af == 0) {
     49         ALOGW("%s: could not get AudioFlinger", __func__);
     50         return PERMISSION_DENIED;
     51     }
     52     return af->openOutput(module, output, config, devices, address, latencyMs, flags);
     53 }
     54 
     55 audio_io_handle_t AudioPolicyService::AudioPolicyClient::openDuplicateOutput(
     56                                                                 audio_io_handle_t output1,
     57                                                                 audio_io_handle_t output2)
     58 {
     59     sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
     60     if (af == 0) {
     61         ALOGW("%s: could not get AudioFlinger", __func__);
     62         return 0;
     63     }
     64     return af->openDuplicateOutput(output1, output2);
     65 }
     66 
     67 status_t AudioPolicyService::AudioPolicyClient::closeOutput(audio_io_handle_t output)
     68 {
     69     sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
     70     if (af == 0) {
     71         return PERMISSION_DENIED;
     72     }
     73 
     74     return af->closeOutput(output);
     75 }
     76 
     77 status_t AudioPolicyService::AudioPolicyClient::suspendOutput(audio_io_handle_t output)
     78 {
     79     sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
     80     if (af == 0) {
     81         ALOGW("%s: could not get AudioFlinger", __func__);
     82         return PERMISSION_DENIED;
     83     }
     84 
     85     return af->suspendOutput(output);
     86 }
     87 
     88 status_t AudioPolicyService::AudioPolicyClient::restoreOutput(audio_io_handle_t output)
     89 {
     90     sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
     91     if (af == 0) {
     92         ALOGW("%s: could not get AudioFlinger", __func__);
     93         return PERMISSION_DENIED;
     94     }
     95 
     96     return af->restoreOutput(output);
     97 }
     98 
     99 status_t AudioPolicyService::AudioPolicyClient::openInput(audio_module_handle_t module,
    100                                                           audio_io_handle_t *input,
    101                                                           audio_config_t *config,
    102                                                           audio_devices_t *device,
    103                                                           const String8& address,
    104                                                           audio_source_t source,
    105                                                           audio_input_flags_t flags)
    106 {
    107     sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
    108     if (af == 0) {
    109         ALOGW("%s: could not get AudioFlinger", __func__);
    110         return PERMISSION_DENIED;
    111     }
    112 
    113     return af->openInput(module, input, config, device, address, source, flags);
    114 }
    115 
    116 status_t AudioPolicyService::AudioPolicyClient::closeInput(audio_io_handle_t input)
    117 {
    118     sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
    119     if (af == 0) {
    120         return PERMISSION_DENIED;
    121     }
    122 
    123     return af->closeInput(input);
    124 }
    125 
    126 status_t AudioPolicyService::AudioPolicyClient::setStreamVolume(audio_stream_type_t stream,
    127                      float volume, audio_io_handle_t output,
    128                      int delay_ms)
    129 {
    130     return mAudioPolicyService->setStreamVolume(stream, volume, output,
    131                                                delay_ms);
    132 }
    133 
    134 status_t AudioPolicyService::AudioPolicyClient::invalidateStream(audio_stream_type_t stream)
    135 {
    136     sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
    137     if (af == 0) {
    138         return PERMISSION_DENIED;
    139     }
    140 
    141     return af->invalidateStream(stream);
    142 }
    143 
    144 void AudioPolicyService::AudioPolicyClient::setParameters(audio_io_handle_t io_handle,
    145                    const String8& keyValuePairs,
    146                    int delay_ms)
    147 {
    148     mAudioPolicyService->setParameters(io_handle, keyValuePairs.string(), delay_ms);
    149 }
    150 
    151 String8 AudioPolicyService::AudioPolicyClient::getParameters(audio_io_handle_t io_handle,
    152                       const String8& keys)
    153 {
    154     String8 result = AudioSystem::getParameters(io_handle, keys);
    155     return result;
    156 }
    157 
    158 status_t AudioPolicyService::AudioPolicyClient::startTone(audio_policy_tone_t tone,
    159               audio_stream_type_t stream)
    160 {
    161     return mAudioPolicyService->startTone(tone, stream);
    162 }
    163 
    164 status_t AudioPolicyService::AudioPolicyClient::stopTone()
    165 {
    166     return mAudioPolicyService->stopTone();
    167 }
    168 
    169 status_t AudioPolicyService::AudioPolicyClient::setVoiceVolume(float volume, int delay_ms)
    170 {
    171     return mAudioPolicyService->setVoiceVolume(volume, delay_ms);
    172 }
    173 
    174 status_t AudioPolicyService::AudioPolicyClient::moveEffects(audio_session_t session,
    175                         audio_io_handle_t src_output,
    176                         audio_io_handle_t dst_output)
    177 {
    178     sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
    179     if (af == 0) {
    180         return PERMISSION_DENIED;
    181     }
    182 
    183     return af->moveEffects(session, src_output, dst_output);
    184 }
    185 
    186 status_t AudioPolicyService::AudioPolicyClient::createAudioPatch(const struct audio_patch *patch,
    187                                                                   audio_patch_handle_t *handle,
    188                                                                   int delayMs)
    189 {
    190     return mAudioPolicyService->clientCreateAudioPatch(patch, handle, delayMs);
    191 }
    192 
    193 status_t AudioPolicyService::AudioPolicyClient::releaseAudioPatch(audio_patch_handle_t handle,
    194                                                                   int delayMs)
    195 {
    196     return mAudioPolicyService->clientReleaseAudioPatch(handle, delayMs);
    197 }
    198 
    199 status_t AudioPolicyService::AudioPolicyClient::setAudioPortConfig(
    200                                                         const struct audio_port_config *config,
    201                                                         int delayMs)
    202 {
    203     return mAudioPolicyService->clientSetAudioPortConfig(config, delayMs);
    204 }
    205 
    206 void AudioPolicyService::AudioPolicyClient::onAudioPortListUpdate()
    207 {
    208     mAudioPolicyService->onAudioPortListUpdate();
    209 }
    210 
    211 void AudioPolicyService::AudioPolicyClient::onAudioPatchListUpdate()
    212 {
    213     mAudioPolicyService->onAudioPatchListUpdate();
    214 }
    215 
    216 void AudioPolicyService::AudioPolicyClient::onDynamicPolicyMixStateUpdate(
    217         String8 regId, int32_t state)
    218 {
    219     mAudioPolicyService->onDynamicPolicyMixStateUpdate(regId, state);
    220 }
    221 
    222 void AudioPolicyService::AudioPolicyClient::onRecordingConfigurationUpdate(
    223         int event, audio_session_t session, audio_source_t source,
    224         const audio_config_base_t *clientConfig, const audio_config_base_t *deviceConfig,
    225         audio_patch_handle_t patchHandle)
    226 {
    227     mAudioPolicyService->onRecordingConfigurationUpdate(event, session, source,
    228             clientConfig, deviceConfig, patchHandle);
    229 }
    230 
    231 audio_unique_id_t AudioPolicyService::AudioPolicyClient::newAudioUniqueId(audio_unique_id_use_t use)
    232 {
    233     return AudioSystem::newAudioUniqueId(use);
    234 }
    235 
    236 }; // namespace android
    237