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