ACR-436 Modify getter API return value from Unknown to empty string()

Change-Id: I91936136f97a3a2f4969c13e749b202e4d313fea

diff --git a/packaging/capi-content-media-content.spec b/packaging/capi-content-media-content.spec
index 6b9a4b8..4112e87 100755 (executable)
--- a/packaging/capi-content-media-content.spec
+++ b/packaging/capi-content-media-content.spec
@@ -1,6 +1,6 @@
 Name:       capi-content-media-content
 Summary:    A Media content library in SLP C API
-Version:    0.2.72
+Version:    0.2.73
 Release:    0
 Group:      Multimedia/API
 License:    Apache-2.0

diff --git a/src/media_audio.c b/src/media_audio.c
index ec70925..7c39ea9 100755 (executable)
--- a/src/media_audio.c
+++ b/src/media_audio.c
@@ -55,8 +55,8 @@ int audio_meta_clone(audio_meta_h *dst, audio_meta_h src)
                audio_meta_s *_dst = (audio_meta_s*)calloc(1, sizeof(audio_meta_s));
                media_content_retvm_if(_dst == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 
-               if (STRING_VALID(_src->media_id)) {
-                       _dst->media_id = strdup(_src->media_id);
+               if (_src->media_id != NULL) {
+                       _dst->media_id = g_strdup(_src->media_id);
                        if (_dst->media_id == NULL) {
                                audio_meta_destroy((audio_meta_h)_dst);
                                media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
@@ -64,8 +64,8 @@ int audio_meta_clone(audio_meta_h *dst, audio_meta_h src)
                        }
                }
 
-               if (STRING_VALID(_src->title)) {
-                       _dst->title = strdup(_src->title);
+               if (_src->title != NULL) {
+                       _dst->title = g_strdup(_src->title);
                        if (_dst->title == NULL) {
                                audio_meta_destroy((audio_meta_h)_dst);
                                media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
@@ -73,8 +73,8 @@ int audio_meta_clone(audio_meta_h *dst, audio_meta_h src)
                        }
                }
 
-               if (STRING_VALID(_src->album)) {
-                       _dst->album = strdup(_src->album);
+               if (_src->album != NULL) {
+                       _dst->album = g_strdup(_src->album);
                        if (_dst->album == NULL) {
                                audio_meta_destroy((audio_meta_h)_dst);
                                media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
@@ -82,8 +82,8 @@ int audio_meta_clone(audio_meta_h *dst, audio_meta_h src)
                        }
                }
 
-               if (STRING_VALID(_src->artist)) {
-                       _dst->artist = strdup(_src->artist);
+               if (_src->artist != NULL) {
+                       _dst->artist = g_strdup(_src->artist);
                        if (_dst->artist == NULL) {
                                audio_meta_destroy((audio_meta_h)_dst);
                                media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
@@ -91,8 +91,8 @@ int audio_meta_clone(audio_meta_h *dst, audio_meta_h src)
                        }
                }
 
-               if (STRING_VALID(_src->album_artist)) {
-                       _dst->album_artist = strdup(_src->album_artist);
+               if (_src->album_artist != NULL) {
+                       _dst->album_artist = g_strdup(_src->album_artist);
                        if (_dst->album_artist == NULL) {
                                audio_meta_destroy((audio_meta_h)_dst);
                                media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
@@ -100,8 +100,8 @@ int audio_meta_clone(audio_meta_h *dst, audio_meta_h src)
                        }
                }
 
-               if (STRING_VALID(_src->genre)) {
-                       _dst->genre = strdup(_src->genre);
+               if (_src->genre != NULL) {
+                       _dst->genre = g_strdup(_src->genre);
                        if (_dst->genre == NULL) {
                                audio_meta_destroy((audio_meta_h)_dst);
                                media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
@@ -109,8 +109,8 @@ int audio_meta_clone(audio_meta_h *dst, audio_meta_h src)
                        }
                }
 
-               if (STRING_VALID(_src->composer)) {
-                       _dst->composer = strdup(_src->composer);
+               if (_src->composer != NULL) {
+                       _dst->composer = g_strdup(_src->composer);
                        if (_dst->composer == NULL) {
                                audio_meta_destroy((audio_meta_h)_dst);
                                media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
@@ -118,8 +118,8 @@ int audio_meta_clone(audio_meta_h *dst, audio_meta_h src)
                        }
                }
 
-               if (STRING_VALID(_src->year)) {
-                       _dst->year = strdup(_src->year);
+               if (_src->year != NULL) {
+                       _dst->year = g_strdup(_src->year);
                        if (_dst->year == NULL) {
                                audio_meta_destroy((audio_meta_h)_dst);
                                media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
@@ -127,8 +127,8 @@ int audio_meta_clone(audio_meta_h *dst, audio_meta_h src)
                        }
                }
 
-               if (STRING_VALID(_src->recorded_date)) {
-                       _dst->recorded_date = strdup(_src->recorded_date);
+               if (_src->recorded_date != NULL) {
+                       _dst->recorded_date = g_strdup(_src->recorded_date);
                        if (_dst->recorded_date == NULL) {
                                audio_meta_destroy((audio_meta_h)_dst);
                                media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
@@ -136,8 +136,8 @@ int audio_meta_clone(audio_meta_h *dst, audio_meta_h src)
                        }
                }
 
-               if (STRING_VALID(_src->copyright)) {
-                       _dst->copyright = strdup(_src->copyright);
+               if (_src->copyright != NULL) {
+                       _dst->copyright = g_strdup(_src->copyright);
                        if (_dst->copyright == NULL) {
                                audio_meta_destroy((audio_meta_h)_dst);
                                media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
@@ -145,8 +145,8 @@ int audio_meta_clone(audio_meta_h *dst, audio_meta_h src)
                        }
                }
 
-               if (STRING_VALID(_src->track_num)) {
-                       _dst->track_num = strdup(_src->track_num);
+               if (_src->track_num != NULL) {
+                       _dst->track_num = g_strdup(_src->track_num);
                        if (_dst->track_num == NULL) {
                                audio_meta_destroy((audio_meta_h)_dst);
                                media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
@@ -200,8 +200,8 @@ int audio_meta_get_album(audio_meta_h audio, char **album)
        int ret = MEDIA_CONTENT_ERROR_NONE;
        audio_meta_s *_audio = (audio_meta_s*)audio;
        if (_audio) {
-               if (STRING_VALID(_audio->album)) {
-                       *album = strdup(_audio->album);
+               if (_audio->album != NULL) {
+                       *album = g_strdup(_audio->album);               /*album can be empty string*/
                        media_content_retvm_if(*album == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
                } else {
                        *album = NULL;
@@ -222,8 +222,8 @@ int audio_meta_get_artist(audio_meta_h audio, char **artist)
        audio_meta_s *_audio = (audio_meta_s*)audio;
 
        if (_audio) {
-               if (STRING_VALID(_audio->artist)) {
-                       *artist = strdup(_audio->artist);
+               if (_audio->artist != NULL) {
+                       *artist = g_strdup(_audio->artist);     /*artist can be empty string*/
                        media_content_retvm_if(*artist == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
                } else {
                        *artist = NULL;
@@ -244,8 +244,8 @@ int audio_meta_get_album_artist(audio_meta_h audio, char **album_artist)
        audio_meta_s *_audio = (audio_meta_s*)audio;
 
        if (_audio) {
-               if (STRING_VALID(_audio->album_artist)) {
-                       *album_artist = strdup(_audio->album_artist);
+               if (_audio->album_artist != NULL) {
+                       *album_artist = g_strdup(_audio->album_artist); /*album_artist can be empty string*/
                        media_content_retvm_if(*album_artist == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
                } else {
                        *album_artist = NULL;
@@ -266,8 +266,8 @@ int audio_meta_get_genre(audio_meta_h audio, char **genre)
        audio_meta_s *_audio = (audio_meta_s*)audio;
 
        if (_audio) {
-               if (STRING_VALID(_audio->genre)) {
-                       *genre = strdup(_audio->genre);
+               if (_audio->genre != NULL) {
+                       *genre = g_strdup(_audio->genre);       /*genre can be empty string*/
                        media_content_retvm_if(*genre == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
                } else {
                        *genre = NULL;
@@ -288,8 +288,8 @@ int audio_meta_get_composer(audio_meta_h audio, char **composer)
        audio_meta_s *_audio = (audio_meta_s*)audio;
 
        if (_audio) {
-               if (STRING_VALID(_audio->composer)) {
-                       *composer = strdup(_audio->composer);
+               if (_audio->composer != NULL) {
+                       *composer = g_strdup(_audio->composer); /*composer can be empty string*/
                        media_content_retvm_if(*composer == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
                } else {
                        *composer = NULL;
@@ -310,8 +310,8 @@ int audio_meta_get_year(audio_meta_h audio, char **year)
        audio_meta_s *_audio = (audio_meta_s*)audio;
 
        if (_audio) {
-               if (STRING_VALID(_audio->year)) {
-                       *year = strdup(_audio->year);
+               if (_audio->year != NULL) {
+                       *year = g_strdup(_audio->year); /*year can be empty string*/
                        media_content_retvm_if(*year == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
                } else {
                        *year = NULL;
@@ -332,8 +332,8 @@ int audio_meta_get_recorded_date(audio_meta_h audio, char **recorded_date)
        audio_meta_s *_audio = (audio_meta_s*)audio;
 
        if (_audio) {
-               if (STRING_VALID(_audio->recorded_date)) {
-                       *recorded_date = strdup(_audio->recorded_date);
+               if (_audio->recorded_date != NULL) {
+                       *recorded_date = g_strdup(_audio->recorded_date);
                        media_content_retvm_if(*recorded_date == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
                } else {
                        *recorded_date = NULL;
@@ -354,8 +354,8 @@ int audio_meta_get_copyright(audio_meta_h audio, char **copyright)
        audio_meta_s *_audio = (audio_meta_s*)audio;
 
        if (_audio) {
-               if (STRING_VALID(_audio->copyright)) {
-                       *copyright = strdup(_audio->copyright);
+               if (_audio->copyright != NULL) {
+                       *copyright = g_strdup(_audio->copyright);       /*copyright can be empty string*/
                        media_content_retvm_if(*copyright == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
                } else {
                        *copyright = NULL;
@@ -376,8 +376,8 @@ int audio_meta_get_track_num(audio_meta_h audio, char **track_num)
        audio_meta_s *_audio = (audio_meta_s*)audio;
 
        if (_audio) {
-               if (STRING_VALID(_audio->track_num)) {
-                       *track_num = strdup(_audio->track_num);
+               if (_audio->track_num != NULL) {
+                       *track_num = g_strdup(_audio->track_num);       /*track_num can be empty string*/
                        media_content_retvm_if(*track_num == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
                } else {
                        *track_num = NULL;

diff --git a/src/media_group.c b/src/media_group.c
index d8ec816..71fb29e 100755 (executable)
--- a/src/media_group.c
+++ b/src/media_group.c
@@ -145,8 +145,8 @@ int media_album_clone(media_album_h *dst, media_album_h src)
 
                _dst->album_id = _src->album_id;
 
-               if (STRING_VALID(_src->name)) {
-                       _dst->name = strdup(_src->name);
+               if (_src->name != NULL) {
+                       _dst->name = g_strdup(_src->name);
                        if (_dst->name == NULL) {
                                media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                                media_album_destroy((media_album_h)_dst);
@@ -154,8 +154,8 @@ int media_album_clone(media_album_h *dst, media_album_h src)
                        }
                }
 
-               if (STRING_VALID(_src->artist)) {
-                       _dst->artist = strdup(_src->artist);
+               if (_src->artist != NULL) {
+                       _dst->artist = g_strdup(_src->artist);
                        if (_dst->artist == NULL) {
                                media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                                media_album_destroy((media_album_h)_dst);
@@ -163,8 +163,8 @@ int media_album_clone(media_album_h *dst, media_album_h src)
                        }
                }
 
-               if (STRING_VALID(_src->album_art_path)) {
-                       _dst->album_art_path = strdup(_src->album_art_path);
+               if (_src->album_art_path != NULL) {
+                       _dst->album_art_path = g_strdup(_src->album_art_path);
                        if (_dst->album_art_path == NULL) {
                                media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                                media_album_destroy((media_album_h)_dst);
@@ -205,8 +205,8 @@ int media_album_get_name(media_album_h album, char **name)
        media_album_s *_album = (media_album_s*)album;
 
        if (_album) {
-               if (STRING_VALID(_album->name)) {
-                       *name = strdup(_album->name);
+               if (_album->name != NULL) {
+                       *name = g_strdup(_album->name);
                        media_content_retvm_if(*name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
                } else {
                        *name = NULL;
@@ -227,8 +227,8 @@ int media_album_get_artist(media_album_h album, char **artist)
        media_album_s *_album = (media_album_s*)album;
 
        if (_album) {
-               if (STRING_VALID(_album->artist)) {
-                       *artist = strdup(_album->artist);
+               if (_album->artist != NULL) {
+                       *artist = g_strdup(_album->artist);
                        media_content_retvm_if(*artist == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
                } else {
                        *artist = NULL;
@@ -249,8 +249,8 @@ int media_album_get_album_art(media_album_h album, char **album_art)
        media_album_s *_album = (media_album_s*)album;
 
        if (_album) {
-               if (STRING_VALID(_album->album_art_path)) {
-                       *album_art = strdup(_album->album_art_path);
+               if (_album->album_art_path != NULL) {
+                       *album_art = g_strdup(_album->album_art_path);
                        media_content_retvm_if(*album_art == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
                } else {
                        *album_art = NULL;

diff --git a/src/media_image.c b/src/media_image.c
index cf344fc..91425e2 100755 (executable)
--- a/src/media_image.c
+++ b/src/media_image.c
@@ -384,4 +384,4 @@ int image_meta_update_to_db(image_meta_h image)
        }
 
        return ret;
-}
\ No newline at end of file
+}

diff --git a/src/media_info.c b/src/media_info.c
index e2232ab..d90efa4 100755 (executable)
--- a/src/media_info.c
+++ b/src/media_info.c
@@ -84,9 +84,9 @@ static void __media_info_thumbnail_completed_cb(int error, const char *path, voi
 
        if (_thumb_cb != NULL) {
                media = _thumb_cb->handle;
-               if ((media != NULL) && STRING_VALID(path)) {
+               if ((media != NULL) && (path != NULL)) {
                        SAFE_FREE(media->thumbnail_path);
-                       media->thumbnail_path = strdup(path);
+                       media->thumbnail_path = g_strdup(path);
                }
 
                media_content_debug("error [%d], thumbnail_path [%s]", error, path);
@@ -669,48 +669,48 @@ int media_info_clone(media_info_h *dst, media_info_h src)
                media_info_s *_dst = (media_info_s*)calloc(1, sizeof(media_info_s));
                media_content_retvm_if(_dst == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 
-               if (STRING_VALID(_src->media_id)) {
-                       _dst->media_id = strdup(_src->media_id);
+               if (_src->media_id) {
+                       _dst->media_id = g_strdup(_src->media_id);
                        if (_dst->media_id == NULL) {
                                media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                                media_info_destroy((media_info_h)_dst);
                                return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                        }
                }
-               if (STRING_VALID(_src->file_path)) {
-                       _dst->file_path = strdup(_src->file_path);
+               if (_src->file_path) {
+                       _dst->file_path = g_strdup(_src->file_path);
                        if (_dst->file_path == NULL) {
                                media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                                media_info_destroy((media_info_h)_dst);
                                return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                        }
                }
-               if (STRING_VALID(_src->display_name)) {
-                       _dst->display_name = strdup(_src->display_name);
+               if (_src->display_name != NULL) {
+                       _dst->display_name = g_strdup(_src->display_name);
                        if (_dst->display_name == NULL) {
                                media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                                media_info_destroy((media_info_h)_dst);
                                return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                        }
                }
-               if (STRING_VALID(_src->mime_type)) {
-                       _dst->mime_type = strdup(_src->mime_type);
+               if (_src->mime_type) {
+                       _dst->mime_type = g_strdup(_src->mime_type);
                        if (_dst->mime_type == NULL) {
                                media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                                media_info_destroy((media_info_h)_dst);
                                return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                        }
                }
-               if (STRING_VALID(_src->thumbnail_path)) {
-                       _dst->thumbnail_path = strdup(_src->thumbnail_path);
+               if (_src->thumbnail_path != NULL) {
+                       _dst->thumbnail_path = g_strdup(_src->thumbnail_path);
                        if (_dst->thumbnail_path == NULL) {
                                media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                                media_info_destroy((media_info_h)_dst);
                                return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                        }
                }
-               if (STRING_VALID(_src->description)) {
-                       _dst->description = strdup(_src->description);
+               if (_src->description != NULL) {
+                       _dst->description = g_strdup(_src->description);
                        if (_dst->description == NULL) {
                                media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                                media_info_destroy((media_info_h)_dst);
@@ -718,8 +718,8 @@ int media_info_clone(media_info_h *dst, media_info_h src)
                        }
                }
 
-               if (STRING_VALID(_src->weather)) {
-                       _dst->weather = strdup(_src->weather);
+               if (_src->weather != NULL) {
+                       _dst->weather = g_strdup(_src->weather);
                        if (_dst->weather == NULL) {
                                media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                                media_info_destroy((media_info_h)_dst);
@@ -727,64 +727,64 @@ int media_info_clone(media_info_h *dst, media_info_h src)
                        }
                }
 
-               if (STRING_VALID(_src->title)) {
-                       _dst->title = strdup(_src->title);
+               if (_src->title != NULL) {
+                       _dst->title = g_strdup(_src->title);
                        if (_dst->title == NULL) {
                                media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                                media_info_destroy((media_info_h)_dst);
                                return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                        }
                }
-               if (STRING_VALID(_src->author)) {
-                       _dst->author = strdup(_src->author);
+               if (_src->author != NULL) {
+                       _dst->author = g_strdup(_src->author);
                        if (_dst->author == NULL) {
                                media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                                media_info_destroy((media_info_h)_dst);
                                return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                        }
                }
-               if (STRING_VALID(_src->provider)) {
-                       _dst->provider = strdup(_src->provider);
+               if (_src->provider != NULL) {
+                       _dst->provider = g_strdup(_src->provider);
                        if (_dst->provider == NULL) {
                                media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                                media_info_destroy((media_info_h)_dst);
                                return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                        }
                }
-               if (STRING_VALID(_src->content_name)) {
-                       _dst->content_name = strdup(_src->content_name);
+               if (_src->content_name != NULL) {
+                       _dst->content_name = g_strdup(_src->content_name);
                        if (_dst->content_name == NULL) {
                                media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                                media_info_destroy((media_info_h)_dst);
                                return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                        }
                }
-               if (STRING_VALID(_src->category)) {
-                       _dst->category = strdup(_src->category);
+               if (_src->category != NULL) {
+                       _dst->category = g_strdup(_src->category);
                        if (_dst->category == NULL) {
                                media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                                media_info_destroy((media_info_h)_dst);
                                return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                        }
                }
-               if (STRING_VALID(_src->location_tag)) {
-                       _dst->location_tag = strdup(_src->location_tag);
+               if (_src->location_tag != NULL) {
+                       _dst->location_tag = g_strdup(_src->location_tag);
                        if (_dst->location_tag == NULL) {
                                media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                                media_info_destroy((media_info_h)_dst);
                                return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                        }
                }
-               if (STRING_VALID(_src->age_rating)) {
-                       _dst->age_rating = strdup(_src->age_rating);
+               if (_src->age_rating != NULL) {
+                       _dst->age_rating = g_strdup(_src->age_rating);
                        if (_dst->age_rating == NULL) {
                                media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                                media_info_destroy((media_info_h)_dst);
                                return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                        }
                }
-               if (STRING_VALID(_src->keyword)) {
-                       _dst->keyword = strdup(_src->keyword);
+               if (_src->keyword != NULL) {
+                       _dst->keyword = g_strdup(_src->keyword);
                        if (_dst->keyword == NULL) {
                                media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                                media_info_destroy((media_info_h)_dst);
@@ -792,8 +792,8 @@ int media_info_clone(media_info_h *dst, media_info_h src)
                        }
                }
 
-               if (STRING_VALID(_src->storage_uuid)) {
-                       _dst->storage_uuid = strdup(_src->storage_uuid);
+               if (_src->storage_uuid != NULL) {
+                       _dst->storage_uuid = g_strdup(_src->storage_uuid);
                        if (_dst->storage_uuid == NULL) {
                                media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                                media_info_destroy((media_info_h)_dst);
@@ -826,8 +826,8 @@ int media_info_clone(media_info_h *dst, media_info_h src)
                                return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                        }
 
-                       if (STRING_VALID(_src->image_meta->media_id)) {
-                               _dst->image_meta->media_id = strdup(_src->image_meta->media_id);
+                       if (_src->image_meta->media_id != NULL) {
+                               _dst->image_meta->media_id = g_strdup(_src->image_meta->media_id);
                                if (_dst->image_meta->media_id == NULL) {
                                        media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                                        media_info_destroy((media_info_h)_dst);
@@ -835,8 +835,8 @@ int media_info_clone(media_info_h *dst, media_info_h src)
                                }
                        }
 
-                       if (STRING_VALID(_src->image_meta->date_taken)) {
-                               _dst->image_meta->date_taken = strdup(_src->image_meta->date_taken);
+                       if (_src->image_meta->date_taken != NULL) {
+                               _dst->image_meta->date_taken = g_strdup(_src->image_meta->date_taken);
                                if (_dst->image_meta->date_taken == NULL) {
                                        media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                                        media_info_destroy((media_info_h)_dst);
@@ -844,8 +844,8 @@ int media_info_clone(media_info_h *dst, media_info_h src)
                                }
                        }
 
-                       if (STRING_VALID(_src->image_meta->burst_id)) {
-                               _dst->image_meta->burst_id = strdup(_src->image_meta->burst_id);
+                       if (_src->image_meta->burst_id != NULL) {
+                               _dst->image_meta->burst_id = g_strdup(_src->image_meta->burst_id);
                                if (_dst->image_meta->burst_id == NULL) {
                                        media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                                        media_info_destroy((media_info_h)_dst);
@@ -853,8 +853,8 @@ int media_info_clone(media_info_h *dst, media_info_h src)
                                }
                        }
 
-                       if (STRING_VALID(_src->image_meta->weather)) {
-                               _dst->image_meta->weather = strdup(_src->image_meta->weather);
+                       if (_src->image_meta->weather != NULL) {
+                               _dst->image_meta->weather = g_strdup(_src->image_meta->weather);
                                if (_dst->image_meta->weather == NULL) {
                                        media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                                        media_info_destroy((media_info_h)_dst);
@@ -862,8 +862,8 @@ int media_info_clone(media_info_h *dst, media_info_h src)
                                }
                        }
 
-                       if (STRING_VALID(_src->image_meta->exposure_time)) {
-                               _dst->image_meta->exposure_time = strdup(_src->image_meta->exposure_time);
+                       if (_src->image_meta->exposure_time != NULL) {
+                               _dst->image_meta->exposure_time = g_strdup(_src->image_meta->exposure_time);
                                if (_dst->image_meta->exposure_time == NULL) {
                                        media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                                        media_info_destroy((media_info_h)_dst);
@@ -871,8 +871,8 @@ int media_info_clone(media_info_h *dst, media_info_h src)
                                }
                        }
 
-                       if (STRING_VALID(_src->image_meta->model)) {
-                               _dst->image_meta->model = strdup(_src->image_meta->model);
+                       if (_src->image_meta->model != NULL) {
+                               _dst->image_meta->model = g_strdup(_src->image_meta->model);
                                if (_dst->image_meta->model == NULL) {
                                        media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                                        media_info_destroy((media_info_h)_dst);
@@ -894,88 +894,88 @@ int media_info_clone(media_info_h *dst, media_info_h src)
                                return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                        }
 
-                       if (STRING_VALID(_src->video_meta->media_id)) {
-                               _dst->video_meta->media_id = strdup(_src->video_meta->media_id);
+                       if (_src->video_meta->media_id != NULL) {
+                               _dst->video_meta->media_id = g_strdup(_src->video_meta->media_id);
                                if (_dst->video_meta->media_id == NULL) {
                                        media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                                        media_info_destroy((media_info_h)_dst);
                                        return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                                }
                        }
-                       if (STRING_VALID(_src->video_meta->title)) {
-                               _dst->video_meta->title = strdup(_src->video_meta->title);
+                       if (_src->video_meta->title != NULL) {
+                               _dst->video_meta->title = g_strdup(_src->video_meta->title);
                                if (_dst->video_meta->title == NULL) {
                                        media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                                        media_info_destroy((media_info_h)_dst);
                                        return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                                }
                        }
-                       if (STRING_VALID(_src->video_meta->album)) {
-                               _dst->video_meta->album = strdup(_src->video_meta->album);
+                       if (_src->video_meta->album != NULL) {
+                               _dst->video_meta->album = g_strdup(_src->video_meta->album);
                                if (_dst->video_meta->album == NULL) {
                                        media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                                        media_info_destroy((media_info_h)_dst);
                                        return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                                }
                        }
-                       if (STRING_VALID(_src->video_meta->artist)) {
-                               _dst->video_meta->artist = strdup(_src->video_meta->artist);
+                       if (_src->video_meta->artist != NULL) {
+                               _dst->video_meta->artist = g_strdup(_src->video_meta->artist);
                                if (_dst->video_meta->artist == NULL) {
                                        media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                                        media_info_destroy((media_info_h)_dst);
                                        return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                                }
                        }
-                       if (STRING_VALID(_src->video_meta->album_artist)) {
-                               _dst->video_meta->album_artist = strdup(_src->video_meta->album_artist);
+                       if (_src->video_meta->album_artist != NULL) {
+                               _dst->video_meta->album_artist = g_strdup(_src->video_meta->album_artist);
                                if (_dst->video_meta->album_artist == NULL) {
                                        media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                                        media_info_destroy((media_info_h)_dst);
                                        return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                                }
                        }
-                       if (STRING_VALID(_src->video_meta->genre)) {
-                               _dst->video_meta->genre = strdup(_src->video_meta->genre);
+                       if (_src->video_meta->genre != NULL) {
+                               _dst->video_meta->genre = g_strdup(_src->video_meta->genre);
                                if (_dst->video_meta->genre == NULL) {
                                        media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                                        media_info_destroy((media_info_h)_dst);
                                        return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                                }
                        }
-                       if (STRING_VALID(_src->video_meta->composer)) {
-                               _dst->video_meta->composer = strdup(_src->video_meta->composer);
+                       if (_src->video_meta->composer != NULL) {
+                               _dst->video_meta->composer = g_strdup(_src->video_meta->composer);
                                if (_dst->video_meta->composer == NULL) {
                                        media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                                        media_info_destroy((media_info_h)_dst);
                                        return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                                }
                        }
-                       if (STRING_VALID(_src->video_meta->year)) {
-                               _dst->video_meta->year = strdup(_src->video_meta->year);
+                       if (_src->video_meta->year != NULL) {
+                               _dst->video_meta->year = g_strdup(_src->video_meta->year);
                                if (_dst->video_meta->year == NULL) {
                                        media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                                        media_info_destroy((media_info_h)_dst);
                                        return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                                }
                        }
-                       if (STRING_VALID(_src->video_meta->recorded_date)) {
-                               _dst->video_meta->recorded_date = strdup(_src->video_meta->recorded_date);
+                       if (_src->video_meta->recorded_date != NULL) {
+                               _dst->video_meta->recorded_date = g_strdup(_src->video_meta->recorded_date);
                                if (_dst->video_meta->recorded_date == NULL) {
                                        media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                                        media_info_destroy((media_info_h)_dst);
                                        return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                                }
                        }
-                       if (STRING_VALID(_src->video_meta->copyright)) {
-                               _dst->video_meta->copyright = strdup(_src->video_meta->copyright);
+                       if (_src->video_meta->copyright != NULL) {
+                               _dst->video_meta->copyright = g_strdup(_src->video_meta->copyright);
                                if (_dst->video_meta->copyright == NULL) {
                                        media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                                        media_info_destroy((media_info_h)_dst);
                                        return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                                }
                        }
-                       if (STRING_VALID(_src->video_meta->track_num)) {
-                               _dst->video_meta->track_num = strdup(_src->video_meta->track_num);
+                       if (_src->video_meta->track_num != NULL) {
+                               _dst->video_meta->track_num = g_strdup(_src->video_meta->track_num);
                                if (_dst->video_meta->track_num == NULL) {
                                        media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                                        media_info_destroy((media_info_h)_dst);
@@ -999,88 +999,88 @@ int media_info_clone(media_info_h *dst, media_info_h src)
                                return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                        }
 
-                       if (STRING_VALID(_src->audio_meta->media_id)) {
-                               _dst->audio_meta->media_id = strdup(_src->audio_meta->media_id);
+                       if (_src->audio_meta->media_id != NULL) {
+                               _dst->audio_meta->media_id = g_strdup(_src->audio_meta->media_id);
                                if (_dst->audio_meta->media_id == NULL) {
                                        media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                                        media_info_destroy((media_info_h)_dst);
                                        return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                                }
                        }
-                       if (STRING_VALID(_src->audio_meta->title)) {
-                               _dst->audio_meta->title = strdup(_src->audio_meta->title);
+                       if (_src->audio_meta->title != NULL) {
+                               _dst->audio_meta->title = g_strdup(_src->audio_meta->title);
                                if (_dst->audio_meta->title == NULL) {
                                        media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                                        media_info_destroy((media_info_h)_dst);
                                        return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                                }
                        }
-                       if (STRING_VALID(_src->audio_meta->album)) {
-                               _dst->audio_meta->album = strdup(_src->audio_meta->album);
+                       if (_src->audio_meta->album != NULL) {
+                               _dst->audio_meta->album = g_strdup(_src->audio_meta->album);
                                if (_dst->audio_meta->album == NULL) {
                                        media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                                        media_info_destroy((media_info_h)_dst);
                                        return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                                }
                        }
-                       if (STRING_VALID(_src->audio_meta->artist)) {
-                               _dst->audio_meta->artist = strdup(_src->audio_meta->artist);
+                       if (_src->audio_meta->artist != NULL) {
+                               _dst->audio_meta->artist = g_strdup(_src->audio_meta->artist);
                                if (_dst->audio_meta->artist == NULL) {
                                        media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                                        media_info_destroy((media_info_h)_dst);
                                        return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                                }
                        }
-                       if (STRING_VALID(_src->audio_meta->album_artist)) {
-                               _dst->audio_meta->album_artist = strdup(_src->audio_meta->album_artist);
+                       if (_src->audio_meta->album_artist != NULL) {
+                               _dst->audio_meta->album_artist = g_strdup(_src->audio_meta->album_artist);
                                if (_dst->audio_meta->album_artist == NULL) {
                                        media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                                        media_info_destroy((media_info_h)_dst);
                                        return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                                }
                        }
-                       if (STRING_VALID(_src->audio_meta->genre)) {
-                               _dst->audio_meta->genre = strdup(_src->audio_meta->genre);
+                       if (_src->audio_meta->genre != NULL) {
+                               _dst->audio_meta->genre = g_strdup(_src->audio_meta->genre);
                                if (_dst->audio_meta->genre == NULL) {
                                        media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                                        media_info_destroy((media_info_h)_dst);
                                        return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                                }
                        }
-                       if (STRING_VALID(_src->audio_meta->composer)) {
-                               _dst->audio_meta->composer = strdup(_src->audio_meta->composer);
+                       if (_src->audio_meta->composer != NULL) {
+                               _dst->audio_meta->composer = g_strdup(_src->audio_meta->composer);
                                if (_dst->audio_meta->composer == NULL) {
                                        media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                                        media_info_destroy((media_info_h)_dst);
                                        return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                                }
                        }
-                       if (STRING_VALID(_src->audio_meta->year)) {
-                               _dst->audio_meta->year = strdup(_src->audio_meta->year);
+                       if (_src->audio_meta->year != NULL) {
+                               _dst->audio_meta->year = g_strdup(_src->audio_meta->year);
                                if (_dst->audio_meta->year == NULL) {
                                        media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                                        media_info_destroy((media_info_h)_dst);
                                        return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                                }
                        }
-                       if (STRING_VALID(_src->audio_meta->recorded_date)) {
-                               _dst->audio_meta->recorded_date = strdup(_src->audio_meta->recorded_date);
+                       if (_src->audio_meta->recorded_date != NULL) {
+                               _dst->audio_meta->recorded_date = g_strdup(_src->audio_meta->recorded_date);
                                if (_dst->audio_meta->recorded_date == NULL) {
                                        media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                                        media_info_destroy((media_info_h)_dst);
                                        return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                                }
                        }
-                       if (STRING_VALID(_src->audio_meta->copyright)) {
-                               _dst->audio_meta->copyright = strdup(_src->audio_meta->copyright);
+                       if (_src->audio_meta->copyright != NULL) {
+                               _dst->audio_meta->copyright = g_strdup(_src->audio_meta->copyright);
                                if (_dst->audio_meta->copyright == NULL) {
                                        media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                                        media_info_destroy((media_info_h)_dst);
                                        return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                                }
                        }
-                       if (STRING_VALID(_src->audio_meta->track_num)) {
-                               _dst->audio_meta->track_num = strdup(_src->audio_meta->track_num);
+                       if (_src->audio_meta->track_num != NULL) {
+                               _dst->audio_meta->track_num = g_strdup(_src->audio_meta->track_num);
                                if (_dst->audio_meta->track_num == NULL) {
                                        media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                                        media_info_destroy((media_info_h)_dst);
@@ -1376,8 +1376,8 @@ int media_info_get_display_name(media_info_h media, char **name)
        int ret = MEDIA_CONTENT_ERROR_NONE;
        media_info_s *_media = (media_info_s*)media;
        if (_media && name) {
-               if (STRING_VALID(_media->display_name)) {
-                       *name = strdup(_media->display_name);
+               if (_media->display_name != NULL) {
+                       *name = g_strdup(_media->display_name);
                        media_content_retvm_if(*name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
                } else {
                        *name = NULL;
@@ -1494,8 +1494,8 @@ int media_info_get_thumbnail_path(media_info_h media, char **path)
        int ret = MEDIA_CONTENT_ERROR_NONE;
        media_info_s *_media = (media_info_s*)media;
        if (_media && path) {
-               if (STRING_VALID(_media->thumbnail_path)) {
-                       *path = strdup(_media->thumbnail_path);
+               if (_media->thumbnail_path != NULL) {
+                       *path = g_strdup(_media->thumbnail_path);
                        media_content_retvm_if(*path == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
                } else {
                        *path = NULL;
@@ -1516,8 +1516,8 @@ int media_info_get_title(media_info_h media, char **title)
        media_info_s *_media = (media_info_s*)media;
 
        if (_media && title)    { /*title can be empty string*/
-               if (STRING_VALID(_media->title)) {
-                       *title = strdup(_media->title);
+               if (_media->title != NULL) {
+                       *title = g_strdup(_media->title);
                        media_content_retvm_if(*title == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
                } else {
                        *title = NULL;
@@ -1537,8 +1537,8 @@ int media_info_get_description(media_info_h media, char **description)
        media_info_s *_media = (media_info_s*)media;
 
        if (_media && description) {
-               if (STRING_VALID(_media->description)) {
-                       *description = strdup(_media->description);
+               if (_media->description != NULL) {      /*description can be empty string*/
+                       *description = g_strdup(_media->description);
                        media_content_retvm_if(*description == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
                } else {
                        *description = NULL;
@@ -1605,7 +1605,7 @@ int media_info_get_weather(media_info_h media, char **weather)
        media_info_s *_media = (media_info_s*)media;
 
        if (_media && weather) {
-               if (STRING_VALID(_media->weather)) {
+               if (_media->weather != NULL) {
                        *weather = strdup(_media->weather);
                        media_content_retvm_if(*weather == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
                } else {
@@ -1658,7 +1658,7 @@ int media_info_get_author(media_info_h media, char **author)
        media_info_s *_media = (media_info_s*)media;
 
        if (_media && author) {
-               if (STRING_VALID(_media->author)) {
+               if (_media->author != NULL) {
                        *author = strdup(_media->author);
                        media_content_retvm_if(*author == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
                } else {
@@ -1679,7 +1679,7 @@ int media_info_get_provider(media_info_h media, char **provider)
        media_info_s *_media = (media_info_s*)media;
 
        if (_media && provider) {
-               if (STRING_VALID(_media->provider)) {
+               if (_media->provider != NULL) {
                        *provider = strdup(_media->provider);
                        media_content_retvm_if(*provider == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
                } else {
@@ -1700,7 +1700,7 @@ int media_info_get_content_name(media_info_h media, char **content_name)
        media_info_s *_media = (media_info_s*)media;
 
        if (_media && content_name) {
-               if (STRING_VALID(_media->content_name)) {
+               if (_media->content_name != NULL) {
                        *content_name = strdup(_media->content_name);
                        media_content_retvm_if(*content_name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
                } else {
@@ -1721,7 +1721,7 @@ int media_info_get_category(media_info_h media, char **category)
        media_info_s *_media = (media_info_s*)media;
 
        if (_media && category) {
-               if (STRING_VALID(_media->category)) {
+               if (_media->category != NULL) {
                        *category = strdup(_media->category);
                        media_content_retvm_if(*category == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
                } else {
@@ -1742,7 +1742,7 @@ int media_info_get_location_tag(media_info_h media, char **location_tag)
        media_info_s *_media = (media_info_s*)media;
 
        if (_media && location_tag) {
-               if (STRING_VALID(_media->location_tag)) {
+               if (_media->location_tag != NULL) {
                        *location_tag = strdup(_media->location_tag);
                        media_content_retvm_if(*location_tag == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
                } else {
@@ -1763,7 +1763,7 @@ int media_info_get_age_rating(media_info_h media, char **age_rating)
        media_info_s *_media = (media_info_s*)media;
 
        if (_media && age_rating) {
-               if (STRING_VALID(_media->age_rating)) {
+               if (_media->age_rating != NULL) {
                        *age_rating = strdup(_media->age_rating);
                        media_content_retvm_if(*age_rating == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
                } else {
@@ -1784,7 +1784,7 @@ int media_info_get_keyword(media_info_h media, char **keyword)
        media_info_s *_media = (media_info_s*)media;
 
        if (_media && keyword) {
-               if (STRING_VALID(_media->keyword)) {
+               if (_media->keyword != NULL) {
                        *keyword = strdup(_media->keyword);
                        media_content_retvm_if(*keyword == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
                } else {

diff --git a/src/media_storage.c b/src/media_storage.c
index d00d15e..4bdddfe 100755 (executable)
--- a/src/media_storage.c
+++ b/src/media_storage.c
@@ -374,4 +374,4 @@ int media_storage_get_scan_status(const char *storage_uuid, media_storage_scan_s
        }
 
        return ret;
-}
\ No newline at end of file
+}

diff --git a/src/media_video.c b/src/media_video.c
index 29b2d19..bc91b9c 100755 (executable)
--- a/src/media_video.c
+++ b/src/media_video.c
@@ -55,8 +55,8 @@ int video_meta_clone(video_meta_h *dst, video_meta_h src)
                video_meta_s *_dst = (video_meta_s*)calloc(1, sizeof(video_meta_s));
                media_content_retvm_if(_dst == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 
-               if (STRING_VALID(_src->media_id)) {
-                       _dst->media_id = strdup(_src->media_id);
+               if (_src->media_id != NULL) {
+                       _dst->media_id = g_strdup(_src->media_id);
                        if (_dst->media_id == NULL) {
                                video_meta_destroy((video_meta_h)_dst);
                                media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
@@ -64,8 +64,8 @@ int video_meta_clone(video_meta_h *dst, video_meta_h src)
                        }
                }
 
-               if (STRING_VALID(_src->title)) {
-                       _dst->title = strdup(_src->title);
+               if (_src->title != NULL) {
+                       _dst->title = g_strdup(_src->title);
                        if (_dst->title == NULL) {
                                video_meta_destroy((video_meta_h)_dst);
                                media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
@@ -73,8 +73,8 @@ int video_meta_clone(video_meta_h *dst, video_meta_h src)
                        }
                }
 
-               if (STRING_VALID(_src->album)) {
-                       _dst->album = strdup(_src->album);
+               if (_src->album != NULL) {
+                       _dst->album = g_strdup(_src->album);
                        if (_dst->album == NULL) {
                                video_meta_destroy((video_meta_h)_dst);
                                media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
@@ -82,8 +82,8 @@ int video_meta_clone(video_meta_h *dst, video_meta_h src)
                        }
                }
 
-               if (STRING_VALID(_src->artist)) {
-                       _dst->artist = strdup(_src->artist);
+               if (_src->artist != NULL) {
+                       _dst->artist = g_strdup(_src->artist);
                        if (_dst->artist == NULL) {
                                video_meta_destroy((video_meta_h)_dst);
                                media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
@@ -91,8 +91,8 @@ int video_meta_clone(video_meta_h *dst, video_meta_h src)
                        }
                }
 
-               if (STRING_VALID(_src->album_artist)) {
-                       _dst->album_artist = strdup(_src->album_artist);
+               if (_src->album_artist != NULL) {
+                       _dst->album_artist = g_strdup(_src->album_artist);
                        if (_dst->album_artist == NULL) {
                                video_meta_destroy((video_meta_h)_dst);
                                media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
@@ -100,8 +100,8 @@ int video_meta_clone(video_meta_h *dst, video_meta_h src)
                        }
                }
 
-               if (STRING_VALID(_src->genre)) {
-                       _dst->genre = strdup(_src->genre);
+               if (_src->genre != NULL) {
+                       _dst->genre = g_strdup(_src->genre);
                        if (_dst->genre == NULL) {
                                video_meta_destroy((video_meta_h)_dst);
                                media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
@@ -109,8 +109,8 @@ int video_meta_clone(video_meta_h *dst, video_meta_h src)
                        }
                }
 
-               if (STRING_VALID(_src->composer)) {
-                       _dst->composer = strdup(_src->composer);
+               if (_src->composer != NULL) {
+                       _dst->composer = g_strdup(_src->composer);
                        if (_dst->composer == NULL) {
                                video_meta_destroy((video_meta_h)_dst);
                                media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
@@ -118,8 +118,8 @@ int video_meta_clone(video_meta_h *dst, video_meta_h src)
                        }
                }
 
-               if (STRING_VALID(_src->year)) {
-                       _dst->year = strdup(_src->year);
+               if (_src->year != NULL) {
+                       _dst->year = g_strdup(_src->year);
                        if (_dst->year == NULL) {
                                video_meta_destroy((video_meta_h)_dst);
                                media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
@@ -127,8 +127,8 @@ int video_meta_clone(video_meta_h *dst, video_meta_h src)
                        }
                }
 
-               if (STRING_VALID(_src->recorded_date)) {
-                       _dst->recorded_date = strdup(_src->recorded_date);
+               if (_src->recorded_date != NULL) {
+                       _dst->recorded_date = g_strdup(_src->recorded_date);
                        if (_dst->recorded_date == NULL) {
                                video_meta_destroy((video_meta_h)_dst);
                                media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
@@ -136,8 +136,8 @@ int video_meta_clone(video_meta_h *dst, video_meta_h src)
                        }
                }
 
-               if (STRING_VALID(_src->copyright)) {
-                       _dst->copyright = strdup(_src->copyright);
+               if (_src->copyright != NULL) {
+                       _dst->copyright = g_strdup(_src->copyright);
                        if (_dst->copyright == NULL) {
                                video_meta_destroy((video_meta_h)_dst);
                                media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
@@ -145,8 +145,8 @@ int video_meta_clone(video_meta_h *dst, video_meta_h src)
                        }
                }
 
-               if (STRING_VALID(_src->track_num)) {
-                       _dst->track_num = strdup(_src->track_num);
+               if (_src->track_num != NULL) {
+                       _dst->track_num = g_strdup(_src->track_num);
                        if (_dst->track_num == NULL) {
                                video_meta_destroy((video_meta_h)_dst);
                                media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
@@ -178,7 +178,7 @@ int video_meta_get_media_id(video_meta_h video, char **media_id)
        int ret = MEDIA_CONTENT_ERROR_NONE;
        video_meta_s *_video = (video_meta_s*)video;
        if (_video) {
-               if (STRING_VALID(_video->media_id)) {
+               if (_video->media_id != NULL) {
                        char *new_string = strdup(_video->media_id);
                        media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 
@@ -201,7 +201,7 @@ int video_meta_get_album(video_meta_h video, char **album)
        int ret = MEDIA_CONTENT_ERROR_NONE;
        video_meta_s *_video = (video_meta_s*)video;
        if (_video) {
-               if (STRING_VALID(_video->album)) {
+               if (_video->album != NULL) {
                        char *new_string = strdup(_video->album);
                        media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 
@@ -224,7 +224,7 @@ int video_meta_get_artist(video_meta_h video, char **artist)
        int ret = MEDIA_CONTENT_ERROR_NONE;
        video_meta_s *_video = (video_meta_s*)video;
        if (_video) {
-               if (STRING_VALID(_video->artist)) {
+               if (_video->artist != NULL) {
                        char *new_string = strdup(_video->artist);
                        media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 
@@ -247,7 +247,7 @@ int video_meta_get_album_artist(video_meta_h video, char **album_artist)
        int ret = MEDIA_CONTENT_ERROR_NONE;
        video_meta_s *_video = (video_meta_s*)video;
        if (_video) {
-               if (STRING_VALID(_video->album_artist)) {
+               if (_video->album_artist != NULL) {
                        char *new_string = strdup(_video->album_artist);
                        media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 
@@ -270,7 +270,7 @@ int video_meta_get_genre(video_meta_h video, char **genre)
        int ret = MEDIA_CONTENT_ERROR_NONE;
        video_meta_s *_video = (video_meta_s*)video;
        if (_video) {
-               if (STRING_VALID(_video->genre)) {
+               if (_video->genre != NULL) {
                        char *new_string = strdup(_video->genre);
                        media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 
@@ -293,7 +293,7 @@ int video_meta_get_composer(video_meta_h video, char **composer)
        int ret = MEDIA_CONTENT_ERROR_NONE;
        video_meta_s *_video = (video_meta_s*)video;
        if (_video) {
-               if (STRING_VALID(_video->composer)) {
+               if (_video->composer != NULL) {
                        char *new_string = strdup(_video->composer);
                        media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 
@@ -316,7 +316,7 @@ int video_meta_get_year(video_meta_h video, char **year)
        int ret = MEDIA_CONTENT_ERROR_NONE;
        video_meta_s *_video = (video_meta_s*)video;
        if (_video) {
-               if (STRING_VALID(_video->year)) {
+               if (_video->year != NULL) {
                        char *new_string = strdup(_video->year);
                        media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 
@@ -339,7 +339,7 @@ int video_meta_get_recorded_date(video_meta_h video, char **recorded_date)
        int ret = MEDIA_CONTENT_ERROR_NONE;
        video_meta_s *_video = (video_meta_s*)video;
        if (_video) {
-               if (STRING_VALID(_video->recorded_date)) {
+               if (_video->recorded_date != NULL) {
                        char *new_string = strdup(_video->recorded_date);
                        media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 
@@ -362,7 +362,7 @@ int video_meta_get_copyright(video_meta_h video, char **copyright)
        int ret = MEDIA_CONTENT_ERROR_NONE;
        video_meta_s *_video = (video_meta_s*)video;
        if (_video) {
-               if (STRING_VALID(_video->copyright)) {
+               if (_video->copyright != NULL) {
                        char *new_string = strdup(_video->copyright);
                        media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 
@@ -385,7 +385,7 @@ int video_meta_get_track_num(video_meta_h video, char **track_num)
        int ret = MEDIA_CONTENT_ERROR_NONE;
        video_meta_s *_video = (video_meta_s*)video;
        if (_video) {
-               if (STRING_VALID(_video->track_num)) {
+               if (_video->track_num != NULL) {
                        char *new_string = strdup(_video->track_num);
                        media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");