src = NULL; \
} \
} while (0)
-#define MC_SAFE_G_FREE(src) do { \
- g_free((gpointer)src); \
- src = NULL; \
- } while (0)
+
#define MC_SAFE_STRLCPY(dst, src, n) g_strlcpy(dst, src, n);
#define MC_STRING_VALID(str) ((str != NULL && strlen(str) > 0) ? TRUE : FALSE)
Name: capi-media-controller
Summary: A media controller library in Tizen Native API
-Version: 0.2.12
+Version: 0.2.13
Release: 1
Group: Multimedia/API
License: Apache-2.0
mode = atoi(params[1]);
- _playlist = (mc_playlist_s *)calloc(1, sizeof(mc_playlist_s));
- if (_playlist == NULL) {
- mc_error("OUT_OF_MEMORY");
- g_strfreev(params);
-
- return;
- }
+ _playlist = g_new0(mc_playlist_s, 1);
_playlist->server_name = g_strdup(params[0]);
_playlist->playlist_name = g_strdup(params[2]);
mc_retm_if(params == NULL, "invalid custom data");
if (params[0])
- sender = strdup(params[0]);
+ sender = g_strdup(params[0]);
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_free(sender);
g_strfreev(params);
return;
}
- command = strdup(params[1]);
+ command = g_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_free(sender);
+ g_free(command);
g_strfreev(params);
}
mc_retvm_if(mc_client == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
- _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");
+ _client = g_new0(media_controller_client_s, 1);
ret = _mc_util_get_own_name(&(_client->client_name));
if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
if (_client->db_handle)
mc_db_disconnect(_client->db_handle);
- MC_SAFE_FREE(_client->client_name);
- MC_SAFE_FREE(_client);
+ g_free(_client->client_name);
+ g_free(_client);
return ret;
}
if (mc_client->listeners != NULL)
g_list_free(mc_client->listeners);
- MC_SAFE_FREE(mc_client->client_name);
- MC_SAFE_FREE(mc_client);
+ g_free(mc_client->client_name);
+ g_free(mc_client);
return ret;
}
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);
- 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_SAFE_FREE(filter_interface_name);
- return MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY;
- }
- *filter_list = g_list_append(*filter_list, filter_data);
- }
+ if (ret == MEDIA_CONTROLLER_ERROR_NONE)
+ *filter_list = g_list_append(*filter_list, g_strdup(server_name));
- MC_SAFE_FREE(filter_interface_name);
+ g_free(filter_interface_name);
return ret;
}
if (ret != MEDIA_CONTROLLER_ERROR_NONE)
mc_error("Error _mc_ipc_send_message [%d]", ret);
- MC_SAFE_G_FREE(interface_name);
+ g_free(interface_name);
return ret;
}
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);
+ g_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_unregister_listener(&mc_client->listeners, interface_name, cb_event[event].signal_name);
- MC_SAFE_FREE(interface_name);
+ g_free(interface_name);
} else {
ret = _mc_ipc_unregister_listener(&mc_client->listeners, MC_DBUS_UPDATE_INTERFACE, cb_event[event].signal_name);
mc_retvm_if(mc_playback == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
- MC_SAFE_FREE(mc_playback->index);
- MC_SAFE_FREE(mc_playback);
+ g_free(mc_playback->index);
+ g_free(mc_playback);
return MEDIA_CONTROLLER_ERROR_NONE;
}
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);
+ g_free(message);
return 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);
+ g_free(message);
return ret;
}
ret = __mc_client_verify_ability(client, server_name, MC_ABILITY_SHUFFLE);
if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
mc_error("fail to verify ability [%d]", ret);
- MC_SAFE_G_FREE(message);
+ g_free(message);
return ret;
}
ret = __mc_client_verify_ability(client, server_name, MC_ABILITY_REPEAT);
if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
mc_error("fail to verify ability [%d]", ret);
- MC_SAFE_G_FREE(message);
+ g_free(message);
return ret;
}
ret = __mc_client_verify_ability(client, server_name, MC_ABILITY_SUBTITLES);
if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
mc_error("fail to verify ability [%d]", ret);
- MC_SAFE_G_FREE(message);
+ g_free(message);
return ret;
}
ret = __mc_client_verify_ability(client, server_name, DISPLAY_MODE_ABILITY + value);
if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
mc_error("fail to verify ability [%d]", ret);
- MC_SAFE_G_FREE(message);
+ g_free(message);
return ret;
}
ret = __mc_client_verify_ability(client, server_name, DISPLAY_ROTATION_ABILITY + value);
if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
mc_error("fail to verify ability [%d]", ret);
- MC_SAFE_G_FREE(message);
+ g_free(message);
return ret;
}
ret = __mc_client_verify_ability(client, server_name, MC_ABILITY_360_MODE);
if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
mc_error("fail to verify ability [%d]", ret);
- MC_SAFE_G_FREE(message);
+ g_free(message);
return ret;
}
default:
mc_error("Not supported event [%d]", event);
- MC_SAFE_G_FREE(message);
+ g_free(message);
return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;
}
- MC_SAFE_G_FREE(message);
+ g_free(message);
return 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);
+ g_free(message);
return ret;
}
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);
+ 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);
+ g_free(message);
return ret;
}
search_item->category, MC_STRING_DELIMITER,
search_item->search_keyword, MC_STRING_DELIMITER,
bundle_str);
- MC_SAFE_FREE(bundle_str);
+ g_free(bundle_str);
mc_secure_debug("[%d][%d][%s][%s]", idx, length, key_str, val_str);
- if (!key_str || !val_str) {
- mc_error("fail to make val_str [%d]", idx);
- ret = MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY;
- goto ERROR;
- }
-
/*key - index, val - val_str (content_type, category, keyword, bundle_size, bundle)*/
ret = bundle_add_str(bundle_data, key_str, val_str);
if (ret != BUNDLE_ERROR_NONE) {
goto ERROR;
}
- MC_SAFE_FREE(key_str);
- MC_SAFE_FREE(val_str);
+ g_free(key_str);
+ g_free(val_str);
}
*res_bundle = bundle_data;
ERROR:
bundle_free(bundle_data);
- MC_SAFE_FREE(key_str);
- MC_SAFE_FREE(val_str);
+ g_free(key_str);
+ g_free(val_str);
return ret;
}
mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "Error when make string from bundle");
message = g_strdup_printf("%s%s%s", mc_client->client_name, MC_STRING_DELIMITER, bundle_str);
- MC_SAFE_G_FREE(bundle_str);
+ 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_SEARCH, NULL, MC_DBUS_SIGNAL_NAME_SEARCH_CMD, message, request_id);
- MC_SAFE_G_FREE(message);
+ g_free(message);
return ret;
}
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);
+ 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);
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);
+ g_free(message);
+ g_free(interface_name);
return ret;
}
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);
+ 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_COMMAND, message, NULL);
- MC_SAFE_G_FREE(message);
+ g_free(message);
return ret;
}
ret = __mc_client_send_command(client, server_name, MC_COMMAND_PLAYBACKSTATE, NULL, MC_DBUS_SIGNAL_NAME_PLAYBACK_STATE_CMD, message, NULL);
- MC_SAFE_G_FREE(message);
+ g_free(message);
return ret;
}
ret = __mc_db_update_db(MC_PRIV_TYPE_SERVER, sql_str);
- MC_SAFE_FREE(sql_str);
+ g_free(sql_str);
return ret;
}
ret = __mc_db_update_db(MC_PRIV_TYPE_SERVER, sql_str);
- MC_SAFE_FREE(sql_str);
+ g_free(sql_str);
return ret;
}
ret = __mc_db_update_db(MC_PRIV_TYPE_SERVER, sql_str);
- MC_SAFE_FREE(sql_str);
+ g_free(sql_str);
return ret;
}
ret = __mc_db_update_db(MC_PRIV_TYPE_SERVER, sql_str);
- MC_SAFE_FREE(sql_str);
+ g_free(sql_str);
return ret;
}
ret = __mc_db_get_record(handle, sql_str, &stmt);
mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "__mc_db_get_record failed [%d]", ret);
- _playback = (media_controller_playback_s *)calloc(1, sizeof(media_controller_playback_s));
- if (!_playback) {
- mc_error("OUT_OF_MEMORY");
- SQLITE3_FINALIZE(stmt);
-
- return MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY;
- }
+ _playback = g_new0(media_controller_playback_s, 1);
_playback->state = sqlite3_column_int(stmt, 0);
_playback->position = (unsigned long long)sqlite3_column_int64(stmt, 1);
{
media_controller_metadata_s *_metadata = NULL;
+ mc_retvm_if(!stmt, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid stmt");
mc_retvm_if(!metadata, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid metadata");
- _metadata = (media_controller_metadata_s *)calloc(1, sizeof(media_controller_metadata_s));
- mc_retvm_if(!_metadata, MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
-
- if (stmt != NULL) {
- _metadata->title = g_strdup((const char *)sqlite3_column_text(stmt, col++));
- _metadata->artist = g_strdup((const char *)sqlite3_column_text(stmt, col++));
- _metadata->album = g_strdup((const char *)sqlite3_column_text(stmt, col++));
- _metadata->author = g_strdup((const char *)sqlite3_column_text(stmt, col++));
- _metadata->genre = g_strdup((const char *)sqlite3_column_text(stmt, col++));
- _metadata->duration = g_strdup((const char *)sqlite3_column_text(stmt, col++));
- _metadata->date = g_strdup((const char *)sqlite3_column_text(stmt, col++));
- _metadata->copyright = g_strdup((const char *)sqlite3_column_text(stmt, col++));
- _metadata->description = g_strdup((const char *)sqlite3_column_text(stmt, col++));
- _metadata->track_num = g_strdup((const char *)sqlite3_column_text(stmt, col++));
- _metadata->picture = g_strdup((const char *)sqlite3_column_text(stmt, col++));
- _metadata->season = g_strdup((const char *)sqlite3_column_text(stmt, col++));
- _metadata->episode = g_strdup((const char *)sqlite3_column_text(stmt, col++));
- _metadata->resolution = g_strdup((const char *)sqlite3_column_text(stmt, col++));
- }
+ _metadata = g_new0(media_controller_metadata_s, 1);
+
+ _metadata->title = g_strdup((const char *)sqlite3_column_text(stmt, col++));
+ _metadata->artist = g_strdup((const char *)sqlite3_column_text(stmt, col++));
+ _metadata->album = g_strdup((const char *)sqlite3_column_text(stmt, col++));
+ _metadata->author = g_strdup((const char *)sqlite3_column_text(stmt, col++));
+ _metadata->genre = g_strdup((const char *)sqlite3_column_text(stmt, col++));
+ _metadata->duration = g_strdup((const char *)sqlite3_column_text(stmt, col++));
+ _metadata->date = g_strdup((const char *)sqlite3_column_text(stmt, col++));
+ _metadata->copyright = g_strdup((const char *)sqlite3_column_text(stmt, col++));
+ _metadata->description = g_strdup((const char *)sqlite3_column_text(stmt, col++));
+ _metadata->track_num = g_strdup((const char *)sqlite3_column_text(stmt, col++));
+ _metadata->picture = g_strdup((const char *)sqlite3_column_text(stmt, col++));
+ _metadata->season = g_strdup((const char *)sqlite3_column_text(stmt, col++));
+ _metadata->episode = g_strdup((const char *)sqlite3_column_text(stmt, col++));
+ _metadata->resolution = g_strdup((const char *)sqlite3_column_text(stmt, col++));
*metadata = (mc_metadata_h)_metadata;
ret = __mc_db_get_ability(handle, server_name, &_decided, &_supported);
mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "__mc_db_get_ability failed");
- basic_ability = (media_controller_ability_s *)calloc(1, sizeof(media_controller_ability_s));
- mc_retvm_if(!basic_ability, MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY, "malloc failed");
+ basic_ability = g_new0(media_controller_ability_s, 1);
basic_ability->decided = _decided;
basic_ability->supported = _supported;
mc_retvm_if(SQLITE_OK != ret, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "prepare error [%s]", sqlite3_errmsg(handle));
while (sqlite3_step(stmt) == SQLITE_ROW) {
- mc_playlist_s *_playlist = (mc_playlist_s *)calloc(1, sizeof(mc_playlist_s));
- if (_playlist == NULL) {
- mc_error("OUT_OF_MEMORY");
- SQLITE3_FINALIZE(stmt);
- return MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY;
- }
+ mc_playlist_s *_playlist = (mc_playlist_s *)g_new0(mc_playlist_s, 1);
_playlist->server_name = g_strdup(server_name);
_playlist->playlist_name = g_strdup((const char *)sqlite3_column_text(stmt, 0));
int _mc_db_get_playlist_by_name(sqlite3 *handle, mc_priv_type_e type, const char *controller_name, const char *playlist_name, mc_playlist_h *playlist)
{
- int ret = MEDIA_CONTROLLER_ERROR_NONE;
- gboolean is_exist = FALSE;
+ mc_playlist_s *_playlist = NULL;
mc_retvm_if(!controller_name, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid controller_name");
mc_retvm_if(!playlist_name, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid playlist_name");
mc_retvm_if(!playlist, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid playlist");
- is_exist = _mc_db_is_playlist_exist(handle, controller_name, playlist_name);
+ if (!_mc_db_is_playlist_exist(handle, controller_name, playlist_name)) {
+ mc_error("playlist is not exist");
+ return MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER;
+ }
- if (is_exist) {
- mc_playlist_s *_playlist = (mc_playlist_s *)calloc(1, sizeof(mc_playlist_s));
- if (_playlist != NULL) {
- _playlist->type = type;
- _playlist->server_name = g_strdup(controller_name);
- _playlist->playlist_name = g_strdup(playlist_name);
+ _playlist = g_new0(mc_playlist_s, 1);
- *playlist = (mc_playlist_h)_playlist;
+ _playlist->type = type;
+ _playlist->server_name = g_strdup(controller_name);
+ _playlist->playlist_name = g_strdup(playlist_name);
- ret = MEDIA_CONTROLLER_ERROR_NONE;
- } else {
- mc_error("OUT_OF_MEMORY");
- ret = MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY;
- }
- } else {
- mc_error("playlist is not exist");
- ret = MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER;
- }
+ *playlist = (mc_playlist_h)_playlist;
- return ret;
+ return MEDIA_CONTROLLER_ERROR_NONE;
}
int _mc_db_get_playlist_item_count(sqlite3 *handle, const char *server_name, char *playlist_name)
index = g_strdup((char *)sqlite3_column_text(stmt, 0));
if (callback(index, (mc_metadata_h)_metadata, user_data) == false) {
- MC_SAFE_FREE(index);
+ g_free(index);
mc_metadata_destroy((mc_metadata_h)_metadata);
break;
}
- MC_SAFE_FREE(index);
+ g_free(index);
mc_metadata_destroy(_metadata);
}
mc_info("[ * Activated Server List - Start * ]");
while (SQLITE_ROW == ret) {
- char *server_name = NULL;
- server_name = strdup((char *)sqlite3_column_text(stmt, 0));
+ char *server_name = g_strdup((char *)sqlite3_column_text(stmt, 0));
idx++;
mc_info("[%d] %s", idx, server_name);
if (callback != NULL) {
if (callback(server_name, user_data) == false) {
- MC_SAFE_FREE(server_name);
+ g_free(server_name);
break;
}
}
- MC_SAFE_FREE(server_name);
+ g_free(server_name);
ret = sqlite3_step(stmt);
}
mc_info("[ * Activated Client List - Start * ]");
while (SQLITE_ROW == ret) {
- char *client_name = NULL;
- client_name = strdup((char *)sqlite3_column_text(stmt, 0));
+ char *client_name = g_strdup((char *)sqlite3_column_text(stmt, 0));
idx++;
mc_info("[%d] %s", idx, client_name);
if (callback != NULL) {
if (callback(client_name, user_data) == false) {
- MC_SAFE_FREE(client_name);
+ g_free(client_name);
break;
}
}
- MC_SAFE_FREE(client_name);
+ g_free(client_name);
ret = sqlite3_step(stmt);
}
ret = __mc_db_update_db(MC_PRIV_TYPE_SERVER, sql_str);
- MC_SAFE_FREE(sql_str);
+ g_free(sql_str);
return ret;
}
ret = __mc_db_update_db(MC_PRIV_TYPE_SERVER, sql_str);
- MC_SAFE_FREE(sql_str);
+ g_free(sql_str);
return ret;
}
ret = __mc_db_update_db(MC_PRIV_TYPE_SERVER, sql_str);
- MC_SAFE_FREE(sql_str);
+ g_free(sql_str);
return ret;
}
ret = __mc_db_update_db(MC_PRIV_TYPE_SERVER, sql_str);
- MC_SAFE_FREE(sql_str);
+ g_free(sql_str);
return ret;
}
ret = __mc_db_update_db(MC_PRIV_TYPE_SERVER, sql_str);
- MC_SAFE_FREE(sql_str);
+ g_free(sql_str);
return ret;
}
mc_secure_error("listener[%s] not found", key);
}
- MC_SAFE_FREE(key);
+ g_free(key);
}
static void __free_dbus_listener(gpointer data)
return;
mc_debug("listener[%s] will be unregistered.", listener->key);
g_dbus_connection_signal_unsubscribe(listener->dbus_conn, listener->handler);
- MC_SAFE_G_FREE(listener->key);
- MC_SAFE_FREE(listener);
+ g_free(listener->key);
+ g_free(listener);
}
static gboolean __is_duplicated_dbus_listener(GList *listener_list, const char *key)
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;
+ mc_ipc_listener_s *listener = NULL;
mc_retvm_if(listener_list == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "listener_list is NULL");
mc_retvm_if(connection == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "connection is NULL");
if (__is_duplicated_dbus_listener(*listener_list, key)) {
mc_error("listener is duplicated");
- MC_SAFE_G_FREE(key);
+ g_free(key);
return MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER;
}
- mc_ipc_listener_s *listener = (mc_ipc_listener_s *)calloc(1, sizeof(mc_ipc_listener_s));
- if (listener == NULL) {
- mc_error("Error memroy allocation");
- MC_SAFE_G_FREE(key);
- return MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY;
- }
+ listener = g_new0(mc_ipc_listener_s, 1);
listener->dbus_conn = connection;
listener->callback = callback;
if (listener->handler == 0) {
mc_error("Error signal subscribe");
- MC_SAFE_G_FREE(key);
- MC_SAFE_FREE(listener);
+ g_free(key);
+ g_free(listener);
return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;
}
mc_debug("listener[%s.%s] is unregistered. listener_cnt[%d]", interface_name, signal_name, g_list_length(*listener_list));
- MC_SAFE_G_FREE(key);
+ g_free(key);
return MEDIA_CONTROLLER_ERROR_NONE;
}
ret = _mc_ipc_unregister_listener(listener_list, filter_interface, signal_name);
- MC_SAFE_G_FREE(filter_interface);
+ g_free(filter_interface);
return MEDIA_CONTROLLER_ERROR_NONE;
}
ret = _mc_ipc_send_message_to_server(MC_MSG_SERVER_CONNECTION, priv_type, app_id);
- MC_SAFE_FREE(app_id);
+ g_free(app_id);
return ret;
}
head_msg_size = sizeof(send_msg) - sizeof(send_msg.msg);
full_msg_size = head_msg_size + request_msg_size;
- temp_buf = (char *)calloc(1, full_msg_size + 1);
- if (temp_buf == NULL) {
- mc_error("Error memroy allocation");
- close(sockfd);
- return MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY;
- }
+ temp_buf = g_malloc0(full_msg_size + 1);
memcpy(temp_buf, &send_msg, head_msg_size);
memcpy(temp_buf + head_msg_size, request_msg, request_msg_size);
if (send_result < send_msg_size) {
mc_stderror("send failed");
close(sockfd);
- MC_SAFE_FREE(temp_buf);
+ g_free(temp_buf);
return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;
}
temp_buf_index += send_result;
send_msg_size = full_msg_size - temp_buf_index;
}
- MC_SAFE_FREE(temp_buf);
+ g_free(temp_buf);
/* Receive Response */
int recv_msg_size = -1;
switch (attribute) {
case MC_META_MEDIA_TITLE:
- MC_SAFE_FREE(_metadata->title);
+ g_free(_metadata->title);
_metadata->title = g_strdup(value);
break;
case MC_META_MEDIA_ARTIST:
- MC_SAFE_FREE(_metadata->artist);
+ g_free(_metadata->artist);
_metadata->artist = g_strdup(value);
break;
case MC_META_MEDIA_ALBUM:
- MC_SAFE_FREE(_metadata->album);
+ g_free(_metadata->album);
_metadata->album = g_strdup(value);
break;
case MC_META_MEDIA_AUTHOR:
- MC_SAFE_FREE(_metadata->author);
+ g_free(_metadata->author);
_metadata->author = g_strdup(value);
break;
case MC_META_MEDIA_GENRE:
- MC_SAFE_FREE(_metadata->genre);
+ g_free(_metadata->genre);
_metadata->genre = g_strdup(value);
break;
case MC_META_MEDIA_DURATION:
- MC_SAFE_FREE(_metadata->duration);
+ g_free(_metadata->duration);
_metadata->duration = g_strdup(value);
break;
case MC_META_MEDIA_DATE:
- MC_SAFE_FREE(_metadata->date);
+ g_free(_metadata->date);
_metadata->date = g_strdup(value);
break;
case MC_META_MEDIA_COPYRIGHT:
- MC_SAFE_FREE(_metadata->copyright);
+ g_free(_metadata->copyright);
_metadata->copyright = g_strdup(value);
break;
case MC_META_MEDIA_DESCRIPTION:
- MC_SAFE_FREE(_metadata->description);
+ g_free(_metadata->description);
_metadata->description = g_strdup(value);
break;
case MC_META_MEDIA_TRACK_NUM:
- MC_SAFE_FREE(_metadata->track_num);
+ g_free(_metadata->track_num);
_metadata->track_num = g_strdup(value);
break;
case MC_META_MEDIA_PICTURE:
- MC_SAFE_FREE(_metadata->picture);
+ g_free(_metadata->picture);
_metadata->picture = g_strdup(value);
break;
case MC_META_MEDIA_SEASON:
ret = _parse_encoded_meta(MC_META_MEDIA_SEASON, value, &int_val_1, &str_val, NULL);
mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "Invalid meta");
- MC_SAFE_FREE(str_val);
+ g_free(str_val);
- MC_SAFE_FREE(_metadata->season);
+ g_free(_metadata->season);
_metadata->season = g_strdup(value);
break;
case MC_META_MEDIA_EPISODE:
ret = _parse_encoded_meta(MC_META_MEDIA_EPISODE, value, &int_val_1, &str_val, NULL);
mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "Invalid meta");
- MC_SAFE_FREE(str_val);
+ g_free(str_val);
- MC_SAFE_FREE(_metadata->episode);
+ g_free(_metadata->episode);
_metadata->episode = g_strdup(value);
break;
case MC_META_MEDIA_RESOLUTION:
ret = _parse_encoded_meta(MC_META_MEDIA_RESOLUTION, value, &int_val_1, NULL, &int_val_2);
mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "Invalid meta");
- MC_SAFE_FREE(str_val);
+ g_free(str_val);
- MC_SAFE_FREE(_metadata->resolution);
+ g_free(_metadata->resolution);
_metadata->resolution = g_strdup(value);
break;
default:
{
int ret = MEDIA_CONTROLLER_ERROR_NONE;
media_controller_metadata_s *_src = (media_controller_metadata_s *)src;
+ media_controller_metadata_s *_dst = NULL;
mc_retvm_if(_src == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "invalid src");
mc_retvm_if(dst == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "invalid dst");
- media_controller_metadata_s *_dst = (media_controller_metadata_s*)calloc(1, sizeof(media_controller_metadata_s));
- mc_retvm_if(_dst == NULL, MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
+ _dst = g_new0(media_controller_metadata_s, 1);
_dst->title = g_strdup(_src->title);
_dst->artist = g_strdup(_src->artist);
mc_retvm_if(mc_metadata == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
- MC_SAFE_G_FREE(mc_metadata->title);
- MC_SAFE_G_FREE(mc_metadata->artist);
- MC_SAFE_G_FREE(mc_metadata->album);
- MC_SAFE_G_FREE(mc_metadata->author);
- MC_SAFE_G_FREE(mc_metadata->genre);
- MC_SAFE_G_FREE(mc_metadata->duration);
- MC_SAFE_G_FREE(mc_metadata->date);
- MC_SAFE_G_FREE(mc_metadata->copyright);
- MC_SAFE_G_FREE(mc_metadata->description);
- MC_SAFE_G_FREE(mc_metadata->track_num);
- MC_SAFE_G_FREE(mc_metadata->picture);
- MC_SAFE_G_FREE(mc_metadata->season);
- MC_SAFE_G_FREE(mc_metadata->episode);
- MC_SAFE_G_FREE(mc_metadata->resolution);
-
- MC_SAFE_FREE(mc_metadata);
+ g_free(mc_metadata->title);
+ g_free(mc_metadata->artist);
+ g_free(mc_metadata->album);
+ g_free(mc_metadata->author);
+ g_free(mc_metadata->genre);
+ g_free(mc_metadata->duration);
+ g_free(mc_metadata->date);
+ g_free(mc_metadata->copyright);
+ g_free(mc_metadata->description);
+ g_free(mc_metadata->track_num);
+ g_free(mc_metadata->picture);
+ g_free(mc_metadata->season);
+ g_free(mc_metadata->episode);
+ g_free(mc_metadata->resolution);
+
+ g_free(mc_metadata);
return MEDIA_CONTROLLER_ERROR_NONE;
}
switch (attribute) {
case MC_META_MEDIA_TITLE:
if (mc_metadata->title != NULL)
- meta_val = strdup(mc_metadata->title);
+ meta_val = g_strdup(mc_metadata->title);
break;
case MC_META_MEDIA_ARTIST:
if (mc_metadata->artist != NULL)
- meta_val = strdup(mc_metadata->artist);
+ meta_val = g_strdup(mc_metadata->artist);
break;
case MC_META_MEDIA_ALBUM:
if (mc_metadata->album != NULL)
- meta_val = strdup(mc_metadata->album);
+ meta_val = g_strdup(mc_metadata->album);
break;
case MC_META_MEDIA_AUTHOR:
if (mc_metadata->author != NULL)
- meta_val = strdup(mc_metadata->author);
+ meta_val = g_strdup(mc_metadata->author);
break;
case MC_META_MEDIA_GENRE:
if (mc_metadata->genre != NULL)
- meta_val = strdup(mc_metadata->genre);
+ meta_val = g_strdup(mc_metadata->genre);
break;
case MC_META_MEDIA_DURATION:
if (mc_metadata->duration != NULL)
- meta_val = strdup(mc_metadata->duration);
+ meta_val = g_strdup(mc_metadata->duration);
break;
case MC_META_MEDIA_DATE:
if (mc_metadata->date != NULL)
- meta_val = strdup(mc_metadata->date);
+ meta_val = g_strdup(mc_metadata->date);
break;
case MC_META_MEDIA_COPYRIGHT:
if (mc_metadata->copyright != NULL)
- meta_val = strdup(mc_metadata->copyright);
+ meta_val = g_strdup(mc_metadata->copyright);
break;
case MC_META_MEDIA_DESCRIPTION:
if (mc_metadata->description != NULL)
- meta_val = strdup(mc_metadata->description);
+ meta_val = g_strdup(mc_metadata->description);
break;
case MC_META_MEDIA_TRACK_NUM:
if (mc_metadata->track_num != NULL)
- meta_val = strdup(mc_metadata->track_num);
+ meta_val = g_strdup(mc_metadata->track_num);
break;
case MC_META_MEDIA_PICTURE:
if (mc_metadata->picture != NULL)
- meta_val = strdup(mc_metadata->picture);
+ meta_val = g_strdup(mc_metadata->picture);
break;
case MC_META_MEDIA_SEASON:
if (mc_metadata->season != NULL)
- meta_val = strdup(mc_metadata->season);
+ meta_val = g_strdup(mc_metadata->season);
break;
case MC_META_MEDIA_EPISODE:
if (mc_metadata->episode != NULL)
- meta_val = strdup(mc_metadata->episode);
+ meta_val = g_strdup(mc_metadata->episode);
break;
case MC_META_MEDIA_RESOLUTION:
if (mc_metadata->resolution != NULL)
- meta_val = strdup(mc_metadata->resolution);
+ meta_val = g_strdup(mc_metadata->resolution);
break;
default:
mc_error("Invalid Parameter [%d]", attribute);
{
int ret = MEDIA_CONTROLLER_ERROR_NONE;
media_controller_ability_s *_src = (media_controller_ability_s *)src;
+ media_controller_ability_s *_dst = NULL;
mc_retvm_if(_src == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "invalid src");
mc_retvm_if(dst == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "invalid dst");
- media_controller_ability_s *_dst = (media_controller_ability_s*)calloc(1, sizeof(media_controller_ability_s));
- mc_retvm_if(_dst == NULL, MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
+ _dst = g_new0(media_controller_ability_s, 1);
_dst->decided = _src->decided;
_dst->supported = _src->supported;
mc_retvm_if(mc_ability == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
- MC_SAFE_FREE(mc_ability);
+ g_free(mc_ability);
return MEDIA_CONTROLLER_ERROR_NONE;
}
{
mc_search_item_s *search_item = (mc_search_item_s*)data;
- if (search_item) {
- MC_SAFE_FREE(search_item->search_keyword);
- if (search_item->data)
- bundle_free(search_item->data);
- MC_SAFE_FREE(search_item);
- }
+ if (!search_item)
+ return;
+
+ bundle_free(search_item->data);
+ g_free(search_item->search_keyword);
+ g_free(search_item);
}
int mc_search_create(mc_search_h *search)
media_controller_search_s *mc_search = NULL;
mc_retvm_if(search == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "search is NULL");
- mc_search = (media_controller_search_s *)calloc(1, sizeof(media_controller_search_s));
- mc_retvm_if(mc_search == NULL, MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY, "Error allocation memory");
+ mc_search = (media_controller_search_s *)g_new0(media_controller_search_s, 1);
*search = (mc_search_h)mc_search;
{
int ret = MEDIA_CONTROLLER_ERROR_NONE;
media_controller_search_s *mc_search = (media_controller_search_s *)search;
+ mc_search_item_s *search_item = NULL;
mc_retvm_if(mc_search == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "search is NULL");
mc_retvm_if(((content_type < MC_CONTENT_TYPE_IMAGE) || (content_type > MC_CONTENT_TYPE_UNDECIDED)), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "content_type is invalid [%d]", content_type);
mc_retvm_if(g_list_length(mc_search->search_list) > 20, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Too many search items");
- mc_search_item_s *search_item = (mc_search_item_s*)calloc(1, sizeof(mc_search_item_s));
- mc_retvm_if(search_item == NULL, MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
+ search_item = g_new0(mc_search_item_s, 1);
search_item->content_type = content_type;
search_item->category = category;
mc_retvm_if(mc_search == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "search is NULL");
g_list_free_full(mc_search->search_list, __destroy_search_list);
- mc_search->search_list = NULL;
-
- MC_SAFE_FREE(mc_search);
+ g_free(mc_search);
return ret;
}
else
_meta = g_strdup_printf("%s%s%d%s", KEY_SEASON, MC_STRING_DELIMITER, season_num, MC_STRING_DELIMITER);
- mc_retvm_if(_meta == NULL, MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY, "Out of memory");
-
_encoded_meta = g_base64_encode((const guchar *)_meta, strlen(_meta));
*encoded_season = _encoded_meta;
- MC_SAFE_G_FREE(_meta);
+ g_free(_meta);
return MEDIA_CONTROLLER_ERROR_NONE;
}
else
_meta = g_strdup_printf("%s%s%d%s", KEY_EPISODE, MC_STRING_DELIMITER, episode_num, MC_STRING_DELIMITER);
- mc_retvm_if(_meta == NULL, MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY, "Out of memory");
-
_encoded_meta = g_base64_encode((const guchar *)_meta, strlen(_meta));
*encoded_episode = _encoded_meta;
- MC_SAFE_G_FREE(_meta);
+ g_free(_meta);
return MEDIA_CONTROLLER_ERROR_NONE;
}
mc_retvm_if(encoded_resolution == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "invalid resolution");
_meta = g_strdup_printf("%s%s%d%s%d", KEY_RESOLUTION, MC_STRING_DELIMITER, width, MC_STRING_DELIMITER, height);
- mc_retvm_if(_meta == NULL, MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY, "Out of memory");
_encoded_meta = g_base64_encode((const guchar *)_meta, strlen(_meta));
*encoded_resolution = _encoded_meta;
- MC_SAFE_G_FREE(_meta);
+ g_free(_meta);
return MEDIA_CONTROLLER_ERROR_NONE;
}
mc_retvm_if(_decoded_meta == NULL, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "decoding fail");
params = g_strsplit((const gchar *)_decoded_meta, MC_STRING_DELIMITER, 0);
- MC_SAFE_G_FREE(_decoded_meta);
+ g_free(_decoded_meta);
mc_retvm_if(params == NULL, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "parsing fail");
if ((params[0] == NULL) || (params[1] == NULL) || (params[2] == NULL)) {
media_controller_metadata_s *metadata;
} mc_playlist_item_s;
-static void __release_playlist_item(mc_playlist_item_s *playlist_item)
+static void __release_playlist_item(gpointer data)
{
- mc_retm_if(playlist_item == NULL, "invalid playlist_item");
+ mc_playlist_item_s *playlist_item = (mc_playlist_item_s *)data;
+ mc_retm_if(!playlist_item, "invalid playlist_item");
- MC_SAFE_FREE(playlist_item->index);
+ g_free(playlist_item->index);
mc_metadata_destroy((mc_metadata_h)playlist_item->metadata);
- MC_SAFE_FREE(playlist_item);
-}
-
-static void __item_destroy(gpointer data)
-{
- mc_playlist_item_s *item = (mc_playlist_item_s *)data;
-
- if (item)
- __release_playlist_item(item);
+ g_free(playlist_item);
}
static gint __compare_playlist_index(gconstpointer data, gconstpointer user_data)
if (meta) {
ret = bundle_add_str(bundle, item->index, meta);
- MC_SAFE_G_FREE(meta);
+ g_free(meta);
if (ret != BUNDLE_ERROR_NONE)
mc_error("fail to bundle_add_str[%p]", iter->data);
}
if (_playlist->item_list != NULL) {
ret = __get_bundle_data(_playlist->item_list, &bundle_data, &bundle_size);
- g_list_free_full(_playlist->item_list, __item_destroy);
+ g_list_free_full(_playlist->item_list, __release_playlist_item);
_playlist->item_list = NULL;
mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "__get_bundle_data failed");
int mc_playlist_create(const char *playlist_name, mc_playlist_h *playlist)
{
+ mc_playlist_s *_playlist = NULL;
+
mc_retvm_if(!MC_STRING_VALID(playlist_name), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "invalid playlist_name");
mc_retvm_if(playlist == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "invalid playlist");
- mc_playlist_s *_playlist = (mc_playlist_s*)calloc(1, sizeof(mc_playlist_s));
- mc_retvm_if(_playlist == NULL, MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
+ _playlist = g_new0(mc_playlist_s, 1);
_playlist->playlist_name = g_strdup(playlist_name);
found_item = g_list_find_custom(_playlist->item_list, (void *)index, __compare_playlist_index);
if (!found_item) {
- _playlist_item = (mc_playlist_item_s*)calloc(1, sizeof(mc_playlist_item_s));
- mc_retvm_if(_playlist_item == NULL, MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY, "memory alloc fail");
-
- _playlist_item->metadata = (media_controller_metadata_s*)calloc(1, sizeof(media_controller_metadata_s));
- if (_playlist_item->metadata == NULL) {
- mc_error("memory alloc fail");
- MC_SAFE_FREE(_playlist_item);
- return MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY;
- }
+ _playlist_item = g_new0(mc_playlist_item_s, 1);
+ _playlist_item->metadata = g_new0(media_controller_metadata_s, 1);
_playlist_item->index = g_strdup(index);
} else {
_playlist_item = (mc_playlist_item_s *)found_item->data;
{
int ret = MEDIA_CONTROLLER_ERROR_NONE;
mc_playlist_s *_src = (mc_playlist_s*)src;
+ mc_playlist_s *_dst = NULL;
mc_retvm_if(_src == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "invalid src");
mc_retvm_if(dst == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "invalid dst");
- mc_playlist_s *_dst = (mc_playlist_s*)calloc(1, sizeof(mc_playlist_s));
- mc_retvm_if(_dst == NULL, MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
+ _dst = (mc_playlist_s*)g_new0(mc_playlist_s, 1);
_dst->server_name = g_strdup(_src->server_name);
_dst->playlist_name = g_strdup(_src->playlist_name);
mc_retvm_if(_playlist == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "invalid playlist");
- MC_SAFE_FREE(_playlist->server_name);
- MC_SAFE_FREE(_playlist->playlist_name);
- g_list_free_full(_playlist->item_list, __item_destroy);
- MC_SAFE_FREE(_playlist);
+ g_free(_playlist->server_name);
+ g_free(_playlist->playlist_name);
+ g_list_free_full(_playlist->item_list, __release_playlist_item);
+ g_free(_playlist);
return ret;
}
mc_retvm_if(mc_server == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
- _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");
+ _server = g_new0(media_controller_server_s, 1);
ret = _mc_util_get_own_name(&(_server->server_name));
if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
_server->playback.index = NULL;
_server->playback.content_type = MC_CONTENT_TYPE_UNDECIDED;
- _server->metadata = (media_controller_metadata_s *)calloc(1, sizeof(media_controller_metadata_s));
- if (_server->metadata == NULL) {
- mc_error("Error allocation memory");
- ret = MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY;
- goto ERROR;
- }
+ _server->metadata = g_new0(media_controller_metadata_s, 1);
_server->basic_ability.decided = (unsigned long)MC_BIT64_UNSET;
_server->basic_ability.supported = (unsigned long)MC_BIT64_UNSET;
if (_server->db_handle)
mc_db_disconnect(_server->db_handle);
- MC_SAFE_FREE(_server->server_name);
- MC_SAFE_FREE(_server->metadata);
- MC_SAFE_FREE(_server);
+ g_free(_server->server_name);
+ g_free(_server->metadata);
+ g_free(_server);
return ret;
}
if (mc_server->listeners != NULL)
g_list_free(mc_server->listeners);
- MC_SAFE_FREE(mc_server->server_name);
+ g_free(mc_server->server_name);
- if (mc_server->metadata != NULL)
- mc_metadata_destroy(mc_server->metadata);
+ mc_metadata_destroy(mc_server->metadata);
- MC_SAFE_FREE(mc_server->playback.index);
- MC_SAFE_FREE(mc_server);
+ g_free(mc_server->playback.index);
+ g_free(mc_server);
return ret;
}
mc_retm_if(params == NULL, "invalid custom data");
if (params[0])
- sender = strdup(params[0]);
+ sender = g_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_free(sender);
g_strfreev(params);
return;
}
- command = strdup(params[1]);
+ command = g_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_free(sender);
+ g_free(command);
g_strfreev(params);
}
int bundle_size = 0;
bundle *bundle_data = NULL;
GList **mc_search = (GList**)user_data;
+ mc_search_item_s *search_item = NULL;
bundle_keyval_get_basic_val((bundle_keyval_t *)kv, &basic_val, &basic_size);
g_strfreev(params);
- mc_search_item_s *search_item = (mc_search_item_s*)calloc(1, sizeof(mc_search_item_s));
- if (search_item == NULL) {
- mc_error("Error OUT_OF_MEMORY");
- MC_SAFE_FREE(keyword);
- bundle_free(bundle_data);
- return;
- }
+ search_item = g_new0(mc_search_item_s, 1);
search_item->content_type = content_type;
search_item->category = category;
search_item->search_keyword = keyword;
- search_item->data = bundle_dup(bundle_data);
-
- if (bundle_data != NULL)
- bundle_free(bundle_data);
+ search_item->data = bundle_data;
*mc_search = g_list_append(*mc_search, search_item);
}
return;
}
- mc_search = (media_controller_search_s *)calloc(1, sizeof(media_controller_search_s));
- if (mc_search == NULL) {
- mc_error("Error allocation memory");
- g_strfreev(params);
- bundle_free(bundle_data);
- return;
- }
+ mc_search = g_new0(media_controller_search_s, 1);
bundle_foreach(bundle_data, __search_cb, &mc_search->search_list);
mc_error("Error _mc_ipc_send_message [%d]", ret);
}
- MC_SAFE_G_FREE(filter_interface_name);
- MC_SAFE_G_FREE(message);
+ g_free(filter_interface_name);
+ g_free(message);
return ret;
}
if (ret != MEDIA_CONTROLLER_ERROR_NONE)
mc_error("Error _mc_ipc_send_message [%d]", ret);
- MC_SAFE_G_FREE(interface_name);
+ g_free(interface_name);
return ret;
}
mc_debug("index update [%s]", index);
- MC_SAFE_FREE(mc_server->playback.index);
+ g_free(mc_server->playback.index);
mc_server->playback.index = g_strdup(index);
- if (mc_server->playback.index == NULL) {
- mc_error("Fail to set playlist item index");
- return MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY;
- }
-
return MEDIA_CONTROLLER_ERROR_NONE;
}
mc_retvm_if(strlen(playlist_name) > MAX_INPUT_STR_LEN, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Playlist_name is too long. The length of the playlist name should be less than %d byte", MAX_INPUT_STR_LEN);
mc_retvm_if(!MC_STRING_VALID(index), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid index");
- MC_SAFE_FREE(mc_server->playback.playlist_name);
- MC_SAFE_FREE(mc_server->playback.index);
+ g_free(mc_server->playback.playlist_name);
+ g_free(mc_server->playback.index);
mc_server->playback.playlist_name = g_strdup(playlist_name);
mc_server->playback.index = g_strdup(index);
- if ((mc_server->playback.playlist_name == NULL) || (mc_server->playback.index == NULL)) {
- mc_error("Fail to set playlist item info");
- MC_SAFE_FREE(mc_server->playback.playlist_name);
- MC_SAFE_FREE(mc_server->playback.index);
- return MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY;
- }
-
return MEDIA_CONTROLLER_ERROR_NONE;
}
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);
+ g_free(interface_name);
return ret;
}
mc_server->updated_cb[event].callback = NULL;
mc_server->updated_cb[event].user_data = NULL;
- MC_SAFE_FREE(interface_name);
+ g_free(interface_name);
return ret;
}
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);
+ 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);
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);
+ g_free(message);
+ g_free(interface_name);
return ret;
}
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_SAFE_G_FREE(bundle_str);
+ g_free(bundle_str);
mc_retvm_if(message == NULL, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "Error when making message");
ret = __mc_server_send_event(server, client_name, MC_EVENT_CUSTOM, event, MC_DBUS_SIGNAL_NAME_CUSTOM_EVENT, message, request_id);
- MC_SAFE_G_FREE(message);
+ g_free(message);
return ret;
}
mc_retm_if(params == NULL, "invalid custom data");
if (params[0])
- sender = strdup(params[0]);
+ sender = g_strdup(params[0]);
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_free(sender);
g_strfreev(params);
return;
}
- command = strdup(params[1]);
+ command = g_strdup(params[1]);
enc_size = atoi(params[2]);
if (enc_size > 0)
bundle_data = bundle_decode((bundle_raw *)params[3], enc_size);
callback(sender, command, bundle_data, receiver->user_data);
- MC_SAFE_FREE(sender);
- MC_SAFE_FREE(command);
+ g_free(sender);
+ g_free(command);
g_strfreev(params);
}
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);
+ 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);
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);
+ g_free(message);
+ g_free(interface_name);
return ret;
}
temp = g_strdup_printf("%s.%s%s", MC_DBUS_INTERFACE_PREFIX, type, name);
__mc_util_check_valid_name(temp, &interface_name);
- MC_SAFE_G_FREE(temp);
+ g_free(temp);
return interface_name;
}
temp = g_strdup_printf("%s.server%s", prefix, filter);
- if (temp == NULL) {
- mc_error("Fail to make interface_name");
- return MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY;
- }
-
__mc_util_check_valid_name(temp, interface_name);
- MC_SAFE_G_FREE(temp);
+ g_free(temp);
return MEDIA_CONTROLLER_ERROR_NONE;
}
ret = _mc_ipc_send_message_to_server(msg_type, priv_type, message);
- MC_SAFE_G_FREE(message);
+ g_free(message);
return ret;
}
else
*str_data = g_strdup_printf("%d%s%s", size_r, MC_STRING_DELIMITER, (unsigned char *)raw_data);
- if (*str_data == NULL)
- ret = MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY;
-
MC_SAFE_FREE(raw_data);
return ret;
size_t msg_index = 0;
char *recv_buf = NULL;
- recv_buf = (char *)calloc(1, MAX_MSG_SIZE + 1);
- recv_msg->msg = (char *)calloc(1, recv_msg->msg_size + 1);
-
- if (recv_buf == NULL || recv_msg->msg == NULL) {
- mc_error("Error memroy allocation");
- MC_SAFE_FREE(recv_buf);
- MC_SAFE_FREE(recv_msg->msg);
- return MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY;
- }
+ recv_buf = g_malloc0(MAX_MSG_SIZE + 1);
+ recv_msg->msg = g_malloc0(recv_msg->msg_size + 1);
while (remain_size > 0) {
memset(recv_buf, 0, MAX_MSG_SIZE + 1);
block_size = MAX_MSG_SIZE;
if ((recv_msg_size = read(sockfd, recv_buf, block_size)) < block_size) {
- MC_SAFE_FREE(recv_buf);
- MC_SAFE_FREE(recv_msg->msg);
+ g_free(recv_buf);
+ g_free(recv_msg->msg);
if (errno == EWOULDBLOCK) {
mc_error("Timeout. Can't try any more");
return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;
remain_size -= recv_msg_size;
}
- MC_SAFE_FREE(recv_buf);
+ g_free(recv_buf);
} else {
mc_error("wrong msg_size [%zu]", recv_msg->msg_size);
recv_msg->msg = NULL;
else
ret = sqlite3_open_v2(db_path, &db_handle, SQLITE_OPEN_READONLY, NULL);
- MC_SAFE_G_FREE(db_path);
+ g_free(db_path);
mc_retvm_if(SQLITE_OK != ret, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "error when db open");
mc_retvm_if(db_handle == NULL, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "db_handle is NULL");
mc_retvm_if(db_path == NULL, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "error when get db path");
db_file = g_file_new_for_path(db_path);
- MC_SAFE_G_FREE(db_path);
+ g_free(db_path);
mc_retvm_if(db_file == NULL, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "could not open file");
result = g_file_delete(db_file, NULL, &g_error);
static void __mc_destroy_queue(gpointer data)
{
mc_service_request *req = (mc_service_request *)data;
- if (req != NULL) {
- if (req->req_msg != NULL)
- MC_SAFE_FREE(req->req_msg->msg);
- MC_SAFE_FREE(req->req_msg);
- MC_SAFE_FREE(req);
- }
+ mc_retm_if(!req, "invalid request");
+
+ if (req->req_msg)
+ g_free(req->req_msg->msg);
+ g_free(req->req_msg);
+ g_free(req);
}
static void __mc_destroy_connected_apps(gpointer data)
g_list_free_full(_app_data->cmds_to_send, g_free);
_app_data->cmds_to_send = NULL;
}
- MC_SAFE_FREE(_app_data->app_id);
- MC_SAFE_FREE(_app_data);
-}
-
-static int __mc_create_request_queue(mc_manage_queue_t **data)
-{
- mc_manage_queue_t *_request = (mc_manage_queue_t *)calloc(1, sizeof(mc_manage_queue_t));
- mc_retvm_if(!_request, MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY, "Failed to create queue manager");
-
- _request->queue = g_queue_new();
-
- if (!_request->queue) {
- mc_error("Failed to create new queue");
- MC_SAFE_FREE(_request);
- return MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY;
- }
-
- *data = _request;
-
- return MEDIA_CONTROLLER_ERROR_NONE;
+ g_free(_app_data->app_id);
+ g_free(_app_data);
}
static void __mc_destroy_request_queue(mc_manage_queue_t *data)
{
mc_retm_if(!data, "invalid data");
- if (data->queue) {
- g_queue_free_full(data->queue, __mc_destroy_queue);
- data->queue = NULL;
- }
- if (data->source) {
- g_source_unref(data->source);
- data->source = NULL;
- }
- MC_SAFE_FREE(data);
+ g_queue_free_full(data->queue, __mc_destroy_queue);
+ data->queue = NULL;
+
+ g_source_unref(data->source);
+ data->source = NULL;
+
+ g_free(data);
}
static void __mc_add_cmd_to_send(gpointer data, gpointer user_data)
static int __mc_list_remove_item(GList **list, int index)
{
+ GList *found = NULL;
+
mc_retvm_if(list == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "invalid list");
mc_retvm_if(index < 0 || index >= (int)g_list_length(*list), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "invalid index");
mc_secure_error("[No-error] index : %d", index);
- mc_app_data_set_t *app_data = g_list_nth_data(*list, index);
- if (app_data != NULL) {
- *list = g_list_remove(*list, app_data);
- MC_SAFE_FREE(app_data->app_id);
- if (app_data->cmds_to_send) {
- mc_secure_error("[No-error] cmd_to_send length [%u]", g_list_length(app_data->cmds_to_send));
- g_list_free_full(app_data->cmds_to_send, g_free);
- }
- MC_SAFE_FREE(app_data);
- mc_secure_error("[No-error] cmd_to_send has been removed");
+ found = g_list_nth(*list, index);
+
+ if (!found) {
+ mc_secure_debug("app_data has been already removed.");
+ return MEDIA_CONTROLLER_ERROR_NONE;
}
+ *list = g_list_remove_link(*list, found);
+ g_list_free_full(found, __mc_destroy_connected_apps);
+
return MEDIA_CONTROLLER_ERROR_NONE;
}
-static int __mc_service_init(mc_service_t **data)
+static void __mc_service_init(mc_service_t **data)
{
- int res = MEDIA_CONTROLLER_ERROR_NONE;
- mc_service_t *_service_data = (mc_service_t *)calloc(1, sizeof(mc_service_t));
- mc_retvm_if(!_service_data, MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY, "Failed to allocate service data");
+ mc_service_t *_service_data = g_new0(mc_service_t, 1);
- res = __mc_create_request_queue(&(_service_data->request));
- if (res != MEDIA_CONTROLLER_ERROR_NONE) {
- mc_error("Failed to create queue data");
- MC_SAFE_FREE(_service_data);
- return MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY;
- }
+ _service_data->request = g_new0(mc_manage_queue_t, 1);
+ _service_data->request->queue = g_queue_new();
*data = _service_data;
-
- return MEDIA_CONTROLLER_ERROR_NONE;
}
static void __mc_service_deinit(mc_service_t *data)
{
- if (data != NULL) {
- if (data->request != NULL)
- __mc_destroy_request_queue(data->request);
- if (data->connected_apps != NULL)
- g_list_free_full(data->connected_apps, __mc_destroy_connected_apps);
- MC_SAFE_FREE(data);
- }
+ if (!data)
+ return;
+
+ if (data->request != NULL)
+ __mc_destroy_request_queue(data->request);
+ if (data->connected_apps != NULL)
+ g_list_free_full(data->connected_apps, __mc_destroy_connected_apps);
+
+ g_free(data);
}
static int __mc_service_check_db(uid_t uid)
/* Check the database exists */
if (!g_file_test(db_path, G_FILE_TEST_EXISTS)) {
mc_error("[NO-ERROR] DB is not created yet, do not need to check DB");
- MC_SAFE_G_FREE(db_path);
+ g_free(db_path);
return MEDIA_CONTROLLER_ERROR_NONE;
}
if (stat(db_path, &buf) == 0) {
if (buf.st_size == 0) {
mc_warning("The size of database is error");
- MC_SAFE_G_FREE(db_path);
+ g_free(db_path);
return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;
}
} else {
mc_stderror("stat failed");
- MC_SAFE_G_FREE(db_path);
+ g_free(db_path);
return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;
}
- MC_SAFE_G_FREE(db_path);
+ g_free(db_path);
/* Connect media controller DB*/
res = mc_db_connect(&db_handle, uid, TRUE);
if (res != MEDIA_CONTROLLER_ERROR_NONE)
mc_error("mc_db_util_migration failed [%d]", res);
- MC_SAFE_FREE(latest_server_name);
+ g_free(latest_server_name);
}
}
return MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER;
}
- _app_data = (mc_app_data_set_t *)calloc(1, sizeof(mc_app_data_set_t));
- mc_retvm_if(!_app_data, MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY, "memory allocation is failed");
+ _app_data = g_new0(mc_app_data_set_t, 1);
_app_data->uid = request_msg->uid;
_app_data->pid = request_msg->pid;
static int __mc_service_remove_cmd_to_send(GList **connected_list, mc_comm_msg_s *request_msg)
{
- mc_list_user_data *user_data = calloc(1, sizeof(mc_list_user_data));
- mc_retvm_if(!user_data, MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY, "memory allocation is failed");
+ int ret = MEDIA_CONTROLLER_ERROR_NONE;
+ mc_list_user_data *user_data = g_new0(mc_list_user_data, 1);
user_data->message = request_msg;
user_data->result = 0;
g_list_foreach(*connected_list, __mc_remove_cmd_to_send, user_data);
mc_debug("user_data->result : %d", user_data->result);
- if (user_data->result > 0) {
- MC_SAFE_FREE(user_data);
- return MEDIA_CONTROLLER_ERROR_NONE;
- } else {
- MC_SAFE_FREE(user_data);
- return MEDIA_CONTROLLER_ERROR_PERMISSION_DENIED;
- }
+ if (user_data->result == 0)
+ ret = MEDIA_CONTROLLER_ERROR_PERMISSION_DENIED;
+
+ g_free(user_data);
+ return ret;
}
static int __mc_notify_server_updated(const char *server_name, mc_server_state_e state)
}
message = g_strdup_printf("%s%s%d", server_name, MC_STRING_DELIMITER, state);
- if (message == NULL) {
- mc_secure_error("Error in message generation");
- g_object_unref(bus);
- return MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY;
- }
/* Send the signal */
emmiting = g_dbus_connection_emit_signal(
mc_secure_error("Failed to emit gdbus signal : %s", error ? error->message : "none");
g_error_free(error);
g_object_unref(bus);
- MC_SAFE_G_FREE(message);
+ g_free(message);
return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;
}
g_object_unref(bus);
- MC_SAFE_G_FREE(message);
+ g_free(message);
return MEDIA_CONTROLLER_ERROR_NONE;
}
if (close(req->client_sock) < 0)
mc_stderror("close failed");
- if (req->req_msg != NULL)
- MC_SAFE_FREE(req->req_msg->msg);
- MC_SAFE_FREE(req->req_msg);
- MC_SAFE_FREE(req);
+ __mc_destroy_queue(req);
return G_SOURCE_CONTINUE;
}
mc_peer_creds creds;
memset(&creds, 0x00, sizeof(mc_peer_creds));
- req = (mc_service_request *) calloc(1, sizeof(mc_service_request));
- if (req == NULL) {
- mc_error("memory allocation is failed");
- send_msg = MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY;
- goto ERROR;
- }
-
- req->req_msg = (mc_comm_msg_s *) calloc(1, sizeof(mc_comm_msg_s));
- if (req->req_msg == NULL) {
- mc_error("memory allocation is failed");
- send_msg = MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY;
- goto ERROR;
- }
+ req = g_new0(mc_service_request, 1);
+ req->req_msg = g_new0(mc_comm_msg_s, 1);
req->client_sock = client_sock;
ret = mc_cynara_receive_untrusted_message(req->client_sock, req->req_msg, &creds);
if (close(client_sock) < 0)
mc_stderror("close failed");
- if (req != NULL) {
- if (req->req_msg != NULL)
- MC_SAFE_FREE(req->req_msg->msg);
- MC_SAFE_FREE(req->req_msg);
- MC_SAFE_FREE(req);
- }
+ __mc_destroy_queue(req);
+
MC_SAFE_FREE(creds.uid);
MC_SAFE_FREE(creds.smack);
mc_debug_fenter();
/* Init data */
- ret = __mc_service_init(&mc_service_data);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- mc_error("Failed to create data");
- __mc_service_deinit(mc_service_data);
- return NULL;
- }
+ __mc_service_init(&mc_service_data);
/* Get uid for login user */
ret = __mc_sys_get_uid(&uid);
mc_debug("metadata [%d] value is NULL\n", idx);
}
- MC_SAFE_FREE(str_val);
- MC_SAFE_FREE(value);
+ g_free(str_val);
+ g_free(value);
}
}
mc_debug("[Client:%s] Playback updated from server[%s] playback_state[%d] position[%lld] playlist_name [%s] index[%s] content_type[%d] age_rating[%d]",
_client->client_name, server_name, playback_state, position, playlist_name, index, content_type, age_rating);
- MC_SAFE_FREE(playlist_name);
- MC_SAFE_FREE(index);
+ g_free(playlist_name);
+ g_free(index);
}
void _mc_metadata_updated_cb(const char *server_name, mc_metadata_h metadata, void *user_data)
mc_debug("playlist_name [%s]", _name);
- MC_SAFE_FREE(_name);
+ g_free(_name);
ret = mc_playlist_get_item_count(playlist, &_item_cnt);
if (ret != MEDIA_CONTROLLER_ERROR_NONE)
for (i = 0; i < TEST_REQ_MAX; i++) {
if ((g_request_id[i] != NULL) && (strcmp(request_id, g_request_id[i]) == 0)) {
found = 1;
- find_request_id = strdup(g_request_id[i]);
- MC_SAFE_FREE(g_request_id[i]);
+ find_request_id = g_strdup(g_request_id[i]);
+ g_free(g_request_id[i]);
break;
}
}
mc_error("[Client:%s] Reply result code[%d] from server[%s]", _client->client_name, result_code, server_name);
}
- MC_SAFE_FREE(find_request_id);
+ g_free(find_request_id);
}
return false;
}
- MC_SAFE_FREE(g_playlist_name);
+ g_free(g_playlist_name);
ret = mc_playlist_get_name(playlist, &g_playlist_name);
if (ret != MEDIA_CONTROLLER_ERROR_NONE)
mc_error("Fail to mc_playlist_get_name [%d]", ret);
g_print("playback state [%d], position [%lld], playlist_name [%s], index [%s], content_type[%d]", playback_state, playback_position, playlist_name, index, content_type);
- MC_SAFE_FREE(playlist_name);
- MC_SAFE_FREE(index);
+ g_free(playlist_name);
+ g_free(index);
ret = mc_client_destroy_playback(playback);
mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, FALSE, "Fail to mc_client_destroy_playback [%d]", ret);
mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, FALSE, "Fail to mc_client_get_server_icon [%d]", ret);
g_print("icon url: %s \n", icon_url);
- MC_SAFE_FREE(icon_url);
+ g_free(icon_url);
ret = mc_client_get_server_subtitles_enabled(g_mc_client, g_server_name, &b_value);
mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, FALSE, "Fail to mc_client_get_server_subtitles_enabled [%d]", ret);
g_mc_client = NULL;
- MC_SAFE_FREE(g_server_name);
- MC_SAFE_FREE(g_playlist_name);
+ g_free(g_server_name);
+ g_free(g_playlist_name);
mc_debug_fleave();
mc_debug("metadata [%d] value is NULL", idx);
}
- MC_SAFE_FREE(str_val);
- MC_SAFE_FREE(value);
+ g_free(str_val);
+ g_free(value);
}
}
if (ret != MEDIA_CONTROLLER_ERROR_NONE)
mc_error("Fail to mc_playlist_foreach_item [%d]", ret);
- MC_SAFE_FREE(playlist_name);
+ g_free(playlist_name);
return true;
}
mc_server_add_item_to_playlist(server, playlist_1, "1", MC_META_MEDIA_EPISODE, episode);
mc_server_add_item_to_playlist(server, playlist_1, "1", MC_META_MEDIA_RESOLUTION, resolution);
- MC_SAFE_FREE(season);
- MC_SAFE_FREE(episode);
- MC_SAFE_FREE(resolution);
+ g_free(season);
+ g_free(episode);
+ g_free(resolution);
ret = mc_metadata_encode_season(2, NULL, &season);
ret = mc_metadata_encode_episode(2, NULL, &episode);
mc_server_add_item_to_playlist(server, playlist_1, "2", MC_META_MEDIA_EPISODE, episode);
mc_server_add_item_to_playlist(server, playlist_1, "2", MC_META_MEDIA_RESOLUTION, resolution);
- MC_SAFE_FREE(season);
- MC_SAFE_FREE(episode);
- MC_SAFE_FREE(resolution);
+ g_free(season);
+ g_free(episode);
+ g_free(resolution);
for (idx = 3; idx < 100; idx++) {
char idx_str[255] = {0,};
mc_debug("playlist_name [%s]", playlist_name);
- MC_SAFE_FREE(playlist_name);
+ g_free(playlist_name);
mc_server_add_item_to_playlist(server, playlist_1, "100", MC_META_MEDIA_PICTURE, "picture_100");
ret = mc_server_update_playlist_done(server, playlist_1);
mc_debug("Remove playlist [%s]", playlist_name);
- MC_SAFE_FREE(playlist_name);
+ g_free(playlist_name);
ret = mc_server_delete_playlist(server, playlist);
if (ret != MEDIA_CONTROLLER_ERROR_NONE)
ret = mc_server_set_metadata(g_mc_server, MC_META_MEDIA_EPISODE, episode);
ret = mc_server_set_metadata(g_mc_server, MC_META_MEDIA_RESOLUTION, resolution);
- MC_SAFE_FREE(season);
- MC_SAFE_FREE(episode);
- MC_SAFE_FREE(resolution);
+ g_free(season);
+ g_free(episode);
+ g_free(resolution);
ret = mc_server_update_metadata(g_mc_server);
if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
projects / platform / core / api / media-controller.git / commitdiff