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_io_handle_t AudioPolicyCompatClient::openOutput(uint32_t *pDevices,
     34                                 uint32_t *pSamplingRate,
     35                                 uint32_t *pFormat,
     36                                 uint32_t *pChannels,
     37                                 uint32_t *pLatencyMs,
     38                                 AudioSystem::output_flags flags)
     39 {
     40     return mServiceOps->open_output(mService, pDevices, pSamplingRate, pFormat,
     41                                     pChannels, pLatencyMs,
     42                                     (audio_policy_output_flags_t)flags);
     43 }
     44 
     45 audio_io_handle_t AudioPolicyCompatClient::openDuplicateOutput(audio_io_handle_t output1,
     46                                                           audio_io_handle_t output2)
     47 {
     48     return mServiceOps->open_duplicate_output(mService, output1, output2);
     49 }
     50 
     51 status_t AudioPolicyCompatClient::closeOutput(audio_io_handle_t output)
     52 {
     53     return mServiceOps->close_output(mService, output);
     54 }
     55 
     56 status_t AudioPolicyCompatClient::suspendOutput(audio_io_handle_t output)
     57 {
     58     return mServiceOps->suspend_output(mService, output);
     59 }
     60 
     61 status_t AudioPolicyCompatClient::restoreOutput(audio_io_handle_t output)
     62 {
     63     return mServiceOps->restore_output(mService, output);
     64 }
     65 
     66 audio_io_handle_t AudioPolicyCompatClient::openInput(uint32_t *pDevices,
     67                                 uint32_t *pSamplingRate,
     68                                 uint32_t *pFormat,
     69                                 uint32_t *pChannels,
     70                                 uint32_t acoustics)
     71 {
     72     return mServiceOps->open_input(mService, pDevices, pSamplingRate, pFormat,
     73                                    pChannels, acoustics);
     74 }
     75 
     76 status_t AudioPolicyCompatClient::closeInput(audio_io_handle_t input)
     77 {
     78     return mServiceOps->close_input(mService, input);
     79 }
     80 
     81 status_t AudioPolicyCompatClient::setStreamOutput(AudioSystem::stream_type stream,
     82                                              audio_io_handle_t output)
     83 {
     84     return mServiceOps->set_stream_output(mService, (audio_stream_type_t)stream,
     85                                           output);
     86 }
     87 
     88 status_t AudioPolicyCompatClient::moveEffects(int session, audio_io_handle_t srcOutput,
     89                                                audio_io_handle_t dstOutput)
     90 {
     91     return mServiceOps->move_effects(mService, session, srcOutput, dstOutput);
     92 }
     93 
     94 String8 AudioPolicyCompatClient::getParameters(audio_io_handle_t ioHandle, const String8& keys)
     95 {
     96     char *str;
     97     String8 out_str8;
     98 
     99     str = mServiceOps->get_parameters(mService, ioHandle, keys.string());
    100     out_str8 = String8(str);
    101     free(str);
    102 
    103     return out_str8;
    104 }
    105 
    106 void AudioPolicyCompatClient::setParameters(audio_io_handle_t ioHandle,
    107                                             const String8& keyValuePairs,
    108                                             int delayMs)
    109 {
    110     mServiceOps->set_parameters(mService, ioHandle, keyValuePairs.string(),
    111                            delayMs);
    112 }
    113 
    114 status_t AudioPolicyCompatClient::setStreamVolume(
    115                                              AudioSystem::stream_type stream,
    116                                              float volume,
    117                                              audio_io_handle_t output,
    118                                              int delayMs)
    119 {
    120     return mServiceOps->set_stream_volume(mService, (audio_stream_type_t)stream,
    121                                           volume, output, delayMs);
    122 }
    123 
    124 status_t AudioPolicyCompatClient::startTone(ToneGenerator::tone_type tone,
    125                                        AudioSystem::stream_type stream)
    126 {
    127     return mServiceOps->start_tone(mService,
    128                                    AUDIO_POLICY_TONE_IN_CALL_NOTIFICATION,
    129                                    (audio_stream_type_t)stream);
    130 }
    131 
    132 status_t AudioPolicyCompatClient::stopTone()
    133 {
    134     return mServiceOps->stop_tone(mService);
    135 }
    136 
    137 status_t AudioPolicyCompatClient::setVoiceVolume(float volume, int delayMs)
    138 {
    139     return mServiceOps->set_voice_volume(mService, volume, delayMs);
    140 }
    141 
    142 }; // namespace android_audio_legacy
    143