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