code.delx.au - pulseaudio/blob - src/modules/bluetooth/bluez5-util.c

   1 /***
   2   This file is part of PulseAudio.
   3
   4   Copyright 2008-2013 João Paulo Rechi Vita
   5
   6   PulseAudio is free software; you can redistribute it and/or modify
   7   it under the terms of the GNU Lesser General Public License as
   8   published by the Free Software Foundation; either version 2.1 of the
   9   License, or (at your option) any later version.
  10
  11   PulseAudio is distributed in the hope that it will be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14   General Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public
  17   License along with PulseAudio; if not, write to the Free Software
  18   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  19   USA.
  20 ***/
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <pulse/xmalloc.h>
  27
  28 #include <pulsecore/core.h>
  29 #include <pulsecore/core-util.h>
  30 #include <pulsecore/dbus-shared.h>
  31 #include <pulsecore/log.h>
  32 #include <pulsecore/macro.h>
  33 #include <pulsecore/refcnt.h>
  34 #include <pulsecore/shared.h>
  35
  36 #include "a2dp-codecs.h"
  37
  38 #include "bluez5-util.h"
  39
  40 #define BLUEZ_SERVICE "org.bluez"
  41 #define BLUEZ_ADAPTER_INTERFACE BLUEZ_SERVICE ".Adapter1"
  42 #define BLUEZ_DEVICE_INTERFACE BLUEZ_SERVICE ".Device1"
  43 #define BLUEZ_MEDIA_ENDPOINT_INTERFACE BLUEZ_SERVICE ".MediaEndpoint1"
  44 #define BLUEZ_MEDIA_TRANSPORT_INTERFACE BLUEZ_SERVICE ".MediaTransport1"
  45
  46 #define A2DP_SOURCE_ENDPOINT "/MediaEndpoint/A2DPSource"
  47 #define A2DP_SINK_ENDPOINT "/MediaEndpoint/A2DPSink"
  48
  49 #define ENDPOINT_INTROSPECT_XML                                         \
  50     DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE                           \
  51     "<node>"                                                            \
  52     " <interface name=\"" BLUEZ_MEDIA_ENDPOINT_INTERFACE "\">"          \
  53     "  <method name=\"SetConfiguration\">"                              \
  54     "   <arg name=\"transport\" direction=\"in\" type=\"o\"/>"          \
  55     "   <arg name=\"properties\" direction=\"in\" type=\"ay\"/>"        \
  56     "  </method>"                                                       \
  57     "  <method name=\"SelectConfiguration\">"                           \
  58     "   <arg name=\"capabilities\" direction=\"in\" type=\"ay\"/>"      \
  59     "   <arg name=\"configuration\" direction=\"out\" type=\"ay\"/>"    \
  60     "  </method>"                                                       \
  61     "  <method name=\"ClearConfiguration\">"                            \
  62     "   <arg name=\"transport\" direction=\"in\" type=\"o\"/>"          \
  63     "  </method>"                                                       \
  64     "  <method name=\"Release\">"                                       \
  65     "  </method>"                                                       \
  66     " </interface>"                                                     \
  67     " <interface name=\"org.freedesktop.DBus.Introspectable\">"         \
  68     "  <method name=\"Introspect\">"                                    \
  69     "   <arg name=\"data\" type=\"s\" direction=\"out\"/>"              \
  70     "  </method>"                                                       \
  71     " </interface>"                                                     \
  72     "</node>"
  73
  74 struct pa_bluetooth_discovery {
  75     PA_REFCNT_DECLARE;
  76
  77     pa_core *core;
  78     pa_dbus_connection *connection;
  79     bool filter_added;
  80     bool matches_added;
  81     bool objects_listed;
  82     pa_hook hooks[PA_BLUETOOTH_HOOK_MAX];
  83     pa_hashmap *adapters;
  84     pa_hashmap *devices;
  85     pa_hashmap *transports;
  86
  87     PA_LLIST_HEAD(pa_dbus_pending, pending);
  88 };
  89
  90 static pa_dbus_pending* send_and_add_to_pending(pa_bluetooth_discovery *y, DBusMessage *m,
  91                                                                   DBusPendingCallNotifyFunction func, void *call_data) {
  92     pa_dbus_pending *p;
  93     DBusPendingCall *call;
  94
  95     pa_assert(y);
  96     pa_assert(m);
  97
  98     pa_assert_se(dbus_connection_send_with_reply(pa_dbus_connection_get(y->connection), m, &call, -1));
  99
 100     p = pa_dbus_pending_new(pa_dbus_connection_get(y->connection), m, call, y, call_data);
 101     PA_LLIST_PREPEND(pa_dbus_pending, y->pending, p);
 102     dbus_pending_call_set_notify(call, func, p, NULL);
 103
 104     return p;
 105 }
 106
 107 pa_bluetooth_transport *pa_bluetooth_transport_new(pa_bluetooth_device *d, const char *owner, const char *path,
 108                                                    pa_bluetooth_profile_t p, const uint8_t *config, size_t size) {
 109     pa_bluetooth_transport *t;
 110
 111     t = pa_xnew0(pa_bluetooth_transport, 1);
 112     t->device = d;
 113     t->owner = pa_xstrdup(owner);
 114     t->path = pa_xstrdup(path);
 115     t->profile = p;
 116     t->config_size = size;
 117
 118     if (size > 0) {
 119         t->config = pa_xnew(uint8_t, size);
 120         memcpy(t->config, config, size);
 121     }
 122
 123     pa_assert_se(pa_hashmap_put(d->discovery->transports, t->path, t) >= 0);
 124
 125     return t;
 126 }
 127
 128 static const char *transport_state_to_string(pa_bluetooth_transport_state_t state) {
 129     switch(state) {
 130         case PA_BLUETOOTH_TRANSPORT_STATE_DISCONNECTED:
 131             return "disconnected";
 132         case PA_BLUETOOTH_TRANSPORT_STATE_IDLE:
 133             return "idle";
 134         case PA_BLUETOOTH_TRANSPORT_STATE_PLAYING:
 135             return "playing";
 136     }
 137
 138     return "invalid";
 139 }
 140
 141 static void transport_state_changed(pa_bluetooth_transport *t, pa_bluetooth_transport_state_t state) {
 142     bool old_any_connected;
 143
 144     pa_assert(t);
 145
 146     if (t->state == state)
 147         return;
 148
 149     old_any_connected = pa_bluetooth_device_any_transport_connected(t->device);
 150
 151     pa_log_debug("Transport %s state changed from %s to %s",
 152                  t->path, transport_state_to_string(t->state), transport_state_to_string(state));
 153
 154     t->state = state;
 155     if (state == PA_BLUETOOTH_TRANSPORT_STATE_DISCONNECTED)
 156         t->device->transports[t->profile] = NULL;
 157
 158     pa_hook_fire(&t->device->discovery->hooks[PA_BLUETOOTH_HOOK_TRANSPORT_STATE_CHANGED], t);
 159
 160     if (old_any_connected != pa_bluetooth_device_any_transport_connected(t->device))
 161         pa_hook_fire(&t->device->discovery->hooks[PA_BLUETOOTH_HOOK_DEVICE_CONNECTION_CHANGED], t->device);
 162 }
 163
 164 void pa_bluetooth_transport_put(pa_bluetooth_transport *t) {
 165     transport_state_changed(t, PA_BLUETOOTH_TRANSPORT_STATE_IDLE);
 166 }
 167
 168 void pa_bluetooth_transport_free(pa_bluetooth_transport *t) {
 169     pa_assert(t);
 170
 171     pa_hashmap_remove(t->device->discovery->transports, t->path);
 172     pa_xfree(t->owner);
 173     pa_xfree(t->path);
 174     pa_xfree(t->config);
 175     pa_xfree(t);
 176 }
 177
 178 static int bluez5_transport_acquire_cb(pa_bluetooth_transport *t, bool optional, size_t *imtu, size_t *omtu) {
 179     DBusMessage *m, *r;
 180     DBusError err;
 181     int ret;
 182     uint16_t i, o;
 183     const char *method = optional ? "TryAcquire" : "Acquire";
 184
 185     pa_assert(t);
 186     pa_assert(t->device);
 187     pa_assert(t->device->discovery);
 188
 189     pa_assert_se(m = dbus_message_new_method_call(t->owner, t->path, BLUEZ_MEDIA_TRANSPORT_INTERFACE, method));
 190
 191     dbus_error_init(&err);
 192
 193     r = dbus_connection_send_with_reply_and_block(pa_dbus_connection_get(t->device->discovery->connection), m, -1, &err);
 194     if (!r) {
 195         if (optional && pa_streq(err.name, "org.bluez.Error.NotAvailable"))
 196             pa_log_info("Failed optional acquire of unavailable transport %s", t->path);
 197         else
 198             pa_log_error("Transport %s() failed for transport %s (%s)", method, t->path, err.message);
 199
 200         dbus_error_free(&err);
 201         return -1;
 202     }
 203
 204     if (!dbus_message_get_args(r, &err, DBUS_TYPE_UNIX_FD, &ret, DBUS_TYPE_UINT16, &i, DBUS_TYPE_UINT16, &o,
 205                                DBUS_TYPE_INVALID)) {
 206         pa_log_error("Failed to parse %s() reply: %s", method, err.message);
 207         dbus_error_free(&err);
 208         ret = -1;
 209         goto finish;
 210     }
 211
 212     if (imtu)
 213         *imtu = i;
 214
 215     if (omtu)
 216         *omtu = o;
 217
 218 finish:
 219     dbus_message_unref(r);
 220     return ret;
 221 }
 222
 223 static void bluez5_transport_release_cb(pa_bluetooth_transport *t) {
 224     DBusMessage *m;
 225     DBusError err;
 226
 227     pa_assert(t);
 228     pa_assert(t->device);
 229     pa_assert(t->device->discovery);
 230
 231     dbus_error_init(&err);
 232
 233     if (t->state <= PA_BLUETOOTH_TRANSPORT_STATE_IDLE) {
 234         pa_log_info("Transport %s auto-released by BlueZ or already released", t->path);
 235         return;
 236     }
 237
 238     pa_assert_se(m = dbus_message_new_method_call(t->owner, t->path, BLUEZ_MEDIA_TRANSPORT_INTERFACE, "Release"));
 239     dbus_connection_send_with_reply_and_block(pa_dbus_connection_get(t->device->discovery->connection), m, -1, &err);
 240
 241     if (dbus_error_is_set(&err)) {
 242         pa_log_error("Failed to release transport %s: %s", t->path, err.message);
 243         dbus_error_free(&err);
 244     } else
 245         pa_log_info("Transport %s released", t->path);
 246 }
 247
 248 bool pa_bluetooth_device_any_transport_connected(const pa_bluetooth_device *d) {
 249     unsigned i;
 250
 251     pa_assert(d);
 252
 253     if (d->device_info_valid != 1)
 254         return false;
 255
 256     for (i = 0; i < PA_BLUETOOTH_PROFILE_COUNT; i++)
 257         if (d->transports[i] && d->transports[i]->state != PA_BLUETOOTH_TRANSPORT_STATE_DISCONNECTED)
 258             return true;
 259
 260     return false;
 261 }
 262
 263 static pa_bluetooth_device* device_create(pa_bluetooth_discovery *y, const char *path) {
 264     pa_bluetooth_device *d;
 265
 266     pa_assert(y);
 267     pa_assert(path);
 268
 269     d = pa_xnew0(pa_bluetooth_device, 1);
 270     d->discovery = y;
 271     d->path = pa_xstrdup(path);
 272
 273     pa_hashmap_put(y->devices, d->path, d);
 274
 275     return d;
 276 }
 277
 278 pa_bluetooth_device* pa_bluetooth_discovery_get_device_by_path(pa_bluetooth_discovery *y, const char *path) {
 279     pa_bluetooth_device *d;
 280
 281     pa_assert(y);
 282     pa_assert(PA_REFCNT_VALUE(y) > 0);
 283     pa_assert(path);
 284
 285     if ((d = pa_hashmap_get(y->devices, path)))
 286         if (d->device_info_valid == 1)
 287             return d;
 288
 289     return NULL;
 290 }
 291
 292 pa_bluetooth_device* pa_bluetooth_discovery_get_device_by_address(pa_bluetooth_discovery *y, const char *remote, const char *local) {
 293     pa_bluetooth_device *d;
 294     void *state = NULL;
 295
 296     pa_assert(y);
 297     pa_assert(PA_REFCNT_VALUE(y) > 0);
 298     pa_assert(remote);
 299     pa_assert(local);
 300
 301     while ((d = pa_hashmap_iterate(y->devices, &state, NULL)))
 302         if (pa_streq(d->address, remote) && pa_streq(d->adapter->address, local))
 303             return d->device_info_valid == 1 ? d : NULL;
 304
 305     return NULL;
 306 }
 307
 308 static void device_free(pa_bluetooth_device *d) {
 309     unsigned i;
 310
 311     pa_assert(d);
 312
 313     for (i = 0; i < PA_BLUETOOTH_PROFILE_COUNT; i++) {
 314         pa_bluetooth_transport *t;
 315
 316         if (!(t = d->transports[i]))
 317             continue;
 318
 319         transport_state_changed(t, PA_BLUETOOTH_TRANSPORT_STATE_DISCONNECTED);
 320         pa_bluetooth_transport_free(t);
 321     }
 322
 323     d->discovery = NULL;
 324     d->adapter = NULL;
 325     pa_xfree(d->path);
 326     pa_xfree(d->alias);
 327     pa_xfree(d->address);
 328     pa_xfree(d);
 329 }
 330
 331 static void device_remove(pa_bluetooth_discovery *y, const char *path) {
 332     pa_bluetooth_device *d;
 333
 334     if (!(d = pa_hashmap_remove(y->devices, path)))
 335         pa_log_warn("Unknown device removed %s", path);
 336     else {
 337         pa_log_debug("Device %s removed", path);
 338         device_free(d);
 339     }
 340 }
 341
 342 static void device_remove_all(pa_bluetooth_discovery *y) {
 343     pa_bluetooth_device *d;
 344
 345     pa_assert(y);
 346
 347     while ((d = pa_hashmap_steal_first(y->devices))) {
 348         d->device_info_valid = -1;
 349         pa_hook_fire(&y->hooks[PA_BLUETOOTH_HOOK_DEVICE_CONNECTION_CHANGED], d);
 350         device_free(d);
 351    }
 352 }
 353
 354 static pa_bluetooth_adapter* adapter_create(pa_bluetooth_discovery *y, const char *path) {
 355     pa_bluetooth_adapter *a;
 356
 357     pa_assert(y);
 358     pa_assert(path);
 359
 360     a = pa_xnew0(pa_bluetooth_adapter, 1);
 361     a->discovery = y;
 362     a->path = pa_xstrdup(path);
 363
 364     pa_hashmap_put(y->adapters, a->path, a);
 365
 366     return a;
 367 }
 368
 369 static void adapter_free(pa_bluetooth_adapter *a) {
 370     pa_bluetooth_device *d;
 371     void *state;
 372
 373     pa_assert(a);
 374     pa_assert(a->discovery);
 375
 376     PA_HASHMAP_FOREACH(d, a->discovery->devices, state)
 377         if (d->adapter == a)
 378             d->adapter = NULL;
 379
 380     pa_xfree(a->path);
 381     pa_xfree(a->address);
 382     pa_xfree(a);
 383 }
 384
 385 static void adapter_remove(pa_bluetooth_discovery *y, const char *path) {
 386     pa_bluetooth_adapter *a;
 387
 388     if (!(a = pa_hashmap_remove(y->adapters, path)))
 389         pa_log_warn("Unknown adapter removed %s", path);
 390     else {
 391         pa_log_debug("Adapter %s removed", path);
 392         adapter_free(a);
 393     }
 394 }
 395
 396 static void adapter_remove_all(pa_bluetooth_discovery *y) {
 397     pa_bluetooth_adapter *a;
 398
 399     pa_assert(y);
 400
 401     /* When this function is called all devices have already been freed */
 402
 403     while ((a = pa_hashmap_steal_first(y->adapters)))
 404         adapter_free(a);
 405 }
 406
 407 static void parse_interfaces_and_properties(pa_bluetooth_discovery *y, DBusMessageIter *dict_i) {
 408     DBusMessageIter element_i;
 409     const char *path;
 410
 411     pa_assert(dbus_message_iter_get_arg_type(dict_i) == DBUS_TYPE_OBJECT_PATH);
 412     dbus_message_iter_get_basic(dict_i, &path);
 413
 414     pa_assert_se(dbus_message_iter_next(dict_i));
 415     pa_assert(dbus_message_iter_get_arg_type(dict_i) == DBUS_TYPE_ARRAY);
 416
 417     dbus_message_iter_recurse(dict_i, &element_i);
 418
 419     while (dbus_message_iter_get_arg_type(&element_i) == DBUS_TYPE_DICT_ENTRY) {
 420         DBusMessageIter iface_i;
 421         const char *interface;
 422
 423         dbus_message_iter_recurse(&element_i, &iface_i);
 424
 425         pa_assert(dbus_message_iter_get_arg_type(&iface_i) == DBUS_TYPE_STRING);
 426         dbus_message_iter_get_basic(&iface_i, &interface);
 427
 428         pa_assert_se(dbus_message_iter_next(&iface_i));
 429         pa_assert(dbus_message_iter_get_arg_type(&iface_i) == DBUS_TYPE_ARRAY);
 430
 431         if (pa_streq(interface, BLUEZ_ADAPTER_INTERFACE)) {
 432             pa_bluetooth_adapter *a;
 433
 434             if ((a = pa_hashmap_get(y->adapters, path))) {
 435                 pa_log_error("Found duplicated D-Bus path for device %s", path);
 436                 return;
 437             } else
 438                 a = adapter_create(y, path);
 439
 440             pa_log_debug("Adapter %s found", path);
 441
 442             /* TODO: parse adapter properties and register endpoints */
 443
 444         } else if (pa_streq(interface, BLUEZ_DEVICE_INTERFACE)) {
 445             pa_bluetooth_device *d;
 446
 447             if ((d = pa_hashmap_get(y->devices, path))) {
 448                 if (d->device_info_valid != 0) {
 449                     pa_log_error("Found duplicated D-Bus path for device %s", path);
 450                     return;
 451                 }
 452             } else
 453                 d = device_create(y, path);
 454
 455             pa_log_debug("Device %s found", d->path);
 456
 457             /* TODO: parse device properties */
 458
 459         } else
 460             pa_log_debug("Unknown interface %s found, skipping", interface);
 461
 462         dbus_message_iter_next(&element_i);
 463     }
 464
 465     return;
 466 }
 467
 468 static void get_managed_objects_reply(DBusPendingCall *pending, void *userdata) {
 469     pa_dbus_pending *p;
 470     pa_bluetooth_discovery *y;
 471     DBusMessage *r;
 472     DBusMessageIter arg_i, element_i;
 473
 474     pa_assert_se(p = userdata);
 475     pa_assert_se(y = p->context_data);
 476     pa_assert_se(r = dbus_pending_call_steal_reply(pending));
 477
 478     if (dbus_message_is_error(r, DBUS_ERROR_UNKNOWN_METHOD)) {
 479         pa_log_warn("BlueZ D-Bus ObjectManager not available");
 480         goto finish;
 481     }
 482
 483     if (dbus_message_get_type(r) == DBUS_MESSAGE_TYPE_ERROR) {
 484         pa_log_error("GetManagedObjects() failed: %s: %s", dbus_message_get_error_name(r), pa_dbus_get_error_message(r));
 485         goto finish;
 486     }
 487
 488     if (!dbus_message_iter_init(r, &arg_i) || !pa_streq(dbus_message_get_signature(r), "a{oa{sa{sv}}}")) {
 489         pa_log_error("Invalid reply signature for GetManagedObjects()");
 490         goto finish;
 491     }
 492
 493     dbus_message_iter_recurse(&arg_i, &element_i);
 494     while (dbus_message_iter_get_arg_type(&element_i) == DBUS_TYPE_DICT_ENTRY) {
 495         DBusMessageIter dict_i;
 496
 497         dbus_message_iter_recurse(&element_i, &dict_i);
 498
 499         parse_interfaces_and_properties(y, &dict_i);
 500
 501         dbus_message_iter_next(&element_i);
 502     }
 503
 504     y->objects_listed = true;
 505
 506 finish:
 507     dbus_message_unref(r);
 508
 509     PA_LLIST_REMOVE(pa_dbus_pending, y->pending, p);
 510     pa_dbus_pending_free(p);
 511 }
 512
 513 static void get_managed_objects(pa_bluetooth_discovery *y) {
 514     DBusMessage *m;
 515
 516     pa_assert(y);
 517
 518     pa_assert_se(m = dbus_message_new_method_call(BLUEZ_SERVICE, "/", "org.freedesktop.DBus.ObjectManager",
 519                                                   "GetManagedObjects"));
 520     send_and_add_to_pending(y, m, get_managed_objects_reply, NULL);
 521 }
 522
 523 pa_hook* pa_bluetooth_discovery_hook(pa_bluetooth_discovery *y, pa_bluetooth_hook_t hook) {
 524     pa_assert(y);
 525     pa_assert(PA_REFCNT_VALUE(y) > 0);
 526
 527     return &y->hooks[hook];
 528 }
 529
 530 static DBusHandlerResult filter_cb(DBusConnection *bus, DBusMessage *m, void *userdata) {
 531     pa_bluetooth_discovery *y;
 532     DBusError err;
 533
 534     pa_assert(bus);
 535     pa_assert(m);
 536     pa_assert_se(y = userdata);
 537
 538     dbus_error_init(&err);
 539
 540     if (dbus_message_is_signal(m, "org.freedesktop.DBus", "NameOwnerChanged")) {
 541         const char *name, *old_owner, *new_owner;
 542
 543         if (!dbus_message_get_args(m, &err,
 544                                    DBUS_TYPE_STRING, &name,
 545                                    DBUS_TYPE_STRING, &old_owner,
 546                                    DBUS_TYPE_STRING, &new_owner,
 547                                    DBUS_TYPE_INVALID)) {
 548             pa_log_error("Failed to parse org.freedesktop.DBus.NameOwnerChanged: %s", err.message);
 549             goto fail;
 550         }
 551
 552         if (pa_streq(name, BLUEZ_SERVICE)) {
 553             if (old_owner && *old_owner) {
 554                 pa_log_debug("Bluetooth daemon disappeared");
 555                 device_remove_all(y);
 556                 adapter_remove_all(y);
 557                 y->objects_listed = false;
 558             }
 559
 560             if (new_owner && *new_owner) {
 561                 pa_log_debug("Bluetooth daemon appeared");
 562                 get_managed_objects(y);
 563             }
 564         }
 565
 566         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 567     } else if (dbus_message_is_signal(m, "org.freedesktop.DBus.ObjectManager", "InterfacesAdded")) {
 568         DBusMessageIter arg_i;
 569
 570         if (!y->objects_listed)
 571             return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; /* No reply received yet from GetManagedObjects */
 572
 573         if (!dbus_message_iter_init(m, &arg_i) || !pa_streq(dbus_message_get_signature(m), "oa{sa{sv}}")) {
 574             pa_log_error("Invalid signature found in InterfacesAdded");
 575             goto fail;
 576         }
 577
 578         parse_interfaces_and_properties(y, &arg_i);
 579
 580         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 581     } else if (dbus_message_is_signal(m, "org.freedesktop.DBus.ObjectManager", "InterfacesRemoved")) {
 582         const char *p;
 583         DBusMessageIter arg_i;
 584         DBusMessageIter element_i;
 585
 586         if (!y->objects_listed)
 587             return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; /* No reply received yet from GetManagedObjects */
 588
 589         if (!dbus_message_iter_init(m, &arg_i) || !pa_streq(dbus_message_get_signature(m), "oas")) {
 590             pa_log_error("Invalid signature found in InterfacesRemoved");
 591             goto fail;
 592         }
 593
 594         dbus_message_iter_get_basic(&arg_i, &p);
 595
 596         pa_assert_se(dbus_message_iter_next(&arg_i));
 597         pa_assert(dbus_message_iter_get_arg_type(&arg_i) == DBUS_TYPE_ARRAY);
 598
 599         dbus_message_iter_recurse(&arg_i, &element_i);
 600
 601         while (dbus_message_iter_get_arg_type(&element_i) == DBUS_TYPE_STRING) {
 602             const char *iface;
 603
 604             dbus_message_iter_get_basic(&element_i, &iface);
 605
 606             if (pa_streq(iface, BLUEZ_DEVICE_INTERFACE))
 607                 device_remove(y, p);
 608             else if (pa_streq(iface, BLUEZ_ADAPTER_INTERFACE))
 609                 adapter_remove(y, p);
 610
 611             dbus_message_iter_next(&element_i);
 612         }
 613
 614         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 615
 616     }
 617
 618 fail:
 619     dbus_error_free(&err);
 620
 621     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 622 }
 623
 624 static uint8_t a2dp_default_bitpool(uint8_t freq, uint8_t mode) {
 625     /* These bitpool values were chosen based on the A2DP spec recommendation */
 626     switch (freq) {
 627         case SBC_SAMPLING_FREQ_16000:
 628         case SBC_SAMPLING_FREQ_32000:
 629             return 53;
 630
 631         case SBC_SAMPLING_FREQ_44100:
 632
 633             switch (mode) {
 634                 case SBC_CHANNEL_MODE_MONO:
 635                 case SBC_CHANNEL_MODE_DUAL_CHANNEL:
 636                     return 31;
 637
 638                 case SBC_CHANNEL_MODE_STEREO:
 639                 case SBC_CHANNEL_MODE_JOINT_STEREO:
 640                     return 53;
 641             }
 642
 643             pa_log_warn("Invalid channel mode %u", mode);
 644             return 53;
 645
 646         case SBC_SAMPLING_FREQ_48000:
 647
 648             switch (mode) {
 649                 case SBC_CHANNEL_MODE_MONO:
 650                 case SBC_CHANNEL_MODE_DUAL_CHANNEL:
 651                     return 29;
 652
 653                 case SBC_CHANNEL_MODE_STEREO:
 654                 case SBC_CHANNEL_MODE_JOINT_STEREO:
 655                     return 51;
 656             }
 657
 658             pa_log_warn("Invalid channel mode %u", mode);
 659             return 51;
 660     }
 661
 662     pa_log_warn("Invalid sampling freq %u", freq);
 663     return 53;
 664 }
 665
 666 const char *pa_bluetooth_profile_to_string(pa_bluetooth_profile_t profile) {
 667     switch(profile) {
 668         case PA_BLUETOOTH_PROFILE_A2DP_SINK:
 669             return "a2dp_sink";
 670         case PA_BLUETOOTH_PROFILE_A2DP_SOURCE:
 671             return "a2dp_source";
 672         case PA_BLUETOOTH_PROFILE_OFF:
 673             return "off";
 674     }
 675
 676     return NULL;
 677 }
 678
 679 static DBusMessage *endpoint_set_configuration(DBusConnection *conn, DBusMessage *m, void *userdata) {
 680     pa_bluetooth_discovery *y = userdata;
 681     pa_bluetooth_device *d;
 682     pa_bluetooth_transport *t;
 683     const char *sender, *path, *endpoint_path, *dev_path = NULL, *uuid = NULL;
 684     const uint8_t *config = NULL;
 685     int size = 0;
 686     pa_bluetooth_profile_t p = PA_BLUETOOTH_PROFILE_OFF;
 687     DBusMessageIter args, props;
 688     DBusMessage *r;
 689
 690     if (!dbus_message_iter_init(m, &args) || !pa_streq(dbus_message_get_signature(m), "oa{sv}")) {
 691         pa_log_error("Invalid signature for method SetConfiguration()");
 692         goto fail2;
 693     }
 694
 695     dbus_message_iter_get_basic(&args, &path);
 696
 697     if (pa_hashmap_get(y->transports, path)) {
 698         pa_log_error("Endpoint SetConfiguration(): Transport %s is already configured.", path);
 699         goto fail2;
 700     }
 701
 702     pa_assert_se(dbus_message_iter_next(&args));
 703
 704     dbus_message_iter_recurse(&args, &props);
 705     if (dbus_message_iter_get_arg_type(&props) != DBUS_TYPE_DICT_ENTRY)
 706         goto fail;
 707
 708     /* Read transport properties */
 709     while (dbus_message_iter_get_arg_type(&props) == DBUS_TYPE_DICT_ENTRY) {
 710         const char *key;
 711         DBusMessageIter value, entry;
 712         int var;
 713
 714         dbus_message_iter_recurse(&props, &entry);
 715         dbus_message_iter_get_basic(&entry, &key);
 716
 717         dbus_message_iter_next(&entry);
 718         dbus_message_iter_recurse(&entry, &value);
 719
 720         var = dbus_message_iter_get_arg_type(&value);
 721
 722         if (pa_streq(key, "UUID")) {
 723             if (var != DBUS_TYPE_STRING) {
 724                 pa_log_error("Property %s of wrong type %c", key, (char)var);
 725                 goto fail;
 726             }
 727
 728             dbus_message_iter_get_basic(&value, &uuid);
 729
 730             endpoint_path = dbus_message_get_path(m);
 731             if (pa_streq(endpoint_path, A2DP_SOURCE_ENDPOINT)) {
 732                 if (pa_streq(uuid, PA_BLUETOOTH_UUID_A2DP_SOURCE))
 733                     p = PA_BLUETOOTH_PROFILE_A2DP_SINK;
 734             } else if (pa_streq(endpoint_path, A2DP_SINK_ENDPOINT)) {
 735                 if (pa_streq(uuid, PA_BLUETOOTH_UUID_A2DP_SINK))
 736                     p = PA_BLUETOOTH_PROFILE_A2DP_SOURCE;
 737             }
 738
 739             if (p == PA_BLUETOOTH_PROFILE_OFF) {
 740                 pa_log_error("UUID %s of transport %s incompatible with endpoint %s", uuid, path, endpoint_path);
 741                 goto fail;
 742             }
 743         } else if (pa_streq(key, "Device")) {
 744             if (var != DBUS_TYPE_OBJECT_PATH) {
 745                 pa_log_error("Property %s of wrong type %c", key, (char)var);
 746                 goto fail;
 747             }
 748
 749             dbus_message_iter_get_basic(&value, &dev_path);
 750         } else if (pa_streq(key, "Configuration")) {
 751             DBusMessageIter array;
 752             a2dp_sbc_t *c;
 753
 754             if (var != DBUS_TYPE_ARRAY) {
 755                 pa_log_error("Property %s of wrong type %c", key, (char)var);
 756                 goto fail;
 757             }
 758
 759             dbus_message_iter_recurse(&value, &array);
 760             var = dbus_message_iter_get_arg_type(&array);
 761             if (var != DBUS_TYPE_BYTE) {
 762                 pa_log_error("%s is an array of wrong type %c", key, (char)var);
 763                 goto fail;
 764             }
 765
 766             dbus_message_iter_get_fixed_array(&array, &config, &size);
 767             if (size != sizeof(a2dp_sbc_t)) {
 768                 pa_log_error("Configuration array of invalid size");
 769                 goto fail;
 770             }
 771
 772             c = (a2dp_sbc_t *) config;
 773
 774             if (c->frequency != SBC_SAMPLING_FREQ_16000 && c->frequency != SBC_SAMPLING_FREQ_32000 &&
 775                 c->frequency != SBC_SAMPLING_FREQ_44100 && c->frequency != SBC_SAMPLING_FREQ_48000) {
 776                 pa_log_error("Invalid sampling frequency in configuration");
 777                 goto fail;
 778             }
 779
 780             if (c->channel_mode != SBC_CHANNEL_MODE_MONO && c->channel_mode != SBC_CHANNEL_MODE_DUAL_CHANNEL &&
 781                 c->channel_mode != SBC_CHANNEL_MODE_STEREO && c->channel_mode != SBC_CHANNEL_MODE_JOINT_STEREO) {
 782                 pa_log_error("Invalid channel mode in configuration");
 783                 goto fail;
 784             }
 785
 786             if (c->allocation_method != SBC_ALLOCATION_SNR && c->allocation_method != SBC_ALLOCATION_LOUDNESS) {
 787                 pa_log_error("Invalid allocation method in configuration");
 788                 goto fail;
 789             }
 790
 791             if (c->subbands != SBC_SUBBANDS_4 && c->subbands != SBC_SUBBANDS_8) {
 792                 pa_log_error("Invalid SBC subbands in configuration");
 793                 goto fail;
 794             }
 795
 796             if (c->block_length != SBC_BLOCK_LENGTH_4 && c->block_length != SBC_BLOCK_LENGTH_8 &&
 797                 c->block_length != SBC_BLOCK_LENGTH_12 && c->block_length != SBC_BLOCK_LENGTH_16) {
 798                 pa_log_error("Invalid block length in configuration");
 799                 goto fail;
 800             }
 801         }
 802
 803         dbus_message_iter_next(&props);
 804     }
 805
 806     if ((d = pa_hashmap_get(y->devices, dev_path))) {
 807         if (d->device_info_valid == -1) {
 808             pa_log_error("Information about device %s is invalid", dev_path);
 809             goto fail2;
 810         }
 811     } else {
 812         /* InterfacesAdded signal is probably on it's way, device_info_valid is kept as 0. */
 813         pa_log_warn("SetConfiguration() received for unknown device %s", dev_path);
 814         d = device_create(y, dev_path);
 815     }
 816
 817     if (d->transports[p] != NULL) {
 818         pa_log_error("Cannot configure transport %s because profile %s is already used", path, pa_bluetooth_profile_to_string(p));
 819         goto fail2;
 820     }
 821
 822     sender = dbus_message_get_sender(m);
 823
 824     pa_assert_se(r = dbus_message_new_method_return(m));
 825     pa_assert_se(dbus_connection_send(pa_dbus_connection_get(y->connection), r, NULL));
 826     dbus_message_unref(r);
 827
 828     d->transports[p] = t = pa_bluetooth_transport_new(d, sender, path, p, config, size);
 829     t->acquire = bluez5_transport_acquire_cb;
 830     t->release = bluez5_transport_release_cb;
 831     pa_bluetooth_transport_put(t);
 832
 833     pa_log_debug("Transport %s available for profile %s", t->path, pa_bluetooth_profile_to_string(t->profile));
 834
 835     return NULL;
 836
 837 fail:
 838     pa_log_error("Endpoint SetConfiguration(): invalid arguments");
 839
 840 fail2:
 841     pa_assert_se(r = dbus_message_new_error(m, "org.bluez.Error.InvalidArguments", "Unable to set configuration"));
 842     return r;
 843 }
 844
 845 static DBusMessage *endpoint_select_configuration(DBusConnection *conn, DBusMessage *m, void *userdata) {
 846     pa_bluetooth_discovery *y = userdata;
 847     a2dp_sbc_t *cap, config;
 848     uint8_t *pconf = (uint8_t *) &config;
 849     int i, size;
 850     DBusMessage *r;
 851     DBusError err;
 852
 853     static const struct {
 854         uint32_t rate;
 855         uint8_t cap;
 856     } freq_table[] = {
 857         { 16000U, SBC_SAMPLING_FREQ_16000 },
 858         { 32000U, SBC_SAMPLING_FREQ_32000 },
 859         { 44100U, SBC_SAMPLING_FREQ_44100 },
 860         { 48000U, SBC_SAMPLING_FREQ_48000 }
 861     };
 862
 863     dbus_error_init(&err);
 864
 865     if (!dbus_message_get_args(m, &err, DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &cap, &size, DBUS_TYPE_INVALID)) {
 866         pa_log_error("Endpoint SelectConfiguration(): %s", err.message);
 867         dbus_error_free(&err);
 868         goto fail;
 869     }
 870
 871     if (size != sizeof(config)) {
 872         pa_log_error("Capabilities array has invalid size");
 873         goto fail;
 874     }
 875
 876     pa_zero(config);
 877
 878     /* Find the lowest freq that is at least as high as the requested sampling rate */
 879     for (i = 0; (unsigned) i < PA_ELEMENTSOF(freq_table); i++)
 880         if (freq_table[i].rate >= y->core->default_sample_spec.rate && (cap->frequency & freq_table[i].cap)) {
 881             config.frequency = freq_table[i].cap;
 882             break;
 883         }
 884
 885     if ((unsigned) i == PA_ELEMENTSOF(freq_table)) {
 886         for (--i; i >= 0; i--) {
 887             if (cap->frequency & freq_table[i].cap) {
 888                 config.frequency = freq_table[i].cap;
 889                 break;
 890             }
 891         }
 892
 893         if (i < 0) {
 894             pa_log_error("Not suitable sample rate");
 895             goto fail;
 896         }
 897     }
 898
 899     pa_assert((unsigned) i < PA_ELEMENTSOF(freq_table));
 900
 901     if (y->core->default_sample_spec.channels <= 1) {
 902         if (cap->channel_mode & SBC_CHANNEL_MODE_MONO)
 903             config.channel_mode = SBC_CHANNEL_MODE_MONO;
 904         else if (cap->channel_mode & SBC_CHANNEL_MODE_JOINT_STEREO)
 905             config.channel_mode = SBC_CHANNEL_MODE_JOINT_STEREO;
 906         else if (cap->channel_mode & SBC_CHANNEL_MODE_STEREO)
 907             config.channel_mode = SBC_CHANNEL_MODE_STEREO;
 908         else if (cap->channel_mode & SBC_CHANNEL_MODE_DUAL_CHANNEL)
 909             config.channel_mode = SBC_CHANNEL_MODE_DUAL_CHANNEL;
 910         else {
 911             pa_log_error("No supported channel modes");
 912             goto fail;
 913         }
 914     }
 915
 916     if (y->core->default_sample_spec.channels >= 2) {
 917         if (cap->channel_mode & SBC_CHANNEL_MODE_JOINT_STEREO)
 918             config.channel_mode = SBC_CHANNEL_MODE_JOINT_STEREO;
 919         else if (cap->channel_mode & SBC_CHANNEL_MODE_STEREO)
 920             config.channel_mode = SBC_CHANNEL_MODE_STEREO;
 921         else if (cap->channel_mode & SBC_CHANNEL_MODE_DUAL_CHANNEL)
 922             config.channel_mode = SBC_CHANNEL_MODE_DUAL_CHANNEL;
 923         else if (cap->channel_mode & SBC_CHANNEL_MODE_MONO)
 924             config.channel_mode = SBC_CHANNEL_MODE_MONO;
 925         else {
 926             pa_log_error("No supported channel modes");
 927             goto fail;
 928         }
 929     }
 930
 931     if (cap->block_length & SBC_BLOCK_LENGTH_16)
 932         config.block_length = SBC_BLOCK_LENGTH_16;
 933     else if (cap->block_length & SBC_BLOCK_LENGTH_12)
 934         config.block_length = SBC_BLOCK_LENGTH_12;
 935     else if (cap->block_length & SBC_BLOCK_LENGTH_8)
 936         config.block_length = SBC_BLOCK_LENGTH_8;
 937     else if (cap->block_length & SBC_BLOCK_LENGTH_4)
 938         config.block_length = SBC_BLOCK_LENGTH_4;
 939     else {
 940         pa_log_error("No supported block lengths");
 941         goto fail;
 942     }
 943
 944     if (cap->subbands & SBC_SUBBANDS_8)
 945         config.subbands = SBC_SUBBANDS_8;
 946     else if (cap->subbands & SBC_SUBBANDS_4)
 947         config.subbands = SBC_SUBBANDS_4;
 948     else {
 949         pa_log_error("No supported subbands");
 950         goto fail;
 951     }
 952
 953     if (cap->allocation_method & SBC_ALLOCATION_LOUDNESS)
 954         config.allocation_method = SBC_ALLOCATION_LOUDNESS;
 955     else if (cap->allocation_method & SBC_ALLOCATION_SNR)
 956         config.allocation_method = SBC_ALLOCATION_SNR;
 957
 958     config.min_bitpool = (uint8_t) PA_MAX(MIN_BITPOOL, cap->min_bitpool);
 959     config.max_bitpool = (uint8_t) PA_MIN(a2dp_default_bitpool(config.frequency, config.channel_mode), cap->max_bitpool);
 960
 961     if (config.min_bitpool > config.max_bitpool)
 962         goto fail;
 963
 964     pa_assert_se(r = dbus_message_new_method_return(m));
 965     pa_assert_se(dbus_message_append_args(r, DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &pconf, size, DBUS_TYPE_INVALID));
 966
 967     return r;
 968
 969 fail:
 970     pa_assert_se(r = dbus_message_new_error(m, "org.bluez.Error.InvalidArguments", "Unable to select configuration"));
 971     return r;
 972 }
 973
 974 static DBusMessage *endpoint_clear_configuration(DBusConnection *conn, DBusMessage *m, void *userdata) {
 975     pa_bluetooth_discovery *y = userdata;
 976     pa_bluetooth_transport *t;
 977     DBusMessage *r;
 978     DBusError err;
 979     const char *path;
 980
 981     dbus_error_init(&err);
 982
 983     if (!dbus_message_get_args(m, &err, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID)) {
 984         pa_log_error("Endpoint ClearConfiguration(): %s", err.message);
 985         dbus_error_free(&err);
 986         goto fail;
 987     }
 988
 989     if ((t = pa_hashmap_get(y->transports, path))) {
 990         pa_log_debug("Clearing transport %s profile %s", t->path, pa_bluetooth_profile_to_string(t->profile));
 991         transport_state_changed(t, PA_BLUETOOTH_TRANSPORT_STATE_DISCONNECTED);
 992         pa_bluetooth_transport_free(t);
 993     }
 994
 995     pa_assert_se(r = dbus_message_new_method_return(m));
 996
 997     return r;
 998
 999 fail:
1000     pa_assert_se(r = dbus_message_new_error(m, "org.bluez.Error.InvalidArguments", "Unable to clear configuration"));
1001     return r;
1002 }
1003
1004 static DBusMessage *endpoint_release(DBusConnection *conn, DBusMessage *m, void *userdata) {
1005     DBusMessage *r;
1006
1007     pa_assert_se(r = dbus_message_new_error(m, BLUEZ_MEDIA_ENDPOINT_INTERFACE ".Error.NotImplemented",
1008                                             "Method not implemented"));
1009
1010     return r;
1011 }
1012
1013 static DBusHandlerResult endpoint_handler(DBusConnection *c, DBusMessage *m, void *userdata) {
1014     struct pa_bluetooth_discovery *y = userdata;
1015     DBusMessage *r = NULL;
1016     const char *path, *interface, *member;
1017
1018     pa_assert(y);
1019
1020     path = dbus_message_get_path(m);
1021     interface = dbus_message_get_interface(m);
1022     member = dbus_message_get_member(m);
1023
1024     pa_log_debug("dbus: path=%s, interface=%s, member=%s", path, interface, member);
1025
1026     if (!pa_streq(path, A2DP_SOURCE_ENDPOINT) && !pa_streq(path, A2DP_SINK_ENDPOINT))
1027         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1028
1029     if (dbus_message_is_method_call(m, "org.freedesktop.DBus.Introspectable", "Introspect")) {
1030         const char *xml = ENDPOINT_INTROSPECT_XML;
1031
1032         pa_assert_se(r = dbus_message_new_method_return(m));
1033         pa_assert_se(dbus_message_append_args(r, DBUS_TYPE_STRING, &xml, DBUS_TYPE_INVALID));
1034
1035     } else if (dbus_message_is_method_call(m, BLUEZ_MEDIA_ENDPOINT_INTERFACE, "SetConfiguration"))
1036         r = endpoint_set_configuration(c, m, userdata);
1037     else if (dbus_message_is_method_call(m, BLUEZ_MEDIA_ENDPOINT_INTERFACE, "SelectConfiguration"))
1038         r = endpoint_select_configuration(c, m, userdata);
1039     else if (dbus_message_is_method_call(m, BLUEZ_MEDIA_ENDPOINT_INTERFACE, "ClearConfiguration"))
1040         r = endpoint_clear_configuration(c, m, userdata);
1041     else if (dbus_message_is_method_call(m, BLUEZ_MEDIA_ENDPOINT_INTERFACE, "Release"))
1042         r = endpoint_release(c, m, userdata);
1043     else
1044         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1045
1046     if (r) {
1047         pa_assert_se(dbus_connection_send(pa_dbus_connection_get(y->connection), r, NULL));
1048         dbus_message_unref(r);
1049     }
1050
1051     return DBUS_HANDLER_RESULT_HANDLED;
1052 }
1053
1054 static void endpoint_init(pa_bluetooth_discovery *y, pa_bluetooth_profile_t profile) {
1055     static const DBusObjectPathVTable vtable_endpoint = {
1056         .message_function = endpoint_handler,
1057     };
1058
1059     pa_assert(y);
1060
1061     switch(profile) {
1062         case PA_BLUETOOTH_PROFILE_A2DP_SINK:
1063             pa_assert_se(dbus_connection_register_object_path(pa_dbus_connection_get(y->connection), A2DP_SOURCE_ENDPOINT,
1064                                                               &vtable_endpoint, y));
1065             break;
1066         case PA_BLUETOOTH_PROFILE_A2DP_SOURCE:
1067             pa_assert_se(dbus_connection_register_object_path(pa_dbus_connection_get(y->connection), A2DP_SINK_ENDPOINT,
1068                                                               &vtable_endpoint, y));
1069             break;
1070         default:
1071             pa_assert_not_reached();
1072             break;
1073     }
1074 }
1075
1076 static void endpoint_done(pa_bluetooth_discovery *y, pa_bluetooth_profile_t profile) {
1077     pa_assert(y);
1078
1079     switch(profile) {
1080         case PA_BLUETOOTH_PROFILE_A2DP_SINK:
1081             dbus_connection_unregister_object_path(pa_dbus_connection_get(y->connection), A2DP_SOURCE_ENDPOINT);
1082             break;
1083         case PA_BLUETOOTH_PROFILE_A2DP_SOURCE:
1084             dbus_connection_unregister_object_path(pa_dbus_connection_get(y->connection), A2DP_SINK_ENDPOINT);
1085             break;
1086         default:
1087             pa_assert_not_reached();
1088             break;
1089     }
1090 }
1091
1092 pa_bluetooth_discovery* pa_bluetooth_discovery_get(pa_core *c) {
1093     pa_bluetooth_discovery *y;
1094     DBusError err;
1095     DBusConnection *conn;
1096     unsigned i;
1097
1098     if ((y = pa_shared_get(c, "bluetooth-discovery")))
1099         return pa_bluetooth_discovery_ref(y);
1100
1101     y = pa_xnew0(pa_bluetooth_discovery, 1);
1102     PA_REFCNT_INIT(y);
1103     y->core = c;
1104     y->adapters = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
1105     y->devices = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
1106     y->transports = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
1107     PA_LLIST_HEAD_INIT(pa_dbus_pending, y->pending);
1108
1109     for (i = 0; i < PA_BLUETOOTH_HOOK_MAX; i++)
1110         pa_hook_init(&y->hooks[i], y);
1111
1112     pa_shared_set(c, "bluetooth-discovery", y);
1113
1114     dbus_error_init(&err);
1115
1116     if (!(y->connection = pa_dbus_bus_get(y->core, DBUS_BUS_SYSTEM, &err))) {
1117         pa_log_error("Failed to get D-Bus connection: %s", err.message);
1118         goto fail;
1119     }
1120
1121     conn = pa_dbus_connection_get(y->connection);
1122
1123     /* dynamic detection of bluetooth audio devices */
1124     if (!dbus_connection_add_filter(conn, filter_cb, y, NULL)) {
1125         pa_log_error("Failed to add filter function");
1126         goto fail;
1127     }
1128     y->filter_added = true;
1129
1130     if (pa_dbus_add_matches(conn, &err,
1131             "type='signal',sender='org.freedesktop.DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged'"
1132             ",arg0='" BLUEZ_SERVICE "'",
1133             "type='signal',sender='" BLUEZ_SERVICE "',interface='org.freedesktop.DBus.ObjectManager',member='InterfacesAdded'",
1134             "type='signal',sender='" BLUEZ_SERVICE "',interface='org.freedesktop.DBus.ObjectManager',"
1135             "member='InterfacesRemoved'",
1136             NULL) < 0) {
1137         pa_log_error("Failed to add D-Bus matches: %s", err.message);
1138         goto fail;
1139     }
1140     y->matches_added = true;
1141
1142     endpoint_init(y, PA_BLUETOOTH_PROFILE_A2DP_SINK);
1143     endpoint_init(y, PA_BLUETOOTH_PROFILE_A2DP_SOURCE);
1144
1145     get_managed_objects(y);
1146
1147     return y;
1148
1149 fail:
1150     pa_bluetooth_discovery_unref(y);
1151     dbus_error_free(&err);
1152
1153     return NULL;
1154 }
1155
1156 pa_bluetooth_discovery* pa_bluetooth_discovery_ref(pa_bluetooth_discovery *y) {
1157     pa_assert(y);
1158     pa_assert(PA_REFCNT_VALUE(y) > 0);
1159
1160     PA_REFCNT_INC(y);
1161
1162     return y;
1163 }
1164
1165 void pa_bluetooth_discovery_unref(pa_bluetooth_discovery *y) {
1166     pa_assert(y);
1167     pa_assert(PA_REFCNT_VALUE(y) > 0);
1168
1169     if (PA_REFCNT_DEC(y) > 0)
1170         return;
1171
1172     pa_dbus_free_pending_list(&y->pending);
1173
1174     if (y->devices) {
1175         device_remove_all(y);
1176         pa_hashmap_free(y->devices);
1177     }
1178
1179     if (y->adapters) {
1180         adapter_remove_all(y);
1181         pa_hashmap_free(y->adapters);
1182     }
1183
1184     if (y->transports) {
1185         pa_assert(pa_hashmap_isempty(y->transports));
1186         pa_hashmap_free(y->transports);
1187     }
1188
1189     if (y->connection) {
1190
1191         if (y->matches_added)
1192             pa_dbus_remove_matches(pa_dbus_connection_get(y->connection),
1193                 "type='signal',sender='org.freedesktop.DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',"
1194                 "arg0='" BLUEZ_SERVICE "'",
1195                 "type='signal',sender='" BLUEZ_SERVICE "',interface='org.freedesktop.DBus.ObjectManager',"
1196                 "member='InterfacesAdded'",
1197                 "type='signal',sender='" BLUEZ_SERVICE "',interface='org.freedesktop.DBus.ObjectManager',"
1198                 "member='InterfacesRemoved'",
1199                 NULL);
1200
1201         if (y->filter_added)
1202             dbus_connection_remove_filter(pa_dbus_connection_get(y->connection), filter_cb, y);
1203
1204         endpoint_done(y, PA_BLUETOOTH_PROFILE_A2DP_SINK);
1205         endpoint_done(y, PA_BLUETOOTH_PROFILE_A2DP_SOURCE);
1206
1207         pa_dbus_connection_unref(y->connection);
1208     }
1209
1210     pa_shared_remove(y->core, "bluetooth-discovery");
1211     pa_xfree(y);
1212 }