Folder related functions cleanup
[platform/core/multimedia/libmedia-service.git] / plugin / media-content-plugin.c
index 2374a36..1a6cbd9 100755 (executable)
  */
 
 #include <string.h>
-#include <sys/stat.h>
 #include <mm_file.h>
-#include <media-thumbnail.h>
+#include <media-util.h>
 #include "media-svc.h"
 #include "media-svc-util.h"
 
-#define MEDIA_SVC_PLUGIN_ERROR_NONE            0
-#define MEDIA_SVC_PLUGIN_ERROR                 -1
-
-#define STRING_VALID(str)      \
-       ((str != NULL && strlen(str) > 0) ? TRUE : FALSE)
-#define STORAGE_VALID(storage)\
-       (((storage == MEDIA_SVC_STORAGE_INTERNAL) || (storage == MEDIA_SVC_STORAGE_EXTERNAL)) ? TRUE : FALSE)
-
-
-typedef enum {
-       ERR_HANDLE = 1,
-       ERR_FILE_PATH,
-       ERR_FOLDER_PATH,
-       ERR_MIME_TYPE,
-       ERR_NOT_MEDIAFILE,
-       ERR_STORAGE_TYPE,
-       ERR_CHECK_ITEM,
-       ERR_MAX,
-} media_svc_error_type_e;
-
-static void __set_error_message(int err_type, char **err_msg);
-
-static void __set_error_message(int err_type, char **err_msg)
+int cleanup_db(sqlite3 *handle, uid_t uid)
 {
-       if (err_msg)
-               *err_msg = NULL;
-       else
-               return;
-
-       if (err_type == ERR_HANDLE)
-               *err_msg = strdup("invalid handle");
-       else if (err_type == ERR_FILE_PATH)
-               *err_msg = strdup("invalid file path");
-       else if (err_type == ERR_FOLDER_PATH)
-               *err_msg = strdup("invalid folder path");
-       else if (err_type == ERR_MIME_TYPE)
-               *err_msg = strdup("invalid mime type");
-       else if (err_type == ERR_NOT_MEDIAFILE)
-               *err_msg = strdup("not media content");
-       else if (err_type == ERR_STORAGE_TYPE)
-               *err_msg = strdup("invalid storage type");
-       else if (err_type == ERR_CHECK_ITEM)
-               *err_msg = strdup("item does not exist");
-       else if (err_type == MS_MEDIA_ERR_DB_CONNECT_FAIL)
-               *err_msg = strdup("DB connect error");
-       else if (err_type == MS_MEDIA_ERR_DB_DISCONNECT_FAIL)
-               *err_msg = strdup("DB disconnect error");
-       else if (err_type == MS_MEDIA_ERR_INVALID_PARAMETER)
-               *err_msg = strdup("invalid parameter");
-       else if (err_type == MS_MEDIA_ERR_DB_INTERNAL)
-               *err_msg = strdup("DB internal error");
-       else if (err_type == MS_MEDIA_ERR_DB_NO_RECORD)
-               *err_msg = strdup("not found in DB");
-       else if (err_type == MS_MEDIA_ERR_INTERNAL)
-               *err_msg = strdup("media service internal error");
-       else if (err_type == MS_MEDIA_ERR_DB_CORRUPT)
-               *err_msg = strdup("DB corrupt error");
-       else
-               *err_msg = strdup("error unknown");
-
-       return;
+       /* For scanner V2 */
+       return MS_MEDIA_ERR_NONE;
 }
 
