bt-service/bt-service-avrcp.c

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