4 * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
10 * http://www.apache.org/licenses/LICENSE-2.0
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
20 #include <dbus/dbus-glib-lowlevel.h>
21 #include <dbus/dbus-glib.h>
22 #include <dbus/dbus.h>
26 #if !defined(LIBNOTIFY_SUPPORT) && !defined(LIBNOTIFICATION_SUPPORT)
27 #include <syspopup_caller.h>
30 #include "bluetooth-api.h"
31 #include "bt-internal-types.h"
33 #include "bt-service-common.h"
34 #include "bt-service-avrcp.h"
35 #include "bt-service-event.h"
36 #include "bt-service-util.h"
38 struct player_settinngs_t {
43 static struct player_settinngs_t loopstatus_settings[] = {
44 { REPEAT_INVALID, "" },
45 { REPEAT_MODE_OFF, "None" },
46 { REPEAT_SINGLE_TRACK, "Track" },
47 { REPEAT_ALL_TRACK, "Playlist" },
48 { REPEAT_INVALID, "" }
51 static struct player_settinngs_t playback_status[] = {
52 { STATUS_STOPPED, "Stopped" },
53 { STATUS_PLAYING, "Playing" },
54 { STATUS_PAUSED, "Paused" },
55 { STATUS_INVALID, "" }
58 static struct player_settinngs_t repeat_settings[] = {
59 { REPEAT_INVALID, "" },
60 { REPEAT_MODE_OFF, "off" },
61 { REPEAT_SINGLE_TRACK, "singletrack" },
62 { REPEAT_ALL_TRACK, "alltracks" },
63 { REPEAT_INVALID, "" }
74 GType bt_media_agent_get_type(void);
76 DBusConnection *g_bt_dbus_conn = NULL;
78 #define BT_MEDIA_TYPE_AGENT (bt_media_agent_get_type())
79 #define BT_MEDIA_GET_AGENT(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), BT_MEDIA_TYPE_AGENT, BtMediaAgent))
80 #define BT_MEDIA_IS_AGENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), BT_MEDIA_TYPE_AGENT))
81 #define BT_MEDIA_AGENT_CLASS(class) (G_TYPE_CHECK_CLASS_CAST((class), BT_MEDIA_TYPE_AGENT, \
83 #define BT_MEDIA_GET_AGENT_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), BT_MEDIA_TYPE_AGENT, \
85 #define BT_MEDIA_IS_AGENT_CLASS(class) (G_TYPE_CHECK_CLASS_TYPE((class), BT_MEDIA_TYPE_AGENT))
87 G_DEFINE_TYPE(BtMediaAgent, bt_media_agent, G_TYPE_OBJECT)
89 static gboolean bt_media_agent_set_property(BtMediaAgent *agent,
90 const char *property, GValue *value,
91 DBusGMethodInvocation *context);
93 static BtMediaAgent *bt_media_obj = NULL;
95 #include "bt-media-agent-method.h"
98 BT_MEDIA_AGENT_ERROR_INVALID_PARAM,
99 BT_MEDIA_AGENT_ERROR_NOT_AVAILABLE,
100 BT_MEDIA_AGENT_ERROR_BUSY,
103 #define BT_MEDIA_AGENT_ERROR (bt_media_agent_error_quark())
105 static GQuark bt_media_agent_error_quark(void)
107 static GQuark quark = 0;
109 quark = g_quark_from_static_string("agent");
114 #define ENUM_ENTRY(NAME, DESC) { NAME, "" #NAME "", DESC }
116 static GError *bt_media_agent_error(BtMediaAgentError error, const char *err_msg)
118 return g_error_new(BT_MEDIA_AGENT_ERROR, error, err_msg, NULL);
121 static void bt_media_agent_init(BtMediaAgent *agent)
123 BT_DBG("agent %p\n", agent);
126 static void bt_media_agent_finalize(GObject *agent)
128 BT_DBG("Free agent %p\n", agent);
130 G_OBJECT_CLASS(bt_media_agent_parent_class)->finalize(agent);
133 static void bt_media_agent_class_init(BtMediaAgentClass *klass)
135 GObjectClass *object_class = (GObjectClass *) klass;
137 BT_DBG("class %p\n", klass);
139 object_class->finalize = bt_media_agent_finalize;
141 dbus_g_object_type_install_info(BT_MEDIA_TYPE_AGENT,
142 &dbus_glib_bt_media_agent_object_info);
145 static BtMediaAgent *__bt_media_agent_new(void)
149 agent = BT_MEDIA_GET_AGENT(g_object_new(BT_MEDIA_TYPE_AGENT, NULL));
151 BT_DBG("agent %p\n", agent);
156 static gboolean bt_media_agent_set_property(BtMediaAgent *agent,
157 const char *property, GValue *val,
158 DBusGMethodInvocation *context)
160 BT_DBG("property %s\n", property);
162 dbus_g_method_return(context);
166 static const char *loopstatus_to_repeat(const char *value)
168 if (strcasecmp(value, "None") == 0)
170 else if (strcasecmp(value, "Track") == 0)
171 return "singletrack";
172 else if (strcasecmp(value, "Playlist") == 0)
178 void set_shuffle(DBusMessageIter *iter)
184 if (dbus_message_iter_get_arg_type(iter) !=
186 BT_DBG("Invalid arguments in method call");
190 dbus_message_iter_get_basic(iter, &shuffle);
191 value = shuffle ? "alltracks" : "off";
193 if (g_strcmp0(value, "alltracks") == 0)
194 status = SHUFFLE_ALL_TRACK;
195 else if (g_strcmp0(value, "off") == 0)
196 status = SHUFFLE_MODE_OFF;
198 status = SHUFFLE_INVALID;
200 _bt_send_event(BT_AVRCP_EVENT,
201 BLUETOOTH_EVENT_AVRCP_SETTING_SHUFFLE_STATUS,
202 DBUS_TYPE_UINT32, &status,
206 void set_loopstatus(DBusMessageIter *iter)
211 if (dbus_message_iter_get_arg_type(iter) !=
213 BT_DBG("Invalid arguments in method call");
217 dbus_message_iter_get_basic(iter, &value);
219 value = loopstatus_to_repeat(value);
221 if (g_strcmp0(value, "singletrack") == 0)
222 status = REPEAT_SINGLE_TRACK;
223 else if (g_strcmp0(value, "alltracks") == 0)
224 status = REPEAT_ALL_TRACK;
225 else if (g_strcmp0(value, "off") == 0)
226 status = REPEAT_MODE_OFF;
228 status = REPEAT_INVALID;
230 _bt_send_event(BT_AVRCP_EVENT,
231 BLUETOOTH_EVENT_AVRCP_SETTING_REPEAT_STATUS,
232 DBUS_TYPE_UINT32, &status,
236 static DBusHandlerResult bt_properties_message(DBusConnection *connection,
237 DBusMessage *message)
239 DBusMessageIter iter, sub;
240 const char *name, *interface;
243 if (!dbus_message_iter_init(message, &iter)){
244 reply = dbus_message_new_error(message,
245 DBUS_ERROR_INVALID_ARGS, "No arguments given");
249 if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING){
250 reply = dbus_message_new_error(message,
251 DBUS_ERROR_INVALID_ARGS, "Invalid argument type");
255 dbus_message_iter_get_basic(&iter, &interface);
256 dbus_message_iter_next(&iter);
258 if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING){
259 reply = dbus_message_new_error(message,
260 DBUS_ERROR_INVALID_ARGS, "Invalid argument type");
264 dbus_message_iter_get_basic(&iter, &name);
265 dbus_message_iter_next(&iter);
267 if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT){
268 reply = dbus_message_new_error(message,
269 DBUS_ERROR_INVALID_ARGS, "Invalid argument type");
273 dbus_message_iter_recurse(&iter, &sub);
275 if (g_strcmp0(interface, BT_MEDIA_PLAYER_INTERFACE) == 0){
276 if (g_strcmp0(name, "LoopStatus") == 0)
277 set_loopstatus(&sub);
278 else if (g_strcmp0(name, "Shuffle") == 0)
282 reply = dbus_message_new_method_return(message);
284 return DBUS_HANDLER_RESULT_NEED_MEMORY;
287 dbus_connection_send(connection, reply, NULL);
288 dbus_message_unref(reply);
290 return DBUS_HANDLER_RESULT_HANDLED;
293 static DBusHandlerResult bt_dbus_message(DBusConnection *connection,
294 DBusMessage *message, void *user_data)
296 const char *interface;
298 interface = dbus_message_get_interface(message);
300 if (interface == NULL)
301 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
303 if (g_strcmp0(interface, BT_PROPERTIES_INTERFACE) == 0)
304 return bt_properties_message(connection, message);
306 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
309 static DBusObjectPathVTable bt_object_table = {
310 .message_function = bt_dbus_message,
313 gboolean bt_dbus_register_object_path(DBusConnection *connection,
316 if (!dbus_connection_register_object_path(connection, path,
317 &bt_object_table, NULL))
323 void bt_dbus_unregister_object_path(DBusConnection *connection,
326 dbus_connection_unregister_object_path(connection, path);
329 static inline void bt_dbus_queue_dispatch(DBusConnection *conn,
330 DBusDispatchStatus status)
332 if (status == DBUS_DISPATCH_DATA_REMAINS){
333 dbus_connection_ref(conn);
334 while (dbus_connection_dispatch(conn)
335 == DBUS_DISPATCH_DATA_REMAINS)
338 dbus_connection_unref(conn);
342 static void bt_dbus_dispatch_status(DBusConnection *conn,
343 DBusDispatchStatus status, void *data)
345 if (!dbus_connection_get_is_connected(conn))
348 bt_dbus_queue_dispatch(conn, status);
351 DBusConnection *bt_dbus_setup_private(DBusBusType type, DBusError *error)
353 DBusConnection *conn;
354 DBusDispatchStatus status;
356 conn = dbus_bus_get_private(type, error);
361 dbus_connection_set_dispatch_status_function(conn,
362 bt_dbus_dispatch_status, NULL, NULL);
364 status = dbus_connection_get_dispatch_status(conn);
365 bt_dbus_queue_dispatch(conn, status);
370 static void __bt_media_append_variant(DBusMessageIter *iter,
371 int type, void *value)
373 char sig[2] = { type, '\0'};
374 DBusMessageIter value_iter;
376 dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, sig,
379 dbus_message_iter_append_basic(&value_iter, type, value);
381 dbus_message_iter_close_container(iter, &value_iter);
384 static void __bt_media_append_dict_entry(DBusMessageIter *iter,
385 const char *key, int type, void *property)
387 DBusMessageIter dict_entry;
390 if (type == DBUS_TYPE_STRING) {
391 str_ptr = *((const char **)property);
392 ret_if(str_ptr == NULL);
395 dbus_message_iter_open_container(iter,
396 DBUS_TYPE_DICT_ENTRY,
399 dbus_message_iter_append_basic(&dict_entry, DBUS_TYPE_STRING, &key);
401 __bt_media_append_variant(&dict_entry, type, property);
403 dbus_message_iter_close_container(iter, &dict_entry);
406 static void __bt_media_append_array_variant(DBusMessageIter *iter, int type,
407 void *val, int n_elements)
409 DBusMessageIter variant, array;
410 char type_sig[2] = { type, '\0' };
411 char array_sig[3] = { DBUS_TYPE_ARRAY, type, '\0' };
413 dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
414 array_sig, &variant);
416 dbus_message_iter_open_container(&variant, DBUS_TYPE_ARRAY,
419 if (dbus_type_is_fixed(type) == TRUE) {
420 dbus_message_iter_append_fixed_array(&array, type, val,
422 } else if (type == DBUS_TYPE_STRING ||
423 type == DBUS_TYPE_OBJECT_PATH) {
424 const char ***str_array = val;
427 for (i = 0; i < n_elements; i++)
428 dbus_message_iter_append_basic(&array, type,
432 dbus_message_iter_close_container(&variant, &array);
433 dbus_message_iter_close_container(iter, &variant);
436 static void __bt_media_append_array(DBusMessageIter *dict, const char *key,
437 int type, void *val, int n_elements)
439 DBusMessageIter entry;
441 dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
444 BT_DBG("key = %s", key);
445 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
447 __bt_media_append_array_variant(&entry, type, val, n_elements);
449 dbus_message_iter_close_container(dict, &entry);
452 static void __bt_media_append_metadata_variant(DBusMessageIter *iter,
453 const char *key, int type, void *property, int count)
455 DBusMessageIter value, metadata;
457 dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, "a{sv}",
460 dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
461 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
462 DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
463 DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &metadata);
465 if (type == DBUS_TYPE_ARRAY)
466 __bt_media_append_array(&metadata, key,
467 DBUS_TYPE_STRING, property, count);
469 __bt_media_append_dict_entry(&metadata, key, type, property);
471 dbus_message_iter_close_container(&value, &metadata);
472 dbus_message_iter_close_container(iter, &value);
475 static void __bt_media_append_metadata_dict_entry(DBusMessageIter *iter,
476 const char *key, int type, void *property, int count)
478 DBusMessageIter dict_entry;
480 char * metadata = "Metadata";
482 if (type == DBUS_TYPE_STRING) {
483 str_ptr = *((const char **)property);
484 ret_if(str_ptr == NULL);
487 dbus_message_iter_open_container(iter,
488 DBUS_TYPE_DICT_ENTRY,
491 dbus_message_iter_append_basic(&dict_entry, DBUS_TYPE_STRING, &metadata);
493 __bt_media_append_metadata_variant(&dict_entry, key, type, property, count);
495 dbus_message_iter_close_container(iter, &dict_entry);
498 static void __bt_metadata_append_property_changed(DBusMessageIter *property_dict,
499 media_metadata_attributes_t *metadata)
501 if(property_dict == NULL || metadata == NULL)
504 __bt_media_append_metadata_dict_entry(property_dict,
506 DBUS_TYPE_STRING, &metadata->title, 0);
508 __bt_media_append_array(property_dict,
510 DBUS_TYPE_ARRAY,&metadata->artist, 1);
512 __bt_media_append_metadata_dict_entry(property_dict,
514 DBUS_TYPE_STRING, &metadata->album, 0);
516 __bt_media_append_array(property_dict,
518 DBUS_TYPE_ARRAY,&metadata->genre, 1);
520 __bt_media_append_metadata_dict_entry(property_dict,
522 DBUS_TYPE_INT64, &metadata->duration, 0);
524 __bt_media_append_metadata_dict_entry(property_dict,
526 DBUS_TYPE_INT32, &metadata->tracknumber, 0);
529 static gboolean __bt_media_emit_property_changed(
530 DBusConnection *connection,
532 const char *interface,
538 DBusMessageIter entry, dict;
542 sig = dbus_message_new_signal(path, DBUS_INTERFACE_PROPERTIES,
543 "PropertiesChanged");
544 retv_if(sig == NULL, FALSE);
546 dbus_message_iter_init_append(sig, &entry);
547 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &interface);
549 dbus_message_iter_open_container(&entry, DBUS_TYPE_ARRAY,
550 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
551 DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
552 DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
554 if (g_strcmp0(name, "Metadata") == 0)
555 __bt_metadata_append_property_changed(&dict,
556 (media_metadata_attributes_t *)property);
558 __bt_media_append_dict_entry(&dict,
559 name, type, property);
561 dbus_message_iter_close_container(&entry, &dict);
563 ret = dbus_connection_send(connection, sig, NULL);
564 dbus_message_unref(sig);
571 int _bt_register_media_player(void)
575 DBusMessageIter iter;
576 DBusMessageIter property_dict;
580 DBusConnection *conn;
581 DBusGConnection *gconn;
583 media_player_settings_t player_settings = {0,};
584 media_metadata_attributes_t metadata = {0,};
586 player_settings.loopstatus = REPEAT_MODE_OFF;
587 player_settings.playbackstatus = STATUS_STOPPED;
588 player_settings.shuffle = FALSE;
589 player_settings.position = 0;
591 metadata.title = "\0";
592 metadata.album = "\0";
593 metadata.tracknumber = 0;
594 metadata.duration = 0;
596 gconn = _bt_get_system_gconn();
597 retv_if(gconn == NULL, BLUETOOTH_ERROR_INTERNAL);
599 conn = bt_dbus_setup_private(DBUS_BUS_SYSTEM, NULL);
600 retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
601 g_bt_dbus_conn = conn;
604 bt_media_obj = __bt_media_agent_new();
606 retv_if(bt_media_obj == NULL, BLUETOOTH_ERROR_INTERNAL);
608 dbus_g_connection_register_g_object(gconn,
609 BT_MEDIA_OBJECT_PATH,
610 G_OBJECT(bt_media_obj));
613 if (!bt_dbus_register_object_path(conn, BT_MEDIA_OBJECT_PATH)){
614 BT_DBG("Could not register interface %s",
615 MPRIS_PLAYER_INTERFACE);
618 adapter_path = _bt_get_adapter_path();
619 retv_if(adapter_path == NULL, BLUETOOTH_ERROR_INTERNAL);
621 msg = dbus_message_new_method_call(BT_BLUEZ_NAME, adapter_path,
622 BT_MEDIA_INTERFACE, "RegisterPlayer");
624 g_free(adapter_path);
626 retv_if(msg == NULL, BLUETOOTH_ERROR_INTERNAL);
628 object = g_strdup(BT_MEDIA_OBJECT_PATH);
630 dbus_message_iter_init_append(msg, &iter);
631 dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH, &object);
634 dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
635 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
636 DBUS_TYPE_STRING_AS_STRING
637 DBUS_TYPE_VARIANT_AS_STRING
638 DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &property_dict);
640 __bt_media_append_dict_entry(&property_dict,
643 &loopstatus_settings[player_settings.loopstatus].property);
645 __bt_media_append_dict_entry(&property_dict,
648 &player_settings.shuffle);
650 __bt_media_append_dict_entry(&property_dict,
653 &playback_status[player_settings.playbackstatus].property);
655 __bt_media_append_dict_entry(&property_dict,
657 DBUS_TYPE_INT64, &player_settings.position);
659 __bt_media_append_metadata_dict_entry(&property_dict,
661 DBUS_TYPE_STRING, &metadata.title, 0);
663 metadata.artists = g_malloc0(sizeof(char *));
664 metadata.artists[0] = "";
666 __bt_media_append_metadata_dict_entry(&property_dict,
668 DBUS_TYPE_ARRAY, &metadata.artists, 1);
670 __bt_media_append_metadata_dict_entry(&property_dict,
672 DBUS_TYPE_STRING, &metadata.album, 0);
674 metadata.genres = g_malloc0(sizeof(char *));
675 metadata.genres[0] = "";
677 __bt_media_append_metadata_dict_entry(&property_dict,
679 DBUS_TYPE_ARRAY, &metadata.genres, 1);
681 __bt_media_append_metadata_dict_entry(&property_dict,
683 DBUS_TYPE_INT64, &metadata.duration, 0);
685 __bt_media_append_metadata_dict_entry(&property_dict,
687 DBUS_TYPE_INT32, &metadata.tracknumber, 0);
689 dbus_message_iter_close_container(&iter, &property_dict);
691 dbus_error_init(&err);
692 reply = dbus_connection_send_with_reply_and_block(conn,
694 dbus_message_unref(msg);
697 BT_DBG("Error in registering the Music Player \n");
699 if (dbus_error_is_set(&err)) {
700 BT_ERR("%s", err.message);
701 dbus_error_free(&err);
702 return BLUETOOTH_ERROR_INTERNAL;
706 dbus_g_connection_unregister_g_object(gconn,
707 G_OBJECT(bt_media_obj));
708 g_object_unref(bt_media_obj);
714 dbus_message_unref(reply);
716 g_free(metadata.artist);
717 g_free(metadata.genre);
719 return BLUETOOTH_ERROR_NONE;
722 int _bt_unregister_media_player(void)
729 DBusConnection *conn;
731 conn = g_bt_dbus_conn;
732 retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
734 adapter_path = _bt_get_adapter_path();
735 retv_if(adapter_path == NULL, BLUETOOTH_ERROR_INTERNAL);
737 msg = dbus_message_new_method_call(BT_BLUEZ_NAME, adapter_path,
738 BT_MEDIA_INTERFACE, "UnregisterPlayer");
740 g_free(adapter_path);
742 retv_if(msg == NULL, BLUETOOTH_ERROR_INTERNAL);
744 object = g_strdup(BT_MEDIA_OBJECT_PATH);
746 dbus_message_append_args(msg,
747 DBUS_TYPE_OBJECT_PATH, &object,
752 dbus_error_init(&err);
753 reply = dbus_connection_send_with_reply_and_block(conn,
755 dbus_message_unref(msg);
758 BT_ERR("Error in unregistering the Music Player \n");
760 if (dbus_error_is_set(&err)) {
761 BT_DBG("%s", err.message);
762 dbus_error_free(&err);
763 return BLUETOOTH_ERROR_INTERNAL;
766 dbus_message_unref(reply);
770 dbus_g_connection_unregister_g_object(_bt_get_system_gconn(),
771 G_OBJECT(bt_media_obj));
772 g_object_unref(bt_media_obj);
776 bt_dbus_unregister_object_path(conn, BT_MEDIA_OBJECT_PATH);
777 g_bt_dbus_conn = NULL;
779 return BLUETOOTH_ERROR_NONE;
782 int _bt_avrcp_set_interal_property(int type, media_player_settings_t *properties)
784 DBusConnection *conn;
786 media_metadata_attributes_t meta_data;
789 conn = g_bt_dbus_conn;
790 retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
794 value = properties->loopstatus;
795 if (!__bt_media_emit_property_changed(
797 BT_MEDIA_OBJECT_PATH,
798 BT_MEDIA_PLAYER_INTERFACE,
801 &loopstatus_settings[value].property)) {
802 BT_DBG("Error sending the PropertyChanged signal \n");
803 return BLUETOOTH_ERROR_INTERNAL;
807 value = properties->shuffle;
808 if (g_strcmp0(repeat_settings[value].property, "alltracks") == 0)
813 if (!__bt_media_emit_property_changed(
815 BT_MEDIA_OBJECT_PATH,
816 BT_MEDIA_PLAYER_INTERFACE,
820 BT_DBG("Error sending the PropertyChanged signal \n");
821 return BLUETOOTH_ERROR_INTERNAL;
825 value = properties->playbackstatus;
826 if (!__bt_media_emit_property_changed(
828 BT_MEDIA_OBJECT_PATH,
829 BT_MEDIA_PLAYER_INTERFACE,
832 &playback_status[value].property)) {
833 BT_DBG("Error sending the PropertyChanged signal \n");
834 return BLUETOOTH_ERROR_INTERNAL;
838 value = properties->position;
839 if (!__bt_media_emit_property_changed(
841 BT_MEDIA_OBJECT_PATH,
842 BT_MEDIA_PLAYER_INTERFACE,
846 BT_DBG("Error sending the PropertyChanged signal \n");
847 return BLUETOOTH_ERROR_INTERNAL;
851 meta_data = properties->metadata;
852 if (!__bt_media_emit_property_changed(
854 BT_MEDIA_OBJECT_PATH,
855 BT_MEDIA_PLAYER_INTERFACE,
859 BT_DBG("Error sending the PropertyChanged signal \n");
860 return BLUETOOTH_ERROR_INTERNAL;
864 BT_DBG("Invalid Type\n");
865 return BLUETOOTH_ERROR_INTERNAL;
868 return BLUETOOTH_ERROR_NONE;
871 int _bt_avrcp_set_properties(media_player_settings_t *properties)
873 if (_bt_avrcp_set_interal_property(LOOPSTATUS,
874 properties) != BLUETOOTH_ERROR_NONE) {
875 return BLUETOOTH_ERROR_INTERNAL;
878 if (_bt_avrcp_set_interal_property(SHUFFLE,
879 properties) != BLUETOOTH_ERROR_NONE) {
880 return BLUETOOTH_ERROR_INTERNAL;
883 if (_bt_avrcp_set_interal_property(PLAYBACKSTATUS,
884 properties) != BLUETOOTH_ERROR_NONE) {
885 return BLUETOOTH_ERROR_INTERNAL;
888 if (_bt_avrcp_set_interal_property(POSITION,
889 properties) != BLUETOOTH_ERROR_NONE) {
890 return BLUETOOTH_ERROR_INTERNAL;
893 if (_bt_avrcp_set_interal_property(METADATA,
894 properties) != BLUETOOTH_ERROR_NONE) {
895 return BLUETOOTH_ERROR_INTERNAL;
898 return BLUETOOTH_ERROR_NONE;
901 int _bt_avrcp_set_property(int type, unsigned int value)
903 media_player_settings_t properties;
909 properties.loopstatus = value;
912 properties.shuffle = value;
915 properties.playbackstatus = value;
918 properties.position = value;
921 BT_DBG("Invalid Type\n");
922 return BLUETOOTH_ERROR_INTERNAL;
925 _bt_avrcp_set_interal_property(type, &properties);
929 return BLUETOOTH_ERROR_NONE;