src/common/media-svc.c

   1 /*
   2  * libmedia-service
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Hyunjun Ko <zzoon.ko@samsung.com>, Haejeong Kim <backto.kim@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21
  22 #include <string.h>
  23 #include <drm_client.h>
  24 #include <media-util.h>
  25 #include "media-svc.h"
  26 #include "media-svc-media.h"
  27 #include "media-svc-debug.h"
  28 #include "media-svc-util.h"
  29 #include "media-svc-db-utils.h"
  30 #include "media-svc-media-folder.h"
  31 #include "media-svc-album.h"
  32 #include "media-svc-noti.h"
  33
  34 static __thread int g_media_svc_item_validity_data_cnt = 1;
  35 static __thread int g_media_svc_item_validity_cur_data_cnt = 0;
  36
  37 static __thread int g_media_svc_move_item_data_cnt = 1;
  38 static __thread int g_media_svc_move_item_cur_data_cnt = 0;
  39
  40 static __thread int g_media_svc_insert_item_data_cnt = 1;
  41 static __thread int g_media_svc_insert_item_cur_data_cnt = 0;
  42
  43 /* Flag for items to be published by notification */
  44 static __thread int g_insert_with_noti = FALSE;
  45
  46 int media_svc_connect(MediaSvcHandle **handle)
  47 {
  48         int ret = MEDIA_INFO_ERROR_NONE;
  49         MediaDBHandle *db_handle = NULL;
  50
  51         media_svc_debug_func();
  52
  53 #if 1   //Use libmedia_utils API
  54         ret = media_db_connect(&db_handle);
  55         if(ret != MS_MEDIA_ERR_NONE)
  56                 return _media_svc_error_convert(ret);
  57
  58 #else
  59         sqlite3 * db_handle = NULL;
  60
  61         ret = _media_svc_connect_db_with_handle(&db_handle);
  62         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
  63 #endif
  64
  65         *handle = db_handle;
  66         return MEDIA_INFO_ERROR_NONE;
  67
  68 }
  69
  70 int media_svc_disconnect(MediaSvcHandle *handle)
  71 {
  72         MediaDBHandle * db_handle = (MediaDBHandle *)handle;
  73
  74         media_svc_debug_func();
  75
  76         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
  77
  78 #if 1   //Use libmedia_utils API
  79         int ret = MEDIA_INFO_ERROR_NONE;
  80
  81         ret = media_db_disconnect(db_handle);
  82         return _media_svc_error_convert(ret);
  83 #else
  84         sqlite3 * db_handle = (sqlite3 *)handle;
  85
  86         return _media_svc_disconnect_db_with_handle(db_handle);
  87 #endif
  88 }
  89
  90 int media_svc_create_table(MediaSvcHandle *handle)
  91 {
  92         int ret = MEDIA_INFO_ERROR_NONE;
  93         sqlite3 * db_handle = (sqlite3 *)handle;
  94
  95         media_svc_debug_func();
  96
  97         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
  98
  99         /*create media table*/
 100         ret = _media_svc_create_media_table(handle);
 101         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 102
 103         /*create folder table*/
 104         ret = _media_svc_create_folder_table(handle);
 105         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 106
 107         /*create playlist table*/
 108         ret = _media_svc_create_playlist_table(handle);
 109         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 110
 111         /* create album table*/
 112         ret = _media_svc_create_album_table(handle);
 113         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 114
 115         /*create tag table*/
 116         ret = _media_svc_create_tag_table(handle);
 117         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 118
 119         /*create bookmark table*/
 120         ret = _media_svc_create_bookmark_table(handle);
 121         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 122
 123 #if 0   /*unify media and custom table*/
 124         /*create custom table*/
 125         ret = _media_svc_create_custom_table(handle);
 126         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 127 #endif
 128
 129         return MEDIA_INFO_ERROR_NONE;
 130 }
 131
 132 int media_svc_get_storage_type(const char *path, media_svc_storage_type_e *storage_type)
 133 {
 134         int ret = MEDIA_INFO_ERROR_NONE;
 135         media_svc_storage_type_e type;
 136
 137         ret = _media_svc_get_store_type_by_path(path, &type);
 138         media_svc_retvm_if(ret < MEDIA_INFO_ERROR_NONE, ret, "_media_svc_get_store_type_by_path failed : %d", ret);
 139
 140         *storage_type = type;
 141
 142         return ret;
 143 }
 144
 145 int media_svc_get_mime_type(const char *path, char *mimetype)
 146 {
 147         int ret = MEDIA_INFO_ERROR_NONE;
 148         drm_bool_type_e is_drm = DRM_FALSE;
 149         drm_content_info_s *drm_contentInfo = NULL;
 150
 151         ret = _media_svc_get_mime_type(path, mimetype, &is_drm, &drm_contentInfo);
 152
 153         SAFE_FREE(drm_contentInfo);
 154
 155         return ret;
 156 }
 157
 158 int media_svc_get_media_type(const char *path, const char *mime_type, media_svc_media_type_e *media_type)
 159 {
 160         int ret = MEDIA_INFO_ERROR_NONE;
 161
 162         ret = _media_svc_get_media_type(path, mime_type, media_type);
 163
 164         return ret;
 165 }
 166
 167 int media_svc_check_item_exist_by_path(MediaSvcHandle *handle, const char *path)
 168 {
 169         int ret = MEDIA_INFO_ERROR_NONE;
 170         sqlite3 * db_handle = (sqlite3 *)handle;
 171         int count = -1;
 172
 173         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 174         media_svc_retvm_if(!STRING_VALID(path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "Path is NULL");
 175
 176         ret = _media_svc_count_record_with_path(db_handle, path, &count);
 177         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 178
 179         if(count > 0) {
 180                 media_svc_debug("item is exist in database");
 181                 return MEDIA_INFO_ERROR_NONE;
 182         } else {
 183                 media_svc_debug("item is not exist in database");
 184                 return MEDIA_INFO_ERROR_DATABASE_NO_RECORD;
 185         }
 186
 187         return MEDIA_INFO_ERROR_NONE;
 188 }
 189
 190 int media_svc_insert_item_begin(MediaSvcHandle *handle, int data_cnt, int with_noti, int from_pid)
 191 {
 192         sqlite3 * db_handle = (sqlite3 *)handle;
 193
 194         media_svc_debug("Transaction data count : [%d]", data_cnt);
 195
 196         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 197         media_svc_retvm_if(data_cnt < 1, MEDIA_INFO_ERROR_INVALID_PARAMETER, "data_cnt shuld be bigger than 1");
 198
 199         g_media_svc_insert_item_data_cnt  = data_cnt;
 200         g_media_svc_insert_item_cur_data_cnt  = 0;
 201
 202         /* Prepare for making noti item list */
 203         if (with_noti) {
 204                 media_svc_debug("making noti list from pid[%d]", from_pid);
 205                 if (_media_svc_create_noti_list(data_cnt) != MEDIA_INFO_ERROR_NONE) {
 206                         return MEDIA_INFO_ERROR_OUT_OF_MEMORY;
 207                 }
 208
 209                 _media_svc_set_noti_from_pid(from_pid);
 210                 g_insert_with_noti = TRUE;
 211         }
 212
 213         return MEDIA_INFO_ERROR_NONE;
 214 }
 215
 216 int media_svc_insert_item_end(MediaSvcHandle *handle)
 217 {
 218         int ret = MEDIA_INFO_ERROR_NONE;
 219         sqlite3 * db_handle = (sqlite3 *)handle;
 220
 221         media_svc_debug_func();
 222
 223         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 224
 225         if (g_media_svc_insert_item_cur_data_cnt  > 0) {
 226
 227                 ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_INSERT_ITEM);
 228                 if (g_insert_with_noti) {
 229                         media_svc_debug("sending noti list");
 230                         _media_svc_publish_noti_list(g_media_svc_insert_item_cur_data_cnt);
 231                         _media_svc_destroy_noti_list(g_media_svc_insert_item_cur_data_cnt);
 232                         g_insert_with_noti = FALSE;
 233                         _media_svc_set_noti_from_pid(-1);
 234                 }
 235         }
 236
 237         g_media_svc_insert_item_data_cnt  = 1;
 238         g_media_svc_insert_item_cur_data_cnt  = 0;
 239
 240         return ret;
 241 }
 242
 243 int media_svc_insert_item_bulk(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, const char *path, int is_burst)
 244 {
 245         int ret = MEDIA_INFO_ERROR_NONE;
 246         sqlite3 * db_handle = (sqlite3 *)handle;
 247         char folder_uuid[MEDIA_SVC_UUID_SIZE+1] = {0,};
 248         media_svc_media_type_e media_type;
 249         drm_content_info_s *drm_contentInfo = NULL;
 250
 251         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 252         media_svc_retvm_if(!STRING_VALID(path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "path is NULL");
 253
 254         if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
 255                 media_svc_error("storage type is incorrect[%d]", storage_type);
 256                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 257         }
 258
 259         media_svc_content_info_s content_info;
 260         memset(&content_info, 0, sizeof(media_svc_content_info_s));
 261
 262         /*Set media info*/
 263         /* if drm_contentinfo is not NULL, the file is OMA DRM.*/
 264         ret = _media_svc_set_media_info(&content_info, storage_type, path, &media_type, FALSE, &drm_contentInfo);
 265         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 266
 267         if(media_type == MEDIA_SVC_MEDIA_TYPE_OTHER) {
 268                 /*Do nothing.*/
 269         } else if(media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) {
 270                 ret = _media_svc_extract_image_metadata(&content_info, media_type);
 271         } else {
 272                 ret = _media_svc_extract_media_metadata(handle, &content_info, media_type, drm_contentInfo);
 273         }
 274         SAFE_FREE(drm_contentInfo);
 275         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 276
 277         /*Set or Get folder id*/
 278         ret = _media_svc_get_and_append_folder_id_by_path(handle, path, storage_type, folder_uuid);
 279         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 280
 281         ret = __media_svc_malloc_and_strncpy(&content_info.folder_uuid, folder_uuid);
 282         media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, &content_info);
 283
 284         if (g_media_svc_insert_item_data_cnt == 1) {
 285
 286                 ret = _media_svc_insert_item_with_data(db_handle, &content_info, is_burst, FALSE);
 287                 media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, &content_info);
 288
 289                 if (g_insert_with_noti)
 290                         _media_svc_insert_item_to_noti_list(&content_info, g_media_svc_insert_item_cur_data_cnt++);
 291
 292         } else if(g_media_svc_insert_item_cur_data_cnt  < (g_media_svc_insert_item_data_cnt  - 1)) {
 293
 294                 ret = _media_svc_insert_item_with_data(db_handle, &content_info, is_burst, TRUE);
 295                 media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, &content_info);
 296
 297                 if (g_insert_with_noti)
 298                         _media_svc_insert_item_to_noti_list(&content_info, g_media_svc_insert_item_cur_data_cnt);
 299
 300                 g_media_svc_insert_item_cur_data_cnt ++;
 301
 302         } else if (g_media_svc_insert_item_cur_data_cnt  == (g_media_svc_insert_item_data_cnt  - 1)) {
 303
 304                 ret = _media_svc_insert_item_with_data(db_handle, &content_info, is_burst, TRUE);
 305                 media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, &content_info);
 306
 307                 if (g_insert_with_noti)
 308                         _media_svc_insert_item_to_noti_list(&content_info, g_media_svc_insert_item_cur_data_cnt);
 309
 310                 ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_INSERT_ITEM);
 311                 media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, &content_info);
 312
 313                 if (g_insert_with_noti) {
 314                         _media_svc_publish_noti_list(g_media_svc_insert_item_cur_data_cnt + 1);
 315                         _media_svc_destroy_noti_list(g_media_svc_insert_item_cur_data_cnt + 1);
 316
 317                         /* Recreate noti list */
 318                         if (_media_svc_create_noti_list(g_media_svc_insert_item_data_cnt) != MEDIA_INFO_ERROR_NONE) {
 319                                 return MEDIA_INFO_ERROR_OUT_OF_MEMORY;
 320                         }
 321                 }
 322
 323                 g_media_svc_insert_item_cur_data_cnt = 0;
 324
 325         } else {
 326                 media_svc_error("Error in media_svc_insert_item_bulk");
 327                 _media_svc_destroy_content_info(&content_info);
 328                 return MEDIA_INFO_ERROR_INTERNAL;
 329         }
 330
 331         _media_svc_destroy_content_info(&content_info);
 332
 333         return MEDIA_INFO_ERROR_NONE;
 334 }
 335
 336 int media_svc_insert_item_immediately(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, const char *path)
 337 {
 338         int ret = MEDIA_INFO_ERROR_NONE;
 339         sqlite3 * db_handle = (sqlite3 *)handle;
 340         char folder_uuid[MEDIA_SVC_UUID_SIZE+1] = {0,};
 341         media_svc_media_type_e media_type;
 342         drm_content_info_s *drm_contentInfo = NULL;
 343
 344         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 345         media_svc_retvm_if(!STRING_VALID(path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "path is NULL");
 346
 347         if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
 348                 media_svc_error("storage type is incorrect[%d]", storage_type);
 349                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 350         }
 351
 352         media_svc_content_info_s content_info;
 353         memset(&content_info, 0, sizeof(media_svc_content_info_s));
 354
 355         /*Set media info*/
 356         ret = _media_svc_set_media_info(&content_info, storage_type, path, &media_type, FALSE, &drm_contentInfo);
 357         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 358
 359         if(media_type == MEDIA_SVC_MEDIA_TYPE_OTHER) {
 360                 /*Do nothing.*/
 361         } else if(media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) {
 362                 ret = _media_svc_extract_image_metadata(&content_info, media_type);
 363                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 364         } else {
 365                 ret = _media_svc_extract_media_metadata(handle, &content_info, media_type, drm_contentInfo);
 366                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 367         }
 368
 369         /*Set or Get folder id*/
 370         ret = _media_svc_get_and_append_folder_id_by_path(handle, path, storage_type, folder_uuid);
 371         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 372
 373         ret = __media_svc_malloc_and_strncpy(&content_info.folder_uuid, folder_uuid);
 374         media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, &content_info);
 375 #if 1
 376         /* Extracting thumbnail */
 377         if (media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE || media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO) {
 378                 char thumb_path[MEDIA_SVC_PATHNAME_SIZE + 1] = {0, };
 379                 int width = 0;
 380                 int height = 0;
 381
 382                 ret = thumbnail_request_from_db_with_size(content_info.path, thumb_path, sizeof(thumb_path), &width, &height);
 383                 if (ret < 0) {
 384                         media_svc_error("thumbnail_request_from_db failed: %d", ret);
 385                 } else {
 386                         media_svc_debug("thumbnail_request_from_db success: %s", thumb_path);
 387                         __media_svc_malloc_and_strncpy(&(content_info.thumbnail_path), thumb_path);
 388                 }
 389
 390                 if (content_info.media_meta.width <= 0)
 391                         content_info.media_meta.width = width;
 392
 393                 if (content_info.media_meta.height <= 0)
 394                         content_info.media_meta.height = height;
 395         }
 396 #endif
 397         ret = _media_svc_insert_item_with_data(db_handle, &content_info, FALSE, FALSE);
 398
 399         if (ret == MEDIA_INFO_ERROR_NONE) {
 400                 media_svc_debug("Insertion is successful. Sending noti for this");
 401                 _media_svc_publish_noti(MS_MEDIA_ITEM_FILE, MS_MEDIA_ITEM_INSERT, content_info.path, content_info.media_type, content_info.media_uuid, content_info.mime_type);
 402         }
 403
 404         _media_svc_destroy_content_info(&content_info);
 405         return ret;
 406 }
 407
 408 int media_svc_insert_folder(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, const char *path)
 409 {
 410         int ret = MEDIA_INFO_ERROR_NONE;
 411         sqlite3 * db_handle = (sqlite3 *)handle;
 412
 413         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 414         media_svc_retvm_if(!STRING_VALID(path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "path is NULL");
 415
 416         if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
 417                 media_svc_error("storage type is incorrect[%d]", storage_type);
 418                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 419         }
 420
 421         media_svc_debug("storage[%d], folder_path[%s]", storage_type, path);
 422
 423         /*Get folder info*/
 424         char *folder_name = NULL;
 425         int folder_modified_date = 0;
 426         char *folder_uuid = _media_info_generate_uuid();
 427         if(folder_uuid == NULL ) {
 428                 media_svc_error("Invalid UUID");
 429                 return MEDIA_INFO_ERROR_INTERNAL;
 430         }
 431
 432         folder_name = g_path_get_basename(path);
 433         folder_modified_date = _media_svc_get_file_time(path);
 434
 435         ret = _media_svc_append_folder(handle, storage_type, folder_uuid, path, folder_name, folder_modified_date);
 436         SAFE_FREE(folder_name);
 437
 438         if (ret < MEDIA_INFO_ERROR_NONE) {
 439                 media_svc_error("_media_svc_append_folder error [%d]", ret);
 440                 return ret;
 441         }
 442
 443         return MEDIA_INFO_ERROR_NONE;
 444 }
 445
 446 int media_svc_move_item_begin(MediaSvcHandle *handle, int data_cnt)
 447 {
 448         sqlite3 * db_handle = (sqlite3 *)handle;
 449
 450         media_svc_debug("Transaction data count : [%d]", data_cnt);
 451
 452         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 453         media_svc_retvm_if(data_cnt < 1, MEDIA_INFO_ERROR_INVALID_PARAMETER, "data_cnt shuld be bigger than 1");
 454
 455         g_media_svc_move_item_data_cnt  = data_cnt;
 456         g_media_svc_move_item_cur_data_cnt  = 0;
 457
 458         return MEDIA_INFO_ERROR_NONE;
 459 }
 460
 461 int media_svc_move_item_end(MediaSvcHandle *handle)
 462 {
 463         int ret = MEDIA_INFO_ERROR_NONE;
 464         sqlite3 * db_handle = (sqlite3 *)handle;
 465
 466         media_svc_debug_func();
 467
 468         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 469
 470         if (g_media_svc_move_item_cur_data_cnt  > 0) {
 471
 472                 ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_MOVE_ITEM);
 473         }
 474
 475         /*clean up old folder path*/
 476         ret = _media_svc_update_folder_table(handle);
 477         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 478
 479         g_media_svc_move_item_data_cnt  = 1;
 480         g_media_svc_move_item_cur_data_cnt  = 0;
 481
 482         return ret;
 483 }
 484
 485 int media_svc_move_item(MediaSvcHandle *handle, media_svc_storage_type_e src_storage, const char *src_path,
 486                         media_svc_storage_type_e dest_storage, const char *dest_path)
 487 {
 488         int ret = MEDIA_INFO_ERROR_NONE;
 489         sqlite3 * db_handle = (sqlite3 *)handle;
 490         char *file_name = NULL;
 491         char *folder_path = NULL;
 492         int modified_time = 0;
 493         char folder_uuid[MEDIA_SVC_UUID_SIZE+1] = {0,};
 494         char old_thumb_path[MEDIA_SVC_PATHNAME_SIZE] = {0,};
 495         char new_thumb_path[MEDIA_SVC_PATHNAME_SIZE] = {0,};
 496         int media_type = -1;
 497
 498         media_svc_debug_func();
 499
 500         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 501         media_svc_retvm_if(!STRING_VALID(src_path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "src_path is NULL");
 502         media_svc_retvm_if(!STRING_VALID(dest_path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "dest_path is NULL");
 503
 504         if ((src_storage != MEDIA_SVC_STORAGE_INTERNAL) && (src_storage != MEDIA_SVC_STORAGE_EXTERNAL)) {
 505                 media_svc_error("src_storage type is incorrect[%d]", src_storage);
 506                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 507         }
 508         if ((dest_storage != MEDIA_SVC_STORAGE_INTERNAL) && (dest_storage != MEDIA_SVC_STORAGE_EXTERNAL)) {
 509                 media_svc_error("dest_storage type is incorrect[%d]", dest_storage);
 510                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 511         }
 512
 513         /*check and update folder*/
 514         ret = _media_svc_get_and_append_folder_id_by_path(handle, dest_path, dest_storage, folder_uuid);
 515         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 516
 517         /*get filename*/
 518         file_name = g_path_get_basename(dest_path);
 519
 520         /*get modified_time*/
 521         modified_time = _media_svc_get_file_time(dest_path);
 522
 523         /*get thumbnail_path to update. only for Imgae and Video items. Audio share album_art(thumbnail)*/
 524         ret = _media_svc_get_media_type_by_path(handle, src_path, &media_type);
 525         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 526
 527         if((media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) ||(media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)) {
 528                 /*get old thumbnail_path*/
 529                 ret = _media_svc_get_thumbnail_path_by_path(handle, src_path, old_thumb_path);
 530                 media_svc_retv_if((ret != MEDIA_INFO_ERROR_NONE) && (ret != MEDIA_INFO_ERROR_DATABASE_NO_RECORD), ret);
 531
 532                 /* If old thumb path is default or not */
 533                 if (strncmp(old_thumb_path, MEDIA_SVC_THUMB_DEFAULT_PATH, sizeof(MEDIA_SVC_THUMB_DEFAULT_PATH)) == 0) {
 534                         strncpy(new_thumb_path, MEDIA_SVC_THUMB_DEFAULT_PATH, sizeof(new_thumb_path));
 535                 } else {
 536                         _media_svc_get_thumbnail_path(dest_storage, new_thumb_path, dest_path, THUMB_EXT);
 537                 }
 538         }
 539
 540         if (g_media_svc_move_item_data_cnt == 1) {
 541
 542                 /*update item*/
 543                 if((media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) ||(media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)) {
 544                         ret = _media_svc_update_item_by_path(handle, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, new_thumb_path, FALSE);
 545                 } else {
 546                         ret = _media_svc_update_item_by_path(handle, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, NULL, FALSE);
 547                 }
 548                 SAFE_FREE(file_name);
 549                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 550
 551                 media_svc_debug("Move is successful. Sending noti for this");
 552
 553                 /* Get notification info */
 554                 media_svc_noti_item *noti_item = NULL;
 555                 ret = _media_svc_get_noti_info(handle, dest_path, MS_MEDIA_ITEM_FILE, &noti_item);
 556                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 557
 558                 /* Send notification for move */
 559                 _media_svc_publish_noti(MS_MEDIA_ITEM_FILE, MS_MEDIA_ITEM_UPDATE, src_path, media_type, noti_item->media_uuid, noti_item->mime_type);
 560                 _media_svc_destroy_noti_item(noti_item);
 561
 562                 /*update folder modified_time*/
 563                 folder_path = g_path_get_dirname(dest_path);
 564                 ret = _media_svc_update_folder_modified_time_by_folder_uuid(handle, folder_uuid, folder_path, FALSE);
 565                 SAFE_FREE(folder_path);
 566                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 567
 568                 ret = _media_svc_update_folder_table(handle);
 569                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 570
 571         } else if (g_media_svc_move_item_cur_data_cnt  < (g_media_svc_move_item_data_cnt  - 1)) {
 572
 573                 /*update item*/
 574                 if((media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) ||(media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)) {
 575                         ret = _media_svc_update_item_by_path(handle, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, new_thumb_path, TRUE);
 576                 } else {
 577                         ret = _media_svc_update_item_by_path(handle, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, NULL, TRUE);
 578                 }
 579                 SAFE_FREE(file_name);
 580                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 581
 582                 /*update folder modified_time*/
 583                 folder_path = g_path_get_dirname(dest_path);
 584                 ret = _media_svc_update_folder_modified_time_by_folder_uuid(handle, folder_uuid, folder_path, TRUE);
 585                 SAFE_FREE(folder_path);
 586                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 587
 588                 g_media_svc_move_item_cur_data_cnt ++;
 589
 590         } else if (g_media_svc_move_item_cur_data_cnt  == (g_media_svc_move_item_data_cnt  - 1)) {
 591
 592                 /*update item*/
 593                 if((media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) ||(media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)) {
 594                         ret = _media_svc_update_item_by_path(handle, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, new_thumb_path, TRUE);
 595                 } else {
 596                         ret = _media_svc_update_item_by_path(handle, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, NULL, TRUE);
 597                 }
 598                 SAFE_FREE(file_name);
 599                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 600
 601                 /*update folder modified_time*/
 602                 folder_path = g_path_get_dirname(dest_path);
 603                 ret = _media_svc_update_folder_modified_time_by_folder_uuid(handle, folder_uuid, folder_path, TRUE);
 604                 SAFE_FREE(folder_path);
 605                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 606
 607                 /*update db*/
 608                 ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_MOVE_ITEM);
 609                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 610
 611                 g_media_svc_move_item_cur_data_cnt = 0;
 612
 613         } else {
 614                 media_svc_error("Error in media_svc_move_item");
 615                 return MEDIA_INFO_ERROR_INTERNAL;
 616         }
 617
 618         /*rename thumbnail file*/
 619         if((media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) ||(media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)) {
 620                 if((strlen(old_thumb_path) > 0) && (strncmp(old_thumb_path, MEDIA_SVC_THUMB_DEFAULT_PATH, sizeof(MEDIA_SVC_THUMB_DEFAULT_PATH)) != 0)) {
 621                         ret = _media_svc_rename_file(old_thumb_path,new_thumb_path);
 622                         if (ret < 0)
 623                                 media_svc_error("_media_svc_rename_file failed : %d", ret);
 624                 }
 625         }
 626
 627         return MEDIA_INFO_ERROR_NONE;
 628 }
 629
 630 int media_svc_set_item_validity_begin(MediaSvcHandle *handle, int data_cnt)
 631 {
 632         sqlite3 * db_handle = (sqlite3 *)handle;
 633
 634         media_svc_debug("Transaction data count : [%d]", data_cnt);
 635
 636         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 637         media_svc_retvm_if(data_cnt < 1, MEDIA_INFO_ERROR_INVALID_PARAMETER, "data_cnt shuld be bigger than 1");
 638
 639         g_media_svc_item_validity_data_cnt  = data_cnt;
 640         g_media_svc_item_validity_cur_data_cnt  = 0;
 641
 642         return MEDIA_INFO_ERROR_NONE;
 643 }
 644
 645 int media_svc_set_item_validity_end(MediaSvcHandle *handle)
 646 {
 647         int ret = MEDIA_INFO_ERROR_NONE;
 648         sqlite3 * db_handle = (sqlite3 *)handle;
 649
 650         media_svc_debug_func();
 651
 652         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 653
 654         if (g_media_svc_item_validity_cur_data_cnt  > 0) {
 655
 656                 ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_SET_ITEM_VALIDITY);
 657         }
 658
 659         g_media_svc_item_validity_data_cnt  = 1;
 660         g_media_svc_item_validity_cur_data_cnt  = 0;
 661
 662         return ret;
 663 }
 664
 665 int media_svc_set_item_validity(MediaSvcHandle *handle, const char *path, int validity)
 666 {
 667         int ret = MEDIA_INFO_ERROR_NONE;
 668         sqlite3 * db_handle = (sqlite3 *)handle;
 669
 670         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 671         media_svc_retvm_if(!STRING_VALID(path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "path is NULL");
 672
 673         media_svc_debug("path=[%s], validity=[%d]", path, validity);
 674
 675         if (g_media_svc_item_validity_data_cnt  == 1) {
 676
 677                 return _media_svc_update_item_validity(db_handle, path, validity, FALSE);
 678
 679         } else if (g_media_svc_item_validity_cur_data_cnt  < (g_media_svc_item_validity_data_cnt  - 1)) {
 680
 681                 ret = _media_svc_update_item_validity(db_handle, path, validity, TRUE);
 682                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 683
 684                 g_media_svc_item_validity_cur_data_cnt ++;
 685
 686         } else if (g_media_svc_item_validity_cur_data_cnt  == (g_media_svc_item_validity_data_cnt  - 1)) {
 687
 688                 ret = _media_svc_update_item_validity(db_handle, path, validity, TRUE);
 689                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 690
 691                 ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_SET_ITEM_VALIDITY);
 692                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 693
 694                 g_media_svc_item_validity_cur_data_cnt  = 0;
 695
 696         } else {
 697
 698                 media_svc_error("Error in media_svc_set_item_validity");
 699                 return MEDIA_INFO_ERROR_INTERNAL;
 700         }
 701
 702         return MEDIA_INFO_ERROR_NONE;
 703 }
 704
 705 int media_svc_delete_item_by_path(MediaSvcHandle *handle, const char *path)
 706 {
 707         int ret = MEDIA_INFO_ERROR_NONE;
 708         sqlite3 * db_handle = (sqlite3 *)handle;
 709         char thumb_path[MEDIA_SVC_PATHNAME_SIZE] = {0,};
 710
 711         media_svc_debug_func();
 712
 713         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 714         media_svc_retvm_if(!STRING_VALID(path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "path is NULL");
 715
 716         int media_type = -1;
 717         ret = _media_svc_get_media_type_by_path(db_handle, path, &media_type);
 718         media_svc_retv_if((ret != MEDIA_INFO_ERROR_NONE), ret);
 719
 720         if((media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) ||(media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)) {
 721                 /*Get thumbnail path to delete*/
 722                 ret = _media_svc_get_thumbnail_path_by_path(db_handle, path, thumb_path);
 723                 media_svc_retv_if((ret != MEDIA_INFO_ERROR_NONE) && (ret != MEDIA_INFO_ERROR_DATABASE_NO_RECORD), ret);
 724         } else if ((media_type == MEDIA_SVC_MEDIA_TYPE_SOUND) ||(media_type == MEDIA_SVC_MEDIA_TYPE_MUSIC)) {
 725                 int count = 0;
 726                 ret = _media_svc_get_media_count_with_album_id_by_path(db_handle, path, &count);
 727                 media_svc_retv_if((ret != MEDIA_INFO_ERROR_NONE), ret);
 728
 729                 if (count == 1) {
 730                         /*Get thumbnail path to delete*/
 731                         ret = _media_svc_get_thumbnail_path_by_path(db_handle, path, thumb_path);
 732                         media_svc_retv_if((ret != MEDIA_INFO_ERROR_NONE) && (ret != MEDIA_INFO_ERROR_DATABASE_NO_RECORD), ret);
 733                 }
 734         }
 735
 736         /* Get notification info */
 737         media_svc_noti_item *noti_item = NULL;
 738         ret = _media_svc_get_noti_info(handle, path, MS_MEDIA_ITEM_FILE, &noti_item);
 739         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 740
 741         /*Delete item*/
 742         ret = _media_svc_delete_item_by_path(db_handle, path);
 743         if (ret != MEDIA_INFO_ERROR_NONE) {
 744                 media_svc_error("_media_svc_delete_item_by_path failed : %d", ret);
 745                 _media_svc_destroy_noti_item(noti_item);
 746
 747                 return ret;
 748         }
 749
 750         /* Send notification */
 751         media_svc_debug("Deletion is successful. Sending noti for this");
 752         _media_svc_publish_noti(MS_MEDIA_ITEM_FILE, MS_MEDIA_ITEM_DELETE, path, media_type, noti_item->media_uuid, noti_item->mime_type);
 753         _media_svc_destroy_noti_item(noti_item);
 754
 755         /*Delete thumbnail*/
 756         if ((strlen(thumb_path) > 0) && (strncmp(thumb_path, MEDIA_SVC_THUMB_DEFAULT_PATH, sizeof(MEDIA_SVC_THUMB_DEFAULT_PATH)) != 0)) {
 757                 int thumb_count = 1;
 758                 /* Get count of media, which contains same thumbnail for music */
 759                 if ((media_type == MEDIA_SVC_MEDIA_TYPE_SOUND) ||(media_type == MEDIA_SVC_MEDIA_TYPE_MUSIC)) {
 760                         ret = _media_svc_get_thumbnail_count(db_handle, thumb_path, &thumb_count);
 761                         if (ret < MEDIA_INFO_ERROR_NONE) {
 762                                 media_svc_error("Failed to get thumbnail count : %d", ret);
 763                         }
 764                 }
 765
 766                 if (thumb_count == 1) {
 767                         if (_media_svc_remove_file(thumb_path) == FALSE) {
 768                                 media_svc_error("fail to remove thumbnail file.");
 769                         }
 770                 }
 771         }
 772
 773         return MEDIA_INFO_ERROR_NONE;
 774 }
 775
 776 int media_svc_delete_all_items_in_storage(MediaSvcHandle *handle, media_svc_storage_type_e storage_type)
 777 {
 778         int ret = MEDIA_INFO_ERROR_NONE;
 779         sqlite3 * db_handle = (sqlite3 *)handle;
 780         char * dirpath = NULL;
 781
 782         media_svc_debug("media_svc_delete_all_items_in_storage [%d]", storage_type);
 783
 784         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 785
 786         if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
 787                 media_svc_error("storage type is incorrect[%d]", storage_type);
 788                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 789         }
 790
 791         ret = _media_svc_truncate_table(db_handle, storage_type);
 792         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 793
 794         dirpath = (storage_type == MEDIA_SVC_STORAGE_INTERNAL) ? MEDIA_SVC_THUMB_INTERNAL_PATH : MEDIA_SVC_THUMB_EXTERNAL_PATH;
 795
 796         /* remove thumbnails */
 797         ret = _media_svc_remove_all_files_in_dir(dirpath);
 798         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 799
 800         return MEDIA_INFO_ERROR_NONE;
 801 }
 802
 803 int media_svc_delete_invalid_items_in_storage(MediaSvcHandle *handle, media_svc_storage_type_e storage_type)
 804 {
 805         sqlite3 * db_handle = (sqlite3 *)handle;
 806
 807         media_svc_debug_func();
 808
 809         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 810
 811         if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
 812                 media_svc_error("storage type is incorrect[%d]", storage_type);
 813                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 814         }
 815
 816         /*Delete from DB and remove thumbnail files*/
 817         return _media_svc_delete_invalid_items(db_handle, storage_type);
 818 }
 819
 820 int media_svc_delete_invalid_items_in_folder(MediaSvcHandle *handle, const char *folder_path)
 821 {
 822         sqlite3 * db_handle = (sqlite3 *)handle;
 823
 824         media_svc_debug_func();
 825
 826         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 827
 828         /*Delete from DB and remove thumbnail files*/
 829         return _media_svc_delete_invalid_folder_items(db_handle, folder_path);
 830 }
 831
 832 int media_svc_set_all_storage_items_validity(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, int validity)
 833 {
 834         sqlite3 * db_handle = (sqlite3 *)handle;
 835
 836         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 837
 838         if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
 839                 media_svc_error("storage type is incorrect[%d]", storage_type);
 840                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 841         }
 842
 843         return _media_svc_update_storage_item_validity(db_handle, storage_type, validity);
 844 }
 845
 846 int media_svc_set_folder_items_validity(MediaSvcHandle *handle, const char *folder_path, int validity, int recursive)
 847 {
 848         sqlite3 * db_handle = (sqlite3 *)handle;
 849
 850         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 851         media_svc_retvm_if(!STRING_VALID(folder_path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "folder_path is NULL");
 852
 853         if(recursive)
 854                 return _media_svc_update_recursive_folder_item_validity(db_handle, folder_path, validity);
 855         else
 856                 return _media_svc_update_folder_item_validity(db_handle, folder_path, validity);
 857 }
 858
 859 int media_svc_refresh_item(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, const char *path)
 860 {
 861         int ret = MEDIA_INFO_ERROR_NONE;
 862         sqlite3 * db_handle = (sqlite3 *)handle;
 863         media_svc_media_type_e media_type;
 864         drm_content_info_s *drm_contentInfo = NULL;
 865
 866         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 867         media_svc_retvm_if(!STRING_VALID(path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "path is NULL");
 868
 869         if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
 870                 media_svc_error("storage type is incorrect[%d]", storage_type);
 871                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 872         }
 873
 874         /* Get notification info */
 875         media_svc_noti_item *noti_item = NULL;
 876         ret = _media_svc_get_noti_info(handle, path, MS_MEDIA_ITEM_FILE, &noti_item);
 877         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 878
 879         media_svc_content_info_s content_info;
 880         memset(&content_info, 0, sizeof(media_svc_content_info_s));
 881
 882         /*Set media info*/
 883         ret = _media_svc_set_media_info(&content_info, storage_type, path, &media_type, TRUE, &drm_contentInfo);
 884         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 885
 886         /* Initialize thumbnail information to remake thumbnail. */
 887         char thumb_path[MEDIA_SVC_PATHNAME_SIZE + 1];
 888         ret = _media_svc_get_thumbnail_path_by_path(handle, path, thumb_path);
 889         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 890
 891         if (g_file_test(thumb_path, G_FILE_TEST_EXISTS) && (strncmp(thumb_path, MEDIA_SVC_THUMB_DEFAULT_PATH, sizeof(MEDIA_SVC_THUMB_DEFAULT_PATH)) != 0)) {
 892                 ret = _media_svc_remove_file(thumb_path);
 893                 media_svc_retv_if(ret != TRUE, ret);
 894         }
 895
 896         ret = _media_svc_update_thumbnail_path(handle, path, NULL);
 897         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 898
 899         if(media_type == MEDIA_SVC_MEDIA_TYPE_OTHER) {
 900                 /*Do nothing.*/
 901         } else if(media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) {
 902                 ret = _media_svc_extract_image_metadata(&content_info, media_type);
 903                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 904         } else {
 905                 ret = _media_svc_extract_media_metadata(handle, &content_info, media_type, drm_contentInfo);
 906                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 907         }
 908 #if 1
 909         /* Extracting thumbnail */
 910         if (media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE || media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO) {
 911                 char thumb_path[MEDIA_SVC_PATHNAME_SIZE + 1] = {0, };
 912                 int width = 0;
 913                 int height = 0;
 914
 915                 ret = thumbnail_request_from_db_with_size(content_info.path, thumb_path, sizeof(thumb_path), &width, &height);
 916                 if (ret < 0) {
 917                         media_svc_error("thumbnail_request_from_db failed: %d", ret);
 918                 } else {
 919                         media_svc_debug("thumbnail_request_from_db success: %s", thumb_path);
 920                         __media_svc_malloc_and_strncpy(&(content_info.thumbnail_path), thumb_path);
 921                 }
 922
 923                 if (content_info.media_meta.width <= 0)
 924                         content_info.media_meta.width = width;
 925
 926                 if (content_info.media_meta.height <= 0)
 927                         content_info.media_meta.height = height;
 928         }
 929 #endif
 930         ret = _media_svc_update_item_with_data(db_handle, &content_info);
 931
 932         if (ret == MEDIA_INFO_ERROR_NONE) {
 933                 media_svc_debug("Update is successful. Sending noti for this");
 934                 _media_svc_publish_noti(MS_MEDIA_ITEM_FILE, MS_MEDIA_ITEM_UPDATE, content_info.path, media_type, noti_item->media_uuid, noti_item->mime_type);
 935         } else {
 936                 media_svc_error("_media_svc_update_item_with_data failed : %d", ret);
 937         }
 938
 939         _media_svc_destroy_content_info(&content_info);
 940         _media_svc_destroy_noti_item(noti_item);
 941
 942         return ret;
 943 }
 944
 945 int media_svc_rename_folder(MediaSvcHandle *handle, const char *src_path, const char *dst_path)
 946 {
 947         sqlite3 * db_handle = (sqlite3 *)handle;
 948         int ret = MEDIA_INFO_ERROR_NONE;
 949
 950         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 951         media_svc_retvm_if(src_path == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "src_path is NULL");
 952         media_svc_retvm_if(dst_path == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "dst_path is NULL");
 953
 954         media_svc_debug("Src path : %s,  Dst Path : %s", src_path, dst_path);
 955
 956         /* Get notification info */
 957         media_svc_noti_item *noti_item = NULL;
 958         ret = _media_svc_get_noti_info(handle, src_path, MS_MEDIA_ITEM_DIRECTORY, &noti_item);
 959         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 960
 961         ret = _media_svc_sql_begin_trans(handle);
 962         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 963
 964         /* Update all folder record's path, which are matched by old parent path */
 965         char *update_folder_path_sql = NULL;
 966         char src_path_slash[MEDIA_SVC_PATHNAME_SIZE + 1];
 967         char dst_path_slash[MEDIA_SVC_PATHNAME_SIZE + 1];
 968
 969         snprintf(src_path_slash, sizeof(src_path_slash), "%s/", src_path);
 970         snprintf(dst_path_slash, sizeof(dst_path_slash), "%s/", dst_path);
 971
 972         update_folder_path_sql = sqlite3_mprintf("UPDATE folder SET path = REPLACE( path, '%q', '%q');", src_path_slash, dst_path_slash);
 973
 974         //ret = _media_svc_sql_query(handle, update_folder_path_sql);
 975         ret = media_db_request_update_db_batch(update_folder_path_sql);
 976         sqlite3_free(update_folder_path_sql);
 977
 978         if (ret != SQLITE_OK) {
 979                 media_svc_error("failed to update folder path");
 980                 _media_svc_sql_rollback_trans(handle);
 981
 982                 return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
 983         }
 984
 985         /* Update all folder record's modified date, which are changed above */
 986         char *update_folder_modified_time_sql = NULL;
 987         time_t date;
 988         time(&date);
 989
 990         update_folder_modified_time_sql = sqlite3_mprintf("UPDATE folder SET modified_time = %d where path like '%q';", date, dst_path);
 991
 992         ret = media_db_request_update_db_batch(update_folder_modified_time_sql);
 993         //ret = _media_svc_sql_query(handle, update_folder_modified_time_sql);
 994         sqlite3_free(update_folder_modified_time_sql);
 995
 996         if (ret != SQLITE_OK) {
 997                 media_svc_error("failed to update folder modified time");
 998                 _media_svc_sql_rollback_trans(handle);
 999
1000                 return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
1001         }
1002
1003         /* Update all items */
1004         char *select_all_sql = NULL;
1005         sqlite3_stmt *sql_stmt = NULL;
1006         char dst_child_path[MEDIA_SVC_PATHNAME_SIZE + 1];
1007
1008         snprintf(dst_child_path, sizeof(dst_child_path), "%s/%%", dst_path);
1009
1010         select_all_sql = sqlite3_mprintf("SELECT media_uuid, path, thumbnail_path, media_type from media where folder_uuid IN ( SELECT folder_uuid FROM folder where path='%q' or path like '%q');", dst_path, dst_child_path);
1011
1012         media_svc_debug("[SQL query] : %s", select_all_sql);
1013
1014         ret = sqlite3_prepare_v2(handle, select_all_sql, -1, &sql_stmt, NULL);
1015         sqlite3_free((char *)select_all_sql);
1016
1017         if (ret != SQLITE_OK) {
1018                 media_svc_error ("prepare error [%s]", sqlite3_errmsg(handle));
1019                 _media_svc_sql_rollback_trans(handle);
1020                 return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
1021         }
1022
1023         while (1) {
1024                 ret = sqlite3_step(sql_stmt);
1025                 if (ret != SQLITE_ROW) {
1026                         media_svc_debug("end of iteration");
1027                         break;
1028                 }
1029
1030                 char media_uuid[MEDIA_SVC_UUID_SIZE + 1] = {0,};
1031                 char media_path[MEDIA_SVC_PATHNAME_SIZE + 1] = {0,};
1032                 char media_thumb_path[MEDIA_SVC_PATHNAME_SIZE + 1] = {0,};
1033                 char media_new_thumb_path[MEDIA_SVC_PATHNAME_SIZE + 1] = {0,};
1034                 int media_type;
1035                 bool no_thumb = FALSE;
1036
1037                 if (STRING_VALID((const char *)sqlite3_column_text(sql_stmt, 0))) {
1038                         strncpy(media_uuid,     (const char *)sqlite3_column_text(sql_stmt, 0), sizeof(media_uuid));
1039                         media_uuid[sizeof(media_uuid) - 1] = '\0';
1040                 } else {
1041                         media_svc_error("media UUID is NULL");
1042                         return MEDIA_INFO_ERROR_DATABASE_INVALID;
1043                 }
1044
1045                 if (STRING_VALID((const char *)sqlite3_column_text(sql_stmt, 1))) {
1046                         strncpy(media_path,     (const char *)sqlite3_column_text(sql_stmt, 1), sizeof(media_path));
1047                         media_path[sizeof(media_path) - 1] = '\0';
1048                 } else {
1049                         media_svc_error("media path is NULL");
1050                         return MEDIA_INFO_ERROR_DATABASE_INVALID;
1051                 }
1052
1053                 if (STRING_VALID((const char *)sqlite3_column_text(sql_stmt, 2))) {
1054                         strncpy(media_thumb_path,       (const char *)sqlite3_column_text(sql_stmt, 2), sizeof(media_thumb_path));
1055                         media_thumb_path[sizeof(media_thumb_path) - 1] = '\0';
1056                 } else {
1057                         media_svc_debug("media thumb path doesn't exist in DB");
1058                         no_thumb = TRUE;
1059                 }
1060
1061                 media_type = sqlite3_column_int(sql_stmt, 3);
1062
1063                 /* Update path, thumbnail path of this item */
1064                 char *replaced_path = NULL;
1065                 replaced_path = _media_svc_replace_path(media_path, src_path, dst_path);
1066                 if (replaced_path == NULL) {
1067                         media_svc_error("_media_svc_replace_path failed");
1068                         SQLITE3_FINALIZE(sql_stmt);
1069                         _media_svc_sql_rollback_trans(handle);
1070                         return MEDIA_INFO_ERROR_INTERNAL;
1071                 }
1072
1073                 media_svc_debug("New media path : %s", replaced_path);
1074                 media_svc_storage_type_e storage_type;
1075
1076                 if (!no_thumb) {
1077                         /* If old thumb path is default or not */
1078                         if (strncmp(media_thumb_path, MEDIA_SVC_THUMB_DEFAULT_PATH, sizeof(MEDIA_SVC_THUMB_DEFAULT_PATH)) == 0) {
1079                                 strncpy(media_new_thumb_path, MEDIA_SVC_THUMB_DEFAULT_PATH, sizeof(media_new_thumb_path));
1080                         } else {
1081                                 ret = _media_svc_get_store_type_by_path(replaced_path, &storage_type);
1082                                 if (ret < 0) {
1083                                         media_svc_error("_media_svc_get_store_type_by_path failed : %d", ret);
1084                                         SAFE_FREE(replaced_path);
1085                                         _media_svc_sql_rollback_trans(handle);
1086                                         return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
1087                                 }
1088
1089                                 ret = _media_svc_get_thumbnail_path(storage_type, media_new_thumb_path, replaced_path, THUMB_EXT);
1090                                 if (ret < 0) {
1091                                         media_svc_error("_media_svc_get_thumbnail_path failed : %d", ret);
1092                                         SAFE_FREE(replaced_path);
1093                                         SQLITE3_FINALIZE(sql_stmt);
1094                                         _media_svc_sql_rollback_trans(handle);
1095                                         return MEDIA_INFO_ERROR_INTERNAL;
1096                                 }
1097                         }
1098
1099                         //media_svc_debug("New media thumbnail path : %s", media_new_thumb_path);
1100                 }
1101
1102                 char *update_item_sql = NULL;
1103
1104                 if (no_thumb) {
1105                         update_item_sql = sqlite3_mprintf("UPDATE media SET path='%q' WHERE media_uuid='%q'", replaced_path, media_uuid);
1106                 } else {
1107                         if (media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE || media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO) {
1108                                 update_item_sql = sqlite3_mprintf("UPDATE media SET path='%q', thumbnail_path='%q' WHERE media_uuid='%q'", replaced_path, media_new_thumb_path, media_uuid);
1109                         } else {
1110                                 update_item_sql = sqlite3_mprintf("UPDATE media SET path='%q', thumbnail_path='%q' WHERE media_uuid='%q'", replaced_path, media_thumb_path, media_uuid);
1111                         }
1112                 }
1113
1114                 ret = media_db_request_update_db_batch(update_item_sql);
1115                 //ret = _media_svc_sql_query(handle, update_item_sql);
1116                 sqlite3_free(update_item_sql);
1117                 SAFE_FREE(replaced_path);
1118
1119                 if (ret != SQLITE_OK) {
1120                         media_svc_error("failed to update item");
1121                         SQLITE3_FINALIZE(sql_stmt);
1122                         _media_svc_sql_rollback_trans(handle);
1123
1124                         return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
1125                 }
1126
1127                 /* Rename thumbnail file of file system */
1128                 if ((!no_thumb) && (media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE || media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)
1129                                 && (strncmp(media_thumb_path, MEDIA_SVC_THUMB_DEFAULT_PATH, sizeof(MEDIA_SVC_THUMB_DEFAULT_PATH)) != 0)) {
1130                         ret = _media_svc_rename_file(media_thumb_path, media_new_thumb_path);
1131                         if (ret < 0) {
1132                                 media_svc_error("_media_svc_rename_file failed : %d", ret);
1133                         }
1134                 }
1135         }
1136
1137         SQLITE3_FINALIZE(sql_stmt);
1138
1139         ret = _media_svc_sql_end_trans(handle);
1140         if (ret != MEDIA_INFO_ERROR_NONE) {
1141                 media_svc_error("mb_svc_sqlite3_commit_trans failed.. Now start to rollback\n");
1142                 _media_svc_sql_rollback_trans(handle);
1143                 return ret;
1144         }
1145
1146         media_svc_debug("Folder update is successful. Sending noti for this");
1147         _media_svc_publish_noti(MS_MEDIA_ITEM_DIRECTORY, MS_MEDIA_ITEM_UPDATE, src_path, -1, noti_item->media_uuid, NULL);
1148         _media_svc_destroy_noti_item(noti_item);
1149
1150         return MEDIA_INFO_ERROR_NONE;
1151 }
1152
1153 int media_svc_request_update_db(const char *db_query)
1154 {
1155         int ret = MEDIA_INFO_ERROR_NONE;
1156
1157         media_svc_retvm_if(!STRING_VALID(db_query), MEDIA_INFO_ERROR_INVALID_PARAMETER, "db_query is NULL");
1158
1159         ret = _media_svc_request_update_db(db_query);
1160
1161         return _media_svc_error_convert(ret);
1162 }
1163
1164 int media_svc_send_dir_update_noti(MediaSvcHandle *handle, const char *dir_path)
1165 {
1166         int ret = MEDIA_INFO_ERROR_NONE;
1167         sqlite3 * db_handle = (sqlite3 *)handle;
1168
1169         media_svc_retvm_if(!STRING_VALID(dir_path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "dir_path is NULL");
1170
1171         /* Get notification info */
1172         media_svc_noti_item *noti_item = NULL;
1173         ret = _media_svc_get_noti_info(db_handle, dir_path, MS_MEDIA_ITEM_DIRECTORY, &noti_item);
1174         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
1175
1176         ret = _media_svc_publish_noti(MS_MEDIA_ITEM_DIRECTORY, MS_MEDIA_ITEM_UPDATE, dir_path, -1, noti_item->media_uuid, NULL);
1177         _media_svc_destroy_noti_item(noti_item);
1178
1179         return ret;
1180 }
1181
1182 int media_svc_count_invalid_items_in_folder(MediaSvcHandle *handle, const char *folder_path, int *count)
1183 {
1184         sqlite3 * db_handle = (sqlite3 *)handle;
1185
1186         media_svc_debug_func();
1187
1188         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
1189         media_svc_retvm_if(folder_path == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "folder_path is NULL");
1190         media_svc_retvm_if(count == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "count is NULL");
1191
1192         return _media_svc_count_invalid_folder_items(db_handle, folder_path, count);
1193 }