profiles/audio/transport.c

   1 /*
   2  *
   3  *  BlueZ - Bluetooth protocol stack for Linux
   4  *
   5  *  Copyright (C) 2006-2007  Nokia Corporation
   6  *  Copyright (C) 2004-2009  Marcel Holtmann <marcel@holtmann.org>
   7  *
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the Free Software
  21  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  22  *
  23  */
  24
  25 #ifdef HAVE_CONFIG_H
  26 #include <config.h>
  27 #endif
  28
  29 #include <errno.h>
  30
  31 #include <glib.h>
  32
  33 #ifdef __TIZEN_PATCH__
  34 #include <sys/types.h>
  35 #include <sys/xattr.h>
  36 #include <linux/xattr.h>
  37 #endif
  38
  39 #include "lib/bluetooth.h"
  40 #include "lib/sdp.h"
  41 #include "lib/uuid.h"
  42
  43 #include "gdbus/gdbus.h"
  44
  45 #include "src/adapter.h"
  46 #include "src/device.h"
  47 #include "src/dbus-common.h"
  48
  49 #include "src/log.h"
  50 #include "src/error.h"
  51 #include "src/shared/queue.h"
  52
  53 #include "avdtp.h"
  54 #include "media.h"
  55 #include "transport.h"
  56 #include "a2dp.h"
  57 #include "sink.h"
  58 #include "source.h"
  59 #include "avrcp.h"
  60
  61 #define MEDIA_TRANSPORT_INTERFACE "org.bluez.MediaTransport1"
  62
  63 typedef enum {
  64         TRANSPORT_STATE_IDLE,           /* Not acquired and suspended */
  65         TRANSPORT_STATE_PENDING,        /* Playing but not acquired */
  66         TRANSPORT_STATE_REQUESTING,     /* Acquire in progress */
  67         TRANSPORT_STATE_ACTIVE,         /* Acquired and playing */
  68         TRANSPORT_STATE_SUSPENDING,     /* Release in progress */
  69 } transport_state_t;
  70
  71 static char *str_state[] = {
  72         "TRANSPORT_STATE_IDLE",
  73         "TRANSPORT_STATE_PENDING",
  74         "TRANSPORT_STATE_REQUESTING",
  75         "TRANSPORT_STATE_ACTIVE",
  76         "TRANSPORT_STATE_SUSPENDING",
  77 };
  78
  79 struct media_request {
  80         DBusMessage             *msg;
  81         guint                   id;
  82 };
  83
  84 struct media_owner {
  85         struct media_transport  *transport;
  86         struct media_request    *pending;
  87         char                    *name;
  88         guint                   watch;
  89 };
  90
  91 struct a2dp_transport {
  92         struct avdtp            *session;
  93         uint16_t                delay;
  94         uint16_t                volume;
  95 };
  96
  97 struct media_transport {
  98         char                    *path;          /* Transport object path */
  99         struct btd_device       *device;        /* Transport device */
 100         struct media_endpoint   *endpoint;      /* Transport endpoint */
 101         struct media_owner      *owner;         /* Transport owner */
 102         uint8_t                 *configuration; /* Transport configuration */
 103         int                     size;           /* Transport configuration size */
 104         int                     fd;             /* Transport file descriptor */
 105         uint16_t                imtu;           /* Transport input mtu */
 106         uint16_t                omtu;           /* Transport output mtu */
 107         transport_state_t       state;
 108         guint                   hs_watch;
 109         guint                   source_watch;
 110         guint                   sink_watch;
 111         guint                   (*resume) (struct media_transport *transport,
 112                                         struct media_owner *owner);
 113         guint                   (*suspend) (struct media_transport *transport,
 114                                         struct media_owner *owner);
 115         void                    (*cancel) (struct media_transport *transport,
 116                                                                 guint id);
 117         GDestroyNotify          destroy;
 118         void                    *data;
 119 };
 120
 121 static GSList *transports = NULL;
 122
 123 static const char *state2str(transport_state_t state)
 124 {
 125         switch (state) {
 126         case TRANSPORT_STATE_IDLE:
 127         case TRANSPORT_STATE_REQUESTING:
 128                 return "idle";
 129         case TRANSPORT_STATE_PENDING:
 130                 return "pending";
 131         case TRANSPORT_STATE_ACTIVE:
 132         case TRANSPORT_STATE_SUSPENDING:
 133                 return "active";
 134         }
 135
 136         return NULL;
 137 }
 138
 139 static gboolean state_in_use(transport_state_t state)
 140 {
 141         switch (state) {
 142         case TRANSPORT_STATE_IDLE:
 143         case TRANSPORT_STATE_PENDING:
 144                 return FALSE;
 145         case TRANSPORT_STATE_REQUESTING:
 146         case TRANSPORT_STATE_ACTIVE:
 147         case TRANSPORT_STATE_SUSPENDING:
 148                 return TRUE;
 149         }
 150
 151         return FALSE;
 152 }
 153
 154 static void transport_set_state(struct media_transport *transport,
 155                                                         transport_state_t state)
 156 {
 157         transport_state_t old_state = transport->state;
 158         const char *str;
 159
 160         if (old_state == state)
 161                 return;
 162
 163         transport->state = state;
 164
 165         DBG("State changed %s: %s -> %s", transport->path, str_state[old_state],
 166                                                         str_state[state]);
 167
 168         str = state2str(state);
 169
 170         if (g_strcmp0(str, state2str(old_state)) != 0)
 171                 g_dbus_emit_property_changed(btd_get_dbus_connection(),
 172                                                 transport->path,
 173                                                 MEDIA_TRANSPORT_INTERFACE,
 174                                                 "State");
 175 }
 176
 177 void media_transport_destroy(struct media_transport *transport)
 178 {
 179         char *path;
 180
 181         if (transport->sink_watch)
 182                 sink_remove_state_cb(transport->sink_watch);
 183
 184         if (transport->source_watch)
 185                 source_remove_state_cb(transport->source_watch);
 186
 187         path = g_strdup(transport->path);
 188         g_dbus_unregister_interface(btd_get_dbus_connection(), path,
 189                                                 MEDIA_TRANSPORT_INTERFACE);
 190
 191         g_free(path);
 192 }
 193
 194 static struct media_request *media_request_create(DBusMessage *msg, guint id)
 195 {
 196         struct media_request *req;
 197
 198         req = g_new0(struct media_request, 1);
 199         req->msg = dbus_message_ref(msg);
 200         req->id = id;
 201
 202         DBG("Request created: method=%s id=%u", dbus_message_get_member(msg),
 203                                                                         id);
 204
 205         return req;
 206 }
 207
 208 static void media_request_reply(struct media_request *req, int err)
 209 {
 210         DBusMessage *reply;
 211
 212         DBG("Request %s Reply %s", dbus_message_get_member(req->msg),
 213                                                         strerror(err));
 214
 215         if (!err)
 216                 reply = g_dbus_create_reply(req->msg, DBUS_TYPE_INVALID);
 217         else
 218                 reply = g_dbus_create_error(req->msg,
 219                                                 ERROR_INTERFACE ".Failed",
 220                                                 "%s", strerror(err));
 221
 222         g_dbus_send_message(btd_get_dbus_connection(), reply);
 223 }
 224
 225 static void media_owner_remove(struct media_owner *owner)
 226 {
 227         struct media_transport *transport = owner->transport;
 228         struct media_request *req = owner->pending;
 229
 230         if (!req)
 231                 return;
 232
 233         DBG("Owner %s Request %s", owner->name,
 234                                         dbus_message_get_member(req->msg));
 235
 236         if (req->id)
 237                 transport->cancel(transport, req->id);
 238
 239         owner->pending = NULL;
 240         if (req->msg)
 241                 dbus_message_unref(req->msg);
 242
 243         g_free(req);
 244 }
 245
 246 static void media_owner_free(struct media_owner *owner)
 247 {
 248         DBG("Owner %s", owner->name);
 249
 250         media_owner_remove(owner);
 251
 252         g_free(owner->name);
 253         g_free(owner);
 254 }
 255
 256 static void media_transport_remove_owner(struct media_transport *transport)
 257 {
 258         struct media_owner *owner = transport->owner;
 259
 260         DBG("Transport %s Owner %s", transport->path, owner->name);
 261
 262         /* Reply if owner has a pending request */
 263         if (owner->pending)
 264                 media_request_reply(owner->pending, EIO);
 265
 266         transport->owner = NULL;
 267
 268         if (owner->watch)
 269                 g_dbus_remove_watch(btd_get_dbus_connection(), owner->watch);
 270
 271         media_owner_free(owner);
 272
 273         if (state_in_use(transport->state))
 274                 transport->suspend(transport, NULL);
 275 }
 276
 277 static gboolean media_transport_set_fd(struct media_transport *transport,
 278                                         int fd, uint16_t imtu, uint16_t omtu)
 279 {
 280         if (transport->fd == fd)
 281                 return TRUE;
 282
 283         transport->fd = fd;
 284         transport->imtu = imtu;
 285         transport->omtu = omtu;
 286
 287         info("%s: fd(%d) ready", transport->path, fd);
 288
 289         return TRUE;
 290 }
 291
 292 static void a2dp_resume_complete(struct avdtp *session,
 293                                 struct avdtp_error *err, void *user_data)
 294 {
 295         struct media_owner *owner = user_data;
 296         struct media_request *req = owner->pending;
 297         struct media_transport *transport = owner->transport;
 298         struct a2dp_sep *sep = media_endpoint_get_sep(transport->endpoint);
 299         struct avdtp_stream *stream;
 300         int fd;
 301         uint16_t imtu, omtu;
 302         gboolean ret;
 303
 304         req->id = 0;
 305
 306         if (err)
 307                 goto fail;
 308
 309         stream = a2dp_sep_get_stream(sep);
 310         if (stream == NULL)
 311                 goto fail;
 312
 313         ret = avdtp_stream_get_transport(stream, &fd, &imtu, &omtu, NULL);
 314         if (ret == FALSE)
 315                 goto fail;
 316
 317         media_transport_set_fd(transport, fd, imtu, omtu);
 318
 319 #ifdef __TIZEN_PATCH__
 320         {
 321                 DBG("Set smack label!");
 322                 int ret;
 323
 324                 ret = fsetxattr(fd, XATTR_NAME_SMACKIPIN, "System", sizeof("System"), 0);
 325                 if (ret != 0) {
 326                         DBG("Set attr error: %d", ret);
 327                 }
 328
 329                 ret = fsetxattr(fd, XATTR_NAME_SMACKIPOUT, "System", sizeof("System"), 0);
 330                 if (ret != 0) {
 331                         DBG("Set attr error: %d", ret);
 332                 }
 333         }
 334 #endif
 335
 336         ret = g_dbus_send_reply(btd_get_dbus_connection(), req->msg,
 337                                                 DBUS_TYPE_UNIX_FD, &fd,
 338                                                 DBUS_TYPE_UINT16, &imtu,
 339                                                 DBUS_TYPE_UINT16, &omtu,
 340                                                 DBUS_TYPE_INVALID);
 341         if (ret == FALSE)
 342                 goto fail;
 343
 344         media_owner_remove(owner);
 345
 346         transport_set_state(transport, TRANSPORT_STATE_ACTIVE);
 347
 348         return;
 349
 350 fail:
 351         media_transport_remove_owner(transport);
 352 }
 353
 354 static guint resume_a2dp(struct media_transport *transport,
 355                                 struct media_owner *owner)
 356 {
 357         struct a2dp_transport *a2dp = transport->data;
 358         struct media_endpoint *endpoint = transport->endpoint;
 359         struct a2dp_sep *sep = media_endpoint_get_sep(endpoint);
 360         guint id;
 361
 362         if (a2dp->session == NULL) {
 363                 a2dp->session = a2dp_avdtp_get(transport->device);
 364                 if (a2dp->session == NULL)
 365                         return 0;
 366         }
 367
 368         if (state_in_use(transport->state))
 369                 return a2dp_resume(a2dp->session, sep, a2dp_resume_complete,
 370                                                                         owner);
 371
 372         if (a2dp_sep_lock(sep, a2dp->session) == FALSE)
 373                 return 0;
 374
 375         id = a2dp_resume(a2dp->session, sep, a2dp_resume_complete, owner);
 376
 377         if (id == 0) {
 378                 a2dp_sep_unlock(sep, a2dp->session);
 379                 return 0;
 380         }
 381
 382         if (transport->state == TRANSPORT_STATE_IDLE)
 383                 transport_set_state(transport, TRANSPORT_STATE_REQUESTING);
 384
 385         return id;
 386 }
 387
 388 static void a2dp_suspend_complete(struct avdtp *session,
 389                                 struct avdtp_error *err, void *user_data)
 390 {
 391         struct media_owner *owner = user_data;
 392         struct media_transport *transport = owner->transport;
 393         struct a2dp_transport *a2dp = transport->data;
 394         struct a2dp_sep *sep = media_endpoint_get_sep(transport->endpoint);
 395
 396         /* Release always succeeds */
 397         if (owner->pending) {
 398                 owner->pending->id = 0;
 399                 media_request_reply(owner->pending, 0);
 400                 media_owner_remove(owner);
 401         }
 402
 403         a2dp_sep_unlock(sep, a2dp->session);
 404         transport_set_state(transport, TRANSPORT_STATE_IDLE);
 405         media_transport_remove_owner(transport);
 406 }
 407
 408 static guint suspend_a2dp(struct media_transport *transport,
 409                                                 struct media_owner *owner)
 410 {
 411         struct a2dp_transport *a2dp = transport->data;
 412         struct media_endpoint *endpoint = transport->endpoint;
 413         struct a2dp_sep *sep = media_endpoint_get_sep(endpoint);
 414
 415         if (owner != NULL)
 416                 return a2dp_suspend(a2dp->session, sep, a2dp_suspend_complete,
 417                                                                         owner);
 418
 419         transport_set_state(transport, TRANSPORT_STATE_IDLE);
 420         a2dp_sep_unlock(sep, a2dp->session);
 421
 422         return 0;
 423 }
 424
 425 static void cancel_a2dp(struct media_transport *transport, guint id)
 426 {
 427         a2dp_cancel(id);
 428 }
 429
 430 static void media_owner_exit(DBusConnection *connection, void *user_data)
 431 {
 432         struct media_owner *owner = user_data;
 433
 434         owner->watch = 0;
 435
 436         media_owner_remove(owner);
 437
 438         media_transport_remove_owner(owner->transport);
 439 }
 440
 441 static void media_transport_set_owner(struct media_transport *transport,
 442                                         struct media_owner *owner)
 443 {
 444         DBG("Transport %s Owner %s", transport->path, owner->name);
 445         transport->owner = owner;
 446         owner->transport = transport;
 447         owner->watch = g_dbus_add_disconnect_watch(btd_get_dbus_connection(),
 448                                                         owner->name,
 449                                                         media_owner_exit,
 450                                                         owner, NULL);
 451 }
 452
 453 static struct media_owner *media_owner_create(DBusMessage *msg)
 454 {
 455         struct media_owner *owner;
 456
 457         owner = g_new0(struct media_owner, 1);
 458         owner->name = g_strdup(dbus_message_get_sender(msg));
 459
 460         DBG("Owner created: sender=%s", owner->name);
 461
 462         return owner;
 463 }
 464
 465 static void media_owner_add(struct media_owner *owner,
 466                                                 struct media_request *req)
 467 {
 468         DBG("Owner %s Request %s", owner->name,
 469                                         dbus_message_get_member(req->msg));
 470
 471         owner->pending = req;
 472 }
 473
 474 static DBusMessage *acquire(DBusConnection *conn, DBusMessage *msg,
 475                                         void *data)
 476 {
 477         struct media_transport *transport = data;
 478         struct media_owner *owner;
 479         struct media_request *req;
 480         guint id;
 481
 482         if (transport->owner != NULL)
 483                 return btd_error_not_authorized(msg);
 484
 485         if (transport->state >= TRANSPORT_STATE_REQUESTING)
 486                 return btd_error_not_authorized(msg);
 487
 488         owner = media_owner_create(msg);
 489         id = transport->resume(transport, owner);
 490         if (id == 0) {
 491                 media_owner_free(owner);
 492                 return btd_error_not_authorized(msg);
 493         }
 494
 495         req = media_request_create(msg, id);
 496         media_owner_add(owner, req);
 497         media_transport_set_owner(transport, owner);
 498
 499         return NULL;
 500 }
 501
 502 static DBusMessage *try_acquire(DBusConnection *conn, DBusMessage *msg,
 503                                                                 void *data)
 504 {
 505         struct media_transport *transport = data;
 506         struct media_owner *owner;
 507         struct media_request *req;
 508         guint id;
 509
 510         if (transport->owner != NULL)
 511                 return btd_error_not_authorized(msg);
 512
 513         if (transport->state >= TRANSPORT_STATE_REQUESTING)
 514                 return btd_error_not_authorized(msg);
 515
 516         if (transport->state != TRANSPORT_STATE_PENDING)
 517                 return btd_error_not_available(msg);
 518
 519         owner = media_owner_create(msg);
 520         id = transport->resume(transport, owner);
 521         if (id == 0) {
 522                 media_owner_free(owner);
 523                 return btd_error_not_authorized(msg);
 524         }
 525
 526         req = media_request_create(msg, id);
 527         media_owner_add(owner, req);
 528         media_transport_set_owner(transport, owner);
 529
 530         return NULL;
 531 }
 532
 533 static DBusMessage *release(DBusConnection *conn, DBusMessage *msg,
 534                                         void *data)
 535 {
 536         struct media_transport *transport = data;
 537         struct media_owner *owner = transport->owner;
 538         const char *sender;
 539         struct media_request *req;
 540         guint id;
 541
 542         sender = dbus_message_get_sender(msg);
 543
 544         if (owner == NULL || g_strcmp0(owner->name, sender) != 0)
 545                 return btd_error_not_authorized(msg);
 546
 547         if (owner->pending) {
 548                 const char *member;
 549
 550                 member = dbus_message_get_member(owner->pending->msg);
 551                 /* Cancel Acquire request if that exist */
 552                 if (g_str_equal(member, "Acquire"))
 553                         media_owner_remove(owner);
 554                 else
 555                         return btd_error_in_progress(msg);
 556         }
 557
 558         transport_set_state(transport, TRANSPORT_STATE_SUSPENDING);
 559
 560         id = transport->suspend(transport, owner);
 561         if (id == 0) {
 562                 media_transport_remove_owner(transport);
 563                 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 564         }
 565
 566         req = media_request_create(msg, id);
 567         media_owner_add(owner, req);
 568
 569         return NULL;
 570 }
 571
 572 static gboolean get_device(const GDBusPropertyTable *property,
 573                                         DBusMessageIter *iter, void *data)
 574 {
 575         struct media_transport *transport = data;
 576         const char *path = device_get_path(transport->device);
 577
 578         dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH, &path);
 579
 580         return TRUE;
 581 }
 582
 583 static gboolean get_uuid(const GDBusPropertyTable *property,
 584                                         DBusMessageIter *iter, void *data)
 585 {
 586         struct media_transport *transport = data;
 587         const char *uuid = media_endpoint_get_uuid(transport->endpoint);
 588
 589         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &uuid);
 590
 591         return TRUE;
 592 }
 593
 594 static gboolean get_codec(const GDBusPropertyTable *property,
 595                                         DBusMessageIter *iter, void *data)
 596 {
 597         struct media_transport *transport = data;
 598         uint8_t codec = media_endpoint_get_codec(transport->endpoint);
 599
 600         dbus_message_iter_append_basic(iter, DBUS_TYPE_BYTE, &codec);
 601
 602         return TRUE;
 603 }
 604
 605 static gboolean get_configuration(const GDBusPropertyTable *property,
 606                                         DBusMessageIter *iter, void *data)
 607 {
 608         struct media_transport *transport = data;
 609         DBusMessageIter array;
 610
 611         dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
 612                                         DBUS_TYPE_BYTE_AS_STRING, &array);
 613
 614         dbus_message_iter_append_fixed_array(&array, DBUS_TYPE_BYTE,
 615                                                 &transport->configuration,
 616                                                 transport->size);
 617
 618         dbus_message_iter_close_container(iter, &array);
 619
 620         return TRUE;
 621 }
 622
 623 static gboolean get_state(const GDBusPropertyTable *property,
 624                                         DBusMessageIter *iter, void *data)
 625 {
 626         struct media_transport *transport = data;
 627         const char *state = state2str(transport->state);
 628
 629         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &state);
 630
 631         return TRUE;
 632 }
 633
 634 static gboolean delay_exists(const GDBusPropertyTable *property, void *data)
 635 {
 636         struct media_transport *transport = data;
 637         struct a2dp_transport *a2dp = transport->data;
 638
 639         return a2dp->delay != 0;
 640 }
 641
 642 static gboolean get_delay(const GDBusPropertyTable *property,
 643                                         DBusMessageIter *iter, void *data)
 644 {
 645         struct media_transport *transport = data;
 646         struct a2dp_transport *a2dp = transport->data;
 647
 648         dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT16, &a2dp->delay);
 649
 650         return TRUE;
 651 }
 652
 653 static gboolean volume_exists(const GDBusPropertyTable *property, void *data)
 654 {
 655         struct media_transport *transport = data;
 656         struct a2dp_transport *a2dp = transport->data;
 657
 658         return a2dp->volume <= 127;
 659 }
 660
 661 static gboolean get_volume(const GDBusPropertyTable *property,
 662                                         DBusMessageIter *iter, void *data)
 663 {
 664         struct media_transport *transport = data;
 665         struct a2dp_transport *a2dp = transport->data;
 666
 667         dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT16, &a2dp->volume);
 668
 669         return TRUE;
 670 }
 671
 672 static void set_volume(const GDBusPropertyTable *property,
 673                         DBusMessageIter *iter, GDBusPendingPropertySet id,
 674                         void *data)
 675 {
 676         struct media_transport *transport = data;
 677         struct a2dp_transport *a2dp = transport->data;
 678         uint16_t volume;
 679         bool notify;
 680
 681         if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_UINT16) {
 682                 g_dbus_pending_property_error(id,
 683                                         ERROR_INTERFACE ".InvalidArguments",
 684                                         "Invalid arguments in method call");
 685                 return;
 686         }
 687
 688         dbus_message_iter_get_basic(iter, &volume);
 689
 690         if (volume > 127) {
 691                 g_dbus_pending_property_error(id,
 692                                         ERROR_INTERFACE ".InvalidArguments",
 693                                         "Invalid arguments in method call");
 694                 return;
 695         }
 696
 697         g_dbus_pending_property_success(id);
 698
 699         if (a2dp->volume == volume)
 700                 return;
 701
 702         a2dp->volume = volume;
 703
 704         notify = transport->source_watch ? true : false;
 705         if (notify)
 706                 g_dbus_emit_property_changed(btd_get_dbus_connection(),
 707                                                 transport->path,
 708                                                 MEDIA_TRANSPORT_INTERFACE,
 709                                                 "Volume");
 710
 711         avrcp_set_volume(transport->device, volume, notify);
 712 }
 713
 714 static const GDBusMethodTable transport_methods[] = {
 715         { GDBUS_ASYNC_METHOD("Acquire",
 716                         NULL,
 717                         GDBUS_ARGS({ "fd", "h" }, { "mtu_r", "q" },
 718                                                         { "mtu_w", "q" }),
 719                         acquire) },
 720         { GDBUS_ASYNC_METHOD("TryAcquire",
 721                         NULL,
 722                         GDBUS_ARGS({ "fd", "h" }, { "mtu_r", "q" },
 723                                                         { "mtu_w", "q" }),
 724                         try_acquire) },
 725         { GDBUS_ASYNC_METHOD("Release", NULL, NULL, release) },
 726         { },
 727 };
 728
 729 static const GDBusPropertyTable transport_properties[] = {
 730         { "Device", "o", get_device },
 731         { "UUID", "s", get_uuid },
 732         { "Codec", "y", get_codec },
 733         { "Configuration", "ay", get_configuration },
 734         { "State", "s", get_state },
 735         { "Delay", "q", get_delay, NULL, delay_exists },
 736         { "Volume", "q", get_volume, set_volume, volume_exists },
 737         { }
 738 };
 739
 740 static void destroy_a2dp(void *data)
 741 {
 742         struct a2dp_transport *a2dp = data;
 743
 744         if (a2dp->session)
 745                 avdtp_unref(a2dp->session);
 746
 747         g_free(a2dp);
 748 }
 749
 750 static void media_transport_free(void *data)
 751 {
 752         struct media_transport *transport = data;
 753
 754         transports = g_slist_remove(transports, transport);
 755
 756         if (transport->owner)
 757                 media_transport_remove_owner(transport);
 758
 759         if (transport->destroy != NULL)
 760                 transport->destroy(transport->data);
 761
 762         g_free(transport->configuration);
 763         g_free(transport->path);
 764         g_free(transport);
 765 }
 766
 767 static void transport_update_playing(struct media_transport *transport,
 768                                                         gboolean playing)
 769 {
 770         DBG("%s State=%s Playing=%d", transport->path,
 771                                         str_state[transport->state], playing);
 772
 773         if (playing == FALSE) {
 774                 if (transport->state == TRANSPORT_STATE_PENDING)
 775                         transport_set_state(transport, TRANSPORT_STATE_IDLE);
 776                 else if (transport->state == TRANSPORT_STATE_ACTIVE) {
 777                         /* Remove owner */
 778                         if (transport->owner != NULL)
 779                                 media_transport_remove_owner(transport);
 780                 }
 781         } else if (transport->state == TRANSPORT_STATE_IDLE)
 782                 transport_set_state(transport, TRANSPORT_STATE_PENDING);
 783 }
 784
 785 static void sink_state_changed(struct btd_service *service,
 786                                                 sink_state_t old_state,
 787                                                 sink_state_t new_state,
 788                                                 void *user_data)
 789 {
 790         struct media_transport *transport = user_data;
 791
 792         if (new_state == SINK_STATE_PLAYING)
 793                 transport_update_playing(transport, TRUE);
 794         else
 795                 transport_update_playing(transport, FALSE);
 796 }
 797
 798 static void source_state_changed(struct btd_service *service,
 799                                                 source_state_t old_state,
 800                                                 source_state_t new_state,
 801                                                 void *user_data)
 802 {
 803         struct media_transport *transport = user_data;
 804
 805         if (new_state == SOURCE_STATE_PLAYING)
 806                 transport_update_playing(transport, TRUE);
 807         else
 808                 transport_update_playing(transport, FALSE);
 809 }
 810
 811 static int media_transport_init_source(struct media_transport *transport)
 812 {
 813         struct btd_service *service;
 814         struct a2dp_transport *a2dp;
 815
 816         service = btd_device_get_service(transport->device, A2DP_SINK_UUID);
 817         if (service == NULL)
 818                 return -EINVAL;
 819
 820         a2dp = g_new0(struct a2dp_transport, 1);
 821
 822         transport->resume = resume_a2dp;
 823         transport->suspend = suspend_a2dp;
 824         transport->cancel = cancel_a2dp;
 825         transport->data = a2dp;
 826         transport->destroy = destroy_a2dp;
 827
 828         a2dp->volume = -1;
 829         transport->sink_watch = sink_add_state_cb(service, sink_state_changed,
 830                                                                 transport);
 831
 832         return 0;
 833 }
 834
 835 static int media_transport_init_sink(struct media_transport *transport)
 836 {
 837         struct btd_service *service;
 838         struct a2dp_transport *a2dp;
 839
 840         service = btd_device_get_service(transport->device, A2DP_SOURCE_UUID);
 841         if (service == NULL)
 842                 return -EINVAL;
 843
 844         a2dp = g_new0(struct a2dp_transport, 1);
 845
 846         transport->resume = resume_a2dp;
 847         transport->suspend = suspend_a2dp;
 848         transport->cancel = cancel_a2dp;
 849         transport->data = a2dp;
 850         transport->destroy = destroy_a2dp;
 851
 852         a2dp->volume = 127;
 853         transport->source_watch = source_add_state_cb(service,
 854                                                         source_state_changed,
 855                                                         transport);
 856
 857         return 0;
 858 }
 859
 860 struct media_transport *media_transport_create(struct btd_device *device,
 861                                                 uint8_t *configuration,
 862                                                 size_t size, void *data)
 863 {
 864         struct media_endpoint *endpoint = data;
 865         struct media_transport *transport;
 866         const char *uuid;
 867         static int fd = 0;
 868
 869         transport = g_new0(struct media_transport, 1);
 870         transport->device = device;
 871         transport->endpoint = endpoint;
 872         transport->configuration = g_new(uint8_t, size);
 873         memcpy(transport->configuration, configuration, size);
 874         transport->size = size;
 875         transport->path = g_strdup_printf("%s/fd%d", device_get_path(device),
 876                                                                         fd++);
 877         transport->fd = -1;
 878
 879         uuid = media_endpoint_get_uuid(endpoint);
 880         if (strcasecmp(uuid, A2DP_SOURCE_UUID) == 0) {
 881                 if (media_transport_init_source(transport) < 0)
 882                         goto fail;
 883         } else if (strcasecmp(uuid, A2DP_SINK_UUID) == 0) {
 884                 if (media_transport_init_sink(transport) < 0)
 885                         goto fail;
 886         } else
 887                 goto fail;
 888
 889         if (g_dbus_register_interface(btd_get_dbus_connection(),
 890                                 transport->path, MEDIA_TRANSPORT_INTERFACE,
 891                                 transport_methods, NULL, transport_properties,
 892                                 transport, media_transport_free) == FALSE) {
 893                 error("Could not register transport %s", transport->path);
 894                 goto fail;
 895         }
 896
 897         transports = g_slist_append(transports, transport);
 898
 899         return transport;
 900
 901 fail:
 902         media_transport_free(transport);
 903         return NULL;
 904 }
 905
 906 const char *media_transport_get_path(struct media_transport *transport)
 907 {
 908         return transport->path;
 909 }
 910
 911 void media_transport_update_delay(struct media_transport *transport,
 912                                                         uint16_t delay)
 913 {
 914         struct a2dp_transport *a2dp = transport->data;
 915
 916         /* Check if delay really changed */
 917         if (a2dp->delay == delay)
 918                 return;
 919
 920         a2dp->delay = delay;
 921
 922         g_dbus_emit_property_changed(btd_get_dbus_connection(),
 923                                         transport->path,
 924                                         MEDIA_TRANSPORT_INTERFACE, "Delay");
 925 }
 926
 927 struct btd_device *media_transport_get_dev(struct media_transport *transport)
 928 {
 929         return transport->device;
 930 }
 931
 932 uint16_t media_transport_get_volume(struct media_transport *transport)
 933 {
 934         struct a2dp_transport *a2dp = transport->data;
 935         return a2dp->volume;
 936 }
 937
 938 void media_transport_update_volume(struct media_transport *transport,
 939                                                                 uint8_t volume)
 940 {
 941         struct a2dp_transport *a2dp = transport->data;
 942
 943         /* Check if volume really changed */
 944         if (a2dp->volume == volume)
 945                 return;
 946
 947         a2dp->volume = volume;
 948
 949         g_dbus_emit_property_changed(btd_get_dbus_connection(),
 950                                         transport->path,
 951                                         MEDIA_TRANSPORT_INTERFACE, "Volume");
 952 }
 953
 954 uint8_t media_transport_get_device_volume(struct btd_device *dev)
 955 {
 956         GSList *l;
 957
 958         if (dev == NULL)
 959                 return 128;
 960
 961         for (l = transports; l; l = l->next) {
 962                 struct media_transport *transport = l->data;
 963                 if (transport->device != dev)
 964                         continue;
 965
 966                 /* Volume is A2DP only */
 967                 if (media_endpoint_get_sep(transport->endpoint))
 968                         return media_transport_get_volume(transport);
 969         }
 970
 971         return 0;
 972 }
 973
 974 void media_transport_update_device_volume(struct btd_device *dev,
 975                                                                 uint8_t volume)
 976 {
 977         GSList *l;
 978
 979         if (dev == NULL)
 980                 return;
 981
 982         for (l = transports; l; l = l->next) {
 983                 struct media_transport *transport = l->data;
 984                 if (transport->device != dev)
 985                         continue;
 986
 987                 /* Volume is A2DP only */
 988                 if (media_endpoint_get_sep(transport->endpoint))
 989                         media_transport_update_volume(transport, volume);
 990         }
 991 }