src/common/media-svc.c

   1 /*
   2  * libmedia-service
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Hyunjun Ko <zzoon.ko@samsung.com>, Haejeong Kim <backto.kim@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21
  22 #include <string.h>
  23 #include <drm_client.h>
  24 #include <media-util.h>
  25 #include "media-svc.h"
  26 #include "media-svc-media.h"
  27 #include "media-svc-debug.h"
  28 #include "media-svc-util.h"
  29 #include "media-svc-db-utils.h"
  30 #include "media-svc-media-folder.h"
  31 #include "media-svc-album.h"
  32 #include "media-svc-noti.h"
  33
  34 static __thread int g_media_svc_item_validity_data_cnt = 1;
  35 static __thread int g_media_svc_item_validity_cur_data_cnt = 0;
  36
  37 static __thread int g_media_svc_move_item_data_cnt = 1;
  38 static __thread int g_media_svc_move_item_cur_data_cnt = 0;
  39
  40 static __thread int g_media_svc_insert_item_data_cnt = 1;
  41 static __thread int g_media_svc_insert_item_cur_data_cnt = 0;
  42
  43 /* Flag for items to be published by notification */
  44 static __thread int g_insert_with_noti = FALSE;
  45
  46 int media_svc_connect(MediaSvcHandle **handle, uid_t uid)
  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,uid);
  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, uid_t uid)
  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, uid);
 101         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 102
 103         /*create folder table*/
 104         ret = _media_svc_create_folder_table(handle, uid);
 105         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 106
 107         /*create playlist table*/
 108         ret = _media_svc_create_playlist_table(handle, uid);
 109         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 110
 111         /* create album table*/
 112         ret = _media_svc_create_album_table(handle, uid);
 113         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 114
 115         /*create tag table*/
 116         ret = _media_svc_create_tag_table(handle,uid);
 117         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 118
 119         /*create bookmark table*/
 120         ret = _media_svc_create_bookmark_table(handle, uid);
 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, uid);
 126         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 127 #endif
 128
 129         return MEDIA_INFO_ERROR_NONE;
 130 }
 131
 132 int media_svc_get_storage_type(const char *path, media_svc_storage_type_e *storage_type)
 133 {
 134         int ret = MEDIA_INFO_ERROR_NONE;
 135         media_svc_storage_type_e type;
 136
 137         ret = _media_svc_get_store_type_by_path(path, &type);
 138         media_svc_retvm_if(ret < MEDIA_INFO_ERROR_NONE, ret, "_media_svc_get_store_type_by_path failed : %d", ret);
 139
 140         *storage_type = type;
 141
 142         return ret;
 143 }
 144
 145 int media_svc_get_mime_type(const char *path, char *mimetype)
 146 {
 147         int ret = MEDIA_INFO_ERROR_NONE;
 148         drm_bool_type_e is_drm = DRM_FALSE;
 149         drm_content_info_s *drm_contentInfo = NULL;
 150
 151         ret = _media_svc_get_mime_type(path, mimetype, &is_drm, &drm_contentInfo);
 152
 153         SAFE_FREE(drm_contentInfo);
 154
 155         return ret;
 156 }
 157
 158 int media_svc_get_media_type(const char *path, const char *mime_type, media_svc_media_type_e *media_type)
 159 {
 160         int ret = MEDIA_INFO_ERROR_NONE;
 161
 162         ret = _media_svc_get_media_type(path, mime_type, media_type);
 163
 164         return ret;
 165 }
 166
 167 int media_svc_check_item_exist_by_path(MediaSvcHandle *handle, const char *path)
 168 {
 169         int ret = MEDIA_INFO_ERROR_NONE;
 170         sqlite3 * db_handle = (sqlite3 *)handle;
 171         int count = -1;
 172
 173         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 174         media_svc_retvm_if(!STRING_VALID(path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "Path is NULL");
 175
 176         ret = _media_svc_count_record_with_path(db_handle, path, &count);
 177         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 178
 179         if(count > 0) {
 180                 media_svc_debug("item is exist in database");
 181                 return MEDIA_INFO_ERROR_NONE;
 182         } else {
 183                 media_svc_debug("item is not exist in database");
 184                 return MEDIA_INFO_ERROR_DATABASE_NO_RECORD;
 185         }
 186
 187         return MEDIA_INFO_ERROR_NONE;
 188 }
 189
 190 int media_svc_insert_item_begin(MediaSvcHandle *handle, int data_cnt, int with_noti, int from_pid)
 191 {
 192         sqlite3 * db_handle = (sqlite3 *)handle;
 193
 194         media_svc_debug("Transaction data count : [%d]", data_cnt);
 195
 196         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 197         media_svc_retvm_if(data_cnt < 1, MEDIA_INFO_ERROR_INVALID_PARAMETER, "data_cnt shuld be bigger than 1");
 198
 199         g_media_svc_insert_item_data_cnt  = data_cnt;
 200         g_media_svc_insert_item_cur_data_cnt  = 0;
 201
 202         /* Prepare for making noti item list */
 203         if (with_noti) {
 204                 media_svc_debug("making noti list from pid[%d]", from_pid);
 205                 if (_media_svc_create_noti_list(data_cnt) != MEDIA_INFO_ERROR_NONE) {
 206                         return MEDIA_INFO_ERROR_OUT_OF_MEMORY;
 207                 }
 208
 209                 _media_svc_set_noti_from_pid(from_pid);
 210                 g_insert_with_noti = TRUE;
 211         }
 212
 213         return MEDIA_INFO_ERROR_NONE;
 214 }
 215
 216 int media_svc_insert_item_end(MediaSvcHandle *handle, uid_t uid)
 217 {
 218         int ret = MEDIA_INFO_ERROR_NONE;
 219         sqlite3 * db_handle = (sqlite3 *)handle;
 220
 221         media_svc_debug_func();
 222
 223         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 224
 225         if (g_media_svc_insert_item_cur_data_cnt  > 0) {
 226
 227                 ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_INSERT_ITEM, uid);
 228                 if (g_insert_with_noti) {
 229                         media_svc_debug("sending noti list");
 230                         _media_svc_publish_noti_list(g_media_svc_insert_item_cur_data_cnt);
 231                         _media_svc_destroy_noti_list(g_media_svc_insert_item_cur_data_cnt);
 232                         g_insert_with_noti = FALSE;
 233                         _media_svc_set_noti_from_pid(-1);
 234                 }
 235         }
 236
 237         g_media_svc_insert_item_data_cnt  = 1;
 238         g_media_svc_insert_item_cur_data_cnt  = 0;
 239
 240         return ret;
 241 }
 242
 243 int media_svc_insert_item_bulk(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, const char *path, int is_burst, uid_t uid)
 244 {
 245         int ret = MEDIA_INFO_ERROR_NONE;
 246         sqlite3 * db_handle = (sqlite3 *)handle;
 247         char folder_uuid[MEDIA_SVC_UUID_SIZE+1] = {0,};
 248         media_svc_media_type_e media_type;
 249         drm_content_info_s *drm_contentInfo = NULL;
 250
 251         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 252         media_svc_retvm_if(!STRING_VALID(path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "path is NULL");
 253
 254         if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
 255                 media_svc_error("storage type is incorrect[%d]", storage_type);
 256                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 257         }
 258
 259         media_svc_content_info_s content_info;
 260         memset(&content_info, 0, sizeof(media_svc_content_info_s));
 261
 262         /*Set media info*/
 263         /* if drm_contentinfo is not NULL, the file is OMA DRM.*/
 264         ret = _media_svc_set_media_info(&content_info, storage_type, path, &media_type, FALSE, &drm_contentInfo);
 265         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 266
 267         if(media_type == MEDIA_SVC_MEDIA_TYPE_OTHER) {
 268                 /*Do nothing.*/
 269         } else if(media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) {
 270                 ret = _media_svc_extract_image_metadata(&content_info, media_type);
 271         } else {
 272                 ret = _media_svc_extract_media_metadata(handle, &content_info, media_type, drm_contentInfo, uid);
 273         }
 274         SAFE_FREE(drm_contentInfo);
 275         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 276
 277         /*Set or Get folder id*/
 278         ret = _media_svc_get_and_append_folder_id_by_path(handle, path, storage_type, folder_uuid, uid);
 279         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 280
 281         ret = __media_svc_malloc_and_strncpy(&content_info.folder_uuid, folder_uuid);
 282         media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, &content_info);
 283
 284         if (g_media_svc_insert_item_data_cnt == 1) {
 285
 286                 ret = _media_svc_insert_item_with_data(db_handle, &content_info, is_burst, FALSE, uid);
 287                 media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, &content_info);
 288
 289                 if (g_insert_with_noti)
 290                         _media_svc_insert_item_to_noti_list(&content_info, g_media_svc_insert_item_cur_data_cnt++);
 291
 292         } else if(g_media_svc_insert_item_cur_data_cnt  < (g_media_svc_insert_item_data_cnt  - 1)) {
 293
 294                 ret = _media_svc_insert_item_with_data(db_handle, &content_info, is_burst, TRUE, uid);
 295                 media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, &content_info);
 296
 297                 if (g_insert_with_noti)
 298                         _media_svc_insert_item_to_noti_list(&content_info, g_media_svc_insert_item_cur_data_cnt);
 299
 300                 g_media_svc_insert_item_cur_data_cnt ++;
 301
 302         } else if (g_media_svc_insert_item_cur_data_cnt  == (g_media_svc_insert_item_data_cnt  - 1)) {
 303
 304                 ret = _media_svc_insert_item_with_data(db_handle, &content_info, is_burst, TRUE, uid);
 305                 media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, &content_info);
 306
 307                 if (g_insert_with_noti)
 308                         _media_svc_insert_item_to_noti_list(&content_info, g_media_svc_insert_item_cur_data_cnt);
 309
 310                 ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_INSERT_ITEM, uid);
 311                 media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, &content_info);
 312
 313                 if (g_insert_with_noti) {
 314                         _media_svc_publish_noti_list(g_media_svc_insert_item_cur_data_cnt + 1);
 315                         _media_svc_destroy_noti_list(g_media_svc_insert_item_cur_data_cnt + 1);
 316
 317                         /* Recreate noti list */
 318                         if (_media_svc_create_noti_list(g_media_svc_insert_item_data_cnt) != MEDIA_INFO_ERROR_NONE) {
 319                                 return MEDIA_INFO_ERROR_OUT_OF_MEMORY;
 320                         }
 321                 }
 322
 323                 g_media_svc_insert_item_cur_data_cnt = 0;
 324
 325         } else {
 326                 media_svc_error("Error in media_svc_insert_item_bulk");
 327                 _media_svc_destroy_content_info(&content_info);
 328                 return MEDIA_INFO_ERROR_INTERNAL;
 329         }
 330
 331         _media_svc_destroy_content_info(&content_info);
 332
 333         return MEDIA_INFO_ERROR_NONE;
 334 }
 335
 336 int media_svc_insert_item_immediately(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, const char *path, uid_t uid)
 337 {
 338         int ret = MEDIA_INFO_ERROR_NONE;
 339         sqlite3 * db_handle = (sqlite3 *)handle;
 340         char folder_uuid[MEDIA_SVC_UUID_SIZE+1] = {0,};
 341         media_svc_media_type_e media_type;
 342         drm_content_info_s *drm_contentInfo = NULL;
 343
 344         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 345         media_svc_retvm_if(!STRING_VALID(path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "path is NULL");
 346
 347         if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
 348                 media_svc_error("storage type is incorrect[%d]", storage_type);
 349                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 350         }
 351
 352         media_svc_content_info_s content_info;
 353         memset(&content_info, 0, sizeof(media_svc_content_info_s));
 354
 355         /*Set media info*/
 356         ret = _media_svc_set_media_info(&content_info, storage_type, path, &media_type, FALSE, &drm_contentInfo);
 357         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 358
 359         if(media_type == MEDIA_SVC_MEDIA_TYPE_OTHER) {
 360                 /*Do nothing.*/
 361         } else if(media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) {
 362                 ret = _media_svc_extract_image_metadata(&content_info, media_type);
 363                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 364         } else {
 365                 ret = _media_svc_extract_media_metadata(handle, &content_info, media_type, drm_contentInfo, uid);
 366                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 367         }
 368
 369         /*Set or Get folder id*/
 370         ret = _media_svc_get_and_append_folder_id_by_path(handle, path, storage_type, folder_uuid, uid);
 371         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 372
 373         ret = __media_svc_malloc_and_strncpy(&content_info.folder_uuid, folder_uuid);
 374         media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, &content_info);
 375 #if 1
 376         /* Extracting thumbnail */
 377         if (media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE || media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO) {
 378                 char thumb_path[MEDIA_SVC_PATHNAME_SIZE + 1] = {0, };
 379                 int width = 0;
 380                 int height = 0;
 381
 382                 ret = thumbnail_request_from_db_with_size(content_info.path, thumb_path, sizeof(thumb_path), &width, &height, uid);
 383                 if (ret < 0) {
 384                         media_svc_error("thumbnail_request_from_db failed: %d", ret);
 385                 } else {
 386                         media_svc_debug("thumbnail_request_from_db success: %s", thumb_path);
 387                         ret = __media_svc_malloc_and_strncpy(&(content_info.thumbnail_path), thumb_path);
 388                         if (ret < 0) {
 389                                 media_svc_error("__media_svc_malloc_and_strncpy failed : %d", ret);
 390                         }
 391                 }
 392
 393                 if (content_info.media_meta.width <= 0)
 394                         content_info.media_meta.width = width;
 395
 396                 if (content_info.media_meta.height <= 0)
 397                         content_info.media_meta.height = height;
 398         }
 399 #endif
 400         ret = _media_svc_insert_item_with_data(db_handle, &content_info, FALSE, FALSE, uid);
 401
 402         if (ret == MEDIA_INFO_ERROR_NONE) {
 403                 media_svc_debug("Insertion is successful. Sending noti for this");
 404                 _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);
 405         }
 406
 407         _media_svc_destroy_content_info(&content_info);
 408         return ret;
 409 }
 410
 411 int media_svc_insert_folder(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, const char *path, uid_t uid)
 412 {
 413         int ret = MEDIA_INFO_ERROR_NONE;
 414         sqlite3 * db_handle = (sqlite3 *)handle;
 415
 416         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 417         media_svc_retvm_if(!STRING_VALID(path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "path is NULL");
 418
 419         if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
 420                 media_svc_error("storage type is incorrect[%d]", storage_type);
 421                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 422         }
 423
 424         media_svc_debug("storage[%d], folder_path[%s]", storage_type, path);
 425
 426         /*Get folder info*/
 427         char *folder_name = NULL;
 428         int folder_modified_date = 0;
 429         char *folder_uuid = _media_info_generate_uuid();
 430         if(folder_uuid == NULL ) {
 431                 media_svc_error("Invalid UUID");
 432                 return MEDIA_INFO_ERROR_INTERNAL;
 433         }
 434
 435         folder_name = g_path_get_basename(path);
 436         folder_modified_date = _media_svc_get_file_time(path);
 437
 438         ret = _media_svc_append_folder(handle, storage_type, folder_uuid, path, folder_name, folder_modified_date, uid);
 439         SAFE_FREE(folder_name);
 440
 441         if (ret < MEDIA_INFO_ERROR_NONE) {
 442                 media_svc_error("_media_svc_append_folder error [%d]", ret);
 443                 return ret;
 444         }
 445
 446         return MEDIA_INFO_ERROR_NONE;
 447 }
 448
 449 int media_svc_move_item_begin(MediaSvcHandle *handle, int data_cnt)
 450 {
 451         sqlite3 * db_handle = (sqlite3 *)handle;
 452
 453         media_svc_debug("Transaction data count : [%d]", data_cnt);
 454
 455         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 456         media_svc_retvm_if(data_cnt < 1, MEDIA_INFO_ERROR_INVALID_PARAMETER, "data_cnt shuld be bigger than 1");
 457
 458         g_media_svc_move_item_data_cnt  = data_cnt;
 459         g_media_svc_move_item_cur_data_cnt  = 0;
 460
 461         return MEDIA_INFO_ERROR_NONE;
 462 }
 463
 464 int media_svc_move_item_end(MediaSvcHandle *handle, uid_t uid)
 465 {
 466         int ret = MEDIA_INFO_ERROR_NONE;
 467         sqlite3 * db_handle = (sqlite3 *)handle;
 468
 469         media_svc_debug_func();
 470
 471         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 472
 473         if (g_media_svc_move_item_cur_data_cnt  > 0) {
 474
 475                 ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_MOVE_ITEM, uid);
 476         }
 477
 478         /*clean up old folder path*/
 479         ret = _media_svc_update_folder_table(handle, uid);
 480         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 481
 482         g_media_svc_move_item_data_cnt  = 1;
 483         g_media_svc_move_item_cur_data_cnt  = 0;
 484
 485         return ret;
 486 }
 487
 488 int media_svc_move_item(MediaSvcHandle *handle, media_svc_storage_type_e src_storage, const char *src_path,
 489                         media_svc_storage_type_e dest_storage, const char *dest_path, uid_t uid)
 490 {
 491         int ret = MEDIA_INFO_ERROR_NONE;
 492         sqlite3 * db_handle = (sqlite3 *)handle;
 493         char *file_name = NULL;
 494         char *folder_path = NULL;
 495         int modified_time = 0;
 496         char folder_uuid[MEDIA_SVC_UUID_SIZE+1] = {0,};
 497         char old_thumb_path[MEDIA_SVC_PATHNAME_SIZE] = {0,};
 498         char new_thumb_path[MEDIA_SVC_PATHNAME_SIZE] = {0,};
 499         int media_type = -1;
 500
 501         media_svc_debug_func();
 502
 503         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 504         media_svc_retvm_if(!STRING_VALID(src_path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "src_path is NULL");
 505         media_svc_retvm_if(!STRING_VALID(dest_path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "dest_path is NULL");
 506
 507         if ((src_storage != MEDIA_SVC_STORAGE_INTERNAL) && (src_storage != MEDIA_SVC_STORAGE_EXTERNAL)) {
 508                 media_svc_error("src_storage type is incorrect[%d]", src_storage);
 509                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 510         }
 511         if ((dest_storage != MEDIA_SVC_STORAGE_INTERNAL) && (dest_storage != MEDIA_SVC_STORAGE_EXTERNAL)) {
 512                 media_svc_error("dest_storage type is incorrect[%d]", dest_storage);
 513                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 514         }
 515
 516         /*check and update folder*/
 517         ret = _media_svc_get_and_append_folder_id_by_path(handle, dest_path, dest_storage, folder_uuid, uid);
 518         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 519
 520         /*get filename*/
 521         file_name = g_path_get_basename(dest_path);
 522
 523         /*get modified_time*/
 524         modified_time = _media_svc_get_file_time(dest_path);
 525
 526         /*get thumbnail_path to update. only for Imgae and Video items. Audio share album_art(thumbnail)*/
 527         ret = _media_svc_get_media_type_by_path(handle, src_path, &media_type);
 528         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 529
 530         if((media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) ||(media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)) {
 531                 /*get old thumbnail_path*/
 532                 ret = _media_svc_get_thumbnail_path_by_path(handle, src_path, old_thumb_path);
 533                 media_svc_retv_if((ret != MEDIA_INFO_ERROR_NONE) && (ret != MEDIA_INFO_ERROR_DATABASE_NO_RECORD), ret);
 534
 535                 /* If old thumb path is default or not */
 536                 if (strncmp(old_thumb_path, _media_svc_get_thumb_default_path(uid), sizeof(_media_svc_get_thumb_default_path(uid))) == 0) {
 537                         strncpy(new_thumb_path, _media_svc_get_thumb_default_path(uid), sizeof(new_thumb_path));
 538                 } else {
 539                         _media_svc_get_thumbnail_path(dest_storage, new_thumb_path, dest_path, THUMB_EXT, uid);
 540                 }
 541         }
 542
 543         if (g_media_svc_move_item_data_cnt == 1) {
 544
 545                 /*update item*/
 546                 if((media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) ||(media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)) {
 547                         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);
 548                 } else {
 549                         ret = _media_svc_update_item_by_path(handle, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, NULL, FALSE, uid);
 550                 }
 551                 SAFE_FREE(file_name);
 552                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 553
 554                 media_svc_debug("Move is successful. Sending noti for this");
 555
 556                 /* Get notification info */
 557                 media_svc_noti_item *noti_item = NULL;
 558                 ret = _media_svc_get_noti_info(handle, dest_path, MS_MEDIA_ITEM_FILE, &noti_item);
 559                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 560
 561                 /* Send notification for move */
 562                 _media_svc_publish_noti(MS_MEDIA_ITEM_FILE, MS_MEDIA_ITEM_UPDATE, src_path, media_type, noti_item->media_uuid, noti_item->mime_type);
 563                 _media_svc_destroy_noti_item(noti_item);
 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, FALSE, uid);
 568                 SAFE_FREE(folder_path);
 569                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 570
 571                 ret = _media_svc_update_folder_table(handle, uid);
 572                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 573
 574         } else if (g_media_svc_move_item_cur_data_cnt  < (g_media_svc_move_item_data_cnt  - 1)) {
 575
 576                 /*update item*/
 577                 if((media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) ||(media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)) {
 578                         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);
 579                 } else {
 580                         ret = _media_svc_update_item_by_path(handle, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, NULL, TRUE, uid);
 581                 }
 582                 SAFE_FREE(file_name);
 583                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 584
 585                 /*update folder modified_time*/
 586                 folder_path = g_path_get_dirname(dest_path);
 587                 ret = _media_svc_update_folder_modified_time_by_folder_uuid(handle, folder_uuid, folder_path, TRUE, uid);
 588                 SAFE_FREE(folder_path);
 589                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 590
 591                 g_media_svc_move_item_cur_data_cnt ++;
 592
 593         } else if (g_media_svc_move_item_cur_data_cnt  == (g_media_svc_move_item_data_cnt  - 1)) {
 594
 595                 /*update item*/
 596                 if((media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) ||(media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)) {
 597                         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);
 598                 } else {
 599                         ret = _media_svc_update_item_by_path(handle, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, NULL, TRUE, uid);
 600                 }
 601                 SAFE_FREE(file_name);
 602                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 603
 604                 /*update folder modified_time*/
 605                 folder_path = g_path_get_dirname(dest_path);
 606                 ret = _media_svc_update_folder_modified_time_by_folder_uuid(handle, folder_uuid, folder_path, TRUE, uid);
 607                 SAFE_FREE(folder_path);
 608                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 609
 610                 /*update db*/
 611                 ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_MOVE_ITEM, uid);
 612                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 613
 614                 g_media_svc_move_item_cur_data_cnt = 0;
 615
 616         } else {
 617                 media_svc_error("Error in media_svc_move_item");
 618                 return MEDIA_INFO_ERROR_INTERNAL;
 619         }
 620
 621         /*rename thumbnail file*/
 622         if((media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) ||(media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)) {
 623                 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)) {
 624                         ret = _media_svc_rename_file(old_thumb_path,new_thumb_path);
 625                         if (ret < 0)
 626                                 media_svc_error("_media_svc_rename_file failed : %d", ret);
 627                 }
 628         }
 629
 630         return MEDIA_INFO_ERROR_NONE;
 631 }
 632
 633 int media_svc_set_item_validity_begin(MediaSvcHandle *handle, int data_cnt)
 634 {
 635         sqlite3 * db_handle = (sqlite3 *)handle;
 636
 637         media_svc_debug("Transaction data count : [%d]", data_cnt);
 638
 639         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 640         media_svc_retvm_if(data_cnt < 1, MEDIA_INFO_ERROR_INVALID_PARAMETER, "data_cnt shuld be bigger than 1");
 641
 642         g_media_svc_item_validity_data_cnt  = data_cnt;
 643         g_media_svc_item_validity_cur_data_cnt  = 0;
 644
 645         return MEDIA_INFO_ERROR_NONE;
 646 }
 647
 648 int media_svc_set_item_validity_end(MediaSvcHandle *handle, uid_t uid)
 649 {
 650         int ret = MEDIA_INFO_ERROR_NONE;
 651         sqlite3 * db_handle = (sqlite3 *)handle;
 652
 653         media_svc_debug_func();
 654
 655         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 656
 657         if (g_media_svc_item_validity_cur_data_cnt  > 0) {
 658
 659                 ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_SET_ITEM_VALIDITY, uid);
 660         }
 661
 662         g_media_svc_item_validity_data_cnt  = 1;
 663         g_media_svc_item_validity_cur_data_cnt  = 0;
 664
 665         return ret;
 666 }
 667
 668 int media_svc_set_item_validity(MediaSvcHandle *handle, const char *path, int validity,uid_t uid)
 669 {
 670         int ret = MEDIA_INFO_ERROR_NONE;
 671         sqlite3 * db_handle = (sqlite3 *)handle;
 672
 673         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 674         media_svc_retvm_if(!STRING_VALID(path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "path is NULL");
 675
 676         media_svc_debug("path=[%s], validity=[%d]", path, validity);
 677
 678         if (g_media_svc_item_validity_data_cnt  == 1) {
 679
 680                 return _media_svc_update_item_validity(db_handle, path, validity, FALSE, uid);
 681
 682         } else if (g_media_svc_item_validity_cur_data_cnt  < (g_media_svc_item_validity_data_cnt  - 1)) {
 683
 684                 ret = _media_svc_update_item_validity(db_handle, path, validity, TRUE, uid);
 685                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 686
 687                 g_media_svc_item_validity_cur_data_cnt ++;
 688
 689         } else if (g_media_svc_item_validity_cur_data_cnt  == (g_media_svc_item_validity_data_cnt  - 1)) {
 690
 691                 ret = _media_svc_update_item_validity(db_handle, path, validity, TRUE, uid);
 692                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 693
 694                 ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_SET_ITEM_VALIDITY, uid);
 695                 media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 696
 697                 g_media_svc_item_validity_cur_data_cnt  = 0;
 698
 699         } else {
 700
 701                 media_svc_error("Error in media_svc_set_item_validity");
 702                 return MEDIA_INFO_ERROR_INTERNAL;
 703         }
 704
 705         return MEDIA_INFO_ERROR_NONE;
 706 }
 707
 708 int media_svc_delete_item_by_path(MediaSvcHandle *handle, const char *path, uid_t uid)
 709 {
 710         int ret = MEDIA_INFO_ERROR_NONE;
 711         sqlite3 * db_handle = (sqlite3 *)handle;
 712         char thumb_path[MEDIA_SVC_PATHNAME_SIZE] = {0,};
 713
 714         media_svc_debug_func();
 715
 716         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 717         media_svc_retvm_if(!STRING_VALID(path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "path is NULL");
 718
 719         int media_type = -1;
 720         ret = _media_svc_get_media_type_by_path(db_handle, path, &media_type);
 721         media_svc_retv_if((ret != MEDIA_INFO_ERROR_NONE), ret);
 722
 723         if((media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) ||(media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)) {
 724                 /*Get thumbnail path to delete*/
 725                 ret = _media_svc_get_thumbnail_path_by_path(db_handle, path, thumb_path);
 726                 media_svc_retv_if((ret != MEDIA_INFO_ERROR_NONE) && (ret != MEDIA_INFO_ERROR_DATABASE_NO_RECORD), ret);
 727         } else if ((media_type == MEDIA_SVC_MEDIA_TYPE_SOUND) ||(media_type == MEDIA_SVC_MEDIA_TYPE_MUSIC)) {
 728                 int count = 0;
 729                 ret = _media_svc_get_media_count_with_album_id_by_path(db_handle, path, &count);
 730                 media_svc_retv_if((ret != MEDIA_INFO_ERROR_NONE), ret);
 731
 732                 if (count == 1) {
 733                         /*Get thumbnail path to delete*/
 734                         ret = _media_svc_get_thumbnail_path_by_path(db_handle, path, thumb_path);
 735                         media_svc_retv_if((ret != MEDIA_INFO_ERROR_NONE) && (ret != MEDIA_INFO_ERROR_DATABASE_NO_RECORD), ret);
 736                 }
 737         }
 738
 739         /* Get notification info */
 740         media_svc_noti_item *noti_item = NULL;
 741         ret = _media_svc_get_noti_info(handle, path, MS_MEDIA_ITEM_FILE, &noti_item);
 742         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 743
 744         /*Delete item*/
 745         ret = _media_svc_delete_item_by_path(db_handle, path, uid);
 746         if (ret != MEDIA_INFO_ERROR_NONE) {
 747                 media_svc_error("_media_svc_delete_item_by_path failed : %d", ret);
 748                 _media_svc_destroy_noti_item(noti_item);
 749
 750                 return ret;
 751         }
 752
 753         /* Send notification */
 754         media_svc_debug("Deletion is successful. Sending noti for this");
 755         _media_svc_publish_noti(MS_MEDIA_ITEM_FILE, MS_MEDIA_ITEM_DELETE, path, media_type, noti_item->media_uuid, noti_item->mime_type);
 756         _media_svc_destroy_noti_item(noti_item);
 757
 758         /*Delete thumbnail*/
 759         if ((strlen(thumb_path) > 0) && (strncmp(thumb_path, _media_svc_get_thumb_default_path(uid), sizeof(_media_svc_get_thumb_default_path(uid))) != 0)) {
 760                 int thumb_count = 1;
 761                 /* Get count of media, which contains same thumbnail for music */
 762                 if ((media_type == MEDIA_SVC_MEDIA_TYPE_SOUND) ||(media_type == MEDIA_SVC_MEDIA_TYPE_MUSIC)) {
 763                         ret = _media_svc_get_thumbnail_count(db_handle, thumb_path, &thumb_count);
 764                         if (ret < MEDIA_INFO_ERROR_NONE) {
 765                                 media_svc_error("Failed to get thumbnail count : %d", ret);
 766                         }
 767                 }
 768
 769                 if (thumb_count == 1) {
 770                         if (_media_svc_remove_file(thumb_path) == FALSE) {
 771                                 media_svc_error("fail to remove thumbnail file.");
 772                         }
 773                 }
 774         }
 775
 776         return MEDIA_INFO_ERROR_NONE;
 777 }
 778
 779 int media_svc_delete_all_items_in_storage(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, uid_t uid)
 780 {
 781         int ret = MEDIA_INFO_ERROR_NONE;
 782         sqlite3 * db_handle = (sqlite3 *)handle;
 783         char * dirpath = NULL;
 784
 785         media_svc_debug("media_svc_delete_all_items_in_storage [%d]", storage_type);
 786
 787         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 788
 789         if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
 790                 media_svc_error("storage type is incorrect[%d]", storage_type);
 791                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 792         }
 793
 794         ret = _media_svc_truncate_table(db_handle, storage_type, uid);
 795         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 796
 797         dirpath = (storage_type == MEDIA_SVC_STORAGE_INTERNAL) ? _media_svc_get_thumb_internal_path(uid) : _media_svc_get_thumb_external_path(uid);
 798
 799         /* remove thumbnails */
 800         ret = _media_svc_remove_all_files_in_dir(dirpath);
 801         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 802
 803         return MEDIA_INFO_ERROR_NONE;
 804 }
 805
 806 int media_svc_delete_invalid_items_in_storage(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, uid_t uid)
 807 {
 808         sqlite3 * db_handle = (sqlite3 *)handle;
 809
 810         media_svc_debug_func();
 811
 812         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 813
 814         if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
 815                 media_svc_error("storage type is incorrect[%d]", storage_type);
 816                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 817         }
 818
 819         /*Delete from DB and remove thumbnail files*/
 820         return _media_svc_delete_invalid_items(db_handle, storage_type, uid);
 821 }
 822
 823 int media_svc_delete_invalid_items_in_folder(MediaSvcHandle *handle, const char *folder_path, uid_t uid)
 824 {
 825         sqlite3 * db_handle = (sqlite3 *)handle;
 826
 827         media_svc_debug_func();
 828
 829         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 830
 831         /*Delete from DB and remove thumbnail files*/
 832         return _media_svc_delete_invalid_folder_items(db_handle, folder_path, uid);
 833 }
 834
 835 int media_svc_set_all_storage_items_validity(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, int validity, uid_t uid)
 836 {
 837         sqlite3 * db_handle = (sqlite3 *)handle;
 838
 839         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 840
 841         if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
 842                 media_svc_error("storage type is incorrect[%d]", storage_type);
 843                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 844         }
 845
 846         return _media_svc_update_storage_item_validity(db_handle, storage_type, validity, uid);
 847 }
 848
 849 int media_svc_set_folder_items_validity(MediaSvcHandle *handle, const char *folder_path, int validity, int recursive, uid_t uid)
 850 {
 851         sqlite3 * db_handle = (sqlite3 *)handle;
 852
 853         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 854         media_svc_retvm_if(!STRING_VALID(folder_path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "folder_path is NULL");
 855
 856         if(recursive)
 857                 return _media_svc_update_recursive_folder_item_validity(db_handle, folder_path, validity , uid);
 858         else
 859                 return _media_svc_update_folder_item_validity(db_handle, folder_path, validity, uid);
 860 }
 861
 862 int media_svc_refresh_item(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, const char *path, uid_t uid)
 863 {
 864         int ret = MEDIA_INFO_ERROR_NONE;
 865         sqlite3 * db_handle = (sqlite3 *)handle;
 866         media_svc_media_type_e media_type;
 867         drm_content_info_s *drm_contentInfo = NULL;
 868
 869         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 870         media_svc_retvm_if(!STRING_VALID(path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "path is NULL");
 871
 872         if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
 873                 media_svc_error("storage type is incorrect[%d]", storage_type);
 874                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 875         }
 876
 877
 878         media_svc_content_info_s content_info;
 879         memset(&content_info, 0, sizeof(media_svc_content_info_s));
 880
 881         /*Set media info*/
 882         ret = _media_svc_set_media_info(&content_info, storage_type, path, &media_type, TRUE, &drm_contentInfo);
 883         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 884
 885         /* Initialize thumbnail information to remake thumbnail. */
 886         char thumb_path[MEDIA_SVC_PATHNAME_SIZE + 1];
 887         ret = _media_svc_get_thumbnail_path_by_path(handle, path, thumb_path);
 888         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 889
 890         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)) {
 891                 ret = _media_svc_remove_file(thumb_path);
 892                 if (ret < MEDIA_INFO_ERROR_NONE) {
 893                         media_svc_error("_media_svc_remove_file failed : %s", thumb_path);
 894                 }
 895         }
 896
 897         ret = _media_svc_update_thumbnail_path(handle, path, NULL, uid);
 898         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 899
 900         /* Get notification info */
 901         media_svc_noti_item *noti_item = NULL;
 902         ret = _media_svc_get_noti_info(handle, path, MS_MEDIA_ITEM_FILE, &noti_item);
 903         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 904
 905         media_type = noti_item->media_type;
 906
 907         if(media_type == MEDIA_SVC_MEDIA_TYPE_OTHER) {
 908                 /*Do nothing.*/
 909         } else if(media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) {
 910                 ret = _media_svc_extract_image_metadata(&content_info, media_type);
 911                 if (ret != MEDIA_INFO_ERROR_NONE) {
 912                         _media_svc_destroy_noti_item(noti_item);
 913                         return ret;
 914                 }
 915         } else {
 916                 ret = _media_svc_extract_media_metadata(handle, &content_info, media_type, drm_contentInfo, uid);
 917                 if (ret != MEDIA_INFO_ERROR_NONE) {
 918                         _media_svc_destroy_noti_item(noti_item);
 919                         return ret;
 920                 }
 921         }
 922 #if 1
 923         /* Extracting thumbnail */
 924         if (media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE || media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO) {
 925                 char thumb_path[MEDIA_SVC_PATHNAME_SIZE + 1] = {0, };
 926                 int width = 0;
 927                 int height = 0;
 928
 929                 ret = thumbnail_request_from_db_with_size(content_info.path, thumb_path, sizeof(thumb_path), &width, &height, uid);
 930                 if (ret < 0) {
 931                         media_svc_error("thumbnail_request_from_db failed: %d", ret);
 932                 } else {
 933                         media_svc_debug("thumbnail_request_from_db success: %s", thumb_path);
 934                         ret = __media_svc_malloc_and_strncpy(&(content_info.thumbnail_path), thumb_path);
 935                         if (ret < 0) {
 936                                 media_svc_error("__media_svc_malloc_and_strncpy failed : %d", ret);
 937                         }
 938                 }
 939
 940                 if (content_info.media_meta.width <= 0)
 941                         content_info.media_meta.width = width;
 942
 943                 if (content_info.media_meta.height <= 0)
 944                         content_info.media_meta.height = height;
 945         }
 946 #endif
 947         ret = _media_svc_update_item_with_data(db_handle, &content_info, uid);
 948
 949         if (ret == MEDIA_INFO_ERROR_NONE) {
 950                 media_svc_debug("Update is successful. Sending noti for this");
 951                 _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);
 952         } else {
 953                 media_svc_error("_media_svc_update_item_with_data failed : %d", ret);
 954         }
 955
 956         _media_svc_destroy_content_info(&content_info);
 957         _media_svc_destroy_noti_item(noti_item);
 958
 959         return ret;
 960 }
 961
 962 int media_svc_rename_folder(MediaSvcHandle *handle, const char *src_path, const char *dst_path, uid_t uid)
 963 {
 964         sqlite3 * db_handle = (sqlite3 *)handle;
 965         int ret = MEDIA_INFO_ERROR_NONE;
 966
 967         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
 968         media_svc_retvm_if(src_path == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "src_path is NULL");
 969         media_svc_retvm_if(dst_path == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "dst_path is NULL");
 970
 971         media_svc_debug("Src path : %s,  Dst Path : %s", src_path, dst_path);
 972
 973         /* Get notification info */
 974         media_svc_noti_item *noti_item = NULL;
 975         ret = _media_svc_get_noti_info(handle, src_path, MS_MEDIA_ITEM_DIRECTORY, &noti_item);
 976         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 977
 978         ret = _media_svc_sql_begin_trans(handle,uid);
 979         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 980
 981         /* Update all folder record's path, which are matched by old parent path */
 982         char *update_folder_path_sql = NULL;
 983         char src_path_slash[MEDIA_SVC_PATHNAME_SIZE + 1];
 984         char dst_path_slash[MEDIA_SVC_PATHNAME_SIZE + 1];
 985
 986         snprintf(src_path_slash, sizeof(src_path_slash), "%s/", src_path);
 987         snprintf(dst_path_slash, sizeof(dst_path_slash), "%s/", dst_path);
 988
 989         update_folder_path_sql = sqlite3_mprintf("UPDATE folder SET path = REPLACE( path, '%q', '%q');", src_path_slash, dst_path_slash);
 990
 991         //ret = _media_svc_sql_query(handle, update_folder_path_sql);
 992         ret = media_db_request_update_db_batch(update_folder_path_sql, uid);
 993         sqlite3_free(update_folder_path_sql);
 994
 995         if (ret != SQLITE_OK) {
 996                 media_svc_error("failed to update folder path");
 997                 _media_svc_sql_rollback_trans(handle, uid);
 998
 999                 return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
1000         }
1001
1002         /* Update all folder record's modified date, which are changed above */
1003         char *update_folder_modified_time_sql = NULL;
1004         time_t date;
1005         time(&date);
1006
1007         update_folder_modified_time_sql = sqlite3_mprintf("UPDATE folder SET modified_time = %d where path like '%q';", date, dst_path);
1008
1009         ret = media_db_request_update_db_batch(update_folder_modified_time_sql, uid);
1010         //ret = _media_svc_sql_query(handle, update_folder_modified_time_sql);
1011         sqlite3_free(update_folder_modified_time_sql);
1012
1013         if (ret != SQLITE_OK) {
1014                 media_svc_error("failed to update folder modified time");
1015                 _media_svc_sql_rollback_trans(handle, uid);
1016
1017                 return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
1018         }
1019
1020         /* Update all items */
1021         char *select_all_sql = NULL;
1022         sqlite3_stmt *sql_stmt = NULL;
1023         char dst_child_path[MEDIA_SVC_PATHNAME_SIZE + 1];
1024
1025         snprintf(dst_child_path, sizeof(dst_child_path), "%s/%%", dst_path);
1026
1027         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);
1028
1029         media_svc_debug("[SQL query] : %s", select_all_sql);
1030
1031         ret = sqlite3_prepare_v2(handle, select_all_sql, -1, &sql_stmt, NULL);
1032         sqlite3_free((char *)select_all_sql);
1033
1034         if (ret != SQLITE_OK) {
1035                 media_svc_error ("prepare error [%s]", sqlite3_errmsg(handle));
1036                 _media_svc_sql_rollback_trans(handle, uid);
1037                 return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
1038         }
1039
1040         while (1) {
1041                 ret = sqlite3_step(sql_stmt);
1042                 if (ret != SQLITE_ROW) {
1043                         media_svc_debug("end of iteration");
1044                         break;
1045                 }
1046
1047                 char media_uuid[MEDIA_SVC_UUID_SIZE + 1] = {0,};
1048                 char media_path[MEDIA_SVC_PATHNAME_SIZE + 1] = {0,};
1049                 char media_thumb_path[MEDIA_SVC_PATHNAME_SIZE + 1] = {0,};
1050                 char media_new_thumb_path[MEDIA_SVC_PATHNAME_SIZE + 1] = {0,};
1051                 int media_type;
1052                 bool no_thumb = FALSE;
1053
1054                 if (STRING_VALID((const char *)sqlite3_column_text(sql_stmt, 0))) {
1055                         strncpy(media_uuid,     (const char *)sqlite3_column_text(sql_stmt, 0), sizeof(media_uuid));
1056                         media_uuid[sizeof(media_uuid) - 1] = '\0';
1057                 } else {
1058                         media_svc_error("media UUID is NULL");
1059                         return MEDIA_INFO_ERROR_DATABASE_INVALID;
1060                 }
1061
1062                 if (STRING_VALID((const char *)sqlite3_column_text(sql_stmt, 1))) {
1063                         strncpy(media_path,     (const char *)sqlite3_column_text(sql_stmt, 1), sizeof(media_path));
1064                         media_path[sizeof(media_path) - 1] = '\0';
1065                 } else {
1066                         media_svc_error("media path is NULL");
1067                         return MEDIA_INFO_ERROR_DATABASE_INVALID;
1068                 }
1069
1070                 if (STRING_VALID((const char *)sqlite3_column_text(sql_stmt, 2))) {
1071                         strncpy(media_thumb_path,       (const char *)sqlite3_column_text(sql_stmt, 2), sizeof(media_thumb_path));
1072                         media_thumb_path[sizeof(media_thumb_path) - 1] = '\0';
1073                 } else {
1074                         media_svc_debug("media thumb path doesn't exist in DB");
1075                         no_thumb = TRUE;
1076                 }
1077
1078                 media_type = sqlite3_column_int(sql_stmt, 3);
1079
1080                 /* Update path, thumbnail path of this item */
1081                 char *replaced_path = NULL;
1082                 replaced_path = _media_svc_replace_path(media_path, src_path, dst_path);
1083                 if (replaced_path == NULL) {
1084                         media_svc_error("_media_svc_replace_path failed");
1085                         SQLITE3_FINALIZE(sql_stmt);
1086                         _media_svc_sql_rollback_trans(handle, uid);
1087                         return MEDIA_INFO_ERROR_INTERNAL;
1088                 }
1089
1090                 media_svc_debug("New media path : %s", replaced_path);
1091                 media_svc_storage_type_e storage_type;
1092
1093                 if (!no_thumb) {
1094                         /* If old thumb path is default or not */
1095                         if (strncmp(media_thumb_path, _media_svc_get_thumb_default_path(uid), sizeof(_media_svc_get_thumb_default_path(uid))) == 0) {
1096                                 strncpy(media_new_thumb_path, _media_svc_get_thumb_default_path(uid), sizeof(media_new_thumb_path));
1097                         } else {
1098                                 ret = _media_svc_get_store_type_by_path(replaced_path, &storage_type);
1099                                 if (ret < 0) {
1100                                         media_svc_error("_media_svc_get_store_type_by_path failed : %d", ret);
1101                                         SAFE_FREE(replaced_path);
1102                                         _media_svc_sql_rollback_trans(handle,uid);
1103                                         return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
1104                                 }
1105
1106                                 ret = _media_svc_get_thumbnail_path(storage_type, media_new_thumb_path, replaced_path, THUMB_EXT, uid);
1107                                 if (ret < 0) {
1108                                         media_svc_error("_media_svc_get_thumbnail_path failed : %d", ret);
1109                                         SAFE_FREE(replaced_path);
1110                                         SQLITE3_FINALIZE(sql_stmt);
1111                                         _media_svc_sql_rollback_trans(handle,uid);
1112                                         return MEDIA_INFO_ERROR_INTERNAL;
1113                                 }
1114                         }
1115
1116                         //media_svc_debug("New media thumbnail path : %s", media_new_thumb_path);
1117                 }
1118
1119                 char *update_item_sql = NULL;
1120
1121                 if (no_thumb) {
1122                         update_item_sql = sqlite3_mprintf("UPDATE media SET path='%q' WHERE media_uuid='%q'", replaced_path, media_uuid);
1123                 } else {
1124                         if (media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE || media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO) {
1125                                 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);
1126                         } else {
1127                                 update_item_sql = sqlite3_mprintf("UPDATE media SET path='%q', thumbnail_path='%q' WHERE media_uuid='%q'", replaced_path, media_thumb_path, media_uuid);
1128                         }
1129                 }
1130
1131                 ret = media_db_request_update_db_batch(update_item_sql,uid);
1132                 //ret = _media_svc_sql_query(handle, update_item_sql);
1133                 sqlite3_free(update_item_sql);
1134                 SAFE_FREE(replaced_path);
1135
1136                 if (ret != SQLITE_OK) {
1137                         media_svc_error("failed to update item");
1138                         SQLITE3_FINALIZE(sql_stmt);
1139                         _media_svc_sql_rollback_trans(handle,uid);
1140
1141                         return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
1142                 }
1143
1144                 /* Rename thumbnail file of file system */
1145                 if ((!no_thumb) && (media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE || media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)
1146                                 && (strncmp(media_thumb_path, _media_svc_get_thumb_default_path(uid), sizeof(_media_svc_get_thumb_default_path(uid))) != 0)) {
1147                         ret = _media_svc_rename_file(media_thumb_path, media_new_thumb_path);
1148                         if (ret < 0) {
1149                                 media_svc_error("_media_svc_rename_file failed : %d", ret);
1150                         }
1151                 }
1152         }
1153
1154         SQLITE3_FINALIZE(sql_stmt);
1155
1156         ret = _media_svc_sql_end_trans(handle, uid);
1157         if (ret != MEDIA_INFO_ERROR_NONE) {
1158                 media_svc_error("mb_svc_sqlite3_commit_trans failed.. Now start to rollback\n");
1159                 _media_svc_sql_rollback_trans(handle,uid);
1160                 return ret;
1161         }
1162
1163         media_svc_debug("Folder update is successful. Sending noti for this");
1164         _media_svc_publish_noti(MS_MEDIA_ITEM_DIRECTORY, MS_MEDIA_ITEM_UPDATE, src_path, -1, noti_item->media_uuid, NULL);
1165         _media_svc_destroy_noti_item(noti_item);
1166
1167         return MEDIA_INFO_ERROR_NONE;
1168 }
1169
1170 int media_svc_request_update_db(const char *db_query, uid_t uid)
1171 {
1172         int ret = MEDIA_INFO_ERROR_NONE;
1173
1174         media_svc_retvm_if(!STRING_VALID(db_query), MEDIA_INFO_ERROR_INVALID_PARAMETER, "db_query is NULL");
1175
1176         ret = _media_svc_request_update_db(db_query, uid);
1177
1178         return _media_svc_error_convert(ret);
1179 }
1180
1181 int media_svc_send_dir_update_noti(MediaSvcHandle *handle, const char *dir_path)
1182 {
1183         int ret = MEDIA_INFO_ERROR_NONE;
1184         sqlite3 * db_handle = (sqlite3 *)handle;
1185
1186         media_svc_retvm_if(!STRING_VALID(dir_path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "dir_path is NULL");
1187
1188         /* Get notification info */
1189         media_svc_noti_item *noti_item = NULL;
1190         ret = _media_svc_get_noti_info(db_handle, dir_path, MS_MEDIA_ITEM_DIRECTORY, &noti_item);
1191         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
1192
1193         ret = _media_svc_publish_noti(MS_MEDIA_ITEM_DIRECTORY, MS_MEDIA_ITEM_UPDATE, dir_path, -1, noti_item->media_uuid, NULL);
1194         _media_svc_destroy_noti_item(noti_item);
1195
1196         return ret;
1197 }
1198
1199 int media_svc_count_invalid_items_in_folder(MediaSvcHandle *handle, const char *folder_path, int *count)
1200 {
1201         sqlite3 * db_handle = (sqlite3 *)handle;
1202
1203         media_svc_debug_func();
1204
1205         media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
1206         media_svc_retvm_if(folder_path == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "folder_path is NULL");
1207         media_svc_retvm_if(count == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "count is NULL");
1208
1209         return _media_svc_count_invalid_folder_items(db_handle, folder_path, count);
1210 }
1211
1212 int media_svc_get_pinyin(MediaSvcHandle *handle, const char * src_str, char **pinyin_str)
1213 {
1214         media_svc_retvm_if(!STRING_VALID(src_str), MEDIA_INFO_ERROR_INVALID_PARAMETER, "String is NULL");
1215
1216         return _media_svc_get_pinyin_str(src_str, pinyin_str);
1217 }
1218 int media_svc_check_pinyin_support(bool *support)
1219 {
1220         *support = _media_svc_check_pinyin_support();
1221
1222         return MEDIA_INFO_ERROR_NONE;
1223 }