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                 if (_media_svc_remove_file(thumb_path) == FALSE) {
 758                         media_svc_error("fail to remove thumbnail file.");
 759                 }
 760         }
 761
 762         return MEDIA_INFO_ERROR_NONE;
 763 }
 764
 765 int media_svc_delete_all_items_in_storage(MediaSvcHandle *handle, media_svc_storage_type_e storage_type)
 766 {
 767         int ret = MEDIA_INFO_ERROR_NONE;
 768         sqlite3 * db_handle = (sqlite3 *)handle;
 769         char * dirpath = NULL;
 770
 771         media_svc_debug("media_svc_delete_all_items_in_storage [%d]", storage_type);
 772
 773         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 774
 775         if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
 776                 media_svc_error("storage type is incorrect[%d]", storage_type);
 777                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 778         }
 779
 780         ret = _media_svc_truncate_table(db_handle, storage_type);
 781         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 782
 783         dirpath = (storage_type == MEDIA_SVC_STORAGE_INTERNAL) ? MEDIA_SVC_THUMB_INTERNAL_PATH : MEDIA_SVC_THUMB_EXTERNAL_PATH;
 784
 785         /* remove thumbnails */
 786         ret = _media_svc_remove_all_files_in_dir(dirpath);
 787         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 788
 789         return MEDIA_INFO_ERROR_NONE;
 790 }
 791
 792 int media_svc_delete_invalid_items_in_storage(MediaSvcHandle *handle, media_svc_storage_type_e storage_type)
 793 {
 794         sqlite3 * db_handle = (sqlite3 *)handle;
 795
 796         media_svc_debug_func();
 797
 798         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 799
 800         if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
 801                 media_svc_error("storage type is incorrect[%d]", storage_type);
 802                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 803         }
 804
 805         /*Delete from DB and remove thumbnail files*/
 806         return _media_svc_delete_invalid_items(db_handle, storage_type);
 807 }
 808
 809 int media_svc_delete_invalid_items_in_folder(MediaSvcHandle *handle, const char *folder_path)
 810 {
 811         sqlite3 * db_handle = (sqlite3 *)handle;
 812
 813         media_svc_debug_func();
 814
 815         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 816
 817         /*Delete from DB and remove thumbnail files*/
 818         return _media_svc_delete_invalid_folder_items(db_handle, folder_path);
 819 }
 820
 821 int media_svc_set_all_storage_items_validity(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, int validity)
 822 {
 823         sqlite3 * db_handle = (sqlite3 *)handle;
 824
 825         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 826
 827         if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
 828                 media_svc_error("storage type is incorrect[%d]", storage_type);
 829                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 830         }
 831
 832         return _media_svc_update_storage_item_validity(db_handle, storage_type, validity);
 833 }
 834
 835 int media_svc_set_folder_items_validity(MediaSvcHandle *handle, const char *folder_path, int validity, int recursive)
 836 {
 837         sqlite3 * db_handle = (sqlite3 *)handle;
 838
 839         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 840         media_svc_retvm_if(!STRING_VALID(folder_path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "folder_path is NULL");
 841
 842         if(recursive)
 843                 return _media_svc_update_recursive_folder_item_validity(db_handle, folder_path, validity);
 844         else
 845                 return _media_svc_update_folder_item_validity(db_handle, folder_path, validity);
 846 }
 847
 848 int media_svc_refresh_item(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, const char *path)
 849 {
 850         int ret = MEDIA_INFO_ERROR_NONE;
 851         sqlite3 * db_handle = (sqlite3 *)handle;
 852         media_svc_media_type_e media_type;
 853         drm_content_info_s *drm_contentInfo = NULL;
 854
 855         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 856         media_svc_retvm_if(!STRING_VALID(path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "path is NULL");
 857
 858         if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
 859                 media_svc_error("storage type is incorrect[%d]", storage_type);
 860                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 861         }
 862
 863         /* Get notification info */
 864         media_svc_noti_item *noti_item = NULL;
 865         ret = _media_svc_get_noti_info(handle, path, MS_MEDIA_ITEM_FILE, &noti_item);
 866         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 867
 868         media_svc_content_info_s content_info;
 869         memset(&content_info, 0, sizeof(media_svc_content_info_s));
 870
 871         /*Set media info*/
 872         ret = _media_svc_set_media_info(&content_info, storage_type, path, &media_type, TRUE, &drm_contentInfo);
 873         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 874
 875         /* Initialize thumbnail information to remake thumbnail. */
 876         char thumb_path[MEDIA_SVC_PATHNAME_SIZE + 1];
 877         ret = _media_svc_get_thumbnail_path_by_path(handle, path, thumb_path);
 878         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 879
 880         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)) {
 881                 ret = _media_svc_remove_file(thumb_path);
 882                 media_svc_retv_if(ret != TRUE, ret);
 883         }
 884
 885         ret = _media_svc_update_thumbnail_path(handle, path, NULL);
 886         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 887
 888         if(media_type == MEDIA_SVC_MEDIA_TYPE_OTHER) {
 889                 /*Do nothing.*/
 890         } else if(media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) {
 891                 ret = _media_svc_extract_image_metadata(&content_info, media_type);
 892                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 893         } else {
 894                 ret = _media_svc_extract_media_metadata(handle, &content_info, media_type, drm_contentInfo);
 895                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 896         }
 897 #if 1
 898         /* Extracting thumbnail */
 899         if (media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE || media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO) {
 900                 char thumb_path[MEDIA_SVC_PATHNAME_SIZE + 1] = {0, };
 901                 int width = 0;
 902                 int height = 0;
 903
 904                 ret = thumbnail_request_from_db_with_size(content_info.path, thumb_path, sizeof(thumb_path), &width, &height);
 905                 if (ret < 0) {
 906                         media_svc_error("thumbnail_request_from_db failed: %d", ret);
 907                 } else {
 908                         media_svc_debug("thumbnail_request_from_db success: %s", thumb_path);
 909                         __media_svc_malloc_and_strncpy(&(content_info.thumbnail_path), thumb_path);
 910                 }
 911
 912                 if (content_info.media_meta.width <= 0)
 913                         content_info.media_meta.width = width;
 914
 915                 if (content_info.media_meta.height <= 0)
 916                         content_info.media_meta.height = height;
 917         }
 918 #endif
 919         ret = _media_svc_update_item_with_data(db_handle, &content_info);
 920
 921         if (ret == MEDIA_INFO_ERROR_NONE) {
 922                 media_svc_debug("Update is successful. Sending noti for this");
 923                 _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);
 924         } else {
 925                 media_svc_error("_media_svc_update_item_with_data failed : %d", ret);
 926         }
 927
 928         _media_svc_destroy_content_info(&content_info);
 929         _media_svc_destroy_noti_item(noti_item);
 930
 931         return ret;
 932 }
 933
 934 int media_svc_rename_folder(MediaSvcHandle *handle, const char *src_path, const char *dst_path)
 935 {
 936         sqlite3 * db_handle = (sqlite3 *)handle;
 937         int ret = MEDIA_INFO_ERROR_NONE;
 938
 939         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 940         media_svc_retvm_if(src_path == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "src_path is NULL");
 941         media_svc_retvm_if(dst_path == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "dst_path is NULL");
 942
 943         media_svc_debug("Src path : %s,  Dst Path : %s", src_path, dst_path);
 944
 945         /* Get notification info */
 946         media_svc_noti_item *noti_item = NULL;
 947         ret = _media_svc_get_noti_info(handle, src_path, MS_MEDIA_ITEM_DIRECTORY, &noti_item);
 948         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 949
 950         ret = _media_svc_sql_begin_trans(handle);
 951         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 952
 953         /* Update all folder record's path, which are matched by old parent path */
 954         char *update_folder_path_sql = NULL;
 955         char src_path_slash[MEDIA_SVC_PATHNAME_SIZE + 1];
 956         char dst_path_slash[MEDIA_SVC_PATHNAME_SIZE + 1];
 957
 958         snprintf(src_path_slash, sizeof(src_path_slash), "%s/", src_path);
 959         snprintf(dst_path_slash, sizeof(dst_path_slash), "%s/", dst_path);
 960
 961         update_folder_path_sql = sqlite3_mprintf("UPDATE folder SET path = REPLACE( path, '%q', '%q');", src_path_slash, dst_path_slash);
 962
 963         //ret = _media_svc_sql_query(handle, update_folder_path_sql);
 964         ret = media_db_request_update_db_batch(update_folder_path_sql);
 965         sqlite3_free(update_folder_path_sql);
 966
 967         if (ret != SQLITE_OK) {
 968                 media_svc_error("failed to update folder path");
 969                 _media_svc_sql_rollback_trans(handle);
 970
 971                 return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
 972         }
 973
 974         /* Update all folder record's modified date, which are changed above */
 975         char *update_folder_modified_time_sql = NULL;
 976         time_t date;
 977         time(&date);
 978
 979         update_folder_modified_time_sql = sqlite3_mprintf("UPDATE folder SET modified_time = %d where path like '%q';", date, dst_path);
 980
 981         ret = media_db_request_update_db_batch(update_folder_modified_time_sql);
 982         //ret = _media_svc_sql_query(handle, update_folder_modified_time_sql);
 983         sqlite3_free(update_folder_modified_time_sql);
 984
 985         if (ret != SQLITE_OK) {
 986                 media_svc_error("failed to update folder modified time");
 987                 _media_svc_sql_rollback_trans(handle);
 988
 989                 return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
 990         }
 991
 992         /* Update all items */
 993         char *select_all_sql = NULL;
 994         sqlite3_stmt *sql_stmt = NULL;
 995         char dst_child_path[MEDIA_SVC_PATHNAME_SIZE + 1];
 996
 997         snprintf(dst_child_path, sizeof(dst_child_path), "%s/%%", dst_path);
 998
 999         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);
