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

   1 /***
   2   This file is part of PulseAudio.
   3
   4   Copyright 2008 Joao 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 <pulsecore/core-util.h>
  27 #include <modules/dbus-util.h>
  28
  29 #include "bluetooth-util.h"
  30
  31 enum mode {
  32     MODE_FIND,
  33     MODE_GET,
  34     MODE_DISCOVER
  35 };
  36
  37 struct pa_bluetooth_discovery {
  38     DBusConnection *connection;
  39     PA_LLIST_HEAD(pa_dbus_pending, pending);
  40
  41     enum mode mode;
  42
  43     /* If mode == MODE_FIND look for a specific device by its address.
  44        If mode == MODE_GET look for a specific device by its path. */
  45     const char *looking_for;
  46     pa_bluetooth_device *found_device;
  47
  48     /* If looking_for is NULL we do long-time discovery */
  49     pa_hashmap *devices;
  50     pa_bluetooth_device_callback_t callback;
  51     struct userdata *userdata;
  52 };
  53
  54 static pa_bluetooth_uuid *uuid_new(const char *uuid) {
  55     pa_bluetooth_uuid *u;
  56
  57     u = pa_xnew(pa_bluetooth_uuid, 1);
  58     u->uuid = pa_xstrdup(uuid);
  59     PA_LLIST_INIT(pa_bluetooth_uuid, u);
  60
  61     return u;
  62 }
  63
  64 static void uuid_free(pa_bluetooth_uuid *u) {
  65     pa_assert(u);
  66
  67     pa_xfree(u->uuid);
  68     pa_xfree(u);
  69 }
  70
  71 static pa_bluetooth_device* device_new(const char *path) {
  72     pa_bluetooth_device *d;
  73
  74     d = pa_xnew(pa_bluetooth_device, 1);
  75
  76     d->device_info_valid = d->audio_sink_info_valid = d->headset_info_valid = 0;
  77
  78     d->data = NULL;
  79
  80     d->name = NULL;
  81     d->path = pa_xstrdup(path);
  82     d->paired = -1;
  83     d->alias = NULL;
  84     d->device_connected = -1;
  85     PA_LLIST_HEAD_INIT(pa_bluetooth_uuid, d->uuids);
  86     d->address = NULL;
  87     d->class = -1;
  88     d->trusted = -1;
  89
  90     d->audio_sink_connected = -1;
  91
  92     d->headset_connected = -1;
  93
  94     return d;
  95 }
  96
  97 void pa_bluetooth_device_free(pa_bluetooth_device *d) {
  98     pa_bluetooth_uuid *u;
  99
 100     pa_assert(d);
 101
 102     while ((u = d->uuids)) {
 103         PA_LLIST_REMOVE(pa_bluetooth_uuid, d->uuids, u);
 104         uuid_free(u);
 105     }
 106
 107     pa_xfree(d->name);
 108     pa_xfree(d->path);
 109     pa_xfree(d->alias);
 110     pa_xfree(d->address);
 111     pa_xfree(d);
 112 }
 113
 114 static pa_bool_t device_is_loaded(pa_bluetooth_device *d) {
 115     pa_assert(d);
 116
 117     return d->device_info_valid && (d->audio_sink_info_valid || d->headset_info_valid);
 118 }
 119
 120 static pa_bool_t device_is_audio(pa_bluetooth_device *d) {
 121     pa_assert(d);
 122
 123     pa_assert(d->device_info_valid);
 124     pa_assert(d->audio_sink_info_valid || d->headset_info_valid);
 125
 126     return d->device_info_valid > 0 &&
 127         (d->audio_sink_info_valid > 0 || d->headset_info_valid > 0);
 128 }
 129
 130 static int parse_device_property(pa_bluetooth_discovery *y, pa_bluetooth_device *d, DBusMessageIter *i) {
 131     const char *key;
 132     DBusMessageIter variant_i;
 133
 134     pa_assert(y);
 135     pa_assert(d);
 136     pa_assert(i);
 137
 138     if (dbus_message_iter_get_arg_type(i) != DBUS_TYPE_STRING) {
 139         pa_log("Property name not a string.");
 140         return -1;
 141     }
 142
 143     dbus_message_iter_get_basic(i, &key);
 144
 145     if (!dbus_message_iter_next(i))  {
 146         pa_log("Property value missing");
 147         return -1;
 148     }
 149
 150     if (dbus_message_iter_get_arg_type(i) != DBUS_TYPE_VARIANT) {
 151         pa_log("Property value not a variant.");
 152         return -1;
 153     }
 154
 155     dbus_message_iter_recurse(i, &variant_i);
 156
 157 /*     pa_log_debug("Parsing property org.bluez.Device.%s", key); */
 158
 159     switch (dbus_message_iter_get_arg_type(&variant_i)) {
 160
 161         case DBUS_TYPE_STRING: {
 162
 163             const char *value;
 164             dbus_message_iter_get_basic(&variant_i, &value);
 165
 166             if (pa_streq(key, "Name")) {
 167                 pa_xfree(d->name);
 168                 d->name = pa_xstrdup(value);
 169             } else if (pa_streq(key, "Alias")) {
 170                 pa_xfree(d->alias);
 171                 d->alias = pa_xstrdup(value);
 172             } else if (pa_streq(key, "Address")) {
 173                 pa_xfree(d->address);
 174                 d->address = pa_xstrdup(value);
 175             }
 176
 177 /*             pa_log_debug("Value %s", value); */
 178
 179             break;
 180         }
 181
 182         case DBUS_TYPE_BOOLEAN: {
 183
 184             dbus_bool_t value;
 185             dbus_message_iter_get_basic(&variant_i, &value);
 186
 187             if (pa_streq(key, "Paired"))
 188                 d->paired = !!value;
 189             else if (pa_streq(key, "Connected"))
 190                 d->device_connected = !!value;
 191             else if (pa_streq(key, "Trusted"))
 192                 d->trusted = !!value;
 193
 194 /*             pa_log_debug("Value %s", pa_yes_no(value)); */
 195
 196             break;
 197         }
 198
 199         case DBUS_TYPE_UINT32: {
 200
 201             uint32_t value;
 202             dbus_message_iter_get_basic(&variant_i, &value);
 203
 204             if (pa_streq(key, "Class"))
 205                 d->class = (int) value;
 206
 207 /*             pa_log_debug("Value %u", (unsigned) value); */
 208
 209             break;
 210         }
 211
 212         case DBUS_TYPE_ARRAY: {
 213
 214             DBusMessageIter ai;
 215             dbus_message_iter_recurse(&variant_i, &ai);
 216
 217             if (dbus_message_iter_get_arg_type(&ai) == DBUS_TYPE_STRING &&
 218                 pa_streq(key, "UUIDs")) {
 219
 220                 while (dbus_message_iter_get_arg_type(&ai) != DBUS_TYPE_INVALID) {
 221                     pa_bluetooth_uuid *node;
 222                     const char *value;
 223
 224                     dbus_message_iter_get_basic(&ai, &value);
 225                     node = uuid_new(value);
 226                     PA_LLIST_PREPEND(pa_bluetooth_uuid, d->uuids, node);
 227
 228                     if (!dbus_message_iter_next(&ai))
 229                         break;
 230                 }
 231             }
 232
 233             break;
 234         }
 235     }
 236
 237     return 0;
 238 }
 239
 240 static int parse_audio_property(pa_bluetooth_discovery *u, int *connected, DBusMessageIter *i) {
 241     const char *key;
 242     DBusMessageIter variant_i;
 243
 244     pa_assert(u);
 245     pa_assert(connected);
 246     pa_assert(i);
 247
 248     if (dbus_message_iter_get_arg_type(i) != DBUS_TYPE_STRING) {
 249         pa_log("Property name not a string.");
 250         return -1;
 251     }
 252
 253     dbus_message_iter_get_basic(i, &key);
 254
 255     if (!dbus_message_iter_next(i))  {
 256         pa_log("Property value missing");
 257         return -1;
 258     }
 259
 260     if (dbus_message_iter_get_arg_type(i) != DBUS_TYPE_VARIANT) {
 261         pa_log("Property value not a variant.");
 262         return -1;
 263     }
 264
 265     dbus_message_iter_recurse(i, &variant_i);
 266
 267 /*     pa_log_debug("Parsing property org.bluez.{AudioSink|Headset}.%s", key); */
 268
 269     switch (dbus_message_iter_get_arg_type(&variant_i)) {
 270
 271         case DBUS_TYPE_BOOLEAN: {
 272
 273             dbus_bool_t value;
 274             dbus_message_iter_get_basic(&variant_i, &value);
 275
 276             if (pa_streq(key, "Connected"))
 277                 *connected = !!value;
 278
 279 /*             pa_log_debug("Value %s", pa_yes_no(value)); */
 280
 281             break;
 282         }
 283     }
 284
 285     return 0;
 286 }
 287
 288 static void run_callback(pa_bluetooth_discovery *y, pa_bluetooth_device *d, pa_bool_t good) {
 289     pa_assert(y);
 290     pa_assert(d);
 291
 292     if (y->mode != MODE_DISCOVER)
 293         return;
 294
 295     if (!device_is_loaded(d))
 296         return;
 297
 298     if (!device_is_audio(d))
 299         return;
 300
 301     y->callback(y->userdata, d, good);
 302
 303 }
 304
 305 static void get_properties_reply(DBusPendingCall *pending, void *userdata) {
 306     DBusMessage *r;
 307     DBusMessageIter arg_i, element_i;
 308     pa_dbus_pending *p;
 309     pa_bluetooth_device *d;
 310     pa_bluetooth_discovery *y;
 311     int valid;
 312
 313     pa_assert_se(p = userdata);
 314     pa_assert_se(y = p->context_data);
 315     pa_assert_se(r = dbus_pending_call_steal_reply(pending));
 316
 317 /*     pa_log_debug("Got %s.GetProperties response for %s", */
 318 /*                  dbus_message_get_interface(p->message), */
 319 /*                  dbus_message_get_path(p->message)); */
 320
 321     d = p->call_data;
 322
 323     valid = dbus_message_get_type(r) == DBUS_MESSAGE_TYPE_ERROR ? -1 : 1;
 324
 325     if (dbus_message_is_method_call(p->message, "org.bluez.Device", "GetProperties"))
 326         d->device_info_valid = valid;
 327     else if (dbus_message_is_method_call(p->message, "org.bluez.Headset", "GetProperties"))
 328         d->headset_info_valid = valid;
 329     else if (dbus_message_is_method_call(p->message, "org.bluez.AudioSink", "GetProperties"))
 330         d->audio_sink_info_valid = valid;
 331
 332     if (dbus_message_get_type(r) == DBUS_MESSAGE_TYPE_ERROR) {
 333
 334         if (!dbus_message_is_error(r, DBUS_ERROR_UNKNOWN_METHOD))
 335             pa_log("Error from GetProperties reply: %s", dbus_message_get_error_name(r));
 336
 337         goto finish;
 338     }
 339
 340     if (!dbus_message_iter_init(r, &arg_i)) {
 341         pa_log("GetProperties reply has no arguments.");
 342         goto finish;
 343     }
 344
 345     if (dbus_message_iter_get_arg_type(&arg_i) != DBUS_TYPE_ARRAY) {
 346         pa_log("GetProperties argument is not an array.");
 347         goto finish;
 348     }
 349
 350     dbus_message_iter_recurse(&arg_i, &element_i);
 351     while (dbus_message_iter_get_arg_type(&element_i) != DBUS_TYPE_INVALID) {
 352
 353         if (dbus_message_iter_get_arg_type(&element_i) == DBUS_TYPE_DICT_ENTRY) {
 354             DBusMessageIter dict_i;
 355
 356             dbus_message_iter_recurse(&element_i, &dict_i);
 357
 358             if (dbus_message_has_interface(p->message, "org.bluez.Device")) {
 359                 if (parse_device_property(y, d, &dict_i) < 0)
 360                     goto finish;
 361
 362             } else if (dbus_message_has_interface(p->message, "org.bluez.Headset")) {
 363                 if (parse_audio_property(y, &d->headset_connected, &dict_i) < 0)
 364                     goto finish;
 365
 366             }  else if (dbus_message_has_interface(p->message, "org.bluez.AudioSink")) {
 367                 if (parse_audio_property(y, &d->audio_sink_connected, &dict_i) < 0)
 368                     goto finish;
 369             }
 370         }
 371
 372         if (!dbus_message_iter_next(&element_i))
 373             break;
 374     }
 375
 376 finish:
 377     run_callback(y, d, TRUE);
 378
 379     dbus_message_unref(r);
 380
 381     PA_LLIST_REMOVE(pa_dbus_pending, y->pending, p);
 382     pa_dbus_pending_free(p);
 383 }
 384
 385 static pa_dbus_pending* send_and_add_to_pending(pa_bluetooth_discovery *y, pa_bluetooth_device *d, DBusMessage *m, DBusPendingCallNotifyFunction func) {
 386     pa_dbus_pending *p;
 387     DBusPendingCall *call;
 388
 389     pa_assert(y);
 390     pa_assert(m);
 391
 392     pa_assert_se(dbus_connection_send_with_reply(y->connection, m, &call, -1));
 393
 394     p = pa_dbus_pending_new(m, call, y, d);
 395     PA_LLIST_PREPEND(pa_dbus_pending, y->pending, p);
 396     dbus_pending_call_set_notify(call, func, p, NULL);
 397
 398     return p;
 399 }
 400
 401 static void found_device(pa_bluetooth_discovery *y, const char* path) {
 402     DBusMessage *m;
 403     pa_bluetooth_device *d;
 404
 405     pa_assert(y);
 406     pa_assert(path);
 407
 408     d = device_new(path);
 409
 410     if (y->mode == MODE_DISCOVER) {
 411         pa_assert(y->devices);
 412         pa_hashmap_put(y->devices, d->path, d);
 413     } else {
 414         pa_assert(!y->found_device);
 415         y->found_device = d;
 416     }
 417
 418     pa_assert_se(m = dbus_message_new_method_call("org.bluez", path, "org.bluez.Device", "GetProperties"));
 419     send_and_add_to_pending(y, d, m, get_properties_reply);
 420
 421     pa_assert_se(m = dbus_message_new_method_call("org.bluez", path, "org.bluez.Headset", "GetProperties"));
 422     send_and_add_to_pending(y, d, m, get_properties_reply);
 423
 424     pa_assert_se(m = dbus_message_new_method_call("org.bluez", path, "org.bluez.AudioSink", "GetProperties"));
 425     send_and_add_to_pending(y, d, m, get_properties_reply);
 426 }
 427
 428 static void list_devices_reply(DBusPendingCall *pending, void *userdata) {
 429     DBusError e;
 430     DBusMessage *r;
 431     char **paths = NULL;
 432     int num = -1;
 433     pa_dbus_pending *p;
 434     pa_bluetooth_discovery *y;
 435
 436     pa_assert(pending);
 437
 438     dbus_error_init(&e);
 439
 440     pa_assert_se(p = userdata);
 441     pa_assert_se(y = p->context_data);
 442     pa_assert_se(r = dbus_pending_call_steal_reply(pending));
 443
 444     if (dbus_message_get_type(r) == DBUS_MESSAGE_TYPE_ERROR) {
 445         pa_log("Error from ListDevices reply: %s", dbus_message_get_error_name(r));
 446         goto end;
 447     }
 448
 449     if (!dbus_message_get_args(r, &e, DBUS_TYPE_ARRAY, DBUS_TYPE_OBJECT_PATH, &paths, &num, DBUS_TYPE_INVALID)) {
 450         pa_log("org.bluez.Adapter.ListDevices returned an error: '%s'\n", e.message);
 451         dbus_error_free(&e);
 452     } else {
 453         int i;
 454
 455         for (i = 0; i < num; ++i)
 456             found_device(y, paths[i]);
 457     }
 458
 459 end:
 460     if (paths)
 461         dbus_free_string_array (paths);
 462
 463     dbus_message_unref(r);
 464
 465     PA_LLIST_REMOVE(pa_dbus_pending, y->pending, p);
 466     pa_dbus_pending_free(p);
 467 }
 468
 469 static void find_device_reply(DBusPendingCall *pending, void *userdata) {
 470     DBusError e;
 471     DBusMessage *r;
 472     char *path = NULL;
 473     pa_dbus_pending *p;
 474     pa_bluetooth_discovery *y;
 475
 476     pa_assert(pending);
 477
 478     dbus_error_init(&e);
 479
 480     pa_assert_se(p = userdata);
 481     pa_assert_se(y = p->context_data);
 482     pa_assert_se(r = dbus_pending_call_steal_reply(pending));
 483
 484     if (dbus_message_get_type(r) == DBUS_MESSAGE_TYPE_ERROR) {
 485         pa_log("Error from FindDevice reply: %s", dbus_message_get_error_name(r));
 486         goto end;
 487     }
 488
 489     if (!dbus_message_get_args(r, &e, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID)) {
 490         pa_log("org.bluez.Adapter.FindDevice returned an error: '%s'\n", e.message);
 491         dbus_error_free(&e);
 492     } else
 493         found_device(y, path);
 494
 495 end:
 496     dbus_message_unref(r);
 497
 498     PA_LLIST_REMOVE(pa_dbus_pending, y->pending, p);
 499     pa_dbus_pending_free(p);
 500 }
 501
 502 static void found_adapter(pa_bluetooth_discovery *y, const char *path) {
 503     DBusMessage *m;
 504
 505     if (y->mode == MODE_FIND) {
 506         pa_assert_se(m = dbus_message_new_method_call("org.bluez", path, "org.bluez.Adapter", "FindDevice"));
 507
 508         pa_assert_se(dbus_message_append_args(m,
 509                                               DBUS_TYPE_STRING, &y->looking_for,
 510                                               DBUS_TYPE_INVALID));
 511
 512         send_and_add_to_pending(y, NULL, m, find_device_reply);
 513
 514     } else {
 515         pa_assert(y->mode == MODE_DISCOVER);
 516
 517         pa_assert_se(m = dbus_message_new_method_call("org.bluez", path, "org.bluez.Adapter", "ListDevices"));
 518         send_and_add_to_pending(y, NULL, m, list_devices_reply);
 519     }
 520 }
 521
 522 static void list_adapters_reply(DBusPendingCall *pending, void *userdata) {
 523     DBusError e;
 524     DBusMessage *r;
 525     char **paths = NULL;
 526     int num = -1;
 527     pa_dbus_pending *p;
 528     pa_bluetooth_discovery *y;
 529
 530     pa_assert(pending);
 531
 532     dbus_error_init(&e);
 533
 534     pa_assert_se(p = userdata);
 535     pa_assert_se(y = p->context_data);
 536     pa_assert_se(r = dbus_pending_call_steal_reply(pending));
 537
 538     if (dbus_message_get_type(r) == DBUS_MESSAGE_TYPE_ERROR) {
 539         pa_log("Error from ListAdapters reply: %s", dbus_message_get_error_name(r));
 540         goto end;
 541     }
 542
 543     if (!dbus_message_get_args(r, &e, DBUS_TYPE_ARRAY, DBUS_TYPE_OBJECT_PATH, &paths, &num, DBUS_TYPE_INVALID)) {
 544         pa_log("org.bluez.Manager.ListAdapters returned an error: %s", e.message);
 545         dbus_error_free(&e);
 546     } else {
 547         int i;
 548
 549         for (i = 0; i < num; ++i)
 550             found_adapter(y, paths[i]);
 551     }
 552
 553 end:
 554     if (paths)
 555         dbus_free_string_array (paths);
 556
 557     dbus_message_unref(r);
 558
 559     PA_LLIST_REMOVE(pa_dbus_pending, y->pending, p);
 560     pa_dbus_pending_free(p);
 561 }
 562
 563 static void list_adapters(pa_bluetooth_discovery *y) {
 564     DBusMessage *m;
 565     pa_assert(y);
 566
 567     pa_assert_se(m = dbus_message_new_method_call("org.bluez", "/", "org.bluez.Manager", "ListAdapters"));
 568     send_and_add_to_pending(y, NULL, m, list_adapters_reply);
 569 }
 570
 571 static DBusHandlerResult filter_cb(DBusConnection *bus, DBusMessage *m, void *userdata) {
 572     DBusError err;
 573     pa_bluetooth_discovery *y;
 574
 575     pa_assert(bus);
 576     pa_assert(m);
 577
 578     pa_assert_se(y = userdata);
 579
 580     dbus_error_init(&err);
 581
 582     pa_log_debug("dbus: interface=%s, path=%s, member=%s\n",
 583             dbus_message_get_interface(m),
 584             dbus_message_get_path(m),
 585             dbus_message_get_member(m));
 586
 587     if (dbus_message_is_signal(m, "org.bluez.Adapter", "DeviceRemoved")) {
 588         const char *path;
 589         pa_bluetooth_device *d;
 590
 591         if (!dbus_message_get_args(m, &err, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID)) {
 592             pa_log("Failed to parse org.bluez.Adapter.DeviceRemoved: %s", err.message);
 593             goto fail;
 594         }
 595
 596         pa_log_debug("Device %s removed", path);
 597
 598         if ((d = pa_hashmap_remove(y->devices, path))) {
 599
 600             pa_assert_se(y->mode == MODE_DISCOVER);
 601             run_callback(y, d, FALSE);
 602
 603             pa_bluetooth_device_free(d);
 604         }
 605
 606         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 607
 608     } else if (dbus_message_is_signal(m, "org.bluez.Adapter", "DeviceCreated")) {
 609         const char *path;
 610
 611         if (!dbus_message_get_args(m, &err, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID)) {
 612             pa_log("Failed to parse org.bluez.Adapter.DeviceCreated: %s", err.message);
 613             goto fail;
 614         }
 615
 616         pa_log_debug("Device %s created", path);
 617
 618         found_device(y, path);
 619         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 620
 621     } else if (dbus_message_is_signal(m, "org.bluez.Manager", "AdapterAdded")) {
 622         const char *path;
 623
 624         if (!dbus_message_get_args(m, &err, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID)) {
 625             pa_log("Failed to parse org.bluez.Manager.AdapterAdded: %s", err.message);
 626             goto fail;
 627         }
 628
 629         pa_log_debug("Adapter %s created", path);
 630
 631         found_adapter(y, path);
 632         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 633
 634     } else if (dbus_message_is_signal(m, "org.bluez.Headset", "PropertyChanged") ||
 635                dbus_message_is_signal(m, "org.bluez.AudioSink", "PropertyChanged") ||
 636                dbus_message_is_signal(m, "org.bluez.Device", "PropertyChanged")) {
 637
 638         pa_bluetooth_device *d;
 639
 640         if ((d = pa_hashmap_get(y->devices, dbus_message_get_path(m)))) {
 641             DBusMessageIter arg_i;
 642
 643             if (!dbus_message_iter_init(m, &arg_i)) {
 644                 pa_log("Failed to parse PropertyChanged: %s", err.message);
 645                 goto fail;
 646             }
 647
 648             if (dbus_message_has_interface(m, "org.bluez.Device")) {
 649                 if (parse_device_property(y, d, &arg_i) < 0)
 650                     goto fail;
 651
 652             } else if (dbus_message_has_interface(m, "org.bluez.Headset")) {
 653                 if (parse_audio_property(y, &d->headset_connected, &arg_i) < 0)
 654                     goto fail;
 655                 d->headset_info_valid = 1;
 656
 657             }  else if (dbus_message_has_interface(m, "org.bluez.AudioSink")) {
 658                 if (parse_audio_property(y, &d->audio_sink_connected, &arg_i) < 0)
 659                     goto fail;
 660                 d->audio_sink_info_valid = 1;
 661             }
 662
 663             pa_assert_se(y->mode == MODE_DISCOVER);
 664             run_callback(y, d, TRUE);
 665         }
 666
 667         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 668     }
 669
 670 fail:
 671     dbus_error_free(&err);
 672
 673     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 674 }
 675
 676 pa_bluetooth_device* pa_bluetooth_find_device(DBusConnection *c, const char* address) {
 677     pa_bluetooth_discovery y;
 678
 679     memset(&y, 0, sizeof(y));
 680     y.mode = MODE_FIND;
 681     y.looking_for = address;
 682     y.connection = c;
 683     PA_LLIST_HEAD_INIT(pa_dbus_pending, y.pending);
 684
 685     list_adapters(&y);
 686
 687     pa_dbus_sync_pending_list(&y.pending);
 688     pa_assert(!y.pending);
 689
 690     if (y.found_device) {
 691         pa_assert(device_is_loaded(y.found_device));
 692
 693         if (!device_is_audio(y.found_device)) {
 694             pa_bluetooth_device_free(y.found_device);
 695             return NULL;
 696         }
 697     }
 698
 699     return y.found_device;
 700 }
 701
 702 pa_bluetooth_device* pa_bluetooth_get_device(DBusConnection *c, const char* path) {
 703     pa_bluetooth_discovery y;
 704
 705     memset(&y, 0, sizeof(y));
 706     y.mode = MODE_GET;
 707     y.connection = c;
 708     PA_LLIST_HEAD_INIT(pa_dbus_pending, y.pending);
 709
 710     found_device(&y, path);
 711
 712     pa_dbus_sync_pending_list(&y.pending);
 713     pa_assert(!y.pending);
 714
 715     if (y.found_device) {
 716         pa_assert(device_is_loaded(y.found_device));
 717
 718         if (!device_is_audio(y.found_device)) {
 719             pa_bluetooth_device_free(y.found_device);
 720             return NULL;
 721         }
 722     }
 723
 724     return y.found_device;
 725 }
 726
 727 pa_bluetooth_discovery* pa_bluetooth_discovery_new(DBusConnection *c, pa_bluetooth_device_callback_t cb, struct userdata *u) {
 728     DBusError err;
 729     pa_bluetooth_discovery *y;
 730
 731     pa_assert(c);
 732     pa_assert(cb);
 733
 734     dbus_error_init(&err);
 735
 736     y = pa_xnew0(pa_bluetooth_discovery, 1);
 737     y->mode = MODE_DISCOVER;
 738     y->connection = c;
 739     y->callback = cb;
 740     y->userdata = u;
 741     y->devices = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
 742     PA_LLIST_HEAD_INIT(pa_dbus_pending, y->pending);
 743
 744     /* dynamic detection of bluetooth audio devices */
 745     if (!dbus_connection_add_filter(c, filter_cb, y, NULL)) {
 746         pa_log_error("Failed to add filter function");
 747         goto fail;
 748     }
 749
 750     if (pa_dbus_add_matches(
 751                 c, &err,
 752                 "type='signal',sender='org.bluez',interface='org.bluez.Manager',member='AdapterAdded'",
 753                 "type='signal',sender='org.bluez',interface='org.bluez.Adapter',member='DeviceRemoved'",
 754                 "type='signal',sender='org.bluez',interface='org.bluez.Adapter',member='DeviceCreated'",
 755                 "type='signal',sender='org.bluez',interface='org.bluez.Device',member='PropertyChanged'",
 756                 "type='signal',sender='org.bluez',interface='org.bluez.Headset',member='PropertyChanged'",
 757                 "type='signal',sender='org.bluez',interface='org.bluez.AudioSink',member='PropertyChanged'", NULL) < 0) {
 758         pa_log("Failed to add D-Bus matches: %s", err.message);
 759         goto fail;
 760     }
 761
 762     list_adapters(y);
 763
 764     return y;
 765
 766 fail:
 767     dbus_error_free(&err);
 768     return NULL;
 769 }
 770
 771 void pa_bluetooth_discovery_free(pa_bluetooth_discovery *y) {
 772     pa_bluetooth_device *d;
 773
 774     pa_assert(y);
 775
 776     pa_dbus_free_pending_list(&y->pending);
 777
 778     if (y->devices) {
 779         while ((d = pa_hashmap_steal_first(y->devices))) {
 780             run_callback(y, d, FALSE);
 781             pa_bluetooth_device_free(d);
 782         }
 783
 784         pa_hashmap_free(y->devices, NULL, NULL);
 785     }
 786
 787     if (y->connection) {
 788         pa_dbus_remove_matches(y->connection,
 789                                "type='signal',sender='org.bluez',interface='org.bluez.Manager',member='AdapterAdded'",
 790                                "type='signal',sender='org.bluez',interface='org.bluez.Manager',member='AdapterRemoved'",
 791                                "type='signal',sender='org.bluez',interface='org.bluez.Adapter',member='DeviceRemoved'",
 792                                "type='signal',sender='org.bluez',interface='org.bluez.Adapter',member='DeviceCreated'",
 793                                "type='signal',sender='org.bluez',interface='org.bluez.Device',member='PropertyChanged'",
 794                                "type='signal',sender='org.bluez',interface='org.bluez.Headset',member='PropertyChanged'",
 795                                "type='signal',sender='org.bluez',interface='org.bluez.AudioSink',member='PropertyChanged'", NULL);
 796
 797         dbus_connection_remove_filter(y->connection, filter_cb, y);
 798     }
 799 }
 800
 801 void pa_bluetooth_discovery_sync(pa_bluetooth_discovery *y) {
 802     pa_assert(y);
 803
 804     pa_dbus_sync_pending_list(&y->pending);
 805 }
 806
 807 const char*pa_bluetooth_get_form_factor(uint32_t class) {
 808     unsigned i;
 809     const char *r;
 810
 811     static const char * const table[] = {
 812         [1] = "headset",
 813         [2] = "hands-free",
 814         [4] = "microphone",
 815         [5] = "speaker",
 816         [6] = "headphone",
 817         [7] = "portable",
 818         [8] = "car",
 819         [10] = "hifi"
 820     };
 821
 822     if (((class >> 8) & 31) != 4)
 823         return NULL;
 824
 825     if ((i = (class >> 2) & 63) > PA_ELEMENTSOF(table))
 826         r =  NULL;
 827     else
 828         r = table[i];
 829
 830     if (!r)
 831         pa_log_debug("Unknown Bluetooth minor device class %u", i);
 832
 833     return r;
 834 }
 835
 836 char *pa_bluetooth_cleanup_name(const char *name) {
 837     char *t, *s, *d;
 838     pa_bool_t space = FALSE;
 839
 840     pa_assert(name);
 841
 842     while ((*name >= 1 && *name <= 32) || *name >= 127)
 843         name++;
 844
 845     t = pa_xstrdup(name);
 846
 847     for (s = d = t; *s; s++) {
 848
 849         if (*s <= 32 || *s >= 127 || *s == '_') {
 850             space = TRUE;
 851             continue;
 852         }
 853
 854         if (space) {
 855             *(d++) = ' ';
 856             space = FALSE;
 857         }
 858
 859         *(d++) = *s;
 860     }
 861
 862     *d = 0;
 863
 864     return t;
 865 }