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 <errno.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, uid_t uid)
  47 {
  48         int ret = MS_MEDIA_ERR_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,uid);
  55         if(ret != MS_MEDIA_ERR_NONE)
  56                 return 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 != MS_MEDIA_ERR_NONE, ret);
  63 #endif
  64
  65         *handle = db_handle;
  66         return MS_MEDIA_ERR_NONE;
  67 }
  68
  69 int media_svc_disconnect(MediaSvcHandle *handle)
  70 {
  71         MediaDBHandle * db_handle = (MediaDBHandle *)handle;
  72
  73         media_svc_debug_func();
  74
  75         media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
  76
  77 #if 1   //Use libmedia_utils API
  78         int ret = MS_MEDIA_ERR_NONE;
  79
  80         ret = media_db_disconnect(db_handle);
  81         return ret;
  82 #else
  83         sqlite3 * db_handle = (sqlite3 *)handle;
  84
  85         return _media_svc_disconnect_db_with_handle(db_handle);
  86 #endif
  87 }
  88
  89 int media_svc_create_table(MediaSvcHandle *handle, uid_t uid)
  90 {
  91         int ret = MS_MEDIA_ERR_NONE;
  92         sqlite3 * db_handle = (sqlite3 *)handle;
  93
  94         media_svc_debug_func();
  95
  96         media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
  97
  98         /*create media table*/
  99         ret = _media_svc_create_media_table(handle, uid);
 100         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 101
 102         /*create folder table*/
 103         ret = _media_svc_create_folder_table(handle, uid);
 104         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 105
 106         /*create playlist table*/
 107         ret = _media_svc_create_playlist_table(handle, uid);
 108         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 109
 110         /* create album table*/
 111         ret = _media_svc_create_album_table(handle, uid);
 112         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 113
 114         /*create tag table*/
 115         ret = _media_svc_create_tag_table(handle,uid);
 116         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 117
 118         /*create bookmark table*/
 119         ret = _media_svc_create_bookmark_table(handle, uid);
 120         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 121
 122 #if 0   /*unify media and custom table*/
 123         /*create custom table*/
 124         ret = _media_svc_create_custom_table(handle, uid);
 125         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 126 #endif
 127
 128         return MS_MEDIA_ERR_NONE;
 129 }
 130
 131 int media_svc_get_storage_type(const char *path, media_svc_storage_type_e *storage_type)
 132 {
 133         int ret = MS_MEDIA_ERR_NONE;
 134         media_svc_storage_type_e type;
 135
 136         ret = _media_svc_get_store_type_by_path(path, &type);
 137         media_svc_retvm_if(ret < MS_MEDIA_ERR_NONE, ret, "_media_svc_get_store_type_by_path failed : %d", ret);
 138
 139         *storage_type = type;
 140
 141         return ret;
 142 }
 143
 144 int media_svc_get_mime_type(const char *path, char *mimetype)
 145 {
 146         int ret = MS_MEDIA_ERR_NONE;
 147
 148         ret = _media_svc_get_mime_type(path, mimetype);
 149
 150         return ret;
 151 }
 152
 153 int media_svc_get_media_type(const char *path, const char *mime_type, media_svc_media_type_e *media_type)
 154 {
 155         int ret = MS_MEDIA_ERR_NONE;
 156
 157         ret = _media_svc_get_media_type(path, mime_type, media_type);
 158
 159         return ret;
 160 }
 161
 162 int media_svc_check_item_exist_by_path(MediaSvcHandle *handle, const char *path)
 163 {
 164         int ret = MS_MEDIA_ERR_NONE;
 165         sqlite3 * db_handle = (sqlite3 *)handle;
 166         int count = -1;
 167
 168         media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 169         media_svc_retvm_if(!STRING_VALID(path), MS_MEDIA_ERR_INVALID_PARAMETER, "Path is NULL");
 170
 171         ret = _media_svc_count_record_with_path(db_handle, path, &count);
 172         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 173
 174         if(count > 0) {
 175                 media_svc_debug("item is exist in database");
 176                 return MS_MEDIA_ERR_NONE;
 177         } else {
 178                 media_svc_debug("item is not exist in database");
 179                 return MS_MEDIA_ERR_DB_NO_RECORD;
 180         }
 181
 182         return MS_MEDIA_ERR_NONE;
 183 }
 184
 185 int media_svc_insert_item_begin(MediaSvcHandle *handle, int data_cnt, int with_noti, int from_pid)
 186 {
 187         sqlite3 * db_handle = (sqlite3 *)handle;
 188
 189         media_svc_debug("Transaction data count : [%d]", data_cnt);
 190
 191         media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 192         media_svc_retvm_if(data_cnt < 1, MS_MEDIA_ERR_INVALID_PARAMETER, "data_cnt shuld be bigger than 1");
 193
 194         g_media_svc_insert_item_data_cnt  = data_cnt;
 195         g_media_svc_insert_item_cur_data_cnt  = 0;
 196
 197         /* Prepare for making noti item list */
 198         if (with_noti) {
 199                 media_svc_debug("making noti list from pid[%d]", from_pid);
 200                 if (_media_svc_create_noti_list(data_cnt) != MS_MEDIA_ERR_NONE) {
 201                         return MS_MEDIA_ERR_OUT_OF_MEMORY;
 202                 }
 203
 204                 _media_svc_set_noti_from_pid(from_pid);
 205                 g_insert_with_noti = TRUE;
 206         }
 207
 208         return MS_MEDIA_ERR_NONE;
 209 }
 210
 211 int media_svc_insert_item_end(MediaSvcHandle *handle, uid_t uid)
 212 {
 213         int ret = MS_MEDIA_ERR_NONE;
 214         sqlite3 * db_handle = (sqlite3 *)handle;
 215
 216         media_svc_debug_func();
 217
 218         media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 219
 220         if (g_media_svc_insert_item_cur_data_cnt  > 0) {
 221
 222                 ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_INSERT_ITEM, uid);
 223                 if (g_insert_with_noti) {
 224                         media_svc_debug("sending noti list");
 225                         _media_svc_publish_noti_list(g_media_svc_insert_item_cur_data_cnt);
 226                         _media_svc_destroy_noti_list(g_media_svc_insert_item_cur_data_cnt);
 227                         g_insert_with_noti = FALSE;
 228                         _media_svc_set_noti_from_pid(-1);
 229                 }
 230         }
 231
 232         g_media_svc_insert_item_data_cnt  = 1;
 233         g_media_svc_insert_item_cur_data_cnt  = 0;
 234
 235         return ret;
 236 }
 237
 238 int media_svc_insert_item_bulk(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, const char *path, int is_burst, uid_t uid)
 239 {
 240         int ret = MS_MEDIA_ERR_NONE;
 241         sqlite3 * db_handle = (sqlite3 *)handle;
 242         char folder_uuid[MEDIA_SVC_UUID_SIZE+1] = {0,};
 243         media_svc_media_type_e media_type;
 244
 245         media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 246         media_svc_retvm_if(!STRING_VALID(path), MS_MEDIA_ERR_INVALID_PARAMETER, "path is NULL");
 247
 248         if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
 249                 media_svc_error("storage type is incorrect[%d]", storage_type);
 250                 return MS_MEDIA_ERR_INVALID_PARAMETER;
 251         }
 252
 253         media_svc_content_info_s content_info;
 254         memset(&content_info, 0, sizeof(media_svc_content_info_s));
 255
 256         /*Set media info*/
 257         ret = _media_svc_set_media_info(&content_info, storage_type, path, &media_type, FALSE);
 258         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 259
 260         if(media_type == MEDIA_SVC_MEDIA_TYPE_OTHER) {
 261                 /*Do nothing.*/
 262         } else if(media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) {
 263                 ret = _media_svc_extract_image_metadata(&content_info, media_type);
 264         } else {
 265                 ret = _media_svc_extract_media_metadata(handle, &content_info, media_type, uid);
 266         }
 267         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 268
 269         /*Set or Get folder id*/
 270         ret = _media_svc_get_and_append_folder_id_by_path(handle, path, storage_type, folder_uuid, uid);
 271         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 272
 273         ret = __media_svc_malloc_and_strncpy(&content_info.folder_uuid, folder_uuid);
 274         media_svc_retv_del_if(ret != MS_MEDIA_ERR_NONE, ret, &content_info);
 275
 276         if (g_media_svc_insert_item_data_cnt == 1) {
 277
 278                 ret = _media_svc_insert_item_with_data(db_handle, &content_info, is_burst, FALSE, uid);
 279                 media_svc_retv_del_if(ret != MS_MEDIA_ERR_NONE, ret, &content_info);
 280
 281                 if (g_insert_with_noti)
 282                         _media_svc_insert_item_to_noti_list(&content_info, g_media_svc_insert_item_cur_data_cnt++);
 283
 284         } else if(g_media_svc_insert_item_cur_data_cnt  < (g_media_svc_insert_item_data_cnt  - 1)) {
 285
 286                 ret = _media_svc_insert_item_with_data(db_handle, &content_info, is_burst, TRUE, uid);
 287                 media_svc_retv_del_if(ret != MS_MEDIA_ERR_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                 g_media_svc_insert_item_cur_data_cnt ++;
 293
 294         } else if (g_media_svc_insert_item_cur_data_cnt  == (g_media_svc_insert_item_data_cnt  - 1)) {
 295
 296                 ret = _media_svc_insert_item_with_data(db_handle, &content_info, is_burst, TRUE, uid);
 297                 media_svc_retv_del_if(ret != MS_MEDIA_ERR_NONE, ret, &content_info);
 298
 299                 if (g_insert_with_noti)
 300                         _media_svc_insert_item_to_noti_list(&content_info, g_media_svc_insert_item_cur_data_cnt);
 301
 302                 ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_INSERT_ITEM, uid);
 303                 media_svc_retv_del_if(ret != MS_MEDIA_ERR_NONE, ret, &content_info);
 304
 305                 if (g_insert_with_noti) {
 306                         _media_svc_publish_noti_list(g_media_svc_insert_item_cur_data_cnt + 1);
 307                         _media_svc_destroy_noti_list(g_media_svc_insert_item_cur_data_cnt + 1);
 308
 309                         /* Recreate noti list */
 310                         if (_media_svc_create_noti_list(g_media_svc_insert_item_data_cnt) != MS_MEDIA_ERR_NONE) {
 311                                 return MS_MEDIA_ERR_OUT_OF_MEMORY;
 312                         }
 313                 }
 314
 315                 g_media_svc_insert_item_cur_data_cnt = 0;
 316
 317         } else {
 318                 media_svc_error("Error in media_svc_insert_item_bulk");
 319                 _media_svc_destroy_content_info(&content_info);
 320                 return MS_MEDIA_ERR_INTERNAL;
 321         }
 322
 323         _media_svc_destroy_content_info(&content_info);
 324
 325         return MS_MEDIA_ERR_NONE;
 326 }
 327
 328 int media_svc_insert_item_immediately(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, const char *path, uid_t uid)
 329 {
 330         int ret = MS_MEDIA_ERR_NONE;
 331         sqlite3 * db_handle = (sqlite3 *)handle;
 332         char folder_uuid[MEDIA_SVC_UUID_SIZE+1] = {0,};
 333         media_svc_media_type_e media_type;
 334
 335         media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 336         media_svc_retvm_if(!STRING_VALID(path), MS_MEDIA_ERR_INVALID_PARAMETER, "path is NULL");
 337
 338         if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
 339                 media_svc_error("storage type is incorrect[%d]", storage_type);
 340                 return MS_MEDIA_ERR_INVALID_PARAMETER;
 341         }
 342
 343         media_svc_content_info_s content_info;
 344         memset(&content_info, 0, sizeof(media_svc_content_info_s));
 345
 346         /*Set media info*/
 347         ret = _media_svc_set_media_info(&content_info, storage_type, path, &media_type, FALSE);
 348         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 349
 350         if(media_type == MEDIA_SVC_MEDIA_TYPE_OTHER) {
 351                 /*Do nothing.*/
 352         } else if(media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) {
 353                 ret = _media_svc_extract_image_metadata(&content_info, media_type);
 354                 media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 355         } else {
 356                 ret = _media_svc_extract_media_metadata(handle, &content_info, media_type, uid);
 357                 media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 358         }
 359
 360         /*Set or Get folder id*/
 361         ret = _media_svc_get_and_append_folder_id_by_path(handle, path, storage_type, folder_uuid, uid);
 362         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 363
 364         ret = __media_svc_malloc_and_strncpy(&content_info.folder_uuid, folder_uuid);
 365         media_svc_retv_del_if(ret != MS_MEDIA_ERR_NONE, ret, &content_info);
 366 #if 1
 367         /* Extracting thumbnail */
 368         if (media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE || media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO) {
 369                 char thumb_path[MEDIA_SVC_PATHNAME_SIZE + 1] = {0, };
 370                 int width = 0;
 371                 int height = 0;
 372
 373                 ret = thumbnail_request_from_db_with_size(content_info.path, thumb_path, sizeof(thumb_path), &width, &height, uid);
 374                 if (ret < 0) {
 375                         media_svc_error("thumbnail_request_from_db failed: %d", ret);
 376                 } else {
 377                         media_svc_debug("thumbnail_request_from_db success: %s", thumb_path);
 378                         ret = __media_svc_malloc_and_strncpy(&(content_info.thumbnail_path), thumb_path);
 379                         if (ret < 0) {
 380                                 media_svc_error("__media_svc_malloc_and_strncpy failed : %d", ret);
 381                         }
 382                 }
 383
 384                 if (content_info.media_meta.width <= 0)
 385                         content_info.media_meta.width = width;
 386
 387                 if (content_info.media_meta.height <= 0)
 388                         content_info.media_meta.height = height;
 389         }
 390 #endif
 391         ret = _media_svc_insert_item_with_data(db_handle, &content_info, FALSE, FALSE, uid);
 392
 393         if (ret == MS_MEDIA_ERR_NONE) {
 394                 media_svc_debug("Insertion is successful. Sending noti for this");
 395                 _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);
 396         }
 397
 398         _media_svc_destroy_content_info(&content_info);
 399         return ret;
 400 }
 401
 402 int media_svc_insert_folder(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, const char *path, uid_t uid)
 403 {
 404         int ret = MS_MEDIA_ERR_NONE;
 405         sqlite3 * db_handle = (sqlite3 *)handle;
 406
 407         media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 408         media_svc_retvm_if(!STRING_VALID(path), MS_MEDIA_ERR_INVALID_PARAMETER, "path is NULL");
 409
 410         if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
 411                 media_svc_error("storage type is incorrect[%d]", storage_type);
 412                 return MS_MEDIA_ERR_INVALID_PARAMETER;
 413         }
 414
 415         media_svc_debug("storage[%d], folder_path[%s]", storage_type, path);
 416
 417         /*Get folder info*/
 418         char *folder_name = NULL;
 419         int folder_modified_date = 0;
 420         char *folder_uuid = _media_info_generate_uuid();
 421         if(folder_uuid == NULL ) {
 422                 media_svc_error("Invalid UUID");
 423                 return MS_MEDIA_ERR_INTERNAL;
 424         }
 425
 426         folder_name = g_path_get_basename(path);
 427         folder_modified_date = _media_svc_get_file_time(path);
 428
 429         ret = _media_svc_append_folder(handle, storage_type, folder_uuid, path, folder_name, folder_modified_date, uid);
 430         SAFE_FREE(folder_name);
 431
 432         if (ret != MS_MEDIA_ERR_NONE) {
 433                 media_svc_error("_media_svc_append_folder error [%d]", ret);
 434                 return ret;
 435         }
 436
 437         return MS_MEDIA_ERR_NONE;
 438 }
 439
 440 int media_svc_move_item_begin(MediaSvcHandle *handle, int data_cnt)
 441 {
 442         sqlite3 * db_handle = (sqlite3 *)handle;
 443
 444         media_svc_debug("Transaction data count : [%d]", data_cnt);
 445
 446         media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 447         media_svc_retvm_if(data_cnt < 1, MS_MEDIA_ERR_INVALID_PARAMETER, "data_cnt shuld be bigger than 1");
 448
 449         g_media_svc_move_item_data_cnt  = data_cnt;
 450         g_media_svc_move_item_cur_data_cnt  = 0;
 451
 452         return MS_MEDIA_ERR_NONE;
 453 }
 454
 455 int media_svc_move_item_end(MediaSvcHandle *handle, uid_t uid)
 456 {
 457         int ret = MS_MEDIA_ERR_NONE;
 458         sqlite3 * db_handle = (sqlite3 *)handle;
 459
 460         media_svc_debug_func();
 461
 462         media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 463
 464         if (g_media_svc_move_item_cur_data_cnt  > 0) {
 465
 466                 ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_MOVE_ITEM, uid);
 467         }
 468
 469         /*clean up old folder path*/
 470         ret = _media_svc_update_folder_table(handle, uid);
 471         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 472
 473         g_media_svc_move_item_data_cnt  = 1;
 474         g_media_svc_move_item_cur_data_cnt  = 0;
 475
 476         return ret;
 477 }
 478
 479 int media_svc_move_item(MediaSvcHandle *handle, media_svc_storage_type_e src_storage, const char *src_path,
 480                         media_svc_storage_type_e dest_storage, const char *dest_path, uid_t uid)
 481 {
 482         int ret = MS_MEDIA_ERR_NONE;
 483         sqlite3 * db_handle = (sqlite3 *)handle;
 484         char *file_name = NULL;
 485         char *folder_path = NULL;
 486         int modified_time = 0;
 487         char folder_uuid[MEDIA_SVC_UUID_SIZE+1] = {0,};
 488         char old_thumb_path[MEDIA_SVC_PATHNAME_SIZE] = {0,};
 489         char new_thumb_path[MEDIA_SVC_PATHNAME_SIZE] = {0,};
 490         int media_type = -1;
 491
 492         media_svc_debug_func();
 493
 494         media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 495         media_svc_retvm_if(!STRING_VALID(src_path), MS_MEDIA_ERR_INVALID_PARAMETER, "src_path is NULL");
 496         media_svc_retvm_if(!STRING_VALID(dest_path), MS_MEDIA_ERR_INVALID_PARAMETER, "dest_path is NULL");
 497
 498         if ((src_storage != MEDIA_SVC_STORAGE_INTERNAL) && (src_storage != MEDIA_SVC_STORAGE_EXTERNAL)) {
 499                 media_svc_error("src_storage type is incorrect[%d]", src_storage);
 500                 return MS_MEDIA_ERR_INVALID_PARAMETER;
 501         }
 502         if ((dest_storage != MEDIA_SVC_STORAGE_INTERNAL) && (dest_storage != MEDIA_SVC_STORAGE_EXTERNAL)) {
 503                 media_svc_error("dest_storage type is incorrect[%d]", dest_storage);
 504                 return MS_MEDIA_ERR_INVALID_PARAMETER;
 505         }
 506
 507         /*check and update folder*/
 508         ret = _media_svc_get_and_append_folder_id_by_path(handle, dest_path, dest_storage, folder_uuid, uid);
 509         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 510
 511         /*get filename*/
 512         file_name = g_path_get_basename(dest_path);
 513
 514         /*get modified_time*/
 515         modified_time = _media_svc_get_file_time(dest_path);
 516
 517         /*get thumbnail_path to update. only for Imgae and Video items. Audio share album_art(thumbnail)*/
 518         ret = _media_svc_get_media_type_by_path(handle, src_path, &media_type);
 519         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 520
 521         if((media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) ||(media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)) {
 522                 /*get old thumbnail_path*/
 523                 ret = _media_svc_get_thumbnail_path_by_path(handle, src_path, old_thumb_path);
 524                 media_svc_retv_if((ret != MS_MEDIA_ERR_NONE) && (ret != MS_MEDIA_ERR_DB_NO_RECORD), ret);
 525
 526                 /* If old thumb path is default or not */
 527                 if (strncmp(old_thumb_path, _media_svc_get_thumb_default_path(uid), sizeof(_media_svc_get_thumb_default_path(uid))) == 0) {
 528                         strncpy(new_thumb_path, _media_svc_get_thumb_default_path(uid), sizeof(new_thumb_path));
 529                 } else {
 530                         _media_svc_get_thumbnail_path(dest_storage, new_thumb_path, dest_path, THUMB_EXT, uid);
 531                 }
 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, uid);
 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, uid);
 541                 }
 542                 SAFE_FREE(file_name);
 543                 media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 544
 545                 media_svc_debug("Move is successful. Sending noti for this");
 546
 547                 /* Get notification info */
 548                 media_svc_noti_item *noti_item = NULL;
 549                 ret = _media_svc_get_noti_info(handle, dest_path, MS_MEDIA_ITEM_FILE, &noti_item);
 550                 media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 551
 552                 /* Send notification for move */
 553                 _media_svc_publish_noti(MS_MEDIA_ITEM_FILE, MS_MEDIA_ITEM_UPDATE, src_path, media_type, noti_item->media_uuid, noti_item->mime_type);
 554                 _media_svc_destroy_noti_item(noti_item);
 555
 556                 /*update folder modified_time*/
 557                 folder_path = g_path_get_dirname(dest_path);
 558                 ret = _media_svc_update_folder_modified_time_by_folder_uuid(handle, folder_uuid, folder_path, FALSE, uid);
 559                 SAFE_FREE(folder_path);
 560                 media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 561
 562                 ret = _media_svc_update_folder_table(handle, uid);
 563                 media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 564
 565         } else if (g_media_svc_move_item_cur_data_cnt  < (g_media_svc_move_item_data_cnt  - 1)) {
 566
 567                 /*update item*/
 568                 if((media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) ||(media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)) {
 569                         ret = _media_svc_update_item_by_path(handle, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, new_thumb_path, TRUE, uid);
 570                 } else {
 571                         ret = _media_svc_update_item_by_path(handle, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, NULL, TRUE, uid);
 572                 }
 573                 SAFE_FREE(file_name);
 574                 media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 575
 576                 /*update folder modified_time*/
 577                 folder_path = g_path_get_dirname(dest_path);
 578                 ret = _media_svc_update_folder_modified_time_by_folder_uuid(handle, folder_uuid, folder_path, TRUE, uid);
 579                 SAFE_FREE(folder_path);
 580                 media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 581
 582                 g_media_svc_move_item_cur_data_cnt ++;
 583
 584         } else if (g_media_svc_move_item_cur_data_cnt  == (g_media_svc_move_item_data_cnt  - 1)) {
 585
 586                 /*update item*/
 587                 if((media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) ||(media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)) {
 588                         ret = _media_svc_update_item_by_path(handle, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, new_thumb_path, TRUE, uid);
 589                 } else {
 590                         ret = _media_svc_update_item_by_path(handle, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, NULL, TRUE, uid);
 591                 }
 592                 SAFE_FREE(file_name);
 593                 media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 594
 595                 /*update folder modified_time*/
 596                 folder_path = g_path_get_dirname(dest_path);
 597                 ret = _media_svc_update_folder_modified_time_by_folder_uuid(handle, folder_uuid, folder_path, TRUE, uid);
 598                 SAFE_FREE(folder_path);
 599                 media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 600
 601                 /*update db*/
 602                 ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_MOVE_ITEM, uid);
 603                 media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 604
 605                 g_media_svc_move_item_cur_data_cnt = 0;
 606
 607         } else {
 608                 media_svc_error("Error in media_svc_move_item");
 609                 return MS_MEDIA_ERR_INTERNAL;
 610         }
 611
 612         /*rename thumbnail file*/
 613         if((media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) ||(media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)) {
 614                 if((strlen(old_thumb_path) > 0) && (strncmp(old_thumb_path, _media_svc_get_thumb_default_path(uid), sizeof(_media_svc_get_thumb_default_path(uid))) != 0)) {
 615                         ret = _media_svc_rename_file(old_thumb_path,new_thumb_path);
 616                         if (ret != MS_MEDIA_ERR_NONE)
 617                                 media_svc_error("_media_svc_rename_file failed : %d", ret);
 618                 }
 619         }
 620
 621         return MS_MEDIA_ERR_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, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 631         media_svc_retvm_if(data_cnt < 1, MS_MEDIA_ERR_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 MS_MEDIA_ERR_NONE;
 637 }
 638
 639 int media_svc_set_item_validity_end(MediaSvcHandle *handle, uid_t uid)
 640 {
 641         int ret = MS_MEDIA_ERR_NONE;
 642         sqlite3 * db_handle = (sqlite3 *)handle;
 643
 644         media_svc_debug_func();
 645
 646         media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_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, uid);
 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,uid_t uid)
 660 {
 661         int ret = MS_MEDIA_ERR_NONE;
 662         sqlite3 * db_handle = (sqlite3 *)handle;
 663
 664         media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 665         media_svc_retvm_if(!STRING_VALID(path), MS_MEDIA_ERR_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, uid);
 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, uid);
 676                 media_svc_retv_if(ret != MS_MEDIA_ERR_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, uid);
 683                 media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 684
 685                 ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_SET_ITEM_VALIDITY, uid);
 686                 media_svc_retv_if(ret != MS_MEDIA_ERR_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 MS_MEDIA_ERR_INTERNAL;
 694         }
 695
 696         return MS_MEDIA_ERR_NONE;
 697 }
 698
 699 int media_svc_delete_item_by_path(MediaSvcHandle *handle, const char *storage_id, const char *path, uid_t uid)
 700 {
 701         int ret = MS_MEDIA_ERR_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, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 708         media_svc_retvm_if(!STRING_VALID(path), MS_MEDIA_ERR_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 != MS_MEDIA_ERR_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 != MS_MEDIA_ERR_NONE) && (ret != MS_MEDIA_ERR_DB_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 != MS_MEDIA_ERR_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 != MS_MEDIA_ERR_NONE) && (ret != MS_MEDIA_ERR_DB_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 != MS_MEDIA_ERR_NONE, ret);
 734
 735         /*Delete item*/
 736         ret = _media_svc_delete_item_by_path(db_handle, path, uid);
 737         if (ret != MS_MEDIA_ERR_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) && (strncmp(thumb_path, _media_svc_get_thumb_default_path(uid), sizeof(_media_svc_get_thumb_default_path(uid))) != 0)) {
 751                 int thumb_count = 1;
 752                 /* Get count of media, which contains same thumbnail for music */
 753                 if ((media_type == MEDIA_SVC_MEDIA_TYPE_SOUND) ||(media_type == MEDIA_SVC_MEDIA_TYPE_MUSIC)) {
 754                         ret = _media_svc_get_thumbnail_count(db_handle, thumb_path, &thumb_count);
 755                         if (ret != MS_MEDIA_ERR_NONE) {
 756                                 media_svc_error("Failed to get thumbnail count : %d", ret);
 757                         }
 758                 }
 759
 760                 if (thumb_count == 1) {
 761                         if (_media_svc_remove_file(thumb_path) == FALSE) {
 762                                 media_svc_error("fail to remove thumbnail file.");
 763                         }
 764                 }
 765         }
 766
 767         return MS_MEDIA_ERR_NONE;
 768 }
 769
 770 int media_svc_delete_all_items_in_storage(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, uid_t uid)
 771 {
 772         int ret = MS_MEDIA_ERR_NONE;
 773         sqlite3 * db_handle = (sqlite3 *)handle;
 774         char * dirpath = NULL;
 775
 776         media_svc_debug("media_svc_delete_all_items_in_storage [%d]", storage_type);
 777
 778         media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 779
 780         if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
 781                 media_svc_error("storage type is incorrect[%d]", storage_type);
 782                 return MS_MEDIA_ERR_INVALID_PARAMETER;
 783         }
 784
 785         ret = _media_svc_truncate_table(db_handle, storage_type, uid);
 786         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 787
 788         dirpath = (storage_type == MEDIA_SVC_STORAGE_INTERNAL) ? _media_svc_get_thumb_internal_path(uid) : _media_svc_get_thumb_external_path(uid);
 789
 790         /* remove thumbnails */
 791         ret = _media_svc_remove_all_files_in_dir(dirpath);
 792         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 793
 794         return MS_MEDIA_ERR_NONE;
 795 }
 796
 797 int media_svc_delete_invalid_items_in_storage(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, uid_t uid)
 798 {
 799         sqlite3 * db_handle = (sqlite3 *)handle;
 800
 801         media_svc_debug_func();
 802
 803         media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 804
 805         if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
 806                 media_svc_error("storage type is incorrect[%d]", storage_type);
 807                 return MS_MEDIA_ERR_INVALID_PARAMETER;
 808         }
 809
 810         /*Delete from DB and remove thumbnail files*/
 811         return _media_svc_delete_invalid_items(db_handle, storage_type, uid);
 812 }
 813
 814 int media_svc_delete_invalid_items_in_folder(MediaSvcHandle *handle, const char *folder_path, uid_t uid)
 815 {
 816         sqlite3 * db_handle = (sqlite3 *)handle;
 817
 818         media_svc_debug_func();
 819
 820         media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 821
 822         /*Delete from DB and remove thumbnail files*/
 823         return _media_svc_delete_invalid_folder_items(db_handle, folder_path, uid);
 824 }
 825
 826 int media_svc_set_all_storage_items_validity(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, int validity, uid_t uid)
 827 {
 828         sqlite3 * db_handle = (sqlite3 *)handle;
 829
 830         media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 831
 832         if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
 833                 media_svc_error("storage type is incorrect[%d]", storage_type);
 834                 return MS_MEDIA_ERR_INVALID_PARAMETER;
 835         }
 836
 837         return _media_svc_update_storage_item_validity(db_handle, storage_type, validity, uid);
 838 }
 839
 840 int media_svc_set_folder_items_validity(MediaSvcHandle *handle, const char *folder_path, int validity, int recursive, uid_t uid)
 841 {
 842         sqlite3 * db_handle = (sqlite3 *)handle;
 843
 844         media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 845         media_svc_retvm_if(!STRING_VALID(folder_path), MS_MEDIA_ERR_INVALID_PARAMETER, "folder_path is NULL");
 846
 847         if(recursive)
 848                 return _media_svc_update_recursive_folder_item_validity(db_handle, folder_path, validity , uid);
 849         else
 850                 return _media_svc_update_folder_item_validity(db_handle, folder_path, validity, uid);
 851 }
 852
 853 int media_svc_refresh_item(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, const char *storage_id, const char *path, uid_t uid)
 854 {
 855         int ret = MS_MEDIA_ERR_NONE;
 856         sqlite3 * db_handle = (sqlite3 *)handle;
 857         media_svc_media_type_e media_type;
 858
 859         media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 860         media_svc_retvm_if(!STRING_VALID(path), MS_MEDIA_ERR_INVALID_PARAMETER, "path is NULL");
 861
 862         if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
 863                 media_svc_error("storage type is incorrect[%d]", storage_type);
 864                 return MS_MEDIA_ERR_INVALID_PARAMETER;
 865         }
 866
 867         media_svc_content_info_s content_info;
 868         memset(&content_info, 0, sizeof(media_svc_content_info_s));
 869
 870         /*Set media info*/
 871         ret = _media_svc_set_media_info(&content_info, storage_type, path, &media_type, TRUE);
 872         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 873
 874         /* Initialize thumbnail information to remake thumbnail. */
 875         char thumb_path[MEDIA_SVC_PATHNAME_SIZE + 1];
 876         ret = _media_svc_get_thumbnail_path_by_path(handle, path, thumb_path);
 877         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 878
 879         if (g_file_test(thumb_path, G_FILE_TEST_EXISTS) && (strncmp(thumb_path, _media_svc_get_thumb_default_path(uid), sizeof(_media_svc_get_thumb_default_path(uid))) != 0)) {
 880                 ret = _media_svc_remove_file(thumb_path);
 881                 if (ret != MS_MEDIA_ERR_NONE) {
 882                         media_svc_error("_media_svc_remove_file failed : %s", thumb_path);
 883                 }
 884         }
 885
 886         ret = _media_svc_update_thumbnail_path(handle, path, NULL, uid);
 887         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 888
 889         /* Get notification info */
 890         media_svc_noti_item *noti_item = NULL;
 891         ret = _media_svc_get_noti_info(handle, path, MS_MEDIA_ITEM_FILE, &noti_item);
 892         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 893
 894         media_type = noti_item->media_type;
 895
 896         if(media_type == MEDIA_SVC_MEDIA_TYPE_OTHER) {
 897                 /*Do nothing.*/
 898         } else if(media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) {
 899                 ret = _media_svc_extract_image_metadata(&content_info, media_type);
 900                 if (ret != MS_MEDIA_ERR_NONE) {
 901                         _media_svc_destroy_noti_item(noti_item);
 902                         return ret;
 903                 }
 904         } else {
 905                 ret = _media_svc_extract_media_metadata(handle, &content_info, media_type, uid);
 906                 if (ret != MS_MEDIA_ERR_NONE) {
 907                         _media_svc_destroy_noti_item(noti_item);
 908                         return ret;
 909                 }
 910         }
 911 #if 1
 912         /* Extracting thumbnail */
 913         if (media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE || media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO) {
 914                 char thumb_path[MEDIA_SVC_PATHNAME_SIZE + 1] = {0, };
 915                 int width = 0;
 916                 int height = 0;
 917
 918                 ret = thumbnail_request_from_db_with_size(content_info.path, thumb_path, sizeof(thumb_path), &width, &height, uid);
 919                 if (ret < 0) {
 920                         media_svc_error("thumbnail_request_from_db failed: %d", ret);
 921                 } else {
 922                         media_svc_debug("thumbnail_request_from_db success: %s", thumb_path);
 923                         ret = __media_svc_malloc_and_strncpy(&(content_info.thumbnail_path), thumb_path);
 924                         if (ret < 0) {
 925                                 media_svc_error("__media_svc_malloc_and_strncpy failed : %d", ret);
 926                         }
 927                 }
 928
 929                 if (content_info.media_meta.width <= 0)
 930                         content_info.media_meta.width = width;
 931
 932                 if (content_info.media_meta.height <= 0)
 933                         content_info.media_meta.height = height;
 934         }
 935 #endif
 936         ret = _media_svc_update_item_with_data(db_handle, &content_info, uid);
 937
 938         if (ret == MS_MEDIA_ERR_NONE) {
 939                 media_svc_debug("Update is successful. Sending noti for this");
 940                 _media_svc_publish_noti(MS_MEDIA_ITEM_FILE, MS_MEDIA_ITEM_UPDATE, content_info.path, noti_item->media_type, noti_item->media_uuid, noti_item->mime_type);
 941         } else {
 942                 media_svc_error("_media_svc_update_item_with_data failed : %d", ret);
 943         }
 944
 945         _media_svc_destroy_content_info(&content_info);
 946         _media_svc_destroy_noti_item(noti_item);
 947
 948         return ret;
 949 }
 950
 951 int media_svc_rename_folder(MediaSvcHandle *handle, const char *storage_id, const char *src_path, const char *dst_path, uid_t uid)
 952 {
 953         sqlite3 * db_handle = (sqlite3 *)handle;
 954         int ret = MS_MEDIA_ERR_NONE;
 955
 956         media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 957         media_svc_retvm_if(src_path == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "src_path is NULL");
 958         media_svc_retvm_if(dst_path == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "dst_path is NULL");
 959
 960         media_svc_debug("Src path : %s,  Dst Path : %s", src_path, dst_path);
 961
 962         /* Get notification info */
 963         media_svc_noti_item *noti_item = NULL;
 964         ret = _media_svc_get_noti_info(handle, src_path, MS_MEDIA_ITEM_DIRECTORY, &noti_item);
 965         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 966
 967         ret = _media_svc_sql_begin_trans(handle,uid);
 968         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 969
 970         /* Update all folder record's path, which are matched by old parent path */
 971         char *update_folder_path_sql = NULL;
 972         char src_path_slash[MEDIA_SVC_PATHNAME_SIZE + 1] = {0,};
 973         char dst_path_slash[MEDIA_SVC_PATHNAME_SIZE + 1] = {0,};
 974
 975         snprintf(src_path_slash, sizeof(src_path_slash), "%s/", src_path);
 976         snprintf(dst_path_slash, sizeof(dst_path_slash), "%s/", dst_path);
 977
 978         update_folder_path_sql = sqlite3_mprintf("UPDATE folder SET path = REPLACE( path, '%q', '%q');", src_path_slash, dst_path_slash);
 979
 980         //ret = _media_svc_sql_query(handle, update_folder_path_sql);
 981         ret = media_db_request_update_db_batch(update_folder_path_sql, uid);
 982         sqlite3_free(update_folder_path_sql);
 983
 984         if (ret != SQLITE_OK) {
 985                 media_svc_error("failed to update folder path");
 986                 _media_svc_sql_rollback_trans(handle, uid);
 987
 988                 return MS_MEDIA_ERR_DB_INTERNAL;
 989         }
 990
 991         /* Update all folder record's modified date, which are changed above */
 992         char *update_folder_modified_time_sql = NULL;
 993         time_t date;
 994         time(&date);
 995
 996         update_folder_modified_time_sql = sqlite3_mprintf("UPDATE folder SET modified_time = %d where path like '%q';", date, dst_path);
 997
 998         ret = media_db_request_update_db_batch(update_folder_modified_time_sql, uid);
 999         //ret = _media_svc_sql_query(handle, update_folder_modified_time_sql);
1000         sqlite3_free(update_folder_modified_time_sql);
1001
1002         if (ret != SQLITE_OK) {
1003                 media_svc_error("failed to update folder modified time");
1004                 _media_svc_sql_rollback_trans(handle, uid);
1005
1006                 return MS_MEDIA_ERR_DB_INTERNAL;
1007         }
1008
1009         /* Update all items */
1010         char *select_all_sql = NULL;
1011         sqlite3_stmt *sql_stmt = NULL;
1012         char dst_child_path[MEDIA_SVC_PATHNAME_SIZE + 1];
1013
1014         snprintf(dst_child_path, sizeof(dst_child_path), "%s/%%", dst_path);
1015
1016         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);
1017
1018         media_svc_debug("[SQL query] : %s", select_all_sql);
1019
1020         ret = sqlite3_prepare_v2(handle, select_all_sql, -1, &sql_stmt, NULL);
1021         sqlite3_free((char *)select_all_sql);
1022
1023         if (ret != MS_MEDIA_ERR_NONE) {
1024                 media_svc_error ("prepare error [%s]", sqlite3_errmsg(handle));
1025                 _media_svc_sql_rollback_trans(handle, uid);
1026                 return MS_MEDIA_ERR_DB_INTERNAL;
1027         }
1028
1029         while (1) {
1030                 ret = sqlite3_step(sql_stmt);
1031                 if (ret != SQLITE_ROW) {
1032                         media_svc_debug("end of iteration");
1033                         break;
1034                 }
1035
1036                 char media_uuid[MEDIA_SVC_UUID_SIZE + 1] = {0,};
1037                 char media_path[MEDIA_SVC_PATHNAME_SIZE + 1] = {0,};
1038                 char media_thumb_path[MEDIA_SVC_PATHNAME_SIZE + 1] = {0,};
1039                 char media_new_thumb_path[MEDIA_SVC_PATHNAME_SIZE + 1] = {0,};
1040                 int media_type;
1041                 bool no_thumb = FALSE;
1042
1043                 if (STRING_VALID((const char *)sqlite3_column_text(sql_stmt, 0))) {
1044                         strncpy(media_uuid,     (const char *)sqlite3_column_text(sql_stmt, 0), sizeof(media_uuid));
1045                         media_uuid[sizeof(media_uuid) - 1] = '\0';
1046                 } else {
1047                         media_svc_error("media UUID is NULL");
1048                         return MS_MEDIA_ERR_DB_INTERNAL;
1049                 }
1050
1051                 if (STRING_VALID((const char *)sqlite3_column_text(sql_stmt, 1))) {
1052                         strncpy(media_path,     (const char *)sqlite3_column_text(sql_stmt, 1), sizeof(media_path));
1053                         media_path[sizeof(media_path) - 1] = '\0';
1054                 } else {
1055                         media_svc_error("media path is NULL");
1056                         return MS_MEDIA_ERR_DB_INTERNAL;
1057                 }
1058
1059                 if (STRING_VALID((const char *)sqlite3_column_text(sql_stmt, 2))) {
1060                         strncpy(media_thumb_path,       (const char *)sqlite3_column_text(sql_stmt, 2), sizeof(media_thumb_path));
1061                         media_thumb_path[sizeof(media_thumb_path) - 1] = '\0';
1062                 } else {
1063                         media_svc_debug("media thumb path doesn't exist in DB");
1064                         no_thumb = TRUE;
1065                 }
1066
1067                 media_type = sqlite3_column_int(sql_stmt, 3);
1068
1069                 /* Update path, thumbnail path of this item */
1070                 char *replaced_path = NULL;
1071                 replaced_path = _media_svc_replace_path(media_path, src_path, dst_path);
1072                 if (replaced_path == NULL) {
1073                         media_svc_error("_media_svc_replace_path failed");
1074                         SQLITE3_FINALIZE(sql_stmt);
1075                         _media_svc_sql_rollback_trans(handle, uid);
1076                         return MS_MEDIA_ERR_INTERNAL;
1077                 }
1078
1079                 media_svc_debug("New media path : %s", replaced_path);
1080                 media_svc_storage_type_e storage_type;
1081
1082                 if (!no_thumb) {
1083                         /* If old thumb path is default or not */
1084                         if (strncmp(media_thumb_path, _media_svc_get_thumb_default_path(uid), sizeof(_media_svc_get_thumb_default_path(uid))) == 0) {
1085                                 strncpy(media_new_thumb_path, _media_svc_get_thumb_default_path(uid), sizeof(media_new_thumb_path));
1086                         } else {
1087                                 ret = _media_svc_get_store_type_by_path(replaced_path, &storage_type);
1088                                 if (ret != MS_MEDIA_ERR_NONE) {
1089                                         media_svc_error("_media_svc_get_store_type_by_path failed : %d", ret);
1090                                         SAFE_FREE(replaced_path);
1091                                         _media_svc_sql_rollback_trans(handle,uid);
1092                                         return ret;
1093                                 }
1094
1095                                 ret = _media_svc_get_thumbnail_path(storage_type, media_new_thumb_path, replaced_path, THUMB_EXT, uid);
1096                                 if (ret != MS_MEDIA_ERR_NONE) {
1097                                         media_svc_error("_media_svc_get_thumbnail_path failed : %d", ret);
1098                                         SAFE_FREE(replaced_path);
1099                                         SQLITE3_FINALIZE(sql_stmt);
1100                                         _media_svc_sql_rollback_trans(handle,uid);
1101                                         return ret;
1102                                 }
1103                         }
1104
1105                         //media_svc_debug("New media thumbnail path : %s", media_new_thumb_path);
1106                 }
1107
1108                 char *update_item_sql = NULL;
1109
1110                 if (no_thumb) {
1111                         update_item_sql = sqlite3_mprintf("UPDATE media SET path='%q' WHERE media_uuid='%q'", replaced_path, media_uuid);
1112                 } else {
1113                         if (media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE || media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO) {
1114                                 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);
1115                         } else {
1116                                 update_item_sql = sqlite3_mprintf("UPDATE media SET path='%q', thumbnail_path='%q' WHERE media_uuid='%q'", replaced_path, media_thumb_path, media_uuid);
1117                         }
1118                 }
1119
1120                 ret = media_db_request_update_db_batch(update_item_sql,uid);
1121                 //ret = _media_svc_sql_query(handle, update_item_sql);
1122                 sqlite3_free(update_item_sql);
1123                 SAFE_FREE(replaced_path);
1124
1125                 if (ret != SQLITE_OK) {
1126                         media_svc_error("failed to update item");
1127                         SQLITE3_FINALIZE(sql_stmt);
1128                         _media_svc_sql_rollback_trans(handle,uid);
1129
1130                         return MS_MEDIA_ERR_DB_INTERNAL;
1131                 }
1132
1133                 /* Rename thumbnail file of file system */
1134                 if ((!no_thumb) && (media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE || media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)
1135                                 && (strncmp(media_thumb_path, _media_svc_get_thumb_default_path(uid), sizeof(_media_svc_get_thumb_default_path(uid))) != 0)) {
1136                         ret = _media_svc_rename_file(media_thumb_path, media_new_thumb_path);
1137                         if (ret != MS_MEDIA_ERR_NONE) {
1138                                 media_svc_error("_media_svc_rename_file failed : %d", ret);
1139                         }
1140                 }
1141         }
1142
1143         SQLITE3_FINALIZE(sql_stmt);
1144
1145         ret = _media_svc_sql_end_trans(handle, uid);
1146         if (ret != MS_MEDIA_ERR_NONE) {
1147                 media_svc_error("mb_svc_sqlite3_commit_trans failed.. Now start to rollback\n");
1148                 _media_svc_sql_rollback_trans(handle,uid);
1149                 return ret;
1150         }
1151
1152         media_svc_debug("Folder update is successful. Sending noti for this");
1153         _media_svc_publish_noti(MS_MEDIA_ITEM_DIRECTORY, MS_MEDIA_ITEM_UPDATE, src_path, -1, noti_item->media_uuid, NULL);
1154         _media_svc_destroy_noti_item(noti_item);
1155
1156         return MS_MEDIA_ERR_NONE;
1157 }
1158
1159 int media_svc_request_update_db(const char *db_query, uid_t uid)
1160 {
1161         int ret = MS_MEDIA_ERR_NONE;
1162
1163         media_svc_retvm_if(!STRING_VALID(db_query), MS_MEDIA_ERR_INVALID_PARAMETER, "db_query is NULL");
1164
1165         ret = _media_svc_request_update_db(db_query, uid);
1166
1167         return ret;
1168 }
1169
1170 int media_svc_send_dir_update_noti(MediaSvcHandle *handle, const char *dir_path)
1171 {
1172         int ret = MS_MEDIA_ERR_NONE;
1173         sqlite3 * db_handle = (sqlite3 *)handle;
1174
1175         media_svc_retvm_if(!STRING_VALID(dir_path), MS_MEDIA_ERR_INVALID_PARAMETER, "dir_path is NULL");
1176
1177         /* Get notification info */
1178         media_svc_noti_item *noti_item = NULL;
1179         ret = _media_svc_get_noti_info(db_handle, dir_path, MS_MEDIA_ITEM_DIRECTORY, &noti_item);
1180         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
1181
1182         ret = _media_svc_publish_noti(MS_MEDIA_ITEM_DIRECTORY, MS_MEDIA_ITEM_UPDATE, dir_path, -1, noti_item->media_uuid, NULL);
1183         _media_svc_destroy_noti_item(noti_item);
1184
1185         return ret;
1186 }
1187
1188 int media_svc_count_invalid_items_in_folder(MediaSvcHandle *handle, const char *folder_path, int *count)
1189 {
1190         sqlite3 * db_handle = (sqlite3 *)handle;
1191
1192         media_svc_debug_func();
1193
1194         media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
1195         media_svc_retvm_if(folder_path == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "folder_path is NULL");
1196         media_svc_retvm_if(count == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "count is NULL");
1197
1198         return _media_svc_count_invalid_folder_items(db_handle, folder_path, count);
1199 }
1200
1201 int media_svc_publish_noti(MediaSvcHandle *handle, media_item_type_e update_item, media_item_update_type_e update_type, const char *path, media_type_e media_type, const char *uuid, const char *mime_type)
1202 {
1203         return _media_svc_publish_noti(update_item, update_type, path, media_type, uuid, mime_type);
1204 }
1205
1206 int media_svc_get_pinyin(MediaSvcHandle *handle, const char * src_str, char **pinyin_str)
1207 {
1208         media_svc_retvm_if(!STRING_VALID(src_str), MS_MEDIA_ERR_INVALID_PARAMETER, "String is NULL");
1209
1210         return _media_svc_get_pinyin_str(src_str, pinyin_str);
1211 }
1212
1213 int media_svc_check_pinyin_support(bool *support)
1214 {
1215         *support = _media_svc_check_pinyin_support();
1216
1217         return MS_MEDIA_ERR_NONE;
1218 }
1219
1220
1221 char *media_info_generate_uuid(void)
1222 {
1223         return _media_info_generate_uuid();
1224 }