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