diff --git a/audio/a2dp.c b/audio/a2dp.c
index 64b37e7..fd1c494 100644
--- a/audio/a2dp.c
+++ b/audio/a2dp.c
int ref;
};
-static DBusConnection *connection = NULL;
-
struct a2dp_server {
bdaddr_t src;
GSList *sinks;
return NULL;
}
-int a2dp_register(DBusConnection *conn, const bdaddr_t *src, GKeyFile *config)
+int a2dp_register(const bdaddr_t *src, GKeyFile *config)
{
gboolean source = TRUE, sink = FALSE;
gboolean delay_reporting = FALSE;
}
proceed:
- if (!connection)
- connection = dbus_connection_ref(conn);
server = find_server(servers, src);
if (!server) {
if (servers)
return;
-
- dbus_connection_unref(connection);
- connection = NULL;
}
struct a2dp_sep *a2dp_add_sep(const bdaddr_t *src, uint8_t type,
diff --git a/audio/a2dp.h b/audio/a2dp.h
index deab3b8..736bc66 100644
--- a/audio/a2dp.h
+++ b/audio/a2dp.h
struct avdtp_error *err,
void *user_data);
-int a2dp_register(DBusConnection *conn, const bdaddr_t *src, GKeyFile *config);
+int a2dp_register(const bdaddr_t *src, GKeyFile *config);
void a2dp_unregister(const bdaddr_t *src);
struct a2dp_sep *a2dp_add_sep(const bdaddr_t *src, uint8_t type,
diff --git a/audio/avrcp.c b/audio/avrcp.c
index 27be7e8..7258e7a 100644
--- a/audio/avrcp.c
+++ b/audio/avrcp.c
avctp_disconnect(session);
}
-int avrcp_register(DBusConnection *conn, const bdaddr_t *src, GKeyFile *config)
+int avrcp_register(const bdaddr_t *src, GKeyFile *config)
{
sdp_record_t *record;
gboolean tmp, master = TRUE;
diff --git a/audio/avrcp.h b/audio/avrcp.h
index bf11a6c..d94a050 100644
--- a/audio/avrcp.h
+++ b/audio/avrcp.h
void *user_data);
};
-int avrcp_register(DBusConnection *conn, const bdaddr_t *src, GKeyFile *config);
+int avrcp_register(const bdaddr_t *src, GKeyFile *config);
void avrcp_unregister(const bdaddr_t *src);
gboolean avrcp_connect(struct audio_device *dev);
diff --git a/audio/control.c b/audio/control.c
index 02aea33..896bc48 100644
--- a/audio/control.c
+++ b/audio/control.c
static void state_changed(struct audio_device *dev, avctp_state_t old_state,
avctp_state_t new_state, void *user_data)
{
+ DBusConnection *conn = btd_get_dbus_connection();
struct control *control = dev->control;
gboolean value;
break;
value = FALSE;
- g_dbus_emit_signal(dev->conn, dev->path,
+ g_dbus_emit_signal(conn, dev->path,
AUDIO_CONTROL_INTERFACE,
"Disconnected", DBUS_TYPE_INVALID);
emit_property_changed(dev->path,
break;
case AVCTP_STATE_CONNECTED:
value = TRUE;
- g_dbus_emit_signal(dev->conn, dev->path,
+ g_dbus_emit_signal(conn, dev->path,
AUDIO_CONTROL_INTERFACE, "Connected",
DBUS_TYPE_INVALID);
emit_property_changed(dev->path,
void control_unregister(struct audio_device *dev)
{
- g_dbus_unregister_interface(dev->conn, dev->path,
+ g_dbus_unregister_interface(btd_get_dbus_connection(), dev->path,
AUDIO_CONTROL_INTERFACE);
}
{
struct control *control;
- if (!g_dbus_register_interface(dev->conn, dev->path,
+ if (!g_dbus_register_interface(btd_get_dbus_connection(), dev->path,
AUDIO_CONTROL_INTERFACE,
control_methods, control_signals, NULL,
dev, path_unregister))
diff --git a/audio/device.c b/audio/device.c
index b93a294..99d6512 100644
--- a/audio/device.c
+++ b/audio/device.c
{
struct dev_priv *priv = dev->priv;
- if (dev->conn)
- dbus_connection_unref(dev->conn);
-
btd_device_unref(dev->btd_dev);
if (priv) {
static void device_set_state(struct audio_device *dev, audio_state_t new_state)
{
+ DBusConnection *conn = btd_get_dbus_connection();
struct dev_priv *priv = dev->priv;
const char *state_str;
DBusMessage *reply = NULL;
reply = dbus_message_new_method_return(priv->dc_req);
dbus_message_unref(priv->dc_req);
priv->dc_req = NULL;
- g_dbus_send_message(dev->conn, reply);
+ g_dbus_send_message(conn, reply);
}
priv->disconnecting = FALSE;
}
dbus_message_unref(priv->conn_req);
priv->conn_req = NULL;
- g_dbus_send_message(dev->conn, reply);
+ g_dbus_send_message(conn, reply);
}
emit_property_changed(dev->path,
{ }
};
-struct audio_device *audio_device_register(DBusConnection *conn,
- struct btd_device *device,
+struct audio_device *audio_device_register(struct btd_device *device,
const char *path, const bdaddr_t *src,
const bdaddr_t *dst)
{
struct audio_device *dev;
- if (!conn || !path)
+ if (!path)
return NULL;
dev = g_new0(struct audio_device, 1);
dev->path = g_strdup(path);
bacpy(&dev->dst, dst);
bacpy(&dev->src, src);
- dev->conn = dbus_connection_ref(conn);
dev->priv = g_new0(struct dev_priv, 1);
dev->priv->state = AUDIO_STATE_DISCONNECTED;
- if (!g_dbus_register_interface(dev->conn, dev->path,
- AUDIO_INTERFACE,
+ if (!g_dbus_register_interface(btd_get_dbus_connection(),
+ dev->path, AUDIO_INTERFACE,
dev_methods, dev_signals, NULL,
dev, NULL)) {
error("Unable to register %s on %s", AUDIO_INTERFACE,
if (device->control)
control_unregister(device);
- g_dbus_unregister_interface(device->conn, device->path,
+ g_dbus_unregister_interface(btd_get_dbus_connection(), device->path,
AUDIO_INTERFACE);
device_free(device);
diff --git a/audio/device.h b/audio/device.h
index 75f1da9..f9b868f 100644
--- a/audio/device.h
+++ b/audio/device.h
struct audio_device {
struct btd_device *btd_dev;
- DBusConnection *conn;
char *path;
bdaddr_t src;
bdaddr_t dst;
struct dev_priv *priv;
};
-struct audio_device *audio_device_register(DBusConnection *conn,
- struct btd_device *device,
+struct audio_device *audio_device_register(struct btd_device *device,
const char *path, const bdaddr_t *src,
const bdaddr_t *dst);
diff --git a/audio/gateway.c b/audio/gateway.c
index 0fe29d1..45b25a1 100644
--- a/audio/gateway.c
+++ b/audio/gateway.c
msg = dbus_message_new_method_call(agent->name, agent->path,
"org.bluez.HandsfreeAgent", "Release");
- g_dbus_send_message(dev->conn, msg);
+ g_dbus_send_message(btd_get_dbus_connection(), msg);
}
static gboolean agent_sendfd(struct hf_agent *agent, int fd,
DBUS_TYPE_UINT16, &gw->version,
DBUS_TYPE_INVALID);
- if (dbus_connection_send_with_reply(dev->conn, msg,
+ if (dbus_connection_send_with_reply(btd_get_dbus_connection(), msg,
&call, -1) == FALSE) {
dbus_message_unref(msg);
return FALSE;
static void rfcomm_connect_cb(GIOChannel *chan, GError *err,
gpointer user_data)
{
+ DBusConnection *conn = btd_get_dbus_connection();
struct audio_device *dev = user_data;
struct gateway *gw = dev->gateway;
DBusMessage *reply;
else
reply = btd_error_failed(gw->msg, "Can't pass file descriptor");
- g_dbus_send_message(dev->conn, reply);
+ g_dbus_send_message(conn, reply);
return;
if (gw->msg) {
DBusMessage *reply;
reply = btd_error_failed(gw->msg, "Connect failed");
- g_dbus_send_message(dev->conn, reply);
+ g_dbus_send_message(conn, reply);
}
gateway_close(dev);
if (gw->msg) {
DBusMessage *reply = btd_error_failed(gw->msg,
gerr ? gerr->message : strerror(-err));
- g_dbus_send_message(dev->conn, reply);
+ g_dbus_send_message(btd_get_dbus_connection(), reply);
}
gateway_close(dev);
DBusMessage *reply = NULL;
char gw_addr[18];
- if (!device->conn)
- return NULL;
-
if (!gw->rfcomm)
return btd_error_not_connected(msg);
if (strcmp(gw->agent->path, path) != 0)
return btd_error_does_not_exist(msg);
- g_dbus_remove_watch(device->conn, gw->agent->watch);
+ g_dbus_remove_watch(conn, gw->agent->watch);
agent_free(gw->agent);
gw->agent = NULL;
if (dev->gateway->agent)
agent_disconnect(dev, dev->gateway->agent);
- g_dbus_unregister_interface(dev->conn, dev->path,
+ g_dbus_unregister_interface(btd_get_dbus_connection(), dev->path,
AUDIO_GATEWAY_INTERFACE);
}
struct gateway *gateway_init(struct audio_device *dev)
{
- if (!g_dbus_register_interface(dev->conn, dev->path,
+ if (!g_dbus_register_interface(btd_get_dbus_connection(), dev->path,
AUDIO_GATEWAY_INTERFACE,
gateway_methods, gateway_signals,
NULL, dev, path_unregister))
diff --git a/audio/headset.c b/audio/headset.c
index 3ded18e..c822e35 100644
--- a/audio/headset.c
+++ b/audio/headset.c
static GSList *headset_callbacks = NULL;
-static void error_connect_failed(DBusConnection *conn, DBusMessage *msg,
- int err)
+static void error_connect_failed(DBusMessage *msg, int err)
{
DBusMessage *reply = btd_error_failed(msg,
err < 0 ? strerror(-err) : "Connect failed");
- g_dbus_send_message(conn, reply);
+ g_dbus_send_message(btd_get_dbus_connection(), reply);
}
static int rfcomm_connect(struct audio_device *device, headset_stream_cb_t cb,
if (p != NULL) {
p->err = -errno;
if (p->msg)
- error_connect_failed(dev->conn, p->msg, p->err);
+ error_connect_failed(p->msg, p->err);
pending_connect_finalize(dev);
}
if (p->msg) {
DBusMessage *reply;
reply = dbus_message_new_method_return(p->msg);
- g_dbus_send_message(dev->conn, reply);
+ g_dbus_send_message(btd_get_dbus_connection(), reply);
}
pending_connect_finalize(dev);
if (p->target_state == HEADSET_STATE_CONNECTED) {
if (p->msg) {
DBusMessage *reply = dbus_message_new_method_return(p->msg);
- g_dbus_send_message(dev->conn, reply);
+ g_dbus_send_message(btd_get_dbus_connection(), reply);
}
pending_connect_finalize(dev);
return;
p->err = sco_connect(dev, NULL, NULL, NULL);
if (p->err < 0) {
if (p->msg)
- error_connect_failed(dev->conn, p->msg, p->err);
+ error_connect_failed(p->msg, p->err);
pending_connect_finalize(dev);
}
}
if (strlen(buf) < 9)
return -EINVAL;
- g_dbus_emit_signal(device->conn, device->path,
+ g_dbus_emit_signal(btd_get_dbus_connection(), device->path,
AUDIO_HEADSET_INTERFACE, "AnswerRequested",
DBUS_TYPE_INVALID);
if (err != CME_ERROR_NONE)
return telephony_generic_rsp(telephony_device, err);
- g_dbus_emit_signal(device->conn, device->path,
+ g_dbus_emit_signal(btd_get_dbus_connection(), device->path,
AUDIO_HEADSET_INTERFACE, "CallTerminated",
DBUS_TYPE_INVALID);
return -EINVAL;
}
- g_dbus_emit_signal(device->conn, device->path,
+ g_dbus_emit_signal(btd_get_dbus_connection(), device->path,
AUDIO_HEADSET_INTERFACE, name,
DBUS_TYPE_UINT16, &gain,
DBUS_TYPE_INVALID);
if (p && p->msg) {
DBusMessage *reply = dbus_message_new_method_return(p->msg);
- g_dbus_send_message(dev->conn, reply);
+ g_dbus_send_message(btd_get_dbus_connection(), reply);
}
pending_connect_finalize(dev);
failed:
if (p && p->msg)
- error_connect_failed(dev->conn, p->msg, p->err);
+ error_connect_failed(p->msg, p->err);
pending_connect_finalize(dev);
if (hs->rfcomm)
headset_set_state(dev, HEADSET_STATE_CONNECTED);
strerror(-err), -err);
p->err = -err;
if (p->msg)
- error_connect_failed(dev->conn, p->msg, p->err);
+ error_connect_failed(p->msg, p->err);
goto failed;
}
error("Unable to connect: %s (%d)", strerror(-err), -err);
p->err = -err;
if (p->msg != NULL)
- error_connect_failed(dev->conn, p->msg, p->err);
+ error_connect_failed(p->msg, p->err);
goto failed;
}
return;
if (p->msg) {
DBusMessage *reply = btd_error_not_supported(p->msg);
- g_dbus_send_message(dev->conn, reply);
+ g_dbus_send_message(btd_get_dbus_connection(), reply);
}
failed:
p->svclass = 0;
return reply;
}
-static DBusMessage *hs_set_gain(DBusConnection *conn,
- DBusMessage *msg,
+static DBusMessage *hs_set_gain(DBusMessage *msg,
void *data, uint16_t gain,
char type)
{
return btd_error_invalid_args(msg);
dbus_message_iter_get_basic(&sub, &gain);
- return hs_set_gain(conn, msg, data, gain,
+ return hs_set_gain(msg, data, gain,
HEADSET_GAIN_SPEAKER);
} else if (g_str_equal("MicrophoneGain", property)) {
if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_UINT16)
return btd_error_invalid_args(msg);
dbus_message_iter_get_basic(&sub, &gain);
- return hs_set_gain(conn, msg, data, gain,
+ return hs_set_gain(msg, data, gain,
HEADSET_GAIN_MICROPHONE);
}
void headset_unregister(struct audio_device *dev)
{
- g_dbus_unregister_interface(dev->conn, dev->path,
+ g_dbus_unregister_interface(btd_get_dbus_connection(), dev->path,
AUDIO_HEADSET_INTERFACE);
}
headset_update(dev, hs, uuids);
- if (!g_dbus_register_interface(dev->conn, dev->path,
+ if (!g_dbus_register_interface(btd_get_dbus_connection(), dev->path,
AUDIO_HEADSET_INTERFACE,
headset_methods, headset_signals, NULL,
dev, path_unregister)) {
emit_property_changed(dev->path,
AUDIO_HEADSET_INTERFACE, "State",
DBUS_TYPE_STRING, &state_str);
- g_dbus_emit_signal(dev->conn, dev->path,
+ g_dbus_emit_signal(btd_get_dbus_connection(), dev->path,
AUDIO_HEADSET_INTERFACE,
"Disconnected",
DBUS_TYPE_INVALID);
slc->inband_ring = TRUE;
else
slc->inband_ring = FALSE;
- g_dbus_emit_signal(dev->conn, dev->path,
+ g_dbus_emit_signal(btd_get_dbus_connection(), dev->path,
AUDIO_HEADSET_INTERFACE,
"Connected",
DBUS_TYPE_INVALID);
telephony_device_connected(dev);
} else if (hs->state == HEADSET_STATE_PLAYING) {
value = FALSE;
- g_dbus_emit_signal(dev->conn, dev->path,
+ g_dbus_emit_signal(btd_get_dbus_connection(), dev->path,
AUDIO_HEADSET_INTERFACE,
"Stopped",
DBUS_TYPE_INVALID);
G_IO_ERR | G_IO_NVAL,
(GIOFunc) sco_cb, dev);
- g_dbus_emit_signal(dev->conn, dev->path,
+ g_dbus_emit_signal(btd_get_dbus_connection(), dev->path,
AUDIO_HEADSET_INTERFACE, "Playing",
DBUS_TYPE_INVALID);
emit_property_changed(dev->path,
struct pending_connect *p = dev->headset->pending;
if (p && p->msg)
- error_connect_failed(dev->conn, p->msg, ECANCELED);
+ error_connect_failed(p->msg, ECANCELED);
pending_connect_finalize(dev);
headset_set_state(dev, HEADSET_STATE_DISCONNECTED);
diff --git a/audio/main.c b/audio/main.c
index a88f163..f7bb32a 100644
--- a/audio/main.c
+++ b/audio/main.c
g_io_channel_shutdown(chan, TRUE, NULL);
}
-static DBusConnection *connection;
-
static int audio_init(void)
{
GKeyFile *config;
gboolean enable_sco;
- connection = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
- if (connection == NULL)
- return -EIO;
-
config = load_config_file(CONFIGDIR "/audio.conf");
- if (audio_manager_init(connection, config, &enable_sco) < 0)
+ if (audio_manager_init(config, &enable_sco) < 0)
goto failed;
if (!enable_sco)
failed:
audio_manager_exit();
- if (connection) {
- dbus_connection_unref(connection);
- connection = NULL;
- }
-
return -EIO;
}
}
audio_manager_exit();
-
- dbus_connection_unref(connection);
}
BLUETOOTH_PLUGIN_DEFINE(audio, VERSION,
diff --git a/audio/manager.c b/audio/manager.c
index 3b105ed..fbfe00f 100644
--- a/audio/manager.c
+++ b/audio/manager.c
static gboolean auto_connect = TRUE;
static int max_connected_headsets = 1;
-static DBusConnection *connection = NULL;
static GKeyFile *config = NULL;
static GSList *adapters = NULL;
static GSList *devices = NULL;
adapter_get_address(adapter, &src);
- err = a2dp_register(connection, &src, config);
+ err = a2dp_register(&src, config);
if (err < 0)
audio_adapter_unref(adp);
adapter_get_address(adapter, &src);
- err = avrcp_register(connection, &src, config);
+ err = avrcp_register(&src, config);
if (err < 0)
audio_adapter_unref(adp);
adapter_get_address(adapter, &src);
- err = media_register(connection, path, &src);
+ err = media_register(path, &src);
if (err < 0)
audio_adapter_unref(adp);
.remove = media_server_remove,
};
-int audio_manager_init(DBusConnection *conn, GKeyFile *conf,
- gboolean *enable_sco)
+int audio_manager_init(GKeyFile *conf, gboolean *enable_sco)
{
char **list;
int i;
gboolean b;
GError *err = NULL;
- connection = dbus_connection_ref(conn);
-
if (!conf)
goto proceed;
void audio_manager_exit(void)
{
- /* Bail out early if we haven't been initialized */
- if (connection == NULL)
- return;
-
- dbus_connection_unref(connection);
- connection = NULL;
-
if (config) {
g_key_file_free(config);
config = NULL;
path = device_get_path(device);
- dev = audio_device_register(connection, device, path, src, dst);
+ dev = audio_device_register(device, path, src, dst);
if (!dev)
return NULL;
diff --git a/audio/manager.h b/audio/manager.h
index 300142d..08d814f 100644
--- a/audio/manager.h
+++ b/audio/manager.h
gboolean media_player;
};
-int audio_manager_init(DBusConnection *conn, GKeyFile *config,
- gboolean *enable_sco);
+int audio_manager_init(GKeyFile *config, gboolean *enable_sco);
void audio_manager_exit(void);
struct audio_device *manager_find_device(const char *path,
diff --git a/audio/media.c b/audio/media.c
index e4a7684..c88afc0 100644
--- a/audio/media.c
+++ b/audio/media.c
struct media_adapter {
bdaddr_t src; /* Adapter address */
char *path; /* Adapter path */
- DBusConnection *conn; /* Adapter connection */
GSList *endpoints; /* Endpoints list */
GSList *players; /* Players list */
};
static void media_endpoint_destroy(struct media_endpoint *endpoint)
{
- struct media_adapter *adapter = endpoint->adapter;
-
DBG("sender=%s path=%s", endpoint->sender, endpoint->path);
if (endpoint->hs_watch)
g_slist_free_full(endpoint->transports,
(GDestroyNotify) media_transport_destroy);
- g_dbus_remove_watch(adapter->conn, endpoint->watch);
+ g_dbus_remove_watch(btd_get_dbus_connection(), endpoint->watch);
g_free(endpoint->capabilities);
g_free(endpoint->sender);
g_free(endpoint->path);
static void clear_configuration(struct media_endpoint *endpoint,
struct media_transport *transport)
{
- DBusConnection *conn;
DBusMessage *msg;
const char *path;
- conn = endpoint->adapter->conn;
-
msg = dbus_message_new_method_call(endpoint->sender, endpoint->path,
MEDIA_ENDPOINT_INTERFACE,
"ClearConfiguration");
path = media_transport_get_path(transport);
dbus_message_append_args(msg, DBUS_TYPE_OBJECT_PATH, &path,
DBUS_TYPE_INVALID);
- g_dbus_send_message(conn, msg);
+ g_dbus_send_message(btd_get_dbus_connection(), msg);
done:
endpoint->transports = g_slist_remove(endpoint->transports, transport);
media_transport_destroy(transport);
endpoint_request_free(request);
}
-static gboolean media_endpoint_async_call(DBusConnection *conn,
- DBusMessage *msg,
+static gboolean media_endpoint_async_call(DBusMessage *msg,
struct media_endpoint *endpoint,
media_endpoint_cb_t cb,
void *user_data,
request = g_new0(struct endpoint_request, 1);
/* Timeout should be less than avdtp request timeout (4 seconds) */
- if (dbus_connection_send_with_reply(conn, msg, &request->call,
+ if (dbus_connection_send_with_reply(btd_get_dbus_connection(),
+ msg, &request->call,
REQUEST_TIMEOUT) == FALSE) {
error("D-Bus send failed");
g_free(request);
void *user_data,
GDestroyNotify destroy)
{
- DBusConnection *conn;
DBusMessage *msg;
- conn = endpoint->adapter->conn;
-
msg = dbus_message_new_method_call(endpoint->sender, endpoint->path,
MEDIA_ENDPOINT_INTERFACE,
"SelectConfiguration");
&capabilities, length,
DBUS_TYPE_INVALID);
- return media_endpoint_async_call(conn, msg, endpoint, cb, user_data,
- destroy);
+ return media_endpoint_async_call(msg, endpoint, cb, user_data, destroy);
}
static gint transport_device_cmp(gconstpointer data, gconstpointer user_data)
void *user_data,
GDestroyNotify destroy)
{
- DBusConnection *conn;
DBusMessage *msg;
const char *path;
DBusMessageIter iter;
if (transport != NULL)
return FALSE;
- conn = endpoint->adapter->conn;
-
- transport = media_transport_create(conn, endpoint, device,
+ transport = media_transport_create(endpoint, device,
configuration, size);
if (transport == NULL)
return FALSE;
transport_get_properties(transport, &iter);
- return media_endpoint_async_call(conn, msg, endpoint, cb, user_data,
- destroy);
+ return media_endpoint_async_call(msg, endpoint, cb, user_data, destroy);
}
static void release_endpoint(struct media_endpoint *endpoint)
return;
}
- g_dbus_send_message(endpoint->adapter->conn, msg);
+ g_dbus_send_message(btd_get_dbus_connection(), msg);
done:
media_endpoint_remove(endpoint);
return NULL;
}
- endpoint->watch = g_dbus_add_disconnect_watch(adapter->conn, sender,
- media_endpoint_exit, endpoint,
- NULL);
+ endpoint->watch = g_dbus_add_disconnect_watch(btd_get_dbus_connection(),
+ sender, media_endpoint_exit,
+ endpoint, NULL);
adapter->endpoints = g_slist_append(adapter->endpoints, endpoint);
info("Endpoint registered: sender=%s path=%s", sender, path);
return;
}
- g_dbus_send_message(mp->adapter->conn, msg);
+ g_dbus_send_message(btd_get_dbus_connection(), msg);
}
static void media_player_free(gpointer data)
{
+ DBusConnection *conn = btd_get_dbus_connection();
struct media_player *mp = data;
struct media_adapter *adapter = mp->adapter;
release_player(mp);
}
- g_dbus_remove_watch(adapter->conn, mp->watch);
- g_dbus_remove_watch(adapter->conn, mp->property_watch);
- g_dbus_remove_watch(adapter->conn, mp->track_watch);
+ g_dbus_remove_watch(conn, mp->watch);
+ g_dbus_remove_watch(conn, mp->property_watch);
+ g_dbus_remove_watch(conn, mp->track_watch);
if (mp->track)
g_hash_table_unref(mp->track);
static int set_setting(uint8_t attr, uint8_t val, void *user_data)
{
struct media_player *mp = user_data;
- struct media_adapter *adapter = mp->adapter;
const char *property, *value;
guint attr_uint = attr;
DBusMessage *msg;
dbus_message_iter_append_basic(&var, DBUS_TYPE_STRING, &value);
dbus_message_iter_close_container(&iter, &var);
- g_dbus_send_message(adapter->conn, msg);
+ g_dbus_send_message(btd_get_dbus_connection(), msg);
return 0;
}
const char *path,
int *err)
{
+ DBusConnection *conn = btd_get_dbus_connection();
struct media_player *mp;
mp = g_new0(struct media_player, 1);
mp->path = g_strdup(path);
mp->timer = g_timer_new();
- mp->watch = g_dbus_add_disconnect_watch(adapter->conn, sender,
+ mp->watch = g_dbus_add_disconnect_watch(conn, sender,
media_player_exit, mp,
NULL);
- mp->property_watch = g_dbus_add_signal_watch(adapter->conn, sender,
+ mp->property_watch = g_dbus_add_signal_watch(conn, sender,
path, MEDIA_PLAYER_INTERFACE,
"PropertyChanged",
property_changed,
mp, NULL);
- mp->track_watch = g_dbus_add_signal_watch(adapter->conn, sender,
+ mp->track_watch = g_dbus_add_signal_watch(conn, sender,
path, MEDIA_PLAYER_INTERFACE,
"TrackChanged",
track_changed,
while (adapter->players)
media_player_destroy(adapter->players->data);
- dbus_connection_unref(adapter->conn);
-
adapters = g_slist_remove(adapters, adapter);
g_free(adapter->path);
g_free(adapter);
}
-int media_register(DBusConnection *conn, const char *path, const bdaddr_t *src)
+int media_register(const char *path, const bdaddr_t *src)
{
struct media_adapter *adapter;
adapter = g_new0(struct media_adapter, 1);
- adapter->conn = dbus_connection_ref(conn);
bacpy(&adapter->src, src);
adapter->path = g_strdup(path);
- if (!g_dbus_register_interface(conn, path, MEDIA_INTERFACE,
+ if (!g_dbus_register_interface(btd_get_dbus_connection(),
+ path, MEDIA_INTERFACE,
media_methods, NULL, NULL,
adapter, path_free)) {
error("D-Bus failed to register %s path", path);
struct media_adapter *adapter = l->data;
if (g_strcmp0(path, adapter->path) == 0) {
- g_dbus_unregister_interface(adapter->conn, path,
- MEDIA_INTERFACE);
+ g_dbus_unregister_interface(btd_get_dbus_connection(),
+ path, MEDIA_INTERFACE);
return;
}
}
diff --git a/audio/media.h b/audio/media.h
index 84fc1bc..82b9694 100644
--- a/audio/media.h
+++ b/audio/media.h
typedef void (*media_endpoint_cb_t) (struct media_endpoint *endpoint,
void *ret, int size, void *user_data);
-int media_register(DBusConnection *conn, const char *path, const bdaddr_t *src);
+int media_register(const char *path, const bdaddr_t *src);
void media_unregister(const char *path);
struct a2dp_sep *media_endpoint_get_sep(struct media_endpoint *endpoint);
diff --git a/audio/sink.c b/audio/sink.c
index 6201d85..4eb2c61 100644
--- a/audio/sink.c
+++ b/audio/sink.c
#define STREAM_SETUP_RETRY_TIMER 2
struct pending_request {
- DBusConnection *conn;
DBusMessage *msg;
unsigned int id;
};
sink_state_t state;
struct pending_request *connect;
struct pending_request *disconnect;
- DBusConnection *conn;
};
struct sink_state_callback {
case AVDTP_SESSION_STATE_DISCONNECTED:
if (sink->state != SINK_STATE_CONNECTING) {
gboolean value = FALSE;
- g_dbus_emit_signal(dev->conn, dev->path,
+ g_dbus_emit_signal(btd_get_dbus_connection(), dev->path,
AUDIO_SINK_INTERFACE, "Disconnected",
DBUS_TYPE_INVALID);
emit_property_changed(dev->path,
static void pending_request_free(struct audio_device *dev,
struct pending_request *pending)
{
- if (pending->conn)
- dbus_connection_unref(pending->conn);
if (pending->msg)
dbus_message_unref(pending->msg);
if (pending->id)
struct avdtp_error *err,
void *user_data)
{
+ DBusConnection *conn = btd_get_dbus_connection();
struct audio_device *dev = user_data;
struct sink *sink = dev->sink;
gboolean value;
sink->disconnect = NULL;
reply = dbus_message_new_method_return(p->msg);
- g_dbus_send_message(p->conn, reply);
+ g_dbus_send_message(conn, reply);
pending_request_free(dev, p);
}
if (old_state == AVDTP_STATE_CONFIGURED &&
sink->state == SINK_STATE_CONNECTING) {
value = TRUE;
- g_dbus_emit_signal(dev->conn, dev->path,
+ g_dbus_emit_signal(conn, dev->path,
AUDIO_SINK_INTERFACE,
"Connected",
DBUS_TYPE_INVALID);
DBUS_TYPE_BOOLEAN, &value);
} else if (old_state == AVDTP_STATE_STREAMING) {
value = FALSE;
- g_dbus_emit_signal(dev->conn, dev->path,
+ g_dbus_emit_signal(conn, dev->path,
AUDIO_SINK_INTERFACE,
"Stopped",
DBUS_TYPE_INVALID);
break;
case AVDTP_STATE_STREAMING:
value = TRUE;
- g_dbus_emit_signal(dev->conn, dev->path, AUDIO_SINK_INTERFACE,
- "Playing", DBUS_TYPE_INVALID);
+ g_dbus_emit_signal(conn, dev->path,
+ AUDIO_SINK_INTERFACE, "Playing",
+ DBUS_TYPE_INVALID);
emit_property_changed(dev->path,
AUDIO_SINK_INTERFACE, "Playing",
DBUS_TYPE_BOOLEAN, &value);
sink->stream_state = new_state;
}
-static void error_failed(DBusConnection *conn, DBusMessage *msg,
- const char *desc)
+static void error_failed(DBusMessage *msg, const char *desc)
{
DBusMessage *reply = btd_error_failed(msg, desc);
- g_dbus_send_message(conn, reply);
+ g_dbus_send_message(btd_get_dbus_connection(), reply);
}
static gboolean stream_setup_retry(gpointer user_data)
if (pending->msg) {
DBusMessage *reply;
reply = dbus_message_new_method_return(pending->msg);
- g_dbus_send_message(pending->conn, reply);
+ g_dbus_send_message(btd_get_dbus_connection(), reply);
}
} else {
DBG("Stream setup failed, after XCASE connect:connect");
if (pending->msg)
- error_failed(pending->conn, pending->msg, "Stream setup failed");
+ error_failed(pending->msg, "Stream setup failed");
}
sink->connect = NULL;
if (pending->msg) {
DBusMessage *reply;
reply = dbus_message_new_method_return(pending->msg);
- g_dbus_send_message(pending->conn, reply);
+ g_dbus_send_message(btd_get_dbus_connection(), reply);
}
sink->connect = NULL;
sink);
} else {
if (pending->msg)
- error_failed(pending->conn, pending->msg, "Stream setup failed");
+ error_failed(pending->msg, "Stream setup failed");
sink->connect = NULL;
pending_request_free(sink->dev, pending);
DBG("Stream setup failed : %s", avdtp_strerror(err));
failed:
if (pending->msg)
- error_failed(pending->conn, pending->msg, "Stream setup failed");
+ error_failed(pending->msg, "Stream setup failed");
pending_request_free(sink->dev, pending);
sink->connect = NULL;
avdtp_unref(sink->session);
failed:
if (pending->msg)
- error_failed(pending->conn, pending->msg, "Stream setup failed");
+ error_failed(pending->msg, "Stream setup failed");
pending_request_free(sink->dev, pending);
sink->connect = NULL;
avdtp_unref(sink->session);
pending = sink->connect;
- pending->conn = dbus_connection_ref(conn);
pending->msg = dbus_message_ref(msg);
DBG("stream creation in progress");
return btd_error_failed(msg, strerror(-err));
pending = g_new0(struct pending_request, 1);
- pending->conn = dbus_connection_ref(conn);
pending->msg = dbus_message_ref(msg);
sink->disconnect = pending;
void sink_unregister(struct audio_device *dev)
{
- g_dbus_unregister_interface(dev->conn, dev->path,
+ g_dbus_unregister_interface(btd_get_dbus_connection(), dev->path,
AUDIO_SINK_INTERFACE);
}
{
struct sink *sink;
- if (!g_dbus_register_interface(dev->conn, dev->path,
+ if (!g_dbus_register_interface(btd_get_dbus_connection(), dev->path,
AUDIO_SINK_INTERFACE,
sink_methods, sink_signals, NULL,
dev, path_unregister))
struct pending_request *pending = sink->connect;
if (pending->msg)
- error_failed(pending->conn, pending->msg,
- "Stream setup failed");
+ error_failed(pending->msg, "Stream setup failed");
pending_request_free(sink->dev, pending);
sink->connect = NULL;
diff --git a/audio/source.c b/audio/source.c
index 8e01666..41aedd2 100644
--- a/audio/source.c
+++ b/audio/source.c
#define STREAM_SETUP_RETRY_TIMER 2
struct pending_request {
- DBusConnection *conn;
DBusMessage *msg;
unsigned int id;
};
source_state_t state;
struct pending_request *connect;
struct pending_request *disconnect;
- DBusConnection *conn;
};
struct source_state_callback {
static void pending_request_free(struct audio_device *dev,
struct pending_request *pending)
{
- if (pending->conn)
- dbus_connection_unref(pending->conn);
if (pending->msg)
dbus_message_unref(pending->msg);
if (pending->id)
source->disconnect = NULL;
reply = dbus_message_new_method_return(p->msg);
- g_dbus_send_message(p->conn, reply);
+ g_dbus_send_message(btd_get_dbus_connection(), reply);
pending_request_free(dev, p);
}
source->stream_state = new_state;
}
-static void error_failed(DBusConnection *conn, DBusMessage *msg,
+static void error_failed(DBusMessage *msg,
const char *desc)
{
DBusMessage *reply = btd_error_failed(msg, desc);
- g_dbus_send_message(conn, reply);
+ g_dbus_send_message(btd_get_dbus_connection(), reply);
}
static gboolean stream_setup_retry(gpointer user_data)
if (pending->msg) {
DBusMessage *reply;
reply = dbus_message_new_method_return(pending->msg);
- g_dbus_send_message(pending->conn, reply);
+ g_dbus_send_message(btd_get_dbus_connection(), reply);
}
} else {
DBG("Stream setup failed, after XCASE connect:connect");
if (pending->msg)
- error_failed(pending->conn, pending->msg, "Stream setup failed");
+ error_failed(pending->msg, "Stream setup failed");
}
source->connect = NULL;
if (pending->msg) {
DBusMessage *reply;
reply = dbus_message_new_method_return(pending->msg);
- g_dbus_send_message(pending->conn, reply);
+ g_dbus_send_message(btd_get_dbus_connection(), reply);
}
source->connect = NULL;
source);
} else {
if (pending->msg)
- error_failed(pending->conn, pending->msg, "Stream setup failed");
+ error_failed(pending->msg, "Stream setup failed");
source->connect = NULL;
pending_request_free(source->dev, pending);
DBG("Stream setup failed : %s", avdtp_strerror(err));
failed:
if (pending->msg)
- error_failed(pending->conn, pending->msg, "Stream setup failed");
+ error_failed(pending->msg, "Stream setup failed");
pending_request_free(source->dev, pending);
source->connect = NULL;
avdtp_unref(source->session);
failed:
if (pending->msg)
- error_failed(pending->conn, pending->msg, "Stream setup failed");
+ error_failed(pending->msg, "Stream setup failed");
pending_request_free(source->dev, pending);
source->connect = NULL;
avdtp_unref(source->session);
pending = source->connect;
- pending->conn = dbus_connection_ref(conn);
pending->msg = dbus_message_ref(msg);
DBG("stream creation in progress");
return btd_error_failed(msg, strerror(-err));
pending = g_new0(struct pending_request, 1);
- pending->conn = dbus_connection_ref(conn);
pending->msg = dbus_message_ref(msg);
source->disconnect = pending;
void source_unregister(struct audio_device *dev)
{
- g_dbus_unregister_interface(dev->conn, dev->path,
+ g_dbus_unregister_interface(btd_get_dbus_connection(), dev->path,
AUDIO_SOURCE_INTERFACE);
}
{
struct source *source;
- if (!g_dbus_register_interface(dev->conn, dev->path,
+ if (!g_dbus_register_interface(btd_get_dbus_connection(), dev->path,
AUDIO_SOURCE_INTERFACE,
source_methods, source_signals, NULL,
dev, path_unregister))
diff --git a/audio/telephony-dummy.c b/audio/telephony-dummy.c
index 2f89139..d1bbfd5 100644
--- a/audio/telephony-dummy.c
+++ b/audio/telephony-dummy.c
#include <dbus/dbus.h>
#include <gdbus.h>
+#include "dbus-common.h"
#include "log.h"
#include "telephony.h"
#include "error.h"
#define TELEPHONY_DUMMY_IFACE "org.bluez.TelephonyTest"
#define TELEPHONY_DUMMY_PATH "/org/bluez/test"
-static DBusConnection *connection = NULL;
-
static const char *chld_str = "0,1,1x,2,2x,3,4";
static char *subscriber_number = NULL;
static char *active_call_number = NULL;
DBG("telephony-dummy: got %s voice dial request",
enable ? "enable" : "disable");
- g_dbus_emit_signal(connection, TELEPHONY_DUMMY_PATH,
+ g_dbus_emit_signal(btd_get_dbus_connection(), TELEPHONY_DUMMY_PATH,
TELEPHONY_DUMMY_IFACE, "VoiceDial",
DBUS_TYPE_INVALID);
DBG("");
- connection = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
-
- if (g_dbus_register_interface(connection, TELEPHONY_DUMMY_PATH,
+ if (g_dbus_register_interface(btd_get_dbus_connection(),
+ TELEPHONY_DUMMY_PATH,
TELEPHONY_DUMMY_IFACE,
dummy_methods, dummy_signals,
NULL, NULL, NULL) == FALSE) {
{
DBG("");
- g_dbus_unregister_interface(connection, TELEPHONY_DUMMY_PATH,
- TELEPHONY_DUMMY_IFACE);
- dbus_connection_unref(connection);
- connection = NULL;
+ g_dbus_unregister_interface(btd_get_dbus_connection(),
+ TELEPHONY_DUMMY_PATH,
+ TELEPHONY_DUMMY_IFACE);
telephony_deinit();
}
diff --git a/audio/telephony-maemo5.c b/audio/telephony-maemo5.c
index 8a00296..deb64e4 100644
--- a/audio/telephony-maemo5.c
+++ b/audio/telephony-maemo5.c
#include <dbus/dbus.h>
#include <gdbus.h>
+#include "dbus-common.h"
#include "log.h"
#include "telephony.h"
#include "error.h"
.operator_name = NULL,
};
-static DBusConnection *connection = NULL;
-
static GSList *calls = NULL;
/* Reference count for determining the call indicator status */
return -ENOMEM;
}
- g_dbus_send_message(connection, msg);
+ g_dbus_send_message(btd_get_dbus_connection(), msg);
return 0;
}
return -ENOMEM;
}
- g_dbus_send_message(connection, msg);
+ g_dbus_send_message(btd_get_dbus_connection(), msg);
return 0;
}
return -ENOMEM;
}
- g_dbus_send_message(connection, msg);
+ g_dbus_send_message(btd_get_dbus_connection(), msg);
return 0;
}
return -ENOMEM;
}
- g_dbus_send_message(connection, msg);
+ g_dbus_send_message(btd_get_dbus_connection(), msg);
return 0;
}
return -ENOMEM;
}
- g_dbus_send_message(connection, msg);
+ g_dbus_send_message(btd_get_dbus_connection(), msg);
return 0;
}
return -ENOMEM;
}
- g_dbus_send_message(connection, msg);
+ g_dbus_send_message(btd_get_dbus_connection(), msg);
return 0;
}
return -ENOMEM;
}
- g_dbus_send_message(connection, msg);
+ g_dbus_send_message(btd_get_dbus_connection(), msg);
return 0;
}
return -ENOMEM;
}
- g_dbus_send_message(connection, msg);
+ g_dbus_send_message(btd_get_dbus_connection(), msg);
return 0;
}
return -ENOMEM;
}
- g_dbus_send_message(connection, msg);
+ g_dbus_send_message(btd_get_dbus_connection(), msg);
return 0;
}
DBusPendingCallNotifyFunction cb,
void *user_data, int type, ...)
{
+ DBusConnection *conn = btd_get_dbus_connection();
DBusMessage *msg;
DBusPendingCall *call;
va_list args;
va_end(args);
if (!cb) {
- g_dbus_send_message(connection, msg);
+ g_dbus_send_message(conn, msg);
return 0;
}
- if (!dbus_connection_send_with_reply(connection, msg, &call, -1)) {
+ if (!dbus_connection_send_with_reply(conn, msg, &call, -1)) {
error("Sending %s failed", method);
dbus_message_unref(msg);
return -EIO;
"path='%s',"
"interface='org.freedesktop.Hal.Device',"
"member='PropertyModified'", path);
- dbus_bus_add_match(connection, match_string, NULL);
+ dbus_bus_add_match(btd_get_dbus_connection(), match_string, NULL);
hal_get_integer(path, "battery.charge_level.last_full", &battchg_last);
hal_get_integer(path, "battery.charge_level.current", &battchg_cur);
int telephony_init(void)
{
+ DBusConnection *conn = btd_get_dbus_connection();
const char *battery_cap = "battery";
uint32_t features = AG_FEATURE_EC_ANDOR_NR |
AG_FEATURE_INBAND_RINGTONE |
AG_FEATURE_EXTENDED_ERROR_RESULT_CODES |
AG_FEATURE_THREE_WAY_CALLING;
- connection = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
-
- if (!dbus_connection_add_filter(connection, signal_filter,
+ if (!dbus_connection_add_filter(conn, signal_filter,
NULL, NULL))
error("Can't add signal filter");
- dbus_bus_add_match(connection,
+ dbus_bus_add_match(conn,
"type=signal,interface=" CSD_CALL_INTERFACE, NULL);
- dbus_bus_add_match(connection,
+ dbus_bus_add_match(conn,
"type=signal,interface=" CSD_CALL_INSTANCE, NULL);
- dbus_bus_add_match(connection,
+ dbus_bus_add_match(conn,
"type=signal,interface=" CSD_CALL_CONFERENCE, NULL);
- dbus_bus_add_match(connection,
+ dbus_bus_add_match(conn,
"type=signal,interface=" NETWORK_INTERFACE, NULL);
- dbus_bus_add_match(connection,
+ dbus_bus_add_match(conn,
"type=signal,interface=" SSC_DBUS_IFACE
",member=modem_state_changed_ind", NULL);
generate_flag_file(NONE_FLAG_FILE);
callerid = callerid_from_file();
- if (!g_dbus_register_interface(connection, TELEPHONY_MAEMO_PATH,
+ if (!g_dbus_register_interface(conn, TELEPHONY_MAEMO_PATH,
TELEPHONY_MAEMO_INTERFACE, telephony_maemo_methods,
NULL, NULL, NULL, NULL)) {
error("telephony-maemo interface %s init failed on path %s",
g_slist_free(calls);
calls = NULL;
- dbus_connection_remove_filter(connection, signal_filter, NULL);
-
- dbus_connection_unref(connection);
- connection = NULL;
+ dbus_connection_remove_filter(btd_get_dbus_connection(),
+ signal_filter, NULL);
telephony_deinit();
}
diff --git a/audio/telephony-maemo6.c b/audio/telephony-maemo6.c
index 0727ffe..d000a2a 100644
--- a/audio/telephony-maemo6.c
+++ b/audio/telephony-maemo6.c
#include <bluetooth/sdp.h>
+#include "dbus-common.h"
#include "log.h"
#include "telephony.h"
#include "error.h"
static int get_property(const char *iface, const char *prop);
-static DBusConnection *connection = NULL;
-
static GSList *calls = NULL;
static GSList *watches = NULL;
static GSList *pending = NULL;
DBusPendingCallNotifyFunction cb,
void *user_data, int type, ...)
{
+ DBusConnection *conn = btd_get_dbus_connection();
DBusMessage *msg;
DBusPendingCall *call;
va_list args;
va_end(args);
if (!cb) {
- g_dbus_send_message(connection, msg);
+ g_dbus_send_message(conn, msg);
return 0;
}
- if (!dbus_connection_send_with_reply(connection, msg, &call, -1)) {
+ if (!dbus_connection_send_with_reply(conn, msg, &call, -1)) {
error("Sending %s failed", method);
dbus_message_unref(msg);
return -EIO;
return -ENOMEM;
}
- g_dbus_send_message(connection, msg);
+ g_dbus_send_message(btd_get_dbus_connection(), msg);
return 0;
}
return -ENOMEM;
}
- g_dbus_send_message(connection, msg);
+ g_dbus_send_message(btd_get_dbus_connection(), msg);
return 0;
}
return -ENOMEM;
}
- g_dbus_send_message(connection, msg);
+ g_dbus_send_message(btd_get_dbus_connection(), msg);
return 0;
}
return -ENOMEM;
}
- g_dbus_send_message(connection, msg);
+ g_dbus_send_message(btd_get_dbus_connection(), msg);
return 0;
}
return -ENOMEM;
}
- g_dbus_send_message(connection, msg);
+ g_dbus_send_message(btd_get_dbus_connection(), msg);
return 0;
}
return -ENOMEM;
}
- g_dbus_send_message(connection, msg);
+ g_dbus_send_message(btd_get_dbus_connection(), msg);
return 0;
}
return -ENOMEM;
}
- g_dbus_send_message(connection, msg);
+ g_dbus_send_message(btd_get_dbus_connection(), msg);
return 0;
}
return -ENOMEM;
}
- g_dbus_send_message(connection, msg);
+ g_dbus_send_message(btd_get_dbus_connection(), msg);
return 0;
}
return -ENOMEM;
}
- g_dbus_send_message(connection, msg);
+ g_dbus_send_message(btd_get_dbus_connection(), msg);
return 0;
}
{
guint watch;
- watch = g_dbus_add_signal_watch(connection, sender, path, interface,
+ watch = g_dbus_add_signal_watch(btd_get_dbus_connection(),
+ sender, path, interface,
member, signal_filter, NULL, NULL);
watches = g_slist_prepend(watches, GUINT_TO_POINTER(watch));
DBG("");
- connection = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
-
add_watch(NULL, NULL, CSD_CALL_INTERFACE, NULL);
add_watch(NULL, NULL, CSD_CALL_INSTANCE, NULL);
add_watch(NULL, NULL, CSD_CALL_CONFERENCE, NULL);
static void remove_watch(gpointer data)
{
- g_dbus_remove_watch(connection, GPOINTER_TO_UINT(data));
+ g_dbus_remove_watch(btd_get_dbus_connection(), GPOINTER_TO_UINT(data));
}
void telephony_exit(void)
g_slist_free_full(watches, remove_watch);
watches = NULL;
- dbus_connection_unref(connection);
- connection = NULL;
-
telephony_deinit();
}
diff --git a/audio/telephony-ofono.c b/audio/telephony-ofono.c
index 961fedd..f962c7e 100644
--- a/audio/telephony-ofono.c
+++ b/audio/telephony-ofono.c
#include <bluetooth/sdp.h>
+#include "dbus-common.h"
#include "log.h"
#include "telephony.h"
guint watch;
};
-static DBusConnection *connection = NULL;
static char *modem_obj_path = NULL;
static char *last_dialed_number = NULL;
static GSList *calls = NULL;
DBusPendingCallNotifyFunction cb,
void *user_data, int type, ...)
{
+ DBusConnection *conn = btd_get_dbus_connection();
DBusMessage *msg;
DBusPendingCall *call;
va_list args;
va_end(args);
if (!cb) {
- g_dbus_send_message(connection, msg);
+ g_dbus_send_message(conn, msg);
return 0;
}
- if (!dbus_connection_send_with_reply(connection, msg, &call, -1)) {
+ if (!dbus_connection_send_with_reply(conn, msg, &call, -1)) {
error("Sending %s failed", method);
dbus_message_unref(msg);
return -EIO;
if (vc->status == CALL_STATUS_INCOMING)
telephony_calling_stopped_ind();
- g_dbus_remove_watch(connection, vc->watch);
+ g_dbus_remove_watch(btd_get_dbus_connection(), vc->watch);
g_free(vc->obj_path);
g_free(vc->number);
g_free(vc);
vc = g_new0(struct voice_call, 1);
vc->obj_path = g_strdup(path);
- vc->watch = g_dbus_add_signal_watch(connection, NULL, path,
+ vc->watch = g_dbus_add_signal_watch(btd_get_dbus_connection(),
+ NULL, path,
OFONO_VC_INTERFACE, "PropertyChanged",
handle_vc_property_changed, vc, NULL);
{
guint watch;
- watch = g_dbus_add_signal_watch(connection, sender, path, interface,
+ watch = g_dbus_add_signal_watch(btd_get_dbus_connection(),
+ sender, path, interface,
member, function, NULL, NULL);
watches = g_slist_prepend(watches, GUINT_TO_POINTER(watch));
int ret;
guint watch;
- connection = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
-
add_watch(OFONO_BUS_NAME, NULL, OFONO_MODEM_INTERFACE,
"PropertyChanged", handle_modem_property_changed);
add_watch(OFONO_BUS_NAME, NULL, OFONO_NETWORKREG_INTERFACE,
add_watch(OFONO_BUS_NAME, NULL, OFONO_VCMANAGER_INTERFACE,
"CallRemoved", handle_vcmanager_call_removed);
- watch = g_dbus_add_service_watch(connection, OFONO_BUS_NAME,
+ watch = g_dbus_add_service_watch(btd_get_dbus_connection(),
+ OFONO_BUS_NAME,
handle_service_connect,
handle_service_disconnect,
NULL, NULL);
static void remove_watch(gpointer data)
{
- g_dbus_remove_watch(connection, GPOINTER_TO_UINT(data));
+ g_dbus_remove_watch(btd_get_dbus_connection(), GPOINTER_TO_UINT(data));
}
static void pending_free(void *data)
g_slist_free_full(pending, pending_free);
pending = NULL;
- dbus_connection_unref(connection);
- connection = NULL;
-
telephony_deinit();
}
diff --git a/audio/transport.c b/audio/transport.c
index 6541fc1..aed9f9a 100644
--- a/audio/transport.c
+++ b/audio/transport.c
};
struct media_transport {
- DBusConnection *conn;
char *path; /* Transport object path */
struct audio_device *device; /* Transport device */
struct media_endpoint *endpoint; /* Transport endpoint */
source_remove_state_cb(transport->source_watch);
path = g_strdup(transport->path);
- g_dbus_unregister_interface(transport->conn, path,
+ g_dbus_unregister_interface(btd_get_dbus_connection(), path,
MEDIA_TRANSPORT_INTERFACE);
g_free(path);
return req;
}
-static void media_request_reply(struct media_request *req,
- DBusConnection *conn, int err)
+static void media_request_reply(struct media_request *req, int err)
{
DBusMessage *reply;
ERROR_INTERFACE ".Failed",
"%s", strerror(err));
- g_dbus_send_message(conn, reply);
+ g_dbus_send_message(btd_get_dbus_connection(), reply);
}
static gboolean media_transport_release(struct media_transport *transport,
/* Reply if owner has a pending request */
if (owner->pending)
- media_request_reply(owner->pending, transport->conn, EIO);
+ media_request_reply(owner->pending, EIO);
transport->owners = g_slist_remove(transport->owners, owner);
if (owner->watch)
- g_dbus_remove_watch(transport->conn, owner->watch);
+ g_dbus_remove_watch(btd_get_dbus_connection(), owner->watch);
media_owner_free(owner);
if ((owner->lock & TRANSPORT_LOCK_WRITE) == 0)
omtu = 0;
- ret = g_dbus_send_reply(transport->conn, req->msg,
+ ret = g_dbus_send_reply(btd_get_dbus_connection(), req->msg,
DBUS_TYPE_UNIX_FD, &fd,
DBUS_TYPE_UINT16, &imtu,
DBUS_TYPE_UINT16, &omtu,
/* Release always succeeds */
if (owner->pending) {
owner->pending->id = 0;
- media_request_reply(owner->pending, transport->conn, 0);
+ media_request_reply(owner->pending, 0);
media_owner_remove(owner);
}
if ((owner->lock & TRANSPORT_LOCK_WRITE) == 0)
omtu = 0;
- ret = g_dbus_send_reply(transport->conn, req->msg,
+ ret = g_dbus_send_reply(btd_get_dbus_connection(), req->msg,
DBUS_TYPE_UNIX_FD, &fd,
DBUS_TYPE_UINT16, &imtu,
DBUS_TYPE_UINT16, &omtu,
/* Release always succeeds */
if (owner->pending) {
owner->pending->id = 0;
- media_request_reply(owner->pending, transport->conn, 0);
+ media_request_reply(owner->pending, 0);
media_owner_remove(owner);
}
if ((owner->lock & TRANSPORT_LOCK_WRITE) == 0)
omtu = 0;
- ret = g_dbus_send_reply(transport->conn, req->msg,
+ ret = g_dbus_send_reply(btd_get_dbus_connection(), req->msg,
DBUS_TYPE_UNIX_FD, &fd,
DBUS_TYPE_UINT16, &imtu,
DBUS_TYPE_UINT16, &omtu,
/* Release always succeeds */
if (owner->pending) {
owner->pending->id = 0;
- media_request_reply(owner->pending, transport->conn, 0);
+ media_request_reply(owner->pending, 0);
media_owner_remove(owner);
}
DBG("Transport %s Owner %s", transport->path, owner->name);
transport->owners = g_slist_append(transport->owners, owner);
owner->transport = transport;
- owner->watch = g_dbus_add_disconnect_watch(transport->conn, owner->name,
+ owner->watch = g_dbus_add_disconnect_watch(btd_get_dbus_connection(),
+ owner->name,
media_owner_exit,
owner, NULL);
}
-static struct media_owner *media_owner_create(DBusConnection *conn,
- DBusMessage *msg,
+static struct media_owner *media_owner_create(DBusMessage *msg,
transport_lock_t lock)
{
struct media_owner *owner;
if (media_transport_acquire(transport, lock) == FALSE)
return btd_error_not_authorized(msg);
- owner = media_owner_create(conn, msg, lock);
+ owner = media_owner_create(msg, lock);
id = transport->resume(transport, owner);
if (id == 0) {
media_transport_release(transport, lock);
if (transport->destroy != NULL)
transport->destroy(transport->data);
- if (transport->conn)
- dbus_connection_unref(transport->conn);
-
g_free(transport->configuration);
g_free(transport->path);
g_free(transport);
transport_update_playing(transport, FALSE);
}
-struct media_transport *media_transport_create(DBusConnection *conn,
- struct media_endpoint *endpoint,
+struct media_transport *media_transport_create(struct media_endpoint *endpoint,
struct audio_device *device,
uint8_t *configuration,
size_t size)
static int fd = 0;
transport = g_new0(struct media_transport, 1);
- transport->conn = dbus_connection_ref(conn);
transport->device = device;
transport->endpoint = endpoint;
transport->configuration = g_new(uint8_t, size);
} else
goto fail;
- if (g_dbus_register_interface(transport->conn, transport->path,
- MEDIA_TRANSPORT_INTERFACE,
+ if (g_dbus_register_interface(btd_get_dbus_connection(),
+ transport->path, MEDIA_TRANSPORT_INTERFACE,
transport_methods, transport_signals, NULL,
transport, media_transport_free) == FALSE) {
error("Could not register transport %s", transport->path);
diff --git a/audio/transport.h b/audio/transport.h
index d20c327..a6b71e5 100644
--- a/audio/transport.h
+++ b/audio/transport.h
struct media_transport;
-struct media_transport *media_transport_create(DBusConnection *conn,
- struct media_endpoint *endpoint,
+struct media_transport *media_transport_create(struct media_endpoint *endpoint,
struct audio_device *device,
uint8_t *configuration,
size_t size);