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                         nwrites = fwrite(path_array[idx], 1, size, fp);
 196                         if (nwrites != size) {
 197                                 media_content_stderror("failed to write");
 198                                 fclose(fp);
 199                                 if (unlink(list_path) < 0)
 200                                         media_content_stderror("failed to delete");
 201                                 return MEDIA_CONTENT_ERROR_INVALID_OPERATION;
 202                         }
 203
 204                         nwrites = fwrite("\n", 1, 1, fp);
 205                         if (nwrites != 1) {
 206                                 media_content_stderror("failed to write");
 207                                 fclose(fp);
 208                                 if (unlink(list_path) < 0)
 209                                         media_content_stderror("failed to delete");
 210                                 return MEDIA_CONTENT_ERROR_INVALID_OPERATION;
 211                         }
 212                 } else {
 213                         media_content_error("path[%d] is invalid string", idx);
 214                 }
 215         }
 216
 217         fclose(fp);
 218
 219         media_insert_cb_s *_cb_data = (media_insert_cb_s *)calloc(1, sizeof(media_insert_cb_s));
 220         media_content_retvm_if(_cb_data == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 221
 222         _cb_data->insert_completed_cb = completed_cb;
 223         _cb_data->user_data = user_data;
 224         _cb_data->insert_list_path = g_strdup(list_path);
 225
 226         if (insert_type == MEDIA_BATCH_INSERT_NORMAL)
 227                 ret = media_files_register(list_path, __media_info_insert_completed_cb, _cb_data, _content_get_uid());
 228         else if (insert_type == MEDIA_BATCH_INSERT_BURSTSHOT)
 229                 ret = media_burstshot_register(list_path, __media_info_insert_completed_cb, _cb_data, _content_get_uid());
 230         else
 231                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 232
 233         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 234                 media_content_error("media_files_register failed : %d", ret);
 235                 if (unlink(list_path) < 0)
 236                         media_content_stderror("failed to delete");
 237                 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 238         }
 239
 240         return ret;
 241 }
 242
 243 int __media_info_get_storage_list_to_remove(const char *condition_query, GArray **storage_list)
 244 {
 245         int ret = MEDIA_CONTENT_ERROR_NONE;
 246         char *query_string = NULL;
 247         sqlite3_stmt *stmt = NULL;
 248
 249         media_content_retv_if(storage_list == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 250         media_content_retv_if(!STRING_VALID(condition_query), MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 251
 252         query_string = sqlite3_mprintf(SELECT_STORAGE_BY_FILTER, condition_query);
 253
 254         ret = _content_query_prepare(&stmt, query_string, NULL, NULL);
 255         SQLITE3_SAFE_FREE(query_string);
 256
 257         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 258
 259         *storage_list = g_array_new(FALSE, FALSE, sizeof(media_storage_s *));
 260
 261         while (sqlite3_step(stmt) == SQLITE_ROW) {
 262                 media_storage_s *storage = (media_storage_s*)calloc(1, sizeof(media_storage_s));
 263                 if (storage == NULL) {
 264                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 265                         SQLITE3_FINALIZE(stmt);
 266                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 267                 }
 268                 storage->storage_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
 269                 storage->storage_type = (int)sqlite3_column_int(stmt, 1);
 270
 271                 g_array_append_val(*storage_list, storage);
 272         }
 273
 274         SQLITE3_FINALIZE(stmt);
 275
 276         return ret;
 277 }
 278
 279 int __media_info_get_thumbnail_to_remove(const char *condition_query, const char *storage_id, int storage_type, GArray **thumb_list)
 280 {
 281         int ret = MEDIA_CONTENT_ERROR_NONE;
 282         char *query_string = NULL;
 283         char *thumbnail_path = NULL;
 284         sqlite3_stmt *stmt = NULL;
 285
 286         media_content_retv_if(thumb_list == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 287         media_content_retv_if(storage_id == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 288         media_content_retv_if(!STRING_VALID(condition_query), MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 289
 290         query_string = sqlite3_mprintf(SELECT_THUMBNAIL_BY_FILTER, storage_id, condition_query, storage_type);
 291
 292         ret = _content_query_prepare(&stmt, query_string, NULL, NULL);
 293         SQLITE3_SAFE_FREE(query_string);
 294
 295         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 296
 297         *thumb_list = g_array_new(FALSE, FALSE, sizeof(char*));
 298
 299         while (sqlite3_step(stmt) == SQLITE_ROW) {
 300                 thumbnail_path = g_strdup((const char *)sqlite3_column_text(stmt, 0));
 301                 if (STRING_VALID(thumbnail_path))
 302                         g_array_append_val(*thumb_list, thumbnail_path);
 303                 else
 304                         SAFE_FREE(thumbnail_path);
 305         }
 306
 307         SQLITE3_FINALIZE(stmt);
 308
 309         return ret;
 310 }
 311
 312 static int __media_info_check_file_validity(const char *path)
 313 {
 314         bool ignore = FALSE;
 315         char *folder_path = NULL;
 316         int ret = MEDIA_CONTENT_ERROR_NONE;
 317
 318         media_content_retvm_if(!STRING_VALID(path), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid path");
 319
 320         ret = _media_util_check_ignore_file(path, &ignore);
 321         media_content_retvm_if(ignore == TRUE, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid ignore path");
 322
 323         ret = _media_util_check_file_exist(path);
 324         media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "invalid path");
 325
 326         folder_path = g_path_get_dirname(path);
 327         ret = _media_util_check_ignore_dir(folder_path, &ignore);
 328         SAFE_FREE(folder_path);
 329         media_content_retvm_if(ignore == TRUE, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid folder path");
 330
 331         return MEDIA_CONTENT_ERROR_NONE;
 332 }
 333
 334 void _media_info_item_get_detail(sqlite3_stmt* stmt, media_info_h media)
 335 {
 336         media_info_s *_media = (media_info_s*)media;
 337
 338         char *tmp_path = NULL;
 339         char repl_path[MAX_PATH_LEN] = {0, };
 340
 341         _media->media_id = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_UUID));
 342
 343         tmp_path = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_PATH));
 344         _media_content_rollback_path(tmp_path, repl_path);
 345         _media->file_path = g_strdup(repl_path);
 346         SAFE_FREE(tmp_path);
 347
 348         _media->display_name = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_FILE_NAME));
 349         _media->media_type = (int)sqlite3_column_int(stmt, MEDIA_INFO_TYPE);
 350         _media->mime_type = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_MIME_TYPE));
 351         _media->size = (unsigned long long)sqlite3_column_int64(stmt, MEDIA_INFO_SIZE);
 352         _media->added_time = (int)sqlite3_column_int(stmt, MEDIA_INFO_ADDED_TIME);
 353         _media->modified_time = (int)sqlite3_column_int(stmt, MEDIA_INFO_MODIFIED_TIME);
 354         _media->thumbnail_path = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_THUMBNAIL_PATH));
 355         _media->description = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_DESCRIPTION));
 356         _media->rating = (int)sqlite3_column_int(stmt, MEDIA_INFO_RATING);
 357         _media->favourite = (int)sqlite3_column_int(stmt, MEDIA_INFO_FAVOURITE);
 358         _media->author = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_AUTHOR));
 359         _media->provider = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_PROVIDER));
 360         _media->content_name = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_CONTENT_NAME));
 361         _media->category = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_CATEGORY));
 362         _media->location_tag = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_LOCATION_TAG));
 363         _media->age_rating = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_AGE_RATING));
 364         _media->keyword = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_KEYWORD));
 365         _media->is_drm = (int)sqlite3_column_int(stmt, MEDIA_INFO_IS_DRM);
 366         _media->storage_type = (int)sqlite3_column_int(stmt, MEDIA_INFO_STORAGE_TYPE);
 367         _media->longitude = (double)sqlite3_column_double(stmt, MEDIA_INFO_LONGITUDE);
 368         _media->latitude = (double)sqlite3_column_double(stmt, MEDIA_INFO_LATITUDE);
 369         _media->altitude = (double)sqlite3_column_double(stmt, MEDIA_INFO_ALTITUDE);
 370         _media->played_count = sqlite3_column_int(stmt, MEDIA_INFO_PLAYED_COUNT);
 371         _media->played_time = sqlite3_column_int(stmt, MEDIA_INFO_LAST_PLAYED_TIME);
 372         _media->played_position = sqlite3_column_int(stmt, MEDIA_INFO_LAST_PLAYED_POSITION);
 373         _media->title = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_TITLE));
 374         _media->timeline = (double)sqlite3_column_double(stmt, MEDIA_INFO_TIMELINE);
 375         _media->weather = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_WEATHER));
 376         _media->sync_status = (int)sqlite3_column_int(stmt, MEDIA_INFO_SYNC_STATUS);
 377         _media->storage_uuid = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_STORAGE_UUID));
 378         _media->is_360 = (int)sqlite3_column_int(stmt, MEDIA_INFO_IS_360);
 379 #ifdef _USE_TVPD_MODE
 380         _media->stitched_info = (int)sqlite3_column_int(stmt, MEDIA_INFO_STITCHED_INFO);
 381 #endif
 382
 383         if (_media->media_type == MEDIA_CONTENT_TYPE_IMAGE) {
 384                 _media->image_meta = (image_meta_s *)calloc(1, sizeof(image_meta_s));
 385                 if (_media->image_meta) {
 386                         _media->image_meta->media_id = g_strdup(_media->media_id);
 387                         _media->image_meta->width = sqlite3_column_int(stmt, MEDIA_INFO_WIDTH);
 388                         _media->image_meta->height = sqlite3_column_int(stmt, MEDIA_INFO_HEIGHT);
 389                         _media->image_meta->fnumber = (double)sqlite3_column_double(stmt, MEDIA_INFO_FNUMBER);
 390                         _media->image_meta->iso = sqlite3_column_int(stmt, MEDIA_INFO_ISO);
 391                         _media->image_meta->date_taken = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_DATETAKEN));
 392                         _media->image_meta->orientation = sqlite3_column_int(stmt, MEDIA_INFO_ORIENTATION);
 393                         _media->image_meta->title = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_TITLE));
 394                         _media->image_meta->burst_id = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_BURST_ID));
 395                         _media->image_meta->exposure_time = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_EXPOSURE_TIME));
 396                         _media->image_meta->model = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_MODEL));
 397                 }
 398         } else if (_media->media_type == MEDIA_CONTENT_TYPE_VIDEO) {
 399                 _media->video_meta = (video_meta_s *)calloc(1, sizeof(video_meta_s));
 400                 if (_media->video_meta) {
 401                         _media->video_meta->media_id = g_strdup(_media->media_id);
 402                         _media->video_meta->width = sqlite3_column_int(stmt, MEDIA_INFO_WIDTH);
 403                         _media->video_meta->height = sqlite3_column_int(stmt, MEDIA_INFO_HEIGHT);
 404                         _media->video_meta->title = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_TITLE));
 405                         _media->video_meta->album = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_ALBUM));
 406                         _media->video_meta->artist = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_ARTIST));
 407                         _media->video_meta->album_artist = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_ALBUM_ARTIST));
 408                         _media->video_meta->genre = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_GENRE));
 409                         _media->video_meta->composer = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_COMPOSER));
 410                         _media->video_meta->year = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_YEAR));
 411                         _media->video_meta->recorded_date = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_RECORDED_DATE));
 412                         _media->video_meta->copyright = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_COPYRIGHT));
 413                         _media->video_meta->track_num = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_TRACK_NUM));
 414                         _media->video_meta->bitrate = sqlite3_column_int(stmt, MEDIA_INFO_BITRATE);
 415                         _media->video_meta->duration = sqlite3_column_int(stmt, MEDIA_INFO_DURATION);
 416                         _media->video_meta->played_count = sqlite3_column_int(stmt, MEDIA_INFO_PLAYED_COUNT);
 417                         _media->video_meta->played_time = sqlite3_column_int(stmt, MEDIA_INFO_LAST_PLAYED_TIME);
 418                         _media->video_meta->played_position = sqlite3_column_int(stmt, MEDIA_INFO_LAST_PLAYED_POSITION);
 419                         _media->video_meta->rotation = sqlite3_column_int(stmt, MEDIA_INFO_ORIENTATION);
 420                 }
 421
 422         } else if ((_media->media_type == MEDIA_CONTENT_TYPE_MUSIC) || (_media->media_type == MEDIA_CONTENT_TYPE_SOUND)) {
 423                 _media->audio_meta = (audio_meta_s *)calloc(1, sizeof(audio_meta_s));
 424                 if (_media->audio_meta) {
 425                         _media->audio_meta->media_id = g_strdup(_media->media_id);
 426                         _media->audio_meta->title = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_TITLE));
 427                         _media->audio_meta->album = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_ALBUM));
 428                         _media->audio_meta->artist = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_ARTIST));
 429                         _media->audio_meta->album_artist = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_ALBUM_ARTIST));
 430                         _media->audio_meta->genre = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_GENRE));
 431                         _media->audio_meta->composer = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_COMPOSER));
 432                         _media->audio_meta->year = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_YEAR));
 433                         _media->audio_meta->recorded_date = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_RECORDED_DATE));
 434                         _media->audio_meta->copyright = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_COPYRIGHT));
 435                         _media->audio_meta->track_num = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_TRACK_NUM));
 436                         _media->audio_meta->bitrate = sqlite3_column_int(stmt, MEDIA_INFO_BITRATE);
 437                         _media->audio_meta->bitpersample = sqlite3_column_int(stmt, MEDIA_INFO_BITPERSAMPLE);
 438                         _media->audio_meta->duration = sqlite3_column_int(stmt, MEDIA_INFO_DURATION);
 439                         _media->audio_meta->played_count = sqlite3_column_int(stmt, MEDIA_INFO_PLAYED_COUNT);
 440                         _media->audio_meta->played_time = sqlite3_column_int(stmt, MEDIA_INFO_LAST_PLAYED_TIME);
 441                         _media->audio_meta->played_position = sqlite3_column_int(stmt, MEDIA_INFO_LAST_PLAYED_POSITION);
 442                         _media->audio_meta->samplerate = sqlite3_column_int(stmt, MEDIA_INFO_SAMPLERATE);
 443                         _media->audio_meta->channel = sqlite3_column_int(stmt, MEDIA_INFO_CHANNEL);
 444                 }
 445         }
 446 }
 447
 448 int _media_info_get_media_info_from_db(const char *path, const char *storage_id, media_info_h media)
 449 {
 450         int ret = MEDIA_CONTENT_ERROR_NONE;
 451         sqlite3_stmt *stmt = NULL;
 452         char *select_query = NULL;
 453         media_info_s *_media = (media_info_s*)media;
 454
 455         media_content_retvm_if(_media == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid media");
 456
 457         select_query = sqlite3_mprintf(SELECT_MEDIA_BY_PATH, storage_id, path);
 458
 459         ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
 460         SQLITE3_SAFE_FREE(select_query);
 461         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 462
 463         if (sqlite3_step(stmt) == SQLITE_ROW) {
 464                 _media_info_item_get_detail(stmt, (media_info_h)_media);
 465         } else {
 466                 media_content_error("There's no media!!");
 467                 media_content_error("%s", path);
 468                 media_content_error("%s", storage_id);
 469                 ret = MEDIA_CONTENT_ERROR_DB_FAILED;
 470         }
 471
 472         SQLITE3_FINALIZE(stmt);
 473
 474         return ret;
 475 }
 476
 477 int media_info_insert_to_db(const char *path, media_info_h *info)
 478 {
 479         char storage_id[MEDIA_CONTENT_UUID_SIZE+1] = {0, };
 480         char repl_path[MAX_PATH_LEN] = {0, };
 481         int ret = MEDIA_CONTENT_ERROR_NONE;
 482
 483         media_content_retvm_if(!STRING_VALID(path), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid path");
 484         media_content_retvm_if(info == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid info");
 485         memset(repl_path, 0, sizeof(repl_path));
 486         ret = _media_content_replace_path(path, repl_path);
 487         media_content_retvm_if(!STRING_VALID(repl_path), MEDIA_CONTENT_ERROR_INVALID_OPERATION, "path replacement failed");
 488
 489         ret = __media_info_check_file_validity(repl_path);
 490         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 491
 492         memset(storage_id, 0x00, sizeof(storage_id));
 493         ret = media_svc_get_storage_id(_content_get_db_handle(), repl_path, storage_id, _content_get_uid());
 494         if (ret != MS_MEDIA_ERR_NONE) {
 495                 media_content_error("media_svc_get_storage_id failed : %d", ret);
 496                 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 497         }
 498
 499         ret = media_svc_check_item_exist_by_path(_content_get_db_handle(), storage_id, repl_path);
 500         if (ret == MS_MEDIA_ERR_DB_NO_RECORD) {
 501                 media_content_sec_debug("media_svc_check_item_exist_by_path : no record : %s", repl_path);
 502
 503                 media_svc_storage_type_e storage_type = 0;
 504
 505                 ret = media_svc_get_storage_type(repl_path, &storage_type, _content_get_uid());
 506                 if (ret != MS_MEDIA_ERR_NONE) {
 507                         media_content_sec_error("media_svc_get_storage_type failed : %d", ret);
 508                         return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 509                 }
 510
 511                 ret = media_svc_insert_item_immediately(_content_get_db_handle(), storage_id, storage_type, repl_path, _content_get_uid());
 512
 513                 if (ret != MS_MEDIA_ERR_NONE) {
 514                         if (ret == MS_MEDIA_ERR_DB_CONSTRAINT_FAIL) {
 515                                 media_content_sec_error("This item is already inserted. This may be normal operation because other process already did this (%s)", repl_path);
 516                                 ret = MEDIA_CONTENT_ERROR_NONE;
 517                         } else {
 518                                 media_content_sec_error("media_svc_insert_item_immediately failed : %d (%s)", ret, repl_path);
 519                         }
 520
 521                         return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 522                 }
 523         } else if (ret != MS_MEDIA_ERR_NONE) {
 524                 media_content_sec_error("media_svc_check_item_exist_by_path failed : %d (%s)", ret, repl_path);
 525                 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 526         }
 527
 528         media_info_s *_media = (media_info_s*)calloc(1, sizeof(media_info_s));
 529         media_content_retvm_if(_media == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 530
 531         if (STRING_VALID(storage_id))
 532                 ret = _media_info_get_media_info_from_db(repl_path, storage_id, (media_info_h)_media);
 533         else
 534                 ret = _media_info_get_media_info_from_db(repl_path, DEFAULT_MEDIA_STORAGE_ID, (media_info_h)_media);
 535
 536         *info = (media_info_h)_media;
 537         return ret;
 538 }
 539
 540 int media_info_insert_batch_to_db(const char **path_array, unsigned int array_length, media_insert_completed_cb completed_cb, void *user_data)
 541 {
 542         char **repl_path_array = NULL;
 543         int idx = 0;
 544         int ret = MS_MEDIA_ERR_NONE;
 545         char repl_path[MAX_PATH_LEN] = {0, };
 546
 547         media_content_retvm_if(path_array == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid path_array");
 548         media_content_retvm_if(array_length <= 0, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid array_length");
 549
 550         repl_path_array = calloc(1, sizeof(char *) * array_length);
 551         media_content_retvm_if(repl_path_array == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 552
 553         for (idx = 0; idx < array_length; idx++) {
 554                 if (STRING_VALID(path_array[idx])) {
 555                         memset(repl_path, 0, sizeof(repl_path));
 556                         _media_content_replace_path(path_array[idx], repl_path);
 557                         repl_path_array[idx] = strndup(repl_path, strlen(repl_path));
 558                 } else {
 559                         media_content_error("path[%d] is invalid string", idx);
 560                 }
 561         }
 562
 563         ret = __media_info_insert_batch(MEDIA_BATCH_INSERT_NORMAL, (const char **)repl_path_array, array_length, completed_cb, user_data);
 564         for (idx = 0; idx < array_length; idx++)
 565                 SAFE_FREE(repl_path_array[idx]);
 566
 567         SAFE_FREE(repl_path_array);
 568
 569         return ret;
 570 }
 571
 572 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)
 573 {
 574         char **repl_path_array = NULL;
 575         int idx = 0;
 576         int ret = MS_MEDIA_ERR_NONE;
 577         char repl_path[MAX_PATH_LEN] = {0, };
 578
 579         media_content_warn("DEPRECATION WARNING: media_info_insert_burst_shot_to_db() is deprecated and will be removed from next release.");
 580
 581         media_content_retvm_if(path_array == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid path_array");
 582         media_content_retvm_if(array_length <= 0, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid array_length");
 583
 584         repl_path_array = calloc(1, sizeof(char *) * array_length);
 585         media_content_retvm_if(repl_path_array == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 586
 587         for (idx = 0; idx < array_length; idx++) {
 588                 if (STRING_VALID(path_array[idx])) {
 589                         memset(repl_path, 0, sizeof(repl_path));
 590                         _media_content_replace_path(path_array[idx], repl_path);
 591                         repl_path_array[idx] = strndup(repl_path, strlen(repl_path));
 592                 } else {
 593                         media_content_error("path[%d] is invalid string", idx);
 594                 }
 595         }
 596
 597         ret = __media_info_insert_batch(MEDIA_BATCH_INSERT_BURSTSHOT, (const char **)repl_path_array, array_length, callback, user_data);
 598         for (idx = 0; idx < array_length; idx++)
 599                 SAFE_FREE(repl_path_array[idx]);
 600
 601         SAFE_FREE(repl_path_array);
 602
 603         return ret;
 604 }
 605
 606 #ifdef _USE_TVPD_MODE
 607 int media_info_get_media_info_by_path_from_db(const char* path, media_info_h* media)
 608 {
 609         char storage_id[MEDIA_CONTENT_UUID_SIZE+1] = {0,};
 610         int ret = MEDIA_CONTENT_ERROR_NONE;
 611         media_content_retvm_if(!STRING_VALID(path), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid path");
 612         media_content_retvm_if(media == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid info");
 613
 614         memset(storage_id, 0x00, sizeof(storage_id));
 615         ret = media_svc_get_storage_id(_content_get_db_handle(), path, storage_id, tzplatform_getuid(TZ_USER_NAME));
 616         if (ret != MS_MEDIA_ERR_NONE) {
 617                 media_content_error("media_svc_get_storage_id failed : %d", ret);
 618                 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 619         }
 620
 621         media_info_s *_media = (media_info_s*)calloc(1, sizeof(media_info_s));
 622         media_content_retvm_if(_media == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 623
 624         ret =  _media_info_get_media_info_from_db(path, storage_id, (media_info_h)_media);
 625         *media = (media_info_h)_media;
 626
 627         return ret;
 628 }
 629 #endif
 630
 631 #ifdef _USE_SENIOR_MODE
 632 int media_info_set_contact(media_info_h media, const char *contact)
 633 {
 634         return __media_info_set_str_data(media, MEDIA_INFO_CONTACT, contact);
 635 }
 636
 637 int media_info_set_app_data(media_info_h media, const char *app_data)
 638 {
 639         return __media_info_set_str_data(media, MEDIA_INFO_APP_DATA, app_data);
 640 }
 641
 642 int media_info_insert_to_db_with_contact_data(const char *path, const char* contact, const char* app_data, media_info_h *info)
 643 {
 644         int ret = media_info_insert_to_db(path, info);
 645         media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "media_info_insert_to_db [%s] failed", path);
 646
 647         ret = media_info_set_contact(*info, contact);
 648         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 649                 media_content_error("media_info_set_contact [%s] failed", contact);
 650
 651                 media_info_s* _media_info = (media_info_s*)*info;
 652                 ret = media_info_delete_from_db(_media_info->media_id);
 653                 media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "media_info_delete_from_db [%s] failed", _media_info->media_id);
 654
 655                 media_info_destroy(*info);
 656                 return ret;
 657         }
 658
 659         ret = media_info_set_app_data(*info, app_data);
 660         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 661                 media_content_error("media_info_set_app_data [%s] failed", app_data);
 662
 663                 media_info_s* _media_info = (media_info_s*)*info;
 664                 ret = media_info_delete_from_db(_media_info->media_id);
 665                 media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "media_info_delete_from_db [%s] failed", _media_info->media_id);
 666
 667                 media_info_destroy(*info);
 668                 return ret;
 669         }
 670
 671         ret = media_info_update_to_db(*info);
 672         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 673                 media_content_error("media_info_update_to_db [] failed");
 674
 675                 media_info_s* _media_info = (media_info_s*)*info;
 676                 ret = media_info_delete_from_db(_media_info->media_id);
 677                 media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "media_info_delete_from_db [%s] failed", _media_info->media_id);
 678
 679                 media_info_destroy(*info);
 680                 return ret;
 681         }
 682
 683         return ret;
 684 }
 685
 686 int media_info_delete_contact_from_db(const char* contact, const char* storage_id)
 687 {
 688         return -1;
 689 }
 690
 691 int media_info_delete_item(const char *media_id)
 692 {
 693         int ret = MEDIA_CONTENT_ERROR_NONE;
 694         char *path = NULL;
 695         char storage_id[MEDIA_CONTENT_UUID_SIZE+1] = {0,};
 696
 697         if (!STRING_VALID(media_id)) {
 698                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 699                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 700         }
 701
 702         memset(storage_id, 0x00, sizeof(storage_id));
 703
 704         ret = __media_info_get_media_path_by_id_from_db(media_id, &path);
 705         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 706                 media_content_error("__media_info_get_media_path_by_id_from_db failed : %d", ret);
 707                 SAFE_FREE(path);
 708                 return ret;
 709         }
 710
 711         ret = _media_db_get_storage_id_by_media_id(media_id, storage_id);
 712         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 713                 media_content_error("_media_db_get_storage_id_by_media_id failed : %d", ret);
 714                 SAFE_FREE(path);
 715                 return ret;
 716         }
 717
 718         ret = media_svc_delete_item_by_path(_content_get_db_handle(), storage_id, path, tzplatform_getuid(TZ_USER_NAME));
 719         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 720                 media_content_error("remove from DB failed : %d", ret);
 721                 SAFE_FREE(path);
 722                 return ret;
 723         }
 724
 725         ret = media_svc_remove_file(path);
 726         SAFE_FREE(path);
 727         return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 728 }
 729
 730 #endif
 731
 732 int media_info_delete_from_db(const char *media_id)
 733 {
 734         int ret = MEDIA_CONTENT_ERROR_NONE;
 735         char *path = NULL;
 736         char storage_id[MEDIA_CONTENT_UUID_SIZE+1] = {0, };
 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->played_count = _src->video_meta->played_count;
1338                         _dst->video_meta->played_time = _src->video_meta->played_time;
1339                         _dst->video_meta->played_position = _src->video_meta->played_position;
1340                         _dst->video_meta->rotation = _src->video_meta->rotation;
1341
1342                 } else if ((_src->media_type == MEDIA_CONTENT_TYPE_MUSIC || _src->media_type == MEDIA_CONTENT_TYPE_SOUND) && _src->audio_meta) {
1343                         _dst->audio_meta = (audio_meta_s *)calloc(1, sizeof(audio_meta_s));
1344                         if (_dst->audio_meta == NULL) {
1345                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1346                                 media_info_destroy((media_info_h)_dst);
1347                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1348                         }
1349
1350                         if (_src->audio_meta->media_id != NULL) {
1351                                 _dst->audio_meta->media_id = g_strdup(_src->audio_meta->media_id);
1352                                 if (_dst->audio_meta->media_id == NULL) {
1353                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1354                                         media_info_destroy((media_info_h)_dst);
1355                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1356                                 }
1357                         }
1358                         if (_src->audio_meta->title != NULL) {
1359                                 _dst->audio_meta->title = g_strdup(_src->audio_meta->title);
1360                                 if (_dst->audio_meta->title == NULL) {
1361                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1362                                         media_info_destroy((media_info_h)_dst);
1363                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1364                                 }
1365                         }
1366                         if (_src->audio_meta->album != NULL) {
1367                                 _dst->audio_meta->album = g_strdup(_src->audio_meta->album);
1368                                 if (_dst->audio_meta->album == NULL) {
1369                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1370                                         media_info_destroy((media_info_h)_dst);
1371                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1372                                 }
1373                         }
1374                         if (_src->audio_meta->artist != NULL) {
1375                                 _dst->audio_meta->artist = g_strdup(_src->audio_meta->artist);
1376                                 if (_dst->audio_meta->artist == NULL) {
1377                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1378                                         media_info_destroy((media_info_h)_dst);
1379                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1380                                 }
1381                         }
1382                         if (_src->audio_meta->album_artist != NULL) {
1383                                 _dst->audio_meta->album_artist = g_strdup(_src->audio_meta->album_artist);
1384                                 if (_dst->audio_meta->album_artist == NULL) {
1385                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1386                                         media_info_destroy((media_info_h)_dst);
1387                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1388                                 }
1389                         }
1390                         if (_src->audio_meta->genre != NULL) {
1391                                 _dst->audio_meta->genre = g_strdup(_src->audio_meta->genre);
1392                                 if (_dst->audio_meta->genre == NULL) {
1393                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1394                                         media_info_destroy((media_info_h)_dst);
1395                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1396                                 }
1397                         }
1398                         if (_src->audio_meta->composer != NULL) {
1399                                 _dst->audio_meta->composer = g_strdup(_src->audio_meta->composer);
1400                                 if (_dst->audio_meta->composer == NULL) {
1401                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1402                                         media_info_destroy((media_info_h)_dst);
1403                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1404                                 }
1405                         }
1406                         if (_src->audio_meta->year != NULL) {
1407                                 _dst->audio_meta->year = g_strdup(_src->audio_meta->year);
1408                                 if (_dst->audio_meta->year == NULL) {
1409                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1410                                         media_info_destroy((media_info_h)_dst);
1411                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1412                                 }
1413                         }
1414                         if (_src->audio_meta->recorded_date != NULL) {
1415                                 _dst->audio_meta->recorded_date = g_strdup(_src->audio_meta->recorded_date);
1416                                 if (_dst->audio_meta->recorded_date == NULL) {
1417                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1418                                         media_info_destroy((media_info_h)_dst);
1419                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1420                                 }
1421                         }
1422                         if (_src->audio_meta->copyright != NULL) {
1423                                 _dst->audio_meta->copyright = g_strdup(_src->audio_meta->copyright);
1424                                 if (_dst->audio_meta->copyright == NULL) {
1425                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1426                                         media_info_destroy((media_info_h)_dst);
1427                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1428                                 }
1429                         }
1430                         if (_src->audio_meta->track_num != NULL) {
1431                                 _dst->audio_meta->track_num = g_strdup(_src->audio_meta->track_num);
1432                                 if (_dst->audio_meta->track_num == NULL) {
1433                                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1434                                         media_info_destroy((media_info_h)_dst);
1435                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1436                                 }
1437                         }
1438
1439                         _dst->audio_meta->channel = _src->audio_meta->channel;
1440                         _dst->audio_meta->samplerate = _src->audio_meta->samplerate;
1441                         _dst->audio_meta->duration = _src->audio_meta->duration;
1442                         _dst->audio_meta->bitrate = _src->audio_meta->bitrate;
1443                         _dst->audio_meta->bitpersample = _src->audio_meta->bitpersample;
1444                         _dst->audio_meta->played_count = _src->audio_meta->played_count;
1445                         _dst->audio_meta->played_time = _src->audio_meta->played_time;
1446                         _dst->audio_meta->played_position = _src->audio_meta->played_position;
1447                 }
1448                 *dst = (media_info_h)_dst;
1449
1450                 ret = MEDIA_CONTENT_ERROR_NONE;
1451         } else {
1452                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1453                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1454         }
1455
1456         return ret;
1457 }
1458
1459 int media_info_get_media_count_from_db(filter_h filter, int *media_count)
1460 {
1461         int ret = MEDIA_CONTENT_ERROR_NONE;
1462
1463         if (media_count == NULL) {
1464                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1465                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1466
1467                 return ret;
1468         }
1469
1470         ret = _media_db_get_group_item_count(NULL, filter, MEDIA_GROUP_NONE, media_count);
1471
1472         return ret;
1473 }
1474
1475 int media_info_foreach_media_from_db(filter_h filter, media_info_cb callback, void *user_data)
1476 {
1477         int ret = MEDIA_CONTENT_ERROR_NONE;
1478
1479         media_content_retvm_if(callback == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid callback");
1480
1481         ret = _media_db_get_group_item(NULL, filter, callback, user_data, MEDIA_GROUP_NONE);
1482
1483         return ret;
1484 }
1485
1486 int media_info_get_tag_count_from_db(const char *media_id, filter_h filter, int *tag_count)
1487 {
1488         int ret = MEDIA_CONTENT_ERROR_NONE;
1489
1490         if (STRING_VALID(media_id) && tag_count) {
1491                 ret = _media_db_get_group_item_count(media_id, filter, MEDIA_GROUP_TAG_BY_MEDIA_ID, tag_count);
1492         } else {
1493                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1494                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1495         }
1496
1497         return ret;
1498 }
1499
1500 int media_info_foreach_tag_from_db(const char *media_id, filter_h filter, media_tag_cb callback, void *user_data)
1501 {
1502         int ret = MEDIA_CONTENT_ERROR_NONE;
1503
1504         if ((callback != NULL) && STRING_VALID(media_id)) {
1505                 ret = _media_db_get_tag(media_id, filter, callback, user_data);
1506         } else {
1507                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1508                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1509         }
1510
1511         return ret;
1512 }
1513
1514 int media_info_get_bookmark_count_from_db(const char *media_id, filter_h filter, int *bookmark_count)
1515 {
1516         int ret = MEDIA_CONTENT_ERROR_NONE;
1517
1518         if (STRING_VALID(media_id) && bookmark_count) {
1519                 ret = _media_db_get_group_item_count(media_id, filter, MEDIA_GROUP_BOOKMARK_BY_MEDIA_ID, bookmark_count);
1520         } else {
1521                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1522                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1523         }
1524
1525         return ret;
1526 }
1527
1528 int media_info_foreach_bookmark_from_db(const char *media_id, filter_h filter, media_bookmark_cb callback, void *user_data)
1529 {
1530         int ret = MEDIA_CONTENT_ERROR_NONE;
1531
1532         if ((callback != NULL) && STRING_VALID(media_id)) {
1533                 ret = _media_db_get_bookmark(media_id, filter, callback, user_data);
1534         } else {
1535                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1536                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1537         }
1538
1539         return ret;
1540 }
1541
1542 int media_info_get_face_count_from_db(const char *media_id, filter_h filter, int *face_count)
1543 {
1544         int ret = MEDIA_CONTENT_ERROR_NONE;
1545
1546         if (STRING_VALID(media_id) && face_count) {
1547                 ret = _media_db_get_group_item_count(media_id, filter, MEDIA_GROUP_FACE_BY_MEDIA_ID, face_count);
1548         } else {
1549                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1550                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1551         }
1552
1553         return ret;
1554 }
1555
1556 int media_info_foreach_face_from_db(const char *media_id, filter_h filter, media_face_cb callback, void *user_data)
1557 {
1558         int ret = MEDIA_CONTENT_ERROR_NONE;
1559
1560         if ((callback != NULL) && STRING_VALID(media_id)) {
1561                 ret = _media_db_get_face(media_id, filter, callback, user_data);
1562         } else {
1563                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1564                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1565         }
1566
1567         return ret;
1568 }
1569
1570 int media_info_get_image(media_info_h media, image_meta_h *image)
1571 {
1572         int ret = MEDIA_CONTENT_ERROR_NONE;
1573
1574         media_info_s *_media = (media_info_s*)media;
1575
1576         media_content_retvm_if(_media == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid media");
1577         media_content_retvm_if(_media->media_type != MEDIA_CONTENT_TYPE_IMAGE, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid media_type");
1578         media_content_retvm_if(_media->image_meta == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid image_meta");
1579
1580         image_meta_s *_image = (image_meta_s*)calloc(1, sizeof(image_meta_s));
1581         media_content_retvm_if(_image == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
1582
1583         _image->media_id = g_strdup(_media->media_id);
1584         _image->width = _media->image_meta->width;
1585         _image->height = _media->image_meta->height;
1586         _image->orientation = _media->image_meta->orientation;
1587         _image->fnumber = _media->image_meta->fnumber;
1588         _image->iso = _media->image_meta->iso;
1589         _image->date_taken = g_strdup(_media->image_meta->date_taken);
1590         _image->title = g_strdup(_media->image_meta->title);
1591         _image->burst_id = g_strdup(_media->image_meta->burst_id);
1592         _image->exposure_time = g_strdup(_media->image_meta->exposure_time);
1593         _image->model = g_strdup(_media->image_meta->model);
1594
1595         *image = (image_meta_h)_image;
1596
1597         return ret;
1598 }
1599
1600 int media_info_get_video(media_info_h media, video_meta_h *video)
1601 {
1602         int ret = MEDIA_CONTENT_ERROR_NONE;
1603
1604         media_info_s *_media = (media_info_s*)media;
1605
1606         media_content_retvm_if(_media == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid media");
1607         media_content_retvm_if(_media->media_type != MEDIA_CONTENT_TYPE_VIDEO, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid media_type");
1608         media_content_retvm_if(_media->video_meta == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid video_meta");
1609
1610         video_meta_s *_video = (video_meta_s*)calloc(1, sizeof(video_meta_s));
1611         media_content_retvm_if(_video == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
1612
1613         _video->media_id = g_strdup(_media->media_id);
1614         _video->title = g_strdup(_media->video_meta->title);
1615         _video->album = g_strdup(_media->video_meta->album);
1616         _video->artist = g_strdup(_media->video_meta->artist);
1617         _video->album_artist = g_strdup(_media->video_meta->album_artist);
1618         _video->genre = g_strdup(_media->video_meta->genre);
1619         _video->composer = g_strdup(_media->video_meta->composer);
1620         _video->year = g_strdup(_media->video_meta->year);
1621         _video->recorded_date = g_strdup(_media->video_meta->recorded_date);
1622         _video->copyright = g_strdup(_media->video_meta->copyright);
1623         _video->track_num = g_strdup(_media->video_meta->track_num);
1624
1625         _video->width = _media->video_meta->width;
1626         _video->height = _media->video_meta->height;
1627         _video->duration = _media->video_meta->duration;
1628         _video->bitrate = _media->video_meta->bitrate;
1629         _video->played_count = _media->video_meta->played_count;
1630         _video->played_time = _media->video_meta->played_time;
1631         _video->played_position = _media->video_meta->played_position;
1632         _video->rotation = _media->video_meta->rotation;
1633
1634         *video = (video_meta_h)_video;
1635
1636         return ret;
1637 }
1638
1639 int media_info_get_audio(media_info_h media, audio_meta_h *audio)
1640 {
1641         int ret = MEDIA_CONTENT_ERROR_NONE;
1642
1643         media_info_s *_media = (media_info_s*)media;
1644
1645         media_content_retvm_if(_media == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid media");
1646         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");
1647         media_content_retvm_if(_media->audio_meta == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid audio_meta");
1648
1649         audio_meta_s *_audio = (audio_meta_s*)calloc(1, sizeof(audio_meta_s));
1650         media_content_retvm_if(_audio == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
1651
1652         _audio->media_id = g_strdup(_media->media_id);
1653         _audio->title = g_strdup(_media->audio_meta->title);
1654         _audio->album = g_strdup(_media->audio_meta->album);
1655         _audio->artist = g_strdup(_media->audio_meta->artist);
1656         _audio->album_artist = g_strdup(_media->audio_meta->album_artist);
1657         _audio->genre = g_strdup(_media->audio_meta->genre);
1658         _audio->composer = g_strdup(_media->audio_meta->composer);
1659         _audio->year = g_strdup(_media->audio_meta->year);
1660         _audio->recorded_date = g_strdup(_media->audio_meta->recorded_date);
1661         _audio->copyright = g_strdup(_media->audio_meta->copyright);
1662         _audio->track_num = g_strdup(_media->audio_meta->track_num);
1663
1664         _audio->duration = _media->audio_meta->duration;
1665         _audio->bitrate = _media->audio_meta->bitrate;
1666         _audio->bitpersample = _media->audio_meta->bitpersample;
1667         _audio->samplerate = _media->audio_meta->samplerate;
1668         _audio->channel = _media->audio_meta->channel;
1669         _audio->played_time = _media->audio_meta->played_time;
1670         _audio->played_count = _media->audio_meta->played_count;
1671         _audio->played_position = _media->audio_meta->played_position;
1672
1673         *audio = (audio_meta_h)_audio;
1674
1675         return ret;
1676 }
1677
1678 int media_info_get_media_id(media_info_h media, char **media_id)
1679 {
1680         int ret = MEDIA_CONTENT_ERROR_NONE;
1681         media_info_s *_media = (media_info_s*)media;
1682
1683         if (_media && media_id) {
1684                 if (STRING_VALID(_media->media_id)) {
1685                         *media_id = strdup(_media->media_id);
1686                         media_content_retvm_if(*media_id == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
1687                 } else {
1688                         *media_id = NULL;
1689                 }
1690                 ret = MEDIA_CONTENT_ERROR_NONE;
1691         } else {
1692                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1693                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1694         }
1695
1696         return ret;
1697 }
1698
1699 int media_info_get_file_path(media_info_h media, char **path)
1700 {
1701         int ret = MEDIA_CONTENT_ERROR_NONE;
1702         media_info_s *_media = (media_info_s*)media;
1703
1704         if (_media && path) {
1705                 if (STRING_VALID(_media->file_path)) {
1706                         *path = strdup(_media->file_path);
1707                         media_content_retvm_if(*path == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
1708                 } else {
1709                         *path = NULL;
1710                 }
1711                 ret = MEDIA_CONTENT_ERROR_NONE;
1712
1713         } else {
1714                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1715                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1716         }
1717
1718         return ret;
1719 }
1720
1721 int media_info_get_display_name(media_info_h media, char **name)
1722 {
1723         int ret = MEDIA_CONTENT_ERROR_NONE;
1724         media_info_s *_media = (media_info_s*)media;
1725         if (_media && name) {
1726                 if (_media->display_name != NULL) {
1727                         *name = g_strdup(_media->display_name);
1728                         media_content_retvm_if(*name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
1729                 } else {
1730                         *name = NULL;
1731                 }
1732                 ret = MEDIA_CONTENT_ERROR_NONE;
1733
1734         } else {
1735                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1736                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1737         }
1738
1739         return ret;
1740 }
1741
1742 int media_info_get_media_type(media_info_h media, media_content_type_e *type)
1743 {
1744         int ret = MEDIA_CONTENT_ERROR_NONE;
1745         media_info_s *_media = (media_info_s*)media;
1746         if (_media && type) {
1747                 *type = _media->media_type;
1748                 ret = MEDIA_CONTENT_ERROR_NONE;
1749         } else {
1750                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1751                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1752         }
1753
1754         return ret;
1755 }
1756
1757 int media_info_get_mime_type(media_info_h media, char **mime_type)
1758 {
1759         int ret = MEDIA_CONTENT_ERROR_NONE;
1760         media_info_s *_media = (media_info_s*)media;
1761
1762         if (_media && mime_type) {
1763                 if (STRING_VALID(_media->mime_type)) {
1764                         *mime_type = strdup(_media->mime_type);
1765                         media_content_retvm_if(*mime_type == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
1766                 } else {
1767                         *mime_type = NULL;
1768                 }
1769                 ret = MEDIA_CONTENT_ERROR_NONE;
1770         } else {
1771                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1772                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1773         }
1774
1775         return ret;
1776 }
1777
1778 int media_info_get_size(media_info_h media, unsigned long long *size)
1779 {
1780         int ret = MEDIA_CONTENT_ERROR_NONE;
1781         media_info_s *_media = (media_info_s*)media;
1782
1783         if (_media && size) {
1784                 *size = _media->size;
1785                 ret = MEDIA_CONTENT_ERROR_NONE;
1786         } else {
1787                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1788                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1789         }
1790
1791         return ret;
1792 }
1793
1794 int media_info_get_added_time(media_info_h media, time_t *added_time)
1795 {
1796         int ret = MEDIA_CONTENT_ERROR_NONE;
1797         media_info_s *_media = (media_info_s*)media;
1798         if (_media && added_time) {
1799                 *added_time = _media->added_time;
1800                 ret = MEDIA_CONTENT_ERROR_NONE;
1801         } else {
1802                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1803                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1804         }
1805
1806         return ret;
1807 }
1808
1809 int media_info_get_modified_time(media_info_h media, time_t* time)
1810 {
1811         int ret = MEDIA_CONTENT_ERROR_NONE;
1812         media_info_s *_media = (media_info_s*)media;
1813         if (_media && time) {
1814                 *time = _media->modified_time;
1815                 ret = MEDIA_CONTENT_ERROR_NONE;
1816         } else {
1817                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1818                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1819         }
1820
1821         return ret;
1822 }
1823
1824 int media_info_get_timeline(media_info_h media, time_t* time)
1825 {
1826         int ret = MEDIA_CONTENT_ERROR_NONE;
1827         media_info_s *_media = (media_info_s*)media;
1828         if (_media && time) {
1829                 *time = _media->timeline;
1830                 ret = MEDIA_CONTENT_ERROR_NONE;
1831         } else {
1832                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1833                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1834         }
1835
1836         return ret;
1837 }
1838
1839 int media_info_get_thumbnail_path(media_info_h media, char **path)
1840 {
1841         int ret = MEDIA_CONTENT_ERROR_NONE;
1842         media_info_s *_media = (media_info_s*)media;
1843         if (_media && path) {
1844                 if (_media->thumbnail_path != NULL) {
1845                         *path = g_strdup(_media->thumbnail_path);
1846                         media_content_retvm_if(*path == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
1847                 } else {
1848                         *path = NULL;
1849                 }
1850                 ret = MEDIA_CONTENT_ERROR_NONE;
1851
1852         } else {
1853                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1854                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1855         }
1856
1857         return ret;
1858 }
1859
1860 int media_info_get_title(media_info_h media, char **title)
1861 {
1862         int ret = MEDIA_CONTENT_ERROR_NONE;
1863         media_info_s *_media = (media_info_s*)media;
1864
1865         if (_media && title)    { /*title can be empty string*/
1866                 if (_media->title != NULL) {
1867                         *title = g_strdup(_media->title);
1868                         media_content_retvm_if(*title == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
1869                 } else {
1870                         *title = NULL;
1871                 }
1872                 ret = MEDIA_CONTENT_ERROR_NONE;
1873         } else {
1874                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1875                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1876         }
1877
1878         return ret;
1879 }
1880 #ifdef _USE_TVPD_MODE
1881 int media_info_get_extract_flag(media_info_h media, int *extract_flag)
1882 {
1883         int ret = MEDIA_CONTENT_ERROR_NONE;
1884         media_info_s *_media = (media_info_s *)media;
1885
1886         if (_media && extract_flag) {
1887                 *extract_flag = _media->extract_flag;
1888                 ret = MEDIA_CONTENT_ERROR_NONE;
1889         } else {
1890                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1891                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1892         }
1893
1894         return ret;
1895 }
1896 #endif
1897
1898 int media_info_get_description(media_info_h media, char **description)
1899 {
1900         int ret = MEDIA_CONTENT_ERROR_NONE;
1901         media_info_s *_media = (media_info_s*)media;
1902
1903         if (_media && description) {
1904                 if (_media->description != NULL) {      /*description can be empty string*/
1905                         *description = g_strdup(_media->description);
1906                         media_content_retvm_if(*description == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
1907                 } else {
1908                         *description = NULL;
1909                 }
1910                 ret = MEDIA_CONTENT_ERROR_NONE;
1911         } else {
1912                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1913                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1914         }
1915
1916         return ret;
1917 }
1918
1919 int media_info_get_longitude(media_info_h media, double* longitude)
1920 {
1921         int ret = MEDIA_CONTENT_ERROR_NONE;
1922         media_info_s *_media = (media_info_s*)media;
1923
1924         if (_media && longitude) {
1925                 *longitude = _media->longitude;
1926                 ret = MEDIA_CONTENT_ERROR_NONE;
1927         } else {
1928                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1929                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1930         }
1931
1932         return ret;
1933 }
1934 int media_info_get_latitude(media_info_h media, double* latitude)
1935 {
1936         int ret = MEDIA_CONTENT_ERROR_NONE;
1937         media_info_s *_media = (media_info_s*)media;
1938
1939         if (_media && latitude) {
1940                 *latitude = _media->latitude;
1941                 ret = MEDIA_CONTENT_ERROR_NONE;
1942         } else {
1943                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1944                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1945         }
1946
1947         return ret;
1948 }
1949
1950 int media_info_get_altitude(media_info_h media, double *altitude)
1951 {
1952         int ret = MEDIA_CONTENT_ERROR_NONE;
1953         media_info_s *_media = (media_info_s*)media;
1954
1955         if (_media && altitude) {
1956                 *altitude = _media->altitude;
1957                 ret = MEDIA_CONTENT_ERROR_NONE;
1958         } else {
1959                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1960                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1961         }
1962
1963         return ret;
1964 }
1965
1966 int media_info_get_weather(media_info_h media, char **weather)
1967 {
1968         int ret = MEDIA_CONTENT_ERROR_NONE;
1969         media_content_warn("DEPRECATION WARNING: media_info_get_weather() is deprecated and will be removed from next release.");
1970         media_info_s *_media = (media_info_s*)media;
1971
1972         if (_media && weather) {
1973                 if (_media->weather != NULL) {
1974                         *weather = strdup(_media->weather);
1975                         media_content_retvm_if(*weather == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
1976                 } else {
1977                         *weather = NULL;
1978                 }
1979                 ret = MEDIA_CONTENT_ERROR_NONE;
1980         } else {
1981                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1982                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1983         }
1984
1985         return ret;
1986 }
1987
1988 int media_info_get_rating(media_info_h media, int *rating)
1989 {
1990         int ret = MEDIA_CONTENT_ERROR_NONE;
1991         media_info_s *_media = (media_info_s*)media;
1992
1993         if (_media && rating) {
1994                 *rating = _media->rating;
1995                 ret = MEDIA_CONTENT_ERROR_NONE;
1996         } else {
1997                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1998                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1999         }
2000
2001         return ret;
2002 }
2003
2004 int media_info_get_favorite(media_info_h media, bool* favorite)
2005 {
2006         int ret = MEDIA_CONTENT_ERROR_NONE;
2007         media_info_s *_media = (media_info_s*)media;
2008
2009         if (_media && favorite) {
2010                 *favorite = _media->favourite;
2011                 ret = MEDIA_CONTENT_ERROR_NONE;
2012         } else {
2013                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2014                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2015         }
2016
2017         return ret;
2018 }
2019
2020 int media_info_get_author(media_info_h media, char **author)
2021 {
2022         int ret = MEDIA_CONTENT_ERROR_NONE;
2023         media_content_warn("DEPRECATION WARNING: media_info_get_author() is deprecated and will be removed from next release.");
2024         media_info_s *_media = (media_info_s*)media;
2025
2026         if (_media && author) {
2027                 if (_media->author != NULL) {
2028                         *author = strdup(_media->author);
2029                         media_content_retvm_if(*author == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
2030                 } else {
2031                         *author = NULL;
2032                 }
2033                 ret = MEDIA_CONTENT_ERROR_NONE;
2034         } else {
2035                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2036                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2037         }
2038
2039         return ret;
2040 }
2041
2042 int media_info_get_provider(media_info_h media, char **provider)
2043 {
2044         int ret = MEDIA_CONTENT_ERROR_NONE;
2045         media_content_warn("DEPRECATION WARNING: media_info_get_provider() is deprecated and will be removed from next release.");
2046         media_info_s *_media = (media_info_s*)media;
2047
2048         if (_media && provider) {
2049                 if (_media->provider != NULL) {
2050                         *provider = strdup(_media->provider);
2051                         media_content_retvm_if(*provider == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
2052                 } else {
2053                         *provider = NULL;
2054                 }
2055                 ret = MEDIA_CONTENT_ERROR_NONE;
2056         } else {
2057                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2058                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2059         }
2060
2061         return ret;
2062 }
2063
2064 int media_info_get_content_name(media_info_h media, char **content_name)
2065 {
2066         int ret = MEDIA_CONTENT_ERROR_NONE;
2067         media_content_warn("DEPRECATION WARNING: media_info_get_content_name() is deprecated and will be removed from next release.");
2068         media_info_s *_media = (media_info_s*)media;
2069
2070         if (_media && content_name) {
2071                 if (_media->content_name != NULL) {
2072                         *content_name = strdup(_media->content_name);
2073                         media_content_retvm_if(*content_name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
2074                 } else {
2075                         *content_name = NULL;
2076                 }
2077                 ret = MEDIA_CONTENT_ERROR_NONE;
2078         } else {
2079                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2080                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2081         }
2082
2083         return ret;
2084 }
2085
2086 int media_info_get_category(media_info_h media, char **category)
2087 {
2088         int ret = MEDIA_CONTENT_ERROR_NONE;
2089         media_content_warn("DEPRECATION WARNING: media_info_get_category() is deprecated and will be removed from next release.");
2090         media_info_s *_media = (media_info_s*)media;
2091
2092         if (_media && category) {
2093                 if (_media->category != NULL) {
2094                         *category = strdup(_media->category);
2095                         media_content_retvm_if(*category == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
2096                 } else {
2097                         *category = NULL;
2098                 }
2099                 ret = MEDIA_CONTENT_ERROR_NONE;
2100         } else {
2101                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2102                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2103         }
2104
2105         return ret;
2106 }
2107
2108 int media_info_get_location_tag(media_info_h media, char **location_tag)
2109 {
2110         int ret = MEDIA_CONTENT_ERROR_NONE;
2111         media_content_warn("DEPRECATION WARNING: media_info_get_location_tag() is deprecated and will be removed from next release.");
2112         media_info_s *_media = (media_info_s*)media;
2113
2114         if (_media && location_tag) {
2115                 if (_media->location_tag != NULL) {
2116                         *location_tag = strdup(_media->location_tag);
2117                         media_content_retvm_if(*location_tag == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
2118                 } else {
2119                         *location_tag = NULL;
2120                 }
2121                 ret = MEDIA_CONTENT_ERROR_NONE;
2122         } else {
2123                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2124                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2125         }
2126
2127         return ret;
2128 }
2129
2130 int media_info_get_age_rating(media_info_h media, char **age_rating)
2131 {
2132         int ret = MEDIA_CONTENT_ERROR_NONE;
2133         media_content_warn("DEPRECATION WARNING: media_info_get_age_rating() is deprecated and will be removed from next release.");
2134         media_info_s *_media = (media_info_s*)media;
2135
2136         if (_media && age_rating) {
2137                 if (_media->age_rating != NULL) {
2138                         *age_rating = strdup(_media->age_rating);
2139                         media_content_retvm_if(*age_rating == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
2140                 } else {
2141                         *age_rating = NULL;
2142                 }
2143                 ret = MEDIA_CONTENT_ERROR_NONE;
2144         } else {
2145                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2146                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2147         }
2148
2149         return ret;
2150 }
2151
2152 int media_info_get_keyword(media_info_h media, char **keyword)
2153 {
2154         int ret = MEDIA_CONTENT_ERROR_NONE;
2155         media_content_warn("DEPRECATION WARNING: media_info_get_keyword() is deprecated and will be removed from next release.");
2156         media_info_s *_media = (media_info_s*)media;
2157
2158         if (_media && keyword) {
2159                 if (_media->keyword != NULL) {
2160                         *keyword = strdup(_media->keyword);
2161                         media_content_retvm_if(*keyword == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
2162                 } else {
2163                         *keyword = NULL;
2164                 }
2165                 ret = MEDIA_CONTENT_ERROR_NONE;
2166         } else {
2167                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2168                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2169         }
2170
2171         return ret;
2172 }
2173
2174 int media_info_get_storage_id(media_info_h media, char **storage_id)
2175 {
2176         int ret = MEDIA_CONTENT_ERROR_NONE;
2177         media_info_s *_media = (media_info_s*)media;
2178
2179         if (_media && storage_id) {
2180                 if (STRING_VALID(_media->storage_uuid)) {
2181                         *storage_id = strdup(_media->storage_uuid);
2182                         media_content_retvm_if(*storage_id == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
2183                 } else {
2184                         *storage_id = NULL;
2185                         ret = MEDIA_CONTENT_ERROR_DB_FAILED;
2186                 }
2187                 ret = MEDIA_CONTENT_ERROR_NONE;
2188         } else {
2189                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2190                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2191         }
2192
2193         return ret;
2194 }
2195
2196 int media_info_is_drm(media_info_h media, bool *is_drm)
2197 {
2198         int ret = MEDIA_CONTENT_ERROR_NONE;
2199         media_info_s *_media = (media_info_s*)media;
2200
2201         if (_media) {
2202                 *is_drm = _media->is_drm;
2203                 ret = MEDIA_CONTENT_ERROR_NONE;
2204         } else {
2205                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2206                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2207         }
2208
2209         return ret;
2210 }
2211
2212 int media_info_is_360_content(media_info_h media, bool *is_360)
2213 {
2214         int ret = MEDIA_CONTENT_ERROR_NONE;
2215         media_info_s *_media = (media_info_s*)media;
2216
2217         if (_media) {
2218                 *is_360 = _media->is_360;
2219                 ret = MEDIA_CONTENT_ERROR_NONE;
2220         } else {
2221                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2222                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2223         }
2224
2225         return ret;
2226 }
2227
2228 #ifdef _USE_TVPD_MODE
2229 int media_info_get_stitched_state(media_info_h media, int *stitched_info)
2230 {
2231         int ret = MEDIA_CONTENT_ERROR_NONE;
2232         media_info_s *_media = (media_info_s*)media;
2233
2234         if (_media) {
2235                 *stitched_info = (_media->stitched_info & 0xFFFF0000) >> 16;
2236                 ret = MEDIA_CONTENT_ERROR_NONE;
2237         } else {
2238                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2239                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2240         }
2241
2242         return ret;
2243 }
2244
2245 int media_info_get_stitched_engine(media_info_h media, int *stitched_info)
2246 {
2247         int ret = MEDIA_CONTENT_ERROR_NONE;
2248         media_info_s *_media = (media_info_s*)media;
2249
2250         if (_media) {
2251                 *stitched_info = _media->stitched_info & 0x0000FFFF;
2252                 ret = MEDIA_CONTENT_ERROR_NONE;
2253         } else {
2254                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2255                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2256         }
2257
2258         return ret;
2259 }
2260 #endif
2261
2262 int media_info_get_storage_type(media_info_h media, media_content_storage_e *storage_type)
2263 {
2264         int ret = MEDIA_CONTENT_ERROR_NONE;
2265         media_info_s *_media = (media_info_s*)media;
2266
2267         if (_media && storage_type) {
2268                 *storage_type = _media->storage_type;
2269                 ret = MEDIA_CONTENT_ERROR_NONE;
2270         } else {
2271                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2272                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2273         }
2274
2275         return ret;
2276 }
2277
2278 #ifdef _USE_TVPD_MODE
2279 int media_info_get_played_position(media_info_h media, int *played_position)
2280 {
2281         int ret = MEDIA_CONTENT_ERROR_NONE;
2282         media_info_s *_media = (media_info_s*)media;
2283
2284         if (_media) {
2285                 *played_position = _media->played_position;
2286                 ret = MEDIA_CONTENT_ERROR_NONE;
2287         } else {
2288                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2289                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2290         }
2291
2292         return ret;
2293 }
2294 #endif
2295
2296 int media_info_get_played_count(media_info_h media, int *played_count)
2297 {
2298         int ret = MEDIA_CONTENT_ERROR_NONE;
2299         media_content_warn("DEPRECATION WARNING: media_info_get_played_count() is deprecated and will be removed from next release.");
2300         media_info_s *_media = (media_info_s*)media;
2301
2302         if (_media) {
2303                 *played_count = _media->played_count;
2304                 ret = MEDIA_CONTENT_ERROR_NONE;
2305         } else {
2306                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2307                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2308         }
2309
2310         return ret;
2311 }
2312
2313 int media_info_get_played_time(media_info_h media, time_t* played_time)
2314 {
2315         int ret = MEDIA_CONTENT_ERROR_NONE;
2316         media_content_warn("DEPRECATION WARNING: media_info_get_played_time() is deprecated and will be removed from next release.");
2317         media_info_s *_media = (media_info_s*)media;
2318
2319         if (_media) {
2320                 *played_time = _media->played_time;
2321                 ret = MEDIA_CONTENT_ERROR_NONE;
2322         } else {
2323                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2324                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2325         }
2326
2327         return ret;
2328 }
2329
2330 int media_info_increase_played_count(media_info_h media)
2331 {
2332         int ret = MEDIA_CONTENT_ERROR_NONE;
2333         media_content_warn("DEPRECATION WARNING: media_info_increase_played_count() is deprecated and will be removed from next release.");
2334
2335         media_info_s *_media = (media_info_s*)media;
2336
2337         if (_media) {
2338                 _media->played_count += 1;
2339         } else {
2340                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2341                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2342         }
2343
2344         return ret;
2345 }
2346
2347 #ifdef _USE_TVPD_MODE
2348 int media_info_get_modified_month(media_info_h media, char **modified_month)
2349 {
2350         int ret = MEDIA_CONTENT_ERROR_NONE;
2351         media_info_s *_media = (media_info_s*)media;
2352
2353         if (_media && modified_month) {
2354                 if (STRING_VALID(_media->modified_month)) {
2355                         *modified_month = strdup(_media->modified_month);
2356                         if (*modified_month == NULL) {
2357                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
2358                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
2359                         }
2360                 } else {
2361                         *modified_month = NULL;
2362                 }
2363                 ret = MEDIA_CONTENT_ERROR_NONE;
2364         } else {
2365                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2366                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2367         }
2368
2369         return ret;
2370 }
2371 #endif
2372 #ifdef _USE_SENIOR_MODE
2373 int media_info_get_contact(media_info_h media, char **contact)
2374 {
2375         int ret = MEDIA_CONTENT_ERROR_NONE;
2376         media_info_s *_media = (media_info_s*)media;
2377
2378         if (_media && contact) {
2379                 if (STRING_VALID(_media->contact)) {
2380                         *contact = strdup(_media->contact);
2381                         if (*contact == NULL) {
2382                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
2383                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
2384                         }
2385                 } else {
2386                         *contact = NULL;
2387                 }
2388                 ret = MEDIA_CONTENT_ERROR_NONE;
2389         } else {
2390                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2391                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2392         }
2393
2394         return ret;
2395 }
2396
2397 int media_info_get_app_data(media_info_h media, char **app_data)
2398 {
2399         int ret = MEDIA_CONTENT_ERROR_NONE;
2400         media_info_s *_media = (media_info_s*)media;
2401
2402         if (_media && app_data) {
2403                 if (STRING_VALID(_media->app_data)) {
2404                         *app_data = strdup(_media->app_data);
2405                         if (*app_data == NULL) {
2406                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
2407                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
2408                         }
2409                 } else {
2410                         *app_data = NULL;
2411                 }
2412                 ret = MEDIA_CONTENT_ERROR_NONE;
2413         } else {
2414                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2415                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2416         }
2417
2418         return ret;
2419 }
2420 #endif
2421 #ifdef _USE_TVPD_MODE
2422 int media_info_set_played_count(media_info_h media, int played_count)
2423 {
2424         int ret = MEDIA_CONTENT_ERROR_NONE;
2425
2426         media_info_s *_media = (media_info_s*)media;
2427
2428         if (_media) {
2429                 _media->played_count = played_count;
2430         } else {
2431                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2432                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2433         }
2434
2435         return ret;
2436 }
2437 #endif
2438
2439 int media_info_set_played_time(media_info_h media)
2440 {
2441         int ret = MEDIA_CONTENT_ERROR_NONE;
2442         media_content_warn("DEPRECATION WARNING: media_info_set_played_time() is deprecated and will be removed from next release.");
2443         time_t current_time;
2444
2445         media_info_s *_media = (media_info_s*)media;
2446
2447         if (_media != NULL) {
2448                 time(&current_time);
2449                 _media->played_time = current_time;
2450         } else {
2451                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2452                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2453         }
2454
2455         return ret;
2456 }
2457 #ifdef _USE_TVPD_MODE
2458 int media_info_set_played_position(media_info_h media, int played_position)
2459 {
2460         int ret = MEDIA_CONTENT_ERROR_NONE;
2461         media_info_s *_media = (media_info_s*)media;
2462
2463         if ((_media != NULL) && (played_position >= 0)) {
2464                 _media->played_position = played_position;
2465         } else {
2466                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2467                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2468         }
2469
2470         return ret;
2471 }
2472 #endif
2473
2474 int media_info_get_media_from_db(const char *media_id, media_info_h *media)
2475 {
2476         int ret = MEDIA_CONTENT_ERROR_NONE;
2477         char select_query[DEFAULT_QUERY_SIZE] = {0, };
2478         char storage_id[MEDIA_CONTENT_UUID_SIZE+1] = {0, };
2479         sqlite3_stmt *stmt = NULL;
2480
2481         if (!STRING_VALID(media_id) || (media == NULL)) {
2482                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2483                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2484         }
2485
2486         memset(select_query, 0x00, sizeof(select_query));
2487         memset(storage_id, 0x00, sizeof(storage_id));
2488
2489         ret = _media_db_get_storage_id_by_media_id(media_id, storage_id);
2490         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
2491
2492         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_MEDIA, storage_id, media_id);
2493
2494         ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
2495         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
2496
2497         media_info_s *_media = NULL;
2498
2499         while (sqlite3_step(stmt) == SQLITE_ROW) {
2500                 if (_media)
2501                         media_info_destroy((media_info_h)_media);
2502
2503                 _media = (media_info_s*)calloc(1, sizeof(media_info_s));
2504
2505                 if (_media == NULL) {
2506                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
2507                         SQLITE3_FINALIZE(stmt);
2508                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
2509                 }
2510
2511                 _media_info_item_get_detail(stmt, (media_info_h)_media);
2512
2513                 *media = (media_info_h)_media;
2514         }
2515
2516         SQLITE3_FINALIZE(stmt);
2517
2518         return ret;
2519 }
2520
2521 int media_info_set_display_name(media_info_h media, const char *display_name)
2522 {
2523         int ret = MEDIA_CONTENT_ERROR_NONE;
2524         media_content_warn("DEPRECATION WARNING: media_info_set_display_name() is deprecated and will be removed from next release.");
2525         media_info_s *_media = (media_info_s*)media;
2526
2527         if (_media != NULL && STRING_VALID(display_name)) {
2528                 SAFE_FREE(_media->display_name);
2529
2530                 _media->display_name = strdup(display_name);
2531                 media_content_retvm_if(_media->display_name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
2532         } else {
2533                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2534                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2535         }
2536
2537         return ret;
2538 }
2539
2540 int media_info_set_description(media_info_h media, const char *description)
2541 {
2542         int ret = MEDIA_CONTENT_ERROR_NONE;
2543         media_content_warn("DEPRECATION WARNING: media_info_set_description() is deprecated and will be removed from next release.");
2544         media_info_s *_media = (media_info_s*)media;
2545
2546         if (_media != NULL) {
2547                 SAFE_FREE(_media->description);
2548
2549                 if (STRING_VALID(description)) {
2550                         _media->description = strdup(description);
2551                         media_content_retvm_if(_media->description == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
2552                 } else {
2553                         _media->description = NULL;
2554                 }
2555         } else {
2556                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2557                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2558         }
2559
2560         return ret;
2561 }
2562
2563 int media_info_set_longitude(media_info_h media, double longitude)
2564 {
2565         int ret = MEDIA_CONTENT_ERROR_NONE;
2566         media_content_warn("DEPRECATION WARNING: media_info_set_longitude() is deprecated and will be removed from next release.");
2567         media_info_s *_media = (media_info_s*)media;
2568
2569         if (_media != NULL) {
2570                 _media->longitude = longitude;
2571         } else {
2572                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2573                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2574         }
2575
2576         return ret;
2577 }
2578
2579 int media_info_set_latitude(media_info_h media, double latitude)
2580 {
2581         int ret = MEDIA_CONTENT_ERROR_NONE;
2582         media_content_warn("DEPRECATION WARNING: media_info_set_latitude() is deprecated and will be removed from next release.");
2583         media_info_s *_media = (media_info_s*)media;
2584
2585         if (_media != NULL) {
2586                 _media->latitude = latitude;
2587         } else {
2588                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2589                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2590         }
2591
2592         return ret;
2593 }
2594
2595 int media_info_set_altitude(media_info_h media, double altitude)
2596 {
2597         int ret = MEDIA_CONTENT_ERROR_NONE;
2598         media_content_warn("DEPRECATION WARNING: media_info_set_altitude() is deprecated and will be removed from next release.");
2599         media_info_s *_media = (media_info_s*)media;
2600
2601         if (_media != NULL) {
2602                 _media->altitude = altitude;
2603         } else {
2604                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2605                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2606         }
2607
2608         return ret;
2609 }
2610
2611 int media_info_set_weather(media_info_h media, const char *weather)
2612 {
2613         int ret = MEDIA_CONTENT_ERROR_NONE;
2614         media_content_warn("DEPRECATION WARNING: media_info_set_weather() is deprecated and will be removed from next release.");
2615         media_info_s *_media = (media_info_s*)media;
2616
2617         if (_media != NULL) {
2618                 SAFE_FREE(_media->weather);
2619
2620                 if (STRING_VALID(weather)) {
2621                         _media->weather = strdup(weather);
2622                         media_content_retvm_if(_media->weather == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
2623                 } else {
2624                         _media->weather = NULL;
2625                 }
2626         } else {
2627                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2628                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2629         }
2630
2631         return ret;
2632 }
2633
2634 int media_info_set_rating(media_info_h media, int rating)
2635 {
2636         int ret = MEDIA_CONTENT_ERROR_NONE;
2637         media_content_warn("DEPRECATION WARNING: media_info_set_rating() is deprecated and will be removed from next release.");
2638         media_info_s *_media = (media_info_s*)media;
2639
2640         if (_media != NULL) {
2641                 _media->rating = rating;
2642         } else {
2643                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2644                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2645         }
2646
2647         return ret;
2648 }
2649
2650 int media_info_set_added_time(media_info_h media, time_t added_time)
2651 {
2652         int ret = MEDIA_CONTENT_ERROR_NONE;
2653         media_content_warn("DEPRECATION WARNING: media_info_set_added_time() is deprecated and will be removed from next release.");
2654
2655         media_info_s *_media = (media_info_s*)media;
2656
2657         if ((_media != NULL) && (added_time >= 0)) {
2658                 _media->added_time = added_time;
2659         } else {
2660                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2661                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2662         }
2663
2664         return ret;
2665 }
2666
2667 int media_info_set_favorite(media_info_h media, bool favorite)
2668 {
2669         int ret = MEDIA_CONTENT_ERROR_NONE;
2670         media_info_s *_media = (media_info_s*)media;
2671
2672         if (_media != NULL) {
2673                 if (favorite == TRUE)
2674                         time(&_media->favourite);
2675                 else
2676                         _media->favourite = 0;
2677         } else {
2678                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2679                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2680         }
2681
2682         return ret;
2683 }
2684
2685 int media_info_set_author(media_info_h media, const char *author)
2686 {
2687         int ret = MEDIA_CONTENT_ERROR_NONE;
2688         media_content_warn("DEPRECATION WARNING: media_info_set_author() is deprecated and will be removed from next release.");
2689         media_info_s *_media = (media_info_s*)media;
2690
2691         if (_media != NULL) {
2692                 if (STRING_VALID(author)) {
2693                         _media->author = strdup(author);
2694                         media_content_retvm_if(_media->author == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
2695                 } else {
2696                         _media->author = NULL;
2697                 }
2698         } else {
2699                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2700                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2701         }
2702
2703         return ret;
2704 }
2705
2706 int media_info_set_provider(media_info_h media, const char *provider)
2707 {
2708         int ret = MEDIA_CONTENT_ERROR_NONE;
2709         media_content_warn("DEPRECATION WARNING: media_info_set_provider() is deprecated and will be removed from next release.");
2710         media_info_s *_media = (media_info_s*)media;
2711
2712         if (_media != NULL) {
2713                 SAFE_FREE(_media->provider);
2714
2715                 if (STRING_VALID(provider)) {
2716                         _media->provider = strdup(provider);
2717                         media_content_retvm_if(_media->provider == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
2718                 } else {
2719                         _media->provider = NULL;
2720                 }
2721         } else {
2722                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2723                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2724         }
2725
2726         return ret;
2727 }
2728
2729 int media_info_set_content_name(media_info_h media, const char *content_name)
2730 {
2731         int ret = MEDIA_CONTENT_ERROR_NONE;
2732         media_content_warn("DEPRECATION WARNING: media_info_set_content_name() is deprecated and will be removed from next release.");
2733         media_info_s *_media = (media_info_s*)media;
2734
2735         if (_media != NULL) {
2736                 SAFE_FREE(_media->content_name);
2737
2738                 if (STRING_VALID(content_name)) {
2739                         _media->content_name = strdup(content_name);
2740                         media_content_retvm_if(_media->content_name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
2741                 } else {
2742                         _media->content_name = NULL;
2743                 }
2744         } else {
2745                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2746                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2747         }
2748
2749         return ret;
2750 }
2751
2752 int media_info_set_category(media_info_h media, const char *category)
2753 {
2754         int ret = MEDIA_CONTENT_ERROR_NONE;
2755         media_content_warn("DEPRECATION WARNING: media_info_set_category() is deprecated and will be removed from next release.");
2756         media_info_s *_media = (media_info_s*)media;
2757
2758         if (_media != NULL) {
2759                 SAFE_FREE(_media->category);
2760
2761                 if (STRING_VALID(category)) {
2762                         _media->category = strdup(category);
2763                         media_content_retvm_if(_media->category == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
2764                 } else {
2765                         _media->category = NULL;
2766                 }
2767         } else {
2768                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2769                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2770         }
2771
2772         return ret;
2773 }
2774
2775 int media_info_set_location_tag(media_info_h media, const char *location_tag)
2776 {
2777         int ret = MEDIA_CONTENT_ERROR_NONE;
2778         media_content_warn("DEPRECATION WARNING: media_info_set_location_tag() is deprecated and will be removed from next release.");
2779         media_info_s *_media = (media_info_s*)media;
2780
2781         if (_media != NULL) {
2782                 SAFE_FREE(_media->location_tag);
2783
2784                 if (STRING_VALID(location_tag)) {
2785                         _media->location_tag = strdup(location_tag);
2786                         media_content_retvm_if(_media->location_tag == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
2787                 } else {
2788                         _media->location_tag = NULL;
2789                 }
2790         } else {
2791                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2792                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2793         }
2794
2795         return ret;
2796 }
2797
2798 int media_info_set_age_rating(media_info_h media, const char *age_rating)
2799 {
2800         int ret = MEDIA_CONTENT_ERROR_NONE;
2801         media_content_warn("DEPRECATION WARNING: media_info_set_age_rating() is deprecated and will be removed from next release.");
2802         media_info_s *_media = (media_info_s*)media;
2803
2804         if (_media != NULL) {
2805                 SAFE_FREE(_media->age_rating);
2806
2807                 if (STRING_VALID(age_rating)) {
2808                         _media->age_rating = strdup(age_rating);
2809                         media_content_retvm_if(_media->age_rating == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
2810                 } else {
2811                         _media->age_rating = NULL;
2812                 }
2813         } else {
2814                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2815                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2816         }
2817
2818         return ret;
2819 }
2820
2821 int media_info_set_keyword(media_info_h media, const char *keyword)
2822 {
2823         int ret = MEDIA_CONTENT_ERROR_NONE;
2824         media_content_warn("DEPRECATION WARNING: media_info_set_keyword() is deprecated and will be removed from next release.");
2825         media_info_s *_media = (media_info_s*)media;
2826
2827         if (_media != NULL) {
2828                 SAFE_FREE(_media->keyword);
2829
2830                 if (STRING_VALID(keyword)) {
2831                         _media->keyword = strdup(keyword);
2832                         media_content_retvm_if(_media->keyword == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
2833                 } else {
2834                         _media->keyword = NULL;
2835                 }
2836         } else {
2837                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2838                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2839         }
2840
2841         return ret;
2842 }
2843
2844 int media_info_update_to_db(media_info_h media)
2845 {
2846         int ret = MEDIA_CONTENT_ERROR_NONE;
2847         media_info_s *_media = (media_info_s*)media;
2848         char *set_sql = NULL;
2849         char *sql = NULL;
2850
2851         if (_media != NULL && STRING_VALID(_media->media_id)) {
2852                 /* This sql is due to sqlite3_mprintf's wrong operation when using floating point in the text format */
2853                 /* This code will be removed when sqlite3_mprintf works clearly */
2854                 char *test_sql = sqlite3_mprintf("%f, %f, %f", _media->longitude, _media->latitude, _media->altitude);
2855                 SQLITE3_SAFE_FREE(test_sql);
2856
2857                 /*Update Pinyin If Support Pinyin*/
2858                 char *file_name_pinyin = NULL;
2859                 char *description_pinyin = NULL;
2860                 char *author_pinyin = NULL;
2861                 char *provider_pinyin = NULL;
2862                 char *content_name_pinyin = NULL;
2863                 char *category_pinyin = NULL;
2864                 char *location_tag_pinyin = NULL;
2865                 char *age_rating_pinyin = NULL;
2866                 char *keyword_pinyin = NULL;
2867                 bool pinyin_support = FALSE;
2868
2869                 /*Update Pinyin If Support Pinyin*/
2870                 media_svc_check_pinyin_support(&pinyin_support);
2871                 if (pinyin_support) {
2872                         if (STRING_VALID(_media->display_name))
2873                                 media_svc_get_pinyin(_media->display_name, &file_name_pinyin);
2874                         if (STRING_VALID(_media->description))
2875                                 media_svc_get_pinyin(_media->description, &description_pinyin);
2876                         if (STRING_VALID(_media->author))
2877                                 media_svc_get_pinyin(_media->author, &author_pinyin);
2878                         if (STRING_VALID(_media->provider))
2879                                 media_svc_get_pinyin(_media->provider, &provider_pinyin);
2880                         if (STRING_VALID(_media->content_name))
2881                                 media_svc_get_pinyin(_media->content_name, &content_name_pinyin);
2882                         if (STRING_VALID(_media->category))
2883                                 media_svc_get_pinyin(_media->category, &category_pinyin);
2884                         if (STRING_VALID(_media->location_tag))
2885                                 media_svc_get_pinyin(_media->location_tag, &location_tag_pinyin);
2886                         if (STRING_VALID(_media->age_rating))
2887                                 media_svc_get_pinyin(_media->age_rating, &age_rating_pinyin);
2888                         if (STRING_VALID(_media->keyword))
2889                                 media_svc_get_pinyin(_media->keyword, &keyword_pinyin);
2890                 }
2891
2892                 char *album = NULL;
2893                 char *artist = NULL;
2894                 char *genre = NULL;
2895                 char *recorded_date = NULL;
2896
2897                 if (_media->media_type == MEDIA_CONTENT_TYPE_VIDEO) {
2898                         if (_media->video_meta->album != NULL)
2899                                 album = strdup(_media->video_meta->album);
2900                         if (_media->video_meta->artist != NULL)
2901                                 artist = strdup(_media->video_meta->artist);
2902                         if (_media->video_meta->genre != NULL)
2903                                 genre = strdup(_media->video_meta->genre);
2904                         if (_media->video_meta->recorded_date != NULL)
2905                                 recorded_date = strdup(_media->video_meta->recorded_date);
2906                 } else if ((_media->media_type == MEDIA_CONTENT_TYPE_MUSIC) || (_media->media_type == MEDIA_CONTENT_TYPE_SOUND)) {
2907                         if (_media->audio_meta->album != NULL)
2908                                 album = strdup(_media->audio_meta->album);
2909                         if (_media->audio_meta->artist != NULL)
2910                                 artist = strdup(_media->audio_meta->artist);
2911                         if (_media->audio_meta->genre != NULL)
2912                                 genre = strdup(_media->audio_meta->genre);
2913                         if (_media->audio_meta->recorded_date != NULL)
2914                                 recorded_date = strdup(_media->audio_meta->recorded_date);
2915                 }
2916
2917 #ifdef _USE_SENIOR_MODE
2918                 if (_media_content_is_support_senior_mode()) {
2919                         set_sql = sqlite3_mprintf("file_name=%Q, added_time=%d, description=%Q, longitude=%f, latitude=%f, altitude=%f, \
2920                                 played_count=%d, last_played_time=%d, last_played_position=%d, \
2921                                 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, \
2922                                 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",
2923                                 _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,
2924                                 _media->author, _media->provider, _media->content_name, _media->category, _media->location_tag, _media->age_rating, _media->keyword, _media->weather, _media->sync_status,
2925                                 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);
2926                 } else
2927 #endif
2928                 {
2929                         set_sql = sqlite3_mprintf("file_name=%Q, added_time=%d, description=%Q, longitude=%f, latitude=%f, altitude=%f, \
2930                                 played_count=%d, last_played_time=%d, last_played_position=%d, \
2931                                 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, \
2932                                 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, \
2933                                 album=%Q, artist=%Q, genre=%Q, recorded_date=%Q",
2934                                 _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,
2935                                 _media->author, _media->provider, _media->content_name, _media->category, _media->location_tag, _media->age_rating, _media->keyword, _media->weather, _media->sync_status,
2936                                 file_name_pinyin, description_pinyin, author_pinyin, provider_pinyin, content_name_pinyin, category_pinyin, location_tag_pinyin, age_rating_pinyin, keyword_pinyin, _media->title,
2937                                 album, artist, genre, recorded_date);
2938                 }
2939
2940                 sql = sqlite3_mprintf("UPDATE %Q SET %s WHERE media_uuid=%Q", _media->storage_uuid, set_sql, _media->media_id);
2941
2942                 ret = _content_query_sql(sql);
2943                 SQLITE3_SAFE_FREE(set_sql);
2944                 SQLITE3_SAFE_FREE(sql);
2945
2946                 SAFE_FREE(file_name_pinyin);
2947                 SAFE_FREE(description_pinyin);
2948                 SAFE_FREE(author_pinyin);
2949                 SAFE_FREE(provider_pinyin);
2950                 SAFE_FREE(content_name_pinyin);
2951                 SAFE_FREE(category_pinyin);
2952                 SAFE_FREE(location_tag_pinyin);
2953                 SAFE_FREE(age_rating_pinyin);
2954                 SAFE_FREE(keyword_pinyin);
2955
2956                 SAFE_FREE(album);
2957                 SAFE_FREE(artist);
2958                 SAFE_FREE(genre);
2959                 SAFE_FREE(recorded_date);
2960
2961                 if (ret == MEDIA_CONTENT_ERROR_NONE) {
2962                         /* Send notification for this update */
2963                         media_content_debug("Update is successfull. Send notification for this");
2964                         if (_media->file_path && _media->mime_type)
2965                                 media_svc_publish_noti(MS_MEDIA_ITEM_FILE, MS_MEDIA_ITEM_UPDATE, _media->file_path, _media->media_type, _media->media_id, _media->mime_type);
2966                         else
2967                                 media_content_error("Can't Send Noti : path or mime type is NULL");
2968                 }
2969         } else {
2970                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2971                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2972         }
2973
2974         return ret;
2975 }
2976
2977 int media_info_refresh_metadata_to_db(const char *media_id)
2978 {
2979         int ret = MEDIA_CONTENT_ERROR_NONE;
2980         media_content_warn("DEPRECATION WARNING: media_info_refresh_metadata_to_db() is deprecated and will be removed from next release.");
2981         media_info_h media = NULL;
2982         char *file_path = NULL;
2983         media_content_storage_e storage_type = 0;
2984         char storage_id[MEDIA_CONTENT_UUID_SIZE+1] = {0, };
2985         char repl_path[MAX_PATH_LEN] = {0, };
2986
2987         if (!STRING_VALID(media_id)) {
2988                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2989                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2990         }
2991
2992         ret = media_info_get_media_from_db(media_id, &media);
2993         if (ret != MEDIA_CONTENT_ERROR_NONE) {
2994                 media_info_destroy(media);
2995                 return ret;
2996         }
2997
2998         ret = media_info_get_storage_type(media, &storage_type);
2999         if (ret != MEDIA_CONTENT_ERROR_NONE) {
3000                 media_info_destroy(media);
3001                 return ret;
3002         }
3003
3004         ret = media_info_get_file_path(media, &file_path);
3005         if (ret != MEDIA_CONTENT_ERROR_NONE) {
3006                 media_info_destroy(media);
3007                 return ret;
3008         }
3009         memset(repl_path, 0, sizeof(repl_path));
3010         ret = _media_content_replace_path(file_path, repl_path);
3011
3012         ret = _media_util_check_file_exist(repl_path);
3013         if (ret != MEDIA_CONTENT_ERROR_NONE) {
3014                 SAFE_FREE(file_path);
3015                 media_info_destroy(media);
3016                 return ret;
3017         }
3018
3019         memset(storage_id, 0x00, sizeof(storage_id));
3020         ret = media_svc_get_storage_id(_content_get_db_handle(), repl_path, storage_id, _content_get_uid());
3021         if (ret != MS_MEDIA_ERR_NONE) {
3022                 media_content_error("media_svc_get_storage_id failed : %d", ret);
3023                 SAFE_FREE(file_path);
3024                 media_info_destroy(media);
3025                 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
3026         }
3027
3028         ret = media_svc_refresh_item(_content_get_db_handle(), storage_id, storage_type, repl_path, _content_get_uid());
3029         if (ret != MS_MEDIA_ERR_NONE)
3030                 ret = _content_error_capi(MEDIA_CONTENT_TYPE, ret);
3031
3032         SAFE_FREE(file_path);
3033         media_info_destroy(media);
3034
3035         return ret;
3036 }
3037
3038 int media_info_move_to_db(media_info_h media, const char* dst_path)
3039 {
3040         int ret = MEDIA_CONTENT_ERROR_NONE;
3041         media_svc_storage_type_e src_storage_type = 0;
3042         media_svc_storage_type_e dst_storage_type = 0;
3043         char storage_id[MEDIA_CONTENT_UUID_SIZE+1] = {0, };
3044         char repl_path[MAX_PATH_LEN] = {0, };
3045         char org_repl_path[MAX_PATH_LEN] = {0, };
3046
3047         media_content_retvm_if(media == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid media");
3048         media_content_retvm_if(!STRING_VALID(dst_path), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid dst_path");
3049         memset(repl_path, 0, sizeof(repl_path));
3050         memset(org_repl_path, 0, sizeof(org_repl_path));
3051         ret = _media_content_replace_path(dst_path, repl_path);
3052         media_content_retvm_if(!STRING_VALID(repl_path), MEDIA_CONTENT_ERROR_INVALID_OPERATION, "path replacement failed");
3053
3054         media_info_s *_media = (media_info_s*)media;
3055
3056         ret = _media_content_replace_path(_media->file_path, org_repl_path);
3057         media_content_retvm_if(!STRING_VALID(org_repl_path), MEDIA_CONTENT_ERROR_INVALID_OPERATION, "path replacement failed");
3058
3059         /* If the two paths are the same, do nothing */
3060         media_content_retvm_if(g_strcmp0(repl_path, org_repl_path) == 0, MEDIA_CONTENT_ERROR_NONE, "Same path");
3061
3062         ret = __media_info_check_file_validity(repl_path);
3063         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
3064
3065         ret = media_svc_get_storage_type(org_repl_path, &src_storage_type, _content_get_uid());
3066         if (ret != MS_MEDIA_ERR_NONE) {
3067                 media_content_sec_error("media_svc_get_storage_type failed : %d", ret);
3068                 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
3069         }
3070
3071         ret = media_svc_get_storage_type(repl_path, &dst_storage_type, _content_get_uid());
3072         if (ret != MS_MEDIA_ERR_NONE) {
3073                 media_content_sec_error("media_svc_get_storage_type failed : %d", ret);
3074                 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
3075         }
3076
3077         if (src_storage_type == MEDIA_SVC_STORAGE_EXTERNAL_USB || dst_storage_type == MEDIA_SVC_STORAGE_EXTERNAL_USB) {
3078                 media_content_sec_error("Unsupported storage type src[%d] dst[%d]", src_storage_type, dst_storage_type);
3079                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
3080         }
3081
3082         memset(storage_id, 0x00, sizeof(storage_id));
3083         ret = media_svc_get_storage_id(_content_get_db_handle(), org_repl_path, storage_id, _content_get_uid());
3084         if (ret != MS_MEDIA_ERR_NONE) {
3085                 media_content_error("media_svc_get_storage_id failed : %d", ret);
3086                 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
3087         }
3088
3089         /*Delete the media info of the dest_path if it already exists.*/
3090         ret = media_svc_check_item_exist_by_path(_content_get_db_handle(), storage_id, repl_path);
3091         if (ret == MS_MEDIA_ERR_NONE) {
3092                 /* Exists */
3093                 ret = media_svc_delete_item_by_path(_content_get_db_handle(), storage_id, repl_path, _content_get_uid());
3094                 if (ret != MS_MEDIA_ERR_NONE) {
3095                         media_content_error("media_svc_delete_item_by_path failed : %d", ret);
3096                         return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
3097                 }
3098         } else if (ret != MS_MEDIA_ERR_NONE && ret != MS_MEDIA_ERR_DB_NO_RECORD) {
3099                 media_content_error("media_svc_check_item_exist_by_path failed : %d", ret);
3100                 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
3101         }
3102
3103         ret = media_svc_move_item(_content_get_db_handle(), storage_id, src_storage_type, org_repl_path, dst_storage_type, repl_path, _content_get_uid());
3104         return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
3105 }
3106
3107 int media_info_create_thumbnail(media_info_h media, media_thumbnail_completed_cb callback, void *user_data)
3108 {
3109         int ret = MEDIA_CONTENT_ERROR_NONE;
3110         static unsigned int req_id = 0;
3111         char repl_path[MAX_PATH_LEN] = {0, };
3112         media_info_s *_media = (media_info_s*)media;
3113
3114         if (_media != NULL && STRING_VALID(_media->media_id) && STRING_VALID(_media->file_path)) {
3115                 memset(repl_path, 0, sizeof(repl_path));
3116                 ret = _media_content_replace_path(_media->file_path, repl_path);
3117                 media_content_retvm_if(!STRING_VALID(repl_path), MEDIA_CONTENT_ERROR_INVALID_OPERATION, "path replacement failed");
3118
3119                 media_thumbnail_cb_s *_thumb_cb = (media_thumbnail_cb_s*)calloc(1, sizeof(media_thumbnail_cb_s));
3120                 media_content_retvm_if(_thumb_cb == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3121                 req_id++;
3122                 _media->request_id = req_id;
3123
3124                 _thumb_cb->handle = _media;
3125                 _thumb_cb->user_data = user_data;
3126                 _thumb_cb->thumbnail_completed_cb = callback;
3127
3128                 ret = thumbnail_request_from_db_async(_media->request_id, repl_path, (ThumbFunc)__media_info_thumbnail_completed_cb, (void *)_thumb_cb, _content_get_uid());
3129                 ret = _content_error_capi(MEDIA_THUMBNAIL_TYPE, ret);
3130         } else {
3131                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
3132                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
3133         }
3134
3135         return ret;
3136 }
3137
3138 int media_info_cancel_thumbnail(media_info_h media)
3139 {
3140         int ret = MEDIA_CONTENT_ERROR_NONE;
3141         media_info_s *_media = (media_info_s*)media;
3142
3143         if (_media != NULL && STRING_VALID(_media->media_id) && _media->request_id > 0) {
3144                 ret = thumbnail_request_cancel_media(_media->request_id);
3145                 ret = _content_error_capi(MEDIA_THUMBNAIL_TYPE, ret);
3146         } else {
3147                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
3148                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
3149         }
3150
3151         return ret;
3152 }
3153
3154 int media_info_start_face_detection(media_info_h media, media_face_detection_completed_cb callback, void *user_data)
3155 {
3156         int ret = MEDIA_CONTENT_ERROR_NONE;
3157         static unsigned int req_id = 0;
3158         media_info_s *_media = (media_info_s*)media;
3159         char repl_path[MAX_PATH_LEN] = {0, };
3160
3161         if (!__media_info_isFaceRecognition_feature_supported()) {
3162                 media_content_error("NOT_SUPPORTED(0x%08x)", MEDIA_CONTENT_ERROR_NOT_SUPPORTED);
3163                 return MEDIA_CONTENT_ERROR_NOT_SUPPORTED;
3164         }
3165
3166         if (_media != NULL && STRING_VALID(_media->media_id) && STRING_VALID(_media->file_path)) {
3167                 memset(repl_path, 0, sizeof(repl_path));
3168                 ret = _media_content_replace_path(_media->file_path, repl_path);
3169                 media_content_retvm_if(!STRING_VALID(repl_path), MEDIA_CONTENT_ERROR_INVALID_OPERATION, "path replacement failed");
3170                 media_face_cb_s *_face_cb = (media_face_cb_s*)calloc(1, sizeof(media_face_cb_s));
3171                 media_content_retvm_if(_face_cb == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3172                 req_id++;
3173                 _media->face_request_id = req_id;
3174
3175                 _face_cb->handle = _media;
3176                 _face_cb->user_data = user_data;
3177                 _face_cb->face_completed_cb = callback;
3178
3179                 ret = dcm_request_extract_face_async(_media->face_request_id, repl_path, (FaceFunc)__media_info_face_completed_cb, (void *)_face_cb, _content_get_uid());
3180                 ret = _content_error_capi(MEDIA_THUMBNAIL_TYPE, ret);
3181         } else {
3182                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
3183                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
3184         }
3185
3186         return ret;
3187 }
3188
3189 int media_info_cancel_face_detection(media_info_h media)
3190 {
3191         int ret = MEDIA_CONTENT_ERROR_NONE;
3192         media_info_s *_media = (media_info_s*)media;
3193
3194         if (!__media_info_isFaceRecognition_feature_supported()) {
3195                 media_content_error("NOT_SUPPORTED(0x%08x)", MEDIA_CONTENT_ERROR_NOT_SUPPORTED);
3196                 return MEDIA_CONTENT_ERROR_NOT_SUPPORTED;
3197         }
3198
3199         if (_media != NULL && STRING_VALID(_media->media_id) && _media->face_request_id > 0) {
3200                 ret = dcm_request_cancel_face(_media->face_request_id);
3201                 ret = _content_error_capi(MEDIA_THUMBNAIL_TYPE, ret);
3202         } else {
3203                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
3204                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
3205         }
3206
3207         return ret;
3208 }
3209
3210 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)
3211 {
3212         media_content_retvm_if(media == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid handle");
3213         char repl_path[MAX_PATH_LEN] = {0, };
3214         char *tmp_path = NULL;
3215
3216         media_svc_content_info_s *svc_content_info = calloc(1, sizeof(media_svc_content_info_s));
3217         media_content_retvm_if(svc_content_info == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3218
3219         memset(repl_path, 0, sizeof(repl_path));
3220         tmp_path = g_strdup(media->file_path);
3221         _media_content_replace_path(tmp_path, repl_path);
3222         svc_content_info->path = g_strdup(repl_path);
3223         SAFE_FREE(tmp_path);
3224
3225         svc_content_info->file_name = g_strdup(media->display_name);
3226         svc_content_info->media_type = media->media_type;
3227         svc_content_info->mime_type = g_strdup(media->mime_type);
3228         svc_content_info->size = media->size;
3229         svc_content_info->storage_type = storage_type;
3230         svc_content_info->storage_uuid = g_strdup(media->storage_uuid);
3231
3232         svc_content_info->added_time = media->added_time;
3233         svc_content_info->modified_time = media->modified_time;
3234         svc_content_info->thumbnail_path = g_strdup(media->thumbnail_path);
3235         svc_content_info->is_drm = media->is_drm;
3236         svc_content_info->last_played_time = media->played_time;
3237         svc_content_info->played_count = media->played_count;
3238         svc_content_info->favourate = media->favourite;
3239
3240 #ifdef _USE_SENIOR_MODE
3241         if (_media_content_is_support_senior_mode()) {
3242                 svc_content_info->contact = g_strdup(media->contact);
3243                 svc_content_info->app_data = g_strdup(media->app_data);
3244         }
3245 #endif
3246
3247         svc_content_info->media_meta.title = g_strdup(media->title);
3248         svc_content_info->media_meta.rating = media->rating;
3249         svc_content_info->media_meta.description = g_strdup(media->description);
3250         svc_content_info->media_meta.longitude = media->longitude;
3251         svc_content_info->media_meta.latitude = media->latitude;
3252         svc_content_info->media_meta.altitude = media->altitude;
3253         svc_content_info->media_meta.weather = g_strdup(media->weather);
3254         svc_content_info->media_meta.category = g_strdup(media->category);
3255         svc_content_info->media_meta.keyword = g_strdup(media->keyword);
3256         svc_content_info->media_meta.location_tag = g_strdup(media->location_tag);
3257         svc_content_info->media_meta.content_name = g_strdup(media->content_name);
3258         svc_content_info->media_meta.age_rating = g_strdup(media->age_rating);
3259         svc_content_info->media_meta.author = g_strdup(media->author);
3260         svc_content_info->media_meta.provider = g_strdup(media->provider);
3261
3262         svc_content_info->media_meta.album = g_strdup(media->audio_meta->album);
3263         svc_content_info->media_meta.artist = g_strdup(media->audio_meta->artist);
3264         svc_content_info->media_meta.genre = g_strdup(media->audio_meta->genre);
3265         svc_content_info->media_meta.recorded_date = g_strdup(media->audio_meta->recorded_date);
3266
3267         *service_content = svc_content_info;
3268
3269         return MEDIA_CONTENT_ERROR_NONE;
3270 }
3271
3272 static int __media_info_set_str_data(media_info_h media, media_info_item_e data_type, const char *str_data)
3273 {
3274         media_info_s *_media = (media_info_s*)media;
3275
3276         media_content_retvm_if(_media == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid media");
3277
3278         switch (data_type) {
3279         case MEDIA_INFO_PATH:
3280                 SAFE_FREE(_media->file_path);
3281                 if (STRING_VALID(str_data)) {
3282                         _media->file_path = strdup(str_data);
3283                         media_content_retvm_if(_media->file_path == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3284                 } else {
3285                         _media->file_path = NULL;
3286                 }
3287                 break;
3288         case MEDIA_INFO_MIME_TYPE:
3289                 SAFE_FREE(_media->mime_type);
3290                 if (STRING_VALID(str_data)) {
3291                         _media->mime_type = strdup(str_data);
3292                         media_content_retvm_if(_media->mime_type == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3293                 } else {
3294                         _media->mime_type = NULL;
3295                 }
3296                 break;
3297         case MEDIA_INFO_THUMBNAIL_PATH:
3298                 SAFE_FREE(_media->thumbnail_path);
3299                 if (STRING_VALID(str_data)) {
3300                         _media->thumbnail_path = strdup(str_data);
3301                         media_content_retvm_if(_media->thumbnail_path == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3302                 } else {
3303                         _media->thumbnail_path = NULL;
3304                 }
3305                 break;
3306         case MEDIA_INFO_TITLE:
3307                 SAFE_FREE(_media->title);
3308                 if (STRING_VALID(str_data)) {
3309                         _media->title = strdup(str_data);
3310                         media_content_retvm_if(_media->title == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3311                 } else {
3312                         _media->title = NULL;
3313                 }
3314                 break;
3315         case MEDIA_INFO_STORAGE_UUID:
3316                 SAFE_FREE(_media->storage_uuid);
3317                 if (STRING_VALID(str_data)) {
3318                         _media->storage_uuid = strdup(str_data);
3319                         media_content_retvm_if(_media->storage_uuid == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3320                 } else {
3321                         _media->storage_uuid = NULL;
3322                 }
3323                 break;
3324         case MEDIA_INFO_ALBUM:
3325                 if (STRING_VALID(_media->media_id)) {
3326                         if (_media->media_type == MEDIA_CONTENT_TYPE_VIDEO) {
3327                                 SAFE_FREE(_media->video_meta->album);
3328                                 if (str_data != NULL) {
3329                                         _media->video_meta->album = strdup(str_data);
3330                                         media_content_retvm_if(_media->video_meta->album == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3331                                 }
3332                         } else if ((_media->media_type == MEDIA_CONTENT_TYPE_MUSIC) || (_media->media_type == MEDIA_CONTENT_TYPE_SOUND)) {
3333                                 SAFE_FREE(_media->audio_meta->album);
3334                                 if (str_data != NULL) {
3335                                         _media->audio_meta->album = strdup(str_data);
3336                                         media_content_retvm_if(_media->audio_meta->album == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3337                                 }
3338                         }
3339                 } else {
3340                         SAFE_FREE(_media->video_meta->album);
3341                         if (str_data != NULL) {
3342                                 _media->video_meta->album = strdup(str_data);
3343                                 media_content_retvm_if(_media->video_meta->album == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3344                         }
3345
3346                         SAFE_FREE(_media->audio_meta->album);
3347                         if (str_data != NULL) {
3348                                 _media->audio_meta->album = strdup(str_data);
3349                                 media_content_retvm_if(_media->audio_meta->album == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3350                         }
3351                 }
3352                 break;
3353         case MEDIA_INFO_ARTIST:
3354                 if (STRING_VALID(_media->media_id)) {
3355                         if (_media->media_type == MEDIA_CONTENT_TYPE_VIDEO) {
3356                                 SAFE_FREE(_media->video_meta->artist);
3357                                 if (str_data != NULL) {
3358                                         _media->video_meta->artist = strdup(str_data);
3359                                         media_content_retvm_if(_media->video_meta->artist == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3360                                 }
3361                         } else if ((_media->media_type == MEDIA_CONTENT_TYPE_MUSIC) || (_media->media_type == MEDIA_CONTENT_TYPE_SOUND)) {
3362                                 SAFE_FREE(_media->audio_meta->artist);
3363                                 if (str_data != NULL) {
3364                                         _media->audio_meta->artist = strdup(str_data);
3365                                         media_content_retvm_if(_media->audio_meta->artist == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3366                                 }
3367                         }
3368                 } else {
3369                         SAFE_FREE(_media->video_meta->artist);
3370                         if (str_data != NULL) {
3371                                 _media->video_meta->artist = strdup(str_data);
3372                                 media_content_retvm_if(_media->video_meta->artist == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3373                         }
3374
3375                         SAFE_FREE(_media->audio_meta->artist);
3376                         if (str_data != NULL) {
3377                                 _media->audio_meta->artist = strdup(str_data);
3378                                 media_content_retvm_if(_media->audio_meta->artist == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3379                         }
3380                 }
3381                 break;
3382         case MEDIA_INFO_GENRE:
3383                 if (STRING_VALID(_media->media_id)) {
3384                         if (_media->media_type == MEDIA_CONTENT_TYPE_VIDEO) {
3385                                 SAFE_FREE(_media->video_meta->genre);
3386                                 if (str_data != NULL) {
3387                                         _media->video_meta->genre = strdup(str_data);
3388                                         media_content_retvm_if(_media->video_meta->genre == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3389                                 }
3390                         } else if ((_media->media_type == MEDIA_CONTENT_TYPE_MUSIC) || (_media->media_type == MEDIA_CONTENT_TYPE_SOUND)) {
3391                                 SAFE_FREE(_media->audio_meta->genre);
3392                                 if (str_data != NULL) {
3393                                         _media->audio_meta->genre = strdup(str_data);
3394                                         media_content_retvm_if(_media->audio_meta->genre == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3395                                 }
3396                         }
3397                 } else {
3398                         SAFE_FREE(_media->video_meta->genre);
3399                         if (str_data != NULL) {
3400                                 _media->video_meta->genre = strdup(str_data);
3401                                 media_content_retvm_if(_media->video_meta->genre == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3402                         }
3403
3404                         SAFE_FREE(_media->audio_meta->genre);
3405                         if (str_data != NULL) {
3406                                 _media->audio_meta->genre = strdup(str_data);
3407                                 media_content_retvm_if(_media->audio_meta->genre == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3408                         }
3409                 }
3410                 break;
3411         case MEDIA_INFO_RECORDED_DATE:
3412                 if (STRING_VALID(_media->media_id)) {
3413                         if (_media->media_type == MEDIA_CONTENT_TYPE_VIDEO) {
3414                                 SAFE_FREE(_media->video_meta->recorded_date);
3415                                 if (str_data != NULL) {
3416                                         _media->video_meta->recorded_date = strdup(str_data);
3417                                         media_content_retvm_if(_media->video_meta->recorded_date == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3418                                 }
3419                         } else if ((_media->media_type == MEDIA_CONTENT_TYPE_MUSIC) || (_media->media_type == MEDIA_CONTENT_TYPE_SOUND)) {
3420                                 SAFE_FREE(_media->audio_meta->recorded_date);
3421                                 if (str_data != NULL) {
3422                                         _media->audio_meta->recorded_date = strdup(str_data);
3423                                         media_content_retvm_if(_media->audio_meta->recorded_date == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3424                                 }
3425                         }
3426                 } else {
3427                         SAFE_FREE(_media->video_meta->recorded_date);
3428                         if (str_data != NULL) {
3429                                 _media->video_meta->recorded_date = strdup(str_data);
3430                                 media_content_retvm_if(_media->video_meta->recorded_date == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3431                         }
3432
3433                         SAFE_FREE(_media->audio_meta->recorded_date);
3434                         if (str_data != NULL) {
3435                                 _media->audio_meta->recorded_date = strdup(str_data);
3436                                 media_content_retvm_if(_media->audio_meta->recorded_date == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3437                         }
3438                 }
3439                 break;
3440         default:
3441                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
3442                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
3443         }
3444
3445         return MEDIA_CONTENT_ERROR_NONE;
3446 }
3447
3448 static int __media_info_destroy(media_info_h media)
3449 {
3450         int ret = MEDIA_CONTENT_ERROR_NONE;
3451         media_info_s *_media = (media_info_s*)media;
3452
3453         if (_media) {
3454                 SAFE_FREE(_media->media_id);
3455                 SAFE_FREE(_media->file_path);
3456                 SAFE_FREE(_media->display_name);
3457                 SAFE_FREE(_media->mime_type);
3458                 SAFE_FREE(_media->thumbnail_path);
3459                 SAFE_FREE(_media->description);
3460                 SAFE_FREE(_media->author);
3461                 SAFE_FREE(_media->provider);
3462                 SAFE_FREE(_media->content_name);
3463                 SAFE_FREE(_media->category);
3464                 SAFE_FREE(_media->location_tag);
3465                 SAFE_FREE(_media->age_rating);
3466                 SAFE_FREE(_media->keyword);
3467                 SAFE_FREE(_media->title);
3468                 SAFE_FREE(_media->weather);
3469                 SAFE_FREE(_media->storage_uuid);
3470
3471                 if (_media->image_meta) {
3472                         SAFE_FREE(_media->image_meta->media_id);
3473                         SAFE_FREE(_media->image_meta->date_taken);
3474                         SAFE_FREE(_media->image_meta->burst_id);
3475                         SAFE_FREE(_media->image_meta->exposure_time);
3476                         SAFE_FREE(_media->image_meta->model);
3477                         SAFE_FREE(_media->image_meta->title);
3478
3479                         SAFE_FREE(_media->image_meta);
3480                 }
3481
3482                 if (_media->video_meta) {
3483                         SAFE_FREE(_media->video_meta->media_id);
3484                         SAFE_FREE(_media->video_meta->title);
3485                         SAFE_FREE(_media->video_meta->album);
3486                         SAFE_FREE(_media->video_meta->artist);
3487                         SAFE_FREE(_media->video_meta->album_artist);
3488                         SAFE_FREE(_media->video_meta->genre);
3489                         SAFE_FREE(_media->video_meta->composer);
3490                         SAFE_FREE(_media->video_meta->year);
3491                         SAFE_FREE(_media->video_meta->recorded_date);
3492                         SAFE_FREE(_media->video_meta->copyright);
3493                         SAFE_FREE(_media->video_meta->track_num);
3494
3495                         SAFE_FREE(_media->video_meta);
3496                 }
3497
3498                 if (_media->audio_meta) {
3499                         SAFE_FREE(_media->audio_meta->media_id);
3500                         SAFE_FREE(_media->audio_meta->title);
3501                         SAFE_FREE(_media->audio_meta->album);
3502                         SAFE_FREE(_media->audio_meta->artist);
3503                         SAFE_FREE(_media->audio_meta->album_artist);
3504                         SAFE_FREE(_media->audio_meta->genre);
3505                         SAFE_FREE(_media->audio_meta->composer);
3506                         SAFE_FREE(_media->audio_meta->year);
3507                         SAFE_FREE(_media->audio_meta->recorded_date);
3508                         SAFE_FREE(_media->audio_meta->copyright);
3509                         SAFE_FREE(_media->audio_meta->track_num);
3510
3511                         SAFE_FREE(_media->audio_meta);
3512                 }
3513
3514                 ret = MEDIA_CONTENT_ERROR_NONE;
3515         } else {
3516                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
3517                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
3518         }
3519
3520         return ret;
3521 }
3522
3523 int media_info_insert_to_db_with_data(media_info_h media)
3524 {
3525         int ret = MEDIA_CONTENT_ERROR_NONE;
3526         int ret_cnt = 0;
3527         char repl_path[MAX_PATH_LEN] = {0, };
3528
3529         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.");
3530
3531         media_info_s *_media = (media_info_s*)media;
3532
3533         media_content_retvm_if(_media == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid media");
3534         media_content_retvm_if(!STRING_VALID(_media->file_path), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid file_path");
3535         media_content_retvm_if(!STRING_VALID(_media->storage_uuid), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid storage_uuid");
3536         media_content_retvm_if(_media->storage_type < 0, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid storage_type [%d]", _media->storage_type);
3537
3538         media_content_sec_debug("storage[%d], path[%s], media_type[%d]", _media->storage_type, _media->file_path, _media->media_type);
3539
3540         media_svc_content_info_s *svc_content_info = NULL;
3541
3542         ret = __media_info_map_data_usr_to_svc(_media, &svc_content_info, _media->storage_type);
3543         media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "__media_info_map_data_usr_to_svc fail");
3544
3545         ret = media_svc_insert_item_immediately_with_data(_content_get_db_handle(), svc_content_info, _content_get_uid());
3546         if (ret != MS_MEDIA_ERR_NONE) {
3547                 media_content_sec_error("media_svc_insert_item_immediately_with_data failed : %d (%s)", ret, _media->file_path);
3548                 media_svc_destroy_content_info(svc_content_info);
3549                 SAFE_FREE(svc_content_info);
3550                 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
3551         }
3552         /*free the svc_content_info*/
3553         media_svc_destroy_content_info(svc_content_info);
3554         SAFE_FREE(svc_content_info);
3555
3556         /*Fill out the handle*/
3557         memset(repl_path, 0, sizeof(repl_path));
3558         ret = _media_content_replace_path(_media->file_path, repl_path);
3559         char *media_file_path = g_strdup(repl_path);
3560
3561         char *media_string_uuid = g_strdup(_media->storage_uuid);
3562
3563         __media_info_destroy(media);
3564 RETRY:
3565         ret = _media_info_get_media_info_from_db(media_file_path, media_string_uuid, media);
3566         if (ret != MEDIA_CONTENT_ERROR_NONE) {
3567                 media_content_error("_media_info_get_media_info_from_db fail [%d]", ret);
3568                 if (ret == MEDIA_CONTENT_ERROR_DB_FAILED && ret_cnt < 5) {
3569                         ret_cnt++;
3570                         media_content_error("RETRY GETTING DATA");
3571                         goto RETRY;
3572                 }
3573         }
3574
3575         SAFE_FREE(media_file_path);
3576         SAFE_FREE(media_string_uuid);
3577
3578         return ret;
3579 }
3580
3581 int media_info_create(const char *path, media_info_h *media)
3582 {
3583         int ret = MEDIA_CONTENT_ERROR_NONE;
3584         char storage_id[MEDIA_CONTENT_UUID_SIZE+1] = {0, };
3585         media_svc_storage_type_e storage_type = 0;
3586         char repl_path[MAX_PATH_LEN] = {0, };
3587         media_content_warn("DEPRECATION WARNING: media_info_create() is deprecated and will be removed from next release. Use media_info_insert_to_db() instead.");
3588
3589         media_content_retvm_if(!STRING_VALID(path), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid path");
3590         media_content_retvm_if(media == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid media");
3591         memset(repl_path, 0, sizeof(repl_path));
3592         ret = _media_content_replace_path(path, repl_path);
3593         media_content_retvm_if(!STRING_VALID(repl_path), MEDIA_CONTENT_ERROR_INVALID_OPERATION, "path replacement failed");
3594
3595         memset(storage_id, 0x00, sizeof(storage_id));
3596
3597         ret = __media_info_check_file_validity(repl_path);
3598         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
3599
3600         ret = media_svc_get_storage_id(_content_get_db_handle(), repl_path, storage_id, _content_get_uid());
3601         if (ret != MS_MEDIA_ERR_NONE) {
3602                 media_content_error("media_svc_get_storage_id failed : %d", ret);
3603                 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
3604         }
3605
3606         ret = media_svc_get_storage_type(repl_path, &storage_type, _content_get_uid());
3607         if (ret != MS_MEDIA_ERR_NONE) {
3608                 media_content_sec_error("media_svc_get_storage_type failed : %d", ret);
3609                 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
3610         }
3611
3612         media_info_s *_media = (media_info_s*)calloc(1, sizeof(media_info_s));
3613         media_content_retvm_if(_media == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
3614
3615         _media->audio_meta = (audio_meta_s *)calloc(1, sizeof(audio_meta_s));
3616         if (_media->audio_meta == NULL) {
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->video_meta = (video_meta_s *)calloc(1, sizeof(video_meta_s));
3623         if (_media->video_meta == NULL) {
3624                 SAFE_FREE(_media->audio_meta);
3625                 SAFE_FREE(_media);
3626                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
3627                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
3628         }
3629
3630         _media->image_meta = (image_meta_s *)calloc(1, sizeof(image_meta_s));
3631         if (_media->image_meta == NULL) {
3632                 SAFE_FREE(_media->audio_meta);
3633                 SAFE_FREE(_media->video_meta);
3634                 SAFE_FREE(_media);
3635                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
3636                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
3637         }
3638
3639         _media->file_path = g_strdup(path);
3640         _media->storage_type = -1;
3641         _media->media_type = 0;
3642         _media->modified_time = 0;
3643         _media->size = 0;
3644         _media->request_id = 0;
3645         _media->longitude = MEDIA_SVC_DEFAULT_GPS_VALUE;
3646         _media->latitude = MEDIA_SVC_DEFAULT_GPS_VALUE;
3647         _media->altitude = MEDIA_SVC_DEFAULT_GPS_VALUE;
3648
3649         if (STRING_VALID(storage_id)) {
3650                 _media->storage_uuid = g_strdup(storage_id);
3651                 _media->storage_type = storage_type;
3652         }
3653
3654         *media = (media_info_h)_media;
3655
3656         return ret;
3657 }
3658
3659 int media_info_set_title(media_info_h media, const char *title)
3660 {
3661         media_content_warn("DEPRECATION WARNING: media_info_set_title() is deprecated and will be removed from next release.");
3662
3663         return __media_info_set_str_data(media, MEDIA_INFO_TITLE, title);
3664 }
3665
3666 int media_info_set_album(media_info_h media, const char *album)
3667 {
3668         media_content_warn("DEPRECATION WARNING: media_info_set_album() is deprecated and will be removed from next release.");
3669
3670         return __media_info_set_str_data(media, MEDIA_INFO_ALBUM, album);
3671 }
3672
3673 int media_info_set_artist(media_info_h media, const char *artist)
3674 {
3675         media_content_warn("DEPRECATION WARNING: media_info_set_artist() is deprecated and will be removed from next release.");
3676
3677         return __media_info_set_str_data(media, MEDIA_INFO_ARTIST, artist);
3678 }
3679
3680 int media_info_set_genre(media_info_h media, const char *genre)
3681 {
3682         media_content_warn("DEPRECATION WARNING: media_info_set_genre() is deprecated and will be removed from next release.");
3683
3684         return __media_info_set_str_data(media, MEDIA_INFO_GENRE, genre);
3685 }
3686
3687 int media_info_set_recorded_date(media_info_h media, const char *recorded_date)
3688 {
3689         media_content_warn("DEPRECATION WARNING: media_info_set_recorded_date() is deprecated and will be removed from next release.");
3690
3691         return __media_info_set_str_data(media, MEDIA_INFO_RECORDED_DATE, recorded_date);
3692 }