Refactoring of CMediaData class: Make it manage song list using CSongStorage class

Change-Id: I19fdd29a964148f9abee039d9a6bde35cd8c7c93
Signed-off-by: Kim Tae Soo <taesoo46.kim@samsung.com>

diff --git a/CMakeLists.txt b/CMakeLists.txt
index c68dd9d..173cc4c 100644 (file)
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -87,6 +87,7 @@ SET(SRCS src/main.cpp
         src/data/folder_info.cpp
         src/data/bus.cpp
         src/data/CategoryStorage.cpp
+        src/data/SongStorage.cpp
 )
 
 SET(TARGET_EDJ "${PROJECT_NAME}.edj")

diff --git a/include/SongStorage.h b/include/SongStorage.h
new file mode 100644 (file)
index 0000000..c843034
--- /dev/null
+++ b/include/SongStorage.h
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __SONG_STORAGE_H__
+#define __SONG_STORAGE_H__
+
+
+class CSongStorage {
+public:
+       enum EType {
+               SONGS_SONG_STORAGE,
+               ALBUM_SONG_STORAGE,
+               FOLDER_SONG_STORAGE,
+               PLAYLIST_SONG_STORAGE,
+               SINGLE_SONG_STORAGE,
+       };
+
+protected:
+       EType t_type;
+       int t_memberId;
+       CSongInfo *t_songInfo;
+       Eina_List *elList;
+
+private:
+       static bool sm_CbOnEachSong(media_info_h mh, void *dt);
+       bool m_OnEachSong(media_info_h mh);
+
+protected:
+       virtual bool t_GetSongList(CNameInfo *info, filter_h filter);
+
+public:
+       CSongStorage() { elList = NULL; }
+       virtual ~CSongStorage() {}
+
+       Eina_List *List(void);
+       void Delete(void);
+};
+
+class CSongsSongStorage : public CSongStorage {
+public:
+       CSongsSongStorage() { t_type = SONGS_SONG_STORAGE; }
+
+       bool Update(filter_h filter);
+};
+
+class CAlbumSongStorage : public CSongStorage {
+public:
+       CAlbumSongStorage() { t_type = ALBUM_SONG_STORAGE; }
+
+       bool Update(CAlbumInfo *alinfo, filter_h filter);
+};
+
+class CFolderSongStorage : public CSongStorage {
+public:
+       CFolderSongStorage() { t_type = FOLDER_SONG_STORAGE; }
+
+       bool Update(CFolderInfo *finfo, filter_h filter);
+};
+
+class CPlaylistSongStorage : public CSongStorage {
+public:
+       CPlaylistSongStorage() { t_type = PLAYLIST_SONG_STORAGE; }
+
+       bool Update(CCategoryInfo *catinfo, filter_h filter);
+};
+
+class CSingleSongStorage : public CSongStorage {
+public:
+       CSingleSongStorage() { t_type = SINGLE_SONG_STORAGE; }
+
+       CSongInfo *SongInfo(filter_h filter);
+};
+
+
+
+#endif // __SONG_STORAGE_H__
\ No newline at end of file

diff --git a/include/mediadata.h b/include/mediadata.h
index fb0423b..3e9f4a6 100644 (file)
--- a/include/mediadata.h
+++ b/include/mediadata.h
@@ -45,19 +45,13 @@ private:
 
 private:
        static bool sm_CbTotalDuration(media_info_h md_h, void *dt);
-       static bool sm_CbEachMediaData(media_info_h md_h, void *dt);
        static bool sm_CbEachFolderData(media_folder_h folder_h, void *dt);
        static bool sm_CbEachAlbumData(media_album_h album_h, void *dt);
        static bool sm_CbPlaylist(media_playlist_h ph, void *dt);
 
 private:
-       bool m_HandleEachMediaData(media_info_h md_h);
        bool m_HandleEachFolderData(media_folder_h folder_h);
        bool m_HandleEachAlbumData(media_album_h album_h);
-       void m_DeleteSongList(void);
-       void m_DeleteFolderSongList(void);
-       void m_DeleteAlbumSongList(void);
-       void m_DeletePlaylistSongList(void);
        void m_DeleteFolderList(void);
        void m_DeleteAlbumList(void);
        void m_DeleteCategoryList(ECategoryType type);
