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