} mc_search_item_s;
/* util */
-int mc_util_get_own_name(char **name);
-char* mc_util_get_interface_name(const char *type, const char *name);
-int mc_util_make_filter_interface_name(const char *prefix, const char *filter, char **interface_name);
-int mc_util_set_command_available(mc_priv_type_e priv_type, const char *name, const char *command_type, const char *command);
-int mc_util_get_command_available(mc_priv_type_e priv_type, const char *name, const char *command_type, const char *command);
-char *mc_util_generate_uuid(void);
-int mc_util_bundle_to_string(bundle *bundle_data, char **str_data);
+int _mc_util_get_own_name(char **name);
+char* _mc_util_get_interface_name(const char *type, const char *name);
+int _mc_util_make_filter_interface_name(const char *prefix, const char *filter, char **interface_name);
+int _mc_util_set_command_available(mc_priv_type_e priv_type, const char *name, const char *command_type, const char *command);
+int _mc_util_get_command_available(mc_priv_type_e priv_type, const char *name, const char *command_type, const char *command);
+char *_mc_util_generate_uuid(void);
+int _mc_util_bundle_to_string(bundle *bundle_data, char **str_data);
gboolean _mc_util_is_valid_playback_action(mc_playback_action_e action);
gboolean _mc_util_is_valid_subscription_type(const mc_subscription_type_e subscription_type);
gboolean _mc_util_is_valid_display_mode(mc_display_mode_e mode);
const char * _mc_util_replace_null(const char *data);
/* for d-bus IPC */
-int mc_ipc_get_dbus_connection(GDBusConnection **conn, int *dref_count);
-int mc_ipc_unref_dbus_connection(GDBusConnection *conn, int *dref_count);
-int mc_ipc_register_listener(GList **manage_list, GDBusConnection *connection, const char *interface_name, const char *signal_name, mc_signal_received_cb callback, void *user_data);
-int mc_ipc_unregister_listener(GList **manage_list, const char *interface_name, const char *signal_name);
-int mc_ipc_unregister_all_listener(GList **manage_list);
-int mc_ipc_unregister_filter_listener(GList **listener_list, const char *server_name, const char *signal_name);
-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);
+int _mc_ipc_get_dbus_connection(GDBusConnection **conn, int *dref_count);
+int _mc_ipc_unref_dbus_connection(GDBusConnection *conn, int *dref_count);
+int _mc_ipc_register_listener(GList **manage_list, GDBusConnection *connection, const char *interface_name, const char *signal_name, mc_signal_received_cb callback, void *user_data);
+int _mc_ipc_unregister_listener(GList **manage_list, const char *interface_name, const char *signal_name);
+int _mc_ipc_unregister_all_listener(GList **manage_list);
+int _mc_ipc_unregister_filter_listener(GList **listener_list, const char *server_name, const char *signal_name);
+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);
int _mc_playlist_update(mc_priv_type_e type, const char *server_name, mc_playlist_h playlist);
int _mc_metadata_set(mc_metadata_h metadata, mc_meta_e attribute, const char *value);
if (params[0])
sender = strdup(params[0]);
- if (mc_util_get_command_available(MC_PRIV_TYPE_CLIENT, sender, MC_EVENT_CUSTOM, params[1]) != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (_mc_util_get_command_available(MC_PRIV_TYPE_CLIENT, sender, MC_EVENT_CUSTOM, params[1]) != MEDIA_CONTROLLER_ERROR_NONE) {
mc_error("Error permission denied");
MC_SAFE_FREE(sender);
g_strfreev(params);
_client = (media_controller_client_s *)calloc(1, sizeof(media_controller_client_s));
mc_retvm_if(_client == NULL, MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY, "Error allocation memory");
- ret = mc_util_get_own_name(&(_client->client_name));
+ ret = _mc_util_get_own_name(&(_client->client_name));
if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- mc_error("Filed to get client name %d", ret);
+ mc_error("Filed to _mc_util_get_own_name %d", ret);
goto Error;
}
- ret = mc_ipc_get_dbus_connection(&(_client->dconn), &(_client->dref_count));
+ ret = _mc_ipc_get_dbus_connection(&(_client->dconn), &(_client->dref_count));
if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
mc_error("error in client init %d", ret);
goto Error;
return MEDIA_CONTROLLER_ERROR_NONE;
Error:
if (_client->dconn)
- mc_ipc_unref_dbus_connection(_client->dconn, &_client->dref_count);
+ _mc_ipc_unref_dbus_connection(_client->dconn, &_client->dref_count);
if (_client->db_handle)
mc_db_disconnect(_client->db_handle);
mc_retvm_if(mc_client == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
/*Send Disconnection Msg to Server*/
- ret = mc_ipc_send_message_to_server(MC_MSG_SERVER_DISCONNECTION, MC_PRIV_TYPE_CLIENT, mc_client->client_name);
+ ret = _mc_ipc_send_message_to_server(MC_MSG_SERVER_DISCONNECTION, MC_PRIV_TYPE_CLIENT, mc_client->client_name);
if (ret != MEDIA_CONTROLLER_ERROR_NONE)
- mc_error("Failed to mc_ipc_send_message_to_server [%d]", ret);
+ mc_error("Failed to _mc_ipc_send_message_to_server [%d]", ret);
if (mc_client->dconn) {
- ret = mc_ipc_unref_dbus_connection(mc_client->dconn, &mc_client->dref_count);
+ ret = _mc_ipc_unref_dbus_connection(mc_client->dconn, &mc_client->dref_count);
if (ret != MEDIA_CONTROLLER_ERROR_NONE)
- mc_error("fail to mc_ipc_unref_dbus_connection");
+ mc_error("fail to _mc_ipc_unref_dbus_connection");
}
if (mc_client->db_handle)
mc_debug("signal = [%s]", signal_name);
- ret = mc_util_make_filter_interface_name(MC_DBUS_UPDATE_INTERFACE, server_name, &filter_interface_name);
- mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "Fail mc_util_make_filter_interface_name");
+ ret = _mc_util_make_filter_interface_name(MC_DBUS_UPDATE_INTERFACE, server_name, &filter_interface_name);
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "Fail _mc_util_make_filter_interface_name");
- ret = mc_ipc_register_listener(&mc_client->listeners, mc_client->dconn, filter_interface_name, signal_name, callback, user_data);
+ ret = _mc_ipc_register_listener(&mc_client->listeners, mc_client->dconn, filter_interface_name, signal_name, callback, user_data);
if (ret == MEDIA_CONTROLLER_ERROR_NONE) {
char *filter_data = (char *)g_strdup(server_name);
if (filter_data == NULL) {
mc_debug("memeory allocation failed");
- mc_ipc_unregister_listener(&mc_client->listeners, filter_interface_name, signal_name);
+ _mc_ipc_unregister_listener(&mc_client->listeners, filter_interface_name, signal_name);
MC_SAFE_FREE(filter_interface_name);
return MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY;
}
if (MC_STRING_VALID(server_name)) {
/* Unregister filter */
- ret = mc_ipc_unregister_filter_listener(&mc_client->listeners, server_name, signal_name);
+ ret = _mc_ipc_unregister_filter_listener(&mc_client->listeners, server_name, signal_name);
if (ret != MEDIA_CONTROLLER_ERROR_NONE)
- mc_error("Fail mc_ipc_unregister_filter_listener");
+ mc_error("Fail _mc_ipc_unregister_filter_listener");
/* Remove from filter_list */
found_item = g_list_find_custom(*filter_list, server_name, __compare_filter);
for (iter = *filter_list; iter; iter = iter->next) {
mc_debug("filter[%s.%s]", (char *)(iter->data), signal_name);
- ret = mc_ipc_unregister_filter_listener(&mc_client->listeners, (char *)(iter->data), signal_name);
+ ret = _mc_ipc_unregister_filter_listener(&mc_client->listeners, (char *)(iter->data), signal_name);
if (ret != MEDIA_CONTROLLER_ERROR_NONE)
- mc_error("Fail mc_ipc_unregister_filter_listener");
+ mc_error("Fail _mc_ipc_unregister_filter_listener");
}
/* Remove all filters */
mc_retvm_if(!MC_STRING_VALID(message), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid message");
mc_retvm_if(!_mc_db_is_activated_server(mc_client->db_handle, server_name), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid server_name");
- ret = mc_util_set_command_available(MC_PRIV_TYPE_CLIENT, mc_client->client_name, command_type, command);
- mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "Error mc_util_set_command_available [%d]", ret);
+ ret = _mc_util_set_command_available(MC_PRIV_TYPE_CLIENT, mc_client->client_name, command_type, command);
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "fail to _mc_util_set_command_available [%d]", ret);
- interface_name = mc_util_get_interface_name(MC_SERVER, server_name);
+ interface_name = _mc_util_get_interface_name(MC_SERVER, server_name);
- ret = mc_ipc_send_message(mc_client->dconn, NULL, interface_name, signal_name, message, request_id);
+ ret = _mc_ipc_send_message(mc_client->dconn, NULL, interface_name, signal_name, message, request_id);
if (ret != MEDIA_CONTROLLER_ERROR_NONE)
- mc_error("Error mc_ipc_send_message [%d]", ret);
+ mc_error("Error _mc_ipc_send_message [%d]", ret);
MC_SAFE_G_FREE(interface_name);
mc_retvm_if(client == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
/*Try Socket Activation by systemd*/
- ret = mc_ipc_service_connect(MC_PRIV_TYPE_CLIENT);
- mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "Failed to get mc_ipc_service_connect");
+ ret = _mc_ipc_service_connect(MC_PRIV_TYPE_CLIENT);
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "Failed to _mc_ipc_service_connect");
ret = __mc_client_create(&mc_client);
if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
#else
if ((event == MC_CLIENT_EVENT_CMD_REPLY) || (event == MC_CLIENT_EVENT_SERVER_CUSTOM)) {
#endif
- 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,
+ 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_CLIENT_EVENT_PLAYBACK_INFO) || (event == MC_CLIENT_EVENT_METADATA) || (event == MC_CLIENT_EVENT_PLAYBACK_ABILITY)
|| (event == MC_CLIENT_EVENT_DISPLAY_MODE_ABILITY) || (event == MC_CLIENT_EVENT_DISPLAY_ROTATION_ABILITY)) {
- ret = mc_ipc_register_listener(&mc_client->listeners, mc_client->dconn, MC_DBUS_UPDATE_INTERFACE, cb_event[event].signal_name,
+ 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 {
- ret = mc_ipc_register_listener(&mc_client->listeners, mc_client->dconn, MC_DBUS_UPDATE_INTERFACE, cb_event[event].signal_name,
+ 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->updated_cb[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_CLIENT_EVENT_CMD_REPLY) || (event == MC_CLIENT_EVENT_SERVER_CUSTOM)) {
- interface_name = mc_util_get_interface_name(MC_CLIENT, mc_client->client_name);
+ interface_name = _mc_util_get_interface_name(MC_CLIENT, mc_client->client_name);
- ret = mc_ipc_unregister_listener(&mc_client->listeners, interface_name, cb_event[event].signal_name);
+ ret = _mc_ipc_unregister_listener(&mc_client->listeners, interface_name, cb_event[event].signal_name);
MC_SAFE_FREE(interface_name);
} else {
- ret = mc_ipc_unregister_listener(&mc_client->listeners, MC_DBUS_UPDATE_INTERFACE, cb_event[event].signal_name);
+ ret = _mc_ipc_unregister_listener(&mc_client->listeners, MC_DBUS_UPDATE_INTERFACE, cb_event[event].signal_name);
ret = __mc_client_unregister_filter_listener(mc_client, &mc_client->updated_cb[event].filter_list, NULL, cb_event[event].signal_name);
}
mc_retvm_if(!_mc_util_is_valid_subscription_type(subscription_type) , MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid subscription_type");
mc_retvm_if(mc_client->updated_cb[subscription_type].callback == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid callback");
- ret = mc_ipc_unregister_listener(&mc_client->listeners, MC_DBUS_UPDATE_INTERFACE, cb_event[subscription_type].signal_name);
+ ret = _mc_ipc_unregister_listener(&mc_client->listeners, MC_DBUS_UPDATE_INTERFACE, cb_event[subscription_type].signal_name);
if (subscription_type == MC_SUBSCRIPTION_TYPE_METADATA || subscription_type == MC_SUBSCRIPTION_TYPE_PLAYBACK_ABILITY
|| subscription_type == MC_SUBSCRIPTION_TYPE_DISPLAY_MODE_ABILITY || subscription_type == MC_SUBSCRIPTION_TYPE_DISPLAY_ROTATION_ABILITY) {
ret = __mc_client_verify_ability(client, server_name, MC_ABILITY_CLIENT_CUSTOM);
mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "fail to verify ability");
- ret = mc_util_bundle_to_string(data, &bundle_str);
+ 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);
goto ERROR;
}
- ret = mc_util_bundle_to_string(search_item->data, &bundle_str);
+ ret = _mc_util_bundle_to_string(search_item->data, &bundle_str);
if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
mc_error("Error when encode bundle [%d][%d]", ret, idx);
goto ERROR;
ret = __mc_client_get_bundle_from_search(search, &bundle_data);
mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "Error __mc_client_get_bundle_from_search [%d]", ret);
- ret = mc_util_bundle_to_string(bundle_data, &bundle_str);
+ ret = _mc_util_bundle_to_string(bundle_data, &bundle_str);
bundle_free(bundle_data);
mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "Error when make string from bundle");
mc_retvm_if(!MC_STRING_VALID(server_name), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "server_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);
+ 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_client->client_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_SERVER, server_name);
- ret = mc_ipc_send_reply(mc_client->dconn, NULL, interface_name, MC_DBUS_SIGNAL_NAME_EVENT_REPLY, message, request_id);
+ char *interface_name = _mc_util_get_interface_name(MC_SERVER, server_name);
+ ret = _mc_ipc_send_reply(mc_client->dconn, NULL, interface_name, MC_DBUS_SIGNAL_NAME_EVENT_REPLY, message, request_id);
if (ret != MEDIA_CONTROLLER_ERROR_NONE)
- mc_error("Error mc_ipc_send_message [%d]", ret);
+ mc_error("Error _mc_ipc_send_message [%d]", ret);
MC_SAFE_G_FREE(message);
MC_SAFE_G_FREE(interface_name);
}
/*Unregister all listener*/
- ret = mc_ipc_unregister_all_listener(&mc_client->listeners);
+ ret = _mc_ipc_unregister_all_listener(&mc_client->listeners);
if (ret != MEDIA_CONTROLLER_ERROR_NONE)
- mc_error("Error mc_ipc_unregister_all_listener [%d]", ret);
+ mc_error("Error _mc_ipc_unregister_all_listener [%d]", ret);
ret = __mc_client_destroy(mc_client);
mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "Error when __mc_client_set_updated_cb [%d]", ret);
}
- ret = mc_util_bundle_to_string(data, &bundle_str);
+ 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);
static int __mc_db_update_db(mc_priv_type_e priv_type, const char *sql_str)
{
- return mc_ipc_send_message_to_server(MC_MSG_DB_UPDATE, priv_type, sql_str);
+ return _mc_ipc_send_message_to_server(MC_MSG_DB_UPDATE, priv_type, sql_str);
}
static int __mc_db_get_record(sqlite3 *handle, char *sql_str, sqlite3_stmt **stmt)
int ret = MEDIA_CONTROLLER_ERROR_NONE;
char *app_id = NULL;
- ret = mc_util_get_own_name(&app_id);
- mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "Failed to get server_name [%d]", ret);
+ ret = _mc_util_get_own_name(&app_id);
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "Failed to _mc_util_get_own_name[%d]", ret);
- ret = mc_ipc_send_message_to_server(MC_MSG_SERVER_CONNECTION, priv_type, app_id);
+ ret = _mc_ipc_send_message_to_server(MC_MSG_SERVER_CONNECTION, priv_type, app_id);
MC_SAFE_FREE(app_id);
g_dbus_connection_signal_unsubscribe(connection, handler);
}
-int mc_ipc_get_dbus_connection(GDBusConnection **connection, int *dref_count)
+int _mc_ipc_get_dbus_connection(GDBusConnection **connection, int *dref_count)
{
GError *error = NULL;
GDBusConnection *_connection = NULL;
return MEDIA_CONTROLLER_ERROR_NONE;
}
-int mc_ipc_unref_dbus_connection(GDBusConnection *connection, int *dref_count)
+int _mc_ipc_unref_dbus_connection(GDBusConnection *connection, int *dref_count)
{
mc_retvm_if(connection == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "invalid connection");
mc_retvm_if(dref_count == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "invalid dref_count");
return MEDIA_CONTROLLER_ERROR_NONE;
}
-int mc_ipc_register_listener(GList **listener_list, GDBusConnection *connection, const char *interface_name, const char *signal_name, mc_signal_received_cb callback, void *user_data)
+int _mc_ipc_register_listener(GList **listener_list, GDBusConnection *connection, const char *interface_name, const char *signal_name, mc_signal_received_cb callback, void *user_data)
{
char *key = NULL;
return MEDIA_CONTROLLER_ERROR_NONE;
}
-int mc_ipc_unregister_listener(GList **listener_list, const char *interface_name, const char *signal_name)
+int _mc_ipc_unregister_listener(GList **listener_list, const char *interface_name, const char *signal_name)
{
GList *found_item = NULL;
char *key = NULL;
return MEDIA_CONTROLLER_ERROR_NONE;
}
-int mc_ipc_unregister_all_listener(GList **listener_list)
+int _mc_ipc_unregister_all_listener(GList **listener_list)
{
mc_retvm_if(listener_list == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "listener_list is NULL");
return MEDIA_CONTROLLER_ERROR_NONE;
}
-int mc_ipc_unregister_filter_listener(GList **listener_list, const char *server_name, const char *signal_name)
+int _mc_ipc_unregister_filter_listener(GList **listener_list, const char *server_name, const char *signal_name)
{
int ret = MEDIA_CONTROLLER_ERROR_NONE;
char *filter_interface = NULL;
mc_retvm_if(!server_name, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "server_name is NULL");
mc_retvm_if(!signal_name, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "signal_name is NULL");
- ret = mc_util_make_filter_interface_name(MC_DBUS_UPDATE_INTERFACE, server_name, &filter_interface);
- mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "Fail mc_util_make_filter_interface_name");
+ ret = _mc_util_make_filter_interface_name(MC_DBUS_UPDATE_INTERFACE, server_name, &filter_interface);
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "Fail _mc_util_make_filter_interface_name");
- ret = mc_ipc_unregister_listener(listener_list, filter_interface, signal_name);
+ ret = _mc_ipc_unregister_listener(listener_list, filter_interface, signal_name);
MC_SAFE_G_FREE(filter_interface);
return MEDIA_CONTROLLER_ERROR_NONE;
}
-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_message(GDBusConnection *connection, const char *dbus_name, const char *interface_name, const char *signal_name, const char *message, char **request_id)
{
const char *req_id = DEFAULT_REQ_ID;
if (request_id != NULL) {
- req_id = mc_util_generate_uuid();
+ req_id = _mc_util_generate_uuid();
*request_id = g_strdup(req_id);
mc_secure_debug("req_id[%s]", req_id);
return __send_message(connection, dbus_name, interface_name, signal_name, message, req_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_reply(GDBusConnection *connection, const char *dbus_name, const char *interface_name, const char *signal_name, const char *message, const char *request_id)
{
return __send_message(connection, dbus_name, interface_name, signal_name, message, 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_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;
int request_msg_size = 0;
return ret;
}
-int mc_ipc_service_connect(mc_priv_type_e priv_type)
+int _mc_ipc_service_connect(mc_priv_type_e priv_type)
{
int ret = MEDIA_CONTROLLER_ERROR_NONE;
#ifdef _ON_DEMAND_SOCKET_ACTIVATION
/* If can't make connection to service, the service activation is needed */
/* Create Socket */
- ret = mc_ipc_create_client_socket(MC_TIMEOUT_SEC_5, &sockfd);
+ ret = _mc_ipc_create_client_socket(MC_TIMEOUT_SEC_5, &sockfd);
mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "socket is not created properly");
/* Set socket activation address, the path is already created by system */
_server = (media_controller_server_s *)calloc(1, sizeof(media_controller_server_s));
mc_retvm_if(_server == NULL, MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY, "Error allocation memory");
- ret = mc_util_get_own_name(&(_server->server_name));
+ ret = _mc_util_get_own_name(&(_server->server_name));
if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- mc_error("Failed to get server_name [%d]", ret);
+ mc_error("Failed to _mc_util_get_own_name [%d]", ret);
goto ERROR;
}
_server->basic_ability.decided = (unsigned long)MC_BIT64_UNSET;
_server->basic_ability.supported = (unsigned long)MC_BIT64_UNSET;
- ret = mc_ipc_get_dbus_connection(&(_server->dconn), &(_server->dref_count));
+ ret = _mc_ipc_get_dbus_connection(&(_server->dconn), &(_server->dref_count));
if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
mc_error("Error allocation memory");
goto ERROR;
ERROR:
if (_server->dconn)
- mc_ipc_unref_dbus_connection(_server->dconn, &_server->dref_count);
+ _mc_ipc_unref_dbus_connection(_server->dconn, &_server->dref_count);
if (_server->db_handle)
mc_db_disconnect(_server->db_handle);
mc_retvm_if(mc_server == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
/*Send Disconnection Msg to Server*/
- ret = mc_ipc_send_message_to_server(MC_MSG_SERVER_DISCONNECTION, MC_PRIV_TYPE_SERVER, mc_server->server_name);
+ ret = _mc_ipc_send_message_to_server(MC_MSG_SERVER_DISCONNECTION, MC_PRIV_TYPE_SERVER, mc_server->server_name);
if (ret != MEDIA_CONTROLLER_ERROR_NONE)
- mc_error("Failed to mc_ipc_send_message_to_server [%d]", ret);
+ mc_error("Failed to _mc_ipc_send_message_to_server [%d]", ret);
if (mc_server->dconn) {
- ret = mc_ipc_unref_dbus_connection(mc_server->dconn, &mc_server->dref_count);
+ ret = _mc_ipc_unref_dbus_connection(mc_server->dconn, &mc_server->dref_count);
if (ret != MEDIA_CONTROLLER_ERROR_NONE)
- mc_error("fail to mc_ipc_unref_dbus_connection");
+ mc_error("fail to _mc_ipc_unref_dbus_connection");
}
if (mc_server->db_handle)
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) {
+ 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;
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) {
+ 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;
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) {
+ 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;
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) {
+ 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;
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) {
+ 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 (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) {
+ 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);
params = g_strsplit(message, MC_STRING_DELIMITER, 0);
mc_retm_if(params == NULL, "invalid search data");
- if (mc_util_get_command_available(MC_PRIV_TYPE_SERVER, params[0], MC_COMMAND_SEARCH, NULL) != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (_mc_util_get_command_available(MC_PRIV_TYPE_SERVER, params[0], MC_COMMAND_SEARCH, NULL) != MEDIA_CONTROLLER_ERROR_NONE) {
mc_error("Error permission denied");
g_strfreev(params);
return;
mc_retm_if(params == NULL, "invalid command");
if (!strncmp(signal_name, MC_DBUS_SIGNAL_NAME_SUBTITLES, strlen(MC_DBUS_SIGNAL_NAME_SUBTITLES))) {
- if (mc_util_get_command_available(MC_PRIV_TYPE_SERVER, params[0], MC_COMMAND_SUBTITLES, NULL) != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (_mc_util_get_command_available(MC_PRIV_TYPE_SERVER, params[0], MC_COMMAND_SUBTITLES, NULL) != MEDIA_CONTROLLER_ERROR_NONE) {
mc_error("Error permission denied for subtitles");
g_strfreev(params);
return;
}
} else if (!strncmp(signal_name, MC_DBUS_SIGNAL_NAME_360, strlen(MC_DBUS_SIGNAL_NAME_360))) {
- if (mc_util_get_command_available(MC_PRIV_TYPE_SERVER, params[0], MC_COMMAND_360, NULL) != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (_mc_util_get_command_available(MC_PRIV_TYPE_SERVER, params[0], MC_COMMAND_360, NULL) != MEDIA_CONTROLLER_ERROR_NONE) {
mc_error("Error permission denied for 360");
g_strfreev(params);
return;
params = g_strsplit(message, MC_STRING_DELIMITER, 0);
mc_retm_if(params == NULL, "invalid display mode command");
- if (mc_util_get_command_available(MC_PRIV_TYPE_SERVER, params[0], MC_COMMAND_DISPLAYMODE, NULL) != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (_mc_util_get_command_available(MC_PRIV_TYPE_SERVER, params[0], MC_COMMAND_DISPLAYMODE, NULL) != MEDIA_CONTROLLER_ERROR_NONE) {
mc_error("Error permission denied");
g_strfreev(params);
return;
params = g_strsplit(message, MC_STRING_DELIMITER, 0);
mc_retm_if(params == NULL, "invalid display rotation command");
- if (mc_util_get_command_available(MC_PRIV_TYPE_SERVER, params[0], MC_COMMAND_DISPLAYROTATION, NULL) != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (_mc_util_get_command_available(MC_PRIV_TYPE_SERVER, params[0], MC_COMMAND_DISPLAYROTATION, NULL) != MEDIA_CONTROLLER_ERROR_NONE) {
mc_error("Error permission denied");
g_strfreev(params);
return;
mc_retvm_if(!message, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "Invalid message");
- ret = mc_ipc_send_message(mc_server->dconn, NULL, interface_name, signal_name, message, NULL);
+ ret = _mc_ipc_send_message(mc_server->dconn, NULL, interface_name, signal_name, message, NULL);
if (ret != MEDIA_CONTROLLER_ERROR_NONE)
- mc_error("Error mc_ipc_send_message [%d]", ret);
+ mc_error("Error _mc_ipc_send_message [%d]", ret);
mc_secure_debug("interface_name[%s] signal_name[%s] message[%s]", interface_name, signal_name, message);
/*Send again for the subscriber which receive filtered msg with server_name*/
char *filter_interface_name = NULL;
- ret = mc_util_make_filter_interface_name(interface_name, mc_server->server_name, &filter_interface_name);
+ ret = _mc_util_make_filter_interface_name(interface_name, mc_server->server_name, &filter_interface_name);
if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- mc_error("Error mc_util_make_interface_name [%d]", ret);
+ mc_error("Error _mc_util_make_filter_interface_name [%d]", ret);
} else {
- ret = mc_ipc_send_message(mc_server->dconn, NULL, filter_interface_name, signal_name, message, NULL);
+ ret = _mc_ipc_send_message(mc_server->dconn, NULL, filter_interface_name, signal_name, message, NULL);
if (ret != MEDIA_CONTROLLER_ERROR_NONE)
- mc_error("Error mc_ipc_send_message [%d]", ret);
+ mc_error("Error _mc_ipc_send_message [%d]", ret);
}
MC_SAFE_G_FREE(filter_interface_name);
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");
- ret = mc_util_set_command_available(MC_PRIV_TYPE_SERVER, mc_server->server_name, command_type, event);
- mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "Error mc_util_set_command_available [%d]", ret);
+ ret = _mc_util_set_command_available(MC_PRIV_TYPE_SERVER, mc_server->server_name, command_type, event);
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "fail to _mc_util_set_command_available [%d]", ret);
- interface_name = mc_util_get_interface_name(MC_CLIENT, client_name);
+ interface_name = _mc_util_get_interface_name(MC_CLIENT, client_name);
- ret = mc_ipc_send_message(mc_server->dconn, NULL, interface_name, signal_name, message, request_id);
+ ret = _mc_ipc_send_message(mc_server->dconn, NULL, interface_name, signal_name, message, request_id);
if (ret != MEDIA_CONTROLLER_ERROR_NONE)
- mc_error("Error mc_ipc_send_message [%d]", ret);
+ mc_error("Error _mc_ipc_send_message [%d]", ret);
MC_SAFE_G_FREE(interface_name);
mc_server->updated_cb[event].callback = callback;
mc_server->updated_cb[event].user_data = user_data;
- interface_name = mc_util_get_interface_name(MC_SERVER, mc_server->server_name);
+ 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, cb_event[event].signal_name, cb_event[event].cb_func, (void *)&(mc_server->updated_cb[event]));
+ ret = _mc_ipc_register_listener(&mc_server->listeners, mc_server->dconn, interface_name, cb_event[event].signal_name, cb_event[event].cb_func, (void *)&(mc_server->updated_cb[event]));
MC_SAFE_FREE(interface_name);
mc_retvm_if(mc_server == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
mc_retvm_if(((event < MC_SERVER_EVENT_PLAYBACK_ACTION) || (event >= MC_SERVER_EVENT_MAX)) , MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid event [%d]", event);
- interface_name = mc_util_get_interface_name(MC_SERVER, mc_server->server_name);
+ interface_name = _mc_util_get_interface_name(MC_SERVER, mc_server->server_name);
- ret = mc_ipc_unregister_listener(&mc_server->listeners, interface_name, cb_event[event].signal_name);
+ ret = _mc_ipc_unregister_listener(&mc_server->listeners, interface_name, cb_event[event].signal_name);
mc_server->updated_cb[event].callback = NULL;
mc_server->updated_cb[event].user_data = NULL;
mc_retvm_if(!__is_valid_parameter(server, client_name), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid parameter");
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);
+ 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_reply(mc_server->dconn, NULL, interface_name, MC_DBUS_SIGNAL_NAME_CMD_REPLY, message, request_id);
+ char *interface_name = _mc_util_get_interface_name(MC_CLIENT, client_name);
+ 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);
+ mc_error("Error _mc_ipc_send_message [%d]", ret);
MC_SAFE_G_FREE(message);
MC_SAFE_G_FREE(interface_name);
mc_retvm_if(!__is_valid_parameter(server, client_name), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid parameter");
mc_retvm_if(!event, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid event");
- ret = mc_util_bundle_to_string(data, &bundle_str);
+ 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_server->server_name, MC_STRING_DELIMITER, event, MC_STRING_DELIMITER, bundle_str);
mc_retvm_if(server == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is null");
/*Try Socket Activation by systemd*/
- ret = mc_ipc_service_connect(MC_PRIV_TYPE_SERVER);
- mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "Failed to get mc_ipc_service_connect");
+ ret = _mc_ipc_service_connect(MC_PRIV_TYPE_SERVER);
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "Failed to _mc_ipc_service_connect");
ret = __mc_server_create(&mc_server);
if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
mc_retvm_if(mc_server == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
- ret = mc_ipc_unregister_all_listener(&mc_server->listeners);
+ ret = _mc_ipc_unregister_all_listener(&mc_server->listeners);
if (ret != MEDIA_CONTROLLER_ERROR_NONE)
- mc_error("fail mc_ipc_unregister_all_listener [%d]", ret);
+ mc_error("fail _mc_ipc_unregister_all_listener [%d]", ret);
ret = __mc_server_send_message(mc_server, MC_DBUS_UPDATE_INTERFACE, MC_DBUS_SIGNAL_NAME_SERVER_STATE, MC_SERVER_STATE_DEACTIVATE, 0, NULL);
if (ret != MEDIA_CONTROLLER_ERROR_NONE)
params = g_strsplit(message, MC_STRING_DELIMITER, 0);
mc_retm_if(params == NULL, "invalid playback state command");
- if (mc_util_get_command_available(MC_PRIV_TYPE_SERVER, params[0], MC_COMMAND_PLAYBACKSTATE, NULL) != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (_mc_util_get_command_available(MC_PRIV_TYPE_SERVER, params[0], MC_COMMAND_PLAYBACKSTATE, NULL) != MEDIA_CONTROLLER_ERROR_NONE) {
mc_error("Error permission denied");
g_strfreev(params);
return;
if (params[0])
sender = strdup(params[0]);
- if (mc_util_get_command_available(MC_PRIV_TYPE_SERVER, sender, MC_COMMAND_CUSTOM, params[1]) != MEDIA_CONTROLLER_ERROR_NONE) {
+ if (_mc_util_get_command_available(MC_PRIV_TYPE_SERVER, sender, MC_COMMAND_CUSTOM, params[1]) != MEDIA_CONTROLLER_ERROR_NONE) {
mc_error("Error permission denied");
MC_SAFE_FREE(sender);
g_strfreev(params);
mc_retvm_if(!__is_valid_parameter(server, client_name), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid parameter");
- ret = mc_util_bundle_to_string(data, &bundle_str);
+ 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);
+ 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_error("Error _mc_ipc_send_message [%d]", ret);
MC_SAFE_G_FREE(message);
MC_SAFE_G_FREE(interface_name);
//#define UNIT_TEST /* for testsuite */
#define MAX_NAME_LENGTH 255
-static void _mc_util_check_valid_name(const char *name, char **valid_name)
+static void __mc_util_check_valid_name(const char *name, char **valid_name)
{
char old_word[MAX_NAME_LENGTH] = {0, };
char new_word[MAX_NAME_LENGTH] = {0, };
mc_retm_if((*valid_name) == NULL, "Error allocation memory.");
}
-int mc_util_get_own_name(char **name)
+int _mc_util_get_own_name(char **name)
{
char temp[MAX_NAME_LENGTH] = {0, };
int pid = -1;
return MEDIA_CONTROLLER_ERROR_NONE;
}
-char *mc_util_get_interface_name(const char *type, const char *name)
+char *_mc_util_get_interface_name(const char *type, const char *name)
{
char *temp = NULL;
char *interface_name = NULL;
temp = g_strdup_printf("%s.%s%s", MC_DBUS_INTERFACE_PREFIX, type, name);
- _mc_util_check_valid_name(temp, &interface_name);
+ __mc_util_check_valid_name(temp, &interface_name);
MC_SAFE_G_FREE(temp);
return interface_name;
}
-int mc_util_make_filter_interface_name(const char *prefix, const char *filter, char **interface_name)
+int _mc_util_make_filter_interface_name(const char *prefix, const char *filter, char **interface_name)
{
char *temp = NULL;
return MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY;
}
- _mc_util_check_valid_name(temp, interface_name);
+ __mc_util_check_valid_name(temp, interface_name);
MC_SAFE_G_FREE(temp);
else
message = g_strdup_printf("%s%s%s", name, command_type, command);
- ret = mc_ipc_send_message_to_server(msg_type, priv_type, message);
+ ret = _mc_ipc_send_message_to_server(msg_type, priv_type, message);
MC_SAFE_G_FREE(message);
return ret;
}
-int mc_util_set_command_available(mc_priv_type_e priv_type, const char *name, const char *command_type, const char *command)
+int _mc_util_set_command_available(mc_priv_type_e priv_type, const char *name, const char *command_type, const char *command)
{
return __send_command_available(priv_type, name, command_type, command, MC_MSG_CLIENT_SET);
}
-int mc_util_get_command_available(mc_priv_type_e priv_type, const char *name, const char *command_type, const char *command)
+int _mc_util_get_command_available(mc_priv_type_e priv_type, const char *name, const char *command_type, const char *command)
{
return __send_command_available(priv_type, name, command_type, command, MC_MSG_CLIENT_GET);
}
-char *mc_util_generate_uuid(void)
+char *_mc_util_generate_uuid(void)
{
uuid_t uuid_value;
static char uuid_unparsed[37];
return uuid_unparsed;
}
-int mc_util_bundle_to_string(bundle *bundle_data, char **str_data)
+int _mc_util_bundle_to_string(bundle *bundle_data, char **str_data)
{
int ret = MEDIA_CONTROLLER_ERROR_NONE;
int size_r = 0;
projects / platform / core / api / media-controller.git / commitdiff