-int connect_db(void **handle, uid_t uid, char **err_msg)
+int insert_item_begin(int item_cnt, bool with_noti, int from_pid)
 {
-       int ret = media_svc_connect(handle, uid);
-
-       if (ret < 0) {
-               __set_error_message(ret, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       return MEDIA_SVC_PLUGIN_ERROR_NONE;
+       return media_svc_insert_item_begin(with_noti, from_pid);
 }
 
-int disconnect_db(void *handle, char **err_msg)
+int insert_item_end(uid_t uid)
 {
-       int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
-
-       if (handle == NULL) {
-               __set_error_message(ERR_HANDLE, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       ret = media_svc_disconnect(handle);
-       if (ret < 0) {
-               __set_error_message(ret, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       return MEDIA_SVC_PLUGIN_ERROR_NONE;
+       return media_svc_insert_item_end(uid);
 }
 
-int check_item_exist(void *handle, const char *file_path, bool *modified, char **err_msg)
+int insert_item(sqlite3 *handle, const char *storage_id, const char *file_path, int storage_type, uid_t uid)
 {
-       int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
-       *modified = TRUE;
-
-       if (handle == NULL) {
-               __set_error_message(ERR_HANDLE, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       if (!STRING_VALID(file_path)) {
-               __set_error_message(ERR_FILE_PATH, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       ret = media_svc_check_item_exist_by_path(handle, file_path);
-       if (ret == MS_MEDIA_ERR_NONE) {
-               time_t modified_time = 0;
-               unsigned long long file_size = 0;
-               struct stat st;
-
-               ret = media_svc_get_file_info(handle, file_path, &modified_time, &file_size);
-               if (ret == MS_MEDIA_ERR_NONE) {
-                       memset(&st, 0, sizeof(struct stat));
-                       if (stat(file_path, &st) == 0) {
-                               if ((st.st_mtime != modified_time) || (st.st_size != file_size))
-                                       *modified = TRUE;
-                               else
-                                       *modified = FALSE;
-                       }
-               }
-
-               return MEDIA_SVC_PLUGIN_ERROR_NONE;     /*exist */
-       }
-
-       __set_error_message(ERR_CHECK_ITEM, err_msg);
-
-       return MEDIA_SVC_PLUGIN_ERROR;          /*not exist */
+       return media_svc_insert_item_bulk(handle, storage_id, storage_type, file_path, uid);
 }
 
-int insert_item_begin(void *handle, int item_cnt, int with_noti, int from_pid, char **err_msg)
+int set_item_validity_begin(int item_cnt)
 {
-       int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
-
-       if (handle == NULL) {
-               __set_error_message(ERR_HANDLE, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       ret = media_svc_insert_item_begin(handle, item_cnt, with_noti, from_pid);
-       if (ret < 0) {
-               __set_error_message(ret, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       return MEDIA_SVC_PLUGIN_ERROR_NONE;
+       /* No more need in v1 */
+       return MS_MEDIA_ERR_NONE;
 }
 
-int insert_item_end(void *handle, uid_t uid, char **err_msg)
+int set_item_validity_end(uid_t uid)
 {
-       int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
-
-       if (handle == NULL) {
-               __set_error_message(ERR_HANDLE, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       ret = media_svc_insert_item_end(handle, uid);
-       if (ret < 0) {
-               __set_error_message(ret, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       return MEDIA_SVC_PLUGIN_ERROR_NONE;
+       /* No more need in v1 */
+       return MS_MEDIA_ERR_NONE;
 }
 
-int insert_item(void *handle, const char *file_path, int storage_type, uid_t uid, char **err_msg)
+int set_item_validity(const char *storage_id, const char *file_path, int storage_type, int validity, uid_t uid)
 {
-       int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
-
-       if (handle == NULL) {
-               __set_error_message(ERR_HANDLE, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       if (!STRING_VALID(file_path)) {
-               __set_error_message(ERR_FILE_PATH, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       if (!STORAGE_VALID(storage_type)) {
-               __set_error_message(ERR_STORAGE_TYPE, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       ret = media_svc_insert_item_bulk(handle, storage_type, file_path, FALSE, uid);
-       if (ret < 0) {
-               __set_error_message(ret, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       return MEDIA_SVC_PLUGIN_ERROR_NONE;
+       return media_svc_set_item_validity(file_path, validity, uid);
 }
 
-int insert_item_immediately(void *handle, const char *file_path, int storage_type, uid_t uid, char **err_msg)
+int send_dir_update_noti(const char *dir_path, const char *folder_id, int update_type, int pid)
 {
-       int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
-
-       if (handle == NULL) {
-               __set_error_message(ERR_HANDLE, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       if (!STRING_VALID(file_path)) {
-               __set_error_message(ERR_FILE_PATH, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       if (!STORAGE_VALID(storage_type)) {
-               __set_error_message(ERR_STORAGE_TYPE, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       ret = media_svc_insert_item_immediately(handle, storage_type, file_path, uid);
-       if (ret < 0) {
-               __set_error_message(ret, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       return MEDIA_SVC_PLUGIN_ERROR_NONE;
+       return media_svc_send_dir_update_noti(dir_path, folder_id, (media_item_update_type_e)update_type, pid);
 }
 
-int insert_burst_item(void *handle, const char *file_path, int storage_type, uid_t uid, char **err_msg)
+int check_db(sqlite3 *handle, uid_t uid)
 {
-       int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
-
-       if (handle == NULL) {
-               __set_error_message(ERR_HANDLE, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
+       int ret = MS_MEDIA_ERR_NONE;
+       int user_version = -1;
 
-       if (!STRING_VALID(file_path)) {
-               __set_error_message(ERR_FILE_PATH, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
+       ret = media_svc_get_user_version(handle, &user_version);
+       if (ret != MS_MEDIA_ERR_NONE)
+               return ret;
 
-       if (!STORAGE_VALID(storage_type)) {
-               __set_error_message(ERR_STORAGE_TYPE, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       ret = media_svc_insert_item_bulk(handle, storage_type, file_path, TRUE, uid);
-       if (ret < 0) {
-               __set_error_message(ret, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
+       if (user_version == 0)
+               ret = media_svc_create_table(uid);
+       else
+               ret = media_svc_check_db_upgrade(handle, user_version, uid);
 
-       return MEDIA_SVC_PLUGIN_ERROR_NONE;
+       return ret;
 }
 
-int set_all_storage_items_validity(void *handle, int storage_type, int validity, uid_t uid, char **err_msg)
+int update_folder_time(sqlite3 *handle, const char *storage_id, char *folder_path, uid_t uid)
 {
-       int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
-
-       if (handle == NULL) {
-               __set_error_message(ERR_HANDLE, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       if (!STORAGE_VALID(storage_type)) {
-               __set_error_message(ERR_STORAGE_TYPE, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       ret = media_svc_set_all_storage_items_validity(handle, storage_type, validity, uid);
-       if (ret < 0) {
-               __set_error_message(ret, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       return MEDIA_SVC_PLUGIN_ERROR_NONE;
+       /* For scanner V2 */
+       return MS_MEDIA_ERR_NONE;
 }
 
-int set_folder_item_validity(void *handle, const char *folder_path, int validity, int recursive, uid_t uid, char **err_msg)
+int get_uuid(char **uuid)
 {
-       int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
-
-       if (handle == NULL) {
-               __set_error_message(ERR_HANDLE, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       if (!STRING_VALID(folder_path)) {
-               __set_error_message(ERR_FOLDER_PATH, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       ret = media_svc_set_folder_items_validity(handle, folder_path, validity, recursive, uid);
-       if (ret < 0) {
-               __set_error_message(ret, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       return MEDIA_SVC_PLUGIN_ERROR_NONE;
+       /* For scanner V2 */
+       return MS_MEDIA_ERR_NONE;
 }
 
-int set_item_validity_begin(void *handle, int item_cnt, char **err_msg)
+int check_storage(sqlite3 *handle, const char *storage_id, char **storage_path, int *validity, uid_t uid)
 {
-       int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
-
-       if (handle == NULL) {
-               __set_error_message(ERR_HANDLE, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       ret = media_svc_set_item_validity_begin(handle, item_cnt);
-       if (ret < 0) {
-               __set_error_message(ret, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       return MEDIA_SVC_PLUGIN_ERROR_NONE;
+       return media_svc_check_storage(handle, storage_id, storage_path, validity);
 }
 
-int set_item_validity_end(void *handle, uid_t uid, char **err_msg)
+int insert_storage(sqlite3 *handle, const char *storage_id, int storage_type, const char *storage_path, uid_t uid)
 {
-       int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
-
-       if (handle == NULL) {
-               __set_error_message(ERR_HANDLE, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       ret = media_svc_set_item_validity_end(handle, uid);
-       if (ret < 0) {
-               __set_error_message(ret, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       return MEDIA_SVC_PLUGIN_ERROR_NONE;
+       return media_svc_insert_storage(handle, storage_id, storage_path, storage_type, uid);
 }
 
-int set_item_validity(void *handle, const char *file_path, int storage_type, int validity, uid_t uid, char **err_msg)
+int update_storage(sqlite3 *handle, const char *storage_id, const char *storage_path, uid_t uid)
 {
-       int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
-
-       if (handle == NULL) {
-               __set_error_message(ERR_HANDLE, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       if (!STRING_VALID(file_path)) {
-               __set_error_message(ERR_FILE_PATH, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       if (!STORAGE_VALID(storage_type)) {
-               __set_error_message(ERR_STORAGE_TYPE, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       ret = media_svc_set_item_validity(handle, file_path, validity, uid);
-
-       if (ret < 0) {
-               __set_error_message(ret, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       return MEDIA_SVC_PLUGIN_ERROR_NONE;
+       return media_svc_update_storage(handle, storage_id, storage_path, uid);
 }
 
-int delete_item(void *handle, const char *file_path, uid_t uid, char **err_msg)
+int set_storage_validity(sqlite3 *handle, const char *storage_id, int validity, uid_t uid)
 {
-       int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
-
-       if (handle == NULL) {
-               __set_error_message(ERR_HANDLE, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       if (!STRING_VALID(file_path)) {
-               __set_error_message(ERR_FILE_PATH, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       ret = media_svc_check_item_exist_by_path(handle, file_path);
-       if (ret == 0) {
-               ret = media_svc_delete_item_by_path(handle, "media", file_path, uid);
-
-               if (ret < 0) {
-                       __set_error_message(ret, err_msg);
-                       return MEDIA_SVC_PLUGIN_ERROR;
-               } else
-                       return MEDIA_SVC_PLUGIN_ERROR_NONE;
-       }
-
-       __set_error_message(ERR_CHECK_ITEM, err_msg);   /*not exist in DB so can't delete item. */
-       return MEDIA_SVC_PLUGIN_ERROR;
+       return media_svc_set_storage_validity(handle, storage_id, validity, uid);
 }
 
-int delete_all_items_in_storage(void *handle, int storage_type, uid_t uid, char **err_msg)
+int set_all_storage_validity(sqlite3 *handle, int validity, uid_t uid)
 {
-       int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
-
-       if (handle == NULL) {
-               __set_error_message(ERR_HANDLE, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       if (!STORAGE_VALID(storage_type)) {
-               __set_error_message(ERR_STORAGE_TYPE, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       ret = media_svc_delete_all_items_in_storage(handle, storage_type, uid);
-       if (ret < 0) {
-               __set_error_message(ret, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       return MEDIA_SVC_PLUGIN_ERROR_NONE;
+       return media_svc_set_storage_validity(handle, NULL, validity, uid);
 }
 
-int delete_all_invalid_items_in_storage(void *handle, int storage_type, uid_t uid, char **err_msg)
+int get_storage_id(sqlite3 *handle, const char *path, char *storage_id, uid_t uid)
 {
-       int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
-
-       if (handle == NULL) {
-               __set_error_message(ERR_HANDLE, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       if (!STORAGE_VALID(storage_type)) {
-               __set_error_message(ERR_STORAGE_TYPE, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       ret = media_svc_delete_invalid_items_in_storage(handle, storage_type, uid);
-       if (ret < 0) {
-               __set_error_message(ret, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       return MEDIA_SVC_PLUGIN_ERROR_NONE;
+       return media_svc_get_storage_id(handle, path, storage_id, uid);
 }
 
-int delete_all_invalid_items_in_folder(void *handle, const char *folder_path, uid_t uid, char **err_msg)
+int set_storage_scan_status(sqlite3 *handle, const char *storage_id, int status, uid_t uid)
 {
-       int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
-
-       if (handle == NULL) {
-               __set_error_message(ERR_HANDLE, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       if (!STRING_VALID(folder_path)) {
-               __set_error_message(ERR_FOLDER_PATH, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       ret = media_svc_delete_invalid_items_in_folder(handle, folder_path, uid);
-       if (ret < 0) {
-               __set_error_message(ret, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       return MEDIA_SVC_PLUGIN_ERROR_NONE;
+       /* For scanner V2 */
+       return MS_MEDIA_ERR_NONE;
 }
 
-
-int update_begin(void)
+int update_item_meta(sqlite3 *handle, uid_t uid)
 {
-       return MEDIA_SVC_PLUGIN_ERROR_NONE;
+       return media_svc_update_item_meta(handle, uid);
 }
 
-int update_end(uid_t uid)
+int insert_item_scan(sqlite3 *handle, const char *storage_id, const char *file_path, int storage_type, uid_t uid)
 {
-       int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
-
-       ret = thumbnail_request_extract_all_thumbs(uid);
-       if (ret < 0) {
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       return MEDIA_SVC_PLUGIN_ERROR_NONE;
+       /* For scanner V2 */
+       return MS_MEDIA_ERR_NONE;
 }
 
-int send_dir_update_noti(void *handle, const char *dir_path, char **err_msg)
+int get_extract_list(sqlite3* handle, const char* storage_id, int storage_type, int scan_type, const char* path, int burst, uid_t uid, void* array)
 {
-       int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
-
-       if (!STRING_VALID(dir_path)) {
-               __set_error_message(ERR_FOLDER_PATH, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       ret = media_svc_send_dir_update_noti(handle, dir_path);
-       if (ret < 0) {
-               __set_error_message(ret, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       return MEDIA_SVC_PLUGIN_ERROR_NONE;
+       /* For scanner V2 */
+       return MS_MEDIA_ERR_NONE;
 }
 
-int count_delete_items_in_folder(void *handle, const char *folder_path, int *count, char **err_msg)
+int update_one_extract_item(sqlite3* handle, const char* storage_id, int storage_type, void* data)
 {
-       int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
-
-       if (handle == NULL) {
-               __set_error_message(ERR_HANDLE, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       if (count == NULL) {
-               __set_error_message(ERR_HANDLE, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       if (!STRING_VALID(folder_path)) {
-               __set_error_message(ERR_FOLDER_PATH, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       ret = media_svc_count_invalid_items_in_folder(handle, folder_path, count);
-       if (ret < 0) {
-               __set_error_message(ret, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       return MEDIA_SVC_PLUGIN_ERROR_NONE;
+       /* For scanner V2 */
+       return MS_MEDIA_ERR_NONE;
 }
 
-int check_db(void *handle, uid_t uid, char **err_msg)
+int query_do_update_list(sqlite3* handle)
 {
-       int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
-
-       /*check db schema*/
-       ret = media_svc_create_table(handle, uid);
-       if (ret < 0) {
-               __set_error_message(ret, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       /*check db version*/
-       ret = media_svc_check_db_upgrade(handle, uid);
-       if (ret < 0) {
-               __set_error_message(ret, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       return MEDIA_SVC_PLUGIN_ERROR_NONE;
+       /* For scanner V2 */
+       return MS_MEDIA_ERR_NONE;
 }
 
-int check_db_corrupt(void *handle, char **err_msg)
+int delete_all_invalid_items_in_folder(sqlite3 *handle, const char* storage_id, const char*path, bool is_recursive, uid_t uid)
 {
-       int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
-
-       /*check db version*/
-       ret = media_svc_check_db_corrupt(handle);
-       if (ret < 0) {
-               __set_error_message(ret, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       return MEDIA_SVC_PLUGIN_ERROR_NONE;
+       /* For scanner V2 */
+       return MS_MEDIA_ERR_NONE;
 }
 
-int get_folder_list(void *handle, char *start_path, char ***folder_list, int **modified_time_list, int **item_num_list, int *count, char **err_msg)
+int delete_invalid_folder_by_path(sqlite3 *handle, const char *storage_id, const char *folder_path, uid_t uid)
 {
-       int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
-
-       if (handle == NULL) {
-               __set_error_message(ERR_HANDLE, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       if (count == NULL) {
-               __set_error_message(ERR_HANDLE, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       ret = media_svc_get_folder_list(handle, start_path, folder_list, (time_t **)modified_time_list, item_num_list, count);
-       if (ret < 0) {
-               __set_error_message(ret, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       return MEDIA_SVC_PLUGIN_ERROR_NONE;
+       /* For scanner V2 */
+       return MS_MEDIA_ERR_NONE;
 }
 
-int update_folder_time(void *handle, char *folder_path, uid_t uid, char **err_msg)
+int insert_folder_begin(int item_cnt)
 {
-       int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
-
-       if (handle == NULL) {
-               __set_error_message(ERR_HANDLE, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       if (folder_path == NULL) {
-               __set_error_message(ERR_HANDLE, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       ret = media_svc_update_folder_time(handle, folder_path, uid);
-       if (ret < 0) {
-               __set_error_message(ret, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
-
-       return MEDIA_SVC_PLUGIN_ERROR_NONE;
+       /* For scanner V2 */
+       return MS_MEDIA_ERR_NONE;
 }
 
-int update_item_begin(void *handle, int item_cnt, char **err_msg)
+int insert_folder_end(uid_t uid)
 {
-       int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
+       /* For scanner V2 */
+       return MS_MEDIA_ERR_NONE;
+}
 
-       if (handle == NULL) {
-               __set_error_message(ERR_HANDLE, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
+int insert_folder(sqlite3 *handle, const char *storage_id, const char *file_path, int storage_type, uid_t uid)
+{
+       return media_svc_insert_folder(handle, storage_id, storage_type, file_path, uid);
+}
 
-       ret = media_svc_update_item_begin(handle, item_cnt);
-       if (ret < 0) {
-               __set_error_message(ret, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
+int set_folder_validity(sqlite3 *handle, const char *storage_id, const char* start_path, int validity, bool is_recursive, uid_t uid)
+{
+       return media_svc_set_folder_validity(storage_id, start_path, validity, is_recursive, uid);
+}
 
-       return MEDIA_SVC_PLUGIN_ERROR_NONE;
+int get_folder_scan_status(sqlite3 *handle, const char *storage_id, const char *path, int *status)
+{
+       /* For scanner V2 */
+       return MS_MEDIA_ERR_NONE;
 }
 
-int update_item_end(void *handle, uid_t uid, char **err_msg)
+int set_folder_scan_status(sqlite3 *handle, const char *storage_id, const char *path, int status, uid_t uid)
 {
-       int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
+       /* For scanner V2 */
+       return MS_MEDIA_ERR_NONE;
+}
 
-       if (handle == NULL) {
-               __set_error_message(ERR_HANDLE, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
+int check_folder_modified(sqlite3 *handle, const char *path, const char *storage_id, bool *modified)
+{
+       /* For scanner V2 */
+       return MS_MEDIA_ERR_NONE;
+}
 
-       ret = media_svc_update_item_end(handle, uid);
-       if (ret < 0) {
-               __set_error_message(ret, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
+int get_null_scan_folder_list(sqlite3 *handle, const char *storage_id, const char *folder_path, char ***folder_list, int *count)
+{
+       /* For scanner V2 */
+       return MS_MEDIA_ERR_NONE;
+}
 
-       return MEDIA_SVC_PLUGIN_ERROR_NONE;
+int change_validity_item_batch(sqlite3 *handle, const char *storage_id, const char *path, int des_validity, int src_validity, uid_t uid)
+{
+       /* For scanner V2 */
+       return MS_MEDIA_ERR_NONE;
 }
 
-int update_item_meta(void *handle, const char *file_path, int storage_type, uid_t uid, char **err_msg)
+int check_folder_exist(sqlite3 *handle, const char *storage_id, const char *folder_path)
 {
-       int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
+       return media_svc_check_folder_exist_by_path(handle, storage_id, folder_path);
+}
 
-       if (handle == NULL) {
-               __set_error_message(ERR_HANDLE, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
+int get_media_type(const char *path, int *mediatype)
+{
+       return media_svc_get_media_type(path, mediatype);
+}
 
-       if (file_path == NULL) {
-               __set_error_message(ERR_HANDLE, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
+int refresh_item(sqlite3 *handle, const char *storage_id, const char *path, uid_t uid)
+{
+       int ret = MS_MEDIA_ERR_NONE;
+       ms_user_storage_type_e storage_type = MS_USER_STORAGE_INTERNAL;
 
-       ret = media_svc_update_item_meta(handle, file_path, storage_type, uid);
-       if (ret < 0) {
-               __set_error_message(ret, err_msg);
-               return MEDIA_SVC_PLUGIN_ERROR;
-       }
+       ret = ms_user_get_storage_type(uid, path, &storage_type);
+       if (ret != MS_MEDIA_ERR_NONE)
+               return ret;
 
-       return MEDIA_SVC_PLUGIN_ERROR_NONE;
+       return media_svc_refresh_item(handle, true, storage_id, storage_type, path, uid);
 }