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