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 <aul/aul.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
  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
  44
  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
 149         if (path == NULL)
 150                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 151
 152         /* In case of drm file. */
 153         if (_media_svc_is_drm_file(path)) {
 154                 ret =  _media_svc_get_mime_in_drm_info(path, mimetype);
 155                 if (ret != MEDIA_INFO_ERROR_NONE) {
 156                         media_svc_error("Fail to get mime");
 157                         return ret;
 158                 }
 159         } else {
 160                 /*in case of normal files */
 161                 if (aul_get_mime_from_file(path, mimetype, 255) < 0) {
 162                         media_svc_error("aul_get_mime_from_file fail");
 163                         return MEDIA_INFO_ERROR_INVALID_MEDIA;
 164                 }
 165         }
 166
 167         return MEDIA_INFO_ERROR_NONE;
 168 }
 169
 170 int media_svc_get_media_type(const char *path, const char *mime_type, media_svc_media_type_e *media_type)
 171 {
 172         int ret = MEDIA_INFO_ERROR_NONE;
 173         int category = 0;
 174
 175         media_svc_media_type_e type;
 176
 177         ret = _media_svc_get_content_type_from_mime(path, mime_type, &category);
 178         if (ret < 0) {
 179                 media_svc_error("_media_svc_get_content_type_from_mime failed : %d", ret);
 180         }
 181
 182         if (category & MEDIA_SVC_CATEGORY_SOUND)                type = MEDIA_SVC_MEDIA_TYPE_SOUND;
 183         else if (category & MEDIA_SVC_CATEGORY_MUSIC)   type = MEDIA_SVC_MEDIA_TYPE_MUSIC;
 184         else if (category & MEDIA_SVC_CATEGORY_IMAGE)   type = MEDIA_SVC_MEDIA_TYPE_IMAGE;
 185         else if (category & MEDIA_SVC_CATEGORY_VIDEO)   type = MEDIA_SVC_MEDIA_TYPE_VIDEO;
 186         else    type = MEDIA_SVC_MEDIA_TYPE_OTHER;
 187
 188         *media_type = type;
 189
 190         return ret;
 191 }
 192
 193 int media_svc_check_item_exist_by_path(MediaSvcHandle *handle, const char *path)
 194 {
 195         int ret = MEDIA_INFO_ERROR_NONE;
 196         sqlite3 * db_handle = (sqlite3 *)handle;
 197         int count = -1;
 198
 199         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 200         media_svc_retvm_if(!STRING_VALID(path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "Path is NULL");
 201
 202         ret = _media_svc_count_record_with_path(db_handle, path, &count);
 203         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 204
 205         if(count > 0) {
 206                 media_svc_debug("item is exist in database");
 207                 return MEDIA_INFO_ERROR_NONE;
 208         } else {
 209                 media_svc_debug("item is not exist in database");
 210                 return MEDIA_INFO_ERROR_DATABASE_NO_RECORD;
 211         }
 212
 213         return MEDIA_INFO_ERROR_NONE;
 214 }
 215
 216 int media_svc_insert_item_begin(MediaSvcHandle *handle, int data_cnt)
 217 {
 218         sqlite3 * db_handle = (sqlite3 *)handle;
 219
 220         media_svc_debug("Transaction data count : [%d]", data_cnt);
 221
 222         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 223         media_svc_retvm_if(data_cnt < 1, MEDIA_INFO_ERROR_INVALID_PARAMETER, "data_cnt shuld be bigger than 1");
 224
 225         g_media_svc_insert_item_data_cnt  = data_cnt;
 226         g_media_svc_insert_item_cur_data_cnt  = 0;
 227
 228         return MEDIA_INFO_ERROR_NONE;
 229 }
 230
 231 int media_svc_insert_item_end(MediaSvcHandle *handle)
 232 {
 233         int ret = MEDIA_INFO_ERROR_NONE;
 234         sqlite3 * db_handle = (sqlite3 *)handle;
 235
 236         media_svc_debug_func();
 237
 238         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 239
 240         if (g_media_svc_insert_item_cur_data_cnt  > 0) {
 241
 242                 ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_INSERT_ITEM);
 243         }
 244
 245         g_media_svc_insert_item_data_cnt  = 1;
 246         g_media_svc_insert_item_cur_data_cnt  = 0;
 247
 248         return ret;
 249 }
 250
 251 int media_svc_insert_item_bulk(MediaSvcHandle *handle, media_svc_storage_type_e storage_type,
 252                           const char *path, const char *mime_type, media_svc_media_type_e media_type)
 253 {
 254         int ret = MEDIA_INFO_ERROR_NONE;
 255         sqlite3 * db_handle = (sqlite3 *)handle;
 256         char folder_uuid[MEDIA_SVC_UUID_SIZE+1] = {0,};
 257
 258         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 259         media_svc_retvm_if(!STRING_VALID(path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "path is NULL");
 260         media_svc_retvm_if(!STRING_VALID(mime_type), MEDIA_INFO_ERROR_INVALID_PARAMETER, "mime_type is NULL");
 261
 262         if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
 263                 media_svc_error("storage type is incorrect[%d]", storage_type);
 264                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 265         }
 266
 267         if ((media_type < MEDIA_SVC_MEDIA_TYPE_IMAGE) || (media_type > MEDIA_SVC_MEDIA_TYPE_OTHER)) {
 268                 media_svc_error("invalid media_type condition[%d]", media_type);
 269                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 270         }
 271
 272         media_svc_debug("storage[%d], path[%s], media_type[%d]", storage_type, path, media_type);
 273
 274         media_svc_content_info_s content_info;
 275         memset(&content_info, 0, sizeof(media_svc_content_info_s));
 276
 277         /*Set media info*/
 278         ret = _media_svc_set_media_info(&content_info, storage_type, path, mime_type, media_type, FALSE);
 279         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 280
 281         if(media_type == MEDIA_SVC_MEDIA_TYPE_OTHER) {
 282                 /*Do nothing.*/
 283         } else if(media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) {
 284                 ret = _media_svc_extract_image_metadata(&content_info, media_type);
 285                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 286         } else {
 287                 ret = _media_svc_extract_media_metadata(handle, &content_info, media_type);
 288                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 289         }
 290
 291         /*Set or Get folder id*/
 292         ret = _media_svc_get_and_append_folder_id_by_path(handle, path, storage_type, folder_uuid);
 293         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 294
 295         ret = __media_svc_malloc_and_strncpy(&content_info.folder_uuid, folder_uuid);
 296         media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, &content_info);
 297
 298         if (g_media_svc_insert_item_data_cnt == 1) {
 299
 300                 ret = _media_svc_insert_item_with_data(db_handle, &content_info, FALSE);
 301                 media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, &content_info);
 302
 303         } else if(g_media_svc_insert_item_cur_data_cnt  < (g_media_svc_insert_item_data_cnt  - 1)) {
 304
 305                 ret = _media_svc_insert_item_with_data(db_handle, &content_info, TRUE);
 306                 media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, &content_info);
 307
 308                 g_media_svc_insert_item_cur_data_cnt ++;
 309
 310         } else if (g_media_svc_insert_item_cur_data_cnt  == (g_media_svc_insert_item_data_cnt  - 1)) {
 311
 312                 ret = _media_svc_insert_item_with_data(db_handle, &content_info, TRUE);
 313                 media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, &content_info);
 314
 315                 ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_INSERT_ITEM);
 316                 media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, &content_info);
 317
 318                 g_media_svc_insert_item_cur_data_cnt = 0;
 319
 320         } else {
 321                 media_svc_error("Error in media_svc_insert_item_bulk");
 322                 _media_svc_destroy_content_info(&content_info);
 323                 return MEDIA_INFO_ERROR_INTERNAL;
 324         }
 325
 326         _media_svc_destroy_content_info(&content_info);
 327
 328         return MEDIA_INFO_ERROR_NONE;
 329 }
 330
 331 int media_svc_insert_item_immediately(MediaSvcHandle *handle, media_svc_storage_type_e storage_type,
 332                           const char *path, const char *mime_type, media_svc_media_type_e media_type)
 333 {
 334         int ret = MEDIA_INFO_ERROR_NONE;
 335         sqlite3 * db_handle = (sqlite3 *)handle;
 336         char folder_uuid[MEDIA_SVC_UUID_SIZE+1] = {0,};
 337
 338         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 339         media_svc_retvm_if(!STRING_VALID(path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "path is NULL");
 340         media_svc_retvm_if(!STRING_VALID(mime_type), MEDIA_INFO_ERROR_INVALID_PARAMETER, "mime_type is NULL");
 341
 342         if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
 343                 media_svc_error("storage type is incorrect[%d]", storage_type);
 344                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 345         }
 346
 347         if ((media_type < MEDIA_SVC_MEDIA_TYPE_IMAGE) || (media_type > MEDIA_SVC_MEDIA_TYPE_OTHER)) {
 348                 media_svc_error("invalid media_type condition[%d]", media_type);
 349                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 350         }
 351
 352         media_svc_debug("storage[%d], path[%s], media_type[%d]", storage_type, path, media_type);
 353
 354         media_svc_content_info_s content_info;
 355         memset(&content_info, 0, sizeof(media_svc_content_info_s));
 356
 357         /*Set media info*/
 358         ret = _media_svc_set_media_info(&content_info, storage_type, path, mime_type, media_type, FALSE);
 359         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 360
 361         if(media_type == MEDIA_SVC_MEDIA_TYPE_OTHER) {
 362                 /*Do nothing.*/
 363         } else if(media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) {
 364                 ret = _media_svc_extract_image_metadata(&content_info, media_type);
 365                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 366         } else {
 367                 ret = _media_svc_extract_media_metadata(handle, &content_info, media_type);
 368                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 369         }
 370
 371         /*Set or Get folder id*/
 372         ret = _media_svc_get_and_append_folder_id_by_path(handle, path, storage_type, folder_uuid);
 373         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 374
 375         ret = __media_svc_malloc_and_strncpy(&content_info.folder_uuid, folder_uuid);
 376         media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, &content_info);
 377 #if 1
 378         /* Extracting thumbnail */
 379         if (media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE || media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO) {
 380                 char thumb_path[MEDIA_SVC_PATHNAME_SIZE + 1] = {0, };
 381                 int width = 0;
 382                 int height = 0;
 383
 384                 ret = thumbnail_request_from_db_with_size(content_info.path, thumb_path, sizeof(thumb_path), &width, &height);
 385                 if (ret < 0) {
 386                         media_svc_error("thumbnail_request_from_db failed: %d", ret);
 387                 } else {
 388                         media_svc_debug("thumbnail_request_from_db success: %s", thumb_path);
 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                 ret = __media_svc_malloc_and_strncpy(&(content_info.thumbnail_path), thumb_path);
 398                 media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, &content_info);
 399         }
 400 #endif
 401         ret = _media_svc_insert_item_with_data(db_handle, &content_info, FALSE);
 402
 403         _media_svc_destroy_content_info(&content_info);
 404         return ret;
 405 }
 406
 407 int media_svc_insert_folder(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, const char *path)
 408 {
 409         int ret = MEDIA_INFO_ERROR_NONE;
 410         sqlite3 * db_handle = (sqlite3 *)handle;
 411
 412         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 413         media_svc_retvm_if(!STRING_VALID(path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "path is NULL");
 414
 415         if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
 416                 media_svc_error("storage type is incorrect[%d]", storage_type);
 417                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 418         }
 419
 420         media_svc_debug("storage[%d], folder_path[%s]", storage_type, path);
 421
 422         /*Get folder info*/
 423         char *folder_name = NULL;
 424         int folder_modified_date = 0;
 425         char *folder_uuid = _media_info_generate_uuid();
 426         if(folder_uuid == NULL ) {
 427                 media_svc_error("Invalid UUID");
 428                 return MEDIA_INFO_ERROR_INTERNAL;
 429         }
 430
 431         folder_name = g_path_get_basename(path);
 432         folder_modified_date = _media_svc_get_file_time(path);
 433
 434         ret = _media_svc_append_folder(handle, storage_type, folder_uuid, path, folder_name, folder_modified_date);
 435         SAFE_FREE(folder_name);
 436
 437         if (ret < MEDIA_INFO_ERROR_NONE) {
 438                 media_svc_error("_media_svc_append_folder error [%d]", ret);
 439                 return ret;
 440         }
 441
 442         return MEDIA_INFO_ERROR_NONE;
 443 }
 444
 445 int media_svc_move_item_begin(MediaSvcHandle *handle, int data_cnt)
 446 {
 447         sqlite3 * db_handle = (sqlite3 *)handle;
 448
 449         media_svc_debug("Transaction data count : [%d]", data_cnt);
 450
 451         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 452         media_svc_retvm_if(data_cnt < 1, MEDIA_INFO_ERROR_INVALID_PARAMETER, "data_cnt shuld be bigger than 1");
 453
 454         g_media_svc_move_item_data_cnt  = data_cnt;
 455         g_media_svc_move_item_cur_data_cnt  = 0;
 456
 457         return MEDIA_INFO_ERROR_NONE;
 458 }
 459
 460 int media_svc_move_item_end(MediaSvcHandle *handle)
 461 {
 462         int ret = MEDIA_INFO_ERROR_NONE;
 463         sqlite3 * db_handle = (sqlite3 *)handle;
 464
 465         media_svc_debug_func();
 466
 467         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 468
 469         if (g_media_svc_move_item_cur_data_cnt  > 0) {
 470
 471                 ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_MOVE_ITEM);
 472         }
 473
 474         /*clean up old folder path*/
 475         ret = _media_svc_update_folder_table(handle);
 476         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 477
 478         g_media_svc_move_item_data_cnt  = 1;
 479         g_media_svc_move_item_cur_data_cnt  = 0;
 480
 481         return ret;
 482 }
 483
 484 int media_svc_move_item(MediaSvcHandle *handle, media_svc_storage_type_e src_storage, const char *src_path,
 485                         media_svc_storage_type_e dest_storage, const char *dest_path)
 486 {
 487         int ret = MEDIA_INFO_ERROR_NONE;
 488         sqlite3 * db_handle = (sqlite3 *)handle;
 489         char *file_name = NULL;
 490         char *folder_path = NULL;
 491         int modified_time = 0;
 492         char folder_uuid[MEDIA_SVC_UUID_SIZE+1] = {0,};
 493         char old_thumb_path[MEDIA_SVC_PATHNAME_SIZE] = {0,};
 494         char new_thumb_path[MEDIA_SVC_PATHNAME_SIZE] = {0,};
 495         int media_type = -1;
 496
 497         media_svc_debug_func();
 498
 499         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 500         media_svc_retvm_if(!STRING_VALID(src_path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "src_path is NULL");
 501         media_svc_retvm_if(!STRING_VALID(dest_path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "dest_path is NULL");
 502
 503         if ((src_storage != MEDIA_SVC_STORAGE_INTERNAL) && (src_storage != MEDIA_SVC_STORAGE_EXTERNAL)) {
 504                 media_svc_error("src_storage type is incorrect[%d]", src_storage);
 505                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 506         }
 507         if ((dest_storage != MEDIA_SVC_STORAGE_INTERNAL) && (dest_storage != MEDIA_SVC_STORAGE_EXTERNAL)) {
 508                 media_svc_error("dest_storage type is incorrect[%d]", dest_storage);
 509                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 510         }
 511
 512         /*check and update folder*/
 513         ret = _media_svc_get_and_append_folder_id_by_path(handle, dest_path, dest_storage, folder_uuid);
 514         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 515
 516         /*get filename*/
 517         file_name = g_path_get_basename(dest_path);
 518
 519         /*get modified_time*/
 520         modified_time = _media_svc_get_file_time(dest_path);
 521
 522         /*get thumbnail_path to update. only for Imgae and Video items. Audio share album_art(thumbnail)*/
 523         ret = _media_svc_get_media_type_by_path(handle, src_path, &media_type);
 524         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 525
 526         if((media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) ||(media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)) {
 527                 /*get old thumbnail_path*/
 528                 ret = _media_svc_get_thumbnail_path_by_path(handle, src_path, old_thumb_path);
 529                 media_svc_retv_if((ret != MEDIA_INFO_ERROR_NONE) && (ret != MEDIA_INFO_ERROR_DATABASE_NO_RECORD), ret);
 530
 531                 _media_svc_get_thumbnail_path(dest_storage, new_thumb_path, dest_path, THUMB_EXT);
 532         }
 533
 534         if (g_media_svc_move_item_data_cnt == 1) {
 535
 536                 /*update item*/
 537                 if((media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) ||(media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)) {
 538                         ret = _media_svc_update_item_by_path(handle, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, new_thumb_path, FALSE);
 539                 } else {
 540                         ret = _media_svc_update_item_by_path(handle, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, NULL, FALSE);
 541                 }
 542                 SAFE_FREE(file_name);
 543                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 544
 545                 /*update folder modified_time*/
 546                 folder_path = g_path_get_dirname(dest_path);
 547                 ret = _media_svc_update_folder_modified_time_by_folder_uuid(handle, folder_uuid, folder_path, FALSE);
 548                 SAFE_FREE(folder_path);
 549                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 550
 551                 ret = _media_svc_update_folder_table(handle);
 552                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 553
 554         } else if (g_media_svc_move_item_cur_data_cnt  < (g_media_svc_move_item_data_cnt  - 1)) {
 555
 556                 /*update item*/
 557                 if((media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) ||(media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)) {
 558                         ret = _media_svc_update_item_by_path(handle, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, new_thumb_path, TRUE);
 559                 } else {
 560                         ret = _media_svc_update_item_by_path(handle, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, NULL, TRUE);
 561                 }
 562                 SAFE_FREE(file_name);
 563                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 564
 565                 /*update folder modified_time*/
 566                 folder_path = g_path_get_dirname(dest_path);
 567                 ret = _media_svc_update_folder_modified_time_by_folder_uuid(handle, folder_uuid, folder_path, TRUE);
 568                 SAFE_FREE(folder_path);
 569                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 570
 571                 g_media_svc_move_item_cur_data_cnt ++;
 572
 573         } else if (g_media_svc_move_item_cur_data_cnt  == (g_media_svc_move_item_data_cnt  - 1)) {
 574
 575                 /*update item*/
 576                 if((media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) ||(media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)) {
 577                         ret = _media_svc_update_item_by_path(handle, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, new_thumb_path, TRUE);
 578                 } else {
 579                         ret = _media_svc_update_item_by_path(handle, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, NULL, TRUE);
 580                 }
 581                 SAFE_FREE(file_name);
 582                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 583
 584                 /*update folder modified_time*/
 585                 folder_path = g_path_get_dirname(dest_path);
 586                 ret = _media_svc_update_folder_modified_time_by_folder_uuid(handle, folder_uuid, folder_path, TRUE);
 587                 SAFE_FREE(folder_path);
 588                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 589
 590                 /*update db*/
 591                 ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_MOVE_ITEM);
 592                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 593
 594                 g_media_svc_move_item_cur_data_cnt = 0;
 595
 596         } else {
 597                 media_svc_error("Error in media_svc_move_item");
 598                 return MEDIA_INFO_ERROR_INTERNAL;
 599         }
 600
 601         /*rename thumbnail file*/
 602         if((media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) ||(media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)) {
 603                 if(strlen(old_thumb_path) > 0) {
 604                         ret = _media_svc_rename_file(old_thumb_path,new_thumb_path);
 605                         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 606                 }
 607         }
 608
 609         return MEDIA_INFO_ERROR_NONE;
 610 }
 611
 612 int media_svc_set_item_validity_begin(MediaSvcHandle *handle, int data_cnt)
 613 {
 614         sqlite3 * db_handle = (sqlite3 *)handle;
 615
 616         media_svc_debug("Transaction data count : [%d]", data_cnt);
 617
 618         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 619         media_svc_retvm_if(data_cnt < 1, MEDIA_INFO_ERROR_INVALID_PARAMETER, "data_cnt shuld be bigger than 1");
 620
 621         g_media_svc_item_validity_data_cnt  = data_cnt;
 622         g_media_svc_item_validity_cur_data_cnt  = 0;
 623
 624         return MEDIA_INFO_ERROR_NONE;
 625 }
 626
 627 int media_svc_set_item_validity_end(MediaSvcHandle *handle)
 628 {
 629         int ret = MEDIA_INFO_ERROR_NONE;
 630         sqlite3 * db_handle = (sqlite3 *)handle;
 631
 632         media_svc_debug_func();
 633
 634         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 635
 636         if (g_media_svc_item_validity_cur_data_cnt  > 0) {
 637
 638                 ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_SET_ITEM_VALIDITY);
 639         }
 640
 641         g_media_svc_item_validity_data_cnt  = 1;
 642         g_media_svc_item_validity_cur_data_cnt  = 0;
 643
 644         return ret;
 645 }
 646
 647 int media_svc_set_item_validity(MediaSvcHandle *handle, const char *path, int validity)
 648 {
 649         int ret = MEDIA_INFO_ERROR_NONE;
 650         sqlite3 * db_handle = (sqlite3 *)handle;
 651
 652         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 653         media_svc_retvm_if(!STRING_VALID(path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "path is NULL");
 654
 655         media_svc_debug("path=[%s], validity=[%d]", path, validity);
 656
 657         if (g_media_svc_item_validity_data_cnt  == 1) {
 658
 659                 return _media_svc_update_item_validity(db_handle, path, validity, FALSE);
 660
 661         } else if (g_media_svc_item_validity_cur_data_cnt  < (g_media_svc_item_validity_data_cnt  - 1)) {
 662
 663                 ret = _media_svc_update_item_validity(db_handle, path, validity, TRUE);
 664                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 665
 666                 g_media_svc_item_validity_cur_data_cnt ++;
 667
 668         } else if (g_media_svc_item_validity_cur_data_cnt  == (g_media_svc_item_validity_data_cnt  - 1)) {
 669
 670                 ret = _media_svc_update_item_validity(db_handle, path, validity, TRUE);
 671                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 672
 673                 ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_SET_ITEM_VALIDITY);
 674                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 675
 676                 g_media_svc_item_validity_cur_data_cnt  = 0;
 677
 678         } else {
 679
 680                 media_svc_error("Error in media_svc_set_item_validity");
 681                 return MEDIA_INFO_ERROR_INTERNAL;
 682         }
 683
 684         return MEDIA_INFO_ERROR_NONE;
 685 }
 686
 687 int media_svc_delete_item_by_path(MediaSvcHandle *handle, const char *path)
 688 {
 689         int ret = MEDIA_INFO_ERROR_NONE;
 690         sqlite3 * db_handle = (sqlite3 *)handle;
 691         char thumb_path[MEDIA_SVC_PATHNAME_SIZE] = {0,};
 692
 693         media_svc_debug_func();
 694
 695         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 696         media_svc_retvm_if(!STRING_VALID(path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "path is NULL");
 697
 698         /*Get thumbnail path to delete*/
 699         ret = _media_svc_get_thumbnail_path_by_path(db_handle, path, thumb_path);
 700         media_svc_retv_if((ret != MEDIA_INFO_ERROR_NONE) && (ret != MEDIA_INFO_ERROR_DATABASE_NO_RECORD), ret);
 701
 702         /*Delete item*/
 703         ret = _media_svc_delete_item_by_path(db_handle, path);
 704         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 705
 706         /*Delete thumbnail*/
 707         if (strlen(thumb_path) > 0) {
 708                 if (_media_svc_remove_file(thumb_path) == FALSE) {
 709                         media_svc_error("fail to remove thumbnail file.");
 710                         return MEDIA_INFO_ERROR_INTERNAL;
 711                 }
 712         }
 713
 714         return MEDIA_INFO_ERROR_NONE;
 715 }
 716
 717 int media_svc_delete_all_items_in_storage(MediaSvcHandle *handle, media_svc_storage_type_e storage_type)
 718 {
 719         int ret = MEDIA_INFO_ERROR_NONE;
 720         sqlite3 * db_handle = (sqlite3 *)handle;
 721         char * dirpath = NULL;
 722
 723         media_svc_debug("media_svc_delete_all_items_in_storage [%d]", storage_type);
 724
 725         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 726
 727         if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
 728                 media_svc_error("storage type is incorrect[%d]", storage_type);
 729                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 730         }
 731
 732         ret = _media_svc_truncate_table(db_handle, storage_type);
 733         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 734
 735         dirpath = (storage_type == MEDIA_SVC_STORAGE_INTERNAL) ? MEDIA_SVC_THUMB_INTERNAL_PATH : MEDIA_SVC_THUMB_EXTERNAL_PATH;
 736
 737         /* remove thumbnails */
 738         ret = _media_svc_remove_all_files_in_dir(dirpath);
 739         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 740
 741         return MEDIA_INFO_ERROR_NONE;
 742 }
 743
 744 int media_svc_delete_invalid_items_in_storage(MediaSvcHandle *handle, media_svc_storage_type_e storage_type)
 745 {
 746         sqlite3 * db_handle = (sqlite3 *)handle;
 747
 748         media_svc_debug_func();
 749
 750         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 751
 752         if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
 753                 media_svc_error("storage type is incorrect[%d]", storage_type);
 754                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 755         }
 756
 757         /*Delete from DB and remove thumbnail files*/
 758         return _media_svc_delete_invalid_items(db_handle, storage_type);
 759 }
 760
 761 int media_svc_delete_invalid_items_in_folder(MediaSvcHandle *handle, const char *folder_path)
 762 {
 763         sqlite3 * db_handle = (sqlite3 *)handle;
 764
 765         media_svc_debug_func();
 766
 767         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 768
 769         /*Delete from DB and remove thumbnail files*/
 770         return _media_svc_delete_invalid_folder_items(db_handle, folder_path);
 771 }
 772
 773 int media_svc_set_all_storage_items_validity(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, int validity)
 774 {
 775         sqlite3 * db_handle = (sqlite3 *)handle;
 776
 777         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 778
 779         if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
 780                 media_svc_error("storage type is incorrect[%d]", storage_type);
 781                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 782         }
 783
 784         return _media_svc_update_storage_item_validity(db_handle, storage_type, validity);
 785 }
 786
 787 int media_svc_set_folder_items_validity(MediaSvcHandle *handle, const char *folder_path, int validity, int recursive)
 788 {
 789         sqlite3 * db_handle = (sqlite3 *)handle;
 790
 791         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 792         media_svc_retvm_if(!STRING_VALID(folder_path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "folder_path is NULL");
 793
 794         if(recursive)
 795                 return _media_svc_update_recursive_folder_item_validity(db_handle, folder_path, validity);
 796         else
 797                 return _media_svc_update_folder_item_validity(db_handle, folder_path, validity);
 798 }
 799
 800 int media_svc_refresh_item(MediaSvcHandle *handle, media_svc_storage_type_e storage_type,
 801                           const char *path, media_svc_media_type_e media_type)
 802 {
 803         int ret = MEDIA_INFO_ERROR_NONE;
 804         sqlite3 * db_handle = (sqlite3 *)handle;
 805
 806         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 807         media_svc_retvm_if(!STRING_VALID(path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "path is NULL");
 808
 809         if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
 810                 media_svc_error("storage type is incorrect[%d]", storage_type);
 811                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 812         }
 813
 814         if ((media_type < MEDIA_SVC_MEDIA_TYPE_IMAGE) || (media_type > MEDIA_SVC_MEDIA_TYPE_OTHER)) {
 815                 media_svc_error("invalid media_type condition[%d]", media_type);
 816                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 817         }
 818
 819         media_svc_debug("storage[%d], path[%s], media_type[%d]", storage_type, path, media_type);
 820
 821         media_svc_content_info_s content_info;
 822         memset(&content_info, 0, sizeof(media_svc_content_info_s));
 823
 824         /*Set media info*/
 825         ret = _media_svc_set_media_info(&content_info, storage_type, path, NULL, media_type, TRUE);
 826         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 827
 828         /* Initialize thumbnail information to remake thumbnail. */
 829         char thumb_path[MEDIA_SVC_PATHNAME_SIZE + 1];
 830         ret = _media_svc_get_thumbnail_path_by_path(handle, path, thumb_path);
 831         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 832
 833         if (g_file_test(thumb_path, G_FILE_TEST_EXISTS)) {
 834                 ret = _media_svc_remove_file(thumb_path);
 835                 media_svc_retv_if(ret != TRUE, ret);
 836         }
 837
 838         ret = _media_svc_update_thumbnail_path(handle, path, NULL);
 839         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 840
 841         if(media_type == MEDIA_SVC_MEDIA_TYPE_OTHER) {
 842                 /*Do nothing.*/
 843         } else if(media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) {
 844                 ret = _media_svc_extract_image_metadata(&content_info, media_type);
 845                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 846         } else {
 847                 ret = _media_svc_extract_media_metadata(handle, &content_info, media_type);
 848                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 849         }
 850 #if 1
 851         /* Extracting thumbnail */
 852         if (media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE || media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO) {
 853                 char thumb_path[MEDIA_SVC_PATHNAME_SIZE + 1] = {0, };
 854                 int width = 0;
 855                 int height = 0;
 856
 857                 ret = thumbnail_request_from_db_with_size(content_info.path, thumb_path, sizeof(thumb_path), &width, &height);
 858                 if (ret < 0) {
 859                         media_svc_error("thumbnail_request_from_db failed: %d", ret);
 860                 } else {
 861                         media_svc_debug("thumbnail_request_from_db success: %s", thumb_path);
 862                 }
 863
 864                 if (content_info.media_meta.width <= 0)
 865                         content_info.media_meta.width = width;
 866
 867                 if (content_info.media_meta.height <= 0)
 868                         content_info.media_meta.height = height;
 869
 870                 ret = __media_svc_malloc_and_strncpy(&(content_info.thumbnail_path), thumb_path);
 871                 media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, &content_info);
 872         }
 873 #endif
 874         ret = _media_svc_update_item_with_data(db_handle, &content_info);
 875
 876         _media_svc_destroy_content_info(&content_info);
 877
 878         return ret;
 879 }
 880
 881 int media_svc_rename_folder(MediaSvcHandle *handle, const char *src_path, const char *dst_path)
 882 {
 883         sqlite3 * db_handle = (sqlite3 *)handle;
 884         int ret = MEDIA_INFO_ERROR_NONE;
 885
 886         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 887         media_svc_retvm_if(src_path == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "src_path is NULL");
 888         media_svc_retvm_if(dst_path == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "dst_path is NULL");
 889
 890         media_svc_debug("Src path : %s,  Dst Path : %s", src_path, dst_path);
 891
 892         ret = _media_svc_sql_begin_trans(handle);
 893         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 894
 895         /* Update all folder record's path, which are matched by old parent path */
 896         char *update_folder_path_sql = NULL;
 897         char src_path_slash[MEDIA_SVC_PATHNAME_SIZE + 1];
 898         char dst_path_slash[MEDIA_SVC_PATHNAME_SIZE + 1];
 899
 900         snprintf(src_path_slash, sizeof(src_path_slash), "%s/", src_path);
 901         snprintf(dst_path_slash, sizeof(dst_path_slash), "%s/", dst_path);
 902
 903         update_folder_path_sql = sqlite3_mprintf("UPDATE folder SET path = REPLACE( path, '%q', '%q');", src_path_slash, dst_path_slash);
 904
 905         //ret = _media_svc_sql_query(handle, update_folder_path_sql);
 906         ret = media_db_request_update_db_batch(update_folder_path_sql);
 907         sqlite3_free(update_folder_path_sql);
 908
 909         if (ret != SQLITE_OK) {
 910                 media_svc_error("failed to update folder path");
 911                 _media_svc_sql_rollback_trans(handle);
 912
 913                 return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
 914         }
 915
 916         /* Update all folder record's modified date, which are changed above */
 917         char *update_folder_modified_time_sql = NULL;
 918         time_t date;
 919         time(&date);
 920
 921         update_folder_modified_time_sql = sqlite3_mprintf("UPDATE folder SET modified_time = %d where path like '%q';", date, dst_path);
 922
 923         ret = media_db_request_update_db_batch(update_folder_modified_time_sql);
 924         //ret = _media_svc_sql_query(handle, update_folder_modified_time_sql);
 925         sqlite3_free(update_folder_modified_time_sql);
 926
 927         if (ret != SQLITE_OK) {
 928                 media_svc_error("failed to update folder modified time");
 929                 _media_svc_sql_rollback_trans(handle);
 930
 931                 return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
 932         }
 933
 934         /* Update all items */
 935         char *select_all_sql = NULL;
 936         sqlite3_stmt *sql_stmt = NULL;
 937         char dst_child_path[MEDIA_SVC_PATHNAME_SIZE + 1];
 938
 939         snprintf(dst_child_path, sizeof(dst_child_path), "%s/%%", dst_path);
 940
 941         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);
 942
 943         media_svc_debug("[SQL query] : %s", select_all_sql);
 944
 945         ret = sqlite3_prepare_v2(handle, select_all_sql, -1, &sql_stmt, NULL);
 946         sqlite3_free((char *)select_all_sql);
 947
 948         if (ret != SQLITE_OK) {
 949                 media_svc_error ("prepare error [%s]", sqlite3_errmsg(handle));
 950                 _media_svc_sql_rollback_trans(handle);
 951                 return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
 952         }
 953
 954         while (1) {
 955                 ret = sqlite3_step(sql_stmt);
 956                 if (ret != SQLITE_ROW) {
 957                         media_svc_debug("end of iteration");
 958                         break;
 959                 }
 960
 961                 char media_uuid[MEDIA_SVC_UUID_SIZE + 1] = {0,};
 962                 char media_path[MEDIA_SVC_PATHNAME_SIZE + 1] = {0,};
 963                 char media_thumb_path[MEDIA_SVC_PATHNAME_SIZE + 1] = {0,};
 964                 char media_new_thumb_path[MEDIA_SVC_PATHNAME_SIZE + 1] = {0,};
 965                 int media_type;
 966                 bool no_thumb = FALSE;
 967
 968                 if (STRING_VALID((const char *)sqlite3_column_text(sql_stmt, 0))) {
 969                         strncpy(media_uuid,     (const char *)sqlite3_column_text(sql_stmt, 0), sizeof(media_uuid));
 970                 } else {
 971                         media_svc_error("media UUID is NULL");
 972                         return MEDIA_INFO_ERROR_DATABASE_INVALID;
 973                 }
 974
 975                 if (STRING_VALID((const char *)sqlite3_column_text(sql_stmt, 1))) {
 976                         strncpy(media_path,     (const char *)sqlite3_column_text(sql_stmt, 1), sizeof(media_path));
 977                 } else {
 978                         media_svc_error("media path is NULL");
 979                         return MEDIA_INFO_ERROR_DATABASE_INVALID;
 980                 }
 981
 982                 if (STRING_VALID((const char *)sqlite3_column_text(sql_stmt, 2))) {
 983                         strncpy(media_thumb_path,       (const char *)sqlite3_column_text(sql_stmt, 2), sizeof(media_thumb_path));
 984                 } else {
 985                         media_svc_debug("media thumb path doesn't exist in DB");
 986                         no_thumb = TRUE;
 987                 }
 988
 989                 media_type = sqlite3_column_int(sql_stmt, 3);
 990
 991                 /* Update path, thumbnail path of this item */
 992                 char *replaced_path = NULL;
 993                 replaced_path = _media_svc_replace_path(media_path, src_path, dst_path);
 994                 if (replaced_path == NULL) {
 995                         media_svc_error("_media_svc_replace_path failed");
 996                         SQLITE3_FINALIZE(sql_stmt);
 997                         _media_svc_sql_rollback_trans(handle);
 998                         return MEDIA_INFO_ERROR_INTERNAL;
 999                 }
1000
1001                 media_svc_debug("New media path : %s", replaced_path);
1002                 media_svc_storage_type_e storage_type;
1003
1004                 if (!no_thumb) {
1005                         ret = _media_svc_get_store_type_by_path(replaced_path, &storage_type);
1006                         if (ret < 0) {
1007                                 media_svc_error("_media_svc_get_store_type_by_path failed : %d", ret);
1008                                 SAFE_FREE(replaced_path);
1009                                 _media_svc_sql_rollback_trans(handle);
1010                                 return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
1011                         }
1012
1013                         ret = _media_svc_get_thumbnail_path(storage_type, media_new_thumb_path, replaced_path, THUMB_EXT);
1014                         if (ret < 0) {
1015                                 media_svc_error("_media_svc_get_thumbnail_path failed : %d", ret);
1016                                 SAFE_FREE(replaced_path);
1017                                 SQLITE3_FINALIZE(sql_stmt);
1018                                 _media_svc_sql_rollback_trans(handle);
1019                                 return MEDIA_INFO_ERROR_INTERNAL;
1020                         }
1021
1022                         //media_svc_debug("New media thumbnail path : %s", media_new_thumb_path);
1023                 }
1024
1025                 char *update_item_sql = NULL;
1026
1027                 if (no_thumb) {
1028                         update_item_sql = sqlite3_mprintf("UPDATE media SET path='%q' WHERE media_uuid='%q'", replaced_path, media_uuid);
1029                 } else {
1030                         if (media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE || media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO) {
1031                                 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);
1032                         } else {
1033                                 update_item_sql = sqlite3_mprintf("UPDATE media SET path='%q', thumbnail_path='%q' WHERE media_uuid='%q'", replaced_path, media_thumb_path, media_uuid);
1034                         }
1035                 }
1036
1037                 ret = media_db_request_update_db_batch(update_item_sql);
1038                 //ret = _media_svc_sql_query(handle, update_item_sql);
1039                 sqlite3_free(update_item_sql);
1040                 SAFE_FREE(replaced_path);
1041
1042                 if (ret != SQLITE_OK) {
1043                         media_svc_error("failed to update item");
1044                         SQLITE3_FINALIZE(sql_stmt);
1045                         _media_svc_sql_rollback_trans(handle);
1046
1047                         return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
1048                 }
1049
1050                 /* Rename thumbnail file of file system */
1051                 if ((!no_thumb) && (media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE || media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)) {
1052                         ret = _media_svc_rename_file(media_thumb_path, media_new_thumb_path);
1053                         if (ret < 0) {
1054                                 media_svc_error("_media_svc_rename_file failed : %d", ret);
1055                                 SQLITE3_FINALIZE(sql_stmt);
1056                                 _media_svc_sql_rollback_trans(handle);
1057
1058                                 return MEDIA_INFO_ERROR_INTERNAL;
1059                         }
1060                 }
1061         }
1062
1063         SQLITE3_FINALIZE(sql_stmt);
1064
1065         ret = _media_svc_sql_end_trans(handle);
1066         if (ret != MEDIA_INFO_ERROR_NONE) {
1067                 media_svc_error("mb_svc_sqlite3_commit_trans failed.. Now start to rollback\n");
1068                 _media_svc_sql_rollback_trans(handle);
1069                 return ret;
1070         }
1071
1072         return MEDIA_INFO_ERROR_NONE;
1073 }
1074
1075 int media_svc_request_update_db(const char *db_query)
1076 {
1077         int ret = MEDIA_INFO_ERROR_NONE;
1078
1079         media_svc_retvm_if(!STRING_VALID(db_query), MEDIA_INFO_ERROR_INVALID_PARAMETER, "db_query is NULL");
1080
1081         ret = _media_svc_request_update_db(db_query);
1082
1083         return _media_svc_error_convert(ret);
1084 }