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