Home | History | Annotate | Download | only in audio 
      1 /*
      2  * Copyright (C) 2011 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 "AudioPolicyCompatClient"
     18 //#define LOG_NDEBUG 0
     19 
     20 #include <stdint.h>
     21 
     22 #include <hardware/hardware.h>
     23 #include <system/audio.h>
     24 #include <system/audio_policy.h>
     25 #include <hardware/audio_policy.h>
     26 
     27 #include <hardware_legacy/AudioSystemLegacy.h>
     28 
     29 #include "AudioPolicyCompatClient.h"
     30 
     31 namespace android_audio_legacy {
     32 
     33 audio_module_handle_t AudioPolicyCompatClient::loadHwModule(const char *moduleName)
     34 {
     35     return mServiceOps->load_hw_module(mService, moduleName);
     36 }
     37 
     38 audio_io_handle_t AudioPolicyCompatClient::openOutput(audio_module_handle_t module,
     39                                                       audio_devices_t *pDevices,
     40                                                       uint32_t *pSamplingRate,
     41                                                       audio_format_t *pFormat,
     42                                                       audio_channel_mask_t *pChannelMask,
     43                                                       uint32_t *pLatencyMs,
     44                                                       audio_output_flags_t flags)
     45 {
     46     return mServiceOps->open_output_on_module(mService, module, pDevices, pSamplingRate,
     47                                               pFormat, pChannelMask, pLatencyMs,
     48                                               flags);
     49 }
     50 
     51 audio_io_handle_t AudioPolicyCompatClient::openDuplicateOutput(audio_io_handle_t output1,
     52                                                           audio_io_handle_t output2)
     53 {
     54     return mServiceOps->open_duplicate_output(mService, output1, output2);
     55 }
     56 
     57 status_t AudioPolicyCompatClient::closeOutput(audio_io_handle_t output)
     58 {
     59     return mServiceOps->close_output(mService, output);
     60 }
     61 
     62 status_t AudioPolicyCompatClient::suspendOutput(audio_io_handle_t output)
     63 {
     64     return mServiceOps->suspend_output(mService, output);
     65 }
     66 
     67 status_t AudioPolicyCompatClient::restoreOutput(audio_io_handle_t output)
     68 {
     69     return mServiceOps->restore_output(mService, output);
     70 }
     71 
     72 audio_io_handle_t AudioPolicyCompatClient::openInput(audio_module_handle_t module,
     73                                                      audio_devices_t *pDevices,
     74                                                      uint32_t *pSamplingRate,
     75                                                      audio_format_t *pFormat,
     76                                                      audio_channel_mask_t *pChannelMask)
     77 {
     78     return mServiceOps->open_input_on_module(mService, module, pDevices,
     79                                              pSamplingRate, pFormat, pChannelMask);
     80 }
     81 
     82 status_t AudioPolicyCompatClient::closeInput(audio_io_handle_t input)
     83 {
     84     return mServiceOps->close_input(mService, input);
     85 }
     86 
     87 status_t AudioPolicyCompatClient::setStreamOutput(AudioSystem::stream_type stream,
     88                                              audio_io_handle_t output)
     89 {
     90     return mServiceOps->set_stream_output(mService, (audio_stream_type_t)stream,
     91                                           output);
     92 }
     93 
     94 status_t AudioPolicyCompatClient::moveEffects(int session, audio_io_handle_t srcOutput,
     95                                                audio_io_handle_t dstOutput)
     96 {
     97     return mServiceOps->move_effects(mService, session, srcOutput, dstOutput);
     98 }
     99 
    100 String8 AudioPolicyCompatClient::getParameters(audio_io_handle_t ioHandle, const String8& keys)
    101 {
    102     char *str;
    103     String8 out_str8;
    104 
    105     str = mServiceOps->get_parameters(mService, ioHandle, keys.string());
    106     out_str8 = String8(str);
    107     free(str);
    108 
    109     return out_str8;
    110 }
    111 
    112 void AudioPolicyCompatClient::setParameters(audio_io_handle_t ioHandle,
    113                                             const String8& keyValuePairs,
    114                                             int delayMs)
    115 {
    116     mServiceOps->set_parameters(mService, ioHandle, keyValuePairs.string(),
    117                            delayMs);
    118 }
    119 
    120 status_t AudioPolicyCompatClient::setStreamVolume(
    121                                              AudioSystem::stream_type stream,
    122                                              float volume,
    123                                              audio_io_handle_t output,
    124                                              int delayMs)
    125 {
    126     return mServiceOps->set_stream_volume(mService, (audio_stream_type_t)stream,
    127                                           volume, output, delayMs);
    128 }
    129 
    130 status_t AudioPolicyCompatClient::startTone(ToneGenerator::tone_type tone,
    131                                        AudioSystem::stream_type stream)
    132 {
    133     return mServiceOps->start_tone(mService,
    134                                    AUDIO_POLICY_TONE_IN_CALL_NOTIFICATION,
    135                                    (audio_stream_type_t)stream);
    136 }
    137 
    138 status_t AudioPolicyCompatClient::stopTone()
    139 {
    140     return mServiceOps->stop_tone(mService);
    141 }
    142 
    143 status_t AudioPolicyCompatClient::setVoiceVolume(float volume, int delayMs)
    144 {
    145     return mServiceOps->set_voice_volume(mService, volume, delayMs);
    146 }
    147 
    148 }; // namespace android_audio_legacy
    149