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
  21 static char * __media_db_get_group_name(media_group_e group);
  22
  23 static char * __media_db_get_group_name(media_group_e group)
  24 {
  25         switch(group)
  26         {
  27                 case MEDIA_CONTENT_GROUP_DISPLAY_NAME:
  28                         return DB_FIELD_MEDIA_DISPLAY_NAME;
  29                 case MEDIA_CONTENT_GROUP_TYPE:
  30                         return DB_FIELD_MEDIA_TYPE;
  31                 case MEDIA_CONTENT_GROUP_MIME_TYPE:
  32                         return DB_FIELD_MEDIA_MIME_TYPE;
  33                 case MEDIA_CONTENT_GROUP_SIZE:
  34                         return DB_FIELD_MEDIA_SIZE;
  35                 case MEDIA_CONTENT_GROUP_ADDED_TIME:
  36                         return DB_FIELD_MEDIA_ADDED_TIME;
  37                 case MEDIA_CONTENT_GROUP_MODIFIED_TIME:
  38                         return DB_FIELD_MEDIA_MODIFIED_TIME;
  39                 case MEDIA_CONTENT_GROUP_TITLE:
  40                         return DB_FIELD_MEDIA_TITLE;
  41                 case MEDIA_CONTENT_GROUP_ARTIST:
  42                         return DB_FIELD_MEDIA_ARTIST;
  43                 case MEDIA_CONTENT_GROUP_GENRE:
  44                         return DB_FIELD_MEDIA_GENRE;
  45                 case MEDIA_CONTENT_GROUP_COMPOSER:
  46                         return DB_FIELD_MEDIA_COMPOSER;
  47                 case MEDIA_CONTENT_GROUP_YEAR:
  48                         return DB_FIELD_MEDIA_YEAR;
  49                 case MEDIA_CONTENT_GROUP_RECORDED_DATE:
  50                         return DB_FIELD_MEDIA_RECORDED_DATE;
  51                 case MEDIA_CONTENT_GROUP_COPYRIGHT:
  52                         return DB_FIELD_MEDIA_COPYRIGHT;
  53                 case MEDIA_CONTENT_GROUP_TRACK_NUM:
  54                         return DB_FIELD_MEDIA_TRACK_NUM;
  55                 case MEDIA_CONTENT_GROUP_DESCRIPTION:
  56                         return DB_FIELD_MEDIA_DESCRIPTION;
  57                 case MEDIA_CONTENT_GROUP_LONGITUDE:
  58                         return DB_FIELD_MEDIA_LONGITUDE;
  59                 case MEDIA_CONTENT_GROUP_LATIITUDE:
  60                         return DB_FIELD_MEDIA_LATITUDE;
  61                 case MEDIA_CONTENT_GROUP_ALTITUDE:
  62                         return DB_FIELD_MEDIA_ALTITUDE;
  63                 case MEDIA_CONTENT_GROUP_RATING:
  64                         return DB_FIELD_MEDIA_RATING;
  65                 case MEDIA_CONTENT_GROUP_AUTHOR:
  66                         return DB_FIELD_MEDIA_AUTHOR;
  67                 case MEDIA_CONTENT_GROUP_PROVIDER:
  68                         return DB_FIELD_MEDIA_PROVIDER;
  69                 case MEDIA_CONTENT_GROUP_CONTENT_NAME:
  70                         return DB_FIELD_MEDIA_CONTENT_NAME;
  71                 case MEDIA_CONTENT_GROUP_CATEGORY:
  72                         return DB_FIELD_MEDIA_CATEGORY;
  73                 case MEDIA_CONTENT_GROUP_LOCATION_TAG:
  74                         return DB_FIELD_MEDIA_LOCATION_TAG;
  75                 case MEDIA_CONTENT_GROUP_AGE_RATING:
  76                         return DB_FIELD_MEDIA_AGE_RATING;
  77                 case MEDIA_CONTENT_GROUP_KEYWORD:
  78                         return DB_FIELD_MEDIA_KEYWORD;
  79                 default:
  80                         return NULL;
  81         }
  82
  83         return NULL;
  84 }
  85
  86 int _media_db_get_group_count(filter_h filter, group_list_e group_type, int *group_count)
  87 {
  88         int ret = MEDIA_CONTENT_ERROR_NONE;
  89         sqlite3_stmt *stmt = NULL;
  90         filter_s *_filter = NULL;
  91         char select_query[DEFAULT_QUERY_SIZE];
  92         char *condition_query = NULL;
  93         char *option_query = NULL;
  94         attribute_h attr;
  95
  96         media_content_debug_func();
  97
  98         memset(select_query, 0x00, sizeof(select_query));
  99
 100         attr = _content_get_attirbute_handle();
 101
 102         switch(group_type) {
 103                 case MEDIA_GROUP_NONE:
 104                 case MEDIA_GROUP_TAG_BY_MEDIA_ID:
 105                 case MEDIA_GROUP_BOOKMARK_BY_MEDIA_ID:
 106                         {
 107                                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 108                                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 109                         }
 110                         break;
 111                 case MEDIA_GROUP_ALBUM:
 112                         attr = _content_get_alias_attirbute_handle();
 113                         //snprintf(select_query, sizeof(select_query), SELECT_ALBUM_COUNT);
 114                         if(!SAFE_STRLCPY(select_query, SELECT_ALBUM_COUNT, sizeof(select_query)))
 115                         {
 116                                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 117                                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 118                         }
 119
 120                         break;
 121                 case MEDIA_GROUP_FOLDER:
 122                         attr = _content_get_alias_attirbute_handle();
 123                         //snprintf(select_query, sizeof(select_query), SELECT_FOLDER_COUNT);
 124                         if(!SAFE_STRLCPY(select_query, SELECT_FOLDER_COUNT, sizeof(select_query)))
 125                         {
 126                                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 127                                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 128                         }
 129                         break;
 130                 case MEDIA_GROUP_PLAYLIST:
 131                         //attr = _content_get_alias_attirbute_handle();
 132                         //snprintf(select_query, sizeof(select_query), SELECT_PLAYLIST_COUNT);
 133                         if(!SAFE_STRLCPY(select_query, SELECT_PLAYLIST_COUNT, sizeof(select_query)))
 134                         {
 135                                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 136                                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 137                         }
 138                         break;
 139                 case MEDIA_GROUP_TAG:
 140                         //attr = _content_get_alias_attirbute_handle();
 141                         //snprintf(select_query, sizeof(select_query), SELECT_TAG_COUNT);
 142                         if(!SAFE_STRLCPY(select_query, SELECT_TAG_COUNT, sizeof(select_query)))
 143                         {
 144                                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 145                                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 146                         }
 147                         break;
 148                 case MEDIA_GROUP_BOOKMARK:
 149                         attr = _content_get_alias_attirbute_handle();
 150                         //snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_COUNT);
 151                         if(!SAFE_STRLCPY(select_query, SELECT_BOOKMARK_COUNT, sizeof(select_query)))
 152                         {
 153                                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 154                                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 155                         }
 156                         break;
 157         }
 158
 159         if(filter != NULL)
 160         {
 161                 _filter = (filter_s*)filter;
 162
 163                 if(STRING_VALID(_filter->condition))
 164                 {
 165                         ret = _media_filter_attribute_generate(attr, _filter->condition, _filter->condition_collate_type, &condition_query);
 166                         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 167                 }
 168
 169                 ret = _media_filter_attribute_option_generate(attr, filter, &option_query);
 170                 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 171
 172                 if(STRING_VALID(condition_query))
 173                 {
 174                         SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, sizeof(select_query));
 175                         SAFE_STRLCAT(select_query, QUERY_KEYWORD_AND, sizeof(select_query));
 176                 }
 177         }
 178
 179         ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
 180         SAFE_FREE(condition_query);
 181         SAFE_FREE(option_query);
 182         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 183
 184         while(sqlite3_step(stmt) == SQLITE_ROW)
 185         {
 186                 *group_count = (int)sqlite3_column_int(stmt, 0);
 187                 media_content_debug("group count : [%d]", *group_count);
 188         }
 189
 190         SQLITE3_FINALIZE(stmt);
 191
 192         return ret;
 193 }
 194
 195 int _media_db_get_media_group_count(media_group_e group, filter_h filter, int *group_count)
 196 {
 197         int ret = MEDIA_CONTENT_ERROR_NONE;
 198         sqlite3_stmt *stmt = NULL;
 199         filter_s *_filter = NULL;
 200         char select_query[DEFAULT_QUERY_SIZE];
 201         char *condition_query = NULL;
 202         char *option_query = NULL;
 203
 204         media_content_debug_func();
 205
 206         memset(select_query, 0x00, sizeof(select_query));
 207
 208         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_COUNT, __media_db_get_group_name(group));
 209
 210         if(filter != NULL)
 211         {
 212                 _filter = (filter_s*)filter;
 213
 214                 if(STRING_VALID(_filter->condition))
 215                 {
 216                         ret = _media_filter_attribute_generate(_content_get_attirbute_handle(), _filter->condition, _filter->condition_collate_type, &condition_query);
 217                         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 218                 }
 219
 220                 ret = _media_filter_attribute_option_generate(_content_get_attirbute_handle(), filter, &option_query);
 221                 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 222
 223                 if(STRING_VALID(condition_query))
 224                 {
 225                         SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, sizeof(select_query));
 226                         SAFE_STRLCAT(select_query, QUERY_KEYWORD_AND, sizeof(select_query));
 227                 }
 228
 229                 SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, sizeof(select_query));
 230                 if(STRING_VALID(condition_query))
 231                         SAFE_STRLCAT(select_query, condition_query, sizeof(select_query));
 232                 if(STRING_VALID(option_query))
 233                         SAFE_STRLCAT(select_query, option_query, sizeof(select_query));
 234
 235                 SAFE_FREE(condition_query);
 236                 SAFE_FREE(option_query);
 237         }
 238
 239         SAFE_STRLCAT(select_query, QUERY_KEYWORD_BRACKET, sizeof(select_query));
 240
 241         ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
 242         SAFE_FREE(condition_query);
 243         SAFE_FREE(option_query);
 244         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 245
 246         while(sqlite3_step(stmt) == SQLITE_ROW)
 247         {
 248                 *group_count = (int)sqlite3_column_int(stmt, 0);
 249                 media_content_debug("group count : [%d]", *group_count);
 250         }
 251
 252         SQLITE3_FINALIZE(stmt);
 253
 254         return ret;
 255 }
 256
 257 int _media_db_get_media_group(media_group_e group, filter_h filter, media_group_cb callback, void *user_data)
 258 {
 259         int ret = MEDIA_CONTENT_ERROR_NONE;
 260         char select_query[DEFAULT_QUERY_SIZE];
 261         char *condition_query = NULL;
 262         char *option_query = NULL;
 263         char *name = NULL;
 264         sqlite3_stmt *stmt = NULL;
 265         filter_s *_filter = NULL;
 266
 267         memset(select_query, 0x00, sizeof(select_query));
 268
 269         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_LIST, __media_db_get_group_name(group));
 270
 271         if(filter != NULL)
 272         {
 273                 _filter = (filter_s*)filter;
 274
 275                 if(_filter->condition)
 276                 {
 277                         ret = _media_filter_attribute_generate(_content_get_attirbute_handle(), _filter->condition, _filter->condition_collate_type, &condition_query);
 278                         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 279                 }
 280
 281                 ret = _media_filter_attribute_option_generate(_content_get_attirbute_handle(), filter, &option_query);
 282                 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 283
 284                 if(STRING_VALID(condition_query))
 285                 {
 286                         SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, sizeof(select_query));
 287                         SAFE_STRLCAT(select_query, QUERY_KEYWORD_AND, sizeof(select_query));
 288                 }
 289         }
 290
 291         ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
 292         SAFE_FREE(condition_query);
 293         SAFE_FREE(option_query);
 294         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 295
 296         while(sqlite3_step(stmt) == SQLITE_ROW)
 297         {
 298                 if(STRING_VALID((const char *)sqlite3_column_text(stmt, 0)))
 299                 {
 300                         name = strdup((const char *)sqlite3_column_text(stmt, 0));
 301                         media_content_debug("group name : [%s]", name);
 302                 }
 303
 304                 if(callback(name, user_data) == false)
 305                 {
 306                         SAFE_FREE(name);
 307                         break;
 308                 }
 309
 310                 SAFE_FREE(name);
 311         }
 312
 313         SQLITE3_FINALIZE(stmt);
 314
 315         return ret;
 316 }
 317
 318 int _media_db_get_album(filter_h filter, media_album_cb callback, void *user_data)
 319 {
 320         int ret = MEDIA_CONTENT_ERROR_NONE;
 321         char select_query[DEFAULT_QUERY_SIZE];
 322         char *condition_query = NULL;
 323         char *option_query = NULL;
 324         sqlite3_stmt *stmt = NULL;
 325         filter_s *_filter = NULL;
 326
 327         memset(select_query, 0x00, sizeof(select_query));
 328
 329         //snprintf(select_query, sizeof(select_query), SELECT_ALBUM_LIST);
 330         if(!SAFE_STRLCPY(select_query, SELECT_ALBUM_LIST, sizeof(select_query)))
 331         {
 332                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 333                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 334         }
 335
 336         if(filter != NULL)
 337         {
 338                 _filter = (filter_s*)filter;
 339
 340                 if(_filter->condition)
 341                 {
 342                         ret = _media_filter_attribute_generate(_content_get_alias_attirbute_handle(), _filter->condition, _filter->condition_collate_type, &condition_query);
 343                         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 344                 }
 345
 346                 ret = _media_filter_attribute_option_generate(_content_get_alias_attirbute_handle(), filter, &option_query);
 347                 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 348
 349                 if(STRING_VALID(condition_query))
 350                 {
 351                         SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, sizeof(select_query));
 352                         SAFE_STRLCAT(select_query, QUERY_KEYWORD_AND, sizeof(select_query));
 353                 }
 354         }
 355
 356         ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
 357         SAFE_FREE(condition_query);
 358         SAFE_FREE(option_query);
 359         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 360
 361         while(sqlite3_step(stmt) == SQLITE_ROW)
 362         {
 363                 media_album_s *album = (media_album_s*)calloc(1, sizeof(media_album_s));
 364
 365                 if(album == NULL)
 366                 {
 367                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 368                         SQLITE3_FINALIZE(stmt);
 369                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 370                 }
 371
 372                 album->album_id = (int)sqlite3_column_int(stmt, 0);
 373
 374                 if(STRING_VALID((const char *)sqlite3_column_text(stmt, 1)))
 375                         album->name = strdup((const char *)sqlite3_column_text(stmt, 1));
 376
 377                 if(STRING_VALID((const char *)sqlite3_column_text(stmt, 2)))
 378                         album->artist = strdup((const char *)sqlite3_column_text(stmt, 2));
 379
 380                 if(STRING_VALID((const char *)sqlite3_column_text(stmt, 3)))
 381                         album->album_art_path = strdup((const char *)sqlite3_column_text(stmt, 3));
 382
 383                 if(callback((media_album_h)album, user_data) == false)
 384                 {
 385                         media_album_destroy((media_album_h)album);
 386                         break;
 387                 }
 388
 389                 media_album_destroy((media_album_h)album);
 390         }
 391
 392         SQLITE3_FINALIZE(stmt);
 393
 394         return ret;
 395 }
 396
 397 int _media_db_get_folder(filter_h filter, media_folder_cb callback, void *user_data)
 398 {
 399         int ret = MEDIA_CONTENT_ERROR_NONE;
 400         char select_query[DEFAULT_QUERY_SIZE];
 401         char *condition_query = NULL;
 402         char *option_query = NULL;
 403         sqlite3_stmt *stmt = NULL;
 404         filter_s *_filter = NULL;
 405
 406         memset(select_query, 0x00, sizeof(select_query));
 407
 408         //snprintf(select_query, sizeof(select_query), SELECT_FOLDER_LIST);
 409         if(!SAFE_STRLCPY(select_query, SELECT_FOLDER_LIST, sizeof(select_query)))
 410         {
 411                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 412                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 413         }
 414
 415         if(filter != NULL)
 416         {
 417                 _filter = (filter_s*)filter;
 418
 419                 if(_filter->condition)
 420                 {
 421                         ret = _media_filter_attribute_generate(_content_get_alias_attirbute_handle(), _filter->condition, _filter->condition_collate_type, &condition_query);
 422                         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 423                 }
 424
 425                 ret = _media_filter_attribute_option_generate(_content_get_alias_attirbute_handle(), filter, &option_query);
 426                 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 427
 428                 if(STRING_VALID(condition_query))
 429                 {
 430                         SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, sizeof(select_query));
 431                         SAFE_STRLCAT(select_query, QUERY_KEYWORD_AND, sizeof(select_query));
 432                 }
 433         }
 434
 435         ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
 436         SAFE_FREE(condition_query);
 437         SAFE_FREE(option_query);
 438         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 439
 440         while(sqlite3_step(stmt) == SQLITE_ROW)
 441         {
 442                 media_folder_s *_folder = (media_folder_s*)calloc(1, sizeof(media_folder_s));
 443
 444                 if(_folder == NULL)
 445                 {
 446                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 447                         SQLITE3_FINALIZE(stmt);
 448                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 449                 }
 450
 451                 if(STRING_VALID((const char *)sqlite3_column_text(stmt, 0)))
 452                         _folder->folder_id = strdup((const char *)sqlite3_column_text(stmt, 0));
 453
 454                 if(STRING_VALID((const char *)sqlite3_column_text(stmt, 1)))
 455                         _folder->path = strdup((const char *)sqlite3_column_text(stmt, 1));
 456
 457                 if(STRING_VALID((const char *)sqlite3_column_text(stmt, 2)))
 458                         _folder->name = strdup((const char *)sqlite3_column_text(stmt, 2));
 459
 460                 _folder->storage_type = (int)sqlite3_column_int(stmt,3);
 461
 462                 _folder->modified_time = (int)sqlite3_column_int(stmt,4);
 463
 464                 if(callback((media_folder_h)_folder, user_data) == false)
 465                 {
 466                         media_folder_destroy((media_folder_h) _folder);
 467                         break;
 468                 }
 469
 470                 media_folder_destroy((media_folder_h) _folder);
 471         }
 472
 473         SQLITE3_FINALIZE(stmt);
 474
 475         return ret;
 476 }
 477
 478 int _media_db_get_playlist(filter_h filter, media_playlist_cb callback, void *user_data)
 479 {
 480         int ret = MEDIA_CONTENT_ERROR_NONE;
 481         char select_query[DEFAULT_QUERY_SIZE];
 482         char *condition_query = NULL;
 483         char *option_query = NULL;
 484         sqlite3_stmt *stmt = NULL;
 485         filter_s *_filter = NULL;
 486
 487         memset(select_query, 0x00, sizeof(select_query));
 488
 489         //snprintf(select_query, sizeof(select_query), SELECT_PLAYLIST_LIST);
 490         if(!SAFE_STRLCPY(select_query, SELECT_PLAYLIST_LIST, sizeof(select_query)))
 491         {
 492                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 493                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 494         }
 495
 496
 497         if(filter != NULL)
 498         {
 499                 _filter = (filter_s*)filter;
 500
 501                 if(_filter->condition)
 502                 {
 503                         //ret = _media_filter_attribute_generate(_content_get_alias_attirbute_handle(), _filter->condition, _filter->condition_collate_type, &condition_query);
 504                         ret = _media_filter_attribute_generate(_content_get_attirbute_handle(), _filter->condition, _filter->condition_collate_type, &condition_query);
 505                         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 506                 }
 507
 508                 //ret = _media_filter_attribute_option_generate(_content_get_alias_attirbute_handle(), filter, &option_query);
 509                 ret = _media_filter_attribute_option_generate(_content_get_attirbute_handle(), filter, &option_query);
 510                 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 511
 512                 if(STRING_VALID(condition_query))
 513                 {
 514                         SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, sizeof(select_query));
 515                         SAFE_STRLCAT(select_query, QUERY_KEYWORD_AND, sizeof(select_query));
 516                 }
 517         }
 518
 519         ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
 520         SAFE_FREE(condition_query);
 521         SAFE_FREE(option_query);
 522         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 523
 524         while(sqlite3_step(stmt) == SQLITE_ROW)
 525         {
 526                 media_playlist_s *_playlist = (media_playlist_s*)calloc(1, sizeof(media_playlist_s));
 527
 528                 if(_playlist == NULL)
 529                 {
 530                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 531                         SQLITE3_FINALIZE(stmt);
 532                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 533                 }
 534
 535                 _playlist->playlist_id = (int)sqlite3_column_int(stmt, 0);
 536
 537                 if(STRING_VALID((const char *)sqlite3_column_text(stmt, 1)))
 538                         _playlist->name = strdup((const char *)sqlite3_column_text(stmt, 1));
 539
 540                 if(callback((media_playlist_h)_playlist, user_data) == false)
 541                 {
 542                         media_playlist_destroy((media_playlist_h)_playlist);
 543                         break;
 544                 }
 545                 media_playlist_destroy((media_playlist_h)_playlist);
 546         }
 547
 548         SQLITE3_FINALIZE(stmt);
 549
 550         return ret;
 551 }
 552
 553 int _media_db_get_playlist_item(int playlist_id, filter_h filter, playlist_member_cb callback, void *user_data)
 554 {
 555         int ret = MEDIA_CONTENT_ERROR_NONE;
 556         char select_query[DEFAULT_QUERY_SIZE];
 557         char *condition_query = NULL;
 558         char *option_query = NULL;
 559         sqlite3_stmt *stmt = NULL;
 560         filter_s *_filter = NULL;
 561
 562         memset(select_query, 0x00, sizeof(select_query));
 563
 564         snprintf(select_query, sizeof(select_query), SELECT_PLAYLIST_ITEM_ID_FROM_PLAYLIST_VIEW, playlist_id);
 565
 566         if(filter != NULL)
 567         {
 568                 _filter = (filter_s*)filter;
 569
 570                 if(_filter->condition)
 571                 {
 572                         //ret = _media_filter_attribute_generate(_content_get_alias_attirbute_handle(), _filter->condition, _filter->condition_collate_type, &condition_query);
 573                         ret = _media_filter_attribute_generate(_content_get_attirbute_handle(), _filter->condition, _filter->condition_collate_type, &condition_query);
 574                         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 575                 }
 576
 577                 //ret = _media_filter_attribute_option_generate(_content_get_alias_attirbute_handle(), filter, &option_query);
 578                 ret = _media_filter_attribute_option_generate(_content_get_attirbute_handle(), filter, &option_query);
 579                 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 580
 581                 if(STRING_VALID(condition_query))
 582                 {
 583                         SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, sizeof(select_query));
 584                         SAFE_STRLCAT(select_query, QUERY_KEYWORD_AND, sizeof(select_query));
 585                 }
 586         }
 587
 588         ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
 589         SAFE_FREE(condition_query);
 590         SAFE_FREE(option_query);
 591         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 592
 593         while(sqlite3_step(stmt) == SQLITE_ROW)
 594         {
 595                 int playlist_member_id = 0;
 596                 char media_uuid[MEDIA_CONTENT_UUID_SIZE+1];
 597                 media_info_h media = NULL;
 598                 memset(media_uuid, 0x00, sizeof(media_uuid));
 599
 600                 playlist_member_id = (int)sqlite3_column_int(stmt, 0);
 601
 602                 if(STRING_VALID((const char *)sqlite3_column_text(stmt, 1)))
 603                         strncpy(media_uuid, (const char *)sqlite3_column_text(stmt, 1), sizeof(media_uuid));
 604
 605                 ret = media_info_get_media_from_db(media_uuid, &media);
 606
 607                 if(callback(playlist_member_id, media, user_data) == false)
 608                 {
 609                         media_info_destroy(media);
 610                         break;
 611                 }
 612                 media_info_destroy(media);
 613         }
 614
 615         SQLITE3_FINALIZE(stmt);
 616
 617         return ret;
 618 }
 619
 620 //same as _media_db_get_playlist
 621 int _media_db_get_tag(const char *media_id, filter_h filter, media_tag_cb callback, void *user_data)
 622 {
 623         int ret = MEDIA_CONTENT_ERROR_NONE;
 624         char select_query[DEFAULT_QUERY_SIZE];
 625         char *condition_query = NULL;
 626         char *option_query = NULL;
 627         sqlite3_stmt *stmt = NULL;
 628         filter_s *_filter = NULL;
 629         attribute_h attr;
 630
 631         memset(select_query, 0x00, sizeof(select_query));
 632
 633         if(!STRING_VALID(media_id))
 634         {
 635                 //attr = _content_get_alias_attirbute_handle();
 636                 attr = _content_get_attirbute_handle();
 637                 //snprintf(select_query, sizeof(select_query), SELECT_TAG_LIST);
 638                 if(!SAFE_STRLCPY(select_query, SELECT_TAG_LIST, sizeof(select_query)))
 639                 {
 640                         media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 641                         return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 642                 }
 643         }
 644         else
 645         {
 646                 attr = _content_get_attirbute_handle();
 647                 snprintf(select_query, sizeof(select_query), SELECT_TAG_LIST_BY_MEDIA_ID, media_id);
 648         }
 649
 650         if(filter != NULL)
 651         {
 652                 _filter = (filter_s*)filter;
 653
 654                 if(_filter->condition)
 655                 {
 656                         ret = _media_filter_attribute_generate(attr, _filter->condition, _filter->condition_collate_type, &condition_query);
 657                         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 658                 }
 659
 660                 ret = _media_filter_attribute_option_generate(attr, filter, &option_query);
 661                 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 662
 663                 if(STRING_VALID(condition_query))
 664                 {
 665                         SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, sizeof(select_query));
 666                         SAFE_STRLCAT(select_query, QUERY_KEYWORD_AND, sizeof(select_query));
 667                 }
 668         }
 669
 670         SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, sizeof(select_query));
 671
 672         ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
 673         SAFE_FREE(condition_query);
 674         SAFE_FREE(option_query);
 675         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 676
 677         while(sqlite3_step(stmt) == SQLITE_ROW)
 678         {
 679                 media_tag_s *_tag = (media_tag_s*)calloc(1, sizeof(media_tag_s));
 680
 681                 if(_tag == NULL)
 682                 {
 683                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 684                         SQLITE3_FINALIZE(stmt);
 685                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 686                 }
 687
 688                 _tag->tag_id = (int)sqlite3_column_int(stmt, 0);
 689
 690                 if(STRING_VALID((const char *)sqlite3_column_text(stmt, 1)))
 691                         _tag->name = strdup((const char *)sqlite3_column_text(stmt, 1));
 692
 693                 if(callback((media_tag_h)_tag, user_data) == false)
 694                 {
 695                         media_tag_destroy((media_tag_h)_tag);
 696                         break;
 697                 }
 698                 media_tag_destroy((media_tag_h)_tag);
 699         }
 700
 701         SQLITE3_FINALIZE(stmt);
 702
 703         return ret;
 704 }
 705
 706 int _media_db_get_bookmark(const char *media_id, filter_h filter, media_bookmark_cb callback, void *user_data)
 707 {
 708         int ret = MEDIA_CONTENT_ERROR_NONE;
 709         char select_query[DEFAULT_QUERY_SIZE];
 710         char *condition_query = NULL;
 711         char *option_query = NULL;
 712         sqlite3_stmt *stmt = NULL;
 713         filter_s *_filter = NULL;
 714         attribute_h attr;
 715
 716         memset(select_query, 0x00, sizeof(select_query));
 717
 718         if(!STRING_VALID(media_id))
 719         {
 720                 attr = _content_get_alias_attirbute_handle();
 721                 //snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST);
 722                 if(!SAFE_STRLCPY(select_query, SELECT_BOOKMARK_LIST, sizeof(select_query)))
 723                 {
 724                         media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 725                         return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 726                 }
 727         }
 728         else
 729         {
 730                 attr = _content_get_attirbute_handle();
 731                 snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST_BY_MEDIA_ID_USUAL, media_id);
 732         }
 733
 734         if(filter != NULL)
 735         {
 736                 _filter = (filter_s*)filter;
 737
 738                 if(_filter->condition)
 739                 {
 740                         ret = _media_filter_attribute_generate(attr, _filter->condition, _filter->condition_collate_type, &condition_query);
 741                         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 742                 }
 743
 744                 ret = _media_filter_attribute_option_generate(attr, filter, &option_query);
 745                 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 746
 747                 if(STRING_VALID(condition_query))
 748                 {
 749                         SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, sizeof(select_query));
 750                         SAFE_STRLCAT(select_query, QUERY_KEYWORD_AND, sizeof(select_query));
 751                 }
 752         }
 753
 754         ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
 755         SAFE_FREE(condition_query);
 756         SAFE_FREE(option_query);
 757         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 758
 759         while(sqlite3_step(stmt) == SQLITE_ROW)
 760         {
 761                 media_bookmark_s *bookmark = (media_bookmark_s*)calloc(1, sizeof(media_bookmark_s));
 762
 763                 if(bookmark == NULL)
 764                 {
 765                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 766                         SQLITE3_FINALIZE(stmt);
 767                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 768                 }
 769
 770                 bookmark->bookmark_id = (int)sqlite3_column_int(stmt, 0);
 771
 772                 if(STRING_VALID((const char *)sqlite3_column_text(stmt, 1)))
 773                         bookmark->media_id = strdup((const char *)sqlite3_column_text(stmt, 1));
 774
 775                 bookmark->marked_time = (int)sqlite3_column_int(stmt, 2);
 776
 777                 if(STRING_VALID((const char *)sqlite3_column_text(stmt, 3)))
 778                         bookmark->thumbnail_path = strdup((const char *)sqlite3_column_text(stmt, 3));
 779
 780                 if(callback((media_bookmark_h)bookmark, user_data) == false)
 781                 {
 782                         media_bookmark_destroy((media_bookmark_h)bookmark);
 783                         break;
 784                 }
 785
 786                 media_bookmark_destroy((media_bookmark_h)bookmark);
 787         }
 788
 789         SQLITE3_FINALIZE(stmt);
 790
 791         return ret;
 792
 793 }
 794
 795 int _media_db_get_group_item_count_by_id(int group_id, filter_h filter, group_list_e group_type, int *item_count)
 796 {
 797         int ret = MEDIA_CONTENT_ERROR_NONE;
 798         sqlite3_stmt *stmt = NULL;
 799         filter_s *_filter = NULL;
 800         char select_query[DEFAULT_QUERY_SIZE];
 801         char *condition_query = NULL;
 802         char *option_query = NULL;
 803         attribute_h attr = NULL;
 804
 805         media_content_debug_func();
 806
 807         memset(select_query, 0x00, sizeof(select_query));
 808
 809         if(group_type == MEDIA_GROUP_ALBUM)
 810         {
 811                 attr = _content_get_attirbute_handle();
 812                 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_ALBUM, group_id);
 813         }
 814         else if(group_type == MEDIA_GROUP_PLAYLIST)
 815         {
 816                 //attr = _content_get_alias_attirbute_handle();
 817                 attr = _content_get_attirbute_handle();
 818                 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_PLAYLIST, group_id);
 819         }
 820         else if(group_type == MEDIA_GROUP_TAG)
 821         {
 822                 attr = _content_get_attirbute_handle();
 823                 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_TAG, group_id);
 824         }
 825         else
 826         {
 827                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 828                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 829         }
 830
 831         if(filter != NULL)
 832         {
 833                 _filter = (filter_s*)filter;
 834
 835                 if(_filter->condition)
 836                 {
 837                         ret = _media_filter_attribute_generate(attr, _filter->condition, _filter->condition_collate_type, &condition_query);
 838                         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 839                 }
 840
 841                 ret = _media_filter_attribute_option_generate(attr, filter, &option_query);
 842                 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 843
 844                 if(STRING_VALID(condition_query))
 845                 {
 846                         SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, sizeof(select_query));
 847                         SAFE_STRLCAT(select_query, QUERY_KEYWORD_AND, sizeof(select_query));
 848                 }
 849         }
 850 /*
 851         if((group_type == MEDIA_GROUP_PLAYLIST) || (group_type == MEDIA_GROUP_TAG))
 852         {
 853                 strncat(select_query, QUERY_KEYWORD_SPACE, strlen(QUERY_KEYWORD_SPACE));
 854
 855                 if(STRING_VALID(condition_query))
 856                         strncat(select_query, condition_query, strlen(condition_query));
 857                 if(STRING_VALID(option_query))
 858                         strncat(select_query, option_query, strlen(option_query));
 859
 860                 strncat(select_query, QUERY_KEYWORD_BRACKET, strlen(QUERY_KEYWORD_BRACKET));
 861
 862                 SAFE_FREE(condition_query);
 863                 SAFE_FREE(option_query);
 864         }
 865 */
 866         ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
 867         SAFE_FREE(condition_query);
 868         SAFE_FREE(option_query);
 869         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 870
 871         while(sqlite3_step(stmt) == SQLITE_ROW)
 872         {
 873                 *item_count = (int)sqlite3_column_int(stmt, 0);
 874                 media_content_debug("group item count : [%d]", *item_count);
 875         }
 876
 877         SQLITE3_FINALIZE(stmt);
 878
 879         return ret;
 880 }
 881
 882 int _media_db_get_group_item_count(const char *group_name, filter_h filter, group_list_e group_type, int *item_count)
 883 {
 884         int ret = MEDIA_CONTENT_ERROR_NONE;
 885         sqlite3_stmt *stmt = NULL;
 886         filter_s *_filter = NULL;
 887         char complete_select_query[DEFAULT_QUERY_SIZE];
 888         char *select_query = NULL;
 889         char *condition_query = NULL;
 890         char *option_query = NULL;
 891
 892         media_content_debug_func();
 893
 894         if(group_type == MEDIA_GROUP_NONE)
 895         {
 896                 select_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_MEDIA);
 897         }
 898         else if(group_type == MEDIA_GROUP_FOLDER)
 899         {
 900                 select_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_FOLDER, group_name);
 901         }
 902         else if(group_type == MEDIA_GROUP_TAG_BY_MEDIA_ID)
 903         {
 904                 select_query = sqlite3_mprintf(SELECT_TAG_COUNT_BY_MEDIA_ID, group_name);
 905         }
 906         else if(group_type == MEDIA_GROUP_BOOKMARK_BY_MEDIA_ID)
 907         {
 908                 select_query = sqlite3_mprintf(SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, group_name);
 909         }
 910         else
 911         {
 912                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 913                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 914         }
 915
 916         if(filter != NULL)
 917         {
 918                 _filter = (filter_s*)filter;
 919
 920                 if(_filter->condition)
 921                 {
 922                         ret = _media_filter_attribute_generate(_content_get_attirbute_handle(), _filter->condition, _filter->condition_collate_type, &condition_query);
 923                         if(ret != MEDIA_CONTENT_ERROR_NONE)
 924                         {
 925                                 sqlite3_free(select_query);
 926                                 return ret;
 927                         }
 928                 }
 929
 930                 ret = _media_filter_attribute_option_generate(_content_get_attirbute_handle(), filter, &option_query);
 931                 if(ret != MEDIA_CONTENT_ERROR_NONE)
 932                 {
 933                         sqlite3_free(select_query);
 934                         return ret;
 935                 }
 936
 937                 if(STRING_VALID(condition_query))
 938                 {
 939                         snprintf(complete_select_query, sizeof(complete_select_query), "%s %s", select_query, QUERY_KEYWORD_AND);
 940                 }
 941                 else
 942                 {
 943                         snprintf(complete_select_query, sizeof(complete_select_query), "%s", select_query);
 944                 }
 945         } else {
 946                 snprintf(complete_select_query, sizeof(complete_select_query), "%s", select_query);
 947         }
 948
 949         if(group_type == MEDIA_GROUP_NONE)
 950         {
 951                 SAFE_STRLCAT(complete_select_query, QUERY_KEYWORD_SPACE, sizeof(complete_select_query));
 952                 if(STRING_VALID(condition_query))
 953                         SAFE_STRLCAT(complete_select_query, condition_query, sizeof(complete_select_query));
 954                 if(STRING_VALID(option_query))
 955                         SAFE_STRLCAT(complete_select_query, option_query, sizeof(complete_select_query));
 956
 957                 SAFE_STRLCAT(complete_select_query, QUERY_KEYWORD_BRACKET, sizeof(complete_select_query));
 958
 959                 SAFE_FREE(condition_query);
 960                 SAFE_FREE(option_query);
 961         }
 962
 963         ret = _content_query_prepare(&stmt, complete_select_query, condition_query, option_query);
 964         sqlite3_free(select_query);
 965         SAFE_FREE(condition_query);
 966         SAFE_FREE(option_query);
 967         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 968
 969         while(sqlite3_step(stmt) == SQLITE_ROW)
 970         {
 971                 *item_count = (int)sqlite3_column_int(stmt, 0);
 972                 media_content_debug("group item count : [%d]", *item_count);
 973         }
 974
 975         SQLITE3_FINALIZE(stmt);
 976
 977         return ret;
 978 }
 979
 980 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)
 981 {
 982         int ret = MEDIA_CONTENT_ERROR_NONE;
 983         char select_query[DEFAULT_QUERY_SIZE];
 984         char *condition_query = NULL;
 985         char *option_query = NULL;
 986         sqlite3_stmt *stmt = NULL;
 987         filter_s *_filter = NULL;
 988
 989         memset(select_query, 0x00, sizeof(select_query));
 990
 991         if(group_type == MEDIA_GROUP_ALBUM)
 992         {
 993                 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_ALBUM, group_id);
 994         }
 995         else if(group_type == MEDIA_GROUP_PLAYLIST)
 996         {
 997                 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_PLAYLIST, group_id);
 998         }
 999         else if(group_type == MEDIA_GROUP_TAG)
