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