Just rename enum

Change-Id: Ieea3bb97cd6f2b7b66eb27fff7daaf886b54670a

diff --git a/include/media_controller_private.h b/include/media_controller_private.h
index 6c475e039ef5146a84e1709111946fe5e9823eba..8656e12332f0a0122435a009ff3f1712b5ad6b20 100755 (executable)
--- a/include/media_controller_private.h
+++ b/include/media_controller_private.h
@@ -274,6 +274,22 @@ typedef struct {
        unsigned long long supported;
 } media_controller_ability_s;
 
+typedef enum {
+       MC_CLIENT_EVENT_SERVER_STATE            = MC_SUBSCRIPTION_TYPE_SERVER_STATE,
+       MC_CLIENT_EVENT_PLAYBACK_INFO   = MC_SUBSCRIPTION_TYPE_PLAYBACK,
+       MC_CLIENT_EVENT_METADATA                = MC_SUBSCRIPTION_TYPE_METADATA,
+       MC_CLIENT_EVENT_SHUFFLE                 = MC_SUBSCRIPTION_TYPE_SHUFFLE_MODE,
+       MC_CLIENT_EVENT_REPEAT                  = MC_SUBSCRIPTION_TYPE_REPEAT_MODE,
+       MC_CLIENT_EVENT_PLAYLIST                        = MC_SUBSCRIPTION_TYPE_PLAYLIST,
+       MC_CLIENT_EVENT_PLAYBACK_ABILITY        = MC_SUBSCRIPTION_TYPE_PLAYBACK_ABILITY,
+       MC_CLIENT_EVENT_SHUFFLE_ABILITY = MC_SUBSCRIPTION_TYPE_SHUFFLE_ABILITY,
+       MC_CLIENT_EVENT_REPEAT_ABILITY  = MC_SUBSCRIPTION_TYPE_REPEAT_ABILITY,
+       MC_CLIENT_EVENT_CMD_REPLY,
+       MC_CLIENT_EVENT_CLIENT_CUSTOM,  //from client to server
+       MC_CLIENT_EVENT_SERVER_CUSTOM,  //from server to client
+       MC_CLIENT_EVENT_MAX,
+} mc_client_receive_event_e;
+
 typedef struct {
        char *server_name;
        void* db_handle;
@@ -302,22 +318,6 @@ typedef struct {
        media_controller_receiver_s event_reply_receiver;
 } media_controller_server_s;
 
-typedef enum {
-       MC_EVENT_SERVER_STATE           = MC_SUBSCRIPTION_TYPE_SERVER_STATE,
-       MC_EVENT_PLAYBACK_INFO  = MC_SUBSCRIPTION_TYPE_PLAYBACK,
-       MC_EVENT_METADATA               = MC_SUBSCRIPTION_TYPE_METADATA,
-       MC_EVENT_SHUFFLE                        = MC_SUBSCRIPTION_TYPE_SHUFFLE_MODE,
-       MC_EVENT_REPEAT                 = MC_SUBSCRIPTION_TYPE_REPEAT_MODE,
-       MC_EVENT_PLAYLIST                       = MC_SUBSCRIPTION_TYPE_PLAYLIST,
-       MC_EVENT_PLAYBACK_ABILITY       = MC_SUBSCRIPTION_TYPE_PLAYBACK_ABILITY,
-       MC_EVENT_SHUFFLE_ABILITY        = MC_SUBSCRIPTION_TYPE_SHUFFLE_ABILITY,
-       MC_EVENT_REPEAT_ABILITY = MC_SUBSCRIPTION_TYPE_REPEAT_ABILITY,
-       MC_EVENT_CMD_REPLY,
-       MC_EVENT_CLIENT_CUSTOM, //from client to server
-       MC_EVENT_SERVER_CUSTOM, //from server to client
-       MC_EVENT_MAX,
-} mc_client_receive_event_e;
-
 typedef struct {
        char            *client_name;
        void            *db_handle;
@@ -327,7 +327,7 @@ typedef struct {
 
        GList *listeners;
 
-       media_controller_receiver_s updated_cb[MC_EVENT_MAX];
+       media_controller_receiver_s updated_cb[MC_CLIENT_EVENT_MAX];
 } media_controller_client_s;
 
 typedef struct {

diff --git a/src/media_controller_client.c b/src/media_controller_client.c
index 5ed831f4dc3e65caddab9767b5e784f633ec4b34..dafbe578a522078a03e9c661e7e9abdf4ac5b5e0 100755 (executable)
--- a/src/media_controller_client.c
+++ b/src/media_controller_client.c
@@ -38,7 +38,7 @@ typedef struct {
        mc_signal_received_cb cb_func;
 } mc_cb_event_s;
 
-mc_cb_event_s cb_event[MC_EVENT_MAX] = {
+mc_cb_event_s cb_event[MC_CLIENT_EVENT_MAX] = {
        {MC_DBUS_SIGNAL_NAME_SERVER_STATE,              __client_server_cb},
        {MC_DBUS_SIGNAL_NAME_PLAY_BACK,                 __client_playback_cb},
        {MC_DBUS_SIGNAL_NAME_METADATA,                  __client_metadata_cb},
@@ -117,7 +117,7 @@ static void __client_metadata_cb(const char *interface_name, const char *signal_
        media_controller_client_s *mc_client = (media_controller_client_s *)user_data;
        mc_retm_if(mc_client == NULL, "mc_client is NULL");
 
-       mc_metadata_updated_cb callback = (mc_metadata_updated_cb)mc_client->updated_cb[MC_EVENT_METADATA].callback;
+       mc_metadata_updated_cb callback = (mc_metadata_updated_cb)mc_client->updated_cb[MC_CLIENT_EVENT_METADATA].callback;
        mc_retm_if(callback == NULL, "metadata_cb is NULL");
        mc_retm_if(message == NULL, "message is NULL");
 
@@ -127,7 +127,7 @@ static void __client_metadata_cb(const char *interface_name, const char *signal_
        if (ret != MEDIA_CONTROLLER_ERROR_NONE)
                mc_error("Fail to mc_db_get_metadata_info");
 
-       callback(message, metadata, mc_client->updated_cb[MC_EVENT_METADATA].user_data);
+       callback(message, metadata, mc_client->updated_cb[MC_CLIENT_EVENT_METADATA].user_data);
 
        mc_metadata_destroy(metadata);
 }
@@ -320,7 +320,7 @@ static void __client_playback_ability_cb(const char *interface_name, const char
        media_controller_client_s *mc_client = (media_controller_client_s *)user_data;
        mc_retm_if(mc_client == NULL, "mc_client is NULL");
 
-       mc_playback_ability_updated_cb callback = (mc_playback_ability_updated_cb)mc_client->updated_cb[MC_EVENT_PLAYBACK_ABILITY].callback;
+       mc_playback_ability_updated_cb callback = (mc_playback_ability_updated_cb)mc_client->updated_cb[MC_CLIENT_EVENT_PLAYBACK_ABILITY].callback;
        mc_retm_if(callback == NULL, "metadata_cb is NULL");
        mc_retm_if(message == NULL, "message is NULL");
 
@@ -330,7 +330,7 @@ static void __client_playback_ability_cb(const char *interface_name, const char
        if (ret != MEDIA_CONTROLLER_ERROR_NONE)
                mc_error("Fail to mc_db_get_pb_action_ability");
 
-       callback(message, ability, mc_client->updated_cb[MC_EVENT_PLAYBACK_ABILITY].user_data);
+       callback(message, ability, mc_client->updated_cb[MC_CLIENT_EVENT_PLAYBACK_ABILITY].user_data);
 
        mc_playback_ability_destroy(ability);
 }
@@ -644,20 +644,20 @@ static int __mc_client_set_updated_cb(mc_client_h client, mc_client_receive_even
 
        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(((event < MC_EVENT_SERVER_STATE) || (event >= MC_EVENT_MAX)) , MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid event [%d]", event);
+       mc_retvm_if(((event < MC_CLIENT_EVENT_SERVER_STATE) || (event >= MC_CLIENT_EVENT_MAX)) , MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid event [%d]", event);
        mc_retvm_if(mc_client->updated_cb[event].callback != NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "callback is already set [%d]", event);
 
        mc_client->updated_cb[event].callback = callback;
        mc_client->updated_cb[event].user_data = user_data;
 
-       if ((event == MC_EVENT_CMD_REPLY) || (event == MC_EVENT_SERVER_CUSTOM)) {
+       if ((event == MC_CLIENT_EVENT_CMD_REPLY) || (event == MC_CLIENT_EVENT_SERVER_CUSTOM)) {
                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, cb_event[event].signal_name,
                                                cb_event[event].cb_func, (void *)&(mc_client->updated_cb[event]));
 
                MC_SAFE_FREE(interface_name);
 
-       } else if ((event == MC_EVENT_METADATA) || event == MC_EVENT_PLAYBACK_ABILITY) {
+       } else if ((event == MC_CLIENT_EVENT_METADATA) || event == MC_CLIENT_EVENT_PLAYBACK_ABILITY) {
                ret = mc_ipc_register_listener(&mc_client->listeners, mc_client->dconn, MC_DBUS_UPDATE_INTERFACE, cb_event[event].signal_name,
                                                cb_event[event].cb_func, (void *)(mc_client));
        } else {
@@ -675,9 +675,9 @@ static int __mc_client_unset_updated_cb(mc_client_h client, mc_client_receive_ev
        char *interface_name = NULL;
 
        mc_retvm_if(mc_client == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
-       mc_retvm_if(((event < MC_EVENT_SERVER_STATE) || (event >= MC_EVENT_MAX)) , MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid event [%d]", event);
+       mc_retvm_if(((event < MC_CLIENT_EVENT_SERVER_STATE) || (event >= MC_CLIENT_EVENT_MAX)) , MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid event [%d]", event);
 
-       if ((event == MC_EVENT_CMD_REPLY) || (event == MC_EVENT_SERVER_CUSTOM)) {
+       if ((event == MC_CLIENT_EVENT_CMD_REPLY) || (event == MC_CLIENT_EVENT_SERVER_CUSTOM)) {
                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, cb_event[event].signal_name);
@@ -698,170 +698,170 @@ static int __mc_client_unset_updated_cb(mc_client_h client, mc_client_receive_ev
 
 int mc_client_set_server_update_cb(mc_client_h client, mc_server_state_updated_cb callback, void *user_data)
 {
-       return __mc_client_set_updated_cb(client, MC_EVENT_SERVER_STATE, callback, user_data);
+       return __mc_client_set_updated_cb(client, MC_CLIENT_EVENT_SERVER_STATE, callback, user_data);
 }
 
 int mc_client_unset_server_update_cb(mc_client_h client)
 {
-       return __mc_client_unset_updated_cb(client, MC_EVENT_SERVER_STATE);
+       return __mc_client_unset_updated_cb(client, MC_CLIENT_EVENT_SERVER_STATE);
 }
 
 int mc_client_set_playback_update_cb(mc_client_h client, mc_playback_updated_cb callback, void *user_data)
 {
-       return __mc_client_set_updated_cb(client, MC_EVENT_PLAYBACK_INFO, callback, user_data);
+       return __mc_client_set_updated_cb(client, MC_CLIENT_EVENT_PLAYBACK_INFO, callback, user_data);
 }
 
 int mc_client_unset_playback_update_cb(mc_client_h client)
 {
-       return __mc_client_unset_updated_cb(client, MC_EVENT_PLAYBACK_INFO);
+       return __mc_client_unset_updated_cb(client, MC_CLIENT_EVENT_PLAYBACK_INFO);
 }
 
 int mc_client_set_metadata_update_cb(mc_client_h client, mc_metadata_updated_cb callback, void *user_data)
 {
        mc_warning("DEPRECATION WARNING: mc_client_set_metadata_update_cb() is deprecated and will be removed from next release. Use mc_client_set_metadata_updated_cb() instead.");
 
-       return __mc_client_set_updated_cb(client, MC_EVENT_METADATA, callback, user_data);
+       return __mc_client_set_updated_cb(client, MC_CLIENT_EVENT_METADATA, callback, user_data);
 }
 
 int mc_client_unset_metadata_update_cb(mc_client_h client)
 {
-       return __mc_client_unset_updated_cb(client, MC_EVENT_METADATA);
+       return __mc_client_unset_updated_cb(client, MC_CLIENT_EVENT_METADATA);
 }
 
 int mc_client_set_shuffle_mode_update_cb(mc_client_h client, mc_shuffle_mode_changed_cb callback, void *user_data)
 {
        mc_warning("DEPRECATION WARNING: mc_client_set_shuffle_mode_update_cb() is deprecated and will be removed from next release. Use mc_client_set_shuffle_mode_updated_cb() instead.");
 
-       return __mc_client_set_updated_cb(client, MC_EVENT_SHUFFLE, callback, user_data);
+       return __mc_client_set_updated_cb(client, MC_CLIENT_EVENT_SHUFFLE, callback, user_data);
 }
 
 int mc_client_unset_shuffle_mode_update_cb(mc_client_h client)
 {
        mc_warning("DEPRECATION WARNING: mc_client_unset_shuffle_mode_update_cb() is deprecated and will be removed from next release. Use mc_client_unset_shuffle_mode_updated_cb() instead.");
 
-       return __mc_client_unset_updated_cb(client, MC_EVENT_SHUFFLE);
+       return __mc_client_unset_updated_cb(client, MC_CLIENT_EVENT_SHUFFLE);
 }
 int mc_client_set_repeat_mode_update_cb(mc_client_h client, mc_repeat_mode_changed_cb callback, void *user_data)
 {
        mc_warning("DEPRECATION WARNING: mc_client_set_repeat_mode_update_cb() is deprecated and will be removed from next release. Use mc_client_set_repeat_mode_updated_cb() instead.");
 
-       return __mc_client_set_updated_cb(client, MC_EVENT_REPEAT, callback, user_data);
+       return __mc_client_set_updated_cb(client, MC_CLIENT_EVENT_REPEAT, callback, user_data);
 }
 
 int mc_client_unset_repeat_mode_update_cb(mc_client_h client)
 {
        mc_warning("DEPRECATION WARNING: mc_client_unset_repeat_mode_update_cb() is deprecated and will be removed from next release. Use mc_client_unset_repeat_mode_updated_cb() instead.");
 
-       return __mc_client_unset_updated_cb(client, MC_EVENT_REPEAT);
+       return __mc_client_unset_updated_cb(client, MC_CLIENT_EVENT_REPEAT);
 }
 
 int mc_client_set_server_updated_cb(mc_client_h client, mc_server_state_updated_cb callback, void *user_data)
 {
-       return __mc_client_set_updated_cb(client, MC_EVENT_SERVER_STATE, callback, user_data);
+       return __mc_client_set_updated_cb(client, MC_CLIENT_EVENT_SERVER_STATE, callback, user_data);
 }
 
 int mc_client_unset_server_updated_cb(mc_client_h client)
 {
-       return __mc_client_unset_updated_cb(client, MC_EVENT_SERVER_STATE);
+       return __mc_client_unset_updated_cb(client, MC_CLIENT_EVENT_SERVER_STATE);
 }
 
 int mc_client_set_playback_updated_cb(mc_client_h client, mc_playback_updated_cb callback, void *user_data)
 {
-       return __mc_client_set_updated_cb(client, MC_EVENT_PLAYBACK_INFO, callback, user_data);
+       return __mc_client_set_updated_cb(client, MC_CLIENT_EVENT_PLAYBACK_INFO, callback, user_data);
 }
 
 int mc_client_unset_playback_updated_cb(mc_client_h client)
 {
-       return __mc_client_unset_updated_cb(client, MC_EVENT_PLAYBACK_INFO);
+       return __mc_client_unset_updated_cb(client, MC_CLIENT_EVENT_PLAYBACK_INFO);
 }
 
 int mc_client_set_metadata_updated_cb(mc_client_h client, mc_metadata_updated_cb callback, void *user_data)
 {
-       return __mc_client_set_updated_cb(client, MC_EVENT_METADATA, callback, user_data);
+       return __mc_client_set_updated_cb(client, MC_CLIENT_EVENT_METADATA, callback, user_data);
 }
 
 int mc_client_unset_metadata_updated_cb(mc_client_h client)
 {
-       return __mc_client_unset_updated_cb(client, MC_EVENT_METADATA);
+       return __mc_client_unset_updated_cb(client, MC_CLIENT_EVENT_METADATA);
 }
 
 int mc_client_set_shuffle_mode_updated_cb(mc_client_h client, mc_shuffle_mode_updated_cb callback, void *user_data)
 {
-       return __mc_client_set_updated_cb(client, MC_EVENT_SHUFFLE, callback, user_data);
+       return __mc_client_set_updated_cb(client, MC_CLIENT_EVENT_SHUFFLE, callback, user_data);
 }
 
 int mc_client_unset_shuffle_mode_updated_cb(mc_client_h client)
 {
-       return __mc_client_unset_updated_cb(client, MC_EVENT_SHUFFLE);
+       return __mc_client_unset_updated_cb(client, MC_CLIENT_EVENT_SHUFFLE);
 }
 
 int mc_client_set_repeat_mode_updated_cb(mc_client_h client, mc_repeat_mode_updated_cb callback, void *user_data)
 {
-       return __mc_client_set_updated_cb(client, MC_EVENT_REPEAT, callback, user_data);
+       return __mc_client_set_updated_cb(client, MC_CLIENT_EVENT_REPEAT, callback, user_data);
 }
 
 int mc_client_unset_repeat_mode_updated_cb(mc_client_h client)
 {
-       return __mc_client_unset_updated_cb(client, MC_EVENT_REPEAT);
+       return __mc_client_unset_updated_cb(client, MC_CLIENT_EVENT_REPEAT);
 }
 
 int mc_client_set_playlist_updated_cb(mc_client_h client, mc_playlist_updated_cb callback, void *user_data)
 {
-       return __mc_client_set_updated_cb(client, MC_EVENT_PLAYLIST, callback, user_data);
+       return __mc_client_set_updated_cb(client, MC_CLIENT_EVENT_PLAYLIST, callback, user_data);
 }
 
 int mc_client_unset_playlist_updated_cb(mc_client_h client)
 {
-       return __mc_client_unset_updated_cb(client, MC_EVENT_PLAYLIST);
+       return __mc_client_unset_updated_cb(client, MC_CLIENT_EVENT_PLAYLIST);
 }
 
 int mc_client_set_cmd_reply_received_cb(mc_client_h client, mc_cmd_reply_received_cb callback, void *user_data)
 {
-       return __mc_client_set_updated_cb(client, MC_EVENT_CMD_REPLY, callback, user_data);
+       return __mc_client_set_updated_cb(client, MC_CLIENT_EVENT_CMD_REPLY, callback, user_data);
 }
 
 int mc_client_unset_cmd_reply_received_cb(mc_client_h client)
 {
-       return __mc_client_unset_updated_cb(client, MC_EVENT_CMD_REPLY);
+       return __mc_client_unset_updated_cb(client, MC_CLIENT_EVENT_CMD_REPLY);
 }
 
 int mc_client_set_custom_event_received_cb(mc_client_h client, mc_client_custom_event_received_cb callback, void *user_data)
 {
-       return __mc_client_set_updated_cb(client, MC_EVENT_SERVER_CUSTOM, callback, user_data);
+       return __mc_client_set_updated_cb(client, MC_CLIENT_EVENT_SERVER_CUSTOM, callback, user_data);
 }
 
 int mc_client_unset_custom_event_received_cb(mc_client_h client)
 {
-       return __mc_client_unset_updated_cb(client, MC_EVENT_SERVER_CUSTOM);
+       return __mc_client_unset_updated_cb(client, MC_CLIENT_EVENT_SERVER_CUSTOM);
 }
 
 int mc_client_set_playback_ability_updated_cb(mc_client_h client, mc_playback_ability_updated_cb callback, void *user_data)
 {
-       return __mc_client_set_updated_cb(client, MC_EVENT_PLAYBACK_ABILITY, callback, user_data);
+       return __mc_client_set_updated_cb(client, MC_CLIENT_EVENT_PLAYBACK_ABILITY, callback, user_data);
 }
 int mc_client_unset_playback_ability_updated_cb(mc_client_h client)
 {
-       return __mc_client_unset_updated_cb(client, MC_EVENT_PLAYBACK_ABILITY);
+       return __mc_client_unset_updated_cb(client, MC_CLIENT_EVENT_PLAYBACK_ABILITY);
 }
 
 int mc_client_set_shuffle_ability_updated_cb(mc_client_h client, mc_shuffle_ability_updated_cb callback, void *user_data)
 {
-       return __mc_client_set_updated_cb(client, MC_EVENT_SHUFFLE_ABILITY, callback, user_data);
+       return __mc_client_set_updated_cb(client, MC_CLIENT_EVENT_SHUFFLE_ABILITY, callback, user_data);
 }
 
 int mc_client_unset_shuffle_ability_updated_cb(mc_client_h client)
 {
-       return __mc_client_unset_updated_cb(client, MC_EVENT_SHUFFLE_ABILITY);
+       return __mc_client_unset_updated_cb(client, MC_CLIENT_EVENT_SHUFFLE_ABILITY);
 }
 
 int mc_client_set_repeat_ability_updated_cb(mc_client_h client, mc_repeat_ability_updated_cb callback, void *user_data)
 {
-       return __mc_client_set_updated_cb(client, MC_EVENT_REPEAT_ABILITY, callback, user_data);
+       return __mc_client_set_updated_cb(client, MC_CLIENT_EVENT_REPEAT_ABILITY, callback, user_data);
 }
 
 int mc_client_unset_repeat_ability_updated_cb(mc_client_h client)
 {
-       return __mc_client_unset_updated_cb(client, MC_EVENT_REPEAT_ABILITY);
+       return __mc_client_unset_updated_cb(client, MC_CLIENT_EVENT_REPEAT_ABILITY);
 }
 
 int mc_client_subscribe(mc_client_h client, const mc_subscription_type_e subscription_type, const char *server_name)
@@ -1349,7 +1349,7 @@ int mc_client_send_custom_command(mc_client_h client, const char *server_name, c
        mc_retvm_if(!MC_STRING_VALID(server_name), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid server_name");
 
        if (callback) {
-               ret = __mc_client_set_updated_cb(client, MC_EVENT_CLIENT_CUSTOM, callback, user_data);
+               ret = __mc_client_set_updated_cb(client, MC_CLIENT_EVENT_CLIENT_CUSTOM, callback, user_data);
                mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "Error when __mc_client_set_updated_cb [%d]", ret);
        }