Modify external storage scansubmit/tizen/20150904.055949accepted/tizen/wearable/20150904.064350accepted/tizen/tv/20150904.064338accepted/tizen/mobile/20150904.064324

Change-Id: Iffe6bbe797712efecd6cf928c3bbc68256df8eb2
Signed-off-by: Minje Ahn <minje.ahn@samsung.com>

18 files changed, 2736 insertions, 794 deletions

diff --git a/include/media-svc-types.h b/include/media-svc-types.h
index 0b99685..914fd6b 100755
--- a/include/media-svc-types.h
+++ b/include/media-svc-types.h
@@ -32,10 +32,11 @@ typedef void MediaSvcHandle;		/**< Handle */
  * Type definition for storage type
  */
 typedef enum {
-	MEDIA_SVC_STORAGE_INTERNAL = 0,			/**< Internal storage*/
-	MEDIA_SVC_STORAGE_EXTERNAL = 1,			/**< External storage*/
-	MEDIA_SVC_STORAGE_CLOUD = 100,			/**< Cloud Storage*/
-	MEDIA_SVC_STORAGE_MAX,					/**< Invalid storage*/
+	MEDIA_SVC_STORAGE_INTERNAL = 0,		/**< The device's internal storage */
+	MEDIA_SVC_STORAGE_EXTERNAL = 1,		/**< The device's external storage like sd card*/
+	MEDIA_SVC_STORAGE_EXTERNAL_USB = 2,	/**< The external USB storage (Since 2.4) */
+	MEDIA_SVC_STORAGE_CLOUD = 100,		/**< The Cloud storage (Since 2.4) */
+	MEDIA_SVC_STORAGE_MAX,				/**< Invalid storage*/
 } media_svc_storage_type_e;
 
 /**
@@ -122,4 +123,15 @@ typedef struct {
 	media_svc_content_meta_s	media_meta;	/**< meta data structure for audio files */
 } media_svc_content_info_s;
 
+/**
+ * Type definition for scanning status
+ */
+typedef enum{
+	MEDIA_SVC_SCAN_PREPARE		= 0,	/**< Prepare scanning*/
+	MEDIA_SVC_SCAN_PROCESSING	= 1,	/**< Process scanning*/
+	MEDIA_SVC_SCAN_STOP			= 2,	/**< Stop scanning*/
+	MEDIA_SVC_SCAN_COMPLETE		= 3,	/**< Complete scanning*/
+	MEDIA_SVC_SCAN_MAX			= 4,	/**< Invalid status*/
+}media_svc_scan_status_type_e;
+
 #endif /*_MEDIA_SVC_TYPES_H_*/
diff --git a/include/media-svc.h b/include/media-svc.h
index 30893fe..5a77ecf 100755
--- a/include/media-svc.h
+++ b/include/media-svc.h
@@ -36,32 +36,34 @@ extern "C" {
 int media_svc_connect(MediaSvcHandle **handle, uid_t uid, bool need_write);
 int media_svc_disconnect(MediaSvcHandle *handle);
 int media_svc_create_table(MediaSvcHandle *handle, uid_t uid);
-int media_svc_check_item_exist_by_path(MediaSvcHandle *handle, const char *path);
-int media_svc_insert_folder(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, const char *path, uid_t uid);
+int media_svc_check_item_exist_by_path(MediaSvcHandle *handle, const char *storage_id, const char *path);
+int media_svc_insert_folder(MediaSvcHandle *handle, const char *storage_id, media_svc_storage_type_e storage_type, const char *path, uid_t uid);
 int media_svc_insert_item_begin(MediaSvcHandle *handle, int with_noti, int data_cnt, int from_pid);
 int media_svc_insert_item_end(MediaSvcHandle *handle, uid_t uid);
-int media_svc_insert_item_bulk(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, const char *path, int is_burst, uid_t uid);
-int media_svc_insert_item_immediately(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, const char *path, uid_t uid);
+int media_svc_insert_item_bulk(MediaSvcHandle *handle, const char *storage_id, media_svc_storage_type_e storage_type, const char *path, int is_burst, uid_t uid);
+int media_svc_insert_item_immediately(MediaSvcHandle *handle, const char *storage_id, media_svc_storage_type_e storage_type, const char *path, uid_t uid);
+#if 0
 int media_svc_move_item_begin(MediaSvcHandle *handle, int data_cnt);
 int media_svc_move_item_end(MediaSvcHandle *handle, uid_t uid);
-int media_svc_move_item(MediaSvcHandle *handle, media_svc_storage_type_e src_storage, const char *src_path, media_svc_storage_type_e dest_storage, const char *dest_path, uid_t uid);
+#endif
+int media_svc_move_item(MediaSvcHandle *handle, const char *storage_id, media_svc_storage_type_e src_storage, const char *src_path, media_svc_storage_type_e dest_storage, const char *dest_path, uid_t uid);
 int media_svc_set_item_validity_begin(MediaSvcHandle *handle, int data_cnt);
 int media_svc_set_item_validity_end(MediaSvcHandle *handle, uid_t uid);
-int media_svc_set_item_validity(MediaSvcHandle *handle, const char *path, int validity, uid_t uid);
+int media_svc_set_item_validity(MediaSvcHandle *handle, const char *storage_id, const char *path, int validity, uid_t uid);
 int media_svc_delete_item_by_path(MediaSvcHandle *handle, const char *storage_id, const char *path, uid_t uid);
-int media_svc_delete_all_items_in_storage(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, uid_t uid);
-int media_svc_delete_invalid_items_in_storage(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, uid_t uid);
-int media_svc_delete_invalid_items_in_folder(MediaSvcHandle *handle, const char *folder_path, uid_t uid);
-int media_svc_set_all_storage_items_validity(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, int validity, uid_t uid);
-int media_svc_set_folder_items_validity(MediaSvcHandle *handle, const char *folder_path, int validity, int recursive, uid_t uid);
-int media_svc_refresh_item(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, const char *storage_id, const char *path, uid_t uid);
+int media_svc_delete_all_items_in_storage(MediaSvcHandle *handle, const char *storage_id, media_svc_storage_type_e storage_type, uid_t uid);
+int media_svc_delete_invalid_items_in_storage(MediaSvcHandle *handle, const char *storage_id, media_svc_storage_type_e storage_type, uid_t uid);
+int media_svc_delete_invalid_items_in_folder(MediaSvcHandle *handle, const char *storage_id, const char *folder_path, bool is_recursive, uid_t uid);
+int media_svc_set_all_storage_items_validity(MediaSvcHandle *handle, const char *storage_id, media_svc_storage_type_e storage_type, int validity, uid_t uid);
+int media_svc_set_folder_items_validity(MediaSvcHandle *handle, const char *storage_id, const char *folder_path, int validity, int recursive, uid_t uid);
+int media_svc_refresh_item(MediaSvcHandle *handle, const char *storage_id, media_svc_storage_type_e storage_type, const char *path, uid_t uid);
 int media_svc_rename_folder(MediaSvcHandle *handle, const char *storage_id, const char *src_path, const char *dst_path, uid_t uid);
 int media_svc_request_update_db(const char *db_query, uid_t uid);
 int media_svc_get_storage_type(const char *path, media_svc_storage_type_e *storage_type, uid_t uid);
-int media_svc_get_file_info(MediaSvcHandle *handle, const char *path, time_t *modified_time, unsigned long long *size);
-int media_svc_send_dir_update_noti(MediaSvcHandle *handle, const char *dir_path);
-int media_svc_count_invalid_items_in_folder(MediaSvcHandle *handle, const char *folder_path, int *count);
-int media_svc_check_db_upgrade(MediaSvcHandle *handle, uid_t uid);
+int media_svc_get_file_info(MediaSvcHandle *handle, const char *storage_id, const char *path, time_t *modified_time, unsigned long long *size);
+int media_svc_send_dir_update_noti(MediaSvcHandle *handle, const char *storage_id, const char *dir_path);
+int media_svc_count_invalid_items_in_folder(MediaSvcHandle *handle, const char *storage_id, const char *folder_path, int *count);
+int media_svc_check_db_upgrade(MediaSvcHandle *handle, bool *need_full_scan, uid_t uid);
 int media_svc_check_db_corrupt(MediaSvcHandle *handle);
 int media_svc_get_folder_list(MediaSvcHandle *handle, char *start_path, char ***folder_list, time_t **modified_time_list, int **item_num_list, int *count);
 int media_svc_update_folder_time(MediaSvcHandle *handle, const char *folder_path, uid_t uid);
@@ -73,13 +75,27 @@ int media_svc_update_item_end(MediaSvcHandle *handle, uid_t uid);
 int media_svc_update_item_meta(MediaSvcHandle *handle, const char *file_path, int storage_type, uid_t uid);
 int media_svc_insert_item_immediately_with_data(MediaSvcHandle *handle, media_svc_content_info_s *content_info, uid_t uid);
 void media_svc_destroy_content_info(media_svc_content_info_s *content_info);
-char *media_info_generate_uuid(void);
-int media_svc_insert_storage(MediaSvcHandle *handle, const char *storage_id, const char *storage_name, const char *storage_path, const char *storage_account, media_svc_storage_type_e storage_type, uid_t uid);
-int media_svc_delete_storage(MediaSvcHandle *handle, const char *storage_id, uid_t uid);
-int media_svc_request_extract_all_thumbs(uid_t uid);
 
+int media_svc_generate_uuid(char **uuid);
+int media_svc_get_mmc_info(MediaSvcHandle *handle, char **storage_name, char **storage_path, int *validity, bool *info_exist);
+int media_svc_check_storage(MediaSvcHandle *handle, const char *storage_id, const char *storage_name, char **storage_path, int *validity);
+int media_svc_insert_storage(MediaSvcHandle *handle, const char *storage_id, const char *storage_name, const char *storage_path, const char *storage_account, media_svc_storage_type_e storage_type, uid_t uid);
+int media_svc_update_storage(MediaSvcHandle *handle, const char *storage_id, const char *storage_path, uid_t uid);
+int media_svc_delete_storage(MediaSvcHandle *handle, const char *storage_id, const char *storage_name, uid_t uid);
+int media_svc_set_storage_validity(MediaSvcHandle *handle, const char *storage_id, int validity, uid_t uid);
+int media_svc_get_storage_id(MediaSvcHandle *handle, const char *path, char *storage_id);
+int media_svc_get_storage_path(MediaSvcHandle *handle, const char *storage_uuid, char **storage_path);
+int media_svc_get_storage_scan_status(MediaSvcHandle *handle, const char *storage_uuid, media_svc_scan_status_type_e *storage_status);
+int media_svc_set_storage_scan_status(MediaSvcHandle *handle, const char *storage_uuid, media_svc_scan_status_type_e storage_status, uid_t uid);
+int media_svc_get_storage_list(MediaSvcHandle *handle, char ***storage_list, char ***storage_id_list, int **scan_status_list, int *count);
+int media_svc_delete_invalid_folder(MediaSvcHandle *handle, const char *storage_id, uid_t uid);
+int media_svc_set_folder_validity(MediaSvcHandle *handle, const char *storage_id, const char *start_path, int validity, bool is_recursive, uid_t uid);
 
+int media_svc_insert_item_pass1(MediaSvcHandle *handle, const char *storage_id, media_svc_storage_type_e storage_type, const char *path, int is_burst, uid_t uid);
+int media_svc_insert_item_pass2(MediaSvcHandle *handle, const char *storage_id, media_svc_storage_type_e storage_type, int scan_type, const char* extract_path, int is_burst, uid_t uid);
 
+int media_svc_insert_folder_begin(MediaSvcHandle *handle, int data_cnt);
+int media_svc_insert_folder_end(MediaSvcHandle *handle, uid_t uid);
 
 #ifdef __cplusplus
 }
diff --git a/plugin/media-content-plugin.c b/plugin/media-content-plugin.c
index 40480ae..a31d457 100755
--- a/plugin/media-content-plugin.c
+++ b/plugin/media-content-plugin.c
@@ -32,7 +32,7 @@
 #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)
+	(((storage == MEDIA_SVC_STORAGE_INTERNAL) || (storage == MEDIA_SVC_STORAGE_EXTERNAL) || (storage == MEDIA_SVC_STORAGE_EXTERNAL_USB)) ? TRUE : FALSE)
 
 
 typedef enum {
@@ -119,7 +119,7 @@ int disconnect_db(void *handle, char **err_msg)
 	return MEDIA_SVC_PLUGIN_ERROR_NONE;
 }
 
-int check_item_exist(void *handle, const char *file_path, bool *modified, char **err_msg)
+int check_item_exist(void *handle, const char *storage_id, const char *file_path, bool *modified, char **err_msg)
 {
 	int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 	*modified = TRUE;
@@ -134,21 +134,18 @@ int check_item_exist(void *handle, const char *file_path, bool *modified, char *
 		return MEDIA_SVC_PLUGIN_ERROR;
 	}
 
-	ret = media_svc_check_item_exist_by_path(handle, file_path);
+	time_t modified_time = 0;
+	unsigned long long file_size = 0;
+	struct stat st;
+
+	ret = media_svc_get_file_info(handle, storage_id, file_path, &modified_time, &file_size);
 	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;
-			}
+		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 */
@@ -195,7 +192,7 @@ int insert_item_end(void *handle, uid_t uid, char **err_msg)
 	return MEDIA_SVC_PLUGIN_ERROR_NONE;
 }
 
