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         SAFE_FREE(condition_query);
 317         SAFE_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         SAFE_FREE(condition_query);
 359         SAFE_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                         SAFE_FREE(name);
 367                         break;
 368                 }
 369
 370                 SAFE_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         SAFE_FREE(condition_query);
 422         SAFE_FREE(option_query);
 423         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 424
 425         while (sqlite3_step(stmt) == SQLITE_ROW) {
 426                 if (STRING_VALID((const char *)sqlite3_column_text(stmt, 0)))
 427                         name = strdup((const char *)sqlite3_column_text(stmt, 0));
 428
 429                 if (callback(name, sqlite3_column_int(stmt, 1), user_data) == false) {
 430                         SAFE_FREE(name);
 431                         break;
 432                 }
 433
 434                 SAFE_FREE(name);
 435         }
 436
 437         SQLITE3_FINALIZE(stmt);
 438
 439         return ret;
 440 }
 441 #else
 442 int _media_db_get_group_count(filter_h filter, group_list_e group_type, int *group_count)
 443 {
 444         int ret = MEDIA_CONTENT_ERROR_NONE;
 445         sqlite3_stmt *stmt = NULL;
 446         char *select_query = NULL;
 447         char *condition_query = NULL;
 448         char *option_query = NULL;
 449         filter_s *_filter = (filter_s *)filter;
 450
 451         switch (group_type) {
 452         case MEDIA_GROUP_ALBUM:
 453                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 454                         select_query = g_strdup_printf(SELECT_ALBUM_COUNT_BY_STORAGE_ID, _filter->storage_id);
 455                 else
 456                         select_query = g_strdup(SELECT_ALBUM_COUNT);
 457                 break;
 458
 459         case MEDIA_GROUP_FOLDER:
 460                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 461                         select_query = g_strdup_printf(SELECT_FOLDER_COUNT_BY_STORAGE_ID, _filter->storage_id);
 462                 else
 463                         select_query = g_strdup(SELECT_FOLDER_COUNT);
 464                 break;
 465
 466         case MEDIA_GROUP_PLAYLIST:
 467                 select_query = g_strdup(SELECT_PLAYLIST_COUNT);
 468                 break;
 469
 470         case MEDIA_GROUP_TAG:
 471                 select_query = g_strdup(SELECT_TAG_COUNT);
 472                 break;
 473
 474         case MEDIA_GROUP_BOOKMARK:
 475                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 476                         select_query = g_strdup_printf(SELECT_BOOKMARK_COUNT_BY_STORAGE_ID, _filter->storage_id);
 477                 else
 478                         select_query = g_strdup(SELECT_BOOKMARK_COUNT);
 479
 480                 break;
 481
 482         case MEDIA_GROUP_STORAGE:
 483                 select_query = g_strdup(SELECT_STORAGE_COUNT);
 484                 break;
 485
 486         case MEDIA_GROUP_FACE:
 487                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 488                         select_query = g_strdup_printf(SELECT_FACE_COUNT_BY_STORAGE_ID, _filter->storage_id);
 489                 else
 490                         select_query = g_strdup(SELECT_FACE_COUNT);
 491                 break;
 492
 493         default:
 494                 content_error("Invalid group type [%d]", group_type);
 495                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 496         }
 497
 498         ret = __media_db_make_query(filter, &condition_query, &option_query);
 499         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 500                 g_free(select_query);
 501                 return ret;
 502         }
 503
 504         ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
 505         g_free(select_query);
 506         g_free(condition_query);
 507         g_free(option_query);
 508         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 509
 510         if (sqlite3_step(stmt) == SQLITE_ROW)
 511                 *group_count = sqlite3_column_int(stmt, 0);
 512
 513         SQLITE3_FINALIZE(stmt);
 514
 515         return ret;
 516 }
 517
 518 int _media_db_get_media_group_count(media_group_e group, filter_h filter, int *group_count)
 519 {
 520         int ret = MEDIA_CONTENT_ERROR_NONE;
 521         sqlite3_stmt *stmt = NULL;
 522         char *select_query = NULL;
 523         char *condition_query = NULL;
 524         char *option_query = NULL;
 525         filter_s *_filter = (filter_s *)filter;
 526
 527         if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 528                 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);
 529         else
 530                 select_query = g_strdup_printf(SELECT_MEDIA_GROUP_COUNT, __media_db_get_group_name(group), __media_db_get_group_name(group));
 531
 532         ret = __media_db_make_query(filter, &condition_query, &option_query);
 533         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 534                 g_free(select_query);
 535                 return ret;
 536         }
 537
 538         ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
 539         g_free(select_query);
 540         g_free(condition_query);
 541         g_free(option_query);
 542         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 543
 544         if (sqlite3_step(stmt) == SQLITE_ROW)
 545                 *group_count = sqlite3_column_int(stmt, 0);
 546
 547         SQLITE3_FINALIZE(stmt);
 548
 549         return ret;
 550 }
 551
 552 int _media_db_get_media_group(media_group_e group, filter_h filter, media_group_cb callback, void *user_data)
 553 {
 554         int ret = MEDIA_CONTENT_ERROR_NONE;
 555         char *select_query = NULL;
 556         char *condition_query = NULL;
 557         char *option_query = NULL;
 558         char *name = NULL;
 559         sqlite3_stmt *stmt = NULL;
 560         filter_s *_filter = (filter_s *)filter;
 561
 562         if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 563                 select_query = g_strdup_printf(SELECT_MEDIA_GROUP_LIST_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
 564         else
 565                 select_query = g_strdup_printf(SELECT_MEDIA_GROUP_LIST, __media_db_get_group_name(group));
 566
 567         ret = __media_db_make_query(filter, &condition_query, &option_query);
 568         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 569                 g_free(select_query);
 570                 return ret;
 571         }
 572
 573         ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
 574         g_free(select_query);
 575         g_free(condition_query);
 576         g_free(option_query);
 577         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 578
 579         while (sqlite3_step(stmt) == SQLITE_ROW) {
 580                 name = g_strdup((const char *)sqlite3_column_text(stmt, 0));
 581
 582                 if (callback(name, user_data) == false) {
 583                         SAFE_FREE(name);
 584                         break;
 585                 }
 586
 587                 SAFE_FREE(name);
 588         }
 589
 590         SQLITE3_FINALIZE(stmt);
 591
 592         return ret;
 593 }
 594 #endif
 595
 596 int _media_db_get_album(filter_h filter, media_album_cb callback, void *user_data)
 597 {
 598         int ret = MEDIA_CONTENT_ERROR_NONE;
 599         char select_query[MAX_QUERY_SIZE] = {0, };
 600         char *condition_query = NULL;
 601         char *option_query = NULL;
 602         sqlite3_stmt *stmt = NULL;
 603         filter_s *_filter = (filter_s *)filter;
 604
 605 #ifdef _USE_TVPD_MODE
 606         if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 607                 snprintf(select_query, sizeof(select_query), SELECT_ALBUM_LIST, _filter->storage_id);
 608         else
 609                 snprintf(select_query, sizeof(select_query), SELECT_ALBUM_LIST, DB_VIEW_MEDIA);
 610 #else
 611         if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 612                 snprintf(select_query, sizeof(select_query), SELECT_ALBUM_LIST_BY_STORAGE_ID, _filter->storage_id);
 613         else
 614                 snprintf(select_query, sizeof(select_query), SELECT_ALBUM_LIST);
 615 #endif
 616         ret = __media_db_make_query(filter, &condition_query, &option_query);
 617         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 618
 619         ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
 620         SAFE_FREE(condition_query);
 621         SAFE_FREE(option_query);
 622         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 623
 624         while (sqlite3_step(stmt) == SQLITE_ROW) {
 625                 media_album_s *album = (media_album_s*)calloc(1, sizeof(media_album_s));
 626
 627                 if (album == NULL) {
 628                         content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 629                         SQLITE3_FINALIZE(stmt);
 630                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 631                 }
 632
 633                 album->album_id = sqlite3_column_int(stmt, 0);
 634                 album->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
 635                 album->artist = g_strdup((const char *)sqlite3_column_text(stmt, 2));
 636                 album->album_art_path = g_strdup((const char *)sqlite3_column_text(stmt, 3));
 637
 638                 if (callback((media_album_h)album, user_data) == false) {
 639                         media_album_destroy((media_album_h)album);
 640                         break;
 641                 }
 642
 643                 media_album_destroy((media_album_h)album);
 644         }
 645
 646         SQLITE3_FINALIZE(stmt);
 647
 648         return ret;
 649 }
 650
 651 int _media_db_get_folder(filter_h filter, media_folder_cb callback, void *user_data)
 652 {
 653         int ret = MEDIA_CONTENT_ERROR_NONE;
 654         char select_query[MAX_QUERY_SIZE] = {0, };
 655         char *condition_query = NULL;
 656         char *option_query = NULL;
 657         sqlite3_stmt *stmt = NULL;
 658         filter_s *_filter = (filter_s *)filter;
 659
 660 #ifdef _USE_TVPD_MODE
 661         if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 662                 snprintf(select_query, sizeof(select_query), SELECT_FOLDER_LIST_BY_STORAGE_ID, _filter->storage_id, _filter->storage_id);
 663         else
 664                 snprintf(select_query, sizeof(select_query), SELECT_FOLDER_LIST, DB_VIEW_MEDIA);
 665 #else
 666         if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 667                 snprintf(select_query, sizeof(select_query), SELECT_FOLDER_LIST_BY_STORAGE_ID, _filter->storage_id);
 668         else
 669                 snprintf(select_query, sizeof(select_query), SELECT_FOLDER_LIST);
 670 #endif
 671         ret = __media_db_make_query(filter, &condition_query, &option_query);
 672         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 673
 674         ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
 675         SAFE_FREE(condition_query);
 676         SAFE_FREE(option_query);
 677         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 678
 679         while (sqlite3_step(stmt) == SQLITE_ROW) {
 680                 media_folder_s *_folder = (media_folder_s*)calloc(1, sizeof(media_folder_s));
 681
 682                 if (_folder == NULL) {
 683                         content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 684                         SQLITE3_FINALIZE(stmt);
 685                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 686                 }
 687
 688                 _folder->folder_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
 689                 _folder->path = g_strdup((const char *)sqlite3_column_text(stmt, 1));
 690                 _folder->name = g_strdup((const char *)sqlite3_column_text(stmt, 2));
 691                 _folder->storage_type = sqlite3_column_int(stmt, 3);
 692                 _folder->storage_uuid = g_strdup((const char *)sqlite3_column_text(stmt, 4));
 693
 694                 if (callback((media_folder_h)_folder, user_data) == false) {
 695                         media_folder_destroy((media_folder_h) _folder);
 696                         break;
 697                 }
 698
 699                 media_folder_destroy((media_folder_h) _folder);
 700         }
 701
 702         SQLITE3_FINALIZE(stmt);
 703
 704         return ret;
 705 }
 706
 707 int _media_db_get_playlist(filter_h filter, media_playlist_cb callback, void *user_data)
 708 {
 709         int ret = MEDIA_CONTENT_ERROR_NONE;
 710         char *condition_query = NULL;
 711         char *option_query = NULL;
 712         sqlite3_stmt *stmt = NULL;
 713
 714         ret = __media_db_make_query(filter, &condition_query, &option_query);
 715         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 716
 717         ret = _content_query_prepare(SELECT_PLAYLIST_LIST, condition_query, option_query, &stmt);
 718         SAFE_FREE(condition_query);
 719         SAFE_FREE(option_query);
 720         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 721
 722         while (sqlite3_step(stmt) == SQLITE_ROW) {
 723                 media_playlist_s *_playlist = (media_playlist_s*)calloc(1, sizeof(media_playlist_s));
 724
 725                 if (_playlist == NULL) {
 726                         content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 727                         SQLITE3_FINALIZE(stmt);
 728                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 729                 }
 730
 731                 _playlist->playlist_id = sqlite3_column_int(stmt, 0);
 732                 _playlist->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
 733                 _playlist->thumbnail_path = g_strdup((const char *)sqlite3_column_text(stmt, 2));
 734
 735                 if (callback((media_playlist_h)_playlist, user_data) == false) {
 736                         media_playlist_destroy((media_playlist_h)_playlist);
 737                         break;
 738                 }
 739                 media_playlist_destroy((media_playlist_h)_playlist);
 740         }
 741
 742         SQLITE3_FINALIZE(stmt);
 743
 744         return ret;
 745 }
 746
 747 int _media_db_get_playlist_item(int playlist_id, filter_h filter, playlist_member_cb callback, void *user_data)
 748 {
 749         int ret = MEDIA_CONTENT_ERROR_NONE;
 750         char *select_query = NULL;
 751         char *condition_query = NULL;
 752         char *option_query = NULL;
 753         sqlite3_stmt *stmt = NULL;
 754
 755         select_query = g_strdup_printf(SELECT_PLAYLIST_ITEM_ALL_FROM_PLAYLIST_VIEW, playlist_id);
 756
 757         ret = __media_db_make_query(filter, &condition_query, &option_query);
 758         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 759                 g_free(select_query);
 760                 return ret;
 761         }
 762
 763         ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
 764         g_free(select_query);
 765         g_free(condition_query);
 766         g_free(option_query);
 767         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 768
 769         while (sqlite3_step(stmt) == SQLITE_ROW) {
 770                 int playlist_member_id = 0;
 771                 playlist_member_id = sqlite3_column_int(stmt, MEDIA_INFO_ITEM_MAX);     /*MEDIA_INFO_ITEM_MAX is pm_id*/
 772
 773                 media_info_s *_media = (media_info_s*)calloc(1, sizeof(media_info_s));
 774
 775                 if (_media == NULL) {
 776                         content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 777                         SQLITE3_FINALIZE(stmt);
 778                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 779                 }
 780
 781                 _media_info_item_get_detail(stmt, (media_info_h)_media);
 782
 783                 if (callback(playlist_member_id, (media_info_h)_media, user_data) == false) {
 784                         media_info_destroy((media_info_h)_media);
 785                         break;
 786                 }
 787                 media_info_destroy((media_info_h)_media);
 788
 789         }
 790
 791         SQLITE3_FINALIZE(stmt);
 792
 793         return ret;
 794 }
 795
 796 int _media_db_get_tag(const char *media_id, filter_h filter, media_tag_cb callback, void *user_data)
 797 {
 798         int ret = MEDIA_CONTENT_ERROR_NONE;
 799         char *select_query = NULL;
 800         char *condition_query = NULL;
 801         char *option_query = NULL;
 802         sqlite3_stmt *stmt = NULL;
 803
 804         if (STRING_VALID(media_id))
 805                 select_query = g_strdup_printf(SELECT_TAG_LIST_BY_MEDIA_ID, media_id);
 806         else
 807                 select_query = g_strdup(SELECT_TAG_LIST);
 808
 809         ret = __media_db_make_query(filter, &condition_query, &option_query);
 810         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 811                 g_free(select_query);
 812                 return ret;
 813         }
 814
 815         ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
 816         g_free(select_query);
 817         g_free(condition_query);
 818         g_free(option_query);
 819         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 820
 821         while (sqlite3_step(stmt) == SQLITE_ROW) {
 822                 media_tag_s *_tag = (media_tag_s*)calloc(1, sizeof(media_tag_s));
 823
 824                 if (_tag == NULL) {
 825                         content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 826                         SQLITE3_FINALIZE(stmt);
 827                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 828                 }
 829
 830                 _tag->tag_id = sqlite3_column_int(stmt, 0);
 831                 _tag->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
 832
 833                 if (callback((media_tag_h)_tag, user_data) == false) {
 834                         media_tag_destroy((media_tag_h)_tag);
 835                         break;
 836                 }
 837                 media_tag_destroy((media_tag_h)_tag);
 838         }
 839
 840         SQLITE3_FINALIZE(stmt);
 841
 842         return ret;
 843 }
 844
 845 int _media_db_get_bookmark(const char *media_id, filter_h filter, media_bookmark_cb callback, void *user_data)
 846 {
 847         int ret = MEDIA_CONTENT_ERROR_NONE;
 848         char select_query[MAX_QUERY_SIZE] = {0, };
 849         char *condition_query = NULL;
 850         char *option_query = NULL;
 851         sqlite3_stmt *stmt = NULL;
 852         filter_s *_filter = (filter_s *)filter;
 853
 854 #ifdef _USE_TVPD_MODE
 855         if (STRING_VALID(media_id)) {   //get bookmark by media_id
 856                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 857                         snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST_BY_MEDIA_ID, _filter->storage_id, media_id);
 858                 else
 859                         snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST_BY_MEDIA_ID, DB_VIEW_MEDIA, media_id);
 860         } else {
 861                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 862                         snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST, _filter->storage_id);
 863                 else
 864                         snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST, DB_VIEW_MEDIA);
 865         }
 866 #else
 867         if (STRING_VALID(media_id)) {   //get bookmark by media_id
 868                 snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST_BY_MEDIA_ID, media_id);
 869         } else {
 870                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 871                         snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST_BY_STORAGE_ID, _filter->storage_id);
 872                 else
 873                         snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST);
 874         }
 875 #endif
 876
 877         ret = __media_db_make_query(filter, &condition_query, &option_query);
 878         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 879
 880         ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
 881         SAFE_FREE(condition_query);
 882         SAFE_FREE(option_query);
 883         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 884
 885         while (sqlite3_step(stmt) == SQLITE_ROW) {
 886                 media_bookmark_s *bookmark = (media_bookmark_s*)calloc(1, sizeof(media_bookmark_s));
 887
 888                 if (bookmark == NULL) {
 889                         content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 890                         SQLITE3_FINALIZE(stmt);
 891                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 892                 }
 893
 894                 bookmark->bookmark_id = sqlite3_column_int(stmt, 0);
 895                 bookmark->media_id = g_strdup((const char *)sqlite3_column_text(stmt, 1));
 896                 bookmark->marked_time = sqlite3_column_int(stmt, 2);
 897                 bookmark->thumbnail_path = g_strdup((const char *)sqlite3_column_text(stmt, 3));
 898                 bookmark->name = g_strdup((const char *)sqlite3_column_text(stmt, 4));
 899
 900                 if (callback((media_bookmark_h)bookmark, user_data) == false) {
 901                         media_bookmark_destroy((media_bookmark_h)bookmark);
 902                         break;
 903                 }
 904
 905                 media_bookmark_destroy((media_bookmark_h)bookmark);
 906         }
 907
 908         SQLITE3_FINALIZE(stmt);
 909
 910         return ret;
 911
 912 }
 913
 914 int _media_db_get_face(const char *media_id, filter_h filter, media_face_cb callback, void *user_data)
 915 {
 916         int ret = MEDIA_CONTENT_ERROR_NONE;
 917         char select_query[MAX_QUERY_SIZE] = {0, };
 918         char *condition_query = NULL;
 919         char *option_query = NULL;
 920         sqlite3_stmt *stmt = NULL;
 921         filter_s *_filter = (filter_s *)filter;
 922
 923 #ifdef _USE_TVPD_MODE
 924         if (STRING_VALID(media_id)) {   //get face by media_id
 925                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 926                         snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST_BY_MEDIA_ID, _filter->storage_id, media_id);
 927                 else
 928                         snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST_BY_MEDIA_ID, DB_VIEW_MEDIA, media_id);
 929         } else {
 930                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 931                         snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST, _filter->storage_id);
 932                 else
 933                         snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST, DB_VIEW_MEDIA);
 934         }
 935 #else
 936         if (STRING_VALID(media_id)) {   //get face by media_id
 937                 snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST_BY_MEDIA_ID, media_id);
 938         } else {
 939                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 940                         snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST_BY_STORAGE_ID, _filter->storage_id);
 941                 else
 942                         snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST);
 943         }
 944 #endif
 945         ret = __media_db_make_query(filter, &condition_query, &option_query);
 946         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 947
 948         ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
 949         SAFE_FREE(condition_query);
 950         SAFE_FREE(option_query);
 951         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 952
 953         while (sqlite3_step(stmt) == SQLITE_ROW) {
 954                 media_face_s *face = (media_face_s*)calloc(1, sizeof(media_face_s));
 955
 956                 if (face == NULL) {
 957                         content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 958                         SQLITE3_FINALIZE(stmt);
 959                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 960                 }
 961
 962                 face->face_id = sqlite3_column_int(stmt, 0);
 963                 face->media_id = g_strdup((const char *)sqlite3_column_text(stmt, 1));
 964                 face->face_rect_x = sqlite3_column_int(stmt, 2);
 965                 face->face_rect_y = sqlite3_column_int(stmt, 3);
 966                 face->face_rect_w = sqlite3_column_int(stmt, 4);
 967                 face->face_rect_h = sqlite3_column_int(stmt, 5);
 968                 face->orientation = sqlite3_column_int(stmt, 6);
 969                 face->face_tag = g_strdup((const char *)sqlite3_column_text(stmt, 7));
 970
 971                 if (callback((media_face_h)face, user_data) == false) {
 972                         media_face_destroy((media_face_h)face);
 973                         break;
 974                 }
 975
 976                 media_face_destroy((media_face_h)face);
 977         }
 978
 979         SQLITE3_FINALIZE(stmt);
 980
 981         return ret;
 982
 983 }
 984
 985 int _media_db_get_group_item_count_by_id(int group_id, filter_h filter, group_list_e group_type, int *item_count)
 986 {
 987         int ret = MEDIA_CONTENT_ERROR_NONE;
 988         sqlite3_stmt *stmt = NULL;
 989         char select_query[MAX_QUERY_SIZE] = {0, };
 990         char *condition_query = NULL;
 991         char *option_query = NULL;
 992         filter_s *_filter = (filter_s *)filter;
 993
 994         switch (group_type) {
 995         case MEDIA_GROUP_ALBUM:
 996 #ifdef _USE_TVPD_MODE
 997                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
 998                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_ALBUM, _filter->storage_id, group_id);
 999                 else
1000                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_ALBUM, DB_VIEW_MEDIA, group_id);
1001 #else
1002                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1003                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_ALBUM_BY_STORAGE_ID, group_id, _filter->storage_id);
1004                 else
1005                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_ALBUM, group_id);
1006 #endif
1007                 break;
1008
1009         case MEDIA_GROUP_PLAYLIST:
1010                 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_PLAYLIST, group_id);
1011                 break;
1012
1013         case MEDIA_GROUP_TAG:
1014                 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_TAG, group_id);
1015                 break;
1016
1017         default:
1018                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1019                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1020         }
1021
1022         ret = __media_db_make_query(filter, &condition_query, &option_query);
1023         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1024
1025         ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1026         SAFE_FREE(condition_query);
1027         SAFE_FREE(option_query);
1028         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1029
1030         if (sqlite3_step(stmt) == SQLITE_ROW)
1031                 *item_count = sqlite3_column_int(stmt, 0);
1032
1033         SQLITE3_FINALIZE(stmt);
1034
1035         return ret;
1036 }
1037
1038 int _media_db_get_group_item_count(const char *group_name, filter_h filter, group_list_e group_type, int *item_count)
1039 {
1040         int ret = MEDIA_CONTENT_ERROR_NONE;
1041         sqlite3_stmt *stmt = NULL;
1042         char select_query[MAX_QUERY_SIZE] = {0, };
1043         char *condition_query = NULL;
1044         char *option_query = NULL;
1045         char *tmp_option = NULL;
1046         bool need_bracket = false;
1047         filter_s *_filter = (filter_s *)filter;
1048
1049         switch (group_type) {
1050         case MEDIA_GROUP_NONE:
1051                 if (!_filter) {
1052 #ifdef _USE_TVPD_MODE
1053                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE, DB_VIEW_MEDIA);
1054 #else
1055                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE);
1056 #endif
1057                         break;
1058                 }
1059
1060                 if (_filter->offset < 0 && _filter->count < 0) {
1061 #ifdef _USE_TVPD_MODE
1062                         if (STRING_VALID(_filter->storage_id))
1063                                 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE, _filter->storage_id);
1064                         else
1065                                 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE, DB_VIEW_MEDIA);
1066 #else
1067                         if (STRING_VALID(_filter->storage_id))
1068                                 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE_BY_STORAGE_ID, _filter->storage_id);
1069                         else
1070                                 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE);
1071 #endif
1072                 } else {
1073 #ifdef _USE_TVPD_MODE
1074                         if (STRING_VALID(_filter->storage_id))
1075                                 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA, _filter->storage_id);
1076                         else
1077                                 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA, DB_VIEW_MEDIA);
1078 #else
1079                         if (STRING_VALID(_filter->storage_id))
1080                                 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_BY_STORAGE_ID, _filter->storage_id);
1081                         else
1082                                 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA);
1083
1084 #endif
1085                         need_bracket = true;
1086                 }
1087                 break;
1088
1089         case MEDIA_GROUP_FOLDER:
1090 #ifdef _USE_TVPD_MODE
1091                 if (_filter && STRING_VALID(_filter->storage_id))
1092                         sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_FOLDER, _filter->storage_id, group_name);
1093                 else
1094                         sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
1095 #else
1096                 if (_filter && STRING_VALID(_filter->storage_id))
1097                         sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_FOLDER_BY_STORAGE_ID, group_name, _filter->storage_id);
1098                 else
1099                         sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_FOLDER, group_name);
1100 #endif
1101                 break;
1102
1103         case MEDIA_GROUP_TAG_BY_MEDIA_ID:
1104                 snprintf(select_query, sizeof(select_query), SELECT_TAG_COUNT_BY_MEDIA_ID, group_name);
1105                 break;
1106
1107         case MEDIA_GROUP_BOOKMARK_BY_MEDIA_ID:
1108 #ifdef _USE_TVPD_MODE
1109                 if (_filter && STRING_VALID(_filter->storage_id))
1110                         sqlite3_snprintf(sizeof(select_query), select_query, SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, _filter->storage_id, group_name);
1111                 else
1112                         sqlite3_snprintf(sizeof(select_query), select_query, SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, DB_VIEW_MEDIA, group_name);
1113 #else
1114                 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, group_name);
1115 #endif
1116                 break;
1117
1118         case MEDIA_GROUP_STORAGE:
1119 #ifdef _USE_TVPD_MODE
1120                 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_STORAGE, group_name, group_name);
1121 #else
1122                 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_STORAGE, group_name);
1123 #endif
1124                 break;
1125
1126         case MEDIA_GROUP_FACE_BY_MEDIA_ID:
1127 #ifdef _USE_TVPD_MODE
1128                 if (_filter && STRING_VALID(_filter->storage_id))
1129                         sqlite3_snprintf(sizeof(select_query), select_query, SELECT_FACE_COUNT_BY_MEDIA_ID, _filter->storage_id, group_name);
1130                 else
1131                         sqlite3_snprintf(sizeof(select_query), select_query, SELECT_FACE_COUNT_BY_MEDIA_ID, DB_VIEW_MEDIA, group_name);
1132 #else
1133                 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_FACE_COUNT_BY_MEDIA_ID, group_name);
1134 #endif
1135                 break;
1136
1137 #ifdef _USE_TVPD_MODE
1138         case MEDIA_GROUP_PVR:
1139                 if (_filter && STRING_VALID(_filter->storage_id))
1140                         snprintf(select_query, sizeof(select_query), SELECT_PVR_COUNT_BY_STORAGE_ID, _filter->storage_id);
1141                 else
1142                         SAFE_STRLCPY(select_query, SELECT_PVR_COUNT, sizeof(select_query));
1143                 break;
1144
1145         case MEDIA_GROUP_UHD:
1146                 if (_filter && STRING_VALID(_filter->storage_id))
1147                         snprintf(select_query, sizeof(select_query), SELECT_UHD_COUNT_BY_STORAGE_ID, _filter->storage_id);
1148                 else
1149                         SAFE_STRLCPY(select_query, SELECT_UHD_COUNT, sizeof(select_query));
1150                 break;
1151 #endif
1152         default:
1153                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1154                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1155         }
1156
1157         ret = __media_db_make_query(filter, &condition_query, &option_query);
1158         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1159
1160         if (need_bracket) {
1161                 tmp_option = g_strconcat(option_query, ")", NULL);
1162                 g_free(option_query);
1163                 option_query = tmp_option;
1164         }
1165
1166         ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1167         SAFE_FREE(condition_query);
1168         SAFE_FREE(option_query);
1169         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1170
1171         if (sqlite3_step(stmt) == SQLITE_ROW)
1172                 *item_count = sqlite3_column_int(stmt, 0);
1173
1174         SQLITE3_FINALIZE(stmt);
1175
1176         return ret;
1177 }
1178
1179 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)
1180 {
1181         int ret = MEDIA_CONTENT_ERROR_NONE;
1182         char select_query[MAX_QUERY_SIZE] = {0, };
1183         char *condition_query = NULL;
1184         char *option_query = NULL;
1185         sqlite3_stmt *stmt = NULL;
1186         filter_s *_filter = (filter_s *)filter;
1187
1188         switch (group_type) {
1189         case MEDIA_GROUP_ALBUM:
1190 #ifdef _USE_TVPD_MODE
1191                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1192                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_ALBUM, _filter->storage_id, group_id);
1193                 else
1194                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_ALBUM, DB_VIEW_MEDIA, group_id);
1195 #else
1196                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1197                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_ALBUM_BY_STORAGE_ID, group_id, _filter->storage_id);
1198                 else
1199                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_ALBUM, group_id);
1200 #endif
1201                 break;
1202
1203         case MEDIA_GROUP_PLAYLIST:
1204 #ifdef _USE_TVPD_MODE
1205                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1206                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_PLAYLIST, _filter->storage_id, group_id);
1207                 else
1208                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_PLAYLIST, DB_VIEW_MEDIA, group_id);
1209 #else
1210                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1211                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_PLAYLIST_BY_STORAGE_ID, group_id, _filter->storage_id);
1212                 else
1213                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_PLAYLIST, group_id);
1214 #endif
1215                 break;
1216
1217         case MEDIA_GROUP_TAG:
1218 #ifdef _USE_TVPD_MODE
1219                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1220                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_TAG, _filter->storage_id, group_id);
1221                 else
1222                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_TAG, DB_VIEW_MEDIA, group_id);
1223 #else
1224                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1225                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_TAG_BY_STORAGE_ID, group_id, _filter->storage_id);
1226                 else
1227                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_TAG, group_id);
1228 #endif
1229                 break;
1230
1231         default:
1232                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1233                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1234         }
1235
1236         ret = __media_db_make_query(filter, &condition_query, &option_query);
1237         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1238
1239         ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1240         SAFE_FREE(condition_query);
1241         SAFE_FREE(option_query);
1242         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1243
1244         while (sqlite3_step(stmt) == SQLITE_ROW) {
1245                 media_info_s *item = (media_info_s*)calloc(1, sizeof(media_info_s));
1246                 if (item == NULL) {
1247                         content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1248                         SQLITE3_FINALIZE(stmt);
1249                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1250                 }
1251
1252                 _media_info_item_get_detail(stmt, (media_info_h)item);
1253
1254                 if (callback((media_info_h)item, user_data) == false) {
1255                         media_info_destroy((media_info_h)item);
1256                         break;
1257                 }
1258
1259                 media_info_destroy((media_info_h)item);
1260         }
1261
1262         SQLITE3_FINALIZE(stmt);
1263
1264         return ret;
1265 }
1266
1267 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)
1268 {
1269         int ret = MEDIA_CONTENT_ERROR_NONE;
1270         char select_query[MAX_QUERY_SIZE] = {0, };
1271         char *condition_query = NULL;
1272         char *option_query = NULL;
1273         sqlite3_stmt *stmt = NULL;
1274         filter_s *_filter = (filter_s *)filter;
1275
1276         switch (group_type) {
1277         case MEDIA_GROUP_NONE:
1278 #ifdef _USE_TVPD_MODE
1279                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1280                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_ITEM, _filter->storage_id);
1281                 else
1282                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_ITEM, DB_VIEW_MEDIA);
1283 #else
1284                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1285                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_ITEM_BY_STORAGE_ID, _filter->storage_id);
1286                 else
1287                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_ITEM);
1288 #endif
1289                 break;
1290
1291         case MEDIA_GROUP_FOLDER:
1292 #ifdef _USE_TVPD_MODE
1293                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1294                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_FOLDER, _filter->storage_id, group_name);
1295                 else
1296                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
1297 #else
1298                 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_FOLDER, group_name);
1299 #endif
1300                 break;
1301
1302         case MEDIA_GROUP_STORAGE:
1303 #ifdef _USE_TVPD_MODE
1304                 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_STORAGE, group_name, group_name);
1305 #else
1306                 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_STORAGE, group_name);
1307 #endif
1308                 break;
1309
1310         default:
1311                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1312                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1313         }
1314
1315         ret = __media_db_make_query(filter, &condition_query, &option_query);
1316         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1317
1318         ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1319         SAFE_FREE(condition_query);
1320         SAFE_FREE(option_query);
1321         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1322
1323         while (sqlite3_step(stmt) == SQLITE_ROW) {
1324                 media_info_s *item = (media_info_s*)calloc(1, sizeof(media_info_s));
1325                 if (item == NULL) {
1326                         content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1327                         SQLITE3_FINALIZE(stmt);
1328                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1329                 }
1330
1331                 _media_info_item_get_detail(stmt, (media_info_h)item);
1332
1333                 if (callback((media_info_h)item, user_data) == false) {
1334                         media_info_destroy((media_info_h)item);
1335                         break;
1336                 }
1337
1338                 media_info_destroy((media_info_h)item);
1339         }
1340
1341         SQLITE3_FINALIZE(stmt);
1342
1343         return ret;
1344 }
1345
1346 #ifdef _USE_SENIOR_MODE
1347 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)
1348 {
1349         int ret = MEDIA_CONTENT_ERROR_NONE;
1350         char select_query1[MAX_QUERY_SIZE] = {0, };
1351         char *condition_query1 = NULL;
1352         char *option_query1 = NULL;
1353         char select_query2[MAX_QUERY_SIZE] = {0, };
1354         char *condition_query2 = NULL;
1355         char *option_query2 = NULL;
1356         sqlite3_stmt *stmt = NULL;
1357         filter_s *_filter1 = (filter_s *)filter1;
1358         filter_s *_filter2 = (filter_s *)filter2;
1359
1360         if ((_filter1 != NULL) && STRING_VALID(_filter1->storage_id))
1361                 snprintf(select_query1, sizeof(select_query1), SELECT_MEDIA_FROM_FOLDER, _filter1->storage_id, group_name);
1362         else
1363                 snprintf(select_query1, sizeof(select_query1), SELECT_MEDIA_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
1364
1365         ret = __media_db_make_query(filter, &condition_query, &option_query);
1366         if (ret != MEDIA_CONTENT_ERROR_NONE) {
1367                 SAFE_FREE(condition_query1);
1368                 SAFE_FREE(option_query1);
1369                 content_error("create select_query1 failed");
1370                 return ret;
1371         }
1372
1373         if ((_filter2 != NULL) && STRING_VALID(_filter2->storage_id))
1374                 snprintf(select_query2, sizeof(select_query2), SELECT_MEDIA_FROM_FOLDER, _filter2->storage_id, group_name);
1375         else
1376                 snprintf(select_query2, sizeof(select_query2), SELECT_MEDIA_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
1377
1378         ret = __media_db_make_query(filter, &condition_query, &option_query);
1379         if (ret != MEDIA_CONTENT_ERROR_NONE) {
1380                 SAFE_FREE(condition_query1);
1381                 SAFE_FREE(option_query1);
1382                 SAFE_FREE(condition_query2);
1383                 SAFE_FREE(option_query2);
1384                 content_error("create select_query2 failed");
1385                 return ret;
1386         }
1387
1388         ret = _content_query_prepare_by_union_select(&stmt, select_query1, condition_query1, option_query1, select_query2, condition_query2, option_query2);
1389         SAFE_FREE(condition_query1);
1390         SAFE_FREE(option_query1);
1391         SAFE_FREE(condition_query2);
1392         SAFE_FREE(option_query2);
1393         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1394
1395         while (sqlite3_step(stmt) == SQLITE_ROW) {
1396                 media_info_s *item = (media_info_s*)calloc(1, sizeof(media_info_s));
1397                 if (item == NULL) {
1398                         content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1399                         SQLITE3_FINALIZE(stmt);
1400                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1401                 }
1402
1403                 _media_info_item_get_detail(stmt, (media_info_h)item);
1404
1405                 if (callback((media_info_h)item, user_data) == false) {
1406                         media_info_destroy((media_info_h)item);
1407                         break;
1408                 }
1409
1410                 media_info_destroy((media_info_h)item);
1411         }
1412
1413         SQLITE3_FINALIZE(stmt);
1414
1415         return ret;
1416 }
1417 #endif
1418
1419 int _media_db_get_media_group_item_count(const char *group_name, filter_h filter, media_group_e group, int *item_count)
1420 {
1421         int ret = MEDIA_CONTENT_ERROR_NONE;
1422         sqlite3_stmt *stmt = NULL;
1423         char select_query[MAX_QUERY_SIZE] = {0, };
1424         char *tmp_option = NULL;
1425         char *condition_query = NULL;
1426         char *option_query = NULL;
1427         filter_s *_filter = (filter_s *)filter;
1428
1429 #ifdef _USE_TVPD_MODE
1430         if (group < MEDIA_PVR_GROUP_DURATION) { /*media content */
1431                 if (group_name != NULL) {
1432                         if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1433                                 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_GROUP, _filter->storage_id, __media_db_get_group_name(group), group_name);
1434                         else
1435                                 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_GROUP, DB_VIEW_MEDIA, __media_db_get_group_name(group), group_name);
1436                 } else {
1437                         if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1438                                 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL, _filter->storage_id, __media_db_get_group_name(group));
1439                         else
1440                                 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL, DB_VIEW_MEDIA, __media_db_get_group_name(group));
1441                 }
1442         } else if (group < MEDIA_UHD_GROUP_CONTENT_TITLE) {/*pvr content*/
1443                 if (group_name != NULL) {
1444                         if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1445                                 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);
1446                         else
1447                                 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_PVR_COUNT_FROM_GROUP, __media_db_get_group_name(group), group_name);
1448                 } else {
1449                         if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1450                                 snprintf(select_query, sizeof(select_query), SELECT_PVR_COUNT_FROM_GROUP_NULL_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group));
1451                         else
1452                                 snprintf(select_query, sizeof(select_query), SELECT_PVR_COUNT_FROM_GROUP_NULL, __media_db_get_group_name(group));
1453                 }
1454         } else {/*uhd content*/
1455                 if (group_name != NULL) {
1456                         if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1457                                 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);
1458                         else
1459                                 sqlite3_snprintf(sizeof(select_query), select_query, SELECT_UHD_COUNT_FROM_GROUP, __media_db_get_group_name(group), group_name);
1460                 } else {
1461                         if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1462                                 snprintf(select_query, sizeof(select_query), SELECT_UHD_COUNT_FROM_GROUP_NULL_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group));
1463                         else
1464                                 snprintf(select_query, sizeof(select_query), SELECT_UHD_COUNT_FROM_GROUP_NULL, __media_db_get_group_name(group));
1465                 }
1466         }
1467 #else
1468         if (group_name != NULL) {
1469                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1470                         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);
1471                 else
1472                         sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_GROUP, __media_db_get_group_name(group), group_name);
1473         } else {
1474                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1475                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
1476                 else
1477                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL, __media_db_get_group_name(group));
1478         }
1479 #endif
1480         ret = __media_db_make_query(filter, &condition_query, &option_query);
1481         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1482
1483         /* If 'filter' is not NULL, 'option_query' must be created. */
1484         if (option_query) {
1485                 tmp_option = g_strconcat(option_query, ")", NULL);
1486                 g_free(option_query);
1487                 option_query = tmp_option;
1488         } else {
1489                 SAFE_STRLCAT(select_query, ")", sizeof(select_query));
1490         }
1491
1492         ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1493         SAFE_FREE(condition_query);
1494         SAFE_FREE(option_query);
1495         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1496
1497         if (sqlite3_step(stmt) == SQLITE_ROW)
1498                 *item_count = sqlite3_column_int(stmt, 0);
1499
1500         SQLITE3_FINALIZE(stmt);
1501
1502         return ret;
1503 }
1504
1505 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)
1506 {
1507         int ret = MEDIA_CONTENT_ERROR_NONE;
1508         char select_query[MAX_QUERY_SIZE] = {0, };
1509         char *condition_query = NULL;
1510         char *option_query = NULL;
1511         sqlite3_stmt *stmt = NULL;
1512         filter_s *_filter = (filter_s *)filter;
1513
1514 #ifdef _USE_TVPD_MODE
1515         if (group_name != NULL) {
1516                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1517                         sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_FROM_GROUP, _filter->storage_id, __media_db_get_group_name(group), group_name);
1518                 else
1519                         sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_FROM_GROUP, DB_VIEW_MEDIA, __media_db_get_group_name(group), group_name);
1520         } else {
1521                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1522                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL, _filter->storage_id, __media_db_get_group_name(group));
1523                 else
1524                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL, DB_VIEW_MEDIA, __media_db_get_group_name(group));
1525         }
1526 #else
1527         if (group_name != NULL) {
1528                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1529                         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);
1530                 else
1531                         sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_FROM_GROUP, __media_db_get_group_name(group), group_name);
1532         } else {
1533                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1534                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
1535                 else
1536                         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL, __media_db_get_group_name(group));
1537         }
1538 #endif
1539         ret = __media_db_make_query(filter, &condition_query, &option_query);
1540         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1541
1542         ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1543         SAFE_FREE(condition_query);
1544         SAFE_FREE(option_query);
1545         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1546
1547         while (sqlite3_step(stmt) == SQLITE_ROW) {
1548                 media_info_s *item = (media_info_s*)calloc(1, sizeof(media_info_s));
1549                 if (item == NULL) {
1550                         content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1551                         SQLITE3_FINALIZE(stmt);
1552                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1553                 }
1554
1555                 _media_info_item_get_detail(stmt, (media_info_h)item);
1556
1557                 if (callback((media_info_h)item, user_data) == false) {
1558                         media_info_destroy((media_info_h)item);
1559                         break;
1560                 }
1561
1562                 media_info_destroy((media_info_h)item);
1563         }
1564
1565         SQLITE3_FINALIZE(stmt);
1566
1567         return ret;
1568 }
1569
1570 int _media_db_get_storage(filter_h filter, media_storage_cb callback, void *user_data)
1571 {
1572         int ret = MEDIA_CONTENT_ERROR_NONE;
1573         char *condition_query = NULL;
1574         char *option_query = NULL;
1575         sqlite3_stmt *stmt = NULL;
1576
1577         ret = __media_db_make_query(filter, &condition_query, &option_query);
1578         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1579
1580         ret = _content_query_prepare(SELECT_STORAGE_LIST, condition_query, option_query, &stmt);
1581         SAFE_FREE(condition_query);
1582         SAFE_FREE(option_query);
1583         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1584
1585         while (sqlite3_step(stmt) == SQLITE_ROW) {
1586                 media_storage_s *_storage = (media_storage_s*)calloc(1, sizeof(media_storage_s));
1587
1588                 if (_storage == NULL) {
1589                         content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1590                         SQLITE3_FINALIZE(stmt);
1591                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1592                 }
1593
1594                 _storage->storage_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
1595                 _storage->storage_path = g_strdup((const char *)sqlite3_column_text(stmt, 1));
1596                 _storage->storage_type = sqlite3_column_int(stmt, 2);
1597
1598                 if (callback((media_storage_h)_storage, user_data) == false) {
1599                         media_storage_destroy((media_storage_h) _storage);
1600                         break;
1601                 }
1602
1603                 media_storage_destroy((media_storage_h) _storage);
1604         }
1605
1606         SQLITE3_FINALIZE(stmt);
1607
1608         return ret;
1609 }
1610
1611 int _media_db_get_storage_id_by_media_id(const char *media_id, char **storage_id)
1612 {
1613         int ret = MEDIA_CONTENT_ERROR_NONE;
1614         sqlite3_stmt *stmt = NULL;
1615         char *select_query = NULL;
1616
1617         select_query = sqlite3_mprintf(SELECT_MEDIA_STORAGE_ID_BY_ID, media_id);
1618
1619         ret = _content_get_result(select_query, &stmt);
1620         SQLITE3_SAFE_FREE(select_query);
1621         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1622
1623         if (sqlite3_step(stmt) == SQLITE_ROW) {
1624                 *storage_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
1625         } else {
1626                 content_error("Invalid media_id[%s]", media_id);
1627                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1628         }
1629
1630         SQLITE3_FINALIZE(stmt);
1631
1632         return ret;
1633 }
1634
1635 #ifdef _USE_TVPD_MODE
1636 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)
1637 {
1638         int ret = MEDIA_CONTENT_ERROR_NONE;
1639         char select_query[DEFAULT_QUERY_SIZE] = {0, };
1640         char *condition_query = NULL;
1641         char *option_query = NULL;
1642         sqlite3_stmt *stmt = NULL;
1643         filter_s *_filter = (filter_s *)filter;
1644
1645         if (group_name != NULL) {
1646                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1647                         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);
1648                 else
1649                         sqlite3_snprintf(sizeof(select_query), select_query, SELECT_PVR_FROM_GROUP, __media_db_get_group_name(group), group_name);
1650         } else {
1651                 if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1652                         snprintf(select_query, sizeof(select_query), SELECT_PVR_FROM_GROUP_NULL_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group));
1653                 else
1654                         snprintf(select_query, sizeof(select_query), SELECT_PVR_FROM_GROUP_NULL, __media_db_get_group_name(group));
1655         }
1656
1657         ret = __media_db_make_query(filter, &condition_query, &option_query);
1658         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1659
1660         ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1661         SAFE_FREE(condition_query);
1662         SAFE_FREE(option_query);
1663         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1664
1665         while (sqlite3_step(stmt) == SQLITE_ROW) {
1666                 media_pvr_s *item = (media_pvr_s*)calloc(1, sizeof(media_pvr_s));
1667                 if (item == NULL) {
1668                         content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1669                         SQLITE3_FINALIZE(stmt);
1670                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1671                 }
1672
1673                 _media_pvr_item_get_detail(stmt, (media_pvr_h)item);
1674
1675                 if (callback((media_pvr_h)item, user_data) == false) {
1676                         media_info_destroy((media_pvr_h)item);
1677                         break;
1678                 }
1679
1680                 media_pvr_destroy((media_pvr_h)item);
1681         }
1682
1683         SQLITE3_FINALIZE(stmt);
1684
1685         return ret;
1686 }
1687
1688 typedef enum {
1689         MEDIA_PVR_MEDIA_ID = 0,
1690         MEDIA_PVR_STORAGE_ID,
1691         MEDIA_PVR_PATH,
1692         MEDIA_PVR_SIZE,
1693         MEDIA_PVR_DURATION,
1694         MEDIA_PVR_TIME_ZONE,
1695         MEDIA_PVR_PTC,
1696         MEDIA_PVR_MAJOR,
1697         MEDIA_PVR_MINOR,
1698         MEDIA_PVR_CHANNEL_TYPE,
1699         MEDIA_PVR_CHANNEL_NAME,
1700         MEDIA_PVR_CHANNEL_NUM,
1701         MEDIA_PVR_SERVICE_PROFILE,
1702         MEDIA_PVR_PROGRAM_TITLE,
1703         MEDIA_PVR_PROGRAM_NUM,
1704         MEDIA_PVR_PROGRAM_CRID,
1705         MEDIA_PVR_GUIDANCE,
1706         MEDIA_PVR_SYNOPSIS,
1707         MEDIA_PVR_GENRE,
1708         MEDIA_PVR_LANGUAGE,
1709         MEDIA_PVR_EMBARGO_TIME,
1710         MEDIA_PVR_EXPIRY_TIME,
1711         MEDIA_PVR_START_TIME,
1712         MEDIA_PVR_PROGRAM_START_TIME,
1713         MEDIA_PVR_PROGRAM_END_TIME,
1714         MEDIA_PVR_PROGRAM_DATE,
1715         MEDIA_PVR_PARENTAL_RATING,
1716         MEDIA_PVR_TIMER_RECORD,
1717         MEDIA_PVR_SERIES_RECORD,
1718         MEDIA_PVR_HD,
1719         MEDIA_PVR_SUBTITLE,
1720         MEDIA_PVR_TTX,
1721         MEDIA_PVR_AD,
1722         MEDIA_PVR_HARDOF_HEARINGRADIO,
1723         MEDIA_PVR_DATA_SERVICE,
1724         MEDIA_PVR_CONTENT_LOCK,
1725         MEDIA_PVR_CONTENT_WATCH,
1726         MEDIA_PVR_HAS_AUDIO_ONLY,
1727         MEDIA_PVR_IS_LOCAL_RECORDED,
1728         MEDIA_PVR_RESOLUTION,
1729         MEDIA_PVR_ASPECTRATIO,
1730         MEDIA_PVR_MODIFIED_MONTH,
1731         MEDIA_PVR_SPORTS_TYPE,
1732         MEDIA_PVR_GUIDANCE_LENGTH,
1733         MEDIA_PVR_TVMODE,
1734         MEDIA_PVR_PLAY_COUNT,
1735         MEDIA_PVR_PRIVATE_DATA,
1736         MEDIA_PVR_HIGHLIGHT,
1737 } media_pvr_field_e;
1738
1739 void _media_pvr_item_get_detail(sqlite3_stmt* stmt, media_pvr_h pvr)
1740 {
1741         media_pvr_s *_pvr = (media_pvr_s*)pvr;
1742
1743         if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_MEDIA_ID)))
1744                 _pvr->media_id = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_MEDIA_ID));
1745
1746         if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_STORAGE_ID)))
1747                 _pvr->storage_id = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_STORAGE_ID));
1748
1749         if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PATH)))
1750                 _pvr->path = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PATH));
1751
1752         _pvr->size = (unsigned long long)sqlite3_column_int64(stmt, MEDIA_PVR_SIZE);
1753
1754         _pvr->duration = sqlite3_column_int(stmt, MEDIA_PVR_DURATION);
1755
1756         _pvr->timezone = sqlite3_column_int(stmt, MEDIA_PVR_TIME_ZONE);
1757
1758         _pvr->ptc = sqlite3_column_int(stmt, MEDIA_PVR_PTC);
1759
1760         _pvr->major = sqlite3_column_int(stmt, MEDIA_PVR_MAJOR);
1761
1762         _pvr->minor = sqlite3_column_int(stmt, MEDIA_PVR_MINOR);
1763
1764         _pvr->channel_type = sqlite3_column_int(stmt, MEDIA_PVR_CHANNEL_TYPE);
1765
1766         _pvr->service_profile = (unsigned int)sqlite3_column_int(stmt, MEDIA_PVR_SERVICE_PROFILE);
1767
1768         if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_CHANNEL_NAME)))
1769                 _pvr->channel_name = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_CHANNEL_NAME));
1770
1771         if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_CHANNEL_NUM)))
1772                 _pvr->channel_num = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_CHANNEL_NUM));
1773
1774         if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PROGRAM_TITLE)))
1775                 _pvr->program_title = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PROGRAM_TITLE));
1776
1777         _pvr->program_num = sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_NUM);
1778
1779         if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PROGRAM_CRID)))
1780                 _pvr->program_crid = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PROGRAM_CRID));
1781
1782         if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_GUIDANCE)))
1783                 _pvr->guidance = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_GUIDANCE));
1784
1785         if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_SYNOPSIS)))
1786                 _pvr->synopsis = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_SYNOPSIS));
1787
1788         if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_GENRE)))
1789                 _pvr->genre = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_GENRE));
1790
1791         if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_LANGUAGE)))
1792                 _pvr->language = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_LANGUAGE));
1793
1794         if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_MODIFIED_MONTH)))
1795                 _pvr->modified_month = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_MODIFIED_MONTH));
1796
1797         if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PRIVATE_DATA)))
1798                 _pvr->private_data = strdup((const char *)sqlite3_column_text(stmt, MEDIA_PVR_PRIVATE_DATA));
1799
1800         _pvr->embargo_time = sqlite3_column_int(stmt, MEDIA_PVR_EMBARGO_TIME);
1801
1802         _pvr->expiry_time = sqlite3_column_int(stmt, MEDIA_PVR_EXPIRY_TIME);
1803
1804         _pvr->start_time = sqlite3_column_int(stmt, MEDIA_PVR_START_TIME);
1805
1806         _pvr->program_start_time = sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_START_TIME);
1807
1808         _pvr->program_end_time = sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_END_TIME);
1809
1810         _pvr->program_date = sqlite3_column_int(stmt, MEDIA_PVR_PROGRAM_DATE);
1811
1812         _pvr->parental_rating = sqlite3_column_int(stmt, MEDIA_PVR_PARENTAL_RATING);
1813
1814         _pvr->timer_record = sqlite3_column_int(stmt, MEDIA_PVR_TIMER_RECORD);
1815
1816         _pvr->series_record = sqlite3_column_int(stmt, MEDIA_PVR_SERIES_RECORD);
1817
1818         _pvr->hd = sqlite3_column_int(stmt, MEDIA_PVR_HD);
1819
1820         _pvr->subtitle = sqlite3_column_int(stmt, MEDIA_PVR_SUBTITLE);
1821
1822         _pvr->ttx = sqlite3_column_int(stmt, MEDIA_PVR_TTX);
1823
1824         _pvr->ad = sqlite3_column_int(stmt, MEDIA_PVR_AD);
1825
1826         _pvr->hard_of_hearing_radio = sqlite3_column_int(stmt, MEDIA_PVR_HARDOF_HEARINGRADIO);
1827
1828         _pvr->data_service = sqlite3_column_int(stmt, MEDIA_PVR_DATA_SERVICE);
1829
1830         _pvr->content_lock = sqlite3_column_int(stmt, MEDIA_PVR_CONTENT_LOCK);
1831
1832         _pvr->content_watch = sqlite3_column_int(stmt, MEDIA_PVR_CONTENT_WATCH);
1833
1834         _pvr->has_audio_only = sqlite3_column_int(stmt, MEDIA_PVR_HAS_AUDIO_ONLY);
1835
1836         _pvr->is_local_record = sqlite3_column_int(stmt, MEDIA_PVR_IS_LOCAL_RECORDED);
1837
1838         _pvr->resolution = sqlite3_column_int(stmt, MEDIA_PVR_RESOLUTION);
1839
1840         _pvr->aspectratio = sqlite3_column_int(stmt, MEDIA_PVR_ASPECTRATIO);
1841
1842         _pvr->sports_type = sqlite3_column_int(stmt, MEDIA_PVR_SPORTS_TYPE);
1843
1844         _pvr->guidance_length = sqlite3_column_int(stmt, MEDIA_PVR_GUIDANCE_LENGTH);
1845
1846         _pvr->tvmode = sqlite3_column_int(stmt, MEDIA_PVR_TVMODE);
1847
1848         _pvr->play_count = sqlite3_column_int(stmt, MEDIA_PVR_PLAY_COUNT);
1849
1850         _pvr->highlight = sqlite3_column_int(stmt, MEDIA_PVR_HIGHLIGHT);
1851
1852         return;
1853 }
1854
1855 int _media_db_get_pvr(filter_h filter, media_pvr_cb callback, void *user_data)
1856 {
1857         int ret = MEDIA_CONTENT_ERROR_NONE;
1858         char select_query[DEFAULT_QUERY_SIZE] = {0, };
1859         char *condition_query = NULL;
1860         char *option_query = NULL;
1861         sqlite3_stmt *stmt = NULL;
1862         filter_s *_filter = (filter_s *)filter;
1863
1864         if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1865                 snprintf(select_query, sizeof(select_query), SELECT_PVR_LIST_BY_STORAGE_ID, _filter->storage_id);
1866         else
1867                 SAFE_STRLCAT(select_query, SELECT_PVR_LIST, sizeof(select_query));
1868
1869         ret = __media_db_make_query(filter, &condition_query, &option_query);
1870         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1871
1872         ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1873         SAFE_FREE(condition_query);
1874         SAFE_FREE(option_query);
1875         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1876
1877         while (sqlite3_step(stmt) == SQLITE_ROW) {
1878                 media_pvr_s *_pvr = (media_pvr_s*)calloc(1, sizeof(media_pvr_s));
1879
1880                 if (_pvr == NULL) {
1881                         content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1882                         SQLITE3_FINALIZE(stmt);
1883                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1884                 }
1885
1886                 _media_pvr_item_get_detail(stmt, (media_pvr_h)_pvr);
1887
1888                 if (callback((media_pvr_h)_pvr, user_data) == false) {
1889                         media_pvr_destroy((media_pvr_h) _pvr);
1890                         break;
1891                 }
1892
1893                 media_pvr_destroy((media_pvr_h) _pvr);
1894         }
1895
1896         SQLITE3_FINALIZE(stmt);
1897
1898         return ret;
1899 }
1900
1901 typedef enum {
1902         MEDIA_UHD_MEDIA_ID = 0,
1903         MEDIA_UHD_STORAGE_ID,
1904         MEDIA_UHD_PATH,
1905         MEDIA_UHD_SIZE,
1906         MEDIA_UHD_CONTENT_ID,
1907         MEDIA_UHD_CONTENT_TITLE,
1908         MEDIA_UHD_FILE_NAME,
1909         MEDIA_UHD_FOLDER_ID,
1910         MEDIA_UHD_RELEASE_DATE,
1911         MEDIA_UHD_MODIFIED_TIME,
1912         MEDIA_UHD_PLAYED_POSITION,
1913         MEDIA_UHD_SUB_TYPE,
1914         MEDIA_UHD_PLAYED_COUNT,
1915 } media_uhd_field_e;
1916
1917 void _media_uhd_item_get_detail(sqlite3_stmt* stmt, media_uhd_h uhd)
1918 {
1919         media_uhd_s *_uhd = (media_uhd_s*)uhd;
1920
1921         if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_UHD_MEDIA_ID)))
1922                 _uhd->media_id = strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_MEDIA_ID));
1923
1924         if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_UHD_STORAGE_ID)))
1925                 _uhd->storage_id = strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_STORAGE_ID));
1926
1927         if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_UHD_PATH)))
1928                 _uhd->path = strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_PATH));
1929
1930         _uhd->size = (unsigned long long)sqlite3_column_int64(stmt, MEDIA_UHD_SIZE);
1931
1932         if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_UHD_CONTENT_ID)))
1933                 _uhd->content_id = strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_CONTENT_ID));
1934
1935         if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_UHD_CONTENT_TITLE)))
1936                 _uhd->content_title = strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_CONTENT_TITLE));
1937
1938         if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_UHD_FILE_NAME)))
1939                 _uhd->file_name = strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_FILE_NAME));
1940
1941         if (STRING_VALID((const char *)sqlite3_column_text(stmt, MEDIA_UHD_RELEASE_DATE)))
1942                 _uhd->release_date = strdup((const char *)sqlite3_column_text(stmt, MEDIA_UHD_RELEASE_DATE));
1943
1944         _uhd->modified_time = sqlite3_column_int(stmt, MEDIA_UHD_MODIFIED_TIME);
1945         _uhd->played_position = sqlite3_column_int(stmt, MEDIA_UHD_PLAYED_POSITION);
1946         _uhd->sub_type = sqlite3_column_int(stmt, MEDIA_UHD_SUB_TYPE);
1947         _uhd->played_count = sqlite3_column_int(stmt, MEDIA_UHD_PLAYED_COUNT);
1948
1949         return;
1950 }
1951
1952 int _media_db_get_uhd(filter_h filter, media_uhd_cb callback, void *user_data)
1953 {
1954         int ret = MEDIA_CONTENT_ERROR_NONE;
1955         char select_query[DEFAULT_QUERY_SIZE] = {0, };
1956         char *condition_query = NULL;
1957         char *option_query = NULL;
1958         sqlite3_stmt *stmt = NULL;
1959         filter_s *_filter = (filter_s *)filter;
1960
1961         if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
1962                 snprintf(select_query, sizeof(select_query), SELECT_UHD_LIST_BY_STORAGE_ID, _filter->storage_id);
1963         else
1964                 SAFE_STRLCAT(select_query, SELECT_UHD_LIST, sizeof(select_query));
1965
1966         ret = __media_db_make_query(filter, &condition_query, &option_query);
1967         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1968
1969         ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
1970         SAFE_FREE(condition_query);
1971         SAFE_FREE(option_query);
1972         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1973
1974         while (sqlite3_step(stmt) == SQLITE_ROW) {
1975                 media_uhd_s *_uhd = (media_uhd_s*)calloc(1, sizeof(media_uhd_s));
1976
1977                 if (_uhd == NULL) {
1978                         content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1979                         SQLITE3_FINALIZE(stmt);
1980                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1981                 }
1982
1983                 _media_uhd_item_get_detail(stmt, (media_uhd_h)_uhd);
1984
1985                 if (callback((media_uhd_h)_uhd, user_data) == false) {
1986                         media_uhd_destroy((media_uhd_h) _uhd);
1987                         break;
1988                 }
1989                 media_uhd_destroy((media_uhd_h) _uhd);
1990         }
1991
1992         SQLITE3_FINALIZE(stmt);
1993
1994         return ret;
1995 }
1996 #endif