5:42 a.m.
This code can register an handsfree audio agent and receive NewConnection and
Release calls.
---
tools/handsfree-audio.c | 332 +++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 332 insertions(+)
create mode 100644 tools/handsfree-audio.c
diff --git a/tools/handsfree-audio.c b/tools/handsfree-audio.c
new file mode 100644
index 0000000..88310aa
--- /dev/null
+++ b/tools/handsfree-audio.c
@@ -0,0 +1,332 @@
+/*
+ *
+ * oFono - Open Source Telephony
+ *
+ * Copyright (C) 2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <signal.h>
+
+#include <gdbus.h>
+#include <glib.h>
+
+#define OFONO_SERVICE "org.ofono"
+#define HFP_AUDIO_MANAGER_PATH "/"
+#define HFP_AUDIO_MANAGER_INTERFACE OFONO_SERVICE ".HandsfreeAudioManager"
+#define HFP_AUDIO_AGENT_PATH "/hfpaudioagent"
+#define HFP_AUDIO_AGENT_INTERFACE OFONO_SERVICE ".HandsfreeAudioAgent"
+
+#define HFP_AUDIO_CVSD 1
+#define HFP_AUDIO_MSBC 2
+
+#define DBG(fmt, arg...) do {\
+ g_print("%s: " fmt "\n", __FUNCTION__, ## arg);\
+ } while (0)
+
+/* DBus related */
+static GMainLoop *main_loop = NULL;
+static DBusConnection *conn;
+static GSList *hcons = NULL;
+
+static gboolean option_nocvsd = FALSE;
+static gboolean option_nomsbc = FALSE;
+
+struct hfp_audio_conn {
+ unsigned char codec;
+ int watch;
+};
+
+static void hfp_audio_conn_free(struct hfp_audio_conn *hcon)
+{
+ DBG("Freeing audio connection %p", hcon);
+
+ hcons = g_slist_remove(hcons, hcon);
+ g_source_remove(hcon->watch);
+ g_free(hcon);
+}
+
+static gboolean hfp_audio_cb(GIOChannel *io, GIOCondition cond, gpointer data)
+{
+ struct hfp_audio_conn *hcon = data;
+ gsize read;
+ gsize written;
+ char buf[60];
+
+ if (cond & (G_IO_HUP | G_IO_NVAL | G_IO_ERR))
+ goto fail;
+
+ if (g_io_channel_read_chars(io, buf, sizeof(buf), &read, NULL) !=
+ G_IO_STATUS_NORMAL)
+ goto fail;
+
+ g_io_channel_write_chars(io, buf+written, read, &written, NULL);
+
+ return TRUE;
+
+fail:
+ DBG("Disconnected");
+ hfp_audio_conn_free(hcon);
+ return FALSE;
+}
+
+static DBusMessage *agent_newconnection(DBusConnection *conn, DBusMessage *msg,
+ void *data)
+{
+ const char *card;
+ int fd;
+ unsigned char codec;
+ GIOChannel *io;
+ struct hfp_audio_conn *hcon;
+
+ DBG("New connection");
+
+ if (dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &card,
+ DBUS_TYPE_UNIX_FD, &fd,
+ DBUS_TYPE_BYTE, &codec,
+ DBUS_TYPE_INVALID) == FALSE)
+ return g_dbus_create_error(msg,
+ HFP_AUDIO_AGENT_INTERFACE ".InvalidArguments",
+ "Invalid arguments");
+
+ DBG("New connection: card=%s fd=%d codec=%d", card, fd, codec);
+
+ io = g_io_channel_unix_new(fd);
+
+ hcon = g_try_malloc0(sizeof(struct hfp_audio_conn));
+ if (hcon == NULL)
+ return NULL;
+
+ hcon->codec = codec;
+ hcon->watch = g_io_add_watch(io, G_IO_IN, hfp_audio_cb, hcon);
+ hcons = g_slist_prepend(hcons, hcon);
+
+ return dbus_message_new_method_return(msg);
+}
+
+static DBusMessage *agent_release(DBusConnection *conn, DBusMessage *msg,
+ void *data)
+{
+ DBG("HFP audio agent released");
+ return dbus_message_new_method_return(msg);
+}
+
+static const GDBusMethodTable agent_methods[] = {
+ { GDBUS_METHOD("NewConnection", NULL, NULL, agent_newconnection) },
+ { GDBUS_METHOD("Release", NULL, NULL, agent_release) },
+ { },
+};
+
+static void hfp_audio_agent_register_reply(DBusPendingCall *call, void *data)
+{
+ DBusMessage *reply = dbus_pending_call_steal_reply(call);
+ DBusError err;
+
+ dbus_error_init(&err);
+
+ if (dbus_set_error_from_message(&err, reply) == TRUE) {
+ DBG("Failed to register audio agent (%s: %s)", err.name,
+ err.message);
+ dbus_error_free(&err);
+ } else {
+ DBG("HFP audio agent registered");
+ }
+
+ dbus_message_unref(reply);
+}
+
+static void hfp_audio_agent_register(DBusConnection *conn)
+{
+ DBusMessage *msg;
+ DBusPendingCall *call;
+ const char *path = HFP_AUDIO_AGENT_PATH;
+ unsigned char codecs[2];
+ const unsigned char *pcodecs = codecs;
+ int ncodecs = 0;
+
+ DBG("Registering audio agent");
+
+ msg = dbus_message_new_method_call(OFONO_SERVICE,
+ HFP_AUDIO_MANAGER_PATH,
+ HFP_AUDIO_MANAGER_INTERFACE,
+ "Register");
+ if (msg == NULL) {
+ DBG("Not enough memory");
+ return;
+ }
+
+ if (option_nocvsd == FALSE)
+ codecs[ncodecs++] = HFP_AUDIO_CVSD;
+
+ if (option_nomsbc == FALSE)
+ codecs[ncodecs++] = HFP_AUDIO_MSBC;
+
+ dbus_message_append_args(msg, DBUS_TYPE_OBJECT_PATH, &path,
+ DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE,
+ &pcodecs, ncodecs, DBUS_TYPE_INVALID);
+
+ if (!dbus_connection_send_with_reply(conn, msg, &call, -1)) {
+ dbus_message_unref(msg);
+ DBG("Unable to register agent");
+ return;
+ }
+
+ dbus_message_unref(msg);
+
+ if (call == NULL) {
+ DBG("Unable to register agent");
+ return;
+ }
+
+ dbus_pending_call_set_notify(call, hfp_audio_agent_register_reply,
+ NULL, NULL);
+
+ dbus_pending_call_unref(call);
+}
+
+static void hfp_audio_agent_create(DBusConnection *conn)
+{
+ DBG("Creating audio agent");
+
+ if (!g_dbus_register_interface(conn, HFP_AUDIO_AGENT_PATH,
+ HFP_AUDIO_AGENT_INTERFACE,
+ agent_methods, NULL, NULL,
+ NULL, NULL)) {
+ DBG("Unable to create local agent");
+ g_main_loop_quit(main_loop);
+ }
+}
+
+static void hfp_audio_agent_destroy(DBusConnection *conn)
+{
+ DBG("Destroying audio agent");
+
+ g_dbus_unregister_interface(conn, HFP_AUDIO_AGENT_PATH,
+ HFP_AUDIO_AGENT_INTERFACE);
+}
+
+static void ofono_connect(DBusConnection *conn, void *user_data)
+{
+ DBG("oFono appeared");
+
+ hfp_audio_agent_register(conn);
+}
+
+static void ofono_disconnect(DBusConnection *conn, void *user_data)
+{
+ DBG("oFono disappeared");
+}
+
+static void disconnect_callback(DBusConnection *conn, void *user_data)
+{
+ DBG("Disconnected from BUS");
+
+ g_main_loop_quit(main_loop);
+}
+
+static void sig_term(int sig)
+{
+ DBG("Terminating");
+
+ g_main_loop_quit(main_loop);
+}
+
+static GOptionEntry options[] = {
+ { "nocvsd", 'c', 0, G_OPTION_ARG_NONE, &option_nocvsd,
+ "Disable CVSD support" },
+ { "nomsbc", 'm', 0, G_OPTION_ARG_NONE, &option_nomsbc,
+ "Disable MSBC support" },
+ { NULL },
+};
+
+int main(int argc, char **argv)
+{
+ GOptionContext *context;
+ GError *error = NULL;
+ DBusError err;
+ guint watch;
+ struct sigaction sa;
+
+ context = g_option_context_new(NULL);
+ g_option_context_add_main_entries(context, options, NULL);
+
+ if (g_option_context_parse(context, &argc, &argv, &error) == FALSE) {
+ if (error != NULL) {
+ DBG("%s", error->message);
+ g_error_free(error);
+ } else
+ DBG("An unknown error occurred");
+ exit(1);
+ }
+
+ g_option_context_free(context);
+
+ if (option_nocvsd == TRUE && option_nomsbc == TRUE) {
+ DBG("At least one codec must be supported");
+ exit(2);
+ }
+
+ main_loop = g_main_loop_new(NULL, FALSE);
+
+ dbus_error_init(&err);
+
+ conn = g_dbus_setup_bus(DBUS_BUS_SYSTEM, NULL, &err);
+ if (conn == NULL) {
+ if (dbus_error_is_set(&err) == TRUE) {
+ DBG("%s", err.message);
+ dbus_error_free(&err);
+ } else
+ DBG("Can't register with system bus");
+ exit(1);
+ }
+
+ g_dbus_set_disconnect_function(conn, disconnect_callback, NULL, NULL);
+
+ memset(&sa, 0, sizeof(sa));
+ sa.sa_handler = sig_term;
+ sigaction(SIGINT, &sa, NULL);
+ sigaction(SIGTERM, &sa, NULL);
+
+ hfp_audio_agent_create(conn);
+
+ watch = g_dbus_add_service_watch(conn, OFONO_SERVICE,
+ ofono_connect, ofono_disconnect, NULL, NULL);
+
+ g_main_loop_run(main_loop);
+
+ g_dbus_remove_watch(conn, watch);
+
+ while (hcons != NULL)
+ hfp_audio_conn_free(hcons->data);
+
+ hfp_audio_agent_destroy(conn);
+
+ dbus_connection_unref(conn);
+
+ g_main_loop_unref(main_loop);
+
+ return 0;
+}
--
1.7.9.5
5:42 a.m.
New subject: [RFC 2/5] handsfree-audio: Build handsfree-audio command line tool
---
Makefile.am | 6 +++++-
1 file changed, 5 insertions(+), 1 deletion(-)
diff --git a/Makefile.am b/Makefile.am
index 557f499..68ae85d 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -718,11 +718,15 @@ TESTS = $(unit_tests)
if TOOLS
noinst_PROGRAMS += tools/huawei-audio tools/auto-enable \
tools/get-location tools/lookup-apn \
- tools/lookup-provider-name tools/tty-redirector
+ tools/lookup-provider-name tools/tty-redirector \
+ tools/handsfree-audio
tools_huawei_audio_SOURCES = $(gdbus_sources) tools/huawei-audio.c
tools_huawei_audio_LDADD = @GLIB_LIBS@ @DBUS_LIBS@
+tools_handsfree_audio_SOURCES = $(gdbus_sources) tools/handsfree-audio.c
+tools_handsfree_audio_LDADD = @GLIB_LIBS@ @DBUS_LIBS@
+
tools_auto_enable_SOURCES = $(gdbus_sources) tools/auto-enable.c
tools_auto_enable_LDADD = @GLIB_LIBS@ @DBUS_LIBS@
--
1.7.9.5
5:42 a.m.
New subject: [RFC 3/5] handsfree-audio: Add Alsa dependancy
---
configure.ac | 5 +++++
1 file changed, 5 insertions(+)
diff --git a/configure.ac b/configure.ac
index a4a350f..9be3ebf 100644
--- a/configure.ac
+++ b/configure.ac
@@ -121,6 +121,11 @@ if (test "${enable_tools}" = "yes"); then
AC_MSG_ERROR(USB library is required))
AC_SUBST(USB_CFLAGS)
AC_SUBST(USB_LIBS)
+
+ PKG_CHECK_MODULES(ALSA, alsa >= 1.0.0, dummy=yes,
+ AC_MSG_ERROR(Alsa library is required))
+ AC_SUBST(ALSA_CFLAGS)
+ AC_SUBST(ALSA_LIBS)
fi
AM_CONDITIONAL(TOOLS, test "${enable_tools}" = "yes")
--
1.7.9.5
5:42 a.m.
New subject: [RFC 4/5] handsfree-audio: Link tool with Alsa
---
Makefile.am | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/Makefile.am b/Makefile.am
index 68ae85d..ab687db 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -725,7 +725,7 @@ tools_huawei_audio_SOURCES = $(gdbus_sources) tools/huawei-audio.c
tools_huawei_audio_LDADD = @GLIB_LIBS@ @DBUS_LIBS@
tools_handsfree_audio_SOURCES = $(gdbus_sources) tools/handsfree-audio.c
-tools_handsfree_audio_LDADD = @GLIB_LIBS@ @DBUS_LIBS@
+tools_handsfree_audio_LDADD = @GLIB_LIBS@ @DBUS_LIBS@ @ALSA_LIBS@ -lpthread
tools_auto_enable_SOURCES = $(gdbus_sources) tools/auto-enable.c
tools_auto_enable_LDADD = @GLIB_LIBS@ @DBUS_LIBS@
--
1.7.9.5
5:42 a.m.
New subject: [RFC 5/5] handsfree-audio: Implement alsa playback
---
tools/handsfree-audio.c | 273 +++++++++++++++++++++++++++++++++++++++--------
1 file changed, 230 insertions(+), 43 deletions(-)
diff --git a/tools/handsfree-audio.c b/tools/handsfree-audio.c
index 88310aa..b5f05d3 100644
--- a/tools/handsfree-audio.c
+++ b/tools/handsfree-audio.c
@@ -30,10 +30,16 @@
#include <stdlib.h>
#include <string.h>
#include <signal.h>
+#include <sys/time.h>
#include <gdbus.h>
#include <glib.h>
+#include <alsa/asoundlib.h>
+#include <pthread.h>
+#include <bluetooth/bluetooth.h>
+#include <bluetooth/sco.h>
+
#define OFONO_SERVICE "org.ofono"
#define HFP_AUDIO_MANAGER_PATH "/"
#define HFP_AUDIO_MANAGER_INTERFACE OFONO_SERVICE ".HandsfreeAudioManager"
@@ -50,57 +56,226 @@
/* DBus related */
static GMainLoop *main_loop = NULL;
static DBusConnection *conn;
-static GSList *hcons = NULL;
+static GSList *threads = NULL;
static gboolean option_nocvsd = FALSE;
static gboolean option_nomsbc = FALSE;
-struct hfp_audio_conn {
+enum {
+ THREAD_STATE_DEFERED,
+ THREAD_STATE_TRANSMIT
+};
+
+struct hfp_audio_thread {
+ int state;
unsigned char codec;
- int watch;
+ int fd;
+ int running;
+ pthread_t thread;
};
-static void hfp_audio_conn_free(struct hfp_audio_conn *hcon)
+static snd_pcm_t *hfp_audio_pcm_init(snd_pcm_stream_t stream)
+{
+ snd_pcm_t *pcm;
+ DBG("Initializing pcm for %s", (stream == SND_PCM_STREAM_CAPTURE) ?
+ "capture" : "playback");
+
+ if (snd_pcm_open(&pcm, "default", stream, SND_PCM_NONBLOCK) < 0) {
+ DBG("Failed to open pcm");
+ return NULL;
+ }
+
+ /* 8000 khz, 16 bits, 128000 bytes/s, 48 bytes/frame, 6000 fps */
+ if (snd_pcm_set_params(pcm, SND_PCM_FORMAT_S16_LE,
+ SND_PCM_ACCESS_RW_INTERLEAVED,
+ 1, 8000, 1, 20000) < 0) {
+ DBG("Failed to set pcm params");
+ snd_pcm_close(pcm);
+ pcm = NULL;
+ }
+
+ return pcm;
+}
+
+static void hfp_audio_thread_free(struct hfp_audio_thread *hcon)
{
DBG("Freeing audio connection %p", hcon);
+ if (!hcon)
+ return;
+
+ hcon->running = 0;
+ if (hcon->thread)
+ pthread_join(hcon->thread, NULL);
- hcons = g_slist_remove(hcons, hcon);
- g_source_remove(hcon->watch);
+ threads = g_slist_remove(threads, hcon);
g_free(hcon);
+ DBG("freed %p", hcon);
}
-static gboolean hfp_audio_cb(GIOChannel *io, GIOCondition cond, gpointer data)
+/* Returns the number of data on sco socket */
+static int hfp_audio_playback(int fd, snd_pcm_t *playback)
{
- struct hfp_audio_conn *hcon = data;
- gsize read;
- gsize written;
- char buf[60];
+ char buf[800];
+ snd_pcm_sframes_t frames;
+ int total, captured, written, bytes;
+
+ bytes = read(fd, buf, sizeof(buf));
+ if (bytes < 0) {
+ DBG("Failed to read: bytes %d, errno %d", bytes, errno);
+ switch (errno) {
+ case ENOTCONN:
+ return -ENOTCONN;
+ case EAGAIN:
+ return 0;
+ default:
+ return -EINVAL;
+ }
+ }
- if (cond & (G_IO_HUP | G_IO_NVAL | G_IO_ERR))
- goto fail;
+ frames = snd_pcm_writei(playback, buf, bytes / 2);
+ switch (frames) {
+ case -EPIPE:
+ DBG("Playback underrun");
+ snd_pcm_prepare(playback);
+ return bytes;
+ case -EAGAIN:
+ DBG("??? %d", bytes / 2);
+ return bytes;
+ case -EBADFD:
+ case -ESTRPIPE:
+ return -EINVAL;
+ }
- if (g_io_channel_read_chars(io, buf, sizeof(buf), &read, NULL) !=
- G_IO_STATUS_NORMAL)
- goto fail;
+ if (frames < bytes / 2)
+ DBG("played %d < requested %d", (int)frames, bytes / 2);
- g_io_channel_write_chars(io, buf+written, read, &written, NULL);
+ return bytes;
+}
- return TRUE;
+/* Returns the number of data on sco socket */
+static int hfp_audio_capture(int fd, snd_pcm_t *capture, GList **outq, int mtu)
+{
+ snd_pcm_sframes_t frames;
+ int totalbytes, captured, written, bytes, tosend;
+ gchar *buf;
+
+ buf = g_try_malloc(mtu);
+ if (!buf)
+ return -ENOMEM;
+
+ frames = snd_pcm_readi(capture, buf, mtu / 2);
+ switch (frames) {
+ case -EPIPE:
+ DBG("Capture overrun");
+ snd_pcm_prepare(capture);
+ return 0;
+ case -EAGAIN:
+ DBG("No data to capture");
+ return 0;
+ case -EBADFD:
+ case -ESTRPIPE:
+ return -EINVAL;
+ }
-fail:
- DBG("Disconnected");
- hfp_audio_conn_free(hcon);
- return FALSE;
+ *outq = g_list_append(*outq, buf);
+
+ return frames * 2;
+}
+
+static void pop_outq(int fd, GList **outq, int qsize, int mtu)
+{
+ GList *el;
+
+ el = g_list_first(*outq);
+ if (!el)
+ return;
+
+ *outq = g_list_remove_link(*outq, el);
+ write(fd, el->data, mtu);
+
+ g_free(el->data);
+ g_list_free(el);
+}
+
+static void *thread_func(void *userdata)
+{
+ struct hfp_audio_thread *hcon = userdata;
+ snd_pcm_t *playback, *capture;
+ int in, totalread = 0;
+ int out, totalwrite = 0;
+ int total, captured, written, bytes;
+ GList *outq = NULL;
+ struct timeval t0, t1, t;
+ struct sco_options opts;
+
+ /* Add SCO options
+ bytes = sizeof(opts);
+ if (getsockopt(hcon->fd, SOL_SCO, SCO_OPTIONS, &opts, &bytes) < 0) {
+ DBG("getsockopt failed");
+ return NULL;
+ }*/
+ opts.mtu = 48;
+
+ DBG("thread started mtu %d", opts.mtu);
+
+ playback = hfp_audio_pcm_init(SND_PCM_STREAM_PLAYBACK);
+ if (!playback)
+ return NULL;
+
+ capture = hfp_audio_pcm_init(SND_PCM_STREAM_CAPTURE);
+ if (!capture) {
+ snd_pcm_close(playback);
+ return NULL;
+ }
+
+ gettimeofday(&t0, NULL);
+ while (hcon->running) {
+ in = hfp_audio_playback(hcon->fd, playback);
+ if (hcon->state == THREAD_STATE_DEFERED)
+ DBG("in %d", in);
+ if ((in == 0 || in == -ENOTCONN) &&
+ hcon->state == THREAD_STATE_DEFERED)
+ goto schedule;
+ else if (in < 0)
+ break;
+ else if (in > 0)
+ hcon->state = THREAD_STATE_TRANSMIT;
+
+ out = hfp_audio_capture(hcon->fd, capture, &outq, opts.mtu);
+ if (out < 0)
+ break;
+
+ totalread += in;
+ totalwrite += out;
+
+ gettimeofday(&t1, NULL);
+ pop_outq(hcon->fd, &outq, 20, opts.mtu);
+
+ timersub(&t1, &t0, &t);
+ /* More than one second passed? */
+ if (t.tv_sec) {
+ DBG("total: read %d, write %d", totalread, totalwrite);
+ gettimeofday(&t0, NULL);
+ }
+schedule:
+ usleep(2000);
+ }
+
+ DBG("thread terminating");
+ snd_pcm_close(playback);
+ snd_pcm_close(capture);
+ return NULL;
}
static DBusMessage *agent_newconnection(DBusConnection *conn, DBusMessage *msg,
void *data)
{
const char *card;
- int fd;
+ int fd, err;
unsigned char codec;
- GIOChannel *io;
- struct hfp_audio_conn *hcon;
+ struct hfp_audio_thread *hcon;
+ DBusMessage *reply;
+ pthread_attr_t attr;
DBG("New connection");
@@ -114,28 +289,45 @@ static DBusMessage *agent_newconnection(DBusConnection *conn,
DBusMessage *msg,
DBG("New connection: card=%s fd=%d codec=%d", card, fd, codec);
- io = g_io_channel_unix_new(fd);
-
- hcon = g_try_malloc0(sizeof(struct hfp_audio_conn));
+ hcon = g_try_malloc0(sizeof(struct hfp_audio_thread));
if (hcon == NULL)
- return NULL;
+ goto fail;
+ hcon->state = THREAD_STATE_DEFERED;
+ hcon->fd = fd;
hcon->codec = codec;
- hcon->watch = g_io_add_watch(io, G_IO_IN, hfp_audio_cb, hcon);
- hcons = g_slist_prepend(hcons, hcon);
- return dbus_message_new_method_return(msg);
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ goto fail;
+
+ hcon->running = 1;
+ if (pthread_create(&hcon->thread, NULL, thread_func, hcon) < 0)
+ goto fail;
+ /* FIXME thread is not joined until we quit */
+
+ threads = g_slist_prepend(threads, hcon);
+
+ return reply;
+
+fail:
+ hfp_audio_thread_free(hcon);
+ return g_dbus_create_error(msg,
+ HFP_AUDIO_AGENT_INTERFACE ".Failed", "Failed to start");
}
static DBusMessage *agent_release(DBusConnection *conn, DBusMessage *msg,
void *data)
{
DBG("HFP audio agent released");
+ /* agent will be registered on next oFono startup */
return dbus_message_new_method_return(msg);
}
static const GDBusMethodTable agent_methods[] = {
- { GDBUS_METHOD("NewConnection", NULL, NULL, agent_newconnection) },
+ { GDBUS_METHOD("NewConnection",
+ GDBUS_ARGS({ "path", "o" }, { "fd", "h" }, {
"codec", "y" }),
+ NULL, agent_newconnection) },
{ GDBUS_METHOD("Release", NULL, NULL, agent_release) },
{ },
};
@@ -167,7 +359,7 @@ static void hfp_audio_agent_register(DBusConnection *conn)
const unsigned char *pcodecs = codecs;
int ncodecs = 0;
- DBG("Registering audio agent");
+ DBG("Registering audio agent in oFono");
msg = dbus_message_new_method_call(OFONO_SERVICE,
HFP_AUDIO_MANAGER_PATH,
@@ -196,11 +388,6 @@ static void hfp_audio_agent_register(DBusConnection *conn)
dbus_message_unref(msg);
- if (call == NULL) {
- DBG("Unable to register agent");
- return;
- }
-
dbus_pending_call_set_notify(call, hfp_audio_agent_register_reply,
NULL, NULL);
@@ -209,7 +396,7 @@ static void hfp_audio_agent_register(DBusConnection *conn)
static void hfp_audio_agent_create(DBusConnection *conn)
{
- DBG("Creating audio agent");
+ DBG("Registering audio agent on DBUS");
if (!g_dbus_register_interface(conn, HFP_AUDIO_AGENT_PATH,
HFP_AUDIO_AGENT_INTERFACE,
@@ -222,7 +409,7 @@ static void hfp_audio_agent_create(DBusConnection *conn)
static void hfp_audio_agent_destroy(DBusConnection *conn)
{
- DBG("Destroying audio agent");
+ DBG("Unregistering audio agent on DBUS");
g_dbus_unregister_interface(conn, HFP_AUDIO_AGENT_PATH,
HFP_AUDIO_AGENT_INTERFACE);
@@ -319,8 +506,8 @@ int main(int argc, char **argv)
g_dbus_remove_watch(conn, watch);
- while (hcons != NULL)
- hfp_audio_conn_free(hcons->data);
+ while (threads != NULL)
+ hfp_audio_thread_free(threads->data);
hfp_audio_agent_destroy(conn);
--
1.7.9.5
3488
days inactive
3488
days old
4 comments
1 participants
participants (1)
-
Frédéric Dalleau