Audio RIL Interface: Initial commit
authorPaul Kocialkowski <contact@paulk.fr>
Tue, 28 Aug 2012 22:03:02 +0000 (00:03 +0200)
committerPaul Kocialkowski <contact@paulk.fr>
Tue, 28 Aug 2012 22:03:02 +0000 (00:03 +0200)
Audio RIL Interface permits to interact with the RIL (Radio Interface Layer).

Signed-off-by: Paul Kocialkowski <contact@paulk.fr>
Android.mk
AudioHardware.cpp
AudioHardware.h
AudioRILInterface.cpp [new file with mode: 0644]
AudioRILInterface.h [new file with mode: 0644]
AudioStreamOut.cpp
include/audio_ril_interface.h [new file with mode: 0644]

index 46d3422..61ffd8c 100644 (file)
@@ -9,6 +9,7 @@ LOCAL_SRC_FILES := \
        AudioResampler.cpp \
        AudioStreamOut.cpp \
        AudioStreamIn.cpp \
+       AudioRILInterface.cpp \
        Mixer.cpp
 
 LOCAL_C_INCLUDES += \
@@ -27,6 +28,7 @@ LOCAL_SHARED_LIBRARIES := \
        libmedia \
        libhardware \
        libhardware_legacy \
+       libdl \
        libc
 
 LOCAL_PRELINK_MODULE := false
index 49aabaf..14248e7 100644 (file)
 #include "AudioHardware.h"
 #include "AudioStreamOut.h"
 #include "AudioStreamIn.h"
+#include "AudioRILInterface.h"
 
 namespace android {
 
 AudioHardware::AudioHardware() :
        mInit(false),
-       mInput(NULL),
        mOutput(NULL),
+       mInput(NULL),
+       mRILInterface(NULL),
        mInDevices(0),
        mOutDevices(0),
        mMicMute(false)
@@ -41,6 +43,7 @@ AudioHardware::AudioHardware() :
        LOGD("AudioHardware()");
 
        mInit = true;
+       mRILInterface = new TinyALSAAudioRILInterface();
 }
 
 AudioHardware::~AudioHardware()
@@ -63,6 +66,9 @@ status_t AudioHardware::setVoiceVolume(float volume)
 {
        LOGD("setVoiceVolume(%f)", volume);
 
+       if(mRILInterface)
+               mRILInterface->setVoiceVolume(volume);
+
        return NO_ERROR;
 }
 
@@ -77,6 +83,9 @@ status_t AudioHardware::setMode(int mode)
 {
        LOGD("setMode(%d)", mode);
 
+       if(mRILInterface)
+               mRILInterface->setMode(mode);
+
        return NO_ERROR;
 }
 
@@ -86,6 +95,9 @@ status_t AudioHardware::setMicMute(bool state)
 
        mMicMute = state;
 
+       if(mRILInterface)
++              mRILInterface->setMicMute(state);
+
        return NO_ERROR;
 }
 
index 8c0c161..309c352 100644 (file)
@@ -26,6 +26,7 @@
 #include <hardware_legacy/AudioHardwareBase.h>
 #include "AudioStreamOut.h"
 #include "AudioStreamIn.h"
