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