#define MC_DBUS_SIGNAL_NAME_SHUFFLE_CMD "shuffle_cmd"
#define MC_DBUS_SIGNAL_NAME_REPEAT_CMD "repeat_cmd"
#define MC_DBUS_SIGNAL_NAME_CUSTOM_CMD "custom_cmd"
-#define MC_DBUS_SIGNAL_NAME_CMD_REPLY "custom_cmd_reply"
-#define MC_DBUS_SIGNAL_NAME_PLAYLIST "playlist"
+#define MC_DBUS_SIGNAL_NAME_CMD_REPLY "cmd_reply"
+#define MC_DBUS_SIGNAL_NAME_PLAYLIST "playlist"
#define MC_DBUS_SIGNAL_NAME_PLAYBACK_PLAYLIST "pb_playlist"
+#define MC_DBUS_SIGNAL_NAME_CUSTOM_COMMAND "custom_command"
+#define MC_DBUS_SIGNAL_NAME_CUSTOM_COMMAND_REPLY "custom_command_reply"
#define MC_COMMAND_PLAYBACKSTATE "_pb_state_cmd_"
#define MC_COMMAND_REPEAT "_repeat_cmd_"
#define MC_COMMAND_CUSTOM "_custom_cmd_"
#define MC_COMMAND_PLAY_PLAYLIST "_playlist_cmd_"
-
+#define MC_COMMAND_CUSTOMACTION "_custom_action_"
+#define MC_COMMAND_CMDREPLY "_cmd_reply_"
#define MC_DB_CMD_CREATE_SERVER "DB_CMD_CREATE_SERVER" /* Create New Server Table*/
#define MC_DB_CMD_UPDATE_SERVER_LIST "DB_CMD_UPDATE_SERVER_LIST" /* Update Server Name*/
media_controller_receiver_s repeat_mode_reciever;
media_controller_receiver_s custom_cmd_reciever;
media_controller_receiver_s play_playlist_reciever;
+ media_controller_receiver_s custom_command_reciever;
} media_controller_server_s;
typedef struct {
media_controller_receiver_s repeat_cb;
media_controller_receiver_s reply_cb;
media_controller_receiver_s playlist_cb;
+ media_controller_receiver_s cmd_reply_cb;
} media_controller_client_s;
/* formal callback to receive signal */
int mc_ipc_unregister_listener(GList **manage_list, GDBusConnection *connection, const char *interface_name, const char *signal_name);
int mc_ipc_unregister_all_listener(GList **manage_list, GDBusConnection *connection);
int mc_ipc_send_message(GDBusConnection *connection, const char *dbus_name, const char *interface_name, const char* signal_name, const char* message, char **request_id);
+int mc_ipc_send_reply(GDBusConnection *connection, const char *dbus_name, const char *interface_name, const char *signal_name, const char *message, const char *request_id);
int mc_ipc_send_message_to_server(mc_msg_type_e msg_type, mc_priv_type_e priv_type, const char *request_msg);
int mc_ipc_service_connect(mc_priv_type_e type);
mc_retm_if(reciever->callback == NULL, "repeat_cb is NULL");
- mc_debug("__client_repeat_cb(%s, %s, %s, %s %p)", interface_name, signal_name, message, request_id, user_data);
+ mc_debug("__client_repeat_cb(%s, %s, %s, %s, %p)", interface_name, signal_name, message, request_id, user_data);
params = g_strsplit(message, MC_STRING_DELIMITER, 0);
mc_retm_if(params == NULL, "invalid repeat mode data");
g_strfreev(params);
}
+static void __client_cmd_reply_received_cb(const char *interface_name, const char *signal_name, const char *message, const char *request_id, void *user_data)
+{
+ gchar **params = NULL;
+ int result_code = 0;
+ int enc_size = 0;
+ bundle *bundle_data = NULL;
+
+ media_controller_receiver_s *reciever = (media_controller_receiver_s *)user_data;
+ mc_retm_if(reciever == NULL, "reciever is NULL");
+
+ mc_cmd_reply_received_cb callback = (mc_cmd_reply_received_cb)reciever->callback;
+ mc_retm_if(reciever->callback == NULL, "reply_cb is NULL");
+
+ mc_debug("__client_cmd_reply_received_cb(%s, %s, %s, %s, %p)", interface_name, signal_name, message, request_id, user_data);
+
+ params = g_strsplit(message, MC_STRING_DELIMITER, 0);
+ mc_retm_if(params == NULL, "invalid custom data");
+
+ if (params[1] != NULL)
+ mc_retm_if(MEDIA_CONTROLLER_ERROR_NONE != mc_safe_strtoi(params[1], &result_code), "getting result_code is failed");
+
+ if (params[2] != NULL)
+ mc_retm_if(MEDIA_CONTROLLER_ERROR_NONE != mc_safe_strtoi(params[2], &enc_size), "getting message is failed");
+
+ if (enc_size > 0)
+ bundle_data = bundle_decode((bundle_raw *)params[3], enc_size);
+
+ callback(params[0], request_id, result_code, bundle_data, reciever->user_data);
+
+ g_strfreev(params);
+}
+
static int __mc_client_create(media_controller_client_s **mc_client)
{
int ret = MEDIA_CONTROLLER_ERROR_NONE;
return ret;
}
+int mc_client_set_cmd_reply_received_cb(mc_client_h client, mc_cmd_reply_received_cb callback, void *user_data)
+{
+ int ret = MEDIA_CONTROLLER_ERROR_NONE;
+ media_controller_client_s *mc_client = (media_controller_client_s *)client;
+
+ mc_retvm_if(mc_client == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
+ mc_retvm_if(callback == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "callback is NULL");
+ mc_retvm_if(mc_client->cmd_reply_cb.callback != NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "callback is already set");
+
+ mc_client->cmd_reply_cb.callback = callback;
+ mc_client->cmd_reply_cb.user_data = user_data;
+
+ char *interface_name = mc_util_get_interface_name(MC_CLIENT, mc_client->client_name);
+ ret = mc_ipc_register_listener(&mc_client->listeners, mc_client->dconn, interface_name, MC_DBUS_SIGNAL_NAME_CMD_REPLY,
+ __client_cmd_reply_received_cb, (void *)&(mc_client->cmd_reply_cb));
+
+ MC_SAFE_FREE(interface_name);
+
+ return ret;
+}
+
+int mc_client_unset_cmd_reply_received_cb(mc_client_h client)
+{
+ int ret = MEDIA_CONTROLLER_ERROR_NONE;
+ media_controller_client_s *mc_client = (media_controller_client_s *)client;
+
+ mc_retvm_if(mc_client == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
+
+ char *interface_name = mc_util_get_interface_name(MC_CLIENT, mc_client->client_name);
+ ret = mc_ipc_unregister_listener(&mc_client->listeners, mc_client->dconn, interface_name, MC_DBUS_SIGNAL_NAME_CMD_REPLY);
+
+ mc_client->cmd_reply_cb.callback = NULL;
+ mc_client->cmd_reply_cb.user_data = NULL;
+ mc_client->cmd_reply_cb.filter_list = NULL;
+
+ MC_SAFE_FREE(interface_name);
+
+ return ret;
+}
+
int mc_client_subscribe(mc_client_h client, const mc_subscription_type_e subscription_type, const char *server_name)
{
int ret = MEDIA_CONTROLLER_ERROR_NONE;
char *message = NULL;
media_controller_client_s *mc_client = (media_controller_client_s *)client;
+ mc_warning("DEPRECATION WARNING: mc_client_send_playback_state_command() is deprecated and will be removed from next release. Use mc_client_send_playback_action_cmd() instead.");
mc_retvm_if(mc_client == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
mc_retvm_if(!MC_STRING_VALID(server_name), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid server_name");
mc_retvm_if(((state < MC_PLAYBACK_STATE_PLAYING) || (state > MC_PLAYBACK_STATE_REWIND)), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "state is invalid");
return ret;
}
+int mc_client_send_playback_action_cmd(mc_client_h client, const char *server_name, mc_playback_action_e action, char **request_id)
+{
+ int ret = MEDIA_CONTROLLER_ERROR_NONE;
+ char *message = NULL;
+ media_controller_client_s *mc_client = (media_controller_client_s *)client;
+
+ mc_retvm_if(mc_client == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
+ mc_retvm_if(!MC_STRING_VALID(server_name), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid server_name");
+ mc_retvm_if(((action < MC_PLAYBACK_ACTION_PLAY) || (action > MC_PLAYBACK_ACTION_TOGGLE_PLAY_PAUSE)), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid action");
+
+ message = g_strdup_printf("%s%s%d", mc_client->client_name, MC_STRING_DELIMITER, action);
+ mc_retvm_if(message == NULL, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "fail making message [%d]", ret);
+
+ ret = __mc_client_send_command(client, server_name, MC_COMMAND_PLAYBACKACTION, NULL, MC_DBUS_SIGNAL_NAME_PLAYBACK_ACTION, message, request_id);
+
+ MC_SAFE_G_FREE(message);
+
+ return ret;
+}
+
+int mc_client_send_playback_position_cmd(mc_client_h client, const char *server_name, unsigned long long position, char **request_id)
+{
+ int ret = MEDIA_CONTROLLER_ERROR_NONE;
+ char *message = NULL;
+ media_controller_client_s *mc_client = (media_controller_client_s *)client;
+
+ mc_retvm_if(mc_client == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
+ mc_retvm_if(!MC_STRING_VALID(server_name), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid server_name");
+
+ message = g_strdup_printf("%s%s%llu", mc_client->client_name, MC_STRING_DELIMITER, position);
+ mc_retvm_if(message == NULL, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "fail making message [%d]", ret);
+
+ ret = __mc_client_send_command(client, server_name, MC_COMMAND_PLAYBACKPOSITION, NULL, MC_DBUS_SIGNAL_NAME_PLAYBACK_POS_CMD, message, request_id);
+
+ MC_SAFE_G_FREE(message);
+
+ return ret;
+}
+
+int mc_client_send_shuffle_mode_cmd(mc_client_h client, const char *server_name, mc_shuffle_mode_e shuffle_mode, char **request_id)
+{
+ int ret = MEDIA_CONTROLLER_ERROR_NONE;
+ char *message = NULL;
+ media_controller_client_s *mc_client = (media_controller_client_s *)client;
+
+ mc_retvm_if(mc_client == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
+ mc_retvm_if(!MC_STRING_VALID(server_name), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid server_name");
+ mc_retvm_if(((shuffle_mode < MC_SHUFFLE_MODE_ON) || (shuffle_mode > MC_SHUFFLE_MODE_OFF)), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "shuffle is invalid");
+
+ message = g_strdup_printf("%s%s%d", mc_client->client_name, MC_STRING_DELIMITER, shuffle_mode);
+ mc_retvm_if(message == NULL, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "fail making message [%d]", ret);
+
+ ret = __mc_client_send_command(client, server_name, MC_COMMAND_SHUFFLE, NULL, MC_DBUS_SIGNAL_NAME_SHUFFLE_CMD, message, request_id);
+
+ MC_SAFE_G_FREE(message);
+
+ return ret;
+}
+
+int mc_client_send_repeat_mode_cmd(mc_client_h client, const char *server_name, mc_repeat_mode_e repeat_mode, char **request_id)
+{
+ int ret = MEDIA_CONTROLLER_ERROR_NONE;
+ char *message = NULL;
+ media_controller_client_s *mc_client = (media_controller_client_s *)client;
+
+ mc_retvm_if(mc_client == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
+ mc_retvm_if(!MC_STRING_VALID(server_name), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid server_name");
+ mc_retvm_if(((repeat_mode < MC_REPEAT_MODE_ON) || (repeat_mode > MC_REPEAT_MODE_ONE_MEDIA)), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "repeat is invalid [%d]", repeat_mode);
+
+ message = g_strdup_printf("%s%s%d", mc_client->client_name, MC_STRING_DELIMITER, repeat_mode);
+ mc_retvm_if(message == NULL, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "fail making message [%d]", ret);
+
+ ret = __mc_client_send_command(client, server_name, MC_COMMAND_REPEAT, NULL, MC_DBUS_SIGNAL_NAME_REPEAT_CMD, message, request_id);
+
+ MC_SAFE_G_FREE(message);
+
+ return ret;
+}
+
int mc_client_send_custom_command(mc_client_h client, const char *server_name, const char *command, bundle *data, mc_command_reply_received_cb callback, void *user_data)
{
int ret = MEDIA_CONTROLLER_ERROR_NONE;
char *bundle_str = NULL;
media_controller_client_s *mc_client = (media_controller_client_s *)client;
+ mc_warning("DEPRECATION WARNING: mc_client_send_custom_command() is deprecated and will be removed from next release. Use mc_client_send_custom_cmd() instead.");
+
mc_retvm_if(mc_client == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
mc_retvm_if(!MC_STRING_VALID(server_name), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid server_name");
char *interface_name_for_reply = mc_util_get_interface_name(MC_CLIENT, mc_client->client_name);
mc_client->reply_cb.callback = callback;
mc_client->reply_cb.user_data = user_data;
- mc_ipc_register_listener(&mc_client->listeners, mc_client->dconn, interface_name_for_reply, MC_DBUS_SIGNAL_NAME_CMD_REPLY, __client_reply_cb, (void *)&(mc_client->reply_cb));
+ mc_ipc_register_listener(&mc_client->listeners, mc_client->dconn, interface_name_for_reply, MC_DBUS_SIGNAL_NAME_CUSTOM_COMMAND_REPLY, __client_reply_cb, (void *)&(mc_client->reply_cb));
MC_SAFE_FREE(interface_name_for_reply);
}
MC_SAFE_G_FREE(bundle_str);
mc_retvm_if(message == NULL, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "Error when making message");
- ret = __mc_client_send_command(client, server_name, MC_COMMAND_CUSTOM, command, MC_DBUS_SIGNAL_NAME_CUSTOM_CMD, message, NULL);
+ ret = __mc_client_send_command(client, server_name, MC_COMMAND_CUSTOM, command, MC_DBUS_SIGNAL_NAME_CUSTOM_COMMAND, message, NULL);
+
+ MC_SAFE_G_FREE(message);
+
+ return ret;
+}
+
+int mc_client_send_playlist_cmd(mc_client_h client, const char *server_name, const char *playlist_name, const char *index, mc_playback_action_e action, unsigned long long position, char **request_id)
+{
+ int ret = MEDIA_CONTROLLER_ERROR_NONE;
+ char *message = NULL;
+ media_controller_client_s *mc_client = (media_controller_client_s *)client;
+
+ mc_retvm_if(mc_client == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
+ mc_retvm_if(!MC_STRING_VALID(server_name), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid server_name");
+ mc_retvm_if(!MC_STRING_VALID(playlist_name), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid playlist_name");
+ mc_retvm_if(!MC_STRING_VALID(index), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid index");
+ mc_retvm_if(((action < MC_PLAYBACK_ACTION_PLAY) || (action > MC_PLAYBACK_ACTION_TOGGLE_PLAY_PAUSE)), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid action");
+
+ message = g_strdup_printf("%s%s%s%s%s%s%d%s%llu", mc_client->client_name, MC_STRING_DELIMITER, playlist_name, MC_STRING_DELIMITER, index, MC_STRING_DELIMITER, action, MC_STRING_DELIMITER, position);
+ mc_retvm_if(message == NULL, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "fail making message [%d]", ret);
+
+ ret = __mc_client_send_command(client, server_name, MC_COMMAND_PLAY_PLAYLIST, NULL, MC_DBUS_SIGNAL_NAME_PLAYBACK_PLAYLIST, message, request_id);
+
+ MC_SAFE_G_FREE(message);
+
+ return ret;
+}
+
+int mc_client_send_custom_cmd(mc_client_h client, const char *server_name, const char *command, bundle *data, char **request_id)
+{
+ int ret = MEDIA_CONTROLLER_ERROR_NONE;
+ char *message = NULL;
+ char *bundle_str = NULL;
+ media_controller_client_s *mc_client = (media_controller_client_s *)client;
+
+ mc_retvm_if(mc_client == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
+ mc_retvm_if(!MC_STRING_VALID(server_name), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid server_name");
+
+ ret = mc_util_bundle_to_string(data, &bundle_str);
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "Error when make string from bundle");
+
+ message = g_strdup_printf("%s%s%s%s%s", mc_client->client_name, MC_STRING_DELIMITER, command, MC_STRING_DELIMITER, bundle_str);
+ MC_SAFE_G_FREE(bundle_str);
+ mc_retvm_if(message == NULL, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "Error when making message");
+
+ ret = __mc_client_send_command(client, server_name, MC_COMMAND_CUSTOMACTION, command, MC_DBUS_SIGNAL_NAME_CUSTOM_CMD, message, request_id);
MC_SAFE_G_FREE(message);
return MEDIA_CONTROLLER_ERROR_NONE;
}
+int mc_ipc_send_reply(GDBusConnection *connection, const char *dbus_name, const char *interface_name, const char *signal_name, const char *message, const char *request_id)
+{
+ GError *error = NULL;
+
+ mc_retvm_if(connection == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "connection is NULL");
+ mc_retvm_if(!MC_STRING_VALID(signal_name), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid signal_name");
+ mc_retvm_if(!MC_STRING_VALID(message), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid message");
+
+ mc_debug("emit signal - interface_name [%s], signal_name [%s]", interface_name, signal_name);
+
+ gboolean emmiting = g_dbus_connection_emit_signal(
+ connection,
+ dbus_name,
+ MC_DBUS_PATH,
+ interface_name,
+ signal_name,
+ g_variant_new("(ss)", request_id, message),
+ &error);
+ if (!emmiting) {
+ mc_error("g_dbus_connection_emit_signal failed : %s", error ? error->message : "none");
+ if (error) {
+ mc_error("Error in g_dbus_connection_emit_signal");
+ g_error_free(error);
+ }
+ return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;
+ }
+
+ return MEDIA_CONTROLLER_ERROR_NONE;
+}
+
int mc_ipc_send_message_to_server(mc_msg_type_e msg_type, mc_priv_type_e priv_type, const char *request_msg)
{
int ret = MEDIA_CONTROLLER_ERROR_NONE;
g_strfreev(params);
}
+static void __server_playback_action_cb(const char *interface_name, const char *signal_name, const char *message, const char *request_id, void *user_data)
+{
+ gchar **params = NULL;
+ media_controller_receiver_s *receiver = (media_controller_receiver_s *)user_data;
+ int value = 0;
+
+ mc_retm_if(receiver == NULL, "reciever is NULL");
+ mc_retm_if(message == NULL, "message is NULL");
+
+ mc_server_playback_action_cmd_received_cb callback = receiver->callback;
+ mc_retm_if(receiver->callback == NULL, "playback_action_command_received_cb is NULL");
+
+ mc_debug("__server_playback_action_cb(%s, %s, %s, %s, %p)", interface_name, signal_name, message, request_id, user_data);
+
+ params = g_strsplit(message, MC_STRING_DELIMITER, 0);
+ mc_retm_if(params == NULL, "invalid playback_action command");
+
+ if (mc_util_get_command_available(MC_PRIV_TYPE_SERVER, params[0], MC_COMMAND_PLAYBACKACTION, NULL) != MEDIA_CONTROLLER_ERROR_NONE) {
+ mc_error("Error permission denied");
+ g_strfreev(params);
+ return;
+ }
+
+ if (mc_safe_strtoi(params[1], &value) != MEDIA_CONTROLLER_ERROR_NONE) {
+ mc_error("Error get recieved value");
+ g_strfreev(params);
+ return;
+ }
+
+ callback(params[0], request_id, (mc_playback_action_e)value, receiver->user_data);
+
+ g_strfreev(params);
+}
+
+static void __server_playback_position_cmd_cb(const char *interface_name, const char *signal_name, const char *message, const char *request_id, void *user_data)
+{
+ gchar **params = NULL;
+ media_controller_receiver_s *receiver = (media_controller_receiver_s *)user_data;
+ unsigned long long value = 0;
+
+ mc_retm_if(receiver == NULL, "reciever is NULL");
+ mc_retm_if(message == NULL, "message is NULL");
+
+ mc_server_playback_position_cmd_received_cb callback = receiver->callback;
+ mc_retm_if(receiver->callback == NULL, "playback_position_cmd_received_cb is NULL");
+
+ mc_debug("__server_playback_position_cmd_cb(%s, %s, %s, %s, %p)", interface_name, signal_name, message, request_id, user_data);
+
+ params = g_strsplit(message, MC_STRING_DELIMITER, 0);
+ mc_retm_if(params == NULL, "invalid playback_position command");
+
+ if (mc_util_get_command_available(MC_PRIV_TYPE_SERVER, params[0], MC_COMMAND_PLAYBACKPOSITION, NULL) != MEDIA_CONTROLLER_ERROR_NONE) {
+ mc_error("Error permission denied");
+ g_strfreev(params);
+ return;
+ }
+
+ if (mc_safe_strtoull(params[1], &value) != MEDIA_CONTROLLER_ERROR_NONE) {
+ mc_error("Error get recieved value");
+ g_strfreev(params);
+ return;
+ }
+
+ callback(params[0], request_id, value, receiver->user_data);
+
+ g_strfreev(params);
+}
+
+static void __server_shuffle_mode_cmd_cb(const char *interface_name, const char *signal_name, const char *message, const char *request_id, void *user_data)
+{
+ gchar **params = NULL;
+ media_controller_receiver_s *receiver = (media_controller_receiver_s *)user_data;
+ int value = 0;
+
+ mc_retm_if(receiver == NULL, "reciever is NULL");
+ mc_retm_if(message == NULL, "message is NULL");
+
+ mc_server_shuffle_mode_cmd_received_cb callback = receiver->callback;
+ mc_retm_if(receiver->callback == NULL, "shuffle_mode_cmd_received_cb is NULL");
+
+ mc_debug("__server_shuffle_mode_cmd_cb(%s, %s, %s, %s, %p)", interface_name, signal_name, message, request_id, user_data);
+
+ params = g_strsplit(message, MC_STRING_DELIMITER, 0);
+ mc_retm_if(params == NULL, "invalid shuffle_mode command");
+
+ if (mc_util_get_command_available(MC_PRIV_TYPE_SERVER, params[0], MC_COMMAND_SHUFFLE, NULL) != MEDIA_CONTROLLER_ERROR_NONE) {
+ mc_error("Error permission denied");
+ g_strfreev(params);
+ return;
+ }
+
+ if (mc_safe_strtoi(params[1], &value) != MEDIA_CONTROLLER_ERROR_NONE) {
+ mc_error("Error get recieved value");
+ g_strfreev(params);
+ return;
+ }
+
+ callback(params[0], request_id, (mc_shuffle_mode_e)value, receiver->user_data);
+
+ g_strfreev(params);
+}
+
+static void __server_repeat_mode_cmd_cb(const char *interface_name, const char *signal_name, const char *message, const char *request_id, void *user_data)
+{
+ gchar **params = NULL;
+ media_controller_receiver_s *receiver = (media_controller_receiver_s *)user_data;
+ int value = 0;
+
+ mc_retm_if(receiver == NULL, "reciever is NULL");
+ mc_retm_if(message == NULL, "message is NULL");
+
+ mc_server_repeat_mode_cmd_received_cb callback = receiver->callback;
+ mc_retm_if(receiver->callback == NULL, "repeat_mode_cmd_received_cb is NULL");
+
+ mc_debug("__server_repeat_mode_cmd_cb(%s, %s, %s, %s, %p)", interface_name, signal_name, message, request_id, user_data);
+
+ params = g_strsplit(message, MC_STRING_DELIMITER, 0);
+ mc_retm_if(params == NULL, "invalid repeat_mode command");
+
+ if (mc_util_get_command_available(MC_PRIV_TYPE_SERVER, params[0], MC_COMMAND_REPEAT, NULL) != MEDIA_CONTROLLER_ERROR_NONE) {
+ mc_error("Error permission denied");
+ g_strfreev(params);
+ return;
+ }
+
+ if (mc_safe_strtoi(params[1], &value) != MEDIA_CONTROLLER_ERROR_NONE) {
+ mc_error("Error get recieved value");
+ g_strfreev(params);
+ return;
+ }
+
+ callback(params[0], request_id, (mc_repeat_mode_e)value, receiver->user_data);
+
+ g_strfreev(params);
+}
+
static void __server_custom_command_cb(const char *interface_name, const char *signal_name, const char *message, const char *request_id, void *user_data)
{
gchar **params = NULL;
g_strfreev(params);
}
+static void __server_play_playlist_cmd_cb(const char *interface_name, const char *signal_name, const char *message, const char *request_id, void *user_data)
+{
+ gchar **params = NULL;
+ media_controller_receiver_s *receiver = (media_controller_receiver_s *)user_data;
+ int action = 0;
+ unsigned long long position = 0;
+
+ mc_retm_if(receiver == NULL, "reciever is NULL");
+ mc_retm_if(message == NULL, "message is NULL");
+
+ mc_server_playlist_cmd_received_cb callback = receiver->callback;
+ mc_retm_if(receiver->callback == NULL, "mc_server_playlist_cmd_received_cb is NULL");
+
+ mc_debug("__server_play_playlist_cmd_cb(%s, %s, %s, %ld, %p)", interface_name, signal_name, message, request_id, user_data);
+
+ params = g_strsplit(message, MC_STRING_DELIMITER, 0);
+ mc_retm_if(params == NULL, "invalid play_playlist command");
+
+ if (mc_util_get_command_available(MC_PRIV_TYPE_SERVER, params[0], MC_COMMAND_PLAY_PLAYLIST, NULL) != MEDIA_CONTROLLER_ERROR_NONE) {
+ mc_error("Error permission denied");
+ g_strfreev(params);
+ return;
+ }
+
+ if (mc_safe_strtoi(params[3], &action) != MEDIA_CONTROLLER_ERROR_NONE) {
+ mc_error("Error get recieved action value");
+ g_strfreev(params);
+ return;
+ }
+
+ if (mc_safe_strtoull(params[4], &position) != MEDIA_CONTROLLER_ERROR_NONE) {
+ mc_error("Error get recieved position value");
+ g_strfreev(params);
+ return;
+ }
+
+ callback(params[0], request_id, params[1], params[2], (mc_playback_action_e)action, position, receiver->user_data);
+
+ g_strfreev(params);
+}
+
+static void __server_custom_cmd_cb(const char *interface_name, const char *signal_name, const char *message, const char *request_id, void *user_data)
+{
+ gchar **params = NULL;
+ int enc_size = 0;
+ char *sender = NULL;
+ char *command = NULL;
+ bundle *bundle_data = NULL;
+
+ media_controller_receiver_s *receiver = (media_controller_receiver_s *)user_data;
+ mc_retm_if(receiver == NULL, "reciever is NULL");
+
+ mc_server_custom_cmd_received_cb callback = receiver->callback;
+ mc_retm_if(receiver->callback == NULL, "custom_command_received_cb is NULL");
+
+ mc_debug("__server_custom_cb(%s, %s, %s, %llu, %p)", interface_name, signal_name, message, request_id, user_data);
+
+ params = g_strsplit(message, MC_STRING_DELIMITER, 0);
+ mc_retm_if(params == NULL, "invalid custom data");
+
+ if (params[0])
+ sender = strdup(params[0]);
+
+ if (mc_util_get_command_available(MC_PRIV_TYPE_SERVER, sender, MC_COMMAND_CUSTOMACTION, params[1]) != MEDIA_CONTROLLER_ERROR_NONE) {
+ mc_error("Error permission denied");
+ MC_SAFE_FREE(sender);
+ g_strfreev(params);
+ return;
+ }
+
+ command = strdup(params[1]);
+ enc_size = atoi(params[2]);
+ if (enc_size > 0)
+ bundle_data = bundle_decode((bundle_raw *)params[3], enc_size);
+
+ callback(sender, request_id, command, bundle_data, receiver->user_data);
+
+ MC_SAFE_FREE(sender);
+ MC_SAFE_FREE(command);
+
+ g_strfreev(params);
+}
+
static int __mc_server_current_is_latest(media_controller_server_s *mc_server, bool *is_latest)
{
int ret = MEDIA_CONTROLLER_ERROR_NONE;
media_controller_server_s *mc_server = (media_controller_server_s *)server;
mc_retvm_if(mc_server == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
- mc_retvm_if(((state < MC_PLAYBACK_STATE_PLAYING) || (state > MC_PLAYBACK_STATE_REWIND)), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "state is invalid");
+ mc_retvm_if(((state < MC_PLAYBACK_STATE_PLAYING) || (state > MC_PLAYBACK_STATE_REWINDING)), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "state is invalid");
mc_debug("playback state update [%d]", state);
media_controller_server_s *mc_server = (media_controller_server_s *)server;
mc_retvm_if(mc_server == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
-
- if ((mode != MC_REPEAT_MODE_ON) && (mode != MC_REPEAT_MODE_OFF)) {
- mc_error("Invalid repeat mode [%d]", mode);
- return MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER;
- }
+ mc_retvm_if(((mode < MC_REPEAT_MODE_ON) || (mode > MC_REPEAT_MODE_ONE_MEDIA)), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "repeat is invalid [%d]", mode);
mc_debug("repeat mode %d", mode);
int ret = MEDIA_CONTROLLER_ERROR_NONE;
media_controller_server_s *mc_server = (media_controller_server_s *)server;
+ mc_warning("DEPRECATION WARNING: mc_server_set_playback_state_command_received_cb() is deprecated and will be removed from next release. Use mc_server_set_playback_action_cmd_received_cb() instead.");
+
mc_retvm_if(mc_server == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
mc_retvm_if(callback == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "callback is NULL");
int ret = MEDIA_CONTROLLER_ERROR_NONE;
media_controller_server_s *mc_server = (media_controller_server_s *)server;
+ mc_warning("DEPRECATION WARNING: mc_server_set_playback_state_command_received_cb() is deprecated and will be removed from next release. Use mc_server_unset_playback_action_cmd_received_cb() instead.");
+
mc_retvm_if(mc_server == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
char *interface_name = mc_util_get_interface_name(MC_SERVER, mc_server->server_name);
return ret;
}
+int mc_server_set_playback_action_cmd_received_cb(mc_server_h server, mc_server_playback_action_cmd_received_cb callback, void *user_data)
+{
+ int ret = MEDIA_CONTROLLER_ERROR_NONE;
+ media_controller_server_s *mc_server = (media_controller_server_s *)server;
+
+ mc_retvm_if(mc_server == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
+ mc_retvm_if(callback == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "callback is NULL");
+
+ mc_server->playback_action_reciever.callback = callback;
+ mc_server->playback_action_reciever.user_data = user_data;
+
+ char *interface_name = mc_util_get_interface_name(MC_SERVER, mc_server->server_name);
+ ret = mc_ipc_register_listener(&mc_server->listeners, mc_server->dconn, interface_name, MC_DBUS_SIGNAL_NAME_PLAYBACK_ACTION, __server_playback_action_cb, (void *)&(mc_server->playback_action_reciever));
+
+ MC_SAFE_FREE(interface_name);
+
+ return ret;
+}
+
+int mc_server_unset_playback_action_cmd_received_cb(mc_server_h server)
+{
+ int ret = MEDIA_CONTROLLER_ERROR_NONE;
+ media_controller_server_s *mc_server = (media_controller_server_s *)server;
+
+ mc_retvm_if(mc_server == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
+
+ char *interface_name = mc_util_get_interface_name(MC_SERVER, mc_server->server_name);
+ ret = mc_ipc_unregister_listener(&mc_server->listeners, mc_server->dconn, interface_name, MC_DBUS_SIGNAL_NAME_PLAYBACK_ACTION);
+
+ mc_server->playback_action_reciever.callback = NULL;
+ mc_server->playback_action_reciever.user_data = NULL;
+
+ MC_SAFE_FREE(interface_name);
+
+ return ret;
+}
+
+int mc_server_set_playback_position_cmd_received_cb(mc_server_h server, mc_server_playback_position_cmd_received_cb callback, void *user_data)
+{
+ int ret = MEDIA_CONTROLLER_ERROR_NONE;
+ media_controller_server_s *mc_server = (media_controller_server_s *)server;
+
+ mc_retvm_if(mc_server == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
+ mc_retvm_if(callback == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "callback is NULL");
+
+ mc_server->playback_position_reciever.callback = callback;
+ mc_server->playback_position_reciever.user_data = user_data;
+
+ char *interface_name = mc_util_get_interface_name(MC_SERVER, mc_server->server_name);
+ ret = mc_ipc_register_listener(&mc_server->listeners, mc_server->dconn, interface_name, MC_DBUS_SIGNAL_NAME_PLAYBACK_POS_CMD, __server_playback_position_cmd_cb, (void *)&(mc_server->playback_position_reciever));
+
+ MC_SAFE_FREE(interface_name);
+
+ return ret;
+}
+
+int mc_server_unset_playback_position_cmd_received_cb(mc_server_h server)
+{
+ int ret = MEDIA_CONTROLLER_ERROR_NONE;
+ media_controller_server_s *mc_server = (media_controller_server_s *)server;
+
+ mc_retvm_if(mc_server == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
+
+ char *interface_name = mc_util_get_interface_name(MC_SERVER, mc_server->server_name);
+ ret = mc_ipc_unregister_listener(&mc_server->listeners, mc_server->dconn, interface_name, MC_DBUS_SIGNAL_NAME_PLAYBACK_POS_CMD);
+
+ mc_server->playback_position_reciever.callback = NULL;
+ mc_server->playback_position_reciever.user_data = NULL;
+
+ MC_SAFE_FREE(interface_name);
+
+ return ret;
+}
+
+int mc_server_set_shuffle_mode_cmd_received_cb(mc_server_h server, mc_server_shuffle_mode_cmd_received_cb callback, void *user_data)
+{
+ int ret = MEDIA_CONTROLLER_ERROR_NONE;
+ media_controller_server_s *mc_server = (media_controller_server_s *)server;
+
+ mc_retvm_if(mc_server == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
+ mc_retvm_if(callback == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "callback is NULL");
+
+ mc_server->shuffle_mode_reciever.callback = callback;
+ mc_server->shuffle_mode_reciever.user_data = user_data;
+
+ char *interface_name = mc_util_get_interface_name(MC_SERVER, mc_server->server_name);
+ ret = mc_ipc_register_listener(&mc_server->listeners, mc_server->dconn, interface_name, MC_DBUS_SIGNAL_NAME_SHUFFLE_CMD, __server_shuffle_mode_cmd_cb, (void *)&(mc_server->shuffle_mode_reciever));
+
+ MC_SAFE_FREE(interface_name);
+
+ return ret;
+}
+
+int mc_server_unset_shuffle_mode_cmd_received_cb(mc_server_h server)
+{
+ int ret = MEDIA_CONTROLLER_ERROR_NONE;
+ media_controller_server_s *mc_server = (media_controller_server_s *)server;
+
+ mc_retvm_if(mc_server == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
+
+ char *interface_name = mc_util_get_interface_name(MC_SERVER, mc_server->server_name);
+ ret = mc_ipc_unregister_listener(&mc_server->listeners, mc_server->dconn, interface_name, MC_DBUS_SIGNAL_NAME_SHUFFLE_CMD);
+
+ mc_server->shuffle_mode_reciever.callback = NULL;
+ mc_server->shuffle_mode_reciever.user_data = NULL;
+
+ MC_SAFE_FREE(interface_name);
+
+ return ret;
+}
+
+int mc_server_set_repeat_mode_cmd_received_cb(mc_server_h server, mc_server_repeat_mode_cmd_received_cb callback, void *user_data)
+{
+ int ret = MEDIA_CONTROLLER_ERROR_NONE;
+ media_controller_server_s *mc_server = (media_controller_server_s *)server;
+
+ mc_retvm_if(mc_server == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
+ mc_retvm_if(callback == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "callback is NULL");
+
+ mc_server->repeat_mode_reciever.callback = callback;
+ mc_server->repeat_mode_reciever.user_data = user_data;
+
+ char *interface_name = mc_util_get_interface_name(MC_SERVER, mc_server->server_name);
+ ret = mc_ipc_register_listener(&mc_server->listeners, mc_server->dconn, interface_name, MC_DBUS_SIGNAL_NAME_REPEAT_CMD, __server_repeat_mode_cmd_cb, (void *)&(mc_server->repeat_mode_reciever));
+
+ MC_SAFE_FREE(interface_name);
+
+ return ret;
+}
+
+int mc_server_unset_repeat_mode_cmd_received_cb(mc_server_h server)
+{
+ int ret = MEDIA_CONTROLLER_ERROR_NONE;
+ media_controller_server_s *mc_server = (media_controller_server_s *)server;
+
+ mc_retvm_if(mc_server == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
+
+ char *interface_name = mc_util_get_interface_name(MC_SERVER, mc_server->server_name);
+ ret = mc_ipc_unregister_listener(&mc_server->listeners, mc_server->dconn, interface_name, MC_DBUS_SIGNAL_NAME_REPEAT_CMD);
+
+ mc_server->repeat_mode_reciever.callback = NULL;
+ mc_server->repeat_mode_reciever.user_data = NULL;
+
+ MC_SAFE_FREE(interface_name);
+
+ return ret;
+}
+
int mc_server_set_custom_command_received_cb(mc_server_h server, mc_server_custom_command_received_cb callback, void *user_data)
{
int ret = MEDIA_CONTROLLER_ERROR_NONE;
mc_retvm_if(mc_server == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
mc_retvm_if(callback == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "callback is NULL");
+ mc_server->custom_command_reciever.callback = callback;
+ mc_server->custom_command_reciever.user_data = user_data;
+
+ char *interface_name = mc_util_get_interface_name(MC_SERVER, mc_server->server_name);
+ ret = mc_ipc_register_listener(&mc_server->listeners, mc_server->dconn, interface_name, MC_DBUS_SIGNAL_NAME_CUSTOM_COMMAND, __server_custom_command_cb, (void *)&(mc_server->custom_command_reciever));
+
+ MC_SAFE_FREE(interface_name);
+
+ return ret;
+}
+
+int mc_server_unset_custom_command_received_cb(mc_server_h server)
+{
+ int ret = MEDIA_CONTROLLER_ERROR_NONE;
+ media_controller_server_s *mc_server = (media_controller_server_s *)server;
+
+ mc_retvm_if(mc_server == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
+
+ char *interface_name = mc_util_get_interface_name(MC_SERVER, mc_server->server_name);
+ ret = mc_ipc_unregister_listener(&mc_server->listeners, mc_server->dconn, interface_name, MC_DBUS_SIGNAL_NAME_CUSTOM_COMMAND);
+
+ mc_server->custom_command_reciever.callback = NULL;
+ mc_server->custom_command_reciever.user_data = NULL;
+
+ MC_SAFE_FREE(interface_name);
+
+ return ret;
+}
+
+int mc_server_send_command_reply(mc_server_h server, const char *client_name, int result_code, bundle *data)
+{
+ int ret = MEDIA_CONTROLLER_ERROR_NONE;
+ char *message = NULL;
+ char *bundle_str = NULL;
+ media_controller_server_s *mc_server = (media_controller_server_s *)server;
+
+ mc_retvm_if(mc_server == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
+ mc_retvm_if(!MC_STRING_VALID(client_name), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "client_name is NULL");
+
+ ret = mc_util_bundle_to_string(data, &bundle_str);
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "Error when make string from bundle");
+
+ message = g_strdup_printf("%s%s%d%s%s", mc_server->server_name, MC_STRING_DELIMITER, result_code, MC_STRING_DELIMITER, bundle_str);
+ MC_SAFE_G_FREE(bundle_str);
+ mc_retvm_if(message == NULL, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "Error when making message");
+
+ char *interface_name = mc_util_get_interface_name(MC_CLIENT, client_name);
+ ret = mc_ipc_send_message(mc_server->dconn, NULL, interface_name, MC_DBUS_SIGNAL_NAME_CUSTOM_COMMAND_REPLY, message, NULL);
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE)
+ mc_error("Error mc_ipc_send_message [%d]", ret);
+
+ MC_SAFE_G_FREE(message);
+ MC_SAFE_G_FREE(interface_name);
+
+ return ret;
+}
+
+int mc_server_set_playlist_cmd_received_cb(mc_server_h server, mc_server_playlist_cmd_received_cb callback, void *user_data)
+{
+ int ret = MEDIA_CONTROLLER_ERROR_NONE;
+ media_controller_server_s *mc_server = (media_controller_server_s *)server;
+
+ mc_retvm_if(mc_server == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
+ mc_retvm_if(callback == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "callback is NULL");
+
+ mc_server->play_playlist_reciever.callback = callback;
+ mc_server->play_playlist_reciever.user_data = user_data;
+
+ char *interface_name = mc_util_get_interface_name(MC_SERVER, mc_server->server_name);
+ ret = mc_ipc_register_listener(&mc_server->listeners, mc_server->dconn, interface_name, MC_DBUS_SIGNAL_NAME_PLAYBACK_PLAYLIST, __server_play_playlist_cmd_cb, (void *)&(mc_server->play_playlist_reciever));
+
+ MC_SAFE_FREE(interface_name);
+
+ return ret;
+}
+
+int mc_server_unset_playlist_cmd_received_cb(mc_server_h server)
+{
+ int ret = MEDIA_CONTROLLER_ERROR_NONE;
+ media_controller_server_s *mc_server = (media_controller_server_s *)server;
+
+ mc_retvm_if(mc_server == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
+
+ char *interface_name = mc_util_get_interface_name(MC_SERVER, mc_server->server_name);
+ ret = mc_ipc_unregister_listener(&mc_server->listeners, mc_server->dconn, interface_name, MC_DBUS_SIGNAL_NAME_PLAYBACK_PLAYLIST);
+
+ mc_server->play_playlist_reciever.callback = NULL;
+ mc_server->play_playlist_reciever.user_data = NULL;
+
+ MC_SAFE_FREE(interface_name);
+
+ return ret;
+}
+
+int mc_server_set_custom_cmd_received_cb(mc_server_h server, mc_server_custom_cmd_received_cb callback, void *user_data)
+{
+ int ret = MEDIA_CONTROLLER_ERROR_NONE;
+ media_controller_server_s *mc_server = (media_controller_server_s *)server;
+
+ mc_retvm_if(mc_server == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
+ mc_retvm_if(callback == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "callback is NULL");
+
mc_server->custom_cmd_reciever.callback = callback;
mc_server->custom_cmd_reciever.user_data = user_data;
char *interface_name = mc_util_get_interface_name(MC_SERVER, mc_server->server_name);
- ret = mc_ipc_register_listener(&mc_server->listeners, mc_server->dconn, interface_name, MC_DBUS_SIGNAL_NAME_CUSTOM_CMD, __server_custom_command_cb, (void *)&(mc_server->custom_cmd_reciever));
+ ret = mc_ipc_register_listener(&mc_server->listeners, mc_server->dconn, interface_name, MC_DBUS_SIGNAL_NAME_CUSTOM_CMD, __server_custom_cmd_cb, (void *)&(mc_server->custom_cmd_reciever));
MC_SAFE_FREE(interface_name);
return ret;
}
-int mc_server_unset_custom_command_received_cb(mc_server_h server)
+int mc_server_unset_custom_cmd_received_cb(mc_server_h server)
{
int ret = MEDIA_CONTROLLER_ERROR_NONE;
media_controller_server_s *mc_server = (media_controller_server_s *)server;
return ret;
}
-int mc_server_send_command_reply(mc_server_h server, const char *client_name, int result_code, bundle *data)
+int mc_server_send_cmd_reply(mc_server_h server, const char *client_name, const char *request_id, int result_code, bundle *data)
{
int ret = MEDIA_CONTROLLER_ERROR_NONE;
char *message = NULL;
mc_retvm_if(mc_server == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
mc_retvm_if(!MC_STRING_VALID(client_name), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "client_name is NULL");
+ mc_retvm_if(!MC_STRING_VALID(request_id), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "request_id is NULL");
ret = mc_util_bundle_to_string(data, &bundle_str);
mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "Error when make string from bundle");
message = g_strdup_printf("%s%s%d%s%s", mc_server->server_name, MC_STRING_DELIMITER, result_code, MC_STRING_DELIMITER, bundle_str);
- MC_SAFE_FREE(bundle_str);
+ MC_SAFE_G_FREE(bundle_str);
mc_retvm_if(message == NULL, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "Error when making message");
char *interface_name = mc_util_get_interface_name(MC_CLIENT, client_name);
- ret = mc_ipc_send_message(mc_server->dconn, NULL, interface_name, MC_DBUS_SIGNAL_NAME_CMD_REPLY, message, NULL);
+ ret = mc_ipc_send_reply(mc_server->dconn, NULL, interface_name, MC_DBUS_SIGNAL_NAME_CMD_REPLY, message, request_id);
if (ret != MEDIA_CONTROLLER_ERROR_NONE)
mc_error("Error mc_ipc_send_message [%d]", ret);
static char *g_server_name;
static mc_playback_states_e g_playback_state;
+static unsigned long long g_playback_position;
+static mc_shuffle_mode_e g_shuffle_mode;
+static mc_repeat_mode_e g_repeat_mode;
+
+typedef enum {
+ TEST_REQ_PB_ACT_CMD,
+ TEST_REQ_PB_POS_CMD,
+ TEST_REQ_SHUFFLE_CMD,
+ TEST_REQ_REPEAT_CMD,
+ TEST_REQ_CUSTOM_CMD,
+ TEST_REQ_MAX,
+} test_req_e;
+static char *g_request_id[TEST_REQ_MAX];
GMainLoop *mainloop = NULL;
mc_debug("[Client:%s] Command Reply (key1: %s)received from server[%s] result code[%d]", _client->client_name, value, server_name, result_code);
}
+void _mc_cmd_reply_received_cb(const char *server_name, const char *request_id, int result_code, bundle *data, void *user_data)
+{
+ char *value = NULL;
+ media_controller_client_s *_client = (media_controller_client_s *)g_mc_client;
+
+ mc_error("[No-Errror][Id:%s]", request_id);
+
+ unsigned int i = 0;
+ unsigned int found = 0;
+ for (i = 0; i < TEST_REQ_MAX; i++) {
+ if (strcmp(request_id, g_request_id[i]) == 0) {
+ found = 1;
+ break;
+ }
+ }
+ if (!found) {
+ mc_error("[Client:%s] Wrong request_id", _client->client_name, request_id);
+ }
+ if (strcmp(request_id, g_request_id[TEST_REQ_CUSTOM_CMD]) == 0) {
+ if (data)
+ bundle_get_str(data, "key1", &value);
+
+ mc_debug("[Client:%s] Custom Command Reply (key1: %s)received from server[%s] result code[%d]", _client->client_name, request_id, value, server_name, result_code);
+ } else {
+ mc_error("[Client:%s] Reply result code[%d] from server[%s]", _client->client_name, request_id, result_code, server_name);
+ }
+}
+
static gboolean _create()
{
g_print("== create \n");
- int ret;
+ int ret = MEDIA_CONTROLLER_ERROR_NONE;
ret = mc_client_create(&g_mc_client);
if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
static gboolean _foreach()
{
g_print("== create \n");
- int ret;
+ int ret = MEDIA_CONTROLLER_ERROR_NONE;
ret = mc_client_foreach_server(g_mc_client, _mc_activated_server_cb, NULL);
if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
return TRUE;
}
-static gboolean _set()
+static gboolean _set_callback()
{
- g_print("== set default callback \n");
int ret = TRUE;
+ mc_debug_fenter();
+
ret = mc_client_set_server_update_cb(g_mc_client, _mc_server_state_updated_cb, NULL);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- g_print("Fail to set param and initialize %d", ret);
- return FALSE;
- }
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, FALSE, "Fail to mc_client_set_server_update_cb [%d]", ret);
ret = mc_client_set_playback_update_cb(g_mc_client, _mc_playback_updated_cb, NULL);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- g_print("Fail to set param and initialize %d", ret);
- return FALSE;
- }
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, FALSE, "Fail to mc_client_set_playback_update_cb [%d]", ret);
ret = mc_client_set_metadata_update_cb(g_mc_client, _mc_metadata_updated_cb, NULL);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- g_print("Fail to set param and initialize %d", ret);
- return FALSE;
- }
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, FALSE, "Fail to mc_client_set_metadata_update_cb [%d]", ret);
ret = mc_client_set_shuffle_mode_update_cb(g_mc_client, _mc_shuffle_mode_updated_cb, NULL);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- g_print("Fail to set param and initialize %d", ret);
- return FALSE;
- }
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, FALSE, "Fail to mc_client_set_shuffle_mode_update_cb [%d]", ret);
ret = mc_client_set_repeat_mode_update_cb(g_mc_client, _mc_repeat_mode_updated_cb, NULL);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- g_print("Fail to set param and initialize %d", ret);
- return FALSE;
- }
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, FALSE, "Fail to mc_client_set_repeat_mode_update_cb [%d]", ret);
- g_print("==\n");
+ ret = mc_client_set_cmd_reply_received_cb(g_mc_client, _mc_cmd_reply_received_cb, NULL);
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, FALSE, "Fail to mc_client_set_reply_received_cb [%d]", ret);
+
+ mc_debug_fleave();
return ret;
}
-static gboolean _unset()
+static gboolean _unset_callback()
{
- g_print("== unset callback \n");
- int ret;
+ int ret = MEDIA_CONTROLLER_ERROR_NONE;
+
+ mc_debug_fenter();
ret = mc_client_unset_server_update_cb(g_mc_client);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- g_print("Fail to deinitialize %d", ret);
- return FALSE;
- }
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, FALSE, "Fail to mc_client_unset_server_update_cb [%d]", ret);
ret = mc_client_unset_playback_update_cb(g_mc_client);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- g_print("Fail to deinitialize %d", ret);
- return FALSE;
- }
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, FALSE, "Fail to mc_client_unset_playback_update_cb [%d]", ret);
ret = mc_client_unset_metadata_update_cb(g_mc_client);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- g_print("Fail to deinitialize %d", ret);
- return FALSE;
- }
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, FALSE, "Fail to mc_client_unset_metadata_update_cb [%d]", ret);
ret = mc_client_unset_shuffle_mode_update_cb(g_mc_client);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- g_print("Fail to deinitialize %d", ret);
- return FALSE;
- }
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, FALSE, "Fail to mc_client_unset_shuffle_mode_update_cb [%d]", ret);
ret = mc_client_unset_repeat_mode_update_cb(g_mc_client);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- g_print("Fail to deinitialize %d", ret);
- return FALSE;
- }
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, FALSE, "Fail to mc_client_unset_repeat_mode_update_cb [%d]", ret);
+
+ ret = mc_client_unset_cmd_reply_received_cb(g_mc_client);
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, FALSE, "Fail to mc_client_unset_reply_received_cb [%d]", ret);
- g_print("== success destroy \n");
+ mc_debug_fleave();
return TRUE;
}
static gboolean _get_info(int type)
{
- g_print("== get information \n");
- int ret;
+ int ret = MEDIA_CONTROLLER_ERROR_NONE;
mc_server_state_e server_state;
mc_playback_h playback;
mc_playback_states_e playback_state;
switch (type) {
case 1:
ret = mc_client_get_latest_server_info(g_mc_client, &g_server_name, &server_state);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- g_print("Fail to get latest server info");
- return FALSE;
- }
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, FALSE, "Fail to mc_client_get_latest_server_info [%d]", ret);
+
g_print("get server name: %s, state: %d", g_server_name, server_state);
+
break;
case 2:
ret = mc_client_get_server_playback_info(g_mc_client, g_server_name, &playback);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- g_print("Fail to get playback info");
- return FALSE;
- }
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, FALSE, "Fail to mc_client_get_server_playback_info [%d]", ret);
+
ret = mc_client_get_playback_state(playback, &playback_state);
if (ret != MEDIA_CONTROLLER_ERROR_NONE)
g_print("Fail to get playback state");
g_print("playback state: %d, position: %lld", playback_state, playback_position);
ret = mc_client_destroy_playback(playback);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- g_print("Fail to destroy playback");
- return FALSE;
- }
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, FALSE, "Fail to mc_client_destroy_playback [%d]", ret);
+
break;
case 3:
ret = mc_client_get_server_metadata(g_mc_client, g_server_name, &metadata);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- g_print("Fail to get metadata");
- return FALSE;
- }
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, FALSE, "Fail to mc_client_get_server_metadata [%d]", ret);
+
ret = mc_client_get_metadata(metadata, MC_META_MEDIA_TITLE, &metadata_value);
if (ret != MEDIA_CONTROLLER_ERROR_NONE)
g_print("Fail to get infot");
g_print("metadata title: %s", metadata_value);
- ret = mc_client_destroy_metadata(metadata);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- g_print("Fail to destroy metadata");
- return FALSE;
- }
free(metadata_value);
+
+ ret = mc_client_destroy_metadata(metadata);
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, FALSE, "Fail to mc_client_destroy_metadata [%d]", ret);
+
break;
case 4:
ret = mc_client_get_server_shuffle_mode(g_mc_client, g_server_name, &shuffle_mode);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- g_print("Fail to get infot");
- return FALSE;
- }
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, FALSE, "Fail to mc_client_get_server_shuffle_mode [%d]", ret);
+
g_print("shuffle mode: %d", shuffle_mode);
break;
case 5:
ret = mc_client_get_server_repeat_mode(g_mc_client, g_server_name, &repeate_mode);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- g_print("Fail to get infot");
- return FALSE;
- }
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, FALSE, "Fail to mc_client_get_server_repeat_mode [%d]", ret);
+
g_print("repeate mode: %d", repeate_mode);
break;
default:
return TRUE;
}
- g_print("== success get information \n");
+ mc_debug_fleave();
return TRUE;
}
static gboolean _send()
{
g_print("== send command to latest server \n");
- int ret;
+ int ret = MEDIA_CONTROLLER_ERROR_NONE;
+ mc_playback_action_e action = MC_PLAYBACK_ACTION_PLAY;
if (g_playback_state == MC_PLAYBACK_STATE_PLAYING)
g_playback_state = MC_PLAYBACK_STATE_STOPPED;
g_playback_state = MC_PLAYBACK_STATE_PLAYING;
ret = mc_client_send_playback_state_command(g_mc_client, g_server_name, g_playback_state);
if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- g_print("Fail to send playback state command %d", ret);
+ g_print("Fail to send playback state command [%d]", ret);
+ return FALSE;
+ }
+
+ ret = mc_client_send_playback_action_cmd(g_mc_client, g_server_name, action, &g_request_id[TEST_REQ_PB_ACT_CMD]);
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ g_print("Fail to send playback action command [%d]", ret);
+ return FALSE;
+ }
+
+ g_playback_position += 1000;
+ ret = mc_client_send_playback_position_cmd(g_mc_client, g_server_name, g_playback_position, &g_request_id[TEST_REQ_PB_POS_CMD]);
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ g_print("Fail to send playback position command [%d]", ret);
+ return FALSE;
+ }
+
+ if (g_shuffle_mode == MC_SHUFFLE_MODE_OFF)
+ g_shuffle_mode = MC_SHUFFLE_MODE_ON;
+ else
+ g_shuffle_mode = MC_SHUFFLE_MODE_OFF;
+ ret = mc_client_send_shuffle_mode_cmd(g_mc_client, g_server_name, g_shuffle_mode, &g_request_id[TEST_REQ_SHUFFLE_CMD]);
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ g_print("Fail to send shuffle mode command [%d]", ret);
+ return FALSE;
+ }
+
+ if (g_repeat_mode == MC_REPEAT_MODE_OFF)
+ g_repeat_mode = MC_REPEAT_MODE_ON;
+ else
+ g_repeat_mode = MC_REPEAT_MODE_OFF;
+
+ ret = mc_client_send_repeat_mode_cmd(g_mc_client, g_server_name, g_repeat_mode, &g_request_id[TEST_REQ_REPEAT_CMD]);
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ g_print("Fail to send shuffle mode command [%d]", ret);
return FALSE;
}
}
bundle_free(bundle_data);
+ bundle_data = bundle_create();
+ bundle_add_str(bundle_data, "key1", "val1_2");
+ bundle_add_str(bundle_data, "key2", "val2_2");
+ bundle_add_str(bundle_data, "key3", "val3_2");
+ bundle_add_str(bundle_data, "key4", "val4_2");
+
+ ret = mc_client_send_custom_cmd(g_mc_client, g_server_name, "Custom Command2", bundle_data, &g_request_id[TEST_REQ_CUSTOM_CMD]);
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ bundle_free(bundle_data);
+ mc_error("Fail to send custom command %d", ret);
+ return FALSE;
+ }
+ bundle_free(bundle_data);
+
+ unsigned int i = 0;
+ for (i = 0; i < TEST_REQ_MAX; i++)
+ mc_error("[No-Errror][%02u][Id:%s]", i, g_request_id[i]);
+
g_print("== success send command \n");
return TRUE;
static gboolean _destroy()
{
- g_print("== destroy \n");
- int ret;
+ int ret = MEDIA_CONTROLLER_ERROR_NONE;
+
+ mc_debug_fenter();
ret = mc_client_destroy(g_mc_client);
if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
return FALSE;
}
- g_print("== success destroy \n");
g_mc_client = NULL;
+
+ MC_SAFE_FREE(g_server_name);
+
+ mc_debug_fleave();
+
return TRUE;
}
else if (!strncmp(cmd, "2", len))
_foreach();
else if (!strncmp(cmd, "3", len))
- _set();
+ _set_callback();
else if (!strncmp(cmd, "4", len))
- _unset();
+ _unset_callback();
else if (!strncmp(cmd, "5", len))
g_menu_state = CURRENT_STATE_INFORMATION_GET_MENU;
else if (!strncmp(cmd, "6", len))
mc_playback_h playback = NULL;
char *str_val = NULL;
int idx = 0;
- mc_playback_states_e playback_state = MC_PLAYBACK_STATE_REWIND;
+ mc_playback_states_e playback_state = MC_PLAYBACK_STATE_REWINDING;
unsigned long long playback_position = 0;
/*Create Client*/
g_io_add_watch(stdin_channel, G_IO_IN, (GIOFunc)input, NULL);
g_playback_state = MC_PLAYBACK_STATE_PLAYING;
+ g_playback_position = 1000;
+ g_shuffle_mode = MC_SHUFFLE_MODE_OFF;
+ g_repeat_mode = MC_REPEAT_MODE_OFF;
mainloop = g_main_loop_new(NULL, FALSE);
#include <glib.h>
#include <glib/gprintf.h>
-#include <media_controller_client.h>
+#include <media_controller_server.h>
#include "media_controller_private.h"
-#define PACKAGE "media_controller_client_test"
-
/*===========================================================================================
| |
| LOCAL DEFINITIONS AND DECLARATIONS FOR MODULE |
void __playback_state_command_received_cb(const char *client_name, mc_playback_states_e state, void *user_data)
{
- media_controller_server_s *mc_server = (media_controller_server_s *)g_mc_server;
- mc_debug("[%s] recieved playback state:[%d] from [%s]", mc_server->server_name, state, client_name);
+ g_print("[%s] recieved playback state:[%d] from [%s]\n", client_name, state, client_name);
+}
+
+void __playback_action_received_cb(const char *client_name, const char *request_id, mc_playback_action_e action, void *user_data)
+{
+ int ret = 0;
+ g_print("[%s][%s] recieved playback action:[%d] from [%s]\n", client_name, request_id, action, client_name);
+
+ ret = mc_server_send_cmd_reply(g_mc_server, client_name, request_id, 0, NULL);
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE)
+ g_print("Fail to mc_server_send_command_reply\n");
+}
+
+void __playback_position_cmd_received_cb(const char *client_name, const char *request_id, unsigned long long position, void *user_data)
+{
+ int ret = 0;
+ g_print("[%s][%s] recieved playback position:[%llu] from [%s]\n", client_name, request_id, position, client_name);
+
+ ret = mc_server_send_cmd_reply(g_mc_server, client_name, request_id, 0, NULL);
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE)
+ g_print("Fail to mc_server_send_command_reply\n");
+}
+
+void __shuffle_mode_cmd_received_cb(const char *client_name, const char *request_id, mc_shuffle_mode_e shuffle_mode, void *user_data)
+{
+ int ret = 0;
+ g_print("[%s][%s] recieved shuffle mode:[%d] from [%s]\n", client_name, request_id, shuffle_mode, client_name);
+
+ ret = mc_server_send_cmd_reply(g_mc_server, client_name, request_id, 0, NULL);
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE)
+ g_print("Fail to mc_server_send_command_reply\n");
+}
+
+void __repeat_mode_cmd_received_cb(const char *client_name, const char *request_id, mc_repeat_mode_e repeat_mode, void *user_data)
+{
+ int ret = 0;
+
+ g_print("[%s][%s] recieved repeat mode:[%d] from [%s]\n", client_name, request_id, repeat_mode, client_name);
+ ret = mc_server_send_cmd_reply(g_mc_server, client_name, request_id, 0, NULL);
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE)
+ g_print("Fail to mc_server_send_command_reply\n");
}
void __custom_command_received_cb(const char *client_name, const char *command, bundle *data, void *user_data)
{
int ret = MEDIA_CONTROLLER_ERROR_NONE;
- media_controller_server_s *mc_server = (media_controller_server_s *)g_mc_server;
char *bundle_data = NULL;
char *get_value1 = NULL;
bundle_data = g_strdup_printf("%s, %s, %s, %s", get_value1, get_value2, get_value3, get_value4);
}
- mc_debug("[%s] recieved command:[%s] from [%s]", mc_server->server_name, command, client_name);
- mc_debug("[%s] recieved bundle:[%s] from [%s]", mc_server->server_name, bundle_data, client_name);
+ g_print("[%s] recieved command:[%s] from [%s]\n", client_name, command, client_name);
+ g_print("[%s] recieved bundle:[%s] from [%s]\n", client_name, bundle_data, client_name);
bundle *bundle_reply = bundle_create();
bundle_add_str(bundle_reply, "key1", "result1");
ret = mc_server_send_command_reply(g_mc_server, client_name, 0, bundle_reply);
if (ret != MEDIA_CONTROLLER_ERROR_NONE)
- mc_error("Fail to mc_server_send_command_reply");
+ g_print("Fail to mc_server_send_command_reply\n");
+
+ bundle_free(bundle_reply);
+ if (bundle_data != NULL)
+ g_free(bundle_data);
+}
+
+void __custom_cmd_received_cb(const char *client_name, const char *request_id, const char *command, bundle *data, void *user_data)
+{
+ int ret = MEDIA_CONTROLLER_ERROR_NONE;
+
+ char *bundle_data = NULL;
+ char *get_value1 = NULL;
+ char *get_value2 = NULL;
+ char *get_value3 = NULL;
+ char *get_value4 = NULL;
+
+ if (data) {
+ bundle_get_str(data, "key1", &get_value1);
+ bundle_get_str(data, "key2", &get_value2);
+ bundle_get_str(data, "key3", &get_value3);
+ bundle_get_str(data, "key4", &get_value4);
+
+ bundle_data = g_strdup_printf("%s, %s, %s, %s", get_value1, get_value2, get_value3, get_value4);
+ }
+
+ g_print("[%s] recieved request_id:[%s] command:[%s] from [%s]\n", client_name, request_id, command, client_name);
+ g_print("[%s] recieved bundle:[%s] from [%s]\n", client_name, bundle_data, client_name);
+
+ bundle *bundle_reply = bundle_create();
+ bundle_add_str(bundle_reply, "key1", "result1_2");
+ bundle_add_str(bundle_reply, "key2", "result2_2");
+ bundle_add_str(bundle_reply, "key3", "result3_2");
+ bundle_add_str(bundle_reply, "key4", "result4_2");
+
+ ret = mc_server_send_cmd_reply(g_mc_server, client_name, request_id, 0, bundle_reply);
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE)
+ g_print("Fail to mc_server_send_command_reply\n");
bundle_free(bundle_reply);
if (bundle_data != NULL)
ret = mc_server_set_playback_state_command_received_cb(g_mc_server, __playback_state_command_received_cb, NULL);
if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- g_print("Fail to create media contoller server");
+ g_print("Fail to set playback_state_command_reciveed_cb");
+ return FALSE;
+ }
+
+ ret = mc_server_set_playback_action_cmd_received_cb(g_mc_server, __playback_action_received_cb, NULL);
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ g_print("Fail to set mc_server_set_playback_action_cmd_received_cb");
+ return FALSE;
+ }
+
+ ret = mc_server_set_playback_position_cmd_received_cb(g_mc_server, __playback_position_cmd_received_cb, NULL);
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ g_print("Fail to set mc_server_set_playback_position_cmd_received_cb");
+ return FALSE;
+ }
+
+ ret = mc_server_set_shuffle_mode_cmd_received_cb(g_mc_server, __shuffle_mode_cmd_received_cb, NULL);
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ g_print("Fail to set mc_server_set_shuffle_mode_cmd_received_cb");
+ return FALSE;
+ }
+
+ ret = mc_server_set_repeat_mode_cmd_received_cb(g_mc_server, __repeat_mode_cmd_received_cb, NULL);
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ g_print("Fail to set mc_server_set_repeat_mode_cmd_received_cb");
return FALSE;
}
ret = mc_server_set_custom_command_received_cb(g_mc_server, __custom_command_received_cb, NULL);
if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- g_print("Fail to create media contoller server");
+ g_print("Fail to set mc_server_set_custom_command_received_cb");
+ return FALSE;
+ }
+
+ ret = mc_server_set_custom_cmd_received_cb(g_mc_server, __custom_cmd_received_cb, NULL);
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ g_print("Fail to set mc_server_set_custom_cmd_received_cb");
return FALSE;
}
static gboolean _set_info(int type, char *cmd)
{
- g_print("== get information \n");
int ret = MEDIA_CONTROLLER_ERROR_NONE;
int playback_state = 0;
unsigned long long playback_position;
char *metadata = NULL;
+ g_print("== get information [%d]\n", type);
+
switch (type) {
case CURRENT_STATE_SET_PLAYBACK_STATE:
playback_state = atoi(cmd);
}
g_print("set state: %d", playback_state);
break;
+
case CURRENT_STATE_SET_PLAYBACK_POSITION:
playback_position = strtoull(cmd, NULL, 10);
ret = mc_server_set_playback_position(g_mc_server, playback_position);
g_metadata_type = atoi(cmd);
g_print("set metadata name: %d", g_metadata_type);
break;
+
case CURRENT_STATE_SET_METADATA_VALUE:
metadata = strdup(cmd);
ret = mc_server_set_metadata(g_mc_server, g_metadata_type, metadata);
_destroy();
else if (!strncmp(cmd, "0", len))
quit();
+ else
+ g_print("wrong command [%s]\n", cmd);
} else {
g_print("wrong command\n");
}
projects / platform / core / api / media-controller.git / commitdiff