src/media_info.c

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