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-svc.h"
  25 #include "media-svc-media.h"
  26 #include "media-svc-debug.h"
  27 #include "media-svc-util.h"
  28 #include "media-svc-db-utils.h"
  29 #include "media-svc-env.h"
  30 #include "media-svc-media-folder.h"
  31 #include "media-svc-album.h"
  32 #include "media-svc-noti.h"
  33 #include "media-svc-storage.h"
  34
  35 static __thread int g_media_svc_item_validity_data_cnt = 1;
  36 static __thread int g_media_svc_item_validity_cur_data_cnt = 0;
  37
  38 static __thread int g_media_svc_insert_item_data_cnt = 1;
  39 static __thread int g_media_svc_insert_item_cur_data_cnt = 0;
  40
  41 static __thread int g_media_svc_update_item_data_cnt = 1;
  42 static __thread int g_media_svc_update_item_cur_data_cnt = 0;
  43
  44 static __thread int g_media_svc_insert_folder_data_cnt = 1;
  45 static __thread int g_media_svc_insert_folder_cur_data_cnt = 0;
  46
  47 /* Flag for items to be published by notification */
  48 static __thread int g_insert_with_noti = FALSE;
  49
  50 #define BATCH_REQUEST_MAX 300
  51
  52 static bool __media_svc_check_storage(ms_user_storage_type_e storage_type)
  53 {
  54         if ((storage_type != MS_USER_STORAGE_INTERNAL)
  55                 && (storage_type != MS_USER_STORAGE_EXTERNAL)
  56                 && (storage_type != MS_USER_STORAGE_EXTERNAL_USB)) {
  57                 media_svc_error("storage type is incorrect[%d]", storage_type);
  58                 return FALSE;
  59         }
  60
  61         return TRUE;
  62 }
  63
  64 int media_svc_connect(MediaSvcHandle **handle, uid_t uid, bool need_write)
  65 {
  66         int ret = MS_MEDIA_ERR_NONE;
  67         MediaDBHandle *db_handle = NULL;
  68
  69         media_svc_debug_fenter();
  70
  71         ret = media_db_connect(&db_handle, uid, need_write);
  72         if (ret != MS_MEDIA_ERR_NONE)
  73                 return ret;
  74
  75         *handle = db_handle;
  76         return MS_MEDIA_ERR_NONE;
  77 }
  78
  79 int media_svc_disconnect(MediaSvcHandle *handle)
  80 {
  81         MediaDBHandle *db_handle = (MediaDBHandle *)handle;
  82
  83         media_svc_debug_fenter();
  84
  85         return media_db_disconnect(db_handle);
  86 }
  87
  88 int media_svc_cleanup_db(MediaSvcHandle *handle, uid_t uid)
  89 {
  90         MediaDBHandle *db_handle = (MediaDBHandle *)handle;
  91
  92         media_svc_debug_fenter();
  93
  94         return _media_svc_do_cleanup(db_handle, uid);
  95 }
  96
  97 int media_svc_get_user_version(MediaSvcHandle *handle, int *user_version)
  98 {
  99         sqlite3 *db_handle = (sqlite3 *)handle;
 100
 101         return _media_svc_get_user_version(db_handle, user_version);
 102 }
 103
 104 int media_svc_create_table(uid_t uid)
 105 {
 106         int ret = MS_MEDIA_ERR_NONE;
 107         char *sql = NULL;
 108
 109         media_svc_debug_fenter();
 110
 111         ret = _media_svc_init_table_query(MEDIA_SVC_DB_TABLE_MEDIA);
 112         if (ret != MS_MEDIA_ERR_NONE) {
 113                 media_svc_error("_media_svc_init_table_query fail.");
 114                 goto ERROR;
 115         }
 116
 117         /*create media table*/
 118         ret = _media_svc_make_table_query(MEDIA_SVC_DB_TABLE_MEDIA, MEDIA_SVC_DB_LIST_MEDIA, uid);
 119         if (ret != MS_MEDIA_ERR_NONE) {
 120                 media_svc_error("_media_svc_make_table_query fail.");
 121                 goto ERROR;
 122         }
 123
 124         /*create folder table*/
 125         ret = _media_svc_make_table_query(MEDIA_SVC_DB_TABLE_FOLDER, MEDIA_SVC_DB_LIST_FOLDER, uid);
 126         if (ret != MS_MEDIA_ERR_NONE) {
 127                 media_svc_error("_media_svc_make_table_query fail.");
 128                 goto ERROR;
 129         }
 130
 131         /*create playlist_map table*/
 132         ret = _media_svc_make_table_query(MEDIA_SVC_DB_TABLE_PLAYLIST_MAP, MEDIA_SVC_DB_LIST_PLAYLIST_MAP, uid);
 133         if (ret != MS_MEDIA_ERR_NONE) {
 134                 media_svc_error("_media_svc_make_table_query fail.");
 135                 goto ERROR;
 136         }
 137
 138         /*create playlist table*/
 139         ret = _media_svc_make_table_query(MEDIA_SVC_DB_TABLE_PLAYLIST, MEDIA_SVC_DB_LIST_PLAYLIST, uid);
 140         if (ret != MS_MEDIA_ERR_NONE) {
 141                 media_svc_error("_media_svc_make_table_query fail.");
 142                 goto ERROR;
 143         }
 144
 145         /* create album table*/
 146         ret = _media_svc_make_table_query(MEDIA_SVC_DB_TABLE_ALBUM, MEDIA_SVC_DB_LIST_ALBUM, uid);
 147         if (ret != MS_MEDIA_ERR_NONE) {
 148                 media_svc_error("_media_svc_make_table_query fail.");
 149                 goto ERROR;
 150         }
 151
 152         /*create tag_map table*/
 153         ret = _media_svc_make_table_query(MEDIA_SVC_DB_TABLE_TAG_MAP, MEDIA_SVC_DB_LIST_TAG_MAP, uid);
 154         if (ret != MS_MEDIA_ERR_NONE) {
 155                 media_svc_error("_media_svc_make_table_query fail.");
 156                 goto ERROR;
 157         }
 158
 159         /*create tag table*/
 160         ret = _media_svc_make_table_query(MEDIA_SVC_DB_TABLE_TAG, MEDIA_SVC_DB_LIST_TAG, uid);
 161         if (ret != MS_MEDIA_ERR_NONE) {
 162                 media_svc_error("_media_svc_make_table_query fail.");
 163                 goto ERROR;
 164         }
 165
 166         /*create bookmark table*/
 167         ret = _media_svc_make_table_query(MEDIA_SVC_DB_TABLE_BOOKMARK, MEDIA_SVC_DB_LIST_BOOKMARK, uid);
 168         if (ret != MS_MEDIA_ERR_NONE) {
 169                 media_svc_error("_media_svc_make_table_query fail.");
 170                 goto ERROR;
 171         }
 172
 173         /*create storage table from tizen 2.4 */
 174         ret = _media_svc_make_table_query(MEDIA_SVC_DB_TABLE_STORAGE, MEDIA_SVC_DB_LIST_STORAGE, uid);
 175         if (ret != MS_MEDIA_ERR_NONE) {
 176                 media_svc_error("_media_svc_make_table_query fail.");
 177                 goto ERROR;
 178         }
 179
 180         /*create face table. from tizen 3.0*/
 181         ret = _media_svc_make_table_query(MEDIA_SVC_DB_TABLE_FACE_SCAN_LIST, MEDIA_SVC_DB_LIST_FACE_SCAN_LIST, uid);
 182         if (ret != MS_MEDIA_ERR_NONE) {
 183                 media_svc_error("_media_svc_make_table_query fail.");
 184                 goto ERROR;
 185         }
 186
 187         ret = _media_svc_make_table_query(MEDIA_SVC_DB_TABLE_FACE, MEDIA_SVC_DB_LIST_FACE, uid);
 188         if (ret != MS_MEDIA_ERR_NONE) {
 189                 media_svc_error("_media_svc_make_table_query fail.");
 190                 goto ERROR;
 191         }
 192
 193         sql = sqlite3_mprintf("pragma user_version = %d;", LATEST_VERSION_NUMBER);
 194         ret = _media_svc_sql_query(sql, uid);
 195         if (ret != MS_MEDIA_ERR_NONE) {
 196                 media_svc_error("user_version update fail.");
 197                 goto ERROR;
 198         }
 199
 200         _media_svc_destroy_table_query();
 201
 202         media_svc_debug_fleave();
 203
 204         return MS_MEDIA_ERR_NONE;
 205 ERROR:
 206         _media_svc_destroy_table_query();
 207
 208         media_svc_debug_fleave();
 209
 210         return ret;
 211 }
 212
 213 int media_svc_get_file_info(MediaSvcHandle *handle, const char *storage_id, const char *path, time_t *modified_time, unsigned long long *size)
 214 {
 215         sqlite3 *db_handle = (sqlite3 *)handle;
 216
 217         return _media_svc_get_fileinfo_by_path(db_handle, storage_id, path, modified_time, size);
 218 }
 219
 220 int media_svc_check_item_exist_by_path(MediaSvcHandle *handle, const char *storage_id, const char *path)
 221 {
 222         int ret = MS_MEDIA_ERR_NONE;
 223         sqlite3 *db_handle = (sqlite3 *)handle;
 224         int count = -1;
 225
 226         ret = _media_svc_count_record_with_path(db_handle, storage_id, path, &count);
 227         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 228
 229         if (count > 0) {
 230                 media_svc_debug("item is exist in database");
 231                 return MS_MEDIA_ERR_NONE;
 232         } else {
 233                 media_svc_debug("item is not exist in database");
 234                 return MS_MEDIA_ERR_DB_NO_RECORD;
 235         }
 236
 237         return MS_MEDIA_ERR_NONE;
 238 }
 239
 240 int media_svc_insert_item_begin(int data_cnt, int with_noti, int from_pid)
 241 {
 242         media_svc_debug("Transaction data count : [%d]", data_cnt);
 243
 244         media_svc_retvm_if(data_cnt < 1, MS_MEDIA_ERR_INVALID_PARAMETER, "data_cnt shuld be bigger than 1");
 245
 246         g_media_svc_insert_item_data_cnt = data_cnt;
 247         g_media_svc_insert_item_cur_data_cnt = 0;
 248
 249         /* Prepare for making noti item list */
 250         if (with_noti) {
 251                 media_svc_debug("making noti list from pid[%d]", from_pid);
 252                 if (_media_svc_create_noti_list(data_cnt) != MS_MEDIA_ERR_NONE)
 253                         return MS_MEDIA_ERR_OUT_OF_MEMORY;
 254
 255                 _media_svc_set_noti_from_pid(from_pid);
 256                 g_insert_with_noti = TRUE;
 257         }
 258
 259         return MS_MEDIA_ERR_NONE;
 260 }
 261
 262 int media_svc_insert_item_end(uid_t uid)
 263 {
 264         int ret = MS_MEDIA_ERR_NONE;
 265
 266         media_svc_debug_fenter();
 267
 268         if (g_media_svc_insert_item_cur_data_cnt > 0) {
 269
 270                 ret = _media_svc_list_query_do(MEDIA_SVC_QUERY_INSERT_ITEM, uid);
 271                 if (g_insert_with_noti) {
 272                         media_svc_debug("sending noti list");
 273                         _media_svc_publish_noti_list(g_media_svc_insert_item_cur_data_cnt);
 274                         _media_svc_destroy_noti_list(g_media_svc_insert_item_cur_data_cnt);
 275                         g_insert_with_noti = FALSE;
 276                         _media_svc_set_noti_from_pid(-1);
 277                 }
 278         }
 279
 280         g_media_svc_insert_item_data_cnt = 1;
 281         g_media_svc_insert_item_cur_data_cnt = 0;
 282
 283         return ret;
 284 }
 285
 286 int media_svc_insert_item_bulk(MediaSvcHandle *handle, const char *storage_id, ms_user_storage_type_e storage_type, const char *path, uid_t uid)
 287 {
 288         int ret = MS_MEDIA_ERR_NONE;
 289         sqlite3 *db_handle = (sqlite3 *)handle;
 290         char folder_uuid[MEDIA_SVC_UUID_SIZE + 1] = {0, };
 291         media_svc_media_type_e media_type;
 292
 293         media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 294         media_svc_retvm_if(!STRING_VALID(storage_id), MS_MEDIA_ERR_INVALID_PARAMETER, "storage_id is NULL");
 295         media_svc_retvm_if(!STRING_VALID(path), MS_MEDIA_ERR_INVALID_PARAMETER, "path is NULL");
 296         media_svc_retvm_if(__media_svc_check_storage(storage_type) != TRUE, MS_MEDIA_ERR_INVALID_PARAMETER, "Invalid storage_type");
 297
 298         media_svc_content_info_s content_info;
 299         memset(&content_info, 0, sizeof(media_svc_content_info_s));
 300
 301         /*Set media info*/
 302         /* if drm_contentinfo is not NULL, the file is OMA DRM.*/
 303         ret = _media_svc_set_media_info(&content_info, storage_id, storage_type, path, &media_type, FALSE);
 304         if (ret != MS_MEDIA_ERR_NONE)
 305                 return ret;
 306
 307         if (media_type == MEDIA_SVC_MEDIA_TYPE_OTHER
 308         || (media_type == MEDIA_SVC_MEDIA_TYPE_PVR)
 309         || (media_type == MEDIA_SVC_MEDIA_TYPE_UHD)
 310         || (media_type == MEDIA_SVC_MEDIA_TYPE_SCSA))
 311                 media_svc_debug("Do nothing[%d]", media_type);
 312         else if (media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE)
 313                 ret = _media_svc_extract_image_metadata(&content_info);
 314         else
 315                 ret = _media_svc_extract_media_metadata(db_handle, &content_info, uid);
 316         media_svc_retv_del_if(ret != MS_MEDIA_ERR_NONE, ret, &content_info);
 317
 318         /*Set or Get folder id*/
 319         ret = _media_svc_get_and_append_folder_id_by_path(db_handle, storage_id, path, storage_type, folder_uuid, uid);
 320         media_svc_retv_del_if(ret != MS_MEDIA_ERR_NONE, ret, &content_info);
 321
 322         content_info.folder_uuid = g_strdup(folder_uuid);
 323         media_svc_retv_del_if(content_info.folder_uuid == NULL, MS_MEDIA_ERR_INTERNAL, &content_info);
 324
 325         if (g_media_svc_insert_item_data_cnt == 1) {
 326
 327                 ret = _media_svc_insert_item_with_data(db_handle, storage_id, &content_info, FALSE, uid);
 328                 media_svc_retv_del_if(ret != MS_MEDIA_ERR_NONE, ret, &content_info);
 329
 330                 if (g_insert_with_noti)
 331                         _media_svc_insert_item_to_noti_list(&content_info, g_media_svc_insert_item_cur_data_cnt++);
 332
 333         } else if (g_media_svc_insert_item_cur_data_cnt < (g_media_svc_insert_item_data_cnt - 1)) {
 334
 335                 ret = _media_svc_insert_item_with_data(db_handle, storage_id, &content_info, TRUE, uid);
 336                 media_svc_retv_del_if(ret != MS_MEDIA_ERR_NONE, ret, &content_info);
 337
 338                 if (g_insert_with_noti)
 339                         _media_svc_insert_item_to_noti_list(&content_info, g_media_svc_insert_item_cur_data_cnt);
 340
 341                 g_media_svc_insert_item_cur_data_cnt++;
 342
 343         } else if (g_media_svc_insert_item_cur_data_cnt == (g_media_svc_insert_item_data_cnt - 1)) {
 344
 345                 ret = _media_svc_insert_item_with_data(db_handle, storage_id, &content_info, TRUE, uid);
 346                 media_svc_retv_del_if(ret != MS_MEDIA_ERR_NONE, ret, &content_info);
 347
 348                 if (g_insert_with_noti)
 349                         _media_svc_insert_item_to_noti_list(&content_info, g_media_svc_insert_item_cur_data_cnt);
 350
 351                 ret = _media_svc_list_query_do(MEDIA_SVC_QUERY_INSERT_ITEM, uid);
 352                 media_svc_retv_del_if(ret != MS_MEDIA_ERR_NONE, ret, &content_info);
 353
 354                 if (g_insert_with_noti) {
 355                         _media_svc_publish_noti_list(g_media_svc_insert_item_cur_data_cnt + 1);
 356                         _media_svc_destroy_noti_list(g_media_svc_insert_item_cur_data_cnt + 1);
 357
 358                         /* Recreate noti list */
 359                         ret = _media_svc_create_noti_list(g_media_svc_insert_item_data_cnt);
 360                         media_svc_retv_del_if(ret != MS_MEDIA_ERR_NONE, ret, &content_info);
 361                 }
 362
 363                 g_media_svc_insert_item_cur_data_cnt = 0;
 364
 365         } else {
 366                 media_svc_error("Error in media_svc_insert_item_bulk");
 367                 _media_svc_destroy_content_info(&content_info);
 368                 return MS_MEDIA_ERR_INTERNAL;
 369         }
 370
 371         _media_svc_destroy_content_info(&content_info);
 372
 373         return MS_MEDIA_ERR_NONE;
 374 }
 375
 376 int media_svc_insert_item_immediately(MediaSvcHandle *handle, const char *storage_id, ms_user_storage_type_e storage_type, const char *path, uid_t uid)
 377 {
 378         int ret = MS_MEDIA_ERR_NONE;
 379         sqlite3 *db_handle = (sqlite3 *)handle;
 380         char folder_uuid[MEDIA_SVC_UUID_SIZE + 1] = {0, };
 381         media_svc_media_type_e media_type;
 382
 383         media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 384         media_svc_retvm_if(!STRING_VALID(storage_id), MS_MEDIA_ERR_INVALID_PARAMETER, "storage_id is NULL");
 385         media_svc_retvm_if(!STRING_VALID(path), MS_MEDIA_ERR_INVALID_PARAMETER, "path is NULL");
 386         media_svc_retvm_if(__media_svc_check_storage(storage_type) != TRUE, MS_MEDIA_ERR_INVALID_PARAMETER, "Invalid storage_type");
 387
 388         media_svc_content_info_s content_info;
 389         memset(&content_info, 0, sizeof(media_svc_content_info_s));
 390
 391         /*Set media info*/
 392         ret = _media_svc_set_media_info(&content_info, storage_id, storage_type, path, &media_type, FALSE);
 393         if (ret != MS_MEDIA_ERR_NONE)
 394                 return ret;
 395
 396         if (media_type == MEDIA_SVC_MEDIA_TYPE_OTHER
 397         || (media_type == MEDIA_SVC_MEDIA_TYPE_PVR)
 398         || (media_type == MEDIA_SVC_MEDIA_TYPE_UHD)
 399         || (media_type == MEDIA_SVC_MEDIA_TYPE_SCSA)) {
 400                 /*Do nothing.*/
 401         } else if (media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) {
 402                 ret = _media_svc_extract_image_metadata(&content_info);
 403         } else {
 404                 ret = _media_svc_extract_media_metadata(db_handle, &content_info, uid);
 405         }
 406
 407         media_svc_retv_del_if(ret != MS_MEDIA_ERR_NONE, ret, &content_info);
 408
 409         /*Set or Get folder id*/
 410         ret = _media_svc_get_and_append_folder_id_by_path(db_handle, storage_id, path, storage_type, folder_uuid, uid);
 411         media_svc_retv_del_if(ret != MS_MEDIA_ERR_NONE, ret, &content_info);
 412
 413         content_info.folder_uuid = g_strdup(folder_uuid);
 414         media_svc_retv_del_if(content_info.folder_uuid == NULL, MS_MEDIA_ERR_INTERNAL, &content_info);
 415
 416         /* Extracting thumbnail */
 417         if (content_info.thumbnail_path == NULL) {
 418                 if (media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE || media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO) {
 419                         char thumb_path[MEDIA_SVC_PATHNAME_SIZE + 1] = {0, };
 420
 421                         ret = _media_svc_create_thumbnail(content_info.path, thumb_path, sizeof(thumb_path), media_type, uid);
 422                         if (ret == MS_MEDIA_ERR_NONE)
 423                                 content_info.thumbnail_path = g_strdup(thumb_path);
 424                 }
 425         }
 426
 427         ret = _media_svc_insert_item_with_data(db_handle, storage_id, &content_info, FALSE, uid);
 428
 429         if (ret == MS_MEDIA_ERR_NONE) {
 430                 media_svc_debug("Insertion is successful. Sending noti for this");
 431                 _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);
 432         } else if (ret == MS_MEDIA_ERR_DB_CONSTRAINT_FAIL) {
 433                 media_svc_error("This item is already inserted. This may be normal operation because other process already did this");
 434         }
 435
 436         _media_svc_destroy_content_info(&content_info);
 437         return ret;
 438 }
 439
 440 int media_svc_move_item(MediaSvcHandle *handle, const char *src_path, const char *dest_path, uid_t uid)
 441 {
 442         int ret = MS_MEDIA_ERR_NONE;
 443         sqlite3 *db_handle = (sqlite3 *)handle;
 444         char *file_name = NULL;
 445         char *folder_path = NULL;
 446         int modified_time = 0;
 447         char folder_uuid[MEDIA_SVC_UUID_SIZE + 1] = {0, };
 448         char old_thumb_path[MEDIA_SVC_PATHNAME_SIZE] = {0, };
 449         char org_stg_id[MEDIA_SVC_UUID_SIZE + 1] = {0, };
 450         char dst_stg_id[MEDIA_SVC_UUID_SIZE + 1] = {0, };
 451         ms_user_storage_type_e org_stg_type = MS_USER_STORAGE_INTERNAL;
 452         ms_user_storage_type_e dst_stg_type = MS_USER_STORAGE_INTERNAL;
 453         int media_type = -1;
 454
 455         media_svc_debug_fenter();
 456
 457         media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 458         media_svc_retvm_if(!STRING_VALID(src_path), MS_MEDIA_ERR_INVALID_PARAMETER, "src_path is NULL");
 459         media_svc_retvm_if(!STRING_VALID(dest_path), MS_MEDIA_ERR_INVALID_PARAMETER, "dest_path is NULL");
 460
 461         /* Get storage_id */
 462         ret = _media_svc_get_storage_uuid(db_handle, src_path, org_stg_id, uid);
 463         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 464         ret = _media_svc_get_storage_uuid(db_handle, dest_path, dst_stg_id, uid);
 465         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 466         /* Get storage_type */
 467         ret = ms_user_get_storage_type(uid, src_path, &org_stg_type);
 468         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 469         ret = ms_user_get_storage_type(uid, dest_path, &dst_stg_type);
 470         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 471
 472         /*check and update folder*/
 473         ret = _media_svc_get_and_append_folder_id_by_path(db_handle, dst_stg_id, dest_path, dst_stg_type, folder_uuid, uid);
 474         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 475
 476         /*get filename*/
 477         file_name = g_path_get_basename(dest_path);
 478
 479         /*get modified_time*/
 480         modified_time = _media_svc_get_file_time(dest_path);
 481
 482         ret = _media_svc_get_media_type_by_path(db_handle, org_stg_id, src_path, &media_type);
 483         if (ret != MS_MEDIA_ERR_NONE) {
 484                 media_svc_error("_media_svc_get_media_type_by_path failed");
 485                 SAFE_FREE(file_name);
 486                 return ret;
 487         }
 488
 489         /*get old thumbnail_path and remove thumbnail */
 490         ret = _media_svc_get_thumbnail_path_by_path(db_handle, src_path, old_thumb_path);
 491         if ((ret != MS_MEDIA_ERR_NONE) && (ret != MS_MEDIA_ERR_DB_NO_RECORD)) {
 492                 media_svc_error("_media_svc_get_thumbnail_path_by_path failed");
 493                 SAFE_FREE(file_name);
 494                 return ret;
 495         }
 496
 497         if (STRING_VALID(old_thumb_path)) {
 498                 ret = _media_svc_remove_file(old_thumb_path);
 499                 if (ret != MS_MEDIA_ERR_NONE)
 500                         media_svc_error("_media_svc_remove_file failed : %d", ret);
 501         }
 502
 503         /*move item*/
 504         ret = _media_svc_update_item_by_path(org_stg_id, src_path, dst_stg_id, dst_stg_type, dest_path, file_name, modified_time, folder_uuid, uid);
 505         SAFE_FREE(file_name);
 506         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 507
 508         media_svc_debug("Move is successful. Sending noti for this");
 509
 510         /* Get notification info */
 511         media_svc_noti_item *noti_item = NULL;
 512         ret = _media_svc_get_noti_info(db_handle, dst_stg_id, dest_path, MS_MEDIA_ITEM_FILE, &noti_item);
 513         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 514
 515         /* Send notification for move */
 516         _media_svc_publish_noti(MS_MEDIA_ITEM_FILE, MS_MEDIA_ITEM_UPDATE, src_path, media_type, noti_item->media_uuid, noti_item->mime_type);
 517         _media_svc_destroy_noti_item(noti_item);
 518
 519         /*update folder modified_time*/
 520         folder_path = g_path_get_dirname(dest_path);
 521         ret = _media_svc_update_folder_modified_time_by_folder_uuid(folder_uuid, folder_path, uid);
 522         SAFE_FREE(folder_path);
 523         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 524
 525         return MS_MEDIA_ERR_NONE;
 526 }
 527
 528 int media_svc_set_item_validity_begin(int data_cnt)
 529 {
 530         media_svc_debug("Transaction data count : [%d]", data_cnt);
 531
 532         media_svc_retvm_if(data_cnt < 1, MS_MEDIA_ERR_INVALID_PARAMETER, "data_cnt shuld be bigger than 1");
 533
 534         g_media_svc_item_validity_data_cnt = data_cnt;
 535         g_media_svc_item_validity_cur_data_cnt = 0;
 536
 537         return MS_MEDIA_ERR_NONE;
 538 }
 539
 540 int media_svc_set_item_validity_end(uid_t uid)
 541 {
 542         int ret = MS_MEDIA_ERR_NONE;
 543
 544         media_svc_debug_fenter();
 545
 546         if (g_media_svc_item_validity_cur_data_cnt > 0)
 547                 ret = _media_svc_list_query_do(MEDIA_SVC_QUERY_SET_ITEM_VALIDITY, uid);
 548
 549         g_media_svc_item_validity_data_cnt = 1;
 550         g_media_svc_item_validity_cur_data_cnt = 0;
 551
 552         return ret;
 553 }
 554
 555 int media_svc_set_item_validity(const char *storage_id, const char *path, int validity, uid_t uid)
 556 {
 557         int ret = MS_MEDIA_ERR_NONE;
 558
 559         if (g_media_svc_item_validity_data_cnt == 1) {
 560
 561                 return _media_svc_update_item_validity(storage_id, path, validity, FALSE, uid);
 562
 563         } else if (g_media_svc_item_validity_cur_data_cnt < (g_media_svc_item_validity_data_cnt - 1)) {
 564
 565                 ret = _media_svc_update_item_validity(storage_id, path, validity, TRUE, uid);
 566                 media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 567
 568                 g_media_svc_item_validity_cur_data_cnt++;
 569
 570         } else if (g_media_svc_item_validity_cur_data_cnt == (g_media_svc_item_validity_data_cnt - 1)) {
 571
 572                 ret = _media_svc_update_item_validity(storage_id, path, validity, TRUE, uid);
 573                 media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 574
 575                 ret = _media_svc_list_query_do(MEDIA_SVC_QUERY_SET_ITEM_VALIDITY, uid);
 576                 media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 577
 578                 g_media_svc_item_validity_cur_data_cnt = 0;
 579
 580         } else {
 581
 582                 media_svc_error("Error in media_svc_set_item_validity");
 583                 return MS_MEDIA_ERR_INTERNAL;
 584         }
 585
 586         return MS_MEDIA_ERR_NONE;
 587 }
 588
 589 int media_svc_delete_item_by_path(MediaSvcHandle *handle, const char *storage_id, const char *path, uid_t uid)
 590 {
 591         int ret = MS_MEDIA_ERR_NONE;
 592         sqlite3 *db_handle = (sqlite3 *)handle;
 593         char thumb_path[MEDIA_SVC_PATHNAME_SIZE] = {0, };
 594
 595         media_svc_debug_fenter();
 596
 597         int media_type = -1;
 598         ret = _media_svc_get_media_type_by_path(db_handle, storage_id, path, &media_type);
 599         media_svc_retv_if((ret != MS_MEDIA_ERR_NONE), ret);
 600
 601         /*Get thumbnail path to delete*/
 602         ret = _media_svc_get_thumbnail_path_by_path(db_handle, path, thumb_path);
 603         media_svc_retv_if((ret != MS_MEDIA_ERR_NONE) && (ret != MS_MEDIA_ERR_DB_NO_RECORD), ret);
 604
 605         if (g_media_svc_insert_item_data_cnt == 1) {
 606
 607                 /* Get notification info */
 608                 media_svc_noti_item *noti_item = NULL;
 609                 ret = _media_svc_get_noti_info(db_handle, storage_id, path, MS_MEDIA_ITEM_FILE, &noti_item);
 610                 media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 611
 612                 /*Delete item*/
 613                 ret = _media_svc_delete_item_by_path(storage_id, path, FALSE, uid);
 614                 if (ret != MS_MEDIA_ERR_NONE) {
 615                         media_svc_error("_media_svc_delete_item_by_path failed : %d", ret);
 616                         _media_svc_destroy_noti_item(noti_item);
 617
 618                         return ret;
 619                 }
 620
 621                 /* Send notification */
 622                 media_svc_debug("Deletion is successful. Sending noti for this");
 623                 _media_svc_publish_noti(MS_MEDIA_ITEM_FILE, MS_MEDIA_ITEM_DELETE, path, media_type, noti_item->media_uuid, noti_item->mime_type);
 624                 _media_svc_destroy_noti_item(noti_item);
 625         } else {
 626                 ret = _media_svc_delete_item_by_path(storage_id, path, TRUE, uid);
 627                 if (ret != MS_MEDIA_ERR_NONE) {
 628                         media_svc_error("_media_svc_delete_item_by_path failed : %d", ret);
 629                         return ret;
 630                 }
 631
 632         }
 633
 634         /*Delete thumbnail*/
 635         if (STRING_VALID(thumb_path)) {
 636                 ret = _media_svc_remove_file(thumb_path);
 637                 if (ret != MS_MEDIA_ERR_NONE)
 638                         media_svc_error("fail to remove thumbnail file.");
 639         }
 640
 641         return MS_MEDIA_ERR_NONE;
 642 }
 643
 644 int media_svc_delete_invalid_items_in_storage(MediaSvcHandle *handle, const char *storage_id, ms_user_storage_type_e storage_type, uid_t uid)
 645 {
 646         sqlite3 *db_handle = (sqlite3 *)handle;
 647
 648         media_svc_debug_fenter();
 649
 650         media_svc_retvm_if(!STRING_VALID(storage_id), MS_MEDIA_ERR_INVALID_PARAMETER, "storage_id is NULL");
 651         media_svc_retvm_if(__media_svc_check_storage(storage_type) != TRUE, MS_MEDIA_ERR_INVALID_PARAMETER, "Invalid storage_type");
 652
 653         /*Delete from DB and remove thumbnail files*/
 654         return _media_svc_delete_invalid_items(db_handle, storage_id, storage_type, uid);
 655 }
 656
 657 int media_svc_set_all_storage_items_validity(const char *storage_id, ms_user_storage_type_e storage_type, int validity, uid_t uid)
 658 {
 659         media_svc_retvm_if(!STRING_VALID(storage_id), MS_MEDIA_ERR_INVALID_PARAMETER, "storage_id is NULL");
 660         media_svc_retvm_if(__media_svc_check_storage(storage_type) != TRUE, MS_MEDIA_ERR_INVALID_PARAMETER, "Invalid storage_type");
 661
 662         return _media_svc_update_storage_item_validity(storage_id, storage_type, validity, uid);
 663 }
 664
 665 int media_svc_set_folder_items_validity(MediaSvcHandle *handle, const char *storage_id, const char *folder_path, int validity, int recursive, uid_t uid)
 666 {
 667         sqlite3 *db_handle = (sqlite3 *)handle;
 668
 669         media_svc_retvm_if(!STRING_VALID(storage_id), MS_MEDIA_ERR_INVALID_PARAMETER, "storage_id is NULL");
 670         media_svc_retvm_if(!STRING_VALID(folder_path), MS_MEDIA_ERR_INVALID_PARAMETER, "folder_path is NULL");
 671
 672         if (recursive)
 673                 return _media_svc_update_recursive_folder_item_validity(storage_id, folder_path, validity, uid);
 674         else
 675                 return _media_svc_update_folder_item_validity(db_handle, storage_id, folder_path, validity, uid);
 676 }
 677
 678 int media_svc_refresh_item(MediaSvcHandle *handle, const char *storage_id, ms_user_storage_type_e storage_type, const char *path, uid_t uid)
 679 {
 680         int ret = MS_MEDIA_ERR_NONE;
 681         sqlite3 *db_handle = (sqlite3 *)handle;
 682         media_svc_media_type_e media_type;
 683         char thumb_path[MEDIA_SVC_PATHNAME_SIZE + 1] = {0, };
 684
 685         media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 686         media_svc_retvm_if(!STRING_VALID(storage_id), MS_MEDIA_ERR_INVALID_PARAMETER, "storage_id is NULL");
 687         media_svc_retvm_if(!STRING_VALID(path), MS_MEDIA_ERR_INVALID_PARAMETER, "path is NULL");
 688         media_svc_retvm_if(__media_svc_check_storage(storage_type) != TRUE, MS_MEDIA_ERR_INVALID_PARAMETER, "Invalid storage_type");
 689
 690         media_svc_content_info_s content_info;
 691         memset(&content_info, 0, sizeof(media_svc_content_info_s));
 692
 693         /*Set media info*/
 694         ret = _media_svc_set_media_info(&content_info, storage_id, storage_type, path, &media_type, TRUE);
 695         if (ret != MS_MEDIA_ERR_NONE)
 696                 return ret;
 697
 698         /* Initialize thumbnail information to remake thumbnail. */
 699         ret = _media_svc_get_thumbnail_path_by_path(db_handle, path, thumb_path);
 700         if (ret != MS_MEDIA_ERR_NONE && ret != MS_MEDIA_ERR_DB_NO_RECORD) {
 701                 _media_svc_destroy_content_info(&content_info);
 702                 return ret;
 703         }
 704
 705         if (STRING_VALID(thumb_path)) {
 706                 if (g_file_test(thumb_path, G_FILE_TEST_EXISTS)) {
 707                         ret = _media_svc_remove_file(thumb_path);
 708                         if (ret != MS_MEDIA_ERR_NONE)
 709                                 media_svc_error("_media_svc_remove_file failed : %s", thumb_path);
 710                 }
 711
 712                 ret = _media_svc_update_thumbnail_path(storage_id, path, NULL, uid);
 713                 if (ret != MS_MEDIA_ERR_NONE) {
 714                         _media_svc_destroy_content_info(&content_info);
 715                         return ret;
 716                 }
 717         }
 718
 719         /* Get notification info */
 720         media_svc_noti_item *noti_item = NULL;
 721         ret = _media_svc_get_noti_info(db_handle, storage_id, path, MS_MEDIA_ITEM_FILE, &noti_item);
 722         if (ret != MS_MEDIA_ERR_NONE) {
 723                 _media_svc_destroy_content_info(&content_info);
 724                 return ret;
 725         }
 726
 727         media_type = noti_item->media_type;
 728         content_info.media_type = media_type;
 729
 730         if (media_type == MEDIA_SVC_MEDIA_TYPE_OTHER
 731         || (media_type == MEDIA_SVC_MEDIA_TYPE_PVR)
 732         || (media_type == MEDIA_SVC_MEDIA_TYPE_UHD)
 733         || (media_type == MEDIA_SVC_MEDIA_TYPE_SCSA))
 734                 media_svc_debug("Do nothing [%d]", media_type);
 735         else if (media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE)
 736                 ret = _media_svc_extract_image_metadata(&content_info);
 737         else
 738                 ret = _media_svc_extract_media_metadata(db_handle, &content_info, uid);
 739
 740         if (ret != MS_MEDIA_ERR_NONE) {
 741                 _media_svc_destroy_noti_item(noti_item);
 742                 _media_svc_destroy_content_info(&content_info);
 743                 return ret;
 744         }
 745
 746         /* Extracting thumbnail */
 747         if (content_info.thumbnail_path == NULL) {
 748                 if (media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE || media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO) {
 749                         memset(thumb_path, 0, sizeof(thumb_path));
 750
 751                         ret = _media_svc_create_thumbnail(content_info.path, thumb_path, sizeof(thumb_path), media_type, uid);
 752                         if (ret == MS_MEDIA_ERR_NONE)
 753                                 content_info.thumbnail_path = g_strdup(thumb_path);
 754                 }
 755         }
 756
 757         ret = _media_svc_update_item_with_data(storage_id, &content_info, uid);
 758
 759         if (ret == MS_MEDIA_ERR_NONE) {
 760                 media_svc_debug("Update is successful. Sending noti for this");
 761                 _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);
 762         } else {
 763                 media_svc_error("_media_svc_update_item_with_data failed : %d", ret);
 764         }
 765
 766         _media_svc_destroy_content_info(&content_info);
 767         _media_svc_destroy_noti_item(noti_item);
 768
 769         return ret;
 770 }
 771
 772 int media_svc_request_update_db(const char *db_query, uid_t uid)
 773 {
 774         return _media_svc_sql_query(db_query, uid);
 775 }
 776
 777 int media_svc_send_dir_update_noti(MediaSvcHandle *handle, const char *storage_id, const char *dir_path, const char *folder_id, media_item_update_type_e update_type, int pid)
 778 {
 779         int ret = MS_MEDIA_ERR_NONE;
 780         sqlite3 *db_handle = (sqlite3 *)handle;
 781         char *uuid = NULL;
 782
 783         media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 784         media_svc_retvm_if(!STRING_VALID(dir_path), MS_MEDIA_ERR_INVALID_PARAMETER, "dir_path is NULL");
 785
 786         /* Get notification info */
 787         media_svc_noti_item *noti_item = NULL;
 788         ret = _media_svc_get_noti_info(db_handle, storage_id, dir_path, MS_MEDIA_ITEM_DIRECTORY, &noti_item);
 789         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 790
 791         if (folder_id != NULL) {
 792                 uuid = strndup(folder_id, strlen(folder_id));
 793         } else {
 794                 if (noti_item->media_uuid != NULL) {
 795                         uuid = strndup(noti_item->media_uuid, strlen(noti_item->media_uuid));
 796                 } else {
 797                         _media_svc_destroy_noti_item(noti_item);
 798                         media_svc_error("folder uuid is wrong");
 799                         return MS_MEDIA_ERR_DB_INTERNAL;
 800                 }
 801         }
 802
 803         ret = _media_svc_publish_dir_noti_v2(MS_MEDIA_ITEM_DIRECTORY, update_type, dir_path, -1, uuid, NULL, pid);
 804         _media_svc_destroy_noti_item(noti_item);
 805         SAFE_FREE(uuid);
 806
 807         return ret;
 808 }
 809
 810 int media_svc_check_db_upgrade(MediaSvcHandle *handle, int user_version, uid_t uid)
 811 {
 812         sqlite3 *db_handle = (sqlite3 *)handle;
 813
 814         media_svc_debug_fenter();
 815
 816         media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 817
 818         return _media_svc_check_db_upgrade(db_handle, user_version, uid);
 819 }
 820
 821 int media_svc_update_item_begin(int data_cnt)
 822 {
 823         media_svc_debug("Transaction data count : [%d]", data_cnt);
 824
 825         media_svc_retvm_if(data_cnt < 1, MS_MEDIA_ERR_INVALID_PARAMETER, "data_cnt shuld be bigger than 1");
 826
 827         g_media_svc_update_item_data_cnt = data_cnt;
 828         g_media_svc_update_item_cur_data_cnt = 0;
 829
 830         return MS_MEDIA_ERR_NONE;
 831 }
 832
 833 int media_svc_update_item_end(uid_t uid)
 834 {
 835         int ret = MS_MEDIA_ERR_NONE;
 836
 837         media_svc_debug_fenter();
 838
 839         if (g_media_svc_update_item_cur_data_cnt > 0)
 840                 ret = _media_svc_list_query_do(MEDIA_SVC_QUERY_UPDATE_ITEM, uid);
 841
 842         g_media_svc_update_item_data_cnt = 1;
 843         g_media_svc_update_item_cur_data_cnt = 0;
 844
 845         return ret;
 846 }
 847
 848 int media_svc_update_item_meta(const char *file_path, const char *storage_id, int storage_type, uid_t uid)
 849 {
 850         int ret = MS_MEDIA_ERR_NONE;
 851         media_svc_media_type_e media_type;
 852
 853         media_svc_retvm_if(!STRING_VALID(file_path), MS_MEDIA_ERR_INVALID_PARAMETER, "path is NULL");
 854         media_svc_retvm_if(__media_svc_check_storage(storage_type) != TRUE, MS_MEDIA_ERR_INVALID_PARAMETER, "Invalid storage_type");
 855
 856         media_svc_content_info_s content_info;
 857         memset(&content_info, 0, sizeof(media_svc_content_info_s));
 858
 859         /*Set media info*/
 860         ret = _media_svc_set_media_info(&content_info, storage_id, storage_type, file_path, &media_type, FALSE);
 861         if (ret != MS_MEDIA_ERR_NONE)
 862                 return ret;
 863
 864         if (media_type == MEDIA_SVC_MEDIA_TYPE_MUSIC)
 865                 ret = _media_svc_extract_music_metadata_for_update(&content_info, media_type);
 866         else {
 867                 _media_svc_destroy_content_info(&content_info);
 868                 return MS_MEDIA_ERR_NONE;
 869         }
 870
 871         if (ret != MS_MEDIA_ERR_NONE) {
 872                 _media_svc_destroy_content_info(&content_info);
 873                 return ret;
 874         }
 875
 876         if (g_media_svc_update_item_data_cnt == 1) {
 877
 878                 ret = _media_svc_update_meta_with_data(&content_info);
 879                 media_svc_retv_del_if(ret != MS_MEDIA_ERR_NONE, ret, &content_info);
 880
 881         } else if (g_media_svc_update_item_cur_data_cnt < (g_media_svc_update_item_data_cnt - 1)) {
 882
 883                 ret = _media_svc_update_meta_with_data(&content_info);
 884                 media_svc_retv_del_if(ret != MS_MEDIA_ERR_NONE, ret, &content_info);
 885
 886                 g_media_svc_update_item_cur_data_cnt++;
 887
 888         } else if (g_media_svc_update_item_cur_data_cnt == (g_media_svc_update_item_data_cnt - 1)) {
 889
 890                 ret = _media_svc_update_meta_with_data(&content_info);
 891                 media_svc_retv_del_if(ret != MS_MEDIA_ERR_NONE, ret, &content_info);
 892
 893                 ret = _media_svc_list_query_do(MEDIA_SVC_QUERY_UPDATE_ITEM, uid);
 894                 media_svc_retv_del_if(ret != MS_MEDIA_ERR_NONE, ret, &content_info);
 895
 896                 g_media_svc_update_item_cur_data_cnt = 0;
 897
 898         } else {
 899                 media_svc_error("Error in media_svc_update_item_meta");
 900                 _media_svc_destroy_content_info(&content_info);
 901                 return MS_MEDIA_ERR_INTERNAL;
 902         }
 903
 904         _media_svc_destroy_content_info(&content_info);
 905
 906         return ret;
 907 }
 908
 909 int media_svc_publish_noti(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)
 910 {
 911         return _media_svc_publish_noti(update_item, update_type, path, media_type, uuid, mime_type);
 912 }
 913
 914 int media_svc_get_pinyin(const char *src_str, char **pinyin_str)
 915 {
 916         media_svc_retvm_if(!STRING_VALID(src_str), MS_MEDIA_ERR_INVALID_PARAMETER, "String is NULL");
 917
 918         return _media_svc_get_pinyin_str(src_str, pinyin_str);
 919 }
 920
 921 int media_svc_check_pinyin_support(bool *support)
 922 {
 923         *support = _media_svc_check_pinyin_support();
 924
 925         return MS_MEDIA_ERR_NONE;
 926 }
 927
 928 int media_svc_set_storage_validity(MediaSvcHandle *handle, const char *storage_id, int validity, uid_t uid)
 929 {
 930         int ret = MS_MEDIA_ERR_NONE;
 931         sqlite3 * db_handle = (sqlite3 *)handle;
 932
 933         media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 934
 935         ret = _media_svc_update_storage_validity(storage_id, validity, uid);
 936         media_svc_retvm_if(ret != MS_MEDIA_ERR_NONE, ret, "update storage validity failed: %d", ret);
 937
 938         ret = _media_svc_update_media_view(db_handle, uid);
 939         media_svc_retvm_if(ret != MS_MEDIA_ERR_NONE, ret, "update media view failed : %d", ret);
 940
 941         return ret;
 942 }
 943
 944 int media_svc_get_storage_id(MediaSvcHandle *handle, const char *path, char *storage_id, uid_t uid)
 945 {
 946         int ret = MS_MEDIA_ERR_NONE;
 947         sqlite3 * db_handle = (sqlite3 *)handle;
 948
 949         media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 950         media_svc_retvm_if(path == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "path is NULL");
 951
 952         ret = _media_svc_get_storage_uuid(db_handle, path, storage_id, uid);
 953
 954         return ret;
 955 }
 956
 957 int media_svc_get_storage_list(MediaSvcHandle *handle, char ***storage_list, char ***storage_id_list, int *count)
 958 {
 959         sqlite3 * db_handle = (sqlite3 *)handle;
 960
 961         media_svc_debug_fenter();
 962
 963         media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 964         media_svc_retvm_if(count == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "count is NULL");
 965
 966         return _media_svc_get_all_storage(db_handle, storage_list, storage_id_list, count);
 967 }
 968
 969 int media_svc_generate_uuid(char **uuid)
 970 {
 971         char *gen_uuid = NULL;
 972         gen_uuid = _media_info_generate_uuid();
 973         media_svc_retvm_if(gen_uuid == NULL, MS_MEDIA_ERR_INTERNAL, "Fail to generate uuid");
 974
 975         *uuid = strdup(gen_uuid);
 976
 977         return MS_MEDIA_ERR_NONE;
 978 }
 979
 980 int media_svc_check_storage(MediaSvcHandle *handle, const char *storage_id, char **storage_path, int *validity, uid_t uid)
 981 {
 982         sqlite3 * db_handle = (sqlite3 *)handle;
 983
 984         media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 985         media_svc_retvm_if(storage_id == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "storage_id is NULL");
 986         media_svc_retvm_if(storage_path == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "storage_path is NULL");
 987         media_svc_retvm_if(validity == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "validity is NULL");
 988
 989         return _media_svc_check_storage(db_handle, storage_id, storage_path, validity, uid);
 990 }
 991
 992 int media_svc_update_storage(MediaSvcHandle *handle, const char *storage_id, const char *storage_path, uid_t uid)
 993 {
 994         sqlite3 * db_handle = (sqlite3 *)handle;
 995
 996         media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 997         media_svc_retvm_if(storage_id == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "storage_id is NULL");
 998         media_svc_retvm_if(storage_path == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "storage_path is NULL");
 999
1000         return _media_svc_update_storage_path(db_handle, storage_id, storage_path, uid);
1001 }
1002
1003 int media_svc_insert_storage(MediaSvcHandle *handle, const char *storage_id, const char *storage_path, ms_user_storage_type_e storage_type, uid_t uid)
1004 {
1005         int ret = MS_MEDIA_ERR_NONE;
1006         sqlite3 *db_handle = (sqlite3 *)handle;
1007
1008         media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
1009         media_svc_retvm_if(storage_id == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "storage_id is NULL");
1010         media_svc_retvm_if(storage_path == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "storage_path is NULL");
1011         media_svc_retvm_if(__media_svc_check_storage(storage_type) != TRUE, MS_MEDIA_ERR_INVALID_PARAMETER, "Invalid storage_type");
1012
1013         ret = _media_svc_append_storage(storage_id, storage_path, storage_type, uid);
1014         media_svc_retvm_if(ret != MS_MEDIA_ERR_NONE, ret, "append storage failed : %d", ret);
1015
1016         ret = _media_svc_create_media_table_with_id(storage_id, uid);
1017         media_svc_retvm_if(ret != MS_MEDIA_ERR_NONE, ret, "create media table failed : %d", ret);
1018
1019         ret = _media_svc_update_media_view(db_handle, uid);
1020         media_svc_retvm_if(ret != MS_MEDIA_ERR_NONE, ret, "update media view failed : %d", ret);
1021
1022         /* Remove external storage that validity is 0 */
1023         ret = _media_svc_delete_invalid_storage(db_handle, storage_type, uid);
1024         media_svc_retvm_if(ret != MS_MEDIA_ERR_NONE, ret, "Delete invalid storage failed : %d", ret);
1025
1026         return ret;
1027 }
1028
1029 int media_svc_insert_folder_begin(int data_cnt)
1030 {
1031         media_svc_debug("Transaction data count : [%d]", data_cnt);
1032
1033         media_svc_retvm_if(data_cnt < 1, MS_MEDIA_ERR_INVALID_PARAMETER, "data_cnt shuld be bigger than 1");
1034
1035         g_media_svc_insert_folder_data_cnt = data_cnt;
1036         g_media_svc_insert_folder_cur_data_cnt = 0;
1037
1038         return MS_MEDIA_ERR_NONE;
1039 }
1040
1041 int media_svc_insert_folder_end(uid_t uid)
1042 {
1043         int ret = MS_MEDIA_ERR_NONE;
1044
1045         media_svc_debug_fenter();
1046
1047         if (g_media_svc_insert_folder_cur_data_cnt > 0)
1048                 ret = _media_svc_list_query_do(MEDIA_SVC_QUERY_INSERT_FOLDER, uid);
1049
1050         g_media_svc_insert_folder_data_cnt = 1;
1051         g_media_svc_insert_folder_cur_data_cnt = 0;
1052
1053         return ret;
1054 }
1055
1056 int media_svc_insert_folder(MediaSvcHandle *handle, const char *storage_id, ms_user_storage_type_e storage_type, const char *path, uid_t uid)
1057 {
1058         int ret = MS_MEDIA_ERR_NONE;
1059         sqlite3 * db_handle = (sqlite3 *)handle;
1060         char folder_uuid[MEDIA_SVC_UUID_SIZE+1] = {0,};
1061
1062         media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
1063         media_svc_retvm_if(!STRING_VALID(storage_id), MS_MEDIA_ERR_INVALID_PARAMETER, "storage_id is NULL");
1064         media_svc_retvm_if(!STRING_VALID(path), MS_MEDIA_ERR_INVALID_PARAMETER, "path is NULL");
1065         media_svc_retvm_if(__media_svc_check_storage(storage_type) != TRUE, MS_MEDIA_ERR_INVALID_PARAMETER, "Invalid storage_type");
1066
1067         if (g_media_svc_insert_folder_data_cnt == 1) {
1068
1069                 ret = _media_svc_get_and_append_folder_id_by_folder_path(handle, storage_id, path, storage_type, folder_uuid, FALSE, uid);
1070
1071         } else if (g_media_svc_insert_folder_cur_data_cnt < (g_media_svc_insert_folder_data_cnt - 1)) {
1072
1073                 ret = _media_svc_get_and_append_folder_id_by_folder_path(handle, storage_id, path, storage_type, folder_uuid, TRUE, uid);
1074                 media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
1075
1076                 g_media_svc_insert_folder_cur_data_cnt++;
1077
1078         } else if (g_media_svc_insert_folder_cur_data_cnt == (g_media_svc_insert_folder_data_cnt - 1)) {
1079
1080                 ret = _media_svc_get_and_append_folder_id_by_folder_path(handle, storage_id, path, storage_type, folder_uuid, TRUE, uid);
1081                 media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
1082
1083                 ret = _media_svc_list_query_do(MEDIA_SVC_QUERY_INSERT_FOLDER, uid);
1084                 media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
1085
1086                 g_media_svc_insert_folder_cur_data_cnt = 0;
1087
1088         } else {
1089                 media_svc_error("Error in media_svc_set_insert_folder");
1090                 return MS_MEDIA_ERR_INTERNAL;
1091         }
1092
1093         return ret;
1094 }
1095
1096 int media_svc_delete_invalid_folder(const char *storage_id, int storage_type, uid_t uid)
1097 {
1098         int ret = MS_MEDIA_ERR_NONE;
1099
1100         ret = _media_svc_delete_invalid_folder(storage_id, storage_type, uid);
1101
1102         return ret;
1103 }
1104
1105 int media_svc_set_folder_validity(MediaSvcHandle *handle, const char *storage_id, const char *start_path, int validity, bool is_recursive, uid_t uid)
1106 {
1107         int ret = MS_MEDIA_ERR_NONE;
1108         sqlite3 * db_handle = (sqlite3 *)handle;
1109
1110         media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
1111
1112         ret = _media_svc_set_folder_validity(db_handle, storage_id, start_path, validity, is_recursive, uid);
1113
1114         return ret;
1115 }
1116
1117 int media_svc_check_folder_exist_by_path(MediaSvcHandle *handle, const char *storage_id, const char *folder_path)
1118 {
1119         int ret = MS_MEDIA_ERR_NONE;
1120         sqlite3 * db_handle = (sqlite3 *)handle;
1121         int count = -1;
1122
1123         media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
1124         media_svc_retvm_if(!STRING_VALID(storage_id), MS_MEDIA_ERR_INVALID_PARAMETER, "storage_id is NULL");
1125         media_svc_retvm_if(!STRING_VALID(folder_path), MS_MEDIA_ERR_INVALID_PARAMETER, "Path is NULL");
1126
1127         ret = _media_svc_count_folder_with_path(db_handle, storage_id, folder_path, &count);
1128         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
1129
1130         if (count > 0) {
1131                 media_svc_debug("item is exist in database");
1132                 return MS_MEDIA_ERR_NONE;
1133         } else {
1134                 media_svc_debug("item is not exist in database");
1135                 return MS_MEDIA_ERR_DB_NO_RECORD;
1136         }
1137
1138         return MS_MEDIA_ERR_NONE;
1139 }
1140
1141 int media_svc_get_folder_id(MediaSvcHandle *handle, const char *storage_id, const char *path, char *folder_id)
1142 {
1143         int ret = MS_MEDIA_ERR_NONE;
1144         sqlite3 * db_handle = (sqlite3 *)handle;
1145
1146         media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
1147         media_svc_retvm_if(path == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "path is NULL");
1148
1149         ret = _media_svc_get_folder_uuid(db_handle, storage_id, path, folder_id);
1150
1151         return ret;
1152 }
1153
1154 int media_svc_append_query(const char *query, uid_t uid)
1155 {
1156         int ret = MS_MEDIA_ERR_NONE;
1157
1158         media_svc_retvm_if(query == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "query is NULL");
1159
1160         ret = _media_svc_append_query_list(query, uid);
1161
1162         return ret;
1163 }
1164
1165 int media_svc_send_query(uid_t uid)
1166 {
1167         int ret = MS_MEDIA_ERR_NONE;
1168
1169         ret = _media_svc_list_query_do(MEDIA_SVC_QUERY_UPDATE_COMMON, uid);
1170
1171         return ret;
1172 }
1173
1174 int media_svc_get_media_type(const char *path, int *mediatype)
1175 {
1176         media_svc_retvm_if(path == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "path is NULL");
1177
1178         return _media_svc_get_media_type(path, mediatype);
1179 }
1180
1181 int media_svc_create_thumbnail(const char *storage_id, const char *file_path, int media_type, uid_t uid, char **thumbnail_path)
1182 {
1183         int ret = MS_MEDIA_ERR_NONE;
1184         char thumb_path[MEDIA_SVC_PATHNAME_SIZE + 1] = { 0, };
1185         char *sql = NULL;
1186
1187         // 1. Check media type
1188         if (media_type != MS_MEDIA_IMAGE && media_type != MS_MEDIA_VIDEO)
1189                 return MS_MEDIA_ERR_UNSUPPORTED_CONTENT;
1190
1191         // 2. try to create thumbnail
1192         ret = _media_svc_create_thumbnail(file_path, thumb_path, MEDIA_SVC_PATHNAME_SIZE, media_type, uid);
1193         if (ret != MS_MEDIA_ERR_NONE) {
1194                 media_svc_error("Failed to create thumbnail [%d]", ret);
1195                 if (ret == MS_MEDIA_ERR_UNSUPPORTED_CONTENT)
1196                         return ret;
1197         }
1198
1199         // 3. Update creation result to media db
1200         sql = sqlite3_mprintf("UPDATE '%q' SET thumbnail_path='%q' WHERE path='%q';", storage_id, thumb_path, file_path);
1201
1202         ret = _media_svc_sql_query(sql, uid);
1203         SQLITE3_SAFE_FREE(sql);
1204         if (ret != MS_MEDIA_ERR_NONE) {
1205                 media_svc_error("Failed to update media db [%d]", ret);
1206                 *thumbnail_path = g_strdup("");
1207         } else {
1208                 *thumbnail_path = g_strdup(thumb_path);
1209         }
1210
1211         return ret;
1212 }