-int insert_item(void *handle, const char *file_path, int storage_type, uid_t uid, char **err_msg)
+int insert_item(void *handle, const char *storage_id, const char *file_path, int storage_type, uid_t uid, char **err_msg)
 {
 	int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 
@@ -214,7 +211,7 @@ int insert_item(void *handle, const char *file_path, int storage_type, uid_t uid
 		return MEDIA_SVC_PLUGIN_ERROR;
 	}
 
-	ret = media_svc_insert_item_bulk(handle, storage_type, file_path, FALSE, uid);
+	ret = media_svc_insert_item_bulk(handle, storage_id, storage_type, file_path, FALSE, uid);
 	if (ret < 0) {
 		__set_error_message(ret, err_msg);
 		return MEDIA_SVC_PLUGIN_ERROR;
@@ -223,7 +220,7 @@ int insert_item(void *handle, const char *file_path, int storage_type, uid_t uid
 	return MEDIA_SVC_PLUGIN_ERROR_NONE;
 }
 
-int insert_item_immediately(void *handle, const char *file_path, int storage_type, uid_t uid, char **err_msg)
+int insert_item_immediately(void *handle, const char *storage_id, const char *file_path, int storage_type, uid_t uid, char **err_msg)
 {
 	int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 
@@ -242,7 +239,7 @@ int insert_item_immediately(void *handle, const char *file_path, int storage_typ
 		return MEDIA_SVC_PLUGIN_ERROR;
 	}
 
-	ret = media_svc_insert_item_immediately(handle, storage_type, file_path, uid);
+	ret = media_svc_insert_item_immediately(handle, storage_id, storage_type, file_path, uid);
 	if (ret < 0) {
 		__set_error_message(ret, err_msg);
 		return MEDIA_SVC_PLUGIN_ERROR;
@@ -251,7 +248,7 @@ int insert_item_immediately(void *handle, const char *file_path, int storage_typ
 	return MEDIA_SVC_PLUGIN_ERROR_NONE;
 }
 
-int insert_burst_item(void *handle, const char *file_path, int storage_type, uid_t uid, char **err_msg)
+int insert_burst_item(void *handle, const char *storage_id, const char *file_path, int storage_type, uid_t uid, char **err_msg)
 {
 	int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 
@@ -270,7 +267,7 @@ int insert_burst_item(void *handle, const char *file_path, int storage_type, uid
 		return MEDIA_SVC_PLUGIN_ERROR;
 	}
 
-	ret = media_svc_insert_item_bulk(handle, storage_type, file_path, TRUE, uid);
+	ret = media_svc_insert_item_bulk(handle, storage_id, storage_type, file_path, TRUE, uid);
 	if (ret < 0) {
 		__set_error_message(ret, err_msg);
 		return MEDIA_SVC_PLUGIN_ERROR;
@@ -279,7 +276,7 @@ int insert_burst_item(void *handle, const char *file_path, int storage_type, uid
 	return MEDIA_SVC_PLUGIN_ERROR_NONE;
 }
 
-int set_all_storage_items_validity(void *handle, int storage_type, int validity, uid_t uid, char **err_msg)
+int set_all_storage_items_validity(void *handle,  const char *storage_id, int storage_type, int validity, uid_t uid, char **err_msg)
 {
 	int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 
@@ -293,7 +290,7 @@ int set_all_storage_items_validity(void *handle, int storage_type, int validity,
 		return MEDIA_SVC_PLUGIN_ERROR;
 	}
 
-	ret = media_svc_set_all_storage_items_validity(handle, storage_type, validity, uid);
+	ret = media_svc_set_all_storage_items_validity(handle, storage_id, storage_type, validity, uid);
 	if (ret < 0) {
 		__set_error_message(ret, err_msg);
 		return MEDIA_SVC_PLUGIN_ERROR;
@@ -302,7 +299,7 @@ int set_all_storage_items_validity(void *handle, int storage_type, int validity,
 	return MEDIA_SVC_PLUGIN_ERROR_NONE;
 }
 
-int set_folder_item_validity(void *handle, const char *folder_path, int validity, int recursive, uid_t uid, char **err_msg)
+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)
 {
 	int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 
@@ -316,7 +313,7 @@ int set_folder_item_validity(void *handle, const char *folder_path, int validity
 		return MEDIA_SVC_PLUGIN_ERROR;
 	}
 
-	ret = media_svc_set_folder_items_validity(handle, folder_path, validity, recursive, uid);
+	ret = media_svc_set_folder_items_validity(handle, storage_id, folder_path, validity, recursive, uid);
 	if (ret < 0) {
 		__set_error_message(ret, err_msg);
 		return MEDIA_SVC_PLUGIN_ERROR;
@@ -361,7 +358,7 @@ int set_item_validity_end(void *handle, uid_t uid, char **err_msg)
 	return MEDIA_SVC_PLUGIN_ERROR_NONE;
 }
 
-int set_item_validity(void *handle, const char *file_path, int storage_type, int validity, uid_t uid, char **err_msg)
+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)
 {
 	int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 
@@ -375,12 +372,7 @@ int set_item_validity(void *handle, const char *file_path, int storage_type, int
 		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);
+	ret = media_svc_set_item_validity(handle, storage_id, file_path, validity, uid);
 
 	if (ret < 0) {
 		__set_error_message(ret, err_msg);
@@ -390,7 +382,7 @@ int set_item_validity(void *handle, const char *file_path, int storage_type, int
 	return MEDIA_SVC_PLUGIN_ERROR_NONE;
 }
 
-int delete_item(void *handle, const char *file_path, uid_t uid, char **err_msg)
+int delete_item(void *handle, const char *storage_id, const char *file_path, uid_t uid, char **err_msg)
 {
 	int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 
@@ -404,9 +396,9 @@ int delete_item(void *handle, const char *file_path, uid_t uid, char **err_msg)
 		return MEDIA_SVC_PLUGIN_ERROR;
 	}
 
-	ret = media_svc_check_item_exist_by_path(handle, file_path);
+	ret = media_svc_check_item_exist_by_path(handle, storage_id, file_path);
 	if (ret == 0) {
-		ret = media_svc_delete_item_by_path(handle, "media", file_path, uid);
+		ret = media_svc_delete_item_by_path(handle, storage_id, file_path, uid);
 
 		if (ret < 0) {
 			__set_error_message(ret, err_msg);
@@ -419,7 +411,7 @@ int delete_item(void *handle, const char *file_path, uid_t uid, char **err_msg)
 	return MEDIA_SVC_PLUGIN_ERROR;
 }
 
-int delete_all_items_in_storage(void *handle, int storage_type, uid_t uid, char **err_msg)
+int delete_all_items_in_storage(void *handle, const char *storage_id, int storage_type, uid_t uid, char **err_msg)
 {
 	int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 
@@ -433,7 +425,7 @@ int delete_all_items_in_storage(void *handle, int storage_type, uid_t uid, char
 		return MEDIA_SVC_PLUGIN_ERROR;
 	}
 
-	ret = media_svc_delete_all_items_in_storage(handle, storage_type, uid);
+	ret = media_svc_delete_all_items_in_storage(handle, storage_id, storage_type, uid);
 	if (ret < 0) {
 		__set_error_message(ret, err_msg);
 		return MEDIA_SVC_PLUGIN_ERROR;
@@ -442,7 +434,7 @@ int delete_all_items_in_storage(void *handle, int storage_type, uid_t uid, char
 	return MEDIA_SVC_PLUGIN_ERROR_NONE;
 }
 
-int delete_all_invalid_items_in_storage(void *handle, int storage_type, uid_t uid, char **err_msg)
+int delete_all_invalid_items_in_storage(void *handle, const char *storage_id, int storage_type, uid_t uid, char **err_msg)
 {
 	int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 
@@ -456,7 +448,7 @@ int delete_all_invalid_items_in_storage(void *handle, int storage_type, uid_t ui
 		return MEDIA_SVC_PLUGIN_ERROR;
 	}
 
-	ret = media_svc_delete_invalid_items_in_storage(handle, storage_type, uid);
+	ret = media_svc_delete_invalid_items_in_storage(handle, storage_id, storage_type, uid);
 	if (ret < 0) {
 		__set_error_message(ret, err_msg);
 		return MEDIA_SVC_PLUGIN_ERROR;
@@ -465,7 +457,7 @@ int delete_all_invalid_items_in_storage(void *handle, int storage_type, uid_t ui
 	return MEDIA_SVC_PLUGIN_ERROR_NONE;
 }
 
-int delete_all_invalid_items_in_folder(void *handle, const char *folder_path, uid_t uid, char **err_msg)
+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)
 {
 	int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 
@@ -479,7 +471,7 @@ int delete_all_invalid_items_in_folder(void *handle, const char *folder_path, ui
 		return MEDIA_SVC_PLUGIN_ERROR;
 	}
 
-	ret = media_svc_delete_invalid_items_in_folder(handle, folder_path, uid);
+	ret = media_svc_delete_invalid_items_in_folder(handle, storage_id, folder_path, is_recursve, uid);
 	if (ret < 0) {
 		__set_error_message(ret, err_msg);
 		return MEDIA_SVC_PLUGIN_ERROR;
@@ -494,7 +486,7 @@ int update_begin(void)
 	return MEDIA_SVC_PLUGIN_ERROR_NONE;
 }
 
-int update_end(uid_t uid)
+int update_end(const char *start_path, uid_t uid)
 {
 	int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 
@@ -506,7 +498,7 @@ int update_end(uid_t uid)
 	return MEDIA_SVC_PLUGIN_ERROR_NONE;
 }
 
-int send_dir_update_noti(void *handle, const char *dir_path, char **err_msg)
+int send_dir_update_noti(void *handle, const char *storage_id, const char *dir_path, char **err_msg)
 {
 	int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 
@@ -515,7 +507,7 @@ int send_dir_update_noti(void *handle, const char *dir_path, char **err_msg)
 		return MEDIA_SVC_PLUGIN_ERROR;
 	}
 
-	ret = media_svc_send_dir_update_noti(handle, dir_path);
+	ret = media_svc_send_dir_update_noti(handle, storage_id, dir_path);
 	if (ret < 0) {
 		__set_error_message(ret, err_msg);
 		return MEDIA_SVC_PLUGIN_ERROR;
@@ -524,7 +516,7 @@ int send_dir_update_noti(void *handle, const char *dir_path, char **err_msg)
 	return MEDIA_SVC_PLUGIN_ERROR_NONE;
 }
 
-int count_delete_items_in_folder(void *handle, const char *folder_path, int *count, char **err_msg)
+int count_delete_items_in_folder(void *handle, const char *storage_id, const char *folder_path, int *count, char **err_msg)
 {
 	int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 
@@ -543,7 +535,7 @@ int count_delete_items_in_folder(void *handle, const char *folder_path, int *cou
 		return MEDIA_SVC_PLUGIN_ERROR;
 	}
 
-	ret = media_svc_count_invalid_items_in_folder(handle, folder_path, count);
+	ret = media_svc_count_invalid_items_in_folder(handle, storage_id, folder_path, count);
 	if (ret < 0) {
 		__set_error_message(ret, err_msg);
 		return MEDIA_SVC_PLUGIN_ERROR;
@@ -552,7 +544,7 @@ int count_delete_items_in_folder(void *handle, const char *folder_path, int *cou
 	return MEDIA_SVC_PLUGIN_ERROR_NONE;
 }
 
-int check_db(void *handle, uid_t uid, char **err_msg)
+int check_db(void *handle, bool *need_full_scan, uid_t uid, char **err_msg)
 {
 	int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 
@@ -564,7 +556,7 @@ int check_db(void *handle, uid_t uid, char **err_msg)
 	}
 
 	/*check db version*/
-	ret = media_svc_check_db_upgrade(handle, uid);
+	ret = media_svc_check_db_upgrade(handle, need_full_scan, uid);
 	if (ret < 0) {
 		__set_error_message(ret, err_msg);
 		return MEDIA_SVC_PLUGIN_ERROR;
@@ -587,7 +579,7 @@ int check_db_corrupt(void *handle, char **err_msg)
 	return MEDIA_SVC_PLUGIN_ERROR_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 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)
 {
 	int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
 
@@ -633,6 +625,231 @@ int update_folder_time(void *handle, char *folder_path, uid_t uid, char **err_ms
 	return MEDIA_SVC_PLUGIN_ERROR_NONE;
 }
 
+int get_uuid(void * handle, char **uuid, char **err_msg)
+{
+	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_generate_uuid(uuid);
+	if(ret < 0) {
+		__set_error_message(ret, err_msg);
+		return MEDIA_SVC_PLUGIN_ERROR;
+	}
+
+	return MEDIA_SVC_PLUGIN_ERROR_NONE;
+}
+
+int get_mmc_info(void * handle, char **storage_name, char **storage_path, int *validity, bool *info_exist, char **err_msg)
+{
+	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_get_mmc_info(handle, storage_name, storage_path, validity, info_exist);
+	if(ret < 0) {
+		__set_error_message(MS_MEDIA_ERR_DB_NO_RECORD, err_msg);
+		return MEDIA_SVC_PLUGIN_ERROR;
+	}
+
+	return MEDIA_SVC_PLUGIN_ERROR_NONE;
+}
+
+int check_storage(void * handle, const char *storage_id, const char *storage_name, char **storage_path, int *validity, char **err_msg)
+{
+	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_check_storage(handle, storage_id, storage_name, storage_path, validity);
+	if(ret < 0) {
+		__set_error_message(ret, err_msg);
+		return MEDIA_SVC_PLUGIN_ERROR;
+	}
+
+	return MEDIA_SVC_PLUGIN_ERROR_NONE;
+}
+
+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)
+{
+	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_storage(handle, storage_id, storage_name, storage_path, NULL, storage_type, uid);
+	if(ret < 0) {
+		__set_error_message(ret, err_msg);
+		return MEDIA_SVC_PLUGIN_ERROR;
+	}
+
+	return MEDIA_SVC_PLUGIN_ERROR_NONE;
+}
+
+int update_storage(void * handle, const char *storage_id, const char *storage_path, uid_t uid, char **err_msg)
+{
+	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_update_storage(handle, storage_id, storage_path, uid);
+	if(ret < 0) {
+		__set_error_message(ret, err_msg);
+		return MEDIA_SVC_PLUGIN_ERROR;
+	}
+
+	return MEDIA_SVC_PLUGIN_ERROR_NONE;
+}
+
+int delete_storage(void * handle, const char *storage_id, const char *storage_name, uid_t uid, char **err_msg)
+{
+	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_delete_storage(handle, storage_id, storage_name, uid);
+	if(ret < 0) {
+		__set_error_message(ret, err_msg);
+		return MEDIA_SVC_PLUGIN_ERROR;
+	}
+
+	return MEDIA_SVC_PLUGIN_ERROR_NONE;
+}
+
+int set_storage_validity(void * handle, const char *storage_id, int validity, uid_t uid, char **err_msg)
+{
+	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_storage_validity(handle, storage_id, validity, uid);
+	if(ret < 0) {
+		__set_error_message(ret, err_msg);
+		return MEDIA_SVC_PLUGIN_ERROR;
+	}
+
+	return MEDIA_SVC_PLUGIN_ERROR_NONE;
+}
+
+int set_all_storage_validity(void * handle, int validity, char **err_msg, 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_storage_validity(handle, NULL, validity, uid);
+	if(ret < 0) {
+		__set_error_message(ret, err_msg);
+		return MEDIA_SVC_PLUGIN_ERROR;
+	}
+
+	return MEDIA_SVC_PLUGIN_ERROR_NONE;
+}
+
+int get_storage_id(void * handle, const char *path, char *storage_id, char **err_msg)
+{
+	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_get_storage_id(handle, path, storage_id);
+	if(ret < 0) {
+		__set_error_message(ret, err_msg);
+		return MEDIA_SVC_PLUGIN_ERROR;
+	}
+
+	return MEDIA_SVC_PLUGIN_ERROR_NONE;
+}
+
+int get_storage_scan_status(void * handle, const char *storage_id, int *status, char **err_msg)
+{
+	int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
+	media_svc_scan_status_type_e storage_status = 0;
+
+	if(handle == NULL) {
+		__set_error_message(ERR_HANDLE, err_msg);
+		return MEDIA_SVC_PLUGIN_ERROR;
+	}
+
+	ret = media_svc_get_storage_scan_status(handle, storage_id, &storage_status);
+	if(ret < 0) {
+		__set_error_message(ret, err_msg);
+		return MEDIA_SVC_PLUGIN_ERROR;
+	}
+
+	*status = storage_status;
+
+	return MEDIA_SVC_PLUGIN_ERROR_NONE;
+}
+
+int set_storage_scan_status(void * handle, const char *storage_id, int status, uid_t uid, char **err_msg)
+{
+	int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
+	media_svc_scan_status_type_e storage_status = status;
+
+	if(handle == NULL) {
+		__set_error_message(ERR_HANDLE, err_msg);
+		return MEDIA_SVC_PLUGIN_ERROR;
+	}
+
+	ret = media_svc_set_storage_scan_status(handle, storage_id, storage_status, uid);
+	if(ret < 0) {
+		__set_error_message(ret, err_msg);
+		return MEDIA_SVC_PLUGIN_ERROR;
+	}
+
+	return MEDIA_SVC_PLUGIN_ERROR_NONE;
+}
+
+int get_storage_list(void * handle, char ***storage_list, char ***storage_id_list,int **scan_status_list, int *count, char **err_msg)
+{
+	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_storage_list(handle, storage_list, storage_id_list, scan_status_list, count);
+	if(ret < 0) {
+		__set_error_message(ret, err_msg);
+		return MEDIA_SVC_PLUGIN_ERROR;
+	}
+
+	return MEDIA_SVC_PLUGIN_ERROR_NONE;
+}
+
 int update_item_begin(void *handle, int item_cnt, char **err_msg)
 {
 	int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
@@ -691,3 +908,154 @@ int update_item_meta(void *handle, const char *file_path, int storage_type, uid_
 
 	return MEDIA_SVC_PLUGIN_ERROR_NONE;
 }
+
+int insert_item_scan(void * handle, const char *storage_id, const char *file_path, int storage_type, uid_t uid, char **err_msg)
+{
+	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_pass1(handle, storage_id, 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;
+}
+
+int update_item_extract(void * handle, const char *storage_id, int storage_type, int scan_type, uid_t uid, const char *path, char **err_msg)
+{
+	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_insert_item_pass2(handle, storage_id, storage_type, scan_type, path, FALSE, uid);
+	if(ret < 0) {
+		__set_error_message(ret, err_msg);
+		return MEDIA_SVC_PLUGIN_ERROR;
+	}
+
+	return MEDIA_SVC_PLUGIN_ERROR_NONE;
+}
+
+int insert_folder_begin(void * handle, int item_cnt, char **err_msg)
+{
+	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_folder_begin(handle, item_cnt);
+	if(ret < 0) {
+		__set_error_message(ret, err_msg);
+		return MEDIA_SVC_PLUGIN_ERROR;
+	}
+
+	return MEDIA_SVC_PLUGIN_ERROR_NONE;
+}
+
+int insert_folder_end(void * handle, uid_t uid, char **err_msg)
+{
+	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_folder_end(handle, uid);
+	if(ret < 0) {
+		__set_error_message(ret, err_msg);
+		return MEDIA_SVC_PLUGIN_ERROR;
+	}
+
+	return MEDIA_SVC_PLUGIN_ERROR_NONE;
+}
+
+int insert_folder(void * handle, const char *storage_id, const char *file_path, int storage_type, uid_t uid, char **err_msg)
+{
+	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_folder(handle, storage_id, 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;
+}
+
+int delete_invalid_folder(void * handle, const char *storage_id, uid_t uid, char **err_msg)
+{
+	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_delete_invalid_folder(handle, storage_id, uid);
+	if(ret < 0) {
+		__set_error_message(ret, err_msg);
+		return MEDIA_SVC_PLUGIN_ERROR;
+	}
+
+	return MEDIA_SVC_PLUGIN_ERROR_NONE;
+}
+
+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)
+{
+	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_folder_validity(handle, storage_id, start_path, validity, is_recursive, uid);
+	if(ret < 0) {
+		__set_error_message(ret, err_msg);
+		return MEDIA_SVC_PLUGIN_ERROR;
+	}
+
+	return MEDIA_SVC_PLUGIN_ERROR_NONE;
+}
diff --git a/src/common/media-svc-db-utils.c b/src/common/media-svc-db-utils.c
index ec1bbc9..dc52505 100755
--- a/src/common/media-svc-db-utils.c
+++ b/src/common/media-svc-db-utils.c
@@ -34,7 +34,7 @@
 #include "media-util-db.h"
 #include "media-svc-media.h"
 
-static int __media_svc_db_upgrade(sqlite3 *db_handle, uid_t uid);
+static int __media_svc_db_upgrade(sqlite3 *db_handle, int cur_version, uid_t uid);
 static int __media_svc_rebuild_view_query(sqlite3 *db_handle, uid_t uid);
 
 
@@ -74,30 +74,50 @@ char *_media_svc_get_path(uid_t uid)
 	return result_psswd;
 }
 
-int __media_svc_add_table_info(char *name, char *triggerName, char *eventTable, char *actionTable, char *viewName)
+int __media_svc_add_table_info(const char *name, const char *triggerName, const char *eventTable, const char *actionTable, const char *viewName)
 {
 	table_info *tbl = NULL;
+
+	media_svc_retvm_if(!STRING_VALID(name), MS_MEDIA_ERR_INVALID_PARAMETER, "name is NULL");
+
+	if (STRING_VALID(triggerName)) {
+		media_svc_retvm_if(!STRING_VALID(eventTable), MS_MEDIA_ERR_INVALID_PARAMETER, "eventTable is NULL");
+		media_svc_retvm_if(!STRING_VALID(actionTable), MS_MEDIA_ERR_INVALID_PARAMETER, "actionTable is NULL");
+	}
+
 	tbl = malloc(sizeof(table_info));
 	if (tbl == NULL) {
 		media_svc_error("MS_MEDIA_ERR_OUT_OF_MEMORY");
 		return MS_MEDIA_ERR_OUT_OF_MEMORY;
 	}
-	memset(tbl, 0, sizeof(table_info));
 
-	if (triggerName != NULL) {
-		tbl->triggerName = strndup(triggerName, strlen(triggerName));
+	memset(tbl, 0x00, sizeof(table_info));
+
+	if (STRING_VALID(triggerName)) {
+		tbl->triggerName = malloc(MEDIA_SVC_PATHNAME_SIZE);
+		if(tbl->triggerName == NULL) {
+			media_svc_error("MS_MEDIA_ERR_OUT_OF_MEMORY");
+			SAFE_FREE(tbl);
+			return MS_MEDIA_ERR_OUT_OF_MEMORY;
+		}
+
+		memset(tbl->triggerName, 0x00, MEDIA_SVC_PATHNAME_SIZE);
+		snprintf(tbl->triggerName, MEDIA_SVC_PATHNAME_SIZE, "%s_%s", triggerName, eventTable);
+
 		tbl->eventTable = strndup(eventTable, strlen(eventTable));
 		tbl->actionTable = strndup(actionTable, strlen(actionTable));
 	}
-	if (viewName != NULL) {
+
+	if (STRING_VALID(viewName)) {
 		tbl->viewName = strndup(viewName, strlen(viewName));
 	}
-	g_hash_table_insert(table, name, tbl);
+
+	g_hash_table_insert(table, (gpointer)name, (gpointer)tbl);
 
 	return MS_MEDIA_ERR_NONE;
 }
 
-int __media_svc_add_column_info(GSList **slist, char *name, char *type, char *option, int version, char *indexName, bool isUnique, bool isTrigger, bool isView)
+int __media_svc_add_column_info(GSList **slist, const char *name, const char *type, const char *option, int version, const char *indexName, bool isUnique, bool isTrigger, bool isView)
 {
 	column_info *col = NULL;
 	col = malloc(sizeof(column_info));
@@ -137,7 +157,7 @@ static int __media_svc_rebuild_view_query(sqlite3 *db_handle, uid_t uid)
 	char *sql = NULL;
 	char table_query[4096] = {0, };
 	char temp[1024] = {0, };
-	int table_len = 0;
+	bool sflag = false;
 	int i, len;
 	/*media */
 	_media_svc_update_media_view(db_handle, uid);
@@ -158,17 +178,16 @@ static int __media_svc_rebuild_view_query(sqlite3 *db_handle, uid_t uid)
 	for (i = 1; i < len; i++) {
 		col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_PLAYLIST], i);
 		if (col_ptr->isView) {
-			if (table_len > 0) {
+			if (sflag == true) {
 				if (strncmp(col_ptr->name, MEDIA_SVC_DB_COLUMN_THUMBNAIL, strlen(MEDIA_SVC_DB_COLUMN_THUMBNAIL)) == 0)
 					snprintf(temp, sizeof(temp), ", playlist.%s AS p_thumbnail_path", col_ptr->name);
 				else
 					snprintf(temp, sizeof(temp), ", playlist.%s", col_ptr->name);
 				strncat(table_query, temp, strlen(temp));
-				table_len = strlen(table_query);
 			} else {
 				snprintf(temp, sizeof(temp), "playlist.%s", col_ptr->name);
 				strncpy(table_query, temp, strlen(temp));
-				table_len = strlen(table_query);
+				sflag = true;
 			}
 		}
 		memset(temp, 0, sizeof(temp));
@@ -182,7 +201,6 @@ static int __media_svc_rebuild_view_query(sqlite3 *db_handle, uid_t uid)
 			else
 				snprintf(temp, sizeof(temp), ", playlist_map.%s", col_ptr->name);
 			strncat(table_query, temp, strlen(temp));
-			table_len = strlen(table_query);
 		}
 		memset(temp, 0, sizeof(temp));
 	}
@@ -193,7 +211,6 @@ static int __media_svc_rebuild_view_query(sqlite3 *db_handle, uid_t uid)
 		if (col_ptr->isView) {
 			snprintf(temp, sizeof(temp), ", media.%s", col_ptr->name);
 			strncat(table_query, temp, strlen(temp));
-			table_len = strlen(table_query);
 		}
 		memset(temp, 0, sizeof(temp));
 	}
@@ -203,21 +220,20 @@ static int __media_svc_rebuild_view_query(sqlite3 *db_handle, uid_t uid)
 	media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 
 	/*create tag_view */
-	table_len = 0;
+	sflag = false;
 	memset(table_query, 0, sizeof(table_query));
 
 	len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_TAG]);
 	for (i = 1; i < len; i++) {
 		col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_TAG], i);
 		if (col_ptr->isView) {
-			if (table_len > 0) {
+			if (sflag == true) {
 				snprintf(temp, sizeof(temp), ", tag.%s", col_ptr->name);
 				strncat(table_query, temp, strlen(temp));
-				table_len = strlen(table_query);
 			} else {
 				snprintf(temp, sizeof(temp), "tag.%s", col_ptr->name);
 				strncpy(table_query, temp, strlen(temp));
-				table_len = strlen(table_query);
+				sflag = true;
 			}
 		}
 		memset(temp, 0, sizeof(temp));
@@ -231,7 +247,6 @@ static int __media_svc_rebuild_view_query(sqlite3 *db_handle, uid_t uid)
 			else
 				snprintf(temp, sizeof(temp), ", tag_map.%s", col_ptr->name);
 			strncat(table_query, temp, strlen(temp));
-			table_len = strlen(table_query);
 		}
 		memset(temp, 0, sizeof(temp));
 	}
@@ -242,7 +257,6 @@ static int __media_svc_rebuild_view_query(sqlite3 *db_handle, uid_t uid)
 		if (col_ptr->isView) {
 			snprintf(temp, sizeof(temp), ", media.%s", col_ptr->name);
 			strncat(table_query, temp, strlen(temp));
-			table_len = strlen(table_query);
 		}
 		memset(temp, 0, sizeof(temp));
 	}
@@ -264,17 +278,20 @@ int _media_svc_make_table_query(sqlite3 *db_handle, const char *table_name, medi
 	char index_query[4096] = {0, };
 	char trigger_query[4096] = {0, };
 	char table_query_sub[1024] = {0, };
-	char temp[1024] = {0, };
-	int table_len = 0;
+	char temp[1024] = {0 ,};
+	int sflag = false;
 	int index_len = 0;
 	int trigger_len = 0;
 	int table_sub_len = 0;
 	int len = 0;
 	int i = 0;
-	sqlite3_stmt *sql_stmt = NULL;
-	int storage_cnt = 0;
 
 	tb = g_hash_table_lookup(table, table_name);
+	if(tb == NULL) {
+		media_svc_debug("lookup fail.. table name [%s] ", table_name);
+		tb = g_hash_table_lookup(table, MEDIA_SVC_DB_TABLE_MEDIA);
+	}
+
 	len = g_slist_length(column_list[list]);
 
 	if (len == 0) {
@@ -286,27 +303,26 @@ int _media_svc_make_table_query(sqlite3 *db_handle, const char *table_name, medi
 		col_ptr = g_slist_nth_data(column_list[list], i);
 		/*create table */
 		if (col_ptr->hasOption) {
-			if (table_len > 0) {
+			if(sflag == true) {
 				snprintf(temp, sizeof(temp), ", %s %s %s", col_ptr->name, col_ptr->type, col_ptr->option);
 				strncat(table_query, temp, strlen(temp));
-				table_len = strlen(table_query);
 			} else {
 				snprintf(temp, sizeof(temp), "%s %s %s", col_ptr->name, col_ptr->type, col_ptr->option);
 				strncpy(table_query, temp, strlen(temp));
-				table_len = strlen(table_query);
+				sflag = true;
 			}
 		} else {
-			if (table_len > 0) {
+			if (sflag == true) {
 				snprintf(temp, sizeof(temp), ", %s %s", col_ptr->name, col_ptr->type);
 				strncat(table_query, temp, strlen(temp));
-				table_len = strlen(table_query);
 			} else {
 				snprintf(temp, sizeof(temp), "%s %s", col_ptr->name, col_ptr->type);
 				strncpy(table_query, temp, strlen(temp));
-				table_len = strlen(table_query);
+				sflag = true;
 			}
 		}
 		memset(temp, 0, sizeof(temp));
+
 		/*unique */
 		if (col_ptr->isUnique) {
 			if (table_sub_len > 0) {
@@ -320,6 +336,7 @@ int _media_svc_make_table_query(sqlite3 *db_handle, const char *table_name, medi
 			}
 		}
 		memset(temp, 0, sizeof(temp));
+
 		/*create index */
 		if (col_ptr->isIndex) {
 			if (index_len > 0) {
@@ -333,16 +350,21 @@ int _media_svc_make_table_query(sqlite3 *db_handle, const char *table_name, medi
 			}
 		}
 		memset(temp, 0, sizeof(temp));
+
 		/*create trigger */
 		if (col_ptr->isTrigger) {
-			if (strncmp(table_name, MEDIA_SVC_DB_TABLE_ALBUM, strlen(MEDIA_SVC_DB_TABLE_ALBUM)) == 0) {
-				snprintf(temp, sizeof(temp), MEDIA_SVC_DB_QUERY_TRIGGER_WITH_COUNT, tb->triggerName, tb->eventTable, tb->actionTable, tb->eventTable, col_ptr->name, col_ptr->name, col_ptr->name, col_ptr->name);
-				strncpy(trigger_query, temp, strlen(temp));
-				trigger_len = strlen(trigger_query);
+			if (STRING_VALID(tb->triggerName)) {
+				if (strncmp(table_name, MEDIA_SVC_DB_TABLE_ALBUM, strlen(MEDIA_SVC_DB_TABLE_ALBUM)) == 0) {
+					snprintf(temp, sizeof(temp), MEDIA_SVC_DB_QUERY_TRIGGER_WITH_COUNT, tb->triggerName, tb->eventTable, tb->actionTable, tb->eventTable, col_ptr->name, col_ptr->name, col_ptr->name, col_ptr->name);
+					strncpy(trigger_query, temp, strlen(temp));
+					trigger_len = strlen(trigger_query);
+				} else {
+					snprintf(temp, sizeof(temp), MEDIA_SVC_DB_QUERY_TRIGGER, tb->triggerName, tb->eventTable, tb->actionTable, col_ptr->name, col_ptr->name);
+					strncpy(trigger_query, temp, strlen(temp));
+					trigger_len = strlen(trigger_query);
+				}
 			} else {
-				snprintf(temp, sizeof(temp), MEDIA_SVC_DB_QUERY_TRIGGER, tb->triggerName, tb->eventTable, tb->actionTable, col_ptr->name, col_ptr->name);
-				strncpy(trigger_query, temp, strlen(temp));
-				trigger_len = strlen(trigger_query);
+				media_svc_error("invalid trigger name");
 			}
 		}
 		memset(temp, 0, sizeof(temp));
@@ -377,7 +399,7 @@ int _media_svc_make_table_query(sqlite3 *db_handle, const char *table_name, medi
 	}
 
 	/*create view */
-	table_len = 0;
+	sflag = false;
 	if (tb != NULL && tb->viewName != NULL) {
 		if (strncmp(table_name, MEDIA_SVC_DB_TABLE_MEDIA, strlen(MEDIA_SVC_DB_TABLE_MEDIA)) == 0) {
 			sql = sqlite3_mprintf(MEDIA_SVC_DB_QUERY_VIEW_MEDIA, tb->viewName, table_name);
@@ -390,17 +412,16 @@ int _media_svc_make_table_query(sqlite3 *db_handle, const char *table_name, medi
 			for (i = 1; i < len; i++) {
 				col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_PLAYLIST], i);
 				if (col_ptr->isView) {
-					if (table_len > 0) {
+					if (sflag == true) {
 						if (strncmp(col_ptr->name, MEDIA_SVC_DB_COLUMN_THUMBNAIL, strlen(MEDIA_SVC_DB_COLUMN_THUMBNAIL)) == 0)
 							snprintf(temp, sizeof(temp), ", playlist.%s AS p_thumbnail_path", col_ptr->name);
 						else
 							snprintf(temp, sizeof(temp), ", playlist.%s", col_ptr->name);
 						strncat(table_query, temp, strlen(temp));
-						table_len = strlen(table_query);
 					} else {
 						snprintf(temp, sizeof(temp), "playlist.%s", col_ptr->name);
 						strncpy(table_query, temp, strlen(temp));
-						table_len = strlen(table_query);
+						sflag = true;
 					}
 				}
 				memset(temp, 0, sizeof(temp));
@@ -414,7 +435,6 @@ int _media_svc_make_table_query(sqlite3 *db_handle, const char *table_name, medi
 					else
 						snprintf(temp, sizeof(temp), ", playlist_map.%s", col_ptr->name);
 					strncat(table_query, temp, strlen(temp));
-					table_len = strlen(table_query);
 				}
 				memset(temp, 0, sizeof(temp));
 			}
@@ -425,7 +445,6 @@ int _media_svc_make_table_query(sqlite3 *db_handle, const char *table_name, medi
 				if (col_ptr->isView) {
 					snprintf(temp, sizeof(temp), ", media.%s", col_ptr->name);
 					strncat(table_query, temp, strlen(temp));
-					table_len = strlen(table_query);
 				}
 				memset(temp, 0, sizeof(temp));
 			}
@@ -439,14 +458,13 @@ int _media_svc_make_table_query(sqlite3 *db_handle, const char *table_name, medi
 			for (i = 1; i < len; i++) {
 				col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_TAG], i);
 				if (col_ptr->isView) {
-					if (table_len > 0) {
+					if(sflag == true) {
 						snprintf(temp, sizeof(temp), ", tag.%s", col_ptr->name);
 						strncat(table_query, temp, strlen(temp));
-						table_len = strlen(table_query);
 					} else {
 						snprintf(temp, sizeof(temp), "tag.%s", col_ptr->name);
 						strncpy(table_query, temp, strlen(temp));
-						table_len = strlen(table_query);
+						sflag = true;
 					}
 				}
 				memset(temp, 0, sizeof(temp));
@@ -460,7 +478,6 @@ int _media_svc_make_table_query(sqlite3 *db_handle, const char *table_name, medi
 					else
 						snprintf(temp, sizeof(temp), ", tag_map.%s", col_ptr->name);
 					strncat(table_query, temp, strlen(temp));
-					table_len = strlen(table_query);
 				}
 				memset(temp, 0, sizeof(temp));
 			}
@@ -471,7 +488,6 @@ int _media_svc_make_table_query(sqlite3 *db_handle, const char *table_name, medi
 				if (col_ptr->isView) {
 					snprintf(temp, sizeof(temp), ", media.%s", col_ptr->name);
 					strncat(table_query, temp, strlen(temp));
-					table_len = strlen(table_query);
 				}
 				memset(temp, 0, sizeof(temp));
 			}
@@ -483,26 +499,10 @@ int _media_svc_make_table_query(sqlite3 *db_handle, const char *table_name, medi
 		}
 	}
 
-	if (strncmp(table_name, MEDIA_SVC_DB_TABLE_STORAGE, strlen(MEDIA_SVC_DB_TABLE_STORAGE)) == 0) {
-		sql = sqlite3_mprintf("SELECT COUNT(*) FROM '%s' WHERE storage_uuid='%s'", MEDIA_SVC_DB_TABLE_STORAGE, MEDIA_SVC_DB_TABLE_MEDIA);
-		ret = _media_svc_sql_prepare_to_step(db_handle, sql, &sql_stmt);
-		media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
-
-		storage_cnt = sqlite3_column_int(sql_stmt, 0);
-		SQLITE3_FINALIZE(sql_stmt);
-
-		if (storage_cnt == 0) {
-			sql = sqlite3_mprintf("INSERT INTO %s VALUES('%s', '%s', '%s', '%s', 0, 0, 1);", MEDIA_SVC_DB_TABLE_STORAGE, MEDIA_SVC_DB_TABLE_MEDIA, MEDIA_SVC_DB_TABLE_MEDIA, _media_svc_get_path(uid), NULL);
-			ret = _media_svc_sql_query(db_handle, sql, uid);
-			sqlite3_free(sql);
-			media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
-		}
-	}
-
 	return MS_MEDIA_ERR_NONE;
 }
 
-int _media_svc_upgrade_table_query(sqlite3 *db_handle, char *table_name, media_svc_table_slist_e list, uid_t uid)
+int _media_svc_upgrade_table_query(sqlite3 *db_handle, const char *table_name, media_svc_table_slist_e list, uid_t uid)
 {
 	int ret = MS_MEDIA_ERR_NONE;
 	column_info *col_ptr = NULL;
@@ -533,7 +533,7 @@ int _media_svc_upgrade_table_query(sqlite3 *db_handle, char *table_name, media_s
 				snprintf(temp, sizeof(temp), "%s %s %s", col_ptr->name, col_ptr->type, col_ptr->option);
 			else
 				snprintf(temp, sizeof(temp), "%s %s", col_ptr->name, col_ptr->type);
-			sql = sqlite3_mprintf(MEDIA_SVC_DB_QUERY_ALTER_TABLE, MEDIA_SVC_DB_TABLE_MEDIA, temp);
+			sql = sqlite3_mprintf(MEDIA_SVC_DB_QUERY_ALTER_TABLE, table_name, temp);
 			ret = _media_svc_sql_query(db_handle, sql, uid);
 			sqlite3_free(sql);
 			media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
@@ -551,7 +551,7 @@ int _media_svc_upgrade_table_query(sqlite3 *db_handle, char *table_name, media_s
 	return MS_MEDIA_ERR_NONE;
 }
 
-int _media_svc_init_table_query()
+int _media_svc_init_table_query(const char *event_table_name)
 {
 	int ret = MS_MEDIA_ERR_NONE;
 	int i = 0;
@@ -564,158 +564,159 @@ int _media_svc_init_table_query()
 
 	/*table specification..    		 (table_name, index, unique set, trigger, view, trigger name, event table, action table, view name) */
 	ret = __media_svc_add_table_info(MEDIA_SVC_DB_TABLE_MEDIA, NULL, NULL, NULL, MEDIA_SVC_DB_VIEW_MEDIA);
-	ret = __media_svc_add_table_info(MEDIA_SVC_DB_TABLE_FOLDER, MEDIA_SVC_DB_TRIGGER_FOLDER, MEDIA_SVC_DB_TABLE_MEDIA, MEDIA_SVC_DB_TABLE_FOLDER, NULL);
-	ret = __media_svc_add_table_info(MEDIA_SVC_DB_TABLE_PLAYLIST_MAP, MEDIA_SVC_DB_TRIGGER_PLAYLIST_MAP, MEDIA_SVC_DB_TABLE_MEDIA, MEDIA_SVC_DB_TABLE_PLAYLIST_MAP, NULL);
+	ret = __media_svc_add_table_info(MEDIA_SVC_DB_TABLE_FOLDER, MEDIA_SVC_DB_TRIGGER_FOLDER, event_table_name, MEDIA_SVC_DB_TABLE_FOLDER, NULL);
+	ret = __media_svc_add_table_info(MEDIA_SVC_DB_TABLE_PLAYLIST_MAP, MEDIA_SVC_DB_TRIGGER_PLAYLIST_MAP, event_table_name, MEDIA_SVC_DB_TABLE_PLAYLIST_MAP, NULL);
 	ret = __media_svc_add_table_info(MEDIA_SVC_DB_TABLE_PLAYLIST, MEDIA_SVC_DB_TRIGGER_PLAYLIST_MAP1, MEDIA_SVC_DB_TABLE_PLAYLIST, MEDIA_SVC_DB_TABLE_PLAYLIST_MAP, MEDIA_SVC_DB_VIEW_PLAYLIST);
-	ret = __media_svc_add_table_info(MEDIA_SVC_DB_TABLE_ALBUM, MEDIA_SVC_DB_TRIGGER_ALBUM, MEDIA_SVC_DB_TABLE_MEDIA, MEDIA_SVC_DB_TABLE_ALBUM, NULL);
-	ret = __media_svc_add_table_info(MEDIA_SVC_DB_TABLE_TAG_MAP, MEDIA_SVC_DB_TRIGGER_TAG_MAP, MEDIA_SVC_DB_TABLE_MEDIA, MEDIA_SVC_DB_TABLE_TAG_MAP, NULL);
+	ret = __media_svc_add_table_info(MEDIA_SVC_DB_TABLE_ALBUM, MEDIA_SVC_DB_TRIGGER_ALBUM, event_table_name, MEDIA_SVC_DB_TABLE_ALBUM, NULL);
+	ret = __media_svc_add_table_info(MEDIA_SVC_DB_TABLE_TAG_MAP, MEDIA_SVC_DB_TRIGGER_TAG_MAP, event_table_name, MEDIA_SVC_DB_TABLE_TAG_MAP, NULL);
 	ret = __media_svc_add_table_info(MEDIA_SVC_DB_TABLE_TAG, MEDIA_SVC_DB_TRIGGER_TAG_MAP1, MEDIA_SVC_DB_TABLE_TAG, MEDIA_SVC_DB_TABLE_TAG_MAP, MEDIA_SVC_DB_VIEW_TAG);
-	ret = __media_svc_add_table_info(MEDIA_SVC_DB_TABLE_BOOKMARK, MEDIA_SVC_DB_TRIGGER_BOOKMARK, MEDIA_SVC_DB_TABLE_MEDIA, MEDIA_SVC_DB_TABLE_BOOKMARK, NULL);
-	ret = __media_svc_add_table_info(MEDIA_SVC_DB_TABLE_STORAGE, MEDIA_SVC_DB_TRIGGER_STORAGE, MEDIA_SVC_DB_TABLE_STORAGE, MEDIA_SVC_DB_TABLE_FOLDER, NULL);
+	ret = __media_svc_add_table_info(MEDIA_SVC_DB_TABLE_BOOKMARK, MEDIA_SVC_DB_TRIGGER_BOOKMARK, event_table_name, MEDIA_SVC_DB_TABLE_BOOKMARK, NULL);
+	ret = __media_svc_add_table_info(MEDIA_SVC_DB_TABLE_STORAGE, NULL, NULL, NULL, NULL);
 	ret = __media_svc_add_table_info(MEDIA_SVC_DB_TABLE_FACE_SCAN_LIST, MEDIA_SVC_DB_TRIGGER_FACE_SCAN_LIST, MEDIA_SVC_DB_TABLE_MEDIA, MEDIA_SVC_DB_TABLE_FACE_SCAN_LIST, NULL);
 	ret = __media_svc_add_table_info(MEDIA_SVC_DB_TABLE_FACE, MEDIA_SVC_DB_TRIGGER_FACE, MEDIA_SVC_DB_TABLE_FACE_SCAN_LIST, MEDIA_SVC_DB_TABLE_FACE, NULL);
-	ret = __media_svc_add_table_info(MEDIA_SVC_DB_TABLE_CUSTOM, MEDIA_SVC_DB_TRIGGER_CUSTOM, MEDIA_SVC_DB_TABLE_MEDIA, MEDIA_SVC_DB_TABLE_CUSTOM, NULL);
 	media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 
 	/*insert column info.. */
 	/*media*/
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_uuid", MEDIA_SVC_DB_TYPE_TEXT, "PRIMARY KEY", 0, NULL, false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "path", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL UNIQUE", 0, NULL, true, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "file_name", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL", 0, "media_file_name_idx", true, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_type", MEDIA_SVC_DB_TYPE_INT, NULL, 0, "media_media_type_idx", false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "mime_type", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, NULL, false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "size", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", 0, NULL, false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "added_time", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", 0, NULL, false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "modified_time", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", 0, "media_modified_time_idx", false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "folder_uuid", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL", 0, "folder_uuid_idx", false, false, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "thumbnail_path", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, NULL, false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "title", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, "media_title_idx", false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "album_id", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", 0, NULL, false, false, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "album", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, "media_album_idx", false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "artist", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, "media_artist_idx", false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "album_artist", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, NULL, false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "genre", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, "media_genre_idx", false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "composer", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, "media_composer_idx", false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "year", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, NULL, false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "recorded_date", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, NULL, false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "copyright", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, NULL, false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "track_num", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, NULL, false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "description", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, NULL, false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "bitrate", MEDIA_SVC_DB_TYPE_INT, "DEFAULT -1", 0, NULL, false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "bitpersample", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", 0, NULL, false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "samplerate", MEDIA_SVC_DB_TYPE_INT, "DEFAULT -1", 0, NULL, false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "channel", MEDIA_SVC_DB_TYPE_INT, "DEFAULT -1", 0, NULL, false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "duration", MEDIA_SVC_DB_TYPE_INT, "DEFAULT -1", 0, NULL, false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "longitude", MEDIA_SVC_DB_TYPE_DOUBLE, "DEFAULT 0", 0, NULL, false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "latitude", MEDIA_SVC_DB_TYPE_DOUBLE, "DEFAULT 0", 0, NULL, false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "altitude", MEDIA_SVC_DB_TYPE_DOUBLE, "DEFAULT 0", 0, NULL, false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "exposure_time", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, NULL, false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "fnumber", MEDIA_SVC_DB_TYPE_DOUBLE, "DEFAULT 0", 0, NULL, false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "iso", MEDIA_SVC_DB_TYPE_INT, "DEFAULT -1", 0, NULL, false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "model", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, NULL, false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "width", MEDIA_SVC_DB_TYPE_INT, "DEFAULT -1", 0, NULL, false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "height", MEDIA_SVC_DB_TYPE_INT, "DEFAULT -1", 0, NULL, false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "datetaken", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, NULL, false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "orientation", MEDIA_SVC_DB_TYPE_INT, "DEFAULT -1", 0, NULL, false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "burst_id", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, NULL, false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "played_count", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", 0, NULL, false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "last_played_time", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", 0, NULL, false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "last_played_position", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", 0, NULL, false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "rating", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", 0, NULL, false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "favourite", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", 0, NULL, false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "author", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, "media_author_idx", false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "provider", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, "media_provider_idx", false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "content_name", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, "media_content_name_idx", false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "category", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, "media_category_idx", false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "location_tag", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, "media_location_tag_idx", false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "age_rating", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, NULL, false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "keyword", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, NULL, false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "is_drm", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", 0, NULL, false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "storage_type", MEDIA_SVC_DB_TYPE_INT, NULL, 0, NULL, false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "timeline", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", 0, "media_timeline_idx", false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "weather", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, NULL, false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "sync_status", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", 0, NULL, false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "file_name_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, NULL, false, false, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "title_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, NULL, false, false, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "album_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, NULL, false, false, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "artist_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, NULL, false, false, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "album_artist_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, NULL, false, false, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "genre_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, NULL, false, false, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "composer_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, NULL, false, false, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "copyright_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, NULL, false, false, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "description_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, NULL, false, false, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "author_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, NULL, false, false, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "provider_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, NULL, false, false, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "content_name_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, NULL, false, false, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "category_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, NULL, false, false, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "location_tag_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, NULL, false, false, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "age_rating_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, NULL, false, false, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "keyword_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, NULL, false, false, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "storage_uuid", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL", 0, NULL, false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "validity", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 1", 0, NULL, false, false, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_uuid", MEDIA_SVC_DB_TYPE_TEXT, "PRIMARY KEY", USER_V2, NULL, false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "path", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL UNIQUE", USER_V2, NULL, true, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "file_name", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL", USER_V2, "media_file_name_idx", true, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_type", MEDIA_SVC_DB_TYPE_INT, NULL, USER_V2, "media_media_type_idx", false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "mime_type", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "size", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V2, NULL, false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "added_time", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V2, NULL, false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "modified_time", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V2, "media_modified_time_idx", false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "folder_uuid", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL", USER_V2, "folder_uuid_idx", false, false, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "thumbnail_path", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "title", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, "media_title_idx", false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "album_id", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V2, NULL, false, false, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "album", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, "media_album_idx", false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "artist", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, "media_artist_idx", false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "album_artist", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "genre", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, "media_genre_idx", false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "composer", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, "media_composer_idx", false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "year", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "recorded_date", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "copyright", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "track_num", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "description", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "bitrate", MEDIA_SVC_DB_TYPE_INT, "DEFAULT -1", USER_V2, NULL, false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "bitpersample", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V3, NULL, false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "samplerate", MEDIA_SVC_DB_TYPE_INT, "DEFAULT -1", USER_V2, NULL, false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "channel", MEDIA_SVC_DB_TYPE_INT, "DEFAULT -1", USER_V2, NULL, false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "duration", MEDIA_SVC_DB_TYPE_INT, "DEFAULT -1", USER_V2, NULL, false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "longitude", MEDIA_SVC_DB_TYPE_DOUBLE, "DEFAULT 0", USER_V2, NULL, false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "latitude", MEDIA_SVC_DB_TYPE_DOUBLE, "DEFAULT 0", USER_V2, NULL, false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "altitude", MEDIA_SVC_DB_TYPE_DOUBLE, "DEFAULT 0", USER_V2, NULL, false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "exposure_time", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V4, NULL, false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "fnumber", MEDIA_SVC_DB_TYPE_DOUBLE, "DEFAULT 0", USER_V4, NULL, false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "iso", MEDIA_SVC_DB_TYPE_INT, "DEFAULT -1", USER_V4, NULL, false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "model", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V4, NULL, false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "width", MEDIA_SVC_DB_TYPE_INT, "DEFAULT -1", USER_V2, NULL, false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "height", MEDIA_SVC_DB_TYPE_INT, "DEFAULT -1", USER_V2, NULL, false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "datetaken", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "orientation", MEDIA_SVC_DB_TYPE_INT, "DEFAULT -1", USER_V2, NULL, false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "burst_id", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "played_count", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V2, NULL, false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "last_played_time", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V2, NULL, false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "last_played_position", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V2, NULL, false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "rating", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V2, NULL, false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "favourite", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V2, NULL, false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "author", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, "media_author_idx", false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "provider", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, "media_provider_idx", false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "content_name", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, "media_content_name_idx", false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "category", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, "media_category_idx", false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "location_tag", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, "media_location_tag_idx", false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "age_rating", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "keyword", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "is_drm", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V2, NULL, false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "storage_type", MEDIA_SVC_DB_TYPE_INT, NULL, USER_V2, NULL, false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "timeline", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V2, "media_timeline_idx", false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "weather", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "sync_status", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V2, NULL, false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "file_name_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "title_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "album_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "artist_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "album_artist_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "genre_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "composer_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "copyright_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "description_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "author_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "provider_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "content_name_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "category_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "location_tag_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "age_rating_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "keyword_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
+	/* storage_uuid column is added in DB v4. When doing DB upgrade to v4, if storage_uuid is NOT NULL, alter table failed. */
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "storage_uuid", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V4, NULL, false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "validity", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 1", USER_V2, NULL, false, false, false);
 	media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 
 	/*folder*/
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FOLDER], "folder_uuid", MEDIA_SVC_DB_TYPE_TEXT, "PRIMARY KEY", 0, NULL, false, false, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FOLDER], "path", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL", 0, NULL, true, false, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FOLDER], "name", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL", 0, NULL, true, false, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FOLDER], "modified_time", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", 0, NULL, false, false, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FOLDER], "name_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, NULL, false, false, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FOLDER], "storage_type", MEDIA_SVC_DB_TYPE_INT, NULL, 0, NULL, false, false, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FOLDER], "storage_uuid", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL", 0, NULL, true, false, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FOLDER], "folder_order", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", 0, NULL, false, false, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FOLDER], "parent_folder_uuid", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, NULL, false, false, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FOLDER], "validity", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 1", 0, NULL, false, false, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FOLDER], "folder_uuid", MEDIA_SVC_DB_TYPE_TEXT, "PRIMARY KEY", USER_V2, NULL, false, false, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FOLDER], "path", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL", USER_V2, NULL, true, false, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FOLDER], "name", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL", USER_V2, NULL, true, false, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FOLDER], "modified_time", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V2, NULL, false, false, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FOLDER], "name_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FOLDER], "storage_type", MEDIA_SVC_DB_TYPE_INT, NULL, USER_V2, NULL, false, false, false);
+	/* storage_uuid column is added in DB v4. When doing DB upgrade to v4, if storage_uuid is NOT NULL, alter table failed. */
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FOLDER], "storage_uuid", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V4,  NULL, true, false, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FOLDER], "folder_order", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V4, NULL, false, false, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FOLDER], "parent_folder_uuid", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V4, NULL, false, false, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FOLDER], "validity", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 1", USER_V4, NULL, false, false, false);
 	media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 
 	/*playlist_map*/
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_PLAYLIST_MAP], "_id", MEDIA_SVC_DB_TYPE_INT, "PRIMARY KEY AUTOINCREMENT", 0, NULL, false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_PLAYLIST_MAP], "playlist_id", MEDIA_SVC_DB_TYPE_INT, "NOT NULL", 0, NULL, false, false, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_PLAYLIST_MAP], "media_uuid", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL", 0, NULL, false, true, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_PLAYLIST_MAP], "play_order", MEDIA_SVC_DB_TYPE_INT, "NOT NULL", 0, NULL, false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_PLAYLIST_MAP], "_id", MEDIA_SVC_DB_TYPE_INT, "PRIMARY KEY AUTOINCREMENT", USER_V2, NULL, false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_PLAYLIST_MAP], "playlist_id", MEDIA_SVC_DB_TYPE_INT, "NOT NULL", USER_V2, NULL, false, false, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_PLAYLIST_MAP], "media_uuid", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL", USER_V2, NULL, false, true, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_PLAYLIST_MAP], "play_order", MEDIA_SVC_DB_TYPE_INT, "NOT NULL", USER_V2, NULL, false, false, true);
 	media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 
 	/*playlist*/
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_PLAYLIST], "playlist_id", MEDIA_SVC_DB_TYPE_INT, "PRIMARY KEY AUTOINCREMENT", 0, NULL, false, true, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_PLAYLIST], "name", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL UNIQUE", 0, NULL, false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_PLAYLIST], "name_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, NULL, false, false, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_PLAYLIST], "thumbnail_path", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, NULL, false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_PLAYLIST], "playlist_id", MEDIA_SVC_DB_TYPE_INT, "PRIMARY KEY AUTOINCREMENT", USER_V2, NULL, false, true, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_PLAYLIST], "name", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL UNIQUE", USER_V2, NULL, false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_PLAYLIST], "name_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_PLAYLIST], "thumbnail_path", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, true);
 	media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 
 	/*album*/
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_ALBUM], "album_id", MEDIA_SVC_DB_TYPE_INT, "PRIMARY KEY AUTOINCREMENT", 0, NULL, false, true, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_ALBUM], "name", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL", 0, NULL, false, false, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_ALBUM], "artist", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, NULL, false, false, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_ALBUM], "album_art", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, NULL, false, false, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_ALBUM], "album_id", MEDIA_SVC_DB_TYPE_INT, "PRIMARY KEY AUTOINCREMENT", USER_V2, NULL, false, true, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_ALBUM], "name", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL", USER_V2, NULL, false, false, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_ALBUM], "artist", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_ALBUM], "album_art", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
 	media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 
 	/*tag_map*/
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_TAG_MAP], "_id", MEDIA_SVC_DB_TYPE_INT, "PRIMARY KEY AUTOINCREMENT", 0, NULL, false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_TAG_MAP], "tag_id", MEDIA_SVC_DB_TYPE_INT, "NOT NULL", 0, NULL, true, false, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_TAG_MAP], "media_uuid", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL", 0, NULL, true, true, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_TAG_MAP], "_id", MEDIA_SVC_DB_TYPE_INT, "PRIMARY KEY AUTOINCREMENT", USER_V2, NULL, false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_TAG_MAP], "tag_id", MEDIA_SVC_DB_TYPE_INT, "NOT NULL", USER_V2, NULL, true, false, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_TAG_MAP], "media_uuid", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL", USER_V2, NULL, true, true, false);
 	media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 
 	/*tag*/
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_TAG], "tag_id ", MEDIA_SVC_DB_TYPE_INT, "PRIMARY KEY AUTOINCREMENT", 0, NULL, false, true, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_TAG], "name", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL UNIQUE", 0, NULL, false, false, true);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_TAG], "name_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, NULL, false, false, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_TAG], "tag_id ", MEDIA_SVC_DB_TYPE_INT, "PRIMARY KEY AUTOINCREMENT", USER_V2, NULL, false, true, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_TAG], "name", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL UNIQUE", USER_V2, NULL, false, false, true);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_TAG], "name_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
 	media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 
 	/*bookmark*/
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_BOOKMARK], "bookmark_id", MEDIA_SVC_DB_TYPE_INT, "PRIMARY KEY AUTOINCREMENT", 0, NULL, false, false, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_BOOKMARK], "media_uuid", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL", 0, NULL, true, true, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_BOOKMARK], "marked_time", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", 0, NULL, true, false, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_BOOKMARK], "thumbnail_path", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, NULL, false, false, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_BOOKMARK], "bookmark_id", MEDIA_SVC_DB_TYPE_INT, "PRIMARY KEY AUTOINCREMENT", USER_V2, NULL, false, false, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_BOOKMARK], "media_uuid", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL", USER_V2, NULL, true, true, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_BOOKMARK], "marked_time", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V2, NULL, true, false, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_BOOKMARK], "thumbnail_path", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
 	media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 
 	/*storage*/
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_STORAGE], "storage_uuid", MEDIA_SVC_DB_TYPE_TEXT, "PRIMARY KEY", 0, NULL, false, true, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_STORAGE], "storage_name", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, NULL, true, false, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_STORAGE], "storage_path", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL", 0, NULL, true, false, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_STORAGE], "storage_account", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, NULL, true, false, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_STORAGE], "storage_type", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", 0, NULL, false, false, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_STORAGE], "scan_status", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", 0, NULL, false, false, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_STORAGE], "validity", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 1", 0, NULL, false, false, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_STORAGE], "storage_uuid", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL", USER_V3, NULL, true, false, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_STORAGE], "storage_name", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V3, NULL, true, false, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_STORAGE], "storage_path", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL", USER_V3, NULL, false, false, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_STORAGE], "storage_account", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V3, NULL, false, false, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_STORAGE], "storage_type", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V3, NULL, false, false, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_STORAGE], "scan_status", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V3, NULL, false, false, false);
+	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_STORAGE], "validity", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 1", USER_V3, NULL, false, false, false);
 	media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 
 	/*face scan list*/
@@ -733,45 +734,200 @@ int _media_svc_init_table_query()
 	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FACE], "orientation", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", 0, NULL, false, false, false);
 	media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 
-	/*custom*/
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_CUSTOM], "_id", MEDIA_SVC_DB_TYPE_INT, "PRIMARY KEY AUTOINCREMENT", 0, NULL, false, false, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_CUSTOM], "media_uuid", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, NULL, false, true, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_CUSTOM], "media_type", MEDIA_SVC_DB_TYPE_INT, NULL, 0, NULL, false, false, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_CUSTOM], "author", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, NULL, false, false, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_CUSTOM], "provider", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, "custom_provider_idx", false, false, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_CUSTOM], "content_name", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, NULL, false, false, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_CUSTOM], "category", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, NULL, false, false, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_CUSTOM], "location_tag", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, NULL, false, false, false);
-	ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_CUSTOM], "age_rating", MEDIA_SVC_DB_TYPE_TEXT, NULL, 0, NULL, false, false, false);
-	media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
-
 	return ret;
 }