1000         {
1001                 snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_TAG, group_id);
1002         }
1003         else
1004         {
1005                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1006                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1007         }
1008
1009         if(filter != NULL)
1010         {
1011                 _filter = (filter_s*)filter;
1012
1013                 if(_filter->condition)
1014                 {
1015                         ret = _media_filter_attribute_generate(_content_get_attirbute_handle(), _filter->condition, _filter->condition_collate_type, &condition_query);
1016                         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1017                 }
1018
1019                 ret = _media_filter_attribute_option_generate(_content_get_attirbute_handle(), filter, &option_query);
1020                 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1021
1022                 if(STRING_VALID(condition_query))
1023                 {
1024                         SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, sizeof(select_query));
1025                         SAFE_STRLCAT(select_query, QUERY_KEYWORD_AND, sizeof(select_query));
1026                 }
1027         }
1028
1029         ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
1030         SAFE_FREE(condition_query);
1031         SAFE_FREE(option_query);
1032         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1033
1034         while(sqlite3_step(stmt) == SQLITE_ROW)
1035         {
1036                 media_info_s *item = (media_info_s*)calloc(1, sizeof(media_info_s));
1037                 if(item == NULL)
1038                 {
1039                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1040                         SQLITE3_FINALIZE(stmt);
1041                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1042                 }
1043
1044                 _media_info_item_get_detail(stmt, (media_info_h)item);
1045
1046                 if(callback((media_info_h)item, user_data) == false)
1047                 {
1048                         media_info_destroy((media_info_h)item);
1049                         break;
1050                 }
1051
1052                 media_info_destroy((media_info_h)item);
1053         }
1054
1055         SQLITE3_FINALIZE(stmt);
1056
1057         return ret;
1058 }
1059
1060 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)
1061 {
1062         int ret = MEDIA_CONTENT_ERROR_NONE;
1063         char complete_select_query[DEFAULT_QUERY_SIZE];
1064         char *select_query = NULL;
1065         char *condition_query = NULL;
1066         char *option_query = NULL;
1067         sqlite3_stmt *stmt = NULL;
1068         filter_s *_filter = NULL;
1069
1070         if(group_type == MEDIA_GROUP_NONE)
1071         {
1072                 select_query = sqlite3_mprintf(SELECT_MEDIA_ITEM);
1073         }
1074         else if(group_type == MEDIA_GROUP_FOLDER)
1075         {
1076                 select_query = sqlite3_mprintf(SELECT_MEDIA_FROM_FOLDER, group_name);
1077         }
1078         else if(group_type == MEDIA_GROUP_BOOKMARK_BY_MEDIA_ID)
1079         {
1080                 select_query = sqlite3_mprintf(SELECT_BOOKMARK_LIST_BY_MEDIA_ID, group_name);
1081         }
1082         else
1083         {
1084                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1085                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1086         }
1087
1088         if(filter != NULL)
1089         {
1090                 _filter = (filter_s*)filter;
1091
1092                 if(_filter->condition)
1093                 {
1094                         ret = _media_filter_attribute_generate(_content_get_attirbute_handle(), _filter->condition, _filter->condition_collate_type, &condition_query);
1095                         if(ret != MEDIA_CONTENT_ERROR_NONE)
1096                         {
1097                                 sqlite3_free(select_query);
1098                                 return ret;
1099                         }
1100                 }
1101
1102                 ret = _media_filter_attribute_option_generate(_content_get_attirbute_handle(), filter, &option_query);
1103                 if(ret != MEDIA_CONTENT_ERROR_NONE)
1104                 {
1105                         sqlite3_free(select_query);
1106                         return ret;
1107                 }
1108
1109                 if(STRING_VALID(condition_query))
1110                 {
1111                         snprintf(complete_select_query, sizeof(complete_select_query), "%s %s", select_query, QUERY_KEYWORD_AND);
1112                 }
1113                 else
1114                 {
1115                         snprintf(complete_select_query, sizeof(complete_select_query), "%s", select_query);
1116                 }
1117         } else {
1118                 snprintf(complete_select_query, sizeof(complete_select_query), "%s", select_query);
1119         }
1120
1121         ret = _content_query_prepare(&stmt, complete_select_query, condition_query, option_query);
1122         sqlite3_free(select_query);
1123         SAFE_FREE(condition_query);
1124         SAFE_FREE(option_query);
1125         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1126
1127         while(sqlite3_step(stmt) == SQLITE_ROW)
1128         {
1129                 media_info_s *item = (media_info_s*)calloc(1, sizeof(media_info_s));
1130                 if(item == NULL)
1131                 {
1132                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1133                         SQLITE3_FINALIZE(stmt);
1134                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1135                 }
1136
1137                 _media_info_item_get_detail(stmt, (media_info_h)item);
1138
1139                 if(callback((media_info_h)item, user_data) == false)
1140                 {
1141                         media_info_destroy((media_info_h)item);
1142                         break;
1143                 }
1144
1145                 media_info_destroy((media_info_h)item);
1146         }
1147
1148         SQLITE3_FINALIZE(stmt);
1149
1150         return ret;
1151 }
1152
1153 int _media_db_get_media_group_item_count(const char *group_name, media_group_e group, filter_h filter, int *item_count)
1154 {
1155         int ret = MEDIA_CONTENT_ERROR_NONE;
1156         sqlite3_stmt *stmt = NULL;
1157         filter_s *_filter = NULL;
1158         char complete_select_query[DEFAULT_QUERY_SIZE];
1159         char *select_query = NULL;
1160         char *condition_query = NULL;
1161         char *option_query = NULL;
1162
1163         media_content_debug_func();
1164
1165         if(group_name != NULL)
1166                 select_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_GROUP, __media_db_get_group_name(group), group_name);
1167         else
1168                 select_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_GROUP_NULL, __media_db_get_group_name(group));
1169
1170         if(filter != NULL)
1171         {
1172                 _filter = (filter_s*)filter;
1173
1174                 if(_filter->condition)
1175                 {
1176                         ret = _media_filter_attribute_generate(_content_get_attirbute_handle(), _filter->condition, _filter->condition_collate_type, &condition_query);
1177                         if(ret != MEDIA_CONTENT_ERROR_NONE)
1178                         {
1179                                 sqlite3_free(select_query);
1180                                 return ret;
1181                         }
1182                 }
1183
1184                 ret = _media_filter_attribute_option_generate(_content_get_attirbute_handle(), filter, &option_query);
1185                 if(ret != MEDIA_CONTENT_ERROR_NONE)
1186                 {
1187                         sqlite3_free(select_query);
1188                         return ret;
1189                 }
1190
1191                 if(STRING_VALID(condition_query))
1192                 {
1193                         snprintf(complete_select_query, sizeof(complete_select_query), "%s %s", select_query, QUERY_KEYWORD_AND);
1194                 }
1195                 else
1196                 {
1197                         snprintf(complete_select_query, sizeof(complete_select_query), "%s", select_query);
1198                 }
1199         } else {
1200                 snprintf(complete_select_query, sizeof(complete_select_query), "%s", select_query);
1201         }
1202
1203         SAFE_STRLCAT(complete_select_query, QUERY_KEYWORD_SPACE, sizeof(complete_select_query));
1204         if(STRING_VALID(condition_query))
1205                 SAFE_STRLCAT(complete_select_query, condition_query, sizeof(complete_select_query));
1206         if(STRING_VALID(option_query))
1207                 SAFE_STRLCAT(complete_select_query, option_query, sizeof(complete_select_query));
1208
1209         SAFE_STRLCAT(complete_select_query, QUERY_KEYWORD_BRACKET, sizeof(complete_select_query));
1210
1211         SAFE_FREE(condition_query);
1212         SAFE_FREE(option_query);
1213
1214         ret = _content_query_prepare(&stmt, complete_select_query, condition_query, option_query);
1215         sqlite3_free(select_query);
1216         SAFE_FREE(condition_query);
1217         SAFE_FREE(option_query);
1218         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1219
1220         while(sqlite3_step(stmt) == SQLITE_ROW)
1221         {
1222                 *item_count = (int)sqlite3_column_int(stmt, 0);
1223                 media_content_debug("group item count : [%d]", *item_count);
1224         }
1225
1226         SQLITE3_FINALIZE(stmt);
1227
1228         return ret;
1229 }
1230
1231 int _media_db_get_media_group_item(const char *group_name, media_group_e group, filter_h filter, media_info_cb callback, void *user_data)
1232 {
1233         int ret = MEDIA_CONTENT_ERROR_NONE;
1234         char complete_select_query[DEFAULT_QUERY_SIZE];
1235         char *select_query = NULL;
1236         char *condition_query = NULL;
1237         char *option_query = NULL;
1238         sqlite3_stmt *stmt = NULL;
1239         filter_s *_filter = NULL;
1240
1241         media_content_debug_func();
1242
1243         if(group_name != NULL)
1244                 select_query = sqlite3_mprintf(SELECT_MEDIA_FROM_GROUP, __media_db_get_group_name(group), group_name);
1245         else
1246                 select_query = sqlite3_mprintf(SELECT_MEDIA_FROM_GROUP_NULL, __media_db_get_group_name(group));
1247
1248         if(filter != NULL)
1249         {
1250                 _filter = (filter_s*)filter;
1251
1252                 if(_filter->condition)
1253                 {
1254                         ret = _media_filter_attribute_generate(_content_get_attirbute_handle(), _filter->condition, _filter->condition_collate_type, &condition_query);
1255                         if(ret != MEDIA_CONTENT_ERROR_NONE)
1256                         {
1257                                 sqlite3_free(select_query);
1258                                 return ret;
1259                         }
1260                 }
1261
1262                 ret = _media_filter_attribute_option_generate(_content_get_attirbute_handle(), filter, &option_query);
1263                 if(ret != MEDIA_CONTENT_ERROR_NONE)
1264                 {
1265                         sqlite3_free(select_query);
1266                         return ret;
1267                 }
1268
1269                 if(STRING_VALID(condition_query))
1270                 {
1271                         snprintf(complete_select_query, sizeof(complete_select_query), "%s %s", select_query, QUERY_KEYWORD_AND);
1272                 }
1273                 else
1274                 {
1275                         snprintf(complete_select_query, sizeof(complete_select_query), "%s", select_query);
1276                 }
1277         } else {
1278                 snprintf(complete_select_query, sizeof(complete_select_query), "%s", select_query);
1279         }
1280
1281         ret = _content_query_prepare(&stmt, complete_select_query, condition_query, option_query);
1282         sqlite3_free(select_query);
1283         SAFE_FREE(condition_query);
1284         SAFE_FREE(option_query);
1285         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1286
1287         while(sqlite3_step(stmt) == SQLITE_ROW)
1288         {
1289                 media_info_s *item = (media_info_s*)calloc(1, sizeof(media_info_s));
1290                 if(item == NULL)
1291                 {
1292                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1293                         SQLITE3_FINALIZE(stmt);
1294                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1295                 }
1296
1297                 _media_info_item_get_detail(stmt, (media_info_h)item);
1298
1299                 if(callback((media_info_h)item, user_data) == false)
1300                 {
1301                         media_info_destroy((media_info_h)item);
1302                         break;
1303                 }
1304
1305                 media_info_destroy((media_info_h)item);
1306         }
1307
1308         SQLITE3_FINALIZE(stmt);
1309
1310         return ret;
1311 }