Merge all storage tables

[platform/core/api/media-content.git] / src / media_db.c

diff --git a/src/media_db.c b/src/media_db.c
index 8169166..b69774d 100755 (executable)
--- a/src/media_db.c
+++ b/src/media_db.c
@@ -19,7 +19,6 @@
 #include <media_info_private.h>
 #include <media_util_private.h>
 
-static char * __media_db_get_group_name(media_group_e group);
 static int __media_db_make_query(filter_h filter, char *select_query, int select_query_size, char **condition_query, char **option_query);
 
 static char * __media_db_get_group_name(media_group_e group)
@@ -220,6 +219,7 @@ static int __media_db_make_query(filter_h filter, char *select_query, int select
        return ret;
 }
 
+#ifdef _USE_TVPD_MODE
 int _media_db_get_group_count(filter_h filter, group_list_e group_type, int *group_count)
 {
        int ret = MEDIA_CONTENT_ERROR_NONE;
@@ -286,10 +286,8 @@ int _media_db_get_group_count(filter_h filter, group_list_e group_type, int *gro
                else
                        snprintf(select_query, sizeof(select_query), SELECT_FACE_COUNT, DB_VIEW_MEDIA);
                break;
-#ifdef _USE_TVPD_MODE
        case MEDIA_GROUP_PVR:
        case MEDIA_GROUP_UHD:
-#endif
        default:
                {
                        media_content_error("Invalid group type [%d]", group_type);
@@ -301,7 +299,7 @@ int _media_db_get_group_count(filter_h filter, group_list_e group_type, int *gro
        ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
-       ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
+       ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
@@ -324,7 +322,6 @@ int _media_db_get_media_group_count(media_group_e group, filter_h filter, int *g
        filter_s *_filter = (filter_s*)filter;
 
        memset(select_query, 0x00, sizeof(select_query));
-#ifdef _USE_TVPD_MODE
        if (group < MEDIA_PVR_GROUP_DURATION) { /*media content*/
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
                        snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_COUNT, __media_db_get_group_name(group), _filter->storage_id);
@@ -341,12 +338,6 @@ int _media_db_get_media_group_count(media_group_e group, filter_h filter, int *g
                else
                        snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_COUNT, __media_db_get_group_name(group));
        }
-#else
-       if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
-               snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_COUNT, __media_db_get_group_name(group), _filter->storage_id);
-       else
-               snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_COUNT, __media_db_get_group_name(group), DB_VIEW_MEDIA);
-#endif
        ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
@@ -360,7 +351,7 @@ int _media_db_get_media_group_count(media_group_e group, filter_h filter, int *g
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
 
-       ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
+       ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
@@ -383,7 +374,6 @@ int _media_db_get_media_group(media_group_e group, filter_h filter, media_group_
        sqlite3_stmt *stmt = NULL;
        filter_s *_filter = (filter_s*)filter;
        memset(select_query, 0x00, sizeof(select_query));
-#ifdef _USE_TVPD_MODE
        if (group < MEDIA_PVR_GROUP_DURATION) { /*media content */
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
                        snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_LIST, __media_db_get_group_name(group), _filter->storage_id);
@@ -400,16 +390,10 @@ int _media_db_get_media_group(media_group_e group, filter_h filter, media_group_
                else
                        snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_LIST, __media_db_get_group_name(group));
        }
-#else
-       if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
-               snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_LIST, __media_db_get_group_name(group), _filter->storage_id);
-       else
-               snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_LIST, __media_db_get_group_name(group), DB_VIEW_MEDIA);
-#endif
        ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
-       ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
+       ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
@@ -429,7 +413,7 @@ int _media_db_get_media_group(media_group_e group, filter_h filter, media_group_
 
        return ret;
 }
-#ifdef _USE_TVPD_MODE
+
 int _media_db_get_media_group_and_count(media_group_e group, filter_h filter, media_group_and_count_cb callback, void *user_data)
 {
        int ret = MEDIA_CONTENT_ERROR_NONE;
@@ -475,7 +459,7 @@ int _media_db_get_media_group_and_count(media_group_e group, filter_h filter, me
        else
                snprintf(group_query, sizeof(group_query), "GROUP BY %s", group_name);
 
-       ret = _content_query_prepare(&stmt, select_query, condition_query, group_query);
+       ret = _content_query_prepare(select_query, condition_query, group_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
@@ -496,7 +480,179 @@ int _media_db_get_media_group_and_count(media_group_e group, filter_h filter, me
 
        return ret;
 }
+#else
+int _media_db_get_group_count(filter_h filter, group_list_e group_type, int *group_count)
+{
+       int ret = MEDIA_CONTENT_ERROR_NONE;
+       sqlite3_stmt *stmt = NULL;
+       char select_query[MAX_QUERY_SIZE] = {0, };
+       char *condition_query = NULL;
+       char *option_query = NULL;
+       filter_s *_filter = (filter_s*)filter;
+
+       memset(select_query, 0x00, sizeof(select_query));
+
+       switch (group_type) {
+       case MEDIA_GROUP_NONE:
+       case MEDIA_GROUP_TAG_BY_MEDIA_ID:
+       case MEDIA_GROUP_BOOKMARK_BY_MEDIA_ID:
+       case MEDIA_GROUP_FACE_BY_MEDIA_ID:
+               {
+                       media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+                       return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+               }
+               break;
+       case MEDIA_GROUP_ALBUM:
+               if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
+                       snprintf(select_query, sizeof(select_query), SELECT_ALBUM_COUNT_BY_STORAGE_ID, _filter->storage_id);
+               else
+                       snprintf(select_query, sizeof(select_query), SELECT_ALBUM_COUNT);
+
+               break;
+       case MEDIA_GROUP_FOLDER:
+               if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
+                       snprintf(select_query, sizeof(select_query), SELECT_FOLDER_COUNT_BY_STORAGE_ID, _filter->storage_id);
+               else
+                       snprintf(select_query, sizeof(select_query), SELECT_FOLDER_COUNT);
+
+               break;
+       case MEDIA_GROUP_PLAYLIST:
+               if (!SAFE_STRLCPY(select_query, SELECT_PLAYLIST_COUNT, sizeof(select_query))) {
+                       media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+                       return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+               }
+               break;
+       case MEDIA_GROUP_TAG:
+               if (!SAFE_STRLCPY(select_query, SELECT_TAG_COUNT, sizeof(select_query))) {
+                       media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+                       return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+               }
+               break;
+       case MEDIA_GROUP_BOOKMARK:
+               if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
+                       snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_COUNT_BY_STORAGE_ID, _filter->storage_id);
+               else
+                       snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_COUNT);
+
+               break;
+       case MEDIA_GROUP_STORAGE:
+               if (!SAFE_STRLCPY(select_query, SELECT_STORAGE_COUNT, sizeof(select_query))) {
+                       media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+                       return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+               }
+               break;
+       case MEDIA_GROUP_FACE:
+               if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
+                       snprintf(select_query, sizeof(select_query), SELECT_FACE_COUNT_BY_STORAGE_ID, _filter->storage_id);
+               else
+                       snprintf(select_query, sizeof(select_query), SELECT_FACE_COUNT);
+               break;
+       default:
+               {
+                       media_content_error("Invalid group type [%d]", group_type);
+                       return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+               }
+               break;
+       }
+
+       ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
+       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+       ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
+       SAFE_FREE(condition_query);
+       SAFE_FREE(option_query);
+       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+       if (sqlite3_step(stmt) == SQLITE_ROW)
+               *group_count = (int)sqlite3_column_int(stmt, 0);
+
+       SQLITE3_FINALIZE(stmt);
+
+       return ret;
+}
+
+int _media_db_get_media_group_count(media_group_e group, filter_h filter, int *group_count)
+{
+       int ret = MEDIA_CONTENT_ERROR_NONE;
+       sqlite3_stmt *stmt = NULL;
+       char select_query[MAX_QUERY_SIZE] = {0, };
+       char *condition_query = NULL;
+       char *option_query = NULL;
+       filter_s *_filter = (filter_s*)filter;
+
+       memset(select_query, 0x00, sizeof(select_query));
+       if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
+               snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_COUNT_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
+       else
+               snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_COUNT, __media_db_get_group_name(group));
+
+       ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
+       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+       SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, sizeof(select_query));
+       if (STRING_VALID(condition_query))
+               SAFE_STRLCAT(select_query, condition_query, sizeof(select_query));
+       if (STRING_VALID(option_query))
+               SAFE_STRLCAT(select_query, option_query, sizeof(select_query));
+       SAFE_STRLCAT(select_query, QUERY_KEYWORD_BRACKET, sizeof(select_query));
+
+       SAFE_FREE(condition_query);
+       SAFE_FREE(option_query);
+
+       ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
+       SAFE_FREE(condition_query);
+       SAFE_FREE(option_query);
+       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+       if (sqlite3_step(stmt) == SQLITE_ROW)
+               *group_count = (int)sqlite3_column_int(stmt, 0);
+
+       SQLITE3_FINALIZE(stmt);
+
+       return ret;
+}
+
+int _media_db_get_media_group(media_group_e group, filter_h filter, media_group_cb callback, void *user_data)
+{
+       int ret = MEDIA_CONTENT_ERROR_NONE;
+       char select_query[MAX_QUERY_SIZE] = {0, };
+       char *condition_query = NULL;
+       char *option_query = NULL;
+       char *name = NULL;
+       sqlite3_stmt *stmt = NULL;
+       filter_s *_filter = (filter_s*)filter;
+       memset(select_query, 0x00, sizeof(select_query));
+
+       if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
+               snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_LIST_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
+       else
+               snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_LIST, __media_db_get_group_name(group));
+
+       ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
+       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+       ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
+       SAFE_FREE(condition_query);
+       SAFE_FREE(option_query);
+       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+       while (sqlite3_step(stmt) == SQLITE_ROW) {
+               name = g_strdup((const char *)sqlite3_column_text(stmt, 0));
+
+               if (callback(name, user_data) == false) {
+                       SAFE_FREE(name);
+                       break;
+               }
+
+               SAFE_FREE(name);
+       }
+
+       SQLITE3_FINALIZE(stmt);
+
+       return ret;
+}
 #endif
