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