mirrors/pulseaudio
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pulseaudio/pulseaudio.git synced 2025-11-04 13:29:59 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

temporary commit of lennarts new bt changes

Browse source
This commit is contained in:
Lennart Poettering 2009-01-29 16:27:27 +01:00
parent 47a9b96b64
commit a71fa021a3
3 changed files with 530 additions and 941 deletions
Download patch file Download diff file Expand all files Collapse all files

21
src/Makefile.am
View file

@ -1003,9 +1003,11 @@ if HAVE_BLUEZ
modlibexec_LTLIBRARIES += \
module-bluetooth-proximity.la \
module-bluetooth-discover.la \
libbluetooth-util.la \
libbluetooth-ipc.la \
libbluetooth-sbc.la \
module-bluetooth-device.la
libbluetooth-sbc.la
#\
# module-bluetooth-device.la
pulselibexec_PROGRAMS += \
proximity-helper
@ -1445,7 +1447,7 @@ proximity_helper_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS)
# Bluetooth sink / source
module_bluetooth_discover_la_SOURCES = modules/bluetooth/module-bluetooth-discover.c
module_bluetooth_discover_la_LDFLAGS = $(MODULE_LDFLAGS)
module_bluetooth_discover_la_LIBADD = $(AM_LIBADD) $(DBUS_LIBS) libpulsecore-@PA_MAJORMINORMICRO@.la libdbus-util.la libpulsecommon-@PA_MAJORMINORMICRO@.la libpulse.la
module_bluetooth_discover_la_LIBADD = $(AM_LIBADD) $(DBUS_LIBS) libpulsecore-@PA_MAJORMINORMICRO@.la libdbus-util.la libbluetooth-util.la libpulsecommon-@PA_MAJORMINORMICRO@.la libpulse.la
module_bluetooth_discover_la_CFLAGS = $(AM_CFLAGS) $(DBUS_CFLAGS)
libbluetooth_sbc_la_SOURCES = modules/bluetooth/sbc.c modules/bluetooth/sbc.h modules/bluetooth/sbc_tables.h modules/bluetooth/sbc_math.h
@ -1459,10 +1461,15 @@ libbluetooth_ipc_la_LDFLAGS = -avoid-version
libbluetooth_ipc_la_LIBADD = $(AM_LIBADD)libpulsecore-@PA_MAJORMINORMICRO@.la libpulsecommon-@PA_MAJORMINORMICRO@.la libpulse.la
libbluetooth_ipc_la_CFLAGS = $(AM_CFLAGS) -w
module_bluetooth_device_la_SOURCES = modules/bluetooth/module-bluetooth-device.c modules/bluetooth/rtp.h
module_bluetooth_device_la_LDFLAGS = $(MODULE_LDFLAGS)
module_bluetooth_device_la_LIBADD = $(AM_LIBADD) $(DBUS_LIBS) libpulsecore-@PA_MAJORMINORMICRO@.la libdbus-util.la libbluetooth-ipc.la libbluetooth-sbc.la libpulsecommon-@PA_MAJORMINORMICRO@.la libpulse.la
module_bluetooth_device_la_CFLAGS = $(AM_CFLAGS) $(DBUS_CFLAGS) -w
libbluetooth_util_la_SOURCES = modules/bluetooth/bluetooth-util.c modules/bluetooth/bluetooth-util.h
libbluetooth_util_la_LDFLAGS = -avoid-version
libbluetooth_util_la_LIBADD = $(AM_LIBADD) $(DBUS_LIBS) libpulsecore-@PA_MAJORMINORMICRO@.la libpulsecommon-@PA_MAJORMINORMICRO@.la libpulse.la libdbus-util.la
libbluetooth_util_la_CFLAGS = $(AM_CFLAGS) $(DBUS_CFLAGS)
#module_bluetooth_device_la_SOURCES = modules/bluetooth/module-bluetooth-device.c modules/bluetooth/rtp.h
#module_bluetooth_device_la_LDFLAGS = $(MODULE_LDFLAGS)
#module_bluetooth_device_la_LIBADD = $(AM_LIBADD) $(DBUS_LIBS) libpulsecore-@PA_MAJORMINORMICRO@.la libdbus-util.la libbluetooth-ipc.la libbluetooth-sbc.la libpulsecommon-@PA_MAJORMINORMICRO@.la libpulse.la
#module_bluetooth_device_la_CFLAGS = $(AM_CFLAGS) $(DBUS_CFLAGS) -w
# Apple Airtunes/RAOP
module_raop_sink_la_SOURCES = modules/module-raop-sink.c

565
src/modules/bluetooth/module-bluetooth-device.c
View file