+
 int _media_db_get_album(filter_h filter, media_album_cb callback, void *user_data)
 {
        int ret = MEDIA_CONTENT_ERROR_NONE;
@@ -507,16 +663,21 @@ int _media_db_get_album(filter_h filter, media_album_cb callback, void *user_dat
        filter_s *_filter = (filter_s*)filter;
 
        memset(select_query, 0x00, sizeof(select_query));
-
+#ifdef _USE_TVPD_MODE
        if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
                snprintf(select_query, sizeof(select_query), SELECT_ALBUM_LIST, _filter->storage_id);
        else
                snprintf(select_query, sizeof(select_query), SELECT_ALBUM_LIST, DB_VIEW_MEDIA);
-
+#else
+       if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
+               snprintf(select_query, sizeof(select_query), SELECT_ALBUM_LIST_BY_STORAGE_ID, _filter->storage_id);
+       else
+               snprintf(select_query, sizeof(select_query), SELECT_ALBUM_LIST);
+#endif
        ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
-       ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
+       ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
@@ -558,17 +719,21 @@ int _media_db_get_folder(filter_h filter, media_folder_cb callback, void *user_d
        filter_s *_filter = (filter_s*)filter;
 
        memset(select_query, 0x00, sizeof(select_query));
-
+#ifdef _USE_TVPD_MODE
        if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
                snprintf(select_query, sizeof(select_query), SELECT_FOLDER_LIST_BY_STORAGE_ID, _filter->storage_id, _filter->storage_id);
        else
                snprintf(select_query, sizeof(select_query), SELECT_FOLDER_LIST, DB_VIEW_MEDIA);
-
+#else
+       if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
+               snprintf(select_query, sizeof(select_query), SELECT_FOLDER_LIST_BY_STORAGE_ID, _filter->storage_id);
+       else
+               snprintf(select_query, sizeof(select_query), SELECT_FOLDER_LIST);
+#endif
        ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
-       ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
-
+       ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
@@ -619,7 +784,7 @@ int _media_db_get_playlist(filter_h filter, media_playlist_cb callback, void *us
        ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
-       ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
+       ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
@@ -664,7 +829,7 @@ int _media_db_get_playlist_item(int playlist_id, filter_h filter, playlist_membe
        ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
-       ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
+       ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
@@ -719,7 +884,7 @@ int _media_db_get_tag(const char *media_id, filter_h filter, media_tag_cb callba
 
        SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, sizeof(select_query));
 
-       ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
+       ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
@@ -758,7 +923,7 @@ int _media_db_get_bookmark(const char *media_id, filter_h filter, media_bookmark
        filter_s *_filter = (filter_s*)filter;
 
        memset(select_query, 0x00, sizeof(select_query));
-
+#ifdef _USE_TVPD_MODE
        if (STRING_VALID(media_id)) {   //get bookmark by media_id
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
                        snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST_BY_MEDIA_ID, _filter->storage_id, media_id);
@@ -770,11 +935,21 @@ int _media_db_get_bookmark(const char *media_id, filter_h filter, media_bookmark
                else
                        snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST, DB_VIEW_MEDIA);
        }
+#else
+       if (STRING_VALID(media_id)) {   //get bookmark by media_id
+               snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST_BY_MEDIA_ID, media_id);
+       } else {
+               if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
+                       snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST_BY_STORAGE_ID, _filter->storage_id);
+               else
+                       snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST);
+       }
+#endif
 
        ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
-       ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
+       ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
@@ -818,7 +993,7 @@ int _media_db_get_face(const char *media_id, filter_h filter, media_face_cb call
        filter_s *_filter = (filter_s*)filter;
 
        memset(select_query, 0x00, sizeof(select_query));
-
+#ifdef _USE_TVPD_MODE
        if (STRING_VALID(media_id)) {   //get face by media_id
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
                        snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST_BY_MEDIA_ID, _filter->storage_id, media_id);
@@ -830,11 +1005,20 @@ int _media_db_get_face(const char *media_id, filter_h filter, media_face_cb call
                else
                        snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST, DB_VIEW_MEDIA);
        }
-
+#else
+       if (STRING_VALID(media_id)) {   //get face by media_id
+               snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST_BY_MEDIA_ID, media_id);
+       } else {
+               if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
+                       snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST_BY_STORAGE_ID, _filter->storage_id);
+               else
+                       snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST);
+       }
+#endif
        ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
