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(void)
 456 {
 457         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 458 }
 459
 460 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)
 461 {
 462         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 463
 464         if (!STRING_VALID(dir_path)) {
 465                 __set_error_message(ERR_FOLDER_PATH, err_msg);
 466                 return MEDIA_SVC_PLUGIN_ERROR;
 467         }
 468
 469         ret = media_svc_send_dir_update_noti(handle, storage_id, dir_path, folder_id, (media_item_update_type_e)update_type, pid);
 470         if (ret < 0) {
 471                 __set_error_message(ret, err_msg);
 472                 return MEDIA_SVC_PLUGIN_ERROR;
 473         }
 474
 475         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 476 }
 477
 478 int count_delete_items_in_folder(void *handle, const char *storage_id, const char *folder_path, int *count, char **err_msg)
 479 {
 480         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 481
 482         if (handle == NULL) {
 483                 __set_error_message(ERR_HANDLE, err_msg);
 484                 return MEDIA_SVC_PLUGIN_ERROR;
 485         }
 486
 487         if (count == NULL) {
 488                 __set_error_message(ERR_HANDLE, err_msg);
 489                 return MEDIA_SVC_PLUGIN_ERROR;
 490         }
 491
 492         if (!STRING_VALID(folder_path)) {
 493                 __set_error_message(ERR_FOLDER_PATH, err_msg);
 494                 return MEDIA_SVC_PLUGIN_ERROR;
 495         }
 496
 497         ret = media_svc_count_invalid_items_in_folder(handle, storage_id, folder_path, count);
 498         if (ret < 0) {
 499                 __set_error_message(ret, err_msg);
 500                 return MEDIA_SVC_PLUGIN_ERROR;
 501         }
 502
 503         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 504 }
 505
 506 int check_db(void *handle, uid_t uid, char **err_msg)
 507 {
 508         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 509         int user_version = -1;
 510
 511         ret = media_svc_get_user_version(handle, &user_version);
 512         if (ret < 0) {
 513                 __set_error_message(ret, err_msg);
 514                 return MEDIA_SVC_PLUGIN_ERROR;
 515         }
 516
 517         if (user_version == 0) {
 518                 /*check db schema*/
 519                 ret = media_svc_create_table(uid);
 520                 if (ret < 0) {
 521                         __set_error_message(ret, err_msg);
 522                         return MEDIA_SVC_PLUGIN_ERROR;
 523                 }
 524         } else {
 525                 /*check db version*/
 526                 ret = media_svc_check_db_upgrade(handle, user_version, uid);
 527                 if (ret < 0) {
 528                         __set_error_message(ret, err_msg);
 529                         return MEDIA_SVC_PLUGIN_ERROR;
 530                 }
 531         }
 532
 533         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 534 }
 535
 536 int check_db_corrupt(void *handle, char **err_msg)
 537 {
 538         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 539
 540         /*check db version*/
 541         ret = media_svc_check_db_corrupt(handle);
 542         if (ret < 0) {
 543                 __set_error_message(ret, err_msg);
 544                 return MEDIA_SVC_PLUGIN_ERROR;
 545         }
 546
 547         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 548 }
 549
 550 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)
 551 {
 552         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 553
 554         if (handle == NULL) {
 555                 __set_error_message(ERR_HANDLE, err_msg);
 556                 return MEDIA_SVC_PLUGIN_ERROR;
 557         }
 558
 559         if (count == NULL) {
 560                 __set_error_message(ERR_HANDLE, err_msg);
 561                 return MEDIA_SVC_PLUGIN_ERROR;
 562         }
 563
 564         ret = media_svc_get_folder_list(handle, start_path, folder_list, (time_t **)modified_time_list, item_num_list, count);
 565         if (ret < 0) {
 566                 __set_error_message(ret, err_msg);
 567                 return MEDIA_SVC_PLUGIN_ERROR;
 568         }
 569
 570         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 571 }
 572
 573 int update_folder_time(void *handle, const char *storage_id, char *folder_path, uid_t uid, char **err_msg)
 574 {
 575         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 576
 577         if (handle == NULL) {
 578                 __set_error_message(ERR_HANDLE, err_msg);
 579                 return MEDIA_SVC_PLUGIN_ERROR;
 580         }
 581
 582         if (folder_path == NULL) {
 583                 __set_error_message(ERR_HANDLE, err_msg);
 584                 return MEDIA_SVC_PLUGIN_ERROR;
 585         }
 586
 587         ret = media_svc_update_folder_time(handle, storage_id, folder_path, uid);
 588         if (ret < 0) {
 589                 __set_error_message(ret, err_msg);
 590                 return MEDIA_SVC_PLUGIN_ERROR;
 591         }
 592
 593         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 594 }
 595
 596 int get_uuid(void * handle, char **uuid, char **err_msg)
 597 {
 598         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 599
 600         ret = media_svc_generate_uuid(uuid);
 601         if (ret < 0) {
 602                 __set_error_message(ret, err_msg);
 603                 return MEDIA_SVC_PLUGIN_ERROR;
 604         }
 605
 606         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 607 }
 608
 609 int get_mmc_info(void * handle, char **storage_name, char **storage_path, int *validity, bool *info_exist, char **err_msg)
 610 {
 611         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 612
 613         if (handle == NULL) {
 614                 __set_error_message(ERR_HANDLE, err_msg);
 615                 return MEDIA_SVC_PLUGIN_ERROR;
 616         }
 617
 618         ret = media_svc_get_mmc_info(handle, storage_name, storage_path, validity, info_exist);
 619         if (ret < 0) {
 620                 __set_error_message(MS_MEDIA_ERR_DB_NO_RECORD, err_msg);
 621                 return MEDIA_SVC_PLUGIN_ERROR;
 622         }
 623
 624         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 625 }
 626
 627 int check_storage(void * handle, const char *storage_id, const char *storage_name, char **storage_path, int *validity, uid_t uid, char **err_msg)
 628 {
 629         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 630
 631         if (handle == NULL) {
 632                 __set_error_message(ERR_HANDLE, err_msg);
 633                 return MEDIA_SVC_PLUGIN_ERROR;
 634         }
 635
 636         ret = media_svc_check_storage(handle, storage_id, storage_name, storage_path, validity, uid);
 637         if (ret < 0) {
 638                 __set_error_message(ret, err_msg);
 639                 return MEDIA_SVC_PLUGIN_ERROR;
 640         }
 641
 642         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 643 }
 644
 645 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)
 646 {
 647         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 648
 649         if (handle == NULL) {
 650                 __set_error_message(ERR_HANDLE, err_msg);
 651                 return MEDIA_SVC_PLUGIN_ERROR;
 652         }
 653
 654         ret = media_svc_insert_storage(handle, storage_id, storage_name, storage_path, storage_type, uid);
 655         if (ret < 0) {
 656                 __set_error_message(ret, err_msg);
 657                 return MEDIA_SVC_PLUGIN_ERROR;
 658         }
 659
 660         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 661 }
 662
 663 int update_storage(void *handle, const char *storage_id, const char *storage_path, uid_t uid, char **err_msg)
 664 {
 665         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 666
 667         if (handle == NULL) {
 668                 __set_error_message(ERR_HANDLE, err_msg);
 669                 return MEDIA_SVC_PLUGIN_ERROR;
 670         }
 671
 672         ret = media_svc_update_storage(handle, storage_id, storage_path, uid);
 673         if (ret < 0) {
 674                 __set_error_message(ret, err_msg);
 675                 return MEDIA_SVC_PLUGIN_ERROR;
 676         }
 677
 678         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 679 }
 680
 681 int delete_storage(void * handle, const char *storage_id, const char *storage_name, uid_t uid, char **err_msg)
 682 {
 683         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 684
 685         if (handle == NULL) {
 686                 __set_error_message(ERR_HANDLE, err_msg);
 687                 return MEDIA_SVC_PLUGIN_ERROR;
 688         }
 689
 690         ret = media_svc_delete_storage(handle, storage_id, storage_name, uid);
 691         if (ret < 0) {
 692                 __set_error_message(ret, err_msg);
 693                 return MEDIA_SVC_PLUGIN_ERROR;
 694         }
 695
 696         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 697 }
 698
 699 int set_storage_validity(void * handle, const char *storage_id, int validity, uid_t uid, char **err_msg)
 700 {
 701         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 702
 703         if (handle == NULL) {
 704                 __set_error_message(ERR_HANDLE, err_msg);
 705                 return MEDIA_SVC_PLUGIN_ERROR;
 706         }
 707
 708         ret = media_svc_set_storage_validity(handle, storage_id, validity, uid);
 709         if (ret < 0) {
 710                 __set_error_message(ret, err_msg);
 711                 return MEDIA_SVC_PLUGIN_ERROR;
 712         }
 713
 714         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 715 }
 716
 717 int set_all_storage_validity(void * handle, int validity, uid_t uid, char **err_msg)
 718 {
 719         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 720
 721         if (handle == NULL) {
 722                 __set_error_message(ERR_HANDLE, err_msg);
 723                 return MEDIA_SVC_PLUGIN_ERROR;
 724         }
 725
 726         ret = media_svc_set_storage_validity(handle, NULL, validity, uid);
 727         if (ret < 0) {
 728                 __set_error_message(ret, err_msg);
 729                 return MEDIA_SVC_PLUGIN_ERROR;
 730         }
 731
 732         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 733 }
 734
 735 int get_storage_id(void * handle, const char *path, char *storage_id, uid_t uid, char **err_msg)
 736 {
 737         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 738
 739         if (handle == NULL) {
 740                 __set_error_message(ERR_HANDLE, err_msg);
 741                 return MEDIA_SVC_PLUGIN_ERROR;
 742         }
 743
 744         ret = media_svc_get_storage_id(handle, path, storage_id, uid);
 745         if (ret < 0) {
 746                 __set_error_message(ret, err_msg);
 747                 return MEDIA_SVC_PLUGIN_ERROR;
 748         }
 749
 750         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 751 }
 752
 753 int get_storage_scan_status(void * handle, const char *storage_id, int *status, char **err_msg)
 754 {
 755         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 756         media_svc_scan_status_type_e storage_status = 0;
 757
 758         if (handle == NULL) {
 759                 __set_error_message(ERR_HANDLE, err_msg);
 760                 return MEDIA_SVC_PLUGIN_ERROR;
 761         }
 762
 763         ret = media_svc_get_storage_scan_status(handle, storage_id, &storage_status);
 764         if (ret < 0) {
 765                 __set_error_message(ret, err_msg);
 766                 return MEDIA_SVC_PLUGIN_ERROR;
 767         }
 768
 769         *status = storage_status;
 770
 771         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 772 }
 773
 774 int set_storage_scan_status(void *handle, const char *storage_id, int status, uid_t uid, char **err_msg)
 775 {
 776         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 777         media_svc_scan_status_type_e storage_status = status;
 778
 779         ret = media_svc_set_storage_scan_status(storage_id, storage_status, uid);
 780         if (ret < 0) {
 781                 __set_error_message(ret, err_msg);
 782                 return MEDIA_SVC_PLUGIN_ERROR;
 783         }
 784
 785         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 786 }
 787
 788 int get_storage_list(void *handle, char ***storage_list, char ***storage_id_list, int **scan_status_list, int *count, char **err_msg)
 789 {
 790         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 791
 792         if (handle == NULL) {
 793                 __set_error_message(ERR_HANDLE, err_msg);
 794                 return MEDIA_SVC_PLUGIN_ERROR;
 795         }
 796
 797         if (count == NULL) {
 798                 __set_error_message(ERR_HANDLE, err_msg);
 799                 return MEDIA_SVC_PLUGIN_ERROR;
 800         }
 801
 802         ret = media_svc_get_storage_list(handle, storage_list, storage_id_list, scan_status_list, count);
 803         if (ret < 0) {
 804                 __set_error_message(ret, err_msg);
 805                 return MEDIA_SVC_PLUGIN_ERROR;
 806         }
 807
 808         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 809 }
 810
 811 int update_item_begin(void *handle, int item_cnt, char **err_msg)
 812 {
 813         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 814
 815         ret = media_svc_update_item_begin(item_cnt);
 816         if (ret < 0) {
 817                 __set_error_message(ret, err_msg);
 818                 return MEDIA_SVC_PLUGIN_ERROR;
 819         }
 820
 821         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 822 }
 823
 824 int update_item_end(void *handle, uid_t uid, char **err_msg)
 825 {
 826         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 827
 828         ret = media_svc_update_item_end(uid);
 829         if (ret < 0) {
 830                 __set_error_message(ret, err_msg);
 831                 return MEDIA_SVC_PLUGIN_ERROR;
 832         }
 833
 834         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 835 }
 836
 837 int update_item_meta(void *handle, const char *file_path, const char *storage_id, int storage_type, uid_t uid, char **err_msg)
 838 {
 839         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 840
 841         if (handle == NULL) {
 842                 __set_error_message(ERR_HANDLE, err_msg);
 843                 return MEDIA_SVC_PLUGIN_ERROR;
 844         }
 845
 846         if (file_path == NULL) {
 847                 __set_error_message(ERR_HANDLE, err_msg);
 848                 return MEDIA_SVC_PLUGIN_ERROR;
 849         }
 850
 851         if (storage_id == NULL) {
 852                 __set_error_message(ERR_HANDLE, err_msg);
 853                 return MEDIA_SVC_PLUGIN_ERROR;
 854         }
 855
 856         ret = media_svc_update_item_meta(handle, file_path, storage_id, storage_type, uid);
 857         if (ret < 0) {
 858                 __set_error_message(ret, err_msg);
 859                 return MEDIA_SVC_PLUGIN_ERROR;
 860         }
 861
 862         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 863 }
 864
 865 int insert_item_scan(void * handle, const char *storage_id, const char *file_path, int storage_type, uid_t uid, char **err_msg)
 866 {
 867         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 868
 869         if (handle == NULL) {
 870                 __set_error_message(ERR_HANDLE, err_msg);
 871                 return MEDIA_SVC_PLUGIN_ERROR;
 872         }
 873
 874         if (!STRING_VALID(file_path)) {
 875                 __set_error_message(ERR_FILE_PATH, err_msg);
 876                 return MEDIA_SVC_PLUGIN_ERROR;
 877         }
 878
 879         if (!STORAGE_VALID(storage_type)) {
 880                 __set_error_message(ERR_STORAGE_TYPE, err_msg);
 881                 return MEDIA_SVC_PLUGIN_ERROR;
 882         }
 883
 884         ret = media_svc_insert_item_pass1(handle, storage_id, storage_type, file_path, FALSE, uid);
 885         if (ret < 0) {
 886                 __set_error_message(ret, err_msg);
 887                 return MEDIA_SVC_PLUGIN_ERROR;
 888         }
 889
 890         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 891 }
 892
 893 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)
 894 {
 895         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 896
 897         if (handle == NULL) {
 898                 __set_error_message(ERR_HANDLE, err_msg);
 899                 return MEDIA_SVC_PLUGIN_ERROR;
 900         }
 901
 902         if (!STORAGE_VALID(storage_type)) {
 903                 __set_error_message(ERR_STORAGE_TYPE, err_msg);
 904                 return MEDIA_SVC_PLUGIN_ERROR;
 905         }
 906
 907         ret = media_svc_insert_item_pass2(handle, storage_id, storage_type, scan_type, path, burst, uid);
 908         if (ret < 0) {
 909                 __set_error_message(ret, err_msg);
 910                 return MEDIA_SVC_PLUGIN_ERROR;
 911         }
 912
 913         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 914 }
 915
 916 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)
 917 {
 918 #if 0
 919         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 920
 921         if (handle == NULL) {
 922                 __set_error_message(ERR_HANDLE, err_msg);
 923                 return MEDIA_SVC_PLUGIN_ERROR;
 924         }
 925
 926         if (!STORAGE_VALID(storage_type)) {
 927                 __set_error_message(ERR_STORAGE_TYPE, err_msg);
 928                 return MEDIA_SVC_PLUGIN_ERROR;
 929         }
 930
 931         ret = media_svc_pass2_get_extract_list(handle, storage_id, storage_type, scan_type, path, burst, uid, array);
 932         if (ret < 0) {
 933                 __set_error_message(ret, err_msg);
 934                 return MEDIA_SVC_PLUGIN_ERROR;
 935         }
 936 #endif
 937         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 938 }
 939
 940 int update_one_extract_item(void* handle, const char* storage_id, int storage_type, void* data, int burst, char** err_msg)
 941 {
 942 #if 0
 943         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 944
 945         if (handle == NULL) {
 946                 __set_error_message(ERR_HANDLE, err_msg);
 947                 return MEDIA_SVC_PLUGIN_ERROR;
 948         }
 949
 950         if (!STORAGE_VALID(storage_type)) {
 951                 __set_error_message(ERR_STORAGE_TYPE, err_msg);
 952                 return MEDIA_SVC_PLUGIN_ERROR;
 953         }
 954
 955         ret = media_svc_insert_one_item_pass2(handle, storage_id, storage_type, data, burst);
 956         if (ret < 0) {
 957                 __set_error_message(ret, err_msg);
 958                 return MEDIA_SVC_PLUGIN_ERROR;
 959         }
 960 #endif
 961         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 962 }
 963
 964 int query_do_update_list(void* handle, char** err_msg)
 965 {
 966 #if 0
 967         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 968
 969         if (handle == NULL) {
 970                 __set_error_message(ERR_HANDLE, err_msg);
 971                 return MEDIA_SVC_PLUGIN_ERROR;
 972         }
 973
 974         ret = media_svc_query_do_update_list(handle);
 975         if (ret < 0) {
 976                 __set_error_message(ret, err_msg);
 977                 return MEDIA_SVC_PLUGIN_ERROR;
 978         }
 979 #endif
 980         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 981 }
 982
 983 int insert_folder_begin(void * handle, int item_cnt, char **err_msg)
 984 {
 985         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 986
 987         ret = media_svc_insert_folder_begin(item_cnt);
 988         if (ret < 0) {
 989                 __set_error_message(ret, err_msg);
 990                 return MEDIA_SVC_PLUGIN_ERROR;
 991         }
 992
 993         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 994 }
 995
 996 int insert_folder_end(void *handle, uid_t uid, char **err_msg)
 997 {
 998         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 999
1000         ret = media_svc_insert_folder_end(uid);
1001         if (ret < 0) {
1002                 __set_error_message(ret, err_msg);
1003                 return MEDIA_SVC_PLUGIN_ERROR;
1004         }
1005
1006         return MEDIA_SVC_PLUGIN_ERROR_NONE;
1007 }
1008
1009 int insert_folder(void * handle, const char *storage_id, const char *file_path, int storage_type, uid_t uid, char **err_msg)
1010 {
1011         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
1012
1013         if (handle == NULL) {
1014                 __set_error_message(ERR_HANDLE, err_msg);
1015                 return MEDIA_SVC_PLUGIN_ERROR;
1016         }
1017
1018         if (!STRING_VALID(file_path)) {
1019                 __set_error_message(ERR_FILE_PATH, err_msg);
1020                 return MEDIA_SVC_PLUGIN_ERROR;
1021         }
1022
1023         if (!STORAGE_VALID(storage_type)) {
1024                 __set_error_message(ERR_STORAGE_TYPE, err_msg);
1025                 return MEDIA_SVC_PLUGIN_ERROR;
1026         }
1027
1028         ret = media_svc_insert_folder(handle, storage_id, storage_type, file_path, uid);
1029         if (ret < 0) {
1030                 __set_error_message(ret, err_msg);
1031                 return MEDIA_SVC_PLUGIN_ERROR;
1032         }
1033
1034         return MEDIA_SVC_PLUGIN_ERROR_NONE;
1035 }
1036
1037 int delete_invalid_folder(void * handle, const char *storage_id, int storage_type, uid_t uid, char **err_msg)
1038 {
1039         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
1040
1041         ret = media_svc_delete_invalid_folder(storage_id, storage_type, uid);
1042         if (ret < 0) {
1043                 __set_error_message(ret, err_msg);
1044                 return MEDIA_SVC_PLUGIN_ERROR;
1045         }
1046
1047         return MEDIA_SVC_PLUGIN_ERROR_NONE;
1048 }
1049
1050 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)
1051 {
1052         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
1053
1054         if (handle == NULL) {
1055                 __set_error_message(ERR_HANDLE, err_msg);
1056                 return MEDIA_SVC_PLUGIN_ERROR;
1057         }
1058
1059         ret = media_svc_set_folder_validity(handle, storage_id, start_path, validity, is_recursive, uid);
1060         if (ret < 0) {
1061                 __set_error_message(ret, err_msg);
1062                 return MEDIA_SVC_PLUGIN_ERROR;
1063         }
1064
1065         return MEDIA_SVC_PLUGIN_ERROR_NONE;
1066 }
1067
1068 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)
1069 {
1070         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
1071
1072         if (handle == NULL) {
1073                 __set_error_message(ERR_HANDLE, err_msg);
1074                 return MEDIA_SVC_PLUGIN_ERROR;
1075         }
1076
1077         ret = media_svc_delete_invalid_folder_by_path(handle, storage_id, folder_path, uid, delete_count);
1078         if (ret < 0) {
1079                 __set_error_message(ret, err_msg);
1080                 return MEDIA_SVC_PLUGIN_ERROR;
1081         }
1082
1083         return MEDIA_SVC_PLUGIN_ERROR_NONE;
1084 }
1085
1086 int get_folder_scan_status(void *handle, const char *storage_id, const char *path, int *status, char **err_msg)
1087 {
1088         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
1089         int storage_status = 0;
1090
1091         if (handle == NULL) {
1092                 __set_error_message(ERR_HANDLE, err_msg);
1093                 return MEDIA_SVC_PLUGIN_ERROR;
1094         }
1095
1096         ret = media_svc_get_folder_scan_status(handle, storage_id, path, &storage_status);
1097         if (ret < 0) {
1098                 __set_error_message(ret, err_msg);
1099                 return MEDIA_SVC_PLUGIN_ERROR;
1100         }
1101
1102         *status = storage_status;
1103
1104         return ret;
1105 }
1106
1107 int set_folder_scan_status(void *handle, const char *storage_id, const char *path, int status, uid_t uid, char **err_msg)
1108 {
1109         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
1110         int storage_status = status;
1111
1112         ret = media_svc_set_folder_scan_status(storage_id, path, storage_status, uid);
1113         if (ret < 0) {
1114                 __set_error_message(ret, err_msg);
1115                 return MEDIA_SVC_PLUGIN_ERROR;
1116         }
1117
1118         return ret;
1119 }
1120
1121 int check_folder_modified(void *handle, const char *path, const char *storage_id, bool *modified, char **err_msg)
1122 {
1123         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
1124         *modified = TRUE;
1125
1126         if (handle == NULL) {
1127                 __set_error_message(ERR_HANDLE, err_msg);
1128                 return MEDIA_SVC_PLUGIN_ERROR;
1129         }
1130
1131         if (!STRING_VALID(path)) {
1132                 __set_error_message(ERR_FILE_PATH, err_msg);
1133                 return MEDIA_SVC_PLUGIN_ERROR;
1134         }
1135
1136         ret = media_svc_get_folder_modified_time(handle, path, storage_id, modified);
1137         if (ret < 0) {
1138                 __set_error_message(ret, err_msg);
1139                 return MEDIA_SVC_PLUGIN_ERROR;
1140         }
1141
1142         return ret;
1143 }
1144
1145 int get_null_scan_folder_list(void *handle, const char *storage_id, const char *folder_path, char ***folder_list, int *count, char **err_msg)
1146 {
1147         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
1148
1149         if (handle == NULL) {
1150                 __set_error_message(ERR_HANDLE, err_msg);
1151                 return MEDIA_SVC_PLUGIN_ERROR;
1152         }
1153
1154         if (count == NULL) {
1155                 __set_error_message(ERR_HANDLE, err_msg);
1156                 return MEDIA_SVC_PLUGIN_ERROR;
1157         }
1158
1159         ret = media_svc_get_null_scan_folder_list(handle, storage_id, folder_path, folder_list, count);
1160         if (ret < 0) {
1161                 __set_error_message(ret, err_msg);
1162                 return MEDIA_SVC_PLUGIN_ERROR;
1163         }
1164
1165         return ret;
1166 }
1167
1168 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)
1169 {
1170         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
1171
1172         ret = media_svc_change_validity_item_batch(storage_id, path, des_validity, src_validity, uid);
1173         if (ret < 0) {
1174                 __set_error_message(ret, err_msg);
1175                 return MEDIA_SVC_PLUGIN_ERROR;
1176         }
1177
1178         return ret;
1179 }
1180
1181 int check_folder_exist(void * handle, const char *storage_id, const char *folder_path, char **err_msg)
1182 {
1183         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
1184
1185         if (handle == NULL) {
1186                 __set_error_message(ERR_HANDLE, err_msg);
1187                 return MEDIA_SVC_PLUGIN_ERROR;
1188         }
1189
1190         ret = media_svc_check_folder_exist_by_path(handle, storage_id, folder_path);
1191         if (ret < 0) {
1192                 __set_error_message(ret, err_msg);
1193                 return MEDIA_SVC_PLUGIN_ERROR;
1194         }
1195
1196         return MEDIA_SVC_PLUGIN_ERROR_NONE;
1197 }
1198
1199 int count_subfolder(void *handle, const char *storage_id, const char *folder_path, int *count, char **err_msg)
1200 {
1201         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
1202         int cnt = 0;
1203
1204         if (handle == NULL) {
1205                 __set_error_message(ERR_HANDLE, err_msg);
1206                 return MEDIA_SVC_PLUGIN_ERROR;
1207         }
1208
1209         ret = media_svc_check_subfolder_by_path(handle, storage_id, folder_path, &cnt);
1210         if (ret < 0) {
1211                 __set_error_message(ret, err_msg);
1212                 return MEDIA_SVC_PLUGIN_ERROR;
1213         }
1214
1215         *count = cnt;
1216
1217         return MEDIA_SVC_PLUGIN_ERROR_NONE;
1218 }
1219
1220 int get_folder_id(void * handle, const char *storage_id, const char *path, char *folder_id, char **err_msg)
1221 {
1222         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
1223
1224         if (handle == NULL) {
1225                 __set_error_message(ERR_HANDLE, err_msg);
1226                 return MEDIA_SVC_PLUGIN_ERROR;
1227         }
1228
1229         ret = media_svc_get_folder_id(handle, storage_id, path, folder_id);
1230         if (ret < 0) {
1231                 __set_error_message(ret, err_msg);
1232                 return MEDIA_SVC_PLUGIN_ERROR;
1233         }
1234
1235         return MEDIA_SVC_PLUGIN_ERROR_NONE;
1236 }
1237
1238 int get_media_type(void *handle, const char *path, int *mediatype, char **err_msg)
1239 {
1240         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
1241
1242         if (handle == NULL) {
1243                 __set_error_message(ERR_HANDLE, err_msg);
1244                 return MEDIA_SVC_PLUGIN_ERROR;
1245         }
1246
1247         ret = media_svc_get_media_type(path, mediatype);
1248         if (ret < 0) {
1249                 __set_error_message(ret, err_msg);
1250                 return MEDIA_SVC_PLUGIN_ERROR;
1251         }
1252
1253         return MEDIA_SVC_PLUGIN_ERROR_NONE;
1254 }
1255
1256