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