-       ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
+       ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
@@ -883,10 +1067,17 @@ int _media_db_get_group_item_count_by_id(int group_id, filter_h filter, group_li
        memset(select_query, 0x00, sizeof(select_query));
 
        if (group_type == MEDIA_GROUP_ALBUM) {
+#ifdef _USE_TVPD_MODE
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
                        snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_ALBUM, _filter->storage_id, group_id);
                else
                        snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_ALBUM, DB_VIEW_MEDIA, group_id);
+#else
+               if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
+                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_ALBUM_BY_STORAGE_ID, group_id, _filter->storage_id);
+               else
+                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_ALBUM, group_id);
+#endif
        } else if (group_type == MEDIA_GROUP_PLAYLIST) {
                snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_PLAYLIST, group_id);
        } else if (group_type == MEDIA_GROUP_TAG) {
@@ -899,7 +1090,7 @@ int _media_db_get_group_item_count_by_id(int group_id, filter_h filter, group_li
        ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
-       ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
+       ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
@@ -930,40 +1121,66 @@ int _media_db_get_group_item_count(const char *group_name, filter_h filter, grou
                        If user wants to set offset and count, use SQL SELECT_MEDIA_COUNT_FROM_MEDIA.
                        If user wants to get count without setting count, SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE */
                if (_filter && ((_filter->offset < 0) && (_filter->count < 0))) {
+#ifdef _USE_TVPD_MODE
                                if (STRING_VALID(_filter->storage_id))
                                        snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE, _filter->storage_id);
                                else
                                        snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE, DB_VIEW_MEDIA);
+#else
+                               if (STRING_VALID(_filter->storage_id))
+                                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE_BY_STORAGE_ID, _filter->storage_id);
+                               else
+                                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE);
+#endif
                                is_simple = TRUE;
                } else {
+#ifdef _USE_TVPD_MODE
                        snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA, DB_VIEW_MEDIA);
