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                         ret = __media_svc_malloc_and_strncpy(&(content_info.thumbnail_path), thumb_path);
 388                         media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, &content_info);
 389                 }
 390
 391                 if (content_info.media_meta.width <= 0)
 392                         content_info.media_meta.width = width;
 393
 394                 if (content_info.media_meta.height <= 0)
 395                         content_info.media_meta.height = height;
 396         }
 397 #endif
 398         ret = _media_svc_insert_item_with_data(db_handle, &content_info, FALSE, FALSE);
 399
 400         if (ret == MEDIA_INFO_ERROR_NONE) {
 401                 media_svc_debug("Insertion is successful. Sending noti for this");
 402                 _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);
 403         }
 404
 405         _media_svc_destroy_content_info(&content_info);
 406         return ret;
 407 }
 408
 409 int media_svc_insert_folder(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, const char *path)
 410 {
 411         int ret = MEDIA_INFO_ERROR_NONE;
 412         sqlite3 * db_handle = (sqlite3 *)handle;
 413
 414         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 415         media_svc_retvm_if(!STRING_VALID(path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "path is NULL");
 416
 417         if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
 418                 media_svc_error("storage type is incorrect[%d]", storage_type);
 419                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 420         }
 421
 422         media_svc_debug("storage[%d], folder_path[%s]", storage_type, path);
 423
 424         /*Get folder info*/
 425         char *folder_name = NULL;
 426         int folder_modified_date = 0;
 427         char *folder_uuid = _media_info_generate_uuid();
 428         if(folder_uuid == NULL ) {
 429                 media_svc_error("Invalid UUID");
 430                 return MEDIA_INFO_ERROR_INTERNAL;
 431         }
 432
 433         folder_name = g_path_get_basename(path);
 434         folder_modified_date = _media_svc_get_file_time(path);
 435
 436         ret = _media_svc_append_folder(handle, storage_type, folder_uuid, path, folder_name, folder_modified_date);
 437         SAFE_FREE(folder_name);
 438
 439         if (ret < MEDIA_INFO_ERROR_NONE) {
 440                 media_svc_error("_media_svc_append_folder error [%d]", ret);
 441                 return ret;
 442         }
 443
 444         return MEDIA_INFO_ERROR_NONE;
 445 }
 446
 447 int media_svc_move_item_begin(MediaSvcHandle *handle, int data_cnt)
 448 {
 449         sqlite3 * db_handle = (sqlite3 *)handle;
 450
 451         media_svc_debug("Transaction data count : [%d]", data_cnt);
 452
 453         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 454         media_svc_retvm_if(data_cnt < 1, MEDIA_INFO_ERROR_INVALID_PARAMETER, "data_cnt shuld be bigger than 1");
 455
 456         g_media_svc_move_item_data_cnt  = data_cnt;
 457         g_media_svc_move_item_cur_data_cnt  = 0;
 458
 459         return MEDIA_INFO_ERROR_NONE;
 460 }
 461
 462 int media_svc_move_item_end(MediaSvcHandle *handle)
 463 {
 464         int ret = MEDIA_INFO_ERROR_NONE;
 465         sqlite3 * db_handle = (sqlite3 *)handle;
 466
 467         media_svc_debug_func();
 468
 469         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 470
 471         if (g_media_svc_move_item_cur_data_cnt  > 0) {
 472
 473                 ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_MOVE_ITEM);
 474         }
 475
 476         /*clean up old folder path*/
 477         ret = _media_svc_update_folder_table(handle);
 478         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 479
 480         g_media_svc_move_item_data_cnt  = 1;
 481         g_media_svc_move_item_cur_data_cnt  = 0;
 482
 483         return ret;
 484 }
 485
 486 int media_svc_move_item(MediaSvcHandle *handle, media_svc_storage_type_e src_storage, const char *src_path,
 487                         media_svc_storage_type_e dest_storage, const char *dest_path)
 488 {
 489         int ret = MEDIA_INFO_ERROR_NONE;
 490         sqlite3 * db_handle = (sqlite3 *)handle;
 491         char *file_name = NULL;
 492         char *folder_path = NULL;
 493         int modified_time = 0;
 494         char folder_uuid[MEDIA_SVC_UUID_SIZE+1] = {0,};
 495         char old_thumb_path[MEDIA_SVC_PATHNAME_SIZE] = {0,};
 496         char new_thumb_path[MEDIA_SVC_PATHNAME_SIZE] = {0,};
 497         int media_type = -1;
 498
 499         media_svc_debug_func();
 500
 501         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 502         media_svc_retvm_if(!STRING_VALID(src_path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "src_path is NULL");
 503         media_svc_retvm_if(!STRING_VALID(dest_path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "dest_path is NULL");
 504
 505         if ((src_storage != MEDIA_SVC_STORAGE_INTERNAL) && (src_storage != MEDIA_SVC_STORAGE_EXTERNAL)) {
 506                 media_svc_error("src_storage type is incorrect[%d]", src_storage);
 507                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 508         }
 509         if ((dest_storage != MEDIA_SVC_STORAGE_INTERNAL) && (dest_storage != MEDIA_SVC_STORAGE_EXTERNAL)) {
 510                 media_svc_error("dest_storage type is incorrect[%d]", dest_storage);
 511                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 512         }
 513
 514         /*check and update folder*/
 515         ret = _media_svc_get_and_append_folder_id_by_path(handle, dest_path, dest_storage, folder_uuid);
 516         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 517
 518         /*get filename*/
 519         file_name = g_path_get_basename(dest_path);
 520
 521         /*get modified_time*/
 522         modified_time = _media_svc_get_file_time(dest_path);
 523
 524         /*get thumbnail_path to update. only for Imgae and Video items. Audio share album_art(thumbnail)*/
 525         ret = _media_svc_get_media_type_by_path(handle, src_path, &media_type);
 526         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 527
 528         if((media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) ||(media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)) {
 529                 /*get old thumbnail_path*/
 530                 ret = _media_svc_get_thumbnail_path_by_path(handle, src_path, old_thumb_path);
 531                 media_svc_retv_if((ret != MEDIA_INFO_ERROR_NONE) && (ret != MEDIA_INFO_ERROR_DATABASE_NO_RECORD), ret);
 532
 533                 _media_svc_get_thumbnail_path(dest_storage, new_thumb_path, dest_path, THUMB_EXT);
 534         }
 535
 536         if (g_media_svc_move_item_data_cnt == 1) {
 537
 538                 /*update item*/
 539                 if((media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) ||(media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)) {
 540                         ret = _media_svc_update_item_by_path(handle, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, new_thumb_path, FALSE);
 541                 } else {
 542                         ret = _media_svc_update_item_by_path(handle, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, NULL, FALSE);
 543                 }
 544                 SAFE_FREE(file_name);
 545                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 546
 547                 media_svc_debug("Move is successful. Sending noti for this");
 548
 549                 /* Get notification info */
 550                 media_svc_noti_item *noti_item = NULL;
 551                 ret = _media_svc_get_noti_info(handle, dest_path, MS_MEDIA_ITEM_FILE, &noti_item);
 552                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 553
 554                 /* Send notification for move */
 555                 _media_svc_publish_noti(MS_MEDIA_ITEM_FILE, MS_MEDIA_ITEM_UPDATE, src_path, media_type, noti_item->media_uuid, noti_item->mime_type);
 556                 _media_svc_destroy_noti_item(noti_item);
 557
 558                 /*update folder modified_time*/
 559                 folder_path = g_path_get_dirname(dest_path);
 560                 ret = _media_svc_update_folder_modified_time_by_folder_uuid(handle, folder_uuid, folder_path, FALSE);
 561                 SAFE_FREE(folder_path);
 562                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 563
 564                 ret = _media_svc_update_folder_table(handle);
 565                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 566
 567         } else if (g_media_svc_move_item_cur_data_cnt  < (g_media_svc_move_item_data_cnt  - 1)) {
 568
 569                 /*update item*/
 570                 if((media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) ||(media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)) {
 571                         ret = _media_svc_update_item_by_path(handle, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, new_thumb_path, TRUE);
 572                 } else {
 573                         ret = _media_svc_update_item_by_path(handle, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, NULL, TRUE);
 574                 }
 575                 SAFE_FREE(file_name);
 576                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 577
 578                 /*update folder modified_time*/
 579                 folder_path = g_path_get_dirname(dest_path);
 580                 ret = _media_svc_update_folder_modified_time_by_folder_uuid(handle, folder_uuid, folder_path, TRUE);
 581                 SAFE_FREE(folder_path);
 582                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 583
 584                 g_media_svc_move_item_cur_data_cnt ++;
 585
 586         } else if (g_media_svc_move_item_cur_data_cnt  == (g_media_svc_move_item_data_cnt  - 1)) {
 587
 588                 /*update item*/
 589                 if((media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) ||(media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)) {
 590                         ret = _media_svc_update_item_by_path(handle, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, new_thumb_path, TRUE);
 591                 } else {
 592                         ret = _media_svc_update_item_by_path(handle, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, NULL, TRUE);
 593                 }
 594                 SAFE_FREE(file_name);
 595                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 596
 597                 /*update folder modified_time*/
 598                 folder_path = g_path_get_dirname(dest_path);
 599                 ret = _media_svc_update_folder_modified_time_by_folder_uuid(handle, folder_uuid, folder_path, TRUE);
 600                 SAFE_FREE(folder_path);
 601                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 602
 603                 /*update db*/
 604                 ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_MOVE_ITEM);
 605                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 606
 607                 g_media_svc_move_item_cur_data_cnt = 0;
 608
 609         } else {
 610                 media_svc_error("Error in media_svc_move_item");
 611                 return MEDIA_INFO_ERROR_INTERNAL;
 612         }
 613
 614         /*rename thumbnail file*/
 615         if((media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) ||(media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)) {
 616                 if(strlen(old_thumb_path) > 0) {
 617                         ret = _media_svc_rename_file(old_thumb_path,new_thumb_path);
 618                         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 619                 }
 620         }
 621
 622         return MEDIA_INFO_ERROR_NONE;
 623 }
 624
 625 int media_svc_set_item_validity_begin(MediaSvcHandle *handle, int data_cnt)
 626 {
 627         sqlite3 * db_handle = (sqlite3 *)handle;
 628
 629         media_svc_debug("Transaction data count : [%d]", data_cnt);
 630
 631         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 632         media_svc_retvm_if(data_cnt < 1, MEDIA_INFO_ERROR_INVALID_PARAMETER, "data_cnt shuld be bigger than 1");
 633
 634         g_media_svc_item_validity_data_cnt  = data_cnt;
 635         g_media_svc_item_validity_cur_data_cnt  = 0;
 636
 637         return MEDIA_INFO_ERROR_NONE;
 638 }
 639
 640 int media_svc_set_item_validity_end(MediaSvcHandle *handle)
 641 {
 642         int ret = MEDIA_INFO_ERROR_NONE;
 643         sqlite3 * db_handle = (sqlite3 *)handle;
 644
 645         media_svc_debug_func();
 646
 647         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 648
 649         if (g_media_svc_item_validity_cur_data_cnt  > 0) {
 650
 651                 ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_SET_ITEM_VALIDITY);
 652         }
 653
 654         g_media_svc_item_validity_data_cnt  = 1;
 655         g_media_svc_item_validity_cur_data_cnt  = 0;
 656
 657         return ret;
 658 }
 659
 660 int media_svc_set_item_validity(MediaSvcHandle *handle, const char *path, int validity)
 661 {
 662         int ret = MEDIA_INFO_ERROR_NONE;
 663         sqlite3 * db_handle = (sqlite3 *)handle;
 664
 665         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 666         media_svc_retvm_if(!STRING_VALID(path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "path is NULL");
 667
 668         media_svc_debug("path=[%s], validity=[%d]", path, validity);
 669
 670         if (g_media_svc_item_validity_data_cnt  == 1) {
 671
 672                 return _media_svc_update_item_validity(db_handle, path, validity, FALSE);
 673
 674         } else if (g_media_svc_item_validity_cur_data_cnt  < (g_media_svc_item_validity_data_cnt  - 1)) {
 675
 676                 ret = _media_svc_update_item_validity(db_handle, path, validity, TRUE);
 677                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 678
 679                 g_media_svc_item_validity_cur_data_cnt ++;
 680
 681         } else if (g_media_svc_item_validity_cur_data_cnt  == (g_media_svc_item_validity_data_cnt  - 1)) {
 682
 683                 ret = _media_svc_update_item_validity(db_handle, path, validity, TRUE);
 684                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 685
 686                 ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_SET_ITEM_VALIDITY);
 687                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 688
 689                 g_media_svc_item_validity_cur_data_cnt  = 0;
 690
 691         } else {
 692
 693                 media_svc_error("Error in media_svc_set_item_validity");
 694                 return MEDIA_INFO_ERROR_INTERNAL;
 695         }
 696
 697         return MEDIA_INFO_ERROR_NONE;
 698 }
 699
 700 int media_svc_delete_item_by_path(MediaSvcHandle *handle, const char *path)
 701 {
 702         int ret = MEDIA_INFO_ERROR_NONE;
 703         sqlite3 * db_handle = (sqlite3 *)handle;
 704         char thumb_path[MEDIA_SVC_PATHNAME_SIZE] = {0,};
 705
 706         media_svc_debug_func();
 707
 708         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 709         media_svc_retvm_if(!STRING_VALID(path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "path is NULL");
 710
 711         int media_type = -1;
 712         ret = _media_svc_get_media_type_by_path(db_handle, path, &media_type);
 713         media_svc_retv_if((ret != MEDIA_INFO_ERROR_NONE), ret);
 714
 715         if((media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) ||(media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)) {
 716                 /*Get thumbnail path to delete*/
 717                 ret = _media_svc_get_thumbnail_path_by_path(db_handle, path, thumb_path);
 718                 media_svc_retv_if((ret != MEDIA_INFO_ERROR_NONE) && (ret != MEDIA_INFO_ERROR_DATABASE_NO_RECORD), ret);
 719         } else if ((media_type == MEDIA_SVC_MEDIA_TYPE_SOUND) ||(media_type == MEDIA_SVC_MEDIA_TYPE_MUSIC)) {
 720                 int count = 0;
 721                 ret = _media_svc_get_media_count_with_album_id_by_path(db_handle, path, &count);
 722                 media_svc_retv_if((ret != MEDIA_INFO_ERROR_NONE), ret);
 723
 724                 if (count == 1) {
 725                         /*Get thumbnail path to delete*/
 726                         ret = _media_svc_get_thumbnail_path_by_path(db_handle, path, thumb_path);
 727                         media_svc_retv_if((ret != MEDIA_INFO_ERROR_NONE) && (ret != MEDIA_INFO_ERROR_DATABASE_NO_RECORD), ret);
 728                 }
 729         }
 730
 731         /* Get notification info */
 732         media_svc_noti_item *noti_item = NULL;
 733         ret = _media_svc_get_noti_info(handle, path, MS_MEDIA_ITEM_FILE, &noti_item);
 734         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 735
 736         /*Delete item*/
 737         ret = _media_svc_delete_item_by_path(db_handle, path);
 738         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 739
 740         /* Send notification */
 741         media_svc_debug("Deletion is successful. Sending noti for this");
 742         _media_svc_publish_noti(MS_MEDIA_ITEM_FILE, MS_MEDIA_ITEM_DELETE, path, media_type, noti_item->media_uuid, noti_item->mime_type);
 743         _media_svc_destroy_noti_item(noti_item);
 744
 745         /*Delete thumbnail*/
 746         if (strlen(thumb_path) > 0) {
 747                 if (_media_svc_remove_file(thumb_path) == FALSE) {
 748                         media_svc_error("fail to remove thumbnail file.");
 749                 }
 750         }
 751
 752         return MEDIA_INFO_ERROR_NONE;
 753 }
 754
 755 int media_svc_delete_all_items_in_storage(MediaSvcHandle *handle, media_svc_storage_type_e storage_type)
 756 {
 757         int ret = MEDIA_INFO_ERROR_NONE;
 758         sqlite3 * db_handle = (sqlite3 *)handle;
 759         char * dirpath = NULL;
 760
 761         media_svc_debug("media_svc_delete_all_items_in_storage [%d]", storage_type);
 762
 763         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 764
 765         if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
 766                 media_svc_error("storage type is incorrect[%d]", storage_type);
 767                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 768         }
 769
 770         ret = _media_svc_truncate_table(db_handle, storage_type);
 771         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 772
 773         dirpath = (storage_type == MEDIA_SVC_STORAGE_INTERNAL) ? MEDIA_SVC_THUMB_INTERNAL_PATH : MEDIA_SVC_THUMB_EXTERNAL_PATH;
 774
 775         /* remove thumbnails */
 776         ret = _media_svc_remove_all_files_in_dir(dirpath);
 777         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 778
 779         return MEDIA_INFO_ERROR_NONE;
 780 }
 781
 782 int media_svc_delete_invalid_items_in_storage(MediaSvcHandle *handle, media_svc_storage_type_e storage_type)
 783 {
 784         sqlite3 * db_handle = (sqlite3 *)handle;
 785
 786         media_svc_debug_func();
 787
 788         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 789
 790         if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
 791                 media_svc_error("storage type is incorrect[%d]", storage_type);
 792                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 793         }
 794
 795         /*Delete from DB and remove thumbnail files*/
 796         return _media_svc_delete_invalid_items(db_handle, storage_type);
 797 }
 798
 799 int media_svc_delete_invalid_items_in_folder(MediaSvcHandle *handle, const char *folder_path)
 800 {
 801         sqlite3 * db_handle = (sqlite3 *)handle;
 802
 803         media_svc_debug_func();
 804
 805         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 806
 807         /*Delete from DB and remove thumbnail files*/
 808         return _media_svc_delete_invalid_folder_items(db_handle, folder_path);
 809 }
 810
 811 int media_svc_set_all_storage_items_validity(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, int validity)
 812 {
 813         sqlite3 * db_handle = (sqlite3 *)handle;
 814
 815         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 816
 817         if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
 818                 media_svc_error("storage type is incorrect[%d]", storage_type);
 819                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 820         }
 821
 822         return _media_svc_update_storage_item_validity(db_handle, storage_type, validity);
 823 }
 824
 825 int media_svc_set_folder_items_validity(MediaSvcHandle *handle, const char *folder_path, int validity, int recursive)
 826 {
 827         sqlite3 * db_handle = (sqlite3 *)handle;
 828
 829         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 830         media_svc_retvm_if(!STRING_VALID(folder_path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "folder_path is NULL");
 831
 832         if(recursive)
 833                 return _media_svc_update_recursive_folder_item_validity(db_handle, folder_path, validity);
 834         else
 835                 return _media_svc_update_folder_item_validity(db_handle, folder_path, validity);
 836 }
 837
 838 int media_svc_refresh_item(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, const char *path)
 839 {
 840         int ret = MEDIA_INFO_ERROR_NONE;
 841         sqlite3 * db_handle = (sqlite3 *)handle;
 842         media_svc_media_type_e media_type;
 843         drm_content_info_s *drm_contentInfo = NULL;
 844
 845         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 846         media_svc_retvm_if(!STRING_VALID(path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "path is NULL");
 847
 848         if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
 849                 media_svc_error("storage type is incorrect[%d]", storage_type);
 850                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 851         }
 852
 853         /* Get notification info */
 854         media_svc_noti_item *noti_item = NULL;
 855         ret = _media_svc_get_noti_info(handle, path, MS_MEDIA_ITEM_FILE, &noti_item);
 856         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 857
 858         media_svc_content_info_s content_info;
 859         memset(&content_info, 0, sizeof(media_svc_content_info_s));
 860
 861         /*Set media info*/
 862         ret = _media_svc_set_media_info(&content_info, storage_type, path, &media_type, TRUE, &drm_contentInfo);
 863         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 864
 865         /* Initialize thumbnail information to remake thumbnail. */
 866         char thumb_path[MEDIA_SVC_PATHNAME_SIZE + 1];
 867         ret = _media_svc_get_thumbnail_path_by_path(handle, path, thumb_path);
 868         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 869
 870         if (g_file_test(thumb_path, G_FILE_TEST_EXISTS)) {
 871                 ret = _media_svc_remove_file(thumb_path);
 872                 media_svc_retv_if(ret != TRUE, ret);
 873         }
 874
 875         ret = _media_svc_update_thumbnail_path(handle, path, NULL);
 876         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 877
 878         if(media_type == MEDIA_SVC_MEDIA_TYPE_OTHER) {
 879                 /*Do nothing.*/
 880         } else if(media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) {
 881                 ret = _media_svc_extract_image_metadata(&content_info, media_type);
 882                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 883         } else {
 884                 ret = _media_svc_extract_media_metadata(handle, &content_info, media_type, drm_contentInfo);
 885                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 886         }
 887 #if 1
 888         /* Extracting thumbnail */
 889         if (media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE || media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO) {
 890                 char thumb_path[MEDIA_SVC_PATHNAME_SIZE + 1] = {0, };
 891                 int width = 0;
 892                 int height = 0;
 893
 894                 ret = thumbnail_request_from_db_with_size(content_info.path, thumb_path, sizeof(thumb_path), &width, &height);
 895                 if (ret < 0) {
 896                         media_svc_error("thumbnail_request_from_db failed: %d", ret);
 897                 } else {
 898                         media_svc_debug("thumbnail_request_from_db success: %s", thumb_path);
 899                         ret = __media_svc_malloc_and_strncpy(&(content_info.thumbnail_path), thumb_path);
 900                         media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, &content_info);
 901                 }
 902
 903                 if (content_info.media_meta.width <= 0)
 904                         content_info.media_meta.width = width;
 905
 906                 if (content_info.media_meta.height <= 0)
 907                         content_info.media_meta.height = height;
 908         }
 909 #endif
 910         ret = _media_svc_update_item_with_data(db_handle, &content_info);
 911
 912         if (ret == MEDIA_INFO_ERROR_NONE) {
 913                 media_svc_debug("Update is successful. Sending noti for this");
 914                 _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);
 915                 _media_svc_destroy_noti_item(noti_item);
 916         }
 917
 918         _media_svc_destroy_content_info(&content_info);
 919
 920         return ret;
 921 }
 922
 923 int media_svc_rename_folder(MediaSvcHandle *handle, const char *src_path, const char *dst_path)
 924 {
 925         sqlite3 * db_handle = (sqlite3 *)handle;
 926         int ret = MEDIA_INFO_ERROR_NONE;
 927
 928         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 929         media_svc_retvm_if(src_path == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "src_path is NULL");
 930         media_svc_retvm_if(dst_path == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "dst_path is NULL");
 931
 932         media_svc_debug("Src path : %s,  Dst Path : %s", src_path, dst_path);
 933
 934         /* Get notification info */
 935         media_svc_noti_item *noti_item = NULL;
 936         ret = _media_svc_get_noti_info(handle, src_path, MS_MEDIA_ITEM_DIRECTORY, &noti_item);
 937         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 938
 939         ret = _media_svc_sql_begin_trans(handle);
 940         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 941
 942         /* Update all folder record's path, which are matched by old parent path */
 943         char *update_folder_path_sql = NULL;
 944         char src_path_slash[MEDIA_SVC_PATHNAME_SIZE + 1];
 945         char dst_path_slash[MEDIA_SVC_PATHNAME_SIZE + 1];
 946
 947         snprintf(src_path_slash, sizeof(src_path_slash), "%s/", src_path);
 948         snprintf(dst_path_slash, sizeof(dst_path_slash), "%s/", dst_path);
 949
 950         update_folder_path_sql = sqlite3_mprintf("UPDATE folder SET path = REPLACE( path, '%q', '%q');", src_path_slash, dst_path_slash);
 951
 952         //ret = _media_svc_sql_query(handle, update_folder_path_sql);
 953         ret = media_db_request_update_db_batch(update_folder_path_sql);
 954         sqlite3_free(update_folder_path_sql);
 955
 956         if (ret != SQLITE_OK) {
 957                 media_svc_error("failed to update folder path");
 958                 _media_svc_sql_rollback_trans(handle);
 959
 960                 return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
 961         }
 962
 963         /* Update all folder record's modified date, which are changed above */
 964         char *update_folder_modified_time_sql = NULL;
 965         time_t date;
 966         time(&date);
 967
 968         update_folder_modified_time_sql = sqlite3_mprintf("UPDATE folder SET modified_time = %d where path like '%q';", date, dst_path);
 969
 970         ret = media_db_request_update_db_batch(update_folder_modified_time_sql);
 971         //ret = _media_svc_sql_query(handle, update_folder_modified_time_sql);
 972         sqlite3_free(update_folder_modified_time_sql);
 973
 974         if (ret != SQLITE_OK) {
 975                 media_svc_error("failed to update folder modified time");
 976                 _media_svc_sql_rollback_trans(handle);
 977
 978                 return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
 979         }
 980
 981         /* Update all items */
 982         char *select_all_sql = NULL;
 983         sqlite3_stmt *sql_stmt = NULL;
 984         char dst_child_path[MEDIA_SVC_PATHNAME_SIZE + 1];
 985
 986         snprintf(dst_child_path, sizeof(dst_child_path), "%s/%%", dst_path);
 987
 988         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);
 989
 990         media_svc_debug("[SQL query] : %s", select_all_sql);
 991
 992         ret = sqlite3_prepare_v2(handle, select_all_sql, -1, &sql_stmt, NULL);
 993         sqlite3_free((char *)select_all_sql);
 994
 995         if (ret != SQLITE_OK) {
 996                 media_svc_error ("prepare error [%s]", sqlite3_errmsg(handle));
 997                 _media_svc_sql_rollback_trans(handle);
 998                 return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
 999         }
