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