+#else
+                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA);
+#endif
                }
        } else if (group_type == MEDIA_GROUP_FOLDER) {
+#ifdef _USE_TVPD_MODE
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
                        tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_FOLDER, _filter->storage_id, group_name);
                else
                        tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
-
+#else
+               if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
+                       tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_FOLDER_BY_STORAGE_ID, group_name, _filter->storage_id);
+               else
+                       tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_FOLDER, group_name);
+#endif
                SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
        } else if (group_type == MEDIA_GROUP_TAG_BY_MEDIA_ID) {
                snprintf(select_query, sizeof(select_query), SELECT_TAG_COUNT_BY_MEDIA_ID, group_name);
        } else if (group_type == MEDIA_GROUP_BOOKMARK_BY_MEDIA_ID) {
+#ifdef _USE_TVPD_MODE
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
                        tmp_query = sqlite3_mprintf(SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, _filter->storage_id, group_name);
                else
                        tmp_query = sqlite3_mprintf(SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, DB_VIEW_MEDIA, group_name);
-
+#else
+               tmp_query = sqlite3_mprintf(SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, group_name);
+#endif
                SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
        } else if (group_type == MEDIA_GROUP_STORAGE) {
+#ifdef _USE_TVPD_MODE
                tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_STORAGE, group_name, group_name);
