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