#define MC_DBUS_SIGNAL_NAME_SERVER_STATE "server_state"
#define MC_DBUS_SIGNAL_NAME_PLAY_BACK "playback"
#define MC_DBUS_SIGNAL_NAME_METADATA "metadata"
-#define MC_DBUS_SIGNAL_NAME_PLAYBACK_SHUFFLE "playback_shuffle"
-#define MC_DBUS_SIGNAL_NAME_PLAYBACK_REPEAT "playback_repeat"
-#define MC_DBUS_SIGNAL_NAME_PLAYBACK_STATE_CMD "playback_state_command"
-#define MC_DBUS_SIGNAL_NAME_CUSTOM_CMD "custom_command"
-#define MC_DBUS_SIGNAL_NAME_CMD_REPLY "command_reply"
-
-#define MC_COMMAND_PLAYBACKSTATE "_playback_command_"
-#define MC_COMMAND_CUSTOM "_custom_command_"
+#define MC_DBUS_SIGNAL_NAME_PLAYBACK_SHUFFLE "shuffle"
+#define MC_DBUS_SIGNAL_NAME_PLAYBACK_REPEAT "repeat"
+#define MC_DBUS_SIGNAL_NAME_PLAYBACK_STATE_CMD "pb_state_cmd"
+#define MC_DBUS_SIGNAL_NAME_PLAYBACK_POS_CMD "pb_position_cmd"
+#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_COMMAND_PLAYBACKSTATE "_pb_state_cmd_"
+#define MC_COMMAND_PLAYBACKPOSITION "_pb_position_cmd_"
+#define MC_COMMAND_SHUFFLE "_shuffle_cmd_"
+#define MC_COMMAND_REPEAT "_repeat_cmd_"
+#define MC_COMMAND_CUSTOM "_custom_cmd_"
#define DEFAULT_USER_UID 5001 /* owner */
media_controller_metadata_s *metadata;
media_controller_receiver_s playback_state_reciever;
+ media_controller_receiver_s playback_position_reciever;
+ media_controller_receiver_s shuffle_mode_reciever;
+ media_controller_receiver_s repeat_mode_reciever;
media_controller_receiver_s custom_cmd_reciever;
} media_controller_server_s;
int mc_util_make_filter_interface_name(const char *prefix, const char *filter, char **interface_name);
int mc_util_set_command_availabe(const char *name, const char *command_type, const char *command);
int mc_util_get_command_availabe(const char *name, const char *command_type, const char *command);
+int mc_safe_strtoi(const char *buffer, int *value);
+int mc_safe_strtoull(const char *buffer, unsigned long long *value);
/* for d-bus IPC */
int mc_ipc_get_dbus_connection(GDBusConnection **conn, int *dref_count);
return ret;
}
+int mc_client_send_playback_position_command(mc_client_h client, const char *server_name, unsigned long long position)
+{
+ int ret = MEDIA_CONTROLLER_ERROR_NONE;
+ char *message = NULL;
+ media_controller_client_s *mc_client = (media_controller_client_s *)client;
+ bool exist_server = FALSE;
+
+ 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_db_check_server_table_exist(mc_client->db_handle, server_name, &exist_server);
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "Error mc_db_check_server_table_exist [%d]", ret);
+ mc_retvm_if(exist_server == FALSE, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Error Invalid server_name");
+
+ ret = mc_util_set_command_availabe(mc_client->client_name, MC_COMMAND_PLAYBACKPOSITION, NULL);
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "Error mc_util_set_command_availabe [%d]", ret);
+
+ 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);
+
+ char *interface_name = mc_util_get_interface_name(MC_SERVER, server_name);
+ ret = mc_ipc_send_message(mc_client->dconn, NULL, interface_name, MC_DBUS_SIGNAL_NAME_PLAYBACK_POS_CMD, message, 0);
+ 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_client_send_shuffle_mode_command(mc_client_h client, const char *server_name, mc_shuffle_mode_e shuffle_mode)
+{
+ int ret = MEDIA_CONTROLLER_ERROR_NONE;
+ char *message = NULL;
+ media_controller_client_s *mc_client = (media_controller_client_s *)client;
+ bool exist_server = FALSE;
+
+ 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");
+
+ ret = mc_db_check_server_table_exist(mc_client->db_handle, server_name, &exist_server);
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "Error mc_db_check_server_table_exist [%d]", ret);
+ mc_retvm_if(exist_server == FALSE, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Error Invalid server_name");
+
+ ret = mc_util_set_command_availabe(mc_client->client_name, MC_COMMAND_SHUFFLE, NULL);
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "Error mc_util_set_command_availabe [%d]", ret);
+
+ 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);
+
+ char *interface_name = mc_util_get_interface_name(MC_SERVER, server_name);
+ ret = mc_ipc_send_message(mc_client->dconn, NULL, interface_name, MC_DBUS_SIGNAL_NAME_SHUFFLE_CMD, message, 0);
+ 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_client_send_repeat_mode_command(mc_client_h client, const char *server_name, mc_repeat_mode_e repeat_mode)
+{
+ int ret = MEDIA_CONTROLLER_ERROR_NONE;
+ char *message = NULL;
+ media_controller_client_s *mc_client = (media_controller_client_s *)client;
+ bool exist_server = FALSE;
+
+ 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_OFF)), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "repeat is invalid");
+
+ ret = mc_db_check_server_table_exist(mc_client->db_handle, server_name, &exist_server);
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "Error mc_db_check_server_table_exist [%d]", ret);
+ mc_retvm_if(exist_server == FALSE, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Error Invalid server_name");
+
+ ret = mc_util_set_command_availabe(mc_client->client_name, MC_COMMAND_REPEAT, NULL);
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "Error mc_util_set_command_availabe [%d]", ret);
+
+ 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);
+
+ char *interface_name = mc_util_get_interface_name(MC_SERVER, server_name);
+ ret = mc_ipc_send_message(mc_client->dconn, NULL, interface_name, MC_DBUS_SIGNAL_NAME_REPEAT_CMD, message, 0);
+ 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_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;
if (mc_util_get_command_availabe(params[0], MC_COMMAND_PLAYBACKSTATE, NULL) != MEDIA_CONTROLLER_ERROR_NONE) {
mc_error("Error permission denied");
+ g_strfreev(params);
+ return ;
+ }
+
+ int value = 0;
+ if (mc_safe_strtoi(params[1], &value) != MEDIA_CONTROLLER_ERROR_NONE) {
+ mc_error("Error get recieved value");
+ g_strfreev(params);
+ return ;
+ }
+
+ callback(params[0], (mc_playback_states_e)value, receiver->user_data);
+
+ g_strfreev(params);
+}
+
+static void __server_playback_position_command_cb(const char *interface_name, const char *signal_name, const char *message, int size, void *user_data)
+{
+ gchar **params = NULL;
+ media_controller_receiver_s *receiver = (media_controller_receiver_s *)user_data;
+ mc_retm_if(receiver == NULL, "reciever is NULL");
+ mc_retm_if(message == NULL, "message is NULL");
+
+ mc_server_playback_position_command_received_cb callback = receiver->callback;
+ mc_retm_if(receiver->callback == NULL, "playback_position_command_received_cb is NULL");
+
+ mc_debug("__server_playback_state_cb(%s, %s, %s, %d, %p)", interface_name, signal_name, message, size, user_data);
+
+ params = g_strsplit(message, MC_STRING_DELIMITER, 0);
+ mc_retm_if(params == NULL, "invalid playback state command");
+
+ if (mc_util_get_command_availabe(params[0], MC_COMMAND_PLAYBACKPOSITION, NULL) != MEDIA_CONTROLLER_ERROR_NONE) {
+ mc_error("Error permission denied");
+ g_strfreev(params);
+ return ;
+ }
+
+ unsigned long long value = 0;
+ if (mc_safe_strtoull(params[1], &value) != MEDIA_CONTROLLER_ERROR_NONE) {
+ mc_error("Error get recieved value");
+ g_strfreev(params);
+ return ;
+ }
+
+ callback(params[0], value, receiver->user_data);
+
+ g_strfreev(params);
+}
+
+static void __server_shuffle_mode_command_cb(const char *interface_name, const char *signal_name, const char *message, int size, void *user_data)
+{
+ gchar **params = NULL;
+ media_controller_receiver_s *receiver = (media_controller_receiver_s *)user_data;
+ mc_retm_if(receiver == NULL, "reciever is NULL");
+ mc_retm_if(message == NULL, "message is NULL");
+
+ mc_server_shuffle_mode_command_received_cb callback = receiver->callback;
+ mc_retm_if(receiver->callback == NULL, "shuffle_mode_command_received_cb is NULL");
+
+ mc_debug("__server_playback_state_cb(%s, %s, %s, %d, %p)", interface_name, signal_name, message, size, user_data);
+
+ params = g_strsplit(message, MC_STRING_DELIMITER, 0);
+ mc_retm_if(params == NULL, "invalid playback state command");
+
+ if (mc_util_get_command_availabe(params[0], MC_COMMAND_SHUFFLE, NULL) != MEDIA_CONTROLLER_ERROR_NONE) {
+ mc_error("Error permission denied");
+ g_strfreev(params);
+ return ;
+ }
+
+ int value = 0;
+ if (mc_safe_strtoi(params[1], &value) != MEDIA_CONTROLLER_ERROR_NONE) {
+ mc_error("Error get recieved value");
+ g_strfreev(params);
+ return ;
+ }
+
+ callback(params[0], (mc_shuffle_mode_e)value, receiver->user_data);
+
+ g_strfreev(params);
+}
+
+static void __server_repeat_mode_command_cb(const char *interface_name, const char *signal_name, const char *message, int size, void *user_data)
+{
+ gchar **params = NULL;
+ media_controller_receiver_s *receiver = (media_controller_receiver_s *)user_data;
+ mc_retm_if(receiver == NULL, "reciever is NULL");
+ mc_retm_if(message == NULL, "message is NULL");
+
+ mc_server_repeat_mode_command_received_cb callback = receiver->callback;
+ mc_retm_if(receiver->callback == NULL, "repeat_mode_command_received_cb is NULL");
+
+ mc_debug("__server_playback_state_cb(%s, %s, %s, %d, %p)", interface_name, signal_name, message, size, user_data);
+
+ params = g_strsplit(message, MC_STRING_DELIMITER, 0);
+ mc_retm_if(params == NULL, "invalid playback state command");
+
+ if (mc_util_get_command_availabe(params[0], MC_COMMAND_REPEAT, NULL) != MEDIA_CONTROLLER_ERROR_NONE) {
+ mc_error("Error permission denied");
+ g_strfreev(params);
+ return ;
+ }
+
+ int value = 0;
+ if (mc_safe_strtoi(params[1], &value) != MEDIA_CONTROLLER_ERROR_NONE) {
+ mc_error("Error get recieved value");
+ g_strfreev(params);
return ;
}
- callback(params[0], (mc_playback_states_e)atoi(params[1]), receiver->user_data);
+ callback(params[0], (mc_repeat_mode_e)value, receiver->user_data);
g_strfreev(params);
}
return ret;
}
+int mc_server_set_playback_position_command_received_cb(mc_server_h server, mc_server_playback_position_command_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_command_cb, (void *)&(mc_server->playback_position_reciever));
+
+ MC_SAFE_FREE(interface_name);
+
+ return ret;
+}
+
+int mc_server_unset_playback_position_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_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_command_received_cb(mc_server_h server, mc_server_shuffle_mode_command_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_command_cb, (void *)&(mc_server->shuffle_mode_reciever));
+
+ MC_SAFE_FREE(interface_name);
+
+ return ret;
+}
+
+int mc_server_unset_shuffle_mode_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_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_command_received_cb(mc_server_h server, mc_server_repeat_mode_command_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_command_cb, (void *)&(mc_server->repeat_mode_reciever));
+
+ MC_SAFE_FREE(interface_name);
+
+ return ret;
+}
+
+int mc_server_unset_repeat_mode_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_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;
*/
#include <aul.h>
+#include <errno.h>
+#include <limits.h>
+#include <stdlib.h>
#include "media_controller_private.h"
+//#define UNIT_TEST /* for testsuite */
#define MAX_NAME_LENGTH 255
static void _mc_util_check_valid_name(const char *name, char **valid_name)
return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;
}
if (AUL_R_OK != aul_app_get_appid_bypid(pid, temp, sizeof(temp))) {
+#ifdef UNIT_TEST
+ mc_error("Fix the name of the unit-tests!");
+ *name = g_strdup("org.tizen.testsuites");
+ return MEDIA_CONTROLLER_ERROR_NONE;
+#else
mc_error("Error failed to get appid!");
return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;
+#endif
}
*name = g_strdup(temp);
return ret;
}
+
+int mc_safe_strtoi(const char *buffer, int *value)
+{
+ char *end = NULL;
+ errno = 0;
+ mc_retvm_if(buffer == NULL || value == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "invalid parameter");
+
+ const long sl = strtol(buffer, &end, 10);
+
+ mc_retvm_if(end == buffer, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "not a decimal number");
+ mc_retvm_if('\0' != *end, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "extra characters at end of input: %s", end);
+ mc_retvm_if((LONG_MIN == sl || LONG_MAX == sl) && (ERANGE == errno), MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "out of range of type long");
+ mc_retvm_if(sl > INT_MAX, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "greater than INT_MAX");
+ mc_retvm_if(sl < INT_MIN, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "smaller than INT_MIN");
+
+ *value = (int)sl;
+
+ return MEDIA_CONTROLLER_ERROR_NONE;
+}
+
+int mc_safe_strtoull(const char *buffer, unsigned long long *value)
+{
+ char *end = NULL;
+ errno = 0;
+ mc_retvm_if(buffer == NULL || value == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "invalid parameter");
+
+ const unsigned long long ull = strtoull(buffer, &end, 10);
+
+ mc_retvm_if(end == buffer, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "not a decimal number");
+ mc_retvm_if('\0' != *end, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "extra characters at end of input: %s", end);
+ mc_retvm_if((ULLONG_MAX == ull) && (ERANGE == errno), MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "out of range of type long");
+
+ *value = (unsigned long long)ull;
+
+ return MEDIA_CONTROLLER_ERROR_NONE;
+}
mc_list_data_set_t *_data = (mc_list_data_set_t *)data;
mc_list_user_data *_user_data = (mc_list_user_data *)user_data;
mc_comm_msg_s *_message = (mc_comm_msg_s *)_user_data->message;
+
if (_data->pid == _message->pid) {
if (_data->s_data != NULL) {
unsigned int i = 0;
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;
GMainLoop *mainloop = NULL;
return FALSE;
}
+ g_playback_position += 1000;
+ ret = mc_client_send_playback_position_command(g_mc_client, g_server_name, g_playback_position);
+ 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_command(g_mc_client, g_server_name, g_shuffle_mode);
+ 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_shuffle_mode_command(g_mc_client, g_server_name, g_repeat_mode);
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ g_print("Fail to send shuffle mode command %d", ret);
+ return FALSE;
+ }
+
struct timespec reqtime;
reqtime.tv_sec = 0;
reqtime.tv_nsec = 500000000;
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);
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);
+ mc_debug("[%s] recieved playback state:[%d] from [%s]", client_name, state, client_name);
+}
+
+void __playback_position_command_received_cb(const char *client_name, unsigned long long position, void *user_data)
+{
+ mc_debug("[%s] recieved playback position:[%llu] from [%s]", client_name, position, client_name);
+}
+
+void __shuffle_mode_command_received_cb(const char *client_name, mc_shuffle_mode_e shuffle_mode, void *user_data)
+{
+ mc_debug("[%s] recieved shuffle mode:[%d] from [%s]", client_name, shuffle_mode, client_name);
+}
+
+void __repeat_mode_command_received_cb(const char *client_name, mc_repeat_mode_e repeat_mode, void *user_data)
+{
+ mc_debug("[%s] recieved repeat mode:[%d] from [%s]", client_name, repeat_mode, client_name);
}
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);
+ mc_debug("[%s] recieved command:[%s] from [%s]", client_name, command, client_name);
+ mc_debug("[%s] recieved bundle:[%s] from [%s]", client_name, bundle_data, client_name);
bundle *bundle_reply = bundle_create();
bundle_add_str(bundle_reply, "key1", "result1");
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_position_command_received_cb(g_mc_server, __playback_position_command_received_cb, NULL);
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ g_print("Fail to set playback_position_command_reciveed_cb");
+ return FALSE;
+ }
+
+ ret = mc_server_set_shuffle_mode_command_received_cb(g_mc_server, __shuffle_mode_command_received_cb, NULL);
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ g_print("Fail to set shuffle_mode_command_reciveed_cb");
+ return FALSE;
+ }
+
+ ret = mc_server_set_repeat_mode_command_received_cb(g_mc_server, __repeat_mode_command_received_cb, NULL);
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ g_print("Fail to set repeat_mode_command_reciveed_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 custom_command_reciveed_cb");
return FALSE;
}
projects / platform / core / api / media-controller.git / commitdiff