[ACR-1777] Deprecate unused APIs
[platform/core/api/media-content.git] / src / media_uhd.c
index 39d9ef9..b9d7858 100755 (executable)
 
 int media_uhd_get_media_count_from_db(filter_h filter, int *media_count)
 {
-       int ret = MEDIA_CONTENT_ERROR_NONE;
+       content_retip_if_fail(media_count);
 
-       if (media_count) {
-               ret = _media_db_get_group_item_count(NULL, filter, MEDIA_GROUP_UHD, media_count);
-       } else {
-               media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-               return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-       }
-
-       return ret;
+       return _media_db_get_group_item_count(NULL, filter, MEDIA_GROUP_UHD, media_count);
 }
 
 int media_uhd_foreach_media_from_db(filter_h filter, media_uhd_cb callback, void *user_data)
 {
-       int ret = MEDIA_CONTENT_ERROR_NONE;
-
-       if (callback != NULL) {
-               ret = _media_db_get_uhd(filter, callback, user_data);
-       } else {
-               media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-               return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-       }
+       content_retip_if_fail(callback);
 
-       return ret;
+       return _media_db_get_uhd(filter, callback, user_data);
 }
 
 int media_uhd_destroy(media_uhd_h uhd)
 {
-       int ret = MEDIA_CONTENT_ERROR_NONE;
        media_uhd_s *_uhd = (media_uhd_s*)uhd;
-       if (_uhd) {
-               SAFE_FREE(_uhd->media_id);
-               SAFE_FREE(_uhd->storage_id);
-               SAFE_FREE(_uhd->path);
-               SAFE_FREE(_uhd->content_id);
-               SAFE_FREE(_uhd->content_title);
-               SAFE_FREE(_uhd->file_name);
-               SAFE_FREE(_uhd->release_date);
-               SAFE_FREE(_uhd);
-
-               ret = MEDIA_CONTENT_ERROR_NONE;
-       } else {
-               media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-               ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-       }
 
-       return ret;
+       content_retip_if_fail(uhd);
+
+       g_free(_uhd->media_id);
+       g_free(_uhd->storage_id);
+       g_free(_uhd->path);
+       g_free(_uhd->content_id);
+       g_free(_uhd->content_title);
+       g_free(_uhd->file_name);
+       g_free(_uhd->release_date);
+       g_free(_uhd);
+
+       return MEDIA_CONTENT_ERROR_NONE;
 }
 
 int media_uhd_clone(media_uhd_h *dst, media_uhd_h src)
 {
-       int ret = MEDIA_CONTENT_ERROR_NONE;
        media_uhd_s *_src = (media_uhd_s*)src;
 
-       if (_src != NULL) {
-               media_uhd_s *_dst = (media_uhd_s*)calloc(1, sizeof(media_uhd_s));
-               if (_dst == NULL) {
-                       media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
-                       return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
-               }
-
-               if (STRING_VALID(_src->media_id)) {
-                       _dst->media_id = strdup(_src->media_id);
-                       if (_dst->media_id == NULL) {
-                               media_uhd_destroy((media_uhd_h)_dst);
-                               media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
-                               return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
-                       }
-               }
-
-               if (STRING_VALID(_src->storage_id)) {
-                       _dst->storage_id = strdup(_src->storage_id);
-                       if (_dst->storage_id == NULL) {
-                               media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
-                               media_uhd_destroy((media_uhd_h)_dst);
-                               return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
-                       }
-               }
-
-               if (STRING_VALID(_src->path)) {
-                       _dst->path = strdup(_src->path);
-                       if (_dst->path == NULL) {
-                               media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
-                               media_uhd_destroy((media_uhd_h)_dst);
-                               return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
-                       }
-               }
-
-               if (STRING_VALID(_src->content_id)) {
-                       _dst->content_id = strdup(_src->content_id);
-                       if (_dst->content_id == NULL) {
-                               media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
-                               media_uhd_destroy((media_uhd_h)_dst);
-                               return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
-                       }
-               }
-
-               if (STRING_VALID(_src->content_title)) {
-                       _dst->content_title = strdup(_src->content_title);
-                       if (_dst->content_title == NULL) {
-                               media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
-                               media_uhd_destroy((media_uhd_h)_dst);
-                               return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
-                       }
-               }
-
-               if (STRING_VALID(_src->release_date)) {
-                       _dst->release_date = strdup(_src->release_date);
-                       if (_dst->release_date == NULL) {
-                               media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
-                               media_uhd_destroy((media_uhd_h)_dst);
-                               return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
-                       }
-               }
-
-               if (STRING_VALID(_src->file_name)) {
-                       _dst->file_name = strdup(_src->file_name);
-                       if (_dst->file_name == NULL) {
-                               media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
-                               media_uhd_destroy((media_uhd_h)_dst);
-                               return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
-                       }
-               }
-
-               _dst->size = _src->size;
-               _dst->modified_time = _src->modified_time;
-               _dst->played_position = _src->played_position;
-               _dst->sub_type = _src->sub_type;
-               _dst->played_count = _src->played_count;
-               *dst = (media_uhd_h)_dst;
-
-               ret = MEDIA_CONTENT_ERROR_NONE;
-       } else {
-               media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-               ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-       }
+       content_retip_if_fail(dst);
+       content_retip_if_fail(src);
 
-       return ret;
+       media_uhd_s *_dst = g_new0(media_uhd_s, 1);
+
+       _dst->media_id = g_strdup(_src->media_id);
+       _dst->storage_id = g_strdup(_src->storage_id);
+       _dst->path = g_strdup(_src->path);
+       _dst->content_id = g_strdup(_src->content_id);
+       _dst->content_title = g_strdup(_src->content_title);
+       _dst->release_date = g_strdup(_src->release_date);
+       _dst->file_name = g_strdup(_src->file_name);
+       _dst->size = _src->size;
+       _dst->modified_time = _src->modified_time;
+       _dst->played_position = _src->played_position;
+       _dst->sub_type = _src->sub_type;
+       _dst->played_count = _src->played_count;
+
+       *dst = (media_uhd_h)_dst;
+
+       return MEDIA_CONTENT_ERROR_NONE;
 }
 
 int media_uhd_get_uhd_from_db(const char *media_id, media_uhd_h *uhd)
