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