* @endcode
*/
-int media_svc_connect(MediaSvcHandle **handle);
+int media_svc_connect(MediaSvcHandle **handle,uid_t uid);
/**
* @endcode
*/
-int media_svc_create_table(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);
+int media_svc_insert_folder(MediaSvcHandle *handle, 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);
+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);
+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);
+int media_svc_insert_item_immediately(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, const char *path, uid_t uid);
int media_svc_move_item_begin(MediaSvcHandle *handle, int data_cnt);
-int media_svc_move_item_end(MediaSvcHandle *handle);
+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);
+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_set_item_validity_begin(MediaSvcHandle *handle, int data_cnt);
-int media_svc_set_item_validity_end(MediaSvcHandle *handle);
+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);
+int media_svc_set_item_validity(MediaSvcHandle *handle, const char *path, int validity, uid_t uid);
-int media_svc_delete_item_by_path(MediaSvcHandle *handle, const char *path);
+int media_svc_delete_item_by_path(MediaSvcHandle *handle, const char *path, uid_t uid);
-int media_svc_delete_all_items_in_storage(MediaSvcHandle *handle, media_svc_storage_type_e storage_type);
+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);
+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);
+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);
+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);
+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 *path);
+int media_svc_refresh_item(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, const char *path, uid_t uid);
-int media_svc_rename_folder(MediaSvcHandle *handle, const char *src_path, const char *dst_path);
+int media_svc_rename_folder(MediaSvcHandle *handle, const char *src_path, const char *dst_path, uid_t uid);
-int media_svc_request_update_db(const char *db_query);
+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);
Name: libmedia-service
Summary: Media information service library for multimedia applications
-Version: 0.2.43
+Version: 0.2.44
Release: 3
Group: System/Libraries
License: Apache License, Version 2.0
return MEDIA_SVC_PLUGIN_ERROR_NONE;
}
-int connect(void ** handle, char ** err_msg)
+int connect(void ** handle, uid_t uid, char ** err_msg)
{
- int ret = media_svc_connect(handle);
+ int ret = media_svc_connect(handle,uid);
if(ret < 0) {
__set_error_message(ret, err_msg);
return MEDIA_SVC_PLUGIN_ERROR_NONE;
}
-int insert_item_end(void * handle, char ** err_msg)
+int insert_item_end(void * handle, uid_t uid, char ** err_msg)
{
int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
return MEDIA_SVC_PLUGIN_ERROR;
}
- ret = media_svc_insert_item_end(handle);
+ ret = media_svc_insert_item_end(handle, uid);
if(ret < 0) {
__set_error_message(ret, err_msg);
return MEDIA_SVC_PLUGIN_ERROR;
return MEDIA_SVC_PLUGIN_ERROR_NONE;
}
-int insert_item(void * handle, const char *file_path, int storage_type, char ** err_msg)
+int insert_item(void * handle, 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);
+ ret = media_svc_insert_item_bulk(handle, storage_type, file_path, FALSE, uid);
if(ret < 0) {
__set_error_message(ret, err_msg);
return MEDIA_SVC_PLUGIN_ERROR;
return MEDIA_SVC_PLUGIN_ERROR_NONE;
}
-int insert_item_immediately(void * handle, const char *file_path, int storage_type, char ** err_msg)
+int insert_item_immediately(void * handle, 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);
+ ret = media_svc_insert_item_immediately(handle, storage_type, file_path, uid);
if(ret < 0) {
__set_error_message(ret, err_msg);
return MEDIA_SVC_PLUGIN_ERROR;
return MEDIA_SVC_PLUGIN_ERROR_NONE;
}
-int insert_burst_item(void * handle, const char *file_path, int storage_type, char ** err_msg)
+int insert_burst_item(void * handle, 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);
+ ret = media_svc_insert_item_bulk(handle, storage_type, file_path, TRUE, uid);
if(ret < 0) {
__set_error_message(ret, err_msg);
return MEDIA_SVC_PLUGIN_ERROR;
return MEDIA_SVC_PLUGIN_ERROR_NONE;
}
-int move_item_end(void * handle, char ** err_msg)
+int move_item_end(void * handle, uid_t uid, char ** err_msg)
{
int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
return MEDIA_SVC_PLUGIN_ERROR;
}
- ret = media_svc_move_item_end(handle);
+ ret = media_svc_move_item_end(handle, uid);
if(ret < 0) {
__set_error_message(ret, err_msg);
return MEDIA_SVC_PLUGIN_ERROR;
return MEDIA_SVC_PLUGIN_ERROR_NONE;
}
-int move_item(void * handle, const char *src_path, int src_storage_type, const char *dest_path, int dest_storage_type, char ** err_msg)
+int move_item(void * handle, const char *src_path, int src_storage_type, const char *dest_path, int dest_storage_type, uid_t uid, char ** err_msg)
{
int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
return MEDIA_SVC_PLUGIN_ERROR;
}
- ret = media_svc_move_item(handle, src_storage_type, src_path, dest_storage_type, dest_path);
+ ret = media_svc_move_item(handle, src_storage_type, src_path, dest_storage_type, dest_path, 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, char ** err_msg)
+int set_all_storage_items_validity(void * handle, 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);
+ ret = media_svc_set_all_storage_items_validity(handle, storage_type, validity, uid);
if(ret < 0) {
__set_error_message(ret, err_msg);
return MEDIA_SVC_PLUGIN_ERROR;
return MEDIA_SVC_PLUGIN_ERROR_NONE;
}
-int set_folder_item_validity(void * handle, const char * folder_path, int validity, int recursive, char ** err_msg)
+int set_folder_item_validity(void * handle, 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);
+ ret = media_svc_set_folder_items_validity(handle, folder_path, validity, recursive, uid);
if(ret < 0) {
__set_error_message(ret, err_msg);
return MEDIA_SVC_PLUGIN_ERROR;
return MEDIA_SVC_PLUGIN_ERROR_NONE;
}
-int set_item_validity_end(void * handle, char ** err_msg)
+int set_item_validity_end(void * handle, uid_t uid, char ** err_msg)
{
int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
return MEDIA_SVC_PLUGIN_ERROR;
}
- ret = media_svc_set_item_validity_end(handle);
+ ret = media_svc_set_item_validity_end(handle, uid);
if(ret < 0) {
__set_error_message(ret, err_msg);
return MEDIA_SVC_PLUGIN_ERROR;
return MEDIA_SVC_PLUGIN_ERROR_NONE;
}
-int set_item_validity(void * handle, const char *file_path, int storage_type, int validity, char ** err_msg)
+int set_item_validity(void * handle, 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;
}
- ret = media_svc_set_item_validity(handle, file_path, validity);
+ ret = media_svc_set_item_validity(handle, file_path, validity, uid);
if(ret < 0) {
__set_error_message(ret, err_msg);
return MEDIA_SVC_PLUGIN_ERROR_NONE;
}
-int delete_item(void * handle, const char *file_path, int storage_type, char ** err_msg)
+int delete_item(void * handle, const char *file_path, int storage_type, uid_t uid, char ** err_msg)
{
int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
ret = media_svc_check_item_exist_by_path(handle, file_path);
if(ret == 0) {
- ret = media_svc_delete_item_by_path(handle, file_path);
+ ret = media_svc_delete_item_by_path(handle, 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, char ** err_msg)
+int delete_all_items_in_storage(void * handle, 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);
+ ret = media_svc_delete_all_items_in_storage(handle, storage_type, uid);
if(ret < 0) {
__set_error_message(ret, err_msg);
return MEDIA_SVC_PLUGIN_ERROR;
return MEDIA_SVC_PLUGIN_ERROR_NONE;
}
-int delete_all_invalid_items_in_storage(void * handle, int storage_type, char ** err_msg)
+int delete_all_invalid_items_in_storage(void * handle, 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);
+ ret = media_svc_delete_invalid_items_in_storage(handle, storage_type, uid);
if(ret < 0) {
__set_error_message(ret, err_msg);
return MEDIA_SVC_PLUGIN_ERROR;
return MEDIA_SVC_PLUGIN_ERROR_NONE;
}
-int delete_all_invalid_items_in_folder(void * handle, const char *folder_path, char ** err_msg)
+int delete_all_invalid_items_in_folder(void * handle, const char *folder_path, 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);
+ ret = media_svc_delete_invalid_items_in_folder(handle, folder_path, uid);
if(ret < 0) {
__set_error_message(ret, err_msg);
return MEDIA_SVC_PLUGIN_ERROR;
return MEDIA_SVC_PLUGIN_ERROR_NONE;
}
-int delete_all_items(void * handle, char ** err_msg)
+int delete_all_items(void * handle, uid_t uid ,char ** err_msg)
{
int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
return MEDIA_SVC_PLUGIN_ERROR;
}
- ret = delete_all_items_in_storage(handle, MEDIA_SVC_STORAGE_INTERNAL, err_msg);
+ ret = delete_all_items_in_storage(handle, MEDIA_SVC_STORAGE_INTERNAL, uid, err_msg);
if(ret < 0)
return MEDIA_SVC_PLUGIN_ERROR;
- ret = delete_all_items_in_storage(handle, MEDIA_SVC_STORAGE_EXTERNAL, err_msg);
+ ret = delete_all_items_in_storage(handle, MEDIA_SVC_STORAGE_EXTERNAL, uid, err_msg);
if(ret < 0)
return MEDIA_SVC_PLUGIN_ERROR;
return MEDIA_SVC_PLUGIN_ERROR_NONE;
}
-int refresh_item(void * handle, const char *file_path, int storage_type, char ** err_msg)
+int refresh_item(void * handle, 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_refresh_item(handle, storage_type, file_path);
+ ret = media_svc_refresh_item(handle, storage_type, file_path, uid);
if(ret < 0) {
__set_error_message(ret, err_msg);
return MEDIA_SVC_PLUGIN_ERROR;
return MEDIA_SVC_PLUGIN_ERROR_NONE;
}
-int update_end(void)
+int update_end(uid_t uid)
{
int ret = MEDIA_SVC_PLUGIN_ERROR_NONE;
- ret = thumbnail_request_extract_all_thumbs();
+ ret = thumbnail_request_extract_all_thumbs(uid);
if (ret < 0) {
return MEDIA_SVC_PLUGIN_ERROR;
}
return MEDIA_INFO_ERROR_NONE;
}
-int _media_svc_append_album(sqlite3 *handle, const char *album, const char *artist, const char *album_art, int * album_id)
+int _media_svc_append_album(sqlite3 *handle, const char *album, const char *artist, const char *album_art, int * album_id, uid_t uid)
{
int err = -1;
char *sql = sqlite3_mprintf("INSERT INTO %s (name, artist, album_art, album_art) values (%Q, %Q, %Q, %Q); ",
MEDIA_SVC_DB_TABLE_ALBUM, album, artist, album_art, album_art);
- err = _media_svc_sql_query(handle, sql);
+ err = _media_svc_sql_query(handle, sql, uid);
sqlite3_free(sql);
if (err != SQLITE_OK) {
media_svc_error("failed to insert albums");
return MEDIA_INFO_ERROR_NONE;
}
-int _media_svc_create_media_table(sqlite3 *db_handle)
+int _media_svc_create_media_table(sqlite3 *db_handle, uid_t uid)
{
int ret = MEDIA_INFO_ERROR_NONE;
char * sql = NULL;
media_svc_retv_if(sql == NULL, MEDIA_INFO_ERROR_OUT_OF_MEMORY);
- ret = _media_svc_sql_query(db_handle, sql);
+ ret = _media_svc_sql_query(db_handle, sql, uid);
sqlite3_free(sql);
if (ret != SQLITE_OK) {
media_svc_error("It failed to create db table (%d)", ret);
media_svc_retv_if(sql == NULL, MEDIA_INFO_ERROR_OUT_OF_MEMORY);
- ret = _media_svc_sql_query(db_handle, sql);
+ ret = _media_svc_sql_query(db_handle, sql, uid);
sqlite3_free(sql);
if (ret != SQLITE_OK) {
media_svc_error("It failed to create db table (%d)", ret);
return MEDIA_INFO_ERROR_NONE;
}
-int _media_svc_create_folder_table(sqlite3 *db_handle)
+int _media_svc_create_folder_table(sqlite3 *db_handle, uid_t uid)
{
int ret = MEDIA_INFO_ERROR_NONE;
char * sql = NULL;
media_svc_retv_if(sql == NULL, MEDIA_INFO_ERROR_OUT_OF_MEMORY);
- ret = _media_svc_sql_query(db_handle, sql);
+ ret = _media_svc_sql_query(db_handle, sql, uid);
sqlite3_free(sql);
if (ret != SQLITE_OK) {
media_svc_error("It failed to create db table (%d)", ret);
media_svc_retv_if(sql == NULL, MEDIA_INFO_ERROR_OUT_OF_MEMORY);
- ret = _media_svc_sql_query(db_handle, sql);
+ ret = _media_svc_sql_query(db_handle, sql, uid);
sqlite3_free(sql);
if (ret != SQLITE_OK) {
media_svc_error("It failed to create trigger (%d)", ret);
return MEDIA_INFO_ERROR_NONE;
}
-int _media_svc_create_playlist_table(sqlite3 *db_handle)
+int _media_svc_create_playlist_table(sqlite3 *db_handle, uid_t uid)
{
int ret = MEDIA_INFO_ERROR_NONE;
char * sql = NULL;
media_svc_retv_if(sql == NULL, MEDIA_INFO_ERROR_OUT_OF_MEMORY);
- ret = _media_svc_sql_query(db_handle, sql);
+ ret = _media_svc_sql_query(db_handle, sql, uid);
sqlite3_free(sql);
if (ret != SQLITE_OK) {
media_svc_error("It failed to create db table (%d)", ret);
media_svc_retv_if(sql == NULL, MEDIA_INFO_ERROR_OUT_OF_MEMORY);
- ret = _media_svc_sql_query(db_handle, sql);
+ ret = _media_svc_sql_query(db_handle, sql, uid);
sqlite3_free(sql);
if (ret != SQLITE_OK) {
media_svc_error("It failed to create db table (%d)", ret);
media_svc_retv_if(sql == NULL, MEDIA_INFO_ERROR_OUT_OF_MEMORY);
- ret = _media_svc_sql_query(db_handle, sql);
+ ret = _media_svc_sql_query(db_handle, sql, uid);
sqlite3_free(sql);
if (ret != SQLITE_OK) {
media_svc_error("It failed to create trigger (%d)", ret);
media_svc_retv_if(sql == NULL, MEDIA_INFO_ERROR_OUT_OF_MEMORY);
- ret = _media_svc_sql_query(db_handle, sql);
+ ret = _media_svc_sql_query(db_handle, sql, uid);
sqlite3_free(sql);
if (ret != SQLITE_OK) {
media_svc_error("It failed to create trigger (%d)", ret);
return MEDIA_INFO_ERROR_NONE;
}
-int _media_svc_create_album_table(sqlite3 *db_handle)
+int _media_svc_create_album_table(sqlite3 *db_handle, uid_t uid)
{
int ret = MEDIA_INFO_ERROR_NONE;
char * sql = NULL;
media_svc_retv_if(sql == NULL, MEDIA_INFO_ERROR_OUT_OF_MEMORY);
- ret = _media_svc_sql_query(db_handle, sql);
+ ret = _media_svc_sql_query(db_handle, sql, uid);
sqlite3_free(sql);
if (ret != SQLITE_OK) {
media_svc_error("It failed to create db table (%d)", ret);
media_svc_retv_if(sql == NULL, MEDIA_INFO_ERROR_OUT_OF_MEMORY);
- ret = _media_svc_sql_query(db_handle, sql);
+ ret = _media_svc_sql_query(db_handle, sql, uid);
sqlite3_free(sql);
if (ret != SQLITE_OK) {
media_svc_error("It failed to create trigger (%d)", ret);
return MEDIA_INFO_ERROR_NONE;
}
-int _media_svc_create_tag_table(sqlite3 *db_handle)
+int _media_svc_create_tag_table(sqlite3 *db_handle, uid_t uid)
{
int ret = MEDIA_INFO_ERROR_NONE;
char * sql = NULL;
media_svc_retv_if(sql == NULL, MEDIA_INFO_ERROR_OUT_OF_MEMORY);
- ret = _media_svc_sql_query(db_handle, sql);
+ ret = _media_svc_sql_query(db_handle, sql, uid);
sqlite3_free(sql);
if (ret != SQLITE_OK) {
media_svc_error("It failed to create db table (%d)", ret);
media_svc_retv_if(sql == NULL, MEDIA_INFO_ERROR_OUT_OF_MEMORY);
- ret = _media_svc_sql_query(db_handle, sql);
+ ret = _media_svc_sql_query(db_handle, sql, uid);
sqlite3_free(sql);
if (ret != SQLITE_OK) {
media_svc_error("It failed to create db table (%d)", ret);
media_svc_retv_if(sql == NULL, MEDIA_INFO_ERROR_OUT_OF_MEMORY);
- ret = _media_svc_sql_query(db_handle, sql);
+ ret = _media_svc_sql_query(db_handle, sql, uid);
sqlite3_free(sql);
if (ret != SQLITE_OK) {
media_svc_error("It failed to create trigger (%d)", ret);
media_svc_retv_if(sql == NULL, MEDIA_INFO_ERROR_OUT_OF_MEMORY);
- ret = _media_svc_sql_query(db_handle, sql);
+ ret = _media_svc_sql_query(db_handle, sql, uid);
sqlite3_free(sql);
if (ret != SQLITE_OK) {
media_svc_error("It failed to create trigger (%d)", ret);
return MEDIA_INFO_ERROR_NONE;
}
-int _media_svc_create_bookmark_table(sqlite3 *db_handle)
+int _media_svc_create_bookmark_table(sqlite3 *db_handle, uid_t uid)
{
int ret = MEDIA_INFO_ERROR_NONE;
char * sql = NULL;
media_svc_retv_if(sql == NULL, MEDIA_INFO_ERROR_OUT_OF_MEMORY);
- ret = _media_svc_sql_query(db_handle, sql);
+ ret = _media_svc_sql_query(db_handle, sql, uid);
sqlite3_free(sql);
if (ret != SQLITE_OK) {
media_svc_error("It failed to create db table (%d)", ret);
media_svc_retv_if(sql == NULL, MEDIA_INFO_ERROR_OUT_OF_MEMORY);
- ret = _media_svc_sql_query(db_handle, sql);
+ ret = _media_svc_sql_query(db_handle, sql, uid);
sqlite3_free(sql);
if (ret != SQLITE_OK) {
media_svc_error("It failed to create trigger (%d)", ret);
return MEDIA_INFO_ERROR_NONE;
}
-int _media_svc_create_custom_table(sqlite3 *db_handle)
+int _media_svc_create_custom_table(sqlite3 *db_handle, uid_t uid)
{
int ret = MEDIA_INFO_ERROR_NONE;
char * sql = NULL;
media_svc_retv_if(sql == NULL, MEDIA_INFO_ERROR_OUT_OF_MEMORY);
- ret = _media_svc_sql_query(db_handle, sql);
+ ret = _media_svc_sql_query(db_handle, sql, uid);
sqlite3_free(sql);
if (ret != SQLITE_OK) {
media_svc_error("It failed to create db table (%d)", ret);
media_svc_retv_if(sql == NULL, MEDIA_INFO_ERROR_OUT_OF_MEMORY);
- ret = _media_svc_sql_query(db_handle, sql);
+ ret = _media_svc_sql_query(db_handle, sql, uid);
sqlite3_free(sql);
if (ret != SQLITE_OK) {
media_svc_error("It failed to create trigger (%d)", ret);
media_svc_retv_if(sql == NULL, MEDIA_INFO_ERROR_OUT_OF_MEMORY);
- ret = _media_svc_sql_query(db_handle, sql);
+ ret = _media_svc_sql_query(db_handle, sql, uid);
sqlite3_free(sql);
if (ret != SQLITE_OK) {
media_svc_error("It failed to create db table (%d)", ret);
return MEDIA_INFO_ERROR_NONE;
}
-int _media_svc_request_update_db(const char *sql_str)
+int _media_svc_request_update_db(const char *sql_str, uid_t uid)
{
int ret = MS_MEDIA_ERR_NONE;
- ret = media_db_request_update_db(sql_str);
+ ret = media_db_request_update_db(sql_str, uid);
return ret;
}
-int _media_svc_sql_query(sqlite3 *db_handle, const char *sql_str)
+int _media_svc_sql_query(sqlite3 *db_handle, const char *sql_str, uid_t uid)
{
int err = -1;
media_svc_debug("[SQL query] : %s", sql_str);
#if 1
//DB will be updated by Media Server.
- err = _media_svc_request_update_db(sql_str);
+ err = _media_svc_request_update_db(sql_str, uid);
return _media_svc_error_convert(err);
#else
return MEDIA_INFO_ERROR_NONE;
}
-int _media_svc_sql_begin_trans(sqlite3 *handle)
+int _media_svc_sql_begin_trans(sqlite3 *handle, uid_t uid)
{
int err = MEDIA_INFO_ERROR_NONE;
media_svc_debug("========_media_svc_sql_begin_trans");
#if 1
//err = _media_svc_request_update_db("BEGIN IMMEDIATE;");
- err = media_db_request_update_db_batch_start("BEGIN IMMEDIATE;");
+ err = media_db_request_update_db_batch_start("BEGIN IMMEDIATE;", uid);
return _media_svc_error_convert(err);
#else
#endif
}
-int _media_svc_sql_end_trans(sqlite3 *handle)
+int _media_svc_sql_end_trans(sqlite3 *handle, uid_t uid)
{
int err = MEDIA_INFO_ERROR_NONE;
media_svc_debug("========_media_svc_sql_end_trans");
#if 1
- err = media_db_request_update_db_batch_end("COMMIT;");
+ err = media_db_request_update_db_batch_end("COMMIT;", uid);
//err = _media_svc_request_update_db("COMMIT;");
return _media_svc_error_convert(err);
#else
#endif
}
-int _media_svc_sql_rollback_trans(sqlite3 *handle)
+int _media_svc_sql_rollback_trans(sqlite3 *handle, uid_t uid)
{
int err = MEDIA_INFO_ERROR_NONE;
media_svc_debug("========_media_svc_sql_rollback_trans");
#if 1
- err = _media_svc_request_update_db("ROLLBACK;");
+ err = _media_svc_request_update_db("ROLLBACK;", uid);
return _media_svc_error_convert(err);
#else
char *err_msg = NULL;
#endif
}
-int _media_svc_sql_query_list(sqlite3 *handle, GList **query_list)
+int _media_svc_sql_query_list(sqlite3 *handle, GList **query_list, uid_t uid)
{
int i = 0;
int length = g_list_length(*query_list);
sql = (char*)g_list_nth_data(*query_list, i);
if(sql != NULL) {
//err = _media_svc_sql_query(handle, sql);
- err = media_db_request_update_db_batch(sql);
+ err = media_db_request_update_db_batch(sql, uid);
//if (err != SQLITE_OK) {
// media_svc_error("A query failed in batch");
if (err < MS_MEDIA_ERR_NONE) {
}
int _media_svc_append_folder(sqlite3 *handle, media_svc_storage_type_e storage_type,
- const char *folder_id, const char *path_name, const char *folder_name, int modified_date)
+ const char *folder_id, const char *path_name, const char *folder_name, int modified_date, uid_t uid)
{
int err = -1;
char *sql = sqlite3_mprintf("INSERT INTO %s (folder_uuid, path, name, storage_type, modified_time) values (%Q, %Q, %Q, '%d', '%d'); ",
MEDIA_SVC_DB_TABLE_FOLDER, folder_id, path_name, folder_name, storage_type, modified_date);
- err = _media_svc_sql_query(handle, sql);
+ err = _media_svc_sql_query(handle, sql, uid);
sqlite3_free(sql);
if (err != SQLITE_OK) {
media_svc_error("failed to insert folder");
return MEDIA_INFO_ERROR_NONE;
}
-int _media_svc_update_folder_modified_time_by_folder_uuid(sqlite3 *handle, const char *folder_uuid, const char *folder_path, bool stack_query)
+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 err = -1;
int modified_time = 0;
char *sql = sqlite3_mprintf("UPDATE %s SET modified_time=%d WHERE folder_uuid=%Q;", MEDIA_SVC_DB_TABLE_FOLDER, modified_time, folder_uuid);
if(!stack_query) {
- err = _media_svc_sql_query(handle, sql);
+ err = _media_svc_sql_query(handle, sql, uid);
sqlite3_free(sql);
if (err != SQLITE_OK) {
media_svc_error("failed to update folder");
return MEDIA_INFO_ERROR_NONE;
}
-int _media_svc_get_and_append_folder_id_by_path(sqlite3 *handle, const char *path, media_svc_storage_type_e storage_type, char *folder_id)
+int _media_svc_get_and_append_folder_id_by_path(sqlite3 *handle, const char *path, media_svc_storage_type_e storage_type, char *folder_id, uid_t uid)
{
char *path_name = NULL;
int ret = MEDIA_INFO_ERROR_NONE;
folder_name = g_path_get_basename(path_name);
folder_modified_date = _media_svc_get_file_time(path_name);
- ret = _media_svc_append_folder(handle, storage_type, folder_uuid, path_name, folder_name, folder_modified_date);
+ ret = _media_svc_append_folder(handle, storage_type, folder_uuid, path_name, folder_name, folder_modified_date, uid);
SAFE_FREE(folder_name);
_strncpy_safe(folder_id, folder_uuid, MEDIA_SVC_UUID_SIZE+1);
}
return ret;
}
-int _media_svc_update_folder_table(sqlite3 *handle)
+int _media_svc_update_folder_table(sqlite3 *handle, uid_t uid)
{
int err = -1;
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);
- err = _media_svc_sql_query(handle, sql);
+ err = _media_svc_sql_query(handle, sql, uid);
sqlite3_free(sql);
if (err != SQLITE_OK) {
media_svc_error("failed to delete folder item");
*/
#include <string.h>
+#include <grp.h>
+#include <pwd.h>
#include "media-svc-media.h"
#include "media-svc-media-folder.h"
#include "media-svc-error.h"
#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;
return MEDIA_INFO_ERROR_NONE;
}
-int _media_svc_insert_item_with_data(sqlite3 *handle, media_svc_content_info_s *content_info, int is_burst, bool stack_query)
+char* _media_svc_get_thumb_default_path(uid_t uid)
+{
+ char *result_psswd = NULL;
+ struct group *grpinfo = NULL;
+ if(uid == getuid())
+ {
+ result_psswd = strdup(MEDIA_SVC_THUMB_DEFAULT_PATH);
+ grpinfo = getgrnam("users");
+ if(grpinfo == NULL) {
+ media_svc_error("getgrnam(users) returns NULL !");
+ return NULL;
+ }
+ }
+ else
+ {
+ struct passwd *userinfo = getpwuid(uid);
+ if(userinfo == NULL) {
+ media_svc_error("getpwuid(%d) returns NULL !", uid);
+ return NULL;
+ }
+ grpinfo = getgrnam("users");
+ if(grpinfo == NULL) {
+ media_svc_error("getgrnam(users) returns NULL !");
+ return NULL;
+ }
+ // Compare git_t type and not group name
+ if (grpinfo->gr_gid != userinfo->pw_gid) {
+ media_svc_error("UID [%d] does not belong to 'users' group!", uid);
+ return NULL;
+ }
+ asprintf(&result_psswd, "%s/data/file-manager-service/.thumb/thumb_default.png", userinfo->pw_dir);
+ }
+
+ 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)
{
media_svc_debug("");
int err = -1;
int width = 0;
int height = 0;
- err = thumbnail_request_from_db_with_size(content_info->path, thumb_path, sizeof(thumb_path), &width, &height);
+ err = thumbnail_request_from_db_with_size(content_info->path, thumb_path, sizeof(thumb_path), &width, &height, uid);
if (err < 0) {
media_svc_error("thumbnail_request_from_db failed: %d", err);
} else {
burst_id = NULL;
if(!stack_query) {
- err = _media_svc_sql_query(handle, sql);
+ err = _media_svc_sql_query(handle, sql, uid);
sqlite3_free(sql);
if (err != SQLITE_OK) {
media_svc_error("failed to insert item");
return MEDIA_INFO_ERROR_NONE;
}
-int _media_svc_update_item_with_data(sqlite3 *handle, media_svc_content_info_s *content_info)
+int _media_svc_update_item_with_data(sqlite3 *handle, media_svc_content_info_s *content_info, uid_t uid)
{
int err = -1;
content_info->path
);
- err = _media_svc_sql_query(handle, sql);
+ err = _media_svc_sql_query(handle, sql, uid);
sqlite3_free(sql);
if (err != SQLITE_OK) {
media_svc_error("failed to update item");
return MEDIA_INFO_ERROR_NONE;
}
-int _media_svc_delete_item_by_path(sqlite3 *handle, const char *path)
+int _media_svc_delete_item_by_path(sqlite3 *handle, const char *path, uid_t uid)
{
int err = -1;
char *sql = sqlite3_mprintf("DELETE FROM %s WHERE validity=1 AND path='%q'", MEDIA_SVC_DB_TABLE_MEDIA, path);
- err = _media_svc_sql_query(handle, sql);
+ err = _media_svc_sql_query(handle, sql, uid);
sqlite3_free(sql);
if (err != SQLITE_OK) {
media_svc_error("It failed to delete item (%d)", err);
return MEDIA_INFO_ERROR_NONE;
}
-int _media_svc_truncate_table(sqlite3 *handle, media_svc_storage_type_e storage_type)
+int _media_svc_truncate_table(sqlite3 *handle, media_svc_storage_type_e storage_type, uid_t uid)
{
int err = -1;
char *sql = sqlite3_mprintf("DELETE FROM %s WHERE storage_type=%d", MEDIA_SVC_DB_TABLE_MEDIA, storage_type);
- err = _media_svc_sql_query(handle, sql);
+ err = _media_svc_sql_query(handle, sql, uid);
sqlite3_free(sql);
if (err != SQLITE_OK) {
media_svc_error("It failed to truncate table (%d)", err);
}
-int _media_svc_delete_invalid_items(sqlite3 *handle, media_svc_storage_type_e storage_type)
+int _media_svc_delete_invalid_items(sqlite3 *handle, media_svc_storage_type_e storage_type, uid_t uid)
{
int idx = 0;
media_svc_thumbnailpath_s *thumbpath_record = NULL;
}
char *sql = sqlite3_mprintf("DELETE FROM %s WHERE validity = 0 AND storage_type=%d", MEDIA_SVC_DB_TABLE_MEDIA, storage_type);
- err = _media_svc_sql_query(handle, sql);
+ err = _media_svc_sql_query(handle, sql, uid);
sqlite3_free(sql);
if (err != SQLITE_OK) {
media_svc_error("To delete invalid items is failed(%d)", err);
/*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_THUMB_DEFAULT_PATH, sizeof(MEDIA_SVC_THUMB_DEFAULT_PATH)) != 0)) {
+ 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)) {
if (_media_svc_remove_file(thumbpath_record[idx].thumbnail_path) == FALSE) {
media_svc_error("fail to remove thumbnail file.");
//SAFE_FREE(thumbpath_record);
return MEDIA_INFO_ERROR_NONE;
}
-int _media_svc_delete_invalid_folder_items(sqlite3 *handle, const char *folder_path)
+int _media_svc_delete_invalid_folder_items(sqlite3 *handle, const char *folder_path, uid_t uid)
{
int idx = 0;
media_svc_thumbnailpath_s *thumbpath_record = NULL;
}
char *sql = sqlite3_mprintf("DELETE FROM %s WHERE validity = 0 AND path LIKE '%q/%%'", MEDIA_SVC_DB_TABLE_MEDIA, folder_path);
- err = _media_svc_sql_query(handle, sql);
+ err = _media_svc_sql_query(handle, sql, uid);
sqlite3_free(sql);
if (err != SQLITE_OK) {
media_svc_error("To delete invalid items is failed(%d)", err);
/*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_THUMB_DEFAULT_PATH, sizeof(MEDIA_SVC_THUMB_DEFAULT_PATH)) != 0)) {
+ 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)) {
if (_media_svc_remove_file(thumbpath_record[idx].thumbnail_path) == FALSE) {
media_svc_error("fail to remove thumbnail file [%s].", thumbpath_record[idx].thumbnail_path);
//SAFE_FREE(thumbpath_record);
}
-int _media_svc_update_item_validity(sqlite3 *handle, const char *path, int validity, bool stack_query)
+int _media_svc_update_item_validity(sqlite3 *handle, const char *path, int validity, bool stack_query, uid_t uid)
{
int err = -1;
char *sql = sqlite3_mprintf("UPDATE %s SET validity=%d WHERE path= '%q'", MEDIA_SVC_DB_TABLE_MEDIA, validity, path);
if(!stack_query) {
- err = _media_svc_sql_query(handle, sql);
+ err = _media_svc_sql_query(handle, sql, uid);
sqlite3_free(sql);
if (err != SQLITE_OK) {
media_svc_error("To update item as valid is failed(%d)", err);
return MEDIA_INFO_ERROR_NONE;
}
-int _media_svc_update_thumbnail_path(sqlite3 *handle, const char *path, const char *thumb_path)
+int _media_svc_update_thumbnail_path(sqlite3 *handle, const char *path, const char *thumb_path, uid_t uid)
{
int err = -1;
char *sql = sqlite3_mprintf("UPDATE %s SET thumbnail_path=%Q WHERE path= %Q", MEDIA_SVC_DB_TABLE_MEDIA, thumb_path, path);
- err = _media_svc_sql_query(handle, sql);
+ err = _media_svc_sql_query(handle, sql, uid);
sqlite3_free(sql);
if (err != SQLITE_OK) {
media_svc_error("To update thumb path failed(%d)", err);
return MEDIA_INFO_ERROR_NONE;
}
-int _media_svc_update_storage_item_validity(sqlite3 *handle, media_svc_storage_type_e storage_type, int validity)
+int _media_svc_update_storage_item_validity(sqlite3 *handle, media_svc_storage_type_e storage_type, int validity, uid_t uid)
{
int err = -1;
char *sql = sqlite3_mprintf("UPDATE %s SET validity=%d WHERE storage_type=%d", MEDIA_SVC_DB_TABLE_MEDIA, validity, storage_type);
- err = _media_svc_sql_query(handle, sql);
+ err = _media_svc_sql_query(handle, sql, uid);
sqlite3_free(sql);
if (err != SQLITE_OK) {
media_svc_error("To update item as valid is failed(%d)", err);
return MEDIA_INFO_ERROR_NONE;
}
-int _media_svc_update_folder_item_validity(sqlite3 *handle, const char *folder_path, int validity)
+int _media_svc_update_folder_item_validity(sqlite3 *handle, const char *folder_path, int validity, uid_t uid)
{
int err = -1;
int ret = MEDIA_INFO_ERROR_NONE;
/*Update folder item validity*/
sql = sqlite3_mprintf("UPDATE %s SET validity=%d WHERE folder_uuid='%q'", MEDIA_SVC_DB_TABLE_MEDIA, validity, folder_uuid);
- err = _media_svc_sql_query(handle, sql);
+ err = _media_svc_sql_query(handle, sql, uid);
sqlite3_free(sql);
if (err != SQLITE_OK) {
media_svc_error("To update folder item as valid is failed(%d)", err);
return MEDIA_INFO_ERROR_NONE;
}
-int _media_svc_update_recursive_folder_item_validity(sqlite3 *handle, const char *folder_path, int validity)
+int _media_svc_update_recursive_folder_item_validity(sqlite3 *handle, const char *folder_path, int validity, uid_t uid)
{
int err = -1;
/*Update folder item validity*/
char *sql = sqlite3_mprintf("UPDATE %s SET validity=%d WHERE path LIKE '%q/%%'", MEDIA_SVC_DB_TABLE_MEDIA, validity, folder_path);
- err = _media_svc_sql_query(handle, sql);
+ err = _media_svc_sql_query(handle, sql, uid);
sqlite3_free(sql);
if (err != SQLITE_OK) {
media_svc_error("To update recursive folder item validity is failed(%d)", err);
}
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)
+ 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*/
}
if(!stack_query) {
- err = _media_svc_sql_query(handle, sql);
+ err = _media_svc_sql_query(handle, sql, uid);
sqlite3_free(sql);
if (err != SQLITE_OK) {
media_svc_error("It failed to update metadata (%d)", err);
return MEDIA_INFO_ERROR_NONE;
}
-int _media_svc_list_query_do(sqlite3 *handle, media_svc_query_type_e query_type)
+int _media_svc_list_query_do(sqlite3 *handle, media_svc_query_type_e query_type, uid_t uid)
{
int ret = MEDIA_INFO_ERROR_NONE;
- ret = _media_svc_sql_begin_trans(handle);
+ ret = _media_svc_sql_begin_trans(handle, uid);
media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
if (query_type == MEDIA_SVC_QUERY_SET_ITEM_VALIDITY)
- ret = _media_svc_sql_query_list(handle, &g_media_svc_item_validity_query_list);
+ ret = _media_svc_sql_query_list(handle, &g_media_svc_item_validity_query_list,uid);
else if (query_type == MEDIA_SVC_QUERY_MOVE_ITEM)
- ret = _media_svc_sql_query_list(handle, &g_media_svc_move_item_query_list);
+ 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);
+ ret = _media_svc_sql_query_list(handle, &g_media_svc_insert_item_query_list, uid);
else
ret = MEDIA_INFO_ERROR_INVALID_PARAMETER;
if (ret != MEDIA_INFO_ERROR_NONE) {
media_svc_error("_media_svc_list_query_do failed. start rollback");
- _media_svc_sql_rollback_trans(handle);
+ _media_svc_sql_rollback_trans(handle,uid);
return ret;
}
- ret = _media_svc_sql_end_trans(handle);
+ ret = _media_svc_sql_end_trans(handle, uid);
if (ret != MEDIA_INFO_ERROR_NONE) {
media_svc_error("mb_svc_sqlite3_commit_trans failed.. Now start to rollback\n");
- _media_svc_sql_rollback_trans(handle);
+ _media_svc_sql_rollback_trans(handle,uid);
return ret;
}
#include <libexif/exif-data.h>
#include <media-thumbnail.h>
#include <media-util.h>
+#include <grp.h>
+#include <pwd.h>
#include "uuid.h"
#include "media-svc-util.h"
#include "media-svc-error.h"
#define MEDIA_SVC_FILE_EXT_LEN_MAX 6 /**< Maximum file ext lenth*/
+#define GLOBAL_USER 0 //#define tzplatform_getenv(TZ_GLOBAL) //TODO
typedef enum {
MEDIA_SVC_EXTRACTED_FIELD_NONE = 0x00000001,
return title;
}
-int _media_svc_save_image(void *image, int size, char *image_path)
+static int _mkdir(const char *dir, mode_t mode) {
+ char tmp[256];
+ char *p = NULL;
+ size_t len;
+
+ snprintf(tmp, sizeof(tmp),"%s",dir);
+ len = strlen(tmp);
+ if(tmp[len - 1] == '/')
+ tmp[len - 1] = 0;
+ for(p = tmp + 1; *p; p++)
+ if(*p == '/') {
+ *p = 0;
+ mkdir(tmp, mode);
+ *p = '/';
+ }
+ return mkdir(tmp, mode);
+}
+
+static char* _media_svc_get_thumb_path(uid_t uid)
+{
+ char *result_psswd = NULL;
+ struct group *grpinfo = NULL;
+ if(uid == getuid())
+ {
+ result_psswd = strdup(MEDIA_SVC_THUMB_PATH_PREFIX);
+ grpinfo = getgrnam("users");
+ if(grpinfo == NULL) {
+ media_svc_error("getgrnam(users) returns NULL !");
+ return NULL;
+ }
+ }
+ else
+ {
+ struct passwd *userinfo = getpwuid(uid);
+ if(userinfo == NULL) {
+ media_svc_error("getpwuid(%d) returns NULL !", uid);
+ return NULL;
+ }
+ grpinfo = getgrnam("users");
+ if(grpinfo == NULL) {
+ media_svc_error("getgrnam(users) returns NULL !");
+ return NULL;
+ }
+ // Compare git_t type and not group name
+ if (grpinfo->gr_gid != userinfo->pw_gid) {
+ media_svc_error("UID [%d] does not belong to 'users' group!", uid);
+ return NULL;
+ }
+ asprintf(&result_psswd, "%s/data/file-manager-service/.thumb", userinfo->pw_dir);
+ }
+
+ _mkdir(result_psswd,S_IRWXU | S_IRWXG | S_IRWXO);
+
+ return result_psswd;
+}
+
+char* _media_svc_get_thumb_internal_path(uid_t uid)
+{
+ char *result_psswd = NULL;
+ struct group *grpinfo = NULL;
+ if(uid == getuid())
+ {
+ result_psswd = strdup(MEDIA_SVC_THUMB_INTERNAL_PATH);
+ grpinfo = getgrnam("users");
+ if(grpinfo == NULL) {
+ media_svc_error("getgrnam(users) returns NULL !");
+ return NULL;
+ }
+ }
+ else
+ {
+ struct passwd *userinfo = getpwuid(uid);
+ if(userinfo == NULL) {
+ media_svc_error("getpwuid(%d) returns NULL !", uid);
+ return NULL;
+ }
+ grpinfo = getgrnam("users");
+ if(grpinfo == NULL) {
+ media_svc_error("getgrnam(users) returns NULL !");
+ return NULL;
+ }
+ // Compare git_t type and not group name
+ if (grpinfo->gr_gid != userinfo->pw_gid) {
+ media_svc_error("UID [%d] does not belong to 'users' group!", uid);
+ return NULL;
+ }
+ asprintf(&result_psswd, "%s/data/file-manager-service/.thumb/phone", userinfo->pw_dir);
+ }
+
+ mkdir(result_psswd,S_IRWXU | S_IRWXG | S_IRWXO);
+
+ return result_psswd;
+}
+
+char* _media_svc_get_thumb_external_path(uid_t uid)
+{
+ char *result_psswd = NULL;
+ struct group *grpinfo = NULL;
+ if(uid == getuid())
+ {
+ result_psswd = strdup(MEDIA_SVC_THUMB_EXTERNAL_PATH);
+ grpinfo = getgrnam("users");
+ if(grpinfo == NULL) {
+ media_svc_error("getgrnam(users) returns NULL !");
+ return NULL;
+ }
+ }
+ else
+ {
+ struct passwd *userinfo = getpwuid(uid);
+ if(userinfo == NULL) {
+ media_svc_error("getpwuid(%d) returns NULL !", uid);
+ return NULL;
+ }
+ grpinfo = getgrnam("users");
+ if(grpinfo == NULL) {
+ media_svc_error("getgrnam(users) returns NULL !");
+ return NULL;
+ }
+ // Compare git_t type and not group name
+ if (grpinfo->gr_gid != userinfo->pw_gid) {
+ media_svc_error("UID [%d] does not belong to 'users' group!", uid);
+ return NULL;
+ }
+ asprintf(&result_psswd, "%s/data/file-manager-service/.thumb/mmc", userinfo->pw_dir);
+ }
+
+ _mkdir(result_psswd,S_IRWXU | S_IRWXG | S_IRWXO);
+
+ return result_psswd;
+}
+
+int _media_svc_save_image(void *image, int size, char *image_path, uid_t uid)
{
media_svc_debug("start save image, path [%s] image size [%d]", image_path, size);
}
struct statfs fs;
- if (-1 == statfs(MEDIA_SVC_THUMB_PATH_PREFIX, &fs)) {
+ if (-1 == statfs(_media_svc_get_thumb_path(uid), &fs)) {
media_svc_error("error in statfs");
return MEDIA_INFO_ERROR_INTERNAL;
}
return MEDIA_INFO_ERROR_NONE;
}
-bool _media_svc_get_thumbnail_path(media_svc_storage_type_e storage_type, char *thumb_path, const char *pathname, const char *img_format)
+
+bool _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)
{
char savename[MEDIA_SVC_PATHNAME_SIZE] = {0};
char file_ext[MEDIA_SVC_FILE_EXT_LEN_MAX + 1] = {0};
char hash[255 + 1];
char *thumbfile_ext = NULL;
- thumb_dir = (storage_type == MEDIA_SVC_STORAGE_INTERNAL) ? MEDIA_SVC_THUMB_INTERNAL_PATH : MEDIA_SVC_THUMB_EXTERNAL_PATH;
+ thumb_dir = (storage_type == MEDIA_SVC_STORAGE_INTERNAL) ? _media_svc_get_thumb_internal_path(uid) : _media_svc_get_thumb_external_path(uid);
memset(file_ext, 0, sizeof(file_ext));
if (!_media_svc_get_file_ext(pathname, file_ext)) {
return MEDIA_INFO_ERROR_NONE;
}
-int _media_svc_extract_media_metadata(sqlite3 *handle, media_svc_content_info_s *content_info, media_svc_media_type_e media_type, drm_content_info_s *drm_contentInfo)
+int _media_svc_extract_media_metadata(sqlite3 *handle, media_svc_content_info_s *content_info, media_svc_media_type_e media_type, drm_content_info_s *drm_contentInfo, uid_t uid)
{
MMHandleType content = 0;
MMHandleType tag = 0;
mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_ARTWORK_MIME, &p, &artwork_mime_size, NULL);
if ((mmf_error == MM_ERROR_NONE) && (artwork_mime_size > 0)) {
- result = _media_svc_get_thumbnail_path(content_info->storage_type, thumb_path, content_info->path, p);
+ result = _media_svc_get_thumbnail_path(content_info->storage_type, thumb_path, content_info->path, p, uid);
if (result == FALSE) {
media_svc_error("Fail to Get Thumbnail Path");
}
if(strlen(thumb_path) > 0)
{
- ret = _media_svc_save_image(image, size, thumb_path);
+ ret = _media_svc_save_image(image, size, thumb_path, uid);
if (ret != MEDIA_INFO_ERROR_NONE) {
media_svc_error("Fail to Save Thumbnail Image");
}
if((strncmp(content_info->media_meta.album, MEDIA_SVC_TAG_UNKNOWN, strlen(MEDIA_SVC_TAG_UNKNOWN))) &&
(strncmp(content_info->media_meta.artist, MEDIA_SVC_TAG_UNKNOWN, strlen(MEDIA_SVC_TAG_UNKNOWN))))
- ret = _media_svc_append_album(handle, content_info->media_meta.album, content_info->media_meta.artist, content_info->thumbnail_path, &album_id);
+ ret = _media_svc_append_album(handle, content_info->media_meta.album, content_info->media_meta.artist, content_info->thumbnail_path, &album_id, uid);
else
- ret = _media_svc_append_album(handle, content_info->media_meta.album, content_info->media_meta.artist, NULL, &album_id);
+ ret = _media_svc_append_album(handle, content_info->media_meta.album, content_info->media_meta.artist, NULL, &album_id, uid);
content_info->album_id = album_id;
}
/* Flag for items to be published by notification */
static __thread int g_insert_with_noti = FALSE;
-int media_svc_connect(MediaSvcHandle **handle)
+int media_svc_connect(MediaSvcHandle **handle, uid_t uid)
{
int ret = MEDIA_INFO_ERROR_NONE;
MediaDBHandle *db_handle = NULL;
media_svc_debug_func();
#if 1 //Use libmedia_utils API
- ret = media_db_connect(&db_handle);
+ ret = media_db_connect(&db_handle,uid);
if(ret != MS_MEDIA_ERR_NONE)
return _media_svc_error_convert(ret);
#endif
}
-int media_svc_create_table(MediaSvcHandle *handle)
+int media_svc_create_table(MediaSvcHandle *handle, uid_t uid)
{
int ret = MEDIA_INFO_ERROR_NONE;
sqlite3 * db_handle = (sqlite3 *)handle;
media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
/*create media table*/
- ret = _media_svc_create_media_table(handle);
+ ret = _media_svc_create_media_table(handle, uid);
media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
/*create folder table*/
- ret = _media_svc_create_folder_table(handle);
+ ret = _media_svc_create_folder_table(handle, uid);
media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
/*create playlist table*/
- ret = _media_svc_create_playlist_table(handle);
+ ret = _media_svc_create_playlist_table(handle, uid);
media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
/* create album table*/
- ret = _media_svc_create_album_table(handle);
+ ret = _media_svc_create_album_table(handle, uid);
media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
/*create tag table*/
- ret = _media_svc_create_tag_table(handle);
+ ret = _media_svc_create_tag_table(handle,uid);
media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
/*create bookmark table*/
- ret = _media_svc_create_bookmark_table(handle);
+ ret = _media_svc_create_bookmark_table(handle, uid);
media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
#if 0 /*unify media and custom table*/
/*create custom table*/
- ret = _media_svc_create_custom_table(handle);
+ ret = _media_svc_create_custom_table(handle, uid);
media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
#endif
return MEDIA_INFO_ERROR_NONE;
}
-int media_svc_insert_item_end(MediaSvcHandle *handle)
+int media_svc_insert_item_end(MediaSvcHandle *handle, uid_t uid)
{
int ret = MEDIA_INFO_ERROR_NONE;
sqlite3 * db_handle = (sqlite3 *)handle;
if (g_media_svc_insert_item_cur_data_cnt > 0) {
- ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_INSERT_ITEM);
+ ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_INSERT_ITEM, uid);
if (g_insert_with_noti) {
media_svc_debug("sending noti list");
_media_svc_publish_noti_list(g_media_svc_insert_item_cur_data_cnt);
return ret;
}
-int media_svc_insert_item_bulk(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, const char *path, int is_burst)
+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 ret = MEDIA_INFO_ERROR_NONE;
sqlite3 * db_handle = (sqlite3 *)handle;
} else if(media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE) {
ret = _media_svc_extract_image_metadata(&content_info, media_type);
} else {
- ret = _media_svc_extract_media_metadata(handle, &content_info, media_type, drm_contentInfo);
+ ret = _media_svc_extract_media_metadata(handle, &content_info, media_type, drm_contentInfo, uid);
}
SAFE_FREE(drm_contentInfo);
media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
/*Set or Get folder id*/
- ret = _media_svc_get_and_append_folder_id_by_path(handle, path, storage_type, folder_uuid);
+ ret = _media_svc_get_and_append_folder_id_by_path(handle, path, storage_type, folder_uuid, uid);
media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
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);
+ ret = _media_svc_insert_item_with_data(db_handle, &content_info, is_burst, FALSE, uid);
media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_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);
+ ret = _media_svc_insert_item_with_data(db_handle, &content_info, is_burst, TRUE, uid);
media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_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);
+ ret = _media_svc_insert_item_with_data(db_handle, &content_info, is_burst, TRUE, uid);
media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_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);
+ ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_INSERT_ITEM, uid);
media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, &content_info);
if (g_insert_with_noti) {
return MEDIA_INFO_ERROR_NONE;
}
-int media_svc_insert_item_immediately(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, const char *path)
+int media_svc_insert_item_immediately(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, const char *path, uid_t uid)
{
int ret = MEDIA_INFO_ERROR_NONE;
sqlite3 * db_handle = (sqlite3 *)handle;
ret = _media_svc_extract_image_metadata(&content_info, media_type);
media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
} else {
- ret = _media_svc_extract_media_metadata(handle, &content_info, media_type, drm_contentInfo);
+ ret = _media_svc_extract_media_metadata(handle, &content_info, media_type, drm_contentInfo, uid);
media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
}
/*Set or Get folder id*/
- ret = _media_svc_get_and_append_folder_id_by_path(handle, path, storage_type, folder_uuid);
+ ret = _media_svc_get_and_append_folder_id_by_path(handle, path, storage_type, folder_uuid, uid);
media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
ret = __media_svc_malloc_and_strncpy(&content_info.folder_uuid, folder_uuid);
int width = 0;
int height = 0;
- ret = thumbnail_request_from_db_with_size(content_info.path, thumb_path, sizeof(thumb_path), &width, &height);
+ ret = thumbnail_request_from_db_with_size(content_info.path, thumb_path, sizeof(thumb_path), &width, &height, uid);
if (ret < 0) {
media_svc_error("thumbnail_request_from_db failed: %d", ret);
} else {
content_info.media_meta.height = height;
}
#endif
- ret = _media_svc_insert_item_with_data(db_handle, &content_info, FALSE, FALSE);
+ ret = _media_svc_insert_item_with_data(db_handle, &content_info, FALSE, FALSE, uid);
if (ret == MEDIA_INFO_ERROR_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)
+int media_svc_insert_folder(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, const char *path, uid_t uid)
{
int ret = MEDIA_INFO_ERROR_NONE;
sqlite3 * db_handle = (sqlite3 *)handle;
folder_name = g_path_get_basename(path);
folder_modified_date = _media_svc_get_file_time(path);
- ret = _media_svc_append_folder(handle, storage_type, folder_uuid, path, folder_name, folder_modified_date);
+ ret = _media_svc_append_folder(handle, storage_type, folder_uuid, path, folder_name, folder_modified_date, uid);
SAFE_FREE(folder_name);
if (ret < MEDIA_INFO_ERROR_NONE) {
return MEDIA_INFO_ERROR_NONE;
}
-int media_svc_move_item_end(MediaSvcHandle *handle)
+int media_svc_move_item_end(MediaSvcHandle *handle, uid_t uid)
{
int ret = MEDIA_INFO_ERROR_NONE;
sqlite3 * db_handle = (sqlite3 *)handle;
if (g_media_svc_move_item_cur_data_cnt > 0) {
- ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_MOVE_ITEM);
+ ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_MOVE_ITEM, uid);
}
/*clean up old folder path*/
- ret = _media_svc_update_folder_table(handle);
+ ret = _media_svc_update_folder_table(handle, uid);
media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
g_media_svc_move_item_data_cnt = 1;
}
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)
+ media_svc_storage_type_e dest_storage, const char *dest_path, uid_t uid)
{
int ret = MEDIA_INFO_ERROR_NONE;
sqlite3 * db_handle = (sqlite3 *)handle;
}
/*check and update folder*/
- ret = _media_svc_get_and_append_folder_id_by_path(handle, dest_path, dest_storage, folder_uuid);
+ ret = _media_svc_get_and_append_folder_id_by_path(handle, dest_path, dest_storage, folder_uuid, uid);
media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
/*get filename*/
media_svc_retv_if((ret != MEDIA_INFO_ERROR_NONE) && (ret != MEDIA_INFO_ERROR_DATABASE_NO_RECORD), ret);
/* If old thumb path is default or not */
- if (strncmp(old_thumb_path, MEDIA_SVC_THUMB_DEFAULT_PATH, sizeof(MEDIA_SVC_THUMB_DEFAULT_PATH)) == 0) {
- strncpy(new_thumb_path, MEDIA_SVC_THUMB_DEFAULT_PATH, sizeof(new_thumb_path));
+ if (strncmp(old_thumb_path, _media_svc_get_thumb_default_path(uid), sizeof(_media_svc_get_thumb_default_path(uid))) == 0) {
+ strncpy(new_thumb_path, _media_svc_get_thumb_default_path(uid), sizeof(new_thumb_path));
} else {
- _media_svc_get_thumbnail_path(dest_storage, new_thumb_path, dest_path, THUMB_EXT);
+ _media_svc_get_thumbnail_path(dest_storage, new_thumb_path, dest_path, THUMB_EXT, uid);
}
}
/*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);
+ 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);
} else {
- ret = _media_svc_update_item_by_path(handle, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, NULL, FALSE);
+ ret = _media_svc_update_item_by_path(handle, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, NULL, FALSE, uid);
}
SAFE_FREE(file_name);
media_svc_retv_if(ret != MEDIA_INFO_ERROR_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, FALSE);
+ ret = _media_svc_update_folder_modified_time_by_folder_uuid(handle, folder_uuid, folder_path, FALSE, uid);
SAFE_FREE(folder_path);
media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
- ret = _media_svc_update_folder_table(handle);
+ ret = _media_svc_update_folder_table(handle, uid);
media_svc_retv_if(ret != MEDIA_INFO_ERROR_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);
+ 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);
} else {
- ret = _media_svc_update_item_by_path(handle, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, NULL, TRUE);
+ ret = _media_svc_update_item_by_path(handle, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, NULL, TRUE, uid);
}
SAFE_FREE(file_name);
media_svc_retv_if(ret != MEDIA_INFO_ERROR_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);
+ ret = _media_svc_update_folder_modified_time_by_folder_uuid(handle, folder_uuid, folder_path, TRUE, uid);
SAFE_FREE(folder_path);
media_svc_retv_if(ret != MEDIA_INFO_ERROR_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);
+ 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);
} else {
- ret = _media_svc_update_item_by_path(handle, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, NULL, TRUE);
+ ret = _media_svc_update_item_by_path(handle, src_path, dest_storage, dest_path, file_name, modified_time, folder_uuid, NULL, TRUE, uid);
}
SAFE_FREE(file_name);
media_svc_retv_if(ret != MEDIA_INFO_ERROR_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);
+ ret = _media_svc_update_folder_modified_time_by_folder_uuid(handle, folder_uuid, folder_path, TRUE, uid);
SAFE_FREE(folder_path);
media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
/*update db*/
- ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_MOVE_ITEM);
+ ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_MOVE_ITEM, uid);
media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
g_media_svc_move_item_cur_data_cnt = 0;
/*rename thumbnail file*/
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)) {
+ if((strlen(old_thumb_path) > 0) && (strncmp(old_thumb_path, _media_svc_get_thumb_default_path(uid), sizeof(_media_svc_get_thumb_default_path(uid))) != 0)) {
ret = _media_svc_rename_file(old_thumb_path,new_thumb_path);
if (ret < 0)
media_svc_error("_media_svc_rename_file failed : %d", ret);
return MEDIA_INFO_ERROR_NONE;
}
-int media_svc_set_item_validity_end(MediaSvcHandle *handle)
+int media_svc_set_item_validity_end(MediaSvcHandle *handle, uid_t uid)
{
int ret = MEDIA_INFO_ERROR_NONE;
sqlite3 * db_handle = (sqlite3 *)handle;
if (g_media_svc_item_validity_cur_data_cnt > 0) {
- ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_SET_ITEM_VALIDITY);
+ ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_SET_ITEM_VALIDITY, uid);
}
g_media_svc_item_validity_data_cnt = 1;
return ret;
}
-int media_svc_set_item_validity(MediaSvcHandle *handle, const char *path, int validity)
+int media_svc_set_item_validity(MediaSvcHandle *handle, const char *path, int validity,uid_t uid)
{
int ret = MEDIA_INFO_ERROR_NONE;
sqlite3 * db_handle = (sqlite3 *)handle;
if (g_media_svc_item_validity_data_cnt == 1) {
- return _media_svc_update_item_validity(db_handle, path, validity, FALSE);
+ return _media_svc_update_item_validity(db_handle, 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);
+ ret = _media_svc_update_item_validity(db_handle, path, validity, TRUE, uid);
media_svc_retv_if(ret != MEDIA_INFO_ERROR_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);
+ ret = _media_svc_update_item_validity(db_handle, path, validity, TRUE, uid);
media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
- ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_SET_ITEM_VALIDITY);
+ ret = _media_svc_list_query_do(db_handle, MEDIA_SVC_QUERY_SET_ITEM_VALIDITY, uid);
media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
g_media_svc_item_validity_cur_data_cnt = 0;
return MEDIA_INFO_ERROR_NONE;
}
-int media_svc_delete_item_by_path(MediaSvcHandle *handle, const char *path)
+int media_svc_delete_item_by_path(MediaSvcHandle *handle, const char *path, uid_t uid)
{
int ret = MEDIA_INFO_ERROR_NONE;
sqlite3 * db_handle = (sqlite3 *)handle;
media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
/*Delete item*/
- ret = _media_svc_delete_item_by_path(db_handle, path);
+ ret = _media_svc_delete_item_by_path(db_handle, path, uid);
if (ret != MEDIA_INFO_ERROR_NONE) {
media_svc_error("_media_svc_delete_item_by_path failed : %d", ret);
_media_svc_destroy_noti_item(noti_item);
_media_svc_destroy_noti_item(noti_item);
/*Delete thumbnail*/
- if ((strlen(thumb_path) > 0) && (strncmp(thumb_path, MEDIA_SVC_THUMB_DEFAULT_PATH, sizeof(MEDIA_SVC_THUMB_DEFAULT_PATH)) != 0)) {
+ if ((strlen(thumb_path) > 0) && (strncmp(thumb_path, _media_svc_get_thumb_default_path(uid), sizeof(_media_svc_get_thumb_default_path(uid))) != 0)) {
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)) {
return MEDIA_INFO_ERROR_NONE;
}
-int media_svc_delete_all_items_in_storage(MediaSvcHandle *handle, media_svc_storage_type_e storage_type)
+int media_svc_delete_all_items_in_storage(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, uid_t uid)
{
int ret = MEDIA_INFO_ERROR_NONE;
sqlite3 * db_handle = (sqlite3 *)handle;
return MEDIA_INFO_ERROR_INVALID_PARAMETER;
}
- ret = _media_svc_truncate_table(db_handle, storage_type);
+ ret = _media_svc_truncate_table(db_handle, storage_type, uid);
media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
- dirpath = (storage_type == MEDIA_SVC_STORAGE_INTERNAL) ? MEDIA_SVC_THUMB_INTERNAL_PATH : MEDIA_SVC_THUMB_EXTERNAL_PATH;
+ dirpath = (storage_type == MEDIA_SVC_STORAGE_INTERNAL) ? _media_svc_get_thumb_internal_path(uid) : _media_svc_get_thumb_external_path(uid);
/* remove thumbnails */
ret = _media_svc_remove_all_files_in_dir(dirpath);
return MEDIA_INFO_ERROR_NONE;
}
-int media_svc_delete_invalid_items_in_storage(MediaSvcHandle *handle, media_svc_storage_type_e storage_type)
+int media_svc_delete_invalid_items_in_storage(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, uid_t uid)
{
sqlite3 * db_handle = (sqlite3 *)handle;
}
/*Delete from DB and remove thumbnail files*/
- return _media_svc_delete_invalid_items(db_handle, storage_type);
+ return _media_svc_delete_invalid_items(db_handle, storage_type, uid);
}
-int media_svc_delete_invalid_items_in_folder(MediaSvcHandle *handle, const char *folder_path)
+int media_svc_delete_invalid_items_in_folder(MediaSvcHandle *handle, const char *folder_path, uid_t uid)
{
sqlite3 * db_handle = (sqlite3 *)handle;
media_svc_retvm_if(db_handle == NULL, MEDIA_INFO_ERROR_INVALID_PARAMETER, "Handle is NULL");
/*Delete from DB and remove thumbnail files*/
- return _media_svc_delete_invalid_folder_items(db_handle, folder_path);
+ return _media_svc_delete_invalid_folder_items(db_handle, folder_path, uid);
}
-int media_svc_set_all_storage_items_validity(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, int validity)
+int media_svc_set_all_storage_items_validity(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, int validity, uid_t uid)
{
sqlite3 * db_handle = (sqlite3 *)handle;
return MEDIA_INFO_ERROR_INVALID_PARAMETER;
}
- return _media_svc_update_storage_item_validity(db_handle, storage_type, validity);
+ return _media_svc_update_storage_item_validity(db_handle, storage_type, validity, uid);
}
-int media_svc_set_folder_items_validity(MediaSvcHandle *handle, const char *folder_path, int validity, int recursive)
+int media_svc_set_folder_items_validity(MediaSvcHandle *handle, const char *folder_path, int validity, int recursive, uid_t uid)
{
sqlite3 * db_handle = (sqlite3 *)handle;
media_svc_retvm_if(!STRING_VALID(folder_path), MEDIA_INFO_ERROR_INVALID_PARAMETER, "folder_path is NULL");
if(recursive)
- return _media_svc_update_recursive_folder_item_validity(db_handle, folder_path, validity);
+ return _media_svc_update_recursive_folder_item_validity(db_handle, folder_path, validity , uid);
else
- return _media_svc_update_folder_item_validity(db_handle, folder_path, validity);
+ return _media_svc_update_folder_item_validity(db_handle, folder_path, validity, uid);
}
-int media_svc_refresh_item(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, const char *path)
+int media_svc_refresh_item(MediaSvcHandle *handle, media_svc_storage_type_e storage_type, const char *path, uid_t uid)
{
int ret = MEDIA_INFO_ERROR_NONE;
sqlite3 * db_handle = (sqlite3 *)handle;
ret = _media_svc_get_thumbnail_path_by_path(handle, path, thumb_path);
media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
- if (g_file_test(thumb_path, G_FILE_TEST_EXISTS) && (strncmp(thumb_path, MEDIA_SVC_THUMB_DEFAULT_PATH, sizeof(MEDIA_SVC_THUMB_DEFAULT_PATH)) != 0)) {
+ if (g_file_test(thumb_path, G_FILE_TEST_EXISTS) && (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 < MEDIA_INFO_ERROR_NONE) {
media_svc_error("_media_svc_remove_file failed : %s", thumb_path);
}
}
- ret = _media_svc_update_thumbnail_path(handle, path, NULL);
+ ret = _media_svc_update_thumbnail_path(handle, path, NULL, uid);
media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
/* Get notification info */
return ret;
}
} else {
- ret = _media_svc_extract_media_metadata(handle, &content_info, media_type, drm_contentInfo);
+ ret = _media_svc_extract_media_metadata(handle, &content_info, media_type, drm_contentInfo, uid);
if (ret != MEDIA_INFO_ERROR_NONE) {
_media_svc_destroy_noti_item(noti_item);
return ret;
int width = 0;
int height = 0;
- ret = thumbnail_request_from_db_with_size(content_info.path, thumb_path, sizeof(thumb_path), &width, &height);
+ ret = thumbnail_request_from_db_with_size(content_info.path, thumb_path, sizeof(thumb_path), &width, &height, uid);
if (ret < 0) {
media_svc_error("thumbnail_request_from_db failed: %d", ret);
} else {
content_info.media_meta.height = height;
}
#endif
- ret = _media_svc_update_item_with_data(db_handle, &content_info);
+ ret = _media_svc_update_item_with_data(db_handle, &content_info, uid);
if (ret == MEDIA_INFO_ERROR_NONE) {
media_svc_debug("Update is successful. Sending noti for this");
return ret;
}
-int media_svc_rename_folder(MediaSvcHandle *handle, const char *src_path, const char *dst_path)
+int media_svc_rename_folder(MediaSvcHandle *handle, const char *src_path, const char *dst_path, uid_t uid)
{
sqlite3 * db_handle = (sqlite3 *)handle;
int ret = MEDIA_INFO_ERROR_NONE;
ret = _media_svc_get_noti_info(handle, src_path, MS_MEDIA_ITEM_DIRECTORY, ¬i_item);
media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
- ret = _media_svc_sql_begin_trans(handle);
+ ret = _media_svc_sql_begin_trans(handle,uid);
media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
/* Update all folder record's path, which are matched by old parent 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);
- ret = media_db_request_update_db_batch(update_folder_path_sql);
+ 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);
+ _media_svc_sql_rollback_trans(handle, uid);
return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
}
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);
+ ret = media_db_request_update_db_batch(update_folder_modified_time_sql, uid);
//ret = _media_svc_sql_query(handle, update_folder_modified_time_sql);
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);
+ _media_svc_sql_rollback_trans(handle, uid);
return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
}
if (ret != SQLITE_OK) {
media_svc_error ("prepare error [%s]", sqlite3_errmsg(handle));
- _media_svc_sql_rollback_trans(handle);
+ _media_svc_sql_rollback_trans(handle, uid);
return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
}
if (replaced_path == NULL) {
media_svc_error("_media_svc_replace_path failed");
SQLITE3_FINALIZE(sql_stmt);
- _media_svc_sql_rollback_trans(handle);
+ _media_svc_sql_rollback_trans(handle, uid);
return MEDIA_INFO_ERROR_INTERNAL;
}
if (!no_thumb) {
/* If old thumb path is default or not */
- if (strncmp(media_thumb_path, MEDIA_SVC_THUMB_DEFAULT_PATH, sizeof(MEDIA_SVC_THUMB_DEFAULT_PATH)) == 0) {
- strncpy(media_new_thumb_path, MEDIA_SVC_THUMB_DEFAULT_PATH, sizeof(media_new_thumb_path));
+ 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);
if (ret < 0) {
media_svc_error("_media_svc_get_store_type_by_path failed : %d", ret);
SAFE_FREE(replaced_path);
- _media_svc_sql_rollback_trans(handle);
+ _media_svc_sql_rollback_trans(handle,uid);
return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
}
- ret = _media_svc_get_thumbnail_path(storage_type, media_new_thumb_path, replaced_path, THUMB_EXT);
+ ret = _media_svc_get_thumbnail_path(storage_type, media_new_thumb_path, replaced_path, THUMB_EXT, uid);
if (ret < 0) {
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);
+ _media_svc_sql_rollback_trans(handle,uid);
return MEDIA_INFO_ERROR_INTERNAL;
}
}
}
}
- ret = media_db_request_update_db_batch(update_item_sql);
+ ret = media_db_request_update_db_batch(update_item_sql,uid);
//ret = _media_svc_sql_query(handle, update_item_sql);
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);
+ _media_svc_sql_rollback_trans(handle,uid);
return MEDIA_INFO_ERROR_DATABASE_INTERNAL;
}
/* Rename thumbnail file of file system */
if ((!no_thumb) && (media_type == MEDIA_SVC_MEDIA_TYPE_IMAGE || media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)
- && (strncmp(media_thumb_path, MEDIA_SVC_THUMB_DEFAULT_PATH, sizeof(MEDIA_SVC_THUMB_DEFAULT_PATH)) != 0)) {
+ && (strncmp(media_thumb_path, _media_svc_get_thumb_default_path(uid), sizeof(_media_svc_get_thumb_default_path(uid))) != 0)) {
ret = _media_svc_rename_file(media_thumb_path, media_new_thumb_path);
if (ret < 0) {
media_svc_error("_media_svc_rename_file failed : %d", ret);
SQLITE3_FINALIZE(sql_stmt);
- ret = _media_svc_sql_end_trans(handle);
+ ret = _media_svc_sql_end_trans(handle, uid);
if (ret != MEDIA_INFO_ERROR_NONE) {
media_svc_error("mb_svc_sqlite3_commit_trans failed.. Now start to rollback\n");
- _media_svc_sql_rollback_trans(handle);
+ _media_svc_sql_rollback_trans(handle,uid);
return ret;
}
return MEDIA_INFO_ERROR_NONE;
}
-int media_svc_request_update_db(const char *db_query)
+int media_svc_request_update_db(const char *db_query, uid_t uid)
{
int ret = MEDIA_INFO_ERROR_NONE;
media_svc_retvm_if(!STRING_VALID(db_query), MEDIA_INFO_ERROR_INVALID_PARAMETER, "db_query is NULL");
- ret = _media_svc_request_update_db(db_query);
+ ret = _media_svc_request_update_db(db_query, uid);
return _media_svc_error_convert(ret);
}
#define _MEDIA_SVC_ALBUM_H_
#include <sqlite3.h>
+#include <sys/types.h>
int _media_svc_get_album_id(sqlite3 *handle, const char *album, const char *artist, int * album_id);
int _media_svc_get_album_art_by_album_id(sqlite3 *handle, int album_id, char **album_art);
-int _media_svc_append_album(sqlite3 *handle, const char *album, const char *artist, const char *album_art, int * album_id);
+int _media_svc_append_album(sqlite3 *handle, const char *album, const char *artist, const char *album_art, int * album_id, uid_t uid);
int _media_svc_get_media_count_with_album_id_by_path(sqlite3 *handle, const char *path, int *count);
#endif /*_MEDIA_SVC_ALBUM_H_*/
int _media_svc_connect_db_with_handle(sqlite3 **db_handle);
int _media_svc_disconnect_db_with_handle(sqlite3 *db_handle);
-int _media_svc_create_media_table(sqlite3 *db_handle);
-int _media_svc_create_folder_table(sqlite3 *db_handle);
-int _media_svc_create_playlist_table(sqlite3 *db_handle);
-int _media_svc_create_album_table(sqlite3 *db_handle);
-int _media_svc_create_tag_table(sqlite3 *db_handle);
-int _media_svc_create_bookmark_table(sqlite3 *db_handle);
-int _media_svc_create_custom_table(sqlite3 *db_handle);
-int _media_svc_request_update_db(const char *sql_str);
-int _media_svc_sql_query(sqlite3 *db_handle, const char *sql_str);
+int _media_svc_create_media_table(sqlite3 *db_handle, uid_t uid);
+int _media_svc_create_folder_table(sqlite3 *db_handle, uid_t uid);
+int _media_svc_create_playlist_table(sqlite3 *db_handle, uid_t uid);
+int _media_svc_create_album_table(sqlite3 *db_handle, uid_t uid);
+int _media_svc_create_tag_table(sqlite3 *db_handle, uid_t uid);
+int _media_svc_create_bookmark_table(sqlite3 *db_handle, uid_t uid);
+int _media_svc_create_custom_table(sqlite3 *db_handle, uid_t uid);
+int _media_svc_request_update_db(const char *sql_str, uid_t uid);
+int _media_svc_sql_query(sqlite3 *db_handle, const char *sql_str, uid_t uid);
int _media_svc_sql_prepare_to_step(sqlite3 *handle, const char *sql_str, sqlite3_stmt** stmt);
-int _media_svc_sql_begin_trans(sqlite3 *handle);
-int _media_svc_sql_end_trans(sqlite3 *handle);
-int _media_svc_sql_rollback_trans(sqlite3 *handle);
-int _media_svc_sql_query_list(sqlite3 *handle, GList **query_list);
+int _media_svc_sql_begin_trans(sqlite3 *handle, uid_t uid);
+int _media_svc_sql_end_trans(sqlite3 *handle, uid_t uid);
+int _media_svc_sql_rollback_trans(sqlite3 *handle, uid_t uid);
+int _media_svc_sql_query_list(sqlite3 *handle, GList **query_list, uid_t uid);
void _media_svc_sql_query_add(GList **query_list, char **query);
void _media_svc_sql_query_release(GList **query_list);
#include "media-svc-types.h"
int _media_svc_get_folder_id_by_foldername(sqlite3 *handle, const char *folder_name, char *folder_id);
-int _media_svc_append_folder(sqlite3 *handle, media_svc_storage_type_e storage_type, const char *folder_id, const char *path_name, const char *folder_name, int modified_date);
-int _media_svc_update_folder_modified_time_by_folder_uuid(sqlite3 *handle, const char *folder_uuid, const char *folder_path, bool stack_query);
-int _media_svc_get_and_append_folder_id_by_path(sqlite3 *handle, const char *path, media_svc_storage_type_e storage_type, char *folder_id);
-int _media_svc_update_folder_table(sqlite3 *handle);
+int _media_svc_append_folder(sqlite3 *handle, media_svc_storage_type_e storage_type, const char *folder_id, const char *path_name, const char *folder_name, int modified_date, 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_id_by_path(sqlite3 *handle, 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);
#endif /*_MEDIA_SVC_MEDIA_FOLDER_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);
-int _media_svc_update_item_with_data(sqlite3 *handle, media_svc_content_info_s *content_info);
+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_update_item_with_data(sqlite3 *handle, media_svc_content_info_s *content_info, uid_t uid);
int _media_svc_get_thumbnail_path_by_path(sqlite3 *handle, const char *path, char *thumbnail_path);
int _media_svc_get_media_type_by_path(sqlite3 *handle, const char *path, int *media_type);
int _media_svc_get_burst_id(sqlite3 *handle, int *id);
-int _media_svc_delete_item_by_path(sqlite3 *handle, const char *path);
-int _media_svc_truncate_table(sqlite3 *handle, media_svc_storage_type_e storage_type);
-int _media_svc_delete_invalid_items(sqlite3 *handle, media_svc_storage_type_e storage_type);
-int _media_svc_delete_invalid_folder_items(sqlite3 *handle, const char *folder_path);
-int _media_svc_update_storage_item_validity(sqlite3 *handle, media_svc_storage_type_e storage_type, int validity);
-int _media_svc_update_folder_item_validity(sqlite3 *handle, const char *folder_path, int validity);
-int _media_svc_update_recursive_folder_item_validity(sqlite3 *handle, const char *folder_path, int validity);
-int _media_svc_update_item_validity(sqlite3 *handle, const char *path, int validity, bool stack_query);
-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);
-int _media_svc_list_query_do(sqlite3 *handle, media_svc_query_type_e query_type);
+int _media_svc_delete_item_by_path(sqlite3 *handle, const char *path, 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_list_query_do(sqlite3 *handle, media_svc_query_type_e query_type, uid_t uid);
int _media_svc_get_media_id_by_path(sqlite3 *handle, const char *path, char *media_uuid, int max_length);
-int _media_svc_update_thumbnail_path(sqlite3 *handle, const char *path, const char *thumb_path);
+int _media_svc_update_thumbnail_path(sqlite3 *handle, const char *path, const char *thumb_path, uid_t uid);
int _media_svc_get_noti_info(sqlite3 *handle, 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);
+char* _media_svc_get_thumb_default_path(uid_t uid);
#endif /*_MEDIA_SVC_MEDIA_H_*/
bool _media_svc_remove_file(const char *path);
int _media_svc_remove_all_files_in_dir(const char *dir_path);
char *_media_svc_get_title_from_filepath (const char *path);
-int _media_svc_save_image(void *image, int size, char *image_path);
-bool _media_svc_get_thumbnail_path(media_svc_storage_type_e storage_type, char *thumb_path, const char *pathname, const char *img_format);
+int _media_svc_save_image(void *image, int size, char *image_path, uid_t uid);
+bool _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);
bool _media_svc_get_file_ext(const char *file_path, char *file_ext);
int _media_svc_get_file_time(const char *full_path);
int _media_svc_set_media_info(media_svc_content_info_s *content_info, media_svc_storage_type_e storage_type,
const char *path, media_svc_media_type_e *media_type, bool refresh, drm_content_info_s **drm_contentInfo);
int _media_svc_extract_image_metadata(media_svc_content_info_s *content_info, media_svc_media_type_e media_type);
-int _media_svc_extract_media_metadata(sqlite3 *handle, media_svc_content_info_s *content_info, media_svc_media_type_e media_type, drm_content_info_s *drm_contentInfo);
+int _media_svc_extract_media_metadata(sqlite3 *handle, media_svc_content_info_s *content_info, media_svc_media_type_e media_type, drm_content_info_s *drm_contentInfo, uid_t uid);
int __media_svc_malloc_and_strncpy(char **dst, const char *src);
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);
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_error_convert(int error);
/* Define data structures for media type and mime type */
projects / platform / core / multimedia / libmedia-service.git / commitdiff