+void __media_svc_table_free(table_info *tb) {
+	SAFE_FREE(tb->triggerName);
+	SAFE_FREE(tb->viewName);
+	SAFE_FREE(tb->eventTable);
+	SAFE_FREE(tb->actionTable);
+	SAFE_FREE(tb);
+}
+
+void __media_svc_column_free(column_info *col) {
+	SAFE_FREE(col->name);
+	SAFE_FREE(col->type);
+	SAFE_FREE(col->option);
+	SAFE_FREE(col->indexName);
+	SAFE_FREE(col);
+}
 
 void _media_svc_destroy_table_query()
 {
 	int i = 0;
+	table_info *tb = NULL;
+	column_info *col_ptr = NULL;
+	int len = 0;
+
+	/* Table Free */
+	tb = g_hash_table_lookup(table, MEDIA_SVC_DB_TABLE_MEDIA);
+	__media_svc_table_free(tb);
+	g_hash_table_remove (table, MEDIA_SVC_DB_TABLE_MEDIA);
+
+	tb = g_hash_table_lookup(table, MEDIA_SVC_DB_TABLE_FOLDER);
+	__media_svc_table_free(tb);
+	g_hash_table_remove (table, MEDIA_SVC_DB_TABLE_FOLDER);
+
+	tb = g_hash_table_lookup(table, MEDIA_SVC_DB_TABLE_PLAYLIST);
+	__media_svc_table_free(tb);
+	g_hash_table_remove (table, MEDIA_SVC_DB_TABLE_PLAYLIST);
+
+	tb = g_hash_table_lookup(table, MEDIA_SVC_DB_TABLE_PLAYLIST_MAP);
+	__media_svc_table_free(tb);
+	g_hash_table_remove (table, MEDIA_SVC_DB_TABLE_PLAYLIST_MAP);
+
+	tb = g_hash_table_lookup(table, MEDIA_SVC_DB_TABLE_ALBUM);
+	__media_svc_table_free(tb);
+	g_hash_table_remove (table, MEDIA_SVC_DB_TABLE_ALBUM);
+
+	tb = g_hash_table_lookup(table, MEDIA_SVC_DB_TABLE_TAG);
+	__media_svc_table_free(tb);
+	g_hash_table_remove (table, MEDIA_SVC_DB_TABLE_TAG);
+
+	tb = g_hash_table_lookup(table, MEDIA_SVC_DB_TABLE_TAG_MAP);
+	__media_svc_table_free(tb);
+	g_hash_table_remove (table, MEDIA_SVC_DB_TABLE_TAG_MAP);
+
+	tb = g_hash_table_lookup(table, MEDIA_SVC_DB_TABLE_BOOKMARK);
+	__media_svc_table_free(tb);
+	g_hash_table_remove (table, MEDIA_SVC_DB_TABLE_BOOKMARK);
+
+	tb = g_hash_table_lookup(table, MEDIA_SVC_DB_TABLE_STORAGE);
+	__media_svc_table_free(tb);
+	g_hash_table_remove (table, MEDIA_SVC_DB_TABLE_STORAGE);
 
-	g_hash_table_remove_all(table);
 	g_hash_table_destroy(table);
 
-	for (i = 0; i < MEDIA_SVC_DB_LIST_MAX; i++)
+	/* Column Free */
+	len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_MEDIA]);
+
+	for(i=1; i<len; i++) {
+		col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_MEDIA], i);
+		__media_svc_column_free(col_ptr);
+	}
+
+	len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_FOLDER]);
+
+	for(i=1; i<len; i++) {
+		col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_FOLDER], i);
+		__media_svc_column_free(col_ptr);
+	}
+
+	len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_PLAYLIST_MAP]);
+
+	for(i=1; i<len; i++) {
+		col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_PLAYLIST_MAP], i);
+		__media_svc_column_free(col_ptr);
+	}
+
+	len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_PLAYLIST]);
+
+	for(i=1; i<len; i++) {
+		col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_PLAYLIST], i);
+		__media_svc_column_free(col_ptr);
+	}
+
+	len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_ALBUM]);
+
+	for(i=1; i<len; i++) {
+		col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_ALBUM], i);
+		__media_svc_column_free(col_ptr);
+	}
+
+	len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_TAG_MAP]);
+
+	for(i=1; i<len; i++) {
+		col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_TAG_MAP], i);
+		__media_svc_column_free(col_ptr);
+	}
+
+	len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_TAG]);
+
+	for(i=1; i<len; i++) {
+		col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_TAG], i);
+		__media_svc_column_free(col_ptr);
+	}
+
+	len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_BOOKMARK]);
+
+	for(i=1; i<len; i++) {
+		col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_BOOKMARK], i);
+		__media_svc_column_free(col_ptr);
+	}
+
+	len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_STORAGE]);
+
+	for(i=1; i<len; i++) {
+		col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_STORAGE], i);
+		__media_svc_column_free(col_ptr);
+	}
+
+	for(i=0; i<MEDIA_SVC_DB_LIST_MAX; i++) {
 		g_slist_free(column_list[i]);
+	}
 }
 
-static int __media_svc_db_upgrade(sqlite3 *db_handle, uid_t uid)
+static int __media_svc_db_upgrade(sqlite3 *db_handle, int cur_version, uid_t uid)
 {
 	int ret = MS_MEDIA_ERR_NONE;
 	char *sql = NULL;
 
-	ret = _media_svc_init_table_query();
+	ret = _media_svc_init_table_query(MEDIA_SVC_DB_TABLE_MEDIA);
 	media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 
 	ret = _media_svc_upgrade_table_query(db_handle, MEDIA_SVC_DB_TABLE_MEDIA, MEDIA_SVC_DB_LIST_MEDIA, uid);
 	media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 
-	ret = _media_svc_upgrade_table_query(db_handle, MEDIA_SVC_DB_TABLE_FOLDER, MEDIA_SVC_DB_LIST_FOLDER, uid);
-	media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
+	/* Upgrade issue in folder table */
+	if(cur_version < USER_V4) {
+		/* Create tmp table */
+		sql = sqlite3_mprintf("CREATE TABLE '%q' AS SELECT * FROM '%q';", MEDIA_SVC_DB_TABLE_TMP_TABLE, MEDIA_SVC_DB_TABLE_FOLDER);
+		media_svc_retv_if(sql == NULL, MS_MEDIA_ERR_OUT_OF_MEMORY);
+
+		ret = _media_svc_sql_query(db_handle, sql, uid);
+		if (ret != MS_MEDIA_ERR_NONE) {
+			media_svc_error("Error when create backup folder table");
+		}
+		sqlite3_free(sql);
+
+		/* Drop original table */
+		sql = sqlite3_mprintf("DROP TABLE '%q';", MEDIA_SVC_DB_TABLE_FOLDER);
+		media_svc_retv_if(sql == NULL, MS_MEDIA_ERR_OUT_OF_MEMORY);
+
+		ret = _media_svc_sql_query(db_handle, sql, uid);
+		if (ret != MS_MEDIA_ERR_NONE) {
+			media_svc_error("Error when drop table");
+		}
+		sqlite3_free(sql);
+
+		/* Create new table */
+		ret = _media_svc_make_table_query(db_handle, MEDIA_SVC_DB_TABLE_FOLDER, MEDIA_SVC_DB_LIST_FOLDER, uid);
+		media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
+
+		/* Insert into new table */
+		sql = sqlite3_mprintf("INSERT INTO '%q'(folder_uuid, path, name, modified_time, name_pinyin, storage_type) SELECT folder_uuid, path, name, modified_time, name_pinyin, storage_type FROM '%q';", MEDIA_SVC_DB_TABLE_FOLDER, MEDIA_SVC_DB_TABLE_TMP_TABLE);
+		media_svc_retv_if(sql == NULL, MS_MEDIA_ERR_OUT_OF_MEMORY);
+
+		ret = _media_svc_sql_query(db_handle, sql, uid);
+		if (ret != MS_MEDIA_ERR_NONE) {
+			media_svc_error("Error when backup folder table");
+		}
+		sqlite3_free(sql);
+
+		/* Drop tmp table*/
+		sql = sqlite3_mprintf("DROP TABLE '%q';", MEDIA_SVC_DB_TABLE_TMP_TABLE);
+		media_svc_retv_if(sql == NULL, MS_MEDIA_ERR_OUT_OF_MEMORY);
+
+		ret = _media_svc_sql_query(db_handle, sql, uid);
+		if (ret != MS_MEDIA_ERR_NONE) {
+			media_svc_error("Error when drop backup folder table");
+		}
+		sqlite3_free(sql);
+
+	} else {
+		ret = _media_svc_upgrade_table_query(db_handle, MEDIA_SVC_DB_TABLE_FOLDER , MEDIA_SVC_DB_LIST_FOLDER, uid);
+		media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
+	}
 
 	ret = _media_svc_upgrade_table_query(db_handle, MEDIA_SVC_DB_TABLE_PLAYLIST_MAP, MEDIA_SVC_DB_LIST_PLAYLIST_MAP, uid);
 	media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
@@ -794,6 +950,21 @@ static int __media_svc_db_upgrade(sqlite3 *db_handle, uid_t uid)
 	ret = _media_svc_upgrade_table_query(db_handle, MEDIA_SVC_DB_TABLE_STORAGE, MEDIA_SVC_DB_LIST_STORAGE, uid);
 	media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 
+	if(cur_version < USER_V4) {
+		/* Need to default value in storage_uuid */
+		sql = sqlite3_mprintf("UPDATE %q SET storage_uuid  = '%q';",MEDIA_SVC_DB_TABLE_MEDIA, "media");
+		media_svc_retv_if(sql == NULL, MS_MEDIA_ERR_OUT_OF_MEMORY);
+
+		ret = _media_svc_sql_query(db_handle, sql, uid);
+		sqlite3_free(sql);
+
+		sql = sqlite3_mprintf("UPDATE %q SET storage_uuid  = '%q';",MEDIA_SVC_DB_TABLE_FOLDER, "media");
+		media_svc_retv_if(sql == NULL, MS_MEDIA_ERR_OUT_OF_MEMORY);
+
+		ret = _media_svc_sql_query(db_handle, sql, uid);
+		sqlite3_free(sql);
+	}
+
 	ret = __media_svc_rebuild_view_query(db_handle, uid);
 
 	sql = sqlite3_mprintf("PRAGMA user_version=%d;", LATEST_VERSION_NUMBER);
@@ -801,6 +972,7 @@ static int __media_svc_db_upgrade(sqlite3 *db_handle, uid_t uid)
 
 	ret = _media_svc_sql_query(db_handle, sql, uid);
 	sqlite3_free(sql);
+
 	_media_svc_destroy_table_query();
 
 	return ret;
@@ -844,7 +1016,7 @@ int _media_svc_sql_prepare_to_step(sqlite3 *handle, const char *sql_str, sqlite3
 
 	err = sqlite3_step(*stmt);
 	if (err != SQLITE_ROW) {
-		media_svc_sec_debug("Item not found. end of row [%s]", sqlite3_errmsg(handle));
+		media_svc_error("[No-Error] Item not found. end of row [%s]", sqlite3_errmsg(handle));
 		SQLITE3_FINALIZE(*stmt);
 		return MS_MEDIA_ERR_DB_NO_RECORD;
 	}
@@ -951,7 +1123,7 @@ void _media_svc_sql_query_release(GList **query_list)
 	}
 }
 