1000
1001         while (1) {
1002                 ret = sqlite3_step(sql_stmt);
1003                 if (ret != SQLITE_ROW) {
1004                         media_svc_debug("end of iteration");
1005                         break;
1006                 }
1007
1008                 char media_uuid[MEDIA_SVC_UUID_SIZE + 1] = {0,};
1009                 char media_path[MEDIA_SVC_PATHNAME_SIZE + 1] = {0,};
1010                 char media_thumb_path[MEDIA_SVC_PATHNAME_SIZE + 1] = {0,};
1011                 char media_new_thumb_path[MEDIA_SVC_PATHNAME_SIZE + 1] = {0,};
1012                 int media_type;
1013                 bool no_thumb = FALSE;
1014
1015                 if (STRING_VALID((const char *)sqlite3_column_text(sql_stmt, 0))) {
1016                         strncpy(media_uuid,     (const char *)sqlite3_column_text(sql_stmt, 0), sizeof(media_uuid));
1017                         media_uuid[sizeof(media_uuid) - 1] = '\0';
1018                 } else {
1019                         media_svc_error("media UUID is NULL");
1020                         return MEDIA_INFO_ERROR_DATABASE_INVALID;
1021                 }
1022
1023                 if (STRING_VALID((const char *)sqlite3_column_text(sql_stmt, 1))) {
1024                         strncpy(media_path,     (const char *)sqlite3_column_text(sql_stmt, 1), sizeof(media_path));
1025                         media_path[sizeof(media_path) - 1] = '\0';
1026                 } else {
1027                         media_svc_error("media path is NULL");
1028                         return MEDIA_INFO_ERROR_DATABASE_INVALID;
1029                 }
1030
1031                 if (STRING_VALID((const char *)sqlite3_column_text(sql_stmt, 2))) {
1032                         strncpy(media_thumb_path,       (const char *)sqlite3_column_text(sql_stmt, 2), sizeof(media_thumb_path));
1033                         media_thumb_path[sizeof(media_thumb_path) - 1] = '\0';
1034                 } else {
1035                         media_svc_debug("media thumb path doesn't exist in DB");
1036                         no_thumb = TRUE;
1037                 }
1038
1039                 media_type = sqlite3_column_int(sql_stmt, 3);
1040
1041                 /* Update path, thumbnail path of this item */
1042                 char *replaced_path = NULL;
1043                 replaced_path = _media_svc_replace_path(media_path, src_path, dst_path);
1044                 if (replaced_path == NULL) {
1045                         media_svc_error("_media_svc_replace_path failed");
1046                         SQLITE3_FINALIZE(sql_stmt);
1047                         _media_svc_sql_rollback_trans(handle);
1048                         return MEDIA_INFO_ERROR_INTERNAL;
1049                 }
1050
1051                 media_svc_debug("New media path : %s", replaced_path);
1052                 media_svc_storage_type_e storage_type;
1053
1054                 if (!no_thumb) {
1055                         ret = _media_svc_get_store_type_by_path(replaced_path, &storage_type);
1056                         if (ret < 0) {
1057                                 media_svc_error("_media_svc_get_store_type_by_path failed : %d", ret);
1058                                 SAFE_FREE(replaced_path);
1059                                 _media_svc_sql_rollback_trans(handle);
1060                                 return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
1061                         }
1062
1063                         ret = _media_svc_get_thumbnail_path(storage_type, media_new_thumb_path, replaced_path, THUMB_EXT);
1064                         if (ret < 0) {
1065                                 media_svc_error("_media_svc_get_thumbnail_path failed : %d", ret);
1066                                 SAFE_FREE(replaced_path);
1067                                 SQLITE3_FINALIZE(sql_stmt);
1068                                 _media_svc_sql_rollback_trans(handle);
1069                                 return MEDIA_INFO_ERROR_INTERNAL;
1070                         }
1071
1072                         //media_svc_debug("New media thumbnail path : %s", media_new_thumb_path);
1073                 }
1074
1075                 char *update_item_sql = NULL;
1076
1077                 if (no_thumb) {
1078                         update_item_sql = sqlite3_mprintf("UPDATE media SET path='%q' WHERE media_uuid='%q'", replaced_path, media_uuid);
1079                 } else {
1080                         if (media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE || media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO) {
1081                                 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);
1082                         } else {
1083                                 update_item_sql = sqlite3_mprintf("UPDATE media SET path='%q', thumbnail_path='%q' WHERE media_uuid='%q'", replaced_path, media_thumb_path, media_uuid);
1084                         }
1085                 }
1086
1087                 ret = media_db_request_update_db_batch(update_item_sql);
1088                 //ret = _media_svc_sql_query(handle, update_item_sql);
1089                 sqlite3_free(update_item_sql);
1090                 SAFE_FREE(replaced_path);
1091
1092                 if (ret != SQLITE_OK) {
1093                         media_svc_error("failed to update item");
1094                         SQLITE3_FINALIZE(sql_stmt);
1095                         _media_svc_sql_rollback_trans(handle);
1096
1097                         return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
1098                 }
1099
1100                 /* Rename thumbnail file of file system */
1101                 if ((!no_thumb) && (media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE || media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)) {
1102                         ret = _media_svc_rename_file(media_thumb_path, media_new_thumb_path);
1103                         if (ret < 0) {
1104                                 media_svc_error("_media_svc_rename_file failed : %d", ret);
1105                                 SQLITE3_FINALIZE(sql_stmt);
1106                                 _media_svc_sql_rollback_trans(handle);
1107
1108                                 return MEDIA_INFO_ERROR_INTERNAL;
1109                         }
1110                 }
1111         }
1112
1113         SQLITE3_FINALIZE(sql_stmt);
1114
1115         ret = _media_svc_sql_end_trans(handle);
1116         if (ret != MEDIA_INFO_ERROR_NONE) {
1117                 media_svc_error("mb_svc_sqlite3_commit_trans failed.. Now start to rollback\n");
1118                 _media_svc_sql_rollback_trans(handle);
1119                 return ret;
1120         }
1121
1122         media_svc_debug("Folder update is successful. Sending noti for this");
1123         _media_svc_publish_noti(MS_MEDIA_ITEM_DIRECTORY, MS_MEDIA_ITEM_UPDATE, src_path, -1, noti_item->media_uuid, NULL);
1124         _media_svc_destroy_noti_item(noti_item);
1125
1126         return MEDIA_INFO_ERROR_NONE;
1127 }
1128
1129 int media_svc_request_update_db(const char *db_query)
1130 {
1131         int ret = MEDIA_INFO_ERROR_NONE;
1132
1133         media_svc_retvm_if(!STRING_VALID(db_query), MEDIA_INFO_ERROR_INVALID_PARAMETER, "db_query is NULL");
1134
1135         ret = _media_svc_request_update_db(db_query);
1136
1137         return _media_svc_error_convert(ret);
1138 }
1139
1140 int media_svc_send_dir_update_noti(MediaSvcHandle *handle, const char *dir_path)
1141 {
1142         int ret = MEDIA_INFO_ERROR_NONE;
1143         sqlite3 * db_handle = (sqlite3 *)handle;
1144
1145         media_svc_retvm_if(!STRING_VALID(dir_path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "dir_path is NULL");
1146
1147         /* Get notification info */
1148         media_svc_noti_item *noti_item = NULL;
1149         ret = _media_svc_get_noti_info(db_handle, dir_path, MS_MEDIA_ITEM_DIRECTORY, &noti_item);
1150         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
1151
1152         ret = _media_svc_publish_noti(MS_MEDIA_ITEM_DIRECTORY, MS_MEDIA_ITEM_UPDATE, dir_path, -1, noti_item->media_uuid, NULL);
1153         _media_svc_destroy_noti_item(noti_item);
1154
1155         return ret;
1156 }