4 * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
6 * Contact: Hyunjun Ko <zzoon.ko@samsung.com>, Haejeong Kim <backto.kim@samsung.com>
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
12 * http://www.apache.org/licenses/LICENSE-2.0
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.
25 #include <media-util.h>
26 #include "media-svc.h"
27 #include "media-svc-util.h"
29 #define MEDIA_SVC_PLUGIN_ERROR_NONE 0
30 #define MEDIA_SVC_PLUGIN_ERROR -1
32 #define STRING_VALID(str) \
33 ((str != NULL && strlen(str) > 0) ? TRUE : FALSE)
34 #define STORAGE_VALID(storage)\
35 (((storage == MEDIA_SVC_STORAGE_INTERNAL) || (storage == MEDIA_SVC_STORAGE_EXTERNAL) || (storage == MEDIA_SVC_STORAGE_EXTERNAL_USB)) ? TRUE : FALSE)
47 } media_svc_error_type_e;
49 static void __set_error_message(int err_type, char **err_msg);
51 static void __set_error_message(int err_type, char **err_msg)
58 if (err_type == ERR_HANDLE)
59 *err_msg = strdup("invalid handle");
60 else if (err_type == ERR_FILE_PATH)
61 *err_msg = strdup("invalid file path");
62 else if (err_type == ERR_FOLDER_PATH)
63 *err_msg = strdup("invalid folder path");
64 else if (err_type == ERR_MIME_TYPE)
65 *err_msg = strdup("invalid mime type");
66 else if (err_type == ERR_NOT_MEDIAFILE)
67 *err_msg = strdup("not media content");
68 else if (err_type == ERR_STORAGE_TYPE)
69 *err_msg = strdup("invalid storage type");
70 else if (err_type == ERR_CHECK_ITEM)
71 *err_msg = strdup("item does not exist");
72 else if (err_type == MS_MEDIA_ERR_DB_CONNECT_FAIL)
73 *err_msg = strdup("DB connect error");
74 else if (err_type == MS_MEDIA_ERR_DB_DISCONNECT_FAIL)
75 *err_msg = strdup("DB disconnect error");
76 else if (err_type == MS_MEDIA_ERR_INVALID_PARAMETER)
77 *err_msg = strdup("invalid parameter");
78 else if (err_type == MS_MEDIA_ERR_DB_INTERNAL)
79 *err_msg = strdup("DB internal error");
80 else if (err_type == MS_MEDIA_ERR_DB_NO_RECORD)
81 *err_msg = strdup("not found in DB");
82 else if (err_type == MS_MEDIA_ERR_INTERNAL)
83 *err_msg = strdup("media service internal error");
84 else if (err_type == MS_MEDIA_ERR_DB_CORRUPT)
85 *err_msg = strdup("DB corrupt error");
87 *err_msg = strdup("error unknown");
92 int connect_db(void **handle, uid_t uid, char **err_msg)
94 int ret = media_svc_connect(handle, uid, FALSE);
97 __set_error_message(ret, err_msg);
98 return MEDIA_SVC_PLUGIN_ERROR;
101 return MEDIA_SVC_PLUGIN_ERROR_NONE;
104 int disconnect_db(void *handle, char **err_msg)
106 int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
108 if (handle == NULL) {
109 __set_error_message(ERR_HANDLE, err_msg);
110 return MEDIA_SVC_PLUGIN_ERROR;
113 ret = media_svc_disconnect(handle);
115 __set_error_message(ret, err_msg);
116 return MEDIA_SVC_PLUGIN_ERROR;
119 return MEDIA_SVC_PLUGIN_ERROR_NONE;
122 int cleanup_db(void *handle, uid_t uid, char **err_msg)
124 int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
126 if (handle == NULL) {
127 __set_error_message(ERR_HANDLE, err_msg);
128 return MEDIA_SVC_PLUGIN_ERROR;
131 ret = media_svc_cleanup_db(handle, uid);
133 __set_error_message(ret, err_msg);
134 return MEDIA_SVC_PLUGIN_ERROR;
137 return MEDIA_SVC_PLUGIN_ERROR_NONE;
140 int check_item_exist(void *handle, const char *storage_id, const char *file_path, bool *modified, char **err_msg)
142 int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
145 if (handle == NULL) {
146 __set_error_message(ERR_HANDLE, err_msg);
147 return MEDIA_SVC_PLUGIN_ERROR;
150 if (!STRING_VALID(file_path)) {
151 __set_error_message(ERR_FILE_PATH, err_msg);
152 return MEDIA_SVC_PLUGIN_ERROR;
155 time_t modified_time = 0;
156 unsigned long long file_size = 0;
159 ret = media_svc_get_file_info(handle, storage_id, file_path, &modified_time, &file_size);
160 if (ret == MS_MEDIA_ERR_NONE) {
161 memset(&st, 0, sizeof(struct stat));
162 if (stat(file_path, &st) == 0) {
163 if ((st.st_mtime != modified_time) || (st.st_size != file_size))
169 return MEDIA_SVC_PLUGIN_ERROR_NONE; /*exist */
172 __set_error_message(ERR_CHECK_ITEM, err_msg);
174 return MEDIA_SVC_PLUGIN_ERROR; /*not exist */
177 int insert_item_begin(void *handle, int item_cnt, int with_noti, int from_pid, char **err_msg)
179 int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
181 ret = media_svc_insert_item_begin(item_cnt, with_noti, from_pid);
183 __set_error_message(ret, err_msg);
184 return MEDIA_SVC_PLUGIN_ERROR;
187 return MEDIA_SVC_PLUGIN_ERROR_NONE;
190 int insert_item_end(void *handle, uid_t uid, char **err_msg)
192 int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
194 ret = media_svc_insert_item_end(uid);
196 __set_error_message(ret, err_msg);
197 return MEDIA_SVC_PLUGIN_ERROR;
200 return MEDIA_SVC_PLUGIN_ERROR_NONE;
203 int insert_item(void *handle, const char *storage_id, const char *file_path, int storage_type, uid_t uid, char **err_msg)
205 int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
207 if (handle == NULL) {
208 __set_error_message(ERR_HANDLE, err_msg);
209 return MEDIA_SVC_PLUGIN_ERROR;
212 if (!STRING_VALID(file_path)) {
213 __set_error_message(ERR_FILE_PATH, err_msg);
214 return MEDIA_SVC_PLUGIN_ERROR;
217 if (!STORAGE_VALID(storage_type)) {
218 __set_error_message(ERR_STORAGE_TYPE, err_msg);
219 return MEDIA_SVC_PLUGIN_ERROR;
222 ret = media_svc_insert_item_bulk(handle, storage_id, storage_type, file_path, uid);
224 __set_error_message(ret, err_msg);
225 return MEDIA_SVC_PLUGIN_ERROR;
228 return MEDIA_SVC_PLUGIN_ERROR_NONE;
231 int set_all_storage_items_validity(void *handle, const char *storage_id, int storage_type, int validity, uid_t uid, char **err_msg)
233 int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
235 if (!STORAGE_VALID(storage_type)) {
236 __set_error_message(ERR_STORAGE_TYPE, err_msg);
237 return MEDIA_SVC_PLUGIN_ERROR;
240 ret = media_svc_set_all_storage_items_validity(storage_id, storage_type, validity, uid);
242 __set_error_message(ret, err_msg);
243 return MEDIA_SVC_PLUGIN_ERROR;
246 return MEDIA_SVC_PLUGIN_ERROR_NONE;
249 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)
251 int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
253 if (handle == NULL) {
254 __set_error_message(ERR_HANDLE, err_msg);
255 return MEDIA_SVC_PLUGIN_ERROR;
258 if (!STRING_VALID(folder_path)) {
259 __set_error_message(ERR_FOLDER_PATH, err_msg);
260 return MEDIA_SVC_PLUGIN_ERROR;
263 ret = media_svc_set_folder_items_validity(handle, storage_id, folder_path, validity, recursive, uid);
265 __set_error_message(ret, err_msg);
266 return MEDIA_SVC_PLUGIN_ERROR;
269 return MEDIA_SVC_PLUGIN_ERROR_NONE;
272 int set_item_validity_begin(void *handle, int item_cnt, char **err_msg)
274 int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
276 ret = media_svc_set_item_validity_begin(item_cnt);
278 __set_error_message(ret, err_msg);
279 return MEDIA_SVC_PLUGIN_ERROR;
282 return MEDIA_SVC_PLUGIN_ERROR_NONE;
285 int set_item_validity_end(void *handle, uid_t uid, char **err_msg)
287 int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
289 ret = media_svc_set_item_validity_end(uid);
291 __set_error_message(ret, err_msg);
292 return MEDIA_SVC_PLUGIN_ERROR;
295 return MEDIA_SVC_PLUGIN_ERROR_NONE;
298 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)
300 int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
302 if (!STRING_VALID(file_path)) {
303 __set_error_message(ERR_FILE_PATH, err_msg);
304 return MEDIA_SVC_PLUGIN_ERROR;
307 ret = media_svc_set_item_validity(storage_id, file_path, validity, uid);
310 __set_error_message(ret, err_msg);
311 return MEDIA_SVC_PLUGIN_ERROR;
314 return MEDIA_SVC_PLUGIN_ERROR_NONE;
317 int delete_item(void *handle, const char *storage_id, const char *file_path, uid_t uid, char **err_msg)
319 int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
321 if (handle == NULL) {
322 __set_error_message(ERR_HANDLE, err_msg);
323 return MEDIA_SVC_PLUGIN_ERROR;
326 if (!STRING_VALID(file_path)) {
327 __set_error_message(ERR_FILE_PATH, err_msg);
328 return MEDIA_SVC_PLUGIN_ERROR;
331 ret = media_svc_check_item_exist_by_path(handle, storage_id, file_path);
333 ret = media_svc_delete_item_by_path(handle, storage_id, file_path, uid);
336 __set_error_message(ret, err_msg);
337 return MEDIA_SVC_PLUGIN_ERROR;
339 return MEDIA_SVC_PLUGIN_ERROR_NONE;
342 __set_error_message(ERR_CHECK_ITEM, err_msg); /*not exist in DB so can't delete item. */
343 return MEDIA_SVC_PLUGIN_ERROR;
346 int delete_all_invalid_items_in_storage(void *handle, const char *storage_id, int storage_type, uid_t uid, char **err_msg)
348 int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
350 if (handle == NULL) {
351 __set_error_message(ERR_HANDLE, err_msg);
352 return MEDIA_SVC_PLUGIN_ERROR;
355 if (!STORAGE_VALID(storage_type)) {
356 __set_error_message(ERR_STORAGE_TYPE, err_msg);
357 return MEDIA_SVC_PLUGIN_ERROR;
360 ret = media_svc_delete_invalid_items_in_storage(handle, storage_id, storage_type, uid);
362 __set_error_message(ret, err_msg);
363 return MEDIA_SVC_PLUGIN_ERROR;
366 return MEDIA_SVC_PLUGIN_ERROR_NONE;
369 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)
371 int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
373 if (!STRING_VALID(dir_path)) {
374 __set_error_message(ERR_FOLDER_PATH, err_msg);
375 return MEDIA_SVC_PLUGIN_ERROR;
378 ret = media_svc_send_dir_update_noti(handle, storage_id, dir_path, folder_id, (media_item_update_type_e)update_type, pid);
380 __set_error_message(ret, err_msg);
381 return MEDIA_SVC_PLUGIN_ERROR;
384 return MEDIA_SVC_PLUGIN_ERROR_NONE;
387 int check_db(void *handle, uid_t uid, char **err_msg)
389 int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
390 int user_version = -1;
392 ret = media_svc_get_user_version(handle, &user_version);
394 __set_error_message(ret, err_msg);
395 return MEDIA_SVC_PLUGIN_ERROR;
398 if (user_version == 0) {
400 ret = media_svc_create_table(uid);
402 __set_error_message(ret, err_msg);
403 return MEDIA_SVC_PLUGIN_ERROR;
407 ret = media_svc_check_db_upgrade(handle, user_version, uid);
409 __set_error_message(ret, err_msg);
410 return MEDIA_SVC_PLUGIN_ERROR;
414 return MEDIA_SVC_PLUGIN_ERROR_NONE;
417 int update_folder_time(void *handle, const char *storage_id, char *folder_path, uid_t uid, char **err_msg)
420 return MEDIA_SVC_PLUGIN_ERROR_NONE;
423 int get_uuid(void * handle, char **uuid, char **err_msg)
425 int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
427 ret = media_svc_generate_uuid(uuid);
429 __set_error_message(ret, err_msg);
430 return MEDIA_SVC_PLUGIN_ERROR;
433 return MEDIA_SVC_PLUGIN_ERROR_NONE;
436 int check_storage(void * handle, const char *storage_id, char **storage_path, int *validity, uid_t uid, char **err_msg)
438 int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
440 if (handle == NULL) {
441 __set_error_message(ERR_HANDLE, err_msg);
442 return MEDIA_SVC_PLUGIN_ERROR;
445 ret = media_svc_check_storage(handle, storage_id, storage_path, validity, uid);
447 __set_error_message(ret, err_msg);
448 return MEDIA_SVC_PLUGIN_ERROR;
451 return MEDIA_SVC_PLUGIN_ERROR_NONE;
454 int insert_storage(void *handle, const char *storage_id, int storage_type, const char *storage_path, uid_t uid, char **err_msg)
456 int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
458 if (handle == NULL) {
459 __set_error_message(ERR_HANDLE, err_msg);
460 return MEDIA_SVC_PLUGIN_ERROR;
463 ret = media_svc_insert_storage(handle, storage_id, storage_path, storage_type, uid);
465 __set_error_message(ret, err_msg);
466 return MEDIA_SVC_PLUGIN_ERROR;
469 return MEDIA_SVC_PLUGIN_ERROR_NONE;
472 int update_storage(void *handle, const char *storage_id, const char *storage_path, uid_t uid, char **err_msg)
474 int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
476 if (handle == NULL) {
477 __set_error_message(ERR_HANDLE, err_msg);
478 return MEDIA_SVC_PLUGIN_ERROR;
481 ret = media_svc_update_storage(handle, storage_id, storage_path, uid);
483 __set_error_message(ret, err_msg);
484 return MEDIA_SVC_PLUGIN_ERROR;
487 return MEDIA_SVC_PLUGIN_ERROR_NONE;
490 int set_storage_validity(void * handle, const char *storage_id, int validity, uid_t uid, char **err_msg)
492 int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
494 if (handle == NULL) {
495 __set_error_message(ERR_HANDLE, err_msg);
496 return MEDIA_SVC_PLUGIN_ERROR;
499 ret = media_svc_set_storage_validity(handle, storage_id, validity, uid);
501 __set_error_message(ret, err_msg);
502 return MEDIA_SVC_PLUGIN_ERROR;
505 return MEDIA_SVC_PLUGIN_ERROR_NONE;
508 int set_all_storage_validity(void * handle, int validity, uid_t uid, char **err_msg)
510 int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
512 if (handle == NULL) {
513 __set_error_message(ERR_HANDLE, err_msg);
514 return MEDIA_SVC_PLUGIN_ERROR;
517 ret = media_svc_set_storage_validity(handle, NULL, validity, uid);
519 __set_error_message(ret, err_msg);
520 return MEDIA_SVC_PLUGIN_ERROR;
523 return MEDIA_SVC_PLUGIN_ERROR_NONE;
526 int get_storage_id(void * handle, const char *path, char *storage_id, uid_t uid, char **err_msg)
528 int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
530 if (handle == NULL) {
531 __set_error_message(ERR_HANDLE, err_msg);
532 return MEDIA_SVC_PLUGIN_ERROR;
535 ret = media_svc_get_storage_id(handle, path, storage_id, uid);
537 __set_error_message(ret, err_msg);
538 return MEDIA_SVC_PLUGIN_ERROR;
541 return MEDIA_SVC_PLUGIN_ERROR_NONE;
544 int set_storage_scan_status(void *handle, const char *storage_id, int status, uid_t uid, char **err_msg)
547 return MEDIA_SVC_PLUGIN_ERROR_NONE;
550 int get_storage_list(void *handle, char ***storage_list, char ***storage_id_list, int *count, char **err_msg)
552 int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
554 if (handle == NULL) {
555 __set_error_message(ERR_HANDLE, err_msg);
556 return MEDIA_SVC_PLUGIN_ERROR;
560 __set_error_message(ERR_HANDLE, err_msg);
561 return MEDIA_SVC_PLUGIN_ERROR;
564 ret = media_svc_get_storage_list(handle, storage_list, storage_id_list, count);
566 __set_error_message(ret, err_msg);
567 return MEDIA_SVC_PLUGIN_ERROR;
570 return MEDIA_SVC_PLUGIN_ERROR_NONE;
573 int update_item_begin(void *handle, int item_cnt, char **err_msg)
575 int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
577 ret = media_svc_update_item_begin(item_cnt);
579 __set_error_message(ret, err_msg);
580 return MEDIA_SVC_PLUGIN_ERROR;
583 return MEDIA_SVC_PLUGIN_ERROR_NONE;
586 int update_item_end(void *handle, uid_t uid, char **err_msg)
588 int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
590 ret = media_svc_update_item_end(uid);
592 __set_error_message(ret, err_msg);
593 return MEDIA_SVC_PLUGIN_ERROR;
596 return MEDIA_SVC_PLUGIN_ERROR_NONE;
599 int update_item_meta(void *handle, const char *file_path, const char *storage_id, int storage_type, uid_t uid, char **err_msg)
601 int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
603 if (handle == NULL) {
604 __set_error_message(ERR_HANDLE, err_msg);
605 return MEDIA_SVC_PLUGIN_ERROR;
608 if (file_path == NULL) {
609 __set_error_message(ERR_HANDLE, err_msg);
610 return MEDIA_SVC_PLUGIN_ERROR;
613 if (storage_id == NULL) {
614 __set_error_message(ERR_HANDLE, err_msg);
615 return MEDIA_SVC_PLUGIN_ERROR;
618 ret = media_svc_update_item_meta(handle, file_path, storage_id, storage_type, uid);
620 __set_error_message(ret, err_msg);
621 return MEDIA_SVC_PLUGIN_ERROR;
624 return MEDIA_SVC_PLUGIN_ERROR_NONE;
627 int insert_item_scan(void * handle, const char *storage_id, const char *file_path, int storage_type, uid_t uid, char **err_msg)
630 return MEDIA_SVC_PLUGIN_ERROR_NONE;
633 int get_extract_list(void* handle, const char* storage_id, int storage_type, int scan_type, const char* path, uid_t uid, void* array, char** err_msg)
636 return MEDIA_SVC_PLUGIN_ERROR_NONE;
639 int update_one_extract_item(void* handle, const char* storage_id, int storage_type, void* data, char** err_msg)
642 return MEDIA_SVC_PLUGIN_ERROR_NONE;
645 int query_do_update_list(void* handle, char** err_msg)
648 return MEDIA_SVC_PLUGIN_ERROR_NONE;
651 int delete_all_invalid_items_in_folder(void **handle, const char* storage_id, const char*path, bool is_recursive, uid_t uid)
654 return MEDIA_SVC_PLUGIN_ERROR_NONE;
657 int delete_invalid_folder_by_path(void **handle, const char *storage_id, const char *folder_path, uid_t uid)
660 return MEDIA_SVC_PLUGIN_ERROR_NONE;
663 int insert_folder_begin(void * handle, int item_cnt, char **err_msg)
665 int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
667 ret = media_svc_insert_folder_begin(item_cnt);
669 __set_error_message(ret, err_msg);
670 return MEDIA_SVC_PLUGIN_ERROR;
673 return MEDIA_SVC_PLUGIN_ERROR_NONE;
676 int insert_folder_end(void *handle, uid_t uid, char **err_msg)
678 int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
680 ret = media_svc_insert_folder_end(uid);
682 __set_error_message(ret, err_msg);
683 return MEDIA_SVC_PLUGIN_ERROR;
686 return MEDIA_SVC_PLUGIN_ERROR_NONE;
689 int insert_folder(void * handle, const char *storage_id, const char *file_path, int storage_type, uid_t uid, char **err_msg)
691 int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
693 if (handle == NULL) {
694 __set_error_message(ERR_HANDLE, err_msg);
695 return MEDIA_SVC_PLUGIN_ERROR;
698 if (!STRING_VALID(file_path)) {
699 __set_error_message(ERR_FILE_PATH, err_msg);
700 return MEDIA_SVC_PLUGIN_ERROR;
703 if (!STORAGE_VALID(storage_type)) {
704 __set_error_message(ERR_STORAGE_TYPE, err_msg);
705 return MEDIA_SVC_PLUGIN_ERROR;
708 ret = media_svc_insert_folder(handle, storage_id, storage_type, file_path, uid);
710 __set_error_message(ret, err_msg);
711 return MEDIA_SVC_PLUGIN_ERROR;
714 return MEDIA_SVC_PLUGIN_ERROR_NONE;
717 int delete_invalid_folder(void * handle, const char *storage_id, int storage_type, uid_t uid, char **err_msg)
719 int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
721 ret = media_svc_delete_invalid_folder(storage_id, storage_type, uid);
723 __set_error_message(ret, err_msg);
724 return MEDIA_SVC_PLUGIN_ERROR;
727 return MEDIA_SVC_PLUGIN_ERROR_NONE;
730 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)
732 int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
734 if (handle == NULL) {
735 __set_error_message(ERR_HANDLE, err_msg);
736 return MEDIA_SVC_PLUGIN_ERROR;
739 ret = media_svc_set_folder_validity(handle, storage_id, start_path, validity, is_recursive, uid);
741 __set_error_message(ret, err_msg);
742 return MEDIA_SVC_PLUGIN_ERROR;
745 return MEDIA_SVC_PLUGIN_ERROR_NONE;
748 int get_folder_scan_status(void *handle, const char *storage_id, const char *path, int *status, char **err_msg)
751 return MEDIA_SVC_PLUGIN_ERROR_NONE;
754 int set_folder_scan_status(void *handle, const char *storage_id, const char *path, int status, uid_t uid, char **err_msg)
757 return MEDIA_SVC_PLUGIN_ERROR_NONE;
760 int check_folder_modified(void *handle, const char *path, const char *storage_id, bool *modified, char **err_msg)
763 return MEDIA_SVC_PLUGIN_ERROR_NONE;
766 int get_null_scan_folder_list(void *handle, const char *storage_id, const char *folder_path, char ***folder_list, int *count, char **err_msg)
769 return MEDIA_SVC_PLUGIN_ERROR_NONE;
772 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)
775 return MEDIA_SVC_PLUGIN_ERROR_NONE;
778 int check_folder_exist(void * handle, const char *storage_id, const char *folder_path, char **err_msg)
780 int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
782 if (handle == NULL) {
783 __set_error_message(ERR_HANDLE, err_msg);
784 return MEDIA_SVC_PLUGIN_ERROR;
787 ret = media_svc_check_folder_exist_by_path(handle, storage_id, folder_path);
789 __set_error_message(ret, err_msg);
790 return MEDIA_SVC_PLUGIN_ERROR;
793 return MEDIA_SVC_PLUGIN_ERROR_NONE;
796 int get_folder_id(void * handle, const char *storage_id, const char *path, char *folder_id, char **err_msg)
798 int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
800 if (handle == NULL) {
801 __set_error_message(ERR_HANDLE, err_msg);
802 return MEDIA_SVC_PLUGIN_ERROR;
805 ret = media_svc_get_folder_id(handle, storage_id, path, folder_id);
807 __set_error_message(ret, err_msg);
808 return MEDIA_SVC_PLUGIN_ERROR;
811 return MEDIA_SVC_PLUGIN_ERROR_NONE;
814 int get_media_type(void *handle, const char *path, int *mediatype, char **err_msg)
816 int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
818 if (handle == NULL) {
819 __set_error_message(ERR_HANDLE, err_msg);
820 return MEDIA_SVC_PLUGIN_ERROR;
823 ret = media_svc_get_media_type(path, mediatype);
825 __set_error_message(ret, err_msg);
826 return MEDIA_SVC_PLUGIN_ERROR;
829 return MEDIA_SVC_PLUGIN_ERROR_NONE;