-int _media_svc_check_db_upgrade(sqlite3 *db_handle, uid_t uid)
+int _media_svc_check_db_upgrade(sqlite3 *db_handle, bool *need_full_scan, uid_t uid)
 {
 	int ret = MS_MEDIA_ERR_NONE;
 	sqlite3_stmt *sql_stmt = NULL;
@@ -970,8 +1142,11 @@ int _media_svc_check_db_upgrade(sqlite3 *db_handle, uid_t uid)
 	SQLITE3_FINALIZE(sql_stmt);
 
 	if (cur_version < LATEST_VERSION_NUMBER) {
+		if(cur_version < USER_V4) {
+			*need_full_scan = true;
+		}
 		media_svc_error("Current DB is out of date(%d).. So start to upgrade DB(%d)", cur_version, LATEST_VERSION_NUMBER);
-		return __media_svc_db_upgrade(db_handle, uid);
+		return __media_svc_db_upgrade(db_handle, cur_version, uid);
 	} else {
 		return MS_MEDIA_ERR_NONE;
 	}
@@ -1010,12 +1185,28 @@ int _media_svc_create_media_table_with_id(sqlite3 *db_handle, const char *table_
 {
 	int ret = MS_MEDIA_ERR_NONE;
 
-	ret = _media_svc_init_table_query();
+	ret = _media_svc_init_table_query(table_id);
 	media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 
 	ret = _media_svc_make_table_query(db_handle, table_id, MEDIA_SVC_DB_LIST_MEDIA, uid);
 	media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 
+	/* Add for trigger */
+	ret = _media_svc_make_table_query(db_handle, MEDIA_SVC_DB_TABLE_FOLDER, MEDIA_SVC_DB_LIST_FOLDER, uid);
+	media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
+
+	ret = _media_svc_make_table_query(db_handle, MEDIA_SVC_DB_TABLE_PLAYLIST_MAP, MEDIA_SVC_DB_LIST_PLAYLIST_MAP, uid);
+	media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
+
+	ret = _media_svc_make_table_query(db_handle, MEDIA_SVC_DB_TABLE_ALBUM, MEDIA_SVC_DB_LIST_ALBUM, uid);
+	media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
+
+	ret = _media_svc_make_table_query(db_handle, MEDIA_SVC_DB_TABLE_TAG_MAP, MEDIA_SVC_DB_LIST_TAG_MAP, uid);
+	media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
+
+	ret = _media_svc_make_table_query(db_handle, MEDIA_SVC_DB_TABLE_BOOKMARK, MEDIA_SVC_DB_LIST_BOOKMARK, uid);
+	media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
+
 	_media_svc_destroy_table_query();
 
 	return ret;
diff --git a/src/common/media-svc-localize-utils.c b/src/common/media-svc-localize-utils.c
index ab3992c..3550993 100755
--- a/src/common/media-svc-localize-utils.c
+++ b/src/common/media-svc-localize-utils.c
@@ -24,6 +24,8 @@
 #include <unicode/ustring.h>
 #include <unicode/ucol.h>
 
+#include <vconf.h>
+
 #include "media-util-err.h"
 #include "media-svc-debug.h"
 #include "media-svc-localize-utils.h"
@@ -50,14 +52,14 @@ int _media_svc_check_utf8(char c)
 
 int SAFE_SNPRINTF(char **buf, int *buf_size, int len, const char *src)
 {
-	int remain;
-	int temp_len;
+	int remain = 0;
+	int temp_len = 0;
 
 	if (len < 0)
 		return -1;
 
 	remain = *buf_size - len;
-	if (remain > strlen(src) + 1) {
+	if (remain > (int)strlen(src) + 1) {
 		temp_len = snprintf((*buf) + len, remain, "%s", src);
 		return temp_len;
 	} else {
@@ -69,7 +71,7 @@ int SAFE_SNPRINTF(char **buf, int *buf_size, int len, const char *src)
 			*buf = temp;
 			*buf_size = *buf_size * 2;
 			remain = *buf_size - len;
-			if (remain > strlen(src) + 1)
+			if (remain > (int)strlen(src) + 1)
 				break;
 		}
 		temp_len = snprintf((*buf) + len, remain, "%s", src);
@@ -114,6 +116,7 @@ static inline int __media_svc_collation_str(const char *src, char **dest)
 	UCollator *collator;
 	char region[50] = {0};
 	char *lang = NULL;
+	const char *en_us = "en_US.UTF-8";
 
 	/*lang = vconf_get_str(VCONFKEY_LANGSET); */
 	if (lang != NULL) {
@@ -125,7 +128,7 @@ static inline int __media_svc_collation_str(const char *src, char **dest)
 			free(lang);
 		}
 	} else {
-		strncpy(region, "en_US.UTF-8", strlen("en_US.UTF-8"));
+		strncpy(region, en_us, strlen(en_us));
 	}
 
 	char *dot = strchr(region, '.');
diff --git a/src/common/media-svc-media-folder.c b/src/common/media-svc-media-folder.c
index abefac9..4a3f634 100755
--- a/src/common/media-svc-media-folder.c
+++ b/src/common/media-svc-media-folder.c
@@ -28,17 +28,60 @@
 #include "media-svc-db-utils.h"
 
 extern __thread GList *g_media_svc_move_item_query_list;
+static __thread GList *g_media_svc_insert_folder_query_list;
 
-int _media_svc_get_folder_id_by_foldername(sqlite3 *handle, const char *storage_id, const char *folder_name, char *folder_id)
+static int __media_svc_is_root_path(const char *folder_path, bool *is_root)
+{
+	media_svc_retvm_if(!STRING_VALID(folder_path), MS_MEDIA_ERR_INVALID_PARAMETER, "folder_path is NULL");
+
+	*is_root = FALSE;
+
+	if (strcmp(folder_path, MEDIA_ROOT_PATH_INTERNAL) == 0 ||
+		strcmp(folder_path, MEDIA_ROOT_PATH_SDCARD) == 0 ||
+		strcmp(folder_path, MEDIA_ROOT_PATH_CLOUD) == 0) {
+		media_svc_debug("ROOT PATH [%d]", folder_path);
+		*is_root = TRUE;
+	}
+
+	return MS_MEDIA_ERR_NONE;
+}
+
+static int __media_svc_parent_is_ext_root_path(const char *folder_path, bool *is_root)
+{
+	char *parent_folder_path = NULL;
+
+	media_svc_retvm_if(!STRING_VALID(folder_path), MS_MEDIA_ERR_INVALID_PARAMETER, "folder_path is NULL");
+
+	*is_root = FALSE;
+
+	parent_folder_path = g_path_get_dirname(folder_path);
+
+	if(!STRING_VALID(parent_folder_path)) {
+		media_svc_error("error : g_path_get_dirname falied");
+		SAFE_FREE(parent_folder_path);
+		return MS_MEDIA_ERR_OUT_OF_MEMORY;
+	}
+
+	if (strcmp(parent_folder_path, MEDIA_ROOT_PATH_EXTERNAL) == 0) {
+		media_svc_debug("parent folder is ROOT PATH [%s]", parent_folder_path);
+		*is_root = TRUE;
+	}
+
+	SAFE_FREE(parent_folder_path);
+
+	return MS_MEDIA_ERR_NONE;
+}
+
+int _media_svc_get_folder_id_by_foldername(sqlite3 *handle, const char *storage_id, const char *folder_name, char *folder_id, uid_t uid)
 {
 	int ret = MS_MEDIA_ERR_NONE;
 	sqlite3_stmt *sql_stmt = NULL;
 	char *sql = NULL;
+	char parent_folder_uuid[MEDIA_SVC_UUID_SIZE+1] = {0, };
+	char *temp_parent_uuid = NULL;
+	char *parent_folder_path = NULL;
 
-	if (STRING_VALID(storage_id))
-		sql = sqlite3_mprintf("SELECT folder_uuid FROM '%s' WHERE storage_uuid = '%q' AND path = '%q';", MEDIA_SVC_DB_TABLE_FOLDER, storage_id, folder_name);
-	else
-		sql = sqlite3_mprintf("SELECT folder_uuid FROM '%s' WHERE path = '%q';", MEDIA_SVC_DB_TABLE_FOLDER, folder_name);
+	sql = sqlite3_mprintf("SELECT folder_uuid, parent_folder_uuid  FROM '%s' WHERE storage_uuid = '%q' AND path = '%q';", MEDIA_SVC_DB_TABLE_FOLDER, storage_id, folder_name);
 
 	ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 
@@ -51,17 +94,80 @@ int _media_svc_get_folder_id_by_foldername(sqlite3 *handle, const char *storage_
 		return ret;
 	}
 
+	memset(parent_folder_uuid, 0, sizeof(parent_folder_uuid));
+
 	_strncpy_safe(folder_id, (const char *)sqlite3_column_text(sql_stmt, 0), MEDIA_SVC_UUID_SIZE + 1);
+	if (STRING_VALID((const char *)sqlite3_column_text(sql_stmt, 1)))	/*root path can be null*/
+		_strncpy_safe(parent_folder_uuid, (const char *)sqlite3_column_text(sql_stmt, 1), MEDIA_SVC_UUID_SIZE+1);
 
 	SQLITE3_FINALIZE(sql_stmt);
 
+	/*root path can be null*/
+	if(!STRING_VALID(parent_folder_uuid)) {
+		bool is_root = FALSE;
+
+		ret = __media_svc_is_root_path(folder_name, &is_root);
+		if (is_root)
+			return MS_MEDIA_ERR_NONE;
+
+		ret = __media_svc_parent_is_ext_root_path(folder_name, &is_root);
+		if (is_root)
+			return MS_MEDIA_ERR_NONE;
+	}
+
+	/* Notice : Below code is the code only for inserting parent folder uuid when upgrade the media db version 3 to 4  */
+	/* Check parent folder uuid */
+	if(!STRING_VALID(parent_folder_uuid)) {
+		/* update parent_uuid */
+		media_svc_error("[No-Error] there is no parent folder uuid. PLEASE CHECK IT");
+
+		parent_folder_path = g_path_get_dirname(folder_name);
+		if(!STRING_VALID(parent_folder_path)) {
+			media_svc_error("error : g_path_get_dirname falied.");
+			return MS_MEDIA_ERR_OUT_OF_MEMORY;
+		}
+
+		if(STRING_VALID(storage_id))
+			sql = sqlite3_mprintf("SELECT folder_uuid  FROM '%s' WHERE storage_uuid = '%q' AND path = '%q';", MEDIA_SVC_DB_TABLE_FOLDER, storage_id, parent_folder_path);
+		else
+			sql = sqlite3_mprintf("SELECT folder_uuid  FROM '%s' WHERE path = '%q';", MEDIA_SVC_DB_TABLE_FOLDER, parent_folder_path);
+
+		SAFE_FREE(parent_folder_path);
+
+		ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
+		if (ret == MS_MEDIA_ERR_NONE) {
+			temp_parent_uuid =  (char *)sqlite3_column_text(sql_stmt, 0);
+			if (temp_parent_uuid != NULL) {
+				_strncpy_safe(parent_folder_uuid, temp_parent_uuid, MEDIA_SVC_UUID_SIZE+1);
+			}
+
+			SQLITE3_FINALIZE(sql_stmt);
+		}
+
+		if(STRING_VALID(parent_folder_uuid)) {
+			if(STRING_VALID(storage_id))
+				sql = sqlite3_mprintf("UPDATE %q SET parent_folder_uuid  = '%q' WHERE storage_uuid = '%q' AND path = '%q';", MEDIA_SVC_DB_TABLE_FOLDER, parent_folder_uuid, storage_id, folder_name);
+			else
+				sql = sqlite3_mprintf("UPDATE %q SET parent_folder_uuid  = '%q' WHERE path = '%q';", MEDIA_SVC_DB_TABLE_FOLDER, parent_folder_uuid, folder_name);
+			ret = _media_svc_sql_query(handle, sql, uid);
+			sqlite3_free(sql);
+		} else {
+			media_svc_error("error when get parent folder uuid");
+		}
+	}
+
 	return ret;
 }
 
-int _media_svc_append_folder(sqlite3 *handle, const char *storage_id, media_svc_storage_type_e storage_type,
-                             const char *folder_id, const char *path_name, const char *folder_name, int modified_date, const char *parent_folder_uuid, uid_t uid)
+static int __media_svc_append_folder(sqlite3 *handle, const char *storage_id, media_svc_storage_type_e storage_type,
+				    const char *folder_id, const char *folder_path, const char *parent_folder_uuid, bool stack_query, uid_t uid)
 {
 	int ret = MS_MEDIA_ERR_NONE;
+	char *folder_name = NULL;
+	int folder_modified_date = 0;
+
+	folder_name = g_path_get_basename(folder_path);
+	folder_modified_date = _media_svc_get_file_time(folder_path);
 
 	/*Update Pinyin If Support Pinyin*/
 	char *folder_name_pinyin = NULL;
@@ -70,10 +176,19 @@ int _media_svc_append_folder(sqlite3 *handle, const char *storage_id, media_svc_
 
 	char *sql = sqlite3_mprintf("INSERT INTO %s (folder_uuid, path, name, storage_uuid, storage_type, modified_time, name_pinyin, parent_folder_uuid) \
 							values (%Q, %Q, %Q, %Q, '%d', '%d', %Q, %Q); ",
-	                            MEDIA_SVC_DB_TABLE_FOLDER, folder_id, path_name, folder_name, storage_id, storage_type, modified_date, folder_name_pinyin, parent_folder_uuid);
-	ret = _media_svc_sql_query(handle, sql, uid);
-	sqlite3_free(sql);
+						     MEDIA_SVC_DB_TABLE_FOLDER, folder_id, folder_path, folder_name, storage_id, storage_type, folder_modified_date, folder_name_pinyin, parent_folder_uuid);
 
+	if(!stack_query)
+	{
+		ret = _media_svc_sql_query(handle, sql, uid);
+		sqlite3_free(sql);
+	}
+	else
+	{
+		_media_svc_sql_query_add(&g_media_svc_insert_folder_query_list, &sql);
+	}
+
+	SAFE_FREE(folder_name);
 	SAFE_FREE(folder_name_pinyin);
 
 	return ret;
@@ -98,16 +213,14 @@ int _media_svc_update_folder_modified_time_by_folder_uuid(sqlite3 *handle, const
 	return ret;
 }
 
-int __media_svc_get_and_append_parent_folder(sqlite3 *handle, const char *storage_id, const char *path, media_svc_storage_type_e storage_type, char *folder_id, uid_t uid)
+static int __media_svc_get_and_append_parent_folder(sqlite3 *handle, const char *storage_id, const char *path, media_svc_storage_type_e storage_type, char *folder_id, uid_t uid)
 {
 	int ret = MS_MEDIA_ERR_NONE;
-	unsigned int next_pos;
+	unsigned int next_pos = 0;
 	char *next = NULL;
 	char *dir_path = NULL;
-	char *token = "/";
+	const char *token = "/";
 	char *folder_uuid = NULL;
-	char *folder_name = NULL;
-	int folder_modified_date = 0;
 	char parent_folder_uuid[MEDIA_SVC_UUID_SIZE + 1] = {0, };
 	bool folder_search_end = FALSE;
 
@@ -117,6 +230,10 @@ int __media_svc_get_and_append_parent_folder(sqlite3 *handle, const char *storag
 		next_pos = strlen(_media_svc_get_path(uid));
 	else if (strncmp(path, MEDIA_ROOT_PATH_SDCARD, strlen(MEDIA_ROOT_PATH_SDCARD)) == 0)
 		next_pos = strlen(MEDIA_ROOT_PATH_SDCARD);
+	else if (strncmp(path, MEDIA_ROOT_PATH_CLOUD, strlen(MEDIA_ROOT_PATH_CLOUD)) == 0)
+		next_pos = strlen(MEDIA_ROOT_PATH_CLOUD);
+	else if (strncmp(path, MEDIA_ROOT_PATH_EXTERNAL, strlen(MEDIA_ROOT_PATH_EXTERNAL)) == 0)
+		next_pos = strlen(MEDIA_ROOT_PATH_EXTERNAL);
 	else {
 		media_svc_error("Invalid Path");
 		return MS_MEDIA_ERR_INTERNAL;
@@ -132,9 +249,15 @@ int __media_svc_get_and_append_parent_folder(sqlite3 *handle, const char *storag
 			media_svc_error("End Path");
 			dir_path = strndup(path, strlen(path));
 			folder_search_end = TRUE;
+			media_svc_error("[No-Error] End Path [%s]", dir_path);
 		}
 
-		ret = _media_svc_get_folder_id_by_foldername(handle, storage_id, dir_path, parent_folder_uuid);
+		if (strcmp(dir_path, MEDIA_ROOT_PATH_EXTERNAL) == 0) {
+			/*To avoid insert MEDIA_ROOT_PATH_EXTERNAL path*/
+			continue;
+		}
+
+		ret = _media_svc_get_folder_id_by_foldername(handle, storage_id, dir_path, parent_folder_uuid, uid);
 		if (ret == MS_MEDIA_ERR_DB_NO_RECORD) {
 			media_svc_error("NOT EXIST dir path : %s", dir_path);
 
@@ -145,17 +268,12 @@ int __media_svc_get_and_append_parent_folder(sqlite3 *handle, const char *storag
 				return MS_MEDIA_ERR_INTERNAL;
 			}
 
-			folder_name = g_path_get_basename(dir_path);
-			folder_modified_date = _media_svc_get_file_time(dir_path);
-
-			ret = _media_svc_append_folder(handle, storage_id, storage_type, folder_uuid, dir_path, folder_name, folder_modified_date, parent_folder_uuid, uid);
+			ret = __media_svc_append_folder(handle, storage_id, storage_type, folder_uuid, dir_path, parent_folder_uuid, FALSE, uid);
 			if (ret != MS_MEDIA_ERR_NONE) {
-				media_svc_error("_media_svc_append_folder is failed");
+				media_svc_error("__media_svc_append_folder is failed");
 			}
 
 			_strncpy_safe(parent_folder_uuid, folder_uuid, MEDIA_SVC_UUID_SIZE + 1);
-
-			SAFE_FREE(folder_name);
 		} else {
 			media_svc_error("EXIST dir path : %s\n", dir_path);
 		}
@@ -163,7 +281,12 @@ int __media_svc_get_and_append_parent_folder(sqlite3 *handle, const char *storag
 		SAFE_FREE(dir_path);
 	}
 
-	_strncpy_safe(folder_id, folder_uuid, MEDIA_SVC_UUID_SIZE + 1);
+	if(STRING_VALID(folder_uuid)) {
+		_strncpy_safe(folder_id, folder_uuid, MEDIA_SVC_UUID_SIZE + 1);
+	} else {
+		media_svc_error("Fail to get folder_uuid");
+		return MS_MEDIA_ERR_INTERNAL;
+	}
 
 	return MS_MEDIA_ERR_NONE;
 }
@@ -172,7 +295,7 @@ int _media_svc_get_and_append_folder(sqlite3 *handle, const char *storage_id, co
 {
 	int ret = MS_MEDIA_ERR_NONE;
 
-	ret = _media_svc_get_folder_id_by_foldername(handle, storage_id, path, folder_id);
+	ret = _media_svc_get_folder_id_by_foldername(handle, storage_id, path, folder_id, uid);
 
 	if (ret == MS_MEDIA_ERR_DB_NO_RECORD) {
 		ret = __media_svc_get_and_append_parent_folder(handle, storage_id, path, storage_type, folder_id, uid);
@@ -195,13 +318,13 @@ int _media_svc_get_and_append_folder_id_by_path(sqlite3 *handle, const char *sto
 	return ret;
 }
 
-int _media_svc_update_folder_table(sqlite3 *handle, uid_t uid)
+int _media_svc_update_folder_table(sqlite3 *handle, const char *storage_id, uid_t uid)
 {
 	int ret = MS_MEDIA_ERR_NONE;
 	char *sql = NULL;
 
-	sql = sqlite3_mprintf("DELETE FROM %s WHERE folder_uuid IN (SELECT folder_uuid FROM %s WHERE folder_uuid NOT IN (SELECT folder_uuid FROM %s))",
-	                      MEDIA_SVC_DB_TABLE_FOLDER, MEDIA_SVC_DB_TABLE_FOLDER, MEDIA_SVC_DB_TABLE_MEDIA);
+	sql = sqlite3_mprintf("DELETE FROM '%s' WHERE folder_uuid IN (SELECT folder_uuid FROM '%s' WHERE folder_uuid NOT IN (SELECT folder_uuid FROM '%s'))",
+	     MEDIA_SVC_DB_TABLE_FOLDER, MEDIA_SVC_DB_TABLE_FOLDER, storage_id);
 
 	ret = _media_svc_sql_query(handle, sql, uid);
 	sqlite3_free(sql);
@@ -213,7 +336,7 @@ static int __media_svc_count_all_folders(sqlite3 *handle, char *start_path, int
 {
 	int ret = MS_MEDIA_ERR_NONE;
 	sqlite3_stmt *sql_stmt = NULL;
-	char *sql = sqlite3_mprintf("SELECT count(*) FROM %s WHERE path LIKE '%q%%'", MEDIA_SVC_DB_TABLE_FOLDER, start_path);
+	char *sql = sqlite3_mprintf("SELECT count(*) FROM '%s' WHERE path LIKE '%q%%'", MEDIA_SVC_DB_TABLE_FOLDER, start_path);
 
 	ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 	if (ret != MS_MEDIA_ERR_NONE) {
@@ -245,7 +368,7 @@ int _media_svc_get_all_folders(sqlite3 *handle, char *start_path, char ***folder
 	}
 
 	if (cnt > 0) {
-		sql = sqlite3_mprintf("SELECT path, modified_time, folder_uuid FROM %s WHERE path LIKE '%q%%'", MEDIA_SVC_DB_TABLE_FOLDER, start_path);
+		sql = sqlite3_mprintf("SELECT path, modified_time, folder_uuid FROM '%s' WHERE path LIKE '%q%%'", MEDIA_SVC_DB_TABLE_FOLDER, start_path);
 	} else {
 		*folder_list = NULL;
 		*modified_time_list = NULL;
@@ -366,3 +489,134 @@ int _media_svc_get_folder_info_by_foldername(sqlite3 *handle, const char *folder
 
 	return ret;
 }
+
+int _media_svc_get_and_append_folder_id_by_folder_path(sqlite3 *handle, const char *storage_id, const char *path, media_svc_storage_type_e storage_type, char *folder_id, bool stack_query, uid_t uid)
+{
+	char *path_name = NULL;
+	int ret = MS_MEDIA_ERR_NONE;
+	char *sql = NULL;
+
+	path_name = strdup(path);
+	if (path_name == NULL) {
+		media_svc_error("out of memory");
+		return MS_MEDIA_ERR_OUT_OF_MEMORY;
+	}
+
+	ret = _media_svc_get_folder_id_by_foldername(handle, storage_id, path_name, folder_id, uid);
+	if (ret == MS_MEDIA_ERR_DB_NO_RECORD) {
+		bool is_root = FALSE;
+		bool is_parent_root = FALSE;
+
+		ret = __media_svc_is_root_path(path_name, &is_root);
+		ret = __media_svc_parent_is_ext_root_path(path_name, &is_parent_root);
+
+		char parent_folder_uuid[MEDIA_SVC_UUID_SIZE+1] = {0, };
+		memset(parent_folder_uuid, 0x00, sizeof(parent_folder_uuid));
+
+		if ((is_root == FALSE) && (is_parent_root == FALSE)) {
+			/*get parent folder id*/
+			char *parent_path_name = g_path_get_dirname(path_name);
+
+			ret = _media_svc_get_folder_id_by_foldername(handle, storage_id, parent_path_name, parent_folder_uuid, uid);
+			if (ret != MS_MEDIA_ERR_NONE) {
+				if (ret == MS_MEDIA_ERR_DB_NO_RECORD) {
+				/*if No-Root directory scanning start before doing storage scanning, parent_folder_uuid can be NULL.
+				You can remove above logic if use below logic always. but I keep above code for the performance issue.
+				Most case (except No-Root directory scanning start before doing storage scanning) get parent_folder_uuid well*/
+				media_svc_error("[No-Error] There is no proper parent_folder_uuid. so try to make it");
+				ret = _media_svc_get_and_append_folder(handle, storage_id, path, storage_type, folder_id, uid);
+				} else {
+					media_svc_error("error when _media_svc_get_parent_folder_id_by_foldername. err = [%d]", ret);
+				}
+
+				SAFE_FREE(path_name);
+				SAFE_FREE(parent_path_name);
+
+				return ret;
+			}
+		}
+
+		char *folder_uuid = _media_info_generate_uuid();
+		if (folder_uuid == NULL) {
+			media_svc_error("Invalid UUID");
+			SAFE_FREE(path_name);
+			return MS_MEDIA_ERR_INTERNAL;
+		}
+
+		ret = __media_svc_append_folder(handle, storage_id, storage_type, folder_uuid, path_name, parent_folder_uuid, stack_query, uid);
+
+		_strncpy_safe(folder_id, folder_uuid, MEDIA_SVC_UUID_SIZE+1);
+
+	} else {
+		sql = sqlite3_mprintf("UPDATE '%s' SET validity=1 WHERE storage_uuid = '%q' AND path = '%q'", MEDIA_SVC_DB_TABLE_FOLDER, storage_id, path);
+
+		if(!stack_query)
+		{
+			ret = _media_svc_sql_query(handle, sql, uid);
+			sqlite3_free(sql);
+		}
+		else
+		{
+			_media_svc_sql_query_add(&g_media_svc_insert_folder_query_list, &sql);
+		}
+	}
+
+	SAFE_FREE(path_name);
+
+	return ret;
+}
+
+int _media_svc_delete_invalid_folder(sqlite3 *handle, const char *storage_id, uid_t uid)
+{
+	int ret = MS_MEDIA_ERR_NONE;
+	char *sql = NULL;
+
+	sql = sqlite3_mprintf("DELETE FROM '%s' WHERE storage_uuid = '%q' AND validity = 0", MEDIA_SVC_DB_TABLE_FOLDER, storage_id);
+	ret = _media_svc_sql_query(handle, sql, uid);
+
+	sqlite3_free(sql);
+
+	return ret;
+}
+
+int _media_svc_set_folder_validity(sqlite3 *handle, const char *storage_id, const char *start_path, int validity, bool is_recursive, uid_t uid)
+{
+	int ret = MS_MEDIA_ERR_NONE;
+	char start_path_id[MEDIA_SVC_UUID_SIZE+1] = {0,};
+	char *sql = NULL;
+
+	if (is_recursive) {
+		sql = sqlite3_mprintf("UPDATE '%s' SET validity = %d WHERE storage_uuid = '%q' AND path LIKE '%q%%'", MEDIA_SVC_DB_TABLE_FOLDER, validity, storage_id, start_path);
+	} else {
+		ret = _media_svc_get_folder_id_by_foldername(handle, storage_id, start_path, start_path_id, uid);
+		media_svc_retvm_if(ret != MS_MEDIA_ERR_NONE, ret, "_media_svc_get_folder_id_by_foldername fail");
+		media_svc_retvm_if(!STRING_VALID(start_path_id), MS_MEDIA_ERR_INVALID_PARAMETER, "start_path_id is NULL");
+
+		sql = sqlite3_mprintf("UPDATE '%s' SET validity = %d WHERE storage_uuid = '%q' AND parent_folder_uuid = '%q'", MEDIA_SVC_DB_TABLE_FOLDER, validity, storage_id, start_path_id);
+	}
+
+	ret = _media_svc_sql_query(handle, sql, uid);
+
+	sqlite3_free(sql);
+
+	return ret;
+}
+
+int _media_svc_delete_folder_by_storage_id(sqlite3 *handle, const char *storage_id, media_svc_storage_type_e storage_type, uid_t uid)
+{
+	int ret = MS_MEDIA_ERR_NONE;
+	char *sql = NULL;
+
+	sql = sqlite3_mprintf("DELETE FROM '%s' WHERE storage_uuid = '%q' AND storage_type = %d", MEDIA_SVC_DB_TABLE_FOLDER, storage_id, storage_type);
+	ret = _media_svc_sql_query(handle, sql, uid);
+
+	sqlite3_free(sql);
+
+	return ret;
+}
+
+GList ** _media_svc_get_folder_list_ptr(void)
+{
+	return &g_media_svc_insert_folder_query_list;
+}
+
diff --git a/src/common/media-svc-media.c b/src/common/media-svc-media.c
index ccd1968..f9c133a 100755
--- a/src/common/media-svc-media.c
+++ b/src/common/media-svc-media.c
@@ -32,8 +32,6 @@
 #include "media-svc-db-utils.h"
 #include "media-svc-noti.h"
 
-#define GLOBAL_USER    0 /*#define     tzplatform_getenv(TZ_GLOBAL) //TODO */
-
 typedef struct {
 	char thumbnail_path[MEDIA_SVC_PATHNAME_SIZE];
 } media_svc_thumbnailpath_s;
@@ -43,19 +41,18 @@ static __thread GList *g_media_svc_insert_item_query_list = NULL;
 __thread GList *g_media_svc_move_item_query_list = NULL;
 static __thread GList *g_media_svc_update_item_query_list = NULL;
 
-static int __media_svc_count_invalid_records_with_thumbnail(sqlite3 *handle, media_svc_storage_type_e storage_type, int *count);
-static int __media_svc_get_invalid_records_with_thumbnail(sqlite3 *handle, media_svc_storage_type_e storage_type,
+static int __media_svc_count_invalid_records_with_thumbnail(sqlite3 *handle, const char *storage_id, media_svc_storage_type_e storage_type, int *count);
+static int __media_svc_get_invalid_records_with_thumbnail(sqlite3 *handle, const char *storage_id, media_svc_storage_type_e storage_type,
                                                           int count, media_svc_thumbnailpath_s *thumb_path);
-static int __media_svc_count_invalid_folder_records_with_thumbnail(sqlite3 *handle, const char *folder_path, int *count);
-static int __media_svc_get_invalid_folder_records_with_thumbnail(sqlite3 *handle, const char *folder_path,
-                                                                 int count, media_svc_thumbnailpath_s *thumb_path);
+static int __media_svc_count_invalid_folder_records_with_thumbnail(sqlite3 *handle, const char *storage_id, const char *folder_path, const char *folder_uuid, bool is_recursive, int *count);
+static int __media_svc_get_invalid_folder_records_with_thumbnail(sqlite3 *handle, const char *storage_id, const char *folder_path, const char *folder_uuid, bool is_recursive, int count, media_svc_thumbnailpath_s *thumb_path);
 
-static int __media_svc_count_invalid_records_with_thumbnail(sqlite3 *handle, media_svc_storage_type_e storage_type, int *count)
+static int __media_svc_count_invalid_records_with_thumbnail(sqlite3 *handle, const char *storage_id, media_svc_storage_type_e storage_type, int *count)
 {
 	int ret = MS_MEDIA_ERR_NONE;
 	sqlite3_stmt *sql_stmt = NULL;
-	char *sql = sqlite3_mprintf("SELECT count(*) FROM %s WHERE validity=0 AND storage_type=%d AND thumbnail_path IS NOT NULL",
-	                            MEDIA_SVC_DB_TABLE_MEDIA, storage_type);
+	char *sql = sqlite3_mprintf("SELECT count(*) FROM '%s' WHERE validity=0 AND storage_type=%d AND thumbnail_path IS NOT NULL",
+					storage_id, storage_type);
 
 	ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 
@@ -72,15 +69,15 @@ static int __media_svc_count_invalid_records_with_thumbnail(sqlite3 *handle, med
 
 }
 
-static int __media_svc_get_invalid_records_with_thumbnail(sqlite3 *handle, media_svc_storage_type_e storage_type,
-                                                          int count, media_svc_thumbnailpath_s *thumb_path)
+static int __media_svc_get_invalid_records_with_thumbnail(sqlite3 *handle, const char *storage_id, media_svc_storage_type_e storage_type,
+							int count, media_svc_thumbnailpath_s * thumb_path)
 {
 	int ret = MS_MEDIA_ERR_NONE;
 	sqlite3_stmt *sql_stmt = NULL;
 	int idx = 0;
 
-	char *sql = sqlite3_mprintf("SELECT thumbnail_path from (select thumbnail_path, validity from %s WHERE storage_type=%d AND thumbnail_path IS NOT NULL GROUP BY thumbnail_path HAVING count() = 1) WHERE validity=0",
-	                            MEDIA_SVC_DB_TABLE_MEDIA, storage_type);
+	char *sql = sqlite3_mprintf("SELECT thumbnail_path from (select thumbnail_path, validity from '%s' WHERE storage_type=%d AND thumbnail_path IS NOT NULL GROUP BY thumbnail_path HAVING count() = 1) WHERE validity=0",
+					MEDIA_SVC_DB_TABLE_MEDIA, storage_type);
 
 	media_svc_debug("[SQL query] : %s", sql);
 
@@ -101,12 +98,17 @@ static int __media_svc_get_invalid_records_with_thumbnail(sqlite3 *handle, media
 	return MS_MEDIA_ERR_NONE;
 }
 
-static int __media_svc_count_invalid_folder_records_with_thumbnail(sqlite3 *handle, const char *folder_path, int *count)
+static int __media_svc_count_invalid_folder_records_with_thumbnail(sqlite3 *handle, const char *storage_id, const char *folder_path, const char *folder_uuid, bool is_recursive, int *count)
 {
 	int ret = MS_MEDIA_ERR_NONE;
 	sqlite3_stmt *sql_stmt = NULL;
-	char *sql = sqlite3_mprintf("SELECT count(*) FROM %s WHERE validity=0 AND path LIKE '%q/%%' AND thumbnail_path IS NOT NULL",
-	                            MEDIA_SVC_DB_TABLE_MEDIA, folder_path);
+	char *sql = NULL;
+
+	if (is_recursive) {
+		sql = sqlite3_mprintf("SELECT count(*) FROM '%s' WHERE validity=0 AND path LIKE '%q/%%' AND thumbnail_path IS NOT NULL", storage_id, folder_path);
+	} else {
+		sql = sqlite3_mprintf("SELECT count(*) FROM '%s' WHERE validity=0 AND folder_uuid = '%q' AND thumbnail_path IS NOT NULL", storage_id, folder_uuid);
+	}
 
 	ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 
@@ -123,15 +125,19 @@ static int __media_svc_count_invalid_folder_records_with_thumbnail(sqlite3 *hand
 
 }
 
-static int __media_svc_get_invalid_folder_records_with_thumbnail(sqlite3 *handle, const char *folder_path,
-                                                                 int count, media_svc_thumbnailpath_s *thumb_path)
+static int __media_svc_get_invalid_folder_records_with_thumbnail(sqlite3 *handle, const char *storage_id, const char *folder_path, const char *folder_uuid, bool is_recursive,
+							int count, media_svc_thumbnailpath_s * thumb_path)
 {
 	int ret = MS_MEDIA_ERR_NONE;
 	sqlite3_stmt *sql_stmt = NULL;
 	int idx = 0;
+	char *sql = NULL;
 
-	char *sql = sqlite3_mprintf("SELECT thumbnail_path from (select thumbnail_path, validity from %s WHERE path LIKE '%q/%%' AND thumbnail_path IS NOT NULL GROUP BY thumbnail_path HAVING count() = 1) WHERE validity=0",
-	                            MEDIA_SVC_DB_TABLE_MEDIA, folder_path);
+	if (is_recursive) {
+		sql = sqlite3_mprintf("SELECT thumbnail_path from (select thumbnail_path, validity from '%s'  WHERE path LIKE '%q/%%' AND thumbnail_path IS NOT NULL GROUP BY thumbnail_path HAVING count() = 1) WHERE validity=0", storage_id, folder_path);
+	} else {
+		sql = sqlite3_mprintf("SELECT thumbnail_path from (select thumbnail_path, validity from '%s'  WHERE folder_uuid =  '%q' AND thumbnail_path IS NOT NULL GROUP BY thumbnail_path HAVING count() = 1) WHERE validity=0", storage_id, folder_uuid);
+	}
 
 	media_svc_debug("[SQL query] : %s", sql);
 
@@ -151,12 +157,12 @@ static int __media_svc_get_invalid_folder_records_with_thumbnail(sqlite3 *handle
 	return MS_MEDIA_ERR_NONE;
 }
 
-int _media_svc_count_record_with_path(sqlite3 *handle, const char *path, int *count)
+int _media_svc_count_record_with_path(sqlite3 *handle,  const char *storage_id, const char *path, int *count)
 {
 	int ret = MS_MEDIA_ERR_NONE;
 	sqlite3_stmt *sql_stmt = NULL;
 
-	char *sql = sqlite3_mprintf("SELECT count(*) FROM %s WHERE path='%q'", MEDIA_SVC_DB_TABLE_MEDIA, path);
+	char *sql = sqlite3_mprintf("SELECT count(*) FROM '%s' WHERE path='%q'", storage_id, path);
 
 	ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 
@@ -204,12 +210,12 @@ char *_media_svc_get_thumb_default_path(uid_t uid)
 	return result_psswd;
 }
 
-int _media_svc_insert_item_with_data(sqlite3 *handle, media_svc_content_info_s *content_info, int is_burst, bool stack_query, uid_t uid)
+int _media_svc_insert_item_with_data(sqlite3 *handle, const char *storage_id, media_svc_content_info_s *content_info, int is_burst, bool stack_query, uid_t uid)
 {
 	int ret = MS_MEDIA_ERR_NONE;
 	char *burst_id = NULL;
 
-	char *db_fields = "media_uuid, path, file_name, media_type, mime_type, size, added_time, modified_time, folder_uuid, \
+	const char *db_fields = "media_uuid, path, file_name, media_type, mime_type, size, added_time, modified_time, folder_uuid, \
 					thumbnail_path, title, album_id, album, artist, album_artist, genre, composer, year, recorded_date, copyright, track_num, description, \
 					bitrate, bitpersample, samplerate, channel, duration, longitude, latitude, altitude, exposure_time, fnumber, iso, model, width, height, datetaken, orientation, \
 					rating, is_drm, storage_type, burst_id, timeline, weather, sync_status, \
@@ -222,7 +228,7 @@ int _media_svc_insert_item_with_data(sqlite3 *handle, media_svc_content_info_s *
 
 	if (is_burst) {
 		int burst_id_int = 0;
-		ret = _media_svc_get_burst_id(handle, &burst_id_int);
+		ret = _media_svc_get_burst_id(handle, storage_id, &burst_id_int);
 		if (ret != MS_MEDIA_ERR_NONE) {
 			burst_id = NULL;
 		}
@@ -413,7 +419,6 @@ int _media_svc_update_meta_with_data(sqlite3 *handle, media_svc_content_info_s *
 								content_info->path
 	                           );
 
-	media_svc_error("");
 	if (sql != NULL) {
 		media_svc_debug("query : %s", sql);
 		_media_svc_sql_query_add(&g_media_svc_update_item_query_list, &sql);
@@ -422,8 +427,6 @@ int _media_svc_update_meta_with_data(sqlite3 *handle, media_svc_content_info_s *
 		ret = MS_MEDIA_ERR_OUT_OF_MEMORY;
 	}
 
-	media_svc_error("");
-
 	return ret;
 }
 
@@ -569,10 +572,11 @@ int _media_svc_delete_item_by_path(sqlite3 *handle, const char *storage_id, cons
 	return ret;
 }
 
-int _media_svc_truncate_table(sqlite3 *handle, media_svc_storage_type_e storage_type, uid_t uid)
+int _media_svc_truncate_table(sqlite3 *handle, const char *storage_id, media_svc_storage_type_e storage_type, uid_t uid)
 {
 	int ret = MS_MEDIA_ERR_NONE;
-	char *sql = sqlite3_mprintf("DELETE FROM %s WHERE storage_type=%d", MEDIA_SVC_DB_TABLE_MEDIA, storage_type);
+
+	char *sql = sqlite3_mprintf("DELETE FROM '%s' where storage_type=%d", storage_id, storage_type);
 
 	ret = _media_svc_sql_query(handle, sql, uid);
 	sqlite3_free(sql);
@@ -580,14 +584,14 @@ int _media_svc_truncate_table(sqlite3 *handle, media_svc_storage_type_e storage_
 	return ret;
 }
 
-int _media_svc_delete_invalid_items(sqlite3 *handle, media_svc_storage_type_e storage_type, uid_t uid)
+int _media_svc_delete_invalid_items(sqlite3 *handle, const char *storage_id, media_svc_storage_type_e storage_type, uid_t uid)
 {
 	int idx = 0;
 	media_svc_thumbnailpath_s *thumbpath_record = NULL;
 	int invalid_count = 0;
 	int ret = MS_MEDIA_ERR_NONE;
 
-	ret = __media_svc_count_invalid_records_with_thumbnail(handle, storage_type, &invalid_count);
+	ret = __media_svc_count_invalid_records_with_thumbnail(handle, storage_id, storage_type, &invalid_count);
 	media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 
 	media_svc_debug("invalid count: %d", invalid_count);
@@ -599,7 +603,7 @@ int _media_svc_delete_invalid_items(sqlite3 *handle, media_svc_storage_type_e st
 			return MS_MEDIA_ERR_OUT_OF_MEMORY;
 		}
 
-		ret = __media_svc_get_invalid_records_with_thumbnail(handle, storage_type, invalid_count, thumbpath_record);
+		ret = __media_svc_get_invalid_records_with_thumbnail(handle, storage_id, storage_type, invalid_count, thumbpath_record);
 		if (ret != MS_MEDIA_ERR_NONE) {
 			media_svc_error("error when get thumbnail record");
 			SAFE_FREE(thumbpath_record);
@@ -609,7 +613,8 @@ int _media_svc_delete_invalid_items(sqlite3 *handle, media_svc_storage_type_e st
 		media_svc_debug("There is no item with thumbnail");
 	}
 
-	char *sql = sqlite3_mprintf("DELETE FROM %s WHERE validity = 0 AND storage_type=%d", MEDIA_SVC_DB_TABLE_MEDIA, storage_type);
+	char *sql = sqlite3_mprintf("DELETE FROM '%s' WHERE validity = 0", storage_id);
+
 	ret = _media_svc_sql_query(handle, sql, uid);
 	sqlite3_free(sql);
 	if (ret != MS_MEDIA_ERR_NONE) {
@@ -632,14 +637,20 @@ int _media_svc_delete_invalid_items(sqlite3 *handle, media_svc_storage_type_e st
 	return MS_MEDIA_ERR_NONE;
 }
 
-int _media_svc_delete_invalid_folder_items(sqlite3 *handle, const char *folder_path, uid_t uid)
+int _media_svc_delete_invalid_folder_items(sqlite3 *handle, const char *storage_id, const char *folder_path, bool is_recursive, uid_t uid)
 {
 	int idx = 0;
 	media_svc_thumbnailpath_s *thumbpath_record = NULL;
 	int invalid_count = 0;
 	int ret = MS_MEDIA_ERR_NONE;
+	char folder_uuid[MEDIA_SVC_UUID_SIZE+1] = {0,};
+	char *sql = NULL;
 
-	ret = __media_svc_count_invalid_folder_records_with_thumbnail(handle, folder_path, &invalid_count);
+	/*get folder uuid from DB*/
+	ret = _media_svc_get_folder_id_by_foldername(handle, storage_id, folder_path, folder_uuid, uid);
+	media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
+
+	ret = __media_svc_count_invalid_folder_records_with_thumbnail(handle, storage_id, folder_path, folder_uuid, is_recursive, &invalid_count);
 	media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 
 	media_svc_debug("invalid count: %d", invalid_count);
@@ -651,7 +662,7 @@ int _media_svc_delete_invalid_folder_items(sqlite3 *handle, const char *folder_p
 			return MS_MEDIA_ERR_OUT_OF_MEMORY;
 		}
 
-		ret = __media_svc_get_invalid_folder_records_with_thumbnail(handle, folder_path, invalid_count, thumbpath_record);
+		ret = __media_svc_get_invalid_folder_records_with_thumbnail(handle, storage_id, folder_path, folder_uuid, is_recursive, invalid_count, thumbpath_record);
 		if (ret != MS_MEDIA_ERR_NONE) {
 			media_svc_error("error when get thumbnail record");
 			SAFE_FREE(thumbpath_record);
@@ -661,7 +672,12 @@ int _media_svc_delete_invalid_folder_items(sqlite3 *handle, const char *folder_p
 		media_svc_debug("There is no item with thumbnail");
 	}
 
-	char *sql = sqlite3_mprintf("DELETE FROM %s WHERE validity = 0 AND path LIKE '%q/%%'", MEDIA_SVC_DB_TABLE_MEDIA, folder_path);
+	if (is_recursive) {
+		sql = sqlite3_mprintf("DELETE FROM '%s' WHERE validity = 0 AND path LIKE '%q/%%'", storage_id, folder_path);
+	} else {
+		sql = sqlite3_mprintf("DELETE FROM '%s' WHERE validity = 0 AND folder_uuid='%q'", storage_id, folder_uuid);
+	}
+
 	ret = _media_svc_sql_query(handle, sql, uid);
 	sqlite3_free(sql);
 	if (ret != MS_MEDIA_ERR_NONE) {
@@ -670,25 +686,27 @@ int _media_svc_delete_invalid_folder_items(sqlite3 *handle, const char *folder_p
 	}
 
 	/*Delete thumbnails*/
-	for (idx = 0; idx < invalid_count; idx++) {
-		if ((strlen(thumbpath_record[idx].thumbnail_path) > 0) && (strncmp(thumbpath_record[idx].thumbnail_path, _media_svc_get_thumb_default_path(uid), sizeof(_media_svc_get_thumb_default_path(uid))) != 0)) {
-			ret = _media_svc_remove_file(thumbpath_record[idx].thumbnail_path);
-			if (ret != MS_MEDIA_ERR_NONE) {
-				media_svc_error("fail to remove thumbnail file.");
+	if (thumbpath_record != NULL)	 {
+		for (idx = 0; idx < invalid_count; idx++) {
+			if ((strlen(thumbpath_record[idx].thumbnail_path) > 0) && (strncmp(thumbpath_record[idx].thumbnail_path, _media_svc_get_thumb_default_path(uid), sizeof(_media_svc_get_thumb_default_path(uid))) != 0)) {
+				ret = _media_svc_remove_file(thumbpath_record[idx].thumbnail_path);
+				if (ret != MS_MEDIA_ERR_NONE) {
+					media_svc_error("fail to remove thumbnail file.");
+				}
 			}
 		}
-	}
 
-	SAFE_FREE(thumbpath_record);
+		SAFE_FREE(thumbpath_record);
+	}
 
 	return MS_MEDIA_ERR_NONE;
 }
 
-int _media_svc_update_item_validity(sqlite3 *handle, const char *path, int validity, bool stack_query, uid_t uid)
+int _media_svc_update_item_validity(sqlite3 *handle, const char *storage_id, const char *path, int validity, bool stack_query, uid_t uid)
 {
 	int ret = MS_MEDIA_ERR_NONE;
 
-	char *sql = sqlite3_mprintf("UPDATE %s SET validity=%d WHERE path= '%q'", MEDIA_SVC_DB_TABLE_MEDIA, validity, path);
+	char *sql = sqlite3_mprintf("UPDATE '%s' SET validity=%d WHERE path= '%q'", storage_id, validity, path);
 
 	if (!stack_query) {
 		ret = _media_svc_sql_query(handle, sql, uid);
@@ -700,7 +718,7 @@ int _media_svc_update_item_validity(sqlite3 *handle, const char *path, int valid
 	return ret;
 }
 
-int _media_svc_update_thumbnail_path(sqlite3 *handle,  const char *storage_id, const char *path, const char *thumb_path, uid_t uid)
+int _media_svc_update_thumbnail_path(sqlite3 *handle, const char *storage_id, const char *path, const char *thumb_path, uid_t uid)
 {
 	int ret = MS_MEDIA_ERR_NONE;
 
@@ -712,11 +730,11 @@ int _media_svc_update_thumbnail_path(sqlite3 *handle,  const char *storage_id, c
 	return ret;
 }
 
-int _media_svc_update_storage_item_validity(sqlite3 *handle, media_svc_storage_type_e storage_type, int validity, uid_t uid)
+int _media_svc_update_storage_item_validity(sqlite3 *handle, const char *storage_id, media_svc_storage_type_e storage_type, int validity, uid_t uid)
 {
 	int ret = MS_MEDIA_ERR_NONE;
 
-	char *sql = sqlite3_mprintf("UPDATE %s SET validity=%d WHERE storage_type=%d", MEDIA_SVC_DB_TABLE_MEDIA, validity, storage_type);
+	char *sql = sqlite3_mprintf("UPDATE '%s' SET validity=%d WHERE storage_type=%d", storage_id, validity, storage_type);
 
 	ret = _media_svc_sql_query(handle, sql, uid);
 	sqlite3_free(sql);
@@ -724,7 +742,7 @@ int _media_svc_update_storage_item_validity(sqlite3 *handle, media_svc_storage_t
 	return ret;
 }
 
-int _media_svc_update_folder_item_validity(sqlite3 *handle, const char *folder_path, int validity, uid_t uid)
+int _media_svc_update_folder_item_validity(sqlite3 *handle, const char *storage_id, const char *folder_path, int validity, uid_t uid)
 {
 	int ret = MS_MEDIA_ERR_NONE;
 	char *sql = NULL;
@@ -732,7 +750,8 @@ int _media_svc_update_folder_item_validity(sqlite3 *handle, const char *folder_p
 	sqlite3_stmt *sql_stmt = NULL;
 
 	/*Get folder ID*/
-	sql = sqlite3_mprintf("SELECT folder_uuid FROM %s WHERE path='%q'", MEDIA_SVC_DB_TABLE_FOLDER, folder_path);
+	sql = sqlite3_mprintf("SELECT folder_uuid FROM '%s' WHERE path='%q' AND storage_uuid='%q'", MEDIA_SVC_DB_TABLE_FOLDER, folder_path, storage_id);
+
 	ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 	if (ret != MS_MEDIA_ERR_NONE) {
 		if (ret == MS_MEDIA_ERR_DB_NO_RECORD)
@@ -747,19 +766,20 @@ int _media_svc_update_folder_item_validity(sqlite3 *handle, const char *folder_p
 	SQLITE3_FINALIZE(sql_stmt);
 
 	/*Update folder item validity*/
-	sql = sqlite3_mprintf("UPDATE %s SET validity=%d WHERE (storage_type = 0 OR storage_type = 1) AND folder_uuid='%q'", MEDIA_SVC_DB_TABLE_MEDIA, validity, folder_uuid);
+	sql = sqlite3_mprintf("UPDATE '%s' SET validity=%d WHERE folder_uuid='%q'", storage_id, validity, folder_uuid);
+
 	ret = _media_svc_sql_query(handle, sql, uid);
 	sqlite3_free(sql);
 
 	return ret;
 }
 
-int _media_svc_update_recursive_folder_item_validity(sqlite3 *handle, const char *folder_path, int validity, uid_t uid)
+int _media_svc_update_recursive_folder_item_validity(sqlite3 *handle, const char *storage_id, const char *folder_path, int validity, uid_t uid)
 {
 	int ret = MS_MEDIA_ERR_NONE;
 
 	/*Update folder item validity*/
-	char *sql = sqlite3_mprintf("UPDATE %s SET validity=%d WHERE (storage_type = 0 OR storage_type = 1) AND path LIKE '%q/%%'", MEDIA_SVC_DB_TABLE_MEDIA, validity, folder_path);
+	char *sql = sqlite3_mprintf("UPDATE '%s' SET validity=%d WHERE (storage_type = 0 OR storage_type = 1) AND path LIKE '%q/%%'", storage_id, validity, folder_path);
 
 	ret = _media_svc_sql_query(handle, sql, uid);
 	sqlite3_free(sql);
@@ -767,8 +787,8 @@ int _media_svc_update_recursive_folder_item_validity(sqlite3 *handle, const char
 	return ret;
 }
 
-int _media_svc_update_item_by_path(sqlite3 *handle, const char *src_path, media_svc_storage_type_e dest_storage, const char *dest_path,
-                                   const char *file_name, int modified_time, const char *folder_uuid, const char *thumb_path, bool stack_query, uid_t uid)
+int _media_svc_update_item_by_path(sqlite3 *handle, const char *storage_id, const char *src_path, media_svc_storage_type_e dest_storage, const char *dest_path,
+				const char *file_name, int modified_time, const char *folder_uuid, const char *thumb_path, bool stack_query, uid_t uid)
 {
 	/* update path, filename, modified_time, folder_uuid, thumbnail_path, */
 	/* played_count, last_played_time, last_played_position, favourite, storaget_type*/
@@ -777,17 +797,17 @@ int _media_svc_update_item_by_path(sqlite3 *handle, const char *src_path, media_
 	char *sql = NULL;
 
 	if (thumb_path != NULL) {
-		sql = sqlite3_mprintf("UPDATE %s SET \
+		sql = sqlite3_mprintf("UPDATE '%s' SET \
 					path=%Q, file_name=%Q, modified_time=%d, folder_uuid=%Q, thumbnail_path=%Q, storage_type=%d, \
 					played_count=0, last_played_time=0, last_played_position=0 \
 					WHERE path=%Q",
-		                      MEDIA_SVC_DB_TABLE_MEDIA, dest_path, file_name, modified_time, folder_uuid, thumb_path, dest_storage, src_path);
+					storage_id, dest_path, file_name, modified_time, folder_uuid, thumb_path, dest_storage, src_path);
 	} else {
-		sql = sqlite3_mprintf("UPDATE %s SET \
+		sql = sqlite3_mprintf("UPDATE '%s' SET \
 					path=%Q, file_name=%Q, modified_time=%d, folder_uuid=%Q, storage_type=%d, \
 					played_count=0, last_played_time=0, last_played_position=0 \
 					WHERE path=%Q",
-		                      MEDIA_SVC_DB_TABLE_MEDIA, dest_path, file_name, modified_time, folder_uuid, dest_storage, src_path);
+					storage_id, dest_path, file_name, modified_time, folder_uuid, dest_storage, src_path);
 	}
 
 	if (!stack_query) {
@@ -813,6 +833,10 @@ int _media_svc_list_query_do(sqlite3 *handle, media_svc_query_type_e query_type,
 		ret = _media_svc_sql_query_list(handle, &g_media_svc_move_item_query_list, uid);
 	else if (query_type == MEDIA_SVC_QUERY_INSERT_ITEM)
 		ret = _media_svc_sql_query_list(handle, &g_media_svc_insert_item_query_list, uid);
+	else if (query_type == MEDIA_SVC_QUERY_UPDATE_ITEM)
+		ret = _media_svc_sql_query_list(handle, &g_media_svc_update_item_query_list, uid);
+	else if (query_type == MEDIA_SVC_QUERY_INSERT_FOLDER)
+		ret = _media_svc_sql_query_list(handle,  _media_svc_get_folder_list_ptr(), uid);
 	else
 		ret = MS_MEDIA_ERR_INVALID_PARAMETER;
 
@@ -832,12 +856,12 @@ int _media_svc_list_query_do(sqlite3 *handle, media_svc_query_type_e query_type,
 	return MS_MEDIA_ERR_NONE;
 }
 
-int _media_svc_get_burst_id(sqlite3 *handle, int *id)
+int _media_svc_get_burst_id(sqlite3 *handle, const char *storage_id, int *id)
 {
 	int ret = MS_MEDIA_ERR_NONE;
 	int cur_id = -1;
 	sqlite3_stmt *sql_stmt = NULL;
-	char *sql = sqlite3_mprintf("SELECT max(CAST(burst_id AS INTEGER)) FROM %s", MEDIA_SVC_DB_TABLE_MEDIA);
+	char *sql = sqlite3_mprintf("SELECT max(CAST(burst_id AS INTEGER)) FROM '%s'", storage_id);
 
 	ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 
@@ -853,7 +877,7 @@ int _media_svc_get_burst_id(sqlite3 *handle, int *id)
 	return MS_MEDIA_ERR_NONE;
 }
 
-int _media_svc_get_noti_info(sqlite3 *handle,  const char *storage_id, const char *path, int update_item, media_svc_noti_item **item)
+int _media_svc_get_noti_info(sqlite3 *handle, const char *storage_id, const char *path, int update_item, media_svc_noti_item **item)
 {
 	int ret = MS_MEDIA_ERR_NONE;
 	sqlite3_stmt *sql_stmt = NULL;
@@ -915,12 +939,12 @@ int _media_svc_get_noti_info(sqlite3 *handle,  const char *storage_id, const cha
 	return MS_MEDIA_ERR_NONE;
 }
 
-int _media_svc_count_invalid_folder_items(sqlite3 *handle, const char *folder_path, int *count)
+int _media_svc_count_invalid_folder_items(sqlite3 *handle, const char *storage_id, const char *folder_path, int *count)
 {
 	int ret = MS_MEDIA_ERR_NONE;
 	sqlite3_stmt *sql_stmt = NULL;
-	char *sql = sqlite3_mprintf("SELECT count(*) FROM %s WHERE validity=0 AND path LIKE '%q/%%'",
-	                            MEDIA_SVC_DB_TABLE_MEDIA, folder_path);
+
+	char *sql = sqlite3_mprintf("SELECT count(*) FROM '%s' WHERE validity=0 AND path LIKE '%q/%%'", storage_id, folder_path);
 
 	ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 
@@ -936,11 +960,11 @@ int _media_svc_count_invalid_folder_items(sqlite3 *handle, const char *folder_pa
 	return MS_MEDIA_ERR_NONE;
 }
 
-int _media_svc_get_thumbnail_count(sqlite3 *handle, const char *thumb_path, int *count)
+int _media_svc_get_thumbnail_count(sqlite3 *handle, const char *storage_id, const char *thumb_path, int *count)
 {
 	int ret = MS_MEDIA_ERR_NONE;
 	sqlite3_stmt *sql_stmt = NULL;
-	char *sql = sqlite3_mprintf("SELECT count(*) FROM %s WHERE thumbnail_path=%Q", MEDIA_SVC_DB_TABLE_MEDIA, thumb_path);
+	char *sql = sqlite3_mprintf("SELECT count(*) FROM '%s' WHERE thumbnail_path=%Q", storage_id, thumb_path);
 
 	ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 
@@ -956,12 +980,11 @@ int _media_svc_get_thumbnail_count(sqlite3 *handle, const char *thumb_path, int
 	return MS_MEDIA_ERR_NONE;
 }
 
-int _media_svc_get_fileinfo_by_path(sqlite3 *handle, const char *path, time_t *modified_time, unsigned long long *size)
+int _media_svc_get_fileinfo_by_path(sqlite3 *handle, const char *storage_id, const char *path, time_t *modified_time, unsigned long long *size)
 {
 	int ret = MS_MEDIA_ERR_NONE;
 	sqlite3_stmt *sql_stmt = NULL;
-	char *sql = sqlite3_mprintf("SELECT modified_time, size FROM %s WHERE path='%q'",
-	                            MEDIA_SVC_DB_TABLE_MEDIA, path);
+	char *sql = sqlite3_mprintf("SELECT modified_time, size FROM '%s' WHERE path='%q'", storage_id, path);
 
 	ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 
@@ -977,3 +1000,194 @@ int _media_svc_get_fileinfo_by_path(sqlite3 *handle, const char *path, time_t *m
 
 	return MS_MEDIA_ERR_NONE;
 }
+
+int _media_svc_insert_item_pass1(sqlite3 *handle, const char *storage_id, media_svc_content_info_s *content_info, int is_burst, bool stack_query, uid_t uid)
+{
+	int ret = MS_MEDIA_ERR_NONE;
+	char *burst_id = NULL;
+
+	media_svc_debug("START pass1");
+
+	char * db_fields = (char *)"media_uuid, folder_uuid, path, file_name, media_type, mime_type, size, added_time, modified_time, is_drm, storage_type, timeline, burst_id, storage_uuid";
+#if 0
+	if (is_burst) {
+		int burst_id_int = 0;
+		ret = _media_svc_get_burst_id(handle, storage_id, &burst_id_int);
+		if (ret != MS_MEDIA_ERR_NONE) {
+			burst_id = NULL;
+		}
+
+		if (burst_id_int > 0) {
+			media_svc_debug("Burst id : %d", burst_id_int);
+			burst_id = sqlite3_mprintf("%d", burst_id_int);
+		}
+
+		/* Get thumbnail for burst shot */
+		char thumb_path[MEDIA_SVC_PATHNAME_SIZE + 1] = {0, };
+		int width = 0;
+		int height = 0;
+
+		ret = _media_svc_request_thumbnail_with_origin_size(content_info->path, thumb_path, sizeof(thumb_path), &width, &height);
+		if(ret == MS_MEDIA_ERR_NONE) {
+			ret = __media_svc_malloc_and_strncpy(&(content_info->thumbnail_path), thumb_path);
+			if (ret != MS_MEDIA_ERR_NONE) {
+				content_info->thumbnail_path = NULL;
+			}
+		}
+
+		if (content_info->media_meta.width <= 0)
+			content_info->media_meta.width = width;
+
+		if (content_info->media_meta.height <= 0)
+			content_info->media_meta.height = height;
+	}
+
+	/* Update Pinyin If Support Pinyin */
+	if(_media_svc_check_pinyin_support())
+	{
+		if(STRING_VALID(content_info->file_name))
+			_media_svc_get_pinyin_str(content_info->file_name, &content_info->file_name_pinyin);
+	}
+#endif
+
+	char *sql = sqlite3_mprintf("INSERT INTO '%s' (%s) VALUES (%Q, %Q, %Q, %Q, %d, %Q, %lld, \
+								%d, %d, %d, %d, %d, %Q, %Q);",
+		storage_id, db_fields,
+		content_info->media_uuid,
+		content_info->folder_uuid,
+		content_info->path,
+		content_info->file_name,
+		content_info->media_type,
+		content_info->mime_type,
+		content_info->size,
+		content_info->added_time,
+		content_info->modified_time,
+		content_info->is_drm,
+		content_info->storage_type,
+		content_info->timeline,
+		burst_id,
+		storage_id
+		);
+#if 0
+	if (burst_id)
+	{
+		sqlite3_free(burst_id);
+		burst_id = NULL;
+	}
+#endif
+	media_svc_debug("MAKE PASS 1 QUERY END");
+
+	if(!stack_query) {
+		ret = _media_svc_sql_query(handle, sql, uid);
+		sqlite3_free(sql);
+		if (ret != MS_MEDIA_ERR_NONE) {
+			media_svc_error("failed to insert item");
+			return ret;
+		}
+	} else {
+		media_svc_debug("query : %s", sql);
+		_media_svc_sql_query_add(&g_media_svc_insert_item_query_list, &sql);
+	}
+	media_svc_debug("END");
+	return MS_MEDIA_ERR_NONE;
+}
+
+int _media_svc_insert_item_pass2(sqlite3 *handle, const char *storage_id, media_svc_content_info_s *content_info, int is_burst, bool stack_query, uid_t uid)
+{
+	int ret = MS_MEDIA_ERR_NONE;
+	//char *burst_id = NULL;
+
+	media_svc_debug_fenter();
+
+	/*Update Pinyin If Support Pinyin*/
+	if(_media_svc_check_pinyin_support())
+	{
+		if(STRING_VALID(content_info->file_name))
+			_media_svc_get_pinyin_str(content_info->file_name, &content_info->file_name_pinyin);
+		if(STRING_VALID(content_info->media_meta.title))
+			_media_svc_get_pinyin_str(content_info->media_meta.title, &content_info->media_meta.title_pinyin);
+		if(STRING_VALID(content_info->media_meta.album))
+			_media_svc_get_pinyin_str(content_info->media_meta.album, &content_info->media_meta.album_pinyin);
+		if(STRING_VALID(content_info->media_meta.artist))
+			_media_svc_get_pinyin_str(content_info->media_meta.artist, &content_info->media_meta.artist_pinyin);
+		if(STRING_VALID(content_info->media_meta.album_artist))
+			_media_svc_get_pinyin_str(content_info->media_meta.album_artist, &content_info->media_meta.album_artist_pinyin);
+		if(STRING_VALID(content_info->media_meta.genre))
+			_media_svc_get_pinyin_str(content_info->media_meta.genre, &content_info->media_meta.genre_pinyin);
+		if(STRING_VALID(content_info->media_meta.composer))
+			_media_svc_get_pinyin_str(content_info->media_meta.composer, &content_info->media_meta.composer_pinyin);
+		if(STRING_VALID(content_info->media_meta.copyright))
+			_media_svc_get_pinyin_str(content_info->media_meta.copyright, &content_info->media_meta.copyright_pinyin);
+		if(STRING_VALID(content_info->media_meta.description))
+			_media_svc_get_pinyin_str(content_info->media_meta.description, &content_info->media_meta.description_pinyin);
+	}
+
+	/*modified month does not exist in Tizen 2.4*/
+	char *sql = sqlite3_mprintf("UPDATE '%s' SET \
+		thumbnail_path=%Q, title=%Q, album_id=%d, album=%Q, artist=%Q, album_artist=%Q, genre=%Q, composer=%Q, year=%Q, \
+		recorded_date=%Q, copyright=%Q, track_num=%Q, description=%Q, bitrate=%d, bitpersample=%d, samplerate=%d, channel=%d, \
+		duration=%d, longitude=%.6f, latitude=%.6f, altitude=%.6f, width=%d, height=%d, datetaken=%Q, orientation=%d, exposure_time=%Q,\
+		fnumber=%.6f, iso=%d, model=%Q,	rating=%d, weather=%Q, file_name_pinyin=%Q, title_pinyin=%Q, album_pinyin=%Q, \
+		artist_pinyin=%Q, album_artist_pinyin=%Q, genre_pinyin=%Q, composer_pinyin=%Q, copyright_pinyin=%Q, description_pinyin=%Q WHERE path=%Q",
+		storage_id,
+		//content_info->folder_uuid,
+		content_info->thumbnail_path,		//
+		content_info->media_meta.title,
+		content_info->album_id,
+		content_info->media_meta.album,
+		content_info->media_meta.artist,
+		content_info->media_meta.album_artist,
+		content_info->media_meta.genre,
+		content_info->media_meta.composer,
+		content_info->media_meta.year,
+		content_info->media_meta.recorded_date,
+		content_info->media_meta.copyright,
+		content_info->media_meta.track_num,
+		content_info->media_meta.description,	//
+		content_info->media_meta.bitrate,
+		content_info->media_meta.bitpersample,
+		content_info->media_meta.samplerate,
+		content_info->media_meta.channel,
+		content_info->media_meta.duration,
+		content_info->media_meta.longitude,
+		content_info->media_meta.latitude,
+		content_info->media_meta.altitude,
+		content_info->media_meta.width,
+		content_info->media_meta.height,
+		content_info->media_meta.datetaken,
+		content_info->media_meta.orientation,
+		content_info->media_meta.exposure_time,
+		content_info->media_meta.fnumber,
+		content_info->media_meta.iso,
+		content_info->media_meta.model,
+		content_info->media_meta.rating,
+		content_info->media_meta.weather,
+		content_info->file_name_pinyin,
+		content_info->media_meta.title_pinyin,
+		content_info->media_meta.album_pinyin,
+		content_info->media_meta.artist_pinyin,
+		content_info->media_meta.album_artist_pinyin,
+		content_info->media_meta.genre_pinyin,
+		content_info->media_meta.composer_pinyin,
+		content_info->media_meta.copyright_pinyin,
+		content_info->media_meta.description_pinyin,
+		content_info->path
+		);
+
+	if(!stack_query) {
+		ret = _media_svc_sql_query(handle, sql, uid);
+		sqlite3_free(sql);
+		if (ret != MS_MEDIA_ERR_NONE) {
+
+			media_svc_error("failed to insert item");
+			return ret;
+		}
+	} else {
+		//media_svc_debug("query : %s", sql);
+		_media_svc_sql_query_add(&g_media_svc_update_item_query_list, &sql);
+	}
+
+	media_svc_debug_fleave();
+
+	return MS_MEDIA_ERR_NONE;
+}
\ No newline at end of file
diff --git a/src/common/media-svc-storage.c b/src/common/media-svc-storage.c
index c4f6d65..649defc 100755
--- a/src/common/media-svc-storage.c
+++ b/src/common/media-svc-storage.c
@@ -34,7 +34,7 @@ int _media_svc_init_storage(sqlite3 *handle, uid_t uid)
 	int storage_cnt = 0;
 
 	/*Add Internal storage*/
-	sql = sqlite3_mprintf("SELECT COUNT(*) FROM '%s' WHERE storage_uuid='%s'", MEDIA_SVC_DB_TABLE_STORAGE, MEDIA_SVC_DB_TABLE_MEDIA);
+	sql = sqlite3_mprintf("SELECT COUNT(*) FROM '%s' WHERE storage_uuid='%s' AND storage_name='%s'", MEDIA_SVC_DB_TABLE_STORAGE, MEDIA_SVC_DB_TABLE_MEDIA, MEDIA_SVC_DB_TABLE_MEDIA);
 	ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
 	media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 
@@ -53,6 +53,71 @@ int _media_svc_init_storage(sqlite3 *handle, uid_t uid)
 	return ret;
 }
 
+int _media_svc_get_mmc_info(MediaSvcHandle *handle, char **storage_name, char **storage_path, int *validity, bool *info_exist)
+{
+	int ret = MS_MEDIA_ERR_NONE;
+	sqlite3_stmt *sql_stmt = NULL;
+	char *sql = NULL;
+
+	sql = sqlite3_mprintf("SELECT * FROM '%s' WHERE storage_uuid=%Q AND storage_name IS NOT '%s'", MEDIA_SVC_DB_TABLE_STORAGE, MEDIA_SVC_DB_TABLE_MEDIA, MEDIA_SVC_DB_TABLE_MEDIA);
+
+	ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
+	if (ret != MS_MEDIA_ERR_NONE) {
+		*storage_name = NULL;
+		*storage_path = NULL;
+		*validity = 0;
+		*info_exist = FALSE;
+
+		if (ret == MS_MEDIA_ERR_DB_NO_RECORD) {
+			*info_exist = FALSE;
+		}
+
+		return ret;
+	}
+
+	if(STRING_VALID((const char *)sqlite3_column_text(sql_stmt, 1)))
+		*storage_name = strdup((const char *)sqlite3_column_text(sql_stmt, 1));
+
+	if(STRING_VALID((const char *)sqlite3_column_text(sql_stmt, 2)))
+		*storage_path = strdup((const char *)sqlite3_column_text(sql_stmt, 2));
+
+	*validity = sqlite3_column_int(sql_stmt, 6);
+
+	*info_exist = TRUE;
+
+	SQLITE3_FINALIZE(sql_stmt);
+
+	return MS_MEDIA_ERR_NONE;
+}
+
+int _media_svc_check_storage(sqlite3 *handle, const char *storage_id, const char *storage_name, char **storage_path, int *validity)
+{
+	int ret = MS_MEDIA_ERR_NONE;
+	sqlite3_stmt *sql_stmt = NULL;
+	char *sql = NULL;
+
+	*storage_path = NULL;
+	*validity = 0;
+
+	if(storage_name != NULL)
+		sql = sqlite3_mprintf("SELECT * FROM '%s' WHERE storage_uuid=%Q AND storage_name=%Q", MEDIA_SVC_DB_TABLE_STORAGE, storage_id, storage_name);
+	else
+		sql = sqlite3_mprintf("SELECT * FROM '%s' WHERE storage_uuid=%Q", MEDIA_SVC_DB_TABLE_STORAGE, storage_id);
+
+	ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
+
+	media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
+
+	if(STRING_VALID((const char *)sqlite3_column_text(sql_stmt, 2)))
+		*storage_path = strdup((const char *)sqlite3_column_text(sql_stmt, 2));
+
+	*validity = sqlite3_column_int(sql_stmt, 6);
+
+	SQLITE3_FINALIZE(sql_stmt);
+
+	return MS_MEDIA_ERR_NONE;
+}
+
 int _media_svc_append_storage(sqlite3 *handle, const char *storage_id, const char *storage_name, const char *storage_path, const char *storage_account, media_svc_storage_type_e storage_type, uid_t uid)
 {
 	int ret = MS_MEDIA_ERR_NONE;
@@ -65,10 +130,47 @@ int _media_svc_append_storage(sqlite3 *handle, const char *storage_id, const cha
 	return ret;
 }
 
-int _media_svc_delete_storage(sqlite3 *handle, const char *storage_id, uid_t uid)
+int _media_svc_update_storage_path(sqlite3 *handle, const char *storage_id, const char *path, uid_t uid)
+{
+	int ret = MS_MEDIA_ERR_NONE;
+	char *sql = NULL;
+	char *old_storage_path = NULL;
+	int validity = 0;
+
+	/*Get old path*/
+	ret = _media_svc_check_storage(handle, storage_id, NULL, &old_storage_path, &validity);
+	media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
+
+	/*Storage table update*/
+	sql = sqlite3_mprintf("UPDATE '%s' SET storage_path=%Q WHERE storage_uuid=%Q", MEDIA_SVC_DB_TABLE_STORAGE, path, storage_id);
+	ret = _media_svc_sql_query(handle, sql, uid);
+	sqlite3_free(sql);
+	media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
+
+	/*Folder table update*/
+	sql = sqlite3_mprintf("UPDATE '%s' SET path=REPLACE(path, %Q, %Q) WHERE storage_uuid=%Q", MEDIA_SVC_DB_TABLE_FOLDER, old_storage_path, path, storage_id);
+	ret = _media_svc_sql_query(handle, sql, uid);
+	sqlite3_free(sql);
+	media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
+
+	/*Media table update*/
+	sql = sqlite3_mprintf("UPDATE '%s' SET path=REPLACE(path, %Q, %Q)", storage_id, old_storage_path, path);
+	ret = _media_svc_sql_query(handle, sql, uid);
+	sqlite3_free(sql);
+	media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
+
+	return ret;
+}
+
+int _media_svc_delete_storage(sqlite3 *handle, const char *storage_id, const char *storage_name, uid_t uid)
 {
 	int ret = MS_MEDIA_ERR_NONE;
-	char *sql = sqlite3_mprintf("DELETE FROM '%s' WHERE storage_uuid=%Q", MEDIA_SVC_DB_TABLE_STORAGE, storage_id);
+	char *sql = NULL;
+
+	if (storage_name != NULL)
+			sql = sqlite3_mprintf("DELETE FROM '%s' WHERE storage_uuid=%Q AND storage_name=%Q", MEDIA_SVC_DB_TABLE_STORAGE, storage_id, storage_name);
+	else if (storage_id != NULL)
+		sql = sqlite3_mprintf("DELETE FROM '%s' WHERE storage_uuid=%Q", MEDIA_SVC_DB_TABLE_STORAGE, storage_id);
 
 	ret = _media_svc_sql_query(handle, sql, uid);
 	sqlite3_free(sql);
@@ -82,7 +184,7 @@ int _media_svc_update_storage_validity(sqlite3 *handle, const char *storage_id,
 	char *sql = NULL;
 
 	if (storage_id == NULL) {
-		sql = sqlite3_mprintf("UPDATE '%s' SET validity=%d WHERE storage_uuid != 'media';", MEDIA_SVC_DB_TABLE_STORAGE, validity);
+		sql = sqlite3_mprintf("UPDATE '%s' SET validity=%d WHERE storage_uuid != 'media' AND storage_type != %d", MEDIA_SVC_DB_TABLE_STORAGE, validity, MEDIA_SVC_STORAGE_CLOUD);
 	} else {
 		sql = sqlite3_mprintf("UPDATE '%s' SET validity=%d WHERE storage_uuid=%Q;", MEDIA_SVC_DB_TABLE_STORAGE, validity, storage_id);
 	}
@@ -92,3 +194,260 @@ int _media_svc_update_storage_validity(sqlite3 *handle, const char *storage_id,
 
 	return ret;
 }
+
+int _media_svc_get_storage_uuid(sqlite3 *handle, const char *path, char *storage_id)
+{
+	int ret = MS_MEDIA_ERR_NONE;
+	sqlite3_stmt *sql_stmt = NULL;
+	char *sql = NULL;
+	char *storage_path = NULL;
+	char *remain_path = NULL;
+	int remain_len = 0;
+
+	if(strncmp(path, MEDIA_ROOT_PATH_INTERNAL, strlen(MEDIA_ROOT_PATH_INTERNAL)) == 0)
+	{
+		_strncpy_safe(storage_id, MEDIA_SVC_DB_TABLE_MEDIA, MEDIA_SVC_UUID_SIZE+1);
+		return MS_MEDIA_ERR_NONE;
+	}
+
+	sql = sqlite3_mprintf("SELECT storage_uuid, storage_path FROM '%s' WHERE validity=1", MEDIA_SVC_DB_TABLE_STORAGE);
+
+	ret = _media_svc_sql_prepare_to_step_simple(handle, sql, &sql_stmt);
+
+	media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
+
+	remain_path = strstr(path+strlen(MEDIA_ROOT_PATH_USB) +1, "/");
+	if (remain_path != NULL)
+		remain_len = strlen(remain_path);
+
+	storage_path = strndup(path, strlen(path) - remain_len);
+
+	while(sqlite3_step(sql_stmt) == SQLITE_ROW)
+	{
+		if(STRING_VALID((const char *)sqlite3_column_text(sql_stmt, 1)))
+		{
+			if (strlen(storage_path)  == strlen((const char *)sqlite3_column_text(sql_stmt, 1)))
+			{
+				if(strncmp(storage_path, (const char *)sqlite3_column_text(sql_stmt, 1), strlen(storage_path)) == 0)
+				{
+					_strncpy_safe(storage_id, (const char *)sqlite3_column_text(sql_stmt, 0), MEDIA_SVC_UUID_SIZE+1);
+					break;
+				}
+			}
+		}
+
+	}
+
+	SQLITE3_FINALIZE(sql_stmt);
+	SAFE_FREE(storage_path);
+
+	if(!STRING_VALID(storage_id))
+	{
+		media_svc_error("Not found valid storage id [%s]", path);
+		ret = MS_MEDIA_ERR_INVALID_PARAMETER;
+	}
+
+	return ret;
+}
+
+int _media_svc_get_storage_type(sqlite3 *handle, const char *storage_id, media_svc_storage_type_e *storage_type)
+{
+	int ret = MS_MEDIA_ERR_NONE;
+	sqlite3_stmt *sql_stmt = NULL;
+	char *sql = NULL;
+
+	if(!STRING_VALID(storage_id))
+	{
+		media_svc_error("Invalid storage_idid");
+		ret = MS_MEDIA_ERR_INVALID_PARAMETER;
+	}
+
+	sql = sqlite3_mprintf("SELECT storage_type FROM '%s' WHERE (storage_uuid=%Q AND validity=1)", MEDIA_SVC_DB_TABLE_STORAGE, storage_id);
+
+	ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
+
+	if (ret != MS_MEDIA_ERR_NONE) {
+		if(ret == MS_MEDIA_ERR_DB_NO_RECORD) {
+			media_svc_debug("there is no storage.");
+		}
+		else {
+			media_svc_error("error when _media_svc_get_storage_type. err = [%d]", ret);
+		}
+		return ret;
+	}
+
+	*storage_type = sqlite3_column_int(sql_stmt, 0);
+
+	SQLITE3_FINALIZE(sql_stmt);
+
+	return ret;
+}
+
+int _media_svc_get_storage_path(sqlite3 *handle, const char *storage_id, char **storage_path)
+{
+	int ret = MS_MEDIA_ERR_NONE;
+	sqlite3_stmt *sql_stmt = NULL;
+	char *sql = NULL;
+
+	if(!STRING_VALID(storage_id))
+	{
+		media_svc_error("Invalid storage_idid");
+		ret = MS_MEDIA_ERR_INVALID_PARAMETER;
+	}
+
+	sql = sqlite3_mprintf("SELECT storage_path FROM '%s' WHERE (storage_uuid=%Q AND validity=1)", MEDIA_SVC_DB_TABLE_STORAGE, storage_id);
+
+	ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
+
+	if (ret != MS_MEDIA_ERR_NONE) {
+		if(ret == MS_MEDIA_ERR_DB_NO_RECORD) {
+			media_svc_debug("there is no storage.");
+		}
+		else {
+			media_svc_error("error when _media_svc_get_storage_type. err = [%d]", ret);
+		}
+		return ret;
+	}
+
+	*storage_path = strdup((char *)sqlite3_column_text(sql_stmt, 0));
+
+	SQLITE3_FINALIZE(sql_stmt);
+
+	return ret;
+}
+
+int _media_svc_get_storage_scan_status(sqlite3 *handle, const char *storage_id, media_svc_scan_status_type_e *scan_status)
+{
+	int ret = MS_MEDIA_ERR_NONE;
+	sqlite3_stmt *sql_stmt = NULL;
+	char *sql = NULL;
+
+	if(!STRING_VALID(storage_id))
+	{
+		media_svc_error("Invalid storage_id");
+		return MS_MEDIA_ERR_INVALID_PARAMETER;
+	}
+
+	sql = sqlite3_mprintf("SELECT scan_status FROM '%s' WHERE (storage_uuid=%Q AND validity=1)", MEDIA_SVC_DB_TABLE_STORAGE, storage_id);
+
+	ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
+
+	if (ret != MS_MEDIA_ERR_NONE) {
+		if(ret == MS_MEDIA_ERR_DB_NO_RECORD) {
+			media_svc_debug("there is no storage.");
+		}
+		else {
+			media_svc_error("error when _media_svc_get_storage_scan_status. err = [%d]", ret);
+		}
+		return ret;
+	}
+
+	*scan_status = sqlite3_column_int(sql_stmt, 0);
+
+	SQLITE3_FINALIZE(sql_stmt);
+
+	return ret;
+}
+
+int _media_svc_set_storage_scan_status(sqlite3 *handle, const char *storage_id, media_svc_scan_status_type_e scan_status, uid_t uid)
+{
+	int ret = MS_MEDIA_ERR_NONE;
+	char *sql = NULL;
+
+	if (storage_id == NULL) {
+		sql = sqlite3_mprintf("UPDATE '%s' SET scan_status=%d WHERE storage_uuid != 'media'", MEDIA_SVC_DB_TABLE_STORAGE, scan_status);
+	} else {
+		sql = sqlite3_mprintf("UPDATE '%s' SET scan_status=%d WHERE storage_uuid=%Q", MEDIA_SVC_DB_TABLE_STORAGE, scan_status, storage_id);
+	}
+
+	ret = _media_svc_sql_query(handle, sql, uid);
+	sqlite3_free(sql);
+
+	return ret;
+}
+
+static int __media_svc_count_all_storage(sqlite3 *handle, int *count)
+{
+	int ret = MS_MEDIA_ERR_NONE;
+	sqlite3_stmt *sql_stmt = NULL;
+	char *sql = sqlite3_mprintf("SELECT count(*) FROM '%s' WHERE validity = 1", MEDIA_SVC_DB_TABLE_STORAGE);
+
+	ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
+	if (ret != MS_MEDIA_ERR_NONE) {
+		media_svc_error("error when _media_svc_sql_prepare_to_step. err = [%d]", ret);
+		return ret;
+	}
+
+	*count = sqlite3_column_int(sql_stmt, 0);
+
+	SQLITE3_FINALIZE(sql_stmt);
+
+	return MS_MEDIA_ERR_NONE;
+}
+
+int _media_svc_get_all_storage(sqlite3 *handle, char ***storage_list, char ***storage_id_list, int **scan_status_list, int *count)
+{
+	int ret = MS_MEDIA_ERR_NONE;
+	int idx = 0;
+	sqlite3_stmt *sql_stmt = NULL;
+	char *sql = NULL;
+	int cnt =0;
+
+	ret  = __media_svc_count_all_storage(handle, &cnt);
+	if (ret != MS_MEDIA_ERR_NONE) {
+		media_svc_error("error when __media_svc_count_all_folders. err = [%d]", ret);
+		return ret;
+	}
+
+	if (cnt > 0) {
+		sql = sqlite3_mprintf("SELECT storage_path, storage_uuid, scan_status FROM '%s' WHERE validity = 1", MEDIA_SVC_DB_TABLE_STORAGE);
+	} else {
+		*storage_list = NULL;
+		*scan_status_list = NULL;
+		return MS_MEDIA_ERR_NONE;
+	}
+
+	*storage_list = malloc(sizeof(char *) * cnt);
+	*storage_id_list = malloc(sizeof(char *) * cnt);
+	*scan_status_list = malloc(sizeof(int) * cnt);
+
+	ret = _media_svc_sql_prepare_to_step(handle, sql, &sql_stmt);
+	if (ret != MS_MEDIA_ERR_NONE) {
+		media_svc_error("prepare error [%s]", sqlite3_errmsg(handle));
+		SAFE_FREE(*storage_list);
+		SAFE_FREE(*scan_status_list);
+		return ret;
+	}
+
+	media_svc_debug("QEURY OK");
+
+	while (1) {
+		(*storage_list)[idx] = strdup((char *)sqlite3_column_text(sql_stmt, 0));
+		(*storage_id_list)[idx] = strdup((char *)sqlite3_column_text(sql_stmt, 1));
+		(*scan_status_list)[idx] = (int)sqlite3_column_int(sql_stmt, 2);
+		if(sqlite3_step(sql_stmt) != SQLITE_ROW)
+			break;
+		idx++;
+	}
+
+	if (cnt == idx + 1) {
+		*count = cnt;
+		media_svc_debug("OK");
+	} else {
+		/* free all data */
+		int i =0;
+		for (i  = 0; i < idx; i ++) {
+			SAFE_FREE((*storage_list)[i]);
+			SAFE_FREE((*storage_id_list)[i]);
+		}
+		SAFE_FREE(*storage_list);
+		SAFE_FREE(*storage_id_list);
+		SAFE_FREE(*scan_status_list);
+		*count = 0;
+		ret = MS_MEDIA_ERR_INTERNAL;
+	}
+
+	SQLITE3_FINALIZE(sql_stmt);
+
+	return ret;
+}
diff --git a/src/common/media-svc-util.c b/src/common/media-svc-util.c
index 11ef4bc..64822ca 100755
--- a/src/common/media-svc-util.c
+++ b/src/common/media-svc-util.c
@@ -35,9 +35,10 @@
 #include <libexif/exif-data.h>
 #include <media-thumbnail.h>
 #include <media-util.h>
+#include <uuid/uuid.h>
+#include <img-codec-parser.h>
 #include <grp.h>
 #include <pwd.h>
-#include "uuid.h"
 #include "media-util-err.h"
 #include "media-svc-util.h"
 #include "media-svc-db-utils.h"
@@ -50,7 +51,6 @@
 #include "media-svc-localize_tw.h"
 
 #define MEDIA_SVC_FILE_EXT_LEN_MAX				6			/**<  Maximum file ext lenth*/
-#define GLOBAL_USER    0 /*#define     tzplatform_getenv(TZ_GLOBAL) //TODO */
 
 /* Define data structures for media type and mime type */
 #define MEDIA_SVC_CATEGORY_UNKNOWN	0x00000000	/**< Default */
@@ -234,7 +234,7 @@ static int __media_svc_split_to_double(char *input, double *arr)
 	for (idx = 0; idx < (len + 1); idx++) {
 		if (input[idx] == ' ') {
 			continue;
-		} else if ((input[idx] == ', ') || (idx == len)) {
+		} else if ((input[idx] == ',') || (idx == len)) {
 			arr[arr_idx] = atof(tmp_arr);
 			arr_idx++;
 			str_idx = 0;
@@ -276,7 +276,8 @@ static int __media_svc_get_exif_info(ExifData *ed,
 		/* Get the contents of the tag in human-readable form */
 		if (tag == EXIF_TAG_ORIENTATION ||
 		    tag == EXIF_TAG_PIXEL_X_DIMENSION ||
-		    tag == EXIF_TAG_PIXEL_Y_DIMENSION) {
+		    tag == EXIF_TAG_PIXEL_Y_DIMENSION ||
+		    tag == EXIF_TAG_ISO_SPEED_RATINGS) {
 
 			if (i_value == NULL) {
 				media_svc_error("i_value is NULL");
@@ -309,6 +310,33 @@ static int __media_svc_get_exif_info(ExifData *ed,
 
 			*d_value = tmp_arr[0] + tmp_arr[1] / 60 + tmp_arr[2] / 3600;
 			/*media_svc_debug("GPS value is [%f], %f, %f, %f", *d_value, tmp_arr[0], tmp_arr[1], tmp_arr[2]); */
+		}  else if (tag == EXIF_TAG_EXPOSURE_TIME) {
+
+			if (buf == NULL) {
+				media_svc_error("buf is NULL");
+				return MS_MEDIA_ERR_INVALID_PARAMETER;
+			}
+
+			ExifByteOrder mByteOrder = exif_data_get_byte_order(ed);
+			ExifRational mRational = exif_get_rational(entry->data, mByteOrder);
+			long numerator = mRational.numerator;
+			long denominator = mRational.denominator;
+			snprintf(buf, MEDIA_SVC_METADATA_LEN_MAX, "%ld/%ld", numerator, denominator);
+
+		} else if (tag == EXIF_TAG_FNUMBER) {
+
+			if (d_value == NULL) {
+				media_svc_error("d_value is NULL");
+				return MS_MEDIA_ERR_INVALID_PARAMETER;
+			}
+
+			ExifByteOrder mByteOrder = exif_data_get_byte_order(ed);
+			ExifRational mRational = exif_get_rational(entry->data, mByteOrder);
+			long numerator = mRational.numerator;
+			long denominator = mRational.denominator;
+
+			*d_value = ((numerator*1.0)/(denominator*1.0));
+
 		} else {
 
 			if (buf == NULL) {
@@ -759,7 +787,7 @@ char *_media_svc_get_thumb_external_path(uid_t uid)
 	return result_psswd;
 }
 
-static int __media_svc_check_thumb_dir(char *thumb_dir)
+static int __media_svc_check_thumb_dir(const char *thumb_dir)
 {
 	int ret = 0;
 	DIR *dir = NULL;
@@ -862,13 +890,13 @@ int _media_svc_get_thumbnail_path(media_svc_storage_type_e storage_type, char *t
 	/*media_svc_debug("img format is [%s]", img_format); */
 
 	if ((strstr(img_format, "jpeg") != NULL) || (strstr(img_format, "jpg") != NULL) || (strstr(img_format, "JPG") != NULL)) {
-		thumbfile_ext = "jpg";
+		thumbfile_ext = (char *)"jpg";
 	} else if ((strstr(img_format, "png") != NULL) || (strstr(img_format, "PNG") != NULL)) {
-		thumbfile_ext = "png";
+		thumbfile_ext = (char *)"png";
 	} else if ((strstr(img_format, "gif") != NULL) || (strstr(img_format, "GIF") != NULL)) {
-		thumbfile_ext = "gif";
+		thumbfile_ext = (char *)"gif";
 	} else if ((strstr(img_format, "bmp") != NULL) || (strstr(img_format, "BMP") != NULL)) {
-		thumbfile_ext = "bmp";
+		thumbfile_ext = (char *)"bmp";
 	} else {
 		media_svc_error("Not proper img format");
 		return MS_MEDIA_ERR_INTERNAL;
@@ -896,28 +924,9 @@ int _media_svc_get_file_time(const char *full_path)
 	return statbuf.st_mtime;
 }
 
-int _media_svc_set_media_info(media_svc_content_info_s *content_info, const char *storage_id, media_svc_storage_type_e storage_type,
-                              const char *path, media_svc_media_type_e *media_type, bool refresh)
+int _media_svc_set_default_value(media_svc_content_info_s *content_info, bool refresh)
 {
 	int ret = MS_MEDIA_ERR_NONE;
-	char *media_uuid = NULL;
-	char *file_name = NULL;
-	struct stat st;
-	bool drm_type = false;
-	char mime_type[256] = {0};
-
-	ret = __media_svc_malloc_and_strncpy(&content_info->path, path);
-	media_svc_retv_del_if(ret != MS_MEDIA_ERR_NONE, ret, content_info);
-
-	memset(&st, 0, sizeof(struct stat));
-	if (stat(path, &st) == 0) {
-		content_info->modified_time = st.st_mtime;
-		content_info->timeline = content_info->modified_time;
-		content_info->size = st.st_size;
-		/*media_svc_debug("Modified time : [%d] Size : [%lld]", content_info->modified_time, content_info->size); */
-	} else {
-		media_svc_stderror("stat failed");
-	}
 
 	/* Set default GPS value before extracting meta information */
 	content_info->media_meta.longitude = MEDIA_SVC_DEFAULT_GPS_VALUE;
@@ -966,6 +975,45 @@ int _media_svc_set_media_info(media_svc_content_info_s *content_info, const char
 	ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.year, MEDIA_SVC_TAG_UNKNOWN);
 	media_svc_retv_del_if(ret != MS_MEDIA_ERR_NONE, ret, content_info);
 
+	if(refresh) {
+		media_svc_debug("refresh");
+		return MS_MEDIA_ERR_NONE;
+	}
+
+	content_info->played_count = 0;
+	content_info->last_played_time= 0;
+	content_info->last_played_position= 0;
+	content_info->favourate= 0;
+	content_info->media_meta.rating = 0;
+
+	return MS_MEDIA_ERR_NONE;
+}
+
+int _media_svc_set_media_info(media_svc_content_info_s *content_info, const char *storage_id, media_svc_storage_type_e storage_type,
+			  const char *path, media_svc_media_type_e *media_type, bool refresh)
+{
+	int ret = MS_MEDIA_ERR_NONE;
+	char * media_uuid = NULL;
+	char * file_name = NULL;
+	struct stat st;
+	bool drm_type = false;
+	char mime_type[256] = {0};
+
+	ret = __media_svc_malloc_and_strncpy(&content_info->path, path);
+	media_svc_retv_del_if(ret != MS_MEDIA_ERR_NONE, ret, content_info);
+
+	memset(&st, 0, sizeof(struct stat));
+	if (stat(path, &st) == 0) {
+		content_info->modified_time = st.st_mtime;
+		content_info->timeline = content_info->modified_time;
+		content_info->size = st.st_size;
+		//media_svc_debug("Modified time : [%d] Size : [%lld]", content_info->modified_time, content_info->size);
+	} else {
+		media_svc_stderror("stat failed");
+	}
+
+	_media_svc_set_default_value(content_info, refresh);
+
 	/* refresh is TRUE when file modified. so only modified_time and size are changed*/
 	if (refresh) {
 		media_svc_debug("refresh");
@@ -1015,16 +1063,10 @@ int _media_svc_set_media_info(media_svc_content_info_s *content_info, const char
 
 	content_info->media_type = *media_type;
 
-	content_info->played_count = 0;
-	content_info->last_played_time = 0;
-	content_info->last_played_position = 0;
-	content_info->favourate = 0;
-	content_info->media_meta.rating = 0;
-
 	return MS_MEDIA_ERR_NONE;
 }
 
-int _media_svc_extract_image_metadata(sqlite3 *handle, media_svc_content_info_s *content_info, media_svc_media_type_e media_type, uid_t uid)
+int _media_svc_extract_image_metadata(sqlite3 *handle, media_svc_content_info_s *content_info)
 {
 	int ret = MS_MEDIA_ERR_NONE;
 	double value = 0.0;
@@ -1048,7 +1090,7 @@ int _media_svc_extract_image_metadata(sqlite3 *handle, media_svc_content_info_s
 	memset(exposure_time_buf, 0x00, sizeof(exposure_time_buf));
 	memset(model_buf, 0x00, sizeof(model_buf));
 
-	if (content_info == NULL || media_type != MEDIA_SVC_MEDIA_TYPE_IMAGE) {
+	if (content_info == NULL || content_info->media_type != MEDIA_SVC_MEDIA_TYPE_IMAGE) {
 		media_svc_error("content_info == NULL || media_type != MEDIA_SVC_MEDIA_TYPE_IMAGE");
 		return MS_MEDIA_ERR_INVALID_PARAMETER;
 	}
@@ -1064,6 +1106,7 @@ int _media_svc_extract_image_metadata(sqlite3 *handle, media_svc_content_info_s
 
 	if (!ed) {
 		media_svc_sec_debug("There is no exif data in [ %s ]", path);
+		goto GET_WIDTH_HEIGHT;
 	}
 
 	if (__media_svc_get_exif_info(ed, buf, NULL, NULL, EXIF_IFD_0, EXIF_TAG_GPS_LATITUDE_REF) == MS_MEDIA_ERR_NONE) {
@@ -1129,11 +1172,7 @@ int _media_svc_extract_image_metadata(sqlite3 *handle, media_svc_content_info_s
 		if (strlen(buf) == 0) {
 			/*media_svc_debug("time  is NULL"); */
 		} else {
-#if 0
-			ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.datetaken, buf);
-#else
 			ret = __media_svc_malloc_and_strncpy_with_size(&content_info->media_meta.datetaken, buf, datetaken_size);
-#endif
 			if (ret != MS_MEDIA_ERR_NONE) {
 				media_svc_error("strcpy error");
 			} else {
@@ -1152,11 +1191,7 @@ int _media_svc_extract_image_metadata(sqlite3 *handle, media_svc_content_info_s
 		if (strlen(buf) == 0) {
 			/*media_svc_debug("time  is NULL"); */
 		} else {
-#if 0
-			ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.datetaken, buf);
-#else
 			ret = __media_svc_malloc_and_strncpy_with_size(&content_info->media_meta.datetaken, buf, datetaken_size);
-#endif
 			if (ret != MS_MEDIA_ERR_NONE) {
 				media_svc_error("strcpy error");
 			} else {
@@ -1181,7 +1216,7 @@ int _media_svc_extract_image_metadata(sqlite3 *handle, media_svc_content_info_s
 	/* Get exposure_time value from exif. */
 	if (__media_svc_get_exif_info(ed, exposure_time_buf, NULL, NULL, EXIF_IFD_0, EXIF_TAG_EXPOSURE_TIME) == MS_MEDIA_ERR_NONE) {
 		if (strlen(exposure_time_buf) == 0) {
-			media_svc_error("exposure_time_buf is NULL");
+			//media_svc_debug("exposure_time_buf is NULL");
 		} else {
 			ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.exposure_time, exposure_time_buf);
 			if (ret != MS_MEDIA_ERR_NONE)
@@ -1214,7 +1249,7 @@ int _media_svc_extract_image_metadata(sqlite3 *handle, media_svc_content_info_s
 	/* Get model value from exif. */
 	if (__media_svc_get_exif_info(ed, model_buf, NULL, NULL, EXIF_IFD_0, EXIF_TAG_MODEL) == MS_MEDIA_ERR_NONE) {
 		if (strlen(model_buf) == 0) {
-			media_svc_error("model_buf is NULL");
+			//media_svc_debug("model_buf is NULL");
 		} else {
 			ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.model, model_buf);
 			if (ret != MS_MEDIA_ERR_NONE)
@@ -1257,6 +1292,24 @@ int _media_svc_extract_image_metadata(sqlite3 *handle, media_svc_content_info_s
 
 	if (ed != NULL) exif_data_unref(ed);
 
+GET_WIDTH_HEIGHT:
+
+	if(content_info->media_meta.width == 0 ||
+		content_info->media_meta.height == 0) {
+		/*Get image width, height*/
+		unsigned int img_width = 0;
+		unsigned int img_height = 0;
+		ImgCodecType img_type = IMG_CODEC_NONE;
+
+		ret = ImgGetImageInfo(path, &img_type, &img_width, &img_height);
+
+		if(content_info->media_meta.width == 0)
+			content_info->media_meta.width = img_width;
+
+		if(content_info->media_meta.height == 0)
+			content_info->media_meta.height = img_height;
+	}
+
 	return MS_MEDIA_ERR_NONE;
 }
 
@@ -1419,15 +1472,15 @@ int _media_svc_extract_music_metadata_for_update(sqlite3 *handle, media_svc_cont
 		}
 	}	else {
 		/* in case of file size 0, MMFW Can't parsting tag info but add it to Music DB. */
-		char *title = NULL;
+		char *no_tag_title = NULL;
 		media_svc_error("no tag information");
 
-		title = _media_svc_get_title_from_filepath(content_info->path);
-		if (title) {
-			ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, title);
-			if (ret != MS_MEDIA_ERR_NONE)
+		no_tag_title = _media_svc_get_title_from_filepath(content_info->path);
+		if (no_tag_title) {
+			ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, no_tag_title);
+			if(ret != MS_MEDIA_ERR_NONE)
 				media_svc_error("strcpy error");
-			SAFE_FREE(title);
+			SAFE_FREE(no_tag_title);
 		} else {
 			media_svc_error("Can't extract title");
 		}
@@ -1438,7 +1491,7 @@ int _media_svc_extract_music_metadata_for_update(sqlite3 *handle, media_svc_cont
 	return MS_MEDIA_ERR_NONE;
 }
 
-int _media_svc_extract_media_metadata(sqlite3 *handle, media_svc_content_info_s *content_info, media_svc_media_type_e media_type, uid_t uid)
+int _media_svc_extract_media_metadata(sqlite3 *handle, media_svc_content_info_s *content_info, uid_t uid)
 {
 	MMHandleType content = 0;
 	MMHandleType tag = 0;
@@ -1447,7 +1500,6 @@ int _media_svc_extract_media_metadata(sqlite3 *handle, media_svc_content_info_s
 	int size = -1;
 	int extracted_field = MEDIA_SVC_EXTRACTED_FIELD_NONE;
 	int mmf_error = MM_ERROR_NONE;
-	bool thumb_extracted_from_drm = FALSE;
 	char *err_attr_name = NULL;
 	char *title = NULL;
 	bool extract_thumbnail = FALSE;
@@ -1575,7 +1627,7 @@ int _media_svc_extract_media_metadata(sqlite3 *handle, media_svc_content_info_s
 
 		mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_RECDATE, &p, &size, NULL);
 		if ((mmf_error == MM_ERROR_NONE) && (size > 0)) {
-			if (media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO) {
+			if (content_info->media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO) {
 				/*Creation time format is 2013-01-01 00:00:00. change it to 2013:01:01 00:00:00 like exif time format*/
 				char time_info[64] = {0, };
 				char p_value[64] = {0, };
@@ -1703,12 +1755,15 @@ int _media_svc_extract_media_metadata(sqlite3 *handle, media_svc_content_info_s
 			} else {
 				media_svc_debug("album already exists. don't need to make album art");
 				ret = _media_svc_get_album_art_by_album_id(handle, album_id, &content_info->thumbnail_path);
-				media_svc_retv_del_if((ret != MS_MEDIA_ERR_NONE) && (ret != MS_MEDIA_ERR_DB_NO_RECORD), ret, content_info);
 				extract_thumbnail = TRUE;
 			}
 		}
 
-		if ((!thumb_extracted_from_drm) && (extract_thumbnail == TRUE)) {
+		/*Do not extract artwork for the USB Storage content*/
+		if (content_info->storage_type == MEDIA_SVC_STORAGE_EXTERNAL_USB)
+			extract_thumbnail = FALSE;
+
+		if (extract_thumbnail == TRUE) {
 			mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_ARTWORK, &image, &size, NULL);
 			if (mmf_error != MM_ERROR_NONE) {
 				media_svc_error("fail to get tag artwork - err(%x)", mmf_error);
@@ -1725,7 +1780,6 @@ int _media_svc_extract_media_metadata(sqlite3 *handle, media_svc_content_info_s
 				/*media_svc_debug("artwork size2 [%d]", size); */
 			}
 			if (image != NULL && size > 0) {
-				int ret = MS_MEDIA_ERR_NONE;
 				char thumb_path[MEDIA_SVC_PATHNAME_SIZE] = "\0";
 				int artwork_mime_size = -1;
 
@@ -1762,7 +1816,7 @@ int _media_svc_extract_media_metadata(sqlite3 *handle, media_svc_content_info_s
 			content_info->album_id = album_id;
 		}
 
-		if (media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO) {
+		if (content_info->media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO) {
 			double longitude = 0.0;
 			double latitude = 0.0;
 			double altitude = 0.0;
@@ -1787,15 +1841,15 @@ int _media_svc_extract_media_metadata(sqlite3 *handle, media_svc_content_info_s
 		}
 	}	else {
 		/* in case of file size 0, MMFW Can't parsting tag info but add it to Music DB. */
-		char *title = NULL;
+		char *no_tag_title = NULL;
 		media_svc_error("no tag information");
 
-		title = _media_svc_get_title_from_filepath(content_info->path);
-		if (title) {
-			ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, title);
-			if (ret != MS_MEDIA_ERR_NONE)
+		no_tag_title = _media_svc_get_title_from_filepath(content_info->path);
+		if (no_tag_title) {
+			ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, no_tag_title);
+			if(ret != MS_MEDIA_ERR_NONE)
 				media_svc_error("strcpy error");
-			SAFE_FREE(title);
+			SAFE_FREE(no_tag_title);
 		} else {
 			media_svc_error("Can't extract title");
 		}
@@ -1807,7 +1861,7 @@ int _media_svc_extract_media_metadata(sqlite3 *handle, media_svc_content_info_s
 	if (cdis_value == 1) {
 		mmf_error = mm_file_create_content_attrs_safe(&content, content_info->path);
 	} else {
-		mmf_error = mm_file_create_content_attrs(&content, content_info->path);
+		mmf_error = mm_file_create_content_attrs_simple(&content, content_info->path);
 	}
 
 	if (mmf_error == MM_ERROR_NONE) {
@@ -1821,7 +1875,7 @@ int _media_svc_extract_media_metadata(sqlite3 *handle, media_svc_content_info_s
 		}
 
 		/*Sound/Music attribute*/
-		if ((media_type == MEDIA_SVC_MEDIA_TYPE_SOUND) || (media_type == MEDIA_SVC_MEDIA_TYPE_MUSIC)) {
+		if ((content_info->media_type == MEDIA_SVC_MEDIA_TYPE_SOUND) || (content_info->media_type == MEDIA_SVC_MEDIA_TYPE_MUSIC)) {
 
 			mmf_error = mm_file_get_attrs(content, &err_attr_name, MM_FILE_CONTENT_AUDIO_BITRATE, &content_info->media_meta.bitrate, NULL);
 			if (mmf_error != MM_ERROR_NONE) {
@@ -1854,7 +1908,7 @@ int _media_svc_extract_media_metadata(sqlite3 *handle, media_svc_content_info_s
 			} else {
 				media_svc_debug("bitpersample : %d", content_info->media_meta.bitpersample);
 			}
-		} else if (media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)	{	/*Video attribute*/
+		} else if (content_info->media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)	{	/*Video attribute*/
 			int audio_bitrate = 0;
 			int video_bitrate = 0;
 
@@ -1923,6 +1977,7 @@ void _media_svc_destroy_content_info(media_svc_content_info_s *content_info)
 	SAFE_FREE(content_info->mime_type);
 	SAFE_FREE(content_info->folder_uuid);
 	SAFE_FREE(content_info->thumbnail_path);
+	SAFE_FREE(content_info->storage_uuid);
 
 	/* Delete media_svc_content_meta_s */
 	SAFE_FREE(content_info->media_meta.title);
@@ -1953,13 +2008,15 @@ void _media_svc_destroy_content_info(media_svc_content_info_s *content_info)
 	return;
 }
 
-int _media_svc_get_store_type_by_path(const char *path, media_svc_storage_type_e *storage_type, uid_t uid)
+int _media_svc_get_storage_type_by_path(const char *path, media_svc_storage_type_e *storage_type, uid_t uid)
 {
 	if (STRING_VALID(path)) {
 		if (strncmp(path, _media_svc_get_path(uid), strlen(_media_svc_get_path(uid))) == 0) {
 			*storage_type = MEDIA_SVC_STORAGE_INTERNAL;
 		} else if (strncmp(path, MEDIA_ROOT_PATH_SDCARD, strlen(MEDIA_ROOT_PATH_SDCARD)) == 0) {
 			*storage_type = MEDIA_SVC_STORAGE_EXTERNAL;
+		} else if (strncmp (path, MEDIA_ROOT_PATH_USB, strlen(MEDIA_ROOT_PATH_USB)) == 0) {
+			*storage_type = MEDIA_SVC_STORAGE_EXTERNAL_USB;
 		} else {
 			media_svc_error("Invalid Path");
 			return MS_MEDIA_ERR_INVALID_PARAMETER;
@@ -2031,6 +2088,7 @@ int _media_svc_get_pinyin_str(const char *src_str, char **pinyin_str)
 	int ret = MS_MEDIA_ERR_NONE;
 	int size = 0;
 	pinyin_name_s *pinyinname = NULL;
+
 	*pinyin_str = NULL;
 
 	if (!STRING_VALID(src_str)) {
@@ -2040,10 +2098,10 @@ int _media_svc_get_pinyin_str(const char *src_str, char **pinyin_str)
 
 	ret = _media_svc_convert_chinese_to_pinyin(src_str, &pinyinname, &size);
 	if (ret == MS_MEDIA_ERR_NONE) {
-		if (STRING_VALID(pinyinname[0].pinyin_name))
+		if(STRING_VALID(pinyinname[0].pinyin_name))
 			*pinyin_str = strdup(pinyinname[0].pinyin_name);
 		else
-			*pinyin_str = strdup(src_str);	/*Return Original Non China Character */
+			*pinyin_str = strdup(src_str);	//Return Original Non China Character
 	}
 
 	_media_svc_pinyin_free(pinyinname, size);
@@ -2057,18 +2115,55 @@ bool _media_svc_check_pinyin_support(void)
 	return TRUE;
 }
 
-int _media_svc_request_extract_all_thumbs(uid_t uid)
+char* _media_svc_get_title_from_path(const char *path)
 {
-	int ret = MS_MEDIA_ERR_NONE;
+	char *filename = NULL;
+	char *title = NULL;
+	char	*ext = NULL;
+	int filename_len = -1;
+	int new_title_len = -1;
 
-	ret = thumbnail_request_extract_all_thumbs(uid);
+	if (!path) {
+		media_svc_error("path is NULL");
+		return NULL;
+	}
 
-	if (ret != MS_MEDIA_ERR_NONE) {
-		media_svc_error("thumbnail_request_from_db failed: %d", ret);
-		ret = MS_MEDIA_ERR_INTERNAL;
-	} else {
-		media_svc_sec_debug("thumbnail_request_extract_all_thumbs");
+	filename = g_path_get_basename(path);
+	if (!STRING_VALID(filename)) {
+		media_svc_error("wrong file name");
+		SAFE_FREE(filename);
+		return NULL;
 	}
 
-	return ret;
+	filename_len = strlen(filename);
+
+	ext = g_strrstr(filename, ".");
+	if (!ext) {
+		media_svc_error("there is no file extention");
+		return filename;
+	}
+
+	new_title_len = filename_len - strlen(ext);
+	if (new_title_len < 1) {
+		media_svc_error("title length is zero");
+		SAFE_FREE(filename);
+		return NULL;
+	}
+
+	title = g_strndup(filename, new_title_len < MEDIA_SVC_PATHNAME_SIZE ? new_title_len : MEDIA_SVC_PATHNAME_SIZE-1);
+
+	SAFE_FREE(filename);
+
+	media_svc_debug("extract title is [%s]", title);
+
+	return title;
+}
+
+#define BUF_LENGHT 256
+
+void _media_svc_print_stderror(void)
+{
+	char buf[BUF_LENGHT] = {0,};
+
+	media_svc_error("STANDARD ERROR [%s]", strerror_r(errno, buf, BUF_LENGHT));
 }
diff --git a/src/common/media-svc.c b/src/common/media-svc.c
index 0e43c15..5328aa2 100755
--- a/src/common/media-svc.c
+++ b/src/common/media-svc.c
@@ -45,17 +45,47 @@ static __thread int g_media_svc_insert_item_cur_data_cnt = 0;
 static __thread int g_media_svc_update_item_data_cnt = 1;
 static __thread int g_media_svc_update_item_cur_data_cnt = 0;
 
+static __thread int g_media_svc_insert_folder_data_cnt = 1;
+static __thread int g_media_svc_insert_folder_cur_data_cnt = 0;
+
 /* Flag for items to be published by notification */
 static __thread int g_insert_with_noti = FALSE;
 
 #define DEFAULT_MEDIA_SVC_STORAGE_ID "media"
 
+typedef struct{
+	int media_type;
+	char *path;
+}media_svc_item_info_s;
+
+static bool __media_svc_check_storage(media_svc_storage_type_e storage_type, bool check_all)
+{
+	if (check_all == TRUE) {
+		if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL)
+			&& (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)
+			&& (storage_type != MEDIA_SVC_STORAGE_EXTERNAL_USB)
+			&& (storage_type != MEDIA_SVC_STORAGE_CLOUD)) {
+			media_svc_error("storage type is incorrect[%d]", storage_type);
+			return FALSE;
+		}
+	} else {
+		if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL)
+			&& (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)
+			&& (storage_type != MEDIA_SVC_STORAGE_EXTERNAL_USB)) {
+			media_svc_error("storage type is incorrect[%d]", storage_type);
+			return FALSE;
+		}
+	}
+
+	return TRUE;
+}
+
 int media_svc_connect(MediaSvcHandle **handle, uid_t uid, bool need_write)
 {
 	int ret = MS_MEDIA_ERR_NONE;
 	MediaDBHandle *db_handle = NULL;
 
-	media_svc_debug_func();
+	media_svc_debug_fenter();
 
 	ret = media_db_connect(&db_handle, uid, need_write);
 	if (ret != MS_MEDIA_ERR_NONE)
@@ -69,7 +99,7 @@ int media_svc_disconnect(MediaSvcHandle *handle)
 {
 	MediaDBHandle *db_handle = (MediaDBHandle *)handle;
 
-	media_svc_debug_func();
+	media_svc_debug_fenter();
 
 	media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 
@@ -84,9 +114,9 @@ int media_svc_create_table(MediaSvcHandle *handle, uid_t uid)
 	int ret = MS_MEDIA_ERR_NONE;
 	sqlite3 *db_handle = (sqlite3 *)handle;
 
-	media_svc_debug_func();
+	media_svc_debug_fenter();
 
-	ret = _media_svc_init_table_query();
+	ret = _media_svc_init_table_query(MEDIA_SVC_DB_TABLE_MEDIA);
 	media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 
 	/*create media table*/
@@ -125,10 +155,11 @@ int media_svc_create_table(MediaSvcHandle *handle, uid_t uid)
 	ret = _media_svc_make_table_query(db_handle, MEDIA_SVC_DB_TABLE_STORAGE, MEDIA_SVC_DB_LIST_STORAGE, uid);
 	media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 
+#if 0
 	/*init storage table*/
 	ret = _media_svc_init_storage(db_handle, uid);
 	media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
-
+#endif
 	/*create face table. from tizen 3.0*/
 	ret = _media_svc_make_table_query(db_handle, MEDIA_SVC_DB_TABLE_FACE_SCAN_LIST, MEDIA_SVC_DB_LIST_FACE_SCAN_LIST, uid);
 	media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
@@ -138,7 +169,7 @@ int media_svc_create_table(MediaSvcHandle *handle, uid_t uid)
 
 	_media_svc_destroy_table_query();
 
-	media_svc_debug_func();
+	media_svc_debug_fleave();
 
 	return MS_MEDIA_ERR_NONE;
 }
@@ -148,36 +179,38 @@ int media_svc_get_storage_type(const char *path, media_svc_storage_type_e *stora
 	int ret = MS_MEDIA_ERR_NONE;
 	media_svc_storage_type_e type;
 
-	ret = _media_svc_get_store_type_by_path(path, &type, uid);
-	media_svc_retvm_if(ret != MS_MEDIA_ERR_NONE, ret, "_media_svc_get_store_type_by_path failed : %d", ret);
+	ret = _media_svc_get_storage_type_by_path(path, &type, uid);
+	media_svc_retvm_if(ret != MS_MEDIA_ERR_NONE, ret, "_media_svc_get_storage_type_by_path failed : %d", ret);
 
 	*storage_type = type;
 
 	return ret;
 }
 
-int media_svc_get_file_info(MediaSvcHandle *handle, const char *path, time_t *modified_time, unsigned long long *size)
+int media_svc_get_file_info(MediaSvcHandle *handle, const char *storage_id, const char *path, time_t *modified_time, unsigned long long *size)
 {
 	int ret = MS_MEDIA_ERR_NONE;
 	sqlite3 *db_handle = (sqlite3 *)handle;
 
 	media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
+	media_svc_retvm_if(!STRING_VALID(storage_id), MS_MEDIA_ERR_INVALID_PARAMETER, "storage_id is NULL");
 
-	ret = _media_svc_get_fileinfo_by_path(db_handle, path, modified_time, size);
+	ret = _media_svc_get_fileinfo_by_path(db_handle, storage_id, path, modified_time, size);
 
 	return ret;
 }
 
-int media_svc_check_item_exist_by_path(MediaSvcHandle *handle, const char *path)
+int media_svc_check_item_exist_by_path(MediaSvcHandle *handle, const char *storage_id, const char *path)
 {
 	int ret = MS_MEDIA_ERR_NONE;
 	sqlite3 *db_handle = (sqlite3 *)handle;
 	int count = -1;
 
 	media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
+	media_svc_retvm_if(!STRING_VALID(storage_id), MS_MEDIA_ERR_INVALID_PARAMETER, "storage_id is NULL");
 	media_svc_retvm_if(!STRING_VALID(path), MS_MEDIA_ERR_INVALID_PARAMETER, "Path is NULL");
 
-	ret = _media_svc_count_record_with_path(db_handle, path, &count);
+	ret = _media_svc_count_record_with_path(db_handle, storage_id, path, &count);
 	media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 
 	if (count > 0) {
@@ -222,7 +255,7 @@ int media_svc_insert_item_end(MediaSvcHandle *handle, uid_t uid)
 	int ret = MS_MEDIA_ERR_NONE;
 	sqlite3 *db_handle = (sqlite3 *)handle;
 
-	media_svc_debug_func();
+	media_svc_debug_fenter();
 
 	media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 
@@ -244,7 +277,7 @@ int media_svc_insert_item_end(MediaSvcHandle *handle, uid_t uid)
 	return ret;
 }
 
-int media_svc_insert_item_bulk(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, const char *path, int is_burst, uid_t uid)
+int media_svc_insert_item_bulk(MediaSvcHandle *handle, const char *storage_id, media_svc_storage_type_e storage_type, const char *path, int is_burst, uid_t uid)
 {
 	int ret = MS_MEDIA_ERR_NONE;
 	sqlite3 *db_handle = (sqlite3 *)handle;
@@ -252,19 +285,16 @@ int media_svc_insert_item_bulk(MediaSvcHandle *handle, media_svc_storage_type_e
 	media_svc_media_type_e media_type;
 
 	media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
+	media_svc_retvm_if(!STRING_VALID(storage_id), MS_MEDIA_ERR_INVALID_PARAMETER, "storage_id is NULL");
 	media_svc_retvm_if(!STRING_VALID(path), MS_MEDIA_ERR_INVALID_PARAMETER, "path is NULL");
-
-	if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
-		media_svc_error("storage type is incorrect[%d]", storage_type);
-		return MS_MEDIA_ERR_INVALID_PARAMETER;
-	}
+	media_svc_retvm_if(__media_svc_check_storage(storage_type, FALSE) != TRUE, MS_MEDIA_ERR_INVALID_PARAMETER, "Invalid storage_type");
 
 	media_svc_content_info_s content_info;
 	memset(&content_info, 0, sizeof(media_svc_content_info_s));
 
 	/*Set media info*/
 	/* if drm_contentinfo is not NULL, the file is OMA DRM.*/
-	ret = _media_svc_set_media_info(&content_info, DEFAULT_MEDIA_SVC_STORAGE_ID, storage_type, path, &media_type, FALSE);
+	ret = _media_svc_set_media_info(&content_info, storage_id, storage_type, path, &media_type, FALSE);
 	if (ret != MS_MEDIA_ERR_NONE) {
 		return ret;
 	}
@@ -272,14 +302,14 @@ int media_svc_insert_item_bulk(MediaSvcHandle *handle, media_svc_storage_type_e
 	if (media_type == MEDIA_SVC_MEDIA_TYPE_OTHER) {
 		/*Do nothing.*/
 	} else if (media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) {
-		ret = _media_svc_extract_image_metadata(handle, &content_info, media_type, uid);
+		ret = _media_svc_extract_image_metadata(db_handle, &content_info);
 	} else {
-		ret = _media_svc_extract_media_metadata(handle, &content_info, media_type, uid);
+		ret = _media_svc_extract_media_metadata(db_handle, &content_info, uid);
 	}
 	media_svc_retv_del_if(ret != MS_MEDIA_ERR_NONE, ret, &content_info);
 
 	/*Set or Get folder id*/
-	ret = _media_svc_get_and_append_folder_id_by_path(handle, DEFAULT_MEDIA_SVC_STORAGE_ID, path, storage_type, folder_uuid, uid);
+	ret = _media_svc_get_and_append_folder_id_by_path(db_handle, storage_id, path, storage_type, folder_uuid, uid);
 	media_svc_retv_del_if(ret != MS_MEDIA_ERR_NONE, ret, &content_info);
 
 	ret = __media_svc_malloc_and_strncpy(&content_info.folder_uuid, folder_uuid);
@@ -287,7 +317,7 @@ int media_svc_insert_item_bulk(MediaSvcHandle *handle, media_svc_storage_type_e
 
 	if (g_media_svc_insert_item_data_cnt == 1) {
 
-		ret = _media_svc_insert_item_with_data(db_handle, &content_info, is_burst, FALSE, uid);
+		ret = _media_svc_insert_item_with_data(db_handle, storage_id, &content_info, is_burst, FALSE, uid);
 		media_svc_retv_del_if(ret != MS_MEDIA_ERR_NONE, ret, &content_info);
 
 		if (g_insert_with_noti)
@@ -295,7 +325,7 @@ int media_svc_insert_item_bulk(MediaSvcHandle *handle, media_svc_storage_type_e
 
 	} else if (g_media_svc_insert_item_cur_data_cnt  < (g_media_svc_insert_item_data_cnt  - 1)) {
 
-		ret = _media_svc_insert_item_with_data(db_handle, &content_info, is_burst, TRUE, uid);
+		ret = _media_svc_insert_item_with_data(db_handle, storage_id, &content_info, is_burst, TRUE, uid);
 		media_svc_retv_del_if(ret != MS_MEDIA_ERR_NONE, ret, &content_info);
 
 		if (g_insert_with_noti)
@@ -305,7 +335,7 @@ int media_svc_insert_item_bulk(MediaSvcHandle *handle, media_svc_storage_type_e
 
 	} else if (g_media_svc_insert_item_cur_data_cnt  == (g_media_svc_insert_item_data_cnt  - 1)) {
 
-		ret = _media_svc_insert_item_with_data(db_handle, &content_info, is_burst, TRUE, uid);
+		ret = _media_svc_insert_item_with_data(db_handle, storage_id, &content_info, is_burst, TRUE, uid);
 		media_svc_retv_del_if(ret != MS_MEDIA_ERR_NONE, ret, &content_info);
 
 		if (g_insert_with_noti)
@@ -336,7 +366,7 @@ int media_svc_insert_item_bulk(MediaSvcHandle *handle, media_svc_storage_type_e
 	return MS_MEDIA_ERR_NONE;
 }
 
-int media_svc_insert_item_immediately(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, const char *path, uid_t uid)
+int media_svc_insert_item_immediately(MediaSvcHandle *handle, const char *storage_id, media_svc_storage_type_e storage_type, const char *path, uid_t uid)
 {
 	int ret = MS_MEDIA_ERR_NONE;
 	sqlite3 *db_handle = (sqlite3 *)handle;
@@ -344,20 +374,15 @@ int media_svc_insert_item_immediately(MediaSvcHandle *handle, media_svc_storage_
 	media_svc_media_type_e media_type;
 
 	media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
+	media_svc_retvm_if(!STRING_VALID(storage_id), MS_MEDIA_ERR_INVALID_PARAMETER, "storage_id is NULL");
 	media_svc_retvm_if(!STRING_VALID(path), MS_MEDIA_ERR_INVALID_PARAMETER, "path is NULL");
-
-#if 0
-	if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
-		media_svc_error("storage type is incorrect[%d]", storage_type);
-		return MS_MEDIA_ERR_INVALID_PARAMETER;
-	}
-#endif
+	media_svc_retvm_if(__media_svc_check_storage(storage_type, FALSE) != TRUE, MS_MEDIA_ERR_INVALID_PARAMETER, "Invalid storage_type");
 
 	media_svc_content_info_s content_info;
 	memset(&content_info, 0, sizeof(media_svc_content_info_s));
 
 	/*Set media info*/
-	ret = _media_svc_set_media_info(&content_info, DEFAULT_MEDIA_SVC_STORAGE_ID, storage_type, path, &media_type, FALSE);
+	ret = _media_svc_set_media_info(&content_info, storage_id, storage_type, path, &media_type, FALSE);
 	if (ret != MS_MEDIA_ERR_NONE) {
 		return ret;
 	}
@@ -365,15 +390,15 @@ int media_svc_insert_item_immediately(MediaSvcHandle *handle, media_svc_storage_
 	if (media_type == MEDIA_SVC_MEDIA_TYPE_OTHER) {
 		/*Do nothing.*/
 	} else if (media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) {
-		ret = _media_svc_extract_image_metadata(handle, &content_info, media_type, uid);
+		ret = _media_svc_extract_image_metadata(db_handle, &content_info);
 	} else {
-		ret = _media_svc_extract_media_metadata(handle, &content_info, media_type, uid);
+		ret = _media_svc_extract_media_metadata(db_handle, &content_info, uid);
 	}
 
 	media_svc_retv_del_if(ret != MS_MEDIA_ERR_NONE, ret, &content_info);
 
 	/*Set or Get folder id*/
-	ret = _media_svc_get_and_append_folder_id_by_path(handle, DEFAULT_MEDIA_SVC_STORAGE_ID, path, storage_type, folder_uuid, uid);
+	ret = _media_svc_get_and_append_folder_id_by_path(db_handle, storage_id, path, storage_type, folder_uuid, uid);
 	media_svc_retv_del_if(ret != MS_MEDIA_ERR_NONE, ret, &content_info);
 
 	ret = __media_svc_malloc_and_strncpy(&content_info.folder_uuid, folder_uuid);
@@ -400,7 +425,7 @@ int media_svc_insert_item_immediately(MediaSvcHandle *handle, media_svc_storage_
 	}
 #endif
 
-	ret = _media_svc_insert_item_with_data(db_handle, &content_info, FALSE, FALSE, uid);
+	ret = _media_svc_insert_item_with_data(db_handle, storage_id, &content_info, FALSE, FALSE, uid);
 
 	if (ret == MS_MEDIA_ERR_NONE) {
 		media_svc_debug("Insertion is successful. Sending noti for this");
@@ -413,28 +438,7 @@ int media_svc_insert_item_immediately(MediaSvcHandle *handle, media_svc_storage_
 	return ret;
 }
 
-int media_svc_insert_folder(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, const char *path, uid_t uid)
-{
-	int ret = MS_MEDIA_ERR_NONE;
-	sqlite3 *db_handle = (sqlite3 *)handle;
-	char folder_uuid[MEDIA_SVC_UUID_SIZE + 1] = {0, };
-	memset(folder_uuid, 0, sizeof(folder_uuid));
-
-	media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
-	media_svc_retvm_if(!STRING_VALID(path), MS_MEDIA_ERR_INVALID_PARAMETER, "path is NULL");
-
-	if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
-		media_svc_error("storage type is incorrect[%d]", storage_type);
-		return MS_MEDIA_ERR_INVALID_PARAMETER;
-	}
-
-	media_svc_debug("storage[%d], folder_path[%s]", storage_type, path);
-
-	ret = _media_svc_get_and_append_folder(db_handle, DEFAULT_MEDIA_SVC_STORAGE_ID, path, storage_type, folder_uuid, uid);
-
-	return ret;
-}
-
+#if 0
 int media_svc_move_item_begin(MediaSvcHandle *handle, int data_cnt)
 {
 	sqlite3 *db_handle = (sqlite3 *)handle;
@@ -455,7 +459,7 @@ int media_svc_move_item_end(MediaSvcHandle *handle, uid_t uid)
 	int ret = MS_MEDIA_ERR_NONE;
 	sqlite3 *db_handle = (sqlite3 *)handle;
 
-	media_svc_debug_func();
+	media_svc_debug_fenter();
 
 	media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 
@@ -465,7 +469,8 @@ int media_svc_move_item_end(MediaSvcHandle *handle, uid_t uid)
 	}
 
 	/*clean up old folder path*/
-	ret = _media_svc_update_folder_table(handle, uid);
+	//need to check it. but media_svc_move_item_end API not used.
+	ret = _media_svc_update_folder_table(db_handle, DEFAULT_MEDIA_SVC_STORAGE_ID, uid);
 	media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 
 	g_media_svc_move_item_data_cnt  = 1;
@@ -473,9 +478,10 @@ int media_svc_move_item_end(MediaSvcHandle *handle, uid_t uid)
 
 	return ret;
 }
+#endif
 
-int media_svc_move_item(MediaSvcHandle *handle, media_svc_storage_type_e src_storage, const char *src_path,
-                        media_svc_storage_type_e dest_storage, const char *dest_path, uid_t uid)
+int media_svc_move_item(MediaSvcHandle *handle, const char *storage_id, media_svc_storage_type_e src_storage, const char *src_path,
+			media_svc_storage_type_e dest_storage, const char *dest_path, uid_t uid)
 {
 	int ret = MS_MEDIA_ERR_NONE;
 	sqlite3 *db_handle = (sqlite3 *)handle;
@@ -487,23 +493,16 @@ int media_svc_move_item(MediaSvcHandle *handle, media_svc_storage_type_e src_sto
 	char new_thumb_path[MEDIA_SVC_PATHNAME_SIZE] = {0, };
 	int media_type = -1;
 
-	media_svc_debug_func();
+	media_svc_debug_fenter();
 
 	media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 	media_svc_retvm_if(!STRING_VALID(src_path), MS_MEDIA_ERR_INVALID_PARAMETER, "src_path is NULL");
 	media_svc_retvm_if(!STRING_VALID(dest_path), MS_MEDIA_ERR_INVALID_PARAMETER, "dest_path is NULL");
-
-	if ((src_storage != MEDIA_SVC_STORAGE_INTERNAL) && (src_storage != MEDIA_SVC_STORAGE_EXTERNAL)) {
-		media_svc_error("src_storage type is incorrect[%d]", src_storage);
-		return MS_MEDIA_ERR_INVALID_PARAMETER;
-	}
-	if ((dest_storage != MEDIA_SVC_STORAGE_INTERNAL) && (dest_storage != MEDIA_SVC_STORAGE_EXTERNAL)) {
-		media_svc_error("dest_storage type is incorrect[%d]", dest_storage);
-		return MS_MEDIA_ERR_INVALID_PARAMETER;
-	}
+	media_svc_retvm_if(__media_svc_check_storage(src_storage, FALSE) != TRUE, MS_MEDIA_ERR_INVALID_PARAMETER, "Invalid src_storage");
+	media_svc_retvm_if(__media_svc_check_storage(dest_storage, FALSE) != TRUE, MS_MEDIA_ERR_INVALID_PARAMETER, "Invalid dest_storage");
 
 	/*check and update folder*/
-	ret = _media_svc_get_and_append_folder_id_by_path(handle, DEFAULT_MEDIA_SVC_STORAGE_ID, dest_path, dest_storage, folder_uuid, uid);
+	ret = _media_svc_get_and_append_folder_id_by_path(db_handle, storage_id, dest_path, dest_storage, folder_uuid, uid);
 	media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 
 	/*get filename*/
@@ -513,7 +512,7 @@ int media_svc_move_item(MediaSvcHandle *handle, media_svc_storage_type_e src_sto
 	modified_time = _media_svc_get_file_time(dest_path);
 
 	/*get thumbnail_path to update. only for Imgae and Video items. Audio share album_art(thumbnail)*/
-	ret = _media_svc_get_media_type_by_path(handle, DEFAULT_MEDIA_SVC_STORAGE_ID, src_path, &media_type);
+	ret = _media_svc_get_media_type_by_path(db_handle, storage_id, src_path, &media_type);
 	if (ret != MS_MEDIA_ERR_NONE) {
 		media_svc_error("_media_svc_get_media_type_by_path failed");
 		SAFE_FREE(file_name);
@@ -522,7 +521,7 @@ int media_svc_move_item(MediaSvcHandle *handle, media_svc_storage_type_e src_sto
 
 	if ((media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) || (media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)) {
 		/*get old thumbnail_path*/
-		ret = _media_svc_get_thumbnail_path_by_path(handle, DEFAULT_MEDIA_SVC_STORAGE_ID, src_path, old_thumb_path);
+		ret = _media_svc_get_thumbnail_path_by_path(db_handle, storage_id, src_path, old_thumb_path);
 		if ((ret != MS_MEDIA_ERR_NONE) && (ret != MS_MEDIA_ERR_DB_NO_RECORD)) {
 			media_svc_error("_media_svc_get_thumbnail_path_by_path failed");
 			SAFE_FREE(file_name);
@@ -541,9 +540,9 @@ int media_svc_move_item(MediaSvcHandle *handle, media_svc_storage_type_e src_sto
 
 		/*update item*/
 		if ((media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) || (media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)) {
-			ret = _media_svc_update_item_by_path(handle, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, new_thumb_path, FALSE, uid);
+			ret = _media_svc_update_item_by_path(db_handle, storage_id, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, new_thumb_path, FALSE, uid);
 		} else {
-			ret = _media_svc_update_item_by_path(handle, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, NULL, FALSE, uid);
+			ret = _media_svc_update_item_by_path(db_handle, storage_id, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, NULL, FALSE, uid);
 		}
 		SAFE_FREE(file_name);
 		media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
@@ -552,7 +551,7 @@ int media_svc_move_item(MediaSvcHandle *handle, media_svc_storage_type_e src_sto
 
 		/* Get notification info */
 		media_svc_noti_item *noti_item = NULL;
-		ret = _media_svc_get_noti_info(handle, DEFAULT_MEDIA_SVC_STORAGE_ID, dest_path, MS_MEDIA_ITEM_FILE, &noti_item);
+		ret = _media_svc_get_noti_info(db_handle, storage_id, dest_path, MS_MEDIA_ITEM_FILE, &noti_item);
 		media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 
 		/* Send notification for move */
@@ -561,27 +560,27 @@ int media_svc_move_item(MediaSvcHandle *handle, media_svc_storage_type_e src_sto
 
 		/*update folder modified_time*/
 		folder_path = g_path_get_dirname(dest_path);
-		ret = _media_svc_update_folder_modified_time_by_folder_uuid(handle, folder_uuid, folder_path, FALSE, uid);
+		ret = _media_svc_update_folder_modified_time_by_folder_uuid(db_handle, folder_uuid, folder_path, FALSE, uid);
 		SAFE_FREE(folder_path);
 		media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 
-		ret = _media_svc_update_folder_table(handle, uid);
+		ret = _media_svc_update_folder_table(db_handle, storage_id, uid);
 		media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 
 	} else if (g_media_svc_move_item_cur_data_cnt  < (g_media_svc_move_item_data_cnt  - 1)) {
 
 		/*update item*/
 		if ((media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) || (media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)) {
-			ret = _media_svc_update_item_by_path(handle, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, new_thumb_path, TRUE, uid);
+			ret = _media_svc_update_item_by_path(db_handle, storage_id, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, new_thumb_path, TRUE, uid);
 		} else {
-			ret = _media_svc_update_item_by_path(handle, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, NULL, TRUE, uid);
+			ret = _media_svc_update_item_by_path(db_handle, storage_id, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, NULL, TRUE, uid);
 		}
 		SAFE_FREE(file_name);
 		media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 
 		/*update folder modified_time*/
 		folder_path = g_path_get_dirname(dest_path);
-		ret = _media_svc_update_folder_modified_time_by_folder_uuid(handle, folder_uuid, folder_path, TRUE, uid);
+		ret = _media_svc_update_folder_modified_time_by_folder_uuid(db_handle, folder_uuid, folder_path, TRUE, uid);
 		SAFE_FREE(folder_path);
 		media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 
@@ -591,16 +590,16 @@ int media_svc_move_item(MediaSvcHandle *handle, media_svc_storage_type_e src_sto
 
 		/*update item*/
 		if ((media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) || (media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)) {
-			ret = _media_svc_update_item_by_path(handle, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, new_thumb_path, TRUE, uid);
+			ret = _media_svc_update_item_by_path(db_handle, storage_id, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, new_thumb_path, TRUE, uid);
 		} else {
-			ret = _media_svc_update_item_by_path(handle, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, NULL, TRUE, uid);
+			ret = _media_svc_update_item_by_path(db_handle, storage_id, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, NULL, TRUE, uid);
 		}
 		SAFE_FREE(file_name);
 		media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 
 		/*update folder modified_time*/
 		folder_path = g_path_get_dirname(dest_path);
-		ret = _media_svc_update_folder_modified_time_by_folder_uuid(handle, folder_uuid, folder_path, TRUE, uid);
+		ret = _media_svc_update_folder_modified_time_by_folder_uuid(db_handle, folder_uuid, folder_path, TRUE, uid);
 		SAFE_FREE(folder_path);
 		media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 
@@ -616,7 +615,7 @@ int media_svc_move_item(MediaSvcHandle *handle, media_svc_storage_type_e src_sto
 	}
 
 	/*rename thumbnail file*/
-/*	if((media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) ||(media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)) { */
+/*	if ((media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) || (media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)) { */
 	if ((strlen(old_thumb_path) > 0) && (strncmp(old_thumb_path, MEDIA_SVC_THUMB_DEFAULT_PATH, sizeof(MEDIA_SVC_THUMB_DEFAULT_PATH)) != 0)) {
 		ret = _media_svc_rename_file(old_thumb_path, new_thumb_path);
 		if (ret != MS_MEDIA_ERR_NONE)
@@ -647,7 +646,7 @@ int media_svc_set_item_validity_end(MediaSvcHandle *handle, uid_t uid)
 	int ret = MS_MEDIA_ERR_NONE;
 	sqlite3 *db_handle = (sqlite3 *)handle;
 
-	media_svc_debug_func();
+	media_svc_debug_fenter();
 
 	media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 
@@ -662,30 +661,31 @@ int media_svc_set_item_validity_end(MediaSvcHandle *handle, uid_t uid)
 	return ret;
 }
 
-int media_svc_set_item_validity(MediaSvcHandle *handle, const char *path, int validity, uid_t uid)
+int media_svc_set_item_validity(MediaSvcHandle *handle, const char *storage_id, const char *path, int validity, uid_t uid)
 {
 	int ret = MS_MEDIA_ERR_NONE;
 	sqlite3 *db_handle = (sqlite3 *)handle;
 
 	media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
+	media_svc_retvm_if(!STRING_VALID(storage_id), MS_MEDIA_ERR_INVALID_PARAMETER, "storage_id is NULL");
 	media_svc_retvm_if(!STRING_VALID(path), MS_MEDIA_ERR_INVALID_PARAMETER, "path is NULL");
 
 	media_svc_debug("path=[%s], validity=[%d]", path, validity);
 
 	if (g_media_svc_item_validity_data_cnt  == 1) {
 
-		return _media_svc_update_item_validity(db_handle, path, validity, FALSE, uid);
+		return _media_svc_update_item_validity(db_handle, storage_id, path, validity, FALSE, uid);
 
 	} else if (g_media_svc_item_validity_cur_data_cnt  < (g_media_svc_item_validity_data_cnt  - 1)) {
 
-		ret = _media_svc_update_item_validity(db_handle, path, validity, TRUE, uid);
+		ret = _media_svc_update_item_validity(db_handle, storage_id, path, validity, TRUE, uid);
 		media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 
 		g_media_svc_item_validity_cur_data_cnt++;
 
 	} else if (g_media_svc_item_validity_cur_data_cnt  == (g_media_svc_item_validity_data_cnt  - 1)) {
 
-		ret = _media_svc_update_item_validity(db_handle, path, validity, TRUE, uid);
+		ret = _media_svc_update_item_validity(db_handle, storage_id, path, validity, TRUE, uid);
 		media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 
 		ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_SET_ITEM_VALIDITY, uid);
@@ -708,7 +708,7 @@ int media_svc_delete_item_by_path(MediaSvcHandle *handle, const char *storage_id
 	sqlite3 *db_handle = (sqlite3 *)handle;
 	char thumb_path[MEDIA_SVC_PATHNAME_SIZE] = {0, };
 
-	media_svc_debug_func();
+	media_svc_debug_fenter();
 
 	media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 	media_svc_retvm_if(!STRING_VALID(storage_id), MS_MEDIA_ERR_INVALID_PARAMETER, "storage_id is NULL");
@@ -770,99 +770,106 @@ int media_svc_delete_item_by_path(MediaSvcHandle *handle, const char *storage_id
 
 	/*Delete thumbnail*/
 	if ((strlen(thumb_path) > 0) && (strncmp(thumb_path, _media_svc_get_thumb_default_path(uid), sizeof(_media_svc_get_thumb_default_path(uid))) != 0)) {
-		ret = _media_svc_remove_file(thumb_path);
-		if (ret != MS_MEDIA_ERR_NONE) {
-			media_svc_error("fail to remove thumbnail file.");
+/*
+		int thumb_count = 1;
+		// Get count of media, which contains same thumbnail for music
+		if ((media_type == MEDIA_SVC_MEDIA_TYPE_SOUND) ||(media_type == MEDIA_SVC_MEDIA_TYPE_MUSIC)) {
+			ret = _media_svc_get_thumbnail_count(db_handle, storage_id, thumb_path, &thumb_count);
+			if (ret != MS_MEDIA_ERR_NONE) {
+				media_svc_error("Failed to get thumbnail count : %d", ret);
+			}
 		}
+
+		if (thumb_count == 1) {
+*/
+			ret = _media_svc_remove_file(thumb_path);
+			if(ret != MS_MEDIA_ERR_NONE) {
+				media_svc_error("fail to remove thumbnail file.");
+			}
+//		}
 	}
 
 	return MS_MEDIA_ERR_NONE;
 }
 
-int media_svc_delete_all_items_in_storage(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, uid_t uid)
+int media_svc_delete_all_items_in_storage(MediaSvcHandle *handle, const char *storage_id, media_svc_storage_type_e storage_type, uid_t uid)
 {
 	int ret = MS_MEDIA_ERR_NONE;
 	sqlite3 *db_handle = (sqlite3 *)handle;
-	char *dirpath = NULL;
 
 	media_svc_debug("media_svc_delete_all_items_in_storage [%d]", storage_type);
 
 	media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
+	media_svc_retvm_if(!STRING_VALID(storage_id), MS_MEDIA_ERR_INVALID_PARAMETER, "storage_id is NULL");
+	media_svc_retvm_if(__media_svc_check_storage(storage_type, FALSE) != TRUE, MS_MEDIA_ERR_INVALID_PARAMETER, "Invalid storage_type");
 
-	if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
-		media_svc_error("storage type is incorrect[%d]", storage_type);
-		return MS_MEDIA_ERR_INVALID_PARAMETER;
-	}
-
-	ret = _media_svc_truncate_table(db_handle, storage_type, uid);
+	ret = _media_svc_truncate_table(db_handle, storage_id, storage_type, uid);
 	media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 
-	dirpath = (storage_type == MEDIA_SVC_STORAGE_INTERNAL) ? _media_svc_get_thumb_internal_path(uid) : _media_svc_get_thumb_external_path(uid);
+	if (storage_type != MEDIA_SVC_STORAGE_EXTERNAL_USB) {
+		const char *dirpath = (storage_type == MEDIA_SVC_STORAGE_INTERNAL) ? MEDIA_SVC_THUMB_INTERNAL_PATH : MEDIA_SVC_THUMB_EXTERNAL_PATH;
 
-	/* remove thumbnails */
-	ret = _media_svc_remove_all_files_in_dir(dirpath);
-	media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
+		/* remove thumbnails */
+		ret = _media_svc_remove_all_files_in_dir(dirpath);
+		media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
+	}
 
 	return MS_MEDIA_ERR_NONE;
 }
 
-int media_svc_delete_invalid_items_in_storage(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, uid_t uid)
+int media_svc_delete_invalid_items_in_storage(MediaSvcHandle *handle, const char *storage_id, media_svc_storage_type_e storage_type, uid_t uid)
 {
 	sqlite3 *db_handle = (sqlite3 *)handle;
 
-	media_svc_debug_func();
+	media_svc_debug_fenter();
 
 	media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
-
-	if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
-		media_svc_error("storage type is incorrect[%d]", storage_type);
-		return MS_MEDIA_ERR_INVALID_PARAMETER;
-	}
+	media_svc_retvm_if(!STRING_VALID(storage_id), MS_MEDIA_ERR_INVALID_PARAMETER, "storage_id is NULL");
+	media_svc_retvm_if(__media_svc_check_storage(storage_type, FALSE) != TRUE, MS_MEDIA_ERR_INVALID_PARAMETER, "Invalid storage_type");
 
 	/*Delete from DB and remove thumbnail files*/
-	return _media_svc_delete_invalid_items(db_handle, storage_type, uid);
+	return _media_svc_delete_invalid_items(db_handle, storage_id, storage_type, uid);
 }
 
-int media_svc_delete_invalid_items_in_folder(MediaSvcHandle *handle, const char *folder_path, uid_t uid)
+int media_svc_delete_invalid_items_in_folder(MediaSvcHandle *handle, const char *storage_id, const char *folder_path, bool is_recursive, uid_t uid)
 {
 	sqlite3 *db_handle = (sqlite3 *)handle;
 
-	media_svc_debug_func();
+	media_svc_debug_fenter();
 
 	media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
+	media_svc_retvm_if(!STRING_VALID(storage_id), MS_MEDIA_ERR_INVALID_PARAMETER, "storage_id is NULL");
 
 	/*Delete from DB and remove thumbnail files*/
-	return _media_svc_delete_invalid_folder_items(db_handle, folder_path, uid);
+	return _media_svc_delete_invalid_folder_items(db_handle, storage_id, folder_path, is_recursive, uid);
 }
 
-int media_svc_set_all_storage_items_validity(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, int validity, uid_t uid)
+int media_svc_set_all_storage_items_validity(MediaSvcHandle *handle, const char *storage_id, media_svc_storage_type_e storage_type, int validity, uid_t uid)
 {
 	sqlite3 *db_handle = (sqlite3 *)handle;
 
 	media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
+	media_svc_retvm_if(!STRING_VALID(storage_id), MS_MEDIA_ERR_INVALID_PARAMETER, "storage_id is NULL");
+	media_svc_retvm_if(__media_svc_check_storage(storage_type, FALSE) != TRUE, MS_MEDIA_ERR_INVALID_PARAMETER, "Invalid storage_type");
 
-	if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
-		media_svc_error("storage type is incorrect[%d]", storage_type);
-		return MS_MEDIA_ERR_INVALID_PARAMETER;
-	}
-
-	return _media_svc_update_storage_item_validity(db_handle, storage_type, validity, uid);
+	return _media_svc_update_storage_item_validity(db_handle, storage_id, storage_type, validity, uid);
 }
 
-int media_svc_set_folder_items_validity(MediaSvcHandle *handle, const char *folder_path, int validity, int recursive, uid_t uid)
+int media_svc_set_folder_items_validity(MediaSvcHandle *handle, const char *storage_id, const char *folder_path, int validity, int recursive, uid_t uid)
 {
 	sqlite3 *db_handle = (sqlite3 *)handle;
 
 	media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
+	media_svc_retvm_if(!STRING_VALID(storage_id), MS_MEDIA_ERR_INVALID_PARAMETER, "storage_id is NULL");
 	media_svc_retvm_if(!STRING_VALID(folder_path), MS_MEDIA_ERR_INVALID_PARAMETER, "folder_path is NULL");
 
 	if (recursive)
-		return _media_svc_update_recursive_folder_item_validity(db_handle, folder_path, validity, uid);
+		return _media_svc_update_recursive_folder_item_validity(db_handle, storage_id, folder_path, validity, uid);
 	else
-		return _media_svc_update_folder_item_validity(db_handle, folder_path, validity, uid);
+		return _media_svc_update_folder_item_validity(db_handle, storage_id, folder_path, validity, uid);
 }
 
-int media_svc_refresh_item(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, const char *storage_id, const char *path, uid_t uid)
+int media_svc_refresh_item(MediaSvcHandle *handle, const char *storage_id, media_svc_storage_type_e storage_type, const char *path, uid_t uid)
 {
 	int ret = MS_MEDIA_ERR_NONE;
 	sqlite3 *db_handle = (sqlite3 *)handle;
@@ -871,17 +878,13 @@ int media_svc_refresh_item(MediaSvcHandle *handle, media_svc_storage_type_e stor
 	media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 	media_svc_retvm_if(!STRING_VALID(storage_id), MS_MEDIA_ERR_INVALID_PARAMETER, "storage_id is NULL");
 	media_svc_retvm_if(!STRING_VALID(path), MS_MEDIA_ERR_INVALID_PARAMETER, "path is NULL");
-
-	if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL) && (storage_type != MEDIA_SVC_STORAGE_CLOUD)) {
-		media_svc_error("storage type is incorrect[%d]", storage_type);
-		return MS_MEDIA_ERR_INVALID_PARAMETER;
-	}
+	media_svc_retvm_if(__media_svc_check_storage(storage_type, FALSE) != TRUE, MS_MEDIA_ERR_INVALID_PARAMETER, "Invalid storage_type");
 
 	media_svc_content_info_s content_info;
 	memset(&content_info, 0, sizeof(media_svc_content_info_s));
 
 	/*Set media info*/
-	ret = _media_svc_set_media_info(&content_info, DEFAULT_MEDIA_SVC_STORAGE_ID, storage_type, path, &media_type, TRUE);
+	ret = _media_svc_set_media_info(&content_info, storage_id, storage_type, path, &media_type, TRUE);
 	if (ret != MS_MEDIA_ERR_NONE) {
 		return ret;
 	}
@@ -909,20 +912,21 @@ int media_svc_refresh_item(MediaSvcHandle *handle, media_svc_storage_type_e stor
 
 	/* Get notification info */
 	media_svc_noti_item *noti_item = NULL;
-	ret = _media_svc_get_noti_info(handle, storage_id, path, MS_MEDIA_ITEM_FILE, &noti_item);
+	ret = _media_svc_get_noti_info(db_handle, storage_id, path, MS_MEDIA_ITEM_FILE, &noti_item);
 	if (ret != MS_MEDIA_ERR_NONE) {
 		_media_svc_destroy_content_info(&content_info);
 		return ret;
 	}
 
 	media_type = noti_item->media_type;
+	content_info.media_type = media_type;
 
 	if (media_type == MEDIA_SVC_MEDIA_TYPE_OTHER) {
 		/*Do nothing.*/
 	} else if (media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) {
-		ret = _media_svc_extract_image_metadata(handle, &content_info, media_type, uid);
+		ret = _media_svc_extract_image_metadata(db_handle, &content_info);
 	} else {
-		ret = _media_svc_extract_media_metadata(handle, &content_info, media_type, uid);
+		ret = _media_svc_extract_media_metadata(db_handle, &content_info, uid);
 	}
 
 	if (ret != MS_MEDIA_ERR_NONE) {
@@ -979,44 +983,23 @@ int media_svc_rename_folder(MediaSvcHandle *handle, const char *storage_id, cons
 
 	media_svc_debug("Src path : %s,  Dst Path : %s", src_path, dst_path);
 
-	ret = _media_svc_sql_begin_trans(handle, uid);
+	ret = _media_svc_sql_begin_trans(db_handle, uid);
 	media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 
-	/* Update all folder record's path, which are matched by old parent path */
-	char *update_folder_path_sql = NULL;
-	char src_path_slash[MEDIA_SVC_PATHNAME_SIZE + 1] = {0, };
-	char dst_path_slash[MEDIA_SVC_PATHNAME_SIZE + 1] = {0, };
-
-	snprintf(src_path_slash, sizeof(src_path_slash), "%s/", src_path);
-	snprintf(dst_path_slash, sizeof(dst_path_slash), "%s/", dst_path);
-
-	update_folder_path_sql = sqlite3_mprintf("UPDATE folder SET path = REPLACE( path, '%q', '%q');", src_path_slash, dst_path_slash);
-
-	/*ret = _media_svc_sql_query(handle, update_folder_path_sql, uid); */
-	ret = media_db_request_update_db_batch(update_folder_path_sql, uid);
-	sqlite3_free(update_folder_path_sql);
-
-	if (ret != SQLITE_OK) {
-		media_svc_error("failed to update folder path");
-		_media_svc_sql_rollback_trans(handle, uid);
-
-		return MS_MEDIA_ERR_DB_INTERNAL;
-	}
-
 	/* Update all folder record's modified date, which are changed above */
 	char *update_folder_modified_time_sql = NULL;
 	time_t date;
 	time(&date);
 
-	update_folder_modified_time_sql = sqlite3_mprintf("UPDATE folder SET modified_time = %d where path like '%q';", date, dst_path);
+	update_folder_modified_time_sql = sqlite3_mprintf("UPDATE folder SET modified_time = %d WHERE path LIKE '%q';", date, dst_path);
 
 	ret = media_db_request_update_db_batch(update_folder_modified_time_sql, uid);
-	/*ret = _media_svc_sql_query(handle, update_folder_modified_time_sql, uid); */
+	//ret = _media_svc_sql_query(db_handle, update_folder_modified_time_sql, uid);
 	sqlite3_free(update_folder_modified_time_sql);
 
 	if (ret != SQLITE_OK) {
 		media_svc_error("failed to update folder modified time");
-		_media_svc_sql_rollback_trans(handle, uid);
+		_media_svc_sql_rollback_trans(db_handle, uid);
 
 		return MS_MEDIA_ERR_DB_INTERNAL;
 	}
@@ -1032,20 +1015,14 @@ int media_svc_rename_folder(MediaSvcHandle *handle, const char *storage_id, cons
 
 	media_svc_debug("[SQL query] : %s", select_all_sql);
 
-	ret = _media_svc_sql_prepare_to_step(db_handle, select_all_sql, &sql_stmt);
+	ret = _media_svc_sql_prepare_to_step_simple(db_handle, select_all_sql, &sql_stmt);
 	if (ret != MS_MEDIA_ERR_NONE) {
 		media_svc_error("error when media_svc_rename_folder. err = [%d]", ret);
 		_media_svc_sql_rollback_trans(db_handle, uid);
 		return ret;
 	}
 
-	while (1) {
-		ret = sqlite3_step(sql_stmt);
-		if (ret != SQLITE_ROW) {
-			media_svc_debug("end of iteration");
-			break;
-		}
-
+	while (sqlite3_step(sql_stmt) == SQLITE_ROW) {
 		char media_uuid[MEDIA_SVC_UUID_SIZE + 1] = {0, };
 		char media_path[MEDIA_SVC_PATHNAME_SIZE + 1] = {0, };
 		char media_thumb_path[MEDIA_SVC_PATHNAME_SIZE + 1] = {0, };
@@ -1085,7 +1062,7 @@ int media_svc_rename_folder(MediaSvcHandle *handle, const char *storage_id, cons
 		if (replaced_path == NULL) {
 			media_svc_error("_media_svc_replace_path failed");
 			SQLITE3_FINALIZE(sql_stmt);
-			_media_svc_sql_rollback_trans(handle, uid);
+			_media_svc_sql_rollback_trans(db_handle, uid);
 			return MS_MEDIA_ERR_INTERNAL;
 		}
 
@@ -1097,11 +1074,11 @@ int media_svc_rename_folder(MediaSvcHandle *handle, const char *storage_id, cons
 			if (strncmp(media_thumb_path, _media_svc_get_thumb_default_path(uid), sizeof(_media_svc_get_thumb_default_path(uid))) == 0) {
 				strncpy(media_new_thumb_path, _media_svc_get_thumb_default_path(uid), sizeof(media_new_thumb_path));
 			} else {
-				ret = _media_svc_get_store_type_by_path(replaced_path, &storage_type, uid);
+				ret = _media_svc_get_storage_type_by_path(replaced_path, &storage_type, uid);
 				if (ret != MS_MEDIA_ERR_NONE) {
-					media_svc_error("_media_svc_get_store_type_by_path failed : %d", ret);
+					media_svc_error("_media_svc_get_storage_type_by_path failed : %d", ret);
 					SAFE_FREE(replaced_path);
-					_media_svc_sql_rollback_trans(handle, uid);
+					_media_svc_sql_rollback_trans(db_handle, uid);
 					return ret;
 				}
 
@@ -1110,7 +1087,7 @@ int media_svc_rename_folder(MediaSvcHandle *handle, const char *storage_id, cons
 					media_svc_error("_media_svc_get_thumbnail_path failed : %d", ret);
 					SAFE_FREE(replaced_path);
 					SQLITE3_FINALIZE(sql_stmt);
-					_media_svc_sql_rollback_trans(handle, uid);
+					_media_svc_sql_rollback_trans(db_handle, uid);
 					return ret;
 				}
 			}
@@ -1135,14 +1112,14 @@ int media_svc_rename_folder(MediaSvcHandle *handle, const char *storage_id, cons
 		}
 
 		ret = media_db_request_update_db_batch(update_item_sql, uid);
-		/*ret = _media_svc_sql_query(handle, update_item_sql, uid); */
+		/*ret = _media_svc_sql_query(db_handle, update_item_sql, uid); */
 		sqlite3_free(update_item_sql);
 		SAFE_FREE(replaced_path);
 
 		if (ret != SQLITE_OK) {
 			media_svc_error("failed to update item");
 			SQLITE3_FINALIZE(sql_stmt);
-			_media_svc_sql_rollback_trans(handle, uid);
+			_media_svc_sql_rollback_trans(db_handle, uid);
 
 			return MS_MEDIA_ERR_DB_INTERNAL;
 		}
@@ -1160,10 +1137,10 @@ int media_svc_rename_folder(MediaSvcHandle *handle, const char *storage_id, cons
 
 	SQLITE3_FINALIZE(sql_stmt);
 
-	ret = _media_svc_sql_end_trans(handle, uid);
+	ret = _media_svc_sql_end_trans(db_handle, uid);
 	if (ret != MS_MEDIA_ERR_NONE) {
-		media_svc_error("mb_svc_sqlite3_commit_trans failed.. Now start to rollback\n");
-		_media_svc_sql_rollback_trans(handle, uid);
+		media_svc_error("mb_svc_sqlite3_commit_trans failed.. Now start to rollback");
+		_media_svc_sql_rollback_trans(db_handle, uid);
 		return ret;
 	}
 
@@ -1186,7 +1163,7 @@ int media_svc_request_update_db(const char *db_query, uid_t uid)
 	return _media_svc_sql_query(NULL, db_query, uid);
 }
 
-int media_svc_send_dir_update_noti(MediaSvcHandle *handle, const char *dir_path)
+int media_svc_send_dir_update_noti(MediaSvcHandle *handle, const char *storage_id, const char *dir_path)
 {
 	int ret = MS_MEDIA_ERR_NONE;
 	sqlite3 *db_handle = (sqlite3 *)handle;
@@ -1196,7 +1173,7 @@ int media_svc_send_dir_update_noti(MediaSvcHandle *handle, const char *dir_path)
 
 	/* Get notification info */
 	media_svc_noti_item *noti_item = NULL;
-	ret = _media_svc_get_noti_info(db_handle, DEFAULT_MEDIA_SVC_STORAGE_ID, dir_path, MS_MEDIA_ITEM_DIRECTORY, &noti_item);
+	ret = _media_svc_get_noti_info(db_handle, storage_id, dir_path, MS_MEDIA_ITEM_DIRECTORY, &noti_item);
 	media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 
 	ret = _media_svc_publish_noti(MS_MEDIA_ITEM_DIRECTORY, MS_MEDIA_ITEM_UPDATE, dir_path, -1, noti_item->media_uuid, NULL);
@@ -1205,34 +1182,37 @@ int media_svc_send_dir_update_noti(MediaSvcHandle *handle, const char *dir_path)
 	return ret;
 }
 
-int media_svc_count_invalid_items_in_folder(MediaSvcHandle *handle, const char *folder_path, int *count)
+int media_svc_count_invalid_items_in_folder(MediaSvcHandle *handle, const char *storage_id, const char *folder_path, int *count)
 {
 	sqlite3 *db_handle = (sqlite3 *)handle;
 
-	media_svc_debug_func();
+	media_svc_debug_fenter();
 
 	media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
+	media_svc_retvm_if(!STRING_VALID(storage_id), MS_MEDIA_ERR_INVALID_PARAMETER, "storage_id is NULL");
 	media_svc_retvm_if(folder_path == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "folder_path is NULL");
 	media_svc_retvm_if(count == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "count is NULL");
 
-	return _media_svc_count_invalid_folder_items(db_handle, folder_path, count);
+	return _media_svc_count_invalid_folder_items(db_handle, storage_id, folder_path, count);
 }
 
-int media_svc_check_db_upgrade(MediaSvcHandle *handle, uid_t uid)
+int media_svc_check_db_upgrade(MediaSvcHandle *handle, bool *need_full_scan, uid_t uid)
 {
 	sqlite3 *db_handle = (sqlite3 *)handle;
 
-	media_svc_debug_func();
+	media_svc_debug_fenter();
+
 	media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 
-	return _media_svc_check_db_upgrade(db_handle, uid);
+	return _media_svc_check_db_upgrade(db_handle, need_full_scan, uid);
 }
 
 int media_svc_check_db_corrupt(MediaSvcHandle *handle)
 {
 	sqlite3 *db_handle = (sqlite3 *)handle;
 
-	media_svc_debug_func();
+	media_svc_debug_fenter();
+
 	media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 
 	return _media_db_check_corrupt(db_handle);
@@ -1242,7 +1222,7 @@ int media_svc_get_folder_list(MediaSvcHandle *handle, char *start_path, char ***
 {
 	sqlite3 *db_handle = (sqlite3 *)handle;
 
-	media_svc_debug_func();
+	media_svc_debug_fenter();
 
 	media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 	media_svc_retvm_if(count == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "count is NULL");
@@ -1290,7 +1270,7 @@ int media_svc_update_item_end(MediaSvcHandle *handle, uid_t uid)
 	int ret = MS_MEDIA_ERR_NONE;
 	sqlite3 *db_handle = (sqlite3 *)handle;
 
-	media_svc_debug_func();
+	media_svc_debug_fenter();
 
 	media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 
@@ -1317,11 +1297,7 @@ int media_svc_update_item_meta(MediaSvcHandle *handle, const char *file_path, in
 
 	media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 	media_svc_retvm_if(!STRING_VALID(file_path), MS_MEDIA_ERR_INVALID_PARAMETER, "path is NULL");
-
-	if ((storage_type != MEDIA_SVC_STORAGE_INTERNAL) && (storage_type != MEDIA_SVC_STORAGE_EXTERNAL)) {
-		media_svc_error("storage type is incorrect[%d]", storage_type);
-		return MS_MEDIA_ERR_INVALID_PARAMETER;
-	}
+	media_svc_retvm_if(__media_svc_check_storage(storage_type, FALSE) != TRUE, MS_MEDIA_ERR_INVALID_PARAMETER, "Invalid storage_type");
 
 	media_svc_content_info_s content_info;
 	memset(&content_info, 0, sizeof(media_svc_content_info_s));
@@ -1337,6 +1313,7 @@ int media_svc_update_item_meta(MediaSvcHandle *handle, const char *file_path, in
 	} else {
 		return MS_MEDIA_ERR_NONE;
 	}
+
 	if (ret != MS_MEDIA_ERR_NONE) {
 		_media_svc_destroy_content_info(&content_info);
 		return ret;
@@ -1394,6 +1371,86 @@ int media_svc_check_pinyin_support(bool *support)
 	return MS_MEDIA_ERR_NONE;
 }
 
+int media_svc_set_storage_validity(MediaSvcHandle *handle, const char *storage_id, int validity, uid_t uid)
+{
+	int ret = MS_MEDIA_ERR_NONE;
+	sqlite3 * db_handle = (sqlite3 *)handle;
+
+	media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
+
+	ret = _media_svc_update_storage_validity(db_handle, storage_id, validity, uid);
+	media_svc_retvm_if(ret != MS_MEDIA_ERR_NONE, ret, "update storage validity failed: %d", ret);
+
+	ret = _media_svc_update_media_view(db_handle, uid);
+	media_svc_retvm_if(ret != MS_MEDIA_ERR_NONE, ret, "update media view failed : %d", ret);
+
+	return ret;
+}
+
+int media_svc_get_storage_id(MediaSvcHandle *handle, const char *path, char *storage_id)
+{
+	int ret = MS_MEDIA_ERR_NONE;
+	sqlite3 * db_handle = (sqlite3 *)handle;
+
+	media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
+	media_svc_retvm_if(path == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "path is NULL");
+
+	ret = _media_svc_get_storage_uuid(db_handle, path, storage_id);
+
+	return ret;
+}
+
+int media_svc_get_storage_path(MediaSvcHandle *handle, const char *storage_uuid, char **storage_path)
+{
+	int ret = MS_MEDIA_ERR_NONE;
+	sqlite3 * db_handle = (sqlite3 *)handle;
+
+	media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
+	media_svc_retvm_if(storage_uuid == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "storage_uuid is NULL");
+
+	ret = _media_svc_get_storage_path(db_handle, storage_uuid, storage_path);
+
+	return ret;
+}
+
+int media_svc_get_storage_scan_status(MediaSvcHandle *handle, const char *storage_uuid, media_svc_scan_status_type_e *storage_status)
+{
+	int ret = MS_MEDIA_ERR_NONE;
+	sqlite3 * db_handle = (sqlite3 *)handle;
+
+	media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
+	media_svc_retvm_if(storage_uuid == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "storage_uuid is NULL");
+
+	ret = _media_svc_get_storage_scan_status(db_handle, storage_uuid, storage_status);
+
+	return ret;
+}
+
+int media_svc_set_storage_scan_status(MediaSvcHandle *handle, const char *storage_uuid, media_svc_scan_status_type_e storage_status, uid_t uid)
+{
+	int ret = MS_MEDIA_ERR_NONE;
+	sqlite3 * db_handle = (sqlite3 *)handle;
+
+	media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
+
+	ret = _media_svc_set_storage_scan_status(db_handle, storage_uuid, storage_status, uid);
+
+	return ret;
+}
+
+int media_svc_get_storage_list(MediaSvcHandle *handle, char ***storage_list, char ***storage_id_list, int **scan_status_list, int *count)
+{
+	sqlite3 * db_handle = (sqlite3 *)handle;
+
+	media_svc_debug_fenter();
+
+	media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
+	media_svc_retvm_if(count == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "count is NULL");
+
+	return _media_svc_get_all_storage(db_handle, storage_list, storage_id_list, scan_status_list, count);
+}
+
+
 static int __media_svc_copy_para_to_content(media_svc_content_info_s *content_info, media_svc_content_info_s *new_content_info)
 {
 	media_svc_retvm_if(content_info == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
@@ -1507,14 +1564,14 @@ static int __media_svc_copy_para_to_content(media_svc_content_info_s *content_in
 			media_svc_error("strcpy artist failed");
 	}
 
-	/*
-		if(STRING_VALID(content_info->media_meta.album_artist))
-		{
-			ret = __media_svc_malloc_and_strncpy(&new_content_info->media_meta.album_artist, content_info->media_meta.album_artist);
-			if(ret != MS_MEDIA_ERR_NONE)
-				media_svc_error("strcpy album_artist failed");
-		}
-	*/
+/*
+	if(STRING_VALID(content_info->media_meta.album_artist))
+	{
+		ret = __media_svc_malloc_and_strncpy(&new_content_info->media_meta.album_artist, content_info->media_meta.album_artist);
+		if(ret != MS_MEDIA_ERR_NONE)
+			media_svc_error("strcpy album_artist failed");
+	}
+*/
 
 	if (STRING_VALID(content_info->media_meta.genre)) {
 		ret = __media_svc_malloc_and_strncpy(&new_content_info->media_meta.genre, content_info->media_meta.genre);
@@ -1678,7 +1735,7 @@ int media_svc_insert_item_immediately_with_data(MediaSvcHandle *handle, media_sv
 	}
 
 	/* Insert to db - calling _media_svc_insert_item_with_data */
-	ret = _media_svc_insert_item_with_data(db_handle, &_new_content_info, FALSE, FALSE, uid);
+	ret = _media_svc_insert_item_with_data(db_handle, _new_content_info.storage_uuid, &_new_content_info, FALSE, FALSE, uid);
 
 	if (ret == MS_MEDIA_ERR_NONE) {
 		media_svc_debug("Insertion is successful.");
@@ -1699,9 +1756,47 @@ void media_svc_destroy_content_info(media_svc_content_info_s *content_info)
 	_media_svc_destroy_content_info(content_info);
 }
 
-char *media_info_generate_uuid(void)
+int media_svc_generate_uuid(char **uuid)
+{
+	char *gen_uuid = NULL;
+	gen_uuid = _media_info_generate_uuid();
+	media_svc_retvm_if(gen_uuid == NULL, MS_MEDIA_ERR_INTERNAL, "Fail to generate uuid");
+
+	*uuid = strdup(gen_uuid);
+
+	return MS_MEDIA_ERR_NONE;
+}
+
+int media_svc_get_mmc_info(MediaSvcHandle *handle, char **storage_name, char **storage_path, int *validity, bool *info_exist)
+{
+	sqlite3 * db_handle = (sqlite3 *)handle;
+
+	media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
+
+	return _media_svc_get_mmc_info(db_handle, storage_name, storage_path, validity, info_exist);
+}
+
+int media_svc_check_storage(MediaSvcHandle *handle, const char *storage_id, const char *storage_name, char **storage_path, int *validity)
 {
-	return _media_info_generate_uuid();
+	sqlite3 * db_handle = (sqlite3 *)handle;
+
+	media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
+	media_svc_retvm_if(storage_id == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "storage_id is NULL");
+	media_svc_retvm_if(storage_path == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "storage_path is NULL");
+	media_svc_retvm_if(validity == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "validity is NULL");
+
+	return _media_svc_check_storage(db_handle, storage_id, storage_name, storage_path, validity);
+}
+
+int media_svc_update_storage(MediaSvcHandle *handle, const char *storage_id, const char *storage_path, uid_t uid)
+{
+	sqlite3 * db_handle = (sqlite3 *)handle;
+
+	media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
+	media_svc_retvm_if(storage_id == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "storage_id is NULL");
+	media_svc_retvm_if(storage_path == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "storage_path is NULL");
+
+	return _media_svc_update_storage_path(db_handle, storage_id, storage_path, uid);
 }
 
 int media_svc_insert_storage(MediaSvcHandle *handle, const char *storage_id, const char *storage_name, const char *storage_path, const char *storage_account, media_svc_storage_type_e storage_type, uid_t uid)
@@ -1712,14 +1807,15 @@ int media_svc_insert_storage(MediaSvcHandle *handle, const char *storage_id, con
 	media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 	media_svc_retvm_if(storage_id == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "storage_id is NULL");
 	media_svc_retvm_if(storage_path == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "storage_path is NULL");
+	media_svc_retvm_if(__media_svc_check_storage(storage_type, FALSE) != TRUE, MS_MEDIA_ERR_INVALID_PARAMETER, "Invalid storage_type");
 
 	ret = _media_svc_append_storage(db_handle, storage_id, storage_name, storage_path, storage_account, storage_type, uid);
 	media_svc_retvm_if(ret != MS_MEDIA_ERR_NONE, ret, "append storage failed : %d", ret);
 
-	ret = _media_svc_create_media_table_with_id(db_handle, storage_id, uid);
-	media_svc_retvm_if(ret != MS_MEDIA_ERR_NONE, ret, "create media table failed : %d", ret);
+	if(strcmp(storage_id, MEDIA_SVC_DB_TABLE_MEDIA)) {
+		ret = _media_svc_create_media_table_with_id(db_handle, storage_id, uid);
+		media_svc_retvm_if(ret != MS_MEDIA_ERR_NONE, ret, "create media table failed : %d", ret);
 
-	if (storage_type == MEDIA_SVC_STORAGE_CLOUD) {
 		ret = _media_svc_update_media_view(db_handle, uid);
 		media_svc_retvm_if(ret != MS_MEDIA_ERR_NONE, ret, "update media view failed : %d", ret);
 	}
@@ -1727,32 +1823,329 @@ int media_svc_insert_storage(MediaSvcHandle *handle, const char *storage_id, con
 	return ret;
 }
 
-int media_svc_delete_storage(MediaSvcHandle *handle, const char *storage_id, uid_t uid)
+int media_svc_delete_storage(MediaSvcHandle *handle, const char *storage_id, const char *storage_name, uid_t uid)
 {
 	int ret = MS_MEDIA_ERR_NONE;
 	sqlite3 *db_handle = (sqlite3 *)handle;
+	media_svc_storage_type_e storage_type;
 
 	media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
 	media_svc_retvm_if(storage_id == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "storage_id is NULL");
 
-	ret = _media_svc_delete_storage(db_handle, storage_id, uid);
+	ret = _media_svc_get_storage_type(db_handle, storage_id, &storage_type);
+	media_svc_retvm_if(ret != MS_MEDIA_ERR_NONE, ret, "_media_svc_get_storage_type_by_path failed : %d", ret);
+
+	ret = _media_svc_delete_storage(db_handle, storage_id, storage_name, uid);
 	media_svc_retvm_if(ret != MS_MEDIA_ERR_NONE, ret, "remove storage failed : %d", ret);
 
-	ret = _media_svc_drop_media_table(db_handle, storage_id, uid);
-	media_svc_retvm_if(ret != MS_MEDIA_ERR_NONE, ret, "drop table failed : %d", ret);
+	ret = _media_svc_delete_folder_by_storage_id(db_handle, storage_id, storage_type, uid);
+	if (ret != MS_MEDIA_ERR_NONE) {
+		media_svc_error("fail to _media_svc_delete_folder_by_storage_id. error : [%d]", ret);
+	}
 
-	ret = _media_svc_update_media_view(db_handle, uid);
-	media_svc_retvm_if(ret != MS_MEDIA_ERR_NONE, ret, "update media view failed : %d", ret);
+	if (storage_type == MEDIA_SVC_STORAGE_EXTERNAL_USB) {
+		ret = _media_svc_drop_media_table(db_handle, storage_id, uid);
+		media_svc_retvm_if(ret != MS_MEDIA_ERR_NONE, ret, "drop table failed : %d", ret);
+
+		ret = _media_svc_update_media_view(db_handle, uid);
+		media_svc_retvm_if(ret != MS_MEDIA_ERR_NONE, ret, "update media view failed : %d", ret);
+	}
 
 	return ret;
 }
 
-int media_svc_request_extract_all_thumbs(uid_t uid)
+int media_svc_insert_folder_begin(MediaSvcHandle *handle, int data_cnt)
+{
+	sqlite3 * db_handle = (sqlite3 *)handle;
+
+	media_svc_debug("Transaction data count : [%d]", data_cnt);
+
+	media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
+	media_svc_retvm_if(data_cnt < 1, MS_MEDIA_ERR_INVALID_PARAMETER, "data_cnt shuld be bigger than 1");
+
+	g_media_svc_insert_folder_data_cnt = data_cnt;
+	g_media_svc_insert_folder_cur_data_cnt  = 0;
+
+	return MS_MEDIA_ERR_NONE;
+}
+
+int media_svc_insert_folder_end(MediaSvcHandle *handle, uid_t uid)
 {
 	int ret = MS_MEDIA_ERR_NONE;
+	sqlite3 * db_handle = (sqlite3 *)handle;
+
+	media_svc_debug_fenter();
 
-	ret =  _media_svc_request_extract_all_thumbs(uid);
-	media_svc_retvm_if(ret != MS_MEDIA_ERR_NONE, ret, "_media_svc_request_extract_all_thumbs failed : %d", ret);
+	media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
+
+	if (g_media_svc_insert_folder_cur_data_cnt  > 0) {
+
+		ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_INSERT_FOLDER, uid);
+	}
+
+	g_media_svc_insert_folder_data_cnt  = 1;
+	g_media_svc_insert_folder_cur_data_cnt  = 0;
 
 	return ret;
 }
+
+int media_svc_insert_folder(MediaSvcHandle *handle, const char *storage_id, media_svc_storage_type_e storage_type, const char *path, uid_t uid)
+{
+	int ret = MS_MEDIA_ERR_NONE;
+	sqlite3 * db_handle = (sqlite3 *)handle;
+	char folder_uuid[MEDIA_SVC_UUID_SIZE+1] = {0,};
+
+	media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
+	media_svc_retvm_if(!STRING_VALID(storage_id), MS_MEDIA_ERR_INVALID_PARAMETER, "storage_id is NULL");
+	media_svc_retvm_if(!STRING_VALID(path), MS_MEDIA_ERR_INVALID_PARAMETER, "path is NULL");
+	media_svc_retvm_if(__media_svc_check_storage(storage_type, FALSE) != TRUE, MS_MEDIA_ERR_INVALID_PARAMETER, "Invalid storage_type");
+
+	if (g_media_svc_insert_folder_data_cnt  == 1) {
+
+		ret = _media_svc_get_and_append_folder_id_by_folder_path(handle, storage_id, path, storage_type, folder_uuid, FALSE, uid);
+
+	} else if (g_media_svc_insert_folder_cur_data_cnt  < (g_media_svc_insert_folder_data_cnt  - 1)) {
+
+		ret = _media_svc_get_and_append_folder_id_by_folder_path(handle, storage_id, path, storage_type, folder_uuid, TRUE, uid);
+		media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
+
+		g_media_svc_insert_folder_cur_data_cnt ++;
+
+	} else if (g_media_svc_insert_folder_cur_data_cnt  == (g_media_svc_insert_folder_data_cnt  - 1)) {
+
+		ret = _media_svc_get_and_append_folder_id_by_folder_path(handle, storage_id, path, storage_type, folder_uuid, TRUE, uid);
+		media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
+
+		ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_INSERT_FOLDER, uid);
+		media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
+
+		g_media_svc_insert_folder_cur_data_cnt  = 0;
+
+	} else {
+		media_svc_error("Error in media_svc_set_insert_folder");
+		return MS_MEDIA_ERR_INTERNAL;
+	}
+
+	return ret;
+}
+
+int media_svc_delete_invalid_folder(MediaSvcHandle *handle, const char *storage_id, uid_t uid)
+{
+	int ret = MS_MEDIA_ERR_NONE;
+	sqlite3 * db_handle = (sqlite3 *)handle;
+
+	media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
+
+	ret = _media_svc_delete_invalid_folder(db_handle, storage_id, uid);
+
+	return ret;
+}
+
+int media_svc_set_folder_validity(MediaSvcHandle *handle, const char *storage_id, const char *start_path, int validity, bool is_recursive, uid_t uid)
+{
+	int ret = MS_MEDIA_ERR_NONE;
+	sqlite3 * db_handle = (sqlite3 *)handle;
+
+	media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
+
+	ret = _media_svc_set_folder_validity(db_handle, storage_id, start_path, validity, is_recursive, uid);
+
+	return ret;
+}
+
+int media_svc_insert_item_pass1(MediaSvcHandle *handle, const char *storage_id, media_svc_storage_type_e storage_type, const char *path, int is_burst, uid_t uid)
+{
+	int ret = MS_MEDIA_ERR_NONE;
+	sqlite3 * db_handle = (sqlite3 *)handle;
+	char folder_uuid[MEDIA_SVC_UUID_SIZE+1] = {0,};
+	media_svc_media_type_e media_type;
+
+	media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
+	media_svc_retvm_if(!STRING_VALID(storage_id), MS_MEDIA_ERR_INVALID_PARAMETER, "storage_id is NULL");
+	media_svc_retvm_if(!STRING_VALID(path), MS_MEDIA_ERR_INVALID_PARAMETER, "path is NULL");
+	media_svc_retvm_if(__media_svc_check_storage(storage_type, FALSE) != TRUE, MS_MEDIA_ERR_INVALID_PARAMETER, "Invalid storage_type");
+
+	media_svc_content_info_s content_info;
+	memset(&content_info, 0, sizeof(media_svc_content_info_s));
+
+	/*Set basic media info*/
+	ret = _media_svc_set_media_info(&content_info, storage_id, storage_type, path, &media_type, FALSE);
+	if (ret != MS_MEDIA_ERR_NONE) {
+		media_svc_error("_media_svc_set_media_info fail %d", ret);
+		return ret;
+	}
+
+	//media_svc_debug("total %d, cur %d insert flag %d", g_media_svc_insert_item_data_cnt, 	g_media_svc_insert_item_cur_data_cnt, g_insert_with_noti);
+
+	/*Set or Get folder id*/
+	ret = _media_svc_get_and_append_folder_id_by_path(db_handle, storage_id, path, storage_type, folder_uuid, uid);
+	media_svc_retv_del_if(ret != MS_MEDIA_ERR_NONE, ret, &content_info);
+
+	ret = __media_svc_malloc_and_strncpy(&content_info.folder_uuid, folder_uuid);
+	media_svc_retv_del_if(ret != MS_MEDIA_ERR_NONE, ret, &content_info);
+
+	if (g_media_svc_insert_item_data_cnt == 1) {
+
+		ret = _media_svc_insert_item_pass1(db_handle, storage_id, &content_info, is_burst, FALSE, uid);
+		media_svc_retv_del_if(ret != MS_MEDIA_ERR_NONE, ret, &content_info);
+
+		if (g_insert_with_noti)
+		{
+			_media_svc_insert_item_to_noti_list(&content_info, g_media_svc_insert_item_cur_data_cnt++);
+		}
+	} else if(g_media_svc_insert_item_cur_data_cnt  < (g_media_svc_insert_item_data_cnt  - 1)) {
+
+		ret = _media_svc_insert_item_pass1(db_handle, storage_id, &content_info, is_burst, TRUE, uid);
+		media_svc_retv_del_if(ret != MS_MEDIA_ERR_NONE, ret, &content_info);
+
+		if (g_insert_with_noti)
+		{
+			_media_svc_insert_item_to_noti_list(&content_info, g_media_svc_insert_item_cur_data_cnt);
+		}
+		media_svc_debug("g_media_svc_insert_item_cur_data_cnt %d", g_media_svc_insert_item_cur_data_cnt);
+		g_media_svc_insert_item_cur_data_cnt ++;
+
+	} else if (g_media_svc_insert_item_cur_data_cnt  == (g_media_svc_insert_item_data_cnt  - 1)) {
+
+		ret = _media_svc_insert_item_pass1(db_handle, storage_id, &content_info, is_burst, TRUE, uid);
+		media_svc_retv_del_if(ret != MS_MEDIA_ERR_NONE, ret, &content_info);
+
+		if (g_insert_with_noti)
+			_media_svc_insert_item_to_noti_list(&content_info, g_media_svc_insert_item_cur_data_cnt);
+
+		ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_INSERT_ITEM, uid);
+		media_svc_retv_del_if(ret != MS_MEDIA_ERR_NONE, ret, &content_info);
+
+		media_svc_debug("_media_svc_list_query_do over");
+
+		if (g_insert_with_noti) {
+			media_svc_debug("publish noti list %d", g_media_svc_insert_item_cur_data_cnt);
+			_media_svc_publish_noti_list(g_media_svc_insert_item_cur_data_cnt + 1);
+			_media_svc_destroy_noti_list(g_media_svc_insert_item_cur_data_cnt + 1);
+
+			/* Recreate noti list */
+			ret = _media_svc_create_noti_list(g_media_svc_insert_item_data_cnt);
+			media_svc_retv_del_if(ret != MS_MEDIA_ERR_NONE, ret, &content_info);
+		}
+
+		g_media_svc_insert_item_cur_data_cnt = 0;
+
+	} else {
+		media_svc_error("Error in media_svc_insert_item_pass1");
+		_media_svc_destroy_content_info(&content_info);
+		return MS_MEDIA_ERR_INTERNAL;
+	}
+
+	_media_svc_destroy_content_info(&content_info);
+
+	return MS_MEDIA_ERR_NONE;
+}
+
+int media_svc_insert_item_pass2(MediaSvcHandle *handle, const char *storage_id, media_svc_storage_type_e storage_type, int scan_type, const char *extract_path, int is_burst, uid_t uid)
+{
+	int ret = MS_MEDIA_ERR_NONE;
+	sqlite3 * db_handle = (sqlite3 *)handle;
+	sqlite3_stmt *sql_stmt = NULL;
+	media_svc_media_type_e media_type;
+	media_svc_content_info_s content_info;
+	GArray *db_data_array = NULL;
+	media_svc_item_info_s *db_data = NULL;
+	int idx = 0;
+	char *sql = NULL;
+
+	media_svc_debug_fenter();
+
+	media_svc_retvm_if(db_handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "Handle is NULL");
+	media_svc_retvm_if(!STRING_VALID(storage_id), MS_MEDIA_ERR_INVALID_PARAMETER, "storage_id is NULL");
+	media_svc_retvm_if(__media_svc_check_storage(storage_type, FALSE) != TRUE, MS_MEDIA_ERR_INVALID_PARAMETER, "Invalid storage_type");
+
+	if (scan_type == MS_MSG_DIRECTORY_SCANNING) {
+		sql = sqlite3_mprintf("SELECT path, media_type FROM '%s' WHERE validity = 1 AND title IS NULL AND path LIKE '%q/%%'", storage_id, extract_path);
+	} else if (scan_type == MS_MSG_DIRECTORY_SCANNING_NON_RECURSIVE) {
+		char folder_uuid[MEDIA_SVC_UUID_SIZE+1] = {0, };
+		ret = _media_svc_get_folder_id_by_foldername(handle, storage_id, extract_path, folder_uuid, uid);
+		media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
+
+		sql = sqlite3_mprintf("SELECT path, media_type FROM '%s' WHERE validity = 1 AND title IS NULL AND folder_uuid = '%q'", storage_id, folder_uuid);
+	} else { /*Storage Scanning*/
+		sql = sqlite3_mprintf("SELECT path, media_type FROM '%s' WHERE validity = 1 AND title IS NULL", storage_id);
+	}
+
+	ret = _media_svc_sql_prepare_to_step_simple(handle, sql, &sql_stmt);
+	if (ret != MS_MEDIA_ERR_NONE) {
+		media_svc_error("error when get list. err = [%d]", ret);
+		return ret;
+	}
+
+	db_data_array = g_array_new(FALSE, FALSE, sizeof(media_svc_item_info_s*));
+	if (db_data_array == NULL) {
+		media_svc_error("db_data_array is NULL. Out of memory");
+		return MS_MEDIA_ERR_OUT_OF_MEMORY;
+	}
+
+	while (sqlite3_step(sql_stmt) == SQLITE_ROW) {
+		db_data = NULL;
+		db_data = malloc(sizeof(media_svc_item_info_s));
+		if(db_data == NULL) {
+			media_svc_error("Out of memory");
+			continue;
+		}
+
+		if(STRING_VALID((const char *)sqlite3_column_text(sql_stmt, 0)))
+			db_data->path = strdup((const char *)sqlite3_column_text(sql_stmt, 0));
+
+		db_data->media_type = (int)sqlite3_column_int(sql_stmt,1);
+
+		g_array_append_val(db_data_array, db_data);
+	}
+
+	SQLITE3_FINALIZE(sql_stmt);
+
+	while (db_data_array->len != 0) {
+		db_data = NULL;
+		db_data = g_array_index(db_data_array, media_svc_item_info_s*, 0);
+		g_array_remove_index (db_data_array, 0);
+
+		if ((db_data == NULL) ||(db_data->path == NULL)) {
+			media_svc_error("invalid db data");
+			continue;
+		}
+
+		media_type = db_data->media_type;
+		media_svc_debug("path is %s, media type %d", db_data->path, media_type);
+		memset(&content_info, 0, sizeof(media_svc_content_info_s));
+		__media_svc_malloc_and_strncpy(&content_info.path, db_data->path);
+
+		content_info.media_type = media_type;
+		content_info.storage_type = storage_type;
+
+		_media_svc_set_default_value(&content_info, FALSE);
+
+		if (media_type == MEDIA_SVC_MEDIA_TYPE_OTHER) {
+			/*Do nothing.*/
+		} else if (media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) {
+			ret = _media_svc_extract_image_metadata(db_handle, &content_info);
+		} else {
+			ret = _media_svc_extract_media_metadata(db_handle, &content_info, uid);
+		}
+
+		ret = _media_svc_insert_item_pass2(db_handle, storage_id, &content_info, is_burst, TRUE, uid);
+
+		_media_svc_destroy_content_info(&content_info);
+		SAFE_FREE(db_data->path);
+		SAFE_FREE(db_data);
+		idx++;
+	}
+
+	if (idx > 0)
+	{
+		ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_UPDATE_ITEM, uid);
+	}
+
+	g_array_free(db_data_array, FALSE);
+	db_data_array = NULL;
+
+	media_svc_debug_fleave();
+
+	return MS_MEDIA_ERR_NONE;
+}
diff --git a/src/include/common/media-svc-db-utils.h b/src/include/common/media-svc-db-utils.h
index bdb72ed..027d869 100755
--- a/src/include/common/media-svc-db-utils.h
+++ b/src/include/common/media-svc-db-utils.h
@@ -29,8 +29,8 @@
 #define SQLITE3_FINALIZE(x)       if(x  != NULL) {sqlite3_finalize(x);}
 
 int _media_svc_make_table_query(sqlite3 *db_handle, const char *table_name, media_svc_table_slist_e list, uid_t uid);
-int _media_svc_upgrade_table_query(sqlite3 *db_handle, char *table_name, media_svc_table_slist_e list, uid_t uid);
-int _media_svc_init_table_query();
+int _media_svc_upgrade_table_query(sqlite3 *db_handle, const char *table_name, media_svc_table_slist_e list, uid_t uid);
+int _media_svc_init_table_query(const char *event_table_name);
 void _media_svc_destroy_table_query();
 int _media_svc_create_media_table_with_id(sqlite3 *db_handle, const char *table_id, uid_t uid);
 int _media_svc_drop_media_table(sqlite3 *handle, const char *storage_id, uid_t uid);
@@ -44,7 +44,7 @@ int _media_svc_sql_rollback_trans(sqlite3 *handle, uid_t uid);
 int _media_svc_sql_query_list(sqlite3 *handle, GList **query_list, uid_t uid);
 void _media_svc_sql_query_add(GList **query_list, char **query);
 void _media_svc_sql_query_release(GList **query_list);
-int _media_svc_check_db_upgrade(sqlite3 *db_handle, uid_t uid);
+int _media_svc_check_db_upgrade(sqlite3 *db_handle, bool *need_full_scan, uid_t uid);
 int _media_db_check_corrupt(sqlite3 *db_handle);
 char *_media_svc_get_path(uid_t uid);
 
diff --git a/src/include/common/media-svc-debug.h b/src/include/common/media-svc-debug.h
index 1f03147..964e612 100755
--- a/src/include/common/media-svc-debug.h
+++ b/src/include/common/media-svc-debug.h
@@ -35,69 +35,82 @@
 
 #define LOG_TAG "MEDIA_SERVICE"
 
+#define FONT_COLOR_RESET    "\033[0m"
+#define FONT_COLOR_RED      "\033[31m"
+#define FONT_COLOR_GREEN    "\033[32m"
+#define FONT_COLOR_YELLOW   "\033[33m"
+#define FONT_COLOR_BLUE     "\033[34m"
+#define FONT_COLOR_PURPLE   "\033[35m"
+#define FONT_COLOR_CYAN     "\033[36m"
+#define FONT_COLOR_GRAY     "\033[37m"
+
 #define media_svc_debug(fmt, arg...) do { \
-		LOGD(" "fmt"", ##arg);     \
-	} while (0)
+			LOGD(FONT_COLOR_RESET" "fmt"", ##arg);     \
+		} while (0)
 
 #define media_svc_error(fmt, arg...) do { \
-		LOGE(" "fmt"", ##arg);     \
-	} while (0)
+			LOGE(FONT_COLOR_RED" "fmt"", ##arg);     \
+		} while (0)
+
+#define media_svc_debug_fenter() do { \
+			LOGD(FONT_COLOR_RESET"<ENTER>");     \
+		} while (0)
 
-#define media_svc_debug_func() do { \
-		LOGD("");     \
-	} while (0)
+#define media_svc_debug_fleave() do { \
+			LOGD(FONT_COLOR_RESET"<LEAVE>");     \
+		} while (0)
 
 #define media_svc_retm_if(expr, fmt, arg...) do { \
-		if(expr) { \
-			LOGE(" "fmt"", ##arg);   \
-			return; \
-		} \
-	} while (0)
+			if(expr) { \
+				LOGE(FONT_COLOR_RED" "fmt"", ##arg);   \
+				return; \
+			} \
+		} while (0)
 #define media_svc_retv_if(expr, val) do { \
-		if(expr) { \
-			LOGE("");     \
-			return (val); \
-		} \
-	} while (0)
+			if(expr) { \
+				LOGE(FONT_COLOR_RED"");     \
+				return (val); \
+			} \
+		} while (0)
 #define media_svc_retvm_if(expr, val, fmt, arg...) do { \
-		if(expr) { \
-			LOGE(" "fmt"", ##arg); 	\
-			return (val); \
-		} \
-	} while (0)
+			if(expr) { \
+				LOGE(FONT_COLOR_RED" "fmt"", ##arg); 	\
+				return (val); \
+			} \
+		} while (0)
 
 #define media_svc_retv_del_if(expr, val, p_str) do { \
-		if(expr) { \
-			LOGE("");     \
-			_media_svc_destroy_content_info(p_str);        \
-			return (val); \
-		} \
-	} while (0)
+			if(expr) { \
+				LOGE(FONT_COLOR_RED"");     \
+				_media_svc_destroy_content_info(p_str);        \
+				return (val); \
+			} \
+		} while (0)
 
 #define media_svc_sec_debug(fmt, arg...) do { \
-		SECURE_LOGI(" "fmt"", ##arg);	 \
-	} while (0)
+			SECURE_LOGI(FONT_COLOR_RESET" "fmt"", ##arg);	 \
+		} while (0)
 
 #define media_svc_sec_warn(fmt, arg...) do { \
-		SECURE_LOGW(" "fmt"", ##arg); 	\
-	} while (0)
+			SECURE_LOGW(FONT_COLOR_GREEN" "fmt"", ##arg); 	\
+		} while (0)
 
 #define media_svct_sec_error(fmt, arg...) do { \
-		SECURE_LOGE(" "fmt"", ##arg);	  \
-	} while (0)
+			SECURE_LOGE(FONT_COLOR_RED" "fmt"", ##arg);	  \
+		} while (0)
 
 #define ERR_BUF_LENGHT 256
 #define media_svc_stderror(fmt) do { \
-		char buf[ERR_BUF_LENGHT] = {0, }; \
-		strerror_r(errno, buf, ERR_BUF_LENGHT); \
-		LOGE(fmt" : standard error= [%s]", buf); \
-	} while (0)
+			char media_svc_stderror_buf[ERR_BUF_LENGHT] = {0,}; \
+			strerror_r(errno, media_svc_stderror_buf, ERR_BUF_LENGHT); \
+			LOGE(FONT_COLOR_RED""fmt" : standard error= [%s]", media_svc_stderror_buf); \
+		} while (0)
 
 #ifdef _USE_LOG_FILE_
 void mediainfo_init_file_debug();
 void mediainfo_close_file_debug();
-FILE *get_fp();
-#define mediainfo_file_dbg(fmt, arg...)      fprintf( get_fp(), "[%s: %d] [%s]" fmt "\n", __FILE__, __LINE__, __FUNCTION__, ##arg)
+FILE* get_fp();
+#define mediainfo_file_dbg(fmt,arg...)      fprintf( get_fp(), "[%s: %d] [%s]" fmt "\n", __FILE__, __LINE__, __FUNCTION__, ##arg)
 
 #endif
 
diff --git a/src/include/common/media-svc-env.h b/src/include/common/media-svc-env.h
index 63e3dc6..a58abcd 100755
--- a/src/include/common/media-svc-env.h
+++ b/src/include/common/media-svc-env.h
@@ -36,8 +36,15 @@ extern "C" {
  * DB information
  */
 
-#define MEDIA_SVC_DB_NAME 						MEDIA_DB_NAME		/**<  media db name*/
-#define LATEST_VERSION_NUMBER					2
+#define LATEST_VERSION_NUMBER					4
+
+/**
+ * Notice : New table user version -1 : alter table issue
+ */
+#define USER_V1									1
+#define USER_V2									2
+#define USER_V3									3
+#define USER_V4									4
 
 /**
  * DB table information
@@ -51,11 +58,11 @@ extern "C" {
 #define MEDIA_SVC_DB_TABLE_PLAYLIST				"playlist"			/**<  playlist table*/
 #define MEDIA_SVC_DB_TABLE_PLAYLIST_MAP			"playlist_map"		/**<  playlist_map table*/
 #define MEDIA_SVC_DB_TABLE_ALBUM				"album"				/**<  album table*/
-#define MEDIA_SVC_DB_TABLE_TAG					"tag"			/**<  tag table*/
-#define MEDIA_SVC_DB_TABLE_TAG_MAP				"tag_map"		/**<  tag_map table*/
-#define MEDIA_SVC_DB_TABLE_BOOKMARK				"bookmark"		/**<  bookmark table*/
-#define MEDIA_SVC_DB_TABLE_CUSTOM				"custom"			/**<  custom table*/
+#define MEDIA_SVC_DB_TABLE_TAG					"tag"				/**<  tag table*/
+#define MEDIA_SVC_DB_TABLE_TAG_MAP				"tag_map"			/**<  tag_map table*/
+#define MEDIA_SVC_DB_TABLE_BOOKMARK				"bookmark"			/**<  bookmark table*/
 #define MEDIA_SVC_DB_TABLE_STORAGE				"storage"			/**<  storage table*/
+#define MEDIA_SVC_DB_TABLE_TMP_TABLE				"tmp"			/**<  tmp table for backup*/
 #define MEDIA_SVC_DB_TABLE_FACE					"face"			/**<  face table*/
 #define MEDIA_SVC_DB_TABLE_FACE_SCAN_LIST			"face_scan_list"	/**<  face_scan_list table*/
 
@@ -77,7 +84,6 @@ extern "C" {
 #define MEDIA_SVC_DB_TRIGGER_TAG_MAP1			"tag_map_cleanup_1"		/**<  tag to map*/
 #define MEDIA_SVC_DB_TRIGGER_BOOKMARK			"bookmark_cleanup"
 #define MEDIA_SVC_DB_TRIGGER_STORAGE			"storage_folder_cleanup"
-#define MEDIA_SVC_DB_TRIGGER_CUSTOM			"custom_cleanup"
 #define MEDIA_SVC_DB_TRIGGER_FACE_SCAN_LIST	"face_scan_list_cleanup"
 #define MEDIA_SVC_DB_TRIGGER_FACE				"face_cleanup"
 
@@ -102,17 +108,17 @@ extern "C" {
 #define MEDIA_SVC_DB_QUERY_TABLE_WITH_UNIQUE	"CREATE TABLE IF NOT EXISTS '%s' (%s, unique(%s));"
 #define MEDIA_SVC_DB_QUERY_TABLE				"CREATE TABLE IF NOT EXISTS '%s' (%s);"
 #define MEDIA_SVC_DB_QUERY_INDEX				"CREATE INDEX IF NOT EXISTS %s on '%s' (%s);"
-#define MEDIA_SVC_DB_QUERY_TRIGGER				"CREATE TRIGGER IF NOT EXISTS %s DELETE ON %s BEGIN DELETE FROM %s WHERE %s=old.%s;END;"
-#define MEDIA_SVC_DB_QUERY_TRIGGER_WITH_COUNT	"CREATE TRIGGER IF NOT EXISTS %s DELETE ON %s BEGIN DELETE FROM %s WHERE (SELECT count(*) FROM %s WHERE %s=old.%s)=1 AND %s=old.%s;END;"
+#define MEDIA_SVC_DB_QUERY_TRIGGER				"CREATE TRIGGER IF NOT EXISTS '%s' DELETE ON '%s' BEGIN DELETE FROM %s WHERE %s=old.%s;END;"
+#define MEDIA_SVC_DB_QUERY_TRIGGER_WITH_COUNT	"CREATE TRIGGER IF NOT EXISTS '%s' DELETE ON '%s' BEGIN DELETE FROM %s WHERE (SELECT count(*) FROM '%s' WHERE %s=old.%s)=1 AND %s=old.%s;END;"
 #define MEDIA_SVC_DB_QUERY_VIEW_MEDIA			"CREATE VIEW IF NOT EXISTS %s AS SELECT * from %s;"
 #define MEDIA_SVC_DB_QUERY_VIEW_PLAYLIST		"CREATE VIEW IF NOT EXISTS %s AS SELECT %s FROM playlist \
 												LEFT OUTER JOIN playlist_map ON playlist.playlist_id = playlist_map.playlist_id \
 												LEFT OUTER JOIN media ON (playlist_map.media_uuid = media.media_uuid AND media.validity=1) \
-LEFT OUTER JOIN (SELECT count(playlist_id) as media_count, playlist_id FROM playlist_map group by playlist_id) as cnt_tbl ON (cnt_tbl.playlist_id=playlist_map.playlist_id AND media.validity=1);"
+												LEFT OUTER JOIN (SELECT count(playlist_id) as media_count, playlist_id FROM playlist_map group by playlist_id) as cnt_tbl ON (cnt_tbl.playlist_id=playlist_map.playlist_id AND media.validity=1);"
 #define MEDIA_SVC_DB_QUERY_VIEW_TAG				"CREATE VIEW IF NOT EXISTS %s AS SELECT %s FROM tag \
 												LEFT OUTER JOIN tag_map ON tag.tag_id=tag_map.tag_id \
 												LEFT OUTER JOIN media ON (tag_map.media_uuid = media.media_uuid AND media.validity=1) \
-LEFT OUTER JOIN (SELECT count(tag_id) as media_count, tag_id FROM tag_map group by tag_id) as cnt_tbl ON (cnt_tbl.tag_id=tag_map.tag_id AND media.validity=1);"
+												LEFT OUTER JOIN (SELECT count(tag_id) as media_count, tag_id FROM tag_map group by tag_id) as cnt_tbl ON (cnt_tbl.tag_id=tag_map.tag_id AND media.validity=1);"
 #define MEDIA_SVC_DB_QUERY_ALTER_TABLE			"ALTER TABLE %s ADD COLUMN %s;"
 #define MEDIA_SVC_DB_QUERY_DROP_VIEW			"DROP VIEW IF EXISTS %s;"
 
@@ -149,23 +155,23 @@ typedef enum {
 	MEDIA_SVC_QUERY_INSERT_ITEM,
 	MEDIA_SVC_QUERY_SET_ITEM_VALIDITY,
 	MEDIA_SVC_QUERY_MOVE_ITEM,
-	MEDIA_SVC_QUERY_UPDATE_ITEM
+	MEDIA_SVC_QUERY_UPDATE_ITEM,
+	MEDIA_SVC_QUERY_INSERT_FOLDER
 } media_svc_query_type_e;
 
 typedef enum {
 	MEDIA_SVC_DB_LIST_MEDIA 		= 0,
-	MEDIA_SVC_DB_LIST_FOLDER 		= 1,
-	MEDIA_SVC_DB_LIST_PLAYLIST_MAP = 2,
-	MEDIA_SVC_DB_LIST_PLAYLIST 	= 3,
-	MEDIA_SVC_DB_LIST_ALBUM		= 4,
-	MEDIA_SVC_DB_LIST_TAG_MAP	= 5,
-	MEDIA_SVC_DB_LIST_TAG 			= 6,
-	MEDIA_SVC_DB_LIST_BOOKMARK 	= 7,
-	MEDIA_SVC_DB_LIST_STORAGE 	= 8,
-	MEDIA_SVC_DB_LIST_FACE_SCAN_LIST	= 9,
-	MEDIA_SVC_DB_LIST_FACE			= 10,
-	MEDIA_SVC_DB_LIST_CUSTOM,
-	MEDIA_SVC_DB_LIST_MAX	,
+	MEDIA_SVC_DB_LIST_FOLDER,
+	MEDIA_SVC_DB_LIST_PLAYLIST_MAP,
+	MEDIA_SVC_DB_LIST_PLAYLIST,
+	MEDIA_SVC_DB_LIST_ALBUM,
+	MEDIA_SVC_DB_LIST_TAG_MAP,
+	MEDIA_SVC_DB_LIST_TAG,
+	MEDIA_SVC_DB_LIST_BOOKMARK,
+	MEDIA_SVC_DB_LIST_STORAGE,
+	MEDIA_SVC_DB_LIST_FACE_SCAN_LIST,
+	MEDIA_SVC_DB_LIST_FACE,
+	MEDIA_SVC_DB_LIST_MAX,
 } media_svc_table_slist_e;
 
 typedef struct table_inform {
diff --git a/src/include/common/media-svc-media-folder.h b/src/include/common/media-svc-media-folder.h
index 9e2b85a..f092a8a 100755
--- a/src/include/common/media-svc-media-folder.h
+++ b/src/include/common/media-svc-media-folder.h
@@ -26,13 +26,16 @@
 #include <stdbool.h>
 #include "media-svc-types.h"
 
-int _media_svc_get_folder_id_by_foldername(sqlite3 *handle, const char *storage_id, const char *folder_name, char *folder_id);
-int _media_svc_append_folder(sqlite3 *handle, const char *storage_id, media_svc_storage_type_e storage_type, const char *folder_id, const char *path_name, const char *folder_name, int modified_date, const char *parent_folder_uuid, uid_t uid);
+int _media_svc_get_folder_id_by_foldername(sqlite3 *handle, const char *storage_id, const char *folder_name, char *folder_id, uid_t uid);
 int _media_svc_update_folder_modified_time_by_folder_uuid(sqlite3 *handle, const char *folder_uuid, const char *folder_path, bool stack_query, uid_t uid);
 int _media_svc_get_and_append_folder(sqlite3 *handle, const char *storage_id, const char *path, media_svc_storage_type_e storage_type, char *folder_id, uid_t uid);
 int _media_svc_get_and_append_folder_id_by_path(sqlite3 *handle, const char *storage_id, const char *path, media_svc_storage_type_e storage_type, char *folder_id, uid_t uid);
-int _media_svc_update_folder_table(sqlite3 *handle, uid_t uid);
+int _media_svc_update_folder_table(sqlite3 *handle, const char *storage_id, uid_t uid);
 int _media_svc_get_all_folders(sqlite3 *handle, char *start_path, char ***folder_list, time_t **modified_time_list, int **item_num_list, int *count);
+int _media_svc_get_and_append_folder_id_by_folder_path(sqlite3 *handle, const char *storage_id, const char *path, media_svc_storage_type_e storage_type, char *folder_id, bool stack_query, uid_t uid);
 int _media_svc_get_folder_info_by_foldername(sqlite3 *handle, const char *folder_name, char *folder_id, time_t *modified_time);
-
+int _media_svc_delete_invalid_folder(sqlite3 *handle, const char *storage_id, uid_t uid);
+int _media_svc_set_folder_validity(sqlite3 *handle, const char *storage_id, const char *start_path, int validity, bool is_recursive, uid_t uid);
+int _media_svc_delete_folder_by_storage_id(sqlite3 *handle, const char *storage_id, media_svc_storage_type_e storage_type, uid_t uid);
+GList ** _media_svc_get_folder_list_ptr(void);
 #endif /*_MEDIA_SVC_MEDIA_FOLDER_H_*/
diff --git a/src/include/common/media-svc-media.h b/src/include/common/media-svc-media.h
index 28c8e69..5358524 100755
--- a/src/include/common/media-svc-media.h
+++ b/src/include/common/media-svc-media.h
@@ -28,28 +28,31 @@
 #include "media-svc-env.h"
 #include "media-svc-noti.h"
 
-int _media_svc_count_record_with_path(sqlite3 *handle, const char *path, int *count);
-int _media_svc_insert_item_with_data(sqlite3 *handle, media_svc_content_info_s *content_info, int is_burst, bool stack_query, uid_t uid);
+int _media_svc_count_record_with_path(sqlite3 *handle, const char *storage_id, const char *path, int *count);
+int _media_svc_insert_item_with_data(sqlite3 *handle, const char *storage_id, media_svc_content_info_s *content_info, int is_burst, bool stack_query, uid_t uid);
 int _media_svc_update_item_with_data(sqlite3 *handle, const char *storage_id, media_svc_content_info_s *content_info, uid_t uid);
 int _media_svc_get_thumbnail_path_by_path(sqlite3 *handle, const char *storage_id, const char *path, char *thumbnail_path);
 int _media_svc_get_media_type_by_path(sqlite3 *handle, const char *storage_id, const char *path, int *media_type);
-int _media_svc_get_burst_id(sqlite3 *handle, int *id);
+int _media_svc_get_burst_id(sqlite3 *handle, const char *storage_id, int *id);
 int _media_svc_delete_item_by_path(sqlite3 *handle, const char *storage_id, const char *path, bool stack_query, uid_t uid);
-int _media_svc_truncate_table(sqlite3 *handle, media_svc_storage_type_e storage_type, uid_t uid);
-int _media_svc_delete_invalid_items(sqlite3 *handle, media_svc_storage_type_e storage_type, uid_t uid);
-int _media_svc_delete_invalid_folder_items(sqlite3 *handle, const char *folder_path, uid_t uid);
-int _media_svc_update_storage_item_validity(sqlite3 *handle, media_svc_storage_type_e storage_type, int validity, uid_t uid);
-int _media_svc_update_folder_item_validity(sqlite3 *handle, const char *folder_path, int validity, uid_t uid);
-int _media_svc_update_recursive_folder_item_validity(sqlite3 *handle, const char *folder_path, int validity, uid_t uid);
-int _media_svc_update_item_validity(sqlite3 *handle, const char *path, int validity, bool stack_query, uid_t uid);
-int _media_svc_update_item_by_path(sqlite3 *handle, const char *src_path, media_svc_storage_type_e dest_storage, const char *dest_path, const char *file_name, int modified_time, const char *folder_uuid, const char *thumb_path, bool stack_query, uid_t uid);
+int _media_svc_truncate_table(sqlite3 *handle, const char *storage_id, media_svc_storage_type_e storage_type, uid_t uid);
+int _media_svc_delete_invalid_items(sqlite3 *handle, const char *storage_id, media_svc_storage_type_e storage_type, uid_t uid);
+int _media_svc_delete_invalid_folder_items(sqlite3 *handle, const char *storage_id, const char *folder_path, bool is_recursive, uid_t uid);
+int _media_svc_update_storage_item_validity(sqlite3 *handle, const char *storage_id, media_svc_storage_type_e storage_type, int validity, uid_t uid);
+int _media_svc_update_folder_item_validity(sqlite3 *handle, const char *storage_id, const char *folder_path, int validity, uid_t uid);
+int _media_svc_update_recursive_folder_item_validity(sqlite3 *handle, const char *storage_id, const char *folder_path, int validity, uid_t uid);
+int _media_svc_update_item_validity(sqlite3 *handle, const char *storage_id, const char *path, int validity, bool stack_query, uid_t uid);
+int _media_svc_update_item_by_path(sqlite3 *handle, const char *storage_id, const char *src_path, media_svc_storage_type_e dest_storage, const char *dest_path, const char *file_name, int modified_time, const char *folder_uuid, const char *thumb_path, bool stack_query, uid_t uid);
 int _media_svc_list_query_do(sqlite3 *handle, media_svc_query_type_e query_type, uid_t uid);
 int _media_svc_update_thumbnail_path(sqlite3 *handle, const char *storage_id, const char *path, const char *thumb_path, uid_t uid);
 int _media_svc_get_noti_info(sqlite3 *handle, const char *storage_id, const char *path, int update_item, media_svc_noti_item **item);
-int _media_svc_count_invalid_folder_items(sqlite3 *handle, const char *folder_path, int *count);
-int _media_svc_get_thumbnail_count(sqlite3 *handle, const char *thumb_path, int *count);
+int _media_svc_count_invalid_folder_items(sqlite3 *handle, const char *storage_id, const char *folder_path, int *count);
+int _media_svc_get_thumbnail_count(sqlite3 *handle, const char *storage_id, const char *thumb_path, int *count);
 char *_media_svc_get_thumb_default_path(uid_t uid);
-int _media_svc_get_fileinfo_by_path(sqlite3 *handle, const char *path, time_t *modified_time, unsigned long long *size);
+int _media_svc_get_fileinfo_by_path(sqlite3 *handle, const char *storage_id, const char *path, time_t *modified_time, unsigned long long *size);
 int _media_svc_update_meta_with_data(sqlite3 *handle, media_svc_content_info_s *content_info);
 
+int _media_svc_insert_item_pass1(sqlite3 *handle, const char *storage_id, media_svc_content_info_s *content_info, int is_burst, bool stack_query, uid_t uid);
+int _media_svc_insert_item_pass2(sqlite3 *handle, const char *storage_id, media_svc_content_info_s *content_info, int is_burst, bool stack_query, uid_t uid);
+
 #endif /*_MEDIA_SVC_MEDIA_H_*/
diff --git a/src/common/media-svc-storage.h b/src/include/common/media-svc-storage.h
index 3ad39e2..13ec6fb 100755
--- a/src/common/media-svc-storage.h
+++ b/src/include/common/media-svc-storage.h
@@ -25,8 +25,18 @@
 #include <sqlite3.h>
 
 int _media_svc_init_storage(sqlite3 *handle, uid_t uid);
+int _media_svc_get_mmc_info(MediaSvcHandle *handle, char **storage_name, char **storage_path, int *validity, bool *info_exist);
+int _media_svc_check_storage(sqlite3 *handle, const char *storage_id, const char *storage_name, char **storage_path, int *validity);
 int _media_svc_append_storage(sqlite3 *handle, const char *storage_id, const char *storage_name, const char *storage_path, const char *storage_account, media_svc_storage_type_e storage_type, uid_t uid);
-int _media_svc_delete_storage(sqlite3 *handle, const char *storage_id, uid_t uid);
+int _media_svc_update_storage_path(sqlite3 *handle, const char *storage_id, const char *path, uid_t uid);
+int _media_svc_delete_storage(sqlite3 *handle, const char *storage_id, const char *storage_name, uid_t uid);
 int _media_svc_update_storage_validity(sqlite3 *handle, const char *storage_id, int validity, uid_t uid);
+int _media_svc_get_storage_uuid(sqlite3 *handle, const char *path, char *storage_id);
+int _media_svc_get_storage_type(sqlite3 *handle, const char *storage_id, media_svc_storage_type_e *storage_type);
+int _media_svc_get_storage_path(sqlite3 *handle, const char *storage_id, char **storage_path);
+int _media_svc_get_storage_scan_status(sqlite3 *handle, const char*storage_id, media_svc_scan_status_type_e *scan_status);
+int _media_svc_set_storage_scan_status(sqlite3 *handle, const char*storage_id, media_svc_scan_status_type_e scan_status, uid_t uid);
+int _media_svc_get_all_storage(sqlite3 *handle, char ***storage_list, char ***storage_id_list, int **scan_status_list, int *count);
+
 
 #endif /*_MEDIA_SVC_STORAGE_H_*/
diff --git a/src/include/common/media-svc-util.h b/src/include/common/media-svc-util.h
index 15a12c1..241e0df 100755
--- a/src/include/common/media-svc-util.h
+++ b/src/include/common/media-svc-util.h
@@ -52,14 +52,15 @@ int _media_svc_remove_file(const char *path);
 int _media_svc_remove_all_files_in_dir(const char *dir_path);
 int _media_svc_get_thumbnail_path(media_svc_storage_type_e storage_type, char *thumb_path, const char *pathname, const char *img_format, uid_t uid);
 int _media_svc_get_file_time(const char *full_path);
+int _media_svc_set_default_value(media_svc_content_info_s *content_info, bool refresh);
 int _media_svc_set_media_info(media_svc_content_info_s *content_info, const char *storage_id, media_svc_storage_type_e storage_type,
-                              const char *path, media_svc_media_type_e *media_type, bool refresh);
-int _media_svc_extract_image_metadata(sqlite3 *handle, media_svc_content_info_s *content_info, media_svc_media_type_e media_type, uid_t uid);
-int _media_svc_extract_media_metadata(sqlite3 *handle, media_svc_content_info_s *content_info, media_svc_media_type_e media_type, uid_t uid);
+			  const char *path, media_svc_media_type_e *media_type, bool refresh);
+int _media_svc_extract_image_metadata(sqlite3 *handle, media_svc_content_info_s *content_info);
+int _media_svc_extract_media_metadata(sqlite3 *handle, media_svc_content_info_s *content_info, uid_t uid);
 int __media_svc_malloc_and_strncpy(char **dst, const char *src);
 time_t __media_svc_get_timeline_from_str(const char *timstr);
 void _media_svc_destroy_content_info(media_svc_content_info_s *content_info);
-int _media_svc_get_store_type_by_path(const char *path, media_svc_storage_type_e *storage_type, uid_t uid);
+int _media_svc_get_storage_type_by_path(const char *path, media_svc_storage_type_e *storage_type, uid_t uid);
 char *_media_svc_replace_path(char *s, const char *olds, const char *news);
 char *_media_svc_get_thumb_internal_path(uid_t uid);
 char *_media_svc_get_thumb_external_path(uid_t uid);
@@ -68,7 +69,8 @@ int _media_svc_request_thumbnail_with_origin_size(const char *path, char *thumb_
 int _media_svc_get_pinyin_str(const char *src_str, char **pinyin_str);
 bool _media_svc_check_pinyin_support(void);
 int _media_svc_extract_music_metadata_for_update(sqlite3 *handle, media_svc_content_info_s *content_info, media_svc_media_type_e media_type);
-int _media_svc_request_extract_all_thumbs(uid_t uid);
+char *_media_svc_get_title_from_path(const char *path);
+void _media_svc_print_stderror(void);
 
 
 #ifdef __cplusplus
diff --git a/test/plugin/media_svc_plugin_test.c b/test/plugin/media_svc_plugin_test.c
index e1af4b0..7cd839e 100755
--- a/test/plugin/media_svc_plugin_test.c
+++ b/test/plugin/media_svc_plugin_test.c
@@ -172,7 +172,7 @@ int main()
 	char *folder_path = tzplatform_mkpath(TZ_USER_CONTENT, "Sounds");
 	ret = svc_set_folder_item_validity(db_handle, folder_path, 0, 1, &err_msg);
 	if (ret < 0) {
-	msg_print(__LINE__, "svc_set_folder_item_validity error");
+		msg_print(__LINE__, "svc_set_folder_item_validity error");
 		if (err_msg != NULL) {
 			printf("err_msg[%s]\n", err_msg);
 			free(err_msg);
@@ -184,7 +184,7 @@ int main()
 
 	ret = svc_delete_all_invalid_items_in_folder(db_handle, folder_path, &err_msg);
 	if (ret < 0) {
-	msg_print(__LINE__, "svc_delete_all_invalid_items_in_folder error");
+		msg_print(__LINE__, "svc_delete_all_invalid_items_in_folder error");
 		if (err_msg != NULL) {
 			printf("err_msg[%s]\n", err_msg);
 			free(err_msg);
@@ -197,7 +197,7 @@ int main()
 	/*db close ================================================== */
 	ret = svc_disconnect(db_handle, &err_msg);
 	if (ret < 0) {
-	msg_print(__LINE__, "svc_disconnect error");
+		msg_print(__LINE__, "svc_disconnect error");
 		if (err_msg != NULL) {
 			printf("err_msg[%s]\n", err_msg);
 			free(err_msg);