plugin/media-content-plugin.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 <sys/stat.h>
  24 #include <mm_file.h>
  25 #include <media-thumbnail.h>
  26 #include <media-util.h>
  27 #include "media-svc.h"
  28 #include "media-svc-util.h"
  29
  30 #define MEDIA_SVC_PLUGIN_ERROR_NONE             0
  31 #define MEDIA_SVC_PLUGIN_ERROR                  -1
  32
  33 #define STRING_VALID(str)       \
  34         ((str != NULL && strlen(str) > 0) ? TRUE : FALSE)
  35 #define STORAGE_VALID(storage)\
  36         (((storage == MEDIA_SVC_STORAGE_INTERNAL) || (storage == MEDIA_SVC_STORAGE_EXTERNAL) || (storage == MEDIA_SVC_STORAGE_EXTERNAL_USB)) ? TRUE : FALSE)
  37
  38
  39 typedef enum {
  40         ERR_HANDLE = 1,
  41         ERR_FILE_PATH,
  42         ERR_FOLDER_PATH,
  43         ERR_MIME_TYPE,
  44         ERR_NOT_MEDIAFILE,
  45         ERR_STORAGE_TYPE,
  46         ERR_CHECK_ITEM,
  47         ERR_MAX,
  48 } media_svc_error_type_e;
  49
  50 static void __set_error_message(int err_type, char **err_msg);
  51
  52 static void __set_error_message(int err_type, char **err_msg)
  53 {
  54         if (err_msg)
  55                 *err_msg = NULL;
  56         else
  57                 return;
  58
  59         if (err_type == ERR_HANDLE)
  60                 *err_msg = strdup("invalid handle");
  61         else if (err_type == ERR_FILE_PATH)
  62                 *err_msg = strdup("invalid file path");
  63         else if (err_type == ERR_FOLDER_PATH)
  64                 *err_msg = strdup("invalid folder path");
  65         else if (err_type == ERR_MIME_TYPE)
  66                 *err_msg = strdup("invalid mime type");
  67         else if (err_type == ERR_NOT_MEDIAFILE)
  68                 *err_msg = strdup("not media content");
  69         else if (err_type == ERR_STORAGE_TYPE)
  70                 *err_msg = strdup("invalid storage type");
  71         else if (err_type == ERR_CHECK_ITEM)
  72                 *err_msg = strdup("item does not exist");
  73         else if (err_type == MS_MEDIA_ERR_DB_CONNECT_FAIL)
  74                 *err_msg = strdup("DB connect error");
  75         else if (err_type == MS_MEDIA_ERR_DB_DISCONNECT_FAIL)
  76                 *err_msg = strdup("DB disconnect error");
  77         else if (err_type == MS_MEDIA_ERR_INVALID_PARAMETER)
  78                 *err_msg = strdup("invalid parameter");
  79         else if (err_type == MS_MEDIA_ERR_DB_INTERNAL)
  80                 *err_msg = strdup("DB internal error");
  81         else if (err_type == MS_MEDIA_ERR_DB_NO_RECORD)
  82                 *err_msg = strdup("not found in DB");
  83         else if (err_type == MS_MEDIA_ERR_INTERNAL)
  84                 *err_msg = strdup("media service internal error");
  85         else if (err_type == MS_MEDIA_ERR_DB_CORRUPT)
  86                 *err_msg = strdup("DB corrupt error");
  87         else
  88                 *err_msg = strdup("error unknown");
  89
  90         return;
  91 }
  92
  93 int connect_db(void **handle, uid_t uid, char **err_msg)
  94 {
  95         int ret = media_svc_connect(handle, uid, true);
  96
  97         if (ret < 0) {
  98                 __set_error_message(ret, err_msg);
  99                 return MEDIA_SVC_PLUGIN_ERROR;
 100         }
 101
 102         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 103 }
 104
 105 int disconnect_db(void *handle, char **err_msg)
 106 {
 107         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 108
 109         if (handle == NULL) {
 110                 __set_error_message(ERR_HANDLE, err_msg);
 111                 return MEDIA_SVC_PLUGIN_ERROR;
 112         }
 113
 114         ret = media_svc_disconnect(handle);
 115         if (ret < 0) {
 116                 __set_error_message(ret, err_msg);
 117                 return MEDIA_SVC_PLUGIN_ERROR;
 118         }
 119
 120         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 121 }
 122
 123 int check_item_exist(void *handle, const char *storage_id, const char *file_path, bool *modified, char **err_msg)
 124 {
 125         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 126         *modified = TRUE;
 127
 128         if (handle == NULL) {
 129                 __set_error_message(ERR_HANDLE, err_msg);
 130                 return MEDIA_SVC_PLUGIN_ERROR;
 131         }
 132
 133         if (!STRING_VALID(file_path)) {
 134                 __set_error_message(ERR_FILE_PATH, err_msg);
 135                 return MEDIA_SVC_PLUGIN_ERROR;
 136         }
 137
 138         time_t modified_time = 0;
 139         unsigned long long file_size = 0;
 140         struct stat st;
 141
 142         ret = media_svc_get_file_info(handle, storage_id, file_path, &modified_time, &file_size);
 143         if (ret == MS_MEDIA_ERR_NONE) {
 144                 memset(&st, 0, sizeof(struct stat));
 145                 if (stat(file_path, &st) == 0) {
 146                         if ((st.st_mtime != modified_time) || (st.st_size != file_size))
 147                                 *modified = TRUE;
 148                         else
 149                                 *modified = FALSE;
 150                 }
 151
 152                 return MEDIA_SVC_PLUGIN_ERROR_NONE;     /*exist */
 153         }
 154
 155         __set_error_message(ERR_CHECK_ITEM, err_msg);
 156
 157         return MEDIA_SVC_PLUGIN_ERROR;          /*not exist */
 158 }
 159
 160 int insert_item_begin(void *handle, int item_cnt, int with_noti, int from_pid, char **err_msg)
 161 {
 162         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 163
 164         ret = media_svc_insert_item_begin(item_cnt, with_noti, from_pid);
 165         if (ret < 0) {
 166                 __set_error_message(ret, err_msg);
 167                 return MEDIA_SVC_PLUGIN_ERROR;
 168         }
 169
 170         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 171 }
 172
 173 int insert_item_end(void *handle, uid_t uid, char **err_msg)
 174 {
 175         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 176
 177         ret = media_svc_insert_item_end(uid);
 178         if (ret < 0) {
 179                 __set_error_message(ret, err_msg);
 180                 return MEDIA_SVC_PLUGIN_ERROR;
 181         }
 182
 183         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 184 }
 185
 186 int insert_item(void *handle, const char *storage_id, const char *file_path, int storage_type, uid_t uid, char **err_msg)
 187 {
 188         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 189
 190         if (handle == NULL) {
 191                 __set_error_message(ERR_HANDLE, err_msg);
 192                 return MEDIA_SVC_PLUGIN_ERROR;
 193         }
 194
 195         if (!STRING_VALID(file_path)) {
 196                 __set_error_message(ERR_FILE_PATH, err_msg);
 197                 return MEDIA_SVC_PLUGIN_ERROR;
 198         }
 199
 200         if (!STORAGE_VALID(storage_type)) {
 201                 __set_error_message(ERR_STORAGE_TYPE, err_msg);
 202                 return MEDIA_SVC_PLUGIN_ERROR;
 203         }
 204
 205         ret = media_svc_insert_item_bulk(handle, storage_id, storage_type, file_path, FALSE, uid);
 206         if (ret < 0) {
 207                 __set_error_message(ret, err_msg);
 208                 return MEDIA_SVC_PLUGIN_ERROR;
 209         }
 210
 211         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 212 }
 213
 214 int insert_item_immediately(void *handle, const char *storage_id, const char *file_path, int storage_type, uid_t uid, char **err_msg)
 215 {
 216         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 217
 218         if (handle == NULL) {
 219                 __set_error_message(ERR_HANDLE, err_msg);
 220                 return MEDIA_SVC_PLUGIN_ERROR;
 221         }
 222
 223         if (!STRING_VALID(file_path)) {
 224                 __set_error_message(ERR_FILE_PATH, err_msg);
 225                 return MEDIA_SVC_PLUGIN_ERROR;
 226         }
 227
 228         if (!STORAGE_VALID(storage_type)) {
 229                 __set_error_message(ERR_STORAGE_TYPE, err_msg);
 230                 return MEDIA_SVC_PLUGIN_ERROR;
 231         }
 232
 233         ret = media_svc_insert_item_immediately(handle, storage_id, storage_type, file_path, uid);
 234         if (ret < 0) {
 235                 __set_error_message(ret, err_msg);
 236                 return MEDIA_SVC_PLUGIN_ERROR;
 237         }
 238
 239         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 240 }
 241
 242 int insert_burst_item(void *handle, const char *storage_id, const char *file_path, int storage_type, uid_t uid, char **err_msg)
 243 {
 244         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 245
 246         if (handle == NULL) {
 247                 __set_error_message(ERR_HANDLE, err_msg);
 248                 return MEDIA_SVC_PLUGIN_ERROR;
 249         }
 250
 251         if (!STRING_VALID(file_path)) {
 252                 __set_error_message(ERR_FILE_PATH, err_msg);
 253                 return MEDIA_SVC_PLUGIN_ERROR;
 254         }
 255
 256         if (!STORAGE_VALID(storage_type)) {
 257                 __set_error_message(ERR_STORAGE_TYPE, err_msg);
 258                 return MEDIA_SVC_PLUGIN_ERROR;
 259         }
 260
 261         ret = media_svc_insert_item_bulk(handle, storage_id, storage_type, file_path, TRUE, uid);
 262         if (ret < 0) {
 263                 __set_error_message(ret, err_msg);
 264                 return MEDIA_SVC_PLUGIN_ERROR;
 265         }
 266
 267         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 268 }
 269
 270 int set_all_storage_items_validity(void *handle, const char *storage_id, int storage_type, int validity, uid_t uid, char **err_msg)
 271 {
 272         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 273
 274         if (!STORAGE_VALID(storage_type)) {
 275                 __set_error_message(ERR_STORAGE_TYPE, err_msg);
 276                 return MEDIA_SVC_PLUGIN_ERROR;
 277         }
 278
 279         ret = media_svc_set_all_storage_items_validity(storage_id, storage_type, validity, uid);
 280         if (ret < 0) {
 281                 __set_error_message(ret, err_msg);
 282                 return MEDIA_SVC_PLUGIN_ERROR;
 283         }
 284
 285         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 286 }
 287
 288 int set_folder_item_validity(void *handle, const char *storage_id, const char *folder_path, int validity, int recursive, uid_t uid, char **err_msg)
 289 {
 290         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 291
 292         if (handle == NULL) {
 293                 __set_error_message(ERR_HANDLE, err_msg);
 294                 return MEDIA_SVC_PLUGIN_ERROR;
 295         }
 296
 297         if (!STRING_VALID(folder_path)) {
 298                 __set_error_message(ERR_FOLDER_PATH, err_msg);
 299                 return MEDIA_SVC_PLUGIN_ERROR;
 300         }
 301
 302         ret = media_svc_set_folder_items_validity(handle, storage_id, folder_path, validity, recursive, uid);
 303         if (ret < 0) {
 304                 __set_error_message(ret, err_msg);
 305                 return MEDIA_SVC_PLUGIN_ERROR;
 306         }
 307
 308         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 309 }
 310
 311 int set_item_validity_begin(void *handle, int item_cnt, char **err_msg)
 312 {
 313         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 314
 315         ret = media_svc_set_item_validity_begin(item_cnt);
 316         if (ret < 0) {
 317                 __set_error_message(ret, err_msg);
 318                 return MEDIA_SVC_PLUGIN_ERROR;
 319         }
 320
 321         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 322 }
 323
 324 int set_item_validity_end(void *handle, uid_t uid, char **err_msg)
 325 {
 326         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 327
 328         ret = media_svc_set_item_validity_end(uid);
 329         if (ret < 0) {
 330                 __set_error_message(ret, err_msg);
 331                 return MEDIA_SVC_PLUGIN_ERROR;
 332         }
 333
 334         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 335 }
 336
 337 int set_item_validity(void *handle, const char *storage_id, const char *file_path, int storage_type, int validity, uid_t uid, char **err_msg)
 338 {
 339         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 340
 341         if (!STRING_VALID(file_path)) {
 342                 __set_error_message(ERR_FILE_PATH, err_msg);
 343                 return MEDIA_SVC_PLUGIN_ERROR;
 344         }
 345
 346         ret = media_svc_set_item_validity(storage_id, file_path, validity, uid);
 347
 348         if (ret < 0) {
 349                 __set_error_message(ret, err_msg);
 350                 return MEDIA_SVC_PLUGIN_ERROR;
 351         }
 352
 353         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 354 }
 355
 356 int delete_item(void *handle, const char *storage_id, const char *file_path, uid_t uid, char **err_msg)
 357 {
 358         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 359
 360         if (handle == NULL) {
 361                 __set_error_message(ERR_HANDLE, err_msg);
 362                 return MEDIA_SVC_PLUGIN_ERROR;
 363         }
 364
 365         if (!STRING_VALID(file_path)) {
 366                 __set_error_message(ERR_FILE_PATH, err_msg);
 367                 return MEDIA_SVC_PLUGIN_ERROR;
 368         }
 369
 370         ret = media_svc_check_item_exist_by_path(handle, storage_id, file_path);
 371         if (ret == 0) {
 372                 ret = media_svc_delete_item_by_path(handle, storage_id, file_path, uid);
 373
 374                 if (ret < 0) {
 375                         __set_error_message(ret, err_msg);
 376                         return MEDIA_SVC_PLUGIN_ERROR;
 377                 } else
 378                         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 379         }
 380
 381         __set_error_message(ERR_CHECK_ITEM, err_msg);   /*not exist in DB so can't delete item. */
 382         return MEDIA_SVC_PLUGIN_ERROR;
 383 }
 384
 385 int delete_all_items_in_storage(void *handle, const char *storage_id, int storage_type, uid_t uid, char **err_msg)
 386 {
 387         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 388
 389         if (!STORAGE_VALID(storage_type)) {
 390                 __set_error_message(ERR_STORAGE_TYPE, err_msg);
 391                 return MEDIA_SVC_PLUGIN_ERROR;
 392         }
 393
 394         ret = media_svc_delete_all_items_in_storage(storage_id, storage_type, uid);
 395         if (ret < 0) {
 396                 __set_error_message(ret, err_msg);
 397                 return MEDIA_SVC_PLUGIN_ERROR;
 398         }
 399
 400         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 401 }
 402
 403 int delete_all_invalid_items_in_storage(void *handle, const char *storage_id, int storage_type, uid_t uid, char **err_msg)
 404 {
 405         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 406
 407         if (handle == NULL) {
 408                 __set_error_message(ERR_HANDLE, err_msg);
 409                 return MEDIA_SVC_PLUGIN_ERROR;
 410         }
 411
 412         if (!STORAGE_VALID(storage_type)) {
 413                 __set_error_message(ERR_STORAGE_TYPE, err_msg);
 414                 return MEDIA_SVC_PLUGIN_ERROR;
 415         }
 416
 417         ret = media_svc_delete_invalid_items_in_storage(handle, storage_id, storage_type, uid);
 418         if (ret < 0) {
 419                 __set_error_message(ret, err_msg);
 420                 return MEDIA_SVC_PLUGIN_ERROR;
 421         }
 422
 423         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 424 }
 425
 426 int delete_all_invalid_items_in_folder(void *handle, const char *storage_id, const char *folder_path, bool is_recursve, uid_t uid, char **err_msg)
 427 {
 428         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 429
 430         if (handle == NULL) {
 431                 __set_error_message(ERR_HANDLE, err_msg);
 432                 return MEDIA_SVC_PLUGIN_ERROR;
 433         }
 434
 435         if (!STRING_VALID(folder_path)) {
 436                 __set_error_message(ERR_FOLDER_PATH, err_msg);
 437                 return MEDIA_SVC_PLUGIN_ERROR;
 438         }
 439
 440         ret = media_svc_delete_invalid_items_in_folder(handle, storage_id, folder_path, is_recursve, uid);
 441         if (ret < 0) {
 442                 __set_error_message(ret, err_msg);
 443                 return MEDIA_SVC_PLUGIN_ERROR;
 444         }
 445
 446         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 447 }
 448
 449
 450 int update_begin(void)
 451 {
 452         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 453 }
 454
 455 int update_end(uid_t uid)
 456 {
 457 #if 0
 458         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 459
 460         ret = thumbnail_request_extract_all_thumbs(uid);
 461         if (ret < 0)
 462                 return MEDIA_SVC_PLUGIN_ERROR;
 463
 464         ret = dcm_svc_request_extract_all(uid);
 465         if (ret < 0)
 466                 return MEDIA_SVC_PLUGIN_ERROR;
 467 #endif
 468         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 469 }
 470
 471 int send_dir_update_noti(void *handle, const char *storage_id, const char *dir_path, const char *folder_id, int update_type, int pid, char **err_msg)
 472 {
 473         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 474
 475         if (!STRING_VALID(dir_path)) {
 476                 __set_error_message(ERR_FOLDER_PATH, err_msg);
 477                 return MEDIA_SVC_PLUGIN_ERROR;
 478         }
 479
 480         ret = media_svc_send_dir_update_noti(handle, storage_id, dir_path, folder_id, (media_item_update_type_e)update_type, pid);
 481         if (ret < 0) {
 482                 __set_error_message(ret, err_msg);
 483                 return MEDIA_SVC_PLUGIN_ERROR;
 484         }
 485
 486         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 487 }
 488
 489 int count_delete_items_in_folder(void *handle, const char *storage_id, const char *folder_path, int *count, char **err_msg)
 490 {
 491         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 492
 493         if (handle == NULL) {
 494                 __set_error_message(ERR_HANDLE, err_msg);
 495                 return MEDIA_SVC_PLUGIN_ERROR;
 496         }
 497
 498         if (count == NULL) {
 499                 __set_error_message(ERR_HANDLE, err_msg);
 500                 return MEDIA_SVC_PLUGIN_ERROR;
 501         }
 502
 503         if (!STRING_VALID(folder_path)) {
 504                 __set_error_message(ERR_FOLDER_PATH, err_msg);
 505                 return MEDIA_SVC_PLUGIN_ERROR;
 506         }
 507
 508         ret = media_svc_count_invalid_items_in_folder(handle, storage_id, folder_path, count);
 509         if (ret < 0) {
 510                 __set_error_message(ret, err_msg);
 511                 return MEDIA_SVC_PLUGIN_ERROR;
 512         }
 513
 514         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 515 }
 516
 517 int check_db(void *handle, uid_t uid, char **err_msg)
 518 {
 519         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 520         int user_version = -1;
 521
 522         ret = media_svc_get_user_version(handle, &user_version);
 523         if (ret < 0) {
 524                 __set_error_message(ret, err_msg);
 525                 return MEDIA_SVC_PLUGIN_ERROR;
 526         }
 527
 528         if (user_version == 0) {
 529                 /*check db schema*/
 530                 ret = media_svc_create_table(uid);
 531                 if (ret < 0) {
 532                         __set_error_message(ret, err_msg);
 533                         return MEDIA_SVC_PLUGIN_ERROR;
 534                 }
 535         } else {
 536                 /*check db version*/
 537                 ret = media_svc_check_db_upgrade(handle, user_version, uid);
 538                 if (ret < 0) {
 539                         __set_error_message(ret, err_msg);
 540                         return MEDIA_SVC_PLUGIN_ERROR;
 541                 }
 542         }
 543
 544         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 545 }
 546
 547 int check_db_corrupt(void *handle, char **err_msg)
 548 {
 549         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 550
 551         /*check db version*/
 552         ret = media_svc_check_db_corrupt(handle);
 553         if (ret < 0) {
 554                 __set_error_message(ret, err_msg);
 555                 return MEDIA_SVC_PLUGIN_ERROR;
 556         }
 557
 558         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 559 }
 560
 561 int get_folder_list(void *handle, const char *storage_id, char *start_path, char ***folder_list, int **modified_time_list, int **item_num_list, int *count, char **err_msg)
 562 {
 563         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 564
 565         if (handle == NULL) {
 566                 __set_error_message(ERR_HANDLE, err_msg);
 567                 return MEDIA_SVC_PLUGIN_ERROR;
 568         }
 569
 570         if (count == NULL) {
 571                 __set_error_message(ERR_HANDLE, err_msg);
 572                 return MEDIA_SVC_PLUGIN_ERROR;
 573         }
 574
 575         ret = media_svc_get_folder_list(handle, start_path, folder_list, (time_t **)modified_time_list, item_num_list, count);
 576         if (ret < 0) {
 577                 __set_error_message(ret, err_msg);
 578                 return MEDIA_SVC_PLUGIN_ERROR;
 579         }
 580
 581         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 582 }
 583
 584 int update_folder_time(void *handle, const char *storage_id, char *folder_path, uid_t uid, char **err_msg)
 585 {
 586         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 587
 588         if (handle == NULL) {
 589                 __set_error_message(ERR_HANDLE, err_msg);
 590                 return MEDIA_SVC_PLUGIN_ERROR;
 591         }
 592
 593         if (folder_path == NULL) {
 594                 __set_error_message(ERR_HANDLE, err_msg);
 595                 return MEDIA_SVC_PLUGIN_ERROR;
 596         }
 597
 598         ret = media_svc_update_folder_time(handle, storage_id, folder_path, uid);
 599         if (ret < 0) {
 600                 __set_error_message(ret, err_msg);
 601                 return MEDIA_SVC_PLUGIN_ERROR;
 602         }
 603
 604         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 605 }
 606
 607 int get_uuid(void * handle, char **uuid, char **err_msg)
 608 {
 609         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 610
 611         ret = media_svc_generate_uuid(uuid);
 612         if (ret < 0) {
 613                 __set_error_message(ret, err_msg);
 614                 return MEDIA_SVC_PLUGIN_ERROR;
 615         }
 616
 617         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 618 }
 619
 620 int get_mmc_info(void * handle, char **storage_name, char **storage_path, int *validity, bool *info_exist, char **err_msg)
 621 {
 622         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 623
 624         if (handle == NULL) {
 625                 __set_error_message(ERR_HANDLE, err_msg);
 626                 return MEDIA_SVC_PLUGIN_ERROR;
 627         }
 628
 629         ret = media_svc_get_mmc_info(handle, storage_name, storage_path, validity, info_exist);
 630         if (ret < 0) {
 631                 __set_error_message(MS_MEDIA_ERR_DB_NO_RECORD, err_msg);
 632                 return MEDIA_SVC_PLUGIN_ERROR;
 633         }
 634
 635         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 636 }
 637
 638 int check_storage(void * handle, const char *storage_id, const char *storage_name, char **storage_path, int *validity, char **err_msg)
 639 {
 640         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 641
 642         if (handle == NULL) {
 643                 __set_error_message(ERR_HANDLE, err_msg);
 644                 return MEDIA_SVC_PLUGIN_ERROR;
 645         }
 646
 647         ret = media_svc_check_storage(handle, storage_id, storage_name, storage_path, validity);
 648         if (ret < 0) {
 649                 __set_error_message(ret, err_msg);
 650                 return MEDIA_SVC_PLUGIN_ERROR;
 651         }
 652
 653         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 654 }
 655
 656 int insert_storage(void *handle, const char *storage_id, int storage_type, const char *storage_name, const char *storage_path, uid_t uid, char **err_msg)
 657 {
 658         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 659
 660         if (handle == NULL) {
 661                 __set_error_message(ERR_HANDLE, err_msg);
 662                 return MEDIA_SVC_PLUGIN_ERROR;
 663         }
 664
 665         ret = media_svc_insert_storage(handle, storage_id, storage_name, storage_path, NULL, storage_type, uid);
 666         if (ret < 0) {
 667                 __set_error_message(ret, err_msg);
 668                 return MEDIA_SVC_PLUGIN_ERROR;
 669         }
 670
 671         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 672 }
 673
 674 int update_storage(void *handle, const char *storage_id, const char *storage_path, uid_t uid, char **err_msg)
 675 {
 676         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 677
 678         if (handle == NULL) {
 679                 __set_error_message(ERR_HANDLE, err_msg);
 680                 return MEDIA_SVC_PLUGIN_ERROR;
 681         }
 682
 683         ret = media_svc_update_storage(handle, storage_id, storage_path, uid);
 684         if (ret < 0) {
 685                 __set_error_message(ret, err_msg);
 686                 return MEDIA_SVC_PLUGIN_ERROR;
 687         }
 688
 689         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 690 }
 691
 692 int delete_storage(void * handle, const char *storage_id, const char *storage_name, uid_t uid, char **err_msg)
 693 {
 694         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 695
 696         if (handle == NULL) {
 697                 __set_error_message(ERR_HANDLE, err_msg);
 698                 return MEDIA_SVC_PLUGIN_ERROR;
 699         }
 700
 701         ret = media_svc_delete_storage(handle, storage_id, storage_name, uid);
 702         if (ret < 0) {
 703                 __set_error_message(ret, err_msg);
 704                 return MEDIA_SVC_PLUGIN_ERROR;
 705         }
 706
 707         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 708 }
 709
 710 int set_storage_validity(void * handle, const char *storage_id, int validity, uid_t uid, char **err_msg)
 711 {
 712         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 713
 714         if (handle == NULL) {
 715                 __set_error_message(ERR_HANDLE, err_msg);
 716                 return MEDIA_SVC_PLUGIN_ERROR;
 717         }
 718
 719         ret = media_svc_set_storage_validity(handle, storage_id, validity, uid);
 720         if (ret < 0) {
 721                 __set_error_message(ret, err_msg);
 722                 return MEDIA_SVC_PLUGIN_ERROR;
 723         }
 724
 725         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 726 }
 727
 728 int set_all_storage_validity(void * handle, int validity, uid_t uid, char **err_msg)
 729 {
 730         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 731
 732         if (handle == NULL) {
 733                 __set_error_message(ERR_HANDLE, err_msg);
 734                 return MEDIA_SVC_PLUGIN_ERROR;
 735         }
 736
 737         ret = media_svc_set_storage_validity(handle, NULL, validity, uid);
 738         if (ret < 0) {
 739                 __set_error_message(ret, err_msg);
 740                 return MEDIA_SVC_PLUGIN_ERROR;
 741         }
 742
 743         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 744 }
 745
 746 int get_storage_id(void * handle, const char *path, char *storage_id, uid_t uid, char **err_msg)
 747 {
 748         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 749
 750         if (handle == NULL) {
 751                 __set_error_message(ERR_HANDLE, err_msg);
 752                 return MEDIA_SVC_PLUGIN_ERROR;
 753         }
 754
 755         ret = media_svc_get_storage_id(handle, path, storage_id, uid);
 756         if (ret < 0) {
 757                 __set_error_message(ret, err_msg);
 758                 return MEDIA_SVC_PLUGIN_ERROR;
 759         }
 760
 761         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 762 }
 763
 764 int get_storage_scan_status(void * handle, const char *storage_id, int *status, char **err_msg)
 765 {
 766         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 767         media_svc_scan_status_type_e storage_status = 0;
 768
 769         if (handle == NULL) {
 770                 __set_error_message(ERR_HANDLE, err_msg);
 771                 return MEDIA_SVC_PLUGIN_ERROR;
 772         }
 773
 774         ret = media_svc_get_storage_scan_status(handle, storage_id, &storage_status);
 775         if (ret < 0) {
 776                 __set_error_message(ret, err_msg);
 777                 return MEDIA_SVC_PLUGIN_ERROR;
 778         }
 779
 780         *status = storage_status;
 781
 782         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 783 }
 784
 785 int set_storage_scan_status(void *handle, const char *storage_id, int status, uid_t uid, char **err_msg)
 786 {
 787         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 788         media_svc_scan_status_type_e storage_status = status;
 789
 790         ret = media_svc_set_storage_scan_status(storage_id, storage_status, uid);
 791         if (ret < 0) {
 792                 __set_error_message(ret, err_msg);
 793                 return MEDIA_SVC_PLUGIN_ERROR;
 794         }
 795
 796         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 797 }
 798
 799 int get_storage_list(void *handle, char ***storage_list, char ***storage_id_list, int **scan_status_list, int *count, char **err_msg)
 800 {
 801         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 802
 803         if (handle == NULL) {
 804                 __set_error_message(ERR_HANDLE, err_msg);
 805                 return MEDIA_SVC_PLUGIN_ERROR;
 806         }
 807
 808         if (count == NULL) {
 809                 __set_error_message(ERR_HANDLE, err_msg);
 810                 return MEDIA_SVC_PLUGIN_ERROR;
 811         }
 812
 813         ret = media_svc_get_storage_list(handle, storage_list, storage_id_list, scan_status_list, count);
 814         if (ret < 0) {
 815                 __set_error_message(ret, err_msg);
 816                 return MEDIA_SVC_PLUGIN_ERROR;
 817         }
 818
 819         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 820 }
 821
 822 int update_item_begin(void *handle, int item_cnt, char **err_msg)
 823 {
 824         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 825
 826         ret = media_svc_update_item_begin(item_cnt);
 827         if (ret < 0) {
 828                 __set_error_message(ret, err_msg);
 829                 return MEDIA_SVC_PLUGIN_ERROR;
 830         }
 831
 832         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 833 }
 834
 835 int update_item_end(void *handle, uid_t uid, char **err_msg)
 836 {
 837         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 838
 839         ret = media_svc_update_item_end(uid);
 840         if (ret < 0) {
 841                 __set_error_message(ret, err_msg);
 842                 return MEDIA_SVC_PLUGIN_ERROR;
 843         }
 844
 845         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 846 }
 847
 848 int update_item_meta(void *handle, const char *file_path, const char *storage_id, int storage_type, uid_t uid, char **err_msg)
 849 {
 850         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 851
 852         if (handle == NULL) {
 853                 __set_error_message(ERR_HANDLE, err_msg);
 854                 return MEDIA_SVC_PLUGIN_ERROR;
 855         }
 856
 857         if (file_path == NULL) {
 858                 __set_error_message(ERR_HANDLE, err_msg);
 859                 return MEDIA_SVC_PLUGIN_ERROR;
 860         }
 861
 862         if (storage_id == NULL) {
 863                 __set_error_message(ERR_HANDLE, err_msg);
 864                 return MEDIA_SVC_PLUGIN_ERROR;
 865         }
 866
 867         ret = media_svc_update_item_meta(handle, file_path, storage_id, storage_type, uid);
 868         if (ret < 0) {
 869                 __set_error_message(ret, err_msg);
 870                 return MEDIA_SVC_PLUGIN_ERROR;
 871         }
 872
 873         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 874 }
 875
 876 int insert_item_scan(void * handle, const char *storage_id, const char *file_path, int storage_type, uid_t uid, char **err_msg)
 877 {
 878         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 879
 880         if (handle == NULL) {
 881                 __set_error_message(ERR_HANDLE, err_msg);
 882                 return MEDIA_SVC_PLUGIN_ERROR;
 883         }
 884
 885         if (!STRING_VALID(file_path)) {
 886                 __set_error_message(ERR_FILE_PATH, err_msg);
 887                 return MEDIA_SVC_PLUGIN_ERROR;
 888         }
 889
 890         if (!STORAGE_VALID(storage_type)) {
 891                 __set_error_message(ERR_STORAGE_TYPE, err_msg);
 892                 return MEDIA_SVC_PLUGIN_ERROR;
 893         }
 894
 895         ret = media_svc_insert_item_pass1(handle, storage_id, storage_type, file_path, FALSE, uid);
 896         if (ret < 0) {
 897                 __set_error_message(ret, err_msg);
 898                 return MEDIA_SVC_PLUGIN_ERROR;
 899         }
 900
 901         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 902 }
 903
 904 int update_item_extract(void * handle, const char *storage_id, int storage_type, int scan_type, uid_t uid, const char *path, int burst, char **err_msg)
 905 {
 906         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 907
 908         if (handle == NULL) {
 909                 __set_error_message(ERR_HANDLE, err_msg);
 910                 return MEDIA_SVC_PLUGIN_ERROR;
 911         }
 912
 913         if (!STORAGE_VALID(storage_type)) {
 914                 __set_error_message(ERR_STORAGE_TYPE, err_msg);
 915                 return MEDIA_SVC_PLUGIN_ERROR;
 916         }
 917
 918         ret = media_svc_insert_item_pass2(handle, storage_id, storage_type, scan_type, path, burst, uid);
 919         if (ret < 0) {
 920                 __set_error_message(ret, err_msg);
 921                 return MEDIA_SVC_PLUGIN_ERROR;
 922         }
 923
 924         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 925 }
 926
 927 int get_extract_list(void* handle, const char* storage_id, int storage_type, int scan_type, const char* path, int burst, uid_t uid, void* array, char** err_msg)
 928 {
 929 #if 0
 930         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 931
 932         if (handle == NULL) {
 933                 __set_error_message(ERR_HANDLE, err_msg);
 934                 return MEDIA_SVC_PLUGIN_ERROR;
 935         }
 936
 937         if (!STORAGE_VALID(storage_type)) {
 938                 __set_error_message(ERR_STORAGE_TYPE, err_msg);
 939                 return MEDIA_SVC_PLUGIN_ERROR;
 940         }
 941
 942         ret = media_svc_pass2_get_extract_list(handle, storage_id, storage_type, scan_type, path, burst, uid, array);
 943         if (ret < 0) {
 944                 __set_error_message(ret, err_msg);
 945                 return MEDIA_SVC_PLUGIN_ERROR;
 946         }
 947 #endif
 948         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 949 }
 950
 951 int update_one_extract_item(void* handle, const char* storage_id, int storage_type, void* data, int burst, char** err_msg)
 952 {
 953 #if 0
 954         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 955
 956         if (handle == NULL) {
 957                 __set_error_message(ERR_HANDLE, err_msg);
 958                 return MEDIA_SVC_PLUGIN_ERROR;
 959         }
 960
 961         if (!STORAGE_VALID(storage_type)) {
 962                 __set_error_message(ERR_STORAGE_TYPE, err_msg);
 963                 return MEDIA_SVC_PLUGIN_ERROR;
 964         }
 965
 966         ret = media_svc_insert_one_item_pass2(handle, storage_id, storage_type, data, burst);
 967         if (ret < 0) {
 968                 __set_error_message(ret, err_msg);
 969                 return MEDIA_SVC_PLUGIN_ERROR;
 970         }
 971 #endif
 972         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 973 }
 974
 975 int query_do_update_list(void* handle, char** err_msg)
 976 {
 977 #if 0
 978         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 979
 980         if (handle == NULL) {
 981                 __set_error_message(ERR_HANDLE, err_msg);
 982                 return MEDIA_SVC_PLUGIN_ERROR;
 983         }
 984
 985         ret = media_svc_query_do_update_list(handle);
 986         if (ret < 0) {
 987                 __set_error_message(ret, err_msg);
 988                 return MEDIA_SVC_PLUGIN_ERROR;
 989         }
 990 #endif
 991         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 992 }
 993
 994 int insert_folder_begin(void * handle, int item_cnt, char **err_msg)
 995 {
 996         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 997
 998         ret = media_svc_insert_folder_begin(item_cnt);
 999         if (ret < 0) {
1000                 __set_error_message(ret, err_msg);
1001                 return MEDIA_SVC_PLUGIN_ERROR;
1002         }
1003
1004         return MEDIA_SVC_PLUGIN_ERROR_NONE;
1005 }
1006
1007 int insert_folder_end(void *handle, uid_t uid, char **err_msg)
1008 {
1009         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
1010
1011         ret = media_svc_insert_folder_end(uid);
1012         if (ret < 0) {
1013                 __set_error_message(ret, err_msg);
1014                 return MEDIA_SVC_PLUGIN_ERROR;
1015         }
1016
1017         return MEDIA_SVC_PLUGIN_ERROR_NONE;
1018 }
1019
1020 int insert_folder(void * handle, const char *storage_id, const char *file_path, int storage_type, uid_t uid, char **err_msg)
1021 {
1022         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
1023
1024         if (handle == NULL) {
1025                 __set_error_message(ERR_HANDLE, err_msg);
1026                 return MEDIA_SVC_PLUGIN_ERROR;
1027         }
1028
1029         if (!STRING_VALID(file_path)) {
1030                 __set_error_message(ERR_FILE_PATH, err_msg);
1031                 return MEDIA_SVC_PLUGIN_ERROR;
1032         }
1033
1034         if (!STORAGE_VALID(storage_type)) {
1035                 __set_error_message(ERR_STORAGE_TYPE, err_msg);
1036                 return MEDIA_SVC_PLUGIN_ERROR;
1037         }
1038
1039         ret = media_svc_insert_folder(handle, storage_id, storage_type, file_path, uid);
1040         if (ret < 0) {
1041                 __set_error_message(ret, err_msg);
1042                 return MEDIA_SVC_PLUGIN_ERROR;
1043         }
1044
1045         return MEDIA_SVC_PLUGIN_ERROR_NONE;
1046 }
1047
1048 int delete_invalid_folder(void * handle, const char *storage_id, int storage_type, uid_t uid, char **err_msg)
1049 {
1050         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
1051
1052         ret = media_svc_delete_invalid_folder(storage_id, storage_type, uid);
1053         if (ret < 0) {
1054                 __set_error_message(ret, err_msg);
1055                 return MEDIA_SVC_PLUGIN_ERROR;
1056         }
1057
1058         return MEDIA_SVC_PLUGIN_ERROR_NONE;
1059 }
1060
1061 int set_folder_validity(void * handle, const char *storage_id, const char* start_path, int validity, bool is_recursive, uid_t uid, char **err_msg)
1062 {
1063         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
1064
1065         if (handle == NULL) {
1066                 __set_error_message(ERR_HANDLE, err_msg);
1067                 return MEDIA_SVC_PLUGIN_ERROR;
1068         }
1069
1070         ret = media_svc_set_folder_validity(handle, storage_id, start_path, validity, is_recursive, uid);
1071         if (ret < 0) {
1072                 __set_error_message(ret, err_msg);
1073                 return MEDIA_SVC_PLUGIN_ERROR;
1074         }
1075
1076         return MEDIA_SVC_PLUGIN_ERROR_NONE;
1077 }
1078
1079 int delete_invalid_folder_by_path(void * handle, const char *storage_id, const char *folder_path, uid_t uid, int *delete_count, char **err_msg)
1080 {
1081         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
1082
1083         if (handle == NULL) {
1084                 __set_error_message(ERR_HANDLE, err_msg);
1085                 return MEDIA_SVC_PLUGIN_ERROR;
1086         }
1087
1088         ret = media_svc_delete_invalid_folder_by_path(handle, storage_id, folder_path, uid, delete_count);
1089         if (ret < 0) {
1090                 __set_error_message(ret, err_msg);
1091                 return MEDIA_SVC_PLUGIN_ERROR;
1092         }
1093
1094         return MEDIA_SVC_PLUGIN_ERROR_NONE;
1095 }
1096
1097 int get_folder_scan_status(void *handle, const char *storage_id, const char *path, int *status, char **err_msg)
1098 {
1099         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
1100         int storage_status = 0;
1101
1102         if (handle == NULL) {
1103                 __set_error_message(ERR_HANDLE, err_msg);
1104                 return MEDIA_SVC_PLUGIN_ERROR;
1105         }
1106
1107         ret = media_svc_get_folder_scan_status(handle, storage_id, path, &storage_status);
1108         if (ret < 0) {
1109                 __set_error_message(ret, err_msg);
1110                 return MEDIA_SVC_PLUGIN_ERROR;
1111         }
1112
1113         *status = storage_status;
1114
1115         return ret;
1116 }
1117
1118 int set_folder_scan_status(void *handle, const char *storage_id, const char *path, int status, uid_t uid, char **err_msg)
1119 {
1120         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
1121         int storage_status = status;
1122
1123         ret = media_svc_set_folder_scan_status(storage_id, path, storage_status, uid);
1124         if (ret < 0) {
1125                 __set_error_message(ret, err_msg);
1126                 return MEDIA_SVC_PLUGIN_ERROR;
1127         }
1128
1129         return ret;
1130 }
1131
1132 int check_folder_modified(void *handle, const char *path, const char *storage_id, bool *modified, char **err_msg)
1133 {
1134         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
1135         *modified = TRUE;
1136
1137         if (handle == NULL) {
1138                 __set_error_message(ERR_HANDLE, err_msg);
1139                 return MEDIA_SVC_PLUGIN_ERROR;
1140         }
1141
1142         if (!STRING_VALID(path)) {
1143                 __set_error_message(ERR_FILE_PATH, err_msg);
1144                 return MEDIA_SVC_PLUGIN_ERROR;
1145         }
1146
1147         ret = media_svc_get_folder_modified_time(handle, path, storage_id, modified);
1148         if (ret < 0) {
1149                 __set_error_message(ret, err_msg);
1150                 return MEDIA_SVC_PLUGIN_ERROR;
1151         }
1152
1153         return ret;
1154 }
1155
1156 int get_null_scan_folder_list(void *handle, const char *storage_id, const char *folder_path, char ***folder_list, int *count, char **err_msg)
1157 {
1158         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
1159
1160         if (handle == NULL) {
1161                 __set_error_message(ERR_HANDLE, err_msg);
1162                 return MEDIA_SVC_PLUGIN_ERROR;
1163         }
1164
1165         if (count == NULL) {
1166                 __set_error_message(ERR_HANDLE, err_msg);
1167                 return MEDIA_SVC_PLUGIN_ERROR;
1168         }
1169
1170         ret = media_svc_get_null_scan_folder_list(handle, storage_id, folder_path, folder_list, count);
1171         if (ret < 0) {
1172                 __set_error_message(ret, err_msg);
1173                 return MEDIA_SVC_PLUGIN_ERROR;
1174         }
1175
1176         return ret;
1177 }
1178
1179 int change_validity_item_batch(void **handle, const char *storage_id, const char *path, int des_validity, int src_validity, uid_t uid, char **err_msg)
1180 {
1181         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
1182
1183         ret = media_svc_change_validity_item_batch(storage_id, path, des_validity, src_validity, uid);
1184         if (ret < 0) {
1185                 __set_error_message(ret, err_msg);
1186                 return MEDIA_SVC_PLUGIN_ERROR;
1187         }
1188
1189         return ret;
1190 }
1191
1192 int check_folder_exist(void * handle, const char *storage_id, const char *folder_path, char **err_msg)
1193 {
1194         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
1195
1196         if (handle == NULL) {
1197                 __set_error_message(ERR_HANDLE, err_msg);
1198                 return MEDIA_SVC_PLUGIN_ERROR;
1199         }
1200
1201         ret = media_svc_check_folder_exist_by_path(handle, storage_id, folder_path);
1202         if (ret < 0) {
1203                 __set_error_message(ret, err_msg);
1204                 return MEDIA_SVC_PLUGIN_ERROR;
1205         }
1206
1207         return MEDIA_SVC_PLUGIN_ERROR_NONE;
1208 }
1209
1210 int count_subfolder(void *handle, const char *storage_id, const char *folder_path, int *count, char **err_msg)
1211 {
1212         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
1213         int cnt = 0;
1214
1215         if (handle == NULL) {
1216                 __set_error_message(ERR_HANDLE, err_msg);
1217                 return MEDIA_SVC_PLUGIN_ERROR;
1218         }
1219
1220         ret = media_svc_check_subfolder_by_path(handle, storage_id, folder_path, &cnt);
1221         if (ret < 0) {
1222                 __set_error_message(ret, err_msg);
1223                 return MEDIA_SVC_PLUGIN_ERROR;
1224         }
1225
1226         *count = cnt;
1227
1228         return MEDIA_SVC_PLUGIN_ERROR_NONE;
1229 }
1230
1231 int get_folder_id(void * handle, const char *storage_id, const char *path, char *folder_id, char **err_msg)
1232 {
1233         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
1234
1235         if (handle == NULL) {
1236                 __set_error_message(ERR_HANDLE, err_msg);
1237                 return MEDIA_SVC_PLUGIN_ERROR;
1238         }
1239
1240         ret = media_svc_get_folder_id(handle, storage_id, path, folder_id);
1241         if (ret < 0) {
1242                 __set_error_message(ret, err_msg);
1243                 return MEDIA_SVC_PLUGIN_ERROR;
1244         }
1245
1246         return MEDIA_SVC_PLUGIN_ERROR_NONE;
1247 }
1248
1249 int get_media_type(void *handle, const char *path, int *mediatype, char **err_msg)
1250 {
1251         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
1252
1253         if (handle == NULL) {
1254                 __set_error_message(ERR_HANDLE, err_msg);
1255                 return MEDIA_SVC_PLUGIN_ERROR;
1256         }
1257
1258         ret = media_svc_get_media_type(path, mediatype);
1259         if (ret < 0) {
1260                 __set_error_message(ret, err_msg);
1261                 return MEDIA_SVC_PLUGIN_ERROR;
1262         }
1263
1264         return MEDIA_SVC_PLUGIN_ERROR_NONE;
1265 }
1266
1267