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