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 <media_info.h>
  18 #include <media-thumbnail.h>
  19 #include <media-util-dcm.h>
  20 #include <media_info_private.h>
  21 #include <media_util_private.h>
  22 #include <system_info.h>
  23
  24
  25 static void __media_info_insert_completed_cb(media_request_result_s *result, void *user_data);
  26 static void __media_info_thumbnail_completed_cb(int error, const char *path, void *user_data);
  27 static void __media_info_face_completed_cb(int error, const int face_count, void *user_data);
  28 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);
  29 static int __media_info_set_str_data(media_info_h media, media_info_item_e data_type, const char *str_data);
  30 static int __media_info_check_file_validity(const char *path);
  31
  32 static int __media_info_get_media_path_by_id_from_db(const char *media_id, char **path)
  33 {
  34         int ret = MEDIA_CONTENT_ERROR_NONE;
  35         sqlite3_stmt *stmt = NULL;
  36         char *select_query = NULL;
  37
  38         media_content_retvm_if(!STRING_VALID(media_id), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid media_id");
  39
  40         select_query = sqlite3_mprintf(SELECT_MEDIA_PATH_BY_ID, media_id);
  41
  42         ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
  43         SQLITE3_SAFE_FREE(select_query);
  44         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
  45
  46         if (sqlite3_step(stmt) == SQLITE_ROW) {
  47                 *path = g_strdup((const char *)sqlite3_column_text(stmt, 0));
  48         } else {
  49                 media_content_error("There's no media with this ID : %s", media_id);
  50                 *path = NULL;
  51                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  52         }
  53
  54         SQLITE3_FINALIZE(stmt);
  55
  56         return ret;
  57 }
  58
  59 static void __media_info_insert_completed_cb(media_request_result_s *result, void *user_data)
  60 {
  61         int ret = MEDIA_CONTENT_ERROR_NONE;
  62         media_insert_cb_s *_cb_data = (media_insert_cb_s *)user_data;
  63
  64         if (_cb_data) {
  65                 if (result)
  66                         ret = _content_error_capi(MEDIA_CONTENT_TYPE, result->result);
  67
  68                 if (_cb_data->insert_completed_cb) {
  69                         media_content_debug("User callback is being called now");
  70                         _cb_data->insert_completed_cb(ret, _cb_data->user_data);
  71                 }
  72
  73                 if (STRING_VALID(_cb_data->insert_list_path)) {
  74                         if (unlink(_cb_data->insert_list_path) < 0)
  75                                 media_content_stderror("failed to delete");
  76                         SAFE_FREE(_cb_data->insert_list_path);
  77                 }
  78         }
  79
  80         SAFE_FREE(_cb_data);
  81
  82         return;
  83 }
  84
  85 static void __media_info_thumbnail_completed_cb(int error, const char *path, void *user_data)
  86 {
  87         int error_value = MEDIA_CONTENT_ERROR_NONE;
  88
  89         media_thumbnail_cb_s *_thumb_cb = (media_thumbnail_cb_s *)user_data;
  90         media_info_s *media = NULL;
  91
  92         if (_thumb_cb != NULL) {
  93                 media = _thumb_cb->handle;
  94
  95                 if (media != NULL) {
  96                         if (media->thumbnail_path != NULL)
  97                                 SAFE_FREE(media->thumbnail_path);
  98
  99                         if (STRING_VALID(path))
 100                                 media->thumbnail_path = g_strdup(path);
 101                         else
 102                                 media->thumbnail_path = g_strdup(EMPTY_STR);
 103                 }
 104
 105                 media_content_debug("error [%d], thumbnail_path [%s]", error, path);
 106                 error_value = _content_error_capi(MEDIA_THUMBNAIL_TYPE, error);
 107                 if (_thumb_cb->thumbnail_completed_cb)
 108                         _thumb_cb->thumbnail_completed_cb(error_value, path, _thumb_cb->user_data);
 109         }
 110
 111         SAFE_FREE(_thumb_cb);
 112
 113         return;
 114 }
 115
 116 static bool __media_info_isFaceRecognition_feature_supported()
 117 {
 118         bool isFaceRecognitionSupported = false;
 119
 120         const int nRetVal = system_info_get_platform_bool("http://tizen.org/feature/vision.face_recognition", &isFaceRecognitionSupported);
 121
 122         if (nRetVal != SYSTEM_INFO_ERROR_NONE) {
 123                 media_content_debug("SYSTEM_INFO_ERROR: vision.face_recognition [%d]", nRetVal);
 124                 return false;
 125         }
 126
 127         return isFaceRecognitionSupported;
 128 }
 129
 130 static void __media_info_face_completed_cb(int error, const int face_count, void *user_data)
 131 {
 132         int error_value = MEDIA_CONTENT_ERROR_NONE;
 133
 134         media_face_cb_s *_face_cb = (media_face_cb_s *)user_data;
 135
 136         if (_face_cb != NULL) {
 137                 media_content_debug("error [%d], face_count [%d]", error, face_count);
 138                 error_value = _content_error_capi(MEDIA_THUMBNAIL_TYPE, error);
 139                 if (_face_cb->face_completed_cb)
 140                         _face_cb->face_completed_cb(error_value, face_count, _face_cb->user_data);
 141         }
 142
 143         SAFE_FREE(_face_cb);
 144
 145         return;
 146 }
 147
 148 static int __media_info_insert_batch(media_batch_insert_e insert_type, const char **path_array,
 149                                         unsigned int array_length,
 150                                         media_insert_completed_cb completed_cb,
 151                                         void *user_data)
 152 {
 153         int ret = MEDIA_CONTENT_ERROR_NONE;
 154         FILE *fp = NULL;
 155         char list_path[255] = {0, };
 156         unsigned int idx = 0;
 157         int nwrites = 0;
 158
 159         for (idx = 0; idx < BATCH_REQUEST_MAX; idx++) {
 160                 snprintf(list_path, sizeof(list_path), "%s/request-%ld-%d", MEDIA_CONTENT_INSERT_FILES_PATH, media_content_gettid(), idx);
 161
 162                 if (g_file_test(list_path, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR)) {
 163                         memset(list_path, 0x00, sizeof(list_path));
 164                         continue;
 165                 } else {
 166                         media_content_debug("The request file list path : %s", list_path);
 167                         break;
 168                 }
 169         }
 170
 171         if (idx == BATCH_REQUEST_MAX) {
 172                 media_content_error("Too many batch request for one thread");
 173                 return MEDIA_CONTENT_ERROR_DB_BUSY;
 174         }
 175
 176         fp = fopen(list_path, "w");
 177         if (fp == NULL) {
 178                 media_content_error("failed to open file : [%s]", list_path);
 179                 media_content_stderror("failed to open file");
 180                 return MEDIA_CONTENT_ERROR_INVALID_OPERATION;
 181         }
 182
 183         for (idx = 0; idx < array_length; idx++) {
 184                 if (STRING_VALID(path_array[idx])) {
 185                         int size = strlen(path_array[idx]);
 186
 187                         ret = __media_info_check_file_validity(path_array[idx]);
 188                         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 189                                 fclose(fp);
 190                                 if (unlink(list_path) < 0)
 191                                         media_content_stderror("failed to delete");
 192                                 return ret;
 193                         }
 194
 195                         if (!_media_util_check_support_media_type(path_array[idx])) {
 196                                 fclose(fp);
 197                                 if (unlink(list_path) < 0)
 198                                         media_content_stderror("failed to delete");
 199                                 return MEDIA_CONTENT_ERROR_NOT_SUPPORTED;
 200                         }
 201
 202                         nwrites = fwrite(path_array[idx], 1, size, fp);
 203                         if (nwrites != size) {
 204                                 media_content_stderror("failed to write");
 205                                 fclose(fp);
 206                                 if (unlink(list_path) < 0)
 207                                         media_content_stderror("failed to delete");
 208                                 return MEDIA_CONTENT_ERROR_INVALID_OPERATION;
 209                         }
 210
 211                         nwrites = fwrite("\n", 1, 1, fp);
 212                         if (nwrites != 1) {
 213                                 media_content_stderror("failed to write");
 214                                 fclose(fp);
 215                                 if (unlink(list_path) < 0)
 216                                         media_content_stderror("failed to delete");
 217                                 return MEDIA_CONTENT_ERROR_INVALID_OPERATION;
 218                         }
 219                 } else {
 220                         media_content_error("path[%d] is invalid string", idx);
 221                 }
 222         }
 223
 224         fclose(fp);
 225
 226         media_insert_cb_s *_cb_data = (media_insert_cb_s *)calloc(1, sizeof(media_insert_cb_s));
 227         media_content_retvm_if(_cb_data == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 228
 229         _cb_data->insert_completed_cb = completed_cb;
 230         _cb_data->user_data = user_data;
 231         _cb_data->insert_list_path = g_strdup(list_path);
 232
 233         if (insert_type == MEDIA_BATCH_INSERT_NORMAL)
 234                 ret = media_files_register(list_path, __media_info_insert_completed_cb, _cb_data, _content_get_uid());
 235         else if (insert_type == MEDIA_BATCH_INSERT_BURSTSHOT)
 236                 ret = media_burstshot_register(list_path, __media_info_insert_completed_cb, _cb_data, _content_get_uid());
 237         else
 238                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 239
 240         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 241                 media_content_error("media_files_register failed : %d", ret);
 242                 if (unlink(list_path) < 0)
 243                         media_content_stderror("failed to delete");
 244                 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 245         }
 246
 247         return ret;
 248 }
 249
 250 int __media_info_get_storage_list_to_remove(const char *condition_query, GArray **storage_list)
 251 {
 252         int ret = MEDIA_CONTENT_ERROR_NONE;
 253         char *query_string = NULL;
 254         sqlite3_stmt *stmt = NULL;
 255
 256         media_content_retv_if(storage_list == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 257         media_content_retv_if(!STRING_VALID(condition_query), MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 258
 259         query_string = sqlite3_mprintf(SELECT_STORAGE_BY_FILTER, condition_query);
 260
 261         ret = _content_query_prepare(&stmt, query_string, NULL, NULL);
 262         SQLITE3_SAFE_FREE(query_string);
 263
 264         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 265
 266         *storage_list = g_array_new(FALSE, FALSE, sizeof(media_storage_s *));
 267
 268         while (sqlite3_step(stmt) == SQLITE_ROW) {
 269                 media_storage_s *storage = (media_storage_s*)calloc(1, sizeof(media_storage_s));
 270                 if (storage == NULL) {
 271                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 272                         SQLITE3_FINALIZE(stmt);
 273                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 274                 }
 275                 storage->storage_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
 276                 storage->storage_type = (int)sqlite3_column_int(stmt, 1);
 277
 278                 g_array_append_val(*storage_list, storage);
 279         }
 280
 281         SQLITE3_FINALIZE(stmt);
 282
 283         return ret;
 284 }
 285
 286 int __media_info_get_thumbnail_to_remove(const char *condition_query, const char *storage_id, int storage_type, GArray **thumb_list)
 287 {
 288         int ret = MEDIA_CONTENT_ERROR_NONE;
 289         char *query_string = NULL;
 290         char *thumbnail_path = NULL;
 291         sqlite3_stmt *stmt = NULL;
 292
 293         media_content_retv_if(thumb_list == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 294         media_content_retv_if(storage_id == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 295         media_content_retv_if(!STRING_VALID(condition_query), MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 296
 297         query_string = sqlite3_mprintf(SELECT_THUMBNAIL_BY_FILTER, storage_id, condition_query, storage_type);
 298
 299         ret = _content_query_prepare(&stmt, query_string, NULL, NULL);
 300         SQLITE3_SAFE_FREE(query_string);
 301
 302         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 303
 304         *thumb_list = g_array_new(FALSE, FALSE, sizeof(char*));
 305
 306         while (sqlite3_step(stmt) == SQLITE_ROW) {
 307                 thumbnail_path = g_strdup((const char *)sqlite3_column_text(stmt, 0));
 308                 if (STRING_VALID(thumbnail_path))
 309                         g_array_append_val(*thumb_list, thumbnail_path);
 310                 else
 311                         SAFE_FREE(thumbnail_path);
 312         }
 313
 314         SQLITE3_FINALIZE(stmt);
 315
 316         return ret;
 317 }
 318
 319 static int __media_info_check_file_validity(const char *path)
 320 {
 321         bool ignore = FALSE;
 322         char *folder_path = NULL;
 323         int ret = MEDIA_CONTENT_ERROR_NONE;
 324
 325         media_content_retvm_if(!STRING_VALID(path), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid path");
 326
 327         ret = _media_util_check_ignore_file(path, &ignore);
 328         media_content_retvm_if(ignore == TRUE, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid ignore path");
 329
 330         ret = _media_util_check_file_exist(path);
 331         media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "invalid path");
 332
 333         folder_path = g_path_get_dirname(path);
 334         ret = _media_util_check_ignore_dir(folder_path, &ignore);
 335         SAFE_FREE(folder_path);
 336         media_content_retvm_if(ignore == TRUE, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid folder path");
 337
 338         return MEDIA_CONTENT_ERROR_NONE;
 339 }
 340
 341 void _media_info_item_get_detail(sqlite3_stmt* stmt, media_info_h media)
 342 {
 343         media_info_s *_media = (media_info_s*)media;
 344
 345         char *tmp_path = NULL;
 346         char repl_path[MAX_PATH_LEN] = {0, };
 347
 348         _media->media_id = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_UUID));
 349
 350         tmp_path = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_PATH));
 351         _media_content_rollback_path(tmp_path, repl_path);
 352         _media->file_path = g_strdup(repl_path);
 353         SAFE_FREE(tmp_path);
 354
 355         _media->display_name = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_FILE_NAME));
 356         _media->media_type = (int)sqlite3_column_int(stmt, MEDIA_INFO_TYPE);
 357         _media->mime_type = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_MIME_TYPE));
 358         _media->size = (unsigned long long)sqlite3_column_int64(stmt, MEDIA_INFO_SIZE);
 359         _media->added_time = (int)sqlite3_column_int(stmt, MEDIA_INFO_ADDED_TIME);
 360         _media->modified_time = (int)sqlite3_column_int(stmt, MEDIA_INFO_MODIFIED_TIME);
 361         _media->thumbnail_path = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_THUMBNAIL_PATH));
 362         _media->description = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_DESCRIPTION));
 363         _media->rating = (int)sqlite3_column_int(stmt, MEDIA_INFO_RATING);
 364         _media->favourite = (int)sqlite3_column_int(stmt, MEDIA_INFO_FAVOURITE);
 365         _media->author = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_AUTHOR));
 366         _media->provider = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_PROVIDER));
 367         _media->content_name = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_CONTENT_NAME));
 368         _media->category = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_CATEGORY));
 369         _media->location_tag = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_LOCATION_TAG));
 370         _media->age_rating = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_AGE_RATING));
 371         _media->keyword = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_KEYWORD));
 372         _media->is_drm = (int)sqlite3_column_int(stmt, MEDIA_INFO_IS_DRM);
 373         _media->storage_type = (int)sqlite3_column_int(stmt, MEDIA_INFO_STORAGE_TYPE);
 374         _media->longitude = (double)sqlite3_column_double(stmt, MEDIA_INFO_LONGITUDE);
 375         _media->latitude = (double)sqlite3_column_double(stmt, MEDIA_INFO_LATITUDE);
 376         _media->altitude = (double)sqlite3_column_double(stmt, MEDIA_INFO_ALTITUDE);
 377         _media->played_count = sqlite3_column_int(stmt, MEDIA_INFO_PLAYED_COUNT);
 378         _media->played_time = sqlite3_column_int(stmt, MEDIA_INFO_LAST_PLAYED_TIME);
 379         _media->played_position = sqlite3_column_int(stmt, MEDIA_INFO_LAST_PLAYED_POSITION);
 380         _media->title = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_TITLE));
 381         _media->timeline = (double)sqlite3_column_double(stmt, MEDIA_INFO_TIMELINE);
 382         _media->weather = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_WEATHER));
 383         _media->sync_status = (int)sqlite3_column_int(stmt, MEDIA_INFO_SYNC_STATUS);
 384         _media->storage_uuid = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_STORAGE_UUID));
 385         _media->is_360 = (int)sqlite3_column_int(stmt, MEDIA_INFO_IS_360);
 386 #ifdef _USE_TVPD_MODE
 387         _media->stitched_info = (int)sqlite3_column_int(stmt, MEDIA_INFO_STITCHED_INFO);
 388 #endif
 389
 390         if (_media->media_type == MEDIA_CONTENT_TYPE_IMAGE) {
 391                 _media->image_meta = (image_meta_s *)calloc(1, sizeof(image_meta_s));
 392                 if (_media->image_meta) {
 393                         _media->image_meta->media_id = g_strdup(_media->media_id);
 394                         _media->image_meta->width = sqlite3_column_int(stmt, MEDIA_INFO_WIDTH);
 395                         _media->image_meta->height = sqlite3_column_int(stmt, MEDIA_INFO_HEIGHT);
 396                         _media->image_meta->fnumber = (double)sqlite3_column_double(stmt, MEDIA_INFO_FNUMBER);
 397                         _media->image_meta->iso = sqlite3_column_int(stmt, MEDIA_INFO_ISO);
 398                         _media->image_meta->date_taken = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_DATETAKEN));
 399                         _media->image_meta->orientation = sqlite3_column_int(stmt, MEDIA_INFO_ORIENTATION);
 400                         _media->image_meta->title = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_TITLE));
 401                         _media->image_meta->burst_id = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_BURST_ID));
 402                         _media->image_meta->exposure_time = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_EXPOSURE_TIME));
 403                         _media->image_meta->model = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_MODEL));
 404                 }
 405         } else if (_media->media_type == MEDIA_CONTENT_TYPE_VIDEO) {
 406                 _media->video_meta = (video_meta_s *)calloc(1, sizeof(video_meta_s));
 407                 if (_media->video_meta) {
 408                         _media->video_meta->media_id = g_strdup(_media->media_id);
 409                         _media->video_meta->width = sqlite3_column_int(stmt, MEDIA_INFO_WIDTH);
 410                         _media->video_meta->height = sqlite3_column_int(stmt, MEDIA_INFO_HEIGHT);
 411                         _media->video_meta->title = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_TITLE));
 412                         _media->video_meta->album = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_ALBUM));
 413                         _media->video_meta->artist = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_ARTIST));
 414                         _media->video_meta->album_artist = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_ALBUM_ARTIST));
 415                         _media->video_meta->genre = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_GENRE));
 416                         _media->video_meta->composer = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_COMPOSER));
 417                         _media->video_meta->year = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_YEAR));
 418                         _media->video_meta->recorded_date = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_RECORDED_DATE));
 419                         _media->video_meta->copyright = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_COPYRIGHT));
 420                         _media->video_meta->track_num = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_TRACK_NUM));
 421                         _media->video_meta->bitrate = sqlite3_column_int(stmt, MEDIA_INFO_BITRATE);
 422                         _media->video_meta->duration = sqlite3_column_int(stmt, MEDIA_INFO_DURATION);
 423                         _media->video_meta->rotation = sqlite3_column_int(stmt, MEDIA_INFO_ORIENTATION);
 424                 }
 425
 426         } else if ((_media->media_type == MEDIA_CONTENT_TYPE_MUSIC) || (_media->media_type == MEDIA_CONTENT_TYPE_SOUND)) {
 427                 _media->audio_meta = (audio_meta_s *)calloc(1, sizeof(audio_meta_s));
 428                 if (_media->audio_meta) {
 429                         _media->audio_meta->media_id = g_strdup(_media->media_id);
 430                         _media->audio_meta->title = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_TITLE));
 431                         _media->audio_meta->album = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_ALBUM));
 432                         _media->audio_meta->artist = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_ARTIST));
 433                         _media->audio_meta->album_artist = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_ALBUM_ARTIST));
 434                         _media->audio_meta->genre = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_GENRE));
 435                         _media->audio_meta->composer = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_COMPOSER));
 436                         _media->audio_meta->year = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_YEAR));
 437                         _media->audio_meta->recorded_date = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_RECORDED_DATE));
 438                         _media->audio_meta->copyright = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_COPYRIGHT));
 439                         _media->audio_meta->track_num = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_TRACK_NUM));
 440                         _media->audio_meta->bitrate = sqlite3_column_int(stmt, MEDIA_INFO_BITRATE);
 441                         _media->audio_meta->bitpersample = sqlite3_column_int(stmt, MEDIA_INFO_BITPERSAMPLE);
 442                         _media->audio_meta->duration = sqlite3_column_int(stmt, MEDIA_INFO_DURATION);
 443                         _media->audio_meta->samplerate = sqlite3_column_int(stmt, MEDIA_INFO_SAMPLERATE);
 444                         _media->audio_meta->channel = sqlite3_column_int(stmt, MEDIA_INFO_CHANNEL);
 445                 }
 446         }
 447 }
 448
 449 int _media_info_get_media_info_from_db(const char *path, const char *storage_id, media_info_h media)
 450 {
 451         int ret = MEDIA_CONTENT_ERROR_NONE;
 452         sqlite3_stmt *stmt = NULL;
 453         char *select_query = NULL;
 454         media_info_s *_media = (media_info_s*)media;
 455
 456         media_content_retvm_if(_media == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid media");
 457
 458         select_query = sqlite3_mprintf(SELECT_MEDIA_BY_PATH, storage_id, path);
 459
 460         ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
 461         SQLITE3_SAFE_FREE(select_query);
 462         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 463
 464         if (sqlite3_step(stmt) == SQLITE_ROW) {
 465                 _media_info_item_get_detail(stmt, (media_info_h)_media);
 466         } else {
 467                 media_content_sec_error("No media : path[%s] storage id[%s]", path, storage_id);
 468                 ret = MEDIA_CONTENT_ERROR_DB_FAILED;
 469         }
 470
 471         SQLITE3_FINALIZE(stmt);
 472
 473         return ret;
 474 }
 475
 476 int media_info_insert_to_db(const char *path, media_info_h *info)
 477 {
 478         char storage_id[MEDIA_CONTENT_UUID_SIZE+1] = {0, };
 479         char repl_path[MAX_PATH_LEN] = {0, };
 480         int ret = MEDIA_CONTENT_ERROR_NONE;
 481
 482         media_content_retvm_if(!STRING_VALID(path), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid path");
 483         media_content_retvm_if(info == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid info");
 484         memset(repl_path, 0, sizeof(repl_path));
 485         ret = _media_content_replace_path(path, repl_path);
 486         media_content_retvm_if(!STRING_VALID(repl_path), MEDIA_CONTENT_ERROR_INVALID_OPERATION, "path replacement failed");
 487
 488         ret = __media_info_check_file_validity(repl_path);
 489         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 490
 491         memset(storage_id, 0x00, sizeof(storage_id));
 492         ret = media_svc_get_storage_id(_content_get_db_handle(), repl_path, storage_id, _content_get_uid());
 493         if (ret != MS_MEDIA_ERR_NONE) {
 494                 media_content_error("media_svc_get_storage_id failed : %d", ret);
 495                 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 496         }
 497
 498         ret = media_svc_check_item_exist_by_path(_content_get_db_handle(), storage_id, repl_path);
 499         if (ret == MS_MEDIA_ERR_DB_NO_RECORD) {
 500                 media_content_sec_debug("media_svc_check_item_exist_by_path : no record : %s", repl_path);
 501                 media_content_retvm_if(!_media_util_check_support_media_type(repl_path), MEDIA_CONTENT_ERROR_NOT_SUPPORTED, "Unsupported media type");
 502                 media_svc_storage_type_e storage_type = 0;
 503
 504                 ret = media_svc_get_storage_type(repl_path, &storage_type, _content_get_uid());
 505                 if (ret != MS_MEDIA_ERR_NONE) {
 506                         media_content_sec_error("media_svc_get_storage_type failed : %d", ret);
 507                         return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 508                 }
 509
 510                 ret = media_svc_insert_item_immediately(_content_get_db_handle(), storage_id, storage_type, repl_path, _content_get_uid());
 511
 512                 if (ret != MS_MEDIA_ERR_NONE) {
 513                         if (ret == MS_MEDIA_ERR_DB_CONSTRAINT_FAIL) {
 514                                 media_content_sec_error("This item is already inserted. This may be normal operation because other process already did this (%s)", repl_path);
 515                                 ret = MEDIA_CONTENT_ERROR_NONE;
 516                         } else {
 517                                 media_content_sec_error("media_svc_insert_item_immediately failed : %d (%s)", ret, repl_path);
 518                         }
 519
 520                         return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 521                 }
 522         } else if (ret != MS_MEDIA_ERR_NONE) {
 523                 media_content_sec_error("media_svc_check_item_exist_by_path failed : %d (%s)", ret, repl_path);
 524                 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 525         }
 526
 527         media_info_s *_media = (media_info_s*)calloc(1, sizeof(media_info_s));
 528         media_content_retvm_if(_media == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 529
 530         if (STRING_VALID(storage_id))
 531                 ret = _media_info_get_media_info_from_db(repl_path, storage_id, (media_info_h)_media);
 532         else
 533                 ret = _media_info_get_media_info_from_db(repl_path, DEFAULT_MEDIA_STORAGE_ID, (media_info_h)_media);
 534
 535         *info = (media_info_h)_media;
 536         return ret;
 537 }
 538
 539 int media_info_insert_batch_to_db(const char **path_array, unsigned int array_length, media_insert_completed_cb completed_cb, void *user_data)
 540 {
 541         char **repl_path_array = NULL;
 542         int idx = 0;
 543         int ret = MS_MEDIA_ERR_NONE;
 544         char repl_path[MAX_PATH_LEN] = {0, };
 545
 546         media_content_retvm_if(path_array == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid path_array");
 547         media_content_retvm_if(array_length <= 0, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid array_length");
 548
 549         repl_path_array = calloc(1, sizeof(char *) * array_length);
 550         media_content_retvm_if(repl_path_array == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 551
 552         for (idx = 0; idx < array_length; idx++) {
 553                 if (STRING_VALID(path_array[idx])) {
 554                         memset(repl_path, 0, sizeof(repl_path));
 555                         _media_content_replace_path(path_array[idx], repl_path);
 556                         repl_path_array[idx] = strndup(repl_path, strlen(repl_path));
 557                 } else {
 558                         media_content_error("path[%d] is invalid string", idx);
 559                 }
 560         }
 561
 562         ret = __media_info_insert_batch(MEDIA_BATCH_INSERT_NORMAL, (const char **)repl_path_array, array_length, completed_cb, user_data);
 563         for (idx = 0; idx < array_length; idx++)
 564                 SAFE_FREE(repl_path_array[idx]);
 565
 566         SAFE_FREE(repl_path_array);
 567
 568         return ret;
 569 }
 570
 571 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)
 572 {
 573         char **repl_path_array = NULL;
 574         int idx = 0;
 575         int ret = MS_MEDIA_ERR_NONE;
 576         char repl_path[MAX_PATH_LEN] = {0, };
 577
 578         media_content_warn("DEPRECATION WARNING: media_info_insert_burst_shot_to_db() is deprecated and will be removed from next release.");
 579
 580         media_content_retvm_if(path_array == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid path_array");
 581         media_content_retvm_if(array_length <= 0, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid array_length");
 582
 583         repl_path_array = calloc(1, sizeof(char *) * array_length);
 584         media_content_retvm_if(repl_path_array == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 585
 586         for (idx = 0; idx < array_length; idx++) {
 587                 if (STRING_VALID(path_array[idx])) {
 588                         memset(repl_path, 0, sizeof(repl_path));
 589                         _media_content_replace_path(path_array[idx], repl_path);
 590                         repl_path_array[idx] = strndup(repl_path, strlen(repl_path));
 591                 } else {
 592                         media_content_error("path[%d] is invalid string", idx);
 593                 }
 594         }
 595
 596         ret = __media_info_insert_batch(MEDIA_BATCH_INSERT_BURSTSHOT, (const char **)repl_path_array, array_length, callback, user_data);
 597         for (idx = 0; idx < array_length; idx++)
 598                 SAFE_FREE(repl_path_array[idx]);
 599
 600         SAFE_FREE(repl_path_array);
 601
 602         return ret;
 603 }
 604
 605 #ifdef _USE_TVPD_MODE
 606 int media_info_get_media_info_by_path_from_db(const char* path, media_info_h* media)
 607 {
 608         char storage_id[MEDIA_CONTENT_UUID_SIZE+1] = {0,};
 609         int ret = MEDIA_CONTENT_ERROR_NONE;
 610         media_content_retvm_if(!STRING_VALID(path), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid path");
 611         media_content_retvm_if(media == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid info");
 612
 613         memset(storage_id, 0x00, sizeof(storage_id));
 614         ret = media_svc_get_storage_id(_content_get_db_handle(), path, storage_id, tzplatform_getuid(TZ_USER_NAME));
 615         if (ret != MS_MEDIA_ERR_NONE) {
 616                 media_content_error("media_svc_get_storage_id failed : %d", ret);
 617                 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 618         }
 619
 620         media_info_s *_media = (media_info_s*)calloc(1, sizeof(media_info_s));
 621         media_content_retvm_if(_media == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 622
 623         ret =  _media_info_get_media_info_from_db(path, storage_id, (media_info_h)_media);
 624         *media = (media_info_h)_media;
 625
 626         return ret;
 627 }
 628 #endif
 629
 630 #ifdef _USE_SENIOR_MODE
 631 int media_info_set_contact(media_info_h media, const char *contact)
 632 {
 633         return __media_info_set_str_data(media, MEDIA_INFO_CONTACT, contact);
 634 }
 635
 636 int media_info_set_app_data(media_info_h media, const char *app_data)
 637 {
 638         return __media_info_set_str_data(media, MEDIA_INFO_APP_DATA, app_data);
 639 }
 640
 641 int media_info_insert_to_db_with_contact_data(const char *path, const char* contact, const char* app_data, media_info_h *info)
 642 {
 643         int ret = media_info_insert_to_db(path, info);
 644         media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "media_info_insert_to_db [%s] failed", path);
 645
 646         ret = media_info_set_contact(*info, contact);
 647         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 648                 media_content_error("media_info_set_contact [%s] failed", contact);
 649
 650                 media_info_s* _media_info = (media_info_s*)*info;
 651                 ret = media_info_delete_from_db(_media_info->media_id);
 652                 media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "media_info_delete_from_db [%s] failed", _media_info->media_id);
 653
 654                 media_info_destroy(*info);
 655                 return ret;
 656         }
 657
 658         ret = media_info_set_app_data(*info, app_data);
 659         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 660                 media_content_error("media_info_set_app_data [%s] failed", app_data);
 661
 662                 media_info_s* _media_info = (media_info_s*)*info;
 663                 ret = media_info_delete_from_db(_media_info->media_id);
 664                 media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "media_info_delete_from_db [%s] failed", _media_info->media_id);
 665
 666                 media_info_destroy(*info);
 667                 return ret;
 668         }
 669
 670         ret = media_info_update_to_db(*info);
 671         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 672                 media_content_error("media_info_update_to_db [] failed");
 673
 674                 media_info_s* _media_info = (media_info_s*)*info;
 675                 ret = media_info_delete_from_db(_media_info->media_id);
 676                 media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "media_info_delete_from_db [%s] failed", _media_info->media_id);
 677
 678                 media_info_destroy(*info);
 679                 return ret;
 680         }
 681
 682         return ret;
 683 }
 684
 685 int media_info_delete_contact_from_db(const char* contact, const char* storage_id)
 686 {
 687         return -1;
 688 }
 689
 690 int media_info_delete_item(const char *media_id)
 691 {
 692         int ret = MEDIA_CONTENT_ERROR_NONE;
 693         char *path = NULL;
 694         char storage_id[MEDIA_CONTENT_UUID_SIZE+1] = {0,};
 695
 696         if (!STRING_VALID(media_id)) {
 697                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 698                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 699         }
 700
 701         memset(storage_id, 0x00, sizeof(storage_id));
 702
 703         ret = __media_info_get_media_path_by_id_from_db(media_id, &path);
 704         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 705                 media_content_error("__media_info_get_media_path_by_id_from_db failed : %d", ret);
 706                 SAFE_FREE(path);
 707                 return ret;
 708         }
 709
 710         ret = _media_db_get_storage_id_by_media_id(media_id, storage_id);
 711         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 712                 media_content_error("_media_db_get_storage_id_by_media_id failed : %d", ret);
 713                 SAFE_FREE(path);
 714                 return ret;
 715         }
 716
 717         ret = media_svc_delete_item_by_path(_content_get_db_handle(), storage_id, path, tzplatform_getuid(TZ_USER_NAME));
 718         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 719                 media_content_error("remove from DB failed : %d", ret);
 720                 SAFE_FREE(path);
 721                 return ret;
 722         }
 723
 724         ret = media_svc_remove_file(path);
 725         SAFE_FREE(path);
 726         return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 727 }
 728
 729 #endif
 730
 731 int media_info_delete_from_db(const char *media_id)
 732 {
 733         int ret = MEDIA_CONTENT_ERROR_NONE;
 734         char *path = NULL;
 735         char storage_id[MEDIA_CONTENT_UUID_SIZE+1] = {0, };
 736         media_content_warn("DEPRECATION WARNING: media_info_delete_from_db() is deprecated and will be removed from next release. Use media_content_scan_file() instead.");
 737
 738         if (!STRING_VALID(media_id)) {
 739                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 740                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 741         }
 742
 743         memset(storage_id, 0x00, sizeof(storage_id));
 744
 745         ret = __media_info_get_media_path_by_id_from_db(media_id, &path);
 746         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 747                 media_content_error("__media_info_get_media_path_by_id_from_db failed : %d", ret);
 748                 SAFE_FREE(path);
 749                 return ret;
 750         }
 751
 752         ret = _media_db_get_storage_id_by_media_id(media_id, storage_id);
 753         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 754                 media_content_error("_media_db_get_storage_id_by_media_id failed : %d", ret);
 755                 SAFE_FREE(path);
 756                 return ret;
 757         }
 758
 759         ret = media_svc_delete_item_by_path(_content_get_db_handle(), storage_id, path, _content_get_uid());
 760         SAFE_FREE(path);
 761
 762         return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 763 }
 764
 765 static int __media_info_delete_thumb_from_list(GArray *thumb_list)
 766 {
 767         int i = 0;
 768         int list_len = 0;
 769         char *thumb_path = NULL;
 770
 771         if (thumb_list != NULL) {
 772                 list_len = thumb_list->len;
 773                 for (i = 0; i < list_len; i++) {
 774                         thumb_path = g_array_index(thumb_list, char*, i);
 775                         media_content_debug("thumb path [%s]", thumb_path);
 776                         if (unlink(thumb_path) < 0)
 777                                 media_content_stderror("failed to delete");
 778                 }
 779         }
 780         return MEDIA_CONTENT_ERROR_NONE;
 781 }
 782
 783 static int __media_info_release_thumb_list(GArray *thumb_list)
 784 {
 785         int i = 0;
 786         int list_len = 0;
 787         char *thumb_path = NULL;
 788
 789         if (thumb_list != NULL) {
 790                 list_len = thumb_list->len;
 791                 for (i = 0; i < list_len; i++) {
 792                         thumb_path = g_array_index(thumb_list, char*, 0);
 793                         g_array_remove_index(thumb_list, 0);
 794                         SAFE_FREE(thumb_path);
 795                 }
 796
 797                 g_array_free(thumb_list, FALSE);
 798         }
 799
 800         return MEDIA_CONTENT_ERROR_NONE;
 801 }
 802
 803 static int __media_info_release_storage_list(GArray *storage_list)
 804 {
 805         int i = 0;
 806         int list_len = 0;
 807         media_storage_s *storage = NULL;
 808
 809         if (storage_list != NULL) {
 810                 list_len = storage_list->len;
 811                 for (i = 0; i < list_len; i++) {
 812                         storage = g_array_index(storage_list, media_storage_s *, 0);
 813                         g_array_remove_index(storage_list, 0);
 814                         SAFE_FREE(storage->storage_id);
 815                         SAFE_FREE(storage);
 816                 }
 817
 818                 g_array_free(storage_list, FALSE);
 819         }
 820
 821         return MEDIA_CONTENT_ERROR_NONE;
 822 }
 823
 824 int media_info_delete_batch_from_db(filter_h filter)
 825 {
 826         int ret = MEDIA_CONTENT_ERROR_NONE;
 827         char *query_string = NULL;
 828         filter_s *_filter = NULL;
 829         attribute_h attr;
 830         char *condition_query = NULL;
 831         GArray *storage_list = NULL;
 832         GArray *thumb_list = NULL;
 833         int idx = 0;
 834         media_storage_s *storage_item = NULL;
 835
 836         media_content_warn("DEPRECATION WARNING: media_info_delete_batch_from_db() is deprecated and will be removed from next release.");
 837
 838         media_content_retvm_if(filter == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid filter");
 839
 840         _filter = (filter_s*)filter;
 841
 842         media_content_retvm_if(_filter->condition == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid condition");
 843
 844         attr = _content_get_attirbute_handle();
 845
 846         ret = _media_filter_attribute_generate(attr, filter, &condition_query);
 847         media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "Invalid condition");
 848
 849         ret = __media_info_get_storage_list_to_remove(condition_query, &storage_list);
 850         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 851                 SAFE_FREE(condition_query);
 852                 __media_info_release_storage_list(storage_list);
 853
 854                 return ret;
 855         }
 856
 857         for (idx = 0; idx < storage_list->len; idx++) {
 858                 storage_item = g_array_index(storage_list, media_storage_s *, idx);
 859                 /*media_content_debug("storage_id[%s] storage_type[%d]", storage_item->storage_id, storage_item->storage_type);*/
 860
 861                 ret = __media_info_get_thumbnail_to_remove(condition_query, storage_item->storage_id, storage_item->storage_type, &thumb_list);
 862                 if (ret != MEDIA_CONTENT_ERROR_NONE) {
 863                         SAFE_FREE(condition_query);
 864                         __media_info_release_storage_list(storage_list);
 865                         __media_info_release_thumb_list(thumb_list);
 866
 867                         return ret;
 868                 }
 869
 870                 query_string = sqlite3_mprintf(DELETE_MEDIA_FROM_MEDIA_BATCH, storage_item->storage_id, condition_query, storage_item->storage_type);
 871
 872                 ret = _content_query_sql(query_string);
 873                 SQLITE3_SAFE_FREE(query_string);
 874
 875                 if (ret == MEDIA_CONTENT_ERROR_NONE) {
 876                         media_content_debug("Batch deletion succeeded. Send notification for this");
 877                         if (storage_item->storage_type == MEDIA_CONTENT_STORAGE_INTERNAL) {
 878                                 media_svc_publish_noti(MS_MEDIA_ITEM_DIRECTORY, MS_MEDIA_ITEM_UPDATE, MEDIA_ROOT_PATH_INTERNAL, -1, NULL, NULL);
 879                         } else {
 880                                 char *storage_path = NULL;
 881                                 media_svc_get_storage_path(_content_get_db_handle(), storage_item->storage_id, &storage_path);
 882                                 if (STRING_VALID(storage_path))
 883                                         media_svc_publish_noti(MS_MEDIA_ITEM_DIRECTORY, MS_MEDIA_ITEM_UPDATE, storage_path, -1, NULL, NULL);
 884
 885                                 SAFE_FREE(storage_path);
 886                         }
 887                         __media_info_delete_thumb_from_list(thumb_list);
 888                 }
 889                 __media_info_release_thumb_list(thumb_list);
 890
 891         }
 892
 893         SAFE_FREE(condition_query);
 894         __media_info_release_storage_list(storage_list);
 895
 896         return ret;
 897 }
 898
 899 int media_info_destroy(media_info_h media)
 900 {
 901         int ret = MEDIA_CONTENT_ERROR_NONE;
 902         media_info_s *_media = (media_info_s*)media;
 903
 904         if (_media) {
 905                 SAFE_FREE(_media->media_id);
 906                 SAFE_FREE(_media->file_path);
 907                 SAFE_FREE(_media->display_name);
 908                 SAFE_FREE(_media->mime_type);
 909                 SAFE_FREE(_media->thumbnail_path);
 910                 SAFE_FREE(_media->description);
 911                 SAFE_FREE(_media->author);
 912                 SAFE_FREE(_media->provider);
 913                 SAFE_FREE(_media->content_name);
 914                 SAFE_FREE(_media->category);
 915                 SAFE_FREE(_media->location_tag);
 916                 SAFE_FREE(_media->age_rating);
 917                 SAFE_FREE(_media->keyword);
 918                 SAFE_FREE(_media->title);
 919 #ifdef _USE_TVPD_MODE
 920                 SAFE_FREE(_media->modified_month);
 921 #endif
 922                 SAFE_FREE(_media->weather);
 923                 SAFE_FREE(_media->storage_uuid);
 924 #ifdef _USE_SENIOR_MODE
 925                 SAFE_FREE(_media->contact);
 926                 SAFE_FREE(_media->app_data);
 927 #endif
 928
 929                 if (_media->image_meta) {
 930                         SAFE_FREE(_media->image_meta->media_id);
 931                         SAFE_FREE(_media->image_meta->date_taken);
 932                         SAFE_FREE(_media->image_meta->burst_id);
 933                         SAFE_FREE(_media->image_meta->exposure_time);
 934                         SAFE_FREE(_media->image_meta->model);
 935                         SAFE_FREE(_media->image_meta->title);
 936
 937                         SAFE_FREE(_media->image_meta);
 938                 }
 939
 940                 if (_media->video_meta) {
 941                         SAFE_FREE(_media->video_meta->media_id);
 942                         SAFE_FREE(_media->video_meta->title);
 943                         SAFE_FREE(_media->video_meta->album);
 944                         SAFE_FREE(_media->video_meta->artist);
 945                         SAFE_FREE(_media->video_meta->album_artist);
 946                         SAFE_FREE(_media->video_meta->genre);
 947                         SAFE_FREE(_media->video_meta->composer);
 948                         SAFE_FREE(_media->video_meta->year);
 949                         SAFE_FREE(_media->video_meta->recorded_date);
 950                         SAFE_FREE(_media->video_meta->copyright);
 951                         SAFE_FREE(_media->video_meta->track_num);
 952
 953                         SAFE_FREE(_media->video_meta);
 954                 }
 955
 956                 if (_media->audio_meta) {
 957                         SAFE_FREE(_media->audio_meta->media_id);
 958                         SAFE_FREE(_media->audio_meta->title);
 959                         SAFE_FREE(_media->audio_meta->album);
 960                         SAFE_FREE(_media->audio_meta->artist);
 961                         SAFE_FREE(_media->audio_meta->album_artist);
 962                         SAFE_FREE(_media->audio_meta->genre);
 963                         SAFE_FREE(_media->audio_meta->composer);
 964                         SAFE_FREE(_media->audio_meta->year);
 965                         SAFE_FREE(_media->audio_meta->recorded_date);
 966                         SAFE_FREE(_media->audio_meta->copyright);
 967                         SAFE_FREE(_media->audio_meta->track_num);
 968
 969                         SAFE_FREE(_media->audio_meta);
 970                 }
 971
 972                 SAFE_FREE(_media);
 973
 974                 ret = MEDIA_CONTENT_ERROR_NONE;
 975         } else {
 976                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 977                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 978         }
 979
 980         return ret;
 981 }
 982
 983 int media_info_clone(media_info_h *dst, media_info_h src)
 984 {
 985         int ret = MEDIA_CONTENT_ERROR_NONE;
 986         media_info_s *_src = (media_info_s*)src;
 987
 988         if (_src != NULL) {
 989                 media_info_s *_dst = (media_info_s*)calloc(1, sizeof(media_info_s));
 990                 media_content_retvm_if(_dst == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 991
 992                 if (_src->media_id) {
 993                         _dst->media_id = g_strdup(_src->media_id);
 994                         if (_dst->media_id == NULL) {
 995                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 996                                 media_info_destroy((media_info_h)_dst);
 997                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 998                         }
 999                 }
1000                 if (_src->file_path) {
1001                         _dst->file_path = g_strdup(_src->file_path);
1002                         if (_dst->file_path == NULL) {
1003                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1004                                 media_info_destroy((media_info_h)_dst);
1005                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1006                         }
1007                 }
1008                 if (_src->display_name != NULL) {
1009                         _dst->display_name = g_strdup(_src->display_name);
1010                         if (_dst->display_name == NULL) {
1011                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1012                                 media_info_destroy((media_info_h)_dst);
1013                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1014                         }
1015                 }
1016                 if (_src->mime_type) {
1017                         _dst->mime_type = g_strdup(_src->mime_type);
1018                         if (_dst->mime_type == NULL) {
1019                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1020                                 media_info_destroy((media_info_h)_dst);
1021                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1022                         }
1023                 }
1024                 if (_src->thumbnail_path != NULL) {
1025                         _dst->thumbnail_path = g_strdup(_src->thumbnail_path);
1026                         if (_dst->thumbnail_path == NULL) {
1027                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1028                                 media_info_destroy((media_info_h)_dst);
1029                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1030                         }
1031                 }
1032                 if (_src->description != NULL) {
1033                         _dst->description = g_strdup(_src->description);
1034                         if (_dst->description == NULL) {
1035                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1036                                 media_info_destroy((media_info_h)_dst);
1037                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1038                         }
1039                 }
1040
1041                 if (_src->weather != NULL) {
1042                         _dst->weather = g_strdup(_src->weather);
1043                         if (_dst->weather == NULL) {
1044                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1045                                 media_info_destroy((media_info_h)_dst);
1046                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1047                         }
1048                 }
1049
1050                 if (_src->title != NULL) {
1051                         _dst->title = g_strdup(_src->title);
1052                         if (_dst->title == NULL) {
1053                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1054                                 media_info_destroy((media_info_h)_dst);
1055                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1056                         }
1057                 }
1058                 if (_src->author != NULL) {
1059                         _dst->author = g_strdup(_src->author);
1060                         if (_dst->author == NULL) {
1061                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1062                                 media_info_destroy((media_info_h)_dst);
1063                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1064                         }
1065                 }
1066                 if (_src->provider != NULL) {
1067                         _dst->provider = g_strdup(_src->provider);
1068                         if (_dst->provider == NULL) {
1069                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1070                                 media_info_destroy((media_info_h)_dst);
1071                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1072                         }
1073                 }
1074                 if (_src->content_name != NULL) {
1075                         _dst->content_name = g_strdup(_src->content_name);
1076                         if (_dst->content_name == NULL) {
1077                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1078                                 media_info_destroy((media_info_h)_dst);
1079                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1080                         }
1081                 }
1082                 if (_src->category != NULL) {
1083                         _dst->category = g_strdup(_src->category);
1084                         if (_dst->category == NULL) {
1085                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1086                                 media_info_destroy((media_info_h)_dst);
1087                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1088                         }
1089                 }
1090                 if (_src->location_tag != NULL) {
1091                         _dst->location_tag = g_strdup(_src->location_tag);
1092                         if (_dst->location_tag == NULL) {
1093                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1094                                 media_info_destroy((media_info_h)_dst);
1095                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1096                         }
1097                 }
1098                 if (_src->age_rating != NULL) {
1099                         _dst->age_rating = g_strdup(_src->age_rating);
1100                         if (_dst->age_rating == NULL) {
1101                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1102                                 media_info_destroy((media_info_h)_dst);
1103                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1104                         }
1105                 }
1106                 if (_src->keyword != NULL) {
1107                         _dst->keyword = g_strdup(_src->keyword);
1108                         if (_dst->keyword == NULL) {
1109                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1110                                 media_info_destroy((media_info_h)_dst);
1111                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1112                         }
1113                 }
1114
1115                 if (_src->storage_uuid != NULL) {
1116                         _dst->storage_uuid = g_strdup(_src->storage_uuid);
1117                         if (_dst->storage_uuid == NULL) {
1118                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1119                                 media_info_destroy((media_info_h)_dst);
1120                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1121                         }
1122                 }
1123 #ifdef _USE_TVPD_MODE
1124                 if (STRING_VALID(_src->modified_month)) {
1125                         _dst->modified_month = strdup(_src->modified_month);
1126                         if (_dst->modified_month == NULL) {
1127                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1128                                 media_info_destroy((media_info_h)_dst);
1129                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1130                         }
1131                 }
1132 #endif
1133 #ifdef _USE_SENIOR_MODE
1134                 if (STRING_VALID(_src->contact)) {
1135                         _dst->contact = strdup(_src->contact);
1136                         if (_dst->contact == NULL) {
1137                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1138                                 media_info_destroy((media_info_h)_dst);
1139                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1140                         }
1141                 }
1142
1143                 if (STRING_VALID(_src->app_data)) {
1144                         _dst->app_data = strdup(_src->app_data);
1145                         if (_dst->app_data == NULL) {
1146                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1147                                 media_info_destroy((media_info_h)_dst);
1148                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1149                         }
1150                 }
1151 #endif
1152
1153                 _dst->media_type = _src->media_type;
1154                 _dst->size = _src->size;
1155                 _dst->added_time = _src->added_time;
1156                 _dst->modified_time = _src->modified_time;
1157                 _dst->timeline = _src->timeline;
1158                 _dst->longitude = _src->longitude;
1159                 _dst->latitude = _src->latitude;
1160                 _dst->altitude = _src->altitude;
1161                 _dst->rating = _src->rating;
1162                 _dst->favourite = _src->favourite;
1163                 _dst->is_drm = _src->is_drm;
1164                 _dst->storage_type = _src->storage_type;
1165                 _dst->played_count = _src->played_count;
1166                 _dst->played_time = _src->played_time;
1167                 _dst->played_position = _src->played_position;
1168                 _dst->sync_status = _src->sync_status;
1169                 _dst->request_id = _src->request_id;
1170                 _dst->face_request_id = _src->face_request_id;
1171                 _dst->is_360 = _src->is_360;
1172 #ifdef _USE_TVPD_MODE
1173                 _dst->stitched_info = _src->stitched_info;
1174                 _dst->extract_flag = _src->extract_flag;
1175 #endif
1176
1177                 if (_src->media_type == MEDIA_CONTENT_TYPE_IMAGE && _src->image_meta) {
1178                         _dst->image_meta = (image_meta_s *)calloc(1, sizeof(image_meta_s));
1179                         if (_dst->image_meta == NULL) {
1180                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1181                                 media_info_destroy((media_info_h)_dst);
1182                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1183                         }
1184
1185                         if (_src->image_meta->media_id != NULL) {
1186                                 _dst->image_meta->media_id = g_strdup(_src->image_meta->media_id);
1187                                 if (_dst->image_meta->media_id == NULL) {
1188                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1189                                         media_info_destroy((media_info_h)_dst);
1190                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1191                                 }
1192                         }
1193
1194                         if (_src->image_meta->date_taken != NULL) {
1195                                 _dst->image_meta->date_taken = g_strdup(_src->image_meta->date_taken);
1196                                 if (_dst->image_meta->date_taken == NULL) {
1197                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1198                                         media_info_destroy((media_info_h)_dst);
1199                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1200                                 }
1201                         }
1202
1203                         if (_src->image_meta->burst_id != NULL) {
1204                                 _dst->image_meta->burst_id = g_strdup(_src->image_meta->burst_id);
1205                                 if (_dst->image_meta->burst_id == NULL) {
1206                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1207                                         media_info_destroy((media_info_h)_dst);
1208                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1209                                 }
1210                         }
1211
1212                         if (_src->image_meta->exposure_time != NULL) {
1213                                 _dst->image_meta->exposure_time = g_strdup(_src->image_meta->exposure_time);
1214                                 if (_dst->image_meta->exposure_time == NULL) {
1215                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1216                                         media_info_destroy((media_info_h)_dst);
1217                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1218                                 }
1219                         }
1220
1221                         if (_src->image_meta->model != NULL) {
1222                                 _dst->image_meta->model = g_strdup(_src->image_meta->model);
1223                                 if (_dst->image_meta->model == NULL) {
1224                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1225                                         media_info_destroy((media_info_h)_dst);
1226                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1227                                 }
1228                         }
1229
1230                         _dst->image_meta->fnumber = _src->image_meta->fnumber;
1231                         _dst->image_meta->iso = _src->image_meta->iso;
1232                         _dst->image_meta->width = _src->image_meta->width;
1233                         _dst->image_meta->height = _src->image_meta->height;
1234                         _dst->image_meta->orientation = _src->image_meta->orientation;
1235
1236                 } else if (_src->media_type == MEDIA_CONTENT_TYPE_VIDEO && _src->video_meta) {
1237                         _dst->video_meta = (video_meta_s *)calloc(1, sizeof(video_meta_s));
1238                         if (_dst->video_meta == NULL) {
1239                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1240                                 media_info_destroy((media_info_h)_dst);
1241                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1242                         }
1243
1244                         if (_src->video_meta->media_id != NULL) {
1245                                 _dst->video_meta->media_id = g_strdup(_src->video_meta->media_id);
1246                                 if (_dst->video_meta->media_id == NULL) {
1247                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1248                                         media_info_destroy((media_info_h)_dst);
1249                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1250                                 }
1251                         }
1252                         if (_src->video_meta->title != NULL) {
1253                                 _dst->video_meta->title = g_strdup(_src->video_meta->title);
1254                                 if (_dst->video_meta->title == NULL) {
1255                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1256                                         media_info_destroy((media_info_h)_dst);
1257                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1258                                 }
1259                         }
1260                         if (_src->video_meta->album != NULL) {
1261                                 _dst->video_meta->album = g_strdup(_src->video_meta->album);
1262                                 if (_dst->video_meta->album == NULL) {
1263                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1264                                         media_info_destroy((media_info_h)_dst);
1265                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1266                                 }
1267                         }
1268                         if (_src->video_meta->artist != NULL) {
1269                                 _dst->video_meta->artist = g_strdup(_src->video_meta->artist);
1270                                 if (_dst->video_meta->artist == NULL) {
1271                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1272                                         media_info_destroy((media_info_h)_dst);
1273                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1274                                 }
1275                         }
1276                         if (_src->video_meta->album_artist != NULL) {
1277                                 _dst->video_meta->album_artist = g_strdup(_src->video_meta->album_artist);
1278                                 if (_dst->video_meta->album_artist == NULL) {
1279                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1280                                         media_info_destroy((media_info_h)_dst);
1281                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1282                                 }
1283                         }
1284                         if (_src->video_meta->genre != NULL) {
1285                                 _dst->video_meta->genre = g_strdup(_src->video_meta->genre);
1286                                 if (_dst->video_meta->genre == NULL) {
1287                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1288                                         media_info_destroy((media_info_h)_dst);
1289                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1290                                 }
1291                         }
1292                         if (_src->video_meta->composer != NULL) {
1293                                 _dst->video_meta->composer = g_strdup(_src->video_meta->composer);
1294                                 if (_dst->video_meta->composer == NULL) {
1295                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1296                                         media_info_destroy((media_info_h)_dst);
1297                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1298                                 }
1299                         }
1300                         if (_src->video_meta->year != NULL) {
1301                                 _dst->video_meta->year = g_strdup(_src->video_meta->year);
1302                                 if (_dst->video_meta->year == NULL) {
1303                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1304                                         media_info_destroy((media_info_h)_dst);
1305                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1306                                 }
1307                         }
1308                         if (_src->video_meta->recorded_date != NULL) {
1309                                 _dst->video_meta->recorded_date = g_strdup(_src->video_meta->recorded_date);
1310                                 if (_dst->video_meta->recorded_date == NULL) {
1311                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1312                                         media_info_destroy((media_info_h)_dst);
1313                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1314                                 }
1315                         }
1316                         if (_src->video_meta->copyright != NULL) {
1317                                 _dst->video_meta->copyright = g_strdup(_src->video_meta->copyright);
1318                                 if (_dst->video_meta->copyright == NULL) {
1319                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1320                                         media_info_destroy((media_info_h)_dst);
1321                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1322                                 }
1323                         }
1324                         if (_src->video_meta->track_num != NULL) {
1325                                 _dst->video_meta->track_num = g_strdup(_src->video_meta->track_num);
1326                                 if (_dst->video_meta->track_num == NULL) {
1327                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1328                                         media_info_destroy((media_info_h)_dst);
1329                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1330                                 }
1331                         }
1332
1333                         _dst->video_meta->width = _src->video_meta->width;
1334                         _dst->video_meta->height = _src->video_meta->height;
1335                         _dst->video_meta->duration = _src->video_meta->duration;
1336                         _dst->video_meta->bitrate = _src->video_meta->bitrate;
1337                         _dst->video_meta->rotation = _src->video_meta->rotation;
1338
1339                 } else if ((_src->media_type == MEDIA_CONTENT_TYPE_MUSIC || _src->media_type == MEDIA_CONTENT_TYPE_SOUND) && _src->audio_meta) {
1340                         _dst->audio_meta = (audio_meta_s *)calloc(1, sizeof(audio_meta_s));
1341                         if (_dst->audio_meta == NULL) {
1342                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1343                                 media_info_destroy((media_info_h)_dst);
1344                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1345                         }
1346
1347                         if (_src->audio_meta->media_id != NULL) {
1348                                 _dst->audio_meta->media_id = g_strdup(_src->audio_meta->media_id);
1349                                 if (_dst->audio_meta->media_id == NULL) {
1350                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1351                                         media_info_destroy((media_info_h)_dst);
1352                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1353                                 }
1354                         }
1355                         if (_src->audio_meta->title != NULL) {
1356                                 _dst->audio_meta->title = g_strdup(_src->audio_meta->title);
1357                                 if (_dst->audio_meta->title == NULL) {
1358                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1359                                         media_info_destroy((media_info_h)_dst);
1360                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1361                                 }
1362                         }
1363                         if (_src->audio_meta->album != NULL) {
1364                                 _dst->audio_meta->album = g_strdup(_src->audio_meta->album);
1365                                 if (_dst->audio_meta->album == NULL) {
1366                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1367                                         media_info_destroy((media_info_h)_dst);
1368                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1369                                 }
1370                         }
1371                         if (_src->audio_meta->artist != NULL) {
1372                                 _dst->audio_meta->artist = g_strdup(_src->audio_meta->artist);
1373                                 if (_dst->audio_meta->artist == NULL) {
1374                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1375                                         media_info_destroy((media_info_h)_dst);
1376                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1377                                 }
1378                         }
1379                         if (_src->audio_meta->album_artist != NULL) {
1380                                 _dst->audio_meta->album_artist = g_strdup(_src->audio_meta->album_artist);
1381                                 if (_dst->audio_meta->album_artist == NULL) {
1382                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1383                                         media_info_destroy((media_info_h)_dst);
1384                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1385                                 }
1386                         }
1387                         if (_src->audio_meta->genre != NULL) {
1388                                 _dst->audio_meta->genre = g_strdup(_src->audio_meta->genre);
1389                                 if (_dst->audio_meta->genre == NULL) {
1390                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1391                                         media_info_destroy((media_info_h)_dst);
1392                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1393                                 }
1394                         }
1395                         if (_src->audio_meta->composer != NULL) {
1396                                 _dst->audio_meta->composer = g_strdup(_src->audio_meta->composer);
1397                                 if (_dst->audio_meta->composer == NULL) {
1398                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1399                                         media_info_destroy((media_info_h)_dst);
1400                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1401                                 }
1402                         }
1403                         if (_src->audio_meta->year != NULL) {
1404                                 _dst->audio_meta->year = g_strdup(_src->audio_meta->year);
1405                                 if (_dst->audio_meta->year == NULL) {
1406                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1407                                         media_info_destroy((media_info_h)_dst);
1408                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1409                                 }
1410                         }
1411                         if (_src->audio_meta->recorded_date != NULL) {
1412                                 _dst->audio_meta->recorded_date = g_strdup(_src->audio_meta->recorded_date);
1413                                 if (_dst->audio_meta->recorded_date == NULL) {
1414                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1415                                         media_info_destroy((media_info_h)_dst);
1416                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1417                                 }
1418                         }
1419                         if (_src->audio_meta->copyright != NULL) {
1420                                 _dst->audio_meta->copyright = g_strdup(_src->audio_meta->copyright);
1421                                 if (_dst->audio_meta->copyright == NULL) {
1422                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1423                                         media_info_destroy((media_info_h)_dst);
1424                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1425                                 }
1426                         }
1427                         if (_src->audio_meta->track_num != NULL) {
1428                                 _dst->audio_meta->track_num = g_strdup(_src->audio_meta->track_num);
1429                                 if (_dst->audio_meta->track_num == NULL) {
1430                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1431                                         media_info_destroy((media_info_h)_dst);
1432                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1433                                 }
1434                         }
1435
1436                         _dst->audio_meta->channel = _src->audio_meta->channel;
1437                         _dst->audio_meta->samplerate = _src->audio_meta->samplerate;
1438                         _dst->audio_meta->duration = _src->audio_meta->duration;
1439                         _dst->audio_meta->bitrate = _src->audio_meta->bitrate;
1440                         _dst->audio_meta->bitpersample = _src->audio_meta->bitpersample;
1441                 }
1442                 *dst = (media_info_h)_dst;
1443
1444                 ret = MEDIA_CONTENT_ERROR_NONE;
1445         } else {
1446                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1447                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1448         }
1449
1450         return ret;
1451 }
1452
1453 int media_info_get_media_count_from_db(filter_h filter, int *media_count)
1454 {
1455         int ret = MEDIA_CONTENT_ERROR_NONE;
1456
1457         if (media_count == NULL) {
1458                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1459                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1460
1461                 return ret;
1462         }
1463
1464         ret = _media_db_get_group_item_count(NULL, filter, MEDIA_GROUP_NONE, media_count);
1465
1466         return ret;
1467 }
1468
1469 int media_info_foreach_media_from_db(filter_h filter, media_info_cb callback, void *user_data)
1470 {
1471         int ret = MEDIA_CONTENT_ERROR_NONE;
1472
1473         media_content_retvm_if(callback == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid callback");
1474
1475         ret = _media_db_get_group_item(NULL, filter, callback, user_data, MEDIA_GROUP_NONE);
1476
1477         return ret;
1478 }
1479
1480 int media_info_get_tag_count_from_db(const char *media_id, filter_h filter, int *tag_count)
1481 {
1482         int ret = MEDIA_CONTENT_ERROR_NONE;
1483
1484         if (STRING_VALID(media_id) && tag_count) {
1485                 ret = _media_db_get_group_item_count(media_id, filter, MEDIA_GROUP_TAG_BY_MEDIA_ID, tag_count);
1486         } else {
1487                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1488                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1489         }
1490
1491         return ret;
1492 }
1493
1494 int media_info_foreach_tag_from_db(const char *media_id, filter_h filter, media_tag_cb callback, void *user_data)
1495 {
1496         int ret = MEDIA_CONTENT_ERROR_NONE;
1497
1498         if ((callback != NULL) && STRING_VALID(media_id)) {
1499                 ret = _media_db_get_tag(media_id, filter, callback, user_data);
1500         } else {
1501                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1502                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1503         }
1504
1505         return ret;
1506 }
1507
1508 int media_info_get_bookmark_count_from_db(const char *media_id, filter_h filter, int *bookmark_count)
1509 {
1510         int ret = MEDIA_CONTENT_ERROR_NONE;
1511
1512         if (STRING_VALID(media_id) && bookmark_count) {
1513                 ret = _media_db_get_group_item_count(media_id, filter, MEDIA_GROUP_BOOKMARK_BY_MEDIA_ID, bookmark_count);
1514         } else {
1515                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1516                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1517         }
1518
1519         return ret;
1520 }
1521
1522 int media_info_foreach_bookmark_from_db(const char *media_id, filter_h filter, media_bookmark_cb callback, void *user_data)
1523 {
1524         int ret = MEDIA_CONTENT_ERROR_NONE;
1525
1526         if ((callback != NULL) && STRING_VALID(media_id)) {
1527                 ret = _media_db_get_bookmark(media_id, filter, callback, user_data);
1528         } else {
1529                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1530                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1531         }
1532
1533         return ret;
1534 }
1535
1536 int media_info_get_face_count_from_db(const char *media_id, filter_h filter, int *face_count)
1537 {
1538         int ret = MEDIA_CONTENT_ERROR_NONE;
1539
1540         if (STRING_VALID(media_id) && face_count) {
1541                 ret = _media_db_get_group_item_count(media_id, filter, MEDIA_GROUP_FACE_BY_MEDIA_ID, face_count);
1542         } else {
1543                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1544                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1545         }
1546
1547         return ret;
1548 }
1549
1550 int media_info_foreach_face_from_db(const char *media_id, filter_h filter, media_face_cb callback, void *user_data)
1551 {
1552         int ret = MEDIA_CONTENT_ERROR_NONE;
1553
1554         if ((callback != NULL) && STRING_VALID(media_id)) {
1555                 ret = _media_db_get_face(media_id, filter, callback, user_data);
1556         } else {
1557                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1558                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1559         }
1560
1561         return ret;
1562 }
1563
1564 int media_info_get_image(media_info_h media, image_meta_h *image)
1565 {
1566         int ret = MEDIA_CONTENT_ERROR_NONE;
1567
1568         media_info_s *_media = (media_info_s*)media;
1569
1570         media_content_retvm_if(_media == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid media");
1571         media_content_retvm_if(_media->media_type != MEDIA_CONTENT_TYPE_IMAGE, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid media_type");
1572         media_content_retvm_if(_media->image_meta == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid image_meta");
1573
1574         image_meta_s *_image = (image_meta_s*)calloc(1, sizeof(image_meta_s));
1575         media_content_retvm_if(_image == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
1576
1577         _image->media_id = g_strdup(_media->media_id);
1578         _image->width = _media->image_meta->width;
1579         _image->height = _media->image_meta->height;
1580         _image->orientation = _media->image_meta->orientation;
1581         _image->fnumber = _media->image_meta->fnumber;
1582         _image->iso = _media->image_meta->iso;
1583         _image->date_taken = g_strdup(_media->image_meta->date_taken);
1584         _image->title = g_strdup(_media->image_meta->title);
1585         _image->burst_id = g_strdup(_media->image_meta->burst_id);
1586         _image->exposure_time = g_strdup(_media->image_meta->exposure_time);
1587         _image->model = g_strdup(_media->image_meta->model);
1588
1589         *image = (image_meta_h)_image;
1590
1591         return ret;
1592 }
1593
1594 int media_info_get_video(media_info_h media, video_meta_h *video)
1595 {
1596         int ret = MEDIA_CONTENT_ERROR_NONE;
1597
1598         media_info_s *_media = (media_info_s*)media;
1599
1600         media_content_retvm_if(_media == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid media");
1601         media_content_retvm_if(_media->media_type != MEDIA_CONTENT_TYPE_VIDEO, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid media_type");
1602         media_content_retvm_if(_media->video_meta == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid video_meta");
1603
1604         video_meta_s *_video = (video_meta_s*)calloc(1, sizeof(video_meta_s));
1605         media_content_retvm_if(_video == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
1606
1607         _video->media_id = g_strdup(_media->media_id);
1608         _video->title = g_strdup(_media->video_meta->title);
1609         _video->album = g_strdup(_media->video_meta->album);
1610         _video->artist = g_strdup(_media->video_meta->artist);
1611         _video->album_artist = g_strdup(_media->video_meta->album_artist);
1612         _video->genre = g_strdup(_media->video_meta->genre);
1613         _video->composer = g_strdup(_media->video_meta->composer);
1614         _video->year = g_strdup(_media->video_meta->year);
1615         _video->recorded_date = g_strdup(_media->video_meta->recorded_date);
1616         _video->copyright = g_strdup(_media->video_meta->copyright);
1617         _video->track_num = g_strdup(_media->video_meta->track_num);
1618
1619         _video->width = _media->video_meta->width;
1620         _video->height = _media->video_meta->height;
1621         _video->duration = _media->video_meta->duration;
1622         _video->bitrate = _media->video_meta->bitrate;
1623         _video->rotation = _media->video_meta->rotation;
1624
1625         *video = (video_meta_h)_video;
1626
1627         return ret;
1628 }
1629
1630 int media_info_get_audio(media_info_h media, audio_meta_h *audio)
1631 {
1632         int ret = MEDIA_CONTENT_ERROR_NONE;
1633
1634         media_info_s *_media = (media_info_s*)media;
1635
1636         media_content_retvm_if(_media == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid media");
1637         media_content_retvm_if(_media->media_type != MEDIA_CONTENT_TYPE_MUSIC && _media->media_type != MEDIA_CONTENT_TYPE_SOUND, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid media_type");
1638         media_content_retvm_if(_media->audio_meta == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid audio_meta");
1639
1640         audio_meta_s *_audio = (audio_meta_s*)calloc(1, sizeof(audio_meta_s));
1641         media_content_retvm_if(_audio == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
1642
1643         _audio->media_id = g_strdup(_media->media_id);
1644         _audio->title = g_strdup(_media->audio_meta->title);
1645         _audio->album = g_strdup(_media->audio_meta->album);
1646         _audio->artist = g_strdup(_media->audio_meta->artist);
1647         _audio->album_artist = g_strdup(_media->audio_meta->album_artist);
1648         _audio->genre = g_strdup(_media->audio_meta->genre);
1649         _audio->composer = g_strdup(_media->audio_meta->composer);
1650         _audio->year = g_strdup(_media->audio_meta->year);
1651         _audio->recorded_date = g_strdup(_media->audio_meta->recorded_date);
1652         _audio->copyright = g_strdup(_media->audio_meta->copyright);
1653         _audio->track_num = g_strdup(_media->audio_meta->track_num);
1654
1655         _audio->duration = _media->audio_meta->duration;
1656         _audio->bitrate = _media->audio_meta->bitrate;
1657         _audio->bitpersample = _media->audio_meta->bitpersample;
1658         _audio->samplerate = _media->audio_meta->samplerate;
1659         _audio->channel = _media->audio_meta->channel;
1660
1661         *audio = (audio_meta_h)_audio;
1662
1663         return ret;
1664 }
1665
1666 int media_info_get_media_id(media_info_h media, char **media_id)
1667 {
1668         int ret = MEDIA_CONTENT_ERROR_NONE;
1669         media_info_s *_media = (media_info_s*)media;
1670
1671         if (_media && media_id) {
1672                 if (STRING_VALID(_media->media_id)) {
1673                         *media_id = strdup(_media->media_id);
1674                         media_content_retvm_if(*media_id == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
1675                 } else {
1676                         *media_id = NULL;
1677                 }
1678                 ret = MEDIA_CONTENT_ERROR_NONE;
1679         } else {
1680                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1681                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1682         }
1683
1684         return ret;
1685 }
1686
1687 int media_info_get_file_path(media_info_h media, char **path)
1688 {
1689         int ret = MEDIA_CONTENT_ERROR_NONE;
1690         media_info_s *_media = (media_info_s*)media;
1691
1692         if (_media && path) {
1693                 if (STRING_VALID(_media->file_path)) {
1694                         *path = strdup(_media->file_path);
1695                         media_content_retvm_if(*path == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
1696                 } else {
1697                         *path = NULL;
1698                 }
1699                 ret = MEDIA_CONTENT_ERROR_NONE;
1700
1701         } else {
1702                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1703                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1704         }
1705
1706         return ret;
1707 }
1708
1709 int media_info_get_display_name(media_info_h media, char **name)
1710 {
1711         int ret = MEDIA_CONTENT_ERROR_NONE;
1712         media_info_s *_media = (media_info_s*)media;
1713         if (_media && name) {
1714                 if (_media->display_name != NULL) {
1715                         *name = g_strdup(_media->display_name);
1716                         media_content_retvm_if(*name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
1717                 } else {
1718                         *name = NULL;
1719                 }
1720                 ret = MEDIA_CONTENT_ERROR_NONE;
1721
1722         } else {
1723                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1724                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1725         }
1726
1727         return ret;
1728 }
1729
1730 int media_info_get_media_type(media_info_h media, media_content_type_e *type)
1731 {
1732         int ret = MEDIA_CONTENT_ERROR_NONE;
1733         media_info_s *_media = (media_info_s*)media;
1734         if (_media && type) {
1735                 *type = _media->media_type;
1736                 ret = MEDIA_CONTENT_ERROR_NONE;
1737         } else {
1738                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1739                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1740         }
1741
1742         return ret;
1743 }
1744
1745 int media_info_get_mime_type(media_info_h media, char **mime_type)
1746 {
1747         int ret = MEDIA_CONTENT_ERROR_NONE;
1748         media_info_s *_media = (media_info_s*)media;
1749
1750         if (_media && mime_type) {
1751                 if (STRING_VALID(_media->mime_type)) {
1752                         *mime_type = strdup(_media->mime_type);
1753                         media_content_retvm_if(*mime_type == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
1754                 } else {
1755                         *mime_type = NULL;
1756                 }
1757                 ret = MEDIA_CONTENT_ERROR_NONE;
1758         } else {
1759                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1760                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1761         }
1762
1763         return ret;
1764 }
1765
1766 int media_info_get_size(media_info_h media, unsigned long long *size)
1767 {
1768         int ret = MEDIA_CONTENT_ERROR_NONE;
1769         media_info_s *_media = (media_info_s*)media;
1770
1771         if (_media && size) {
1772                 *size = _media->size;
1773                 ret = MEDIA_CONTENT_ERROR_NONE;
1774         } else {
1775                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1776                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1777         }
1778
1779         return ret;
1780 }
1781
1782 int media_info_get_added_time(media_info_h media, time_t *added_time)
1783 {
1784         int ret = MEDIA_CONTENT_ERROR_NONE;
1785         media_info_s *_media = (media_info_s*)media;
1786         if (_media && added_time) {
1787                 *added_time = _media->added_time;
1788                 ret = MEDIA_CONTENT_ERROR_NONE;
1789         } else {
1790                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1791                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1792         }
1793
1794         return ret;
1795 }
1796
1797 int media_info_get_modified_time(media_info_h media, time_t* time)
1798 {
1799         int ret = MEDIA_CONTENT_ERROR_NONE;
1800         media_info_s *_media = (media_info_s*)media;
1801         if (_media && time) {
1802                 *time = _media->modified_time;
1803                 ret = MEDIA_CONTENT_ERROR_NONE;
1804         } else {
1805                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1806                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1807         }
1808
1809         return ret;
1810 }
1811
1812 int media_info_get_timeline(media_info_h media, time_t* time)
1813 {
1814         int ret = MEDIA_CONTENT_ERROR_NONE;
1815         media_info_s *_media = (media_info_s*)media;
1816         if (_media && time) {
1817                 *time = _media->timeline;
1818                 ret = MEDIA_CONTENT_ERROR_NONE;
1819         } else {
1820                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1821                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1822         }
1823
1824         return ret;
1825 }
1826
1827 int media_info_get_thumbnail_path(media_info_h media, char **path)
1828 {
1829         int ret = MEDIA_CONTENT_ERROR_NONE;
1830         media_info_s *_media = (media_info_s*)media;
1831         if (_media && path) {
1832                 if (_media->thumbnail_path != NULL) {
1833                         *path = g_strdup(_media->thumbnail_path);
1834                         media_content_retvm_if(*path == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
1835                 } else {
1836                         *path = NULL;
1837                 }
1838                 ret = MEDIA_CONTENT_ERROR_NONE;
1839
1840         } else {
1841                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1842                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1843         }
1844
1845         return ret;
1846 }
1847
1848 int media_info_get_title(media_info_h media, char **title)
1849 {
1850         int ret = MEDIA_CONTENT_ERROR_NONE;
1851         media_info_s *_media = (media_info_s*)media;
1852
1853         if (_media && title)    { /*title can be empty string*/
1854                 if (_media->title != NULL) {
1855                         *title = g_strdup(_media->title);
1856                         media_content_retvm_if(*title == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
1857                 } else {
1858                         *title = NULL;
1859                 }
1860                 ret = MEDIA_CONTENT_ERROR_NONE;
1861         } else {
1862                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1863                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1864         }
1865
1866         return ret;
1867 }
1868 #ifdef _USE_TVPD_MODE
1869 int media_info_get_extract_flag(media_info_h media, int *extract_flag)
1870 {
1871         int ret = MEDIA_CONTENT_ERROR_NONE;
1872         media_info_s *_media = (media_info_s *)media;
1873
1874         if (_media && extract_flag) {
1875                 *extract_flag = _media->extract_flag;
1876                 ret = MEDIA_CONTENT_ERROR_NONE;
1877         } else {
1878                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1879                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1880         }
1881
1882         return ret;
1883 }
1884 #endif
1885
1886 int media_info_get_description(media_info_h media, char **description)
1887 {
1888         int ret = MEDIA_CONTENT_ERROR_NONE;
1889         media_info_s *_media = (media_info_s*)media;
1890
1891         if (_media && description) {
1892                 if (_media->description != NULL) {      /*description can be empty string*/
1893                         *description = g_strdup(_media->description);
1894                         media_content_retvm_if(*description == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
1895                 } else {
1896                         *description = NULL;
1897                 }
1898                 ret = MEDIA_CONTENT_ERROR_NONE;
1899         } else {
1900                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1901                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1902         }
1903
1904         return ret;
1905 }
1906
1907 int media_info_get_longitude(media_info_h media, double* longitude)
1908 {
1909         int ret = MEDIA_CONTENT_ERROR_NONE;
1910         media_info_s *_media = (media_info_s*)media;
1911
1912         if (_media && longitude) {
1913                 *longitude = _media->longitude;
1914                 ret = MEDIA_CONTENT_ERROR_NONE;
1915         } else {
1916                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1917                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1918         }
1919
1920         return ret;
1921 }
1922 int media_info_get_latitude(media_info_h media, double* latitude)
1923 {
1924         int ret = MEDIA_CONTENT_ERROR_NONE;
1925         media_info_s *_media = (media_info_s*)media;
1926
1927         if (_media && latitude) {
1928                 *latitude = _media->latitude;
1929                 ret = MEDIA_CONTENT_ERROR_NONE;
1930         } else {
1931                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1932                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1933         }
1934
1935         return ret;
1936 }
1937
1938 int media_info_get_altitude(media_info_h media, double *altitude)
1939 {
1940         int ret = MEDIA_CONTENT_ERROR_NONE;
1941         media_info_s *_media = (media_info_s*)media;
1942
1943         if (_media && altitude) {
1944                 *altitude = _media->altitude;
1945                 ret = MEDIA_CONTENT_ERROR_NONE;
1946         } else {
1947                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1948                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1949         }
1950
1951         return ret;
1952 }
1953
1954 int media_info_get_weather(media_info_h media, char **weather)
1955 {
1956         int ret = MEDIA_CONTENT_ERROR_NONE;
1957         media_content_warn("DEPRECATION WARNING: media_info_get_weather() is deprecated and will be removed from next release.");
1958         media_info_s *_media = (media_info_s*)media;
1959
1960         if (_media && weather) {
1961                 if (_media->weather != NULL) {
1962                         *weather = strdup(_media->weather);
1963                         media_content_retvm_if(*weather == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
1964                 } else {
1965                         *weather = NULL;
1966                 }
1967                 ret = MEDIA_CONTENT_ERROR_NONE;
1968         } else {
1969                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1970                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1971         }
1972
1973         return ret;
1974 }
1975
1976 int media_info_get_rating(media_info_h media, int *rating)
1977 {
1978         int ret = MEDIA_CONTENT_ERROR_NONE;
1979         media_info_s *_media = (media_info_s*)media;
1980
1981         if (_media && rating) {
1982                 *rating = _media->rating;
1983                 ret = MEDIA_CONTENT_ERROR_NONE;
1984         } else {
1985                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1986                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1987         }
1988
1989         return ret;
1990 }
1991
1992 int media_info_get_favorite(media_info_h media, bool* favorite)
1993 {
1994         int ret = MEDIA_CONTENT_ERROR_NONE;
1995         media_info_s *_media = (media_info_s*)media;
1996
1997         if (_media && favorite) {
1998                 *favorite = _media->favourite;
1999                 ret = MEDIA_CONTENT_ERROR_NONE;
2000         } else {
2001                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2002                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2003         }
2004
2005         return ret;
2006 }
2007
2008 int media_info_get_author(media_info_h media, char **author)
2009 {
2010         int ret = MEDIA_CONTENT_ERROR_NONE;
2011         media_content_warn("DEPRECATION WARNING: media_info_get_author() is deprecated and will be removed from next release.");
2012         media_info_s *_media = (media_info_s*)media;
2013
2014         if (_media && author) {
2015                 if (_media->author != NULL) {
2016                         *author = strdup(_media->author);
2017                         media_content_retvm_if(*author == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
2018                 } else {
2019                         *author = NULL;
2020                 }
2021                 ret = MEDIA_CONTENT_ERROR_NONE;
2022         } else {
2023                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2024                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2025         }
2026
2027         return ret;
2028 }
2029
2030 int media_info_get_provider(media_info_h media, char **provider)
2031 {
2032         int ret = MEDIA_CONTENT_ERROR_NONE;
2033         media_content_warn("DEPRECATION WARNING: media_info_get_provider() is deprecated and will be removed from next release.");
2034         media_info_s *_media = (media_info_s*)media;
2035
2036         if (_media && provider) {
2037                 if (_media->provider != NULL) {
2038                         *provider = strdup(_media->provider);
2039                         media_content_retvm_if(*provider == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
2040                 } else {
2041                         *provider = NULL;
2042                 }
2043                 ret = MEDIA_CONTENT_ERROR_NONE;
2044         } else {
2045                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2046                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2047         }
2048
2049         return ret;
2050 }
2051
2052 int media_info_get_content_name(media_info_h media, char **content_name)
2053 {
2054         int ret = MEDIA_CONTENT_ERROR_NONE;
2055         media_content_warn("DEPRECATION WARNING: media_info_get_content_name() is deprecated and will be removed from next release.");
2056         media_info_s *_media = (media_info_s*)media;
2057
2058         if (_media && content_name) {
2059                 if (_media->content_name != NULL) {
2060                         *content_name = strdup(_media->content_name);
2061                         media_content_retvm_if(*content_name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
2062                 } else {
2063                         *content_name = NULL;
2064                 }
2065                 ret = MEDIA_CONTENT_ERROR_NONE;
2066         } else {
2067                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2068                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2069         }
2070
2071         return ret;
2072 }
2073
2074 int media_info_get_category(media_info_h media, char **category)
2075 {
2076         int ret = MEDIA_CONTENT_ERROR_NONE;
2077         media_content_warn("DEPRECATION WARNING: media_info_get_category() is deprecated and will be removed from next release.");
2078         media_info_s *_media = (media_info_s*)media;
2079
2080         if (_media && category) {
2081                 if (_media->category != NULL) {
2082                         *category = strdup(_media->category);
2083                         media_content_retvm_if(*category == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
2084                 } else {
2085                         *category = NULL;
2086                 }
2087                 ret = MEDIA_CONTENT_ERROR_NONE;
2088         } else {
2089                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2090                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2091         }
2092
2093         return ret;
2094 }
2095
2096 int media_info_get_location_tag(media_info_h media, char **location_tag)
2097 {
2098         int ret = MEDIA_CONTENT_ERROR_NONE;
2099         media_content_warn("DEPRECATION WARNING: media_info_get_location_tag() is deprecated and will be removed from next release.");
2100         media_info_s *_media = (media_info_s*)media;
2101
2102         if (_media && location_tag) {
2103                 if (_media->location_tag != NULL) {
2104                         *location_tag = strdup(_media->location_tag);
2105                         media_content_retvm_if(*location_tag == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
2106                 } else {
2107                         *location_tag = NULL;
2108                 }
2109                 ret = MEDIA_CONTENT_ERROR_NONE;
2110         } else {
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_get_age_rating(media_info_h media, char **age_rating)
2119 {
2120         int ret = MEDIA_CONTENT_ERROR_NONE;
2121         media_content_warn("DEPRECATION WARNING: media_info_get_age_rating() is deprecated and will be removed from next release.");
2122         media_info_s *_media = (media_info_s*)media;
2123
2124         if (_media && age_rating) {
2125                 if (_media->age_rating != NULL) {
2126                         *age_rating = strdup(_media->age_rating);
2127                         media_content_retvm_if(*age_rating == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
2128                 } else {
2129                         *age_rating = NULL;
2130                 }
2131                 ret = MEDIA_CONTENT_ERROR_NONE;
2132         } else {
2133                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2134                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2135         }
2136
2137         return ret;
2138 }
2139
2140 int media_info_get_keyword(media_info_h media, char **keyword)
2141 {
2142         int ret = MEDIA_CONTENT_ERROR_NONE;
2143         media_content_warn("DEPRECATION WARNING: media_info_get_keyword() is deprecated and will be removed from next release.");
2144         media_info_s *_media = (media_info_s*)media;
2145
2146         if (_media && keyword) {
2147                 if (_media->keyword != NULL) {
2148                         *keyword = strdup(_media->keyword);
2149                         media_content_retvm_if(*keyword == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
2150                 } else {
2151                         *keyword = NULL;
2152                 }
2153                 ret = MEDIA_CONTENT_ERROR_NONE;
2154         } else {
2155                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2156                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2157         }
2158
2159         return ret;
2160 }
2161
2162 int media_info_get_storage_id(media_info_h media, char **storage_id)
2163 {
2164         int ret = MEDIA_CONTENT_ERROR_NONE;
2165         media_content_warn("DEPRECATION WARNING: media_info_get_storage_id() is deprecated and will be removed from next release.");
2166         media_info_s *_media = (media_info_s*)media;
2167
2168         if (_media && storage_id) {
2169                 if (STRING_VALID(_media->storage_uuid)) {
2170                         *storage_id = strdup(_media->storage_uuid);
2171                         media_content_retvm_if(*storage_id == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
2172                 } else {
2173                         *storage_id = NULL;
2174                         ret = MEDIA_CONTENT_ERROR_DB_FAILED;
2175                 }
2176         } else {
2177                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2178                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2179         }
2180
2181         return ret;
2182 }
2183
2184 int media_info_is_drm(media_info_h media, bool *is_drm)
2185 {
2186         int ret = MEDIA_CONTENT_ERROR_NONE;
2187         media_info_s *_media = (media_info_s*)media;
2188
2189         if (_media) {
2190                 *is_drm = _media->is_drm;
2191                 ret = MEDIA_CONTENT_ERROR_NONE;
2192         } else {
2193                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2194                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2195         }
2196
2197         return ret;
2198 }
2199
2200 int media_info_is_360_content(media_info_h media, bool *is_360)
2201 {
2202         int ret = MEDIA_CONTENT_ERROR_NONE;
2203         media_info_s *_media = (media_info_s*)media;
2204
2205         if (_media) {
2206                 *is_360 = _media->is_360;
2207                 ret = MEDIA_CONTENT_ERROR_NONE;
2208         } else {
2209                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2210                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2211         }
2212
2213         return ret;
2214 }
2215
2216 #ifdef _USE_TVPD_MODE
2217 int media_info_get_stitched_state(media_info_h media, int *stitched_info)
2218 {
2219         int ret = MEDIA_CONTENT_ERROR_NONE;
2220         media_info_s *_media = (media_info_s*)media;
2221
2222         if (_media) {
2223                 *stitched_info = (_media->stitched_info & 0xFFFF0000) >> 16;
2224                 ret = MEDIA_CONTENT_ERROR_NONE;
2225         } else {
2226                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2227                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2228         }
2229
2230         return ret;
2231 }
2232
2233 int media_info_get_stitched_engine(media_info_h media, int *stitched_info)
2234 {
2235         int ret = MEDIA_CONTENT_ERROR_NONE;
2236         media_info_s *_media = (media_info_s*)media;
2237
2238         if (_media) {
2239                 *stitched_info = _media->stitched_info & 0x0000FFFF;
2240                 ret = MEDIA_CONTENT_ERROR_NONE;
2241         } else {
2242                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2243                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2244         }
2245
2246         return ret;
2247 }
2248 #endif
2249
2250 int media_info_get_storage_type(media_info_h media, media_content_storage_e *storage_type)
2251 {
2252         int ret = MEDIA_CONTENT_ERROR_NONE;
2253         media_content_warn("DEPRECATION WARNING: media_info_get_storage_type() is deprecated and will be removed from next release. Use storage_get_type_dev() instead.");
2254         media_info_s *_media = (media_info_s*)media;
2255
2256         if (_media && storage_type) {
2257                 *storage_type = _media->storage_type;
2258                 ret = MEDIA_CONTENT_ERROR_NONE;
2259         } else {
2260                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2261                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2262         }
2263
2264         return ret;
2265 }
2266
2267 #ifdef _USE_TVPD_MODE
2268 int media_info_get_played_position(media_info_h media, int *played_position)
2269 {
2270         int ret = MEDIA_CONTENT_ERROR_NONE;
2271         media_info_s *_media = (media_info_s*)media;
2272
2273         if (_media) {
2274                 *played_position = _media->played_position;
2275                 ret = MEDIA_CONTENT_ERROR_NONE;
2276         } else {
2277                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2278                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2279         }
2280
2281         return ret;
2282 }
2283 #endif
2284
2285 int media_info_get_played_count(media_info_h media, int *played_count)
2286 {
2287         int ret = MEDIA_CONTENT_ERROR_NONE;
2288         media_content_warn("DEPRECATION WARNING: media_info_get_played_count() is deprecated and will be removed from next release.");
2289         media_info_s *_media = (media_info_s*)media;
2290
2291         if (_media) {
2292                 *played_count = _media->played_count;
2293                 ret = MEDIA_CONTENT_ERROR_NONE;
2294         } else {
2295                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2296                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2297         }
2298
2299         return ret;
2300 }
2301
2302 int media_info_get_played_time(media_info_h media, time_t* played_time)
2303 {
2304         int ret = MEDIA_CONTENT_ERROR_NONE;
2305         media_content_warn("DEPRECATION WARNING: media_info_get_played_time() is deprecated and will be removed from next release.");
2306         media_info_s *_media = (media_info_s*)media;
2307
2308         if (_media) {
2309                 *played_time = _media->played_time;
2310                 ret = MEDIA_CONTENT_ERROR_NONE;
2311         } else {
2312                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2313                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2314         }
2315
2316         return ret;
2317 }
2318
2319 int media_info_increase_played_count(media_info_h media)
2320 {
2321         int ret = MEDIA_CONTENT_ERROR_NONE;
2322         media_content_warn("DEPRECATION WARNING: media_info_increase_played_count() is deprecated and will be removed from next release.");
2323
2324         media_info_s *_media = (media_info_s*)media;
2325
2326         if (_media) {
2327                 _media->played_count += 1;
2328         } else {
2329                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2330                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2331         }
2332
2333         return ret;
2334 }
2335
2336 #ifdef _USE_TVPD_MODE
2337 int media_info_get_modified_month(media_info_h media, char **modified_month)
2338 {
2339         int ret = MEDIA_CONTENT_ERROR_NONE;
2340         media_info_s *_media = (media_info_s*)media;
2341
2342         if (_media && modified_month) {
2343                 if (STRING_VALID(_media->modified_month)) {
2344                         *modified_month = strdup(_media->modified_month);
2345                         if (*modified_month == NULL) {
2346                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
2347                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
2348                         }
2349                 } else {
2350                         *modified_month = NULL;
2351                 }
2352                 ret = MEDIA_CONTENT_ERROR_NONE;
2353         } else {
2354                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2355                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2356         }
2357
2358         return ret;
2359 }
2360 #endif
2361 #ifdef _USE_SENIOR_MODE
2362 int media_info_get_contact(media_info_h media, char **contact)
2363 {
2364         int ret = MEDIA_CONTENT_ERROR_NONE;
2365         media_info_s *_media = (media_info_s*)media;
2366
2367         if (_media && contact) {
2368                 if (STRING_VALID(_media->contact)) {
2369                         *contact = strdup(_media->contact);
2370                         if (*contact == NULL) {
2371                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
2372                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
2373                         }
2374                 } else {
2375                         *contact = NULL;
2376                 }
2377                 ret = MEDIA_CONTENT_ERROR_NONE;
2378         } else {
2379                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2380                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2381         }
2382
2383         return ret;
2384 }
2385
2386 int media_info_get_app_data(media_info_h media, char **app_data)
2387 {
2388         int ret = MEDIA_CONTENT_ERROR_NONE;
2389         media_info_s *_media = (media_info_s*)media;
2390
2391         if (_media && app_data) {
2392                 if (STRING_VALID(_media->app_data)) {
2393                         *app_data = strdup(_media->app_data);
2394                         if (*app_data == NULL) {
2395                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
2396                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
2397                         }
2398                 } else {
2399                         *app_data = NULL;
2400                 }
2401                 ret = MEDIA_CONTENT_ERROR_NONE;
2402         } else {
2403                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2404                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2405         }
2406
2407         return ret;
2408 }
2409 #endif
2410 #ifdef _USE_TVPD_MODE
2411 int media_info_set_played_count(media_info_h media, int played_count)
2412 {
2413         int ret = MEDIA_CONTENT_ERROR_NONE;
2414
2415         media_info_s *_media = (media_info_s*)media;
2416
2417         if (_media) {
2418                 _media->played_count = played_count;
2419         } else {
2420                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2421                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2422         }
2423
2424         return ret;
2425 }
2426 #endif
2427
2428 int media_info_set_played_time(media_info_h media)
2429 {
2430         int ret = MEDIA_CONTENT_ERROR_NONE;
2431         media_content_warn("DEPRECATION WARNING: media_info_set_played_time() is deprecated and will be removed from next release.");
2432         time_t current_time;
2433
2434         media_info_s *_media = (media_info_s*)media;
2435
2436         if (_media != NULL) {
2437                 time(&current_time);
2438                 _media->played_time = current_time;
2439         } else {
2440                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2441                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2442         }
2443
2444         return ret;
2445 }
2446 #ifdef _USE_TVPD_MODE
2447 int media_info_set_played_position(media_info_h media, int played_position)
2448 {
2449         int ret = MEDIA_CONTENT_ERROR_NONE;
2450         media_info_s *_media = (media_info_s*)media;
2451
2452         if ((_media != NULL) && (played_position >= 0)) {
2453                 _media->played_position = played_position;
2454         } else {
2455                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2456                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2457         }
2458
2459         return ret;
2460 }
2461 #endif
2462
2463 int media_info_get_media_from_db(const char *media_id, media_info_h *media)
2464 {
2465         int ret = MEDIA_CONTENT_ERROR_NONE;
2466         char select_query[DEFAULT_QUERY_SIZE] = {0, };
2467         char storage_id[MEDIA_CONTENT_UUID_SIZE+1] = {0, };
2468         sqlite3_stmt *stmt = NULL;
2469
2470         if (!STRING_VALID(media_id) || (media == NULL)) {
2471                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2472                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2473         }
2474
2475         memset(select_query, 0x00, sizeof(select_query));
2476         memset(storage_id, 0x00, sizeof(storage_id));
2477
2478         ret = _media_db_get_storage_id_by_media_id(media_id, storage_id);
2479         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
2480
2481         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_MEDIA, storage_id, media_id);
2482
2483         ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
2484         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
2485
2486         media_info_s *_media = NULL;
2487
2488         if (sqlite3_step(stmt) == SQLITE_ROW) {
2489                 _media = (media_info_s*)calloc(1, sizeof(media_info_s));
2490
2491                 if (_media == NULL) {
2492                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
2493                         SQLITE3_FINALIZE(stmt);
2494                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
2495                 }
2496
2497                 _media_info_item_get_detail(stmt, (media_info_h)_media);
2498
2499                 *media = (media_info_h)_media;
2500         } else {
2501                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2502         }
2503
2504         SQLITE3_FINALIZE(stmt);
2505
2506         return ret;
2507 }
2508
2509 int media_info_set_display_name(media_info_h media, const char *display_name)
2510 {
2511         int ret = MEDIA_CONTENT_ERROR_NONE;
2512         media_content_warn("DEPRECATION WARNING: media_info_set_display_name() is deprecated and will be removed from next release.");
2513         media_info_s *_media = (media_info_s*)media;
2514
2515         if (_media != NULL && STRING_VALID(display_name)) {
2516                 SAFE_FREE(_media->display_name);
2517
2518                 _media->display_name = strdup(display_name);
2519                 media_content_retvm_if(_media->display_name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
2520         } else {
2521                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2522                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2523         }
2524
2525         return ret;
2526 }
2527
2528 int media_info_set_description(media_info_h media, const char *description)
2529 {
2530         int ret = MEDIA_CONTENT_ERROR_NONE;
2531         media_content_warn("DEPRECATION WARNING: media_info_set_description() is deprecated and will be removed from next release.");
2532         media_info_s *_media = (media_info_s*)media;
2533
2534         if (_media != NULL) {
2535                 SAFE_FREE(_media->description);
2536
2537                 if (STRING_VALID(description)) {
2538                         _media->description = strdup(description);
2539                         media_content_retvm_if(_media->description == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
2540                 } else {
2541                         _media->description = NULL;
2542                 }
2543         } else {
2544                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2545                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2546         }
2547
2548         return ret;
2549 }
2550
2551 int media_info_set_longitude(media_info_h media, double longitude)
2552 {
2553         int ret = MEDIA_CONTENT_ERROR_NONE;
2554         media_content_warn("DEPRECATION WARNING: media_info_set_longitude() is deprecated and will be removed from next release.");
2555         media_info_s *_media = (media_info_s*)media;
2556
2557         if (_media != NULL) {
2558                 _media->longitude = longitude;
2559         } else {
2560                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2561                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2562         }
2563
2564         return ret;
2565 }
2566
2567 int media_info_set_latitude(media_info_h media, double latitude)
2568 {
2569         int ret = MEDIA_CONTENT_ERROR_NONE;
2570         media_content_warn("DEPRECATION WARNING: media_info_set_latitude() is deprecated and will be removed from next release.");
2571         media_info_s *_media = (media_info_s*)media;
2572
2573         if (_media != NULL) {
2574                 _media->latitude = latitude;
2575         } else {
2576                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2577                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2578         }
2579
2580         return ret;
2581 }
2582
2583 int media_info_set_altitude(media_info_h media, double altitude)
2584 {
2585         int ret = MEDIA_CONTENT_ERROR_NONE;
2586         media_content_warn("DEPRECATION WARNING: media_info_set_altitude() is deprecated and will be removed from next release.");
2587         media_info_s *_media = (media_info_s*)media;
2588
2589         if (_media != NULL) {
2590                 _media->altitude = altitude;
2591         } else {
2592                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2593                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2594         }
2595
2596         return ret;
2597 }
2598
2599 int media_info_set_weather(media_info_h media, const char *weather)
2600 {
2601         int ret = MEDIA_CONTENT_ERROR_NONE;
2602         media_content_warn("DEPRECATION WARNING: media_info_set_weather() is deprecated and will be removed from next release.");
2603         media_info_s *_media = (media_info_s*)media;
2604
2605         if (_media != NULL) {
2606                 SAFE_FREE(_media->weather);
2607
2608                 if (STRING_VALID(weather)) {
2609                         _media->weather = strdup(weather);
2610                         media_content_retvm_if(_media->weather == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
2611                 } else {
2612                         _media->weather = NULL;
2613                 }
2614         } else {
2615                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2616                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2617         }
2618
2619         return ret;
2620 }
2621
2622 int media_info_set_rating(media_info_h media, int rating)
2623 {
2624         int ret = MEDIA_CONTENT_ERROR_NONE;
2625         media_content_warn("DEPRECATION WARNING: media_info_set_rating() is deprecated and will be removed from next release.");
2626         media_info_s *_media = (media_info_s*)media;
2627
2628         if (_media != NULL) {
2629                 _media->rating = rating;
2630         } else {
2631                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2632                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2633         }
2634
2635         return ret;
2636 }
2637
2638 int media_info_set_added_time(media_info_h media, time_t added_time)
2639 {
2640         int ret = MEDIA_CONTENT_ERROR_NONE;
2641         media_content_warn("DEPRECATION WARNING: media_info_set_added_time() is deprecated and will be removed from next release.");
2642
2643         media_info_s *_media = (media_info_s*)media;
2644
2645         if ((_media != NULL) && (added_time >= 0)) {
2646                 _media->added_time = added_time;
2647         } else {
2648                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2649                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2650         }
2651
2652         return ret;
2653 }
2654
2655 int media_info_set_favorite(media_info_h media, bool favorite)
2656 {
2657         int ret = MEDIA_CONTENT_ERROR_NONE;
2658         media_info_s *_media = (media_info_s*)media;
2659
2660         if (_media != NULL) {
2661                 if (favorite == TRUE)
2662                         time(&_media->favourite);
2663                 else
2664                         _media->favourite = 0;
2665         } else {
2666                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2667                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2668         }
2669
2670         return ret;
2671 }
2672
2673 int media_info_set_author(media_info_h media, const char *author)
2674 {
2675         int ret = MEDIA_CONTENT_ERROR_NONE;
2676         media_content_warn("DEPRECATION WARNING: media_info_set_author() is deprecated and will be removed from next release.");
2677         media_info_s *_media = (media_info_s*)media;
2678
2679         if (_media != NULL) {
2680                 if (STRING_VALID(author)) {
2681                         _media->author = strdup(author);
2682                         media_content_retvm_if(_media->author == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
2683                 } else {
2684                         _media->author = NULL;
2685                 }
2686         } else {
2687                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2688                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2689         }
2690
2691         return ret;
2692 }
2693
2694 int media_info_set_provider(media_info_h media, const char *provider)
2695 {
2696         int ret = MEDIA_CONTENT_ERROR_NONE;
2697         media_content_warn("DEPRECATION WARNING: media_info_set_provider() is deprecated and will be removed from next release.");
2698         media_info_s *_media = (media_info_s*)media;
2699
2700         if (_media != NULL) {
2701                 SAFE_FREE(_media->provider);
2702
2703                 if (STRING_VALID(provider)) {
2704                         _media->provider = strdup(provider);
2705                         media_content_retvm_if(_media->provider == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
2706                 } else {
2707                         _media->provider = NULL;
2708                 }
2709         } else {
2710                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2711                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2712         }
2713
2714         return ret;
2715 }
2716
2717 int media_info_set_content_name(media_info_h media, const char *content_name)
2718 {
2719         int ret = MEDIA_CONTENT_ERROR_NONE;
2720         media_content_warn("DEPRECATION WARNING: media_info_set_content_name() is deprecated and will be removed from next release.");
2721         media_info_s *_media = (media_info_s*)media;
2722
2723         if (_media != NULL) {
2724                 SAFE_FREE(_media->content_name);
2725
2726                 if (STRING_VALID(content_name)) {
2727                         _media->content_name = strdup(content_name);
2728                         media_content_retvm_if(_media->content_name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
2729                 } else {
2730                         _media->content_name = NULL;
2731                 }
2732         } else {
2733                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2734                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2735         }
2736
2737         return ret;
2738 }
2739
2740 int media_info_set_category(media_info_h media, const char *category)
2741 {
2742         int ret = MEDIA_CONTENT_ERROR_NONE;
2743         media_content_warn("DEPRECATION WARNING: media_info_set_category() is deprecated and will be removed from next release.");
2744         media_info_s *_media = (media_info_s*)media;
2745
2746         if (_media != NULL) {
2747                 SAFE_FREE(_media->category);
2748
2749                 if (STRING_VALID(category)) {
2750                         _media->category = strdup(category);
2751                         media_content_retvm_if(_media->category == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
2752                 } else {
2753                         _media->category = NULL;
2754                 }
2755         } else {
2756                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2757                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2758         }
2759
2760         return ret;
2761 }
2762
2763 int media_info_set_location_tag(media_info_h media, const char *location_tag)
2764 {
2765         int ret = MEDIA_CONTENT_ERROR_NONE;
2766         media_content_warn("DEPRECATION WARNING: media_info_set_location_tag() is deprecated and will be removed from next release.");
2767         media_info_s *_media = (media_info_s*)media;
2768
2769         if (_media != NULL) {
2770                 SAFE_FREE(_media->location_tag);
2771
2772                 if (STRING_VALID(location_tag)) {
2773                         _media->location_tag = strdup(location_tag);
2774                         media_content_retvm_if(_media->location_tag == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
2775                 } else {
2776                         _media->location_tag = NULL;
2777                 }
2778         } else {
2779                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2780                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2781         }
2782
2783         return ret;
2784 }
2785
2786 int media_info_set_age_rating(media_info_h media, const char *age_rating)
2787 {
2788         int ret = MEDIA_CONTENT_ERROR_NONE;
2789         media_content_warn("DEPRECATION WARNING: media_info_set_age_rating() is deprecated and will be removed from next release.");
2790         media_info_s *_media = (media_info_s*)media;
2791
2792         if (_media != NULL) {
2793                 SAFE_FREE(_media->age_rating);
2794
2795                 if (STRING_VALID(age_rating)) {
2796                         _media->age_rating = strdup(age_rating);
2797                         media_content_retvm_if(_media->age_rating == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
2798                 } else {
2799                         _media->age_rating = NULL;
2800                 }
2801         } else {
2802                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2803                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2804         }
2805
2806         return ret;
2807 }
2808
2809 int media_info_set_keyword(media_info_h media, const char *keyword)
2810 {
2811         int ret = MEDIA_CONTENT_ERROR_NONE;
2812         media_content_warn("DEPRECATION WARNING: media_info_set_keyword() is deprecated and will be removed from next release.");
2813         media_info_s *_media = (media_info_s*)media;
2814
2815         if (_media != NULL) {
2816                 SAFE_FREE(_media->keyword);
2817
2818                 if (STRING_VALID(keyword)) {
2819                         _media->keyword = strdup(keyword);
2820                         media_content_retvm_if(_media->keyword == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
2821                 } else {
2822                         _media->keyword = NULL;
2823                 }
2824         } else {
2825                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2826                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2827         }
2828
2829         return ret;
2830 }
2831
2832 int media_info_update_to_db(media_info_h media)
2833 {
2834         int ret = MEDIA_CONTENT_ERROR_NONE;
2835         media_info_s *_media = (media_info_s*)media;
2836         char *set_sql = NULL;
2837         char *sql = NULL;
2838
2839         if (_media != NULL && STRING_VALID(_media->media_id)) {
2840                 /* This sql is due to sqlite3_mprintf's wrong operation when using floating point in the text format */
2841                 /* This code will be removed when sqlite3_mprintf works clearly */
2842                 char *test_sql = sqlite3_mprintf("%f, %f, %f", _media->longitude, _media->latitude, _media->altitude);
2843                 SQLITE3_SAFE_FREE(test_sql);
2844
2845                 /*Update Pinyin If Support Pinyin*/
2846                 char *file_name_pinyin = NULL;
2847                 char *description_pinyin = NULL;
2848                 char *author_pinyin = NULL;
2849                 char *provider_pinyin = NULL;
2850                 char *content_name_pinyin = NULL;
2851                 char *category_pinyin = NULL;
2852                 char *location_tag_pinyin = NULL;
2853                 char *age_rating_pinyin = NULL;
2854                 char *keyword_pinyin = NULL;
2855                 bool pinyin_support = FALSE;
2856
2857                 /*Update Pinyin If Support Pinyin*/
2858                 media_svc_check_pinyin_support(&pinyin_support);
2859                 if (pinyin_support) {
2860                         if (STRING_VALID(_media->display_name))
2861                                 media_svc_get_pinyin(_media->display_name, &file_name_pinyin);
2862                         if (STRING_VALID(_media->description))
2863                                 media_svc_get_pinyin(_media->description, &description_pinyin);
2864                         if (STRING_VALID(_media->author))
2865                                 media_svc_get_pinyin(_media->author, &author_pinyin);
2866                         if (STRING_VALID(_media->provider))
2867                                 media_svc_get_pinyin(_media->provider, &provider_pinyin);
2868                         if (STRING_VALID(_media->content_name))
2869                                 media_svc_get_pinyin(_media->content_name, &content_name_pinyin);
2870                         if (STRING_VALID(_media->category))
2871                                 media_svc_get_pinyin(_media->category, &category_pinyin);
2872                         if (STRING_VALID(_media->location_tag))
2873                                 media_svc_get_pinyin(_media->location_tag, &location_tag_pinyin);
2874                         if (STRING_VALID(_media->age_rating))
2875                                 media_svc_get_pinyin(_media->age_rating, &age_rating_pinyin);
2876                         if (STRING_VALID(_media->keyword))
2877                                 media_svc_get_pinyin(_media->keyword, &keyword_pinyin);
2878                 }
2879
2880                 char *album = NULL;
2881                 char *artist = NULL;
2882                 char *genre = NULL;
2883                 char *recorded_date = NULL;
2884
2885                 if (_media->media_type == MEDIA_CONTENT_TYPE_VIDEO) {
2886                         if (_media->video_meta->album != NULL)
2887                                 album = strdup(_media->video_meta->album);
2888                         if (_media->video_meta->artist != NULL)
2889                                 artist = strdup(_media->video_meta->artist);
2890                         if (_media->video_meta->genre != NULL)
2891                                 genre = strdup(_media->video_meta->genre);
2892                         if (_media->video_meta->recorded_date != NULL)
2893                                 recorded_date = strdup(_media->video_meta->recorded_date);
2894                 } else if ((_media->media_type == MEDIA_CONTENT_TYPE_MUSIC) || (_media->media_type == MEDIA_CONTENT_TYPE_SOUND)) {
2895                         if (_media->audio_meta->album != NULL)
2896                                 album = strdup(_media->audio_meta->album);
2897                         if (_media->audio_meta->artist != NULL)
2898                                 artist = strdup(_media->audio_meta->artist);
2899                         if (_media->audio_meta->genre != NULL)
2900                                 genre = strdup(_media->audio_meta->genre);
2901                         if (_media->audio_meta->recorded_date != NULL)
2902                                 recorded_date = strdup(_media->audio_meta->recorded_date);
2903                 }
2904
2905 #ifdef _USE_SENIOR_MODE
2906                 if (_media_content_is_support_senior_mode()) {
2907                         set_sql = sqlite3_mprintf("file_name=%Q, added_time=%d, description=%Q, longitude=%f, latitude=%f, altitude=%f, \
2908                                 played_count=%d, last_played_time=%d, last_played_position=%d, \
2909                                 rating=%d, favourite=%d, author=%Q, provider=%Q, content_name=%Q, category=%Q, location_tag=%Q, age_rating=%Q, keyword=%Q, weather=%Q, sync_status=%d, \
2910                                 file_name_pinyin=%Q, description_pinyin=%Q, author_pinyin=%Q, provider_pinyin=%Q, content_name_pinyin=%Q, category_pinyin=%Q, location_tag_pinyin=%Q, age_rating_pinyin=%Q, keyword_pinyin=%Q, title=%Q, contact=%Q, app_data=%Q",
2911                                 _media->display_name, _media->added_time, _media->description, _media->longitude, _media->latitude, _media->altitude, _media->played_count, _media->played_time, _media->played_position, _media->rating, _media->favourite,
2912                                 _media->author, _media->provider, _media->content_name, _media->category, _media->location_tag, _media->age_rating, _media->keyword, _media->weather, _media->sync_status,
2913                                 file_name_pinyin, description_pinyin, author_pinyin, provider_pinyin, content_name_pinyin, category_pinyin, location_tag_pinyin, age_rating_pinyin, keyword_pinyin, _media->title, _media->contact, _media->app_data);
2914                 } else
2915 #endif
2916                 {
2917                         set_sql = sqlite3_mprintf("file_name=%Q, added_time=%d, description=%Q, longitude=%f, latitude=%f, altitude=%f, \
2918                                 played_count=%d, last_played_time=%d, last_played_position=%d, \
2919                                 rating=%d, favourite=%d, author=%Q, provider=%Q, content_name=%Q, category=%Q, location_tag=%Q, age_rating=%Q, keyword=%Q, weather=%Q, sync_status=%d, \
2920                                 file_name_pinyin=%Q, description_pinyin=%Q, author_pinyin=%Q, provider_pinyin=%Q, content_name_pinyin=%Q, category_pinyin=%Q, location_tag_pinyin=%Q, age_rating_pinyin=%Q, keyword_pinyin=%Q, title=%Q, \
2921                                 album=%Q, artist=%Q, genre=%Q, recorded_date=%Q",
2922                                 _media->display_name, _media->added_time, _media->description, _media->longitude, _media->latitude, _media->altitude, _media->played_count, _media->played_time, _media->played_position, _media->rating, _media->favourite,
2923                                 _media->author, _media->provider, _media->content_name, _media->category, _media->location_tag, _media->age_rating, _media->keyword, _media->weather, _media->sync_status,
2924                                 file_name_pinyin, description_pinyin, author_pinyin, provider_pinyin, content_name_pinyin, category_pinyin, location_tag_pinyin, age_rating_pinyin, keyword_pinyin, _media->title,
2925                                 album, artist, genre, recorded_date);
2926                 }
2927
2928                 sql = sqlite3_mprintf("UPDATE %Q SET %s WHERE media_uuid=%Q", _media->storage_uuid, set_sql, _media->media_id);
2929
2930                 ret = _content_query_sql(sql);
2931                 SQLITE3_SAFE_FREE(set_sql);
2932                 SQLITE3_SAFE_FREE(sql);
2933
2934                 SAFE_FREE(file_name_pinyin);
2935                 SAFE_FREE(description_pinyin);
2936                 SAFE_FREE(author_pinyin);
2937                 SAFE_FREE(provider_pinyin);
2938                 SAFE_FREE(content_name_pinyin);
2939                 SAFE_FREE(category_pinyin);
2940                 SAFE_FREE(location_tag_pinyin);
2941                 SAFE_FREE(age_rating_pinyin);
2942                 SAFE_FREE(keyword_pinyin);
2943
2944                 SAFE_FREE(album);
2945                 SAFE_FREE(artist);
2946                 SAFE_FREE(genre);
2947                 SAFE_FREE(recorded_date);
2948
2949                 if (ret == MEDIA_CONTENT_ERROR_NONE) {
2950                         /* Send notification for this update */
2951                         media_content_debug("Update is successfull. Send notification for this");
2952                         if (_media->file_path && _media->mime_type)
2953                                 media_svc_publish_noti(MS_MEDIA_ITEM_FILE, MS_MEDIA_ITEM_UPDATE, _media->file_path, _media->media_type, _media->media_id, _media->mime_type);
2954                         else
2955                                 media_content_error("Can't Send Noti : path or mime type is NULL");
2956                 }
2957         } else {
2958                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2959                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2960         }
2961
2962         return ret;
2963 }
2964
2965 int media_info_refresh_metadata_to_db(const char *media_id)
2966 {
2967         int ret = MEDIA_CONTENT_ERROR_NONE;
2968         media_content_warn("DEPRECATION WARNING: media_info_refresh_metadata_to_db() is deprecated and will be removed from next release.");
2969         media_info_h media = NULL;
2970         char *file_path = NULL;
2971         media_content_storage_e storage_type = 0;
2972         char storage_id[MEDIA_CONTENT_UUID_SIZE+1] = {0, };
2973         char repl_path[MAX_PATH_LEN] = {0, };
2974
2975         if (!STRING_VALID(media_id)) {
2976                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2977                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2978         }
2979
2980         ret = media_info_get_media_from_db(media_id, &media);
2981         if (ret != MEDIA_CONTENT_ERROR_NONE) {
2982                 media_info_destroy(media);
2983                 return ret;
2984         }
2985
2986         ret = media_info_get_storage_type(media, &storage_type);
2987         if (ret != MEDIA_CONTENT_ERROR_NONE) {
2988                 media_info_destroy(media);
2989                 return ret;
2990         }
2991
2992         ret = media_info_get_file_path(media, &file_path);
2993         if (ret != MEDIA_CONTENT_ERROR_NONE) {
2994                 media_info_destroy(media);
2995                 return ret;
2996         }
2997         memset(repl_path, 0, sizeof(repl_path));
2998         ret = _media_content_replace_path(file_path, repl_path);
2999
3000         ret = _media_util_check_file_exist(repl_path);
3001         if (ret != MEDIA_CONTENT_ERROR_NONE) {
3002                 SAFE_FREE(file_path);
3003                 media_info_destroy(media);
3004                 return ret;
3005         }
3006
3007         memset(storage_id, 0x00, sizeof(storage_id));
3008         ret = media_svc_get_storage_id(_content_get_db_handle(), repl_path, storage_id, _content_get_uid());
3009         if (ret != MS_MEDIA_ERR_NONE) {
3010                 media_content_error("media_svc_get_storage_id failed : %d", ret);
3011                 SAFE_FREE(file_path);
3012                 media_info_destroy(media);
3013                 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
3014         }
3015
3016         ret = media_svc_refresh_item(_content_get_db_handle(), storage_id, storage_type, repl_path, _content_get_uid());
3017         if (ret != MS_MEDIA_ERR_NONE)
3018                 ret = _content_error_capi(MEDIA_CONTENT_TYPE, ret);
3019
3020         SAFE_FREE(file_path);
3021         media_info_destroy(media);
3022
3023         return ret;
3024 }
3025
3026 int media_info_move_to_db(media_info_h media, const char* dst_path)
3027 {
3028         int ret = MEDIA_CONTENT_ERROR_NONE;
3029         char storage_id[MEDIA_CONTENT_UUID_SIZE+1] = {0, };
3030         char repl_path[MAX_PATH_LEN] = {0, };
3031         char org_repl_path[MAX_PATH_LEN] = {0, };
3032
3033         media_content_retvm_if(media == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid media");
3034         media_content_retvm_if(!STRING_VALID(dst_path), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid dst_path");
3035         memset(repl_path, 0, sizeof(repl_path));
3036         memset(org_repl_path, 0, sizeof(org_repl_path));
3037         ret = _media_content_replace_path(dst_path, repl_path);
3038         media_content_retvm_if(!STRING_VALID(repl_path), MEDIA_CONTENT_ERROR_INVALID_OPERATION, "path replacement failed");
3039
3040         media_info_s *_media = (media_info_s*)media;
3041
3042         ret = _media_content_replace_path(_media->file_path, org_repl_path);
3043         media_content_retvm_if(!STRING_VALID(org_repl_path), MEDIA_CONTENT_ERROR_INVALID_OPERATION, "path replacement failed");
3044
3045         /* If the two paths are the same, do nothing */
3046         media_content_retvm_if(g_strcmp0(repl_path, org_repl_path) == 0, MEDIA_CONTENT_ERROR_NONE, "Same path");
3047
3048         ret = __media_info_check_file_validity(repl_path);
3049         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
3050
3051         memset(storage_id, 0x00, sizeof(storage_id));
3052         ret = media_svc_get_storage_id(_content_get_db_handle(), org_repl_path, storage_id, _content_get_uid());
3053         if (ret != MS_MEDIA_ERR_NONE) {
3054                 media_content_error("media_svc_get_storage_id failed : %d", ret);
3055                 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
3056         }
3057
3058         ret = media_svc_move_item(_content_get_db_handle(), org_repl_path, repl_path, _content_get_uid());
3059         return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
3060 }
3061
3062 int media_info_create_thumbnail(media_info_h media, media_thumbnail_completed_cb callback, void *user_data)
3063 {
3064         int ret = MEDIA_CONTENT_ERROR_NONE;
3065         media_content_warn("DEPRECATION WARNING: media_info_create_thumbnail() is deprecated and will be removed from next release. Use media_info_generate_thumbnail() instead.");
3066         static unsigned int req_id = 0;
3067         char repl_path[MAX_PATH_LEN] = {0, };
3068         media_info_s *_media = (media_info_s*)media;
3069
3070         if (_media != NULL && STRING_VALID(_media->media_id) && STRING_VALID(_media->file_path)) {
3071                 memset(repl_path, 0, sizeof(repl_path));
3072                 ret = _media_content_replace_path(_media->file_path, repl_path);
3073                 media_content_retvm_if(!STRING_VALID(repl_path), MEDIA_CONTENT_ERROR_INVALID_OPERATION, "path replacement failed");
3074
3075                 media_thumbnail_cb_s *_thumb_cb = (media_thumbnail_cb_s*)calloc(1, sizeof(media_thumbnail_cb_s));
3076                 media_content_retvm_if(_thumb_cb == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3077                 req_id++;
3078                 _media->request_id = req_id;
3079
3080                 _thumb_cb->handle = _media;
3081                 _thumb_cb->user_data = user_data;
3082                 _thumb_cb->thumbnail_completed_cb = callback;
3083
3084                 ret = thumbnail_request_from_db_async(_media->request_id, repl_path, (ThumbFunc)__media_info_thumbnail_completed_cb, (void *)_thumb_cb, _content_get_uid());
3085                 ret = _content_error_capi(MEDIA_THUMBNAIL_TYPE, ret);
3086         } else {
3087                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
3088                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
3089         }
3090
3091         return ret;
3092 }
3093
3094 int media_info_generate_thumbnail(media_info_h media)
3095 {
3096         int ret = MEDIA_CONTENT_ERROR_NONE;
3097         char repl_path[MAX_PATH_LEN] = {0, };
3098         char *thumb_path = NULL;
3099         media_info_s *_media = (media_info_s*)media;
3100
3101         if (_media != NULL && STRING_VALID(_media->media_id) && STRING_VALID(_media->file_path)) {
3102                 /* Already exists */
3103                 if (STRING_VALID(_media->thumbnail_path))
3104                         return MEDIA_CONTENT_ERROR_NONE;
3105
3106                 memset(repl_path, 0, sizeof(repl_path));
3107                 ret = _media_content_replace_path(_media->file_path, repl_path);
3108                 media_content_retvm_if(!STRING_VALID(repl_path), MEDIA_CONTENT_ERROR_INVALID_OPERATION, "path replacement failed");
3109
3110                 ret = media_svc_create_thumbnail(_media->storage_uuid, repl_path, _media->media_type, _content_get_uid(), &thumb_path);
3111                 ret = _content_error_capi(MEDIA_THUMBNAIL_TYPE, ret);
3112                 if (ret == MEDIA_CONTENT_ERROR_UNSUPPORTED_CONTENT) {
3113                         SAFE_FREE(thumb_path);
3114                         return ret;
3115                 }
3116
3117                 /* thumb_path is not NULL except #MEDIA_CONTENT_ERROR_UNSUPPORTED_CONTENT */
3118                 _media->thumbnail_path = g_strdup(thumb_path);
3119                 SAFE_FREE(thumb_path);
3120                 if (_media->thumbnail_path == NULL)
3121                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
3122         } else {
3123                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
3124                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
3125         }
3126
3127         return ret;
3128 }
3129
3130 int media_info_cancel_thumbnail(media_info_h media)
3131 {
3132         int ret = MEDIA_CONTENT_ERROR_NONE;
3133         media_content_warn("DEPRECATION WARNING: media_info_cancel_thumbnail() is deprecated and will be removed from next release.");
3134         media_info_s *_media = (media_info_s*)media;
3135
3136         if (_media != NULL && STRING_VALID(_media->media_id) && _media->request_id > 0) {
3137                 ret = thumbnail_request_cancel_media(_media->request_id);
3138                 ret = _content_error_capi(MEDIA_THUMBNAIL_TYPE, ret);
3139         } else {
3140                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
3141                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
3142         }
3143
3144         return ret;
3145 }
3146
3147 int media_info_start_face_detection(media_info_h media, media_face_detection_completed_cb callback, void *user_data)
3148 {
3149         int ret = MEDIA_CONTENT_ERROR_NONE;
3150         static unsigned int req_id = 0;
3151         media_info_s *_media = (media_info_s*)media;
3152         char repl_path[MAX_PATH_LEN] = {0, };
3153
3154         if (!__media_info_isFaceRecognition_feature_supported()) {
3155                 media_content_error("NOT_SUPPORTED(0x%08x)", MEDIA_CONTENT_ERROR_NOT_SUPPORTED);
3156                 return MEDIA_CONTENT_ERROR_NOT_SUPPORTED;
3157         }
3158
3159         if (_media != NULL && STRING_VALID(_media->media_id) && STRING_VALID(_media->file_path)) {
3160                 memset(repl_path, 0, sizeof(repl_path));
3161                 ret = _media_content_replace_path(_media->file_path, repl_path);
3162                 media_content_retvm_if(!STRING_VALID(repl_path), MEDIA_CONTENT_ERROR_INVALID_OPERATION, "path replacement failed");
3163                 media_face_cb_s *_face_cb = (media_face_cb_s*)calloc(1, sizeof(media_face_cb_s));
3164                 media_content_retvm_if(_face_cb == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3165                 req_id++;
3166                 _media->face_request_id = req_id;
3167
3168                 _face_cb->user_data = user_data;
3169                 _face_cb->face_completed_cb = callback;
3170
3171                 ret = dcm_request_extract_face_async(_media->face_request_id, repl_path, (FaceFunc)__media_info_face_completed_cb, (void *)_face_cb, _content_get_uid());
3172                 ret = _content_error_capi(MEDIA_THUMBNAIL_TYPE, ret);
3173         } else {
3174                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
3175                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
3176         }
3177
3178         return ret;
3179 }
3180
3181 int media_info_cancel_face_detection(media_info_h media)
3182 {
3183         int ret = MEDIA_CONTENT_ERROR_NONE;
3184         media_info_s *_media = (media_info_s*)media;
3185
3186         if (!__media_info_isFaceRecognition_feature_supported()) {
3187                 media_content_error("NOT_SUPPORTED(0x%08x)", MEDIA_CONTENT_ERROR_NOT_SUPPORTED);
3188                 return MEDIA_CONTENT_ERROR_NOT_SUPPORTED;
3189         }
3190
3191         if (_media != NULL && STRING_VALID(_media->media_id) && _media->face_request_id > 0) {
3192                 ret = dcm_request_cancel_face(_media->face_request_id);
3193                 ret = _content_error_capi(MEDIA_THUMBNAIL_TYPE, ret);
3194         } else {
3195                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
3196                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
3197         }
3198
3199         return ret;
3200 }
3201
3202 static int __media_info_map_data_usr_to_svc(media_info_s *media, media_svc_content_info_s **service_content, media_content_storage_e storage_type)
3203 {
3204         media_content_retvm_if(media == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid handle");
3205         char repl_path[MAX_PATH_LEN] = {0, };
3206         char *tmp_path = NULL;
3207
3208         media_svc_content_info_s *svc_content_info = calloc(1, sizeof(media_svc_content_info_s));
3209         media_content_retvm_if(svc_content_info == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3210
3211         memset(repl_path, 0, sizeof(repl_path));
3212         tmp_path = g_strdup(media->file_path);
3213         _media_content_replace_path(tmp_path, repl_path);
3214         svc_content_info->path = g_strdup(repl_path);
3215         SAFE_FREE(tmp_path);
3216
3217         svc_content_info->file_name = g_strdup(media->display_name);
3218         svc_content_info->media_type = media->media_type;
3219         svc_content_info->mime_type = g_strdup(media->mime_type);
3220         svc_content_info->size = media->size;
3221         svc_content_info->storage_type = storage_type;
3222         svc_content_info->storage_uuid = g_strdup(media->storage_uuid);
3223
3224         svc_content_info->added_time = media->added_time;
3225         svc_content_info->modified_time = media->modified_time;
3226         svc_content_info->thumbnail_path = g_strdup(media->thumbnail_path);
3227         svc_content_info->is_drm = media->is_drm;
3228         svc_content_info->last_played_time = media->played_time;
3229         svc_content_info->played_count = media->played_count;
3230         svc_content_info->favourate = media->favourite;
3231
3232 #ifdef _USE_SENIOR_MODE
3233         if (_media_content_is_support_senior_mode()) {
3234                 svc_content_info->contact = g_strdup(media->contact);
3235                 svc_content_info->app_data = g_strdup(media->app_data);
3236         }
3237 #endif
3238
3239         svc_content_info->media_meta.title = g_strdup(media->title);
3240         svc_content_info->media_meta.rating = media->rating;
3241         svc_content_info->media_meta.description = g_strdup(media->description);
3242         svc_content_info->media_meta.longitude = media->longitude;
3243         svc_content_info->media_meta.latitude = media->latitude;
3244         svc_content_info->media_meta.altitude = media->altitude;
3245         svc_content_info->media_meta.weather = g_strdup(media->weather);
3246         svc_content_info->media_meta.category = g_strdup(media->category);
3247         svc_content_info->media_meta.keyword = g_strdup(media->keyword);
3248         svc_content_info->media_meta.location_tag = g_strdup(media->location_tag);
3249         svc_content_info->media_meta.content_name = g_strdup(media->content_name);
3250         svc_content_info->media_meta.age_rating = g_strdup(media->age_rating);
3251         svc_content_info->media_meta.author = g_strdup(media->author);
3252         svc_content_info->media_meta.provider = g_strdup(media->provider);
3253
3254         svc_content_info->media_meta.album = g_strdup(media->audio_meta->album);
3255         svc_content_info->media_meta.artist = g_strdup(media->audio_meta->artist);
3256         svc_content_info->media_meta.genre = g_strdup(media->audio_meta->genre);
3257         svc_content_info->media_meta.recorded_date = g_strdup(media->audio_meta->recorded_date);
3258
3259         *service_content = svc_content_info;
3260
3261         return MEDIA_CONTENT_ERROR_NONE;
3262 }
3263
3264 static int __media_info_set_str_data(media_info_h media, media_info_item_e data_type, const char *str_data)
3265 {
3266         media_info_s *_media = (media_info_s*)media;
3267
3268         media_content_retvm_if(_media == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid media");
3269
3270         switch (data_type) {
3271         case MEDIA_INFO_PATH:
3272                 SAFE_FREE(_media->file_path);
3273                 if (STRING_VALID(str_data)) {
3274                         _media->file_path = strdup(str_data);
3275                         media_content_retvm_if(_media->file_path == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3276                 } else {
3277                         _media->file_path = NULL;
3278                 }
3279                 break;
3280         case MEDIA_INFO_MIME_TYPE:
3281                 SAFE_FREE(_media->mime_type);
3282                 if (STRING_VALID(str_data)) {
3283                         _media->mime_type = strdup(str_data);
3284                         media_content_retvm_if(_media->mime_type == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3285                 } else {
3286                         _media->mime_type = NULL;
3287                 }
3288                 break;
3289         case MEDIA_INFO_THUMBNAIL_PATH:
3290                 SAFE_FREE(_media->thumbnail_path);
3291                 if (STRING_VALID(str_data)) {
3292                         _media->thumbnail_path = strdup(str_data);
3293                         media_content_retvm_if(_media->thumbnail_path == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3294                 } else {
3295                         _media->thumbnail_path = NULL;
3296                 }
3297                 break;
3298         case MEDIA_INFO_TITLE:
3299                 SAFE_FREE(_media->title);
3300                 if (STRING_VALID(str_data)) {
3301                         _media->title = strdup(str_data);
3302                         media_content_retvm_if(_media->title == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3303                 } else {
3304                         _media->title = NULL;
3305                 }
3306                 break;
3307         case MEDIA_INFO_STORAGE_UUID:
3308                 SAFE_FREE(_media->storage_uuid);
3309                 if (STRING_VALID(str_data)) {
3310                         _media->storage_uuid = strdup(str_data);
3311                         media_content_retvm_if(_media->storage_uuid == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3312                 } else {
3313                         _media->storage_uuid = NULL;
3314                 }
3315                 break;
3316         case MEDIA_INFO_ALBUM:
3317                 if (STRING_VALID(_media->media_id)) {
3318                         if (_media->media_type == MEDIA_CONTENT_TYPE_VIDEO) {
3319                                 SAFE_FREE(_media->video_meta->album);
3320                                 if (str_data != NULL) {
3321                                         _media->video_meta->album = strdup(str_data);
3322                                         media_content_retvm_if(_media->video_meta->album == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3323                                 }
3324                         } else if ((_media->media_type == MEDIA_CONTENT_TYPE_MUSIC) || (_media->media_type == MEDIA_CONTENT_TYPE_SOUND)) {
3325                                 SAFE_FREE(_media->audio_meta->album);
3326                                 if (str_data != NULL) {
3327                                         _media->audio_meta->album = strdup(str_data);
3328                                         media_content_retvm_if(_media->audio_meta->album == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3329                                 }
3330                         }
3331                 } else {
3332                         SAFE_FREE(_media->video_meta->album);
3333                         if (str_data != NULL) {
3334                                 _media->video_meta->album = strdup(str_data);
3335                                 media_content_retvm_if(_media->video_meta->album == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3336                         }
3337
3338                         SAFE_FREE(_media->audio_meta->album);
3339                         if (str_data != NULL) {
3340                                 _media->audio_meta->album = strdup(str_data);
3341                                 media_content_retvm_if(_media->audio_meta->album == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3342                         }
3343                 }
3344                 break;
3345         case MEDIA_INFO_ARTIST:
3346                 if (STRING_VALID(_media->media_id)) {
3347                         if (_media->media_type == MEDIA_CONTENT_TYPE_VIDEO) {
3348                                 SAFE_FREE(_media->video_meta->artist);
3349                                 if (str_data != NULL) {
3350                                         _media->video_meta->artist = strdup(str_data);
3351                                         media_content_retvm_if(_media->video_meta->artist == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3352                                 }
3353                         } else if ((_media->media_type == MEDIA_CONTENT_TYPE_MUSIC) || (_media->media_type == MEDIA_CONTENT_TYPE_SOUND)) {
3354                                 SAFE_FREE(_media->audio_meta->artist);
3355                                 if (str_data != NULL) {
3356                                         _media->audio_meta->artist = strdup(str_data);
3357                                         media_content_retvm_if(_media->audio_meta->artist == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3358                                 }
3359                         }
3360                 } else {
3361                         SAFE_FREE(_media->video_meta->artist);
3362                         if (str_data != NULL) {
3363                                 _media->video_meta->artist = strdup(str_data);
3364                                 media_content_retvm_if(_media->video_meta->artist == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3365                         }
3366
3367                         SAFE_FREE(_media->audio_meta->artist);
3368                         if (str_data != NULL) {
3369                                 _media->audio_meta->artist = strdup(str_data);
3370                                 media_content_retvm_if(_media->audio_meta->artist == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3371                         }
3372                 }
3373                 break;
3374         case MEDIA_INFO_GENRE:
3375                 if (STRING_VALID(_media->media_id)) {
3376                         if (_media->media_type == MEDIA_CONTENT_TYPE_VIDEO) {
3377                                 SAFE_FREE(_media->video_meta->genre);
3378                                 if (str_data != NULL) {
3379                                         _media->video_meta->genre = strdup(str_data);
3380                                         media_content_retvm_if(_media->video_meta->genre == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3381                                 }
3382                         } else if ((_media->media_type == MEDIA_CONTENT_TYPE_MUSIC) || (_media->media_type == MEDIA_CONTENT_TYPE_SOUND)) {
3383                                 SAFE_FREE(_media->audio_meta->genre);
3384                                 if (str_data != NULL) {
3385                                         _media->audio_meta->genre = strdup(str_data);
3386                                         media_content_retvm_if(_media->audio_meta->genre == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3387                                 }
3388                         }
3389                 } else {
3390                         SAFE_FREE(_media->video_meta->genre);
3391                         if (str_data != NULL) {
3392                                 _media->video_meta->genre = strdup(str_data);
3393                                 media_content_retvm_if(_media->video_meta->genre == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3394                         }
3395
3396                         SAFE_FREE(_media->audio_meta->genre);
3397                         if (str_data != NULL) {
3398                                 _media->audio_meta->genre = strdup(str_data);
3399                                 media_content_retvm_if(_media->audio_meta->genre == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3400                         }
3401                 }
3402                 break;
3403         case MEDIA_INFO_RECORDED_DATE:
3404                 if (STRING_VALID(_media->media_id)) {
3405                         if (_media->media_type == MEDIA_CONTENT_TYPE_VIDEO) {
3406                                 SAFE_FREE(_media->video_meta->recorded_date);
3407                                 if (str_data != NULL) {
3408                                         _media->video_meta->recorded_date = strdup(str_data);
3409                                         media_content_retvm_if(_media->video_meta->recorded_date == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3410                                 }
3411                         } else if ((_media->media_type == MEDIA_CONTENT_TYPE_MUSIC) || (_media->media_type == MEDIA_CONTENT_TYPE_SOUND)) {
3412                                 SAFE_FREE(_media->audio_meta->recorded_date);
3413                                 if (str_data != NULL) {
3414                                         _media->audio_meta->recorded_date = strdup(str_data);
3415                                         media_content_retvm_if(_media->audio_meta->recorded_date == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3416                                 }
3417                         }
3418                 } else {
3419                         SAFE_FREE(_media->video_meta->recorded_date);
3420                         if (str_data != NULL) {
3421                                 _media->video_meta->recorded_date = strdup(str_data);
3422                                 media_content_retvm_if(_media->video_meta->recorded_date == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3423                         }
3424
3425                         SAFE_FREE(_media->audio_meta->recorded_date);
3426                         if (str_data != NULL) {
3427                                 _media->audio_meta->recorded_date = strdup(str_data);
3428                                 media_content_retvm_if(_media->audio_meta->recorded_date == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3429                         }
3430                 }
3431                 break;
3432         default:
3433                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
3434                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
3435         }
3436
3437         return MEDIA_CONTENT_ERROR_NONE;
3438 }
3439
3440 static int __media_info_destroy(media_info_h media)
3441 {
3442         int ret = MEDIA_CONTENT_ERROR_NONE;
3443         media_info_s *_media = (media_info_s*)media;
3444
3445         if (_media) {
3446                 SAFE_FREE(_media->media_id);
3447                 SAFE_FREE(_media->file_path);
3448                 SAFE_FREE(_media->display_name);
3449                 SAFE_FREE(_media->mime_type);
3450                 SAFE_FREE(_media->thumbnail_path);
3451                 SAFE_FREE(_media->description);
3452                 SAFE_FREE(_media->author);
3453                 SAFE_FREE(_media->provider);
3454                 SAFE_FREE(_media->content_name);
3455                 SAFE_FREE(_media->category);
3456                 SAFE_FREE(_media->location_tag);
3457                 SAFE_FREE(_media->age_rating);
3458                 SAFE_FREE(_media->keyword);
3459                 SAFE_FREE(_media->title);
3460                 SAFE_FREE(_media->weather);
3461                 SAFE_FREE(_media->storage_uuid);
3462
3463                 if (_media->image_meta) {
3464                         SAFE_FREE(_media->image_meta->media_id);
3465                         SAFE_FREE(_media->image_meta->date_taken);
3466                         SAFE_FREE(_media->image_meta->burst_id);
3467                         SAFE_FREE(_media->image_meta->exposure_time);
3468                         SAFE_FREE(_media->image_meta->model);
3469                         SAFE_FREE(_media->image_meta->title);
3470
3471                         SAFE_FREE(_media->image_meta);
3472                 }
3473
3474                 if (_media->video_meta) {
3475                         SAFE_FREE(_media->video_meta->media_id);
3476                         SAFE_FREE(_media->video_meta->title);
3477                         SAFE_FREE(_media->video_meta->album);
3478                         SAFE_FREE(_media->video_meta->artist);
3479                         SAFE_FREE(_media->video_meta->album_artist);
3480                         SAFE_FREE(_media->video_meta->genre);
3481                         SAFE_FREE(_media->video_meta->composer);
3482                         SAFE_FREE(_media->video_meta->year);
3483                         SAFE_FREE(_media->video_meta->recorded_date);
3484                         SAFE_FREE(_media->video_meta->copyright);
3485                         SAFE_FREE(_media->video_meta->track_num);
3486
3487                         SAFE_FREE(_media->video_meta);
3488                 }
3489
3490                 if (_media->audio_meta) {
3491                         SAFE_FREE(_media->audio_meta->media_id);
3492                         SAFE_FREE(_media->audio_meta->title);
3493                         SAFE_FREE(_media->audio_meta->album);
3494                         SAFE_FREE(_media->audio_meta->artist);
3495                         SAFE_FREE(_media->audio_meta->album_artist);
3496                         SAFE_FREE(_media->audio_meta->genre);
3497                         SAFE_FREE(_media->audio_meta->composer);
3498                         SAFE_FREE(_media->audio_meta->year);
3499                         SAFE_FREE(_media->audio_meta->recorded_date);
3500                         SAFE_FREE(_media->audio_meta->copyright);
3501                         SAFE_FREE(_media->audio_meta->track_num);
3502
3503                         SAFE_FREE(_media->audio_meta);
3504                 }
3505
3506                 ret = MEDIA_CONTENT_ERROR_NONE;
3507         } else {
3508                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
3509                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
3510         }
3511
3512         return ret;
3513 }
3514
3515 int media_info_insert_to_db_with_data(media_info_h media)
3516 {
3517         int ret = MEDIA_CONTENT_ERROR_NONE;
3518         int ret_cnt = 0;
3519         char repl_path[MAX_PATH_LEN] = {0, };
3520
3521         media_content_warn("DEPRECATION WARNING: media_info_insert_to_db_with_data() is deprecated and will be removed from next release. Use media_info_insert_to_db() instead.");
3522
3523         media_info_s *_media = (media_info_s*)media;
3524
3525         media_content_retvm_if(_media == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid media");
3526         media_content_retvm_if(!STRING_VALID(_media->file_path), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid file_path");
3527         media_content_retvm_if(!STRING_VALID(_media->storage_uuid), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid storage_uuid");
3528         media_content_retvm_if(_media->storage_type < 0, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid storage_type [%d]", _media->storage_type);
3529
3530         media_content_sec_debug("storage[%d], path[%s], media_type[%d]", _media->storage_type, _media->file_path, _media->media_type);
3531
3532         media_svc_content_info_s *svc_content_info = NULL;
3533
3534         ret = __media_info_map_data_usr_to_svc(_media, &svc_content_info, _media->storage_type);
3535         media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "__media_info_map_data_usr_to_svc fail");
3536
3537         ret = media_svc_insert_item_immediately_with_data(_content_get_db_handle(), svc_content_info, _content_get_uid());
3538         if (ret != MS_MEDIA_ERR_NONE) {
3539                 media_content_sec_error("media_svc_insert_item_immediately_with_data failed : %d (%s)", ret, _media->file_path);
3540                 media_svc_destroy_content_info(svc_content_info);
3541                 SAFE_FREE(svc_content_info);
3542                 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
3543         }
3544         /*free the svc_content_info*/
3545         media_svc_destroy_content_info(svc_content_info);
3546         SAFE_FREE(svc_content_info);
3547
3548         /*Fill out the handle*/
3549         memset(repl_path, 0, sizeof(repl_path));
3550         ret = _media_content_replace_path(_media->file_path, repl_path);
3551         char *media_file_path = g_strdup(repl_path);
3552
3553         char *media_string_uuid = g_strdup(_media->storage_uuid);
3554
3555         __media_info_destroy(media);
3556 RETRY:
3557         ret = _media_info_get_media_info_from_db(media_file_path, media_string_uuid, media);
3558         if (ret != MEDIA_CONTENT_ERROR_NONE) {
3559                 media_content_error("_media_info_get_media_info_from_db fail [%d]", ret);
3560                 if (ret == MEDIA_CONTENT_ERROR_DB_FAILED && ret_cnt < 5) {
3561                         ret_cnt++;
3562                         media_content_error("RETRY GETTING DATA");
3563                         goto RETRY;
3564                 }
3565         }
3566
3567         SAFE_FREE(media_file_path);
3568         SAFE_FREE(media_string_uuid);
3569
3570         return ret;
3571 }
3572
3573 int media_info_create(const char *path, media_info_h *media)
3574 {
3575         int ret = MEDIA_CONTENT_ERROR_NONE;
3576         char storage_id[MEDIA_CONTENT_UUID_SIZE+1] = {0, };
3577         media_svc_storage_type_e storage_type = 0;
3578         char repl_path[MAX_PATH_LEN] = {0, };
3579         media_content_warn("DEPRECATION WARNING: media_info_create() is deprecated and will be removed from next release. Use media_info_insert_to_db() instead.");
3580
3581         media_content_retvm_if(!STRING_VALID(path), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid path");
3582         media_content_retvm_if(media == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid media");
3583         memset(repl_path, 0, sizeof(repl_path));
3584         ret = _media_content_replace_path(path, repl_path);
3585         media_content_retvm_if(!STRING_VALID(repl_path), MEDIA_CONTENT_ERROR_INVALID_OPERATION, "path replacement failed");
3586
3587         memset(storage_id, 0x00, sizeof(storage_id));
3588
3589         ret = __media_info_check_file_validity(repl_path);
3590         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
3591
3592         ret = media_svc_get_storage_id(_content_get_db_handle(), repl_path, storage_id, _content_get_uid());
3593         if (ret != MS_MEDIA_ERR_NONE) {
3594                 media_content_error("media_svc_get_storage_id failed : %d", ret);
3595                 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
3596         }
3597
3598         ret = media_svc_get_storage_type(repl_path, &storage_type, _content_get_uid());
3599         if (ret != MS_MEDIA_ERR_NONE) {
3600                 media_content_sec_error("media_svc_get_storage_type failed : %d", ret);
3601                 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
3602         }
3603
3604         media_info_s *_media = (media_info_s*)calloc(1, sizeof(media_info_s));
3605         media_content_retvm_if(_media == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3606
3607         _media->audio_meta = (audio_meta_s *)calloc(1, sizeof(audio_meta_s));
3608         if (_media->audio_meta == NULL) {
3609                 SAFE_FREE(_media);
3610                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
3611                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
3612         }
3613
3614         _media->video_meta = (video_meta_s *)calloc(1, sizeof(video_meta_s));
3615         if (_media->video_meta == NULL) {
3616                 SAFE_FREE(_media->audio_meta);
3617                 SAFE_FREE(_media);
3618                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
3619                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
3620         }
3621
3622         _media->image_meta = (image_meta_s *)calloc(1, sizeof(image_meta_s));
3623         if (_media->image_meta == NULL) {
3624                 SAFE_FREE(_media->audio_meta);
3625                 SAFE_FREE(_media->video_meta);
3626                 SAFE_FREE(_media);
3627                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
3628                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
3629         }
3630
3631         _media->file_path = g_strdup(path);
3632         _media->storage_type = -1;
3633         _media->media_type = 0;
3634         _media->modified_time = 0;
3635         _media->size = 0;
3636         _media->request_id = 0;
3637         _media->longitude = MEDIA_SVC_DEFAULT_GPS_VALUE;
3638         _media->latitude = MEDIA_SVC_DEFAULT_GPS_VALUE;
3639         _media->altitude = MEDIA_SVC_DEFAULT_GPS_VALUE;
3640
3641         if (STRING_VALID(storage_id)) {
3642                 _media->storage_uuid = g_strdup(storage_id);
3643                 _media->storage_type = storage_type;
3644         }
3645
3646         *media = (media_info_h)_media;
3647
3648         return ret;
3649 }
3650
3651 int media_info_set_title(media_info_h media, const char *title)
3652 {
3653         media_content_warn("DEPRECATION WARNING: media_info_set_title() is deprecated and will be removed from next release.");
3654
3655         return __media_info_set_str_data(media, MEDIA_INFO_TITLE, title);
3656 }
3657
3658 int media_info_set_album(media_info_h media, const char *album)
3659 {
3660         media_content_warn("DEPRECATION WARNING: media_info_set_album() is deprecated and will be removed from next release.");
3661
3662         return __media_info_set_str_data(media, MEDIA_INFO_ALBUM, album);
3663 }
3664
3665 int media_info_set_artist(media_info_h media, const char *artist)
3666 {
3667         media_content_warn("DEPRECATION WARNING: media_info_set_artist() is deprecated and will be removed from next release.");
3668
3669         return __media_info_set_str_data(media, MEDIA_INFO_ARTIST, artist);
3670 }
3671
3672 int media_info_set_genre(media_info_h media, const char *genre)
3673 {
3674         media_content_warn("DEPRECATION WARNING: media_info_set_genre() is deprecated and will be removed from next release.");
3675
3676         return __media_info_set_str_data(media, MEDIA_INFO_GENRE, genre);
3677 }
3678
3679 int media_info_set_recorded_date(media_info_h media, const char *recorded_date)
3680 {
3681         media_content_warn("DEPRECATION WARNING: media_info_set_recorded_date() is deprecated and will be removed from next release.");
3682
3683         return __media_info_set_str_data(media, MEDIA_INFO_RECORDED_DATE, recorded_date);
3684 }