* 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;
/**
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_*/
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);
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
}
#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 {
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;
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 */
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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);
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;
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);
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
}
/*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;
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;
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;
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;
+}
#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);
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));
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);
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));
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));
}
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));
}
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));
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));
}
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));
}
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) {
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) {
}
}
memset(temp, 0, sizeof(temp));
+
/*create index */
if (col_ptr->isIndex) {
if (index_len > 0) {
}
}
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));
}
/*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);
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));
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));
}
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));
}
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));
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));
}
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));
}
}
}
- 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;
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);
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;
/*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*/
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);
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);
ret = _media_svc_sql_query(db_handle, sql, uid);
sqlite3_free(sql);
+
_media_svc_destroy_table_query();
return ret;
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;
}
}
}
-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;
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;
}
{
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;
#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"
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 {
*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);
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) {
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, '.');
#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);
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;
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;
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;
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;
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);
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);
}
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;
}
{
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);
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);
{
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) {
}
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;
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;
+}
+
#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;
__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);
}
-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);
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);
}
-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);
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);
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, \
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;
}
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);
ret = MS_MEDIA_ERR_OUT_OF_MEMORY;
}
- media_svc_error("");
-
return ret;
}
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);
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);
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);
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) {
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);
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);
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) {
}
/*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);
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;
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);
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;
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)
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);
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*/
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) {
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;
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);
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;
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);
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);
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);
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
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);
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;
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);
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);
}
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;
+}
#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"
#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 */
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;
/* 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");
*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) {
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;
/*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;
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;
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");
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;
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;
}
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) {
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 {
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 {
/* 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)
/* 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)
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;
}
}
} 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");
}
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;
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;
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, };
} 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);
/*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;
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;
}
} 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");
}
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) {
}
/*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) {
} 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;
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);
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;
int ret = MS_MEDIA_ERR_NONE;
int size = 0;
pinyin_name_s *pinyinname = NULL;
+
*pinyin_str = NULL;
if (!STRING_VALID(src_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);
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));
}
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)
{
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");
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*/
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);
_media_svc_destroy_table_query();
- media_svc_debug_func();
+ media_svc_debug_fleave();
return MS_MEDIA_ERR_NONE;
}
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) {
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");
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;
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;
}
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);
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)
} 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)
} 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)
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;
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;
}
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);
}
#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");
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;
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");
}
/*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;
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;
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*/
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);
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);
/*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);
/* 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, ¬i_item);
+ ret = _media_svc_get_noti_info(db_handle, storage_id, dest_path, MS_MEDIA_ITEM_FILE, ¬i_item);
media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
/* Send notification for move */
/*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);
/*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);
}
/*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)
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");
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);
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");
/*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;
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;
}
/* Get notification info */
media_svc_noti_item *noti_item = NULL;
- ret = _media_svc_get_noti_info(handle, storage_id, path, MS_MEDIA_ITEM_FILE, ¬i_item);
+ ret = _media_svc_get_noti_info(db_handle, storage_id, path, MS_MEDIA_ITEM_FILE, ¬i_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) {
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;
}
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, };
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;
}
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;
}
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;
}
}
}
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;
}
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;
}
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;
/* 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, ¬i_item);
+ ret = _media_svc_get_noti_info(db_handle, storage_id, dir_path, MS_MEDIA_ITEM_DIRECTORY, ¬i_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);
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);
{
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");
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");
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));
} else {
return MS_MEDIA_ERR_NONE;
}
+
if (ret != MS_MEDIA_ERR_NONE) {
_media_svc_destroy_content_info(&content_info);
return ret;
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");
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);
}
/* 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.");
_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)
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);
}
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;
+}
#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);
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);
#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
* 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
#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*/
#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"
#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;"
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 {
#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_*/
#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_*/
#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_*/
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);
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
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);
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);
/*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);
projects / platform / core / multimedia / libmedia-service.git / commitdiff