1000
1001         media_svc_debug("[SQL query] : %s", select_all_sql);
1002
1003         ret = sqlite3_prepare_v2(handle, select_all_sql, -1, &sql_stmt, NULL);
1004         sqlite3_free((char *)select_all_sql);
1005
1006         if (ret != SQLITE_OK) {
1007                 media_svc_error ("prepare error [%s]", sqlite3_errmsg(handle));
1008                 _media_svc_sql_rollback_trans(handle);
1009                 return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
1010         }
1011
1012         while (1) {
1013                 ret = sqlite3_step(sql_stmt);
1014                 if (ret != SQLITE_ROW) {
1015                         media_svc_debug("end of iteration");
1016                         break;
1017                 }
1018
1019                 char media_uuid[MEDIA_SVC_UUID_SIZE + 1] = {0,};
1020                 char media_path[MEDIA_SVC_PATHNAME_SIZE + 1] = {0,};
1021                 char media_thumb_path[MEDIA_SVC_PATHNAME_SIZE + 1] = {0,};
1022                 char media_new_thumb_path[MEDIA_SVC_PATHNAME_SIZE + 1] = {0,};
1023                 int media_type;
1024                 bool no_thumb = FALSE;
1025
1026                 if (STRING_VALID((const char *)sqlite3_column_text(sql_stmt, 0))) {
1027                         strncpy(media_uuid,     (const char *)sqlite3_column_text(sql_stmt, 0), sizeof(media_uuid));
1028                         media_uuid[sizeof(media_uuid) - 1] = '\0';
1029                 } else {
1030                         media_svc_error("media UUID is NULL");
1031                         return MEDIA_INFO_ERROR_DATABASE_INVALID;
1032                 }
1033
1034                 if (STRING_VALID((const char *)sqlite3_column_text(sql_stmt, 1))) {
1035                         strncpy(media_path,     (const char *)sqlite3_column_text(sql_stmt, 1), sizeof(media_path));
1036                         media_path[sizeof(media_path) - 1] = '\0';
1037                 } else {
1038                         media_svc_error("media path is NULL");
1039                         return MEDIA_INFO_ERROR_DATABASE_INVALID;
1040                 }
1041
1042                 if (STRING_VALID((const char *)sqlite3_column_text(sql_stmt, 2))) {
1043                         strncpy(media_thumb_path,       (const char *)sqlite3_column_text(sql_stmt, 2), sizeof(media_thumb_path));
1044                         media_thumb_path[sizeof(media_thumb_path) - 1] = '\0';
1045                 } else {
1046                         media_svc_debug("media thumb path doesn't exist in DB");
1047                         no_thumb = TRUE;
1048                 }
1049
1050                 media_type = sqlite3_column_int(sql_stmt, 3);
1051
1052                 /* Update path, thumbnail path of this item */
1053                 char *replaced_path = NULL;
1054                 replaced_path = _media_svc_replace_path(media_path, src_path, dst_path);
1055                 if (replaced_path == NULL) {
1056                         media_svc_error("_media_svc_replace_path failed");
1057                         SQLITE3_FINALIZE(sql_stmt);
1058                         _media_svc_sql_rollback_trans(handle);
1059                         return MEDIA_INFO_ERROR_INTERNAL;
1060                 }
1061
1062                 media_svc_debug("New media path : %s", replaced_path);
1063                 media_svc_storage_type_e storage_type;
1064
1065                 if (!no_thumb) {
1066                         /* If old thumb path is default or not */
1067                         if (strncmp(media_thumb_path, MEDIA_SVC_THUMB_DEFAULT_PATH, sizeof(MEDIA_SVC_THUMB_DEFAULT_PATH)) == 0) {
1068                                 strncpy(media_new_thumb_path, MEDIA_SVC_THUMB_DEFAULT_PATH, sizeof(media_new_thumb_path));
1069                         } else {
1070                                 ret = _media_svc_get_store_type_by_path(replaced_path, &storage_type);
1071                                 if (ret < 0) {
1072                                         media_svc_error("_media_svc_get_store_type_by_path failed : %d", ret);
1073                                         SAFE_FREE(replaced_path);
1074                                         _media_svc_sql_rollback_trans(handle);
1075                                         return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
1076                                 }
1077
1078                                 ret = _media_svc_get_thumbnail_path(storage_type, media_new_thumb_path, replaced_path, THUMB_EXT);
1079                                 if (ret < 0) {
1080                                         media_svc_error("_media_svc_get_thumbnail_path failed : %d", ret);
1081                                         SAFE_FREE(replaced_path);
1082                                         SQLITE3_FINALIZE(sql_stmt);
1083                                         _media_svc_sql_rollback_trans(handle);
1084                                         return MEDIA_INFO_ERROR_INTERNAL;
1085                                 }
1086                         }
1087
1088                         //media_svc_debug("New media thumbnail path : %s", media_new_thumb_path);
1089                 }
1090
1091                 char *update_item_sql = NULL;
1092
1093                 if (no_thumb) {
1094                         update_item_sql = sqlite3_mprintf("UPDATE media SET path='%q' WHERE media_uuid='%q'", replaced_path, media_uuid);
1095                 } else {
1096                         if (media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE || media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO) {
1097                                 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);
1098                         } else {
1099                                 update_item_sql = sqlite3_mprintf("UPDATE media SET path='%q', thumbnail_path='%q' WHERE media_uuid='%q'", replaced_path, media_thumb_path, media_uuid);
1100                         }
1101                 }
1102
1103                 ret = media_db_request_update_db_batch(update_item_sql);
1104                 //ret = _media_svc_sql_query(handle, update_item_sql);
1105                 sqlite3_free(update_item_sql);
1106                 SAFE_FREE(replaced_path);
1107
1108                 if (ret != SQLITE_OK) {
1109                         media_svc_error("failed to update item");
1110                         SQLITE3_FINALIZE(sql_stmt);
1111                         _media_svc_sql_rollback_trans(handle);
1112
1113                         return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
1114                 }
1115
1116                 /* Rename thumbnail file of file system */
1117                 if ((!no_thumb) && (media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE || media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)
1118                                 && (strncmp(media_thumb_path, MEDIA_SVC_THUMB_DEFAULT_PATH, sizeof(MEDIA_SVC_THUMB_DEFAULT_PATH)) != 0)) {
1119                         ret = _media_svc_rename_file(media_thumb_path, media_new_thumb_path);
1120                         if (ret < 0) {
1121                                 media_svc_error("_media_svc_rename_file failed : %d", ret);
1122                         }
1123                 }
1124         }
1125
1126         SQLITE3_FINALIZE(sql_stmt);
1127
1128         ret = _media_svc_sql_end_trans(handle);
1129         if (ret != MEDIA_INFO_ERROR_NONE) {
1130                 media_svc_error("mb_svc_sqlite3_commit_trans failed.. Now start to rollback\n");
1131                 _media_svc_sql_rollback_trans(handle);
1132                 return ret;
1133         }
1134
1135         media_svc_debug("Folder update is successful. Sending noti for this");
1136         _media_svc_publish_noti(MS_MEDIA_ITEM_DIRECTORY, MS_MEDIA_ITEM_UPDATE, src_path, -1, noti_item->media_uuid, NULL);
1137         _media_svc_destroy_noti_item(noti_item);
1138
1139         return MEDIA_INFO_ERROR_NONE;
1140 }
1141
1142 int media_svc_request_update_db(const char *db_query)
1143 {
1144         int ret = MEDIA_INFO_ERROR_NONE;
1145
1146         media_svc_retvm_if(!STRING_VALID(db_query), MEDIA_INFO_ERROR_INVALID_PARAMETER, "db_query is NULL");
1147
1148         ret = _media_svc_request_update_db(db_query);
1149
1150         return _media_svc_error_convert(ret);
1151 }
1152
1153 int media_svc_send_dir_update_noti(MediaSvcHandle *handle, const char *dir_path)
1154 {
1155         int ret = MEDIA_INFO_ERROR_NONE;
1156         sqlite3 * db_handle = (sqlite3 *)handle;
1157
1158         media_svc_retvm_if(!STRING_VALID(dir_path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "dir_path is NULL");
1159
1160         /* Get notification info */
1161         media_svc_noti_item *noti_item = NULL;
1162         ret = _media_svc_get_noti_info(db_handle, dir_path, MS_MEDIA_ITEM_DIRECTORY, &noti_item);
1163         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
1164
1165         ret = _media_svc_publish_noti(MS_MEDIA_ITEM_DIRECTORY, MS_MEDIA_ITEM_UPDATE, dir_path, -1, noti_item->media_uuid, NULL);
1166         _media_svc_destroy_noti_item(noti_item);
1167
1168         return ret;
1169 }
1170
1171 int media_svc_count_invalid_items_in_folder(MediaSvcHandle *handle, const char *folder_path, int *count)
1172 {
1173         sqlite3 * db_handle = (sqlite3 *)handle;
1174
1175         media_svc_debug_func();
1176
1177         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
1178         media_svc_retvm_if(folder_path == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "folder_path is NULL");
1179         media_svc_retvm_if(count == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "count is NULL");
1180
1181         return _media_svc_count_invalid_folder_items(db_handle, folder_path, count);
1182 }