bt-service/bt-service-avrcp.c

   1 /*
   2  * Bluetooth-frwk
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact:  Hocheol Seo <hocheol.seo@samsung.com>
   7  *               Girishashok Joshi <girish.joshi@samsung.com>
   8  *               Chanyeol Park <chanyeol.park@samsung.com>
   9  *
  10  * Licensed under the Apache License, Version 2.0 (the "License");
  11  * you may not use this file except in compliance with the License.
  12  * You may obtain a copy of the License at
  13  *
  14  *              http://www.apache.org/licenses/LICENSE-2.0
  15  *
  16  * Unless required by applicable law or agreed to in writing, software
  17  * distributed under the License is distributed on an "AS IS" BASIS,
  18  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  19  * See the License for the specific language governing permissions and
  20  * limitations under the License.
  21  *
  22  */
  23
  24 #include <gio/gio.h>
  25 #include <glib.h>
  26 #include <dlog.h>
  27 #include <string.h>
  28 #if !defined(LIBNOTIFY_SUPPORT) && !defined(LIBNOTIFICATION_SUPPORT)
  29 #include <syspopup_caller.h>
  30 #endif
  31 #include <dbus/dbus.h>
  32
  33 #include "bluetooth-api.h"
  34 #include "bt-internal-types.h"
  35 #include "bt-service-common.h"
  36 #include "bt-service-avrcp.h"
  37 #include "bt-service-event.h"
  38 #include "bt-service-util.h"
  39 #include "bt-service-audio.h"
  40
  41 static bt_player_settinngs_t loopstatus_settings[] = {
  42         { REPEAT_INVALID, "" },
  43         { REPEAT_MODE_OFF, "None" },
  44         { REPEAT_SINGLE_TRACK, "Track" },
  45         { REPEAT_ALL_TRACK, "Playlist" },
  46         { REPEAT_INVALID, "" }
  47 };
  48
  49 static bt_player_settinngs_t shuffle_settings[] = {
  50         { SHUFFLE_INVALID, "" },
  51         { SHUFFLE_MODE_OFF, "off" },
  52         { SHUFFLE_ALL_TRACK, "alltracks" },
  53         { SHUFFLE_GROUP, "group" },
  54         { SHUFFLE_INVALID, "" }
  55 };
  56
  57 static bt_player_settinngs_t player_status[] = {
  58         { STATUS_STOPPED, "stopped" },
  59         { STATUS_PLAYING, "playing" },
  60         { STATUS_PAUSED, "paused" },
  61         { STATUS_FORWARD_SEEK, "forward-seek" },
  62         { STATUS_REVERSE_SEEK, "reverse-seek" },
  63         { STATUS_ERROR, "error" },
  64         { STATUS_INVALID, "" }
  65 };
  66
  67 GDBusConnection *bt_gdbus_conn = NULL;
  68 static guint avrcp_reg_id = 0;
  69 static GDBusProxy *service_gproxy = NULL;
  70
  71 /* Introspection data exposed from bt-service */
  72 static const gchar bt_avrcp_bluez_introspection_xml[] =
  73 "<node name='/'>"
  74 " <interface name='org.freedesktop.DBus.Properties'>"
  75 "     <method name='Set'>"
  76 "          <arg type='s' name='interface' direction='in'/>"
  77 "          <arg type='s' name='property' direction='in'/>"
  78 "          <arg type='v' name='value' direction='in'/>"
  79 "     </method>"
  80 " </interface>"
  81 "</node>";
  82
  83 static gboolean __bt_media_emit_property_changed(GDBusConnection *connection,
  84                 const char *path, const char *interface, const char *name,
  85                 const GVariant *variant)
  86 {
  87         GVariantBuilder *builder = NULL;
  88         GError *error = NULL;
  89
  90         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
  91         g_variant_builder_add(builder, "{sv}", name, variant);
  92
  93         g_dbus_connection_emit_signal(connection, NULL, path,
  94                                 DBUS_INTERFACE_PROPERTIES,
  95                                 "PropertiesChanged",
  96                                 g_variant_new("(sa{sv})",
  97                                 interface, builder),
  98                                 &error);
  99
 100         g_variant_builder_unref(builder);
 101         if (error) {
 102                 BT_ERR("Could not Emit PropertiesChanged Signal: errCode[%x], message[%s]",
 103                         error->code, error->message);
 104                 g_clear_error(&error);
 105                 return FALSE;
 106         }
 107
 108         return TRUE;
 109 }
 110
 111 static GQuark __bt_avrcp_error_quark(void)
 112 {
 113         static GQuark quark = 0;
 114
 115         if (!quark)
 116                 quark = g_quark_from_static_string("bt-avrcp");
 117
 118         return quark;
 119 }
 120
 121 static GError *__bt_avrcp_set_error(bt_avrcp_error_t error)
 122 {
 123         BT_ERR("error[%d]\n", error);
 124
 125         switch (error) {
 126         case BT_AVRCP_ERROR_INVALID_PARAM:
 127                 return g_error_new(BT_AVRCP_ERROR, error,
 128                                 BT_ERROR_INVALID_PARAM);
 129         case BT_AVRCP_ERROR_INVALID_INTERFACE:
 130                 return g_error_new(BT_AVRCP_ERROR, error,
 131                                 BT_ERROR_INVALID_INTERFACE);
 132         case BT_AVRCP_ERROR_INTERNAL:
 133         default:
 134                 return g_error_new(BT_AVRCP_ERROR, error,
 135                                 BT_ERROR_INTERNAL);
 136         }
 137 }
 138
 139 static void __bt_avrcp_agent_method(GDBusConnection *connection,
 140                 const gchar *sender,
 141                 const gchar *object_path,
 142                 const gchar *interface_name,
 143                 const gchar *method_name,
 144                 GVariant *parameters,
 145                 GDBusMethodInvocation *invocation,
 146                 gpointer user_data)
 147 {
 148         BT_DBG("+");
 149         BT_INFO("method %s", method_name);
 150         BT_INFO("object_path %s", object_path);
 151         int ret = BT_AVRCP_ERROR_NONE;
 152         GError *err = NULL;
 153         gboolean shuffle_status;
 154         guint32 status;
 155         gchar *interface = NULL;
 156         gchar *property = NULL;
 157         gchar *loop_status = NULL;
 158         GVariant *value;
 159
 160         if (g_strcmp0(method_name, "Set") == 0) {
 161                 g_variant_get(parameters, "(&s&sv)", &interface, &property,
 162                                 &value);
 163
 164                 if (g_strcmp0(interface, BT_MEDIA_PLAYER_INTERFACE) != 0) {
 165                         ret = BT_AVRCP_ERROR_INVALID_INTERFACE;
 166                         goto fail;
 167                 }
 168         }
 169
 170         BT_DBG("Property: %s\n", property);
 171         if (g_strcmp0(property, "Shuffle") == 0) {
 172
 173                 if (!g_variant_is_of_type(value, G_VARIANT_TYPE_BOOLEAN)) {
 174                         BT_ERR("Error");
 175                         ret = BT_AVRCP_ERROR_INVALID_PARAM;
 176                         goto fail;
 177                 }
 178
 179                 shuffle_status = g_variant_get_boolean(value);
 180                 BT_DBG("Value: %s\n", shuffle_status ? "TRUE" : "FALSE");
 181                 if (shuffle_status == TRUE)
 182                         status = SHUFFLE_ALL_TRACK;
 183                 else
 184                         status = SHUFFLE_MODE_OFF;
 185
 186                 _bt_send_event(BT_AVRCP_EVENT,
 187                                 BLUETOOTH_EVENT_AVRCP_SETTING_SHUFFLE_STATUS,
 188                                 g_variant_new("(u)", status));
 189         } else if (g_strcmp0(property, "LoopStatus") == 0) {
 190
 191                 if (!g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) {
 192                         BT_ERR("Error");
 193                         ret = BT_AVRCP_ERROR_INVALID_PARAM;
 194                         goto fail;
 195                 }
 196
 197                 loop_status = (gchar *)g_variant_get_string(value, NULL);
 198                 BT_DBG("Value: %s\n", loop_status);
 199
 200                 if (g_strcmp0(loop_status, "Track") == 0)
 201                         status = REPEAT_SINGLE_TRACK;
 202                 else if (g_strcmp0(loop_status, "Playlist") == 0)
 203                         status = REPEAT_ALL_TRACK;
 204                 else if (g_strcmp0(loop_status, "None") == 0)
 205                         status = REPEAT_MODE_OFF;
 206                 else
 207                         status = REPEAT_INVALID;
 208
 209                 _bt_send_event(BT_AVRCP_EVENT,
 210                                 BLUETOOTH_EVENT_AVRCP_SETTING_REPEAT_STATUS,
 211                                 g_variant_new("(u)", status));
 212         }
 213
 214         BT_DBG("-");
 215         return;
 216
 217 fail:
 218         g_variant_unref(value);
 219         err = __bt_avrcp_set_error(ret);
 220         g_dbus_method_invocation_return_gerror(invocation, err);
 221         g_clear_error(&err);
 222         BT_INFO("-");
 223 }
 224
 225 static const GDBusInterfaceVTable method_table = {
 226         __bt_avrcp_agent_method,
 227         NULL,
 228         NULL,
 229 };
 230
 231 static GDBusNodeInfo *__bt_avrcp_create_method_node_info
 232                                 (const gchar *introspection_data)
 233 {
 234         GError *err = NULL;
 235         GDBusNodeInfo *node_info = NULL;
 236
 237         if (introspection_data == NULL)
 238                 return NULL;
 239
 240         node_info = g_dbus_node_info_new_for_xml(introspection_data, &err);
 241
 242         if (err) {
 243                 BT_ERR("Unable to create node: %s", err->message);
 244                 g_clear_error(&err);
 245         }
 246
 247         return node_info;
 248 }
 249
 250 static GDBusProxy *__bt_avrcp_gdbus_init_service_proxy(void)
 251 {
 252         BT_DBG("+");
 253         GDBusProxy *proxy;
 254         GError *err = NULL;
 255         char *adapter_path;
 256
 257         if (bt_gdbus_conn == NULL)
 258                 bt_gdbus_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &err);
 259
 260         if (!bt_gdbus_conn) {
 261                 if (err) {
 262                         BT_ERR("Unable to connect to gdbus: %s", err->message);
 263                         g_clear_error(&err);
 264                 }
 265                 return NULL;
 266         }
 267
 268         adapter_path = _bt_get_adapter_path();
 269         retv_if(adapter_path == NULL, NULL);
 270
 271         proxy =  g_dbus_proxy_new_sync(bt_gdbus_conn,
 272                         G_DBUS_PROXY_FLAGS_NONE, NULL,
 273                         BT_BLUEZ_NAME, adapter_path,
 274                         BT_MEDIA_INTERFACE, NULL, &err);
 275         g_free(adapter_path);
 276
 277         if (!proxy) {
 278                 BT_ERR("Unable to create proxy");
 279                 if (err) {
 280                         BT_ERR("Error: %s", err->message);
 281                         g_clear_error(&err);
 282                 }
 283                 return NULL;
 284         }
 285
 286         BT_DBG("-");;
 287         return proxy;
 288 }
 289
 290 static GDBusProxy *__bt_avrcp_gdbus_get_service_proxy(void)
 291 {
 292         return (service_gproxy) ? service_gproxy :
 293                         __bt_avrcp_gdbus_init_service_proxy();
 294 }
 295
 296 int _bt_register_media_player(void)
 297 {
 298         BT_DBG("+");
 299         gchar *adapter_path;
 300         gboolean shuffle_status;
 301         gchar *path;
 302         GDBusConnection *conn;
 303         GDBusNodeInfo *node_info;
 304         GDBusProxy *proxy;
 305         GVariantBuilder *builder;
 306         GVariant *ret;
 307         GError *error = NULL;
 308
 309         media_player_settings_t player_settings = {0,};
 310
 311         player_settings.repeat  = REPEAT_MODE_OFF;
 312         player_settings.status = STATUS_STOPPED;
 313         player_settings.position = 0;
 314         shuffle_status = FALSE;
 315
 316         conn = _bt_get_system_gconn();
 317         retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
 318         bt_gdbus_conn = conn;
 319
 320         node_info = __bt_avrcp_create_method_node_info(
 321                                 bt_avrcp_bluez_introspection_xml);
 322         if (node_info == NULL)
 323                 return BLUETOOTH_ERROR_INTERNAL;
 324
 325         avrcp_reg_id = g_dbus_connection_register_object(bt_gdbus_conn,
 326                                         BT_MEDIA_OBJECT_PATH,
 327                                         node_info->interfaces[0],
 328                                         &method_table,
 329                                         NULL, NULL, &error);
 330         g_dbus_node_info_unref(node_info);
 331
 332         if (avrcp_reg_id == 0) {
 333                 BT_ERR("Failed to register: %s", error->message);
 334                 g_clear_error(&error);
 335                 return BLUETOOTH_ERROR_INTERNAL;
 336         }
 337
 338         adapter_path = _bt_get_adapter_path();
 339         retv_if(adapter_path == NULL, BLUETOOTH_ERROR_INTERNAL);
 340
 341         proxy =  g_dbus_proxy_new_sync(conn,
 342                         G_DBUS_PROXY_FLAGS_NONE, NULL,
 343                         BT_BLUEZ_NAME, adapter_path,
 344                         BT_MEDIA_INTERFACE, NULL, &error);
 345         g_free(adapter_path);
 346
 347         if (proxy == NULL) {
 348                 BT_ERR("Unable to create proxy");
 349                 if (error) {
 350                         BT_ERR("Error: %s", error->message);
 351                         g_clear_error(&error);
 352                 }
 353                 return BLUETOOTH_ERROR_INTERNAL;
 354         }
 355
 356         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
 357
 358         g_variant_builder_add(builder, "{sv}", "LoopStatus",
 359                         g_variant_new("s",
 360                         loopstatus_settings[player_settings.repeat].property));
 361         BT_ERR("LoopStatus: %s", loopstatus_settings[player_settings.repeat].property);
 362
 363         g_variant_builder_add(builder, "{sv}", "Shuffle",
 364                         g_variant_new("b", shuffle_status));
 365
 366         g_variant_builder_add(builder, "{sv}", "PlaybackStatus",
 367                         g_variant_new("s",
 368                         player_status[player_settings.status].property));
 369         BT_ERR("PlaybackStatus: %s", player_status[player_settings.status].property);
 370
 371         g_variant_builder_add(builder, "{sv}", "Position",
 372                         g_variant_new("u", player_settings.position));
 373
 374         path = g_strdup(BT_MEDIA_OBJECT_PATH);
 375         ret = g_dbus_proxy_call_sync(proxy, "RegisterPlayer",
 376                         g_variant_new("(oa{sv})", path, builder),
 377                         G_DBUS_CALL_FLAGS_NONE, -1,
 378                         NULL, &error);
 379
 380         g_object_unref(proxy);
 381         g_free(path);
 382         g_variant_builder_unref(builder);
 383
 384         if (ret == NULL) {
 385                 BT_ERR("Call RegisterPlayer Failed");
 386                 if (error) {
 387                         BT_ERR("errCode[%x], message[%s]",
 388                                         error->code, error->message);
 389                         g_clear_error(&error);
 390                 }
 391                 return BLUETOOTH_ERROR_INTERNAL;
 392         }
 393
 394         g_variant_unref(ret);
 395         return BLUETOOTH_ERROR_NONE;
 396 }
 397
 398 static void __bt_avrcp_unregister_object_path(void)
 399 {
 400         if (avrcp_reg_id > 0) {
 401                 g_dbus_connection_unregister_object(bt_gdbus_conn,
 402                                                         avrcp_reg_id);
 403                 avrcp_reg_id = 0;
 404         }
 405 }
 406
 407 int _bt_unregister_media_player(void)
 408 {
 409         BT_DBG("+");
 410         GDBusProxy *proxy;
 411         GVariant *ret;
 412         GError *error = NULL;
 413         GDBusConnection *conn;
 414         gchar *path;
 415
 416         conn = bt_gdbus_conn;
 417         retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
 418
 419         proxy = __bt_avrcp_gdbus_get_service_proxy();
 420         if (proxy == NULL)
 421                 return BLUETOOTH_ERROR_INTERNAL;
 422
 423         path = g_strdup(BT_MEDIA_OBJECT_PATH);
 424         BT_DBG("path is [%s]", path);
 425
 426         ret = g_dbus_proxy_call_sync(proxy, "UnregisterPlayer",
 427                         g_variant_new("(o)", path),
 428                         G_DBUS_CALL_FLAGS_NONE, -1,
 429                         NULL, &error);
 430         g_free(path);
 431
 432         if (ret == NULL) {
 433                 BT_ERR("UnregisterPlayer failed");
 434                 if (error) {
 435                         BT_ERR("D-Bus API failure: errCode[%x], message[%s]",
 436                                         error->code, error->message);
 437                         g_clear_error(&error);
 438                 }
 439                 return BLUETOOTH_ERROR_INTERNAL;
 440         }
 441
 442         __bt_avrcp_unregister_object_path();
 443
 444         g_variant_unref(ret);
 445         g_object_unref(bt_gdbus_conn);
 446         bt_gdbus_conn = NULL;
 447
 448         BT_DBG("-");
 449         return BLUETOOTH_ERROR_NONE;
 450 }
 451
 452 int _bt_avrcp_set_track_info(media_metadata_attributes_t *meta_data)
 453 {
 454         BT_DBG("+");
 455         char *interface = BT_MEDIA_PLAYER_INTERFACE;
 456         GDBusConnection *conn;
 457         GError *error = NULL;
 458         GVariantBuilder *builder = NULL;
 459         GVariantBuilder *inner_builder = NULL;
 460         GVariant *children[1];
 461         gboolean ret;
 462
 463         retv_if(meta_data == NULL, BLUETOOTH_ERROR_INTERNAL);
 464
 465         conn = bt_gdbus_conn;
 466         retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
 467
 468         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
 469         inner_builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
 470
 471         g_variant_builder_add(inner_builder, "{sv}",
 472                 "xesam:title", g_variant_new_string(meta_data->title));
 473
 474         children[0] = g_variant_new_string(meta_data->artist);
 475         g_variant_builder_add(inner_builder, "{sv}",
 476                 "xesam:artist", g_variant_new_array(G_VARIANT_TYPE_STRING,
 477                 children, 1));
 478
 479         g_variant_builder_add(inner_builder, "{sv}",
 480                 "xesam:album", g_variant_new_string(meta_data->album));
 481
 482         children[0] = g_variant_new_string(meta_data->genre);
 483         g_variant_builder_add(inner_builder, "{sv}",
 484                 "xesam:genre", g_variant_new_array(G_VARIANT_TYPE_STRING,
 485                 children, 1));
 486
 487         g_variant_builder_add(inner_builder, "{sv}",
 488                 "xesam:totalTracks", g_variant_new_int32(meta_data->total_tracks));
 489
 490         g_variant_builder_add(inner_builder, "{sv}",
 491                 "xesam:trackNumber", g_variant_new_int32(meta_data->number));
 492
 493         g_variant_builder_add(inner_builder, "{sv}",
 494                 "mpris:lenght", g_variant_new_int64(meta_data->duration));
 495
 496         g_variant_builder_add(builder, "{sv}",
 497                 "Metadata", g_variant_new("a{sv}", inner_builder));
 498
 499         ret = g_dbus_connection_emit_signal(conn, NULL, BT_MEDIA_OBJECT_PATH,
 500                                 DBUS_INTERFACE_PROPERTIES,
 501                                 "PropertiesChanged",
 502                                 g_variant_new("(sa{sv})",
 503                                 interface, builder),
 504                                 &error);
 505
 506         g_variant_builder_unref(inner_builder);
 507         g_variant_builder_unref(builder);
 508
 509         if (!ret) {
 510                 if (error != NULL) {
 511                         BT_ERR("D-Bus API failure: errCode[%x], message[%s]",
 512                                 error->code, error->message);
 513                         g_clear_error(&error);
 514                 }
 515         }
 516
 517         BT_DBG("-");
 518         return BLUETOOTH_ERROR_NONE;
 519 }
 520
 521 int _bt_avrcp_set_interal_property(int type, media_player_settings_t *properties)
 522 {
 523         BT_DBG("+");
 524         GDBusConnection *conn;
 525         int value;
 526         media_metadata_attributes_t meta_data;
 527         gboolean shuffle;
 528         GVariantBuilder *builder = NULL;
 529         GVariant *children[1];
 530
 531         conn = bt_gdbus_conn;
 532         retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
 533
 534         switch (type) {
 535         case REPEAT:
 536                 value = properties->repeat;
 537                 if (!__bt_media_emit_property_changed(conn, BT_MEDIA_OBJECT_PATH,
 538                                 BT_MEDIA_PLAYER_INTERFACE, "LoopStatus",
 539                                 g_variant_new_string(loopstatus_settings[value].property))) {
 540                         BT_ERR("Error sending the PropertyChanged signal \n");
 541                         return BLUETOOTH_ERROR_INTERNAL;
 542                 }
 543                 break;
 544         case SHUFFLE:
 545                 value = properties->shuffle;
 546                 if (g_strcmp0(shuffle_settings[value].property, "off") == 0)
 547                         shuffle = FALSE;
 548                 else
 549                         shuffle = TRUE;
 550
 551                 if (!__bt_media_emit_property_changed(conn, BT_MEDIA_OBJECT_PATH,
 552                                 BT_MEDIA_PLAYER_INTERFACE, "Shuffle",
 553                                 g_variant_new_boolean(shuffle))) {
 554                         BT_ERR("Error sending the PropertyChanged signal \n");
 555                         return BLUETOOTH_ERROR_INTERNAL;
 556                 }
 557                 break;
 558         case STATUS:
 559                 value = properties->status;
 560                 if (!__bt_media_emit_property_changed(conn, BT_MEDIA_OBJECT_PATH,
 561                                 BT_MEDIA_PLAYER_INTERFACE, "PlaybackStatus",
 562                                 g_variant_new_string(player_status[value].property))) {
 563                         BT_ERR("Error sending the PropertyChanged signal \n");
 564                         return BLUETOOTH_ERROR_INTERNAL;
 565                 }
 566                 break;
 567         case POSITION:
 568                 value = properties->position;
 569                 if (!__bt_media_emit_property_changed(conn, BT_MEDIA_OBJECT_PATH,
 570                                 BT_MEDIA_PLAYER_INTERFACE, "Position",
 571                                 g_variant_new_uint32(value))) {
 572                         BT_ERR("Error sending the PropertyChanged signal \n");
 573                         return BLUETOOTH_ERROR_INTERNAL;
 574                 }
 575                 break;
 576         case METADATA:
 577                 meta_data = properties->metadata;
 578
 579                 builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
 580                 g_variant_builder_add(builder, "{sv}",
 581                                 "xesam:title", g_variant_new_string(meta_data.title));
 582
 583                 children[0] = g_variant_new_string(meta_data.artist);
 584                 g_variant_builder_add(builder, "{sv}",
 585                                 "xesam:artist", g_variant_new_array(G_VARIANT_TYPE_STRING,
 586                                                 children, 1));
 587
 588                 g_variant_builder_add(builder, "{sv}",
 589                                 "xesam:album", g_variant_new_string(meta_data.album));
 590
 591                 children[0] = g_variant_new_string(meta_data.genre);
 592                 g_variant_builder_add(builder, "{sv}",
 593                                 "xesam:genre", g_variant_new_array(G_VARIANT_TYPE_STRING,
 594                                                 children, 1));
 595
 596                 g_variant_builder_add(builder, "{sv}",
 597                                 "xesam:totalTracks", g_variant_new_int32(meta_data.total_tracks));
 598
 599                 g_variant_builder_add(builder, "{sv}",
 600                                 "xesam:trackNumber", g_variant_new_int32(meta_data.number));
 601
 602                 g_variant_builder_add(builder, "{sv}",
 603                                 "mpris:lenght", g_variant_new_int64(meta_data.duration));
 604
 605                 if (!__bt_media_emit_property_changed(conn, BT_MEDIA_OBJECT_PATH,
 606                                 BT_MEDIA_PLAYER_INTERFACE, "Metadata",
 607                                 g_variant_new("a{sv}", builder))) {
 608                         BT_ERR("Error sending the PropertyChanged signal \n");
 609                         g_variant_builder_unref(builder);
 610                         return BLUETOOTH_ERROR_INTERNAL;
 611                 }
 612                 g_variant_builder_unref(builder);
 613                 break;
 614         default:
 615                 BT_ERR("Invalid Type\n");
 616                 return BLUETOOTH_ERROR_INTERNAL;
 617         }
 618         BT_DBG("-");
 619         return BLUETOOTH_ERROR_NONE;
 620 }
 621
 622 int _bt_avrcp_set_properties(media_player_settings_t *properties)
 623 {
 624         BT_DBG("+");
 625
 626         if (_bt_avrcp_set_interal_property(REPEAT,
 627                                 properties) != BLUETOOTH_ERROR_NONE) {
 628                         return BLUETOOTH_ERROR_INTERNAL;
 629         }
 630         if (_bt_avrcp_set_interal_property(SHUFFLE,
 631                         properties) != BLUETOOTH_ERROR_NONE) {
 632                 return BLUETOOTH_ERROR_INTERNAL;
 633         }
 634
 635         if (_bt_avrcp_set_interal_property(STATUS,
 636                         properties) != BLUETOOTH_ERROR_NONE) {
 637                 return BLUETOOTH_ERROR_INTERNAL;
 638         }
 639
 640         if (_bt_avrcp_set_interal_property(POSITION,
 641                         properties) != BLUETOOTH_ERROR_NONE) {
 642                 return BLUETOOTH_ERROR_INTERNAL;
 643         }
 644
 645         if (_bt_avrcp_set_interal_property(METADATA,
 646                         properties) != BLUETOOTH_ERROR_NONE) {
 647                 return BLUETOOTH_ERROR_INTERNAL;
 648         }
 649         BT_DBG("-");
 650         return BLUETOOTH_ERROR_NONE;
 651 }
 652
 653 int _bt_avrcp_set_property(int type, unsigned int value)
 654 {
 655         BT_DBG("+");
 656         media_player_settings_t properties;
 657
 658         switch (type) {
 659         case REPEAT:
 660                 properties.repeat = value;
 661                 break;
 662         case SHUFFLE:
 663                 properties.shuffle = value;
 664                 break;
 665         case STATUS:
 666                 properties.status = value;
 667                 break;
 668         case POSITION:
 669                 properties.position = value;
 670                 break;
 671         default:
 672                 BT_DBG("Invalid Type\n");
 673                 return BLUETOOTH_ERROR_INTERNAL;
 674         }
 675
 676         if (_bt_avrcp_set_interal_property(type,
 677                         &properties) != BLUETOOTH_ERROR_NONE)
 678                 return BLUETOOTH_ERROR_INTERNAL;
 679
 680         BT_DBG("-");
 681
 682         return BLUETOOTH_ERROR_NONE;
 683 }