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         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 458 #if 0
 459         ret = thumbnail_request_extract_all_thumbs(uid);
 460         if (ret < 0) {
 461                 return MEDIA_SVC_PLUGIN_ERROR;
 462         }
 463 #endif
 464         ret = dcm_svc_request_extract_all(uid);
 465         if (ret < 0) {
 466                 return MEDIA_SVC_PLUGIN_ERROR;
 467         }
 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, char **err_msg, uid_t uid)
 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, 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);
 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 insert_folder_begin(void * handle, int item_cnt, char **err_msg)
 928 {
 929         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 930
 931         ret = media_svc_insert_folder_begin(item_cnt);
 932         if (ret < 0) {
 933                 __set_error_message(ret, err_msg);
 934                 return MEDIA_SVC_PLUGIN_ERROR;
 935         }
 936
 937         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 938 }
 939
 940 int insert_folder_end(void *handle, uid_t uid, char **err_msg)
 941 {
 942         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 943
 944         ret = media_svc_insert_folder_end(uid);
 945         if (ret < 0) {
 946                 __set_error_message(ret, err_msg);
 947                 return MEDIA_SVC_PLUGIN_ERROR;
 948         }
 949
 950         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 951 }
 952
 953 int insert_folder(void * handle, const char *storage_id, const char *file_path, int storage_type, uid_t uid, char **err_msg)
 954 {
 955         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 956
 957         if (handle == NULL) {
 958                 __set_error_message(ERR_HANDLE, err_msg);
 959                 return MEDIA_SVC_PLUGIN_ERROR;
 960         }
 961
 962         if (!STRING_VALID(file_path)) {
 963                 __set_error_message(ERR_FILE_PATH, err_msg);
 964                 return MEDIA_SVC_PLUGIN_ERROR;
 965         }
 966
 967         if (!STORAGE_VALID(storage_type)) {
 968                 __set_error_message(ERR_STORAGE_TYPE, err_msg);
 969                 return MEDIA_SVC_PLUGIN_ERROR;
 970         }
 971
 972         ret = media_svc_insert_folder(handle, storage_id, storage_type, file_path, uid);
 973         if (ret < 0) {
 974                 __set_error_message(ret, err_msg);
 975                 return MEDIA_SVC_PLUGIN_ERROR;
 976         }
 977
 978         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 979 }
 980
 981 int delete_invalid_folder(void * handle, const char *storage_id, uid_t uid, char **err_msg)
 982 {
 983         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 984
 985         ret = media_svc_delete_invalid_folder(storage_id, uid);
 986         if (ret < 0) {
 987                 __set_error_message(ret, err_msg);
 988                 return MEDIA_SVC_PLUGIN_ERROR;
 989         }
 990
 991         return MEDIA_SVC_PLUGIN_ERROR_NONE;
 992 }
 993
 994 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)
 995 {
 996         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 997
 998         if (handle == NULL) {
 999                 __set_error_message(ERR_HANDLE, err_msg);
1000                 return MEDIA_SVC_PLUGIN_ERROR;
1001         }
1002
1003         ret = media_svc_set_folder_validity(handle, storage_id, start_path, validity, is_recursive, uid);
1004         if (ret < 0) {
1005                 __set_error_message(ret, err_msg);
1006                 return MEDIA_SVC_PLUGIN_ERROR;
1007         }
1008
1009         return MEDIA_SVC_PLUGIN_ERROR_NONE;
1010 }
1011
1012 int get_folder_scan_status(void *handle, const char *storage_id, const char *path, int *status, char **err_msg)
1013 {
1014         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
1015         int storage_status = 0;
1016
1017         if (handle == NULL) {
1018                 __set_error_message(ERR_HANDLE, err_msg);
1019                 return MEDIA_SVC_PLUGIN_ERROR;
1020         }
1021
1022         ret = media_svc_get_folder_scan_status(handle, storage_id, path, &storage_status);
1023         if (ret < 0) {
1024                 __set_error_message(ret, err_msg);
1025                 return MEDIA_SVC_PLUGIN_ERROR;
1026         }
1027
1028         *status = storage_status;
1029
1030         return ret;
1031 }
1032
1033 int set_folder_scan_status(void *handle, const char *storage_id, const char *path, int status, uid_t uid, char **err_msg)
1034 {
1035         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
1036         int storage_status = status;
1037
1038         ret = media_svc_set_folder_scan_status(storage_id, path, storage_status, uid);
1039         if (ret < 0) {
1040                 __set_error_message(ret, err_msg);
1041                 return MEDIA_SVC_PLUGIN_ERROR;
1042         }
1043
1044         return ret;
1045 }
1046
1047 int check_folder_modified(void *handle, const char *path, const char *storage_id, bool *modified, char **err_msg)
1048 {
1049         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
1050         *modified = TRUE;
1051
1052         if (handle == NULL) {
1053                 __set_error_message(ERR_HANDLE, err_msg);
1054                 return MEDIA_SVC_PLUGIN_ERROR;
1055         }
1056
1057         if (!STRING_VALID(path)) {
1058                 __set_error_message(ERR_FILE_PATH, err_msg);
1059                 return MEDIA_SVC_PLUGIN_ERROR;
1060         }
1061
1062         ret = media_svc_get_folder_modified_time(handle, path, storage_id, modified);
1063         if (ret < 0) {
1064                 __set_error_message(ret, err_msg);
1065                 return MEDIA_SVC_PLUGIN_ERROR;
1066         }
1067
1068         return ret;
1069 }
1070
1071 int get_null_scan_folder_list(void *handle, const char *storage_id, const char *folder_path, char ***folder_list, int *count, char **err_msg)
1072 {
1073         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
1074
1075         if (handle == NULL) {
1076                 __set_error_message(ERR_HANDLE, err_msg);
1077                 return MEDIA_SVC_PLUGIN_ERROR;
1078         }
1079
1080         if (count == NULL) {
1081                 __set_error_message(ERR_HANDLE, err_msg);
1082                 return MEDIA_SVC_PLUGIN_ERROR;
1083         }
1084
1085         ret = media_svc_get_null_scan_folder_list(handle, storage_id, folder_path, folder_list, count);
1086         if (ret < 0) {
1087                 __set_error_message(ret, err_msg);
1088                 return MEDIA_SVC_PLUGIN_ERROR;
1089         }
1090
1091         return ret;
1092 }
1093
1094 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)
1095 {
1096         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
1097
1098         ret = media_svc_change_validity_item_batch(storage_id, path, des_validity, src_validity, uid);
1099         if (ret < 0) {
1100                 __set_error_message(ret, err_msg);
1101                 return MEDIA_SVC_PLUGIN_ERROR;
1102         }
1103
1104         return ret;
1105 }
1106
1107 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)
1108 {
1109         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
1110
1111         if (handle == NULL) {
1112                 __set_error_message(ERR_HANDLE, err_msg);
1113                 return MEDIA_SVC_PLUGIN_ERROR;
1114         }
1115
1116         ret = media_svc_delete_invalid_folder_by_path(handle, storage_id, folder_path, uid, delete_count);
1117         if (ret < 0) {
1118                 __set_error_message(ret, err_msg);
1119                 return MEDIA_SVC_PLUGIN_ERROR;
1120         }
1121
1122         return MEDIA_SVC_PLUGIN_ERROR_NONE;
1123 }
1124
1125 int check_folder_exist(void * handle, const char *storage_id, const char *folder_path, char **err_msg)
1126 {
1127         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
1128
1129         if (handle == NULL) {
1130                 __set_error_message(ERR_HANDLE, err_msg);
1131                 return MEDIA_SVC_PLUGIN_ERROR;
1132         }
1133
1134         ret = media_svc_check_folder_exist_by_path(handle, storage_id, folder_path);
1135         if (ret < 0) {
1136                 __set_error_message(ret, err_msg);
1137                 return MEDIA_SVC_PLUGIN_ERROR;
1138         }
1139
1140         return MEDIA_SVC_PLUGIN_ERROR_NONE;
1141 }
1142
1143 int count_subfolder(void *handle, const char *storage_id, const char *folder_path, int *count, char **err_msg)
1144 {
1145         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
1146         int cnt = 0;
1147
1148         if (handle == NULL) {
1149                 __set_error_message(ERR_HANDLE, err_msg);
1150                 return MEDIA_SVC_PLUGIN_ERROR;
1151         }
1152
1153         ret = media_svc_check_subfolder_by_path(handle, storage_id, folder_path, &cnt);
1154         if (ret < 0) {
1155                 __set_error_message(ret, err_msg);
1156                 return MEDIA_SVC_PLUGIN_ERROR;
1157         }
1158
1159         *count = cnt;
1160
1161         return MEDIA_SVC_PLUGIN_ERROR_NONE;
1162 }
1163
1164 int get_folder_id(void * handle, const char *storage_id, const char *path, char *folder_id, char **err_msg)
1165 {
1166         int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
1167
1168         if (handle == NULL) {
1169                 __set_error_message(ERR_HANDLE, err_msg);
1170                 return MEDIA_SVC_PLUGIN_ERROR;
1171         }
1172
1173         ret = media_svc_get_folder_id(handle, storage_id, path, folder_id);
1174         if (ret < 0) {
1175                 __set_error_message(ret, err_msg);
1176                 return MEDIA_SVC_PLUGIN_ERROR;
1177         }
1178
1179         return MEDIA_SVC_PLUGIN_ERROR_NONE;
1180 }
1181
1182