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