From 22dd53fe6ef9783c3357a6da1ecedd3b01bb7003 Mon Sep 17 00:00:00 2001 From: Luiz Augusto von Dentz Date: Fri, 22 Jun 2007 20:58:12 +0000 Subject: Update build to make use of newly create files. --- audio/Makefile.am | 3 +- audio/headset.c | 827 ++++++++++++------------------------------------------ audio/headset.h | 49 +++- audio/main.c | 6 +- audio/manager.c | 369 +++++------------------- audio/manager.h | 67 +---- audio/unix.c | 9 +- 7 files changed, 296 insertions(+), 1034 deletions(-) diff --git a/audio/Makefile.am b/audio/Makefile.am index 68648a16..84242544 100644 --- a/audio/Makefile.am +++ b/audio/Makefile.am @@ -11,7 +11,8 @@ servicedir = $(libdir)/bluetooth service_PROGRAMS = bluetoothd-service-audio bluetoothd_service_audio_SOURCES = main.c \ - manager.h manager.c headset.h headset.c ipc.h unix.h unix.c + manager.h manager.c headset.h headset.c ipc.h unix.h unix.c \ + error.h error.c device.h device.c gateway.h gateway.c bluetoothd_service_audio_LDADD = $(top_builddir)/common/libhelper.a \ @GLIB_LIBS@ @DBUS_LIBS@ @BLUEZ_LIBS@ diff --git a/audio/headset.c b/audio/headset.c index 723bc1ab..59fe21e7 100644 --- a/audio/headset.c +++ b/audio/headset.c @@ -53,10 +53,7 @@ #include "dbus-helper.h" #include "logging.h" #include "manager.h" -#include "headset.h" - -#define DEFAULT_HS_AG_CHANNEL 12 -#define DEFAULT_HF_AG_CHANNEL 13 +#include "error.h" #define RING_INTERVAL 3000 @@ -65,32 +62,12 @@ #define HEADSET_GAIN_SPEAKER 'S' #define HEADSET_GAIN_MICROPHONE 'M' -typedef enum { - HEADSET_EVENT_KEYPRESS, - HEADSET_EVENT_GAIN, - HEADSET_EVENT_UNKNOWN, - HEADSET_EVENT_INVALID -} headset_event_t; - -typedef enum { - HEADSET_STATE_DISCONNECTED = 0, - HEADSET_STATE_CONNECT_IN_PROGRESS, - HEADSET_STATE_CONNECTED, - HEADSET_STATE_PLAY_IN_PROGRESS, - HEADSET_STATE_PLAYING, -} headset_state_t; - -typedef enum { - SVC_HEADSET, - SVC_HANDSFREE -} hs_type; - struct pending_connect { DBusMessage *msg; GIOChannel *io; guint io_id; int sock; - struct ipc_data_cfg *cfg; + struct ipc_packet *pkt; }; struct headset { @@ -108,7 +85,7 @@ struct headset { int data_start; int data_length; - hs_type type; + headset_type_t type; headset_state_t state; struct pending_connect *pending_connect; @@ -120,17 +97,6 @@ struct headset { static DBusHandlerResult hs_disconnect(DBusConnection *conn, DBusMessage *msg, void *data); -static gboolean disable_hfp = FALSE; -static gboolean sco_over_hci = TRUE; - -static GIOChannel *hs_server = NULL; -static GIOChannel *hf_server = NULL; - -static uint32_t hs_record_id = 0; -static uint32_t hf_record_id = 0; - -static DBusConnection *connection = NULL; - static void pending_connect_free(struct pending_connect *c) { if (c->io) @@ -140,7 +106,7 @@ static void pending_connect_free(struct pending_connect *c) g_free(c); } -static void hs_signal_gain_setting(audio_device_t *device, const char *buf) +static void hs_signal_gain_setting(struct device *device, const char *buf) { const char *name; dbus_uint16_t gain; @@ -175,7 +141,7 @@ static void hs_signal_gain_setting(audio_device_t *device, const char *buf) return; } - dbus_connection_emit_signal(connection, device->object_path, + dbus_connection_emit_signal(device->conn, device->path, AUDIO_HEADSET_INTERFACE, name, DBUS_TYPE_UINT16, &gain, DBUS_TYPE_INVALID); @@ -204,7 +170,7 @@ static headset_event_t parse_headset_event(const char *buf, char *rsp, return HEADSET_EVENT_UNKNOWN; } -static void close_sco(audio_device_t *device) +static void close_sco(struct device *device) { struct headset *hs = device->headset; @@ -213,13 +179,13 @@ static void close_sco(audio_device_t *device) hs->sco = NULL; assert(hs->rfcomm); hs->state = HEADSET_STATE_CONNECTED; - dbus_connection_emit_signal(connection, device->object_path, + dbus_connection_emit_signal(device->conn, device->path, AUDIO_HEADSET_INTERFACE, "Stopped", DBUS_TYPE_INVALID); } static gboolean rfcomm_io_cb(GIOChannel *chan, GIOCondition cond, - audio_device_t *device) + struct device *device) { struct headset *hs; unsigned char buf[BUF_SIZE]; @@ -279,7 +245,7 @@ static gboolean rfcomm_io_cb(GIOChannel *chan, GIOCondition cond, hs->ring_timer = 0; } - dbus_connection_emit_signal(connection, device->object_path, + dbus_connection_emit_signal(device->conn, device->path, AUDIO_HEADSET_INTERFACE, "AnswerRequested", DBUS_TYPE_INVALID); @@ -322,75 +288,8 @@ failed: return FALSE; } -static void send_cancel_auth(audio_device_t *device) -{ - DBusMessage *cancel; - char addr[18], *address = addr; - const char *uuid; - - if (device->headset->type == SVC_HEADSET) - uuid = HSP_AG_UUID; - else - uuid = HFP_AG_UUID; - - cancel = dbus_message_new_method_call("org.bluez", "/org/bluez", - "org.bluez.Database", - "CancelAuthorizationRequest"); - if (!cancel) { - error("Unable to allocate new method call"); - return; - } - - ba2str(&device->bda, addr); - - dbus_message_append_args(cancel, DBUS_TYPE_STRING, &address, - DBUS_TYPE_STRING, &uuid, DBUS_TYPE_INVALID); - - send_message_and_unref(connection, cancel); -} - -static void auth_callback(DBusPendingCall *call, void *data) -{ - audio_device_t *device = data; - struct headset *hs = device->headset; - DBusMessage *reply = dbus_pending_call_steal_reply(call); - DBusError err; - - dbus_error_init(&err); - if (dbus_set_error_from_message(&err, reply)) { - error("Access denied: %s", err.message); - if (dbus_error_has_name(&err, DBUS_ERROR_NO_REPLY)) { - debug("Canceling authorization request"); - send_cancel_auth(device); - } - dbus_error_free(&err); - g_io_channel_close(hs->rfcomm); - g_io_channel_unref(hs->rfcomm); - hs->rfcomm = NULL; - } else { - char hs_address[18]; - - g_io_add_watch(hs->rfcomm, - G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL, - (GIOFunc) rfcomm_io_cb, device); - - ba2str(&device->bda, hs_address); - - debug("Accepted headset connection from %s for %s", hs_address, - device->object_path); - - hs->state = HEADSET_STATE_CONNECTED; - dbus_connection_emit_signal(connection, device->object_path, - AUDIO_HEADSET_INTERFACE, - "Connected", - DBUS_TYPE_INVALID); - } - - dbus_message_unref(reply); -} - static gboolean sco_cb(GIOChannel *chan, GIOCondition cond, - audio_device_t *device) + struct device *device) { struct headset *hs; @@ -407,7 +306,7 @@ static gboolean sco_cb(GIOChannel *chan, GIOCondition cond, return FALSE; } -static GIOError headset_send(headset_t *hs, const char *str) +static GIOError headset_send(struct headset *hs, const char *str) { GIOError err; gsize total_written, written, count; @@ -434,7 +333,7 @@ static GIOError headset_send(headset_t *hs, const char *str) } static gboolean sco_connect_cb(GIOChannel *chan, GIOCondition cond, - audio_device_t *device) + struct device *device) { struct headset *hs; int ret, sk, err, flags; @@ -467,7 +366,7 @@ static gboolean sco_connect_cb(GIOChannel *chan, GIOCondition cond, goto failed; } - debug("SCO socket opened for headset %s", device->object_path); + debug("SCO socket opened for headset %s", device->path); info("SCO fd=%d", sk); hs->sco = chan; @@ -480,7 +379,13 @@ static gboolean sco_connect_cb(GIOChannel *chan, GIOCondition cond, if (hs->pending_connect->msg) { reply = dbus_message_new_method_return(hs->pending_connect->msg); if (reply) - send_message_and_unref(connection, reply); + send_message_and_unref(device->conn, reply); + } + else if (hs->pending_connect->pkt) { + headset_get_config(device, hs->pending_connect->sock, + hs->pending_connect->pkt); + unix_send_cfg(hs->pending_connect->sock, + hs->pending_connect->pkt); } pending_connect_free(hs->pending_connect); @@ -489,7 +394,7 @@ static gboolean sco_connect_cb(GIOChannel *chan, GIOCondition cond, fcntl(sk, F_SETFL, 0); hs->state = HEADSET_STATE_PLAYING; - dbus_connection_emit_signal(connection, device->object_path, + dbus_connection_emit_signal(device->conn, device->path, AUDIO_HEADSET_INTERFACE, "Playing", DBUS_TYPE_INVALID); @@ -506,7 +411,7 @@ static gboolean sco_connect_cb(GIOChannel *chan, GIOCondition cond, return FALSE; failed: - err_connect_failed(connection, hs->pending_connect->msg, err); + err_connect_failed(device->conn, hs->pending_connect->msg, strerror(err)); if (hs->pending_connect->io) g_io_channel_close(hs->pending_connect->io); pending_connect_free(hs->pending_connect); @@ -518,7 +423,7 @@ failed: return FALSE; } -static int sco_connect(audio_device_t *device, struct pending_connect *c) +static int sco_connect(struct device *device, struct pending_connect *c) { struct headset *hs = device->headset; struct sockaddr_sco addr; @@ -583,7 +488,7 @@ static int sco_connect(audio_device_t *device, struct pending_connect *c) } static gboolean rfcomm_connect_cb(GIOChannel *chan, GIOCondition cond, - audio_device_t *device) + struct device *device) { struct headset *hs; char hs_address[18]; @@ -620,7 +525,7 @@ static gboolean rfcomm_connect_cb(GIOChannel *chan, GIOCondition cond, hs->pending_connect->io = NULL; hs->state = HEADSET_STATE_CONNECTED; - dbus_connection_emit_signal(connection, device->object_path, + dbus_connection_emit_signal(device->conn, device->path, AUDIO_HEADSET_INTERFACE, "Connected", DBUS_TYPE_INVALID); @@ -634,7 +539,7 @@ static gboolean rfcomm_connect_cb(GIOChannel *chan, GIOCondition cond, reply = dbus_message_new_method_return(hs->pending_connect->msg); if (reply) - send_message_and_unref(connection, reply); + send_message_and_unref(device->conn, reply); } pending_connect_free(hs->pending_connect); @@ -643,7 +548,7 @@ static gboolean rfcomm_connect_cb(GIOChannel *chan, GIOCondition cond, return FALSE; failed: - err_connect_failed(connection, hs->pending_connect->msg, err); + err_connect_failed(device->conn, hs->pending_connect->msg, strerror(err)); if (hs->pending_connect->io) g_io_channel_close(hs->pending_connect->io); pending_connect_free(hs->pending_connect); @@ -654,7 +559,7 @@ failed: return FALSE; } -static int rfcomm_connect(audio_device_t *device, int *err) +static int rfcomm_connect(struct device *device, int *err) { struct headset *hs = device->headset; struct sockaddr_rc addr; @@ -735,219 +640,6 @@ failed: return -1; } -static int create_hsp_ag_record(sdp_buf_t *buf, uint8_t ch) -{ - sdp_list_t *svclass_id, *pfseq, *apseq, *root; - uuid_t root_uuid, svclass_uuid, ga_svclass_uuid; - uuid_t l2cap_uuid, rfcomm_uuid; - sdp_profile_desc_t profile; - sdp_list_t *aproto, *proto[2]; - sdp_record_t record; - sdp_data_t *channel; - int ret; - - memset(&record, 0, sizeof(sdp_record_t)); - - sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP); - root = sdp_list_append(0, &root_uuid); - sdp_set_browse_groups(&record, root); - - sdp_uuid16_create(&svclass_uuid, HEADSET_AGW_SVCLASS_ID); - svclass_id = sdp_list_append(0, &svclass_uuid); - sdp_uuid16_create(&ga_svclass_uuid, GENERIC_AUDIO_SVCLASS_ID); - svclass_id = sdp_list_append(svclass_id, &ga_svclass_uuid); - sdp_set_service_classes(&record, svclass_id); - - sdp_uuid16_create(&profile.uuid, HEADSET_PROFILE_ID); - profile.version = 0x0100; - pfseq = sdp_list_append(0, &profile); - sdp_set_profile_descs(&record, pfseq); - - sdp_uuid16_create(&l2cap_uuid, L2CAP_UUID); - proto[0] = sdp_list_append(0, &l2cap_uuid); - apseq = sdp_list_append(0, proto[0]); - - sdp_uuid16_create(&rfcomm_uuid, RFCOMM_UUID); - proto[1] = sdp_list_append(0, &rfcomm_uuid); - channel = sdp_data_alloc(SDP_UINT8, &ch); - proto[1] = sdp_list_append(proto[1], channel); - apseq = sdp_list_append(apseq, proto[1]); - - aproto = sdp_list_append(0, apseq); - sdp_set_access_protos(&record, aproto); - - sdp_set_info_attr(&record, "Headset Audio Gateway", 0, 0); - - if (sdp_gen_record_pdu(&record, buf) < 0) - ret = -1; - else - ret = 0; - - sdp_data_free(channel); - sdp_list_free(proto[0], 0); - sdp_list_free(proto[1], 0); - sdp_list_free(apseq, 0); - sdp_list_free(pfseq, 0); - sdp_list_free(aproto, 0); - sdp_list_free(root, 0); - sdp_list_free(svclass_id, 0); - sdp_list_free(record.attrlist, (sdp_free_func_t) sdp_data_free); - sdp_list_free(record.pattern, free); - - return ret; -} - -static int create_hfp_ag_record(sdp_buf_t *buf, uint8_t ch) -{ - sdp_list_t *svclass_id, *pfseq, *apseq, *root; - uuid_t root_uuid, svclass_uuid, ga_svclass_uuid; - uuid_t l2cap_uuid, rfcomm_uuid; - sdp_profile_desc_t profile; - sdp_list_t *aproto, *proto[2]; - sdp_record_t record; - uint16_t u16 = 0x0009; - sdp_data_t *channel, *features; - uint8_t netid = 0x01; - sdp_data_t *network = sdp_data_alloc(SDP_UINT8, &netid); - int ret; - - memset(&record, 0, sizeof(sdp_record_t)); - - sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP); - root = sdp_list_append(0, &root_uuid); - sdp_set_browse_groups(&record, root); - - sdp_uuid16_create(&svclass_uuid, HANDSFREE_AGW_SVCLASS_ID); - svclass_id = sdp_list_append(0, &svclass_uuid); - sdp_uuid16_create(&ga_svclass_uuid, GENERIC_AUDIO_SVCLASS_ID); - svclass_id = sdp_list_append(svclass_id, &ga_svclass_uuid); - sdp_set_service_classes(&record, svclass_id); - - sdp_uuid16_create(&profile.uuid, HANDSFREE_PROFILE_ID); - profile.version = 0x0105; - pfseq = sdp_list_append(0, &profile); - sdp_set_profile_descs(&record, pfseq); - - sdp_uuid16_create(&l2cap_uuid, L2CAP_UUID); - proto[0] = sdp_list_append(0, &l2cap_uuid); - apseq = sdp_list_append(0, proto[0]); - - sdp_uuid16_create(&rfcomm_uuid, RFCOMM_UUID); - proto[1] = sdp_list_append(0, &rfcomm_uuid); - channel = sdp_data_alloc(SDP_UINT8, &ch); - proto[1] = sdp_list_append(proto[1], channel); - apseq = sdp_list_append(apseq, proto[1]); - - features = sdp_data_alloc(SDP_UINT16, &u16); - sdp_attr_add(&record, SDP_ATTR_SUPPORTED_FEATURES, features); - - aproto = sdp_list_append(0, apseq); - sdp_set_access_protos(&record, aproto); - - sdp_set_info_attr(&record, "Hands-Free Audio Gateway", 0, 0); - - sdp_attr_add(&record, SDP_ATTR_EXTERNAL_NETWORK, network); - - if (sdp_gen_record_pdu(&record, buf) < 0) - ret = -1; - else - ret = 0; - - sdp_data_free(channel); - sdp_list_free(proto[0], 0); - sdp_list_free(proto[1], 0); - sdp_list_free(apseq, 0); - sdp_list_free(pfseq, 0); - sdp_list_free(aproto, 0); - sdp_list_free(root, 0); - sdp_list_free(svclass_id, 0); - sdp_list_free(record.attrlist, (sdp_free_func_t) sdp_data_free); - sdp_list_free(record.pattern, free); - - return ret; -} - -static uint32_t headset_add_ag_record(uint8_t channel, sdp_buf_t *buf) -{ - DBusMessage *msg, *reply; - DBusError derr; - dbus_uint32_t rec_id; - - msg = dbus_message_new_method_call("org.bluez", "/org/bluez", - "org.bluez.Database", "AddServiceRecord"); - if (!msg) { - error("Can't allocate new method call"); - return 0; - } - - dbus_message_append_args(msg, DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, - &buf->data, buf->data_size, DBUS_TYPE_INVALID); - - dbus_error_init(&derr); - reply = dbus_connection_send_with_reply_and_block(connection, msg, - -1, &derr); - - dbus_message_unref(msg); - - if (dbus_error_is_set(&derr) || - dbus_set_error_from_message(&derr, reply)) { - error("Adding service record failed: %s", derr.message); - dbus_error_free(&derr); - return 0; - } - - dbus_message_get_args(reply, &derr, DBUS_TYPE_UINT32, &rec_id, - DBUS_TYPE_INVALID); - - if (dbus_error_is_set(&derr)) { - error("Invalid arguments to AddServiceRecord reply: %s", - derr.message); - dbus_message_unref(reply); - dbus_error_free(&derr); - return 0; - } - - dbus_message_unref(reply); - - debug("add_ag_record: got record id 0x%x", rec_id); - - return rec_id; -} - -int headset_remove_ag_record(uint32_t rec_id) -{ - DBusMessage *msg, *reply; - DBusError derr; - - msg = dbus_message_new_method_call("org.bluez", "/org/bluez", - "org.bluez.Database", - "RemoveServiceRecord"); - if (!msg) { - error("Can't allocate new method call"); - return 0; - } - - dbus_message_append_args(msg, DBUS_TYPE_UINT32, &rec_id, - DBUS_TYPE_INVALID); - - dbus_error_init(&derr); - reply = dbus_connection_send_with_reply_and_block(connection, msg, - -1, &derr); - - dbus_message_unref(msg); - - if (dbus_error_is_set(&derr)) { - error("Removing service record 0x%x failed: %s", - rec_id, derr.message); - dbus_error_free(&derr); - return 0; - } - - dbus_message_unref(reply); - - return 0; -} - static void get_record_reply(DBusPendingCall *call, void *data) { DBusMessage *reply; @@ -957,7 +649,7 @@ static void get_record_reply(DBusPendingCall *call, void *data) sdp_record_t *record = NULL; sdp_list_t *protos, *classes = NULL; uuid_t uuid; - audio_device_t *device = data; + struct device *device = data; struct headset *hs = device->headset; struct pending_connect *c; @@ -1036,8 +728,8 @@ static void get_record_reply(DBusPendingCall *call, void *data) if (rfcomm_connect(device, &err) < 0) { error("Unable to connect"); - if (c->msg) - err_connect_failed(connection, c->msg, err); + if (c->msg) + err_connect_failed(device->conn, c->msg, strerror(err)); goto failed; } @@ -1045,13 +737,13 @@ static void get_record_reply(DBusPendingCall *call, void *data) sdp_record_free(record); dbus_message_unref(reply); - finish_sdp_transaction(connection, &device->bda); + device_finish_sdp_transaction(device); return; failed_not_supported: - if (c->msg) - err_not_supported(connection, c->msg); + if (c->msg) + err_not_supported(device->conn, c->msg); failed: if (classes) sdp_list_free(classes, free); @@ -1062,18 +754,18 @@ failed: pending_connect_free(hs->pending_connect); hs->pending_connect = NULL; hs->state = HEADSET_STATE_DISCONNECTED; - finish_sdp_transaction(connection, &device->bda); + device_finish_sdp_transaction(device); } static DBusHandlerResult hs_stop(DBusConnection *conn, DBusMessage *msg, void *data) { - audio_device_t *device = data; + struct device *device = data; struct headset *hs = device->headset; DBusMessage *reply = NULL; if (!hs || !hs->sco) - return err_not_connected(connection, msg); + return err_not_connected(conn, msg); if (msg) { reply = dbus_message_new_method_return(msg); @@ -1085,8 +777,8 @@ static DBusHandlerResult hs_stop(DBusConnection *conn, DBusMessage *msg, hs->pending_connect) { g_io_channel_close(hs->pending_connect->io); if (hs->pending_connect->msg) - err_connect_failed(connection, hs->pending_connect->msg, - EINTR); + err_connect_failed(conn, hs->pending_connect->msg, + strerror(EINTR)); pending_connect_free(hs->pending_connect); hs->pending_connect = NULL; hs->state = HEADSET_STATE_CONNECTED; @@ -1095,7 +787,7 @@ static DBusHandlerResult hs_stop(DBusConnection *conn, DBusMessage *msg, close_sco(device); if (reply) - send_message_and_unref(connection, reply); + send_message_and_unref(conn, reply); return DBUS_HANDLER_RESULT_HANDLED; } @@ -1103,7 +795,7 @@ static DBusHandlerResult hs_stop(DBusConnection *conn, DBusMessage *msg, static DBusHandlerResult hs_is_playing(DBusConnection *conn, DBusMessage *msg, void *data) { - audio_device_t *device = data; + struct device *device = data; struct headset *hs = device->headset; DBusMessage *reply; dbus_bool_t playing; @@ -1122,7 +814,7 @@ static DBusHandlerResult hs_is_playing(DBusConnection *conn, DBusMessage *msg, dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &playing, DBUS_TYPE_INVALID); - send_message_and_unref(connection, reply); + send_message_and_unref(conn, reply); return DBUS_HANDLER_RESULT_HANDLED; } @@ -1130,7 +822,7 @@ static DBusHandlerResult hs_is_playing(DBusConnection *conn, DBusMessage *msg, static DBusHandlerResult hs_disconnect(DBusConnection *conn, DBusMessage *msg, void *data) { - audio_device_t *device = data; + struct device *device = data; struct headset *hs = device->headset; DBusMessage *reply = NULL; char hs_address[18]; @@ -1163,9 +855,9 @@ static DBusHandlerResult hs_disconnect(DBusConnection *conn, DBusMessage *msg, if (hs->pending_connect->io_id) g_source_remove(hs->pending_connect->io_id); if (hs->pending_connect->msg) - err_connect_failed(connection, + err_connect_failed(conn, hs->pending_connect->msg, - EINTR); + strerror(EINTR)); pending_connect_free(hs->pending_connect); hs->pending_connect = NULL; } @@ -1173,9 +865,9 @@ static DBusHandlerResult hs_disconnect(DBusConnection *conn, DBusMessage *msg, hs->state = HEADSET_STATE_DISCONNECTED; ba2str(&device->bda, hs_address); - info("Disconnected from %s, %s", hs_address, device->object_path); + info("Disconnected from %s, %s", hs_address, device->path); - dbus_connection_emit_signal(connection, device->object_path, + dbus_connection_emit_signal(device->conn, device->path, AUDIO_HEADSET_INTERFACE, "Disconnected", DBUS_TYPE_INVALID); @@ -1183,7 +875,7 @@ static DBusHandlerResult hs_disconnect(DBusConnection *conn, DBusMessage *msg, hs->data_length = 0; if (reply) - send_message_and_unref(connection, reply); + send_message_and_unref(conn, reply); return DBUS_HANDLER_RESULT_HANDLED; } @@ -1192,7 +884,7 @@ static DBusHandlerResult hs_is_connected(DBusConnection *conn, DBusMessage *msg, void *data) { - audio_device_t *device = data; + struct device *device = data; DBusMessage *reply; dbus_bool_t connected; @@ -1200,12 +892,12 @@ static DBusHandlerResult hs_is_connected(DBusConnection *conn, if (!reply) return DBUS_HANDLER_RESULT_NEED_MEMORY; - connected = headset_is_connected(device->headset); + connected = (device->headset->state >= HEADSET_STATE_CONNECTED); dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &connected, DBUS_TYPE_INVALID); - send_message_and_unref(connection, reply); + send_message_and_unref(conn, reply); return DBUS_HANDLER_RESULT_HANDLED; } @@ -1215,7 +907,7 @@ static void get_handles_reply(DBusPendingCall *call, void *data) DBusMessage *msg = NULL, *reply; DBusPendingCall *pending; DBusError derr; - audio_device_t *device = data; + struct device *device = data; struct headset *hs = device->headset; struct pending_connect *c; char address[18], *addr_ptr = address; @@ -1236,9 +928,10 @@ static void get_handles_reply(DBusPendingCall *call, void *data) if (c->msg) { if (dbus_error_has_name(&derr, "org.bluez.Error.ConnectionAttemptFailed")) - err_connect_failed(connection, c->msg, EHOSTDOWN); + err_connect_failed(device->conn, c->msg, + strerror(EHOSTDOWN)); else - err_not_supported(connection, c->msg); + err_not_supported(device->conn, c->msg); } dbus_error_free(&derr); goto failed; @@ -1248,37 +941,36 @@ static void get_handles_reply(DBusPendingCall *call, void *data) DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, &array, &array_len, DBUS_TYPE_INVALID)) { - error("Unable to get args from reply"); - if (c->msg) - err_not_supported(connection, c->msg); + if (c->msg) + err_not_supported(device->conn, c->msg); goto failed; } if (!array) { error("get_handles_reply: Unable to get handle array from reply"); if (c->msg) - err_not_supported(connection, c->msg); + err_not_supported(device->conn, c->msg); goto failed; } if (array_len < 1) { debug("No record handles found"); if (c->msg) - err_not_supported(connection, c->msg); + err_not_supported(device->conn, c->msg); goto failed; } if (array_len > 1) debug("Multiple records found. Using the first one."); - msg = dbus_message_new_method_call("org.bluez", "/org/bluez/hci0", + msg = dbus_message_new_method_call("org.bluez", device->adapter_path, "org.bluez.Adapter", "GetRemoteServiceRecord"); if (!msg) { error("Unable to allocate new method call"); - if (c->msg) - err_connect_failed(connection, c->msg, ENOMEM); + if (c->msg) + err_connect_failed(device->conn, c->msg, strerror(ENOMEM)); goto failed; } @@ -1290,10 +982,10 @@ static void get_handles_reply(DBusPendingCall *call, void *data) DBUS_TYPE_UINT32, &handle, DBUS_TYPE_INVALID); - if (!dbus_connection_send_with_reply(connection, msg, &pending, -1)) { + if (!dbus_connection_send_with_reply(device->conn, msg, &pending, -1)) { error("Sending GetRemoteServiceRecord failed"); if (c->msg) - err_connect_failed(connection, c->msg, EIO); + err_connect_failed(device->conn, c->msg, strerror(EIO)); goto failed; } @@ -1315,7 +1007,7 @@ static DBusHandlerResult hs_connect(DBusConnection *conn, DBusMessage *msg, void *data) { DBusPendingCall *pending; - audio_device_t *device = data; + struct device *device = data; struct headset *hs = device->headset; const char *hs_svc; const char *addr_ptr; @@ -1325,7 +1017,7 @@ static DBusHandlerResult hs_connect(DBusConnection *conn, DBusMessage *msg, assert(hs != NULL); if (hs->state > HEADSET_STATE_DISCONNECTED || hs->pending_connect) - return err_already_connected(connection, msg); + return err_already_connected(conn, msg); hs->pending_connect = g_try_new0(struct pending_connect, 1); if (!hs->pending_connect) { @@ -1345,12 +1037,12 @@ static DBusHandlerResult hs_connect(DBusConnection *conn, DBusMessage *msg, pending_connect_free(hs->pending_connect); hs->pending_connect = NULL; hs->state = HEADSET_STATE_DISCONNECTED; - return err_connect_failed(conn, msg, err); + return err_connect_failed(conn, msg, strerror(err)); } else return DBUS_HANDLER_RESULT_HANDLED; } - msg = dbus_message_new_method_call("org.bluez", "/org/bluez/hci0", + msg = dbus_message_new_method_call("org.bluez", device->adapter_path, "org.bluez.Adapter", "GetRemoteServiceHandles"); if (!msg) { @@ -1372,13 +1064,13 @@ static DBusHandlerResult hs_connect(DBusConnection *conn, DBusMessage *msg, DBUS_TYPE_STRING, &hs_svc, DBUS_TYPE_INVALID); - if (!dbus_connection_send_with_reply(connection, msg, &pending, -1)) { + if (!dbus_connection_send_with_reply(conn, msg, &pending, -1)) { error("Sending GetRemoteServiceHandles failed"); pending_connect_free(hs->pending_connect); hs->pending_connect = NULL; hs->state = HEADSET_STATE_DISCONNECTED; dbus_message_unref(msg); - return err_connect_failed(connection, msg, EIO); + return err_connect_failed(conn, msg, strerror(EIO)); } dbus_pending_call_set_notify(pending, get_handles_reply, device, NULL); @@ -1390,7 +1082,7 @@ static DBusHandlerResult hs_connect(DBusConnection *conn, DBusMessage *msg, static gboolean ring_timer_cb(gpointer data) { - audio_device_t *device = data; + struct device *device = data; assert(device != NULL); @@ -1403,14 +1095,14 @@ static gboolean ring_timer_cb(gpointer data) static DBusHandlerResult hs_ring(DBusConnection *conn, DBusMessage *msg, void *data) { - audio_device_t *device = data; + struct device *device = data; struct headset *hs = device->headset; DBusMessage *reply = NULL; assert(hs != NULL); if (hs->state < HEADSET_STATE_CONNECTED) - return err_not_connected(connection, msg); + return err_not_connected(conn, msg); if (msg) { reply = dbus_message_new_method_return(msg); @@ -1425,14 +1117,14 @@ static DBusHandlerResult hs_ring(DBusConnection *conn, DBusMessage *msg, if (headset_send(device->headset, "\r\nRING\r\n") != G_IO_ERROR_NONE) { dbus_message_unref(reply); - return err_failed(connection, msg, "Failed"); + return err_failed(conn, msg, "Failed"); } hs->ring_timer = g_timeout_add(RING_INTERVAL, ring_timer_cb, device); done: if (reply) - send_message_and_unref(connection, reply); + send_message_and_unref(conn, reply); return DBUS_HANDLER_RESULT_HANDLED; } @@ -1441,12 +1133,12 @@ static DBusHandlerResult hs_cancel_ringing(DBusConnection *conn, DBusMessage *msg, void *data) { - audio_device_t *device = data; + struct device *device = data; struct headset *hs = device->headset; DBusMessage *reply = NULL; if (hs->state < HEADSET_STATE_CONNECTED) - return err_not_connected(connection, msg); + return err_not_connected(conn, msg); if (msg) { reply = dbus_message_new_method_return(msg); @@ -1464,7 +1156,7 @@ static DBusHandlerResult hs_cancel_ringing(DBusConnection *conn, done: if (reply) - send_message_and_unref(connection, reply); + send_message_and_unref(conn, reply); return DBUS_HANDLER_RESULT_HANDLED; } @@ -1472,18 +1164,18 @@ done: static DBusHandlerResult hs_play(DBusConnection *conn, DBusMessage *msg, void *data) { - audio_device_t *device = data; + struct device *device = data; struct headset *hs = device->headset; struct pending_connect *c; if (hs->state < HEADSET_STATE_CONNECTED) - return err_not_connected(connection, msg); + return err_not_connected(conn, msg); if (hs->state >= HEADSET_STATE_PLAY_IN_PROGRESS || hs->pending_connect) - return err_already_connected(connection, msg); + return err_already_connected(conn, msg); if (hs->sco) - return err_already_connected(connection, msg); + return err_already_connected(conn, msg); c = g_try_new0(struct pending_connect, 1); if (!c) @@ -1506,7 +1198,7 @@ static DBusHandlerResult hs_get_speaker_gain(DBusConnection *conn, DBusMessage *msg, void *data) { - audio_device_t *device = data; + struct device *device = data; struct headset *hs = device->headset; DBusMessage *reply; dbus_uint16_t gain; @@ -1525,7 +1217,7 @@ static DBusHandlerResult hs_get_speaker_gain(DBusConnection *conn, dbus_message_append_args(reply, DBUS_TYPE_UINT16, &gain, DBUS_TYPE_INVALID); - send_message_and_unref(connection, reply); + send_message_and_unref(conn, reply); return DBUS_HANDLER_RESULT_HANDLED; } @@ -1534,7 +1226,7 @@ static DBusHandlerResult hs_get_mic_gain(DBusConnection *conn, DBusMessage *msg, void *data) { - audio_device_t *device = data; + struct device *device = data; struct headset *hs = device->headset; DBusMessage *reply; dbus_uint16_t gain; @@ -1553,7 +1245,7 @@ static DBusHandlerResult hs_get_mic_gain(DBusConnection *conn, dbus_message_append_args(reply, DBUS_TYPE_UINT16, &gain, DBUS_TYPE_INVALID); - send_message_and_unref(connection, reply); + send_message_and_unref(conn, reply); return DBUS_HANDLER_RESULT_HANDLED; } @@ -1562,7 +1254,7 @@ static DBusHandlerResult hs_set_gain(DBusConnection *conn, DBusMessage *msg, void *data, char type) { - audio_device_t *device = data; + struct device *device = data; struct headset *hs = device->headset; DBusMessage *reply; DBusError derr; @@ -1605,7 +1297,7 @@ static DBusHandlerResult hs_set_gain(DBusConnection *conn, done: if (type == HEADSET_GAIN_SPEAKER) { hs->sp_gain = gain; - dbus_connection_emit_signal(conn, device->object_path, + dbus_connection_emit_signal(conn, device->path, AUDIO_HEADSET_INTERFACE, "SpeakerGainChanged", DBUS_TYPE_UINT16, &gain, @@ -1613,7 +1305,7 @@ done: } else { hs->mic_gain = gain; - dbus_connection_emit_signal(conn, device->object_path, + dbus_connection_emit_signal(conn, device->path, AUDIO_HEADSET_INTERFACE, "MicrophoneGainChanged", DBUS_TYPE_UINT16, &gain, @@ -1666,7 +1358,7 @@ static DBusSignalVTable headset_signals[] = { { NULL, NULL } }; -static void headset_set_channel(headset_t *headset, sdp_record_t *record) +static void headset_set_channel(struct headset *headset, sdp_record_t *record) { int ch; sdp_list_t *protos; @@ -1688,16 +1380,12 @@ static void headset_set_channel(headset_t *headset, sdp_record_t *record) error("Unable to get RFCOMM channel from Headset record"); } -void headset_update(headset_t *headset, sdp_record_t *record, uint16_t svc) +void headset_update(void *device, sdp_record_t *record, uint16_t svc) { + struct headset *headset = ((struct device *) device)->headset; + switch (svc) { case HANDSFREE_SVCLASS_ID: - if (disable_hfp) { - debug("Ignoring Handsfree record since HFP support" - " has been disabled"); - return; - } - if (headset->hfp_handle && (headset->hfp_handle != record->handle)) { error("More than one HFP record found on device"); @@ -1730,12 +1418,12 @@ void headset_update(headset_t *headset, sdp_record_t *record, uint16_t svc) headset_set_channel(headset, record); } -headset_t *headset_init(const char *object_path, sdp_record_t *record, +struct headset *headset_init(void *device, sdp_record_t *record, uint16_t svc) { - headset_t *headset; + struct headset *headset; - headset = g_new0(headset_t, 1); + headset = g_new0(struct headset, 1); headset->rfcomm_ch = -1; headset->sp_gain = -1; headset->mic_gain = -1; @@ -1745,13 +1433,6 @@ headset_t *headset_init(const char *object_path, sdp_record_t *record, switch (svc) { case HANDSFREE_SVCLASS_ID: - if (disable_hfp) { - debug("Ignoring Handsfree record since HFP support" - " has been disabled"); - g_free(headset); - return NULL; - } - headset->hfp_handle = record->handle; break; @@ -1766,7 +1447,8 @@ headset_t *headset_init(const char *object_path, sdp_record_t *record, } register_iface: - if (!dbus_connection_register_interface(connection, object_path, + if (!dbus_connection_register_interface(((struct device *) device)->conn, + ((struct device *) device)->path, AUDIO_HEADSET_INTERFACE, headset_methods, headset_signals, NULL)) { @@ -1780,279 +1462,120 @@ register_iface: return headset; } -void headset_free(const char *object_path) +void headset_free(void *device) { - audio_device_t *device; + struct headset *headset = ((struct device *) device)->headset; - if (!dbus_connection_get_object_user_data(connection, object_path, - (void *) &device)) - return; - - if (device->headset->state != HEADSET_STATE_DISCONNECTED) + if (headset->state != HEADSET_STATE_DISCONNECTED) hs_disconnect(NULL, NULL, device); - g_free(device->headset); - device->headset = NULL; + g_free(headset); + headset = NULL; } -static gboolean headset_server_io_cb(GIOChannel *chan, GIOCondition cond, - void *data) +int headset_get_config(void *device, int sock, struct ipc_packet *pkt) { - int srv_sk, cli_sk; - struct sockaddr_rc addr; - socklen_t size; - char hs_address[18], *address = hs_address; - const char *uuid; - audio_device_t *device; - struct headset *hs; - DBusMessage *auth; - DBusPendingCall *pending; - - if (cond & G_IO_NVAL) - return FALSE; - - if (cond & (G_IO_HUP | G_IO_ERR)) { - error("Hangup or error on rfcomm server socket"); - g_io_channel_close(chan); - raise(SIGTERM); - return FALSE; - } - - srv_sk = g_io_channel_unix_get_fd(chan); - - size = sizeof(struct sockaddr_rc); - cli_sk = accept(srv_sk, (struct sockaddr *) &addr, &size); - if (cli_sk < 0) { - error("accept: %s (%d)", strerror(errno), errno); - return TRUE; - } - - device = manager_headset_connected(&addr.rc_bdaddr); - if (!device) { - close(cli_sk); - return TRUE; - } - - hs = device->headset; - - if (hs->state > HEADSET_STATE_DISCONNECTED || hs->rfcomm) { - debug("Refusing new connection since one already exists"); - close(cli_sk); - return TRUE; - } - - hs->rfcomm = g_io_channel_unix_new(cli_sk); - if (!hs->rfcomm) { - error("Allocating new GIOChannel failed!"); - close(cli_sk); - return TRUE; - } - - if (chan == hs_server) { - hs->type = SVC_HEADSET; - uuid = HSP_AG_UUID; - } else { - hs->type = SVC_HANDSFREE; - uuid = HFP_AG_UUID; - } - - auth = dbus_message_new_method_call("org.bluez", "/org/bluez", - "org.bluez.Database", - "RequestAuthorization"); - if (!auth) { - error("Unable to allocate RequestAuthorization method call"); - goto failed; - } - - ba2str(&device->bda, hs_address); - - dbus_message_append_args(auth, DBUS_TYPE_STRING, &address, - DBUS_TYPE_STRING, &uuid, DBUS_TYPE_INVALID); + struct headset *headset = ((struct device *) device)->headset; + struct ipc_data_cfg *cfg = (struct ipc_data_cfg *) pkt->data; + int err = EINVAL; + struct pending_connect *c; - if (!dbus_connection_send_with_reply(connection, auth, &pending, -1)) { - error("Sending of authorization request failed"); - goto failed; + if (headset->sco == NULL) { + c = g_try_new0(struct pending_connect, 1); + if (c == NULL) + goto error; + c->sock = sock; + c->pkt = pkt; + if ((err = sco_connect(device, c)) < 0) + goto error; + return 0; } - dbus_pending_call_set_notify(pending, auth_callback, device, NULL); - dbus_pending_call_unref(pending); - dbus_message_unref(auth); - - return TRUE; - -failed: - if (hs->rfcomm) { - g_io_channel_close(hs->rfcomm); - g_io_channel_unref(hs->rfcomm); - hs->rfcomm = NULL; - } + cfg->fd = g_io_channel_unix_get_fd(headset->sco); + cfg->fd_opt = CFG_FD_OPT_READWRITE; + cfg->encoding = 0; + cfg->bitpool = 0; + cfg->channels = 1; + cfg->pkt_len = 48; + cfg->sample_size = 2; + cfg->rate = 8000; - return TRUE; + return 0; +error: + cfg->fd = -1; + return -err; } -static GIOChannel *server_socket(uint8_t *channel) +headset_type_t headset_get_type(void *device) { - int sock, lm; - struct sockaddr_rc addr; - socklen_t sa_len; - GIOChannel *io; - - sock = socket(AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM); - if (sock < 0) { - error("server socket: %s (%d)", strerror(errno), errno); - return NULL; - } + struct headset *headset = ((struct device *) device)->headset; - lm = RFCOMM_LM_SECURE; - if (setsockopt(sock, SOL_RFCOMM, RFCOMM_LM, &lm, sizeof(lm)) < 0) { - error("server setsockopt: %s (%d)", strerror(errno), errno); - close(sock); - return NULL; - } - - memset(&addr, 0, sizeof(addr)); - addr.rc_family = AF_BLUETOOTH; - bacpy(&addr.rc_bdaddr, BDADDR_ANY); - addr.rc_channel = channel ? *channel : 0; - - if (bind(sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) { - error("server bind: %s", strerror(errno), errno); - close(sock); - return NULL; - } - - if (listen(sock, 1) < 0) { - error("server listen: %s", strerror(errno), errno); - close(sock); - return NULL; - } - - sa_len = sizeof(struct sockaddr_rc); - getsockname(sock, (struct sockaddr *) &addr, &sa_len); - *channel = addr.rc_channel; - - io = g_io_channel_unix_new(sock); - if (!io) { - error("Unable to allocate new io channel"); - close(sock); - return NULL; - } - - return io; + return headset->type; } -gboolean headset_is_connected(headset_t *headset) +void headset_set_type(void *device, headset_type_t type) { - if (headset->state >= HEADSET_STATE_CONNECTED) - return TRUE; - else - return FALSE; + struct headset *headset = ((struct device *) device)->headset; + + headset->type = type; } -int headset_server_init(DBusConnection *conn, gboolean no_hfp, - gboolean sco_hci) +int headset_connect_rfcomm(void *device, int sock) { - uint8_t chan = DEFAULT_HS_AG_CHANNEL; - sdp_buf_t buf; - - connection = dbus_connection_ref(conn); + struct headset *headset = ((struct device *) device)->headset; - hs_server = server_socket(&chan); - if (!hs_server) - return -1; - - if (create_hsp_ag_record(&buf, chan) < 0) { - error("Unable to allocate new service record"); - return -1; - } - - hs_record_id = headset_add_ag_record(chan, &buf); - free(buf.data); - if (!hs_record_id) { - error("Unable to register HS AG service record"); - g_io_channel_unref(hs_server); - hs_server = NULL; - return -1; - } - - g_io_add_watch(hs_server, G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL, - (GIOFunc) headset_server_io_cb, NULL); - - disable_hfp = no_hfp; - - sco_over_hci = sco_hci; - - if (disable_hfp) - return 0; + headset->rfcomm = g_io_channel_unix_new(sock); - chan = DEFAULT_HF_AG_CHANNEL; - - hf_server = server_socket(&chan); - if (!hf_server) - return -1; - - if (create_hfp_ag_record(&buf, chan) < 0) { - error("Unable to allocate new service record"); - return -1; - } + return headset->rfcomm ? 0 : -EINVAL; +} - hf_record_id = headset_add_ag_record(chan, &buf); - free(buf.data); - if (!hf_record_id) { - error("Unable to register HS AG service record"); - g_io_channel_unref(hf_server); - hs_server = NULL; - return -1; - } +int headset_close_rfcomm(void *device) +{ + struct headset *headset = ((struct device *) device)->headset; - g_io_add_watch(hf_server, G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL, - (GIOFunc) headset_server_io_cb, NULL); + g_io_channel_close(headset->rfcomm); + g_io_channel_unref(headset->rfcomm); + headset->rfcomm = NULL; return 0; } -void headset_exit(void) +void headset_set_state(void *device, headset_state_t state) { - if (hs_record_id) { - headset_remove_ag_record(hs_record_id); - hs_record_id = 0; - } + struct headset *headset = ((struct device *) device)->headset; - if (hs_server) { - g_io_channel_unref(hs_server); - hs_server = NULL; - } + switch(state) { + case HEADSET_STATE_DISCONNECTED: + case HEADSET_STATE_CONNECT_IN_PROGRESS: + break; + case HEADSET_STATE_CONNECTED: + if (headset->rfcomm) { + char hs_address[18]; - if (hf_record_id) { - headset_remove_ag_record(hf_record_id); - hf_record_id = 0; - } + g_io_add_watch(headset->rfcomm, + G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL, + (GIOFunc) rfcomm_io_cb, device); - if (hf_server) { - g_io_channel_unref(hf_server); - hf_server = NULL; + ba2str(&((struct device *) device)->bda, hs_address); + + dbus_connection_emit_signal(((struct device *) device)->conn, + ((struct device *) device)->path, + AUDIO_HEADSET_INTERFACE, + "Connected", + DBUS_TYPE_INVALID); + } + break; + case HEADSET_STATE_PLAY_IN_PROGRESS: + case HEADSET_STATE_PLAYING: + break; } - dbus_connection_unref(connection); - connection = NULL; + headset->state = state; } -int headset_get_config(headset_t *headset, int sock, struct ipc_data_cfg *cfg) +headset_state_t headset_get_state(void *device) { - if (!sco_over_hci) - return -1; + struct headset *headset = ((struct device *) device)->headset; - if (headset->sco == NULL) - return -1; - - cfg->fd = g_io_channel_unix_get_fd(headset->sco); - cfg->fd_opt = CFG_FD_OPT_READWRITE; - cfg->encoding = 0; - cfg->bitpool = 0; - cfg->channels = 1; - cfg->pkt_len = 48; - cfg->sample_size = 2; - cfg->rate = 8000; - - return 0; + return headset->state; } diff --git a/audio/headset.h b/audio/headset.h index b420860e..470fddc8 100644 --- a/audio/headset.h +++ b/audio/headset.h @@ -20,10 +20,6 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ -#ifndef __AUDIO_HEADSET_H -#define __AUDIO_HEADSET_H - -#include #include #include @@ -33,22 +29,45 @@ #define AUDIO_HEADSET_INTERFACE "org.bluez.audio.Headset" -typedef struct headset headset_t; +#define DEFAULT_HS_AG_CHANNEL 12 +#define DEFAULT_HF_AG_CHANNEL 13 -headset_t *headset_init(const char *object_path, sdp_record_t *record, - uint16_t svc); +typedef enum { + HEADSET_EVENT_KEYPRESS, + HEADSET_EVENT_GAIN, + HEADSET_EVENT_UNKNOWN, + HEADSET_EVENT_INVALID +} headset_event_t; + +typedef enum { + HEADSET_STATE_DISCONNECTED = 0, + HEADSET_STATE_CONNECT_IN_PROGRESS, + HEADSET_STATE_CONNECTED, + HEADSET_STATE_PLAY_IN_PROGRESS, + HEADSET_STATE_PLAYING, +} headset_state_t; -void headset_free(const char *object_path); +typedef enum { + SVC_HEADSET, + SVC_HANDSFREE +} headset_type_t; + +struct headset; + +struct headset *headset_init(void *device, sdp_record_t *record, + uint16_t svc); -void headset_update(headset_t *headset, sdp_record_t *record, uint16_t svc); +void headset_free(void *device); -gboolean headset_is_connected(headset_t *headset); +void headset_update(void *device, sdp_record_t *record, uint16_t svc); -int headset_server_init(DBusConnection *conn, gboolean disable_hfp, - gboolean sco_hci); +int headset_get_config(void *device, int sock, struct ipc_packet *pkt); -void headset_exit(void); +headset_type_t headset_get_type(void *device); +void headset_set_type(void *device, headset_type_t type); -int headset_get_config(headset_t *headset, int sock, struct ipc_data_cfg *cfg); +int headset_connect_rfcomm(void *device, int sock); +int headset_close_rfcomm(void *device); -#endif /* __AUDIO_HEADSET_H_ */ +headset_state_t headset_get_state(void *device); +void headset_set_state(void *device, headset_state_t state); diff --git a/audio/main.c b/audio/main.c index 0ca8ce87..4a32a320 100644 --- a/audio/main.c +++ b/audio/main.c @@ -40,7 +40,7 @@ /* Configuration settings */ static gboolean disable_hfp = TRUE; -static gboolean sco_hci = FALSE; +static gboolean sco_hci = TRUE; static GMainLoop *main_loop = NULL; @@ -137,7 +137,7 @@ int main(int argc, char *argv[]) exit(1); } - if (headset_server_init(conn, disable_hfp, sco_hci) < 0) { + if (gateway_init(conn, disable_hfp, sco_hci) < 0) { error("Headset initialization failed!"); exit(1); } @@ -149,7 +149,7 @@ int main(int argc, char *argv[]) audio_exit(); - headset_exit(); + gateway_exit(); unix_exit(); diff --git a/audio/manager.c b/audio/manager.c index 7faa0490..d8872968 100644 --- a/audio/manager.c +++ b/audio/manager.c @@ -42,12 +42,11 @@ #include -#include "dbus.h" #include "dbus-helper.h" #include "logging.h" -#include "headset.h" #include "manager.h" +#include "error.h" typedef enum { HEADSET = 1 << 0, @@ -67,7 +66,7 @@ typedef enum { } audio_sdp_state_t; struct audio_sdp_data { - audio_device_t *device; + struct device *device; DBusMessage *msg; /* Method call or NULL */ @@ -79,7 +78,7 @@ struct audio_sdp_data { static DBusConnection *connection = NULL; -static audio_device_t *default_dev = NULL; +static struct device *default_dev = NULL; static GSList *devices = NULL; @@ -87,80 +86,12 @@ static void get_next_record(struct audio_sdp_data *data); static DBusHandlerResult get_handles(const char *uuid, struct audio_sdp_data *data); -/* FIXME: Remove these once global error functions exist */ -static DBusHandlerResult error_reply(DBusConnection *conn, DBusMessage *msg, - const char *name, const char *descr) -{ - DBusMessage *derr; - - if (!conn || !msg) - return DBUS_HANDLER_RESULT_HANDLED; - - derr = dbus_message_new_error(msg, name, descr); - if (!derr) { - error("Unable to allocate new error return"); - return DBUS_HANDLER_RESULT_NEED_MEMORY; - } - - return send_message_and_unref(conn, derr); -} - -DBusHandlerResult err_invalid_args(DBusConnection *conn, DBusMessage *msg, - const char *descr) -{ - return error_reply(conn, msg, "org.bluez.audio.Error.InvalidArguments", - descr ? descr : "Invalid arguments in method call"); -} - -DBusHandlerResult err_already_connected(DBusConnection *conn, DBusMessage *msg) -{ - return error_reply(conn, msg, "org.bluez.audio.Error.AlreadyConnected", - "Already connected to a device"); -} - -DBusHandlerResult err_not_connected(DBusConnection *conn, DBusMessage *msg) -{ - return error_reply(conn, msg, "org.bluez.audio.Error.NotConnected", - "Not connected to any device"); -} - -DBusHandlerResult err_not_supported(DBusConnection *conn, DBusMessage *msg) -{ - return error_reply(conn, msg, "org.bluez.audio.Error.NotSupported", - "The service is not supported by the remote device"); -} - -DBusHandlerResult err_connect_failed(DBusConnection *conn, - DBusMessage *msg, int err) -{ - return error_reply(conn, msg, "org.bluez.audio.Error.ConnectFailed", - strerror(err)); -} - -DBusHandlerResult err_does_not_exist(DBusConnection *conn, DBusMessage *msg) -{ - return error_reply(conn, msg, "org.bluez.audio.Error.DoesNotExist", - "Does not exist"); -} - -DBusHandlerResult err_not_available(DBusConnection *conn, DBusMessage *msg) -{ - return error_reply(conn, msg, "org.bluez.audio.Error.NotAvailable", - "Not available"); -} - -DBusHandlerResult err_failed(DBusConnection *conn, DBusMessage *msg, - const char *dsc) -{ - return error_reply(conn, msg, "org.bluez.audio.Error.Failed", dsc); -} - -static audio_device_t *find_device(bdaddr_t *bda) +static struct device *find_device(bdaddr_t *bda) { GSList *l; for (l = devices; l != NULL; l = l->next) { - audio_device_t *device = l->data; + struct device *device = l->data; if (bacmp(&device->bda, bda) == 0) return device; } @@ -168,113 +99,25 @@ static audio_device_t *find_device(bdaddr_t *bda) return NULL; } -static DBusHandlerResult device_get_address(DBusConnection *conn, - DBusMessage *msg, - void *data) -{ - audio_device_t *device = data; - DBusMessage *reply; - char address[18], *ptr = address; - - reply = dbus_message_new_method_return(msg); - if (!reply) - return DBUS_HANDLER_RESULT_NEED_MEMORY; - - ba2str(&device->bda, address); - - dbus_message_append_args(reply, DBUS_TYPE_STRING, &ptr, - DBUS_TYPE_INVALID); - - return send_message_and_unref(conn, reply); -} - -static DBusHandlerResult device_get_connected(DBusConnection *conn, - DBusMessage *msg, - void *data) -{ - DBusMessageIter iter, array_iter; - audio_device_t *device = data; - DBusMessage *reply; - const char *iface; - - reply = dbus_message_new_method_return(msg); - if (!reply) - return DBUS_HANDLER_RESULT_NEED_MEMORY; - - dbus_message_iter_init_append(reply, &iter); - - dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, - DBUS_TYPE_STRING_AS_STRING, &array_iter); - - if (device->headset && headset_is_connected(device->headset)) { - iface = AUDIO_HEADSET_INTERFACE; - dbus_message_iter_append_basic(&array_iter, - DBUS_TYPE_STRING, &iface); - } - - dbus_message_iter_close_container(&iter, &array_iter); - - return send_message_and_unref(conn, reply); -} - -static DBusMethodVTable device_methods[] = { - { "GetAddress", device_get_address, - "", "s" }, - { "GetConnectedInterfaces", device_get_connected, - "", "s" }, - { NULL, NULL, NULL, NULL } -}; - -static void free_device(audio_device_t *device) -{ - g_free(device); -} - -static audio_device_t *create_device(bdaddr_t *bda) +static struct device *create_device(bdaddr_t *bda) { static int device_id = 0; - audio_device_t *device; - - device = g_new0(audio_device_t, 1); + char path[128]; - bacpy(&device->bda, bda); - - snprintf(device->object_path, sizeof(device->object_path) - 1, + snprintf(path, sizeof(path) - 1, "%s/device%d", AUDIO_MANAGER_PATH, device_id++); - return device; + return device_register(connection, path, bda); } -static void remove_device(audio_device_t *device) +static void remove_device(struct device *device) { devices = g_slist_remove(devices, device); - if (device->headset) - headset_free(device->object_path); - dbus_connection_destroy_object_path(connection, device->object_path); - g_free(device); + dbus_connection_destroy_object_path(connection, device->path); } - -static gboolean add_device(audio_device_t *device) +static gboolean add_device(struct device *device) { - if (!dbus_connection_create_object_path(connection, - device->object_path, - device, NULL)) { - error("D-Bus failed to register %s path", device->object_path); - return FALSE; - } - - if (!dbus_connection_register_interface(connection, - device->object_path, - AUDIO_DEVICE_INTERFACE, - device_methods, NULL, NULL)) { - error("Failed to register %s interface to %s", - AUDIO_DEVICE_INTERFACE, device->object_path); - dbus_connection_destroy_object_path(connection, - device->object_path); - return FALSE; - } - /* First device became default */ if (g_slist_length(devices) == 0) default_dev = device; @@ -296,7 +139,7 @@ static uint16_t get_service_uuid(const sdp_record_t *record) } memcpy(&uuid, classes->data, sizeof(uuid)); - + if (!sdp_uuid128_to_uuid(&uuid)) { error("Not a 16 bit UUID"); sdp_list_free(classes, free); @@ -304,7 +147,7 @@ static uint16_t get_service_uuid(const sdp_record_t *record) } if (uuid.type == SDP_UUID32) { - if (uuid.value.uuid32 > 0xFFFF) { + if (uuid.value.uuid32 > 0xFFFF) { error("Not a 16 bit UUID"); goto done; } @@ -318,43 +161,7 @@ done: return uuid16; } -void finish_sdp_transaction(DBusConnection *conn, bdaddr_t *dba) -{ - char address[18], *addr_ptr = address; - DBusMessage *msg, *reply; - DBusError derr; - - ba2str(dba, address); - - msg = dbus_message_new_method_call("org.bluez", "/org/bluez/hci0", - "org.bluez.Adapter", - "FinishRemoteServiceTransaction"); - if (!msg) { - error("Unable to allocate new method call"); - return; - } - - dbus_message_append_args(msg, DBUS_TYPE_STRING, &addr_ptr, - DBUS_TYPE_INVALID); - - dbus_error_init(&derr); - reply = dbus_connection_send_with_reply_and_block(conn, msg, -1, - &derr); - - dbus_message_unref(msg); - - if (dbus_error_is_set(&derr) || - dbus_set_error_from_message(&derr, reply)) { - error("FinishRemoteServiceTransaction(%s) failed: %s", - address, derr.message); - dbus_error_free(&derr); - return; - } - - dbus_message_unref(reply); -} - -static void handle_record(sdp_record_t *record, audio_device_t *device) +static void handle_record(sdp_record_t *record, struct device *device) { uint16_t uuid16; @@ -364,9 +171,9 @@ static void handle_record(sdp_record_t *record, audio_device_t *device) case HEADSET_SVCLASS_ID: debug("Found Headset record"); if (device->headset) - headset_update(device->headset, record, uuid16); + headset_update(device, record, uuid16); else - device->headset = headset_init(device->object_path, + device->headset = headset_init(device, record, uuid16); break; case HEADSET_AGW_SVCLASS_ID: @@ -375,9 +182,9 @@ static void handle_record(sdp_record_t *record, audio_device_t *device) case HANDSFREE_SVCLASS_ID: debug("Found Hansfree record"); if (device->headset) - headset_update(device->headset, record, uuid16); + headset_update(device, record, uuid16); else - device->headset = headset_init(device->object_path, + device->headset = headset_init(device, record, uuid16); break; case HANDSFREE_AGW_SVCLASS_ID: @@ -434,8 +241,8 @@ static gint record_iface_cmp(gconstpointer a, gconstpointer b) static void finish_sdp(struct audio_sdp_data *data, gboolean success) { - const char *path, *addr; - char **required; + const char *addr; + char **required = NULL; int required_len, i; DBusMessage *reply = NULL; DBusError derr; @@ -443,7 +250,7 @@ static void finish_sdp(struct audio_sdp_data *data, gboolean success) debug("Audio service discovery completed with %s", success ? "success" : "failure"); - finish_sdp_transaction(connection, &data->device->bda); + device_finish_sdp_transaction(data->device); if (!success) goto done; @@ -508,14 +315,9 @@ static void finish_sdp(struct audio_sdp_data *data, gboolean success) debug("Required interface %s not supported", iface); success = FALSE; err_not_supported(connection, data->msg); - dbus_free_string_array(required); goto done; } - dbus_free_string_array(required); - - path = data->device->object_path; - reply = dbus_message_new_method_return(data->msg); if (!reply) { success = FALSE; @@ -532,24 +334,27 @@ update: dbus_connection_emit_signal(connection, AUDIO_MANAGER_PATH, AUDIO_MANAGER_INTERFACE, "DeviceCreated", - DBUS_TYPE_STRING, &path, + DBUS_TYPE_STRING, + &data->device->path, DBUS_TYPE_INVALID); if (data->device->headset) - dbus_connection_emit_signal(connection, AUDIO_MANAGER_PATH, + dbus_connection_emit_signal(connection, + AUDIO_MANAGER_PATH, AUDIO_MANAGER_INTERFACE, "HeadsetCreated", - DBUS_TYPE_STRING, &path, + DBUS_TYPE_STRING, + &data->device->path, DBUS_TYPE_INVALID); - dbus_message_append_args(reply, DBUS_TYPE_STRING, &path, - DBUS_TYPE_INVALID); + dbus_message_append_args(reply, DBUS_TYPE_STRING, + &data->device->path, + DBUS_TYPE_INVALID); send_message_and_unref(connection, reply); } done: - if (required) - dbus_free_string_array(required); + dbus_free_string_array(required); if (!success) - free_device(data->device); + remove_device(data->device); if (data->msg) dbus_message_unref(data->msg); g_slist_foreach(data->handles, (GFunc) g_free, NULL); @@ -575,7 +380,8 @@ static void get_record_reply(DBusPendingCall *call, error("GetRemoteServiceRecord failed: %s", derr.message); if (dbus_error_has_name(&derr, "org.bluez.Error.ConnectionAttemptFailed")) - err_connect_failed(connection, data->msg, EHOSTDOWN); + err_connect_failed(connection, data->msg, + strerror(EHOSTDOWN)); else err_failed(connection, data->msg, derr.message); dbus_error_free(&derr); @@ -625,12 +431,13 @@ static void get_next_record(struct audio_sdp_data *data) char address[18], *ptr = address; dbus_uint32_t *handle; - msg = dbus_message_new_method_call("org.bluez", "/org/bluez/hci0", + msg = dbus_message_new_method_call("org.bluez", + data->device->adapter_path, "org.bluez.Adapter", "GetRemoteServiceRecord"); if (!msg) { error("Unable to allocate new method call"); - err_connect_failed(connection, data->msg, ENOMEM); + err_connect_failed(connection, data->msg, strerror(ENOMEM)); finish_sdp(data, FALSE); return; } @@ -649,7 +456,7 @@ static void get_next_record(struct audio_sdp_data *data) if (!dbus_connection_send_with_reply(connection, msg, &pending, -1)) { error("Sending GetRemoteServiceRecord failed"); - err_connect_failed(connection, data->msg, EIO); + err_connect_failed(connection, data->msg, strerror(EIO)); finish_sdp(data, FALSE); return; } @@ -687,7 +494,7 @@ static void get_handles_reply(DBusPendingCall *call, error("GetRemoteServiceHandles failed: %s", derr.message); if (dbus_error_has_name(&derr, "org.bluez.Error.ConnectionAttemptFailed")) - err_connect_failed(connection, data->msg, EHOSTDOWN); + err_connect_failed(connection, data->msg, strerror(EHOSTDOWN)); else err_failed(connection, data->msg, derr.message); dbus_error_free(&derr); @@ -744,7 +551,8 @@ static DBusHandlerResult get_handles(const char *uuid, const char *ptr = address; DBusMessage *msg; - msg = dbus_message_new_method_call("org.bluez", "/org/bluez/hci0", + msg = dbus_message_new_method_call("org.bluez", + data->device->adapter_path, "org.bluez.Adapter", "GetRemoteServiceHandles"); if (!msg) { @@ -781,7 +589,7 @@ failed: } static DBusHandlerResult resolve_services(DBusMessage *msg, - audio_device_t *device) + struct device *device) { struct audio_sdp_data *sdp_data; @@ -793,9 +601,9 @@ static DBusHandlerResult resolve_services(DBusMessage *msg, return get_handles(GENERIC_AUDIO_UUID, sdp_data); } -audio_device_t *manager_headset_connected(bdaddr_t *bda) +struct device *manager_device_connected(bdaddr_t *bda) { - audio_device_t *device; + struct device *device; const char *path; gboolean created = FALSE; @@ -806,19 +614,19 @@ audio_device_t *manager_headset_connected(bdaddr_t *bda) if (!device) { device = create_device(bda); if (!add_device(device)) { - free_device(device); + remove_device(device); return NULL; } created = TRUE; } if (!device->headset) - device->headset = headset_init(device->object_path, NULL, 0); + device->headset = headset_init(device, NULL, 0); if (!device->headset) return NULL; - path = device->object_path; + path = device->path; if (created) { dbus_connection_emit_signal(connection, AUDIO_MANAGER_PATH, @@ -847,7 +655,7 @@ audio_device_t *manager_headset_connected(bdaddr_t *bda) return device; } -static gboolean device_supports_interface(audio_device_t *device, +static gboolean device_supports_interface(struct device *device, const char *iface) { if (strcmp(iface, AUDIO_HEADSET_INTERFACE) == 0) @@ -873,7 +681,7 @@ static gboolean device_supports_interface(audio_device_t *device, return FALSE; } -static gboolean device_matches(audio_device_t *device, char **interfaces) +static gboolean device_matches(struct device *device, char **interfaces) { int i; @@ -895,7 +703,7 @@ static DBusHandlerResult am_create_device(DBusConnection *conn, char **required; int required_len; bdaddr_t bda; - audio_device_t *device; + struct device *device; DBusMessage *reply; DBusError derr; @@ -950,7 +758,7 @@ static DBusHandlerResult am_create_device(DBusConnection *conn, dbus_free_string_array(required); - path = device->object_path; + path = device->path; reply = dbus_message_new_method_return(msg); if (!reply) @@ -1015,16 +823,13 @@ static DBusHandlerResult am_list_devices(DBusConnection *conn, DBUS_TYPE_STRING_AS_STRING, &array_iter); for (l = devices; l != NULL; l = l->next) { - audio_device_t *device = l->data; - const char *path; + struct device *device = l->data; if (!device_matches(device, required)) continue; - path = device->object_path; - dbus_message_iter_append_basic(&array_iter, - DBUS_TYPE_STRING, &path); + DBUS_TYPE_STRING, &device->path); } dbus_message_iter_close_container(&iter, &array_iter); @@ -1036,10 +841,10 @@ static DBusHandlerResult am_list_devices(DBusConnection *conn, static gint device_path_cmp(gconstpointer a, gconstpointer b) { - const audio_device_t *device = a; + const struct device *device = a; const char *path = b; - return strcmp(device->object_path, path); + return strcmp(device->path, path); } static DBusHandlerResult am_remove_device(DBusConnection *conn, @@ -1050,7 +855,7 @@ static DBusHandlerResult am_remove_device(DBusConnection *conn, DBusMessage *reply; GSList *match; const char *path; - audio_device_t *device; + struct device *device; dbus_error_init(&derr); if (!dbus_message_get_args(msg, &derr, @@ -1067,9 +872,7 @@ static DBusHandlerResult am_remove_device(DBusConnection *conn, match = g_slist_find_custom(devices, path, device_path_cmp); if (!match) - return error_reply(connection, msg, - "org.bluez.audio.Error.DoesNotExist", - "The device does not exist"); + return err_does_not_exist(connection, msg); reply = dbus_message_new_method_return(msg); if (!reply) @@ -1092,7 +895,7 @@ static DBusHandlerResult am_remove_device(DBusConnection *conn, default_dev = device; } - param = default_dev ? default_dev->object_path : ""; + param = default_dev ? default_dev->path : ""; dbus_connection_emit_signal(conn, AUDIO_MANAGER_PATH, AUDIO_MANAGER_INTERFACE, @@ -1120,10 +923,10 @@ static DBusHandlerResult am_find_by_addr(DBusConnection *conn, DBusMessage *msg, void *data) { - const char *path, *address; + const char *address; DBusMessage *reply; DBusError derr; - audio_device_t *device; + struct device *device; bdaddr_t bda; dbus_error_init(&derr); @@ -1147,9 +950,7 @@ static DBusHandlerResult am_find_by_addr(DBusConnection *conn, if (!reply) return DBUS_HANDLER_RESULT_NEED_MEMORY; - path = device->object_path; - - dbus_message_append_args(reply, DBUS_TYPE_STRING, &path, + dbus_message_append_args(reply, DBUS_TYPE_STRING, &device->path, DBUS_TYPE_INVALID); return send_message_and_unref(conn, reply); @@ -1160,27 +961,20 @@ static DBusHandlerResult am_default_device(DBusConnection *conn, void *data) { DBusMessage *reply; - const char *path; if (!default_dev) - return error_reply(connection, msg, - "org.bluez.audio.Error.DoesNotExist", - "There is no default device"); + return err_does_not_exist(connection, msg); if (default_dev->headset == NULL && dbus_message_is_method_call(msg, AUDIO_MANAGER_INTERFACE, "DefaultHeadset")) - return error_reply(connection, msg, - "org.bluez.audio.Error.DoesNotExist", - "There is no default headset"); + return err_does_not_exist(connection, msg); reply = dbus_message_new_method_return(msg); if (!reply) return DBUS_HANDLER_RESULT_NEED_MEMORY; - path = default_dev->object_path; - - dbus_message_append_args(reply, DBUS_TYPE_STRING, &path, + dbus_message_append_args(reply, DBUS_TYPE_STRING, &default_dev->path, DBUS_TYPE_INVALID); return send_message_and_unref(connection, reply); @@ -1194,7 +988,7 @@ static DBusHandlerResult am_change_default_device(DBusConnection *conn, DBusMessage *reply; GSList *match; const char *path; - audio_device_t *device; + struct device *device; dbus_error_init(&derr); if (!dbus_message_get_args(msg, &derr, @@ -1211,9 +1005,7 @@ static DBusHandlerResult am_change_default_device(DBusConnection *conn, match = g_slist_find_custom(devices, path, device_path_cmp); if (!match) - return error_reply(connection, msg, - "org.bluez.audio.Error.DoesNotExist", - "The device does not exist"); + return err_does_not_exist(connection, msg); reply = dbus_message_new_method_return(msg); if (!reply) @@ -1221,25 +1013,21 @@ static DBusHandlerResult am_change_default_device(DBusConnection *conn, device = match->data; - path = device->object_path; - if (!dbus_message_is_method_call(msg, AUDIO_MANAGER_INTERFACE, "ChangeDefaultHeadset")) dbus_connection_emit_signal(conn, AUDIO_MANAGER_PATH, AUDIO_MANAGER_INTERFACE, "DefaultDeviceChanged", - DBUS_TYPE_STRING, &path, + DBUS_TYPE_STRING, &device->path, DBUS_TYPE_INVALID); else if (device->headset) dbus_connection_emit_signal(conn, AUDIO_MANAGER_PATH, AUDIO_MANAGER_INTERFACE, "DefaultHeadsetChanged", - DBUS_TYPE_STRING, &path, + DBUS_TYPE_STRING, &device->path, DBUS_TYPE_INVALID); else - return error_reply(connection, msg, - "org.bluez.audio.Error.DoesNotExist", - "The headset does not exist"); + return err_does_not_exist(connection, msg); default_dev = device; return send_message_and_unref(connection, reply); @@ -1316,20 +1104,7 @@ void audio_exit(void) connection = NULL; } -int manager_get_device(int sock, uint8_t role, struct ipc_data_cfg *cfg) +struct device * manager_default_device() { - GSList *l; - - if (default_dev && default_dev->headset && - headset_is_connected(default_dev->headset)) - return headset_get_config(default_dev->headset, sock, cfg); - - for (l = devices; l != NULL; l = l->next) { - audio_device_t *dev = l->data; - - if (dev->headset && headset_is_connected(dev->headset)) - return headset_get_config(dev->headset, sock, cfg); - } - - return -1; + return default_dev; } diff --git a/audio/manager.h b/audio/manager.h index 5cdf2b23..65515483 100644 --- a/audio/manager.h +++ b/audio/manager.h @@ -21,78 +21,17 @@ * */ -#include - #include -#include "headset.h" +#include "device.h" #define AUDIO_MANAGER_PATH "/org/bluez/audio" #define AUDIO_MANAGER_INTERFACE "org.bluez.audio.Manager" -#define AUDIO_DEVICE_INTERFACE "org.bluez.audio.Device" - -#define GENERIC_AUDIO_UUID "00001203-0000-1000-8000-00805F9B34FB" - -#define HSP_HS_UUID "00001108-0000-1000-8000-00805F9B34FB" -#define HSP_AG_UUID "00001112-0000-1000-8000-00805F9B34FB" - -#define HFP_HS_UUID "0000111E-0000-1000-8000-00805F9B34FB" -#define HFP_AG_UUID "0000111F-0000-1000-8000-00805F9B34FB" - -#define ADVANCED_AUDIO_UUID "0000110D-0000-1000-8000-00805F9B34FB" - -#define A2DP_SOURCE_UUID "0000110A-0000-1000-8000-00805F9B34FB" -#define A2DP_SINK_UUID "0000110B-0000-1000-8000-00805F9B34FB" - -#define AVRCP_REMOTE_UUID "0000110E-0000-1000-8000-00805F9B34FB" -#define AVRCP_TARGET_UUID "0000110C-0000-1000-8000-00805F9B34FB" - -/* Move these to respective .h files once they exist */ -#define AUDIO_GATEWAY_INTERFACE "org.bluez.audio.Gateway" -#define AUDIO_SINK_INTERFACE "org.bluez.audio.Sink" -#define AUDIO_SOURCE_INTERFACE "org.bluez.audio.Source" -#define AUDIO_CONTROL_INTERFACE "org.bluez.audio.Control" -#define AUDIO_TARGET_INTERFACE "org.bluez.audio.Target" -typedef struct gateway gateway_t; -typedef struct sink sink_t; -typedef struct source source_t; -typedef struct control control_t; -typedef struct target target_t; - -typedef struct audio_device { - char object_path[128]; - bdaddr_t bda; - - headset_t *headset; - - gateway_t *gateway; - sink_t *sink; - source_t *source; - control_t *control; - target_t *target; - -} audio_device_t; - -audio_device_t *manager_headset_connected(bdaddr_t *bda); - int audio_init(DBusConnection *conn); void audio_exit(void); -void finish_sdp_transaction(DBusConnection *conn, bdaddr_t *dba); - - -DBusHandlerResult err_invalid_args(DBusConnection *conn, DBusMessage *msg, - const char *descr); -DBusHandlerResult err_already_connected(DBusConnection *conn, DBusMessage *msg); -DBusHandlerResult err_not_connected(DBusConnection *conn, DBusMessage *msg); -DBusHandlerResult err_not_supported(DBusConnection *conn, DBusMessage *msg); -DBusHandlerResult err_connect_failed(DBusConnection *conn, - DBusMessage *msg, int err); -DBusHandlerResult err_does_not_exist(DBusConnection *conn, DBusMessage *msg); -DBusHandlerResult err_not_available(DBusConnection *conn, DBusMessage *msg); -DBusHandlerResult err_failed(DBusConnection *conn, DBusMessage *msg, - const char *dsc); +struct device *manager_device_connected(bdaddr_t *bda); -int manager_get_device(int sock, uint8_t role, struct ipc_data_cfg *cfg); +struct device *manager_default_device(); diff --git a/audio/unix.c b/audio/unix.c index 2dad00df..f17404b4 100644 --- a/audio/unix.c +++ b/audio/unix.c @@ -78,6 +78,7 @@ static int unix_sendmsg_fd(int sock, int fd, struct ipc_packet *pkt) static gboolean unix_event(GIOChannel *chan, GIOCondition cond, gpointer data) { + struct device *device; struct sockaddr_un addr; socklen_t addrlen; struct ipc_packet *pkt; @@ -118,9 +119,13 @@ static gboolean unix_event(GIOChannel *chan, GIOCondition cond, gpointer data) cfg = (struct ipc_data_cfg *) pkt->data; memset(cfg, 0, sizeof(struct ipc_data_cfg)); - if (manager_get_device(clisk, pkt->role, cfg) == 0) - unix_send_cfg(clisk, pkt); + if ((device = manager_default_device())) { + if (device->headset) + headset_get_config(device, clisk, pkt); + } + if (cfg->fd != 0) + unix_send_cfg(clisk, pkt); break; case PKT_TYPE_STATUS_REQ: info("Package PKT_TYPE_STATUS_REQ"); -- cgit