@@ -166,34 +83,26 @@ int media_uhd_get_uhd_from_db(const char *media_id, media_uhd_h *uhd)
        char *select_query = NULL;
        sqlite3_stmt *stmt = NULL;
 
-       if (!STRING_VALID(media_id) || (uhd == NULL)) {
-               media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-               return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-       }
+       content_retip_if_fail(STRING_VALID(media_id));
+       content_retip_if_fail(uhd);
 
        select_query = sqlite3_mprintf(SELECT_UHD_FROM_UHD, media_id);
 
-       ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
-       sqlite3_free(select_query);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+       ret = _content_get_result(select_query, &stmt);
+       SQLITE3_SAFE_FREE(select_query);
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        media_uhd_s *_uhd = NULL;
 
-       while (sqlite3_step(stmt) == SQLITE_ROW) {
-               if (_uhd)
-                       media_uhd_destroy((media_uhd_h)_uhd);
-
-               _uhd = (media_uhd_s*)calloc(1, sizeof(media_uhd_s));
-
-               if (_uhd == NULL) {
-                       media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
-                       SQLITE3_FINALIZE(stmt);
-                       return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
-               }
+       if (sqlite3_step(stmt) == SQLITE_ROW) {
+               _uhd = g_new0(media_uhd_s, 1);
 
                _media_uhd_item_get_detail(stmt, (media_uhd_h)_uhd);
 
                *uhd = (media_uhd_h)_uhd;
+       } else {
+               content_error("Nonexistent media id[%s]", media_id);
+               ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
        }
 
        SQLITE3_FINALIZE(stmt);
@@ -203,342 +112,207 @@ int media_uhd_get_uhd_from_db(const char *media_id, media_uhd_h *uhd)
 
 int media_uhd_get_media_id(media_uhd_h uhd, char **media_id)
 {
-       int ret = MEDIA_CONTENT_ERROR_NONE;
        media_uhd_s *_uhd = (media_uhd_s*)uhd;
 
-       if (_uhd && media_id) {
-               if (STRING_VALID(_uhd->media_id)) {
-                       *media_id = strdup(_uhd->media_id);
-                       if (*media_id == NULL) {
-                               media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
-                               return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
-                       }
-               } else {
-                       *media_id = NULL;
-               }
-
-               ret = MEDIA_CONTENT_ERROR_NONE;
-       } else {
-               media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-               ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-       }
+       content_retip_if_fail(uhd);
+       content_retip_if_fail(media_id);
 
-       return ret;
+       *media_id = g_strdup(_uhd->media_id);
+
+       return MEDIA_CONTENT_ERROR_NONE;
 }
 
 int media_uhd_get_storage_id(media_uhd_h uhd, char **storage_id)
 {
-       int ret = MEDIA_CONTENT_ERROR_NONE;
        media_uhd_s *_uhd = (media_uhd_s*)uhd;
 
-       if (_uhd && storage_id) {
-               if (STRING_VALID(_uhd->storage_id)) {
-                       *storage_id = strdup(_uhd->storage_id);
-                       if (*storage_id == NULL) {
-                               media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
-                               return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
-                       }
-               } else {
-                       *storage_id = NULL;
-               }
-
-               ret = MEDIA_CONTENT_ERROR_NONE;
-       } else {
-               media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-               ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-       }
+       content_retip_if_fail(uhd);
+       content_retip_if_fail(storage_id);
 
-       return ret;
+       *storage_id = g_strdup(_uhd->storage_id);
+
+       return MEDIA_CONTENT_ERROR_NONE;
 }
 
 int media_uhd_get_path(media_uhd_h uhd, char **path)
 {
-       int ret = MEDIA_CONTENT_ERROR_NONE;
        media_uhd_s *_uhd = (media_uhd_s*)uhd;
 
-       if (_uhd && path) {
-               if (STRING_VALID(_uhd->path)) {
-                       *path = strdup(_uhd->path);
-                       if (*path == NULL) {
-                               media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
-                               return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
-                       }
-               } else {
-                       *path = NULL;
-               }
-
-               ret = MEDIA_CONTENT_ERROR_NONE;
-       } else {
-               media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-               ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-       }
+       content_retip_if_fail(uhd);
+       content_retip_if_fail(path);
 
-       return ret;
+       *path = g_strdup(_uhd->path);
+
+       return MEDIA_CONTENT_ERROR_NONE;
 }
 
 int media_uhd_get_size(media_uhd_h uhd, unsigned long long *size)
 {
-       int ret = MEDIA_CONTENT_ERROR_NONE;
        media_uhd_s *_uhd = (media_uhd_s*)uhd;
 
-       if (_uhd && size) {
-               *size = _uhd->size;
-               ret = MEDIA_CONTENT_ERROR_NONE;
-       } else {
-               media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-               ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-       }
+       content_retip_if_fail(uhd);
+       content_retip_if_fail(size);
 
-       return ret;
+       *size = _uhd->size;
+
+       return MEDIA_CONTENT_ERROR_NONE;
 }
 
 int media_uhd_get_content_id(media_uhd_h uhd, char **content_id)
 {
-       int ret = MEDIA_CONTENT_ERROR_NONE;
        media_uhd_s *_uhd = (media_uhd_s*)uhd;
 
-       if (_uhd && content_id) {
-               if (STRING_VALID(_uhd->content_id)) {
-                       *content_id = strdup(_uhd->content_id);
-                       if (*content_id == NULL) {
-                               media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
-                               return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
-                       }
-               } else {
-                       *content_id = NULL;
-               }
-
-               ret = MEDIA_CONTENT_ERROR_NONE;
-       } else {
-               media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-               ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-       }
+       content_retip_if_fail(uhd);
+       content_retip_if_fail(content_id);
 
-       return ret;
+       *content_id = g_strdup(_uhd->content_id);
+
+       return MEDIA_CONTENT_ERROR_NONE;
 }
 
 int media_uhd_get_content_title(media_uhd_h uhd, char **content_title)
 {
-       int ret = MEDIA_CONTENT_ERROR_NONE;
        media_uhd_s *_uhd = (media_uhd_s*)uhd;
 
-       if (_uhd && content_title) {
-               if (STRING_VALID(_uhd->content_title)) {
-                       *content_title = strdup(_uhd->content_title);
-                       if (*content_title == NULL) {
-                               media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
-                               return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
-                       }
-               } else {
-                       *content_title = NULL;
-               }
-
-               ret = MEDIA_CONTENT_ERROR_NONE;
-       } else {
-               media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-               ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-       }
+       content_retip_if_fail(uhd);
+       content_retip_if_fail(content_title);
 
-       return ret;
+       *content_title = g_strdup(_uhd->content_title);
+
+       return MEDIA_CONTENT_ERROR_NONE;
 }
 
 int media_uhd_get_file_name(media_uhd_h uhd, char **file_name)
 {
-       int ret = MEDIA_CONTENT_ERROR_NONE;
        media_uhd_s *_uhd = (media_uhd_s*)uhd;
 
-       if (_uhd && file_name) {
-               if (STRING_VALID(_uhd->file_name)) {
-                       *file_name = strdup(_uhd->file_name);
-                       if (*file_name == NULL) {
-                               media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
-                               return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
-                       }
-               } else {
-                       *file_name = NULL;
-               }
-
-               ret = MEDIA_CONTENT_ERROR_NONE;
-       } else {
-               media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-               ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-       }
+       content_retip_if_fail(uhd);
+       content_retip_if_fail(file_name);
 
-       return ret;
+       *file_name = g_strdup(_uhd->file_name);
+
+       return MEDIA_CONTENT_ERROR_NONE;
 }
 
 int media_uhd_get_release_date(media_uhd_h uhd, char **release_date)
 {
-       int ret = MEDIA_CONTENT_ERROR_NONE;
        media_uhd_s *_uhd = (media_uhd_s*)uhd;
 
-       if (_uhd && release_date) {
-               if (STRING_VALID(_uhd->release_date)) {
-                       *release_date = strdup(_uhd->release_date);
-                       if (*release_date == NULL) {
-                               media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
-                               return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
-                       }
-               } else {
-                       *release_date = NULL;
-               }
-
-               ret = MEDIA_CONTENT_ERROR_NONE;
-       } else {
-               media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-               ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-       }
+       content_retip_if_fail(uhd);
+       content_retip_if_fail(release_date);
 
-       return ret;
+       *release_date = g_strdup(_uhd->release_date);
+
+       return MEDIA_CONTENT_ERROR_NONE;
 }
 
 int media_uhd_get_modified_time(media_uhd_h uhd, time_t *modified_time)
 {
-       int ret = MEDIA_CONTENT_ERROR_NONE;
        media_uhd_s *_uhd = (media_uhd_s*)uhd;
 
-       if (_uhd && modified_time) {
-               *modified_time = _uhd->modified_time;
-               ret = MEDIA_CONTENT_ERROR_NONE;
-       } else {
-               media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-               ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-       }
+       content_retip_if_fail(uhd);
+       content_retip_if_fail(modified_time);
 
-       return ret;
+       *modified_time = _uhd->modified_time;
+
+       return MEDIA_CONTENT_ERROR_NONE;
 }
 
 int media_uhd_get_played_position(media_uhd_h uhd, int *played_position)
 {
-       int ret = MEDIA_CONTENT_ERROR_NONE;
        media_uhd_s *_uhd = (media_uhd_s*)uhd;
 
-       if (_uhd) {
-               *played_position = _uhd->played_position;
-               ret = MEDIA_CONTENT_ERROR_NONE;
-       } else {
-               media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-               ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-       }
+       content_retip_if_fail(uhd);
+       content_retip_if_fail(played_position);
 
-       return ret;
+       *played_position = _uhd->played_position;
+
+       return MEDIA_CONTENT_ERROR_NONE;
 }
 
 int media_uhd_get_sub_type(media_uhd_h uhd, int *sub_type)
 {
-       int ret = MEDIA_CONTENT_ERROR_NONE;
        media_uhd_s *_uhd = (media_uhd_s*)uhd;
 
-       if (_uhd) {
-               *sub_type = _uhd->sub_type;
-               ret = MEDIA_CONTENT_ERROR_NONE;
-       } else {
-               media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-               ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-       }
+       content_retip_if_fail(uhd);
+       content_retip_if_fail(sub_type);
 
-       return ret;
+       *sub_type = _uhd->sub_type;
+
+       return MEDIA_CONTENT_ERROR_NONE;
 }
 
 int media_uhd_get_played_count(media_uhd_h uhd, int *played_count)
 {
-       int ret = MEDIA_CONTENT_ERROR_NONE;
        media_uhd_s *_uhd = (media_uhd_s*)uhd;
 
-       if (_uhd) {
-               *played_count = _uhd->played_count;
-               ret = MEDIA_CONTENT_ERROR_NONE;
-       } else {
-               media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-               ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-       }
+       content_retip_if_fail(uhd);
+       content_retip_if_fail(played_count);
 
-       return ret;
+       *played_count = _uhd->played_count;
+
+       return MEDIA_CONTENT_ERROR_NONE;
 }
 
 int media_uhd_set_played_position(media_uhd_h uhd, int played_position)
 {
-       int ret = MEDIA_CONTENT_ERROR_NONE;
        media_uhd_s *_uhd = (media_uhd_s*)uhd;
 
-       if ((_uhd != NULL) && (played_position >= 0)) {
-               _uhd->played_position = played_position;
-       } else {
-               media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-               ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-       }
+       content_retip_if_fail(uhd);
+       content_retip_if_fail(played_position);
 
-       return ret;
+       _uhd->played_position = played_position;
+
+       return MEDIA_CONTENT_ERROR_NONE;
 }
 
 int media_uhd_set_content_title(media_uhd_h uhd, const char *content_title)
 {
-       int ret = MEDIA_CONTENT_ERROR_NONE;
        media_uhd_s *_uhd = (media_uhd_s*)uhd;
 
-       if (_uhd != NULL && STRING_VALID(content_title)) {
-               SAFE_FREE(_uhd->content_title);
-               _uhd->content_title = strdup(content_title);
-               if (_uhd->content_title == NULL) {
-                       media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
-                       return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
-               }
-       } else {
-               media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-               ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-       }
+       content_retip_if_fail(uhd);
+       content_retip_if_fail(STRING_VALID(content_title));
 
-       return ret;
+       g_free(_uhd->content_title);
+       _uhd->content_title = g_strdup(content_title);
+
+       return MEDIA_CONTENT_ERROR_NONE;
 }
 
 int media_uhd_set_release_date(media_uhd_h uhd, const char *release_date)
 {
-       int ret = MEDIA_CONTENT_ERROR_NONE;
        media_uhd_s *_uhd = (media_uhd_s*)uhd;
 
-       if (_uhd != NULL && STRING_VALID(release_date)) {
-               SAFE_FREE(_uhd->release_date);
-               _uhd->release_date = strdup(release_date);
-               if (_uhd->release_date == NULL) {
-                       media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
-                       return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
-               }
-       } else {
-               media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-               ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-       }
+       content_retip_if_fail(uhd);
+       content_retip_if_fail(STRING_VALID(release_date));
 
-       return ret;
+       g_free(_uhd->release_date);
+       _uhd->release_date = g_strdup(release_date);
+
+       return MEDIA_CONTENT_ERROR_NONE;
 }
 
 int media_uhd_set_sub_type(media_uhd_h uhd, int sub_type)
 {
-       int ret = MEDIA_CONTENT_ERROR_NONE;
        media_uhd_s *_uhd = (media_uhd_s*)uhd;
 
-       if ((_uhd != NULL) && (sub_type >= 0)) {
-               _uhd->sub_type = sub_type;
-       } else {
-               media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-               ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-       }
+       content_retip_if_fail(uhd);
+       content_retip_if_fail(sub_type >= 0);
 
-       return ret;
+       _uhd->sub_type = sub_type;
+
+       return MEDIA_CONTENT_ERROR_NONE;
 }
 
 int media_uhd_set_played_count(media_uhd_h uhd, int played_count)
 {
-       int ret = MEDIA_CONTENT_ERROR_NONE;
        media_uhd_s *_uhd = (media_uhd_s*)uhd;
 
-       if (_uhd != NULL) {
-               _uhd->played_count = played_count;
-       } else {
-               media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-               ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-       }
+       content_retip_if_fail(uhd);
 
-       return ret;
+       _uhd->played_count = played_count;
+
+       return MEDIA_CONTENT_ERROR_NONE;
 }
 
 int media_uhd_update_to_db(media_uhd_h uhd)
@@ -547,15 +321,14 @@ int media_uhd_update_to_db(media_uhd_h uhd)
        media_uhd_s *_uhd = (media_uhd_s*)uhd;
        char *update_query = NULL;
 
-       if (_uhd != NULL && STRING_VALID(_uhd->media_id) && STRING_VALID(_uhd->path)) {
-               update_query = sqlite3_mprintf(UPDATE_UHD_META_FROM_UHD, _uhd->content_title, _uhd->release_date, _uhd->played_position, _uhd->sub_type, _uhd->played_count, _uhd->media_id);
+       content_retip_if_fail(uhd);
+       content_retip_if_fail(STRING_VALID(_uhd->media_id));
+       content_retip_if_fail(STRING_VALID(_uhd->path));
 
-               ret = _content_query_sql(update_query);
-               sqlite3_free(update_query);
-       } else {
-               media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-               ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-       }
+       update_query = sqlite3_mprintf(UPDATE_UHD_META_FROM_UHD, _uhd->content_title, _uhd->release_date, _uhd->played_position, _uhd->sub_type, _uhd->played_count, _uhd->media_id);
+
+       ret = _content_query_sql(update_query);
+       sqlite3_free(update_query);
 
        return ret;
 }