src/media_info.c

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