-
+#else
+               tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_STORAGE, group_name);
+#endif
                SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
        } else if (group_type == MEDIA_GROUP_FACE_BY_MEDIA_ID) {
+#ifdef _USE_TVPD_MODE
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
                        tmp_query = sqlite3_mprintf(SELECT_FACE_COUNT_BY_MEDIA_ID, _filter->storage_id, group_name);
                else
                        tmp_query = sqlite3_mprintf(SELECT_FACE_COUNT_BY_MEDIA_ID, DB_VIEW_MEDIA, group_name);
-
+#else
+               tmp_query = sqlite3_mprintf(SELECT_FACE_COUNT_BY_MEDIA_ID, group_name);
+#endif
                SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
 #ifdef _USE_TVPD_MODE
        } else if (group_type == MEDIA_GROUP_PVR) {
@@ -1003,7 +1220,7 @@ int _media_db_get_group_item_count(const char *group_name, filter_h filter, grou
                SAFE_FREE(option_query);
        }
 
-       ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
+       ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        if (tmp_query != NULL)
                SQLITE3_SAFE_FREE(tmp_query);
        SAFE_FREE(condition_query);
@@ -1029,6 +1246,7 @@ int _media_db_get_group_item_by_id(int group_id, filter_h filter, media_info_cb
 
        memset(select_query, 0x00, sizeof(select_query));
 
+#ifdef _USE_TVPD_MODE
        if (group_type == MEDIA_GROUP_ALBUM) {
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
                        snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_ALBUM, _filter->storage_id, group_id);
@@ -1048,11 +1266,31 @@ int _media_db_get_group_item_by_id(int group_id, filter_h filter, media_info_cb
                media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
                return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
        }
-
+#else
+       if (group_type == MEDIA_GROUP_ALBUM) {
+               if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
+                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_ALBUM_BY_STORAGE_ID, group_id, _filter->storage_id);
+               else
+                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_ALBUM, group_id);
+       } else if (group_type == MEDIA_GROUP_PLAYLIST) {
+               if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
+                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_PLAYLIST_BY_STORAGE_ID, group_id, _filter->storage_id);
+               else
+                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_PLAYLIST, group_id);
+       } else if (group_type == MEDIA_GROUP_TAG) {
+               if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
+                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_TAG_BY_STORAGE_ID, group_id, _filter->storage_id);
+               else
+                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_TAG, group_id);
+       } else {
+               media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+               return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+       }
+#endif
        ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