+#include "AudioRILInterface.h"
 
 namespace android {
 
@@ -66,6 +67,7 @@ public:
 
        TinyALSAAudioStreamOut *mOutput;
        TinyALSAAudioStreamIn *mInput;
+       TinyALSAAudioRILInterface *mRILInterface;
 
 protected:
        virtual status_t dump(int fd, const Vector<String16>& args);
diff --git a/AudioRILInterface.cpp b/AudioRILInterface.cpp
new file mode 100644 (file)
index 0000000..2b5087d
--- /dev/null
@@ -0,0 +1,137 @@
+/*
+ * Copyright (C) 2012 Paul Kocialkowski <contact@paulk.fr>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <dlfcn.h>
+
+#define LOG_TAG "AudioHardware"
+#include <cutils/log.h>
+
+#include "AudioHardware.h"
+#include "AudioRILInterface.h"
+
+namespace android {
+
+TinyALSAAudioRILInterface::TinyALSAAudioRILInterface() :
+       mInterface(NULL)
+{
+       void *mDlHandle = NULL;
+
+       LOGD("AudioRILInterface()");
+
+       mDlHandle = dlopen(AUDIO_RIL_INTERFACE_LIB, RTLD_NOW);
+       if(mDlHandle != NULL) {
+               mInterfaceOpen = (struct audio_ril_interface *(*)(void))
+                       dlsym(mDlHandle, "audio_ril_interface_open");
+               mInterfaceClose = (void (*)(struct audio_ril_interface *))
+                       dlsym(mDlHandle, "audio_ril_interface_close");
+
+               if(mInterfaceOpen == NULL || mInterfaceClose == NULL) {
+                       LOGE("AudioRILInterface(): Unable to get the functions from %s",
+                               AUDIO_RIL_INTERFACE_LIB);
+               } else {
+                       mInterface = mInterfaceOpen();
+
+                       if(mInterface == NULL) {
+                               LOGE("AudioRILInterface(): Unable to get interface");
+                       }
+               }
+       } else {
+               LOGE("AudioRILInterface(): Unable to dlopen %s", AUDIO_RIL_INTERFACE_LIB);
+       }
+}
+
+TinyALSAAudioRILInterface::~TinyALSAAudioRILInterface()
+{
+       LOGD("~AudioRILInterface()");
+
+       dlclose(mDlHandle);
+       mDlHandle = NULL;
+       mInterface = NULL;
+}
+
+status_t TinyALSAAudioRILInterface::setMode(int mode)
+{
+       int rc;
+
+       LOGD("TinyALSAAudioRILInterface::setMode(%d)", mode);
+
+       if(mInterface == NULL || mInterface->mode == NULL)
+               return BAD_VALUE;
+
+       rc = mInterface->mode(mInterface->pdata, mode);
+       if(rc < 0) {
+               LOGD("TinyALSAAudioRILInterface::setMode(): Error");
+               return BAD_VALUE;
+       }
+
+       return NO_ERROR;
+}
+
+status_t TinyALSAAudioRILInterface::setMicMute(bool mute)
+{
+       int rc;
+
+       LOGD("TinyALSAAudioRILInterface::setMicMute(%d)", (int) mute);
+
+       if(mInterface == NULL || mInterface->mic_mute == NULL)
+               return BAD_VALUE;
+
+       rc = mInterface->mic_mute(mInterface->pdata, mute);
+       if(rc < 0) {
+               LOGD("TinyALSAAudioRILInterface::setMicMute(): Error");
+               return BAD_VALUE;
+       }
+
+       return NO_ERROR;
+}
+
+status_t TinyALSAAudioRILInterface::setVoiceVolume(float volume)
+{
+       int rc;
+
+       LOGD("TinyALSAAudioRILInterface::setVoiceVolume(%f)", volume);
+
+       if(mInterface == NULL || mInterface->voice_volume == NULL)
+               return BAD_VALUE;
+
+       rc = mInterface->voice_volume(mInterface->pdata, volume);
+       if(rc < 0) {
+               LOGD("TinyALSAAudioRILInterface::setVoiceVolume(): Error");
+               return BAD_VALUE;
+       }
+
+       return NO_ERROR;
+}
+
+status_t TinyALSAAudioRILInterface::setRouting(int route)
+{
+       int rc;
+
+       LOGD("TinyALSAAudioRILInterface::setRouting(%d)", route);
+
+       if(mInterface == NULL || mInterface->routing == NULL)
+               return BAD_VALUE;
+
+       rc = mInterface->routing(mInterface->pdata, route);
+       if(rc < 0) {
+               LOGD("TinyALSAAudioRILInterface::setRouting(): Error");
+               return BAD_VALUE;
+       }
+
+       return NO_ERROR;
+}
+
+}; // namespace android
diff --git a/AudioRILInterface.h b/AudioRILInterface.h
new file mode 100644 (file)
index 0000000..4df7d33
--- /dev/null
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2012 Paul Kocialkowski <contact@paulk.fr>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TINYALSA_AUDIO_RIL_INTERFACE_H
+#define TINYALSA_AUDIO_RIL_INTERFACE_H
+
+#include <audio_ril_interface.h>
+
+namespace android {
+
+class TinyALSAAudioRILInterface
+{
+public:
+       TinyALSAAudioRILInterface();
+       virtual ~TinyALSAAudioRILInterface();
+
+       virtual status_t setMode(int mode);
+       virtual status_t setMicMute(bool mute);
+       virtual status_t setVoiceVolume(float volume);
+       virtual status_t setRouting(int route);
+
+private:
+       struct audio_ril_interface *mInterface;
+       struct audio_ril_interface *(*mInterfaceOpen)(void);
+       void (*mInterfaceClose)(struct audio_ril_interface *);
+
+       void *mDlHandle;
+};
+
+}; // namespace android
+
+#endif
index 6a2c349..74b2048 100644 (file)
@@ -199,6 +199,9 @@ status_t TinyALSAAudioStreamOut::setParameters(const String8& keyValuePairs)
                        mMixer->route(mDevice);
                }
 
+               if(mAudioHardware->mRILInterface)
+                       mAudioHardware->mRILInterface->setRouting(device);
+
                param.remove(key);
        }
 
diff --git a/include/audio_ril_interface.h b/include/audio_ril_interface.h
new file mode 100644 (file)
index 0000000..2252036
--- /dev/null
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2012 Paul Kocialkowski <contact@paulk.fr>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TINYALSA_AUDIO_RIL_INTERFACE
+#define TINYALSA_AUDIO_RIL_INTERFACE
+
+#define AUDIO_RIL_INTERFACE_LIB        "libaudio-ril-interface.so"
+
+struct audio_ril_interface {
+       void *pdata;
+       int (*mode)(void *pdata, int mode);
+       int (*mic_mute)(void *pdata, int mute);
+       int (*voice_volume)(void *pdata, float volume);
+       int (*routing)(void *pdata, int route);
+};
+
+#endif