@@ -66,12 +60,8 @@ private:
        void m_DestroyFilter(void);
 
        void m_GetCategoryList(ECategoryType type);
-       int m_GetPlaylistSongList(CCategoryInfo *catinfo);
-       int m_GetFolderSongList(CFolderInfo *finfo);
        int m_GetFolderList(void);
-       int m_GetAlbumSongList(CAlbumInfo *alinfo);
        int m_GetAlbumList(void);
-       int m_GetSongList(void);
        void m_UpdateLists(void);
 
 public:

diff --git a/src/data/CategoryStorage.cpp b/src/data/CategoryStorage.cpp
index 7e7b946..4ea93bd 100644 (file)
--- a/src/data/CategoryStorage.cpp
+++ b/src/data/CategoryStorage.cpp
@@ -135,14 +135,13 @@ bool CPlaylistStorage::m_OnEachPlaylist(media_playlist_h ph)
                int categoryId = 0;
                int songCount = 0;
                _CHECK(catinfo = new CCategoryInfo)
-                       _CHECK(catinfo->Create())
-                       _CHECK(media_playlist_get_name(ph, &tmpStr) == MEDIA_CONTENT_ERROR_NONE)
-                       _CHECK(media_playlist_get_playlist_id(ph, &categoryId) == MEDIA_CONTENT_ERROR_NONE)
-                       _CHECK(media_playlist_get_media_count_from_db(catinfo->CategoryId(), NULL, &songCount) == MEDIA_CONTENT_ERROR_NONE)
-                       _CHECK(media_playlist_foreach_media_from_db(catinfo->CategoryId(), NULL,
-                       sm_CbPlaylistMember, (void *)catinfo) == MEDIA_CONTENT_ERROR_NONE)
-
-                       _WHEN_SUCCESS{
+               _CHECK(catinfo->Create())
+               _CHECK(media_playlist_get_name(ph, &tmpStr) == MEDIA_CONTENT_ERROR_NONE)
+               _CHECK(media_playlist_get_playlist_id(ph, &categoryId) == MEDIA_CONTENT_ERROR_NONE)
+               _CHECK(media_playlist_get_media_count_from_db(catinfo->CategoryId(), NULL, &songCount) == MEDIA_CONTENT_ERROR_NONE)
+               _CHECK(media_playlist_foreach_media_from_db(catinfo->CategoryId(), NULL, sm_CbPlaylistMember, (void *)catinfo) == MEDIA_CONTENT_ERROR_NONE)
+
+               _WHEN_SUCCESS {
                        catinfo->SetName(tmpStr);
                        catinfo->SetCategoryId(categoryId);
                        catinfo->SetSongCount(songCount);

diff --git a/src/data/SongStorage.cpp b/src/data/SongStorage.cpp
new file mode 100644 (file)
index 0000000..7f33e23
--- /dev/null
+++ b/src/data/SongStorage.cpp
@@ -0,0 +1,285 @@
+/*
+ * Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#include <Eina.h>
+#include <media_content.h>
+#include <sys/time.h>
+#include <stdlib.h>
+#include <string.h>
+#include "dbg.h"
+#include "i18n.h"
+#include "define.h"
+
+#include <AppCommon.h>
+#include "song_info.h"
+#include "album_info.h"
+#include "category_info.h"
+#include "folder_info.h"
+#include "SongStorage.h"
+#include "common.h"
+
+
+bool CSongStorage::sm_CbOnEachSong(media_info_h mh, void *dt)
+{
+       CSongStorage *root = (CSongStorage *)dt;
+       bool r = false;
+       if (root)
+               r = root->m_OnEachSong(mh);
+
+       return r;
+}
+
+
+bool CSongStorage::m_OnEachSong(media_info_h mh)
+{
+       _CREATE_BEGIN {
+               CSongInfo *songInfo = NULL;
+               audio_meta_h audio_h = NULL;
+               char *filePath;
+               char *thumbnailPath;
+               int mediaType;
+               char *mediaId;
+               char *title;
+               char *artist;
+               char *album;
+               char *genre;
+               char *composer;
+               int duration;
+
+               _CHECK(songInfo = new CSongInfo)
+               _CHECK(songInfo->Create())
+               _CHECK(media_info_get_file_path(mh, &filePath) == MEDIA_CONTENT_ERROR_NONE)
+               _CHECK(media_info_get_thumbnail_path(mh, &thumbnailPath) == MEDIA_CONTENT_ERROR_NONE)
+               _CHECK(media_info_get_media_type(mh, (media_content_type_e *)&mediaType) == MEDIA_CONTENT_ERROR_NONE)
+               _CHECK(media_info_get_audio(mh, &audio_h) == MEDIA_CONTENT_ERROR_NONE)
+               _CHECK(audio_meta_get_media_id(audio_h, &mediaId) == MEDIA_CONTENT_ERROR_NONE)
+               _CHECK(media_info_get_title(mh, &title) == MEDIA_CONTENT_ERROR_NONE)
+               _CHECK(audio_meta_get_artist(audio_h, &artist) == MEDIA_CONTENT_ERROR_NONE)
+               _CHECK(audio_meta_get_album(audio_h, &album) == MEDIA_CONTENT_ERROR_NONE)
+               _CHECK(audio_meta_get_genre(audio_h, &genre) == MEDIA_CONTENT_ERROR_NONE)
+               _CHECK(audio_meta_get_composer(audio_h, &composer) == MEDIA_CONTENT_ERROR_NONE)
+               _CHECK(audio_meta_get_duration(audio_h, &duration) == MEDIA_CONTENT_ERROR_NONE)
+
+
+               _WHEN_SUCCESS {
+                       songInfo->SetPath(filePath);
+                       songInfo->SetThumbnailPath(thumbnailPath);
+                       songInfo->SetType(mediaType);
+                       songInfo->SetId(mediaId);
+                       songInfo->SetName(title);
+                       songInfo->SetArtist(artist);
+                       songInfo->SetAlbum(album);
+                       songInfo->SetGenre(genre);
+                       songInfo->SetComposer(composer);
+                       songInfo->SetDuration(duration);
+
+                       audio_meta_destroy(audio_h);
+
+                       switch (t_type) {
+                       case SONGS_SONG_STORAGE:
+                       case ALBUM_SONG_STORAGE:
+                       case FOLDER_SONG_STORAGE:
+                               elList = eina_list_append(elList, songInfo);
+                               break;
+
+                       case PLAYLIST_SONG_STORAGE:
+                               songInfo->SetMemberId(t_memberId);
+                               elList = eina_list_append(elList, songInfo);
+                               break;
+
+                       case SINGLE_SONG_STORAGE:
+                               t_songInfo = songInfo;
+                               break;
+
+                       default:
+                               _ERR("Invalid Song Storage Type!!");
+                               ASSERT(0);
+                               break;
+                       }
+               }
+
+               _CHECK_FAIL{}
+               _CHECK_FAIL{}
+               _CHECK_FAIL{}
+               _CHECK_FAIL{}
+               _CHECK_FAIL{}
+               _CHECK_FAIL{}
+               _CHECK_FAIL{}
+               _CHECK_FAIL{ audio_meta_destroy(audio_h); }
+               _CHECK_FAIL{}
+               _CHECK_FAIL{}
+               _CHECK_FAIL{}
+               _CHECK_FAIL{ songInfo->Destroy(); }
+               _CHECK_FAIL{ delete songInfo; }
+       } _CREATE_END_AND_CATCH{ return false; }
+
+       return true;
+}
+
+
+bool CSongStorage::t_GetSongList(CNameInfo *info, filter_h filter)
+{
+       int r;
+
+       switch (t_type) {
+       case SONGS_SONG_STORAGE:
+       case SINGLE_SONG_STORAGE:
+               {
+                       r = media_info_foreach_media_from_db(filter,
+                               sm_CbOnEachSong, (void *)this);
+                       if (r != MEDIA_CONTENT_ERROR_NONE) {
+                               _ERR("media_info_foreach_media_from_db failed");
+                               return false;
+                       }
+               }
+               break;
+
+       case ALBUM_SONG_STORAGE:
+               {
+                       ASSERT(info);
+                       CAlbumInfo *alinfo = (CAlbumInfo *)info;
+
+                       r = media_album_foreach_media_from_db(alinfo->AlbumId(), filter,
+                               sm_CbOnEachSong, (void *)this);
+                       if (r != MEDIA_CONTENT_ERROR_NONE) {
+                               _ERR("media_album_foreach_media_from_db failed");
+                               return false;
+                       }
+               }
+               break;
+
+       case FOLDER_SONG_STORAGE:
+               {
+                       ASSERT(info);
+                       CFolderInfo *finfo = (CFolderInfo *)info;
+
+                       r = media_folder_foreach_media_from_db(finfo->Id(), filter,
+                               sm_CbOnEachSong, (void *)this);
+                       if (r != MEDIA_CONTENT_ERROR_NONE) {
+                               _ERR("media_folder_foreach_media_from_db failed");
+                               return false;
+                       }
+               }
+               break;
+
+       case PLAYLIST_SONG_STORAGE:
+               {
+                       ASSERT(info);
+                       CCategoryInfo *catinfo = (CCategoryInfo *)info;
+                       CCategoryInfo::CListMember *member = NULL;
+                       media_info_h mdh;
+                       Eina_List *l = NULL;
+                       void *obj = NULL;
+                       int r;
+
+                       if (!catinfo->MemberList()) {
+                               _DBG("Playlist is empty");
+                               return false;
+                       }
+
+                       EINA_LIST_FOREACH(catinfo->MemberList(), l, obj) {
+                               member = (CCategoryInfo::CListMember *)obj;
+                               if (!member->mediaId)
+                                       continue;
+
+                               r = media_info_get_media_from_db(member->mediaId, &mdh);
+                               if (r != MEDIA_CONTENT_ERROR_NONE) {
+                                       _ERR("unable to get handle from id");
+                                       continue;
+                               }
+
+                               t_memberId = member->memberId;
+                               if (!m_OnEachSong(mdh)) {
+                                       _ERR("unable to get media data");
+                                       return false;
+                               }
+                       }
+               }
+               break;
+
+       default:
+               _ERR("Invalid Song Storage Type!!");
+               ASSERT(0);
+               break;
+       }
+
+       return true;
+}
+
+
+Eina_List *CSongStorage::List(void)
+{
+       return elList;
+}
+
+
+void CSongStorage::Delete(void)
+{
+       if (!elList)
+               return;
+
+       CSongInfo *songInfo = NULL;
+       void *obj = NULL;
+
+       EINA_LIST_FREE(elList, obj) {
+               songInfo = (CSongInfo *)obj;
+               songInfo->Destroy();
+               delete songInfo;
+       }
+
+       elList = NULL;
+}
+
+
+bool CSongsSongStorage::Update(filter_h filter)
+{
+       Delete();
+       t_GetSongList(NULL, filter);
+       return true;
+}
+
+
+bool CAlbumSongStorage::Update(CAlbumInfo *alinfo, filter_h filter)
+{
+       Delete();
+       t_GetSongList(alinfo, filter);
+       return true;
+}
+
+
+bool CFolderSongStorage::Update(CFolderInfo *finfo, filter_h filter)
+{
+       Delete();
+       t_GetSongList(finfo, filter);
+       return true;
+}
+
+
+bool CPlaylistSongStorage::Update(CCategoryInfo *catinfo, filter_h filter)
+{
+       Delete();
+       t_GetSongList(catinfo, filter);
+       return true;
+}
+
+
+CSongInfo *CSingleSongStorage::SongInfo(filter_h filter)
+{
+       Delete();
+       t_GetSongList(NULL, filter);
+       return t_songInfo;
+}
\ No newline at end of file

diff --git a/src/data/mediadata.cpp b/src/data/mediadata.cpp
index 6893576..9cf3bb9 100644 (file)
--- a/src/data/mediadata.cpp
+++ b/src/data/mediadata.cpp
@@ -29,6 +29,7 @@
 #include "category_info.h"
 #include "folder_info.h"
 #include "CategoryStorage.h"
+#include "SongStorage.h"
 #include "mediadata.h"
 #include "common.h"
 
@@ -48,19 +49,19 @@ enum songlist_type {
 
 
 struct SMediadata {
-       Eina_List *songlist;
        Eina_List *folderlist;
-       Eina_List *folder_songlist;
        Eina_List *albumlist;
-       Eina_List *album_songlist;
 
-       //Eina_List *categoryList[CAT_TYPE_MAX];
+       CSongsSongStorage    *storageSong;
+       CAlbumSongStorage    *storageAlbumSong;
+       CFolderSongStorage   *storageFolderSong;
+       CPlaylistSongStorage *storagePlaylistSong;
+       CSingleSongStorage   *storageSingleSong;
 
        CPlaylistStorage *storagePlaylist;
        CArtistStorage   *storageArtist;
        CGenreStorage    *storageGenre;
 
-       Eina_List *playlist_songlist;
        Eina_List *cblist;
        CSongInfo *songInfo;
        filter_h filter;
@@ -70,6 +71,11 @@ struct SMediadata {
        SMediadata() {
                memset(this, 0, sizeof(SMediadata));
 
+               storageSong = new CSongsSongStorage;
+               storageFolderSong = new CFolderSongStorage;
+               storageAlbumSong = new CAlbumSongStorage;
+               storagePlaylistSong = new CPlaylistSongStorage;
+               storageSingleSong = new CSingleSongStorage;
                storagePlaylist = new CPlaylistStorage;
                storageArtist = new CArtistStorage;
                storageGenre = new CGenreStorage;
@@ -78,6 +84,11 @@ struct SMediadata {
                delete storageGenre;
                delete storageArtist;
                delete storagePlaylist;
+               delete storageSingleSong;
+               delete storagePlaylistSong;
+               delete storageAlbumSong;
+               delete storageFolderSong;
+               delete storageSong;
        }
 };
 
@@ -252,19 +263,6 @@ bool CMediadata::sm_CbTotalDuration(media_info_h md_h, void *dt)
 }
 
 
-bool CMediadata::sm_CbEachMediaData(media_info_h md_h, void *dt)
-{
-       CMediadata *root = (CMediadata *)dt;
-
-       if (!root)
-               return false;
-
-       root->m_HandleEachMediaData(md_h);
-
-       return true;
-}
-
-
 bool CMediadata::sm_CbEachFolderData(media_folder_h folder_h, void *dt)
 {
        CMediadata *root = (CMediadata *)dt;
@@ -325,127 +323,6 @@ bool CMediadata::sm_CbPlaylist(media_playlist_h ph, void* dt)
 }
 
 
-bool CMediadata::m_HandleEachMediaData(media_info_h md_h)
-{
-       CSongInfo *songInfo = NULL;
-       audio_meta_h audio_h = NULL;
-       char* tmpStr = NULL;
-       int tmpValue;
-       bool ret;
-
-       songInfo = new CSongInfo;
-       if (!songInfo) {
-               _ERR("Memory alloc failed");
-               return false;
-       }
-
-       ret = songInfo->Create();
-       if (!ret) {
-               _ERR("CSongInfo creation failed");
-               delete songInfo;
-               return false;
-       }
-
-       if (media_info_get_file_path(md_h, &tmpStr)
-               != MEDIA_CONTENT_ERROR_NONE) {
-               _ERR("Media file path Fetch error");
-               songInfo->Destroy();
-               delete songInfo;
-               return false;
-       }
-       songInfo->SetPath(tmpStr);
-
-       if (media_info_get_thumbnail_path(md_h, &tmpStr) !=
-               MEDIA_CONTENT_ERROR_NONE)
-               _ERR("Media thumbnail path Fetch error");
-       songInfo->SetThumbnailPath(tmpStr);
-
-       if (media_info_get_media_type(md_h,
-               (media_content_type_e *)&tmpValue) !=
-               MEDIA_CONTENT_ERROR_NONE)
-               _ERR("Media type Fetch error");
-       songInfo->SetType(tmpValue);
-
-       if (media_info_get_audio(md_h, &audio_h) !=
-               MEDIA_CONTENT_ERROR_NONE) {
-               _ERR("Media info get audio error");
-               songInfo->Destroy();
-               delete songInfo;
-               return false;
-       }
-
-       if (audio_meta_get_media_id(audio_h, &tmpStr) !=
-               MEDIA_CONTENT_ERROR_NONE) {
-               _ERR("Media ID Fetch error");
-               audio_meta_destroy(audio_h);
-               songInfo->Destroy();
-               delete songInfo;
-               return false;
-       }
-       songInfo->SetId(tmpStr);
-
-       if (media_info_get_title(md_h, &tmpStr) !=
-               MEDIA_CONTENT_ERROR_NONE)
-               _ERR("audio title get error");
-       songInfo->SetName(tmpStr);
-
-       if (audio_meta_get_artist(audio_h, &tmpStr) !=
-               MEDIA_CONTENT_ERROR_NONE)
-               _ERR("audio artist get error");
-       songInfo->SetArtist(tmpStr);
-
-       if (audio_meta_get_album(audio_h, &tmpStr) !=
-               MEDIA_CONTENT_ERROR_NONE)
-               _ERR("audio album get error");
-       songInfo->SetAlbum(tmpStr);
-
-       if (audio_meta_get_genre(audio_h, &tmpStr) !=
-               MEDIA_CONTENT_ERROR_NONE)
-               _ERR("audio genre get error");
-       songInfo->SetGenre(tmpStr);
-
-       if (audio_meta_get_composer(audio_h, &tmpStr) !=
-               MEDIA_CONTENT_ERROR_NONE)
-               _ERR("audio composer get error");
-       songInfo->SetComposer(tmpStr);
-
-       if (audio_meta_get_duration(audio_h, &tmpValue) !=
-               MEDIA_CONTENT_ERROR_NONE)
-               _ERR("audio duration get error");
-       songInfo->SetDuration(tmpValue);
-
-       audio_meta_destroy(audio_h);
-
-       switch (m->slist_type) {
-       case E_FOLDER_SONGS:
-               m->folder_songlist = eina_list_append(
-                       m->folder_songlist, songInfo);
-               break;
-
-       case E_ALBUM_SONGS:
-               m->album_songlist = eina_list_append(
-                       m->album_songlist, songInfo);
-               break;
-
-       case E_PLAYLIST_SONGS:
-               songInfo->SetMemberId(m->member_id);
-               m->playlist_songlist = eina_list_append(
-                       m->playlist_songlist, songInfo);
-               break;
-
-       case E_SINGLE_SONG:
-               m->songInfo = songInfo;
-               break;
-
-       case E_ALL_SONGS:
-       default:
-               m->songlist = eina_list_append(m->songlist, songInfo);
-               break;
-       }
-       return true;
-}
-
-
 bool CMediadata::m_HandleEachFolderData(media_folder_h folder_h)
 {
        CFolderInfo *finfo = NULL;
@@ -567,12 +444,9 @@ bool CMediadata::m_HandleEachAlbumData(media_album_h album_h)
        }
        alinfo->SetSongCount(tmpValue);
 
-       if (m->album_songlist)
-               m_DeleteAlbumSongList();
+       m->storageAlbumSong->Update(alinfo, m->filter);
 
-       m_GetAlbumSongList(alinfo);
-
-       EINA_LIST_FOREACH(m->album_songlist, l, obj) {
+       EINA_LIST_FOREACH(m->storageAlbumSong->List(), l, obj) {
                songInfo = (CSongInfo *)obj;
                tmpStr = songInfo->Genre();
                if (tmpStr) {
@@ -581,7 +455,7 @@ bool CMediadata::m_HandleEachAlbumData(media_album_h album_h)
                }
        }
 
-       EINA_LIST_FOREACH(m->album_songlist, l, obj) {
+       EINA_LIST_FOREACH(m->storageAlbumSong->List(), l, obj) {
                songInfo = (CSongInfo *)obj;
                tmpStr = songInfo->ThumbnailPath();
                if (tmpStr) {
@@ -594,76 +468,6 @@ bool CMediadata::m_HandleEachAlbumData(media_album_h album_h)
        return true;
 }
 
-void CMediadata::m_DeleteSongList(void)
-{
-       if (!m->songlist)
-               return;
-
-       CSongInfo *songInfo = NULL;
-       void *obj = NULL;
-
-       EINA_LIST_FREE(m->songlist, obj) {
-               songInfo = (CSongInfo *)obj;
-               songInfo->Destroy();
-               delete songInfo;
-       }
-
-       m->songlist = NULL;
-}
-
-
-void CMediadata::m_DeleteFolderSongList(void)
-{
-       CSongInfo *songInfo = NULL;
-       void *obj = NULL;
-
-       if (!m->folder_songlist)
-               return;
-
-       EINA_LIST_FREE(m->folder_songlist, obj) {
-               songInfo = (CSongInfo *)obj;
-               songInfo->Destroy();
-               delete songInfo;
-       }
-
-       m->folder_songlist = NULL;
-}
-
-
-void CMediadata::m_DeleteAlbumSongList(void)
-{
-       CSongInfo *songInfo = NULL;
-       void *obj = NULL;
-       if (!m->album_songlist)
-               return;
-
-       EINA_LIST_FREE(m->album_songlist, obj) {
-               songInfo = (CSongInfo *)obj;
-               songInfo->Destroy();
-               delete songInfo;
-       }
-
-       m->album_songlist = NULL;
-}
-
-
-void CMediadata::m_DeletePlaylistSongList(void)
-{
-       CSongInfo *songInfo = NULL;
-       void *obj = NULL;
-
-       if (!m->playlist_songlist)
-               return;
-
-       EINA_LIST_FREE(m->playlist_songlist, obj) {
-               songInfo = (CSongInfo *)obj;
-               songInfo->Destroy();
-               delete songInfo;
-       }
-
-       m->playlist_songlist = NULL;
-}
-
 
 void CMediadata::m_DeleteFolderList(void)
 {
@@ -760,7 +564,6 @@ void CMediadata::m_DestroyFilter(void)
 }
 
 
-
 void CMediadata::m_GetCategoryList(ECategoryType type)
 {
        CAlbumInfo *alinfo = NULL;
@@ -821,60 +624,6 @@ void CMediadata::m_GetCategoryList(ECategoryType type)
 }
 
 
-int CMediadata::m_GetPlaylistSongList(CCategoryInfo *catinfo)
-{
-       media_info_h mdh;
-       Eina_List *l = NULL;
-       CCategoryInfo::CListMember *member = NULL;
-       void *obj = NULL;
-       int r;
-
-       if (!catinfo || !catinfo->MemberList()) {
-               _ERR(" Invalid argument ");
-               return false;
-       }
-
-       m->slist_type = E_PLAYLIST_SONGS;
-
-       EINA_LIST_FOREACH(catinfo->MemberList(), l, obj) {
-               member = (CCategoryInfo::CListMember *)obj;
-               if (!member->mediaId)
-                       continue;
-
-               r = media_info_get_media_from_db(member->mediaId, &mdh);
-               if (r != MEDIA_CONTENT_ERROR_NONE) {
-                       _ERR("unable to get handle from id");
-                       continue;
-               }
-
-               m->member_id = member->memberId;
-               if (!m_HandleEachMediaData(mdh))
-                       _ERR("unable to get media data");
-       }
-
-       return true;
-}
-
-
-int CMediadata::m_GetFolderSongList(CFolderInfo *finfo)
-{
-       char *id = NULL;
-       int r;
-
-       id = finfo->Id();
-
-       m->slist_type = E_FOLDER_SONGS;
-       r = media_folder_foreach_media_from_db(id, m->filter,
-               sm_CbEachMediaData, (void *)this);
-       if (r != MEDIA_CONTENT_ERROR_NONE) {
-               _ERR("Media folder foreach folder from db failed");
-               return false;
-       }
-
-       return true;
-}
-
-
 int CMediadata::m_GetFolderList(void)
 {
        int r;
@@ -890,25 +639,6 @@ int CMediadata::m_GetFolderList(void)
 }
 
 
-int CMediadata::m_GetAlbumSongList(CAlbumInfo *alinfo)
-{
-       int id;
-       int r;
-
-       id = alinfo->AlbumId();
-
-       m->slist_type = E_ALBUM_SONGS;
-       r = media_album_foreach_media_from_db(id, m->filter,
-               sm_CbEachMediaData, (void *)this);
-       if (r != MEDIA_CONTENT_ERROR_NONE) {
-               _ERR("Media folder foreach folder from db failed");
-               return false;
-       }
-
-       return true;
-}
-
-
 int CMediadata::m_GetAlbumList(void)
 {
        int r;
@@ -924,22 +654,6 @@ int CMediadata::m_GetAlbumList(void)
 }
 
 
-int CMediadata::m_GetSongList(void)
-{
-       int r;
-
-       m->slist_type = E_ALL_SONGS;
-       r = media_info_foreach_media_from_db(m->filter,
-               sm_CbEachMediaData, (void *)this);
-       if (r != MEDIA_CONTENT_ERROR_NONE) {
-               _ERR("Media folder foreach folder from db failed");
-               return false;
-       }
-
-       return true;
-}
-
-
 void CMediadata::m_UpdateLists(void)
 {
        bool r;
@@ -950,8 +664,7 @@ void CMediadata::m_UpdateLists(void)
                return;
        }
 
-       m_DeleteSongList();
-       m_GetSongList();
+       m->storageSong->Update(m->filter);
 
        m_DeleteAlbumList();
        m_GetAlbumList();
@@ -998,15 +711,16 @@ void CMediadata::Destroy(void)
        struct SCbInfo *cbinfo;
        void *obj;
 
-       m_DeleteSongList();
+       m->storageSong->Delete();
        m_DeleteAlbumList();
-       m_DeleteAlbumSongList();
+       m->storageAlbumSong->Delete();
        m_DeleteFolderList();
-       m_DeleteFolderSongList();
+       m->storageFolderSong->Delete();
        m_DeleteCategoryList(CAT_TYPE_ARTIST);
        m_DeleteCategoryList(CAT_TYPE_GENRE);
        m_DeleteCategoryList(CAT_TYPE_PLAYLISTS);
-       m_DeletePlaylistSongList();
+       m->storagePlaylistSong->Delete();
+
        if (m->songInfo && m->songInfo->FlagCreate())
                m->songInfo->Destroy();
        delete m->songInfo;
@@ -1092,14 +806,7 @@ CSongInfo *CMediadata::SongByUri(char *uri)
        media_filter_set_condition(filter, buf,
                MEDIA_CONTENT_COLLATE_DEFAULT);
 
-       m->slist_type = E_SINGLE_SONG;
-       r = media_info_foreach_media_from_db(filter, sm_CbEachMediaData,
-               (void *)this);
-       if (r != MEDIA_CONTENT_ERROR_NONE)
-               _ERR("Failed to fetch media info");
-
-       if (media_filter_destroy(filter) != MEDIA_CONTENT_ERROR_NONE)
-               _ERR("Filter destroy failed");
+       m->songInfo = m->storageSingleSong->SongInfo(filter);
 
        return m->songInfo;
 }
@@ -1116,23 +823,21 @@ Eina_List *CMediadata::Medialist(int source_type, int listType, void *info)
 
        switch (listType) {
        case LIST_TYPE_SONG:
-               return m->songlist;
+               return m->storageSong->List();
 
        case LIST_TYPE_ALBUM:
                return m->albumlist;
 
        case LIST_TYPE_ALBUM_SONG:
-               m_DeleteAlbumSongList();
-               m_GetAlbumSongList((CAlbumInfo *)info);
-               return m->album_songlist;
+               m->storageAlbumSong->Update((CAlbumInfo *)info, m->filter);
+               return m->storageAlbumSong->List();
 
        case LIST_TYPE_FOLDER:
                return m->folderlist;
 
        case LIST_TYPE_FOLDER_SONG:
-               m_DeleteFolderSongList();
-               m_GetFolderSongList((CFolderInfo *)info);
-               return m->folder_songlist;
+               m->storageFolderSong->Update((CFolderInfo *)info, m->filter);
+               return m->storageFolderSong->List();
 
        case LIST_TYPE_ARTIST:
                return m->storageArtist->List();
@@ -1145,9 +850,8 @@ Eina_List *CMediadata::Medialist(int source_type, int listType, void *info)
                return m->storagePlaylist->List();
 
        case LIST_TYPE_PLAYLISTS_SONG:
-               m_DeletePlaylistSongList();
-               m_GetPlaylistSongList((CCategoryInfo *)info);
-               return m->playlist_songlist;
+               m->storagePlaylistSong->Update((CCategoryInfo *)info, m->filter);
+               return m->storagePlaylistSong->List();
 
        default:
                _ERR(" Wrong list type ");