src/media_db.c

   1 /*
   2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3 *
   4 * Licensed under the Apache License, Version 2.0 (the "License");
   5 * you may not use this file except in compliance with the License.
   6 * You may obtain a copy of the License at
   7 *
   8 * http://www.apache.org/licenses/LICENSE-2.0
   9 *
  10 * Unless required by applicable law or agreed to in writing, software
  11 * distributed under the License is distributed on an "AS IS" BASIS,
  12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 * See the License for the specific language governing permissions and
  14 * limitations under the License.
  15 */
  16
  17
  18 #include <media_content.h>
  19 #include <media_info_private.h>
  20 #include <media_util_private.h>
  21
  22 static const char * __media_db_get_group_name(media_group_e group)
  23 {
  24         switch (group) {
  25         case MEDIA_CONTENT_GROUP_DISPLAY_NAME:
  26                 return DB_FIELD_MEDIA_DISPLAY_NAME;
  27         case MEDIA_CONTENT_GROUP_TYPE:
  28                 return DB_FIELD_MEDIA_TYPE;
  29         case MEDIA_CONTENT_GROUP_MIME_TYPE:
  30                 return DB_FIELD_MEDIA_MIME_TYPE;
  31         case MEDIA_CONTENT_GROUP_SIZE:
  32                 return DB_FIELD_MEDIA_SIZE;
  33         case MEDIA_CONTENT_GROUP_ADDED_TIME:
  34                 return DB_FIELD_MEDIA_ADDED_TIME;
  35         case MEDIA_CONTENT_GROUP_MODIFIED_TIME:
  36                 return DB_FIELD_MEDIA_MODIFIED_TIME;
  37         case MEDIA_CONTENT_GROUP_TITLE:
  38                 return DB_FIELD_MEDIA_TITLE;
  39         case MEDIA_CONTENT_GROUP_ARTIST:
  40                 return DB_FIELD_MEDIA_ARTIST;
  41         case MEDIA_CONTENT_GROUP_ALBUM_ARTIST:
  42                 return DB_FIELD_MEDIA_ALBUM_ARTIST;
  43         case MEDIA_CONTENT_GROUP_GENRE:
  44                 return DB_FIELD_MEDIA_GENRE;
  45         case MEDIA_CONTENT_GROUP_COMPOSER:
  46                 return DB_FIELD_MEDIA_COMPOSER;
  47         case MEDIA_CONTENT_GROUP_YEAR:
  48                 return DB_FIELD_MEDIA_YEAR;
  49         case MEDIA_CONTENT_GROUP_RECORDED_DATE:
  50                 return DB_FIELD_MEDIA_RECORDED_DATE;
  51         case MEDIA_CONTENT_GROUP_COPYRIGHT:
  52                 return DB_FIELD_MEDIA_COPYRIGHT;
  53         case MEDIA_CONTENT_GROUP_TRACK_NUM:
  54                 return DB_FIELD_MEDIA_TRACK_NUM;
  55         case MEDIA_CONTENT_GROUP_DESCRIPTION:
  56                 return DB_FIELD_MEDIA_DESCRIPTION;
  57         case MEDIA_CONTENT_GROUP_LONGITUDE:
  58                 return DB_FIELD_MEDIA_LONGITUDE;
  59         case MEDIA_CONTENT_GROUP_LATITUDE:
  60                 return DB_FIELD_MEDIA_LATITUDE;
  61         case MEDIA_CONTENT_GROUP_ALTITUDE:
  62                 return DB_FIELD_MEDIA_ALTITUDE;
  63         case MEDIA_CONTENT_GROUP_RATING:
  64                 return DB_FIELD_MEDIA_RATING;
  65 #ifdef _USE_TVPD_MODE
  66         case MEDIA_CONTENT_GROUP_MODIFIED_MONTH:
  67                 return DB_FIELD_MEDIA_MODIFIED_DATE;
  68         case MEDIA_CONTENT_GROUP_MODIFIED_DATE:
  69                 return DB_FIELD_MEDIA_MODIFIED_DATE;
  70 #endif
  71 #ifdef _USE_SENIOR_MODE
  72         case MEDIA_CONTENT_GROUP_CONTACT:
  73                 return DB_FIELD_MEDIA_CONTACT;
  74 #endif
  75 #ifdef _USE_TVPD_MODE
  76         case MEDIA_CONTENT_GROUP_ALBUM:
  77                 return DB_FIELD_MEDIA_ALBUM;
  78         case MEDIA_PVR_GROUP_DURATION:
  79                 return DB_FIELD_PVR_DURATION;
  80         case MEDIA_PVR_GROUP_TIME_ZONE:
  81                 return DB_FIELD_PVR_TIME_ZONE;
  82         case MEDIA_PVR_GROUP_PTC:
  83                 return DB_FIELD_PVR_PTC;
  84         case MEDIA_PVR_GROUP_MAJOR:
  85                 return DB_FIELD_PVR_MAJOR;
  86         case MEDIA_PVR_GROUP_MINOR:
  87                 return DB_FIELD_PVR_MINOR;
  88         case MEDIA_PVR_GROUP_CHANNEL_TYPE:
  89                 return DB_FIELD_PVR_CHANNEL_TYPE;
  90         case MEDIA_PVR_GROUP_CHANNEL_NAME:
  91                 return DB_FIELD_PVR_CHANNEL_NAME;
  92         case MEDIA_PVR_GROUP_CHANNEL_NUM:
  93                 return DB_FIELD_PVR_CHANNEL_NUM;
  94         case MEDIA_PVR_GROUP_PROGRAM_TITLE:
  95                 return DB_FIELD_PVR_PROGRAM_TITLE;
  96         case MEDIA_PVR_GROUP_PROGRAM_NUM:
  97                 return DB_FIELD_PVR_PROGRAM_NUM;
  98         case MEDIA_PVR_GROUP_PROGRAM_CRID:
  99                 return DB_FIELD_PVR_PROGRAM_CRID;
 100         case MEDIA_PVR_GROUP_GUIDANCE:
 101                 return DB_FIELD_PVR_GUIDANCE;
 102         case MEDIA_PVR_GROUP_SYNOPSIS:
 103                 return DB_FIELD_PVR_SYNOPSIS;
 104         case MEDIA_PVR_GROUP_GENRE:
 105                 return DB_FIELD_PVR_GENRE;
 106         case MEDIA_PVR_GROUP_LANGUAGE:
 107                 return DB_FIELD_PVR_LANGUAGE;
 108         case MEDIA_PVR_GROUP_EMBARGO_TIME:
 109                 return DB_FIELD_PVR_EMBARGO_TIME;
 110         case MEDIA_PVR_GROUP_EXPIRY_TIME:
 111                 return DB_FIELD_PVR_EXPIRY_TIME;
 112         case MEDIA_PVR_GROUP_START_TIME:
 113                 return DB_FIELD_PVR_START_TIME;
 114         case MEDIA_PVR_GROUP_PROGRAM_START_TIME:
 115                 return DB_FIELD_PVR_PROGRAM_START_TIME;
 116         case MEDIA_PVR_GROUP_PROGRAM_END_TIME:
 117                 return DB_FIELD_PVR_PROGRAM_END_TIME;
 118         case MEDIA_PVR_GROUP_PROGRAM_DATE:
 119                 return DB_FIELD_PVR_PROGRAM_DATE;
 120         case MEDIA_PVR_GROUP_PARENTAL_RATING:
 121                 return DB_FIELD_PVR_PARENTAL_RATING;
 122         case MEDIA_PVR_GROUP_TIMER_RECORD:
 123                 return DB_FIELD_PVR_TIMER_RECORD;
 124         case MEDIA_PVR_GROUP_SERIES_RECORD:
 125                 return DB_FIELD_PVR_SERIES_RECORD;
 126         case MEDIA_PVR_GROUP_HD:
 127                 return DB_FIELD_PVR_HD;
 128         case MEDIA_PVR_GROUP_SUBTITLE:
 129                 return DB_FIELD_PVR_SUBTITLE;
 130         case MEDIA_PVR_GROUP_TTX:
 131                 return DB_FIELD_PVR_TTX;
 132         case MEDIA_PVR_GROUP_AD:
 133                 return DB_FIELD_PVR_AD;
 134         case MEDIA_PVR_GROUP_HARDOF_HEARINGRADIO:
 135                 return DB_FIELD_PVR_HARDOF_HEARINGRADIO;
 136         case MEDIA_PVR_GROUP_DATA_SERVICE:
 137                 return DB_FIELD_PVR_DATA_SERVICE;
 138         case MEDIA_PVR_GROUP_CONTENT_LOCK:
 139                 return DB_FIELD_PVR_CONTENT_LOCK;
 140         case MEDIA_PVR_GROUP_CONTENT_WATCH:
 141                 return DB_FIELD_PVR_CONTENT_WATCH;
 142         case MEDIA_PVR_GROUP_HAS_AUDIO_ONLY:
 143                 return DB_FIELD_PVR_HAS_AUDIO_ONLY;
 144         case MEDIA_PVR_GROUP_IS_LOCAL_RECORDED:
 145                 return DB_FIELD_PVR_IS_LOCAL_RECORD;
 146         case MEDIA_PVR_GROUP_RESOLUTION:
 147                 return DB_FIELD_PVR_RESOLUTION;
 148         case MEDIA_PVR_GROUP_ASPECTRATIO:
 149                 return DB_FIELD_PVR_ASPECTRATIO;
 150         case MEDIA_PVR_GROUP_MODIFIED_MONTH:
 151                 return DB_FIELD_PVR_MODIFIED_DATE;
 152         case MEDIA_PVR_GROUP_MODIFIED_DATE:
 153                 return DB_FIELD_PVR_MODIFIED_DATE;
 154         case MEDIA_PVR_GROUP_SPORTS_TYPE:
 155                 return DB_FIELD_PVR_SPORTS_TYPE;
 156         case MEDIA_PVR_GROUP_GUIDANCE_LENGTH:
 157                 return DB_FIELD_PVR_GUIDANCE_LENGTH;
 158         case MEDIA_PVR_GROUP_TVMODE:
 159                 return DB_FIELD_PVR_TVMODE;
 160         case MEDIA_PVR_GROUP_PLAY_COUNT:
 161                 return DB_FIELD_PVR_PLAY_COUNT;
 162         case MEDIA_PVR_GROUP_PRIVATE_DATA:
 163                 return DB_FIELD_PVR_PRIVATE_DATA;
 164         case MEDIA_UHD_GROUP_CONTENT_TITLE:
 165                 return DB_FIELD_UHD_CONTENT_TITLE;
 166         case MEDIA_UHD_GROUP_RELEASE_DATE:
 167                 return DB_FIELD_UHD_RELEASE_DATE;
 168         case MEDIA_UHD_GROUP_SUB_TYPE:
 169                 return DB_FIELD_UHD_SUB_TYPE;
 170         case MEDIA_UHD_GROUP_FILE_NAME:
 171                 return DB_FIELD_UHD_FILE_NAME;
 172         case MEDIA_UHD_GROUP_PLAYED_COUNT:
 173                 return DB_FIELD_UHD_PLAYED_COUNT;
 174 #endif
 175         default:
 176                 return NULL;
 177         }
 178
 179         return NULL;
 180 }
 181
 182 static int __media_db_make_query(filter_h filter, char **condition_query, char **option_query)
 183 {
 184         int ret = MEDIA_CONTENT_ERROR_NONE;
 185         filter_s *_filter = (filter_s *)filter;
 186
 187         content_retv_if(!_filter, MEDIA_CONTENT_ERROR_NONE);
 188
 189         if (STRING_VALID(_filter->condition)) {
 190                 ret = _media_filter_build_condition(_filter->is_full_condition, _filter->condition, _filter->condition_collate_type, condition_query);
 191                 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 192         }
 193
 194         ret = _media_filter_build_option(filter, option_query);
 195         if (ret != MEDIA_CONTENT_ERROR_NONE)
 196                 g_free(*condition_query);
 197
 198         return ret;
 199 }
 200
 201 #ifdef _USE_TVPD_MODE
 202 int _media_db_get_group_count(filter_h filter, group_list_e group_type, int *group_count)
 203 {
 204         int ret = MEDIA_CONTENT_ERROR_NONE;
 205         sqlite3_stmt *stmt = NULL;
 206         char *select_query = NULL;
 207         char *condition_query = NULL;
 208         char *option_query = NULL;
 209         filter_s *_filter = (filter_s *)filter;
 210
 211         switch (group_type) {
 212         case MEDIA_GROUP_ALBUM:
 213                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 214                         select_query = g_strdup_printf(SELECT_ALBUM_COUNT, _filter->storage_id);
 215                 else
 216                         select_query = g_strdup_printf(SELECT_ALBUM_COUNT, DB_VIEW_MEDIA);
 217                 break;
 218
 219         case MEDIA_GROUP_FOLDER:
 220                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 221                         select_query = g_strdup_printf(SELECT_FOLDER_COUNT_BY_STORAGE_ID, _filter->storage_id, _filter->storage_id);
 222                 else
 223                         select_query = g_strdup_printf(SELECT_FOLDER_COUNT, DB_VIEW_MEDIA);
 224                 break;
 225
 226         case MEDIA_GROUP_PLAYLIST:
 227                 select_query = g_strdup(SELECT_PLAYLIST_COUNT);
 228                 break;
 229
 230         case MEDIA_GROUP_TAG:
 231                 select_query = g_strdup(SELECT_TAG_COUNT);
 232                 break;
 233
 234         case MEDIA_GROUP_BOOKMARK:
 235                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 236                         select_query = g_strdup_printf(SELECT_BOOKMARK_COUNT, _filter->storage_id);
 237                 else
 238                         select_query = g_strdup_printf(SELECT_BOOKMARK_COUNT, DB_VIEW_MEDIA);
 239
 240                 break;
 241
 242         case MEDIA_GROUP_STORAGE:
 243                 select_query = g_strdup(SELECT_STORAGE_COUNT);
 244                 break;
 245
 246         case MEDIA_GROUP_FACE:
 247                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 248                         select_query = g_strdup_printf(SELECT_FACE_COUNT, _filter->storage_id);
 249                 else
 250                         select_query = g_strdup_printf(SELECT_FACE_COUNT, DB_VIEW_MEDIA);
 251                 break;
 252
 253         default:
 254                 content_error("Invalid group type [%d]", group_type);
 255                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 256         }
 257
 258         ret = __media_db_make_query(filter, &condition_query, &option_query);
 259         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 260                 g_free(select_query);
 261                 return ret;
 262         }
 263
 264         ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
 265         g_free(select_query);
 266         g_free(condition_query);
 267         g_free(option_query);
 268         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 269
 270         if (sqlite3_step(stmt) == SQLITE_ROW)
 271                 *group_count = sqlite3_column_int(stmt, 0);
 272
 273         SQLITE3_FINALIZE(stmt);
 274
 275         return ret;
 276 }
 277
 278 int _media_db_get_media_group_count(media_group_e group, filter_h filter, int *group_count)
 279 {
 280         int ret = MEDIA_CONTENT_ERROR_NONE;
 281         sqlite3_stmt *stmt = NULL;
 282         char select_query[MAX_QUERY_SIZE] = {0, };
 283         char *condition_query = NULL;
 284         char *option_query = NULL;
 285         char *tmp_option = NULL;
 286         filter_s *_filter = (filter_s *)filter;
 287
 288         if (group < MEDIA_PVR_GROUP_DURATION) { /*media content*/
 289                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 290                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_COUNT, __media_db_get_group_name(group), _filter->storage_id);
 291                 else
 292                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_COUNT, __media_db_get_group_name(group), DB_VIEW_MEDIA);
 293         } else if (group < MEDIA_UHD_GROUP_CONTENT_TITLE) { /*pvr content*/
 294                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 295                         snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_COUNT_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
 296                 else
 297                         snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_COUNT, __media_db_get_group_name(group));
 298         } else { /*uhd content*/
 299                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 300                         snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_COUNT_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
 301                 else
 302                         snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_COUNT, __media_db_get_group_name(group));
 303         }
 304         ret = __media_db_make_query(filter, &condition_query, &option_query);
 305         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 306
 307         if (option_query) {
 308                 tmp_option = g_strconcat(option_query, ")", NULL);
 309                 g_free(option_query);
 310                 option_query = tmp_option;
 311         } else {
 312                 SAFE_STRLCAT(select_query, ")", sizeof(select_query));
 313         }
 314
 315         ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
 316         g_free(condition_query);
 317         g_free(option_query);
 318         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 319
 320         if (sqlite3_step(stmt) == SQLITE_ROW)
 321                 *group_count = sqlite3_column_int(stmt, 0);
 322
 323         SQLITE3_FINALIZE(stmt);
 324
 325         return ret;
 326 }
 327
 328 int _media_db_get_media_group(media_group_e group, filter_h filter, media_group_cb callback, void *user_data)
 329 {
 330         int ret = MEDIA_CONTENT_ERROR_NONE;
 331         char select_query[MAX_QUERY_SIZE] = {0, };
 332         char *condition_query = NULL;
 333         char *option_query = NULL;
 334         char *name = NULL;
 335         sqlite3_stmt *stmt = NULL;
 336         filter_s *_filter = (filter_s *)filter;
 337
 338         if (group < MEDIA_PVR_GROUP_DURATION) { /*media content */
 339                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 340                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_LIST, __media_db_get_group_name(group), _filter->storage_id);
 341                 else
 342                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_LIST, __media_db_get_group_name(group), DB_VIEW_MEDIA);
 343         } else if (group < MEDIA_UHD_GROUP_CONTENT_TITLE) { /*pvr content */
 344                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 345                         snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_LIST_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
 346                 else
 347                         snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_LIST, __media_db_get_group_name(group));
 348         } else { /* uhd content */
 349                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 350                         snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_LIST_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
 351                 else
 352                         snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_LIST, __media_db_get_group_name(group));
 353         }
 354         ret = __media_db_make_query(filter, &condition_query, &option_query);
 355         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 356
 357         ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
 358         g_free(condition_query);
 359         g_free(option_query);
 360         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 361
 362         while (sqlite3_step(stmt) == SQLITE_ROW) {
 363                 name = g_strdup((const char *)sqlite3_column_text(stmt, 0));
 364
 365                 if (callback(name, user_data) == false) {
 366                         g_free(name);
 367                         break;
 368                 }
 369
 370                 g_free(name);
 371         }
 372
 373         SQLITE3_FINALIZE(stmt);
 374
 375         return ret;
 376 }
 377
 378 int _media_db_get_media_group_and_count(media_group_e group, filter_h filter, media_group_and_count_cb callback, void *user_data)
 379 {
 380         int ret = MEDIA_CONTENT_ERROR_NONE;
 381         char select_query[DEFAULT_QUERY_SIZE] = {0, };
 382         char group_query[DEFAULT_QUERY_SIZE] = {0, };
 383         char *condition_query = NULL;
 384         char *option_query = NULL;
 385         char *name = NULL;
 386         sqlite3_stmt *stmt = NULL;
 387         filter_s *_filter = (filter_s *)filter;
 388
 389         const char* group_name = __media_db_get_group_name(group);
 390         if (!STRING_VALID(group_name)) {
 391                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 392                 content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 393         }
 394
 395         if (group < MEDIA_PVR_GROUP_DURATION) { /*media content*/
 396                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 397                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_AND_COUNT, group_name, _filter->storage_id);
 398                 else
 399                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_AND_COUNT, group_name, DB_VIEW_MEDIA);
 400         } else if (group < MEDIA_UHD_GROUP_CONTENT_TITLE) {/*pvr content*/
 401                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 402                         snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_AND_COUNT_BY_STORAGE_ID, group_name, _filter->storage_id);
 403                 else
 404                         snprintf(select_query, sizeof(select_query), SELECT_PVR_GROUP_AND_COUNT, group_name);
 405         } else {/*uhd content*/
 406                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 407                         snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_AND_COUNT_BY_STORAGE_ID, group_name, _filter->storage_id);
 408                 else
 409                         snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_AND_COUNT, group_name);
 410         }
 411
 412         ret = __media_db_make_query(filter, &condition_query, &option_query);
 413         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 414
 415         if (STRING_VALID(option_query))
 416                 snprintf(group_query, sizeof(group_query), "GROUP BY %s %s", group_name, option_query);
 417         else
 418                 snprintf(group_query, sizeof(group_query), "GROUP BY %s", group_name);
 419
 420         ret = _content_query_prepare(select_query, condition_query, group_query, &stmt);
 421         g_free(condition_query);
 422         g_free(option_query);
 423         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 424
 425         while (sqlite3_step(stmt) == SQLITE_ROW) {
 426                 name = g_strdup((const char *)sqlite3_column_text(stmt, 0));
 427
 428                 if (callback(name, sqlite3_column_int(stmt, 1), user_data) == false) {
 429                         g_free(name);
 430                         break;
 431                 }
 432
 433                 g_free(name);
 434         }
 435
 436         SQLITE3_FINALIZE(stmt);
 437
 438         return ret;
 439 }
 440 #else
 441 int _media_db_get_group_count(filter_h filter, group_list_e group_type, int *group_count)
 442 {
 443         int ret = MEDIA_CONTENT_ERROR_NONE;
 444         sqlite3_stmt *stmt = NULL;
 445         char *select_query = NULL;
 446         char *condition_query = NULL;
 447         char *option_query = NULL;
 448         filter_s *_filter = (filter_s *)filter;
 449
 450         switch (group_type) {
 451         case MEDIA_GROUP_ALBUM:
 452                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 453                         select_query = g_strdup_printf(SELECT_ALBUM_COUNT_BY_STORAGE_ID, _filter->storage_id);
 454                 else
 455                         select_query = g_strdup(SELECT_ALBUM_COUNT);
 456                 break;
 457
 458         case MEDIA_GROUP_FOLDER:
 459                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 460                         select_query = g_strdup_printf(SELECT_FOLDER_COUNT_BY_STORAGE_ID, _filter->storage_id);
 461                 else
 462                         select_query = g_strdup(SELECT_FOLDER_COUNT);
 463                 break;
 464
 465         case MEDIA_GROUP_PLAYLIST:
 466                 select_query = g_strdup(SELECT_PLAYLIST_COUNT);
 467                 break;
 468
 469         case MEDIA_GROUP_TAG:
 470                 select_query = g_strdup(SELECT_TAG_COUNT);
 471                 break;
 472
 473         case MEDIA_GROUP_BOOKMARK:
 474                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 475                         select_query = g_strdup_printf(SELECT_BOOKMARK_COUNT_BY_STORAGE_ID, _filter->storage_id);
 476                 else
 477                         select_query = g_strdup(SELECT_BOOKMARK_COUNT);
 478
 479                 break;
 480
 481         case MEDIA_GROUP_STORAGE:
 482                 select_query = g_strdup(SELECT_STORAGE_COUNT);
 483                 break;
 484
 485         case MEDIA_GROUP_FACE:
 486                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 487                         select_query = g_strdup_printf(SELECT_FACE_COUNT_BY_STORAGE_ID, _filter->storage_id);
 488                 else
 489                         select_query = g_strdup(SELECT_FACE_COUNT);
 490                 break;
 491
 492         default:
 493                 content_error("Invalid group type [%d]", group_type);
 494                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 495         }
 496
 497         ret = __media_db_make_query(filter, &condition_query, &option_query);
 498         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 499                 g_free(select_query);
 500                 return ret;
 501         }
 502
 503         ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
 504         g_free(select_query);
 505         g_free(condition_query);
 506         g_free(option_query);
 507         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 508
 509         if (sqlite3_step(stmt) == SQLITE_ROW)
 510                 *group_count = sqlite3_column_int(stmt, 0);
 511
 512         SQLITE3_FINALIZE(stmt);
 513
 514         return ret;
 515 }
 516
 517 int _media_db_get_media_group_count(media_group_e group, filter_h filter, int *group_count)
 518 {
 519         int ret = MEDIA_CONTENT_ERROR_NONE;
 520         sqlite3_stmt *stmt = NULL;
 521         char *select_query = NULL;
 522         char *condition_query = NULL;
 523         char *option_query = NULL;
 524         filter_s *_filter = (filter_s *)filter;
 525
 526         if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 527                 select_query = g_strdup_printf(SELECT_MEDIA_GROUP_COUNT_BY_STORAGE_ID, __media_db_get_group_name(group), __media_db_get_group_name(group), _filter->storage_id);
 528         else
 529                 select_query = g_strdup_printf(SELECT_MEDIA_GROUP_COUNT, __media_db_get_group_name(group), __media_db_get_group_name(group));
 530
 531         ret = __media_db_make_query(filter, &condition_query, &option_query);
 532         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 533                 g_free(select_query);
 534                 return ret;
 535         }
 536
 537         ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
 538         g_free(select_query);
 539         g_free(condition_query);
 540         g_free(option_query);
 541         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 542
 543         if (sqlite3_step(stmt) == SQLITE_ROW)
 544                 *group_count = sqlite3_column_int(stmt, 0);
 545
 546         SQLITE3_FINALIZE(stmt);
 547
 548         return ret;
 549 }
 550
 551 int _media_db_get_media_group(media_group_e group, filter_h filter, media_group_cb callback, void *user_data)
 552 {
 553         int ret = MEDIA_CONTENT_ERROR_NONE;
 554         char *select_query = NULL;
 555         char *condition_query = NULL;
 556         char *option_query = NULL;
 557         char *name = NULL;
 558         sqlite3_stmt *stmt = NULL;
 559         filter_s *_filter = (filter_s *)filter;
 560
 561         if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 562                 select_query = g_strdup_printf(SELECT_MEDIA_GROUP_LIST_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
 563         else
 564                 select_query = g_strdup_printf(SELECT_MEDIA_GROUP_LIST, __media_db_get_group_name(group));
 565
 566         ret = __media_db_make_query(filter, &condition_query, &option_query);
 567         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 568                 g_free(select_query);
 569                 return ret;
 570         }
 571
 572         ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
 573         g_free(select_query);
 574         g_free(condition_query);
 575         g_free(option_query);
 576         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 577
 578         while (sqlite3_step(stmt) == SQLITE_ROW) {
 579                 name = g_strdup((const char *)sqlite3_column_text(stmt, 0));
 580
 581                 if (callback(name, user_data) == false) {
 582                         g_free(name);
 583                         break;
 584                 }
 585
 586                 g_free(name);
 587         }
 588
 589         SQLITE3_FINALIZE(stmt);
 590
 591         return ret;
 592 }
 593 #endif
 594
 595 int _media_db_get_album(filter_h filter, media_album_cb callback, void *user_data)
 596 {
 597         int ret = MEDIA_CONTENT_ERROR_NONE;
 598         char select_query[MAX_QUERY_SIZE] = {0, };
 599         char *condition_query = NULL;
 600         char *option_query = NULL;
 601         sqlite3_stmt *stmt = NULL;
 602         filter_s *_filter = (filter_s *)filter;
 603
 604 #ifdef _USE_TVPD_MODE
 605         if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 606                 snprintf(select_query, sizeof(select_query), SELECT_ALBUM_LIST, _filter->storage_id);
 607         else
 608                 snprintf(select_query, sizeof(select_query), SELECT_ALBUM_LIST, DB_VIEW_MEDIA);
 609 #else
 610         if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 611                 snprintf(select_query, sizeof(select_query), SELECT_ALBUM_LIST_BY_STORAGE_ID, _filter->storage_id);
 612         else
 613                 snprintf(select_query, sizeof(select_query), SELECT_ALBUM_LIST);
 614 #endif
 615         ret = __media_db_make_query(filter, &condition_query, &option_query);
 616         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 617
 618         ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
 619         g_free(condition_query);
 620         g_free(option_query);
 621         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 622
 623         while (sqlite3_step(stmt) == SQLITE_ROW) {
 624                 media_album_s *album = g_new0(media_album_s, 1);
 625
 626                 album->album_id = sqlite3_column_int(stmt, 0);
 627                 album->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
 628                 album->artist = g_strdup((const char *)sqlite3_column_text(stmt, 2));
 629                 album->album_art_path = g_strdup((const char *)sqlite3_column_text(stmt, 3));
 630
 631                 if (callback((media_album_h)album, user_data) == false) {
 632                         media_album_destroy((media_album_h)album);
 633                         break;
 634                 }
 635
 636                 media_album_destroy((media_album_h)album);
 637         }
 638
 639         SQLITE3_FINALIZE(stmt);
 640
 641         return ret;
 642 }
 643
 644 int _media_db_get_folder(filter_h filter, media_folder_cb callback, void *user_data)
 645 {
 646         int ret = MEDIA_CONTENT_ERROR_NONE;
 647         char select_query[MAX_QUERY_SIZE] = {0, };
 648         char *condition_query = NULL;
 649         char *option_query = NULL;
 650         sqlite3_stmt *stmt = NULL;
 651         filter_s *_filter = (filter_s *)filter;
 652
 653 #ifdef _USE_TVPD_MODE
 654         if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 655                 snprintf(select_query, sizeof(select_query), SELECT_FOLDER_LIST_BY_STORAGE_ID, _filter->storage_id, _filter->storage_id);
 656         else
 657                 snprintf(select_query, sizeof(select_query), SELECT_FOLDER_LIST, DB_VIEW_MEDIA);
 658 #else
 659         if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 660                 snprintf(select_query, sizeof(select_query), SELECT_FOLDER_LIST_BY_STORAGE_ID, _filter->storage_id);
 661         else
 662                 snprintf(select_query, sizeof(select_query), SELECT_FOLDER_LIST);
 663 #endif
 664         ret = __media_db_make_query(filter, &condition_query, &option_query);
 665         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 666
 667         ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
 668         g_free(condition_query);
 669         g_free(option_query);
 670         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 671
 672         while (sqlite3_step(stmt) == SQLITE_ROW) {
 673                 media_folder_s *_folder = g_new0(media_folder_s, 1);
 674
 675                 _folder->folder_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
 676                 _folder->path = g_strdup((const char *)sqlite3_column_text(stmt, 1));
 677                 _folder->name = g_strdup((const char *)sqlite3_column_text(stmt, 2));
 678                 _folder->storage_type = sqlite3_column_int(stmt, 3);
 679                 _folder->storage_uuid = g_strdup((const char *)sqlite3_column_text(stmt, 4));
 680
 681                 if (callback((media_folder_h)_folder, user_data) == false) {
 682                         media_folder_destroy((media_folder_h) _folder);
 683                         break;
 684                 }
 685
 686                 media_folder_destroy((media_folder_h) _folder);
 687         }
 688
 689         SQLITE3_FINALIZE(stmt);
 690
 691         return ret;
 692 }
 693
 694 int _media_db_get_playlist(filter_h filter, media_playlist_cb callback, void *user_data)
 695 {
 696         int ret = MEDIA_CONTENT_ERROR_NONE;
 697         char *condition_query = NULL;
 698         char *option_query = NULL;
 699         sqlite3_stmt *stmt = NULL;
 700
 701         ret = __media_db_make_query(filter, &condition_query, &option_query);
 702         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 703
 704         ret = _content_query_prepare(SELECT_PLAYLIST_LIST, condition_query, option_query, &stmt);
 705         g_free(condition_query);
 706         g_free(option_query);
 707         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 708
 709         while (sqlite3_step(stmt) == SQLITE_ROW) {
 710                 media_playlist_s *_playlist = g_new0(media_playlist_s, 1);
 711
 712                 _playlist->playlist_id = sqlite3_column_int(stmt, 0);
 713                 _playlist->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
 714                 _playlist->thumbnail_path = g_strdup((const char *)sqlite3_column_text(stmt, 2));
 715
 716                 if (callback((media_playlist_h)_playlist, user_data) == false) {
 717                         media_playlist_destroy((media_playlist_h)_playlist);
 718                         break;
 719                 }
 720                 media_playlist_destroy((media_playlist_h)_playlist);
 721         }
 722
 723         SQLITE3_FINALIZE(stmt);
 724
 725         return ret;
 726 }
 727
 728 int _media_db_get_playlist_item(int playlist_id, filter_h filter, playlist_member_cb callback, void *user_data)
 729 {
 730         int ret = MEDIA_CONTENT_ERROR_NONE;
 731         char *select_query = NULL;
 732         char *condition_query = NULL;
 733         char *option_query = NULL;
 734         sqlite3_stmt *stmt = NULL;
 735
 736         select_query = g_strdup_printf(SELECT_PLAYLIST_ITEM_ALL_FROM_PLAYLIST_VIEW, playlist_id);
 737
 738         ret = __media_db_make_query(filter, &condition_query, &option_query);
 739         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 740                 g_free(select_query);
 741                 return ret;
 742         }
 743
 744         ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
 745         g_free(select_query);
 746         g_free(condition_query);
 747         g_free(option_query);
 748         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 749
 750         while (sqlite3_step(stmt) == SQLITE_ROW) {
 751                 int playlist_member_id = 0;
 752                 playlist_member_id = sqlite3_column_int(stmt, MEDIA_INFO_ITEM_MAX);     /*MEDIA_INFO_ITEM_MAX is pm_id*/
 753
 754                 media_info_s *_media = g_new0(media_info_s, 1);
 755
 756                 _media_info_item_get_detail(stmt, (media_info_h)_media);
 757
 758                 if (callback(playlist_member_id, (media_info_h)_media, user_data) == false) {
 759                         media_info_destroy((media_info_h)_media);
 760                         break;
 761                 }
 762                 media_info_destroy((media_info_h)_media);
 763
 764         }
 765
 766         SQLITE3_FINALIZE(stmt);
 767
 768         return ret;
 769 }
 770
 771 int _media_db_get_tag(const char *media_id, filter_h filter, media_tag_cb callback, void *user_data)
 772 {
 773         int ret = MEDIA_CONTENT_ERROR_NONE;
 774         char *select_query = NULL;
 775         char *condition_query = NULL;
 776         char *option_query = NULL;
 777         sqlite3_stmt *stmt = NULL;
 778
 779         if (STRING_VALID(media_id))
 780                 select_query = g_strdup_printf(SELECT_TAG_LIST_BY_MEDIA_ID, media_id);
 781         else
 782                 select_query = g_strdup(SELECT_TAG_LIST);
 783
 784         ret = __media_db_make_query(filter, &condition_query, &option_query);
 785         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 786                 g_free(select_query);
 787                 return ret;
 788         }
 789
 790         ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
 791         g_free(select_query);
 792         g_free(condition_query);
 793         g_free(option_query);
 794         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 795
 796         while (sqlite3_step(stmt) == SQLITE_ROW) {
 797                 media_tag_s *_tag = g_new0(media_tag_s, 1);
 798
 799                 _tag->tag_id = sqlite3_column_int(stmt, 0);
 800                 _tag->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
 801
 802                 if (callback((media_tag_h)_tag, user_data) == false) {
 803                         media_tag_destroy((media_tag_h)_tag);
 804                         break;
 805                 }
 806                 media_tag_destroy((media_tag_h)_tag);
 807         }
 808
 809         SQLITE3_FINALIZE(stmt);
 810
 811         return ret;
 812 }
 813
 814 int _media_db_get_bookmark(const char *media_id, filter_h filter, media_bookmark_cb callback, void *user_data)
 815 {
 816         int ret = MEDIA_CONTENT_ERROR_NONE;
 817         char select_query[MAX_QUERY_SIZE] = {0, };
 818         char *condition_query = NULL;
 819         char *option_query = NULL;
 820         sqlite3_stmt *stmt = NULL;
 821         filter_s *_filter = (filter_s *)filter;
 822
 823 #ifdef _USE_TVPD_MODE
 824         if (STRING_VALID(media_id)) {   //get bookmark by media_id
 825                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 826                         snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST_BY_MEDIA_ID, _filter->storage_id, media_id);
 827                 else
 828                         snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST_BY_MEDIA_ID, DB_VIEW_MEDIA, media_id);
 829         } else {
 830                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 831                         snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST, _filter->storage_id);
 832                 else
 833                         snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST, DB_VIEW_MEDIA);
 834         }
 835 #else
 836         if (STRING_VALID(media_id)) {   //get bookmark by media_id
 837                 snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST_BY_MEDIA_ID, media_id);
 838         } else {
 839                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 840                         snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST_BY_STORAGE_ID, _filter->storage_id);
 841                 else
 842                         snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST);
 843         }
 844 #endif
 845
 846         ret = __media_db_make_query(filter, &condition_query, &option_query);
 847         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 848
 849         ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
 850         g_free(condition_query);
 851         g_free(option_query);
 852         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 853
 854         while (sqlite3_step(stmt) == SQLITE_ROW) {
 855                 media_bookmark_s *bookmark = g_new0(media_bookmark_s, 1);
 856
 857                 bookmark->bookmark_id = sqlite3_column_int(stmt, 0);
 858                 bookmark->media_id = g_strdup((const char *)sqlite3_column_text(stmt, 1));
 859                 bookmark->marked_time = sqlite3_column_int(stmt, 2);
 860                 bookmark->thumbnail_path = g_strdup((const char *)sqlite3_column_text(stmt, 3));
 861                 bookmark->name = g_strdup((const char *)sqlite3_column_text(stmt, 4));
 862
 863                 if (callback((media_bookmark_h)bookmark, user_data) == false) {
 864                         media_bookmark_destroy((media_bookmark_h)bookmark);
 865                         break;
 866                 }
 867
 868                 media_bookmark_destroy((media_bookmark_h)bookmark);
 869         }
 870
 871         SQLITE3_FINALIZE(stmt);
 872
 873         return ret;
 874
 875 }
 876
 877 int _media_db_get_face(const char *media_id, filter_h filter, media_face_cb callback, void *user_data)
 878 {
 879         int ret = MEDIA_CONTENT_ERROR_NONE;
 880         char select_query[MAX_QUERY_SIZE] = {0, };
 881         char *condition_query = NULL;
 882         char *option_query = NULL;
 883         sqlite3_stmt *stmt = NULL;
 884         filter_s *_filter = (filter_s *)filter;
 885
 886 #ifdef _USE_TVPD_MODE
 887         if (STRING_VALID(media_id)) {   //get face by media_id
 888                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 889                         snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST_BY_MEDIA_ID, _filter->storage_id, media_id);
 890                 else
 891                         snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST_BY_MEDIA_ID, DB_VIEW_MEDIA, media_id);
 892         } else {
 893                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 894                         snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST, _filter->storage_id);
 895                 else
 896                         snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST, DB_VIEW_MEDIA);
 897         }
 898 #else
 899         if (STRING_VALID(media_id)) {   //get face by media_id
 900                 snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST_BY_MEDIA_ID, media_id);
 901         } else {
 902                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 903                         snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST_BY_STORAGE_ID, _filter->storage_id);
 904                 else
 905                         snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST);
 906         }
 907 #endif
 908         ret = __media_db_make_query(filter, &condition_query, &option_query);
 909         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 910
 911         ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
 912         g_free(condition_query);
 913         g_free(option_query);
 914         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 915
 916         while (sqlite3_step(stmt) == SQLITE_ROW) {
 917                 media_face_s *face = g_new0(media_face_s, 1);
 918
 919                 face->face_id = sqlite3_column_int(stmt, 0);
 920                 face->media_id = g_strdup((const char *)sqlite3_column_text(stmt, 1));
 921                 face->face_rect_x = sqlite3_column_int(stmt, 2);
 922                 face->face_rect_y = sqlite3_column_int(stmt, 3);
 923                 face->face_rect_w = sqlite3_column_int(stmt, 4);
 924                 face->face_rect_h = sqlite3_column_int(stmt, 5);
 925                 face->orientation = sqlite3_column_int(stmt, 6);
 926                 face->face_tag = g_strdup((const char *)sqlite3_column_text(stmt, 7));
 927
 928                 if (callback((media_face_h)face, user_data) == false) {
 929                         media_face_destroy((media_face_h)face);
 930                         break;
 931                 }
 932
 933                 media_face_destroy((media_face_h)face);
 934         }
 935
 936         SQLITE3_FINALIZE(stmt);
 937
 938         return ret;
 939
 940 }
 941
 942 int _media_db_get_group_item_count_by_id(int group_id, filter_h filter, group_list_e group_type, int *item_count)
 943 {
 944         int ret = MEDIA_CONTENT_ERROR_NONE;
 945         sqlite3_stmt *stmt = NULL;
 946         char select_query[MAX_QUERY_SIZE] = {0, };
 947         char *condition_query = NULL;
 948         char *option_query = NULL;
 949         filter_s *_filter = (filter_s *)filter;
 950
 951         switch (group_type) {
 952         case MEDIA_GROUP_ALBUM:
 953 #ifdef _USE_TVPD_MODE
 954                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 955                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_ALBUM, _filter->storage_id, group_id);
 956                 else
 957                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_ALBUM, DB_VIEW_MEDIA, group_id);
 958 #else
 959                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 960                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_ALBUM_BY_STORAGE_ID, group_id, _filter->storage_id);
 961                 else
 962                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_ALBUM, group_id);
 963 #endif
 964                 break;
 965
 966         case MEDIA_GROUP_PLAYLIST:
 967                 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_PLAYLIST, group_id);
 968                 break;
 969
 970         case MEDIA_GROUP_TAG:
 971                 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_TAG, group_id);
 972                 break;
 973
 974         default:
 975                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 976                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 977         }
 978
 979         ret = __media_db_make_query(filter, &condition_query, &option_query);
 980         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 981
 982         ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
 983         g_free(condition_query);
 984         g_free(option_query);
 985         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 986
 987         if (sqlite3_step(stmt) == SQLITE_ROW)
 988                 *item_count = sqlite3_column_int(stmt, 0);
 989
 990         SQLITE3_FINALIZE(stmt);
 991
 992         return ret;
 993 }
 994
 995 int _media_db_get_group_item_count(const char *group_name, filter_h filter, group_list_e group_type, int *item_count)
 996 {
 997         int ret = MEDIA_CONTENT_ERROR_NONE;
 998         sqlite3_stmt *stmt = NULL;
 999         char select_query[MAX_QUERY_SIZE] = {0, };
1000         char *condition_query = NULL;
1001         char *option_query = NULL;
1002         char *tmp_option = NULL;
1003         bool need_bracket = false;
1004         filter_s *_filter = (filter_s *)filter;
1005
1006         switch (group_type) {
1007         case MEDIA_GROUP_NONE:
1008                 if (!_filter) {
1009 #ifdef _USE_TVPD_MODE
1010                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE, DB_VIEW_MEDIA);
1011 #else
1012                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE);
1013 #endif
1014                         break;
1015                 }
1016
1017                 if (_filter->offset < 0 && _filter->count < 0) {
1018 #ifdef _USE_TVPD_MODE
1019                         if (STRING_VALID(_filter->storage_id))
1020                                 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE, _filter->storage_id);
1021                         else
1022                                 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE, DB_VIEW_MEDIA);
1023 #else
1024                         if (STRING_VALID(_filter->storage_id))
1025                                 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE_BY_STORAGE_ID, _filter->storage_id);
1026                         else
1027                                 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE);
1028 #endif
1029                 } else {
1030 #ifdef _USE_TVPD_MODE
1031                         if (STRING_VALID(_filter->storage_id))
1032                                 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA, _filter->storage_id);
1033                         else
1034                                 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA, DB_VIEW_MEDIA);
1035 #else
1036                         if (STRING_VALID(_filter->storage_id))
1037                                 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_BY_STORAGE_ID, _filter->storage_id);
1038                         else
1039                                 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA);
1040
1041 #endif
1042                         need_bracket = true;
1043                 }
1044                 break;
1045
1046         case MEDIA_GROUP_FOLDER:
1047 #ifdef _USE_TVPD_MODE
1048                 if (_filter && STRING_VALID(_filter->storage_id))
1049                         sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_FOLDER, _filter->storage_id, group_name);
1050                 else
1051                         sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
1052 #else
1053                 if (_filter && STRING_VALID(_filter->storage_id))
1054                         sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_FOLDER_BY_STORAGE_ID, group_name, _filter->storage_id);
1055                 else
1056                         sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_FOLDER, group_name);
1057 #endif
1058                 break;
1059
1060         case MEDIA_GROUP_TAG_BY_MEDIA_ID:
1061                 snprintf(select_query, sizeof(select_query), SELECT_TAG_COUNT_BY_MEDIA_ID, group_name);
1062                 break;
1063
1064         case MEDIA_GROUP_BOOKMARK_BY_MEDIA_ID:
1065 #ifdef _USE_TVPD_MODE
1066                 if (_filter && STRING_VALID(_filter->storage_id))
1067                         sqlite3_snprintf(sizeof(select_query), select_query, SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, _filter->storage_id, group_name);
1068                 else
1069                         sqlite3_snprintf(sizeof(select_query), select_query, SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, DB_VIEW_MEDIA, group_name);
1070 #else
1071                 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, group_name);
1072 #endif
1073                 break;
1074
1075         case MEDIA_GROUP_STORAGE:
1076 #ifdef _USE_TVPD_MODE
1077                 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_STORAGE, group_name, group_name);
1078 #else
1079                 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_STORAGE, group_name);
1080 #endif
1081                 break;
1082
1083         case MEDIA_GROUP_FACE_BY_MEDIA_ID:
1084 #ifdef _USE_TVPD_MODE
1085                 if (_filter && STRING_VALID(_filter->storage_id))
1086                         sqlite3_snprintf(sizeof(select_query), select_query, SELECT_FACE_COUNT_BY_MEDIA_ID, _filter->storage_id, group_name);
1087                 else
1088                         sqlite3_snprintf(sizeof(select_query), select_query, SELECT_FACE_COUNT_BY_MEDIA_ID, DB_VIEW_MEDIA, group_name);
1089 #else
1090                 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_FACE_COUNT_BY_MEDIA_ID, group_name);
1091 #endif
1092                 break;
1093
1094 #ifdef _USE_TVPD_MODE
1095         case MEDIA_GROUP_PVR:
1096                 if (_filter && STRING_VALID(_filter->storage_id))
1097                         snprintf(select_query, sizeof(select_query), SELECT_PVR_COUNT_BY_STORAGE_ID, _filter->storage_id);
1098                 else
1099                         SAFE_STRLCPY(select_query, SELECT_PVR_COUNT, sizeof(select_query));
1100                 break;
1101
1102         case MEDIA_GROUP_UHD:
1103                 if (_filter && STRING_VALID(_filter->storage_id))
1104                         snprintf(select_query, sizeof(select_query), SELECT_UHD_COUNT_BY_STORAGE_ID, _filter->storage_id);
1105                 else
1106                         SAFE_STRLCPY(select_query, SELECT_UHD_COUNT, sizeof(select_query));
1107                 break;
1108 #endif
1109         default:
1110                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1111                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1112         }
1113
1114         ret = __media_db_make_query(filter, &condition_query, &option_query);
1115         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1116
1117         if (need_bracket) {
1118                 tmp_option = g_strconcat(option_query, ")", NULL);
1119                 g_free(option_query);
1120                 option_query = tmp_option;
1121         }
1122
1123         ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1124         g_free(condition_query);
1125         g_free(option_query);
1126         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1127
1128         if (sqlite3_step(stmt) == SQLITE_ROW)
1129                 *item_count = sqlite3_column_int(stmt, 0);
1130
1131         SQLITE3_FINALIZE(stmt);
1132
1133         return ret;
1134 }
1135
1136 int _media_db_get_group_item_by_id(int group_id, filter_h filter, media_info_cb callback, void *user_data, group_list_e group_type)
1137 {
1138         int ret = MEDIA_CONTENT_ERROR_NONE;
1139         char select_query[MAX_QUERY_SIZE] = {0, };
1140         char *condition_query = NULL;
1141         char *option_query = NULL;
1142         sqlite3_stmt *stmt = NULL;
1143         filter_s *_filter = (filter_s *)filter;
1144
1145         switch (group_type) {
1146         case MEDIA_GROUP_ALBUM:
1147 #ifdef _USE_TVPD_MODE
1148                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1149                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_ALBUM, _filter->storage_id, group_id);
1150                 else
1151                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_ALBUM, DB_VIEW_MEDIA, group_id);
1152 #else
1153                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1154                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_ALBUM_BY_STORAGE_ID, group_id, _filter->storage_id);
1155                 else
1156                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_ALBUM, group_id);
1157 #endif
1158                 break;
1159
1160         case MEDIA_GROUP_PLAYLIST:
1161 #ifdef _USE_TVPD_MODE
1162                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1163                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_PLAYLIST, _filter->storage_id, group_id);
1164                 else
1165                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_PLAYLIST, DB_VIEW_MEDIA, group_id);
1166 #else
1167                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1168                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_PLAYLIST_BY_STORAGE_ID, group_id, _filter->storage_id);
1169                 else
1170                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_PLAYLIST, group_id);
1171 #endif
1172                 break;
1173
1174         case MEDIA_GROUP_TAG:
1175 #ifdef _USE_TVPD_MODE
1176                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1177                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_TAG, _filter->storage_id, group_id);
1178                 else
1179                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_TAG, DB_VIEW_MEDIA, group_id);
1180 #else
1181                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1182                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_TAG_BY_STORAGE_ID, group_id, _filter->storage_id);
1183                 else
1184                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_TAG, group_id);
1185 #endif
1186                 break;
1187
1188         default:
1189                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1190                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1191         }
1192
1193         ret = __media_db_make_query(filter, &condition_query, &option_query);
1194         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1195
1196         ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1197         g_free(condition_query);
1198         g_free(option_query);
1199         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1200
1201         while (sqlite3_step(stmt) == SQLITE_ROW) {
1202                 media_info_s *item = g_new0(media_info_s, 1);
1203
1204                 _media_info_item_get_detail(stmt, (media_info_h)item);
1205
1206                 if (callback((media_info_h)item, user_data) == false) {
1207                         media_info_destroy((media_info_h)item);
1208                         break;
1209                 }
1210
1211                 media_info_destroy((media_info_h)item);
1212         }
1213
1214         SQLITE3_FINALIZE(stmt);
1215
1216         return ret;
1217 }
1218
1219 int _media_db_get_group_item(const char *group_name, filter_h filter, media_info_cb callback, void *user_data, group_list_e group_type)
1220 {
1221         int ret = MEDIA_CONTENT_ERROR_NONE;
1222         char select_query[MAX_QUERY_SIZE] = {0, };
1223         char *condition_query = NULL;
1224         char *option_query = NULL;
1225         sqlite3_stmt *stmt = NULL;
1226         filter_s *_filter = (filter_s *)filter;
1227
1228         switch (group_type) {
1229         case MEDIA_GROUP_NONE:
1230 #ifdef _USE_TVPD_MODE
1231                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1232                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_ITEM, _filter->storage_id);
1233                 else
1234                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_ITEM, DB_VIEW_MEDIA);
1235 #else
1236                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1237                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_ITEM_BY_STORAGE_ID, _filter->storage_id);
1238                 else
1239                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_ITEM);
1240 #endif
1241                 break;
1242
1243         case MEDIA_GROUP_FOLDER:
1244 #ifdef _USE_TVPD_MODE
1245                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1246                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_FOLDER, _filter->storage_id, group_name);
1247                 else
1248                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
1249 #else
1250                 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_FOLDER, group_name);
1251 #endif
1252                 break;
1253
1254         case MEDIA_GROUP_STORAGE:
1255 #ifdef _USE_TVPD_MODE
1256                 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_STORAGE, group_name, group_name);
1257 #else
1258                 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_STORAGE, group_name);
1259 #endif
1260                 break;
1261
1262         default:
1263                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1264                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1265         }
1266
1267         ret = __media_db_make_query(filter, &condition_query, &option_query);
1268         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1269
1270         ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1271         g_free(condition_query);
1272         g_free(option_query);
1273         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1274
1275         while (sqlite3_step(stmt) == SQLITE_ROW) {
1276                 media_info_s *item = g_new0(media_info_s, 1);
1277
1278                 _media_info_item_get_detail(stmt, (media_info_h)item);
1279
1280                 if (callback((media_info_h)item, user_data) == false) {
1281                         media_info_destroy((media_info_h)item);
1282                         break;
1283                 }
1284
1285                 media_info_destroy((media_info_h)item);
1286         }
1287
1288         SQLITE3_FINALIZE(stmt);
1289
1290         return ret;
1291 }
1292
1293 #ifdef _USE_SENIOR_MODE
1294 int _media_db_get_group_item_by_union_select(const char *group_name, filter_h filter1, filter_h filter2, media_info_cb callback, void *user_data)
1295 {
1296         int ret = MEDIA_CONTENT_ERROR_NONE;
1297         char select_query1[MAX_QUERY_SIZE] = {0, };
1298         char *condition_query1 = NULL;
1299         char *option_query1 = NULL;
1300         char select_query2[MAX_QUERY_SIZE] = {0, };
1301         char *condition_query2 = NULL;
1302         char *option_query2 = NULL;
1303         sqlite3_stmt *stmt = NULL;
1304         filter_s *_filter1 = (filter_s *)filter1;
1305         filter_s *_filter2 = (filter_s *)filter2;
1306
1307         if ((_filter1 != NULL) && STRING_VALID(_filter1->storage_id))
1308                 snprintf(select_query1, sizeof(select_query1), SELECT_MEDIA_FROM_FOLDER, _filter1->storage_id, group_name);
1309         else
1310                 snprintf(select_query1, sizeof(select_query1), SELECT_MEDIA_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
1311
1312         ret = __media_db_make_query(filter, &condition_query1, &option_query1);
1313         if (ret != MEDIA_CONTENT_ERROR_NONE) {
1314                 SAFE_FREE(condition_query1);
1315                 SAFE_FREE(option_query1);
1316                 content_error("create select_query1 failed");
1317                 return ret;
1318         }
1319
1320         if ((_filter2 != NULL) && STRING_VALID(_filter2->storage_id))
1321                 snprintf(select_query2, sizeof(select_query2), SELECT_MEDIA_FROM_FOLDER, _filter2->storage_id, group_name);
1322         else
1323                 snprintf(select_query2, sizeof(select_query2), SELECT_MEDIA_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
1324
1325         ret = __media_db_make_query(filter, &condition_query2, &option_query2);
1326         if (ret != MEDIA_CONTENT_ERROR_NONE) {
1327                 SAFE_FREE(condition_query1);
1328                 SAFE_FREE(option_query1);
1329                 SAFE_FREE(condition_query2);
1330                 SAFE_FREE(option_query2);
1331                 content_error("create select_query2 failed");
1332                 return ret;
1333         }
1334
1335         ret = _content_query_prepare_by_union_select(&stmt, select_query1, condition_query1, option_query1, select_query2, condition_query2, option_query2);
1336         SAFE_FREE(condition_query1);
1337         SAFE_FREE(option_query1);
1338         SAFE_FREE(condition_query2);
1339         SAFE_FREE(option_query2);
1340         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1341
1342         while (sqlite3_step(stmt) == SQLITE_ROW) {
1343                 media_info_s *item = g_new0(media_info_s, 1);
1344
1345                 _media_info_item_get_detail(stmt, (media_info_h)item);
1346
1347                 if (callback((media_info_h)item, user_data) == false) {
1348                         media_info_destroy((media_info_h)item);
1349                         break;
1350                 }
1351
1352                 media_info_destroy((media_info_h)item);
1353         }
1354
1355         SQLITE3_FINALIZE(stmt);
1356
1357         return ret;
1358 }
1359 #endif
1360
1361 int _media_db_get_media_group_item_count(const char *group_name, filter_h filter, media_group_e group, int *item_count)
1362 {
1363         int ret = MEDIA_CONTENT_ERROR_NONE;
1364         sqlite3_stmt *stmt = NULL;
1365         char select_query[MAX_QUERY_SIZE] = {0, };
1366         char *tmp_option = NULL;
1367         char *condition_query = NULL;
1368         char *option_query = NULL;
1369         filter_s *_filter = (filter_s *)filter;
1370
1371 #ifdef _USE_TVPD_MODE
1372         if (group < MEDIA_PVR_GROUP_DURATION) { /*media content */
1373                 if (group_name != NULL) {
1374                         if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1375                                 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_GROUP, _filter->storage_id, __media_db_get_group_name(group), group_name);
1376                         else
1377                                 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_GROUP, DB_VIEW_MEDIA, __media_db_get_group_name(group), group_name);
1378                 } else {
1379                         if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1380                                 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL, _filter->storage_id, __media_db_get_group_name(group));
1381                         else
1382                                 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL, DB_VIEW_MEDIA, __media_db_get_group_name(group));
1383                 }
1384         } else if (group < MEDIA_UHD_GROUP_CONTENT_TITLE) {/*pvr content*/
1385                 if (group_name != NULL) {
1386                         if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1387                                 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_PVR_COUNT_FROM_GROUP_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group), group_name);
1388                         else
1389                                 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_PVR_COUNT_FROM_GROUP, __media_db_get_group_name(group), group_name);
1390                 } else {
1391                         if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1392                                 snprintf(select_query, sizeof(select_query), SELECT_PVR_COUNT_FROM_GROUP_NULL_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group));
1393                         else
1394                                 snprintf(select_query, sizeof(select_query), SELECT_PVR_COUNT_FROM_GROUP_NULL, __media_db_get_group_name(group));
1395                 }
1396         } else {/*uhd content*/
1397                 if (group_name != NULL) {
1398                         if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1399                                 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_UHD_COUNT_FROM_GROUP_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group), group_name);
1400                         else
1401                                 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_UHD_COUNT_FROM_GROUP, __media_db_get_group_name(group), group_name);
1402                 } else {
1403                         if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1404                                 snprintf(select_query, sizeof(select_query), SELECT_UHD_COUNT_FROM_GROUP_NULL_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group));
1405                         else
1406                                 snprintf(select_query, sizeof(select_query), SELECT_UHD_COUNT_FROM_GROUP_NULL, __media_db_get_group_name(group));
1407                 }
1408         }
1409 #else
1410         if (group_name != NULL) {
1411                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1412                         sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_GROUP_BY_STORAGE_ID, __media_db_get_group_name(group), group_name, _filter->storage_id);
1413                 else
1414                         sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_GROUP, __media_db_get_group_name(group), group_name);
1415         } else {
1416                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1417                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
1418                 else
1419                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL, __media_db_get_group_name(group));
1420         }
1421 #endif
1422         ret = __media_db_make_query(filter, &condition_query, &option_query);
1423         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1424
1425         /* If 'filter' is not NULL, 'option_query' must be created. */
1426         if (option_query) {
1427                 tmp_option = g_strconcat(option_query, ")", NULL);
1428                 g_free(option_query);
1429                 option_query = tmp_option;
1430         } else {
1431                 SAFE_STRLCAT(select_query, ")", sizeof(select_query));
1432         }
1433
1434         ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1435         g_free(condition_query);
1436         g_free(option_query);
1437         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1438
1439         if (sqlite3_step(stmt) == SQLITE_ROW)
1440                 *item_count = sqlite3_column_int(stmt, 0);
1441
1442         SQLITE3_FINALIZE(stmt);
1443
1444         return ret;
1445 }
1446
1447 int _media_db_get_media_group_item(const char *group_name, filter_h filter, media_group_e group, media_info_cb callback, void *user_data)
1448 {
1449         int ret = MEDIA_CONTENT_ERROR_NONE;
1450         char select_query[MAX_QUERY_SIZE] = {0, };
1451         char *condition_query = NULL;
1452         char *option_query = NULL;
1453         sqlite3_stmt *stmt = NULL;
1454         filter_s *_filter = (filter_s *)filter;
1455
1456 #ifdef _USE_TVPD_MODE
1457         if (group_name != NULL) {
1458                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1459                         sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_FROM_GROUP, _filter->storage_id, __media_db_get_group_name(group), group_name);
1460                 else
1461                         sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_FROM_GROUP, DB_VIEW_MEDIA, __media_db_get_group_name(group), group_name);
1462         } else {
1463                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1464                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL, _filter->storage_id, __media_db_get_group_name(group));
1465                 else
1466                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL, DB_VIEW_MEDIA, __media_db_get_group_name(group));
1467         }
1468 #else
1469         if (group_name != NULL) {
1470                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1471                         sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_FROM_GROUP_BY_STORAGE_ID, __media_db_get_group_name(group), group_name, _filter->storage_id);
1472                 else
1473                         sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_FROM_GROUP, __media_db_get_group_name(group), group_name);
1474         } else {
1475                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1476                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
1477                 else
1478                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL, __media_db_get_group_name(group));
1479         }
1480 #endif
1481         ret = __media_db_make_query(filter, &condition_query, &option_query);
1482         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1483
1484         ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1485         g_free(condition_query);
1486         g_free(option_query);
1487         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1488
1489         while (sqlite3_step(stmt) == SQLITE_ROW) {
1490                 media_info_s *item = g_new0(media_info_s, 1);
1491
1492                 _media_info_item_get_detail(stmt, (media_info_h)item);
1493
1494                 if (callback((media_info_h)item, user_data) == false) {
1495                         media_info_destroy((media_info_h)item);
1496                         break;
1497                 }
1498
1499                 media_info_destroy((media_info_h)item);
1500         }
1501
1502         SQLITE3_FINALIZE(stmt);
1503
1504         return ret;
1505 }
1506
1507 int _media_db_get_storage(filter_h filter, media_storage_cb callback, void *user_data)
1508 {
1509         int ret = MEDIA_CONTENT_ERROR_NONE;
1510         char *condition_query = NULL;
1511         char *option_query = NULL;
1512         sqlite3_stmt *stmt = NULL;
1513
1514         ret = __media_db_make_query(filter, &condition_query, &option_query);
1515         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1516
1517         ret = _content_query_prepare(SELECT_STORAGE_LIST, condition_query, option_query, &stmt);
1518         g_free(condition_query);
1519         g_free(option_query);
1520         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1521
1522         while (sqlite3_step(stmt) == SQLITE_ROW) {
1523                 media_storage_s *_storage = g_new0(media_storage_s, 1);
1524
1525                 _storage->storage_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
1526                 _storage->storage_path = g_strdup((const char *)sqlite3_column_text(stmt, 1));
1527                 _storage->storage_type = sqlite3_column_int(stmt, 2);
1528
1529                 if (callback((media_storage_h)_storage, user_data) == false) {
1530                         media_storage_destroy((media_storage_h) _storage);
1531                         break;
1532                 }
1533
1534                 media_storage_destroy((media_storage_h) _storage);
1535         }
1536
1537         SQLITE3_FINALIZE(stmt);
1538
1539         return ret;
1540 }
1541
1542 int _media_db_get_storage_id_by_media_id(const char *media_id, char **storage_id)
1543 {
1544         int ret = MEDIA_CONTENT_ERROR_NONE;
1545         sqlite3_stmt *stmt = NULL;
1546         char *select_query = NULL;
1547
1548         select_query = sqlite3_mprintf(SELECT_MEDIA_STORAGE_ID_BY_ID, media_id);
1549
1550         ret = _content_get_result(select_query, &stmt);
1551         SQLITE3_SAFE_FREE(select_query);
1552         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1553
1554         if (sqlite3_step(stmt) == SQLITE_ROW) {
1555                 *storage_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
1556         } else {
1557                 content_error("Invalid media_id[%s]", media_id);
1558                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1559         }
1560
1561         SQLITE3_FINALIZE(stmt);
1562
1563         return ret;
1564 }
1565
1566 #ifdef _USE_TVPD_MODE
1567 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)
1568 {
1569         int ret = MEDIA_CONTENT_ERROR_NONE;
1570         char select_query[DEFAULT_QUERY_SIZE] = {0, };
1571         char *condition_query = NULL;
1572         char *option_query = NULL;
1573         sqlite3_stmt *stmt = NULL;
1574         filter_s *_filter = (filter_s *)filter;
1575
1576         if (group_name != NULL) {
1577                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1578                         sqlite3_snprintf(sizeof(select_query), select_query, SELECT_PVR_FROM_GROUP_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group), group_name);
1579                 else
1580                         sqlite3_snprintf(sizeof(select_query), select_query, SELECT_PVR_FROM_GROUP, __media_db_get_group_name(group), group_name);
1581         } else {
1582                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1583                         snprintf(select_query, sizeof(select_query), SELECT_PVR_FROM_GROUP_NULL_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group));
1584                 else
1585                         snprintf(select_query, sizeof(select_query), SELECT_PVR_FROM_GROUP_NULL, __media_db_get_group_name(group));
1586         }
1587
1588         ret = __media_db_make_query(filter, &condition_query, &option_query);
1589         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1590
1591         ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1592         g_free(condition_query);
1593         g_free(option_query);
1594         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1595
1596         while (sqlite3_step(stmt) == SQLITE_ROW) {
1597                 media_pvr_s *item = g_new0(media_pvr_s, 1);
1598
1599                 _media_pvr_item_get_detail(stmt, (media_pvr_h)item);
1600
1601                 if (callback((media_pvr_h)item, user_data) == false) {
1602                         media_info_destroy((media_pvr_h)item);
1603                         break;
1604                 }
1605
1606                 media_pvr_destroy((media_pvr_h)item);
1607         }
1608
1609         SQLITE3_FINALIZE(stmt);
1610
1611         return ret;
1612 }
1613
1614 typedef enum {
1615         MEDIA_PVR_MEDIA_ID = 0,
1616         MEDIA_PVR_STORAGE_ID,
1617         MEDIA_PVR_PATH,
1618         MEDIA_PVR_SIZE,
1619         MEDIA_PVR_DURATION,
1620         MEDIA_PVR_TIME_ZONE,
1621         MEDIA_PVR_PTC,
1622         MEDIA_PVR_MAJOR,
1623         MEDIA_PVR_MINOR,
1624         MEDIA_PVR_CHANNEL_TYPE,
1625         MEDIA_PVR_CHANNEL_NAME,
1626         MEDIA_PVR_CHANNEL_NUM,
1627         MEDIA_PVR_SERVICE_PROFILE,
1628         MEDIA_PVR_PROGRAM_TITLE,
1629         MEDIA_PVR_PROGRAM_NUM,
1630         MEDIA_PVR_PROGRAM_CRID,
1631         MEDIA_PVR_GUIDANCE,
1632         MEDIA_PVR_SYNOPSIS,
1633         MEDIA_PVR_GENRE,
1634         MEDIA_PVR_LANGUAGE,
1635         MEDIA_PVR_EMBARGO_TIME,
1636         MEDIA_PVR_EXPIRY_TIME,
1637         MEDIA_PVR_START_TIME,
1638         MEDIA_PVR_PROGRAM_START_TIME,
1639         MEDIA_PVR_PROGRAM_END_TIME,
1640         MEDIA_PVR_PROGRAM_DATE,
1641         MEDIA_PVR_PARENTAL_RATING,
1642         MEDIA_PVR_TIMER_RECORD,
1643         MEDIA_PVR_SERIES_RECORD,
1644         MEDIA_PVR_HD,
1645         MEDIA_PVR_SUBTITLE,
1646         MEDIA_PVR_TTX,
1647         MEDIA_PVR_AD,
1648         MEDIA_PVR_HARDOF_HEARINGRADIO,
1649         MEDIA_PVR_DATA_SERVICE,
1650         MEDIA_PVR_CONTENT_LOCK,
1651         MEDIA_PVR_CONTENT_WATCH,
1652         MEDIA_PVR_HAS_AUDIO_ONLY,
1653         MEDIA_PVR_IS_LOCAL_RECORDED,
1654         MEDIA_PVR_RESOLUTION,
1655         MEDIA_PVR_ASPECTRATIO,
1656         MEDIA_PVR_MODIFIED_MONTH,
1657         MEDIA_PVR_SPORTS_TYPE,
1658         MEDIA_PVR_GUIDANCE_LENGTH,
1659         MEDIA_PVR_TVMODE,
1660         MEDIA_PVR_PLAY_COUNT,
1661         MEDIA_PVR_PRIVATE_DATA,
1662         MEDIA_PVR_HIGHLIGHT,
1663 } media_pvr_field_e;
1664
1665 void _media_pvr_item_get_detail(sqlite3_stmt* stmt, media_pvr_h pvr)
1666 {
1667         media_pvr_s *_pvr = (media_pvr_s*)pvr;
1668
1669         _pvr->media_id = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_MEDIA_ID));
1670         _pvr->storage_id = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_STORAGE_ID));
1671         _pvr->path = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PATH));
1672         _pvr->size = (unsigned long long)sqlite3_column_int64(stmt, MEDIA_PVR_SIZE);
1673         _pvr->duration = sqlite3_column_int(stmt, MEDIA_PVR_DURATION);
1674         _pvr->timezone = sqlite3_column_int(stmt, MEDIA_PVR_TIME_ZONE);
1675         _pvr->ptc = sqlite3_column_int(stmt, MEDIA_PVR_PTC);
1676         _pvr->major = sqlite3_column_int(stmt, MEDIA_PVR_MAJOR);
1677         _pvr->minor = sqlite3_column_int(stmt, MEDIA_PVR_MINOR);
1678         _pvr->channel_type = sqlite3_column_int(stmt, MEDIA_PVR_CHANNEL_TYPE);
1679         _pvr->service_profile = (unsigned int)sqlite3_column_int(stmt, MEDIA_PVR_SERVICE_PROFILE);
1680         _pvr->channel_name = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_CHANNEL_NAME));
1681         _pvr->channel_num = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_CHANNEL_NUM));
1682         _pvr->program_title = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PROGRAM_TITLE));
1683         _pvr->program_num = sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_NUM);
1684         _pvr->program_crid = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PROGRAM_CRID));
1685         _pvr->guidance = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_GUIDANCE));
1686         _pvr->synopsis = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_SYNOPSIS));
1687         _pvr->genre = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_GENRE));
1688         _pvr->language = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_LANGUAGE));
1689         _pvr->modified_month = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_MODIFIED_MONTH));
1690         _pvr->private_data = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PRIVATE_DATA));
1691         _pvr->embargo_time = sqlite3_column_int(stmt, MEDIA_PVR_EMBARGO_TIME);
1692         _pvr->expiry_time = sqlite3_column_int(stmt, MEDIA_PVR_EXPIRY_TIME);
1693         _pvr->start_time = sqlite3_column_int(stmt, MEDIA_PVR_START_TIME);
1694         _pvr->program_start_time = sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_START_TIME);
1695         _pvr->program_end_time = sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_END_TIME);
1696         _pvr->program_date = sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_DATE);
1697         _pvr->parental_rating = sqlite3_column_int(stmt, MEDIA_PVR_PARENTAL_RATING);
1698         _pvr->timer_record = sqlite3_column_int(stmt, MEDIA_PVR_TIMER_RECORD);
1699         _pvr->series_record = sqlite3_column_int(stmt, MEDIA_PVR_SERIES_RECORD);
1700         _pvr->hd = sqlite3_column_int(stmt, MEDIA_PVR_HD);
1701         _pvr->subtitle = sqlite3_column_int(stmt, MEDIA_PVR_SUBTITLE);
1702         _pvr->ttx = sqlite3_column_int(stmt, MEDIA_PVR_TTX);
1703         _pvr->ad = sqlite3_column_int(stmt, MEDIA_PVR_AD);
1704         _pvr->hard_of_hearing_radio = sqlite3_column_int(stmt, MEDIA_PVR_HARDOF_HEARINGRADIO);
1705         _pvr->data_service = sqlite3_column_int(stmt, MEDIA_PVR_DATA_SERVICE);
1706         _pvr->content_lock = sqlite3_column_int(stmt, MEDIA_PVR_CONTENT_LOCK);
1707         _pvr->content_watch = sqlite3_column_int(stmt, MEDIA_PVR_CONTENT_WATCH);
1708         _pvr->has_audio_only = sqlite3_column_int(stmt, MEDIA_PVR_HAS_AUDIO_ONLY);
1709         _pvr->is_local_record = sqlite3_column_int(stmt, MEDIA_PVR_IS_LOCAL_RECORDED);
1710         _pvr->resolution = sqlite3_column_int(stmt, MEDIA_PVR_RESOLUTION);
1711         _pvr->aspectratio = sqlite3_column_int(stmt, MEDIA_PVR_ASPECTRATIO);
1712         _pvr->sports_type = sqlite3_column_int(stmt, MEDIA_PVR_SPORTS_TYPE);
1713         _pvr->guidance_length = sqlite3_column_int(stmt, MEDIA_PVR_GUIDANCE_LENGTH);
1714         _pvr->tvmode = sqlite3_column_int(stmt, MEDIA_PVR_TVMODE);
1715         _pvr->play_count = sqlite3_column_int(stmt, MEDIA_PVR_PLAY_COUNT);
1716         _pvr->highlight = sqlite3_column_int(stmt, MEDIA_PVR_HIGHLIGHT);
1717
1718         return;
1719 }
1720
1721 int _media_db_get_pvr(filter_h filter, media_pvr_cb callback, void *user_data)
1722 {
1723         int ret = MEDIA_CONTENT_ERROR_NONE;
1724         char select_query[DEFAULT_QUERY_SIZE] = {0, };
1725         char *condition_query = NULL;
1726         char *option_query = NULL;
1727         sqlite3_stmt *stmt = NULL;
1728         filter_s *_filter = (filter_s *)filter;
1729
1730         if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1731                 snprintf(select_query, sizeof(select_query), SELECT_PVR_LIST_BY_STORAGE_ID, _filter->storage_id);
1732         else
1733                 SAFE_STRLCAT(select_query, SELECT_PVR_LIST, sizeof(select_query));
1734
1735         ret = __media_db_make_query(filter, &condition_query, &option_query);
1736         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1737
1738         ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1739         g_free(condition_query);
1740         g_free(option_query);
1741         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1742
1743         while (sqlite3_step(stmt) == SQLITE_ROW) {
1744                 media_pvr_s *_pvr = g_new0(media_pvr_s, 1);
1745
1746                 _media_pvr_item_get_detail(stmt, (media_pvr_h)_pvr);
1747
1748                 if (callback((media_pvr_h)_pvr, user_data) == false) {
1749                         media_pvr_destroy((media_pvr_h) _pvr);
1750                         break;
1751                 }
1752
1753                 media_pvr_destroy((media_pvr_h) _pvr);
1754         }
1755
1756         SQLITE3_FINALIZE(stmt);
1757
1758         return ret;
1759 }
1760
1761 typedef enum {
1762         MEDIA_UHD_MEDIA_ID = 0,
1763         MEDIA_UHD_STORAGE_ID,
1764         MEDIA_UHD_PATH,
1765         MEDIA_UHD_SIZE,
1766         MEDIA_UHD_CONTENT_ID,
1767         MEDIA_UHD_CONTENT_TITLE,
1768         MEDIA_UHD_FILE_NAME,
1769         MEDIA_UHD_FOLDER_ID,
1770         MEDIA_UHD_RELEASE_DATE,
1771         MEDIA_UHD_MODIFIED_TIME,
1772         MEDIA_UHD_PLAYED_POSITION,
1773         MEDIA_UHD_SUB_TYPE,
1774         MEDIA_UHD_PLAYED_COUNT,
1775 } media_uhd_field_e;
1776
1777 void _media_uhd_item_get_detail(sqlite3_stmt* stmt, media_uhd_h uhd)
1778 {
1779         media_uhd_s *_uhd = (media_uhd_s*)uhd;
1780
1781         _uhd->media_id = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_MEDIA_ID));
1782         _uhd->storage_id = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_STORAGE_ID));
1783         _uhd->path = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_PATH));
1784         _uhd->size = (unsigned long long)sqlite3_column_int64(stmt, MEDIA_UHD_SIZE);
1785         _uhd->content_id = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_CONTENT_ID));
1786         _uhd->content_title = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_CONTENT_TITLE));
1787         _uhd->file_name = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_FILE_NAME));
1788         _uhd->release_date = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_RELEASE_DATE));
1789         _uhd->modified_time = sqlite3_column_int(stmt, MEDIA_UHD_MODIFIED_TIME);
1790         _uhd->played_position = sqlite3_column_int(stmt, MEDIA_UHD_PLAYED_POSITION);
1791         _uhd->sub_type = sqlite3_column_int(stmt, MEDIA_UHD_SUB_TYPE);
1792         _uhd->played_count = sqlite3_column_int(stmt, MEDIA_UHD_PLAYED_COUNT);
1793
1794         return;
1795 }
1796
1797 int _media_db_get_uhd(filter_h filter, media_uhd_cb callback, void *user_data)
1798 {
1799         int ret = MEDIA_CONTENT_ERROR_NONE;
1800         char select_query[DEFAULT_QUERY_SIZE] = {0, };
1801         char *condition_query = NULL;
1802         char *option_query = NULL;
1803         sqlite3_stmt *stmt = NULL;
1804         filter_s *_filter = (filter_s *)filter;
1805
1806         if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1807                 snprintf(select_query, sizeof(select_query), SELECT_UHD_LIST_BY_STORAGE_ID, _filter->storage_id);
1808         else
1809                 SAFE_STRLCAT(select_query, SELECT_UHD_LIST, sizeof(select_query));
1810
1811         ret = __media_db_make_query(filter, &condition_query, &option_query);
1812         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1813
1814         ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1815         g_free(condition_query);
1816         g_free(option_query);
1817         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1818
1819         while (sqlite3_step(stmt) == SQLITE_ROW) {
1820                 media_uhd_s *_uhd = g_new0(media_uhd_s, 1);
1821
1822                 _media_uhd_item_get_detail(stmt, (media_uhd_h)_uhd);
1823
1824                 if (callback((media_uhd_h)_uhd, user_data) == false) {
1825                         media_uhd_destroy((media_uhd_h) _uhd);
1826                         break;
1827                 }
1828                 media_uhd_destroy((media_uhd_h) _uhd);
1829         }
1830
1831         SQLITE3_FINALIZE(stmt);
1832
1833         return ret;
1834 }
1835 #endif