@ -4,17 +4,17 @@
Copyright 2008 Joao Paulo Rechi Vita
PulseAudio is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.
it under the terms of the GNU Lesser General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
PulseAudio is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with PulseAudio; if not, write to the Free Software
You should have received a copy of the GNU Lesser General Public
License along with PulseAudio; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
USA.
***/
@ -44,13 +44,14 @@
#include <pulsecore/time-smoother.h>
#include <pulsecore/rtclock.h>
#include "../dbus-util.h"
#include <modules/dbus-util.h>
#include "module-bluetooth-device-symdef.h"
#include "ipc.h"
#include "sbc.h"
#include "rtp.h"
#include "bluetooth-util.h"
#define DEFAULT_SINK_NAME "bluetooth_sink"
#define BUFFER_SIZE 2048
#define MAX_BITPOOL 64
#define MIN_BITPOOL 2U
@ -63,13 +64,29 @@ PA_MODULE_DESCRIPTION("Bluetooth audio sink and source");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(FALSE);
PA_MODULE_USAGE(
"sink_name=<name of the device> "
"name=<name for the card/sink/source, to be prefixed> "
"card_name=<name for the card> "
"sink_name=<name for the sink> "
"source_name=<name for the source> "
"address=<address of the device> "
"profile=<a2dp|hsp> "
"rate=<sample rate> "
"channels=<number of channels> "
"path=<device object path>");
static const char* const valid_modargs[] = {
"name",
"card_name",
"sink_name",
"source_name",
"address",
"profile",
"rate",
"channels",
"path",
NULL
};
struct bt_a2dp {
sbc_capabilities_t sbc_capabilities;
sbc_t sbc; /* Codec data */
@ -84,6 +101,12 @@ struct bt_a2dp {
unsigned frame_count; /* Current frames in buffer*/
};
enum profile {
PROFILE_A2DP,
PROFILE_SCO,
PROFILE_OFF
};
struct userdata {
pa_core *core;
pa_module *module;
@ -98,33 +121,24 @@ struct userdata {
uint64_t offset;
pa_smoother *smoother;
char *name;
char *addr;
char *profile;
pa_sample_spec ss;
char *address;
pa_sample_spec sample_spec;
int audioservice_fd;
int service_fd;
int stream_fd;
uint8_t transport;
char *strtransport;
size_t link_mtu;
size_t block_size;
pa_usec_t latency;
struct bt_a2dp a2dp;
char *path;
pa_dbus_connection *conn;
};
pa_dbus_connection *connection;
static const char* const valid_modargs[] = {
"sink_name",
"address",
"profile",
"rate",
"channels",
"path",
NULL
enum profile profile;
pa_bluetooth_device *device;
};
static int bt_audioservice_send(int sk, const bt_audio_msg_header_t *msg) {
@ -234,7 +248,7 @@ static int bt_getcaps(struct userdata *u) {
msg.getcaps_req.h.name = BT_GET_CAPABILITIES;
msg.getcaps_req.h.length = sizeof(msg.getcaps_req);
strncpy(msg.getcaps_req.device, u->addr, 18);
strncpy(msg.getcaps_req.device, u->address, 18);
if (pa_streq(u->profile, "a2dp"))
msg.getcaps_req.transport = BT_CAPABILITIES_TRANSPORT_A2DP;
else if (pa_streq(u->profile, "hsp"))
@ -489,7 +503,6 @@ static int bt_setconf(struct userdata *u) {
}
u->transport = msg.setconf_rsp.transport;
u->strtransport = (u->transport == BT_CAPABILITIES_TRANSPORT_A2DP ? pa_xstrdup("A2DP") : pa_xstrdup("SCO"));
u->link_mtu = msg.setconf_rsp.link_mtu;
/* setup SBC encoder now we agree on parameters */
@ -933,18 +946,288 @@ static int source_set_volume_cb(pa_source *s) {
return 0;
}
static char *get_name(const char *type, pa_modargs *ma, const char *device_id, pa_bool_t *namereg_fail) {
char *t;
const char *n;
pa_assert(type);
pa_assert(ma);
pa_assert(device_id);
pa_assert(namereg_fail);
t = pa_sprintf_malloc("%s_name", type);
n = pa_modargs_get_value(ma, t, NULL);
pa_xfree(t);
if (n) {
*namereg_fail = TRUE;
return pa_xstrdup(n);
}
if ((n = pa_modargs_get_value(ma, "name", NULL)))
*namereg_fail = TRUE;
else {
n = device_id;
*namereg_fail = FALSE;
}
return pa_sprintf_malloc("bluez_%s.%s", type, n);
}
static int add_sink(struct userdata *u) {
pa_sink_new_data data;
pa_bool_t b;
pa_sink_new_data_init(&data);
data.driver = __FILE__;
data.module = m;
pa_sink_new_data_set_sample_spec(&data, &u->ss);
pa_proplist_setf(data.proplist, PA_PROP_DEVICE_DESCRIPTION, "Bluetooth %s on %s", u->profile == PROFILE_A2DP ? "A2DP" : "HSP/HFP", u->addr);
pa_proplist_sets(data.proplist, "bluetooth.protocol", u->profile == PROFILE_A2DP ? "a2dp" : "sco");
data.card = u->card;
data.name = get_name("sink", ma, u->addr, &b);
data.namereg_fail = b;
u->sink = pa_sink_new(u->core, &data, PA_SINK_HARDWARE|PA_SINK_LATENCY);
pa_sink_new_data_done(&data);
if (!u->sink) {
pa_log_error("Failed to create sink");
return -1;
}
u->sink->userdata = u;
u->sink->parent.process_msg = sink_process_msg;
u->sink->get_volume = sink_get_volume_cb;
u->sink->set_volume = sink_set_volume_cb;
pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq);
pa_sink_set_rtpoll(u->sink, u->rtpoll);
return 0;
}
static int add_source(struct userdata *u) {
pa_source_new_data data;
pa_bool_t b;
pa_source_new_data_init(&data);
data.driver = __FILE__;
data.module = m;
pa_source_new_data_set_sample_spec(&data, &u->ss);
pa_proplist_setf(data.proplist, PA_PROP_DEVICE_DESCRIPTION, "Bluetooth %s on %s", u->profile == PROFILE_A2DP ? "A2DP" : "HSP/HFP", u->addr);
pa_proplist_sets(data.proplist, "bluetooth.protocol", u->profile == PROFILE_A2DP ? "a2dp" : "sco");
data.card = u->card;
data.name = get_name("source", ma, u->addr, &b);
data.namereg_fail = b;
u->source = pa_source_new(u->core, &data, PA_SOURCE_HARDWARE|PA_SOURCE_LATENCY);
pa_source_new_data_done(&data);
if (!u->source) {
pa_log_error("Failed to create source");
return -1;
}
u->source->userdata = u;
u->source->parent.process_msg = source_process_msg;
u->source->get_volume = source_get_volume_cb;
u->source->set_volume = source_set_volume_cb;
pa_source_set_asyncmsgq(u->source, u->thread_mq.inq);
pa_source_set_rtpoll(u->source, u->rtpoll);
return 0;
}
static void init_profile(struct userdata *u) {
enum profile *d;
pa_assert(u);
if (u->profile == PROFILE_A2DP ||
u->profile == PROFILE_SCO)
add_sink(u);
if (u->profile == PROFILE_SCO)
add_source(u);
}
static int init_bt(struct userdata *u) {
pa_assert(u);
/* connect to the bluez audio service */
if ((u->audioservice_fd = bt_audio_service_open()) < 0) {
pa_log_error("Couldn't connect to bluetooth audio service");
return -1;
}
pa_log_debug("Connected to the bluetooth audio service");
/* queries device capabilities */
if (bt_getcaps(u) < 0) {
pa_log_error("Failed to get device capabilities");
return -1;
}
pa_log_debug("Got device capabilities");
return 0;
}
static setup_bt(struct userdata *u) {
pa_assert(u);
/* configures the connection */
if (bt_setconf(u) < 0) {
pa_log_error("Failed to set config");
return -1;
}
pa_log_debug("Connection to the device configured");
/* gets the device socket */
if (bt_getstreamfd(u) < 0) {
pa_log_error("Failed to get stream fd (%d)", e);
return -1;
}
pa_log_debug("Got the device socket");
}
static int card_set_profile(pa_card *c, pa_card_profile *new_profile) {
struct userdata *u;
enum profile *d;
pa_queue *inputs = NULL, *outputs = NULL;
pa_assert(c);
pa_assert(new_profile);
pa_assert_se(u = c->userdata);
d = PA_CARD_PROFILE_DATA(new_profile);
if (u->sink) {
inputs = pa_sink_move_all_start(u->sink);
pa_sink_unlink(u->sink);
pa_sink_unref(u->sink);
u->sink = NULL;
}
if (u->source) {
outputs = pa_source_move_all_start(u->source);
pa_source_unlink(u->source);
pa_source_unref(u->source);
u->source = NULL;
}
u->profile = *d;
init_profile(u);
if (inputs) {
if (u->sink)
pa_sink_move_all_finish(u->sink, inputs, FALSE);
else
pa_sink_move_all_fail(inputs);
}
if (outputs) {
if (u->source)
pa_source_move_all_finish(u->source, outputs, FALSE);
else
pa_source_move_all_fail(outputs);
}
return 0;
}
static int add_card(struct userdata *u) {
pa_card_new_data data;
pa_bool_t b;
pa_card_profile *p;
enum profile *d;
pa_card_new_data_init(&data);
data.driver = __FILE__;
data.module = u->module;
pa_proplist_sets(data.proplist, PA_PROP_DEVICE_STRING, u->addr);
pa_proplist_setf(data.proplist, PA_PROP_DEVICE_API, "bluez");
pa_proplist_setf(data.proplist, PA_PROP_DEVICE_CLASS, "sound");
pa_proplist_setf(data.proplist, PA_PROP_DEVICE_CONNECTOR, "bluetooth");
/* pa_proplist_setf(data.proplist, PA_PROP_DEVICE_FORM_FACTOR, "headset"); /\*FIXME*\/ */
/* pa_proplist_setf(data.proplist, PA_PROP_DEVICE_VENDOR_PRODUCT_ID, "product_id"); /\*FIXME*\/ */
/* pa_proplist_setf(data.proplist, PA_PROP_DEVICE_SERIAL, "serial"); /\*FIXME*\/ */
data.name = get_name("card", ma, u->addr, &b);
data.namereg_fail = b;
data.profiles = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
if (u->transport == BT_CAPABILITIES_TRANSPORT_A2DP ||
u->transport == BT_CAPABILITIES_TRANSPORT_ANY) {
p = pa_card_profile_new("a2dp", "A2DP Advanced Audio Distribution Profile", sizeof(enum profile));
p->priority = 10;
p->n_sinks = 1;
p->n_sources = 0;
p->max_sink_channels = 2;
p->max_source_channels = 0;
d = PA_CARD_PROFILE_DATA(p);
*d = PROFILE_A2DP;
}
if (u->transport == BT_CAPABILITIES_TRANSPORT_SCO ||
u->transport == BT_CAPABILITIES_TRANSPORT_ANY) {
p = pa_card_profile_new("hsp", "HSP/HFP Headset/Hands-Free Profile", sizeof(enum profile));
p->priority = 20;
p->n_sinks = 1;
p->n_sources = 1;
p->max_sink_channels = 1;
p->max_source_channels = 1;
d = PA_CARD_PROFILE_DATA(p);
*d = PROFILE_SCO;
}
pa_assert(!pa_hashmap_isempty(data.profiles));
p = pa_card_profile_new("off", "Off", sizeof(enum profile));
d = PA_CARD_PROFILE_DATA(p);
*d = PROFILE_OFF;
u->card = pa_card_new(m->core, &data);
pa_card_new_data_done(&data);
if (!u->card) {
pa_log("Failed to allocate card.");
return -1;
}
card->userdata = u;
card->set_profile = card_set_profile;
d = PA_CARD_PROFILE_DATA(u->card->active_profile);
u->profile = *d;
return 0;
}
int pa__init(pa_module* m) {
int e;
pa_modargs *ma;
uint32_t channels;
pa_sink_new_data data;
pa_sink_new_data sink_data;
pa_source_new_data source_data;
pa_card card_data;
struct pollfd *pollfd;
struct userdata *u;
DBusError err;
char *tmp;
pa_bool_t b;
const char *p;
pa_assert(m);
dbus_error_init(&err);
if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
pa_log_error("Failed to parse module arguments");
goto fail;
}
m->userdata = u = pa_xnew0(struct userdata, 1);
u->module = m;
@ -952,157 +1235,109 @@ int pa__init(pa_module* m) {
u->audioservice_fd = -1;
u->stream_fd = -1;
u->transport = (uint8_t) -1;
u->offset = 0;
u->latency = 0;
u->a2dp.sbc_initialized = FALSE;
u->smoother = pa_smoother_new(PA_USEC_PER_SEC, PA_USEC_PER_SEC*2, TRUE, 10);
u->rtpoll = pa_rtpoll_new();
pa_thread_mq_init(&u->thread_mq, u->core->mainloop, u->rtpoll);
u->rtpoll_item = NULL;
u->ss = m->core->default_sample_spec;
u->add_source = m->core->default_sample_spec;
if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
pa_log_error("Failed to parse module arguments");
goto fail;
}
if (!(u->name = pa_xstrdup(pa_modargs_get_value(ma, "sink_name", DEFAULT_SINK_NAME)))) {
pa_log_error("Failed to get device name from module arguments");
goto fail;
}
if (!(u->addr = pa_xstrdup(pa_modargs_get_value(ma, "address", NULL)))) {
if (!(u->address = pa_xstrdup(pa_modargs_get_value(ma, "address", NULL)))) {
pa_log_error("Failed to get device address from module arguments");
goto fail;
}
if (!(u->profile = pa_xstrdup(pa_modargs_get_value(ma, "profile", NULL)))) {
u->path = pa_xstrdup(pa_modargs_get_value(ma, "path", NULL));
p = pa_modargs_get_value(ma, "profile", NULL);
if (p && !pa_streq(p, "hsp") && !pa_streq(p, "a2dp")) {
pa_log_error("Failed to get profile from module arguments");
goto fail;
}
if (pa_modargs_get_value_u32(ma, "rate", &u->ss.rate) < 0) {
if (pa_modargs_get_value_u32(ma, "rate", &u->ss.rate) < 0 ||
u->ss.rate <= 0 || u->ss.rate > PA_RATE_MAX) {
pa_log_error("Failed to get rate from module arguments");
goto fail;
}
u->path = pa_xstrdup(pa_modargs_get_value(ma, "path", NULL));
channels = u->ss.channels;
if (pa_modargs_get_value_u32(ma, "channels", &channels) < 0) {
if (pa_modargs_get_value_u32(ma, "channels", &channels) < 0 ||
channels <= 0 || channels > PA_CHANNELS_MAX) {
pa_log_error("Failed to get channels from module arguments");
goto fail;
}
u->ss.channels = (uint8_t) channels;
/* connect to the bluez audio service */
u->audioservice_fd = bt_audio_service_open();
if (u->audioservice_fd <= 0) {
pa_log_error("Couldn't connect to bluetooth audio service");
/* Connect to the BT service and query capabilities */
if (init_bt(u) < 0)
goto fail;
}
pa_log_debug("Connected to the bluetooth audio service");
/* queries device capabilities */
e = bt_getcaps(u);
if (e < 0) {
pa_log_error("Failed to get device capabilities");
/* Add the card structure. This will also initialize the default profile */
if (add_card(u) < 0)
goto fail;
}
pa_log_debug("Got device capabilities");
/* configures the connection */
e = bt_setconf(u);
if (e < 0) {
pa_log_error("Failed to set config");
goto fail;
}
pa_log_debug("Connection to the device configured");
/* Now configure the the right profile */
if (setup_bt(u) < 0)
/* gets the device socket */
e = bt_getstreamfd(u);
if (e < 0) {
pa_log_error("Failed to get stream fd (%d)", e);
if (init_profile(u) < 0)
goto fail;
}
pa_log_debug("Got the device socket");
/* create sink */
pa_sink_new_data_init(&data);
data.driver = __FILE__;
data.module = m;
pa_sink_new_data_set_name(&data, u->name);
pa_sink_new_data_set_sample_spec(&data, &u->ss);
pa_proplist_sets(data.proplist, PA_PROP_DEVICE_STRING, u->name);
pa_proplist_setf(data.proplist, PA_PROP_DEVICE_DESCRIPTION, "Bluetooth %s '%s' (%s)", u->strtransport, u->name, u->addr);
pa_proplist_sets(data.proplist, "bluetooth.protocol", u->profile);
pa_proplist_setf(data.proplist, PA_PROP_DEVICE_API, "bluez");
pa_proplist_setf(data.proplist, PA_PROP_DEVICE_CLASS, "sound");
pa_proplist_setf(data.proplist, PA_PROP_DEVICE_CONNECTOR, "bluetooth");
/* pa_proplist_setf(data.proplist, PA_PROP_DEVICE_FORM_FACTOR, "headset"); /\*FIXME*\/ */
/* pa_proplist_setf(data.proplist, PA_PROP_DEVICE_VENDOR_PRODUCT_ID, "product_id"); /\*FIXME*\/ */
/* pa_proplist_setf(data.proplist, PA_PROP_DEVICE_SERIAL, "serial"); /\*FIXME*\/ */
u->sink = pa_sink_new(m->core, &data, PA_SINK_HARDWARE|PA_SINK_LATENCY);
pa_sink_new_data_done(&data);
if (!u->sink) {
pa_log_error("Failed to create sink");
if (u->path) {
DBusError err;
dbus_error_init(&err);
char *t;
u->conn = pa_dbus_bus_get(m->core, DBUS_BUS_SYSTEM, &err);
if (dbus_error_is_set(&err) || (!u->conn)) {
pa_log("Failed to get D-Bus connection: %s", err.message);
goto fail;
}
u->sink->userdata = u;
u->sink->parent.process_msg = sink_process_msg;
pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq);
pa_sink_set_rtpoll(u->sink, u->rtpoll);
if (!dbus_connection_add_filter(pa_dbus_connection_get(u->conn), filter_cb, u, NULL)) {
pa_log_error("Failed to add filter function");
goto fail;
}
if (u->transport == BT_CAPABILITIES_TRANSPORT_SCO ||
u->transport == BT_CAPABILITIES_TRANSPORT_ANY) {
t = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='PropertyChanged',path='%s'", u->path);
dbus_bus_add_match(pa_dbus_connection_get(u->conn), t, &err);
pa_xfree(t);
if (dbus_error_is_set(&err)) {
pa_log_error("Unable to subscribe to org.bluez.Headset signals: %s: %s", err.name, err.message);
goto fail;
}
}
if (u->transport == BT_CAPABILITIES_TRANSPORT_A2DP ||
u->transport == BT_CAPABILITIES_TRANSPORT_ANY) {
t = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.AudioSink',member='PropertyChanged',path='%s'", u->path);
dbus_bus_add_match(pa_dbus_connection_get(u->conn), t, &err);
pa_xfree(t);
if (dbus_error_is_set(&err)) {
pa_log_error("Unable to subscribe to org.bluez.AudioSink signals: %s: %s", err.name, err.message);
goto fail;
}
}
}
u->rtpoll_item = pa_rtpoll_item_new(u->rtpoll, PA_RTPOLL_NEVER, 1);
pollfd = pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL);
pollfd->fd = u->stream_fd;
pollfd->events = pollfd->revents = 0;
/* start rt thread */
if (!(u->thread = pa_thread_new(thread_func, u))) {
pa_log_error("Failed to create IO thread");
goto fail;
}
if (u->sink)
pa_sink_put(u->sink);
if (!u->path)
goto end;
/* connect to the bus */
u->conn = pa_dbus_bus_get(m->core, DBUS_BUS_SYSTEM, &err);
if (dbus_error_is_set(&err) || (u->conn == NULL) ) {
pa_log("Failed to get D-Bus connection: %s", err.message);
goto fail;
}
if (u->source)
pa_sink_put(u->source);
/* monitor property changes */
if (!dbus_connection_add_filter(pa_dbus_connection_get(u->conn), filter_cb, u, NULL)) {
pa_log_error("Failed to add filter function");
goto fail;
}
if (pa_streq(u->profile, "hsp")) {
tmp = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='PropertyChanged',path='%s'", u->path);
dbus_bus_add_match(pa_dbus_connection_get(u->conn), tmp, &err);
pa_xfree(tmp);
if (dbus_error_is_set(&err)) {
pa_log_error("Unable to subscribe to org.bluez.Headset signals: %s: %s", err.name, err.message);
goto fail;
}
} else {
tmp = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.AudioSink',member='PropertyChanged',path='%s'", u->path);
dbus_bus_add_match(pa_dbus_connection_get(u->conn), tmp, &err);
pa_xfree(tmp);
if (dbus_error_is_set(&err)) {
pa_log_error("Unable to subscribe to org.bluez.AudioSink signals: %s: %s", err.name, err.message);
goto fail;
}
}
u->sink->get_volume = sink_get_volume_cb;
u->sink->set_volume = sink_set_volume_cb;
if (u->source) {
u->source->get_volume = source_get_volume_cb;
u->source->set_volume = source_set_volume_cb;
}
end:
pa_modargs_free(ma);
return 0;
@ -1114,6 +1349,17 @@ fail:
return -1;
}
int pa__get_n_used(pa_module *m) {
struct userdata *u;
pa_assert(m);
pa_assert_se(u = m->userdata);
return
(u->sink ? pa_sink_linked_by(u->sink) : 0) +
(u->source ? pa_source_linked_by(u->source) : 0);
}
void pa__done(pa_module *m) {
struct userdata *u;
pa_assert(m);
@ -1123,23 +1369,29 @@ void pa__done(pa_module *m) {
if (u->conn) {
DBusError error;
char *tmp;
dbus_error_init(&error);
char *t;
if (pa_streq(u->profile, "hsp")) {
tmp = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='PropertyChanged',path='%s'", u->path);
dbus_bus_remove_match(pa_dbus_connection_get(u->conn), tmp, &error);
pa_xfree(tmp);
if (u->transport == BT_CAPABILITIES_TRANSPORT_SCO ||
u->transport == BT_CAPABILITIES_TRANSPORT_ANY) {
t = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='PropertyChanged',path='%s'", u->path);
dbus_error_init(&error);
dbus_bus_remove_match(pa_dbus_connection_get(u->conn), t, &error);
dbus_error_free(&error);
} else {
tmp = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.AudioSink',member='PropertyChanged',path='%s'", u->path);
dbus_bus_remove_match(pa_dbus_connection_get(u->conn), tmp, &error);
pa_xfree(tmp);
pa_xfree(t);
}
if (u->transport == BT_CAPABILITIES_TRANSPORT_A2DP ||
u->transport == BT_CAPABILITIES_TRANSPORT_ANY) {
t = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.AudioSink',member='PropertyChanged',path='%s'", u->path);
dbus_error_init(&error);
dbus_bus_remove_match(pa_dbus_connection_get(u->conn), t, &error);
dbus_error_free(&error);
pa_xfree(t);
}
dbus_connection_remove_filter(pa_dbus_connection_get(u->conn), filter_cb, u);
pa_dbus_connection_unref(u->conn);
}
@ -1149,6 +1401,9 @@ void pa__done(pa_module *m) {
if (u->sink)
pa_sink_unlink(u->sink);
if (u->source)
pa_source_unlink(u->source);
if (u->thread) {
pa_asyncmsgq_send(u->thread_mq.inq, NULL, PA_MESSAGE_SHUTDOWN, NULL, 0, NULL);
pa_thread_free(u->thread);
@ -1157,6 +1412,12 @@ void pa__done(pa_module *m) {
if (u->sink)
pa_sink_unref(u->sink);
if (u->source)
pa_source_unref(u->source);
if (u->card)
pa_card_unref(u->card);
pa_thread_mq_done(&u->thread_mq);
if (u->rtpoll_item)
@ -1177,7 +1438,7 @@ void pa__done(pa_module *m) {
pa_close(u->stream_fd);
if (u->audioservice_fd >= 0)
pa_close(u->audioservice_fd);
pa_close(u->service_fd);
pa_xfree(u);
}

853
src/modules/bluetooth/module-bluetooth-discover.c
View file

@ -4,17 +4,17 @@
Copyright 2008 Joao Paulo Rechi Vita
PulseAudio is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.
it under the terms of the GNU Lesser General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
PulseAudio is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with PulseAudio; if not, write to the Free Software
You should have received a copy of the GNU Lesser General Public
License along with PulseAudio; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
USA.
***/
@ -29,817 +29,138 @@
#include <pulse/xmalloc.h>
#include <pulsecore/module.h>
#include <pulsecore/core-util.h>
#include <pulsecore/modargs.h>
#include <pulsecore/macro.h>
#include <pulsecore/llist.h>
#include <pulsecore/core-util.h>
#include <modules/dbus-util.h>
#include "../dbus-util.h"
#include "module-bluetooth-discover-symdef.h"
#include "bluetooth-util.h"
PA_MODULE_AUTHOR("Joao Paulo Rechi Vita");
PA_MODULE_DESCRIPTION("Detect available bluetooth audio devices and load bluetooth audio drivers");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_USAGE("");
PA_MODULE_USAGE("async=<Asynchronous initialization?>");
struct module {
char *profile;
uint32_t index;
PA_LLIST_FIELDS(struct module);
};
struct uuid {
char *uuid;
PA_LLIST_FIELDS(struct uuid);
};
struct dbus_pending {
char *path;
char *profile;
DBusPendingCall *pending;
PA_LLIST_FIELDS(struct dbus_pending);
};
struct device {
char *name;
char *object_path;
int paired;
char *alias;
int connected;
PA_LLIST_HEAD(struct uuid, uuid_list);
char *address;
int class;
int trusted;
PA_LLIST_HEAD(struct module, module_list);
PA_LLIST_FIELDS(struct device);
static const char* const valid_modargs[] = {
"async",
NULL
};
struct userdata {
pa_module *module;
pa_dbus_connection *conn;
dbus_int32_t dbus_data_slot;
PA_LLIST_HEAD(struct device, device_list);
PA_LLIST_HEAD(struct dbus_pending, dbus_pending_list);
pa_core *core;
pa_dbus_connection *connection;
pa_bluetooth_discovery *discovery;
};
static struct module *module_new(const char *profile, pa_module *pa_m) {
struct module *m;
m = pa_xnew(struct module, 1);
m->profile = pa_xstrdup(profile);
m->index = pa_m->index;
PA_LLIST_INIT(struct module, m);
return m;
}
static void module_free(struct module *m) {
pa_assert(m);
pa_xfree(m->profile);
pa_xfree(m);
}
static struct module* module_find(struct device *d, const char *profile) {
struct module *m;
for (m = d->module_list; m; m = m->next)
if (pa_streq(m->profile, profile))
return m;
return NULL;
}
static struct uuid *uuid_new(const char *uuid) {
struct uuid *node;
node = pa_xnew(struct uuid, 1);
node->uuid = pa_xstrdup(uuid);
PA_LLIST_INIT(struct uuid, node);
return node;
}
static void uuid_free(struct uuid *uuid) {
pa_assert(uuid);
pa_xfree(uuid->uuid);
pa_xfree(uuid);
}
static struct dbus_pending *dbus_pending_new(struct userdata *u, DBusPendingCall *pending, const char *path, const char *profile) {
struct dbus_pending *node;
pa_assert(pending);
node = pa_xnew(struct dbus_pending, 1);
node->pending = pending;
node->path = pa_xstrdup(path);
node->profile = pa_xstrdup(profile);
PA_LLIST_INIT(struct dbus_pending, node);
dbus_pending_call_set_data(pending, u->dbus_data_slot, node, NULL);
return node;
}
static void dbus_pending_free(struct dbus_pending *pending) {
pa_assert(pending);
pa_xfree(pending->path);
pa_xfree(pending->profile);
dbus_pending_call_cancel(pending->pending);
dbus_pending_call_unref(pending->pending);
pa_xfree(pending);
}
static struct device *device_new(const char *object_path) {
struct device *node;
node = pa_xnew(struct device, 1);
node->name = NULL;
node->object_path = pa_xstrdup(object_path);
node->paired = -1;
node->alias = NULL;
node->connected = -1;
PA_LLIST_HEAD_INIT(struct uuid, node->uuid_list);
node->address = NULL;
node->class = -1;
node->trusted = -1;
PA_LLIST_HEAD_INIT(struct module, node->module_list);
PA_LLIST_INIT(struct device, node);
return node;
}
static void device_free(struct device *device) {
struct module *m;
struct uuid *i;
pa_assert(device);
while ((m = device->module_list)) {
PA_LLIST_REMOVE(struct module, device->module_list, m);
module_free(m);
}
while ((i = device->uuid_list)) {
PA_LLIST_REMOVE(struct uuid, device->uuid_list, i);
uuid_free(i);
}
pa_xfree(device->name);
pa_xfree(device->object_path);
pa_xfree(device->alias);
pa_xfree(device->address);
pa_xfree(device);
}
static struct device* device_find(struct userdata *u, const char *path) {
struct device *i;
for (i = u->device_list; i; i = i->next)
if (pa_streq(i->object_path, path))
return i;
return NULL;
}
static int parse_device_property(struct userdata *u, struct device *d, DBusMessageIter *i) {
const char *key;
DBusMessageIter variant_i;
static void load_module_for_device(struct userdata *u, pa_bluetooth_device *d, pa_bool_t good) {
pa_assert(u);
pa_assert(d);
pa_assert(i);
if (dbus_message_iter_get_arg_type(i) != DBUS_TYPE_STRING) {
pa_log("Property name not a string.");
if (good &&
d->device_connected > 0 &&
(d->audio_sink_connected > 0 || d->headset_connected > 0)) {
if (PA_PTR_TO_UINT(d->data) == PA_INVALID_INDEX) {
pa_module *m = NULL;
char *args;
/* Oh, awesome, a new device has shown up and been connected! */
args = pa_sprintf_malloc("name=\"%s\" address=\"%s\" path=\"%s\"", d->address, d->address, d->path);
pa_log_debug("Loading module-bluetooth-device %s", args);
/* m = pa_module_load(u->module->core, "module-bluetooth-device", args); */
pa_xfree(args);
if (m)
d->data = PA_UINT_TO_PTR(m->index);
else
pa_log_debug("Failed to load module for device %s", d->path);
}
} else {
if (PA_PTR_TO_UINT(d->data) != PA_INVALID_INDEX) {
/* Hmm, disconnection? Then let's unload our module */
pa_log_debug("Unloading module for %s", d->path);
/* pa_module_unload_request_by_index(u->core, PA_PTR_TO_UINT(d->data), TRUE); */
d->data = NULL;
}
}
}
static int setup_dbus(struct userdata *u) {
DBusError err;
dbus_error_init(&err);
u->connection = pa_dbus_bus_get(u->core, DBUS_BUS_SYSTEM, &err);
if (dbus_error_is_set(&err) || !u->connection) {
pa_log("Failed to get D-Bus connection: %s", err.message);
dbus_error_free(&err);
return -1;
}
dbus_message_iter_get_basic(i, &key);
if (!dbus_message_iter_next(i)) {
pa_log("Property value missing");
return -1;
}
if (dbus_message_iter_get_arg_type(i) != DBUS_TYPE_VARIANT) {
pa_log("Property value not a variant.");
return -1;
}
dbus_message_iter_recurse(i, &variant_i);
pa_log_debug("Parsing device property %s", key);
switch (dbus_message_iter_get_arg_type(&variant_i)) {
case DBUS_TYPE_STRING: {
const char *value;
dbus_message_iter_get_basic(&variant_i, &value);
if (pa_streq(key, "Name")) {
pa_xfree(d->name);
d->name = pa_xstrdup(value);
} else if (pa_streq(key, "Alias")) {
pa_xfree(d->alias);
d->alias = pa_xstrdup(value);
} else if (pa_streq(key, "Address")) {
pa_xfree(d->address);
d->address = pa_xstrdup(value);
}
break;
}
case DBUS_TYPE_BOOLEAN: {
dbus_bool_t value;
dbus_message_iter_get_basic(&variant_i, &value);
if (pa_streq(key, "Paired"))
d->paired = !!value;
else if (pa_streq(key, "Connected"))
d->connected = !!value;
else if (pa_streq(key, "Trusted"))
d->trusted = !!value;
break;
}
case DBUS_TYPE_UINT32: {
uint32_t value;
dbus_message_iter_get_basic(&variant_i, &value);
if (pa_streq(key, "Class"))
d->class = (int) value;
break;
}
case DBUS_TYPE_ARRAY: {
DBusMessageIter ai;
dbus_message_iter_recurse(&variant_i, &ai);
if (dbus_message_iter_get_arg_type(&ai) == DBUS_TYPE_STRING &&
pa_streq(key, "UUIDs")) {
while (dbus_message_iter_get_arg_type(&ai) != DBUS_TYPE_INVALID) {
struct uuid *node;
const char *value;
dbus_message_iter_get_basic(&ai, &value);
node = uuid_new(value);
PA_LLIST_PREPEND(struct uuid, d->uuid_list, node);
if (!dbus_message_iter_next(&ai))
break;
}
}
break;
}
}
return 0;
}
static int get_device_properties(struct userdata *u, struct device *d) {
DBusError e;
DBusMessage *m = NULL, *r = NULL;
DBusMessageIter arg_i, element_i;
int ret = -1;
pa_assert(u);
pa_assert(d);
dbus_error_init(&e);
pa_assert_se(m = dbus_message_new_method_call("org.bluez", d->object_path, "org.bluez.Device", "GetProperties"));
r = dbus_connection_send_with_reply_and_block(pa_dbus_connection_get(u->conn), m, -1, &e);
if (!r) {
pa_log("org.bluez.Device.GetProperties failed: %s", e.message);
goto finish;
}
if (!dbus_message_iter_init(r, &arg_i)) {
pa_log("org.bluez.Device.GetProperties reply has no arguments");
goto finish;
}
if (dbus_message_iter_get_arg_type(&arg_i) != DBUS_TYPE_ARRAY) {
pa_log("org.bluez.Device.GetProperties argument is not an array");
goto finish;
}
dbus_message_iter_recurse(&arg_i, &element_i);
while (dbus_message_iter_get_arg_type(&element_i) != DBUS_TYPE_INVALID) {
if (dbus_message_iter_get_arg_type(&element_i) == DBUS_TYPE_DICT_ENTRY) {
DBusMessageIter dict_i;
dbus_message_iter_recurse(&element_i, &dict_i);
if (parse_device_property(u, d, &dict_i) < 0)
goto finish;
}
if (!dbus_message_iter_next(&element_i))
break;
}
ret = 0;
finish:
if (m)
dbus_message_unref(m);
if (r)
dbus_message_unref(r);
dbus_error_free(&e);
return ret;
}
static void load_module_for_device(struct userdata *u, struct device *d, const char *profile) {
char *args;
pa_module *pa_m;
struct module *m;
pa_assert(u);
pa_assert(d);
get_device_properties(u, d);
args = pa_sprintf_malloc("sink_name=\"%s\" address=\"%s\" profile=\"%s\" path=\"%s\"", d->name, d->address, profile, d->object_path);
pa_m = pa_module_load(u->module->core, "module-bluetooth-device", args);
pa_xfree(args);
if (!pa_m) {
pa_log_debug("Failed to load module for device %s", d->object_path);
return;
}
m = module_new(profile, pa_m);
PA_LLIST_PREPEND(struct module, d->module_list, m);
}
static void unload_module_for_device(struct userdata *u, struct device *d, const char *profile) {
struct module *m;
pa_assert(u);
pa_assert(d);
if (!(m = module_find(d, profile)))
return;
pa_module_unload_request_by_index(u->module->core, m->index, TRUE);
PA_LLIST_REMOVE(struct module, d->module_list, m);
module_free(m);
}
static DBusHandlerResult filter_cb(DBusConnection *bus, DBusMessage *msg, void *userdata) {
DBusMessageIter arg_i;
DBusError err;
const char *value;
int pa__init(pa_module* m) {
struct userdata *u;
pa_modargs *ma;
pa_bool_t async = FALSE;
pa_assert(bus);
pa_assert(msg);
pa_assert(userdata);
u = userdata;
pa_assert(m);
dbus_error_init(&err);
pa_log_debug("dbus: interface=%s, path=%s, member=%s\n",
dbus_message_get_interface(msg),
dbus_message_get_path(msg),
dbus_message_get_member(msg));
if (dbus_message_is_signal(msg, "org.bluez.Adapter", "DeviceRemoved")) {
if (!dbus_message_iter_init(msg, &arg_i))
pa_log("dbus: message has no parameters");
else if (dbus_message_iter_get_arg_type(&arg_i) != DBUS_TYPE_OBJECT_PATH)
pa_log("dbus: argument is not object path");
else {
struct device *d;
dbus_message_iter_get_basic(&arg_i, &value);
pa_log_debug("hcid: device %s removed", value);
if ((d = device_find(u, value))) {
PA_LLIST_REMOVE(struct device, u->device_list, d);
device_free(d);
}
if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
pa_log("Failed to parse module arguments");
goto fail;
}
} else if (dbus_message_is_signal(msg, "org.bluez.Headset", "PropertyChanged") ||
dbus_message_is_signal(msg, "org.bluez.AudioSink", "PropertyChanged")) {
struct device *d;
const char *profile;
DBusMessageIter variant_i;
dbus_bool_t connected;
if (!dbus_message_iter_init(msg, &arg_i)) {
pa_log("dbus: message has no parameters");
goto done;
if (pa_modargs_get_value_boolean(ma, "async", &async) < 0) {
pa_log("Failed to parse tsched argument.");
goto fail;
}
if (dbus_message_iter_get_arg_type(&arg_i) != DBUS_TYPE_STRING) {
pa_log("Property name not a string.");
goto done;
}
m->userdata = u = pa_xnew0(struct userdata, 1);
u->module = m;
u->core = m->core;
dbus_message_iter_get_basic(&arg_i, &value);
if (setup_dbus(u) < 0)
goto fail;
if (!pa_streq(value, "Connected"))
goto done;
if (!(u->discovery = pa_bluetooth_discovery_new(pa_dbus_connection_get(u->connection), load_module_for_device, u)))
goto fail;
if (!dbus_message_iter_next(&arg_i)) {
pa_log("Property value missing");
goto done;
}
if (!async)
pa_bluetooth_discovery_sync(u->discovery);
if (dbus_message_iter_get_arg_type(&arg_i) != DBUS_TYPE_VARIANT) {
pa_log("Property value not a variant.");
goto done;
}
return 0;
dbus_message_iter_recurse(&arg_i, &variant_i);
fail:
pa__done(m);
if (dbus_message_iter_get_arg_type(&variant_i) != DBUS_TYPE_BOOLEAN) {
pa_log("Property value not a boolean.");
goto done;
}
dbus_message_iter_get_basic(&variant_i, &connected);
if (dbus_message_is_signal(msg, "org.bluez.Headset", "PropertyChanged"))
profile = "hsp";
else
profile = "a2dp";
d = device_find(u, dbus_message_get_path(msg));
if (connected) {
if (!d) {
d = device_new(dbus_message_get_path(msg));
PA_LLIST_PREPEND(struct device, u->device_list, d);
}
load_module_for_device(u, d, profile);
} else if (d)
unload_module_for_device(u, d, profile);
}
done:
dbus_error_free(&err);
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
static void get_properties_reply(DBusPendingCall *pending, void *user_data) {
struct userdata *u;
DBusMessage *r;
dbus_bool_t connected;
DBusMessageIter arg_i, element_i;
DBusMessageIter variant_i;
struct device *d;
struct dbus_pending *p;
pa_assert(u = user_data);
r = dbus_pending_call_steal_reply(pending);
if (!r)
goto end;
if (dbus_message_get_type(r) == DBUS_MESSAGE_TYPE_ERROR) {
pa_log("Error from GetProperties reply: %s", dbus_message_get_error_name(r));
goto end;
}
if (!dbus_message_iter_init(r, &arg_i)) {
pa_log("%s GetProperties reply has no arguments", p->profile);
goto end;
}
if (dbus_message_iter_get_arg_type(&arg_i) != DBUS_TYPE_ARRAY) {
pa_log("%s GetProperties argument is not an array", p->profile);
goto end;
}
connected = FALSE;
dbus_message_iter_recurse(&arg_i, &element_i);
while (dbus_message_iter_get_arg_type(&element_i) != DBUS_TYPE_INVALID) {
if (dbus_message_iter_get_arg_type(&element_i) == DBUS_TYPE_DICT_ENTRY) {
DBusMessageIter dict_i;
const char *key;
dbus_message_iter_recurse(&element_i, &dict_i);
if (dbus_message_iter_get_arg_type(&dict_i) != DBUS_TYPE_STRING) {
pa_log("Property name not a string.");
goto end;
}
dbus_message_iter_get_basic(&dict_i, &key);
if (!dbus_message_iter_next(&dict_i)) {
pa_log("Property value missing");
goto end;
}
if (dbus_message_iter_get_arg_type(&dict_i) != DBUS_TYPE_VARIANT) {
pa_log("Property value not a variant.");
goto end;
}
dbus_message_iter_recurse(&dict_i, &variant_i);
switch (dbus_message_iter_get_arg_type(&variant_i)) {
case DBUS_TYPE_BOOLEAN: {
dbus_bool_t value;
dbus_message_iter_get_basic(&variant_i, &value);
if (pa_streq(key, "Connected")) {
connected = value;
goto endloop;
}
break;
}
}
}
if (!dbus_message_iter_next(&element_i))
break;
}
endloop:
if (connected) {
p = dbus_pending_call_get_data(pending, u->dbus_data_slot);
pa_log_debug("%s: %s connected", p->path, p->profile);
d = device_find(u, p->path);
if (!d) {
d = device_new(p->path);
PA_LLIST_PREPEND(struct device, u->device_list, d);
}
load_module_for_device(u, d, p->profile);
}
dbus_message_unref(r);
end:
p = dbus_pending_call_get_data(pending, u->dbus_data_slot);
PA_LLIST_REMOVE(struct dbus_pending, u->dbus_pending_list, p);
dbus_pending_free(p);
}
static void list_devices_reply(DBusPendingCall *pending, void *user_data) {
DBusMessage *r, *m;
DBusPendingCall *call;
DBusError e;
char **paths = NULL;
int i, num = -1;
struct dbus_pending *p;
struct userdata *u;
pa_assert(u = user_data);
dbus_error_init(&e);
r = dbus_pending_call_steal_reply(pending);
if (!r) {
pa_log("Failed to get ListDevices reply");
goto end;
}
if (dbus_message_get_type(r) == DBUS_MESSAGE_TYPE_ERROR) {
pa_log("Error from ListDevices reply: %s", dbus_message_get_error_name(r));
goto end;
}
if (!dbus_message_get_args(r, &e, DBUS_TYPE_ARRAY, DBUS_TYPE_OBJECT_PATH, &paths, &num, DBUS_TYPE_INVALID)) {
pa_log("org.bluez.Adapter.ListDevices returned an error: '%s'\n", e.message);
dbus_error_free(&e);
} else {
for (i = 0; i < num; ++i) {
pa_assert_se(m = dbus_message_new_method_call("org.bluez", paths[i], "org.bluez.Headset", "GetProperties"));
if (dbus_connection_send_with_reply(pa_dbus_connection_get(u->conn), m, &call, -1)) {
p = dbus_pending_new(u, call, paths[i], "hsp");
PA_LLIST_PREPEND(struct dbus_pending, u->dbus_pending_list, p);
dbus_pending_call_set_notify(call, get_properties_reply, u, NULL);
} else {
pa_log("Failed to send GetProperties");
}
dbus_message_unref(m);
pa_assert_se(m = dbus_message_new_method_call("org.bluez", paths[i], "org.bluez.AudioSink", "GetProperties"));
if (dbus_connection_send_with_reply(pa_dbus_connection_get(u->conn), m, &call, -1)) {
p = dbus_pending_new(u, call, paths[i], "a2dp");
PA_LLIST_PREPEND(struct dbus_pending, u->dbus_pending_list, p);
dbus_pending_call_set_notify(call, get_properties_reply, u, NULL);
} else {
pa_log("Failed to send GetProperties");
}
dbus_message_unref(m);
}
}
if (paths)
dbus_free_string_array (paths);
dbus_message_unref(r);
end:
p = dbus_pending_call_get_data(pending, u->dbus_data_slot);
PA_LLIST_REMOVE(struct dbus_pending, u->dbus_pending_list, p);
dbus_pending_free(p);
}
static void list_adapters_reply(DBusPendingCall *pending, void *user_data) {
DBusMessage *r, *m;
DBusPendingCall *call;
DBusError e;
char **paths = NULL;
int i, num = -1;
struct dbus_pending *p;
struct userdata *u;
pa_assert(u = user_data);
dbus_error_init(&e);
r = dbus_pending_call_steal_reply(pending);
if (!r) {
pa_log("Failed to get ListAdapters reply");
goto end;
}
if (dbus_message_get_type(r) == DBUS_MESSAGE_TYPE_ERROR) {
pa_log("Error from ListAdapters reply: %s", dbus_message_get_error_name(r));
goto end;
}
if (!dbus_message_get_args(r, &e, DBUS_TYPE_ARRAY, DBUS_TYPE_OBJECT_PATH, &paths, &num, DBUS_TYPE_INVALID)) {
pa_log("org.bluez.Manager.ListAdapters returned an error: '%s'\n", e.message);
dbus_error_free(&e);
} else {
for (i = 0; i < num; ++i) {
pa_assert_se(m = dbus_message_new_method_call("org.bluez", paths[i], "org.bluez.Adapter", "ListDevices"));
if (dbus_connection_send_with_reply(pa_dbus_connection_get(u->conn), m, &call, -1)) {
p = dbus_pending_new(u, call, NULL, NULL);
PA_LLIST_PREPEND(struct dbus_pending, u->dbus_pending_list, p);
dbus_pending_call_set_notify(call, list_devices_reply, u, NULL);
} else {
pa_log("Failed to send ListDevices");
}
dbus_message_unref(m);
}
}
if (paths)
dbus_free_string_array (paths);
dbus_message_unref(r);
end:
p = dbus_pending_call_get_data(pending, u->dbus_data_slot);
PA_LLIST_REMOVE(struct dbus_pending, u->dbus_pending_list, p);
dbus_pending_free(p);
}
static void lookup_devices(struct userdata *u) {
DBusMessage *m;
DBusPendingCall *call;
struct dbus_pending *p;
pa_assert(u);
pa_assert_se(m = dbus_message_new_method_call("org.bluez", "/", "org.bluez.Manager", "ListAdapters"));
if (dbus_connection_send_with_reply(pa_dbus_connection_get(u->conn), m, &call, -1)) {
p = dbus_pending_new(u, call, NULL, NULL);
PA_LLIST_PREPEND(struct dbus_pending, u->dbus_pending_list, p);
dbus_pending_call_set_notify(call, list_adapters_reply, u, NULL);
} else {
pa_log("Failed to send ListAdapters");
}
dbus_message_unref(m);
return -1;
}
void pa__done(pa_module* m) {
struct userdata *u;
struct device *i;
struct dbus_pending *p;
pa_assert(m);
if (!(u = m->userdata))
return;
while ((p = u->dbus_pending_list)) {
PA_LLIST_REMOVE(struct dbus_pending, u->dbus_pending_list, p);
dbus_pending_free(p);
}
if (u->discovery)
pa_bluetooth_discovery_free(u->discovery);
while ((i = u->device_list)) {
PA_LLIST_REMOVE(struct device, u->device_list, i);
device_free(i);
}
if (u->dbus_data_slot != -1) {
dbus_pending_call_free_data_slot(&u->dbus_data_slot);
}
if (u->conn) {
DBusError error;
dbus_error_init(&error);
dbus_bus_remove_match(pa_dbus_connection_get(u->conn), "type='signal',sender='org.bluez',interface='org.bluez.Adapter',member='DeviceRemoved'", &error);
dbus_error_free(&error);
dbus_bus_remove_match(pa_dbus_connection_get(u->conn), "type='signal',sender='org.bluez',interface='org.bluez.Headset',member='PropertyChanged'", &error);
dbus_error_free(&error);
dbus_bus_remove_match(pa_dbus_connection_get(u->conn), "type='signal',sender='org.bluez',interface='org.bluez.AudioSink',member='PropertyChanged'", &error);
dbus_error_free(&error);
dbus_connection_remove_filter(pa_dbus_connection_get(u->conn), filter_cb, u);
pa_dbus_connection_unref(u->conn);
}
if (u->connection)
pa_dbus_connection_unref(u->connection);
pa_xfree(u);
}
int pa__init(pa_module* m) {
DBusError err;
struct userdata *u;
pa_assert(m);
dbus_error_init(&err);
m->userdata = u = pa_xnew(struct userdata, 1);
u->dbus_data_slot = -1;
u->module = m;
PA_LLIST_HEAD_INIT(struct device, u->device_list);
PA_LLIST_HEAD_INIT(DBusPendingCall, u->dbus_pending_list);
/* connect to the bus */
u->conn = pa_dbus_bus_get(m->core, DBUS_BUS_SYSTEM, &err);
if (dbus_error_is_set(&err) || (u->conn == NULL) ) {
pa_log("Failed to get D-Bus connection: %s", err.message);
goto fail;
}
if (!dbus_pending_call_allocate_data_slot(&u->dbus_data_slot))
goto fail;
/* dynamic detection of bluetooth audio devices */
if (!dbus_connection_add_filter(pa_dbus_connection_get(u->conn), filter_cb, u, NULL)) {
pa_log_error("Failed to add filter function");
goto fail;
}
dbus_bus_add_match(pa_dbus_connection_get(u->conn), "type='signal',sender='org.bluez',interface='org.bluez.Adapter',member='DeviceRemoved'", &err);
if (dbus_error_is_set(&err)) {
pa_log_error("Unable to subscribe to org.bluez.Adapter signals: %s: %s", err.name, err.message);
goto fail;
}
dbus_bus_add_match(pa_dbus_connection_get(u->conn), "type='signal',sender='org.bluez',interface='org.bluez.Headset',member='PropertyChanged'", &err);
if (dbus_error_is_set(&err)) {
pa_log_error("Unable to subscribe to org.bluez.Headset signals: %s: %s", err.name, err.message);
goto fail;
}
dbus_bus_add_match(pa_dbus_connection_get(u->conn), "type='signal',sender='org.bluez',interface='org.bluez.AudioSink',member='PropertyChanged'", &err);
if (dbus_error_is_set(&err)) {
pa_log_error("Unable to subscribe to org.bluez.AudioSink signals: %s: %s", err.name, err.message);
goto fail;
}
lookup_devices(u);
return 0;
fail:
dbus_error_free(&err);
pa__done(m);
return -1;
}