-       ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
+       ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
@@ -1090,7 +1328,7 @@ int _media_db_get_group_item(const char *group_name, filter_h filter, media_info
        filter_s *_filter = (filter_s*)filter;
 
        memset(select_query, 0x00, sizeof(select_query));
-
+#ifdef _USE_TVPD_MODE
        if (group_type == MEDIA_GROUP_NONE) {
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
                        snprintf(select_query, sizeof(select_query), SELECT_MEDIA_ITEM, _filter->storage_id);
@@ -1107,11 +1345,25 @@ int _media_db_get_group_item(const char *group_name, filter_h filter, media_info
                media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
                return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
        }
-
+#else
+       if (group_type == MEDIA_GROUP_NONE) {
+               if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
+                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_ITEM_BY_STORAGE_ID, _filter->storage_id);
+               else
+                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_ITEM);
+       } else if (group_type == MEDIA_GROUP_FOLDER) {
+               snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_FOLDER, group_name);
+       } else if (group_type == MEDIA_GROUP_STORAGE) {
+               snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_STORAGE, group_name);
+       } else {
+               media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+               return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+       }
+#endif
        ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
-       ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
+       ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
@@ -1274,17 +1526,17 @@ int _media_db_get_media_group_item_count(const char *group_name, filter_h filter
 #else
        if (group_name != NULL) {
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id)) {
-                       tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_GROUP, _filter->storage_id, __media_db_get_group_name(group), group_name);
+                       tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_GROUP_BY_STORAGE_ID, __media_db_get_group_name(group), group_name, _filter->storage_id);
                        SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
                } else {
-                       tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_GROUP, DB_VIEW_MEDIA, __media_db_get_group_name(group), group_name);
+                       tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_GROUP, __media_db_get_group_name(group), group_name);
                        SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
                }
        } else {
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
-                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL, _filter->storage_id, __media_db_get_group_name(group));
+                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
                else
-                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL, DB_VIEW_MEDIA, __media_db_get_group_name(group));
+                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL, __media_db_get_group_name(group));
        }
 #endif
        ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
