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