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