src/media_info.c

   1 /*
   2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3 *
   4 * Licensed under the Apache License, Version 2.0 (the "License");
   5 * you may not use this file except in compliance with the License.
   6 * You may obtain a copy of the License at
   7 *
   8 * http://www.apache.org/licenses/LICENSE-2.0
   9 *
  10 * Unless required by applicable law or agreed to in writing, software
  11 * distributed under the License is distributed on an "AS IS" BASIS,
  12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 * See the License for the specific language governing permissions and
  14 * limitations under the License.
  15 */
  16
  17 #include <media_info.h>
  18 #include <media-thumbnail.h>
  19 #include <media-util-dcm.h>
  20 #include <media_info_private.h>
  21 #include <media_util_private.h>
  22 #include <system_info.h>
  23
  24
  25 #define media_content_retv_free_info_if(expr, val, p_str) do { \
  26                                 if (expr) {     \
  27                                         LOGE(FONT_COLOR_RED"Memory allocation failure"FONT_COLOR_RESET);        \
  28                                         media_info_destroy(p_str);      \
  29                                         return (val);   \
  30                                 }       \
  31                         } while (0)
  32
  33
  34 static void __media_info_insert_completed_cb(media_request_result_s *result, void *user_data);
  35 static void __media_info_thumbnail_completed_cb(int error, const char *path, void *user_data);
  36 static void __media_info_face_completed_cb(int error, const int face_count, void *user_data);
  37 static int __media_info_insert_batch(const char **path_array, unsigned int array_length, media_insert_completed_cb completed_cb, void *user_data);
  38 static int __media_info_check_file_validity(const char *path);
  39
  40 static int __media_info_get_media_path_by_id_from_db(const char *media_id, char **path)
  41 {
  42         int ret = MEDIA_CONTENT_ERROR_NONE;
  43         sqlite3_stmt *stmt = NULL;
  44         char *select_query = NULL;
  45
  46         media_content_retvm_if(!STRING_VALID(media_id), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid media_id");
  47
  48         select_query = sqlite3_mprintf(SELECT_MEDIA_PATH_BY_ID, media_id);
  49
  50         ret = _content_get_result(select_query, &stmt);
  51         SQLITE3_SAFE_FREE(select_query);
  52         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
  53
  54         if (sqlite3_step(stmt) == SQLITE_ROW) {
  55                 *path = g_strdup((const char *)sqlite3_column_text(stmt, 0));
  56         } else {
  57                 media_content_error("There's no media with this ID : %s", media_id);
  58                 *path = NULL;
  59                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  60         }
  61
  62         SQLITE3_FINALIZE(stmt);
  63
  64         return ret;
  65 }
  66
  67 static void __media_info_insert_completed_cb(media_request_result_s *result, void *user_data)
  68 {
  69         int ret = MEDIA_CONTENT_ERROR_NONE;
  70         media_insert_cb_s *_cb_data = (media_insert_cb_s *)user_data;
  71
  72         if (_cb_data) {
  73                 if (result)
  74                         ret = _content_error_capi(result->result);
  75
  76                 if (_cb_data->insert_completed_cb) {
  77                         media_content_debug("User callback is being called now");
  78                         _cb_data->insert_completed_cb(ret, _cb_data->user_data);
  79                 }
  80
  81                 if (STRING_VALID(_cb_data->insert_list_path)) {
  82                         if (unlink(_cb_data->insert_list_path) < 0)
  83                                 media_content_stderror("failed to delete");
  84                         SAFE_FREE(_cb_data->insert_list_path);
  85                 }
  86         }
  87
  88         SAFE_FREE(_cb_data);
  89
  90         return;
  91 }
  92
  93 static void __media_info_thumbnail_completed_cb(int error, const char *path, void *user_data)
  94 {
  95         int error_value = MEDIA_CONTENT_ERROR_NONE;
  96
  97         media_thumbnail_cb_s *_thumb_cb = (media_thumbnail_cb_s *)user_data;
  98         media_info_s *media = NULL;
  99
 100         if (_thumb_cb != NULL) {
 101                 media = _thumb_cb->handle;
 102
 103                 if (media != NULL) {
 104                         if (media->thumbnail_path != NULL)
 105                                 SAFE_FREE(media->thumbnail_path);
 106
 107                         if (STRING_VALID(path))
 108                                 media->thumbnail_path = g_strdup(path);
 109                         else
 110                                 media->thumbnail_path = g_strdup(MEDIA_CONTENT_EMPTY_STRING);
 111                 }
 112
 113                 media_content_debug("error [%d], thumbnail_path [%s]", error, path);
 114                 error_value = _content_error_capi(error);
 115                 if (_thumb_cb->thumbnail_completed_cb)
 116                         _thumb_cb->thumbnail_completed_cb(error_value, path, _thumb_cb->user_data);
 117         }
 118
 119         SAFE_FREE(_thumb_cb);
 120
 121         return;
 122 }
 123
 124 static bool __media_info_isFaceRecognition_feature_supported()
 125 {
 126         bool isFaceRecognitionSupported = false;
 127
 128         const int nRetVal = system_info_get_platform_bool("http://tizen.org/feature/vision.face_recognition", &isFaceRecognitionSupported);
 129
 130         if (nRetVal != SYSTEM_INFO_ERROR_NONE) {
 131                 media_content_debug("SYSTEM_INFO_ERROR: vision.face_recognition [%d]", nRetVal);
 132                 return false;
 133         }
 134
 135         return isFaceRecognitionSupported;
 136 }
 137
 138 static void __media_info_face_completed_cb(int error, const int face_count, void *user_data)
 139 {
 140         int error_value = MEDIA_CONTENT_ERROR_NONE;
 141
 142         media_face_cb_s *_face_cb = (media_face_cb_s *)user_data;
 143
 144         if (_face_cb != NULL) {
 145                 media_content_debug("error [%d], face_count [%d]", error, face_count);
 146                 error_value = _content_error_capi(error);
 147                 if (_face_cb->face_completed_cb)
 148                         _face_cb->face_completed_cb(error_value, face_count, _face_cb->user_data);
 149         }
 150
 151         SAFE_FREE(_face_cb);
 152
 153         return;
 154 }
 155
 156 static int __media_info_insert_batch(const char **path_array,
 157                                         unsigned int array_length,
 158                                         media_insert_completed_cb completed_cb,
 159                                         void *user_data)
 160 {
 161         int ret = MEDIA_CONTENT_ERROR_NONE;
 162         FILE *fp = NULL;
 163         char list_path[255] = {0, };
 164         unsigned int idx = 0;
 165         int nwrites = 0;
 166
 167         for (idx = 0; idx < BATCH_REQUEST_MAX; idx++) {
 168                 snprintf(list_path, sizeof(list_path), "%s/request-%ld-%d", MEDIA_CONTENT_INSERT_FILES_PATH, media_content_gettid(), idx);
 169
 170                 if (g_file_test(list_path, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR)) {
 171                         memset(list_path, 0x00, sizeof(list_path));
 172                         continue;
 173                 } else {
 174                         media_content_debug("The request file list path : %s", list_path);
 175                         break;
 176                 }
 177         }
 178
 179         if (idx == BATCH_REQUEST_MAX) {
 180                 media_content_error("Too many batch request for one thread");
 181                 return MEDIA_CONTENT_ERROR_DB_BUSY;
 182         }
 183
 184         fp = fopen(list_path, "w");
 185         if (fp == NULL) {
 186                 media_content_error("failed to open file : [%s]", list_path);
 187                 media_content_stderror("failed to open file");
 188                 return MEDIA_CONTENT_ERROR_INVALID_OPERATION;
 189         }
 190
 191         for (idx = 0; idx < array_length; idx++) {
 192                 if (STRING_VALID(path_array[idx])) {
 193                         int size = strlen(path_array[idx]);
 194
 195                         ret = __media_info_check_file_validity(path_array[idx]);
 196                         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 197                                 fclose(fp);
 198                                 if (unlink(list_path) < 0)
 199                                         media_content_stderror("failed to delete");
 200                                 return ret;
 201                         }
 202
 203                         if (!_media_util_check_support_media_type(path_array[idx])) {
 204                                 fclose(fp);
 205                                 if (unlink(list_path) < 0)
 206                                         media_content_stderror("failed to delete");
 207                                 return MEDIA_CONTENT_ERROR_NOT_SUPPORTED;
 208                         }
 209
 210                         nwrites = fwrite(path_array[idx], 1, size, fp);
 211                         if (nwrites != size) {
 212                                 media_content_stderror("failed to write");
 213                                 fclose(fp);
 214                                 if (unlink(list_path) < 0)
 215                                         media_content_stderror("failed to delete");
 216                                 return MEDIA_CONTENT_ERROR_INVALID_OPERATION;
 217                         }
 218
 219                         nwrites = fwrite("\n", 1, 1, fp);
 220                         if (nwrites != 1) {
 221                                 media_content_stderror("failed to write");
 222                                 fclose(fp);
 223                                 if (unlink(list_path) < 0)
 224                                         media_content_stderror("failed to delete");
 225                                 return MEDIA_CONTENT_ERROR_INVALID_OPERATION;
 226                         }
 227                 } else {
 228                         media_content_error("path[%d] is invalid string", idx);
 229                 }
 230         }
 231
 232         fclose(fp);
 233
 234         media_insert_cb_s *_cb_data = (media_insert_cb_s *)calloc(1, sizeof(media_insert_cb_s));
 235         media_content_retvm_if(_cb_data == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 236
 237         _cb_data->insert_completed_cb = completed_cb;
 238         _cb_data->user_data = user_data;
 239         _cb_data->insert_list_path = g_strdup(list_path);
 240
 241         ret = media_files_register(list_path, __media_info_insert_completed_cb, _cb_data, _content_get_uid());
 242         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 243                 media_content_error("media_files_register failed : %d", ret);
 244                 if (unlink(list_path) < 0)
 245                         media_content_stderror("failed to delete");
 246                 return _content_error_capi(ret);
 247         }
 248
 249         return ret;
 250 }
 251
 252 static int __media_info_check_file_validity(const char *path)
 253 {
 254         bool ignore = FALSE;
 255         char *folder_path = NULL;
 256         int ret = MEDIA_CONTENT_ERROR_NONE;
 257
 258         media_content_retvm_if(!STRING_VALID(path), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid path");
 259
 260         ret = _media_util_check_ignore_file(path, &ignore);
 261         media_content_retvm_if(ignore == TRUE, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid ignore path");
 262
 263         ret = _media_util_check_file_exist(path);
 264         media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "invalid path");
 265
 266         folder_path = g_path_get_dirname(path);
 267         ret = _media_util_check_ignore_dir(folder_path, &ignore);
 268         g_free(folder_path);
 269         media_content_retvm_if(ignore == TRUE, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid folder path");
 270
 271         return MEDIA_CONTENT_ERROR_NONE;
 272 }
 273
 274 void _media_info_item_get_detail(sqlite3_stmt* stmt, media_info_h media)
 275 {
 276         media_info_s *_media = (media_info_s*)media;
 277
 278         _media->media_id = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_UUID));
 279         _media->file_path = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_PATH));
 280         _media->display_name = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_FILE_NAME));
 281         _media->media_type = (int)sqlite3_column_int(stmt, MEDIA_INFO_TYPE);
 282         _media->mime_type = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_MIME_TYPE));
 283         _media->size = (unsigned long long)sqlite3_column_int64(stmt, MEDIA_INFO_SIZE);
 284         _media->added_time = (int)sqlite3_column_int(stmt, MEDIA_INFO_ADDED_TIME);
 285         _media->modified_time = (int)sqlite3_column_int(stmt, MEDIA_INFO_MODIFIED_TIME);
 286         _media->thumbnail_path = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_THUMBNAIL_PATH));
 287         _media->description = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_DESCRIPTION));
 288         _media->rating = (int)sqlite3_column_int(stmt, MEDIA_INFO_RATING);
 289         _media->favourite = (int)sqlite3_column_int(stmt, MEDIA_INFO_FAVOURITE);
 290         _media->is_drm = (int)sqlite3_column_int(stmt, MEDIA_INFO_IS_DRM);
 291         _media->storage_type = (int)sqlite3_column_int(stmt, MEDIA_INFO_STORAGE_TYPE);
 292         _media->longitude = (double)sqlite3_column_double(stmt, MEDIA_INFO_LONGITUDE);
 293         _media->latitude = (double)sqlite3_column_double(stmt, MEDIA_INFO_LATITUDE);
 294         _media->altitude = (double)sqlite3_column_double(stmt, MEDIA_INFO_ALTITUDE);
 295         _media->title = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_TITLE));
 296         _media->timeline = (double)sqlite3_column_double(stmt, MEDIA_INFO_TIMELINE);
 297         _media->storage_uuid = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_STORAGE_UUID));
 298         _media->is_360 = (int)sqlite3_column_int(stmt, MEDIA_INFO_IS_360);
 299 #ifdef _USE_TVPD_MODE
 300         _media->played_count = sqlite3_column_int(stmt, MEDIA_INFO_PLAYED_COUNT);
 301         _media->played_time = sqlite3_column_int(stmt, MEDIA_INFO_LAST_PLAYED_TIME);
 302         _media->played_position = sqlite3_column_int(stmt, MEDIA_INFO_LAST_PLAYED_POSITION);
 303         _media->stitched_info = (int)sqlite3_column_int(stmt, MEDIA_INFO_STITCHED_INFO);
 304 #endif
 305
 306         if (_media->media_type == MEDIA_CONTENT_TYPE_IMAGE) {
 307                 _media->image_meta = (image_meta_s *)calloc(1, sizeof(image_meta_s));
 308                 if (_media->image_meta) {
 309                         _media->image_meta->media_id = g_strdup(_media->media_id);
 310                         _media->image_meta->width = sqlite3_column_int(stmt, MEDIA_INFO_WIDTH);
 311                         _media->image_meta->height = sqlite3_column_int(stmt, MEDIA_INFO_HEIGHT);
 312                         _media->image_meta->fnumber = (double)sqlite3_column_double(stmt, MEDIA_INFO_FNUMBER);
 313                         _media->image_meta->iso = sqlite3_column_int(stmt, MEDIA_INFO_ISO);
 314                         _media->image_meta->date_taken = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_DATETAKEN));
 315                         _media->image_meta->orientation = sqlite3_column_int(stmt, MEDIA_INFO_ORIENTATION);
 316                         _media->image_meta->exposure_time = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_EXPOSURE_TIME));
 317                         _media->image_meta->model = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_MODEL));
 318                 }
 319         } else if (_media->media_type == MEDIA_CONTENT_TYPE_VIDEO) {
 320                 _media->video_meta = (video_meta_s *)calloc(1, sizeof(video_meta_s));
 321                 if (_media->video_meta) {
 322                         _media->video_meta->media_id = g_strdup(_media->media_id);
 323                         _media->video_meta->width = sqlite3_column_int(stmt, MEDIA_INFO_WIDTH);
 324                         _media->video_meta->height = sqlite3_column_int(stmt, MEDIA_INFO_HEIGHT);
 325                         _media->video_meta->album = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_ALBUM));
 326                         _media->video_meta->artist = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_ARTIST));
 327                         _media->video_meta->album_artist = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_ALBUM_ARTIST));
 328                         _media->video_meta->genre = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_GENRE));
 329                         _media->video_meta->composer = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_COMPOSER));
 330                         _media->video_meta->year = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_YEAR));
 331                         _media->video_meta->recorded_date = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_RECORDED_DATE));
 332                         _media->video_meta->copyright = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_COPYRIGHT));
 333                         _media->video_meta->track_num = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_TRACK_NUM));
 334                         _media->video_meta->bitrate = sqlite3_column_int(stmt, MEDIA_INFO_BITRATE);
 335                         _media->video_meta->duration = sqlite3_column_int(stmt, MEDIA_INFO_DURATION);
 336                         _media->video_meta->rotation = sqlite3_column_int(stmt, MEDIA_INFO_ORIENTATION);
 337                 }
 338
 339         } else if ((_media->media_type == MEDIA_CONTENT_TYPE_MUSIC) || (_media->media_type == MEDIA_CONTENT_TYPE_SOUND)) {
 340                 _media->audio_meta = (audio_meta_s *)calloc(1, sizeof(audio_meta_s));
 341                 if (_media->audio_meta) {
 342                         _media->audio_meta->media_id = g_strdup(_media->media_id);
 343                         _media->audio_meta->album = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_ALBUM));
 344                         _media->audio_meta->artist = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_ARTIST));
 345                         _media->audio_meta->album_artist = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_ALBUM_ARTIST));
 346                         _media->audio_meta->genre = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_GENRE));
 347                         _media->audio_meta->composer = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_COMPOSER));
 348                         _media->audio_meta->year = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_YEAR));
 349                         _media->audio_meta->recorded_date = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_RECORDED_DATE));
 350                         _media->audio_meta->copyright = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_COPYRIGHT));
 351                         _media->audio_meta->track_num = g_strdup((const char *)sqlite3_column_text(stmt, MEDIA_INFO_TRACK_NUM));
 352                         _media->audio_meta->bitrate = sqlite3_column_int(stmt, MEDIA_INFO_BITRATE);
 353                         _media->audio_meta->bitpersample = sqlite3_column_int(stmt, MEDIA_INFO_BITPERSAMPLE);
 354                         _media->audio_meta->duration = sqlite3_column_int(stmt, MEDIA_INFO_DURATION);
 355                         _media->audio_meta->samplerate = sqlite3_column_int(stmt, MEDIA_INFO_SAMPLERATE);
 356                         _media->audio_meta->channel = sqlite3_column_int(stmt, MEDIA_INFO_CHANNEL);
 357                 }
 358         }
 359 }
 360 #ifdef _USE_TVPD_MODE
 361 int _media_info_get_media_info_from_db(const char *path, const char *storage_id, media_info_h media)
 362 {
 363         int ret = MEDIA_CONTENT_ERROR_NONE;
 364         sqlite3_stmt *stmt = NULL;
 365         char *select_query = NULL;
 366         media_info_s *_media = (media_info_s*)media;
 367
 368         media_content_retvm_if(_media == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid media");
 369
 370         select_query = sqlite3_mprintf(SELECT_MEDIA_BY_PATH, storage_id, path);
 371
 372         ret = _content_get_result(select_query, &stmt);
 373         SQLITE3_SAFE_FREE(select_query);
 374         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 375
 376         if (sqlite3_step(stmt) == SQLITE_ROW) {
 377                 _media_info_item_get_detail(stmt, (media_info_h)_media);
 378         } else {
 379                 media_content_sec_error("No media : path[%s] storage id[%s]", path, storage_id);
 380                 ret = MEDIA_CONTENT_ERROR_DB_FAILED;
 381         }
 382
 383         SQLITE3_FINALIZE(stmt);
 384
 385         return ret;
 386 }
 387 #else
 388 int _media_info_get_media_info_from_db(const char *path, media_info_h media)
 389 {
 390         int ret = MEDIA_CONTENT_ERROR_NONE;
 391         sqlite3_stmt *stmt = NULL;
 392         char *select_query = NULL;
 393         media_info_s *_media = (media_info_s*)media;
 394
 395         media_content_retvm_if(_media == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid media");
 396
 397         select_query = sqlite3_mprintf(SELECT_MEDIA_BY_PATH, path);
 398
 399         ret = _content_get_result(select_query, &stmt);
 400         SQLITE3_SAFE_FREE(select_query);
 401         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 402
 403         if (sqlite3_step(stmt) == SQLITE_ROW) {
 404                 _media_info_item_get_detail(stmt, (media_info_h)_media);
 405         } else {
 406                 media_content_sec_error("No media : path[%s]", path);
 407                 ret = MEDIA_CONTENT_ERROR_DB_FAILED;
 408         }
 409
 410         SQLITE3_FINALIZE(stmt);
 411
 412         return ret;
 413 }
 414 #endif
 415
 416 int media_info_insert_to_db(const char *path, media_info_h *info)
 417 {
 418         char storage_id[MEDIA_CONTENT_UUID_SIZE+1] = {0, };
 419         char repl_path[MAX_PATH_LEN] = {0, };
 420         int ret = MEDIA_CONTENT_ERROR_NONE;
 421         ms_user_storage_type_e storage_type = MS_USER_STORAGE_INTERNAL;
 422         int modified_time = 0;
 423
 424         media_content_retvm_if(!STRING_VALID(path), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid path");
 425         media_content_retvm_if(info == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid info");
 426         memset(repl_path, 0, sizeof(repl_path));
 427         ret = _media_content_replace_path(path, repl_path);
 428         media_content_retvm_if(!STRING_VALID(repl_path), MEDIA_CONTENT_ERROR_INVALID_OPERATION, "path replacement failed");
 429
 430         ret = __media_info_check_file_validity(repl_path);
 431         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 432
 433         memset(storage_id, 0x00, sizeof(storage_id));
 434         ret = media_svc_get_storage_id(_content_get_db_handle(), repl_path, storage_id, _content_get_uid());
 435         if (ret != MS_MEDIA_ERR_NONE) {
 436                 media_content_error("media_svc_get_storage_id failed : %d", ret);
 437                 return _content_error_capi(ret);
 438         }
 439
 440         ret = ms_user_get_storage_type(_content_get_uid(), repl_path, &storage_type);
 441         if (ret != MS_MEDIA_ERR_NONE) {
 442                 media_content_sec_error("ms_user_get_storage_type failed : %d", ret);
 443                 return _content_error_capi(ret);
 444         }
 445
 446         /* Get modified time for check exists */
 447         ret = media_svc_get_modified_time(_content_get_db_handle(), storage_id, repl_path, &modified_time);
 448         if (ret == MS_MEDIA_ERR_NONE) {
 449                 /* Refresh if need */
 450                 if (modified_time != _media_util_get_file_time(repl_path)) {
 451                         ret = media_svc_refresh_item(_content_get_db_handle(), false, storage_id, storage_type, repl_path, _content_get_uid());
 452                         if (ret != MS_MEDIA_ERR_NONE) {
 453                                 media_content_error("media_svc_refresh_item failed : %d", ret);
 454                                 return _content_error_capi(ret);
 455                         }
 456                 }
 457         } else if (ret == MS_MEDIA_ERR_DB_NO_RECORD) {
 458                 media_content_sec_debug("media_svc_check_item_exist_by_path : no record : %s", repl_path);
 459                 media_content_retvm_if(!_media_util_check_support_media_type(repl_path), MEDIA_CONTENT_ERROR_NOT_SUPPORTED, "Unsupported media type");
 460
 461                 ret = media_svc_insert_item_immediately(_content_get_db_handle(), storage_id, storage_type, repl_path, _content_get_uid());
 462                 if (ret != MS_MEDIA_ERR_NONE) {
 463                         if (ret == MS_MEDIA_ERR_DB_CONSTRAINT_FAIL) {
 464                                 media_content_sec_error("This item is already inserted. This may be normal operation because other process already did this (%s)", repl_path);
 465                                 ret = MEDIA_CONTENT_ERROR_NONE;
 466                         } else {
 467                                 media_content_sec_error("media_svc_insert_item_immediately failed : %d (%s)", ret, repl_path);
 468                         }
 469
 470                         return _content_error_capi(ret);
 471                 }
 472         } else {
 473                 media_content_sec_error("media_svc_get_modified_time failed : %d (%s)", ret, repl_path);
 474                 return _content_error_capi(ret);
 475         }
 476
 477         media_info_s *_media = (media_info_s*)calloc(1, sizeof(media_info_s));
 478         media_content_retvm_if(_media == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 479 #ifdef _USE_TVPD_MODE
 480         if (STRING_VALID(storage_id))
 481                 ret = _media_info_get_media_info_from_db(repl_path, storage_id, (media_info_h)_media);
 482         else
 483                 ret = _media_info_get_media_info_from_db(repl_path, DB_TABLE_MEDIA, (media_info_h)_media);
 484
 485         *info = (media_info_h)_media;
 486 #else
 487         ret = _media_info_get_media_info_from_db(repl_path, (media_info_h)_media);
 488
 489         *info = (media_info_h)_media;
 490 #endif
 491         return ret;
 492 }
 493
 494 int media_info_insert_batch_to_db(const char **path_array, unsigned int array_length, media_insert_completed_cb completed_cb, void *user_data)
 495 {
 496         char **repl_path_array = NULL;
 497         int idx = 0;
 498         int ret = MS_MEDIA_ERR_NONE;
 499         char repl_path[MAX_PATH_LEN] = {0, };
 500
 501         media_content_retvm_if(path_array == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid path_array");
 502         media_content_retvm_if(array_length <= 0, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid array_length");
 503
 504         repl_path_array = calloc(1, sizeof(char *) * array_length);
 505         media_content_retvm_if(repl_path_array == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 506
 507         for (idx = 0; idx < array_length; idx++) {
 508                 if (STRING_VALID(path_array[idx])) {
 509                         memset(repl_path, 0, sizeof(repl_path));
 510                         _media_content_replace_path(path_array[idx], repl_path);
 511                         repl_path_array[idx] = strndup(repl_path, strlen(repl_path));
 512                 } else {
 513                         media_content_error("path[%d] is invalid string", idx);
 514                 }
 515         }
 516
 517         ret = __media_info_insert_batch((const char **)repl_path_array, array_length, completed_cb, user_data);
 518         for (idx = 0; idx < array_length; idx++)
 519                 SAFE_FREE(repl_path_array[idx]);
 520
 521         SAFE_FREE(repl_path_array);
 522
 523         return ret;
 524 }
 525 #ifdef _USE_TVPD_MODE
 526 int media_info_get_media_info_by_path_from_db(const char* path, media_info_h* media)
 527 {
 528         char storage_id[MEDIA_CONTENT_UUID_SIZE+1] = {0,};
 529         int ret = MEDIA_CONTENT_ERROR_NONE;
 530         media_content_retvm_if(!STRING_VALID(path), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid path");
 531         media_content_retvm_if(media == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid info");
 532
 533         memset(storage_id, 0x00, sizeof(storage_id));
 534         ret = media_svc_get_storage_id(_content_get_db_handle(), path, storage_id, tzplatform_getuid(TZ_USER_NAME));
 535         if (ret != MS_MEDIA_ERR_NONE) {
 536                 media_content_error("media_svc_get_storage_id failed : %d", ret);
 537                 return _content_error_capi(ret);
 538         }
 539
 540         media_info_s *_media = (media_info_s*)calloc(1, sizeof(media_info_s));
 541         media_content_retvm_if(_media == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 542
 543         ret =  _media_info_get_media_info_from_db(path, storage_id, (media_info_h)_media);
 544         *media = (media_info_h)_media;
 545
 546         return ret;
 547 }
 548 #endif
 549
 550 int media_info_delete_from_db(const char *media_id)
 551 {
 552         int ret = MEDIA_CONTENT_ERROR_NONE;
 553         char *path = NULL;
 554         char *storage_id = NULL;
 555         media_content_warn("DEPRECATION WARNING: media_info_delete_from_db() is deprecated and will be removed from next release. Use media_content_scan_file() instead.");
 556
 557         if (!STRING_VALID(media_id)) {
 558                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 559                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 560         }
 561
 562         ret = __media_info_get_media_path_by_id_from_db(media_id, &path);
 563         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 564                 media_content_error("__media_info_get_media_path_by_id_from_db failed : %d", ret);
 565                 SAFE_FREE(path);
 566                 return ret;
 567         }
 568
 569         ret = _media_db_get_storage_id_by_media_id(media_id, &storage_id);
 570         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 571                 media_content_error("_media_db_get_storage_id_by_media_id failed : %d", ret);
 572                 SAFE_FREE(path);
 573                 return ret;
 574         }
 575
 576         ret = media_svc_delete_item_by_path(_content_get_db_handle(), storage_id, path, _content_get_uid());
 577         SAFE_FREE(path);
 578         SAFE_FREE(storage_id);
 579
 580         return _content_error_capi(ret);
 581 }
 582
 583 int media_info_destroy(media_info_h media)
 584 {
 585         media_info_s *_media = (media_info_s*)media;
 586         media_content_retvm_if(_media == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Handle is null");
 587
 588         SAFE_FREE(_media->media_id);
 589         SAFE_FREE(_media->file_path);
 590         SAFE_FREE(_media->display_name);
 591         SAFE_FREE(_media->mime_type);
 592         SAFE_FREE(_media->thumbnail_path);
 593         SAFE_FREE(_media->description);
 594         SAFE_FREE(_media->title);
 595 #ifdef _USE_TVPD_MODE
 596         SAFE_FREE(_media->modified_month);
 597 #endif
 598         SAFE_FREE(_media->storage_uuid);
 599 #ifdef _USE_SENIOR_MODE
 600         SAFE_FREE(_media->contact);
 601         SAFE_FREE(_media->app_data);
 602 #endif
 603
 604         if (_media->image_meta) {
 605                 SAFE_FREE(_media->image_meta->media_id);
 606                 SAFE_FREE(_media->image_meta->date_taken);
 607                 SAFE_FREE(_media->image_meta->exposure_time);
 608                 SAFE_FREE(_media->image_meta->model);
 609
 610                 SAFE_FREE(_media->image_meta);
 611         }
 612
 613         if (_media->video_meta) {
 614                 SAFE_FREE(_media->video_meta->media_id);
 615                 SAFE_FREE(_media->video_meta->album);
 616                 SAFE_FREE(_media->video_meta->artist);
 617                 SAFE_FREE(_media->video_meta->album_artist);
 618                 SAFE_FREE(_media->video_meta->genre);
 619                 SAFE_FREE(_media->video_meta->composer);
 620                 SAFE_FREE(_media->video_meta->year);
 621                 SAFE_FREE(_media->video_meta->recorded_date);
 622                 SAFE_FREE(_media->video_meta->copyright);
 623                 SAFE_FREE(_media->video_meta->track_num);
 624
 625                 SAFE_FREE(_media->video_meta);
 626         }
 627
 628         if (_media->audio_meta) {
 629                 SAFE_FREE(_media->audio_meta->media_id);
 630                 SAFE_FREE(_media->audio_meta->album);
 631                 SAFE_FREE(_media->audio_meta->artist);
 632                 SAFE_FREE(_media->audio_meta->album_artist);
 633                 SAFE_FREE(_media->audio_meta->genre);
 634                 SAFE_FREE(_media->audio_meta->composer);
 635                 SAFE_FREE(_media->audio_meta->year);
 636                 SAFE_FREE(_media->audio_meta->recorded_date);
 637                 SAFE_FREE(_media->audio_meta->copyright);
 638                 SAFE_FREE(_media->audio_meta->track_num);
 639
 640                 SAFE_FREE(_media->audio_meta);
 641         }
 642
 643         SAFE_FREE(_media);
 644
 645         return MEDIA_CONTENT_ERROR_NONE;
 646 }
 647
 648 int media_info_clone(media_info_h *dst, media_info_h src)
 649 {
 650         media_info_s *_src = (media_info_s*)src;
 651         media_content_retvm_if(_src == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Source handle is null");
 652
 653         media_info_s *_dst = (media_info_s*)calloc(1, sizeof(media_info_s));
 654         media_content_retvm_if(_dst == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 655
 656         if (_src->media_id) {
 657                 _dst->media_id = g_strdup(_src->media_id);
 658                 media_content_retv_free_info_if(_dst->media_id == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (media_info_h)_dst);
 659         }
 660         if (_src->file_path) {
 661                 _dst->file_path = g_strdup(_src->file_path);
 662                 media_content_retv_free_info_if(_dst->file_path == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (media_info_h)_dst);
 663         }
 664         if (_src->display_name != NULL) {
 665                 _dst->display_name = g_strdup(_src->display_name);
 666                 media_content_retv_free_info_if(_dst->display_name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (media_info_h)_dst);
 667         }
 668         if (_src->mime_type) {
 669                 _dst->mime_type = g_strdup(_src->mime_type);
 670                 media_content_retv_free_info_if(_dst->mime_type == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (media_info_h)_dst);
 671         }
 672         if (_src->thumbnail_path != NULL) {
 673                 _dst->thumbnail_path = g_strdup(_src->thumbnail_path);
 674                 media_content_retv_free_info_if(_dst->thumbnail_path == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (media_info_h)_dst);
 675         }
 676         if (_src->description != NULL) {
 677                 _dst->description = g_strdup(_src->description);
 678                 media_content_retv_free_info_if(_dst->description == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (media_info_h)_dst);
 679         }
 680
 681         if (_src->title != NULL) {
 682                 _dst->title = g_strdup(_src->title);
 683                 media_content_retv_free_info_if(_dst->title == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (media_info_h)_dst);
 684         }
 685
 686         if (_src->storage_uuid != NULL) {
 687                 _dst->storage_uuid = g_strdup(_src->storage_uuid);
 688                 media_content_retv_free_info_if(_dst->storage_uuid == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (media_info_h)_dst);
 689         }
 690 #ifdef _USE_TVPD_MODE
 691         if (STRING_VALID(_src->modified_month)) {
 692                 _dst->modified_month = strdup(_src->modified_month);
 693                 media_content_retv_free_info_if(_dst->modified_month == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (media_info_h)_dst);
 694         }
 695 #endif
 696 #ifdef _USE_SENIOR_MODE
 697         if (STRING_VALID(_src->contact)) {
 698                 _dst->contact = strdup(_src->contact);
 699                 media_content_retv_free_info_if(_dst->contact == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (media_info_h)_dst);
 700         }
 701
 702         if (STRING_VALID(_src->app_data)) {
 703                 _dst->app_data = strdup(_src->app_data);
 704                 media_content_retv_free_info_if(_dst->app_data == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (media_info_h)_dst);
 705         }
 706 #endif
 707
 708         _dst->media_type = _src->media_type;
 709         _dst->size = _src->size;
 710         _dst->added_time = _src->added_time;
 711         _dst->modified_time = _src->modified_time;
 712         _dst->timeline = _src->timeline;
 713         _dst->longitude = _src->longitude;
 714         _dst->latitude = _src->latitude;
 715         _dst->altitude = _src->altitude;
 716         _dst->rating = _src->rating;
 717         _dst->favourite = _src->favourite;
 718         _dst->is_drm = _src->is_drm;
 719         _dst->storage_type = _src->storage_type;
 720         _dst->request_id = _src->request_id;
 721         _dst->face_request_id = _src->face_request_id;
 722         _dst->is_360 = _src->is_360;
 723 #ifdef _USE_TVPD_MODE
 724         _dst->played_count = _src->played_count;
 725         _dst->played_time = _src->played_time;
 726         _dst->played_position = _src->played_position;
 727         _dst->stitched_info = _src->stitched_info;
 728         _dst->extract_flag = _src->extract_flag;
 729 #endif
 730
 731         if (_src->media_type == MEDIA_CONTENT_TYPE_IMAGE && _src->image_meta) {
 732                 _dst->image_meta = (image_meta_s *)calloc(1, sizeof(image_meta_s));
 733                 media_content_retv_free_info_if(_dst->image_meta == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (media_info_h)_dst);
 734
 735                 if (_src->image_meta->media_id != NULL) {
 736                         _dst->image_meta->media_id = g_strdup(_src->image_meta->media_id);
 737                         media_content_retv_free_info_if(_dst->image_meta->media_id == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (media_info_h)_dst);
 738                 }
 739
 740                 if (_src->image_meta->date_taken != NULL) {
 741                         _dst->image_meta->date_taken = g_strdup(_src->image_meta->date_taken);
 742                         media_content_retv_free_info_if(_dst->image_meta->date_taken == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (media_info_h)_dst);
 743                 }
 744
 745                 if (_src->image_meta->exposure_time != NULL) {
 746                         _dst->image_meta->exposure_time = g_strdup(_src->image_meta->exposure_time);
 747                         media_content_retv_free_info_if(_dst->image_meta->exposure_time == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (media_info_h)_dst);
 748                 }
 749
 750                 if (_src->image_meta->model != NULL) {
 751                         _dst->image_meta->model = g_strdup(_src->image_meta->model);
 752                         media_content_retv_free_info_if(_dst->image_meta->model == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (media_info_h)_dst);
 753                 }
 754
 755                 _dst->image_meta->fnumber = _src->image_meta->fnumber;
 756                 _dst->image_meta->iso = _src->image_meta->iso;
 757                 _dst->image_meta->width = _src->image_meta->width;
 758                 _dst->image_meta->height = _src->image_meta->height;
 759                 _dst->image_meta->orientation = _src->image_meta->orientation;
 760
 761         } else if (_src->media_type == MEDIA_CONTENT_TYPE_VIDEO && _src->video_meta) {
 762                 _dst->video_meta = (video_meta_s *)calloc(1, sizeof(video_meta_s));
 763                 media_content_retv_free_info_if(_dst->video_meta == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (media_info_h)_dst);
 764
 765                 if (_src->video_meta->media_id != NULL) {
 766                         _dst->video_meta->media_id = g_strdup(_src->video_meta->media_id);
 767                         media_content_retv_free_info_if(_dst->video_meta->media_id == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (media_info_h)_dst);
 768                 }
 769                 if (_src->video_meta->album != NULL) {
 770                         _dst->video_meta->album = g_strdup(_src->video_meta->album);
 771                         media_content_retv_free_info_if(_dst->video_meta->album == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (media_info_h)_dst);
 772                 }
 773                 if (_src->video_meta->artist != NULL) {
 774                         _dst->video_meta->artist = g_strdup(_src->video_meta->artist);
 775                         media_content_retv_free_info_if(_dst->video_meta->artist == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (media_info_h)_dst);
 776                 }
 777                 if (_src->video_meta->album_artist != NULL) {
 778                         _dst->video_meta->album_artist = g_strdup(_src->video_meta->album_artist);
 779                         media_content_retv_free_info_if(_dst->video_meta->album_artist == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (media_info_h)_dst);
 780                 }
 781                 if (_src->video_meta->genre != NULL) {
 782                         _dst->video_meta->genre = g_strdup(_src->video_meta->genre);
 783                         media_content_retv_free_info_if(_dst->video_meta->genre == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (media_info_h)_dst);
 784                 }
 785                 if (_src->video_meta->composer != NULL) {
 786                         _dst->video_meta->composer = g_strdup(_src->video_meta->composer);
 787                         media_content_retv_free_info_if(_dst->video_meta->composer == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (media_info_h)_dst);
 788                 }
 789                 if (_src->video_meta->year != NULL) {
 790                         _dst->video_meta->year = g_strdup(_src->video_meta->year);
 791                         media_content_retv_free_info_if(_dst->video_meta->year == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (media_info_h)_dst);
 792                 }
 793                 if (_src->video_meta->recorded_date != NULL) {
 794                         _dst->video_meta->recorded_date = g_strdup(_src->video_meta->recorded_date);
 795                         media_content_retv_free_info_if(_dst->video_meta->recorded_date == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (media_info_h)_dst);
 796                 }
 797                 if (_src->video_meta->copyright != NULL) {
 798                         _dst->video_meta->copyright = g_strdup(_src->video_meta->copyright);
 799                         media_content_retv_free_info_if(_dst->video_meta->copyright == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (media_info_h)_dst);
 800                 }
 801                 if (_src->video_meta->track_num != NULL) {
 802                         _dst->video_meta->track_num = g_strdup(_src->video_meta->track_num);
 803                         media_content_retv_free_info_if(_dst->video_meta->track_num == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (media_info_h)_dst);
 804                 }
 805
 806                 _dst->video_meta->width = _src->video_meta->width;
 807                 _dst->video_meta->height = _src->video_meta->height;
 808                 _dst->video_meta->duration = _src->video_meta->duration;
 809                 _dst->video_meta->bitrate = _src->video_meta->bitrate;
 810                 _dst->video_meta->rotation = _src->video_meta->rotation;
 811
 812         } else if ((_src->media_type == MEDIA_CONTENT_TYPE_MUSIC || _src->media_type == MEDIA_CONTENT_TYPE_SOUND) && _src->audio_meta) {
 813                 _dst->audio_meta = (audio_meta_s *)calloc(1, sizeof(audio_meta_s));
 814                 media_content_retv_free_info_if(_dst->audio_meta == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (media_info_h)_dst);
 815
 816                 if (_src->audio_meta->media_id != NULL) {
 817                         _dst->audio_meta->media_id = g_strdup(_src->audio_meta->media_id);
 818                         media_content_retv_free_info_if(_dst->audio_meta->media_id == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (media_info_h)_dst);
 819                 }
 820                 if (_src->audio_meta->album != NULL) {
 821                         _dst->audio_meta->album = g_strdup(_src->audio_meta->album);
 822                         media_content_retv_free_info_if(_dst->audio_meta->album == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (media_info_h)_dst);
 823                 }
 824                 if (_src->audio_meta->artist != NULL) {
 825                         _dst->audio_meta->artist = g_strdup(_src->audio_meta->artist);
 826                         media_content_retv_free_info_if(_dst->audio_meta->artist == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (media_info_h)_dst);
 827                 }
 828                 if (_src->audio_meta->album_artist != NULL) {
 829                         _dst->audio_meta->album_artist = g_strdup(_src->audio_meta->album_artist);
 830                         media_content_retv_free_info_if(_dst->audio_meta->album_artist == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (media_info_h)_dst);
 831                 }
 832                 if (_src->audio_meta->genre != NULL) {
 833                         _dst->audio_meta->genre = g_strdup(_src->audio_meta->genre);
 834                         media_content_retv_free_info_if(_dst->audio_meta->genre == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (media_info_h)_dst);
 835                 }
 836                 if (_src->audio_meta->composer != NULL) {
 837                         _dst->audio_meta->composer = g_strdup(_src->audio_meta->composer);
 838                         media_content_retv_free_info_if(_dst->audio_meta->composer == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (media_info_h)_dst);
 839                 }
 840                 if (_src->audio_meta->year != NULL) {
 841                         _dst->audio_meta->year = g_strdup(_src->audio_meta->year);
 842                         media_content_retv_free_info_if(_dst->audio_meta->year == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (media_info_h)_dst);
 843                 }
 844                 if (_src->audio_meta->recorded_date != NULL) {
 845                         _dst->audio_meta->recorded_date = g_strdup(_src->audio_meta->recorded_date);
 846                         media_content_retv_free_info_if(_dst->audio_meta->recorded_date == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (media_info_h)_dst);
 847                 }
 848                 if (_src->audio_meta->copyright != NULL) {
 849                         _dst->audio_meta->copyright = g_strdup(_src->audio_meta->copyright);
 850                         media_content_retv_free_info_if(_dst->audio_meta->copyright == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (media_info_h)_dst);
 851                 }
 852                 if (_src->audio_meta->track_num != NULL) {
 853                         _dst->audio_meta->track_num = g_strdup(_src->audio_meta->track_num);
 854                         media_content_retv_free_info_if(_dst->audio_meta->track_num == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (media_info_h)_dst);
 855                 }
 856
 857                 _dst->audio_meta->channel = _src->audio_meta->channel;
 858                 _dst->audio_meta->samplerate = _src->audio_meta->samplerate;
 859                 _dst->audio_meta->duration = _src->audio_meta->duration;
 860                 _dst->audio_meta->bitrate = _src->audio_meta->bitrate;
 861                 _dst->audio_meta->bitpersample = _src->audio_meta->bitpersample;
 862         }
 863         *dst = (media_info_h)_dst;
 864
 865         return MEDIA_CONTENT_ERROR_NONE;
 866 }
 867
 868 int media_info_get_media_count_from_db(filter_h filter, int *media_count)
 869 {
 870         int ret = MEDIA_CONTENT_ERROR_NONE;
 871
 872         if (media_count == NULL) {
 873                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 874                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 875
 876                 return ret;
 877         }
 878
 879         ret = _media_db_get_group_item_count(NULL, filter, MEDIA_GROUP_NONE, media_count);
 880
 881         return ret;
 882 }
 883
 884 int media_info_foreach_media_from_db(filter_h filter, media_info_cb callback, void *user_data)
 885 {
 886         int ret = MEDIA_CONTENT_ERROR_NONE;
 887
 888         media_content_retvm_if(callback == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid callback");
 889
 890         ret = _media_db_get_group_item(NULL, filter, callback, user_data, MEDIA_GROUP_NONE);
 891
 892         return ret;
 893 }
 894
 895 int media_info_get_tag_count_from_db(const char *media_id, filter_h filter, int *tag_count)
 896 {
 897         int ret = MEDIA_CONTENT_ERROR_NONE;
 898
 899         if (STRING_VALID(media_id) && tag_count) {
 900                 ret = _media_db_get_group_item_count(media_id, filter, MEDIA_GROUP_TAG_BY_MEDIA_ID, tag_count);
 901         } else {
 902                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 903                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 904         }
 905
 906         return ret;
 907 }
 908
 909 int media_info_foreach_tag_from_db(const char *media_id, filter_h filter, media_tag_cb callback, void *user_data)
 910 {
 911         int ret = MEDIA_CONTENT_ERROR_NONE;
 912
 913         if ((callback != NULL) && STRING_VALID(media_id)) {
 914                 ret = _media_db_get_tag(media_id, filter, callback, user_data);
 915         } else {
 916                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 917                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 918         }
 919
 920         return ret;
 921 }
 922
 923 int media_info_get_bookmark_count_from_db(const char *media_id, filter_h filter, int *bookmark_count)
 924 {
 925         int ret = MEDIA_CONTENT_ERROR_NONE;
 926
 927         if (STRING_VALID(media_id) && bookmark_count) {
 928                 ret = _media_db_get_group_item_count(media_id, filter, MEDIA_GROUP_BOOKMARK_BY_MEDIA_ID, bookmark_count);
 929         } else {
 930                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 931                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 932         }
 933
 934         return ret;
 935 }
 936
 937 int media_info_foreach_bookmark_from_db(const char *media_id, filter_h filter, media_bookmark_cb callback, void *user_data)
 938 {
 939         int ret = MEDIA_CONTENT_ERROR_NONE;
 940
 941         if ((callback != NULL) && STRING_VALID(media_id)) {
 942                 ret = _media_db_get_bookmark(media_id, filter, callback, user_data);
 943         } else {
 944                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 945                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 946         }
 947
 948         return ret;
 949 }
 950
 951 int media_info_get_face_count_from_db(const char *media_id, filter_h filter, int *face_count)
 952 {
 953         int ret = MEDIA_CONTENT_ERROR_NONE;
 954
 955         if (STRING_VALID(media_id) && face_count) {
 956                 ret = _media_db_get_group_item_count(media_id, filter, MEDIA_GROUP_FACE_BY_MEDIA_ID, face_count);
 957         } else {
 958                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 959                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 960         }
 961
 962         return ret;
 963 }
 964
 965 int media_info_foreach_face_from_db(const char *media_id, filter_h filter, media_face_cb callback, void *user_data)
 966 {
 967         int ret = MEDIA_CONTENT_ERROR_NONE;
 968
 969         if ((callback != NULL) && STRING_VALID(media_id)) {
 970                 ret = _media_db_get_face(media_id, filter, callback, user_data);
 971         } else {
 972                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 973                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 974         }
 975
 976         return ret;
 977 }
 978
 979 int media_info_get_image(media_info_h media, image_meta_h *image)
 980 {
 981         int ret = MEDIA_CONTENT_ERROR_NONE;
 982
 983         media_info_s *_media = (media_info_s*)media;
 984
 985         media_content_retvm_if(_media == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid media");
 986         media_content_retvm_if(_media->media_type != MEDIA_CONTENT_TYPE_IMAGE, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid media_type");
 987         media_content_retvm_if(_media->image_meta == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid image_meta");
 988
 989         image_meta_s *_image = (image_meta_s*)calloc(1, sizeof(image_meta_s));
 990         media_content_retvm_if(_image == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 991
 992         _image->media_id = g_strdup(_media->media_id);
 993         _image->width = _media->image_meta->width;
 994         _image->height = _media->image_meta->height;
 995         _image->orientation = _media->image_meta->orientation;
 996         _image->fnumber = _media->image_meta->fnumber;
 997         _image->iso = _media->image_meta->iso;
 998         _image->date_taken = g_strdup(_media->image_meta->date_taken);
 999         _image->exposure_time = g_strdup(_media->image_meta->exposure_time);
1000         _image->model = g_strdup(_media->image_meta->model);
1001
1002         *image = (image_meta_h)_image;
1003
1004         return ret;
1005 }
1006
1007 int media_info_get_video(media_info_h media, video_meta_h *video)
1008 {
1009         int ret = MEDIA_CONTENT_ERROR_NONE;
1010
1011         media_info_s *_media = (media_info_s*)media;
1012
1013         media_content_retvm_if(_media == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid media");
1014         media_content_retvm_if(_media->media_type != MEDIA_CONTENT_TYPE_VIDEO, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid media_type");
1015         media_content_retvm_if(_media->video_meta == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid video_meta");
1016
1017         video_meta_s *_video = (video_meta_s*)calloc(1, sizeof(video_meta_s));
1018         media_content_retvm_if(_video == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
1019
1020         _video->media_id = g_strdup(_media->media_id);
1021         _video->album = g_strdup(_media->video_meta->album);
1022         _video->artist = g_strdup(_media->video_meta->artist);
1023         _video->album_artist = g_strdup(_media->video_meta->album_artist);
1024         _video->genre = g_strdup(_media->video_meta->genre);
1025         _video->composer = g_strdup(_media->video_meta->composer);
1026         _video->year = g_strdup(_media->video_meta->year);
1027         _video->recorded_date = g_strdup(_media->video_meta->recorded_date);
1028         _video->copyright = g_strdup(_media->video_meta->copyright);
1029         _video->track_num = g_strdup(_media->video_meta->track_num);
1030
1031         _video->width = _media->video_meta->width;
1032         _video->height = _media->video_meta->height;
1033         _video->duration = _media->video_meta->duration;
1034         _video->bitrate = _media->video_meta->bitrate;
1035         _video->rotation = _media->video_meta->rotation;
1036
1037         *video = (video_meta_h)_video;
1038
1039         return ret;
1040 }
1041
1042 int media_info_get_audio(media_info_h media, audio_meta_h *audio)
1043 {
1044         int ret = MEDIA_CONTENT_ERROR_NONE;
1045
1046         media_info_s *_media = (media_info_s*)media;
1047
1048         media_content_retvm_if(_media == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid media");
1049         media_content_retvm_if(_media->media_type != MEDIA_CONTENT_TYPE_MUSIC && _media->media_type != MEDIA_CONTENT_TYPE_SOUND, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid media_type");
1050         media_content_retvm_if(_media->audio_meta == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid audio_meta");
1051
1052         audio_meta_s *_audio = (audio_meta_s*)calloc(1, sizeof(audio_meta_s));
1053         media_content_retvm_if(_audio == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
1054
1055         _audio->media_id = g_strdup(_media->media_id);
1056         _audio->album = g_strdup(_media->audio_meta->album);
1057         _audio->artist = g_strdup(_media->audio_meta->artist);
1058         _audio->album_artist = g_strdup(_media->audio_meta->album_artist);
1059         _audio->genre = g_strdup(_media->audio_meta->genre);
1060         _audio->composer = g_strdup(_media->audio_meta->composer);
1061         _audio->year = g_strdup(_media->audio_meta->year);
1062         _audio->recorded_date = g_strdup(_media->audio_meta->recorded_date);
1063         _audio->copyright = g_strdup(_media->audio_meta->copyright);
1064         _audio->track_num = g_strdup(_media->audio_meta->track_num);
1065
1066         _audio->duration = _media->audio_meta->duration;
1067         _audio->bitrate = _media->audio_meta->bitrate;
1068         _audio->bitpersample = _media->audio_meta->bitpersample;
1069         _audio->samplerate = _media->audio_meta->samplerate;
1070         _audio->channel = _media->audio_meta->channel;
1071
1072         *audio = (audio_meta_h)_audio;
1073
1074         return ret;
1075 }
1076
1077 int media_info_get_media_id(media_info_h media, char **media_id)
1078 {
1079         int ret = MEDIA_CONTENT_ERROR_NONE;
1080         media_info_s *_media = (media_info_s*)media;
1081
1082         if (_media && media_id) {
1083                 if (STRING_VALID(_media->media_id)) {
1084                         *media_id = strdup(_media->media_id);
1085                         media_content_retvm_if(*media_id == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
1086                 } else {
1087                         *media_id = NULL;
1088                 }
1089                 ret = MEDIA_CONTENT_ERROR_NONE;
1090         } else {
1091                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1092                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1093         }
1094
1095         return ret;
1096 }
1097
1098 int media_info_get_file_path(media_info_h media, char **path)
1099 {
1100         int ret = MEDIA_CONTENT_ERROR_NONE;
1101         media_info_s *_media = (media_info_s*)media;
1102
1103         if (_media && path) {
1104                 if (STRING_VALID(_media->file_path)) {
1105                         *path = strdup(_media->file_path);
1106                         media_content_retvm_if(*path == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
1107                 } else {
1108                         *path = NULL;
1109                 }
1110                 ret = MEDIA_CONTENT_ERROR_NONE;
1111
1112         } else {
1113                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1114                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1115         }
1116
1117         return ret;
1118 }
1119
1120 int media_info_get_display_name(media_info_h media, char **name)
1121 {
1122         int ret = MEDIA_CONTENT_ERROR_NONE;
1123         media_info_s *_media = (media_info_s*)media;
1124         if (_media && name) {
1125                 if (_media->display_name != NULL) {
1126                         *name = g_strdup(_media->display_name);
1127                         media_content_retvm_if(*name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
1128                 } else {
1129                         *name = NULL;
1130                 }
1131                 ret = MEDIA_CONTENT_ERROR_NONE;
1132
1133         } else {
1134                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1135                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1136         }
1137
1138         return ret;
1139 }
1140
1141 int media_info_get_media_type(media_info_h media, media_content_type_e *type)
1142 {
1143         int ret = MEDIA_CONTENT_ERROR_NONE;
1144         media_info_s *_media = (media_info_s*)media;
1145         if (_media && type) {
1146                 *type = _media->media_type;
1147                 ret = MEDIA_CONTENT_ERROR_NONE;
1148         } else {
1149                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1150                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1151         }
1152
1153         return ret;
1154 }
1155
1156 int media_info_get_mime_type(media_info_h media, char **mime_type)
1157 {
1158         int ret = MEDIA_CONTENT_ERROR_NONE;
1159         media_info_s *_media = (media_info_s*)media;
1160
1161         if (_media && mime_type) {
1162                 if (STRING_VALID(_media->mime_type)) {
1163                         *mime_type = strdup(_media->mime_type);
1164                         media_content_retvm_if(*mime_type == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
1165                 } else {
1166                         *mime_type = NULL;
1167                 }
1168                 ret = MEDIA_CONTENT_ERROR_NONE;
1169         } else {
1170                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1171                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1172         }
1173
1174         return ret;
1175 }
1176
1177 int media_info_get_size(media_info_h media, unsigned long long *size)
1178 {
1179         int ret = MEDIA_CONTENT_ERROR_NONE;
1180         media_info_s *_media = (media_info_s*)media;
1181
1182         if (_media && size) {
1183                 *size = _media->size;
1184                 ret = MEDIA_CONTENT_ERROR_NONE;
1185         } else {
1186                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1187                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1188         }
1189
1190         return ret;
1191 }
1192
1193 int media_info_get_added_time(media_info_h media, time_t *added_time)
1194 {
1195         int ret = MEDIA_CONTENT_ERROR_NONE;
1196         media_info_s *_media = (media_info_s*)media;
1197         if (_media && added_time) {
1198                 *added_time = _media->added_time;
1199                 ret = MEDIA_CONTENT_ERROR_NONE;
1200         } else {
1201                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1202                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1203         }
1204
1205         return ret;
1206 }
1207
1208 int media_info_get_modified_time(media_info_h media, time_t* time)
1209 {
1210         int ret = MEDIA_CONTENT_ERROR_NONE;
1211         media_info_s *_media = (media_info_s*)media;
1212         if (_media && time) {
1213                 *time = _media->modified_time;
1214                 ret = MEDIA_CONTENT_ERROR_NONE;
1215         } else {
1216                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1217                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1218         }
1219
1220         return ret;
1221 }
1222
1223 int media_info_get_timeline(media_info_h media, time_t* time)
1224 {
1225         int ret = MEDIA_CONTENT_ERROR_NONE;
1226         media_info_s *_media = (media_info_s*)media;
1227         if (_media && time) {
1228                 *time = _media->timeline;
1229                 ret = MEDIA_CONTENT_ERROR_NONE;
1230         } else {
1231                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1232                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1233         }
1234
1235         return ret;
1236 }
1237
1238 int media_info_get_thumbnail_path(media_info_h media, char **path)
1239 {
1240         int ret = MEDIA_CONTENT_ERROR_NONE;
1241         media_info_s *_media = (media_info_s*)media;
1242         if (_media && path) {
1243                 if (_media->thumbnail_path != NULL) {
1244                         *path = g_strdup(_media->thumbnail_path);
1245                         media_content_retvm_if(*path == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
1246                 } else {
1247                         *path = NULL;
1248                 }
1249                 ret = MEDIA_CONTENT_ERROR_NONE;
1250
1251         } else {
1252                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1253                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1254         }
1255
1256         return ret;
1257 }
1258
1259 int media_info_get_title(media_info_h media, char **title)
1260 {
1261         int ret = MEDIA_CONTENT_ERROR_NONE;
1262         media_info_s *_media = (media_info_s*)media;
1263
1264         if (_media && title)    { /*title can be empty string*/
1265                 if (_media->title != NULL) {
1266                         *title = g_strdup(_media->title);
1267                         media_content_retvm_if(*title == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
1268                 } else {
1269                         *title = NULL;
1270                 }
1271                 ret = MEDIA_CONTENT_ERROR_NONE;
1272         } else {
1273                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1274                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1275         }
1276
1277         return ret;
1278 }
1279
1280 int media_info_get_description(media_info_h media, char **description)
1281 {
1282         int ret = MEDIA_CONTENT_ERROR_NONE;
1283         media_info_s *_media = (media_info_s*)media;
1284
1285         if (_media && description) {
1286                 if (_media->description != NULL) {      /*description can be empty string*/
1287                         *description = g_strdup(_media->description);
1288                         media_content_retvm_if(*description == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
1289                 } else {
1290                         *description = NULL;
1291                 }
1292                 ret = MEDIA_CONTENT_ERROR_NONE;
1293         } else {
1294                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1295                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1296         }
1297
1298         return ret;
1299 }
1300
1301 int media_info_get_longitude(media_info_h media, double* longitude)
1302 {
1303         int ret = MEDIA_CONTENT_ERROR_NONE;
1304         media_info_s *_media = (media_info_s*)media;
1305
1306         if (_media && longitude) {
1307                 *longitude = _media->longitude;
1308                 ret = MEDIA_CONTENT_ERROR_NONE;
1309         } else {
1310                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1311                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1312         }
1313
1314         return ret;
1315 }
1316 int media_info_get_latitude(media_info_h media, double* latitude)
1317 {
1318         int ret = MEDIA_CONTENT_ERROR_NONE;
1319         media_info_s *_media = (media_info_s*)media;
1320
1321         if (_media && latitude) {
1322                 *latitude = _media->latitude;
1323                 ret = MEDIA_CONTENT_ERROR_NONE;
1324         } else {
1325                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1326                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1327         }
1328
1329         return ret;
1330 }
1331
1332 int media_info_get_altitude(media_info_h media, double *altitude)
1333 {
1334         int ret = MEDIA_CONTENT_ERROR_NONE;
1335         media_info_s *_media = (media_info_s*)media;
1336
1337         if (_media && altitude) {
1338                 *altitude = _media->altitude;
1339                 ret = MEDIA_CONTENT_ERROR_NONE;
1340         } else {
1341                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1342                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1343         }
1344
1345         return ret;
1346 }
1347
1348 int media_info_get_rating(media_info_h media, int *rating)
1349 {
1350         int ret = MEDIA_CONTENT_ERROR_NONE;
1351         media_info_s *_media = (media_info_s*)media;
1352
1353         if (_media && rating) {
1354                 *rating = _media->rating;
1355                 ret = MEDIA_CONTENT_ERROR_NONE;
1356         } else {
1357                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1358                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1359         }
1360
1361         return ret;
1362 }
1363
1364 int media_info_get_favorite(media_info_h media, bool* favorite)
1365 {
1366         int ret = MEDIA_CONTENT_ERROR_NONE;
1367         media_info_s *_media = (media_info_s*)media;
1368
1369         if (_media && favorite) {
1370                 *favorite = _media->favourite;
1371                 ret = MEDIA_CONTENT_ERROR_NONE;
1372         } else {
1373                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1374                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1375         }
1376
1377         return ret;
1378 }
1379
1380 int media_info_get_storage_id(media_info_h media, char **storage_id)
1381 {
1382         int ret = MEDIA_CONTENT_ERROR_NONE;
1383         media_content_warn("DEPRECATION WARNING: media_info_get_storage_id() is deprecated and will be removed from next release.");
1384         media_info_s *_media = (media_info_s*)media;
1385
1386         if (_media && storage_id) {
1387                 if (STRING_VALID(_media->storage_uuid)) {
1388                         *storage_id = strdup(_media->storage_uuid);
1389                         media_content_retvm_if(*storage_id == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
1390                 } else {
1391                         *storage_id = NULL;
1392                         ret = MEDIA_CONTENT_ERROR_DB_FAILED;
1393                 }
1394         } else {
1395                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1396                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1397         }
1398
1399         return ret;
1400 }
1401
1402 int media_info_is_drm(media_info_h media, bool *is_drm)
1403 {
1404         int ret = MEDIA_CONTENT_ERROR_NONE;
1405         media_info_s *_media = (media_info_s*)media;
1406
1407         if (_media) {
1408                 *is_drm = _media->is_drm;
1409                 ret = MEDIA_CONTENT_ERROR_NONE;
1410         } else {
1411                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1412                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1413         }
1414
1415         return ret;
1416 }
1417
1418 int media_info_is_360_content(media_info_h media, bool *is_360)
1419 {
1420         int ret = MEDIA_CONTENT_ERROR_NONE;
1421         media_info_s *_media = (media_info_s*)media;
1422
1423         if (_media) {
1424                 *is_360 = _media->is_360;
1425                 ret = MEDIA_CONTENT_ERROR_NONE;
1426         } else {
1427                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1428                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1429         }
1430
1431         return ret;
1432 }
1433
1434 int media_info_get_storage_type(media_info_h media, media_content_storage_e *storage_type)
1435 {
1436         int ret = MEDIA_CONTENT_ERROR_NONE;
1437         media_content_warn("DEPRECATION WARNING: media_info_get_storage_type() is deprecated and will be removed from next release. Use storage_get_type_dev() instead.");
1438         media_info_s *_media = (media_info_s*)media;
1439
1440         if (_media && storage_type) {
1441                 *storage_type = _media->storage_type;
1442                 ret = MEDIA_CONTENT_ERROR_NONE;
1443         } else {
1444                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1445                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1446         }
1447
1448         return ret;
1449 }
1450
1451 #ifdef _USE_SENIOR_MODE
1452 int media_info_set_contact(media_info_h media, const char *contact)
1453 {
1454         int ret = MEDIA_CONTENT_ERROR_NONE;
1455         media_info_s *_media = (media_info_s*)media;
1456
1457         if (_media != NULL) {
1458                 SAFE_FREE(_media->contact);
1459                 if (STRING_VALID(contact)) {
1460                         _media->contact = strdup(contact);
1461                         media_content_retvm_if(_media->contact == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
1462                 } else {
1463                         _media->contact = NULL;
1464                 }
1465         } else {
1466                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1467                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1468         }
1469
1470         return ret;
1471 }
1472
1473 int media_info_set_app_data(media_info_h media, const char *app_data)
1474 {
1475         int ret = MEDIA_CONTENT_ERROR_NONE;
1476         media_info_s *_media = (media_info_s*)media;
1477
1478         if (_media != NULL) {
1479                 SAFE_FREE(_media->app_data);
1480                 if (STRING_VALID(app_data)) {
1481                         _media->app_data = strdup(app_data);
1482                         media_content_retvm_if(_media->app_data == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
1483                 } else {
1484                         _media->app_data = NULL;
1485                 }
1486         } else {
1487                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1488                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1489         }
1490
1491         return ret;
1492 }
1493
1494 int media_info_insert_to_db_with_contact_data(const char *path, const char* contact, const char* app_data, media_info_h *info)
1495 {
1496         int ret = media_info_insert_to_db(path, info);
1497         media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "media_info_insert_to_db [%s] failed", path);
1498
1499         ret = media_info_set_contact(*info, contact);
1500         if (ret != MEDIA_CONTENT_ERROR_NONE) {
1501                 media_content_error("media_info_set_contact [%s] failed", contact);
1502
1503                 media_info_s* _media_info = (media_info_s*)*info;
1504                 ret = media_info_delete_from_db(_media_info->media_id);
1505                 media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "media_info_delete_from_db [%s] failed", _media_info->media_id);
1506
1507                 media_info_destroy(*info);
1508                 return ret;
1509         }
1510
1511         ret = media_info_set_app_data(*info, app_data);
1512         if (ret != MEDIA_CONTENT_ERROR_NONE) {
1513                 media_content_error("media_info_set_app_data [%s] failed", app_data);
1514
1515                 media_info_s* _media_info = (media_info_s*)*info;
1516                 ret = media_info_delete_from_db(_media_info->media_id);
1517                 media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "media_info_delete_from_db [%s] failed", _media_info->media_id);
1518
1519                 media_info_destroy(*info);
1520                 return ret;
1521         }
1522
1523         ret = media_info_update_to_db(*info);
1524         if (ret != MEDIA_CONTENT_ERROR_NONE) {
1525                 media_content_error("media_info_update_to_db [] failed");
1526
1527                 media_info_s* _media_info = (media_info_s*)*info;
1528                 ret = media_info_delete_from_db(_media_info->media_id);
1529                 media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "media_info_delete_from_db [%s] failed", _media_info->media_id);
1530
1531                 media_info_destroy(*info);
1532                 return ret;
1533         }
1534
1535         return ret;
1536 }
1537
1538 int media_info_delete_contact_from_db(const char* contact, const char* storage_id)
1539 {
1540         return -1;
1541 }
1542
1543 int media_info_delete_item(const char *media_id)
1544 {
1545         int ret = MEDIA_CONTENT_ERROR_NONE;
1546         char *path = NULL;
1547         char *storage_id = NULL;
1548
1549         if (!STRING_VALID(media_id)) {
1550                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1551                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1552         }
1553
1554         ret = __media_info_get_media_path_by_id_from_db(media_id, &path);
1555         if (ret != MEDIA_CONTENT_ERROR_NONE) {
1556                 media_content_error("__media_info_get_media_path_by_id_from_db failed : %d", ret);
1557                 SAFE_FREE(path);
1558                 return ret;
1559         }
1560
1561         ret = _media_db_get_storage_id_by_media_id(media_id, &storage_id);
1562         if (ret != MEDIA_CONTENT_ERROR_NONE) {
1563                 media_content_error("_media_db_get_storage_id_by_media_id failed : %d", ret);
1564                 SAFE_FREE(path);
1565                 return ret;
1566         }
1567
1568         ret = media_svc_delete_item_by_path(_content_get_db_handle(), storage_id, path, tzplatform_getuid(TZ_USER_NAME));
1569         SAFE_FREE(storage_id);
1570         if (ret != MEDIA_CONTENT_ERROR_NONE) {
1571                 media_content_error("remove from DB failed : %d", ret);
1572                 SAFE_FREE(path);
1573                 return ret;
1574         }
1575
1576         ret = media_svc_remove_file(path);
1577         SAFE_FREE(path);
1578         return _content_error_capi(ret);
1579 }
1580
1581 int media_info_get_contact(media_info_h media, char **contact)
1582 {
1583         int ret = MEDIA_CONTENT_ERROR_NONE;
1584         media_info_s *_media = (media_info_s*)media;
1585
1586         if (_media && contact) {
1587                 if (STRING_VALID(_media->contact)) {
1588                         *contact = strdup(_media->contact);
1589                         if (*contact == NULL) {
1590                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1591                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1592                         }
1593                 } else {
1594                         *contact = NULL;
1595                 }
1596                 ret = MEDIA_CONTENT_ERROR_NONE;
1597         } else {
1598                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1599                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1600         }
1601
1602         return ret;
1603 }
1604
1605 int media_info_get_app_data(media_info_h media, char **app_data)
1606 {
1607         int ret = MEDIA_CONTENT_ERROR_NONE;
1608         media_info_s *_media = (media_info_s*)media;
1609
1610         if (_media && app_data) {
1611                 if (STRING_VALID(_media->app_data)) {
1612                         *app_data = strdup(_media->app_data);
1613                         if (*app_data == NULL) {
1614                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1615                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1616                         }
1617                 } else {
1618                         *app_data = NULL;
1619                 }
1620                 ret = MEDIA_CONTENT_ERROR_NONE;
1621         } else {
1622                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1623                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1624         }
1625
1626         return ret;
1627 }
1628 #endif
1629 #ifdef _USE_TVPD_MODE
1630 int media_info_get_played_count(media_info_h media, int *played_count)
1631 {
1632         int ret = MEDIA_CONTENT_ERROR_NONE;
1633         media_info_s *_media = (media_info_s*)media;
1634
1635         if (_media) {
1636                 *played_count = _media->played_count;
1637                 ret = MEDIA_CONTENT_ERROR_NONE;
1638         } else {
1639                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1640                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1641         }
1642
1643         return ret;
1644 }
1645
1646 int media_info_set_played_count(media_info_h media, int played_count)
1647 {
1648         int ret = MEDIA_CONTENT_ERROR_NONE;
1649
1650         media_info_s *_media = (media_info_s*)media;
1651
1652         if (_media) {
1653                 _media->played_count = played_count;
1654         } else {
1655                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1656                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1657         }
1658
1659         return ret;
1660 }
1661
1662 int media_info_set_played_position(media_info_h media, int played_position)
1663 {
1664         int ret = MEDIA_CONTENT_ERROR_NONE;
1665         media_info_s *_media = (media_info_s*)media;
1666
1667         if ((_media != NULL) && (played_position >= 0)) {
1668                 _media->played_position = played_position;
1669         } else {
1670                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1671                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1672         }
1673
1674         return ret;
1675 }
1676
1677 int media_info_get_played_position(media_info_h media, int *played_position)
1678 {
1679         int ret = MEDIA_CONTENT_ERROR_NONE;
1680         media_info_s *_media = (media_info_s*)media;
1681
1682         if (_media) {
1683                 *played_position = _media->played_position;
1684                 ret = MEDIA_CONTENT_ERROR_NONE;
1685         } else {
1686                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1687                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1688         }
1689
1690         return ret;
1691 }
1692
1693 int media_info_set_played_time(media_info_h media)
1694 {
1695         int ret = MEDIA_CONTENT_ERROR_NONE;
1696         time_t current_time;
1697
1698         media_info_s *_media = (media_info_s*)media;
1699
1700         if (_media != NULL) {
1701                 time(&current_time);
1702                 _media->played_time = current_time;
1703         } else {
1704                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1705                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1706         }
1707
1708         return ret;
1709 }
1710
1711 int media_info_get_played_time(media_info_h media, time_t* played_time)
1712 {
1713         int ret = MEDIA_CONTENT_ERROR_NONE;
1714         media_info_s *_media = (media_info_s*)media;
1715
1716         if (_media) {
1717                 *played_time = _media->played_time;
1718                 ret = MEDIA_CONTENT_ERROR_NONE;
1719         } else {
1720                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1721                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1722         }
1723
1724         return ret;
1725 }
1726
1727 int media_info_get_extract_flag(media_info_h media, int *extract_flag)
1728 {
1729         int ret = MEDIA_CONTENT_ERROR_NONE;
1730         media_info_s *_media = (media_info_s *)media;
1731
1732         if (_media && extract_flag) {
1733                 *extract_flag = _media->extract_flag;
1734                 ret = MEDIA_CONTENT_ERROR_NONE;
1735         } else {
1736                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1737                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1738         }
1739
1740         return ret;
1741 }
1742
1743 int media_info_get_stitched_state(media_info_h media, int *stitched_info)
1744 {
1745         int ret = MEDIA_CONTENT_ERROR_NONE;
1746         media_info_s *_media = (media_info_s*)media;
1747
1748         if (_media) {
1749                 *stitched_info = (_media->stitched_info & 0xFFFF0000) >> 16;
1750                 ret = MEDIA_CONTENT_ERROR_NONE;
1751         } else {
1752                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1753                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1754         }
1755
1756         return ret;
1757 }
1758
1759 int media_info_get_stitched_engine(media_info_h media, int *stitched_info)
1760 {
1761         int ret = MEDIA_CONTENT_ERROR_NONE;
1762         media_info_s *_media = (media_info_s*)media;
1763
1764         if (_media) {
1765                 *stitched_info = _media->stitched_info & 0x0000FFFF;
1766                 ret = MEDIA_CONTENT_ERROR_NONE;
1767         } else {
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_modified_month(media_info_h media, char **modified_month)
1776 {
1777         int ret = MEDIA_CONTENT_ERROR_NONE;
1778         media_info_s *_media = (media_info_s*)media;
1779
1780         if (_media && modified_month) {
1781                 if (STRING_VALID(_media->modified_month)) {
1782                         *modified_month = strdup(_media->modified_month);
1783                         if (*modified_month == NULL) {
1784                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1785                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1786                         }
1787                 } else {
1788                         *modified_month = NULL;
1789                 }
1790                 ret = MEDIA_CONTENT_ERROR_NONE;
1791         } else {
1792                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1793                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1794         }
1795
1796         return ret;
1797 }
1798
1799 #endif
1800
1801 int media_info_get_media_from_db(const char *media_id, media_info_h *media)
1802 {
1803         int ret = MEDIA_CONTENT_ERROR_NONE;
1804         char select_query[DEFAULT_QUERY_SIZE] = {0, };
1805         sqlite3_stmt *stmt = NULL;
1806
1807         if (!STRING_VALID(media_id) || (media == NULL)) {
1808                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1809                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1810         }
1811
1812         memset(select_query, 0x00, sizeof(select_query));
1813
1814 #ifdef _USE_TVPD_MODE
1815         char *storage_id = NULL;
1816
1817         ret = _media_db_get_storage_id_by_media_id(media_id, &storage_id);
1818         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1819         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_MEDIA, storage_id, media_id);
1820         SAFE_FREE(storage_id);
1821 #else
1822         snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_MEDIA, media_id);
1823 #endif
1824         ret = _content_get_result(select_query, &stmt);
1825         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1826
1827         media_info_s *_media = NULL;
1828
1829         if (sqlite3_step(stmt) == SQLITE_ROW) {
1830                 _media = (media_info_s*)calloc(1, sizeof(media_info_s));
1831
1832                 if (_media == NULL) {
1833                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1834                         SQLITE3_FINALIZE(stmt);
1835                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1836                 }
1837
1838                 _media_info_item_get_detail(stmt, (media_info_h)_media);
1839
1840                 *media = (media_info_h)_media;
1841         } else {
1842                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1843         }
1844
1845         SQLITE3_FINALIZE(stmt);
1846
1847         return ret;
1848 }
1849
1850 int media_info_set_favorite(media_info_h media, bool favorite)
1851 {
1852         int ret = MEDIA_CONTENT_ERROR_NONE;
1853         media_info_s *_media = (media_info_s*)media;
1854
1855         if (_media != NULL) {
1856                 if (favorite == TRUE)
1857                         time(&_media->favourite);
1858                 else
1859                         _media->favourite = 0;
1860         } else {
1861                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1862                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1863         }
1864
1865         return ret;
1866 }
1867
1868 int media_info_update_to_db(media_info_h media)
1869 {
1870         int ret = MEDIA_CONTENT_ERROR_NONE;
1871         media_info_s *_media = (media_info_s*)media;
1872         char *set_sql = NULL;
1873         char *sql = NULL;
1874
1875         if (_media != NULL && STRING_VALID(_media->media_id)) {
1876                 /* This sql is due to sqlite3_mprintf's wrong operation when using floating point in the text format */
1877                 /* This code will be removed when sqlite3_mprintf works clearly */
1878                 char *test_sql = sqlite3_mprintf("%f, %f, %f", _media->longitude, _media->latitude, _media->altitude);
1879                 SQLITE3_SAFE_FREE(test_sql);
1880
1881                 /*Update Pinyin If Support Pinyin*/
1882                 char *file_name_pinyin = NULL;
1883                 char *description_pinyin = NULL;
1884                 bool pinyin_support = FALSE;
1885
1886                 /*Update Pinyin If Support Pinyin*/
1887                 media_svc_check_pinyin_support(&pinyin_support);
1888                 if (pinyin_support) {
1889                         if (STRING_VALID(_media->display_name))
1890                                 media_svc_get_pinyin(_media->display_name, &file_name_pinyin);
1891                         if (STRING_VALID(_media->description))
1892                                 media_svc_get_pinyin(_media->description, &description_pinyin);
1893                 }
1894 #ifdef _USE_TVPD_MODE
1895 #ifdef _USE_SENIOR_MODE
1896                 if (_media_content_is_support_senior_mode()) {
1897                         set_sql = sqlite3_mprintf("media_display_name=%Q, media_description=%Q, media_longitude=%f, media_latitude=%f, media_file_name_pinyin=%Q, media_description_pinyin=%Q, played_count=%d, last_played_time=%d, last_played_position=%d, media_rating=%d, media_favourite=%d, contact=%Q, app_data=%Q",
1898                                 _media->display_name, _media->description, _media->longitude, _media->latitude, file_name_pinyin, description_pinyin, _media->played_count, _media->played_time, _media->played_position, _media->rating, _media->favourite, _media->contact, _media->app_data);
1899                 } else
1900 #endif
1901                 {
1902                         set_sql = sqlite3_mprintf("media_display_name=%Q, media_description=%Q, media_longitude=%f, media_latitude=%f, media_file_name_pinyin=%Q, media_description_pinyin=%Q, played_count=%d, last_played_time=%d, last_played_position=%d, media_rating=%d, media_favourite=%d",
1903                                 _media->display_name, _media->description, _media->longitude, _media->latitude, file_name_pinyin, description_pinyin, _media->played_count, _media->played_time, _media->played_position, _media->rating, _media->favourite);
1904                 }
1905 #else
1906                 set_sql = sqlite3_mprintf("media_display_name=%Q, media_description=%Q, media_longitude=%f, media_latitude=%f, media_file_name_pinyin=%Q, media_description_pinyin=%Q, media_rating=%d, media_favourite=%d", _media->display_name, _media->description, _media->longitude, _media->latitude, file_name_pinyin, description_pinyin, _media->rating, _media->favourite);
1907 #endif
1908 #ifdef _USE_TVPD_MODE
1909                 sql = sqlite3_mprintf("UPDATE %Q SET %s WHERE media_id=%Q", _media->storage_uuid, set_sql, _media->media_id);
1910 #else
1911                 sql = sqlite3_mprintf("UPDATE %q SET %s WHERE media_id=%Q", DB_TABLE_MEDIA, set_sql, _media->media_id);
1912 #endif
1913                 ret = _content_query_sql(sql);
1914                 SQLITE3_SAFE_FREE(set_sql);
1915                 SQLITE3_SAFE_FREE(sql);
1916
1917                 SAFE_FREE(file_name_pinyin);
1918                 SAFE_FREE(description_pinyin);
1919
1920                 if (ret == MEDIA_CONTENT_ERROR_NONE) {
1921                         /* Send notification for this update */
1922                         media_content_debug("Update is successfull. Send notification for this");
1923                         if (_media->file_path && _media->mime_type)
1924                                 media_svc_publish_noti(MS_MEDIA_ITEM_UPDATE, _media->file_path, _media->media_type, _media->media_id, _media->mime_type);
1925                         else
1926                                 media_content_error("Can't Send Noti : path or mime type is NULL");
1927                 }
1928         } else {
1929                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1930                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1931         }
1932
1933         return ret;
1934 }
1935
1936 int media_info_move_to_db(media_info_h media, const char* dst_path)
1937 {
1938         int ret = MEDIA_CONTENT_ERROR_NONE;
1939         char repl_path[MAX_PATH_LEN] = {0, };
1940
1941         media_content_retvm_if(media == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid media");
1942         media_content_retvm_if(!STRING_VALID(dst_path), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid dst_path");
1943         memset(repl_path, 0, sizeof(repl_path));
1944         ret = _media_content_replace_path(dst_path, repl_path);
1945         media_content_retvm_if(!STRING_VALID(repl_path), MEDIA_CONTENT_ERROR_INVALID_OPERATION, "path replacement failed");
1946
1947         media_info_s *_media = (media_info_s*)media;
1948
1949         /* If dst_path is folder, append file_name */
1950         if (g_file_test(repl_path, G_FILE_TEST_IS_DIR)) {
1951                 if (repl_path[strlen(repl_path) - 1] != '/')
1952                         SAFE_STRLCAT(repl_path, "/", sizeof(repl_path));
1953
1954                 SAFE_STRLCAT(repl_path, _media->display_name, sizeof(repl_path));
1955         }
1956
1957         /* If the two paths are the same, do nothing */
1958         media_content_retvm_if(g_strcmp0(repl_path, _media->file_path) == 0, MEDIA_CONTENT_ERROR_NONE, "Same path");
1959
1960         ret = __media_info_check_file_validity(repl_path);
1961         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
1962
1963         ret = media_svc_move_item(_content_get_db_handle(), _media->file_path, repl_path, _media->media_id, _media->media_type, _media->mime_type, _content_get_uid());
1964         return _content_error_capi(ret);
1965 }
1966
1967 int media_info_create_thumbnail(media_info_h media, media_thumbnail_completed_cb callback, void *user_data)
1968 {
1969         int ret = MEDIA_CONTENT_ERROR_NONE;
1970         media_content_warn("DEPRECATION WARNING: media_info_create_thumbnail() is deprecated and will be removed from next release. Use media_info_generate_thumbnail() instead.");
1971         static unsigned int req_id = 0;
1972         media_info_s *_media = (media_info_s*)media;
1973
1974         if (_media != NULL && STRING_VALID(_media->media_id) && STRING_VALID(_media->file_path)) {
1975                 media_thumbnail_cb_s *_thumb_cb = (media_thumbnail_cb_s*)calloc(1, sizeof(media_thumbnail_cb_s));
1976                 media_content_retvm_if(_thumb_cb == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
1977                 req_id++;
1978                 _media->request_id = req_id;
1979
1980                 _thumb_cb->handle = _media;
1981                 _thumb_cb->user_data = user_data;
1982                 _thumb_cb->thumbnail_completed_cb = callback;
1983
1984                 ret = thumbnail_request_from_db_async(_media->request_id, _media->file_path, (ThumbFunc)__media_info_thumbnail_completed_cb, (void *)_thumb_cb, _content_get_uid());
1985                 ret = _content_error_capi(ret);
1986         } else {
1987                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1988                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1989         }
1990
1991         return ret;
1992 }
1993
1994 int media_info_generate_thumbnail(media_info_h media)
1995 {
1996         int ret = MEDIA_CONTENT_ERROR_NONE;
1997         char *thumb_path = NULL;
1998         media_info_s *_media = (media_info_s*)media;
1999
2000         if (_media != NULL && STRING_VALID(_media->media_id) && STRING_VALID(_media->file_path)) {
2001                 /* Already exists */
2002                 if (STRING_VALID(_media->thumbnail_path))
2003                         return MEDIA_CONTENT_ERROR_NONE;
2004
2005                 ret = media_svc_create_thumbnail(_media->file_path, _media->media_type, _content_get_uid(), &thumb_path);
2006                 ret = _content_error_capi(ret);
2007                 if (ret == MEDIA_CONTENT_ERROR_UNSUPPORTED_CONTENT) {
2008                         SAFE_FREE(thumb_path);
2009                         return ret;
2010                 }
2011
2012                 /* thumb_path is not NULL except #MEDIA_CONTENT_ERROR_UNSUPPORTED_CONTENT */
2013                 _media->thumbnail_path = g_strdup(thumb_path);
2014                 SAFE_FREE(thumb_path);
2015                 if (_media->thumbnail_path == NULL)
2016                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
2017         } else {
2018                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2019                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2020         }
2021
2022         return ret;
2023 }
2024
2025 int media_info_cancel_thumbnail(media_info_h media)
2026 {
2027         int ret = MEDIA_CONTENT_ERROR_NONE;
2028         media_content_warn("DEPRECATION WARNING: media_info_cancel_thumbnail() is deprecated and will be removed from next release.");
2029         media_info_s *_media = (media_info_s*)media;
2030
2031         if (_media != NULL && STRING_VALID(_media->media_id) && _media->request_id > 0) {
2032                 ret = thumbnail_request_cancel_media(_media->request_id);
2033                 ret = _content_error_capi(ret);
2034         } else {
2035                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2036                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2037         }
2038
2039         return ret;
2040 }
2041
2042 int media_info_start_face_detection(media_info_h media, media_face_detection_completed_cb callback, void *user_data)
2043 {
2044         int ret = MEDIA_CONTENT_ERROR_NONE;
2045         static unsigned int req_id = 0;
2046         media_info_s *_media = (media_info_s*)media;
2047
2048         if (!__media_info_isFaceRecognition_feature_supported()) {
2049                 media_content_error("NOT_SUPPORTED(0x%08x)", MEDIA_CONTENT_ERROR_NOT_SUPPORTED);
2050                 return MEDIA_CONTENT_ERROR_NOT_SUPPORTED;
2051         }
2052
2053         if (_media != NULL && STRING_VALID(_media->media_id) && STRING_VALID(_media->file_path)) {
2054                 if (g_strcmp0(_media->mime_type, "image/jpeg") != 0 && g_strcmp0(_media->mime_type, "image/png") != 0 && g_strcmp0(_media->mime_type, "image/bmp") != 0) {
2055                         media_content_error("Unsupported mime type");
2056                         return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2057                 }
2058
2059                 media_face_cb_s *_face_cb = (media_face_cb_s*)calloc(1, sizeof(media_face_cb_s));
2060                 media_content_retvm_if(_face_cb == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
2061                 req_id++;
2062                 _media->face_request_id = req_id;
2063
2064                 _face_cb->user_data = user_data;
2065                 _face_cb->face_completed_cb = callback;
2066
2067                 ret = dcm_request_extract_face_async(_media->face_request_id, _media->file_path, (FaceFunc)__media_info_face_completed_cb, (void *)_face_cb, _content_get_uid());
2068                 ret = _content_error_capi(ret);
2069         } else {
2070                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2071                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2072         }
2073
2074         return ret;
2075 }
2076
2077 int media_info_cancel_face_detection(media_info_h media)
2078 {
2079         int ret = MEDIA_CONTENT_ERROR_NONE;
2080         media_info_s *_media = (media_info_s*)media;
2081
2082         if (!__media_info_isFaceRecognition_feature_supported()) {
2083                 media_content_error("NOT_SUPPORTED(0x%08x)", MEDIA_CONTENT_ERROR_NOT_SUPPORTED);
2084                 return MEDIA_CONTENT_ERROR_NOT_SUPPORTED;
2085         }
2086
2087         if (_media != NULL && STRING_VALID(_media->media_id) && _media->face_request_id > 0) {
2088                 ret = dcm_request_cancel_face(_media->face_request_id);
2089                 ret = _content_error_capi(ret);
2090         } else {
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_set_description(media_info_h media, const char *description)
2099 {
2100         int ret = MEDIA_CONTENT_ERROR_NONE;
2101         media_content_warn("DEPRECATION WARNING: media_info_set_description() is deprecated and will be removed from next release.");
2102         media_info_s *_media = (media_info_s*)media;
2103
2104         if (_media != NULL) {
2105                 SAFE_FREE(_media->description);
2106
2107                 if (STRING_VALID(description)) {
2108                         _media->description = strdup(description);
2109                         media_content_retvm_if(_media->description == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
2110                 } else {
2111                         _media->description = NULL;
2112                 }
2113         } else {
2114                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2115                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2116         }
2117
2118         return ret;
2119 }
2120
2121 int media_info_set_longitude(media_info_h media, double longitude)
2122 {
2123         int ret = MEDIA_CONTENT_ERROR_NONE;
2124         media_content_warn("DEPRECATION WARNING: media_info_set_longitude() is deprecated and will be removed from next release.");
2125         media_info_s *_media = (media_info_s*)media;
2126
2127         if (_media != NULL) {
2128                 _media->longitude = longitude;
2129         } else {
2130                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2131                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2132         }
2133
2134         return ret;
2135 }
2136
2137 int media_info_set_latitude(media_info_h media, double latitude)
2138 {
2139         int ret = MEDIA_CONTENT_ERROR_NONE;
2140         media_content_warn("DEPRECATION WARNING: media_info_set_latitude() is deprecated and will be removed from next release.");
2141         media_info_s *_media = (media_info_s*)media;
2142
2143         if (_media != NULL) {
2144                 _media->latitude = latitude;
2145         } else {
2146                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2147                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2148         }
2149
2150         return ret;
2151 }
2152
2153 int media_info_set_rating(media_info_h media, int rating)
2154 {
2155         int ret = MEDIA_CONTENT_ERROR_NONE;
2156         media_content_warn("DEPRECATION WARNING: media_info_set_rating() is deprecated and will be removed from next release.");
2157         media_info_s *_media = (media_info_s*)media;
2158
2159         if (_media != NULL) {
2160                 _media->rating = rating;
2161         } else {
2162                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
2163                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
2164         }
2165
2166         return ret;
2167 }
2168
2169 #ifdef TIZEN_FEATURE_COMPATIBILITY
2170 int media_info_set_added_time(media_info_h media, time_t added_time)
2171 {
2172         media_content_warn("DEPRECATION WARNING: media_info_set_added_time() is removed from 5.5.");
2173
2174         return MEDIA_CONTENT_ERROR_NONE;
2175 }
2176
2177 int media_info_delete_batch_from_db(filter_h filter)
2178 {
2179         media_content_warn("DEPRECATION WARNING: media_info_delete_batch_from_db() is removed from 5.5.");
2180
2181         return MEDIA_CONTENT_ERROR_NONE;
2182 }
2183
2184 int media_info_create(const char *path, media_info_h *media)
2185 {
2186         media_content_warn("DEPRECATION WARNING: media_info_create() is removed from 5.5.");
2187
2188         return MEDIA_CONTENT_ERROR_NONE;
2189 }
2190
2191 int media_info_refresh_metadata_to_db(const char *media_id)
2192 {
2193         media_content_warn("DEPRECATION WARNING: media_info_refresh_metadata_to_db() is removed from 5.5.");
2194
2195         return MEDIA_CONTENT_ERROR_NONE;
2196 }
2197
2198 int media_info_set_display_name(media_info_h media, const char *display_name)
2199 {
2200         media_content_warn("DEPRECATION WARNING: media_info_set_display_name() is removed from 5.5.");
2201
2202         return MEDIA_CONTENT_ERROR_NONE;
2203 }
2204 #endif