src/media_info.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 #include <unistd.h>
  18 #include <media_content.h>
  19 #include <media-thumbnail.h>
  20 #include <media_info_private.h>
  21 #include <media_util_private.h>
  22 #include <media-svc.h>
  23 #include <media-util.h>
  24
  25 static int __media_info_get_media_info_from_db(char *path, media_info_h media);
  26 static void __media_info_insert_completed_cb(media_request_result_s *result, void *user_data);
  27 static void __media_info_thumbnail_completed_cb(int error, const char *path, void *user_data);
  28 static bool __media_info_delete_batch_cb(media_info_h media, void *user_data);
  29 static int __media_info_insert_batch(media_batch_insert_e insert_type, const char **path_array, unsigned int array_length, media_insert_completed_cb completed_cb, void *user_data);
  30
  31 static int __media_info_get_media_info_from_db(char *path, media_info_h media)
  32 {
  33         int ret = MEDIA_CONTENT_ERROR_NONE;
  34         sqlite3_stmt *stmt = NULL;
  35         char *select_query = NULL;
  36         media_info_s *_media = (media_info_s*)media;
  37
  38         if(_media == NULL)
  39         {
  40                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  41                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  42         }
  43
  44         select_query = sqlite3_mprintf(SELECT_MEDIA_BY_PATH, path);
  45
  46         ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
  47         sqlite3_free(select_query);
  48         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
  49
  50         if(sqlite3_step(stmt) == SQLITE_ROW)
  51         {
  52                 _media_info_item_get_detail(stmt, (media_info_h)_media);
  53                 media_content_debug("New Media ID: %s", _media->media_id);
  54         } else {
  55                 media_content_debug("There's no media!!");
  56         }
  57 /*
  58         while(sqlite3_step(stmt) == SQLITE_ROW)
  59         {
  60                 _media_info_item_get_detail(stmt, (media_info_h)_media);
  61                 media_content_debug("New Media ID: %s", _media->media_id);
  62         }
  63 */
  64         SQLITE3_FINALIZE(stmt);
  65
  66         return ret;
  67 }
  68
  69 static int __media_info_get_media_path_by_id_from_db(const char *media_id, char **path)
  70 {
  71         int ret = MEDIA_CONTENT_ERROR_NONE;
  72         sqlite3_stmt *stmt = NULL;
  73         char *select_query = NULL;
  74
  75         if(!STRING_VALID(media_id))
  76         {
  77                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  78                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  79         }
  80
  81         select_query = sqlite3_mprintf(SELECT_MEDIA_PATH_BY_ID, media_id);
  82
  83         ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
  84         sqlite3_free(select_query);
  85         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
  86
  87         if(sqlite3_step(stmt) == SQLITE_ROW)
  88         {
  89                 if(STRING_VALID((const char *)sqlite3_column_text(stmt, 0)))
  90                         *path = strdup((const char *)sqlite3_column_text(stmt, 0));
  91         } else {
  92                 media_content_debug("There's no media with this ID : %s", media_id);
  93                 *path = NULL;
  94                 ret = MEDIA_CONTENT_ERROR_DB_FAILED;
  95         }
  96
  97         SQLITE3_FINALIZE(stmt);
  98
  99         return ret;
 100 }
 101
 102 static void __media_info_insert_completed_cb(media_request_result_s *result, void *user_data)
 103 {
 104         int ret = MEDIA_CONTENT_ERROR_NONE;
 105         media_insert_cb_s *_cb_data = (media_insert_cb_s *)user_data;
 106
 107         if (_cb_data) {
 108                 if (result) {
 109                         ret = _content_error_capi(MEDIA_CONTENT_TYPE, result->result);
 110                 }
 111
 112                 if (_cb_data->insert_completed_cb)
 113                         _cb_data->insert_completed_cb(ret, _cb_data->user_data);
 114
 115                 if (STRING_VALID(_cb_data->insert_list_path)) {
 116                         if (unlink(_cb_data->insert_list_path) < 0) {
 117                                 media_content_error("failed to delete : %s", strerror(errno));
 118                         }
 119                         SAFE_FREE(_cb_data->insert_list_path);
 120                 }
 121         }
 122
 123         SAFE_FREE(_cb_data);
 124
 125         return;
 126 }
 127
 128 static void __media_info_thumbnail_completed_cb(int error, const char *path, void *user_data)
 129 {
 130         int error_value = MEDIA_CONTENT_ERROR_NONE;
 131
 132         media_thumbnail_cb_s *_thumb_cb = (media_thumbnail_cb_s *)user_data;
 133         media_info_s *media = NULL;
 134
 135         if(_thumb_cb != NULL)
 136         {
 137                 media = _thumb_cb->handle;
 138                 if((media != NULL) && STRING_VALID(path))
 139                 {
 140                         SAFE_FREE(media->thumbnail_path);
 141                         media->thumbnail_path = strdup(path);
 142                 }
 143
 144                 media_content_debug("error [%d], thumbnail_path [%s]", error, path);
 145                 error_value = _content_error_capi(MEDIA_THUMBNAIL_TYPE, error);
 146                 if (_thumb_cb->thumbnail_completed_cb)
 147                         _thumb_cb->thumbnail_completed_cb(error_value, path, _thumb_cb->user_data);
 148         }
 149
 150         SAFE_FREE(_thumb_cb);
 151
 152         return;
 153 }
 154
 155 static bool __media_info_delete_batch_cb(media_info_h media, void *user_data)
 156 {
 157         char *thumb_path = NULL;
 158         media_content_type_e media_type = 0;
 159
 160         if(media == NULL)
 161         {
 162                 media_content_debug("NO Item \n");
 163                 return true;
 164         }
 165
 166         media_info_get_media_type(media, &media_type);
 167         media_content_debug("media_type : [%d] \n", media_type);
 168
 169         media_info_get_thumbnail_path(media, &thumb_path);
 170         if (STRING_VALID(thumb_path)) {
 171                 if (strncmp(MEDIA_CONTENT_THUMB_DEFAULT_PATH, thumb_path, strlen(MEDIA_CONTENT_THUMB_DEFAULT_PATH)) != 0) {
 172                         media_content_debug("Deleting thumbnail : [%s] \n", thumb_path);
 173                         if (unlink(thumb_path) < 0) {
 174                                 media_content_error("failed to delete : %s", strerror(errno));
 175                         }
 176                 }
 177
 178                 SAFE_FREE(thumb_path);
 179         }
 180
 181         return true;
 182 }
 183
 184 void _media_info_item_get_detail(sqlite3_stmt* stmt, media_info_h media)
 185 {
 186 //#define MEDIA_INFO_ITEM "media_uuid, path, file_name, media_type, mime_type, size, added_time, modified_time, thumbnail_path, description,
 187 //                                                      rating, favourite, author, provider, content_name, category, location_tag, age_rating, keyword, is_drm, storage_type, longitude, latitude, altitude, width, height, datetaken, orientation, title, album, artist, genre, composer, year, recorded_date, copyright, track_num, bitrate, duration, played_count, last_played_time, last_played_position, samplerate, channel"
 188
 189         media_info_s *_media = (media_info_s*)media;
 190
 191         if(STRING_VALID((const char *)sqlite3_column_text(stmt, 0)))
 192                 _media->media_id = strdup((const char *)sqlite3_column_text(stmt, 0));
 193
 194         if(STRING_VALID((const char *)sqlite3_column_text(stmt, 1)))
 195                 _media->file_path = strdup((const char *)sqlite3_column_text(stmt, 1));
 196
 197         if(STRING_VALID((const char *)sqlite3_column_text(stmt, 2)))
 198                 _media->display_name = strdup((const char *)sqlite3_column_text(stmt, 2));
 199
 200         _media->media_type = (int)sqlite3_column_int(stmt, 3);
 201
 202         if(STRING_VALID((const char *)sqlite3_column_text(stmt, 4)))
 203                 _media->mime_type = strdup((const char *)sqlite3_column_text(stmt, 4));
 204
 205         _media->size = (unsigned long long)sqlite3_column_int64(stmt, 5);
 206
 207         _media->added_time = (int)sqlite3_column_int(stmt, 6);
 208
 209         _media->modified_time = (int)sqlite3_column_int(stmt, 7);
 210
 211         if(STRING_VALID((const char *)sqlite3_column_text(stmt, 8)))
 212                 _media->thumbnail_path= strdup((const char *)sqlite3_column_text(stmt, 8));
 213
 214         if(STRING_VALID((const char *)sqlite3_column_text(stmt, 9)))
 215                 _media->description = strdup((const char *)sqlite3_column_text(stmt, 9));
 216
 217         _media->rating = (int)sqlite3_column_int(stmt,10);
 218
 219         _media->favourite = (int)sqlite3_column_int(stmt, 11);
 220
 221         if(STRING_VALID((const char *)sqlite3_column_text(stmt, 12)))
 222                 _media->author = strdup((const char *)sqlite3_column_text(stmt, 12));
 223
 224         if(STRING_VALID((const char *)sqlite3_column_text(stmt, 13)))
 225                 _media->provider = strdup((const char *)sqlite3_column_text(stmt, 13));
 226
 227         if(STRING_VALID((const char *)sqlite3_column_text(stmt, 14)))
 228                 _media->content_name = strdup((const char *)sqlite3_column_text(stmt, 14));
 229
 230         if(STRING_VALID((const char *)sqlite3_column_text(stmt, 15)))
 231                 _media->category = strdup((const char *)sqlite3_column_text(stmt, 15));
 232
 233         if(STRING_VALID((const char *)sqlite3_column_text(stmt, 16)))
 234                 _media->location_tag = strdup((const char *)sqlite3_column_text(stmt, 16));
 235
 236         if(STRING_VALID((const char *)sqlite3_column_text(stmt, 17)))
 237                 _media->age_rating = strdup((const char *)sqlite3_column_text(stmt, 17));
 238
 239         if(STRING_VALID((const char *)sqlite3_column_text(stmt, 18)))
 240                 _media->keyword = strdup((const char *)sqlite3_column_text(stmt, 18));
 241
 242         _media->is_drm = (int)sqlite3_column_int(stmt, 19);
 243
 244         _media->storage_type = (int)sqlite3_column_int(stmt, 20);
 245
 246         _media->longitude = (double)sqlite3_column_double(stmt, 21);
 247         _media->latitude = (double)sqlite3_column_double(stmt, 22);
 248         _media->altitude = (double)sqlite3_column_double(stmt, 23);
 249
 250         if(STRING_VALID((const char *)sqlite3_column_text(stmt, 28)))
 251                 _media->title = strdup((const char *)sqlite3_column_text(stmt, 28));
 252
 253         if(_media->media_type == MEDIA_CONTENT_TYPE_IMAGE) {
 254                 _media->image_meta = (image_meta_s *)calloc(1, sizeof(image_meta_s));
 255                 if(_media->image_meta) {
 256                         if(STRING_VALID(_media->media_id))
 257                                 _media->image_meta->media_id = strdup(_media->media_id);
 258
 259                         _media->image_meta->width = sqlite3_column_int(stmt, 24);
 260                         _media->image_meta->height = sqlite3_column_int(stmt, 25);
 261
 262                         if(STRING_VALID((const char *)sqlite3_column_text(stmt, 26)))
 263                                 _media->image_meta->date_taken = strdup((const char *)sqlite3_column_text(stmt, 26));
 264
 265                         _media->image_meta->orientation = sqlite3_column_int(stmt, 27);
 266
 267                         if(STRING_VALID((const char *)sqlite3_column_text(stmt, 28)))
 268                                 _media->image_meta->title = strdup((const char *)sqlite3_column_text(stmt, 28));
 269
 270                         if(STRING_VALID((const char *)sqlite3_column_text(stmt, 44)))
 271                                 _media->image_meta->burst_id = strdup((const char *)sqlite3_column_text(stmt, 44));
 272                 }
 273
 274         } else if(_media->media_type == MEDIA_CONTENT_TYPE_VIDEO) {
 275                 _media->video_meta = (video_meta_s *)calloc(1, sizeof(video_meta_s));
 276                 if(_media->video_meta) {
 277                         if(STRING_VALID(_media->media_id))
 278                                 _media->video_meta->media_id = strdup(_media->media_id);
 279
 280                         if(STRING_VALID((const char *)sqlite3_column_text(stmt, 28)))
 281                                 _media->video_meta->title = strdup((const char *)sqlite3_column_text(stmt, 28));
 282
 283                         if(STRING_VALID((const char *)sqlite3_column_text(stmt, 29)))
 284                                 _media->video_meta->album = strdup((const char *)sqlite3_column_text(stmt, 29));
 285
 286                         if(STRING_VALID((const char *)sqlite3_column_text(stmt, 30)))
 287                                 _media->video_meta->artist = strdup((const char *)sqlite3_column_text(stmt, 30));
 288
 289                         if(STRING_VALID((const char *)sqlite3_column_text(stmt, 31)))
 290                                 _media->video_meta->genre = strdup((const char *)sqlite3_column_text(stmt, 31));
 291
 292                         if(STRING_VALID((const char *)sqlite3_column_text(stmt, 32)))
 293                                 _media->video_meta->composer = strdup((const char *)sqlite3_column_text(stmt, 32));
 294
 295                         if(STRING_VALID((const char *)sqlite3_column_text(stmt, 33)))
 296                                 _media->video_meta->year = strdup((const char *)sqlite3_column_text(stmt, 33));
 297
 298                         if(STRING_VALID((const char *)sqlite3_column_text(stmt, 34)))
 299                                 _media->video_meta->recorded_date = strdup((const char *)sqlite3_column_text(stmt, 34));
 300
 301                         if(STRING_VALID((const char *)sqlite3_column_text(stmt, 35)))
 302                                 _media->video_meta->copyright = strdup((const char *)sqlite3_column_text(stmt, 35));
 303
 304                         if(STRING_VALID((const char *)sqlite3_column_text(stmt, 36)))
 305                                 _media->video_meta->track_num = strdup((const char *)sqlite3_column_text(stmt, 36));
 306
 307                         _media->video_meta->bitrate = sqlite3_column_int(stmt, 37);
 308                         _media->video_meta->duration = sqlite3_column_int(stmt, 38);
 309                         _media->video_meta->played_count = sqlite3_column_int(stmt, 39);
 310                         _media->video_meta->played_time = sqlite3_column_int(stmt, 40);
 311                         _media->video_meta->played_position = sqlite3_column_int(stmt, 41);
 312                         _media->video_meta->width = sqlite3_column_int(stmt, 24);
 313                         _media->video_meta->height = sqlite3_column_int(stmt, 25);
 314                 }
 315
 316         }
 317         else if((_media->media_type == MEDIA_CONTENT_TYPE_MUSIC) || (_media->media_type == MEDIA_CONTENT_TYPE_SOUND)) {
 318                 _media->audio_meta = (audio_meta_s *)calloc(1, sizeof(audio_meta_s));
 319                 if(_media->audio_meta) {
 320                         if(STRING_VALID(_media->media_id))
 321                                 _media->audio_meta->media_id = strdup(_media->media_id);
 322
 323                         if(STRING_VALID((const char *)sqlite3_column_text(stmt, 28)))
 324                                 _media->audio_meta->title = strdup((const char *)sqlite3_column_text(stmt, 28));
 325
 326                         if(STRING_VALID((const char *)sqlite3_column_text(stmt, 29)))
 327                                 _media->audio_meta->album = strdup((const char *)sqlite3_column_text(stmt, 29));
 328
 329                         if(STRING_VALID((const char *)sqlite3_column_text(stmt, 30)))
 330                                 _media->audio_meta->artist = strdup((const char *)sqlite3_column_text(stmt, 30));
 331
 332                         if(STRING_VALID((const char *)sqlite3_column_text(stmt, 31)))
 333                                 _media->audio_meta->genre = strdup((const char *)sqlite3_column_text(stmt, 31));
 334
 335                         if(STRING_VALID((const char *)sqlite3_column_text(stmt, 32)))
 336                                 _media->audio_meta->composer = strdup((const char *)sqlite3_column_text(stmt, 32));
 337
 338                         if(STRING_VALID((const char *)sqlite3_column_text(stmt, 33)))
 339                                 _media->audio_meta->year = strdup((const char *)sqlite3_column_text(stmt, 33));
 340
 341                         if(STRING_VALID((const char *)sqlite3_column_text(stmt, 34)))
 342                                 _media->audio_meta->recorded_date = strdup((const char *)sqlite3_column_text(stmt, 34));
 343
 344                         if(STRING_VALID((const char *)sqlite3_column_text(stmt, 35)))
 345                                 _media->audio_meta->copyright = strdup((const char *)sqlite3_column_text(stmt, 35));
 346
 347                         if(STRING_VALID((const char *)sqlite3_column_text(stmt, 36)))
 348                                 _media->audio_meta->track_num = strdup((const char *)sqlite3_column_text(stmt, 36));
 349
 350                         _media->audio_meta->bitrate = sqlite3_column_int(stmt, 37);
 351                         _media->audio_meta->duration = sqlite3_column_int(stmt, 38);
 352                         _media->audio_meta->played_count = sqlite3_column_int(stmt, 39);
 353                         _media->audio_meta->played_time = sqlite3_column_int(stmt, 40);
 354                         _media->audio_meta->played_position = sqlite3_column_int(stmt, 41);
 355                         _media->audio_meta->samplerate = sqlite3_column_int(stmt, 42);
 356                         _media->audio_meta->channel = sqlite3_column_int(stmt, 43);
 357                 }
 358
 359         }
 360 }
 361
 362 int media_info_insert_to_db (const char *path, media_info_h *info)
 363 {
 364         int ret = MEDIA_CONTENT_ERROR_NONE;
 365
 366         if(!STRING_VALID(path))
 367         {
 368                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 369                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 370         }
 371
 372         if(info == NULL)
 373         {
 374                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 375                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 376         }
 377
 378 #if 0
 379         media_content_debug("Register: %s", path);
 380         ret = media_file_register(path);
 381         if(ret != MS_MEDIA_ERR_NONE)
 382         {
 383                 media_content_error("media_file_register failed");
 384                 return _content_error_capi(MEDIA_REGISTER_TYPE, ret);
 385         }
 386
 387 #else
 388         char *_path = strdup(path);
 389         if (_path == NULL) {
 390                 media_content_error("strdup failed : %s", path);
 391                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 392         }
 393
 394         ret = media_svc_check_item_exist_by_path(_content_get_db_handle(), _path);
 395         if (ret == MEDIA_INFO_ERROR_DATABASE_NO_RECORD) {
 396                 media_content_debug("media_svc_check_item_exist_by_path : no record : %s", _path);
 397
 398                 media_svc_storage_type_e storage_type;
 399
 400                 ret = media_svc_get_storage_type(_path, &storage_type);
 401                 if (ret < 0) {
 402                         media_content_error("media_svc_get_storage_type failed : %d (%s)", ret, _path);
 403                         SAFE_FREE(_path);
 404                         return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 405                 }
 406
 407                 media_content_debug("media_svc_insert_item_immediately: %s", _path);
 408                 ret = media_svc_insert_item_immediately(_content_get_db_handle(), storage_type, _path);
 409
 410                 if (ret < 0) {
 411                         media_content_error("media_svc_insert_item_immediately failed : %d (%s)", ret, _path);
 412                         SAFE_FREE(_path);
 413                         return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 414                 }
 415         } else if (ret != MEDIA_INFO_ERROR_NONE) {
 416                 media_content_error("media_svc_check_item_exist_by_path failed : %d (%s)", ret, _path);
 417                 SAFE_FREE(_path);
 418                 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 419         }
 420 #endif
 421
 422         media_info_s *_media = (media_info_s*)calloc(1, sizeof(media_info_s));
 423         if(_media == NULL)
 424         {
 425                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 426                 SAFE_FREE(_path);
 427                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 428         }
 429
 430         _media->file_path = _path;
 431         if(_media->file_path == NULL)
 432         {
 433                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 434                 SAFE_FREE(_media);
 435                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 436         }
 437
 438         ret = __media_info_get_media_info_from_db(_media->file_path, (media_info_h)_media);
 439
 440         *info = (media_info_h)_media;
 441         return ret;
 442 }
 443
 444 static int __media_info_insert_batch(media_batch_insert_e insert_type, const char **path_array,
 445                                         unsigned int array_length,
 446                                         media_insert_completed_cb completed_cb,
 447                                         void *user_data)
 448 {
 449         int ret = MEDIA_CONTENT_ERROR_NONE;
 450         FILE *fp = NULL;
 451         char list_path[255] = {0,};
 452         int idx = 0;
 453         int nwrites = 0;
 454
 455         for (idx = 0; idx < BATCH_REQUEST_MAX; idx++) {
 456                 snprintf(list_path, sizeof(list_path), "%s/request-%ld-%d", MEDIA_CONTENT_INSERT_FILES_PATH, media_content_gettid(), idx);
 457
 458                 if (g_file_test(list_path, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR)) {
 459                         memset(list_path, 0x00, sizeof(list_path));
 460                         continue;
 461                 } else {
 462                         media_content_debug("The request file list path : %s", list_path);
 463                         break;
 464                 }
 465         }
 466
 467         if (idx == BATCH_REQUEST_MAX) {
 468                 media_content_error("Too many batch request for one thread");
 469                 return MEDIA_CONTENT_ERROR_DB_BUSY;
 470         }
 471
 472         fp = fopen(list_path, "w");
 473         if (fp == NULL) {
 474                 media_content_error("failed to open file : %s [%s]", list_path, strerror(errno));
 475                 return MEDIA_CONTENT_ERROR_INVALID_OPERATION;
 476         }
 477
 478         for (idx = 0; idx < array_length; idx++) {
 479                 if (STRING_VALID(path_array[idx])) {
 480                         int size = strlen(path_array[idx]);
 481
 482                         nwrites = fwrite(path_array[idx], 1, size, fp);
 483                         if (nwrites != size) {
 484                                 media_content_error("failed to write thumbnail : %s", strerror(errno));
 485                                 fclose(fp);
 486                                 if (unlink(list_path) < 0) {
 487                                         media_content_error("failed to delete : %s", strerror(errno));
 488                                 }
 489                                 return MEDIA_CONTENT_ERROR_INVALID_OPERATION;
 490                         }
 491
 492                         nwrites = fwrite("\n", 1, 1, fp);
 493                         if (nwrites != 1) {
 494                                 media_content_error("failed to write thumbnail : %s", strerror(errno));
 495                                 fclose(fp);
 496                                 if (unlink(list_path) < 0) {
 497                                         media_content_error("failed to delete : %s", strerror(errno));
 498                                 }
 499                                 return MEDIA_CONTENT_ERROR_INVALID_OPERATION;
 500                         }
 501                 } else {
 502                         media_content_error("path[%d] is invalid string", idx);
 503                 }
 504         }
 505
 506         fclose(fp);
 507
 508         media_insert_cb_s *_cb_data = (media_insert_cb_s *)calloc(1, sizeof(media_insert_cb_s));
 509         _cb_data->insert_completed_cb = completed_cb;
 510         _cb_data->user_data = user_data;
 511         _cb_data->insert_list_path = strdup(list_path);
 512
 513         if(insert_type == MEDIA_BATCH_INSERT_NORMAL)
 514                 ret = media_files_register(list_path, __media_info_insert_completed_cb, _cb_data);
 515         else if(insert_type == MEDIA_BATCH_INSERT_BURSTSHOT)
 516                 ret = media_burstshot_register(list_path, __media_info_insert_completed_cb, _cb_data);
 517         else
 518                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 519
 520         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 521                 media_content_error("media_files_register failed : %d", ret);
 522                 if (unlink(list_path) < 0) {
 523                         media_content_error("failed to delete : %s", strerror(errno));
 524                 }
 525                 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 526         }
 527
 528         return ret;
 529 }
 530
 531 int media_info_insert_batch_to_db(
 532                                         const char **path_array,
 533                                         unsigned int array_length,
 534                                         media_insert_completed_cb completed_cb,
 535                                         void *user_data)
 536 {
 537         if (path_array == NULL)
 538         {
 539                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 540                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 541         }
 542
 543         if (array_length <= 0)
 544         {
 545                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 546                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 547         }
 548
 549         return __media_info_insert_batch(MEDIA_BATCH_INSERT_NORMAL, path_array, array_length, completed_cb, user_data);
 550 }
 551
 552 int media_info_insert_burst_shot_to_db(const char **path_array, unsigned int array_length, media_insert_burst_shot_completed_cb callback, void *user_data)
 553 {
 554         if (path_array == NULL)
 555         {
 556                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 557                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 558         }
 559
 560         if (array_length <= 0)
 561         {
 562                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 563                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 564         }
 565
 566         return __media_info_insert_batch(MEDIA_BATCH_INSERT_BURSTSHOT, path_array, array_length, callback, user_data);
 567 }
 568
 569 int media_info_delete_from_db(const char *media_id)
 570 {
 571         int ret = MEDIA_CONTENT_ERROR_NONE;
 572
 573         if(!STRING_VALID(media_id))
 574         {
 575                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 576                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 577         }
 578
 579 #if 0
 580         char *query_string = NULL;
 581         query_string = sqlite3_mprintf(DELETE_MEDIA_FROM_MEDIA, media_id);
 582
 583         ret = _content_query_sql(query_string);
 584
 585         sqlite3_free(query_string);
 586
 587         return ret;
 588 #else
 589         char *path = NULL;
 590
 591         ret = __media_info_get_media_path_by_id_from_db(media_id, &path);
 592         if (ret < MEDIA_CONTENT_ERROR_NONE) {
 593                 media_content_error("__media_info_get_media_path_by_id_from_db failed : %d", ret);
 594                 SAFE_FREE(path);
 595                 return ret;
 596         }
 597
 598         ret = media_svc_delete_item_by_path(_content_get_db_handle(), path);
 599         SAFE_FREE(path);
 600
 601         return _content_error_capi(ret,MEDIA_CONTENT_TYPE);
 602 #endif
 603 }
 604
 605 int media_info_delete_batch_from_db(filter_h filter)
 606 {
 607         int ret = MEDIA_CONTENT_ERROR_NONE;
 608
 609         char *query_string = NULL;
 610         filter_s *_filter = NULL;
 611         attribute_h attr;
 612         char *condition_query = NULL;
 613
 614         if(filter == NULL)
 615         {
 616                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 617                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 618         }
 619
 620         /* Delete thumbnail of each item */
 621         ret = _media_db_get_group_item(NULL, filter, __media_info_delete_batch_cb, NULL, MEDIA_GROUP_NONE);
 622
 623         _filter = (filter_s*)filter;
 624         attr = _content_get_attirbute_handle();
 625
 626         if(_filter->condition)
 627         {
 628                 ret = _media_filter_attribute_generate(attr, _filter->condition, _filter->condition_collate_type, &condition_query);
 629                 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 630         }
 631
 632         if(STRING_VALID(condition_query))
 633         {
 634                 query_string = sqlite3_mprintf(DELETE_MEDIA_FROM_MEDIA_BATCH, condition_query);
 635         }
 636         else
 637         {
 638                 SAFE_FREE(condition_query);
 639                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 640         }
 641
 642         ret = _content_query_sql(query_string);
 643         if (ret == MEDIA_CONTENT_ERROR_NONE) {
 644                 /*  Send notification for this
 645                         In this case, send noti for internal storage and external storage
 646                 */
 647                 media_content_debug("Batch deletion is successfull. Send notification for this");
 648                 media_db_update_send(getpid(), MS_MEDIA_ITEM_DIRECTORY, MS_MEDIA_ITEM_UPDATE, MEDIA_CONTENT_PATH_PHONE, NULL, -1, NULL);
 649                 media_db_update_send(getpid(), MS_MEDIA_ITEM_DIRECTORY, MS_MEDIA_ITEM_UPDATE, MEDIA_CONTENT_PATH_MMC, NULL, -1, NULL);
 650         }
 651
 652         SAFE_FREE(condition_query);
 653         sqlite3_free(query_string);
 654
 655         return ret;
 656 }
 657
 658 int media_info_destroy(media_info_h media)
 659 {
 660         int ret = MEDIA_CONTENT_ERROR_NONE;
 661         media_info_s *_media = (media_info_s*)media;
 662
 663         if(_media)
 664         {
 665                 SAFE_FREE(_media->media_id);
 666                 SAFE_FREE(_media->file_path);
 667                 SAFE_FREE(_media->display_name);
 668                 SAFE_FREE(_media->mime_type);
 669                 SAFE_FREE(_media->thumbnail_path);
 670                 SAFE_FREE(_media->description);
 671                 SAFE_FREE(_media->author);
 672                 SAFE_FREE(_media->provider);
 673                 SAFE_FREE(_media->content_name);
 674                 SAFE_FREE(_media->category);
 675                 SAFE_FREE(_media->location_tag);
 676                 SAFE_FREE(_media->age_rating);
 677                 SAFE_FREE(_media->keyword);
 678                 SAFE_FREE(_media->title);
 679
 680                 if(_media->image_meta) {
 681                         SAFE_FREE(_media->image_meta->media_id);
 682                         SAFE_FREE(_media->image_meta->date_taken);
 683                         SAFE_FREE(_media->image_meta->burst_id);
 684
 685                         SAFE_FREE(_media->image_meta);
 686                 } else if(_media->video_meta) {
 687                         SAFE_FREE(_media->video_meta->media_id);
 688                         SAFE_FREE(_media->video_meta->title);
 689                         SAFE_FREE(_media->video_meta->album);
 690                         SAFE_FREE(_media->video_meta->artist);
 691                         SAFE_FREE(_media->video_meta->genre);
 692                         SAFE_FREE(_media->video_meta->composer);
 693                         SAFE_FREE(_media->video_meta->year);
 694                         SAFE_FREE(_media->video_meta->recorded_date);
 695                         SAFE_FREE(_media->video_meta->copyright);
 696                         SAFE_FREE(_media->video_meta->track_num);
 697
 698                         SAFE_FREE(_media->video_meta);
 699                 } else if(_media->audio_meta) {
 700                         SAFE_FREE(_media->audio_meta->media_id);
 701                         SAFE_FREE(_media->audio_meta->title);
 702                         SAFE_FREE(_media->audio_meta->album);
 703                         SAFE_FREE(_media->audio_meta->artist);
 704                         SAFE_FREE(_media->audio_meta->genre);
 705                         SAFE_FREE(_media->audio_meta->composer);
 706                         SAFE_FREE(_media->audio_meta->year);
 707                         SAFE_FREE(_media->audio_meta->recorded_date);
 708                         SAFE_FREE(_media->audio_meta->copyright);
 709                         SAFE_FREE(_media->audio_meta->track_num);
 710
 711                         SAFE_FREE(_media->audio_meta);
 712                 }
 713
 714                 SAFE_FREE(_media);
 715
 716                 ret = MEDIA_CONTENT_ERROR_NONE;
 717         }
 718         else
 719         {
 720                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 721                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 722         }
 723
 724         return ret;
 725 }
 726
 727 int media_info_clone(media_info_h *dst, media_info_h src)
 728 {
 729         int ret = MEDIA_CONTENT_ERROR_NONE;
 730         media_info_s *_src = (media_info_s*)src;
 731
 732
 733         if(_src != NULL)
 734         {
 735                 media_info_s *_dst = (media_info_s*)calloc(1, sizeof(media_info_s));
 736
 737                 if(_dst == NULL)
 738                 {
 739                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 740                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 741                 }
 742
 743                 if(STRING_VALID(_src->media_id))
 744                 {
 745                         _dst->media_id = strdup(_src->media_id);
 746                         if(_dst->media_id == NULL)
 747                         {
 748                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 749                                 media_info_destroy((media_info_h)_dst);
 750                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 751                         }
 752                 }
 753                 if(STRING_VALID(_src->file_path))
 754                 {
 755                         _dst->file_path = strdup(_src->file_path);
 756                         if(_dst->file_path == NULL)
 757                         {
 758                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 759                                 media_info_destroy((media_info_h)_dst);
 760                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 761                         }
 762                 }
 763                 if(STRING_VALID(_src->display_name))
 764                 {
 765                         _dst->display_name = strdup(_src->display_name);
 766                         if(_dst->display_name == NULL)
 767                         {
 768                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 769                                 media_info_destroy((media_info_h)_dst);
 770                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 771                         }
 772                 }
 773                 if(STRING_VALID(_src->mime_type))
 774                 {
 775                         _dst->mime_type = strdup(_src->mime_type);
 776                         if(_dst->mime_type == NULL)
 777                         {
 778                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 779                                 media_info_destroy((media_info_h)_dst);
 780                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 781                         }
 782                 }
 783                 if(STRING_VALID(_src->thumbnail_path))
 784                 {
 785                         _dst->thumbnail_path = strdup(_src->thumbnail_path);
 786                         if(_dst->thumbnail_path == NULL)
 787                         {
 788                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 789                                 media_info_destroy((media_info_h)_dst);
 790                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 791                         }
 792                 }
 793                 if(STRING_VALID(_src->description))
 794                 {
 795                         _dst->description = strdup(_src->description);
 796                         if(_dst->description == NULL)
 797                         {
 798                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 799                                 media_info_destroy((media_info_h)_dst);
 800                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 801                         }
 802                 }
 803                 if(STRING_VALID(_src->title))
 804                 {
 805                         _dst->title = strdup(_src->title);
 806                         if(_dst->title == NULL)
 807                         {
 808                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 809                                 media_info_destroy((media_info_h)_dst);
 810                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 811                         }
 812                 }
 813                 if(STRING_VALID(_src->author))
 814                 {
 815                         _dst->author = strdup(_src->author);
 816                         if(_dst->author == NULL)
 817                         {
 818                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 819                                 media_info_destroy((media_info_h)_dst);
 820                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 821                         }
 822                 }
 823                 if(STRING_VALID(_src->provider))
 824                 {
 825                         _dst->provider = strdup(_src->provider);
 826                         if(_dst->provider == NULL)
 827                         {
 828                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 829                                 media_info_destroy((media_info_h)_dst);
 830                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 831                         }
 832                 }
 833                 if(STRING_VALID(_src->content_name))
 834                 {
 835                         _dst->content_name = strdup(_src->content_name);
 836                         if(_dst->content_name == NULL)
 837                         {
 838                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 839                                 media_info_destroy((media_info_h)_dst);
 840                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 841                         }
 842                 }
 843                 if(STRING_VALID(_src->category))
 844                 {
 845                         _dst->category = strdup(_src->category);
 846                         if(_dst->category == NULL)
 847                         {
 848                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 849                                 media_info_destroy((media_info_h)_dst);
 850                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 851                         }
 852                 }
 853                 if(STRING_VALID(_src->location_tag))
 854                 {
 855                         _dst->location_tag = strdup(_src->location_tag);
 856                         if(_dst->location_tag == NULL)
 857                         {
 858                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 859                                 media_info_destroy((media_info_h)_dst);
 860                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 861                         }
 862                 }
 863                 if(STRING_VALID(_src->age_rating))
 864                 {
 865                         _dst->age_rating = strdup(_src->age_rating);
 866                         if(_dst->age_rating == NULL)
 867                         {
 868                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 869                                 media_info_destroy((media_info_h)_dst);
 870                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 871                         }
 872                 }
 873                 if(STRING_VALID(_src->keyword))
 874                 {
 875                         _dst->keyword = strdup(_src->keyword);
 876                         if(_dst->keyword == NULL)
 877                         {
 878                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 879                                 media_info_destroy((media_info_h)_dst);
 880                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 881                         }
 882                 }
 883
 884                 _dst->media_type = _src->media_type;
 885                 _dst->size = _src->size;
 886                 _dst->added_time = _src->added_time;
 887                 _dst->modified_time = _src->modified_time;
 888                 _dst->longitude = _src->longitude;
 889                 _dst->latitude = _src->latitude;
 890                 _dst->altitude = _src->altitude;
 891                 _dst->rating = _src->rating;
 892                 _dst->favourite = _src->favourite;
 893                 _dst->is_drm = _src->is_drm;
 894                 _dst->storage_type = _src->storage_type;
 895
 896                 if(_src->media_type == MEDIA_CONTENT_TYPE_IMAGE && _src->image_meta) {
 897                         _dst->image_meta = (image_meta_s *)calloc(1, sizeof(image_meta_s));
 898                         if(_dst->image_meta == NULL)
 899                         {
 900                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 901                                 media_info_destroy((media_info_h)_dst);
 902                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 903                         }
 904
 905                         if(STRING_VALID(_src->image_meta->media_id))
 906                         {
 907                                 _dst->image_meta->media_id = strdup(_src->image_meta->media_id);
 908                                 if(_dst->image_meta->media_id == NULL)
 909                                 {
 910                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 911                                         media_info_destroy((media_info_h)_dst);
 912                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 913                                 }
 914                         }
 915
 916                         if(STRING_VALID(_src->image_meta->date_taken))
 917                         {
 918                                 _dst->image_meta->date_taken = strdup(_src->image_meta->date_taken);
 919                                 if(_dst->image_meta->date_taken == NULL)
 920                                 {
 921                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 922                                         media_info_destroy((media_info_h)_dst);
 923                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 924                                 }
 925                         }
 926
 927                         if(STRING_VALID(_src->image_meta->burst_id))
 928                         {
 929                                 _dst->image_meta->burst_id = strdup(_src->image_meta->burst_id);
 930                                 if(_dst->image_meta->burst_id == NULL)
 931                                 {
 932                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 933                                         media_info_destroy((media_info_h)_dst);
 934                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 935                                 }
 936                         }
 937                         _dst->image_meta->width = _src->image_meta->width;
 938                         _dst->image_meta->height = _src->image_meta->height;
 939                         _dst->image_meta->orientation = _src->image_meta->orientation;
 940
 941                 } else if(_src->media_type == MEDIA_CONTENT_TYPE_VIDEO && _src->video_meta) {
 942                         _dst->video_meta = (video_meta_s *)calloc(1, sizeof(video_meta_s));
 943                         if(_dst->video_meta == NULL)
 944                         {
 945                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 946                                 media_info_destroy((media_info_h)_dst);
 947                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 948                         }
 949
 950                         if(STRING_VALID(_src->video_meta->media_id))
 951                         {
 952                                 _dst->video_meta->media_id = strdup(_src->video_meta->media_id);
 953                                 if(_dst->video_meta->media_id == NULL)
 954                                 {
 955                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 956                                         media_info_destroy((media_info_h)_dst);
 957                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 958                                 }
 959                         }
 960                         if(STRING_VALID(_src->video_meta->title))
 961                         {
 962                                 _dst->video_meta->title = strdup(_src->video_meta->title);
 963                                 if(_dst->video_meta->title == NULL)
 964                                 {
 965                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 966                                         media_info_destroy((media_info_h)_dst);
 967                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 968                                 }
 969                         }
 970                         if(STRING_VALID(_src->video_meta->album))
 971                         {
 972                                 _dst->video_meta->album = strdup(_src->video_meta->album);
 973                                 if(_dst->video_meta->album == NULL)
 974                                 {
 975                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 976                                         media_info_destroy((media_info_h)_dst);
 977                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 978                                 }
 979                         }
 980                         if(STRING_VALID(_src->video_meta->artist))
 981                         {
 982                                 _dst->video_meta->artist = strdup(_src->video_meta->artist);
 983                                 if(_dst->video_meta->artist == NULL)
 984                                 {
 985                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 986                                         media_info_destroy((media_info_h)_dst);
 987                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 988                                 }
 989                         }
 990                         if(STRING_VALID(_src->video_meta->genre))
 991                         {
 992                                 _dst->video_meta->genre = strdup(_src->video_meta->genre);
 993                                 if(_dst->video_meta->genre == NULL)
 994                                 {
 995                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 996                                         media_info_destroy((media_info_h)_dst);
 997                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 998                                 }
 999                         }
1000                         if(STRING_VALID(_src->video_meta->composer))
1001                         {
1002                                 _dst->video_meta->composer = strdup(_src->video_meta->composer);
1003                                 if(_dst->video_meta->composer == NULL)
1004                                 {
1005                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1006                                         media_info_destroy((media_info_h)_dst);
1007                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1008                                 }
1009                         }
1010                         if(STRING_VALID(_src->video_meta->year))
1011                         {
1012                                 _dst->video_meta->year = strdup(_src->video_meta->year);
1013                                 if(_dst->video_meta->year == NULL)
1014                                 {
1015                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1016                                         media_info_destroy((media_info_h)_dst);
1017                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1018                                 }
1019                         }
1020                         if(STRING_VALID(_src->video_meta->recorded_date))
1021                         {
1022                                 _dst->video_meta->recorded_date = strdup(_src->video_meta->recorded_date);
1023                                 if(_dst->video_meta->recorded_date == NULL)
1024                                 {
1025                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1026                                         media_info_destroy((media_info_h)_dst);
1027                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1028                                 }
1029                         }
1030                         if(STRING_VALID(_src->video_meta->copyright))
1031                         {
1032                                 _dst->video_meta->copyright = strdup(_src->video_meta->copyright);
1033                                 if(_dst->video_meta->copyright == NULL)
1034                                 {
1035                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1036                                         media_info_destroy((media_info_h)_dst);
1037                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1038                                 }
1039                         }
1040                         if(STRING_VALID(_src->video_meta->track_num))
1041                         {
1042                                 _dst->video_meta->track_num = strdup(_src->video_meta->track_num);
1043                                 if(_dst->video_meta->track_num == NULL)
1044                                 {
1045                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1046                                         media_info_destroy((media_info_h)_dst);
1047                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1048                                 }
1049                         }
1050
1051                         _dst->video_meta->width = _src->video_meta->width;
1052                         _dst->video_meta->height = _src->video_meta->height;
1053                         _dst->video_meta->duration = _src->video_meta->duration;
1054                         _dst->video_meta->bitrate = _src->video_meta->bitrate;
1055                         _dst->video_meta->played_count = _src->video_meta->played_count;
1056                         _dst->video_meta->played_time = _src->video_meta->played_time;
1057                         _dst->video_meta->played_position = _src->video_meta->played_position;
1058
1059                 } else if((_src->media_type == MEDIA_CONTENT_TYPE_MUSIC || _src->media_type == MEDIA_CONTENT_TYPE_SOUND) && _src->audio_meta) {
1060                         _dst->audio_meta = (audio_meta_s *)calloc(1, sizeof(audio_meta_s));
1061                         if(_dst->audio_meta == NULL)
1062                         {
1063                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1064                                 media_info_destroy((media_info_h)_dst);
1065                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1066                         }
1067
1068                         if(STRING_VALID(_src->audio_meta->media_id))
1069                         {
1070                                 _dst->audio_meta->media_id = strdup(_src->audio_meta->media_id);
1071                                 if(_dst->audio_meta->media_id == NULL)
1072                                 {
1073                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1074                                         media_info_destroy((media_info_h)_dst);
1075                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1076                                 }
1077                         }
1078                         if(STRING_VALID(_src->audio_meta->title))
1079                         {
1080                                 _dst->audio_meta->title = strdup(_src->audio_meta->title);
1081                                 if(_dst->audio_meta->title == NULL)
1082                                 {
1083                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1084                                         media_info_destroy((media_info_h)_dst);
1085                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1086                                 }
1087                         }
1088                         if(STRING_VALID(_src->audio_meta->album))
1089                         {
1090                                 _dst->audio_meta->album = strdup(_src->audio_meta->album);
1091                                 if(_dst->audio_meta->album == NULL)
1092                                 {
1093                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1094                                         media_info_destroy((media_info_h)_dst);
1095                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1096                                 }
1097                         }
1098                         if(STRING_VALID(_src->audio_meta->artist))
1099                         {
1100                                 _dst->audio_meta->artist = strdup(_src->audio_meta->artist);
1101                                 if(_dst->audio_meta->artist == NULL)
1102                                 {
1103                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1104                                         media_info_destroy((media_info_h)_dst);
1105                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1106                                 }
1107                         }
1108                         if(STRING_VALID(_src->audio_meta->genre))
1109                         {
1110                                 _dst->audio_meta->genre = strdup(_src->audio_meta->genre);
1111                                 if(_dst->audio_meta->genre == NULL)
1112                                 {
1113                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1114                                         media_info_destroy((media_info_h)_dst);
1115                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1116                                 }
1117                         }
1118                         if(STRING_VALID(_src->audio_meta->composer))
1119                         {
1120                                 _dst->audio_meta->composer = strdup(_src->audio_meta->composer);
1121                                 if(_dst->audio_meta->composer == NULL)
1122                                 {
1123                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1124                                         media_info_destroy((media_info_h)_dst);
1125                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1126                                 }
1127                         }
1128                         if(STRING_VALID(_src->audio_meta->year))
1129                         {
1130                                 _dst->audio_meta->year = strdup(_src->audio_meta->year);
1131                                 if(_dst->audio_meta->year == NULL)
1132                                 {
1133                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1134                                         media_info_destroy((media_info_h)_dst);
1135                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1136                                 }
1137                         }
1138                         if(STRING_VALID(_src->audio_meta->recorded_date))
1139                         {
1140                                 _dst->audio_meta->recorded_date = strdup(_src->audio_meta->recorded_date);
1141                                 if(_dst->audio_meta->recorded_date == NULL)
1142                                 {
1143                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1144                                         media_info_destroy((media_info_h)_dst);
1145                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1146                                 }
1147                         }
1148                         if(STRING_VALID(_src->audio_meta->copyright))
1149                         {
1150                                 _dst->audio_meta->copyright = strdup(_src->audio_meta->copyright);
1151                                 if(_dst->audio_meta->copyright == NULL)
1152                                 {
1153                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1154                                         media_info_destroy((media_info_h)_dst);
1155                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1156                                 }
1157                         }
1158                         if(STRING_VALID(_src->audio_meta->track_num))
1159                         {
1160                                 _dst->audio_meta->track_num = strdup(_src->audio_meta->track_num);
1161                                 if(_dst->audio_meta->track_num == NULL)
1162                                 {
1163                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1164                                         media_info_destroy((media_info_h)_dst);
1165                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1166                                 }
1167                         }
1168
1169                         _dst->audio_meta->channel = _src->audio_meta->channel;
1170                         _dst->audio_meta->samplerate = _src->audio_meta->samplerate;
1171                         _dst->audio_meta->duration = _src->audio_meta->duration;
1172                         _dst->audio_meta->bitrate = _src->audio_meta->bitrate;
1173                         _dst->audio_meta->played_count = _src->audio_meta->played_count;
1174                         _dst->audio_meta->played_time = _src->audio_meta->played_time;
1175                         _dst->audio_meta->played_position = _src->audio_meta->played_position;
1176
1177                 }
1178                 *dst = (media_info_h)_dst;
1179
1180                 ret = MEDIA_CONTENT_ERROR_NONE;
1181         }
1182         else
1183         {
1184                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1185                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1186         }
1187
1188         return ret;
1189 }
1190
1191 int media_info_get_media_count_from_db(filter_h filter, int *media_count)
1192 {
1193         int ret = MEDIA_CONTENT_ERROR_NONE;
1194
1195         media_content_debug_func();
1196
1197         if(media_count == NULL)
1198         {
1199                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1200                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1201
1202                 return ret;
1203         }
1204
1205         ret = _media_db_get_group_item_count(NULL, filter, MEDIA_GROUP_NONE, media_count);
1206
1207         return ret;
1208 }
1209
1210 int media_info_foreach_media_from_db(filter_h filter, media_info_cb callback, void *user_data)
1211 {
1212         int ret = MEDIA_CONTENT_ERROR_NONE;
1213
1214         media_content_debug_func();
1215
1216         if(callback == NULL)
1217         {
1218                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1219                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1220         }
1221
1222         ret = _media_db_get_group_item(NULL, filter, callback, user_data, MEDIA_GROUP_NONE);
1223
1224         return ret;
1225 }
1226
1227 int media_info_get_tag_count_from_db(const char *media_id, filter_h filter, int *tag_count)
1228 {
1229         int ret = MEDIA_CONTENT_ERROR_NONE;
1230
1231         media_content_debug_func();
1232
1233         if(STRING_VALID(media_id) && tag_count)
1234         {
1235                 ret = _media_db_get_group_item_count(media_id, filter, MEDIA_GROUP_TAG_BY_MEDIA_ID, tag_count);
1236         }
1237         else
1238         {
1239                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1240                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1241         }
1242
1243         return ret;
1244 }
1245
1246 int media_info_foreach_tag_from_db(const char *media_id, filter_h filter, media_tag_cb callback, void *user_data)
1247 {
1248         int ret = MEDIA_CONTENT_ERROR_NONE;
1249
1250         media_content_debug_func();
1251
1252         if((callback != NULL) && STRING_VALID(media_id))
1253         {
1254                 ret = _media_db_get_tag(media_id, filter, callback, user_data);
1255         }
1256         else
1257         {
1258                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1259                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1260         }
1261
1262         return ret;
1263 }
1264
1265 int media_info_get_bookmark_count_from_db(const char *media_id, filter_h filter, int *bookmark_count)
1266 {
1267         int ret = MEDIA_CONTENT_ERROR_NONE;
1268
1269         media_content_debug_func();
1270
1271         if(STRING_VALID(media_id) && bookmark_count)
1272         {
1273                 ret = _media_db_get_group_item_count(media_id, filter, MEDIA_GROUP_BOOKMARK_BY_MEDIA_ID, bookmark_count);
1274         }
1275         else
1276         {
1277                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1278                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1279         }
1280
1281         return ret;
1282 }
1283
1284 int media_info_foreach_bookmark_from_db (const char *media_id, filter_h filter, media_bookmark_cb callback, void *user_data)
1285 {
1286         int ret = MEDIA_CONTENT_ERROR_NONE;
1287
1288         media_content_debug_func();
1289
1290         if((callback != NULL) && STRING_VALID(media_id))
1291         {
1292                 ret = _media_db_get_bookmark(media_id, filter, callback, user_data);
1293         }
1294         else
1295         {
1296                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1297                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1298         }
1299
1300         return ret;
1301 }
1302
1303 int media_info_get_image(media_info_h media, image_meta_h *image)
1304 {
1305         int ret = MEDIA_CONTENT_ERROR_NONE;
1306
1307         media_info_s *_media = (media_info_s*)media;
1308
1309         if(_media == NULL)
1310         {
1311                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1312                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1313         }
1314
1315         if(_media->media_type != MEDIA_CONTENT_TYPE_IMAGE)
1316         {
1317                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1318                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1319         }
1320
1321         if(_media->image_meta == NULL)
1322         {
1323                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1324                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1325         }
1326
1327         image_meta_s *_image = (image_meta_s*)calloc(1, sizeof(image_meta_s));
1328
1329         if(_image == NULL)
1330         {
1331                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1332                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1333         }
1334
1335         if(STRING_VALID(_media->media_id)) {
1336                 _image->media_id = strdup(_media->media_id);
1337         }
1338
1339         _image->width = _media->image_meta->width;
1340         _image->height = _media->image_meta->height;
1341         _image->orientation = _media->image_meta->orientation;
1342
1343         if(STRING_VALID(_media->image_meta->date_taken)) {
1344                 _image->date_taken = strdup(_media->image_meta->date_taken);
1345         }
1346
1347         if(STRING_VALID(_media->image_meta->title)) {
1348                 _image->title = strdup(_media->image_meta->title);
1349         }
1350
1351         if(STRING_VALID(_media->image_meta->burst_id)) {
1352                 _image->burst_id = strdup(_media->image_meta->burst_id);
1353         }
1354
1355         *image = (image_meta_h)_image;
1356
1357         return ret;
1358 }
1359
1360 int media_info_get_video(media_info_h media, video_meta_h *video)
1361 {
1362         int ret = MEDIA_CONTENT_ERROR_NONE;
1363
1364         media_info_s *_media = (media_info_s*)media;
1365
1366         if(_media == NULL)
1367         {
1368                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1369                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1370         }
1371
1372         if(_media->media_type != MEDIA_CONTENT_TYPE_VIDEO)
1373         {
1374                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1375                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1376         }
1377
1378         if(_media->video_meta == NULL)
1379         {
1380                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1381                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1382         }
1383
1384         video_meta_s *_video = (video_meta_s*)calloc(1, sizeof(video_meta_s));
1385
1386         if(_video == NULL)
1387         {
1388                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1389                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1390         }
1391
1392         if(STRING_VALID(_media->media_id)) {
1393                 _video->media_id = strdup(_media->media_id);
1394         }
1395
1396         if(STRING_VALID(_media->video_meta->title)) {
1397                 _video->title = strdup(_media->video_meta->title);
1398         }
1399         if(STRING_VALID(_media->video_meta->album)) {
1400                 _video->album = strdup(_media->video_meta->album);
1401         }
1402         if(STRING_VALID(_media->video_meta->artist)) {
1403                 _video->artist = strdup(_media->video_meta->artist);
1404         }
1405         if(STRING_VALID(_media->video_meta->genre)) {
1406                 _video->genre = strdup(_media->video_meta->genre);
1407         }
1408         if(STRING_VALID(_media->video_meta->composer)) {
1409                 _video->composer = strdup(_media->video_meta->composer);
1410         }
1411         if(STRING_VALID(_media->video_meta->year)) {
1412                 _video->year = strdup(_media->video_meta->year);
1413         }
1414         if(STRING_VALID(_media->video_meta->recorded_date)) {
1415                 _video->recorded_date = strdup(_media->video_meta->recorded_date);
1416         }
1417         if(STRING_VALID(_media->video_meta->copyright)) {
1418                 _video->copyright = strdup(_media->video_meta->copyright);
1419         }
1420         if(STRING_VALID(_media->video_meta->track_num)) {
1421                 _video->track_num = strdup(_media->video_meta->track_num);
1422         }
1423
1424         _video->width = _media->video_meta->width;
1425         _video->height = _media->video_meta->height;
1426         _video->duration = _media->video_meta->duration;
1427         _video->bitrate = _media->video_meta->bitrate;
1428         _video->played_count = _media->video_meta->played_count;
1429         _video->played_time = _media->video_meta->played_time;
1430         _video->played_position = _media->video_meta->played_position;
1431
1432         *video = (video_meta_h)_video;
1433
1434         return ret;
1435 }
1436
1437 int media_info_get_audio(media_info_h media, audio_meta_h *audio)
1438 {
1439         int ret = MEDIA_CONTENT_ERROR_NONE;
1440
1441         media_info_s *_media = (media_info_s*)media;
1442
1443         if(_media == NULL)
1444         {
1445                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1446                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1447         }
1448
1449         if(_media->media_type != MEDIA_CONTENT_TYPE_MUSIC && _media->media_type != MEDIA_CONTENT_TYPE_SOUND)
1450         {
1451                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1452                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1453         }
1454
1455         if(_media->audio_meta == NULL)
1456         {
1457                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1458                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1459         }
1460
1461         audio_meta_s *_audio = (audio_meta_s*)calloc(1, sizeof(audio_meta_s));
1462
1463         if(_audio == NULL)
1464         {
1465                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1466                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1467         }
1468
1469         if(STRING_VALID(_media->media_id)) {
1470                 _audio->media_id = strdup(_media->media_id);
1471         }
1472
1473         if(STRING_VALID(_media->audio_meta->title)) {
1474                 _audio->title = strdup(_media->audio_meta->title);
1475         }
1476         if(STRING_VALID(_media->audio_meta->album)) {
1477                 _audio->album = strdup(_media->audio_meta->album);
1478         }
1479         if(STRING_VALID(_media->audio_meta->artist)) {
1480                 _audio->artist = strdup(_media->audio_meta->artist);
1481         }
1482         if(STRING_VALID(_media->audio_meta->genre)) {
1483                 _audio->genre = strdup(_media->audio_meta->genre);
1484         }
1485         if(STRING_VALID(_media->audio_meta->composer)) {
1486                 _audio->composer = strdup(_media->audio_meta->composer);
1487         }
1488         if(STRING_VALID(_media->audio_meta->year)) {
1489                 _audio->year = strdup(_media->audio_meta->year);
1490         }
1491         if(STRING_VALID(_media->audio_meta->recorded_date)) {
1492                 _audio->recorded_date = strdup(_media->audio_meta->recorded_date);
1493         }
1494         if(STRING_VALID(_media->audio_meta->copyright)) {
1495                 _audio->copyright = strdup(_media->audio_meta->copyright);
1496         }
1497         if(STRING_VALID(_media->audio_meta->track_num)) {
1498                 _audio->track_num = strdup(_media->audio_meta->track_num);
1499         }
1500
1501         _audio->duration = _media->audio_meta->duration;
1502         _audio->bitrate = _media->audio_meta->bitrate;
1503         _audio->samplerate = _media->audio_meta->samplerate;
1504         _audio->channel = _media->audio_meta->channel;
1505         _audio->played_time = _media->audio_meta->played_time;
1506         _audio->played_count = _media->audio_meta->played_count;
1507         _audio->played_position = _media->audio_meta->played_position;
1508
1509         *audio = (audio_meta_h)_audio;
1510
1511         return ret;
1512 }
1513
1514 int media_info_get_media_id(media_info_h media, char **media_id)
1515 {
1516         int ret = MEDIA_CONTENT_ERROR_NONE;
1517         media_info_s *_media = (media_info_s*)media;
1518
1519         if(_media && media_id)
1520         {
1521                 if(STRING_VALID(_media->media_id))
1522                 {
1523                         *media_id = strdup(_media->media_id);
1524                         if(*media_id == NULL)
1525                         {
1526                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1527                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1528                         }
1529                 }
1530                 else
1531                 {
1532                         *media_id = NULL;
1533                 }
1534                 ret = MEDIA_CONTENT_ERROR_NONE;
1535         }
1536         else
1537         {
1538                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1539                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1540         }
1541
1542         return ret;
1543 }
1544
1545 int media_info_get_file_path(media_info_h media, char **path)
1546 {
1547         int ret = MEDIA_CONTENT_ERROR_NONE;
1548         media_info_s *_media = (media_info_s*)media;
1549
1550         if(_media && path)
1551         {
1552                 if(STRING_VALID(_media->file_path))
1553                 {
1554                         *path = strdup(_media->file_path);
1555                         if(*path == NULL)
1556                         {
1557                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1558                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1559                         }
1560                 }
1561                 else
1562                 {
1563                         *path = NULL;
1564                 }
1565                 ret = MEDIA_CONTENT_ERROR_NONE;
1566
1567         }
1568         else
1569         {
1570                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1571                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1572         }
1573
1574         return ret;
1575 }
1576
1577 int media_info_get_display_name(media_info_h media, char **name)
1578 {
1579         int ret = MEDIA_CONTENT_ERROR_NONE;
1580         media_info_s *_media = (media_info_s*)media;
1581         if(_media && name)
1582         {
1583                 if(STRING_VALID(_media->display_name))
1584                 {
1585                         *name = strdup(_media->display_name);
1586                         if(*name == NULL)
1587                         {
1588                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1589                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1590                         }
1591                 }
1592                 else
1593                 {
1594                         *name = NULL;
1595                 }
1596                 ret = MEDIA_CONTENT_ERROR_NONE;
1597
1598         }
1599         else
1600         {
1601                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1602                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1603         }
1604
1605         return ret;
1606 }
1607
1608 int media_info_get_media_type(media_info_h media, media_content_type_e *type)
1609 {
1610         int ret = MEDIA_CONTENT_ERROR_NONE;
1611         media_info_s *_media = (media_info_s*)media;
1612         if(_media && type)
1613         {
1614                 *type = _media->media_type;
1615                 ret = MEDIA_CONTENT_ERROR_NONE;
1616         }
1617         else
1618         {
1619                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1620                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1621         }
1622
1623         return ret;
1624 }
1625
1626 int media_info_get_mime_type(media_info_h media, char **mime_type)
1627 {
1628         int ret = MEDIA_CONTENT_ERROR_NONE;
1629         media_info_s *_media = (media_info_s*)media;
1630
1631         if(_media && mime_type)
1632         {
1633                 if(STRING_VALID(_media->mime_type))
1634                 {
1635                         *mime_type = strdup(_media->mime_type);
1636                         if(*mime_type == NULL)
1637                         {
1638                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1639                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1640                         }
1641                 }
1642                 else
1643                 {
1644                         *mime_type = NULL;
1645                 }
1646                 ret = MEDIA_CONTENT_ERROR_NONE;
1647         }
1648         else
1649         {
1650                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1651                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1652         }
1653
1654         return ret;
1655 }
1656
1657 int media_info_get_size(media_info_h media, unsigned long long *size)
1658 {
1659         int ret = MEDIA_CONTENT_ERROR_NONE;
1660         media_info_s *_media = (media_info_s*)media;
1661
1662         if(_media && size)
1663         {
1664                 *size = _media->size;
1665                 ret = MEDIA_CONTENT_ERROR_NONE;
1666         }
1667         else
1668         {
1669                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1670                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1671         }
1672
1673         return ret;
1674 }
1675
1676 int media_info_get_added_time(media_info_h media, time_t *added_time)
1677 {
1678         int ret = MEDIA_CONTENT_ERROR_NONE;
1679         media_info_s *_media = (media_info_s*)media;
1680         if(_media && added_time)
1681         {
1682                 *added_time = _media->added_time;
1683                 ret = MEDIA_CONTENT_ERROR_NONE;
1684         }
1685         else
1686         {
1687                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1688                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1689         }
1690
1691         return ret;
1692 }
1693
1694 int media_info_get_modified_time(media_info_h media, time_t* time)
1695 {
1696         int ret = MEDIA_CONTENT_ERROR_NONE;
1697         media_info_s *_media = (media_info_s*)media;
1698         if(_media && time)
1699         {
1700                 *time = _media->modified_time;
1701                 ret = MEDIA_CONTENT_ERROR_NONE;
1702         }
1703         else
1704         {
1705                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1706                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1707         }
1708
1709         return ret;
1710 }
1711
1712 int media_info_get_thumbnail_path(media_info_h media, char **path)
1713 {
1714         int ret = MEDIA_CONTENT_ERROR_NONE;
1715         media_info_s *_media = (media_info_s*)media;
1716         if(_media && path)
1717         {
1718                 if(STRING_VALID(_media->thumbnail_path))
1719                 {
1720                         *path = strdup(_media->thumbnail_path);
1721                         if(*path == NULL)
1722                         {
1723                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1724                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1725                         }
1726                 }
1727                 else
1728                 {
1729                         *path = NULL;
1730                 }
1731                 ret = MEDIA_CONTENT_ERROR_NONE;
1732
1733         }
1734         else
1735         {
1736                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1737                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1738         }
1739
1740         return ret;
1741 }
1742
1743 int media_info_get_title(media_info_h media, char **title)
1744 {
1745         int ret = MEDIA_CONTENT_ERROR_NONE;
1746         media_info_s *_media = (media_info_s*)media;
1747
1748         if(_media && title)
1749         {
1750                 if(STRING_VALID(_media->title))
1751                 {
1752                         *title = strdup(_media->title);
1753                         if(*title == NULL)
1754                         {
1755                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1756                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1757                         }
1758                 }
1759                 else
1760                 {
1761                         *title = NULL;
1762                 }
1763                 ret = MEDIA_CONTENT_ERROR_NONE;
1764         }
1765         else
1766         {
1767                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1768                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1769         }
1770
1771         return ret;
1772 }
1773
1774 int media_info_get_description(media_info_h media, char **description)
1775 {
1776         int ret = MEDIA_CONTENT_ERROR_NONE;
1777         media_info_s *_media = (media_info_s*)media;
1778
1779         if(_media && description)
1780         {
1781                 if(STRING_VALID(_media->description))
1782                 {
1783                         *description = strdup(_media->description);
1784                         if(*description == NULL)
1785                         {
1786                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1787                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1788                         }
1789                 }
1790                 else
1791                 {
1792                         *description = NULL;
1793                 }
1794                 ret = MEDIA_CONTENT_ERROR_NONE;
1795         }
1796         else
1797         {
1798                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1799                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1800         }
1801
1802         return ret;
1803 }
1804
1805 int media_info_get_longitude(media_info_h media, double* longitude)
1806 {
1807         int ret = MEDIA_CONTENT_ERROR_NONE;
1808         media_info_s *_media = (media_info_s*)media;
1809
1810         if(_media && longitude)
1811         {
1812                 *longitude = _media->longitude;
1813                 ret = MEDIA_CONTENT_ERROR_NONE;
1814         }
1815         else
1816         {
1817                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1818                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1819         }
1820
1821         return ret;
1822 }
1823 int media_info_get_latitude(media_info_h media, double* latitude)
1824 {
1825         int ret = MEDIA_CONTENT_ERROR_NONE;
1826         media_info_s *_media = (media_info_s*)media;
1827
1828         if(_media && latitude)
1829         {
1830                 *latitude = _media->latitude;
1831                 ret = MEDIA_CONTENT_ERROR_NONE;
1832         }
1833         else
1834         {
1835                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1836                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1837         }
1838
1839         return ret;
1840 }
1841
1842 int media_info_get_altitude(media_info_h media, double *altitude)
1843 {
1844         int ret = MEDIA_CONTENT_ERROR_NONE;
1845         media_info_s *_media = (media_info_s*)media;
1846
1847         if(_media && altitude)
1848         {
1849                 *altitude = _media->altitude;
1850                 ret = MEDIA_CONTENT_ERROR_NONE;
1851         }
1852         else
1853         {
1854                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1855                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1856         }
1857
1858         return ret;
1859 }
1860
1861 int media_info_get_rating(media_info_h media, int *rating)
1862 {
1863         int ret = MEDIA_CONTENT_ERROR_NONE;
1864         media_info_s *_media = (media_info_s*)media;
1865
1866         if(_media && rating)
1867         {
1868                 *rating = _media->rating;
1869                 ret = MEDIA_CONTENT_ERROR_NONE;
1870         }
1871         else
1872         {
1873                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1874                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1875         }
1876
1877         return ret;
1878 }
1879
1880 int media_info_get_favorite(media_info_h media, bool* favorite)
1881 {
1882         int ret = MEDIA_CONTENT_ERROR_NONE;
1883         media_info_s *_media = (media_info_s*)media;
1884
1885         if(_media && favorite)
1886         {
1887
1888                 *favorite = _media->favourite;
1889                 ret = MEDIA_CONTENT_ERROR_NONE;
1890         }
1891         else
1892         {
1893                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1894                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1895         }
1896
1897         return ret;
1898 }
1899
1900 int media_info_get_author(media_info_h media, char **author)
1901 {
1902         int ret = MEDIA_CONTENT_ERROR_NONE;
1903         media_info_s *_media = (media_info_s*)media;
1904
1905         if(_media && author)
1906         {
1907                 if(STRING_VALID(_media->author))
1908                 {
1909                         *author = strdup(_media->author);
1910                         if(*author == NULL)
1911                         {
1912                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1913                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1914                         }
1915                 }
1916                 else
1917                 {
1918                         *author = NULL;
1919                 }
1920                 ret = MEDIA_CONTENT_ERROR_NONE;
1921         }
1922         else
1923         {
1924                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1925                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1926         }
1927
1928         return ret;
1929 }
1930
1931 int media_info_get_provider(media_info_h media, char **provider)
1932 {
1933         int ret = MEDIA_CONTENT_ERROR_NONE;
1934         media_info_s *_media = (media_info_s*)media;
1935
1936         if(_media && provider)
1937         {
1938                 if(STRING_VALID(_media->provider))
1939                 {
1940                         *provider = strdup(_media->provider);
1941                         if(*provider == NULL)
1942                         {
1943                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1944                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1945                         }
1946                 }
1947                 else
1948                 {
1949                         *provider = NULL;
1950                 }
1951                 ret = MEDIA_CONTENT_ERROR_NONE;
1952         }
1953         else
1954         {
1955                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1956                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1957         }
1958
1959         return ret;
1960 }
1961
1962 int media_info_get_content_name(media_info_h media, char **content_name)
1963 {
1964         int ret = MEDIA_CONTENT_ERROR_NONE;
1965         media_info_s *_media = (media_info_s*)media;
1966
1967         if(_media && content_name)
1968         {
1969                 if(STRING_VALID(_media->content_name))
1970                 {
1971                         *content_name = strdup(_media->content_name);
1972                         if(*content_name == NULL)
1973                         {
1974                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1975                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1976                         }
1977                 }
1978                 else
1979                 {
1980                         *content_name = NULL;
1981                 }
1982                 ret = MEDIA_CONTENT_ERROR_NONE;
1983         }
1984         else
1985         {
1986                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1987                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1988         }
1989
1990         return ret;
1991 }
1992
1993 int media_info_get_category(media_info_h media, char **category)
1994 {
1995         int ret = MEDIA_CONTENT_ERROR_NONE;
1996         media_info_s *_media = (media_info_s*)media;
1997
1998         if(_media && category)
1999         {
2000                 if(STRING_VALID(_media->category))
2001                 {
2002                         *category = strdup(_media->category);
2003                         if(*category == NULL)
2004                         {
2005                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
2006                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
2007                         }
2008                 }
2009                 else
2010                 {
2011                         *category = NULL;
2012                 }
2013                 ret = MEDIA_CONTENT_ERROR_NONE;
2014         }
2015         else
2016         {
2017                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2018                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2019         }
2020
2021         return ret;
2022 }
2023
2024 int media_info_get_location_tag(media_info_h media, char **location_tag)
2025 {
2026         int ret = MEDIA_CONTENT_ERROR_NONE;
2027         media_info_s *_media = (media_info_s*)media;
2028
2029         if(_media && location_tag)
2030         {
2031                 if(STRING_VALID(_media->location_tag))
2032                 {
2033                         *location_tag = strdup(_media->location_tag);
2034                         if(*location_tag == NULL)
2035                         {
2036                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
2037                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
2038                         }
2039                 }
2040                 else
2041                 {
2042                         *location_tag = NULL;
2043                 }
2044                 ret = MEDIA_CONTENT_ERROR_NONE;
2045         }
2046         else
2047         {
2048                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2049                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2050         }
2051
2052         return ret;
2053 }
2054
2055 int media_info_get_age_rating(media_info_h media, char **age_rating)
2056 {
2057         int ret = MEDIA_CONTENT_ERROR_NONE;
2058         media_info_s *_media = (media_info_s*)media;
2059
2060         if(_media && age_rating)
2061         {
2062                 if(STRING_VALID(_media->age_rating))
2063                 {
2064                         *age_rating = strdup(_media->age_rating);
2065                         if(*age_rating == NULL)
2066                         {
2067                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
2068                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
2069                         }
2070                 }
2071                 else
2072                 {
2073                         *age_rating = NULL;
2074                 }
2075                 ret = MEDIA_CONTENT_ERROR_NONE;
2076         }
2077         else
2078         {
2079                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2080                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2081         }
2082
2083         return ret;
2084 }
2085
2086 int media_info_get_keyword(media_info_h media, char **keyword)
2087 {
2088         int ret = MEDIA_CONTENT_ERROR_NONE;
2089         media_info_s *_media = (media_info_s*)media;
2090
2091         if(_media && keyword)
2092         {
2093                 if(STRING_VALID(_media->keyword))
2094                 {
2095                         *keyword = strdup(_media->keyword);
2096                         if(*keyword == NULL)
2097                         {
2098                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
2099                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
2100                         }
2101                 }
2102                 else
2103                 {
2104                         *keyword = NULL;
2105                 }
2106                 ret = MEDIA_CONTENT_ERROR_NONE;
2107         }
2108         else
2109         {
2110                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2111                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2112         }
2113
2114         return ret;
2115 }
2116
2117 int media_info_is_drm(media_info_h media, bool *is_drm)
2118 {
2119         int ret = MEDIA_CONTENT_ERROR_NONE;
2120         media_info_s *_media = (media_info_s*)media;
2121
2122         if(_media)
2123         {
2124                 *is_drm = _media->is_drm;
2125                 ret = MEDIA_CONTENT_ERROR_NONE;
2126         }
2127         else
2128         {
2129                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2130                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2131         }
2132
2133         return ret;
2134 }
2135
2136 int media_info_get_storage_type(media_info_h media, media_content_storage_e *storage_type)
2137 {
2138         int ret = MEDIA_CONTENT_ERROR_NONE;
2139         media_info_s *_media = (media_info_s*)media;
2140
2141         if(_media && storage_type)
2142         {
2143                 *storage_type = _media->storage_type;
2144                 ret = MEDIA_CONTENT_ERROR_NONE;
2145         }
2146         else
2147         {
2148                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2149                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2150         }
2151
2152         return ret;
2153 }
2154
2155 int media_info_get_media_from_db(const char *media_id, media_info_h *media)
2156 {
2157         int ret = MEDIA_CONTENT_ERROR_NONE;
2158         char select_query[DEFAULT_QUERY_SIZE];
2159         sqlite3_stmt *stmt = NULL;
2160
2161         if(!STRING_VALID(media_id) || (media == NULL))
2162         {
2163                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2164                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2165         }
2166
2167         memset(select_query, 0x00, sizeof(select_query));
2168
2169         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_MEDIA, media_id);
2170         ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
2171         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
2172
2173         while(sqlite3_step(stmt) == SQLITE_ROW)
2174         {
2175                 media_info_s *_media = (media_info_s*)calloc(1, sizeof(media_info_s));
2176
2177                 if(_media == NULL)
2178                 {
2179                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
2180                         SQLITE3_FINALIZE(stmt);
2181                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
2182                 }
2183
2184                 _media_info_item_get_detail(stmt, (media_info_h)_media);
2185
2186                 *media = (media_info_h)_media;
2187         }
2188
2189         SQLITE3_FINALIZE(stmt);
2190
2191         return ret;
2192 }
2193
2194 int media_info_set_display_name(media_info_h media, const char *display_name)
2195 {
2196         int ret = MEDIA_CONTENT_ERROR_NONE;
2197         media_info_s *_media = (media_info_s*)media;
2198
2199         if(_media != NULL && STRING_VALID(display_name))
2200         {
2201                 SAFE_FREE(_media->display_name);
2202
2203                 _media->display_name = strdup(display_name);
2204                 if(_media->display_name == NULL)
2205                 {
2206                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
2207                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
2208                 }
2209         }
2210         else
2211         {
2212                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2213                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2214         }
2215
2216         return ret;
2217 }
2218
2219 int media_info_set_description(media_info_h media, const char *description)
2220 {
2221         int ret = MEDIA_CONTENT_ERROR_NONE;
2222         media_info_s *_media = (media_info_s*)media;
2223
2224         if(_media != NULL)
2225         {
2226                 SAFE_FREE(_media->description);
2227
2228                 if(STRING_VALID(description))
2229                 {
2230                         _media->description = strdup(description);
2231
2232                         if(_media->description == NULL)
2233                         {
2234                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
2235                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
2236                         }
2237                 }
2238                 else
2239                 {
2240                         _media->description = NULL;
2241                 }
2242         }
2243         else
2244         {
2245                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2246                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2247         }
2248
2249         return ret;
2250 }
2251
2252 int media_info_set_longitude(media_info_h media, double longitude)
2253 {
2254         int ret = MEDIA_CONTENT_ERROR_NONE;
2255         media_info_s *_media = (media_info_s*)media;
2256
2257         if(_media != NULL)
2258         {
2259                 _media->longitude = longitude;
2260         }
2261         else
2262         {
2263                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2264                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2265         }
2266
2267         return ret;
2268 }
2269
2270 int media_info_set_latitude(media_info_h media, double latitude)
2271 {
2272         int ret = MEDIA_CONTENT_ERROR_NONE;
2273         media_info_s *_media = (media_info_s*)media;
2274
2275         if(_media != NULL)
2276         {
2277                 _media->latitude = latitude;
2278         }
2279         else
2280         {
2281                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2282                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2283         }
2284
2285         return ret;
2286 }
2287
2288 int media_info_set_altitude(media_info_h media, double altitude)
2289 {
2290         int ret = MEDIA_CONTENT_ERROR_NONE;
2291         media_info_s *_media = (media_info_s*)media;
2292
2293         if(_media != NULL)
2294         {
2295                 _media->altitude = altitude;
2296         }
2297         else
2298         {
2299                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2300                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2301         }
2302
2303         return ret;
2304 }
2305
2306 int media_info_set_rating(media_info_h media, int rating)
2307 {
2308         int ret = MEDIA_CONTENT_ERROR_NONE;
2309         media_info_s *_media = (media_info_s*)media;
2310
2311         if(_media != NULL)
2312         {
2313                 _media->rating = rating;
2314         }
2315         else
2316         {
2317                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2318                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2319         }
2320
2321         return ret;
2322 }
2323
2324 int media_info_set_added_time(media_info_h media, time_t added_time)
2325 {
2326         int ret = MEDIA_CONTENT_ERROR_NONE;
2327
2328         media_info_s *_media = (media_info_s*)media;
2329
2330         if((_media != NULL) && (added_time >= 0))
2331         {
2332                 _media->added_time = added_time;
2333         }
2334         else
2335         {
2336                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2337                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2338         }
2339
2340         return ret;
2341 }
2342
2343 int media_info_set_favorite(media_info_h media, bool favorite)
2344 {
2345         int ret = MEDIA_CONTENT_ERROR_NONE;
2346         media_info_s *_media = (media_info_s*)media;
2347
2348         if(_media != NULL)
2349         {
2350                 _media->favourite = favorite;
2351         }
2352         else
2353         {
2354                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2355                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2356         }
2357
2358         return ret;
2359 }
2360
2361 int media_info_set_author(media_info_h media, const char *author)
2362 {
2363         int ret = MEDIA_CONTENT_ERROR_NONE;
2364         media_info_s *_media = (media_info_s*)media;
2365
2366         if(_media != NULL)
2367         {
2368                 if(STRING_VALID(author))
2369                 {
2370                         _media->author = strdup(author);
2371                         if(_media->author == NULL)
2372                         {
2373                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
2374                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
2375                         }
2376                 }
2377                 else
2378                 {
2379                         _media->author = NULL;
2380                 }
2381         }
2382         else
2383         {
2384                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2385                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2386         }
2387
2388         return ret;
2389 }
2390
2391 int media_info_set_provider(media_info_h media, const char *provider)
2392 {
2393         int ret = MEDIA_CONTENT_ERROR_NONE;
2394         media_info_s *_media = (media_info_s*)media;
2395
2396         if(_media != NULL)
2397         {
2398                 SAFE_FREE(_media->provider);
2399
2400                 if(STRING_VALID(provider))
2401                 {
2402                         _media->provider = strdup(provider);
2403                         if(_media->provider == NULL)
2404                         {
2405                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
2406                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
2407                         }
2408                 }
2409                 else
2410                 {
2411                         _media->provider = NULL;
2412                 }
2413         }
2414         else
2415         {
2416                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2417                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2418         }
2419
2420         return ret;
2421 }
2422
2423 int media_info_set_content_name(media_info_h media, const char *content_name)
2424 {
2425         int ret = MEDIA_CONTENT_ERROR_NONE;
2426         media_info_s *_media = (media_info_s*)media;
2427
2428         if(_media != NULL)
2429         {
2430                 SAFE_FREE(_media->content_name);
2431
2432                 if(STRING_VALID(content_name))
2433                 {
2434                         _media->content_name = strdup(content_name);
2435                         if(_media->content_name == NULL)
2436                         {
2437                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
2438                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
2439                         }
2440                 }
2441                 else
2442                 {
2443                         _media->content_name = NULL;
2444                 }
2445         }
2446         else
2447         {
2448                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2449                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2450         }
2451
2452         return ret;
2453 }
2454
2455 int media_info_set_category(media_info_h media, const char *category)
2456 {
2457         int ret = MEDIA_CONTENT_ERROR_NONE;
2458         media_info_s *_media = (media_info_s*)media;
2459
2460         if(_media != NULL)
2461         {
2462                 SAFE_FREE(_media->category);
2463
2464                 if(STRING_VALID(category))
2465                 {
2466                         _media->category = strdup(category);
2467                         if(_media->category == NULL)
2468                         {
2469                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
2470                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
2471                         }
2472                 }
2473                 else
2474                 {
2475                         _media->category = NULL;
2476                 }
2477         }
2478         else
2479         {
2480                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2481                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2482         }
2483
2484         return ret;
2485 }
2486
2487 int media_info_set_location_tag(media_info_h media, const char *location_tag)
2488 {
2489         int ret = MEDIA_CONTENT_ERROR_NONE;
2490         media_info_s *_media = (media_info_s*)media;
2491
2492         if(_media != NULL)
2493         {
2494                 SAFE_FREE(_media->location_tag);
2495
2496                 if(STRING_VALID(location_tag))
2497                 {
2498                         _media->location_tag = strdup(location_tag);
2499                         if(_media->location_tag == NULL)
2500                         {
2501                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
2502                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
2503                         }
2504                 }
2505                 else
2506                 {
2507                         _media->location_tag = NULL;
2508                 }
2509         }
2510         else
2511         {
2512                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2513                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2514         }
2515
2516         return ret;
2517 }
2518
2519 int media_info_set_age_rating(media_info_h media, const char *age_rating)
2520 {
2521         int ret = MEDIA_CONTENT_ERROR_NONE;
2522         media_info_s *_media = (media_info_s*)media;
2523
2524         if(_media != NULL)
2525         {
2526                 SAFE_FREE(_media->age_rating);
2527
2528                 if(STRING_VALID(age_rating))
2529                 {
2530                         _media->age_rating = strdup(age_rating);
2531                         if(_media->age_rating == NULL)
2532                         {
2533                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
2534                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
2535                         }
2536                 }
2537                 else
2538                 {
2539                         _media->age_rating = NULL;
2540                 }
2541         }
2542         else
2543         {
2544                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2545                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2546         }
2547
2548         return ret;
2549 }
2550
2551 int media_info_set_keyword(media_info_h media, const char *keyword)
2552 {
2553         int ret = MEDIA_CONTENT_ERROR_NONE;
2554         media_info_s *_media = (media_info_s*)media;
2555
2556         if(_media != NULL)
2557         {
2558                 SAFE_FREE(_media->keyword);
2559
2560                 if(STRING_VALID(keyword))
2561                 {
2562                         _media->keyword = strdup(keyword);
2563                         if(_media->keyword == NULL)
2564                         {
2565                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
2566                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
2567                         }
2568                 }
2569                 else
2570                 {
2571                         _media->keyword = NULL;
2572                 }
2573         }
2574         else
2575         {
2576                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2577                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2578         }
2579
2580         return ret;
2581 }
2582
2583 int media_info_update_to_db(media_info_h media)
2584 {
2585         int ret = MEDIA_CONTENT_ERROR_NONE;
2586         int len = 0;
2587         media_info_s *_media = (media_info_s*)media;
2588         char *set_sql = NULL;
2589         char sql[MAX_QUERY_SIZE];
2590         memset(sql, '\0', sizeof(sql));
2591
2592         if(_media != NULL && STRING_VALID(_media->media_id))
2593         {
2594                 /* This sql is due to sqlite3_mprintf's wrong operation when using floating point in the text format */
2595                 /* This code will be removed when sqlite3_mprintf works clearly */
2596                 char *test_sql = sqlite3_mprintf("%f, %f, %f", _media->longitude, _media->latitude, _media->altitude);
2597                 sqlite3_free(test_sql);
2598
2599                 set_sql = sqlite3_mprintf("file_name=%Q, added_time=%d, description=%Q, longitude=%f, latitude=%f, altitude=%f, \
2600                         rating=%d, favourite=%d, author=%Q, provider=%Q, content_name=%Q, category=%Q, location_tag=%Q, age_rating=%Q, keyword=%Q",
2601                         _media->display_name, _media->added_time, _media->description, _media->longitude, _media->latitude, _media->altitude, _media->rating, _media->favourite,
2602                         _media->author, _media->provider, _media->content_name, _media->category, _media->location_tag, _media->age_rating, _media->keyword);
2603
2604                 len = snprintf(sql, sizeof(sql), "UPDATE %s SET %s WHERE media_uuid='%s'", DB_TABLE_MEDIA, set_sql, _media->media_id);
2605                 sqlite3_free(set_sql);
2606                 if (len > 0) {
2607                         sql[len] = '\0';
2608                 } else {
2609                         media_content_error("snprintf failed");
2610                         return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2611                 }
2612
2613                 ret = _content_query_sql(sql);
2614                 if (ret == MEDIA_CONTENT_ERROR_NONE) {
2615                         /*  Send notification for this update */
2616                         media_content_debug("Update is successfull. Send notification for this");
2617                         if (_media->file_path && _media->mime_type) {
2618                                 media_db_update_send(getpid(), MS_MEDIA_ITEM_FILE, MS_MEDIA_ITEM_UPDATE, _media->file_path, _media->media_id, _media->media_type, _media->mime_type);
2619                         } else {
2620                                 media_content_error("Can't media_db_update_send : path or mime type is NULL");
2621                         }
2622                 }
2623         }
2624         else
2625         {
2626                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2627                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2628         }
2629
2630         return ret;
2631 }
2632
2633 int media_info_refresh_metadata_to_db(const char *media_id)
2634 {
2635         int ret = MEDIA_CONTENT_ERROR_NONE;
2636         media_info_h media = NULL;
2637         char *file_path = NULL;
2638         media_content_storage_e storage_type = 0;
2639
2640         if(!STRING_VALID(media_id))
2641         {
2642                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2643                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2644         }
2645
2646         ret = media_info_get_media_from_db(media_id, &media);
2647         if(ret != MEDIA_CONTENT_ERROR_NONE)
2648         {
2649                 media_info_destroy(media);
2650                 return ret;
2651         }
2652
2653         ret = media_info_get_storage_type(media, &storage_type);
2654         if(ret != MEDIA_CONTENT_ERROR_NONE)
2655         {
2656                 media_info_destroy(media);
2657                 return ret;
2658         }
2659
2660         ret = media_info_get_file_path(media, &file_path);
2661         if(ret != MEDIA_CONTENT_ERROR_NONE)
2662         {
2663                 media_info_destroy(media);
2664                 return ret;
2665         }
2666
2667         ret = media_svc_refresh_item(_content_get_db_handle(), storage_type, file_path);
2668
2669         SAFE_FREE(file_path);
2670         media_info_destroy(media);
2671
2672         return ret;
2673 }
2674
2675 int media_info_move_to_db(media_info_h media, const char* dst_path)
2676 {
2677         int ret = MEDIA_CONTENT_ERROR_NONE;
2678
2679         int src_storage_type = 0;
2680         int dst_storage_type = 0;
2681
2682         if(media == NULL || !STRING_VALID(dst_path))
2683         {
2684                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2685                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2686         }
2687
2688         media_info_s *_media = (media_info_s*)media;
2689
2690         ret = _media_util_get_store_type_by_path(_media->file_path, &src_storage_type);
2691         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
2692         ret = _media_util_get_store_type_by_path(dst_path, &dst_storage_type);
2693         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
2694
2695         ret = media_svc_move_item(_content_get_db_handle(), src_storage_type, _media->file_path, dst_storage_type, dst_path);
2696         return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
2697 }
2698
2699 int media_info_create_thumbnail(media_info_h media, media_thumbnail_completed_cb callback, void *user_data)
2700 {
2701         int ret = MEDIA_CONTENT_ERROR_NONE;
2702         media_info_s *_media = (media_info_s*)media;
2703
2704         if(_media != NULL && STRING_VALID(_media->media_id) && STRING_VALID(_media->file_path))
2705         {
2706                 media_thumbnail_cb_s *_thumb_cb = (media_thumbnail_cb_s*)calloc(1, sizeof(media_thumbnail_cb_s));
2707                 _thumb_cb->handle = _media;
2708                 _thumb_cb->user_data = user_data;
2709                 _thumb_cb->thumbnail_completed_cb = callback;
2710
2711                 ret = thumbnail_request_from_db_async(_media->file_path, (ThumbFunc)__media_info_thumbnail_completed_cb, (void *)_thumb_cb);
2712                 ret = _content_error_capi(MEDIA_THUMBNAIL_TYPE, ret);
2713         }
2714         else
2715         {
2716                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2717                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2718         }
2719
2720         return ret;
2721 }
2722
2723 int media_info_cancel_thumbnail(media_info_h media)
2724 {
2725         int ret = MEDIA_CONTENT_ERROR_NONE;
2726         media_info_s *_media = (media_info_s*)media;
2727
2728         if(_media != NULL && STRING_VALID(_media->media_id) && STRING_VALID(_media->file_path))
2729         {
2730                 ret = thumbnail_request_cancel_media(_media->file_path);
2731                 ret = _content_error_capi(MEDIA_THUMBNAIL_TYPE, ret);
2732         }
2733         else
2734         {
2735                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2736                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2737         }
2738
2739         return ret;
2740 }