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