@@ -1304,7 +1556,7 @@ int _media_db_get_media_group_item_count(const char *group_name, filter_h filter
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
 
-       ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
+       ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        if (tmp_query != NULL)
                SQLITE3_SAFE_FREE(tmp_query);
        SAFE_FREE(condition_query);
@@ -1330,7 +1582,7 @@ int _media_db_get_media_group_item(const char *group_name, filter_h filter, medi
        filter_s *_filter = (filter_s*)filter;
 
        memset(select_query, 0x00, sizeof(select_query));
-
+#ifdef _USE_TVPD_MODE
        if (group_name != NULL) {
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
                        tmp_query = sqlite3_mprintf(SELECT_MEDIA_FROM_GROUP, _filter->storage_id, __media_db_get_group_name(group), group_name);
@@ -1344,7 +1596,21 @@ int _media_db_get_media_group_item(const char *group_name, filter_h filter, medi
                else
                        snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL, DB_VIEW_MEDIA, __media_db_get_group_name(group));
        }
+#else
+       if (group_name != NULL) {
+               if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
+                       tmp_query = sqlite3_mprintf(SELECT_MEDIA_FROM_GROUP_BY_STORAGE_ID, __media_db_get_group_name(group), group_name, _filter->storage_id);
+               else
+                       tmp_query = sqlite3_mprintf(SELECT_MEDIA_FROM_GROUP, __media_db_get_group_name(group), group_name);
 
+               SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
+       } else {
+               if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
+                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
+               else
+                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL, __media_db_get_group_name(group));
+       }
+#endif
        ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
        if (ret != MEDIA_CONTENT_ERROR_NONE) {
                if (tmp_query != NULL)
@@ -1352,7 +1618,7 @@ int _media_db_get_media_group_item(const char *group_name, filter_h filter, medi
                return ret;
        }
 
-       ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
+       ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        if (tmp_query != NULL)
                SQLITE3_SAFE_FREE(tmp_query);
        SAFE_FREE(condition_query);
@@ -1400,7 +1666,7 @@ int _media_db_get_storage(filter_h filter, media_storage_cb callback, void *user
        ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
-       ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
+       ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
@@ -1430,6 +1696,31 @@ int _media_db_get_storage(filter_h filter, media_storage_cb callback, void *user
 
        return ret;
 }
+
+int _media_db_get_storage_id_by_media_id(const char *media_id, char **storage_id)
+{
+       int ret = MEDIA_CONTENT_ERROR_NONE;
+       sqlite3_stmt *stmt = NULL;
+       char *select_query = NULL;
+
+       select_query = sqlite3_mprintf(SELECT_MEDIA_STORAGE_ID_BY_ID, media_id);
+
+       ret = _content_get_result(select_query, &stmt);
+       SQLITE3_SAFE_FREE(select_query);
+       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+       if (sqlite3_step(stmt) == SQLITE_ROW) {
+               *storage_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
+       } else {
+               media_content_error("Invalid media_id[%s]", media_id);
+               ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+       }
+
+       SQLITE3_FINALIZE(stmt);
+
+       return ret;
+}
+
 #ifdef _USE_TVPD_MODE
 int _media_db_get_pvr_group_item(const char *group_name, filter_h filter, media_group_e group, media_pvr_cb callback, void *user_data)
 {
@@ -1464,7 +1755,7 @@ int _media_db_get_pvr_group_item(const char *group_name, filter_h filter, media_
                return ret;
        }
 
-       ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
+       ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        if (tmp_query != NULL)
                sqlite3_free(tmp_query);
        SAFE_FREE(condition_query);
@@ -1680,7 +1971,7 @@ int _media_db_get_pvr(filter_h filter, media_pvr_cb callback, void *user_data)
        ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
-       ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
+       ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
@@ -1708,38 +1999,7 @@ int _media_db_get_pvr(filter_h filter, media_pvr_cb callback, void *user_data)
 
        return ret;
 }
-#endif
-
-int _media_db_get_storage_id_by_media_id(const char *media_id, char *storage_id)
-{
-       int ret = MEDIA_CONTENT_ERROR_NONE;
-       sqlite3_stmt *stmt = NULL;
-       char *select_query = NULL;
-
-       select_query = sqlite3_mprintf(SELECT_MEDIA_STORAGE_ID_BY_ID, media_id);
-
-       ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
-       SQLITE3_SAFE_FREE(select_query);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
-
-       if (sqlite3_step(stmt) == SQLITE_ROW) {
-               if (STRING_VALID((const char *)sqlite3_column_text(stmt, 0))) {
-                       if (!SAFE_STRLCPY(storage_id, (const char *)sqlite3_column_text(stmt, 0), MEDIA_CONTENT_UUID_SIZE+1)) {
-                               media_content_error("Storage id copy fail");
-                               ret = MEDIA_CONTENT_ERROR_INVALID_OPERATION;
-                       }
-               }
-       } else {
-               media_content_error("There's no media!!");
-               ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-       }
-
-       SQLITE3_FINALIZE(stmt);
-
-       return ret;
-}
 
-#ifdef _USE_TVPD_MODE
 typedef enum {
        MEDIA_UHD_MEDIA_ID = 0,
        MEDIA_UHD_STORAGE_ID,
@@ -1810,7 +2070,7 @@ int _media_db_get_uhd(filter_h filter, media_uhd_cb callback, void *user_data)
        ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
-       ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
+       ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);